Partilhar via

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

  • Artigo

O Azure Key Vault é um serviço que lhe permite encriptar chaves de autenticação, chaves de conta de armazenamento, chaves de encriptação de dados, ficheiros .pfx e palavras-passe através de chaves protegidas. Se quiser saber mais sobre o Azure Key Vault, poderá querer rever: O que é o Azure Key Vault?

O Azure Key Vault HSM Gerido é um serviço cloud totalmente gerido, altamente disponível e compatível com normas de inquilino único que lhe permite salvaguardar chaves criptográficas para as suas aplicações na cloud com HSMs validados fiPS 140-2 de Nível 3. Se quiser saber mais sobre o Azure Key Vault HSM Gerido, poderá querer rever: O que é o Azure Key Vault HSM Gerido?

O cliente da biblioteca de chaves do Azure Key Vault suporta chaves RSA, chaves de Curva Elíptica (EC), bem como chaves simétricas (oct) ao executar num HSM gerido, cada uma com suporte correspondente em módulos de segurança de hardware (HSM). Oferece operações para criar, obter, atualizar, eliminar, remover, fazer cópias de segurança, restaurar e listar as chaves e as respetivas versões.

Utilize a biblioteca de cliente para chaves de Key Vault do Azure na sua aplicação de Node.js para:

  • Crie chaves com a curva elíptica ou a encriptação RSA, opcionalmente apoiada por Módulos de Segurança de Hardware (HSM).
  • Importar, Eliminar e Atualizar chaves.
  • Obtenha uma ou mais chaves e chaves eliminadas, com os respetivos atributos.
  • Recuperar uma chave eliminada e restaurar uma chave de cópia de segurança.
  • Obtenha as versões de uma chave.

Ao utilizar o cliente de criptografia disponível nesta biblioteca, também tem acesso a:

  • Encriptar
  • Desencriptação
  • Assinatura de
  • A verificar
  • Teclas de moldagem
  • Anular a aplicação de chaves

Nota: este pacote não pode ser utilizado no browser devido às limitações do serviço Key Vault do Azure. Veja este documento para obter orientações.

Ligações principais:

Introdução

Ambientes atualmente suportados

Pré-requisitos

Instalar o pacote

Instalar a biblioteca de cliente do Azure Key Vault Key com o npm

npm install @azure/keyvault-keys

Instalar a biblioteca de identidades

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

npm install @azure/identity

Configurar TypeScript

Os utilizadores do TypeScript precisam de ter definições de tipo de Nó instaladas:

npm install @types/node

Também tem de ativar compilerOptions.allowSyntheticDefaultImports no seu tsconfig.json. Tenha em atenção que, se tiver ativado compilerOptions.esModuleInterop, allowSyntheticDefaultImports está ativado por predefinição. Veja o manual de opções do compilador do TypeScript para obter mais informações.

Conceitos-chave

  • O Cliente de chave é a interface principal para interagir com os métodos de API relacionados com chaves na API de Key Vault do Azure a partir de uma aplicação JavaScript. Depois de inicializado, fornece um conjunto básico de métodos que podem ser utilizados para criar, ler, atualizar e eliminar chaves.
  • Uma Versão de chave é uma versão de uma chave no Key Vault. Sempre que um utilizador atribui um valor a um nome de chave exclusivo, é criada uma nova versão dessa chave. A obtenção de uma chave por um nome devolverá sempre o valor mais recente atribuído, a menos que seja fornecida uma versão específica à consulta.
  • A eliminação recuperável permite que os Key Vaults suportem a eliminação e remoção como dois passos separados, pelo que as chaves eliminadas não são imediatamente perdidas. Isto só acontece se o Key Vault tiver a eliminação recuperável ativada.
  • Uma Cópia de segurança de chave pode ser gerada a partir de qualquer chave criada. Estas cópias de segurança são provenientes de dados binários e só podem ser utilizadas para regenerar uma chave eliminada anteriormente.
  • O cliente Cryptography é uma interface separada que interage com os métodos da API de chaves na API de Key Vault. Este cliente concentra-se apenas nas operações de criptografia que podem ser executadas com uma chave que já foi criada no Key Vault. Mais informações sobre este cliente na secção Criptografia .

Autenticar com o Azure Active Directory

O serviço Key Vault depende do Azure Active Directory para autenticar pedidos para as respetivas APIs. O @azure/identity pacote fornece uma variedade de tipos de credenciais que a sua aplicação pode utilizar para o fazer. O README para @azure/identity fornece mais detalhes e exemplos para começar.

Para interagir com o serviço Key Vault do Azure, terá de criar uma instância da classe, um URL do KeyClient cofre e um objeto de credencial. Os exemplos apresentados neste documento utilizam um objeto de credencial com o nome DefaultAzureCredential, que é adequado para a maioria dos cenários, incluindo ambientes de desenvolvimento e produção locais. Além disso, recomendamos a utilização de uma identidade gerida para autenticação em ambientes de produção.

Pode encontrar mais informações sobre as diferentes formas de autenticação e os tipos de credenciais correspondentes na documentação da Identidade do Azure.

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

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

