Schlüssel in Cloud KMS importieren

In diesem Thema wird beschrieben, wie Sie einen kryptografischen Schlüssel in Cloud HSM oder den Cloud Key Management Service importieren.

Weitere Informationen zum Importieren von Schlüsseln, einschließlich Einschränkungen, finden Sie unter Schlüsselimport.

Die in diesem Thema beschriebenen Schritte lassen sich in 5 bis 10 Minuten ausführen. Dabei sind die Schritte unter Vorbereitung nicht berücksichtigt. Wenn Sie den Schlüssel manuell verpacken, wird die Aufgabe komplexer.

Hinweis

Es wird empfohlen, ein neues Projekt zum Testen dieser Funktion zu erstellen, um die Bereinigung nach dem Testen zu vereinfachen und zu gewährleisten, dass Sie alle erforderlichen IAM-Berechtigungen für den Import eines Schlüssels haben.

Bevor Sie einen Schlüssel importieren können, müssen Sie das Projekt, das lokale System und den Schlüssel selbst vorbereiten.

Das Projekt vorbereiten

  1. Melden Sie sich bei Ihrem Google-Konto an.

    Wenn Sie noch kein Konto haben, melden Sie sich hier für ein neues Konto an.

  2. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  3. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

  4. Aktivieren Sie die erforderliche API.

    Aktivieren Sie die API

  5. Installieren und initialisieren Sie das Cloud SDK.
  6. Der Nutzer, der den Import durchführt, benötigt die folgenden IAM-Berechtigungen, um Schlüsselbunde, Schlüssel und Importjobs zu erstellen. Wenn der Nutzer nicht der Projektinhaber ist, können Sie ihm beide der folgenden vordefinierten Rollen zuweisen:

    • roles/editor
    • roles/cloudkms.importer

    Weitere Informationen zu verfügbaren IAM-Rollen und Berechtigungen für Cloud KMS finden Sie unter Berechtigungen und Rollen.

In lokalem Datenspeicher suchen

Bereiten Sie das lokale System vor, indem Sie eine der folgenden Optionen auswählen. Für die meisten Nutzer wird das automatische Key-Wrapping empfohlen.

  • Wenn Sie zulassen möchten, dass das gcloud-Befehlszeilentool Ihre Schlüssel automatisch verpackt, bevor Sie sie an Google Cloud übertragen, müssen Sie die Pyca-Kryptografie-Bibliothek auf Ihrem lokalen Server installieren. Die Pyca-Bibliothek wird von dem Importjob verwendet, der den Schlüssel lokal verpackt und schützt, bevor er an Google Cloud gesendet wird.
  • Wenn Sie Ihre Schlüssel manuell verpacken möchten, müssen Sie OpenSSL für manuelles Key-Wrapping konfigurieren.

Den Schlüssel vorbereiten

Prüfen Sie, ob Algorithmus und Länge Ihres Schlüssels unterstützt werden. Die zulässigen Algorithmen für einen Schlüssel hängen davon ab, ob der Schlüssel für die synchrone Verschlüsselung, die asymmetrische Verschlüsselung oder die asymmetrische Signatur verwendet wird und ob der Schlüssel in Software oder in einem HSM gespeichert ist. Sie geben den Algorithmus des Schlüssels als Teil der Importanfrage an.

Unabhängig davon müssen Sie auch prüfen, wie der Schlüssel codiert ist, und gegebenenfalls Anpassungen vornehmen.

Folgende Bereiche können für eine Schlüsselversion nach dem Erstellen oder Importieren nicht mehr geändert werden:

  • Das Schutzniveau des Schlüssels gibt an, ob der Schlüssel in Software, in einem HSM oder in einem externen Schlüsselverwaltungssystem vorhanden ist. Schlüsselmaterial kann nicht von einer dieser Speicherumgebungen in eine andere verschoben werden. Alle Versionen eines Schlüssels haben das gleiche Schutzniveau.

  • Der Zweck des Schlüssels gibt an, ob die Versionen des Schlüssels für die symmetrische Verschlüsselung, die asymmetrische Verschlüsselung oder die asymmetrische Signatur verwendet werden. Der Zweck eines Schlüssels beschränkt die möglichen Algorithmen, die zum Erstellen von Versionen dieses Schlüssels verwendet werden können. Alle Versionen eines Schlüssels haben den gleichen Zweck.

