Biblioteca de cliente do Azure Key Vault Key para JavaScript - versão 4.10.0

O Azure Key Vault é um serviço que permite criptografar chaves de autenticação, chaves de conta de armazenamento, chaves de criptografia de dados, arquivos .pfx e senhas usando chaves seguras. Se quiser saber mais sobre o Azure Key Vault, consulte: O que é o Azure Key Vault?

O Azure Key Vault Managed HSM é um serviço de nuvem totalmente gerenciado, altamente disponível, de locatário único e compatível com os padrões que permite proteger chaves criptográficas para seus aplicativos em nuvem usando HSMs validados pelo FIPS 140-2 Nível 3. Se quiser saber mais sobre o Azure Key Vault Managed HSM, convém analisar: O que é o Azure Key Vault Managed HSM?

O cliente da biblioteca de chaves do Azure Key Vault suporta chaves RSA, chaves Elliptic Curve (EC), bem como chaves simétricas (oct) quando executadas em um HSM gerenciado, cada uma com suporte correspondente em módulos de segurança de hardware (HSM). Ele oferece operações para criar, recuperar, atualizar, excluir, limpar, fazer backup, restaurar e listar as chaves e suas versões.

Use a biblioteca de cliente para Chaves do Cofre de Chaves do Azure em seu aplicativo Node.js para:

Crie chaves usando curva elíptica ou criptografia RSA, opcionalmente apoiada por módulos de segurança de hardware (HSM).
Importe, exclua e atualize as chaves.
Obtenha uma ou mais chaves e chaves excluídas, com seus atributos.
Recupere uma chave excluída e restaure uma chave de backup.
Obtenha as versões de uma chave.

Usando o cliente de criptografia disponível nesta biblioteca, você também tem acesso a:

Encriptação
Desencriptação
Assinatura
Verificação
Teclas de embrulho
Desembrulhar chaves

Observação: este pacote não pode ser usado no navegador devido a limitações do serviço Azure Key Vault, consulte este documento para obter orientação.

Ligações principais:

Código fonte
Pacote (npm)
de documentação de referência da API
Documentação do produto
Amostras

Como Começar

Ambientes atualmente suportados

Versões LTS do Node.js

Pré-requisitos

Uma assinatura do Azure
Um existente do Azure Key Vault. Se precisar de criar um cofre de chaves, pode fazê-lo no Portal do Azure seguindo os passos indicados em este documento. Como alternativa, use a CLI do Azure seguindo estas etapas.
Se estiver usando o HSM gerenciado, um HSM gerenciado do Azure Key Vault existente. Se você precisar criar um HSM gerenciado, poderá fazê-lo usando a CLI do Azure seguindo as etapas em este documento.

Instale o pacote

Instalar a biblioteca de cliente do Azure Key Vault Key usando npm

npm install @azure/keyvault-keys

Instalar a biblioteca de identidades

Os clientes do Azure Key Vault são autenticados usando a biblioteca de identidades do Azure. Instale-o também usando npm

npm install @azure/identity

Configurar o TypeScript

Os usuários do TypeScript precisam ter definições de tipo de nó instaladas:

npm install @types/node

Você também precisa ativar compilerOptions.allowSyntheticDefaultImports em seu tsconfig.json. Observe que, se você tiver habilitado compilerOptions.esModuleInterop, allowSyntheticDefaultImports está habilitado por padrão. Consulte manual de opções do compilador do TypeScript para obter mais informações.

Conceitos-chave

O de cliente Key é a interface principal para interagir com os métodos de API relacionados a chaves na API do Azure Key Vault de um aplicativo JavaScript. Uma vez inicializado, ele fornece um conjunto básico de métodos que podem ser usados para criar, ler, atualizar e excluir chaves.
Uma versão Key é uma versão de uma chave no Cofre da Chave. Cada vez que um usuário atribui um valor a um nome de chave exclusivo, uma nova versão dessa chave é criada. Recuperar uma chave por um nome sempre retornará o valor mais recente atribuído, a menos que uma versão específica seja fornecida à consulta.
Soft delete permite que os Cofres de Chaves suportem a exclusão e a limpeza como duas etapas separadas, para que as chaves excluídas não sejam imediatamente perdidas. Isso só acontece se o Cofre da Chave tiver de exclusão suave habilitada.
Um de backup de chave pode ser gerado a partir de qualquer chave criada. Esses backups vêm como dados binários e só podem ser usados para regenerar uma chave excluída anteriormente.
O do cliente Cryptography é uma interface separada que interage com os métodos da API de chaves na API do Cofre da Chave. Este cliente concentra-se apenas nas operações de criptografia que podem ser executadas usando uma chave que já foi criada no Cofre de Chaves. Mais informações sobre este cliente na seção Criptografia.

