namespace

crypto.webcrypto

namespace webcrypto

An implementation of the Web Crypto API standard.

See the Web Crypto API documentation for details.

interface AeadParams
- additionalData?: BufferSource
- iv: BufferSource
- name: string
- tagLength: number
interface AesCbcParams
- iv: BufferSource
- name: string
interface AesCtrParams
- counter: BufferSource
- length: number
- name: string
interface AesDerivedKeyParams
- length: number
- name: string
interface AesKeyAlgorithm
- length: number
- name: string
interface AesKeyGenParams
- length: number
- name: string
interface Algorithm
- name: string
interface Argon2Params
- associatedData?: BufferSource
- memory: number
- name: string
- nonce: BufferSource
- parallelism: number
- passes: number
- secretValue?: BufferSource
- version?: number
interface ContextParams
- context?: BufferSource
- name: string
interface Crypto
Importing the webcrypto object (import { webcrypto } from 'node:crypto') gives an instance of the Crypto class. Crypto is a singleton that provides access to the remainder of the crypto API.
- readonly subtle: SubtleCrypto
  Provides access to the SubtleCrypto API.
- getRandomValues<T extends Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike> | Int8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | BigUint64Array<ArrayBufferLike> | BigInt64Array<ArrayBufferLike>>(
  typedArray: T
  ): T;
  Generates cryptographically strong random values. The given typedArray is filled with random values, and a reference to typedArray is returned.
  The given typedArray must be an integer-based instance of NodeJS.TypedArray, i.e. Float32Array and Float64Array are not accepted.
  An error will be thrown if the given typedArray is larger than 65,536 bytes.
- randomUUID(): `${string}-${string}-${string}-${string}-${string}`;
  Generates a random RFC 4122 version 4 UUID. The UUID is generated using a cryptographic pseudorandom number generator.
interface CryptoKey
- readonly algorithm: KeyAlgorithm
  An object detailing the algorithm for which the key can be used along with additional algorithm-specific parameters.
- readonly extractable: boolean
  When true, the CryptoKey can be extracted using either subtleCrypto.exportKey() or subtleCrypto.wrapKey().
- readonly type: KeyType
  A string identifying whether the key is a symmetric ('secret') or asymmetric ('private' or 'public') key.
- readonly usages: KeyUsage[]
  An array of strings identifying the operations for which the key may be used.
  The possible usages are:
  'encrypt' - The key may be used to encrypt data.
  'decrypt' - The key may be used to decrypt data.
  'sign' - The key may be used to generate digital signatures.
  'verify' - The key may be used to verify digital signatures.
  'deriveKey' - The key may be used to derive a new key.
  'deriveBits' - The key may be used to derive bits.
  'wrapKey' - The key may be used to wrap another key.
  'unwrapKey' - The key may be used to unwrap another key.
  Valid key usages depend on the key algorithm (identified by cryptokey.algorithm.name).
interface CryptoKeyPair
The CryptoKeyPair is a simple dictionary object with publicKey and privateKey properties, representing an asymmetric key pair.
- privateKey: CryptoKey
  A CryptoKey whose type will be 'private'.
- publicKey: CryptoKey
  A CryptoKey whose type will be 'public'.