Wenn Sie keinen Schlüssel zum Importieren haben, aber das Verfahren zum Importieren von Schlüsseln prüfen möchten, können Sie mit dem folgenden Befehl einen symmetrischen Schlüssel auf dem lokalen System erstellen:

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

Verwenden Sie diesen Schlüssel nur zu Testzwecken. Ein in dieser Weise erstellter Schlüssel ist möglicherweise nicht für die Produktion geeignet.

Wenn Sie den Schlüssel manuell verpacken, dann tun Sie dies, bevor Sie mit den Verfahren in diesem Thema fortfahren.

Den Zielschlüssel und Schlüsselbund erstellen

Ein Cloud KMS-Schlüssel ist ein Containerobjekt, das null oder mehr Schlüsselversionen enthält. Jede Schlüsselversion hat einen kryptografischen Schlüssel.

Wenn Sie einen Schlüssel in Cloud KMS oder Cloud HSM importieren, wird der importierte Schlüssel zu einer neuen Schlüsselversion in einem vorhandenen Cloud KMS- oder Cloud HSM-Schlüssel. Im Folgenden wird dieser Schlüssel als Zielschlüssel bezeichnet. Der Zielschlüssel muss vorhanden sein, bevor Sie Schlüsselmaterial darin importieren können.

Das Importieren einer Schlüsselversion hat keine Auswirkungen auf die vorhandenen Versionen dieses Schlüssels. Es wird jedoch empfohlen, beim Testen des Schlüsselimports einen leeren Schlüssel zu erstellen. Ein leerer Schlüssel hat keine Version, ist nicht aktiv und kann nicht angewendet werden.

Ein Schlüssel befindet sich immer in einem Schlüsselbund. In diesem Thema wird dieser Schlüsselbund als Zielschlüsselbund bezeichnet. Der Speicherort des Zielschlüssels bestimmt, wo das Schlüsselmaterial nach dem Import verfügbar ist. Cloud HSM-Schlüssel können an einigen Standorten nicht erstellt oder importiert werden. Nachdem ein Schlüssel erstellt wurde, kann er nicht mehr zu einem anderen Schlüsselbund oder an einen anderen Speicherort verschoben werden.

Mit den unten aufgeführten Schritten können Sie einen leeren Schlüssel für einen neuen Schlüsselbund mit dem gcloud-Befehlszeilentool oder mit der Google Cloud Console erstellen.

Web-UI

  1. Rufen Sie in der Cloud Console die Seite Cryptographic Keys (Kryptografische Schlüssel) auf.

    Zur Seite "Kryptografische Schlüssel"

  2. Klicken Sie auf KeyRing erstellen.

  3. Geben Sie im Feld Schlüsselbundname einen Namen für den Schlüsselbund ein.

  4. Wählen Sie in der Drop-down-Liste Zone eine Zone aus.

  5. Klicken Sie auf Erstellen. Die Seite mit den Details zum Schlüsselbund wird geöffnet.

  6. Klicken Sie auf Schlüssel erstellen.

  7. Wählen Sie Importierter Schlüssel aus. Dadurch wird verhindert, dass eine erste Schlüsselversion erstellt wird.

  8. Geben Sie im Feld Schlüsselname einen Namen für den Schlüssel ein.

  9. Setzen Sie das Schutzniveau entweder auf Software oder auf HSM.

  10. [Optional] Bei importierten Schlüsseln ist die automatische Rotation standardmäßig deaktiviert. Wenn Sie die automatische Rotation aktivieren, werden in Cloud KMS neue Schlüsselversionen generiert und die importierte Schlüsselversion nach einer Rotation nicht mehr die Standardversion.

  11. [Optional] Klicken Sie im Feld Labels auf Add label (Label hinzufügen), [wenn Sie Ihren Schlüssel mit Labels versehen möchten][4].

  12. Klicken Sie auf Erstellen.

Befehlszeile

