SubtleCrypto on Grafana Labs

decrypt

Mon, 21 Sep 2026 15:16:28 +0000

decrypt

The decrypt() method decrypts some encrypted data.

Usage

decrypt(algorithm, key, data)

Parameters

Name	Type	Description
`algorithm`	AesCbcParams, AesCtrParams, or AesGcmParams object	Defines the algorithm to use and any extra-parameters. The values given for the extra parameters must match those used in the corresponding [encrypt] call.
`key`	CryptoKey	The key to use for decryption.
`data`	`ArrayBuffer`, `TypedArray`, or `DataView`	The encrypted data to be decrypted (also known as ciphertext).

Supported algorithms

AES-CBC	AES-CTR	AES-GCM	RSA-OAEP
✅ AesCbcParams	✅ AesCtrParams	✅ AesGcmParams	✅ RsaOaepParams

Return Value

A Promise that resolves to a new ArrayBuffer containing the decrypted data.

Throws

Type	Description
`InvalidAccessError`	Raised when the requested operation is not valid with the provided key. For instance when an invalid encryption algorithm is used, or a key not matching the selected algorithm is provided.
`OperationError`	Raised when the operation failed for an operation-specific reason. For instance, if the algorithm size is invalid, or errors occurred during the process of decrypting the ciphertext.

Example

export default async function () {
  const plaintext = new TextEncoder().encode('Hello, World!');

  /**
   * Generate a symmetric key using the AES-CBC algorithm.
   */
  const key = await crypto.subtle.generateKey(
    {
      name: 'AES-CBC',
      length: 256,
    },
    true,
    ['encrypt', 'decrypt']
  );

  /**
   * Encrypt the plaintext using the AES-CBC key with
   * have generated.
   */
  const iv = crypto.getRandomValues(new Uint8Array(16));
  const ciphertext = await crypto.subtle.encrypt(
    {
      name: 'AES-CBC',
      iv: iv,
    },
    key,
    plaintext
  );

  /**
   * Decrypt the ciphertext using the same key to verify
   * that the resulting plaintext is the same as the original.
   */
  const deciphered = await crypto.subtle.decrypt(
    {
      name: 'AES-CBC',
      iv: iv,
    },
    key,
    ciphertext
  );

  console.log(
    'deciphered text == original plaintext: ',
    arrayBufferToHex(deciphered) === arrayBufferToHex(plaintext)
  );
}

function arrayBufferToHex(buffer) {
  return [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, '0')).join('');
}

deriveBits

Mon, 21 Sep 2026 15:16:28 +0000

deriveBits

It takes as its arguments the base key, the derivation algorithm to use, and the length of the bits to derive. It returns a Promise which will be fulfilled with an ArrayBuffer containing the derived bits. This array of bits can be used as a key for encryption or decryption as a shared secret.

Usage

deriveBits(algorithm, baseKey, length)

Parameters

Name	Type	Description
`algorithm`	EcdhKeyDeriveParams or Pbkdf2Params	An object defining a derivation algorithm to use.
`baseKey`	CryptoKey	Represents an input to derivation algorithm. Could be an ECDH private key or a PBKDF2 password imported as a CryptoKey.
`length`	`number`	The length of the bits to derive. Must be a positive number and a multiple of 8.

Supported algorithms

ECDH	PBKDF2	HKDF
✅ EcdhKeyDeriveParams	✅ Pbkdf2Params	❌

Return Value

A Promise that resolves to a new ArrayBuffer containing the derived bits.

Throws

Type	Description
`OperationError`	Raised when `length` is 0 or not a multiple of 8.

Examples

Deriving bits using ECDH

