Observação:

• Este tutorial requer acesso ao Oracle Cloud. Para se inscrever e obter uma conta gratuita, consulte Conceitos Básicos do Oracle Cloud Infrastructure Free Tier.
• Ele usa valores de exemplo para credenciais, tenancy e compartimentos do Oracle Cloud Infrastructure. Ao concluir seu laboratório, substitua esses valores por valores específicos do seu ambiente de nuvem.

Criar redundância para Chaves Assimétricas nos Vaults Virtuais do Oracle Cloud Infrastructure

Introdução

No mundo digital acelerado de hoje, a segurança de dados é de extrema importância. À medida que as organizações dependem cada vez mais de uma infraestrutura baseada em nuvem, garantir que a confidencialidade de informações confidenciais se torne primordial. Para isso, geralmente eles usam criptografia, o que requer gerenciamento de chaves seguro. No entanto, o gerenciamento de chaves pode representar desafios significativos, especialmente quando se trata de redundância e disponibilidade. Neste post no blog, exploraremos como você pode obter redundância para chaves assimétricas em vaults virtuais e como os aplicativos em duas regiões diferentes podem aproveitar isso para criptografia e decriptografia.

O Oracle Cloud Infrastructure (OCI) oferece VPV (Virtual Private Vault), um serviço de gerenciamento de chaves totalmente gerenciado que permite gerenciar de forma centralizada as chaves usadas para criptografia de dados, decriptografia e assinatura. Um dos recursos mais críticos do VPV é o backup e a restauração entre regiões. Com esse recurso, você pode fazer backup e restaurar chaves entre regiões, tornando-as disponíveis para uso em uma região diferente da onde foram criadas.

Vale ressaltar que o backup e a restauração só funcionam para o VPV, não para o VV (Virtual Vault), outro serviço de gerenciamento de chaves oferecido pela OCI. Além disso, não há como fazer backup das chaves do Módulo de Segurança de Hardware (HSM) no Vault Virtual. No entanto, com a opção de tecla BYOK (Bring Your Own Key)/importar, você pode importar o mesmo material de chave em dois cofres de regiões diferentes e, mesmo que uma região esteja totalmente inativa, a cópia em outra região servirá como backup. Essa redundância garante que suas chaves estejam sempre disponíveis, mesmo que uma região experimente uma interrupção ou um desastre. Ele também permite que você atenda aos requisitos regulatórios e de conformidade que determinam a redundância principal e a recuperação de desastres.

Objetivo

Este tutorial orienta você pelas etapas de alto nível para importar a mesma chave RSA para vaults virtuais localizados em duas regiões diferentes. A importação de chaves será executada em uma região usando um procedimento passo a passo, enquanto um script será utilizado na outra região para a importação. Depois de importar a chave, criptografaremos os dados de teste usando a chave em uma região e, em seguida, descriptografaremos o texto de criptografia resultante usando a mesma chave no vault localizado na outra região.

Pré-requisitos

Uma conta do OCI com acesso para criar e gerenciar Vaults e Chaves.

Observação: Para o cenário "Traga sua própria chave (BYOK), você deve aplicar patch ao OpenSSL. Para aplicar patch a OpenSSL, é necessário acesso privilegiado para executar os comandos de shell necessários. É recomendável executar os comandos de shell em uma caixa Linux com acesso privilegiado. Os comandos da CLI do OCI podem ser executados no shell da nuvem ou em uma caixa do Linux em que a CLI do OCI está instalada e configurada. Siga este procedimento para instalar e configurar a CLI do OCI em uma caixa do Linux.

Tarefa 1: Importar chave para um vault na primeira região (exemplo:Phoenix)

Siga este procedimento para importar uma Chave Assimétrica (RSA) para um Vault Virtual.

1. Aplique patch ao OpenSSL: Para o cenário "Traga sua própria chave (BYOK)", você deve aplicar patch ao OpenSSL para encapsulamento RSA_OAEP_AES_SHA256. Siga este procedimento para aplicar patch ao OpenSSL.

2. Gere o material-chave: Use o material-chave gerado por uma ferramenta ou origem com base em seus requisitos. Neste tutorial, estamos usando OpenSSL para gerar o material da chave.

   $HOME/local/bin/openssl.sh genrsa -out PRIVATEKEY.pem 2048
   
   

