Criptografar um arquivo Descriptografar um arquivo Criptografar todos os arquivos em um diretório Descriptografar todos os arquivos em um diretório Criptografar e descriptografar na linha de comando Uso de várias chaves mestras Criptografar e descriptografar em scripts Usar o armazenamento em cache de chaves de dados

Exemplos da CLI de criptografia da AWS

Use os seguintes exemplos para testar a CLI de Criptografia da AWS na plataforma de sua preferência. Para obter ajuda com chaves mestras e outros parâmetros, consulte Como usar a CLI de criptografia da AWS. Para obter uma referência rápida, consulte Referência da sintaxe e de parâmetros da CLI do AWS Encryption SDK.

nota

Os exemplos a seguir usam a sintaxe da CLI de Criptografia da AWS versão 2.1x..

Os novos atributos de segurança foram lançados originalmente nas versões 1.7.x e 2.0.x. da CLI de criptografia da AWS. No entanto, a versão 1.8x da CLI de criptografia da AWS substitui a versão 1.7.x e a versão 2.1.x da CLI de criptografia da AWSsubstitui a 2.0.x. Para obter detalhes, consulte o boletim de segurança pertinente no repositório aws-encryption-sdk-cli no GitHub.

Para obter um exemplo de como usar o atributo de segurança que limita as chaves de dados criptografadas, consulte Limitar as chaves de dados criptografadas.

Para obter um exemplo de como usar chaves multirregionais do AWS KMS, consulte Usar AWS KMS keys multirregionais.

Tópicos

Criptografar um arquivo
Descriptografar um arquivo
Criptografar todos os arquivos em um diretório
Descriptografar todos os arquivos em um diretório
Criptografar e descriptografar na linha de comando
Uso de várias chaves mestras
Criptografar e descriptografar em scripts
Usar o armazenamento em cache de chaves de dados

Criptografar um arquivo

Este exemplo usa a CLI de Criptografia da AWS para criptografar o conteúdo do arquivo hello.txt, que contém uma string "Hello World".

Quando você executa um comando encrypt em um arquivo, a CLI de Criptografia da AWS obtém o conteúdo do arquivo, gera uma chave de dados exclusiva, criptografa o conteúdo do arquivo sob a chave de dados e, em seguida, grava a mensagem criptografada em um novo arquivo.

O primeiro comando salva o ARN da AWS KMS key em uma variável $keyArn. Ao criptografar com uma AWS KMS key, você pode identificá-la usando um ID de chave, ARN de chave, nome de alias ou ARN de alias. Para obter detalhes sobre os identificadores de chave de uma AWS KMS key, consulte Identificadores de chave no Guia do desenvolvedor do AWS Key Management Service.

O segundo comando criptografa o conteúdo do arquivo. O comando usa o parâmetro --encrypt para especificar a operação, e o parâmetro --input para indicar o arquivo a ser criptografado. O --wrapping-keys parâmetro e seu atributo key necessário informam o comando para usar a AWS KMS key representada pelo ARN da chave.

O comando usa o parâmetro --metadata-output para especificar um arquivo de texto para os metadados sobre a operação de criptografia. Como prática recomendada, o comando usa o parâmetro --encryption-context para especificar um contexto de criptografia.

Esse comando também usa o parâmetro --commitment-policy para definir explicitamente a política de compromisso. Na versão 1.8. x, ele é necessário quando você usa o parâmetro --wrapping-keys. A partir da versão 2.1x, o parâmetro --commitment-policy passou a ser opcional, mas é recomendado.

O valor do parâmetro --output, um ponto (.), informa o comando para gravar o arquivo de saída no diretório atual.

Quando o comando encrypt é bem-sucedido, ele não retorna nenhuma saída. Para determinar se o comando foi bem-sucedido, verifique o valor booliano na variável $?. Quando o comando é bem-sucedido, o valor de $? é 0 (Bash) ou True (PowerShell). Quando o comando falha, o valor de $? é não zero (Bash) ou False (PowerShell).

Você também pode usar um comando de listagem de diretório para ver se o comando encrypt criou um novo arquivo, hello.txt.encrypted. Como o comando encrypt não especificou um nome de arquivo para a saída, a CLI de Criptografia da AWS gravou a saída em um arquivo com o mesmo nome que o arquivo de entrada mais um sufixo .encrypted. Para usar outro sufixo ou suprimir o sufixo, use o parâmetro --suffix.

