Protegendo o arquivo MOF

Aplica-se a: Windows PowerShell 4.0, Windows PowerShell 5.0

O DSC gerencia a configuração dos nós do servidor aplicando informações armazenadas em um arquivo MOF, onde o Gerenciador de Configuração Local (LCM) implementa o estado final desejado. Como esse arquivo contém os detalhes da configuração, é importante mantê-lo seguro. Este artigo descreve como garantir que o nó de destino tenha criptografado o arquivo.

A partir da versão 5.0 do PowerShell, todo o arquivo MOF é criptografado por padrão quando é aplicado ao nó usando o Start-DSCConfiguration cmdlet. O processo descrito neste artigo é necessário somente ao implementar uma solução usando o protocolo pull service se os certificados não forem gerenciados, para garantir que as configurações baixadas pelo nó de destino possam ser descriptografadas e lidas pelo sistema antes de serem aplicadas (por exemplo, o serviço pull disponível no Windows Server). Os nós registrados no DSC de Automação do Azure terão automaticamente certificados instalados e gerenciados pelo serviço sem necessidade de sobrecarga administrativa.

Pré-requisitos

Para criptografar com êxito as credenciais usadas para proteger uma configuração DSC, verifique se você tem o seguinte:

• Alguns meios de emissão e distribuição de certificados. Este tópico e seus exemplos pressupõem que você esteja usando a Autoridade de Certificação do Ative Directory. Para obter mais informações básicas sobre os Serviços de Certificados do Ative Directory, consulte Visão geral dos Serviços de Certificados do Ative Directory.
• Acesso administrativo ao(s) nó(s) de destino.
• Cada nó de destino tem um certificado com capacidade de criptografia salvo em seu Repositório Pessoal. No Windows PowerShell, o caminho para o repositório é Cert:\LocalMachine\My. Os exemplos neste tópico usam o modelo de "autenticação de estação de trabalho", que você pode encontrar (junto com outros modelos de certificado) em Modelos de certificado padrão.
• Se você estiver executando essa configuração em um computador diferente do nó de destino, exporte a chave pública do certificado e importe-a para o computador do qual executará a configuração. Certifique-se de exportar apenas a chave pública ; Mantenha a chave privada segura.

Processo global

1. Configure os certificados, chaves e impressões digitais, certificando-se de que cada nó de destino tenha cópias do certificado e que o computador de configuração tenha a chave pública e a impressão digital.
2. Crie um bloco de dados de configuração que contenha o caminho e a impressão digital da chave pública.
3. Crie um script de configuração que defina a configuração desejada para o nó de destino e configure a descriptografia nos nós de destino comandando o Gerenciador de Configuração Local para descriptografar os dados de configuração usando o certificado e sua impressão digital.
4. Execute a configuração, que definirá as configurações do Gerenciador de Configurações Local e iniciará a configuração do DSC.

Requisitos do certificado

Para implementar a criptografia de credenciais, um certificado de chave pública deve estar disponível no Nó de Destinoconfiável pelo computador que está sendo usado para criar a configuração DSC. Este certificado de chave pública tem requisitos específicos para ser usado para criptografia de credenciais DSC:

1. Uso da chave:
   • Deve conter: 'KeyEncipherment' e 'DataEncipherment'.
   • Não deve conter: 'Assinatura Digital'.
2. Utilização melhorada da chave:
   • Deve conter: Encriptação de documentos (1.3.6.1.4.1.311.80.1).
   • Não deve conter: Autenticação de Cliente (1.3.6.1.5.5.7.3.2) e Autenticação de Servidor (1.3.6.1.5.5.7.3.1).
3. A Chave Privada do certificado está disponível no *Target Node_.
4. O provedor para o certificado deve ser "Microsoft RSA SChannel Cryptographic Provider".

Qualquer certificado existente no Nó de Destino que atenda a esses critérios pode ser usado para proteger credenciais DSC.

Criação de certificados

Há duas abordagens que você pode adotar para criar e usar o Certificado de Criptografia necessário (par de chaves público-privado).

1. Crie-o no Nó de Destino e exporte apenas a chave pública para o Nó de Criação
2. Crie-o no Nó de Criação e exporte todo o par de chaves para o Nó de Destino

