Protegendo o Arquivo MOFSecuring the MOF File

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

O DSC gerencia a configuração dos nós de servidor aplicando as informações armazenadas em um arquivo MOF, em que o LCM (Gerenciador de Configurações Local) implementa o estado final desejado.DSC manages the configuration of server nodes by applying information stored in a MOF file, where the Local Configuration Manager (LCM) implements the desired end state. Como esse arquivo contém os detalhes da configuração, é importante mantê-lo em segurança.Because this file contains the details of the configuration, it’s important to keep it secure. Este tópico descreve como garantir que o nó de destino criptografou o arquivo.This topic describes how to ensure the target node has encrypted the file.

A partir do PowerShell versão 5.0, o arquivo MOF inteiro é criptografado por padrão quando aplicado ao nó usando o cmdlet Start-DSCConfiguration.Beginning with PowerShell version 5.0, the entire MOF file is encrypted by default when it is applied to the node using the Start-DSCConfiguration cmdlet. O processo descrito neste artigo será necessário somente ao implementar uma solução usando o protocolo de serviço de pull se os certificados não forem gerenciados, para garantir que as configurações baixadas pelo nó de destino possam ser criptografadas e lidas pelo sistema antes de serem aplicadas (por exemplo, o serviço de pull disponível no Windows Server).The process described in this article is required only when implementing a solution using the pull service protocol if certificates are not managed, to ensure configurations downloaded by the target node can be decrypted and read by the system before they are applied (for example, the pull service available in Windows Server). Nós registrados no DSC de Automação do Azure terão certificados automaticamente instalados e gerenciados pelo serviço sem a necessidade de sobrecarga administrativa.Nodes registered to Azure Automation DSC will automatically have certificates installed and managed by the service with no administrative overhead required.

Observação: este tópico discute os certificados usados para criptografia.Note: This topic discusses certificates used for encryption. Para criptografia, um certificado autoassinado é suficiente porque a chave privada é mantida sempre segredo e a criptografia não afeta a confiança do documento.For encryption, a self-signed certificate is sufficient, because the private key is always kept secret and encryption does not imply trust of the document. Certificados autoassinados não devem ser usados para fins de autenticação.Self-signed certificates should not be used for authentication purposes. Você deve usar um certificado de uma AC (Autoridade de Certificação) confiável para fins de autenticação.You should use a certificate from a trusted Certification Authority (CA) for any authentication purposes.

Pré-requisitosPrerequisites

Para criptografar com êxito as credenciais usadas para proteger uma configuração DSC, verifique se que você tem o seguinte:To successfully encrypt the credentials used to secure a DSC configuration, make sure you have the following:

  • Algum meio de emitir e distribuir certificados.Some means of issuing and distributing certificates. Este tópico e seus exemplos pressupõem que você está usando uma Autoridade de Certificação do Active Directory.This topic and its examples assume you are using Active Directory Certification Authority. Para obter mais informações sobre os Serviços de Certificados do Active Directory, consulte Visão Geral dos Serviços de Certificados do Active Directory e Serviços de Certificados do Active Directory no Windows Server 2008.For more background information on Active Directory Certificate Services, see Active Directory Certificate Services Overview and Active Directory Certificate Services in Windows Server 2008.
  • Acesso administrativo ao nó ou nós de destino.Administrative access to the target node or nodes.
  • Cada nó de destino tem um certificado com capacidade de criptografia salvo no seu Repositório Pessoal.Each target node has an encryption-capable certificate saved its Personal Store. No Windows PowerShell, o caminho até o repositório é Cert:\LocalMachine\My.In Windows PowerShell, the path to the store is Cert:\LocalMachine\My. Os exemplos neste tópico usam o modelo “autenticação de estação de trabalho”, que você pode encontrar (junto com outros modelos de certificado) em Modelos de Certificados Padrão.The examples in this topic use the “workstation authentication” template, which you can find (along with other certificate templates) at Default Certificate Templates.
  • Se você for executar essa configuração em um computador diferente do nó de destino, exporte a chave pública do certificado e, em seguida, importe-a para o computador no qual executará a configuração.If you will be running this configuration on a computer other than the target node, export the public key of the certificate, and then import it to the computer you will run the configuration from. Certifique-se de exportar apenas a chave pública; mantenha a chave privada em segurança.Make sure that you export only the public key; keep the private key secure.

