Azure Key Vault Key-clientbibliotheek voor JavaScript - versie 4.8.0

  • Artikel

Azure Key Vault is een service waarmee u verificatiesleutels, opslagaccountsleutels, gegevensversleutelingssleutels, PFX-bestanden en wachtwoorden kunt versleutelen met behulp van beveiligde sleutels. Als u meer wilt weten over Azure Key Vault, kunt u het volgende lezen: Wat is Azure Key Vault?

Azure Key Vault Managed HSM is een volledig beheerde, maximaal beschikbare cloudservice met één tenant en voldoet aan standaarden waarmee u cryptografische sleutels voor uw cloudtoepassingen kunt beveiligen met behulp van HSM's met FIPS 140-2 Niveau 3. Als u meer wilt weten over Azure Key Vault Managed HSM, kunt u het volgende lezen: Wat is Azure Key Vault Managed HSM?

De Azure Key Vault-sleutelbibliotheekclient ondersteunt RSA-sleutels, EC-sleutels (Elliptic Curve) en symmetrische sleutels (oct) bij uitvoering op een beheerde HSM, elk met bijbehorende ondersteuning in HSM (Hardware Security Modules). Het biedt bewerkingen voor het maken, ophalen, bijwerken, verwijderen, opschonen, back-up maken, herstellen en vermelden van de sleutels en de bijbehorende versies.

Gebruik de clientbibliotheek voor Azure Key Vault Keys in uw Node.js-toepassing voor het volgende:

  • Maak sleutels met behulp van elliptische curve of RSA-versleuteling, optioneel ondersteund door HSM (Hardware Security Modules).
  • Sleutels importeren, verwijderen en bijwerken.
  • Haal een of meer sleutels en verwijderde sleutels op, met de bijbehorende kenmerken.
  • Een verwijderde sleutel herstellen en een back-up van een sleutel herstellen.
  • Haal de versies van een sleutel op.

Met behulp van de cryptografieclient die beschikbaar is in deze bibliotheek, hebt u ook toegang tot:

  • Coderen
  • Decoderen
  • Ondertekenen
  • Controleren
  • Wrapping-sleutels
  • Sleutels uitpakken

Opmerking: dit pakket kan niet worden gebruikt in de browser vanwege beperkingen van de Azure Key Vault-service. Raadpleeg dit document voor hulp.

Belangrijke koppelingen:

Aan de slag

Momenteel ondersteunde omgevingen

Vereisten

Het pakket installeren

De Azure Key Vault Key-clientbibliotheek installeren met npm

npm install @azure/keyvault-keys

De identiteitsbibliotheek installeren

Azure Key Vault-clients worden geverifieerd met behulp van de Azure-identiteitsbibliotheek. Installeer het ook met npm

npm install @azure/identity

TypeScript configureren

TypeScript-gebruikers moeten knooppunttypedefinities hebben geïnstalleerd:

npm install @types/node

U moet ook inschakelen compilerOptions.allowSyntheticDefaultImports in uw tsconfig.json. Houd er rekening mee dat als u hebt ingeschakeld compilerOptions.esModuleInterop, allowSyntheticDefaultImports standaard is ingeschakeld. Zie het handboek voor compileropties van TypeScript voor meer informatie.

Belangrijkste concepten

  • De sleutelclient is de primaire interface voor interactie met de API-methoden met betrekking tot sleutels in de Azure Key Vault-API vanuit een JavaScript-toepassing. Zodra het is geïnitialiseerd, biedt het een basisset met methoden die kunnen worden gebruikt om sleutels te maken, lezen, bijwerken en verwijderen.
  • Een sleutelversie is een versie van een sleutel in de Key Vault. Telkens wanneer een gebruiker een waarde toewijst aan een unieke sleutelnaam, wordt er een nieuwe versie van die sleutel gemaakt. Als u een sleutel met een naam opvraagt, wordt altijd de meest recente waarde geretourneerd die is toegewezen, tenzij een specifieke versie wordt opgegeven voor de query.
  • Met voorlopig verwijderen kunnen Key Vaults het verwijderen en opschonen als twee afzonderlijke stappen ondersteunen, zodat verwijderde sleutels niet onmiddellijk verloren gaan. Dit gebeurt alleen als voor de Key Vault voorlopig verwijderen is ingeschakeld.
  • Een sleutelback-up kan worden gegenereerd op basis van elke gemaakte sleutel. Deze back-ups worden geleverd als binaire gegevens en kunnen alleen worden gebruikt om een eerder verwijderde sleutel opnieuw te genereren.
  • De Cryptografie-client is een afzonderlijke interface die communiceert met de API-methoden voor sleutels in de Key Vault-API. Deze client richt zich alleen op de cryptografiebewerkingen die kunnen worden uitgevoerd met behulp van een sleutel die al in de Key Vault is gemaakt. Meer informatie over deze client vindt u in de sectie Cryptografie .

