Cloud KMS로 키 버전 가져오기

이 주제에서는 암호화 키를 새 키 버전으로 Cloud HSM 또는 Cloud Key Management Service에 가져오는 방법을 보여줍니다.

한도 및 제한사항을 비롯한 키 가져오기에 대한 자세한 내용은 키 가져오기를 참고하세요.

시작하기 전에 단계를 제외한 5~10 분 후에 이 주제의 단계를 완료할 수 있습니다. 키를 수동으로 래핑하면 작업이 복잡해집니다.

시작하기 전에

새 프로젝트를 만들어 테스트 후 정리를 쉽게 하고 키를 가져올 적절한 Identity and Access Management(IAM) 권한이 있는지 확인하기 위해 이 기능을 테스트하는 것이 좋습니다.

키를 가져오기 전에 프로젝트, 로컬 시스템, 키 자체를 준비해야 합니다.

프로젝트 준비

Google Cloud 계정에 로그인합니다. Google Cloud를 처음 사용하는 경우 계정을 만들고 Google 제품의 실제 성능을 평가해 보세요. 신규 고객에게는 워크로드를 실행, 테스트, 배포하는 데 사용할 수 있는 $300의 무료 크레딧이 제공됩니다.

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

Go to project selector

Google Cloud 프로젝트에 결제가 사용 설정되어 있는지 확인합니다.

Enable the required API.

Enable the API

Install the Google Cloud CLI.

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.

Go to project selector

Google Cloud 프로젝트에 결제가 사용 설정되어 있는지 확인합니다.

Enable the required API.

Enable the API

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

가져오기를 수행하는 사용자는 키링, 키, 가져오기 작업을 만들 수 있는 다음 IAM 권한이 필요합니다. 사용자가 프로젝트 소유자가 아닌 경우 두 가지 사전 정의된 역할 중 모두를 사용자에게 할당할 수 있습니다.
- roles/editor
- roles/cloudkms.importer
Cloud KMS에서 사용할 수 있는 IAM 역할 및 권한에 대한 자세한 내용은 권한 및 역할을 참조하세요.

로컬 시스템 준비

다음 옵션 중 하나를 선택하여 로컬 시스템을 준비합니다. 자동 키 래핑은 대부분의 사용자에게 권장됩니다.

키를 Google Cloud로 전송하기 전에 Google Cloud CLI가 자동으로 래핑하도록 허용하려면 로컬 시스템에 Pyca 암호화 라이브러리를 설치해야 합니다. Pyca 라이브러리는 Google Cloud로 보내기 전에 키를 래핑하고 보호하는 가져오기 작업에서 사용됩니다.
키를 수동으로 래핑하려면 수동 키 래핑을 위해 OpenSSL을 구성해야 합니다.

키 준비

키의 알고리즘 및 길이가 지원되는지 확인합니다. 키에 허용되는 알고리즘은 키가 대칭적 암호화, 비대칭 암호화, 비대칭 서명에 사용되는지 여부와 키가 소프트웨어 또는 HSM에 저장되는지 여부에 따라 다릅니다. 가져오기 요청의 일부로 키의 알고리즘을 지정합니다.

별개로 키가 인코딩되는 방식을 확인하고, 필요한 경우 조정해야 합니다.

만들거나 가져온 키 버전에서 다음을 변경할 수 없습니다.

보호 수준은 키가 소프트웨어, HSM, 외부 키 관리 시스템에 유지되는지 여부를 나타냅니다. 이러한 스토리지 환경 중 하나에서 다른 스토리지 환경으로 키 자료를 이동할 수 없습니다. 키의 모든 버전은 동일한 보호 수준을 갖습니다.
용도는 키 버전이 대칭 암호화, 비대칭 암호화 또는 비대칭 서명에 사용되는지 여부를 나타냅니다. 키의 용도에 따라 해당 키의 버전을 만드는 데 사용할 수 있는 가능한 알고리즘이 제한됩니다. 키의 모든 버전은 동일한 용도를 갖습니다.

가져올 키가 없지만 키 가져오기 절차를 확인하려면 다음 명령어를 사용하여 로컬 시스템에서 대칭 키를 만들 수 있습니다.

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

이 키는 테스트에만 사용하세요. 이 방법으로 만든 키는 프로덕션 용도에 적합하지 않을 수 있습니다.

수동으로 키를 래핑해야 하는 경우, 이 주제의 절차를 계속 진행하기 전에 래핑합니다.

대상 키 및 키링 만들기

Cloud KMS 키는 키 버전이 0개 이상 포함된 컨테이너 객체입니다. 각 키 버전에는 암호화 키가 포함되어 있습니다.

Cloud KMS 또는 Cloud HSM으로 키를 가져올 때 가져온 키는 기존 Cloud KMS 또는 Cloud HSM 키의 새 키 버전이 됩니다. 이 주제의 나머지 부분에서는 이 키를 대상 키라고 합니다. 키 자료를 가져오려면 먼저 대상 키가 있어야 합니다.

키 버전을 가져오는 것은 해당 키의 기존 버전에 영향을 미치지 않습니다. 그러나 키 가져오기를 테스트할 때는 비어 있는 키를 만드는 것이 좋습니다. 비어 있는 키는 버전이 없고 활성화되지 않았으며 사용할 수 없습니다.

