Proteger las credenciales de dominio derivadas con Credential Guard

Artículo
04/01/2016

Introducida en Windows 10 Enterprise, Credential Guard usa seguridad basada en la virtualización para aislar secretos, de manera que solo el software del sistema con privilegios puede acceder a ellos. El acceso no autorizado a estos secretos puede derivar en robos, como ataques Pass-the-Hash o Pass-the-Ticket.

Credential Guard ofrece las siguientes características y soluciones:

Seguridad de hardware Credential Guard aumenta la seguridad de las credenciales de dominio derivadas de sacar provecho de las características de seguridad de la plataforma, como el arranque seguro y la virtualización.
Seguridad basada en la virtualización Los servicios de Windows que administran las credenciales de dominio derivadas y otros secretos se ejecutan en un entorno protegido que está aislado del sistema operativo en ejecución.
Mejor protección contra las amenazas permanentes avanzadas Si proteges las credenciales de dominio derivadas con la seguridad basada en la virtualización, se bloquean las técnicas de ataques de robo de credenciales y herramientas que se usan en muchos ataques dirigidos. Con la ejecución de malware en el sistema operativo con privilegios administrativos no se pueden extraer secretos que están protegidos con la seguridad basada en la virtualización. Aunque Credential Guard es una mitigación eficaz, los ataques de amenazas persistentes probablemente cambiarán por nuevas técnicas de ataque y también deberías incorporar Device Guard y otras arquitecturas y estrategias de seguridad.
Facilidad de uso Puedes administrar Credential Guard mediante la directiva de grupo, WMI, desde un símbolo del sistema y de Windows PowerShell.

Funcionamiento

Credential Guard aísla secretos que versiones anteriores de Windows almacenaron en la autoridad de seguridad local (LSA) mediante seguridad basada en la virtualización. Antes de Windows 10, la LSA almacenaba secretos usados por el sistema operativo en la memoria del proceso. Con Credential Guard, el proceso de LSA en el sistema operativo se comunica con un nuevo componente denominado proceso LSA aislado que almacena y protege estos secretos. Los datos almacenados mediante el proceso LSA aislado se protegen con la seguridad basada en la virtualización y no son accesibles para el resto del sistema operativo. LSA usa llamadas a procedimiento remoto para comunicarse con el proceso LSA aislado.

Por motivos de seguridad, el proceso LSA aislado no hospeda ningún controlador de dispositivo. En su lugar, solo hospeda un pequeño subconjunto de binarios del sistema operativo que solo son necesarios para la seguridad. Todos estos binarios se firman con un certificado de confianza de la seguridad basada en la virtualización y estas firmas se validan antes de iniciar el archivo en el entorno protegido.

Además, Credential Guard no admite variantes anteriores de conjuntos de cifrado y protocolos de autenticación de Kerberos y NTLM al usar credenciales derivadas predeterminadas, incluidas NTLMv1, MS-CHAPv2 y tipos de cifrado Kerberos menos seguros, como DES.

Aquí encontrarás una descripción general de cómo está aislado el LSA mediante seguridad basada en la virtualización:

Mt483740.credguard(es-es,VS.85).png

Funcionalidades nuevas y modificadas

Para ver lo que se ha agregado o modificado en Credential Guard, consulta Novedades de Credential Guard.

Requisitos de hardware y software

El equipo debe cumplir los siguientes requisitos de hardware y software para usar Credential Guard:

Requisito	Descripción
Windows 10 Enterprise	El equipo debe ejecutar Windows 10 Enterprise.
Firmware UEFI versión 2.3.1 o posterior y arranque seguro	Para comprobar que el firmware está usando la versión UEFI 2.3.1 o posteriores y el arranque seguro, puedes validarlo con respecto al requisito del programa de compatibilidad de hardware de Windows System.Fundamentals.Firmware.CS.UEFISecureBoot.ConnectedStandby.
Extensiones de virtualización	Las siguientes extensiones de virtualización son necesarias para admitir la seguridad basada en la virtualización: Intel VT-x o AMD-V Traducción de direcciones de segundo nivel
Arquitectura x64	Las características que usa la seguridad basada en la virtualización en el hipervisor de Windows solo pueden ejecutarse en un equipo de 64 bits.
Un VT-d o AMD Vi IOMMU (unidad de administración de memoria de entrada y salida)	En Windows 10, un IOMMU mejora la resistencia del sistema contra los ataques a la memoria. ¹
Módulo de plataforma segura (TPM) versión 1.2 o 2.0	TPM 1.2 y 2.0 proporciona protección para las claves de cifrado que se almacenan en el firmware. TPM 1.2 no es compatible con Windows 10 (compilación 10240); sin embargo, es compatible con Windows 10, versión 1511 (compilación 10586) y posteriores. Nota Si no tienes un TPM instalado, Credential Guard se habilitará de todas formas, pero las claves usadas para cifrar Credential Guard no estarán protegidas con el TPM.
Proceso de actualización segura de firmware	Para comprobar que el firmware cumple el proceso de actualización segura de firmware, puedes validarlo con respecto al requisito del programa de compatibilidad de hardware de Windows System.Fundamentals.Firmware.UEFISecureBoot.
El firmware se actualiza para la Implementación de Secure MOR	Credential Guard requiere el bit Secure MOR para ayudar a prevenir determinados ataques de memoria.
Equipo físico	En el caso de los equipos que ejecutan Windows 10, no puedes ejecutar Credential Guard en una máquina virtual.

¹ Si eliges la opción Protección de DMA y arranque seguro en la configuración de directiva de grupo, se requiera una IOMMU. La opción de directiva de grupo Arranque seguro habilita Credential Guard en dispositivos sin una IOMMU.

Administrar Credential Guard

Credential Guard usa características de seguridad basada en la virtualización que deben estar habilitadas en cada equipo antes de que puedas usarlas.

Activar Credential Guard mediante el uso de la directiva de grupo

Puedes usar la directiva de grupo para habilitar Credential Guard porque agregará las características de seguridad basada en la virtualización para ti.

