Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# AWS Encryption SDK for C
AWS Encryption SDK for C Ini menyediakan pustaka enkripsi sisi klien untuk pengembang yang menulis aplikasi di C. Ini juga berfungsi sebagai dasar untuk implementasi AWS Encryption SDK dalam bahasa pemrograman tingkat tinggi.
Seperti semua implementasi AWS Encryption SDK, AWS Encryption SDK for C menawarkan fitur perlindungan data tingkat lanjut. Ini termasuk [enkripsi amplop](concepts.md#envelope-encryption), data otentikasi tambahan (AAD), dan [rangkaian algoritma](concepts.md#crypto-algorithm) kunci simetris yang aman, diautentikasi, seperti AES-GCM 256-bit dengan derivasi dan penandatanganan kunci.
Semua implementasi khusus bahasa sepenuhnya dapat AWS Encryption SDK dioperasikan. [Misalnya, Anda dapat mengenkripsi data dengan AWS Encryption SDK for C dan mendekripsi dengan [implementasi bahasa yang didukung](programming-languages.md), termasuk CLI Enkripsi AWS .](crypto-cli.md)
AWS Encryption SDK for C Membutuhkan AWS SDK untuk C\$1\$1 untuk berinteraksi dengan AWS Key Management Service (AWS KMS). Anda perlu menggunakannya hanya jika Anda menggunakan [AWS KMS keyring](use-kms-keyring.md) opsional. Namun, AWS Encryption SDK tidak memerlukan AWS KMS atau AWS layanan lainnya.
**Pelajari Lebih Lanjut**
+ Untuk detail tentang pemrograman dengan AWS Encryption SDK for C, lihat [contoh C](c-examples.md), [contoh](https://github.com/aws/aws-encryption-sdk-c/tree/master/examples) di [aws-encryption-sdk-c repositori aktif](https://github.com/aws/aws-encryption-sdk-c/) GitHub, dan dokumentasi [AWS Encryption SDK for C API](https://aws.github.io/aws-encryption-sdk-c/html/).
+ Untuk diskusi tentang cara menggunakan data AWS Encryption SDK for C untuk mengenkripsi sehingga Anda dapat mendekripsi dalam beberapa Wilayah AWS, lihat [Cara mendekripsi ciphertext di beberapa wilayah dengan di C di](https://aws.amazon.com/blogs/security/how-to-decrypt-ciphertexts-multiple-regions-aws-encryption-sdk-in-c/) Blog Keamanan. AWS Encryption SDK AWS
**Topics**
+ [Menginstal](c-language-installation.md)
+ [Menggunakan C SDK](c-language-using.md)
+ [Contoh](c-examples.md)
# Instalasi AWS Encryption SDK for C
Instal versi terbaru dari file AWS Encryption SDK for C.
**catatan**
[Semua versi yang AWS Encryption SDK for C lebih awal dari 2.0.0 sedang dalam fase. end-of-support](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle)
Anda dapat memperbarui dengan aman dari versi 2.0. *x* dan yang lebih baru ke versi terbaru AWS Encryption SDK for C tanpa kode atau perubahan data apa pun. Namun, [fitur keamanan baru](about-versions.md#version-2) diperkenalkan di versi 2.0. *x* tidak kompatibel ke belakang. Untuk memperbarui dari versi lebih awal dari 1.7. *x* ke versi 2.0. *x* dan yang lebih baru, Anda harus terlebih dahulu memperbarui ke yang terbaru 1. *x* versi AWS Encryption SDK for C. Lihat perinciannya di [Migrasi Anda AWS Encryption SDK](migration.md).
Anda dapat menemukan petunjuk terperinci untuk menginstal dan membangun [file README](https://github.com/aws/aws-encryption-sdk-c/#readme) dari [aws-encryption-sdk-c](https://github.com/aws/aws-encryption-sdk-c/)repositori. AWS Encryption SDK for C Ini termasuk instruksi untuk membangun di Amazon Linux, Ubuntu, macOS, dan platform Windows.
Sebelum Anda mulai, putuskan apakah Anda ingin menggunakan [AWS KMS gantungan kunci](use-kms-keyring.md) di. AWS Encryption SDK Jika Anda menggunakan AWS KMS keyring, Anda perlu menginstal. AWS SDK untuk C\$1\$1 AWS SDK diperlukan untuk berinteraksi dengan [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS). Ketika Anda menggunakan AWS KMS keyrings, AWS Encryption SDK digunakan AWS KMS untuk menghasilkan dan melindungi kunci enkripsi yang melindungi data Anda.
Anda tidak perlu menginstal AWS SDK untuk C\$1\$1 jika Anda menggunakan jenis keyring lain, seperti keyring AES mentah, keyring RSA mentah, atau multi-keyring yang tidak menyertakan keyring. AWS KMS Namun, saat menggunakan tipe keyring mentah, Anda perlu membuat dan melindungi kunci pembungkus mentah Anda sendiri.
Jika Anda mengalami masalah dengan instalasi Anda, [ajukan masalah](https://github.com/aws/aws-encryption-sdk-c/issues) di `aws-encryption-sdk-c` repositori atau gunakan tautan umpan balik apa pun di halaman ini.
# Menggunakan AWS Encryption SDK for C
Topik ini menjelaskan beberapa fitur yang tidak didukung dalam implementasi bahasa pemrograman lainnya. AWS Encryption SDK for C
Contoh di bagian ini menunjukkan cara menggunakan [versi 2.0. ](about-versions.md)*x* dan yang lebih baru AWS Encryption SDK for C. Untuk contoh yang menggunakan versi sebelumnya, temukan rilis Anda di daftar [Rilis](https://github.com/aws/aws-encryption-sdk-c/releases) dari [aws-encryption-sdk-c repositori repositori](https://github.com/aws/aws-encryption-sdk-c/) di. GitHub
Untuk detail tentang pemrograman dengan AWS Encryption SDK for C, lihat [contoh C](c-examples.md), [contoh](https://github.com/aws/aws-encryption-sdk-c/tree/master/examples) di [aws-encryption-sdk-c repositori aktif](https://github.com/aws/aws-encryption-sdk-c/) GitHub, dan dokumentasi [AWS Encryption SDK for C API](https://aws.github.io/aws-encryption-sdk-c/html/).
Lihat juga: [Gantungan kunci](choose-keyring.md)
**Topics**
+ [Pola untuk mengenkripsi dan mendekripsi data](#c-language-using-pattern)
+ [Penghitungan referensi](#c-language-using-release)
## Pola untuk mengenkripsi dan mendekripsi data
Bila Anda menggunakan AWS Encryption SDK for C, Anda mengikuti pola yang mirip dengan ini: membuat [keyring](concepts.md#keyring), membuat [CMM](concepts.md#crypt-materials-manager) yang menggunakan keyring, membuat sesi yang menggunakan CMM (dan keyring), dan kemudian memproses sesi.
1. Memuat string kesalahan.
Panggil `aws_cryptosdk_load_error_strings()` metode dalam kode C atau C \$1\$1 Anda. Ini memuat informasi kesalahan yang sangat berguna untuk debugging.
Anda hanya perlu memanggilnya sekali, seperti dalam `main` metode Anda.
```
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
```
2. Buat keyring.
Konfigurasikan [keyring](concepts.md#keyring) Anda dengan tombol pembungkus yang ingin Anda gunakan untuk mengenkripsi kunci data Anda. Contoh ini menggunakan [AWS KMS keyring](use-kms-keyring.md) dengan satu AWS KMS key, tetapi Anda dapat menggunakan semua jenis keyring sebagai gantinya.
Untuk mengidentifikasi AWS KMS key dalam keyring enkripsi di AWS Encryption SDK for C, tentukan [kunci ARN atau [alias](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn) ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN). Dalam keyring dekripsi, Anda harus menggunakan kunci ARN. Lihat perinciannya di [Mengidentifikasi AWS KMS keys dalam AWS KMS keyring](use-kms-keyring.md#kms-keyring-id).
```
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);
```
3. Buat sesi.
Dalam AWS Encryption SDK for C, Anda menggunakan *sesi* untuk mengenkripsi pesan teks biasa tunggal atau mendekripsi pesan ciphertext tunggal, terlepas dari ukurannya. Sesi mempertahankan status pesan selama pemrosesannya.
Konfigurasikan sesi Anda dengan pengalokasi, keyring, dan mode: atau. `AWS_CRYPTOSDK_ENCRYPT` `AWS_CRYPTOSDK_DECRYPT` Jika Anda perlu mengubah mode sesi, gunakan `aws_cryptosdk_session_reset` metode ini.
Saat Anda membuat sesi dengan keyring, AWS Encryption SDK for C secara otomatis membuat manajer materi kriptografi default (CMM) untuk Anda. Anda tidak perlu membuat, memelihara, atau menghancurkan objek ini.
Misalnya, sesi berikut menggunakan pengalokasi dan keyring yang didefinisikan pada langkah 1. Saat Anda mengenkripsi data, modenya adalah`AWS_CRYPTOSDK_ENCRYPT`.
```
struct aws_cryptosdk_session * session = aws_cryptosdk_session_new_from_keyring_2(allocator, AWS_CRYPTOSDK_ENCRYPT, kms_keyring);
```
4. Enkripsi atau dekripsi data.
Untuk memproses data dalam sesi, gunakan `aws_cryptosdk_session_process` metode ini. Jika buffer input cukup besar untuk menampung seluruh plaintext, dan buffer output cukup besar untuk menampung seluruh ciphertext, Anda dapat menelepon. `aws_cryptosdk_session_process_full` Namun, jika Anda perlu menangani data streaming, Anda dapat menelepon `aws_cryptosdk_session_process` dalam satu lingkaran. Sebagai contoh, lihat contoh [file\$1streaming.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/file_streaming.cpp). `aws_cryptosdk_session_process_full`Ini diperkenalkan dalam AWS Encryption SDK versi 1.9. *x* dan 2.2. *x*.
Ketika sesi dikonfigurasi untuk mengenkripsi data, bidang plaintext menjelaskan input dan bidang ciphertext menggambarkan output. `plaintext`Bidang menyimpan pesan yang ingin Anda enkripsi dan `ciphertext` bidang mendapatkan [pesan terenkripsi](message-format.md) yang dikembalikan oleh metode enkripsi.
```
/* Encrypting data */
aws_cryptosdk_session_process_full(session,
ciphertext,
ciphertext_buffer_size,
&ciphertext_length,
plaintext,
plaintext_length)
```
Ketika sesi dikonfigurasi untuk mendekripsi data, bidang ciphertext menjelaskan input dan bidang plaintext menggambarkan output. `ciphertext`Bidang menyimpan [pesan terenkripsi](message-format.md) yang dikembalikan oleh metode enkripsi, dan `plaintext` bidang mendapatkan pesan teks biasa yang dikembalikan oleh metode dekripsi.
Untuk mendekripsi data, panggil metode. `aws_cryptosdk_session_process_full`
```
/* Decrypting data */
aws_cryptosdk_session_process_full(session,
plaintext,
plaintext_buffer_size,
&plaintext_length,
ciphertext,
ciphertext_length)
```
## Penghitungan referensi
Untuk mencegah kebocoran memori, pastikan untuk melepaskan referensi Anda ke semua objek yang Anda buat saat Anda selesai menggunakannya. Jika tidak, Anda akan berakhir dengan kebocoran memori. SDK menyediakan metode untuk mempermudah tugas ini.
Setiap kali Anda membuat objek induk dengan salah satu objek anak berikut, objek induk mendapatkan dan mempertahankan referensi ke objek anak, sebagai berikut:
+ Sebuah [keyring](concepts.md#keyring), seperti membuat sesi dengan keyring
+ [Manajer materi kriptografi](concepts.md#crypt-materials-manager) default (CMM), seperti membuat sesi atau CMM khusus dengan CMM default
+ [Cache kunci data](data-key-caching.md), seperti membuat CMM caching dengan keyring dan cache
Kecuali Anda memerlukan referensi independen ke objek anak, Anda dapat melepaskan referensi Anda ke objek anak segera setelah Anda membuat objek induk. Referensi yang tersisa untuk objek anak dilepaskan ketika objek induk dihancurkan. Pola ini memastikan bahwa Anda mempertahankan referensi ke setiap objek hanya selama Anda membutuhkannya, dan Anda tidak membocorkan memori karena referensi yang belum dirilis.
Anda hanya bertanggung jawab untuk merilis referensi ke objek anak yang Anda buat secara eksplisit. Anda tidak bertanggung jawab untuk mengelola referensi ke objek apa pun yang dibuat SDK untuk Anda. Jika SDK membuat objek, seperti CMM default yang ditambahkan `aws_cryptosdk_caching_cmm_new_from_keyring` metode ke sesi, SDK mengelola pembuatan dan penghancuran objek dan referensinya.
Dalam contoh berikut, ketika Anda membuat sesi dengan [keyring](concepts.md#keyring), sesi mendapatkan referensi ke keyring, dan mempertahankan referensi itu sampai sesi dihancurkan. Jika Anda tidak perlu mempertahankan referensi tambahan ke keyring, Anda dapat menggunakan `aws_cryptosdk_keyring_release` metode untuk melepaskan objek keyring segera setelah sesi dibuat. Metode ini mengurangi jumlah referensi untuk keyring. Referensi sesi ke keyring dilepaskan saat Anda menelepon `aws_cryptosdk_session_destroy` untuk menghancurkan sesi.
```
// The session gets a reference to the keyring.
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(alloc, AWS_CRYPTOSDK_ENCRYPT, keyring);
// After you create a session with a keyring, release the reference to the keyring object.
aws_cryptosdk_keyring_release(keyring);
```
Untuk tugas yang lebih kompleks, seperti menggunakan kembali keyring untuk beberapa sesi atau menentukan rangkaian algoritme dalam CMM, Anda mungkin perlu mempertahankan referensi independen ke objek. Jika demikian, jangan segera panggil metode rilis. Sebagai gantinya, lepaskan referensi Anda saat Anda tidak lagi menggunakan objek, selain menghancurkan sesi.
Teknik penghitungan referensi ini juga berfungsi ketika Anda menggunakan alternatif CMMs, seperti CMM caching untuk caching [kunci data](data-key-caching.md). Saat Anda membuat CMM caching dari cache dan keyring, CMM caching mendapatkan referensi ke kedua objek. Kecuali Anda membutuhkannya untuk tugas lain, Anda dapat melepaskan referensi independen Anda ke cache dan keyring segera setelah CMM caching dibuat. Kemudian, ketika Anda membuat sesi dengan CMM caching, Anda dapat melepaskan referensi Anda ke CMM caching.
Perhatikan bahwa Anda hanya bertanggung jawab untuk merilis referensi ke objek yang Anda buat secara eksplisit. Objek yang dibuat metode untuk Anda, seperti CMM default yang mendasari CMM caching, dikelola oleh metode.
```
/ Create the caching CMM from a cache and a keyring.
struct aws_cryptosdk_cmm *caching_cmm = aws_cryptosdk_caching_cmm_new_from_keyring(allocator, cache, kms_keyring, NULL, 60, AWS_TIMESTAMP_SECS);
// Release your references to the cache and the keyring.
aws_cryptosdk_materials_cache_release(cache);
aws_cryptosdk_keyring_release(kms_keyring);
// Create a session with the caching CMM.
struct aws_cryptosdk_session *session = aws_cryptosdk_session_new_from_cmm_2(allocator, AWS_CRYPTOSDK_ENCRYPT, caching_cmm);
// Release your references to the caching CMM.
aws_cryptosdk_cmm_release(caching_cmm);
// ...
aws_cryptosdk_session_destroy(session);
```
# AWS Encryption SDK for C contoh
Contoh berikut menunjukkan cara menggunakan untuk mengenkripsi dan AWS Encryption SDK for C mendekripsi data.
Contoh di bagian ini menunjukkan cara menggunakan versi 2.0. *x* dan kemudian AWS Encryption SDK for C. Untuk contoh yang menggunakan versi sebelumnya, temukan rilis Anda di daftar [Rilis](https://github.com/aws/aws-encryption-sdk-c/releases) dari [aws-encryption-sdk-c repositori repositori](https://github.com/aws/aws-encryption-sdk-c/) di. GitHub
Ketika Anda menginstal dan membangun AWS Encryption SDK for C, kode sumber untuk ini dan contoh lainnya disertakan dalam `examples` subdirektori, dan mereka dikompilasi dan dibangun ke dalam `build` direktori. Anda juga dapat menemukannya di [contoh](https://github.com/aws/aws-encryption-sdk-c/tree/master/examples) subdirektori [aws-encryption-sdk-c](https://github.com/aws/aws-encryption-sdk-c/)repositori di. GitHub
**Topics**
+ [Mengenkripsi dan mendekripsi string](#c-example-strings)
## Mengenkripsi dan mendekripsi string
Contoh berikut menunjukkan kepada Anda bagaimana menggunakan AWS Encryption SDK for C untuk mengenkripsi dan mendekripsi string.
Contoh ini menampilkan [AWS KMS keyring](use-kms-keyring.md), jenis keyring yang menggunakan AWS KMS key in [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/) untuk menghasilkan dan mengenkripsi kunci data. Contohnya termasuk kode yang ditulis dalam C \$1\$1. Yang AWS Encryption SDK for C mengharuskan AWS SDK untuk C\$1\$1 untuk memanggil AWS KMS saat menggunakan AWS KMS keyrings. Jika Anda menggunakan keyring yang tidak berinteraksi AWS KMS, seperti keyring AES mentah, keyring RSA mentah, atau multi-keyring yang tidak menyertakan keyring, tidak diperlukan. AWS KMS AWS SDK untuk C\$1\$1
Untuk bantuan membuat AWS KMS key, lihat [Membuat Kunci](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) di *Panduan AWS Key Management Service Pengembang*. Untuk bantuan mengidentifikasi AWS KMS keys dalam AWS KMS gantungan kunci, lihat[Mengidentifikasi AWS KMS keys dalam AWS KMS keyring](use-kms-keyring.md#kms-keyring-id).
**Lihat contoh kode lengkap**: [string.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/string.cpp)
**Topics**
+ [Enkripsi string](#c-example-string-encrypt)
+ [Dekripsi string](#c-example-string-decrypt)
### Enkripsi string
Bagian pertama dari contoh ini menggunakan AWS KMS keyring dengan satu AWS KMS key untuk mengenkripsi string plaintext.
Langkah 1. Memuat string kesalahan.
Panggil `aws_cryptosdk_load_error_strings()` metode dalam kode C atau C \$1\$1 Anda. Ini memuat informasi kesalahan yang sangat berguna untuk debugging.
Anda hanya perlu memanggilnya sekali, seperti dalam `main` metode Anda.
```
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
```
Langkah 2: Bangun keyring.
Buat AWS KMS keyring untuk enkripsi. Keyring dalam contoh ini dikonfigurasi dengan satu AWS KMS key, tetapi Anda dapat mengonfigurasi AWS KMS keyring dengan beberapa AWS KMS keys, termasuk AWS KMS keys di akun yang berbeda Wilayah AWS dan berbeda.
Untuk mengidentifikasi AWS KMS key dalam keyring enkripsi di AWS Encryption SDK for C, tentukan [kunci ARN atau [alias](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn) ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN). Dalam keyring dekripsi, Anda harus menggunakan kunci ARN. Lihat perinciannya di [Mengidentifikasi AWS KMS keys dalam AWS KMS keyring](use-kms-keyring.md#kms-keyring-id).
[Mengidentifikasi AWS KMS keys dalam AWS KMS keyring](use-kms-keyring.md#kms-keyring-id)
Ketika Anda membuat keyring dengan beberapa AWS KMS keys, Anda menentukan yang AWS KMS key digunakan untuk menghasilkan dan mengenkripsi kunci data plaintext, dan array opsional tambahan yang mengenkripsi kunci data plaintext AWS KMS keys yang sama. Dalam hal ini, Anda hanya menentukan generator AWS KMS key.
Sebelum menjalankan kode ini, ganti contoh kunci ARN dengan yang valid.
```
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);
```
Langkah 3: Buat sesi.
Buat sesi menggunakan pengalokasi, enumerator mode, dan keyring.
Setiap sesi membutuhkan mode: baik `AWS_CRYPTOSDK_ENCRYPT` untuk mengenkripsi atau `AWS_CRYPTOSDK_DECRYPT` mendekripsi. Untuk mengubah mode sesi yang ada, gunakan `aws_cryptosdk_session_reset` metode ini.
Setelah membuat sesi dengan keyring, Anda dapat melepaskan referensi ke keyring menggunakan metode yang disediakan SDK. Sesi mempertahankan referensi ke objek keyring selama masa pakainya. Referensi ke keyring dan objek sesi dilepaskan saat Anda menghancurkan sesi. Teknik [penghitungan referensi](c-language-using.md#c-language-using-release) ini membantu mencegah kebocoran memori dan mencegah objek dilepaskan saat sedang digunakan.
```
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(alloc, AWS_CRYPTOSDK_ENCRYPT, kms_keyring);
/* When you add the keyring to the session, release the keyring object */
aws_cryptosdk_keyring_release(kms_keyring);
```
Langkah 4: Atur konteks enkripsi.
[Konteks enkripsi adalah data](concepts.md#encryption-context) otentikasi tambahan yang sewenang-wenang dan tidak rahasia. Ketika Anda menyediakan konteks enkripsi pada enkripsi, AWS Encryption SDK kriptografis mengikat konteks enkripsi ke ciphertext sehingga konteks enkripsi yang sama diperlukan untuk mendekripsi data. Menggunakan konteks enkripsi adalah opsional, tetapi kami merekomendasikannya sebagai praktik terbaik.
Pertama, buat tabel hash yang menyertakan string konteks enkripsi.
```
/* Allocate a hash table for the encryption context */
int set_up_enc_ctx(struct aws_allocator *alloc, struct aws_hash_table *my_enc_ctx)
// Create encryption context strings
AWS_STATIC_STRING_FROM_LITERAL(enc_ctx_key1, "Example");
AWS_STATIC_STRING_FROM_LITERAL(enc_ctx_value1, "String");
AWS_STATIC_STRING_FROM_LITERAL(enc_ctx_key2, "Company");
AWS_STATIC_STRING_FROM_LITERAL(enc_ctx_value2, "MyCryptoCorp");
// Put the key-value pairs in the hash table
aws_hash_table_put(my_enc_ctx, enc_ctx_key1, (void *)enc_ctx_value1, &was_created)
aws_hash_table_put(my_enc_ctx, enc_ctx_key2, (void *)enc_ctx_value2, &was_created)
```
Dapatkan pointer yang bisa berubah ke konteks enkripsi dalam sesi. Kemudian, gunakan `aws_cryptosdk_enc_ctx_clone` fungsi untuk menyalin konteks enkripsi ke dalam sesi. Simpan salinan `my_enc_ctx` sehingga Anda dapat memvalidasi nilai setelah mendekripsi data.
Konteks enkripsi adalah bagian dari sesi, bukan parameter yang diteruskan ke fungsi proses sesi. Ini menjamin bahwa konteks enkripsi yang sama digunakan untuk setiap segmen pesan, bahkan jika fungsi proses sesi dipanggil beberapa kali untuk mengenkripsi seluruh pesan.
```
struct aws_hash_table *session_enc_ctx = aws_cryptosdk_session_get_enc_ctx_ptr_mut(session);
aws_cryptosdk_enc_ctx_clone(alloc, session_enc_ctx, my_enc_ctx)
```
Langkah 5: Enkripsi string.
Untuk mengenkripsi string plaintext, gunakan `aws_cryptosdk_session_process_full` metode dengan sesi dalam mode enkripsi. Metode ini, diperkenalkan dalam AWS Encryption SDK versi 1.9. *x* dan 2.2. *x*, dirancang untuk enkripsi dan dekripsi non-streaming. Untuk menangani streaming data, panggil `aws_cryptosdk_session_process` dalam satu lingkaran.
Saat mengenkripsi, bidang plaintext adalah bidang input; bidang ciphertext adalah bidang keluaran. Saat pemrosesan selesai, `ciphertext_output` bidang berisi [pesan terenkripsi](concepts.md#message), termasuk ciphertext aktual, kunci data terenkripsi, dan konteks enkripsi. Anda dapat mendekripsi pesan terenkripsi ini dengan menggunakan AWS Encryption SDK untuk setiap bahasa pemrograman yang didukung.
```
/* Gets the length of the plaintext that the session processed */
size_t ciphertext_len_output;
if (AWS_OP_SUCCESS != aws_cryptosdk_session_process_full(session,
ciphertext_output,
ciphertext_buf_sz_output,
&ciphertext_len_output,
plaintext_input,
plaintext_len_input)) {
aws_cryptosdk_session_destroy(session);
return 8;
}
```
Langkah 6: Bersihkan sesi.
Langkah terakhir menghancurkan sesi termasuk referensi ke CMM dan keyring.
Jika Anda lebih suka, alih-alih menghancurkan sesi, Anda dapat menggunakan kembali sesi dengan keyring dan CMM yang sama untuk mendekripsi string, atau untuk mengenkripsi atau mendekripsi pesan lain. Untuk menggunakan sesi untuk mendekripsi, gunakan `aws_cryptosdk_session_reset` metode untuk mengubah mode ke. `AWS_CRYPTOSDK_DECRYPT`
### Dekripsi string
Bagian kedua dari contoh ini mendekripsi pesan terenkripsi yang berisi ciphertext dari string asli.
Langkah 1: Muat string kesalahan.
Panggil `aws_cryptosdk_load_error_strings()` metode dalam kode C atau C \$1\$1 Anda. Ini memuat informasi kesalahan yang sangat berguna untuk debugging.
Anda hanya perlu memanggilnya sekali, seperti dalam `main` metode Anda.
```
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
```
Langkah 2: Bangun keyring.
Saat Anda mendekripsi data AWS KMS, Anda meneruskan [pesan terenkripsi yang dikembalikan oleh](concepts.md#message) API enkripsi. [Decrypt API](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) tidak mengambil AWS KMS key sebagai input. Sebaliknya, AWS KMS menggunakan yang sama AWS KMS key untuk mendekripsi ciphertext yang digunakan untuk mengenkripsi itu. Namun, AWS Encryption SDK memungkinkan Anda menentukan AWS KMS keyring dengan enkripsi dan AWS KMS keys dekripsi.
Saat mendekripsi, Anda dapat mengonfigurasi keyring hanya dengan AWS KMS keys yang ingin Anda gunakan untuk mendekripsi pesan terenkripsi. Misalnya, Anda mungkin ingin membuat keyring hanya dengan AWS KMS key yang digunakan oleh peran tertentu dalam organisasi Anda. Tidak AWS Encryption SDK akan pernah menggunakan AWS KMS key kecuali muncul di keyring dekripsi. Jika SDK tidak dapat mendekripsi kunci data terenkripsi dengan menggunakan keyring AWS KMS keys dalam yang Anda berikan, baik karena tidak ada AWS KMS keys dalam keyring yang digunakan untuk mengenkripsi salah satu kunci data, atau karena pemanggil tidak memiliki izin untuk menggunakan AWS KMS keys dalam keyring untuk mendekripsi, panggilan dekripsi gagal.
[Ketika Anda menentukan AWS KMS key untuk keyring dekripsi, Anda harus menggunakan kunci ARN.](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) [Alias](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn) hanya ARNs diizinkan dalam gantungan kunci enkripsi. Untuk bantuan mengidentifikasi AWS KMS keys dalam AWS KMS gantungan kunci, lihat[Mengidentifikasi AWS KMS keys dalam AWS KMS keyring](use-kms-keyring.md#kms-keyring-id).
Dalam contoh ini, kami menentukan keyring yang dikonfigurasi dengan yang sama AWS KMS key digunakan untuk mengenkripsi string. Sebelum menjalankan kode ini, ganti contoh kunci ARN dengan yang valid.
```
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);
```
Langkah 3: Buat sesi.
Buat sesi menggunakan pengalokasi dan keyring. Untuk mengkonfigurasi sesi untuk dekripsi, konfigurasikan sesi dengan mode. `AWS_CRYPTOSDK_DECRYPT`
Setelah membuat sesi dengan keyring, Anda dapat melepaskan referensi ke keyring menggunakan metode yang disediakan SDK. Sesi mempertahankan referensi ke objek keyring selama masa pakainya, dan sesi dan keyring dilepaskan saat Anda menghancurkan sesi. Teknik penghitungan referensi ini membantu mencegah kebocoran memori dan mencegah objek dilepaskan saat sedang digunakan.
```
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(alloc, AWS_CRYPTOSDK_DECRYPT, kms_keyring);
/* When you add the keyring to the session, release the keyring object */
aws_cryptosdk_keyring_release(kms_keyring);
```
Langkah 4: Dekripsi string.
Untuk mendekripsi string, gunakan `aws_cryptosdk_session_process_full` metode dengan sesi yang dikonfigurasi untuk dekripsi. Metode ini, diperkenalkan dalam AWS Encryption SDK versi 1.9. *x* dan 2.2. *x*, dirancang untuk enkripsi dan dekripsi non-streaming. Untuk menangani streaming data, panggil `aws_cryptosdk_session_process` dalam satu lingkaran.
Saat mendekripsi, bidang ciphertext adalah bidang input dan bidang plaintext adalah bidang keluaran. `ciphertext_input`Bidang menyimpan [pesan terenkripsi yang dikembalikan](message-format.md) oleh metode enkripsi. Saat pemrosesan selesai, `plaintext_output` bidang berisi string plaintext (didekripsi).
```
size_t plaintext_len_output;
if (AWS_OP_SUCCESS != aws_cryptosdk_session_process_full(session,
plaintext_output,
plaintext_buf_sz_output,
&plaintext_len_output,
ciphertext_input,
ciphertext_len_input)) {
aws_cryptosdk_session_destroy(session);
return 13;
}
```
Langkah 5: Verifikasi konteks enkripsi.
Pastikan bahwa konteks enkripsi yang sebenarnya — yang digunakan untuk mendekripsi pesan — berisi konteks enkripsi yang Anda berikan saat mengenkripsi pesan. Konteks enkripsi yang sebenarnya mungkin mencakup pasangan tambahan, karena [pengelola materi kriptografi](concepts.md#crypt-materials-manager) (CMM) dapat menambahkan pasangan ke konteks enkripsi yang disediakan sebelum mengenkripsi pesan.
Di dalam AWS Encryption SDK for C, Anda tidak diharuskan untuk menyediakan konteks enkripsi saat mendekripsi karena konteks enkripsi disertakan dalam pesan terenkripsi yang dikembalikan SDK. Namun, sebelum mengembalikan pesan teks biasa, fungsi dekripsi Anda harus memverifikasi bahwa semua pasangan dalam konteks enkripsi yang disediakan muncul dalam konteks enkripsi yang digunakan untuk mendekripsi pesan.
Pertama, dapatkan pointer read-only ke tabel hash di sesi. Tabel hash ini berisi konteks enkripsi yang digunakan untuk mendekripsi pesan.
```
const struct aws_hash_table *session_enc_ctx = aws_cryptosdk_session_get_enc_ctx_ptr(session);
```
Kemudian, loop melalui konteks enkripsi dalam tabel `my_enc_ctx` hash yang Anda salin saat mengenkripsi. Verifikasi bahwa setiap pasangan dalam tabel `my_enc_ctx` hash yang digunakan untuk mengenkripsi muncul di tabel `session_enc_ctx` hash yang digunakan untuk mendekripsi. Jika ada kunci yang hilang, atau kunci itu memiliki nilai yang berbeda, hentikan pemrosesan dan tulis pesan kesalahan.
```
for (struct aws_hash_iter iter = aws_hash_iter_begin(my_enc_ctx); !aws_hash_iter_done(&iter);
aws_hash_iter_next(&iter)) {
struct aws_hash_element *session_enc_ctx_kv_pair;
aws_hash_table_find(session_enc_ctx, iter.element.key, &session_enc_ctx_kv_pair)
if (!session_enc_ctx_kv_pair ||
!aws_string_eq(
(struct aws_string *)iter.element.value, (struct aws_string *)session_enc_ctx_kv_pair->value)) {
fprintf(stderr, "Wrong encryption context!\n");
abort();
}
}
```
Langkah 6: Bersihkan sesi.
Setelah Anda memverifikasi konteks enkripsi, Anda dapat menghancurkan sesi, atau menggunakannya kembali. Jika Anda perlu mengkonfigurasi ulang sesi, gunakan `aws_cryptosdk_session_reset` metode ini.
```
aws_cryptosdk_session_destroy(session);
```