Freigeben über

CryptographyClient class

Paket:
@azure/keyvault-keys

Ein Client, der zum Ausführen kryptografischer Vorgänge auf einem Azure Key Vault-Schlüssel oder einem lokalen JsonWebKey-verwendet wird.

Konstruktoren

CryptographyClient(JsonWebKey)

Erstellt eine neue Instanz des Kryptografieclients für den angegebenen Schlüssel im lokalen Modus.

Beispielverwendung:

import { CryptographyClient } from "@azure/keyvault-keys";

const jsonWebKey = {
  kty: "RSA",
  kid: "test-key-123",
  use: "sig",
  alg: "RS256",
  n: new Uint8Array([112, 34, 56, 98, 123, 244, 200, 99]),
  e: new Uint8Array([1, 0, 1]),
  d: new Uint8Array([45, 67, 89, 23, 144, 200, 76, 233]),
  p: new Uint8Array([34, 89, 100, 77, 204, 56, 29, 77]),
  q: new Uint8Array([78, 99, 201, 45, 188, 34, 67, 90]),
  dp: new Uint8Array([23, 45, 78, 56, 200, 144, 32, 67]),
  dq: new Uint8Array([12, 67, 89, 144, 99, 56, 23, 45]),
  qi: new Uint8Array([78, 90, 45, 201, 34, 67, 120, 55]),
};
const client = new CryptographyClient(jsonWebKey);
CryptographyClient(string | KeyVaultKey, TokenCredential, CryptographyClientOptions)

Erstellt eine neue Instanz des Kryptografieclients für den angegebenen Schlüssel.

Beispielverwendung:

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

Eigenschaften

keyID

Die ID des Schlüssels, der zum Ausführen kryptografischer Vorgänge für den Client verwendet wird.
vaultUrl

Die Basis-URL zum Tresor. Wenn ein lokaler JsonWebKey- verwendet wird, ist vaultUrl leer.

Methoden

decrypt(DecryptParameters, DecryptOptions)

Entschlüsselt den angegebenen Chiffretext mit den angegebenen Entschlüsselungsparametern. Je nach dem Algorithmus, der in den Entschlüsselungsparametern verwendet wird, ändert sich der Satz möglicher Entschlüsselungsparameter.

Microsoft empfiehlt, CBC nicht zu verwenden, ohne zuerst die Integrität des Chiffretexts zu gewährleisten, z. B. einen HMAC. Weitere Informationen finden Sie unter https://learn.microsoft.com/dotnet/standard/security/vulnerabilities-cbc-mode.

Beispielverwendung:

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());
decrypt(string, Uint8Array, DecryptOptions)

Entschlüsselt den angegebenen Verschlüsselungstext mit dem angegebenen Kryptografiealgorithmus.

Beispielverwendung:

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

Microsoft empfiehlt, CBC nicht zu verwenden, ohne zuerst die Integrität des Chiffretexts zu gewährleisten, z. B. einen HMAC. Weitere Informationen finden Sie unter https://learn.microsoft.com/dotnet/standard/security/vulnerabilities-cbc-mode.
encrypt(EncryptParameters, EncryptOptions)

Verschlüsselt den angegebenen Klartext mit den angegebenen Verschlüsselungsparametern. Je nach dem Algorithmus, der in den Verschlüsselungsparametern festgelegt ist, ändert sich der Satz möglicher Verschlüsselungsparameter.

Beispielverwendung:

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);
encrypt(string, Uint8Array, EncryptOptions)

Verschlüsselt den angegebenen Klartext mit dem angegebenen Kryptografiealgorithmus

Beispielverwendung:

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);
sign(string, Uint8Array, SignOptions)

Kryptografisch signieren sie den Digest einer Nachricht

Beispielverwendung:

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);
signData(string, Uint8Array, SignOptions)

Kryptografisch signieren sie einen Datenblock

Beispielverwendung:

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);
unwrapKey(KeyWrapAlgorithm, Uint8Array, UnwrapKeyOptions)

Entpackt den angegebenen umschlossenen Schlüssel mithilfe des angegebenen Kryptografiealgorithmus

Beispielverwendung:

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);
verify(string, Uint8Array, Uint8Array, VerifyOptions)

Überprüfen des Digests für signierte Nachrichten

Beispielverwendung:

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);
verifyData(string, Uint8Array, Uint8Array, VerifyOptions)

Überprüfen des signierten Datenblocks

Beispielverwendung:

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);
wrapKey(KeyWrapAlgorithm, Uint8Array, WrapKeyOptions)

Umschließt den angegebenen Schlüssel mithilfe des angegebenen Kryptografiealgorithmus

Beispielverwendung:

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

Details zum Konstruktor

CryptographyClient(JsonWebKey)

Erstellt eine neue Instanz des Kryptografieclients für den angegebenen Schlüssel im lokalen Modus.