Desde la consola de administración de directiva de grupo, ve a Configuración del equipo -> Plantillas administrativas -> Sistema -> Device Guard.
Haz doble clic en Activar la seguridad basada en la virtualización y, a continuación, haz clic en la opción Habilitado.
Selecciona el cuadro Nivel de seguridad de la plataforma, elige Arranque seguro o Protección de DMA y arranque seguro.
En el cuadro Credential Guard Configuration, haz clic en Enabled with UEFI lock y, a continuación, haga clic en Aceptar. Si quieres poder desactivar Credential Guard de forma remota, elige Enabled without lock.
Cierra la Consola de administración de directivas de grupo.

Agregar Credential Guard a una imagen

Si te gustaría agregar Credential Guard a una imagen, agrega las características de seguridad basada en la virtualización y, a continuación, activa Credential Guard.

Agregar las características de seguridad basada en la virtualización

En primer lugar, debes agregar las características de seguridad basada en la virtualización. Para ello, usa el Panel de control o la herramienta Administración y mantenimiento de imágenes de implementación (DISM).

Nota Si habilitas Credential Guard mediante una directiva de grupo, estos pasos no son necesarios. La directiva de grupo instalará las características para ti.

Mt483740.wedge(es-es,VS.85).gif Agregar las características de seguridad basada en la virtualización mediante Programas y características

Abre el panel de control Programas y características.
Haz clic en Activar o desactivar la característica de Windows.
Selecciona la casilla Modo de usuario aislado.
Ve a Hyper-V -> Plataforma Hyper-V y, a continuación, selecciona la casilla Hipervisor Hyper-V.
Haz clic en Aceptar.

Mt483740.wedge(es-es,VS.85).gif Agregar las características de seguridad basada en la virtualización a una imagen sin conexión mediante DISM

Abre un símbolo del sistema con privilegios elevados.

Agrega el hipervisor Hyper-V ejecutando el siguiente comando:

dism /image:<WIM file name> /Enable-Feature /FeatureName:Microsoft-Hyper-V-Hypervisor

Agrega el Modo de usuario aislado ejecutando el siguiente comando:

dism /image:<WIM file name> /Enable-Feature /FeatureName:IsolatedUserMode

Nota

También puedes agregar estas características a una imagen en línea con DISM o Configuration Manager.

Activar Credential Guard

Si no usas la directiva de grupo, puedes habilitar Credential Guard mediante el registro.

Mt483740.wedge(es-es,VS.85).gif Activar Credential Guard mediante el registro

Abre el Editor del registro.
Habilitar la seguridad basada en la virtualización:
- Ve a HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\DeviceGuard.
- Agrega un nuevo valor DWORD denominado EnableVirtualizationBasedSecurity. Establece el valor de esta configuración del registro en 1 para habilitar la seguridad basada en la virtualización y establécelo en 0 para deshabilitarla.
- Agrega un nuevo valor DWORD denominado RequirePlatformSecurityFeatures. Establece el valor de esta configuración del registro en 1 para que solo use el Arranque seguro o establécelo en 2 para que use la Protección de DMA y arranque seguro.
Activar Credential Guard:
- Ve a HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\LSA.
- Agrega un nuevo valor DWORD denominado LsaCfgFlags. Establece el valor de esta configuración de registro en 1 para habilitar Credential Guard con el bloqueo UEFI, establécelo en 2 para habilitar Credential Guard sin el bloqueo y establécelo en 0 para deshabilitarlo.
Cierra el Editor del registro.

Nota

También puedes activar Credential Guard configurando las entradas del Registro en la configuración desatendida FirstLogonCommands.

Quitar Credential Guard

Si tienes que quitar Credential Guard en un equipo, debes hacer lo siguiente:

Si usas la directiva de grupo, deshabilita la configuración de directiva de grupo que usaste para habilitar Credential Guard (Configuración del equipo -> Plantillas administrativas -> Sistema -> Device Guard -> Activar la seguridad basada en la virtualización).
Elimina la siguiente configuración del registro: HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\DeviceGuard\LsaCfgFlags.
Elimina las variables EFI de Credential Guard mediante bcdedit.

Mt483740.wedge(es-es,VS.85).gif Eliminar las variables EFI de Credential Guard

En un símbolo del sistema con privilegios elevados, escribe los siguientes comandos:

mountvol X: /s
copy %WINDIR%\System32\SecConfig.efi X:\EFI\Microsoft\Boot\SecConfig.efi /Y
bcdedit /create {0cb3b571-2f2e-4343-a879-d86a476d7215} /d "DebugTool" /application osloader
bcdedit /set {0cb3b571-2f2e-4343-a879-d86a476d7215} path "\EFI\Microsoft\Boot\SecConfig.efi"
bcdedit /set {bootmgr} bootsequence {0cb3b571-2f2e-4343-a879-d86a476d7215}
bcdedit /set {0cb3b571-2f2e-4343-a879-d86a476d7215} loadoptions DISABLE-LSA-ISO
bcdedit /set {0cb3b571-2f2e-4343-a879-d86a476d7215} device partition=X:
mountvol X: /d

Reinicia el equipo.
Acepta la solicitud para deshabilitar Credential Guard.
Como alternativa, puedes deshabilitar las características de seguridad basada en la virtualización para desactivar Credential Guard.

Nota

El equipo debe tener acceso de un solo uso a un controlador de dominio para descifrar contenido, como archivos cifrados con EFS.

Si quieres desactivar Credential Guard y la seguridad basada en la virtualización, ejecuta el siguiente comando bcdedit después de desactivar todos los valores de configuración de registro y de directiva de grupo de seguridad basada en la virtualización:

bcdedit /set {0cb3b571-2f2e-4343-a879-d86a476d7215} loadoptions DISABLE-LSA-ISO,DISABLE-VBS

Para obtener más información sobre la seguridad basada en la virtualización y Device Guard, consulta el tema Guía de implementación de Device Guard.

Comprueba que se ejecuta Credential Guard

Puedes usar información del sistema para garantizar que Credential Guard se ejecuta en un equipo.

