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à.
# AWS Encryption SDK interfaccia a riga di comando
L'interfaccia a riga di AWS Encryption SDK comando (CLI di AWS crittografia) consente di utilizzare la per crittografare e AWS Encryption SDK decrittografare i dati in modo interattivo nella riga di comando e negli script. Non è necessario avere competenze specifiche di crittografia o programmazione.
**Nota**
[Le versioni dell' AWS Encryption CLI precedenti alla 4.0.0 sono in fase di sviluppo. end-of-support](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle)
È possibile eseguire l'aggiornamento dalla versione 2.1 in tutta sicurezza. *x* e versioni successive alla versione più recente di AWS Encryption CLI senza modifiche al codice o ai dati. Tuttavia, nella versione 2.1 sono state introdotte [nuove funzionalità di sicurezza](about-versions.md#version-2). *x* non sono retrocompatibili. Per eseguire l'aggiornamento dalla versione 1.7. *x* o versioni precedenti, devi prima eseguire l'aggiornamento alla versione 1 più recente. versione *x* della CLI di AWS crittografia. Per informazioni dettagliate, vedi [Migrazione del tuo AWS Encryption SDK](migration.md).
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
Come tutte le implementazioni di AWS Encryption SDK, l' AWS Encryption CLI offre funzionalità avanzate di protezione dei dati. [Queste includono la [crittografia a busta](https://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/how-it-works.html#envelope-encryption), dati autenticati aggiuntivi (AAD) e [suite di algoritmi](https://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/supported-algorithms.html) a chiave simmetrica sicure, autenticate e simmetriche, come AES-GCM a 256 bit con derivazione delle chiavi, impegno delle chiavi e firma.](concepts.md#key-commitment)
L' AWS Encryption CLI è basata su [SDK di crittografia AWS per Python](python.md)ed è supportata su Linux, macOS e Windows. Puoi eseguire comandi e script per crittografare e decrittografare i tuoi dati nella tua shell preferita su Linux o macOS, in una finestra del prompt dei comandi (cmd.exe) su Windows e in una console su qualsiasi sistema. PowerShell
Tutte le implementazioni specifiche del linguaggio di, inclusa la AWS CLI di crittografia AWS Encryption SDK, sono interoperabili. Ad esempio, puoi crittografare i dati con [SDK di crittografia AWS per Java](java.md)e decrittografarli con l' AWS Encryption CLI.
Questo argomento introduce l' AWS Encryption CLI, spiega come installarla e utilizzarla e fornisce diversi esempi per aiutarti a iniziare. Per iniziare rapidamente, consulta [Come crittografare e decrittografare i dati con la AWS CLI di crittografia](https://aws.amazon.com/blogs/security/how-to-encrypt-and-decrypt-your-data-with-the-aws-encryption-cli/) nel blog sulla sicurezza. AWS Per informazioni più dettagliate, consulta [Read The Docs](https://aws-encryption-sdk-cli.readthedocs.io/en/latest/) e unisciti a noi nello sviluppo della CLI di AWS crittografia [aws-encryption-sdk-cli](https://github.com/aws/aws-encryption-sdk-cli/)nel repository su. GitHub
**Performance**
La CLI di AWS crittografia è basata su. SDK di crittografia AWS per Python Ogni volta che si esegue l'interfaccia a riga di comando, avvia una nuova istanza del runtime Python. Per migliorare le prestazioni, quando possibile, utilizzare un singolo comando anziché una serie di comandi indipendenti. Ad esempio, eseguire un comando che elabora i file in una directory in modo ricorsivo invece di eseguire comandi separati per ogni file.
**Topics**
+ [Installazione dell'interfaccia a riga di comando](crypto-cli-install.md)
+ [Come utilizzare l'interfaccia a riga di comando](crypto-cli-how-to.md)
+ [Esempi](crypto-cli-examples.md)
+ [Sintassi e riferimento parametri](crypto-cli-reference.md)
+ [Versioni](crypto-cli-versions.md)
# Installazione dell'interfaccia AWS Encryption SDK a riga di comando
Questo argomento spiega come installare la CLI di AWS crittografia. Per informazioni dettagliate, consulta il [aws-encryption-sdk-cli](https://github.com/aws/aws-encryption-sdk-cli/)repository su GitHub e [Leggi i documenti](https://aws-encryption-sdk-cli.readthedocs.io/en/latest/).
**Topics**
+ [
## Installazione dei prerequisiti
](#crypto-cli-prerequisites)
+ [Installazione dell'interfaccia a riga di comando](#install-sdk-cli)
## Installazione dei prerequisiti
La CLI di AWS crittografia è basata su. SDK di crittografia AWS per Python Per installare l' AWS Encryption CLI, sono necessari Python e lo strumento di gestione `pip` dei pacchetti Python. Python e `pip` sono disponibili su tutte le piattaforme supportate.
Installa i seguenti prerequisiti prima di installare la CLI di AWS crittografia,
**Python**
Python 3.8 o versioni successive è richiesto dalle versioni 4.2.0 e successive della AWS CLI di crittografia.
Le versioni precedenti di AWS Encryption CLI supportano Python 2.7 e 3.4 e versioni successive, ma consigliamo di utilizzare la versione più recente di Encryption CLI. AWS
Python è incluso nella maggior parte delle installazioni Linux e macOS, ma è necessario eseguire l'aggiornamento a Python 3.6 o versione successiva. Ti consigliamo di usare la versione più recente di Python. Su Windows, devi installare Python; non è installato di default. [Per scaricare e installare Python, vedi Python downloads.](https://www.python.org/downloads/)
Per stabilire se Python è installato, nella riga di comando, digita quanto segue.
```
python
```
Per verificare la versione di Python, utilizza il parametro `-V` (V maiuscola).
```
python -V
```
In Windows, dopo aver installato Python, aggiungi il percorso del `Python.exe` file al valore della variabile di ambiente **Path**.
Per impostazione predefinita, Python è installato nella directory di tutti gli utenti o in una directory profilo utente (`$home` o `%userprofile%`) nella sottodirectory `AppData\Local\Programs\Python`. Per trovare la posizione del file `Python.exe` nel sistema, verifica una delle seguenti chiavi di registro. Puoi usare PowerShell per cercare nel registro.
```
PS C:\> dir HKLM:\Software\Python\PythonCore\version\InstallPath
# -or-
PS C:\> dir HKCU:\Software\Python\PythonCore\version\InstallPath
```
**pip**
`pip` è il programma di gestione del pacchetto Python. Per installare la CLI di AWS crittografia e le relative dipendenze, è necessario `pip` 8.1 o versione successiva. Per semplificare l'installazione o l'aggiornamento di `pip`, consulta [Installazione](https://pip.pypa.io/en/latest/installing/) nella documentazione di `pip`.
Nelle installazioni Linux, le versioni `pip` precedenti alla 8.1 non possono creare la libreria di **crittografia richiesta** dall' AWS Encryption CLI. Se scegli di non aggiornare la tua `pip` versione, puoi installare gli strumenti di compilazione separatamente. Per ulteriori informazioni, consulta la sezione relativa alla [creazione di una crittografia in Linux](https://cryptography.io/en/latest/installation.html#building-cryptography-on-linux).
**AWS Command Line Interface**
Il AWS Command Line Interface (AWS CLI) è necessario solo se si utilizza AWS KMS keys in AWS Key Management Service (AWS KMS) con la CLI di AWS crittografia. Se si utilizza un [fornitore di chiavi master](concepts.md#master-key-provider) diverso, non AWS CLI è obbligatorio.
Per utilizzarlo AWS KMS keys con l' AWS Encryption CLI, è necessario [installare](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) e [configurare](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-quick-configuration). AWS CLI La configurazione rende AWS KMS disponibili le credenziali utilizzate per l'autenticazione alla AWS CLI di crittografia.
## Installazione e aggiornamento della CLI di AWS crittografia
Installa la versione più recente della CLI di AWS crittografia. [Quando si utilizza `pip` per installare l' AWS Encryption CLI, installa automaticamente le librerie necessarie alla CLI, inclusa la libreria di crittografia Python e [SDK di crittografia AWS per Python](python.md)la. [AWS SDK per Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)](https://cryptography.io/en/latest/)
**Nota**
[Le versioni dell' AWS Encryption CLI precedenti alla 4.0.0 sono in fase di sviluppo. end-of-support](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle)
È possibile eseguire l'aggiornamento dalla versione 2.1 in tutta sicurezza. *x* e versioni successive alla versione più recente di AWS Encryption CLI senza modifiche al codice o ai dati. Tuttavia, nella versione 2.1 sono state introdotte [nuove funzionalità di sicurezza](about-versions.md#version-2). *x* non sono retrocompatibili. Per eseguire l'aggiornamento dalla versione 1.7. *x* o precedente, devi prima eseguire l'aggiornamento alla versione 1 più recente. versione *x* della CLI di AWS crittografia. Per informazioni dettagliate, vedi [Migrazione del tuo AWS Encryption SDK](migration.md).
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 installare la versione più recente della CLI di AWS crittografia**
```
pip install aws-encryption-sdk-cli
```
**Per eseguire l'aggiornamento alla versione più recente della CLI di AWS crittografia**
```
pip install --upgrade aws-encryption-sdk-cli
```
**Per trovare i numeri di versione della tua CLI di AWS crittografia e AWS Encryption SDK**
```
aws-encryption-cli --version
```
L'output elenca i numeri di versione di entrambe le librerie.
```
aws-encryption-sdk-cli/2.1.0 aws-encryption-sdk/2.0.0
```
**Per eseguire l'aggiornamento alla versione più recente della CLI di AWS crittografia**
```
pip install --upgrade aws-encryption-sdk-cli
```
L'installazione della CLI di AWS crittografia installa anche la versione più recente di AWS SDK per Python (Boto3), se non è già installata. Se Boto3 è installato, il programma di installazione verifica la versione di Boto3 e la aggiorna se necessario.
**Per trovare la versione installata di Boto3**
```
pip show boto3
```
**Per eseguire l'aggiornamento alla versione più recente di Boto3**
```
pip install --upgrade boto3
```
Per installare la versione della CLI di AWS crittografia attualmente in fase di sviluppo, consulta il [aws-encryption-sdk-cli](https://github.com/aws/aws-encryption-sdk-cli/)repository su. GitHub
Per ulteriori dettagli sull'utilizzo di `pip` per installare e aggiornare i pacchetti Python, consulta la [documentazione relativa a pip](https://pip.pypa.io/en/stable/quickstart/).
# Come utilizzare la CLI AWS di crittografia
Questo argomento spiega come utilizzare i parametri nella CLI di AWS crittografia. Per alcuni esempi, consulta [Esempi di CLI AWS di crittografia](crypto-cli-examples.md). Per la documentazione completa, consulta [Leggi i documenti](https://aws-encryption-sdk-cli.readthedocs.io/en/latest/). La sintassi mostrata in questi esempi è per la versione 2.1 di AWS Encryption CLI. *x e versioni* successive.
**Nota**
[Le versioni dell' AWS Encryption CLI precedenti alla 4.0.0 sono in fase di sviluppo. end-of-support](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle)
È possibile eseguire l'aggiornamento dalla versione 2.1 in tutta sicurezza. *x* e versioni successive alla versione più recente di AWS Encryption CLI senza modifiche al codice o ai dati. Tuttavia, nella versione 2.1 sono state introdotte [nuove funzionalità di sicurezza](about-versions.md#version-2). *x* non sono retrocompatibili. Per eseguire l'aggiornamento dalla versione 1.7. *x* o precedente, devi prima eseguire l'aggiornamento alla versione 1 più recente. versione *x* della CLI di AWS crittografia. Per informazioni dettagliate, vedi [Migrazione del tuo AWS Encryption SDK](migration.md).
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**
+ [
## Come crittografare e decrittare i dati
](#crypto-cli-e-d-intro)
+ [
## Come specificare le chiavi di avvolgimento
](#crypto-cli-master-key)
+ [
## Come fornire l'input
](#crypto-cli-input)
+ [
## Come specificare la posizione dell'output
](#crypto-cli-output)
+ [
## Come utilizzare un contesto di crittografia
](#crypto-cli-encryption-context)
+ [
## Come specificare una politica di impegno
](#crypto-cli-commitment-policy)
+ [
## Come archiviare i parametri in un file di configurazione
](#crypto-cli-config-file)
## Come crittografare e decrittare i dati
L' AWS Encryption CLI utilizza le funzionalità di AWS Encryption SDK per semplificare la crittografia e la decrittografia dei dati in modo sicuro.
**Nota**
Il `--master-keys` parametro è obsoleto nella versione 1.8. *x* della AWS Encryption CLI e rimosso nella versione 2.1. *x.* Utilizza invece il parametro `--wrapping-keys`. A partire dalla versione 2.1. *x*, il `--wrapping-keys` parametro è necessario per la crittografia e la decrittografia. Per informazioni dettagliate, vedi [AWS Encryption SDK Sintassi CLI e riferimento ai parametri](crypto-cli-reference.md).
+ Quando si crittografano i dati nella CLI di AWS crittografia, si specificano i dati in testo non crittografato e [una chiave di wrapping](concepts.md#master-key) (*o chiave master*), ad esempio in (). AWS KMS key AWS Key Management Service AWS KMS Se si utilizza un provider di chiavi master personalizzato, è necessario specificare anche il provider. È inoltre possibile specificare i percorsi di output per il [messaggio crittografato](concepts.md#message) e per i metadati relativi all'operazione di crittografia. Un [contesto di crittografia](concepts.md#encryption-context) è opzionale, ma consigliato.
Nella versione 1.8. *x*, il `--commitment-policy` parametro è obbligatorio quando si utilizza il `--wrapping-keys` parametro; in caso contrario non è valido. A partire dalla versione 2.1. *x*, il `--commitment-policy` parametro è facoltativo, ma consigliato.
```
aws-encryption-cli --encrypt --input myPlaintextData \
--wrapping-keys key=1234abcd-12ab-34cd-56ef-1234567890ab \
--output myEncryptedMessage \
--metadata-output ~/metadata \
--encryption-context purpose=test \
--commitment-policy require-encrypt-require-decrypt
```
L' AWS Encryption CLI crittografa i tuoi dati con una chiave dati unica. Quindi crittografa la chiave dati con le chiavi di avvolgimento specificate. Restituisce un [messaggio crittografato](concepts.md#message) e i metadati relativi all'operazione. Il messaggio crittografato contiene i dati crittografati (*testo cifrato*) e una copia crittografata della chiave di dati. Non devi preoccuparti di archiviare, gestire o perdere la chiave di dati.
+ Quando esegui la decrittografia dei dati, passi il tuo messaggio crittografato, il contesto di crittografia opzionale e la posizione per l'output di testo non crittografato e i metadati. È inoltre necessario specificare le chiavi di wrapping che la CLI di AWS crittografia può utilizzare per decrittografare il messaggio o indicare alla CLI di AWS crittografia che può utilizzare qualsiasi chiave di wrapping che ha crittografato il messaggio.
A partire dalla versione 1.8. *x*, il `--wrapping-keys` parametro è facoltativo durante la decrittografia, ma consigliato. A partire dalla versione 2.1. *x*, il `--wrapping-keys` parametro è necessario per la crittografia e la decrittografia.
Durante la decrittografia, è possibile utilizzare l'attributo **key** del `--wrapping-keys` parametro per specificare le chiavi di wrapping che decrittografano i dati. La specificazione di una chiave di AWS KMS wrapping durante la decrittografia è facoltativa, ma è una [procedura consigliata](best-practices.md) che impedisce di utilizzare una chiave che non si intende utilizzare. Se utilizzi un provider di chiavi master personalizzato, devi specificare il provider e la chiave di wrapping.
Se non si utilizza l'attributo **key**, è necessario impostare l'[attributo **discovery**](#discovery-cli-attribute) del `--wrapping-keys` parametro su`true`, che consente alla CLI di crittografia di AWS decrittografia utilizzando qualsiasi chiave di wrapping che ha crittografato il messaggio.
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).
Il `--buffer` parametro restituisce testo in chiaro solo dopo l'elaborazione di tutti gli input, inclusa la verifica della firma digitale, se presente.
Il `--decrypt-unsigned` parametro decrittografa il testo cifrato e garantisce che i messaggi non siano firmati prima della decrittografia. Utilizzate questo parametro se avete utilizzato il `--algorithm` parametro e selezionato una suite di algoritmi senza firma digitale per crittografare i dati. Se il testo cifrato è firmato, la decrittografia non riesce.
È possibile utilizzare `--decrypt` o `--decrypt-unsigned` per la decrittografia, ma non entrambi.
```
aws-encryption-cli --decrypt --input myEncryptedMessage \
--wrapping-keys key=1234abcd-12ab-34cd-56ef-1234567890ab \
--output myPlaintextData \
--metadata-output ~/metadata \
--max-encrypted-data-keys 1 \
--buffer \
--encryption-context purpose=test \
--commitment-policy require-encrypt-require-decrypt
```
L' AWS Encryption CLI utilizza la chiave di wrapping per decrittografare la chiave dati nel messaggio crittografato. Quindi usa la chiave di dati per decrittografare i dati. Restituisce i tuoi dati di testo non crittografato e i metadati relativi all'operazione.
## Come specificare le chiavi di avvolgimento
Quando si crittografano i dati nella CLI di AWS crittografia, è necessario specificare almeno [una chiave di wrapping](concepts.md#master-key) (*o* chiave master). È possibile utilizzare AWS KMS keys in AWS Key Management Service (AWS KMS), avvolgere le chiavi di un [provider di chiavi master](concepts.md#master-key-provider) personalizzate o entrambe. Il provider di chiavi master personalizzato può essere qualsiasi provider di chiave master compatibile con Python.
Per specificare le chiavi di wrapping nelle versioni 1.8. *x* e versioni successive, utilizzate il `--wrapping-keys` parametro (`-w`). Il valore di questo parametro è una raccolta di [attributi](#cli-master-key-attributes) con il `attribute=value` formato. Gli attributi utilizzati dipendono dal provider di chiavi master e dal comando.
+ **AWS KMS**. Nei comandi di crittografia, è necessario specificare un `--wrapping-keys` parametro con un attributo **chiave**. A partire dalla versione 2.1. *x*, il `--wrapping-keys` parametro è richiesto anche nei comandi di decrittografia. Durante la decrittografia, il `--wrapping-keys` parametro deve avere un attributo **chiave** o un attributo **discovery** con un valore pari a `true` (ma non entrambi). Gli altri attributi sono facoltativi.
+ **Provider di chiavi master personalizzato**. È necessario specificare un `--wrapping-keys` parametro in ogni comando. Il valore di parametro deve avere gli attributi relativi a **chiave** e **provider**.
È possibile includere [più `--wrapping-keys` parametri](#cli-many-cmks) e più attributi **chiave** nello stesso comando.
### Confezionamento degli attributi dei parametri chiave
Il valore del parametro `--wrapping-keys` consiste nei seguenti attributi e nei loro rispettivi valori. Un `--wrapping-keys` parametro (o `--master-keys` parametro) è obbligatorio in tutti i comandi di crittografia. A partire dalla versione 2.1. *x*, il `--wrapping-keys` parametro è necessario anche per la decrittografia.
Se nel nome o nel valore di un attributo sono inclusi spazi o caratteri speciali, racchiudi il nome e il valore tra virgolette. Ad esempio, `--wrapping-keys key=12345 "provider=my cool provider"`.
**Chiave: Specificare una chiave di avvolgimento**
Usa l'attributo **key** per identificare una chiave di avvolgimento. Durante la crittografia, il valore può essere qualsiasi identificatore di chiave riconosciuto dal fornitore della chiave principale.
```
--wrapping-keys key=1234abcd-12ab-34cd-56ef-1234567890ab
```
In un comando encrypt, è necessario includere almeno un attributo e un valore **chiave**. **Per crittografare la chiave dati con più chiavi di wrapping, utilizza [più](#cli-many-cmks) attributi chiave.**
```
aws-encryption-cli --encrypt --wrapping-keys key=1234abcd-12ab-34cd-56ef-1234567890ab key=1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d
```
Nei comandi di crittografia che utilizzano AWS KMS keys, il valore della **chiave** può essere l'ID della chiave, l'ARN della chiave, un nome alias o l'alias ARN. Ad esempio, questo comando di crittografia utilizza un ARN alias nel valore dell'attributo della **chiave**. *Per i dettagli sugli identificatori di chiave per an AWS KMS key, consulta Identificatori di [chiave](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) nella Guida per gli sviluppatori.AWS Key Management Service *
```
aws-encryption-cli --encrypt --wrapping-keys key=arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias
```
Nei comandi di decrittografia che utilizzano un provider di chiavi master personalizzato, sono necessari gli attributi **chiave** e **provider**.
```
\\ Custom master key provider
aws-encryption-cli --decrypt --wrapping-keys provider='myProvider' key='100101'
```
Nei comandi di decrittografia che utilizzano AWS KMS, è possibile utilizzare l'attributo **key** per specificare l'attributo AWS KMS keys da utilizzare per la decrittografia o l'[attributo **discovery**](#discovery-cli-attribute) con un valore di`true`, che consente alla AWS CLI di crittografia di utilizzare qualsiasi AWS KMS key elemento utilizzato per crittografare il messaggio. Se si specifica un AWS KMS key, deve essere una delle chiavi di avvolgimento utilizzate per crittografare il messaggio.
[Specificare la chiave di avvolgimento è una procedura consigliata.AWS Encryption SDK](best-practices.md) Ti assicura di utilizzare quello che intendi AWS KMS key utilizzare.
In un comando decrypt, il valore dell'attributo **key** deve essere un [ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) chiave.
```
\\ AWS KMS key
aws-encryption-cli --decrypt --wrapping-keys key=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
```
**Discovery: usa any durante la decrittografia AWS KMS key **
Se non è necessario limitare l'utilizzo durante AWS KMS keys la decrittografia, è possibile utilizzare l'attributo **discovery** con un valore di. `true` Un valore di `true` consente alla CLI di AWS crittografia di decrittografare utilizzando qualsiasi elemento AWS KMS key che ha crittografato il messaggio. Se non si specifica un attributo di rilevamento, il **rilevamento** è `false` (impostazione predefinita). L'attributo **discovery** è valido solo nei comandi di decrittografia e solo quando il messaggio è stato crittografato con. AWS KMS keys
L'attributo **discovery** con un valore di `true` è un'alternativa all'utilizzo dell'attributo **key** per specificare. AWS KMS keys Quando si decrittografa un messaggio crittografato con AWS KMS keys, ogni `--wrapping-keys` parametro deve avere un attributo **chiave** o un attributo di **rilevamento** con un valore pari a`true`, ma non entrambi.
Quando l'individuazione è vera, è consigliabile utilizzare gli attributi **discovery-partition e **discovery-account**** per limitare l' AWS KMS keys utilizzo a quelli specificati. Account AWS Nell'esempio seguente, gli attributi di **rilevamento** consentono alla CLI di AWS crittografia di utilizzare qualsiasi elemento AWS KMS key specificato. Account AWS
```
aws-encryption-cli --decrypt --wrapping-keys \
discovery=true \
discovery-partition=aws \
discovery-account=111122223333 \
discovery-account=444455556666
```
**Provider: Specificare il fornitore della chiave principale**
L'attributo del **provider** identifica il [provider della chiave master](concepts.md#master-key-provider). Il valore predefinito è `aws-kms`, che rappresenta AWS KMS. Se stai usando un altro provider di chiavi master, è necessario utilizzare l'attributo **provider**.
```
--wrapping-keys key=12345 provider=my_custom_provider
```
Per ulteriori informazioni sull'utilizzo di provider di chiavi master personalizzati (non AWS KMS), **consultate l'argomento Configurazione avanzata** nel file [README](https://github.com/aws/aws-encryption-sdk-cli/blob/master/README.rst) per l'archivio [CLI di AWS crittografia](https://github.com/aws/aws-encryption-sdk-cli/).
**Regione: Specificare un Regione AWS**
Utilizza l'attributo **region** per specificare il Regione AWS di un AWS KMS key. Questo attributo è valido solo per i comandi di crittografia e solo quando il provider della chiave master è AWS KMS.
```
--encrypt --wrapping-keys key=alias/primary-key region=us-east-2
```
AWS I comandi CLI di crittografia utilizzano Regione AWS ciò che è specificato nel valore dell'attributo **chiave** se include una regione, ad esempio un ARN. se il valore della **chiave** specifica a Regione AWS, l'attributo **region** viene ignorato.
L'attributo della **regione** prevale su altre specifiche relative alle regioni. Se non si utilizza un attributo region, i comandi CLI di AWS crittografia utilizzano quello Regione AWS specificato nel [profilo AWS CLI denominato](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-using-profiles), se presente, o il profilo predefinito.
**Profilo: specifica un profilo denominato**
Utilizza l'attributo del **profilo** per specificare un AWS CLI profilo denominato[https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-using-profiles](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-using-profiles). I profili denominati possono includere credenziali e un. Regione AWS Questo attributo è valido solo quando il provider della chiave master è AWS KMS.
```
--wrapping-keys key=alias/primary-key profile=admin-1
```
È possibile utilizzare l'attributo del **profilo** per specificare credenziali alternative nei comandi di crittografia e decrittografia. In un comando encrypt, la CLI di AWS crittografia utilizza Regione AWS il profilo specificato solo quando il valore **della** chiave non include una regione e non **esiste** un attributo region. In un comando decrypt, il profilo Regione AWS in the name viene ignorato.
### Come specificare più chiavi di avvolgimento
È possibile specificare più chiavi di wrapping (o *chiavi master*) in ogni comando.
Se si specifica più di una chiave di wrapping, la prima chiave di wrapping genera e crittografa la chiave dati utilizzata per crittografare i dati. Le altre chiavi di wrapping crittografano la stessa chiave dati. Il [messaggio crittografato](concepts.md#message) risultante contiene i dati crittografati («ciphertext») e una raccolta di chiavi di dati crittografate, una crittografata da ciascuna chiave di wrapping. Qualsiasi involucro può decrittografare una chiave di dati crittografata e quindi decrittografare i dati.
Esistono due modi per specificare più chiavi di wrapping:
+ Includi più attributi **chiave** nel valore del `--wrapping-keys` parametro.
```
$key_oregon=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
$key_ohio=arn:aws:kms:us-east-2:111122223333:key/0987ab65-43cd-21ef-09ab-87654321cdef
--wrapping-keys key=$key_oregon key=$key_ohio
```
+ Includere molteplici parametri `--wrapping-keys` nello stesso comando. Utilizzate questa sintassi quando i valori degli attributi specificati non si applicano a tutte le chiavi di wrapping del comando.
```
--wrapping-keys region=us-east-2 key=alias/test_key \
--wrapping-keys region=us-west-1 key=alias/test_key
```
L'attributo **discovery** con un valore di `true` consente alla CLI di AWS crittografia di utilizzare qualsiasi attributo AWS KMS key che ha crittografato il messaggio. Se si utilizzano più `--wrapping-keys` parametri nello stesso comando, l'utilizzo `discovery=true` di qualsiasi `--wrapping-keys` parametro ha effettivamente la precedenza sui limiti dell'attributo **chiave negli altri** parametri. `--wrapping-keys`
Ad esempio, nel comando seguente, l'attributo **key** nel primo `--wrapping-keys` parametro limita la CLI di AWS crittografia al valore specificato. AWS KMS key Tuttavia, l'attributo **discovery** nel secondo `--wrapping-keys` parametro consente alla CLI di AWS crittografia di utilizzare uno qualsiasi AWS KMS key degli account specificati per decrittografare il messaggio.
```
aws-encryption-cli --decrypt \
--wrapping-keys key=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab \
--wrapping-keys discovery=true \
discovery-partition=aws \
discovery-account=111122223333 \
discovery-account=444455556666
```
## Come fornire l'input
[L'operazione di crittografia nella CLI di AWS crittografia accetta dati in testo semplice come input e restituisce un messaggio crittografato.](concepts.md#message) L'operazione di decrittografia richiede un messaggio crittografato come input e restituisce un dati di testo non crittografato.
Il `--input` parametro (`-i`), che indica all' AWS Encryption CLI dove trovare l'input, è richiesto in tutti i comandi Encryption AWS CLI.
Puoi fornire l'input in uno dei seguenti modi:
+ Utilizza un file.
```
--input myData.txt
```
+ Usa un modello di nome di file.
```
--input testdir/*.xml
```
+ Utilizza una directory o un modello di nome di directory. Quando l'input è una directory, il `--recursive` parametro (`-r`, `-R`) è obbligatorio.
```
--input testdir --recursive
```
+ Indirizza l'input al comando (stdin). Utilizza un valore di `-` per il parametro `--input`. (Il parametro `--input` è sempre obbligatorio).
```
echo 'Hello World' | aws-encryption-cli --encrypt --input -
```
## Come specificare la posizione dell'output
Il `--output` parametro indica alla CLI di AWS crittografia dove scrivere i risultati dell'operazione di crittografia o decrittografia. È richiesto in ogni comando CLI di AWS crittografia. La CLI di AWS crittografia crea un nuovo file di output per ogni file di input dell'operazione.
Se esiste già un file di output, per impostazione predefinita, la CLI di AWS crittografia stampa un avviso, quindi sovrascrive il file. Per evitare la sovrascrittura, utilizza il parametro `--interactive` che richiede la conferma prima di sovrascrivere oppure `--no-overwrite`, che salta l'input nel caso in cui l'output comporti una sovrascrittura. Per annullare l'avviso relativo alla sovrascrittura, utilizza `--quiet`. Per acquisire errori e avvisi dalla CLI di AWS crittografia, utilizzate `2>&1` l'operatore di reindirizzamento per scriverli nel flusso di output.
**Nota**
I comandi che sovrascrivano i file di output cominciano con l'eliminare il file di output. Se il comando ha esito negativo, il file di output potrebbe essere già stato eliminato.
Puoi modificare la posizione dell'output in diversi modi.
+ Specifica un nome di file. Se specifichi un percorso per il file, tutte le directory nel percorso devono esistere prima di eseguire il comando.
```
--output myEncryptedData.txt
```
+ Specifica una directory. La directory di output deve esistere prima di eseguire il comando.
Se l'input contiene sottodirectory, il comando riproduce le sottodirectory nella directory specificata.
```
--output Test
```
Quando la posizione di output è una directory (senza nomi di file), la CLI di AWS crittografia crea i nomi dei file di output in base ai nomi dei file di input più un suffisso. Le operazioni di crittografia aggiungono `.encrypted` al nome del file di input, mentre le operazioni di decrittografia aggiungono `.decrypted`. Per modificare il suffisso, utilizza il parametro `--suffix`.
Ad esempio, se esegui la crittografia `file.txt`, il comando di crittografia crea `file.txt.encrypted`. Se esegui la decrittografia `file.txt.encrypted`, il comando di decrittografia crea `file.txt.encrypted.decrypted`.
+ Scrivi nella riga di comando (stdout). Inserisci un valore di `-` per il parametro `--output`. È possibile utilizzare `--output -` per reindirizzare l'output a un altro comando o programma.
```
--output -
```
## Come utilizzare un contesto di crittografia
L' AWS Encryption CLI consente di fornire un contesto di crittografia nei comandi di crittografia e decrittografia. Non è necessario, ma è una best practice crittografica che ti consigliamo.
Un *contesto di crittografia* è rappresentato da tipi di *dati autenticati aggiuntivi* arbitrari e non segreti. Nella CLI di AWS crittografia, il contesto di crittografia è costituito da una raccolta di `name=value` coppie. È possibile utilizzare i contenuti nelle coppie, incluse le informazioni sui file, i dati che consentono di individuare le operazioni di crittografia nei log o i dati richiesti da concessioni e policy.
**In un comando di crittografia**
Il contesto di crittografia specificato in un comando di crittografia, insieme alle eventuali coppie aggiunte dal [CMM](concepts.md#crypt-materials-manager), è vincolato a livello crittografico ai dati crittografati. Inoltre è incluso (in testo normale) nel [messaggio crittografato](concepts.md#encryption-context) che il comando restituisce. Se si utilizza un AWS KMS key, il contesto di crittografia potrebbe anche apparire in testo semplice nei record e nei registri di controllo, ad esempio. AWS CloudTrail
L'esempio seguente mostra un contesto di crittografia con tre coppie `name=value`.
```
--encryption-context purpose=test dept=IT class=confidential
```
**In un comando di decrittazione**
In un comando di decrittografia, il contesto di crittografia consente di confermare che stai decrittografando il messaggio crittografato corretto.
Non devi fornire un contesto di crittografia in un comando di decrittografia, anche se, per crittografare, è stato usato un contesto di crittografia. Tuttavia, se lo fai, l' AWS Encryption CLI verifica che ogni elemento nel contesto di crittografia del comando decrypt corrisponda a un elemento nel contesto di crittografia del messaggio crittografato. Se non corrisponde alcun elemento, il comando di decrittografia ha esito negativo.
Ad esempio, il comando seguente decrittografa il messaggio crittografato solo se il relativo contesto di crittografia include `dept=IT`.
```
aws-encryption-cli --decrypt --encryption-context dept=IT ...
```
Un contesto di crittografia è una parte importante della tua strategia di sicurezza. Tuttavia, quando scegli un contesto di crittografia, ricordati che i suoi valori non sono segreti. Non includere dati riservati nel contesto di crittografia.
**Per specificare un contesto di crittografia**
+ In un comando di **crittografia**, utilizza il parametro `--encryption-context` con una o più coppie `name=value`. Utilizza uno spazio per separare ogni coppia.
```
--encryption-context name=value [name=value] ...
```
+ In un comando di **decrittografia**, il valore del parametro `--encryption-context` può includere coppie `name=value` , elementi `name` (senza valori) o una combinazione di entrambi.
```
--encryption-context name[=value] [name] [name=value] ...
```
Se `name` o `value` in una coppia `name=value` include spazi o caratteri speciali, racchiudi la coppia completa tra virgolette.
```
--encryption-context "department=software engineering" "Regione AWS=us-west-2"
```
Ad esempio, questo comando di crittografia include un contesto di crittografia con due coppie, `purpose=test` e `dept=23`.
```
aws-encryption-cli --encrypt --encryption-context purpose=test dept=23 ...
```
Questo comando di decrittografia avrebbe esito positivo. Il contesto di crittografia in ogni comando è un sottoinsieme del contesto di crittografia originale.
```
\\ Any one or both of the encryption context pairs
aws-encryption-cli --decrypt --encryption-context dept=23 ...
\\ Any one or both of the encryption context names
aws-encryption-cli --decrypt --encryption-context purpose ...
\\ Any combination of names and pairs
aws-encryption-cli --decrypt --encryption-context dept purpose=test ...
```
Tuttavia, questi comandi di decrittografia non avrebbero esito positivo. Il contesto di crittografia nel messaggio crittografato non contiene gli elementi specificati.
```
aws-encryption-cli --decrypt --encryption-context dept=Finance ...
aws-encryption-cli --decrypt --encryption-context scope ...
```
## Come specificare una politica di impegno
Per impostare la [politica di impegno](concepts.md#commitment-policy) per il comando, utilizzare il [`--commitment-policy`parametro](crypto-cli-reference.md#syntax-commitment-policy). Questo parametro è stato introdotto nella versione 1.8. *x*. È valido nei comandi di crittografia e decrittografia. La politica di impegno impostata è valida solo per il comando in cui viene visualizzata. Se non si imposta una politica di impegno per un comando, la CLI di AWS crittografia utilizza il valore predefinito.
Ad esempio, il seguente valore del parametro imposta la politica di impegno su`require-encrypt-allow-decrypt`, che crittografa sempre con l'impegno della chiave, ma decrittograferà un testo cifrato crittografato con o senza impegno di chiave.
```
--commitment-policy require-encrypt-allow-decrypt
```
## Come archiviare i parametri in un file di configurazione
È possibile risparmiare tempo ed evitare errori di digitazione salvando i parametri e i valori di AWS Encryption CLI utilizzati di frequente nei file di configurazione.
Un *file di configurazione* è un file di testo che contiene parametri e valori per un comando CLI di AWS crittografia. Quando si fa riferimento a un file di configurazione in un comando CLI di AWS crittografia, il riferimento viene sostituito dai parametri e dai valori nel file di configurazione. L'effetto è lo stesso se digitassi il contenuto del file nella riga di comando. Un file di configurazione può avere qualsiasi nome e può essere posizionato in qualsiasi directory a cui l'utente attuale può accedere.
Il seguente file di configurazione di esempio`key.conf`, ne specifica due AWS KMS keys in diverse regioni.
```
--wrapping-keys key=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
--wrapping-keys key=arn:aws:kms:us-east-2:111122223333:key/0987ab65-43cd-21ef-09ab-87654321cdef
```
Per utilizzare il file di configurazione in un comando, inserisci il prefisso con la chiocciola nel nome del file (`@`). In una PowerShell console, utilizzate un segno di spunta rovesciata per sfuggire al segno at (). ``@`
Questo comando di esempio utilizza il file `key.conf` in un comando di crittografia.
------
#### [ Bash ]
```
$ aws-encryption-cli -e @key.conf -i hello.txt -o testdir
```
------
#### [ PowerShell ]
```
PS C:\> aws-encryption-cli -e `@key.conf -i .\Hello.txt -o .\TestDir
```
------
**Regole dei file di configurazione**
Le regole per l'utilizzo di file di configurazione sono le seguenti:
+ È possibile includere più parametri in ogni file di configurazione ed elencarli in qualsiasi ordine. Elenca ciascun parametro con i relativi valori (se presenti) su una riga separata.
+ Utilizza `#` per aggiungere un commento a tutta o a una parte di una riga.
+ È possibile includere riferimenti ad altri file di configurazione. Non usate il segno di spunta contro il segno di spunta per sfuggire al `@` segno, nemmeno dentro. PowerShell
+ Se utilizzi le virgolette in un file di configurazione, tale testo non può estendersi su più righe.
Ad esempio, questo è il contenuto di un file `encrypt.conf` di esempio.
```
# Archive Files
--encrypt
--output /archive/logs
--recursive
--interactive
--encryption-context class=unclassified dept=IT
--suffix # No suffix
--metadata-output ~/metadata
@caching.conf # Use limited caching
```
È inoltre possibile includere più file di configurazione in un comando. In questo esempio il comando utilizza entrambi i file di configurazione `encrypt.conf` e `master-keys.conf`.
------
#### [ Bash ]
```
$ aws-encryption-cli -i /usr/logs @encrypt.conf @master-keys.conf
```
------
#### [ PowerShell ]
```
PS C:\> aws-encryption-cli -i $home\Test\*.log `@encrypt.conf `@master-keys.conf
```
------
**Prossimo:** [Prova gli esempi della CLI di AWS crittografia](crypto-cli-examples.md)
# 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
```
# AWS Encryption SDK Sintassi CLI e riferimento ai parametri
Questo argomento fornisce diagrammi di sintassi e brevi descrizioni dei parametri per aiutarti a utilizzare l'interfaccia a riga di comando (CLI) AWS Encryption SDK . Per informazioni su come inserire chiavi e altri parametri, consulta. [Come utilizzare la CLI AWS di crittografia](crypto-cli-how-to.md) Per alcuni esempi, consulta [Esempi di CLI AWS di crittografia](crypto-cli-examples.md). Per la documentazione completa, consulta [Leggi i documenti](https://aws-encryption-sdk-cli.readthedocs.io/en/latest/).
**Topics**
+ [
## AWS Sintassi CLI di crittografia
](#crypto-cli-syntax)
+ [
## AWS Parametri della riga di comando CLI di crittografia
](#crypto-cli-parameters)
+ [
## Parametri avanzati
](#cli-advanced-parameters)
## AWS Sintassi CLI di crittografia
Questi diagrammi di sintassi della CLI di AWS crittografia mostrano la sintassi per ogni attività eseguita con la CLI di crittografia. AWS Rappresentano la sintassi consigliata nella versione 2.1 di AWS Encryption CLI. *x e versioni* successive.
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
**Nota**
A meno che non sia indicato nella descrizione del parametro, ogni parametro o attributo può essere utilizzato una sola volta in ogni comando.
Se si utilizza un attributo non supportato da un parametro, l' AWS Encryption CLI ignora tale attributo non supportato senza un avviso o un errore.
**Chiedere aiuto**
Per ottenere la sintassi CLI di AWS crittografia completa con le descrizioni dei parametri, usa o. `--help` `-h`
```
aws-encryption-cli (--help | -h)
```
**Ottenere la versione**
Per ottenere il numero di versione dell'installazione della CLI di AWS crittografia, utilizzare. `--version` Assicurati di includere la versione quando fai domande, segnali problemi o condividi suggerimenti sull'uso della CLI di AWS crittografia.
```
aws-encryption-cli --version
```
**Crittografare i dati**
Il seguente diagramma di sintassi mostra i parametri utilizzati da un comando **encrypt**.
```
aws-encryption-cli --encrypt
--input [--recursive] [--decode]
--output