Schlüssel mit OpenSSL unter Linux verpacken

In diesem Thema erfahren Sie, wie Sie einen Schlüssel manuell verpacken, bevor Sie den Schlüssel in Cloud KMS importieren. Folgen Sie der Anleitung zu diesem Thema nur dann, wenn Sie den Schlüssel nicht vor dem Importieren automatisch mit dem gcloud-Befehlszeilentool verpacken möchten. Eine Übersicht über die Unterschiede finden Sie unter So importieren Sie Schlüssel.

Die in diesem Thema beschriebenen Schritte lassen sich in 5 bis 10 Minuten ausführen. Dabei sind die Schritte unter Vorbereitung nicht berücksichtigt.

Hinweis

Bevor Sie einen Schlüssel verpacken können, müssen Sie die folgenden Voraussetzungen erfüllen.

1. Erstellen Sie einen Zielschlüsselring und -schlüssel sowie einen Importjob.
2. Überprüfen Sie, ob Ihr Schlüssel für den Import in Cloud KMS lokal verfügbar und richtig formatiert ist.
3. OpenSSL aktualisieren und neu kompilieren

Verpackungsschlüssel abrufen

In diesem Abschnitt wird erläutert, wie Sie den Verpackungsschlüssel aus dem Importjob abrufen, den Sie unter Hinweise erstellt haben. Wir empfehlen, die Google Cloud Console zu verwenden.

Console

1. Rufen Sie in der Cloud Console die Seite Kryptografische Schlüsselbunde auf.

   Zur Seite "Kryptografische Schlüsselbunde"

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

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

4. Klicken Sie auf Mehr und anschließend im Pop-up-Menü auf Verpackungsschlüssel herunterladen.

gcloud

Führen Sie den Befehl gcloud kms import-jobs describe aus, um zu überprüfen, ob der Importjob aktiv ist:

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

state: ACTIVE

Führen Sie den folgenden Befehl aus, um den öffentlichen Schlüssel aus dem Importjob in ${HOME}/wrapping-key.pem zu speichern.

gcloud kms import-jobs describe \
  --location=location \
  --keyring=keyring \
  --format="value(publicKey.pem)" \
  import-job-name > ${HOME}/wrapping-key.pem

Hinweis:Sie müssen den öffentlichen Schlüssel nur einmal herunterladen und können ihn verwenden, bis der Importjob abläuft.

API

1. Rufen Sie die Methode [ImportJob.get][11] auf.

2. Rufen Sie den öffentlichen Schlüssel über das Feld [publicKey][13] der Antwort ImportJob.get ab. Dieser Wert hat den Typ [WrappingPublicKey][14]. Das Feld [pem][21] vom Typ [WrappingPublicKey][22] ist der öffentliche Schlüssel, der im PEM-Format (Privacy Enhanced Mail) codiert ist.

Hinweis: Prüfen Sie, ob Algorithmus und Länge Ihres Schlüssels unterstützt werden. Die zulässigen Algorithmen für einen Schlüssel hängen davon ab, ob der Schlüssel für die synchrone Verschlüsselung, die asymmetrische Verschlüsselung oder die asymmetrische Signatur verwendet wird und ob der Schlüssel in Software oder in einem Hardware Security Module (HSM) gespeichert ist.

Weitere Informationen zum PEM-codierten Format finden Sie unter RFC 7468, insbesondere in den Abschnitten Allgemeine Überlegungen und Textcodierung von Informationen zum öffentlichen Schlüssel.

Umgebungsvariablen einrichten

Die OpenSSL-Befehle erfordern mehrere Dateipfade als Eingabewerte. Definieren Sie Umgebungsvariablen für die Dateipfade, um die Ausführung der Befehle zu erleichtern.

Hinweis: Bei Bedarf können Sie alle diese Befehle in einem Shell-Skript speichern und das Skript ausführen, um die Variablen auf einmal festzulegen. Möglicherweise müssen Sie einige Werte für jeden zu verpackenden Schlüssel anpassen.

1. Legen Sie die Variable OpenSSL_V110 auf den Pfad Ihres openssl.sh-Skripts fest. Wenn Sie die Anleitung zum Patchen und Neukompilieren von OpenSSL genau befolgt haben, können Sie diesen Befehl verwenden, ohne den Wert der Variablen zu ändern.

   OPENSSL_V110="${HOME}/local/bin/openssl.sh"
   

2. Legen Sie für die Variable PUB_WRAPPING_KEY den vollständigen Pfad zum Verpackungsschlüssel fest, den Sie aus dem Importjob heruntergeladen haben. Der Verpackungsschlüssel endet auf .pem.

   Mit den folgenden Befehlen wird die Variable PUB_WRAPPING_KEY auf ${HOME}/wrapping-key.pem gesetzt.

   PUB_WRAPPING_KEY="${HOME}/wrapping-key.pem"
   

3. Legen Sie für die Variable TARGET_KEY den vollständigen Pfad zum entpackten Schlüssel fest.

   • Legen Sie für symmetrische Schlüssel TARGET_KEY auf den Pfad zur Datei .bin fest.
   • Legen Sie für asymmetrische Schlüssel TARGET_KEY auf den Pfad zur Datei .der fest.

   TARGET_KEY=/path/to/key
   