O método 1 é recomendado porque a chave privada usada para descriptografar credenciais no MOF permanece no nó de destino o tempo todo.

Criando o certificado no nó de destino

A chave privada deve ser mantida em segredo, porque é usada para descriptografar o MOF no nó de destino A maneira mais fácil de fazer isso é criar o certificado de chave privada no nó de destino e copiar o certificado de chave pública para o computador que está sendo usado para criar a configuração DSC em um arquivo MOF. O exemplo a seguir:

1. cria um certificado no nó Destino
2. exporta o certificado de chave pública no nó de destino.
3. importa o certificado de chave pública para o meu armazenamento de certificados no nó Criação.

No nó de destino: criar e exportar o certificado

Nó de destino: Windows Server 2016 e Windows 10

# note: These steps need to be performed in an Administrator PowerShell session
$cert = New-SelfSignedCertificate -Type DocumentEncryptionCertLegacyCsp -DnsName 'DscEncryptionCert' -HashAlgorithm SHA256
# export the public key certificate
$cert | Export-Certificate -FilePath "$env:temp\DscPublicKey.cer" -Force

Uma vez exportado, o DscPublicKey.cer precisaria ser copiado para o nó de criação.

No nó de criação: importe a chave pública do certificado

# Import to the my store
Import-Certificate -FilePath "$env:temp\DscPublicKey.cer" -CertStoreLocation Cert:\LocalMachine\My

Criando o certificado no nó de criação

Como alternativa, o certificado de criptografia pode ser criado no nó de criação, exportado com a chave privada como um arquivo PFX e, em seguida, importado no nó de destino. Este é o método atual para implementar a criptografia de credenciais DSC no Nano Server. Embora o PFX esteja protegido com uma senha, ele deve ser mantido seguro durante o trânsito. O exemplo a seguir:

1. cria um certificado no nó Criação.
2. exporta o certificado, incluindo a chave privada no nó Criação.
3. remove a chave privada do nó Criação, mas mantém o certificado de chave pública no meu armazenamento.
4. importa o certificado de chave privada para o armazenamento de certificados My(Personal) no nó Destino.
   • ele deve ser adicionado ao armazenamento raiz para que seja confiável pelo nó de destino.

No nó de criação: criar e exportar o certificado

Nó de destino: Windows Server 2016 e Windows 10

# note: These steps need to be performed in an Administrator PowerShell session
$cert = New-SelfSignedCertificate -Type DocumentEncryptionCertLegacyCsp -DnsName 'DscEncryptionCert' -HashAlgorithm SHA256
# export the private key certificate
$mypwd = ConvertTo-SecureString -String "YOUR_PFX_PASSWD" -Force -AsPlainText
$cert | Export-PfxCertificate -FilePath "$env:temp\DscPrivateKey.pfx" -Password $mypwd -Force
# remove the private key certificate from the node but keep the public key certificate
$cert | Export-Certificate -FilePath "$env:temp\DscPublicKey.cer" -Force
$cert | Remove-Item -Force
Import-Certificate -FilePath "$env:temp\DscPublicKey.cer" -CertStoreLocation Cert:\LocalMachine\My

Uma vez exportado, o DscPrivateKey.pfx precisaria ser copiado para o nó de destino.

No nó de destino: importe a chave privada do certificado como uma raiz confiável

# Import to the root store so that it is trusted
$mypwd = ConvertTo-SecureString -String "YOUR_PFX_PASSWD" -Force -AsPlainText
Import-PfxCertificate -FilePath "$env:temp\DscPrivateKey.pfx" -CertStoreLocation Cert:\LocalMachine\My -Password $mypwd > $null

Dados de configuração

O bloco de dados de configuração define em quais nós de destino operar, se as credenciais devem ou não ser criptografadas, os meios de criptografia e outras informações. Para obter mais informações sobre o bloco de dados de configuração, consulte Separando dados de configuração e de ambiente.

Os elementos que podem ser configurados para cada nó relacionados à criptografia de credenciais são:

• NodeName - o nome do nó de destino para o qual a criptografia de credencial está sendo configurada.
• PsDscAllowPlainTextPassword - se as credenciais não criptografadas poderão ser passadas para este nó. Isto não é recomendado.
• Impressão digital - a impressão digital do certificado que será usada para descriptografar as credenciais na Configuração DSC no nó de destino. Esse certificado deve existir no armazenamento de certificados do Computador Local no Nó de Destino.
• CertificateFile - o arquivo de certificado (contendo apenas a chave pública) que deve ser usado para criptografar as credenciais para o nó de destino. Este deve ser um arquivo de certificado binário X.509 codificado pelo DER ou X.509 codificado em Base-64.

Este exemplo mostra um bloco de dados de configuração que especifica um nó de destino para agir no targetNode nomeado, o caminho para o arquivo de certificado de chave pública (chamado targetNode.cer) e a impressão digital da chave pública.

$ConfigData = @{
    AllNodes = @(
        @{
            # The name of the node we are describing
            NodeName        = "targetNode"

            # The path to the .cer file containing the
            # public key of the Encryption Certificate
            # used to encrypt credentials for this node
            CertificateFile = "C:\publicKeys\targetNode.cer"


            # The thumbprint of the Encryption Certificate
            # used to decrypt the credentials on target node
            Thumbprint      = "AA11BB22CC33DD44EE55FF66AA77BB88CC99DD00"
        }
    )
}

Script de configuração

No próprio script de configuração, use o parâmetro para garantir que as PsCredential credenciais sejam armazenadas pelo menor tempo possível. Quando você executa o exemplo fornecido, o DSC solicitará credenciais e, em seguida, criptografará o arquivo MOF usando o CertificateFile associado ao nó de destino no bloco de dados de configuração. Este exemplo de código copia um arquivo de um compartilhamento protegido para um usuário.

configuration CredentialEncryptionExample
{
    param(
        [Parameter(Mandatory=$true)]
        [ValidateNotNullorEmpty()]
        [PsCredential] $credential
    )

    Node $AllNodes.NodeName
    {
        File exampleFile
        {
            SourcePath = "\\Server\share\path\file.ext"
            DestinationPath = "C:\destinationPath"
            Credential = $credential
        }
    }
}

Configurar a desencriptação

Antes que Start-DscConfiguration possa funcionar, você precisa informar ao Gerenciador de Configuração Local em cada nó de destino qual certificado usar para descriptografar as credenciais, usando o recurso CertificateID para verificar a impressão digital do certificado. Esta função de exemplo encontrará o certificado local apropriado (talvez seja necessário personalizá-lo para que ele encontre o certificado exato que você deseja usar):

# Get the certificate that works for encryption
function Get-LocalEncryptionCertificateThumbprint
{
    (dir Cert:\LocalMachine\my) | %{
        # Verify the certificate is for Encryption and valid
        if ($_.PrivateKey.KeyExchangeAlgorithm -and $_.Verify())
        {
            return $_.Thumbprint
        }
    }
}

Com o certificado identificado por sua impressão digital, o script de configuração pode ser atualizado para usar o valor:

configuration CredentialEncryptionExample
{
    param(
        [Parameter(Mandatory=$true)]
        [ValidateNotNullorEmpty()]
        [PsCredential] $credential
    )

    Node $AllNodes.NodeName
    {
        File exampleFile
        {
            SourcePath = "\\Server\share\path\file.ext"
            DestinationPath = "C:\destinationPath"
            Credential = $credential
        }

        LocalConfigurationManager
        {
             CertificateId = $node.Thumbprint
        }
    }
}

Executando a configuração

Neste ponto, você pode executar a configuração, que produzirá dois arquivos:

• Um *.meta.mof arquivo que configura o Gerenciador de Configurações Local para descriptografar as credenciais usando o certificado armazenado no armazenamento da máquina local e identificado por sua impressão digital. Set-DscLocalConfigurationManager aplica o *.meta.mof arquivo.
• Um arquivo MOF que realmente aplica a configuração. Start-DscConfiguration aplica a configuração.

Esses comandos realizarão essas etapas:

Write-Host "Generate DSC Configuration..."
CredentialEncryptionExample -ConfigurationData $ConfigData -OutputPath .\CredentialEncryptionExample

Write-Host "Setting up LCM to decrypt credentials..."
Set-DscLocalConfigurationManager .\CredentialEncryptionExample -Verbose