interface CShakeParams
- customization?: BufferSource
- functionName?: BufferSource
- length: number
- name: string
interface EcdhKeyDeriveParams
- name: string
- public: CryptoKey
interface EcdsaParams
- hash: AlgorithmIdentifier
- name: string
interface EcKeyAlgorithm
- name: string
- namedCurve: string
interface EcKeyGenParams
- name: string
- namedCurve: string
interface EcKeyImportParams
- name: string
- namedCurve: string
interface EncapsulatedBits
- ciphertext: ArrayBuffer
- sharedKey: ArrayBuffer
interface EncapsulatedKey
- ciphertext: ArrayBuffer
- sharedKey: CryptoKey
interface HkdfParams
- hash: AlgorithmIdentifier
- info: BufferSource
- name: string
- salt: BufferSource
interface HmacImportParams
- hash: AlgorithmIdentifier
- length?: number
- name: string
interface HmacKeyAlgorithm
- hash: KeyAlgorithm
- length: number
- name: string
interface HmacKeyGenParams
- hash: AlgorithmIdentifier
- length?: number
- name: string
interface JsonWebKey
- alg?: string
- crv?: string
- d?: string
- dp?: string
- dq?: string
- e?: string
- ext?: boolean
- k?: string
- key_ops?: string[]
- kty?: string
- n?: string
- oth?: RsaOtherPrimesInfo[]
- p?: string
- q?: string
- qi?: string
- use?: string
- x?: string
- y?: string
interface KeyAlgorithm
- name: string
interface KmacImportParams
- length?: number
- name: string
interface KmacKeyAlgorithm
- length: number
- name: string
interface KmacKeyGenParams
- length?: number
- name: string
interface KmacParams
- customization?: BufferSource
- length: number
- name: string
interface Pbkdf2Params
- hash: AlgorithmIdentifier
- iterations: number
- name: string
- salt: BufferSource
interface RsaHashedImportParams
- hash: AlgorithmIdentifier
- name: string
interface RsaHashedKeyAlgorithm
- hash: KeyAlgorithm
- modulusLength: number
- name: string
- publicExponent: BigInteger
interface RsaHashedKeyGenParams
- hash: AlgorithmIdentifier
- modulusLength: number
- name: string
- publicExponent: BigInteger
interface RsaKeyAlgorithm
- modulusLength: number
- name: string
- publicExponent: BigInteger
interface RsaKeyGenParams
- modulusLength: number
- name: string
- publicExponent: BigInteger
interface RsaOaepParams
- label?: BufferSource
- name: string
interface RsaOtherPrimesInfo
- d?: string
- r?: string
- t?: string
interface RsaPssParams
- name: string
- saltLength: number
interface SubtleCrypto
- decapsulateBits(
  decapsulationAlgorithm: AlgorithmIdentifier,
  decapsulationKey: CryptoKey,
  ciphertext: BufferSource
  ): Promise<ArrayBuffer>;
  A message recipient uses their asymmetric private key to decrypt an "encapsulated key" (ciphertext), thereby recovering a temporary symmetric key (represented as ArrayBuffer) which is then used to decrypt a message.
  The algorithms currently supported include:
  'ML-KEM-512'
  'ML-KEM-768'
  'ML-KEM-1024'
  @returns
  Fulfills with ArrayBuffer upon success.
- decapsulateKey(
  decapsulationAlgorithm: AlgorithmIdentifier,
  decapsulationKey: CryptoKey,
  ciphertext: BufferSource,
  sharedKeyAlgorithm: AlgorithmIdentifier | HmacImportParams | AesDerivedKeyParams | KmacImportParams,
  extractable: boolean,
  usages: KeyUsage[]
  ): Promise<CryptoKey>;
  A message recipient uses their asymmetric private key to decrypt an "encapsulated key" (ciphertext), thereby recovering a temporary symmetric key (represented as CryptoKey) which is then used to decrypt a message.
  The algorithms currently supported include:
  'ML-KEM-512'
  'ML-KEM-768'
  'ML-KEM-1024'
  @param usages
  See Key usages.
  @returns
  Fulfills with CryptoKey upon success.
- decrypt(
  algorithm: AlgorithmIdentifier | AeadParams | AesCbcParams | AesCtrParams | RsaOaepParams,
  key: CryptoKey,
  data: BufferSource
  ): Promise<ArrayBuffer>;
  Using the method and parameters specified in algorithm and the keying material provided by key, this method attempts to decipher the provided data. If successful, the returned promise will be resolved with an <ArrayBuffer> containing the plaintext result.
  The algorithms currently supported include:
  'AES-CBC'
  'AES-CTR'
  'AES-GCM'
  'AES-OCB'
  'ChaCha20-Poly1305'
  'RSA-OAEP'
- deriveBits(
  algorithm: EcdhKeyDeriveParams,
  baseKey: CryptoKey,
  length?: null | number
  ): Promise<ArrayBuffer>;
  Using the method and parameters specified in algorithm and the keying material provided by baseKey, this method attempts to generate length bits. The Node.js implementation requires that when length is a number it must be multiple of 8. When length is null the maximum number of bits for a given algorithm is generated. This is allowed for the 'ECDH', 'X25519', and 'X448' algorithms. If successful, the returned promise will be resolved with an <ArrayBuffer> containing the generated data.
  The algorithms currently supported include:
  'Argon2d'
  'Argon2i'
  'Argon2id'
  'ECDH'
  'HKDF'
  'PBKDF2'
  'X25519'
  'X448'
  deriveBits(
  algorithm: Argon2Params | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params,
  baseKey: CryptoKey,
  length: number
  ): Promise<ArrayBuffer>;
