Partager via

Bibliothèque cliente de clés Azure Key Vault pour JavaScript - version 4.10.0

Azure Key Vault est un service qui vous permet de chiffrer des clés d’authentification, des clés de compte de stockage, des clés de chiffrement de données, des fichiers .pfx et des mots de passe à l’aide de clés sécurisées. Si vous souhaitez en savoir plus sur Azure Key Vault, vous pouvez consulter : Qu’est-ce qu’Azure Key Vault ?

Azure Key Vault Managed HSM est un service cloud entièrement managé, hautement disponible, à locataire unique et conforme aux normes, qui vous permet de protéger les clés de chiffrement pour vos applications cloud à l’aide de HSM validés FIPS 140-2 de niveau 3. Si vous souhaitez en savoir plus sur azure Key Vault Managed HSM, vous pouvez consulter : Qu’est-ce qu’Azure Key Vault Managed HSM ?

Le client de bibliothèque de clés Azure Key Vault prend en charge les clés RSA, les clés EC (Elliptic Curve), ainsi que les clés symétriques (oct) lors de l’exécution sur un HSM managé, chacune avec prise en charge correspondante dans les modules de sécurité matériels (HSM). Il offre des opérations pour créer, récupérer, mettre à jour, supprimer, purger, sauvegarder, restaurer et répertorier les clés et ses versions.

Utilisez la bibliothèque cliente pour les clés Azure Key Vault dans votre application Node.js pour :

  • Créez des clés à l’aide d’une courbe elliptique ou d’un chiffrement RSA, éventuellement sauvegardées par des modules de sécurité matériels (HSM).
  • Importer, supprimer et mettre à jour des clés.
  • Obtenez une ou plusieurs clés et des clés supprimées, avec leurs attributs.
  • Récupérez une clé supprimée et restaurez une clé sauvegardée.
  • Obtenez les versions d’une clé.

À l’aide du client de chiffrement disponible dans cette bibliothèque, vous avez également accès à :

  • Cryptage
  • Décryptage
  • Signature
  • Vérifier
  • Touches d’habillage
  • Désencapsuler les clés

Remarque : Ce package ne peut pas être utilisé dans le navigateur en raison des limitations du service Azure Key Vault, reportez-vous à ce document pour obtenir des conseils.

Liens clés :

Mise en route

Environnements actuellement pris en charge

Conditions préalables

Installer le package

Installer la bibliothèque de client De clés Azure Key Vault à l’aide de npm

npm install @azure/keyvault-keys

Installer la bibliothèque d’identités

Les clients Azure Key Vault s’authentifient à l’aide de la bibliothèque d’identités Azure. Installez-le également à l’aide de npm

npm install @azure/identity

Configurer TypeScript

Les utilisateurs TypeScript doivent avoir installé les définitions de type Node :

npm install @types/node

Vous devez également activer compilerOptions.allowSyntheticDefaultImports dans votre tsconfig.json. Notez que si vous avez activé compilerOptions.esModuleInterop, allowSyntheticDefaultImports est activé par défaut. Pour plus d’informations, consultez manuel des options du compilateur de TypeScript.

Concepts clés

  • Le client clé est l’interface principale permettant d’interagir avec les méthodes d’API liées aux clés de l’API Azure Key Vault à partir d’une application JavaScript. Une fois initialisé, il fournit un ensemble de méthodes de base qui peuvent être utilisées pour créer, lire, mettre à jour et supprimer des clés.
  • Une version de clé est une version d’une clé dans le coffre de clés. Chaque fois qu’un utilisateur affecte une valeur à un nom de clé unique, une nouvelle version de cette clé est créée. La récupération d’une clé par un nom retourne toujours la dernière valeur affectée, sauf si une version spécifique est fournie à la requête.
  • suppression réversible permet aux coffres de clés de prendre en charge la suppression et la purge en deux étapes distinctes, de sorte que les clés supprimées ne sont pas immédiatement perdues. Cela se produit uniquement si key Vault a suppression réversible activée.
  • Une de sauvegarde de clé peut être générée à partir de n’importe quelle clé créée. Ces sauvegardes sont des données binaires et peuvent être utilisées uniquement pour régénérer une clé précédemment supprimée.
  • Le client de chiffrement est une interface distincte qui interagit avec les méthodes d’API clés dans l’API Key Vault. Ce client se concentre uniquement dans les opérations de chiffrement qui peuvent être exécutées à l’aide d’une clé qui a déjà été créée dans le coffre de clés. En savoir plus sur ce client dans la section de chiffrement.

