Proteger credenciais de domínio derivadas com o Credential Guard

Artigo
04/01/2016

Introduzida no Windows 10 Enterprise, o Credential Guard utiliza segurança baseada em virtualização para isolar segredos, para que somente o software do sistema com privilégios possa acessá-los. O acesso não autorizado a esses segredos pode levar a ataques de roubo de credenciais, como os ataques Pass-the-Hash ou Pass-The-Ticket.

O Credential Guard oferece os seguintes recursos e soluções:

Segurança de hardware O Credential Guard aumenta a segurança das credenciais de domínio derivadas aproveitando os recursos de segurança da plataforma, como a Inicialização Segura e a virtualização.
Segurança baseada em virtualização Os serviços Windows que gerenciam as credenciais de domínio derivadas e outros segredos são executados em um ambiente protegido que é isolado do sistema operacional em execução.
Melhor proteção contra ameaças avançadas persistentes Proteger as credenciais de domínio derivadas usando a segurança com base em virtualização bloqueia as técnicas de ataque de roubo de credenciais e as ferramentas usadas em muitos ataques direcionados. O malware com privilégios administrativos em execução no sistema operacional não pode extrair segredos protegidos pela segurança baseada em virtualização. Embora o Credential Guard seja uma mitigação eficiente, os ataques de ameaças persistentes provavelmente adotarão novas técnicas de ataque, e você também deverá incorporar o Device Guard e outras estratégias e arquiteturas de segurança.
Capacidade de gerenciamento Você pode gerenciar o Credential Guard usando a Política de Grupo, o WMI, um prompt de comando e o Windows PowerShell.

Como funciona

O Credential Guard isola segredos que as versões anteriores do Windows armazenaram na LSA (autoridade de segurança local) usando a segurança baseada em virtualização. Antes do Windows 10, a LSA armazenava segredos usados pelo sistema operacional em sua memória de processamento. Com o Credential Guard, o processo da LSA no sistema operacional se comunica com um novo componente chamado processo isolado da LSA que armazena e protege os segredos. Os dados armazenados no processo isolado da LSA são protegidos com a segurança baseada em virtualização e não são acessíveis ao restante do sistema operacional. A LSA usa chamadas de procedimento remoto para se comunicar com o processo isolado da LSA.

Por motivos de segurança, o processo isolado da LSA não hospeda nenhum driver de dispositivo. Em vez disso, ele só hospeda um pequeno subconjunto de binários do sistema operacional que são necessários à segurança e nada mais. Todos esses binários são assinados com um certificado de confiança da segurança baseada em virtualização, e essas assinaturas são validadas antes de iniciar o arquivo no ambiente protegido.

O Credential Guard também não permite variantes mais antigas de protocolos de autenticação Kerberos e NTLM e pacotes de codificação ao usar credenciais derivadas padrão, incluindo NTLMv1, MS-CHAPv2 e tipos de criptografia Kerberos mais fracos, como o DES.

Aqui está uma visão geral de como a LSA é isolada com a segurança baseada em virtualização:

Mt483740.credguard(pt-br,VS.85).png

Funcionalidades novas e alteradas

Para ver o que foi adicionado ou alterado no Credential Guard, consulte Quais são as novidades no Credential Guard?

Requisitos de hardware e software

O computador deve atender aos seguintes requisitos de hardware e software para usar o Credential Guard:

Requisito	Descrição
Windows 10 Enterprise	O computador deve estar executando o Windows 10 Enterprise.
Firmware UEFI versão 2.3.1 ou superior e Inicialização Segura	Para verificar se o firmware está usando UEFI versão 2.3.1 ou superior e Inicialização Segura, você pode validá-lo em relação ao requisito do Programa de Compatibilidade de Hardware do Windows System.Fundamentals.Firmware.CS.UEFISecureBoot.ConnectedStandby.
Extensões de virtualização	As seguintes extensões de virtualização são necessárias para dar suporte à segurança baseada em virtualização: Intel VT-x ou AMD-V Conversão de Endereços de Segundo Nível
Arquitetura x64	Os recursos usados pela segurança baseada em virtualização no hipervisor do Windows podem ser executados apenas em um computador de 64 bits.
Um VT-d ou AMD Vi IOMMU (Unidade de gerenciamento de memória de entrada/saída)	No Windows 10, uma IOMMU aprimora a resiliência do sistema contra ataques de memória. ¹
Trusted Platform Module (TPM) versão 1.2 ou 2.0	O TPM 1.2 e 2.0 fornece proteção para as chaves de criptografia que são armazenadas no firmware. O TPM 1.2 não tem suporte no Windows 10 (compilação 10240); no entanto, ele tem suporte no Windows 10, versão 1511 (compilação 10586) e versões posteriores. Observação Se você não tiver um TPM instalado, o Credential Guard ainda será habilitado, mas as chaves usadas para criptografá-lo não serão protegidas pelo TPM.
Processo de atualização de firmware seguro	Para verificar se o firmware está em conformidade com o processo de atualização de firmware seguro, você pode validá-lo em relação ao requisito do Programa de Compatibilidade de Hardware do Windows System.Fundamentals.Firmware.UEFISecureBoot.
O firmware é atualizado para Implementação de MOR seguro	O Credential Guard requer o bit MOR seguro para ajudar a impedir certos ataques à memória.
Computador físico	Para computadores com o Windows 10, não é possível executar o Credential Guard em uma máquina virtual.