export default async function () {
  // Generate a key pair for Alice
  const aliceKeyPair = await crypto.subtle.generateKey(
    {
      name: 'ECDH',
      namedCurve: 'P-256',
    },
    true,
    ['deriveKey', 'deriveBits']
  );

  // Generate a key pair for Bob
  const bobKeyPair = await crypto.subtle.generateKey(
    {
      name: 'ECDH',
      namedCurve: 'P-256',
    },
    true,
    ['deriveKey', 'deriveBits']
  );

  // Derive shared secret for Alice
  const aliceSharedSecret = await deriveSharedSecret(aliceKeyPair.privateKey, bobKeyPair.publicKey);

  // Derive shared secret for Bob
  const bobSharedSecret = await deriveSharedSecret(bobKeyPair.privateKey, aliceKeyPair.publicKey);

  console.log('alice shared secret: ' + printArrayBuffer(aliceSharedSecret));
  console.log('bob shared secret: ' + printArrayBuffer(bobSharedSecret));
}

async function deriveSharedSecret(privateKey, publicKey) {
  return crypto.subtle.deriveBits(
    {
      name: 'ECDH',
      public: publicKey,
    },
    privateKey,
    256
  );
}

const printArrayBuffer = (buffer) => {
  const view = new Uint8Array(buffer);
  return Array.from(view);
};

Deriving bits using PBKDF2

export default async function () {
  const password = new TextEncoder().encode('my secret password');

  // Import the password as a key
  const baseKey = await crypto.subtle.importKey('raw', password, 'PBKDF2', false, [
    'deriveBits',
    'deriveKey',
  ]);

  // Generate a random salt
  const salt = crypto.getRandomValues(new Uint8Array(16));

  // Derive 256 bits using PBKDF2
  const derivedBits = await crypto.subtle.deriveBits(
    {
      name: 'PBKDF2',
      hash: 'SHA-256',
      salt: salt,
      iterations: 310000,
    },
    baseKey,
    256
  );

  console.log('derived bits: ' + printArrayBuffer(derivedBits));
}

const printArrayBuffer = (buffer) => {
  const view = new Uint8Array(buffer);
  return Array.from(view);
};

digest

Mon, 21 Sep 2026 15:16:28 +0000

digest

The digest() method generates a cryptographically secure digest of the given data. A digest is a short fixed-length value derived from some input data. The digest() method is commonly used to compute a checksum of data or to verify the integrity of data.

Usage

digest(algorithm, data)

Parameters

Name	Type	Description
`algorithm`	a `string` or object with a single `name` string property	Names the hash function to use. Supported values are `"SHA-1"`, `"SHA-256"`, `"SHA-384"` and `"SHA-512"`. Note that the SHA-1 hash function is not considered safe for cryptographic use.
`data`	`ArrayBuffer`, `TypedArray`, or `DataView`	The data to be digested.

Supported algorithms

SHA-1	SHA-256	SHA-384	SHA-512
✅	✅	✅	✅

Return Value

A Promise that resolves to a new ArrayBuffer containing the digest.

Example

export default async function () {
  const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode('Hello, world!'));

  console.log(arrayBufferToHex(digest));
}

function arrayBufferToHex(buffer) {
  return [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, '0')).join('');
}

deriveKey

Mon, 21 Sep 2026 15:16:28 +0000

deriveKey

The deriveKey() method derives a secret key from a master key. It takes as arguments a base key, the derivation algorithm to use, and the desired properties for the key to derive. It returns a Promise which will be fulfilled with a CryptoKey object representing the new key.

Usage

deriveKey(algorithm, baseKey, derivedKeyType, extractable, keyUsages)

Parameters

Name	Type	Description
`algorithm`	Pbkdf2Params	An object defining the derivation algorithm to use.
`baseKey`	CryptoKey	The base key to derive the new key from. For PBKDF2, this is the password imported as a CryptoKey.
`derivedKeyType`	object with `name` and `length` properties	An object defining the algorithm the derived key will be used for. Must include `name` (e.g., `AES-GCM`, `AES-CBC`, `AES-CTR`, `AES-KW`) and `length` (e.g., 256).
`extractable`	`boolean`	Whether the key can be exported using exportKey.
`keyUsages`	`Array<string>`	An array indicating what the key can be used for (e.g., `encrypt`, `decrypt`).

Supported algorithms

PBKDF2	ECDH	HKDF
✅ Pbkdf2Params	❌	❌

Supported derived key algorithms

AES-CBC	AES-CTR	AES-GCM	AES-KW	HMAC
✅	✅	✅	✅	❌