새로 만든 키에 가져온 버전만 포함되도록 지정하여 Cloud KMS에서 실수로 새 버전을 생성하는 것을 방지할 수 있습니다.

키링에 키가 있습니다. 이 주제에서는 이 키링을 대상 키링이라고 합니다. 대상 키링의 위치는 가져오기 후 키 자료를 사용할 수 있는 위치를 결정합니다. 일부 위치에서는 Cloud HSM 키를 만들거나 가져올 수 없습니다. 키를 만든 후에는 다른 키링 또는 위치로 이동할 수 없습니다.

다음 단계에 따라 Google Cloud CLI 또는 Google Cloud Console을 사용하여 새 키 링에 빈 키를 만듭니다.

콘솔

Google Cloud 콘솔에서 키 관리 페이지로 이동합니다.

키 관리로 이동
키링 만들기를 클릭합니다.
키링 이름 필드에 키링의 이름을 입력합니다.
위치 유형에서 위치 유형과 위치를 선택합니다.
만들기를 클릭합니다. 키 만들기 페이지가 열립니다.
키 이름 필드에 키의 이름을 입력합니다.
보호 수준에서 소프트웨어 또는 HSM을 선택한 후 계속을 클릭합니다.
키 자료에서 가져온 키를 선택한 후 계속을 클릭합니다. 이렇게 하면 초기 키 버전이 생성되지 않습니다.
키의 용도와 알고리즘을 설정한 후 계속을 클릭합니다.
선택사항: 이 키에 가져온 키 버전만 포함하려면 키 버전을 가져오기만 하도록 제한을 선택합니다. 이렇게 하면 Cloud KMS에서 실수로 새 키 버전을 만드는 것을 방지할 수 있습니다.
선택사항: 가져온 키의 경우 기본적으로 자동 순환이 중지됩니다. 자동 순환을 사용 설정하려면 키 순환 기간 필드에서 값을 선택합니다.

자동 순환을 사용 설정하면 Cloud KMS에 새로운 키 버전이 생성되고 순환 후 가져온 키 버전은 더 이상 기본 키 버전이 되지 않습니다.
만들기를 클릭합니다.

gcloud

명령줄에서 Cloud KMS를 사용하려면 먼저 최신 버전의 Google Cloud CLI로 설치 또는 업그레이드하세요.

대상 키링을 만듭니다. Cloud HSM 키로 가져오려면 Cloud HSM을 지원하는 위치를 선택합니다.
```
gcloud kms keyrings create KEY_RING \
  --location LOCATION
```
키링을 만드는 방법에 대해 자세히 알아보세요.
대상 키를 만듭니다.
- 키의 용도를 지정합니다.
- --skip-initial-version-creation 플래그를 사용하여 초기 버전이 생성되지 않도록 합니다.
- 선택사항: --import-only 플래그를 사용하여 Cloud KMS에서 새 버전이 생성되지 않도록 합니다.
- 선택사항: 순환 정책을 지정하지 마세요. 자동 순환을 사용 설정하면 Cloud KMS에 새로운 키 버전이 생성되고 순환 후 가져온 키 버전은 더 이상 기본 키 버전이 되지 않습니다. --import-only 플래그를 지정한 경우 순환 정책을 지정할 수 없습니다.
```
gcloud kms keys create KEY_NAME \
  --location LOCATION \
  --keyring KEY_RING \
  --purpose PURPOSE \
  --skip-initial-version-creation \
  --import-only
```
Cloud KMS 키 또는 Cloud HSM 키 생성에 대해 자세히 알아보세요.

Go

이 코드를 실행하려면 먼저 Go 개발 환경을 설정하고 Cloud KMS Go SDK를 설치합니다.

