- C
-
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)
- C# / .NET
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);
- AWS Encryption CLI
-
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, vedi 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 .
- Java
-
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.ForbidEncryptAllowDecrypt
argomento. 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();
- JavaScript
-
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_DECRYPT
argomento. 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)
- Python
-
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 encrypt
decrypt
, 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
)