Unión de una clave con OpenSSL en Linux

En este tema, se muestra cómo unir una clave de forma manual 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 forma automática antes de importar la clave. Para obtener una descripción general de las diferencias, consulta Cómo funciona la importación de claves.

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

Antes de comenzar

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

1. Crea un llavero de claves de destino y una clave, y crea un trabajo de importación.
2. Verifica que tu clave esté disponible de forma local y tenga el formato correcto para importar 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 el ícono Más (3 puntos verticales) junto al trabajo de importación.

5. Haz clic 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 siguiente comando 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 codificado con PEM, consulta RFC 7468, especialmente las secciones Consideraciones generales y Codificación textual de la información de clave pública del asunto.

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 de manera simultánea. Es posible que debas ajustar algunos de los valores de cada clave que deseas unir.

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

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

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

   Con los comandos siguientes, 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.

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

   TARGET_KEY=/path/to/key
   

4. Configura la variable BASE_DIR en un directorio en el que se puedan escribir los archivos temporales y crea el directorio si es necesario. Solo tu usuario actual debe poder 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 tres 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 finalmente importarás y asegúrate de tener acceso para escribir en el 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 de forma correcta, estás listo para unir la clave.

Une la clave

1. Ejecuta el siguiente comando para generar una clave AES temporal aleatoria de 32 bytes y guardarla en la ubicación a la que apunta ${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 por 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 obligatorio según 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, también unida con la clave pública del trabajo de importación.

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 ir antes que 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.