Google は AI 技術を使用して、コンテンツをご希望の言語に翻訳しています。AI 翻訳には誤りが含まれる場合があります。

耐量子鍵のインポート

このガイドでは、耐量子インポート方法を使用して、暗号鍵を新しい鍵バージョンとして Cloud Key Management Service にインポートする方法について説明します。このアプローチは、将来の量子コンピュータによる「今すぐ収集、後で解読」（HNDL）攻撃から転送中の鍵を保護するのに役立ちます。

耐量子鍵インポートでは、鍵カプセル化メカニズム（KEM）やハイブリッド公開鍵暗号化（HPKE）などの標準のポスト量子暗号（PQC）ツールを使用して、転送中の鍵を保護します。

耐量子鍵インポートは、ソフトウェアバックアップ鍵（SOFTWARE 保護レベル）でサポートされています。

始める前に

鍵をインポートするには、プロジェクト、ローカルシステム、鍵マテリアル自体の準備が必要です。

プロジェクトを準備する

Google Cloud アカウントにログインします。を初めて使用する場合は、 Google Cloud、アカウントを作成して、実際のシナリオでプロダクトがどのように機能するかを評価してください。新規のお客様には、ワークロードの実行、テスト、デプロイができる無料クレジット $300 分を差し上げます。

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.

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

Google Cloud CLI をインストールします。

外部 ID プロバイダ（IdP）を使用している場合は、まず連携 ID を使用して gcloud CLI にログインする必要があります。

gcloud CLI を初期化するには、次のコマンドを実行します:

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.

Roles required to enable APIs

Enable the API

Google Cloud CLI をインストールします。

外部 ID プロバイダ（IdP）を使用している場合は、まず連携 ID を使用して gcloud CLI にログインする必要があります。

gcloud CLI を初期化するには、次のコマンドを実行します:

gcloud init

必要なロール

鍵をインポートするために必要な権限を取得するには、鍵リングに対する次の IAM ロールを付与するよう管理者に依頼してください。

既存の鍵にのみインポートする場合: Cloud KMS インポーター (roles/cloudkms.importer)
新しい鍵にインポートする場合: Cloud KMS 管理者 (roles/cloudkms.admin)

ロールの付与については、プロジェクト、フォルダ、組織へのアクセス権の管理をご覧ください。

必要な権限は、カスタムロールや他の事前定義ロールから取得することもできます。

ローカルシステムを準備する

ローカルシステムには、鍵カプセル化メカニズム（KEM）やハイブリッド公開鍵暗号化（HPKE）などのポスト量子暗号（PQC）ツールをサポートする暗号ライブラリが必要です。Tink、OpenSSL、または次の機能をサポートする別の暗号ライブラリを使用できます。

ハイブリッド公開鍵暗号化（HPKE）
次のいずれかの KEM アルゴリズム:
- ML-KEM-768
- ML-KEM-1024
- X-WING（ML-KEM-768 と X25519 のハイブリッド）
HKDF-SHA256 鍵導出関数（KDF）
AES-256-GCM アルゴリズムを使用した関連データを伴う認証付き暗号化（AEAD）

鍵を準備する

鍵のアルゴリズムと長さがサポートされていることを確認します。鍵のすべてのバージョンで、同じ保護レベル（SOFTWARE）を使用する必要があります。

ターゲットキーとキーリングを作成する

鍵マテリアルをインポートすると、既存の鍵の新しい鍵バージョンになります。この鍵はターゲットキーと呼ばれます。鍵マテリアルをインポートする前に、ターゲットキーリングとターゲットキーが存在している必要があります。

Google Cloud CLI またはコンソールを使用して、新しいキーリングに空のソフトウェアバックアップ鍵を作成する手順は次のとおりです。 Google Cloud CLI または Google Cloud

コンソール

コンソール Google Cloud で、 [**鍵管理**] ページに移動します。

