Partager via

Exemples de scripts Azure Disk Encryption pour machines virtuelles Linux

  • Article

Attention

Cet article fait référence à CentOS, une distribution Linux ayant atteint l’état EOL (fin du service). Faites le point sur votre utilisation et organisez-vous en conséquence. Pour plus d’informations, consultez les conseils d’aide relatifs à la fin de vie de CentOS.

S’applique à : ✔️ Machines virtuelles Linux ✔️ Groupes identiques flexibles

Cet article fournit des exemples de scripts pour la préparation de disques durs virtuels préchiffrés et d’autres tâches.

Notes

Sauf mention contraire, tous les scripts font référence à la dernière version hors AAD d’ADE.

Exemples de scripts PowerShell pour Azure Disk Encryption

  • Répertorier toutes les machines virtuelles chiffrées dans votre abonnement

    Vous pouvez rechercher toutes les machines virtuelles chiffrées avec ADE et la version de l’extension, dans tous les groupes de ressources d’un abonnement, à l’aide de ce script PowerShell.

    À l’inverse, ces cmdlets affichent toutes les machines virtuelles chiffrées avec ADE (sans la version de l’extension) :

    $osVolEncrypted = {(Get-AzVMDiskEncryptionStatus -ResourceGroupName $_.ResourceGroupName -VMName $_.Name).OsVolumeEncrypted}
$dataVolEncrypted= {(Get-AzVMDiskEncryptionStatus -ResourceGroupName $_.ResourceGroupName -VMName $_.Name).DataVolumesEncrypted}
Get-AzVm | Format-Table @{Label="MachineName"; Expression={$_.Name}}, @{Label="OsVolumeEncrypted"; Expression=$osVolEncrypted}, @{Label="DataVolumesEncrypted"; Expression=$dataVolEncrypted}

  • Répertorier toutes les instances VMSS chiffrées de votre abonnement

    Vous pouvez rechercher toutes les instances VMSS chiffrées avec ADE et la version de l’extension, dans tous les groupes de ressources d’un abonnement, à l’aide de ce script PowerShell.

  • Répertorier tous les secrets de chiffrement de disque utilisées pour chiffrer les machines virtuelles dans un coffre de clés

    Get-AzKeyVaultSecret -VaultName $KeyVaultName | where {$_.Tags.ContainsKey('DiskEncryptionKeyFileName')} | format-table @{Label="MachineName"; Expression={$_.Tags['MachineName']}}, @{Label="VolumeLetter"; Expression={$_.Tags['VolumeLetter']}}, @{Label="EncryptionKeyURL"; Expression={$_.Id}}

Utilisation du script PowerShell des prérequis Azure Disk Encryption

Si vous êtes déjà familiarisé avec les prérequis d’Azure Disk Encryption, vous pouvez utiliser le script PowerShell des prérequis d’Azure Disk Encryption. Vous trouverez un exemple d’utilisation de ce script PowerShell dans Démarrage rapide du chiffrement d’une machine virtuelle. Vous pouvez supprimer les commentaires d’une section du script, en commençant à la ligne 211, pour chiffrer tous les disques des machines virtuelles d’un groupe de ressources existant.

Le tableau suivant présente les paramètres pouvant être utilisés dans le script PowerShell :

Paramètre Description Obligatoire ?
$resourceGroupName Nom du groupe de ressources auquel appartient le coffre de clés. Un groupe de ressources portant ce nom sera créé s’il n’existe pas encore. True
$keyVaultName Nom du coffre de clés dans lequel les clés de chiffrement doivent être placées. Un coffre portant ce nom sera créé s’il n’existe pas encore. True
$location Emplacement du coffre de clés. Assurez-vous que le coffre de clés et les machines virtuelles à chiffrer se trouvent au même emplacement. Obtenez une liste des emplacements avec Get-AzLocation. True
$subscriptionId Identificateur de l’abonnement Azure à utiliser. Vous pouvez obtenir votre ID d’abonnement avec Get-AzSubscription. True
$aadAppName Nom de l’application Microsoft Entra utilisée pour écrire des secrets dans KeyVault. S’il n’existe aucune application de ce nom, une nouvelle application sera créée en utilisant le nom que vous avez saisi. Si cette application existe déjà, appliquez le paramètre aadClientSecret au script. False
$aadClientSecret Secret client de l’application Microsoft Entra qui a été créée précédemment. False
$keyEncryptionKeyName Nom de la clé de chiffrement principale facultative dans KeyVault. Une clé portant ce nom sera créée si elle n’existe pas encore. False

