Como usar o OpenSSL e a ferramenta de linha de comando do CloudHSM para transferir minhas chaves com segurança para o CloudHSM?

Breve descrição

Primeiro, criptografe sua chave de carga útil com uma chave efêmera do Advanced Encryption Standard (AES). Em seguida, criptografe a chave AES efêmera com sua chave pública de um par de chaves. Por fim, junte a chave de carga útil criptografada e a chave efêmera criptografada em um único arquivo. O arquivo é enviado ao CloudHSM em formato criptografado e a chave privada descriptografa o arquivo do par de chaves. O mecanismo AES_KEY_WRAP decodifica a chave AES efêmera e a usa para descriptografar sua chave de carga útil.

Observação: conclua as etapas a seguir em uma instância do Amazon Elastic Compute Cloud (Amazon EC2) que executa Linux. É uma prática recomendada usar uma imagem de máquina da Amazon (AMI) do Amazon Linux 2023 que inclui a versão e os utilitários necessários do OpenSSL.

Crie estas chaves:

• Chave AES, RSA ou EC de carga útil que você importa e usa com seu CloudHSM.
• Chave AES temporária que AES_KEY_WRAP exige para criptografar a carga útil. Esta é uma prática recomendada para usar a AES porque não há limites de tamanho do que é possível criptografar.
• Par de chaves RSA para encapsular e desencapsular com segurança as chaves no seu CloudHSM.

Para usar o envelop wrap, você deve ter o OpenSSL versão 3.x.

Para determinar a versão do OpenSSL que você tem, execute o seguinte comando:

openssl version

Exemplo de saída:

OpenSSL 3.0.8 7 Feb 2023 (Library: OpenSSL 3.0.8 7 Feb 2023)

Resolução

Observação: nos comandos seguintes, substitua os seguintes valores pelos seus próprios valores:

• YOUR_CRYPTO_USER_NAME com seu nome de usuário criptográfico
• YOUR_CRYPTO_USER_PASSWORD com sua senha
• YOUR_WRAPPING_KEY_LABEL com o rótulo de chave que você atribuiu para encapsular sua chave pública RSA
• YOUR_UNWRAPPING_KEY_LABEL com o rótulo de chave que você atribuiu para desencapsular sua chave privada RSA
• YOUR_IMPORTED_KEY_LABEL com o rótulo de chave atribuído à chave de carga útil importada

Seus rótulos de chave de encapsular e desencapsular devem ser exclusivos, pois os rótulos de chave são uma condição de filtro para os comandos key generate-file e key unwrap. Ou use uma condição de filtro diferente para identificar chaves de forma exclusiva. Para obter mais informações sobre filtros de chaves, consulte Filtrar chaves usando a CLI do CloudHSM.

Defina credenciais de usuário criptográfico para a CLI do CloudHSM

Execute os seguintes comandos:

export CLOUDHSM_ROLE="crypto-user"
export CLOUDHSM_PIN="YOUR_CRYPTO_USER_NAME:YOUR_CRYPTO_USER_PASSWORD"

Importe a carga útil do AES

Para criar, criptografar e importar as chaves locais, conclua as etapas a seguir:

1. Para criar as chaves AES, AES efêmeras e RSA de carga útil, execute os seguintes comandos:

   openssl rand -out payload_aes 32
   openssl rand -out ephemeral_aes 32
   /opt/cloudhsm/bin/cloudhsm-cli key generate-asymmetric-pair rsa --public-label YOUR_WRAPPING_KEY_LABEL --private-label YOUR_UNWRAPPING_KEY_LABEL --modulus-size-bits 4096 --public-exponent 65537 --private-attributes unwrap=true
   /opt/cloudhsm/bin/cloudhsm-cli key generate-file --encoding pem --path public.pem --filter attr.label=YOUR_WRAPPING_KEY_LABEL

   Observação: para rastrear seus arquivos, crie as chaves no seu próprio diretório.

2. Para inserir os valores hexadecimais brutos da chave AES efêmera em uma variável, execute o seguinte comando:

   EPHEMERAL_AES_HEX=$(hexdump -v -e '/1 "%02X"' < ephemeral_aes)

   Observação: certifique-se de ter instalado o utilitário hexdump. Se você não instalar o hexdump, o comando anterior retornará um erro. Consulte a documentação do seu sistema operacional (SO) para obter instruções sobre como instalar o utilitário hexdump.

3. Para usar a chave AES efêmera para encapsular a carga útil, execute o comando OpenSSL enc:

   openssl enc -id-aes256-wrap-pad -K $EPHEMERAL_AES_HEX -iv A65959A6 -in payload_aes -out payload_wrapped

   Observação: a cifra -id-aes256-wrap-pad é o mecanismo de encapsulamento compatível com a RFC 3394 que coexiste com CKM_RSA_AES_KEY_WRAP. A extensão RFC 3394, RFC 5649, define os valores -iv. Para obter mais informações, consulte Quebra de chave AES com algoritmo de preenchimento e algoritmo de quebra de chave AES no site da IETF.

4. Use a chave pública do par de chaves RSA para criptografar a chave AES:

   openssl pkeyutl -encrypt -in ephemeral_aes -out ephemeral_wrapped -pubin -inkey public.pem -pkeyopt rsa_padding_mode:oaep -pkeyopt rsa_oaep_md:sha1 -pkeyopt rsa_mgf1_md:sha1

5. Em sua máquina local, una a chave de carga útil criptografada e a chave AES efêmera em um único arquivo chamado rsa_aes_wrapped:

   cat ephemeral_wrapped payload_wrapped > rsa_aes_wrapped

