Azure Key Vault-Schlüsselclientbibliothek für JavaScript – Version 4.10.0

2025-06-13

Azure Key Vault ist ein Dienst, mit dem Sie Authentifizierungsschlüssel, Speicherkontoschlüssel, Datenverschlüsselungsschlüssel, PFX-Dateien und Kennwörter mithilfe gesicherter Schlüssel verschlüsseln können. Wenn Sie mehr über Azure Key Vault wissen möchten, können Sie folgendes überprüfen: Was ist Azure Key Vault?

Azure Key Vault Managed HSM ist ein vollständig verwalteter, hochverwalteter, hochverwendiger, standardkonformer Clouddienst, mit dem Sie kryptografische Schlüssel für Ihre Cloudanwendungen mithilfe von FIPS 140-2 Level 3 validierten HSMs schützen können. Wenn Sie mehr über azure Key Vault Managed HSM erfahren möchten, sollten Sie folgendes überprüfen: Was ist azure Key Vault Managed HSM?

Der Azure Key Vault-Schlüsselbibliotheksclient unterstützt RSA-Schlüssel, Elliptic Curve (EC)-Schlüssel sowie symmetrische (oct) Schlüssel, wenn sie für ein verwaltetes HSM ausgeführt werden, jeweils mit entsprechender Unterstützung in Hardwaresicherheitsmodulen (HSM). Es bietet Vorgänge zum Erstellen, Abrufen, Aktualisieren, Löschen, Löschen, Sichern, Wiederherstellen und Auflisten der Schlüssel und der zugehörigen Versionen.

Verwenden Sie die Clientbibliothek für Azure Key Vault Keys in Ihrer Node.js Anwendung, um:

Erstellen Sie Schlüssel mit elliptischer Kurve oder RSA-Verschlüsselung, optional gesichert durch Hardware-Sicherheitsmodule (HSM).
Importieren, Löschen und Aktualisieren von Schlüsseln.
Rufen Sie einen oder mehrere Schlüssel und gelöschte Schlüssel mit ihren Attributen ab.
Wiederherstellen eines gelöschten Schlüssels und Wiederherstellen eines gesicherten Schlüssels.
Ruft die Versionen eines Schlüssels ab.

Mithilfe des kryptografieclients, der in dieser Bibliothek verfügbar ist, haben Sie auch Zugriff auf:

Verschlüsseln
Entschlüsseln
signatur-
Prüfen
Umbruchschlüssel
Entwrapping-Tasten

Hinweis: Dieses Paket kann aufgrund von Azure Key Vault-Dienstbeschränkungen nicht im Browser verwendet werden. Weitere Informationen finden Sie in diesem Dokument.

Wichtige Links:

Erste Schritte

Derzeit unterstützte Umgebungen

LTS-Versionen von Node.js

Voraussetzungen

Ein Azure-Abonnement
Eine vorhandene Azure Key Vault-. Wenn Sie einen Schlüsseltresor erstellen müssen, können Sie dies im Azure-Portal tun, indem Sie die Schritte in dieses Dokumentsausführen. Alternativ können Sie die Azure CLI verwenden, indem Sie diesen Schrittenfolgen.
Bei Verwendung von verwaltetem HSM, einem vorhandenen azure Key Vault Managed HSM. Wenn Sie ein verwaltetes HSM erstellen müssen, können Sie dies mithilfe der Azure CLI tun, indem Sie die Schritte in diesem Dokumentausführen.

Installiere das Paket

Installieren der Azure Key Vault Key-Clientbibliothek mithilfe von npm

npm install @azure/keyvault-keys

Installieren der Identitätsbibliothek

Azure Key Vault-Clients authentifizieren sich mithilfe der Azure-Identitätsbibliothek. Installieren sie auch mithilfe von npm

npm install @azure/identity

Konfigurieren von TypeScript

TypeScript-Benutzer müssen Knotentypdefinitionen installiert haben:

npm install @types/node