Chiffrer ou déchiffrer des machines virtuelles sans application Microsoft Entra

Chiffrer ou déchiffrer des machines virtuelles avec une application Microsoft Entra (version précédente)

Chiffrement d’un lecteur du système d’exploitation sur une machine virtuelle Linux en cours d’exécution

Configuration requise pour le chiffrement du lecteur du système d’exploitation

  • La machine virtuelle doit utiliser une distribution compatible avec le chiffrement de disque du système d’exploitation, comme indiqué dans Systèmes d’exploitation pris en charge avec Azure Disk Encryption.
  • La machine virtuelle doit être créée à partir de l’image Marketplace dans Azure Resource Manager.
  • Machine virtuelle Azure au moins 4 Go de RAM (la taille recommandée est de 7 Go). Pour plus d’informations, consultez Configuration requise en mémoire.
  • (Pour RHEL et CentOS) Désactivez SELinux. Pour désactiver SELinux, consultez la rubrique « 4.4.2. Désactivation de SELinux » dans le Guide d’utilisation et d’administration SELinux sur la machine virtuelle.
  • Après avoir désactivé SELinux, redémarrez au moins une fois la machine virtuelle.

Étapes

  1. Créez une machine virtuelle en utilisant l’une des distributions spécifiées précédemment.

  2. Configurez la machine virtuelle selon vos besoins. Si vous souhaitez chiffrer tous les lecteurs (de données et du système d’exploitation), les lecteurs de données doivent être spécifiés et montables à partir de /etc/fstab.

    Notes

    Utilisez UUID =... pour définir les lecteurs de données dans /etc/fstab au lieu de spécifier le nom de l’appareil de traitement par blocs (par exemple, /dev/sdb1). L’ordre des lecteurs sur la machine virtuelle est modifié au cours du chiffrement. Si votre machine virtuelle s’appuie sur un ordre spécifique d’appareils de traitement par blocs, leur montage échouera après le chiffrement.

  3. Déconnectez-vous des sessions SSH.

  4. Pour chiffrer le système d’exploitation, spécifiez All ou OS pour VolumeType quand vous activez le chiffrement.

    Notes

    Tous les processus d’espace utilisateur qui ne s’exécutent pas en tant que services systemd doivent être arrêtés avec un SIGKILL. Redémarrez la machine virtuelle. Lorsque vous activez le chiffrement du lecteur du système d’exploitation sur une machine virtuelle en cours d’exécution, prévoyez un temps d’arrêt de la machine virtuelle.

  5. Surveillez régulièrement la progression du chiffrement à l’aide des instructions fournies dans la section suivante.

  6. Lorsque Get-AzVmDiskEncryptionStatus indique « VMRestartPending », redémarrez votre machine virtuelle en vous y connectant ou bien en utilisant le portail, PowerShell ou CLI.

    C:\> Get-AzVmDiskEncryptionStatus  -ResourceGroupName $ResourceGroupName -VMName $VMName
-ExtensionName $ExtensionName

    OsVolumeEncrypted          : VMRestartPending
DataVolumesEncrypted       : NotMounted
OsVolumeEncryptionSettings : Microsoft.Azure.Management.Compute.Models.DiskEncryptionSettings
ProgressMessage            : OS disk successfully encrypted, reboot the VM

    Avant le redémarrage, nous vous recommandons d’enregistrer les diagnostics de démarrage de la machine virtuelle.

Surveillance de la progression du chiffrement du système d’exploitation

Il existe trois façons de surveiller la progression du chiffrement du système d’exploitation :

  • Utilisez l’applet de commande Get-AzVmDiskEncryptionStatus et examinez le champ ProgressMessage :

    Get-AzVMDiskEncryptionStatus -ResourceGroupName $_.ResourceGroupName -VMName $_.Name

    OsVolumeEncrypted          : EncryptionInProgress
