Libreria client chiave di Azure Key Vault per JavaScript - versione 4.8.0

Articolo
02/16/2024

Azure Key Vault è un servizio che consente di crittografare chiavi di autenticazione, chiavi dell'account di archiviazione, chiavi di crittografia dei dati, file pfx e password usando chiavi protette. Per altre informazioni su Azure Key Vault, è possibile consultare: Che cos'è Azure Key Vault?

Il modulo di protezione hardware gestito di Azure Key Vault è un servizio cloud completamente gestito, a disponibilità elevata, a tenant singolo e conforme agli standard che consente di proteggere le chiavi crittografiche per le applicazioni cloud usando moduli di protezione hardware convalidati FIPS 140-2 livello 3. Per altre informazioni su HSM gestito di Azure Key Vault, è possibile esaminare: Che cos'è il modulo di protezione hardware gestito di Azure Key Vault?

Il client della libreria delle chiavi di Azure Key Vault supporta le chiavi RSA, le chiavi EC (Elliptic Curve) e le chiavi simmetriche (ott) quando vengono eseguite su un modulo di protezione hardware gestito, ognuna con il supporto corrispondente nei moduli di protezione hardware. Offre operazioni per creare, recuperare, aggiornare, eliminare, ripulire, eseguire il backup, ripristinare ed elencare le chiavi e le relative versioni.

Usare la libreria client per Chiavi di Azure Key Vault nell'applicazione Node.js per:

Creare chiavi usando la curva ellittica o la crittografia RSA, facoltativamente supportata da moduli di protezione hardware( HSM).
Importare, eliminare e aggiornare le chiavi.
Ottenere una o più chiavi ed eliminare chiavi, con i relativi attributi.
Recuperare una chiave eliminata e ripristinare una chiave di cui è stato eseguito il backup.
Ottenere le versioni di una chiave.

Usando il client di crittografia disponibile in questa libreria, è anche possibile accedere a:

Encrypting
Decrittografia
per la firma
Verifica
Ritorno a capo delle chiavi
Annullamento del wrapping delle chiavi

Nota: questo pacchetto non può essere usato nel browser a causa delle limitazioni del servizio di Azure Key Vault. Per indicazioni, fare riferimento a questo documento.

Collegamenti principali:

Introduzione

Ambienti attualmente supportati

Versioni LTS di Node.js

Prerequisiti

Una sottoscrizione di Azure
Un Key Vault di Azure esistente. Se è necessario creare un insieme di credenziali delle chiavi, è possibile farlo nel portale di Azure seguendo la procedura descritta in questo documento. In alternativa, usare l'interfaccia della riga di comando di Azure seguendo questa procedura.
Se si usa il modulo di protezione hardware gestito, un modulo di protezione hardware gestito di Azure Key Vault esistente. Se è necessario creare un modulo di protezione hardware gestito, è possibile farlo usando l'interfaccia della riga di comando di Azure seguendo la procedura descritta in questo documento.

Installare il pacchetto

Installare la libreria client di Azure Key Vault Key usando npm

npm install @azure/keyvault-keys

Installare la libreria di identità

I client di Azure Key Vault eseguono l'autenticazione tramite la libreria di identità di Azure. Installarlo anche usando npm

npm install @azure/identity

Configurare TypeScript

Gli utenti typeScript devono avere le definizioni dei tipi di nodo installate:

npm install @types/node

È anche necessario abilitare compilerOptions.allowSyntheticDefaultImports nel tsconfig.json. Si noti che se è stato abilitato , allowSyntheticDefaultImports è abilitato compilerOptions.esModuleInteropper impostazione predefinita. Per altre informazioni, vedere il manuale delle opzioni del compilatore di TypeScript .

Concetti chiave

