Importer et exporter des clés sur OVHcloud KMS avec BYOK

Objectif

Bring Your Own Key (BYOK) vous permet d'importer et d'exporter du matériel cryptographique avec OVHcloud Key Management Service (KMS) sans l'envoyer en clair. Une paire de clés RSA de transport protège le matériel en transit : la clé publique l'encapsule et seul le détenteur de la clé privée peut le désencapsuler.

Ce guide vous explique comment importer et exporter une clé avec OVHcloud KMS en utilisant l'encapsulation de clé RSA asymétrique (BYOK).

Prérequis

• Disposer d'un compte client OVHcloud.
• Avoir commandé un OVHcloud KMS.
• Avoir configuré une méthode d'authentification pour le plan de données OKMS (jeton d'accès personnel, compte de service ou certificat d'accès).
• Pouvoir appliquer une politique IAM sur votre domaine OKMS ; les actions BYOK requises sont listées dans la section « Configurer IAM pour le BYOK ».
• Optionnel : avoir installé la CLI OKMS (version 0.6.0 ou ultérieure) ou le SDK Go pour les exemples en onglets.

En pratique

Comprendre la cérémonie d'encapsulation RSA

La cérémonie implique deux environnements et un opérateur :

• Destination (Dst) : votre domaine OKMS, où la clé importée est stockée.
• Source (Src) : le système qui détient actuellement le matériel de clé (un autre KMS, une application ou un outil tel qu'OpenSSL).
• Operator : l'entité disposant des autorisations nécessaires pour accéder à la fois au domaine OKMS et à la source de la clé à importer. Il peut s'agir d'une personne utilisant le CLI OKMS ou d'un service passant par l'API.

1. Générez une paire de clés RSA de transport sur OVHcloud KMS avec les opérations wrapKey et unwrapKey.
2. Exportez la clé de transport publique depuis OVHcloud KMS.
3. Importez la clé de transport publique dans l'environnement source.
4. Sur la source, exportez le matériel de clé encapsulé (chiffré) avec la clé de transport en utilisant RSA-OAEP ou RSA-OAEP-256.
5. Sur la destination, importez la clé encapsulée avec POST /api/{okmsId}/v1/servicekey et une charge utile wrappedKeys. Le KMS désencapsule le ciphertext avec la clé de transport privée et stocke la clé de service résultante.

Les clés ainsi importées ont never_extractable défini à false, car le matériel existait en dehors du KMS avant l'import. Pour extraire ultérieurement une clé sous forme encapsulée, importez-la avec extractable défini à true (il ne peut pas être activé ensuite) et suivez la section « Exporter une clé encapsulée ». Consultez la section « Attributs de sensibilité des clés de service » pour obtenir la liste complète des attributs.

Configurer IAM pour le BYOK

Appliquez une politique à la ressource de votre domaine OKMS. Son URN est affiché dans l'onglet Informations générales du dashboard de votre domaine OKMS. Remplacez <identity_urn> et <okms_urn> par vos valeurs. Créez les politiques via l'espace client OVHcloud ou l'API OVHcloud.

Import BYOK — lire, créer ou importer des clés de service et désencapsuler avec une clé de transport :

{
  "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"
  ]
}

Export BYOK — importer une clé de transport publique, mettre à jour l'extractibilité et encapsuler une clé pour l'export :

{
  "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"
  ]
}

Créer la clé de transport RSA sur le KMS de destination

Créez une clé RSA dédiée à l'encapsulation. Pour la cérémonie d'import, définissez à la fois wrapKey et unwrapKey sur cette clé ; elles sont mutuellement exclusives avec sign et verify.

Tailles de clé RSA prises en charge : 2048, 3072 ou 4096 bits.

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

Conservez l'id de la clé renvoyée — vous en avez besoin comme wrappingKeyId lors de l'import.

Obtenir la clé de transport publique

