Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Quantensicherer Schlüsselimport

In dieser Anleitung erfahren Sie, wie Sie einen kryptografischen Schlüssel mit einer quantensicheren Importmethode als neue Schlüsselversion in den Cloud Key Management Service importieren. Dieser Ansatz trägt dazu bei, den Schlüssel während der Übertragung vor „Store now, decrypt later“-Angriffen (SNDL) durch zukünftige Quantencomputer zu schützen.

Beim quantensicheren Schlüsselimport werden standardmäßige Post-Quanten-Kryptografie-Tools (PQC) verwendet, einschließlich Key Encapsulation Mechanisms (KEMs) und Hybrid Public Key Encryption (HPKE), um Ihren Schlüssel während der Übertragung zu schützen.

Der quantensichere Schlüsselimport wird für softwaregestützte Schlüssel (Schutzstufe SOFTWARE) unterstützt.

Hinweis

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

Projekt vorbereiten

Melden Sie sich in Ihrem Google Cloud -Konto an. Wenn Sie mit Google Cloudnoch nicht vertraut sind, erstellen Sie einfach ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API, if it is not already enabled.

Roles required to enable APIs

To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

Enable the API

Install the Google Cloud CLI.

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

To initialize the gcloud CLI, run the following command:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API, if it is not already enabled.

Roles required to enable APIs

Enable the API

Install the Google Cloud CLI.

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

To initialize the gcloud CLI, run the following command:

gcloud init

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für den Schlüsselbund zuzuweisen, damit Sie die nötigen Berechtigungen zum Importieren eines Schlüssels haben:

Nur in vorhandene Schlüssel importieren: Cloud KMS-Importeur (roles/cloudkms.importer)
Für den Import in neue Schlüssel: Cloud KMS-Administrator (roles/cloudkms.admin)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Lokales System vorbereiten

Sie benötigen eine kryptografische Bibliothek auf Ihrem lokalen System, die PQC-Tools (Post-Quantum Cryptography) unterstützt, einschließlich KEMs (Key Encapsulation Mechanisms) und HPKE (Hybrid Public Key Encryption). Sie können Tink, OpenSSL oder eine andere kryptografische Bibliothek verwenden, die Folgendes unterstützt:

Hybrid Public Key Encryption (HPKE)
Einer der folgenden KEM-Algorithmen:
- ML-KEM-768
- ML-KEM-1024
- X-WING (eine Mischung aus ML-KEM-768 und X25519)
Die Schlüsselableitungsfunktion (KDF) HKDF-SHA256
Authentifizierte Verschlüsselung mit verknüpften Daten (Authenticated Encryption with Associated Data, AEAD) mit dem AES-256-GCM-Algorithmus

Schlüssel vorbereiten

Prüfen Sie, ob Algorithmus und Länge Ihres Schlüssels unterstützt werden. Alle Versionen eines Schlüssels müssen dieselbe Schutzebene (SOFTWARE) haben.

Den Zielschlüssel und Schlüsselbund erstellen

Wenn Sie Schlüsselmaterial importieren, wird es zu einer neuen Schlüsselversion eines vorhandenen Schlüssels. Dieser Schlüssel wird als Zielschlüssel bezeichnet. Der Zielschlüsselbund und der Zielschlüssel müssen vorhanden sein, bevor Sie Schlüsselmaterial importieren können.

Führen Sie die folgenden Schritte aus, um mit der Google Cloud CLI oder der Google Cloud Console einen leeren softwaregestützten Schlüssel in einem neuen Schlüsselbund zu erstellen.

Console

Rufen Sie in der Google Cloud Console die Seite Schlüsselverwaltung auf.

