- C
-
À partir de la version 1.7. x du Kit SDK de chiffrement AWS pour C, vous utilisez la aws_cryptosdk_session_set_commitment_policy
fonction pour définir la politique d'engagement de vos sessions de chiffrement et de déchiffrement. La politique d'engagement que vous avez définie s'applique à toutes les opérations de chiffrement et de déchiffrement appelées lors de cette session.
Les aws_cryptosdk_session_new_from_cmm
fonctions aws_cryptosdk_session_new_from_keyring
et sont obsolètes dans la version 1.7. x et supprimé dans la version 2.0. x. Ces fonctions sont remplacées par aws_cryptosdk_session_new_from_keyring_2
des aws_cryptosdk_session_new_from_cmm_2
fonctions qui renvoient une session.
Lorsque vous utilisez le aws_cryptosdk_session_new_from_keyring_2
et aws_cryptosdk_session_new_from_cmm_2
dans la dernière version 1. x versions, vous devez appeler la aws_cryptosdk_session_set_commitment_policy
fonction avec la valeur de la politique d'COMMITMENT_POLICY_FORBID_ENCRYPT_ALLOW_DECRYPT
engagement. Dans les versions 2.0. x et versions ultérieures, l'appel de cette fonction est facultatif et prend toutes les valeurs valides. Politique d'engagement par défaut pour les versions 2.0. x et les versions ultérieures sontCOMMITMENT_POLICY_REQUIRE_ENCRYPT_REQUIRE_DECRYPT
.
Pour obtenir un exemple complet, veuillez consulter 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
La require-encrypt-require-decrypt
valeur est la politique d'engagement par défaut dans toutes les versions du AWS Encryption SDK for. NET. Vous pouvez le définir explicitement en tant que meilleure pratique, mais ce n'est pas obligatoire. Toutefois, si vous utilisez le AWS Encryption SDK pour. NETpour déchiffrer un texte chiffré par une implémentation de l'engagement AWS Encryption SDK sans clé dans une autre langue, vous devez remplacer la valeur de la politique d'engagement par ou. REQUIRE_ENCRYPT_ALLOW_DECRYPT
FORBID_ENCRYPT_ALLOW_DECRYPT
Dans le cas contraire, les tentatives de déchiffrement du texte chiffré échoueront.
Dans le AWS Encryption SDK fourreau. NET, vous définissez la politique d'engagement pour une instance de AWS Encryption SDK. Instanciez un AwsEncryptionSdkConfig
objet avec un CommitmentPolicy
paramètre et utilisez l'objet de configuration pour créer l' AWS Encryption SDK instance. Appelez ensuite les Decrypt()
méthodes Encrypt()
et de l' AWS Encryption SDK instance configurée.
Cet exemple définit la politique d'engagement surrequire-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
-
Pour définir une politique d'engagement dans le AWS chiffrementCLI, utilisez le --commitment-policy
paramètre. Ce paramètre est introduit dans la version 1.8. x.
Dans le dernier 1. version x, lorsque vous utilisez le --wrapping-keys
paramètre dans une --decrypt
commande --encrypt
ou, un --commitment-policy
paramètre avec la forbid-encrypt-allow-decrypt
valeur est requis. Dans le cas contraire, le --commitment-policy
paramètre n'est pas valide.
Dans les versions 2.1. x et versions ultérieures, le --commitment-policy
paramètre est facultatif et prend par défaut la require-encrypt-require-decrypt
valeur, qui ne crypte ni ne déchiffre aucun texte chiffré sans engagement de clé. Toutefois, nous vous recommandons de définir la politique d'engagement de manière explicite dans tous les appels de chiffrement et de déchiffrement afin de faciliter la maintenance et le dépannage.
Cet exemple définit la politique d'engagement. Il utilise également le --wrapping-keys
paramètre qui remplace le --master-keys
paramètre à partir de la version 1.8. x. Pour plus de détails, consultez Mise à jour des fournisseurs de clés AWS KMS principales. Pour des exemples complets, voirExemples deAWSCLI de chiffrement.
\\ 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
-
À partir de la version 1.7. x du Kit SDK de chiffrement AWS pour Java, vous définissez la politique d'engagement sur votre instance deAwsCrypto
, l'objet qui représente le AWS Encryption SDK client. Ce paramètre de politique d'engagement s'applique à toutes les opérations de chiffrement et de déchiffrement effectuées sur ce client.
Le AwsCrypto()
constructeur est obsolète dans la dernière version 1. Les versions x de Kit SDK de chiffrement AWS pour Java et sont supprimées dans la version 2.0. x. Il est remplacé par une nouvelle Builder
classe, une nouvelle Builder.withCommitmentPolicy()
méthode et le type CommitmentPolicy
énuméré.
Dans le dernier 1. x versions, la Builder
classe a besoin de la Builder.withCommitmentPolicy()
méthode et de l'CommitmentPolicy.ForbidEncryptAllowDecrypt
argument. À partir de la version 2.0. x, la Builder.withCommitmentPolicy()
méthode est facultative ; la valeur par défaut estCommitmentPolicy.RequireEncryptRequireDecrypt
.
Pour un exemple complet, consultez 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
-
À partir de la version 1.7. x de Kit SDK de chiffrement AWS pour JavaScript, vous pouvez définir la politique d'engagement lorsque vous appelez la nouvelle buildClient
fonction qui instancie un AWS Encryption SDK client. La buildClient
fonction prend une valeur énumérée qui représente votre politique d'engagement. Il renvoie des decrypt
fonctionnalités mises à jour encrypt
et qui appliquent votre politique d'engagement lorsque vous cryptez et déchiffrez.
Dans le dernier 1. x versions, la buildClient
fonction nécessite l'CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT
argument. À partir de la version 2.0. x, l'argument de politique d'engagement est facultatif et la valeur par défaut estCommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
.
Le code de Node.js et celui du navigateur sont identiques à cette fin, sauf que le navigateur a besoin d'une instruction pour définir les informations d'identification.
L'exemple suivant chiffre les données à l'aide d'un AWS KMS trousseau de clés. La nouvelle buildClient
fonction définit la politique d'engagement sur FORBID_ENCRYPT_ALLOW_DECRYPT
la valeur par défaut de la dernière valeur 1. x versions. Les mises à niveau encrypt
et decrypt
les fonctions qui buildClient
en découlent appliquent la politique d'engagement que vous avez définie.
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
-
À partir de la version 1.7. x du Kit SDK de chiffrement AWS pour Python, vous définissez la politique d'engagement sur votre instance deEncryptionSDKClient
, un nouvel objet qui représente le AWS Encryption SDK client. La politique d'engagement que vous définissez s'applique à tous encrypt
les decrypt
appels qui utilisent cette instance du client.
Dans le dernier 1. x versions, le EncryptionSDKClient
constructeur a besoin de la valeur CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT
énumérée. À partir de la version 2.0. x, l'argument de politique d'engagement est facultatif et la valeur par défaut estCommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
.
Cet exemple utilise le nouveau EncryptionSDKClient
constructeur et définit la politique d'engagement sur 1.7. x valeur par défaut. Le constructeur instancie un client qui représente le. AWS Encryption SDK Lorsque vous appelez les stream
méthodes encrypt
decrypt
, ou sur ce client, elles appliquent la politique d'engagement que vous avez définie. Cet exemple utilise également le nouveau constructeur de la StrictAwsKmsMasterKeyProvider
classe, qui indique le AWS KMS keys moment du chiffrement et du déchiffrement.
Pour un exemple complet, consultez le fichier 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
)