Return Value

A Promise that resolves to a new CryptoKey object.

Example

export default async function () {
  const password = new TextEncoder().encode('my secret password');

  // Import the password as a key
  const baseKey = await crypto.subtle.importKey('raw', password, 'PBKDF2', false, [
    'deriveBits',
    'deriveKey',
  ]);

  // Generate a random salt
  const salt = crypto.getRandomValues(new Uint8Array(16));

  // Derive an AES-GCM key using PBKDF2
  const derivedKey = await crypto.subtle.deriveKey(
    {
      name: 'PBKDF2',
      hash: 'SHA-256',
      salt: salt,
      iterations: 310000,
    },
    baseKey,
    {
      name: 'AES-GCM',
      length: 256,
    },
    true,
    ['encrypt', 'decrypt']
  );

  console.log('derived key: ' + JSON.stringify(derivedKey));
}

encrypt

Mon, 21 Sep 2026 15:16:28 +0000

encrypt

The encrypt() method encrypts some data.

Usage

encrypt(algorithm, key, data)

Parameters

Name	Type	Description
`algorithm`	AesCbcParams, AesCtrParams, or AesGcmParams object	Defines the algorithm to use and any extra-parameters.
`key`	CryptoKey	The key to use for encryption.
`data`	`ArrayBuffer`, `TypedArray`, or `DataView`	The data to be encrypted (also known as “plaintext”).

Supported algorithms

AES-CBC	AES-CTR	AES-GCM	RSA-OAEP
✅ AesCbcParams	✅ AesCtrParams	✅ AesGcmParams	✅ RsaOaepParams

Return Value

A Promise that resolves to a new ArrayBuffer containing the encrypted data.

Throws

Type	Description
`InvalidAccessError`	Raised when the requested operation is not valid with the provided key. For instance when an invalid encryption algorithm is used, or a key not matching the selected algorithm is provided.
`OperationError`	Raised when the operation failed for an operation-specific reason. For instance, if the algorithm size is invalid, or errors occurred during the process of decrypting the ciphertext.

Example

export default async function () {
  const plaintext = new TextEncoder().encode('Hello, World!');

  /**
   * Generate a symmetric key using the AES-CBC algorithm.
   */
  const key = await crypto.subtle.generateKey(
    {
      name: 'AES-CBC',
      length: 256,
    },
    true,
    ['encrypt', 'decrypt']
  );

  /**
   * Encrypt the plaintext using the AES-CBC key with
   * have generated.
   */
  const iv = crypto.getRandomValues(new Uint8Array(16));
  const ciphertext = await crypto.subtle.encrypt(
    {
      name: 'AES-CBC',
      iv: iv,
    },
    key,
    plaintext
  );

  /**
   * Decrypt the ciphertext using the same key to verify
   * that the resulting plaintext is the same as the original.
   */
  const deciphered = await crypto.subtle.decrypt(
    {
      name: 'AES-CBC',
      iv: iv,
    },
    key,
    ciphertext
  );

  console.log(
    'deciphered text == original plaintext: ',
    arrayBufferToHex(deciphered) === arrayBufferToHex(plaintext)
  );
}

function arrayBufferToHex(buffer) {
  return [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, '0')).join('');
}

exportKey

Mon, 21 Sep 2026 15:16:28 +0000

exportKey

The exportKey() method takes a CryptoKey object as input and exports it in an external, portable format.

Note that for a key to be exportable, it must have been created with the extractable flag set to true.

Usage

exportKey(format, key)

Parameters

Name	Type	Description
`format`	`string`	Defines the data format in which the key should be exported. Depending on the algorithm and key type, the data format could vary. Currently supported formats are `raw`, `jwk`, `spki`, and `pkcs8`.
`key`	CryptoKey	The key to export.

Supported algorithms

AES-CBC	AES-CTR	AES-GCM	AES-KW	ECDH	ECDSA	HMAC	PBKDF2	RSA-OAEP	RSASSA-PKCS1-v1_5	RSA-PSS
✅ AesCbcParams	✅ AesCtrParams	✅ AesGcmParams	❌	✅ EcdhKeyDeriveParams	✅ EcdsaParams	✅ HmacKeyGenParams	✅ Pbkdf2Params	✅ RsaHashedImportParams	✅ RsaHashedImportParams	✅ RsaHashedImportParams

