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

Resolução

Primeiro, criptografe sua chave de carga útil com uma chave efêmera do Advanced Encryption Standard (AES). Em seguida, criptografe a 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.

Crie estas chaves:

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

Antes de começar, certifique-se de ter o OpenSSL v 3.x para usar o envelop wrap:

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

Nos comandos a seguir, substitua esses 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 atribuído à sua chave pública RSA para empacotamento
• YOUR_UNWRAPPING_KEY_LABEL com o rótulo de chave atribuído à sua chave privada RSA para desempacotamento
• YOUR_IMPORTED_KEY_LABEL com o rótulo de chave atribuído à chave de carga útil importada

Observação: O comando key generate-file e o comando key unwrap exigem que as chaves de encapsulamento sejam identificáveis de forma exclusiva, pois os rótulos das chaves são uma condição de filtro. Certifique-se de que YOUR_WRAPPING_KEY_LABEL e YOUR_UNWRAPPING_KEY_LABEL sejam rótulos de chave exclusivos. 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 o seguinte comando:

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 essas chaves no seu próprio diretório.

2. Para gerar 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 o utilitário hexdump instalado. 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 encapsular a carga útil com a chave AES efêmera, execute o comando enc OpenSSL:

   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 corresponde a 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. Criptografe a chave AES com a chave pública do par de chaves RSA:

   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 desempacotar 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 desempacotar as chaves AES. Com base no uso da chave, use --attributes para atribuir atributos de chave. Para obter mais informações sobre opções e atributos-chave, consulte o exemplo de key unwrap rsa-aes e Key attributes for CloudHSM CLI, respectivamente.

   Você recebe uma importação bem-sucedida 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

Para importar a carga útil, 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