Fonction UpdateProcThreadAttribute (processthreadsapi.h)
Met à jour l’attribut spécifié dans une liste d’attributs pour la création de processus et de threads.
Syntaxe
BOOL UpdateProcThreadAttribute(
[in, out] LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList,
[in] DWORD dwFlags,
[in] DWORD_PTR Attribute,
[in] PVOID lpValue,
[in] SIZE_T cbSize,
[out, optional] PVOID lpPreviousValue,
[in, optional] PSIZE_T lpReturnSize
);
Paramètres
[in, out] lpAttributeList
Pointeur vers une liste d’attributs créée par la fonction InitializeProcThreadAttributeList .
[in] dwFlags
Ce paramètre est réservé et doit être égal à zéro.
[in] Attribute
Clé d’attribut à mettre à jour dans la liste d’attributs. Ce paramètre peut prendre les valeurs suivantes.
| Valeur | Signification |
|---|---|
|
Le paramètre lpValue est un pointeur vers une structure GROUP_AFFINITY qui spécifie l’affinité du groupe de processeur pour le nouveau thread.
Pris en charge dans Windows 7 et versions ultérieures et Windows Server 2008 R2 et versions ultérieures. |
|
Le paramètre lpValue est un pointeur vers une liste de handles à hériter par le processus enfant.
Ces handles doivent être créés en tant que handles pouvant être hérités et ne doivent pas inclure de pseudo-handles tels que ceux retournés par la fonction GetCurrentProcess ou GetCurrentThread . Notez que si vous utilisez cet attribut, transmettez la valeur TRUE pour le paramètre bInheritHandles de la fonction CreateProcess .
|
|
Le paramètre lpValue est un pointeur vers une structure PROCESSOR_NUMBER qui spécifie le processeur idéal pour le nouveau thread.
Pris en charge dans Windows 7 et versions ultérieures et Windows Server 2008 R2 et versions ultérieures. |
|
Le paramètre lpValue est un pointeur vers un WORD qui spécifie l’architecture de l’ordinateur du processus enfant.
Pris en charge dans Windows 11 et versions ultérieures. Le MOT pointé par lpValue peut être une valeur répertoriée dans IMAGE FILE MACHINE CONSTANTS. |
|
Le paramètre lpValue est un pointeur vers un DWORD ou un DWORD64 qui spécifie la stratégie d’atténuation des exploits pour le processus enfant. À partir de Windows 10, version 1703, ce paramètre peut également être un pointeur vers un tableau à deux éléments DWORD64 .
La stratégie spécifiée remplace les stratégies définies pour l’application et le système et ne peut pas être modifiée une fois que le processus enfant a commencé à s’exécuter. Le DWORD ou DWORD64 pointé par lpValue peut être une ou plusieurs des valeurs répertoriées dans les remarques. Pris en charge dans Windows 7 et versions ultérieures et Windows Server 2008 R2 et versions ultérieures. |
|
Le paramètre lpValue est un pointeur vers le handle d’un processus à utiliser (au lieu du processus appelant) comme parent pour le processus en cours de création. Le handle du processus utilisé doit avoir le droit d’accès PROCESS_CREATE_PROCESS .
Les attributs hérités du processus spécifié incluent les handles, le mappage d’appareil, l’affinité processeur, la priorité, les quotas, le jeton de processus et l’objet de travail. (Notez que certains attributs tels que le port de débogage proviennent du processus de création, et non du processus spécifié par ce handle.) |
|
Le paramètre lpValue est un pointeur vers le numéro de nœud du nœud NUMA préféré pour le nouveau processus.
Pris en charge dans Windows 7 et versions ultérieures et Windows Server 2008 R2 et versions ultérieures. |
|
Le paramètre lpValue est un pointeur vers une structure UMS_CREATE_THREAD_ATTRIBUTES qui spécifie un contexte de thread de planification en mode utilisateur (UMS) et une liste d’achèvement UMS à associer au thread.
Une fois le thread UMS créé, le système le met en file d’attente vers la liste d’achèvement spécifiée. Le thread UMS s’exécute uniquement quand le planificateur UMS d’une application récupère le thread UMS à partir de la liste d’achèvement et le sélectionne pour l’exécuter. Pour plus d’informations, consultez Planification en mode utilisateur. Pris en charge dans Windows 7 et versions ultérieures et Windows Server 2008 R2 et versions ultérieures. Non pris en charge dans Windows 11 et versions ultérieures (voir Planification en mode utilisateur). |
|
Le paramètre lpValue est un pointeur vers une structure SECURITY_CAPABILITIES qui définit les fonctionnalités de sécurité d’un conteneur d’application. Si cet attribut est défini, le nouveau processus sera créé en tant que processus AppContainer.
Pris en charge dans Windows 8 et versions ultérieures et Windows Server 2012 et versions ultérieures. |
|
Le paramètre lpValue est un pointeur vers une valeur DWORD de PROTECTION_LEVEL_SAME. Cela spécifie le niveau de protection du processus enfant à être identique au niveau de protection de son processus parent.
Pris en charge dans Windows 8.1 et versions ultérieures et Windows Server 2012 R2 et versions ultérieures. |
|
Le paramètre lpValue est un pointeur vers une valeur DWORD qui spécifie la stratégie de processus enfant. La stratégie spécifie s’il faut autoriser la création d’un processus enfant.
Pour plus d’informations sur les valeurs possibles pour le DWORD vers lequel lpValue pointe, consultez Remarques. Pris en charge dans Windows 10 et versions ultérieures et Windows Server 2016 et versions ultérieures. |
|
Cet attribut s’applique uniquement aux applications win32 qui ont été converties en packages UWP à l’aide du pont de bureau.
Le paramètre lpValue est un pointeur vers une valeur DWORD qui spécifie la stratégie d’application de bureau. La stratégie spécifie si les processus descendants doivent continuer à s’exécuter dans l’environnement de bureau. Pour plus d’informations sur les valeurs possibles pour le DWORD vers lequel lpValue pointe, consultez Remarques. Pris en charge dans Windows 10 version 1703 et versions ultérieures et Windows Server version 1709 et ultérieures. |
|
Le paramètre lpValue est un pointeur vers une liste de handles de travail à affecter au processus enfant, dans l’ordre spécifié.
Pris en charge dans Windows 10 et versions ultérieures et Windows Server 2016 et versions ultérieures. |
|
Le paramètre lpValue est un pointeur vers une valeur DWORD64 qui spécifie l’ensemble de fonctionnalités XState facultatives à activer pour le nouveau thread.
Pris en charge dans Windows 11 et versions ultérieures et Windows Server 2022 et versions ultérieures. |
[in] lpValue
Pointeur vers la valeur d’attribut. Cette valeur doit persister jusqu’à ce que la liste d’attributs soit détruite à l’aide de la fonction DeleteProcThreadAttributeList.
[in] cbSize
Taille de la valeur d’attribut spécifiée par le paramètre lpValue .
[out, optional] lpPreviousValue
Ce paramètre est réservé et doit avoir la valeur NULL.
[in, optional] lpReturnSize
Ce paramètre est réservé et doit avoir la valeur NULL.
Valeur retournée
Si la fonction réussit, la valeur de retour est différente de zéro.
Si la fonction échoue, la valeur de retour est égale à zéro. Pour obtenir des informations détaillées sur l’erreur, appelez GetLastError.
Remarques
Une liste d’attributs est une structure opaque qui se compose d’une série de paires clé/valeur, une pour chaque attribut. Un processus peut mettre à jour uniquement les clés d’attribut décrites dans cette rubrique.
Le DWORD ou DWORD64 pointé par lpValue peut être une ou plusieurs des valeurs suivantes lorsque vous spécifiez PROC_THREAD_ATTRIBUTE_MITIGATION_POLICY pour le paramètre Attribute :
- PROCESS_CREATION_MITIGATION_POLICY_DEP_ENABLE (0x00000001)Active la prévention de l’exécution des données (DEP) pour le processus enfant. Pour plus d’informations, consultez Prévention de l’exécution des données.
- PROCESS_CREATION_MITIGATION_POLICY_DEP_ATL_THUNK_ENABLE (0x00000002)Active l’émulation de thunk DEP-ATL pour le processus enfant. L’émulation de thunk DEP-ATL permet au système d’intercepter les erreurs NX qui proviennent de la couche de thunk de la bibliothèque de modèles actifs (ATL). Cette valeur ne peut être spécifiée qu’avec PROCESS_CREATION_MITIGATION_POLICY_DEP_ENABLE.
- PROCESS_CREATION_MITIGATION_POLICY_SEHOP_ENABLE (0x00000004)Active la protection du gestionnaire d’exceptions structuré (SEHOP) pour le processus enfant. SEHOP bloque les exploits qui utilisent la technique de remplacement du gestionnaire d’exceptions structuré (SEH).
-
Windows 7, Windows Server 2008 R2, Windows Server 2008 et Windows Vista : Les valeurs suivantes ne sont pas prises en charge tant que Windows 8 et Windows Server 2012.
-
La stratégie forcer la randomisation de la disposition de l’espace d’adressage (ASLR), si elle est activée, rebase de force les images qui ne sont pas compatibles avec la base dynamique en agissant comme si une collision de base d’images s’était produite au moment du chargement. Si des réinstallations sont nécessaires, les images qui n’ont pas de section de déplacement de base ne seront pas chargées.
Les options d’atténuation suivantes sont disponibles pour la stratégie ASLR obligatoire :
- PROCESS_CREATION_MITIGATION_POLICY_FORCE_RELOCATE_IMAGES_ALWAYS_ON (0x00000001 << 8)
- PROCESS_CREATION_MITIGATION_POLICY_FORCE_RELOCATE_IMAGES_ALWAYS_OFF (0x00000002 << 8)
- PROCESS_CREATION_MITIGATION_POLICY_FORCE_RELOCATE_IMAGES_ALWAYS_ON_REQ_RELOCS (0x00000003 << 8)
-
Le tas se termine sur la stratégie d’altération, s’il est activé, entraîne l’arrêt du tas s’il devient endommagé. Notez que « always off » ne remplace pas l’option d’adhésion par défaut pour les fichiers binaires dont les versions actuelles du sous-système sont définies dans l’en-tête d’image. Le mode utilisateur est appliqué à l’arrêt du tas en cas d’altération.
Les options d’atténuation suivantes sont disponibles pour l’arrêt du tas en cas de stratégie d’altération :
- PROCESS_CREATION_MITIGATION_POLICY_HEAP_TERMINATE_ALWAYS_ON (0x00000001 << 12)
- PROCESS_CREATION_MITIGATION_POLICY_HEAP_TERMINATE_ALWAYS_OFF (0x00000002 << 12)
-
La stratégie de randomisation ascendante, qui comprend des options de randomisation de la pile, entraîne l’utilisation d’un emplacement aléatoire comme adresse utilisateur la plus basse.
Les options d’atténuation suivantes sont disponibles pour la stratégie de randomisation ascendante :
- PROCESS_CREATION_MITIGATION_POLICY_BOTTOM_UP_ASLR_ALWAYS_ON (0x00000001 << 16)
- PROCESS_CREATION_MITIGATION_POLICY_BOTTOM_UP_ASLR_ALWAYS_OFF (0x00000002 << 16)
-
La stratégie de randomisation ascendante à entropie élevée, si elle est activée, permet d’utiliser jusqu’à 1 To de variance ascendante. Notez que la randomisation ascendante à entropie élevée est efficace si et uniquement si l’ASLR de bas en haut est également activé ; La randomisation ascendante à entropie élevée n’est significative que pour les processus natifs 64 bits.
Les options d’atténuation suivantes sont disponibles pour la stratégie de randomisation ascendante à entropie élevée :
- PROCESS_CREATION_MITIGATION_POLICY_HIGH_ENTROPY_ASLR_ALWAYS_ON (0x00000001 << 20)
- PROCESS_CREATION_MITIGATION_POLICY_HIGH_ENTROPY_ASLR_ALWAYS_OFF (0x00000002 << 20)
-
La stratégie d’application de vérification de handle stricte, si elle est activée, entraîne le déclenchement immédiat d’une exception sur une référence de handle incorrect. Si cette stratégie n’est pas activée, un état d’échec est retourné à partir de la référence de handle à la place.
Les options d’atténuation suivantes sont disponibles pour la stratégie d’application de vérification de la gestion stricte :
- PROCESS_CREATION_MITIGATION_POLICY_STRICT_HANDLE_CHECKS_ALWAYS_ON (0x00000001 << 24)
- PROCESS_CREATION_MITIGATION_POLICY_STRICT_HANDLE_CHECKS_ALWAYS_OFF (0x00000002 << 24)
-
La stratégie de désactivation des appels système Win32k, si elle est activée, empêche un processus d’effectuer des appels Win32k.
Les options d’atténuation suivantes sont disponibles pour la stratégie de désactivation des appels système Win32k :
- PROCESS_CREATION_MITIGATION_POLICY_WIN32K_SYSTEM_CALL_DISABLE_ALWAYS_ON (0x00000001 << 28)
- PROCESS_CREATION_MITIGATION_POLICY_WIN32K_SYSTEM_CALL_DISABLE_ALWAYS_OFF (0x00000002 << 28)
-
La stratégie De désactivation du point d’extension, si elle est activée, empêche l’utilisation de certains points d’extension tiers intégrés. Cette stratégie bloque les points d’extension suivants :
- DLL AppInit
- Fournisseurs de services en couches (LSP) Winsock
- Crochets Windows globaux
- Éditeurs de méthode d’entrée hérités
Les options d’atténuation suivantes sont disponibles pour la stratégie de désactivation du point d’extension :
- PROCESS_CREATION_MITIGATION_POLICY_EXTENSION_POINT_DISABLE_ALWAYS_ON (0x00000001 << 32)
- PROCESS_CREATION_MITIGATION_POLICY_EXTENSION_POINT_DISABLE_ALWAYS_OFF (0x00000002 << 32)
-
La stratégie CFG (Control Flow Guard), si elle est activée, place des restrictions supplémentaires sur les appels indirects dans le code qui a été créé avec CFG activé.
Les options d’atténuation suivantes sont disponibles pour contrôler la stratégie CFG :
- PROCESS_CREATION_MITIGATION_POLICY_CONTROL_FLOW_GUARD_MASK (0x00000003ui64 << 40)
- PROCESS_CREATION_MITIGATION_POLICY_CONTROL_FLOW_GUARD_DEFER (0x00000000ui64 << 40)
- PROCESS_CREATION_MITIGATION_POLICY_CONTROL_FLOW_GUARD_ALWAYS_ON (0x0000001ui64 << 40)
- PROCESS_CREATION_MITIGATION_POLICY_CONTROL_FLOW_GUARD_ALWAYS_OFF (0x00000002ui64 << 40)
- PROCESS_CREATION_MITIGATION_POLICY_CONTROL_FLOW_GUARD_EXPORT_SUPPRESSION (0x00000003ui64 << 40)
-
En outre, la stratégie suivante peut être spécifiée pour appliquer que les DLL/EXE doivent activer CFG. Si une tentative de chargement d’une EXE/DLL qui n’active pas CFG est effectuée, le chargement échoue :
- PROCESS_CREATION_MITIGATION_POLICY2_STRICT_CONTROL_FLOW_GUARD_MASK (0x00000003ui64 << 8)
- PROCESS_CREATION_MITIGATION_POLICY2_STRICT_CONTROL_FLOW_GUARD_DEFER (0x0000000ui64 << 8)
- PROCESS_CREATION_MITIGATION_POLICY2_STRICT_CONTROL_FLOW_GUARD_ALWAYS_ON (0x0000001ui64 << 8)
- PROCESS_CREATION_MITIGATION_POLICY2_STRICT_CONTROL_FLOW_GUARD_ALWAYS_OFF (0x00000002ui64 << 8)
- PROCESS_CREATION_MITIGATION_POLICY2_STRICT_CONTROL_FLOW_GUARD_RESERVED (0x00000003ui64 << 8)
-
La stratégie de code dynamique, si elle est activée, empêche un processus de générer du code dynamique ou de modifier le code exécutable.
Les options d’atténuation suivantes sont disponibles pour la stratégie de code dynamique :
- PROCESS_CREATION_MITIGATION_POLICY_PROHIBIT_DYNAMIC_CODE_MASK (0x00000003ui64 << 36)
- PROCESS_CREATION_MITIGATION_POLICY_PROHIBIT_DYNAMIC_CODE_DEFER (0x0000000ui64 << 36)
- PROCESS_CREATION_MITIGATION_POLICY_PROHIBIT_DYNAMIC_CODE_ALWAYS_ON (0x0000001ui64 << 36)
- PROCESS_CREATION_MITIGATION_POLICY_PROHIBIT_DYNAMIC_CODE_ALWAYS_OFF (0x00000002ui64 << 36)
- PROCESS_CREATION_MITIGATION_POLICY_PROHIBIT_DYNAMIC_CODE_ALWAYS_ON_ALLOW_OPT_OUT (0x00000003ui64 << 36)
-
La stratégie de signature binaire nécessite que les FICHIERS EXE/DLL soient correctement signés.
Les options d’atténuation suivantes sont disponibles pour la stratégie de signature binaire :
- PROCESS_CREATION_MITIGATION_POLICY_BLOCK_NON_MICROSOFT_BINARIES_MASK (0x00000003ui64 << 44)
- PROCESS_CREATION_MITIGATION_POLICY_BLOCK_NON_MICROSOFT_BINARIES_DEFER (0x0000000ui64 << 44)
- PROCESS_CREATION_MITIGATION_POLICY_BLOCK_NON_MICROSOFT_BINARIES_ALWAYS_ON (0x0000001ui64 << 44)
- PROCESS_CREATION_MITIGATION_POLICY_BLOCK_NON_MICROSOFT_BINARIES_ALWAYS_OFF (0x00000002ui64 << 44)
- PROCESS_CREATION_MITIGATION_POLICY_BLOCK_NON_MICROSOFT_BINARIES_ALLOW_STORE (0x00000003ui64 << 44)
-
La stratégie de prévention du chargement des polices pour le processus détermine si les polices non système peuvent être chargées pour un processus. Lorsque la stratégie est activée, le processus ne peut pas charger des polices non système.
Les options d’atténuation suivantes sont disponibles pour la stratégie de prévention du chargement des polices :
- PROCESS_CREATION_MITIGATION_POLICY_FONT_DISABLE_MASK (0x00000003ui64 << 48)
- PROCESS_CREATION_MITIGATION_POLICY_FONT_DISABLE_DEFER (0x0000000ui64 << 48)
- PROCESS_CREATION_MITIGATION_POLICY_FONT_DISABLE_ALWAYS_ON (0x0000001ui64 << 48)
- PROCESS_CREATION_MITIGATION_POLICY_FONT_DISABLE_ALWAYS_OFF (0x00000002ui64 << 48)
- PROCESS_CREATION_MITIGATION_POLICY_AUDIT_NONSYSTEM_FONTS (0x00000003ui64 << 48)
-
La stratégie de chargement d’images du processus détermine les types d’images exécutables qui peuvent être mappées dans le processus. Lorsque la stratégie est activée, les images ne peuvent pas être chargées à partir de certains emplacements, tels que supprimer des appareils ou des fichiers qui ont l’étiquette obligatoire Faible.
Les options d’atténuation suivantes sont disponibles pour la stratégie de chargement d’images :
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_NO_REMOTE_MASK (0x00000003ui64 << 52)
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_NO_REMOTE_DEFER (0x0000000ui64 << 52)
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_NO_REMOTE_ALWAYS_ON (0x00000001ui64 << 52)
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_NO_REMOTE_ALWAYS_OFF (0x00000002ui64 << 52)
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_NO_REMOTE_RESERVED (0x00000003ui64 << 52)
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_NO_LOW_LABEL_MASK (0x00000003ui64 << 56)
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_NO_LOW_LABEL_DEFER (0x0000000ui64 << 56)
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_NO_LOW_LABEL_ALWAYS_ON (0x00000001ui64 << 56)
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_NO_LOW_LABEL_ALWAYS_OFF (0x00000002ui64 << 56)
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_NO_LOW_LABEL_RESERVED (0x00000003ui64 << 56)
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_PREFER_SYSTEM32_MASK (0x00000003ui64 << 60)
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_PREFER_SYSTEM32_DEFER (0x0000000ui64 << 60)
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_PREFER_SYSTEM32_ALWAYS_ON (0x0000001ui64 << 60)
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_PREFER_SYSTEM32_ALWAYS_OFF (0x00000002ui64 << 60)
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_PREFER_SYSTEM32_RESERVED (0x00000003ui64 << 60)
-
La stratégie forcer la randomisation de la disposition de l’espace d’adressage (ASLR), si elle est activée, rebase de force les images qui ne sont pas compatibles avec la base dynamique en agissant comme si une collision de base d’images s’était produite au moment du chargement. Si des réinstallations sont nécessaires, les images qui n’ont pas de section de déplacement de base ne seront pas chargées.
-
Windows 10, version 1709 : La valeur suivante est disponible uniquement dans Windows 10, version 1709 ou ultérieure, et uniquement avec les mises à jour de sécurité Windows de janvier 2018 et toutes les mises à jour de microprogramme applicables du fabricant d’appareils OEM. Consultez l’Aide du client Windows pour les professionnels de l’informatique pour vous protéger contre les vulnérabilités de canal latéral d’exécution spéculative.
-
- PROCESS_CREATION_MITIGATION_POLICY2_RESTRICT_INDIRECT_BRANCH_PREDICTION_ALWAYS_ON (0x0000001ui64 << 16)Cet indicateur peut être utilisé par les processus pour se protéger contre les threads matériels frères (hyperthreads) contre l’interférence avec les prédictions de branche indirectes. Les processus qui contiennent des informations sensibles dans leur espace d’adressage doivent envisager d’activer cet indicateur pour se protéger contre les attaques impliquant une prédiction de branche indirecte (comme CVE-2017-5715).
-
-
Windows 10, version 1809 : La valeur suivante est disponible uniquement dans Windows 10, version 1809 ou ultérieure.
-
- PROCESS_CREATION_MITIGATION_POLICY2_SPECULATIVE_STORE_BYPASS_DISABLE_ALWAYS_ON (0x0000001ui64 << 24)Cet indicateur peut être utilisé par les processus pour désactiver la fonctionnalité de contournement du magasin spéculatif (SSB) des processeurs qui peuvent être vulnérables aux attaques de canal latéral à l’exécution spéculative impliquant SSB (CVE-2018-3639). Cet indicateur est uniquement pris en charge par certains processeurs Intel qui ont les fonctionnalités matérielles requises. Sur les processeurs qui ne prennent pas en charge cette fonctionnalité, l’indicateur n’a aucun effet.
-
Windows 10, version 2004 : Les valeurs suivantes sont disponibles uniquement dans Windows 10, version 2004 ou ultérieure.
La protection de la pile appliquée par le matériel (HSP) est une fonctionnalité de sécurité matérielle dans laquelle le processeur vérifie les adresses de retour de fonction au moment de l’exécution en utilisant un mécanisme de pile fantôme. Pour le HSP en mode utilisateur, le mode par défaut est le mode de compatibilité, où seules les violations de pile d’ombres qui se produisent dans les modules considérés comme compatibles avec les piles d’ombres (CETCOMPAT) sont irrécupérables. En mode strict, toutes les violations de la pile d’ombres sont irrécupérables.
Les options d’atténuation suivantes sont disponibles pour la protection de la pile en mode utilisateur appliquée par le matériel et les fonctionnalités associées :
- PROCESS_CREATION_MITIGATION_POLICY2_CET_USER_SHADOW_STACKS_ALWAYS_ON (0x00000001ui64 << 28)
- PROCESS_CREATION_MITIGATION_POLICY2_CET_USER_SHADOW_STACKS_ALWAYS_OFF (0x00000002ui64 << 28)
- PROCESS_CREATION_MITIGATION_POLICY2_CET_USER_SHADOW_STACKS_STRICT_MODE (0x00000003ui64 << 28)
- PROCESS_CREATION_MITIGATION_POLICY2_USER_CET_SET_CONTEXT_IP_VALIDATION_ALWAYS_ON (0x0000001ui64 << 32)
- PROCESS_CREATION_MITIGATION_POLICY2_USER_CET_SET_CONTEXT_IP_VALIDATION_ALWAYS_OFF (0x00000002ui64 << 32)
- PROCESS_CREATION_MITIGATION_POLICY2_USER_CET_SET_CONTEXT_IP_VALIDATION_RELAXED_MODE (0x00000003ui64 << 32)
- PROCESS_CREATION_MITIGATION_POLICY2_BLOCK_NON_CET_BINARIES_ALWAYS_ON (0x0000001ui64 << 36)
- PROCESS_CREATION_MITIGATION_POLICY2_BLOCK_NON_CET_BINARIES_ALWAYS_OFF (0x00000002ui64 << 36)
- PROCESS_CREATION_MITIGATION_POLICY2_BLOCK_NON_CET_BINARIES_NON_EHCONT (0x00000003ui64 << 36)
- PROCESS_CREATION_MITIGATION_POLICY2_CET_DYNAMIC_APIS_OUT_OF_PROC_ONLY_ALWAYS_ON (0x0000001ui64 << 48)
- PROCESS_CREATION_MITIGATION_POLICY2_CET_DYNAMIC_APIS_OUT_OF_PROC_ONLY_ALWAYS_OFF (0x00000002ui64 << 48)
- PROCESS_CREATION_MITIGATION_POLICY2_FSCTL_SYSTEM_CALL_DISABLE_ALWAYS_ON (0x00000001ui64 << 56)
- PROCESS_CREATION_MITIGATION_POLICY2_FSCTL_SYSTEM_CALL_DISABLE_ALWAYS_OFF (0x00000002ui64 << 56)
Validation du pointeur d’instruction :
Blocage de la charge des fichiers binaires non-CETCOMPAT/non-EHCONT :
Restriction de certaines API HSP utilisées pour spécifier les propriétés de sécurité du code dynamique pour qu’elles ne puissent être appelées qu’en dehors du processus :
La stratégie de désactivation des appels système FSCTL, si elle est activée, empêche un processus d’effectuer des appels NtFsControlFile. Les options d’atténuation suivantes sont disponibles pour la stratégie de désactivation des appels système FSCTL :
Le DWORD pointé vers par lpValue peut être une ou plusieurs des valeurs suivantes lorsque vous spécifiez PROC_THREAD_ATTRIBUTE_CHILD_PROCESS_POLICY pour le paramètre Attribute :
PROCESS_CREATION_CHILD_PROCESS_RESTRICTED 0x01
Le processus en cours de création n’est pas autorisé à créer des processus enfants. Cette restriction devient une propriété du jeton tel que le processus s’exécute. Il convient de noter que cette restriction n’est effective que dans les applications bac à sable (telles que AppContainer) qui garantissent que les handles de processus privilégiés ne sont pas accessibles au processus. Par exemple, si un processus limitant la création d’un processus enfant est en mesure d’accéder à un autre handle de processus avec des droits d’accès PROCESS_CREATE_PROCESS ou PROCESS_VM_WRITE, il peut être possible de contourner la restriction de processus enfant.
0x02 PROCESS_CREATION_CHILD_PROCESS_OVERRIDE
Le processus en cours de création est autorisé à créer un processus enfant, s’il est autrement restreint. Vous pouvez uniquement spécifier cette valeur si le processus qui crée le nouveau processus n’est pas restreint.
Le DWORD pointé vers par lpValue peut être une ou plusieurs des valeurs suivantes lorsque vous spécifiez PROC_THREAD_ATTRIBUTE_DESKTOP_APP_POLICY pour le paramètre Attribute :
PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_ENABLE_PROCESS_TREE 0x01
Le processus en cours de création crée tous les processus enfants en dehors de l’environnement d’exécution de l’application de bureau. Ce comportement est la valeur par défaut pour les processus pour lesquels aucune stratégie n’a été définie.
0x02 PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_DISABLE_PROCESS_TREE
Le processus en cours de création crée tous les processus enfants à l’intérieur de l’environnement d’exécution de l’application de bureau. Cette stratégie est héritée par les processus descendants jusqu’à ce qu’elle soit remplacée par la création d’un processus avec PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_ENABLE_PROCESS_TREE.
PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_OVERRIDE 0x04
Le processus en cours de création s’exécute à l’intérieur de l’environnement d’exécution de l’application de bureau. Cette stratégie s’applique uniquement au processus en cours de création, et non à ses descendants.
Pour lancer le processus enfant avec le même niveau de protection que le parent, le processus parent doit spécifier l’attribut PROC_THREAD_ATTRIBUTE_PROTECTION_LEVEL pour le processus enfant. Cela peut être utilisé pour les processus protégés et non protégés. Par exemple, lorsque cet indicateur est utilisé par un processus non protégé, le système lance un processus enfant au niveau non protégé. L’indicateur CREATE_PROTECTED_PROCESS doit être spécifié dans les deux cas.
L’exemple suivant lance un processus enfant avec le même niveau de protection que le processus parent :
DWORD ProtectionLevel = PROTECTION_LEVEL_SAME;
SIZE_T AttributeListSize;
STARTUPINFOEXW StartupInfoEx = { 0 };
StartupInfoEx.StartupInfo.cb = sizeof(StartupInfoEx);
InitializeProcThreadAttributeList(NULL, 1, 0, &AttributeListSize)
StartupInfoEx.lpAttributeList = (LPPROC_THREAD_ATTRIBUTE_LIST) HeapAlloc(
GetProcessHeap(),
0,
AttributeListSize
);
if (InitializeProcThreadAttributeList(StartupInfoEx.lpAttributeList,
1,
0,
&AttributeListSize) == FALSE)
{
Result = GetLastError();
goto exitFunc;
}
if (UpdateProcThreadAttribute(StartupInfoEx.lpAttributeList,
0,
PROC_THREAD_ATTRIBUTE_PROTECTION_LEVEL,
&ProtectionLevel,
sizeof(ProtectionLevel),
NULL,
NULL) == FALSE)
{
Result = GetLastError();
goto exitFunc;
}
PROCESS_INFORMATION ProcessInformation = { 0 };
if (CreateProcessW(ApplicationName,
CommandLine,
ProcessAttributes,
ThreadAttributes,
InheritHandles,
EXTENDED_STARTUPINFO_PRESENT | CREATE_PROTECTED_PROCESS,
Environment,
CurrentDirectory,
(LPSTARTUPINFOW)&StartupInfoEx,
&ProcessInformation) == FALSE)
{
Result = GetLastError();
goto exitFunc;
}
Configuration requise
| Condition requise | Valeur |
|---|---|
| Client minimal pris en charge | Windows Vista [applications de bureau uniquement] |
| Serveur minimal pris en charge | Windows Server 2008 [applications de bureau uniquement] |
| Plateforme cible | Windows |
| En-tête | processthreadsapi.h (inclure Windows.h sur Windows 7, Windows Server 2008 Windows Server 2008 R2) |
| Bibliothèque | Kernel32.lib |
| DLL | Kernel32.dll |
Voir aussi
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour