기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.
# 커밋 정책 설정
[키 커밋](concepts.md#key-commitment)을 사용하면 암호화된 데이터가 항상 동일한 일반 텍스트로 복호화됩니다. 버전 1.7.*x*부터이 보안 속성을 제공하기 위해는 키 커밋과 함께 새 [알고리즘 제품군](supported-algorithms.md)을 AWS Encryption SDK 사용합니다. 데이터를 암호화하고 복호화할 때 키 커밋 사용 여부를 결정하려면 [커밋 정책](concepts.md#commitment-policy) 구성 설정을 사용합니다. 키 커밋으로 데이터를 암호화하고 복호화하는 것이 [AWS Encryption SDK 모범 사례](best-practices.md)입니다.
커밋 정책 설정은 최신 1.*x* 버전에서 버전 AWS Encryption SDK 2.0.x** 이상으로 마이그레이션하는 마이그레이션 프로세스의 두 번째 단계에서 중요한 부분입니다. 커밋 정책을 설정하고 변경한 후에는 애플리케이션을 프로덕션 환경에 배포하기 전에 철저하게 테스트해야 합니다. 마이그레이션 지침은 [마이그레이션 및 배포 방법 AWS Encryption SDK](migration-guide.md) 섹션을 참조하세요.
2.0.*x* 이상 버전에서 커밋 정책 설정에는 다음과 같은 세 가지 유효한 값이 있습니다. 최신 1.*x* 버전(1.7*x* 버전부터)에서는 `ForbidEncryptAllowDecrypt`만 유효합니다.
+ `ForbidEncryptAllowDecrypt` -는 키 커밋으로 암호화할 AWS Encryption SDK 수 없습니다. 암호화된 사이퍼텍스트를 키 커밋 사용 여부와 관계없이 복호화할 수 있습니다.
최신 1.*x* 버전에서 이는 유일하게 유효한 값입니다. 이를 통해 키 커밋으로 복호화할 준비가 완전히 완료되기 전까지는 키 커밋으로 암호화하지 않도록 합니다. 이 값을 명시적으로 설정하면 2.0.*x* 이상 버전으로 업그레이드할 때 커밋 정책이 자동으로 `require-encrypt-require-decrypt`로 변경되는 것을 방지할 수 있습니다. 대신, 단계적으로 [커밋 정책을 마이그레이션](#migrate-commitment-policy)할 수 있습니다.
+ `RequireEncryptAllowDecrypt` -는 AWS Encryption SDK 항상 키 커밋으로 암호화합니다. 암호화된 사이퍼텍스트를 키 커밋 사용 여부와 관계없이 복호화할 수 있습니다. 이 값은 버전 2.0.*x*에 추가되었습니다.
+ `RequireEncryptRequireDecrypt` -는 AWS Encryption SDK 항상 키 커밋으로 암호화 및 복호화합니다. 이 값은 버전 2.0.*x*에 추가되었습니다. 이는 버전 2.0.*x* 이상에서 기본값입니다.
최신 1.*x* 버전에서 유일하게 유효한 커밋 정책 값은 `ForbidEncryptAllowDecrypt`입니다. 2.0.*x* 이상 버전으로 마이그레이션한 후 준비가 되는 대로 [커밋 정책을 단계적으로 변경](migration-guide.md)할 수 있습니다. 키 커밋 없이 암호화된 메시지가 없는 것이 확인되기 전에는 커밋 정책을 `RequireEncryptRequireDecrypt`로 업데이트하지 마세요.
다음 예제는 최신 1.*x* 버전 및 2.0.*x* 이상 버전에서 커밋 정책을 설정하는 방법을 보여줍니다. 기술은 프로그래밍 언어에 따라 달라집니다.
**마이그레이션에 대해 자세히 알아보기**
AWS Encryption SDK for Java AWS Encryption SDK for Python및 AWS 암호화 CLI의 경우에서 마스터 키 공급자에 필요한 변경 사항에 대해 알아봅니다[AWS KMS 마스터 키 공급자 업데이트](migrate-mkps-v2.md).
AWS Encryption SDK for C 및의 경우의 키링에 대한 선택적 업데이트에 대해 AWS Encryption SDK for JavaScript알아봅니다[AWS KMS 키링 업데이트](migrate-keyrings-v2.md).
## 커밋 정책 설정 방법
커밋 정책을 설정하는 데 사용하는 방법은 각 언어 구현마다 조금씩 다릅니다. 이 예제에서는 해당 작업 방법을 보여줍니다. 커밋 정책을 변경하기 전에 [마이그레이션 및 배포 방법](migration-guide.md)에서 다단계 접근 방식을 검토하세요.
------
#### [ C ]
버전 1.7.*x*부터 `aws_cryptosdk_session_set_commitment_policy` 함수를 AWS Encryption SDK for C사용하여 암호화 및 복호화 세션에 커밋 정책을 설정합니다. 설정한 커밋 정책은 해당 세션에서 호출된 모든 암호화 및 복호화 작업에 적용됩니다.
`aws_cryptosdk_session_new_from_keyring` 및 `aws_cryptosdk_session_new_from_cmm` 함수는 버전 1.7.*x*에서 더 이상 사용되지 않으며 버전 2.0.*x*에서 제거되었습니다. 이러한 함수는 세션을 반환하는 `aws_cryptosdk_session_new_from_keyring_2` 및 `aws_cryptosdk_session_new_from_cmm_2` 함수로 대체됩니다.
최신 1.*x* 버전에서 `aws_cryptosdk_session_new_from_keyring_2` 및 `aws_cryptosdk_session_new_from_cmm_2`를 사용한 경우 `COMMITMENT_POLICY_FORBID_ENCRYPT_ALLOW_DECRYPT` 커밋 정책 값을 사용하여 `aws_cryptosdk_session_set_commitment_policy` 함수를 호출해야 합니다. 2.0.*x* 이상 버전의 경우 이 함수를 호출하는 것은 선택 사항이며 유효한 값을 모두 사용합니다. 2.0.*x* 이상 버전의 기본 커밋 정책은 `COMMITMENT_POLICY_REQUIRE_ENCRYPT_REQUIRE_DECRYPT`입니다.
전체 예를 보려면 [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` 값은 AWS Encryption SDK for .NET의 모든 버전에서 기본 커밋 정책입니다. 모범 사례로 명시적으로 설정할 수 있지만 필수 사항은 아닙니다. 그러나 AWS Encryption SDK for .NET을 사용하여 키 커밋 AWS Encryption SDK 없이의 다른 언어 구현으로 암호화된 사이퍼텍스트를 해독하는 경우 커밋 정책 값을 `REQUIRE_ENCRYPT_ALLOW_DECRYPT` 또는 로 변경해야 합니다`FORBID_ENCRYPT_ALLOW_DECRYPT`. 그러지 않으면 사이퍼텍스트 복호화 시도가 실패합니다.
AWS Encryption SDK for .NET에서의 인스턴스에 커밋 정책을 설정합니다 AWS Encryption SDK. `CommitmentPolicy` 파라미터를 사용하여 `AwsEncryptionSdkConfig` 객체를 인스턴스화하고 구성 객체를 사용하여 AWS Encryption SDK 인스턴스를 생성합니다. 그런 다음 구성된 AWS Encryption SDK 인스턴스의 `Encrypt()` 및 `Decrypt()` 메서드를 호출합니다.
이 예에서는 커밋 정책을 `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 ]
AWS 암호화 CLI에서 커밋 정책을 설정하려면 `--commitment-policy` 파라미터를 사용합니다. 이 파라미터는 버전 1.8.*x*에 도입되었습니다.
최신 1.*x* 버전의 경우 `--encrypt` 또는 `--decrypt` 명령에서 `--wrapping-keys` 파라미터를 사용할 때는 `forbid-encrypt-allow-decrypt` 값이 있는 `--commitment-policy` 파라미터가 필요합니다. 그러지 않으면 `--commitment-policy` 파라미터가 유효하지 않게 됩니다.
2.1.*x* 및 이상 버전에서는 `--commitment-policy` 파라미터가 선택 사항이며 키 커밋 없이 암호화된 사이퍼텍스트를 암호화하거나 복호화하지 않는 `require-encrypt-require-decrypt` 값이 기본값입니다. 하지만 유지 관리 및 문제 해결에 도움이 되도록 모든 암호화 및 복호화 호출에서 커밋 정책을 명시적으로 설정하는 것이 좋습니다.
이 예에서는 커밋 정책을 설정합니다. 또한 1.8.*x* 버전부터 `--master-keys` 파라미터를 대체하는 `--wrapping-keys` 파라미터를 사용합니다. 자세한 내용은 [AWS KMS 마스터 키 공급자 업데이트](migrate-mkps-v2.md)을 참조하세요. 전체 예제는 [AWS 암호화 CLI의 예](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 ]
버전 1.7.*x*부터 AWS Encryption SDK 클라이언트를 나타내는 객체`AwsCrypto`인의 인스턴스에 커밋 정책을 AWS Encryption SDK for Java설정합니다. 이 커밋 정책 설정은 해당 클라이언트에서 호출된 모든 암호화 및 복호화 작업에 적용됩니다.
`AwsCrypto()` 생성자는의 최신 1.*x* 버전에서는 더 이상 사용되지 AWS Encryption SDK for Java 않으며 버전 2.0.*x*에서는 제거됩니다. 새 `Builder` 클래스, `Builder.withCommitmentPolicy()` 메서드, `CommitmentPolicy` 열거 유형으로 대체됩니다.
최신 1.*x* 버전의 `Builder` 클래스에는 `Builder.withCommitmentPolicy()` 메서드와 `CommitmentPolicy.ForbidEncryptAllowDecrypt` 인수가 필요합니다. 2.0.*x* 버전부터 `Builder.withCommitmentPolicy()` 메서드는 선택 사항이고 기본값은 `CommitmentPolicy.RequireEncryptRequireDecrypt`입니다.
전체 예제는 [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 ]
버전 1.7.*x*부터 AWS Encryption SDK 클라이언트를 인스턴스화하는 새 `buildClient` 함수를 호출할 때 커밋 정책을 설정할 AWS Encryption SDK for JavaScript수 있습니다. `buildClient` 함수는 커밋 정책을 나타내는 열거형 값을 사용합니다. 암호화 및 복호화 시 커밋 정책을 적용하는 업데이트된 `encrypt` 및 `decrypt` 함수를 반환합니다.
최신 1.*x* 버전에서는 `buildClient` 함수에 `CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT` 인수가 필요합니다. 2.0.*x* 버전부터 커밋 정책 인수는 선택 사항이고 기본값은 `CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT`입니다.
브라우저에 자격 증명을 설정하려면 명령문이 필요하다는 점을 제외하면 Node.js 코드와 브라우저의 코드는 동일합니다.
다음 예제에서는 AWS KMS 키링을 사용하여 데이터를 암호화합니다. 새 `buildClient` 함수는 커밋 정책을 `FORBID_ENCRYPT_ALLOW_DECRYPT`로 설정하며 이는 최신 1.*x* 버전의 기본값입니다. `buildClient`에서 반환되는 업그레이드된 `encrypt` 및 `decrypt` 함수는 사용자가 설정한 커밋 정책을 적용합니다.
```
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 ]
버전 1.7.*x*부터 AWS Encryption SDK 클라이언트를 나타내는 새 객체`EncryptionSDKClient`인의 인스턴스에 커밋 정책을 AWS Encryption SDK for Python설정합니다. 설정한 커밋 정책은 해당 클라이언트 인스턴스를 사용하는 모든 `encrypt` 및 `decrypt` 호출에 적용됩니다.
최신 1.*x* 버전의 `EncryptionSDKClient` 생성자에는 `CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT` 열거형 값이 필요합니다. 2.0.*x* 버전부터 커밋 정책 인수는 선택 사항이고 기본값은 `CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT`입니다.
이 예제에서는 새 `EncryptionSDKClient` 생성자를 사용하고 커밋 정책을 1.7.*x* 기본값으로 설정합니다. 생성자는 AWS Encryption SDK를 나타내는 클라이언트를 인스턴스화합니다. 이 클라이언트에서 `encrypt`, `decrypt` 또는 `stream` 메서드를 호출하면 설정한 커밋 정책이 적용됩니다. 또한이 예제에서는 암호화 및 복호화 AWS KMS keys 시기를 지정하는 `StrictAwsKmsMasterKeyProvider` 클래스의 새 생성자를 사용합니다.
전체 예제는 [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` 값은 AWS Encryption SDK for Rust의 모든 버전에서 기본 커밋 정책입니다. 모범 사례로 명시적으로 설정할 수 있지만 필수 사항은 아닙니다. 그러나 AWS Encryption SDK for Rust를 사용하여 키 커밋 AWS Encryption SDK 없이의 다른 언어 구현으로 암호화된 사이퍼텍스트를 해독하는 경우 커밋 정책 값을 `REQUIRE_ENCRYPT_ALLOW_DECRYPT` 또는 로 변경해야 합니다`FORBID_ENCRYPT_ALLOW_DECRYPT`. 그러지 않으면 사이퍼텍스트 복호화 시도가 실패합니다.
AWS Encryption SDK for Rust에서의 인스턴스에 커밋 정책을 설정합니다 AWS Encryption SDK. `comitment_policy` 파라미터를 사용하여 `AwsEncryptionSdkConfig` 객체를 인스턴스화하고 구성 객체를 사용하여 AWS Encryption SDK 인스턴스를 생성합니다. 그런 다음 구성된 AWS Encryption SDK 인스턴스의 `Encrypt()` 및 `Decrypt()` 메서드를 호출합니다.
이 예에서는 커밋 정책을 `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)
}
```
------