4. Legen Sie die Variable BASE_DIR auf ein Verzeichnis fest, in das temporäre Dateien geschrieben werden können, und erstellen Sie gegebenenfalls das Verzeichnis. Auf dieses Verzeichnis sollte nur Ihr aktueller Nutzer zugreifen können. Verwenden Sie kein abschließendes /-Zeichen am Ende des Verzeichnisnamens.

   BASE_DIR="${HOME}/wrap_tmp"
   mkdir -m 700 -p ${BASE_DIR}
   

5. Definieren Sie Umgebungsvariablen für die drei Zwischendateien.

   TEMP_AES_KEY="${BASE_DIR}/temp_aes_key.bin"
   TEMP_AES_KEY_WRAPPED="${BASE_DIR}/temp_aes_key_wrapped.bin"
   TARGET_KEY_WRAPPED="${BASE_DIR}/target_key_wrapped.bin"
   

6. Setzen Sie die Variable RSA_AES_WRAPPED_KEY auf den vollständigen Pfad, um den verpackten Zielschlüssel zu schreiben, den Sie letztendlich importieren. Stellen Sie dabei sicher, dass Sie Schreibzugriff auf das Verzeichnis haben.

   RSA_AES_WRAPPED_KEY=/path/to/wrapped-target-key.bin
   mkdir -m u+wx -p $(dirname ${RSA_AES_WRAPPED_KEY})
   

7. Überprüfen Sie mit den folgenden Befehlen, ob alle Umgebungsvariablen korrekt festgelegt sind:

   echo "OPENSSL_V110: " ${OPENSSL_V110}; \
   echo "PUB_WRAPPING_KEY: " ${PUB_WRAPPING_KEY}; \
   echo "TARGET_KEY: " ${TARGET_KEY}; \
   echo "BASE_DIR: " ${BASE_DIR}; \
   echo "TEMP_AES_KEY: " ${TEMP_AES_KEY}; \
   echo "TEMP_AES_KEY_WRAPPED: " ${TEMP_AES_KEY_WRAPPED}; \
   echo "TARGET_KEY_WRAPPED: " ${TARGET_KEY_WRAPPED}; \
   echo "RSA_AES_WRAPPED_KEY: " ${RSA_AES_WRAPPED_KEY}
   

Wenn die Variablen richtig eingestellt sind, können Sie den Schlüssel verpacken.

Schlüssel verpacken

1. Führen Sie den folgenden Befehl aus, um einen temporären, 32 Byte langen, zufälligen AES-Schlüssel zu generieren und ihn an dem von ${TEMP_AES_KEY} gezeigten Speicherort zu speichern.

   "${OPENSSL_V110}" rand -out "${TEMP_AES_KEY}" 32
   

2. Verpacken Sie den temporären AES-Schlüssel mithilfe des CKM_RSA_PKCS_OAEP-Algorithmus mit dem öffentlichen Wrapping-Schlüssel.

   "${OPENSSL_V110}" rsautl \
      -encrypt \
      -pubin \
      -inkey "${PUB_WRAPPING_KEY}" \
      -in "${TEMP_AES_KEY}" \
      -out "${TEMP_AES_KEY_WRAPPED}" \
      -oaep
   

3. Verpacken Sie den Zielschlüssel mit dem verpackten temporären AES-Schlüssel mithilfe des Algorithmus CKM_AES_KEY_WRAP_PAD. Ersetzen Sie target-key-file durch den Namen der .bin- oder pub- Datei für den Schlüssel.

   "${OPENSSL_V110}" enc \
     -id-aes256-wrap-pad \
     -iv A65959A6 \
     -K $( hexdump -v -e '/1 "%02x"' < "${TEMP_AES_KEY}" ) \
     -in "${TARGET_KEY}" \
     -out "${TARGET_KEY_WRAPPED}"
   

   Das Flag -iv A65959A6 legt A65959A6 als alternativen Anfangswert fest. Dies ist in der Spezifikation RFC 5649 erforderlich.

   Sie haben nun zwei Schlüssel verpackt:

   • ${TEMP_AES_KEY_WRAPPED} ist der temporäre AES-Schlüssel, den Sie auf dem lokalen System erstellt haben. Er ist mit dem öffentlichen Schlüssel aus dem Importjob verpackt.
   • ${TARGET_KEY_WRAPPED} ist der Zielschlüssel, den Sie importieren, zusammen mit dem von Ihnen generierten temporären AES-Schlüssel.

4. Verketten Sie die beiden verpackten Schlüssel und schreiben Sie die Ausgabe in eine einzelne Datei. Ändern Sie nicht die Reihenfolge der beiden Schlüssel im folgenden Befehl. Der temporäre Schlüssel muss vor dem Zielschlüssel stehen.

   Achtung: Dieser Befehl überschreibt alle vorhandenen Dateien, auf die die Variable ${RSA_AES_WRAPPED_KEY} verweist.

   cat "${TEMP_AES_KEY_WRAPPED}" "${TARGET_KEY_WRAPPED}" > "${RSA_AES_WRAPPED_KEY}"
   

5. Löschen Sie die nicht mehr benötigten Zwischendateien.

   rm ${BASE_DIR}/*
   

Ihr verpackter Schlüssel ist am Ort ${RSA_AES_WRAPPED_KEY}-Variable vorhanden und Sie können eine Anfrage zum Importieren Ihres Schlüssels stellen.