Esta página se ha traducido con Cloud Translation API.

Importa una clave a Cloud KMS

En este tema, se muestra cómo importar una clave criptográfica a Cloud HSM o Cloud Key Management Service.

Para obtener más detalles sobre la importación de claves, incluidas las limitaciones y restricciones, consulta Importación de claves.

Puedes completar los pasos en este tema en 5 a 10 minutos, sin incluir los pasos de Antes de comenzar. Unir la clave de forma manual agrega complejidad a la tarea.

Antes de comenzar

Se recomienda que crees un proyecto nuevo para probar esta función, a fin de facilitar la limpieza después de realizar las pruebas y asegurarte de que tengas permisos de IAM adecuados para importar una clave.

Antes de importar una clave, debes preparar el proyecto, el sistema local y la clave en sí.

Prepara el proyecto

Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

Ir al selector de proyectos

Comprueba que la facturación esté habilitada en tu proyecto.

Descubre cómo puedes habilitar la facturación

Habilita la API necesaria.

Habilita la API

Instala e inicializa el SDK de Cloud.

En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

Ir al selector de proyectos

Comprueba que la facturación esté habilitada en tu proyecto.

Descubre cómo puedes habilitar la facturación

Habilita la API necesaria.

Habilita la API

Instala e inicializa el SDK de Cloud.

El usuario que realiza la importación necesita los siguientes permisos de IAM para crear claves, llaveros de claves y trabajos de importación. Si el usuario no es el propietario del proyecto, puedes asignar ambas funciones predefinidas:
- roles/editor
- roles/cloudkms.importer
Si deseas obtener más información sobre las funciones y los permisos de IAM disponibles para Cloud KMS, consulta Permisos y funciones.

Prepara el sistema local

Prepara el sistema local mediante la elección de una de las siguientes opciones. La mayoría de los usuarios recomienda la unión automática de claves.

Si deseas permitir que la herramienta de línea de comandos de gcloud una tus claves de forma automática antes de transmitirlas a Google Cloud, debes instalar la biblioteca de criptografía de Pyca en tu sistema local. El trabajo de importación que une y protege la clave de manera local antes de enviarla a Google Cloud usa la biblioteca de Pyca.
Si deseas unir tus claves de forma manual, debes configurar OpenSSL para la unión manual de claves.

Prepara la clave

Verifica que se admitan el algoritmo y la longitud de la clave. Los algoritmos permitidos para una clave dependen de si la clave se usa para encriptación simétrica, encriptación asimétrica o firma asimétrica, así como si la clave se almacena en software o en un HSM. Debes especificar el algoritmo de la clave como parte de la solicitud de importación.

Por separado, también debes verificar cómo se codifica la clave y realizar los ajustes necesarios.

Lo siguiente no se puede cambiar en una versión de clave después de su creación o importación:

El nivel de protección de la clave indica si la clave persiste en un software, en un HSM o en un sistema de administración de claves externo. El material de las claves no se puede mover de uno de estos entornos de almacenamiento a otro. Todas las versiones de una clave tienen el mismo nivel de protección.
El propósito de la clave indica si sus versiones se usan para encriptación simétrica, encriptación asimétrica o firma asimétrica. El propósito de una clave limita los posibles algoritmos que se pueden usar para crear versiones de esa clave. Todas las versiones de una clave tienen el mismo propósito.

Si no tienes una clave que desees importar, pero quieres validar el procedimiento de importación de claves, puedes crear una clave simétrica en el sistema local con el siguiente comando:

openssl rand 32 > ${HOME}/test.bin

Usa esta clave solo para pruebas. Es posible que una clave creada de esta manera no sea apropiada para su uso en producción.

Si necesitas unir la clave de forma manual, hazlo antes de continuar con los procedimientos de este tema.

Crea la clave de destino y el llavero de claves

Una clave de Cloud KMS es un objeto de contenedor que contiene cero o más versiones de claves. Cada versión de clave contiene una clave criptográfica.

