Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Mengkonfigurasi AWS Encryption SDK
AWS Encryption SDK Ini dirancang agar mudah digunakan. Meskipun AWS Encryption SDK memiliki beberapa opsi konfigurasi, nilai default dipilih dengan cermat agar praktis dan aman untuk sebagian besar aplikasi. Namun, Anda mungkin perlu menyesuaikan konfigurasi untuk meningkatkan kinerja atau menyertakan fitur khusus dalam desain Anda.
Saat mengonfigurasi implementasi Anda, tinjau [praktik AWS Encryption SDK terbaik](best-practices.md) dan terapkan sebanyak yang Anda bisa.
**Topics**
+ [Memilih bahasa pemrograman](#config-language)
+ [Memilih tombol pembungkus](#config-keys)
+ [Menggunakan Multi-region AWS KMS keys](#config-mrks)
+ [Memilih rangkaian algoritme](#config-algorithm)
+ [Membatasi kunci data terenkripsi](#config-limit-keys)
+ [Membuat filter penemuan](#config-discovery)
+ [Mengkonfigurasi konteks enkripsi yang diperlukan CMM](#config-required-encryption-context-cmm)
+ [Menetapkan kebijakan komitmen](#config-commitment-policy)
+ [Bekerja dengan data streaming](#config-stream)
+ [Menyembunyikan kunci data](#config-caching)
## Memilih bahasa pemrograman
AWS Encryption SDK Ini tersedia dalam berbagai [bahasa pemrograman](programming-languages.md). Implementasi bahasa dirancang untuk sepenuhnya dapat dioperasikan dan menawarkan fitur yang sama, meskipun mereka mungkin diimplementasikan dengan cara yang berbeda. Biasanya, Anda menggunakan perpustakaan yang kompatibel dengan aplikasi Anda. Namun, Anda dapat memilih bahasa pemrograman untuk implementasi tertentu. Misalnya, jika Anda lebih suka bekerja dengan [gantungan kunci](choose-keyring.md), Anda dapat memilih AWS Encryption SDK for C atau. AWS Encryption SDK for JavaScript
## Memilih tombol pembungkus
Ini AWS Encryption SDK menghasilkan kunci data simetris yang unik untuk mengenkripsi setiap pesan. Kecuali Anda menggunakan [caching kunci data](data-key-caching.md), Anda tidak perlu mengkonfigurasi, mengelola, atau menggunakan kunci data. Yang AWS Encryption SDK melakukannya untuk Anda.
Namun, Anda harus memilih satu atau lebih kunci pembungkus untuk mengenkripsi setiap kunci data. AWS Encryption SDK Mendukung tombol simetris AES dan tombol asimetris RSA dalam berbagai ukuran. Ini juga mendukung enkripsi AWS KMS keys simetris [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS). Anda bertanggung jawab atas keamanan dan daya tahan kunci pembungkus Anda, jadi kami sarankan Anda menggunakan kunci enkripsi dalam modul keamanan perangkat keras atau layanan infrastruktur utama, seperti AWS KMS.
Untuk menentukan kunci pembungkus Anda untuk enkripsi dan dekripsi, Anda menggunakan keyring (C, Java,, .NET JavaScript, dan Python) atau penyedia kunci master (Java, Python, Encryption CLI). AWS Anda dapat menentukan satu kunci pembungkus atau beberapa kunci pembungkus dari jenis yang sama atau berbeda. Jika Anda menggunakan beberapa kunci pembungkus untuk membungkus kunci data, setiap kunci pembungkus akan mengenkripsi salinan kunci data yang sama. Kunci data terenkripsi (satu per kunci pembungkus) disimpan dengan data terenkripsi dalam pesan terenkripsi yang dikembalikan. AWS Encryption SDK Untuk mendekripsi data, pertama-tama AWS Encryption SDK harus menggunakan salah satu kunci pembungkus Anda untuk mendekripsi kunci data terenkripsi.
Untuk menentukan AWS KMS key dalam keyring atau penyedia kunci utama, gunakan pengenal AWS KMS kunci yang didukung. Untuk detail tentang pengidentifikasi kunci untuk AWS KMS kunci, lihat [Pengidentifikasi Kunci di Panduan AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) *Pengembang*.
+ Saat mengenkripsi dengan AWS Encryption SDK for Java,, AWS Encryption SDK for JavaScript, atau AWS CLI Enkripsi AWS Encryption SDK for Python, Anda dapat menggunakan pengidentifikasi kunci yang valid (ID kunci, ARN kunci, nama alias, atau alias ARN) untuk kunci KMS. Saat mengenkripsi dengan AWS Encryption SDK for C, Anda hanya dapat menggunakan ID kunci atau kunci ARN.
Jika Anda menentukan nama alias atau alias ARN untuk kunci KMS saat mengenkripsi, menyimpan kunci ARN saat ini terkait dengan alias AWS Encryption SDK itu; itu tidak menyimpan alias. Perubahan pada alias tidak memengaruhi kunci KMS yang digunakan untuk mendekripsi kunci data Anda.
+ Saat mendekripsi dalam mode ketat (di mana Anda menentukan kunci pembungkus tertentu), Anda harus menggunakan ARN kunci untuk mengidentifikasi. AWS KMS keys Persyaratan ini berlaku untuk semua implementasi bahasa dari. AWS Encryption SDK
Ketika Anda mengenkripsi dengan AWS KMS keyring, AWS Encryption SDK menyimpan ARN kunci AWS KMS key dalam metadata kunci data terenkripsi. Saat mendekripsi dalam mode ketat, AWS Encryption SDK memverifikasi bahwa ARN kunci yang sama muncul di keyring (atau penyedia kunci utama) sebelum mencoba menggunakan kunci pembungkus untuk mendekripsi kunci data terenkripsi. Jika Anda menggunakan pengenal kunci yang berbeda, tidak AWS Encryption SDK akan mengenali atau menggunakan AWS KMS key, bahkan jika pengidentifikasi merujuk ke kunci yang sama.
Untuk menentukan kunci [AES mentah atau key](use-raw-aes-keyring.md) [pair RSA mentah sebagai kunci](use-raw-rsa-keyring.md) pembungkus dalam keyring, Anda harus menentukan namespace dan nama. Dalam penyedia kunci master, `Provider ID` adalah setara dengan namespace dan setara dengan nama. `Key ID` Saat mendekripsi, Anda harus menggunakan namespace dan nama yang sama persis untuk setiap kunci pembungkus mentah seperti yang Anda gunakan saat mengenkripsi. Jika Anda menggunakan namespace atau nama yang berbeda, tidak AWS Encryption SDK akan mengenali atau menggunakan kunci pembungkus, meskipun materi kuncinya sama.
## Menggunakan Multi-region AWS KMS keys
Anda dapat menggunakan AWS Key Management Service (AWS KMS) Tombol multi-region sebagai kunci pembungkus di. AWS Encryption SDK Jika Anda mengenkripsi dengan kunci Multi-wilayah dalam satu Wilayah AWS, Anda dapat mendekripsi menggunakan kunci Multi-wilayah terkait di yang berbeda. Wilayah AWS Support untuk kunci Multi-region diperkenalkan di versi 2.3. *x* dari AWS Encryption SDK dan versi 3.0. *x* dari CLI AWS Enkripsi.
AWS KMS Kunci multi-wilayah adalah satu set berbeda AWS KMS keys Wilayah AWS yang memiliki bahan kunci dan ID kunci yang sama. Anda dapat menggunakan kunci *terkait* ini seolah-olah mereka adalah kunci yang sama di Wilayah yang berbeda. Kunci Multi-Region mendukung pemulihan bencana umum dan skenario pencadangan yang memerlukan enkripsi di satu Wilayah dan mendekripsi di Wilayah yang berbeda tanpa melakukan panggilan Lintas wilayah. AWS KMS Untuk informasi tentang kunci Multi-region, lihat [Menggunakan kunci Multi-region](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html) di Panduan *AWS Key Management Service Pengembang*.
Untuk mendukung kunci Multi-wilayah, AWS Encryption SDK termasuk gantungan kunci yang AWS KMS sadar Multi-wilayah dan penyedia kunci utama. multi-Region-awareSimbol baru dalam setiap bahasa pemrograman mendukung tombol Single-region dan Multi-region.
+ Untuk kunci Single-region, multi-Region-aware simbol berperilaku seperti AWS KMS keyring wilayah tunggal dan penyedia kunci master. Ini mencoba untuk mendekripsi ciphertext hanya dengan kunci Single-region yang mengenkripsi data.
+ [Untuk kunci Multi-region, multi-Region-aware simbol mencoba mendekripsi ciphertext dengan kunci Multi-region yang sama yang mengenkripsi data atau dengan kunci replika Multi-wilayah terkait di Wilayah yang Anda tentukan.](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html#mrk-replica-key)
Di multi-Region-aware keyrings dan penyedia kunci master yang mengambil lebih dari satu kunci KMS, Anda dapat menentukan beberapa kunci Single-region dan Multi-region. Namun, Anda hanya dapat menentukan satu kunci dari setiap set kunci replika Multi-wilayah terkait. Jika Anda menentukan lebih dari satu pengenal kunci dengan ID kunci yang sama, panggilan konstruktor gagal.
Anda juga dapat menggunakan kunci Multi-region dengan AWS KMS keyring standar, Single-region dan penyedia kunci master. Namun, Anda harus menggunakan kunci Multi-region yang sama di Wilayah yang sama untuk mengenkripsi dan mendekripsi. Keyring wilayah tunggal dan penyedia kunci utama mencoba mendekripsi ciphertext hanya dengan kunci yang mengenkripsi data.
Contoh berikut menunjukkan cara mengenkripsi dan mendekripsi data menggunakan kunci Multi-region dan multi-Region-aware keyrings baru dan penyedia kunci utama. Contoh-contoh ini mengenkripsi data di `us-east-1` Wilayah dan mendekripsi data di `us-west-2` Wilayah menggunakan kunci replika Multi-wilayah terkait di setiap Wilayah. Sebelum menjalankan contoh ini, ganti contoh Multi-region key ARN dengan nilai yang valid dari Anda. Akun AWS
------
#### [ C ]
Untuk mengenkripsi dengan kunci Multi-region, gunakan `Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder()` metode ini untuk membuat instance keyring. Tentukan kunci Multi-wilayah.
Contoh sederhana ini tidak termasuk [konteks enkripsi](concepts.md#encryption-context). Untuk contoh yang menggunakan konteks enkripsi di C, lihat[Mengenkripsi dan mendekripsi string](c-examples.md#c-example-strings).
Untuk contoh lengkap, lihat [kms\$1multi\$1region\$1keys.cpp](https://github.com/aws/aws-encryption-sdk-c/tree/master/examples/kms_multi_region_keys.cpp) di AWS Encryption SDK for C repositori pada. GitHub
```
/* Encrypt with a multi-Region KMS key in us-east-1 */
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
/* Initialize a multi-Region keyring */
const char *mrk_us_east_1 = "arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";
struct aws_cryptosdk_keyring *mrk_keyring =
Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder().Build(mrk_us_east_1);
/* Create a session; release the keyring */
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(aws_default_allocator(), AWS_CRYPTOSDK_ENCRYPT, mrk_keyring);
aws_cryptosdk_keyring_release(mrk_keyring);
/* Encrypt the data
* aws_cryptosdk_session_process_full is designed for non-streaming data
*/
aws_cryptosdk_session_process_full(
session, ciphertext, ciphertext_buf_sz, &ciphertext_len, plaintext, plaintext_len));
/* Clean up the session */
aws_cryptosdk_session_destroy(session);
```
------
#### [ C\$1 / .NET ]
Untuk mengenkripsi dengan kunci Multi-region di Wilayah AS Timur (Virginia N.) (us-east-1), buat instance `CreateAwsKmsMrkKeyringInput` objek dengan pengenal kunci untuk kunci Multi-region dan klien untuk Wilayah yang ditentukan. AWS KMS Kemudian gunakan `CreateAwsKmsMrkKeyring()` metode untuk membuat keyring.
`CreateAwsKmsMrkKeyring()`Metode ini membuat keyring dengan tepat satu kunci Multi-region. Untuk mengenkripsi dengan beberapa kunci pembungkus, termasuk kunci Multi-wilayah, gunakan metode ini. `CreateAwsKmsMrkMultiKeyring()`
Untuk contoh lengkapnya, lihat [AwsKmsMrkKeyringExample.cs](https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/Examples/Keyring/AwsKmsMrkKeyringExample.cs) di repositori.NET AWS Encryption SDK for. GitHub
```
//Encrypt with a multi-Region KMS key in us-east-1 Region
// Instantiate the AWS Encryption SDK and material providers
var encryptionSdk = AwsEncryptionSdkFactory.CreateDefaultAwsEncryptionSdk();
var materialProviders =
AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();
// Multi-Region keys have a distinctive key ID that begins with 'mrk'
// Specify a multi-Region key in us-east-1
string mrkUSEast1 = "arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";
// Create the keyring
// You can specify the Region or get the Region from the key ARN
var createMrkEncryptKeyringInput = new CreateAwsKmsMrkKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USEast1),
KmsKeyId = mrkUSEast1
};
var mrkEncryptKeyring = materialProviders.CreateAwsKmsMrkKeyring(createMrkEncryptKeyringInput);
// Define the encryption context
var encryptionContext = new Dictionary()
{
{"purpose", "test"}
};
// Encrypt your plaintext data.
var encryptInput = new EncryptInput
{
Plaintext = plaintext,
Keyring = mrkEncryptKeyring,
EncryptionContext = encryptionContext
};
var encryptOutput = encryptionSdk.Encrypt(encryptInput);
```
------
#### [ AWS Encryption CLI ]
Contoh ini mengenkripsi `hello.txt` file di bawah kunci Multi-region di Wilayah us-east-1. Karena contoh menentukan ARN kunci dengan elemen Region, contoh ini tidak menggunakan atribut region **dari** parameter. `--wrapping-keys`
Jika ID kunci dari kunci pembungkus tidak menentukan Wilayah, Anda dapat menggunakan atribut **region** `--wrapping-keys` untuk menentukan wilayah, seperti`--wrapping-keys key=$keyID region=us-east-1`.
```
# Encrypt with a multi-Region KMS key in us-east-1 Region
# To run this example, replace the fictitious key ARN with a valid value.
$ mrkUSEast1=arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab
$ aws-encryption-cli --encrypt \
--input hello.txt \
--wrapping-keys key=$mrkUSEast1 \
--metadata-output ~/metadata \
--encryption-context purpose=test \
--output .
```
------
#### [ Java ]
Untuk mengenkripsi dengan kunci Multi-region, buat instance `AwsKmsMrkAwareMasterKeyProvider` dan tentukan kunci Multi-region.
Untuk contoh lengkap, lihat [https://github.com/aws/aws-encryption-sdk-java/blob/master/src/examples/java/com/amazonaws/crypto/examples/v2/BasicMultiRegionKeyEncryptionExample.java](https://github.com/aws/aws-encryption-sdk-java/blob/master/src/examples/java/com/amazonaws/crypto/examples/v2/BasicMultiRegionKeyEncryptionExample.java)di AWS Encryption SDK for Java repositori pada. GitHub
```
//Encrypt with a multi-Region KMS key in us-east-1 Region
// Instantiate the client
final AwsCrypto crypto = AwsCrypto.builder()
.withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
.build();
// Multi-Region keys have a distinctive key ID that begins with 'mrk'
// Specify a multi-Region key in us-east-1
final String mrkUSEast1 = "arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";
// Instantiate an AWS KMS master key provider in strict mode for multi-Region keys
// Configure it to encrypt with the multi-Region key in us-east-1
final AwsKmsMrkAwareMasterKeyProvider kmsMrkProvider = AwsKmsMrkAwareMasterKeyProvider
.builder()
.buildStrict(mrkUSEast1);
// Create an encryption context
final Map encryptionContext = Collections.singletonMap("Purpose", "Test");
// Encrypt your plaintext data
final CryptoResult encryptResult = crypto.encryptData(
kmsMrkProvider,
encryptionContext,
sourcePlaintext);
byte[] ciphertext = encryptResult.getResult();
```
------
#### [ JavaScript Browser ]
Untuk mengenkripsi dengan kunci Multi-region, gunakan `buildAwsKmsMrkAwareStrictMultiKeyringBrowser()` metode untuk membuat keyring dan tentukan kunci Multi-region.
Untuk contoh lengkap, lihat [kms\$1multi\$1region\$1simple.ts di repositori](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-browser/src/kms_multi_region_simple.ts) pada. AWS Encryption SDK for JavaScript GitHub
```
/* Encrypt with a multi-Region KMS key in us-east-1 Region */
import {
buildAwsKmsMrkAwareStrictMultiKeyringBrowser,
buildClient,
CommitmentPolicy,
KMS,
} from '@aws-crypto/client-browser'
/* Instantiate an AWS Encryption SDK client */
const { encrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
declare const credentials: {
accessKeyId: string
secretAccessKey: string
sessionToken: string
}
/* Instantiate an AWS KMS client
* The AWS Encryption SDK for JavaScript gets the Region from the key ARN
*/
const clientProvider = (region: string) => new KMS({ region, credentials })
/* Specify a multi-Region key in us-east-1 */
const multiRegionUsEastKey =
'arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'
/* Instantiate the keyring */
const encryptKeyring = buildAwsKmsMrkAwareStrictMultiKeyringBrowser({
generatorKeyId: multiRegionUsEastKey,
clientProvider,
})
/* Set the encryption context */
const context = {
purpose: 'test',
}
/* Test data to encrypt */
const cleartext = new Uint8Array([1, 2, 3, 4, 5])
/* Encrypt the data */
const { result } = await encrypt(encryptKeyring, cleartext, {
encryptionContext: context,
})
```
------
#### [ JavaScript Node.js ]
Untuk mengenkripsi dengan kunci Multi-region, gunakan `buildAwsKmsMrkAwareStrictMultiKeyringNode()` metode untuk membuat keyring dan tentukan kunci Multi-region.
Untuk contoh lengkap, lihat [kms\$1multi\$1region\$1simple.ts di repositori](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-node/src/kms_multi_region_simple.ts) pada. AWS Encryption SDK for JavaScript GitHub
```
//Encrypt with a multi-Region KMS key in us-east-1 Region
import { buildClient } from '@aws-crypto/client-node'
/* Instantiate the AWS Encryption SDK client
const { encrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
/* Test string to encrypt */
const cleartext = 'asdf'
/* Multi-Region keys have a distinctive key ID that begins with 'mrk'
* Specify a multi-Region key in us-east-1
*/
const multiRegionUsEastKey =
'arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'
/* Create an AWS KMS keyring */
const mrkEncryptKeyring = buildAwsKmsMrkAwareStrictMultiKeyringNode({
generatorKeyId: multiRegionUsEastKey,
})
/* Specify an encryption context */
const context = {
purpose: 'test',
}
/* Create an encryption keyring */
const { result } = await encrypt(mrkEncryptKeyring, cleartext, {
encryptionContext: context,
})
```
------
#### [ Python ]
Untuk mengenkripsi dengan kunci AWS KMS Multi-region, gunakan `MRKAwareStrictAwsKmsMasterKeyProvider()` metode dan tentukan kunci Multi-region.
Untuk contoh lengkap, lihat [mrk\$1aware\$1kms\$1provider.py](https://github.com/aws/aws-encryption-sdk-python/blob/master/examples/src/legacy/mrk_aware_kms_provider.py) di AWS Encryption SDK for Python repositori pada. GitHub
```
* Encrypt with a multi-Region KMS key in us-east-1 Region
# Instantiate the client
client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT)
# Specify a multi-Region key in us-east-1
mrk_us_east_1 = "arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab"
# Use the multi-Region method to create the master key provider
# in strict mode
strict_mrk_key_provider = MRKAwareStrictAwsKmsMasterKeyProvider(
key_ids=[mrk_us_east_1]
)
# Set the encryption context
encryption_context = {
"purpose": "test"
}
# Encrypt your plaintext data
ciphertext, encrypt_header = client.encrypt(
source=source_plaintext,
encryption_context=encryption_context,
key_provider=strict_mrk_key_provider
)
```
------
Selanjutnya, pindahkan ciphertext Anda ke Region. `us-west-2` Anda tidak perlu mengenkripsi ulang ciphertext.
Untuk mendekripsi ciphertext dalam mode ketat di `us-west-2` Region, buat instance simbol multi-Region-aware dengan kunci ARN dari kunci Multi-region terkait di Region. `us-west-2` Jika Anda menentukan kunci ARN dari kunci Multi-wilayah terkait di Wilayah yang berbeda (termasuk`us-east-1`, di mana itu dienkripsi), multi-Region-aware simbol akan membuat panggilan lintas wilayah untuk itu. AWS KMS key
Saat mendekripsi dalam mode ketat, multi-Region-aware simbol membutuhkan kunci ARN. Ini hanya menerima satu ARN kunci dari setiap set kunci Multi-wilayah terkait.
Sebelum menjalankan contoh ini, ganti contoh Multi-region key ARN dengan nilai yang valid dari Anda. Akun AWS
------
#### [ C ]
Untuk mendekripsi dalam mode ketat dengan kunci Multi-region, gunakan `Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder()` metode ini untuk membuat instance keyring. Tentukan kunci Multi-wilayah terkait di Wilayah lokal (us-west-2).
Untuk contoh lengkap, lihat [kms\$1multi\$1region\$1keys.cpp](https://github.com/aws/aws-encryption-sdk-c/tree/master/examples/kms_multi_region_keys.cpp) di AWS Encryption SDK for C repositori pada. GitHub
```
/* Decrypt with a related multi-Region KMS key in us-west-2 Region */
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
/* Initialize a multi-Region keyring */
const char *mrk_us_west_2 = "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";
struct aws_cryptosdk_keyring *mrk_keyring =
Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder().Build(mrk_us_west_2);
/* Create a session; release the keyring */
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(aws_default_allocator(), AWS_CRYPTOSDK_ENCRYPT, mrk_keyring);
aws_cryptosdk_session_set_commitment_policy(session,
COMMITMENT_POLICY_REQUIRE_ENCRYPT_REQUIRE_DECRYPT);
aws_cryptosdk_keyring_release(mrk_keyring);
/* Decrypt the ciphertext
* aws_cryptosdk_session_process_full is designed for non-streaming data
*/
aws_cryptosdk_session_process_full(
session, plaintext, plaintext_buf_sz, &plaintext_len, ciphertext, ciphertext_len));
/* Clean up the session */
aws_cryptosdk_session_destroy(session);
```
------
#### [ C\$1 / .NET ]
Untuk mendekripsi dalam mode ketat dengan satu kunci Multi-wilayah, gunakan konstruktor dan metode yang sama yang Anda gunakan untuk merakit input dan membuat keyring untuk mengenkripsi. Buat instance `CreateAwsKmsMrkKeyringInput` objek dengan ARN kunci dari kunci Multi-wilayah terkait dan AWS KMS klien untuk Wilayah AS Barat (Oregon) (us-west-2). Kemudian gunakan `CreateAwsKmsMrkKeyring()` metode untuk membuat keyring Multi-wilayah dengan satu kunci KMS Multi-wilayah.
Untuk contoh lengkapnya, lihat [AwsKmsMrkKeyringExample.cs](https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/Examples/Keyring/AwsKmsMrkKeyringExample.cs) di repositori.NET AWS Encryption SDK for. GitHub
```
// Decrypt with a related multi-Region KMS key in us-west-2 Region
// Instantiate the AWS Encryption SDK and material providers
var encryptionSdk = AwsEncryptionSdkFactory.CreateDefaultAwsEncryptionSdk();
var materialProviders =
AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();
// Specify the key ARN of the multi-Region key in us-west-2
string mrkUSWest2 = "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";
// Instantiate the keyring input
// You can specify the Region or get the Region from the key ARN
var createMrkDecryptKeyringInput = new CreateAwsKmsMrkKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USWest2),
KmsKeyId = mrkUSWest2
};
// Create the multi-Region keyring
var mrkDecryptKeyring = materialProviders.CreateAwsKmsMrkKeyring(createMrkDecryptKeyringInput);
// Decrypt the ciphertext
var decryptInput = new DecryptInput
{
Ciphertext = ciphertext,
Keyring = mrkDecryptKeyring
};
var decryptOutput = encryptionSdk.Decrypt(decryptInput);
```
------
#### [ AWS Encryption CLI ]
Untuk mendekripsi dengan kunci Multi-region terkait di Wilayah us-west-2, gunakan atribut kunci parameter untuk menentukan ARN **kuncinya**. `--wrapping-keys`
```
# Decrypt with a related multi-Region KMS key in us-west-2 Region
# To run this example, replace the fictitious key ARN with a valid value.
$ mrkUSWest2=arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab
$ aws-encryption-cli --decrypt \
--input hello.txt.encrypted \
--wrapping-keys key=$mrkUSWest2 \
--commitment-policy require-encrypt-require-decrypt \
--encryption-context purpose=test \
--metadata-output ~/metadata \
--max-encrypted-data-keys 1 \
--buffer \
--output .
```
------
#### [ Java ]
Untuk mendekripsi dalam mode ketat, buat instance `AwsKmsMrkAwareMasterKeyProvider` dan tentukan kunci Multi-wilayah terkait di Wilayah lokal (us-west-2).
Untuk contoh lengkap, lihat [BasicMultiRegionKeyEncryptionExample.java](https://github.com/aws/aws-encryption-sdk-java/blob/master/src/examples/java/com/amazonaws/crypto/examples/v2/BasicMultiRegionKeyEncryptionExample.java) di AWS Encryption SDK for Java repositori pada. GitHub
```
// Decrypt with a related multi-Region KMS key in us-west-2 Region
// Instantiate the client
final AwsCrypto crypto = AwsCrypto.builder()
.withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
.build();
// Related multi-Region keys have the same key ID. Their key ARNs differs only in the Region field.
String mrkUSWest2 = "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab";
// Use the multi-Region method to create the master key provider
// in strict mode
AwsKmsMrkAwareMasterKeyProvider kmsMrkProvider = AwsKmsMrkAwareMasterKeyProvider.builder()
.buildStrict(mrkUSWest2);
// Decrypt your ciphertext
CryptoResult decryptResult = crypto.decryptData(
kmsMrkProvider,
ciphertext);
byte[] decrypted = decryptResult.getResult();
```
------
#### [ JavaScript Browser ]
Untuk mendekripsi dalam mode ketat, gunakan `buildAwsKmsMrkAwareStrictMultiKeyringBrowser()` metode untuk membuat keyring dan tentukan kunci Multi-region terkait di Wilayah lokal (us-west-2).
Untuk contoh lengkap, lihat [kms\$1multi\$1region\$1simple.ts di repositori](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-browser/src/kms_multi_region_simple.ts) pada. AWS Encryption SDK for JavaScript GitHub
```
/* Decrypt with a related multi-Region KMS key in us-west-2 Region */
import {
buildAwsKmsMrkAwareStrictMultiKeyringBrowser,
buildClient,
CommitmentPolicy,
KMS,
} from '@aws-crypto/client-browser'
/* Instantiate an AWS Encryption SDK client */
const { decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
declare const credentials: {
accessKeyId: string
secretAccessKey: string
sessionToken: string
}
/* Instantiate an AWS KMS client
* The AWS Encryption SDK for JavaScript gets the Region from the key ARN
*/
const clientProvider = (region: string) => new KMS({ region, credentials })
/* Specify a multi-Region key in us-west-2 */
const multiRegionUsWestKey =
'arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'
/* Instantiate the keyring */
const mrkDecryptKeyring = buildAwsKmsMrkAwareStrictMultiKeyringBrowser({
generatorKeyId: multiRegionUsWestKey,
clientProvider,
})
/* Decrypt the data */
const { plaintext, messageHeader } = await decrypt(mrkDecryptKeyring, result)
```
------
#### [ JavaScript Node.js ]
Untuk mendekripsi dalam mode ketat, gunakan `buildAwsKmsMrkAwareStrictMultiKeyringNode()` metode untuk membuat keyring dan tentukan kunci Multi-region terkait di Wilayah lokal (us-west-2).
Untuk contoh lengkap, lihat [kms\$1multi\$1region\$1simple.ts di repositori](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-node/src/kms_multi_region_simple.ts) pada. AWS Encryption SDK for JavaScript GitHub
```
/* Decrypt with a related multi-Region KMS key in us-west-2 Region */
import { buildClient } from '@aws-crypto/client-node'
/* Instantiate the client
const { decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
/* Multi-Region keys have a distinctive key ID that begins with 'mrk'
* Specify a multi-Region key in us-west-2
*/
const multiRegionUsWestKey =
'arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'
/* Create an AWS KMS keyring */
const mrkDecryptKeyring = buildAwsKmsMrkAwareStrictMultiKeyringNode({
generatorKeyId: multiRegionUsWestKey,
})
/* Decrypt your ciphertext */
const { plaintext, messageHeader } = await decrypt(decryptKeyring, result)
```
------
#### [ Python ]
Untuk mendekripsi dalam mode ketat, gunakan `MRKAwareStrictAwsKmsMasterKeyProvider()` metode untuk membuat penyedia kunci master. Tentukan kunci Multi-wilayah terkait di Wilayah lokal (us-west-2).
Untuk contoh lengkap, lihat [mrk\$1aware\$1kms\$1provider.py](https://github.com/aws/aws-encryption-sdk-python/blob/master/examples/src/legacy/mrk_aware_kms_provider.py) di AWS Encryption SDK for Python repositori pada. GitHub
```
# Decrypt with a related multi-Region KMS key in us-west-2 Region
# Instantiate the client
client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT)
# Related multi-Region keys have the same key ID. Their key ARNs differs only in the Region field
mrk_us_west_2 = "arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab"
# Use the multi-Region method to create the master key provider
# in strict mode
strict_mrk_key_provider = MRKAwareStrictAwsKmsMasterKeyProvider(
key_ids=[mrk_us_west_2]
)
# Decrypt your ciphertext
plaintext, _ = client.decrypt(
source=ciphertext,
key_provider=strict_mrk_key_provider
)
```
------
Anda juga dapat mendekripsi dalam *mode penemuan* dengan tombol AWS KMS Multi-wilayah. Saat mendekripsi dalam mode penemuan, Anda tidak menentukan apa pun. AWS KMS keys(Untuk informasi tentang gantungan kunci AWS KMS penemuan wilayah tunggal, lihat[Menggunakan AWS KMS keyring penemuan](use-kms-keyring.md#kms-keyring-discovery).)
Jika Anda dienkripsi dengan kunci Multi-region, multi-Region-aware simbol dalam mode penemuan akan mencoba mendekripsi dengan menggunakan kunci Multi-wilayah terkait di Wilayah lokal. Jika tidak ada; panggilan gagal. Dalam mode penemuan, tidak AWS Encryption SDK akan mencoba panggilan lintas wilayah untuk kunci Multi-wilayah yang digunakan untuk enkripsi.
**catatan**
Jika Anda menggunakan multi-Region-aware simbol dalam mode penemuan untuk mengenkripsi data, operasi enkripsi gagal.
Contoh berikut menunjukkan cara mendekripsi dengan multi-Region-aware simbol dalam mode penemuan. Karena Anda tidak menentukan AWS KMS key, AWS Encryption SDK harus mendapatkan Wilayah dari sumber yang berbeda. Jika memungkinkan, tentukan Wilayah lokal secara eksplisit. Jika tidak, AWS Encryption SDK akan mendapatkan Wilayah lokal dari Wilayah yang dikonfigurasi dalam AWS SDK untuk bahasa pemrograman Anda.
Sebelum menjalankan contoh ini, ganti contoh ID akun dan ARN kunci Multi-wilayah dengan nilai yang valid dari Anda. Akun AWS
------
#### [ C ]
Untuk mendekripsi dalam mode penemuan dengan kunci Multi-region, gunakan `Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder()` metode untuk membangun keyring, dan `Aws::Cryptosdk::KmsKeyring::DiscoveryFilter::Builder()` metode untuk membangun filter penemuan. Untuk menentukan Wilayah lokal, tentukan `ClientConfiguration` dan tentukan di AWS KMS klien.
Untuk contoh lengkap, lihat [kms\$1multi\$1region\$1keys.cpp](https://github.com/aws/aws-encryption-sdk-c/tree/master/examples/kms_multi_region_keys.cpp) di AWS Encryption SDK for C repositori pada. GitHub
```
/* Decrypt in discovery mode with a multi-Region KMS key */
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
/* Construct a discovery filter for the account and partition. The
* filter is optional, but it's a best practice that we recommend.
*/
const char *account_id = "111122223333";
const char *partition = "aws";
const std::shared_ptr discovery_filter =
Aws::Cryptosdk::KmsKeyring::DiscoveryFilter::Builder(partition).AddAccount(account_id).Build();
/* Create an AWS KMS client in the desired region. */
const char *region = "us-west-2";
Aws::Client::ClientConfiguration client_config;
client_config.region = region;
const std::shared_ptr kms_client =
Aws::MakeShared("AWS_SAMPLE_CODE", client_config);
struct aws_cryptosdk_keyring *mrk_keyring =
Aws::Cryptosdk::KmsMrkAwareSymmetricKeyring::Builder()
.WithKmsClient(kms_client)
.BuildDiscovery(region, discovery_filter);
/* Create a session; release the keyring */
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(aws_default_allocator(), AWS_CRYPTOSDK_DECRYPT, mrk_keyring);
aws_cryptosdk_keyring_release(mrk_keyring);
commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
/* Decrypt the ciphertext
* aws_cryptosdk_session_process_full is designed for non-streaming data
*/
aws_cryptosdk_session_process_full(
session, plaintext, plaintext_buf_sz, &plaintext_len, ciphertext, ciphertext_len));
/* Clean up the session */
aws_cryptosdk_session_destroy(session);
```
------
#### [ C\$1 / .NET ]
Untuk membuat keyring multi-Region-aware penemuan di AWS Encryption SDK for .NET, buat instance `CreateAwsKmsMrkDiscoveryKeyringInput` objek yang mengambil AWS KMS klien untuk tertentu Wilayah AWS, dan filter penemuan opsional yang membatasi kunci KMS ke partisi dan akun tertentu AWS . Kemudian panggil `CreateAwsKmsMrkDiscoveryKeyring()` metode dengan objek input. Untuk contoh lengkapnya, lihat [AwsKmsMrkDiscoveryKeyringExample.cs](https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/Examples/Keyring/AwsKmsMrkDiscoveryKeyringExample.cs) di repositori.NET AWS Encryption SDK for. GitHub
Untuk membuat keyring multi-Region-aware penemuan untuk lebih dari satu Wilayah AWS, gunakan `CreateAwsKmsMrkDiscoveryMultiKeyring()` metode ini untuk membuat multi-keyring, atau gunakan `CreateAwsKmsMrkDiscoveryKeyring()` untuk membuat beberapa keyring multi-Region-aware penemuan dan kemudian gunakan `CreateMultiKeyring()` metode untuk menggabungkannya dalam multi-keyring.
Sebagai contoh, lihat [AwsKmsMrkDiscoveryMultiKeyringExample.cs](https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/Examples/Keyring/AwsKmsMrkDiscoveryMultiKeyringExample.cs).
```
// Decrypt in discovery mode with a multi-Region KMS key
// Instantiate the AWS Encryption SDK and material providers
var encryptionSdk = AwsEncryptionSdkFactory.CreateDefaultAwsEncryptionSdk();
var materialProviders =
AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();
List account = new List { "111122223333" };
// Instantiate the discovery filter
DiscoveryFilter mrkDiscoveryFilter = new DiscoveryFilter()
{
AccountIds = account,
Partition = "aws"
}
// Create the keyring
var createMrkDiscoveryKeyringInput = new CreateAwsKmsMrkDiscoveryKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USWest2),
DiscoveryFilter = mrkDiscoveryFilter
};
var mrkDiscoveryKeyring = materialProviders.CreateAwsKmsMrkDiscoveryKeyring(createMrkDiscoveryKeyringInput);
// Decrypt the ciphertext
var decryptInput = new DecryptInput
{
Ciphertext = ciphertext,
Keyring = mrkDiscoveryKeyring
};
var decryptOutput = encryptionSdk.Decrypt(decryptInput);
```
------
#### [ AWS Encryption CLI ]
Untuk mendekripsi dalam mode penemuan, gunakan atribut **penemuan** parameter. `--wrapping-keys` Atribut **discovery-account** dan **discovery-partition** membuat filter penemuan yang opsional, tetapi direkomendasikan.
Untuk menentukan Region, perintah ini mencakup atribut **region** dari `--wrapping-keys` parameter.
```
# Decrypt in discovery mode with a multi-Region KMS key
$ aws-encryption-cli --decrypt \
--input hello.txt.encrypted \
--wrapping-keys discovery=true \
discovery-account=111122223333 \
discovery-partition=aws \
region=us-west-2 \
--encryption-context purpose=test \
--metadata-output ~/metadata \
--max-encrypted-data-keys 1 \
--buffer \
--output .
```
------
#### [ Java ]
Untuk menentukan Wilayah lokal, gunakan `builder().withDiscoveryMrkRegion` parameter. Jika tidak, AWS Encryption SDK mendapatkan Wilayah lokal dari Wilayah yang dikonfigurasi di [AWS SDK untuk Java](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/java-dg-region-selection.html).
Untuk contoh lengkap, lihat [DiscoveryMultiRegionDecryptionExample.java](https://github.com/aws/aws-encryption-sdk-java/blob/master/src/examples/java/com/amazonaws/crypto/examples/v2/DiscoveryMultiRegionDecryptionExample.java) di AWS Encryption SDK for Java repositori pada. GitHub
```
// Decrypt in discovery mode with a multi-Region KMS key
// Instantiate the client
final AwsCrypto crypto = AwsCrypto.builder()
.withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
.build();
DiscoveryFilter discoveryFilter = new DiscoveryFilter("aws", 111122223333);
AwsKmsMrkAwareMasterKeyProvider mrkDiscoveryProvider = AwsKmsMrkAwareMasterKeyProvider
.builder()
.withDiscoveryMrkRegion(Region.US_WEST_2)
.buildDiscovery(discoveryFilter);
// Decrypt your ciphertext
final CryptoResult decryptResult = crypto
.decryptData(mrkDiscoveryProvider, ciphertext);
```
------
#### [ JavaScript Browser ]
Untuk mendekripsi dalam mode penemuan dengan kunci Multi-region simetris, gunakan metode ini. `AwsKmsMrkAwareSymmetricDiscoveryKeyringBrowser()`
Untuk contoh lengkap, lihat [kms\$1multi\$1region\$1discovery.ts di repositori](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-browser/src/kms_multi_region_discovery.ts) pada. AWS Encryption SDK for JavaScript GitHub
```
/* Decrypt in discovery mode with a multi-Region KMS key */
import {
AwsKmsMrkAwareSymmetricDiscoveryKeyringBrowser,
buildClient,
CommitmentPolicy,
KMS,
} from '@aws-crypto/client-browser'
/* Instantiate an AWS Encryption SDK client */
const { decrypt } = buildClient()
declare const credentials: {
accessKeyId: string
secretAccessKey: string
sessionToken: string
}
/* Instantiate the KMS client with an explicit Region */
const client = new KMS({ region: 'us-west-2', credentials })
/* Create a discovery filter */
const discoveryFilter = { partition: 'aws', accountIDs: ['111122223333'] }
/* Create an AWS KMS discovery keyring */
const mrkDiscoveryKeyring = new AwsKmsMrkAwareSymmetricDiscoveryKeyringBrowser({
client,
discoveryFilter,
})
/* Decrypt the data */
const { plaintext, messageHeader } = await decrypt(mrkDiscoveryKeyring, ciphertext)
```
------
#### [ JavaScript Node.js ]
Untuk mendekripsi dalam mode penemuan dengan kunci Multi-region simetris, gunakan metode ini. `AwsKmsMrkAwareSymmetricDiscoveryKeyringNode()`
Untuk contoh lengkap, lihat [kms\$1multi\$1region\$1discovery.ts di repositori](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-node/src/kms_multi_region_discovery.ts) pada. AWS Encryption SDK for JavaScript GitHub
```
/* Decrypt in discovery mode with a multi-Region KMS key */
import {
AwsKmsMrkAwareSymmetricDiscoveryKeyringNode,
buildClient,
CommitmentPolicy,
KMS,
} from '@aws-crypto/client-node'
/* Instantiate the Encryption SDK client
const { decrypt } = buildClient()
/* Instantiate the KMS client with an explicit Region */
const client = new KMS({ region: 'us-west-2' })
/* Create a discovery filter */
const discoveryFilter = { partition: 'aws', accountIDs: ['111122223333'] }
/* Create an AWS KMS discovery keyring */
const mrkDiscoveryKeyring = new AwsKmsMrkAwareSymmetricDiscoveryKeyringNode({
client,
discoveryFilter,
})
/* Decrypt your ciphertext */
const { plaintext, messageHeader } = await decrypt(mrkDiscoveryKeyring, result)
```
------
#### [ Python ]
Untuk mendekripsi dalam mode penemuan dengan kunci Multi-wilayah, gunakan metode ini. `MRKAwareDiscoveryAwsKmsMasterKeyProvider()`
Untuk contoh lengkap, lihat [mrk\$1aware\$1kms\$1provider.py](https://github.com/aws/aws-encryption-sdk-python/blob/master/examples/src/legacy/mrk_aware_kms_provider.py) di AWS Encryption SDK for Python repositori pada. GitHub
```
# Decrypt in discovery mode with a multi-Region KMS key
# Instantiate the client
client = aws_encryption_sdk.EncryptionSDKClient()
# Create the discovery filter and specify the region
decrypt_kwargs = dict(
discovery_filter=DiscoveryFilter(account_ids="111122223333", partition="aws"),
discovery_region="us-west-2",
)
# Use the multi-Region method to create the master key provider
# in discovery mode
mrk_discovery_key_provider = MRKAwareDiscoveryAwsKmsMasterKeyProvider(**decrypt_kwargs)
# Decrypt your ciphertext
plaintext, _ = client.decrypt(
source=ciphertext,
key_provider=mrk_discovery_key_provider
)
```
------
## Memilih rangkaian algoritme
AWS Encryption SDK Mendukung beberapa [algoritma enkripsi simetris dan asimetris untuk mengenkripsi](concepts.md#symmetric-key-encryption) kunci data Anda di bawah kunci pembungkus yang Anda tentukan. [[Namun, ketika menggunakan kunci data tersebut untuk mengenkripsi data Anda, AWS Encryption SDK default ke [rangkaian algoritme yang direkomendasikan yang menggunakan algoritma](supported-algorithms.md#recommended-algorithms) AES-GCM dengan [derivasi kunci, tanda tangan digital, dan komitmen kunci](reference.md).](concepts.md#key-commitment)](concepts.md#digital-sigs) Meskipun rangkaian algoritme default kemungkinan cocok untuk sebagian besar aplikasi, Anda dapat memilih rangkaian algoritme alternatif. Misalnya, beberapa model kepercayaan akan dipenuhi oleh rangkaian algoritma tanpa [tanda tangan digital](concepts.md#digital-sigs). Untuk informasi tentang rangkaian algoritme yang AWS Encryption SDK didukung, lihat[Suite algoritma yang didukung di AWS Encryption SDK](supported-algorithms.md).
Contoh berikut menunjukkan cara memilih rangkaian algoritma alternatif saat mengenkripsi. Contoh-contoh ini memilih rangkaian algoritma AES-GCM yang direkomendasikan dengan derivasi kunci dan komitmen kunci, tetapi tanpa tanda tangan digital. Saat Anda mengenkripsi dengan rangkaian algoritme yang tidak menyertakan tanda tangan digital, gunakan mode dekripsi khusus tanpa tanda tangan saat mendekripsi. Mode ini, yang gagal jika menemukan ciphertext yang ditandatangani, paling berguna saat streaming dekripsi.
------
#### [ C ]
Untuk menentukan rangkaian algoritma alternatif di AWS Encryption SDK for C, Anda harus membuat CMM secara eksplisit. Kemudian gunakan `aws_cryptosdk_default_cmm_set_alg_id` with the CMM dan suite algoritma yang dipilih.
```
/* Specify an algorithm suite without signing */
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
/* Construct an AWS KMS keyring */
struct aws_cryptosdk_keyring *kms_keyring = Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn);
/* To set an alternate algorithm suite, create an cryptographic
materials manager (CMM) explicitly
*/
struct aws_cryptosdk_cmm *cmm = aws_cryptosdk_default_cmm_new(aws_default_allocator(), kms_keyring);
aws_cryptosdk_keyring_release(kms_keyring);
/* Specify the algorithm suite for the CMM */
aws_cryptosdk_default_cmm_set_alg_id(cmm, ALG_AES256_GCM_HKDF_SHA512_COMMIT_KEY);
/* Construct the session with the CMM,
then release the CMM reference
*/
struct aws_cryptosdk_session *session = aws_cryptosdk_session_new_from_cmm_2(alloc, AWS_CRYPTOSDK_ENCRYPT, cmm);
aws_cryptosdk_cmm_release(cmm);
/* Encrypt the data
Use aws_cryptosdk_session_process_full with non-streaming data
*/
if (AWS_OP_SUCCESS != aws_cryptosdk_session_process_full(
session,
ciphertext,
ciphertext_buf_sz,
&ciphertext_len,
plaintext,
plaintext_len)) {
aws_cryptosdk_session_destroy(session);
return AWS_OP_ERR;
}
```
Saat mendekripsi data yang dienkripsi tanpa tanda tangan digital, gunakan. `AWS_CRYPTOSDK_DECRYPT_UNSIGNED` Hal ini menyebabkan dekripsi gagal jika menemukan ciphertext yang ditandatangani.
```
/* Decrypt unsigned streaming data */
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
/* Construct an AWS KMS keyring */
struct aws_cryptosdk_keyring *kms_keyring = Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn);
/* Create a session for decrypting with the AWS KMS keyring
Then release the keyring reference
*/
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(alloc, AWS_CRYPTOSDK_DECRYPT_UNSIGNED, kms_keyring);
aws_cryptosdk_keyring_release(kms_keyring);
if (!session) {
return AWS_OP_ERR;
}
/* Limit encrypted data keys */
aws_cryptosdk_session_set_max_encrypted_data_keys(session, 1);
/* Decrypt
Use aws_cryptosdk_session_process_full with non-streaming data
*/
if (AWS_OP_SUCCESS != aws_cryptosdk_session_process_full(
session,
plaintext,
plaintext_buf_sz,
&plaintext_len,
ciphertext,
ciphertext_len)) {
aws_cryptosdk_session_destroy(session);
return AWS_OP_ERR;
}
```
------
#### [ C\$1 / .NET ]
Untuk menentukan rangkaian algoritme alternatif di AWS Encryption SDK for .NET, tentukan `AlgorithmSuiteId` properti [EncryptInput](https://github.com/aws/aws-encryption-sdk/blob/mainline/AwsEncryptionSDK/runtimes/net/Generated/AwsEncryptionSdk/EncryptInput.cs)objek. AWS Encryption SDK Untuk .NET mencakup [konstanta](https://github.com/aws/aws-cryptographic-material-providers-library/blob/main/AwsCryptographicMaterialProviders/runtimes/net/Generated/AwsCryptographicMaterialProviders/AlgorithmSuiteId.cs) yang dapat Anda gunakan untuk mengidentifikasi rangkaian algoritme pilihan Anda.
The AWS Encryption SDK for .NET tidak memiliki metode untuk mendeteksi ciphertext yang ditandatangani saat streaming dekripsi karena pustaka ini tidak mendukung data streaming.
```
// Specify an algorithm suite without signing
// Instantiate the AWS Encryption SDK and material providers
var encryptionSdk = AwsEncryptionSdkFactory.CreateDefaultAwsEncryptionSdk();
var materialProviders =
AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();
// Create the keyring
var keyringInput = new CreateAwsKmsKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(),
KmsKeyId = keyArn
};
var keyring = materialProviders.CreateAwsKmsKeyring(keyringInput);
// Encrypt your plaintext data
var encryptInput = new EncryptInput
{
Plaintext = plaintext,
Keyring = keyring,
AlgorithmSuiteId = AlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY
};
var encryptOutput = encryptionSdk.Encrypt(encryptInput);
```
------
#### [ AWS Encryption CLI ]
Saat mengenkripsi `hello.txt` file, contoh ini menggunakan `--algorithm` parameter untuk menentukan rangkaian algoritma tanpa tanda tangan digital.
```
# Specify an algorithm suite without signing
# 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
$ aws-encryption-cli --encrypt \
--input hello.txt \
--wrapping-keys key=$keyArn \
--algorithm AES_256_GCM_HKDF_SHA512_COMMIT_KEY \
--metadata-output ~/metadata \
--encryption-context purpose=test \
--commitment-policy require-encrypt-require-decrypt \
--output hello.txt.encrypted \
--decode
```
Saat mendekripsi, contoh ini menggunakan parameter. `--decrypt-unsigned` Parameter ini disarankan untuk memastikan bahwa Anda mendekripsi ciphertext yang tidak ditandatangani, terutama dengan CLI, yang selalu streaming input dan output.
```
# Decrypt unsigned streaming data
# 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
$ aws-encryption-cli --decrypt-unsigned \
--input hello.txt.encrypted \
--wrapping-keys key=$keyArn \
--max-encrypted-data-keys 1 \
--commitment-policy require-encrypt-require-decrypt \
--encryption-context purpose=test \
--metadata-output ~/metadata \
--output .
```
------
#### [ Java ]
Untuk menentukan rangkaian algoritma alternatif, gunakan `AwsCrypto.builder().withEncryptionAlgorithm()` metode ini. Contoh ini menentukan rangkaian algoritma alternatif tanpa tanda tangan digital.
```
// Specify an algorithm suite without signing
// Instantiate the client
AwsCrypto crypto = AwsCrypto.builder()
.withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
.withEncryptionAlgorithm(CryptoAlgorithm.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY)
.build();
String awsKmsKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
// Create a master key provider in strict mode
KmsMasterKeyProvider masterKeyProvider = KmsMasterKeyProvider.builder()
.buildStrict(awsKmsKey);
// Create an encryption context to identify this ciphertext
Map encryptionContext = Collections.singletonMap("Example", "FileStreaming");
// Encrypt your plaintext data
CryptoResult encryptResult = crypto.encryptData(
masterKeyProvider,
sourcePlaintext,
encryptionContext);
byte[] ciphertext = encryptResult.getResult();
```
Saat streaming data untuk dekripsi, gunakan `createUnsignedMessageDecryptingStream()` metode ini untuk memastikan bahwa semua ciphertext yang Anda dekripsi tidak ditandatangani.
```
// Decrypt unsigned streaming data
// Instantiate the client
AwsCrypto crypto = AwsCrypto.builder()
.withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
.withMaxEncryptedDataKeys(1)
.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);
// Decrypt the encrypted message
FileInputStream in = new FileInputStream(srcFile + ".encrypted");
CryptoInputStream decryptingStream = crypto.createUnsignedMessageDecryptingStream(masterKeyProvider, in);
// Return the plaintext data
// Write the plaintext data to disk
FileOutputStream out = new FileOutputStream(srcFile + ".decrypted");
IOUtils.copy(decryptingStream, out);
decryptingStream.close();
```
------
#### [ JavaScript Browser ]
Untuk menentukan rangkaian algoritma alternatif, gunakan `suiteId` parameter dengan nilai `AlgorithmSuiteIdentifier` enum.
```
// Specify an algorithm suite without signing
// Instantiate the client
const { encrypt } = buildClient( CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT )
// Specify a KMS key
const generatorKeyId = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
// Create a keyring with the KMS key
const keyring = new KmsKeyringBrowser({ generatorKeyId })
// Encrypt your plaintext data
const { result } = await encrypt(keyring, cleartext, { suiteId: AlgorithmSuiteIdentifier.ALG_AES256_GCM_IV12_TAG16_HKDF_SHA512_COMMIT_KEY, encryptionContext: context, })
```
Saat mendekripsi, gunakan metode standar`decrypt`. AWS Encryption SDK for JavaScript di browser tidak memiliki `decrypt-unsigned` mode karena browser tidak mendukung streaming.
```
// Decrypt unsigned streaming data
// Instantiate the client
const { decrypt } = buildClient( CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT )
// Create a keyring with the same KMS key used to encrypt
const generatorKeyId = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
const keyring = new KmsKeyringBrowser({ generatorKeyId })
// Decrypt the encrypted message
const { plaintext, messageHeader } = await decrypt(keyring, ciphertextMessage)
```
------
#### [ JavaScript Node.js ]
Untuk menentukan rangkaian algoritma alternatif, gunakan `suiteId` parameter dengan nilai `AlgorithmSuiteIdentifier` enum.
```
// Specify an algorithm suite without signing
// Instantiate the client
const { encrypt } = buildClient( CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT )
// Specify a KMS key
const generatorKeyId = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
// Create a keyring with the KMS key
const keyring = new KmsKeyringNode({ generatorKeyId })
// Encrypt your plaintext data
const { result } = await encrypt(keyring, cleartext, { suiteId: AlgorithmSuiteIdentifier.ALG_AES256_GCM_IV12_TAG16_HKDF_SHA512_COMMIT_KEY, encryptionContext: context, })
```
Saat mendekripsi data yang dienkripsi tanpa tanda tangan digital, gunakan Stream. decryptUnsignedMessage Metode ini gagal jika menemukan ciphertext yang ditandatangani.
```
// Decrypt unsigned streaming data
// Instantiate the client
const { decryptUnsignedMessageStream } = buildClient( CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT )
// Create a keyring with the same KMS key used to encrypt
const generatorKeyId = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
const keyring = new KmsKeyringNode({ generatorKeyId })
// Decrypt the encrypted message
const outputStream = createReadStream(filename) .pipe(decryptUnsignedMessageStream(keyring))
```
------
#### [ Python ]
Untuk menentukan algoritma enkripsi alternatif, gunakan `algorithm` parameter dengan nilai `Algorithm` enum.
```
# Specify an algorithm suite without signing
# Instantiate a client
client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT,
max_encrypted_data_keys=1)
# 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 the plaintext using an alternate algorithm suite
ciphertext, encrypted_message_header = client.encrypt(
algorithm=Algorithm.AES_256_GCM_HKDF_SHA512_COMMIT_KEY, source=source_plaintext, key_provider=kms_key_provider
)
```
Saat mendekripsi pesan yang dienkripsi tanpa tanda tangan digital, gunakan mode `decrypt-unsigned` streaming, terutama saat mendekripsi saat streaming.
```
# Decrypt unsigned streaming data
# Instantiate the client
client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT,
max_encrypted_data_keys=1)
# 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]
)
# Decrypt with decrypt-unsigned
with open(ciphertext_filename, "rb") as ciphertext, open(cycled_plaintext_filename, "wb") as plaintext:
with client.stream(mode="decrypt-unsigned",
source=ciphertext,
key_provider=master_key_provider) as decryptor:
for chunk in decryptor:
plaintext.write(chunk)
# Verify that the encryption context
assert all(
pair in decryptor.header.encryption_context.items() for pair in encryptor.header.encryption_context.items()
)
return ciphertext_filename, cycled_plaintext_filename
```
------
#### [ Rust ]
Untuk menentukan rangkaian algoritme alternatif di AWS Encryption SDK for Rust, tentukan `algorithm_suite_id` properti dalam permintaan enkripsi Anda.
```
// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Define the key namespace and key name
let key_namespace: &str = "HSM_01";
let key_name: &str = "AES_256_012";
// Optional: Create an 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 Raw AES keyring
let raw_aes_keyring = mpl
.create_raw_aes_keyring()
.key_name(key_name)
.key_namespace(key_namespace)
.wrapping_key(aws_smithy_types::Blob::new(AESWrappingKey))
.wrapping_alg(AesWrappingAlg::AlgAes256GcmIv12Tag16)
.send()
.await?;
// Encrypt your plaintext data
let plaintext = example_data.as_bytes();
let encryption_response = esdk_client.encrypt()
.plaintext(plaintext)
.keyring(raw_aes_keyring.clone())
.encryption_context(encryption_context.clone())
.algorithm_suite_id(AlgAes256GcmHkdfSha512CommitKey)
.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"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Define the key namespace and key name
var keyNamespace = "HSM_01"
var keyName = "AES_256_012"
// 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 Raw AES keyring
aesKeyRingInput := mpltypes.CreateRawAesKeyringInput{
KeyName: keyName,
KeyNamespace: keyNamespace,
WrappingKey: key,
WrappingAlg: mpltypes.AesWrappingAlgAlgAes256GcmIv12Tag16,
}
aesKeyring, err := matProv.CreateRawAesKeyring(context.Background(), aesKeyRingInput)
if err != nil {
panic(err)
}
// Encrypt your plaintext data
algorithmSuiteId := mpltypes.ESDKAlgorithmSuiteIdAlgAes256GcmHkdfSha512CommitKey
res, err := encryptionClient.Encrypt(context.Background(), esdktypes.EncryptInput{
Plaintext: []byte(exampleText),
EncryptionContext: encryptionContext,
Keyring: aesKeyring,
AlgorithmSuiteId: &algorithmSuiteId,
})
if err != nil {
panic(err)
}
```
------
## Membatasi kunci data terenkripsi
Anda dapat membatasi jumlah kunci data terenkripsi dalam pesan terenkripsi. Fitur praktik terbaik ini dapat membantu Anda mendeteksi keyring yang salah konfigurasi saat mengenkripsi atau ciphertext berbahaya saat mendekripsi. Ini juga mencegah panggilan yang tidak perlu, mahal, dan berpotensi lengkap ke infrastruktur utama Anda. Membatasi kunci data terenkripsi paling berharga saat Anda mendekripsi pesan dari sumber yang tidak tepercaya.
Meskipun sebagian besar pesan terenkripsi memiliki satu kunci data terenkripsi untuk setiap kunci pembungkus yang digunakan dalam enkripsi, pesan terenkripsi dapat berisi hingga 65.535 kunci data terenkripsi. Aktor jahat mungkin membuat pesan terenkripsi dengan ribuan kunci data terenkripsi, tidak ada yang dapat didekripsi. Akibatnya, AWS Encryption SDK akan mencoba untuk mendekripsi setiap kunci data terenkripsi sampai habis kunci data terenkripsi dalam pesan.
Untuk membatasi kunci data terenkripsi, gunakan parameter. `MaxEncryptedDataKeys` Parameter ini tersedia untuk semua bahasa pemrograman yang didukung mulai versi 1.9. *x* dan 2.2. *x* dari AWS Encryption SDK. Ini opsional dan valid saat mengenkripsi dan mendekripsi. Contoh berikut mendekripsi data yang dienkripsi di bawah tiga kunci pembungkus yang berbeda. `MaxEncryptedDataKeys`Nilai diatur ke 3.
------
#### [ C ]
```
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
/* Construct an AWS KMS keyring */
struct aws_cryptosdk_keyring *kms_keyring =
Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn1, { key_arn2, key_arn3 });
/* Create a session */
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(alloc, AWS_CRYPTOSDK_DECRYPT, kms_keyring);
aws_cryptosdk_keyring_release(kms_keyring);
/* Limit encrypted data keys */
aws_cryptosdk_session_set_max_encrypted_data_keys(session, 3);
/* Decrypt */
size_t ciphertext_consumed_output;
aws_cryptosdk_session_process(session,
plaintext_output,
plaintext_buf_sz_output,
&plaintext_len_output,
ciphertext_input,
ciphertext_len_input,
&ciphertext_consumed_output);
assert(aws_cryptosdk_session_is_done(session));
assert(ciphertext_consumed == ciphertext_len);
```
------
#### [ C\$1 / .NET ]
Untuk membatasi kunci data terenkripsi di AWS Encryption SDK for .NET, buat instance klien untuk.NET dan atur `MaxEncryptedDataKeys` parameter opsionalnya ke nilai yang diinginkan. AWS Encryption SDK Kemudian, panggil `Decrypt()` metode pada AWS Encryption SDK instance yang dikonfigurasi.
```
// Decrypt with limited data keys
// Instantiate the material providers
var materialProviders =
AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();
// Configure the commitment policy on the AWS Encryption SDK instance
var config = new AwsEncryptionSdkConfig
{
MaxEncryptedDataKeys = 3
};
var encryptionSdk = AwsEncryptionSdkFactory.CreateAwsEncryptionSdk(config);
// Create the keyring
string keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
var createKeyringInput = new CreateAwsKmsKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(),
KmsKeyId = keyArn
};
var decryptKeyring = materialProviders.CreateAwsKmsKeyring(createKeyringInput);
// Decrypt the ciphertext
var decryptInput = new DecryptInput
{
Ciphertext = ciphertext,
Keyring = decryptKeyring
};
var decryptOutput = encryptionSdk.Decrypt(decryptInput);
```
------
#### [ AWS Encryption CLI ]
```
# Decrypt with limited encrypted data keys
$ aws-encryption-cli --decrypt \
--input hello.txt.encrypted \
--wrapping-keys key=$key_arn1 key=$key_arn2 key=$key_arn3 \
--buffer \
--max-encrypted-data-keys 3 \
--encryption-context purpose=test \
--metadata-output ~/metadata \
--output .
```
------
#### [ Java ]
```
// Construct a client with limited encrypted data keys
final AwsCrypto crypto = AwsCrypto.builder()
.withMaxEncryptedDataKeys(3)
.build();
// Create an AWS KMS master key provider
final KmsMasterKeyProvider keyProvider = KmsMasterKeyProvider.builder()
.buildStrict(keyArn1, keyArn2, keyArn3);
// Decrypt
final CryptoResult decryptResult = crypto.decryptData(keyProvider, ciphertext)
```
------
#### [ JavaScript Browser ]
```
// Construct a client with limited encrypted data keys
const { encrypt, decrypt } = buildClient({ maxEncryptedDataKeys: 3 })
declare const credentials: {
accessKeyId: string
secretAccessKey: string
sessionToken: string
}
const clientProvider = getClient(KMS, {
credentials: { accessKeyId, secretAccessKey, sessionToken }
})
// Create an AWS KMS keyring
const keyring = new KmsKeyringBrowser({
clientProvider,
keyIds: [keyArn1, keyArn2, keyArn3],
})
// Decrypt
const { plaintext, messageHeader } = await decrypt(keyring, ciphertext)
```
------
#### [ JavaScript Node.js ]
```
// Construct a client with limited encrypted data keys
const { encrypt, decrypt } = buildClient({ maxEncryptedDataKeys: 3 })
// Create an AWS KMS keyring
const keyring = new KmsKeyringBrowser({
keyIds: [keyArn1, keyArn2, keyArn3],
})
// Decrypt
const { plaintext, messageHeader } = await decrypt(keyring, ciphertext)
```
------
#### [ Python ]
```
# Instantiate a client with limited encrypted data keys
client = aws_encryption_sdk.EncryptionSDKClient(max_encrypted_data_keys=3)
# Create an AWS KMS master key provider
master_key_provider = aws_encryption_sdk.StrictAwsKmsMasterKeyProvider(
key_ids=[key_arn1, key_arn2, key_arn3])
# Decrypt
plaintext, header = client.decrypt(source=ciphertext, key_provider=master_key_provider)
```
------
#### [ Rust ]
```
// Instantiate the AWS Encryption SDK client with limited encrypted data keys
let esdk_config = AwsEncryptionSdkConfig::builder()
.max_encrypted_data_keys(max_encrypted_data_keys)
.build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Define the key namespace and key name
let key_namespace: &str = "HSM_01";
let key_name: &str = "AES_256_012";
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Generate `max_encrypted_data_keys` raw AES keyrings to use with your keyring
let mut raw_aes_keyrings: Vec = vec![];
assert!(max_encrypted_data_keys > 0, "max_encrypted_data_keys MUST be greater than 0");
let mut i = 0;
while i < max_encrypted_data_keys {
let aes_key_bytes = generate_aes_key_bytes();
let raw_aes_keyring = mpl
.create_raw_aes_keyring()
.key_name(key_name)
.key_namespace(key_namespace)
.wrapping_key(aes_key_bytes)
.wrapping_alg(AesWrappingAlg::AlgAes256GcmIv12Tag16)
.send()
.await?;
raw_aes_keyrings.push(raw_aes_keyring);
i += 1;
}
// Create a Multi Keyring with `max_encrypted_data_keys` AES Keyrings
let generator_keyring = raw_aes_keyrings.remove(0);
let multi_keyring = mpl
.create_multi_keyring()
.generator(generator_keyring)
.child_keyrings(raw_aes_keyrings)
.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"
)
// Instantiate the AWS Encryption SDK client with limited encrypted data keys
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{
MaxEncryptedDataKeys: &maxEncryptedDataKeys,
})
if err != nil {
panic(err)
}
// Define the key namespace and key name
var keyNamespace = "HSM_01"
var keyName = "RSA_2048_06"
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Generate `maxEncryptedDataKeys` raw AES keyrings to use with your keyring
rawAESKeyrings := make([]mpltypes.IKeyring, 0, maxEncryptedDataKeys)
var i int64 = 0
for i < maxEncryptedDataKeys {
key, err := generate256KeyBytesAES()
if err != nil {
panic(err)
}
aesKeyRingInput := mpltypes.CreateRawAesKeyringInput{
KeyName: keyName,
KeyNamespace: keyNamespace,
WrappingKey: key,
WrappingAlg: mpltypes.AesWrappingAlgAlgAes256GcmIv12Tag16,
}
aesKeyring, err := matProv.CreateRawAesKeyring(context.Background(), aesKeyRingInput)
if err != nil {
panic(err)
}
rawAESKeyrings = append(rawAESKeyrings, aesKeyring)
i++
}
// Create a Multi Keyring with `max_encrypted_data_keys` AES Keyrings
createMultiKeyringInput := mpltypes.CreateMultiKeyringInput{
Generator: rawAESKeyrings[0],
ChildKeyrings: rawAESKeyrings[1:],
}
multiKeyring, err := matProv.CreateMultiKeyring(context.Background(), createMultiKeyringInput)
if err != nil {
panic(err)
}
```
------
## Membuat filter penemuan
Saat mendekripsi data yang dienkripsi dengan kunci KMS, ini adalah praktik terbaik untuk mendekripsi dalam *mode ketat*, yaitu membatasi kunci pembungkus yang digunakan hanya untuk yang Anda tentukan. Namun, jika perlu, Anda juga dapat mendekripsi dalam *mode penemuan*, di mana Anda tidak menentukan kunci pembungkus apa pun. Dalam mode ini, AWS KMS dapat mendekripsi kunci data terenkripsi menggunakan kunci KMS yang mengenkripsi itu, terlepas dari siapa yang memiliki atau memiliki akses ke kunci KMS itu.
[Jika Anda harus mendekripsi dalam mode penemuan, kami sarankan Anda selalu menggunakan *filter penemuan*, yang membatasi kunci KMS yang dapat digunakan untuk yang ada di partisi dan yang ditentukan Akun AWS .](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) Filter penemuan adalah opsional, tetapi ini adalah praktik terbaik.
Gunakan tabel berikut untuk menentukan nilai partisi untuk filter penemuan Anda.
| Region | Partition |
| --- | --- |
| Wilayah AWS | aws |
| Wilayah Tiongkok | aws-cn |
| AWS GovCloud (US) Regions | aws-us-gov |
Contoh di bagian ini menunjukkan cara membuat filter penemuan. Sebelum menggunakan kode, ganti nilai contoh dengan nilai yang valid untuk partisi Akun AWS dan.
------
#### [ C ]
Untuk contoh lengkap, lihat [kms\$1discovery.cpp di file](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/kms_discovery.cpp) AWS Encryption SDK for C.
```
/* Create a discovery filter for an AWS account and partition */
const char *account_id = "111122223333";
const char *partition = "aws";
const std::shared_ptr discovery_filter =
Aws::Cryptosdk::KmsKeyring::DiscoveryFilter::Builder(partition).AddAccount(account_id).Build();
```
------
#### [ C\$1 / .NET ]
Untuk contoh lengkapnya, lihat [DiscoveryFilterExample.cs](https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/Examples/DiscoveryFilterExample.cs) di AWS Encryption SDK for .NET.
```
// Create a discovery filter for an AWS account and partition
List account = new List { "111122223333" };
DiscoveryFilter exampleDiscoveryFilter = new DiscoveryFilter()
{
AccountIds = account,
Partition = "aws"
}
```
------
#### [ AWS Encryption CLI ]
```
# Decrypt in discovery mode with a discovery filter
$ aws-encryption-cli --decrypt \
--input hello.txt.encrypted \
--wrapping-keys discovery=true \
discovery-account=111122223333 \
discovery-partition=aws \
--encryption-context purpose=test \
--metadata-output ~/metadata \
--max-encrypted-data-keys 1 \
--buffer \
--output .
```
------
#### [ Java ]
Untuk contoh lengkap, lihat [DiscoveryDecryptionExample.java](https://github.com/aws/aws-encryption-sdk-java/blob/master/src/examples/java/com/amazonaws/crypto/examples/v2/DiscoveryDecryptionExample.java) di file. AWS Encryption SDK for Java
```
// Create a discovery filter for an AWS account and partition
DiscoveryFilter discoveryFilter = new DiscoveryFilter("aws", 111122223333);
```
------
#### [ JavaScript (Node and Browser) ]
[Untuk contoh lengkap, lihat [kms\$1filtered\$1discovery.ts (Node.js) dan kms\$1multi\$1region\$1discovery.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-node/src/kms_filtered_discovery.ts) (Browser) di file.](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-browser/src/kms_multi_region_discovery.ts) AWS Encryption SDK for JavaScript
```
/* Create a discovery filter for an AWS account and partition */
const discoveryFilter = {
accountIDs: ['111122223333'],
partition: 'aws',
}
```
------
#### [ Python ]
Untuk contoh lengkap, lihat [discovery\$1kms\$1provider.py di file](https://github.com/aws/aws-encryption-sdk-python/blob/master/examples/src/legacy/discovery_kms_provider.py) AWS Encryption SDK for Python.
```
# Create the discovery filter and specify the region
decrypt_kwargs = dict(
discovery_filter=DiscoveryFilter(account_ids="111122223333", partition="aws"),
discovery_region="us-west-2",
)
```
------
#### [ Rust ]
```
let discovery_filter = DiscoveryFilter::builder()
.account_ids(vec![111122223333.to_string()])
.partition("aws".to_string())
.build()?;
```
------
#### [ Go ]
```
import (
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
)
discoveryFilter := mpltypes.DiscoveryFilter{
AccountIds: []string{111122223333},
Partition: "aws",
}
```
------
## Mengkonfigurasi konteks enkripsi yang diperlukan CMM
Anda dapat menggunakan konteks enkripsi CMM yang diperlukan untuk memerlukan [konteks enkripsi](concepts.md#encryption-context) dalam operasi kriptografi Anda. Konteks enkripsi adalah sekumpulan pasangan kunci-nilai non-rahasia. Konteks enkripsi terikat secara kriptografis ke data terenkripsi sehingga konteks enkripsi yang sama diperlukan untuk mendekripsi bidang. Bila Anda menggunakan konteks enkripsi CMM yang diperlukan, Anda dapat menentukan satu atau beberapa *kunci konteks enkripsi yang diperlukan (kunci* wajib) yang harus disertakan dalam semua panggilan enkripsi dan dekripsi.
**catatan**
Konteks enkripsi yang diperlukan CMM hanya didukung oleh versi berikut:
Versi 3. *x* dari AWS Encryption SDK for Java
Versi 4. *x* dan yang lebih baru AWS Encryption SDK untuk .NET
Versi 4. *x* dari AWS Encryption SDK for Python, bila digunakan dengan dependensi [Perpustakaan Penyedia Materi Kriptografi](https://github.com/aws/aws-cryptographic-material-providers-library) (MPL) opsional.
Versi 0.1. *x* atau yang lebih baru AWS Encryption SDK untuk Go
Jika Anda mengenkripsi data menggunakan konteks enkripsi CMM yang diperlukan, Anda hanya dapat mendekripsi dengan salah satu versi yang didukung ini.
Pada enkripsi, AWS Encryption SDK memverifikasi bahwa semua kunci konteks enkripsi yang diperlukan disertakan dalam konteks enkripsi yang Anda tentukan. AWS Encryption SDK Tanda konteks enkripsi yang Anda tentukan. Hanya pasangan kunci-nilai yang bukan kunci wajib yang diserialisasi dan disimpan dalam teks biasa di header pesan terenkripsi yang dikembalikan oleh operasi enkripsi.
Saat mendekripsi, Anda harus menyediakan konteks enkripsi yang berisi semua pasangan kunci-nilai yang mewakili kunci yang diperlukan. AWS Encryption SDK Menggunakan konteks enkripsi ini dan pasangan kunci-nilai yang disimpan dalam header pesan terenkripsi untuk merekonstruksi konteks enkripsi asli yang Anda tentukan dalam operasi enkripsi. Jika AWS Encryption SDK tidak dapat merekonstruksi konteks enkripsi asli, maka operasi dekripsi gagal. Jika Anda memberikan pasangan kunci-nilai yang berisi kunci yang diperlukan dengan nilai yang salah, pesan terenkripsi tidak dapat didekripsi. Anda harus memberikan pasangan nilai kunci yang sama yang ditentukan pada enkripsi.
**penting**
Pertimbangkan dengan cermat nilai mana yang Anda pilih untuk kunci yang diperlukan dalam konteks enkripsi Anda. Anda harus dapat memberikan kunci yang sama dan nilai yang sesuai lagi pada dekripsi. Jika Anda tidak dapat mereproduksi kunci yang diperlukan, pesan terenkripsi tidak dapat didekripsi.
Contoh berikut menginisialisasi AWS KMS keyring dengan konteks enkripsi CMM yang diperlukan.
------
#### [ C\$1 / .NET ]
```
var encryptionContext = new Dictionary()
{
{"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 AWS Encryption SDK and material providers
var esdk = new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
// Instantiate the keyring input object
var createKeyringInput = new CreateAwsKmsKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(),
KmsKeyId = kmsKey
};
// Create the keyring
var kmsKeyring = mpl.CreateAwsKmsKeyring(createKeyringInput);
var createCMMInput = new CreateRequiredEncryptionContextCMMInput
{
UnderlyingCMM = mpl.CreateDefaultCryptographicMaterialsManager(new CreateDefaultCryptographicMaterialsManagerInput{Keyring = kmsKeyring}),
// If you pass in a keyring but no underlying cmm, it will result in a failure because only cmm is supported.
RequiredEncryptionContextKeys = new List(encryptionContext.Keys)
};
// Create the required encryption context CMM
var requiredEcCMM = mpl.CreateRequiredEncryptionContextCMM(createCMMInput);
```
------
#### [ Java ]
```
// Instantiate the AWS Encryption SDK
final AwsCrypto crypto = AwsCrypto.builder()
.withCommitmentPolicy(CommitmentPolicy.RequireEncryptRequireDecrypt)
.build();
// Create your encryption context
final Map encryptionContext = new HashMap<>();
encryptionContext.put("encryption", "context");
encryptionContext.put("is not", "secret");
encryptionContext.put("but adds", "useful metadata");
encryptionContext.put("that can help you", "be confident that");
encryptionContext.put("the data you are handling", "is what you think it is");
// Create a list of required encryption contexts
final List requiredEncryptionContextKeys = Arrays.asList("encryption", "context");
// Create the keyring
final MaterialProviders materialProviders = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsKeyringInput keyringInput = CreateAwsKmsKeyringInput.builder()
.kmsKeyId(keyArn)
.kmsClient(KmsClient.create())
.build();
IKeyring kmsKeyring = materialProviders.CreateAwsKmsKeyring(keyringInput);
// Create the required encryption context CMM
ICryptographicMaterialsManager cmm =
materialProviders.CreateDefaultCryptographicMaterialsManager(
CreateDefaultCryptographicMaterialsManagerInput.builder()
.keyring(kmsKeyring)
.build()
);
ICryptographicMaterialsManager requiredCMM =
materialProviders.CreateRequiredEncryptionContextCMM(
CreateRequiredEncryptionContextCMMInput.builder()
.requiredEncryptionContextKeys(requiredEncryptionContextKeys)
.underlyingCMM(cmm)
.build()
);
```
------
#### [ Python ]
Untuk menggunakan CMM konteks enkripsi yang diperlukan, Anda juga harus menggunakan pustaka penyedia materi (MPL). AWS Encryption SDK for Python
```
# Instantiate the AWS Encryption SDK client
client = aws_encryption_sdk.EncryptionSDKClient(
commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
# Create your encryption context
encryption_context: Dict[str, str] = {
"key1": "value1",
"key2": "value2",
"requiredKey1": "requiredValue1",
"requiredKey2": "requiredValue2"
}
# Create a list of required encryption context keys
required_encryption_context_keys: List[str] = ["requiredKey1", "requiredKey2"]
# Instantiate the material providers library
mpl: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Create the AWS KMS keyring
keyring_input: CreateAwsKmsKeyringInput = CreateAwsKmsKeyringInput(
kms_key_id=kms_key_id,
kms_client=boto3.client('kms', region_name="us-west-2")
)
kms_keyring: IKeyring = mpl.create_aws_kms_keyring(keyring_input)
# Create the required encryption context CMM
underlying_cmm: ICryptographicMaterialsManager = \
mpl.create_default_cryptographic_materials_manager(
CreateDefaultCryptographicMaterialsManagerInput(
keyring=kms_keyring
)
)
required_ec_cmm: ICryptographicMaterialsManager = \
mpl.create_required_encryption_context_cmm(
CreateRequiredEncryptionContextCMMInput(
required_encryption_context_keys=required_encryption_context_keys,
underlying_cmm=underlying_cmm,
)
)
```
------
#### [ Rust ]
```
// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().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([
("key1".to_string(), "value1".to_string()),
("key2".to_string(), "value2".to_string()),
("requiredKey1".to_string(), "requiredValue1".to_string()),
("requiredKey2".to_string(), "requiredValue2".to_string()),
]);
// Create a list of required encryption context keys
let required_encryption_context_keys: Vec = vec![
"requiredKey1".to_string(),
"requiredKey2".to_string(),
];
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create the AWS KMS keyring
let kms_keyring = mpl
.create_aws_kms_keyring()
.kms_key_id(kms_key_id)
.kms_client(kms_client)
.send()
.await?;
kms_multi_keyring: IKeyring = mat_prov.create_aws_kms_multi_keyring(
input=kms_multi_keyring_input
)
// Create the required encryption context CMM
let underlying_cmm = mpl
.create_default_cryptographic_materials_manager()
.keyring(kms_keyring)
.send()
.await?;
let required_ec_cmm = mpl
.create_required_encryption_context_cmm()
.underlying_cmm(underlying_cmm.clone())
.required_encryption_context_keys(required_encryption_context_keys)
.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
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
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 = defaultKmsKeyRegion
})
// 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",
}
// Create a list of required encryption context keys
requiredEncryptionContextKeys := []string{}
requiredEncryptionContextKeys = append(requiredEncryptionContextKeys, "requiredKey1", "requiredKey2")
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create the AWS KMS keyring
awsKmsKeyringInput := mpltypes.CreateAwsKmsKeyringInput{
KmsClient: kmsClient,
KmsKeyId: utils.GetDefaultKMSKeyId(),
}
awsKmsKeyring, err := matProv.CreateAwsKmsKeyring(context.Background(), awsKmsKeyringInput)
if err != nil {
panic(err)
}
// Create the required encryption context CMM
underlyingCMM, err := matProv.CreateDefaultCryptographicMaterialsManager(context.Background(), mpltypes.CreateDefaultCryptographicMaterialsManagerInput{Keyring: awsKmsKeyring})
if err != nil {
panic(err)
}
requiredEncryptionContextInput := mpltypes.CreateRequiredEncryptionContextCMMInput{
UnderlyingCMM: underlyingCMM,
RequiredEncryptionContextKeys: requiredEncryptionContextKeys,
}
requiredEC, err := matProv.CreateRequiredEncryptionContextCMM(context.Background(), requiredEncryptionContextInput)
if err != nil {
panic(err)
}
```
------
## Menetapkan kebijakan komitmen
[*Kebijakan komitmen*](concepts.md#commitment-policy) [adalah pengaturan konfigurasi yang menentukan apakah aplikasi Anda mengenkripsi dan mendekripsi dengan komitmen utama.](concepts.md#key-commitment) [Mengenkripsi dan mendekripsi dengan komitmen utama adalah praktik terbaik.AWS Encryption SDK](best-practices.md)
Menyetel dan menyesuaikan kebijakan komitmen Anda adalah langkah penting dalam [bermigrasi](migration.md) dari versi 1.7. *x* dan sebelumnya AWS Encryption SDK ke versi 2.0. *x* dan kemudian. Perkembangan ini dijelaskan secara rinci dalam [topik migrasi](migrate-commitment-policy.md).
Nilai kebijakan komitmen default di versi terbaru AWS Encryption SDK (dimulai pada versi 2.0. *x*),`RequireEncryptRequireDecrypt`, sangat ideal untuk sebagian besar situasi. Namun, jika Anda perlu mendekripsi ciphertext yang dienkripsi tanpa komitmen utama, Anda mungkin perlu mengubah kebijakan komitmen Anda. `RequireEncryptAllowDecrypt` Untuk contoh cara menetapkan kebijakan komitmen dalam setiap bahasa pemrograman, lihat[Menetapkan kebijakan komitmen Anda](migrate-commitment-policy.md).
## Bekerja dengan data streaming
Saat Anda mengalirkan data untuk dekripsi, ketahuilah bahwa teks biasa yang didekripsi AWS Encryption SDK kembali setelah pemeriksaan integritas selesai, tetapi sebelum tanda tangan digital diverifikasi. Untuk memastikan bahwa Anda tidak mengembalikan atau menggunakan plaintext sampai tanda tangan diverifikasi, kami sarankan Anda menyangga plaintext yang dialirkan hingga seluruh proses dekripsi selesai.
[Masalah ini muncul hanya ketika Anda melakukan streaming ciphertext untuk dekripsi, dan hanya ketika Anda menggunakan rangkaian algoritme, seperti rangkaian algoritme [default, yang menyertakan tanda tangan](supported-algorithms.md) digital.](concepts.md#digital-sigs)
Untuk mempermudah buffering, beberapa implementasi AWS Encryption SDK bahasa, seperti AWS Encryption SDK for JavaScript di Node.js, menyertakan fitur buffering sebagai bagian dari metode dekripsi. AWS Encryption CLI, yang selalu mengalirkan input dan output memperkenalkan `--buffer` parameter dalam versi 1.9. *x* dan 2.2. *x*. Dalam implementasi bahasa lain, Anda dapat menggunakan fitur buffering yang ada. ( AWS Encryption SDK Untuk .NET tidak mendukung streaming.)
Jika Anda menggunakan rangkaian algoritme tanpa tanda tangan digital, pastikan untuk menggunakan `decrypt-unsigned` fitur ini di setiap implementasi bahasa. Fitur ini mendekripsi ciphertext tetapi gagal jika menemukan ciphertext yang ditandatangani. Lihat perinciannya di [Memilih rangkaian algoritme](#config-algorithm).
## Menyembunyikan kunci data
Secara umum, menggunakan kembali kunci data tidak disarankan, tetapi AWS Encryption SDK menawarkan opsi [caching kunci data](data-key-caching.md) yang menyediakan penggunaan kembali kunci data secara terbatas. Caching kunci data dapat meningkatkan kinerja beberapa aplikasi dan mengurangi panggilan ke infrastruktur utama Anda. Sebelum menggunakan caching kunci data dalam produksi, sesuaikan [ambang keamanan](thresholds.md), dan uji untuk memastikan bahwa manfaatnya lebih besar daripada kerugian menggunakan kembali kunci data.