Azure Key Vault Key-Clientbibliothek für JavaScript– Version 4.8.0

Artikel
02/26/2024

Azure Key Vault ist ein Dienst, mit dem Sie Authentifizierungsschlüssel, Speicherkontoschlüssel, Datenverschlüsselungsschlüssel, PFX-Dateien und Kennwörter mithilfe von geschützten Schlüsseln verschlüsseln können. Wenn Sie mehr über Azure Key Vault erfahren möchten, sollten Sie folgendes lesen: Was ist Azure Key Vault?

Azure Key Vault Managed HSM ist ein vollständig verwalteter, hochverfügbarer, standardkonformer Clouddienst mit nur einem Mandanten, mit dem Sie kryptografische Schlüssel für Ihre Cloudanwendungen mit 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 lesen: Was ist Azure Key Vault Managed HSM?

Der Azure Key Vault-Schlüsselbibliotheksclient unterstützt RSA-Schlüssel, EC-Schlüssel (Elliptic Curve) sowie symmetrische Schlüssel (Oct), 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 ihrer Versionen.

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

Erstellen Sie Schlüssel mit elliptischer Kurve oder RSA-Verschlüsselung, optional unterstützt durch Hardwaresicherheitsmodule (HSM).
Schlüssel importieren, löschen und aktualisieren.
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
Rufen Sie die Versionen eines Schlüssels ab.

Mithilfe des in dieser Bibliothek verfügbaren Kryptografieclients haben Sie auch Zugriff auf:

Verschlüsselt
Entschlüsseln
Signieren
Überprüfen
Umschließen von Schlüsseln
Entpacken von Schlüsseln

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

Wichtige Links:

Erste Schritte

Die derzeitig unterstützten 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 diesem Dokument ausführen. Alternativ können Sie die Azure CLI verwenden, indem Sie die folgenden Schritte ausführen.
Wenn Sie verwaltetes HSM verwenden, ist ein vorhandenes Azure Key Vault Managed HSM vorhanden. Wenn Sie ein verwaltetes HSM erstellen müssen, können Sie dies mithilfe der Azure CLI tun, indem Sie die Schritte in diesem Dokument ausführen.

Installieren des Pakets

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 es 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 in Ihrem tsconfig.json aktivieren compilerOptions.allowSyntheticDefaultImports . Beachten Sie, dass, wenn Sie aktiviert compilerOptions.esModuleInterophaben, allowSyntheticDefaultImports standardmäßig aktiviert ist. Weitere Informationen finden Sie im Handbuch für Compileroptionen von TypeScript .

Wichtige Begriffe

Der Schlüsselclient 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 es einen grundlegenden Satz von Methoden bereit, die zum Erstellen, Lesen, Aktualisieren und Löschen von Schlüsseln verwendet werden können.
Eine Schlüsselversion 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. Beim Abrufen eines Schlüssels nach einem Namen wird immer der neueste zugewiesene Wert zurückgegeben, es sei denn, eine bestimmte Version wird für die Abfrage bereitgestellt.
Vorläufiges Löschen ermöglicht es Key Vaults, das Löschen und Löschen in zwei separaten Schritten zu unterstützen, sodass gelöschte Schlüssel nicht sofort verloren gehen. Dies geschieht nur, wenn für die Key Vault vorläufiges Löschen aktiviert ist.
Eine Schlüsselsicherung kann aus jedem erstellten Schlüssel generiert werden. Diese Sicherungen werden als Binärdaten verwendet 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 mit einem Schlüssel 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 verwendet Azure Active Directory, um Anforderungen an seine APIs zu authentifizieren. Das @azure/identity Paket bietet eine Vielzahl von Anmeldeinformationstypen, die Ihre Anwendung dazu verwenden kann. Die INFODATEI 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 instance der KeyClient -Klasse, eine Tresor-URL und ein Anmeldeinformationsobjekt erstellen. Die in diesem Dokument gezeigten Beispiele verwenden ein Anmeldeinformationsobjekt namens DefaultAzureCredential, das für die meisten Szenarien geeignet ist, einschließlich lokaler Entwicklungs- und Produktionsumgebungen. Darüber hinaus wird die Verwendung einer verwalteten Identität für die Authentifizierung in Produktionsumgebungen empfohlen.

Weitere Informationen zu verschiedenen Authentifizierungsmethoden und den entsprechenden Anmeldeinformationstypen finden Sie in der Dokumentation zu Azure Identity.

Hier sehen Sie ein kurzes Beispiel. Importieren Sie DefaultAzureCredential zunächst und KeyClient:

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

Nachdem diese importiert wurden, können wir als Nächstes eine Verbindung mit dem Key Vault-Dienst herstellen:

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

Angeben der API-Version des Azure Key Vault-Diensts

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

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

Beispiele

Die folgenden Abschnitte enthalten Codeausschnitte, die einige der allgemeinen Aufgaben mit Azure Key Vault Keys behandeln. Die szenarien, die hier behandelt werden, 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 Schlüssellisten.