Haz clic en Inicio, Tipo msinfo32.exe y, a continuación, haz clic en Información del sistema.
Haz clic en Resumen del sistema.
Confirma que se muestra la opción Credential Guard junto a Servicios de seguridad de Device Guard en ejecución.

A continuación, se incluye un ejemplo:

Consideraciones sobre el uso de Credential Guard

Si Credential Guard está habilitada en un dispositivo después de que se una a un dominio, los secretos de usuario y del dispositivo podrían estar ya en riesgo. Te recomendamos que Protección de credenciales esté habilitada antes de que el equipo se una a un dominio.
Debes realizar revisiones regulares de los equipos que tienen Credential Guard habilitada. Esto puede hacerse con directivas de auditoría de seguridad o consultas de WMI. Esta es una lista de identificadores de evento de WinInit que buscar:
- Identificador de evento 13 Credential Guard (LsaIso.exe) se ha iniciado y protegerá los credenciales de LSA.
- Identificador de evento 14 Configuración de Credential Guard (LsaIso.exe): 0x1, 0
  - La primera variable: 0x1 significa que Credential Guard está configurado para ejecutarse. 0x0 significa que no está configurado para ejecutarse.
  - La segunda variable: 0 significa que está configurado para ejecutarse en el modo de protección. 1 significa que está configurado para ejecutarse en modo de prueba. Esta variable debe ser siempre 0.
- Identificador de evento 15 Credential Guard está configurada (LsaIso.exe), pero el kernel seguro no se está ejecutando. Continúa sin Credential Guard.
- Identificador de evento 16 Credential Guard (LsaIso.exe) no se pudo iniciar: [código de error]
- Identificador de evento 17 Error al leer la configuración UEFI de Credential Guard (LsaIso.exe): [código de error]
También puedes comprobar que el TPM se usa para la protección de claves consultando el siguiente evento en el origen de eventos Microsoft -> Windows -> Kernel-Arranque. Si ejecutas con un TPM, el valor de máscara de TPM PCR será distinto de 0.
- Event ID 51 Aprovisionamiento de la clave de cifrado maestro de VSM. Estado de la eliminación de la copia en caché: 0x0. Estado de la generación de la clave nueva: 0x1. Estado de la generación de la clave nueva: 0x1. Estado del sello: 0x1. Máscara de TPM PCR: 0x0.
Las contraseñas siguen sin ser seguras por lo que te recomendamos que la organización implemente Credential Guard y evite las contraseñas y otros métodos de autenticación, como tarjetas inteligentes físicas, tarjetas inteligentes virtuales, Microsoft Passport o Microsoft Passport for Work.
Algunos proveedores de compatibilidad para seguridad de terceros (SSP y puntos de acceso) podrían no ser compatibles con Credential Guard. Credential Guard no permite que SSP de terceros soliciten hashes de contraseña de LSA. Sin embargo, los SSP y puntos de acceso personalizados siguen recibiendo la notificación de la contraseña cuando un usuario inicia sesión o cambia su contraseña. No se admite el uso de API no documentadas dentro de los SSP y puntos de acceso personalizados. Te recomendamos que las implementaciones personalizadas de SSP y puntos de acceso personalizados se prueben con respecto a Credential Guard para garantizar que los SSP y AP no dependen de comportamientos no documentados o no compatibles. Por ejemplo, no se admite el uso de la API KerbQuerySupplementalCredentialsMessage. No debes reemplazar SSP de Kerberos o NTLM con SSP y puntos de acceso personalizados. Para obtener más información, consulta Restrictions around Registering and Installing a Security Package en MSDN.
Cuando la amplitud y profundidad de las protecciones que ofrece Credential Guard aumentan, las versiones posteriores de Windows 10 que ejecuten Credential Guard podrían influir en los escenarios que estaban funcionando en el pasado. Por ejemplo, Credential Guard puede bloquear el uso de un tipo particular de credencial o de un componente concreto para impedir que el malware saque provecho de las vulnerabilidades. Por lo tanto, te recomendamos que los escenarios necesarios para las operaciones de una organización se prueben antes de actualizar un dispositivo que con Credential Guard en ejecución.
Si usas puntos de conexión Wi-Fi y VPN que se basan en MS-CHAPv2, están sujetos a ataques similares como NTLMv1. Te recomendamos que las organizaciones usen la autenticación basada en certificados para conexiones Wi-Fi y VPN.
A partir de Windows 10, versión 1511, las credenciales de dominio que se almacenan con el Administrador de credenciales están protegidas con Credential Guard. El Administrador de credenciales te permite almacenar credenciales, como nombres de usuario y contraseñas que usas para iniciar sesión en sitios web o a otros equipos de una red. Las consideraciones siguientes se aplican a las protecciones de Credential Guard para el Administrador de credenciales:
- Las credenciales que guardan los Servicios de Escritorio remoto no se pueden usar para conectarse a otra máquina de forma remota sin proporcionar la contraseña.
- Las aplicaciones que extraen credenciales de dominio derivadas desde el Administrador de credenciales ya no podrán usar estas credenciales.
- No se pueden restaurar credenciales mediante el panel de control del Administrador de credenciales si las credenciales se han recuperado a través de una copia de seguridad de un equipo que tenga activado Credential Guard. Si necesitas hacer una copia de seguridad de tus credenciales, debes hacerlo antes de habilitar Credential Guard. De lo contrario, no podrás restaurar dichas credenciales.

Escenarios que no protege Credential Guard

Algunas maneras de almacenar las credenciales no están protegidas por Credential Guard, incluidos:

Software que administra credenciales fuera de la protección de la característica de Windows
Las cuentas locales y cuentas de Microsoft
Un servidor de Windows Server 2016 Technical Preview con determinados roles de servidor, como un controlador de dominio o una puerta de enlace de Escritorio remoto. Si usas un servidor de Windows Server 2016 Technical Preview como un equipo cliente, obtendrá la misma protección de la que dispondría si ejecutase Windows 10 Enterprise.
Registradores de pulsaciones de teclas
Ataques físicos
No impide que un atacante con malware en el equipo use los privilegios asociados con cualquier credencial. Te recomendamos que uses equipos dedicados para las cuentas de gran valor, como los profesionales de TI y los usuarios con activos de gran valor de acceso en la organización.