O arquivo hello.txt.encrypted contém uma mensagem criptografada que inclui o texto cifrado do arquivo hello.txt, uma cópia criptografada da chave de dados e metadados adicionais incluindo o contexto de criptografia.

Descriptografar um arquivo

Este exemplo usa a CLI de Criptografia da AWS para descriptografar o conteúdo do arquivo Hello.txt.encrypted que foi criptografado no exemplo anterior.

O comando decrypt usa o parâmetro --decrypt para indicar a operação, e o parâmetro --input para identificar o arquivo a ser descriptografado. O valor do parâmetro --output é um ponto que representa o diretório atual.

O parâmetro --wrapping-keys com um atributo key especifica a chave de encapsulamento usada para descriptografar a mensagem criptografada. Em comandos decrypt com AWS KMS keys, o valor do atributo key deve ser um ARN de chave. O parâmetro --wrapping-keys é obrigatório em comandos encrypt. Se você usar AWS KMS keys, poderá usar o atributo key prara especificar AWS KMS keys para descritografar ou o atributo discovery com um valor definido comotrue (mas não ambos). Se estiver usando outro provedor de chaves mestras, os atributos key e provider serão necessários.

A partir da versão 2.1x, o parâmetro --commitment-policy passou a ser opcional, mas é recomendado. Usá-lo explicitamente deixa clara sua intenção, mesmo se você especificar o valor padrão, require-encrypt-require-decrypt.

O parâmetro --encryption-context é opcional no comando decrypt, mesmo quando um contexto de criptografia é fornecido no comando encrypt. Nesse caso, o comando decrypt usa o mesmo contexto de criptografia que foi fornecido no comando encrypt. Antes de descriptografar, a CLI de criptografia da AWS verifica se o contexto de criptografia na mensagem criptografada inclui um par de purpose=test. Caso contrário, o comando decrypt falhará.

O parâmetro --metadata-output especifica um arquivo de metadados sobre a operação de descriptografia. O valor do parâmetro --output, um ponto (.), grava o arquivo de saída no diretório atual.

É uma prática recomendada usar o parâmetro --max-encrypted-data-keys, para evitar a descriptografia de uma mensagem malformada com um número excessivo de chaves de dados criptografadas. Especifique o número esperado de chaves de dados criptografadas (um para cada chave de encapsulamento usada na criptografia) ou uma quantidade máxima razoável (como 5). Para obter mais detalhes, consulte Limitar as chaves de dados criptografadas.

Ele --buffer retorna texto sem formatação somente após o processamento de todas as entradas, incluindo a verificação da assinatura digital, se houver uma.

Quando um comando decrypt é bem-sucedido, ele não retorna nenhuma saída. Para determinar se o comando foi bem-sucedido, obtenha o valor da variável $?. Você também pode usar um comando de listagem de diretório para ver se o comando criou um novo arquivo com um sufixo .decrypted. Para ver o conteúdo de texto não criptografado, use um comando para obter o conteúdo do arquivo, como cat ou Get-Content.

Criptografar todos os arquivos em um diretório

Este exemplo usa a criptografia da CLI de criptografia da AWS para criptografar o conteúdo de todos os arquivos em um diretório.

Quando um comando afeta vários arquivos, a CLI de criptografia da AWS processa cada arquivo individualmente. Ela obtém o conteúdo do arquivo, obtém uma chave de dados exclusiva para o arquivo da chave mestre, criptografa o conteúdo do arquivo sob a chave de dados e grava os resultados em um novo arquivo no diretório de saída. Como resultado, você pode descriptografar os arquivos de saída de maneira independente.

Essa listagem do diretório TestDir mostra os arquivos de texto não criptografado que desejamos criptografar.

O primeiro comando salva o nome do atributo da Amazon (ARN) de uma AWS KMS key na variável $keyArn.

O segundo comando criptografa o conteúdo dos arquivos no diretório TestDir e grava os arquivos de conteúdo criptografado no TestEnc. Se o diretório TestEnc não existir, o comando falhará. Como o local de entrada é um diretório, o parâmetro --recursive é obrigatório.

O parâmetro --wrapping-keys e seu atributo-chave obrigatório especificam a chave de encapsulamento a ser usada. O comando encrypt inclui um contexto de criptografia, dept=IT. Quando você especifica um contexto de criptografia em um comando que criptografa vários arquivos, o mesmo contexto de criptografia é usado para todos os arquivos.

