Cette page a été traduite par l'API Cloud Translation.
Switch to English

Importer une clé dans Cloud KMS

Cette rubrique explique comment importer une clé cryptographique dans Cloud HSM ou Cloud Key Management Service.

Pour plus d'informations sur l'importation de clés, y compris les limites et les restrictions, reportez-vous à la section Importation de clé.

Vous pouvez suivre la procédure décrite dans cette rubrique en 5 à 10 minutes, sans compter les étapes Avant de commencer. L'encapsulation manuelle de la clé ajoute de la complexité à la tâche.

Avant de commencer

Il est recommandé de créer un projet pour tester cette fonctionnalité, faciliter le nettoyage après le test et vous assurer que vous disposez des autorisations IAM appropriées pour importer une clé.

Avant de pouvoir importer une clé, vous devez préparer le projet, le système local et la clé elle-même.

Préparer le projet

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activez l'API requise.

    Activer l'API

  5. Installez et initialisez le SDK Cloud.
  6. L'utilisateur effectuant l'importation doit disposer des autorisations IAM suivantes pour créer des trousseaux de clés, des clés et des tâches d'importation. Si l'utilisateur n'est pas le propriétaire du projet, vous pouvez lui attribuer les deux des deux rôles prédéfinis suivants :

    • roles/editor
    • roles/cloudkms.importer

    Pour en savoir plus sur les rôles et autorisations IAM disponibles pour Cloud KMS, consultez la page Autorisations et rôles.

Préparer le système local

Préparez le système local en choisissant l'une des options suivantes. L'encapsulation automatique des clés est recommandée pour la plupart des utilisateurs.

Préparer la clé

Vérifiez que l'algorithme et la longueur de votre clé sont compatibles. Les algorithmes autorisés pour une clé varient selon si la clé est utilisée pour le chiffrement symétrique, le chiffrement asymétrique ou la signature asymétrique, ainsi que si la clé est stockée dans un logiciel ou un HSM. Vous spécifiez l'algorithme de la clé dans le cadre de la requête d'importation.

Séparément, vous devez également vérifier la manière dont la clé est encodée et effectuer des ajustements si nécessaire.

Une fois créés ou importés, les éléments suivants ne peuvent pas être modifiés :

  • Le niveau de protection de la clé indique si la clé persiste dans le logiciel, dans un HSM ou dans un système de gestion de clés externe. Le matériel de la clé ne peut pas être déplacé d'un de ces environnements de stockage à un autre. Les versions d'une clé ont toutes le même niveau de protection.

  • L'objectif de la clé indique si les versions de la clé sont utilisées pour le chiffrement symétrique, le chiffrement asymétrique ou la signature asymétrique. L'objectif d'une clé limite les algorithmes pouvant être utilisés afin de créer des versions de cette clé. Les versions d'une clé ont toutes la même fonction.

Si vous n'avez pas de clé à importer, mais que vous souhaitez valider la procédure d'importation, vous pouvez créer une clé symétrique sur le système local à l'aide de la commande suivante :

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

Utilisez cette clé uniquement pour les tests. Une clé créée de cette manière peut ne pas être appropriée pour une utilisation en production.

Si vous devez encapsuler la clé manuellement, faites-le avant de continuer avec les procédures de cette rubrique.

Créer la clé de ciblage et le trousseau de clés

Une clé Cloud KMS est un objet de conteneur qui contient zéro, une ou plusieurs versions de clé. Chaque version de clé contient une clé de chiffrement.

Lorsque vous importez une clé dans Cloud KMS ou Cloud HSM, la clé importée devient une nouvelle version de clé sur une clé Cloud KMS ou Cloud HSM existante. Dans le reste de cet article, cette clé est appelée clé cible. La clé cible doit exister avant de pouvoir y importer du matériel de clé.

L'importation d'une version de clé n'a aucun effet sur les versions existantes de cette clé. Toutefois, il est recommandé de créer une clé vide lors du test de l'importation de clé. Une clé vide n'a pas de version, n'est pas active et ne peut pas être utilisée.

