Vuelve a encriptar datos

En este tema, se muestra cómo volver a encriptar datos con una clave simétrica de Cloud Key Management Service. Puedes adaptar estos ejemplos para claves asimétricas. Si sospechas que una clave se usa sin autorización, debes volver a encriptar los datos que esta protege y, luego, inhabilitar o programar la destrucción de la versión de clave anterior.

Antes de comenzar

Para esta situación, se requieren estas condiciones:

  • Haber encriptado datos mediante Cloud KMS.

  • La versión de clave que usaste en la encriptación no debe estar inhabilitada, programada para su destrucción ni destruida. Usarás esta versión de clave para desencriptar los datos encriptados.

  • Haber rotado claves. La rotación de claves crea una versión de clave primaria nueva. Usarás esta versión de clave primaria nueva para volver a encriptar los datos.

Cómo volver a encriptar datos con claves asimétricas

Los ejemplos de este tema muestran cómo volver a encriptar datos con una clave simétrica. Cuando usas una clave simétrica, Cloud KMS infiere automáticamente la versión de clave que se usará para la desencriptación. Cuando utilices una clave asimétrica, debes especificar la versión de la clave.

El flujo de trabajo para volver a encriptar datos con claves asimétricas es similar al que se describe en este tema.

Flujo de trabajo para volver a encriptar los datos

Sigue estos pasos para volver a encriptar los datos y también inhabilitar la versión de clave que se usó para la encriptación original o programar su destrucción.

  1. Desencripta los datos con la versión de clave anterior

  2. Vuelve a encriptar los datos con la versión de clave primaria nueva

  3. Inhabilita o programa la destrucción de la versión de clave anterior

Desencripta los datos con la versión de clave anterior

De manera automática, Cloud KMS usa la versión de clave correcta para desencriptar los datos, salvo que esta se encuentre inhabilitada, esté programada para su destrucción o se haya destruido. En los siguientes ejemplos, se muestra cómo desencriptar los datos. Este código de desencriptación es el mismo que se usa en Encripta y desencripta.

Línea de comandos

Para desencriptar los datos, proporciona la información de la clave adecuada, especifica el nombre del archivo encriptado (archivo cifrado) que se desencriptará y el nombre del archivo en el que se guardará el contenido desencriptado.

    gcloud kms decrypt \
      --location=location \
      --keyring=keyring-name \
      --key=key-name \
      --ciphertext-file=filepath-and-file-to-decrypt \
      --plaintext-file=decrypted-filepath-and-file.dec
    

La versión principal de la clave se usa de forma predeterminada. Para especificar una versión diferente, establece la marca --version en el número de versión. En este ejemplo, se usa la versión 2 de my-key:

    gcloud kms decrypt \
      --location=location \
      --keyring=keyring-name \
      --key=key-name \
      --version=key-version
      --ciphertext-file=filepath-and-file-to-decrypt \
      --plaintext-file=decrypted-filepath-and-file.dec
    

El comando decrypt admite una marca --additional-authenticated-data- file opcional para especificar un archivo con datos autenticados adicionales. El tamaño del archivo de datos autenticados adicionales no debe superar los 64 KiB.

Si --ciphertext-file o --additional-authenticated-data-file se configura como -, ese archivo se lee desde stdin. De manera similar, si --plaintext-file se configura como -, el texto sin formato desencriptado se escribe en stdout.

En el siguiente ejemplo de decrypt, se muestra cómo especificar datos autenticados adicionales.

    gcloud kms decrypt \
      --location=location \
      --keyring=keyring-name \
      --key=key-name \
      --additional-authenticated-data-file=aad-file-path-and-name \
      --ciphertext-file=filepath-and-file-to-decrypt \
      --plaintext-file=decrypted-filepath-and-file.dec
    

Protocolo

El texto desencriptado que se muestra en el archivo JSON de Cloud KMS está codificado en base64.

Para desencriptar datos, haz una solicitud POST y proporciona la información del proyecto y de la clave correspondientes, y especifica el texto encriptado (cifrado) que se desencriptará en el campo ciphertext del cuerpo de la solicitud. Reemplaza API_KEY por una clave de API válida. Consulta Accede a la API para obtener información sobre cómo generar una clave de API.

    POST https://cloudkms.googleapis.com/v1/projects/project-id/locations/location/keyRings/keyring-name/cryptoKeys/key-namecryptoKey_name:decrypt&key=api-key-name
    
    {
      "ciphertext": "CiQAhMwwBo61cHas7dDgifrUFs5zNzBJ2uZtVFq4ZPEl6fUVT4kSmQ...",
    }
    