Key Management aufrufen
Klicken Sie auf Schlüsselbund erstellen.
Geben Sie im Feld Schlüsselbundname einen Namen für den Schlüsselbund ein.
Wählen Sie unter Standorttyp einen Standorttyp und einen Standort aus.
Klicken Sie auf Erstellen. Die Seite Schlüssel erstellen wird geöffnet.
Geben Sie im Feld Schlüsselname einen Namen für den Schlüssel ein.
Wählen Sie als Schutzniveau die Option Software aus.
Wählen Sie unter Schlüsselmaterial die Option Importierter Schlüssel aus und klicken Sie dann auf Weiter. Dadurch wird verhindert, dass eine erste Schlüsselversion erstellt wird.
Legen Sie den Zweck und den Algorithmus für den Schlüssel fest und klicken Sie dann auf Weiter.
Optional: Wenn dieser Schlüssel nur importierte Schlüsselversionen enthalten soll, wählen Sie Schlüsselversionen ausschließlich auf Import einschränken aus. So wird verhindert, dass Sie versehentlich neue Schlüsselversionen in Cloud KMS erstellen.
Optional: Bei importierten Schlüsseln ist die automatische Rotation standardmäßig deaktiviert. Wählen Sie im Feld Schlüsselrotationszeitraum einen Wert aus, um die automatische Rotation zu aktivieren.

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.
Klicken Sie auf Erstellen.

gcloud

Wenn Sie Cloud KMS über die Befehlszeile verwenden möchten, müssen Sie zuerst die Google Cloud CLI installieren oder auf die neueste Version aktualisieren.

Erstellen Sie den Zielschlüsselbund. Wählen Sie einen Standort aus, der mit der gewünschten Schutzstufe kompatibel ist. Weitere Informationen zu unterstützten Standorten finden Sie unter Cloud KMS-Standorte.
```
gcloud kms keyrings create KEY_RING \
  --location LOCATION
```
Weitere Informationen zum Erstellen von Schlüsselbunden
Erstellen Sie den Zielschlüssel mit dem Befehl kms keys create und dem Flag --skip-initial-version-creation. Dadurch wird ein Schlüssel ohne anfängliche Schlüsselversion erstellt, sodass Ihr importiertes Schlüsselmaterial die Version 1 hat. Verwenden Sie das Flag --import-only, um zu verhindern, dass Cloud KMS Schlüsselmaterial für neue Schlüsselversionen generiert. Wenn dieses Flag festgelegt ist, müssen neue Schlüsselversionen für diesen Schlüssel importiert werden. Als --import-only erstellte Schlüssel müssen manuell rotiert werden.
```
gcloud kms keys create KEY_NAME \
  --location LOCATION \
  --keyring KEY_RING \
  --purpose PURPOSE \
  --protection-level SOFTWARE \
  --skip-initial-version-creation \
  --import-only
```
Ersetzen Sie Folgendes:
- KEY_NAME: Der Name, den Sie für den Schlüssel verwenden möchten.
- LOCATION: der Speicherort des Schlüsselbunds.
- KEY_RING: der Schlüsselbund, in dem Sie den Schlüssel erstellen möchten.
- PURPOSE: der Zweck, für den Sie den Schlüssel verwenden möchten.

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.

So erstellen Sie einen neuen Schlüsselbund:

curl "https://cloudkms.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/keyRings?keyRingId=KEY_RING" \
    --request "POST" \
    --header "authorization: Bearer TOKEN" \
    --header "content-type: application/json" \
    --header "x-goog-user-project: PROJECT_ID" \
    --data "{}"

Weitere Informationen finden Sie in der KeyRing.create API-Dokumentation.

Leeren Schlüssel erstellen, der nur für den Import verwendet werden kann:

curl "https://cloudkms.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/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", "importOnly": "true", "versionTemplate":{"protectionLevel":"PROTECTION_LEVEL","algorithm":"ALGORITHM"}}"

Weitere Informationen finden Sie in der CryptoKey.create API-Dokumentation.

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 Schutzstufe und der Importmethode.

Der quantensichere Schlüsselimport wird nur für die Schutzstufe SOFTWARE unterstützt. Wählen Sie eine der folgenden quantensicheren Importmethoden aus:

HPKE_KEM_XWING_HKDF_SHA256_AES_256_GCM
HPKE_KEM_ML_KEM_768_HKDF_SHA256_AES_256_GCM
HPKE_KEM_ML_KEM_1024_HKDF_SHA256_AES_256_GCM

gcloud

Führen Sie den folgenden Befehl aus, um einen Importjob mit einer quantensicheren Importmethode zu erstellen:

gcloud kms import-jobs create IMPORT_JOB \
    --location LOCATION \
    --keyring KEY_RING \
    --import-method IMPORT_METHOD \
    --protection-level software

Ersetzen Sie Folgendes:

