Sichern der MOF-Datei

Gilt für: Windows PowerShell 4.0, Windows PowerShell 5.0

DSC verwaltet die Konfiguration von Serverknoten durch Anwenden von Informationen, die in einer MOF-Datei gespeichert sind, in der der lokale Konfigurations-Manager (Local Configuration Manager, LCM) den gewünschten Endzustand implementiert. Da diese Datei die Details der Konfiguration enthält, ist es wichtig, sie sicher aufzubewahren. In diesem Artikel wird beschrieben, wie Sie sicherstellen, dass der Zielknoten die Datei verschlüsselt hat.

Ab PowerShell Version 5.0 wird die gesamte MOF-Datei standardmäßig verschlüsselt, wenn sie mit dem Start-DSCConfiguration Cmdlet auf den Knoten angewendet wird. Der in diesem Artikel beschriebene Prozess ist nur erforderlich, wenn eine Lösung mithilfe des Pulldienstprotokolls implementiert wird, wenn Zertifikate nicht verwaltet werden, um sicherzustellen, dass Konfigurationen, die vom Zielknoten heruntergeladen wurden, vom System entschlüsselt und gelesen werden können, bevor sie angewendet werden (z. B. der in Windows Server verfügbare Pulldienst). Auf Knoten, die bei Azure Automation DSC registriert sind, werden automatisch Zertifikate installiert und vom Dienst verwaltet, ohne dass ein Verwaltungsaufwand erforderlich ist.

Voraussetzungen

Um die Anmeldeinformationen, die zum Sichern einer DSC-Konfiguration verwendet werden, erfolgreich zu verschlüsseln, stellen Sie sicher, dass Sie über Folgendes verfügen:

• Einige Mittel zum Ausstellen und Verteilen von Zertifikaten. In diesem Thema und den zugehörigen Beispielen wird davon ausgegangen, dass Sie die Active Directory-Zertifizierungsstelle verwenden. Weitere Hintergrundinformationen zu Active Directory-Zertifikatdiensten finden Sie unter Übersicht über Active Directory-Zertifikatdienste.
• Administrativer Zugriff auf den Zielknoten bzw. die Zielknoten.
• Jeder Zielknoten verfügt über ein verschlüsselungsfähiges Zertifikat, das im persönlichen Speicher gespeichert ist. In Windows PowerShell lautet der Pfad zum Speicher Cert:\LocalMachine\My. In den Beispielen in diesem Thema wird die Vorlage "Arbeitsstationsauthentifizierung" verwendet, die Sie (zusammen mit anderen Zertifikatvorlagen) unter Standardzertifikatvorlagen finden.
• Wenn Sie diese Konfiguration auf einem anderen Computer als dem Zielknoten ausführen, exportieren Sie den öffentlichen Schlüssel des Zertifikats, und importieren Sie ihn dann auf den Computer, von dem aus Sie die Konfiguration ausführen möchten. Stellen Sie sicher, dass Sie nur den öffentlichen Schlüssel exportieren. Bewahren Sie den privaten Schlüssel sicher auf.

Gesamtprozess

1. Richten Sie die Zertifikate, Schlüssel und Fingerabdrücke ein, und stellen Sie sicher, dass jeder Zielknoten über Kopien des Zertifikats verfügt und der Konfigurationscomputer über den öffentlichen Schlüssel und den Fingerabdruck verfügt.
2. Erstellen Sie einen Konfigurationsdatenblock, der den Pfad und den Fingerabdruck des öffentlichen Schlüssels enthält.
3. Erstellen Sie ein Konfigurationsskript, das die gewünschte Konfiguration für den Zielknoten definiert und die Entschlüsselung auf den Zielknoten einrichtet, indem Sie den lokalen Konfigurations-Manager anweisen, die Konfigurationsdaten mithilfe des Zertifikats und seines Fingerabdrucks zu entschlüsseln.
4. Führen Sie die Konfiguration aus, wodurch die Einstellungen des lokalen Konfigurations-Managers festgelegt und die DSC-Konfiguration gestartet wird.

Anforderungen an das Zertifikat

Um die Verschlüsselung von Anmeldeinformationen zu aktivieren, muss auf dem Zielknoten ein Zertifikat mit öffentlichem Schlüssel verfügbar sein, das von dem Computer als vertrauenswürdig eingestuft wird, der zum Erstellen der DSC-Konfiguration verwendet wird. Für dieses Zertifikat mit öffentlichem Schlüssel gelten bestimmte Anforderungen, damit es für die Verschlüsselung von DSC-Anmeldeinformationen verwendet werden kann:

1. Verwendung des Schlüssels:
   • Muss enthalten: 'KeyEncipherment' und 'DataEncipherment'.
   • Sollte Folgendes nicht enthalten: "Digitale Signatur".
2. Verbesserte Schlüsselverwendung:
   • Muss enthalten: Document Encryption (1.3.6.1.4.1.311.80.1).
   • Sollte Folgendes nicht enthalten: Clientauthentifizierung (1.3.6.1.5.5.7.3.2) und Serverauthentifizierung (1.3.6.1.5.5.7.3.1).
3. Der private Schlüssel für das Zertifikat ist auf der Node_ *Target verfügbar.
4. Der Anbieter für das Zertifikat muss "Microsoft RSA SChannel Cryptographic Provider" sein.

Jedes vorhandene Zertifikat auf dem Zielknoten , das diese Kriterien erfüllt, kann zum Sichern von DSC-Anmeldeinformationen verwendet werden.

Erstellung von Zertifikaten

Es gibt zwei Ansätze, die Sie verwenden können, um das erforderliche Verschlüsselungszertifikat (öffentlich-privates Schlüsselpaar) zu erstellen und zu verwenden.

1. Erstellen Sie ihn auf dem Zielknoten, und exportieren Sie nur den öffentlichen Schlüssel in den Erstellungsknoten
2. Erstellen Sie es auf dem Authoring-Knoten , und exportieren Sie das gesamte Schlüsselpaar auf den Ziel-Knoten.

Methode 1 wird empfohlen, da der private Schlüssel, der zum Entschlüsseln von Anmeldeinformationen im MOF verwendet wird, jederzeit auf dem Zielknoten verbleibt.

Erstellen des Zertifikats auf dem Zielknoten

Der private Schlüssel muss geheim gehalten werden, da er zum Entschlüsseln des MOF auf dem Zielknoten verwendet wird. Die einfachste Möglichkeit besteht darin, das Zertifikat mit dem privaten Schlüssel auf dem Zielknoten zu erstellen und das Zertifikat mit öffentlichem Schlüssel auf den Computer zu kopieren, der zum Erstellen der DSC-Konfiguration in einer MOF-Datei verwendet wird. Das folgende Beispiel:

1. erstellt ein Zertifikat auf dem Zielknoten
2. exportiert das Public-Key-Zertifikat auf dem Zielknoten.
3. importiert das Zertifikat mit öffentlichem Schlüssel in den Zertifikatspeicher "My" auf dem Knoten "Erstellung".

Auf dem Zielknoten: Erstellen und Exportieren des Zertifikats

Zielknoten: Windows Server 2016 und 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

Nach dem Exportieren müssen die DscPublicKey.cer auf den Erstellungsknoten kopiert werden.

Auf dem Authoring-Knoten: Importieren des öffentlichen Schlüssels des Zertifikats

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

Erstellen des Zertifikats auf dem Erstellungsknoten

Alternativ kann das Verschlüsselungszertifikat auf dem Erstellungsknoten erstellt, mit dem privaten Schlüssel als PFX-Datei exportiert und dann auf dem Zielknoten importiert werden. Dies ist die aktuelle Methode zum Implementieren der Verschlüsselung von DSC-Anmeldeinformationen auf Nano Server. Obwohl die PFX mit einem Passwort gesichert ist, sollte sie während der Übertragung sicher aufbewahrt werden. Das folgende Beispiel:

1. Erstellt ein Zertifikat auf dem Knoten Erstellung.
2. exportiert das Zertifikat einschließlich des privaten Schlüssels auf dem Erstellungsknoten.
3. entfernt den privaten Schlüssel aus dem Erstellungsknoten, behält aber das Zertifikat mit öffentlichem Schlüssel im Speicher "My " bei.
4. importiert das Zertifikat des privaten Schlüssels in den Zertifikatspeicher My(Personal) auf dem Zielknoten.
   • Er muss dem Stammspeicher hinzugefügt werden, damit er vom Zielknoten als vertrauenswürdig eingestuft wird.

Auf dem Erstellungsknoten: Erstellen und Exportieren des Zertifikats

Zielknoten: Windows Server 2016 und 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

Nach dem Exportieren müssten sie DscPrivateKey.pfx auf den Zielknoten kopiert werden.

Auf dem Zielknoten: Importieren Sie den privaten Schlüssel des Zertifikats als vertrauenswürdigen Stamm

# 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

Konfigurationsdaten

