Azure Key Vault JavaScripthez készült kulcsügyféloldali kódtár – 4.10.0-s verzió

Az Azure Key Vault egy szolgáltatás, amellyel biztonságos kulcsokkal titkosíthatja a hitelesítési kulcsokat, a tárfiókkulcsokat, az adattitkosítási kulcsokat, a .pfx fájlokat és a jelszavakat. Ha többet szeretne megtudni az Azure Key Vaultról, érdemes lehet áttekinteni: Mi az Az Azure Key Vault?

Az Azure Key Vault felügyelt HSM egy teljes körűen felügyelt, magas rendelkezésre állású, egybérlős, szabványoknak megfelelő felhőszolgáltatás, amely lehetővé teszi a titkosítási kulcsok védelmét a felhőalkalmazások számára a FIPS 140–2 3. szintű hitelesített HSM-ek használatával. Ha többet szeretne megtudni az Azure Key Vault által felügyelt HSM-ről, érdemes lehet áttekinteni a következőt: Mi az Az Azure Key Vault által felügyelt HSM?

Az Azure Key Vault kulcstár-ügyfél támogatja az RSA-kulcsokat, az elliptikus görbe (EC) kulcsokat, valamint a szimmetrikus (okt) kulcsokat a felügyelt HSM-eken való futtatáskor, amelyek mindegyike megfelelő támogatást nyújt a hardveres biztonsági modulokban (HSM). Műveleteket kínál a kulcsok és azok verzióinak létrehozásához, lekéréséhez, frissítéséhez, törléséhez, törléséhez, törléséhez, biztonsági mentéséhez, visszaállításához és listázásához.

Használja az Azure Key Vault-kulcsok ügyfélkódtárát a Node.js alkalmazásban a következő célokra:

Kulcsok létrehozása háromliptikus görbével vagy RSA-titkosítással, opcionálisan hardveres biztonsági modulok (HSM) segítségével.
Kulcsok importálása, törlése és frissítése.
Szerezzen be egy vagy több kulcsot és törölt kulcsokat az attribútumaikkal együtt.
Helyreállíthat egy törölt kulcsot, és visszaállíthat egy biztonsági másolatot.
A kulcsok verzióinak lekérése.

Az ebben a kódtárban elérhető titkosítási ügyféllel a következőket is elérheti:

Titkosítása
Visszafejtése
Aláírás
Ellenőrzése
Körbefuttatási kulcsok
Kulcsok kibontása

Megjegyzés: Ez a csomag az Azure Key Vault szolgáltatás korlátozásai miatt nem használható a böngészőben, útmutatásért tekintse meg a dokumentum .

Főbb hivatkozások:

Kezdő lépések

Jelenleg támogatott környezetek

A Node.jsLTS-változatai

Előfeltételek

Azure-előfizetés
Meglévő Azure Key Vault. Ha kulcstartót kell létrehoznia, ezt az Azure Portalon teheti meg a dokumentum lépéseit követve. Másik lehetőségként használja az Azure CLI-t az alábbi lépések .
Felügyelt HSM használata esetén egy meglévő Azure Key Vault felügyelt HSM-. Ha felügyelt HSM-et kell létrehoznia, ezt az Azure CLI használatával teheti meg a dokumentum lépéseit követve.

A csomag telepítése

Az Azure Key Vault-kulcs ügyfélkódtárának telepítése npm használatával

npm install @azure/keyvault-keys

Az identitástár telepítése

Az Azure Key Vault-ügyfelek az Azure-identitástár használatával hitelesítik magukat. Telepítse az npm használatával is

npm install @azure/identity

TypeScript konfigurálása

A TypeScript-felhasználóknak telepítve kell lenniük a csomóponttípus-definícióknak:

npm install @types/node

A tsconfig.jsoncompilerOptions.allowSyntheticDefaultImports is engedélyeznie kell. Vegye figyelembe, hogy ha engedélyezte a compilerOptions.esModuleInterop, a allowSyntheticDefaultImports alapértelmezés szerint engedélyezve van. További információért tekintse meg TypeScript fordítóbeállítási kézikönyvét.

Főbb fogalmak