DataVolumesEncrypted       : NotMounted
OsVolumeEncryptionSettings : Microsoft.Azure.Management.Compute.Models.DiskEncryptionSettings
ProgressMessage            : OS disk encryption started

    Dès que la machine virtuelle passe à l’état « Le chiffrement du lecteur du système d’exploitation a démarré », l’opération prend entre 40 et 50 minutes sur une machine virtuelle avec un stockage Premium.

    En raison de l’erreur #388 dans WALinuxAgent, OsVolumeEncrypted et DataVolumesEncrypted apparaissent comme Unknown dans certaines distributions. Ce problème est résolu automatiquement dans WALinuxAgent version 2.1.5 et ultérieure. Si Unknown s’affiche dans la sortie, vous pouvez vérifier l’état du chiffrement du disque en utilisant l’Explorateur de ressources Azure.

    Accédez à l’Explorateur de ressources Azure, puis développez cette hiérarchie dans le panneau de sélection de gauche :

    |-- subscriptions
   |-- [Your subscription]
        |-- resourceGroups
             |-- [Your resource group]
                  |-- providers
                       |-- Microsoft.Compute
                            |-- virtualMachines
                                 |-- [Your virtual machine]
                                      |-- InstanceView

    Faites défiler InstanceView pour afficher l’état de chiffrement de vos lecteurs.

    Vue d’instance de machine virtuelle

  • Recherchez les diagnostics de démarrage. Les messages de l’extension ADE doivent être précédés du préfixe [AzureDiskEncryption].

  • Connectez-vous à la machine virtuelle via SSH et obtenez le journal des extensions à partir de :

    /var/log/azure/Microsoft.Azure.Security.AzureDiskEncryptionForLinux

    Nous vous déconseillons de vous connecter à la machine virtuelle lorsque le chiffrement du système d’exploitation est en cours. Copiez les journaux d’activité uniquement lorsque les deux autres méthodes ont échoué.

Préparer un disque dur virtuel Linux déjà chiffré

La préparation des disques durs virtuels préchiffrés peut varier en fonction de la distribution. Des exemples sur la préparation d’Ubuntu, openSUSE et CentOS 7 sont disponibles.

Configurez le chiffrement lors de l’installation de la distribution en procédant comme suit :

  1. Sélectionnez Configure encrypted volumes (Configurer les volumes chiffrés) lors du partitionnement des disques.

    Configuration Ubuntu 16.04 - Configurer les volumes chiffrés

  2. Créez un lecteur de démarrage séparé qui ne doit pas être chiffré. Chiffrez votre lecteur racine.

    Configuration Ubuntu 16.04 - Sélectionner les appareils à chiffrer

  3. Indiquez une phrase secrète. Il s’agit de la phrase secrète que vous avez chargée dans le coffre de clés.

    Configuration Ubuntu 16.04 - Fournir la phrase secrète

  4. Terminez le partitionnement.

    Configuration Ubuntu 16.04 - Terminer le partitionnement

  5. Lorsque vous démarrez la machine virtuelle et devez fournir une phrase secrète, utilisez la phrase secrète que vous avez fournie à l’étape 3.

    Configuration Ubuntu 16.04 - Fournir la phrase secrète au démarrage

  6. Préparez la machine virtuelle au chargement dans Azure en suivant ces instructions. N’exécutez pas encore la dernière étape (annulation de l’approvisionnement de la machine virtuelle).

Configurez le chiffrement pour l’utiliser dans Azure en effectuant les étapes suivantes :

  1. Créez un fichier sous /usr/local/sbin/azure_crypt_key.sh à l’aide du contenu dans le script suivant. Prêtez une attention particulière à KeyFileName, car il s’agit du nom de fichier de phrase secrète utilisé par Azure.

    #!/bin/sh
MountPoint=/tmp-keydisk-mount
KeyFileName=LinuxPassPhraseFileName
echo "Trying to get the key from disks ..." >&2
mkdir -p $MountPoint
modprobe vfat >/dev/null 2>&1
modprobe ntfs >/dev/null 2>&1
sleep 2
OPENED=0
cd /sys/block
for DEV in sd*; do

    echo "> Trying device: $DEV ..." >&2
    mount -t vfat -r /dev/${DEV}1 $MountPoint >/dev/null||
    mount -t ntfs -r /dev/${DEV}1 $MountPoint >/dev/null
    if [ -f $MountPoint/$KeyFileName ]; then
            cat $MountPoint/$KeyFileName
            umount $MountPoint 2>/dev/null
            OPENED=1
            break
    fi
    umount $MountPoint 2>/dev/null
done

  if [ $OPENED -eq 0 ]; then
    echo "FAILED to find suitable passphrase file ..." >&2
    echo -n "Try to enter your password: " >&2
    read -s -r A </dev/console
    echo -n "$A"
 else
    echo "Success loading keyfile!" >&2
