Verifica certificaciones

Esta es una versión de Cloud KMS. se pueden producir cambios que generen incompatibilidad con versiones anteriores is sujetas a ningún ANS o política de baja del servicio.

En el caso de las claves creadas en Cloud HSM, tienes la opción de solicitar una declaración de certificación para proporcionar evidencia de que la clave está protegida realmente por un HSM. La declaración es un token con una firma criptográfica que el hardware físico agrega directamente y que el usuario puede verificar. En este tema, se describe cómo verificar la firma de la declaración de certificación y determinar si la declaración coincide con la versión de clave.

Los ejemplos de este tema corresponden a entornos de Linux.

Antes de comenzar

• En este tema, se incluyen ejemplos en los que se usa la línea de comandos. Para hacerlo más simple, usaremos Cloud Shell. En el ejemplo de certificación, se usa OpenSSL, que viene instalado en Cloud Shell.

• Si todavía no lo has hecho, crea un llavero de claves en una de las regiones admitidas por Cloud HSM y crea una clave que tenga el nivel de protección HSM.

• Crea las siguientes secuencias de comandos de Python.

Secuencia de comandos para verificar una certificación

Crea el archivo verify.py en la línea de comandos en que verificarás la certificación a fin de facilitar el proceso. Si usas Cloud Shell, puedes usar el editor de código para crearlo. Usa el siguiente contenido en este archivo.

#!/usr/bin/env python
from OpenSSL import crypto
import gzip,sys

_END_DELIM = "-----END CERTIFICATE-----"
def verify(blob, signature, certs_file):
  with open(certs_file, 'r') as cert_data:
    certs = [cert + _END_DELIM for cert in cert_data.read().split(_END_DELIM)
             if cert.strip(' \t\n\r')]
    for cert in certs:
      cert_obj = crypto.load_certificate(crypto.FILETYPE_PEM, cert)
      try:
        crypto.verify(cert_obj, signature, blob, 'sha256')
        return True
      except crypto.Error as er:
        continue
    return False

attest_unzipped = gzip.open(sys.argv.pop(), 'rb').read()
certs_file = sys.argv.pop()
blob, signature = attest_unzipped[:-256], attest_unzipped[-256:]
verified = verify(blob, signature, certs_file)
print('Signature verified!' if verified else 'Signature failed!')

Secuencia de comandos para analizar una certificación

Crea un archivo llamado parse.py que contenga el siguiente código a fin de facilitar el análisis de una certificación.

#!/usr/bin/python
import io, gzip, sys, struct

HEADER = ">III"
TLV = ">II"
_CAVIUM_ATTESTATION_ASYM_OFFSET = 984
_CAVIUM_ATTESTATION_SYM_OFFSET = 24

def parse(attestation):
  # Parse Object, (Cavium stores its structures in big endian.)
  obj_handle, attr_count, obj_size = struct.unpack_from(HEADER, attestation, 0)
  obj_header_size = struct.calcsize(HEADER)
  attestation = attestation[obj_header_size:]
  while attr_count > 0:
    # Parse each Attribute.
    attr_type, attr_len = struct.unpack_from(TLV, attestation, 0)
    attestation = attestation[struct.calcsize(TLV):]
    print '0x%04x: %r' % (attr_type, attestation[:attr_len])
    attr_count -= 1
    attestation = attestation[attr_len:]
  return obj_header_size + obj_size

attest_unzipped = gzip.open(sys.argv.pop(), 'rb').read()
key_type = sys.argv.pop()
if key_type == 'symmetric':
  print "Private Key Attestation"
  parse(attest_unzipped[_CAVIUM_ATTESTATION_SYM_OFFSET:])
else:
  print "Public Key Attestation"
  offset = parse(attest_unzipped[_CAVIUM_ATTESTATION_ASYM_OFFSET:])
  print 'Private Key Attestation'
  parse(attest_unzipped[(_CAVIUM_ATTESTATION_ASYM_OFFSET + offset):])

