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 der Google Cloud CLI 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 Hinweis erstellt haben. Wir empfehlen, die Google Cloud console zu verwenden.

Console

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

   Seite „Schlüsselverwaltung“ aufrufen

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 CLI

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 \
  --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=KEY_RING \
  --format="value(publicKey.pem)" \
  IMPORT_JOB > ${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 ImportJob.get Methode auf.

2. Rufen Sie den öffentlichen Schlüssel über das publicKey Feld der ImportJob.get Antwort ab. Dieser Wert hat den Typ WrappingPublicKey. Das Feld pem vom Typ WrappingPublicKey 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. Achten Sie darauf, dass Sie Schreibzugriff auf die unten definierten Verzeichnisse haben.

Hinweis: Bei Bedarf können Sie alle diese Befehle in einem Shell-Script speichern und das Script 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 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.

   PUB_WRAPPING_KEY="WRAPPING_KEY_PATH"
   

2. Legen Sie für die Variable TARGET_KEY den vollständigen Pfad zum entpackten (Ziel-)Schlüssel fest.

   TARGET_KEY=TARGET_KEY_PATH
   

   Ersetzen Sie TARGET_KEY_PATH durch den Pfad zur .bin-Datei für symmetrische Schlüssel oder den Pfad zur .der-Datei für asymmetrische Schlüssel.

3. Wenn Sie mit RSA-AES verpacken, legen Sie für die Variable TEMP_AES_KEY den vollständigen Pfad zum temporären AES-Schlüssel fest.

   TEMP_AES_KEY=TEMP_AES_KEY_PATH
   

4. Legen Sie für die Variable WRAPPED_KEY den vollständigen Pfad fest, unter dem Sie den verpackten Zielschlüssel speichern möchten, der für den Import bereit ist.

   WRAPPED_KEY=WRAPPED_KEY_PATH
   

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

   echo "PUB_WRAPPING_KEY: " ${PUB_WRAPPING_KEY}; \
   echo "TARGET_KEY: " ${TARGET_KEY}; \
   echo "TEMP_AES_KEY: " ${TEMP_AES_KEY}; \
   echo "WRAPPED_KEY: " ${WRAPPED_KEY}
   

Wenn die Variablen richtig eingestellt sind, können Sie den Schlüssel verpacken. Es gibt zwei Ansätze, wie unten beschrieben: nur mit RSA oder mit RSA-AES.

Schlüssel zusammenfassen

Schlüssel mit RSA verpacken

Bei diesem Ansatz wird der Zielschlüssel in einem RSA-Block verpackt. Die Größe des Zielschlüssels ist daher begrenzt. Mit dieser Methode können Sie beispielsweise keinen anderen RSA-Schlüssel verpacken. Die unterstützten Importmethoden sind rsa-oaep-3072-sha256 und rsa-oaep-4096-sha256.

• Verpacken Sie den Zielschlüssel mit dem öffentlichen Verpackungsschlüssel mithilfe des Algorithmus CKM_RSA_PKCS_OAEP:

  openssl pkeyutl \
    -encrypt \
    -pubin \
    -inkey ${PUB_WRAPPING_KEY} \
    -in ${TARGET_KEY} \
    -out ${WRAPPED_KEY} \
    -pkeyopt rsa_padding_mode:oaep \
    -pkeyopt rsa_oaep_md:sha256 \
    -pkeyopt rsa_mgf1_md:sha256
  

Schlüssel mit RSA-AES verpacken

Bei diesem Ansatz wird der Zielschlüssel mit einem temporären AES-Schlüssel verpackt. Der temporäre AES-Schlüssel wird dann mit dem RSA-Schlüssel verpackt. Diese beiden verpackten Schlüssel werden verkettet und importiert. Da der Zielschlüssel mit AES und nicht mit RSA verpackt wird, kann dieser Ansatz zum Verpacken großer Schlüssel verwendet werden. Die unterstützten Importmethoden sind rsa-oaep-3072-sha1-aes-256, rsa-oaep-4096-sha1-aes-256, rsa-oaep-3072-sha256-aes-256 und rsa-oaep-4096-sha256-aes-256.

1. Generieren Sie einen temporären zufälligen AES-Schlüssel mit einer Länge von 32 Byte und speichern Sie ihn am Speicherort, der durch ${TEMP_AES_KEY} angegeben wird:

   openssl rand -out "${TEMP_AES_KEY}" 32
   

2. Verpacken Sie den temporären AES-Schlüssel mithilfe des Algorithmus CKM_RSA_PKCS_OAEP mit dem öffentlichen Verpackungsschlüssel. Wenn die Importmethode entweder rsa-oaep-3072-sha1-aes-256 oder rsa-oaep-4096-sha1-aes-256 ist, verwenden Sie sha1 für rsa_oaep_md und rsa_mgf1_md. Verwenden Sie sha256 für rsa-oaep-3072-sha256-aes-256 und rsa-oaep-4096-sha256-aes-256.

   openssl pkeyutl \
     -encrypt \
     -pubin \
     -inkey ${PUB_WRAPPING_KEY} \
     -in ${TEMP_AES_KEY} \
     -out ${WRAPPED_KEY} \
     -pkeyopt rsa_padding_mode:oaep \
     -pkeyopt rsa_oaep_md:{sha1|sha256} \
     -pkeyopt rsa_mgf1_md:{sha1|sha256}
   

3. Legen Sie für die Variable OpenSSL_V110 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"
   

4. Verpacken Sie den Zielschlüssel mit dem temporären AES-Schlüssel mithilfe des Algorithmus CKM_AES_KEY_WRAP_PAD und hängen Sie ihn an WRAPPED_KEY an.

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

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

Nächste Schritte

• Der unter WRAPPED_KEY gespeicherte verpackte Schlüssel kann jetzt importiert werden. Folgen Sie der Anleitung unter Importing a manually-wrapped key, um den Schlüssel zu importieren.