Cuando importas una clave a Cloud KMS o Cloud HSM, la clave importada se convierte en una versión de la clave nueva en una clave de Cloud KMS o Cloud HSM existente. En el resto de este tema, esta clave se llama clave de destino. La clave de destino debe existir antes de que puedas importar el material de claves.

La importación de una versión de clave no tiene efecto en las versiones existentes de esa clave. Sin embargo, se recomienda crear una clave vacía cuando se pruebe la importación de claves. Una clave vacía no tiene versión, no está activa y no se puede usar.

De manera opcional, puedes especificar que la clave recién creada solo contenga versiones importadas, lo que evita la generación accidental de versiones nuevas en Cloud KMS.

Existe una clave en un llavero de claves. En este tema, el llavero de claves se denomina llavero de claves de destino. La ubicación del llavero de claves de destino determina la ubicación en la que está disponible el material de la clave después de la importación. Las claves de Cloud HSM no se pueden crear ni importar en algunas ubicaciones. Después de crear una clave, no se puede mover a un llavero de claves o a una ubicación diferente.

Sigue estos pasos para crear una clave vacía en un llavero de claves nuevo mediante la herramienta de línea de comandos de gcloud o Google Cloud Console.

Console

Ve a la página Llaveros de claves criptográficas en Cloud Console.

Ir a la página Llaveros de claves criptográficas
Haz clic en Crear llavero de claves.
En el campo Nombre del llavero de claves, ingresa el nombre de tu llavero de claves.
Selecciona una ubicación en el menú desplegable Ubicación.
Haga clic en Crear. Se abrirá la página de detalles del llavero de claves.
Haz clic en Crear clave.
Selecciona Clave importada. Esto evita que se cree una versión inicial de la clave.
Ingresa el nombre en el campo Nombre de la clave.
Establece el Nivel de protección como Software o HSM.
La rotación automática está inhabilitada de forma predeterminada (opcional). Si habilitas la rotación automática, se generarán versiones de clave nuevas en Cloud KMS, y la versión de clave importada ya no será la versión de clave predeterminada después de una rotación.
Puedes especificar que una clave solo contenga versiones importadas (opcional). Esto evita la creación accidental de versiones nuevas en Cloud KMS.
[De manera opcional, si deseas agregar etiquetas a tu clave][4], haz clic en Agregar etiqueta en el campo Etiquetas.
Haga clic en Crear.

gcloud

Para usar Cloud KMS en la línea de comandos, primero Instala o actualiza a la versión más reciente del SDK de Cloud.

Crea el llavero de claves de destino. Si deseas importar a una clave de Cloud HSM, selecciona una ubicación compatible con Cloud HSM.
```
gcloud kms keyrings create key-ring-name \
  --location location
```
Puedes obtener más información sobre cómo crear llaveros de claves.
Crea la clave de destino.
- Especifica el propósito de la clave.
- Evita que se cree una versión inicial con la marca --skip-initial-version-creation.
- Evita que se creen versiones nuevas en Cloud KMS mediante la marca --import-only (opcional).
- No especifiques una política de rotación (opcional). Si habilitas la rotación automática, se generarán versiones de clave nuevas en Cloud KMS, y la versión de clave importada ya no será la versión de clave predeterminada después de una rotación. No puedes especificar una política de rotación si especificaste la marca --import-only.
```
gcloud kms keys create key-name \
  --location location \
  --keyring key-ring-name \
  --purpose purpose \
  --skip-initial-version-creation
  --import-only
```
Puedes obtener más información sobre cómo crear claves de Cloud KMS o claves de Cloud HSM.

Python

Para ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python para Cloud KMS.

Ver en GitHub Comentarios