import (
	"context"
	"fmt"
	"io"

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

// createKeyForImport creates a new asymmetric signing key in Cloud HSM.
func createKeyForImport(w io.Writer, parent, id string) error {
	// parent := "projects/my-project/locations/us-east1/keyRings/my-key-ring"
	// id := "my-imported-key"

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

	// Build the request.
	req := &kmspb.CreateCryptoKeyRequest{
		Parent:      parent,
		CryptoKeyId: id,
		CryptoKey: &kmspb.CryptoKey{
			Purpose: kmspb.CryptoKey_ASYMMETRIC_SIGN,
			VersionTemplate: &kmspb.CryptoKeyVersionTemplate{
				ProtectionLevel: kmspb.ProtectionLevel_HSM,
				Algorithm:       kmspb.CryptoKeyVersion_EC_SIGN_P256_SHA256,
			},
			// Ensure that only imported versions may be added to this key.
			ImportOnly: true,
		},
		SkipInitialVersionCreation: true,
	}

	// Call the API.
	result, err := client.CreateCryptoKey(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to create key: %w", err)
	}
	fmt.Fprintf(w, "Created key: %s\n", result.Name)
	return nil
}

Java

이 코드를 실행하려면 먼저 자바 개발 환경을 설정하고 Cloud KMS 자바 SDK를 설치합니다.

import com.google.cloud.kms.v1.CreateCryptoKeyRequest;
import com.google.cloud.kms.v1.CryptoKey;
import com.google.cloud.kms.v1.CryptoKey.CryptoKeyPurpose;
import com.google.cloud.kms.v1.CryptoKeyVersion.CryptoKeyVersionAlgorithm;
import com.google.cloud.kms.v1.CryptoKeyVersionTemplate;
import com.google.cloud.kms.v1.KeyManagementServiceClient;
import com.google.cloud.kms.v1.KeyRingName;
import com.google.cloud.kms.v1.ProtectionLevel;
import java.io.IOException;

public class CreateKeyForImport {

  public void createKeyForImport() 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 id = "my-import-key";
    createKeyForImport(projectId, locationId, keyRingId, id);
  }

  // Create a new crypto key to hold imported key versions.
  public void createKeyForImport(String projectId, String locationId, String keyRingId, String id)
      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.
      KeyRingName keyRingName = KeyRingName.of(projectId, locationId, keyRingId);

      // Create the crypto key.
      CryptoKey createdKey =
          client.createCryptoKey(
              CreateCryptoKeyRequest.newBuilder()
                  .setParent(keyRingName.toString())
                  .setCryptoKeyId(id)
                  .setCryptoKey(
                      CryptoKey.newBuilder()
                          .setPurpose(CryptoKeyPurpose.ASYMMETRIC_SIGN)
                          .setVersionTemplate(
                              CryptoKeyVersionTemplate.newBuilder()
                                  .setProtectionLevel(ProtectionLevel.HSM)
                                  .setAlgorithm(CryptoKeyVersionAlgorithm.EC_SIGN_P256_SHA256))
                          // Ensure that only imported versions may be
                          // added to this key.
                          .setImportOnly(true))
                  .setSkipInitialVersionCreation(true)
                  .build());

      System.out.printf("Created crypto key %s%n", createdKey.getName());
    }
  }
}

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 id = 'my-imported-key';

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

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

// Build the parent key ring name
const keyRingName = client.keyRingPath(projectId, locationId, keyRingId);

async function createKeyForImport() {
  const [key] = await client.createCryptoKey({
    parent: keyRingName,
    cryptoKeyId: id,
    cryptoKey: {
      purpose: 'ENCRYPT_DECRYPT',
      versionTemplate: {
        algorithm: 'GOOGLE_SYMMETRIC_ENCRYPTION',
        protectionLevel: 'HSM',
      },
      // Optional: ensure that only imported versions may be added to this
      // key.
      importOnly: true,
    },
    // Do not allow KMS to generate an initial version of this key.
    skipInitialVersionCreation: true,
  });

  console.log(`Created key for import: ${key.name}`);
  return key;
}

return createKeyForImport();

Python

이 코드를 실행하려면 먼저 Python 개발 환경을 설정하고 Cloud KMS Python SDK를 설치합니다.

from google.cloud import kms


def create_key_for_import(
    project_id: str, location_id: str, key_ring_id: str, crypto_key_id: str
) -> None:
    """

    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').
    """

    # 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,
            # Do not allow KMS to generate an initial version of this key.
            "skip_initial_version_creation": True,
        }
    )
    print(f"Created hsm key: {created_key.name}")

API

이 예시에서는 curl을 HTTP 클라이언트로 사용하여 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 "{}"

자세한 내용은 API 문서KeyRing.create를 참조하세요.

가져오기 전용 빈 키를 만듭니다.

curl "https://cloudkms.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys?cryptoKeyId=KEY_NAME&skipInitialVersionCreation=true&importOnly=true" \
    --request "POST" \
    --header "authorization: Bearer TOKEN" \
    --header "content-type: application/json" \
    --header "x-goog-user-project: PROJECT_ID" \
    --data "{"purpose":"PURPOSE", "versionTemplate":{"protectionLevel":"PROTECTION_LEVEL","algorithm":"ALGORITHM"}}"

자세한 내용은 API 문서CryptoKey.create를 참조하세요.

이제 키링과 키가 있지만 키에 키 자료와 버전이 없고 활성 상태가 아닙니다. 다음으로 가져오기 작업을 만듭니다.

가져오기 작업 만들기

가져오기 작업은 키를 가져온 후 변경할 수 없는 속성을 포함하여 가져오는 키의 특성을 정의합니다.

보호 수준은 이 가져오기 작업으로 가져온 키가 소프트웨어, HSM 또는 외부 키 관리 시스템에 상주할지 여부를 정의합니다. 키를 최종적으로 가져온 후에는 보호 수준을 변경할 수 없습니다.

가져오기 메서드는 로컬 시스템에서 대상 Google Cloud 프로젝트로 전송되는 동안 가져온 키를 보호하는 래핑 키를 만드는 데 사용되는 알고리즘을 정의합니다. 3072비트 또는 4096비트 RSA 키를 선택할 수 있습니다. 구체적인 요구사항이 없으면 3072 비트 래핑 키를 사용하는 것이 좋습니다.

gcloud CLI, Google Cloud Console 또는 Cloud Key Management Service API를 사용하여 가져오기 작업을 만들 수 있습니다.

Console

Google Cloud 콘솔에서 키 관리 페이지로 이동합니다.