O comando também tem um parâmetro --metadata-output para informar à CLI de criptografia da AWS onde gravar os metadados sobre as operações de criptografia. A CLI de criptografia da AWS grava um registro de metadados para cada arquivo que foi criptografado.

A partir da versão 2.1.x, o --commitment-policy parameter passou a ser opcional, mas é recomendado. Se o comando ou script falhar porque não consegue decifrar um texto cifrado, a configuração explícita da política de compromisso pode ajudar a detectar o problema rapidamente.

Quando o comando é concluído, a CLI de criptografia da AWS grava os arquivos criptografados no diretório TestEnc, mas não retorna nenhuma saída.

O último comando lista os arquivos no diretório TestEnc. Há um arquivo de saída de conteúdo criptografado para cada arquivo de entrada de conteúdo de texto não criptografado. Como o comando não especificou um sufixo alternativo, o comando encrypt acrescentou .encrypted a cada um dos nomes de arquivos de entrada.

Descriptografar todos os arquivos em um diretório

Este exemplo descriptografa todos os arquivos em um diretório. Ele começa com os arquivos no diretório TestEnc que foram criptografados no exemplo anterior.

Este comando decrypt descriptografa todos os arquivos no diretório TestEnc e grava os arquivos de texto não criptografado no diretório TestDec. O parâmetro --wrapping-keys com um atributo de chave e um valor de ARN de chave informa à CLI de criptografia da AWS qual AWS KMS keys usar para descriptografar os arquivos. O comando usa o parâmetro --interactive para informar à CLI de criptografia da AWS para avisar você antes de substituir um arquivo com o mesmo nome.

Esse comando também usa o contexto de criptografia que foi fornecido quando os arquivos foram criptografados. Ao descriptografar vários arquivos, a CLI de criptografia da AWS verifica o contexto de criptografia de cada arquivo. Se a verificação do contexto de criptografia em qualquer arquivo falhar, a CLI de criptografia da AWS rejeita o arquivo, grava um aviso, registra a falha nos metadados e continua verificando os arquivos restantes. Se a CLI de criptografia da AWS não conseguir descriptografar um arquivo por qualquer outro motivo, todo o comando decrypt falhará imediatamente.

Neste exemplo, as mensagens criptografadas em todos os arquivos de entrada contêm o elemento do contexto de criptografia de dept=IT. No entanto, se você estiver descriptografando mensagens com diferentes contextos de criptografia, você ainda poderá verificar parte do contexto de criptografia. Por exemplo, se algumas mensagens tiverem um contexto de criptografia de dept=finance e outras tiverem dept=IT, você poderá verificar se o contexto de criptografia sempre contém um nome dept sem especificar o valor. Se desejar ser mais específico, você poderá descriptografar os arquivos em comandos separados.

O comando decrypt não retorna nenhuma saída, mas você pode usar um comando de listagem de diretórios para ver se ele criou novos arquivos com o sufixo .decrypted. Para ver o conteúdo de texto não criptografado, use um comando para obter o conteúdo do arquivo.

Criptografar e descriptografar na linha de comando

Estes exemplos mostram como redirecionar a entrada para comandos (stdin) e gravar a saída na linha de comando (stdout). Eles explicam como representar stdin e stdout em um comando e como usar ferramentas de codificação Base64 internas para impedir que o shell interprete caracteres não ASCII incorretamente.

Este exemplo redireciona uma string de texto não criptografado para um comando encrypt e salva a mensagem criptografada em uma variável. Em seguida, ele redireciona a mensagem criptografada na variável para um comando decrypt, que grava sua saída no pipeline (stdout).

O exemplo consiste em três comandos:

O primeiro comando salva o ARN da chave de um AWS KMS key em uma variável $keyArn.

O segundo comando redireciona a string Hello World para o comando encrypt e salva o resultado na variável $encrypted.

Os parâmetros --input e --output são obrigatórios em todos os comandos da CLI de criptografia da AWS. Para indicar que a entrada está sendo redirecionada para o comando (stdin), use um hífen (-) para o valor do parâmetro --input. Para enviar a saída para a linha de comando (stdout), use um hífen para o valor do parâmetro --output.

O parâmetro --encode codifica a saída em Base64 antes de retorná-la. Isso evita que o shell interprete incorretamente os caracteres não ASCII na mensagem criptografada.