Autenticação com o Azure Ative Directory

O serviço Cofre da Chave depende do Azure Ative Directory para autenticar solicitações para suas APIs. O pacote @azure/identity fornece uma variedade de tipos de credenciais que seu aplicativo pode usar para fazer isso. O README para @azure/identity fornece mais detalhes e exemplos para você começar.

Para interagir com o serviço Azure Key Vault, você precisará criar uma instância da classe , um de URL do cofre e um objeto de credencial. Os exemplos mostrados neste documento usam um objeto de credencial chamado DefaultAzureCredential, que é apropriado para a maioria dos cenários, incluindo ambientes de desenvolvimento local e produção. Além disso, recomendamos o uso de um de identidade gerenciado para autenticação em ambientes de produção.

Você pode encontrar mais informações sobre diferentes maneiras de autenticação e seus tipos de credenciais correspondentes na documentação do Azure Identity.

Aqui está um exemplo rápido. Primeiro, importe DefaultAzureCredential e KeyClient. Depois que eles forem importados, podemos nos conectar em seguida ao serviço Cofre de Chaves:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

// Build the URL to reach your key vault
const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`; // or `https://${vaultName}.managedhsm.azure.net` for managed HSM.

// Lastly, create our keys client and connect to the service
const client = new KeyClient(url, credential);

Especificando a versão da API do serviço Azure Key Vault

Por padrão, esse pacote usa a versão mais recente do serviço Azure Key Vault, que é 7.2. Você pode alterar a versão de serviço que está sendo usada definindo a opção serviceVersion no construtor do cliente, conforme mostrado abaixo:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

// Build the URL to reach your key vault
const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`; // or `https://${vaultName}.managedhsm.azure.net` for managed HSM.

// Change the Azure Key Vault service API version being used via the `serviceVersion` option
const client = new KeyClient(url, credential, {
  serviceVersion: "7.0", // Or 7.1
});

Exemplos

As seções a seguir fornecem trechos de código que abrangem algumas das tarefas comuns usando as Chaves do Cofre da Chave do Azure. Os cenários aqui abordados consistem em:

Criando uma chave.
Obter uma chave.
Criação e atualização de chaves com atributos.
Excluir uma chave.
Iteração de listas de chaves.

Criando uma chave

createKey cria uma chave para ser armazenada no Cofre de Chaves do Azure. Se já existir uma chave com o mesmo nome, será criada uma nova versão da chave.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";
const result = await client.createKey(keyName, "RSA");
console.log("result: ", result);

O segundo parâmetro enviado para createKey é o tipo da chave. O tipo de chaves com suporte dependerá da SKU e se você estiver usando um Cofre de Chaves do Azure ou um HSM Gerenciado do Azure. Para obter uma lista de up-to-date dos tipos de chaves suportados, consulte Sobre chaves

Obter uma chave

A maneira mais simples de ler as chaves de volta do cofre é obter uma chave pelo nome. Isso recuperará a versão mais recente da chave. Opcionalmente, você pode obter uma versão diferente da chave se especificá-la como parte dos parâmetros opcionais.

getKey recupera uma chave armazenada anteriormente no Cofre de Chaves.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const latestKey = await client.getKey(keyName);
console.log(`Latest version of the key ${keyName}: `, latestKey);

const specificKey = await client.getKey(keyName, { version: latestKey.properties.version! });
console.log(`The key ${keyName} at the version ${latestKey.properties.version!}: `, specificKey);

Criação e atualização de chaves com atributos

Os seguintes atributos também podem ser atribuídos a qualquer chave em um Cofre de Chaves:

tags: Qualquer conjunto de valores-chave que podem ser usados para pesquisar e filtrar chaves.
keyOps: Uma matriz das operações que esta chave será capaz de executar (encrypt, decrypt, sign, verify, wrapKey, unwrapKey).
enabled: Um valor booleano que determina se o valor da chave pode ser lido ou não.
notBefore: Uma determinada data após a qual o valor da chave pode ser recuperado.
expires: Uma determinada data após a qual o valor da chave não pode ser recuperado.

Um objeto com esses atributos pode ser enviado como o terceiro parâmetro de createKey, logo após o nome e o valor da chave, da seguinte maneira:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const result = await client.createKey(keyName, "RSA", {
  enabled: false,
});
console.log("result: ", result);

Isso criará uma nova versão da mesma chave, que terá os atributos fornecidos mais recentes.

Os atributos também podem ser atualizados para uma versão de chave existente com updateKeyProperties, da seguinte maneira:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const result = await client.createKey(keyName, "RSA");
await client.updateKeyProperties(keyName, result.properties.version, {
  enabled: false,
});