def create_key_for_import(project_id, location_id, key_ring_id, crypto_key_id):
    """

    Sets up an empty CryptoKey within a KeyRing for import.

    Args:
        project_id (string): Google Cloud project ID (e.g. 'my-project').
        location_id (string): Cloud KMS location (e.g. 'us-east1').
        key_ring_id (string): ID of the Cloud KMS key ring (e.g. 'my-key-ring').
        crypto_key_id (string): ID of the key to import (e.g. 'my-asymmetric-signing-key').
    """

    # Import the client library.
    from google.cloud import kms

    # Create the client.
    client = kms.KeyManagementServiceClient()

    # Build the key. For more information regarding allowed values of these fields, see:
    # https://googleapis.dev/python/cloudkms/latest/_modules/google/cloud/kms_v1/types/resources.html
    purpose = kms.CryptoKey.CryptoKeyPurpose.ASYMMETRIC_SIGN
    algorithm = kms.CryptoKeyVersion.CryptoKeyVersionAlgorithm.EC_SIGN_P256_SHA256
    protection_level = kms.ProtectionLevel.HSM
    key = {
        'purpose': purpose,
        'version_template': {
            'algorithm': algorithm,
            'protection_level': protection_level
        }
    }

    # Build the parent key ring name.
    key_ring_name = client.key_ring_path(project_id, location_id, key_ring_id)

    # Call the API.
    created_key = client.create_crypto_key(request={'parent': key_ring_name, 'crypto_key_id': crypto_key_id, 'crypto_key': key})
    print('Created hsm key: {}'.format(created_key.name))

API

En estos ejemplos, se usa curl como un cliente HTTP para demostrar el uso de la API. Para obtener más información sobre el control de acceso, consulta Accede a la API de Cloud KMS.

curl "https://cloudkms.googleapis.com/v1/projects/project-id/locations/location-id/keyRings?keyRingId=key-ring-name" \
    --request "POST" \
    --header "authorization: Bearer token" \
    --header "content-type: application/json" \
    --header "x-goog-user-project: project-id" \
    --data "{}"

Consulta la documentación sobre la API de KeyRing.create para obtener más información.

curl "https://cloudkms.googleapis.com/v1/projects/project-id/locations/location-id/keyRings/key-ring-name/cryptoKeys?cryptoKeyId=key-name&skipInitialVersionCreation=true&importOnly=true" \
    --request "POST" \
    --header "authorization: Bearer token" \
    --header "content-type: application/json" \
    --header "x-goog-user-project: project-id" \
    --data "{"purpose":"purpose", "versionTemplate":{"protectionLevel":"protection-level","algorithm":"algorithm"}}"

Consulta la documentación sobre la API de CryptoKey.create para obtener más información.

El llavero de claves y la clave se crearon, pero la clave no contiene material, no tiene versión y no está activa. Luego, crea un trabajo de importación.

Crea el trabajo de importación

Un trabajo de importación define las características de las claves que importa, incluidas las propiedades que no se pueden cambiar después de que se importa la clave.

El nivel de protección define si las claves que resultan de este trabajo de importación residen en software, en un HSM o en un sistema de administración de claves externo. El nivel de protección no se puede cambiar después de que la clave se importa.

El método de importación define el algoritmo usado para crear la clave de unión que protege las claves importadas durante el tránsito de tu sistema local al proyecto de Google Cloud de destino. Puedes elegir una clave RSA de 3072 bits o 4096 bits. A menos que tengas requisitos específicos, se recomienda la clave de unión de 3072 bits.

Puedes crear un trabajo de importación mediante la herramienta de gcloud, Cloud Console o la API de Cloud Key Management Service.

Console

Ve a la página Llaveros de claves criptográficas en Cloud Console.

Ir a la página Llaveros de claves criptográficas
Haz clic en el nombre del llavero de claves de destino.
Establece el Nivel de protección en Software o HSM. Usa el mismo nivel de protección que estableciste para la clave de destino.
Haz clic en Crear trabajo de importación.
En el campo Nombre, ingresa el nombre de tu trabajo de importación.
En el menú desplegable Método de importación, configura el método de importación en RSA de 3072 bits o RSA de 4096 bits.
Haga clic en Crear.

