Cripta i dischi con chiavi di crittografia fornite dal cliente

Questo argomento fornisce informazioni su come criptare i dischi con chiavi di crittografia fornite dal cliente.

Per informazioni sulla crittografia del disco, vedi Informazioni sulla crittografia del disco.

Per informazioni sulla crittografia dei dischi per le chiavi di crittografia gestite dal cliente (CMEK), consulta Proteggi le risorse utilizzando chiavi Cloud KMS.

L'uso di CSEK significa che fornisci le tue chiavi di crittografia, mentre Compute Engine utilizza le tue chiavi per proteggere le chiavi generate da Google utilizzate per criptare e decriptare i tuoi dati. Solo gli utenti che sono in grado di fornire la chiave corretta possono utilizzare le risorse protetta da una chiave di crittografia fornita dal cliente (CSEK).

Google non archivia le chiavi sui suoi server e non può accedere ai tuoi a meno che tu non fornisca la chiave. Ciò significa anche che se dimentica o perdi la chiave, Google non ha modo di recuperarla o recuperare i dati criptati con la chiave persa.

Quando elimini un disco permanente, Google elimina le chiavi di crittografia, rendere i dati irrecuperabili. Questa operazione è irreversibile.

Prima di iniziare

  • Leggi ulteriori informazioni su dischi, immagini, e snapshot dei dischi.
  • Se non l'hai già fatto, configura l'autenticazione. Autenticazione è Il processo di verifica dell'identità per l'accesso ai servizi e alle API di Google Cloud. Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi eseguire l'autenticazione Compute Engine come segue.

    Select the tab for how you plan to use the samples on this page:

    Console

    When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

    gcloud

    1. Installa Google Cloud CLI, quindi initialize eseguendo questo comando: 

      gcloud init
    2. Set a default region and zone.

      3. Python

      Per utilizzare gli Python esempi in questa pagina in una località dell'ambiente di sviluppo, installare e inizializzare gcloud CLI quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

      1. Installa Google Cloud CLI.

      2. Per initialize gcloud CLI, esegui questo comando: 

        gcloud init

      3. Crea credenziali di autenticazione locali per il tuo Account Google: 

        gcloud auth application-default login

      Per ulteriori informazioni, vedi Set up authentication for a local development environment.

      REST

      Per utilizzare gli esempi di API REST in questa pagina in un ambiente di sviluppo locale, utilizzi le credenziali che fornisci a gcloud CLI.

        Installa Google Cloud CLI, quindi initialize eseguendo questo comando: 

        gcloud init

      Per ulteriori informazioni, vedi Esegui l'autenticazione per l'utilizzo di REST nella documentazione sull'autenticazione di Google Cloud.

Limitazioni

Per la crittografia lato client si applicano le seguenti limitazioni:

Limitazioni generali

La disponibilità delle chiavi di crittografia fornite dal cliente dipende dalla località l'account di fatturazione, non la località della risorsa.

Le chiavi di crittografia fornite dal cliente non sono disponibili per gli account di fatturazione si trovano nei seguenti paesi:

  • Brasile
  • India

Limitazioni tecniche

  • Puoi criptare solo nuovi dischi permanenti con la tua chiave. Tu non puoi criptare i dischi permanenti esistenti con la tua chiave.

  • Non puoi utilizzare le tue chiavi con i dischi SSD locali poiché le chiavi vengono gestite dall'infrastruttura di Google ed eliminate quando la VM viene arrestata.

  • Compute Engine non archivia le chiavi di crittografia con modelli di istanze, quindi devi archiviare le tue chiavi in KMS per criptare i dischi gruppo di istanze gestite.

  • Non puoi sospendere le istanze a cui sono collegati dischi protetti da CSEK.

Specifiche

Questa sezione descrive le specifiche di crittografia e il formato della CSEK.

Crittografia

Compute Engine usa la tua chiave di crittografia per proteggere di crittografia con crittografia AES-256.

Formato chiave obbligatorio

Spetta a te generare e gestire la chiave. Devi fornire una chiave Una stringa a 256 bit codificata nello standard RFC 4648 base64 in Compute Engine.

Di seguito è riportato un esempio di una chiave codificata base64, generata con la stringa "Un saluto dalla Google Cloud Platform"

SGVsbG8gZnJvbSBHb29nbGUgQ2xvdWQgUGxhdGZvcm0=

Può essere generato utilizzando lo script seguente:

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

