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

# Etapa 3: Criptografar o material de chave
<a name="importing-keys-encrypt-key-material"></a>

Depois de [fazer download da chave pública e importar o token](importing-keys-get-public-key-and-token.md), criptografe seu material de chaves usando a chave pública que você baixou e o algoritmo de empacotamento que você especificou. Se precisar substituir a chave pública ou o token de importação, ou alterar o algoritmo de empacotamento, você deverá baixar uma nova chave pública e importar o token. Para obter informações sobre as chaves públicas e os algoritmos de empacotamento que AWS KMS oferecem suporte, consulte [Selecionar uma especificação de chave pública de empacotamento](importing-keys-get-public-key-and-token.md#select-wrapping-key-spec) e. [Selecionar um algoritmo de empacotamento](importing-keys-get-public-key-and-token.md#select-wrapping-algorithm)

O material de chaves deve estar em formato binário. Para obter informações detalhadas, consulte [Requisitos para material de chave importada](importing-keys-conceptual.md#importing-keys-material-requirements).

**nota**  
Para pares de chaves assimétricas, criptografe e importe somente a chave privada. AWS KMS deriva a chave pública da chave privada.  
A combinação a seguir NÃO é compatível: material de chave ECC\$1NIST\$1P521, especificação de chave de empacotamento pública RSA\$12048 e um algoritmo de empacotamento RSAES\$1OAEP\$1SHA\$1\$1.  
Não é possível empacotar diretamente o material de chave ECC\$1NIST\$1P521 com uma chave de empacotamento pública RSA\$12048. Use uma chave de empacotamento maior ou um algoritmo de empacotamento RSA\$1AES\$1KEY\$1WRAP\$1SHA\$1\$1.  
Os algoritmos de empacotamento RSA\$1AES\$1KEY\$1WRAP\$1SHA\$1256 e RSA\$1AES\$1KEY\$1WRAP\$1SHA\$11 não são compatíveis em regiões da China.

Geralmente, você criptografa o material de chaves ao exportá-lo do HSM (módulo de segurança de hardware) ou do sistema de gerenciamento de chaves. Para obter informações sobre como exportar material de chaves em formato binário, consulte a documentação do HSM ou do sistema de gerenciamento de chaves. Você também pode consultar a seção a seguir, que fornece uma demonstração da prova de conceito usando OpenSSL.

Ao criptografar o material de chaves, use o mesmo algoritmo de empacotamento que você especificou quando [fez download da chave pública e do token de importação](importing-keys-get-public-key-and-token.md). Para encontrar o algoritmo de empacotamento que você especificou, consulte o evento de CloudTrail log da [GetParametersForImport](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetParametersForImport.html)solicitação associada.

## Gerar material de chave para testes
<a name="importing-keys-example-key-material"></a>

Os comandos do OpenSSL a seguir geram material de chave de cada tipo compatível para testes. Esses exemplos são fornecidos somente para testes e proof-of-concept demonstrações. Para sistemas de produção, use um método mais seguro para gerar o material de chaves, como um módulo de segurança de hardware ou um sistema de gerenciamento de chaves.

Para converter as chaves privadas de pares de chaves assimétricas em formato codificado em DER, canalize o comando de geração de material de chave para o comando `openssl pkcs8` a seguir. O parâmetro `topk8` direciona o OpenSSL a usar uma chave privada como entrada e retornar uma chave formatada PKCS\$18. (O comportamento padrão é o oposto.) 

```
openssl pkcs8 -topk8 -outform der -nocrypt
```

Os comandos a seguir geram material de chave de teste para cada tipo de chave compatível.
+ Chave de criptografia simétrica (32 bytes)

  Esse comando gera uma chave simétrica de 256 bits (sequência aleatória de 32 bytes) e a salva no arquivo `PlaintextKeyMaterial.bin`. Não é necessário codificar esse material de chaves. 

  ```
  openssl rand -out PlaintextKeyMaterial.bin 32
  ```

  Somente nas regiões da China, você deve gerar uma chave simétrica de 128 bits (sequência aleatória de 16 bytes).

  ```
  openssl rand -out PlaintextKeyMaterial.bin 16
  ```
+ Chaves de HMAC

  Esse comando gera uma sequência de bytes aleatória do tamanho especificado. Não é necessário codificar esse material de chaves. 

  O comprimento da chave de HMAC deve corresponder ao comprimento definido pela especificação da chave do KMS. Por exemplo, se a chave do KMS for HMAC\$1384, você deverá importar uma chave de 384 bits (48 bytes).

  ```
  openssl rand -out HMAC_224_PlaintextKey.bin 28
  
  openssl rand -out HMAC_256_PlaintextKey.bin 32
  
  openssl rand -out HMAC_384_PlaintextKey.bin 48
  
  openssl rand -out HMAC_512_PlaintextKey.bin 64
  ```
+ Chaves privadas RSA

  ```
  openssl genpkey -algorithm rsa -pkeyopt rsa_keygen_bits:2048 | openssl pkcs8 -topk8 -outform der -nocrypt > RSA_2048_PrivateKey.der
  
  openssl genpkey -algorithm rsa -pkeyopt rsa_keygen_bits:3072 | openssl pkcs8 -topk8 -outform der -nocrypt > RSA_3072_PrivateKey.der
  
  openssl genpkey -algorithm rsa -pkeyopt rsa_keygen_bits:4096 | openssl pkcs8 -topk8 -outform der -nocrypt > RSA_4096_PrivateKey.der
  ```
+ Chaves privadas ECC

  ```
  openssl genpkey -algorithm ec -pkeyopt ec_paramgen_curve:P-256 | openssl pkcs8 -topk8 -outform der -nocrypt > ECC_NIST_P256_PrivateKey.der
  
  openssl genpkey -algorithm ec -pkeyopt ec_paramgen_curve:P-384 | openssl pkcs8 -topk8 -outform der -nocrypt > ECC_NIST_P384_PrivateKey.der
  
  openssl genpkey -algorithm ec -pkeyopt ec_paramgen_curve:P-521 | openssl pkcs8 -topk8 -outform der -nocrypt > ECC_NIST_P521_PrivateKey.der
  
  openssl genpkey -algorithm ec -pkeyopt ec_paramgen_curve:secp256k1 | openssl pkcs8 -topk8 -outform der -nocrypt > ECC_SECG_P256K1_PrivateKey.der
  ```
+ SM2 chaves privadas (somente regiões da China)

  ```
  openssl genpkey -algorithm ec -pkeyopt ec_paramgen_curve:sm2 | openssl pkcs8 -topk8 -outform der -nocrypt > SM2_PrivateKey.der
  ```

## Exemplos de material de chave de criptografia com OpenSSL
<a name="importing-keys-encrypt-key-material-openssl"></a>

Os exemplos a seguir mostram como usar o [OpenSSL](https://openssl.org/) para criptografar seu material de chaves com a chave pública que você baixou. Para criptografar seu material de chave usando uma chave SM2 pública (somente para regiões da China), use a [`SM2OfflineOperationHelper`classe](offline-operations.md#key-spec-sm-offline-helper). Para obter mais informações sobre os tipos de material de chave compatíveis com cada algoritmo de empacotamento, consulte [Selecionar um algoritmo de empacotamento](importing-keys-get-public-key-and-token.md#select-wrapping-algorithm).

**Importante**  
Esses exemplos são apenas uma demonstração da prova de conceito. Para sistemas de produção, use um método mais seguro (tal como um HSM ou sistema de gerenciamento de chaves comercial) para gerar e armazenar seu material de chaves.  
A combinação a seguir NÃO é compatível: material de chave ECC\$1NIST\$1P521, especificação de chave de empacotamento pública RSA\$12048 e um algoritmo de empacotamento RSAES\$1OAEP\$1SHA\$1\$1.  
Não é possível empacotar diretamente o material de chave ECC\$1NIST\$1P521 com uma chave de empacotamento pública RSA\$12048. Use uma chave de empacotamento maior ou um algoritmo de empacotamento RSA\$1AES\$1KEY\$1WRAP\$1SHA\$1\$1.

------
#### [ RSAES\$1OAEP\$1SHA\$11 ]

AWS KMS suporta o RSAES\$1OAEP\$1SHA\$11 para chaves de criptografia simétricas (SYMMETRIC\$1DEFAULT), chaves privadas de curva elíptica (ECC), chaves privadas e chaves HMAC. SM2 

O RSAES\$1OAEP\$1SHA\$11 não é compatível com chaves privadas de RSA. Além disso, não é possível usar uma chave pública de empacotamento RSA\$12048 com nenhum algoritmo de empacotamento RSAES\$1OAEP\$1SHA\$1\$1 para empacotar uma chave privada ECC\$1NIST\$1P521 (secp521r1). Você dever usar uma chave pública de empacotamento maior ou um algoritmo de empacotamento RSA\$1AES\$1KEY\$1WRAP.

O exemplo a seguir criptografa seu material de chaves com a [chave pública que você baixou](importing-keys-get-public-key-and-token.md) e com o algoritmo de encapsulamento RSAES\$1OAEP\$1SHA\$11 e o salva no arquivo `EncryptedKeyMaterial.bin`. 

Neste exemplo:
+ *`WrappingPublicKey.bin`* é o arquivo que contém a chave pública de empacotamento baixada. 
+ *`PlaintextKeyMaterial.bin`* é o arquivo que contém o material de chave que você está criptografando, como `PlaintextKeyMaterial.bin`, `HMAC_384_PlaintextKey.bin` ou `ECC_NIST_P521_PrivateKey.der`.

```
$ openssl pkeyutl \
    -encrypt \
    -in PlaintextKeyMaterial.bin \
    -out EncryptedKeyMaterial.bin \
    -inkey WrappingPublicKey.bin \
    -keyform DER \
    -pubin \
    -pkeyopt rsa_padding_mode:oaep \
    -pkeyopt rsa_oaep_md:sha1
```

------
#### [ RSAES\$1OAEP\$1SHA\$1256 ]

AWS KMS suporta o RSAES\$1OAEP\$1SHA\$1256 para chaves de criptografia simétricas (SYMMETRIC\$1DEFAULT), chaves privadas de curva elíptica (ECC), chaves privadas e chaves HMAC. SM2 

O RSAES\$1OAEP\$1SHA\$1256 não é compatível com chaves privadas de RSA. Além disso, não é possível usar uma chave pública de empacotamento RSA\$12048 com nenhum algoritmo de empacotamento RSAES\$1OAEP\$1SHA\$1\$1 para empacotar uma chave privada ECC\$1NIST\$1P521 (secp521r1). Você dever usar uma chave pública maior ou um algoritmo de empacotamento RSA\$1AES\$1KEY\$1WRAP.

O exemplo a seguir criptografa o material de chaves com a [chave pública que você baixou](importing-keys-get-public-key-and-token.md) e com o algoritmo de empacotamento RSAES\$1OAEP\$1SHA\$1256 e o salva no arquivo `EncryptedKeyMaterial.bin`. 

Neste exemplo:
+ *`WrappingPublicKey.bin`* é o arquivo que contém a chave de empacotamento pública baixada. Se você fez download da chave pública do console, esse arquivo será chamado `wrappingKey_KMS key_key_ID_timestamp` (por exemplo, `wrappingKey_f44c4e20-f83c-48f4-adc6-a1ef38829760_0809092909`). 
+ *`PlaintextKeyMaterial.bin`* é o arquivo que contém o material de chave que você está criptografando, como `PlaintextKeyMaterial.bin`, `HMAC_384_PlaintextKey.bin` ou `ECC_NIST_P521_PrivateKey.der`.

```
$ openssl pkeyutl \
    -encrypt \
    -in PlaintextKeyMaterial.bin \
    -out EncryptedKeyMaterial.bin \
    -inkey WrappingPublicKey.bin \
    -keyform DER \
    -pubin \
    -pkeyopt rsa_padding_mode:oaep \
    -pkeyopt rsa_oaep_md:sha256 \
    -pkeyopt rsa_mgf1_md:sha256
```

------
#### [ RSA\$1AES\$1KEY\$1WRAP\$1SHA\$11 ]

O algoritmo de empacotamento RSA\$1AES\$1KEY\$1WRAP\$1SHA\$11 envolve duas operações de criptografia.

1. Criptografe o material de chaves com uma chave simétrica AES que você gera e um algoritmo de criptografia simétrica AES.

1. Criptografe a chave simétrica AES que você usou com a chave pública que você baixou e o algoritmo de empacotamento RSAES\$1OAEP\$1SHA\$11.

O algoritmo de empacotamento RSA\$1AES\$1KEY\$1WRAP\$1SHA\$11 requer OpenSSL versão 3.*x* ou superior.

1. 

**Gerar uma chave de criptografia simétrica AES de 256 bits**

   Esse comando gera uma chave de criptografia simétrica AES que consiste em 256 bits aleatórios e a salva no arquivo `aes-key.bin`

   ```
   # Generate a 32-byte AES symmetric encryption key
   $ openssl rand -out aes-key.bin 32
   ```

1. 

**Criptografar o material de chave com a chave de criptografia simétrica AES**

   Esse comando criptografa o material da chave com a chave de criptografia simétrica AES e salva o material da chave criptografada no arquivo `key-material-wrapped.bin`.

   Neste comando de exemplo:
   + *`PlaintextKeyMaterial.bin`* é o arquivo que contém o material de chave que você está importando, como `PlaintextKeyMaterial.bin`, `HMAC_384_PlaintextKey.bin`, `RSA_3072_PrivateKey.der` ou `ECC_NIST_P521_PrivateKey.der`.
   + *`aes-key.bin`* é o arquivo que contém a chave de criptografia simétrica AES de 256 bits que você gerou no comando anterior.

   ```
   # Encrypt your key material with the AES symmetric encryption key
   $ openssl enc -id-aes256-wrap-pad \
           -K "$(xxd -p < aes-key.bin | tr -d '\n')" \
           -iv A65959A6 \
           -in PlaintextKeyMaterial.bin \
           -out key-material-wrapped.bin
   ```

1. 

**Criptografar a chave de criptografia simétrica AES com a chave pública**

   Esse comando criptografa sua chave de criptografia simétrica AES com a chave pública que você baixou e o algoritmo de empacotamento RSAES\$1OAEP\$1SHA\$11, a codifica em DER e a salva no arquivo `aes-key-wrapped.bin`. 

   Neste comando de exemplo:
   + *`WrappingPublicKey.bin`* é o arquivo que contém a chave de empacotamento pública baixada. Se você fez download da chave pública do console, esse arquivo será chamado `wrappingKey_KMS key_key_ID_timestamp` (por exemplo, `wrappingKey_f44c4e20-f83c-48f4-adc6-a1ef38829760_0809092909`
   + *`aes-key.bin`* é o arquivo que contém a chave de criptografia simétrica AES de 256 bits que você gerou no primeiro comando dessa sequência de exemplos.

   ```
   # Encrypt your AES symmetric encryption key with the downloaded public key
   $ openssl pkeyutl \
       -encrypt \
       -in aes-key.bin \
       -out aes-key-wrapped.bin \
       -inkey WrappingPublicKey.bin \
       -keyform DER \
       -pubin \
       -pkeyopt rsa_padding_mode:oaep \
       -pkeyopt rsa_oaep_md:sha1 \
       -pkeyopt rsa_mgf1_md:sha1
   ```

1. 

**Gerar o arquivo a ser importado**

   Concatene o arquivo com o material da chave criptografada e o arquivo com a chave AES criptografada. Salve-os no arquivo `EncryptedKeyMaterial.bin`, que é o arquivo que você importará no [Etapa 4: Importar o material de chave](importing-keys-import-key-material.md).

   Neste comando de exemplo:
   + *`key-material-wrapped.bin`* é o arquivo que contém o material de chaves criptografado.
   + *`aes-key-wrapped.bin`* é o arquivo que contém a chave de criptografia AES criptografada.

   ```
   # Combine the encrypted AES key and encrypted key material in a file
   $ cat aes-key-wrapped.bin key-material-wrapped.bin > EncryptedKeyMaterial.bin
   ```

------
#### [ RSA\$1AES\$1KEY\$1WRAP\$1SHA\$1256 ]

O algoritmo de empacotamento RSA\$1AES\$1KEY\$1WRAP\$1SHA\$1256 envolve duas operações de criptografia.

1. Criptografe o material de chaves com uma chave simétrica AES que você gera e um algoritmo de criptografia simétrica AES.

1. Criptografe a chave simétrica AES que você usou com a chave pública que você baixou e o algoritmo de empacotamento RSAES\$1OAEP\$1SHA\$1256.

O algoritmo de empacotamento RSAES\$1OAEP\$1SHA\$1256 requer OpenSSL versão 3.*x* ou superior.

1. 

**Gerar uma chave de criptografia simétrica AES de 256 bits**

   Esse comando gera uma chave de criptografia simétrica AES que consiste em 256 bits aleatórios e a salva no arquivo `aes-key.bin`

   ```
   # Generate a 32-byte AES symmetric encryption key
   $ openssl rand -out aes-key.bin 32
   ```

1. 

**Criptografar o material de chave com a chave de criptografia simétrica AES**

   Esse comando criptografa o material da chave com a chave de criptografia simétrica AES e salva o material da chave criptografada no arquivo `key-material-wrapped.bin`.

   Neste comando de exemplo:
   + *`PlaintextKeyMaterial.bin`* é o arquivo que contém o material de chave que você está importando, como `PlaintextKeyMaterial.bin`, `HMAC_384_PlaintextKey.bin`, `RSA_3072_PrivateKey.der` ou `ECC_NIST_P521_PrivateKey.der`.
   + *`aes-key.bin`* é o arquivo que contém a chave de criptografia simétrica AES de 256 bits que você gerou no comando anterior.

   ```
   # Encrypt your key material with the AES symmetric encryption key
   $ openssl enc -id-aes256-wrap-pad \
           -K "$(xxd -p < aes-key.bin | tr -d '\n')" \
           -iv A65959A6 \
           -in PlaintextKeyMaterial.bin \
           -out key-material-wrapped.bin
   ```

1. 

**Criptografar a chave de criptografia simétrica AES com a chave pública**

   Esse comando criptografa a chave de criptografia simétrica AES com a chave pública que você baixou e o algoritmo de empacotamento RSAES\$1OAEP\$1SHA\$1256, a codifica em DER e a salva no arquivo `aes-key-wrapped.bin`. 

   Neste comando de exemplo:
   + *`WrappingPublicKey.bin`* é o arquivo que contém a chave de empacotamento pública baixada. Se você fez download da chave pública do console, esse arquivo será chamado `wrappingKey_KMS key_key_ID_timestamp` (por exemplo, `wrappingKey_f44c4e20-f83c-48f4-adc6-a1ef38829760_0809092909`
   + *`aes-key.bin`* é o arquivo que contém a chave de criptografia simétrica AES de 256 bits que você gerou no primeiro comando dessa sequência de exemplos.

   ```
   # Encrypt your AES symmetric encryption key with the downloaded public key
   $ openssl pkeyutl \
       -encrypt \
       -in aes-key.bin \
       -out aes-key-wrapped.bin \
       -inkey WrappingPublicKey.bin \
       -keyform DER \
       -pubin \
       -pkeyopt rsa_padding_mode:oaep \
       -pkeyopt rsa_oaep_md:sha256 \
       -pkeyopt rsa_mgf1_md:sha256
   ```

1. 

**Gerar o arquivo a ser importado**

   Concatene o arquivo com o material da chave criptografada e o arquivo com a chave AES criptografada. Salve-os no arquivo `EncryptedKeyMaterial.bin`, que é o arquivo que você importará no [Etapa 4: Importar o material de chave](importing-keys-import-key-material.md).

   Neste comando de exemplo:
   + *`key-material-wrapped.bin`* é o arquivo que contém o material de chaves criptografado.
   + *`aes-key-wrapped.bin`* é o arquivo que contém a chave de criptografia AES criptografada.

   ```
   # Combine the encrypted AES key and encrypted key material in a file
   $ cat aes-key-wrapped.bin key-material-wrapped.bin > EncryptedKeyMaterial.bin
   ```

------

Vá para [Etapa 4: Importar o material de chave](importing-keys-import-key-material.md).