Função UpdateProcThreadAttribute (processthreadsapi.h)
Atualiza o atributo especificado em uma lista de atributos para criação de processo e thread.
Sintaxe
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
);
Parâmetros
[in, out] lpAttributeList
Um ponteiro para uma lista de atributos criada pela função InitializeProcThreadAttributeList .
[in] dwFlags
Esse parâmetro é reservado e precisa ser zero.
[in] Attribute
A chave de atributo a ser atualizada na lista de atributos. Esse parâmetro pode usar um dos valores a seguir.
| Valor | Significado |
|---|---|
|
O parâmetro lpValue é um ponteiro para uma estrutura GROUP_AFFINITY que especifica a afinidade do grupo de processadores para o novo thread.
Com suporte no Windows 7 e mais recente e no Windows Server 2008 R2 e mais recente. |
|
O parâmetro lpValue é um ponteiro para uma lista de identificadores a serem herdados pelo processo filho.
Esses identificadores devem ser criados como identificadores herdáveis e não devem incluir pseudo-identificadores, como os retornados pela função GetCurrentProcess ou GetCurrentThread . Observe que, se você usar esse atributo, passe um valor true para o parâmetro bInheritHandles da função CreateProcess .
|
|
O parâmetro lpValue é um ponteiro para uma estrutura PROCESSOR_NUMBER que especifica o processador ideal para o novo thread.
Com suporte no Windows 7 e mais recente e no Windows Server 2008 R2 e mais recente. |
|
O parâmetro lpValue é um ponteiro para um WORD que especifica a arquitetura do computador do processo filho.
Com suporte no Windows 11 e mais recente. O WORD apontado por lpValue pode ser um valor listado em IMAGE FILE MACHINE CONSTANTS. |
|
O parâmetro lpValue é um ponteiro para um DWORD ou DWORD64 que especifica a política de mitigação de exploração para o processo filho. A partir do Windows 10, versão 1703, esse parâmetro também pode ser um ponteiro para uma matriz DWORD64 de dois elementos.
A política especificada substitui as políticas definidas para o aplicativo e o sistema e não pode ser alterada após o processo filho começar a ser executado. O DWORD ou DWORD64 apontado por lpValue pode ser um ou mais dos valores listados nos comentários. Com suporte no Windows 7 e mais recente e no Windows Server 2008 R2 e mais recente. |
|
O parâmetro lpValue é um ponteiro para o identificador de um processo a ser usado (em vez do processo de chamada) como o pai do processo que está sendo criado. O identificador do processo usado deve ter o direito de acesso PROCESS_CREATE_PROCESS.
Os atributos herdados do processo especificado incluem identificadores, o mapa do dispositivo, a afinidade do processador, a prioridade, as cotas, o token de processo e o objeto de trabalho. (Observe que alguns atributos, como a porta de depuração, virão do processo de criação, não do processo especificado por esse identificador.) |
|
O parâmetro lpValue é um ponteiro para o número do nó do nó NUMA preferencial para o novo processo.
Com suporte no Windows 7 e mais recente e no Windows Server 2008 R2 e mais recente. |
|
O parâmetro lpValue é um ponteiro para uma estrutura UMS_CREATE_THREAD_ATTRIBUTES que especifica um contexto de thread umS (agendamento de modo de usuário) e uma lista de conclusão umS a ser associada ao thread.
Depois que o thread UMS é criado, o sistema o enfileira na lista de conclusão especificada. O thread UMS é executado somente quando o agendador UMS de um aplicativo recupera o thread UMS da lista de conclusão e o seleciona para ser executado. Para obter mais informações, consulte Agendamento do modo de usuário. Com suporte no Windows 7 e mais recente e no Windows Server 2008 R2 e mais recente. Sem suporte no Windows 11 e mais recente (consulte Agendamento no modo de usuário). |
|
O parâmetro lpValue é um ponteiro para uma estrutura SECURITY_CAPABILITIES que define os recursos de segurança de um contêiner de aplicativo. Se esse atributo for definido, o novo processo será criado como um processo AppContainer.
Com suporte no Windows 8 e mais recente e no Windows Server 2012 e mais recente. |
|
O parâmetro lpValue é um ponteiro para um valor DWORD de PROTECTION_LEVEL_SAME. Isso especifica o nível de proteção do processo filho para ser o mesmo que o nível de proteção de seu processo pai.
Com suporte no Windows 8.1 e mais recente e no Windows Server 2012 R2 e mais recente. |
|
O parâmetro lpValue é um ponteiro para um valor DWORD que especifica a política de processo filho. A política especifica se um processo filho deve ser criado.
Para obter informações sobre os valores possíveis para o DWORD para o qual lpValue aponta, consulte Comentários. Com suporte no Windows 10 e mais recente e no Windows Server 2016 e mais recente. |
|
Esse atributo é relevante apenas para aplicativos win32 que foram convertidos em pacotes UWP usando a Ponte de Desktop.
O parâmetro lpValue é um ponteiro para um valor DWORD que especifica a política de aplicativo da área de trabalho. A política especifica se os processos descendentes devem continuar a ser executados no ambiente da área de trabalho. Para obter informações sobre os valores possíveis para o DWORD para o qual lpValue aponta, consulte Comentários. Com suporte no Windows 10 versão 1703 e mais recente e windows server versão 1709 e mais recente. |
|
O parâmetro lpValue é um ponteiro para uma lista de identificadores de trabalho a serem atribuídos ao processo filho, na ordem especificada.
Com suporte no Windows 10 e mais recente e no Windows Server 2016 e mais recente. |
|
O parâmetro lpValue é um ponteiro para um valor DWORD64 que especifica o conjunto de recursos opcionais do XState a serem habilitados para o novo thread.
Com suporte no Windows 11 e mais recente e no Windows Server 2022 e mais recente. |
[in] lpValue
Um ponteiro para o valor do atributo. Esse valor deve persistir até que a lista de atributos seja destruída usando a função DeleteProcThreadAttributeList.
[in] cbSize
O tamanho do valor do atributo especificado pelo parâmetro lpValue .
[out, optional] lpPreviousValue
Esse parâmetro é reservado e deve ser NULL.
[in, optional] lpReturnSize
Esse parâmetro é reservado e deve ser NULL.
Valor retornado
Se a função for bem-sucedida, o valor retornado será diferente de zero.
Se a função falhar, o valor retornado será zero. Para obter informações de erro estendidas, chame GetLastError.
Comentários
Uma lista de atributos é uma estrutura opaca que consiste em uma série de pares chave/valor, um para cada atributo. Um processo pode atualizar apenas as chaves de atributo descritas neste tópico.
O DWORD ou DWORD64 apontado por lpValue pode ser um ou mais dos seguintes valores quando você especifica PROC_THREAD_ATTRIBUTE_MITIGATION_POLICY para o parâmetro Attribute :
- PROCESS_CREATION_MITIGATION_POLICY_DEP_ENABLE (0x00000001)Habilita a DEP (prevenção de execução de dados) para o processo filho. Para obter mais informações, consulte Prevenção de execução de dados.
- PROCESS_CREATION_MITIGATION_POLICY_DEP_ATL_THUNK_ENABLE (0x00000002)Habilita a emulação thunk de DEP-ATL para o processo filho. A emulação de conversão DEP-ATL faz com que o sistema intercepte falhas NX originadas da camada de conversão da ATL (Biblioteca de Modelos Ativos). Esse valor só pode ser especificado com PROCESS_CREATION_MITIGATION_POLICY_DEP_ENABLE.
- PROCESS_CREATION_MITIGATION_POLICY_SEHOP_ENABLE (0x00000004)Habilita a SEHOP (proteção de substituição de manipulador de exceção estruturada) para o processo filho. O SEHOP bloqueia explorações que usam a técnica de substituição do SEH (manipulador de exceção estruturado).
-
Windows 7, Windows Server 2008 R2, Windows Server 2008 e Windows Vista: Os valores a seguir não têm suporte até o Windows 8 e o Windows Server 2012.
-
A política de ASLR (Address Space Layout Randomization) forçada, se habilitada, rebaseia à força imagens que não são compatíveis com base dinâmica agindo como se uma colisão de base de imagem tivesse ocorrido no momento da carga. Se forem necessárias realocações, as imagens que não têm uma seção de realocação base não serão carregadas.
As seguintes opções de mitigação estão disponíveis para a política ASLR obrigatória:
- 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)
-
O heap termina na política de corrupção, se habilitada, faz com que o heap seja encerrado se ele se tornar corrompido. Observe que 'always off' não substitui a aceitação padrão para binários com as versões atuais do subsistema definidas no cabeçalho da imagem. A terminação de heap em corrupção é imposta pelo modo de usuário.
As seguintes opções de mitigação estão disponíveis para o encerramento de heap na política de corrupção:
- PROCESS_CREATION_MITIGATION_POLICY_HEAP_TERMINATE_ALWAYS_ON (0x00000001 << 12)
- PROCESS_CREATION_MITIGATION_POLICY_HEAP_TERMINATE_ALWAYS_OFF (0x00000002 << 12)
-
A política de randomização de baixo para cima, que inclui opções de randomização de pilha, faz com que um local aleatório seja usado como o endereço de usuário mais baixo.
As seguintes opções de mitigação estão disponíveis para a política de randomização de baixo para cima:
- PROCESS_CREATION_MITIGATION_POLICY_BOTTOM_UP_ASLR_ALWAYS_ON (0x00000001 << 16)
- PROCESS_CREATION_MITIGATION_POLICY_BOTTOM_UP_ASLR_ALWAYS_OFF (0x00000002 << 16)
-
A política de randomização de baixo para cima de entropia alta, se habilitada, faz com que até 1 TB de variação de baixo para cima seja usada. Observe que a randomização de baixo para cima de entropia alta é eficaz se e somente se o ASLR de baixo para cima também estiver habilitado; A randomização de baixo para cima da entropia alta só é significativa para processos nativos de 64 bits.
As seguintes opções de mitigação estão disponíveis para a política de randomização de baixo para cima de entropia alta:
- PROCESS_CREATION_MITIGATION_POLICY_HIGH_ENTROPY_ASLR_ALWAYS_ON (0x00000001 << 20)
- PROCESS_CREATION_MITIGATION_POLICY_HIGH_ENTROPY_ASLR_ALWAYS_OFF (0x00000002 << 20)
-
O identificador estrito que verifica a política de imposição, se habilitada, faz com que uma exceção seja gerada imediatamente em uma referência de identificador incorreto. Se essa política não estiver habilitada, um status de falha será retornado da referência de identificador.
As seguintes opções de mitigação estão disponíveis para a política de imposição de verificação de identificador estrita:
- PROCESS_CREATION_MITIGATION_POLICY_STRICT_HANDLE_CHECKS_ALWAYS_ON (0x00000001 << 24)
- PROCESS_CREATION_MITIGATION_POLICY_STRICT_HANDLE_CHECKS_ALWAYS_OFF (0x00000002 << 24)
-
A política de desabilitação da chamada do sistema Win32k, se habilitada, impede que um processo execute chamadas win32k.
As seguintes opções de mitigação estão disponíveis para a política de desabilitação de chamada do sistema 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)
-
A política Desabilitar Ponto de Extensão, se habilitada, impede que determinados pontos de extensão internos de terceiros sejam usados. Essa política bloqueia os seguintes pontos de extensão:
- AppInit DLLs
- Provedores de serviços em camadas winsock (LSPs)
- Ganchos globais do Windows
- IMEs (Editores de Método de Entrada Herdados)
As seguintes opções de mitigação estão disponíveis para a política de desabilitação do ponto de extensão:
- PROCESS_CREATION_MITIGATION_POLICY_EXTENSION_POINT_DISABLE_ALWAYS_ON (0x00000001 << 32)
- PROCESS_CREATION_MITIGATION_POLICY_EXTENSION_POINT_DISABLE_ALWAYS_OFF (0x00000002 << 32)
-
A política de CFG (Proteção de Fluxo de Controle), se ativada, impõe restrições adicionais às chamadas indiretas no código que foi criado com o CFG habilitado.
As seguintes opções de mitigação estão disponíveis para controlar a política 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 (0x00000001ui64 << 40)
- PROCESS_CREATION_MITIGATION_POLICY_CONTROL_FLOW_GUARD_ALWAYS_OFF (0x00000002ui64 << 40)
- PROCESS_CREATION_MITIGATION_POLICY_CONTROL_FLOW_GUARD_EXPORT_SUPPRESSION (0x00000003ui64 << 40)
-
Além disso, a política a seguir pode ser especificada para impor que EXEs/DLLs devem habilitar o CFG. Se for feita uma tentativa de carregar um EXE/DLL que não habilita o CFG, a carga falhará:
- PROCESS_CREATION_MITIGATION_POLICY2_STRICT_CONTROL_FLOW_GUARD_MASK (0x00000003ui64 << 8)
- PROCESS_CREATION_MITIGATION_POLICY2_STRICT_CONTROL_FLOW_GUARD_DEFER (0x00000000ui64 << 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)
-
A política de código dinâmico, se ativada, impede que um processo gere código dinâmico ou modifique o código executável.
As seguintes opções de mitigação estão disponíveis para a política de código dinâmico:
- PROCESS_CREATION_MITIGATION_POLICY_PROHIBIT_DYNAMIC_CODE_MASK (0x00000003ui64 << 36)
- PROCESS_CREATION_MITIGATION_POLICY_PROHIBIT_DYNAMIC_CODE_DEFER (0x00000000ui64 << 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)
-
A política de assinatura binária exige que EXEs/DLLs sejam assinados corretamente.
As seguintes opções de mitigação estão disponíveis para a política de assinatura binária:
- PROCESS_CREATION_MITIGATION_POLICY_BLOCK_NON_MICROSOFT_BINARIES_MASK (0x00000003ui64 << 44)
- PROCESS_CREATION_MITIGATION_POLICY_BLOCK_NON_MICROSOFT_BINARIES_DEFER (0x00000000ui64 << 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)
-
A política de prevenção de carregamento de fontes para o processo determina se fontes que não são do sistema podem ser carregadas para um processo. Quando a política é ativada, o processo é impedido de carregar fontes que não são do sistema.
As seguintes opções de mitigação estão disponíveis para a política de prevenção de carregamento de fontes:
- PROCESS_CREATION_MITIGATION_POLICY_FONT_DISABLE_MASK (0x00000003ui64 << 48)
- PROCESS_CREATION_MITIGATION_POLICY_FONT_DISABLE_DEFER (0x00000000ui64 << 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)
-
A política de carregamento de imagem do processo determina os tipos de imagens executáveis que podem ser mapeadas para o processo. Quando a política está ativada, as imagens não podem ser carregadas de alguns locais, como remover dispositivos ou arquivos que tenham o rótulo Baixa obrigatória.
As seguintes opções de mitigação estão disponíveis para a política de carregamento de imagens:
- 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 (0x00000000ui64 << 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 (0x00000000ui64 << 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 (0x00000003ui64 << 60)
-
A política de ASLR (Address Space Layout Randomization) forçada, se habilitada, rebaseia à força imagens que não são compatíveis com base dinâmica agindo como se uma colisão de base de imagem tivesse ocorrido no momento da carga. Se forem necessárias realocações, as imagens que não têm uma seção de realocação base não serão carregadas.
-
Windows 10, versão 1709: O valor a seguir está disponível apenas no Windows 10, versão 1709 ou posterior e somente com as atualizações de segurança do Windows de janeiro de 2018 e quaisquer atualizações de firmware aplicáveis do fabricante do dispositivo OEM. Consulte Diretrizes do cliente Windows para profissionais de TI para proteger contra vulnerabilidades de canal lateral de execução especulativa.
-
- PROCESS_CREATION_MITIGATION_POLICY2_RESTRICT_INDIRECT_BRANCH_PREDICTION_ALWAYS_ON (0x00000001ui64 << 16)Esse sinalizador pode ser usado por processos para proteger contra threads de hardware irmãos (hiperthreads) de interferir em previsões de branch indireto. Os processos que têm informações confidenciais em seu espaço de endereço devem considerar habilitar esse sinalizador para proteger contra ataques envolvendo previsão de branch indireto (como CVE-2017-5715).
-
-
Windows 10, versão 1809: O valor a seguir está disponível somente no Windows 10, versão 1809 ou posterior.
-
- PROCESS_CREATION_MITIGATION_POLICY2_SPECULATIVE_STORE_BYPASS_DISABLE_ALWAYS_ON (0x00000001ui64 << 24)Esse sinalizador pode ser usado por processos para desabilitar o recurso de Bypass de Repositório Especulativo (SSB) de CPUs que podem estar vulneráveis a ataques de canal lateral de execução especulativa envolvendo SSB (CVE-2018-3639). Esse sinalizador só tem suporte de determinadas CPUs Intel que têm os recursos de hardware necessários. Em CPUs que não dão suporte a esse recurso, o sinalizador não tem efeito.
-
Windows 10, versão 2004: Os valores a seguir estão disponíveis apenas no Windows 10, versão 2004 ou posterior.
O HSP (Proteção de Pilha imposta por hardware) é um recurso de segurança baseado em hardware em que a CPU verifica os endereços de retorno da função em runtime empregando um mecanismo de pilha de sombra. Para o HSP no modo de usuário, o modo padrão é o modo de compatibilidade, em que apenas violações de pilha de sombra que ocorrem em módulos considerados compatíveis com pilhas de sombra (CETCOMPAT) são fatais. No modo estrito, todas as violações da pilha de sombra são fatais.
As seguintes opções de mitigação estão disponíveis para o modo de usuário Proteção de Pilha imposta por hardware e recursos relacionados:
- PROCESS_CREATION_MITIGATION_POLICY2_CET_USER_SHADOW_STACKS_ALWAYS_ON (0x00000001ui64 << 28)
- PROCESS_CREATION_MITIGATION_POLICY2_CET_USER_SHADOW_STACKS_ALWAYS_OFF (0x000000002ui64 << 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 (0x00000003ui64 << 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)
Validação do ponteiro de instrução:
Bloqueando a carga de binários não CETCOMPAT/não EHCONT:
Restringir determinadas APIs de HSP usadas para especificar propriedades de segurança do código dinâmico para serem chamadas apenas de fora do processo:
A política de desabilitação da chamada do sistema FSCTL, se habilitada, impede que um processo execute chamadas NtFsControlFile. As seguintes opções de mitigação estão disponíveis para a política de desabilitação de chamada do sistema FSCTL:
O DWORD apontado por lpValue pode ser um ou mais dos seguintes valores quando você especifica PROC_THREAD_ATTRIBUTE_CHILD_PROCESS_POLICY para o parâmetro Attribute :
PROCESS_CREATION_CHILD_PROCESS_RESTRICTED 0x01
O processo que está sendo criado não tem permissão para criar processos filho. Essa restrição se torna uma propriedade do token à medida que o processo é executado. Deve-se observar que essa restrição só é eficaz em aplicativos em área restrita (como AppContainer) que garantem que os identificadores de processo privilegiado não estejam acessíveis ao processo. Por exemplo, se um processo que restringe a criação de processos filho for capaz de acessar outro identificador de processo com PROCESS_CREATE_PROCESS ou PROCESS_VM_WRITE direitos de acesso, talvez seja possível ignorar a restrição de processo filho.
PROCESS_CREATION_CHILD_PROCESS_OVERRIDE 0x02
O processo que está sendo criado tem permissão para criar um processo filho, caso contrário, ele seria restrito. Você só poderá especificar esse valor se o processo que está criando o novo processo não for restrito.
O DWORD apontado por lpValue pode ser um ou mais dos seguintes valores quando você especifica PROC_THREAD_ATTRIBUTE_DESKTOP_APP_POLICY para o parâmetro Attribute :
0x01 PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_ENABLE_PROCESS_TREE
O processo que está sendo criado criará todos os processos filho fora do ambiente de runtime do aplicativo da área de trabalho. Esse comportamento é o padrão para processos para os quais nenhuma política foi definida.
PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_DISABLE_PROCESS_TREE 0x02
O processo que está sendo criado criará todos os processos filho dentro do ambiente de runtime do aplicativo da área de trabalho. Essa política é herdada pelos processos descendentes até ser substituída criando um processo com PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_ENABLE_PROCESS_TREE.
PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_OVERRIDE 0x04
O processo que está sendo criado será executado dentro do ambiente de runtime do aplicativo da área de trabalho. Essa política se aplica somente ao processo que está sendo criado, não aos seus descendentes.
Para iniciar o processo filho com o mesmo nível de proteção que o pai, o processo pai deve especificar o atributo PROC_THREAD_ATTRIBUTE_PROTECTION_LEVEL para o processo filho. Isso pode ser usado para processos protegidos e desprotegidos. Por exemplo, quando esse sinalizador é usado por um processo desprotegido, o sistema iniciará um processo filho no nível desprotegido. O sinalizador CREATE_PROTECTED_PROCESS deve ser especificado em ambos os casos.
O exemplo a seguir inicia um processo filho com o mesmo nível de proteção que o processo pai:
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;
}
Requisitos
| Requisito | Valor |
|---|---|
| Cliente mínimo com suporte | Windows Vista [somente aplicativos da área de trabalho] |
| Servidor mínimo com suporte | Windows Server 2008 [somente aplicativos da área de trabalho] |
| Plataforma de Destino | Windows |
| Cabeçalho | processthreadsapi.h (inclua Windows.h no Windows 7, Windows Server 2008 Windows Server 2008 R2) |
| Biblioteca | Kernel32.lib |
| DLL | Kernel32.dll |