Secuencia de comandos para verificar una clave pública

Crea un archivo llamado verify_pubkey.py que contenga el siguiente código a fin de facilitar la verificación de una clave pública.

#!/usr/bin/env python
import sys

public_key_file = sys.argv.pop()
parsed_attest_file = sys.argv.pop()
with open(public_key_file, 'r') as public_key_data:
  # remove the "BEGIN" and "END" line.
  publickey = "".join(public_key_data.read().split('\n')[1:-2])
  publickey = base64.b64decode(publickey)
  # KCV is the first 6 bytes of the SHA1 digest of the key.
  kcv = hashlib.sha1(publickey).hexdigest()[:6]
  # EKCV is the SHA256 digest of the key
  ekcv = hashlib.sha256(publickey).hexdigest()

  with open(parsed_attest_file, 'r') as parsed_attest_data:
    if kcv in parsed_attest_data.read() and ekcv in parsed_attest_data.read():
      print 'Public key matched with attestation.'
    else:
      print 'Public key not matched with attestation.'
      attest_lines = parsed_attest_data.readlines()
      # field 0x0173 corresponds to KCV,
      # field 1003 (Custom Cavium) corresponds to EKCV
      kcv_lines = [line for line in attest_lines (if line.startswith('0x0173:') or if line.startswith('0x1003:'))]
      print(kcv_lines)

Recupera el archivo de certificación

Para recuperar la certificación de una versión de clave criptográfica, puedes usar Google Cloud Platform Console o la línea de comandos.

Console

1. Ve a la página Claves criptográficas de GCP Console.
   Ir a la página Claves criptográficas
   

2. Haz clic en el nombre del llavero de claves que contiene la clave cuya versión quieres certificar.

3. Haz clic en la clave cuya versión quieres certificar.

4. Ubica la versión de clave que quieres certificar y haz clic en el ícono Más (3 puntos verticales).

5. Haz clic en Obtener certificación.

6. En el diálogo Obtener certificación, haz clic en Descargar. El archivo de certificación se descargará en tu computadora.

El nombre del archivo de certificación tiene el formato [KEYRING]-[KEY]-[KEYVERSION]-attestation.dat. Cuando ejecutes los comandos de ejemplo que aparecen en el resto del tema, reemplaza attestation.dat por el nombre del archivo que descargaste.

Línea de comandos

1. Haz clic en el botón Activar Google Cloud Shell en la parte superior de la ventana de la consola. Se abrirá una sesión de Cloud Shell en un marco nuevo en la parte inferior de la consola, que mostrará una línea de comandos. La sesión del shell puede tardar unos segundos en inicializarse.

2. En la ventana de la línea de comandos de Cloud Shell, usa el comando gcloud alpha kms keys version describe para recuperar la certificación de la clave que quieres certificar. La marca --attestation-file permite especificar la ruta de acceso y el nombre de archivo de destino de la certificación que recuperes.

   gcloud alpha kms keys versions describe [KEY_VERSION] \
     --key [KEY_NAME] \
     --location [LOCATION] \
     --keyring [KEY_RING] \
     --attestation-file attestation.dat
   

Certifica una clave

Puedes verificar la firma de una certificación mediante dos certificados: uno que pertenece a la autoridad certificada (CA) de Google y otro que pertenece a la CA de Cavium.

1. Recupera la cadena de certificados de la CA que quieres usar.

   curl -O https://www.gstatic.com/cloudhsm/cloud-kms-prod-[LOCATION]-[google|cavium].pem
   

   Reemplaza [LOCATION] por una de las regiones admitidas por Cloud HSM y [google|cavium] por google o cavium. En este ejemplo, se usan la ubicación us-west y la CA de Google:

   curl -O https://www.gstatic.com/cloudhsm/cloud-kms-prod-us-west1-google.pem
   

   Para mostrar el contenido del certificado, ejecuta este comando:

   openssl x509 -in cloud-kms-prod-[LOCATION]-[google|cavium].pem -text
   

