Unión de una clave con OpenSSL en Linux

En este tema, se muestra cómo unir manualmente una clave antes de importar la clave a Cloud KMS. Solo debes seguir las instrucciones de este tema si no deseas usar la herramienta de línea de comandos de gcloud para unir la clave de manera automática antes de importarla. Para obtener una descripción general de las diferencias, consulta Cómo funciona la importación de claves.

Puedes completar los pasos en este tema en 5 a 10 minutos, sin incluir los pasos de Antes de comenzar.

Antes de comenzar

Antes de unir una clave, debes completar los siguientes requisitos previos.

1. Crea un llavero de claves y una clave de destino, y crea un trabajo de importación.
2. Verifica que tu clave esté disponible de forma local y con el formato correcto para importarla a Cloud KMS.
3. Aplica un parche y vuelve a compilar OpenSSL.

Recupera la clave de unión

En esta sección, se muestra cómo recuperar la clave de unión del trabajo de importación que creaste en Antes de comenzar. Se recomienda usar Google Cloud Console.

Console

1. Ve a la página Claves criptográficas en Cloud Console.

   Ir a la página Claves criptográficas

2. Haz clic en el nombre del llavero de claves que contiene tu trabajo de importación.

3. Haz clic en la pestaña Trabajos de importación en la parte superior de la página.

4. Haz clic en Más y, luego, en Descargar clave de unión en el menú emergente.

gcloud

Para verificar que el trabajo de importación esté activo, ejecuta el comando gcloud kms import-jobs describe:

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

state: ACTIVE

Ejecuta el comando siguiente para guardar la clave pública del trabajo de importación en ${HOME}/wrapping-key.pem:

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

Nota: Solo necesitas descargar la clave pública una vez y puedes usarla hasta que venza el trabajo de importación.

API

1. Realiza una llamada al método [11] [ImportJob.get].

2. Recupera la clave pública mediante el campo [publicKey][13] de la respuesta ImportJob.get. Este valor es del tipo [WrappingPublicKey][14]. El campo [pem][21] del tipo [WrappingPublicKey][22] es la clave pública codificada en formato de correo con privacidad mejorada (PEM).

Para obtener más información sobre el formato con codificación PEM, consulta RFC 7468, en especial, las secciones Consideraciones generales e Información de la codificación textual de la clave pública del sujeto.

Configura variables de entorno

Los comandos de OpenSSL requieren varias rutas de acceso a archivos como valores de entrada. Define variables de entorno para las rutas de acceso a archivos a fin de facilitar la ejecución de los comandos.

Nota: Si lo deseas, puedes guardar todos estos comandos en una secuencia de comandos de shell y ejecutar la secuencia de comandos para configurar las variables a la vez. Es posible que debas ajustar algunos de los valores de cada clave que deseas unir.

1. Configura la variable OpenSSL_V110 como la ruta de tu secuencia de comandos openssl.sh. Si seguiste las instrucciones para aplicar parches y volver a compilar OpenSSL de forma exacta, puedes usar este comando sin modificar el valor de la variable.

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

2. Establece la variable PUB_WRAPPING_KEY en la ruta completa a la clave de unión que descargaste del trabajo de importación. La clave de unión finaliza en .pem.

   Con los siguientes comandos, se establece la variable PUB_WRAPPING_KEY en ${HOME}/wrapping-key.pem.

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

3. Establece la variable TARGET_KEY en la ruta completa a la clave separada.

   • En el caso de las claves simétricas, establece TARGET_KEY en la ruta al archivo .bin.
   • Para las claves asimétricas, configura TARGET_KEY en la ruta al archivo .der.

   TARGET_KEY=/path/to/key
   

4. Establece la variable BASE_DIR en un directorio en el que se puedan escribir los archivos temporales y crea el directorio si es necesario. Solo el usuario actual debería acceder a este directorio. No uses un carácter / al final del nombre del directorio.

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

5. Define variables de entorno para los archivos intermedios.

   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. Establece la variable RSA_AES_WRAPPED_KEY en la ruta de acceso completa para escribir la clave de destino unida que luego importarás y asegúrate de tener acceso de escritura al directorio.

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

7. Verifica que todas las variables de entorno estén configuradas correctamente con los siguientes 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}
   

Cuando las variables estén configuradas correctamente, ya puedes unir la clave.

Une la clave

1. Ejecuta el siguiente comando para generar una clave AES temporal aleatoria con una longitud de 32 bytes y guárdala en la ubicación que apunta a ${TEMP_AES_KEY}.

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

2. Une la clave AES temporal con la clave pública de unión con el 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. Une la clave de destino con la clave AES temporal mediante el algoritmo CKM_AES_KEY_WRAP_PAD. Reemplaza target-key-file con el nombre del archivo .bin o pub para la clave.

   "${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}"
   

   La marca -iv A65959A6 establece A65959A6 como el valor inicial alternativo. Esto es necesario para la especificación RFC 5649.

   Ya uniste las dos claves:

   • ${TEMP_AES_KEY_WRAPPED} es la clave AES temporal que creaste en el sistema local, unida con la clave pública del trabajo de importación.
   • ${TARGET_KEY_WRAPPED} es la clave de destino que importarás, junto con la clave AES temporal que generaste.

4. Concatena las dos claves unidas y escribe el resultado en un solo archivo. No modifiques el orden de las dos claves en el siguiente comando. la clave temporal debe aparecer antes de la clave de destino.

   Advertencia: Este comando reemplaza cualquier archivo existente al que apunte la variable ${RSA_AES_WRAPPED_KEY}.

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

5. Borra los archivos intermedios que ya no son necesarios.

   rm ${BASE_DIR}/*
   

La clave unida existe en la variable ${RSA_AES_WRAPPED_KEY} de ubicación y puedes realizar una solicitud para importar tu clave.