Import i eksport kluczy w OVHcloud KMS za pomocą BYOK

Wprowadzenie

Bring Your Own Key (BYOK) umożliwia import i eksport materiału kryptograficznego klucza w OVHcloud Key Management Service (KMS) bez przesyłania go w postaci jawnej. Para kluczy transportowych RSA chroni materiał w trakcie przesyłania: klucz publiczny go opakowuje, a tylko posiadacz klucza prywatnego może go rozpakować.

Ten przewodnik wyjaśnia, jak zaimportować i wyeksportować klucz w OVHcloud KMS przy użyciu asymetrycznego opakowywania kluczy RSA (BYOK).

Wymagania początkowe

• Konto klienta OVHcloud.
• Zamówiona usługa OVHcloud KMS.
• Skonfigurowana metoda uwierzytelniania dla płaszczyzny danych OKMS (osobisty token dostępu, konto serwisowe lub certyfikat dostępu).
• Możliwość zastosowania polityki IAM w domenie OKMS; wymagane akcje BYOK są wymienione w sekcji Konfiguracja IAM dla BYOK.
• Opcjonalnie: zainstalowane CLI OKMS (wersja 0.6.0 lub nowsza) lub SDK Go na potrzeby przykładów w kartach.

W praktyce

Zrozumienie ceremonii opakowywania RSA

Ceremonia obejmuje dwa środowiska i operatora:

• Miejsce docelowe (Dst): Twoja domena OKMS, w której zostanie przechowywany zaimportowany klucz.
• Źródło (Src): system, który obecnie przechowuje materiał klucza (inny KMS, aplikacja lub narzędzie takie jak OpenSSL).
• Operator: podmiot posiadający uprawnienia dostępu zarówno do domeny OKMS, jak i do źródła klucza do zaimportowania. Może to być osoba korzystająca z CLI OKMS lub usługa działająca poprzez API.

1. Wygeneruj parę kluczy transportowych RSA w OVHcloud KMS z operacjami wrapKey i unwrapKey.
2. Wyeksportuj publiczny klucz transportowy z OVHcloud KMS.
3. Zaimportuj publiczny klucz transportowy do środowiska źródłowego.
4. Po stronie źródła wyeksportuj materiał klucza opakowany (zaszyfrowany) kluczem transportowym, używając RSA-OAEP lub RSA-OAEP-256.
5. Po stronie miejsca docelowego zaimportuj opakowany klucz za pomocą POST /api/{okmsId}/v1/servicekey i ładunku wrappedKeys. KMS rozpakowuje ciphertext prywatnym kluczem transportowym i zapisuje wynikowy klucz serwisowy.

Klucze zaimportowane w ten sposób mają never_extractable ustawione na false, ponieważ materiał istniał poza KMS przed importem. Aby później wyodrębnić klucz w formie opakowanej, zaimportuj go z extractable ustawionym na true (nie można tego włączyć później) i postępuj zgodnie z sekcją Eksport opakowanego klucza. Pełną listę atrybutów znajdziesz w sekcji Atrybuty wrażliwości kluczy serwisowych.

Konfiguracja IAM dla BYOK

Zastosuj politykę do zasobu swojej domeny OKMS. Jego URN jest wyświetlany w zakładce Informacje ogólne w dashboardzie Twojej domeny OKMS. Zastąp <identity_urn> i <okms_urn> swoimi wartościami. Utwórz polityki za pośrednictwem Panelu klienta OVHcloud lub API OVHcloud.

Import BYOK — odczyt, tworzenie lub import kluczy serwisowych oraz rozpakowywanie za pomocą klucza transportowego:

{
  "name": "okms-byok-import",
  "description": "Import wrapped keys into an OKMS domain using RSA BYOK",
  "identities": ["<identity_urn>"],
  "resources": [{ "urn": "<okms_urn>" }],
  "action": [
    "okms:apikms:serviceKey/get",
    "okms:apikms:serviceKey/create",
    "okms:apikms:serviceKey/unwrapKey",
    "okms:apikms:serviceKey/import"
  ]
}

Eksport BYOK — import publicznego klucza transportowego, aktualizacja możliwości wyodrębnienia oraz opakowanie klucza do eksportu:

{
  "name": "okms-byok-export",
  "description": "Export wrapped keys from an OKMS domain using RSA BYOK",
  "identities": ["<identity_urn>"],
  "resources": [{ "urn": "<okms_urn>" }],
  "action": [
    "okms:apikms:serviceKey/get",
    "okms:apikms:serviceKey/create",
    "okms:apikms:serviceKey/import",
    "okms:apikms:serviceKey/update",
    "okms:apikms:serviceKey/wrapKey"
  ]
}

Utworzenie klucza transportowego RSA w docelowym KMS

Utwórz klucz RSA przeznaczony do opakowywania. Na potrzeby ceremonii importu ustaw na tym kluczu zarówno wrapKey, jak i unwrapKey; wzajemnie wykluczają się one z sign i verify.

Obsługiwane rozmiary kluczy RSA: 2048, 3072 lub 4096 bitów.

curl -X POST "https://<region>.okms.ovh.net/api/<okmsId>/v1/servicekey" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "byok-transport-rsa",
    "type": "RSA",
    "size": 2048,
    "operations": ["wrapKey", "unwrapKey"]
  }'

okms keys generate byok-transport-rsa \
  --type rsa \
  --size 2048 \
  --usage wrapKey,unwrapKey

resp, err := okmsClient.GenerateRSAKeyPair(
  ctx,
  okmsId,
  types.N2048,
  "byok-transport-rsa",
  types.SOFTWARE,
  "",
  []types.CryptographicUsages{types.WrapKey, types.UnwrapKey},
)
if err != nil {
  return err
}
transportKeyID := resp.Id

Zapisz zwrócone id klucza — potrzebujesz go jako wrappingKeyId podczas importu.

Pobranie publicznego klucza transportowego

Wyeksportuj publiczną część klucza transportowego i przekaż ją środowisku źródłowemu. Nigdy nie udostępniaj klucza prywatnego — pozostaje on wewnątrz docelowego KMS.

curl -X GET "https://<region>.okms.ovh.net/api/<okmsId>/v1/servicekey/<transport-key-id>?format=jwk" \
  -H "Authorization: Bearer <token>"

okms keys export <transport-key-id> --format jwk

pub, err := okmsClient.ExportPublicKey(ctx, okmsId, transportKeyID)
if err != nil {
  return err
}
// pub to crypto.PublicKey (*rsa.PublicKey w przypadku klucza transportowego RSA)

jwk, err := okmsClient.ExportJwkPublicKey(ctx, okmsId, transportKeyID)
if err != nil {
  return err
}

Opakowanie materiału klucza źródłowego

W środowisku źródłowym zaszyfruj materiał klucza publicznym kluczem RSA miejsca docelowego.

Ten krok odbywa się poza OVHcloud KMS: w środowisku źródłowym użyj biblioteki JOSE.

Obsługiwane algorytmy opakowywania (RFC 7518):

keyFormatType opisuje format jawnego materiału klucza przed opakowaniem i po rozpakowaniu. Ciphertext jest zawsze ciągiem JWE Compact Serialization (algorytm opakowywania jest przenoszony w nagłówku JWE).

Po opakowaniu publicznym kluczem miejsca docelowego prześlij uzyskaną wartość ciphertext w formacie JWE Compact Serialization w żądaniu importu. Przykład w Go dla tego kroku opakowywania znajdziesz w sekcji Przykład end-to-end w Go.

Import opakowanego klucza

Wywołaj POST /api/{okmsId}/v1/servicekey z tablicą wrappedKeys zamiast jawnych keys.

Każdy wpis wrappedKeys:

Możesz zaimportować sam klucz publiczny (class staje się PUBLIC_KEY) lub klucz prywatny (KMS odtwarza część publiczną; class staje się KEY_PAIR). Materiał symetryczny jest przechowywany jako SECRET_KEY.

Akcje IAM przy tym wywołaniu: okms:apikms:serviceKey/create, okms:apikms:serviceKey/import oraz okms:apikms:serviceKey/unwrapKey na kluczu transportowym.