Como esse comando é apenas uma prova de conceito, omitimos o contexto de criptografia e suprimimos os metadados (-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
```
O terceiro comando redireciona a mensagem criptografada na variável $encrypted para descriptografar o comando.

Esse comando decrypt usa --input - para indicar que a entrada é proveniente do pipeline (stdin) e do --output - para enviar a saída para o pipeline (stdout). (O parâmetro de entrada usa o local da entrada, não os bytes reais da entrada. Portanto, você não pode usar a variável $encrypted como o valor do parâmetro --input.)

Este exemplo usa o atributo de descoberta do parâmetro --wrapping-keys para permitir que a CLI de criptografia da AWS use qualquer AWS KMS key para descriptografar os dados. Ele não especifica uma política de compromisso, portanto, usa o valor padrão para a versão 2.1.x e posteriores, require-encrypt-require-decrypt.

Como a saída foi criptografada e, em seguida, codificada, o comando decrypt usa o parâmetro --decode para decodificar a entrada codificada em Base64 antes de descriptografá-la. Você também pode usar o parâmetro --decode para decodificar a entrada codificada em Base64 antes de criptografá-la.

Novamente, o comando omite o contexto de criptografia e suprime os metadados (-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
```

Você também pode executar operações de criptografia e descriptografia em um único comando sem a variável de intervenção.

Como no exemplo anterior, os parâmetros --input e --output têm um valor - e o comando usa o parâmetro --encode para codificar a saída, e o parâmetro --decode para decodificar a entrada.

Uso de várias chaves mestras

Este exemplo mostra como usar várias chaves mestras ao criptografar e descriptografar dados na CLI de criptografia da AWS.

Quando você usa várias chaves mestras para criptografar dados, qualquer uma das chaves mestras pode ser usada para descriptografar os dados. Essa estratégia garante que você possa descriptografar os dados mesmo que uma das chaves mestras esteja indisponível. Se você estiver armazenando os dados criptografados em várias Regiões da AWS, essa estratégia permite que você use uma chave mestra na mesma região para descriptografar os dados.

Quando você criptografa com várias chaves mestras, a primeira chave mestra desempenha uma função especial. Ela gera a chave de dados que é usada para criptografar os dados. As demais chaves mestras criptografam a chave de dados de texto não criptografado. A mensagem criptografada resultante inclui os dados criptografados e uma coleção de chaves de dados criptografadas, uma para cada chave mestre. Embora a primeira chave mestra tenha gerado a chave de dados, qualquer uma das chaves mestras poderá descriptografar uma das chaves de dados, que pode ser usada para descriptografar os dados.

Criptografia com três chaves mestres

Este comando de exemplo usa três chaves de encapsulamento para criptografar o arquivo Finance.log, uma em cada uma das três Regiões da AWS.

Ele grava a mensagem criptografada no diretório Archive. O comando usa o parâmetro --suffix sem nenhum valor para suprimir o sufixo. Portanto, os nomes dos arquivos de entrada e saída serão o mesmos.

O comando usa o parâmetro --wrapping-keys com três atributos key. Você também pode usar vários parâmetros --wrapping-keys no mesmo comando.

Para criptografar o arquivo de log, a CLI de criptografia da AWS solicita a primeira chave de encapsulamento na lista, $key1, para gerar a chave de dados que ela usa para criptografar os dados. Em seguida, ela usa cada uma das outras chaves de encapsulamento para criptografar uma cópia de texto não criptografado da mesma chave de dados. A mensagem criptografada no arquivo de saída inclui todas as três chaves de dados criptografadas.

Este comando descriptografa a cópia criptografada do arquivo Finance.log e grava-o em um arquivo Finance.log.clear no diretório Finance. Para descriptografar dados criptografados abaixo de três AWS KMS keys, especifique os mesmos três AWS KMS keys ou qualquer subconjunto deles. Este exemplo especifica somente um dos AWS KMS keys.

Para informar à CLI de criptografia da AWS qual AWS KMS keys usar para descriptografar seus dados, use o atributo da chave do parâmetro. --wrapping-keys Em comandos decrypt com AWS KMS keys, o valor do atributo da chave deve ser um ARN da chave.

É preciso ter permissão para chamar a API Decrypt no AWS KMS keys que você especificar. Para obter mais informações, consulte Autenticação e controle de acesso do AWS KMS.

Como prática recomendada, estes exemplos usam o parâmetro --max-encrypted-data-keys para evitar a descriptografia de uma mensagem malformada com um número excessivo de chaves de dados criptografadas. Embora o exemplo use somente uma chave de encapsulamento para decodificação, a mensagem criptografada tem três (3) chaves de dados criptografadas; uma para cada uma das três chaves de encapsulamento usadas na criptografia. Especifique o número esperado de chaves de dados criptografadas ou um valor máximo razoável, como 5. Se especificar um valor máximo menor que 3, o comando falhará. Para obter mais detalhes, consulte Limitar as chaves de dados criptografadas.

Criptografar e descriptografar em scripts

Este exemplo mostra como usar a CLI de criptografia da AWS em scripts. Você pode escrever scripts que apenas criptografam e descriptografam dados ou scripts que criptografam ou descriptografam como parte de um processo de gerenciamento de dados.

Neste exemplo, o script obtém uma coleção de arquivos de log, compacta-os, criptografa-os e, em seguida, copia os arquivos criptografados em um bucket do Amazon S3. Esse script processa cada arquivo separadamente, para que você possa descriptografá-los e expandi-los de maneira independente.

Ao compactar e criptografar arquivos, certifique-se de compactar antes de criptografar. Dados criptografados corretamente não podem ser compactados.

Atenção

Tenha cuidado ao compactar dados que incluam segredos e dados que possam ser controlados por um ator mal-intencionado. O tamanho final dos dados compactados pode revelar inadvertidamente informações confidenciais sobre seu conteúdo.

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

Usar o armazenamento em cache de chaves de dados

Este exemplo usa o armazenamento em cache de chaves de dados em um comando que criptografa um grande número de arquivos.

Por padrão, a CLI de criptografia da AWS (e outras versões do AWS Encryption SDK) gera uma chave de dados exclusiva para cada arquivo que criptografa. Embora o uso de uma chave de dados exclusiva para cada operação seja uma prática recomendada de criptografia, a reutilização limitada de chaves de dados é aceitável em algumas situações. Se você estiver considerando o armazenamento em cache de chaves de dados, consulte um engenheiro de segurança para compreender os requisitos de segurança do seu aplicativo e determinar os limites de segurança apropriados para você.

Neste exemplo, o armazenamento em cache de chaves de dados acelera a operação de criptografia reduzindo a frequência de solicitações ao provedor de chaves mestras.

O comando neste exemplo criptografa um diretório grande com vários subdiretórios que contêm um total de aproximadamente 800 pequenos arquivos de log. O primeiro comando salva o ARN da AWS KMS key em uma variável keyARN. O segundo comando criptografa todos os arquivos no diretório de entrada (recursivamente) e os grava em um diretório de arquivo morto. O comando usa o parâmetro --suffix para especificar o sufixo .archive.

O parâmetro --caching permite o armazenamento em cache da chave de dados. O atributo capacity, que limita o número de chaves de dados no cache, está definido como 1, porque o processamento de arquivos seriais nunca usa mais de uma chave de dados de cada vez. O atributo max_age, que determina por quanto tempo a chave de dados armazenada em cache pode ser usada, está definido como 10 segundos.

O atributo opcional max_messages_encrypted está definido como 10 mensagens, portanto, uma única chave de dados nunca é usada para criptografar mais de 10 arquivos. A limitação do número de arquivos criptografados por cada chave de dados reduz o número de arquivos que devem ser afetados no caso improvável de uma chave de dados estar comprometida.

Para executar esse comando em arquivos de log gerados pelo sistema operacional, você pode precisar de permissões de administrador (sudo no Linux; Run as Administrator (Executar como administrador) no Windows).

Para testar o efeito do armazenamento em cache da chave de dados, este exemplo usa o cmdlet Measure-Command no PowerShell. Ao executar esse exemplo sem o armazenamento em cache da chave de dados, ele demora cerca de 25 segundos para ser concluído. Esse processo gera uma nova chave de dados para cada arquivo no diretório.


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

O armazenamento em cache da chave de dados acelera o processo, mesmo quando você limita cada chave de dados para um máximo de 10 arquivos. O comando agora demora menos de 12 segundos para ser concluído e reduz o número de chamadas ao provedor de chaves mestras para 1/10 do 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

Se você eliminar a restrição max_messages_encrypted, todos os arquivos serão criptografados com a mesma chave de dados. Essa alteração aumenta o risco de reutilização de chaves de dados sem tornar o processo muito mais rápido. No entanto, ela reduz o número de chamadas ao provedor de chaves mestras para 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

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Como usar a CLI

Referência da sintaxe e de parâmetros