Sie müssen auch compilerOptions.allowSyntheticDefaultImports in Ihrem tsconfig.jsonaktivieren. Wenn Sie compilerOptions.esModuleInteropaktiviert haben, ist allowSyntheticDefaultImports standardmäßig aktiviert. Weitere Informationen finden Sie im Compileroptionenhandbuch TypeScript.

Wichtige Begriffe

Der Key Client ist die primäre Schnittstelle für die Interaktion mit den API-Methoden im Zusammenhang mit Schlüsseln in der Azure Key Vault-API aus einer JavaScript-Anwendung. Nach der Initialisierung stellt sie einen grundlegenden Satz von Methoden bereit, die zum Erstellen, Lesen, Aktualisieren und Löschen von Schlüsseln verwendet werden können.
Eine Key-Version ist eine Version eines Schlüssels im Key Vault. Jedes Mal, wenn ein Benutzer einem eindeutigen Schlüsselnamen einen Wert zuweist, wird eine neue Version dieses Schlüssels erstellt. Wenn Sie einen Schlüssel anhand eines Namens abrufen, wird immer der neueste Wert zurückgegeben, es sei denn, eine bestimmte Version wird der Abfrage bereitgestellt.
soft delete ermöglicht Es Key Vaults, das Löschen und Löschen als zwei separate Schritte zu unterstützen, sodass gelöschte Schlüssel nicht sofort verloren gehen. Dies geschieht nur, wenn der Key Vault soft-delete aktiviert hat.
Ein Schlüsselsicherungs- kann von jedem erstellten Schlüssel generiert werden. Diese Sicherungen sind binärdaten und können nur verwendet werden, um einen zuvor gelöschten Schlüssel neu zu generieren.
Der Kryptografieclient ist eine separate Schnittstelle, die mit den Schlüssel-API-Methoden in der Key Vault-API interagiert. Dieser Client konzentriert sich nur auf die Kryptografievorgänge, die mithilfe eines Schlüssels ausgeführt werden können, der bereits im Key Vault erstellt wurde. Weitere Informationen zu diesem Client im Abschnitt Kryptografie.

Authentifizieren mit Azure Active Directory

Der Key Vault-Dienst basiert auf Azure Active Directory, um Anforderungen an seine APIs zu authentifizieren. Das @azure/identity-Paket bietet eine Vielzahl von Anmeldeinformationstypen, die Ihre Anwendung verwenden kann, um dies zu tun. Die README für @azure/identity enthält weitere Details und Beispiele für die ersten Schritte.

Um mit dem Azure Key Vault-Dienst zu interagieren, müssen Sie eine Instanz der KeyClient Klasse, eine Vault-URL und ein Anmeldeinformationsobjekt erstellen. In den Beispielen in diesem Dokument wird ein Anmeldeinformationsobjekt namens DefaultAzureCredentialverwendet, das für die meisten Szenarien geeignet ist, einschließlich lokaler Entwicklungs- und Produktionsumgebungen. Darüber hinaus empfehlen wir die Verwendung einer verwalteten Identität für die Authentifizierung in Produktionsumgebungen.

Weitere Informationen zu verschiedenen Möglichkeiten der Authentifizierung und der entsprechenden Anmeldeinformationstypen finden Sie in der Azure Identity-Dokumentation.

Hier ist ein schnelles Beispiel. Importieren Sie zunächst DefaultAzureCredential und KeyClient. Sobald diese importiert wurden, können wir als Nächstes eine Verbindung mit dem Key Vault-Dienst herstellen:

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

Angeben der Azure Key Vault-Dienst-API-Version

Standardmäßig verwendet dieses Paket die neueste Azure Key Vault-Dienstversion, die 7.2ist. Sie können die verwendete Dienstversion ändern, indem Sie die Option serviceVersion im Clientkonstruktor wie unten gezeigt festlegen:

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

Beispiele

In den folgenden Abschnitten werden Codeausschnitte bereitgestellt, die einige der allgemeinen Aufgaben mithilfe von Azure Key Vault Keys abdecken. Die hier behandelten Szenarien bestehen aus:

Erstellen eines Schlüssels.
Abrufen eines Schlüssels.
Erstellen und Aktualisieren von Schlüsseln mit Attributen.
Löschen eines Schlüssels.
Durchlaufen von Listen mit Schlüsseln.

Erstellen eines Schlüssels

createKey erstellt einen Schlüssel, der im Azure Key Vault gespeichert werden soll. Wenn bereits ein Schlüssel mit demselben Namen vorhanden ist, wird eine neue Version des Schlüssels erstellt.

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

Der zweite Parameter, der an createKey gesendet wird, ist der Typ des Schlüssels. Der unterstützte Schlüsseltyp hängt von der SKU ab und unabhängig davon, ob Sie einen Azure Key Vault oder ein azure Managed HSM verwenden. Eine up-to-Datumsliste der unterstützten Schlüsseltypen finden Sie unter Informationen zu Schlüsseln

Abrufen eines Schlüssels

Die einfachste Möglichkeit zum Lesen von Schlüsseln aus dem Tresor besteht darin, einen Schlüssel anhand des Namens zu erhalten. Dadurch wird die neueste Version des Schlüssels abgerufen. Sie können optional eine andere Version des Schlüssels abrufen, wenn Sie ihn als Teil der optionalen Parameter angeben.

getKey ruft einen Schlüssel ab, der zuvor im Key Vault gespeichert ist.

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

Erstellen und Aktualisieren von Schlüsseln mit Attributen

Die folgenden Attribute können auch jedem Schlüssel in einem Key Vault zugewiesen werden:

tags: Jeder Satz von Schlüsselwerten, die zum Suchen und Filtern von Schlüsseln verwendet werden können.
keyOps: Ein Array der Vorgänge, die dieser Schlüssel ausführen kann (encrypt, decrypt, sign, verify, wrapKey, unwrapKey).
enabled: Ein boolescher Wert, der bestimmt, ob der Schlüsselwert gelesen werden kann.
notBefore: Ein bestimmtes Datum, nach dem der Schlüsselwert abgerufen werden kann.
expires: Ein bestimmtes Datum, nach dem der Schlüsselwert nicht abgerufen werden kann.

Ein Objekt mit diesen Attributen kann wie folgt als dritter Parameter von createKeygesendet werden, direkt hinter dem Namen und Wert des Schlüssels:

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

Dadurch wird eine neue Version desselben Schlüssels erstellt, die über die neuesten bereitgestellten Attribute verfügt.

Attribute können auch mit updateKeyPropertiesauf eine vorhandene Schlüsselversion aktualisiert werden:

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

Löschen eines Schlüssels

Die beginDeleteKey-Methode startet das Löschen eines Schlüssels. Dieser Vorgang erfolgt im Hintergrund, sobald die erforderlichen Ressourcen verfügbar sind.

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

Wenn vorläufig gelöschte für den Key Vault aktiviert ist, beschriftet dieser Vorgang nur den Schlüssel als gelöschten Schlüssel. Ein gelöschter Schlüssel kann nicht aktualisiert werden. Sie können nur gelesen, wiederhergestellt oder gelöscht werden.

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

Da Keys einige Zeit in Anspruch nehmen, um vollständig gelöscht zu werden, gibt beginDeleteKey ein Poller-Objekt zurück, das den zugrunde liegenden Long Running Operation gemäß unseren Richtlinien nachverfolgt: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

Der empfangene Abrufer ermöglicht es Ihnen, den gelöschten Schlüssel durch Aufrufen von poller.getResult()abzurufen. Sie können auch warten, bis der Löschvorgang abgeschlossen ist, indem Sie einzelne Dienstaufrufe ausführen, bis der Schlüssel gelöscht wird, oder indem Sie warten, bis der Vorgang abgeschlossen ist:

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

Eine weitere Möglichkeit, zu warten, bis der Schlüssel vollständig gelöscht wird, besteht darin, einzelne Anrufe wie folgt zu erledigen:

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

Konfigurieren der automatischen Schlüsseldrehung