키 관리 페이지로 이동
대상 키링의 이름을 클릭합니다.
보호 수준을 소프트웨어 또는 HSM으로 설정합니다. 대상 키에 설정한 것과 동일한 보호 수준을 사용합니다.
가져오기 작업 만들기를 클릭합니다.
이름 필드에 가져오기 작업 이름을 입력합니다.
가져오기 메서드 드롭다운에서 가져오기 메서드를 3072비트 RSA 또는 4096비트 RSA로 설정합니다.
만들기를 클릭합니다.

gcloud

명령줄에서 Cloud KMS를 사용하려면 먼저 최신 버전의 Google Cloud CLI로 설치 또는 업그레이드하세요.

가져오기 작업을 만들려면 다음과 같은 명령어를 사용합니다.

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

대상 키와 동일한 키링과 위치를 사용합니다.
보호 수준을 software 또는 hsm 중 하나로 설정합니다.
가져오기 방법을 rsa-oaep-3072-sha1-aes-256, rsa-oaep-4096-sha1-aes-256, rsa-oaep-3072-sha256-aes-256, rsa-oaep-4096-sha256-aes-256, rsa-oaep-3072-sha256, rsa-oaep-4096-sha256 중 하나로 설정합니다.

Go

이 코드를 실행하려면 먼저 Go 개발 환경을 설정하고 Cloud KMS Go SDK를 설치합니다.

import (
	"context"
	"fmt"
	"io"

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

// createImportJob creates a new job for importing keys into KMS.
func createImportJob(w io.Writer, parent, id string) error {
	// parent := "projects/PROJECT_ID/locations/global/keyRings/my-key-ring"
	// id := "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()

	// Build the request.
	req := &kmspb.CreateImportJobRequest{
		Parent:      parent,
		ImportJobId: id,
		ImportJob: &kmspb.ImportJob{
			// See allowed values and their descriptions at
			// https://cloud.google.com/kms/docs/algorithms#protection_levels
			ProtectionLevel: kmspb.ProtectionLevel_HSM,
			// See allowed values and their descriptions at
			// https://cloud.google.com/kms/docs/key-wrapping#import_methods
			ImportMethod: kmspb.ImportJob_RSA_OAEP_3072_SHA1_AES_256,
		},
	}

	// Call the API.
	result, err := client.CreateImportJob(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to create import job: %w", err)
	}
	fmt.Fprintf(w, "Created import job: %s\n", result.Name)
	return nil
}

Java

이 코드를 실행하려면 먼저 자바 개발 환경을 설정하고 Cloud KMS 자바 SDK를 설치합니다.

import com.google.cloud.kms.v1.ImportJob;
import com.google.cloud.kms.v1.ImportJob.ImportMethod;
import com.google.cloud.kms.v1.KeyManagementServiceClient;
import com.google.cloud.kms.v1.KeyRingName;
import com.google.cloud.kms.v1.ProtectionLevel;
import java.io.IOException;

public class CreateImportJob {

  public void createImportJob() 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 id = "my-import-job";
    createImportJob(projectId, locationId, keyRingId, id);
  }

  // Create a new import job.
  public void createImportJob(String projectId, String locationId, String keyRingId, String id)
      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.
      KeyRingName keyRingName = KeyRingName.of(projectId, locationId, keyRingId);

      // Build the import job to create, with parameters.
      ImportJob importJob =
          ImportJob.newBuilder()
              // See allowed values and their descriptions at
              // https://cloud.google.com/kms/docs/algorithms#protection_levels
              .setProtectionLevel(ProtectionLevel.HSM)
              // See allowed values and their descriptions at
              // https://cloud.google.com/kms/docs/key-wrapping#import_methods
              .setImportMethod(ImportMethod.RSA_OAEP_3072_SHA1_AES_256)
              .build();

      // Create the import job.
      ImportJob createdImportJob = client.createImportJob(keyRingName, id, importJob);
      System.out.printf("Created import job %s%n", createdImportJob.getName());
    }
  }
}

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 id = 'my-import-job';

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

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

// Build the parent key ring name
const keyRingName = client.keyRingPath(projectId, locationId, keyRingId);