Wrapping chiave RSA

Oltre a codificare la chiave in base64, puoi eseguire il wrapping la chiave utilizzando un certificato di chiave pubblica RSA fornito da Google, in base64, per poi usare questa chiave nelle tue richieste.

Il wrapping RSA è un processo in cui utilizzi una chiave pubblica per criptare i tuoi dati. Dopo che i dati sono stati criptati con la chiave pubblica, possono essere decriptato dalla rispettiva chiave privata. In questo caso, la chiave privata è nota solo ai servizi Google Cloud. Esegui il wrapping della chiave con l'RSA ti assicuri che solo i servizi Google Cloud possano eseguire l'unwrapping del tuo e usarla per proteggere i tuoi dati.

Per ulteriori informazioni, vedi Crittografia RSA.

Per creare una chiave con wrapping RSA per Compute Engine, segui questi passaggi:

  1. Esegui il wrapping della chiave utilizzando la chiave pubblica fornita in un certificato che gestito da Compute Engine. Assicurati di eseguire il wrapping della chiave utilizzando OAEP per la spaziatura interna, non per la spaziatura interna PKCS #1 v1.5.
  2. Codifica la chiave con wrapping RSA utilizzando la codifica Base64 standard.

Scarica il certificato pubblico gestito da Compute Engine da:

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

Esistono molti modi per generare e il wrapping RSA della chiave, un metodo che che conoscete meglio. Di seguito sono riportati due esempi di wrapping RSA della chiave che puoi utilizzare.

Esempio 1

Le seguenti istruzioni utilizzano il openssl a riga di comando per eseguire il wrapping RSA e codificare una chiave.

  1. (Facoltativo) Genera una chiave casuale a 256 bit (32 byte). Se hai già che vuoi utilizzare, puoi saltare questo passaggio. Ci sono molti modi per generare una chiave. Ad esempio:

    $ head -c 32 /dev/urandom | LC_CTYPE=C tr '\n' = > mykey.txt

  2. Scarica il public key certificate:

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

  3. Estrai la chiave pubblica dal certificato:

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

  4. Esegui il wrapping RSA della chiave, assicurandoti di sostituire mykey.txt con il tuo file di chiave.

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

  5. Codifica la chiave con wrapping RSA in base64.

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

Esempio 2

Di seguito è riportato uno script Python di esempio che genera uno script casuale a 256 bit (32 byte) e crea una chiave con wrapping RSA codificata in base64 utilizzando crittografia libreria:

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)

Il token è pronto per l'uso.

Usa una chiave con wrapping RSA

Con Google Cloud CLI, puoi fornire una chiave regolare e un Chiave con wrapping RSA nello stesso modo.

Nell'API, utilizza sha256 anziché rawKey se vuoi utilizzare una proprietà chiave con wrapping RSA.

Crittografia delle risorse con CSEK mediante lo strumento a riga di comando

Configurazione

Le chiavi di crittografia possono essere utilizzate tramite Google Cloud CLI.

Scarica e installa gcloud.

File di chiavi

Quando usi lo strumento a riga di comando gcloud compute per impostare le chiavi, fornisci chiavi codificate utilizzando un file di chiave che contiene le chiavi codificate come un elenco JSON. Un file di chiave può contenere più chiavi, consentendoti di gestirne molte in un unico posto. In alternativa, puoi creare singoli file di chiave gestire ogni chiave separatamente. Un file di chiave può essere utilizzato solo con gcloud CLI. Quando utilizzi REST, devi fornire la chiave direttamente nella richiesta.

Ogni voce nel file della chiave deve fornire:

  • L'URI completo della risorsa protetta dalla chiave
  • La chiave corrispondente
  • Il tipo di chiave, raw o rsa-encrypted

Quando utilizzi il file della chiave nelle richieste, lo strumento cerca e utilizza le rispettive chiavi. Se non sono presenti risorse corrispondenti trovata, la richiesta non va a buon fine.

Un esempio di file di chiave ha il seguente aspetto: 

[
  {
  "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"
  }
]

Best practice per la gestione del file di chiave

Se utilizzi un file di chiave, limita l'accesso al file solo a quelle che ne hanno bisogno. Assicurati di impostare le autorizzazioni appropriate per questi file e valuta la possibilità di crittografare questi file con strumenti aggiuntivi:

Cripta un nuovo disco permanente con CSEK