Processo geralOverall process

  1. Configure os certificados, chaves e as impressões digitais, certificando-se de que cada nó de destino possua cópias do certificado e que o computador de configuração tenha a chave pública e a impressão digital.Set up the certificates, keys, and thumbprints, making sure that each target node has copies of the certificate and the configuration computer has the public key and thumbprint.
  2. Crie um bloco de dados de configuração que contenha o caminho e a impressão digital da chave pública.Create a configuration data block that contains the path and thumbprint of the public key.
  3. Crie um script de configuração que defina a configuração desejada para o nó de destino e configure a descriptografia em nós de destino ao ordenar que o Gerenciador de Configurações Local descriptografe os dados de configuração usando o certificado e sua impressão digital.Create a configuration script that defines your desired configuration for the target node and sets up decryption on the target nodes by commanding the Local Configuration manager to decrypt the configuration data using the certificate and its thumbprint.
  4. Execute a configuração, que definirá as configurações do Gerenciador de Configurações Local e iniciará a configuração DSC.Run the configuration, which will set the Local Configuration Manager settings and start the DSC configuration.

Diagrama1

Requisitos de CertificadoCertificate Requirements

Para ativar a criptografia de credenciais, um certificado de chave pública deve estar disponível no Nó de Destino que é confiável para o computador que está sendo usado para criar a configuração DSC.To enact credential encryption, a public key certificate must be available on the Target Node that is trusted by the computer being used to author the DSC configuration. Esse certificado de chave pública tem requisitos específicos para ser usado para criptografia de credencial DSC:This public key certificate has specific requirements for it to be used for DSC credential encryption:

  1. Uso de chave:Key Usage:
    • Deve conter: 'KeyEncipherment' e 'DataEncipherment'.Must contain: 'KeyEncipherment' and 'DataEncipherment'.
    • Não deve conter: “Assinatura Digital”.Should not contain: 'Digital Signature'.
  2. Uso avançado de chave:Enhanced Key Usage:
    • Deve conter: Criptografia de Documento (1.3.6.1.4.1.311.80.1).Must contain: Document Encryption (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).Should not contain: Client Authentication (1.3.6.1.5.5.7.3.2) and Server Authentication (1.3.6.1.5.5.7.3.1).
  3. A Chave Privada do certificado está disponível no *Nó de Destino_.The Private Key for the certificate is available on the *Target Node_.
  4. O Provedor para o certificado deve ser "Microsoft RSA SChannel Cryptographic Provider".The Provider for the certificate must be "Microsoft RSA SChannel Cryptographic Provider".

Melhor Prática Recomendada: embora você possa usar um certificado contendo um Uso de Chave de 'Assinatura Digital' ou um dos EKUs de autenticação, isso permitirá que a chave de criptografia seja mais facilmente usada de modo incorreto e fique mais vulnerável a ataques.Recommended Best Practice: Although you can use a certificate with containing a Key Usage of 'Digital Signature' or one of the Authentication EKU's, this will enable the encryption key to be more easily misused and vulnerable to attack. Assim, a melhor prática é usar um certificado criado especificamente para a finalidade de proteger credenciais DSC que omite esses Usos de Chave e EKUs.So it is best practice to use a certificate created specifically for the purpose of securing DSC credentials that omits these Key Usage and EKUs.

Qualquer certificado existente no Nó de Destino que atende esses critérios pode ser usado para proteger credenciais DSC.Any existing certificate on the Target Node that meets these criteria can be used to secure DSC credentials.

Criação de certificadoCertificate creation

Há duas abordagens que você pode executar para criar e usar o certificado de criptografia necessário (par de chaves públicas-privadas).There are two approaches you can take to create and use the required Encryption Certificate (public-private key pair).

  1. Criá-lo no Nó de Destino e exportar apenas a chave pública para o Nó de CriaçãoCreate it on the Target Node and export just the public key to the Authoring Node
  2. Criá-lo no Nó de Criação e exportar o par de chaves inteiro para o Nó de DestinoCreate it on the Authoring Node and export the entire key pair to the Target Node

O Método 1 é recomendado porque a chave privada usada para descriptografar credenciais no MOF permanece no nó de destino em todos os momentos.Method 1 is recommended because the private key used to decrypt credentials in the MOF stays on the Target Node at all times.

Criando o certificado no nó de destinoCreating the Certificate on the Target Node