Exportez la partie publique de la clé de transport et transmettez-la à l'environnement source. Ne partagez jamais la clé privée — elle reste à l'intérieur du KMS de destination.

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 est un crypto.PublicKey (*rsa.PublicKey pour une clé de transport RSA)

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

Encapsuler le matériel de clé source

Sur l'environnement source, chiffrez le matériel de clé avec la clé RSA publique de destination.

Cette étape se déroule en dehors d'OVHcloud KMS : utilisez une bibliothèque JOSE sur l'environnement source.

Algorithmes d'encapsulation pris en charge (RFC 7518) :

keyFormatType décrit le format du matériel de clé en clair avant encapsulation et après désencapsulation. Le ciphertext est toujours une chaîne JWE Compact Serialization (l'algorithme d'encapsulation est porté dans l'en-tête JWE).

Après encapsulation avec la clé publique de destination, envoyez le ciphertext JWE Compact Serialization obtenu dans la requête d'import. Pour un exemple en Go de cette étape d'encapsulation, reportez-vous à la section « Exemple de bout en bout en Go ».

Importer la clé encapsulée

Appelez POST /api/{okmsId}/v1/servicekey avec un tableau wrappedKeys au lieu de keys en clair.

Chaque entrée de wrappedKeys :

Vous pouvez importer une clé uniquement publique (class devient PUBLIC_KEY) ou une clé privée (le KMS reconstruit la partie publique ; class devient KEY_PAIR). Le matériel symétrique est stocké comme SECRET_KEY.

Actions IAM sur cet appel : okms:apikms:serviceKey/create, okms:apikms:serviceKey/import et okms:apikms:serviceKey/unwrapKey sur la clé de transport.

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

Vérifier la clé importée

Confirmez que la clé existe et correspond au type et aux opérations attendus.

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
}

Vérifiez que :

• l'état (state) de la clé est active (ou activez-la si votre workflow l'exige).
• type, size et operations correspondent à ce que vous attendez.
• les attributs de sensibilité sous attributes reflètent une clé importée (never_extractable vaut false).

Vous pouvez ensuite utiliser la clé pour encrypt, decrypt, sign ou verify, comme documenté dans le guide « Utiliser votre OVHcloud Key Management Service (KMS) ».

Exporter une clé encapsulée

L'export sécurisé est l'inverse de l'import : OVHcloud KMS chiffre le matériel de clé avec une clé de transport RSA et ne renvoie qu'un ciphertext JWE. La clé de transport privée doit résider dans l'environnement de destination — ici le système externe qui reçoit la clé, et non OVHcloud KMS — afin que seul cet environnement puisse désencapsuler le matériel.

Comprendre la cérémonie d'export

1. Générez une paire de clés RSA de transport sur l'environnement de destination (un autre KMS ou un outil qui recevra la clé).
2. Importez la clé de transport publique de destination dans OVHcloud KMS avec l'opération wrapKey. Cette clé est le wrappingKeyId utilisé au moment de l'export.
3. Sur OVHcloud KMS, exportez la clé de service encapsulée par cette clé de transport. La clé doit avoir été créée ou importée avec extractable défini à true. Définissez ensuite extractable à false lorsque c'est possible.
4. Transférez le ciphertext vers la destination et désencapsulez-le avec la clé de transport privée de destination.

La clé de transport référencée par wrappingKeyId doit être une clé RSA dans le même domaine OKMS, avec l'usage wrapKey. Pour exporter une clé stockée dans le HSM, reportez-vous à la section « Utiliser le BYOK avec des clés HSM ». Les clés sensibles (matériel AES/oct et RSA/EC privé) ne peuvent être extraites qu'après encapsulation — l'extraction en clair n'est pas prise en charge pour ces clés.

Importer la clé de transport publique de destination dans OVHcloud KMS

Enregistrez la clé publique de destination pour qu'OVHcloud KMS puisse encapsuler la clé exportée avec elle. Importez-la comme clé RSA uniquement publique avec wrapKey (sans matériel privé).

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