curl -X POST "https://<region>.okms.ovh.net/api/<okmsId>/v1/servicekey" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "imported-aes-byok",
    "operations": ["encrypt", "decrypt"],
    "wrappedKeys": [
      {
        "keyFormatType": "JWK",
        "wrappingKeyId": "<transport-key-id>",
        "ciphertext": "<jwe-compact-serialization>"
      }
    ]
  }'

okms keys import --usage encrypt,decrypt \
  --wrapping-key-id <transport-key-id> \
  --wrapped-key-format JWK \
  imported-aes-byok @wrapped.jwe

resp, err := okmsClient.ImportWrappedServiceKey(
  ctx,
  okmsId,
  transportKeyID,
  jweCompact,
  types.JWK,
  "imported-aes-byok",
  "",
  []types.CryptographicUsages{types.Encrypt, types.Decrypt},
)
if err != nil {
  return err
}
importedKeyID := resp.Id

Weryfikacja zaimportowanego klucza

Potwierdź, że klucz istnieje i odpowiada oczekiwanemu typowi oraz operacjom.

curl -X GET "https://<region>.okms.ovh.net/api/<okmsId>/v1/servicekey/<imported-key-id>" \
  -H "Authorization: Bearer <token>"

okms keys get <imported-key-id>

key, err := okmsClient.GetServiceKey(ctx, okmsId, importedKeyID, nil)
if err != nil {
  return err
}

Sprawdź, czy:

• atrybut state klucza ma wartość active (lub aktywuj go, jeśli wymaga tego Twój przepływ pracy).
• type, size i operations odpowiadają Twoim założeniom.
• atrybuty wrażliwości w attributes odzwierciedlają zaimportowany klucz (never_extractable ma wartość false).

Następnie możesz używać klucza do operacji encrypt, decrypt, sign lub verify zgodnie z dokumentacją Korzystanie z OVHcloud Key Management Service (KMS).

Eksport opakowanego klucza

Bezpieczny eksport jest odwrotnością importu: OVHcloud KMS szyfruje materiał klucza kluczem transportowym RSA i zwraca wyłącznie ciphertext JWE. Prywatny klucz transportowy musi znajdować się w środowisku docelowym — czyli w systemie zewnętrznym, który otrzymuje klucz, a nie w OVHcloud KMS — aby tylko to środowisko mogło rozpakować materiał.

Zrozumienie ceremonii eksportu

1. Wygeneruj parę kluczy transportowych RSA w środowisku docelowym (inny KMS lub narzędzie, które odbierze klucz).
2. Zaimportuj publiczny klucz transportowy miejsca docelowego do OVHcloud KMS z operacją wrapKey. Ten klucz to wrappingKeyId używany w momencie eksportu.
3. W OVHcloud KMS wyeksportuj klucz serwisowy opakowany tym kluczem transportowym. Klucz musi zostać utworzony lub zaimportowany z extractable ustawionym na true. Następnie, gdy to możliwe, ustaw extractable na false.
4. Przenieś ciphertext do miejsca docelowego i rozpakuj go prywatnym kluczem transportowym miejsca docelowego.

Klucz transportowy wskazany przez wrappingKeyId musi być kluczem RSA w tej samej domenie OKMS z użyciem wrapKey. Aby wyeksportować klucz przechowywany w HSM, zobacz Użycie BYOK z kluczami HSM. Klucze wrażliwe (materiał AES/oct oraz prywatny materiał RSA/EC) można wyodrębnić tylko po opakowaniu — wyodrębnianie w postaci jawnej nie jest obsługiwane dla tych kluczy.

Import publicznego klucza transportowego miejsca docelowego do OVHcloud KMS

Zarejestruj publiczny klucz miejsca docelowego, aby OVHcloud KMS mógł nim opakować eksportowany klucz. Zaimportuj go jako klucz RSA wyłącznie publiczny z wrapKey (bez materiału prywatnego).

curl -X POST "https://<region>.okms.ovh.net/api/<okmsId>/v1/servicekey" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "byok-export-transport-pub",
    "type": "RSA",
    "operations": ["wrapKey"],
    "keys": [
      {
        "kty": "RSA",
        "n": "<base64url-modulus>",
        "e": "<base64url-exponent>",
        "key_ops": ["wrapKey"]
      }
    ]
  }'

