Öffentlichen Schlüssel abrufen

Den öffentlichen Schlüsselabschnitt einer asymmetrischen Schlüsselversion können Sie mit der Google Cloud Console, dem gcloud-Befehlszeilentool und der Cloud Key Management Service API abrufen.

Der öffentliche Schlüssel liegt im PEM-Format (Privacy-enhanced Electronic Mail) vor. Weitere Informationen finden Sie in den Abschnitten General Considerations (Allgemeine Hinweise) und Textual Encoding of Subject Public Key Info (Textcodierung der Informationen zum öffentlichen Schlüssel des Antragstellers) von RFC 7468.

Der Nutzer oder Dienst, der den öffentlichen Schlüssel abruft, benötigt die Berechtigung cloudkms.cryptoKeyVersions.viewPublicKey für die Schlüsselversion. Informationen zu Berechtigungen im Cloud KMS-Betarelease finden Sie unter Berechtigungen und Rollen.

Konsole

So laden Sie den öffentlichen Schlüssel für eine vorhandene asymmetrische Schlüsselversion herunter:

  1. Öffnen Sie in der Cloud Console die Seite Kryptografische Schlüssel.
  2. Klicken Sie auf den Namen des Schlüsselbunds, der den Schlüssel enthält.
  3. Klicken Sie auf den Namen des Schlüssels, der die Schlüsselversion enthält.
  4. Klicken Sie für die Schlüsselversion, deren öffentlichen Schlüssel Sie abrufen möchten, auf das Dreipunkt-Symbol.
  5. Klicken Sie auf Öffentlichen Schlüssel abrufen. Der öffentliche Schlüssel wird angezeigt. Sie können den öffentlichen Schlüssel in die Zwischenablage kopieren oder herunterladen. Wenn die Option Get public key (Öffentlichen Schlüssel abrufen) nicht angezeigt wird, prüfen Sie, ob es sich um einen asymmetrischen Schlüssel handelt und Sie die Berechtigung cloudkms.cryptoKeyVersions.viewPublicKey haben.

    Öffentlicher Schlüssel

Der Dateiname eines öffentlichen Schlüssels, der von der Cloud Console heruntergeladen wurde, hat das Format [key-ring]-[key-name]-[key-version].pub. Die Bestandteile des Dateinamens sind per Bindestrich voneinander getrennt. Aus diesem Grund wird Platzhaltertext von eckigen Klammern ([ und ]) umgeben.

Befehlszeile

gcloud kms keys versions \
  get-public-key key-version \
  --location location \
  --keyring key-ring \
  --key key \
  --output-file key-name.pub

API

Sie können den öffentlichen Schlüssel mithilfe der Methode CryptoKeyVersions.getPublicKey abrufen.

Geben Sie die Ressourcen-ID der Schlüsselversion für den öffentlichen Schlüssel an, den Sie abrufen möchten.

Go

import (
	"context"
	"crypto/x509"
	"encoding/pem"
	"fmt"

	cloudkms "cloud.google.com/go/kms/apiv1"
	kmspb "google.golang.org/genproto/googleapis/cloud/kms/v1"
)

// getAsymmetricPublicKey retrieves the public key from a saved asymmetric key pair on KMS.
func getAsymmetricPublicKey(name string) (interface{}, error) {
	// name: "projects/PROJECT_ID/locations/global/keyRings/RING_ID/cryptoKeys/KEY_ID/cryptoKeyVersions/1"
	ctx := context.Background()
	client, err := cloudkms.NewKeyManagementClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("cloudkms.NewKeyManagementClient: %v", err)
	}

	// Build the request.
	req := &kmspb.GetPublicKeyRequest{
		Name: name,
	}
	// Call the API.
	response, err := client.GetPublicKey(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("GetPublicKey: %v", err)
	}
	// Parse the key.
	keyBytes := []byte(response.Pem)
	block, _ := pem.Decode(keyBytes)
	publicKey, err := x509.ParsePKIXPublicKey(block.Bytes)
	if err != nil {
		return nil, fmt.Errorf("x509.ParsePKIXPublicKey: %v", err)
	}
	return publicKey, nil
}

Java

/**
 * Retrieves the public key from a saved asymmetric key pair on Cloud KMS
 *
 * Example keyName:
 *   "projects/PROJECT_ID/locations/global/keyRings/RING_ID/cryptoKeys/KEY_ID/cryptoKeyVersions/1"
 */
public static PublicKey getAsymmetricPublicKey(String keyName)
    throws IOException, GeneralSecurityException {

  // Create the Cloud KMS client.
  try (KeyManagementServiceClient client = KeyManagementServiceClient.create()) {
    com.google.cloud.kms.v1.PublicKey pub = client.getPublicKey(keyName);

    // Convert a PEM key to DER without taking a dependency on a third party library
    String pemKey = pub.getPem();
    pemKey = pemKey.replaceFirst("-----BEGIN PUBLIC KEY-----", "");
    pemKey = pemKey.replaceFirst("-----END PUBLIC KEY-----", "");
    pemKey = pemKey.replaceAll("\\s", "");
    byte[] derKey = BaseEncoding.base64().decode(pemKey);

    X509EncodedKeySpec keySpec = new X509EncodedKeySpec(derKey);

    if (pub.getAlgorithm().name().contains("RSA")) {
      return KeyFactory.getInstance("RSA").generatePublic(keySpec);
    } else if (pub.getAlgorithm().name().contains("EC")) {
      return KeyFactory.getInstance("EC").generatePublic(keySpec);
    } else {
      throw new UnsupportedOperationException(String.format(
          "key at path '%s' is of unsupported type '%s'.", keyName, pub.getAlgorithm()));
    }
  }
}

Node.js

async function getPublicKey(
  projectId = 'your-project-id', // Your GCP projectId
  keyRingId = 'my-key-ring', // Name of the crypto key's key ring
  cryptoKeyId = 'my-key', // Name of the crypto key, e.g. "my-key"
  cryptoKeyVersionId = '1' // Version of the crypto key to fetch
) {
  // Import the library and create a client
  const kms = require('@google-cloud/kms');
  const client = new kms.KeyManagementServiceClient();

  // The location of the crypto key's key ring, e.g. "global"
  const locationId = 'global';

  // Construct the cyrpto key version ID
  const name = client.cryptoKeyVersionPath(
    projectId,
    locationId,
    keyRingId,
    cryptoKeyId,
    cryptoKeyVersionId
  );

  // Get public key from Cloud KMS
  const [publicKey] = await client.getPublicKey({name: name});

  // Return the public key pem
  return publicKey.pem;
}

Python

def get_asymmetric_public_key(key_name):
    """
    Retrieves the public key from a saved asymmetric key pair on Cloud KMS

    Example key_name:
      "projects/PROJECT_ID/locations/global/keyRings/RING_ID/cryptoKeys\
              /KEY_ID/cryptoKeyVersions/1"

    Requires:
      cryptography.hazmat.backends.default_backend
      cryptography.hazmat.primitives.serialization
    """

    client = kms_v1.KeyManagementServiceClient()
    response = client.get_public_key(key_name)

    key_txt = response.pem.encode('ascii')
    key = serialization.load_pem_public_key(key_txt, default_backend())
    return key