Biblioteca de clientes do Azure Key Vault Key para JavaScript – versão 4.8.0

Artigo
02/16/2024

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, talvez queira 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 (out) 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 de Key Vault do Azure em seu aplicativo Node.js para:

Crie chaves usando a curva elíptica ou a criptografia RSA, opcionalmente apoiada 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.
Obter as versões de uma chave.

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

Criptografia
Descriptografar
Assinando
Verificando
Quebra automática de teclas
Desencapsular chaves

Observação: este 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 principais:

Introdução

Ambientes com suporte no momento

Versões LTS do Node.js

Pré-requisitos

Uma assinatura do Azure
Um Key Vault existente do Azure. Se você precisar criar um cofre de chaves, poderá fazer isso no Portal do Azure seguindo as etapas neste 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 neste documento.

Instalar o pacote

Instalar a biblioteca de clientes do Azure Key Vault Key usando o npm

npm install @azure/keyvault-keys

Instalar a biblioteca de identidade

Os clientes Key Vault do Azure se autenticam usando a biblioteca de identidade do Azure. Instale-o também usando npm

npm install @azure/identity

Configurar TypeScript

Os usuários do TypeScript precisam ter definições de tipo de nó 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 será habilitado por padrão. Confira o manual de opções do compilador do TypeScript para obter mais informações.

Principais conceitos

O cliente Key é a interface principal para interagir com os métodos de API relacionados a chaves na API de Key Vault do Azure 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 de chave é 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. 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.
A exclusão reversível permite que os Key Vaults deem 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 a exclusão reversível habilitada.
Um backup de chave pode ser gerado 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 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 Criptografia .

Autenticação com o Azure Active Directory

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

Para interagir com o serviço de Key Vault do Azure, você precisará criar uma instância da KeyClient classe , 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, é recomendável 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 credenciais correspondentes na documentação da Identidade do Azure.

Aqui está um exemplo rápido. Primeiro, importe DefaultAzureCredential e KeyClient:

const { DefaultAzureCredential } = require("@azure/identity");
const { KeyClient } = require("@azure/keyvault-keys");

Depois que eles forem importados, poderemos nos conectar ao serviço Key Vault:

const { DefaultAzureCredential } = require("@azure/identity");
const { KeyClient } = require("@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 Key Vault do Azure

Por padrão, esse pacote usa a versão mais recente do serviço Key Vault do Azure, 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:

const { DefaultAzureCredential } = require("@azure/identity");
const { KeyClient } = require("@azure/keyvault-keys");

const credential = new DefaultAzureCredential();

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

// 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 de Key Vault do Azure. Os cenários abordados aqui consistem em:

Criando uma chave.
Obtendo uma chave.
Criar e atualizar chaves com atributos.
Excluindo uma chave.
Iterando listas de chaves.

Criando uma chave

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

const { DefaultAzureCredential } = require("@azure/identity");
const { KeyClient } = require("@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";

async function main() {
  const result = await client.createKey(keyName, "RSA");
  console.log("result: ", result);
}

main();

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 Key Vault do Azure ou um HSM Gerenciado do Azure. Para obter uma lista atualizada de 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 por nome. Isso recuperará a versão mais recente da chave. Opcionalmente, você poderá obter uma versão diferente da chave se especificá-la como parte dos parâmetros opcionais.

getKeyrecupera uma chave de repositórios anteriores no Key Vault.

const { DefaultAzureCredential } = require("@azure/identity");
const { KeyClient } = require("@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";

async function main() {
  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);
}

main();

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-valor que pode ser usado para pesquisar e filtrar chaves.
keyOps: uma matriz das operações que essa chave poderá executar (encrypt, decrypt, , signverify, 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:

const { DefaultAzureCredential } = require("@azure/identity");
const { KeyClient } = require("@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";

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

main();

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:

const { DefaultAzureCredential } = require("@azure/identity");
const { KeyClient } = require("@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";

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

main();

Excluindo uma chave

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

const { DefaultAzureCredential } = require("@azure/identity");
const { KeyClient } = require("@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";

async function main() {
  const poller = await client.beginDeleteKey(keyName);
  await poller.pollUntilDone();
}

main();

Se a 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.

const { DefaultAzureCredential } = require("@azure/identity");
const { KeyClient } = require("@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";

async function main() {
  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);
}

main();

Como Keys leva algum tempo para ser totalmente excluído, 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:

const { DefaultAzureCredential } = require("@azure/identity");
const { KeyClient } = require("@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";

async function main() {
  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);
}

main();

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

const { DefaultAzureCredential } = require("@azure/identity");
const { KeyClient } = require("@azure/keyvault-keys");
const { delay } = require("@azure/core-util");

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

async function main() {
  const poller = await client.beginDeleteKey(keyName);

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

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

main();

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.

const { DefaultAzureCredential } = require("@azure/identity");
const { KeyClient } = require("@azure/keyvault-keys");

const url = `https://<YOUR KEYVAULT NAME>.vault.azure.net`;
const client = new KeyClient(url, new DefaultAzureCredential());

async function main() {
  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);
}

main();

Iterando listas de chaves

Usando o KeyClient, você pode recuperar e iterar todas as chaves em um Key Vault do Azure, 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 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:

const { DefaultAzureCredential } = require("@azure/identity");
const { KeyClient } = require("@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";

async function main() {
  for await (let keyProperties of client.listPropertiesOfKeys()) {
    console.log("Key properties: ", keyProperties);
  }
  for await (let deletedKey of client.listDeletedKeys()) {
    console.log("Deleted: ", deletedKey);
  }
  for await (let versionProperties of client.listPropertiesOfKeyVersions(keyName)) {
    console.log("Version properties: ", versionProperties);
  }
}

main();

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:

const { DefaultAzureCredential } = require("@azure/identity");
const { KeyClient } = require("@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";

async function main() {
  for await (let page of client.listPropertiesOfKeys().byPage()) {
    for (let keyProperties of page) {
      console.log("Key properties: ", keyProperties);
    }
  }
  for await (let page of client.listDeletedKeys().byPage()) {
    for (let deletedKey of page) {
      console.log("Deleted key: ", deletedKey);
    }
  }
  for await (let page of client.listPropertiesOfKeyVersions(keyName).byPage()) {
    for (let versionProperties of page) {
      console.log("Version: ", versionProperties);
    }
  }
}

main();

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 Key Vault do Azure com o conjunto de credenciais fornecido. Depois de 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 keysClient = new KeyClient(url, credential);

async function main() {
  // Create or retrieve a key from the keyvault
  let myKey = await keysClient.createKey("MyKey", "RSA");

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

main();

Encrypt

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 keysClient = new KeyClient(url, credential);

async function main() {
  let myKey = await keysClient.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);
}

main();

Descriptografar

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 keysClient = new KeyClient(url, credential);

async function main() {
  let myKey = await keysClient.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());
}

main();

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 "crypto";

const credential = new DefaultAzureCredential();

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

const keysClient = new KeyClient(url, credential);

async function main() {
  let myKey = await keysClient.createKey("MyKey", "RSA");
  const cryptographyClient = new CryptographyClient(myKey, credential);

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

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

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

main();

Assinar dados

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 keysClient = new KeyClient(url, credential);

async function main() {
  let myKey = await keysClient.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);
}

main();

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 "crypto";

const credential = new DefaultAzureCredential();

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

const keysClient = new KeyClient(url, credential);

async function main() {
  let myKey = await keysClient.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);
}

main();

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 keysClient = new KeyClient(url, credential);

async function main() {
  let myKey = await keysClient.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);
}

main();

Quebra de tecla

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 keysClient = new KeyClient(url, credential);

async function main() {
  let myKey = await keysClient.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);
}

main();

Desembrulhar 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 keysClient = new KeyClient(url, credential);

async function main() {
  let myKey = await keysClient.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);
}

main();

Solução de problemas

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

A habilitação do 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 log pode ser habilitado no runtime chamando setLogLevel em @azure/logger:

const { setLogLevel } = require("@azure/logger");

setLogLevel("info");

Próximas etapas

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

Contribuição

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

Impressões

Compartilhar via