Azure Key Vault Key Client Library for JavaScript – 4.8.0-s verzió

Az Azure Key Vault egy olyan 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 Vault-ról, tekintse át a következőt: Mi az az Azure Key Vault?

Az Azure Key Vault Managed 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ű ellenőrzött HSM-ekkel. Ha többet szeretne megtudni az Azure Key Vault Felügyelt HSM-ről, érdemes lehet áttekinteni a következőt: Mi az az Azure Key Vault managed 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 rendelkezik a hardveres biztonsági modulok (HSM) megfelelő támogatásával. 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, végleges 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 Keys ügyfélkódtárát az 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 kulcsot az attribútumaikkal együtt.
• Törölt kulcs helyreállítása és biztonsági mentési kulcs visszaállítása.
• Kulcsverziók 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 ezt a dokumentumot.

Főbb hivatkozások:

• Forráskód
• Csomag (npm)
• API-referenciadokumentáció
• Termékdokumentáció
• Példák

Első lépések

Jelenleg támogatott környezetek

• A Node.jsLTS-verziói

Előfeltételek

• Azure-előfizetés
• Egy meglévő Azure-Key Vault. Ha létre kell hoznia egy kulcstartót, ezt az Azure Portalon teheti meg a jelen dokumentum lépéseit követve. Alternatív megoldásként használja az Azure CLI-t az alábbi lépések végrehajtásával.
• 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 jelen dokumentumban található lépések végrehajtásával.

A csomag telepítése

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

npm install @azure/keyvault-keys

Az identitástár telepítése

Az Azure Key Vault-ügyfelek hitelesítése az Azure-identitástár használatával történik. Az npm használatával is telepítheti

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.json is engedélyeznie compilerOptions.allowSyntheticDefaultImports kell. Vegye figyelembe, hogy ha engedélyeztecompilerOptions.esModuleInteropallowSyntheticDefaultImports, a alapértelmezés szerint engedélyezve van. További információt a TypeScript fordítóbeállítási kézikönyvében talál.

Fő fogalmak

• A kulcsügyfél az elsődleges felület, amely egy JavaScript-alkalmazásból származó Azure Key Vault API kulcsaival kapcsolatos API-metódusokkal kommunikál. Az inicializálás után a kulcsok létrehozásához, olvasásához, frissítéséhez és törléséhez használható egyszerű metóduskészletet biztosít.
• A kulcsverzió az Key Vault kulcsának verzió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, hacsak nem ad meg egy adott verziót a lekérdezésnek.
• A helyreállítható törlés lehetővé teszi, hogy a Key Vaultok két külön lépésként 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 engedélyezve van a helyreállítható törlés.
• A kulcs biztonsági mentése 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 kulcsok API-metódusaival kommunikál a Key Vault API-ban. Ez az ügyfél csak azokra a titkosítási műveletekre összpontosít, amelyeket a Key Vault már létrehozott kulccsal lehet végrehajtani. Erről az ügyfélről a Titkosítás 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-k felé irányuló kérések hitelesítéséhez. A @azure/identity csomag számos hitelesítőadat-típust biztosít, amelyeket az alkalmazás ehhez használhat. A README for @azure/identity 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 KeyClient egy osztálypéldányt, egy tároló URL-címét és egy hitelesítőadat-objektumot. Az ebben a dokumentumban bemutatott példák egy nevű hitelesítő objektumot DefaultAzureCredentialhasználnak, amely a legtöbb forgatókönyvhöz, beleértve a helyi fejlesztési és éles környezeteket is. Emellett azt javasoljuk, hogy felügyelt identitást használjon a hitelesítéshez éles környezetben.

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ában talál további információt.

Íme egy gyors példa. Először importálja DefaultAzureCredential és KeyClient:

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

Az importálás után csatlakozhatunk a Key Vault szolgáltatáshoz:

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

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

Alapértelmezés szerint ez a csomag az Azure Key Vault legújabb szolgáltatásverzióját használja, amely a következő7.2: . A használt szolgáltatásverziót az ügyfélkonstruktorban az alábbi módon serviceVersion állíthatja be:

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éldák