En este ejemplo, se usa curl:

    curl -s -X POST "https://cloudkms.googleapis.com/v1/projects/project-id/locations/location/keyRings/keyring-name/cryptoKeys/key-name:decrypt" \
      -d "{\"ciphertext\":\"encrypted-content\"}" \
      -H "Authorization:Bearer api-key"\
      -H "Content-Type:application/json"
    

C#

        public static void Decrypt(string projectId, string locationId, string keyRingId, string cryptoKeyId,
        string ciphertextFile, string plaintextFile)
            {
                KeyManagementServiceClient client = KeyManagementServiceClient.Create();
                CryptoKeyName cryptoKeyName =
                    new CryptoKeyName(projectId, locationId, keyRingId, cryptoKeyId);

                byte[] ciphertext = File.ReadAllBytes(ciphertextFile);
                DecryptResponse result = client.Decrypt(cryptoKeyName, ByteString.CopyFrom(ciphertext));

                // Output decrypted data to a file.
                File.WriteAllBytes(plaintextFile, result.Plaintext.ToByteArray());
                Console.Write($"Decrypted file created: {plaintextFile}");
            }

Go

import (
    	"context"
    	"fmt"

    	cloudkms "cloud.google.com/go/kms/apiv1"
    	kmspb "google.golang.org/genproto/googleapis/cloud/kms/v1"
    )

    // decryptSymmetric will decrypt the input ciphertext bytes using the specified symmetric key.
    func decryptSymmetric(name string, ciphertext []byte) ([]byte, error) {
    	// name := "projects/PROJECT_ID/locations/global/keyRings/RING_ID/cryptoKeys/KEY_ID"
    	// cipherBytes, err := encryptRSA(rsaDecryptPath, []byte("Sample message"))
    	// if err != nil {
    	//   return nil, fmt.Errorf("encryptRSA: %v", err)
    	// }
    	// ciphertext := base64.StdEncoding.EncodeToString(cipherBytes)
    	ctx := context.Background()
    	client, err := cloudkms.NewKeyManagementClient(ctx)
    	if err != nil {
    		return nil, fmt.Errorf("cloudkms.NewKeyManagementClient: %v", err)
    	}

    	// Build the request.
    	req := &kmspb.DecryptRequest{
    		Name:       name,
    		Ciphertext: ciphertext,
    	}
    	// Call the API.
    	resp, err := client.Decrypt(ctx, req)
    	if err != nil {
    		return nil, fmt.Errorf("Decrypt: %v", err)
    	}
    	return resp.Plaintext, nil
    }
    

Java


    /** Decrypts the provided ciphertext with the specified crypto key. */
    public static byte[] decrypt(
        String projectId, String locationId, String keyRingId, String cryptoKeyId, byte[] ciphertext)
        throws IOException {

      // Create the KeyManagementServiceClient using try-with-resources to manage client cleanup.
      try (KeyManagementServiceClient client = KeyManagementServiceClient.create()) {

        // The resource name of the cryptoKey
        String resourceName = CryptoKeyPathName.format(projectId, locationId, keyRingId, cryptoKeyId);

        // Decrypt the ciphertext with Cloud KMS.
        DecryptResponse response = client.decrypt(resourceName, ByteString.copyFrom(ciphertext));

        // Extract the plaintext from the response.
        return response.getPlaintext().toByteArray();
      }
    }

Node.js

async function decrypt(
      projectId = 'your-project-id', // Your GCP projectId
      keyRingId = 'my-key-ring', // Name of the crypto key's key ring
      cryptoKeyId = 'my-key', // Name of the crypto key, e.g. "my-key"
      ciphertextFileName = './path/to/plaintext.txt.encrypted',
      plaintextFileName = './path/to/plaintext.txt.decrypted'
    ) {
      const fs = require('fs');
      const {promisify} = require('util');

      // Import the library and create a client
      const kms = require('@google-cloud/kms');
      const client = new kms.KeyManagementServiceClient();

      // The location of the crypto key's key ring, e.g. "global"
      const locationId = 'global';

      // Reads the file to be decrypted
      const readFile = promisify(fs.readFile);
      const ciphertext = await readFile(ciphertextFileName);
      const name = client.cryptoKeyPath(
        projectId,
        locationId,
        keyRingId,
        cryptoKeyId
      );

      // Decrypts the file using the specified crypto key
      const [result] = await client.decrypt({name, ciphertext});

      // Writes the decrypted file to disk
      const writeFile = promisify(fs.writeFile);
      await writeFile(plaintextFileName, result.plaintext);
      console.log(
        `Decrypted ${ciphertextFileName}, result saved to ${plaintextFileName}.`
      );
    }

PHP