Der Konfigurationsdatenblock definiert, auf welchen Zielknoten gearbeitet werden soll, ob die Anmeldeinformationen, die Verschlüsselungsmittel und andere Informationen verschlüsselt werden sollen oder nicht. Weitere Informationen zum Konfigurationsdatenblock finden Sie unter Trennen von Konfigurations- und Umgebungsdaten.

Die Elemente, die für jeden Knoten konfiguriert werden können, der sich auf die Verschlüsselung von Anmeldeinformationen bezieht, sind:

• NodeName – der Name des Zielknotens, für den die Verschlüsselung von Anmeldeinformationen konfiguriert wird.
• PsDscAllowPlainTextPassword : Gibt an, ob unverschlüsselte Anmeldeinformationen an diesen Knoten übergeben werden dürfen. Dies wird nicht empfohlen.
• Fingerabdruck : Der Fingerabdruck des Zertifikats, das zum Entschlüsseln der Anmeldeinformationen in der DSC-Konfiguration auf dem Zielknoten verwendet wird. Dieses Zertifikat muss im Zertifikatspeicher des lokalen Computers auf dem Zielknoten vorhanden sein.
• CertificateFile – die Zertifikatsdatei (die nur den öffentlichen Schlüssel enthält), die zum Verschlüsseln der Anmeldeinformationen für den Zielknoten verwendet werden soll. Dabei muss es sich entweder um eine DER-codierte binäre X.509- oder Base-64-codierte Zertifikatsdatei im X.509-Format handeln.

Dieses Beispiel zeigt einen Konfigurationsdatenblock, der einen Zielknoten mit dem Namen targetNode angibt, den Pfad zur Zertifikatdatei mit dem öffentlichen Schlüssel (mit dem Namen targetNode.cer) und den Fingerabdruck für den öffentlichen Schlüssel.

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

Konfigurationsskript

Verwenden Sie den PsCredential Parameter im Konfigurationsskript selbst, um sicherzustellen, dass die Anmeldeinformationen so kurz wie möglich gespeichert werden. Wenn Sie das bereitgestellte Beispiel ausführen, werden Sie von DSC zur Eingabe von Anmeldeinformationen aufgefordert und dann die MOF-Datei mithilfe der CertificateFile verschlüsselt, die dem Zielknoten im Konfigurationsdatenblock zugeordnet ist. In diesem Codebeispiel wird eine Datei aus einer Freigabe kopiert, die für einen Benutzer gesichert ist.

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

Einrichten der Entschlüsselung

Bevor Start-DscConfiguration ausgeführt werden kann, müssen Sie dem lokalen Konfigurations-Manager auf jedem Zielknoten mitteilen, welches Zertifikat zum Entschlüsseln der Anmeldeinformationen verwendet werden soll, indem Sie die CertificateID-Ressource verwenden, um den Fingerabdruck des Zertifikats zu überprüfen. Diese Beispielfunktion findet das entsprechende lokale Zertifikat (Sie müssen es möglicherweise anpassen, damit es genau das Zertifikat findet, das Sie verwenden möchten):

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

Wenn das Zertifikat durch seinen Fingerabdruck identifiziert wird, kann das Konfigurationsskript aktualisiert werden, um den folgenden Wert zu verwenden:

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

Ausführen der Konfiguration

An diesem Punkt können Sie die Konfiguration ausführen, die zwei Dateien ausgibt:

• Eine *.meta.mof Datei, mit der der lokale Konfigurations-Manager so konfiguriert wird, dass die Anmeldeinformationen mithilfe des Zertifikats entschlüsselt werden, das im Speicher des lokalen Computers gespeichert ist und durch seinen Fingerabdruck identifiziert wird. Set-DscLocalConfigurationManager wendet die *.meta.mof Datei an.
• Eine MOF-Datei, die die Konfiguration tatsächlich anwendet. Start-DscConfiguration wendet die Konfiguration an.

Mit diesen Befehlen werden die folgenden Schritte ausgeführt:

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

In diesem Beispiel wird die DSC-Konfiguration per Push auf den Zielknoten übertragen. Die DSC-Konfiguration kann auch mithilfe eines DSC-Pull-Servers angewendet werden, sofern einer verfügbar ist.

Weitere Informationen zum Anwenden von DSC-Konfigurationen mithilfe eines DSC-Pullservers finden Sie unter Einrichten eines DSC-Pullclients .

Beispiel für ein Modul zur Verschlüsselung von Anmeldeinformationen

Im Folgenden finden Sie ein vollständiges Beispiel, das alle diese Schritte enthält, sowie ein Hilfs-Cmdlet, das die öffentlichen Schlüssel exportiert und kopiert:

# 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