3. Obter a Chave de Finalização RSA Pública.

   oci kms management wrapping-key get --endpoint <control_plane_URL>
   
   

   oci kms management wrapping-key get --endpoint https://abcdefghijk-management.kms.us-phoenix-1.oraclecloud.com --raw-output --query 'data."public-key"' > VAULT_PUBLIC_WRAPPING_KEY.pem
   
   

4. Aplique o RSA-OAEP com o AES para encapsular o material da chave usando a interface CLI.

   a. Gerar uma chave AES temporária.

   openssl rand -out <temporary_AES_key_path> 32
   
   

   $HOME/local/bin/openssl.sh rand -out TEMP_AES_KEY.key 32
   
   

   b. Encapsule a chave AES temporária com a chave de encapsulamento pública usando RSA-OAEP com SHA-256.

   openssl pkeyutl -encrypt -in <temporary_AES_key_path> -inkey <vault_public_wrapping_key_path> -pubin -out <wrapped_temporary_AES_key_file> -pkeyopt rsa_padding_mode:oaep -pkeyopt rsa_oaep_md:sha256
   
   

   $HOME/local/bin/openssl.sh pkeyutl -encrypt -in TEMP_AES_KEY.key -inkey VAULT_PUBLIC_WRAPPING_KEY.pem -pubin -out WRAPPED_TEMP_AES_KEY.bin -pkeyopt rsa_padding_mode:oaep -pkeyopt rsa_oaep_md:sha256
   
   

   c. Gere hexadecimal do material da chave AES temporária.

   temporary_AES_key_hexdump=$(hexdump -v -e '/1 "%02x"' < temporary_AES_key_path)
   
   

   TEMPORARY_AES_KEY_HEXDUMP=$(hexdump -v -e '/1 "%02x"' < TEMP_AES_KEY.key)
   
   

   d. Se a chave privada RSA que você deseja importar estiver no formato PEM, converta-a em DER.

   ${OpenSSL_path} pkcs8 -topk8 -nocrypt -inform PEM -outform DER -in <your_pem_RSA_private_key_path> -out <your_RSA_private_key_file>
   
   

   $HOME/local/bin/openssl.sh pkcs8 -topk8 -nocrypt -inform PEM -outform DER -in PRIVATEKEY.pem -out TARGET_KEY.key
   
   

   e. Encapsule sua chave privada RSA com a chave AES temporária.

   openssl enc -id-aes256-wrap-pad -iv A65959A6 -K temporary_AES_key_hexdump -in <your_RSA_private_key_file> -out <wrapped_target_key_file>
   
   

   $HOME/local/bin/openssl.sh enc -id-aes256-wrap-pad -iv A65959A6 -K $TEMPORARY_AES_KEY_HEXDUMP -in TARGET_KEY.key -out WRAPPED_TARGET_KEY.bin
   
   

   f. Crie o material da chave encapsulado concatenando as duas chaves encapsuladas.

   cat <wrapped_temporary_AES_key_file> <wrapped_target_key_file> > <wrapped_key_material_file>
   
   

   cat WRAPPED_TEMP_AES_KEY.bin WRAPPED_TARGET_KEY.bin > WRAPPED_KEY_MATERIAL.bin
   
   

   g. Aplique a codificação base64 no material da chave encapsulado e, em seguida, importe-a para criar uma chave via CLI.

   base64 WRAPPED_KEY_MATERIAL.bin -w 0 > WRAPPED_KEY_MATERIAL.base64
   
   

5. Importe o Material da Chave como uma Chave Externa usando a CLI do OCI.

   oci kms management key import --wrapped-import-key <wrapped_key_material> --compartment-id <compartment_id> --display-name <key_name> --endpoint <control_plane_URL> --key-shape <key_encryption_information> --protection-mode <key_protection_mode>
   
   

   echo "{ \"wrappingAlgorithm\": \"RSA_OAEP_AES_SHA256\", \"keyMaterial\": \"$(cat WRAPPED_KEY_MATERIAL.base64)\" }" > WRAPPED_IMPORT_KEY.json
   
   

   echo "{ \"algorithm\": \"RSA\", \"length\": \"256\" }" > KEY_SHAPE.json
   
   

   oci kms management key import --wrapped-import-key file://WRAPPED_IMPORT_KEY.json --compartment-id ocid1.compartment.oc1..aaaaaaaabbbbbbbbbccccccccdddddddeeeeeefffff --display-name IMPORTEDKEY --endpoint https://abcdefghijk-management.kms.us-phoenix-1.oraclecloud.com --key-shape file://KEY_SHAPE.json --protection-mode SOFTWARE
   
   

