Udostępnij za pomocą

Biblioteka klienta kluczy usługi Azure Key Vault dla języka JavaScript — wersja 4.10.0

Azure Key Vault to usługa, która umożliwia szyfrowanie kluczy uwierzytelniania, kluczy konta magazynu, kluczy szyfrowania danych, plików pfx i haseł przy użyciu zabezpieczonych kluczy. Jeśli chcesz dowiedzieć się więcej o usłudze Azure Key Vault, warto zapoznać się z tematem: Co to jest usługa Azure Key Vault?

Zarządzany moduł HSM usługi Azure Key Vault to w pełni zarządzana, wysoce dostępna, jednodostępna, zgodna ze standardami usługa w chmurze, która umożliwia ochronę kluczy kryptograficznych dla aplikacji w chmurze przy użyciu zweryfikowanych modułów HSM fiPS 140-2 poziom 3. Jeśli chcesz dowiedzieć się więcej na temat zarządzanego modułu HSM usługi Azure Key Vault, warto zapoznać się z artykułem: Co to jest zarządzany moduł HSM usługi Azure Key Vault?

Klient biblioteki kluczy usługi Azure Key Vault obsługuje klucze RSA, klucze Elliptic Curve (EC), a także klucze symetryczne (oct) podczas uruchamiania względem zarządzanego modułu HSM, z których każda obsługuje sprzętowe moduły zabezpieczeń (HSM). Oferuje ona operacje tworzenia, pobierania, aktualizowania, usuwania, przeczyszczania, tworzenia kopii zapasowej, przywracania i wyświetlania listy kluczy i jego wersji.

Użyj biblioteki klienta dla kluczy usługi Azure Key Vault w aplikacji Node.js, aby:

  • Utwórz klucze przy użyciu krzywej eliptycznej lub szyfrowania RSA, opcjonalnie wspierane przez sprzętowe moduły zabezpieczeń (HSM).
  • Importowanie, usuwanie i aktualizowanie kluczy.
  • Pobierz co najmniej jeden klucz i usunięte klucze z ich atrybutami.
  • Odzyskiwanie usuniętego klucza i przywracanie kopii zapasowej klucza.
  • Pobierz wersje klucza.

Korzystając z klienta kryptografii dostępnego w tej bibliotece, masz również dostęp do:

  • Szyfrowania
  • Odszyfrowywania
  • Podpis
  • Weryfikowanie
  • Klucze zawijania
  • Rozpasanie kluczy

Uwaga: nie można używać tego pakietu w przeglądarce z powodu ograniczeń usługi Azure Key Vault, zapoznaj się z tym dokumencie wskazówki.

Kluczowe linki:

Wprowadzenie

Obecnie obsługiwane środowiska

  • Wersje LTS systemu Node.js

Wymagania wstępne

Instalowanie pakietu

Instalowanie biblioteki klienta kluczy usługi Azure Key Vault przy użyciu narzędzia npm

npm install @azure/keyvault-keys

Instalowanie biblioteki tożsamości

Klienci usługi Azure Key Vault uwierzytelniają się przy użyciu biblioteki tożsamości platformy Azure. Zainstaluj go również przy użyciu narzędzia npm

npm install @azure/identity

Konfigurowanie języka TypeScript

Użytkownicy języka TypeScript muszą mieć zainstalowane definicje typu węzła:

npm install @types/node

Należy również włączyć compilerOptions.allowSyntheticDefaultImports w tsconfig.json. Należy pamiętać, że jeśli włączono compilerOptions.esModuleInterop, allowSyntheticDefaultImports jest domyślnie włączona. Aby uzyskać więcej informacji, zobacz podręcznik opcje kompilatora języka TypeScript.

Najważniejsze pojęcia

  • Klucz klienta to podstawowy interfejs umożliwiający interakcję z metodami interfejsu API powiązanymi z kluczami w interfejsie API usługi Azure Key Vault z poziomu aplikacji JavaScript. Po zainicjowaniu udostępnia on podstawowy zestaw metod, których można użyć do tworzenia, odczytywania, aktualizowania i usuwania kluczy.
  • Wersja klucza to wersja klucza w usłudze Key Vault. Za każdym razem, gdy użytkownik przypisuje wartość do unikatowej nazwy klucza, tworzona jest nowa wersja tego klucza. Pobieranie klucza według nazwy zawsze zwróci najnowszą przypisaną wartość, chyba że do zapytania zostanie podana określona wersja.
  • usuwanie nietrwałe umożliwia magazynom kluczy obsługę usuwania i przeczyszczania jako dwóch oddzielnych kroków, dlatego usunięte klucze nie zostaną natychmiast utracone. Dzieje się tak tylko wtedy, gdy usługa Key Vault włączona usuwania nietrwałego.
  • kopii zapasowej klucza można wygenerować na podstawie dowolnego utworzonego klucza. Te kopie zapasowe są danymi binarnymi i mogą być używane tylko do ponownego wygenerowania wcześniej usuniętego klucza.
  • klienta kryptografii to oddzielny interfejs, który współdziała z metodami interfejsu API kluczy w interfejsie API usługi Key Vault. Ten klient koncentruje się tylko w operacjach kryptograficznych, które można wykonać przy użyciu klucza, który został już utworzony w usłudze Key Vault. Więcej informacji na temat tego klienta znajduje się w sekcji kryptografii.