- deriveKey(
  algorithm: Argon2Params | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params,
  baseKey: CryptoKey,
  derivedKeyAlgorithm: AlgorithmIdentifier | HmacImportParams | AesDerivedKeyParams | KmacImportParams,
  extractable: boolean,
  keyUsages: readonly KeyUsage[]
  ): Promise<CryptoKey>;
  Using the method and parameters specified in algorithm, and the keying material provided by baseKey, this method attempts to generate a new <CryptoKey>based on the method and parameters inderivedKeyAlgorithm`.
  Calling subtle.deriveKey() is equivalent to calling subtle.deriveBits() to generate raw keying material, then passing the result into the subtle.importKey() method using the deriveKeyAlgorithm, extractable, and keyUsages parameters as input.
  The algorithms currently supported include:
  'Argon2d'
  'Argon2i'
  'Argon2id'
  'ECDH'
  'HKDF'
  'PBKDF2'
  'X25519'
  'X448'
  @param keyUsages
  See Key usages.
- digest(
  algorithm: AlgorithmIdentifier | CShakeParams,
  data: BufferSource
  ): Promise<ArrayBuffer>;
  Using the method identified by algorithm, subtle.digest() attempts to generate a digest of data. If successful, the returned promise is resolved with an <ArrayBuffer> containing the computed digest.
  If algorithm is provided as a <string>, it must be one of:
  'cSHAKE128'
  'cSHAKE256'
  'SHA-1'
  'SHA-256'
  'SHA-384'
  'SHA-512'
  'SHA3-256'
  'SHA3-384'
  'SHA3-512'
  If algorithm is provided as an <Object>, it must have a name property whose value is one of the above.
- encapsulateBits(
  encapsulationAlgorithm: AlgorithmIdentifier,
  encapsulationKey: CryptoKey
  ): Promise<EncapsulatedBits>;
  Uses a message recipient's asymmetric public key to encrypt a temporary symmetric key. This encrypted key is the "encapsulated key" represented as EncapsulatedBits.
  The algorithms currently supported include:
  'ML-KEM-512'
  'ML-KEM-768'
  'ML-KEM-1024'
  @returns
  Fulfills with EncapsulatedBits upon success.
- encapsulateKey(
  encapsulationAlgorithm: AlgorithmIdentifier,
  encapsulationKey: CryptoKey,
  sharedKeyAlgorithm: AlgorithmIdentifier | HmacImportParams | AesDerivedKeyParams | KmacImportParams,
  extractable: boolean,
  usages: KeyUsage[]
  ): Promise<EncapsulatedKey>;
  Uses a message recipient's asymmetric public key to encrypt a temporary symmetric key. This encrypted key is the "encapsulated key" represented as EncapsulatedKey.
  The algorithms currently supported include:
  'ML-KEM-512'
  'ML-KEM-768'
  'ML-KEM-1024'
  @param usages
  See Key usages.
  @returns
  Fulfills with EncapsulatedKey upon success.
- encrypt(
  algorithm: AlgorithmIdentifier | AeadParams | AesCbcParams | AesCtrParams | RsaOaepParams,
  key: CryptoKey,
  data: BufferSource
  ): Promise<ArrayBuffer>;
  Using the method and parameters specified by algorithm and the keying material provided by key, this method attempts to encipher data. If successful, the returned promise is resolved with an <ArrayBuffer> containing the encrypted result.
  The algorithms currently supported include:
  'AES-CBC'
  'AES-CTR'
  'AES-GCM'
  'AES-OCB'
  'ChaCha20-Poly1305'
  'RSA-OAEP'
- exportKey(
  format: 'jwk',
  key: CryptoKey
  ): Promise<JsonWebKey>;
  Exports the given key into the specified format, if supported.
  If the <CryptoKey> is not extractable, the returned promise will reject.
  When format is either 'pkcs8' or 'spki' and the export is successful, the returned promise will be resolved with an <ArrayBuffer> containing the exported key data.
  When format is 'jwk' and the export is successful, the returned promise will be resolved with a JavaScript object conforming to the JSON Web Key specification.
  @param format
  Must be one of 'raw', 'pkcs8', 'spki', 'jwk', 'raw-secret', 'raw-public', or 'raw-seed'.
  @returns
  <Promise> containing <ArrayBuffer>.
  exportKey(
  format: 'spki' | 'pkcs8' | 'raw' | 'raw-public' | 'raw-secret' | 'raw-seed',
  key: CryptoKey
  ): Promise<ArrayBuffer>;
- generateKey(
  algorithm: EcKeyGenParams | RsaHashedKeyGenParams,
  extractable: boolean,
  keyUsages: readonly KeyUsage[]
  ): Promise<CryptoKeyPair>;
  Using the parameters provided in algorithm, this method attempts to generate new keying material. Depending on the algorithm used either a single CryptoKey or a CryptoKeyPair is generated.
  The CryptoKeyPair (public and private key) generating algorithms supported include:
  'ECDH'
  'ECDSA'
  'Ed25519'
  'Ed448'
  'ML-DSA-44'
  'ML-DSA-65'
  'ML-DSA-87'
  'ML-KEM-512'
  'ML-KEM-768'
  'ML-KEM-1024'
  'RSA-OAEP'
  'RSA-PSS'
  'RSASSA-PKCS1-v1_5'
  'X25519'
  'X448'
  The CryptoKey (secret key) generating algorithms supported include:
  'AES-CBC'
  'AES-CTR'
  'AES-GCM'
  'AES-KW'
  'AES-OCB'
  'ChaCha20-Poly1305'
  'HMAC'
  'KMAC128'
  'KMAC256'
  @param keyUsages
  See Key usages.
  generateKey(
  algorithm: AesKeyGenParams | HmacKeyGenParams | KmacKeyGenParams | Pbkdf2Params,
  extractable: boolean,
  keyUsages: readonly KeyUsage[]
  ): Promise<CryptoKey>;
  generateKey(
  algorithm: AlgorithmIdentifier,
  extractable: boolean,
  keyUsages: KeyUsage[]
  ): Promise<CryptoKey | CryptoKeyPair>;
- getPublicKey(
  key: CryptoKey,
  keyUsages: KeyUsage[]
  ): Promise<CryptoKey>;
  Derives the public key from a given private key.
  @param key
  A private key from which to derive the corresponding public key.
  @param keyUsages
  See Key usages.
  @returns
  Fulfills with a CryptoKey upon success.
- importKey(
  format: 'jwk',
  keyData: JsonWebKey,
  algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm | KmacImportParams,
  extractable: boolean,
  keyUsages: readonly KeyUsage[]
  ): Promise<CryptoKey>;
  This method attempts to interpret the provided keyData as the given format to create a CryptoKey instance using the provided algorithm, extractable, and keyUsages arguments. If the import is successful, the returned promise will be resolved with a {CryptoKey} representation of the key material.
  If importing KDF algorithm keys, extractable must be false.
  @param format
  Must be one of 'raw', 'pkcs8', 'spki', 'jwk', 'raw-secret', 'raw-public', or 'raw-seed'.
  @param keyUsages
  See Key usages.
  importKey(
  format: 'spki' | 'pkcs8' | 'raw' | 'raw-public' | 'raw-secret' | 'raw-seed',
  keyData: BufferSource,
  algorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm | KmacImportParams,
  extractable: boolean,
  keyUsages: KeyUsage[]
  ): Promise<CryptoKey>;
- sign(
  algorithm: AlgorithmIdentifier | ContextParams | EcdsaParams | KmacParams | RsaPssParams,
  key: CryptoKey,
  data: BufferSource
  ): Promise<ArrayBuffer>;
  Using the method and parameters given by algorithm and the keying material provided by key, this method attempts to generate a cryptographic signature of data. If successful, the returned promise is resolved with an <ArrayBuffer> containing the generated signature.
  The algorithms currently supported include:
  'ECDSA'
  'Ed25519'
  'Ed448'
  'HMAC'
  'KMAC128'
  'KMAC256'
  'ML-DSA-44'
  'ML-DSA-65'
  'ML-DSA-87'
  'RSA-PSS'
  'RSASSA-PKCS1-v1_5'
- unwrapKey(
  format: KeyFormat,
  wrappedKey: BufferSource,
  unwrappingKey: CryptoKey,
  unwrapAlgorithm: AlgorithmIdentifier | AeadParams | AesCbcParams | AesCtrParams | RsaOaepParams,
  unwrappedKeyAlgorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm | KmacImportParams,
  extractable: boolean,
  keyUsages: KeyUsage[]
  ): Promise<CryptoKey>;
  In cryptography, "wrapping a key" refers to exporting and then encrypting the keying material. This method attempts to decrypt a wrapped key and create a <CryptoKey> instance. It is equivalent to calling subtle.decrypt() first on the encrypted key data (using the wrappedKey, unwrapAlgo, and unwrappingKey arguments as input) then passing the results in to the subtle.importKey() method using the unwrappedKeyAlgo, extractable, and keyUsages arguments as inputs. If successful, the returned promise is resolved with a <CryptoKey> object.
  The wrapping algorithms currently supported include:
  'AES-CBC'
  'AES-CTR'
  'AES-GCM'
  'AES-KW'
  'AES-OCB'
  'ChaCha20-Poly1305'
  'RSA-OAEP'
  The unwrapped key algorithms supported include:
  'AES-CBC'
  'AES-CTR'
  'AES-GCM'
  'AES-KW'
  'AES-OCB'
  'ChaCha20-Poly1305'
  'ECDH'
  'ECDSA'
  'Ed25519'
  'Ed448'
  'HMAC'
  'KMAC128'
  'KMAC256'
  'ML-DSA-44'
  'ML-DSA-65'
  'ML-DSA-87'
  'ML-KEM-512'
  'ML-KEM-768'
  'ML-KEM-1024'
  'RSA-OAEP'
  'RSA-PSS'
  'RSASSA-PKCS1-v1_5'
  'X25519'
  'X448'
  @param format
  Must be one of 'raw', 'pkcs8', 'spki', 'jwk', 'raw-secret', 'raw-public', or 'raw-seed'.
  @param keyUsages
  See Key usages.
- verify(
  algorithm: AlgorithmIdentifier | ContextParams | EcdsaParams | KmacParams | RsaPssParams,
  key: CryptoKey,
  signature: BufferSource,
  data: BufferSource
  ): Promise<boolean>;
  Using the method and parameters given in algorithm and the keying material provided by key, This method attempts to verify that signature is a valid cryptographic signature of data. The returned promise is resolved with either true or false.
  The algorithms currently supported include:
  'ECDSA'
  'Ed25519'
  'Ed448'
  'HMAC'
  'KMAC128'
  'KMAC256'
  'ML-DSA-44'
  'ML-DSA-65'
  'ML-DSA-87'
  'RSA-PSS'
  'RSASSA-PKCS1-v1_5'
- wrapKey(
  format: KeyFormat,
  key: CryptoKey,
  wrappingKey: CryptoKey,
  wrapAlgorithm: AlgorithmIdentifier | AeadParams | AesCbcParams | AesCtrParams | RsaOaepParams
  ): Promise<ArrayBuffer>;
  In cryptography, "wrapping a key" refers to exporting and then encrypting the keying material. This method exports the keying material into the format identified by format, then encrypts it using the method and parameters specified by wrapAlgo and the keying material provided by wrappingKey. It is the equivalent to calling subtle.exportKey() using format and key as the arguments, then passing the result to the subtle.encrypt() method using wrappingKey and wrapAlgo as inputs. If successful, the returned promise will be resolved with an <ArrayBuffer> containing the encrypted key data.
  The wrapping algorithms currently supported include:
  'AES-CBC'
  'AES-CTR'
  'AES-GCM'
  'AES-KW'
  'AES-OCB'
  'ChaCha20-Poly1305'
  'RSA-OAEP'
  @param format
  Must be one of 'raw', 'pkcs8', 'spki', 'jwk', 'raw-secret', 'raw-public', or 'raw-seed'.
type AlgorithmIdentifier = Algorithm | string
type BigInteger = Uint8Array
type BufferSource = ArrayBufferView | ArrayBuffer
type HashAlgorithmIdentifier = AlgorithmIdentifier
type KeyFormat = 'jwk' | 'pkcs8' | 'raw' | 'raw-public' | 'raw-secret' | 'raw-seed' | 'spki'
type KeyType = 'private' | 'public' | 'secret'
type KeyUsage = 'encrypt' | 'decrypt' | 'sign' | 'verify' | 'deriveKey' | 'deriveBits' | 'encapsulateBits' | 'decapsulateBits' | 'encapsulateKey' | 'decapsulateKey' | 'wrapKey' | 'unwrapKey'
type NamedCurve = string

crypto.webcrypto

namespace webcrypto

interface AeadParams

interface AesCbcParams

interface AesCtrParams

interface AesDerivedKeyParams

interface AesKeyAlgorithm

interface AesKeyGenParams

interface Algorithm

interface Argon2Params

interface ContextParams

interface Crypto

interface CryptoKey

interface CryptoKeyPair

interface CShakeParams

interface EcdhKeyDeriveParams

interface EcdsaParams

interface EcKeyAlgorithm

interface EcKeyGenParams

interface EcKeyImportParams

interface EncapsulatedBits

interface EncapsulatedKey

interface HkdfParams

interface HmacImportParams

interface HmacKeyAlgorithm

interface HmacKeyGenParams

interface JsonWebKey

interface KeyAlgorithm

interface KmacImportParams

interface KmacKeyAlgorithm

interface KmacKeyGenParams

interface KmacParams

interface Pbkdf2Params

interface RsaHashedImportParams

interface RsaHashedKeyAlgorithm

interface RsaHashedKeyGenParams

interface RsaKeyAlgorithm

interface RsaKeyGenParams

interface RsaOaepParams

interface RsaOtherPrimesInfo

interface RsaPssParams

interface SubtleCrypto