Da utilizzare ReEncrypt con un AWS SDK o CLI

Esempio 1: ricrittografare un messaggio crittografato con una KMS chiave simmetrica diversa (Linux e macOS).

Il seguente esempio di re-encrypt comando mostra il metodo consigliato per ricrittografare i dati con. AWS CLI

Fornite il testo cifrato in un file. Nel valore del --ciphertext-blob parametro, utilizzate il fileb:// prefisso, che indica loro di leggere i dati CLI da un file binario. Se il file non si trova nella directory corrente, digitate il percorso completo del file. Per ulteriori informazioni sulla lettura AWS CLI dei valori dei parametri da un file, consultate Loading AWS CLI parameters from a file < https://docs.aws.amazon.com/cli/ latest/userguide/cli - usage-parameters-file .html> nella AWS Command Line Interface User Guide e Best Practices for Local File Parameters< https://aws.amazon.com/blogs/ developer/ best-practices-for-local -file-parameters/> nel AWS Command Line Tool Blog .Specificare la KMS chiave di origine, che decrittografa il CipherText.Il --source-key-id parametro non è richiesto quando si esegue la decrittografia con crittografia simmetrica KMSchiavi. AWS KMSpuò ottenere la KMS chiave utilizzata per crittografare i dati dai metadati nel blob di testo cifrato. Ma è sempre consigliabile specificare la chiave che si sta utilizzando. KMS Questa pratica garantisce l'utilizzo della KMS chiave desiderata e impedisce di decrittografare inavvertitamente un testo cifrato utilizzando una KMS chiave non attendibile.Specificate la chiave di destinazione, che cripta nuovamente i dati.Il parametro KMS è sempre obbligatorio. --destination-key-id Questo esempio utilizza una chiaveARN, ma è possibile utilizzare qualsiasi identificatore di chiave valido. Richiedere l'output in chiaro come valore di testo. Il --query parametro indica loro di CLI ottenere solo il valore del Plaintext campo dall'output. Il --output parametro restituisce l'output come text.BASE64-Decode il testo non crittografato e lo salva in un file.L'esempio seguente trasferisce (|) il valore del parametro all'utilità Base64, che lo decodifica. Plaintext Quindi, reindirizza (>) l'output decodificato al file. ExamplePlaintext

Prima di eseguire questo comando, sostituisci la chiave di esempio IDs con identificatori di chiave validi del tuo account. 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

Questo comando non produce alcun output. L'output del re-encrypt comando viene decodificato in base64 e salvato in un file.

Per ulteriori informazioni, vedere ReEncrypt < https://docs.aws.amazon.com/kms/ latest/APIReference/API _ ReEncrypt .html nel Key Management Service Reference.AWS API

Esempio 2: Per crittografare nuovamente un messaggio crittografato con una KMS chiave simmetrica diversa (prompt dei comandi di Windows).

Il seguente esempio di re-encrypt comando è lo stesso del precedente, tranne per il fatto che utilizza l'certutilutilità per decodificare in Base64 i dati di testo in chiaro. Questa procedura richiede due comandi, come illustrato negli esempi seguenti.

Prima di eseguire questo comando, sostituisci l'ID della chiave di esempio con un ID chiave valido del tuo AWS account.

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

Quindi usa l'certutilutilità

certutil -decode ExamplePlaintextFile.base64 ExamplePlaintextFile

Output:

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

Per ulteriori informazioni, vedere ReEncrypt < https://docs.aws.amazon.com/kms/ latest/APIReference/API _ ReEncrypt .html nel AWS Key Management Service API Reference.

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(())
}