IMPORT_JOB: Ein eindeutiger Name für den Importjob.
LOCATION: der Speicherort des Schlüsselbunds, in dem Sie Ihren Zielschlüssel erstellt haben
KEY_RING: der Name des Schlüsselbunds, in dem Sie den Zielschlüssel erstellt haben.
IMPORT_METHOD: die quantensichere Importmethode, die Sie verwenden möchten, z. B. hpke-kem-xwing-hkdf-sha256-aes-256-gcm.

REST

Rufen Sie die Methode keyRings.importJobs.create auf.

curl "https://cloudkms.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/importJobs?import_job_id=IMPORT_JOB" \
    --request "POST" \
    --header "authorization: Bearer TOKEN" \
    --header "content-type: application/json" \
    --data '{"import_method": "IMPORT_METHOD", "protection_level": "SOFTWARE"}'

Ersetzen Sie Folgendes:

PROJECT_ID: die Kennung Ihres Cloud KMS-Projekts.
LOCATION: der Speicherort des Schlüsselbunds, in dem Sie Ihren Zielschlüssel erstellt haben
KEY_RING: der Name des Schlüsselbunds, in dem Sie den Zielschlüssel erstellt haben
IMPORT_JOB: Ein eindeutiger Name für den Importjob.
TOKEN: das Token zur Authentifizierung der Anfrage.
IMPORT_METHOD: die quantensichere Importmethode, die Sie verwenden möchten, z. B. HPKE_KEM_XWING_HKDF_SHA256_AES_256_GCM.

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 der Google Cloud CLI, derGoogle Cloud Console oder der Cloud Key Management Service API prüfen.

Console

Rufen Sie in der Google Cloud Console die Seite Schlüsselverwaltung auf.

Key Management aufrufen
Klicken Sie auf den Namen des Schlüsselbunds, der den Importjob enthält.
Klicken Sie oben auf der Seite auf den Tab Importjobs.
Der Status wird unter Status neben dem Namen des Importjobs angezeigt.

gcloud

Wenn Sie Cloud KMS über die Befehlszeile verwenden möchten, müssen Sie zuerst die Google Cloud CLI installieren oder auf die neueste Version aktualisieren.

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 \
  --format="value(state)"

Die Ausgabe sieht etwa so aus:

state: ACTIVE

Go

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

import (
	"context"
	"fmt"
	"io"

	kms "cloud.google.com/go/kms/apiv1"
	"cloud.google.com/go/kms/apiv1/kmspb"
)

// checkStateImportJob checks the state of an ImportJob in KMS.
func checkStateImportJob(w io.Writer, name string) error {
	// name := "projects/PROJECT_ID/locations/global/keyRings/my-key-ring/importJobs/my-import-job"

	// Create the client.
	ctx := context.Background()
	client, err := kms.NewKeyManagementClient(ctx)
	if err != nil {
		return fmt.Errorf("failed to create kms client: %w", err)
	}
	defer client.Close()

	// Call the API.
	result, err := client.GetImportJob(ctx, &kmspb.GetImportJobRequest{
		Name: name,
	})
	if err != nil {
		return fmt.Errorf("failed to get import job: %w", err)
	}
	fmt.Fprintf(w, "Current state of import job %q: %s\n", result.Name, result.State)
	return nil
}

Java

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

import com.google.cloud.kms.v1.ImportJob;
import com.google.cloud.kms.v1.ImportJobName;
import com.google.cloud.kms.v1.KeyManagementServiceClient;
import java.io.IOException;

public class CheckStateImportJob {

  public void checkStateImportJob() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String locationId = "us-east1";
    String keyRingId = "my-key-ring";
    String importJobId = "my-import-job";
    checkStateImportJob(projectId, locationId, keyRingId, importJobId);
  }

  // Check the state of an import job in Cloud KMS.
  public void checkStateImportJob(
      String projectId, String locationId, String keyRingId, String importJobId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only
    // needs to be created once, and can be reused for multiple requests. After
    // completing all of your requests, call the "close" method on the client to
    // safely clean up any remaining background resources.
    try (KeyManagementServiceClient client = KeyManagementServiceClient.create()) {
      // Build the parent name from the project, location, and key ring.
      ImportJobName importJobName = ImportJobName.of(projectId, locationId, keyRingId, importJobId);

      // Retrieve the state of an existing import job.
      ImportJob importJob = client.getImportJob(importJobName);
      System.out.printf(
          "Current state of import job %s: %s%n", importJob.getName(), importJob.getState());
    }
  }
}

