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.

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

Os ganchos locais ainda funcionam com a política Desabilitar Ponto de Extensão habilitada. Esse comportamento é usado para impedir que pontos de extensão herdados sejam carregados em um processo que não os usa.

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)

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)

Validação do ponteiro de instrução:

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)

Bloqueando a carga de binários não CETCOMPAT/não 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)

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:

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)

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:

PROCESS_CREATION_MITIGATION_POLICY2_FSCTL_SYSTEM_CALL_DISABLE_ALWAYS_ON (0x00000001ui64 << 56)

PROCESS_CREATION_MITIGATION_POLICY2_FSCTL_SYSTEM_CALL_DISABLE_ALWAYS_OFF (0x00000002ui64 << 56)

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

Confira também

DeleteProcThreadAttributeList

InitializeProcThreadAttributeList

Funções de thread e processo