Función UpdateProcThreadAttribute (processthreadsapi.h)

Artículo
03/08/2023

Actualiza el atributo especificado en una lista de atributos para la creación de procesos y subprocesos.

Sintaxis

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

Puntero a una lista de atributos creada por la función InitializeProcThreadAttributeList .

[in] dwFlags

Este parámetro está reservado y debe ser cero.

[in] Attribute

Clave de atributo que se va a actualizar en la lista de atributos. Este parámetro puede ser uno de los valores siguientes.

Valor	Significado
PROC_THREAD_ATTRIBUTE_GROUP_AFFINITY	El parámetro lpValue es un puntero a una estructura GROUP_AFFINITY que especifica la afinidad de grupo de procesadores para el nuevo subproceso. Compatible con Windows 7 y versiones más recientes y Windows Server 2008 R2 y versiones posteriores.
PROC_THREAD_ATTRIBUTE_HANDLE_LIST	El parámetro lpValue es un puntero a una lista de identificadores que el proceso secundario hereda. Estos identificadores se deben crear como identificadores heredados y no deben incluir pseudo identificadores, como los devueltos por la función GetCurrentProcess o GetCurrentThread . Tenga en cuenta si usa este atributo, pase un valor de TRUE para el parámetro bInheritHandles de la función CreateProcess .
PROC_THREAD_ATTRIBUTE_IDEAL_PROCESSOR	El parámetro lpValue es un puntero a una estructura PROCESSOR_NUMBER que especifica el procesador ideal para el nuevo subproceso. Compatible con Windows 7 y versiones más recientes y Windows Server 2008 R2 y versiones posteriores.
PROC_THREAD_ATTRIBUTE_MACHINE_TYPE	El parámetro lpValue es un puntero a un WORD que especifica la arquitectura de máquina del proceso secundario. Compatible con Windows 11 y versiones posteriores. La PALABRA a la que apunta lpValue puede ser un valor enumerado en IMAGE FILE MACHINE CONSTANTS.
PROC_THREAD_ATTRIBUTE_MITIGATION_POLICY	El parámetro lpValue es un puntero a un DWORD o DWORD64 que especifica la directiva de mitigación de vulnerabilidades para el proceso secundario. A partir de Windows 10, versión 1703, este parámetro también puede ser un puntero a una matriz de DWORD64 de dos elementos. La directiva especificada invalida las directivas establecidas para la aplicación y el sistema y no se pueden cambiar después de que el proceso secundario comience a ejecutarse. El DWORD o DWORD64 apuntado por lpValue puede ser uno o varios de los valores enumerados en los comentarios. Compatible con Windows 7 y versiones más recientes y Windows Server 2008 R2 y versiones posteriores.
PROC_THREAD_ATTRIBUTE_PARENT_PROCESS	El parámetro lpValue es un puntero al identificador de un proceso que se va a usar (en lugar del proceso de llamada) como elemento primario para el proceso que se va a crear. El identificador del proceso usado debe tener el derecho de acceso PROCESS_CREATE_PROCESS . Los atributos heredados del proceso especificado incluyen identificadores, el mapa del dispositivo, la afinidad del procesador, la prioridad, las cuotas, el token de proceso y el objeto de trabajo. (Tenga en cuenta que algunos atributos como el puerto de depuración provendrán del proceso de creación, no del proceso especificado por este identificador).
PROC_THREAD_ATTRIBUTE_PREFERRED_NODE	El parámetro lpValue es un puntero al número de nodo del nodo NUMA preferido para el nuevo proceso. Compatible con Windows 7 y versiones más recientes y Windows Server 2008 R2 y versiones posteriores.
PROC_THREAD_ATTRIBUTE_UMS_THREAD	El parámetro lpValue es un puntero a una estructura de UMS_CREATE_THREAD_ATTRIBUTES que especifica un contexto de subproceso de programación en modo de usuario (UMS) y una lista de finalización de UMS que se va a asociar al subproceso. Una vez creado el subproceso de UMS, el sistema lo pone en cola en la lista de finalización especificada. El subproceso de UMS solo se ejecuta cuando el programador de UMS de una aplicación recupera el subproceso de UMS de la lista de finalización y lo selecciona para ejecutarse. Para obtener más información, consulte Programación en modo de usuario. Compatible con Windows 7 y versiones más recientes y Windows Server 2008 R2 y versiones posteriores. No se admite en Windows 11 y versiones posteriores (consulta Programación en modo de usuario).
PROC_THREAD_ATTRIBUTE_SECURITY_CAPABILITIES	El parámetro lpValue es un puntero a una estructura de SECURITY_CAPABILITIES que define las funcionalidades de seguridad de un contenedor de aplicaciones. Si este atributo se establece, el nuevo proceso se creará como un proceso de AppContainer. Compatible con Windows 8 y versiones más recientes y Windows Server 2012 y versiones posteriores.
PROC_THREAD_ATTRIBUTE_PROTECTION_LEVEL	El parámetro lpValue es un puntero a un valor DWORD de PROTECTION_LEVEL_SAME. Esto especifica el nivel de protección del proceso secundario para que sea el mismo que el nivel de protección de su proceso primario. Compatible con Windows 8.1 y versiones más recientes y Windows Server 2012 R2 y versiones posteriores.
PROC_THREAD_ATTRIBUTE_CHILD_PROCESS_POLICY	El parámetro lpValue es un puntero a un valor DWORD que especifica la directiva de proceso secundario. La directiva especifica si se permite crear un proceso secundario. Para obtener información sobre los posibles valores de DWORD a los que apunta lpValue , vea Comentarios. Compatible con Windows 10 y versiones más recientes y Windows Server 2016 y versiones posteriores.
PROC_THREAD_ATTRIBUTE_DESKTOP_APP_POLICY	Este atributo solo es relevante para las aplicaciones win32 que se han convertido en paquetes para UWP mediante el puente de escritorio. El parámetro lpValue es un puntero a un valor DWORD que especifica la directiva de aplicación de escritorio. La directiva especifica si los procesos descendientes deben continuar ejecutándose en el entorno de escritorio. Para obtener información sobre los posibles valores de DWORD a los que apunta lpValue , vea Comentarios. Compatible con Windows 10 versión 1703 y versiones más recientes y Windows Server versión 1709 y versiones posteriores.
PROC_THREAD_ATTRIBUTE_JOB_LIST	El parámetro lpValue es un puntero a una lista de identificadores de trabajo que se asignarán al proceso secundario, en el orden especificado. Compatible con Windows 10 y versiones más recientes y Windows Server 2016 y versiones posteriores.
PROC_THREAD_ATTRIBUTE_ENABLE_OPTIONAL_XSTATE_FEATURES	El parámetro lpValue es un puntero a un valor de DWORD64 que especifica el conjunto de características XState opcionales que se habilitarán para el nuevo subproceso. Compatible con Windows 11 y versiones más recientes y Windows Server 2022 y versiones posteriores.

