Impostazione della politica di impegno

A partire dalla versione 1.7. x of the SDK di crittografia AWS per C, si utilizza la aws_cryptosdk_session_set_commitment_policy funzione per impostare la politica di impegno per le sessioni di crittografia e decrittografia. La politica di impegno impostata si applica a tutte le operazioni di crittografia e decrittografia eseguite in quella sessione.

Le aws_cryptosdk_session_new_from_cmm funzioni aws_cryptosdk_session_new_from_keyring and sono obsolete nella versione 1.7. x e rimosso nella versione 2.0. x. Queste funzioni vengono sostituite da aws_cryptosdk_session_new_from_keyring_2 e aws_cryptosdk_session_new_from_cmm_2 funzioni che restituiscono una sessione.

Quando si utilizza aws_cryptosdk_session_new_from_keyring_2 la aws_cryptosdk_session_new_from_cmm_2 versione più recente di 1. x versioni, è necessario chiamare la aws_cryptosdk_session_set_commitment_policy funzione con il valore della policy di COMMITMENT_POLICY_FORBID_ENCRYPT_ALLOW_DECRYPT impegno. Nelle versioni 2.0. x e versioni successive, la chiamata a questa funzione è facoltativa e richiede tutti i valori validi. La politica di impegno predefinita per le versioni 2.0. x e versioni successive sonoCOMMITMENT_POLICY_REQUIRE_ENCRYPT_REQUIRE_DECRYPT.

Per un esempio completo, vedi string.cpp.

/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();

/* Create an AWS KMS keyring */
const char * key_arn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
struct aws_cryptosdk_keyring *kms_keyring = Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn);

/* Create an encrypt session with a CommitmentPolicy setting */
struct aws_cryptosdk_session *encrypt_session = aws_cryptosdk_session_new_from_keyring_2(
    alloc, AWS_CRYPTOSDK_ENCRYPT, kms_keyring);

aws_cryptosdk_keyring_release(kms_keyring);
aws_cryptosdk_session_set_commitment_policy(encrypt_session,
    COMMITMENT_POLICY_FORBID_ENCRYPT_ALLOW_DECRYPT);

...
/* Encrypt your data */

size_t plaintext_consumed_output;
aws_cryptosdk_session_process(encrypt_session,
                              ciphertext_output,
                              ciphertext_buf_sz_output,
                              ciphertext_len_output,
                              plaintext_input,
                              plaintext_len_input,
                              &plaintext_consumed_output)
...

/* Create a decrypt session with a CommitmentPolicy setting */

struct aws_cryptosdk_keyring *kms_keyring = Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn);
struct aws_cryptosdk_session *decrypt_session = *aws_cryptosdk_session_new_from_keyring_2(
        alloc, AWS_CRYPTOSDK_DECRYPT, kms_keyring);
aws_cryptosdk_keyring_release(kms_keyring);
aws_cryptosdk_session_set_commitment_policy(decrypt_session,
        COMMITMENT_POLICY_FORBID_ENCRYPT_ALLOW_DECRYPT);

/* Decrypt your ciphertext */
size_t ciphertext_consumed_output;
aws_cryptosdk_session_process(decrypt_session,
                              plaintext_output,
                              plaintext_buf_sz_output,
                              plaintext_len_output,
                              ciphertext_input,
                              ciphertext_len_input,
                              &ciphertext_consumed_output)

Il require-encrypt-require-decrypt valore è la politica di impegno predefinita in tutte le versioni del AWS Encryption SDK modulo. NET. È possibile impostarlo esplicitamente come procedura consigliata, ma non è obbligatorio. Tuttavia, se si utilizza il AWS Encryption SDK for. NETper decrittografare il testo cifrato che è stato crittografato mediante un'implementazione in un'altra lingua di AWS Encryption SDK Without Key Commitment Commitment, è necessario modificare il valore della policy di impegno in or. REQUIRE_ENCRYPT_ALLOW_DECRYPT FORBID_ENCRYPT_ALLOW_DECRYPT In caso contrario, i tentativi di decrittografare il testo cifrato falliranno.

Nella forma. AWS Encryption SDK NET, hai impostato la politica di impegno su un'istanza di AWS Encryption SDK. Crea un'istanza di un AwsEncryptionSdkConfig oggetto con un CommitmentPolicy parametro e usa l'oggetto di configurazione per creare l' AWS Encryption SDK istanza. Quindi, chiamate i Decrypt() metodi Encrypt() and dell'istanza AWS Encryption SDK configurata.