Node.js

Um diesen Code auszuführen, richten Sie zuerst eine Node.js-Entwicklungsumgebung ein und installieren Sie das Cloud KMS Node.js SDK.

//
// TODO(developer): Uncomment these variables before running the sample.
//
// const projectId = 'my-project';
// const locationId = 'us-east1';
// const keyRingId = 'my-key-ring';
// const importJobId = 'my-import-job';

// Imports the Cloud KMS library
const {KeyManagementServiceClient} = require('@google-cloud/kms');

// Instantiates a client
const client = new KeyManagementServiceClient();

// Build the import job name
const importJobName = client.importJobPath(
  projectId,
  locationId,
  keyRingId,
  importJobId
);

async function checkStateImportJob() {
  const [importJob] = await client.getImportJob({
    name: importJobName,
  });

  console.log(
    `Current state of import job ${importJob.name}: ${importJob.state}`
  );
  return importJob;
}

return checkStateImportJob();

Python

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

from google.cloud import kms


def check_state_import_job(
    project_id: str, location_id: str, key_ring_id: str, import_job_id: str
) -> None:
    """
    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').
    """

    # 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(f"Current state of import job {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.

Verwenden Sie die Methode ImportJobs.get, um den Status eines Importjobs zu prüfen:

curl "https://cloudkms.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/importJobs/IMPORT_JOB_ID" \
    --request "GET" \
    --header "authorization: Bearer TOKEN"

Sobald der Importjob aktiv ist, können Sie einen Schlüssel importieren.

Öffentlichen Wrapping-Schlüssel abrufen

Nachdem der Importjob ACTIVE wurde, rufen Sie den zugehörigen öffentlichen Schlüssel ab. Sie verwenden diesen öffentlichen Schlüssel auf Ihrem lokalen System, um das zu importierende Schlüsselmaterial zu verpacken.

gcloud

Führen Sie den folgenden Befehl aus, um den öffentlichen Schlüssel herunterzuladen:

gcloud kms import-jobs describe IMPORT_JOB \
    --location LOCATION \
    --keyring KEY_RING \
    --format="value(publicKey.data)"

Ersetzen Sie Folgendes:

IMPORT_JOB: der Name des Importjobs.
LOCATION: der Speicherort des Schlüsselbunds, in dem Sie den Importjob erstellt haben.
KEY_RING: der Name des Schlüsselbunds, in dem Sie den Importjob erstellt haben.

Der öffentliche Schlüssel ist Base64-codiert.

REST

Rufen Sie die Methode keyRings.importJobs.get auf.
Rufen Sie den öffentlichen Schlüssel aus dem Feld publicKey.data der Antwort ab und speichern Sie ihn lokal als public_key.data.

Schlüsselmaterial vorbereiten und verpacken

Verwenden Sie eine unterstützte externe kryptografische Bibliothek auf Ihrem lokalen System, um das Schlüsselmaterial mit dem abgerufenen öffentlichen Wrapping-Schlüssel zu wrappen.

Beim Verpackungsvorgang muss HPKE.Seal() (RFC 9180) ausgeführt werden, um einen verpackten Schlüssel zu erzeugen. Damit sind die folgenden Schritte abgeschlossen:

Kapseln Sie den abgerufenen öffentlichen Schlüssel, um ein gemeinsames Secret und einen Kapselungsschlüssel zu erstellen.
Leiten Sie mit HKDF-SHA256 einen sitzungsspezifischen symmetrischen Schlüssel aus dem gemeinsamen Secret ab.
Verschlüsseln Sie Ihr Schlüsselmaterial mit dem temporären Schlüssel mit AES-256-GCM.
Verketten Sie den Kapselungsschlüssel und das als Geheimtext verschlüsselte Schlüsselmaterial. Dies ist der resultierende verpackte Schlüssel, den Sie zum Importieren des Schlüssels verwenden. Speichern Sie die Datei als wrapped_key.bin.

Das folgende Go-Codebeispiel zeigt, wie Schlüsselmaterial mit der tink-go-Bibliothek umschlossen wird:

package main

