Como encapsular uma chave usando o OpenSSL no Linux

Neste tópico, mostramos como encapsular uma chave manualmente antes de importá-la para o Cloud KMS. Você só precisa seguir as instruções neste tópico se não quiser usar a ferramenta de linha de comando gcloud para encapsular automaticamente a chave antes de importá-la. Para uma visão geral das diferenças, consulte Como a importação de chave funciona.

Você pode concluir as etapas deste tópico em 5 a 10 minutos, sem incluir as etapas Antes de começar.

Antes de começar

Antes de envolver uma chave, você precisa concluir os seguintes pré-requisitos:

1. Crie um keyring e uma chave de segmentação e crie um job de importação.
2. Verifique se a chave está disponível localmente e formatada corretamente para importação no Cloud KMS.
3. Corrigir e recompilar o OpenSSL

Recuperar a chave de encapsulamento

Esta seção mostra como recuperar a chave de encapsulamento do job de importação criado em Antes de começar. É recomendável usar o Console do Google Cloud.

Console

1. Acesse a página Chaves criptográficas no Console do Cloud.

   Acessar a página "Chaves criptográficas"

2. Clique no nome do keyring que contém o job de importação.

3. Clique na guia Jobs de importação na parte superior da página.

4. Clique em Mais e em Fazer o download da chave de encapsulamento no menu pop-up.

gcloud

Para verificar se o job de importação está ativo, execute o comando gcloud kms import-jobs describe:

gcloud kms import-jobs describe import-job \
  --location location \
  --keyring key-ring-name \
  --format="value(state)"

state: ACTIVE

Executar o seguinte comando para salvar a chave pública do job de importação em ${HOME}/wrapping-key.pem

gcloud kms import-jobs describe \
  --location=location \
  --keyring=keyring \
  --format="value(publicKey.pem)" \
  import-job-name > ${HOME}/wrapping-key.pem

Observação: você só precisa fazer o download da chave pública uma vez e usá-la até que o job de importação expire.

API

1. Chame o método [ImportJob.get][11].

2. Recupere a chave pública por meio do campo [13][publicKey] da resposta ImportJob.get. Esse valor é do tipo [WrappingPublicKey][14]. O campo [21][pem] do tipo [22][WrappingPublicKey] é a chave pública codificada no formato Privacy Enhanced Mail (PEM).

Para mais informações sobre o formato codificado PEM, consulte RFC 7468, , especialmente as Considerações gerais e as seções Codificação textual das Informações de chave pública do assunto (página em inglês).

Configurar variáveis de ambiente

Os comandos OpenSSL requerem vários caminhos de arquivo como valores de entrada. Defina variáveis de ambiente aos caminhos de arquivo para facilitar a execução dos comandos.

Observação: se quiser, salve todos esses comandos em um script de shell e execute o script para definir as variáveis de uma só vez. Talvez seja necessário ajustar alguns dos valores de cada chave que você quer encapsular.

1. Defina a variável OpenSSL_V110 como o caminho do script openssl.sh. Se você seguiu as instruções para corrigir e recompilar o OpenSSL exatamente, pode usar esse comando sem modificar o valor da variável.

   OPENSSL_V110="${HOME}/local/bin/openssl.sh"
   

2. Defina a variável PUB_WRAPPING_KEY como o caminho completo para a chave de encapsulamento do job de importação. A chave de encapsulamento termina em .pem.

   Os comandos a seguir definem a variável PUB_WRAPPING_KEY como ${HOME}/wrapping-key.pem.

   PUB_WRAPPING_KEY="${HOME}/wrapping-key.pem"
   

3. Defina a variável TARGET_KEY como o caminho completo para a chave não encapsulada.

   • Para chaves simétricas, defina TARGET_KEY como o caminho para o arquivo .bin.
   • Para chaves assimétricas, defina TARGET_KEY como o caminho para o arquivo .der.

   TARGET_KEY=/path/to/key
   

4. Defina a variável BASE_DIR como um diretório em que os arquivos temporários podem ser gravados e crie o diretório, se necessário. Esse diretório precisa ser acessível apenas pelo usuário atual. Não use um caractere / no final do nome do diretório.

   BASE_DIR="${HOME}/wrap_tmp"
   mkdir -m 700 -p ${BASE_DIR}
   

