Funzione UpdateProcThreadAttribute (processthreadsapi.h)

Aggiorna l'attributo specificato in un elenco di attributi per la creazione di processi e thread.

Sintassi

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
);

Parametri

[in, out] lpAttributeList

Puntatore a un elenco di attributi creato dalla funzione InitializeProcThreadAttributeList .

[in] dwFlags

Questo parametro è riservato e deve essere zero.

[in] Attribute

Chiave dell'attributo da aggiornare nell'elenco di attributi. Questo parametro può avere uno dei valori seguenti.

[in] lpValue

Puntatore al valore dell'attributo. Questo valore deve essere persistente finché l'elenco di attributi non viene eliminato usando la funzione DeleteProcThreadAttributeList.

[in] cbSize

Dimensione del valore dell'attributo specificato dal parametro lpValue .

[out, optional] lpPreviousValue

Questo parametro è riservato e deve essere NULL.

[in, optional] lpReturnSize

Questo parametro è riservato e deve essere NULL.

Valore restituito

Se la funzione ha esito positivo, il valore restituito è diverso da zero.

Se la funzione ha esito negativo, il valore restituito è zero. Per informazioni dettagliate sull'errore, chiamare GetLastError.

Commenti

Un elenco di attributi è una struttura opaca costituita da una serie di coppie chiave/valore, una per ogni attributo. Un processo può aggiornare solo le chiavi dell'attributo descritte in questo argomento.

DWORD o DWORD64 puntato da lpValue può essere uno o più dei valori seguenti quando si specifica PROC_THREAD_ATTRIBUTE_MITIGATION_POLICY per il parametro Attribute:

PROCESS_CREATION_MITIGATION_POLICY_DEP_ENABLE (0x00000001 )Abilita la prevenzione dell'esecuzione dei dati per il processo figlio. Per altre informazioni, vedere Prevenzione dell'esecuzione dei dati.

PROCESS_CREATION_MITIGATION_POLICY_DEP_ATL_THUNK_ENABLE (0x00000002 )Abilita l'emulazione dep-ATL thunk per il processo figlio. L'emulazione DEP-ATL thunk causa l'intercettamento degli errori di NX provenienti dal livello di thunk di Active Template Library (ATL). Questo valore può essere specificato solo con PROCESS_CREATION_MITIGATION_POLICY_DEP_ENABLE.

PROCESS_CREATION_MITIGATION_POLICY_SEHOP_ENABLE (0x00000004 )Abilita il gestore delle eccezioni strutturate sovrascrive la protezione (SEHOP) per il processo figlio. SEHOP blocca gli exploit che usano la tecnica di sovrascrittura del gestore eccezioni strutturata (SEH).

Windows 7, Windows Server 2008 R2, Windows Server 2008 e Windows Vista: I valori seguenti non sono supportati fino a Windows 8 e Windows Server 2012.

Il criterio force Address Space Layout Randomization (ASLR), se abilitato, ribase delle immagini che non sono compatibili con la base dinamica fungendo da collisione di base immagine durante il caricamento. Se sono necessarie le rilocazioni, le immagini che non dispongono di una sezione di rilocazione di base non verranno caricate.

Per i criteri ASLR obbligatori sono disponibili le opzioni di mitigazione seguenti:

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)

L'heap termina nei criteri di danneggiamento, se abilitati, causa l'interruzione dell'heap in caso di danneggiamento. Si noti che 'always off' non esegue l'override del consenso esplicito predefinito per i file binari con le versioni del sottosistema correnti impostate nell'intestazione dell'immagine. L'heap termina in caso di danneggiamento viene applicata la modalità utente.

Le opzioni di mitigazione seguenti sono disponibili per l'interruzione dell'heap nei criteri di danneggiamento:

PROCESS_CREATION_MITIGATION_POLICY_HEAP_TERMINATE_ALWAYS_ON (0x00000001 << 12)

PROCESS_CREATION_MITIGATION_POLICY_HEAP_TERMINATE_ALWAYS_OFF (0x00000002 << 12)

I criteri casuali in basso, che includono opzioni di randomizzazione dello stack, determinano l'uso di una posizione casuale come indirizzo utente più basso.

Per i criteri di casualizzazione in basso sono disponibili le opzioni di mitigazione seguenti:

PROCESS_CREATION_MITIGATION_POLICY_BOTTOM_UP_ASLR_ALWAYS_ON (0x00000001 << 16)

PROCESS_CREATION_MITIGATION_POLICY_BOTTOM_UP_ASLR_ALWAYS_OFF (0x00000002 << 16)

Se abilitata, i criteri di randomizzazione inferiore a entropia elevata causano l'uso di un massimo di 1 TB di varianza inferiore. Si noti che l'alta entropia casuale dal basso verso l'alto è efficace se e solo se ASLR inferiore è abilitato anche; l'entropia inferiore casuale è significativa solo per i processi nativi a 64 bit.

