UpdateProcThreadAttribute, fonction (processthreadsapi.h)
Mises à 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é de 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 machine 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 LES CONSTANTES DE MACHINE IMAGE FILE. |
|
Le paramètre lpValue est un pointeur vers un DWORD ou un DWORD64 qui spécifie la stratégie d’atténuation des attaques pour le processus enfant. À compter de Windows 10, version 1703, ce paramètre peut également être un pointeur vers un tableau DWORD64 deux éléments.
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 après le démarrage de l’exécution du processus enfant. 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 un handle vers un processus à utiliser au lieu du processus appelant comme parent pour le processus en cours de création. Le processus à utiliser doit avoir le droit d’accès PROCESS_CREATE_PROCESS .
Les attributs hérités du processus spécifié incluent les handles, le mappage des appareils, 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 de 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 lorsque le planificateur UMS d’une application récupère le thread UMS 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 les 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 est créé en tant que processus AppContainer.
Pris en charge dans Windows 8 et versions ultérieures et Windows Server 2012 et plus récentes. |
|
Le paramètre lpValue est un pointeur vers une valeur DWORDde PROTECTION_LEVEL_SAME. Cela spécifie que le niveau de protection du processus enfant doit être identique au niveau de protection de son processus parent.
Pris en charge dans Windows 8.1 et versions plus récentes et Windows Server 2012 R2 et 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 plus récentes. |
|
Cet attribut s’applique uniquement aux applications win32 qui ont été converties en packages UWP à l’aide de la Pont du 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 ultérieure et Windows Server version 1709 et ultérieure. |
|
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 plus récentes. |
|
Le paramètre lpValue est un pointeur vers une valeur DWORD64 qui spécifie le jeu 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 être conservée 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 être NULL.
[in, optional] lpReturnSize
Ce paramètre est réservé et doit être 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 entraîne l’interception par le système des erreurs NX provenant de la couche de thunks ATL (Active Template Library). 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 contre le remplacement du gestionnaire d’exceptions structuré (SEHOP) pour le processus enfant. SEHOP bloque les attaques qui utilisent la technique de remplacement du gestionnaire d’exceptions structurées (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 de force ASLR (Address Space Layout Randomization), si elle est activée, rebasage de force les images qui ne sont pas compatibles de base dynamique en agissant comme si une collision de base d’images s’était produite au moment du chargement. Si des relocalisations sont requises, les images qui n’ont pas de section de déplacement de base ne sont 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 en cas de stratégie d’endommagement, s’il est activé, entraîne l’arrêt du tas s’il est endommagé. Notez que « always off » ne remplace pas l’option d’inscription par défaut pour les fichiers binaires dont les versions de sous-système actuelles sont définies dans l’en-tête d’image. Le mode utilisateur est appliqué en cas d’endommagement du tas.
Les options d’atténuation suivantes sont disponibles pour la fin du tas en cas de stratégie d’endommagement :
- PROCESS_CREATION_MITIGATION_POLICY_HEAP_TERMINATE_ALWAYS_ON (12 0x00000001 << )
- PROCESS_CREATION_MITIGATION_POLICY_HEAP_TERMINATE_ALWAYS_OFF (12 0x00000002 << )
-
La stratégie de randomisation ascendante, qui inclut des options de randomisation de 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 (16 0x00000001 << )
- PROCESS_CREATION_MITIGATION_POLICY_BOTTOM_UP_ASLR_ALWAYS_OFF (16 0x00000002 << )
-
La stratégie de randomisation ascendante à entropie élevée, si elle est activée, entraîne l’utilisation de jusqu’à 1 To de variance ascendante. Notez que la randomisation ascendante à haute entropie est efficace si et seulement si l’ASLR de bas en haut est également activé ; La randomisation ascendante à entropie élevée n’est significative que pour les processus 64 bits natifs.
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 (20 0x00000001 << )
- PROCESS_CREATION_MITIGATION_POLICY_HIGH_ENTROPY_ASLR_ALWAYS_OFF (20 0x00000002 << )
-
La stratégie d’application de vérification de handle stricte, si elle est activée, provoque 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 échec status 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 handle stricte :
- PROCESS_CREATION_MITIGATION_POLICY_STRICT_HANDLE_CHECKS_ALWAYS_ON (24 0x00000001 << )
- PROCESS_CREATION_MITIGATION_POLICY_STRICT_HANDLE_CHECKS_ALWAYS_OFF (24 0x00000002 << )
-
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 (28 0x00000001 << )
- PROCESS_CREATION_MITIGATION_POLICY_WIN32K_SYSTEM_CALL_DISABLE_ALWAYS_OFF (28 0x00000002 << )
-
La stratégie Désactiver le 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
- Hooks 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 (32 0x00000001 << )
- PROCESS_CREATION_MITIGATION_POLICY_EXTENSION_POINT_DISABLE_ALWAYS_OFF (32 0x00000002 << )
-
La stratégie Control Flow Guard (CFG), si elle est activée, place des restrictions supplémentaires sur les appels indirects dans le code qui a été généré 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 (0x0000000ui64 << 40)
- PROCESS_CREATION_MITIGATION_POLICY_CONTROL_FLOW_GUARD_ALWAYS_ON (0x00000001ui64 << 40)
- PROCESS_CREATION_MITIGATION_POLICY_CONTROL_FLOW_GUARD_ALWAYS_OFF (0x00000002ui64 << 40)
- PROCESS_CREATION_MITIGATION_POLICY_CONTROL_FLOW_GUARD_EXPORT_SUPPRESSION (0x0000003ui64 << 40)
-
En outre, la stratégie suivante peut être spécifiée pour appliquer que les FICHIERS EXE/DLL doivent activer CFG. Si une tentative est effectuée pour charger un EXE/DLL qui n’active pas CFG, 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 (0x00000001ui64 << 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 (0x0000003ui64 << 36)
- PROCESS_CREATION_MITIGATION_POLICY_PROHIBIT_DYNAMIC_CODE_DEFER (0x0000000ui64 << 36)
- PROCESS_CREATION_MITIGATION_POLICY_PROHIBIT_DYNAMIC_CODE_ALWAYS_ON (0x00000001ui64 << 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 (0x00000001ui64 << 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 (0x0000003ui64 << 48)
- PROCESS_CREATION_MITIGATION_POLICY_FONT_DISABLE_DEFER (0x0000000ui64 << 48)
- PROCESS_CREATION_MITIGATION_POLICY_FONT_DISABLE_ALWAYS_ON (0x00000001ui64 << 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 (0x00000000ui64 << 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 (0x0000003ui64 << 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 (0x00000001ui64 << 60)
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_PREFER_SYSTEM32_ALWAYS_OFF (0x00000002ui64 << 60)
- PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_PREFER_SYSTEM32_RESERVED (0x0000003ui64 << 60)
-
La stratégie de force ASLR (Address Space Layout Randomization), si elle est activée, rebasage de force les images qui ne sont pas compatibles de base dynamique en agissant comme si une collision de base d’images s’était produite au moment du chargement. Si des relocalisations sont requises, les images qui n’ont pas de section de déplacement de base ne sont 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 de l’appareil OEM. Consultez Conseils du client Windows pour les professionnels de l’informatique afin de 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 (0x00000001ui64 << 16)Cet indicateur peut être utilisé par des processus pour vous protéger contre les threads matériels frères (hyperthreads) d’interférer avec les prédictions de branche indirectes. Les processus qui ont 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 (par exemple CVE-2017-5715).
-
-
Windows 10, version 1809 : la valeur suivante est disponible uniquement dans Windows 10, version 1809 ou version 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 côté exécution spéculative impliquant SSB (CVE-2018-3639). Cet indicateur est uniquement pris en charge par certains processeurs Intel qui disposent des 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 se produisant 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 pile d’ombres sont irrécupérables.
Les options d’atténuation suivantes sont disponibles pour la protection de la pile appliquée en mode utilisateur 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 (0x00000001ui64 << 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 (0x00000001ui64 << 36)
- PROCESS_CREATION_MITIGATION_POLICY2_BLOCK_NON_CET_BINARIES_ALWAYS_OFF (0x00000002ui64 << 36)
- PROCESS_CREATION_MITIGATION_POLICY2_BLOCK_NON_CET_BINARIES_NON_EHCONT (0x0000003ui64 << 36)
- PROCESS_CREATION_MITIGATION_POLICY2_CET_DYNAMIC_APIS_OUT_OF_PROC_ONLY_ALWAYS_ON (0x00000001ui64 << 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é 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 :
0x01 PROCESS_CREATION_CHILD_PROCESS_RESTRICTED
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 en 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 ne pouvez spécifier cette valeur que si le processus qui crée le nouveau processus n’est pas limité.
Le DWORD pointé 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 :
0x01 PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_ENABLE_PROCESS_TREE
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.
PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_DISABLE_PROCESS_TREE 0x02
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.
0x04 PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_OVERRIDE
Le processus en cours de création s’exécute dans 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