5. Defina as variáveis de ambiente para os três arquivos intermediários.

   TEMP_AES_KEY="${BASE_DIR}/temp_aes_key.bin"
   TEMP_AES_KEY_WRAPPED="${BASE_DIR}/temp_aes_key_wrapped.bin"
   TARGET_KEY_WRAPPED="${BASE_DIR}/target_key_wrapped.bin"
   

6. Defina a variável RSA_AES_WRAPPED_KEY como o caminho completo para gravar a chave de segmentação encapsulada que você eventualmente importará e verifique se você tem acesso para gravar no diretório.

   RSA_AES_WRAPPED_KEY=/path/to/wrapped-target-key.bin
   mkdir -m u+wx -p $(dirname ${RSA_AES_WRAPPED_KEY})
   

7. Verifique se todas as variáveis de ambiente estão definidas corretamente usando os seguintes comandos:

   echo "OPENSSL_V110: " ${OPENSSL_V110}; \
   echo "PUB_WRAPPING_KEY: " ${PUB_WRAPPING_KEY}; \
   echo "TARGET_KEY: " ${TARGET_KEY}; \
   echo "BASE_DIR: " ${BASE_DIR}; \
   echo "TEMP_AES_KEY: " ${TEMP_AES_KEY}; \
   echo "TEMP_AES_KEY_WRAPPED: " ${TEMP_AES_KEY_WRAPPED}; \
   echo "TARGET_KEY_WRAPPED: " ${TARGET_KEY_WRAPPED}; \
   echo "RSA_AES_WRAPPED_KEY: " ${RSA_AES_WRAPPED_KEY}
   

Quando as variáveis estiverem definidas corretamente, você estará pronto para encapsular a chave.

Unir a chave

1. Execute o comando a seguir para gerar uma chave AES aleatória temporária de 32 bytes e salvá-la no local apontado por ${TEMP_AES_KEY}.

   "${OPENSSL_V110}" rand -out "${TEMP_AES_KEY}" 32
   

2. Encapsule a chave temporária AES com a chave pública encapsulada usando o algoritmo CKM_RSA_PKCS_OAEP.

   "${OPENSSL_V110}" rsautl \
      -encrypt \
      -pubin \
      -inkey "${PUB_WRAPPING_KEY}" \
      -in "${TEMP_AES_KEY}" \
      -out "${TEMP_AES_KEY_WRAPPED}" \
      -oaep
   

3. Una a chave de destino com a chave AES temporária usando o algoritmo CKM_AES_KEY_WRAP_PAD. Substitua target-key-file pelo nome do arquivo .bin ou pub da chave.

   "${OPENSSL_V110}" enc \
     -id-aes256-wrap-pad \
     -iv A65959A6 \
     -K $( hexdump -v -e '/1 "%02x"' < "${TEMP_AES_KEY}" ) \
     -in "${TARGET_KEY}" \
     -out "${TARGET_KEY_WRAPPED}"
   

   A sinalização -iv A65959A6 define A65959A6 como o valor inicial alternativo. Isso é exigido pela especificação RFC 5649.

   Agora você configurou duas chaves:

   • ${TEMP_AES_KEY_WRAPPED} é a chave AES temporária que você criou no sistema local, encapsulada com a chave pública do job de importação.
   • ${TARGET_KEY_WRAPPED} é a chave de segmentação que você importará, encapsulada com a chave AES temporária que você gerou.

4. Concatene as duas chaves encapsuladas e grave a saída em um único arquivo. Não modifique a ordem das duas chaves no comando abaixo; a chave temporária precisa vir antes da chave de destino.

   Aviso: este comando substitui qualquer arquivo atual apontado pela variável ${RSA_AES_WRAPPED_KEY}.

   cat "${TEMP_AES_KEY_WRAPPED}" "${TARGET_KEY_WRAPPED}" > "${RSA_AES_WRAPPED_KEY}"
   

5. Exclua os arquivos intermediários que não são mais necessários.

   rm ${BASE_DIR}/*
   

Sua chave encapsulada existe na variável ${RSA_AES_WRAPPED_KEY} do local, e você pode fazer uma solicitação para importar sua chave.