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

Azure Key Vault ist ein Dienst, mit dem Sie Authentifizierungsschlüssel, Speicherkontoschlüssel, Datenverschlüsselungsschlüssel, PFX-Dateien und Kennwörter mithilfe geschützter Schlüssel 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 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, die optional durch Hardwaresicherheitsmodule (HSM) unterstützt wird.
• Importieren, Löschen und Aktualisieren von Schlüsseln
• Rufen Sie mindestens einen Schlüssel und gelöschte Schlüssel mit ihren Attributen ab.
• Stellen Sie einen gelöschten Schlüssel wieder her, und stellen Sie einen gesicherten Schlüssel wieder her.
• Rufen Sie die Versionen eines Schlüssels ab.

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

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

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

Quellcode | Paket (npm) | API-Referenzdokumentation | Produktdokumentation | Beispiele

Erste Schritte

Die derzeitig unterstützten Umgebungen

• LTS-Versionen von Node.js
• Neueste Versionen von Safari, Chrome, Edge und Firefox.

Ausführlichere Informationen finden Sie in der Supportrichtlinie.

Voraussetzungen

• Ein Azure-Abonnement.
• Ein vorhandenes azure Key Vault Managed HSM. Wenn Sie eine Azure-Key Vault erstellen müssen, können Sie die Azure CLI verwenden.

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

Konfigurieren Ihrer Key Vault

Verwenden Sie den folgenden Azure CLI-Codeausschnitt , um Anmeldeinformationen für geheime Clientschlüssel zu erstellen/abzurufen.

• Erstellen Sie einen Dienstprinzipal, und konfigurieren Sie dessen Zugriff auf Azure-Ressourcen:

  az ad sp create-for-rbac -n <your-application-name> --skip-assignment
  

  Ausgabe:

  {
    "appId": "generated-app-ID",
    "displayName": "dummy-app-name",
    "name": "http://dummy-app-name",
    "password": "random-password",
    "tenant": "tenant-ID"
  }
  

• Verwenden Sie die oben zurückgegebenen Anmeldeinformationen, um AZURE_CLIENT_ID(appId), AZURE_CLIENT_SECRET(password) und AZURE_TENANT_ID(tenant) Umgebungsvariablen festzulegen. Das folgende Beispiel zeigt eine Möglichkeit, dies in Bash zu tun:

    export AZURE_CLIENT_ID="generated-app-ID"
    export AZURE_CLIENT_SECRET="random-password"
    export AZURE_TENANT_ID="tenant-ID"
  

• Erteilen Sie der oben genannten Anwendungsautorisierung, um Schlüsselvorgänge für den keyvault auszuführen:

  az keyvault set-policy --name <your-key-vault-name> --spn $AZURE_CLIENT_ID --key-permissions backup create decrypt delete encrypt get import list purge recover restore sign unwrapKey update verify wrapKey
  

  --key-permissions: Akzeptierte Werte: sichern, erstellen, entschlüsseln, löschen, verschlüsseln, abrufen, importieren, listen, bereinigen, wiederherstellen, wiederherstellen, signieren, unwrapKey, aktualisieren, überprüfen, wrapKey

  Wenn Sie stattdessen die rollenbasierte Zugriffssteuerung (Role-Based Access Control, RBAC) für Key Vault aktiviert haben, finden Sie Rollen wie "Key Vault Crypto Officer" in unserem RBAC-Leitfaden.

  Wenn Sie Ihre Schlüssel mit verwaltetem HSM verwalten, lesen Sie die Zugriffssteuerung, die verschiedene integrierte Rollen unterstützt, die von Azure Resource Manager (ARM) isoliert sind.

• Verwenden Sie den oben genannten Key Vault Namen, um Details zu Ihrem Tresor abzurufen, der auch Ihre Key Vault-URL enthält:

  az keyvault show --name <your-key-vault-name>
  

Aktivieren Ihres verwalteten HSM

Dieser Abschnitt gilt nur, wenn Sie ein verwaltetes HSM erstellen. Wenn Sie eine Azure-Key Vault erstellen, können Sie mit dem nächsten Abschnitt fortfahren.

Bis zur Aktivierung des HSM sind alle Datenebenenbefehle deaktiviert. Sie können keine Schlüssel erstellen oder Rollen zuweisen. Nur die designierten Administratoren, die im Rahmen des Erstellungsbefehls zugewiesen wurden, können das HSM aktivieren. Zum Aktivieren des HSM müssen Sie die Sicherheitsdomäne herunterladen.

Für die HSM-Aktivierung benötigen Sie Folgendes:

• Mindestens 3 RSA-Schlüsselpaare (maximal 10).
• Geben Sie die Mindestanzahl von Schlüsseln an, die zum Entschlüsseln der Sicherheitsdomäne (Quorum) erforderlich sind. Zum Aktivieren des HSM senden Sie mindestens 3 (maximal 10) öffentliche RSA-Schlüssel an das HSM. Das HSM verschlüsselt die Sicherheitsdomäne mit diesen Schlüsseln und sendet sie zurück. Nachdem diese Sicherheitsdomäne erfolgreich heruntergeladen wurde, ist Ihr HSM einsatzbereit. Darüber hinaus müssen Sie ein Quorum angeben. Hierbei handelt es sich um die Mindestanzahl privater Schlüssel, die zum Entschlüsseln der Sicherheitsdomäne erforderlich sind.