Supported formats

ECDH and ECDSA algorithms have support for pkcs8, spki, raw and jwk formats.
RSA-OAEP, RSASSA-PKCS1-v1_5 and RSA-PSS algorithms have support for pkcs8, spki and jwk formats.
AES-* and HMAC algorithms have currently support for raw and jwk formats.
PBKDF2 algorithm has support for raw format only.

Return Value

A Promise that resolves to a new ArrayBuffer or an JsonWebKey object/dictionary containing the key.

Throws

Type	Description
`InvalidAccessError`	Raised when trying to export a non-extractable key.
`NotSupportedError`	Raised when trying to export in an unknown format.
`TypeError`	Raised when trying to use an invalid format.

Example

export default async function () {
  /**
   * Generate a symmetric key using the AES-CBC algorithm.
   */
  const generatedKey = await crypto.subtle.generateKey(
    {
      name: 'AES-CBC',
      length: '256',
    },
    true,
    ['encrypt', 'decrypt']
  );

  /**
   * Export the key in raw format.
   */
  const exportedKey = await crypto.subtle.exportKey('raw', generatedKey);

  /**
   * Reimport the key in raw format to verify its integrity.
   */
  const importedKey = await crypto.subtle.importKey('raw', exportedKey, 'AES-CBC', true, [
    'encrypt',
    'decrypt',
  ]);

  console.log(JSON.stringify(importedKey));
}

generateKey

Mon, 21 Sep 2026 15:16:28 +0000

generateKey

The generateKey() generates a new cryptographic key and returns it as a CryptoKey object or a CryptoKeyPair object that can be used with the Web Crypto API.

Usage

generateKey(algorithm, extractable, keyUsages)

Parameters

Name	Type	Description
`algorithm`	a `string` or algorithm object with a single `name` string	The type of key to generate. It can be either a string with any of the currently supported algorithms as a value or any of the generation key parameter objects.
`extractable`	`boolean`	Whether the key can be exported using exportKey.
`keyUsages`	`Array<string>`	An array of strings describing what operations can be performed with the key. Key usages could vary depending on the algorithm.

Supported algorithms

AES-CBC	AES-CTR	AES-GCM	AES-KW	ECDH	ECDSA	HMAC	PBKDF2	RSA-OAEP	RSASSA-PKCS1-v1_5	RSA-PSS
✅ AesCbcParams	✅ AesCtrParams	✅ AesGcmParams	❌	✅ EcdhKeyDeriveParams	✅ EcdsaParams	✅ HmacKeyGenParams	✅ Pbkdf2Params	✅ RsaHashedImportParams	✅ RsaHashedImportParams	✅ RsaHashedImportParams

Return Value

A Promise that resolves with the generated key as a CryptoKey object or a CryptoKeyPair object.

Algorithm specific input

	HMAC	AES	ECDH	ECDSA	RSA-OAEP	RSASSA-PKCS1-v1_5	RSA-PSS
Parameters type to use	`HmacKeyGenParams`	`AesKeyGenParams`	`EcKeyGenParams`	`EcKeyGenParams`	`RSAHashedKeyGenParams`	`RSAHashedKeyGenParams`	`RSAHashedKeyGenParams`
Possible key usages	`sign`, `verify`	`encrypt`, `decrypt`	`deriveKey`, `deriveBits`	`sign`, `verify`	`encrypt`, `decrypt`	`sign`, `verify`	`sign`, `verify`

Throws

Type	Description
`SyntaxError`	Raised when the `keyUsages` parameter is empty, but the key is of type `secret` or `private`.

Example

export default async function () {
  const key = await crypto.subtle.generateKey(
    {
      name: 'AES-CBC',
      length: 256,
    },
    true,
    ['encrypt', 'decrypt']
  );

  console.log(JSON.stringify(key));
}

importKey

