Importieren eines Schlüssels

Der Import von Schlüsseln erfordert einen speziellen Prozess. Dies gewährleistet die Integrität der Schlüssel. Das Ziel ist es, dass keine Informationen über die Schlüssel selbst das Backend verlassen, in das es importiert werden soll.

Dies nutzt das Envelope-Verschlüsselungskonzept, um das Schlüsselmaterial vor dem Hochladen zu verpacken. Daher muss vor dem Hochladen von Schlüsseln ein Verpackungsschlüssel im Ziel-Backend erstellt werden, um das Schlüsselmaterial entsprechend schützen zu können.

Voraussetzungen

Sie haben einen Key Ring in Ihrem Projekt erstellt: Erstellen und Verwalten von Key Rings

Einen symmetrischen Schlüssel importieren

Eine Übersicht über Zwecke und Algorithmen finden Sie unter Konzepte.

STACKIT API

Erstellen Sie einen Schlüssel, in den eine Version importiert werden soll.
Terminal-Fenster
```
curl  -X POST \
'https://kms.api.eu01.stackit.cloud/v1/projects/<project-id>/regions/<region-id>/keyrings/<keyring-id>/keys' \
--header 'Authorization: Bearer <access-token>' \
--header 'Content-Type: application/json' \
--data '{
    "displayName": "sample_key",
    "protection": "software",
    "purpose": "symmetric_encrypt_decrypt",
    "algorithm": "aes_256_gcm",
}'
```
Mögliche Werte für den Verwendungszweck:
- symmetric_encrypt_decrypt
- message_authentication_code
Mögliche Werte für Algorithmusus:
- aes_256_gcm (für symmetric_encrypt_decrypt)
- hmac_sha256 (für message_authentication_code)
- hmac_sha384 (für message_authentication_code)
- hmac_sha512 (für message_authentication_code)

Erstellen Sie einen Verpackungsschlüssel

curl  -X POST \
'https://kms.api.eu01.stackit.cloud/v1/projects/<project-id>/regions/<region-id>/keyrings/<keyring-id/wrappingkeys' \
--header 'Authorization: Bearer <access-token>' \
--header 'Content-Type: application/json' \
--data-raw '{
    "displayName": "wrapping-key",
    "description": "wrapping key to wrap the key material to import to",
    "protection": "software",
    "purpose": "wrap_symmetric_key",
    "algorithm": "rsa_2048_oaep_sha256",
}'

Mögliche Werte für den Verwendungszweck:

wrap_symmetric_key

Mögliche Werte für Algorithmus:

rsa_2048_oaep_sha256
rsa_3072_oaep_sha256
rsa_4096_oaep_sha256
rsa_4096_oaep_sha512

Laden Sie den öffentlichen Schlüssel des Verpackungsschlüssels herunter

curl  -X GET \
'https://kms.api.eu01.stackit.cloud/v1/projects/<project-id>/regions/<region-id>/keyrings/<keyring-id/wrappingkeys/<wrapping-key-id>' \
--header 'Authorization: Bearer <access-token>'

Verwenden Sie den Verpackungsschlüssel, um das zu importierende Schlüsselmaterial zu verschlüsseln
Terminal-Fenster
```
openssl pkeyutl \
-encrypt \
-pubin \
-inkey <wrapping-key> \
-in <key-to-import> \
-pkeyopt rsa_padding_mode:oaep \
-pkeyopt rsa_oaep_md:sha256 \
-pkeyopt rsa_mgf1_md:sha256 \
| base64
```
Verwenden Sie je nach gewähltem Hash-Algorithmus im ersten Schritt sha256 oder sha512 für pkeyopt

Laden Sie den verpackten Schlüssel in den Zielschlüssel hoch

curl  -X POST \
'https://kms.api.eu01.stackit.cloud/v1/projects/<project-id>/regions/<region-id>/keyrings/<keyring-id>/keys/<key-id>/import' \
--header 'Authorization: Bearer <access-token>' \
--header 'Content-Type: application/json' \
--data-raw '{
    "wrappingKeyId": "<wrapping-key-id>",
    "wrappedKey": "<base64-encoded-wrapped-key>"
}'

Einen asymmetrischen Schlüssel importieren

Eine Übersicht über Zwecke und Algorithmen finden Sie unter Konzepte.

STACKIT API