Im folgenden Beispiel wird gezeigt, wie Sie openssl verwenden, um 3 selbstsignierte Zertifikate zu generieren.

openssl req -newkey rsa:2048 -nodes -keyout cert_0.key -x509 -days 365 -out cert_0.cer
openssl req -newkey rsa:2048 -nodes -keyout cert_1.key -x509 -days 365 -out cert_1.cer
openssl req -newkey rsa:2048 -nodes -keyout cert_2.key -x509 -days 365 -out cert_2.cer

Verwenden Sie den Befehl az keyvault security-domain download, um die Sicherheitsdomäne herunterzuladen und Ihr verwaltetes HSM zu aktivieren. Im folgenden Beispiel werden 3 RSA-Schlüsselpaare verwendet (für diesen Befehl werden nur öffentliche Schlüssel benötigt) und das Quorum auf 2 festgelegt.

az keyvault security-domain download --hsm-name <your-key-vault-name> --sd-wrapping-keys ./certs/cert_0.cer ./certs/cert_1.cer ./certs/cert_2.cer --sd-quorum 2 --security-domain-file ContosoMHSM-SD.json

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 es 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. Das Abrufen eines Schlüssels nach einem Namen gibt immer den zuletzt zugewiesenen Wert zurück, es sei denn, für die Abfrage wird eine bestimmte Version bereitgestellt.
• Das vorläufige 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.
• Aus jedem erstellten Schlüssel kann eine Schlüsselsicherung 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 kryptografische Vorgä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 stellt eine Vielzahl von Anmeldeinformationstypen bereit, die Ihre Anwendung dazu verwenden kann. Die INFOdatei für @azure/identity enthält weitere Details und Beispiele für die ersten Schritte.

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

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

Sobald diese importiert wurden, können wir eine Verbindung mit dem Azure Key Vault-Dienst herstellen. Hierzu müssen wir einige Einstellungen aus dem Azure-Key Vault, 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:

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

// DefaultAzureCredential expects the following three environment variables:
// * AZURE_TENANT_ID: The tenant ID in Azure Active Directory
// * AZURE_CLIENT_ID: The application (client) ID registered in the AAD tenant
// * AZURE_CLIENT_SECRET: The client secret for the registered application
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, nämlich 7.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 häufigen Aufgaben mit Azure Key Vault Keys behandeln. 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 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 an gesendete createKey Parameter ist der Typ des Schlüssels. Der Typ der unterstützten Schlüssel hängt von der SKU ab und davon, ob Sie eine Azure-Key Vault oder ein verwaltetes Azure-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 nach Name 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 Schlüssel ab, der zuvor im Key Vault gespeichert 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 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üsselwerten, die zum Suchen und Filtern von Schlüsseln verwendet werden können.
• keyOps: Ein Array der Vorgänge, die mit diesem Schlüssel ausgeführt werden können (encrypt, , decryptsign, verify, wrapKey). 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 hinter 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 zuletzt 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 beginnt mit dem 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 bei diesem 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, beginDeleteKey gibt ein Poller-Objekt zurück, das den zugrunde liegenden Langlaufvorgang gemäß unseren Richtlinien nachverfolgt: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

Mit dem empfangenen Abfrageprogramm 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 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 wurde, besteht darin, einzelne Aufrufe wie folgt auszuführen:

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

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

Iterieren von Schlüssellisten

Mithilfe des KeyClient können Sie alle Schlüssel in einer 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 neuesten Versionen nach ihrem Namen auf.
• listDeletedKeys listet alle gelöschten Schlüssel nur in den neuesten Versionen nach ihrem 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 direkt nach dem Aufrufen der API-Methode, die Sie verwenden möchten, wie folgt hinzu .byPage() :

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

Kryptografie

Diese Bibliothek bietet auch eine Reihe von kryptografischen Hilfsprogrammen, die über CryptographyClientverfügbar sind. KeyClientÄhnlich wie wird CryptographyClient eine Verbindung mit Azure Key Vault mit den angegebenen Anmeldeinformationen hergestellt. Sobald die Verbindung hergestellt wurde, CryptographyClient können Sie Schlüssel verschlüsseln, entschlüsseln, signieren, überprüfen, umschließen und Schlüssel auspacken.

Wir können als nächstes eine Verbindung mit dem Schlüsseltresordienst herstellen, genau wie mit dem 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);
}

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

Daten signieren

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

Daten überprüfen

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üsselungsschicht.

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 auspacken

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

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 über die folgenden Links:

• KeyVault-Schlüsselbeispiele (JavaScript)
• KeyVault-Schlüsselbeispiele (TypeScript)
• KeyVault Keys–Testfälle

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.