okms keys import byok-export-transport-pub @destination-transport-public.pem \
  --usage wrapKey

pemBytes, err := os.ReadFile("destination-transport-public.pem")
if err != nil {
  return err
}
resp, err := okmsClient.ImportKeyPairPEM(
  ctx,
  okmsId,
  pemBytes,
  "byok-export-transport-pub",
  "",
  []types.CryptographicUsages{types.WrapKey},
)
if err != nil {
  return err
}
wrappingKeyID := resp.Id

destKey, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
  return err
}
resp, err := okmsClient.ImportKey(
  ctx,
  okmsId,
  &destKey.PublicKey,
  "byok-export-transport-pub",
  "",
  []types.CryptographicUsages{types.WrapKey},
)
if err != nil {
  return err
}
wrappingKeyID := resp.Id

Zapisz zwrócone id klucza jako wrappingKeyId.

Włączenie wyodrębniania

Eksportowany klucz musi być możliwy do wyodrębnienia, a decyzja o tym zapada podczas tworzenia lub importu klucza. Później extractable można zmienić tylko z true na false: po ustawieniu na false nie można go już nigdy przywrócić do true. Klucza utworzonego lub zaimportowanego bez extractable ustawionego na true nie będzie więc nigdy można wyeksportować. Ta reguła dotyczy zarówno kluczy SOFTWARE, jak i kluczy HSM.

Ustaw extractable na true podczas tworzenia klucza:

curl -X POST "https://<region>.okms.ovh.net/api/<okmsId>/v1/servicekey" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "aes-to-migrate",
    "type": "oct",
    "size": 256,
    "operations": ["encrypt", "decrypt"],
    "extractable": true
  }'

okms keys generate aes-to-migrate \
  --type oct \
  --size 256 \
  --usage encrypt,decrypt \
  --extractable

resp, err := okmsClient.GenerateSymmetricKey(
  ctx,
  okmsId,
  types.N256,
  "aes-to-migrate",
  types.SOFTWARE,
  "",
  []types.CryptographicUsages{types.Encrypt, types.Decrypt},
  okms.WithExtractable(true),
)
if err != nil {
  return err
}
keyID := resp.Id

W przypadku importu ustaw "extractable": true w treści żądania (API REST), dodaj --extractable (CLI OKMS) lub przekaż okms.WithExtractable(true) (SDK Go).

Gdy klucz nie musi już być eksportowany, na przykład po udanym eksporcie opakowanym (patrz sekcja Eksport klucza opakowanego kluczem transportowym), wyłącz wyodrębnianie. Tej operacji nie można cofnąć. Akcja IAM: okms:apikms:serviceKey/update.

curl -X PATCH "https://<region>.okms.ovh.net/api/<okmsId>/v1/servicekey/<key-id>" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "extractable": false
  }'

okms keys update <key-id> --extractable=false

extractable := false
_, err := okmsClient.UpdateServiceKey(ctx, okmsId, keyID, types.PatchServiceKeyRequest{
  Extractable: &extractable,
})
if err != nil {
  return err
}

Eksport klucza opakowanego kluczem transportowym

Wywołaj GET /api/{okmsId}/v1/servicekey/{keyId} z poniższymi parametrami zapytania opakowywania. Gdy te parametry są obecne, API zwraca wrappedKeys zamiast jawnych keys.

Akcje IAM: okms:apikms:serviceKey/get na eksportowanym kluczu oraz okms:apikms:serviceKey/wrapKey na kluczu transportowym.

curl -X GET "https://<region>.okms.ovh.net/api/<okmsId>/v1/servicekey/<key-id>?wrappingKeyId=<wrapping-key-id>&wrappedKeyFormat=JWK&wrappingAlgorithm=RSA-OAEP-256" \
  -H "Authorization: Bearer <token>"

{
  "id": "<key-id>",
  "name": "imported-aes-byok",
  "type": "oct",
  "class": "SECRET_KEY",
  "size": 256,
  "operations": ["encrypt", "decrypt"],
  "wrappedKeys": [
    {
      "keyFormatType": "JWK",
      "wrappingKeyId": "<wrapping-key-id>",
      "ciphertext": "<jwe-compact-serialization>"
    }
  ]
}