Une clé existe sur un trousseau de clés. Dans cet article, ce trousseau de clés est appelé trousseau de clés cible. L'emplacement du trousseau de clés cible détermine l'emplacement où le matériel de clé est disponible après l'importation. Les clés Cloud HSM ne peuvent pas être créées ou importées dans certains emplacements. Une fois la clé créée, elle ne peut pas être transférée vers un autre trousseau ou à un autre emplacement.

Suivez ces étapes pour créer une clé vide à l'aide de l'outil de ligne de commande gcloud ou de Google Cloud Console.

UI Web

  1. Accédez à la page Clés de chiffrement dans Cloud Console.

    Accéder à la page Clés de chiffrement

  2. Cliquez sur Créer un trousseau.

  3. Dans le champ Nom du trousseau, saisissez le nom du trousseau de clés.

  4. Dans la liste déroulante Emplacement, sélectionnez un emplacement.

  5. Cliquez sur Créer. La page d'informations du trousseau de clés s'ouvre.

  6. Cliquez sur Créer une clé.

  7. Sélectionnez Clé importée. Cela empêche la création d'une version de clé initiale.

  8. Dans le champ Nom de la clé, saisissez le nom de votre clé.

  9. Définissez le niveau de protection sur Logiciel ou HSM.

  10. [Facultatif] Pour les clés importées, la rotation automatique est désactivée par défaut. Si vous activez la rotation automatique, les nouvelles versions de clé seront générées dans Cloud KMS et la version de clé importée ne sera plus la version de clé par défaut après une rotation.

  11. [Facultatif] Dans le champ Labels (Libellés), cliquez sur Add label (Ajouter un libellé) si vous souhaitez [ajouter des libellés à la clé][4].

  12. Cliquez sur Create (Créer).

Ligne de commande

Pour utiliser Cloud KMS sur la ligne de commande, commencez par installer ou mettre à jour le SDK Cloud.

  1. Créez le trousseau de clés de ciblage. Si vous avez l'intention d'importer dans une clé Cloud HSM, sélectionnez un emplacement compatible avec Cloud HSM.

    gcloud kms keyrings create key-ring-name \
      --location location
    

    Vous pouvez en savoir plus sur la création de trousseaux de clés.

  2. Créez la clé de ciblage.

    • Définissez la fonction de la clé :
      • Pour une clé symétrique, définissez la fonction sur encryption.
      • Pour une clé asymétrique, définissez la fonction sur asymmetric-signing ou asymmetric-encryption.
    • Empêchez la création d'une version initiale à l'aide de l'option --skip-initial-version-creation.
    • [Facultatif] Ne spécifiez pas de règle de rotation. Si vous activez la rotation automatique, les nouvelles versions de clé seront générées dans Cloud KMS et la version de clé importée ne sera plus la version de clé par défaut après une rotation.
    gcloud kms keys create key-name \
      --location location \
      --keyring key-ring-name \
      --purpose purpose \
      --skip-initial-version-creation
    

    En savoir plus sur la création de clés Cloud KMS ou de clés Cloud HSM.

Python

Pour exécuter ce code, commencez par configurer un environnement de développement Python, puis installez le SDK Cloud KMS pour Python.

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

Ces exemples utilisent curl comme client HTTP pour démontrer l'utilisation de l'API. Pour en savoir plus sur le contrôle des accès, consultez la page Accéder à l'API 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 "{}"

Pour plus d'informations, consultez la documentation de l'API KeyRing.create.

curl "https://cloudkms.googleapis.com/v1/projects/project-id/locations/location-id/keyRings/key-ring-name/cryptoKeys?cryptoKeyId=key-name&skipInitialVersionCreation=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"}}"

Pour plus d'informations, consultez la documentation de l'API CryptoKey.create.

Le trousseau de clés et la clé existent désormais, mais la clé ne contient aucun matériel de clé, n'a aucune version et n'est pas active. Ensuite, vous créez une tâche d'importation.

Créer la tâche d'importation

Une tâche d'importation définit les caractéristiques des clés qu'elle importe, y compris les propriétés qui ne peuvent pas être modifiées après l'importation de la clé.

Le niveau de protection détermine si les clés résultant de cette tâche d'importation résident dans un logiciel, un HSM ou un système de gestion de clés externe. Le niveau de protection ne peut plus être modifié une fois la clé importée.

