Libreria client delle chiavi di Azure Key Vault per JavaScript - versione 4.10.0

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, è consigliabile esaminare: 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 sul modulo di protezione hardware gestito di Azure Key Vault, è consigliabile esaminare: Che cos'è il modulo di protezione hardware gestito di Azure Key Vault?

Il client della libreria di chiavi di Azure Key Vault supporta le chiavi RSA, le chiavi EC (Elliptic Curve), nonché le chiavi Symmetric (oct) durante l'esecuzione su un modulo di protezione hardware gestito, ognuna con il supporto corrispondente nei moduli di protezione hardware .HSM. Offre operazioni per creare, recuperare, aggiornare, eliminare, eliminare, eliminare, eseguire il backup, ripristinare ed elencare le chiavi e le relative versioni.

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

Creare chiavi usando la curva ellittica o la crittografia RSA, supportata facoltativamente da moduli di protezione hardware( HSM).
Importare, eliminare e aggiornare le chiavi.
Ottenere una o più chiavi ed eliminare chiavi, con i relativi attributi.
Ripristinare 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:

Crittografia
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 Azure Key Vault. Per indicazioni, vedere questo documento.

Collegamenti chiave:

Come iniziare

Ambienti attualmente supportati

Versioni LTS di Node.js

Prerequisiti

Una sottoscrizione di Azure
Un azure Key Vault esistente. Se è necessario creare un insieme di credenziali delle chiavi, è possibile farlo nel portale di Azure seguendo i passaggi descritti in questo documento. In alternativa, usare l'interfaccia della riga di comando di Azure seguendo questi passaggi.
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 delle chiavi di Azure Key Vault usando npm

npm install @azure/keyvault-keys

Installare la libreria delle identità

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

npm install @azure/identity

Configurare TypeScript

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

npm install @types/node

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

Concetti chiave

Il client chiave è l'interfaccia principale per interagire con i metodi API correlati alle chiavi nell'API di Azure Key Vault 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 nell'insieme di credenziali delle chiavi. 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.
eliminazione temporanea consente agli insiemi di credenziali delle chiavi di supportare l'eliminazione e l'eliminazione come due passaggi separati, in modo che le chiavi eliminate non vengano perse immediatamente. Ciò si verifica solo se l'insieme di credenziali delle chiavi ha abilitata per l'eliminazione temporanea.
È possibile generare un di backup delle chiavi di da qualsiasi chiave creata. Questi backup vengono usati come 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 di Key Vault. Questo client è incentrato solo sulle operazioni di crittografia che possono essere eseguite usando una chiave già creata nell'insieme di credenziali delle chiavi. Altre informazioni su questo client sono disponibili nella sezione cryptography.

Autenticazione con Azure Active Directory

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

Per interagire con il servizio Azure Key Vault, è necessario creare un'istanza della classe KeyClient, un URL dell'insieme di credenziali e un oggetto credenziali. 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. È anche consigliabile usare un di 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 relativa all'identità di Azure .

Ecco un rapido esempio. Prima di tutto, importare DefaultAzureCredential e KeyClient. Dopo l'importazione, è possibile connettersi al servizio Key Vault:

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

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 7.2. È possibile modificare la versione del servizio usata impostando l'opzione serviceVersion nel costruttore client, come illustrato di seguito:

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

Esempi

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

Creazione di una chiave.
Ottenere una chiave.
Creazione e aggiornamento delle chiavi con attributi.
Eliminazione di una chiave.
Elenchi di chiavi iterando.

Creazione di una chiave

createKey crea una chiave da archiviare in Azure Key Vault. Se esiste già una chiave con lo stesso nome, viene creata una nuova versione della chiave.

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

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'istanza di Azure Key Vault o un modulo di protezione hardware gestito di Azure. Per un elenco up-to-date 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 si specifica come parte dei parametri facoltativi.

getKey recupera una chiave negli archivi precedenti nell'insieme di credenziali delle chiavi.

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

Creazione e aggiornamento di chiavi con attributi

Gli attributi seguenti possono anche essere assegnati a qualsiasi chiave in un insieme di credenziali delle chiavi:

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 specificata dopo la 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:

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

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

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

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

Eliminazione di una chiave

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

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

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

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

Poiché le chiavi richiedono del tempo per essere eliminate completamente, beginDeleteKey restituisce un oggetto Poller che tiene traccia dell'operazione a esecuzione prolungata sottostante in base alle linee guida seguenti: 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 finché la chiave non viene eliminata o attendendo il completamento del processo:

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

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

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

Configurazione della rotazione automatica delle chiavi

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

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

Iterazione di elenchi di chiavi

Usando KeyClient, è possibile recuperare e scorrere tutte le chiavi in un insieme di credenziali delle chiavi 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 elenca tutte le chiavi eliminate in base ai nomi, solo nelle versioni più recenti.
listPropertiesOfKeyVersions elenca tutte le versioni di una chiave in base a un nome di chiave.

Che può essere usato come segue:

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

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

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

Crittografia

Questa libreria offre anche un set di utilità crittografiche disponibili tramite CryptographyClient. Analogamente alla KeyClient, CryptographyClient si connetterà ad Azure Key Vault con il set di credenziali fornito. 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 dell'insieme di credenziali delle chiavi esattamente come si fa con il 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 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);

Cifrare

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

Decriptare

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

Segno

sign firma crittograficamente il digest (hash) di un messaggio con una firma.

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

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

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

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

Esegui il wrapping della chiave

wrapKey eseguirà 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 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);

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

Risoluzione dei problemi

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

L'abilitazione della registrazione può aiutare a 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 nel @azure/logger:

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

setLogLevel("info");

Passaggi successivi

Per altri esempi di codice, vedere i collegamenti seguenti:

Contribuire

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

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-06-12