Azure Key Vault Key Client Library for JavaScript – 4.8.0-s verzió
Az Azure Key Vault egy olyan szolgáltatás, amellyel biztonságos kulcsokkal titkosíthatja a hitelesítési kulcsokat, a tárfiókkulcsokat, az adattitkosítási kulcsokat, a .pfx fájlokat és a jelszavakat. Ha többet szeretne megtudni az Azure Key Vault-ról, tekintse át a következőt: Mi az az Azure Key Vault?
Az Azure Key Vault Managed HSM egy teljes körűen felügyelt, magas rendelkezésre állású, egybérlős, szabványoknak megfelelő felhőszolgáltatás, amely lehetővé teszi a titkosítási kulcsok védelmét a felhőalkalmazások számára a FIPS 140-2 3. szintű ellenőrzött HSM-ekkel. Ha többet szeretne megtudni az Azure Key Vault Felügyelt HSM-ről, érdemes lehet áttekinteni a következőt: Mi az az Azure Key Vault managed HSM?
Az Azure Key Vault kulcstár-ügyfél támogatja az RSA-kulcsokat, az elliptikus görbe (EC) kulcsokat, valamint a szimmetrikus (okt) kulcsokat a felügyelt HSM-eken való futtatáskor, amelyek mindegyike rendelkezik a hardveres biztonsági modulok (HSM) megfelelő támogatásával. Műveleteket kínál a kulcsok és azok verzióinak létrehozásához, lekéréséhez, frissítéséhez, törléséhez, végleges törléséhez, biztonsági mentéséhez, visszaállításához és listázásához.
Használja az Azure Key Vault Keys ügyfélkódtárát az Node.js alkalmazásban a következő célokra:
- Kulcsok létrehozása háromliptikus görbével vagy RSA-titkosítással, opcionálisan hardveres biztonsági modulok (HSM) segítségével.
- Kulcsok importálása, törlése és frissítése.
- Szerezzen be egy vagy több kulcsot és törölt kulcsot az attribútumaikkal együtt.
- Törölt kulcs helyreállítása és biztonsági mentési kulcs visszaállítása.
- Kulcsverziók lekérése.
Az ebben a kódtárban elérhető titkosítási ügyféllel a következőket is elérheti:
- Titkosítása
- Visszafejtése
- Aláírás
- Ellenőrzése
- Körbefuttatási kulcsok
- Kulcsok kibontása
Megjegyzés: Ez a csomag az Azure Key Vault szolgáltatás korlátozásai miatt nem használható a böngészőben. Útmutatásért tekintse meg ezt a dokumentumot.
Főbb hivatkozások:
Első lépések
Jelenleg támogatott környezetek
Előfeltételek
- Azure-előfizetés
- Egy meglévő Azure-Key Vault. Ha létre kell hoznia egy kulcstartót, ezt az Azure Portalon teheti meg a jelen dokumentum lépéseit követve. Alternatív megoldásként használja az Azure CLI-t az alábbi lépések végrehajtásával.
- Felügyelt HSM használata esetén egy meglévő Azure Key Vault Felügyelt HSM. Ha felügyelt HSM-et kell létrehoznia, ezt az Azure CLI használatával teheti meg a jelen dokumentumban található lépések végrehajtásával.
A csomag telepítése
Az Azure Key Vault Key ügyfélkódtár telepítése az npm használatával
npm install @azure/keyvault-keys
Az identitástár telepítése
Az Azure Key Vault-ügyfelek hitelesítése az Azure-identitástár használatával történik. Az npm használatával is telepítheti
npm install @azure/identity
TypeScript konfigurálása
A TypeScript-felhasználóknak telepítve kell lenniük a csomóponttípus-definícióknak:
npm install @types/node
A tsconfig.json is engedélyeznie compilerOptions.allowSyntheticDefaultImports
kell. Vegye figyelembe, hogy ha engedélyeztecompilerOptions.esModuleInterop
allowSyntheticDefaultImports
, a alapértelmezés szerint engedélyezve van. További információt a TypeScript fordítóbeállítási kézikönyvében talál.
Fő fogalmak
- A kulcsügyfél az elsődleges felület, amely egy JavaScript-alkalmazásból származó Azure Key Vault API kulcsaival kapcsolatos API-metódusokkal kommunikál. Az inicializálás után a kulcsok létrehozásához, olvasásához, frissítéséhez és törléséhez használható egyszerű metóduskészletet biztosít.
- A kulcsverzió az Key Vault kulcsának verziója. Minden alkalommal, amikor egy felhasználó egy értéket rendel egy egyedi kulcsnévhez, létrejön a kulcs új verziója . A kulcs név szerinti lekérése mindig a legújabb hozzárendelt értéket adja vissza, hacsak nem ad meg egy adott verziót a lekérdezésnek.
- A helyreállítható törlés lehetővé teszi, hogy a Key Vaultok két külön lépésként támogassák a törlést és a törlést, így a törölt kulcsok nem vesznek el azonnal. Ez csak akkor fordul elő, ha a Key Vault engedélyezve van a helyreállítható törlés.
- A kulcs biztonsági mentése bármely létrehozott kulcsból létrehozható. Ezek a biztonsági másolatok bináris adatokként jönnek létre, és csak a korábban törölt kulcsok újragenerálásához használhatók.
- A titkosítási ügyfél egy külön felület, amely a kulcsok API-metódusaival kommunikál a Key Vault API-ban. Ez az ügyfél csak azokra a titkosítási műveletekre összpontosít, amelyeket a Key Vault már létrehozott kulccsal lehet végrehajtani. Erről az ügyfélről a Titkosítás szakaszban olvashat bővebben.
Hitelesítés az Azure Active Directoryval
A Key Vault szolgáltatás az Azure Active Directoryra támaszkodik az API-k felé irányuló kérések hitelesítéséhez. A @azure/identity
csomag számos hitelesítőadat-típust biztosít, amelyeket az alkalmazás ehhez használhat. A README for @azure/identity
további részleteket és mintákat tartalmaz az első lépésekhez.
Az Azure Key Vault szolgáltatás használatához létre kell hoznia KeyClient
egy osztálypéldányt, egy tároló URL-címét és egy hitelesítőadat-objektumot. Az ebben a dokumentumban bemutatott példák egy nevű hitelesítő objektumot DefaultAzureCredential
használnak, amely a legtöbb forgatókönyvhöz, beleértve a helyi fejlesztési és éles környezeteket is. Emellett azt javasoljuk, hogy felügyelt identitást használjon a hitelesítéshez éles környezetben.
A hitelesítés különböző módjairól és a hozzájuk tartozó hitelesítő adatok típusairól az Azure Identity dokumentációjában talál további információt.
Íme egy gyors példa. Először importálja DefaultAzureCredential
és KeyClient
:
const { DefaultAzureCredential } = require("@azure/identity");
const { KeyClient } = require("@azure/keyvault-keys");
Az importálás után csatlakozhatunk a Key Vault szolgáltatáshoz:
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);
Az Azure Key Vault szolgáltatás API-verziójának megadása
Alapértelmezés szerint ez a csomag az Azure Key Vault legújabb szolgáltatásverzióját használja, amely a következő7.2
: . A használt szolgáltatásverziót az ügyfélkonstruktorban az alábbi módon serviceVersion
állíthatja be:
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
});
Példák
Az alábbi szakaszok olyan kódrészleteket nyújtanak, amelyek az Azure Key Vault Keys használatával végzett gyakori feladatok némelyikét ismertetik. Az itt tárgyalt forgatókönyvek a következőkből állnak:
- Kulcs létrehozása.
- Kulcs beszerzése.
- Kulcsok létrehozása és frissítése attribútumokkal.
- Kulcs törlése.
- Kulcslisták iterálása.
Kulcs létrehozása
createKey
létrehoz egy kulcsot, amely az Azure Key Vault tárolandó. Ha már létezik azonos nevű kulcs, akkor létrejön a kulcs új verziója.
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();
A második elküldött createKey
paraméter a kulcs típusa. A támogatott kulcsok típusa a termékváltozattól és attól függ, hogy Azure-Key Vault vagy Azure-beli felügyelt HSM-et használ-e. A támogatott kulcstípusok naprakész listájáért tekintse meg a Kulcsok ismertetése témakört.
Kulcs lekérése
A kulcsok visszaolvasásának legegyszerűbb módja a kulcsok név szerinti lekérése. Ez lekéri a kulcs legújabb verzióját. Ha a választható paraméterek részeként adja meg, a kulcs másik verzióját is lekérheti.
getKey
lekéri a Key Vault korábbi kulcstárolóit.
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();
Kulcsok létrehozása és frissítése attribútumokkal
A következő attribútumok a Key Vault bármely kulcsához hozzárendelhetők:
tags
: A kulcsok kereséséhez és szűréséhez használható kulcsértékek összes készlete.keyOps
: A kulcs által végrehajtható műveletek tömbje (encrypt
, ,decrypt
sign
,verify
, , ).unwrapKey
wrapKey
enabled
: Logikai érték, amely meghatározza, hogy a kulcs értéke olvasható-e vagy sem.notBefore
: Egy adott dátum, amely után a kulcsérték lekérhető.expires
: Egy adott dátum, amely után a kulcsérték nem kérhető le.
Az ezekkel az attribútumokkal rendelkező objektumok a harmadik paramétereként createKey
küldhetők el közvetlenül a kulcs neve és értéke után, az alábbiak szerint:
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();
Ezzel létrehoz egy új verziót ugyanannak a kulcsnak, amely a legújabb attribútumokkal rendelkezik.
Az attribútumok frissíthetők egy meglévő kulcsverzióra is a használatával updateKeyProperties
, az alábbiak szerint:
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();
Kulcs törlése
A beginDeleteKey
metódus elindítja egy kulcs törlését.
Ez a folyamat a háttérben történik, amint a szükséges erőforrások elérhetővé válnak.
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();
Ha a helyreállítható törlés engedélyezve van a Key Vault, ez a művelet csak törölt kulcsként címkézi meg a kulcsot. A törölt kulcsok nem frissíthetők. Csak olvashatók, helyreállíthatók vagy törölhetők.
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();
Mivel a kulcsok teljes törlése eltarthat egy ideig, egy Poller-objektumot ad vissza, beginDeleteKey
amely nyomon követi a mögöttes hosszú futású műveletet az irányelveink szerint: https://azure.github.io/azure-sdk/typescript_design.html#ts-lro
A kapott lekérdezés lehetővé teszi a törölt kulcs lekérését a következő hívásával: poller.getResult()
.
A törlés befejezését úgy is megvárhatja, hogy egyes szolgáltatáshívásokat futtat a kulcs törléséig, vagy megvárja a folyamat befejezését:
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();
A kulcs teljes törlésének egy másik módja az egyes hívások lebonyolítása, az alábbiak szerint:
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();
Az automatikus kulcsrotálás konfigurálása
A KeyClient használatával automatikus kulcsrotálást konfigurálhat a kulcshoz a rotációs szabályzat megadásával. A KeyClient emellett egy metódust is biztosít a kulcs igény szerinti elforgatására az adott kulcs új verziójának létrehozásával.
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();
Kulcslisták iterálása
A KeyClient használatával lekérheti és iterálhatja az Azure-Key Vault összes kulcsát, valamint az összes törölt kulcsot és egy adott kulcs verzióját. A következő API-metódusok érhetők el:
listPropertiesOfKeys
az összes nem törölt kulcsot listázni fogja a nevük alapján, csak a legújabb verziójukon.listDeletedKeys
az összes törölt kulcsot listázni fogja a nevük alapján, csak a legújabb verziójukon.listPropertiesOfKeyVersions
egy kulcs összes verzióját listázni fogja egy kulcsnév alapján.
A következő módon használható:
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();
Ezen metódusok mindegyike egyszerre adja vissza az összes elérhető eredményt . Ha oldalak alapján szeretné lekérni őket, adja hozzá .byPage()
közvetlenül a használni kívánt API-metódus meghívása után, az alábbiak szerint:
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();
Titkosítás
Ez a kódtár a segítségével CryptographyClient
elérhető titkosítási segédprogramok készletét is kínálja. A -hez hasonlóan a KeyClient
CryptographyClient
megadott hitelesítő adatokkal csatlakozik az Azure Key Vault. A csatlakozás CryptographyClient
után titkosíthatja, visszafejtheti, aláírhatja, ellenőrizheti, körbefuttathatja a kulcsokat és feloldhatja a kulcsokat.
A következő lépésben ugyanúgy csatlakozhatunk a Key Vault szolgáltatáshoz, mint a KeyClient
-hez.
Át kell másolnunk néhány beállítást abból a kulcstartóból, amelyhez csatlakozunk a környezeti változókba. Ha már a környezetünkben vannak, a következő kóddal férhetünk hozzájuk:
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();
Titkosítás
encrypt
titkosítja az üzenetet.
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();
Visszafejtés
decrypt
visszafejt egy titkosított üzenetet.
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();
Előjel
sign
kriptográfiailag aláírja egy üzenet kivonatát (kivonatát) aláírással.
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();
Adatok aláírása
signData
kriptográfiai aláírással ír alá egy üzenetet.
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();
Ellenőrzés
verify
kriptográfiailag ellenőrzi, hogy az aláírt kivonat aláírása az adott aláírással történt-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();
Adatok ellenőrzése
verifyData
kriptográfiailag ellenőrzi, hogy az aláírt üzenet az adott aláírással lett-e aláírva.
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();
Kulcs körbefuttatása
wrapKey
a titkosítási réteggel burkolja a kulcsot.
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();
Kulcs kicsomagolása
unwrapKey
egy becsomagolt kulcsot fog kicsomagolni.
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();
Hibaelhárítás
A különböző hibaforgatókönyvek diagnosztizálásával kapcsolatos részletekért tekintse meg a hibaelhárítási útmutatónkat .
A naplózás engedélyezése hasznos információkat deríthet fel a hibákról. A HTTP-kérések és -válaszok naplójának megtekintéséhez állítsa a környezeti változót értékre AZURE_LOG_LEVEL
info
. A naplózás futásidőben is engedélyezhető a következő hívásával setLogLevel
@azure/logger
:
const { setLogLevel } = require("@azure/logger");
setLogLevel("info");
Következő lépések
További kódmintákat az alábbi hivatkozásokon találhat:
- Key Vault kulcsminták (JavaScript)
- Key Vault kulcsminták (TypeScript)
- Key Vault kulcstesztelési esetek
Közreműködés
Ha hozzá szeretne járulni ehhez a kódtárhoz, olvassa el a közreműködői útmutatót , amelyből többet is megtudhat a kód buildeléséhez és teszteléséhez.
Azure SDK for JavaScript