Mitigaciones adicionales

Credential Guard puede proporcionar mitigaciones frente a los ataques de credenciales derivadas y evitar el uso de credenciales robadas en otro lugar. Sin embargo, los equipos pueden seguir siendo vulnerables a determinados ataques, incluso si las credenciales derivadas están protegidas con Credential Guard. Estos ataques pueden incluir el mal uso de privilegios y el uso de credenciales derivadas directamente desde un dispositivo en peligro, al reutilizar credenciales robadas anteriormente antes de instalar Device Guard, y el abuso de herramientas de administración y configuraciones de aplicaciones no seguras. Por este motivo, las mitigaciones adicionales también deben implementarse para hacer que el entorno de dominio sea más sólido.

Los ataques de robo de credenciales permiten al atacante robar secretos de un dispositivo y usarlos en otro dispositivo. Al implementar directivas de autenticación con autenticación compuesta en Windows Server 2012 R2 o dominios posteriores, los usuarios pueden verse restringidos a iniciar sesión solamente desde dispositivos específicos unidos a un dominio. Sin embargo, dado que los dispositivos también usan secretos compartidos para la autenticación, los atacantes también pueden robar esos secretos. Mediante la implementación de certificados de dispositivo con Credential Guard, las directivas de autenticación pueden requerir que el dispositivo se autentique con su clave privada. Esto impide que los secretos compartidos en dispositivos robados se usen con las contraseñas de usuario o claves secretas Kerberos robadas para iniciar sesión como usuario.

La autenticación de certificado de dispositivo tiene los siguientes requisitos:

Los dominios de dispositivo son Windows Server 2012 o superior y todos los controladores de dominio tienen certificados, que cumplen la estricta validación KDC [EKU de KDC presente y el nombre de dominio DNS coincide con el campo DNSName de la extensión SubjectAltName (SAN)].
Los dispositivos de Windows 10 cuentan con los certificados de controlador de dominio que emite la entidad de certificación en el almacén de la empresa.
Se establece un proceso para garantizar la identidad y la confiabilidad del dispositivo de una manera similar a la que establecerías la identidad y la confiabilidad de un usuario antes de emitirle una tarjeta inteligente.

Configuración de la directiva de grupo adicional

Hay algunas configuraciones de directiva de grupo que puedes habilitar que proporcionan más protección contra ataques de credenciales:

En los controladores de dominio, configura la compatibilidad KDC para notificaciones, autenticación compuesta y sistema de protección Kerberos mediante la directiva de grupo. Establece la configuración de la directiva de grupo Compatibilidad de KDC con notificaciones, autenticación compuesta y protección de Kerberos en Admitida o Siempre proporcionar notificaciones.
En los dispositivos que ejecutan Windows 10, también puedes activarla mediante la directiva de grupo. Para ello, habilita la configuración de directiva de grupo Compatibilidad del cliente de Kerberos con reclamaciones, autenticación compuesta y protección de Kerberos y Enviar siempre el primer sistema de autenticación compuesta en Configuración del equipo -> Plantillas administrativas -> Sistema -> Kerberos.

Autenticación compuesta

La autenticación compuesta agrega la identidad del dispositivo para el usuario durante la autenticación para los recursos y el dominio. Sin la autenticación compuesta, se validan solo los secretos del usuario. Con la autenticación compuesta, el cliente Kerberos debe tener secretos del usuario y del dispositivo.

Habilitar la autenticación compuesta también habilita la protección de Kerberos, que ofrece dos ventajas adicionales:

La autenticación de usuario en dispositivos unidos a un dominio se protegerá. Esto significa que las capturas de red contendrán la autenticación inicial Kerberos cifrada. Sin la clave de dispositivo apropiada, los requisitos como Kerberos están protegidos contra ataques de diccionario sin conexión.
Los errores de KDC están firmados, lo que proporciona protección contra ataques de suplantación de error.

Implementación de certificados de equipo

Si los controladores de dominio de la organización ejecutan Windows Server 2016 Technical Preview, los dispositivos que ejecutan Windows 10 automáticamente inscribirán un certificado de equipo cuando Credential Guard está habilitada y el equipo está unido al dominio.

Si los controladores de dominio ejecutan Windows Server 2012 R2, los certificados de equipo deben aprovisionarse manualmente en cada dispositivo. Para ello, puedes crear una plantilla de certificado de la entidad de certificado o del controlador de dominio e implementar los certificados de equipo para cada dispositivo.

Para los certificados de la máquina, deben aplicarse los mismos procedimientos de seguridad que se usan para emitir tarjetas inteligentes a los usuarios.

Desde la consola del Administrador de certificados, haz clic con el botón secundario en Plantillas de certificado y, a continuación, haz clic en Administrar.
Haz clic con el botón secundario en Autenticación de estación de trabajo y, a continuación, haz clic en Duplicar plantilla.
Haz clic en la nueva plantilla y, a continuación, haz clic en Propiedades.
En la pestaña Extensiones , haz clic en Directivas de aplicación y, a continuación, haz clic en Editar.
Haz clic en Autenticación de cliente y, a continuación, haz clic en Quitar.
Agrega el EKU ID-PKInit-KPClientAuth. Haz clic en Agregar, haz clic en Nuevo y, a continuación, especifica los siguientes valores:
- Nombre: Autenticación de cliente Kerberos
- Identificador de objeto: 1.3.6.1.5.2.3.4
En la pestaña Extensiones , haz clic en Directivas de emisión y, a continuación, haz clic en Editar.
En Directivas de emisión, haz clic en Seguridad alta.
En la pestaña Nombre del sujeto, desactiva la casilla Nombre DNS y, a continuación, selecciona la casilla Nombre principal de usuario (UPN).

En dispositivos que ejecutan Credential Guard, inscribe los dispositivos que usan el certificado de autenticación de equipo ejecutando el siguiente comando:

CertReq -EnrollCredGuardCert MachineAuthentication

Nota