A chave privada deve ser mantida em segredo, pois é usada para descriptografar o MOF no Nó de Destino. A forma mais fácil de fazer isso é criar o certificado da chave privada no Nó de Destino e copiar o certificado de chave pública no computador que está sendo usado para criar a configuração DSC em um arquivo MOF.The private key must be kept secret, because is used to decrypt the MOF on the Target Node The easiest way to do that is to create the private key certificate on the Target Node, and copy the public key certificate to the computer being used to author the DSC configuration into a MOF file. O exemplo a seguir:The following example:

  1. cria um certificado no Nó de destinocreates a certificate on the Target node
  2. exporta o certificado de chave pública para o Nó de destino.exports the public key certificate on the Target node.
  3. importa o certificado de chave pública para o meu repositório de certificados no Nó de criação.imports the public key certificate into the my certificate store on the Authoring node.

No Nó de destino: criar e exportar o certificadoOn the Target Node: create and export the certificate

Nó de Criação: Windows Server 2016 e Windows 10Authoring Node: Windows Server 2016 and 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 copiados no Nó de Criação.Once exported, the DscPublicKey.cer would need to be copied to the Authoring Node.

Nó de Criação: Windows Server 2012 R2/Windows 8.1 e versões anterioresAuthoring Node: Windows Server 2012 R2/Windows 8.1 and earlier

Como não há suporte para o cmdlet New-SelfSignedCertificate em sistemas operacionais Windows anteriores ao Windows 10 e o Windows Server 2016 não dá suporte ao parâmetro Type, um método alternativo de criar esse certificado é necessário nesses sistemas operacionais.Because the New-SelfSignedCertificate cmdlet on Windows Operating Systems prior to Windows 10 and Windows Server 2016 do not support the Type parameter, an alternate method of creating this certificate is required on these operating systems. Nesse caso, você pode usar makecert.exe ou certutil.exe para criar o certificado.In this case you can use makecert.exe or certutil.exe to create the certificate.

Um método alternativo é baixar o script New-SelfSignedCertificateEx.ps1 do Microsoft Script Center e usá-lo para criar o certificado em vez disso:An alternate method is to download the New-SelfSignedCertificateEx.ps1 script from Microsoft Script Center and use it to create the certificate instead:

# note: These steps need to be performed in an Administrator PowerShell session
# and in the folder that contains New-SelfSignedCertificateEx.ps1
. .\New-SelfSignedCertificateEx.ps1
New-SelfsignedCertificateEx `
    -Subject "CN=${ENV:ComputerName}" `
    -EKU 'Document Encryption' `
    -KeyUsage 'KeyEncipherment, DataEncipherment' `
    -SAN ${ENV:ComputerName} `
    -FriendlyName 'DSC Credential Encryption certificate' `
    -Exportable `
    -StoreLocation 'LocalMachine' `
    -StoreName 'My' `
    -KeyLength 2048 `
    -ProviderName 'Microsoft Enhanced Cryptographic Provider v1.0' `
    -AlgorithmName 'RSA' `
    -SignatureAlgorithm 'SHA256'
# Locate the newly created certificate
$Cert = Get-ChildItem -Path cert:\LocalMachine\My `
    | Where-Object {
        ($_.FriendlyName -eq 'DSC Credential Encryption certificate') `
        -and ($_.Subject -eq "CN=${ENV:ComputerName}")
    } | Select-Object -First 1
# export the public key certificate
$cert | Export-Certificate -FilePath "$env:temp\DscPublicKey.cer" -Force

Uma vez exportado, o DscPublicKey.cer precisaria ser copiados no Nó de Criação.Once exported, the DscPublicKey.cer would need to be copied to the Authoring Node.

No Nó de Criação: importar a chave pública do certificadoOn the Authoring Node: import the cert’s public key

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

Criando o certificado no Nó de CriaçãoCreating the Certificate on the Authoring Node

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.Alternately, the encryption certificate can be created on the Authoring Node, exported with the private key as a PFX file and then imported on the Target Node. Esse é o método atual para implementar a criptografia de credencial DSC no Nano Server.This is the current method for implementing DSC credential encryption on Nano Server. Embora o PFX seja protegido por uma senha, ele deve ser mantido seguro durante o trânsito.Although the PFX is secured with a password it should be kept secure during transit. O exemplo a seguir:The following example:

  1. cria um certificado no Nó de criação.creates a certificate on the Authoring node.
  2. exporta o certificado, incluindo a chave privada do Nó de criação.exports the certificate including the private key on the Authoring node.
  3. remove a chave privada do Nó de criação, mas mantém o certificado de chave pública no meu repositório.removes the private key from the Authoring node, but keeps the public key certificate in the my store.
  4. importa o certificado de chave privada para o repositório de certificados raiz no Nó de destino.imports the private key certificate into the root certificate store on the Target node.
    • ele deve ser adicionado ao repositório raiz para que seja confiável pelo Nó de destino.it must be added to the root store so that it will be trusted by the Target node.