Key Management に移動
[キーリングを作成] をクリックします。
[キーリング名] フィールドに、キーリングの名前を入力します。
[ロケーションタイプ] で、ロケーションタイプとロケーションを選択します。
[作成] をクリックします。[鍵の作成] ページが開きます。
[鍵名] フィールドに、鍵の名前を入力します。
[**保護レベル**] で、[**ソフトウェア**] を選択します。
[**鍵マテリアル**] で [**インポートした鍵**] を選択し、[**続行**] をクリックします。これにより、初期鍵バージョンが作成されなくなります。
鍵の目的とアルゴリズム を設定し、[続行] をクリックします。
省略可: この鍵にインポートした鍵バージョンのみを含める場合は、[鍵バージョンをインポートのみに制限する] を選択します。これにより、Cloud KMS で誤って新しい鍵バージョンが作成されることが回避されます。
省略可: インポートした鍵の場合、自動ローテーションはデフォルトで無効になっています。自動ローテーションを有効にするには、[鍵のローテーション期間] フィールドで値を選択します。

自動ローテーションを有効にすると、新しい鍵バージョンが Cloud KMS で生成され、インポートした鍵バージョンはローテーション後のデフォルトの鍵バージョンではなくなります。
[作成] をクリックします。

gcloud

コマンドラインで Cloud KMS を使用するには、まず Google Cloud CLI の最新バージョンをインストールまたはアップグレードします。

ターゲットキーリングを作成します。使用する保護レベルと互換性のあるロケーションを選択します。サポートされているロケーションの詳細については、Cloud KMS のロケーションをご覧ください。
```
gcloud kms keyrings create KEY_RING \
  --location LOCATION
```
詳しくは、キーリングを作成をご覧ください。
--skip-initial-version-creation フラグを指定して kms keys create コマンドを使用して、ターゲットキーを作成します。これにより、初期鍵バージョンがない鍵が作成され、インポートした鍵マテリアルがバージョン 1 になります。--import-only フラグを使用すると、Cloud KMS が新しい鍵バージョンの鍵マテリアルを生成しなくなります。このフラグを設定すると、この鍵の新しい鍵バージョンをインポートする必要があります。--import-only として作成された鍵は、手動でローテーションする必要があります。
```
gcloud kms keys create KEY_NAME \
  --location LOCATION \
  --keyring KEY_RING \
  --purpose PURPOSE \
  --protection-level SOFTWARE \
  --skip-initial-version-creation \
  --import-only
```
次のように置き換えます。
- KEY_NAME: 鍵に使用する名前。
- LOCATION: キーリングのロケーション。
- KEY_RING: キーを作成するキーリング。
- PURPOSE：鍵に使用する目的。

API

これらの例では、HTTP クライアントとして curl を使用して API の使用例を示しています。アクセス制御の詳細については、Cloud KMS API へのアクセスをご覧ください。

新しいキーリングを作成します。

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 "{}"

詳しくは、KeyRing.create API ドキュメントをご覧ください。

空のインポート専用鍵を作成します。

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"}}"

詳しくは、CryptoKey.create API ドキュメントをご覧ください。

鍵リングと鍵は存在しますが、この鍵には鍵マテリアルが含まれず、バージョンがなく、アクティブではありません。次に、インポートジョブを作成します。

インポートジョブを作成する

インポートジョブは、インポートした鍵の特性（保護レベルやインポート方法など）を定義します。

耐量子鍵インポートは、SOFTWARE 保護レベルでのみサポートされています。次のいずれかの耐量子インポート方法を選択します。

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

次のコマンドを実行して、耐量子インポート方法でインポートジョブを作成します。

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

次のように置き換えます。

IMPORT_JOB: インポートジョブに使用する一意の名前。
LOCATION: ターゲットキーを作成したキーリングのロケーション。
KEY_RING: ターゲットキーを作成したキーリングの名前。
IMPORT_METHOD: 使用する耐量子インポート方法（hpke-kem-xwing-hkdf-sha256-aes-256-gcm など）。

REST

keyRings.importJobs.create メソッドを呼び出します。

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"}'

次のように置き換えます。

PROJECT_ID: Cloud KMS プロジェクトの ID。
LOCATION: ターゲットキーを作成したキーリングのロケーション。
KEY_RING: ターゲットキーを作成したキーリングの名前。
IMPORT_JOB: インポートジョブに使用する一意の名前。
TOKEN: リクエストを認証するトークン。
IMPORT_METHOD: 使用する耐量子インポート方法（HPKE_KEM_XWING_HKDF_SHA256_AES_256_GCM など）。

インポートジョブの状態を確認する