Conservez l'id de la clé renvoyée comme wrappingKeyId.

Activer l'extraction

La clé que vous exportez doit être extractible, et cela se décide à la création ou à l'import de la clé. Ensuite, extractable peut uniquement passer de true à false : une fois défini à false, il ne peut plus jamais être remis à true. Une clé créée ou importée sans extractable défini à true ne pourra donc jamais être exportée. Cette règle s'applique aussi bien aux clés SOFTWARE qu'aux clés HSM.

Définissez extractable à true lors de la création de la clé :

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

Pour un import, définissez "extractable": true dans le corps de la requête (API REST), ajoutez --extractable (CLI OKMS) ou passez okms.WithExtractable(true) (SDK Go).

Lorsque la clé n'a plus besoin d'être exportée, par exemple après un export encapsulé réussi (reportez-vous à la section « Exporter la clé encapsulée par la clé de transport »), désactivez l'extraction. Cette opération est irréversible. Action 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
}

Exporter la clé encapsulée par la clé de transport

Appelez GET /api/{okmsId}/v1/servicekey/{keyId} avec les paramètres de requête d'encapsulation ci-dessous. Lorsque ces paramètres sont présents, l'API renvoie wrappedKeys au lieu de keys en clair.

Actions IAM : okms:apikms:serviceKey/get sur la clé exportée, et okms:apikms:serviceKey/wrapKey sur la clé de transport.

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

Désencapsuler le ciphertext sur la destination

Transférez le ciphertext vers l'environnement de destination. Désencapsulez-le avec la clé de transport privée de destination (la contrepartie de la clé publique que vous avez importée dans OVHcloud KMS).

• Si la destination est un autre domaine OKMS, importez-y le matériel encapsulé avec wrappedKeys comme dans la section « Importer la clé encapsulée », en utilisant l'identifiant de la clé de transport de ce domaine comme wrappingKeyId.
• Si la destination est un système externe, utilisez son API native de désencapsulation ou d'import, avec la clé de transport privée, le même keyFormatType et le même algorithme d'encapsulation qu'à l'export.

Utiliser le BYOK avec des clés HSM

Avec le niveau de protection HSM, le matériel de clé est encapsulé et désencapsulé à l'intérieur du HSM : il n'apparaît jamais en clair dans OVHcloud KMS. Le format JWE est le même que pour les clés SOFTWARE (RSA-OAEP ou RSA-OAEP-256 avec A256GCM).

La clé de transport doit être stockée dans le HSM dès que la clé importée ou exportée y est stockée, comme le résume le tableau ci-dessous :

Les imports dans le HSM décrits ci-dessous ne sont présentés qu'avec l'API REST.

Créer une clé de transport HSM

Pour importer une clé dans le HSM, créez la clé de transport avec le niveau de protection 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

Exportez ensuite sa clé publique et encapsulez le matériel de clé sur la source, comme décrit dans les sections « Obtenir la clé de transport publique » et « Encapsuler le matériel de clé source ».

Importer une clé dans le HSM

Comme le HSM n'expose jamais le matériel désencapsulé, OVHcloud KMS ne peut pas déduire le type de clé. La requête d'import diffère de celle d'un import SOFTWARE :

• Définissez protectionLevel à HSM. La clé de transport doit elle aussi être une clé HSM.
• Déclarez type : oct, RSA ou EC. Ne définissez pas size ni curve pour RSA et EC : le HSM les lit à partir de la clé. Pour oct, size est facultatif (128, 192 ou 256).
• Ne définissez pas keyFormatType dans wrappedKeys. Le texte en clair encapsulé dans le JWE doit correspondre aux octets bruts de la clé pour une clé oct, et à la clé privée en PKCS#8 (DER) pour une clé RSA ou EC.
• Clés prises en charge : AES 128, 192 ou 256 bits, RSA 2048, 3072 ou 4096 bits, EC P-256, P-384 ou P-521. Une clé publique seule ne peut pas être importée encapsulée dans le HSM : seul l'import en clair est possible.

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>"
      }
    ]
  }'

