Chiffrer des disques avec des clés fournies par le client

Linux Windows

Cet article fournit des informations sur le chiffrement des disques avec des clés de chiffrement fournies par le client.

Pour en savoir plus sur le chiffrement du disque, consultez la page À propos du chiffrement du disque.

Pour en savoir plus sur le chiffrement des disques avec des clés de chiffrement gérées par le client (CMEK), consultez la page Protéger les ressources à l'aide de clés Cloud KMS.

L'utilisation de clés CSEK signifie que vous fournissez vos propres clés de chiffrement, et que Compute Engine utilise vos clés pour protéger les clés générées par Google permettant de chiffrer et de déchiffrer vos données. Seuls les utilisateurs qui fournissent la clé correcte peuvent utiliser les ressources protégées par une clé de chiffrement fournie par le client (CSEK).

Google ne stocke pas vos clés sur ses serveurs et ne peut accéder à vos données protégées que si vous fournissez la clé appropriée. Par conséquent, si vous l'oubliez ou la perdez, il est impossible pour Google de la récupérer ou de récupérer les données chiffrées avec la clé perdue.

Lorsque vous supprimez un disque persistant, Google supprime les clés de chiffrement, ce qui rend les données irrécupérables. Ce processus est irréversible.

Avant de commencer

Lisez les sections consacrées aux disques, aux images et aux instantanés de disque.
Si ce n'est pas déjà fait, configurez l'authentification. L'authentification est le processus permettant de valider votre identité pour accéder aux services et aux API Google Cloud. Pour exécuter du code ou des exemples depuis un environnement de développement local, vous pouvez vous authentifier auprès de Compute Engine comme suit :

Sélectionnez l'onglet correspondant à la façon dont vous prévoyez d'utiliser les exemples de cette page :
Console

Lorsque vous utilisez la console Google Cloud pour accéder aux services et aux API Google Cloud, vous n'avez pas besoin de configurer l'authentification.
gcloud
1. Installez Google Cloud CLI, puis initialisez-la en exécutant la commande suivante :
```
gcloud init
```
  Remarque : Si vous avez déjà installé gcloud CLI, assurez-vous que vous disposez de la dernière version en exécutant gcloud components update.
2. Définissez une région et une zone par défaut.
Python

Pour utiliser les exemples Python de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.
1. Installez Google Cloud CLI.
2. Pour initialiser gcloudCLI, exécutez la commande suivante :
```
gcloud init
```
3. Créez des identifiants d'authentification locaux pour votre compte Google :
```
gcloud auth application-default login
```
Pour en savoir plus, consultez les sections sur Configurer l'authentification pour un environnement de développement local.
REST

Pour utiliser les exemples d'API REST de cette page dans un environnement de développement local, vous devez utiliser les identifiants que vous fournissez à gcloud CLI.

Restrictions

Pour les clés CSEK, les restrictions suivantes s'appliquent :

Restrictions générales

La disponibilité des clés de chiffrement fournies par le client dépend de l'emplacement de votre compte de facturation, et non de l'emplacement de la ressource.

Les clés de chiffrement fournies par le client ne sont pas disponibles pour les comptes de facturation situés dans les pays suivants :

Brésil
Inde

Restrictions techniques

Vous pouvez chiffrer les nouveaux disques persistants avec votre propre clé, mais pas les disques persistants existants.
Vous ne pouvez pas utiliser vos propres clés avec des disques SSD locaux, car ces disques ne persistent pas au-delà de la durée de vie d'une VM. En outre, les disques SSD locaux sont déjà protégés par une clé de chiffrement éphémère que Google ne conserve pas.
Compute Engine ne stocke pas de clés de chiffrement avec les modèles d'instances. Vous devez donc stocker vos propres clés dans le service de gestion des clés pour chiffrer les disques dans un groupe d'instances géré.
Vous ne pouvez pas suspendre des instances auxquelles des disques protégés par CSEK sont associés.