Mon, 21 Sep 2026 15:16:28 +0000

importKey

The importKey() imports a key from an external, portable format, and gives you a CryptoKey object that can be used with the Web Crypto API.

Usage

importKey(format, keyData, algorithm, extractable, keyUsages)

Parameters

Name	Type	Description
`format`	`string`	Defines the data format of the key to import. Depending on the algorithm and key type, the data format could vary. Currently supported formats are `raw`, `jwk`, `spki`, and `pkcs8`.
`keyData`	`ArrayBuffer`, `TypedArray`, `DataView` or JsonWebKey	the data to import the key from.
`algorithm`	a `string` or object with a single `name` string property	The algorithm to use to import the key.
`extractable`	`boolean`	Indicates whether it will be possible to export the key using exportKey.
`keyUsages`	`Array<string>`	An array of strings describing what operations can be performed with the key. Supported usages include `encrypt`, `decrypt`, `sign`, `verify`, `deriveBits`, and `deriveKey`.

Supported algorithms

AES-CBC	AES-CTR	AES-GCM	AES-KW	ECDH	ECDSA	HMAC	PBKDF2	RSA-OAEP	RSASSA-PKCS1-v1_5	RSA-PSS
✅ AesCbcParams	✅ AesCtrParams	✅ AesGcmParams	❌	✅ EcdhKeyDeriveParams	✅ EcdsaParams	✅ HmacKeyGenParams	✅ Pbkdf2Params	✅ RsaHashedImportParams	✅ RsaHashedImportParams	✅ RsaHashedImportParams

Supported formats

ECDH and ECDSA algorithms have support for pkcs8, spki, raw and jwk formats.
RSA-OAEP, RSASSA-PKCS1-v1_5 and RSA-PSS algorithms have support for pkcs8, spki and jwk formats.
AES-* and HMAC algorithms have currently support for raw and jwk formats.
PBKDF2 algorithm has support for raw format only.

PBKDF2 constraints

When importing a key for the PBKDF2 algorithm, the following constraints apply:

extractable must be false. Attempting to set it to true throws a SyntaxError.
Only the raw format is supported. Other formats throw a NotSupportedError.
Only deriveBits and deriveKey usages are allowed. Other usages throw a SyntaxError.

Return Value

A Promise that resolves with the imported key as a CryptoKey object.

Throws

Type	Description
`SyntaxError`	Raised when the `keyUsages` parameter is empty but the key is of type `secret` or `private`.
`TypeError`	Raised when trying to use an invalid format, or if the `keyData` is not suited for that format.

Examples

Round-trip key export/import

export default async function () {
  /**
   * Generate a symmetric key using the AES-CBC algorithm.
   */
  const generatedKey = await crypto.subtle.generateKey(
    {
      name: 'AES-CBC',
      length: '256',
    },
    true,
    ['encrypt', 'decrypt']
  );

  /**
   * Export the key in raw format.
   */
  const exportedKey = await crypto.subtle.exportKey('raw', generatedKey);

  /**
   * Reimport the key in raw format to verify its integrity.
   */
  const importedKey = await crypto.subtle.importKey('raw', exportedKey, 'AES-CBC', true, [
    'encrypt',
    'decrypt',
  ]);

  console.log(JSON.stringify(importedKey));
}

Import a static raw key and decrypt transmitted data

This example demonstrates how to import a static raw key and decrypt some transmitted data in base64. The transmitted data in this example represents an initialization vector and encoded data, and in a real-world scenario, it can be a response body or other data received from a request.

import { b64decode } from 'k6/encoding';

export default async function () {
  const transmittedData = base64Decode(
    'whzEN310mrlWIH/icf0dMquRZ2ENyfOzkvPuu92WR/9F8dbeFM8EGUVNIhaS'
  );

  // keyData is the key used to decrypt the data, which is usually stored in a secure location
  // for this example, we are using a static key
  const keyData = new Uint8Array([
    109, 151, 76, 33, 232, 253, 176, 90, 94, 40, 146, 227, 139, 208, 245, 139, 69, 215, 55, 197, 43,
    122, 160, 178, 228, 104, 4, 115, 138, 159, 119, 49,
  ]);

  try {
    const result = await decrypt(keyData, transmittedData);

    // should output decrypted message
    // INFO[0000] result: 'my secret message'  source=console
    console.log("result: '" + result + "'");
  } catch (e) {
    console.log('Error: ' + JSON.stringify(e));
  }
}