A Key-ügyfél az elsődleges felület, amely egy JavaScript-alkalmazás kulcsaival kapcsolatos API-metódusokkal kommunikál. Az inicializálás után a kulcsok létrehozására, olvasására, frissítésére és törlésére használható alapvető módszereket biztosít.
A kulcsverzió a Key Vault egyik kulcsverziója. Minden alkalommal, amikor egy felhasználó egy értéket rendel egy egyedi kulcsnévhez, létrejön a kulcs új verziója. A kulcs név szerinti lekérése mindig a legújabb hozzárendelt értéket adja vissza, kivéve, ha egy adott verziót ad meg a lekérdezésnek.
Helyreállítható törlés lehetővé teszi, hogy a Key Vaultok két külön lépésben támogassák a törlést és a törlést, így a törölt kulcsok nem vesznek el azonnal. Ez csak akkor fordul elő, ha a Key Vault helyreállítható törlési engedélyezve van.
A kulcs biztonsági mentési bármely létrehozott kulcsból létrehozható. Ezek a biztonsági másolatok bináris adatokként jönnek létre, és csak a korábban törölt kulcsok újragenerálásához használhatók.
A titkosítási ügyfél egy külön felület, amely a Key Vault API kulcs API-metódusaival kommunikál. Ez az ügyfél csak azokra a titkosítási műveletekre összpontosít, amelyek a Key Vaultban már létrehozott kulccsal végrehajthatók. Erről az ügyfélről a titkosítási szakaszban olvashat bővebben.

Hitelesítés az Azure Active Directoryval

A Key Vault szolgáltatás az Azure Active Directoryra támaszkodik az API-khoz érkező kérések hitelesítéséhez. A @azure/identity csomag számos hitelesítő adattípust biztosít, amelyeket az alkalmazás használhat erre. A README további részleteket és mintákat tartalmaz az első lépésekhez.

Az Azure Key Vault szolgáltatás használatához létre kell hoznia egy példányt a KeyClient osztályból, egy tároló URL-címét és egy hitelesítő objektumot. A dokumentumban bemutatott példák egy DefaultAzureCredentialnevű hitelesítő objektumot használnak, amely a legtöbb forgatókönyvhez, beleértve a helyi fejlesztési és éles környezeteket is. Emellett azt is javasoljuk, hogy felügyelt identitás használjon éles környezetekben történő hitelesítéshez.

A hitelesítés különböző módjairól és a hozzájuk tartozó hitelesítő adatok típusairól az Azure Identity dokumentációjánaktalál további információt.

Íme egy gyors példa. Először importálja DefaultAzureCredential és KeyClient. Ezek importálása után a következő lépésben csatlakozhatunk a Key Vault szolgáltatáshoz:

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

Az Azure Key Vault szolgáltatás API-verziójának megadása

Ez a csomag alapértelmezés szerint a legújabb Azure Key Vault szolgáltatásverziót használja, amely 7.2. A használt szolgáltatásverziót az ügyfélkonstruktor serviceVersion beállításával módosíthatja az alábbiak szerint:

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

Példák

A következő szakaszok olyan kódrészleteket nyújtanak, amelyek az Azure Key Vault kulcsait használó gyakori feladatok némelyikét fedik le. Az itt tárgyalt forgatókönyvek a következőkből állnak:

Kulcs létrehozása.
Kulcs lekérése.
Kulcsok létrehozása és frissítése attribútumokkal.
Kulcs törlése.
kulcslisták iterálása.

Kulcs létrehozása

createKey létrehoz egy kulcsot, amely az Azure Key Vaultban tárolható. Ha már létezik egy azonos nevű kulcs, akkor létrejön a kulcs új verziója.

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

A második, createKey küldött paraméter a kulcs típusa. A támogatott kulcsok típusa az SKU-tól és attól függ, hogy Azure Key Vaultot vagy Azure Managed HSM-et használ-e. A támogatott kulcstípusok up-todátumlistájáért tekintse meg A kulcsokról

Kulcs lekérése

A kulcsok visszaolvasásának legegyszerűbb módja a kulcsok név szerinti lekérése. Ez lekéri a kulcs legújabb verzióját. Ha az opcionális paraméterek részeként adja meg, a kulcs másik verzióját is lekérheti.

getKey lekéri a Key Vault korábbi kulcstárolóit.

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

Kulcsok létrehozása és frissítése attribútumokkal

A következő attribútumok a Key Vault bármely kulcsához hozzárendelhetők:

tags: A kulcsok kereséséhez és szűréséhez használható kulcsértékek összes készlete.
keyOps: A kulcs által végrehajtható műveletek tömbje (encrypt, decrypt, sign, verify, wrapKey, unwrapKey).
enabled: Logikai érték, amely meghatározza, hogy a kulcs értéke olvasható-e vagy sem.
notBefore: Egy adott dátum, amely után a kulcsérték lekérhető.
expires: Egy adott dátum, amely után a kulcsérték nem kérhető le.

Az ilyen attribútumokkal rendelkező objektumok a createKeyharmadik paramétereként küldhetők el közvetlenül a kulcs neve és értéke után, az alábbiak szerint:

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

Ezzel létrehoz egy új verziót ugyanannak a kulcsnak, amely a legújabb attribútumokkal rendelkezik.

Az attribútumok egy meglévő kulcsverzióra is frissíthetők updateKeyProperties, az alábbiak szerint:

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

