Ejemplos de la CLI de cifrado del AWS - AWS Encryption SDK
Cifrado de un archivoDescifrado de un archivoCifrado de todos los archivos de un directorioDescifrado de todos los archivos de un directorioCifrado y descifrado en la línea de comandosUso de varias claves maestrasCifrado y descifrado en scriptsUso del almacenamiento en caché de claves de datos

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Ejemplos de la CLI de cifrado del AWS

Utilice los siguientes ejemplos para probar la CLI de cifrado del AWS en la plataforma que prefiera. Para obtener ayuda con las claves maestras y otros parámetros, consulte Cómo utilizar la CLI de cifrado del AWS. Para obtener rápidamente información de referencia, consulte Referencia de sintaxis y parámetros de la CLI del AWS Encryption SDK.

nota

Los siguientes ejemplos utilizan la sintaxis de la versión 2.1.x de la CLI de cifrado del AWS.

Las nuevas funciones de seguridad se publicaron originalmente en las versiones 1.7.x y 2.0.x. de la CLI de cifrado del AWS. Sin embargo, la versión 1.8.x de la CLI de cifrado de AWS reemplaza a la versión 1.7.x y la versión 2.1.x de la CLI de cifrado de AWS reemplaza a la 2.0.x. Para obtener más información, consulte el aviso de seguridad correspondiente en el repositorio aws-encryption-sdk-cli en GitHub.

Para ver un ejemplo que muestra cómo usar la característica de seguridad que limita las claves de datos cifrados, consulte Limitar las claves de datos cifrados.

Para ver un ejemplo que muestra cómo utilizar claves multirregionales de AWS KMS, consulte Uso de varias regiones AWS KMS keys.

Cifrado de un archivo

En este ejemplo, se utiliza la CLI de cifrado del AWS para cifrar el contenido del archivo hello.txt, que contiene una cadena "Hello World".

Cuando se ejecuta un comando de cifrado en un archivo, la CLI de cifrado del AWS obtiene el contenido del archivo, genera una clave de datos única, cifra el contenido del archivo con la clave de datos y, a continuación, escribe el mensaje cifrado en otro archivo.

El primer comando guarda el ARN de un AWS KMS key en una variable $keyArn. Al cifrar con un AWS KMS key, puede identificarlo mediante el ID de la clave, el ARN de clave, el nombre de alias o el ARN del alias. Para obtener más información sobre los identificadores de clave de un AWS KMS key, consulte Identificadores de clave en la Guía para desarrolladores de AWS Key Management Service.

El segundo comando cifra el contenido del archivo. El comando utiliza el parámetro --encrypt para especificar la operación y el parámetro --input para indicar el archivo que se ha de cifrar. El parámetro --wrapping-keys y su atributo key obligatorio indican al comando que debe usar la AWS KMS key representada por el ARN de la clave.

El comando utiliza el parámetro --metadata-output para especificar un archivo de texto para los metadatos acerca de la operación de cifrado. El comando aplica la práctica recomendada de utilizar el parámetro --encryption-context para especificar un contexto de cifrado.

Este comando también usa el parámetro --commitment-policy para establecer la política de compromiso de forma explícita. En la versión 1.8.x, se requiere este parámetro cuando usa el parámetro --wrapping-keys. En la versión 2.1.x, el parámetro --commitment-policy es opcional, pero se recomienda.

El valor del parámetro --output, un punto (.), indica al comando que escriba el archivo de salida en el directorio actual.

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 .

Cuando el comando de cifrado se ejecuta correctamente, no devuelve ningún resultado. Para determinar si el comando se ha ejecutado correctamente, consulte el valor booleano de la variable $?. Cuando el comando se ejecuta correctamente, el valor de $? es 0 (Bash) o True (PowerShell). Cuando el comando no se ejecuta correctamente, el valor de $? es distinto de cero (Bash) o False (PowerShell).

Bash
$ echo $?
0
PowerShell
PS C:\> $?
True

También puede utilizar un comando de lista de directorios para comprobar que el comando de cifrado ha creado un archivo nuevo, hello.txt.encrypted. Dado que el comando de cifrado no ha especificado el nombre de archivo del resultado, la CLI de cifrado del AWS escribió el resultado en un archivo con el mismo nombre que el archivo de entrada seguido del sufijo .encrypted. Si desea utilizar un sufijo diferente o suprimir el sufijo, utilice el parámetro --suffix.