Wenn Sie Cloud KMS in der Befehlszeile verwenden möchten, müssen Sie zuerst Cloud SDK installieren oder ein Upgrade ausführen.

  1. Erstellen Sie den Zielschlüsselbund. Wenn Sie in einen Cloud HSM-Schlüssel importieren möchten, wählen Sie einen Standort mit Unterstützung für Cloud HSM aus.

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

    Weitere Informationen zur Erstellung von Schlüsselbunden

  2. Erstellen Sie den Zielschlüssel.

    • Legen Sie den Zweck des Schlüssels fest:
      • Legen Sie für einen zentrischen Schlüssel den Zweck auf encryption fest.
      • Legen Sie für einen asymmetrischen Schlüssel den Zweck auf asymmetric-signing oder asymmetric-encryption fest.
    • Mit dem Flag --skip-initial-version-creation verhindern Sie, dass eine anfängliche Version erstellt wird.
    • Legen Sie nicht das Schutzniveau fest.
    • Geben Sie keinen Algorithmus für den Zielschlüssel an. Sie geben den Algorithmus des importierten Schlüssels als Teil der Importanfrage an.
    • [Optional] Geben Sie keine Rotationsrichtlinie an. Wenn Sie die automatische Rotation aktivieren, werden in Cloud KMS neue Schlüsselversionen generiert und die importierte Schlüsselversion nach einer Rotation nicht mehr die Standardversion.
    gcloud kms keys create key-name \
      --location location \
      --keyring key-ring-name \
      --purpose purpose \
      --skip-initial-version-creation
    

    Hier erhalten Sie weitere Informationen zum Erstellen von Cloud KMS-Schlüsseln oder Cloud HSM-Schlüsseln

Python

Um diesen Code auszuführen, müssen Sie zuerst eine Python-Entwicklungsumgebung einrichten und das Cloud KMS Python SDK installieren.

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))

Der Schlüsselbund und der Schlüssel sind jetzt vorhanden, aber der Schlüssel enthält kein Schlüsselmaterial, keine Version und ist nicht aktiv. Als Nächstes erstellen Sie einen Importjob.

Erstellen Sie den Importjob

Ein Importjob definiert die Merkmale der importierten Schlüssel, einschließlich der Attribute, die nach dem Import des Schlüssels nicht mehr geändert werden können.

Das Schutzniveau legt fest, ob Schlüssel, die aus diesem Importjob stammen, in Software, in einem HSM oder in einem externen Schlüsselverwaltungssystem gespeichert sind. Das Schutzniveau kann nicht mehr geändert werden, nachdem der Schlüssel schließlich importiert wurde.

Die Importmethode definiert den Algorithmus, der zum Erstellen des Verpackungsschlüssels verwendet wird, der importierte Schlüssel bei der Übertragung von Ihrem lokalen System zum Google Cloud-Zielprojekt schützt. Sie können einen RSA-Schlüssel mit 3.072 Bit oder 4.096 Bit auswählen. Wenn es keine speziellen Anforderungen gibt, wird der 3.072-Bit-Verpackungsschlüssel empfohlen.

Sie können einen Importjob mit dem gcloud-Tool, der Cloud Console oder der Cloud Key Management Service-API erstellen.

Web-UI

  1. Rufen Sie in der Cloud Console die Seite Cryptographic Keys (Kryptografische Schlüssel) auf.

    Zur Seite "Kryptografische Schlüssel"

  2. Klicken Sie auf den Namen des Zielschlüsselbunds.

  3. Setzen Sie das Schutzniveau entweder auf Software oder auf HSM. Verwenden Sie dasselbe Schutzniveau wie für den Zielschlüssel.

  4. Klicken Sie auf Importjob erstellen.

  5. Geben Sie im Feld Name einen Namen für den Importjob ein.

  6. Wählen Sie im Drop-down-Menü Importmethode entweder 3.072-Bit-RSA oder 4.096-Bit-RSA aus.

  7. Klicken Sie auf Erstellen.

Befehlszeile

Wenn Sie Cloud KMS in der Befehlszeile verwenden möchten, müssen Sie zuerst Cloud SDK installieren oder ein Upgrade ausführen.

Einen Importjob erstellen Sie mit einem Befehl wie dem folgenden.

