Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menetapkan kebijakan komitmen Anda
[Komitmen utama](concepts.md#key-commitment) memastikan bahwa data terenkripsi Anda selalu didekripsi ke teks biasa yang sama. Untuk menyediakan properti keamanan ini, dimulai dari versi 1.7. *x*, AWS Encryption SDK menggunakan [suite algoritma](supported-algorithms.md) baru dengan komitmen utama. Untuk menentukan apakah data Anda dienkripsi dan didekripsi dengan komitmen utama, gunakan pengaturan konfigurasi kebijakan [komitmen](concepts.md#commitment-policy). [Mengenkripsi dan mendekripsi data dengan komitmen utama adalah praktik terbaik.AWS Encryption SDK](best-practices.md)
Menetapkan kebijakan komitmen adalah bagian penting dari langkah kedua dalam proses migrasi — migrasi dari yang terbaru 1. *x* versi AWS Encryption SDK ke versi 2.0. *x* dan kemudian. Setelah menetapkan dan mengubah kebijakan komitmen Anda, pastikan untuk menguji aplikasi Anda secara menyeluruh sebelum menerapkannya dalam produksi. Untuk panduan migrasi, lihat[Cara memigrasi dan menyebarkan AWS Encryption SDK](migration-guide.md).
Pengaturan kebijakan komitmen memiliki tiga nilai valid di versi 2.0. *x* dan kemudian. Yang terbaru 1. *x* versi (dimulai dengan versi 1.7. *x*), `ForbidEncryptAllowDecrypt` hanya valid.
+ `ForbidEncryptAllowDecrypt`— AWS Encryption SDK Tidak dapat mengenkripsi dengan komitmen utama. Ini dapat mendekripsi ciphertext yang dienkripsi dengan atau tanpa komitmen utama.
Yang terbaru 1. *x* versi, ini adalah satu-satunya nilai yang valid. Ini memastikan bahwa Anda tidak mengenkripsi dengan komitmen utama sampai Anda sepenuhnya siap untuk mendekripsi dengan komitmen utama. Menyetel nilai secara eksplisit mencegah kebijakan komitmen Anda berubah secara otomatis menjadi `require-encrypt-require-decrypt` saat Anda meningkatkan ke versi 2.0. *x* atau yang lebih baru. Sebagai gantinya, Anda dapat [memigrasikan kebijakan komitmen Anda](#migrate-commitment-policy) secara bertahap.
+ `RequireEncryptAllowDecrypt`— AWS Encryption SDK Selalu dienkripsi dengan komitmen utama. Ini dapat mendekripsi ciphertext yang dienkripsi dengan atau tanpa komitmen utama. Nilai ini ditambahkan dalam versi 2.0. *x*.
+ `RequireEncryptRequireDecrypt`— AWS Encryption SDK Selalu mengenkripsi dan mendekripsi dengan komitmen utama. Nilai ini ditambahkan dalam versi 2.0. *x*. Ini adalah nilai default dalam versi 2.0. *x* dan kemudian.
Yang terbaru 1. *x* versi, satu-satunya nilai kebijakan komitmen yang valid adalah`ForbidEncryptAllowDecrypt`. Setelah Anda bermigrasi ke versi 2.0. *x* atau lebih baru, Anda dapat [mengubah kebijakan komitmen Anda secara bertahap](migration-guide.md) saat Anda siap. Jangan perbarui kebijakan komitmen Anda `RequireEncryptRequireDecrypt` sampai Anda yakin bahwa Anda tidak memiliki pesan yang dienkripsi tanpa komitmen utama.
Contoh-contoh ini menunjukkan kepada Anda cara menetapkan kebijakan komitmen Anda di 1 terbaru. *x* versi dan dalam versi 2.0. *x* dan kemudian. Tekniknya tergantung pada bahasa pemrograman Anda.
**Pelajari lebih lanjut tentang migrasi**
Untuk AWS Encryption SDK for Java, AWS Encryption SDK for Python, dan CLI AWS Enkripsi, pelajari tentang perubahan yang diperlukan untuk menguasai penyedia kunci di. [Memperbarui penyedia kunci AWS KMS utama](migrate-mkps-v2.md)
Untuk AWS Encryption SDK for C dan AWS Encryption SDK for JavaScript, pelajari tentang pembaruan opsional untuk keyrings di[Memperbarui AWS KMS keyrings](migrate-keyrings-v2.md).
## Cara menetapkan kebijakan komitmen Anda
Teknik yang Anda gunakan untuk menetapkan kebijakan komitmen Anda sedikit berbeda dengan setiap implementasi bahasa. Contoh-contoh ini menunjukkan kepada Anda bagaimana melakukannya. Sebelum mengubah kebijakan komitmen Anda, tinjau pendekatan multi-tahap di[Cara bermigrasi dan menyebarkan](migration-guide.md).
------
#### [ C ]
Dimulai pada versi 1.7. *x* dari AWS Encryption SDK for C, Anda menggunakan `aws_cryptosdk_session_set_commitment_policy` fungsi untuk mengatur kebijakan komitmen pada sesi enkripsi dan dekripsi Anda. Kebijakan komitmen yang Anda tetapkan berlaku untuk semua operasi enkripsi dan dekripsi yang dipanggil pada sesi tersebut.
`aws_cryptosdk_session_new_from_cmm`Fungsi `aws_cryptosdk_session_new_from_keyring` dan tidak digunakan lagi di versi 1.7. *x* dan dihapus dalam versi 2.0. *x*. Fungsi-fungsi ini digantikan oleh `aws_cryptosdk_session_new_from_keyring_2` dan `aws_cryptosdk_session_new_from_cmm_2` fungsi yang mengembalikan sesi.
Saat Anda menggunakan `aws_cryptosdk_session_new_from_keyring_2` dan `aws_cryptosdk_session_new_from_cmm_2` yang terbaru 1. *x* versi, Anda diminta untuk memanggil `aws_cryptosdk_session_set_commitment_policy` fungsi dengan nilai kebijakan `COMMITMENT_POLICY_FORBID_ENCRYPT_ALLOW_DECRYPT` komitmen. Dalam versi 2.0. *x* dan yang lebih baru, memanggil fungsi ini adalah opsional dan dibutuhkan semua nilai yang valid. Kebijakan komitmen default untuk versi 2.0. *x* dan yang lebih `COMMITMENT_POLICY_REQUIRE_ENCRYPT_REQUIRE_DECRYPT` baru
Untuk contoh lengkap, lihat [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 ]
`require-encrypt-require-decrypt`Nilai adalah kebijakan komitmen default di semua versi AWS Encryption SDK untuk .NET. Anda dapat mengaturnya secara eksplisit sebagai praktik terbaik, tetapi itu tidak diperlukan. Namun, jika Anda menggunakan AWS Encryption SDK untuk.NET untuk mendekripsi ciphertext yang dienkripsi oleh implementasi bahasa lain dari komitmen AWS Encryption SDK tanpa kunci, Anda perlu mengubah nilai kebijakan komitmen menjadi atau. `REQUIRE_ENCRYPT_ALLOW_DECRYPT` `FORBID_ENCRYPT_ALLOW_DECRYPT` Jika tidak, upaya untuk mendekripsi ciphertext akan gagal.
Dalam AWS Encryption SDK untuk .NET, Anda menetapkan kebijakan komitmen pada instance AWS Encryption SDK. Buat instance `AwsEncryptionSdkConfig` objek dengan `CommitmentPolicy` parameter, dan gunakan objek konfigurasi untuk membuat instance. AWS Encryption SDK Kemudian, panggil `Encrypt()` dan `Decrypt()` metode dari AWS Encryption SDK instance yang dikonfigurasi.
Contoh ini menetapkan kebijakan komitmen untuk`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 ]
Untuk menetapkan kebijakan komitmen dalam CLI AWS Enkripsi, gunakan parameter. `--commitment-policy` Parameter ini diperkenalkan dalam versi 1.8. *x*.
Yang terbaru 1. versi *x*, ketika Anda menggunakan `--wrapping-keys` parameter dalam `--decrypt` perintah `--encrypt` atau, `--commitment-policy` parameter dengan `forbid-encrypt-allow-decrypt` nilai diperlukan. Jika tidak, `--commitment-policy` parameternya tidak valid.
Dalam versi 2.1. *x* dan yang lebih baru, `--commitment-policy` parameternya opsional dan default ke `require-encrypt-require-decrypt` nilai, yang tidak akan mengenkripsi atau mendekripsi ciphertext apa pun yang dienkripsi tanpa komitmen kunci. Namun, kami menyarankan agar Anda menetapkan kebijakan komitmen secara eksplisit di semua panggilan enkripsi dan dekripsi untuk membantu pemeliharaan dan pemecahan masalah.
Contoh ini menetapkan kebijakan komitmen. Ini juga menggunakan `--wrapping-keys` parameter yang menggantikan `--master-keys` parameter yang dimulai pada versi 1.8. *x*. Lihat perinciannya di [Memperbarui penyedia kunci AWS KMS utama](migrate-mkps-v2.md). Untuk contoh lengkap, lihat[Contoh CLI AWS Enkripsi](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 ]
Dimulai pada versi 1.7. *x* dari AWS Encryption SDK for Java, Anda menetapkan kebijakan komitmen pada instance Anda`AwsCrypto`, objek yang mewakili AWS Encryption SDK klien. Pengaturan kebijakan komitmen ini berlaku untuk semua operasi enkripsi dan dekripsi yang dipanggil pada klien tersebut.
`AwsCrypto()`Konstruktor tidak digunakan lagi di 1 terbaru. *x* versi AWS Encryption SDK for Java dan dihapus dalam versi 2.0. *x*. Ini digantikan oleh `Builder` kelas baru, `Builder.withCommitmentPolicy()` metode, dan tipe `CommitmentPolicy` enumerasi.
Yang terbaru 1. *x* versi, `Builder` kelas membutuhkan `Builder.withCommitmentPolicy()` metode dan `CommitmentPolicy.ForbidEncryptAllowDecrypt` argumen. Dimulai pada versi 2.0. *x*, `Builder.withCommitmentPolicy()` metode ini opsional; nilai defaultnya adalah`CommitmentPolicy.RequireEncryptRequireDecrypt`.
Untuk contoh lengkap, lihat [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 ]
Dimulai pada versi 1.7. *x* dari AWS Encryption SDK for JavaScript, Anda dapat mengatur kebijakan komitmen ketika Anda memanggil `buildClient` fungsi baru yang membuat instance AWS Encryption SDK klien. `buildClient`Fungsi ini mengambil nilai yang disebutkan yang mewakili kebijakan komitmen Anda. Ini mengembalikan `decrypt` fungsi yang diperbarui `encrypt` dan yang menegakkan kebijakan komitmen Anda saat Anda mengenkripsi dan mendekripsi.
Yang terbaru 1. *x* versi, `buildClient` fungsi membutuhkan `CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT` argumen. Dimulai pada versi 2.0. *x*, argumen kebijakan komitmen adalah opsional dan nilai defaultnya adalah`CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT`.
Kode untuk Node.js dan browser identik untuk tujuan ini, kecuali bahwa browser membutuhkan pernyataan untuk mengatur kredensialnya.
Contoh berikut mengenkripsi data dengan keyring. AWS KMS `buildClient`Fungsi baru menetapkan kebijakan komitmen ke`FORBID_ENCRYPT_ALLOW_DECRYPT`, nilai default di 1 terbaru. *x* versin. Upgrade `encrypt` dan `decrypt` fungsi yang `buildClient` dikembalikan menegakkan kebijakan komitmen yang Anda tetapkan.
```
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 ]
Dimulai pada versi 1.7. *x* dari AWS Encryption SDK for Python, Anda menetapkan kebijakan komitmen pada instance Anda`EncryptionSDKClient`, objek baru yang mewakili AWS Encryption SDK klien. Kebijakan komitmen yang Anda tetapkan berlaku untuk semua `encrypt` dan `decrypt` panggilan yang menggunakan instance klien tersebut.
Yang terbaru 1. *x* versi, `EncryptionSDKClient` konstruktor membutuhkan nilai yang `CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT` disebutkan. Dimulai pada versi 2.0. *x*, argumen kebijakan komitmen adalah opsional dan nilai defaultnya adalah`CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT`.
Contoh ini menggunakan `EncryptionSDKClient` konstruktor baru dan menetapkan kebijakan komitmen ke 1.7. *x* nilai default. Konstruktor membuat instance klien yang mewakili. AWS Encryption SDK Ketika Anda memanggil`encrypt`,`decrypt`, atau `stream` metode pada klien ini, mereka menegakkan kebijakan komitmen yang Anda tetapkan. Contoh ini juga menggunakan konstruktor baru untuk `StrictAwsKmsMasterKeyProvider` kelas, yang menentukan AWS KMS keys saat mengenkripsi dan mendekripsi.
Untuk contoh lengkap, lihat [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 ]
`require-encrypt-require-decrypt`Nilainya adalah kebijakan komitmen default di semua versi AWS Encryption SDK untuk Rust. Anda dapat mengaturnya secara eksplisit sebagai praktik terbaik, tetapi itu tidak diperlukan. Namun, jika Anda menggunakan AWS Encryption SDK for Rust untuk mendekripsi ciphertext yang dienkripsi oleh implementasi bahasa lain dari komitmen AWS Encryption SDK tanpa kunci, Anda perlu mengubah nilai kebijakan komitmen menjadi atau. `REQUIRE_ENCRYPT_ALLOW_DECRYPT` `FORBID_ENCRYPT_ALLOW_DECRYPT` Jika tidak, upaya untuk mendekripsi ciphertext akan gagal.
Dalam AWS Encryption SDK for Rust, Anda menetapkan kebijakan komitmen pada instance AWS Encryption SDK. Buat instance `AwsEncryptionSdkConfig` objek dengan `comitment_policy` parameter, dan gunakan objek konfigurasi untuk membuat instance. AWS Encryption SDK Kemudian, panggil `Encrypt()` dan `Decrypt()` metode dari AWS Encryption SDK instance yang dikonfigurasi.
Contoh ini menetapkan kebijakan komitmen untuk`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)
}
```
------