gcloud

Para usar Cloud KMS en la línea de comandos, primero Instala o actualiza a la versión más reciente del SDK de Cloud.

Usa un comando como el siguiente para crear un trabajo de importación.

gcloud kms import-jobs create import-job \
  --location location \
  --keyring key-ring-name \
  --import-method import-method \
  --protection-level protection-level

Usa el mismo llavero de claves y la misma ubicación que usa la clave de destino.
Establece el nivel de protección en software o hsm.
Configura el método de importación en rsa-oaep-3072-sha1-aes-256 o rsa-oaep-4096-sha1-aes-256.

Python

Para ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python para Cloud KMS.

Ver en GitHub Comentarios

def create_import_job(project_id, location_id, key_ring_id, import_job_id):
    """
    Create a new import job in Cloud KMS.

    Args:
        project_id (string): Google Cloud project ID (e.g. 'my-project').
        location_id (string): Cloud KMS location (e.g. 'us-east1').
        key_ring_id (string): ID of the Cloud KMS key ring (e.g. 'my-key-ring').
        import_job_id (string): ID of the import job (e.g. 'my-import-job').
    """

    # Import the client library.
    from google.cloud import kms

    # Create the client.
    client = kms.KeyManagementServiceClient()

    # Retrieve the fully-qualified key_ring string.
    key_ring_name = client.key_ring_path(project_id, location_id, key_ring_id)

    # Set paramaters for the import job, allowed values for ImportMethod and ProtectionLevel found here:
    # https://googleapis.dev/python/cloudkms/latest/_modules/google/cloud/kms_v1/types/resources.html

    import_method = kms.ImportJob.ImportMethod.RSA_OAEP_3072_SHA1_AES_256
    protection_level = kms.ProtectionLevel.HSM
    import_job_params = {"import_method": import_method, "protection_level": protection_level}

    # Call the client to create a new import job.
    import_job = client.create_import_job({"parent": key_ring_name, "import_job_id": import_job_id, "import_job": import_job_params})

    print('Created import job: {}'.format(import_job.name))

API

En estos ejemplos, se usa curl como un cliente HTTP para demostrar el uso de la API. Para obtener más información sobre el control de acceso, consulta Accede a la API de Cloud KMS.

Crea una instancia delImportJob y especificar valores para los ImportJob.protectionLevel yImportJob.importMethod campos.
Llama al método ImportJob.create con tu instancia de ImportJob como cuerpo de la solicitud.

Verifica el estado del trabajo de importación

El estado inicial de un trabajo de importación es PENDING_GENERATION. Cuando el estado es ACTIVE, puedes usarlo para importar claves.

Los trabajos de importación vencen después de tres días. Si el trabajo de importación venció, debes crear uno nuevo.

Puedes comprobar el estado de un trabajo de importación con la herramienta de línea de comandos de gcloud, Google Cloud Console o la API de Cloud Key Management Service.

Console

Ve a la página Llaveros de claves criptográficas en Cloud Console.

Ir a la página Llaveros de claves criptográficas
Haz clic en el nombre del llavero de claves que contiene tu trabajo de importación.
Haz clic en la pestaña Trabajos de importación en la parte superior de la página.
El estado aparecerá en Estado junto al nombre de tu trabajo de importación.

gcloud

Para usar Cloud KMS en la línea de comandos, primero Instala o actualiza a la versión más reciente del SDK de Cloud.

Cuando un trabajo de importación está activo, puedes usarlo para importar claves. Este proceso puede tomar unos minutos. Usa este comando para verificar que el trabajo de importación esté activo. Usa la ubicación y el llavero de claves donde creaste el trabajo de importación.

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

state: ACTIVE

Python

Para ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python para Cloud KMS.

Ver en GitHub Comentarios