Puoi criptare un nuovo disco permanente fornendo una chiave durante la VM o durante la creazione del disco.

Console

  1. Vai alla pagina Dischi.

    Vai a dischi

  2. Fai clic su Crea disco e inserisci le proprietà del nuovo disco.

  3. In Crittografia, seleziona Chiave fornita dal cliente.

  4. Fornisci la chiave di crittografia per il disco nella casella di testo e seleziona Chiave con wrapping se il wrapping della chiave è stato eseguito con la chiave RSA pubblica.

gcloud

Nello strumento gcloud compute, cripta un disco usando l'istruzione --csek-key-file durante la creazione della VM. Se utilizzi una chiave con wrapping RSA, utilizza la Componente gcloud beta:

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

Per criptare un disco permanente autonomo:

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

REST

Puoi criptare un disco utilizzando la proprietà diskEncryptionKey e creando una richiesta all'API v1 per una chiave non elaborata (con wrapping RSA) oppure all'API API beta per una chiave con wrapping RSA. Fornisci una delle seguenti proprietà nella tua richiesta:

  • rawKey: se la chiave è codificata in base64
  • rsaEncryptedKey: se la chiave è con wrapping RSA e con codifica Base64

Ad esempio, per criptare un nuovo disco durante la creazione di una VM con un Chiave con wrapping 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
 }
],
...
}

Allo stesso modo, puoi anche utilizzare REST per creare un nuovo disco e criptarlo con la tua chiave:

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

Crea uno snapshot da un disco criptato con CSEK

Se crei uno snapshot da un disco criptato, anche lo snapshot deve essere criptato. Devi specificare una chiave per criptare lo snapshot. Non puoi convertire dischi criptati o snapshot criptati per utilizzare l'impostazione predefinita di Compute Engine la crittografia, a meno che crea una nuova immagine disco e un nuovo disco permanente.

Gli snapshot dei dischi criptati con CSEK sono sempre snapshot completi. Questo è diverso da snapshot di dischi criptati con chiavi di crittografia gestite dal cliente (CMEK), ovvero incrementale. Il prezzo degli snapshot dipende sulla dimensione totale dello snapshot, quindi uno snapshot completo potrebbe costare più di un snapshot incrementale.

Per creare lo snapshot di un disco permanente da un disco criptato, richiesta di creazione deve fornire la chiave di crittografia che hai utilizzato per crittografare un disco permanente standard.

Esamina il Best practice per disco permanente permanenti prima di creare lo snapshot.

Console

  1. Vai alla pagina Snapshot.

    Vai a Snapshot

  2. Fai clic su Crea snapshot.

  3. In Disco di origine, scegli il disco criptato che vuoi creare un'istantanea di

  4. Fornisci la chiave di crittografia per il disco nella casella di testo e seleziona Chiave con wrapping se il wrapping della chiave è stato eseguito con la chiave RSA pubblica.

  5. Cripta il nuovo snapshot fornendo una chiave di crittografia aggiuntiva in nella sezione Crittografia.

REST

Per effettuare la richiesta, fornisci la proprietà sourceDiskEncryptionKey per accedere il disco permanente di origine. Devi criptare il nuovo snapshot utilizzando snapshotEncryptionKey proprietà.

Effettua una richiesta all'API v1 per una chiave non elaborata (con wrapping RSA) oppure all'API API beta per una chiave con wrapping 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 proprietà sourceDiskEncryptionKey deve corrispondere alla chiave utilizzata per la crittografia del disco permanente. In caso contrario, la richiesta non va a buon fine.

snapshotEncryptionKey ti consente di fornire una chiave per criptare lo snapshot in modo che, se quest'ultimo viene utilizzato per creare nuovi è necessario fornire una chiave corrispondente. Questa chiave deve seguire la precedente formato della chiave. Puoi anche scegliere di abbandonare questa proprietà non definito e lo snapshot può essere utilizzato per creare nuovi dischi permanenti senza richiedere una chiave.

Crea una nuova immagine da un disco o da un'immagine personalizzata criptata con CSEK

Puoi creare immagini personalizzate da dischi permanenti criptati o copiare in formato Docker. Non puoi utilizzare la console per copiare immagini. Utilizza la Google Cloud CLI o REST per copiare le immagini.