fi

  2. Modifiez la configuration du chiffrement dans /etc/crypttab. Il doit se présenter comme suit :

     xxx_crypt uuid=xxxxxxxxxxxxxxxxxxxxx none luks,discard,keyscript=/usr/local/sbin/azure_crypt_key.sh

  3. Ajoutez des autorisations exécutables au script :

     sudo chmod +x /usr/local/sbin/azure_crypt_key.sh

  4. Éditez /etc/initramfs-tools/modules en ajoutant des lignes :

     vfat
 ntfs
 nls_cp437
 nls_utf8
 nls_iso8859-1

  5. Exécutez update-initramfs -u -k all pour mettre à jour l’initramfs afin de mettre en vigueur le keyscript.

  6. Vous pouvez maintenant annuler l’approvisionnement de la machine virtuelle.

    Configuration d’Ubuntu 16.04 - update-initramfs

  7. Passez à l’étape suivante et chargez votre disque dur virtuel dans Azure.

Télécharger des disques durs virtuels cryptés dans un compte de stockage Azure

Une fois le chiffrement DM-Crypt activé, le disque dur virtuel chiffré local doit être chargé sur votre compte de stockage.

    Add-AzVhd [-Destination] <Uri> [-LocalFilePath] <FileInfo> [[-NumberOfUploaderThreads] <Int32> ] [[-BaseImageUriToPatch] <Uri> ] [[-OverWrite]] [ <CommonParameters>]

Charger le secret pour la machine virtuelle préchiffrée dans votre coffre de clés

Quand vous chiffrez une machine virtuelle avec une application Microsoft Entra (version précédente), le secret de chiffrement de disque obtenu précédemment doit être chargé comme secret dans votre coffre de clés. Le coffre de clés doit avoir le chiffrement de disque et des autorisations activés pour votre client Microsoft Entra.

 $AadClientId = "My-AAD-Client-Id"
 $AadClientSecret = "My-AAD-Client-Secret"

 $key vault = New-AzKeyVault -VaultName $KeyVaultName -ResourceGroupName $ResourceGroupName -Location $Location

 Set-AzKeyVaultAccessPolicy -VaultName $KeyVaultName -ResourceGroupName $ResourceGroupName -ServicePrincipalName $AadClientId -PermissionsToKeys all -PermissionsToSecrets all
 Set-AzKeyVaultAccessPolicy -VaultName $KeyVaultName -ResourceGroupName $ResourceGroupName -EnabledForDiskEncryption

La clé secrète de chiffrement de disque non chiffré avec une clé de chiffrement à clé KEK

Utilisez Set-AzKeyVaultSecret pour configurer la clé secrète dans votre coffre de clés. La phrase secrète est encodée sous forme de chaîne en base64, puis chargée dans le coffre de clés. Assurez-vous également que les balises suivantes sont définies lors de la création de la clé secrète dans le coffre de clés.


 # This is the passphrase that was provided for encryption during the distribution installation
 $passphrase = "contoso-password"

 $tags = @{"DiskEncryptionKeyEncryptionAlgorithm" = "RSA-OAEP"; "DiskEncryptionKeyFileName" = "LinuxPassPhraseFileName"}
 $secretName = [guid]::NewGuid().ToString()
 $secretValue = [Convert]::ToBase64String([System.Text.Encoding]::ASCII.GetBytes($passphrase))
 $secureSecretValue = ConvertTo-SecureString $secretValue -AsPlainText -Force

 $secret = Set-AzKeyVaultSecret -VaultName $KeyVaultName -Name $secretName -SecretValue $secureSecretValue -tags $tags
 $secretUrl = $secret.Id

Utilisez $secretUrl à l’étape suivante pour attacher le lecteur du système d’exploitation sans utiliser de clé de chiffrement à clé.

Disque chiffré avec une clé secrète de chiffrement de disque à clé KEK