Sono disponibili le opzioni di mitigazione seguenti per i criteri casuali di entropia inferiore:

PROCESS_CREATION_MITIGATION_POLICY_HIGH_ENTROPY_ASLR_ALWAYS_ON (0x00000001 << 20)

PROCESS_CREATION_MITIGATION_POLICY_HIGH_ENTROPY_ASLR_ALWAYS_OFF (0x00000002 << 20)

Il controllo rigoroso dei criteri di imposizione, se abilitato, causa la generazione immediata di un'eccezione in un riferimento di handle non valido. Se questo criterio non è abilitato, verrà restituito uno stato di errore dal riferimento di handle.

Sono disponibili le opzioni di mitigazione seguenti per i criteri di imposizione dei controlli di gestione rigorosi:

PROCESS_CREATION_MITIGATION_POLICY_STRICT_HANDLE_CHECKS_ALWAYS_ON (0x00000001 << 24)

PROCESS_CREATION_MITIGATION_POLICY_STRICT_HANDLE_CHECKS_ALWAYS_OFF (0x00000002 << 24)

Il criterio di disabilitazione della chiamata di sistema Win32k, se abilitato, impedisce a un processo di effettuare chiamate Win32k.

Per il criterio di disabilitazione delle chiamate di sistema Win32k sono disponibili le opzioni di mitigazione seguenti:

PROCESS_CREATION_MITIGATION_POLICY_WIN32K_SYSTEM_CALL_DISABLE_ALWAYS_ON (0x00000001 << 28)

PROCESS_CREATION_MITIGATION_POLICY_WIN32K_SYSTEM_CALL_DISABLE_ALWAYS_OFF (0x00000002 << 28)

Il criterio Disabilita punto di estensione, se abilitato, impedisce l'uso di determinati punti di estensione di terze parti predefiniti. Questo criterio blocca i punti di estensione seguenti:

• DLL AppInit
• Provider di servizi a più livelli Winsock
• Hook di Windows globali
• Editor dei metodi di input legacy (IMEs)

Gli hook locali continuano a funzionare con il criterio Di disabilitazione del punto di estensione abilitato. Questo comportamento viene usato per impedire che i punti di estensione legacy vengano caricati in un processo che non li usa.

Per il criterio di disabilitazione del punto di estensione sono disponibili le opzioni di mitigazione seguenti:

PROCESS_CREATION_MITIGATION_POLICY_EXTENSION_POINT_DISABLE_ALWAYS_ON (0x00000001 << 32)

PROCESS_CREATION_MITIGATION_POLICY_EXTENSION_POINT_DISABLE_ALWAYS_OFF (0x00000002 << 32)

I criteri di Control Flow Guard (CFG), se attivati, comportano restrizioni aggiuntive sulle chiamate indirette nel codice compilato con CFG abilitato.

Per controllare i criteri cfg sono disponibili le opzioni di mitigazione seguenti:

• PROCESS_CREATION_MITIGATION_POLICY_CONTROL_FLOW_GUARD_MASK (0x00000003ui64 << 40)
• PROCESS_CREATION_MITIGATION_POLICY_CONTROL_FLOW_GUARD_DEFER (0x000000000ui64 << 40)
• PROCESS_CREATION_MITIGATION_POLICY_CONTROL_FLOW_GUARD_ALWAYS_ON (0x00000001ui64 << 40)
• PROCESS_CREATION_MITIGATION_POLICY_CONTROL_FLOW_GUARD_ALWAYS_OFF (0x000000002ui64 << 40)
• PROCESS_CREATION_MITIGATION_POLICY_CONTROL_FLOW_GUARD_EXPORT_SUPPRESSION (0x00000003ui64 << 40)

Inoltre, è possibile specificare i criteri seguenti per applicare che EXEs/DLL devono abilitare cfg. Se si tenta di caricare un file EXE/DLL che non abilita CFG, il caricamento avrà esito negativo:

• PROCESS_CREATION_MITIGATION_POLICY2_STRICT_CONTROL_FLOW_GUARD_MASK (0x00000003ui64 << 8)
• PROCESS_CREATION_MITIGATION_POLICY2_STRICT_CONTROL_FLOW_GUARD_DEFER (0x000000000ui64 << 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)

I criteri di codice dinamico, se attivati, impediscono a un processo di generare codice dinamico o modificare il codice eseguibile.

Per i criteri di codice dinamico sono disponibili le opzioni di mitigazione seguenti:

PROCESS_CREATION_MITIGATION_POLICY_PROHIBIT_DYNAMIC_CODE_MASK (0x00000003ui64 << 36)

