Partager via

Bibliothèque de client Azure Key Vault Key pour JavaScript - version 4.8.0

  • Article

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

Azure Key Vault Managed HSM est un service cloud entièrement managé, hautement disponible 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 Niveau 3. Si vous souhaitez en savoir plus sur Azure Key Vault HSM managé, consultez : Qu’est-ce qu’Azure Key Vault HSM managé ?

Le client de bibliothèque de clés Azure Key Vault prend en charge les clés RSA, les clés de courbe elliptique (EC), ainsi que les clés symétriques (oct) lors de l’exécution sur un HSM managé, chacune avec la prise en charge correspondante dans les modules de sécurité matériels (HSM). Il offre des opérations de création, de récupération, de mise à jour, de suppression, de purge, de sauvegarde, de restauration et de liste des clés et de leurs versions.

Utilisez la bibliothèque cliente pour azure Key Vault Keys dans votre application Node.js pour :

  • Créez des clés à l’aide d’une courbe elliptique ou d’un chiffrement RSA, éventuellement soutenu par des modules de sécurité matériels (HSM).
  • Clés d’importation, de suppression et de mise à jour.
  • 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.
  • Obtenir les versions d’une clé.

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

  • Chiffrement
  • Déchiffrement
  • Signature
  • Vérification
  • Clés 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 :

Prise en main

Environnements actuellement pris en charge

Prérequis

Installer le package

Installer la bibliothèque de client Azure Key Vault Key à 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é des définitions de type de nœud :

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 le manuel des options du compilateur de TypeScript .

Concepts clés

  • Le client Key est l’interface principale permettant d’interagir avec les méthodes d’API liées aux clés dans 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 Key Vault. 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.
  • La suppression réversible permet aux coffres de clés de prendre en charge la suppression et le vidage en deux étapes distinctes, de sorte que les clés supprimées ne sont pas immédiatement perdues. Cela se produit uniquement si la suppression réversible du Key Vault est activée.
  • Une sauvegarde de clé peut être générée à partir de n’importe quelle clé créée. Ces sauvegardes sont fournies sous forme de données binaires et ne peuvent être utilisées que pour régénérer une clé précédemment supprimée.
  • Le client Cryptography est une interface distincte qui interagit avec les méthodes d’API clés dans l’API Key Vault. Ce client se concentre uniquement sur 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 Key Vault. Pour plus d’informations sur ce client, consultez la section Chiffrement .

Authentification avec Azure Active Directory

Le service Key Vault s’appuie sur Azure Active Directory pour authentifier les demandes adressées à ses API. Le package @azure/identity fournit divers types d’informations d’identification que votre application peut utiliser à cette fin. Le FICHIER 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 un instance de la KeyClient classe, 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 aux environnements de développement et de production locaux. En outre, nous vous recommandons d’utiliser une identité managée pour l’authentification dans les environnements de production.

Vous trouverez plus d’informations sur les différentes méthodes d’authentification et leurs types d’informations d’identification correspondants dans la documentation Azure Identity.

Voici un exemple rapide. Tout d’abord, importez DefaultAzureCredential et KeyClient:

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

Une fois ceux-ci importés, nous pouvons ensuite nous connecter au service 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);

Spécification de la version de l’API du 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 :

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

Exemples

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

Création d’une clé

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

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

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 Key Vault Azure ou d’un HSM managé Azure. Pour obtenir une liste à jour des types de clés pris en charge, consultez À propos des clés

Obtention d’une clé

Le moyen le 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.

getKeyrécupère une clé des magasins précédents dans le 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();

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

Les attributs suivants peuvent également être attribués à n’importe quelle clé d’un Key Vault :

  • tags: tout ensemble de clés-valeurs qui peut être utilisé pour rechercher et filtrer des clés.
  • keyOps: tableau des opérations que cette clé sera en mesure d’effectuer (encrypt, , decryptsign, 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 :

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

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 :

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

Suppression d’une clé

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

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

Si la suppression réversible est activée pour le Key Vault, cette opération n’étiquetera la clé qu’en tant que clé supprimée. Une clé supprimée ne peut pas être mise à jour. Elles peuvent uniquement être lues, récupérées ou vidées.

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

Étant donné que la suppression complète des clés prend un certain temps, beginDeleteKey retourne un objet Poller qui effectue le suivi de l’opération de longue durée sous-jacente conformément à nos instructions : https://azure.github.io/azure-sdk/typescript_design.html#ts-lro

Le 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é :

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

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

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

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. En outre, KeyClient fournit une méthode pour faire pivoter une clé à la demande en créant une nouvelle version de la clé donnée.

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

Itération de listes de clés

À l’aide de KeyClient, vous pouvez récupérer et itérer toutes les clés d’un Key Vault 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 leur nom, uniquement dans leurs versions les plus récentes.
  • listDeletedKeys répertorie toutes vos clés supprimées en fonction de leur nom, uniquement à leur version la plus récente.
  • listPropertiesOfKeyVersions répertorie toutes les versions d’une clé en fonction d’un nom de clé.

Qui peut être utilisé comme suit :

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

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

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

Chiffrement

Cette bibliothèque offre également un ensemble d’utilitaires de chiffrement disponibles via CryptographyClient. Comme pour , KeyClientCryptographyClient se connecte à Azure Key Vault avec l’ensemble d’informations d’identification fourni. Une fois connecté, CryptographyClient peut chiffrer, déchiffrer, signer, vérifier, habillage des clés et désencapsuler les clés.

Nous pouvons ensuite nous connecter au service de coffre de clés comme nous le faisons avec .KeyClient Nous devons copier certains paramètres du coffre de clés à laquelle nous nous connectons dans nos variables d’environnement. Une fois qu’ils sont 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 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 (Chiffrer)

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

Déchiffrer

decrypt déchiffrera 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 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();

Signer

sign signe par chiffrement le digest (hachage) d’un message avec une signature.

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

Données de signature

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

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

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

Clé d’habillage

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

Unwrap Key

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

Dépannage

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 à mieux comprendre les échecs. Pour avoir 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 @azure/logger :

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

setLogLevel("info");

Étapes suivantes

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

Contribution

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.

Impressions