La méthode d'importation définit l'algorithme utilisé pour créer la clé d'encapsulation qui protège les clés importées lors du transit de votre système local vers le projet Google Cloud cible. Vous pouvez choisir une clé RSA de 3 072 bits ou de 4 096 bits. Nous vous recommandons d'utiliser la clé d'encapsulation 3 072 bits, sauf si vous avez des exigences spécifiques.

Vous pouvez créer une tâche d'importation à l'aide de l'outil gcloud, de Cloud Console ou de l'API Cloud Key Management Service.

UI Web

  1. Accédez à la page Clés de chiffrement dans Cloud Console.

    Accéder à la page Clés de chiffrement

  2. Cliquez sur le nom du trousseau de clés de ciblage.

  3. Définissez le niveau de protection sur Logiciel ou HSM. Utilisez le même niveau de protection que celui défini pour la clé de ciblage.

  4. Cliquez sur Créer une tâche d'importation.

  5. Dans le champ Nom, saisissez le nom de la tâche d'importation.

  6. Dans le menu déroulant Méthode d'importation, définissez la méthode d'importation RSA 3 072 bits ou RSA 4 096 bits.

  7. Cliquez sur Create (Créer).

Ligne de commande

Pour utiliser Cloud KMS sur la ligne de commande, commencez par installer ou mettre à jour le SDK Cloud.

Utilisez une commande comme celle-ci pour créer une tâche d'importation.

gcloud kms import-jobs create import-job \
  --location location \
  --keyring key-ring-name \
  --import-method import-method \
  --protection-level protection-level
  • Utilisez le même trousseau de clés et le même emplacement que la clé de ciblage.
  • Définissez le niveau de protection sur software ou hsm.
  • Définissez la méthode d'importation sur rsa-oaep-3072-sha1-aes-256 ou rsa-oaep-4096-sha1-aes-256.

Python

Pour exécuter ce code, commencez par configurer un environnement de développement Python, puis installez le SDK Cloud KMS pour Python.

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

Ces exemples utilisent curl comme client HTTP pour démontrer l'utilisation de l'API. Pour en savoir plus sur le contrôle des accès, consultez la page Accéder à l'API Cloud KMS.

  1. Créez une instance du type ImportJob et spécifiez des valeurs pour les champsImportJob.protectionLevel et ImportJob.importMethod.

  2. En utilisant l'instance d'ImportJob comme corps de la requête, appelez la méthode ImportJob.create.

Vérifier l'état de la tâche d'importation

L'état initial d'une tâche d'importation est PENDING_GENERATION. Lorsque l'état est ACTIVE, vous pouvez l'utiliser pour importer des clés.

Une tâche d'importation expire au bout de trois jours. Si la tâche d'importation est arrivée à expiration, vous devez en créer une.

Vous pouvez vérifier l'état d'une tâche d'importation à l'aide de l'outil de ligne de commande gcloud, de Google Cloud Console ou de l'API Cloud Key Management Service.

UI Web

  1. Accédez à la page Clés de chiffrement dans Cloud Console.

    Accéder à la page Clés de chiffrement

  2. Cliquez sur le nom du trousseau de clés contenant la tâche d'importation.

  3. Cliquez sur l'onglet Tâches d'importation situé en haut de la page.

  4. L'état est alors visible sous État, à côté du nom de la tâche d'importation.

Ligne de commande

Pour utiliser Cloud KMS sur la ligne de commande, commencez par installer ou mettre à jour le SDK Cloud.

Lorsqu'une tâche d'importation est active, vous pouvez l'utiliser pour importer des clés. Cette opération peut prendre quelques minutes. Utilisez cette commande pour vérifier que la tâche d'importation est active. Utilisez l'emplacement et le trousseau de clés où vous avez créé la tâche d'importation.

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

Python

Pour exécuter ce code, commencez par configurer un environnement de développement Python, puis installez le SDK Cloud KMS pour Python.

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

Ces exemples utilisent curl comme client HTTP pour démontrer l'utilisation de l'API. Pour en savoir plus sur le contrôle des accès, consultez la page Accéder à l'API Cloud KMS.

Appelez la méthode ImportJob.get et vérifiez la valeur du champ state. Si l'état (state) est défini sur PENDING_GENERATION, c'est que la tâche d'importation est toujours en cours de création. Revérifiez régulièrement l'état jusqu'à ce qu'il bascule sur ACTIVE.