Questo esempio imposta la politica di impegno surequire-encrypt-allow-decrypt.

// Instantiate the material providers
var materialProviders =
    AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();

// Configure the commitment policy on the AWS Encryption SDK instance
var config = new AwsEncryptionSdkConfig
{
    CommitmentPolicy = CommitmentPolicy.REQUIRE_ENCRYPT_ALLOW_DECRYPT
};
var encryptionSdk = AwsEncryptionSdkFactory.CreateAwsEncryptionSdk(config);

string keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";

var encryptionContext = new Dictionary<string, string>()
{
    {"purpose", "test"}encryptionSdk
};

var createKeyringInput = new CreateAwsKmsKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(),
    KmsKeyId = keyArn
};
var keyring = materialProviders.CreateAwsKmsKeyring(createKeyringInput);

// Encrypt your plaintext data
var encryptInput = new EncryptInput
{
    Plaintext = plaintext,
    Keyring = keyring,
    EncryptionContext = encryptionContext
};
var encryptOutput = encryptionSdk.Encrypt(encryptInput);

// Decrypt your ciphertext
var decryptInput = new DecryptInput
{
    Ciphertext = ciphertext,
    Keyring = keyring
};
var decryptOutput = encryptionSdk.Decrypt(decryptInput);

Per impostare una politica di impegno nella AWS crittografiaCLI, utilizzare il --commitment-policy parametro. Questo parametro è stato introdotto nella versione 1.8. x.

Nell'ultimo 1. versione x, quando si utilizza il --wrapping-keys parametro in un --decrypt comando --encrypt or, è richiesto un --commitment-policy parametro con il forbid-encrypt-allow-decrypt valore. Altrimenti, il --commitment-policy parametro non è valido.

Nelle versioni 2.1. x e versioni successive, il --commitment-policy parametro è facoltativo e il valore predefinito è il require-encrypt-require-decrypt valore, che non crittograferà o decrittograferà alcun testo cifrato crittografato senza l'impegno di una chiave. Tuttavia, ti consigliamo di impostare la politica di impegno in modo esplicito in tutte le chiamate di crittografia e decrittografia per facilitare la manutenzione e la risoluzione dei problemi.

Questo esempio imposta la politica di impegno. Utilizza inoltre il --wrapping-keys parametro che sostituisce il --master-keys parametro a partire dalla versione 1.8. x. Per informazioni dettagliate, consultare Aggiornamento dei provider di chiavi AWS KMS principali. Per esempi completi, vedereEsempi diAWSCLI di crittografia.

\\ To run this example, replace the fictitious key ARN with a valid value. 
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab

\\ Encrypt your plaintext data - no change to algorithm suite used
$ aws-encryption-cli --encrypt \
                     --input hello.txt \
                     --wrapping-keys key=$keyArn \
                     --commitment-policy forbid-encrypt-allow-decrypt \
                     --metadata-output ~/metadata \
                     --encryption-context purpose=test \
                     --output .

\\ Decrypt your ciphertext - supports key commitment on 1.7 and later
$ aws-encryption-cli --decrypt \
                     --input hello.txt.encrypted \
                     --wrapping-keys key=$keyArn \
                     --commitment-policy forbid-encrypt-allow-decrypt \
                     --encryption-context purpose=test \
                     --metadata-output ~/metadata \
                     --output .

A partire dalla versione 1.7. x di SDK di crittografia AWS per Java, imposti la politica di impegno sulla tua istanza diAwsCrypto, l'oggetto che rappresenta il AWS Encryption SDK client. Questa impostazione della politica di impegno si applica a tutte le operazioni di crittografia e decrittografia eseguite su quel client.

Il AwsCrypto() costruttore è obsoleto nell'ultima versione 1. le versioni x di SDK di crittografia AWS per Java and vengono rimosse nella versione 2.0. x. Viene sostituito da una nuova Builder classe, da un Builder.withCommitmentPolicy() metodo e dal tipo CommitmentPolicy enumerato.

Nell'ultimo 1. x versioni, la Builder classe richiede il Builder.withCommitmentPolicy() metodo e l'CommitmentPolicy.ForbidEncryptAllowDecryptargomento. A partire dalla versione 2.0. x, il Builder.withCommitmentPolicy() metodo è facoltativo; il valore predefinito èCommitmentPolicy.RequireEncryptRequireDecrypt.