Erstellen Sie einen Schlüssel, in den eine Version importiert werden soll
Terminal-Fenster
```
curl  -X POST \
'https://kms.api.eu01.stackit.cloud/v1/projects/<project-id>/regions/<region-id>/keyrings/<keyring-id>/keys' \
--header 'Authorization: Bearer <access-token>' \
--header 'Content-Type: application/json' \
--data '{
    "displayName": "sample_key",
    "protection": "software",
    "purpose": "asymmetric_encrypt_decrypt",
    "algorithm": "rsa_2048_oaep_sha256",
}'
```
Mögliche Werte für den Verwendungszweck:
- asymmetric_encrypt_decrypt
- asymmetric_sign_verify
Mögliche Werte für Algorithmus:
- rsa_2048_oap_sha256 (für asymmetric_encrypt_decrypt)
- rsa_3072_oap_sha256 (für asymmetric_encrypt_decrypt)
- rsa_4096_oap_sha256 (für asymmetric_encrypt_decrypt)
- rsa_4096_oap_sha512 (für asymmetric_encrypt_decrypt)
- ecdsa_p256_sha256 (für asymmetric_sign_verify)
- ecdsa_p384_sha384 (für asymmetric_sign_verify)
- ecdsa_p521_sha512 (für asymmetric_sign_verify)

Erstellen Sie einen Verpackungsschlüssel

curl  -X POST \
'https://kms.api.eu01.stackit.cloud/v1/projects/<project-id>/regions/<region-id>/keyrings/<keyring-id/wrappingkeys' \
--header 'Authorization: Bearer <access-token>' \
--header 'Content-Type: application/json' \
--data-raw '{
    "displayName": "wrapping-key",
    "description": "wrapping key to wrap the key material to import to",
    "protection": "software",
    "purpose": "wrap_asymmetric_key",
    "algorithm": "rsa_2048_oaep_sha256_aes_key_wrap"
}'

Mögliche Werte für den Verwendungszweck:

wrap_asymmetric_key

Mögliche Werte für Algorithmus:

rsa_2048_oaep_sha256_aes_256_key_wrap
rsa_3072_oaep_sha256_aes_256_key_wrap
rsa_4096_oaep_sha256_aes_256_key_wrap
rsa_4096_oaep_sha512_aes_256_key_wrap

Rufen Sie den öffentlichen Schlüssel des Verpackungsschlüssels ab und speichern Sie ihn in einer Datei wrapping_key.pem

curl  -X GET \
'https://kms.api.eu01.stackit.cloud/v1/projects/<project-id>/regions/<region-id>/keyrings/<keyring-id>/wrappingkeys/<wrapping-key-id>' \
--header 'Authorization: Bearer <access-token>'

Generieren Sie einen kurzlebigen 256-Bit-AES-Schlüssel
Terminal-Fenster
```
openssl rand 32 > key
```
Konvertieren Sie Ihren vorhandenen PKCS#1-Schlüssel in das PKCS#8-Format und kodieren Sie ihn als .der
Terminal-Fenster
```
openssl pkcs8 -topk8 -inform pem -outform der -nocrypt -in <your-key> -out pkcs8.der
```

Verschlüsseln Sie den kurzlebigen AES-Schlüssel mit dem öffentlichen Schlüssel des Verpackungsschlüssels und kodieren Sie ihn mit base64

openssl pkeyutl -encrypt -pubin -inkey wrapping_key.pem -in key -pkeyopt rsa_padding_mode:oaep -pkeyopt rsa_oaep_md:sha256 -pkeyopt rsa_mgf1_md:sha256 > wrapped_key.bin

Verschlüsseln Sie den privaten RSA-Schlüssel mit dem generierten AES-Schlüssel

openssl enc -e -id-aes256-wrap-pad -iv A65959A6 -K $(hexdump -v -e '1/1 "%02x"' key) -in private.der >> wrapped_key.bin

Laden Sie den verpackten Schlüssel in den Zielschlüssel hoch

curl  -X POST \
'https://kms.api.eu01.stackit.cloud/v1/projects/<project-id>/regions/<region-id>/keyrings/<keyring-id>/keys/<key-id>/import' \
--header 'Authorization: Bearer <access-token>' \
--header 'Content-Type: application/json' \
--data '{
    "wrappingKeyId": "<wrapping-key-id>",
    "wrappedKey": "<base64-encoded-wrapped-key>"
}'