Sdílet prostřednictvím

Klientská knihovna Azure Key Vault Key pro JavaScript – verze 4.8.0

  • Článek

Azure Key Vault je služba, která umožňuje šifrovat ověřovací klíče, klíče účtu úložiště, šifrovací klíče dat, soubory .pfx a hesla pomocí zabezpečených klíčů. Pokud se chcete o Azure Key Vault dozvědět více, můžete si projít téma Co je Azure Key Vault?

Azure Key Vault Managed HSM je plně spravovaná, vysoce dostupná cloudová služba s jedním tenantem kompatibilní se standardy, která umožňuje chránit kryptografické klíče pro cloudové aplikace pomocí modulů HSM ověřených standardem FIPS 140-2 Level 3. Pokud se chcete o spravovaném HSM Azure Key Vault dozvědět více, můžete si projít téma Co je Azure Key Vault Managed HSM?

Klient knihovny klíčů Azure Key Vault podporuje klíče RSA, klíče EC (Elliptic Curve) a také symetrické klíče (oct) při spuštění proti spravovanému HSM, přičemž každá z nich má odpovídající podporu v modulech hardwarového zabezpečení (HSM). Nabízí operace pro vytvoření, načtení, aktualizaci, odstranění, vymazání, zálohování, obnovení a výpis klíčů a jejich verzí.

Pomocí klientské knihovny klíčů Azure Key Vault v aplikaci Node.js můžete:

  • Vytvořte klíče pomocí eliptické křivky nebo šifrování RSA, které jsou volitelně podporovány moduly hardwarového zabezpečení (HSM).
  • Importovat, odstranit a aktualizovat klíče.
  • Získejte jeden nebo více klíčů a odstraněných klíčů s jejich atributy.
  • Obnovení odstraněného klíče a obnovení zálohovaného klíče
  • Získejte verze klíče.

Pomocí kryptografického klienta, který je k dispozici v této knihovně, máte také přístup k:

  • Šifrování
  • Dešifrování
  • certifikát
  • Ověření
  • Zalamování klíčů
  • Rozbalování klíčů

Poznámka: Tento balíček nejde použít v prohlížeči kvůli omezením služby Azure Key Vault. Pokyny najdete v tomto dokumentu.

Klíčové odkazy:

Začínáme

Aktuálně podporovaná prostředí

Požadavky

Instalace balíčku

Instalace klientské knihovny Azure Key Vault Key pomocí npm

npm install @azure/keyvault-keys

Instalace knihovny identit

Klienti Azure Key Vault se ověřují pomocí knihovny identit Azure. Nainstalujte ho také pomocí npm.

npm install @azure/identity

Konfigurace TypeScriptu

Uživatelé TypeScriptu musí mít nainstalované definice typů uzlů:

npm install @types/node

Musíte také povolit compilerOptions.allowSyntheticDefaultImports ve svém tsconfig.json. Všimněte si, že pokud jste povolili compilerOptions.esModuleInterop, allowSyntheticDefaultImports je ve výchozím nastavení povolená. Další informace najdete v příručce k možnostem kompilátoru TypeScriptu .

Klíčové koncepty

  • Klient klíče je primárním rozhraním pro interakci s metodami rozhraní API souvisejícími s klíči v rozhraní Azure Key Vault API z javascriptové aplikace. Po inicializaci poskytuje základní sadu metod, které lze použít k vytváření, čtení, aktualizaci a odstraňování klíčů.
  • Verze klíče je verze klíče v Key Vault. Pokaždé, když uživatel přiřadí hodnotu jedinečnému názvu klíče, vytvoří se nová verze tohoto klíče. Načtení klíče podle názvu vždy vrátí nejnovější přiřazenou hodnotu, pokud není dotazu poskytnuta konkrétní verze.
  • Obnovitelné odstranění umožňuje službě Key Vault podporovat odstranění a vymazání ve dvou samostatných krocích, takže odstraněné klíče se okamžitě neztratí. K tomu dochází pouze v případě, že je u Key Vault povolené obnovitelné odstranění.
  • Zálohu klíče je možné vygenerovat z libovolného vytvořeného klíče. Tyto zálohy pocházejí z binárních dat a dají se použít pouze k opětovnému vygenerování dříve odstraněného klíče.
  • Klient kryptografie je samostatné rozhraní, které komunikuje s metodami rozhraní API klíčů v rozhraní API Key Vault. Tento klient se zaměřuje pouze na kryptografické operace, které lze provést pomocí klíče, který byl již vytvořen v Key Vault. Další informace o tomto klientovi najdete v části Kryptografie .