def check_state_import_job(project_id, location_id, key_ring_id, import_job_id):
    """
    Check the state of an import job in Cloud KMS.

    Args:
        project_id (string): Google Cloud project ID (e.g. 'my-project').
        location_id (string): Cloud KMS location (e.g. 'us-east1').
        key_ring_id (string): ID of the Cloud KMS key ring (e.g. 'my-key-ring').
        import_job_id (string): ID of the import job (e.g. 'my-import-job').
    """

    # Import the client library.
    from google.cloud import kms

    # Create the client.
    client = kms.KeyManagementServiceClient()

    # Retrieve the fully-qualified import_job string.
    import_job_name = client.import_job_path(
        project_id, location_id, key_ring_id, import_job_id)

    # Retrieve the state from an existing import job.
    import_job = client.get_import_job(name=import_job_name)

    print('Current state of import job {}: {}'.format(import_job.name, import_job.state))

API

En estos ejemplos, se usa curl como un cliente HTTP para demostrar el uso de la API. Para obtener más información sobre el control de acceso, consulta Accede a la API de Cloud KMS.

Llama al método ImportJob.get y verifica el campo state. Si state es PENDING_GENERATION, el trabajo de importación todavía se está creando. Vuelve a verificar periódicamente el estado hasta que sea ACTIVE.

Tan pronto como el trabajo de importación esté activo, puedes realizar una solicitud para importar una clave.

Evita la modificación de trabajos de importación

El trabajo de importación determina muchas características de la clave importada, incluido el algoritmo de la clave y si una clave importada es una de HSM o de software. Puedes configurar los permisos de administración de identidades y accesos para evitar que los usuarios creen trabajos de importación, mientras permites que usen trabajos de importación para importar claves.

Otorga solo a los administradores de claves el permiso importjobs.create.
Otorga el permiso importjobs.useToImport para un trabajo de importación específico al operador que usará ese trabajo a fin de importar claves.
Cuando crees el trabajo de importación, especifica el nivel de protección y el algoritmo para las claves importadas con él.

Hasta que el trabajo de importación caduque, los usuarios que tienen el permiso importjobs.useToImport y no tienen el permiso importjobs.create para un trabajo de importación determinado pueden importar claves, pero no pueden modificar las características del trabajo de importación.

Importe la clave

Después de verificar el estado del trabajo de importación, puedes realizar una solicitud de importación.

Usas diferentes marcas para realizar la solicitud de importación, según si deseas que la herramienta de línea de comandos de gcloud se una a tu clave de forma automática o si ya la uniste de forma manual.

Sin importar si uniste tu clave de forma manual o automática, debes configurar un algoritmo compatible que coincida con la longitud de la clave real que se importará y especifique el propósito de la clave.

Las claves con propósito ENCRYPT_DECRYPT usan el algoritmo google-symmetric-encryption y tienen una longitud de 32.
Las claves con el propósito ASYMMETRIC_ENCRYPT o ASYMMETRIC_SIGN admiten una variedad de algoritmos y longitudes.

El propósito de la clave no se puede cambiar después de crearla, pero las versiones de la clave posteriores se pueden crear en longitudes diferentes a la versión inicial.

Importa y une una clave de forma automática

Si deseas usar la unión automática, debes usar la herramienta de línea de comandos de gcloud. Usa un comando como el siguiente. Configura --target-key-file en la ubicación de la clave separada para unir y, luego, importar. No configures -rsa-aes-wrapped-key-file.

De forma opcional, puedes establecer la marca --public-key-file en la ubicación en la que se descargó la clave pública. Cuando se importa una gran cantidad de claves, esto evita que la clave pública se descargue durante cada importación. Por ejemplo, puedes escribir una secuencia de comandos que haya descargado la clave pública una vez y, luego, haya proporcionado su ubicación cuando haya importado cada clave.