インポートジョブの初期状態は PENDING_GENERATION です。状態が ACTIVE の場合、それを使用して鍵をインポートできます。

インポートジョブは 3 日後に期限切れになります。インポートジョブが期限切れになった場合は、新しいジョブを作成する必要があります。

インポートジョブの状態は、Google Cloud CLI、the Google Cloud コンソール、または Cloud Key Management Service API を使用して確認できます。

コンソール

コンソール Google Cloud で、[**鍵管理**] ページに移動します。

[鍵管理] ページに移動
インポートジョブが含まれる鍵リングの名前をクリックします。
ページの上部にある [インポートジョブ] タブをクリックします。
状態は、インポートジョブの名前の横にある [ステータス] に表示されます。

gcloud

コマンドラインで Cloud KMS を使用するには、まず Google Cloud CLI の最新バージョンをインストールまたはアップグレードします。

インポートジョブがアクティブな場合は、それを使用して鍵をインポートできます。これには数分かかることがあります。このコマンドを使用して、インポートジョブがアクティブであることを確認します。インポートジョブを作成したロケーションとキーリングを使用します。

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

出力は次のようになります。

state: ACTIVE

Go

このコードを実行するには、まず Go 開発環境を設定し、Cloud KMS Go SDK をインストールします。

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

このコードを実行するには、まず Java 開発環境を設定し、Cloud KMS Java SDK をインストールします。

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

このコードを実行するには、まず Node.js 開発環境を設定し、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

このコードを実行するには、まず Python 開発環境を設定し、Cloud KMS Python SDK をインストールします。

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

インポートジョブの状態を確認するには、 ImportJobs.get メソッドを使用します。

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

インポートジョブがアクティブになるとすぐに、鍵をインポートするリクエストをすることができます。

公開ラッピング鍵を取得する

インポートジョブが ACTIVE になったら、関連付けられている公開鍵を取得します。この公開鍵は、ローカルシステムでインポートする鍵マテリアルをラップするために使用します。

gcloud

次のコマンドを実行して、公開鍵をダウンロードします。

gcloud kms import-jobs describe IMPORT_JOB 

    --location LOCATION 

    --keyring KEY_RING 

    --format="value(publicKey.data)"

次のように置き換えます。

IMPORT_JOB: インポートジョブの名前。
LOCATION: インポートジョブを作成したキーリングのロケーション。
KEY_RING: インポートジョブを作成したキーリングの名前。

公開鍵は Base64 でエンコードされています。

REST

keyRings.importJobs.get メソッドを呼び出します。
レスポンスの publicKey.data フィールドから公開鍵を取得し、public_key.data としてローカルに保存します。

鍵マテリアルを準備してラップする

ローカルシステムでサポートされている外部暗号ライブラリを使用して、取得した公開ラッピング鍵を使用して鍵マテリアルをラップします。

ラッピングプロセスでは、HPKE.Seal()（RFC 9180）を実行して、ラップされた鍵を生成する必要があります。これにより、次の手順が完了します。

取得した公開鍵をカプセル化して、共有シークレットとカプセル化鍵を生成します。
HKDF-SHA256 を使用して、共有シークレットからエフェメラル対称鍵を導出します。
AES-256-GCM を使用して、エフェメラル鍵で鍵マテリアルを暗号化します。
カプセル化鍵と暗号テキストとして暗号化された鍵マテリアルを連結します。これが、鍵のインポートに使用するラップされた鍵です。これを wrapped_key.bin として保存します。

次の Go コードサンプルは、tink-go ライブラリを使用して鍵マテリアルをラップする方法を示しています。

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

出力の Base64 文字列を保存するか、バイナリファイルにデコードします: bash echo "BASE64_WRAPPED_KEY" | base64 --decode > wrapped_key.bin

ラップされた鍵をインポートする

準備したラップされた鍵を、ターゲットキーの新しい鍵バージョンとしてインポートします。

gcloud

kms keys versions import コマンドを実行します。

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

次のように置き換えます。

LOCATION: ターゲットキーを含むキーリングのロケーション。
KEY_RING: ターゲットキーを含むキーリングの名前。
KEY_NAME: ターゲットキーの名前。
IMPORT_JOB: インポートジョブの名前。
ALGORITHM: インポートする鍵マテリアルのアルゴリズム。

