Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esempi di CLI AWS di crittografia
Usa i seguenti esempi per provare la CLI di AWS crittografia sulla piattaforma che preferisci. Per assistenza sulle chiavi master e altri parametri, consulta [Come utilizzare la CLI AWS di crittografia](crypto-cli-how-to.md). Per un riferimento rapido, consulta [AWS Encryption SDK Sintassi CLI e riferimento ai parametri](crypto-cli-reference.md).
**Nota**
Gli esempi seguenti utilizzano la sintassi per AWS Encryption CLI versione 2.1. *x.*
Le nuove funzionalità di sicurezza sono state originariamente rilasciate nelle versioni 1.7 di AWS Encryption CLI. *x* e 2.0. *x*. Tuttavia, AWS Encryption CLI versione 1.8. *x* sostituisce la versione 1.7. *x* e AWS Encryption CLI 2.1. *x* sostituisce 2.0. *x.* Per i dettagli, [consulta l'avviso di sicurezza](https://github.com/aws/aws-encryption-sdk-cli/security/advisories/GHSA-2xwp-m7mq-7q3r) pertinente nel [aws-encryption-sdk-cli](https://github.com/aws/aws-encryption-sdk-cli/)repository su. GitHub
Per un esempio che mostra come utilizzare la funzionalità di sicurezza che limita le chiavi di dati crittografate, vedi. [Limitazione delle chiavi di dati crittografate](configure.md#config-limit-keys)
Per un esempio che mostra come utilizzare le chiavi AWS KMS multiregionali, vedi[Utilizzo di più regioni AWS KMS keys](configure.md#config-mrks).
**Topics**
+ [Crittografia di un file](#cli-example-encrypt-file)
+ [Decrittazione di un file](#cli-example-decrypt-file)
+ [Crittografia di tutti i file in una directory](#cli-example-encrypt-directory)
+ [Decrittazione di tutti i file in una directory](#cli-example-decrypt-directory)
+ [Crittografia e decrittazione nella riga di comando](#cli-example-stdin)
+ [Utilizzo di più chiavi master](#cli-example-multimaster)
+ [Crittografia e decrittazione negli script](#cli-example-script)
+ [Utilizzo del caching della chiave dei dati](#cli-example-caching)
## Crittografia di un file
Questo esempio utilizza l' AWS Encryption CLI per crittografare il contenuto del `hello.txt` file, che contiene una stringa «Hello World».
Quando si esegue un comando di crittografia su un file, la CLI di AWS crittografia ottiene il contenuto del file, genera una chiave [dati univoca](concepts.md#DEK), crittografa il contenuto del file sotto la chiave dati e quindi scrive [il messaggio crittografato](concepts.md#message) in un nuovo file.
Il primo comando salva la chiave ARN di an AWS KMS key nella `$keyArn` variabile. Quando si esegue la crittografia con un AWS KMS key, è possibile identificarlo utilizzando un ID chiave, un ARN della chiave, un nome alias o un alias ARN. *Per i dettagli sugli identificatori chiave per an AWS KMS key, consulta Identificatori [chiave](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) nella Guida per gli sviluppatori.AWS Key Management Service *
Il secondo comando crittografa il contenuto del file. Il comando utilizza il parametro `--encrypt` per specificare l'operazione e il parametro `--input` per indicare il file da crittografare. Il [`--wrapping-keys`parametro](crypto-cli-how-to.md#crypto-cli-master-key) e il relativo attributo **chiave** richiesto indicano al comando di utilizzare l' AWS KMS key ARN rappresentato dalla chiave ARN.
Il comando utilizza il parametro `--metadata-output` per specificare un file di testo per i metadati relativi all'operazione di crittografia. Come best practice, il comando utilizza il parametro `--encryption-context` per specificare un [contesto di crittografia](crypto-cli-how-to.md#crypto-cli-encryption-context).
Questo comando utilizza il [`--commitment-policy`parametro](crypto-cli-reference.md#syntax-commitment-policy) anche per impostare la politica di impegno in modo esplicito. Nella versione 1.8. *x*, questo parametro è obbligatorio quando si utilizza il `--wrapping-keys` parametro. A partire dalla versione 2.1. *x*, il `--commitment-policy` parametro è facoltativo, ma consigliato.
Il valore del parametro `--output`, un punto (.), consente al comando di scrivere il file di output nella directory corrente.
------
#### [ 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 .
```
------
Quando il comando di crittografia va a buon fine, non viene restituito alcun output. Per determinare se il comando è riuscito, controlla il valore Boolean nella variabile `$?`. Quando il comando ha esito positivo, il valore di `$?` è `0` (Bash) o `True` (PowerShell). Quando il comando fallisce, il valore di `$?` è diverso da zero (Bash) o (). `False` PowerShell
------
#### [ Bash ]
```
$ echo $?
0
```
------
#### [ PowerShell ]
```
PS C:\> $?
True
```
------
È inoltre possibile utilizzare un comando di elenco di directory per visualizzare se il comando di crittografia ha creato un nuovo file, `hello.txt.encrypted`. Poiché il comando encrypt non ha specificato un nome di file per l'output, la CLI di AWS crittografia ha scritto l'output in un file con lo stesso nome del file di input più `.encrypted` un suffisso. Per utilizzare un suffisso diverso o eliminarlo, utilizza il parametro `--suffix`.
Il file `hello.txt.encrypted` contiene un [messaggio crittografato](concepts.md#message) che include il testo cifrato del file `hello.txt`, una copia cifrata della chiave dei dati e metadati aggiuntivi, tra cui il contesto di crittografia.
------
#### [ 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
```
------
## Decrittazione di un file
Questo esempio utilizza l' AWS Encryption CLI per decrittografare il contenuto del `Hello.txt.encrypted` file crittografato nell'esempio precedente.
Il comando di decrittografia utilizza il parametro `--decrypt` per specificare l'operazione e il parametro `--input` per indicare il file da decrittografare. Il valore del parametro `--output` è un punto che rappresenta la directory attuale.
Il `--wrapping-keys` parametro con un attributo **key** specifica la chiave di wrapping utilizzata per decrittografare il messaggio crittografato. Nei comandi di decrittografia con AWS KMS keys, il valore dell'attributo chiave deve essere un [ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) di chiave. Il `--wrapping-keys` parametro è obbligatorio in un comando decrypt. Se si utilizza AWS KMS keys, è possibile utilizzare l'attributo **key** to specific AWS KMS keys for decrypting o l'attributo **discovery** con un valore pari a `true` (ma non entrambi). Se si utilizza un provider di chiavi master personalizzato, gli attributi **key** e **provider** sono obbligatori.
Il [`--commitment-policy`parametro](crypto-cli-reference.md#syntax-commitment-policy) è facoltativo a partire dalla versione 2.1. *x*, ma è consigliato. Usarlo esplicitamente rende chiaro l'intento, anche se si specifica il valore predefinito,. `require-encrypt-require-decrypt`
Il parametro `--encryption-context` è facoltativo nel comando di decrittografia, anche quando un [contesto di crittografia](crypto-cli-how-to.md#crypto-cli-encryption-context) viene fornito nel comando di crittografia. In questo caso, il comando di decrittografia usa lo stesso contesto di crittografia fornito nel relativo comando. Prima della decrittografia, l'Encryption AWS CLI verifica che il contesto di crittografia nel messaggio crittografato includa una coppia. `purpose=test` In caso contrario, il comando di decrittografia ha esito negativo.
Il parametro `--metadata-output` specifica un file di metadati per l'operazione di decrittografia. Il valore del parametro `--output`, un punto (.), scrive il file di output nella directory corrente.
Come procedura ottimale, utilizzate il `--max-encrypted-data-keys` parametro per evitare di decifrare un messaggio in formato errato con un numero eccessivo di chiavi di dati crittografate. Specificate il numero previsto di chiavi dati crittografate (una per ogni chiave di wrapping utilizzata nella crittografia) o un numero massimo ragionevole (ad esempio 5). Per informazioni dettagliate, vedi [Limitazione delle chiavi di dati crittografate](configure.md#config-limit-keys).
`--buffer`Restituisce il testo in chiaro solo dopo l'elaborazione di tutti gli input, inclusa la verifica della firma digitale, se presente.
------
#### [ 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 .
```
------
Quando un comando di decrittografia va a buon fine, non viene restituito alcun output. Per stabilire se il comando è riuscito, ottieni il valore della variabile `$?`. È inoltre possibile utilizzare un comando di elenco di directory per visualizzare se il comando ha creato un nuovo file con il suffisso `.decrypted`. Per vedere i contenuti di testo normale, utilizza un comando per ottenere il contenuto del file, ad esempio `cat` o [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
```
------
## Crittografia di tutti i file in una directory
Questo esempio utilizza l' AWS Encryption CLI per crittografare il contenuto di tutti i file in una directory.
Quando un comando influisce su più file, la CLI di AWS crittografia elabora ogni file singolarmente. Ottiene i contenuti dei file e una [chiave di dati](concepts.md#DEK) univoca per il file da una chiave master, crittografa i contenuti del file nella chiave dei dati e scrive i risultati in un nuovo file nella directory di output. Di conseguenza, è possibile decrittografare i file di output in modo indipendente.
Questo elenco della directory `TestDir` mostra i file di testo non crittografato che vogliamo crittografare.
------
#### [ 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
```
------
Il primo comando salva l'[Amazon Resource Name (ARN)](https://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html#find-cmk-id-arn) di un AWS KMS key nella `$keyArn` variabile.
Il secondo comando crittografa i contenuti dei file nella directory `TestDir` e scrive i file di contenuti crittografati nella directory `TestEnc`. Se la directory `TestEnc` non esiste, il comando ha esito negativo. Poiché la posizione di input è una directory, il parametro `--recursive` è obbligatorio.
Il [`--wrapping-keys`parametro](crypto-cli-how-to.md#crypto-cli-master-key) e l'attributo **chiave** richiesto specificano la chiave di wrapping da utilizzare. Il comando di crittografia include un [contesto di crittografia](crypto-cli-how-to.md#crypto-cli-encryption-context), `dept=IT`. Quando viene specificato un contesto di crittografia in un comando che crittografa più file, lo stesso contesto di crittografia viene utilizzato per tutti i file.
Il comando dispone anche di un `--metadata-output` parametro per indicare alla CLI di AWS crittografia dove scrivere i metadati sulle operazioni di crittografia. L' AWS Encryption CLI scrive un record di metadati per ogni file che è stato crittografato.
[`--commitment-policy parameter`](crypto-cli-how-to.md#crypto-cli-commitment-policy)È facoltativo a partire dalla versione 2.1. *x*, ma è consigliato. Se il comando o lo script fallisce perché non è in grado di decrittografare un testo cifrato, l'impostazione della politica di impegno esplicito potrebbe aiutare a rilevare rapidamente il problema.
Al termine del comando, la CLI di AWS crittografia scrive i file crittografati `TestEnc` nella directory, ma non restituisce alcun output.
Il comando finale elenca i file nella directory `TestEnc`. C'è un file di output di contenuti crittografati per ogni file di input di contenuti di testo non crittografato. Poiché il comando non ha specificato un altro suffisso, il comando di crittografia ha aggiunto `.encrypted` a ciascuno dei nomi dei file di 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
```
------
## Decrittazione di tutti i file in una directory
Questo esempio decrittografa tutti i file in una directory. Inizia con i file nella directory `TestEnc` che sono stati crittografati nell'esempio precedente.
------
#### [ 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
```
------
Questo comando decrypt decripta tutti i file nella TestEnc directory e scrive i file in chiaro nella directory. TestDec Il `--wrapping-keys` parametro con un attributo **chiave** e un valore [ARN della chiave](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) indica alla AWS CLI di crittografia quale utilizzare AWS KMS keys per decrittografare i file. Il comando utilizza il `--interactive` parametro per indicare alla CLI di AWS crittografia di richiedere all'utente una richiesta prima di sovrascrivere un file con lo stesso nome.
Questo comando utilizza inoltre il contesto di crittografia fornito quando i file sono stati crittografati. Quando si decifrano più file, l'Encryption AWS CLI controlla il contesto di crittografia di ogni file. Se il controllo del contesto di crittografia su un file non riesce, l' AWS Encryption CLI rifiuta il file, scrive un avviso, registra l'errore nei metadati e quindi continua a controllare i file rimanenti. Se la CLI di AWS crittografia non riesce a decrittografare un file per qualsiasi altro motivo, l'intero comando decrypt fallisce immediatamente.
In questo esempio, i messaggi crittografati in tutti i file di input contengono l'elemento del contesto di crittografia `dept=IT`. Tuttavia, se stai decrittografando messaggi con diversi contesti di crittografia, potresti comunque essere in grado di verificare parte del contesto di crittografia. Ad esempio, se alcuni messaggi avessero un contesto di crittografia di `dept=finance` e altri di `dept=IT`, potresti verificare che il contesto di crittografia contenga sempre un nome `dept` senza specificare il valore. Se volessi essere più specifico, potresti decrittografare i file in comandi distinti.
Il comando di decrittografia non restituisce alcun output, ma è possibile utilizzare un comando per visualizzare l'elenco delle directory e verificare se sono stati creati nuovi file con il suffisso `.decrypted`. Per vedere i contenuti di testo non crittografato, utilizza un comando per ottenere il contenuto del 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
```
------
## Crittografia e decrittazione nella riga di comando
Questi esempi illustrano come reindirizzare l'input per i comandi (stdin) e scrivere l'output nella riga di comando (stdout). Viene mostrato come rappresentare stdin e stdout in un comando e come utilizzare gli strumenti di codifica Base64 integrati per evitare che la shell interpreti non correttamente i caratteri non ASCII.
Questo esempio reindirizza una stringa di testo non crittografato a un comando di crittografia e salva il messaggio crittografato in una variabile. Quindi, reindirizza il messaggio crittografato nella variabile a un comando di decrittografia, che scrive l'output alla pipeline (stdout).
L'esempio è costituito da tre comandi:
+ Il primo comando salva la [chiave ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) di an AWS KMS key nella `$keyArn` variabile.
------
#### [ 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'
```
------
+ Il secondo comando reindirizza la stringa `Hello World` al comando di crittografia e salva il risultato nella variabile `$encrypted`.
I `--output` parametri `--input` and sono obbligatori in tutti i comandi della CLI di AWS crittografia. Per indicare che l'input è in fase di reindirizzamento al comando (stdin), utilizza un trattino (`-`) per il valore del parametro `--input`. Per inviare l'output alla riga di comando (stdout), utilizza un trattino per il valore del parametro `--output`.
Il parametro `--encode` codifica l'output con Base64 prima di restituirlo. In questo modo si impedisce alla shell di interpretare erroneamente i caratteri non ASCII nel messaggio crittografato.
Poiché questo comando è solo un proof of concept, abbiamo omesso il contesto di crittografia e soppresso i metadati (`-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
```
------
+ Il terzo comando reindirizza il messaggio crittografato nella variabile `$encrypted` al comando di decrittografia.
Questo comando di decrittografia utilizza `--input -` per indicare che l'input proviene dalla pipeline (stdin) e `--output -` per inviare l'output alla pipeline (stdout). (Il parametro di input richiede la posizione dell'input, non i byte effettivi dell'input, perciò non è possibile utilizzare la variabile `$encrypted` come valore del parametro `--input`).
Questo esempio utilizza l'attributo **discovery** del `--wrapping-keys` parametro per consentire alla CLI di AWS crittografia di utilizzare any AWS KMS key per decrittografare i dati. Non specifica una [politica di impegno](concepts.md#commitment-policy), quindi utilizza il valore predefinito per la versione 2.1. *x* e versioni successive,`require-encrypt-require-decrypt`.
Poiché l'output è stato crittografato e poi codificato, il comando di decrittografia utilizza il parametro `--decode` per decodificare l'input codificato con Base64 prima di decrittografarlo. È inoltre possibile utilizzare il parametro `--decode` per decodificare l'input codificato con Base64 prima di crittografarlo.
Come in precedenza, il comando omette il contesto di crittografia e sopprime i metadati (-`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
```
------
È inoltre possibile eseguire le operazioni di crittografia e decrittografia in un singolo comando senza l'intervento della variabile.
Come nell'esempio precedente, i parametri `--input` e `--output` hanno un valore `-` e il comando utilizza il parametro `--encode` per codificare l'output e il parametro `--decode` per decodificare l'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
```
------
## Utilizzo di più chiavi master
Questo esempio mostra come utilizzare più chiavi master per la crittografia e la decrittografia dei dati nella CLI di crittografia AWS .
Quando si utilizzano più chiavi master per crittografare i dati, una qualsiasi delle chiavi master può essere utilizzata per decrittografare i dati. Questa strategia garantisce che tu possa decrittografare i dati anche se una delle chiavi master non è disponibile. Se si archiviano i dati crittografati in più Regioni AWS, questa strategia consente di utilizzare una chiave master nella stessa regione per decrittografare i dati.
Quando esegui la crittografia con più chiavi master, la prima chiave master ricopre un ruolo speciale. Genera la chiave di dati utilizzata per crittografare i dati. Le restanti chiavi master crittografano la chiave dei dati di testo non crittografato. Il [messaggio crittografato](concepts.md#message) risultante include i dati crittografati e una raccolta di chiavi di dati crittografati, una per ciascuna chiave master. Anche se la prima chiave master ha generato la chiave dei dati, una delle chiavi master può decrittografare una delle chiavi dei dati, che può essere utilizzata per decrittografare i dati.
**Crittografia con tre chiavi master**
Questo comando di esempio utilizza tre chiavi di wrapping per crittografare il `Finance.log` file, una su tre. Regioni AWS
Scrive il messaggio crittografato nella directory `Archive`. Il comando utilizza il parametro `--suffix` con nessun valore per sopprimere il suffisso, in modo che i nomi dei file di input e di output saranno gli stessi.
Il comando utilizza il parametro `--wrapping-keys` con tre attributi della **chiave**. È inoltre possibile utilizzare più parametri `--wrapping-keys` nello stesso comando.
Per crittografare il file di registro, l' AWS Encryption CLI richiede alla prima chiave di wrapping dell'elenco `$key1` di generare la chiave dati che utilizza per crittografare i dati. Quindi, utilizza ciascuna delle altre chiavi di wrapping per crittografare una copia in testo semplice della stessa chiave di dati. Il messaggio crittografato nel file di output include tutte e tre le chiavi di dati crittografati.
------
#### [ 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
```
------
Questo comando decrittografa la copia crittografata del file `Finance.log` e la scrive su un file `Finance.log.clear` nella directory `Finance`. Per decrittografare i dati crittografati con meno di tre dati AWS KMS keys, puoi specificare gli stessi tre AWS KMS keys o qualsiasi sottoinsieme di essi. Questo esempio specifica solo uno dei. AWS KMS keys
Per indicare alla CLI di AWS crittografia quale utilizzare AWS KMS keys per decrittografare i dati, utilizza l'attributo **key del parametro**. `--wrapping-keys` Quando si decrittografa con AWS KMS keys, il valore dell'attributo **chiave** deve essere un [ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) chiave.
È necessario disporre dell'autorizzazione per chiamare l'[API Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) nel luogo specificato. AWS KMS keys Per ulteriori informazioni, consulta [Autenticazione e controllo degli accessi](https://docs.aws.amazon.com/kms/latest/developerguide/control-access.html) per. AWS KMS
Come procedura ottimale, in questi esempi viene utilizzato il `--max-encrypted-data-keys` parametro per evitare di decifrare un messaggio in formato errato con un numero eccessivo di chiavi di dati crittografate. Anche se questo esempio utilizza una sola chiave di wrapping per la decrittografia, il messaggio crittografato ha tre (3) chiavi dati crittografate, una per ciascuna delle tre chiavi di wrapping utilizzate durante la crittografia. Specificate il numero previsto di chiavi dati crittografate o un valore massimo ragionevole, ad esempio 5. Se si specifica un valore massimo inferiore a 3, il comando ha esito negativo. Per informazioni dettagliate, vedi [Limitazione delle chiavi di dati crittografate](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
```
------
## Crittografia e decrittazione negli script
Questo esempio mostra come utilizzare la CLI di AWS crittografia negli script. È possibile scrivere script solo per crittografare e decrittografare i dati o script che crittografano o decrittografano come parte di un processo di gestione dei dati.
In questo esempio, lo script ottiene una raccolta di file di log, li comprime, li crittografa e quindi copia i file crittografati in un bucket Amazon S3. Questo script elabora ciascun file separatamente, in modo che tu possa decrittografarli ed espanderli in modo indipendente.
Quando comprimi e crittografi i file, assicurati di eseguire la compressione prima della crittografia. I dati crittografati correttamente non sono comprimibili.
**avvertimento**
Fai attenzione durante la compressione dei dati, che include sia segreti sia dati che potrebbero essere controllati da malintenzionati. Le dimensioni finali dei dati compressi potrebbero inavvertitamente rivelare informazioni sensibili sui contenuti.
------
#### [ 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"
}
}
}
}
}
}
```
------
## Utilizzo del caching della chiave dei dati
Questo esempio utilizza il [caching della chiave dei dati](data-key-caching.md) in un comando che crittografa un numero elevato di file.
Per impostazione predefinita, l' AWS Encryption CLI (e altre versioni di AWS Encryption SDK) genera una chiave dati univoca per ogni file che crittografa. Anche se utilizzare una chiave di dati univoca per ciascuna operazione è una best practice crittografica, il riutilizzo limitato delle chiavi dei dati è accettabile in alcune situazioni. Se stai pensando al caching della chiave dei dati, consulta un ingegnere che si occupa di sicurezza per comprendere i requisiti di sicurezza dell'applicazione e stabilire le relative soglie per le tue esigenze.
In questo esempio, il caching della chiave dei dati velocizza l'operazione di crittografia riducendo la frequenza delle richieste al provider della chiave master.
Il comando in questo esempio crittografa una directory di grandi dimensioni con più sottodirectory che contengono un totale di circa 800 piccoli file di log. Il primo comando salva l'ARN della AWS KMS key in una variabile `keyARN`. Il secondo comando crittografa tutti i file nella directory di input (in modo ricorsivo) e li scrive in una directory di archivio. Il comando utilizza il parametro `--suffix` per specificare il suffisso `.archive`.
Il parametro `--caching` consente di eseguire il caching della chiave dei dati. L'attributo di **capacità**, che limita il numero di chiavi di dati nella cache, è impostato su 1, perché l'elaborazione dei file di serie non impiega mai più di una chiave di dati alla volta. L'attributo **max\$1age**, che stabilisce per quanto tempo è possibile utilizzare la chiave di dati memorizzati nella cache, è impostato su 10 secondi.
L'attributo opzionale **max\$1messages\$1encrypted** è impostato su 10 messaggi, perciò una singola chiave dei dati non viene mai utilizzata per crittografare più di 10 file. Limitando il numero di file crittografati da ciascuna chiave di dati si riduce il numero di file interessati nell'improbabile caso in cui una chiave di dati sia stata compromessa.
Per eseguire questo comando nei file di log generati dal tuo sistema operativo, potresti aver bisogno delle autorizzazioni da amministratore (`sudo` in Linux; **Esegui come amministratore** in 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
```
------
Per testare l'effetto della memorizzazione nella cache delle chiavi di dati, questo esempio utilizza il cmdlet [Measure-Command](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/measure-command) in. PowerShell Quando esegui questo esempio senza il caching della chiave dei dati, sono necessari circa 25 secondi per il completamento. Questo processo genera una nuova chiave di dati per ciascun file nella directory.
```
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
```
Il caching della chiave di dati rende il processo più rapido, anche quando limiti ogni chiave di dati a un massimo di 10 file. Il comando ora impiega meno di 12 secondi per il completamento e riduce il numero di chiamate al provider della chiave master a 1/10 del valore originale.
```
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
```
Se elimini la restrizione `max_messages_encrypted`, tutti i file sono crittografati con la stessa chiave dei dati. Questa modifica aumenta il rischio di riutilizzare le chiavi dei dati senza accelerare il processo. Tuttavia, riduce il numero di chiamate al provider di chiavi master a 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
```