gcloud kms import-jobs create import-job \
  --location location \
  --keyring key-ring-name \
  --import-method import-method \
  --protection-level protection-level
  • Verwenden Sie denselben Schlüsselbund und denselben Speicherort wie der Zielschlüssel.
  • Legen Sie das Schutzniveau auf software oder hsm fest.
  • Legen Sie die Importmethode auf rsa-oaep-3072-sha1-aes-256 oder rsa-oaep-4096-sha1-aes-256 fest.

Python

Um diesen Code auszuführen, müssen Sie zuerst eine Python-Entwicklungsumgebung einrichten und das Cloud KMS Python SDK installieren.

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

In diesen Beispielen wird curl als HTTP-Client verwendet, um die Verwendung der API zu demonstrieren. Weitere Informationen zur Zugriffssteuerung finden Sie unter Auf die Cloud KMS API zugreifen.

  1. Erstellen Sie eine Instanz desImportJob und geben Sie Werte für die Felder ImportJob.protectionLevel und ImportJob.importMethod ein.

  2. Rufen Sie die Methode ImportJob.create mit Ihrer Instanz von ImportJob als Anfragetext auf.

Status des Importjobs überprüfen

Der Ausgangsstatus für einen Importjob ist PENDING_GENERATION. Wenn der Status ACTIVE lautet, können Sie damit Schlüssel importieren.

Ein Importjob läuft nach drei Tagen ab. Wenn der Importjob abgelaufen ist, müssen Sie einen neuen erstellen.

Sie können den Status eines Importjobs mit dem gcloud-Befehlszeilentool, der Google Cloud Console oder der Cloud Key Management Service API überprüfen.

Web-UI

  1. Rufen Sie in der Cloud Console die Seite Cryptographic Keys (Kryptografische Schlüssel) auf.

    Zur Seite "Kryptografische Schlüssel"

  2. Klicken Sie auf den Namen des Schlüsselbunds, der den Importjob enthält.

  3. Klicken Sie oben auf der Seite auf den Tab Importjobs.

  4. Der Status wird unter Status neben dem Namen des Importjobs angezeigt.

Befehlszeile

Wenn Sie Cloud KMS in der Befehlszeile verwenden möchten, müssen Sie zuerst Cloud SDK installieren oder ein Upgrade ausführen.

Wenn ein Importjob aktiv ist, können Sie damit Schlüssel importieren. Dies kann einige Minuten dauern. Überprüfen Sie mit diesem Befehl, ob der Importjob aktiv ist. Verwenden Sie den Speicherort und den Schlüsselbund, an dem Sie den Importjob erstellt haben.

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

Python

Um diesen Code auszuführen, müssen Sie zuerst eine Python-Entwicklungsumgebung einrichten und das Cloud KMS Python SDK installieren.

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

In diesen Beispielen wird curl als HTTP-Client verwendet, um die Verwendung der API zu demonstrieren. Weitere Informationen zur Zugriffssteuerung finden Sie unter Auf die Cloud KMS API zugreifen.

Rufen Sie die Methode ImportJob.get auf und überprüfen Sie das Feld state. Wenn state PENDING_GENERATION lautet, wird der Importjob noch erstellt. Prüfen Sie den Status regelmäßig, bis er ACTIVE lautet.

Sobald der Importjob aktiv ist, können Sie eine Anfrage zum Importieren eines Schlüssels stellen.

Änderungen an Importjobs verhindern

Der Importjob bestimmt viele Eigenschaften des importierten Schlüssels, einschließlich seines Algorithmus und ob ein importierter Schlüssel ein HSM- oder Softwareschlüssel ist. Sie können Identitäts- und Zugriffsverwaltungsberechtigungen so konfigurieren, dass Nutzer keine Importjobs erstellen können, aber gleichzeitig zulassen, dass sie Importjobs zum Importieren von Schlüsseln verwenden.

  1. Gewähren Sie nur den Schlüsseladministratoren importjobs.create.
  2. Erteilen Sie dem Operator, der diesen Job zum Importieren von Schlüsseln verwendet, die Berechtigung importjobs.useToImport für einen bestimmten Importjob.
  3. Geben Sie beim Erstellen des Importjobs das Schutzniveau und den Algorithmus für die damit importierten Schlüssel an.

Bis zum Ablauf des Importjobs können Nutzer, die importjobs.useToImport und nicht die Berechtigung importjobs.create für einen bestimmten Importjob haben, Schlüssel importieren, jedoch nicht die Eigenschaften des Importjobs ändern.

