Compartilhar via

Biblioteca de clientes de chaves do Azure Key Vault 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 protegidas. Se você quiser saber mais sobre o Azure Key Vault, talvez queira examinar: O que é o Azure Key Vault?

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

O cliente da biblioteca de chaves do Azure Key Vault dá suporte a chaves RSA, chaves EC (Curva Elíptica), bem como chaves simétricas (outubro) ao executar em um HSM gerenciado, cada uma com suporte correspondente em HSM (módulos de segurança de hardware). 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 clientes para chaves do Azure Key Vault em seu aplicativo Node.js para:

  • Crie chaves usando a curva elíptica ou a criptografia RSA, opcionalmente apoiadas por HSM (Módulos de Segurança de Hardware).
  • Importar, excluir e atualizar 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:

  • Criptografar
  • Descriptografar
  • Assinando
  • Verificar
  • Teclas de encapsulamento
  • Desembrulhar chaves

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

Links de chave:

Como começar

Ambientes com suporte no momento

Pré-requisitos

  • Uma assinatura do Azure
  • Umexistente do Azure Key Vault . Se você precisar criar um cofre de chaves, poderá fazê-lo no Portal do Azure seguindo as etapas 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á fazer isso usando a CLI do Azure seguindo as etapas em este documento.

Instalar o pacote

Instalar a biblioteca de clientes da Chave do Azure Key Vault usando o 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. Instalá-lo também usando o npm

npm install @azure/identity

Configurar TypeScript

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

npm install @types/node

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

Conceitos principais

  • O 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. Depois de inicializado, ele fornece um conjunto básico de métodos que podem ser usados para criar, ler, atualizar e excluir chaves.
  • Uma versão do Key é uma versão de uma chave no Key Vault. Sempre que um usuário atribui um valor a um nome de chave exclusivo, uma nova versão dessa chave é criada. A recuperação de uma chave por um nome sempre retornará o valor mais recente atribuído, a menos que uma versão específica seja fornecida à consulta.
  • exclusão reversível permite que os Key Vaults ofereçam suporte à exclusão e à limpeza como duas etapas separadas, portanto, as chaves excluídas não são perdidas imediatamente. Isso só acontecerá se o Key Vault tiver de exclusão reversível habilitada.
  • Uma de backup de chave pode ser gerada 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 cliente Cryptography é uma interface separada que interage com os métodos de API de chaves na API do Key Vault. Esse cliente se concentra apenas nas operações de criptografia que podem ser executadas usando uma chave que já foi criada no Key Vault. Mais informações sobre esse cliente na seção Cryptography.

Autenticação com o Azure Active Directory

O serviço do Key Vault depende do Azure Active Directory para autenticar solicitações para suas APIs. O pacote @azure/identity fornece uma variedade de tipos de credencial 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 do Azure Key Vault, você precisará criar uma instância da classe KeyClient, uma 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 locais de desenvolvimento e produção. Além disso, recomendamos usar uma identidade gerenciada para autenticação em ambientes de produção.

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

Aqui está um exemplo rápido. Primeiro, importe DefaultAzureCredential e KeyClient. Depois que eles forem importados, poderemos nos conectar ao serviço do Key Vault:

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 de serviço do Azure Key Vault

Por padrão, esse pacote usa a versão mais recente do serviço do Azure Key Vault, que é 7.2. Você pode alterar a versão do 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 snippets de código que abrangem algumas das tarefas comuns usando chaves do Azure Key Vault. Os cenários abordados aqui consistem em:

Criando uma chave

createKey cria uma chave a ser armazenada no Azure Key Vault. Se uma chave com o mesmo nome já existir, uma nova versão da chave será criada.

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á do SKU e se você está usando um Azure Key Vault ou um HSM Gerenciado do Azure. Para obter uma lista de datas up-tode tipos de chave com suporte, consulte Sobre chaves

Obtendo 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ê poderá obter uma versão diferente da chave se especifique-a como parte dos parâmetros opcionais.

getKey recupera uma chave de repositórios anteriores no Key Vault.

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);

Criando e atualizando chaves com atributos

Os seguintes atributos também podem ser atribuídos a qualquer chave em um Key Vault:

  • tags: qualquer conjunto de chave-valores que possa ser usado para pesquisar e filtrar chaves.
  • keyOps: uma matriz das operações que essa chave poderá executar (encrypt, decrypt, sign, verify, wrapKey, unwrapKey).
  • enabled: um valor booliano 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,
});

Excluindo uma chave

O método beginDeleteKey inicia a exclusão de uma chave. Esse processo ocorrerá 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 reversível estiver habilitada para o Key Vault, 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 limpos.

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 Chaves levam algum tempo para serem totalmente excluídas, beginDeleteKey retorna um objeto Poller que controla a Operação de Execução Longa subjacente de acordo com nossas diretrizes: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

O sondador recebido permitirá que você obtenha a chave excluída chamando para poller.getResult(). Você também pode aguardar até que a exclusão seja concluída 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 aguardar 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, o 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);

Iterando listas de chaves

Usando o KeyClient, você pode recuperar e iterar por todas as chaves em um Azure Key Vault, bem como por 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 chaves não excluídas por seus nomes, somente em suas versões mais recentes.
  • listDeletedKeys listará todas as suas chaves excluídas por seus nomes, somente 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 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 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 ao mesmo tempo. 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

Essa biblioteca também oferece um conjunto de utilitários criptográficos disponíveis por meio de CryptographyClient. Semelhante ao KeyClient, CryptographyClient se conectará ao Azure Key Vault com o conjunto de credenciais fornecido. Uma vez conectado, CryptographyClient pode criptografar, descriptografar, assinar, verificar, encapsular chaves e desembrulhar chaves.

Podemos nos conectar ao serviço do cofre de chaves da mesma forma que fazemos com o KeyClient. Precisaremos copiar algumas configurações do cofre de chaves ao qual estamos nos conectando em nossas variáveis de ambiente. Depois que eles estiverem em nosso ambiente, poderemos 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 criptografará 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 descriptografará uma mensagem criptografada.

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);

Assinar dados

signData assinará uma mensagem criptograficamente 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);

Encapsular chave

wrapKey encapsulará 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);

Decodificar Chave

unwrapKey desembrulhará uma chave encapsulada.

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);

Resoluçã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 runtime chamando setLogLevel no @azure/logger:

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

setLogLevel("info");

Próximas etapas

Você pode encontrar mais exemplos de código por meio dos seguintes links:

Contribuindo

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

  • Last updated on