6. Para usar a chave privada RSA com a chave unwrap rsa-aes para desencapsular a chave de carga útil unida no CloudHSM, execute o seguinte comando:

   /opt/cloudhsm/bin/cloudhsm-cli key unwrap rsa-aes --data-path rsa_aes_wrapped --key-type-class aes --label YOUR_IMPORTED_KEY_LABEL --hash-function sha1 --mgf mgf1-sha1 --filter attr.label=YOUR_UNWRAPPING_KEY_LABEL --attributes decrypt=true encrypt=true

   Observação: você deve usar --key-type-class aes para desencapsular as chaves AES. Com base no uso da chave, use --attributes para atribuir atributos de chave. Para mais informações sobre opções e atributos de chave, consulte Atributos de chave da CLI do CloudHSM e os exemplos de como usar o comando key unwrap rsa-aes.

   Você recebe uma importação da chave AES de carga útil semelhante à seguinte saída:

   {
     "error_code": 0,
     "data": {
       "key": {
         "key-reference": "0x000000000068031a",
         "key-info": {
           "key-owners": [
             {
               "username": "YOUR_CRYPTO_USER_NAME",
               "key-coverage": "full"
             }
           ],
           "shared-users": [],
           "cluster-coverage": "full"
         },
         "attributes": {
           "key-type": "aes",
           "label": "YOUR_IMPORTED_KEY_LABEL",
           "id": "0x",
           "check-value": "0xb31c2a",
           "class": "secret-key",
           "encrypt": true,
           "decrypt": true,
           "token": true,
           "always-sensitive": false,
           "derive": false,
           "destroyable": true,
           "extractable": true,
           "local": false,
           "modifiable": true,
           "never-extractable": false,
           "private": true,
           "sensitive": true,
           "sign": true,
           "trusted": false,
           "unwrap": false,
           "verify": true,
           "wrap": false,
           "wrap-with-trusted": false,
           "key-length-bytes": 32
         }
       }
     }
   }

Importar a carga útil RSA

Conclua as etapas a seguir:

1. Para desencapsular uma chave privada RSA no CloudHSM, execute os seguintes comandos para transformar a chave de carga útil em uma chave privada RSA:

   openssl genrsa -out payload_rsa.pem 2048
   openssl rand -out ephemeral_aes 32

2. Use um editor de texto simples para verificar o formato das chaves RSA:

   PKCS1 format: -----BEGIN RSA PRIVATE KEY----- - PKCS8 format: -----BEGIN PRIVATE KEY-----

   Observação: as chaves RSA estão no formato PKCS #1. No entanto, a CLI do CloudHSM presume que a chave privada esteja no formato PKCS #8 DER.

3. Para converter a chave payload_rsa.pem no formato PKCS #8 e codificado em DER, execute o seguinte comando:

   openssl pkcs8 -topk8 -inform PEM -outform DER -in payload_rsa.pem -out payload_rsa_pkcs8.der -nocrypt

4. Conclua as etapas 2 a 5 na seção Importar a carga útil do AES. Substitua payload_aes por payload_rsa_pkcs8.der.

5. Para desempacotar a chave privada RSA de carga útil no CloudHSM, execute o seguinte comando:

   /opt/cloudhsm/bin/cloudhsm-cli key unwrap rsa-aes --data-path rsa_aes_wrapped --key-type-class rsa-private --label YOUR_IMPORTED_KEY_LABEL --hash-function sha1 --mgf mgf1-sha1 --filter attr.label=YOUR_UNWRAPPING_KEY_LABEL --attributes decrypt=true sign=true

   Observação: você deve usar --key-type-class rsa-private para desempacotar as chaves RSA. Com base no uso da chave, use --attributes para atribuir atributos de chave.

Importe a carga útil de EC

Para importar a carga útil, conclua as etapas a seguir:

1. Para desencapsular uma chave privada EC no CloudHSM, execute os seguintes comandos para transformar a chave de carga útil em uma chave privada EC:

   openssl ecparam -name secp256k1 -genkey -noout -out payload_ec.pemopenssl rand -out ephemeral_aes 32

2. Use um editor de texto simples para verificar o formato das chaves EC:

   PKCS1 format: -----BEGIN EC PRIVATE KEY----- - PKCS8 format: -----BEGIN PRIVATE KEY-----

   Observação: as chaves EC estão no formato PKCS #1. No entanto, a CLI do CloudHSM presume que a chave privada esteja no formato PKCS #8 DER.

3. Para converter a chave payload_ec.pem no formato PKCS #8 e codificado em DER, execute o seguinte comando:

   openssl pkcs8 -topk8 -inform PEM -outform DER -in payload_ec.pem -out payload_ec_pkcs8.der -nocrypt

4. Conclua as etapas 2 a 5 na seção Importar a carga útil do AES. Substitua payload_aes por payload_ec_pkcs8.der.

5. Para desempacotar a chave privada EC de carga útil no CloudHSM, execute o seguinte comando:

   /opt/cloudhsm/bin/cloudhsm-cli key unwrap rsa-aes --data-path rsa_aes_wrapped --key-type-class ec-private --label YOUR_IMPORTED_KEY_LABEL --hash-function sha1 --mgf mgf1-sha1 --filter attr.label=YOUR_UNWRAPPING_KEY_LABEL --attributes decrypt=true sign=true

   Observação: você deve usar --key-type-class ec-private para desempacotar as chaves EC. Com base no uso da chave, use --attributes para atribuir atributos de chave.

Informações relacionadas

Mecanismos compatíveis com a biblioteca PKCS #11 para o AWS CloudHSM Client SDK 5