use Google\Cloud\Kms\V1\KeyManagementServiceClient;
    use Google\Cloud\Kms\V1\CryptoKey;

    /** Uncomment and populate these variables in your code */
    // $projectId = 'The Google project ID';
    // $locationId = 'The location ID of the crypto key. Can be "global", "us-west1", etc.';
    // $keyRingId = 'The KMS key ring ID';
    // $cryptoKeyId = 'The KMS key ID';
    // $ciphertextFileName = 'The path to the file containing ciphertext to decrypt';
    // $plaintextFileName = 'The path to write the plaintext';

    $kms = new KeyManagementServiceClient();

    // The resource name of the CryptoKey.
    $cryptoKey = new CryptoKey();
    $cryptoKeyName = $kms->cryptoKeyName($projectId, $locationId, $keyRingId, $cryptoKeyId);

    $ciphertext = file_get_contents($ciphertextFileName);
    $response = $kms->decrypt($cryptoKeyName, $ciphertext);

    // Write the encrypted text to a file.
    file_put_contents($plaintextFileName, $response->getPlaintext());
    printf('Saved decrypted text to %s' . PHP_EOL, $plaintextFileName);

Python

def decrypt_symmetric(project_id, location_id, key_ring_id, crypto_key_id,
                          ciphertext):
        """Decrypts input ciphertext using the provided symmetric CryptoKey."""

        from google.cloud import kms_v1

        # Creates an API client for the KMS API.
        client = kms_v1.KeyManagementServiceClient()

        # The resource name of the CryptoKey.
        name = client.crypto_key_path_path(project_id, location_id, key_ring_id,
                                           crypto_key_id)
        # Use the KMS API to decrypt the data.
        response = client.decrypt(name, ciphertext)
        return response.plaintext

Ruby

# project_id    = "Your Google Cloud project ID"
    # location_id   = "The location of the key ring"
    # key_ring_id   = "The ID of the key ring"
    # crypto_key_id = "The ID of the crypto key"
    # ciphertext_file = "File to decrypt"
    # plaintext_file  = "File to store decrypted data"

    require "google/cloud/kms/v1"
    CloudKMS = Google::Cloud::Kms::V1

    # Initialize the client
    client = CloudKMS::KeyManagementServiceClient.new

    # The crypto key to use
    crypto_key = CloudKMS::KeyManagementServiceClient.crypto_key_path(
      project_id, location_id, key_ring_id, crypto_key_id
    )

    # Read the encrypted data from the file
    ciphertext = File.open(ciphertext_file, "rb", &:read)

    # Use the KMS API to decrypt the data
    response = client.decrypt crypto_key, ciphertext

    # Write the decrypted text to the output file
    File.open(plaintext_file, "wb") { |f| f.write response.plaintext }

    puts "Saved decrypted #{ciphertext_file} as #{plaintext_file}"

Vuelve a encriptar los datos con la versión de clave primaria nueva

Cloud KMS usa la versión de clave primaria nueva de manera automática para encriptar los datos. En los siguientes ejemplos, se muestra cómo hacerlo. Este código de encriptación es el mismo que se usa en Encripta y desencripta.

Línea de comandos

Para encriptar datos, proporciona la información de clave correcta, especifica el nombre del archivo de texto sin formato que encriptarás y también el nombre del archivo que incluirá el contenido encriptado.

    gcloud kms encrypt \
      --location=location  \
      --keyring=keyring-name \
      --key=key-name \
      --plaintext-file=filepath-and-file-to-encrypt \
      --ciphertext-file=encrypted-filepath-and-file.enc
    

El tamaño del archivo de texto sin formato no debe superar los 64 KiB.

El comando encrypt admite la marca opcional --additional-authenticated-data-file para especificar un archivo que contiene datos autenticados adicionales. El tamaño del archivo de datos autenticados adicionales no debe superar los 64 KiB.

Si --plaintext-file o --additional-authenticated-data-file se configura como -, ese archivo se lee desde stdin. De manera similar, si configuras --ciphertext-file como -, el cifrado se escribirá en stdout.

El comando encrypt admite la marca opcional --version para indicar la versión de la clave que se utilizará en la encriptación. Según la configuración predeterminada, se usa la versión principal.

En el siguiente ejemplo de encrypt, se muestra cómo especificar una versión de clave y datos autenticados adicionales.

    gcloud kms encrypt \
      --location=location  \
      --keyring=keyring-name \
      --key=key-name \
      --version=key-version \
      --additional-authenticated-data-file=aad-file-path-and-name \
      --plaintext-file=filepath-and-file-to-encrypt \
      --ciphertext-file=encrypted-filepath-and-file.enc
    

Protocolo

El contenido debe estar codificado en base 64 antes de que Cloud KMS pueda encriptarlo.

