Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Définition de votre politique d'engagement
[L'engagement clé](concepts.md#key-commitment) garantit que vos données cryptées sont toujours déchiffrées dans le même texte clair. Pour fournir cette propriété de sécurité, à partir de la version 1.7. *x*, AWS Encryption SDK utilise de nouvelles [suites d'algorithmes](supported-algorithms.md) avec un engagement clé. Pour déterminer si vos données sont cryptées et déchiffrées avec un engagement clé, utilisez le paramètre de configuration de la [politique d'engagement](concepts.md#commitment-policy). [Le chiffrement et le déchiffrement des données avec un engagement clé constituent une bonne pratique.AWS Encryption SDK](best-practices.md)
La définition d'une politique d'engagement est un élément important de la deuxième étape du processus de migration, à savoir la migration depuis la dernière 1. *x* versions des AWS Encryption SDK deux versions 2.0. *x* et versions ultérieures. Après avoir défini et modifié votre politique d'engagement, assurez-vous de tester votre application de manière approfondie avant de la déployer en production. Pour obtenir des conseils sur la migration, voir[Comment migrer et déployer le AWS Encryption SDK](migration-guide.md).
Le paramètre de politique d'engagement comporte trois valeurs valides dans les versions 2.0. *x* et versions ultérieures. Dans le dernier 1. *x* versions (en commençant par la version 1.7. *x*), seul `ForbidEncryptAllowDecrypt` est valide.
+ `ForbidEncryptAllowDecrypt`— Ils AWS Encryption SDK ne peuvent pas chiffrer avec un engagement clé. Il peut déchiffrer les textes chiffrés avec ou sans clé d'engagement.
Dans le dernier 1. *x* versions, c'est la seule valeur valide. Cela garantit que vous ne chiffrez pas avec un engagement clé tant que vous n'êtes pas entièrement prêt à déchiffrer avec un engagement clé. La définition explicite de cette valeur empêche que votre politique d'engagement soit automatiquement modifiée `require-encrypt-require-decrypt` lorsque vous passez aux versions 2.0. *x* ou version ultérieure. Au lieu de cela, vous pouvez [migrer votre politique d'engagement](#migrate-commitment-policy) par étapes.
+ `RequireEncryptAllowDecrypt`— Il chiffre AWS Encryption SDK toujours avec un engagement clé. Il peut déchiffrer les textes chiffrés avec ou sans clé d'engagement. Cette valeur est ajoutée dans la version 2.0. *x.*
+ `RequireEncryptRequireDecrypt`— Il chiffre et déchiffre AWS Encryption SDK toujours avec un engagement clé. Cette valeur est ajoutée dans la version 2.0. *x.* Il s'agit de la valeur par défaut dans les versions 2.0. *x* et versions ultérieures.
Dans le dernier 1. *x* versions, la seule valeur de la politique d'engagement valide est`ForbidEncryptAllowDecrypt`. Après avoir migré vers la version 2.0. *x* ou ultérieurement, vous pouvez [modifier votre politique d'engagement par étapes au](migration-guide.md) fur et à mesure que vous êtes prêt. Ne mettez pas à jour votre politique d'engagement `RequireEncryptRequireDecrypt` tant que vous n'êtes pas certain qu'aucun message n'est crypté sans clé d'engagement.
Ces exemples vous montrent comment définir votre politique d'engagement dans la dernière version 1. dans les versions *x* et dans les versions 2.0. *x* et versions ultérieures. La technique dépend de votre langage de programmation.
**En savoir plus sur la migration**
Pour Kit SDK de chiffrement AWS pour Java, Kit SDK de chiffrement AWS pour Python, et la CLI de AWS chiffrement, découvrez les modifications requises pour les fournisseurs de clés principales dans[Mise à jour des fournisseurs de clés AWS KMS principales](migrate-mkps-v2.md).
Pour Kit SDK de chiffrement AWS pour C et Kit SDK de chiffrement AWS pour JavaScript, découvrez une mise à jour facultative des porte-clés dans[Mise à jour des AWS KMS porte-clés](migrate-keyrings-v2.md).
## Comment définir votre politique d'engagement
La technique que vous utilisez pour définir votre politique d'engagement diffère légèrement selon la mise en œuvre de chaque langue. Ces exemples vous montrent comment procéder. Avant de modifier votre politique d'engagement, passez en revue l'approche en plusieurs étapes dans[Comment migrer et déployer](migration-guide.md).
------
#### [ 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 sont`COMMITMENT_POLICY_REQUIRE_ENCRYPT_REQUIRE_DECRYPT`.
Pour obtenir un exemple complet, veuillez consulter [string.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/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\$1 / .NET ]
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 sur`require-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()
{
{"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 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 en savoir plus, consultez [Mise à jour des fournisseurs de clés AWS KMS principales](migrate-mkps-v2.md). Pour des exemples complets, voir[Exemples de CLI AWS de chiffrement](crypto-cli-examples.md).
```
\\ 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 de`AwsCrypto`, 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.ForbidEncryptAllowDecrypt`argument. À partir de la version 2.0. *x*, la `Builder.withCommitmentPolicy()` méthode est facultative ; la valeur par défaut est`CommitmentPolicy.RequireEncryptRequireDecrypt`.
Pour un exemple complet, consultez [SetCommitmentPolicyExample.java.](https://github.com/aws/aws-encryption-sdk-java/blob/master/src/examples/java/com/amazonaws/crypto/examples/v2/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 encryptResult = crypto.encryptData(
masterKeyProvider,
sourcePlaintext,
encryptionContext);
byte[] ciphertext = encryptResult.getResult();
// Decrypt your ciphertext
CryptoResult 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 est`CommitmentPolicy.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 de`EncryptionSDKClient`, 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 est`CommitmentPolicy.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\$1commitment.py](https://github.com/aws/aws-encryption-sdk-python/blob/master/examples/src/legacy/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
)
```
------
#### [ Rust ]
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 sur`forbid-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?;
```
------
#### [ Go ]
```
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)
}
```
------