Console

  1. Vai alla pagina Immagini.

    Vai a Google Immagini

  2. Fai clic su Crea immagine.

  3. In Disco di origine, scegli il disco criptato che vuoi creare un'immagine di

  4. In Crittografia, seleziona una soluzione di gestione delle chiavi di crittografia.

  5. Se il wrapping della chiave è stato eseguito con la chiave RSA pubblica, seleziona Con wrapping chiave.

gcloud

Segui le istruzioni per crea un'immagine, e aggiungi il flag --csek-key-file con un percorso al file della chiave di crittografia per l'oggetto di origine criptato. Utilizza il componente gcloud beta se utilizzi una chiave con wrapping RSA:

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

Se vuoi criptare la nuova immagine con la tua chiave, aggiungi quest'ultima alla chiave file:

[
  {
  "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

La richiesta di creazione dell'API deve contenere la proprietà della chiave di crittografia per di origine. Ad esempio, includi una delle seguenti proprietà a seconda del tipo di oggetto di origine:

  • Disco permanente: sourceDiskEncryptionKey
  • Immagine: sourceImageEncryptionKey

Includi anche le proprietà rawKey o rsaEncryptedKey a seconda il tipo di chiave. Richiedi all'API v1 una chiave non elaborata (con wrapping RSA), o all'API beta per una chiave con wrapping RSA. L'esempio seguente converte da un disco permanente criptato e con wrapping RSA a un'immagine che utilizza la stessa chiave di crittografia.

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 proprietà facoltativa imageEncryptionKey ti consente di fornire una chiave per criptarla in modo che quando questa viene utilizzata per creare nuovi è necessario fornire una chiave corrispondente. Questa chiave deve seguire la stessa chiave descritto sopra. Puoi anche scegliere di abbandonare questa proprietà non definito e l'immagine può essere utilizzata per creare nuovi dischi permanenti senza richiedere una chiave.

Cripta un'immagine importata con CSEK

Puoi criptare una nuova immagine quando importa manualmente un'immagine personalizzata in in Compute Engine. Prima di poter importare un'immagine, devi creare e comprimere un file immagine disco e il file compresso in Cloud Storage.

Importa l'immagine Compute Engine personalizzata che vuoi criptare. Specifica l'URI del file compresso e specifica anche un percorso di crittografia.

Console

  1. Vai alla pagina Immagini.

    Vai a Google Immagini

  2. Fai clic su Crea immagine.

  3. In Origine, scegli File Cloud Storage.

  4. In File Cloud Storage, inserisci l'URI Cloud Storage.

  5. In Crittografia, scegli Chiave fornita dal cliente e specifica la chiave di crittografia per criptare l'immagine nella casella di testo.

gcloud

Utilizza il comando compute images create per creare una nuova immagine e specifica il flag --csek-key-file con un file di chiave di crittografia. Se utilizzi un Chiave con wrapping RSA, utilizza il componente gcloud beta:

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

Sostituisci quanto segue:

  • [IMAGE_NAME]: il nome della nuova immagine personalizzata.
  • [BUCKET_NAME]: il nome del bucket Cloud Storage che contiene del file immagine compresso.
  • [COMPRESSED_FILE]: il nome del file immagine compresso.
  • [KEY_FILE]: il percorso di un file di chiave di crittografia sul tuo server la workstation.

REST

Per criptare una nuova immagine creata da un file RAW, aggiungi la nuova imageEncryptionKey proprietà alla richiesta di creazione dell'immagine, seguita da rawKey o rsaEncryptedKey. Effettua una richiesta all'API v1 per un chiave non elaborata (con wrapping RSA) o all'API beta per una chiave con wrapping 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=="
  }
}

Crea un disco permanente da una risorsa criptata con CSEK

Crea un disco da uno snapshot criptato con CSEK

Console

  1. Vai alla pagina Dischi.

    Vai a dischi

  2. Fai clic su Crea disco.

  3. In Tipo di origine, seleziona Istantanea.

  4. In Crittografia, seleziona una soluzione di gestione delle chiavi di crittografia.

  5. Se il wrapping della chiave è stato eseguito con la chiave RSA pubblica, seleziona Con wrapping chiave.

gcloud

Nello strumento gcloud compute, fornisci la chiave di crittografia per lo snapshot usando il flag --csek-key-file quando crei il disco. Se utilizzi una chiave con wrapping RSA, utilizza il componente gcloud beta:

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

REST

