Udostępnij za pośrednictwem

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

  • Artykuł

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 platformy Azure Key Vault to w pełni zarządzana, wysoce dostę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 przejrzeć artykuł: Co to jest zarządzany moduł HSM platformy Azure Key Vault?

Klient biblioteki kluczy usługi Azure Key Vault obsługuje klucze RSA, klucze krzywej eliptycznej (EC), a także klucze symetryczne (okta) 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:

  • Tworzenie kluczy przy użyciu krzywej eliptycznej lub szyfrowania RSA, opcjonalnie wspieranego 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
  • Podpisywanie
  • Weryfikowanie
  • Klucze zawijania
  • Odpisanie kluczy

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

Linki kluczowe:

Wprowadzenie

Obecnie obsługiwane środowiska

Wymagania wstępne

Instalowanie pakietu

Instalowanie biblioteki klienta usługi Azure Key Vault Key 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. Pamiętaj, że jeśli włączono compilerOptions.esModuleInteropopcję , allowSyntheticDefaultImports jest domyślnie włączona. Aby uzyskać więcej informacji, zobacz podręcznik opcji kompilatora języka TypeScript .

Kluczowe pojęcia

  • Klient klucza jest podstawowym interfejsem umożliwiającym 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 jest wersją klucza w Key Vault. Za każdym razem, gdy użytkownik przypisuje wartość do unikatowej nazwy klucza, tworzona jest nowa wersja tego klucza. Pobranie klucza według nazwy zawsze zwróci najnowszą przypisaną wartość, chyba że określona wersja zostanie dostarczona do zapytania.
  • Usuwanie nietrwałe umożliwia magazynom kluczy obsługę usuwania i przeczyszczania jako dwóch oddzielnych kroków, dlatego usunięte klucze nie są natychmiast tracone. Dzieje się tak tylko wtedy, gdy Key Vault ma włączone usuwanie nietrwałe.
  • Kopię zapasową klucza można wygenerować na podstawie dowolnego utworzonego klucza. Te kopie zapasowe są danymi binarnymi i mogą być używane tylko do ponownego generowania wcześniej usuniętego klucza.
  • Klient kryptografii jest oddzielnym interfejsem, który współdziała z metodami interfejsu API kluczy w interfejsie API 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 Key Vault. Więcej informacji o tym kliencie znajduje się w sekcji Kryptografia .

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 zawiera @azure/identity więcej szczegółów i przykładów, które ułatwiają rozpoczęcie pracy.

Aby wchodzić w interakcje z usługą Azure Key Vault, należy utworzyć wystąpienie KeyClient klasy, adres URL magazynu i obiekt poświadczeń. W przykładach przedstawionych w tym dokumencie użyto 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żywanie 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 tożsamości platformy Azure.

Oto szybki przykład. Najpierw zaimportuj DefaultAzureCredential i KeyClient:

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

Po zaimportowaniu tych elementów możemy nawiązać połączenie z usługą Key Vault:

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

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

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

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

Przykłady

Poniższe sekcje zawierają fragmenty kodu, które obejmują niektóre typowe zadania korzystające z kluczy usługi Azure Key Vault. Scenariusze, które zostały tu omówione, składają się z następujących elementów:

Tworzenie klucza

createKeyTworzy klucz, który ma być przechowywany w usłudze Azure Key Vault. Jeśli klucz o tej samej nazwie już istnieje, zostanie utworzona nowa wersja klucza.

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

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. Aby uzyskać aktualną listę obsługiwanych typów kluczy, zobacz Informacje o kluczach

Uzyskiwanie klucza

Najprostszym sposobem odczytu kluczy z magazynu jest uzyskanie 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.

getKeypobiera klucz poprzednich magazynów w Key Vault.

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

Tworzenie i aktualizowanie kluczy za pomocą atrybutów

Następujące atrybuty można również przypisać do dowolnego klucza w Key Vault:

  • tags: dowolny zestaw klucz-wartości, który może służyć do wyszukiwania i filtrowania kluczy.
  • keyOps: Tablica operacji, które ten klucz będzie mógł wykonać (encrypt, decrypt, sign, verify, wrapKeyunwrapKey).
  • 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:

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

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ą updateKeyPropertiespolecenia w następujący sposób:

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

Usuwanie klucza

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

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

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

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

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żliwi pobranie usuniętego klucza przez wywołanie metody poller.getResult(). Możesz również poczekać na zakończenie usuwania, uruchamiając pojedyncze wywołania usługi do momentu usunięcia klucza lub czekając na zakończenie procesu:

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

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

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

Konfigurowanie automatycznego obracania kluczy

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

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

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 Program wyświetli listę wszystkich kluczy, które nie zostały usunięte według ich nazw, tylko w najnowszych wersjach.
  • listDeletedKeys Program wyświetli listę wszystkich usuniętych kluczy według ich nazw, tylko w najnowszych wersjach.
  • listPropertiesOfKeyVersions program wyświetli listę wszystkich wersji klucza na podstawie nazwy klucza.

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

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

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:

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

Kryptografia

Ta biblioteka oferuje również zestaw narzędzi kryptograficznych dostępnych za pośrednictwem programu CryptographyClient. Podobnie jak w przypadku elementu KeyClient, CryptographyClient połączy się z usługą Azure Key Vault z podanym zestawem poświadczeń. Po nawiązaniu połączenia CryptographyClient można szyfrować, odszyfrowywać, podpisywać, weryfikować, opakowywać 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, do naszych zmiennych środowiskowych. Gdy znajdują się one w naszym środowisku, możemy uzyskać do nich dostęp za pomocą 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 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();

Encrypt

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

Decrypt

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

Znak

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

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

Dane podpisywania

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

Weryfikacja

verify Program kryptograficznie sprawdzi, czy podpisany skrót został podpisany przy użyciu podanego podpisu.

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

Weryfikowanie danych

verifyData Program zweryfikuje kryptograficznie, czy podpisana wiadomość została podpisana przy użyciu podanego 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 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();

Zawijanie klucza

wrapKey spowoduje zawijanie klucza za pomocą warstwy 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 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();

Odpakowywanie klucza

unwrapKey spowoduje rozpaklenie 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 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();

Rozwiązywanie problemów

Zobacz nasz przewodnik rozwiązywania problemów , 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ą AZURE_LOG_LEVEL środowiskową na info. Alternatywnie rejestrowanie można włączyć w czasie wykonywania, wywołując setLogLevel polecenie w pliku @azure/logger:

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

setLogLevel("info");

Następne kroki

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

Współtworzenie

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

Wrażenia