Debes reiniciar el dispositivo después de realizar la inscripción del certificado de autenticación de equipo.

Vincular las directivas de emisión a un grupo

Mediante el uso de una directiva de autenticación, puedes asegurarte de que los usuarios solo inician sesión en dispositivos que ejecutan Credential Guard. No obstante, antes de implementar la directiva de autenticación, debes ejecutar primero un par de scripts que configuren el entorno.

get-IssuancePolicy.ps1 muestra todas las directivas de emisión que están disponibles en la entidad de certificación.

En el símbolo del sistema de Windows PowerShell, ejecuta el siguiente comando:
```
.\get-IssuancePolicy.ps1 –LinkedToGroup:All
```
set-IssuancePolicyToGroupLink.ps1 crea un grupo de seguridad universal, crea una unidad organizativa y vincula la directiva de emisión a ese grupo de seguridad universal.

En el símbolo del sistema de Windows PowerShell, ejecuta el siguiente comando:
```
.\set-IssuancePolicyToGroupLink.ps1 –IssuancePolicyName:”<name of issuance policy>” –groupOU:”<Name of OU to create>” –groupName:”<name of Universal security group to create>”
```

Implementar la directiva de autenticación

Antes de configurar la directiva de autenticación, debes iniciar cualquier intento fallido de aplicar una directiva de autenticación en KDC. Para hacer esto en el Visor de eventos, ve a Registros de aplicaciones y servicios\Microsoft\Windows\Autenticación, haz clic con el botón secundario en AuthenticationPolicyFailures-DomainController y, a continuación, haz clic en Habilitar registro.

Ahora puedes configurar una directiva de autenticación para usar Credential Guard.

Mt483740.wedge(es-es,VS.85).gif Agregar una directiva de autenticación para Credential Guard

Asegúrate de que los controladores de dominio están ejecutando al menos el nivel funcional de dominio de Windows Server 2012 R2.
Crea un grupo de seguridad que se usará para identificar los equipos que aplicarán esta directiva de autenticación.
Agrega la cuenta de equipo a este grupo de seguridad.
Abre el Centro de administración de Active Directory.
Haz clic en Autenticación, haz clic en Nueva y, a continuación, haz clic en Directiva de autenticación.
En el cuadro Nombre para mostrar, escribe un nombre para esta directiva de autenticación.
En el encabezado Cuentas, haz clic en Agregar.
En la casilla Seleccionar usuarios, equipos o cuentas de servicio, escribe el nombre de la cuenta de usuario y, a continuación, haz clic en Aceptar.
En el encabezado Usuario, haz clic en el botón Editar que se aplica a la cuenta de usuario.
Haz clic en Agregar una condición.
En el cuadro Editar las condiciones de control de acceso, asegúrate de que se lee Usuario > Grupo > Miembro de cada > Valor y, a continuación, haz clic en Agregar elementos.
En el cuadro de diálogo Seleccionar usuarios, equipos o cuentas de servicio, escribe el nombre del grupo de seguridad que creaste con el script set-IssuancePolicyToGroupLink y, a continuación, haz clic en Aceptar.
Haz clic en Aceptar para cerrar el cuadro Editar las condiciones de control de acceso.
Haz clic en Aceptar para crear la directiva de autenticación.
Cierra el Centro de administración de Active Directory.

Nota

Cuando se implementan directivas de autenticación en modo de cumplimiento con Credential Guard, los usuarios no podrán iniciar sesión con dispositivos que no tengan el certificado de autenticación de la máquina aprovisionada. Esto se aplica en escenarios de inicio de sesión local y remoto.

Apéndice: scripts

A continuación, presentamos una lista de los scripts que se mencionan en este tema.

Obtener las directivas de emisión disponibles en la entidad de certificación

Guarda este archivo de script como get-IssuancePolicy.ps1.

#######################################
##     Parameters to be defined      ##
##     by the user                   ##
#######################################

Param (
$Identity,
$LinkedToGroup
)

#######################################
##     Strings definitions           ##
#######################################
Data getIP_strings {
# culture=\"en-US\"
ConvertFrom-StringData -stringdata @'
help1 = This command can be used to retrieve all available Issuance Policies in a forest. The forest of the currently logged on user is targetted.
help2 = Usage:
help3 = The following parameter is mandatory:
help4 = -LinkedToGroup:<yes|no|all>
help5 = "yes" will return only Issuance Policies that are linked to groups. Checks that the linked Issuance Policies are linked to valid groups.
help6 = "no" will return only Issuance Policies that are not currently linked to any group. 
help7 = "all" will return all Issuance Policies defined in the forest. Checks that the linked Issuance policies are linked to valid groups.
help8 = The following parameter is optional:
help9 = -Identity:<Name, Distinguished Name or Display Name of the Issuance Policy that you want to retrieve>. If you specify an identity, the option specified in the "-LinkedToGroup" parameter is ignored.
help10 = Output: This script returns the Issuance Policy objects meeting the criteria defined by the above parameters.
help11 = Examples:
errorIPNotFound = Error: no Issuance Policy could be found with Identity "{0}"
ErrorNotSecurity = Error: Issuance Policy "{0}" is linked to group "{1}" which is not of type "Security".
ErrorNotUniversal = Error: Issuance Policy "{0}" is linked to group "{1}" whose scope is not "Universal".
ErrorHasMembers = Error: Issuance Policy "{0}" is linked to group "{1}" which has a non-empty membership. The group has the following members:
LinkedIPs = The following Issuance Policies are linked to groups:
displayName = displayName : {0}
Name = Name : {0}
dn = distinguishedName : {0}
        InfoName = Linked Group Name: {0} 
        InfoDN = Linked Group DN: {0}   
NonLinkedIPs = The following Issuance Policies are NOT linked to groups:
'@
}

##Import-LocalizedData getIP_strings


import-module ActiveDirectory


#######################################
##           Help                    ##
#######################################