Verifiëren met Azure Active Directory

De Key Vault-service is afhankelijk van Azure Active Directory om aanvragen voor de API's te verifiëren. Het @azure/identity pakket biedt verschillende referentietypen die uw toepassing kan gebruiken om dit te doen. Leesmij voor @azure/identity biedt meer details en voorbeelden om u op weg te helpen.

Als u wilt communiceren met de Azure Key Vault-service, moet u een exemplaar van de KeyClient klasse, een kluis-URL en een referentieobject maken. De voorbeelden in dit document maken gebruik van een referentieobject met de naam DefaultAzureCredential, dat geschikt is voor de meeste scenario's, waaronder lokale ontwikkelings- en productieomgevingen. Daarnaast raden we u aan een beheerde identiteit te gebruiken voor verificatie in productieomgevingen.

Meer informatie over verschillende manieren van verificatie en de bijbehorende referentietypen vindt u in de Documentatie over Azure Identity.

Hier volgt een kort voorbeeld. DefaultAzureCredential Importeer eerst en KeyClient:

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

Zodra deze zijn geïmporteerd, kunnen we vervolgens verbinding maken met de Key Vault-service:

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

De API-versie van de Azure Key Vault-service opgeven

Dit pakket maakt standaard gebruik van de nieuwste serviceversie van Azure Key Vault, namelijk 7.2. U kunt de gebruikte serviceversie wijzigen door de optie serviceVersion in te stellen in de clientconstructor, zoals hieronder wordt weergegeven:

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

Voorbeelden

De volgende secties bevatten codefragmenten die betrekking hebben op enkele van de algemene taken met behulp van Azure Key Vault-sleutels. De scenario's die hier worden behandeld, bestaan uit:

Een sleutel maken

createKeyhiermee maakt u een sleutel die moet worden opgeslagen in de Azure Key Vault. Als er al een sleutel met dezelfde naam bestaat, wordt er een nieuwe versie van de sleutel gemaakt.

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

De tweede parameter die naar createKey wordt verzonden, is het type sleutel. Het type sleutels dat wordt ondersteund, is afhankelijk van de SKU en of u een Azure Key Vault of een door Azure beheerde HSM gebruikt. Raadpleeg Over sleutels voor een up-to-date lijst met ondersteunde sleuteltypen

Een sleutel ophalen

De eenvoudigste manier om sleutels uit de kluis te lezen, is door een sleutel op naam op te halen. Hiermee wordt de meest recente versie van de sleutel opgehaald. U kunt desgewenst een andere versie van de sleutel ophalen als u deze opgeeft als onderdeel van de optionele parameters.

getKeyhaalt een sleutel op die eerder is opgeslagen in de 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();

Sleutels met kenmerken maken en bijwerken

De volgende kenmerken kunnen ook worden toegewezen aan elke sleutel in een Key Vault:

  • tags: een set sleutelwaarden die kan worden gebruikt om sleutels te zoeken en te filteren.
  • keyOps: Een matrix van de bewerkingen die met deze sleutel kunnen worden uitgevoerd (encrypt, decrypt, sign, verify, wrapKey, , ). unwrapKey
  • enabled: Een booleaanse waarde die bepaalt of de sleutelwaarde kan worden gelezen of niet.
  • notBefore: Een opgegeven datum waarna de sleutelwaarde kan worden opgehaald.
  • expires: Een opgegeven datum waarna de sleutelwaarde niet kan worden opgehaald.

Een object met deze kenmerken kan als volgt worden verzonden als de derde parameter van createKey, direct na de naam en waarde van de sleutel:

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

Hiermee wordt een nieuwe versie van dezelfde sleutel gemaakt, die de meest recente kenmerken heeft.

Kenmerken kunnen ook worden bijgewerkt naar een bestaande sleutelversie met updateKeyProperties, als volgt:

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

Een sleutel verwijderen

Met beginDeleteKey de methode wordt het verwijderen van een sleutel gestart. Dit proces vindt plaats op de achtergrond zodra de benodigde resources beschikbaar zijn.

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

