As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Como usar a CLI AWS de criptografia
Este tópico explica como usar os parâmetros na CLI AWS de criptografia. Para obter exemplos, consulte [Exemplos da CLI AWS de criptografia](crypto-cli-examples.md). Para obter a documentação completa, consulte [Leia os documentos](https://aws-encryption-sdk-cli.readthedocs.io/en/latest/). A sintaxe mostrada nesses exemplos é para a versão 2.1 do AWS Encryption CLI. *x* e mais tarde.
**nota**
[Versões da CLI de AWS criptografia anteriores à 4.0.0 estão em fase. end-of-support](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle)
Você pode atualizar com segurança a partir da versão 2.1.*x* e posteriores até a versão mais recente da CLI de criptografia da AWS sem realizar alterações no código ou nos dados. No entanto, os [novos atributos de segurança](about-versions.md#version-2) introduzidos na versão 2.1.*x* não são compatíveis com versões anteriores. Para atualizar a partir da versão 1.7. *x* ou anterior, você deve primeiro atualizar para a última 1. versão *x* da CLI AWS de criptografia. Para obter detalhes, consulte [Migrando seu AWS Encryption SDK](migration.md).
Novos recursos de segurança foram lançados originalmente nas versões 1.7 do AWS Encryption CLI. *x* e 2.0. *x.* No entanto, a versão AWS 1.8 do Encryption CLI. *x* substitui a versão 1.7. *x* e CLI de AWS criptografia 2.1. *x* substitui 2.0. *x.* Para obter detalhes, consulte a [consultoria de segurança](https://github.com/aws/aws-encryption-sdk-cli/security/advisories/GHSA-2xwp-m7mq-7q3r) relevante no [aws-encryption-sdk-cli](https://github.com/aws/aws-encryption-sdk-cli/)repositório em 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](configure.md#config-limit-keys).
Para ver um exemplo de como usar chaves AWS KMS multirregionais, consulte[Usando várias regiões AWS KMS keys](configure.md#config-mrks).
**Topics**
+ [Como criptografar e descriptografar dados](#crypto-cli-e-d-intro)
+ [Como especificar chaves de encapsulamento](#crypto-cli-master-key)
+ [Como fornecer entrada](#crypto-cli-input)
+ [Como especificar o local de saída](#crypto-cli-output)
+ [Como usar um contexto de criptografia](#crypto-cli-encryption-context)
+ [Como especificar uma política de compromisso](#crypto-cli-commitment-policy)
+ [Como armazenar parâmetros em um arquivo de configuração](#crypto-cli-config-file)
## Como criptografar e descriptografar dados
A CLI de AWS criptografia usa os recursos do AWS Encryption SDK para facilitar a criptografia e a descriptografia de dados com segurança.
**nota**
O parâmetro `--master-keys` foi descontinuado na versão 1.8. *x* da CLI de criptografia da AWS e removido na versão 2.1.*x.*. Em vez disso, use o parâmetro `--wrapping-keys`. A partir da versão 2.1.*x*, o parâmetro `--wrapping-keys` passou a ser necessário ao criptografar e descriptografar. Para obter detalhes, consulte [AWS Encryption SDK Referência de sintaxe e parâmetros da CLI](crypto-cli-reference.md).
+ Ao criptografar dados na CLI de AWS criptografia, você especifica seus dados de texto sem formatação e [uma chave de encapsulamento](concepts.md#master-key) (*ou chave mestra*), como in (). AWS KMS key AWS Key Management Service AWS KMS Se estiver usando um provedor de chaves mestras personalizado, você também precisará especificar o provedor. Você também especifica locais de saída para a [mensagem criptografada](concepts.md#message) e para os metadados sobre a operação de criptografia. Um [contexto de criptografia](concepts.md#encryption-context) é opcional, mas recomendado.
Na versão 1.8.*x*, o parâmetro `--commitment-policy` é obrigatório quando você usar o parâmetro `--wrapping-keys`; caso contrário ele não será válido. A partir da versão 2.1*x*, o parâmetro `--commitment-policy` passou a ser opcional, mas é recomendado.
```
aws-encryption-cli --encrypt --input myPlaintextData \
--wrapping-keys key=1234abcd-12ab-34cd-56ef-1234567890ab \
--output myEncryptedMessage \
--metadata-output ~/metadata \
--encryption-context purpose=test \
--commitment-policy require-encrypt-require-decrypt
```
A CLI de AWS criptografia criptografa seus dados com uma chave de dados exclusiva. Em seguida, ele criptografa cada chave de dados sob a chave de encapsulamento especificada. Ela retorna uma [mensagem criptografada](concepts.md#message) e os metadados sobre a operação. A mensagem criptografada contém os dados criptografados (*texto cifrado*) e uma cópia criptografada da chave de dados. Você não precisa se preocupar com o armazenamento, o gerenciamento ou a perda da chave de dados.
+ Ao descriptografar os dados, você passa sua mensagem criptografada, o contexto de criptografia opcional e o local para a saída do texto não criptografado e os metadados. Você também especifica as chaves de encapsulamento que a CLI de AWS criptografia pode usar para descriptografar a mensagem ou informa à CLI de AWS criptografia que ela pode usar qualquer chave de encapsulamento que criptografe a mensagem.
A partir da versão 1.8.*x*, o parâmetro `--wrapping-keys` passou a ser opcional, mas é recomendado. A partir da versão 2.1.*x*, o parâmetro `--wrapping-keys` passou a ser necessário ao criptografar e descriptografar.
Ao descriptografar, você pode usar o atributo **key** do parâmetro `--wrapping-keys` para especificar as chaves de encapsulamento que descriptografam seus dados. Especificar uma chave de AWS KMS encapsulamento ao descriptografar é opcional, mas é uma [prática recomendada](best-practices.md) que impede que você use uma chave que você não pretendia usar. Se estiver usando um provedor de chaves mestras personalizado, você deverá especificar o provedor.
Se você não usar o atributo de **chave**, deverá definir o atributo de [**descoberta**](#discovery-cli-attribute) do `--wrapping-keys` parâmetro como`true`, o que permite que a CLI de AWS criptografia seja descriptografada usando qualquer chave de encapsulamento que criptografou a mensagem.
É 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 detalhes, consulte [Limitar as chaves de dados criptografadas](configure.md#config-limit-keys).
O parâmetro `--buffer` retorna texto simples somente após o processamento de todas as entradas, incluindo a verificação da assinatura digital, se houver uma.
O parâmetro `--decrypt-unsigned` descriptografa o texto cifrado e garante que as mensagens não sejam assinadas antes de serem descriptografadas. Use esse parâmetro se você usou o parâmetro `--algorithm` e selecionou um pacote de algoritmos sem assinatura digital para criptografar dados. Se o texto cifrado for assinado, a descriptografia falhará.
Você pode usar `--decrypt` ou `--decrypt-unsigned` para fazer a descriptografia, mas não ambos.
```
aws-encryption-cli --decrypt --input myEncryptedMessage \
--wrapping-keys key=1234abcd-12ab-34cd-56ef-1234567890ab \
--output myPlaintextData \
--metadata-output ~/metadata \
--max-encrypted-data-keys 1 \
--buffer \
--encryption-context purpose=test \
--commitment-policy require-encrypt-require-decrypt
```
A CLI de AWS criptografia usa a chave de empacotamento para descriptografar a chave de dados na mensagem criptografada. Em seguida, ela usa a chave de dados para descriptografar os dados. Ela retorna os dados em texto não criptografado e os metadados sobre a operação.
## Como especificar chaves de encapsulamento
Ao criptografar dados na CLI de AWS criptografia, você precisa especificar pelo menos [uma chave de encapsulamento (*ou* chave mestra](concepts.md#master-key)). Você pode usar AWS KMS keys in AWS Key Management Service (AWS KMS), agrupar chaves de um [provedor de chave mestra](concepts.md#master-key-provider) personalizado ou ambos. O provedor de chaves mestras personalizado pode ser qualquer provedor de chaves mestras compatível com o Python.
Para especificar as chaves de encapsulamento nas versões 1.8.*x* e posteriores, use o parâmetro `--wrapping-keys` (`-w`). O valor deste parâmetro é uma coleção de [atributos](#cli-master-key-attributes) com o formato `attribute=value`. Os atributos que você usa dependem do provedor de chaves mestras e do comando.
+ **AWS KMS**. Em comandos encrypt, você deve especificar um parâmetro `--wrapping-keys` com um atributo **key**. A partir da versão 2.1.*x*, o parâmetro `--wrapping-keys` também passou a ser necessário em comandos de descriptografia. Ao descriptografar, o parâmetro `--wrapping-keys` deve ter um atributo **key** ou um atributo **discovery** (mas não os dois) com o valor de `true`. Todos os outros atributos são opcionais.
+ **Provedor de chaves mestres personalizado**. Você deve especificar um parâmetro `--wrapping-keys` em cada comando. O valor do parâmetro deve ter os atributos **key** e **provider**.
Você pode incluir [vários parâmetros `--wrapping-keys`](#cli-many-cmks) e vários atributos **key** no mesmo comando.
### Encapsulando os atributos dos parâmetros de chave
O valor do parâmetro `--wrapping-keys` consiste nos seguintes atributos e seus valores. Um parâmetro `--wrapping-keys` (ou parâmetro `--master-keys`) é necessário em todos os comandos de criptografia. A partir da versão 2.1.*x*, o parâmetro `--wrapping-keys` também passou a ser necessário em comandos de descriptografia.
Se um nome ou valor de atributo incluir espaços ou caracteres especiais, coloque o nome e o valor entre aspas. Por exemplo, .`--wrapping-keys key=12345 "provider=my cool provider"`
**Chave: especifique uma chave de encapsulamento**
Use o atributo **key** para identificar uma chave de encapsulamento. Ao criptografar, o valor pode ser qualquer identificador de chave que o provedor de chaves mestras reconhece.
```
--wrapping-keys key=1234abcd-12ab-34cd-56ef-1234567890ab
```
Em um comando encrypt, cada valor do parâmetro você deve incluir pelo menos um atributo **key** e um valor. Para criptografar sua chave de dados em várias chaves de encapsulamento, use [vários atributos **key**](#cli-many-cmks).
```
aws-encryption-cli --encrypt --wrapping-keys key=1234abcd-12ab-34cd-56ef-1234567890ab key=1a2b3c4d-5e6f-1a2b-3c4d-5e6f1a2b3c4d
```
Nos comandos de criptografia usados AWS KMS keys, o valor da **chave pode ser o ID da chave**, o ARN da chave, um nome de alias ou o ARN do alias. Por exemplo, este comando encrypt usa um ARN do alias no valor do atributo **key**. Para obter detalhes sobre os identificadores de chave de um AWS KMS key, consulte [Identificadores de chave](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) no Guia do *AWS Key Management Service desenvolvedor*.
```
aws-encryption-cli --encrypt --wrapping-keys key=arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias
```
Em comandos decrypt que usam um provedor de chaves mestres personalizado, os atributos **key** e **provider** são necessários.
```
\\ Custom master key provider
aws-encryption-cli --decrypt --wrapping-keys provider='myProvider' key='100101'
```
Nos comandos de descriptografia usados AWS KMS, você pode usar o atributo **chave** para especificar o a ser usado AWS KMS keys para descriptografia ou o [atributo de **descoberta**](#discovery-cli-attribute) com um valor de, `true` que permite que a AWS CLI de criptografia use qualquer AWS KMS key um que tenha sido usado para criptografar a mensagem. Se você especificar um AWS KMS key, ele deverá ser uma das chaves de encapsulamento usadas para criptografar a mensagem.
A especificação da chave de encapsulamento é uma [AWS Encryption SDK prática recomendada](best-practices.md). Isso garante que você use o AWS KMS key que pretende usar.
Em um comando decrypt, o valor do atributo **key** deve ser um [ARN de chave.](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN)
```
\\ AWS KMS key
aws-encryption-cli --decrypt --wrapping-keys key=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
```
**Descoberta: use qualquer um AWS KMS key ao descriptografar**
Se você não precisar limitar o uso AWS KMS keys ao descriptografar, você pode usar o atributo de **descoberta** com um valor de. `true` Um valor de `true` permite que a CLI de AWS criptografia decodifique usando qualquer AWS KMS key uma que criptografe a mensagem. Se você não especificar um atributo **discovery**, a descoberta será `false` (padrão). O atributo de **descoberta** é válido somente em comandos de descriptografia e somente quando a mensagem foi criptografada com. AWS KMS keys
O atributo **discovery** com o valor definido como `true` é uma alternativa ao uso do atributo **key** para especificar uma AWS KMS keys. Ao descriptografar uma mensagem criptografada com AWS KMS keys, cada `--wrapping-keys` parâmetro deve ter um **atributo-chave** ou um atributo de **descoberta** com um valor de`true`, mas não ambos.
Quando a descoberta é verdadeira, é uma prática recomendada usar os atributos **discovery-partition** e **discovery-account** para limitar o AWS KMS keys uso aos atributos especificados por você. Contas da AWS No exemplo a seguir, os atributos de **descoberta** permitem que a CLI de AWS criptografia use qualquer um dos atributos AWS KMS key especificados. Contas da AWS
```
aws-encryption-cli --decrypt --wrapping-keys \
discovery=true \
discovery-partition=aws \
discovery-account=111122223333 \
discovery-account=444455556666
```
**Provider: especifique o provedor de chaves mestras**
O atributo **provider** identifica o [provedor de chaves mestres](concepts.md#master-key-provider). O valor padrão é `aws-kms` que representa o AWS KMS. Se estiver usando outro provedor de chaves mestres, o atributo **provider** será necessário.
```
--wrapping-keys key=12345 provider=my_custom_provider
```
Para obter mais informações sobre o uso de provedores de chaves mestras personalizadas (que não sejam AWS KMS), consulte o tópico **Configuração avançada** no arquivo [README](https://github.com/aws/aws-encryption-sdk-cli/blob/master/README.rst) do repositório da [CLI e criptografia da AWS](https://github.com/aws/aws-encryption-sdk-cli/).
**Região: Especifique uma Região da AWS**
Use o atributo de **região** para especificar o Região da AWS de um AWS KMS key. Esse atributo é válido apenas em comandos encrypt e somente quando o provedor de chaves mestras é o AWS KMS.
```
--encrypt --wrapping-keys key=alias/primary-key region=us-east-2
```
AWS Os comandos CLI de criptografia usam o Região da AWS que é especificado no valor do atributo **chave** se incluir uma região, como um ARN. Se o valor da **chave** especificar um Região da AWS, o atributo **região** será ignorado.
O atributo **region** tem precedência sobre outras especificações de região. Se você não usar um atributo de região, os comandos da CLI de AWS criptografia usarão o Região da AWS especificado em seu [perfil AWS CLI nomeado](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-using-profiles), se houver, ou em seu perfil padrão.
**Profile: especifique um perfil nomeado**
Use o atributo **profile** para especificar um AWS CLI perfil nomeado[ da ](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-using-profiles). Os perfis nomeados podem incluir credenciais e uma Região da AWS. Esse atributo é válido somente quando o provedor de chaves mestras é o AWS KMS.
```
--wrapping-keys key=alias/primary-key profile=admin-1
```
Você pode usar o atributo **profile** para especificar credenciais alternativas em comandos encrypt e decrypt. Em um comando encrypt, a CLI de AWS criptografia usa Região da AWS o no perfil nomeado somente quando o valor **da** chave não inclui uma região e não há **nenhum** atributo de região. Em um comando decrypt, o perfil Região da AWS in the name é ignorado.
### Como especificar várias chaves mestras
Você pode especificar várias chaves de encapsulamento (ou *chaves mestras*) em cada comando.
Se você especificar mais de uma chave de encapsulamento, a primeira chave de encapsulamento gerará (e criptografará) a chave de dados usada para criptografar seus dados. As outras chaves de encapsulamento criptografam a mesma chave de dados. A [mensagem criptografada](concepts.md#message) resultante contém os dados criptografados ("texto cifrado") e uma coleção de chaves de dados criptografadas, criptografadas por cada chave de encapsulamento. Qualquer uma das chaves de encapsulamento podem descriptografar uma chave de dados e descriptografar os dados.
Há duas maneiras de especificar várias chaves de encapsulamento:
+ Incluir vários atributos **key** no valor do parâmetro `--wrapping-keys`.
```
$key_oregon=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
$key_ohio=arn:aws:kms:us-east-2:111122223333:key/0987ab65-43cd-21ef-09ab-87654321cdef
--wrapping-keys key=$key_oregon key=$key_ohio
```
+ Incluir vários parâmetros `--wrapping-keys` no mesmo comando. Use essa sintaxe quando os valores dos atributos que você especificar não se aplicarem a todas as chaves de encapsulamento no comando.
```
--wrapping-keys region=us-east-2 key=alias/test_key \
--wrapping-keys region=us-west-1 key=alias/test_key
```
O atributo de **descoberta** com um valor de `true` permite que a CLI de AWS criptografia use qualquer um AWS KMS key que criptografe a mensagem. Se você usar vários parâmetros `--wrapping-keys` no mesmo comando, o uso de `discovery=true` em qualquer parâmetro `--wrapping-keys` substituirá efetivamente os limites do atributo **key** em outros parâmetros `--wrapping-keys`.
Por exemplo, no comando a seguir, o atributo **chave** no primeiro `--wrapping-keys` parâmetro limita a CLI de AWS criptografia ao especificado. AWS KMS key No entanto, o atributo de **descoberta** no segundo `--wrapping-keys` parâmetro permite que a CLI de AWS criptografia use qualquer AWS KMS key uma das contas especificadas para descriptografar a mensagem.
```
aws-encryption-cli --decrypt \
--wrapping-keys key=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab \
--wrapping-keys discovery=true \
discovery-partition=aws \
discovery-account=111122223333 \
discovery-account=444455556666
```
## Como fornecer entrada
[A operação de AWS criptografia na CLI de criptografia usa dados de texto simples como entrada e retorna uma mensagem criptografada.](concepts.md#message) A operação de descriptografia usa uma mensagem criptografada como entrada e retorna dados de texto não criptografado.
O `--input` parâmetro (`-i`), que informa à CLI de AWS criptografia onde encontrar a entrada, é obrigatório em todos os comandos da AWS CLI de criptografia.
Você pode fornecer entrada de qualquer uma das seguintes formas:
+ Usar um arquivo.
```
--input myData.txt
```
+ Usar um padrão de nome de arquivo.
```
--input testdir/*.xml
```
+ Use um diretório ou um padrão de nome de diretório. Quando a entrada é um diretório, o parâmetro `--recursive` (`-r`, `-R`) é necessário.
```
--input testdir --recursive
```
+ Redirecionar a entrada para o comando (stdin). Use um valor de `-` para o parâmetro `--input`. (O parâmetro `--input` sempre é necessário.)
```
echo 'Hello World' | aws-encryption-cli --encrypt --input -
```
## Como especificar o local de saída
O `--output` parâmetro informa à CLI de AWS criptografia onde gravar os resultados da operação de criptografia ou descriptografia. É necessário em todos os comandos da CLI de AWS criptografia. A CLI de criptografia da AWS cria um novo arquivo de saída para cada arquivo de entrada na operação.
Se um arquivo de saída já existir, por padrão, a CLI de AWS criptografia imprime um aviso e, em seguida, sobrescreve o arquivo. Para evitar a substituição, use o parâmetro `--interactive`, que solicita sua confirmação antes de substituir, ou `--no-overwrite`, que ignora a entrada se a saída puder provocar uma substituição. Para suprimir o aviso de substituição, use `--quiet`. Para capturar erros e avisos da CLI de AWS criptografia, use `2>&1` o operador de redirecionamento para gravá-los no fluxo de saída.
**nota**
Os comandos que substituem arquivos de saída começam excluindo o arquivo de saída. Se o comando falhar, o arquivo de saída talvez já tenha sido excluído.
Você pode definir o local da saída de várias maneiras.
+ Especificar um nome de arquivo. Se você especificar um caminho para o arquivo, todos os diretórios no caminho devem existir antes do comando ser executado.
```
--output myEncryptedData.txt
```
+ Especificar um diretório. O diretório de saída deve existir antes do comando ser executado.
Se a entrada contiver subdiretórios, o comando reproduzirá os subdiretórios no diretório especificado.
```
--output Test
```
Quando o local de saída é um diretório (sem nomes de arquivo), a CLI de AWS criptografia cria nomes de arquivos de saída com base nos nomes dos arquivos de entrada mais um sufixo. As operações de criptografia acrescentam `.encrypted` ao nome do arquivo de entrada e as operações de descriptografia acrescentam `.decrypted`. Para alterar o sufixo, use o parâmetro `--suffix`.
Por exemplo, se você criptografar `file.txt`, o comando encrypt criará `file.txt.encrypted`. Se você descriptografar `file.txt.encrypted`, o comando decrypt criará `file.txt.encrypted.decrypted`.
+ Gravar na linha de comando (stdout). Insira um valor de `-` para o parâmetro `--output`. Você pode usar `--output -` para redirecionar a saída em outro comando ou programa.
```
--output -
```
## Como usar um contexto de criptografia
A CLI de AWS criptografia permite que você forneça um contexto de criptografia nos comandos de criptografia e descriptografia. Ele não é necessário, mas é uma melhor prática criptográfica que recomendamos.
Um *contexto de criptografia* é um tipo de *dados autenticados adicionais* arbitrários e que não são segredos. Na CLI de criptografia da AWS , o contexto de criptografia consiste em uma coleção de pares `name=value`. Você pode usar qualquer conteúdo nos pares, incluindo informações sobre os arquivos; dados que o ajudam a encontrar a operação de criptografia em logs; ou dados que suas concessões ou políticas exigem.
**Em um comando encrypt**
O contexto de criptografia que você especifica em um comando encrypt, junto com qualquer par que o [CMM](concepts.md#crypt-materials-manager) adicionar, é associado de maneira criptográfica aos dados criptografados. Ele também é incluído (em não criptografado) na [mensagem criptografada](concepts.md#encryption-context) que o comando retorna. Se você estiver usando um AWS KMS key, o contexto de criptografia também poderá aparecer em texto simples em registros e registros de auditoria, como. AWS CloudTrail
O exemplo a seguir mostra um contexto de criptografia com três pares `name=value`.
```
--encryption-context purpose=test dept=IT class=confidential
```
**Em um comando decrypt**
Em um comando decrypt, o contexto de criptografia ajuda a confirmar se você está descriptografando a mensagem criptografada correta.
Não é necessário fornecer um contexto de criptografia em um comando decrypt, mesmo que um contexto de criptografia tenha sido usado na criptografia. No entanto, se você fizer isso, a CLI de AWS criptografia verificará se cada elemento no contexto de criptografia do comando decrypt corresponde a um elemento no contexto de criptografia da mensagem criptografada. Se um elemento não corresponder, o comando decrypt falhará.
Por exemplo, o comando a seguir descriptografa a mensagem criptografada somente se o contexto de criptografia incluir `dept=IT`.
```
aws-encryption-cli --decrypt --encryption-context dept=IT ...
```
Um contexto de criptografia é uma parte importante de sua estratégia de segurança. No entanto, ao escolher um contexto de criptografia, lembre-se de que seus valores não são secretos. Não inclua dados confidenciais no contexto de criptografia.
**Como especificar um contexto de criptografia**
+ Em um comando **encrypt**, use o parâmetro `--encryption-context` com um ou mais pares `name=value`. Use um espaço para separar cada par.
```
--encryption-context name=value [name=value] ...
```
+ Em um comando **decrypt**, o valor do parâmetro `--encryption-context` pode incluir pares `name=value`, elementos `name` (sem valores) ou uma combinação de ambos.
```
--encryption-context name[=value] [name] [name=value] ...
```
Se o `name` ou o `value` em um par de `name=value` incluir espaços ou caracteres especiais, coloque o par inteiro entre aspas.
```
--encryption-context "department=software engineering" "Região da AWS=us-west-2"
```
Por exemplo, este comando encrypt inclui um contexto de criptografia com dois pares, `purpose=test` e `dept=23`.
```
aws-encryption-cli --encrypt --encryption-context purpose=test dept=23 ...
```
Esse comando decrypt tem êxito. O contexto de criptografia em cada comando é um subconjunto do contexto de criptografia original.
```
\\ Any one or both of the encryption context pairs
aws-encryption-cli --decrypt --encryption-context dept=23 ...
\\ Any one or both of the encryption context names
aws-encryption-cli --decrypt --encryption-context purpose ...
\\ Any combination of names and pairs
aws-encryption-cli --decrypt --encryption-context dept purpose=test ...
```
No entanto, esses comandos decrypt falharão. O contexto de criptografia na mensagem criptografada não contém os elementos específicos.
```
aws-encryption-cli --decrypt --encryption-context dept=Finance ...
aws-encryption-cli --decrypt --encryption-context scope ...
```
## Como especificar uma política de compromisso
Para definir a [política de compromisso](concepts.md#commitment-policy) para o comando, use o [parâmetro `--commitment-policy`](crypto-cli-reference.md#syntax-commitment-policy). Esse parâmetro foi apresentado na versão 1.8.*x.*. Ele 'é válido em comandos de criptografia e descriptografia. A política de compromisso que você definir será válida somente para o comando no qual ela aparece. Se você não definir uma política de compromisso para um comando, a CLI de AWS criptografia usará o valor padrão.
Por exemplo, o valor do parâmetro a seguir define a política de compromisso como `require-encrypt-allow-decrypt`, que sempre criptografa com o confirmação de chave, mas descriptografa um texto cifrado criptografado com ou sem confirmação de chave.
```
--commitment-policy require-encrypt-allow-decrypt
```
## Como armazenar parâmetros em um arquivo de configuração
Você pode economizar tempo e evitar erros de digitação salvando os parâmetros e valores da CLI de AWS criptografia usados com frequência nos arquivos de configuração.
Um *arquivo de configuração* é um arquivo de texto que contém parâmetros e valores para um comando CLI de AWS criptografia. Ao fazer referência a um arquivo de configuração em um comando da CLI de criptografia da AWS , a referência é substituída pelos parâmetros e valores no arquivo de configuração. O efeito será o mesmo como se você tivesse digitado o conteúdo do arquivo na linha de comando. Um arquivo de configuração pode ter qualquer nome e pode ser localizado em qualquer diretório que o usuário atual pode acessar.
O arquivo de configuração de exemplo a seguir, `key.conf`, especifica duas AWS KMS keys em diferentes regiões.
```
--wrapping-keys key=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
--wrapping-keys key=arn:aws:kms:us-east-2:111122223333:key/0987ab65-43cd-21ef-09ab-87654321cdef
```
Para usar o arquivo de configuração em um comando, prefixe o nome do arquivo com uma arroba (`@`). Em um PowerShell console, use um caractere de crase para escapar do sinal arroba (``@`).
Este comando de exemplo usa o arquivo `key.conf` em um comando encrypt.
------
#### [ Bash ]
```
$ aws-encryption-cli -e @key.conf -i hello.txt -o testdir
```
------
#### [ PowerShell ]
```
PS C:\> aws-encryption-cli -e `@key.conf -i .\Hello.txt -o .\TestDir
```
------
**Regras do arquivo de configuração**
As regras para uso de arquivos de configuração são:
+ Você pode incluir vários parâmetros em cada arquivo de configuração e listá-los em qualquer ordem. Liste cada parâmetro com seus valores (se houver) em uma linha separada.
+ Use `#` para adicionar um comentário a toda ou a parte de uma linha.
+ Você pode incluir referências a outros arquivos de configuração. Não use uma craqueta para escapar da `@` placa, mesmo dentro PowerShell.
+ Se você usar aspas em um arquivo de configuração, o texto entre aspas não pode abranger várias linhas.
Por exemplo, este é o conteúdo de um arquivo `encrypt.conf` de exemplo.
```
# Archive Files
--encrypt
--output /archive/logs
--recursive
--interactive
--encryption-context class=unclassified dept=IT
--suffix # No suffix
--metadata-output ~/metadata
@caching.conf # Use limited caching
```
Você também pode incluir vários arquivos de configuração em um comando. Este comando de exemplo usa os arquivos de configuração `encrypt.conf` e `master-keys.conf`.
------
#### [ Bash ]
```
$ aws-encryption-cli -i /usr/logs @encrypt.conf @master-keys.conf
```
------
#### [ PowerShell ]
```
PS C:\> aws-encryption-cli -i $home\Test\*.log `@encrypt.conf `@master-keys.conf
```
------
**Próximo:** [ Experimente os exemplos da CLI de criptografia da AWS](crypto-cli-examples.md)