Depois de estes serem importados, podemos ligar-nos 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);

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

Por predefinição, este pacote utiliza a versão mais recente do serviço do Azure Key Vault, que é 7.2. Pode alterar a versão do serviço que está a ser utilizada ao definir a opção serviceVersion no construtor 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 secções seguintes fornecem fragmentos de código que abrangem algumas das tarefas comuns com o Azure Key Vault Keys. Os cenários abordados aqui consistem em:

Criar uma chave

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

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 é createKey o tipo da chave. O tipo de chaves que são suportadas dependerá do SKU e se está a utilizar um Key Vault do Azure ou um HSM Gerido do Azure. Para obter uma lista atualizada dos tipos de chave suportados, veja About keys (Acerca das chaves)

Obter uma chave

A forma mais simples de ler as chaves a partir do cofre é obter uma chave pelo nome. Esta ação irá obter a versão mais recente da chave. Opcionalmente, pode obter uma versão diferente da chave se a especificar como parte dos parâmetros opcionais.

getKeyobtém uma chave de arquivos 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();

Criar e atualizar chaves com atributos

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

  • tags: qualquer conjunto de valores-chave que pode ser utilizado para procurar e filtrar chaves.
  • keyOps: uma matriz das operações que esta chave poderá 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 obtido.
  • expires: uma determinada data após a qual não é possível obter o valor da chave.

Um objeto com estes atributos pode ser enviado como o terceiro parâmetro de createKey, imediatamente a seguir ao nome e valor da chave, da seguinte forma:

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

Esta ação irá criar uma nova versão da mesma chave, que terá os atributos mais recentes fornecidos.

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

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

Eliminar uma chave

O beginDeleteKey método inicia a eliminação de uma chave. Este 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 eliminação recuperável estiver ativada para a Key Vault, esta operação só irá etiquetar a chave como uma chave eliminada. Não é possível atualizar uma chave eliminada. Só podem ser lidas, recuperadas ou removidas.

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

Uma vez que as Chaves demoram algum tempo a ser totalmente eliminadas, beginDeleteKey devolve um objeto Poller que controla a Operação de Execução Prolongada subjacente de acordo com as nossas diretrizes: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

O poller recebido irá permitir-lhe obter a chave eliminada ao chamar para poller.getResult(). Também pode aguardar até que a eliminação seja concluída ao executar chamadas de serviço individuais até a chave ser eliminada ou ao aguardar 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 forma de esperar até que a chave seja totalmente eliminada é efetuar chamadas individuais, da seguinte forma:

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

Configurar a Rotação Automática de Chaves

Com o KeyClient, pode configurar a rotação automática de chaves para uma chave ao especificar a política de rotação. Além disso, o KeyClient fornece um método para rodar uma chave a pedido ao criar uma nova versão da chave especificada.

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

Listas de iteração de chaves

Com o KeyClient, pode obter e iterar todas as chaves num Key Vault do Azure, bem como através de todas as chaves eliminadas e das versões de uma chave específica. Estão disponíveis os seguintes métodos de API:

  • listPropertiesOfKeys listará todas as chaves não eliminadas pelos respetivos nomes, apenas nas versões mais recentes.
  • listDeletedKeys listará todas as chaves eliminadas pelos respetivos nomes, apenas nas versões mais recentes.
  • listPropertiesOfKeyVersions irá listar todas as versões de uma chave com base num nome de chave.

Que pode ser utilizado da seguinte forma:

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 estes métodos devolverão todos os resultados disponíveis ao mesmo tempo. Para obtê-las por páginas, adicione .byPage() logo após invocar o método de API que pretende utilizar, da seguinte forma:

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

Esta biblioteca também oferece um conjunto de utilitários criptográficos disponíveis através do CryptographyClient. Semelhante ao KeyClient, CryptographyClient ligar-se-á ao Azure Key Vault com o conjunto de credenciais fornecido. Depois de ligado, CryptographyClient pode encriptar, desencriptar, assinar, verificar, moldar chaves e desembrulhar chaves.

Em seguida, podemos ligar ao serviço do cofre de chaves, tal como fazemos com o KeyClient. Teremos de copiar algumas definições do cofre de chaves a que estamos a ligar-nos às nossas variáveis de ambiente. Assim que estiverem no nosso ambiente, podemos aceder aos mesmos 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();

Encriptar

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

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

Verificação

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

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 irá verificar criptograficamente se a mensagem assinada foi assinada com a assinatura especificada.

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

Moldar Tecla

wrapKey moldará uma chave com uma camada de encriptação.

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 irá 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();

Resolução de problemas

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

Ativar o registo pode ajudar a descobrir informações úteis sobre falhas. Para ver um registo de pedidos e respostas HTTP, defina a variável de AZURE_LOG_LEVEL ambiente como info. Em alternativa, o registo pode ser ativado no runtime ao chamar setLogLevel no @azure/logger:

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

setLogLevel("info");

Passos seguintes

Pode encontrar mais exemplos de código através das seguintes ligações:

Contribuir

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

Impressões