2. Instala el wrapper de Python para OpenSSL.

   pip install --user pyopenssl
   

3. Ejecuta la herramienta de verificación en la ventana de la línea de comandos de Cloud Shell.

   python verify.py \
     cloud-kms-prod-[LOCATION]-[google|cavium].pem attestation.dat
   

   La herramienta verifica la firma que está al final del archivo de certificación con la clave pública proporcionada en el paquete de certificados del HSM. En la actualidad, el paquete contiene todas las cadenas de certificados de todos los HSM, pero solo hasta el nivel anterior al certificado de la autoridad certificada (CA).

Verifica los valores del archivo de certificación

No solo puedes verificar la firma de la certificación, sino también otras partes de ella. Por ejemplo, puedes verificar el ID de la versión de clave de la certificación con el ID de la versión de clave que se puede ver en Cloud KMS.

Para analizar el archivo de certificación, ejecuta el siguiente comando:

python parse.py [symmetric|asymmetric] attestation.dat > parsed.dat

El archivo parsed.dat se usará en las secciones posteriores.

Verifica el ID de la versión de clave

Puedes verificar si la certificación contiene el hash SHA-256 del ID de recurso de la versión de clave.

1. Obtén el ID de recurso de la versión de clave. Puedes usar GCP Console para obtener el ID de recurso de la versión de clave o ejecutar el siguiente comando de gcloud:

   gcloud alpha kms keys versions list \
     --location [LOCATION] \
     --keyring [KEY_RING] --key [KEY]
   

2. En la línea de comandos, asigna a resource_name el ID de recurso de la versión de clave que acabas de recuperar.

   resource_name=projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEY_RING]/cryptoKeys/[KEY]/cryptoKeyVersions/[VERSION]
   

3. Ejecuta la secuencia de comandos de certificación para comparar el hash SHA-256 del ID de recurso de la versión de clave que recuperaste en el paso 1 con el contenido de la certificación.

   echo -n $resource_name | sha256sum | cut -d ' ' -f 1 | grep -f - parsed.dat
   

Verifica las propiedades de la clave

Puedes ver las propiedades de la clave, por ejemplo, si es posible extraerla o estacionarla y qué operaciones criptográficas admite. Estas propiedades corresponden a los campos del estándar PKCS #11.

Para determinar si una clave se puede extraer, examina el campo 0x0162:

grep '0x0162:' parsed.dat

Para determinar si una clave se puede estacionar, examina el campo 0x0002:

grep '0x0002:' parsed.dat

Para determinar el tipo de la clave, examina el campo 0x0100. Además, los tipos de claves se enumeran en el estándar PCKS #11 con el prefijo CKK_*.

grep '0x0100:' parsed.dat

Verifica la clave pública

En el caso de las claves asimétricas, puedes verificar que el par de claves generado coincida con la clave pública. Puedes comparar el valor de la suma de verificación de la clave (KCV) y el KCV extendido (EKCV) de la clave pública con el contenido de la certificación.

1. Recupera la clave pública de manera local.

   gcloud alpha kms keys versions get-public-key \
     [KEY_VERSION] --location [LOCATION] \
     --keyring [KEY_RING] --key [KEY] \
     --output-file /tmp/key.pub
   

   Además de usar gcloud, también puedes recuperar la clave pública mediante GCP Console y la API de Cloud KMS.

2. Ejecuta la secuencia de comandos para verificar la clave pública.

   python verify_pubkey.py parsed.dat /tmp/key.pub
   

Información adicional

• Puedes verificar una certificación para determinar si una versión de clave se creó dentro de un HSM. Dado que la verificación es independiente de Google de manera intencional, no puedes verificar una certificación mediante Google Cloud Platform Console, la API de Cloud KMS ni la línea de comandos de gcloud.