ReEncryptÚselo con una AWS SDK o CLI

Ejemplo 1: volver a cifrar un mensaje cifrado con una KMS clave simétrica diferente (Linux y macOS).

El siguiente ejemplo de re-encrypt comando muestra la forma recomendada de volver a cifrar los datos con. AWS CLI

Proporcione el texto cifrado de un archivo. En el valor del --ciphertext-blob parámetro, utilice el fileb:// prefijo, que indica que debe leer los datos de un archivo CLI binario. Si el archivo no se encuentra en el directorio actual, escriba la ruta completa al archivo. Para obtener más información sobre la lectura de los valores de los AWS CLI AWS CLI parámetros de un archivo, consulte Carga de parámetros desde un archivo < https://docs.aws.amazon.com/cli/ latest/userguide/cli - usage-parameters-file .html> en la Guía del usuario de la interfaz de línea de AWS comandos y Prácticas recomendadas para los parámetros de archivos locales< https://aws.amazon.com/blogs/ developer/ best-practices-for-local -file-parameters/> en el blog de herramientas de línea de AWS comandos .Especifique la KMS clave fuente, que descifra el texto cifrado.El --source-key-id parámetro no es necesario cuando se descifra con cifrado simétrico. KMS AWS KMSpuede obtener la KMS clave que se utilizó para cifrar los datos de los metadatos del blob de texto cifrado. Sin embargo, siempre se recomienda especificar la KMS clave que se está utilizando. Esta práctica garantiza que utiliza la KMS clave deseada y evita que descifre inadvertidamente un texto cifrado con una clave en la que no confíe. Especifique la KMS clave de destino, que volverá a cifrar los datos. El parámetro siempre KMS es obligatorio. --destination-key-id En este ejemplo se utiliza una claveARN, pero se puede utilizar cualquier identificador de clave válido. Solicite la salida en texto simple como un valor de texto.El parámetro le indica a la que debe obtener únicamente el valor del campo de la salida. --query CLI Plaintext El parámetro --output devuelve la salida como texto. Decodifique en base64 el texto sin formato y guárdelo en un archivo. El siguiente ejemplo canaliza (|) el valor del parámetro Plaintext a la utilidad Base64, que lo decodifica. A continuación, redirige (>) la salida descodificada al archivo ExamplePlaintext.

Antes de ejecutar este comando, sustituya la clave de ejemplo por identificadores de clave IDs válidos de su cuenta. AWS

aws kms re-encrypt \
    --ciphertext-blob fileb://ExampleEncryptedFile \
    --source-key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --destination-key-id 0987dcba-09fe-87dc-65ba-ab0987654321 \
    --query CiphertextBlob \
    --output text | base64 --decode > ExampleReEncryptedFile

Este comando no genera ninguna salida. La salida del comando re-encrypt se descodifica en base64 y se guarda en un archivo.

Para obtener más información, consulte ReEncrypt < https://docs.aws.amazon.com/kms/ latest/APIReference/API _ ReEncrypt .html en la referencia del servicio API de administración de AWS claves.

Ejemplo 2: Para volver a cifrar un mensaje cifrado con una KMS clave simétrica diferente (línea de comandos de Windows).

El siguiente comando re-encrypt de ejemplo es el mismo que el anterior, excepto que usa la utilidad certutil para descodificar en Base64 los datos de texto sin formato. Como se muestra en los siguientes ejemplos, este procedimiento requiere dos comandos.

Antes de ejecutar este comando, sustituya el identificador de clave de ejemplo por un identificador de clave válido de su cuenta. AWS

aws kms re-encrypt ^
    --ciphertext-blob fileb://ExampleEncryptedFile ^
    --source-key-id 1234abcd-12ab-34cd-56ef-1234567890ab ^
    --destination-key-id 0987dcba-09fe-87dc-65ba-ab0987654321 ^
    --query CiphertextBlob ^
    --output text > ExampleReEncryptedFile.base64

A continuación, use la utilidad certutil

certutil -decode ExamplePlaintextFile.base64 ExamplePlaintextFile

