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.

[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 hooks locaux fonctionnent toujours avec la stratégie De désactivation du point d’extension activée. Ce comportement est utilisé pour empêcher le chargement de points d’extension hérités dans un processus qui ne les utilise pas.

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)

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)

Validation du pointeur d’instruction :

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)

Blocage de la charge des fichiers binaires non-CETCOMPAT/non-EHCONT :

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)

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 :

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)

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 :

PROCESS_CREATION_MITIGATION_POLICY2_FSCTL_SYSTEM_CALL_DISABLE_ALWAYS_ON (0x00000001ui64 << 56)

PROCESS_CREATION_MITIGATION_POLICY2_FSCTL_SYSTEM_CALL_DISABLE_ALWAYS_OFF (0x00000002ui64 << 56)

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

DeleteProcThreadAttributeList

InitializeProcThreadAttributeList

Fonctions de processus et de thread