¹ Se você escolher a opção Inicialização Segura e a proteção de DMA na configuração da Política de Grupo, uma IOMMU será necessária. A opção de Política de Grupo Inicialização Segura habilita o Credential Guard em dispositivos sem uma IOMMU.

Gerenciar o Credential Guard

O Credential Guard usa recursos de segurança baseados em virtualização que devem ser habilitados em cada computador para que você possa usá-lo.

Ative o Credential Guard usando a Política de Grupo

É possível usar a Política de Grupo para habilitar o Credential Guard, já que ela adicionará os recursos de segurança baseados em virtualização para você.

No Console de Gerenciamento de Política de Grupo, vá para Configuração do Computador -> Modelos Administrativos -> Sistema -> Device Guard.
Clique duas vezes em Ativar Segurança Baseada em Virtualização e clique na opção Habilitado.
Na caixa Selecione o Nível de Segurança da Plataforma, escolha Inicialização Segura ou Inicialização Segura e Proteção de DMA.
Na caixa Credential Guard Configuration, clique em Enabled with UEFI lock e clique em OK. Se você quiser ter a possibilidade de desativar o Credential Guard remotamente, escolha Enabled without lock.
Feche o Console de Gerenciamento de Política de Grupo.

Adicionar o Credential Guard a uma imagem

Se deseja adicionar o Credential Guard a uma imagem, você pode fazer isso adicionando recursos de segurança baseada em virtualização e ativando o Credential Guard.

Adicionar os recursos de segurança baseados em virtualização

Primeiramente, você deve adicionar os recursos de segurança baseada em virtualização. Você pode fazer isso usando o Painel de Controle ou a ferramenta DISM (Gerenciamento e Manutenção de Imagens de Implantação)

Observação Se você habilitar o Credential Guard usando a Política de Grupo, essas etapas não são necessárias. A Política de Grupo instalará os recursos para você.

Mt483740.wedge(pt-br,VS.85).gif Adicionar os recursos de segurança baseada em virtualização usando Programas e Recursos

Abra Programas e Recursos no Painel de Controle.
Clique em Ativar ou desativar recursos do Windows.
Marque a caixa de seleção Modo de Usuário Isolado.
Vá para Hyper-V -> Plataforma Hyper-V e marque a caixa de seleção Hipervisor do Hyper-V.
Clique em OK.

Mt483740.wedge(pt-br,VS.85).gif Adicionar os recursos de segurança baseada em virtualização a uma imagem offline usando o DISM

Abra um prompt de comando com privilégios elevados.

Adicione o Hipervisor do Hyper-V executando o seguinte comando:

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

Adicione o Modo de Usuário Isolado executando o seguinte comando:

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

Observação

Você também pode adicionar esses recursos a uma imagem online usando o DISM ou o Configuration Manager.

Ativar o Credential Guard

Se você não usa a Política de Grupo, poderá habilitar o Credential Guard usando o Registro.

Mt483740.wedge(pt-br,VS.85).gif Ativar o Credential Guard usando o Registro