gcloud kms keys versions import \
  --import-job import-job \
  --location location \
  --keyring key-ring-name \
  --key key-name \
  --algorithm algorithm-name \
  --target-key-file path-to-unwrapped-key-to-import

La clave de unión asociada al trabajo de importación une la clave, que se transmite a Google Cloud y se importa como una versión de clave nueva en la clave de destino.

Importa una clave unida de forma manual

Usa las instrucciones de esta sección para importar una clave que uniste de forma manual. Configura --rsa-aes-wrapped-key-file en la ubicación de la clave que uniste de forma manual. No configures --target-key-file.

Console

Abre la página Llavero de claves criptográficas en Cloud Console.
Haz clic en el nombre del llavero de claves que contiene tu trabajo de importación. Se mostrará la clave de destino junto con cualquier otra clave en el llavero de claves.
Haz clic en el nombre de la clave de destino y, luego, en Importar versión de clave.
Selecciona tu trabajo de importación en el menú desplegable Seleccionar trabajo de importación.
En el selector Subir la clave unida (Upload the wrapped key), selecciona la clave que ya uniste.
Si importas una clave asimétrica, selecciona el algoritmo en el menú desplegable Algoritmo. Tu página Importar versión de clave debe ser similar a la que se muestra a continuación:
Haga clic en Import.

gcloud

Para usar Cloud KMS en la línea de comandos, primero Instala o actualiza a la versión más reciente del SDK de Cloud.

Usa un comando como el siguiente.

gcloud kms keys versions import \
  --import-job import-job \
  --location location \
  --keyring key-ring-name \
  --key key-name \
  --algorithm algorithm-name \
  --rsa-aes-wrapped-key-file path-to-wrapped-key-to-import

Para obtener más información, consulta el resultado del comando gcloud kms keys versions import --help.

Python

Para ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python para Cloud KMS.

Ver en GitHub Comentarios

def import_manually_wrapped_key(project_id, location_id, key_ring_id, crypto_key_id, import_job_id):
    """
    Generates and imports local key material to Cloud KMS.

    Args:
        project_id (string): Google Cloud project ID (e.g. 'my-project').
        location_id (string): Cloud KMS location (e.g. 'us-east1').
        key_ring_id (string): ID of the Cloud KMS key ring (e.g. 'my-key-ring').
        crypto_key_id (string): ID of the key to import (e.g. 'my-asymmetric-signing-key').
        import_job_id (string): ID of the import job (e.g. 'my-import-job').
    """

    # Import the client library and Python standard cryptographic libraries.
    import os
    from cryptography.hazmat import backends
    from cryptography.hazmat.primitives import hashes, keywrap, serialization
    from cryptography.hazmat.primitives.asymmetric import ec, padding
    from google.cloud import kms

    # Generate some key material in Python and format it in PKCS #8 DER as
    # required by Google Cloud KMS.
    key = ec.generate_private_key(ec.SECP256R1, backends.default_backend())
    formatted_key = key.private_bytes(
        serialization.Encoding.DER,
        serialization.PrivateFormat.PKCS8,
        serialization.NoEncryption())

    print('Generated key bytes: {}'.format(formatted_key))

    # Create the client.
    client = kms.KeyManagementServiceClient()

    # Retrieve the fully-qualified crypto_key and import_job string.
    crypto_key_name = client.crypto_key_path(
        project_id, location_id, key_ring_id, crypto_key_id)
    import_job_name = client.import_job_path(
        project_id, location_id, key_ring_id, import_job_id)

    # Generate a temporary 32-byte key for AES-KWP and wrap the key material.
    kwp_key = os.urandom(32)
    wrapped_target_key = keywrap.aes_key_wrap_with_padding(
        kwp_key, formatted_key, backends.default_backend())

    # Retrieve the public key from the import job.
    import_job = client.get_import_job(name=import_job_name)
    import_job_pub = serialization.load_pem_public_key(
        bytes(import_job.public_key.pem, 'UTF-8'), backends.default_backend())

    # Wrap the KWP key using the import job key.
    wrapped_kwp_key = import_job_pub.encrypt(
        kwp_key,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA1()),
            algorithm=hashes.SHA1(),
            label=None))

    # Import the wrapped key material.
    client.import_crypto_key_version({
        "parent": crypto_key_name,
        "import_job": import_job_name,
        "algorithm": kms.CryptoKeyVersion.CryptoKeyVersionAlgorithm.EC_SIGN_P256_SHA256,
        "rsa_aes_wrapped_key": wrapped_kwp_key + wrapped_target_key,
    })

    print('Imported: {}'.format(import_job.name))

