Azure Key Vault Key-klientbibliotek för JavaScript – version 4.8.0

Artikel
02/16/2024

Azure Key Vault är en tjänst som gör att du kan kryptera autentiseringsnycklar, lagringskontonycklar, datakrypteringsnycklar, PFX-filer och lösenord med hjälp av skyddade nycklar. Om du vill veta mer om Azure Key Vault kanske du vill granska: Vad är Azure Key Vault?

Azure Key Vault Managed HSM är en fullständigt hanterad, högtillgänglig molntjänst som är kompatibel med en enda klientorganisation och som gör att du kan skydda kryptografiska nycklar för dina molnprogram med FIPS 140-2 Level 3-verifierade HSM:er. Om du vill veta mer om Azure Key Vault Managed HSM kan du läsa: Vad är Azure Key Vault Managed HSM?

Azure Key Vault-nyckelbiblioteksklienten stöder RSA-nycklar, EC-nycklar (Elliptic Curve) samt symmetriska nycklar (okt) när de körs mot en hanterad HSM, var och en med motsvarande stöd i maskinvarusäkerhetsmoduler (HSM). Den erbjuder åtgärder för att skapa, hämta, uppdatera, ta bort, rensa, säkerhetskopiera, återställa och lista nycklarna och dess versioner.

Använd klientbiblioteket för Azure Key Vault Keys i ditt Node.js-program för att:

Skapa nycklar med hjälp av elliptisk kurva eller RSA-kryptering, som eventuellt backas upp av maskinvarusäkerhetsmoduler (HSM).
Importera, ta bort och uppdatera nycklar.
Hämta en eller flera nycklar och borttagna nycklar med deras attribut.
Återställa en borttagen nyckel och återställa en säkerhetskopierad nyckel.
Hämta versionerna av en nyckel.

Med hjälp av kryptografiklienten som är tillgänglig i det här biblioteket har du också åtkomst till:

Kryptera
Dekryptera
Signering
Kontrollera
Omslutningsnycklar
Avskrivning av nycklar

Obs! Det här paketet kan inte användas i webbläsaren på grund av begränsningar i Azure Key Vault-tjänsten. Mer information finns i det här dokumentet.

Nyckellänkar:

Komma igång

Miljöer som stöds för närvarande

LTS-versioner av Node.js

Förutsättningar

En Azure-prenumeration
En befintlig Azure-Key Vault. Om du behöver skapa ett nyckelvalv kan du göra det i Azure-portalen genom att följa stegen i det här dokumentet. Du kan också använda Azure CLI genom att följa dessa steg.
Om du använder Managed HSM, en befintlig Azure Key Vault Managed HSM. Om du behöver skapa en hanterad HSM kan du göra det med hjälp av Azure CLI genom att följa stegen i det här dokumentet.

Installera paketet

Installera Azure Key Vault Key-klientbiblioteket med npm

npm install @azure/keyvault-keys

Installera identitetsbiblioteket

Azure Key Vault-klienter autentiserar med hjälp av Azure-identitetsbiblioteket. Installera den också med npm

npm install @azure/identity

Konfigurera TypeScript

TypeScript-användare måste ha nodtypsdefinitioner installerade:

npm install @types/node

Du måste också aktivera compilerOptions.allowSyntheticDefaultImports i din tsconfig.json. Observera att om du har aktiverat compilerOptions.esModuleInteropallowSyntheticDefaultImports är aktiverad som standard. Mer information finns i Handbook för kompilatoralternativ i TypeScript .

Viktiga begrepp

Nyckelklienten är det primära gränssnittet för att interagera med API-metoderna relaterade till nycklar i Azure Key Vault-API:et från ett JavaScript-program. När den har initierats innehåller den en grundläggande uppsättning metoder som kan användas för att skapa, läsa, uppdatera och ta bort nycklar.
En nyckelversion är en version av en nyckel i Key Vault. Varje gång en användare tilldelar ett värde till ett unikt nyckelnamn skapas en ny version av nyckeln. Om du hämtar en nyckel med ett namn returneras alltid det senaste tilldelade värdet, såvida inte en viss version anges för frågan.
Mjuk borttagning gör att Key Vaults stöder borttagning och rensning som två separata steg, så borttagna nycklar går inte omedelbart förlorade. Detta inträffar bara om Key Vault har mjuk borttagning aktiverat.
En nyckelsäkerhetskopia kan genereras från valfri skapad nyckel. Dessa säkerhetskopior kommer som binära data och kan bara användas för att återskapa en tidigare borttagen nyckel.
Kryptografiklienten är ett separat gränssnitt som interagerar med api-metoderna för nycklar i Key Vault-API:et. Den här klienten fokuserar bara på kryptografiåtgärder som kan köras med hjälp av en nyckel som redan har skapats i Key Vault. Mer om den här klienten finns i avsnittet Kryptografi .

