Delen via

Azure Key Vault Key-clientbibliotheek voor JavaScript - versie 4.10.0

Azure Key Vault is een service waarmee u verificatiesleutels, opslagaccountsleutels, gegevensversleutelingssleutels, PFX-bestanden en wachtwoorden kunt versleutelen met behulp van beveiligde sleutels. Als u meer wilt weten over Azure Key Vault, kunt u het volgende bekijken: Wat is Azure Key Vault?

Azure Key Vault Managed HSM is een volledig beheerde, maximaal beschikbare cloudservice met één tenant die voldoet aan standaarden waarmee u cryptografische sleutels voor uw cloudtoepassingen kunt beveiligen met behulp van met FIPS 140-2 Level 3 gevalideerde HSM's. Als u meer wilt weten over beheerde HSM van Azure Key Vault, kunt u het volgende bekijken: Wat is azure Key Vault Managed HSM?

De Azure Key Vault-sleutelbibliotheekclient ondersteunt RSA-sleutels, Ec-sleutels (Elliptic Curve) en symmetrische sleutels (oct) wanneer deze worden uitgevoerd op een beheerde HSM, elk met bijbehorende ondersteuning in HSM (Hardware Security Modules). Het biedt bewerkingen voor het maken, ophalen, bijwerken, verwijderen, opschonen, back-up maken, herstellen en vermelden van de sleutels en de bijbehorende versies.

Gebruik de clientbibliotheek voor Azure Key Vault-sleutels in uw Node.js toepassing voor het volgende:

  • Maak sleutels met behulp van elliptische curve of RSA-versleuteling, optioneel ondersteund door HSM (Hardware Security Modules).
  • Sleutels importeren, verwijderen en bijwerken.
  • Haal een of meer sleutels en verwijderde sleutels op met hun kenmerken.
  • Herstel een verwijderde sleutel en herstel een back-upsleutel.
  • Haal de versies van een sleutel op.

Met behulp van de cryptografieclient die beschikbaar is in deze bibliotheek, hebt u ook toegang tot:

  • Coderen
  • Decoderen
  • Ondertekening
  • Controleren
  • Teruglooptoetsen
  • Uitpakken van sleutels

Opmerking: dit pakket kan niet worden gebruikt in de browser vanwege servicebeperkingen van Azure Key Vault. Raadpleeg dit document voor hulp.

Sleutelkoppelingen:

Aan de slag

Momenteel ondersteunde omgevingen

Vereiste voorwaarden

Installeer het pakket

De Azure Key Vault-clientbibliotheek voor sleutels installeren met behulp van npm

npm install @azure/keyvault-keys

De identiteitsbibliotheek installeren

Azure Key Vault-clients verifiëren met behulp van de Azure-identiteitsbibliotheek. Installeer het ook met npm

npm install @azure/identity

TypeScript configureren

TypeScript-gebruikers moeten knooppunttypedefinities hebben geïnstalleerd:

npm install @types/node

U moet ook compilerOptions.allowSyntheticDefaultImports inschakelen in uw tsconfig.json. Houd er rekening mee dat als u compilerOptions.esModuleInterophebt ingeschakeld, allowSyntheticDefaultImports standaard is ingeschakeld. Zie het handboek voor compileropties van TypeScript voor meer informatie.

Belangrijke concepten

  • De -sleutelclient is de primaire interface voor interactie met de API-methoden met betrekking tot sleutels in de Azure Key Vault-API vanuit een JavaScript-toepassing. Zodra deze is geïnitialiseerd, biedt het een basisset methoden die kunnen worden gebruikt voor het maken, lezen, bijwerken en verwijderen van sleutels.
  • Een -sleutelversie is een versie van een sleutel in de Sleutelkluis. Telkens wanneer een gebruiker een waarde toewijst aan een unieke sleutelnaam, wordt er een nieuwe versie van die sleutel gemaakt. Als u een sleutel op een naam opvraagt, wordt altijd de meest recente waarde geretourneerd die is toegewezen, tenzij er een specifieke versie aan de query wordt verstrekt.
  • voorlopig verwijderen kan Key Vaults ondersteuning bieden voor verwijdering en opschonen als twee afzonderlijke stappen, zodat verwijderde sleutels niet onmiddellijk verloren gaan. Dit gebeurt alleen als key vault voorlopig verwijderen is ingeschakeld.
  • Een -sleutelback-up kan worden gegenereerd op basis van elke gemaakte sleutel. Deze back-ups worden geleverd als binaire gegevens en kunnen alleen worden gebruikt om een eerder verwijderde sleutel opnieuw te genereren.
  • De Cryptografieclient is een afzonderlijke interface die communiceert met de sleutels-API-methoden in de Key Vault-API. Deze client is alleen gericht op de cryptografiebewerkingen die kunnen worden uitgevoerd met behulp van een sleutel die al is gemaakt in de Key Vault. Meer informatie over deze client in de sectie Cryptografie.