REST

cryptoKeyVersions.import メソッドを呼び出します。

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"}'

次のように置き換えます。

PROJECT_ID: Cloud KMS プロジェクトの ID。
LOCATION: ターゲットキーを含むキーリングのロケーション。
KEY_RING: ターゲットキーを含むキーリングの名前。
KEY_NAME: ターゲットキーの名前。
TOKEN: リクエストを認証するトークン。
IMPORT_JOB: 対応するインポートジョブの ID。
ALGORITHM: インポートする鍵マテリアルのアルゴリズム。
PATH_TO_WRAPPED_KEY: Base64 形式の手動でラップされた鍵のパス。

インポートした鍵バージョンの状態を確認する

インポートした鍵バージョンの初期状態は PENDING_IMPORT です。状態が ENABLED の場合、鍵は正常にインポートされています。インポートが失敗する場合、状態は IMPORT_FAILED です。

インポートリクエストの状態は、Google Cloud CLI、 Google Cloud コンソール、または Cloud Key Management Service API を使用して確認できます。

コンソール

[Key Management] ページを Google Cloud コンソールで開きます。
インポートジョブが含まれる鍵リングの名前をクリックします。
ページの上部にある [インポートジョブ] タブをクリックします。
状態は、インポートジョブの名前の横にある [ステータス] に表示されます。

gcloud

コマンドラインで Cloud KMS を使用するには、まず Google Cloud CLI の最新バージョンをインストールまたはアップグレードします。

versions list コマンドを使用して状態を確認します。このトピックの前半で作成したのと同じロケーション、ターゲットキーリング、ターゲットキーを使用します。

gcloud kms keys versions list \
  --keyring KEY_RING \
  --location LOCATION \
  --key KEY_NAME

Go

このコードを実行するには、まず Go 開発環境を設定し、Cloud KMS Go SDK をインストールします。

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

このコードを実行するには、まず Java 開発環境を設定し、Cloud KMS Java SDK をインストールします。

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

このコードを実行するには、まず Node.js 開発環境を設定し、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

このコードを実行するには、まず Python 開発環境を設定し、Cloud KMS Python SDK をインストールします。

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

これらの例では、HTTP クライアントとして curl を使用して API の使用例を示しています。アクセス制御の詳細については、 Cloud KMS API へのアクセスをご覧ください。

ImportJob.get メソッドを呼び出して、 [state][api_importjob_fields_state] フィールドを確認します。state が PENDING_GENERATION の場合、インポートジョブは作成中です。このフィールドが ACTIVE になるまで定期的に状態を確認します。

最初の鍵バージョンをインポートすると、鍵のステータスが ENABLED に変わります。対称鍵を使用する場合は、インポートした鍵バージョンをメインバージョンに設定する必要があります。

以前に破棄した鍵を再インポートする

DESTROYED 状態または IMPORT_FAILED 状態の以前にインポートした鍵バージョンを ENABLED 状態に戻す必要がある場合は、まったく同じ鍵マテリアルを再インポートできます。

破棄された鍵バージョンを再インポートする手順は、元のインポートジョブまたは新しいインポートジョブ（同じ SOFTWARE 保護レベル）を使用して、最初のインポートと同じ手順で行います。

OpenSSL を使用して鍵をラップする

自動鍵ラッピングを設定する

耐量子鍵のインポート コレクションでコンテンツを整理 必要に応じて、コンテンツの保存と分類を行います。

始める前に

プロジェクトを準備する

必要なロール

ローカル システムを準備する

鍵を準備する

ターゲットキーとキーリングを作成する

コンソール

gcloud

API

インポート ジョブを作成する

gcloud

REST

インポート ジョブの状態を確認する

コンソール

gcloud

Go

Java

Node.js

Python

API

公開ラッピング鍵を取得する

gcloud

REST

鍵マテリアルを準備してラップする

ラップされた鍵をインポートする

gcloud

REST

インポートした鍵バージョンの状態を確認する

コンソール

gcloud

Go

Java

Node.js

Python

API

以前に破棄した鍵を再インポートする

耐量子鍵のインポート

ローカルシステムを準備する

インポートジョブを作成する

インポートジョブの状態を確認する