Abra o Editor do Registro.
Habilite a segurança baseada em virtualização:
- Vá para HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\DeviceGuard.
- Adicione um novo valor DWORD denominado EnableVirtualizationBasedSecurity. Defina o valor de configuração do Registro como 1 para habilitar a segurança baseada em virtualização e defina-o como 0 para desabilitá-la.
- Adicione um novo valor DWORD denominado RequirePlatformSecurityFeatures. Defina o valor da configuração do Registro como 1 para usar a Inicialização Segura somente ou defina-o como 2 para usar a Inicialização Segura e a proteção de DMA.
Habilite o Credential Guard:
- Vá para HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\LSA.
- Adicione um novo valor DWORD denominado LsaCfgFlags. Configure o valor dessa configuração do Registro como 1 para habilitar o Credential Guard com o bloqueio UEFI, como 2 para habilitar o Credential Guard sem bloqueio e como 0 para desabilitá-lo.
Feche o Editor do Registro.

Observação

Você também pode ativar o Credential Guard definindo as entradas do Registro na configuração autônoma FirstLogonCommands.

Remover o Credential Guard

Se você precisar remover o Credential Guard em um computador, deverá fazer o seguinte:

Se você usou a Política de Grupo, desabilite a configuração você usou para habilitar o Credential Guard (Configuração do Computador -> Modelos Administrativos -> Sistema -> Device Guard -> Ativar Segurança Baseada em Virtualização).
Exclua a seguinte configuração do Registro: HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\DeviceGuard\LsaCfgFlags
Exclua as variáveis EFI do Credential Guard usando bcdedit.

Mt483740.wedge(pt-br,VS.85).gif Excluir as variáveis de EFI do Credential Guard

Em um prompt de comando elevado, digite os seguintes 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

Reinicie o computador.
Aceite o prompt para desabilitar o Credential Guard
Como alternativa, você pode desabilitar os recursos de segurança baseada em virtualização para desativar o Credential Guard.

Observação

O computador deve ter um acesso único a um controlador de domínio para descriptografar o conteúdo, como arquivos que estavam criptografados com o EFS.

Se você deseja desativar o Credential Guard e a segurança baseada em virtualização, execute o seguinte comando bcdedit após desativar todas as configurações do Registro e da Política de Grupo de segurança baseada em virtualização:

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

Para saber mais sobre a segurança baseada em virtualização e o Device Guard, consulte Guia de implantação do Device Guard.

Verificar se o Credential Guard está em execução

Você pode usar Informações do Sistema para verificar se o Credential Guard está em execução em um computador.

Clique em Iniciar, digite msinfo32.exe e clique em Informações do Sistema.
Clique em Resumo do Sistema.
Confirme se o Credential Guard é mostrado ao lado de Serviços de Segurança do Device Guard em Execução.

Aqui está um exemplo:

Considerações ao usar o Credential Guard

Se o Credential Guard for habilitado em um dispositivo depois que ele ingressar em um domínio, os segredos do usuário e do dispositivo já poderão estar comprometidos. Recomendamos que a Proteção de Credenciais seja habilitada antes de o computador ingressar em um domínio.
Você deve executar análises regulares dos computadores que têm o Credential Guard habilitado. Isso pode ser feito com políticas de auditoria de segurança ou consultas WMI. Aqui está uma lista de IDs de eventos WinInit a serem procuradas:
- ID de evento 13 O Credential Guard (LsaIso.exe) foi iniciado e protegerá as credenciais da LSA.
- ID de evento 14 Configuração do Credential Guard (LsaIso.exe): 0x1, 0
  - A primeira variável: 0x1 significa que o Credential Guard está configurado para execução. 0x0 indica que ele não está configurado para execução.
  - A segunda variável: 0 significa que ele está configurado para execução no modo de proteção. 1 significa que ele está configurado para execução no modo de teste. Essa variável deve ser sempre 0.