import (
    "bytes"
    "encoding/base64"
    "flag"
    "fmt"
    "log"

    "google.golang.org/protobuf/proto"
    "github.com/tink-crypto/tink-go/v2/hybrid"
    "github.com/tink-crypto/tink-go/v2/keyset"

    hpkepb "github.com/tink-crypto/tink-go/v2/proto/hpke_go_proto"
    tinkpb "github.com/tink-crypto/tink-go/v2/proto/tink_go_proto"
)

var (
    publicKeyB64Flag = flag.String("public_key", "", "Base64 encoded public key for wrapping.")
    targetKeyB64Flag = flag.String("target_key", "", "Base64 encoded 32-byte target key to be wrapped.")
)

func main() {
    flag.Parse()

    if *publicKeyB64Flag == "" {
        log.Fatal("-public_key is required")
    }
    if *targetKeyB64Flag == "" {
        log.Fatal("-target_key is required")
    }

    pkBytes, err := base64.StdEncoding.DecodeString(*publicKeyB64Flag)
    if err != nil {
        log.Fatalf("failed to decode public key: %v", err)
    }

    targetKey, err := base64.StdEncoding.DecodeString(*targetKeyB64Flag)
    if err != nil {
        log.Fatalf("failed to decode target key: %v", err)
    }

    hpkePubKey := &hpkepb.HpkePublicKey{
        Version: 0,
        Params: &hpkepb.HpkeParams{
            Kem:  hpkepb.HpkeKem_ML_KEM768,
            Kdf:  hpkepb.HpkeKdf_HKDF_SHA256,
            Aead: hpkepb.HpkeAead_AES_256_GCM,
        },
        PublicKey: pkBytes,
    }
    serializedPubKey, err := proto.Marshal(hpkePubKey)
    if err != nil {
        log.Fatalf("failed to marshal HPKE public key: %v", err)
    }

    ks := &tinkpb.Keyset{
        PrimaryKeyId: 1,
        Key: []*tinkpb.Keyset_Key{
            {
                KeyData: &tinkpb.KeyData{
                    TypeUrl:         "type.googleapis.com/google.crypto.tink.HpkePublicKey",
                    Value:           serializedPubKey,
                    KeyMaterialType: tinkpb.KeyData_ASYMMETRIC_PUBLIC,
                },
                Status:           tinkpb.KeyStatusType_ENABLED,
                KeyId:            1,
                OutputPrefixType: tinkpb.OutputPrefixType_RAW,
            },
        },
    }
    serializedKeyset, err := proto.Marshal(ks)
    if err != nil {
        log.Fatalf("failed to marshal keyset: %v", err)
    }

    // Create a KeysetHandle and retrieve the HybridEncrypt primitive.
    reader := keyset.NewBinaryReader(bytes.NewReader(serializedKeyset))
    handle, err := keyset.ReadWithNoSecrets(reader)
    if err != nil {
        log.Fatalf("failed to create keyset handle: %v", err)
    }

    enc, err := hybrid.NewHybridEncrypt(handle)
    if err != nil {
        log.Fatalf("failed to create hybrid encrypt primitive: %v", err)
    }

    // Perform the wrapping operation. Tink's HPKE implementation handles the
  // 'enc || ciphertext' concatenation automatically.
    wrappedKey, err := enc.Encrypt(targetKey, nil)
    if err != nil {
        log.Fatalf("failed to wrap key: %v", err)
    }

    fmt.Printf("Final wrappedKey (base64):\n%s\n", base64.StdEncoding.EncodeToString(wrappedKey))
}

Speichern Sie den Base64-Ausgabestring oder decodieren Sie ihn in eine Binärdatei: bash echo "BASE64_WRAPPED_KEY" | base64 --decode > wrapped_key.bin

Verpackten Schlüssel importieren

Importieren Sie den vorbereiteten verpackten Schlüssel als neue Schlüsselversion Ihres Zielschlüssels.

gcloud

Führen Sie den Befehl kms keys versions import aus:

gcloud kms keys versions import \
    --location LOCATION \
    --keyring KEY_RING \
    --key KEY_NAME \
    --import-job IMPORT_JOB \
    --algorithm ALGORITHM \
    --wrapped-key-file wrapped_key.bin

Ersetzen Sie Folgendes:

LOCATION: der Speicherort des Schlüsselbunds, der den Zielschlüssel enthält.
KEY_RING: der Name des Schlüsselbunds, der den Zielschlüssel enthält
KEY_NAME: der Name Ihres Targeting-Schlüssels.
IMPORT_JOB: der Name des Importjobs.
ALGORITHM: Der Algorithmus des zu importierenden Schlüsselmaterials.

REST

Rufen Sie die Methode cryptoKeyVersions.import auf.

curl "https://cloudkms.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY_NAME/cryptoKeyVersions:import" \
    --request "POST" \
    --header "authorization: Bearer TOKEN" \
    --header "content-type: application/json" \
    --data '{"importJob": "IMPORT_JOB", "algorithm": "ALGORITHM", "wrappedKey": "PATH_TO_WRAPPED_KEY"}'

Ersetzen Sie Folgendes:

PROJECT_ID: die Kennung Ihres Cloud KMS-Projekts.
LOCATION: der Speicherort des Schlüsselbunds, der Ihren Targeting-Schlüssel enthält
KEY_RING: der Name des Schlüsselbunds, der den Zielschlüssel enthält
KEY_NAME: der Name Ihres Targeting-Schlüssels.
TOKEN: das Token zur Authentifizierung der Anfrage.
IMPORT_JOB: die Kennung des entsprechenden Importjobs.
ALGORITHM: der Algorithmus des zu importierenden Schlüsselmaterials.
PATH_TO_WRAPPED_KEY: der Pfad zu Ihrem manuell verpackten Schlüssel im base64-Format.

Status der importierten Schlüsselversion prüfen

Der Ausgangszustand für eine importierte Schlüsselversion ist PENDING_IMPORT. Wenn der Status ENABLED ist, wurde die Schlüsselversion erfolgreich importiert. Wenn der Import fehlschlägt, lautet der Status IMPORT_FAILED.

Sie können den Status einer Importanfrage mit der Google Cloud CLI, derGoogle Cloud -Konsole oder der Cloud Key Management Service API prüfen.

Console

Rufen Sie in der Google Cloud Console die Seite Schlüsselverwaltung auf.

Key Management aufrufen
Klicken Sie auf den Namen des Schlüsselbunds, der den Importjob enthält.
Klicken Sie oben auf der Seite auf den Tab Importjobs.
Der Status wird unter Status neben dem Namen des Importjobs angezeigt.

gcloud

Wenn Sie Cloud KMS über die Befehlszeile verwenden möchten, müssen Sie zuerst die aktuelle Version der Google Cloud CLI installieren oder ein Upgrade darauf durchfü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 KEY_RING \
  --location LOCATION \
  --key KEY_NAME

Go

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

import (
	"context"
	"fmt"
	"io"

	kms "cloud.google.com/go/kms/apiv1"
	"cloud.google.com/go/kms/apiv1/kmspb"
)

// checkStateImportedKey checks the state of a CryptoKeyVersion in KMS.
func checkStateImportedKey(w io.Writer, name string) error {
	// name := "projects/PROJECT_ID/locations/global/keyRings/my-key-ring/cryptoKeys/my-imported-key/cryptoKeyVersions/1"

	// Create the client.
	ctx := context.Background()
	client, err := kms.NewKeyManagementClient(ctx)
	if err != nil {
		return fmt.Errorf("failed to create kms client: %w", err)
	}
	defer client.Close()

	// Call the API.
	result, err := client.GetCryptoKeyVersion(ctx, &kmspb.GetCryptoKeyVersionRequest{
		Name: name,
	})
	if err != nil {
		return fmt.Errorf("failed to get crypto key version: %w", err)
	}
	fmt.Fprintf(w, "Current state of crypto key version %q: %s\n", result.Name, result.State)
	return nil
}

Java

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

import com.google.cloud.kms.v1.CryptoKeyVersion;
import com.google.cloud.kms.v1.CryptoKeyVersionName;
import com.google.cloud.kms.v1.KeyManagementServiceClient;
import java.io.IOException;

public class CheckStateImportedKey {