Salida:

Input Length = 18
Output Length = 12
CertUtil: -decode command completed successfully.

Para obtener más información, consulte ReEncrypt < https://docs.aws.amazon.com/kms/ latest/APIReference/API _ ReEncrypt .html en la APIreferencia del servicio de administración de AWS claves.

class KeyEncrypt:
    def __init__(self, kms_client):
        self.kms_client = kms_client

    @classmethod
    def from_client(cls) -> "KeyEncrypt":
        """
        Creates a KeyEncrypt instance with a default KMS client.

        :return: An instance of KeyEncrypt initialized with the default KMS client.
        """
        kms_client = boto3.client("kms")
        return cls(kms_client)


    def re_encrypt(self, source_key_id, cipher_text):
        """
        Takes ciphertext previously encrypted with one key and reencrypt it by using
        another key.

        :param source_key_id: The ARN or ID of the original key used to encrypt the
                              ciphertext.
        :param cipher_text: The encrypted ciphertext.
        :return: The ciphertext encrypted by the second key.
        """
        destination_key_id = input(
            f"Your ciphertext is currently encrypted with key {source_key_id}. "
            f"Enter another key ID or ARN to reencrypt it: "
        )
        if destination_key_id != "":
            try:
                cipher_text = self.kms_client.re_encrypt(
                    SourceKeyId=source_key_id,
                    DestinationKeyId=destination_key_id,
                    CiphertextBlob=cipher_text,
                )["CiphertextBlob"]
            except ClientError as err:
                logger.error(
                    "Couldn't reencrypt your ciphertext. Here's why: %s",
                    err.response["Error"]["Message"],
                )
            else:
                print(f"Reencrypted your ciphertext as: {cipher_text}")
                return cipher_text
        else:
            print("Skipping reencryption demo.")

require 'aws-sdk-kms' # v2: require 'aws-sdk'

# Human-readable version of the ciphertext of the data to reencrypt.

blob = '01020200785d68faeec386af1057904926253051eb2919d3c16078badf65b808b26dd057c101747cadf3593596e093d4ffbf22434a6d00000068306606092a864886f70d010706a0593057020100305206092a864886f70d010701301e060960864801650304012e3011040c9d629e573683972cdb7d94b30201108025b20b060591b02ca0deb0fbdfc2f86c8bfcb265947739851ad56f3adce91eba87c59691a9a1'
sourceCiphertextBlob = [blob].pack('H*')

# Replace the fictitious key ARN with a valid key ID

destinationKeyId = 'arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321'

client = Aws::KMS::Client.new(region: 'us-west-2')

resp = client.re_encrypt({
                           ciphertext_blob: sourceCiphertextBlob,
                           destination_key_id: destinationKeyId
                         })

# Display a readable version of the resulting re-encrypted blob.
puts 'Blob:'
puts resp.ciphertext_blob.unpack('H*')

async fn reencrypt_string(
    verbose: bool,
    client: &Client,
    input_file: &str,
    output_file: &str,
    first_key: &str,
    new_key: &str,
) -> Result<(), Error> {
    // Get blob from input file
    // Open input text file and get contents as a string
    // input is a base-64 encoded string, so decode it:
    let data = fs::read_to_string(input_file)
        .map(|input_file| base64::decode(input_file).expect("invalid base 64"))
        .map(Blob::new);

    let resp = client
        .re_encrypt()
        .ciphertext_blob(data.unwrap())
        .source_key_id(first_key)
        .destination_key_id(new_key)
        .send()
        .await?;

    // Did we get an encrypted blob?
    let blob = resp.ciphertext_blob.expect("Could not get encrypted text");
    let bytes = blob.as_ref();

    let s = base64::encode(bytes);
    let o = &output_file;

    let mut ofile = File::create(o).expect("unable to create file");
    ofile.write_all(s.as_bytes()).expect("unable to write");

    if verbose {
        println!("Wrote the following to {}:", output_file);
        println!("{}", s);
    } else {
        println!("Wrote base64-encoded output to {}", output_file);
    }

    Ok(())
}