const decrypt = async (keyData, transmittedData) => {
  const initializeVectorLength = 12;

  // the first 12 bytes are the initialization vector
  const iv = new Uint8Array(transmittedData.subarray(0, initializeVectorLength));

  // the rest of the transmitted data is the encrypted data
  const encryptedData = new Uint8Array(transmittedData.subarray(initializeVectorLength));

  const importedKey = await crypto.subtle.importKey(
    'raw',
    keyData,
    { name: 'AES-GCM', length: '256' },
    true,
    ['decrypt']
  );

  const plain = await crypto.subtle.decrypt(
    { name: 'AES-GCM', iv: iv },
    importedKey,
    encryptedData
  );

  return new TextDecoder().decode(plain);
};

const base64Decode = (base64String) => {
  return new Uint8Array(b64decode(base64String));
};

Import a static JWK key and decrypt transmitted data

This example is similar to the previous one. It demonstrates how to import a static jwk key and decrypt some transmitted data (which contains the initialization vector and encoded data) in base64.

import { b64decode } from 'k6/encoding';

export default async function () {
  // transmitted data is the base64 of the initialization vector + encrypted data
  // that unusually transmitted over the network
  const transmittedData = base64Decode(
    'drCfxl4O+5FcrHe8Bs0CvKlw3gZpv+S5if3zn7c4BJzHJ35QDFV4sJB0pbDT'
  );

  // keyData is the key used to decrypt the data, which is usually stored in a secure location
  // for this example, we are using a static key
  const jwkKeyData = {
    kty: 'oct',
    ext: true,
    key_ops: ['decrypt', 'encrypt'],
    alg: 'A256GCM',
    k: '9Id_8iG6FkGOWmc1S203vGVnTExtpDGxdQN7v7OV9Uc',
  };

  try {
    const result = await decrypt(jwkKeyData, transmittedData);

    // should output decrypted message
    // INFO[0000] result: 'my secret message'  source=console
    console.log("result: '" + result + "'");
  } catch (e) {
    console.log('Error: ' + JSON.stringify(e));
  }
}

const decrypt = async (keyData, transmittedData) => {
  const initializeVectorLength = 12;

  // the first 12 bytes are the initialization vector
  const iv = new Uint8Array(transmittedData.subarray(0, initializeVectorLength));

  // the rest of the transmitted data is the encrypted data
  const encryptedData = new Uint8Array(transmittedData.subarray(initializeVectorLength));

  const importedKey = await crypto.subtle.importKey(
    'jwk',
    keyData,
    { name: 'AES-GCM', length: 256 },
    true,
    ['encrypt', 'decrypt']
  );

  const plain = await crypto.subtle.decrypt(
    { name: 'AES-GCM', iv: iv },
    importedKey,
    encryptedData
  );

  return new TextDecoder().decode(plain);
};

const base64Decode = (base64String) => {
  return new Uint8Array(b64decode(base64String));
};

Import a password for PBKDF2 key derivation

This example demonstrates how to import a password as key material for PBKDF2 key derivation.

export default async function () {
  const password = new TextEncoder().encode('my secret password');

  // Import the password as a key for PBKDF2
  // Note: extractable must be false for PBKDF2
  const baseKey = await crypto.subtle.importKey('raw', password, 'PBKDF2', false, [
    'deriveBits',
    'deriveKey',
  ]);

  console.log('imported PBKDF2 key: ' + JSON.stringify(baseKey));

  // Now you can use this key with deriveBits or deriveKey
  const salt = crypto.getRandomValues(new Uint8Array(16));
  const derivedBits = await crypto.subtle.deriveBits(
    {
      name: 'PBKDF2',
      hash: 'SHA-256',
      salt: salt,
      iterations: 310000,
    },
    baseKey,
    256
  );

  console.log('derived bits: ' + arrayBufferToHex(derivedBits));
}