[in] lpValue

Puntero al valor del atributo. Este valor debe conservarse hasta que la lista de atributos se destruye mediante la función DeleteProcThreadAttributeList.

[in] cbSize

Tamaño del valor del atributo especificado por el parámetro lpValue .

[out, optional] lpPreviousValue

Este parámetro está reservado y debe ser NULL.

[in, optional] lpReturnSize

Este parámetro está reservado y debe ser NULL.

Valor devuelto

Si la función se realiza correctamente, el valor devuelto es distinto de cero.

Si la función no se realiza correctamente, el valor devuelto es cero. Para obtener información de error extendida, llame a GetLastError.

Comentarios

Una lista de atributos es una estructura opaca que consta de una serie de pares clave-valor, uno para cada atributo. Un proceso solo puede actualizar las claves de atributo descritas en este tema.

DWORD o DWORD64 apuntado por lpValue puede ser uno o varios de los valores siguientes al especificar PROC_THREAD_ATTRIBUTE_MITIGATION_POLICY para el parámetro Attribute:

PROCESS_CREATION_MITIGATION_POLICY_DEP_ENABLE (0x00000001)Habilita la prevención de ejecución de datos (DEP) para el proceso secundario. Para obtener más información, consulte Prevención de ejecución de datos.

PROCESS_CREATION_MITIGATION_POLICY_DEP_ATL_THUNK_ENABLE (0x00000002)Habilita la emulación thunk de DEP-ATL para el proceso secundario. La emulación thunk de DEP-ATL hace que el sistema intercepte los errores de NX que se originan en la capa thunk de la Biblioteca de plantillas activas (ATL). Este valor solo se puede especificar con PROCESS_CREATION_MITIGATION_POLICY_DEP_ENABLE.