API

En estos ejemplos, se usa curl como un cliente HTTP para demostrar el uso de la API. Para obtener más información sobre el control de acceso, consulta Accede a la API de Cloud KMS.

Para el cuerpo de la solicitud del método cryptoKeyVersions.import, define el campo algorithm como el algoritmo de la clave que se está importando. No es necesario que este valor coincida con la versionTemplate de la CryptoKey que está importando esta versión. El campo algorithm es del tipo CryptoKeyVersionAlgorithm.
Además, para el cuerpo de la solicitud, establece el campo wrappedKeyMaterial en el material de clave que ya uniste.
Llama al método cryptoKeyVersions.import. La respuesta cryptoKeyVersions.import es del tipo CryptoKeyVersion. Cuando una clave se importa con éxito, su estado es ENABLED, y puedes usarla a través de Cloud KMS.

Se iniciará la solicitud de importación de claves. Puedes supervisar su estado.

Verifica el estado de la clave importada

El estado inicial de una clave importada es PENDING_IMPORT. Cuando el estado es ENABLED, la clave se importó de forma correcta. Si la importación falla, el estado es IMPORT_FAILED.

Puedes comprobar el estado de una solicitud de importación con la herramienta de línea de comandos de gcloud, Google Cloud Console o la API de Cloud Key Management Service.

Console

Abre la página Llavero de claves criptográficas en Cloud Console.
Haz clic en el nombre del llavero de claves que contiene tu trabajo de importación.
Haz clic en la pestaña Trabajos de importación en la parte superior de la página.
El estado aparecerá en Estado junto al nombre de tu trabajo de importación.

gcloud

Para usar Cloud KMS en la línea de comandos, primero Instala o actualiza a la versión más reciente del SDK de Cloud.

Usa el comando versions list para verificar el estado. Usa la misma ubicación, el llavero de claves de destino y la clave de destino que creaste antes en este tema.

gcloud kms keys versions list \
  --keyring keyring \
  --location location \
  --key key-name

Python

Para ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python para Cloud KMS.

Ver en GitHub Comentarios

def check_state_imported_key(project_id, location_id, key_ring_id, import_job_id):
    """
    Check the state of an import job in Cloud KMS.

    Args:
        project_id (string): Google Cloud project ID (e.g. 'my-project').
        location_id (string): Cloud KMS location (e.g. 'us-east1').
        key_ring_id (string): ID of the Cloud KMS key ring (e.g. 'my-key-ring').
        import_job_id (string): ID of the import job (e.g. 'my-import-job').
    """

    # Import the client library.
    from google.cloud import kms

    # Create the client.
    client = kms.KeyManagementServiceClient()

    # Retrieve the fully-qualified import_job string.
    import_job_name = client.import_job_path(
        project_id, location_id, key_ring_id, import_job_id)

    # Retrieve the state from an existing import job.
    import_job = client.get_import_job(name=import_job_name)

    print('Current state of import job {}: {}'.format(import_job.name, import_job.state))

API

En estos ejemplos, se usa curl como un cliente HTTP para demostrar el uso de la API. Para obtener más información sobre el control de acceso, consulta Accede a la API de Cloud KMS.

Después de importar la clave, su estado cambia a Activa. En el caso de las claves simétricas, debes configurar la versión de la clave importada como la versión principal antes de poder usar la clave.