El archivo hello.txt.encrypted contiene un mensaje cifrado que incluye el texto cifrado del archivo hello.txt, una copia cifrada de la clave de datos y metadatos adicionales, incluido el contexto de cifrado.

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

Descifrado de un archivo

En este ejemplo se utiliza la CLI de cifrado del AWS para descifrar el contenido del archivo Hello.txt.encrypted que se cifró en el ejemplo anterior.

El comando de descifrado utiliza el parámetro --decrypt para indicar la operación y el parámetro --input para identificar el archivo que se ha de descifrar. El valor del parámetro --output es un punto que representa el directorio actual.

El parámetro --wrapping-keys con un atributo key especifica la clave de empaquetado que se utiliza para descifrar el mensaje cifrado. En los comandos de descifrado con AWS KMS keys, el valor del atributo key debe ser un ARN de clave. El parámetro --wrapping-keys es obligatorio en un comando de descifrado. Si usa AWS KMS keys, puede usar el atributo key para especificar AWS KMS keys para descifrar o el atributo discovery con un valor de true (pero no ambos). Si utiliza un proveedor de claves maestras personalizado, los atributos key y provider son obligatorios.

El parámetro --commitment-policy es opcional a partir de la versión 2.1.x, pero se recomienda. Su uso explícito deja clara su intención, incluso si especifica el valor predeterminado, require-encrypt-require-decrypt.

El parámetro --encryption-context es opcional en el comando de descifrado, incluso cuando se proporciona un contexto de cifrado en el comando de cifrado. En este caso, el comando de descifrado utiliza el mismo contexto de cifrado que se proporcionó en el comando de cifrado. Antes del descifrado, la CLI de cifrado del AWS verifica que el contexto de cifrado del mensaje cifrado incluya un par purpose=test. En caso contrario, el comando de descifrado genera un error.

El parámetro --metadata-output especifica un archivo para los metadatos relativos a la operación de descifrado. El valor del parámetro --output, un punto (.), escribe el archivo de salida en el directorio actual.

Como práctica recomendada, utilice el parámetro --max-encrypted-data-keys para evitar descifrar un mensaje mal formado con un número excesivo de claves de datos cifradas. Especifique el número esperado de claves de datos cifrados (una por cada clave de empaquetado utilizada en el cifrado) o un máximo razonable (por ejemplo, 5). Para obtener más información, consulte Limitar las claves de datos cifrados.

El --buffer devuelve el texto no cifrado solo después de procesar todas las entradas, incluida la verificación de la firma digital, si existe alguna.

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 .