Erstellen eines Schlüssels

createKeyerstellt 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.

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

Der zweite Parameter, der an createKey gesendet wird, ist der Typ des Schlüssels. Der Typ der unterstützten Schlüssel hängt von der SKU ab und davon, ob Sie ein Azure Key Vault oder ein Azure Managed HSM verwenden. Eine aktuelle Liste der unterstützten Schlüsseltypen finden Sie unter Informationen zu Schlüsseln.

Abrufen eines Schlüssels

Die einfachste Möglichkeit zum Zurücklesen von Schlüsseln aus dem Tresor besteht darin, einen Schlüssel anhand des Namens abzurufen. 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.

getKeyruft einen vorherigen Schlüsselspeicher im Key Vault ab.

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

Erstellen und Aktualisieren von Schlüsseln mit Attributen

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

tags: Beliebiger Satz von Schlüsseln und Werten, 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, , decryptsign, verifywrapKey, , unwrapKey).
enabled: Ein boolescher Wert, der bestimmt, ob der Schlüsselwert gelesen werden kann oder nicht.
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 nach dem Namen und Wert des Schlüssels:

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

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

Attribute können auch wie folgt auf eine vorhandene Schlüsselversion mit updateKeyPropertiesaktualisiert werden:

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

Löschen eines Schlüssels

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

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

Wenn vorläufiges Löschen für die Key Vault aktiviert ist, wird der Schlüssel durch diesen Vorgang nur als gelöschter Schlüssel bezeichnet. Ein gelöschter Schlüssel kann nicht aktualisiert werden. Sie können nur gelesen, wiederhergestellt oder gelöscht werden.

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

Da Schlüssel einige Zeit in Anspruch nehmen, bis sie vollständig gelöscht werden, gibt ein Poller-Objekt zurück, beginDeleteKey das den zugrunde liegenden lang andauernden Vorgang gemäß unseren Richtlinien nachverfolgt: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

Mit dem empfangenen Abrufprogramm können Sie den gelöschten Schlüssel abrufen, indem Sie aufrufen poller.getResult(). Sie können auch warten, bis der Löschvorgang abgeschlossen ist, indem Sie entweder einzelne Dienstaufrufe ausführen, bis der Schlüssel gelöscht wird, oder indem Sie warten, bis der Vorgang abgeschlossen ist:

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

Eine weitere Möglichkeit, zu warten, bis der Schlüssel vollständig gelöscht ist, besteht darin, einzelne Aufrufe wie folgt auszuführen:

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

Konfigurieren der automatischen Schlüsselrotation

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

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

Durchlaufen von Schlüssellisten

Mithilfe des KeyClients können Sie alle Schlüssel in einem Azure-Key Vault sowie 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 in den aktuellen Versionen nach ihren Namen auf.
listDeletedKeys listet alle gelöschten Schlüssel nur in den neuesten Versionen mit ihren Namen auf.
listPropertiesOfKeyVersions listet alle Versionen eines Schlüssels basierend auf einem Schlüsselnamen auf.

Diese kann wie folgt verwendet werden:

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

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

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

Kryptografie

Diese Bibliothek bietet auch eine Reihe von kryptografischen Hilfsprogrammen, die über verfügbar sind CryptographyClient. KeyClientÄhnlich wie bei wird CryptographyClient eine Verbindung mit Azure Key Vault mit dem bereitgestellten Anmeldeinformationssatz hergestellt. Sobald eine Verbindung hergestellt wurde, CryptographyClient kann sie verschlüsseln, entschlüsseln, signieren, überprüfen, Schlüssel umschließen und Schlüssel entpacken.

Wir können als Nächstes eine Verbindung mit dem Schlüsseltresordienst herstellen, genau wie mit .KeyClient Wir müssen einige Einstellungen aus dem Schlüsseltresor, mit dem wir eine Verbindung herstellen, in unsere Umgebungsvariablen kopieren. 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 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();

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

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

Signieren

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

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

Überprüfung

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

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

Schlüssel umschließen

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

Schlüssel zum 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 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();

Problembehandlung

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

Die Aktivierung der Protokollierung kann hilfreiche Informationen über Fehler aufdecken. Um ein Protokoll von HTTP-Anforderungen und -Antworten anzuzeigen, legen Sie die Umgebungsvariable AZURE_LOG_LEVEL auf info fest. Alternativ kann die Protokollierung zur Laufzeit aktiviert werden, indem Sie setLogLevel in @azure/logger aufrufen:

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

setLogLevel("info");

Nächste Schritte

Weitere Codebeispiele finden Sie unter den folgenden Links:

Mitwirken

Wenn Sie an dieser Bibliothek mitwirken möchten, lesen Sie die Anleitung für Mitwirkende, um mehr darüber zu erfahren, wie Sie den Code erstellen und testen können.

Aufrufe

Freigeben über