Dès que la tâche d'importation est active, vous pouvez effectuer une demande d'importation d'une clé.

Empêcher la modification des tâches d'importation

La tâche d'importation détermine de nombreuses caractéristiques de la clé importée, y compris l'algorithme de la clé et si une clé importée est une clé HSM ou une clé logicielle. Vous pouvez configurer les autorisations Identity and Access Management pour empêcher les utilisateurs de créer des tâches d'importation, tout en leur permettant d'utiliser des tâches d'importation pour importer des clés.

  1. N'accordez l'autorisation importjobs.create qu'aux administrateurs de clés.
  2. Accordez l'autorisation importjobs.useToImport pour une tâche d'importation spécifique à l'opérateur qui utilisera cette tâche pour importer des clés.
  3. Lorsque vous créez la tâche d'importation, spécifiez le niveau de protection et l'algorithme des clés importées à l'aide de celle-ci.

Jusqu'à l'expiration de la tâche d'importation, les utilisateurs disposant de importjobs.useToImport et n'ayant pas l'autorisation importjobs.create pour une tâche d'importation donnée peuvent importer des clés, mais ne peuvent pas modifier les caractéristiques de la tâche d'importation.

Importer la clé

Après avoir vérifié l'état de la tâche d'importation, vous pouvez envoyer une requête d'importation.

Vous utilisez différentes options pour effectuer la requête d'importation, selon si vous souhaitez que l'outil de ligne de commande gcloud encapsule automatiquement votre clé ou si vous l'avez encapsulée manuellement.

Quelle que soit l'encapsulation manuelle ou automatique de votre clé, vous devez définir l'algorithme sur un algorithme compatible qui correspond à la longueur de la clé réelle à importer et qui spécifie l'objectif de la clé).

  • Les clés ayant pour objectif ENCRYPT_DECRYPT utilisent l'algorithme google-symmetric-encryption et ont une longueur de 32.

  • Les clés ayant pour objectif ASYMMETRIC_ENCRYPT ou ASYMMETRIC_SIGN acceptent divers algorithmes et longueurs.

    L'objectif d'une clé ne peut pas être modifié après la création de la clé, mais les versions de clé ultérieures peuvent être créées avec des longueurs différentes de la version de clé initiale.

Encapsulation automatique et importation d'une clé

Si vous souhaitez utiliser l'encapsulation automatique, vous devez utiliser l'outil de ligne de commande gcloud. Utilisez une commande semblable à celle-ci. Définissez --target-key-file sur l'emplacement de la clé non encapsulée pour encapsuler et importer. Ne définissez pas -rsa-aes-wrapped-key-file.

Vous pouvez éventuellement définir l'option --public-key-file à l'emplacement où la clé publique a déjà été téléchargée. Lorsque vous importez un grand nombre de clés, cela empêche le téléchargement de la clé publique lors de chaque importation. Par exemple, vous pouvez écrire un script qui a téléchargé la clé publique une fois, puis fourni son emplacement lors de l'importation de chaque clé.

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 clé est encapsulée par la clé d'encapsulation associée à la tâche d'importation, transmise à Google Cloud et importée en tant que nouvelle version de clé sur la clé cible.

Importer manuellement une clé encapsulée

Suivez les instructions de cette section pour importer une clé que vous avez manuellement encapsulée. Définissez --rsa-aes-wrapped-key-file sur l'emplacement de la clé que vous avez encapsulée manuellement. Ne définissez pas --target-key-file.

Vous pouvez éventuellement définir l'option --public-key-file à l'emplacement où la clé publique a déjà été téléchargée. Lorsque vous importez un grand nombre de clés, cela empêche le téléchargement de la clé publique lors de chaque importation. Par exemple, vous pouvez écrire un script qui a téléchargé la clé publique une fois, puis fourni son emplacement lors de l'importation de chaque clé.