function arrayBufferToHex(buffer) {
  return [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, '0')).join('');
}

sign

Mon, 21 Sep 2026 15:16:28 +0000

sign

The sign() operation generates a digital signature of the provided data, using the given CryptoKey object.

Usage

sign(algorithm, key, data)

Parameters

Name	Type	Description
`algorithm`	`string` or object with a single `name` string property (`{name: "RSASSA-PKCS1-v1_5"}`) or an EcdsaParams, HmacKeyGenParams, or RsaPssParams object.	The signature algorithm to use.
`key`	CryptoKey	The key to use for signing.
`data`	`ArrayBuffer`, `TypedArray`, or `DataView`	The data to be signed.

Supported algorithms

ECDSA	HMAC	RSASSA-PKCS1-v1_5	RSA-PSS
✅ EcdsaParams	✅ HmacKeyGenParams	✅	✅ RsaPssParams

Return Value

A Promise that resolves with the signature as an ArrayBuffer.

Throws

Type	Description
`InvalidAccessError`	Raised when the signing key either does not support signing operation, or is incompatible with the selected algorithm.

Examples

Signing data with HMAC key

export default async function () {
  const generatedKey = await crypto.subtle.generateKey(
    {
      name: 'HMAC',
      hash: { name: 'SHA-1' },
    },
    true,
    ['sign', 'verify']
  );

  const data = new TextEncoder().encode('Hello World');

  /**
   * Signes the encoded data with the provided key using the HMAC algorithm
   * the returned signature can be verified using the verify method.
   */
  const signature = await crypto.subtle.sign('HMAC', generatedKey, data);

  /**
   * Verifies the signature of the encoded data with the provided key using the HMAC algorithm.
   */
  const verified = await crypto.subtle.verify('HMAC', generatedKey, signature, data);

  console.log('verified: ', verified);
}

Signing and verifying data with ECDSA

export default async function () {
  const keyPair = await crypto.subtle.generateKey(
    {
      name: 'ECDSA',
      namedCurve: 'P-256',
    },
    true,
    ['sign', 'verify']
  );

  const data = new TextEncoder().encode('Hello World');

  const alg = { name: 'ECDSA', hash: { name: 'SHA-256' } };

  // makes a signature of the encoded data with the provided key
  const signature = await crypto.subtle.sign(alg, keyPair.privateKey, data);

  console.log('signature: ', printArrayBuffer(signature));

  //Verifies the signature of the encoded data with the provided key
  const verified = await crypto.subtle.verify(alg, keyPair.publicKey, signature, data);

  console.log('verified: ', verified);
}

const printArrayBuffer = (buffer) => {
  const view = new Uint8Array(buffer);
  return Array.from(view);
};

verify

Mon, 21 Sep 2026 15:16:28 +0000

verify

The verify() operation verifies a digital signature. It ensures that some data was signed by a known key and that the data has not been tampered with since it was signed.

Usage

verify(algorithm, key, signature, data)

Parameters

Name	Type	Description
`algorithm`	`string` or object with a single `name` string property (`{name: "RSASSA-PKCS1-v1_5"}`) or an EcdsaParams, HmacKeyGenParams, or RsaPssParams object.	The signature algorithm to use.
`key`	CryptoKey	The key that will be used to verify the signature.
`signature`	`ArrayBuffer`	The signature to verify.
`data`	`ArrayBuffer`	The data whose signature is to be verified.

Supported algorithms

ECDSA	HMAC	RSASSA-PKCS1-v1_5	RSA-PSS
✅ EcdsaParams	✅ HmacKeyGenParams	✅	✅ RsaPssParams

Return Value

A Promise that resolves to a boolean value indicating if the signature is valid.

Throws

Type	Description
`InvalidAccessError`	Raised when the key either does not support the `verify` operation, or is incompatible with the selected algorithm.

Examples

Verifying an HMAC signature

