Biblioteca cliente de claves de Azure Key Vault para JavaScript: versión 4.8.0

Artículo
02/16/2024

Azure Key Vault es un servicio que permite cifrar claves de autenticación, claves de cuenta de almacenamiento, claves de cifrado de datos, archivos .pfx y contraseñas mediante claves protegidas. Si desea obtener más información sobre Azure Key Vault, puede que desee revisar: ¿Qué es Azure Key Vault?

HSM administrado de Azure Key Vault es un servicio en la nube totalmente administrado, de alta disponibilidad, de un solo inquilino y compatible con estándares que le permite proteger las claves criptográficas de las aplicaciones en la nube mediante HSM validados por FIPS 140-2 nivel 3. Si desea obtener más información sobre HSM administrado de Azure Key Vault, puede que quiera revisar: ¿Qué es Azure Key Vault HSM administrado?

El cliente de la biblioteca de claves de Azure Key Vault admite claves RSA, claves de curva elíptica (EC), así como claves simétricas (oct) al ejecutarse en un HSM administrado, cada una con la compatibilidad correspondiente en módulos de seguridad de hardware (HSM). Ofrece operaciones para crear, recuperar, actualizar, eliminar, purgar, realizar copias de seguridad, restaurar y enumerar las claves y sus versiones.

Use la biblioteca cliente para claves de Azure Key Vault en la aplicación de Node.js para:

Cree claves mediante la curva elíptica o el cifrado RSA, respaldado opcionalmente por módulos de seguridad de hardware (HSM).
Importar, eliminar y actualizar claves.
Obtenga una o varias claves y las claves eliminadas, con sus atributos.
Recupere una clave eliminada y restaure una clave de copia de seguridad.
Obtenga las versiones de una clave.

Con el cliente de criptografía disponible en esta biblioteca también tiene acceso a:

Cifrado
Descifrado
de firma
Comprobando
Ajustar claves
Desencapsulado de claves

Nota: Este paquete no se puede usar en el explorador debido a las limitaciones del servicio azure Key Vault, consulte este documento para obtener instrucciones.

Vínculos principales:

Introducción

Entornos admitidos actualmente

Versiones de LTS de Node.js

Requisitos previos

Una suscripción de Azure
Una Key Vault de Azure existente. Si necesita crear un almacén de claves, puede hacerlo en Azure Portal siguiendo los pasos descritos en este documento. Como alternativa, siga estos pasos para usar la CLI de Azure.
Si usa HSM administrado, un HSM administrado de Azure Key Vault existente. Si necesita crear un HSM administrado, puede hacerlo mediante la CLI de Azure siguiendo los pasos descritos en este documento.

Instalar el paquete

Instalación de la biblioteca cliente de Azure Key Vault Key mediante npm

npm install @azure/keyvault-keys

Instalación de la biblioteca de identidades

Azure Key Vault los clientes se autentican mediante la biblioteca de identidades de Azure. Instálelo también con npm

npm install @azure/identity

Configurar TypeScript

Los usuarios de TypeScript deben tener instaladas definiciones de tipo de nodo:

npm install @types/node

También debe habilitar compilerOptions.allowSyntheticDefaultImports en la tsconfig.json. Tenga en cuenta que si ha habilitado , allowSyntheticDefaultImports está habilitado compilerOptions.esModuleInteropde forma predeterminada. Consulte el manual de opciones del compilador de TypeScript para obtener más información.

Conceptos clave