- ID de evento 15 O Credential Guard (LsaIso.exe) está configurado, mas o kernel seguro não está em execução; continuando sem o Credential Guard.
- ID de evento 16 O Credential Guard (LsaIso.exe) falhou ao iniciar: [código de erro]
- ID de evento 17 Erro ao ler a configuração UEFI do Credential Guard (LsaIso.exe): [código de erro]
Você também pode verificar se o TPM está sendo usado para proteção de chave, verificando o seguinte evento na origem do evento Microsoft -> Windows -> Inicialização do Kernel. Se você estiver executando com um TPM, o valor de máscara TPM PCR será algo diferente de 0.
- Provisionamento de Chave de Criptografia Mestra VSM ID de Evento 51. Status de uso da cópia em cache: 0x0. Status da desselagem da cópia em cache: 0x1. Status da nova geração de chave: 0x1. Status de selagem: 0x1. Máscara de TPM PCR: 0x0.
As senhas ainda são fracas, portanto, recomendamos que sua organização implante o Credential Guard e troque as senhas por outros métodos de autenticação, como cartões inteligentes físicos, cartões inteligentes virtuais, Microsoft Passport ou Microsoft Passport for Work.
Alguns provedores de suporte de segurança (SSPs e PAs) terceirizados podem não ser compatíveis com o Credential Guard. O Credential Guard não permite que SSPs terceirizados solicitem hashes de senha da LSA. No entanto, SSPs e PAs ainda são notificados sobre a senha quando um usuário faz logon e/ou altera sua senha. Qualquer uso de APIs não documentadas dentro de SSPs e PAs personalizados não é permitido. Recomendamos que implementações personalizadas de SSPs/PAs sejam testadas com o Credential Guard para garantir que os SSPs e PAs não dependam de nenhum comportamento não documentado ou sem suporte. Por exemplo, o uso da API KerbQuerySupplementalCredentialsMessage não é permitido. Você não deve substituir os SSPs NTLM ou Kerberos por SSPs e PAs personalizados. Para saber mais, veja Restrições relacionadas ao registro e à instalação de um pacote de segurança no MSDN.
À medida que a profundidade e a abrangência de proteções fornecidas pelo Credential Guard aumentam, as versões posteriores do Windows 10 com o Credential Guard podem ter impacto em cenários que funcionavam no passado. Por exemplo, o Credential Guard pode bloquear o uso de um determinado tipo de credencial ou componente para impedir que malwares tirem proveito das vulnerabilidades. Portanto, recomendamos que os cenários necessários para as operações em uma organização sejam testados antes da atualização de um dispositivo que tenha o Credential Guard em execução.
Se você estiver usando pontos de extremidade de Wi-Fi e VPN baseados em MS-CHAPv2, eles estarão sujeitos a ataques semelhantes, como NTLMv1. Recomendamos que as organizações usem a autenticação baseada em certificado para conexões Wi-Fi e VPN.
A partir do Windows 10, versão 1511, as credenciais de domínio que são armazenadas com o Gerenciador de Credenciais são protegidas com o Credential Guard. O Gerenciador de Credenciais permite que você armazene credenciais, como nomes de usuário e senhas que você usa para fazer logon em sites ou em outros computadores em uma rede. As considerações a seguir se aplicam às proteções do Credential Guard para o Gerenciador de Credenciais:
- As credenciais salvas pelos Serviços de Área de Trabalho Remota não podem ser usadas para se conectar remotamente a outro computador sem fornecer a senha.
- Os aplicativos que extraem as credenciais de domínio derivadas do Gerenciador de Credenciais não poderão mais usar essas credenciais.
- Você não poderá restaurar credenciais usando o painel de controle do Gerenciador de Credenciais se as credenciais tiverem sido armazenadas em backup em um computador com o Credential Guard ativado. Se você precisar fazer backup de suas credenciais, deverá fazer isso antes de habilitar o Credential Guard. Caso contrário, você não conseguirá restaurar essas credenciais.

Cenários não protegidos pelo Credential Guard

Algumas formas de armazenar credenciais não são protegidas pelo Credential Guard, incluindo:

O software que gerencia credenciais fora da proteção de recursos do Windows
Contas locais e contas da Microsoft
Um servidor do Windows Server Technical Preview 2016 executando determinadas funções de servidor, como um controlador de domínio ou o Gateway de Área de Trabalho Remota. Se você estiver usando um servidor do Windows Server 2016 Technical Preview como um computador cliente, ele receberá a mesma proteção que receberia executando o Windows 10 Enterprise.
Keyloggers
Ataques físicos
Não impedir que um invasor com malware no computador use os privilégios associados a qualquer credencial. Recomendamos usar computadores dedicados para contas de alto valor, como profissionais de TI e usuários com ativos de alto valor de acesso em sua organização.

Mitigações adicionais

O Credential Guard pode oferecer mitigações contra ataques em credenciais derivadas e evitar o uso de credenciais roubadas em outros lugares. No entanto, os computadores ainda podem estar vulneráveis a determinados ataques, mesmo que as credenciais derivadas estejam protegidas pelo Credential Guard. Esses ataques podem incluir o abuso de privilégios e o uso de credenciais derivadas diretamente de um dispositivo comprometido, reutilizando credenciais roubadas anteriormente, antes do Device Guard, e o abuso de ferramentas de gerenciamento e fracas configurações do aplicativo. Por causa disso, mitigações adicionais também precisam ser implantadas para tornar o ambiente de domínio mais robusto.