Para encriptar datos, realiza una solicitud POST, proporciona la información del proyecto y la clave que corresponda, y especifica el texto codificado en Base64 que se encriptará en el campo plaintext del cuerpo de la solicitud. Reemplaza API_KEY por una clave de API válida. Consulta Accede a la API para obtener información sobre cómo generar una clave de API.

    POST https://cloudkms.googleapis.com/v1/projects/project-id/locations/location/keyRings/keyring-name/cryptoKeys/key-name:encrypt&key=api-key
    
    {
      "plaintext": "BASE64_ENCODED_INPUT",
    }
    

En este ejemplo, se usa curl:

    curl -s -X POST "https://cloudkms.googleapis.com/v1/projects/project-id/locations/location/keyRings/keyring-name/cryptoKeys/key-name:encrypt" \
      -d "{\"plaintext\":\"base64-encoded-input\"}" \
      -H "Authorization:Bearer api-key"\
      -H "Content-Type:application/json"
    

C#

        public static void Encrypt(string projectId, string locationId, string keyRingId, string cryptoKeyId,
    string plaintextFile, string ciphertextFile)
            {
                KeyManagementServiceClient client = KeyManagementServiceClient.Create();
                CryptoKeyName cryptoKeyName =
                    new CryptoKeyName(projectId, locationId, keyRingId, cryptoKeyId);

                byte[] plaintext = File.ReadAllBytes(plaintextFile);
                CryptoKeyPathName pathName = CryptoKeyPathName.Parse(cryptoKeyName.ToString());
                EncryptResponse result = client.Encrypt(pathName, ByteString.CopyFrom(plaintext));

                // Output encrypted data to a file.
                File.WriteAllBytes(ciphertextFile, result.Ciphertext.ToByteArray());
                Console.Write($"Encrypted file created: {ciphertextFile}");
            }

Go

import (
    	"context"
    	"fmt"

    	cloudkms "cloud.google.com/go/kms/apiv1"
    	kmspb "google.golang.org/genproto/googleapis/cloud/kms/v1"
    )

    // encryptSymmetric will encrypt the input plaintext with the specified symmetric key.
    func encryptSymmetric(name string, plaintext []byte) ([]byte, error) {
    	// name := "projects/PROJECT_ID/locations/global/keyRings/RING_ID/cryptoKeys/KEY_ID"
    	// plaintext := []byte("Sample message")
    	ctx := context.Background()
    	client, err := cloudkms.NewKeyManagementClient(ctx)
    	if err != nil {
    		return nil, fmt.Errorf("cloudkms.NewKeyManagementClient: %v", err)
    	}

    	// Build the request.
    	req := &kmspb.EncryptRequest{
    		Name:      name,
    		Plaintext: plaintext,
    	}
    	// Call the API.
    	resp, err := client.Encrypt(ctx, req)
    	if err != nil {
    		return nil, fmt.Errorf("Encrypt: %v", err)
    	}
    	return resp.Ciphertext, nil
    }
    

Java


    /** Encrypts the given plaintext using the specified crypto key. */
    public static byte[] encrypt(
        String projectId, String locationId, String keyRingId, String cryptoKeyId, byte[] plaintext)
        throws IOException {

      // Create the KeyManagementServiceClient using try-with-resources to manage client cleanup.
      try (KeyManagementServiceClient client = KeyManagementServiceClient.create()) {

        // The resource name of the cryptoKey
        String resourceName = CryptoKeyPathName.format(projectId, locationId, keyRingId, cryptoKeyId);

        // Encrypt the plaintext with Cloud KMS.
        EncryptResponse response = client.encrypt(resourceName, ByteString.copyFrom(plaintext));

        // Extract the ciphertext from the response.
        return response.getCiphertext().toByteArray();
      }
    }

Node.js

async function encrypt(
      projectId = 'your-project-id', // Your GCP projectId
      keyRingId = 'my-key-ring', // Name of the crypto key's key ring
      cryptoKeyId = 'my-key', // Name of the crypto key, e.g. "my-key"
      plaintextFileName = './path/to/plaintext.txt',
      ciphertextFileName = './path/to/plaintext.txt.encrypted'
    ) {
      const fs = require('fs');
      const {promisify} = require('util');

      // Import the library and create a client
      const kms = require('@google-cloud/kms');
      const client = new kms.KeyManagementServiceClient();

      // The location of the crypto key's key ring, e.g. "global"
      const locationId = 'global';

      // Reads the file to be encrypted
      const readFile = promisify(fs.readFile);
      const plaintext = await readFile(plaintextFileName);
      const name = client.cryptoKeyPath(
        projectId,
        locationId,
        keyRingId,
        cryptoKeyId
      );

      // Encrypts the file using the specified crypto key
      const [result] = await client.encrypt({name, plaintext});
      const writeFile = promisify(fs.writeFile);
      await writeFile(ciphertextFileName, result.ciphertext);
      console.log(`Encrypted ${plaintextFileName} using ${result.name}.`);
      console.log(`Result saved to ${ciphertextFileName}.`);
    }