Uwierzytelnianie za pomocą usługi Azure Active Directory

Usługa Key Vault korzysta z usługi Azure Active Directory do uwierzytelniania żądań w swoich interfejsach API. Pakiet @azure/identity udostępnia różne typy poświadczeń, których aplikacja może użyć do tego celu. Plik README dla @azure/identity zawiera więcej szczegółów i przykładów, które ułatwiają rozpoczęcie pracy.

Aby móc korzystać z usługi Azure Key Vault, należy utworzyć wystąpienie klasy KeyClient, adres URL magazynu i obiekt poświadczeń. Przykłady przedstawione w tym dokumencie używają obiektu poświadczeń o nazwie DefaultAzureCredential, który jest odpowiedni dla większości scenariuszy, w tym lokalnych środowisk programistycznych i produkcyjnych. Ponadto zalecamy użycie tożsamości zarządzanej do uwierzytelniania w środowiskach produkcyjnych.

Więcej informacji na temat różnych sposobów uwierzytelniania i odpowiadających im typów poświadczeń można znaleźć w dokumentacji Azure Identity.

Oto szybki przykład. Najpierw zaimportuj DefaultAzureCredential i KeyClient. Po zaimportowaniu tych elementów możemy połączyć się z usługą Key Vault:

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

Określanie wersji interfejsu API usługi Azure Key Vault

Domyślnie ten pakiet używa najnowszej wersji usługi Azure Key Vault, która jest 7.2. Możesz zmienić używaną wersję usługi, ustawiając opcję serviceVersion w konstruktorze klienta, jak pokazano poniżej:

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

Przykłady

W poniższych sekcjach przedstawiono fragmenty kodu, które obejmują niektóre typowe zadania korzystające z kluczy usługi Azure Key Vault. Scenariusze, które zostały tutaj omówione, składają się z następujących elementów:

Tworzenie klucza

createKey tworzy klucz do przechowywania w usłudze Azure Key Vault. Jeśli klucz o tej samej nazwie już istnieje, zostanie utworzona nowa wersja klucza.

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

Drugi parametr wysyłany do createKey jest typem klucza. Obsługiwany typ kluczy zależy od jednostki SKU i tego, czy używasz usługi Azure Key Vault, czy zarządzanego modułu HSM platformy Azure. Listę obsługiwanych typów kluczy up-tomożna znaleźć w Informacje o kluczach

Uzyskiwanie klucza

Najprostszym sposobem odczytu kluczy z magazynu jest pobranie klucza według nazwy. Spowoduje to pobranie najnowszej wersji klucza. Opcjonalnie możesz pobrać inną wersję klucza, jeśli określisz go jako część parametrów opcjonalnych.

getKey pobiera poprzednie magazyny kluczy w usłudze Key Vault.

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

const credential = new DefaultAzureCredential();

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

const client = new KeyClient(url, credential);

const keyName = "MyKeyName";

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

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

Tworzenie i aktualizowanie kluczy za pomocą atrybutów

Do dowolnego klucza w usłudze Key Vault można również przypisać następujące atrybuty:

  • tags: dowolny zestaw klucz-wartości, których można użyć do wyszukiwania i filtrowania kluczy.
  • keyOps: tablica operacji, które ten klucz będzie mógł wykonać (encrypt, decrypt, sign, verify, wrapKey, unwrapKey).
  • enabled: wartość logiczna określająca, czy wartość klucza może być odczytywana, czy nie.
  • notBefore: dana data, po której można pobrać wartość klucza.
  • expires: dana data, po której nie można pobrać wartości klucza.

Obiekt z tymi atrybutami można wysłać jako trzeci parametr createKey, bezpośrednio po nazwie i wartości klucza w następujący sposób:

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

Spowoduje to utworzenie nowej wersji tego samego klucza, która będzie zawierać najnowsze podane atrybuty.

Atrybuty można również zaktualizować do istniejącej wersji klucza za pomocą updateKeyProperties, w następujący sposób:

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

Usuwanie klucza

Metoda beginDeleteKey rozpoczyna usuwanie klucza. Ten proces będzie występować w tle natychmiast po udostępnieniu niezbędnych zasobów.

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