Ověřování pomocí Azure Active Directory

Služba Key Vault se při ověřování požadavků vůči svým rozhraním API spoléhá na Azure Active Directory. Balíček @azure/identity poskytuje různé typy přihlašovacích údajů, které vaše aplikace k tomu může použít. Soubor README pro @azure/identity obsahuje další podrobnosti a ukázky, které vám pomůžou začít.

Pokud chcete pracovat se službou Azure Key Vault, budete muset vytvořit instanci KeyClient třídy, adresu URL trezoru a objekt přihlašovacích údajů. Příklady uvedené v tomto dokumentu používají objekt přihlašovacích údajů s názvem DefaultAzureCredential, který je vhodný pro většinu scénářů, včetně místního vývojového a produkčního prostředí. Kromě toho doporučujeme pro ověřování v produkčních prostředích používat spravovanou identitu .

Další informace o různých způsobech ověřování a jejich odpovídajících typech přihlašovacích údajů najdete v dokumentaci ke službě Azure Identity.

Tady je stručný příklad. Nejprve importujte DefaultAzureCredential a KeyClient:

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

Po importu se můžeme připojit ke službě 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);

Určení verze rozhraní API služby Azure Key Vault

Ve výchozím nastavení tento balíček používá nejnovější verzi služby Azure Key Vault, která je 7.2. Verzi používané služby můžete změnit nastavením možnosti serviceVersion v konstruktoru klienta, jak je znázorněno níže:

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

Příklady

Následující části obsahují fragmenty kódu, které pokrývají některé běžné úlohy s využitím klíčů Azure Key Vault. Scénáře, které jsou zde popsány, zahrnují:

Vytvoření klíče

createKeyvytvoří klíč, který se uloží do Key Vault Azure. Pokud už klíč se stejným názvem existuje, vytvoří se nová verze klíče.

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

Druhý parametr odeslaný do createKey je typ klíče. Typ podporovaných klíčů bude záviset na SKU a na tom, jestli používáte azure Key Vault nebo spravovaný HSM Azure. Aktuální seznam podporovaných typů klíčů najdete v tématu Informace o klíčích.

Získání klíče

Nejjednodušší způsob, jak číst klíče zpět z trezoru, je získat klíč podle názvu. Tím se načte nejnovější verze klíče. Volitelně můžete získat jinou verzi klíče, pokud ji zadáte jako součást volitelných parametrů.

getKeynačte klíč, který se dříve ukládá do 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();

Vytváření a aktualizace klíčů pomocí atributů

Následující atributy lze také přiřadit libovolnému klíči v Key Vault:

  • tags: Libovolná sada hodnot klíčů, kterou je možné použít k vyhledávání a filtrování klíčů.
  • keyOps: Pole operací, které bude tento klíč moct provádět (encrypt, , decrypt, sign, verify, wrapKey). unwrapKey
  • enabled: Logická hodnota, která určuje, jestli je možné hodnotu klíče přečíst nebo ne.
  • notBefore: Zadané datum, po kterém lze hodnotu klíče načíst.
  • expires: Zadané datum, po kterém nelze načíst hodnotu klíče.

Objekt s těmito atributy lze odeslat jako třetí parametr createKey, hned za názvem a hodnotou klíče, a to následujícím způsobem:

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

Tím se vytvoří nová verze stejného klíče, který bude mít nejnovější poskytnuté atributy.

Atributy lze také aktualizovat na existující verzi klíče pomocí updateKeyPropertiespříkazu , a to následujícím způsobem:

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

Odstranění klíče

Metoda beginDeleteKey zahájí odstranění klíče. Tento proces bude probíhat na pozadí, jakmile budou k dispozici potřebné prostředky.

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