PHP

use Google\Cloud\Kms\V1\KeyManagementServiceClient;

    /** Uncomment and populate these variables in your code */
    // $projectId = 'The Google project ID';
    // $locationId = 'The location ID of the crypto key. Can be "global", "us-west1", etc.';
    // $keyRingId = 'The KMS key ring ID';
    // $cryptoKeyId = 'The KMS key ID';
    // $plaintextFileName = 'The path to the file containing plaintext to encrypt';
    // $ciphertextFileName = 'The path to write the ciphertext';

    $kms = new KeyManagementServiceClient();

    // The resource name of the CryptoKey.
    $cryptoKeyName = $kms->cryptoKeyName($projectId, $locationId, $keyRingId, $cryptoKeyId);

    $plaintext = file_get_contents($plaintextFileName);
    $response = $kms->encrypt($cryptoKeyName, $plaintext);

    // Write the encrypted text to a file.
    file_put_contents($ciphertextFileName, $response->getCiphertext());
    printf('Saved encrypted text to %s' . PHP_EOL, $ciphertextFileName);

Python

def encrypt_symmetric(project_id, location_id, key_ring_id, crypto_key_id,
                          plaintext):
        """Encrypts input plaintext data using the provided symmetric CryptoKey."""

        from google.cloud import kms_v1

        # Creates an API client for the KMS API.
        client = kms_v1.KeyManagementServiceClient()

        # The resource name of the CryptoKey.
        name = client.crypto_key_path_path(project_id, location_id, key_ring_id,
                                           crypto_key_id)

        # Use the KMS API to encrypt the data.
        response = client.encrypt(name, plaintext)
        return response.ciphertext

Ruby

# project_id      = "Your Google Cloud project ID"
    # location_id     = "The location of the key ring"
    # key_ring_id     = "The ID of the key ring"
    # crypto_key_id   = "The ID of the crypto key"
    # plaintext_file  = "File to encrypt"
    # ciphertext_file = "File to store encrypted input data"

    require "google/cloud/kms/v1"
    CloudKMS = Google::Cloud::Kms::V1

    # Initialize the client
    client = CloudKMS::KeyManagementServiceClient.new

    # The crypto key to use
    crypto_key = CloudKMS::KeyManagementServiceClient.crypto_key_path(
      project_id, location_id, key_ring_id, crypto_key_id
    )

    # Read the secret data from the file
    plaintext = File.open(plaintext_file, "rb", &:read)

    # Use the KMS API to encrypt the data
    response = client.encrypt crypto_key, plaintext

    # Write the encrypted binary data to the output file
    File.open(ciphertext_file, "wb") { |f| f.write response.ciphertext }

    puts "Saved encrypted #{plaintext_file} as #{ciphertext_file}"

Inhabilita la versión de clave anterior o programa su destrucción

Si rotaste la clave en respuesta a un posible incidente, inhabilita o la versión de clave anterior programa su destrucción después de volver a encriptar los datos.

Inhabilita una versión de clave habilitada

Solo se pueden inhabilitar las claves habilitadas. Para ello, usa el método UpdateCryptoKeyVersion.

Línea de comandos

Para inhabilitar la versión 42 de la clave answer del llavero de claves answers en la ubicación global, usa el siguiente comando:

    gcloud kms keys versions disable 42 \
      --location global \
      --keyring answers \
      --key answer
    

C#

      public static void DisableCryptoKeyVersion(string projectId, string locationId, string keyRingId, string cryptoKeyId, string versionId)
          {
              KeyManagementServiceClient client = KeyManagementServiceClient.Create();

              // The CryptoKeyVersion to disable.
              CryptoKeyVersionName versionName =
                  new CryptoKeyVersionName(projectId, locationId, keyRingId, cryptoKeyId, versionId);

              CryptoKeyVersion version = client.GetCryptoKeyVersion(versionName);
              version.State = CryptoKeyVersion.Types.CryptoKeyVersionState.Disabled;

              FieldMask fieldMask = new FieldMask { Paths = { "state" } };

              CryptoKeyVersion patchResult = client.UpdateCryptoKeyVersion(version, fieldMask);

              Console.Write($"Disabled Crypto Key Version: {patchResult.Name}");
          }

Go