No Nó de criação: criar e exportar o certificadoOn the Authoring Node: create and export the certificate

Nó de destino: Windows Server 2016 e Windows 10Target Node: Windows Server 2016 and 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 no Nó de Destino.Once exported, the DscPrivateKey.pfx would need to be copied to the Target Node.

Nó de destino: Windows Server 2012 R2/Windows 8.1 e versões anterioresTarget Node: Windows Server 2012 R2/Windows 8.1 and earlier

Como não há suporte para o cmdlet New-SelfSignedCertificate em sistemas operacionais Windows anteriores ao Windows 10 e o Windows Server 2016 não dá suporte ao parâmetro Type, um método alternativo de criar esse certificado é necessário nesses sistemas operacionais.Because the New-SelfSignedCertificate cmdlet on Windows Operating Systems prior to Windows 10 and Windows Server 2016 do not support the Type parameter, an alternate method of creating this certificate is required on these operating systems. Nesse caso, você pode usar makecert.exe ou certutil.exe para criar o certificado.In this case you can use makecert.exe or certutil.exe to create the certificate.

Um método alternativo é baixar o script New-SelfSignedCertificateEx.ps1 do Microsoft Script Center e usá-lo para criar o certificado em vez disso:An alternate method is to download the New-SelfSignedCertificateEx.ps1 script from Microsoft Script Center and use it to create the certificate instead:

# note: These steps need to be performed in an Administrator PowerShell session
# and in the folder that contains New-SelfSignedCertificateEx.ps1
. .\New-SelfSignedCertificateEx.ps1
New-SelfsignedCertificateEx `
    -Subject "CN=${ENV:ComputerName}" `
    -EKU 'Document Encryption' `
    -KeyUsage 'KeyEncipherment, DataEncipherment' `
    -SAN ${ENV:ComputerName} `
    -FriendlyName 'DSC Credential Encryption certificate' `
    -Exportable `
    -StoreLocation 'LocalMachine' `
    -KeyLength 2048 `
    -ProviderName 'Microsoft Enhanced Cryptographic Provider v1.0' `
    -AlgorithmName 'RSA' `
    -SignatureAlgorithm 'SHA256'
# Locate the newly created certificate
$Cert = Get-ChildItem -Path cert:\LocalMachine\My `
    | Where-Object {
        ($_.FriendlyName -eq 'DSC Credential Encryption certificate') `
        -and ($_.Subject -eq "CN=${ENV:ComputerName}")
    } | Select-Object -First 1
# export the public 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

No Nó de destino: importar a chave privada do certificado como uma raiz confiávelOn the Target Node: import the cert’s private key as a trusted root

# 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çãoConfiguration data

O bloco de dados de configuração define em quais nós de destino vai operar, se vai criptografar as credenciais ou não, o meio de criptografia e outras informações.The configuration data block defines which target nodes to operate on, whether or not to encrypt the credentials, the means of encryption, and other information. Para obter mais informações sobre o bloco de dados de configuração, consulte Separando Dados de Configuração e de Ambiente.For more information on the configuration data block, see Separating Configuration and Environment Data.

Os elementos que podem ser configurados para cada nó que estão relacionados à criptografia de credencial são:The elements that can be configured for each node that are related to credential encryption are:

  • NodeName: o nome do nó de destino para o qual a criptografia de credencial está sendo configurada.NodeName - the name of the target node that the credential encryption is being configured for.
  • PsDscAllowPlainTextPassword: se credenciais sem criptografia poderão ou não ser passadas para esse nó.PsDscAllowPlainTextPassword - whether unencrypted credentials will be allowed to be passed to this node. Isso não é recomendável.This is not recommended.
  • Impressão digital: a impressão digital do certificado que será usada para descriptografar as credenciais na Configuração DSC no Nó de Destino.Thumbprint - the thumbprint of the certificate that will be used to decrypt the credentials in the DSC Configuration on the Target Node. Esse certificado deve existir no repositório de certificados do Computador Local no Nó de Destino.This certificate must exist in the Local Machine certificate store on the Target Node.
  • CertificateFile: o arquivo de certificado (contendo somente a chave pública) que deve ser usado para criptografar as credenciais para o Nó de Destino.CertificateFile - the certificate file (containing the public key only) that should be used to encrypt the credentials for the Target Node. Isso deve ser X.509 binário codificado por DER ou um arquivo de certificado de formato X.509 com codificação de Base 64.This must be either a DER encoded binary X.509 or Base-64 encoded X.509 format certificate file.

Este exemplo mostra um bloco de dados de configuração que especifica um nó de destino para atuar no targetNode nomeado, o caminho até o arquivo de certificado de chave pública (denominado targetNode.cer) e a impressão digital da chave pública.This example shows a configuration data block that specifies a target node to act on named targetNode, the path to the public key certificate file (named targetNode.cer), and the thumbprint for the public key.

$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 = "AC23EA3A9E291A75757A556D0B71CBBF8C4F6FD8" 
            }; 
        );    
    }

Script de configuraçãoConfiguration script

No próprio script de configuração, use o parâmetro PsCredential para garantir que as credenciais sejam armazenadas pelo menor tempo possível.In the configuration script itself, use the PsCredential parameter to ensure that credentials are stored for the shortest possible time. Quando você executa o exemplo fornecido, a DSC solicitará credenciais e, em seguida, criptografará o arquivo MOF usando o CertificateFile que está associado com o nó de destino no bloco de dados de configuração.When you run the supplied example, DSC will prompt you for credentials and then encrypt the MOF file using the CertificateFile that is associated with the target node in the configuration data block. Este exemplo de código copia um arquivo de um compartilhamento protegido para um usuário.This code example copies a file from a share that is secured to a user.

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 
        } 
    } 
}

Configurando a descriptografiaSetting up decryption

Para que o Start-DscConfiguration possa funcionar, você precisa informar ao Gerenciador de Configurações 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.Before Start-DscConfiguration can work, you have to tell the Local Configuration Manager on each target node which certificate to use to decrypt the credentials, using the CertificateID resource to verify the certificate’s thumbprint. A função neste exemplo encontrará o certificado local apropriado (talvez seja necessário personalizá-lo para ele encontrar o certificado exato que você deseja usar):This example function will find the appropriate local certificate (you might have to customize it so it will find the exact certificate you want to use):

# 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:With the certificate identified by its thumbprint, the configuration script can be updated to use the value:

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çãoRunning the configuration

Neste ponto, você pode executar a configuração, o que resultará em dois arquivos:At this point, you can run the configuration, which will output two files:

  • Um arquivo *.meta.mof que configura o Gerenciador de Configurações Local para descriptografar as credenciais usando o certificado armazenado no repositório do computador local e identificado por sua impressão digital.A *.meta.mof file that configures the Local Configuration Manager to decrypt the credentials using the certificate that is stored on the local machine store and identified by its thumbprint. Set-DscLocalConfigurationManager aplica o arquivo *.meta.mof.Set-DscLocalConfigurationManager applies the *.meta.mof file.
  • Um arquivo MOF que realmente aplica a configuração.A MOF file that actually applies the configuration. O Start-DscConfiguration aplica a configuração.Start-DscConfiguration applies the configuration.

Estes comandos realizarão estas etapas:These commands will accomplish those steps:

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 por push a configuração DSC para o nó de destino.This example would push the DSC configuration to the target node. A configuração DSC também poderá ser aplicada usando um Servidor de Pull de DSC, se houver um disponível.The DSC configuration can also be applied using a DSC Pull Server if one is available.

Consulte Configurando um cliente pull de DSC para obter mais informações sobre como aplicar configurações de DSC usando um Servidor de Pull de DSC.See Setting up a DSC pull client for more information on applying DSC configurations using a DSC Pull Server.

Exemplo de Módulo de Criptografia de CredencialCredential Encryption Module Example

Aqui está um exemplo completo que incorpora todas essas etapas, além de um cmdlet auxiliar que exporta e copia as chaves públicas:Here is a full example that incorporates all of these steps, plus a helper cmdlet that exports and copies the public keys:

# 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