El cliente de clave es la interfaz principal para interactuar con los métodos de API relacionados con las claves de la API de Azure Key Vault desde una aplicación JavaScript. Una vez inicializado, proporciona un conjunto básico de métodos que se pueden usar para crear, leer, actualizar y eliminar claves.
Una versión de clave es una versión de una clave en el Key Vault. Cada vez que un usuario asigna un valor a un nombre de clave único, se crea una nueva versión de esa clave. La recuperación de una clave por un nombre siempre devolverá el valor más reciente asignado, a menos que se proporcione una versión específica a la consulta.
La eliminación temporal permite a los almacenes de claves admitir la eliminación y purga como dos pasos independientes, por lo que las claves eliminadas no se pierden inmediatamente. Esto solo sucede si el Key Vault tiene habilitada la eliminación temporal.
Se puede generar una copia de seguridad de claves a partir de cualquier clave creada. Estas copias de seguridad vienen como datos binarios y solo se pueden usar para regenerar una clave eliminada anteriormente.
El cliente de criptografía es una interfaz independiente que interactúa con los métodos de API de claves de la API de Key Vault. Este cliente se centra solo en las operaciones de criptografía que se pueden ejecutar mediante una clave que ya se ha creado en el Key Vault. Más información sobre este cliente en la sección Criptografía .

Autenticación con Azure Active Directory

El servicio Key Vault se basa en Azure Active Directory para autenticar las solicitudes en sus API. El paquete @azure/identity proporciona una variedad de tipos de credenciales que la aplicación puede usar para hacerlo. El archivo Léame para @azure/identity proporciona más detalles y ejemplos para empezar.

Para interactuar con el servicio azure Key Vault, deberá crear una instancia de la KeyClient clase, una dirección URL del almacén y un objeto de credencial. Los ejemplos que se muestran en este documento usan un objeto de credencial denominado DefaultAzureCredential, que es adecuado para la mayoría de los escenarios, incluidos los entornos de desarrollo y producción locales. Además, se recomienda usar una identidad administrada para la autenticación en entornos de producción.

Puede encontrar más información sobre las distintas formas de autenticación y sus tipos de credenciales correspondientes en la documentación de Azure Identity.

Este es un ejemplo rápido. En primer lugar, importe DefaultAzureCredential y KeyClient:

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

Una vez importados, podemos conectarse al servicio 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);

Especificación de la versión de la API del servicio Azure Key Vault

De forma predeterminada, este paquete usa la versión más reciente del servicio azure Key Vault, que es 7.2. Puede cambiar la versión del servicio que se usa estableciendo la opción serviceVersion en el constructor de cliente, como se muestra a continuación:

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

Ejemplos

En las secciones siguientes se proporcionan fragmentos de código que abarcan algunas de las tareas comunes mediante Claves de Azure Key Vault. Los escenarios que se tratan aquí constan de:

Creación de una clave.
Obtener una clave.
Creación y actualización de claves con atributos.
Eliminación de una clave.
Iteración de listas de claves.

Creación de una clave

createKeycrea una clave que se va a almacenar en azure Key Vault. Si ya existe una clave con el mismo nombre, se crea una nueva versión de la clave.

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

El segundo parámetro enviado a createKey es el tipo de la clave. El tipo de claves compatibles dependerá de la SKU y de si usa una instancia de Azure Key Vault o un HSM administrado de Azure. Para obtener una lista actualizada de los tipos de clave admitidos, consulte Acerca de las claves.

Obtención de una clave

La manera más sencilla de leer las claves del almacén es obtener una clave por su nombre. Esto recuperará la versión más reciente de la clave. Opcionalmente, puede obtener una versión diferente de la clave si la especifica como parte de los parámetros opcionales.

getKeyrecupera un almacén de claves anterior en el 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();

Creación y actualización de claves con atributos

Los atributos siguientes también se pueden asignar a cualquier clave de un Key Vault:

tags: cualquier conjunto de valores de clave que se puede usar para buscar y filtrar claves.
keyOps: matriz de las operaciones que esta clave podrá realizar (encrypt, decrypt, sign, verify, wrapKey, unwrapKey).
enabled: valor booleano que determina si el valor de clave se puede leer o no.
notBefore: fecha determinada después de la cual se puede recuperar el valor de clave.
expires: fecha determinada después de la cual no se puede recuperar el valor de clave.

Un objeto con estos atributos se puede enviar como tercer parámetro de , justo después del nombre y el valor de createKeyla clave, como se indica a continuación:

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

Esto creará una nueva versión de la misma clave, que tendrá los atributos proporcionados más recientes.

Los atributos también se pueden actualizar a una versión de clave existente con updateKeyProperties, como se indica a continuación:

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