export default async function () {
  const generatedKey = await crypto.subtle.generateKey(
    {
      name: 'HMAC',
      hash: { name: 'SHA-1' },
    },
    true,
    ['sign', 'verify']
  );

  const data = new TextEncoder().encode('Hello World');

  /**
   * Signes the encoded data with the provided key using the HMAC algorithm
   * the returned signature can be verified using the verify method.
   */
  const signature = await crypto.subtle.sign('HMAC', generatedKey, data);

  /**
   * Verifies the signature of the encoded data with the provided key using the HMAC algorithm.
   */
  const verified = await crypto.subtle.verify('HMAC', generatedKey, signature, data);

  console.log('verified: ', verified);
}

Verifying an ECDSA signature

export default async function () {
  const publicKey = await crypto.subtle.importKey(
    'spki',
    spkiPublicKeyData,
    { name: 'ECDSA', namedCurve: 'P-256' },
    true,
    ['verify']
  );

  // Verifies the signature of the encoded data with the provided key
  const verified = await crypto.subtle.verify(
    {
      name: 'ECDSA',
      hash: 'SHA-256',
    },
    publicKey,
    signature,
    plaintText
  );

  console.log('verified: ', verified);
}

const spkiPublicKeyData = new Uint8Array([
  48, 89, 48, 19, 6, 7, 42, 134, 72, 206, 61, 2, 1, 6, 8, 42, 134, 72, 206, 61, 3, 1, 7, 3, 66, 0,
  4, 10, 5, 30, 56, 111, 103, 196, 166, 225, 229, 203, 238, 125, 55, 116, 91, 88, 142, 190, 114, 15,
  117, 89, 22, 40, 111, 150, 41, 105, 122, 57, 23, 17, 216, 106, 234, 201, 103, 8, 210, 58, 38, 35,
  216, 198, 237, 187, 84, 217, 164, 63, 100, 6, 105, 49, 128, 15, 53, 29, 158, 117, 235, 238, 30,
]);

const plaintText = new Uint8Array([
  95, 77, 186, 79, 50, 12, 12, 232, 118, 114, 90, 252, 229, 251, 210, 91, 248, 62, 90, 113, 37, 160,
  140, 175, 231, 60, 62, 186, 196, 33, 119, 157, 249, 213, 93, 24, 12, 58, 233, 148, 38, 69, 225,
  216, 47, 238, 140, 157, 41, 75, 60, 177, 160, 138, 153, 49, 32, 27, 60, 14, 129, 252, 71, 202,
  207, 131, 21, 162, 175, 102, 50, 65, 19, 195, 182, 98, 48, 195, 70, 8, 196, 244, 89, 54, 52, 206,
  2, 178, 103, 54, 34, 119, 240, 168, 64, 202, 116, 188, 61, 26, 98, 54, 149, 44, 94, 215, 170, 248,
  168, 254, 203, 221, 250, 117, 132, 230, 151, 140, 234, 93, 42, 91, 159, 183, 241, 180, 140, 139,
  11, 229, 138, 48, 82, 2, 117, 77, 131, 118, 16, 115, 116, 121, 60, 240, 38, 170, 238, 83, 0, 114,
  125, 131, 108, 215, 30, 113, 179, 69, 221, 178, 228, 68, 70, 255, 197, 185, 1, 99, 84, 19, 137,
  13, 145, 14, 163, 128, 152, 74, 144, 25, 16, 49, 50, 63, 22, 219, 204, 157, 107, 225, 104, 184,
  72, 133, 56, 76, 160, 62, 18, 96, 10, 193, 194, 72, 2, 138, 243, 114, 108, 201, 52, 99, 136, 46,
  168, 192, 42, 171,
]);

const signature = new Uint8Array([
  83, 223, 63, 226, 42, 29, 106, 105, 225, 145, 197, 180, 118, 154, 109, 110, 66, 67, 47, 251, 53,
  190, 203, 65, 207, 36, 19, 57, 49, 122, 124, 118, 59, 74, 222, 134, 42, 235, 180, 229, 134, 24,
  205, 81, 171, 156, 100, 218, 127, 242, 126, 53, 27, 77, 249, 101, 157, 132, 244, 30, 67, 30, 64,
  12,
]);