Beispielverwendung:

import { CryptographyClient } from "@azure/keyvault-keys";

const jsonWebKey = {
  kty: "RSA",
  kid: "test-key-123",
  use: "sig",
  alg: "RS256",
  n: new Uint8Array([112, 34, 56, 98, 123, 244, 200, 99]),
  e: new Uint8Array([1, 0, 1]),
  d: new Uint8Array([45, 67, 89, 23, 144, 200, 76, 233]),
  p: new Uint8Array([34, 89, 100, 77, 204, 56, 29, 77]),
  q: new Uint8Array([78, 99, 201, 45, 188, 34, 67, 90]),
  dp: new Uint8Array([23, 45, 78, 56, 200, 144, 32, 67]),
  dq: new Uint8Array([12, 67, 89, 144, 99, 56, 23, 45]),
  qi: new Uint8Array([78, 90, 45, 201, 34, 67, 120, 55]),
};
const client = new CryptographyClient(jsonWebKey);

new CryptographyClient(key: JsonWebKey)

Parameter

key
JsonWebKey

Der JsonWebKey, der während Kryptografievorgängen verwendet werden soll.

CryptographyClient(string | KeyVaultKey, TokenCredential, CryptographyClientOptions)

Erstellt eine neue Instanz des Kryptografieclients für den angegebenen Schlüssel.

Beispielverwendung:

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

new CryptographyClient(key: string | KeyVaultKey, credential: TokenCredential, pipelineOptions?: CryptographyClientOptions)

Parameter

key

string | KeyVaultKey

Der Schlüssel, der während Kryptografieaufgaben verwendet werden soll. Sie können auch den Bezeichner des Schlüssels übergeben, d. h. dessen URL hier.

credential
TokenCredential

Ein Objekt, das die TokenCredential Schnittstelle implementiert, die zum Authentifizieren von Anforderungen an den Dienst verwendet wird. Verwenden Sie das @azure/identity-Paket, um eine Anmeldeinformation zu erstellen, die Ihren Anforderungen entspricht.

pipelineOptions
CryptographyClientOptions

Pipelineoptionen zum Konfigurieren von Key Vault-API-Anforderungen. Lassen Sie diesen Parameter aus, um die Standardpipelinekonfiguration zu verwenden.

Details zur Eigenschaft

keyID

Die ID des Schlüssels, der zum Ausführen kryptografischer Vorgänge für den Client verwendet wird.

undefined | string keyID

Eigenschaftswert

undefined | string

vaultUrl

Die Basis-URL zum Tresor. Wenn ein lokaler JsonWebKey- verwendet wird, ist vaultUrl leer.

string vaultUrl

Eigenschaftswert

string

Details zur Methode

decrypt(DecryptParameters, DecryptOptions)

Entschlüsselt den angegebenen Chiffretext mit den angegebenen Entschlüsselungsparametern. Je nach dem Algorithmus, der in den Entschlüsselungsparametern verwendet wird, ändert sich der Satz möglicher Entschlüsselungsparameter.

Microsoft empfiehlt, CBC nicht zu verwenden, ohne zuerst die Integrität des Chiffretexts zu gewährleisten, z. B. einen HMAC. Weitere Informationen finden Sie unter https://learn.microsoft.com/dotnet/standard/security/vulnerabilities-cbc-mode.

Beispielverwendung:

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

function decrypt(decryptParameters: DecryptParameters, options?: DecryptOptions): Promise<DecryptResult>

Parameter

decryptParameters
DecryptParameters

Die Entschlüsselungsparameter.

options
DecryptOptions

Weitere Optionen.

Gibt zurück

Promise<DecryptResult>

decrypt(string, Uint8Array, DecryptOptions)

Warnung

Diese API ist nun veraltet.

Use decrypt({ algorithm, ciphertext }, options) instead.

Entschlüsselt den angegebenen Verschlüsselungstext mit dem angegebenen Kryptografiealgorithmus.

Beispielverwendung:

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

Microsoft empfiehlt, CBC nicht zu verwenden, ohne zuerst die Integrität des Chiffretexts zu gewährleisten, z. B. einen HMAC. Weitere Informationen finden Sie unter https://learn.microsoft.com/dotnet/standard/security/vulnerabilities-cbc-mode.

function decrypt(algorithm: string, ciphertext: Uint8Array, options?: DecryptOptions): Promise<DecryptResult>

Parameter

algorithm

string

Der zu verwendende Algorithmus.

ciphertext

Uint8Array

Der zu entschlüsselnde Text.

options
DecryptOptions

Weitere Optionen.

Gibt zurück

Promise<DecryptResult>

encrypt(EncryptParameters, EncryptOptions)

Verschlüsselt den angegebenen Klartext mit den angegebenen Verschlüsselungsparametern. Je nach dem Algorithmus, der in den Verschlüsselungsparametern festgelegt ist, ändert sich der Satz möglicher Verschlüsselungsparameter.