Une clé de transport HSM peut aussi désencapsuler une clé SOFTWARE : dans ce cas, suivez la section « Importer la clé encapsulée » avec keyFormatType.

Exporter une clé depuis le HSM

Seules les clés symétriques (oct) peuvent être exportées depuis le HSM : le HSM ne libère jamais les clés privées RSA ou EC. Comme pour une clé SOFTWARE, la clé doit avoir été créée ou importée avec extractable défini à true, ce qui ne peut pas être activé ensuite (reportez-vous à la section « Activer l'extraction »).

La clé de transport doit être stockée dans le HSM. Importez la clé de transport publique de destination avec le niveau de protection 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"]
      }
    ]
  }'

Exportez ensuite la clé en définissant wrappedKeyFormat à RAW : le HSM encapsule toujours les octets bruts de la clé, donc la charge utile du JWE déchiffré est la clé AES elle-même (32 octets pour une clé de 256 bits).

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

Sur la destination, déchiffrez le JWE avec la clé de transport privée, comme décrit dans la section « Désencapsuler le ciphertext sur la destination ».

Exemple de bout en bout en Go

Les exemples suivants déroulent les deux cérémonies sur une paire de clés RSA, en utilisant le SDK Go pour les appels à OVHcloud KMS et go-jose pour les opérations JWE réalisées en dehors d'OVHcloud KMS. Les deux exemples encodent le matériel de clé en PKCS#8 (DER), ce qui correspond à la valeur PKCS8 de keyFormatType.

Importer une clé générée localement

Le programme génère la clé avec la bibliothèque standard Go, l'encapsule localement avec la clé de transport publique, puis l'importe. Le matériel de clé n'est jamais envoyé en clair à OVHcloud KMS.

// 1. Créer la clé de transport sur OVHcloud KMS et récupérer sa partie publique.
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. Générer la clé à importer et l'encoder en 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. Encapsuler le matériel de clé sous forme de JWE : encapsulation de clé RSA-OAEP-256, chiffrement du contenu 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. Importer la clé encapsulée. Le KMS la désencapsule et déduit le type et la taille à partir du matériel de clé.
// Elle est importée comme extractible pour que l'exemple suivant puisse l'exporter : cela ne peut pas être activé ensuite.
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

L'algorithme de chiffrement du contenu JWE (enc) doit être A256GCM.

Exporter une clé et déchiffrer le JWE

La destination (ici, le programme local) génère la paire de clés de transport, importe uniquement sa partie publique dans OVHcloud KMS, puis déchiffre, avec la partie privée, le JWE exporté.

// Identifiant de la clé de service à exporter, par exemple la clé importée dans l'exemple précédent.
keyID := uuid.MustParse("<key-id>")

// 1. Générer la paire de clés de transport sur la destination.
destKey, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
  return err
}

// 2. Importer uniquement sa partie publique dans OVHcloud KMS, avec l'usage wrapKey.
wrappingKey, err := okmsClient.ImportKey(
  ctx,
  okmsId,
  &destKey.PublicKey,
  "byok-export-transport-pub",
  "",
  []types.CryptographicUsages{types.WrapKey},
)
if err != nil {
  return err
}

// 3. Exporter la clé encapsulée par la clé publique de destination. La clé doit avoir été créée ou
// importée comme extractible. L'extraction est désactivée une fois l'export terminé, ce qui est irréversible.
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. Déchiffrer le JWE avec la clé privée de destination et analyser le matériel de clé 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 contient le matériel de clé exporté, utilisé dans la suite du programme.

Aller plus loin

Utiliser votre OVHcloud Key Management Service (KMS)

Méthodes d'authentification OKMS

Premiers pas avec OVHcloud Key Management Service (KMS)

Échangez avec notre communauté d'utilisateurs.