PROCESS_CREATION_MITIGATION_POLICY_SEHOP_ENABLE (0x00000004)Habilita la protección contra sobrescritura del controlador de excepciones estructurado (SEHOP) para el proceso secundario. SEHOP bloquea vulnerabilidades de seguridad que usan la técnica de sobrescritura del controlador de excepciones estructurado (SEH).

Windows 7, Windows Server 2008 R2, Windows Server 2008 y Windows Vista: Los valores siguientes no se admiten hasta Windows 8 y Windows Server 2012.

La directiva forzar la selección aleatoria del diseño del espacio de direcciones (ASLR), si está habilitada, vuelve a basar las imágenes que no son compatibles dinámicamente con la acción de actuar como si se producira una colisión de base de imagen en el tiempo de carga. Si se requieren reubicaciones, no se cargarán imágenes que no tengan una sección de reubicación base.

Las siguientes opciones de mitigación están disponibles para la directiva ASLR obligatoria:

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)

El montón finaliza en la directiva de daños, si está habilitada, hace que el montón finalice si se daña. Tenga en cuenta que "always off" no invalida la participación predeterminada para los archivos binarios con las versiones del subsistema actuales establecidas en el encabezado de imagen. La finalización del montón en daños es el modo de usuario aplicado.

Las siguientes opciones de mitigación están disponibles para finalizar el montón en la directiva de daños:

PROCESS_CREATION_MITIGATION_POLICY_HEAP_TERMINATE_ALWAYS_ON (0x00000001 << 12)

PROCESS_CREATION_MITIGATION_POLICY_HEAP_TERMINATE_ALWAYS_OFF (0x00000002 << 12)

La directiva de selección aleatoria de abajo arriba, que incluye opciones de selección aleatoria de pila, hace que se use una ubicación aleatoria como la dirección de usuario más baja.

Las siguientes opciones de mitigación están disponibles para la directiva de selección aleatoria de abajo arriba:

PROCESS_CREATION_MITIGATION_POLICY_BOTTOM_UP_ASLR_ALWAYS_ON (0x00000001 << 16)

PROCESS_CREATION_MITIGATION_POLICY_BOTTOM_UP_ASLR_ALWAYS_OFF (0x00000002 << 16)

La directiva de selección aleatoria de alta entropía, si está habilitada, hace que se usen hasta 1 TB de varianza inferior hacia arriba. Tenga en cuenta que la selección aleatoria de arriba abajo arriba de alta entropía es eficaz si y solo si asLR de abajo arriba también está habilitado; la selección aleatoria de arriba abajo arriba de alta entropía solo es significativa para los procesos nativos de 64 bits.

Las siguientes opciones de mitigación están disponibles para la directiva de selección aleatoria de alta entropía:

PROCESS_CREATION_MITIGATION_POLICY_HIGH_ENTROPY_ASLR_ALWAYS_ON (0x00000001 << 20)

PROCESS_CREATION_MITIGATION_POLICY_HIGH_ENTROPY_ASLR_ALWAYS_OFF (0x00000002 << 20)

La directiva estricta de comprobación de cumplimiento de control, si está habilitada, hace que se genere una excepción inmediatamente en una referencia de identificador incorrecta. Si esta directiva no está habilitada, se devolverá un estado de error desde la referencia de identificador en su lugar.

Las siguientes opciones de mitigación están disponibles para la directiva de cumplimiento de control estricto:

PROCESS_CREATION_MITIGATION_POLICY_STRICT_HANDLE_CHECKS_ALWAYS_ON (0x00000001 << 24)

PROCESS_CREATION_MITIGATION_POLICY_STRICT_HANDLE_CHECKS_ALWAYS_OFF (0x00000002 << 24)

La llamada al sistema Win32k deshabilita la directiva, si está habilitada, impide que un proceso realice llamadas de Win32k.

Las siguientes opciones de mitigación están disponibles para la directiva de deshabilitación de llamadas del 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)

La directiva Deshabilitar punto de extensión, si está habilitada, impide que se usen determinados puntos de extensión integrados de terceros. Esta directiva bloquea los siguientes puntos de extensión:

DLL de AppInit
Proveedores de servicios en capas de Winsock (LSP)
Enlaces globales de Windows
Editores de métodos de entrada heredados (IME)

Los enlaces locales siguen funcionando con la directiva Deshabilitar punto de extensión habilitada. Este comportamiento se usa para evitar que los puntos de extensión heredados se carguen en un proceso que no los use.