UI Web

  1. Ouvrez la page Clés cryptographiques dans Cloud Console.

  2. Cliquez sur le nom du trousseau de clés contenant la tâche d'importation. La clé de ciblage s'affiche, ainsi que toutes les autres clés du trousseau.

  3. Cliquez sur le nom de la clé de ciblage, puis sur Importer la version de clé.

  4. Sélectionnez votre tâche d'importation dans la liste déroulante Select import job (Sélectionner une tâche d'importation).

  5. Dans le sélecteur Upload the wrapped key (Importer la clé encapsulée), sélectionnez la clé que vous avez déjà encapsulée.

  6. Si vous importez une clé asymétrique, sélectionnez l'algorithme dans la liste déroulante Algorithm (Algorithme). Une page Importer une version de clé semblable à celle-ci doit s'afficher :

    Importer une version de clé

  7. Cliquez sur Import (Importer).

Ligne de commande

Pour utiliser Cloud KMS sur la ligne de commande, commencez par installer ou mettre à jour le SDK Cloud.

Utilisez une commande semblable à celle-ci.

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

Pour plus d'informations, consultez la sortie de la commande gcloud kms keys versions import --help.

Python

Pour exécuter ce code, commencez par configurer un environnement de développement Python, puis installez le SDK Cloud KMS pour Python.

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

Ces exemples utilisent curl comme client HTTP pour démontrer l'utilisation de l'API. Pour en savoir plus sur le contrôle des accès, consultez la page Accéder à l'API Cloud KMS.

  1. Pour le corps de la requête de la méthode cryptoKeyVersions.import, définissez le champ algorithm sur l'algorithme de la clé importée. Cette valeur ne doit pas nécessairement correspondre au modèle versionTemplate de la clé CryptoKey qui importe cette version. Le champ algorithm est de type CryptoKeyVersionAlgorithm.

  2. Toujours pour le corps de la requête, définissez le champ wrappedKeyMaterial sur le matériel de clé que vous avez déjà encapsulé.

  3. Appelez la méthode cryptoKeyVersions.import. La réponse de cryptoKeyVersions.import est du type CryptoKeyVersion. Lorsqu'une clé a bien été importée, son état est ENABLED et vous pouvez l'utiliser dans Cloud KMS.

La requête d'importation de clé est lancée. Vous pouvez surveiller son état.

Vérifier l'état de la clé importée

L'état initial d'une clé importée est PENDING_IMPORT. Lorsque l'état est ENABLED, la clé a bien été importée. Si l'importation échoue, l'état est IMPORT_FAILED.

Vous pouvez vérifier l'état d'une requête d'importation à l'aide de l'outil de ligne de commande gcloud, de Google Cloud Console ou de l'API Cloud Key Management Service.

UI Web

  1. Ouvrez la page Clés cryptographiques dans Cloud Console.

  2. Cliquez sur le nom du trousseau de clés contenant la tâche d'importation.

  3. Cliquez sur l'onglet Tâches d'importation situé en haut de la page.

  4. L'état est alors visible sous État, à côté du nom de la tâche d'importation.

Ligne de commande

Pour utiliser Cloud KMS sur la ligne de commande, commencez par installer ou mettre à jour le SDK Cloud.

Utilisez la commande versions list pour vérifier l'état. Utilisez les mêmes emplacements, trousseaux de clés de ciblage et clés de ciblage créés précédemment dans cette section.

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

Python

Pour exécuter ce code, commencez par configurer un environnement de développement Python, puis installez le SDK Cloud KMS pour Python.

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

Ces exemples utilisent curl comme client HTTP pour démontrer l'utilisation de l'API. Pour en savoir plus sur le contrôle des accès, consultez la page Accéder à l'API Cloud KMS.

Appelez la méthode ImportJob.get et vérifiez la valeur du champ state. Si l'état (state) est défini sur PENDING_GENERATION, c'est que la tâche d'importation est toujours en cours de création. Revérifiez régulièrement l'état jusqu'à ce qu'il bascule sur ACTIVE.

Une fois la clé importée, son état devient Actif. Pour les clés symétriques, vous devez définir la version de clé importée comme version principale avant de pouvoir utiliser la clé.

Clés symétriques : définir la version principale

Cette étape est requise lors de l'importation de clés symétriques et n'est pas pertinente pour les clés asymétriques. Une clé asymétrique ne possède pas de version principale. Vous devez utiliser l'outil de ligne de commande gcloud pour définir la version principale.

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

Étape suivante