Avant de télécharger la clé secrète dans le coffre de clés, vous pouvez éventuellement la chiffrer à l’aide d’une clé de chiffrement à clé. Utilisez l’API de retour à la ligne pour chiffrer d’abord la clé secrète à l’aide de la clé de chiffrement à clé. La sortie de cette opération de retour à la ligne est une chaîne d’URL encodée en base64 que vous pouvez ensuite charger comme clé secrète à l’aide de l’applet de commande Set-AzKeyVaultSecret.

    # This is the passphrase that was provided for encryption during the distribution installation
    $passphrase = "contoso-password"

    Add-AzKeyVaultKey -VaultName $KeyVaultName -Name "keyencryptionkey" -Destination Software
    $KeyEncryptionKey = Get-AzKeyVaultKey -VaultName $KeyVault.OriginalVault.Name -Name "keyencryptionkey"

    $apiversion = "2015-06-01"

    ##############################
    # Get Auth URI
    ##############################

    $uri = $KeyVault.VaultUri + "/keys"
    $headers = @{}

    $response = try { Invoke-RestMethod -Method GET -Uri $uri -Headers $headers } catch { $_.Exception.Response }

    $authHeader = $response.Headers["www-authenticate"]
    $authUri = [regex]::match($authHeader, 'authorization="(.*?)"').Groups[1].Value

    Write-Host "Got Auth URI successfully"

    ##############################
    # Get Auth Token
    ##############################

    $uri = $authUri + "/oauth2/token"
    $body = "grant_type=client_credentials"
    $body += "&client_id=" + $AadClientId
    $body += "&client_secret=" + [Uri]::EscapeDataString($AadClientSecret)
    $body += "&resource=" + [Uri]::EscapeDataString("https://vault.azure.net")
    $headers = @{}

    $response = Invoke-RestMethod -Method POST -Uri $uri -Headers $headers -Body $body

    $access_token = $response.access_token

    Write-Host "Got Auth Token successfully"

    ##############################
    # Get KEK info
    ##############################

    $uri = $KeyEncryptionKey.Id + "?api-version=" + $apiversion
    $headers = @{"Authorization" = "Bearer " + $access_token}

    $response = Invoke-RestMethod -Method GET -Uri $uri -Headers $headers

    $keyid = $response.key.kid

    Write-Host "Got KEK info successfully"

    ##############################
    # Encrypt passphrase using KEK
    ##############################

    $passphraseB64 = [Convert]::ToBase64String([System.Text.Encoding]::ASCII.GetBytes($Passphrase))
    $uri = $keyid + "/encrypt?api-version=" + $apiversion
    $headers = @{"Authorization" = "Bearer " + $access_token; "Content-Type" = "application/json"}
    $bodyObj = @{"alg" = "RSA-OAEP"; "value" = $passphraseB64}
    $body = $bodyObj | ConvertTo-Json

    $response = Invoke-RestMethod -Method POST -Uri $uri -Headers $headers -Body $body

    $wrappedSecret = $response.value

    Write-Host "Encrypted passphrase successfully"

    ##############################
    # Store secret
    ##############################

    $secretName = [guid]::NewGuid().ToString()
    $uri = $KeyVault.VaultUri + "/secrets/" + $secretName + "?api-version=" + $apiversion
    $secretAttributes = @{"enabled" = $true}
    $secretTags = @{"DiskEncryptionKeyEncryptionAlgorithm" = "RSA-OAEP"; "DiskEncryptionKeyFileName" = "LinuxPassPhraseFileName"}
    $headers = @{"Authorization" = "Bearer " + $access_token; "Content-Type" = "application/json"}
    $bodyObj = @{"value" = $wrappedSecret; "attributes" = $secretAttributes; "tags" = $secretTags}
    $body = $bodyObj | ConvertTo-Json

    $response = Invoke-RestMethod -Method PUT -Uri $uri -Headers $headers -Body $body

    Write-Host "Stored secret successfully"

    $secretUrl = $response.id

Utilisez $KeyEncryptionKey et $secretUrl à l’étape suivante pour attacher le lecteur du système d’exploitation à l’aide de la clé de chiffrement à clé.

Spécifier une URL secrète lorsque vous attachez un lecteur de système d’exploitation

Sans utiliser de clé de chiffrement à clé KEK

Lorsque vous attachez le lecteur du système d’exploitation, exécutez la commande $secretUrl. L’URL a été générée dans la section « La clé secrète de chiffrement de disque non chiffrée avec une clé de chiffrement à clé ».

    Set-AzVMOSDisk `
            -VM $VirtualMachine `
            -Name $OSDiskName `
            -SourceImageUri $VhdUri `
            -VhdUri $OSDiskUri `
            -Linux `
            -CreateOption FromImage `
            -DiskEncryptionKeyVaultId $KeyVault.ResourceId `
            -DiskEncryptionKeyUrl $SecretUrl

À l’aide d’une clé de chiffrement à clé KEK

Lorsque vous attachez le lecteur du système d’exploitation, exécutez les commandes $KeyEncryptionKey et $secretUrl. L’URL a été générée dans la section « Secret de chiffrement de disque chiffré avec une clé KEK ».

    Set-AzVMOSDisk `
            -VM $VirtualMachine `
            -Name $OSDiskName `
            -SourceImageUri $CopiedTemplateBlobUri `
            -VhdUri $OSDiskUri `
            -Linux `
            -CreateOption FromImage `
            -DiskEncryptionKeyVaultId $KeyVault.ResourceId `
            -DiskEncryptionKeyUrl $SecretUrl `
            -KeyEncryptionKeyVaultId $KeyVault.ResourceId `
            -KeyEncryptionKeyURL $KeyEncryptionKey.Id