Las siguientes opciones de mitigación están disponibles para la directiva de deshabilitación del punto de extensión:

PROCESS_CREATION_MITIGATION_POLICY_EXTENSION_POINT_DISABLE_ALWAYS_ON (0x00000001 << 32)

PROCESS_CREATION_MITIGATION_POLICY_EXTENSION_POINT_DISABLE_ALWAYS_OFF (0x00000002 << 32)

La directiva Protección de flujo de control (CFG), si está activada, coloca restricciones adicionales en las llamadas indirectas en el código que se ha creado con CFG habilitado.

Las siguientes opciones de mitigación están disponibles para controlar la directiva 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)

Además, se puede especificar la siguiente directiva para aplicar que las EXE/DLL deben habilitar CFG. Si se intenta cargar un ARCHIVO EXE/DLL que no habilita CFG, se producirá un error en la carga:

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)

La directiva de código dinámico, si está activada, impide que un proceso genere código dinámico o modifique el código ejecutable.

Las siguientes opciones de mitigación están disponibles para la directiva 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)

La directiva de firma binaria requiere que los ARCHIVOS EXE/DLL se firmen correctamente.

Las siguientes opciones de mitigación están disponibles para la directiva de firma binaria:

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)

La directiva de prevención de carga de fuentes para el proceso determina si se pueden cargar fuentes que no son del sistema para un proceso. Cuando la directiva está activada, se impide que el proceso cargue fuentes que no son del sistema.

Las siguientes opciones de mitigación están disponibles para la directiva de prevención de carga de fuentes:

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 (0x000000001ui64 << 48)

PROCESS_CREATION_MITIGATION_POLICY_FONT_DISABLE_ALWAYS_OFF (0x00000002ui64 << 48)

PROCESS_CREATION_MITIGATION_POLICY_AUDIT_NONSYSTEM_FONTS (0x00000003ui64 << 48)

La directiva de carga de imágenes del proceso determina los tipos de imágenes ejecutables que se pueden asignar al proceso. Cuando la directiva está activada, las imágenes no se pueden cargar desde algunas ubicaciones, como quitar dispositivos o archivos que tengan la etiqueta obligatoria Baja.

Las siguientes opciones de mitigación están disponibles para la directiva de carga de imágenes:

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 (0x000000001ui64 << 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, versión 1709: El siguiente valor solo está disponible en Windows 10, versión 1709 o posterior y solo con las actualizaciones de seguridad de Windows de enero de 2018 y las actualizaciones de firmware aplicables del fabricante del dispositivo OEM. Consulte Guía del cliente de Windows para profesionales de TI para protegerse frente a vulnerabilidades de canal lateral de ejecución especulativa.

PROCESS_CREATION_MITIGATION_POLICY2_RESTRICT_INDIRECT_BRANCH_PREDICTION_ALWAYS_ON (0x000000001ui64 << 16) Los procesos pueden usar esta marca para protegerse frente a subprocesos de hardware del mismo nivel (hiperprocesos) de interferir con predicciones de rama indirecta. Los procesos que tienen información confidencial en su espacio de direcciones deben considerar la posibilidad de habilitar esta marca para protegerse frente a ataques relacionados con la predicción de rama indirecta (como CVE-2017-5715).

Windows 10, versión 1809: El siguiente valor solo está disponible en Windows 10, versión 1809 o posterior.

PROCESS_CREATION_MITIGATION_POLICY2_SPECULATIVE_STORE_BYPASS_DISABLE_ALWAYS_ON (0x00000001ui64 24 << ) Los procesos pueden usar esta marca para deshabilitar la característica de omisión de almacén especulativo (SSB) de cpu que pueden ser vulnerables a ataques de canal lateral de ejecución especulativa que implican SSB (CVE-2018-3639). Esta marca solo es compatible con determinadas CPU intel que tienen las características de hardware necesarias. En las CPU que no admiten esta característica, la marca no tiene ningún efecto.

Windows 10, versión 2004: Los valores siguientes solo están disponibles en Windows 10, versión 2004 o posterior.

Protección de pila aplicada por hardware (HSP) es una característica de seguridad basada en hardware en la que la CPU comprueba las direcciones de devolución de función en tiempo de ejecución mediante el empleo de un mecanismo de pila de sombras. En el caso del HSP en modo de usuario, el modo predeterminado es el modo de compatibilidad, donde solo se producen infracciones de la pila de sombras en módulos que se consideran compatibles con las pilas de sombras (CETCOMPAT). En modo estricto, todas las infracciones de la pila de sombras son fatales.

Las siguientes opciones de mitigación están disponibles para la protección de pila aplicada por hardware en modo de usuario y características relacionadas:

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)