async function createImportJob() {
  const [importJob] = await client.createImportJob({
    parent: keyRingName,
    importJobId: id,
    importJob: {
      protectionLevel: 'HSM',
      importMethod: 'RSA_OAEP_3072_SHA256',
    },
  });

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

return createImportJob();

Python

이 코드를 실행하려면 먼저 Python 개발 환경을 설정하고 Cloud KMS Python SDK를 설치합니다.

from google.cloud import kms


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

    # 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(f"Created import job: {import_job.name}")

API

이 예시에서는 curl을 HTTP 클라이언트로 사용하여 API 사용을 보여줍니다. 액세스 제어에 대한 자세한 내용은 Cloud KMS API 액세스를 참조하세요.

가져오기 작업을 만들려면 ImportJobs.create 메서드를 사용합니다.

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

다음을 바꿉니다.

IMPORT_METHOD: 지원되는 키 래핑 메서드입니다.
PROTECTION_LEVEL: 이 가져오기 작업에서 가져온 키 버전의 보호 수준입니다.

가져오기 작업의 상태 확인

가져오기 작업의 초기 상태는 PENDING_GENERATION입니다. 상태가 ACTIVE이면 이를 사용하여 키를 가져올 수 있습니다.

가져오기 작업은 3일 후에 만료됩니다. 가져오기 작업이 만료된 경우 새 작업을 만들어야 합니다.

Google Cloud CLI, Google Cloud Console, Cloud Key Management Service API를 사용하여 가져오기 작업의 상태를 확인할 수 있습니다.

Console

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

이 코드를 실행하려면 먼저 자바 개발 환경을 설정하고 Cloud KMS 자바 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

이 예시에서는 curl을 HTTP 클라이언트로 사용하여 API 사용을 보여줍니다. 액세스 제어에 대한 자세한 내용은 Cloud KMS 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"

가져오기 작업이 활성화되는 즉시 키 가져오기 요청을 할 수 있습니다.

가져오기 작업 수정 방지

가져오기 작업은 키 알고리즘과 가져온 키가 HSM 키인지 소프트웨어 키인지 여부를 비롯하여 가져온 키의 여러 특성을 결정합니다. IAM 권한을 구성하여 사용자가 가져오기 작업을 생성하지 못하도록 하고 가져오기 작업을 사용하여 키를 가져올 수 있도록 허용할 수 있습니다.

키 관리자에게만 importjobs.create 권한을 부여합니다.
이 작업을 사용하여 키를 가져올 운영자에게 특정 가져오기 작업의 importjobs.useToImport 권한을 부여합니다.
가져오기 작업을 만들 때 이를 사용하여 가져오는 키 버전의 보호 수준과 알고리즘을 지정합니다.

가져오기 작업이 만료될 때까지 해당 가져오기 작업에 대한 importjobs.useToImport는 있지만 importjobs.create 권한이 없는 사용자는 키를 가져올 수는 있지만 가져오기 작업의 특성을 수정할 수 없습니다.

키 가져오기

가져오기 작업의 상태를 확인한 후 가져오기를 요청할 수 있습니다.

Google Cloud CLI에서 키를 자동으로 래핑할지 또는 이미 키를 수동으로 래핑했는지 여부에 따라 다른 플래그를 사용하여 가져오기를 요청합니다.

키를 수동 또는 자동으로 래핑했는지 여부에 관계없이 알고리즘을 가져올 실제 키의 길이와 일치하는 지원되는 알고리즘으로 설정하고 키의 목적을 지정합니다.

용도가 ENCRYPT_DECRYPT인 키는 google-symmetric-encryption 알고리즘을 사용하며 길이는 32입니다.
용도가 ASYMMETRIC_DECRYPT 또는 ASYMMETRIC_SIGN인 키는 다양한 알고리즘과 길이를 지원합니다.

키를 만든 후에는 키의 용도를 변경할 수 없지만 후속 키 버전은 초기 키 버전과 다른 길이로 만들 수 있습니다.

자동으로 키 래핑 및 가져오기

자동 래핑을 사용하려면 Google Cloud CLI를 사용해야 합니다. 다음과 같은 명령어를 사용합니다. --target-key-file을 래핑하고 가져오려는 래핑 해제된 키의 위치로 설정합니다. --wrapped-key-file은 설정하지 마세요.

선택적으로 --public-key-file 플래그를 공개 키가 이미 다운로드된 위치로 설정할 수 있습니다. 이렇게 하면 많은 키를 가져올 때 각 가져오기 중에 공개 키가 다운로드되지 않습니다. 예를 들어 공개 키를 한 번 다운로드한 다음 각 키를 가져올 때 위치를 제공한 스크립트를 작성할 수 있습니다.

gcloud kms keys versions import \
    --import-job IMPORT_JOB \
    --location LOCATION \
    --keyring KEY_RING \
    --key KEY_NAME \
    --algorithm ALGORITHM \
    --target-key-file PATH_TO_UNWRAPPED_KEY

키는 가져오기 작업과 연결된 래핑 키로 래핑되고 Google Cloud로 전송되고 대상 키에서 새 키 버전으로 가져옵니다.

수동으로 래핑된 키 가져오기

이 섹션의 안내에 따라 수동으로 래핑한 키를 가져옵니다. --wrapped-key-file을 수동으로 래핑한 키의 위치로 설정합니다. --target-key-file을 설정하지 마세요.

Console

Google Cloud Console에서 키 관리 페이지를 엽니다.
가져오기 작업이 있는 키링의 이름을 클릭합니다. 대상 키가 키링의 다른 키와 함께 표시됩니다.
대상 키의 이름을 클릭한 다음 키 버전 가져오기를 클릭합니다.
가져오기 작업 선택 드롭다운에서 가져오기 작업을 선택합니다.
래핑된 키 업로드 선택기에서 이미 래핑된 키를 선택합니다.
비대칭 키를 가져올 경우 알고리즘 드롭다운에서 알고리즘을 선택합니다. 키 버전 가져오기 페이지가 다음과 비슷하게 표시됩니다.
가져오기를 클릭합니다.

gcloud

명령줄에서 Cloud KMS를 사용하려면 먼저 최신 버전의 Google Cloud CLI로 설치 또는 업그레이드하세요.

다음과 같은 명령어를 사용합니다.

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

자세한 내용은 gcloud kms keys versions import --help 명령어의 출력을 참조하세요.

Go

이 코드를 실행하려면 먼저 Go 개발 환경을 설정하고 Cloud KMS Go SDK를 설치합니다.

import (
	"context"
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha1"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"io"

	kms "cloud.google.com/go/kms/apiv1"
	"cloud.google.com/go/kms/apiv1/kmspb"
	"github.com/google/tink/go/kwp/subtle"
)

// importManuallyWrappedKey wraps key material and imports it into KMS.
func importManuallyWrappedKey(w io.Writer, importJobName, cryptoKeyName string) error {
	// importJobName := "projects/PROJECT_ID/locations/global/keyRings/my-key-ring/importJobs/my-import-job"
	// cryptoKeyName := "projects/PROJECT_ID/locations/global/keyRings/my-key-ring/cryptoKeys/my-imported-key"

	// Generate a ECDSA keypair, and format the private key as PKCS #8 DER.
	key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	if err != nil {
		return fmt.Errorf("failed to generate keypair: %w", err)
	}
	keyBytes, err := x509.MarshalPKCS8PrivateKey(key)
	if err != nil {
		return fmt.Errorf("failed to format private key: %w", err)
	}

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

	// Generate a temporary 32-byte key for AES-KWP and wrap the key material.
	kwpKey := make([]byte, 32)
	if _, err := rand.Read(kwpKey); err != nil {
		return fmt.Errorf("failed to generate AES-KWP key: %w", err)
	}
	kwp, err := subtle.NewKWP(kwpKey)
	if err != nil {
		return fmt.Errorf("failed to create KWP cipher: %w", err)
	}
	wrappedTarget, err := kwp.Wrap(keyBytes)
	if err != nil {
		return fmt.Errorf("failed to wrap target key with KWP: %w", err)
	}

	// Retrieve the public key from the import job.
	importJob, err := client.GetImportJob(ctx, &kmspb.GetImportJobRequest{
		Name: importJobName,
	})
	if err != nil {
		return fmt.Errorf("failed to retrieve import job: %w", err)
	}
	pubBlock, _ := pem.Decode([]byte(importJob.PublicKey.Pem))
	pubAny, err := x509.ParsePKIXPublicKey(pubBlock.Bytes)
	if err != nil {
		return fmt.Errorf("failed to parse import job public key: %w", err)
	}
	pub, ok := pubAny.(*rsa.PublicKey)
	if !ok {
		return fmt.Errorf("unexpected public key type %T, want *rsa.PublicKey", pubAny)
	}

	// Wrap the KWP key using the import job key.
	wrappedWrappingKey, err := rsa.EncryptOAEP(sha1.New(), rand.Reader, pub, kwpKey, nil)
	if err != nil {
		return fmt.Errorf("failed to wrap KWP key: %w", err)
	}

	// Concatenate the wrapped KWP key and the wrapped target key.
	combined := append(wrappedWrappingKey, wrappedTarget...)

	// Build the request.
	req := &kmspb.ImportCryptoKeyVersionRequest{
		Parent:     cryptoKeyName,
		ImportJob:  importJobName,
		Algorithm:  kmspb.CryptoKeyVersion_EC_SIGN_P256_SHA256,
		WrappedKey: combined,
	}

	// Call the API.
	result, err := client.ImportCryptoKeyVersion(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to import crypto key version: %w", err)
	}
	fmt.Fprintf(w, "Created crypto key version: %s\n", result.Name)
	return nil
}

Java

이 코드를 실행하려면 먼저 자바 개발 환경을 설정하고 Cloud KMS 자바 SDK를 설치합니다.

import com.google.cloud.kms.v1.CryptoKeyName;
import com.google.cloud.kms.v1.CryptoKeyVersion;
import com.google.cloud.kms.v1.ImportCryptoKeyVersionRequest;
import com.google.cloud.kms.v1.ImportJob;
import com.google.cloud.kms.v1.ImportJobName;
import com.google.cloud.kms.v1.KeyManagementServiceClient;
import com.google.crypto.tink.subtle.Kwp;
import com.google.protobuf.ByteString;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.spec.ECGenParameterSpec;
import java.security.spec.MGF1ParameterSpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import javax.crypto.Cipher;
import javax.crypto.spec.OAEPParameterSpec;
import javax.crypto.spec.PSource;

public class ImportManuallyWrappedKey {

  public void importManuallyWrappedKey() throws GeneralSecurityException, 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 importJobId = "my-import-job";
    importManuallyWrappedKey(projectId, locationId, keyRingId, cryptoKeyId, importJobId);
  }

  // Generates and imports local key material into Cloud KMS.
  public void importManuallyWrappedKey(
      String projectId, String locationId, String keyRingId, String cryptoKeyId, String importJobId)
      throws GeneralSecurityException, IOException {

    // Generate a new ECDSA keypair, and format the private key as PKCS #8 DER.
    KeyPairGenerator generator = KeyPairGenerator.getInstance("EC");
    generator.initialize(new ECGenParameterSpec("secp256r1"));
    KeyPair kp = generator.generateKeyPair();
    byte[] privateBytes = kp.getPrivate().getEncoded();

    // 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 crypto key and import job names from the project, location,
      // key ring, and ID.
      final CryptoKeyName cryptoKeyName =
          CryptoKeyName.of(projectId, locationId, keyRingId, cryptoKeyId);
      final ImportJobName importJobName =
          ImportJobName.of(projectId, locationId, keyRingId, importJobId);

      // Generate a temporary 32-byte key for AES-KWP and wrap the key material.
      byte[] kwpKey = new byte[32];
      new SecureRandom().nextBytes(kwpKey);
      Kwp kwp = new Kwp(kwpKey);
      final byte[] wrappedTargetKey = kwp.wrap(privateBytes);

      // Retrieve the public key from the import job.
      ImportJob importJob = client.getImportJob(importJobName);
      String publicKeyStr = importJob.getPublicKey().getPem();
      // Manually convert PEM to DER. :-(
      publicKeyStr = publicKeyStr.replace("-----BEGIN PUBLIC KEY-----", "");
      publicKeyStr = publicKeyStr.replace("-----END PUBLIC KEY-----", "");
      publicKeyStr = publicKeyStr.replaceAll("\n", "");
      byte[] publicKeyBytes = Base64.getDecoder().decode(publicKeyStr);
      PublicKey publicKey =
          KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(publicKeyBytes));

      // Wrap the KWP key using the import job key.
      Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-1AndMGF1Padding");
      cipher.init(
          Cipher.ENCRYPT_MODE,
          publicKey,
          new OAEPParameterSpec(
              "SHA-1", "MGF1", MGF1ParameterSpec.SHA1, PSource.PSpecified.DEFAULT));
      byte[] wrappedWrappingKey = cipher.doFinal(kwpKey);

      // Concatenate the wrapped KWP key and the wrapped target key.
      ByteString combinedWrappedKeys =
          ByteString.copyFrom(wrappedWrappingKey).concat(ByteString.copyFrom(wrappedTargetKey));

      // Import the wrapped key material.
      CryptoKeyVersion version =
          client.importCryptoKeyVersion(
              ImportCryptoKeyVersionRequest.newBuilder()
                  .setParent(cryptoKeyName.toString())
                  .setImportJob(importJobName.toString())
                  .setAlgorithm(CryptoKeyVersion.CryptoKeyVersionAlgorithm.EC_SIGN_P256_SHA256)
                  .setRsaAesWrappedKey(combinedWrappedKeys)
                  .build());

      System.out.printf("Imported: %s%n", version.getName());
    }
  }
}

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 importJobId = 'my-import-job';

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

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