Kulcs törlése

A beginDeleteKey metódus elindítja a kulcs törlését. Ez a folyamat a háttérben fog történni, amint a szükséges erőforrások rendelkezésre állnak.

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

Ha helyreállítható törlési engedélyezve van a Key Vaulthoz, ez a művelet csak törölt kulcsként címkézi fel a kulcsot. A törölt kulcsok nem frissíthetők. Csak olvashatók, helyreállíthatók vagy törölhetők.

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

Mivel a kulcsok teljes törlése eltarthat egy ideig, beginDeleteKey egy Poller-objektumot ad vissza, amely nyomon követi a mögöttes hosszú futású műveletet az irányelveink szerint: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

A kapott lekérdezés lehetővé teszi a törölt kulcs lekérését a poller.getResult()hívásával. A törlés befejezését az egyes szolgáltatáshívások futtatásával is megvárhatja a kulcs törléséig, vagy megvárhatja, amíg a folyamat befejeződik:

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

A kulcs teljes törlésének egy másik módja, ha egyéni hívásokat hajt végre, az alábbiak szerint:

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

Automatikus kulcsforgatás konfigurálása

A KeyClient használatával a kulcs automatikus elforgatását a rotációs szabályzat megadásával konfigurálhatja. A KeyClient emellett lehetővé teszi a kulcs igény szerinti elforgatását az adott kulcs új verziójának létrehozásával.

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

Kulcslisták iterálása

A KeyClient használatával lekérheti és iterálhatja az Azure Key Vault összes kulcsát, valamint az összes törölt kulcsot és egy adott kulcs verzióját. A következő API-metódusok érhetők el:

listPropertiesOfKeys az összes nem törölt kulcsot a nevük alapján listázhatja, csak a legújabb verziókban.
listDeletedKeys az összes törölt kulcsot a nevük alapján listázhatja, csak a legújabb verziókban.
listPropertiesOfKeyVersions egy kulcs összes verzióját egy kulcsnév alapján listázni fogja.

A következő módon használható:

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

Ezek a módszerek egyszerre az összes elérhető eredményt. Ha oldalak szerint szeretné lekérni őket, adja hozzá .byPage() közvetlenül a használni kívánt API-metódus meghívása után, az alábbiak szerint:

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

Kriptográfia

Ez a kódtár a CryptographyClientkeresztül elérhető titkosítási segédprogramok készletét is tartalmazza. A KeyClientCryptographyClient a megadott hitelesítő adatokkal csatlakozik az Azure Key Vaulthoz. A csatlakozás után CryptographyClient titkosíthatja, visszafejtheti, aláírhatja, ellenőrizheti, körbefuttathatja a kulcsokat és feloldhatja a kulcsokat.

A következő lépésben ugyanúgy csatlakozhatunk a Key Vault szolgáltatáshoz, mint a KeyClient. Át kell másolnunk néhány beállítást a kulcstartóból, amelyhez csatlakozunk a környezeti változóinkba. Miután a környezetünkben vannak, a következő kóddal érhetjük el őket:

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

Titkosítás

encrypt titkosít egy üzenetet.

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

Dekódolás

decrypt visszafejt egy titkosított üzenetet.

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

Bejelentkezés

sign kriptográfiailag aláírja egy üzenet kivonatát (kivonatát) aláírással.

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

Adatok aláírása

signData kriptográfiailag aláírással ír alá egy üzenetet.

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

Igazol

verify kriptográfiailag ellenőrzi, hogy az aláírt kivonat aláírása az adott aláírással történt-e.

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

Adatok ellenőrzése

verifyData kriptográfiailag ellenőrzi, hogy az aláírt üzenet aláírása az adott aláírással történt-e.

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

Kulcs becsomagolása

wrapKey titkosítási réteggel fogja körbefutni a kulcsot.

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

Kulcs kicsomagolása

unwrapKey egy becsomagolt kulcsot fog kicsomagolni.

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

Hibaelhárítás

A különböző hibaforgatókönyvek diagnosztizálásával kapcsolatos részletekért tekintse meg hibaelhárítási útmutatónkat.

A naplózás engedélyezése segíthet a hibákról szóló hasznos információk feltárásában. A HTTP-kérések és válaszok naplójának megtekintéséhez állítsa a környezeti változót a AZURE_LOG_LEVEL következőre info: . Alternatívaként a naplózás futásidőben is engedélyezhető a setLogLevel hívásával a @azure/logger.

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

setLogLevel("info");

Következő lépések

További kódmintákat az alábbi hivatkozásokon talál:

Közreműködés

Ha hozzá szeretne járulni ehhez a kódtárhoz, olvassa el a közreműködői útmutatót, amelyből többet is megtudhat a kód összeállításáról és teszteléséről.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-06-13