Os ataques de roubo de credenciais permitem que um invasor roube segredos de um dispositivo e use-os em outro dispositivo. Implantando políticas de autenticação com autenticação composta no Windows Server 2012 R2 ou em domínios mais recentes, os usuários podem ser restritos a entrar somente em dispositivos específicos integrados ao domínio. Entretanto, como os dispositivos também usam segredos compartilhados para autenticação, os invasores também podem roubar esses segredos. Implantando certificados de dispositivos com o Credential Guard, as políticas de autenticação podem exigir que o dispositivo seja autenticado com sua chave privada. Isso impede que os segredos compartilhados em dispositivos roubados sejam usados com senhas de usuário roubadas ou chaves secretas Kerberos para entrar como o usuário.

A autenticação de certificado de dispositivo tem os seguintes requisitos:

Os domínios de dispositivos são Windows Server 2012 ou acima, e todos os controladores de domínio possuem certificados, os quais satisfazem a rigorosa validação KDC (EKU KDC presente e o nome de domínio DNS corresponde ao campo DNSName da extensão SAN (SubjectAltName)).
Os dispositivos Windows 10 têm os certificados de controlador de domínio no repositório da empresa emitidos pela AC.
Um processo é estabelecido para garantir a identidade e a confiabilidade do dispositivo de uma forma semelhante, como você estabeleceria a identidade e a confiabilidade de um usuário antes de emitir um cartão inteligente para ele.

Configurações adicionais de Política de Grupo

Há algumas configurações de Política de Grupo que você pode habilitar que oferecem mais proteção contra ataques de credenciais:

Nos controladores de domínio, configure o suporte KDC para declarações, autenticação composta e sistema de proteção Kerberos usando a Política de Grupo. Defina a configuração de Política de Grupo Suporte do KDC a declarações, autenticação composta e proteção Kerberos como Com suporte ou Sempre fornecer declarações.
Em dispositivos que executam o Windows 10, você pode ativá-lo usando também a Política de Grupo. Para fazer isso, habilite as configurações de Política de Grupo Suporte do cliente Kerberos a declarações, autenticação composta e proteção Kerberos e Sempre enviar autenticação composta primeiro em Configuração do Computador -> Modelos Administrativos -> Sistema -> Kerberos.

Autenticação composta

A autenticação composta adiciona a identidade do dispositivo à do usuário durante a autenticação para o domínio e os recursos. Sem a autenticação composta, somente os segredos do usuário são validados. Com a autenticação composta, o cliente Kerberos deve ter segredos do usuário e do dispositivo.

A habilitação da autenticação composta também habilita a proteção Kerberos, que oferece dois benefícios adicionais:

A autenticação do usuário em dispositivos integrados ao domínio será protegida. Isso significa que as capturas de rede conterão a autenticação inicial Kerberos criptografada. Sem a chave de dispositivo apropriada, os AS-REQs Kerberos são protegidos contra ataques de dicionário offline.
Os erros KDC são assinados, o que oferece proteção contra ataques de falsificação de erro.

Implantando certificados de computadores

Se os controladores de domínio de sua organização estiverem executando o Windows Server 2016 Technical Preview, os dispositivos que executam o Windows 10 automaticamente inscreverão um certificado de máquina quando o Credential Guard for habilitado e o computador ingressar no domínio.

Se os controladores de domínio estiverem executando o Windows Server 2012 R2, os certificados de computador deverão ser provisionados manualmente em cada dispositivo. Você pode fazer isso criando um modelo de certificado no controlador de domínio ou na autoridade do certificado ou implantando os certificados de computador em cada dispositivo.

Os mesmos procedimentos de segurança usados para a emissão de cartões inteligentes para usuários devem ser aplicados a certificados do computador.

No console do Gerenciador de Certificados, clique com o botão direito em Modelos de Certificados e clique em Gerenciar.
Clique com botão direito em Autenticação de Estação de Trabalho e clique em Modelo Duplicado.
Clique com o botão direito no novo modelo e, em seguida, clique em Propriedades.
Na guia Extensões, clique em Políticas de Aplicativo e, em seguida, clique em Editar.
Clique em Autenticação de Cliente e clique em Remover.
Adicione o EKU ID-PKInit-KPClientAuth. Clique em Adicionar, clique em Novo e especifique os seguintes valores:
- Nome: Autenticação de cliente Kerberos
- Identificador de objeto: 1.3.6.1.5.2.3.4
Na guia Extensões, clique em Políticas de Emissão e, em seguida, clique em Editar.
Em Políticas de Emissão, clique em Alta Garantia.
Na guia Nome do Requerente, desmarque a caixa de seleção Nome DNS e marque a caixa de seleção Nome UPN.