okms keys export <key-id> \
  --wrapping-key-id <wrapping-key-id> \
  --wrapped-key-format JWK \
  --wrapping-algorithm RSA-OAEP-256

wrapped, err := okmsClient.GetWrappedServiceKey(
  ctx,
  okmsId,
  keyID,
  wrappingKeyID,
  types.JWK,
  types.RSAOAEP256,
)
if err != nil {
  return err
}
ciphertext := wrapped[0].Ciphertext

Rozpakowanie ciphertextu w miejscu docelowym

Przenieś ciphertext do środowiska docelowego. Rozpakuj go prywatnym kluczem transportowym miejsca docelowego (odpowiednikiem klucza publicznego zaimportowanego do OVHcloud KMS).

• Jeśli miejscem docelowym jest inna domena OKMS, zaimportuj tam opakowany materiał za pomocą wrappedKeys jak w Import opakowanego klucza, używając identyfikatora klucza transportowego tej domeny jako wrappingKeyId.
• Jeśli miejscem docelowym jest system zewnętrzny, użyj jego natywnego API rozpakowywania / importu z prywatnym kluczem transportowym oraz tym samym keyFormatType / algorytmem opakowywania, którego użyto przy eksporcie.

Użycie BYOK z kluczami HSM

Przy poziomie ochrony HSM materiał klucza jest opakowywany i rozpakowywany wewnątrz HSM: nigdy nie pojawia się w postaci jawnej w OVHcloud KMS. Format JWE jest taki sam jak dla kluczy SOFTWARE (RSA-OAEP lub RSA-OAEP-256 z A256GCM).

Klucz transportowy musi być przechowywany w HSM zawsze wtedy, gdy przechowywany jest w nim importowany lub eksportowany klucz, co podsumowuje poniższa tabela:

Opisane poniżej operacje importu do HSM są przedstawione wyłącznie dla API REST.

Utworzenie klucza transportowego HSM

Aby zaimportować klucz do HSM, utwórz klucz transportowy z poziomem ochrony HSM:

curl -X POST "https://<region>.okms.ovh.net/api/<okmsId>/v1/servicekey" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "byok-transport-rsa-hsm",
    "type": "RSA",
    "size": 2048,
    "operations": ["wrapKey", "unwrapKey"],
    "protectionLevel": "HSM"
  }'

okms keys generate byok-transport-rsa-hsm \
  --type rsa \
  --size 2048 \
  --usage wrapKey,unwrapKey \
  --protectionLevel hsm

resp, err := okmsClient.GenerateRSAKeyPair(
  ctx,
  okmsId,
  types.N2048,
  "byok-transport-rsa-hsm",
  types.HSM,
  "",
  []types.CryptographicUsages{types.WrapKey, types.UnwrapKey},
)
if err != nil {
  return err
}
transportKeyID := resp.Id

Następnie wyeksportuj jego klucz publiczny i opakuj materiał klucza w źródle, jak opisano w sekcjach Pobranie publicznego klucza transportowego i Opakowanie materiału klucza źródłowego.

Import klucza do HSM

Ponieważ HSM nigdy nie ujawnia rozpakowanego materiału, OVHcloud KMS nie może wywnioskować typu klucza. Żądanie importu różni się od importu SOFTWARE:

• Ustaw protectionLevel na HSM. Klucz transportowy również musi być kluczem HSM.
• Zadeklaruj type: oct, RSA lub EC. Nie ustawiaj size ani curve dla RSA i EC: HSM odczytuje je z klucza. Dla oct parametr size jest opcjonalny (128, 192 lub 256).
• Nie ustawiaj keyFormatType w wrappedKeys. Tekst jawny opakowany w JWE musi zawierać surowe bajty klucza w przypadku klucza oct oraz klucz prywatny w formacie PKCS#8 (DER) w przypadku klucza RSA lub EC.
• Obsługiwane klucze: AES 128, 192 lub 256 bitów, RSA 2048, 3072 lub 4096 bitów, EC P-256, P-384 lub P-521. Samego klucza publicznego nie można zaimportować do HSM w postaci opakowanej; możliwy jest tylko import w postaci jawnej.