Authentification auprès d’Azure Active Directory

Le service Key Vault s’appuie sur Azure Active Directory pour authentifier les demandes auprès de ses API. Le package @azure/identity fournit divers types d’informations d’identification que votre application peut utiliser pour ce faire. Le README pour @azure/identity fournit plus de détails et d’exemples pour vous aider à démarrer.

Pour interagir avec le service Azure Key Vault, vous devez créer une instance de la classe KeyClient, une URL de coffre et un objet d’informations d’identification. Les exemples présentés dans ce document utilisent un objet d’informations d’identification nommé DefaultAzureCredential, qui convient à la plupart des scénarios, y compris les environnements de développement et de production locaux. En outre, nous vous recommandons d’utiliser une d’identité managée pour l’authentification dans les environnements de production.

Vous trouverez plus d’informations sur différentes façons d’authentifier et leurs types d’informations d’identification correspondants dans la documentation Azure Identity.

Voici un exemple rapide. Tout d’abord, importez DefaultAzureCredential et KeyClient. Une fois ces informations importées, nous pouvons ensuite nous connecter au service 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);

Spécification de la version de l’API de service Azure Key Vault

Par défaut, ce package utilise la dernière version du service Azure Key Vault qui est 7.2. Vous pouvez modifier la version du service utilisée en définissant l’option serviceVersion dans le constructeur client, comme indiqué ci-dessous :

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

Exemples

Les sections suivantes fournissent des extraits de code qui couvrent certaines des tâches courantes à l’aide des clés Azure Key Vault. Les scénarios abordés ici sont les suivants :

Création d’une clé

createKey crée une clé à stocker dans Azure Key Vault. Si une clé portant le même nom existe déjà, une nouvelle version de la clé est créée.

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

Le deuxième paramètre envoyé à createKey est le type de la clé. Le type de clés pris en charge dépend de la référence SKU et de l’utilisation d’un coffre de clés Azure ou d’un HSM managé Azure. Pour obtenir une liste up-to-date des types de clés pris en charge, reportez-vous à À propos des clés

Obtention d’une clé

La façon la plus simple de lire les clés à partir du coffre consiste à obtenir une clé par nom. Cette opération récupère la version la plus récente de la clé. Vous pouvez éventuellement obtenir une autre version de la clé si vous la spécifiez dans le cadre des paramètres facultatifs.

getKey récupère une clé des magasins précédents dans le coffre de clés.

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

Création et mise à jour de clés avec des attributs

Les attributs suivants peuvent également être attribués à n’importe quelle clé dans un coffre de clés :

  • tags: n’importe quel ensemble de clés-valeurs qui peuvent être utilisées pour rechercher et filtrer des clés.
  • keyOps: tableau des opérations que cette clé sera en mesure d’effectuer (encrypt, decrypt, sign, verify, wrapKey, unwrapKey).
  • enabled: valeur booléenne qui détermine si la valeur de clé peut être lue ou non.
  • notBefore: date donnée après laquelle la valeur de clé peut être récupérée.
  • expires: date donnée après laquelle la valeur de clé ne peut pas être récupérée.

Un objet avec ces attributs peut être envoyé en tant que troisième paramètre de createKey, juste après le nom et la valeur de la clé, comme suit :

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

Cela crée une nouvelle version de la même clé, qui aura les derniers attributs fournis.

Les attributs peuvent également être mis à jour vers une version de clé existante avec updateKeyProperties, comme suit :

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

Suppression d’une clé

La méthode beginDeleteKey démarre la suppression d’une clé. Ce processus se produit en arrière-plan dès que les ressources nécessaires sont disponibles.

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

Si de suppression réversible est activée pour le coffre de clés, cette opération étiquette uniquement la clé en tant que clé supprimée. Impossible de mettre à jour une clé supprimée. Ils peuvent uniquement être lus, récupérés ou vidés.

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

Étant donné que les clés prennent un certain temps pour être entièrement supprimées, beginDeleteKey retourne un objet Poller qui suit l’opération de longue durée sous-jacente en fonction de nos instructions : https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

L’polleur reçu vous permet d’obtenir la clé supprimée en appelant poller.getResult(). Vous pouvez également attendre la fin de la suppression en exécutant des appels de service individuels jusqu’à ce que la clé soit supprimée ou en attendant que le processus soit terminé :

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

Une autre façon d’attendre que la clé soit entièrement supprimée consiste à effectuer des appels individuels, comme suit :

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