Il client Key è l'interfaccia principale per interagire con i metodi API correlati alle chiavi nell'API Key Vault di Azure da un'applicazione JavaScript. Dopo l'inizializzazione, fornisce un set di base di metodi che possono essere usati per creare, leggere, aggiornare ed eliminare chiavi.
Una versione chiave è una versione di una chiave nel Key Vault. Ogni volta che un utente assegna un valore a un nome di chiave univoco, viene creata una nuova versione di tale chiave. Il recupero di una chiave in base a un nome restituirà sempre il valore più recente assegnato, a meno che non venga fornita una versione specifica alla query.
L'eliminazione temporanea consente agli insiemi di credenziali delle chiavi di supportare l'eliminazione e l'eliminazione come due passaggi separati, quindi le chiavi eliminate non vengono perse immediatamente. Ciò si verifica solo se il Key Vault ha abilitato l'eliminazione temporanea.
Un backup della chiave può essere generato da qualsiasi chiave creata. Questi backup sono dati binari e possono essere usati solo per rigenerare una chiave eliminata in precedenza.
Il client di crittografia è un'interfaccia separata che interagisce con i metodi API delle chiavi nell'API Key Vault. Questo client è incentrato solo sulle operazioni di crittografia che possono essere eseguite usando una chiave già creata nel Key Vault. Altre informazioni su questo client sono disponibili nella sezione Crittografia .

Autenticazione con Azure Active Directory

Il servizio Key Vault si basa su Azure Active Directory per autenticare le richieste alle API. Il @azure/identity pacchetto offre un'ampia gamma di tipi di credenziali che l'applicazione può usare per eseguire questa operazione. ReadME per @azure/identity fornisce altri dettagli ed esempi per iniziare.

Per interagire con il servizio azure Key Vault, è necessario creare un'istanza della KeyClient classe, un URL dell'insieme di credenziali e un oggetto credenziale. Gli esempi illustrati in questo documento usano un oggetto credenziali denominato DefaultAzureCredential, appropriato per la maggior parte degli scenari, inclusi gli ambienti di sviluppo e produzione locali. È inoltre consigliabile usare un'identità gestita per l'autenticazione negli ambienti di produzione.

Per altre informazioni sui diversi modi di autenticazione e sui relativi tipi di credenziali corrispondenti, vedere la documentazione di Identità di Azure.

Ecco un esempio rapido. Per prima cosa, importare DefaultAzureCredential e KeyClient:

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

Dopo l'importazione, è possibile connettersi al servizio 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);

Specifica della versione dell'API del servizio azure Key Vault

Per impostazione predefinita, questo pacchetto usa la versione più recente del servizio azure Key Vault, ovvero 7.2. È possibile modificare la versione del servizio usata impostando l'opzione serviceVersion nel costruttore client, come illustrato di seguito:

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

Esempio

Le sezioni seguenti forniscono frammenti di codice che illustrano alcune delle attività comuni che usano Chiavi di Azure Key Vault. Gli scenari trattati di seguito sono costituiti da:

Creazione di una chiave.
Ottenere una chiave.
Creazione e aggiornamento delle chiavi con attributi.
Eliminazione di una chiave.
Iterazione di elenchi di chiavi.

Creazione di una chiave

createKeycrea una chiave da archiviare nel Key Vault di Azure. Se esiste già una chiave con lo stesso nome, viene creata una nuova versione della chiave.

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

Il secondo parametro inviato a createKey è il tipo della chiave. Il tipo di chiavi supportate dipende dallo SKU e dal fatto che si usi un Key Vault di Azure o un modulo di protezione hardware gestito di Azure. Per un elenco aggiornato dei tipi di chiave supportati, vedere Informazioni sulle chiavi

Ottenere una chiave

Il modo più semplice per leggere le chiavi dall'insieme di credenziali consiste nel ottenere una chiave in base al nome. Verrà recuperata la versione più recente della chiave. Facoltativamente, è possibile ottenere una versione diversa della chiave se viene specificata come parte dei parametri facoltativi.

getKeyrecupera un archivio precedente della chiave nel 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();

Creazione e aggiornamento di chiavi con attributi

Gli attributi seguenti possono anche essere assegnati a qualsiasi chiave in un Key Vault:

tags: qualsiasi set di valori chiave che può essere usato per cercare e filtrare le chiavi.
keyOps: matrice delle operazioni che questa chiave sarà in grado di eseguire (encrypt, decrypt, sign, verify, wrapKey, unwrapKey).
enabled: valore booleano che determina se il valore della chiave può essere letto o meno.
notBefore: data specificata dopo la quale è possibile recuperare il valore della chiave.
expires: data successiva alla quale non è possibile recuperare il valore della chiave.

Un oggetto con questi attributi può essere inviato come terzo parametro di createKey, subito dopo il nome e il valore della chiave, come indicato di seguito:

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

Verrà creata una nuova versione della stessa chiave, che avrà gli attributi forniti più recenti.

Gli attributi possono anche essere aggiornati a una versione di chiave esistente con updateKeyProperties, come indicato di seguito:

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