Validación del puntero de instrucción:

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)

Bloqueo de la carga de archivos binarios no CETCOMPAT/no 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)

Restricción de determinadas API de HSP usadas para especificar las propiedades de seguridad del código dinámico para que solo se puedan llamar desde fuera del proceso:

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)

La llamada al sistema FSCTL deshabilita la directiva, si está habilitada, impide que un proceso realice llamadas a NtFsControlFile. Las siguientes opciones de mitigación están disponibles para la directiva de deshabilitación de llamadas del 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)

El DWORD al que apunta lpValue puede ser uno o varios de los valores siguientes al especificar PROC_THREAD_ATTRIBUTE_CHILD_PROCESS_POLICY para el parámetro Attribute :

PROCESS_CREATION_CHILD_PROCESS_RESTRICTED 0x01

El proceso que se crea no puede crear procesos secundarios. Esta restricción se convierte en una propiedad del token a medida que se ejecuta el proceso. Debe tenerse en cuenta que esta restricción solo es efectiva en aplicaciones de espacio aislado (como AppContainer), lo que garantiza que los identificadores de proceso con privilegios no sean accesibles para el proceso. Por ejemplo, si un proceso que restringe la creación de procesos secundarios puede acceder a otro identificador de proceso con PROCESS_CREATE_PROCESS o PROCESS_VM_WRITE derechos de acceso, puede que sea posible omitir la restricción del proceso secundario.

PROCESS_CREATION_CHILD_PROCESS_OVERRIDE 0x02

El proceso que se crea puede crear un proceso secundario, si de lo contrario se restringiría. Solo puede especificar este valor si el proceso que crea el nuevo proceso no está restringido.

El DWORD al que apunta lpValue puede ser uno o varios de los valores siguientes al especificar PROC_THREAD_ATTRIBUTE_DESKTOP_APP_POLICY para el parámetro Attribute :

PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_ENABLE_PROCESS_TREE 0x01

El proceso que se va a crear creará cualquier proceso secundario fuera del entorno de tiempo de ejecución de la aplicación de escritorio. Este comportamiento es el valor predeterminado para los procesos para los que no se ha establecido ninguna directiva.

PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_DISABLE_PROCESS_TREE 0x02

El proceso que se va a crear creará cualquier proceso secundario dentro del entorno en tiempo de ejecución de la aplicación de escritorio. Los procesos descendientes heredan esta directiva hasta que se invalida mediante la creación de un proceso con PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_ENABLE_PROCESS_TREE.

PROCESS_CREATION_DESKTOP_APP_BREAKAWAY_OVERRIDE 0x04

El proceso que se va a crear se ejecutará dentro del entorno de tiempo de ejecución de la aplicación de escritorio. Esta directiva solo se aplica al proceso que se va a crear, no a sus descendientes.

Para iniciar el proceso secundario con el mismo nivel de protección que el elemento primario, el proceso primario debe especificar el atributo PROC_THREAD_ATTRIBUTE_PROTECTION_LEVEL para el proceso secundario. Esto se puede usar para procesos protegidos y desprotegidos. Por ejemplo, cuando un proceso desprotegido usa esta marca, el sistema iniciará un proceso secundario en el nivel desprotegido. La marca CREATE_PROTECTED_PROCESS debe especificarse en ambos casos.

En el ejemplo siguiente se inicia un proceso secundario con el mismo nivel de protección que el proceso primario:

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	Value
Cliente mínimo compatible	Windows Vista [solo aplicaciones de escritorio]
Servidor mínimo compatible	Windows Server 2008 [solo aplicaciones de escritorio]
Plataforma de destino	Windows
Encabezado	processthreadsapi.h (incluye Windows.h en Windows 7, Windows Server 2008 Windows Server 2008 R2)
Library	Kernel32.lib
Archivo DLL	Kernel32.dll

Vea también

DeleteProcThreadAttributeList

InitializeProcThreadAttributeList

Funciones de proceso y subproceso

Compartir a través de

Función UpdateProcThreadAttribute (processthreadsapi.h)

Sintaxis

Parámetros

Valor devuelto

Comentarios

Requisitos

Vea también

Comentarios

Recursos adicionales