Eliminar uma chave

O método beginDeleteKey inicia a exclusão de uma chave. Este processo acontecerá em segundo plano assim que os recursos necessários estiverem disponíveis.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const poller = await client.beginDeleteKey(keyName);
await poller.pollUntilDone();

Se de exclusão suave estiver habilitada para o Cofre da Chave, essa operação rotulará apenas a chave como uma chave excluída. Uma chave excluída não pode ser atualizada. Eles só podem ser lidos, recuperados ou expurgados.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const poller = await client.beginDeleteKey(keyName);

// You can use the deleted key immediately:
const deletedKey = poller.getResult();

// The key is being deleted. Only wait for it if you want to restore it or purge it.
await poller.pollUntilDone();

// You can also get the deleted key this way:
await client.getDeletedKey(keyName);

// Deleted keys can also be recovered or purged:

// recoverDeletedKey also returns a poller, just like beginDeleteKey.
const recoverPoller = await client.beginRecoverDeletedKey(keyName);
await recoverPoller.pollUntilDone();

// And here is how to purge a deleted key
await client.purgeDeletedKey(keyName);

Como as chaves levam algum tempo para serem totalmente excluídas, beginDeleteKey retorna um objeto Poller que controla a operação de longa execução subjacente de acordo com nossas diretrizes: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

O poller recebido permitirá que você obtenha a chave excluída ligando para poller.getResult(). Você também pode esperar até que a exclusão termine executando chamadas de serviço individuais até que a chave seja excluída ou aguardando até que o processo seja concluído:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const poller = await client.beginDeleteKey(keyName);

// You can use the deleted key immediately:
let deletedKey = poller.getResult();

// Or you can wait until the key finishes being deleted:
deletedKey = await poller.pollUntilDone();
console.log(deletedKey);

Outra maneira de esperar até que a chave seja totalmente excluída é fazer chamadas individuais, da seguinte maneira:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const poller = await client.beginDeleteKey(keyName);

while (!poller.isDone()) {
  await poller.poll();
  await delay(5000);
}

console.log(`The key ${keyName} is fully deleted`);

Configurando a rotação automática de chaves

Usando o KeyClient, você pode configurar a rotação automática de chaves para uma chave especificando a política de rotação. Além disso, KeyClient fornece um método para girar uma chave sob demanda criando uma nova versão da chave fornecida.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

// Set the key's automated rotation policy to rotate the key 30 days before expiry.
const policy = await client.updateKeyRotationPolicy(keyName, {
  lifetimeActions: [
    {
      action: "Rotate",
      timeBeforeExpiry: "P30D",
    },
  ],
  // You may also specify the duration after which any newly rotated key will expire.
  // In this case, any new key versions will expire after 90 days.
  expiresIn: "P90D",
});

// You can get the current key rotation policy of a given key by calling the getKeyRotationPolicy method.
const currentPolicy = await client.getKeyRotationPolicy(keyName);

// Finally, you can rotate a key on-demand by creating a new version of the given key.
const rotatedKey = await client.rotateKey(keyName);

Iteração de listas de chaves

Usando o KeyClient, você pode recuperar e iterar através de todas as chaves em um Cofre de Chaves do Azure, bem como através de todas as chaves excluídas e as versões de uma chave específica. Os seguintes métodos de API estão disponíveis:

listPropertiesOfKeys listará todas as suas chaves não excluídas por seus nomes, apenas em suas versões mais recentes.
listDeletedKeys listará todas as suas chaves excluídas por seus nomes, apenas em suas versões mais recentes.
listPropertiesOfKeyVersions listará todas as versões de uma chave com base em um nome de chave.

Que pode ser usado da seguinte forma:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

for await (const keyProperties of client.listPropertiesOfKeys()) {
  console.log("Key properties: ", keyProperties);
}

for await (const deletedKey of client.listDeletedKeys()) {
  console.log("Deleted: ", deletedKey);
}

for await (const versionProperties of client.listPropertiesOfKeyVersions(keyName)) {
  console.log("Version properties: ", versionProperties);
}

Todos esses métodos retornarão todos os resultados disponíveis de uma só vez. Para recuperá-los por páginas, adicione .byPage() logo após invocar o método de API que você deseja usar, da seguinte maneira:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

for await (const page of client.listPropertiesOfKeys().byPage()) {
  for (const keyProperties of page) {
    console.log("Key properties: ", keyProperties);
  }
}

for await (const page of client.listDeletedKeys().byPage()) {
  for (const deletedKey of page) {
    console.log("Deleted key: ", deletedKey);
  }
}

for await (const page of client.listPropertiesOfKeyVersions(keyName).byPage()) {
  for (const versionProperties of page) {
    console.log("Version: ", versionProperties);
  }
}