Beispielverwendung:

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

function encrypt(encryptParameters: EncryptParameters, options?: EncryptOptions): Promise<EncryptResult>

Parameter

encryptParameters
EncryptParameters

Die Verschlüsselungsparameter, die für den ausgewählten Verschlüsselungsalgorithmus schlüsseliert werden.

options
EncryptOptions

Weitere Optionen.

Gibt zurück

Promise<EncryptResult>

encrypt(string, Uint8Array, EncryptOptions)

Warnung

Diese API ist nun veraltet.

Use encrypt({ algorithm, plaintext }, options) instead.

Verschlüsselt den angegebenen Klartext mit dem angegebenen Kryptografiealgorithmus

Beispielverwendung:

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

function encrypt(algorithm: string, plaintext: Uint8Array, options?: EncryptOptions): Promise<EncryptResult>

Parameter

algorithm

string

Der zu verwendende Algorithmus.

plaintext

Uint8Array

Der zu verschlüsselnde Text.

options
EncryptOptions

Weitere Optionen.

Gibt zurück

Promise<EncryptResult>

sign(string, Uint8Array, SignOptions)

Kryptografisch signieren sie den Digest einer Nachricht

Beispielverwendung:

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

function sign(algorithm: string, digest: Uint8Array, options?: SignOptions): Promise<SignResult>

Parameter

algorithm

string

Der zu verwendende Signaturalgorithmus.

digest

Uint8Array

Der Digest der zu signierenden Daten.

options
SignOptions

Weitere Optionen.

Gibt zurück

Promise<SignResult>

signData(string, Uint8Array, SignOptions)

Kryptografisch signieren sie einen Datenblock

Beispielverwendung:

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

function signData(algorithm: string, data: Uint8Array, options?: SignOptions): Promise<SignResult>

Parameter

algorithm

string

Der zu verwendende Signaturalgorithmus.

data

Uint8Array

Die zu signierenden Daten.

options
SignOptions

Weitere Optionen.

Gibt zurück

Promise<SignResult>

unwrapKey(KeyWrapAlgorithm, Uint8Array, UnwrapKeyOptions)

Entpackt den angegebenen umschlossenen Schlüssel mithilfe des angegebenen Kryptografiealgorithmus

Beispielverwendung:

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

function unwrapKey(algorithm: KeyWrapAlgorithm, encryptedKey: Uint8Array, options?: UnwrapKeyOptions): Promise<UnwrapResult>

Parameter

algorithm
KeyWrapAlgorithm

Der Entschlüsselungsalgorithmus, der zum Entschlüsseln des Schlüssels verwendet werden soll.

encryptedKey

Uint8Array

Der verschlüsselte Schlüssel zum Entpacken.

options
UnwrapKeyOptions

Weitere Optionen.

Gibt zurück

Promise<UnwrapResult>

verify(string, Uint8Array, Uint8Array, VerifyOptions)

Überprüfen des Digests für signierte Nachrichten

Beispielverwendung:

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

function verify(algorithm: string, digest: Uint8Array, signature: Uint8Array, options?: VerifyOptions): Promise<VerifyResult>

Parameter

algorithm

string

Der Signaturalgorithmus, mit dem überprüft werden soll.

digest

Uint8Array

Der zu überprüfende Digest.

signature

Uint8Array

Die Signatur, mit der der Digest überprüft werden soll.

options
VerifyOptions

Weitere Optionen.

Gibt zurück

Promise<VerifyResult>

verifyData(string, Uint8Array, Uint8Array, VerifyOptions)

Überprüfen des signierten Datenblocks

Beispielverwendung:

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

function verifyData(algorithm: string, data: Uint8Array, signature: Uint8Array, options?: VerifyOptions): Promise<VerifyResult>

Parameter

algorithm

string

Der Algorithmus, mit dem überprüft werden soll.

data

Uint8Array

Der signierte Datenblock, der überprüft werden soll.

signature

Uint8Array

Die Signatur, mit der der Block überprüft werden soll.

options
VerifyOptions

Weitere Optionen.

Gibt zurück

Promise<VerifyResult>

wrapKey(KeyWrapAlgorithm, Uint8Array, WrapKeyOptions)

Umschließt den angegebenen Schlüssel mithilfe des angegebenen Kryptografiealgorithmus

Beispielverwendung:

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

function wrapKey(algorithm: KeyWrapAlgorithm, key: Uint8Array, options?: WrapKeyOptions): Promise<WrapResult>

Parameter

algorithm
KeyWrapAlgorithm

Der Verschlüsselungsalgorithmus, der zum Umschließen des angegebenen Schlüssels verwendet werden soll.

key

Uint8Array

Der umgebrochene Schlüssel.

options
WrapKeyOptions

Weitere Optionen.

Gibt zurück

Promise<WrapResult>