Write-Host "Starting Configuration..."
Start-DscConfiguration .\CredentialEncryptionExample -wait -Verbose

Este exemplo enviaria a configuração DSC para o nó de destino. A configuração DSC também pode ser aplicada usando um DSC Pull Server, se houver um disponível.

Consulte Configurando um cliente de recebimento de DSC para obter mais informações sobre como aplicar configurações de DSC usando um servidor de recebimento de DSC.

Exemplo de módulo de criptografia de credenciais

Aqui está um exemplo completo que incorpora todas essas etapas, além de um cmdlet auxiliar que exporta e copia as chaves públicas:

# A simple example of using credentials
configuration CredentialEncryptionExample
{
    param(
        [Parameter(Mandatory=$true)]
        [ValidateNotNullorEmpty()]
        [PsCredential] $credential
    )

    Node $AllNodes.NodeName
    {
        File exampleFile
        {
            SourcePath = "\\server\share\file.txt"
            DestinationPath = "C:\Users\user"
            Credential = $credential
        }

        LocalConfigurationManager
        {
            CertificateId = $node.Thumbprint
        }
    }
}

# A Helper to invoke the configuration, with the correct public key
# To encrypt the configuration credentials
function Start-CredentialEncryptionExample
{
    [CmdletBinding()]
    param ($computerName)

    [string] $thumbprint = Get-EncryptionCertificate -computerName $computerName -Verbose
    Write-Verbose "using cert: $thumbprint"

    $certificatePath = join-path -Path "$env:SystemDrive\$script:publicKeyFolder" -childPath "$computername.EncryptionCertificate.cer"

    $ConfigData=    @{
        AllNodes = @(
                        @{
                            # The name of the node we are describing
                            NodeName = "$computerName"

                            # The path to the .cer file containing the
                            # public key of the Encryption Certificate
                            CertificateFile = "$certificatePath"

                            # The thumbprint of the Encryption Certificate
                            # used to decrypt the credentials
                            Thumbprint = $thumbprint
                        };
                    );
    }

    Write-Verbose "Generate DSC Configuration..."
    CredentialEncryptionExample -ConfigurationData $ConfigData -OutputPath .\CredentialEncryptionExample `
        -credential (Get-Credential -UserName "$env:USERDOMAIN\$env:USERNAME" -Message "Enter credentials for configuration")

    Write-Verbose "Setting up LCM to decrypt credentials..."
    Set-DscLocalConfigurationManager .\CredentialEncryptionExample -Verbose

    Write-Verbose "Starting Configuration..."
    Start-DscConfiguration .\CredentialEncryptionExample -wait -Verbose
}

#region HelperFunctions

# The folder name for the exported public keys
$script:publicKeyFolder = "publicKeys"

# Get the certificate that works for encryptions
function Get-EncryptionCertificate
{
    [CmdletBinding()]
    param ($computerName)

    $returnValue= Invoke-Command -ComputerName $computerName -ScriptBlock {
        $certificates = dir Cert:\LocalMachine\my

        $certificates | %{
                    # Verify the certificate is for Encryption and valid
            if ($_.PrivateKey.KeyExchangeAlgorithm -and $_.Verify())
            {
                # Create the folder to hold the exported public key
                $folder= Join-Path -Path $env:SystemDrive\ -ChildPath $using:publicKeyFolder
                if (! (Test-Path $folder))
                {
                    md $folder | Out-Null
                }

                # Export the public key to a well known location
                $certPath = Export-Certificate -Cert $_ -FilePath (Join-Path -path $folder -childPath "EncryptionCertificate.cer")

                # Return the thumbprint, and exported certificate path
                return @($_.Thumbprint,$certPath);
            }
        }
    }

    Write-Verbose "Identified and exported cert..."
    # Copy the exported certificate locally
    $destinationPath = join-path -Path "$env:SystemDrive\$script:publicKeyFolder" -childPath "$computername.EncryptionCertificate.cer"
    Copy-Item -Path (join-path -path \\$computername -childPath $returnValue[1].FullName.Replace(":","$"))  $destinationPath | Out-Null

    # Return the thumbprint
    return $returnValue[0]
}

Start-CredentialEncryptionExample