Az alábbi szakaszok olyan kódrészleteket nyújtanak, amelyek az Azure Key Vault Keys használatával végzett gyakori feladatok némelyikét ismertetik. Az itt tárgyalt forgatókönyvek a következőkből állnak:

• Kulcs létrehozása.
• Kulcs beszerzése.
• Kulcsok létrehozása és frissítése attribútumokkal.
• Kulcs törlése.
• Kulcslisták iterálása.

Kulcs létrehozása

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

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

A második elküldött createKey paraméter a kulcs típusa. A támogatott kulcsok típusa a termékváltozattól és attól függ, hogy Azure-Key Vault vagy Azure-beli felügyelt HSM-et használ-e. A támogatott kulcstípusok naprakész listájáért tekintse meg a Kulcsok ismertetése témakört.

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 a választható paraméterek részeként adja meg, a kulcs másik verzióját is lekérheti.

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

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

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, , decryptsign, verify, , ). unwrapKeywrapKey
• 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 ezekkel az attribútumokkal rendelkező objektumok a harmadik paramétereként createKeyküldhetők el közvetlenül a kulcs neve és értéke után, az alábbiak szerint:

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

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

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

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

Kulcs törlése

A beginDeleteKey metódus elindítja egy kulcs törlését. Ez a folyamat a háttérben történik, amint a szükséges erőforrások elérhetővé válnak.

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

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

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

Mivel a kulcsok teljes törlése eltarthat egy ideig, egy Poller-objektumot ad vissza, beginDeleteKey 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 következő hívásával: poller.getResult(). A törlés befejezését úgy is megvárhatja, hogy egyes szolgáltatáshívásokat futtat a kulcs törléséig, vagy megvárja a folyamat befejezését:

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

A kulcs teljes törlésének egy másik módja az egyes hívások lebonyolítása, az alábbiak szerint:

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

Az automatikus kulcsrotálás konfigurálása

A KeyClient használatával automatikus kulcsrotálást konfigurálhat a kulcshoz a rotációs szabályzat megadásával. A KeyClient emellett egy metódust is biztosít a kulcs igény szerinti elforgatására az adott kulcs új verziójának létrehozásával.

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

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 listázni fogja a nevük alapján, csak a legújabb verziójukon.
• listDeletedKeys az összes törölt kulcsot listázni fogja a nevük alapján, csak a legújabb verziójukon.
• listPropertiesOfKeyVersions egy kulcs összes verzióját listázni fogja egy kulcsnév alapján.

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

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

Ezen metódusok mindegyike egyszerre adja vissza az összes elérhető eredményt . Ha oldalak alapján 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:

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

Titkosítás

Ez a kódtár a segítségével CryptographyClientelérhető titkosítási segédprogramok készletét is kínálja. A -hez hasonlóan a KeyClientCryptographyClient megadott hitelesítő adatokkal csatlakozik az Azure Key Vault. A csatlakozás CryptographyClient után 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-hez. Át kell másolnunk néhány beállítást abból a kulcstartóból, amelyhez csatlakozunk a környezeti változókba. Ha már a környezetünkben vannak, a következő kóddal férhetünk hozzájuk:

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

Titkosítás

encrypt titkosítja az ü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 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();

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

Előjel

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

Adatok aláírása

signData kriptográfiai 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 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();

Ellenőrzés

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

Adatok ellenőrzése

verifyData kriptográfiailag ellenőrzi, hogy az aláírt üzenet az adott aláírással lett-e aláírva.

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

Kulcs körbefuttatása

wrapKey a titkosítási réteggel burkolja 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 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();

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

Hibaelhárítás

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

A naplózás engedélyezése hasznos információkat deríthet fel a hibákról. A HTTP-kérések és -válaszok naplójának megtekintéséhez állítsa a környezeti változót értékre AZURE_LOG_LEVELinfo. A naplózás futásidőben is engedélyezhető a következő hívásával setLogLevel@azure/logger:

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

setLogLevel("info");

Következő lépések

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

• Key Vault kulcsminták (JavaScript)
• Key Vault kulcsminták (TypeScript)
• Key Vault kulcstesztelési esetek

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 buildeléséhez és teszteléséhez.