Verifiëren met Azure Active Directory

De Key Vault-service is afhankelijk van Azure Active Directory voor het verifiëren van aanvragen voor de BIJBEHORENDE API's. Het @azure/identity-pakket biedt verschillende referentietypen die uw toepassing hiervoor kan gebruiken. De LEESMIJ voor @azure/identity biedt meer informatie en voorbeelden om u op weg te helpen.

Als u wilt communiceren met de Azure Key Vault-service, moet u een exemplaar van de klasse KeyClient maken, een kluis-URL en een referentieobject. In de voorbeelden in dit document wordt een referentieobject met de naam DefaultAzureCredentialgebruikt. Dit is geschikt voor de meeste scenario's, waaronder lokale ontwikkel- en productieomgevingen. Daarnaast raden we u aan een beheerde identiteit te gebruiken voor verificatie in productieomgevingen.

Meer informatie over verschillende manieren om te verifiëren en de bijbehorende referentietypen vindt u in de Azure Identity-documentatie.

Hier volgt een snel voorbeeld. Importeer eerst DefaultAzureCredential en KeyClient. Zodra deze zijn geïmporteerd, kunnen we verbinding maken met de Key Vault-service:

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

De API-versie van de Azure Key Vault-service opgeven

Dit pakket maakt standaard gebruik van de nieuwste versie van de Azure Key Vault-service die 7.2is. U kunt de serviceversie wijzigen die wordt gebruikt door de optie in te stellen serviceVersion in de clientconstructor, zoals hieronder wordt weergegeven:

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

Voorbeelden

De volgende secties bevatten codefragmenten die betrekking hebben op enkele algemene taken met behulp van Azure Key Vault-sleutels. De scenario's die hier worden behandeld, bestaan uit:

Een sleutel maken

createKey maakt een sleutel die moet worden opgeslagen in Azure Key Vault. Als er al een sleutel met dezelfde naam bestaat, wordt er een nieuwe versie van de sleutel gemaakt.

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

De tweede parameter die naar createKey wordt verzonden, is het type sleutel. Het type sleutels dat wordt ondersteund, is afhankelijk van de SKU en of u een Azure Key Vault of een door Azure beheerde HSM gebruikt. Raadpleeg voor een up-to-datumlijst met ondersteunde sleuteltypen Over sleutels

Een sleutel ophalen

De eenvoudigste manier om sleutels terug te lezen uit de kluis is door een sleutel op naam op te halen. Hiermee wordt de meest recente versie van de sleutel opgehaald. U kunt desgewenst een andere versie van de sleutel ophalen als u deze opgeeft als onderdeel van de optionele parameters.

getKey haalt een vorige sleutelopslag op in de Sleutelkluis.

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

Sleutels maken en bijwerken met kenmerken

De volgende kenmerken kunnen ook worden toegewezen aan elke sleutel in een sleutelkluis:

  • tags: elke set sleutelwaarden die kunnen worden gebruikt voor het zoeken en filteren van sleutels.
  • keyOps: een matrix van de bewerkingen die met deze sleutel kunnen worden uitgevoerd (encrypt, decrypt, sign, verify, wrapKey, unwrapKey).
  • enabled: een Booleaanse waarde die bepaalt of de sleutelwaarde wel of niet kan worden gelezen.
  • notBefore: een bepaalde datum waarna de sleutelwaarde kan worden opgehaald.
  • expires: een bepaalde datum waarna de sleutelwaarde niet kan worden opgehaald.

Een object met deze kenmerken kan als de derde parameter van createKeyworden verzonden, direct na de naam en waarde van de sleutel, als volgt:

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

Hiermee maakt u een nieuwe versie van dezelfde sleutel, die beschikt over de meest recente kenmerken.

Kenmerken kunnen als volgt worden bijgewerkt naar een bestaande sleutelversie met updateKeyProperties:

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

Een sleutel verwijderen

Met de methode beginDeleteKey wordt het verwijderen van een sleutel gestart. Dit proces vindt plaats op de achtergrond zodra de benodigde resources beschikbaar zijn.

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