curl -X POST "https://<region>.okms.ovh.net/api/<okmsId>/v1/servicekey" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "imported-aes-hsm",
    "type": "oct",
    "operations": ["encrypt", "decrypt"],
    "protectionLevel": "HSM",
    "wrappedKeys": [
      {
        "wrappingKeyId": "<hsm-transport-key-id>",
        "ciphertext": "<jwe-compact-serialization>"
      }
    ]
  }'

Klucz transportowy HSM może również rozpakować klucz SOFTWARE: w takim przypadku postępuj zgodnie z sekcją Import opakowanego klucza, podając keyFormatType.

Eksport klucza z HSM

Z HSM można eksportować tylko klucze symetryczne (oct): HSM nigdy nie udostępnia kluczy prywatnych RSA ani EC. Podobnie jak w przypadku klucza SOFTWARE, klucz musi zostać utworzony lub zaimportowany z extractable ustawionym na true, czego nie można włączyć później (zobacz Włączenie wyodrębniania).

Klucz transportowy musi być przechowywany w HSM. Zaimportuj publiczny klucz transportowy miejsca docelowego z poziomem ochrony HSM:

curl -X POST "https://<region>.okms.ovh.net/api/<okmsId>/v1/servicekey" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "byok-export-transport-pub-hsm",
    "type": "RSA",
    "operations": ["wrapKey"],
    "protectionLevel": "HSM",
    "keys": [
      {
        "kty": "RSA",
        "n": "<base64url-modulus>",
        "e": "<base64url-exponent>",
        "key_ops": ["wrapKey"]
      }
    ]
  }'

Następnie wyeksportuj klucz, ustawiając wrappedKeyFormat na RAW: HSM zawsze opakowuje surowe bajty klucza, więc odszyfrowana zawartość JWE to sam klucz AES (32 bajty w przypadku klucza 256-bitowego).

curl -X GET "https://<region>.okms.ovh.net/api/<okmsId>/v1/servicekey/<hsm-key-id>?wrappingKeyId=<hsm-wrapping-key-id>&wrappedKeyFormat=RAW&wrappingAlgorithm=RSA-OAEP-256" \
  -H "Authorization: Bearer <token>"

okms keys export <hsm-key-id> \
  --wrapping-key-id <hsm-wrapping-key-id> \
  --wrapped-key-format RAW \
  --wrapping-algorithm RSA-OAEP-256

wrapped, err := okmsClient.GetWrappedServiceKey(
  ctx,
  okmsId,
  hsmKeyID,
  hsmWrappingKeyID,
  types.RAW,
  types.RSAOAEP256,
)
if err != nil {
  return err
}
ciphertext := wrapped[0].Ciphertext

W miejscu docelowym odszyfruj JWE prywatnym kluczem transportowym, jak opisano w sekcji Rozpakowanie ciphertextu w miejscu docelowym.

Przykład end-to-end w Go

Poniższe przykłady przeprowadzają obie ceremonie z parą kluczy RSA, używając SDK Go do wywołań OVHcloud KMS oraz go-jose do operacji JWE wykonywanych poza OVHcloud KMS. Oba przykłady kodują materiał klucza w formacie PKCS#8 (DER), co odpowiada wartości PKCS8 pola keyFormatType.

Import klucza wygenerowanego lokalnie

Program generuje klucz za pomocą standardowej biblioteki Go, opakowuje go lokalnie publicznym kluczem transportowym, a następnie go importuje. Klucz nigdy nie trafia do OVHcloud KMS w postaci jawnej.

// 1. Utwórz klucz transportowy w OVHcloud KMS i pobierz jego część publiczną.
transportKey, err := okmsClient.GenerateRSAKeyPair(
  ctx,
  okmsId,
  types.N2048,
  "byok-transport-rsa",
  types.SOFTWARE,
  "",
  []types.CryptographicUsages{types.WrapKey, types.UnwrapKey},
)
if err != nil {
  return err
}
transportPub, err := okmsClient.ExportPublicKey(ctx, okmsId, transportKey.Id)
if err != nil {
  return err
}