function Display-Help {

    ""
    $getIP_strings.help1
    ""
$getIP_strings.help2
""
$getIP_strings.help3
"     " + $getIP_strings.help4
"             " + $getIP_strings.help5
    "             " + $getIP_strings.help6
    "             " + $getIP_strings.help7
""
$getIP_strings.help8
    "     " + $getIP_strings.help9
    ""
    $getIP_strings.help10
""
""    
$getIP_strings.help11
    "     " + '$' + "myIPs = .\get-IssuancePolicy.ps1 -LinkedToGroup:All"
    "     " + '$' + "myLinkedIPs = .\get-IssuancePolicy.ps1 -LinkedToGroup:yes"
    "     " + '$' + "myIP = .\get-IssuancePolicy.ps1 -Identity:""Medium Assurance"""
""
}


$root = get-adrootdse
$domain = get-addomain -current loggedonuser
$configNCDN = [String]$root.configurationNamingContext


if ( !($Identity) -and !($LinkedToGroup) ) {
display-Help
break
}

if ($Identity) {
    $OIDs = get-adobject -Filter {(objectclass -eq "msPKI-Enterprise-Oid") -and ((name -eq $Identity) -or (displayname -eq $Identity) -or (distinguishedName -like $Identity)) } -searchBase $configNCDN -properties *

    if ($OIDs -eq $null) {
$errormsg = $getIP_strings.ErrorIPNotFound -f $Identity
write-host $errormsg -ForegroundColor Red
    }
    
    foreach ($OID in $OIDs) {
    
        if ($OID."msDS-OIDToGroupLink") {
            # In case the Issuance Policy is linked to a group, it is good to check whether there is any problem with the mapping.
            $groupDN = $OID."msDS-OIDToGroupLink"
            $group = get-adgroup -Identity $groupDN
    $groupName = $group.Name
            
            # Analyze the group
            if ($group.groupCategory -ne "Security") {
$errormsg = $getIP_strings.ErrorNotSecurity -f $Identity, $groupName
                write-host $errormsg -ForegroundColor Red
            }
            if ($group.groupScope -ne "Universal") {
                $errormsg = $getIP_strings.ErrorNotUniversal -f $Identity, $groupName
write-host $errormsg -ForegroundColor Red
            }
            $members = Get-ADGroupMember -Identity $group
            if ($members) {
                $errormsg = $getIP_strings.ErrorHasMembers -f $Identity, $groupName
write-host $errormsg -ForegroundColor Red
                foreach ($member in $members) {
                    write-host "          "  $member -ForeGroundColor Red
                }
            }
        }
        
    }
    return $OIDs
    break
}

if (($LinkedToGroup -eq "yes") -or ($LinkedToGroup -eq "all")) {
    $LDAPFilter = "(&(objectClass=msPKI-Enterprise-Oid)(msDS-OIDToGroupLink=*)(flags=2))"
    $LinkedOIDs = get-adobject -searchBase $configNCDN -LDAPFilter $LDAPFilter -properties *

    write-host ""    
    write-host "*****************************************************"
    write-host $getIP_strings.LinkedIPs
    write-host "*****************************************************"
    write-host ""
    if ($LinkedOIDs -ne $null){
      foreach ($OID in $LinkedOIDs) {
  
          # Display basic information about the Issuance Policies
          ""
  $getIP_strings.displayName -f $OID.displayName
  $getIP_strings.Name -f $OID.Name
  $getIP_strings.dn -f $OID.distinguishedName
       
          
          # Get the linked group.
          $groupDN = $OID."msDS-OIDToGroupLink"
          $group = get-adgroup -Identity $groupDN
          $getIP_strings.InfoName -f $group.Name
          $getIP_strings.InfoDN -f $groupDN
          
          # Analyze the group
          $OIDName = $OID.displayName
    $groupName = $group.Name
          if ($group.groupCategory -ne "Security") {
          $errormsg = $getIP_strings.ErrorNotSecurity -f $OIDName, $groupName
          write-host $errormsg -ForegroundColor Red
          }
          if ($group.groupScope -ne "Universal") {
          $errormsg = $getIP_strings.ErrorNotUniversal -f $OIDName, $groupName
          write-host $errormsg -ForegroundColor Red
          }
          $members = Get-ADGroupMember -Identity $group
          if ($members) {
          $errormsg = $getIP_strings.ErrorHasMembers -f $OIDName, $groupName
          write-host $errormsg -ForegroundColor Red
              foreach ($member in $members) {
                  write-host "          "  $member -ForeGroundColor Red
              }
          }
          write-host ""
      }
    }else{
write-host "There are no issuance policies that are mapped to a group"
    }
    if ($LinkedToGroup -eq "yes") {
        return $LinkedOIDs
        break
    }
}    

if (($LinkedToGroup -eq "no") -or ($LinkedToGroup -eq "all")) {  
    $LDAPFilter = "(&(objectClass=msPKI-Enterprise-Oid)(!(msDS-OIDToGroupLink=*))(flags=2))"
    $NonLinkedOIDs = get-adobject -searchBase $configNCDN -LDAPFilter $LDAPFilter -properties *

    write-host ""    
    write-host "*********************************************************"
    write-host $getIP_strings.NonLinkedIPs
    write-host "*********************************************************"
    write-host ""
    if ($NonLinkedOIDs -ne $null) {
      foreach ($OID in $NonLinkedOIDs) {

# Display basic information about the Issuance Policies
write-host ""
$getIP_strings.displayName -f $OID.displayName
$getIP_strings.Name -f $OID.Name
$getIP_strings.dn -f $OID.distinguishedName
write-host ""
      }
    }else{
write-host "There are no issuance policies which are not mapped to groups"
    }
    if ($LinkedToGroup -eq "no") {
        return $NonLinkedOIDs
        break
    }
}

Nota

Si tienes problemas para ejecutar este script, prueba a reemplazar la comilla simple después del parámetro ConvertFrom-StringData.

Vincular una directiva de emisión a un grupo

Guarda el archivo de script como set-IssuancePolicyToGroupLink.ps1.

#######################################
##     Parameters to be defined      ##
##     by the user                   ##
#######################################

Param (
$IssuancePolicyName,
$groupOU,
$groupName
)

#######################################
##     Strings definitions           ##
#######################################