Mithilfe des KeyClient können Sie die automatische Schlüsselrotation für einen Schlüssel konfigurieren, indem Sie die Drehungsrichtlinie angeben. Darüber hinaus stellt KeyClient eine Methode zum Drehen eines Schlüssels bei Bedarf bereit, indem eine neue Version des angegebenen Schlüssels erstellt wird.

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

Durchlaufen von Listen mit Schlüsseln

Mit dem KeyClient können Sie alle Schlüssel in einem Azure Key Vault sowie über alle gelöschten Schlüssel und die Versionen eines bestimmten Schlüssels abrufen und durchlaufen. Die folgenden API-Methoden sind verfügbar:

listPropertiesOfKeys listet alle Nicht gelöschten Schlüssel nur nach ihren Namen auf.
listDeletedKeys listet alle gelöschten Schlüssel nur nach ihren Namen auf.
listPropertiesOfKeyVersions listet alle Versionen eines Schlüssels basierend auf einem Schlüsselnamen auf.

Dies kann wie folgt verwendet werden:

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

Alle diese Methoden geben alle verfügbaren Ergebnisse gleichzeitig zurück. Um sie nach Seiten abzurufen, fügen Sie .byPage() direkt nach dem Aufrufen der API-Methode hinzu, die Sie verwenden möchten, wie folgt:

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

Kryptographie

Diese Bibliothek bietet auch eine Reihe von kryptografischen Hilfsprogrammen, die über CryptographyClientverfügbar sind. Ähnlich wie die KeyClientstellt CryptographyClient eine Verbindung mit Azure Key Vault mit den bereitgestellten Anmeldeinformationen her. Nach der Verbindung können CryptographyClient Schlüssel verschlüsseln, entschlüsseln, signieren, überprüfen, umschließen und Entschlüsselungsschlüssel entschlüsseln.

Wir können als Nächstes eine Verbindung mit dem Key Vault-Dienst herstellen, genau wie bei der KeyClient. Wir müssen einige Einstellungen aus dem Schlüsseltresor kopieren, mit dem wir eine Verbindung mit unseren Umgebungsvariablen herstellen. Sobald sie sich in unserer Umgebung befinden, können wir mit dem folgenden Code darauf zugreifen:

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

Verschlüsseln

encrypt verschlüsselt eine Nachricht.

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

Entschlüsseln

decrypt entschlüsselt eine verschlüsselte Nachricht.

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

Zeichen

sign signiert kryptografisch den Digest (Hash) einer Nachricht mit einer 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);

Signieren von Daten

signData signiert eine Nachricht kryptografisch mit einer 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);

Überprüfen

verify überprüft kryptografisch, ob der signierte Digest mit der angegebenen Signatur signiert wurde.

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

Überprüfen von Daten

verifyData überprüft kryptografisch, ob die signierte Nachricht mit der angegebenen Signatur signiert wurde.

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

Schlüssel packen

wrapKey umschließt einen Schlüssel mit einer Verschlüsselungsebene.

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

Schlüssel entpacken

unwrapKey entpackt einen umschlossenen Schlüssel.

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

Problembehandlung

Weitere Informationen zur Diagnose verschiedener Fehlerszenarien finden Sie in unserem Anleitung zur Problembehandlung.

Das Aktivieren der Protokollierung kann hilfreiche Informationen zu Fehlern aufdecken. Um ein Protokoll von HTTP-Anforderungen und -Antworten anzuzeigen, legen Sie die AZURE_LOG_LEVEL Umgebungsvariable auf infofest. Alternativ kann die Protokollierung zur Laufzeit durch Aufrufen von setLogLevel im @azure/loggeraktiviert werden:

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

setLogLevel("info");

Nächste Schritte

Weitere Codebeispiele finden Sie über die folgenden Links:

Mitarbeit

Wenn Sie an dieser Bibliothek mitwirken möchten, lesen Sie bitte den mitwirkenden Leitfaden, um mehr über das Erstellen und Testen des Codes zu erfahren.