// Build the crypto key and importjob resource names
const cryptoKeyName = client.cryptoKeyPath(
  projectId,
  locationId,
  keyRingId,
  cryptoKeyId
);
const importJobName = client.importJobPath(
  projectId,
  locationId,
  keyRingId,
  importJobId
);

async function wrapAndImportKey() {
  // Generate a 32-byte key to import.
  const crypto = require('crypto');
  const targetKey = crypto.randomBytes(32);

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

  // Wrap the target key using the import job key
  const wrappedTargetKey = crypto.publicEncrypt(
    {
      key: importJob.publicKey.pem,
      oaepHash: 'sha256',
      padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
    },
    targetKey
  );

  // Import the target key version
  const [version] = await client.importCryptoKeyVersion({
    parent: cryptoKeyName,
    importJob: importJobName,
    algorithm: 'GOOGLE_SYMMETRIC_ENCRYPTION',
    wrappedKey: wrappedTargetKey,
  });

  console.log(`Imported key version: ${version.name}`);
  return version;
}

return wrapAndImportKey();

Python

이 코드를 실행하려면 먼저 Python 개발 환경을 설정하고 Cloud KMS Python SDK를 설치합니다.

import os

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


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

    # 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(f"Generated key bytes: {formatted_key!r}")

    # 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(f"Imported: {import_job.name}")