Data ErrorMsg {
# culture=\"en-US\"
ConvertFrom-StringData -stringdata @'
help1 = This command can be used to set the link between a certificate issuance policy and a universal security group.
help2 = Usage:
help3 = The following parameters are required:
help4 = -IssuancePolicyName:<name or display name of the issuance policy that you want to link to a group>
help5 = -groupName:<name of the group you want to link the issuance policy to>. If no name is specified, any existing link to a group is removed from the Issuance Policy.
help6 = The following parameter is optional:
help7 = -groupOU:<Name of the Organizational Unit dedicated to the groups which are linked to issuance policies>. If this parameter is not specified, the group is looked for or created in the Users container.
help8 = Examples:
help9 = This command will link the issuance policy whose display name is "High Assurance" to the group "HighAssuranceGroup" in the Organizational Unit "OU_FOR_IPol_linked_groups". If the group or the Organizational Unit do not exist, you will be prompted to create them.
help10 = This command will unlink the issuance policy whose name is "402.164959C40F4A5C12C6302E31D5476062" from any group.
MultipleIPs = Error: Multiple Issuance Policies with name or display name "{0}" were found in the subtree of "{1}"
NoIP = Error: no issuance policy with name or display name "{0}" could be found in the subtree of "{1}".
IPFound = An Issuance Policy with name or display name "{0}" was successfully found: {1}
MultipleOUs = Error: more than 1 Organizational Unit with name "{0}" could be found in the subtree of "{1}".
confirmOUcreation = Warning: The Organizational Unit that you specified does not exist. Do you want to create it?
OUCreationSuccess = Organizational Unit "{0}" successfully created.
OUcreationError = Error: Organizational Unit "{0}" could not be created.
OUFoundSuccess = Organizational Unit "{0}" was successfully found.
multipleGroups = Error: More than one group with name "{0}" was found in Organizational Unit "{1}".  
confirmGroupCreation = Warning: The group that you specified does not exist. Do you want to create it?
groupCreationSuccess = Univeral Security group "{0}" successfully created.
groupCreationError = Error: Univeral Security group "{0}" could not be created.
GroupFound = Group "{0}" was successfully found.
confirmLinkDeletion = Warning: The Issuance Policy "{0}" is currently linked to group "{1}". Do you really want to remove the link?
UnlinkSuccess = Certificate issuance policy successfully unlinked from any group.
UnlinkError = Removing the link failed.
UnlinkExit = Exiting without removing the link from the issuance policy to the group.
IPNotLinked = The Certificate issuance policy is not currently linked to any group. If you want to link it to a group, you should specify the -groupName option when starting this script.
ErrorNotSecurity = Error: You cannot link issuance Policy "{0}" to group "{1}" because this group is not of type "Security".
ErrorNotUniversal = Error: You cannot link issuance Policy "{0}" to group "{1}" because the scope of this group is not "Universal".
ErrorHasMembers = Error: You cannot link issuance Policy "{0}" to group "{1}" because it has a non-empty membership. The group has the following members:
ConfirmLinkReplacement = Warning: The Issuance Policy "{0}" is currently linked to group "{1}". Do you really want to update the link to point to group "{2}"?
LinkSuccess = The certificate issuance policy was successfully linked to the specified group.
LinkError = The certificate issuance policy could not be linked to the specified group.
ExitNoLinkReplacement = Exiting without setting the new link.
'@
}

# import-localizeddata ErrorMsg

function Display-Help {
""
write-host $ErrorMsg.help1
""
write-host $ErrorMsg.help2
""
write-host $ErrorMsg.help3
write-host "`t" $ErrorMsg.help4
write-host "`t" $ErrorMsg.help5
""
write-host $ErrorMsg.help6
write-host "`t" $ErrorMsg.help7
""
""
write-host $ErrorMsg.help8
""
write-host $ErrorMsg.help9
".\Set-IssuancePolicyToGroupMapping.ps1 -IssuancePolicyName ""High Assurance"" -groupOU ""OU_FOR_IPol_linked_groups"" -groupName ""HighAssuranceGroup"" "
""
write-host $ErrorMsg.help10
'.\Set-IssuancePolicyToGroupMapping.ps1 -IssuancePolicyName "402.164959C40F4A5C12C6302E31D5476062" -groupName $null '
""
}



# Assumption:  The group to which the Issuance Policy is going 
#              to be linked is (or is going to be created) in 
#              the domain the user running this script is a member of.
import-module ActiveDirectory
$root = get-adrootdse
$domain = get-addomain -current loggedonuser


if ( !($IssuancePolicyName) ) {
display-Help
break
}

#######################################
##     Find the OID object           ##
##     (aka Issuance Policy)         ##
#######################################

$searchBase = [String]$root.configurationnamingcontext
$OID = get-adobject -searchBase $searchBase -Filter { ((displayname -eq $IssuancePolicyName) -or (name -eq $IssuancePolicyName)) -and (objectClass -eq "msPKI-Enterprise-Oid")} -properties *

if ($OID -eq $null) {
$tmp = $ErrorMsg.NoIP -f $IssuancePolicyName, $searchBase  
write-host $tmp -ForeGroundColor Red
break;
}
elseif ($OID.GetType().IsArray) {
$tmp = $ErrorMsg.MultipleIPs -f $IssuancePolicyName, $searchBase  
write-host $tmp -ForeGroundColor Red
break;
}
else {
$tmp = $ErrorMsg.IPFound -f $IssuancePolicyName, $OID.distinguishedName
write-host $tmp -ForeGroundColor Green
}



#######################################
##  Find the container of the group  ##
#######################################