import (
    	"context"
    	"fmt"
    	"io"

    	cloudkms "cloud.google.com/go/kms/apiv1"
    	kmspb "google.golang.org/genproto/googleapis/cloud/kms/v1"
    	fieldmask "google.golang.org/genproto/protobuf/field_mask"
    )

    // disableCryptoKeyVersion disables a specified key version on KMS.
    func disableCryptoKeyVersion(w io.Writer, name string) error {
    	// name := "projects/PROJECT_ID/locations/global/keyRings/RING_ID/cryptoKeys/KEY_ID/cryptoKeyVersions/1"
    	ctx := context.Background()
    	client, err := cloudkms.NewKeyManagementClient(ctx)
    	if err != nil {
    		return fmt.Errorf("cloudkms.NewKeyManagementClient: %v", err)
    	}
    	// Build the request.
    	req := &kmspb.UpdateCryptoKeyVersionRequest{
    		CryptoKeyVersion: &kmspb.CryptoKeyVersion{
    			Name:  name,
    			State: kmspb.CryptoKeyVersion_DISABLED,
    		},
    		UpdateMask: &fieldmask.FieldMask{
    			Paths: []string{"state"},
    		},
    	}
    	// Call the API.
    	result, err := client.UpdateCryptoKeyVersion(ctx, req)
    	if err != nil {
    		return fmt.Errorf("UpdateCryptoKeyVersion: %v", err)
    	}
    	fmt.Fprintf(w, "Disabled crypto key version: %s", result)
    	return nil
    }
    

Java


    /** Disables the given version of the crypto key. */
    public static CryptoKeyVersion disableCryptoKeyVersion(
        String projectId, String locationId, String keyRingId, String cryptoKeyId, String version)
        throws IOException {
      // Create the Cloud KMS client.
      try (KeyManagementServiceClient client = KeyManagementServiceClient.create()) {

        // The resource name of the cryptoKey version
        String versionName =
            CryptoKeyVersionName.format(projectId, locationId, keyRingId, cryptoKeyId, version);

        // Retrieve the current state
        CryptoKeyVersion current = client.getCryptoKeyVersion(versionName);

        // Build a copy that updates the state to disabled
        CryptoKeyVersion updated =
            CryptoKeyVersion.newBuilder()
                .setName(current.getName())
                .setState(CryptoKeyVersionState.DISABLED)
                .build();

        // Create a FieldMask that only allows 'state' to be updated
        FieldMask fieldMask = FieldMaskUtil.fromString(CryptoKeyVersion.class, "state");

        // Update the version state
        CryptoKeyVersion response = client.updateCryptoKeyVersion(updated, fieldMask);

        return response;
      }
    }

Node.js

async function disableCryptoKeyVersion(
      projectId = 'your-project-id', // Your GCP Project ID
      keyRingId = 'my-key-ring', // Name of the crypto key version's key ring
      cryptoKeyId = 'my-key', // Name of the version's crypto key
      version = 1234 // The version's id
    ) {
      // Import the library and create a client
      const kms = require('@google-cloud/kms');
      const client = new kms.KeyManagementServiceClient();

      // The location of the crypto key versions's key ring, e.g. "global"
      const locationId = 'global';

      // Get the full path to the crypto key
      const name = client.cryptoKeyVersionPath(
        projectId,
        locationId,
        keyRingId,
        cryptoKeyId,
        version
      );

      // Gets a crypto key version
      const [cryptoKeyVersion] = await client.getCryptoKeyVersion({name});

      // Disables a crypto key version
      const [result] = await client.updateCryptoKeyVersion({
        cryptoKeyVersion: {state: 'DISABLED', name: cryptoKeyVersion.name},
        updateMask: ['state'],
      });
      console.log(`Crypto key version ${result.name} disabled.`);
    }

PHP

use Google\Cloud\Kms\V1\KeyManagementServiceClient;
    use Google\Cloud\Kms\V1\CryptoKeyVersion\CryptoKeyVersionState;
    use Google\Protobuf\FieldMask;

    /** Uncomment and populate these variables in your code */
    // $projectId = 'The Google project ID';
    // $locationId = 'The location ID of the crypto key. Can be "global", "us-west1", etc.';
    // $keyRingId = 'The KMS key ring ID';
    // $cryptoKeyId = 'The KMS key ID';
    // $version = 'The KMS key version number';

    $kms = new KeyManagementServiceClient();

    // The resource name of the Crypto Key version.
    $cryptoKeyVersionName = $kms->cryptoKeyVersionName($projectId, $locationId, $keyRingId, $cryptoKeyId, $version);

    // Get the CryptoKey.
    $cryptoKeyVersion = $kms->getCryptoKeyVersion($cryptoKeyVersionName);
    // Disable the cryptokey
    $cryptoKeyVersion->setState(CryptoKeyVersionState::DISABLED);

    $updateMask = new FieldMask();
    $updateMask->setPaths(['state']);
    $kms->updateCryptoKeyVersion($cryptoKeyVersion, $updateMask);

    printf('Disabled version %s for cryptoKey %s in keyRing %s' . PHP_EOL, $version, $cryptoKeyId, $keyRingId);