API

이 예시에서는 curl을 HTTP 클라이언트로 사용하여 API 사용을 보여줍니다. 액세스 제어에 대한 자세한 내용은 Cloud KMS API 액세스를 참조하세요.

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_ID", "algorithm": "ALGORITHM", "wrappedKey": "WRAPPED_KEY"}'

다음을 바꿉니다.

IMPORT_JOB_ID: 해당 가져오기 작업의 전체 리소스 이름
ALGORITHM: 가져올 키의 algorithm(CryptoKeyVersionAlgorithm 유형)
WRAPPED_KEY: base64 형식의 수동으로 래핑된 키

키 가져오기 요청이 시작됩니다. 상태를 모니터링할 수 있습니다.

가져온 키 버전 상태 확인

가져온 키 버전의 초기 상태는 PENDING_IMPORT입니다. 상태가 ENABLED이면 키 버전을 성공적으로 가져온 것입니다. 가져오기에 실패하면 상태는 IMPORT_FAILED입니다.

Google Cloud CLI, Google Cloud Console, Cloud Key Management Service API를 사용하여 가져오기 요청의 상태를 확인할 수 있습니다.

Console

Google Cloud Console에서 키 관리 페이지를 엽니다.
가져오기 작업이 있는 키링의 이름을 클릭합니다.
페이지 상단에 있는 가져오기 작업 탭을 클릭합니다.
상태가 가져오기 작업 이름 옆에 있는 상태 아래에 표시됩니다.

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

