- 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_DECRYPTengagement. 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.ForbidEncryptAllowDecryptargument. À 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_DECRYPTargument. À 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 encryptdecrypt, 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
)