Configuration de la rotation automatique des clés

À l’aide de KeyClient, vous pouvez configurer la rotation automatique des clés pour une clé en spécifiant la stratégie de rotation. De plus, KeyClient fournit une méthode pour faire pivoter une clé à la demande en créant une nouvelle version de la clé donnée.

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

Itération des listes de clés

À l’aide de KeyClient, vous pouvez récupérer et itérer toutes les clés d’un coffre de clés Azure, ainsi que toutes les clés supprimées et les versions d’une clé spécifique. Les méthodes d’API suivantes sont disponibles :

  • listPropertiesOfKeys répertorie toutes vos clés non supprimées par leurs noms, uniquement à leurs dernières versions.
  • listDeletedKeys répertorie toutes vos clés supprimées par leurs noms, uniquement à leurs dernières versions.
  • listPropertiesOfKeyVersions répertorie toutes les versions d’une clé en fonction d’un nom de clé.

Qui peut être utilisé comme suit :

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

Toutes ces méthodes retournent tous les résultats disponibles à la fois. Pour les récupérer par pages, ajoutez .byPage() juste après l’appel de la méthode d’API que vous souhaitez utiliser, comme suit :

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

Cryptographie

Cette bibliothèque offre également un ensemble d’utilitaires de chiffrement disponibles via CryptographyClient. Comme pour le KeyClient, CryptographyClient se connectera à Azure Key Vault avec l’ensemble d’informations d’identification fourni. Une fois connecté, CryptographyClient pouvez chiffrer, déchiffrer, signer, vérifier, encapsuler des clés et annuler les clés.

Nous pouvons ensuite nous connecter au service key vault comme nous le faisons avec le KeyClient. Nous devons copier certains paramètres à partir du coffre de clés vers lequel nous nous connectons à nos variables d’environnement. Une fois qu’ils se trouvent dans notre environnement, nous pouvons y accéder avec le code suivant :

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

Chiffrer

encrypt chiffre un message.

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

Décrypter

decrypt déchiffre un message chiffré.

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

Signe

sign signera par chiffrement la synthèse (hachage) d’un message avec une signature.

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

Signer des données

signData signera par chiffrement un message avec une signature.

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

Vérifier

verify vérifie par chiffrement que le digest signé a été signé avec la signature donnée.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";
import { createHash } from "node:crypto";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const hash = createHash("sha256");
hash.update("My Message");
const digest = hash.digest();

const signResult = await cryptographyClient.sign("RS256", digest);
console.log("sign result: ", signResult.result);

const verifyResult = await cryptographyClient.verify("RS256", digest, signResult.result);
console.log("verify result: ", verifyResult.result);

Vérifier les données

verifyData vérifie par chiffrement que le message signé a été signé avec la signature donnée.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

const buffer = Buffer.from("My Message");

const signResult = await cryptographyClient.signData("RS256", buffer);
console.log("sign result: ", signResult.result);

const verifyResult = await cryptographyClient.verifyData("RS256", buffer, signResult.result);
console.log("verify result: ", verifyResult.result);

Inclure la clé

wrapKey encapsule une clé avec une couche de chiffrement.

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

Ne pas inclure la clé

unwrapKey désencapsulera une clé encapsulée.

import { DefaultAzureCredential } from "@azure/identity";
import { KeyClient, CryptographyClient } from "@azure/keyvault-keys";

const credential = new DefaultAzureCredential();

const vaultName = "<YOUR KEYVAULT NAME>";
const url = `https://${vaultName}.vault.azure.net`;

const client = new KeyClient(url, credential);

const myKey = await client.createKey("MyKey", "RSA");
const cryptographyClient = new CryptographyClient(myKey, credential);

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

Résolution des problèmes

Consultez notre guide de résolution des problèmes pour plus d’informations sur la façon de diagnostiquer différents scénarios d’échec.

L’activation de la journalisation peut vous aider à découvrir des informations utiles sur les échecs. Pour afficher un journal des requêtes et réponses HTTP, définissez la variable d’environnement AZURE_LOG_LEVEL sur info. Vous pouvez également activer la journalisation au moment de l’exécution en appelant setLogLevel dans la @azure/logger:

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

setLogLevel("info");

Étapes suivantes

Vous trouverez d’autres exemples de code via les liens suivants :

Contribuer

Si vous souhaitez contribuer à cette bibliothèque, lisez le guide de contribution pour en savoir plus sur la génération et le test du code.