Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Impostazione della politica di impegno
[Key Commitment](concepts.md#key-commitment) garantisce che i dati crittografati vengano sempre decrittografati nello stesso testo in chiaro. Per fornire questa proprietà di sicurezza, a partire dalla versione 1.7. *x*, AWS Encryption SDK utilizza nuove [suite di algoritmi](supported-algorithms.md) con impegno chiave. Per determinare se i dati sono crittografati e decrittografati con key commitment, utilizza l'impostazione di configurazione della [policy di impegno](concepts.md#commitment-policy). [La crittografia e la decrittografia dei dati con impegno chiave è una best practice.AWS Encryption SDK](best-practices.md)
La definizione di una politica di impegno è una parte importante della seconda fase del processo di migrazione: la migrazione dalla versione più recente 1. *x* versioni delle due AWS Encryption SDK versioni 2.0. *x* e versioni successive. Dopo aver impostato e modificato la politica di impegno, assicuratevi di testare a fondo l'applicazione prima di distribuirla in produzione. Per indicazioni sulla migrazione, consulta[Come migrare e distribuire il AWS Encryption SDK](migration-guide.md).
L'impostazione della politica di impegno ha tre valori validi nelle versioni 2.0. *x* e versioni successive. Nell'ultimo 1. versioni *x* (a partire dalla versione 1.7. *x*), solo `ForbidEncryptAllowDecrypt` è valido.
+ `ForbidEncryptAllowDecrypt`— AWS Encryption SDK Non possono crittografare con un impegno chiave. Può decrittografare testi cifrati crittografati con o senza impegno di chiave.
Negli ultimi 1. *x* versioni, questo è l'unico valore valido. Garantisce che non si esegua la crittografia con l'impegno della chiave finché non si è completamente preparati a decrittografare con impegno chiave. L'impostazione del valore impedisce esplicitamente che la politica di impegno venga modificata automaticamente al `require-encrypt-require-decrypt` momento dell'aggiornamento alla versione 2.0. *x* o versioni successive. Puoi invece [migrare la tua politica di impegno](#migrate-commitment-policy) in più fasi.
+ `RequireEncryptAllowDecrypt`— Crittografa AWS Encryption SDK sempre con un impegno fondamentale. Può decrittografare testi cifrati crittografati con o senza impegno di chiave. Questo valore viene aggiunto nella versione 2.0. *x*.
+ `RequireEncryptRequireDecrypt`— Crittografa e decrittografa AWS Encryption SDK sempre con impegno fondamentale. Questo valore viene aggiunto nella versione 2.0. *x*. È il valore predefinito nelle versioni 2.0. *x* e versioni successive.
Nell'ultimo 1. *x* versioni, l'unico valore valido della politica di impegno è`ForbidEncryptAllowDecrypt`. Dopo la migrazione alla versione 2.0. *x* o versione successiva, puoi [modificare la tua politica di impegno gradualmente](migration-guide.md) man mano che sei pronto. Non aggiornate la vostra politica di impegno `RequireEncryptRequireDecrypt` finché non sarete certi di non avere messaggi crittografati senza l'impegno di una chiave.
Questi esempi mostrano come impostare la politica di impegno più recente 1. versioni *x* e nelle versioni 2.0. *x* e versioni successive. La tecnica dipende dal linguaggio di programmazione utilizzato.
**Scopri di più sulla migrazione**
Per SDK di crittografia AWS per Java e sulla AWS Encryption CLI, scopri le modifiche necessarie ai provider di chiavi master in. SDK di crittografia AWS per Python[Aggiornamento dei provider di chiavi AWS KMS principali](migrate-mkps-v2.md)
Per SDK di crittografia AWS per C e SDK di crittografia AWS per JavaScript, scopri come aggiornare facoltativamente i portachiavi in. [Aggiornamento dei AWS KMS portachiavi](migrate-keyrings-v2.md)
## Come impostare la tua politica di impegno
La tecnica utilizzata per impostare la politica di impegno varia leggermente a seconda dell'implementazione linguistica. Questi esempi mostrano come farlo. Prima di modificare la tua politica di impegno, esamina l'approccio in più fasi contenuto in[Come migrare e implementare](migration-guide.md).
------
#### [ 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 sono`COMMITMENT_POLICY_REQUIRE_ENCRYPT_REQUIRE_DECRYPT`.
Per un esempio completo, vedi [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 ]
Il `require-encrypt-require-decrypt` valore è la politica di impegno predefinita in tutte le versioni di per.NET. AWS Encryption SDK È possibile impostarla in modo esplicito come procedura consigliata, ma non è obbligatoria. Tuttavia, se si utilizza for.NET AWS Encryption SDK per decrittografare il testo cifrato che è stato crittografato con un'implementazione in un'altra lingua dell'impegno AWS Encryption SDK senza chiave, è necessario modificare il valore della policy di impegno in o. `REQUIRE_ENCRYPT_ALLOW_DECRYPT` `FORBID_ENCRYPT_ALLOW_DECRYPT` In caso contrario, i tentativi di decrittografare il testo cifrato falliranno.
In per.NET, si imposta la politica di impegno su un'istanza di. AWS Encryption SDK 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 su`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 ]
Per impostare una politica di impegno nella CLI di AWS crittografia, 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](migrate-mkps-v2.md). Per esempi completi, vedere[Esempi di CLI AWS di crittografia](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 ]
A partire dalla versione 1.7. *x* di SDK di crittografia AWS per Java, imposti la politica di impegno sulla tua istanza di`AwsCrypto`, 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.](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 ]
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 su`FORBID_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 di`EncryptionSDKClient`, 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\$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 ]
Il `require-encrypt-require-decrypt` valore è la politica di impegno predefinita in tutte le versioni di AWS Encryption SDK for Rust. Puoi impostarla esplicitamente come best practice, ma non è obbligatoria. Tuttavia, se si utilizza AWS Encryption SDK for Rust per decrittografare il testo cifrato che è stato crittografato con un'implementazione in un'altra lingua dell'impegno AWS Encryption SDK senza chiave, è necessario modificare il valore della politica di impegno in o. `REQUIRE_ENCRYPT_ALLOW_DECRYPT` `FORBID_ENCRYPT_ALLOW_DECRYPT` Altrimenti, i tentativi di decrittografare il testo cifrato falliranno.
In AWS Encryption SDK for Rust, si imposta la politica di impegno su un'istanza di. AWS Encryption SDK Crea un'istanza di un `AwsEncryptionSdkConfig` oggetto con un `comitment_policy` 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 su`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)
}
```
------