Python

def disable_crypto_key_version(project_id, location_id, key_ring_id,
                                   crypto_key_id, version_id):
        """Disables a CryptoKeyVersion associated with a given CryptoKey and
        KeyRing."""

        from google.cloud import kms_v1
        from google.cloud.kms_v1 import enums

        # Creates an API client for the KMS API.
        client = kms_v1.KeyManagementServiceClient()

        # Construct the resource name of the CryptoKeyVersion.
        name = client.crypto_key_version_path(project_id, location_id, key_ring_id,
                                              crypto_key_id, version_id)

        # Use the KMS API to disable the CryptoKeyVersion.
        new_state = enums.CryptoKeyVersion.CryptoKeyVersionState.DISABLED
        version = {'name': name, 'state': new_state}
        update_mask = {'paths': ["state"]}

        # Print results
        response = client.update_crypto_key_version(version, update_mask)
        print('CryptoKeyVersion {}\'s state has been set to {}.'.format(
            name, response.state))

Ruby

# project_id    = "Your Google Cloud project ID"
    # location_id   = "The location of the key ring"
    # key_ring_id   = "The ID of the key ring"
    # crypto_key_id = "The ID of the crypto key"
    # version_id    = "Version of the crypto key"

    require "google/cloud/kms/v1"
    CloudKMS = Google::Cloud::Kms::V1

    # Initialize the client
    client = CloudKMS::KeyManagementServiceClient.new

    # Retrieve the crypto key version to update
    version_path = CloudKMS::KeyManagementServiceClient.crypto_key_version_path(
      project_id, location_id, key_ring_id, crypto_key_id, version_id
    )
    version = client.get_crypto_key_version version_path

    # Set the version state to disabled for update
    version.state = CloudKMS::CryptoKeyVersion::CryptoKeyVersionState::DISABLED
    update_mask = Google::Protobuf::FieldMask.new
    update_mask.paths << "state"

    # Disable the crypto key version
    result = client.update_crypto_key_version version, update_mask

    puts "Disabled version #{version_id} of #{crypto_key_id}"

Programa la destrucción de una versión de clave

Solo se puede programar la destrucción de las versiones de clave habilitadas o inhabilitadas. Para ello, usa el método DestroyCryptoKeyVersion.

Para evitar accidentes y daños por parte de individuos malintencionados, cuando se usa DestroyCryptoKeyVersion, el material de clave NO se destruye de inmediato. En lugar de eso, la versión de clave pasa a estar programada para su destrucción durante 24 horas, período después del cual se destruye automáticamente. No hay forma de anular este resguardo de seguridad. Si decides cancelar la destrucción, tienes un plazo de 24 horas después de la programación para restablecer la versión de clave.

La destrucción se refiere a la eliminación del material de clave, pero aún existe un registro de la versión (p. ej., el número de versión no se puede volver a usar). Esta acción NO se puede revertir, y cualquier dato encriptado con esta versión no podrá recuperarse.

Línea de comandos

Destruye la versión 42 de la clave answer del llavero de claves answers en la ubicación global.

    gcloud kms keys versions destroy 42 \
      --location global \
      --keyring answers \
      --key answer
    

C#

      public static void DestroyCryptoKeyVersion(string projectId, string locationId, string keyRingId, string cryptoKeyId, string versionId)
          {
              KeyManagementServiceClient client = KeyManagementServiceClient.Create();

              // The CryptoKeyVersion to destroy.
              CryptoKeyVersionName versionName =
                  new CryptoKeyVersionName(projectId, locationId, keyRingId, cryptoKeyId, versionId);

              CryptoKeyVersion result = client.DestroyCryptoKeyVersion(versionName);

              Console.Write($"Destroyed Crypto Key Version: {result.Name}");
          }

Go

import (
    	"context"
    	"fmt"
    	"io"

    	cloudkms "cloud.google.com/go/kms/apiv1"
    	kmspb "google.golang.org/genproto/googleapis/cloud/kms/v1"
    )

    // destroyCryptoKeyVersion marks a specified key version for deletion.
    // The key can be restored if requested within 24 hours.
    func destroyCryptoKeyVersion(w io.Writer, name string) error {
    	// name := "projects/PROJECT_ID/locations/global/keyRings/RING_ID/cryptoKeys/KEY_ID/cryptoKeyVersions/1"
    	ctx := context.Background()
    	client, err := cloudkms.NewKeyManagementClient(ctx)
    	if err != nil {
    		return fmt.Errorf("cloudkms.NewKeyManagementClient: %v", err)
    	}
    	// Build the request.
    	req := &kmspb.DestroyCryptoKeyVersionRequest{
    		Name: name,
    	}
    	// Call the API.
    	result, err := client.DestroyCryptoKeyVersion(ctx, req)
    	if err != nil {
    		return fmt.Errorf("DestroyCryptoKeyVersion: %v", err)
    	}
    	fmt.Fprintf(w, "Destroyed crypto key version: %s", result)
    	return nil
    }
    