Autentisera med Azure Active Directory

Key Vault-tjänsten förlitar sig på Azure Active Directory för att autentisera begäranden till dess API:er. Paketet @azure/identity innehåller en mängd olika typer av autentiseringsuppgifter som ditt program kan använda för att göra detta. README för @azure/identity innehåller mer information och exempel för att komma igång.

För att interagera med Tjänsten Azure Key Vault måste du skapa en instans av KeyClient klassen, en valv-URL och ett autentiseringsobjekt. Exemplen som visas i det här dokumentet använder ett autentiseringsuppgiftsobjekt med namnet DefaultAzureCredential, vilket är lämpligt för de flesta scenarier, inklusive lokala utvecklings- och produktionsmiljöer. Dessutom rekommenderar vi att du använder en hanterad identitet för autentisering i produktionsmiljöer.

Du hittar mer information om olika sätt att autentisera och deras motsvarande typer av autentiseringsuppgifter i Azure Identity-dokumentationen.

Här är ett snabbt exempel. Importera först DefaultAzureCredential och KeyClient:

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

När dessa har importerats kan vi ansluta till tjänsten 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);

Ange API-versionen för Azure Key Vault-tjänsten

Som standard använder det här paketet den senaste versionen av Azure Key Vault-tjänsten, som är 7.2. Du kan ändra den tjänstversion som används genom att ange alternativet serviceVersion i klientkonstruktorn enligt nedan:

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

Exempel

Följande avsnitt innehåller kodfragment som beskriver några av de vanliga uppgifterna med hjälp av Azure Key Vault Keys. De scenarier som beskrivs här består av:

Skapa en nyckel.
Hämta en nyckel.
Skapa och uppdatera nycklar med attribut.
Tar bort en nyckel.
Itererande listor över nycklar.

Skapa en nyckel

createKeyskapar en nyckel som ska lagras i Azure Key Vault. Om det redan finns en nyckel med samma namn skapas en ny version av nyckeln.

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

Den andra parametern som skickas till createKey är nyckelns typ. Vilken typ av nycklar som stöds beror på SKU:n och om du använder en Azure-Key Vault eller en Azure Managed HSM. En uppdaterad lista över nyckeltyper som stöds finns i Om nycklar

Hämta en nyckel

Det enklaste sättet att läsa nycklar tillbaka från valvet är att hämta en nyckel efter namn. Den senaste versionen av nyckeln hämtas. Du kan också hämta en annan version av nyckeln om du anger den som en del av de valfria parametrarna.

getKeyhämtar en nyckel som tidigare lagrar i 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();

Skapa och uppdatera nycklar med attribut

Följande attribut kan också tilldelas till valfri nyckel i en Key Vault:

tags: Alla uppsättningar nyckelvärden som kan användas för att söka efter och filtrera nycklar.
keyOps: En matris med de åtgärder som den här nyckeln kommer att kunna utföra (encrypt, , signdecrypt, verify, wrapKey, unwrapKey).
enabled: Ett booleskt värde som avgör om nyckelvärdet kan läsas eller inte.
notBefore: Ett angivet datum efter vilket nyckelvärdet kan hämtas.
expires: Ett angivet datum då nyckelvärdet inte kan hämtas.

Ett objekt med dessa attribut kan skickas som den tredje parametern createKeyi , direkt efter nyckelns namn och värde enligt följande:

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

Då skapas en ny version av samma nyckel, som har de senaste attributen.

Attribut kan också uppdateras till en befintlig nyckelversion med updateKeyProperties, enligt följande:

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

Ta bort en nyckel