Importieren Sie den Schlüssel

Nachdem Sie den Status des Importjobs überprüft haben, können Sie eine Importanfrage stellen.

Sie verwenden verschiedene Flags für die Importanfrage, je nachdem, ob das gcloud-Befehlszeilentool Ihren Schlüssel automatisch verpacken soll oder ob Sie ihn bereits manuell verpackt haben.

Unabhängig davon, ob Sie Ihren Schlüssel manuell oder automatisch verpackt haben, müssen Sie unter Algorithmus einen unterstützten Algorithmus festlegen, der der Länge des tatsächlich zu importierenden Schlüssels entspricht und den Zweck des Schlüssels angibt.

  • Schlüssel mit dem Zweck ENCRYPT_DECRYPT verwenden den Algorithmus google-symmetric-encryption und haben eine Länge von 32.

  • Schlüssel mit dem Zweck ASYMMETRIC_ENCRYPT oder ASYMMETRIC_SIGN unterstützen eine Vielzahl von Algorithmen und Längen.

    Der Zweck eines Schlüssels kann nach dem Erstellen des Schlüssels nicht mehr geändert werden. Für nachfolgende Schlüsselversionen können Sie jedoch eine andere Länge als die ursprüngliche Schlüsselversion festlegen.

Schlüssel automatisch verpacken und importieren

Wenn Sie das automatische Umschließen verwenden möchten, müssen Sie das gcloud-Befehlszeilentool verwenden. Verwenden Sie einen Befehl wie den folgenden. Legen Sie für --target-key-file den Speicherort des entpackten Schlüssels fest, der verpackt und importiert werden soll. Legen Sie nicht -rsa-aes-wrapped-key-file fest.

Sie können das Flag --public-key-file optional auf den Speicherort festlegen, an dem der öffentliche Schlüssel bereits heruntergeladen wurde. Beim Importieren einer großen Anzahl von Schlüsseln wird dadurch verhindert, dass der öffentliche Schlüssel bei jedem Import heruntergeladen wird. Sie können beispielsweise ein Skript schreiben, das den öffentlichen Schlüssel einmal herunterlädt und dann beim Importieren jedes Schlüssels seinen Speicherort angibt.

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

Der Schlüssel wird von dem Verpackungsschlüssel, der dem Importjob zugeordnet ist, verpackt, an Google Cloud übertragen und als neue Schlüsselversion für den Zielschlüssel importiert.

Manuell verpackten Schlüssel importieren

Folgen Sie der Anleitung in diesem Abschnitt, um einen manuell verpackten Schlüssel zu importieren. Legen Sie für --rsa-aes-wrapped-key-file den Speicherort des manuell verpackten Schlüssels fest. Legen Sie nicht --target-key-file fest.

Sie können das Flag --public-key-file optional auf den Speicherort festlegen, an dem der öffentliche Schlüssel bereits heruntergeladen wurde. Beim Importieren einer großen Anzahl von Schlüsseln wird dadurch verhindert, dass der öffentliche Schlüssel bei jedem Import heruntergeladen wird. Sie können beispielsweise ein Skript schreiben, das den öffentlichen Schlüssel einmal herunterlädt und dann beim Importieren jedes Schlüssels seinen Speicherort angibt.

Web-UI

  1. Öffnen Sie in der Cloud Console die Seite Kryptografische Schlüssel.

  2. Klicken Sie auf den Namen des Schlüsselbunds, der den Importjob enthält. Der Zielschlüssel wird zusammen mit allen anderen Schlüsseln auf dem Schlüsselbund angezeigt.

  3. Klicken Sie auf den Namen des Zielschlüssels und dann auf Schlüsselversion importieren.

  4. Wählen Sie den Importjob aus dem Drop-down-Menü Importjob auswählen aus.

  5. Wählen Sie aus der Auswahl Verpackten Schlüssel hochladen den Schlüssel aus, den Sie bereits verpackt haben.

  6. Wenn Sie einen asymmetrischen Schlüssel importieren, wählen Sie den Algorithmus aus dem Drop-down-Menü Algorithmus aus. Die Seite Schlüsselversion importieren sollte in etwa so aussehen:

    Schlüsselversion importieren

  7. Klicken Sie auf Importieren.

