Mitigações adicionais
A Credential Guard oferece mitigações contra ataques a credenciais derivadas, impedindo o uso de credenciais roubadas em outros lugares. No entanto, os dispositivos ainda podem ser vulneráveis a determinados ataques, mesmo que as credenciais derivadas sejam protegidas pelo Credential Guard. Esses ataques podem incluir o abuso de privilégios e o uso de credenciais derivadas diretamente de um dispositivo comprometido, o reutilização de credenciais roubadas antes da habilitação do Credential Guard e o abuso de ferramentas de gerenciamento e configurações fracas de aplicativo. Devido a isso, a mitigação adicional também deve ser implantada para tornar o ambiente de domínio mais robusto.
Qualificações de segurança adicionais
Todos os dispositivos que atendem a proteções de linha de base para hardware, firmware e software podem usar o Credential Guard.
Dispositivos que atendem a mais qualificações podem fornecer proteções adicionais para reduzir ainda mais a superfície de ataque.
As qualificações da lista de tabelas a seguir para melhorar a segurança. Recomendamos atender às qualificações adicionais para fortalecer o nível de segurança que o Credential Guard pode fornecer.
| Proteção | Requisitos | Benefícios à segurança: |
|---|---|---|
| Configuração e gerenciamento de Inicialização Segura | - A senha do BIOS ou a autenticação mais forte devem ter suporte - Na configuração do BIOS, a autenticação bios deve ser definida - Deve haver suporte para a opção BIOS protegida para configurar a lista de dispositivos de inicialização permitidos (por exemplo, Inicializar somente do disco rígido interno) e a ordem do dispositivo de inicialização, substituindo BOOTORDER a modificação feita pelo sistema operacional |
– Impedir que outros sistemas operacionais sejam iniciados -Impedir alterações nas configurações do BIOS |
| Inicialização segura da plataforma de confiança com raízes de hardware | – A Integridade da Inicialização (Inicialização Segura da Plataforma) deve ter suporte. Consulte os requisitos do Programa de Compatibilidade de Hardware do Windows em System.Fundamentals.Firmware.CS.UEFISecureBoot.ConnectedStandby – HSTI (Hardware Security Test Interface) deve ser implementado. Consulte Especificação de testabilidade de segurança de hardware |
- A integridade da inicialização (inicialização segura da plataforma) desde o início oferece proteções contra invasores fisicamente presentes e defesa mais completa contra malware. - O HSTI fornece garantia de segurança para o silício e a plataforma protegidos corretamente |
| Atualização de firmware por meio de Windows Update | – O firmware deve dar suporte a atualizações de campo por meio de Windows Update e atualização de encapsulamento UEFI | Ajuda a garantir que as atualizações de firmware sejam rápidas, seguras e confiáveis. |
| Proteger configuração e gerenciamento de inicialização | – Funcionalidades necessárias do BIOS: capacidade do OEM de adicionar ISV, OEM ou Certificado Enterprise em DB de Inicialização Segura no tempo de fabricação – Configurações necessárias: a AC uefi da Microsoft deve ser removida do DB de Inicialização Segura. O suporte para módulos UEFI de terceiros é permitido, mas deve usar certificados fornecidos pelo ISV ou certificado OEM para o software UEFI específico |
- As empresas podem optar por permitir que drivers/aplicativos EFI proprietários sejam executados - a remoção da AC UEFI da Microsoft do Secure Boot DB fornece controle total às empresas sobre o software executado antes das botas do sistema operacional |
| Habilitação de VBS da proteção de No-Execute (NX) para serviços de runtime UEFI | - O VBS habilita a proteção NX nas regiões de código de serviço de runtime da UEFI e nas regiões de memória de dados. O código de serviço de tempo de execução UEFI deve dar suporte a proteções de página somente leitura, e os dados do serviço de tempo de execução UEFI não devem ser executáveis. O serviço de runtime UEFI deve atender aos seguintes requisitos: – Implementar UEFI 2.6 EFI_MEMORY_ATTRIBUTES_TABLE. Toda a memória do serviço de runtime UEFI (código e dados) deve ser descrita por esta tabela – as seções DEP devem estar alinhadas à página na memória (não necessária para em armazenamento não volátil). - A Tabela de Atributos de Memória precisa marcar corretamente o código e os dados quanto RO/NX à configuração pelo sistema operacional – Todas as entradas devem incluir atributos EFI_MEMORY_RO, EFI_MEMORY_XPou ambos. - Nenhuma entrada pode ficar com nenhum dos atributos acima, indicando memória executável e gravável. A memória deve ser legível e executável ou gravável e não executável (CONSULTE INFORMAÇÕES IMPORTANTES APÓS ESTA TABELA) |
– Vulnerabilidades no runtime UEFI, se houver, são impedidas de comprometer o VBS (como em funções como UpdateCapsule e SetVariable) – Reduz a superfície de ataque para o VBS do firmware do sistema. |
| Suporte de firmware para proteção SMM | - A especificação WSMT (Tabela de Mitigações de Segurança) do Windows SMM contém detalhes de uma tabela ACPI criada para uso com sistemas operacionais Windows que dão suporte a recursos baseados em virtualização do Windows. | - Protege contra possíveis vulnerabilidades nos serviços de runtime da UEFI, se houver, será impedido de comprometer o VBS (como em funções como UpdateCapsule e SetVariable) - Reduz a superfície de ataque ao VBS do firmware do sistema - Bloqueia ataques de segurança adicionais contra o SMM |
Importante
Em relação à habilitação de VBS da proteção NX para serviços de runtime da UEFI:
- Ele só se aplica à memória do serviço de runtime UEFI e não à memória do serviço de inicialização UEFI
- A proteção é aplicada pelo VBS nas tabelas de páginas do sistema operacional
- Não use seções que sejam graváveis e executáveis
- Não tente modificar diretamente a memória do sistema executável
- Não use código dinâmico
Restringir usuários de domínio a dispositivos específicos ingressados no domínio
Os ataques de roubo de credenciais permitem que um invasor roube segredos de um dispositivo e use-os em outro dispositivo. Se um usuário conseguir fazer logon em vários dispositivos, qualquer dispositivo poderá ser usado para roubar credenciais. Como você garante que os usuários só entrem com dispositivos habilitados para o Credential Guard? Ao implantar políticas de autenticação que as restringem a dispositivos específicos ingressados no domínio que foram configurados com o Credential Guard. Para o controlador de domínio saber de qual dispositivo o usuário está fazendo logon, é necessário usar a proteção Kerberos.
Proteção Kerberos
A proteção Kerberos faz parte do RFC 6113. Quando um dispositivo dá suporte à proteção Kerberos, seu TGT é usado para proteger a prova de posse do usuário que pode atenuar ataques de dicionário offline. A proteção Kerberos também oferece a vantagem adicional de erros KDC assinados que reduz a falsificação que pode resultar em coisas como ataques de downgrade.
Para habilitar o blindamento kerberos para restringir usuários de domínio a dispositivos específicos ingressados no domínio:
- Os usuários precisam estar em domínios que estejam executando o Windows Server 2012 R2 ou superior
- Todos os controladores de domínio nesses domínios devem ser configurados para dar suporte à proteção Kerberos. 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.
- Todos os dispositivos com Credential Guard aos quais os usuários serão restritos devem ser configurados para dar suporte ao blindamento Kerberos. Habilite o suporte ao cliente Kerberos para declarações, autenticação composta e configurações de Política de Grupo de blindagem Kerberos em Configuração de Computador ->Modelos Administrativos ->Sistema ->Kerberos.
Proteger segredos de dispositivo ingressados no domínio
Como os dispositivos que ingressaram no domínio também usam segredos compartilhados para autenticação, os invasores também podem roubar esses segredos. Quando certificados de dispositivo são implantados com o Credential Guard, é possível proteger a chave privada. Em seguida, as políticas de autenticação podem exigir que os usuários entrem em dispositivos que se autenticam usando esses certificados. Isso impede que os segredos compartilhados em dispositivos roubados sejam usados com credenciais roubadas para fazer logon como o usuário.
A autenticação de certificado de dispositivos que ingressaram no domínio tem os seguintes requisitos:
- As contas dos dispositivos devem estar no nível funcional de domínio do Windows Server 2012 ou superior.
- Todos os controladores de domínio nesses domínios têm certificados KDC que atendem aos requisitos rígidos de certificado de validação KDC:
- EKU KDC presente
- O nome de domínio DNS deve corresponder ao campo DNSName da extensão SAN (SubjectAltName)
- Os dispositivos Windows têm a AC emitindo os certificados do controlador de domínio no repositório empresarial.
- Um processo deve ser 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.
Implantar certificados de dispositivo ingressados no domínio
Para garantir que os certificados com a política de emissão necessária estejam instalados apenas nos dispositivos que esses usuários devem usar, eles deverão ser implantados manualmente 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 dispositivo.
Por exemplo, digamos que você queira usar a política Alta Garantia apenas nesses dispositivos. Usando uma autoridade de certificação do Windows Server Enterprise, você criaria um novo modelo.
Criar um novo modelo de certificado
- No console do Gerenciador de Certificados, clique com o botão direito do mouse em Gerenciar Modelos > de Certificado
- Clique com o botão direito do mouse em Modelo duplicado de autenticação > de estação de trabalho
- Clique com o botão direito do mouse no novo modelo e selecione Propriedades
- Na guia Extensões , selecione Políticas de > Aplicativo Editar
- Selecione Autenticação do Cliente e selecione Remover
- Adicione o EKU ID-PKInit-KPClientAuth. Selecione Adicionar > 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 , selecione Editar Políticas > de Emissão
- Em Políticas de Emissão, selecione Alta Garantia
- Na guia Nome do assunto, desmarque o nome DNS marcar caixa e selecione a caixa UPN (Nome da Entidade de Usuário) marcar caixa
Em seguida, nos dispositivos que executam o Credential Guard, registre os dispositivos usando o certificado que você acabou de criar.
Registrar dispositivos em um certificado
Execute o seguinte comando:
CertReq -EnrollCredGuardCert MachineAuthentication
Observação
Você deve reiniciar o dispositivo depois de registrar o certificado de autenticação do computador.
Como uma política de emissão de certificado pode ser usada para o controle de acesso
A partir do nível funcional de domínio do Windows Server 2008 R2, o suporte de controladores de domínio para garantia do mecanismo de autenticação oferece uma maneira de mapear OIDs de política de emissão de certificados para grupos de segurança universal. Controladores de domínio do Windows Server 2012 com suporte a solicitações podem mapeá-las para declarações. Para saber mais sobre a garantia do mecanismo de autenticação, consulte Guia passo a passo da garantia do mecanismo de autenticação para AD DS no Windows Server 2008 R2 no TechNet.
Para ver as políticas de emissão disponíveis
- 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
Para vincular uma política de emissão a um grupo de segurança universal
- 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>"
Restringir o logon do usuário
Agora concluímos o seguinte:
- Uma política de emissão de certificado especial foi criado para identificar dispositivos que atendem aos critérios de implantação necessários para que o usuário possa fazer logon
- Essa política foi mapeada para um grupo de segurança universal ou solicitação
- Forneceu uma maneira de os controladores de domínio obterem os dados de autorização do dispositivo durante o logon do usuário usando o blindamento Kerberos. Agora o que resta a fazer é configurar a verificação de acesso nos controladores de domínio. Isso é feito por meio de políticas de autenticação.
Políticas de autenticação têm os seguintes requisitos:
- As contas dos usuários devem estar no nível funcional de domínio do Windows Server 2012 ou um domínio superior.
Criando uma política de autenticação que restrinja usuários ao grupo de segurança universal específico
- Abrir o Centro Administrativo do Active Directory
- Selecionar Nova > Política de Autenticação >
- Na caixa Nome de exibição , insira um nome para essa política de autenticação
- No título Contas , selecione Adicionar
- Na caixa de diálogo Selecionar Usuários, Computadores ou Contas de Serviço, digite o nome da conta de usuário que você deseja restringir e selecione OK
- No título Logon do Usuário, selecione o botão Editar
- Selecione Adicionar uma condição
- Na caixa Editar Controle de Acesso Condições, verifique se ele lê Membro do Grupo > de Usuários > de cada > valor e selecione Adicionar itens
- Na caixa de diálogo Selecionar Usuários, Computadores ou Contas de Serviço, digite o nome do grupo de segurança universal criado com o script set-IssuancePolicyToGroupLink e selecione OK
- Selecione OK para fechar a caixa Editar Controle de Acesso Condições
- Selecione OK para criar a política de autenticação
- Selecionar Centro Administrativo do Active Directory
Observação
Quando a política de autenticação impõe restrições de política, os usuários não poderão fazer logon usando dispositivos que não tenham um certificado com a política de emissão apropriada implantada. Isso se aplica aos cenários de entrada local e remota. Portanto, é altamente recomendável primeiro só auditar as restrições de política para garantir que você não tenha falhas inesperadas.
Descobrir falhas de autenticação devido a políticas de autenticação
Para facilitar o acompanhamento de falhas de autenticação devido a políticas de autenticação, há um log operacional com apenas esses eventos. Para habilitar os logs nos controladores de domínio, em Visualizador de Eventos, navegue até Logs de Aplicativos e Serviços\Microsoft\Windows\Autenticação, clique com o botão direito do mouse em AuthenticationPolicyFailures-DomainController e selecione Habilitar Log.
Para saber mais sobre eventos de política de autenticação, consulte Políticas de autenticação e silos de política de autenticação.
Apêndice: scripts
Veja a seguir uma lista dos scripts 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 targeted.
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.
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de