이 코드를 실행하려면 먼저 자바 개발 환경을 설정하고 Cloud KMS 자바 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

이 예시에서는 curl을 HTTP 클라이언트로 사용하여 API 사용을 보여줍니다. 액세스 제어에 대한 자세한 내용은 Cloud KMS API 액세스를 참조하세요.

ImportJob.get 메서드를 호출하고 state 필드를 확인합니다. state가 PENDING_GENERATION이면 가져오기 작업이 아직 생성되는 중입니다. ACTIVE가 될 때까지 상태를 주기적으로 다시 확인합니다.

초기 키 버전을 가져오면 키 상태가 활성으로 변경됩니다. 대칭 키의 경우 키를 사용하기 전에 가져온 키 버전을 기본 버전으로 설정해야 합니다.

대칭 키: 기본 버전 설정

이 단계는 대칭 키를 가져올 때 필요하며 비대칭 키와는 관련이 없습니다. 비대칭 키에는 기본 버전이 없습니다. Google Cloud CLI를 사용하여 기본 버전을 설정해야 합니다.

gcloud kms keys set-primary-version KEY_NAME\
    --location=LOCATION\
    --keyring=KEY_RING\
    --version=KEY_VERSION

이전에 폐기된 키 다시 가져오기

Cloud Key Management Service는 원래 키 자료를 제공하여 이전에 가져온 키 버전을 DESTROYED 또는 IMPORT_FAILED 상태에서 ENABLED 상태로 복원할 수 있도록 하는 키 다시 가져오기를 지원합니다. 최초 가져오기 실패로 인해 원본 키 자료를 가져오지 못한 경우 키 자료가 제공될 수 있습니다.

제한사항

이전에 가져온 CryptoKeyVersions만 다시 가져올 수 있습니다.
다시 가져온 키 자료는 이전에 버전을 성공적으로 가져온 경우 원래 키 자료와 정확하게 일치해야 합니다.
이 기능 출시 이전에 폐기된 CryptoKeyVersions는 다시 가져올 수 없습니다. 버전을 다시 가져올 수 있는 경우 CryptoKeyVersion의 reimport_eligible 필드는 true이고, 그렇지 않은 경우 false입니다.

소프트웨어 및 Cloud HSM 키는 다시 가져올 수 있지만 외부 키는 다시 가져올 수 없습니다.

폐기된 키 다시 가져오기

가져오기 작업 만들기의 단계에 따라 다시 가져올 ImportJob을 만듭니다. 보호 수준이 원래 보호 수준과 일치하면 기존 ImportJob 또는 새 ImportJob을 사용할 수 있습니다.

Console

Google Cloud 콘솔에서 키 관리 페이지로 이동합니다.

키 관리 페이지로 이동
키 버전을 다시 가져오려는 키가 포함된 키링의 이름을 클릭합니다.
키 버전을 다시 가져올 키를 클릭합니다.
다시 가져오려는 키 버전 옆의 점 3개를 클릭합니다.
키 버전 다시 가져오기를 선택합니다.
가져오기 작업 선택 드롭다운에서 가져오기 작업을 선택합니다.
래핑된 키 업로드 선택기에서 이미 래핑된 키를 선택합니다. 이 키는 원본 키 자료와 일치해야 합니다.
다시 가져오기를 클릭합니다.

gcloud

명령줄에서 Cloud KMS를 사용하려면 먼저 최신 버전의 Google Cloud CLI로 설치 또는 업그레이드하세요.

원래 키 자료를 사용하여 키 버전을 다시 가져옵니다.

gcloud kms keys versions import \
--location LOCATION \
--keyring KEY_RING \
--key KEY_NAME \
--version KEY_VERSION \
--algorithm ALGORITHM \
--import-job IMPORT_JOB \
--target-key-file PATH_TO_KEY \

API

이 예시에서는 curl을 HTTP 클라이언트로 사용하여 API 사용을 보여줍니다. 액세스 제어에 대한 자세한 내용은 Cloud KMS API 액세스를 참조하세요.

cryptoKeyVersions.import 메서드의 요청 본문에서 cryptoKeyVersion 필드를 가져올 버전의 키 버전 이름으로 설정합니다. 암호화 키의 하위 요소여야 합니다.
요청 본문에서 algorithm 필드를 가져올 키의 알고리즘으로 설정합니다. 이 값은 원본 키 버전의 알고리즘과 일치해야 합니다. algorithm 필드는 CryptoKeyVersionAlgorithm 유형입니다.
요청 본문에서 wrappedKeyMaterial 필드를 이미 래핑한 키 자료로 설정합니다.
cryptoKeyVersions.import 메서드를 호출합니다. cryptoKeyVersions.import 응답은 CryptoKeyVersion 유형입니다. 키를 가져오면 상태가 ENABLED가 되어 Cloud KMS에서 이 키를 사용할 수 있습니다.

다음 단계

가져온 키 확인. 가져온 키 자료가 원본 키와 동일한지 확인한 후 이 키를 사용하여 서명하거나 데이터를 보호할 수 있습니다.
키 가져오기 실패 문제 해결

자동 키 래핑 설정

가져온 키 버전 확인