Criptografia

Esta biblioteca também oferece um conjunto de utilitários criptográficos disponíveis através do CryptographyClient. Semelhante ao KeyClient, CryptographyClient se conectará ao Cofre de Chaves do Azure com o conjunto de credenciais fornecido. Uma vez conectado, CryptographyClient pode criptografar, descriptografar, assinar, verificar, encapsular chaves e desembrulhar chaves.

Em seguida, podemos nos conectar ao serviço de cofre de chaves, assim como fazemos com o KeyClient. Precisaremos copiar algumas configurações do cofre de chaves ao qual estamos nos conectando para nossas variáveis de ambiente. Uma vez que eles estão em nosso ambiente, podemos acessá-los com o seguinte código:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

// Create or retrieve a key from the keyvault
const myKey = await client.createKey("MyKey", "RSA");

// Lastly, create our cryptography client and connect to the service
const cryptographyClient = new CryptographyClient(myKey, credential);

Criptografar

encrypt irá encriptar uma mensagem.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey.id, credential);

const encryptResult = await cryptographyClient.encrypt({
  algorithm: "RSA1_5",
  plaintext: Buffer.from("My Message"),
});
console.log("encrypt result: ", encryptResult.result);

Desencriptar

decrypt irá desencriptar uma mensagem encriptada.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey.id, credential);

const encryptResult = await cryptographyClient.encrypt({
  algorithm: "RSA1_5",
  plaintext: Buffer.from("My Message"),
});
console.log("encrypt result: ", encryptResult.result);

const decryptResult = await cryptographyClient.decrypt({
  algorithm: "RSA1_5",
  ciphertext: encryptResult.result,
});
console.log("decrypt result: ", decryptResult.result.toString());

Assinar

sign assinará criptograficamente o resumo (hash) de uma mensagem com uma assinatura.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";
import { createHash } from "node:crypto";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

let myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const signatureValue = "MySignature";
const hash = createHash("sha256");

const digest = hash.update(signatureValue).digest();
console.log("digest: ", digest);

const signResult = await cryptographyClient.sign("RS256", digest);
console.log("sign result: ", signResult.result);

Dados de assinatura

signData assinará criptograficamente uma mensagem com uma assinatura.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const signResult = await cryptographyClient.signData("RS256", Buffer.from("My Message"));
console.log("sign result: ", signResult.result);

Verificar

verify verificará criptograficamente se o resumo assinado foi assinado com a assinatura fornecida.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";
import { createHash } from "node:crypto";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const hash = createHash("sha256");
hash.update("My Message");
const digest = hash.digest();

const signResult = await cryptographyClient.sign("RS256", digest);
console.log("sign result: ", signResult.result);

const verifyResult = await cryptographyClient.verify("RS256", digest, signResult.result);
console.log("verify result: ", verifyResult.result);

Verificar dados

verifyData verificará criptograficamente se a mensagem assinada foi assinada com a assinatura fornecida.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const buffer = Buffer.from("My Message");

const signResult = await cryptographyClient.signData("RS256", buffer);
console.log("sign result: ", signResult.result);

const verifyResult = await cryptographyClient.verifyData("RS256", buffer, signResult.result);
console.log("verify result: ", verifyResult.result);

Moldar Chave

wrapKey envolverá uma chave com uma camada de criptografia.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const wrapResult = await cryptographyClient.wrapKey("RSA-OAEP", Buffer.from("My Key"));
console.log("wrap result:", wrapResult.result);

Anular a Moldagem da Chave

unwrapKey vai desembrulhar uma chave embrulhada.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const wrapResult = await cryptographyClient.wrapKey("RSA-OAEP", Buffer.from("My Key"));
console.log("wrap result:", wrapResult.result);

const unwrapResult = await cryptographyClient.unwrapKey("RSA-OAEP", wrapResult.result);
console.log("unwrap result: ", unwrapResult.result);

Solução de problemas

Consulte nosso guia de solução de problemas para obter detalhes sobre como diagnosticar vários cenários de falha.

Habilitar o registro em log pode ajudar a descobrir informações úteis sobre falhas. Para ver um log de solicitações e respostas HTTP, defina a variável de ambiente AZURE_LOG_LEVEL como info. Como alternativa, o registro em log pode ser habilitado em tempo de execução chamando setLogLevel no @azure/logger:

import { setLogLevel } from "@azure/logger";

setLogLevel("info");

Próximos passos

Você pode encontrar mais exemplos de código através dos seguintes links:

Contribuir

Se você quiser contribuir para esta biblioteca, leia o guia de contribuição para saber mais sobre como criar e testar o código.

Comentários

Esta página foi útil?

Last updated on 2025-06-13