Als voorlopig verwijderen is ingeschakeld voor de Key Vault, wordt de sleutel alleen gelabeld als een verwijderde sleutel. Een verwijderde sleutel kan niet worden bijgewerkt. Ze kunnen alleen worden gelezen, hersteld of opgeschoond.

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

Omdat het even duurt voordat sleutels volledig zijn verwijderd, beginDeleteKey wordt een Poller-object geretourneerd dat de onderliggende langlopende bewerking bijhoudt volgens onze richtlijnen: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

Met de ontvangen poller kunt u de verwijderde sleutel ophalen door aan te roepen naar poller.getResult(). U kunt ook wachten totdat het verwijderen is voltooid door afzonderlijke serviceoproepen uit te voeren totdat de sleutel is verwijderd of door te wachten totdat het proces is voltooid:

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

Een andere manier om te wachten totdat de sleutel volledig is verwijderd, is door als volgt afzonderlijke aanroepen uit te voeren:

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

Automatische sleutelrotatie configureren

Met de KeyClient kunt u automatische sleutelrotatie voor een sleutel configureren door het rotatiebeleid op te geven. Daarnaast biedt KeyClient een methode om een sleutel op aanvraag te roteren door een nieuwe versie van de opgegeven sleutel te maken.

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

Herhalende lijsten met sleutels

Met keyClient kunt u alle sleutels in een Azure-Key Vault ophalen en herhalen, evenals alle verwijderde sleutels en de versies van een specifieke sleutel. De volgende API-methoden zijn beschikbaar:

  • listPropertiesOfKeys vermeldt al uw niet-verwijderde sleutels op hun naam, alleen in hun nieuwste versies.
  • listDeletedKeys geeft alle verwijderde sleutels weer op hun naam, alleen in hun nieuwste versies.
  • listPropertiesOfKeyVersions geeft alle versies van een sleutel weer op basis van een sleutelnaam.

Deze kan als volgt worden gebruikt:

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

Al deze methoden retourneren alle beschikbare resultaten in één keer. Als u deze op pagina's wilt ophalen, voegt u als volgt toe .byPage() nadat u de API-methode hebt aangeroepen die u wilt gebruiken:

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

Cryptografie

Deze bibliotheek biedt ook een set cryptografische hulpprogramma's die beschikbaar zijn via CryptographyClient. Net als bij KeyClientmaakt CryptographyClient u verbinding met Azure Key Vault met de opgegeven set referenties. Zodra u verbinding hebt, CryptographyClient kunt u sleutels versleutelen, ontsleutelen, ondertekenen, verifiëren, verpakken en sleutels uitpakken.

We kunnen vervolgens verbinding maken met de sleutelkluisservice, net zoals we dat doen met de KeyClient. We moeten enkele instellingen van de sleutelkluis waarmee we verbinding maken, kopiëren naar onze omgevingsvariabelen. Zodra ze zich in onze omgeving bevinden, kunnen we ze openen met de volgende code:

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

Versleutelen

encrypt versleutelt een bericht.

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

Ontsleutelen

decrypt ontsleutelt een versleuteld bericht.

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

Teken

sign hiermee wordt de samenvatting (hash) van een bericht cryptografisch ondertekend met een handtekening.

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

Tekengegevens

signData zal een bericht cryptografisch ondertekenen met een handtekening.

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

Verifiëren

verify controleert cryptografisch of de ondertekende samenvatting is ondertekend met de opgegeven handtekening.

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

Gegevens verifiëren

verifyData controleert cryptografisch of het ondertekende bericht is ondertekend met de opgegeven handtekening.

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

Sleutelterugloop

wrapKey verpakt een sleutel met een versleutelingslaag.

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

Sleutel uitpakken

unwrapKey wordt een verpakte sleutel uitgepakt.

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

Problemen oplossen

Zie onze gids voor probleemoplossing voor meer informatie over het diagnosticeren van verschillende foutscenario's.

Het inschakelen van logboekregistratie kan helpen bij het ontdekken van nuttige informatie over fouten. Als u een logboek met HTTP-aanvragen en -antwoorden wilt zien, stelt u de AZURE_LOG_LEVEL omgevingsvariabele in op info. U kunt logboekregistratie ook tijdens runtime inschakelen door aan te roepen setLogLevel in de @azure/logger:

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

setLogLevel("info");

Volgende stappen

Meer codevoorbeelden vindt u via de volgende koppelingen:

Bijdragen

Als u een bijdrage wilt leveren aan deze bibliotheek, leest u de handleiding voor bijdragen voor meer informatie over het bouwen en testen van de code.

Weergaven