Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Contoh CLI AWS Enkripsi
Gunakan contoh berikut untuk mencoba CLI AWS Enkripsi pada platform yang Anda inginkan. Untuk bantuan dengan kunci master dan parameter lainnya, lihat[Cara menggunakan CLI AWS Enkripsi](crypto-cli-how-to.md). Untuk referensi cepat, lihat[AWS Encryption SDK Sintaks CLI dan referensi parameter](crypto-cli-reference.md).
**catatan**
Contoh berikut menggunakan sintaks untuk AWS Enkripsi CLI versi 2.1. *x*.
Fitur keamanan baru awalnya dirilis dalam AWS Enkripsi CLI versi 1.7. *x* dan 2.0. *x*. Namun, AWS Enkripsi CLI versi 1.8. *x* menggantikan versi 1.7. *x* dan AWS Enkripsi CLI 2.1. *x* menggantikan 2.0. *x*. Untuk detailnya, lihat [penasihat keamanan](https://github.com/aws/aws-encryption-sdk-cli/security/advisories/GHSA-2xwp-m7mq-7q3r) yang relevan di [aws-encryption-sdk-cli](https://github.com/aws/aws-encryption-sdk-cli/)repositori di. GitHub
Untuk contoh yang menunjukkan cara menggunakan fitur keamanan yang membatasi kunci data terenkripsi, lihat. [Membatasi kunci data terenkripsi](configure.md#config-limit-keys)
Untuk contoh yang menunjukkan cara menggunakan kunci AWS KMS Multi-region, lihat[Menggunakan Multi-region AWS KMS keys](configure.md#config-mrks).
**Topics**
+ [Mengenkripsi file](#cli-example-encrypt-file)
+ [Mendekripsi file](#cli-example-decrypt-file)
+ [Mengenkripsi semua file dalam direktori](#cli-example-encrypt-directory)
+ [Mendekripsi semua file dalam direktori](#cli-example-decrypt-directory)
+ [Mengenkripsi dan mendekripsi pada baris perintah](#cli-example-stdin)
+ [Menggunakan beberapa kunci master](#cli-example-multimaster)
+ [Mengenkripsi dan mendekripsi dalam skrip](#cli-example-script)
+ [Menggunakan caching kunci data](#cli-example-caching)
## Mengenkripsi file
Contoh ini menggunakan CLI AWS Enkripsi untuk mengenkripsi isi `hello.txt` file, yang berisi string “Hello World”.
Ketika Anda menjalankan perintah enkripsi pada file, CLI AWS Enkripsi mendapatkan konten file, menghasilkan kunci [data unik](concepts.md#DEK), mengenkripsi konten file di bawah kunci data, dan kemudian menulis pesan [terenkripsi ke](concepts.md#message) file baru.
Perintah pertama menyimpan ARN kunci dari AWS KMS key variabel. `$keyArn` Saat mengenkripsi dengan AWS KMS key, Anda dapat mengidentifikasinya dengan menggunakan ID kunci, ARN kunci, nama alias, atau alias ARN. Untuk detail tentang pengidentifikasi kunci AWS KMS key, lihat [Pengidentifikasi Kunci di Panduan AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) *Pengembang*.
Perintah kedua mengenkripsi isi file. Perintah menggunakan `--encrypt` parameter untuk menentukan operasi dan `--input` parameter untuk menunjukkan file yang akan dienkripsi. [`--wrapping-keys`Parameter](crypto-cli-how-to.md#crypto-cli-master-key), dan atribut **kunci** yang diperlukan, beri tahu perintah untuk menggunakan yang AWS KMS key diwakili oleh kunci ARN.
Perintah menggunakan `--metadata-output` parameter untuk menentukan file teks untuk metadata tentang operasi enkripsi. Sebagai praktik terbaik, perintah menggunakan `--encryption-context` parameter untuk menentukan [konteks enkripsi](crypto-cli-how-to.md#crypto-cli-encryption-context).
Perintah ini juga menggunakan [`--commitment-policy`parameter](crypto-cli-reference.md#syntax-commitment-policy) untuk menetapkan kebijakan komitmen secara eksplisit. Dalam versi 1.8. *x*, parameter ini diperlukan saat Anda menggunakan `--wrapping-keys` parameter. Dimulai pada versi 2.1. *x*, `--commitment-policy` parameternya opsional, tetapi disarankan.
Nilai `--output` parameter, titik (.), memberi tahu perintah untuk menulis file output ke direktori saat ini.
------
#### [ Bash ]
```
\\ 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 \
--metadata-output ~/metadata \
--encryption-context purpose=test \
--commitment-policy require-encrypt-require-decrypt \
--output .
```
------
#### [ PowerShell ]
```
# To run this example, replace the fictitious key ARN with a valid value.
PS C:\> $keyArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
PS C:\> aws-encryption-cli --encrypt `
--input Hello.txt `
--wrapping-keys key=$keyArn `
--metadata-output $home\Metadata.txt `
--commitment-policy require-encrypt-require-decrypt `
--encryption-context purpose=test `
--output .
```
------
Ketika perintah enkripsi berhasil, itu tidak mengembalikan output apa pun. Untuk menentukan apakah perintah berhasil, periksa nilai Boolean dalam variabel. `$?` Ketika perintah berhasil, nilai dari `$?` adalah `0` (Bash) atau `True` (PowerShell). Ketika perintah gagal, nilai `$?` adalah bukan nol (Bash) atau `False` (PowerShell).
------
#### [ Bash ]
```
$ echo $?
0
```
------
#### [ PowerShell ]
```
PS C:\> $?
True
```
------
Anda juga dapat menggunakan perintah daftar direktori untuk melihat bahwa perintah enkripsi membuat file baru,`hello.txt.encrypted`. Karena perintah enkripsi tidak menentukan nama file untuk output, CLI AWS Enkripsi menulis output ke file dengan nama yang sama dengan file input ditambah `.encrypted` akhiran. Untuk menggunakan akhiran yang berbeda, atau menekan sufiks, gunakan parameter. `--suffix`
`hello.txt.encrypted`File berisi [pesan terenkripsi](concepts.md#message) yang mencakup ciphertext `hello.txt` file, salinan kunci data terenkripsi, dan metadata tambahan, termasuk konteks enkripsi.
------
#### [ Bash ]
```
$ ls
hello.txt hello.txt.encrypted
```
------
#### [ PowerShell ]
```
PS C:\> dir
Directory: C:\TestCLI
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 9/15/2017 5:57 PM 11 Hello.txt
-a---- 9/17/2017 1:06 PM 585 Hello.txt.encrypted
```
------
## Mendekripsi file
Contoh ini menggunakan CLI AWS Enkripsi untuk mendekripsi isi `Hello.txt.encrypted` file yang dienkripsi pada contoh sebelumnya.
Perintah dekripsi menggunakan `--decrypt` parameter untuk menunjukkan operasi dan `--input` parameter untuk mengidentifikasi file yang akan didekripsi. Nilai `--output` parameter adalah titik yang mewakili direktori saat ini.
`--wrapping-keys`Parameter dengan atribut **kunci menentukan kunci** pembungkus yang digunakan untuk mendekripsi pesan terenkripsi. Dalam dekripsi perintah dengan AWS KMS keys, nilai atribut kunci harus berupa [ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) kunci. `--wrapping-keys`Parameter diperlukan dalam perintah dekripsi. Jika Anda menggunakan AWS KMS keys, Anda dapat menggunakan atribut **kunci** untuk menentukan AWS KMS keys untuk mendekripsi atau atribut **penemuan** dengan nilai `true` (tetapi tidak keduanya). Jika Anda menggunakan penyedia kunci master kustom, atribut **kunci** dan **penyedia** diperlukan.
[`--commitment-policy`Parameternya](crypto-cli-reference.md#syntax-commitment-policy) opsional dimulai pada versi 2.1. *x*, tetapi disarankan. Menggunakannya secara eksplisit membuat maksud Anda jelas, bahkan jika Anda menentukan nilai default,. `require-encrypt-require-decrypt`
`--encryption-context`Parameter ini opsional dalam perintah dekripsi, bahkan ketika [konteks enkripsi](crypto-cli-how-to.md#crypto-cli-encryption-context) disediakan dalam perintah enkripsi. Dalam hal ini, perintah dekripsi menggunakan konteks enkripsi yang sama yang disediakan dalam perintah enkripsi. Sebelum mendekripsi, AWS CLI Enkripsi memverifikasi bahwa konteks enkripsi dalam pesan terenkripsi menyertakan pasangan. `purpose=test` Jika tidak, perintah dekripsi gagal.
`--metadata-output`Parameter menentukan file untuk metadata tentang operasi dekripsi. Nilai `--output` parameter, titik (.), menulis file output ke direktori saat ini.
Sebagai praktik terbaik, gunakan `--max-encrypted-data-keys` parameter untuk menghindari dekripsi pesan yang salah dengan jumlah kunci data terenkripsi yang berlebihan. Tentukan jumlah yang diharapkan dari kunci data terenkripsi (satu untuk setiap kunci pembungkus yang digunakan dalam enkripsi) atau maksimum yang wajar (seperti 5). Lihat perinciannya di [Membatasi kunci data terenkripsi](configure.md#config-limit-keys).
Plaintext `--buffer` mengembalikan hanya setelah semua input diproses, termasuk memverifikasi tanda tangan digital jika ada.
------
#### [ Bash ]
```
\\ 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 \
--input hello.txt.encrypted \
--wrapping-keys key=$keyArn \
--commitment-policy require-encrypt-require-decrypt \
--encryption-context purpose=test \
--metadata-output ~/metadata \
--max-encrypted-data-keys 1 \
--buffer \
--output .
```
------
#### [ PowerShell ]
```
\\ To run this example, replace the fictitious key ARN with a valid value.
PS C:\> $keyArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
PS C:\> aws-encryption-cli --decrypt `
--input Hello.txt.encrypted `
--wrapping-keys key=$keyArn `
--commitment-policy require-encrypt-require-decrypt `
--encryption-context purpose=test `
--metadata-output $home\Metadata.txt `
--max-encrypted-data-keys 1 `
--buffer `
--output .
```
------
Ketika perintah dekripsi berhasil, itu tidak mengembalikan output apa pun. Untuk menentukan apakah perintah berhasil, dapatkan nilai `$?` variabel. Anda juga dapat menggunakan perintah daftar direktori untuk melihat bahwa perintah tersebut membuat file baru dengan `.decrypted` akhiran. [Untuk melihat konten plaintext, gunakan perintah untuk mendapatkan konten file, seperti `cat` atau Get-Content.](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.management/get-content)
------
#### [ Bash ]
```
$ ls
hello.txt hello.txt.encrypted hello.txt.encrypted.decrypted
$ cat hello.txt.encrypted.decrypted
Hello World
```
------
#### [ PowerShell ]
```
PS C:\> dir
Directory: C:\TestCLI
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 9/17/2017 1:01 PM 11 Hello.txt
-a---- 9/17/2017 1:06 PM 585 Hello.txt.encrypted
-a---- 9/17/2017 1:08 PM 11 Hello.txt.encrypted.decrypted
PS C:\> Get-Content Hello.txt.encrypted.decrypted
Hello World
```
------
## Mengenkripsi semua file dalam direktori
Contoh ini menggunakan CLI Enkripsi untuk mengenkripsi isi semua file dalam direktori. AWS
Ketika sebuah perintah mempengaruhi beberapa file, CLI AWS Enkripsi memproses setiap file satu per satu. Ini mendapatkan isi file, mendapatkan [kunci data](concepts.md#DEK) unik untuk file dari kunci master, mengenkripsi konten file di bawah kunci data, dan menulis hasilnya ke file baru di direktori output. Akibatnya, Anda dapat mendekripsi file output secara independen.
Daftar `TestDir` direktori ini menunjukkan file plaintext yang ingin kita enkripsi.
------
#### [ Bash ]
```
$ ls testdir
cool-new-thing.py hello.txt employees.csv
```
------
#### [ PowerShell ]
```
PS C:\> dir C:\TestDir
Directory: C:\TestDir
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 9/12/2017 3:11 PM 2139 cool-new-thing.py
-a---- 9/15/2017 5:57 PM 11 Hello.txt
-a---- 9/17/2017 1:44 PM 46 Employees.csv
```
------
Perintah pertama menyimpan [Amazon Resource Name (ARN)](https://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html#find-cmk-id-arn) dari AWS KMS key variabel. `$keyArn`
Perintah kedua mengenkripsi konten file dalam `TestDir` direktori dan menulis file konten terenkripsi ke direktori. `TestEnc` Jika `TestEnc` direktori tidak ada, perintah gagal. Karena lokasi input adalah direktori, `--recursive` parameter diperlukan.
[`--wrapping-keys`Parameter](crypto-cli-how-to.md#crypto-cli-master-key), dan atribut **kunci** yang diperlukan, tentukan kunci pembungkus yang akan digunakan. Perintah enkripsi mencakup [konteks enkripsi](crypto-cli-how-to.md#crypto-cli-encryption-context),`dept=IT`. Saat Anda menentukan konteks enkripsi dalam perintah yang mengenkripsi beberapa file, konteks enkripsi yang sama digunakan untuk semua file.
Perintah ini juga memiliki `--metadata-output` parameter untuk memberi tahu CLI AWS Enkripsi tempat menulis metadata tentang operasi enkripsi. CLI AWS Enkripsi menulis satu catatan metadata untuk setiap file yang dienkripsi.
[`--commitment-policy parameter`](crypto-cli-how-to.md#crypto-cli-commitment-policy)Ini opsional dimulai pada versi 2.1. *x*, tetapi disarankan. Jika perintah atau skrip gagal karena tidak dapat mendekripsi ciphertext, pengaturan kebijakan komitmen eksplisit dapat membantu Anda mendeteksi masalah dengan cepat.
Ketika perintah selesai, CLI AWS Enkripsi menulis file terenkripsi ke `TestEnc` direktori, tetapi tidak mengembalikan output apa pun.
Perintah terakhir mencantumkan file dalam `TestEnc` direktori. Ada satu file output dari konten terenkripsi untuk setiap file input konten plaintext. Karena perintah tidak menentukan akhiran alternatif, perintah enkripsi ditambahkan `.encrypted` ke masing-masing nama file input.
------
#### [ Bash ]
```
# To run this example, replace the fictitious key ARN with a valid master key identifier.
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
$ aws-encryption-cli --encrypt \
--input testdir --recursive\
--wrapping-keys key=$keyArn \
--encryption-context dept=IT \
--commitment-policy require-encrypt-require-decrypt \
--metadata-output ~/metadata \
--output testenc
$ ls testenc
cool-new-thing.py.encrypted employees.csv.encrypted hello.txt.encrypted
```
------
#### [ PowerShell ]
```
# To run this example, replace the fictitious key ARN with a valid master key identifier.
PS C:\> $keyArn = arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
PS C:\> aws-encryption-cli --encrypt `
--input .\TestDir --recursive `
--wrapping-keys key=$keyArn `
--encryption-context dept=IT `
--commitment-policy require-encrypt-require-decrypt `
--metadata-output .\Metadata\Metadata.txt `
--output .\TestEnc
PS C:\> dir .\TestEnc
Directory: C:\TestEnc
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 9/17/2017 2:32 PM 2713 cool-new-thing.py.encrypted
-a---- 9/17/2017 2:32 PM 620 Hello.txt.encrypted
-a---- 9/17/2017 2:32 PM 585 Employees.csv.encrypted
```
------
## Mendekripsi semua file dalam direktori
Contoh ini mendekripsi semua file dalam direktori. Dimulai dengan file di `TestEnc` direktori yang dienkripsi dalam contoh sebelumnya.
------
#### [ Bash ]
```
$ ls testenc
cool-new-thing.py.encrypted hello.txt.encrypted employees.csv.encrypted
```
------
#### [ PowerShell ]
```
PS C:\> dir C:\TestEnc
Directory: C:\TestEnc
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 9/17/2017 2:32 PM 2713 cool-new-thing.py.encrypted
-a---- 9/17/2017 2:32 PM 620 Hello.txt.encrypted
-a---- 9/17/2017 2:32 PM 585 Employees.csv.encrypted
```
------
Perintah dekripsi ini mendekripsi semua file dalam TestEnc direktori dan menulis file plaintext ke direktori. TestDec `--wrapping-keys`Parameter dengan atribut **kunci** dan nilai [ARN kunci](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) memberi tahu AWS CLI Enkripsi yang akan digunakan AWS KMS keys untuk mendekripsi file. Perintah menggunakan `--interactive` parameter untuk memberi tahu CLI AWS Enkripsi untuk meminta Anda sebelum menimpa file dengan nama yang sama.
Perintah ini juga menggunakan konteks enkripsi yang disediakan saat file dienkripsi. Saat mendekripsi beberapa file, AWS CLI Enkripsi memeriksa konteks enkripsi setiap file. Jika pemeriksaan konteks enkripsi pada file apa pun gagal, CLI AWS Enkripsi menolak file, menulis peringatan, mencatat kegagalan dalam metadata, dan kemudian terus memeriksa file yang tersisa. Jika CLI AWS Enkripsi gagal mendekripsi file karena alasan lain, seluruh perintah dekripsi segera gagal.
Dalam contoh ini, pesan terenkripsi di semua file input berisi elemen konteks `dept=IT` enkripsi. Namun, jika Anda mendekripsi pesan dengan konteks enkripsi yang berbeda, Anda mungkin masih dapat memverifikasi bagian dari konteks enkripsi. Misalnya, jika beberapa pesan memiliki konteks enkripsi `dept=finance` dan yang lainnya memiliki`dept=IT`, Anda dapat memverifikasi bahwa konteks enkripsi selalu berisi `dept` nama tanpa menentukan nilainya. Jika Anda ingin lebih spesifik, Anda dapat mendekripsi file dalam perintah terpisah.
Perintah dekripsi tidak mengembalikan output apa pun, tetapi Anda dapat menggunakan perintah daftar direktori untuk melihat bahwa itu membuat file baru dengan akhiran. `.decrypted` Untuk melihat konten plaintext, gunakan perintah untuk mendapatkan konten file.
------
#### [ Bash ]
```
# To run this example, replace the fictitious key ARN with a valid master key identifier.
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
$ aws-encryption-cli --decrypt \
--input testenc --recursive \
--wrapping-keys key=$keyArn \
--encryption-context dept=IT \
--commitment-policy require-encrypt-require-decrypt \
--metadata-output ~/metadata \
--max-encrypted-data-keys 1 \
--buffer \
--output testdec --interactive
$ ls testdec
cool-new-thing.py.encrypted.decrypted hello.txt.encrypted.decrypted employees.csv.encrypted.decrypted
```
------
#### [ PowerShell ]
```
# To run this example, replace the fictitious key ARN with a valid master key identifier.
PS C:\> $keyArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
PS C:\> aws-encryption-cli --decrypt `
--input C:\TestEnc --recursive `
--wrapping-keys key=$keyArn `
--encryption-context dept=IT `
--commitment-policy require-encrypt-require-decrypt `
--metadata-output $home\Metadata.txt `
--max-encrypted-data-keys 1 `
--buffer `
--output C:\TestDec --interactive
PS C:\> dir .\TestDec
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 10/8/2017 4:57 PM 2139 cool-new-thing.py.encrypted.decrypted
-a---- 10/8/2017 4:57 PM 46 Employees.csv.encrypted.decrypted
-a---- 10/8/2017 4:57 PM 11 Hello.txt.encrypted.decrypted
```
------
## Mengenkripsi dan mendekripsi pada baris perintah
Contoh-contoh ini menunjukkan cara menyalurkan input ke perintah (stdin) dan menulis output ke baris perintah (stdout). Mereka menjelaskan cara merepresentasikan stdin dan stdout dalam sebuah perintah dan cara menggunakan alat pengkodean Base64 bawaan untuk mencegah shell salah menafsirkan karakter non-ASCII.
Contoh ini menyalurkan string teks biasa ke perintah enkripsi dan menyimpan pesan terenkripsi dalam variabel. Kemudian, ia menyalurkan pesan terenkripsi dalam variabel ke perintah dekripsi, yang menulis outputnya ke pipeline (stdout).
Contohnya terdiri dari tiga perintah:
+ Perintah pertama menyimpan [ARN kunci](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) dari AWS KMS key variabel. `$keyArn`
------
#### [ Bash ]
```
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
```
------
#### [ PowerShell ]
```
PS C:\> $keyArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
```
------
+ Perintah kedua `Hello World` menyalurkan string ke perintah enkripsi dan menyimpan hasilnya dalam `$encrypted` variabel.
`--output`Parameter `--input` dan diperlukan di semua perintah AWS Enkripsi CLI. Untuk menunjukkan bahwa input sedang disalurkan ke perintah (stdin), gunakan tanda hubung (`-`) untuk nilai parameter. `--input` Untuk mengirim output ke baris perintah (stdout), gunakan tanda hubung untuk nilai parameter. `--output`
`--encode`Parameter Base64-mengkodekan output sebelum mengembalikannya. Ini mencegah shell salah menafsirkan karakter non-ASCII dalam pesan terenkripsi.
Karena perintah ini hanyalah bukti konsep, kami menghilangkan konteks enkripsi dan menekan metadata (). `-S`
------
#### [ Bash ]
```
$ encrypted=$(echo 'Hello World' | aws-encryption-cli --encrypt -S \
--input - --output - --encode \
--wrapping-keys key=$keyArn )
```
------
#### [ PowerShell ]
```
PS C:\> $encrypted = 'Hello World' | aws-encryption-cli --encrypt -S `
--input - --output - --encode `
--wrapping-keys key=$keyArn
```
------
+ Perintah ketiga menyalurkan pesan terenkripsi dalam `$encrypted` variabel ke perintah dekripsi.
Perintah dekripsi ini digunakan `--input -` untuk menunjukkan bahwa input berasal dari pipeline (stdin) dan `--output -` untuk mengirim output ke pipeline (stdout). (Parameter input mengambil lokasi input, bukan byte input yang sebenarnya, sehingga Anda tidak dapat menggunakan `$encrypted` variabel sebagai nilai `--input` parameter.)
Contoh ini menggunakan atribut **penemuan** `--wrapping-keys` parameter untuk memungkinkan CLI AWS Enkripsi menggunakan apapun AWS KMS key untuk mendekripsi data. Itu tidak menentukan [kebijakan komitmen](concepts.md#commitment-policy), sehingga menggunakan nilai default untuk versi 2.1. *x* dan kemudian, `require-encrypt-require-decrypt`
Karena output dienkripsi dan kemudian dikodekan, perintah dekripsi menggunakan `--decode` parameter untuk memecahkan kode input yang dikodekan Base64 sebelum mendekripsi. Anda juga dapat menggunakan `--decode` parameter untuk memecahkan kode input yang dikodekan Base64 sebelum mengenkripsinya.
Sekali lagi, perintah menghilangkan konteks enkripsi dan menekan metadata (-). `S`
------
#### [ Bash ]
```
$ echo $encrypted | aws-encryption-cli --decrypt --wrapping-keys discovery=true --input - --output - --decode --buffer -S
Hello World
```
------
#### [ PowerShell ]
```
PS C:\> $encrypted | aws-encryption-cli --decrypt --wrapping-keys discovery=$true --input - --output - --decode --buffer -S
Hello World
```
------
Anda juga dapat melakukan operasi enkripsi dan dekripsi dalam satu perintah tanpa variabel intervensi.
Seperti pada contoh sebelumnya, `--output` parameter `--input` dan memiliki `-` nilai dan perintah menggunakan `--encode` parameter untuk menyandikan output dan `--decode` parameter untuk memecahkan kode input.
------
#### [ Bash ]
```
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
$ echo 'Hello World' |
aws-encryption-cli --encrypt --wrapping-keys key=$keyArn --input - --output - --encode -S |
aws-encryption-cli --decrypt --wrapping-keys discovery=true --input - --output - --decode -S
Hello World
```
------
#### [ PowerShell ]
```
PS C:\> $keyArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
PS C:\> 'Hello World' |
aws-encryption-cli --encrypt --wrapping-keys key=$keyArn --input - --output - --encode -S |
aws-encryption-cli --decrypt --wrapping-keys discovery=$true --input - --output - --decode -S
Hello World
```
------
## Menggunakan beberapa kunci master
Contoh ini menunjukkan cara menggunakan beberapa kunci master saat mengenkripsi dan mendekripsi data di CLI Enkripsi. AWS
Bila Anda menggunakan beberapa kunci master untuk mengenkripsi data, salah satu kunci master dapat digunakan untuk mendekripsi data. Strategi ini memastikan bahwa Anda dapat mendekripsi data bahkan jika salah satu kunci master tidak tersedia. Jika Anda menyimpan data terenkripsi dalam beberapa Wilayah AWS, strategi ini memungkinkan Anda menggunakan kunci master di Wilayah yang sama untuk mendekripsi data.
Saat Anda mengenkripsi dengan beberapa kunci master, kunci master pertama memainkan peran khusus. Ini menghasilkan kunci data yang digunakan untuk mengenkripsi data. Kunci master yang tersisa mengenkripsi kunci data teks biasa. [Pesan terenkripsi yang](concepts.md#message) dihasilkan mencakup data terenkripsi dan kumpulan kunci data terenkripsi, satu untuk setiap kunci master. Meskipun kunci master pertama menghasilkan kunci data, salah satu kunci master dapat mendekripsi salah satu kunci data, yang dapat digunakan untuk mendekripsi data.
**Mengenkripsi dengan tiga kunci utama**
Perintah contoh ini menggunakan tiga kunci pembungkus untuk mengenkripsi `Finance.log` file, satu di masing-masing tiga. Wilayah AWS
Ini menulis pesan terenkripsi ke direktori. `Archive` Perintah menggunakan `--suffix` parameter tanpa nilai untuk menekan akhiran, sehingga nama file input dan output akan sama.
Perintah menggunakan `--wrapping-keys` parameter dengan tiga atribut **kunci**. Anda juga dapat menggunakan beberapa `--wrapping-keys` parameter dalam perintah yang sama.
Untuk mengenkripsi file log, CLI AWS Enkripsi meminta kunci pembungkus pertama dalam daftar`$key1`,, untuk menghasilkan kunci data yang digunakannya untuk mengenkripsi data. Kemudian, ia menggunakan masing-masing kunci pembungkus lainnya untuk mengenkripsi salinan teks biasa dari kunci data yang sama. Pesan terenkripsi dalam file output mencakup ketiga kunci data terenkripsi.
------
#### [ Bash ]
```
$ key1=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
$ key2=arn:aws:kms:us-east-2:111122223333:key/0987ab65-43cd-21ef-09ab-87654321cdef
$ key3=arn:aws:kms:ap-southeast-1:111122223333:key/1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d
$ aws-encryption-cli --encrypt --input /logs/finance.log \
--output /archive --suffix \
--encryption-context class=log \
--metadata-output ~/metadata \
--wrapping-keys key=$key1 key=$key2 key=$key3
```
------
#### [ PowerShell ]
```
PS C:\> $key1 = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
PS C:\> $key2 = 'arn:aws:kms:us-east-2:111122223333:key/0987ab65-43cd-21ef-09ab-87654321cdef'
PS C:\> $key3 = 'arn:aws:kms:ap-southeast-1:111122223333:key/1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d'
PS C:\> aws-encryption-cli --encrypt --input D:\Logs\Finance.log `
--output D:\Archive --suffix `
--encryption-context class=log `
--metadata-output $home\Metadata.txt `
--wrapping-keys key=$key1 key=$key2 key=$key3
```
------
Perintah ini mendekripsi salinan `Finance.log` file yang dienkripsi dan menulisnya ke `Finance.log.clear` file di direktori. `Finance` Untuk mendekripsi data yang dienkripsi di bawah tiga AWS KMS keys, Anda dapat menentukan tiga AWS KMS keys atau subset yang sama. Contoh ini hanya menentukan salah satu dari. AWS KMS keys
Untuk memberi tahu CLI AWS Enkripsi yang AWS KMS keys akan digunakan untuk mendekripsi data Anda, gunakan atribut **kunci parameter**. `--wrapping-keys` Saat mendekripsi dengan AWS KMS keys, nilai atribut **kunci** harus berupa [ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) kunci.
Anda harus memiliki izin untuk memanggil [Decrypt API](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) pada yang AWS KMS keys Anda tentukan. Untuk informasi selengkapnya, lihat [Otentikasi dan Kontrol Akses untuk AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/control-access.html).
Sebagai praktik terbaik, contoh ini menggunakan `--max-encrypted-data-keys` parameter untuk menghindari dekripsi pesan yang salah dengan jumlah kunci data terenkripsi yang berlebihan. Meskipun contoh ini hanya menggunakan satu kunci pembungkus untuk dekripsi, pesan terenkripsi memiliki tiga (3) kunci data terenkripsi; satu untuk masing-masing dari tiga kunci pembungkus yang digunakan saat mengenkripsi. Tentukan jumlah yang diharapkan dari kunci data terenkripsi atau nilai maksimum yang wajar, seperti 5. Jika Anda menentukan nilai maksimum kurang dari 3, perintah gagal. Lihat perinciannya di [Membatasi kunci data terenkripsi](configure.md#config-limit-keys).
------
#### [ Bash ]
```
$ aws-encryption-cli --decrypt --input /archive/finance.log \
--wrapping-keys key=$key1 \
--output /finance --suffix '.clear' \
--metadata-output ~/metadata \
--max-encrypted-data-keys 3 \
--buffer \
--encryption-context class=log
```
------
#### [ PowerShell ]
```
PS C:\> aws-encryption-cli --decrypt `
--input D:\Archive\Finance.log `
--wrapping-keys key=$key1 `
--output D:\Finance --suffix '.clear' `
--metadata-output .\Metadata\Metadata.txt `
--max-encrypted-data-keys 3 `
--buffer `
--encryption-context class=log
```
------
## Mengenkripsi dan mendekripsi dalam skrip
Contoh ini menunjukkan cara menggunakan CLI AWS Enkripsi dalam skrip. Anda dapat menulis skrip yang hanya mengenkripsi dan mendekripsi data, atau skrip yang mengenkripsi atau mendekripsi sebagai bagian dari proses manajemen data.
Dalam contoh ini, skrip mendapatkan koleksi file log, mengompresnya, mengenkripsi mereka, dan kemudian menyalin file terenkripsi ke bucket Amazon S3. Skrip ini memproses setiap file secara terpisah, sehingga Anda dapat mendekripsi dan mengembangkannya secara independen.
Saat Anda mengompres dan mengenkripsi file, pastikan untuk mengompres sebelum Anda mengenkripsi. Data yang dienkripsi dengan benar tidak dapat dikompresi.
**Awas**
Hati-hati saat mengompresi data yang mencakup rahasia dan data yang mungkin dikendalikan oleh aktor jahat. Ukuran akhir dari data terkompresi mungkin secara tidak sengaja mengungkapkan informasi sensitif tentang isinya.
------
#### [ Bash ]
```
# Continue running even if an operation fails.
set +e
dir=$1
encryptionContext=$2
s3bucket=$3
s3folder=$4
masterKeyProvider="aws-kms"
metadataOutput="/tmp/metadata-$(date +%s)"
compress(){
gzip -qf $1
}
encrypt(){
# -e encrypt
# -i input
# -o output
# --metadata-output unique file for metadata
# -m masterKey read from environment variable
# -c encryption context read from the second argument.
# -v be verbose
aws-encryption-cli -e -i ${1} -o $(dirname ${1}) --metadata-output ${metadataOutput} -m key="${masterKey}" provider="${masterKeyProvider}" -c "${encryptionContext}" -v
}
s3put (){
# copy file argument 1 to s3 location passed into the script.
aws s3 cp ${1} ${s3bucket}/${s3folder}
}
# Validate all required arguments are present.
if [ "${dir}" ] && [ "${encryptionContext}" ] && [ "${s3bucket}" ] && [ "${s3folder}" ] && [ "${masterKey}" ]; then
# Is $dir a valid directory?
test -d "${dir}"
if [ $? -ne 0 ]; then
echo "Input is not a directory; exiting"
exit 1
fi
# Iterate over all the files in the directory, except *gz and *encrypted (in case of a re-run).
for f in $(find ${dir} -type f \( -name "*" ! -name \*.gz ! -name \*encrypted \) ); do
echo "Working on $f"
compress ${f}
encrypt ${f}.gz
rm -f ${f}.gz
s3put ${f}.gz.encrypted
done;
else
echo "Arguments: "
echo " and ENV var \$masterKey must be set"
exit 255
fi
```
------
#### [ PowerShell ]
```
#Requires -Modules AWSPowerShell, Microsoft.PowerShell.Archive
Param
(
[Parameter(Mandatory)]
[ValidateScript({Test-Path $_})]
[String[]]
$FilePath,
[Parameter()]
[Switch]
$Recurse,
[Parameter(Mandatory=$true)]
[String]
$wrappingKeyID,
[Parameter()]
[String]
$masterKeyProvider = 'aws-kms',
[Parameter(Mandatory)]
[ValidateScript({Test-Path $_})]
[String]
$ZipDirectory,
[Parameter(Mandatory)]
[ValidateScript({Test-Path $_})]
[String]
$EncryptDirectory,
[Parameter()]
[String]
$EncryptionContext,
[Parameter(Mandatory)]
[ValidateScript({Test-Path $_})]
[String]
$MetadataDirectory,
[Parameter(Mandatory)]
[ValidateScript({Test-S3Bucket -BucketName $_})]
[String]
$S3Bucket,
[Parameter()]
[String]
$S3BucketFolder
)
BEGIN {}
PROCESS {
if ($files = dir $FilePath -Recurse:$Recurse)
{
# Step 1: Compress
foreach ($file in $files)
{
$fileName = $file.Name
try
{
Microsoft.PowerShell.Archive\Compress-Archive -Path $file.FullName -DestinationPath $ZipDirectory\$filename.zip
}
catch
{
Write-Error "Zip failed on $file.FullName"
}
# Step 2: Encrypt
if (-not (Test-Path "$ZipDirectory\$filename.zip"))
{
Write-Error "Cannot find zipped file: $ZipDirectory\$filename.zip"
}
else
{
# 2>&1 captures command output
$err = (aws-encryption-cli -e -i "$ZipDirectory\$filename.zip" `
-o $EncryptDirectory `
-m key=$wrappingKeyID provider=$masterKeyProvider `
-c $EncryptionContext `
--metadata-output $MetadataDirectory `
-v) 2>&1
# Check error status
if ($? -eq $false)
{
# Write the error
$err
}
elseif (Test-Path "$EncryptDirectory\$fileName.zip.encrypted")
{
# Step 3: Write to S3 bucket
if ($S3BucketFolder)
{
Write-S3Object -BucketName $S3Bucket -File "$EncryptDirectory\$fileName.zip.encrypted" -Key "$S3BucketFolder/$fileName.zip.encrypted"
}
else
{
Write-S3Object -BucketName $S3Bucket -File "$EncryptDirectory\$fileName.zip.encrypted"
}
}
}
}
}
}
```
------
## Menggunakan caching kunci data
Contoh ini menggunakan [caching kunci data](data-key-caching.md) dalam perintah yang mengenkripsi sejumlah besar file.
Secara default, CLI AWS Enkripsi (dan versi lain dari AWS Encryption SDK) menghasilkan kunci data unik untuk setiap file yang dienkripsi. Meskipun menggunakan kunci data unik untuk setiap operasi adalah praktik terbaik kriptografi, penggunaan kembali kunci data yang terbatas dapat diterima untuk beberapa situasi. Jika Anda mempertimbangkan caching kunci data, konsultasikan dengan insinyur keamanan untuk memahami persyaratan keamanan aplikasi Anda dan tentukan ambang keamanan yang tepat untuk Anda.
Dalam contoh ini, caching kunci data mempercepat operasi enkripsi dengan mengurangi frekuensi permintaan ke penyedia kunci master.
Perintah dalam contoh ini mengenkripsi direktori besar dengan beberapa subdirektori yang berisi total sekitar 800 file log kecil. Perintah pertama menyimpan ARN dari AWS KMS key dalam variabel. `keyARN` Perintah kedua mengenkripsi semua file dalam direktori input (rekursif) dan menulisnya ke direktori arsip. Perintah menggunakan `--suffix` parameter untuk menentukan `.archive` sufiks.
`--caching`Parameter memungkinkan caching kunci data. Atribut **kapasitas**, yang membatasi jumlah kunci data dalam cache, diatur ke 1, karena pemrosesan file serial tidak pernah menggunakan lebih dari satu kunci data pada satu waktu. Atribut **max\$1age**, yang menentukan berapa lama kunci data cache dapat digunakan, diatur ke 10 detik.
Atribut **max\$1messages\$1encrypted** opsional disetel ke 10 pesan, sehingga satu kunci data tidak pernah digunakan untuk mengenkripsi lebih dari 10 file. Membatasi jumlah file yang dienkripsi oleh setiap kunci data mengurangi jumlah file yang akan terpengaruh jika kunci data dikompromikan.
Untuk menjalankan perintah ini pada file log yang dihasilkan sistem operasi Anda, Anda mungkin memerlukan izin administrator (`sudo`di Linux; **Jalankan sebagai Administrator** di Windows).
------
#### [ Bash ]
```
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
$ aws-encryption-cli --encrypt \
--input /var/log/httpd --recursive \
--output ~/archive --suffix .archive \
--wrapping-keys key=$keyArn \
--encryption-context class=log \
--suppress-metadata \
--caching capacity=1 max_age=10 max_messages_encrypted=10
```
------
#### [ PowerShell ]
```
PS C:\> $keyARN = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
PS C:\> aws-encryption-cli --encrypt `
--input C:\Windows\Logs --recursive `
--output $home\Archive --suffix '.archive' `
--wrapping-keys key=$keyARN `
--encryption-context class=log `
--suppress-metadata `
--caching capacity=1 max_age=10 max_messages_encrypted=10
```
------
Untuk menguji efek caching kunci data, contoh ini menggunakan cmdlet [Measure-Command](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/measure-command) in. PowerShell Ketika Anda menjalankan contoh ini tanpa caching kunci data, dibutuhkan sekitar 25 detik untuk menyelesaikannya. Proses ini menghasilkan kunci data baru untuk setiap file dalam direktori.
```
PS C:\> Measure-Command {aws-encryption-cli --encrypt `
--input C:\Windows\Logs --recursive `
--output $home\Archive --suffix '.archive' `
--wrapping-keys key=$keyARN `
--encryption-context class=log `
--suppress-metadata }
Days : 0
Hours : 0
Minutes : 0
Seconds : 25
Milliseconds : 453
Ticks : 254531202
TotalDays : 0.000294596298611111
TotalHours : 0.00707031116666667
TotalMinutes : 0.42421867
TotalSeconds : 25.4531202
TotalMilliseconds : 25453.1202
```
Caching kunci data membuat proses lebih cepat, bahkan ketika Anda membatasi setiap kunci data hingga maksimal 10 file. Perintah sekarang membutuhkan waktu kurang dari 12 detik untuk menyelesaikan dan mengurangi jumlah panggilan ke penyedia kunci master menjadi 1/10 dari nilai aslinya.
```
PS C:\> Measure-Command {aws-encryption-cli --encrypt `
--input C:\Windows\Logs --recursive `
--output $home\Archive --suffix '.archive' `
--wrapping-keys key=$keyARN `
--encryption-context class=log `
--suppress-metadata `
--caching capacity=1 max_age=10 max_messages_encrypted=10}
Days : 0
Hours : 0
Minutes : 0
Seconds : 11
Milliseconds : 813
Ticks : 118132640
TotalDays : 0.000136727592592593
TotalHours : 0.00328146222222222
TotalMinutes : 0.196887733333333
TotalSeconds : 11.813264
TotalMilliseconds : 11813.264
```
Jika Anda menghilangkan `max_messages_encrypted` batasan, semua file dienkripsi di bawah kunci data yang sama. Perubahan ini meningkatkan risiko menggunakan kembali kunci data tanpa membuat proses lebih cepat. Namun, ini mengurangi jumlah panggilan ke penyedia kunci master menjadi 1.
```
PS C:\> Measure-Command {aws-encryption-cli --encrypt `
--input C:\Windows\Logs --recursive `
--output $home\Archive --suffix '.archive' `
--wrapping-keys key=$keyARN `
--encryption-context class=log `
--suppress-metadata `
--caching capacity=1 max_age=10}
Days : 0
Hours : 0
Minutes : 0
Seconds : 10
Milliseconds : 252
Ticks : 102523367
TotalDays : 0.000118661304398148
TotalHours : 0.00284787130555556
TotalMinutes : 0.170872278333333
TotalSeconds : 10.2523367
TotalMilliseconds : 10252.3367
```