Pokud je pro Key Vault povolené obnovitelné odstranění, označí tato operace klíč pouze jako odstraněný klíč. Odstraněný klíč nejde aktualizovat. Dají se jenom číst, obnovit nebo vymazat.

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

Vzhledem k tomu, že úplné odstranění klíčů nějakou dobu trvá, beginDeleteKey vrátí objekt Poller, který sleduje podkladovou dlouhotrvající operaci podle našich pokynů: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

Přijatý poller vám umožní získat odstraněný klíč voláním na poller.getResult(). Můžete také počkat na dokončení odstranění spuštěním jednotlivých volání služby, dokud se klíč nesmaže, nebo čekáním na dokončení 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();

Dalším způsobem, jak počkat na úplné odstranění klíče, je provést jednotlivá volání následujícím způsobem:

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

Konfigurace automatické obměně klíčů

Pomocí KeyClientu můžete nakonfigurovat automatickou obměnu klíče zadáním zásad obměna klíčů. KeyClient navíc poskytuje metodu pro obměně klíče na vyžádání vytvořením nové verze daného klíče.

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

Iterace seznamů klíčů

Pomocí KeyClient můžete načíst a iterovat všechny klíče v Azure Key Vault, stejně jako všechny odstraněné klíče a verze konkrétního klíče. K dispozici jsou následující metody rozhraní API:

  • listPropertiesOfKeys zobrazí seznam všech neodstraněných klíčů podle jejich názvů, pouze v jejich nejnovějších verzích.
  • listDeletedKeys zobrazí seznam všech odstraněných klíčů podle jejich názvů, pouze v jejich nejnovějších verzích.
  • listPropertiesOfKeyVersions zobrazí seznam všech verzí klíče na základě názvu klíče.

Které lze použít následujícím způsobem:

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

Všechny tyto metody vrátí všechny dostupné výsledky najednou. Pokud je chcete načíst po stránkách, přidejte .byPage() hned po vyvolání metody rozhraní API, kterou chcete použít, následujícím způsobem:

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

Tato knihovna také nabízí sadu kryptografických nástrojů dostupných prostřednictvím CryptographyClient. Podobně jako se KeyClientnástroj CryptographyClient připojí k Azure Key Vault pomocí zadané sady přihlašovacích údajů. Po připojení CryptographyClient můžete klíče šifrovat, dešifrovat, podepisovat, ověřovat, zalamovat a rozbalovat klíče.

Ke službě trezoru klíčů se můžeme dále připojit stejně jako u KeyClientslužby . Některá nastavení z trezoru klíčů, ke kterému se připojujeme, budeme muset zkopírovat do proměnných prostředí. Jakmile jsou v našem prostředí, můžeme k nim přistupovat pomocí následujícího kódu:

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 zašifruje zprávu.

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 dešifruje zašifrovanou zprávu.

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

Znaménko

sign kryptograficky podepíše hodnotu hash (hash) zprávy s 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();

Podepsat data

signData kryptograficky podepíše zprávu s 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();

Ověření

verify kryptograficky ověří, že podepsaný souhrn byl podepsán daným 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 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();

Ověření dat

verifyData kryptograficky ověří, že podepsaná zpráva byla podepsána daným 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 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();

Zalamování klíče

wrapKey zabalí klíč s vrstvou šifrování.

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

Rozbalení klíče

unwrapKey rozbalí zabalený klíč.

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

Poradce při potížích

Podrobnosti o tom, jak diagnostikovat různé scénáře selhání, najdete v našem průvodci odstraňováním potíží.

Povolení protokolování může pomoct odhalit užitečné informace o selháních. Pokud chcete zobrazit protokol požadavků a odpovědí HTTP, nastavte proměnnou AZURE_LOG_LEVEL prostředí na info. Případně je možné protokolování povolit za běhu voláním setLogLevel v :@azure/logger

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

setLogLevel("info");

Další kroky

Další ukázky kódu najdete na následujících odkazech:

Přispívání

Pokud chcete přispívat do této knihovny, přečtěte si prosím průvodce přispívání , kde se dozvíte více o tom, jak sestavit a otestovat kód.

Imprese