// 2. Wygeneruj klucz do zaimportowania i zakoduj go w formacie PKCS#8 (DER).
srcKey, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
  return err
}
plaintext, err := x509.MarshalPKCS8PrivateKey(srcKey)
if err != nil {
  return err
}

// 3. Opakuj materiał klucza jako JWE: opakowanie klucza RSA-OAEP-256, szyfrowanie treści A256GCM.
encrypter, err := jose.NewEncrypter(
  jose.A256GCM,
  jose.Recipient{Algorithm: jose.RSA_OAEP_256, Key: transportPub},
  nil,
)
if err != nil {
  return err
}
jwe, err := encrypter.Encrypt(plaintext)
if err != nil {
  return err
}
ciphertext, err := jwe.CompactSerialize()
if err != nil {
  return err
}

// 4. Zaimportuj opakowany klucz. KMS rozpakowuje go i wnioskuje typ oraz rozmiar z materiału.
// Jest importowany jako możliwy do wyodrębnienia, aby następny przykład mógł go wyeksportować: nie można tego włączyć później.
imported, err := okmsClient.ImportWrappedServiceKey(
  ctx,
  okmsId,
  transportKey.Id,
  ciphertext,
  types.PKCS8,
  "imported-rsa-byok",
  "",
  []types.CryptographicUsages{types.Sign, types.Verify},
  okms.WithExtractable(true),
)
if err != nil {
  return err
}
keyID := imported.Id

Algorytm szyfrowania treści JWE (enc) musi mieć wartość A256GCM.

Eksport klucza i odszyfrowanie JWE

Miejsce docelowe (tutaj lokalny program) generuje parę kluczy transportowych, importuje do OVHcloud KMS tylko jej część publiczną, a następnie odszyfrowuje wyeksportowany JWE częścią prywatną.

// Identyfikator klucza serwisowego do wyeksportowania, na przykład klucza zaimportowanego w poprzednim przykładzie.
keyID := uuid.MustParse("<key-id>")

// 1. Wygeneruj parę kluczy transportowych w miejscu docelowym.
destKey, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
  return err
}

// 2. Zaimportuj do OVHcloud KMS tylko jej część publiczną, z użyciem wrapKey.
wrappingKey, err := okmsClient.ImportKey(
  ctx,
  okmsId,
  &destKey.PublicKey,
  "byok-export-transport-pub",
  "",
  []types.CryptographicUsages{types.WrapKey},
)
if err != nil {
  return err
}

// 3. Wyeksportuj klucz opakowany publicznym kluczem miejsca docelowego. Klucz musi zostać utworzony lub
// zaimportowany jako możliwy do wyodrębnienia. Po eksporcie wyodrębnianie zostaje nieodwracalnie wyłączone.
defer func() {
  extractable := false
  _, _ = okmsClient.UpdateServiceKey(ctx, okmsId, keyID, types.PatchServiceKeyRequest{Extractable: &extractable})
}()
wrapped, err := okmsClient.GetWrappedServiceKey(
  ctx,
  okmsId,
  keyID,
  wrappingKey.Id,
  types.PKCS8,
  types.RSAOAEP256,
)
if err != nil {
  return err
}

// 4. Odszyfruj JWE prywatnym kluczem miejsca docelowego i przeanalizuj materiał PKCS#8.
jwe, err := jose.ParseEncrypted(
  wrapped[0].Ciphertext,
  []jose.KeyAlgorithm{jose.RSA_OAEP_256},
  []jose.ContentEncryption{jose.A256GCM},
)
if err != nil {
  return err
}
plaintext, err := jwe.Decrypt(destKey)
if err != nil {
  return err
}

exportedKey, err := x509.ParsePKCS8PrivateKey(plaintext)
if err != nil {
  return err
}
// exportedKey zawiera wyeksportowany materiał klucza, używany w dalszej części programu.

Sprawdź również

Korzystanie z OVHcloud Key Management Service (KMS)

Metody uwierzytelniania OKMS

Pierwsze kroki z OVHcloud Key Management Service (KMS)

Dołącz do grona naszych użytkowników.