Spécifications

Cette section décrit la spécification du chiffrement et le format des clés CSEK.

Chiffrement

Compute Engine utilise votre clé de chiffrement pour protéger les clés de chiffrement de Google via le standard AES-256.

Format de clé requis

C'est à vous de générer et de gérer votre clé. Elle doit être composée d'une chaîne de 256 bits codée selon le standard RFC 4648 base64 pour Compute Engine.

Voici un exemple de clé encodée en base64, générée avec la chaîne "Hello from Google Cloud Platform"

SGVsbG8gZnJvbSBHb29nbGUgQ2xvdWQgUGxhdGZvcm0=

Elle peut être générée via le script suivant :

read -sp "String:" ; \
    [[ ${#REPLY} == 32 ]] && \
        echo "$(echo -n "$REPLY" | base64)" || \
        (>&2 echo -e "\nERROR:Wrong Size"; false)

Encapsuler une clé RSA

Outre l'encodage de votre clé en base64, vous pouvez, en option, l'encapsuler à l'aide d'un certificat de clé publique RSA fourni par Google, l'encoder en base64, puis l'utiliser dans vos requêtes.

L'encapsulation RSA est un processus dans lequel vous utilisez une clé publique pour chiffrer vos données. Une fois ces données chiffrées avec la clé publique, elles ne peuvent être déchiffrées que par la clé privée correspondante. Dans ce cas, la clé privée n'est connue que des services Google Cloud. En encapsulant votre clé à l'aide du certificat RSA, vous vous assurez que seuls les services Google Cloud peuvent la désencapsuler et l'utiliser pour protéger vos données.

Pour plus d'informations, consultez la page sur le chiffrement RSA.

Pour créer une clé encapsulée en RSA pour Compute Engine, procédez comme suit :

encapsuler votre clé à l'aide de la clé publique fournie dans un certificat géré par Compute Engine (veillez à effectuer l'encapsulation via le remplissage OAEP, et non via le remplissage PKCS #1 v1.5) ;
encoder votre clé encapsulée en RSA via un encodage standard en base64.

Téléchargez le certificat public géré par Compute Engine à partir de :

https://cloud-certs.storage.googleapis.com/google-cloud-csek-ingress.pem

Il y a plusieurs façons de générer et de stocker votre clé RSA. Utilisez une méthode qui vous est familière. Vous trouverez ci-dessous deux exemples d'encapsulation RSA que vous pouvez utiliser.

Exemple 1

Les instructions suivantes, qui permettent d'encapsuler une clé en RSA et de l'encoder, fonctionnent avec l'utilitaire de ligne de commande openssl.

Facultatif : générez une clé aléatoire de 256 bits (32 octets). Si vous disposez déjà d'une clé que vous souhaitez utiliser, vous pouvez ignorer cette étape. Il existe de nombreuses manières de générer une clé. Exemple :
```
$ head -c 32 /dev/urandom | LC_CTYPE=C tr '\n' = > mykey.txt
```

Téléchargez le certificat de clé publique :

$  curl -s -O -L https://cloud-certs.storage.googleapis.com/google-cloud-csek-ingress.pem

Extrayez la clé publique du certificat :

$ openssl x509 -pubkey -noout -in google-cloud-csek-ingress.pem > pubkey.pem

Encapsulez votre clé en RSA, en veillant à remplacer mykey.txt par votre propre fichier de clé.

$ openssl rsautl -oaep -encrypt -pubin -inkey pubkey.pem -in mykey.txt -out rsawrappedkey.txt

Encodez en base64 votre clé encapsulée en RSA.

$ openssl enc -base64 -in rsawrappedkey.txt | tr -d '\n' | sed -e '$a\' > rsawrapencodedkey.txt

Exemple 2

Voici un exemple de script Python, qui montre la génération d'une chaîne aléatoire de 256 bits (32 octets) et la création d'une clé encapsulée en RSA encodée en base64 à l'aide de la bibliothèque cryptography :

compute/encryption/generate_wrapped_rsa_key.py

Afficher sur GitHub Commentaires

import argparse
import base64
import os
from typing import Optional

from cryptography import x509
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives.asymmetric.rsa import RSAPublicKey
import requests

GOOGLE_PUBLIC_CERT_URL = (
    "https://cloud-certs.storage.googleapis.com/google-cloud-csek-ingress.pem"
)

def get_google_public_cert_key() -> RSAPublicKey:
    """
    Downloads the Google public certificate.

    Returns:
        RSAPublicKey object with the Google public certificate.
    """
    r = requests.get(GOOGLE_PUBLIC_CERT_URL)
    r.raise_for_status()

    # Load the certificate.
    certificate = x509.load_pem_x509_certificate(r.content, default_backend())

    # Get the certicate's public key.
    public_key = certificate.public_key()

    return public_key

def wrap_rsa_key(public_key: RSAPublicKey, private_key_bytes: bytes) -> bytes:
    """
    Use the Google public key to encrypt the customer private key.

    This means that only the Google private key is capable of decrypting
    the customer private key.

    Args:
        public_key: The public key to use for encrypting.
        private_key_bytes: The private key to be encrypted.

    Returns:
        private_key_bytes encrypted using the public_key. Encoded using
        base64.
    """
    wrapped_key = public_key.encrypt(
        private_key_bytes,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA1()),
            algorithm=hashes.SHA1(),
            label=None,
        ),
    )
    encoded_wrapped_key = base64.b64encode(wrapped_key)
    return encoded_wrapped_key

def main(key_file: Optional[str]) -> None:
    """
    This script will encrypt a private key with Google public key.

    Args:
        key_file: path to a file containing your private key. If not
            provided, a new key will be generated (256 bit).
    """
    # Generate a new 256-bit private key if no key is specified.
    if not key_file:
        customer_key_bytes = os.urandom(32)
    else:
        with open(key_file, "rb") as f:
            customer_key_bytes = f.read()

    google_public_key = get_google_public_cert_key()
    wrapped_rsa_key = wrap_rsa_key(google_public_key, customer_key_bytes)

    b64_key = base64.b64encode(customer_key_bytes).decode("utf-8")

    print(f"Base-64 encoded private key: {b64_key}")
    print(f"Wrapped RSA key: {wrapped_rsa_key.decode('utf-8')}")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument("--key_file", help="File containing your binary private key.")

    args = parser.parse_args()

    main(args.key_file)

Votre clé est maintenant prête à être utilisée.

Utiliser une clé encapsulée en RSA

Dans Google Cloud CLI, vous pouvez fournir une clé normale et une clé encapsulée en RSA de la même manière.

Dans l'API, utilisez la propriété sha256 au lieu de rawKey si vous souhaitez utiliser une clé encapsulée en RSA.

Chiffrer des ressources avec des clés CSEK à l'aide de l'outil de ligne de commande

Prérequis

Les clés de chiffrement peuvent être utilisées via Google Cloud CLI.

Téléchargez et installez gcloud.

Fichier de clé

Lorsque vous utilisez l'outil de ligne de commande gcloud compute pour configurer vos clés, vous fournissez les clés encodées par le biais d'un fichier qui les répertorie sous la forme d'une liste JSON. Un fichier de clé peut contenir plusieurs clés, ce qui vous permet de les gérer toutes en un seul endroit. Vous pouvez également créer un fichier par clé, pour les gérer séparément. Un fichier de clé ne peut être utilisé qu'avec gcloud CLI. Lorsque vous utilisez REST, vous devez indiquer la clé directement dans votre requête.

Chaque entrée de votre fichier de clé doit fournir :

L'URI complète de la ressource protégée par la clé
La clé correspondante
le type de clé, raw ou rsa-encrypted.

Lorsque vous utilisez le fichier de clé dans vos requêtes, l'outil recherche les ressources correspondantes et utilise les clés appropriées. Si aucune ressource correspondante n'est trouvée, la requête échoue.

Un fichier de clé ressemble à ceci (par exemple) :

[
  {
  "uri": "https://www.googleapis.com/compute/v1/projects/myproject/zones/us-central1-a/disks/example-disk",
  "key": "acXTX3rxrKAFTF0tYVLvydU1riRZTvUNC4g5I11NY+c=",
  "key-type": "raw"
  },
  {
  "uri": "https://www.googleapis.com/compute/v1/projects/myproject/global/snapshots/my-private-snapshot",
  "key": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA==",
  "key-type": "rsa-encrypted"
  }
]

Bonnes pratiques pour la gestion de vos fichiers de clé

Si vous utilisez un fichier de clé, limitez l'accès à votre fichier aux seules personnes qui en ont besoin. Assurez-vous de définir les autorisations appropriées et envisagez de chiffrer ces fichiers à l'aide d'outils supplémentaires :

Sous Windows, vous pouvez utiliser BitLocker ou Encrypting File System (EFS).
Sous macOS, essayez FileVault 2.
Sous Linux, vous pouvez envisager de recourir à Linux Unified Key Setup (LUKS) ou à eCryptfs.

Chiffrer un nouveau disque persistant avec des clés CSEK

Vous pouvez chiffrer un nouveau disque persistant en fournissant une clé lors de la création de la VM ou du disque.

Console

Accédez à la page Disques.

Accéder à la page Disques
Cliquez sur Créer un disque et saisissez les propriétés du nouveau disque.
Sous Chiffrement, sélectionnez Clé gérée par le client.
Dans la zone de texte, indiquez la clé de chiffrement du disque et sélectionnez Clé de chiffrement de clé si la clé a été encapsulée avec la clé publique RSA.

gcloud

Dans l'outil gcloud compute, vous pouvez chiffrer un disque à l'aide de l'option --csek-key-file lors de la création d'une VM. Si vous utilisez une clé encapsulée en RSA, servez-vous du composant gcloud beta :

gcloud (beta) compute instances create example-instance --csek-key-file example-file.json

Pour chiffrer un disque persistant autonome :

gcloud (beta) compute disks create example-disk --csek-key-file example-file.json

REST

Pour chiffrer un disque, utilisez la propriété diskEncryptionKey et envoyez une requête à l'API v1 pour obtenir une clé brute (non encapsulée en RSA) ou à l'API bêta pour obtenir une clé encapsulée en RSA. Dans votre requête, indiquez l'une des propriétés suivantes :

rawKey : si votre clé est encodée en base64.
rsaEncryptedKey : si votre clé est encapsulée en RSA et encodée en base64.

Par exemple, pour chiffrer un nouveau disque lors de la création de la VM avec une clé encapsulée en RSA :

POST https://compute.googleapis.com/compute/beta/projects/myproject/zones/us-central1-a/instances

{
"machineType": "zones/us-central1-a/machineTypes/e2-standard-2",
"disks": [
 {
  "type": "PERSISTENT",
  "diskEncryptionKey": {
    "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  },
  "initializeParams": {
   "sourceImage": "projects/debian-cloud/global/images/debian-9-stretch-v20170619"
  },
  "boot": true
 }
],
...
}

De même, vous pouvez utiliser REST pour créer un disque persistant autonome et le chiffrer avec votre propre clé :

POST https://compute.googleapis.com/compute/beta/projects/myproject/zones/
us-central1-a/disks?sourceImage=https%3A%2F%2Fwww.googleapis.com%2Fcompute%2F
alpha%2Fprojects%2Fdebian-cloud%2Fglobal%2Fimages%2Fdebian-9-stretch-v20170619

{
 "name": "new-encrypted-disk-key",
 "diskEncryptionKey": {
   "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  },
 "type": "zones/us-central1-a/diskTypes/pd-standard"
}

Créer un instantané à partir d'un disque chiffré avec une clé CSEK

Si vous créez un instantané à partir d'un disque chiffré, l'instantané doit également être chiffré. Pour chiffrer l'instantané, vous devez spécifier une clé. Il est impossible de modifier des disques ou des instantanés chiffrés pour qu'ils utilisent le chiffrement Compute Engine par défaut, sauf si vous créez une image disque et un disque persistant.

Les instantanés de disques chiffrés avec des CSEK sont toujours des instantanés complets. Ils diffèrent des instantanés de disques chiffrés avec des clés de chiffrement gérées par le client (CMEK) qui sont incrémentiels. Les instantanés sont facturés en fonction de leur taille totale. Un instantané complet peut donc coûter plus cher qu'un instantané incrémentiel.

Pour créer un instantané de disque persistant à partir d'un disque chiffré, votre requête de création d'instantané doit inclure la clé de chiffrement que vous avez utilisée pour chiffrer le disque persistant.

Consultez les bonnes pratiques pour les instantanés de disque persistant avant de créer votre instantané.

Console

Accéder à la page Instantanés.

Accéder à la section "Instantanés"
Cliquez sur Create snapshot (Créer un instantané).
Sous Disque source, choisissez le disque chiffré dont vous souhaitez créer un instantané.
Dans la zone de texte, indiquez la clé de chiffrement du disque et sélectionnez Clé de chiffrement de clé si la clé a été encapsulée avec la clé publique RSA.
Chiffrez le nouvel instantané en fournissant une clé de chiffrement supplémentaire dans la section Chiffrement.

REST

Pour envoyer la requête, indiquez la propriété sourceDiskEncryptionKey afin d'accéder au disque persistant source. Vous devez chiffrer le nouvel instantané à l'aide de la propriété snapshotEncryptionKey.

Envoyez une requête à l'API v1 pour obtenir une clé brute (non encapsulée en RSA) ou à l'API bêta pour obtenir une clé encapsulée en RSA.

POST https://compute.googleapis.com/compute/beta/projects/myproject/zones/us-central1-a/disks/example-disk/createSnapshot

{
 "snapshotEncryptionKey":  {
   "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
 },
  "sourceDiskEncryptionKey": {
   "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  },
 "name": "snapshot-encrypted-disk"
}

La propriété sourceDiskEncryptionKey doit correspondre à la clé utilisée pour chiffrer le disque persistant. À défaut, la requête échoue.

La propriété snapshotEncryptionKey vous permet de spécifier une clé pour chiffrer l'instantané. Ainsi, si l'instantané est utilisé pour créer des disques persistants, une clé correspondante doit être fournie. Cette clé doit suivre le format de clé précédent. Vous pouvez également choisir de laisser cette propriété indéfinie. Ainsi, l’instantané pourra être utilisé pour créer des disques persistants sans nécessiter de clé.

Créer une image à partir d'une image personnalisée ou d'un disque chiffré avec une clé CSEK

Vous pouvez créer des images personnalisées à partir de disques persistants chiffrés ou copier des images chiffrées. Vous ne pouvez pas utiliser la console pour copier des images. Utilisez la Google Cloud CLI ou REST pour copier des images.

Console

Accédez à la page Images.

Accéder à la page "Images"
Cliquez sur Create image (Créer une image).
Sous Disque source, choisissez le disque chiffré dont vous souhaitez créer une image.
Sous Chiffrement, sélectionnez une solution de gestion des clés de chiffrement.
Si la clé a été encapsulée avec la clé RSA publique, sélectionnez Clé encapsulée.

gcloud

Suivez les instructions de création d'une image et ajoutez l'option --csek-key-file avec un chemin d'accès au fichier de clé de chiffrement utilisé pour l'objet source chiffré. Utilisez le composant gcloud beta si vous utilisez une clé encapsulée en RSA :

gcloud (beta) compute images create .... --csek-key-file example-file.json

Si vous souhaitez chiffrer la nouvelle image avec votre clé, ajoutez la clé au fichier de clé :

[
  {
  "uri": "https://www.googleapis.com/compute/v1/projects/myproject/zones/us-central1-a/disks/source-disk",
  "key": "acX3RqzxrKAFTF0tYVLvydU1riRZTvUNC4g5I11NY-c=",
  "key-type": "raw"
  },
  {
  "uri": "https://www.googleapis.com/compute/v1/projects/myproject/global/snapshots/the-new-image",
  "key": "TF0t-cSfl7CT7xRF1LTbAgi7U6XXUNC4zU_dNgx0nQc=",
  "key-type": "raw"
  }
]

REST

Votre requête de création d'API doit contenir la propriété de clé de chiffrement correspondant à votre objet source. Par exemple, incluez l’une des propriétés suivantes en fonction du type d’objet source :

Disque persistant : sourceDiskEncryptionKey
Image : sourceImageEncryptionKey

En fonction du type de clé, incluez également la propriété rawKey ou rsaEncryptedKey. Envoyez une requête à l'API v1 pour obtenir une clé brute (non encapsulée en RSA) ou à l'API bêta pour obtenir une clé encapsulée en RSA. L'exemple suivant montre la conversion d'un disque persistant chiffré et encapsulé en RSA en une image qui utilise la même clé de chiffrement.

POST https://compute.googleapis.com/compute/beta/projects/myproject/global/images

{
 "name": "image-encrypted-disk",
 "sourceDiskEncryptionKey": {
    "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  }
 "imageEncryptionKey": {
    "rsaEncryptedKey":  "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
    },
 "sourceDisk": "projects/myproject/zones/us-central1-a/disks/source-disks"
}

La propriété facultative imageEncryptionKey vous permet de fournir une clé afin de chiffrer l'image. Lorsque l'image est utilisée dans la création de disques persistants, une clé correspondante doit alors être fournie. Cette clé doit suivre le même format que celui décrit ci-dessus. Vous pouvez également choisir de laisser cette propriété indéfinie. Ainsi, l'image pourra être utilisée pour créer des disques persistants sans nécessiter de clé.

Chiffrer une image importée avec une clé CSEK

Vous pouvez chiffrer une nouvelle image lorsque vous importez manuellement une image personnalisée dans Compute Engine. Pour pouvoir importer une image, vous devez créer et compresser un fichier image de disque, puis importer ce fichier compressé dans Cloud Storage.

Importez l'image Compute Engine personnalisée à chiffrer. Spécifiez l'URI du fichier compressé, ainsi que le chemin d'accès à votre fichier de clé de chiffrement.

Console

Accédez à la page Images.

Accéder à la page "Images"
Cliquez sur Create image (Créer une image).
Sous Source, choisissez Fichier Cloud Storage.
Sous Fichier Cloud Storage, saisissez l'URI Cloud Storage.
Sous Chiffrement, choisissez Clé fournie par le client puis, dans la zone de texte, saisissez la clé de chiffrement à utiliser pour chiffrer l'image.

gcloud

Exécutez la commande compute images create pour créer une image en spécifiant un fichier de clé de chiffrement pour l'option --csek-key-file. Si vous utilisez une clé encapsulée en RSA, utilisez le composant gcloud beta :

gcloud (beta) compute images create [IMAGE_NAME] \
    --source-uri gs://[BUCKET_NAME]/[COMPRESSED_FILE] \
    --csek-key-file [KEY_FILE]

Remplacez les éléments suivants :

[IMAGE_NAME] : nom de la nouvelle image personnalisée.
[BUCKET_NAME] : nom du bucket Cloud Storage contenant votre fichier image compressé.
[COMPRESSED_FILE] : nom du fichier image compressé.
[KEY_FILE] : chemin d'accès à un fichier de clé de chiffrement sur votre poste de travail local.

REST

Pour chiffrer une nouvelle image créée à partir d'un fichier RAW, ajoutez la nouvelle propriété imageEncryptionKey à la requête de création d'image. Ajoutez ensuite rawKey ou rsaEncryptedKey. Envoyez une requête à l'API v1 pour obtenir une clé brute (non encapsulée en RSA) ou à l'API bêta pour obtenir une clé encapsulée en RSA.

POST https://compute.googleapis.com/compute/beta/projects/myproject/global/images

{
"rawDisk": {
 "source": "http://storage.googleapis.com/example-image/example-image.tar.gz"
},
"name": "new-encrypted-image",
"sourceType": "RAW",
"imageEncryptionKey": {
  "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  }
}

Créer un disque persistant à partir d'une ressource chiffrée avec une clé CSEK

Créer un disque à partir d'un instantané chiffré avec une clé CSEK

Console

Accédez à la page Disques.

Accéder à la page Disques
Cliquez sur Créer un disque.
Sous Type de source, sélectionnez Instantané.
Sous Chiffrement, sélectionnez une solution de gestion des clés de chiffrement.
Si la clé a été encapsulée avec la clé RSA publique, sélectionnez Clé encapsulée.

gcloud

Dans l'outil gcloud compute, fournissez la clé de chiffrement de l'instantané à l'aide de l'option --csek-key-file lorsque vous créez le disque. Si vous utilisez une clé encapsulée en RSA, utilisez le composant gcloud beta :

gcloud (beta) compute disks create ... --source-snapshot example-snapshot --csek-key-file example-file.json

REST

Pour utiliser un instantané chiffré, indiquez la propriété sourceSnapshotEncryptionKey dans votre requête. Ajoutez ensuite rawKey ou rsaEncryptedKey. Envoyez une requête à l'API v1 pour obtenir une clé brute (non encapsulée en RSA) ou à l'API bêta pour obtenir une clé encapsulée en RSA. Par exemple, sur un nouveau disque persistant autonome en utilisant un instantané chiffré :

POST https://compute.googleapis.com/compute/beta/projects/myproject/zones/us-central1-a/disks

{
"name": "disk-from-encrypted-snapshot",
"sourceSnapshot": "global/snapshots/encrypted-snapshot",
"sourceSnapshotEncryptionKey": {
  "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  }
}

Créer un disque à partir d'une image chiffrée avec une clé CSEK

Console

Accédez à la page Disques.

Accéder à la page Disques
Cliquez sur Créer un disque.
Sous Type de source, sélectionnez Image.
Sous Chiffrement, sélectionnez une solution de gestion des clés de chiffrement.
Si la clé a été encapsulée avec la clé RSA publique, sélectionnez Clé encapsulée.

gcloud

Dans l'outil gcloud compute, fournissez la clé de chiffrement de l'image à l'aide de l'option --csek-key-file lorsque vous créez le disque. Si vous utilisez une clé encapsulée en RSA, utilisez le composant gcloud beta :

gcloud (beta) compute disks create ... --image example-image --csek-key-file example-file.json

REST

Pour utiliser une image chiffrée, indiquez la propriété sourceImageEncryptionKey. Ajoutez ensuite rawKey ou rsaEncryptedKey. Envoyez une requête à l'API v1 pour obtenir une clé brute (non encapsulée en RSA) ou à l'API bêta pour obtenir une clé encapsulée en RSA.

POST https://compute.googleapis.com/compute/v1/projects/myproject/zones/us-central1-a/disks

{
"name": "disk-from-encrypted-image",
"sourceImageEncryptionKey": {
  "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  },
"sourceImage": "global/images/encrypted-image"
}

Associer un disque chiffré avec une clé CSEK à une nouvelle VM

Console

Accédez à la page Créer une instance.

Accéder à la page Créer une instance
Dans la section Disque de démarrage, cliquez sur Modifier, puis procédez comme suit :
1. Sur la page Disque de démarrage, cliquez sur l'onglet Disques existants.
2. Dans la liste Disque, choisissez un disque chiffré existant à associer à la VM.
3. Dans la zone de texte, saisissez la clé de chiffrement et sélectionnez Clé de chiffrement de clé si la clé a été encapsulée avec la clé publique RSA.
  
  Remarque : Ces options ne s'affichent que lorsqu'un disque chiffré est sélectionné dans la liste Disque.
4. Cliquez sur Select (Sélectionner).
Poursuivez le processus de création de la VM.

gcloud

Pour créer une VM et lui associer un disque chiffré, créez un fichier de clé et fournissez la clé à l'aide de l'option --csek-key-file lors de la création de la VM. Si vous utilisez une clé encapsulée en RSA, servez-vous du composant gcloud beta :

gcloud (beta) compute instances create example-instance \
    --disk name=example-disk,boot=yes \
    --csek-key-file example-file.json

REST

Créez une VM à l'aide de l'API Compute Engine et indiquez la propriété rawKey ou rsaEncryptedKey avec la spécification de disque. Envoyez une requête à l'API v1 pour obtenir une clé brute (non encapsulée en RSA) ou à l'API bêta pour obtenir une clé encapsulée en RSA.

Voici un extrait d'un exemple de spécification de disque :

"disks": [
{
  "deviceName": "encrypted-disk",
  "source": "projects/myproject/zones/us-central1-f/disks/encrypted-disk",
  "diskEncryptionKey": {
    "rawKey": "SGVsbG8gZnJvbSBHb29nbGUgQ2xvdWQgUGxhdGZvcm0="
  }
 }
]

Démarrer ou redémarrer des VM dont les disques sont chiffrés avec des clés CSEK

Pour en savoir plus sur l'arrêt ou le démarrage d'une VM contenant des disques chiffrés, consultez la section Redémarrer une VM associée à des disques chiffrés.

Utiliser la ligne de commande pour créer des ressources mixtes

Si vous souhaitez effectuer une seule et même requête via Google Cloud CLI pour créer un mélange de ressources chiffrées par le client et de ressources chiffrées de manière standard, vous pouvez utiliser l'option --csek-key-file associée à un fichier de clé ainsi que l'option --no-require-csek-key-create dans votre requête. Lorsque vous fournissez ces deux options, gcloud CLI crée toutes les ressources chiffrées par le client qui sont explicitement définies dans votre fichier de clé, ainsi que toutes les ressources standards que vous spécifiez.

Par exemple, supposons qu'un fichier de clé contienne le code suivant :

[
  {
  "uri": "https://www.googleapis.com/compute/beta/projects/myproject/zones/us-central1-a/disks/example-disk",
  "key": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA==",
  "key-type": "rsa-encrypted"
  }
]

Si, dans la même requête, vous souhaitez créer une VM avec un disque chiffré par le client via le fichier de clé et, en même temps, créer une VM avec un disque chiffré de manière standard, procédez comme suit :

gcloud beta compute instances create example-disk example-disk-2 \
    --csek-key-file mykeyfile.json --no-require-csek-key-create

En principe, il ne devrait pas être possible de créer example-disk-2 si vous avez spécifié l'option --csek-key-file, car le disque n'est pas explicitement défini dans le fichier de clé. Lorsque vous ajoutez --no-require-csek-key-create, les deux disques sont créés, l'un étant chiffré à l'aide du fichier de clé et l'autre par le biais du chiffrement Google.

Supprimer votre clé CSEK d'un disque persistant

Vous pouvez déchiffrer le contenu d'un disque chiffré par le client et créer un disque qui utilise le chiffrement Compute Engine par défaut.

Créez une image du disque chiffré et spécifiez le chiffrement automatique pour la nouvelle image.
Utilisez la nouvelle image pour créer un disque persistant.

Le nouveau disque persistant utilisera le chiffrement Compute Engine par défaut pour protéger son contenu. Tous les instantanés que vous créerez à partir de ce disque devront également utiliser le chiffrement par défaut.