Eliminación de una clave

El beginDeleteKey método inicia la eliminación de una clave. Este proceso se realizará en segundo plano en cuanto estén disponibles los recursos necesarios.

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

Si la eliminación temporal está habilitada para el Key Vault, esta operación solo etiquetará la clave como una clave eliminada. No se puede actualizar una clave eliminada. Solo se pueden leer, recuperar o purgar.

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

Dado que las claves tardan algún tiempo en eliminarse completamente, beginDeleteKey devuelve un objeto Poller que realiza un seguimiento de la operación de larga duración subyacente según nuestras directrices: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

El sondeo recibido le permitirá obtener la clave eliminada llamando a poller.getResult(). También puede esperar hasta que finalice la eliminación mediante la ejecución de llamadas de servicio individuales hasta que se elimine la clave o esperando hasta que se realice el proceso:

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

Otra manera de esperar hasta que la clave se elimine por completo es realizar llamadas individuales, como se indica a continuación:

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

Configuración de la rotación automática de claves

Con KeyClient, puede configurar la rotación automática de claves para una clave especificando la directiva de rotación. Además, KeyClient proporciona un método para rotar una clave a petición mediante la creación de una nueva versión de la clave 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();

Iteración de listas de claves

Con KeyClient, puede recuperar e iterar todas las claves de una Key Vault de Azure, así como a través de todas las claves eliminadas y las versiones de una clave específica. Los siguientes métodos de API están disponibles:

listPropertiesOfKeys mostrará todas las claves no eliminadas por sus nombres, solo en sus versiones más recientes.
listDeletedKeys mostrará todas las claves eliminadas por sus nombres, solo en sus versiones más recientes.
listPropertiesOfKeyVersions mostrará todas las versiones de una clave en función de un nombre de clave.

Que se puede usar de la siguiente manera:

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 estos métodos devolverán todos los resultados disponibles a la vez. Para recuperarlos por páginas, agregue .byPage() justo después de invocar el método de API que desea usar, como se indica a continuación:

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

Criptografía

Esta biblioteca también ofrece un conjunto de utilidades criptográficas disponibles a través CryptographyClientde . De forma similar a KeyClient, CryptographyClient se conectará a Azure Key Vault con el conjunto de credenciales proporcionado. Una vez conectado, CryptographyClient puede cifrar, descifrar, firmar, comprobar, encapsular claves y desencapsular claves.

A continuación, podemos conectarse al servicio del almacén de claves igual que con .KeyClient Tendremos que copiar algunas opciones de configuración del almacén de claves a las que nos conectamos a nuestras variables de entorno. Una vez que se encuentren en nuestro entorno, podemos acceder a ellos con el código siguiente:

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

Cifrado

encrypt cifrará un mensaje.

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

Descifrado

decrypt descifrará un mensaje cifrado.

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

Firma

sign firmará criptográficamente el resumen (hash) de un mensaje con una firma.

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

Firmar datos

signData firmará criptográficamente un mensaje con una firma.

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

Comprobar

verify comprobará criptográficamente que el resumen firmado se firmó con la firma 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();

Comprobar datos

verifyData comprobará criptográficamente que el mensaje firmado se firmó con la firma 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();

Ajustar clave

wrapKey encapsulará una clave con una capa de cifrado.

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

Desencapsular clave

unwrapKey desencapsulará una clave ajustada.

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

Solución de problemas

Consulte nuestra guía de solución de problemas para obtener más información sobre cómo diagnosticar varios escenarios de error.

La habilitación del registro puede ayudar a descubrir información útil sobre los errores. Para ver un registro de solicitudes y respuestas HTTP, establezca la variable de entorno AZURE_LOG_LEVEL en info. Como alternativa, el registro se puede habilitar en tiempo de ejecución llamando a setLogLevel en @azure/logger:

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

setLogLevel("info");

Pasos siguientes

Puede encontrar más ejemplos de código a través de los vínculos siguientes:

Contribuciones

Si desea contribuir a esta biblioteca, lea la guía de contribución para obtener más información sobre cómo compilar y probar el código.

Impresiones