Em dispositivos que executam o Credential Guard, registre os dispositivos usando o certificado de autenticação do computador e executando o seguinte comando:

CertReq -EnrollCredGuardCert MachineAuthentication

Observação

Você deve reiniciar o dispositivo depois de registrar o certificado de autenticação do computador.

Vincular as políticas de emissão a um grupo

Usando uma política de autenticação, você pode garantir que os usuários só entrem em dispositivos que executem o Credential Guard. No entanto, antes de implantar a política de autenticação, você deve primeiro executar alguns dos scripts que configuram seu ambiente.

O get-IssuancePolicy.ps1 mostra todas as políticas de emissão que estão disponíveis na autoridade de certificação.

Em um prompt de comando do Windows PowerShell, execute o seguinte comando:
```
.\get-IssuancePolicy.ps1 –LinkedToGroup:All
```
O set-IssuancePolicyToGroupLink.ps1 cria um grupo de segurança Universal, cria uma unidade organizacional e vincula a política de emissão a esse grupo de segurança Universal.

Em um prompt de comando do Windows PowerShell, execute o seguinte comando:
```
.\set-IssuancePolicyToGroupLink.ps1 –IssuancePolicyName:”<name of issuance policy>” –groupOU:”<Name of OU to create>” –groupName:”<name of Universal security group to create>”
```

Implantar a política de autenticação

Antes de configurar a política de autenticação, você deve registrar em log qualquer falha na tentativa de aplicar uma política de autenticação no KDC. Para fazer isso no Visualizador de Eventos, navegue até Logs de Aplicativos e Serviços\Microsoft\Windows\Authentication, clique com botão direito em AuthenticationPolicyFailures-DomainController e clique em Habilitar Log.

Agora você pode configurar uma política de autenticação para usar o Credential Guard.

Mt483740.wedge(pt-br,VS.85).gif Para adicionar uma política de autenticação para o Credential Guard

Certifique-se de que os controladores de domínio estejam executando pelo menos o nível funcional de domínio do Windows Server 2012 R2.
Crie um grupo de segurança que será usado para identificar os computadores que terão essa política de autenticação aplicada a eles.
Adicione a conta do computador a esse grupo de segurança.
Abra o Centro Administrativo do Active Directory.
Clique em Autenticação, Nova e Política de Autenticação.
Na caixa Nome de exibição, insira um nome para a política de autenticação.
Sob o título Contas, clique em Adicionar.
Na caixa de diálogo Selecionar Usuários, Computadores ou Contas de Serviço, digite o nome da conta de usuário e clique em OK.
Sob o título Usuário, clique no botão Editar que se aplica à conta de usuário.
Clique em Adicionar uma condição.
Na caixa Editar Condições de Controle de Acesso, verifique se ela mostra Usuário > Grupo > Membro de cada > Valor e clique em Adicionar itens.
Na caixa de diálogo Selecionar Usuários, Computadores ou Contas de Serviço, digite o nome do grupo de segurança que você criou com o script set-IssuancePolicyToGroupLink e clique em OK.
Clique em OK para fechar a caixa Editar Condições de Controle de Acesso.
Clique em OK para criar a política de autenticação.
Feche o Centro Administrativo do Active Directory.

Observação

Quando as políticas de autenticação no modo de imposição são implantadas com o Credential Guard, os usuários não conseguem entrar usando dispositivos que não tenham o certificado de autenticação do computador provisionado. Isso se aplica aos cenários de entrada local e remota.

Apêndice: scripts

Veja a seguir uma lista dos scripts que são mencionados neste tópico.

Obter as políticas de emissão disponíveis na autoridade de certificação

Salve este arquivo 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
    }
}

Observação

Se você estiver com dificuldade para executar esse script, tente substituir a aspa simples após o parâmetro ConvertFrom-StringData.

Vincular uma política de emissão a um grupo

Salve o arquivo 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
}
}

Observação

Se você estiver com dificuldade para executar esse script, tente substituir a aspa simples após o parâmetro ConvertFrom-StringData.