Jeśli usuwania nietrwałego jest włączona dla usługi Key Vault, ta operacja będzie oznaczać tylko klucz jako klucz usunięty. Nie można zaktualizować usuniętego klucza. Mogą być odczytywane, odzyskiwane lub czyszczone.

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

Ponieważ usunięcie kluczy zajmuje trochę czasu, beginDeleteKey zwraca obiekt Poller, który śledzi podstawową operację długotrwałą zgodnie z naszymi wytycznymi: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

Odebrany element poller umożliwia pobranie usuniętego klucza przez wywołanie polecenia poller.getResult(). Możesz również poczekać na zakończenie usuwania, uruchamiając poszczególne wywołania usługi do momentu usunięcia klucza lub czekając na zakończenie procesu:

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

Innym sposobem oczekiwania na całkowite usunięcie klucza jest wykonywanie poszczególnych wywołań w następujący sposób:

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

Konfigurowanie automatycznego obracania kluczy

Za pomocą elementu KeyClient można skonfigurować automatyczną rotację kluczy dla klucza, określając zasady rotacji. Ponadto usługa KeyClient udostępnia metodę rotacji klucza na żądanie przez utworzenie nowej wersji danego klucza.

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

Iterowanie list kluczy

Za pomocą klienta KeyClient można pobierać i iterować wszystkie klucze w usłudze Azure Key Vault, a także za pośrednictwem wszystkich usuniętych kluczy i wersji określonego klucza. Dostępne są następujące metody interfejsu API:

  • listPropertiesOfKeys wyświetli listę wszystkich kluczy, które nie zostały usunięte według ich nazw, tylko w ich najnowszych wersjach.
  • listDeletedKeys wyświetli listę wszystkich usuniętych kluczy według ich nazw, tylko w ich najnowszych wersjach.
  • listPropertiesOfKeyVersions wyświetli listę wszystkich wersji klucza na podstawie nazwy klucza.

Których można użyć w następujący sposób:

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

Wszystkie te metody będą zwracać wszystkie dostępne wyniki jednocześnie. Aby pobrać je według stron, dodaj .byPage() bezpośrednio po wywołaniu metody interfejsu API, której chcesz użyć, w następujący sposób:

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

Kryptografia

Ta biblioteka oferuje również zestaw narzędzi kryptograficznych dostępnych za pośrednictwem CryptographyClient. Podobnie jak w przypadku KeyClientCryptographyClient połączy się z usługą Azure Key Vault przy użyciu podanego zestawu poświadczeń. Po nawiązaniu połączenia CryptographyClient mogą szyfrować, odszyfrowywać, podpisywać, weryfikować, zawijać klucze i odpakowywać klucze.

Następnie możemy nawiązać połączenie z usługą magazynu kluczy tak samo jak w przypadku KeyClient. Musimy skopiować niektóre ustawienia z magazynu kluczy, z którym nawiązujemy połączenie z naszymi zmiennymi środowiskowymi. Gdy znajdują się one w naszym środowisku, możemy uzyskać do nich dostęp przy użyciu następującego kodu:

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

Szyfrowanie

encrypt zaszyfruje komunikat.

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

Odszyfrowywanie

decrypt odszyfruje zaszyfrowaną wiadomość.

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

Zaloguj

sign kryptograficznie podpisze skrót (skrót) wiadomości z podpisem.

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

Dane podpisywania

signData będzie kryptograficznie podpisywać komunikat z podpisem.

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

Weryfikacja

verify zweryfikuje kryptograficznie, czy podpisany skrót został podpisany przy użyciu danego podpisu.

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

Weryfikowanie danych

verifyData zweryfikuje kryptograficznie, czy podpisana wiadomość została podpisana przy użyciu danego podpisu.

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

Opakuj klucz

wrapKey opakowuje klucz warstwą szyfrowania.

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

Odpakuj klucz

unwrapKey spowoduje odpakowywanie opakowanego klucza.

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

Rozwiązywanie problemów

Zobacz nasz przewodnik rozwiązywania problemów z , aby uzyskać szczegółowe informacje na temat diagnozowania różnych scenariuszy awarii.

Włączenie rejestrowania może pomóc odkryć przydatne informacje o błędach. Aby wyświetlić dziennik żądań i odpowiedzi HTTP, ustaw zmienną środowiskową AZURE_LOG_LEVEL na info. Alternatywnie rejestrowanie można włączyć w czasie wykonywania, wywołując setLogLevel w @azure/logger:

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

setLogLevel("info");

Dalsze kroki

Więcej przykładów kodu można znaleźć za pośrednictwem następujących linków:

Wkład

Jeśli chcesz współtworzyć tę bibliotekę, przeczytaj przewodnik dotyczący współtworzenia , aby dowiedzieć się więcej na temat tworzenia i testowania kodu.

  • Last updated on