PROCESS_CREATION_MITIGATION_POLICY_PROHIBIT_DYNAMIC_CODE_DEFER (0x000000000ui64 << 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)

Per i criteri di firma binaria è necessario che le DLL/EXEs siano firmate correttamente.

Per i criteri di firma binaria sono disponibili le opzioni di mitigazione seguenti:

• PROCESS_CREATION_MITIGATION_POLICY_BLOCK_NON_MICROSOFT_BINARIES_MASK (0x00000003ui64 << 44)
• PROCESS_CREATION_MITIGATION_POLICY_BLOCK_NON_MICROSOFT_BINARIES_DEFER (0x000000000ui64 << 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)

I criteri di prevenzione del caricamento dei tipi di carattere per il processo determinano se i tipi di carattere non di sistema possono essere caricati per un processo. Quando il criterio è attivato, al processo viene impedito il caricamento di tipi di carattere non di sistema.

Per i criteri di prevenzione del caricamento dei tipi di carattere sono disponibili le opzioni di mitigazione seguenti:

PROCESS_CREATION_MITIGATION_POLICY_FONT_DISABLE_MASK (0x00000003ui64 << 48)

PROCESS_CREATION_MITIGATION_POLICY_FONT_DISABLE_DEFER (0x000000000ui64 << 48)

PROCESS_CREATION_MITIGATION_POLICY_FONT_DISABLE_ALWAYS_ON (0x00000001ui64 << 48)

PROCESS_CREATION_MITIGATION_POLICY_FONT_DISABLE_ALWAYS_OFF (0x000000002ui64 << 48)

PROCESS_CREATION_MITIGATION_POLICY_AUDIT_NONSYSTEM_FONTS (0x00000003ui64 << 48)

I criteri di caricamento delle immagini del processo determinano i tipi di immagini eseguibili di cui è possibile eseguire il mapping nel processo. Quando il criterio è attivato, le immagini non possono essere caricate da alcune posizioni, ad esempio rimuovere dispositivi o file con l'etichetta Obbligatoria bassa.

Per i criteri di caricamento delle immagini sono disponibili le opzioni di mitigazione seguenti:

PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_NO_REMOTE_MASK (0x00000003ui64 << 52)

PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_NO_REMOTE_DEFER (0x000000000ui64 << 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 (0x000000000ui64 << 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 (0x000000000ui64 << 60)

PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_PREFER_SYSTEM32_ALWAYS_ON (0x00000001ui64 << 60)

PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_PREFER_SYSTEM32_ALWAYS_OFF (0x000000002ui64 << 60)

PROCESS_CREATION_MITIGATION_POLICY_IMAGE_LOAD_PREFER_SYSTEM32_RESERVED (0x00000003ui64 << 60)

Windows 10, versione 1709: Il valore seguente è disponibile solo in Windows 10, versione 1709 o successiva e solo con gli aggiornamenti della sicurezza di Windows di gennaio 2018 e gli aggiornamenti del firmware applicabili dal produttore del dispositivo OEM. Vedere Linee guida per i client Windows per professionisti IT per la protezione da vulnerabilità del canale laterale dell'esecuzione speculativa.

PROCESS_CREATION_MITIGATION_POLICY2_RESTRICT_INDIRECT_BRANCH_PREDICTION_ALWAYS_ON (0x00000001ui64 << 16)Questo flag può essere usato dai processi per proteggere da thread hardware di pari livello (hyperthread) da interferire con stime di ramo indiretto. I processi con informazioni riservate nello spazio indirizzi devono prendere in considerazione l'abilitazione di questo flag per la protezione da attacchi che coinvolgono stime indirette del ramo (ad esempio CVE-2017-5715).

Windows 10, versione 1809: Il valore seguente è disponibile solo in Windows 10, versione 1809 o successiva.

PROCESS_CREATION_MITIGATION_POLICY2_SPECULATIVE_STORE_BYPASS_DISABLE_ALWAYS_ON (0x000000001ui64 << 24)Questo flag può essere usato dai processi per disabilitare la funzionalità Speculative Store Bypass (SSB) di CPU che potrebbero essere vulnerabili agli attacchi di canale lato esecuzione speculativo che coinvolgono SSB (CVE-2018-3639). Questo flag è supportato solo da determinate CPU Intel che dispongono delle funzionalità hardware necessarie. Nelle CPU che non supportano questa funzionalità, il flag non ha alcun effetto.

Windows 10, versione 2004: I valori seguenti sono disponibili solo in Windows 10 versione 2004 o successiva.

HSP (Hardware-enforced Stack Protection) è una funzionalità di sicurezza basata su hardware in cui la CPU verifica gli indirizzi restituiti dalla funzione in fase di esecuzione usando un meccanismo dello stack shadow. Per HSP in modalità utente, la modalità predefinita è la modalità di compatibilità, in cui solo le violazioni dello stack shadow che si verificano nei moduli considerati compatibili con gli stack shadow (CETCOMPAT) sono irreversibili. In modalità strict, tutte le violazioni dello stack shadow sono irreversibili.

Le opzioni di mitigazione seguenti sono disponibili per la protezione dello stack applicata dall'hardware in modalità utente e per le funzionalità correlate:

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)

Convalida del puntatore all'istruzione:

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 (0x000000002ui64 << 32)

PROCESS_CREATION_MITIGATION_POLICY2_USER_CET_SET_CONTEXT_IP_VALIDATION_RELAXED_MODE (0x00000003ui64 << 32)

Blocco del carico dei file binari non CETCOMPAT/non EHCONT:

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 (0x00000003ui64 << 36)

Limitazione di determinate API HSP usate per specificare le proprietà di sicurezza del codice dinamico in modo che possano essere chiamate solo dall'esterno del processo:

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)