Java


    /** Marks the given version of a crypto key to be destroyed at a scheduled future point. */
    public static CryptoKeyVersion destroyCryptoKeyVersion(
        String projectId, String locationId, String keyRingId, String cryptoKeyId, String version)
        throws IOException {

      // Create the Cloud KMS client.
      try (KeyManagementServiceClient client = KeyManagementServiceClient.create()) {

        // The resource name of the cryptoKey version
        String versionName =
            CryptoKeyVersionName.format(projectId, locationId, keyRingId, cryptoKeyId, version);

        // Destroy the cryptoKey version
        CryptoKeyVersion destroyed = client.destroyCryptoKeyVersion(versionName);

        return destroyed;
      }
    }

Node.js

async function destroyCryptoKeyVersion(
      projectId = 'your-project-id', // Your GCP projectId
      keyRingId = 'my-key-ring', // Name of the crypto key version's key ring
      cryptoKeyId = 'my-key', // Name of the version's crypto key
      version = 1234 // The version's id
    ) {
      // Import the library and create a client
      const kms = require('@google-cloud/kms');
      const client = new kms.KeyManagementServiceClient();

      // The location of the crypto key versions's key ring, e.g. "global"
      const locationId = 'global';

      // Get the full path to the crypto key version
      const name = client.cryptoKeyVersionPath(
        projectId,
        locationId,
        keyRingId,
        cryptoKeyId,
        version
      );

      // destroys a crypto key version
      const [result] = await client.destroyCryptoKeyVersion({name});
      console.log(`Crypto key version ${result.name} destroyed.`);
    }

PHP

use Google\Cloud\Kms\V1\KeyManagementServiceClient;

    /** Uncomment and populate these variables in your code */
    // $projectId = 'The Google project ID';
    // $locationId = 'The location ID of the crypto key. Can be "global", "us-west1", etc.';
    // $keyRingId = 'The KMS key ring ID';
    // $cryptoKeyId = 'The KMS key ID';
    // $version = 'The KMS key version number';

    $kms = new KeyManagementServiceClient();

    // The resource name of the Crypto Key version.
    $cryptoKeyVersionName = $kms->cryptoKeyVersionName($projectId, $locationId, $keyRingId, $cryptoKeyId, $version);

    // Get the CryptoKey.
    $cryptoKeyVersion = $kms->destroyCryptoKeyVersion($cryptoKeyVersionName);

    printf('Destroyed version %s for cryptoKey %s in keyRing %s' . PHP_EOL, $version, $cryptoKeyId, $keyRingId);

Python

def destroy_crypto_key_version(
            project_id, location_id, key_ring_id, crypto_key_id, version_id):
        """Schedules a CryptoKeyVersion associated with a given CryptoKey and
        KeyRing for destruction 24 hours in the future."""

        from google.cloud import kms_v1

        # Creates an API client for the KMS API.
        client = kms_v1.KeyManagementServiceClient()

        # Construct the resource name of the CryptoKeyVersion.
        name = client.crypto_key_version_path(project_id, location_id, key_ring_id,
                                              crypto_key_id, version_id)

        # Use the KMS API to mark the CryptoKeyVersion for destruction.
        response = client.destroy_crypto_key_version(name)

        # Print results
        print('CryptoKeyVersion {}\'s state has been set to {}.'.format(
            name, response.state))

Ruby

# project_id    = "Your Google Cloud project ID"
    # location_id   = "The location of the key ring"
    # key_ring_id   = "The ID of the key ring"
    # crypto_key_id = "The ID of the crypto key"
    # version_id    = "Version of the crypto key"

    require "google/cloud/kms/v1"
    CloudKMS = Google::Cloud::Kms::V1

    # Initialize the client
    client = CloudKMS::KeyManagementServiceClient.new

    # The crypto key version to destroy
    version = CloudKMS::KeyManagementServiceClient.crypto_key_version_path(
      project_id, location_id, key_ring_id, crypto_key_id, version_id
    )

    # Destroy the crypto key version
    destroyed = client.destroy_crypto_key_version version

    puts "Destroyed version #{version_id} of #{crypto_key_id}"