Eliminazione di una chiave

Il beginDeleteKey metodo avvia l'eliminazione di una chiave. Questo processo verrà eseguito in background non appena saranno disponibili le risorse necessarie.

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

Se l'eliminazione temporanea è abilitata per il Key Vault, questa operazione etichetta solo la chiave come chiave eliminata. Non è possibile aggiornare una chiave eliminata. Possono essere letti, recuperati o eliminati.

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

Poiché l'eliminazione completa delle chiavi richiede tempo, beginDeleteKey restituisce un oggetto Poller che tiene traccia dell'operazione a esecuzione prolungata sottostante in base alle linee guida: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

Il poller ricevuto consentirà di ottenere la chiave eliminata chiamando a poller.getResult(). È anche possibile attendere il completamento dell'eliminazione eseguendo singole chiamate al servizio fino a quando la chiave non viene eliminata o attendendo il completamento del processo:

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

Un altro modo per attendere che la chiave venga eliminata completamente consiste nell'eseguire singole chiamate, come indicato di seguito:

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

Configurazione della rotazione automatica delle chiavi

Usando KeyClient, è possibile configurare la rotazione automatica delle chiavi per una chiave specificando i criteri di rotazione. Inoltre, KeyClient fornisce un metodo per ruotare una chiave su richiesta creando una nuova versione della chiave specificata.

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

Iterazione di elenchi di chiavi

Usando KeyClient, è possibile recuperare e scorrere tutte le chiavi in un Key Vault di Azure, nonché tramite tutte le chiavi eliminate e le versioni di una chiave specifica. Sono disponibili i metodi API seguenti:

listPropertiesOfKeys elenca tutte le chiavi non eliminate in base ai nomi, solo nelle versioni più recenti.
listDeletedKeys verranno elencate tutte le chiavi eliminate in base ai nomi, solo nelle versioni più recenti.
listPropertiesOfKeyVersions verranno elencate tutte le versioni di una chiave in base a un nome di chiave.

Che può essere usato come segue:

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

Tutti questi metodi restituiranno tutti i risultati disponibili contemporaneamente. Per recuperarli in base alle pagine, aggiungere .byPage() subito dopo aver richiamato il metodo API che si vuole usare, come indicato di seguito:

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

Crittografia

Questa libreria offre anche un set di utilità crittografiche disponibili tramite CryptographyClient. Analogamente a KeyClient, CryptographyClient si connetterà ad Azure Key Vault con il set specificato di credenziali. Dopo la connessione, CryptographyClient può crittografare, decrittografare, firmare, verificare, eseguire il wrapping delle chiavi e annullare il wrapping delle chiavi.

È quindi possibile connettersi al servizio key vault esattamente come avviee con .KeyClient È necessario copiare alcune impostazioni dall'insieme di credenziali delle chiavi a cui ci si connette nelle variabili di ambiente. Una volta che si trovano nell'ambiente, è possibile accedervi con il codice seguente:

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 crittograferà un messaggio.

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 decrittograferà un messaggio crittografato.

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

Sign

sign firma in modo crittografico il digest (hash) di un messaggio con una firma.

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

Firma dati

signData firma crittograficamente un messaggio con una firma.

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

Verificare

verify verificherà in modo crittografico che il digest firmato sia stato firmato con la firma specificata.

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

Verificare i dati

verifyData verificherà in modo crittografico che il messaggio firmato sia stato firmato con la firma specificata.

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

Eseguire il wrapping della chiave

wrapKey esegue il wrapping di una chiave con un livello di crittografia.

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

Annulla il wrapping della chiave

unwrapKey annulla il wrapping di una chiave di cui è stato eseguito il wrapping.

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

Risoluzione dei problemi

Per informazioni dettagliate su come diagnosticare vari scenari di errore, vedere la guida alla risoluzione dei problemi .

L'abilitazione della registrazione consente di individuare informazioni utili sugli errori. Per visualizzare un log di richieste e risposte HTTP, impostare la variabile di ambiente AZURE_LOG_LEVEL su info. In alternativa, la registrazione può essere abilitata in fase di esecuzione chiamando setLogLevel in @azure/logger:

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

setLogLevel("info");

Passaggi successivi

Per altri esempi di codice, vedere i collegamenti seguenti:

Contributo

Per contribuire a questa libreria, leggere la guida ai contributi per altre informazioni su come compilare e testare il codice.

Impression

Condividi tramite