Cuando el comando de descifrado se ejecuta correctamente, no devuelve ningún resultado. Para determinar si el comando se ha ejecutado correctamente, obtenga el valor de la variable $?. También puede utilizar un comando de lista de directorios para comprobar que el comando de descifrado ha creado un archivo nuevo con el sufijo .decrypted. Para ver el contenido de texto no cifrado, utilice un comando para obtener el contenido del archivo (por ejemplo, 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

Cifrado de todos los archivos de un directorio

En este ejemplo se utiliza la CLI de cifrado del AWS para cifrar el contenido de todos los archivos de un directorio.

Cuando un comando afecta a varios archivos, la CLI de cifrado del AWS procesa cada uno de ellos de manera individual. Obtiene el contenido del archivo, obtiene una clave de datos única para el archivo a partir de la clave maestra, cifra el contenido del archivo con la clave de datos y escribe los resultados en un archivo nuevo en el directorio de salida. Por lo tanto, los archivos de salida se pueden descifrar de manera independiente.

Esta lista del directorio TestDir muestra los archivos de texto no cifrado que deseamos cifrar.

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

El primer comando guarda el nombre de recurso de Amazon (ARN) de una AWS KMS key en la variable $keyArn.

El segundo comando cifra el contenido de los archivos en el directorio TestDir y escribe los archivos con el contenido cifrado en el directorio TestEnc. Si el directorio TestEnc no existe, el comando genera un error. Dado que la ubicación de entrada es un directorio, el parámetro --recursive es obligatorio.

El parámetro --wrapping-keys y su atributo key obligatorio especifican la clave de empaquetado para utilizar. El comando de cifrado incluye un contexto de cifrado, dept=IT. Cuando especifique un contexto de cifrado en un comando que cifre varios archivos, se utilizará el mismo contexto de cifrado para todos ellos.

El comando también tiene un parámetro --metadata-output para indicar a la CLI de cifrado del AWS dónde escribir los metadatos relativos a las operaciones de cifrado. La CLI de cifrado del AWS escribe un registro de metadatos por cada archivo que se cifró.

El --commitment-policy parameter es opcional a partir de la versión 2.1.x, pero se recomienda. Si el comando o el script fallan porque no pueden descifrar un texto cifrado, la configuración explícita de la política de compromiso puede ayudarle a detectar el problema rápidamente.

Cuando se completa el comando, la CLI de cifrado del AWS escribe los archivos cifrados en el directorio TestEnc, pero no devuelve ningún resultado.

El último comando muestra los archivos en el directorio TestEnc. Hay un archivo de salida de contenido cifrado por cada archivo de entrada de contenido de texto no cifrado. Dado que el comando no ha especificado un sufijo alternativo, el comando de cifrado ha agregado .encrypted al nombre de cada archivo de entrada.

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

Descifrado de todos los archivos de un directorio

Este ejemplo descifra todos los archivos de un directorio. Comienza por los archivos del directorio TestEnc que se han cifrado en el ejemplo anterior.

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

Este comando de descifrado descifra todos los archivos del directorio TestEnc y escribe los archivos de texto no cifrado en el directorio TestDec. El parámetro --wrapping-keys con un atributo key y un valor de ARN de clave indica a la CLI de cifrado del AWS qué AWS KMS keys se debe utilizar para descifrar los archivos. El comando utiliza el parámetro --interactive para indicar a la CLI de cifrado del AWS que le pregunte antes de sobrescribir un archivo con el mismo nombre.

Este comando también utiliza el contexto de cifrado que se proporcionó al cifrar los archivos. Cuando se descifran varios archivos, la CLI de cifrado del AWS comprueba el contexto de cifrado de cada archivo. Si la comprobación del contexto de cifrado no se lleva cabo correctamente en cualquier archivo, la CLI de cifrado del AWS rechaza el archivo, escribe una advertencia, registra el error en los metadatos y, a continuación, sigue comprobando el resto de los archivos. Si la CLI de cifrado del AWS no consigue descifrar un archivo por cualquier otro motivo, el comando de descifrado en su conjunto produce un error de forma inmediata.

En este ejemplo, los mensajes cifrados de todos los archivos de entrada contienen el elemento de contexto de cifrado dept=IT. Sin embargo, si va a descifrar mensajes con diferentes contextos de cifrado, puede verificar parte del contexto de cifrado. Por ejemplo, si algunos mensajes tuviesen el contexto de cifrado dept=finance y otros tuviesen dept=IT, podría verificar que el contexto de cifrado siempre contiene el nombre dept, sin especificar su valor. Si desea mayor precisión, podría descifrar los archivos mediante comandos independientes.

El comando de descifrado no devuelve ningún resultado, pero puede utilizar un comando de lista de directorios para comprobar que ha creado nuevos archivos con el sufijo .decrypted. Para ver el contenido de texto no cifrado, utilice un comando para obtener el contenido del archivo.

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

Cifrado y descifrado en la línea de comandos

Estos ejemplos muestran cómo canalizar la entrada a los comandos (stdin) y escribir el resultado en la línea de comandos (stdout). Explican cómo representar stdin y stdout en un comando y cómo utilizar las herramientas de codificación Base64 integradas para evitar que el shell interprete incorrectamente los caracteres no ASCII.

En este ejemplo se canaliza una cadena de texto no cifrado a un comando de cifrado y se guarda el mensaje cifrado en una variable. A continuación, se canaliza el mensaje cifrado de la variable a un comando de descifrado que escribe su resultado en la canalización (stdout).

El ejemplo se compone de tres comandos:

  • El primer comando guarda el ARN de clave de un AWS KMS key en una variable $keyArn.

    Bash
    $  keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
    PowerShell
    PS C:\> $keyArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'

     

  • El segundo comando envía la cadena Hello World al comando de cifrado y guarda el resultado en la variable $encrypted.

    Los parámetros --input y --output son obligatorios en todos los comandos de la CLI de cifrado del AWS. Para indicar que la entrada se va a canalizar al comando (stdin), utilice un guion (-) para el valor del parámetro --input. Para enviar el resultado a la línea de comandos (stdout), utilice un guion para el valor del parámetro --output.

    El parámetro --encode codifica en Base64 el resultado antes de devolverlo. Esto impide que el shell interprete incorrectamente los caracteres no ASCII del mensaje cifrado.

    Dado que este comando es una mera prueba de concepto, omitimos el contexto de cifrado y suprimimos los metadatos (-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

     

  • El tercer comando canaliza el mensaje cifrado de la variable $encrypted al comando de descifrado.

    Este comando de descifrado utiliza --input - para indicar que la entrada procede de la canalización (stdin) y --output - para enviar el resultado a la canalización (stdout). (El parámetro de entrada toma la ubicación de la entrada, no los bytes de entrada reales, por lo que no puede utilizar la variable $encrypted como valor del parámetro --input.)

    En este ejemplo, se utiliza el atributo discovery del parámetro --wrapping-keys para permitir que la CLI de cifrado del AWS utilice cualquier AWS KMS key para descifrar los datos. No especifica una política de compromiso, por lo que utiliza el valor predeterminado para las versiones 2.1.x y posteriores, require-encrypt-require-decrypt.

    Debido a que el resultado se ha cifrado y, a continuación, codificado, el comando de descifrado utiliza el parámetro --decode para descodificar entrada codificada en Base64 antes de descifrarlo. También puede utilizar el parámetro --decode para descodificar la entrada codificada en Base64 antes de cifrarla.

    También en este caso, el comando omite el contexto de cifrado y elimina los metadatos (-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

También puede realizar las operaciones de cifrado y descifrado en un solo comando sin que intervenga la variable.

Como en el ejemplo anterior, los parámetros --input y --output tienen un valor -; el comando usa el parámetro --encode para codificar el resultado y el parámetro --decode para descodificar la entrada.

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

Uso de varias claves maestras

En este ejemplo se muestra cómo utilizar varias claves maestras al cifrar y descifrar datos en la CLI de cifrado del AWS.

Cuando se utilizan varias claves maestras para cifrar los datos, cualquiera de ellas se puede utilizar para descifrarlos. Esta estrategia garantiza que se puedan descifrar los datos, aunque una de las claves maestras no esté disponible. Si almacena los datos cifrados en varias Regiones de AWS, esta estrategia permite utilizar una clave maestra de la misma región para descifrar los datos.

Cuando se realiza el cifrado con varias claves maestras, la primera de ellas desempeña una función especial. Genera la clave de datos que se utiliza para cifrar los datos. Las demás claves maestras cifran la clave de datos en texto no cifrado. El mensaje cifrado resultante incluye los datos cifrados y una colección de claves de datos cifradas, una por cada clave maestra. Aunque la primera clave maestra fue la que generó la clave de datos, cualquiera de ellas puede descifrar una de las claves de datos con el fin de utilizarla para descifrar los datos.

Cifrado con tres claves maestras

El comando de este ejemplo utiliza tres claves maestras para cifrar el archivo Finance.log, una en cada una de las tres Regiones de AWS.

Escribe el mensaje cifrado en el directorio Archive. El comando utiliza el parámetro --suffix sin ningún valor para suprimir el sufijo, de tal forma que los nombres de los archivos de entrada y salida sean iguales.

El comando utiliza el parámetro --wrapping-keys con tres atributos key. También puede utilizar varios parámetros --wrapping-keys en el mismo comando.

Para cifrar el archivo de registro, la CLI de cifrado del AWS pide a la primera clave de empaquetado de la lista, $key1, que genere la clave de datos que utiliza para cifrar los datos. A continuación, utiliza cada una de las demás claves de empaquetado para cifrar una copia en texto no cifrado de la misma clave de datos. El mensaje cifrado del archivo de salida incluye las tres claves de datos cifradas.

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

Este comando descifra la copia cifrada del archivo Finance.log y la escribe en un archivo Finance.log.clear del directorio Finance. Para descifrar los datos cifrados en tres AWS KMS keys, puede especificar los mismos tres AWS KMS keys o cualquier subconjunto de ellos. En este ejemplo se especifica solo uno de los AWS KMS keys.

Para indicar a la CLI de cifrado del AWS qué AWS KMS keys se debe utilizar para descifrar los datos, utilice el atributo key del parámetro --wrapping-keys. Al descifrar con AWS KMS keys, el valor del atributo key debe ser un ARN de clave.

Debe tener permiso para llamar a la API de descifrado en el AWS KMS keys que especifique. Para obtener más información, consulte Autenticación y control de acceso de AWS KMS.

Como práctica recomendada, en este ejemplo se utiliza el parámetro --max-encrypted-data-keys para evitar descifrar un mensaje mal formado con un número excesivo de claves de datos cifradas. Aunque en este ejemplo se utiliza solo una clave de empaquetado para el descifrado, el mensaje cifrado tiene tres (3) claves de datos cifrados, una para cada una de las tres claves de empaquetado utilizadas al cifrar. Especifique el número esperado de claves de datos cifrados o un valor máximo razonable, como 5. Si especifica un valor máximo inferior a 3, se produce un error en el comando. Para obtener más información, consulte Limitar las claves de datos cifrados.

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

Cifrado y descifrado en scripts

En este ejemplo se muestra cómo utilizar la CLI de cifrado del AWS en scripts. Puede escribir scripts que se limiten a cifrar y descifrar datos o scripts que cifren o descifren los datos dentro de un proceso de administración de datos.

En este ejemplo, el script obtiene una colección de archivos de registro, los comprime, los cifra y, una vez cifrados, los copia en un bucket de Amazon S3. Este script procesa cada archivo por separado, de forma que podrá descifrarlos y expandirlos por separado.

Cuando comprima y cifre archivos, asegúrese de comprimirlos antes de cifrarlos. Los datos cifrados correctamente no se pueden comprimir.

aviso

Tenga cuidado al comprimir datos que incluyan secretos e información confidencial que algún tercero malintencionado podría tratar de controlar. El tamaño final de los datos comprimidos podría, sin pretenderlo, revelar información confidencial sobre su contenido.

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"
                    }
                }
            }
        }
    }
}

