Sécurisation du fichier MOF

S’applique à : Windows PowerShell 4.0, Windows PowerShell 5.0

DSC gère la configuration des nœuds de serveur en appliquant les informations stockées dans un fichier MOF, où le gestionnaire de configuration local (LCM) implémente l’état final souhaité. Étant donné que ce fichier contient les détails de la configuration, il est important de le protéger. Cet article explique comment s’assurer que le nœud cible a chiffré le fichier.

À partir de la version 5.0 de PowerShell, l’intégralité du fichier MOF est chiffrée par défaut lorsqu’il est appliqué au nœud à l’aide de l’applet Start-DSCConfiguration de commande. Le processus décrit dans cet article n’est requis que lors de l’implémentation d’une solution à l’aide du protocole de service d’extraction si les certificats ne sont pas gérés, afin de garantir que les configurations téléchargées par le nœud cible peuvent être déchiffrées et lues par le système avant d’être appliquées (par exemple, le service d’extraction disponible dans Windows Server). Les nœuds inscrits auprès d’Azure Automation DSC auront automatiquement des certificats installés et gérés par le service, sans surcharge administrative requise.

Prerequisites

Pour chiffrer correctement les informations d’identification utilisées pour sécuriser une configuration DSC, assurez-vous que vous disposez des éléments suivants :

• Quelques moyens d’émission et de distribution des certificats. Cette rubrique et ses exemples supposent que vous utilisez l’autorité de certification Active Directory. Pour plus d’informations sur les services de certificats Active Directory, consultez Vue d’ensemble des services de certificats Active Directory.
• Accès administratif au(x) noeud(s) cible(s).
• Chaque nœud cible dispose d’un certificat compatible avec le chiffrement enregistré dans son magasin personnel. Dans Windows PowerShell, le chemin d’accès au magasin est Cert :\LocalMachine\My. Les exemples de cette rubrique utilisent le modèle « Authentification du poste de travail », que vous pouvez trouver (avec d’autres modèles de certificat) dans Modèles de certificat par défaut.
• Si vous comptez exécuter cette configuration sur un ordinateur autre que le nœud cible, exportez la clé publique du certificat, puis importez-la sur l’ordinateur à partir duquel vous exécuterez la configuration. Assurez-vous d’exporter uniquement la clé publique ; Protégez la clé privée.

Processus global

1. Configurez les certificats, les clés et les empreintes numériques, en vous assurant que chaque nœud cible dispose de copies du certificat et que l’ordinateur de configuration dispose de la clé publique et de l’empreinte.
2. Créez un bloc de données de configuration qui contient le chemin d’accès et l’empreinte numérique de la clé publique.
3. Créez un script de configuration qui définit la configuration souhaitée pour le nœud cible et configure le déchiffrement sur les nœuds cibles en ordonnant au gestionnaire de configuration local de déchiffrer les données de configuration à l’aide du certificat et de son empreinte.
4. Exécutez la configuration, qui définira les paramètres du Gestionnaire de configuration local et démarrera la configuration DSC.

Exigences relatives aux certificats

Pour mettre en œuvre le chiffrement des informations d’identification, un certificat de clé publique doit être disponible sur le nœud cibleapprouvé par l’ordinateur utilisé pour créer la configuration DSC. Ce certificat de clé publique est soumis à des exigences spécifiques pour être utilisé pour le chiffrement des informations d’identification DSC :

1. Utilisation clé :
   • Doit contenir : 'KeyEncipherment' et 'DataEncipherment'.
   • Ne doit pas contenir : 'Signature numérique'.
2. Utilisation améliorée des clés :
   • Doit contenir : Chiffrement des documents (1.3.6.1.4.1.311.80.1).
   • Ne doit pas contenir : l’authentification du client (1.3.6.1.5.5.7.3.2) et l’authentification du serveur (1.3.6.1.5.5.7.3.1).
3. La clé privée du certificat est disponible sur le Node_ *Target.
4. Le fournisseur du certificat doit être « Microsoft RSA SChannel Cryptographic Provider ».

Tout certificat existant sur le nœud cible qui répond à ces critères peut être utilisé pour sécuriser les informations d’identification DSC.

Création de certificats

Vous pouvez adopter deux approches pour créer et utiliser le certificat de chiffrement requis (paire de clés publique-privée).

1. Créez-la sur le nœud cible et exportez uniquement la clé publique vers le nœud auteur
2. Créez-le sur le nœud de création et exportez l’intégralité de la paire de clés vers le nœud cible

La méthode 1 est recommandée, car la clé privée utilisée pour déchiffrer les informations d’identification dans le MOF reste à tout moment sur le nœud cible.

Création du certificat sur le nœud cible

La clé privée doit être gardée secrète, car elle est utilisée pour déchiffrer le MOF sur le nœud cible . La méthode la plus simple consiste à créer le certificat de clé privée sur le nœud cible et à copier le certificat de clé publique sur l’ordinateur utilisé pour créer la configuration DSC dans un fichier MOF. L’exemple suivant :