Als voorlopig verwijderen is ingeschakeld voor de Sleutelkluis, wordt met deze bewerking alleen de sleutel gelabeld als een verwijderde sleutel. Een verwijderde sleutel kan niet worden bijgewerkt. Ze kunnen alleen worden gelezen, hersteld of verwijderd.

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

Omdat het enige tijd duurt voordat sleutels volledig zijn verwijderd, retourneert beginDeleteKey een Poller-object dat de onderliggende langdurige bewerking bijhoudt volgens onze richtlijnen: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

Met de ontvangen poller kunt u de verwijderde sleutel ophalen door poller.getResult()aan te roepen. U kunt ook wachten totdat het verwijderen is voltooid door afzonderlijke service-aanroepen uit te voeren totdat de sleutel is verwijderd of door te wachten totdat het proces is voltooid:

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

Een andere manier om te wachten totdat de sleutel volledig is verwijderd, is door afzonderlijke aanroepen uit te voeren:

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

Automatische sleutelrotatie configureren

Met KeyClient kunt u automatische sleutelrotatie voor een sleutel configureren door het rotatiebeleid op te geven. Daarnaast biedt KeyClient een methode om een sleutel on-demand te roteren door een nieuwe versie van de opgegeven sleutel te maken.

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

Lijsten met sleutels herhalen

Met behulp van KeyClient kunt u alle sleutels in een Azure Key Vault ophalen en herhalen, evenals via alle verwijderde sleutels en de versies van een specifieke sleutel. De volgende API-methoden zijn beschikbaar:

  • listPropertiesOfKeys vermeldt al uw niet-verwijderde sleutels op hun naam, alleen in de nieuwste versies.
  • listDeletedKeys vermeldt al uw verwijderde sleutels op hun naam, alleen in de nieuwste versies.
  • listPropertiesOfKeyVersions geeft alle versies van een sleutel weer op basis van een sleutelnaam.

Dit kan als volgt worden gebruikt:

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

Al deze methoden retourneren alle beschikbare resultaten tegelijk. Als u ze op pagina's wilt ophalen, voegt u .byPage() toe nadat u de API-methode hebt aangeroepen die u wilt gebruiken, als volgt:

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

Cryptografie

Deze bibliotheek biedt ook een set cryptografische hulpprogramma's die beschikbaar zijn via CryptographyClient. Net als bij de KeyClientmaakt CryptographyClient verbinding met Azure Key Vault met de opgegeven set referenties. Nadat de verbinding is gemaakt, kan CryptographyClient sleutels versleutelen, ontsleutelen, ondertekenen, verifiëren, verpakken en sleutels uitpakken.

We kunnen nu net als met de KeyClientverbinding maken met de sleutelkluisservice. We moeten enkele instellingen uit de sleutelkluis kopiëren waarmee we verbinding maken met onze omgevingsvariabelen. Zodra ze zich in onze omgeving bevinden, kunnen we ze openen met de volgende code:

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

Versleutelen

encrypt een bericht versleutelt.

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

Ontsleutelen

decrypt ontsleutelt een versleuteld bericht.

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

Ondertekenen

sign zal de digest (hash) van een bericht met een handtekening cryptografisch ondertekenen.

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

Gegevens ondertekenen

signData zal een bericht cryptografisch ondertekenen met een handtekening.

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

Verifiëren

verify controleert cryptografisch of de ondertekende samenvatting is ondertekend met de opgegeven handtekening.

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

Gegevens verifiëren

verifyData controleert cryptografisch of het ondertekende bericht is ondertekend met de opgegeven handtekening.

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

Sleutel inpakken

wrapKey wordt een sleutel verpakt met een versleutelingslaag.

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

Sleutel uitpakken

unwrapKey een verpakte sleutel uitpakken.

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

Probleemoplossingsproces

Raadpleeg onze gids voor probleemoplossing voor meer informatie over het vaststellen van verschillende foutscenario's.

Het inschakelen van logboekregistratie kan helpen nuttige informatie over fouten te ontdekken. Als u een logboek met HTTP-aanvragen en -antwoorden wilt zien, stelt u de omgevingsvariabele AZURE_LOG_LEVEL in op info. U kunt logboekregistratie ook tijdens runtime inschakelen door setLogLevel aan te roepen in de @azure/logger:

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

setLogLevel("info");

Volgende stappen

U vindt meer codevoorbeelden via de volgende koppelingen:

Bijdragen

Als u een bijdrage wilt leveren aan deze bibliotheek, leest u de gids voor bijdragen voor meer informatie over het bouwen en testen van de code.