Befehlszeile

Wenn Sie Cloud KMS in der Befehlszeile verwenden möchten, müssen Sie zuerst Cloud SDK installieren oder ein Upgrade ausführen.

Verwenden Sie einen Befehl wie den folgenden.

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

Weitere Informationen finden Sie in der Ausgabe des Befehls gcloud kms keys versions import --help.

Python

Um diesen Code auszuführen, müssen Sie zuerst eine Python-Entwicklungsumgebung einrichten und das Cloud KMS Python SDK installieren.

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

In diesen Beispielen wird curl als HTTP-Client verwendet, um die Verwendung der API zu demonstrieren. Weitere Informationen zur Zugriffssteuerung finden Sie unter Auf die Cloud KMS API zugreifen.

  1. Setzen Sie für den Anfragetext der Methode cryptoKeyVersions.import das Feld algorithm auf den Algorithmus des zu importierenden Schlüssels. Dieser Wert muss nicht mit dem versionTemplate des CryptoKey übereinstimmen, der diese Version importiert. Das Feld algorithm hat den Typ CryptoKeyVersionAlgorithm.

  2. Legen Sie außerdem für den Anfragetext im Feld wrappedKeyMaterial das Schlüsselmaterial fest, das Siebereits verpackt haben.

  3. Rufen Sie die Methode cryptoKeyVersions.import auf. Die Antwort cryptoKeyVersions.import hat den Typ CryptoKeyVersion. Wurde ein Schlüssel erfolgreich importiert, lautet der Status ENABLED und Sie können ihn in Cloud KMS verwenden.

Die Anfrage für den Schlüsselimport wird initiiert. Sie können den Status überwachen.

Status des importierten Schlüssels prüfen

Der Anfangsstatus für einen importierten Schlüssel ist PENDING_IMPORT. Wenn der Status ENABLED lautet, wurde der Schlüssel erfolgreich importiert. Wenn der Import fehlschlägt, lautet der Status IMPORT_FAILED.

Sie können den Status einer Importanfrage mit dem gcloud-Befehlszeilentool, der Google Cloud Console oder der Cloud Key Management Service API überprüfen.

Web-UI

  1. Öffnen Sie in der Cloud Console die Seite Kryptografische Schlüssel.

  2. Klicken Sie auf den Namen des Schlüsselbunds, der den Importjob enthält.

  3. Klicken Sie oben auf der Seite auf den Tab Importjobs.

  4. Der Status wird unter Status neben dem Namen des Importjobs angezeigt.

Befehlszeile

Wenn Sie Cloud KMS in der Befehlszeile verwenden möchten, müssen Sie zuerst Cloud SDK installieren oder ein Upgrade ausführen.

Prüfen Sie den Status mithilfe des Befehls versions list. Verwenden Sie denselben Speicherort, denselben Schlüsselbund und denselben Schlüssel, den Sie zuvor in diesem Thema erstellt haben.

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

Python

Um diesen Code auszuführen, müssen Sie zuerst eine Python-Entwicklungsumgebung einrichten und das Cloud KMS Python SDK installieren.

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

In diesen Beispielen wird curl als HTTP-Client verwendet, um die Verwendung der API zu demonstrieren. Weitere Informationen zur Zugriffssteuerung finden Sie unter Auf die Cloud KMS API zugreifen.

Rufen Sie die Methode ImportJob.get auf und überprüfen Sie das Feld state. Wenn state PENDING_GENERATION lautet, wird der Importjob noch erstellt. Prüfen Sie den Status regelmäßig, bis er ACTIVE lautet.

Nach dem Import des Schlüssels ändert sich sein Status in Aktiv. Bei symmetrischen Schlüsseln müssen Sie die importierte Schlüsselversion als primäre Version festlegen, bevor Sie den Schlüssel verwenden können.

Symmetrische Schlüssel: Legen Sie die primäre Version fest

Dieser Schritt ist beim Importieren von Symmetrieschlüsseln erforderlich und für asymmetrische Schlüssel nicht relevant. Ein asymmetrischer Schlüssel hat keine primäre Version. Sie müssen das gcloud-Befehlszeilentool verwenden, um die primäre Version festzulegen.

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

Nächste Schritte