Per utilizzare uno snapshot criptato, fornisci sourceSnapshotEncryptionKey in la tua richiesta, seguita da rawKey o rsaEncryptedKey. Invia una richiesta a all'API v1 per una chiave non elaborata (non con wrapping RSA) o all'API Beta per una Chiave con wrapping RSA. Ad esempio, in un nuovo disco permanente autonomo utilizzando una snapshot criptato:

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

Crea un disco da un'immagine criptata con CSEK

Console

  1. Vai alla pagina Dischi.

    Vai a dischi

  2. Fai clic su Crea disco.

  3. In Tipo di origine, seleziona Immagine.

  4. In Crittografia, seleziona una soluzione di gestione delle chiavi di crittografia.

  5. Se il wrapping della chiave è stato eseguito con la chiave RSA pubblica, seleziona Con wrapping chiave.

gcloud

Nello strumento gcloud compute, fornisci la chiave di crittografia dell'immagine utilizzando il flag --csek-key-file quando crei il disco. Se utilizzi un Chiave con wrapping RSA, utilizza il componente gcloud beta:

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

REST

Per usare un'immagine criptata, fornisci sourceImageEncryptionKey, seguito da rawKey o rsaEncryptedKey. Invia una richiesta a all'API v1 per una chiave non elaborata (non con wrapping RSA) o all'API Beta per una Chiave con wrapping 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"
}

Collegamento di un disco criptato con CSEK a una nuova VM

Console

  1. Vai alla pagina Crea un'istanza.

    Vai a Crea un'istanza

  2. Nella sezione Disco di avvio, fai clic su Cambia e segui questi passaggi:

    1. Nella pagina Disco di avvio, fai clic sulla scheda Dischi esistenti.
    2. Dall'elenco Disco, scegli un disco criptato esistente su cui per collegarti alla VM.

    3. Inserisci la chiave di crittografia nella casella di testo e seleziona Chiave con wrapping se il wrapping della chiave è stato eseguito con la chiave RSA pubblica.

    4. Fai clic su Seleziona.

  3. Continua con il processo di creazione della VM.

gcloud

Per creare una VM e collegare un disco criptato, crea un file chiave e fornisci la chiave utilizzando il flag --csek-key-file quando crei la VM. Se utilizzi una chiave con wrapping RSA, utilizza la Componente gcloud beta:

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

REST

Crea una VM utilizzando l'API Compute Engine e fornire il rawKey rsaEncryptedKey con le specifiche del disco. Invia una richiesta a all'API v1 per una chiave non elaborata (non con wrapping RSA) o all'API Beta per una Chiave con wrapping RSA.

Ecco uno snippet di una specifica del disco di esempio:

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

Avvio o riavvio delle VM con dischi criptati con CSEK

Per maggiori dettagli sull'arresto o sull'avvio di una VM con dischi criptati: lettura Riavvio di una VM con un disco criptato.

Utilizzo della riga di comando per creare risorse miste

Se vuoi creare una combinazione di crittografia standard e crittografia dal cliente in una singola richiesta con Google Cloud CLI, puoi utilizzare il flag --csek-key-file con un file di chiave e --no-require-csek-key-create nella richiesta. Se fornisci entrambi i flag, gcloud CLI crea tutte le risorse criptate dal cliente che sono nel file della chiave, oltre a creare eventuali risorse standard da te specificate.

Ad esempio, supponiamo che un file chiave contenga quanto segue:

[
  {
  "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"
  }
]

Se volessi creare una VM con un disco criptato dal cliente utilizzando il file della chiave e allo stesso tempo crea una VM con crittografia standard nella stessa richiesta, puoi farlo come segue:

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

Generalmente non è possibile creare example-disk-2 se ha specificato il flag --csek-key-file perché il disco non è definito in modo esplicito nel file della chiave. Se aggiungi --no-require-csek-key-create, entrambi i dischi vengono uno è stato criptato con il file della chiave e l'altro è criptato Crittografia di Google.

Rimuovere la CSEK da un disco permanente

Puoi decriptare i contenuti di un disco criptato dal cliente e crearne uno nuovo che utilizza la crittografia predefinita di Compute Engine.

  1. Crea un'immagine del disco criptato e specifica crittografia automatica per la nuova immagine.
  2. Utilizza la nuova immagine per crea un nuovo disco permanente.

Dopo la creazione, il nuovo disco permanente utilizza Compute Engine. la crittografia predefinita per proteggere i contenuti del disco. Eventuali snapshot creati dal disco deve usare anche la crittografia predefinita.