Uso del almacenamiento en caché de claves de datos

En este ejemplo, se utiliza el almacenamiento en caché de claves de datos en un comando que cifra gran cantidad de archivos.

De forma predeterminada, la CLI de cifrado del AWS (y otras versiones del AWS Encryption SDK) genera una clave de datos única para cada archivo que cifra. Aunque el uso de una clave de datos única para cada operación es una práctica criptográfica recomendada, una reutilización limitada de las claves de datos es aceptable en algunas situaciones. Si está estudiando la posibilidad de utilizar el almacenamiento en caché de claves de datos, consulte a un ingeniero de seguridad para conocer los requisitos de seguridad de la aplicación y determinar los umbrales de seguridad que sean adecuados para su caso.

En este ejemplo, el almacenamiento en caché de claves de datos acelera la operación de cifrado porque reduce la frecuencia de las solicitudes al proveedor de claves maestras.

El comando de este ejemplo cifra un gran directorio con varios subdirectorios que contienen un total aproximado de 800 archivos de registro de pequeño tamaño. El primer comando guarda el ARN de la AWS KMS key en una variable keyARN. El segundo comando cifra todos los archivos del directorio de entrada (de forma recursiva) y los escribe en un directorio de archivo. El comando utiliza el parámetro --suffix para especificar el sufijo .archive.

