Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Festlegung Ihrer Verpflichtungspolitik
[Key Commitment](concepts.md#key-commitment) stellt sicher, dass Ihre verschlüsselten Daten immer im gleichen Klartext entschlüsselt werden. Um diese Sicherheitseigenschaft ab Version 1.7 bereitzustellen. *x* AWS Encryption SDK verwendet neue [Algorithmus-Suiten](supported-algorithms.md) mit hohem Engagement. Um festzustellen, ob Ihre Daten mit Key Commitment ver- und entschlüsselt werden, verwenden Sie die Konfigurationseinstellung der [Commitment-Richtlinie](concepts.md#commitment-policy). [Das Verschlüsseln und Entschlüsseln von Daten mit Key Commitment ist eine AWS Encryption SDK bewährte Methode.](best-practices.md)
Die Festlegung einer verbindlichen Richtlinie ist ein wichtiger Bestandteil des zweiten Schritts im Migrationsprozess — der Migration von der letzten Version 1. *x* Versionen der beiden AWS Encryption SDK Versionen 2.0. *x* und später. Nachdem Sie Ihre Verpflichtungsrichtlinie festgelegt und geändert haben, sollten Sie Ihre Anwendung gründlich testen, bevor Sie sie in der Produktion einsetzen. Hinweise zur Migration finden Sie unter[Wie migriert und implementiert man AWS Encryption SDK](migration-guide.md).
Die Richtlinieneinstellung „Commitment“ hat in den Versionen 2.0 drei gültige Werte. *x* und später. In der letzten 1. *x-Versionen* (beginnend mit Version 1.7. *x*), `ForbidEncryptAllowDecrypt` ist nur gültig.
+ `ForbidEncryptAllowDecrypt`— Sie AWS Encryption SDK können nicht mit Schlüsselzusage verschlüsseln. Es kann Chiffretexte entschlüsseln, die mit oder ohne Schlüsselbindung verschlüsselt wurden.
In der letzten Version 1. *x-Versionen*, dies ist der einzig gültige Wert. Es stellt sicher, dass Sie erst dann mit Key Commitment verschlüsseln, wenn Sie vollständig bereit sind, mit Key Commitment zu entschlüsseln. Wenn Sie den Wert explizit festlegen, wird verhindert, dass sich Ihre Verpflichtungsrichtlinie automatisch ändert, `require-encrypt-require-decrypt` wenn Sie auf Version 2.0 aktualisieren. *x* oder später. Stattdessen können Sie [Ihre Verpflichtungspolitik schrittweise migrieren](#migrate-commitment-policy).
+ `RequireEncryptAllowDecrypt`— Das verschlüsselt AWS Encryption SDK immer mit Schlüsselzusage. Es kann Chiffretexte entschlüsseln, die mit oder ohne Schlüsselbindung verschlüsselt wurden. Dieser Wert wurde in Version 2.0 hinzugefügt. *x.*
+ `RequireEncryptRequireDecrypt`— Der verschlüsselt und entschlüsselt AWS Encryption SDK immer mit Schlüsselbindung. Dieser Wert wurde in Version 2.0 hinzugefügt. *x.* Dies ist der Standardwert in den Versionen 2.0. *x* und später.
In der letzten 1. *x-Versionen*, der einzig gültige Wert der Verpflichtungspolice ist`ForbidEncryptAllowDecrypt`. Nach der Migration auf Version 2.0. *x* oder später können Sie [Ihre Verpflichtungsrichtlinie schrittweise ändern](migration-guide.md), sobald Sie bereit sind. Aktualisieren Sie Ihre Verpflichtungsrichtlinie `RequireEncryptRequireDecrypt` erst, wenn Sie sicher sind, dass Sie keine Nachrichten ohne Schlüsselbindung verschlüsselt haben.
Diese Beispiele zeigen Ihnen, wie Sie Ihre Verpflichtungsrichtlinie in der neuesten Version festlegen. *x-Versionen* und in den Versionen 2.0. *x* und später. Die Technik hängt von Ihrer Programmiersprache ab.
**Erfahren Sie mehr über Migration**
Informationen zu AWS-Verschlüsselungs-SDK for Java den erforderlichen Änderungen an den AWS Hauptschlüsselanbietern finden Sie unter, und die Encryption CLI[Aktualisierung der AWS KMS Hauptschlüsselanbieter](migrate-mkps-v2.md). AWS-Verschlüsselungs-SDK for Python
Informationen zu einem optionalen Update für AWS-Verschlüsselungs-SDK for C Schlüsselanhänger finden Sie unter[AWS KMS Schlüsselanhänger aktualisieren](migrate-keyrings-v2.md). AWS-Verschlüsselungs-SDK for JavaScript
## Wie legen Sie Ihre Verpflichtungsrichtlinie fest
Die Methode, mit der Sie Ihre Verpflichtungspolitik festlegen, unterscheidet sich je nach Sprachimplementierung geringfügig. Diese Beispiele zeigen Ihnen, wie das geht. Bevor Sie Ihre Verpflichtungspolitik ändern, überprüfen Sie den mehrstufigen Ansatz unter[Wie migriert und implementiert man](migration-guide.md).
------
#### [ C ]
Ab Version 1.7. *x* von AWS-Verschlüsselungs-SDK for C, Sie verwenden die `aws_cryptosdk_session_set_commitment_policy` Funktion, um die Verpflichtungsrichtlinie für Ihre Verschlüsselungs- und Entschlüsselungssitzungen festzulegen. Die von Ihnen festgelegte Commitment-Richtlinie gilt für alle Verschlüsselungs- und Entschlüsselungsvorgänge, die in dieser Sitzung aufgerufen werden.
Die `aws_cryptosdk_session_new_from_cmm` Funktionen `aws_cryptosdk_session_new_from_keyring` und sind in Version 1.7 veraltet. *x* und in Version 2.0 entfernt. *x.* Diese Funktionen werden durch `aws_cryptosdk_session_new_from_cmm_2` Funktionen `aws_cryptosdk_session_new_from_keyring_2` und ersetzt, die eine Sitzung zurückgeben.
Wenn Sie das `aws_cryptosdk_session_new_from_keyring_2` und `aws_cryptosdk_session_new_from_cmm_2` in der letzten Version verwenden 1. *x-Versionen*, Sie müssen die `aws_cryptosdk_session_set_commitment_policy` Funktion mit dem `COMMITMENT_POLICY_FORBID_ENCRYPT_ALLOW_DECRYPT` Commitment-Policy-Wert aufrufen. In den Versionen 2.0. *x* und höher ist der Aufruf dieser Funktion optional und akzeptiert alle gültigen Werte. Die Standard-Commitment-Richtlinie für Versionen 2.0. *x* und höher ist`COMMITMENT_POLICY_REQUIRE_ENCRYPT_REQUIRE_DECRYPT`.
Ein vollständiges Beispiel finden Sie unter [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 ]
Der `require-encrypt-require-decrypt` Wert ist die Standard-Commitment-Richtlinie in allen Versionen von AWS Encryption SDK für.NET. Sie können es als bewährte Methode explizit festlegen, dies ist jedoch nicht erforderlich. Wenn Sie jedoch AWS Encryption SDK for .NET verwenden, um Chiffretext zu entschlüsseln, der mit einer anderen Sprachimplementierung von AWS Encryption SDK Without Key Commitment verschlüsselt wurde, müssen Sie den Wert der Commitment-Richtlinie auf oder ändern. `REQUIRE_ENCRYPT_ALLOW_DECRYPT` `FORBID_ENCRYPT_ALLOW_DECRYPT` Andernfalls schlagen Versuche, den Chiffretext zu entschlüsseln, fehl.
Im AWS Encryption SDK für.NET legen Sie die Commitment-Richtlinie für eine Instanz von fest. AWS Encryption SDK Instanziieren Sie ein `AwsEncryptionSdkConfig` Objekt mit einem `CommitmentPolicy` Parameter und verwenden Sie das Konfigurationsobjekt, um die Instanz zu erstellen. AWS Encryption SDK Rufen Sie dann die `Decrypt()` Methoden `Encrypt()` und der konfigurierten AWS Encryption SDK Instanz auf.
In diesem Beispiel wird die Commitment-Richtlinie auf festgelegt`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 ]
Verwenden Sie den `--commitment-policy` Parameter, um eine Commitment-Richtlinie in der AWS Encryption CLI festzulegen. Dieser Parameter wurde in Version 1.8 eingeführt. *x.*
In der letzten 1. *X-Version*, wenn Sie den `--wrapping-keys` Parameter in einem `--encrypt` `--decrypt` OR-Befehl verwenden, ist ein `--commitment-policy` Parameter mit dem `forbid-encrypt-allow-decrypt` Wert erforderlich. Andernfalls ist der `--commitment-policy` Parameter ungültig.
In den Versionen 2.1. *x* und höher ist der `--commitment-policy` Parameter optional und hat standardmäßig den `require-encrypt-require-decrypt` Wert, der keinen Chiffretext ver- oder entschlüsselt, der ohne Schlüsselzuweisung verschlüsselt wurde. Wir empfehlen jedoch, dass Sie die Commitment-Richtlinie explizit für alle Verschlüsselungs- und Entschlüsselungsanfragen festlegen, um die Wartung und Fehlerbehebung zu erleichtern.
In diesem Beispiel wird die Commitment-Richtlinie festgelegt. Außerdem wird der `--wrapping-keys` Parameter verwendet, der den `--master-keys` Parameter ab Version 1.8 ersetzt. *x.* Details hierzu finden Sie unter [Aktualisierung der AWS KMS Hauptschlüsselanbieter](migrate-mkps-v2.md). Vollständige Beispiele finden Sie unter[Beispiele für die AWS Encryption 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 ]
Ab Version 1.7. *x* von AWS-Verschlüsselungs-SDK for Java, Sie legen die Commitment-Richtlinie für Ihre Instanz von fest`AwsCrypto`, dem Objekt, das den AWS Encryption SDK Client darstellt. Diese Commitment-Richtlinieneinstellung gilt für alle Verschlüsselungs- und Entschlüsselungsvorgänge, die auf diesem Client aufgerufen werden.
Der `AwsCrypto()` Konstruktor ist in der neuesten Version 1 veraltet. *x-Versionen* von AWS-Verschlüsselungs-SDK for Java und wurden in Version 2.0 entfernt. *x.* Es wird durch eine neue `Builder` Klasse, eine `Builder.withCommitmentPolicy()` Methode und den `CommitmentPolicy` Aufzählungstyp ersetzt.
In der letzten 1. *x-Versionen*, die `Builder` Klasse benötigt die `Builder.withCommitmentPolicy()` Methode und das `CommitmentPolicy.ForbidEncryptAllowDecrypt` Argument. Ab Version 2.0. *x*, die `Builder.withCommitmentPolicy()` Methode ist optional; der Standardwert ist`CommitmentPolicy.RequireEncryptRequireDecrypt`.
Ein vollständiges Beispiel finden Sie unter [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 ]
Ab Version 1.7. *x* von AWS-Verschlüsselungs-SDK for JavaScript, Sie können die Commitment-Richtlinie festlegen, wenn Sie die neue `buildClient` Funktion aufrufen, die einen AWS Encryption SDK Client instanziiert. Die `buildClient` Funktion verwendet einen Aufzählungswert, der Ihre Commitment-Richtlinie darstellt. Sie gibt aktualisierte `decrypt` Funktionen `encrypt` und Funktionen zurück, die Ihre Verpflichtungsrichtlinie beim Verschlüsseln und Entschlüsseln durchsetzen.
In der letzten Version 1. *x-Versionen*, die `buildClient` Funktion benötigt das `CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT` Argument. Ab Version 2.0. *x*, das Argument der Commitment-Richtlinie ist optional und der Standardwert ist`CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT`.
Der Code für Node.js und der Browser sind für diesen Zweck identisch, außer dass der Browser eine Anweisung benötigt, um Anmeldeinformationen festzulegen.
Im folgenden Beispiel werden Daten mit einem AWS KMS Schlüsselbund verschlüsselt. Die neue `buildClient` Funktion setzt die Commitment-Richtlinie auf`FORBID_ENCRYPT_ALLOW_DECRYPT`, den Standardwert in der letzten Version 1. *x* Versionen. Das Upgrade `encrypt` und die `decrypt` Funktionen, die `buildClient` zurückgegeben werden, setzen die von Ihnen festgelegte Verpflichtungsrichtlinie durch.
```
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 ]
Ab Version 1.7. *x* von AWS-Verschlüsselungs-SDK for Python, Sie legen die Commitment-Richtlinie für Ihre Instanz von fest`EncryptionSDKClient`, einem neuen Objekt, das den AWS Encryption SDK Client darstellt. Die von Ihnen festgelegte Commitment-Richtlinie gilt für alle `decrypt` Aufrufe `encrypt` und Aufrufe, die diese Instanz des Clients verwenden.
In der letzten Version 1. *X-Versionen*, der `EncryptionSDKClient` Konstruktor benötigt den `CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT` Aufzählungswert. Ab Version 2.0. *x*, das Argument der Commitment-Richtlinie ist optional und der Standardwert ist`CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT`.
In diesem Beispiel wird der neue `EncryptionSDKClient` Konstruktor verwendet und die Commitment-Richtlinie auf 1.7 gesetzt. *x* Standardwert. Der Konstruktor instanziiert einen Client, der den darstellt. AWS Encryption SDK Wenn Sie die `stream` Methoden `encrypt``decrypt`, oder auf diesem Client aufrufen, setzen sie die von Ihnen festgelegte Commitment-Richtlinie durch. In diesem Beispiel wird auch der neue Konstruktor für die `StrictAwsKmsMasterKeyProvider` Klasse verwendet, der festlegt, AWS KMS keys wann verschlüsselt und entschlüsselt werden soll.
[Ein vollständiges Beispiel finden Sie unter 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 ]
Der `require-encrypt-require-decrypt` Wert ist die Standard-Commitment-Richtlinie in allen Versionen von AWS Encryption SDK for Rust. Sie können es als bewährte Methode explizit festlegen, aber es ist nicht erforderlich. Wenn Sie jedoch AWS Encryption SDK for Rust verwenden, um Chiffretext zu entschlüsseln, der mit einer Implementierung von AWS Encryption SDK Without Key Commitment in einer anderen Sprache verschlüsselt wurde, müssen Sie den Richtlinienwert Commitment auf oder ändern. `REQUIRE_ENCRYPT_ALLOW_DECRYPT` `FORBID_ENCRYPT_ALLOW_DECRYPT` Andernfalls schlagen Versuche, den Chiffretext zu entschlüsseln, fehl.
In der AWS Encryption SDK für Rust legen Sie die Commitment-Richtlinie für eine Instanz von fest. AWS Encryption SDK Instanziieren Sie ein `AwsEncryptionSdkConfig` Objekt mit einem `comitment_policy` Parameter und verwenden Sie das Konfigurationsobjekt, um die Instanz zu erstellen. AWS Encryption SDK Rufen Sie dann die `Decrypt()` Methoden `Encrypt()` und der konfigurierten AWS Encryption SDK Instanz auf.
In diesem Beispiel wird die Commitment-Richtlinie auf festgelegt`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)
}
```
------