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 diAWSCLI di crittografia

Utilizza i seguenti esempi per provareAWSCLI di crittografia sulla piattaforma che preferisci. Per assistenza sulle chiavi master e altri parametri, consulta Come usare la CLI di AWS crittografia. Per un riferimento rapido, consulta Sintassi e riferimento parametri dell'interfaccia a riga di comando AWS Encryption SDK.

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

Per un esempio che mostra come usareAWS KMSChiavi multiregione, consultaUtilizzo di più regioni AWS KMS keys.

Crittografia di un file

In questo esempio viene utilizzato ilAWSCLI di crittografia per crittografare il contenuto delhello.txt, che contiene una stringa «Hello World».

Quando si esegue un comando di crittografia su un file,AWSLa CLI di crittografia ottiene il contenuto del file, genera un unicochiave di dati, crittografa il contenuto del file sotto la chiave dati e quindi scrive ilmessaggio crittografatosu un nuovo file.

Il primo comando salva la chiave ARN di unaAWS KMS keynella$keyArnvariabile. Quando si crittografa con unAWS KMS key, puoi identificarlo utilizzando un ID chiave, una chiave ARN, un nome dell'alias o un ARN di alias. Per informazioni dettagliateAWS KMS key, consultaIdentificatori chiavenellaAWS Key Management ServiceGuida per gli sviluppatori.

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 parametro --wrapping-keys e l'attributo della chiave obbligatorio, comunicano al comando di utilizzare la AWS KMS key rappresentata dall'ARN di chiave.

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 anche il--commitment-policyparametroper definire esplicitamente la politica di impegno. Nella versione 1.8.x, questo parametro è obbligatorio quando si utilizza--wrapping-keysParametro . A partire dalla versione 2.1.x, il--commitment-policyparametro opzionale, 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) oTrue(PowerShell). Quando il comando non riesce, il valore di$?è diverso da zero (Bash) oFalse(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 di crittografia non ha specificato un nome di file per l'output,AWSLa CLI di crittografia ha scritto l'output su un file con lo stesso nome del file di input più un.encryptedsuffisso. 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

In questo esempio viene utilizzato ilAWSCLI di crittografia per decrittografare il contenuto delHello.txt.encryptedfile 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.

La--wrapping-keysparametro con achiaveattributo specifica la chiave di wrapping utilizzata per decrittografare il messaggio crittografato. Nel decrittografare i comandi conAWS KMS keys, il valore dell'attributo chiave deve essere unARN della chiave. La--wrapping-keysIl parametro è obbligatorio in un comando di decrittografia. Se stai usandoAWS KMS keysè possibile utilizzare l'chiaveattributo da specificareAWS KMS keysper decrittografare oscopertaattributo con un valore ditrue(ma non entrambi). Se stai utilizzando un provider di chiave master personalizzato,chiaveefornitoreGli attributi sono obbligatori.

La--commitment-policyparametroè opzionale a partire dalla versione 2.1.xma è il valore consigliato. Il suo utilizzo rende esplicitamente chiaro il tuo intento, anche se specifichi 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 di decrittografare, ilAWSLa CLI di crittografia verifica che il contesto di crittografia nel messaggio crittografato includa unapurpose=testcoppia. 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 best practice, utilizzare l'--max-encrypted-data-keysparametro per evitare di decrittografare un messaggio malformato con un numero eccessivo di chiavi dati crittografate. Specificare il numero previsto di chiavi dati crittografate (una per ogni chiave di wrapping utilizzata nella crittografia) o un massimo ragionevole (ad esempio 5). Per dettagli, consultare Limitazione delle chiavi di dati crittografate.

La--bufferrestituisce testo semplice 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

In questo esempio viene utilizzato ilAWSCLI di crittografia per crittografare i contenuti di tutti i file in una directory.

Quando un comando influisce su più file,AWSLa crittografia CLI elabora ogni file individualmente. 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 ilAmazon Resource Name (ARN)di unAWS KMS keynella$keyArnvariabile.

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.

La--wrapping-keysparametro, e la sua richiestachiaveattributo, specificare la chiave di avvolgimento 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 ha anche un--metadata-outputparametro per dire alAWSCLI di crittografia dove scrivere i metadati sulle operazioni di crittografia. LaAWSLa CLI di crittografia scrive un record di metadati per ogni file crittografato.

La--commitment-policy parameterè opzionale a partire dalla versione 2.1.xma è il valore consigliato. Se il comando o lo script non riesce perché non è in grado di decrittografare un testo cifrato, l'impostazione esplicita del criterio di impegno potrebbe aiutarti a rilevare rapidamente il problema.

Quando il comando viene completato, l'AWSLa CLI di crittografia scrive i file crittografati sulTestEncdirectory, 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 decrittografa tutti i file nellaTestEncdirectory e scrive i file di testo normale nellaTestDecdirectory. La--wrapping-keysparametro con achiaveattributo eARN della chiaveil valore dice ilAWSCLI di crittografia cheAWS KMS keysda utilizzare per decrittografare i file. Il comando utilizza l'--interactiveparametro per dire alAWSCLI di crittografia per richiedere l'utente 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 esegui la decrittografia di più file,AWSLa CLI di crittografia verifica il contesto di crittografia di ogni file. Se il controllo del contesto di crittografia su qualsiasi file non riesce,AWSLa CLI di crittografia rifiuta il file, scrive un avviso, registra l'errore nei metadati, quindi continua a verificare gli altri file. Se il fileAWSLa CLI di crittografia non riesce a decrittografare un file per qualsiasi altro motivo, l'intero comando di decrittografia ha esito negativo 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ù tasti master

Questo esempio illustra come utilizzare più chiavi master per crittografare e decrittografare i dati nellaAWSCLI di crittografia.

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 memorizzano i dati crittografati in piùRegioni AWS, questa strategia ti 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 ilFinance.logfile, uno su treRegioni 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,AWSLa CLI di crittografia chiede la prima chiave di wrapping nell'elenco,$key1, per generare la chiave di dati utilizzata per crittografare i dati. Quindi, utilizza ognuna delle altre chiavi di wrapping per crittografare una copia non crittografata 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 sotto i treAWS KMS keys, è possibile specificare gli stessi treAWS KMS keyso qualsiasi sottoinsieme di essi. Questo esempio specifica uno deiAWS KMS keys.

Per raccontare ilAWSCLI di crittografia cheAWS KMS keysutilizzare per decrittografare i dati, utilizzare l'chiaveattributo del--wrapping-keysParametro . Quando esegui la decrittografia conAWS KMS keys, il valore delchiaveattributo deve essere unARN della chiave.

Devi disporre dell'autorizzazione per chiamare ilDecrittografare l'APIsulAWS KMS keysspecificate. Per ulteriori informazioni, consultaAutenticazione e controllo degli accessi perAWS KMS.

Come best practice, questi esempi utilizzano--max-encrypted-data-keysparametro per evitare di decrittografare un messaggio malformato con un numero eccessivo di chiavi dati crittografate. Anche se questo esempio utilizza una sola chiave 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. Specificare 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 dettagli, consultare Limitazione delle chiavi di 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

In questo esempio viene illustrato come utilizzare l'AWSCLI di 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, 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, ilAWSCLI di crittografia (e altre versioni delAWS Encryption SDK) genera una chiave di 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 verificare l'effetto della cache delle chiavi di dati, questo esempio utilizzaMisura-comandocmdlet inPowerShell. 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