Claves simétricas: Configura la versión principal

Este paso es obligatorio cuando se importan claves simétricas y no es relevante para claves asimétricas. Una clave asimétrica no tiene una versión principal. Debes usar la herramienta de línea de comandos de gcloud para configurar la versión principal.

gcloud kms keys set-primary-version key-name --version=version-number

Vuelve a importar una clave destruida previamente.

Cloud Key Management Service admite la reimportación de claves, lo que te permite restablecer una versión de clave importada con anterioridad en el estado DESTROYED o IMPORT_FAILED al estado ENABLED mediante el suministro del material de la clave original. Si no se importó ningún material de clave original debido a un error de importación inicial, se puede proporcionar cualquier material de clave.

Restricciones

Solo se puede volver a importar CryptoKeyVersions (importado anteriormente).
El material de clave que se volvió a importar debe coincidir exactamente con el material de clave original si la versión se importó correctamente con anterioridad.
CryptoKeyVersions destruido antes de la actualización de esta característica no se puede volver a importar. El campo reimport_eligible de CryptoKeyVersion es true si la versión es apta para volver a importarse y false si no lo es.

Las claves de software y Cloud HSM se pueden volver a importar, pero las claves externas no se pueden volver a importar.

Vuelve a importar una clave destruida

Crea un ImportJob para volver a importar. Para ello, sigue los pasos en Crea el trabajo de importación. Puedes usar un ImportJob existente o un ImportJob nuevo, siempre y cuando el nivel de protección coincida con el nivel de protección original.

Console

Ve a la página Llaveros de claves criptográficas en Cloud Console.

Ir a la página Llaveros de claves criptográficas
Haz clic en el nombre del llavero de claves que contiene la clave cuya versión de clave se volverá a importar.
Haz clic en la clave cuya versión de clave deseas volver a importar.
Haz clic en los tres puntos junto a la versión de clave que deseas volver a importar.
Selecciona Volver a importar la versión de clave.
Selecciona tu trabajo de importación en el menú desplegable Seleccionar trabajo de importación.
En el selector Subir la clave unida (Upload the wrapped key), selecciona la clave que ya uniste. Esta clave debe coincidir con el material de la clave original.
Haz clic en Volver a importar.

gcloud

Para usar Cloud KMS en la línea de comandos, primero Instala o actualiza a la versión más reciente del SDK de Cloud.

Vuelve a importar la versión de la clave con el material de la clave original.

gcloud kms keys versions import \
--location location \
--keyring key-ring-name \
--key key-name \
--version key-version
--algorithm algorithm \
--import-job import-job \
--target-key-file key-file \

API

En estos ejemplos, se usa curl como un cliente HTTP para demostrar el uso de la API. Para obtener más información sobre el control de acceso, consulta Accede a la API de Cloud KMS.

En el cuerpo de la solicitud del método cryptoKeyVersions.import, establece el campo cryptoKeyVersion en el nombre de la versión de clave de la versión que se está importando. Debe ser un elemento secundario de la clave criptográfica.
En el cuerpo de la solicitud, establece el campo algorithm en el algoritmo de la clave que se está importando. Este valor debe coincidir con el algoritmo de la versión de clave original. El campo algorithm es del tipo CryptoKeyVersionAlgorithm.
En el cuerpo de la solicitud, configura el campo wrappedKeyMaterial con el material de la clave que ya uniste.
Llama al método cryptoKeyVersions.import. La respuesta cryptoKeyVersions.import es del tipo CryptoKeyVersion. Cuando una clave se importa con éxito, su estado es ENABLED, y puedes usarla a través de Cloud KMS.

¿Qué sigue?

Verifica una clave importada y el material de claves; puedes usar la clave para firmar o proteger datos.
Solucionar problemas de importación de una clave con errores

Encapsular una clave con OpenSSL

Verificar una clave importada