El parámetro --caching permite el almacenamiento en caché de claves de datos. El atributo capacity, que limita el número de claves de datos de la caché, se establece en 1, ya que el procesamiento de archivos en serie nunca utiliza más de una clave de datos a la vez. El atributo max_age, que determina durante cuánto tiempo se puede utilizar la clave de datos almacenada en la memoria caché, se establece en 10 segundos.

El atributo opcional max_messages_encrypted se establece en 10 mensajes, de tal forma que la misma clave de datos nunca se utilice para cifrar más de 10 archivos. Limitar la cantidad de archivos cifrados mediante cada clave de datos reduce la cantidad de archivos que se verían afectadas en el caso poco probable de que se filtrase una clave de datos.

Para ejecutar este comando en los archivos de registro generados por el sistema operativo, es posible que necesite permisos de administrador (sudo en Linux; Ejecutar como administrador en 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

Para comprobar el efecto del almacenamiento en caché de claves de datos, en este ejemplo se utiliza el cmdlet Measure-Command en PowerShell. Cuando se ejecuta este ejemplo sin almacenar las claves de datos en caché, tarda unos 25 segundos en completarse. Este proceso genera una nueva clave de datos para cada archivo del directorio.

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

El almacenamiento en caché de claves de datos agiliza el proceso, aunque se limite cada clave de datos para un máximo de 10 archivos. Ahora, el comando tarda menos de 12 segundos en completarse y reduce el número de llamadas al proveedor de claves maestras a 1/10 del valor original.

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

Si se elimina la restricción max_messages_encrypted, todos los archivos se cifrarán con la misma clave de datos. Este cambio aumenta el riesgo inherente a la reutilización de claves de datos sin aportar mucha más rapidez al proceso. Sin embargo, reduce a una sola el número de llamadas al proveedor de claves maestras.

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