1. crée un certificat sur le nœud Target
2. exporte le certificat de clé publique sur le nœud cible.
3. importe le certificat de clé publique dans le magasin de mes certificats sur le nœud Création.

Sur le nœud cible : créez et exportez le certificat

Nœud cible : Windows Server 2016 et 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

Une fois exporté, il DscPublicKey.cer doit être copié sur le nœud de création.

Sur le nœud auteur : importez la clé publique du certificat

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

Création du certificat sur le nœud de création

Le certificat de chiffrement peut également être créé sur le nœud de création, exporté avec la clé privée sous forme de fichier PFX, puis importé sur le nœud cible. Il s’agit de la méthode actuelle d’implémentation du chiffrement des informations d’identification DSC sur Nano Server. Bien que le PFX soit sécurisé par un mot de passe, il doit être conservé en toute sécurité pendant le transport. L’exemple suivant :

1. crée un certificat sur le nœud Authoring.
2. exporte le certificat, y compris la clé privée, sur le nœud Authoring.
3. supprime la clé privée du nœud Création, mais conserve le certificat de clé publique dans ma boutique.
4. importe le certificat de clé privée dans le magasin de certificats My(Personal) sur le nœud cible.
   • il doit être ajouté au magasin racine afin d’être approuvé par le nœud cible.

Sur le nœud auteur : créez et exportez le certificat

Nœud cible : Windows Server 2016 et 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

Une fois exporté, il DscPrivateKey.pfx doit être copié sur le nœud cible.

Sur le nœud cible : importez la clé privée du certificat en tant que racine approuvée

# 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

données de configuration ;

Le bloc de données de configuration définit les nœuds cibles sur lesquels opérer, le chiffrement ou non des informations d’identification, les moyens de chiffrement et d’autres informations. Pour plus d’informations sur le bloc de données de configuration, consultez Séparation des données de configuration et d’environnement.

Les éléments qui peuvent être configurés pour chaque nœud et qui sont liés au chiffrement des informations d’identification sont les suivants :

• NodeName : nom du nœud cible pour lequel le chiffrement des informations d’identification est configuré.
• PsDscAllowPlainTextPassword : indique si les informations d’identification non chiffrées peuvent être transmises à ce nœud. Ce n’est pas recommandé.
• Empreinte numérique : empreinte numérique du certificat qui sera utilisé pour déchiffrer les informations d’identification dans la configuration DSC sur le nœud cible. Ce certificat doit exister dans le magasin de certificats de l’ordinateur local sur le nœud cible.
• CertificateFile : fichier de certificat (contenant uniquement la clé publique) qui doit être utilisé pour chiffrer les informations d’identification du nœud cible. Il doit s’agir d’un fichier de certificat binaire X.509 encodé DER ou au format X.509 encodé en base 64.

Cet exemple montre un bloc de données de configuration qui spécifie un nœud cible sur lequel agir nommé targetNode, le chemin d’accès au fichier de certificat de clé publique (nommé targetNode.cer) et l’empreinte numérique de la clé publique.

$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 configuration

Dans le script de configuration lui-même, utilisez le paramètre pour vous assurer que les PsCredential informations d’identification sont stockées le moins longtemps possible. Lorsque vous exécutez l’exemple fourni, DSC vous demande des informations d’identification, puis chiffre le fichier MOF à l’aide du CertificateFile associé au nœud cible dans le bloc de données de configuration. Cet exemple de code copie un fichier à partir d’un partage sécurisé pour un utilisateur.

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

Configuration du décryptage

Pour que Start-DscConfiguration puisse fonctionner, vous devez indiquer au gestionnaire de configuration local de chaque nœud cible le certificat à utiliser pour déchiffrer les informations d’identification, à l’aide de la ressource CertificateID pour vérifier l’empreinte numérique du certificat. Cet exemple de fonction trouvera le certificat local approprié (vous devrez peut-être le personnaliser pour qu’il trouve le certificat exact que vous souhaitez utiliser) :

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

Avec le certificat identifié par son empreinte, le script de configuration peut être mis à jour pour utiliser la valeur :

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

Exécution de la configuration

À ce stade, vous pouvez exécuter la configuration, qui affichera deux fichiers :

• Fichier *.meta.mof qui configure le gestionnaire de configuration local pour déchiffrer les informations d’identification à l’aide du certificat stocké sur le magasin de machines local et identifié par son empreinte. Set-DscLocalConfigurationManager applique le *.meta.mof fichier.
• Fichier MOF qui applique réellement la configuration. Start-DscConfiguration applique la configuration.

Les commandes suivantes permettent d’accomplir les étapes suivantes :

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

Cet exemple permet d’envoyer la configuration DSC au nœud cible. La configuration DSC peut également être appliquée à l’aide d’un serveur collecteur DSC s’il en existe un.

Pour plus d’informations sur l’application de configurations DSC à l’aide d’un serveur d’extraction DSC, reportez-vous à la section Configuration d’un client d’extraction DSC .

Exemple de module de chiffrement d’informations d’identification

Voici un exemple complet qui intègre toutes ces étapes, ainsi qu’une applet de commande d’assistance qui exporte et copie les clés publiques :

# 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