Définition de votre politique d'engagement

À 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)

La require-encrypt-require-decrypt valeur est la politique d'engagement par défaut dans toutes les versions de 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 for .NET pour déchiffrer du texte chiffré par une autre implémentation linguistique de l'engagement AWS Encryption SDK sans clé, 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 fichier pour .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);

Pour définir une politique d'engagement dans la CLI de AWS chiffrement, 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 de CLI AWS 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 .

À 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 nécessite la Builder.withCommitmentPolicy() méthode et 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();

À 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)

À 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
)

La require-encrypt-require-decrypt valeur est la politique d'engagement par défaut dans toutes les versions de AWS Encryption SDK for Rust. Vous pouvez le définir explicitement en tant que meilleure pratique, mais ce n'est pas obligatoire. Toutefois, si vous utilisez AWS Encryption SDK for Rust pour déchiffrer du texte chiffré par une autre implémentation linguistique de l'engagement AWS Encryption SDK sans clé, vous devez modifier la valeur de la politique d'engagement en ou. REQUIRE_ENCRYPT_ALLOW_DECRYPT FORBID_ENCRYPT_ALLOW_DECRYPT Dans le cas contraire, les tentatives de déchiffrement du texte chiffré échoueront.

Dans AWS Encryption SDK for Rust, vous définissez la politique d'engagement pour une instance de AWS Encryption SDK. Instanciez un AwsEncryptionSdkConfig objet avec un comitment_policy 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 surforbid-encrypt-allow-decrypt.

// Configure the commitment policy on the AWS Encryption SDK instance
let esdk_config = AwsEncryptionSdkConfig::builder()
                    .commitment_policy(ForbidEncryptAllowDecrypt)
                    .build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;

// Create an AWS KMS client
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);

// Create your encryption context
let encryption_context = HashMap::from([
    ("encryption".to_string(), "context".to_string()),
    ("is not".to_string(), "secret".to_string()),
    ("but adds".to_string(), "useful metadata".to_string()),
    ("that can help you".to_string(), "be confident that".to_string()),
    ("the data you are handling".to_string(), "is what you think it is".to_string()),
]);

// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;

// Create an AWS KMS keyring
let kms_keyring = mpl
    .create_aws_kms_keyring()
    .kms_key_id(kms_key_id)
    .kms_client(kms_client)
    .send()
    .await?;

// Encrypt your plaintext data
let plaintext = example_data.as_bytes();

let encryption_response = esdk_client.encrypt()
    .plaintext(plaintext)
    .keyring(kms_keyring.clone())
    .encryption_context(encryption_context.clone())
    .send()
    .await?;

// Decrypt your ciphertext
let decryption_response = esdk_client.decrypt()
    .ciphertext(ciphertext)
    .keyring(kms_keyring)
    // Provide the encryption context that was supplied to the encrypt method
    .encryption_context(encryption_context)
    .send()
    .await?;

import (
    "context"
    
	mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
	mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
	client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
	esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/kms"
)

// Instantiate the AWS Encryption SDK client
commitPolicyForbidEncryptAllowDecrypt := mpltypes.ESDKCommitmentPolicyForbidEncryptAllowDecrypt
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{CommitmentPolicy: &commitPolicyForbidEncryptAllowDecrypt})
if err != nil {
    panic(err)
}

// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
    panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
    o.Region = KmsKeyRegion
})

// Optional: Create an encryption context
encryptionContext := map[string]string{
    "encryption":                "context",
    "is not":                    "secret",
    "but adds":                  "useful metadata",
    "that can help you":         "be confident that",
    "the data you are handling": "is what you think it is",
}

// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
    panic(err)
}

// Create an AWS KMS keyring
awsKmsKeyringInput := mpltypes.CreateAwsKmsKeyringInput{
    KmsClient: kmsClient,
    KmsKeyId:  kmsKeyId,
}
awsKmsKeyring, err := matProv.CreateAwsKmsKeyring(context.Background(), awsKmsKeyringInput)
if err != nil {
    panic(err)
}

// Encrypt your plaintext data
res, err := forbidEncryptClient.Encrypt(context.Background(), esdktypes.EncryptInput{
    Plaintext:         []byte(exampleText),
    EncryptionContext: encryptionContext,
    Keyring:           awsKmsKeyring,
})
if err != nil {
    panic(err)
}

// Decrypt your ciphertext
decryptOutput, err := forbidEncryptClient.Decrypt(context.Background(), esdktypes.DecryptInput{
    Ciphertext:        res.Ciphertext,
    EncryptionContext: encryptionContext,
    Keyring:           awsKmsKeyring,
})
if err != nil {
    panic(err)
}