Condividi tramite

Funzione UpdateProcThreadAttribute (processthreadsapi.h)

  • Articolo

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.

Valore Significato
PROC_THREAD_ATTRIBUTE_GROUP_AFFINITY
 Il parametro lpValue è un puntatore a una struttura GROUP_AFFINITY che specifica l'affinità del gruppo di processori per il nuovo thread.

Supportato in Windows 7 e versioni successive e Windows Server 2008 R2 e versioni successive.
PROC_THREAD_ATTRIBUTE_HANDLE_LIST
 Il parametro lpValue è un puntatore a un elenco di handle da ereditare dal processo figlio.

Questi handle devono essere creati come handle ereditabili e non devono includere pseudo handle, ad esempio quelli restituiti dalla funzione GetCurrentProcess o GetCurrentThread.

Si noti se si usa questo attributo, passare un valore true per il parametro bInheritHandles della funzione CreateProcess .
 
PROC_THREAD_ATTRIBUTE_IDEAL_PROCESSOR
 Il parametro lpValue è un puntatore a una struttura PROCESSOR_NUMBER che specifica il processore ideale per il nuovo thread.

Supportato in Windows 7 e versioni successive e Windows Server 2008 R2 e versioni successive.
PROC_THREAD_ATTRIBUTE_MACHINE_TYPE
 Il parametro lpValue è un puntatore a word che specifica l'architettura del computer del processo figlio.

Supportato in Windows 11 e versioni successive.

Word puntato a per lpValue può essere un valore elencato nelle COSTANTI DI IMAGE FILE MACHINE.
PROC_THREAD_ATTRIBUTE_MITIGATION_POLICY
 Il parametro lpValue è un puntatore a un DWORD o DWORD64 che specifica i criteri di mitigazione degli exploit per il processo figlio. A partire da Windows 10 versione 1703, questo parametro può anche essere un puntatore a una matrice di DWORD64 a due elementi.

Il criterio specificato esegue l'override dei criteri impostati per l'applicazione e non può essere modificato dopo l'avvio del processo figlio.

DWORD o DWORD64 puntato da lpValue può essere uno o più dei valori elencati nelle osservazioni.

Supportato in Windows 7 e versioni successive e Windows Server 2008 R2 e versioni successive.
PROC_THREAD_ATTRIBUTE_PARENT_PROCESS
 Il parametro lpValue è un puntatore all'handle di un processo da usare (anziché il processo chiamante) come padre per il processo creato. L'handle per il processo usato deve avere il diritto di accesso PROCESS_CREATE_PROCESS .

Gli attributi ereditati dal processo specificato includono handle, la mappa del dispositivo, l'affinità del processore, la priorità, le quote, il token di processo e l'oggetto processo. Si noti che alcuni attributi, ad esempio la porta di debug, provengono dal processo di creazione, non dal processo specificato da questo handle.
PROC_THREAD_ATTRIBUTE_PREFERRED_NODE
 Il parametro lpValue è un puntatore al numero di nodo del nodo NUMA preferito per il nuovo processo.

Supportato in Windows 7 e versioni successive e Windows Server 2008 R2 e versioni successive.
PROC_THREAD_ATTRIBUTE_UMS_THREAD
 Il parametro lpValue è un puntatore a una struttura UMS_CREATE_THREAD_ATTRIBUTES che specifica un contesto di pianificazione in modalità utente e un elenco di completamento UMS da associare al thread.

Dopo aver creato il thread UMS, il sistema lo accoda all'elenco di completamento specificato. Il thread UMS viene eseguito solo quando l'utilità di pianificazione UMS di un'applicazione recupera il thread UMS dall'elenco di completamento e lo seleziona per l'esecuzione. Per altre informazioni, vedere Pianificazione in modalità utente.

Supportato in Windows 7 e versioni successive e Windows Server 2008 R2 e versioni successive.

Non supportato in Windows 11 e versioni successive (vedere Pianificazione in modalità utente).
PROC_THREAD_ATTRIBUTE_SECURITY_CAPABILITIES
 Il parametro lpValue è un puntatore a una struttura SECURITY_CAPABILITIES che definisce le funzionalità di sicurezza di un contenitore di app. Se questo attributo è impostato, il nuovo processo verrà creato come processo AppContainer.

Supportato in Windows 8 e versioni successive e Windows Server 2012 e versioni successive.
PROC_THREAD_ATTRIBUTE_PROTECTION_LEVEL
 Il parametro lpValue è un puntatore a un valore DWORD di PROTECTION_LEVEL_SAME. In questo modo viene specificato il livello di protezione del processo figlio allo stesso livello di protezione del processo padre.

Supportato in Windows 8.1 e versioni successive e Windows Server 2012 R2 e versioni successive.
PROC_THREAD_ATTRIBUTE_CHILD_PROCESS_POLICY
 Il parametro lpValue è un puntatore a un valore DWORD che specifica i criteri del processo figlio. Il criterio specifica se consentire la creazione di un processo figlio.

Per informazioni sui valori possibili per la DWORD a cui punta lpValue , vedere Osservazioni.

Supportato in Windows 10 e versioni successive e Windows Server 2016 e versioni successive.
PROC_THREAD_ATTRIBUTE_DESKTOP_APP_POLICY
 Questo attributo è rilevante solo per le applicazioni win32 convertite in pacchetti UWP usando Desktop Bridge.

Il parametro lpValue è un puntatore a un valore DWORD che specifica i criteri dell'app desktop. Il criterio specifica se i processi discendenti devono continuare a essere eseguiti nell'ambiente desktop.

Per informazioni sui valori possibili per la DWORD a cui punta lpValue , vedere Osservazioni.

Supportato in Windows 10 versione 1703 e versioni successive e windows Server versione 1709 e versioni successive.
PROC_THREAD_ATTRIBUTE_JOB_LIST
 Il parametro lpValue è un puntatore a un elenco di handle di processi da assegnare al processo figlio, nell'ordine specificato.

Supportato in Windows 10 e versioni successive e Windows Server 2016 e versioni successive.
PROC_THREAD_ATTRIBUTE_ENABLE_OPTIONAL_XSTATE_FEATURES
 Il parametro lpValue è un puntatore a un valore DWORD64 che specifica il set di funzionalità XState facoltative da abilitare per il nuovo thread.

Supportato in Windows 11 e versioni successive e Windows Server 2022 e versioni successive.

[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