Per un esempio completo, consulta SetCommitmentPolicyExample.java.

// Instantiate the client
final AwsCrypto crypto = AwsCrypto.builder()
    .withCommitmentPolicy(CommitmentPolicy.ForbidEncryptAllowDecrypt)
    .build();

// Create a master key provider in strict mode
String awsKmsKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";

KmsMasterKeyProvider masterKeyProvider = KmsMasterKeyProvider.builder()
    .buildStrict(awsKmsKey);

// Encrypt your plaintext data
CryptoResult<byte[], KmsMasterKey> encryptResult = crypto.encryptData(
    masterKeyProvider,
    sourcePlaintext,
    encryptionContext);
byte[] ciphertext = encryptResult.getResult();

// Decrypt your ciphertext
CryptoResult<byte[], KmsMasterKey> decryptResult = crypto.decryptData(
        masterKeyProvider,
        ciphertext);
byte[] decrypted = decryptResult.getResult();

A partire dalla versione 1.7. x of the SDK di crittografia AWS per JavaScript, è possibile impostare la politica di impegno quando si chiama la nuova buildClient funzione che crea un'istanza di un AWS Encryption SDK client. La buildClient funzione assume un valore enumerato che rappresenta la politica di impegno dell'utente. Restituisce decrypt funzioni aggiornate encrypt e che applicano la politica di impegno dell'utente durante la crittografia e la decrittografia.

Nell'ultimo 1. x versioni, la buildClient funzione richiede l'CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPTargomento. A partire dalla versione 2.0. x, l'argomento della politica di impegno è facoltativo e il valore predefinito èCommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT.

Il codice per Node.js e il browser sono identici per questo scopo, tranne per il fatto che il browser necessita di una dichiarazione per impostare le credenziali.

L'esempio seguente crittografa i dati con un AWS KMS portachiavi. La nuova buildClient funzione imposta la politica di impegno suFORBID_ENCRYPT_ALLOW_DECRYPT, il valore predefinito nell'ultimo 1. Versioni x. Gli aggiornamenti encrypt e le decrypt funzioni buildClient restituite applicano la politica di impegno impostata.

import { buildClient } from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT)

// Create an AWS KMS keyring
const generatorKeyId = 'arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias'
const keyIds = ['arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab']
const keyring = new KmsKeyringNode({ generatorKeyId, keyIds })

// Encrypt your plaintext data
const { ciphertext } = await encrypt(keyring, plaintext, { encryptionContext: context })

// Decrypt your ciphertext
const { decrypted, messageHeader } = await decrypt(keyring, ciphertext)

A partire dalla versione 1.7. x di SDK di crittografia AWS per Python, imposti la politica di impegno sulla tua istanza diEncryptionSDKClient, un nuovo oggetto che rappresenta il AWS Encryption SDK client. La politica di impegno che hai impostato si applica a tutte encrypt le decrypt chiamate che utilizzano quell'istanza del client.

Nell'ultima versione 1. versioni x, il EncryptionSDKClient costruttore richiede il valore CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT enumerato. A partire dalla versione 2.0. x, l'argomento della politica di impegno è facoltativo e il valore predefinito èCommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT.

Questo esempio utilizza il nuovo EncryptionSDKClient costruttore e imposta la politica di impegno su 1.7. x valore predefinito. Il costruttore crea un'istanza di un client che rappresenta il. AWS Encryption SDK Quando chiami i stream metodi encryptdecrypt, o su questo client, questi applicano la politica di impegno che hai impostato. Questo esempio utilizza anche il nuovo costruttore per la StrictAwsKmsMasterKeyProvider classe, che specifica AWS KMS keys quando crittografare e decrittografare.

Per un esempio completo, vedete set_commitment.py.

# Instantiate the client
client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT)

// Create a master key provider in strict mode
aws_kms_key = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
aws_kms_strict_master_key_provider = StrictAwsKmsMasterKeyProvider(
        key_ids=[aws_kms_key]
)

# Encrypt your plaintext data
ciphertext, encrypt_header = client.encrypt(
        source=source_plaintext,
        encryption_context=encryption_context,
        master_key_provider=aws_kms_strict_master_key_provider
)

# Decrypt your ciphertext
decrypted, decrypt_header = client.decrypt(
        source=ciphertext,
        master_key_provider=aws_kms_strict_master_key_provider
)