Metoden beginDeleteKey startar borttagningen av en nyckel. Den här processen sker i bakgrunden så snart de nödvändiga resurserna är tillgängliga.

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

Om mjuk borttagning är aktiverat för Key Vault märks bara nyckeln som en borttagen nyckel i den här åtgärden. Det går inte att uppdatera en borttagen nyckel. De kan bara läsas, återställas eller rensas.

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

Eftersom nycklar tar lite tid att ta bort beginDeleteKey helt returnerar ett Poller-objekt som håller reda på den underliggande långvariga åtgärden enligt våra riktlinjer: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

Med den mottagna pollern kan du hämta den borttagna nyckeln genom att anropa till poller.getResult(). Du kan också vänta tills borttagningen har slutförts antingen genom att köra enskilda tjänstanrop tills nyckeln har tagits bort eller genom att vänta tills processen är klar:

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

Ett annat sätt att vänta tills nyckeln har tagits bort helt är att utföra enskilda anrop på följande sätt:

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

Konfigurera automatisk nyckelrotation

Med Hjälp av KeyClient kan du konfigurera automatisk nyckelrotation för en nyckel genom att ange rotationsprincipen. Dessutom tillhandahåller KeyClient en metod för att rotera en nyckel på begäran genom att skapa en ny version av den angivna nyckeln.

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

Itererande listor över nycklar

Med Hjälp av KeyClient kan du hämta och iterera genom alla nycklar i en Azure-Key Vault, samt genom alla borttagna nycklar och versioner av en specifik nyckel. Följande API-metoder är tillgängliga:

listPropertiesOfKeys visar en lista över alla icke-borttagna nycklar efter deras namn, endast i de senaste versionerna.
listDeletedKeys visar en lista över alla borttagna nycklar efter deras namn, endast i de senaste versionerna.
listPropertiesOfKeyVersions visar en lista över alla versioner av en nyckel baserat på ett nyckelnamn.

Som kan användas på följande sätt:

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

Alla dessa metoder returnerar alla tillgängliga resultat samtidigt. Om du vill hämta dem via sidor lägger du till .byPage() direkt efter att du har anropat den API-metod som du vill använda, enligt följande:

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

Kryptografi

Det här biblioteket erbjuder också en uppsättning kryptografiska verktyg som är tillgängliga via CryptographyClient. På samma KeyClientCryptographyClient sätt som ansluter till Azure Key Vault med den angivna uppsättningen autentiseringsuppgifter. När du är ansluten CryptographyClient kan kryptera, dekryptera, signera, verifiera, omsluta nycklar och packa upp nycklar.

Vi kan sedan ansluta till key vault-tjänsten precis som med KeyClient. Vi måste kopiera vissa inställningar från nyckelvalvet som vi ansluter till i våra miljövariabler. När de är i vår miljö kan vi komma åt dem med följande kod:

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

Kryptera

encrypt krypterar ett meddelande.

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

Avkryptera

decrypt dekrypterar ett krypterat meddelande.

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

Tecken

sign signerar kryptografiskt sammandraget (hash) för ett meddelande med en signatur.

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

Signera data

signData signerar kryptografiskt ett meddelande med en signatur.

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

Verifiera

verify verifierar kryptografiskt att den signerade sammandraget signerades med den angivna signaturen.

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

Verifiera data

verifyData verifierar kryptografiskt att det signerade meddelandet signerats med den angivna signaturen.

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

Radbrytningsnyckel

wrapKey omsluter en nyckel med ett krypteringslager.

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

Packa upp nyckel

unwrapKey tar bort en omsluten nyckel.

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

Felsökning

Mer information om hur du diagnostiserar olika felscenarier finns i vår felsökningsguide .

Aktivering av loggning kan hjälpa dig att hitta användbar information om fel. Om du vill se en logg över HTTP-begäranden och svar anger du AZURE_LOG_LEVEL miljövariabeln till info. Du kan också aktivera loggning vid körning genom att anropa setLogLevel i @azure/logger:

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

setLogLevel("info");

Nästa steg

Du hittar fler kodexempel via följande länkar:

Bidra

Om du vill bidra till det här biblioteket kan du läsa bidragsguiden för att lära dig mer om hur du skapar och testar koden.

Visningar

Dela via