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. Per un riferimento rapido, consulta AWS Encryption SDK Sintassi CLI e riferimento ai parametri.

Per un esempio che mostra come utilizzare la funzionalità di sicurezza che limita le chiavi di dati crittografate, vedi. Limitazione delle chiavi dati crittografate

Per un esempio che mostra come utilizzare le chiavi AWS KMS multiregionali, vediUtilizzo di più regioni AWS KMS keys.

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, crittografa il contenuto del file sotto la chiave dati e quindi scrive il messaggio crittografato 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 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-keysparametro 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.

Questo comando utilizza il --commitment-policyparametro 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 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 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-policyparametro è 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 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, consultare Limitazione delle chiavi dati crittografate.

--bufferRestituisce 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.

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 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) 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-keysparametro e l'attributo chiave richiesto specificano la chiave di wrapping da utilizzare. Il comando di crittografia include un contesto di crittografia, 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È 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 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:

È 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 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 chiave.

È necessario disporre dell'autorizzazione per chiamare l'API Decrypt nel luogo specificato. AWS KMS keys Per ulteriori informazioni, consulta Autenticazione e controllo degli accessi 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, consultare Limitazione delle chiavi dati crittografate.

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.

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: <Directory> <encryption context> <s3://bucketname> <s3 folder>"
    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 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_age, che stabilisce per quanto tempo è possibile utilizzare la chiave di dati memorizzati nella cache, è impostato su 10 secondi.

L'attributo opzionale max_messages_encrypted è 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 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