Importar e exportar chaves no OVHcloud KMS com BYOK

Objetivo

Bring Your Own Key (BYOK) permite-lhe importar e exportar material de chave criptográfico com o OVHcloud Key Management Service (KMS) sem o enviar em texto claro. Um par de chaves RSA de transporte protege o material em trânsito: a chave pública encapsula-o e apenas o detentor da chave privada o pode desencapsular.

Este guia explica como importar e exportar uma chave com o OVHcloud KMS utilizando encapsulamento de chave RSA assimétrico (BYOK).

Requisitos

• Dispor de uma conta de cliente OVHcloud.
• Ter encomendado um KMS OVHcloud.
• Ter configurado um método de autenticação para o plano de dados OKMS (token de acesso pessoal, conta de serviço ou certificado de acesso).
• Poder aplicar uma política IAM no seu domínio OKMS; as ações BYOK necessárias estão listadas em Configurar o IAM para o BYOK.
• Opcional: a CLI OKMS (versão 0.6.0 ou superior) ou o SDK Go instalado para os exemplos nos separadores.

Instruções

Compreender a cerimónia de encapsulamento RSA

A cerimónia envolve dois ambientes e um operador:

• Destino (Dst): o seu domínio OKMS, onde a chave importada será armazenada.
• Origem (Src): o sistema que detém atualmente o material de chave (outro KMS, uma aplicação ou uma ferramenta como o OpenSSL).
• Operator: a entidade que dispõe das permissões necessárias para aceder tanto ao domínio OKMS como à origem da chave a importar. Pode ser uma pessoa que utiliza o CLI OKMS ou um serviço que atua através da API.

1. Gere um par de chaves RSA de transporte no OVHcloud KMS com as operações wrapKey e unwrapKey.
2. Exporte a chave de transporte pública do OVHcloud KMS.
3. Importe a chave de transporte pública no ambiente de origem.
4. Na origem, exporte o material de chave encapsulado (encriptado) com a chave de transporte utilizando RSA-OAEP ou RSA-OAEP-256.
5. No destino, importe a chave encapsulada com POST /api/{okmsId}/v1/servicekey e uma carga útil wrappedKeys. O KMS desencapsula o ciphertext com a chave de transporte privada e armazena a chave de serviço resultante.

As chaves importadas desta forma têm never_extractable definido como false, porque o material existia fora do KMS antes da importação. Para extrair posteriormente uma chave sob forma encapsulada, importe-a com extractable definido como true (não pode ser ativado posteriormente) e siga Exportar uma chave encapsulada. Consulte Atributos de sensibilidade das chaves de serviço para a lista completa de atributos.

Configurar o IAM para o BYOK

Aplique uma política ao recurso do seu domínio OKMS. O respetivo URN é apresentado no separador Informações gerais do dashboard do seu domínio OKMS. Substitua <identity_urn> e <okms_urn> pelos seus valores. Crie as políticas através da Área de Cliente OVHcloud ou da API OVHcloud.

Importação BYOK — ler, criar ou importar chaves de serviço e desencapsular com uma chave de transporte:

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

Exportação BYOK — importar uma chave de transporte pública, atualizar a extraibilidade e encapsular uma chave para exportação:

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

Criar a chave de transporte RSA no KMS de destino

Crie uma chave RSA dedicada ao encapsulamento. Para a cerimónia de importação, defina nesta chave tanto wrapKey como unwrapKey; são mutuamente exclusivas com sign e verify.

Tamanhos de chave RSA suportados: 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

Guarde o id da chave devolvida — irá precisar dele como wrappingKeyId durante a importação.

Obter a chave de transporte pública

Exporte a parte pública da chave de transporte e forneça-a ao ambiente de origem. Nunca partilhe a chave privada — ela permanece dentro do KMS de destino.

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 é um crypto.PublicKey (*rsa.PublicKey para uma chave de transporte RSA)

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

Encapsular o material de chave de origem

No ambiente de origem, encripte o material de chave com a chave RSA pública de destino.

Este passo é realizado fora do OVHcloud KMS: utilize uma biblioteca JOSE no ambiente de origem.

Algoritmos de encapsulamento suportados (RFC 7518):

keyFormatType descreve o formato do material de chave em texto claro antes do encapsulamento e após o desencapsulamento. O ciphertext é sempre uma cadeia JWE Compact Serialization (o algoritmo de encapsulamento é transportado no cabeçalho JWE).

Após o encapsulamento com a chave pública de destino, envie no pedido de importação o ciphertext JWE Compact Serialization resultante. Para um exemplo em Go deste passo de encapsulamento, consulte Exemplo de ponta a ponta em Go.

Importar a chave encapsulada

Invoque POST /api/{okmsId}/v1/servicekey com um array wrappedKeys em vez de keys em texto claro.

Cada entrada de wrappedKeys:

Pode importar uma chave apenas pública (class passa a PUBLIC_KEY) ou uma chave privada (o KMS reconstrói a parte pública; class passa a KEY_PAIR). O material simétrico é armazenado como SECRET_KEY.

Ações IAM nesta chamada: okms:apikms:serviceKey/create, okms:apikms:serviceKey/import e okms:apikms:serviceKey/unwrapKey na chave de transporte.

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

Verificar a chave importada

Confirme que a chave existe e corresponde ao tipo e às operações esperadas.

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
}

Verifique que:

• o state da chave é active (ou ative-a se o seu fluxo de trabalho o exigir).
• type, size e operations correspondem ao esperado.
• os atributos de sensibilidade em attributes refletem uma chave importada (never_extractable vale false).

Pode depois utilizar a chave para encrypt, decrypt, sign ou verify, conforme documentado em Utilizar o seu OVHcloud Key Management Service (KMS).

Exportar uma chave encapsulada

A exportação segura é o inverso da importação: o OVHcloud KMS encripta o material de chave com uma chave de transporte RSA e devolve apenas um ciphertext JWE. A chave de transporte privada deve residir no ambiente de destino — aqui o sistema externo que recebe a chave, não o OVHcloud KMS — para que apenas esse ambiente possa desencapsular o material.

Compreender a cerimónia de exportação

1. Gere um par de chaves RSA de transporte no ambiente de destino (outro KMS ou uma ferramenta que receberá a chave).
2. Importe a chave de transporte pública de destino no OVHcloud KMS com a operação wrapKey. Esta chave é o wrappingKeyId utilizado no momento da exportação.
3. No OVHcloud KMS, exporte a chave de serviço encapsulada por essa chave de transporte. A chave deve ter sido criada ou importada com extractable definido como true. Defina depois extractable como false quando possível.
4. Transfira o ciphertext para o destino e desencapsule-o com a chave de transporte privada de destino.

A chave de transporte referenciada por wrappingKeyId deve ser uma chave RSA no mesmo domínio OKMS, com a utilização wrapKey. Para exportar uma chave armazenada no HSM, consulte Utilizar o BYOK com chaves HSM. As chaves sensíveis (material AES/oct e RSA/EC privado) só podem ser extraídas após encapsulamento — a extração em texto claro não é suportada para essas chaves.

Importar a chave de transporte pública de destino no OVHcloud KMS

Registe a chave pública de destino para que o OVHcloud KMS possa encapsular com ela a chave exportada. Importe-a como chave RSA apenas pública com wrapKey (sem material privado).

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

Guarde o id da chave devolvida como wrappingKeyId.

Ativar a extração

A chave que exporta deve ser extraível, e isso é decidido na criação ou na importação da chave. Depois, extractable só pode passar de true para false: uma vez definido como false, nunca mais pode voltar a ser definido como true. Uma chave criada ou importada sem extractable definido como true nunca poderá, portanto, ser exportada. Esta regra aplica-se tanto às chaves SOFTWARE como às chaves HSM.

Defina extractable como true ao criar a chave:

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

Para uma importação, defina "extractable": true no corpo do pedido (API REST), adicione --extractable (CLI OKMS) ou passe okms.WithExtractable(true) (SDK Go).

Quando a chave já não precisar de ser exportada, por exemplo após uma exportação encapsulada bem-sucedida (consulte Exportar a chave encapsulada com a chave de transporte), desative a extração. Esta operação é irreversível. Ação 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
}

Exportar a chave encapsulada com a chave de transporte

Invoque GET /api/{okmsId}/v1/servicekey/{keyId} com os parâmetros de consulta de encapsulamento abaixo. Quando estes parâmetros estão presentes, a API devolve wrappedKeys em vez de keys em texto claro.

Ações IAM: okms:apikms:serviceKey/get na chave exportada e okms:apikms:serviceKey/wrapKey na chave de transporte.

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

Desencapsular o ciphertext no destino

Transfira o ciphertext para o ambiente de destino. Desencapsule-o com a chave de transporte privada de destino (a contraparte da chave pública que importou no OVHcloud KMS).

• Se o destino for outro domínio OKMS, importe aí o material encapsulado com wrappedKeys como em Importar a chave encapsulada, utilizando o identificador da chave de transporte desse domínio como wrappingKeyId.
• Se o destino for um sistema externo, utilize a respetiva API nativa de desencapsulamento / importação com a chave de transporte privada e o mesmo keyFormatType / algoritmo de encapsulamento que na exportação.

Utilizar o BYOK com chaves HSM

Com o nível de proteção HSM, o material de chave é encapsulado e desencapsulado dentro do HSM: nunca aparece em texto claro no OVHcloud KMS. O formato JWE é o mesmo que para as chaves SOFTWARE (RSA-OAEP ou RSA-OAEP-256 com A256GCM).

A chave de transporte deve estar armazenada no HSM sempre que a chave importada ou exportada estiver armazenada nele, como resume a tabela seguinte:

As importações no HSM descritas abaixo só são apresentadas com a API REST.

Criar uma chave de transporte HSM

Para importar uma chave no HSM, crie a chave de transporte com o nível de proteção 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

Em seguida, exporte a respetiva chave pública e encapsule o material de chave na origem, conforme descrito em Obter a chave de transporte pública e Encapsular o material de chave de origem.

Importar uma chave no HSM

Como o HSM nunca expõe o material desencapsulado, o OVHcloud KMS não pode deduzir o tipo de chave. O pedido de importação difere do pedido de uma importação SOFTWARE:

• Defina protectionLevel como HSM. A chave de transporte também deve ser uma chave HSM.
• Declare type: oct, RSA ou EC. Não defina size nem curve para RSA e EC: o HSM lê-os a partir da chave. Para oct, size é opcional (128, 192 ou 256).
• Não defina keyFormatType em wrappedKeys. O texto claro encapsulado no JWE deve corresponder aos bytes brutos da chave para uma chave oct, e à chave privada em PKCS#8 (DER) para uma chave RSA ou EC.
• Chaves suportadas: AES de 128, 192 ou 256 bits, RSA de 2048, 3072 ou 4096 bits, EC P-256, P-384 ou P-521. Uma chave pública isolada não pode ser importada encapsulada no HSM: apenas a importação em texto claro é possível.

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

Uma chave de transporte HSM também pode desencapsular uma chave SOFTWARE: nesse caso, siga Importar a chave encapsulada com keyFormatType.

Exportar uma chave a partir do HSM

Apenas as chaves simétricas (oct) podem ser exportadas a partir do HSM: o HSM nunca liberta as chaves privadas RSA ou EC. Tal como para uma chave SOFTWARE, a chave deve ter sido criada ou importada com extractable definido como true, o que não pode ser ativado posteriormente (consulte Ativar a extração).

A chave de transporte deve estar armazenada no HSM. Importe a chave de transporte pública de destino com o nível de proteção 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"]
      }
    ]
  }'

Em seguida, exporte a chave definindo wrappedKeyFormat como RAW: o HSM encapsula sempre os bytes brutos da chave, pelo que a carga útil do JWE desencriptado é a própria chave AES (32 bytes para uma chave 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

No destino, desencripte o JWE com a chave de transporte privada, conforme descrito em Desencapsular o ciphertext no destino.

Exemplo de ponta a ponta em Go

Os exemplos seguintes executam as duas cerimónias com um par de chaves RSA, utilizando o SDK Go para as chamadas ao OVHcloud KMS e o go-jose para as operações JWE realizadas fora do OVHcloud KMS. Ambos os exemplos codificam o material de chave em PKCS#8 (DER), o que corresponde ao valor PKCS8 de keyFormatType.

Importar uma chave gerada localmente

O programa gera a chave com a biblioteca padrão de Go, encapsula-a localmente com a chave de transporte pública e depois importa-a. O material de chave nunca é enviado em texto claro para o OVHcloud KMS.

// 1. Crie a chave de transporte no OVHcloud KMS e obtenha a sua parte pública.
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. Gere a chave a importar e codifique-a em 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. Encapsule o material de chave como JWE: encapsulamento de chave RSA-OAEP-256, encriptação do conteúdo 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. Importe a chave encapsulada. O KMS desencapsula-a e deduz o tipo e o tamanho a partir do material.
// É importada como extraível para que o exemplo seguinte a possa exportar: isto não pode ser ativado posteriormente.
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

O algoritmo de encriptação do conteúdo JWE (enc) deve ser A256GCM.

Exportar uma chave e desencriptar o JWE

O destino (aqui, o programa local) gera o par de chaves de transporte, importa apenas a sua parte pública no OVHcloud KMS e, em seguida, desencripta, com a parte privada, o JWE exportado.

// Identificador da chave de serviço a exportar, por exemplo a chave importada no exemplo anterior.
keyID := uuid.MustParse("<key-id>")

// 1. Gere o par de chaves de transporte no destino.
destKey, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
  return err
}

// 2. Importe apenas a sua parte pública no OVHcloud KMS, com a utilização wrapKey.
wrappingKey, err := okmsClient.ImportKey(
  ctx,
  okmsId,
  &destKey.PublicKey,
  "byok-export-transport-pub",
  "",
  []types.CryptographicUsages{types.WrapKey},
)
if err != nil {
  return err
}

// 3. Exporte a chave encapsulada pela chave pública de destino. A chave deve ter sido criada ou
// importada como extraível. A extração é desativada após a exportação, o que é irreversível.
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. Desencripte o JWE com a chave privada de destino e analise o material 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 contém o material de chave exportado, utilizado no resto do programa.

Quer saber mais?

Utilizar o seu OVHcloud Key Management Service (KMS)

Métodos de autenticação OKMS

Primeiros passos com OVHcloud Key Management Service (KMS)

Fale com a nossa comunidade de utilizadores.