  public void checkStateImportedKey() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String locationId = "us-east1";
    String keyRingId = "my-key-ring";
    String cryptoKeyId = "my-crypto-key";
    String cryptoKeyVersionId = "1";
    checkStateImportedKey(projectId, locationId, keyRingId, cryptoKeyId, cryptoKeyVersionId);
  }

  // Check the state of an imported key in Cloud KMS.
  public void checkStateImportedKey(
      String projectId,
      String locationId,
      String keyRingId,
      String cryptoKeyId,
      String cryptoKeyVersionId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only
    // needs to be created once, and can be reused for multiple requests. After
    // completing all of your requests, call the "close" method on the client to
    // safely clean up any remaining background resources.
    try (KeyManagementServiceClient client = KeyManagementServiceClient.create()) {
      // Build the version name from its path components.
      CryptoKeyVersionName versionName =
          CryptoKeyVersionName.of(
              projectId, locationId, keyRingId, cryptoKeyId, cryptoKeyVersionId);

      // Retrieve the state of an existing version.
      CryptoKeyVersion version = client.getCryptoKeyVersion(versionName);
      System.out.printf(
          "Current state of crypto key version %s: %s%n", version.getName(), version.getState());
    }
  }
}

Node.js

Um diesen Code auszuführen, richten Sie zuerst eine Node.js-Entwicklungsumgebung ein und installieren Sie das Cloud KMS Node.js SDK.

//
// TODO(developer): Uncomment these variables before running the sample.
//
// const projectId = 'my-project';
// const locationId = 'us-east1';
// const keyRingId = 'my-key-ring';
// const cryptoKeyId = 'my-imported-key';
// const cryptoKeyVersionId = '1';

// Imports the Cloud KMS library
const {KeyManagementServiceClient} = require('@google-cloud/kms');

// Instantiates a client
const client = new KeyManagementServiceClient();

// Build the key version name
const keyVersionName = client.cryptoKeyVersionPath(
  projectId,
  locationId,
  keyRingId,
  cryptoKeyId,
  cryptoKeyVersionId
);

async function checkStateCryptoKeyVersion() {
  const [keyVersion] = await client.getCryptoKeyVersion({
    name: keyVersionName,
  });

  console.log(
    `Current state of key version ${keyVersion.name}: ${keyVersion.state}`
  );
  return keyVersion;
}

return checkStateCryptoKeyVersion();

Python

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

from google.cloud import kms


def check_state_imported_key(
    project_id: str, location_id: str, key_ring_id: str, import_job_id: str
) -> None:
    """
    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').
    """

    # 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(f"Current state of import job {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 prüfen Sie das Feld [state][api_importjob_fields_state]. Wenn state PENDING_GENERATION ist, wird der Importjob noch erstellt. Prüfen Sie den Status regelmäßig, bis er ACTIVE lautet.

Nachdem die erste Schlüsselversion importiert wurde, ändert sich der Status des Schlüssels in ENABLED. Bei symmetrischen Schlüsseln müssen Sie die importierte Schlüsselversion als primäre Version festlegen, bevor Sie den Schlüssel verwenden können.

Einen gelöschten Schlüssel noch einmal importieren

Wenn Sie eine zuvor importierte Schlüsselversion, die den Status DESTROYED oder IMPORT_FAILED hat, wieder in den Status ENABLED versetzen möchten, können Sie genau dasselbe Schlüsselmaterial noch einmal importieren.

Das erneute Importieren einer gelöschten Schlüsselversion erfolgt auf dieselbe Weise wie der ursprüngliche Import, entweder mit dem ursprünglichen Importjob oder mit einem neuen Importjob (mit derselben Schutzstufe SOFTWARE).

Zurück

Schlüssel mit OpenSSL verpacken

Weiter

Automatisches Schlüssel-Wrapping einrichten

Quantensicherer Schlüsselimport Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Hinweis

Projekt vorbereiten

Erforderliche Rollen

Lokales System vorbereiten

Schlüssel vorbereiten

Den Zielschlüssel und Schlüsselbund erstellen

Console

gcloud

API

Erstellen Sie den Importjob

gcloud

REST

Status des Importjobs überprüfen

Console

gcloud

Go

Java

Node.js

Python

API

Öffentlichen Wrapping-Schlüssel abrufen

gcloud

REST

Schlüsselmaterial vorbereiten und verpacken

Verpackten Schlüssel importieren

gcloud

REST

Status der importierten Schlüsselversion prüfen

Console

gcloud

Go

Java

Node.js

Python

API

Einen gelöschten Schlüssel noch einmal importieren

Quantensicherer Schlüsselimport