Tarefa 2: Importar a mesma chave para um vault virtual na segunda região (exemplo: Ashburn)

• Use o script a seguir para importar uma Chave Assimétrica (RSA) para um Vault Virtual.

• Abra um prompt de comando e execute o script a seguir, substituindo os nomes e valores do arquivo de exemplo conforme apropriado.

  #!/bin/bash
  
  #This script is for demonstration purposes only. It provides
  #a functioning set of calls to show how to import RSA keys
  #into the OCI Vault service.
  
  set -e;
  #set -x;
  
  #OPENSSL_PATH="<path to patched openssl.sh>"
  #PRIVATE_KEY="<path to target private key which needs to be imported>"
  #KEY_SIZE="<key size in bytes>"
  #DISPLAY_NAME="<Display Name>"
  #VAULT_KEYMANAGEMENT_ENDPOINT="<Vault Management Endpoint>"
  #COMPARTMENT_ID="<Compartment OCID>"
  
  #Sample
  OPENSSL_PATH="$HOME/local/bin/openssl.sh"
  PRIVATE_KEY="$HOME/local/bin/PRIVATEKEY.pem"
  KEY_SIZE="256"
  DISPLAY_NAME="IMPORTEDKEY"
  VAULT_KEYMANAGEMENT_ENDPOINT="https://abceefghijk-management.kms.us-ashburn-1.oraclecloud.com"
  COMPARTMENT_ID="ocid1.compartment.oc1..aaaaaaaabbbbbbccccccccdddddddeeeeeeeffffffff"
  
  WORK_DIR=$(mktemp -d -t kms_XXXX)
  BASE64="base64"
  
  echo "Openssl Path: ${OPENSSL_PATH}"
  echo "Work Dir: ${WORK_DIR}"
  
  #Getting Vault Public RSA Wrapping Key
  oci kms management wrapping-key get --endpoint ${VAULT_KEYMANAGEMENT_ENDPOINT} --raw-output --query 'data."public-key"' > ${WORK_DIR}/vault_public_wrapping_key.pem
  WRAPPING_KEY="${WORK_DIR}/vault_public_wrapping_key.pem"
  
  #Convert the private key to PKCS8 DER format.
  target_key_path=${WORK_DIR}/target_key.key
  ${OPENSSL_PATH} pkcs8 -topk8 -nocrypt -inform PEM -outform DER -in ${PRIVATE_KEY} -out ${target_key_path}
  
  #Generate a temporary AES key.
  temp_aes_key_path=${WORK_DIR}/temp_aes_key.key
  ${OPENSSL_PATH} rand -out ${temp_aes_key_path} 32
  
  #Wrap the temporary AES key by using RSA-OAEP with SHA-256.
  wrapped_temp_aes_key=${WORK_DIR}/wrapped_temp_aes_key.bin
  ${OPENSSL_PATH} pkeyutl -encrypt -in ${temp_aes_key_path} -inkey ${WRAPPING_KEY} -pubin -out ${wrapped_temp_aes_key} -pkeyopt rsa_padding_mode:oaep -pkeyopt rsa_oaep_md:sha256
  
  #Wrap the target RSA key.
  wrapped_target_key=${WORK_DIR}/wrapped_target_key.bin
  temp_aes_key_hexdump=$(hexdump -v -e '/1 "%02x"' < ${temp_aes_key_path})
  ${OPENSSL_PATH} enc -id-aes256-wrap-pad -iv A65959A6 -K ${temp_aes_key_hexdump} -in ${target_key_path} -out ${wrapped_target_key}
  
  #Create the wrapped key material.
  wrapped_key_material_bin=${WORK_DIR}/wrapped_key_material.bin
  cat ${wrapped_temp_aes_key} ${wrapped_target_key} > ${wrapped_key_material_bin}
  
  echo "Binary wrapped key for console is available at: ${wrapped_key_material_bin}"
  
  #Import the wrapped key to the Vault service after base64 encoding the payload.
  
  wrapped_key_material_base64=${WORK_DIR}/wrapped_key_material.base64
  ${BASE64} ${wrapped_key_material_bin} -w 0 > ${wrapped_key_material_base64}
  echo "Base64 encoded wrapped key for CLI or API is available at: ${wrapped_key_material_base64}"
  
  #####1. IMPORT NEW KEY USING CONSOLE #####
  #browse and upload ${WORK_DIR}/wrapped_key_material.bin file in key import section on console.
  
  #####2. IMPORT NEW KEY USING OCI_CLI #####
  key_material=$(${BASE64} ${wrapped_key_material_bin})
  echo "{ \"wrappingAlgorithm\": \"RSA_OAEP_AES_SHA256\", \"keyMaterial\": \"$(cat ${wrapped_key_material_base64})\" }" > wrapped_import_key.json
  echo "{ \"algorithm\": \"RSA\", \"length\": ${KEY_SIZE} }" > key_shape.json
  
  oci kms management key import --wrapped-import-key file://wrapped_import_key.json --compartment-id ${COMPARTMENT_ID} --display-name ${DISPLAY_NAME} --endpoint ${VAULT_KEYMANAGEMENT_ENDPOINT} --key-shape file://key_shape.json --protection-mode SOFTWARE
  
  

