Azure 密钥保管库 Klientbibliotek för JavaScript – version 4.10.0

2025-06-12

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 med en enda klient, standardkompatibel molntjänst 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 kanske du vill granska: Vad är Azure Key Vault Managed HSM?

Azure Key Vault-nyckelbiblioteksklienten stöder RSA-nycklar, Elliptiska kurvnycklar (EC) 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-nycklar 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
Packa upp 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 prenumeration på Azure
En befintlig Azure Key Vault-. Om du behöver skapa ett nyckelvalv kan du göra det i Azure Portal genom att följa stegen i det här dokumentet. Du kan också använda Azure CLI genom att följa de här stegen.
Om du använder Managed HSM en befintligAzure 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 definitioner av nodtyp installerade:

npm install @types/node

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

Viktiga begrepp

Key-klienten är det primära gränssnittet för att interagera med API-metoderna som är 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 Nyckelvalvet. 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 tillhandahålls till frågan.
Mjuk borttagning gör att Key Vaults kan stödja borttagning och rensning som två separata steg, så borttagna nycklar går inte omedelbart förlorade. Detta händer 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.
Den kryptografiklienten är ett separat gränssnitt som interagerar med api-metoderna för nycklar i Key Vault-API:et. Den här klienten fokuserar endast 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 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 sina API:er. @azure/identity-paketet innehåller en mängd olika typer av autentiseringsuppgifter som programmet kan använda för att göra detta. I README för @azure/identity finns mer information och exempel för att komma igång.

För att kunna interagera med Azure Key Vault-tjänsten måste du skapa en instans av klassen KeyClient, en url för valv och ett autentiseringsobjekt. Exemplen som visas i det här dokumentet använder ett autentiseringsobjekt 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 dokumentationen Azure Identity.

Här är ett snabbt exempel. Importera först DefaultAzureCredential och KeyClient. När dessa har importerats kan vi ansluta till Key Vault-tjänsten:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

// Build the URL to reach your key vault
const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`; // or `https://${vaultName}.managedhsm.azure.net` for managed HSM.

// Lastly, create our keys client and connect to the service
const client = new KeyClient(url, credential);

Ange Azure Key Vault-tjänstens API-version

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:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

// Build the URL to reach your key vault
const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`; // or `https://${vaultName}.managedhsm.azure.net` for managed HSM.

// Change the Azure Key Vault service API version being used via the `serviceVersion` option
const client = new KeyClient(url, credential, {
  serviceVersion: "7.0", // Or 7.1
});

Exempel

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

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

Skapa en nyckel

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

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

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

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";
const result = await client.createKey(keyName, "RSA");
console.log("result: ", result);

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

Hämta en nyckel

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

getKey hämtar en nyckel tidigare butiker i Key Vault.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

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

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const latestKey = await client.getKey(keyName);
console.log(`Latest version of the key ${keyName}: `, latestKey);

const specificKey = await client.getKey(keyName, { version: latestKey.properties.version! });
console.log(`The key ${keyName} at the version ${latestKey.properties.version!}: `, specificKey);

Skapa och uppdatera nycklar med attribut

Följande attribut kan också tilldelas till valfri nyckel i ett Nyckelvalv:

tags: Alla uppsättningar med 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 ska kunna utföra (encrypt, decrypt, sign, 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 efter vilket nyckelvärdet inte kan hämtas.

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

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

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

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

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

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:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

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

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

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

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.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

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

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const poller = await client.beginDeleteKey(keyName);
await poller.pollUntilDone();

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

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

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

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const poller = await client.beginDeleteKey(keyName);

// You can use the deleted key immediately:
const deletedKey = poller.getResult();

// The key is being deleted. Only wait for it if you want to restore it or purge it.
await poller.pollUntilDone();

// You can also get the deleted key this way:
await client.getDeletedKey(keyName);

// Deleted keys can also be recovered or purged:

// recoverDeletedKey also returns a poller, just like beginDeleteKey.
const recoverPoller = await client.beginRecoverDeletedKey(keyName);
await recoverPoller.pollUntilDone();

// And here is how to purge a deleted key
await client.purgeDeletedKey(keyName);

Eftersom nycklar tar lite tid att ta bort helt returnerar beginDeleteKey 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:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

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

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const poller = await client.beginDeleteKey(keyName);

// You can use the deleted key immediately:
let deletedKey = poller.getResult();

// Or you can wait until the key finishes being deleted:
deletedKey = await poller.pollUntilDone();
console.log(deletedKey);

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

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

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

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const poller = await client.beginDeleteKey(keyName);

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

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

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.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

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

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

// Set the key's automated rotation policy to rotate the key 30 days before expiry.
const policy = await client.updateKeyRotationPolicy(keyName, {
  lifetimeActions: [
    {
      action: "Rotate",
      timeBeforeExpiry: "P30D",
    },
  ],
  // You may also specify the duration after which any newly rotated key will expire.
  // In this case, any new key versions will expire after 90 days.
  expiresIn: "P90D",
});

// You can get the current key rotation policy of a given key by calling the getKeyRotationPolicy method.
const currentPolicy = await client.getKeyRotationPolicy(keyName);

// Finally, you can rotate a key on-demand by creating a new version of the given key.
const rotatedKey = await client.rotateKey(keyName);

Itererande listor över nycklar

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

listPropertiesOfKeys listar alla nycklar som inte har tagits bort med deras namn, endast i de senaste versionerna.
listDeletedKeys listar 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:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

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

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

for await (const keyProperties of client.listPropertiesOfKeys()) {
  console.log("Key properties: ", keyProperties);
}

for await (const deletedKey of client.listDeletedKeys()) {
  console.log("Deleted: ", deletedKey);
}

for await (const versionProperties of client.listPropertiesOfKeyVersions(keyName)) {
  console.log("Version properties: ", versionProperties);
}

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:

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

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

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

for await (const page of client.listPropertiesOfKeys().byPage()) {
  for (const keyProperties of page) {
    console.log("Key properties: ", keyProperties);
  }
}

for await (const page of client.listDeletedKeys().byPage()) {
  for (const deletedKey of page) {
    console.log("Deleted key: ", deletedKey);
  }
}

for await (const page of client.listPropertiesOfKeyVersions(keyName).byPage()) {
  for (const versionProperties of page) {
    console.log("Version: ", versionProperties);
  }
}

Kryptografi

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

Vi kan sedan ansluta till key vault-tjänsten precis som vi gör med KeyClient. Vi måste kopiera vissa inställningar från nyckelvalvet som vi ansluter till till 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 client = new KeyClient(url, credential);

// Create or retrieve a key from the keyvault
const myKey = await client.createKey("MyKey", "RSA");

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

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

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey.id, credential);

const encryptResult = await cryptographyClient.encrypt({
  algorithm: "RSA1_5",
  plaintext: Buffer.from("My Message"),
});
console.log("encrypt result: ", encryptResult.result);

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

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey.id, credential);

const encryptResult = await cryptographyClient.encrypt({
  algorithm: "RSA1_5",
  plaintext: Buffer.from("My Message"),
});
console.log("encrypt result: ", encryptResult.result);

const decryptResult = await cryptographyClient.decrypt({
  algorithm: "RSA1_5",
  ciphertext: encryptResult.result,
});
console.log("decrypt result: ", decryptResult.result.toString());

Signera

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

const credential = new DefaultAzureCredential();

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

const client = new KeyClient(url, credential);

let myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

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

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

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

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

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const signResult = await cryptographyClient.signData("RS256", Buffer.from("My Message"));
console.log("sign result: ", signResult.result);

Kontrollera

verify kommer kryptografiskt att verifiera att den signerade sammandraget har signerats med den angivna signaturen.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";
import { createHash } from "node:crypto";

const credential = new DefaultAzureCredential();

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

const client = new KeyClient(url, credential);

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const hash = createHash("sha256");
hash.update("My Message");
const digest = hash.digest();

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

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

Verifiera data

verifyData kommer kryptografiskt att verifiera att det signerade meddelandet signerades 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 client = new KeyClient(url, credential);

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const buffer = Buffer.from("My Message");

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

const verifyResult = await cryptographyClient.verifyData("RS256", buffer, signResult.result);
console.log("verify result: ", verifyResult.result);

Packa nyckeln

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

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const wrapResult = await cryptographyClient.wrapKey("RSA-OAEP", Buffer.from("My Key"));
console.log("wrap result:", wrapResult.result);

Packa upp nyckeln

unwrapKey hämtar 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 client = new KeyClient(url, credential);

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const wrapResult = await cryptographyClient.wrapKey("RSA-OAEP", Buffer.from("My Key"));
console.log("wrap result:", wrapResult.result);

const unwrapResult = await cryptographyClient.unwrapKey("RSA-OAEP", wrapResult.result);
console.log("unwrap result: ", unwrapResult.result);

Felsökning

Mer information om hur du diagnostiserar olika felscenarier finns i felsökningsguiden för .

Aktivering av loggning kan hjälpa dig att hitta användbar information om fel. Om du vill se en logg med 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:

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

setLogLevel("info");

Nästa steg

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

Bidrag

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

Feedback

Var den här sidan till hjälp?