if ($groupOU -eq $null) {
# default to the Users container
$groupContainer = $domain.UsersContainer
} 
else {
$searchBase = [string]$domain.DistinguishedName
$groupContainer = get-adobject -searchBase $searchBase -Filter { (Name -eq $groupOU) -and (objectClass -eq "organizationalUnit")}
if ($groupContainer.count -gt 1) {
$tmp = $ErrorMsg.MultipleOUs -f $groupOU, $searchBase
write-host $tmp -ForegroundColor Red
break;
}
elseif ($groupContainer -eq $null) {
$tmp = $ErrorMsg.confirmOUcreation
write-host $tmp " ( (y)es / (n)o )" -ForegroundColor Yellow -nonewline
$userChoice = read-host
if ( ($userChoice -eq "y") -or ($userChoice -eq "yes") ) {
new-adobject -Name $groupOU -displayName $groupOU -Type "organizationalUnit" -ProtectedFromAccidentalDeletion $true -path $domain.distinguishedName
if ($?){
$tmp = $ErrorMsg.OUCreationSuccess -f $groupOU
write-host $tmp -ForegroundColor Green
}
else{
$tmp = $ErrorMsg.OUCreationError -f $groupOU
write-host $tmp -ForeGroundColor Red 
break;
}
$groupContainer = get-adobject -searchBase $searchBase -Filter { (Name -eq $groupOU) -and (objectClass -eq "organizationalUnit")}
}
else {
break;
}
}
else {
$tmp = $ErrorMsg.OUFoundSuccess -f $groupContainer.name
write-host $tmp -ForegroundColor Green
}
}

#######################################
##  Find the group               ##
#######################################

if (($groupName -ne $null) -and ($groupName -ne "")){
##$searchBase = [String]$groupContainer.DistinguishedName
$searchBase = $groupContainer
$group = get-adgroup -Filter { (Name -eq $groupName) -and (objectClass -eq "group") } -searchBase $searchBase
if ($group -ne $null -and $group.gettype().isarray) {
$tmp = $ErrorMsg.multipleGroups -f $groupName, $searchBase
write-host $tmp -ForeGroundColor Red
break;
}
elseif ($group -eq $null) {
$tmp = $ErrorMsg.confirmGroupCreation
write-host $tmp " ( (y)es / (n)o )" -ForegroundColor Yellow -nonewline
$userChoice = read-host
if ( ($userChoice -eq "y") -or ($userChoice -eq "yes") ) {
new-adgroup -samAccountName $groupName -path $groupContainer.distinguishedName -GroupScope "Universal" -GroupCategory "Security"
if ($?){
$tmp = $ErrorMsg.GroupCreationSuccess -f $groupName
write-host $tmp -ForegroundColor Green
}else{
$tmp = $ErrorMsg.groupCreationError -f $groupName
write-host $tmp -ForeGroundColor Red 
break
}
$group = get-adgroup -Filter { (Name -eq $groupName) -and (objectClass -eq "group") } -searchBase $searchBase
}
else {
break;
}
}
else {
$tmp = $ErrorMsg.GroupFound -f $group.Name
write-host $tmp -ForegroundColor Green
}
} 
else {
## If the group is not specified, we should remove the link if any exists
if ($OID."msDS-OIDToGroupLink" -ne $null) {
$tmp = $ErrorMsg.confirmLinkDeletion -f $IssuancePolicyName, $OID."msDS-OIDToGroupLink"
write-host $tmp " ( (y)es / (n)o )" -ForegroundColor Yellow -nonewline
$userChoice = read-host
if ( ($userChoice -eq "y") -or ($userChoice -eq "yes") ) {
set-adobject -Identity $OID -Clear "msDS-OIDToGroupLink"
if ($?) {
$tmp = $ErrorMsg.UnlinkSuccess
write-host $tmp -ForeGroundColor Green
}else{
$tmp = $ErrorMsg.UnlinkError
write-host $tmp -ForeGroundColor Red
}
} 
else { 
$tmp = $ErrorMsg.UnlinkExit
write-host $tmp
break 
}
}
else {
$tmp = $ErrorMsg.IPNotLinked
write-host $tmp -ForeGroundColor Yellow
}
break;
}


#######################################
##  Verify that the group is         ##
##  Universal, Security, and         ## 
##  has no members                   ##
#######################################

if ($group.GroupScope -ne "Universal") {
$tmp = $ErrorMsg.ErrorNotUniversal -f $IssuancePolicyName, $groupName
write-host $tmp -ForeGroundColor Red
break;
}
if ($group.GroupCategory -ne "Security") {
$tmp = $ErrorMsg.ErrorNotSecurity -f $IssuancePolicyName, $groupName
write-host $tmp -ForeGroundColor Red
break;
}
$members = Get-ADGroupMember -Identity $group
if ($members -ne $null) {
$tmp = $ErrorMsg.ErrorHasMembers -f $IssuancePolicyName, $groupName
write-host $tmp -ForeGroundColor Red
foreach ($member in $members) {write-host "   $member.name" -ForeGroundColor Red}
break;
}


#######################################
##  We have verified everything. We  ##
##  can create the link from the     ## 
##  Issuance Policy to the group.    ##
#######################################

if ($OID."msDS-OIDToGroupLink" -ne $null) {
$tmp = $ErrorMsg.ConfirmLinkReplacement -f $IssuancePolicyName, $OID."msDS-OIDToGroupLink", $group.distinguishedName
write-host $tmp  "( (y)es / (n)o )" -ForegroundColor Yellow -nonewline
$userChoice = read-host
if ( ($userChoice -eq "y") -or ($userChoice -eq "yes") ) {
$tmp = @{'msDS-OIDToGroupLink'= $group.DistinguishedName}
set-adobject -Identity $OID -Replace $tmp
if ($?) {
$tmp = $Errormsg.LinkSuccess
write-host $tmp -Foreground Green
}else{
$tmp = $ErrorMsg.LinkError
write-host $tmp -Foreground Red
}
} else { 
$tmp = $Errormsg.ExitNoLinkReplacement
write-host $tmp
break 
}
}
else {
$tmp = @{'msDS-OIDToGroupLink'= $group.DistinguishedName}
set-adobject -Identity $OID -Add $tmp
if ($?) {
$tmp = $Errormsg.LinkSuccess
write-host $tmp -Foreground Green
}else{
$tmp = $ErrorMsg.LinkError
write-host $tmp -Foreground Red
}
}

Nota

Si tienes problemas para ejecutar este script, prueba a reemplazar la comilla simple después del parámetro ConvertFrom StringData.