Tarefa 3: Criptografar e Decriptografar seus Dados

Agora que você tem uma chave criada no seu vault, pode usá-la para criptografar e decriptografar seus dados.

• Obtenha o ID da chave que você criou. Você pode localizar o ID da chave clicando na sua chave no vault e procurando o campo "ID da Chave" no painel de detalhes da chave.

• Você pode usar as chaves para criptografar e decriptografar seus dados. Texto simples incluído na solicitação de exemplo é um valor base64-encoded de uma string UTF-8.

  • Texto simples: a OCI é uma infraestrutura de nuvem pública de segurança em primeiro lugar

  • Base64: T0NJIGlzIGEgc2VjdXJpdHktZmlyc3QgcHVibGljIGNsb3VkIGluZnJhc3RydWN0dXJl

1. Criptografe usando a Chave RSA presente no vault da primeira região.

   oci kms crypto encrypt --key-id <key_ocid> --plaintext <plaintext Base64 Encoded> --encryption-algorithm <Encryption Algorithm> --endpoint <Vault Crypto Endpoint>

   • Para criptografar usando o algoritmo de criptografia de chave RSA, o parâmetro é obrigatório e os valores aceitos são RSA_OAEP_SHA_1, RSA_OAEP_SHA_256

     

2. Decriptografar usando a Chave RSA presente no vault da segunda região.

   oci kms crypto decrypt --key-id <key_ocid> --ciphertext <cipher text> --encryption-algorithm <Encryption Algorithm> --endpoint <Vault Crypto Endpoint>

   

O OCI Key Management oferece recursos robustos que permitem obter redundância de chaves e gerenciar com segurança suas chaves de criptografia. Com backup, restauração e replicação entre regiões para Vault Virtual Privado e opção de importação BYOK/chave para o vault virtual, você pode garantir que seus dados permaneçam seguros mesmo que uma região esteja totalmente inativa. Os aplicativos hospedados em diferentes regiões podem utilizar esses recursos para criptografar e decriptografar dados de forma segura em diferentes regiões.

Links Relacionados

• Oracle Cloud Infrastructure Vault

Confirmações

Autor - Chaitanya Chintala (Cloud Security Advisor)

Mais Recursos de Aprendizagem

Explore outros laboratórios no site docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal YouTube do Oracle Learning. Além disso, visite education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.

---

Título e Informações de Copyright

Create redundancy for Asymmetric Keys in Oracle Cloud Infrastructure Virtual Vaults

F82529-01

June 2023

Copyright © 2023, Oracle and/or its affiliates.