Il criterio di disabilitazione della chiamata di sistema NTTL, se abilitato, impedisce a un processo di effettuare chiamate NtFsControlFile. Sono disponibili le seguenti opzioni di mitigazione per il criterio di disabilitazione delle chiamate di sistema CRTL:

PROCESS_CREATION_MITIGATION_POLICY2_FSCTL_SYSTEM_CALL_DISABLE_ALWAYS_ON (0x00000001ui64 << 56)

PROCESS_CREATION_MITIGATION_POLICY2_FSCTL_SYSTEM_CALL_DISABLE_ALWAYS_OFF (0x000000002ui64 << 56)

La DWORD a cui punta lpValue può essere uno o più dei valori seguenti quando si specifica PROC_THREAD_ATTRIBUTE_CHILD_PROCESS_POLICY per il parametro Attribute:

PROCESS_CREATION_CHILD_PROCESS_RESTRICTED 0x01

Il processo creato non può creare processi figlio. Questa restrizione diventa una proprietà del token durante l'esecuzione del processo. Si noti che questa restrizione è valida solo nelle applicazioni in modalità sandbox (ad esempio AppContainer) che assicurano che gli handle di processo con privilegi non siano accessibili al processo. Ad esempio, se un processo che limita la creazione di processi figlio è in grado di accedere a un altro handle di processo con diritti di accesso PROCESS_CREATE_PROCESS o PROCESS_VM_WRITE, potrebbe essere possibile ignorare la restrizione del processo figlio.

PROCESS_CREATION_CHILD_PROCESS_OVERRIDE 0x02

Il processo creato può creare un processo figlio, se altrimenti sarà limitato. È possibile specificare questo valore solo se il processo che crea il nuovo processo non è limitato.

La DWORD a cui punta lpValue può essere uno o più dei valori seguenti quando si specifica PROC_THREAD_ATTRIBUTE_DESKTOP_APP_POLICY per il parametro Attribute :

0x01 PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_ENABLE_PROCESS_TREE

Il processo creato creerà tutti i processi figlio all'esterno dell'ambiente di runtime dell'app desktop. Questo comportamento è l'impostazione predefinita per i processi per i quali non è stato impostato alcun criterio.

PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_DISABLE_PROCESS_TREE 0x02

Il processo creato creerà tutti i processi figlio all'interno dell'ambiente di runtime dell'app desktop. Questo criterio viene ereditato dai processi discendenti fino a quando non viene sottoposto a override creando un processo con PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_ENABLE_PROCESS_TREE.

PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_OVERRIDE 0x04

Il processo creato verrà eseguito all'interno dell'ambiente di runtime dell'app desktop. Questo criterio si applica solo al processo creato, non ai relativi discendenti.

Per avviare il processo figlio con lo stesso livello di protezione dell'elemento padre, il processo padre deve specificare l'attributo PROC_THREAD_ATTRIBUTE_PROTECTION_LEVEL per il processo figlio. Può essere usato sia per i processi protetti che per i processi non protetti. Ad esempio, quando questo flag viene usato da un processo non protetto, il sistema avvierà un processo figlio a livello non protetto. Il flag CREATE_PROTECTED_PROCESS deve essere specificato in entrambi i casi.

Nell'esempio seguente viene avviato un processo figlio con lo stesso livello di protezione del processo padre:

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;
}

Requisiti

Requisito	Valore
Client minimo supportato	Windows Vista [solo app desktop]
Server minimo supportato	Windows Server 2008 [solo app desktop]
Piattaforma di destinazione	Windows
Intestazione	processthreadsapi.h (includere Windows.h in Windows 7, Windows Server 2008 Windows Server 2008 R2)
Libreria	Kernel32.lib
DLL	Kernel32.dll

Vedere anche

DeleteProcThreadAttributeList

InitializeProcThreadAttributeList

Funzioni di processi e thread