crypto
The node:crypto module provides cryptographic functionality that includes a
set of wrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify
functions.
const { createHmac } = await import('node:crypto');
const secret = 'abcdefg';
const hash = createHmac('sha256', secret)
.update('I love cupcakes')
.digest('hex');
console.log(hash);
// Prints:
// c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
Usage in Deno
import * as mod from "node:crypto";
Classes
Instances of the Cipher class are used to encrypt data. The class can be
used in one of two ways:
Instances of the Decipher class are used to decrypt data. The class can be
used in one of two ways:
The DiffieHellman class is a utility for creating Diffie-Hellman key
exchanges.
Encapsulates an X509 certificate and provides read-only access to its information.
Functions
Creates and returns a Cipher object, with the given algorithm, key and
initialization vector (iv).
Creates and returns a Decipher object that uses the given algorithm, key and initialization vector (iv).
Creates a DiffieHellman key exchange object using the supplied prime and an
optional specific generator.
Creates an Elliptic Curve Diffie-Hellman (ECDH) key exchange object using a
predefined curve specified by the curveName string. Use getCurves to obtain a list of available curve names. On recent
OpenSSL releases, openssl ecparam -list_curves will also display the name
and description of each available elliptic curve.
Creates and returns a Hash object that can be used to generate hash digests
using the given algorithm. Optional options argument controls stream
behavior. For XOF hash functions such as 'shake256', the outputLength option
can be used to specify the desired output length in bytes.
Creates and returns an Hmac object that uses the given algorithm and key.
Optional options argument controls stream behavior.
Creates and returns a new key object containing a private key. If key is a
string or Buffer, format is assumed to be 'pem'; otherwise, key must be an object with the properties described above.
Creates and returns a new key object containing a public key. If key is a
string or Buffer, format is assumed to be 'pem'; if key is a KeyObject with type 'private', the public key is derived from the given private key;
otherwise, key must be an object with the properties described above.
Creates and returns a new key object containing a secret key for symmetric
encryption or Hmac.
Creates and returns a Sign object that uses the given algorithm. Use getHashes to obtain the names of the available digest algorithms.
Optional options argument controls the stream.Writable behavior.
Creates and returns a Verify object that uses the given algorithm.
Use getHashes to obtain an array of names of the available
signing algorithms. Optional options argument controls the stream.Writable behavior.
Computes the Diffie-Hellman secret based on a privateKey and a publicKey.
Both keys must have the same asymmetricKeyType, which must be one of 'dh' (for Diffie-Hellman), 'ec' (for ECDH), 'x448', or 'x25519' (for ECDH-ES).
Asynchronously generates a new random secret key of the given length. The type will determine which validations will be performed on the length.
Generates a new asymmetric key pair of the given type. RSA, RSA-PSS, DSA, EC,
Ed25519, Ed448, X25519, X448, and DH are currently supported.
Synchronously generates a new random secret key of the given length. The type will determine which validations will be performed on the length.
Creates a predefined DiffieHellmanGroup key exchange object. The
supported groups are listed in the documentation for DiffieHellmanGroup.
A convenient alias for webcrypto.getRandomValues. This implementation is not compliant with the Web Crypto spec, to write web-compatible code use webcrypto.getRandomValues instead.
A utility for creating one-shot hash digests of data. It can be faster than the object-based crypto.createHash() when hashing a smaller amount of data
(<= 5MB) that's readily available. If the data can be big or if it is streamed, it's still recommended to use crypto.createHash() instead. The algorithm
is dependent on the available algorithms supported by the version of OpenSSL on the platform. Examples are 'sha256', 'sha512', etc. On recent releases
of OpenSSL, openssl list -digest-algorithms will display the available digest algorithms.
HKDF is a simple key derivation function defined in RFC 5869. The given ikm, salt and info are used with the digest to derive a key of keylen bytes.
Provides a synchronous HKDF key derivation function as defined in RFC 5869. The
given ikm, salt and info are used with the digest to derive a key of keylen bytes.
Provides an asynchronous Password-Based Key Derivation Function 2 (PBKDF2)
implementation. A selected HMAC digest algorithm specified by digest is
applied to derive a key of the requested byte length (keylen) from the password, salt and iterations.
Provides a synchronous Password-Based Key Derivation Function 2 (PBKDF2)
implementation. A selected HMAC digest algorithm specified by digest is
applied to derive a key of the requested byte length (keylen) from the password, salt and iterations.
Decrypts buffer with privateKey. buffer was previously encrypted using
the corresponding public key, for example using publicEncrypt.
Encrypts buffer with privateKey. The returned data can be decrypted using
the corresponding public key, for example using publicDecrypt.
Encrypts the content of buffer with key and returns a new Buffer with encrypted content. The returned data can be decrypted using
the corresponding private key, for example using privateDecrypt.
Generates cryptographically strong pseudorandom data. The size argument
is a number indicating the number of bytes to generate.
This function is similar to randomBytes but requires the first
argument to be a Buffer that will be filled. It also
requires that a callback is passed in.
Return a random integer n such that min <= n < max. This
implementation avoids modulo bias.
Generates a random RFC 4122 version 4 UUID. The UUID is generated using a cryptographic pseudorandom number generator.
Provides a synchronous scrypt implementation. Scrypt is a password-based key derivation function that is designed to be expensive computationally and memory-wise in order to make brute-force attacks unrewarding.
Enables the FIPS compliant crypto provider in a FIPS-enabled Node.js build. Throws an error if FIPS mode is not available.
Calculates and returns the signature for data using the given private key and
algorithm. If algorithm is null or undefined, then the algorithm is
dependent upon the key type (especially Ed25519 and Ed448).
This function compares the underlying bytes that represent the given ArrayBuffer, TypedArray, or DataView instances using a constant-time
algorithm.
Verifies the given signature for data using the given key and algorithm. If algorithm is null or undefined, then the algorithm is dependent upon the
key type (especially Ed25519 and Ed448).
Interfaces
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.
The CryptoKeyPair is a simple dictionary object with publicKey and privateKey properties, representing an asymmetric key pair.
Namespaces
Type Aliases
Variables
Specifies the active default cipher list used by the current Node.js process (colon-separated values).
Specifies the built-in default cipher list used by Node.js (colon-separated values).
Causes the salt length for RSA_PKCS1_PSS_PADDING to be determined automatically when verifying a signature.
Sets the salt length for RSA_PKCS1_PSS_PADDING to the digest size when signing or verifying.
Sets the salt length for RSA_PKCS1_PSS_PADDING to the maximum permissible value when signing data.
Applies multiple bug workarounds within OpenSSL. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html for detail.
Instructs OpenSSL to allow a non-[EC]DHE-based key exchange mode for TLS v1.3
Allows legacy insecure renegotiation between OpenSSL and unpatched clients or servers. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html.
Attempts to use the server's preferences instead of the client's when selecting a cipher. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html.
Instructs OpenSSL to use Cisco's version identifier of DTLS_BAD_VER.
Instructs OpenSSL to add server-hello extension from an early version of the cryptopro draft.
Instructs OpenSSL to disable a SSL 3.0/TLS 1.0 vulnerability workaround added in OpenSSL 0.9.6d.
Instructs OpenSSL to always start a new session when performing renegotiation.
Instructs OpenSSL server to prioritize ChaCha20-Poly1305 when the client does. This option has no effect if SSL_OP_CIPHER_SERVER_PREFERENCE is not enabled.
class Certificate
Usage in Deno
import { Certificate } from "node:crypto";
The methods are non-functional stubs.
SPKAC is a Certificate Signing Request mechanism originally implemented by
Netscape and was specified formally as part of HTML5's keygen element.
<keygen> is deprecated since HTML 5.2 and new projects
should not use this element anymore.
The node:crypto module provides the Certificate class for working with SPKAC
data. The most common usage is handling output generated by the HTML5 <keygen> element. Node.js uses OpenSSL's SPKAC
implementation internally.
Methods #
#exportChallenge(spkac: BinaryLike): Buffer #exportPublicKey(spkac: BinaryLike,encoding?: string,): Buffer #verifySpkac(spkac: ArrayBufferView): boolean Static Methods #
#exportChallenge(spkac: BinaryLike): Buffer const { Certificate } = await import('node:crypto');
const spkac = getSpkacSomehow();
const challenge = Certificate.exportChallenge(spkac);
console.log(challenge.toString('utf8'));
// Prints: the challenge as a UTF8 string
#exportPublicKey(spkac: BinaryLike,encoding?: string,): Buffer const { Certificate } = await import('node:crypto');
const spkac = getSpkacSomehow();
const publicKey = Certificate.exportPublicKey(spkac);
console.log(publicKey);
// Prints: the public key as <Buffer ...>
#verifySpkac(spkac: ArrayBufferView): boolean import { Buffer } from 'node:buffer';
const { Certificate } = await import('node:crypto');
const spkac = getSpkacSomehow();
console.log(Certificate.verifySpkac(Buffer.from(spkac)));
// Prints: true or false
class Cipher
Usage in Deno
import { Cipher } from "node:crypto";
Instances of the Cipher class are used to encrypt data. The class can be
used in one of two ways:
- As a
streamthat is both readable and writable, where plain unencrypted data is written to produce encrypted data on the readable side, or - Using the
cipher.update()andcipher.final()methods to produce the encrypted data.
The createCipheriv method is
used to create Cipher instances. Cipher objects are not to be created
directly using the new keyword.
Example: Using Cipher objects as streams:
const {
scrypt,
randomFill,
createCipheriv,
} = await import('node:crypto');
const algorithm = 'aes-192-cbc';
const password = 'Password used to generate key';
// First, we'll generate the key. The key length is dependent on the algorithm.
// In this case for aes192, it is 24 bytes (192 bits).
scrypt(password, 'salt', 24, (err, key) => {
if (err) throw err;
// Then, we'll generate a random initialization vector
randomFill(new Uint8Array(16), (err, iv) => {
if (err) throw err;
// Once we have the key and iv, we can create and use the cipher...
const cipher = createCipheriv(algorithm, key, iv);
let encrypted = '';
cipher.setEncoding('hex');
cipher.on('data', (chunk) => encrypted += chunk);
cipher.on('end', () => console.log(encrypted));
cipher.write('some clear text data');
cipher.end();
});
});
Example: Using Cipher and piped streams:
import {
createReadStream,
createWriteStream,
} from 'node:fs';
import {
pipeline,
} from 'node:stream';
const {
scrypt,
randomFill,
createCipheriv,
} = await import('node:crypto');
const algorithm = 'aes-192-cbc';
const password = 'Password used to generate key';
// First, we'll generate the key. The key length is dependent on the algorithm.
// In this case for aes192, it is 24 bytes (192 bits).
scrypt(password, 'salt', 24, (err, key) => {
if (err) throw err;
// Then, we'll generate a random initialization vector
randomFill(new Uint8Array(16), (err, iv) => {
if (err) throw err;
const cipher = createCipheriv(algorithm, key, iv);
const input = createReadStream('test.js');
const output = createWriteStream('test.enc');
pipeline(input, cipher, output, (err) => {
if (err) throw err;
});
});
});
Example: Using the cipher.update() and cipher.final() methods:
const {
scrypt,
randomFill,
createCipheriv,
} = await import('node:crypto');
const algorithm = 'aes-192-cbc';
const password = 'Password used to generate key';
// First, we'll generate the key. The key length is dependent on the algorithm.
// In this case for aes192, it is 24 bytes (192 bits).
scrypt(password, 'salt', 24, (err, key) => {
if (err) throw err;
// Then, we'll generate a random initialization vector
randomFill(new Uint8Array(16), (err, iv) => {
if (err) throw err;
const cipher = createCipheriv(algorithm, key, iv);
let encrypted = cipher.update('some clear text data', 'utf8', 'hex');
encrypted += cipher.final('hex');
console.log(encrypted);
});
});
Constructors #
#Cipher() Methods #
Once the cipher.final() method has been called, the Cipher object can no
longer be used to encrypt data. Attempts to call cipher.final() more than
once will result in an error being thrown.
#setAutoPadding(autoPadding?: boolean): this When using block encryption algorithms, the Cipher class will automatically
add padding to the input data to the appropriate block size. To disable the
default padding call cipher.setAutoPadding(false).
When autoPadding is false, the length of the entire input data must be a
multiple of the cipher's block size or cipher.final() will throw an error.
Disabling automatic padding is useful for non-standard padding, for instance
using 0x0 instead of PKCS padding.
The cipher.setAutoPadding() method must be called before cipher.final().
#update(data: BinaryLike): Buffer Updates the cipher with data. If the inputEncoding argument is given,
the dataargument is a string using the specified encoding. If the inputEncodingargument is not given, data must be a Buffer, TypedArray, or DataView. If data is a Buffer,
TypedArray, or DataView, then inputEncoding is ignored.
The outputEncoding specifies the output format of the enciphered
data. If the outputEncodingis specified, a string using the specified encoding is returned. If nooutputEncoding is provided, a Buffer is returned.
The cipher.update() method can be called multiple times with new data until cipher.final() is called. Calling cipher.update() after cipher.final() will result in an error being
thrown.
class Decipher
Usage in Deno
import { Decipher } from "node:crypto";
Instances of the Decipher class are used to decrypt data. The class can be
used in one of two ways:
- As a
streamthat is both readable and writable, where plain encrypted data is written to produce unencrypted data on the readable side, or - Using the
decipher.update()anddecipher.final()methods to produce the unencrypted data.
The createDecipheriv method is
used to create Decipher instances. Decipher objects are not to be created
directly using the new keyword.
Example: Using Decipher objects as streams:
import { Buffer } from 'node:buffer';
const {
scryptSync,
createDecipheriv,
} = await import('node:crypto');
const algorithm = 'aes-192-cbc';
const password = 'Password used to generate key';
// Key length is dependent on the algorithm. In this case for aes192, it is
// 24 bytes (192 bits).
// Use the async `crypto.scrypt()` instead.
const key = scryptSync(password, 'salt', 24);
// The IV is usually passed along with the ciphertext.
const iv = Buffer.alloc(16, 0); // Initialization vector.
const decipher = createDecipheriv(algorithm, key, iv);
let decrypted = '';
decipher.on('readable', () => {
let chunk;
while (null !== (chunk = decipher.read())) {
decrypted += chunk.toString('utf8');
}
});
decipher.on('end', () => {
console.log(decrypted);
// Prints: some clear text data
});
// Encrypted with same algorithm, key and iv.
const encrypted =
'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa';
decipher.write(encrypted, 'hex');
decipher.end();
Example: Using Decipher and piped streams:
import {
createReadStream,
createWriteStream,
} from 'node:fs';
import { Buffer } from 'node:buffer';
const {
scryptSync,
createDecipheriv,
} = await import('node:crypto');
const algorithm = 'aes-192-cbc';
const password = 'Password used to generate key';
// Use the async `crypto.scrypt()` instead.
const key = scryptSync(password, 'salt', 24);
// The IV is usually passed along with the ciphertext.
const iv = Buffer.alloc(16, 0); // Initialization vector.
const decipher = createDecipheriv(algorithm, key, iv);
const input = createReadStream('test.enc');
const output = createWriteStream('test.js');
input.pipe(decipher).pipe(output);
Example: Using the decipher.update() and decipher.final() methods:
import { Buffer } from 'node:buffer';
const {
scryptSync,
createDecipheriv,
} = await import('node:crypto');
const algorithm = 'aes-192-cbc';
const password = 'Password used to generate key';
// Use the async `crypto.scrypt()` instead.
const key = scryptSync(password, 'salt', 24);
// The IV is usually passed along with the ciphertext.
const iv = Buffer.alloc(16, 0); // Initialization vector.
const decipher = createDecipheriv(algorithm, key, iv);
// Encrypted using same algorithm, key and iv.
const encrypted =
'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa';
let decrypted = decipher.update(encrypted, 'hex', 'utf8');
decrypted += decipher.final('utf8');
console.log(decrypted);
// Prints: some clear text data
Constructors #
#Decipher() Methods #
Once the decipher.final() method has been called, the Decipher object can
no longer be used to decrypt data. Attempts to call decipher.final() more
than once will result in an error being thrown.
#setAutoPadding(auto_padding?: boolean): this When data has been encrypted without standard block padding, calling decipher.setAutoPadding(false) will disable automatic padding to prevent decipher.final() from checking for and
removing padding.
Turning auto padding off will only work if the input data's length is a multiple of the ciphers block size.
The decipher.setAutoPadding() method must be called before decipher.final().
Updates the decipher with data. If the inputEncoding argument is given,
the data argument is a string using the specified encoding. If the inputEncoding argument is not given, data must be a Buffer. If data is a Buffer then inputEncoding is
ignored.
The outputEncoding specifies the output format of the enciphered
data. If the outputEncoding is specified, a string using the specified encoding is returned. If no outputEncoding is provided, a Buffer is returned.
The decipher.update() method can be called multiple times with new data until decipher.final() is called. Calling decipher.update() after decipher.final() will result in an error
being thrown.
class DiffieHellman
Usage in Deno
import { DiffieHellman } from "node:crypto";
The DiffieHellman class is a utility for creating Diffie-Hellman key
exchanges.
Instances of the DiffieHellman class can be created using the createDiffieHellman function.
import assert from 'node:assert';
const {
createDiffieHellman,
} = await import('node:crypto');
// Generate Alice's keys...
const alice = createDiffieHellman(2048);
const aliceKey = alice.generateKeys();
// Generate Bob's keys...
const bob = createDiffieHellman(alice.getPrime(), alice.getGenerator());
const bobKey = bob.generateKeys();
// Exchange and generate the secret...
const aliceSecret = alice.computeSecret(bobKey);
const bobSecret = bob.computeSecret(aliceKey);
// OK
assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex'));
Constructors #
#DiffieHellman() Properties #
#verifyError: number A bit field containing any warnings and/or errors resulting from a check
performed during initialization of the DiffieHellman object.
The following values are valid for this property (as defined in node:constants module):
DH_CHECK_P_NOT_SAFE_PRIMEDH_CHECK_P_NOT_PRIMEDH_UNABLE_TO_CHECK_GENERATORDH_NOT_SUITABLE_GENERATOR
Methods #
#computeSecret(otherPublicKey: ArrayBufferView,inputEncoding?: null,outputEncoding?: null,): Buffer Computes the shared secret using otherPublicKey as the other
party's public key and returns the computed shared secret. The supplied
key is interpreted using the specified inputEncoding, and secret is
encoded using specified outputEncoding.
If the inputEncoding is not
provided, otherPublicKey is expected to be a Buffer, TypedArray, or DataView.
If outputEncoding is given a string is returned; otherwise, a Buffer is returned.
#computeSecret(): Buffer #computeSecret(): string #computeSecret(): string #generateKeys(): Buffer Generates private and public Diffie-Hellman key values unless they have been
generated or computed already, and returns
the public key in the specified encoding. This key should be
transferred to the other party.
If encoding is provided a string is returned; otherwise a Buffer is returned.
This function is a thin wrapper around DH_generate_key(). In particular,
once a private key has been generated or set, calling this function only updates
the public key but does not generate a new private key.
#generateKeys(encoding: BinaryToTextEncoding): string #getGenerator(): Buffer Returns the Diffie-Hellman generator in the specified encoding.
If encoding is provided a string is
returned; otherwise a Buffer is returned.
#getGenerator(encoding: BinaryToTextEncoding): string Returns the Diffie-Hellman prime in the specified encoding.
If encoding is provided a string is
returned; otherwise a Buffer is returned.
#getPrime(encoding: BinaryToTextEncoding): string #getPrivateKey(): Buffer Returns the Diffie-Hellman private key in the specified encoding.
If encoding is provided a
string is returned; otherwise a Buffer is returned.
#getPrivateKey(encoding: BinaryToTextEncoding): string #getPublicKey(): Buffer Returns the Diffie-Hellman public key in the specified encoding.
If encoding is provided a
string is returned; otherwise a Buffer is returned.
#getPublicKey(encoding: BinaryToTextEncoding): string #setPrivateKey(privateKey: ArrayBufferView): void Sets the Diffie-Hellman private key. If the encoding argument is provided,privateKey is expected
to be a string. If no encoding is provided, privateKey is expected
to be a Buffer, TypedArray, or DataView.
This function does not automatically compute the associated public key. Either diffieHellman.setPublicKey() or diffieHellman.generateKeys() can be
used to manually provide the public key or to automatically derive it.
#setPrivateKey(privateKey: string,encoding: BufferEncoding,): void #setPublicKey(publicKey: ArrayBufferView): void Sets the Diffie-Hellman public key. If the encoding argument is provided, publicKey is expected
to be a string. If no encoding is provided, publicKey is expected
to be a Buffer, TypedArray, or DataView.
#setPublicKey(publicKey: string,encoding: BufferEncoding,): void class ECDH
Usage in Deno
import { ECDH } from "node:crypto";
The convertKey method is a non-functional sub.
The ECDH class is a utility for creating Elliptic Curve Diffie-Hellman (ECDH)
key exchanges.
Instances of the ECDH class can be created using the createECDH function.
import assert from 'node:assert';
const {
createECDH,
} = await import('node:crypto');
// Generate Alice's keys...
const alice = createECDH('secp521r1');
const aliceKey = alice.generateKeys();
// Generate Bob's keys...
const bob = createECDH('secp521r1');
const bobKey = bob.generateKeys();
// Exchange and generate the secret...
const aliceSecret = alice.computeSecret(bobKey);
const bobSecret = bob.computeSecret(aliceKey);
assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex'));
// OK
Constructors #
#ECDH() Methods #
#computeSecret(otherPublicKey: ArrayBufferView): Buffer Computes the shared secret using otherPublicKey as the other
party's public key and returns the computed shared secret. The supplied
key is interpreted using specified inputEncoding, and the returned secret
is encoded using the specified outputEncoding.
If the inputEncoding is not
provided, otherPublicKey is expected to be a Buffer, TypedArray, or DataView.
If outputEncoding is given a string will be returned; otherwise a Buffer is returned.
ecdh.computeSecret will throw anERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY error when otherPublicKey lies outside of the elliptic curve. Since otherPublicKey is
usually supplied from a remote user over an insecure network,
be sure to handle this exception accordingly.
#computeSecret(otherPublicKey: string,inputEncoding: BinaryToTextEncoding,): Buffer #computeSecret(otherPublicKey: ArrayBufferView,outputEncoding: BinaryToTextEncoding,): string #computeSecret(): string #generateKeys(): Buffer Generates private and public EC Diffie-Hellman key values, and returns
the public key in the specified format and encoding. This key should be
transferred to the other party.
The format argument specifies point encoding and can be 'compressed' or 'uncompressed'. If format is not specified, the point will be returned in'uncompressed' format.
If encoding is provided a string is returned; otherwise a Buffer is returned.
#generateKeys(encoding: BinaryToTextEncoding,format?: ECDHKeyFormat,): string #getPrivateKey(): Buffer If encoding is specified, a string is returned; otherwise a Buffer is
returned.
#getPrivateKey(encoding: BinaryToTextEncoding): string #getPublicKey(encoding?: null,format?: ECDHKeyFormat,): Buffer The format argument specifies point encoding and can be 'compressed' or 'uncompressed'. If format is not specified the point will be returned in'uncompressed' format.
If encoding is specified, a string is returned; otherwise a Buffer is
returned.
#getPublicKey(encoding: BinaryToTextEncoding,format?: ECDHKeyFormat,): string #setPrivateKey(privateKey: ArrayBufferView): void Sets the EC Diffie-Hellman private key.
If encoding is provided, privateKey is expected
to be a string; otherwise privateKey is expected to be a Buffer, TypedArray, or DataView.
If privateKey is not valid for the curve specified when the ECDH object was
created, an error is thrown. Upon setting the private key, the associated
public point (key) is also generated and set in the ECDH object.
#setPrivateKey(privateKey: string,encoding: BinaryToTextEncoding,): void Static Methods #
#convertKey(key: BinaryLike,curve: string,inputEncoding?: BinaryToTextEncoding,outputEncoding?: "latin1"
| "hex"
| "base64"
| "base64url",format?: "uncompressed"
| "compressed"
| "hybrid",): Buffer | string Converts the EC Diffie-Hellman public key specified by key and curve to the
format specified by format. The format argument specifies point encoding
and can be 'compressed', 'uncompressed' or 'hybrid'. The supplied key is
interpreted using the specified inputEncoding, and the returned key is encoded
using the specified outputEncoding.
Use getCurves to obtain a list of available curve names.
On recent OpenSSL releases, openssl ecparam -list_curves will also display
the name and description of each available elliptic curve.
If format is not specified the point will be returned in 'uncompressed' format.
If the inputEncoding is not provided, key is expected to be a Buffer, TypedArray, or DataView.
Example (uncompressing a key):
const {
createECDH,
ECDH,
} = await import('node:crypto');
const ecdh = createECDH('secp256k1');
ecdh.generateKeys();
const compressedKey = ecdh.getPublicKey('hex', 'compressed');
const uncompressedKey = ECDH.convertKey(compressedKey,
'secp256k1',
'hex',
'hex',
'uncompressed');
// The converted key and the uncompressed public key should be the same
console.log(uncompressedKey === ecdh.getPublicKey('hex'));
class Hash
Usage in Deno
import { Hash } from "node:crypto";
The Hash class is a utility for creating hash digests of data. It can be
used in one of two ways:
- As a
streamthat is both readable and writable, where data is written to produce a computed hash digest on the readable side, or - Using the
hash.update()andhash.digest()methods to produce the computed hash.
The createHash method is used to create Hash instances. Hashobjects are not to be created directly using the new keyword.
Example: Using Hash objects as streams:
const {
createHash,
} = await import('node:crypto');
const hash = createHash('sha256');
hash.on('readable', () => {
// Only one element is going to be produced by the
// hash stream.
const data = hash.read();
if (data) {
console.log(data.toString('hex'));
// Prints:
// 6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
}
});
hash.write('some data to hash');
hash.end();
Example: Using Hash and piped streams:
import { createReadStream } from 'node:fs';
import { stdout } from 'node:process';
const { createHash } = await import('node:crypto');
const hash = createHash('sha256');
const input = createReadStream('test.js');
input.pipe(hash).setEncoding('hex').pipe(stdout);
Example: Using the hash.update() and hash.digest() methods:
const {
createHash,
} = await import('node:crypto');
const hash = createHash('sha256');
hash.update('some data to hash');
console.log(hash.digest('hex'));
// Prints:
// 6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
Constructors #
#Hash() Methods #
#copy(options?: HashOptions): Hash Creates a new Hash object that contains a deep copy of the internal state
of the current Hash object.
The optional options argument controls stream behavior. For XOF hash
functions such as 'shake256', the outputLength option can be used to
specify the desired output length in bytes.
An error is thrown when an attempt is made to copy the Hash object after
its hash.digest() method has been called.
// Calculate a rolling hash.
const {
createHash,
} = await import('node:crypto');
const hash = createHash('sha256');
hash.update('one');
console.log(hash.copy().digest('hex'));
hash.update('two');
console.log(hash.copy().digest('hex'));
hash.update('three');
console.log(hash.copy().digest('hex'));
// Etc.
Calculates the digest of all of the data passed to be hashed (using the hash.update() method).
If encoding is provided a string will be returned; otherwise
a Buffer is returned.
The Hash object can not be used again after hash.digest() method has been
called. Multiple calls will cause an error to be thrown.
#digest(encoding: BinaryToTextEncoding): string #update(data: BinaryLike): Hash Updates the hash content with the given data, the encoding of which
is given in inputEncoding.
If encoding is not provided, and the data is a string, an
encoding of 'utf8' is enforced. If data is a Buffer, TypedArray, orDataView, then inputEncoding is ignored.
This can be called many times with new data as it is streamed.
class KeyObject
Usage in Deno
import { KeyObject } from "node:crypto";
The following are non-functional stubs:
- from
- symmetricKeySize
- equals
Node.js uses a KeyObject class to represent a symmetric or asymmetric key,
and each kind of key exposes different functions. The createSecretKey, createPublicKey and createPrivateKey methods are used to create KeyObjectinstances. KeyObject
objects are not to be created directly using the newkeyword.
Most applications should consider using the new KeyObject API instead of
passing keys as strings or Buffers due to improved security features.
KeyObject instances can be passed to other threads via postMessage().
The receiver obtains a cloned KeyObject, and the KeyObject does not need to
be listed in the transferList argument.
Constructors #
#KeyObject() Properties #
#asymmetricKeyDetails: AsymmetricKeyDetails | undefined This property exists only on asymmetric keys. Depending on the type of the key, this object contains information about the key. None of the information obtained through this property can be used to uniquely identify a key or to compromise the security of the key.
For RSA-PSS keys, if the key material contains a RSASSA-PSS-params sequence,
the hashAlgorithm, mgf1HashAlgorithm, and saltLength properties will be
set.
Other key details might be exposed via this API using additional attributes.
#asymmetricKeyType: KeyType | undefined For asymmetric keys, this property represents the type of the key. Supported key types are:
'rsa'(OID 1.2.840.113549.1.1.1)'rsa-pss'(OID 1.2.840.113549.1.1.10)'dsa'(OID 1.2.840.10040.4.1)'ec'(OID 1.2.840.10045.2.1)'x25519'(OID 1.3.101.110)'x448'(OID 1.3.101.111)'ed25519'(OID 1.3.101.112)'ed448'(OID 1.3.101.113)'dh'(OID 1.2.840.113549.1.3.1)
This property is undefined for unrecognized KeyObject types and symmetric
keys.
#symmetricKeySize: number | undefined For secret keys, this property represents the size of the key in bytes. This
property is undefined for asymmetric keys.
Depending on the type of this KeyObject, this property is either'secret' for secret (symmetric) keys, 'public' for public (asymmetric) keys
or 'private' for private (asymmetric) keys.
Methods #
Returns true or false depending on whether the keys have exactly the same
type, value, and parameters. This method is not constant time.
#export(options: KeyExportOptions<"pem">): string | Buffer For symmetric keys, the following encoding options can be used:
For public keys, the following encoding options can be used:
For private keys, the following encoding options can be used:
The result type depends on the selected encoding format, when PEM the result is a string, when DER it will be a buffer containing the data encoded as DER, when JWK it will be an object.
When JWK encoding format was selected, all other encoding options are ignored.
PKCS#1, SEC1, and PKCS#8 type keys can be encrypted by using a combination of
the cipher and format options. The PKCS#8 type can be used with anyformat to encrypt any key algorithm (RSA, EC, or DH) by specifying acipher. PKCS#1 and SEC1 can only be
encrypted by specifying a cipherwhen the PEM format is used. For maximum compatibility, use PKCS#8 for
encrypted private keys. Since PKCS#8 defines its own
encryption mechanism, PEM-level encryption is not supported when encrypting
a PKCS#8 key. See RFC 5208 for PKCS#8 encryption and RFC 1421 for
PKCS#1 and SEC1 encryption.
#export(options?: KeyExportOptions<"der">): Buffer #export(options?: JwkKeyExportOptions): JsonWebKey #toCryptoKey(): webcrypto.CryptoKey Converts a KeyObject instance to a CryptoKey.
Static Methods #
#from(key: webcrypto.CryptoKey): KeyObject Example: Converting a CryptoKey instance to a KeyObject:
const { KeyObject } = await import('node:crypto');
const { subtle } = globalThis.crypto;
const key = await subtle.generateKey({
name: 'HMAC',
hash: 'SHA-256',
length: 256,
}, true, ['sign', 'verify']);
const keyObject = KeyObject.from(key);
console.log(keyObject.symmetricKeySize);
// Prints: 32 (symmetric key size in bytes)
class Sign
Usage in Deno
import { Sign } from "node:crypto";
The sign and verify methods are not supported with non BinaryLike input.
The Sign class is a utility for generating signatures. It can be used in one
of two ways:
- As a writable
stream, where data to be signed is written and thesign.sign()method is used to generate and return the signature, or - Using the
sign.update()andsign.sign()methods to produce the signature.
The createSign method is used to create Sign instances. The
argument is the string name of the hash function to use. Sign objects are not
to be created directly using the new keyword.
Example: Using Sign and Verify objects as streams:
const {
generateKeyPairSync,
createSign,
createVerify,
} = await import('node:crypto');
const { privateKey, publicKey } = generateKeyPairSync('ec', {
namedCurve: 'sect239k1',
});
const sign = createSign('SHA256');
sign.write('some data to sign');
sign.end();
const signature = sign.sign(privateKey, 'hex');
const verify = createVerify('SHA256');
verify.write('some data to sign');
verify.end();
console.log(verify.verify(publicKey, signature, 'hex'));
// Prints: true
Example: Using the sign.update() and verify.update() methods:
const {
generateKeyPairSync,
createSign,
createVerify,
} = await import('node:crypto');
const { privateKey, publicKey } = generateKeyPairSync('rsa', {
modulusLength: 2048,
});
const sign = createSign('SHA256');
sign.update('some data to sign');
sign.end();
const signature = sign.sign(privateKey);
const verify = createVerify('SHA256');
verify.update('some data to sign');
verify.end();
console.log(verify.verify(publicKey, signature));
// Prints: true
Constructors #
#Sign() Methods #
Calculates the signature on all the data passed through using either sign.update() or sign.write().
If privateKey is not a KeyObject, this function behaves as if privateKey had been passed to createPrivateKey. If it is an
object, the following additional properties can be passed:
If outputEncoding is provided a string is returned; otherwise a Buffer is returned.
The Sign object can not be again used after sign.sign() method has been
called. Multiple calls to sign.sign() will result in an error being thrown.
#sign(privateKey: ,outputFormat: BinaryToTextEncoding,): string #update(data: BinaryLike): this Updates the Sign content with the given data, the encoding of which
is given in inputEncoding.
If encoding is not provided, and the data is a string, an
encoding of 'utf8' is enforced. If data is a Buffer, TypedArray, orDataView, then inputEncoding is ignored.
This can be called many times with new data as it is streamed.
class Verify
Usage in Deno
import { Verify } from "node:crypto";
The Verify class is a utility for verifying signatures. It can be used in one
of two ways:
- As a writable
streamwhere written data is used to validate against the supplied signature, or - Using the
verify.update()andverify.verify()methods to verify the signature.
The createVerify method is used to create Verify instances. Verify objects are not to be created directly using the new keyword.
See Sign for examples.
Constructors #
#Verify() Methods #
#update(data: BinaryLike): Verify Updates the Verify content with the given data, the encoding of which
is given in inputEncoding.
If inputEncoding is not provided, and the data is a string, an
encoding of 'utf8' is enforced. If data is a Buffer, TypedArray, or DataView, then inputEncoding is ignored.
This can be called many times with new data as it is streamed.
Verifies the provided data using the given object and signature.
If object is not a KeyObject, this function behaves as if object had been passed to createPublicKey. If it is an
object, the following additional properties can be passed:
The signature argument is the previously calculated signature for the data, in
the signatureEncoding.
If a signatureEncoding is specified, the signature is expected to be a
string; otherwise signature is expected to be a Buffer, TypedArray, or DataView.
The verify object can not be used again after verify.verify() has been
called. Multiple calls to verify.verify() will result in an error being
thrown.
Because public keys can be derived from private keys, a private key may be passed instead of a public key.
#verify(): boolean class X509Certificate
Usage in Deno
import { X509Certificate } from "node:crypto";
Encapsulates an X509 certificate and provides read-only access to its information.
const { X509Certificate } = await import('node:crypto');
const x509 = new X509Certificate('{... pem encoded cert ...}');
console.log(x509.subject);
Constructors #
#X509Certificate(buffer: BinaryLike) Properties #
#fingerprint: string The SHA-1 fingerprint of this certificate.
Because SHA-1 is cryptographically broken and because the security of SHA-1 is
significantly worse than that of algorithms that are commonly used to sign
certificates, consider using x509.fingerprint256 instead.
#fingerprint256: string The SHA-256 fingerprint of this certificate.
#fingerprint512: string The SHA-512 fingerprint of this certificate.
Because computing the SHA-256 fingerprint is usually faster and because it is
only half the size of the SHA-512 fingerprint, x509.fingerprint256 may be
a better choice. While SHA-512 presumably provides a higher level of security in
general, the security of SHA-256 matches that of most algorithms that are
commonly used to sign certificates.
#infoAccess: string | undefined A textual representation of the certificate's authority information access extension.
This is a line feed separated list of access descriptions. Each line begins with the access method and the kind of the access location, followed by a colon and the value associated with the access location.
After the prefix denoting the access method and the kind of the access location, the remainder of each line might be enclosed in quotes to indicate that the value is a JSON string literal. For backward compatibility, Node.js only uses JSON string literals within this property when necessary to avoid ambiguity. Third-party code should be prepared to handle both possible entry formats.
#issuerCertificate: X509Certificate | undefined The issuer certificate or undefined if the issuer certificate is not
available.
#serialNumber: string The serial number of this certificate.
Serial numbers are assigned by certificate authorities and do not uniquely
identify certificates. Consider using x509.fingerprint256 as a unique
identifier instead.
#subjectAltName: string | undefined The subject alternative name specified for this certificate.
This is a comma-separated list of subject alternative names. Each entry begins with a string identifying the kind of the subject alternative name followed by a colon and the value associated with the entry.
Earlier versions of Node.js incorrectly assumed that it is safe to split this
property at the two-character sequence ', ' (see CVE-2021-44532). However,
both malicious and legitimate certificates can contain subject alternative names
that include this sequence when represented as a string.
After the prefix denoting the type of the entry, the remainder of each entry might be enclosed in quotes to indicate that the value is a JSON string literal. For backward compatibility, Node.js only uses JSON string literals within this property when necessary to avoid ambiguity. Third-party code should be prepared to handle both possible entry formats.
#validFromDate: Date The date/time from which this certificate is valid, encapsulated in a Date object.
#validToDate: Date The date/time until which this certificate is valid, encapsulated in a Date object.
Methods #
#checkEmail(email: string,options?: Pick<X509CheckOptions, "subject">,): string | undefined Checks whether the certificate matches the given email address.
If the 'subject' option is undefined or set to 'default', the certificate
subject is only considered if the subject alternative name extension either does
not exist or does not contain any email addresses.
If the 'subject' option is set to 'always' and if the subject alternative
name extension either does not exist or does not contain a matching email
address, the certificate subject is considered.
If the 'subject' option is set to 'never', the certificate subject is never
considered, even if the certificate contains no subject alternative names.
#checkHost(name: string,options?: X509CheckOptions,): string | undefined Checks whether the certificate matches the given host name.
If the certificate matches the given host name, the matching subject name is
returned. The returned name might be an exact match (e.g., foo.example.com)
or it might contain wildcards (e.g., *.example.com). Because host name
comparisons are case-insensitive, the returned subject name might also differ
from the given name in capitalization.
If the 'subject' option is undefined or set to 'default', the certificate
subject is only considered if the subject alternative name extension either does
not exist or does not contain any DNS names. This behavior is consistent with RFC 2818 ("HTTP Over TLS").
If the 'subject' option is set to 'always' and if the subject alternative
name extension either does not exist or does not contain a matching DNS name,
the certificate subject is considered.
If the 'subject' option is set to 'never', the certificate subject is never
considered, even if the certificate contains no subject alternative names.
Checks whether the certificate matches the given IP address (IPv4 or IPv6).
Only RFC 5280 iPAddress subject alternative names are considered, and they
must match the given ip address exactly. Other subject alternative names as
well as the subject field of the certificate are ignored.
#checkIssued(otherCert: X509Certificate): boolean Checks whether this certificate was issued by the given otherCert.
#checkPrivateKey(privateKey: KeyObject): boolean Checks whether the public key for this certificate is consistent with the given private key.
There is no standard JSON encoding for X509 certificates. ThetoJSON() method returns a string containing the PEM encoded
certificate.
Returns information about this certificate using the legacy certificate object encoding.
class Hmac
Usage in Deno
import { Hmac } from "node:crypto";
Since v20.13.0 Calling Hmac class directly with Hmac() or new Hmac() is deprecated due to being internals, not intended for public use. Please use the createHmac method to create Hmac instances.
The Hmac class is a utility for creating cryptographic HMAC digests. It can
be used in one of two ways:
- As a
streamthat is both readable and writable, where data is written to produce a computed HMAC digest on the readable side, or - Using the
hmac.update()andhmac.digest()methods to produce the computed HMAC digest.
The createHmac method is used to create Hmac instances. Hmacobjects are not to be created directly using the new keyword.
Example: Using Hmac objects as streams:
const {
createHmac,
} = await import('node:crypto');
const hmac = createHmac('sha256', 'a secret');
hmac.on('readable', () => {
// Only one element is going to be produced by the
// hash stream.
const data = hmac.read();
if (data) {
console.log(data.toString('hex'));
// Prints:
// 7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
}
});
hmac.write('some data to hash');
hmac.end();
Example: Using Hmac and piped streams:
import { createReadStream } from 'node:fs';
import { stdout } from 'node:process';
const {
createHmac,
} = await import('node:crypto');
const hmac = createHmac('sha256', 'a secret');
const input = createReadStream('test.js');
input.pipe(hmac).pipe(stdout);
Example: Using the hmac.update() and hmac.digest() methods:
const {
createHmac,
} = await import('node:crypto');
const hmac = createHmac('sha256', 'a secret');
hmac.update('some data to hash');
console.log(hmac.digest('hex'));
// Prints:
// 7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
Constructors #
#Hmac() Methods #
Calculates the HMAC digest of all of the data passed using hmac.update().
If encoding is
provided a string is returned; otherwise a Buffer is returned;
The Hmac object can not be used again after hmac.digest() has been
called. Multiple calls to hmac.digest() will result in an error being thrown.
#digest(encoding: BinaryToTextEncoding): string #update(data: BinaryLike): Hmac Updates the Hmac content with the given data, the encoding of which
is given in inputEncoding.
If encoding is not provided, and the data is a string, an
encoding of 'utf8' is enforced. If data is a Buffer, TypedArray, orDataView, then inputEncoding is ignored.
This can be called many times with new data as it is streamed.
function checkPrime
Usage in Deno
import { checkPrime } from "node:crypto";
Overload 1
#checkPrime(value: LargeNumberLike,callback: (err: Error | null,result: boolean,) => void,): voidChecks the primality of the candidate.
Parameters #
#value: LargeNumberLike #callback: (err: Error | null,result: boolean,) => void Return Type #
void Overload 2
#checkPrime(value: LargeNumberLike,options: CheckPrimeOptions,callback: (err: Error | null,result: boolean,) => void,): voidParameters #
#value: LargeNumberLike #options: CheckPrimeOptions #callback: (err: Error | null,result: boolean,) => void Return Type #
void function checkPrimeSync
Usage in Deno
import { checkPrimeSync } from "node:crypto";
#checkPrimeSync(candidate: LargeNumberLike,options?: CheckPrimeOptions,): booleanChecks the primality of the candidate.
Parameters #
#candidate: LargeNumberLike A possible prime encoded as a sequence of big endian octets of arbitrary length.
#options: CheckPrimeOptions Return Type #
boolean true if the candidate is a prime with an error probability less than 0.25 ** options.checks.
function createCipheriv
Usage in Deno
import { createCipheriv } from "node:crypto";
Overload 1
#createCipheriv(): CipherCCMCreates and returns a Cipher object, with the given algorithm, key and
initialization vector (iv).
The options argument controls stream behavior and is optional except when a
cipher in CCM or OCB mode (e.g. 'aes-128-ccm') is used. In that case, theauthTagLength option is required and specifies the length of the
authentication tag in bytes, see CCM mode. In GCM mode, the authTagLengthoption is not required but can be used to set the length of the authentication
tag that will be returned by getAuthTag() and defaults to 16 bytes.
For chacha20-poly1305, the authTagLength option defaults to 16 bytes.
The algorithm is dependent on OpenSSL, examples are 'aes192', etc. On
recent OpenSSL releases, openssl list -cipher-algorithms will
display the available cipher algorithms.
The key is the raw key used by the algorithm and iv is an initialization vector. Both arguments must be 'utf8' encoded
strings,Buffers, TypedArray, or DataViews. The key may optionally be
a KeyObject of type secret. If the cipher does not need
an initialization vector, iv may be null.
When passing strings for key or iv, please consider caveats when using strings as inputs to cryptographic APIs.
Initialization vectors should be unpredictable and unique; ideally, they will be cryptographically random. They do not have to be secret: IVs are typically just added to ciphertext messages unencrypted. It may sound contradictory that something has to be unpredictable and unique, but does not have to be secret; remember that an attacker must not be able to predict ahead of time what a given IV will be.
Parameters #
Return Type #
Overload 2
Overload 3
Overload 4
#createCipheriv(algorithm: CipherChaCha20Poly1305Types,key: CipherKey,iv: BinaryLike,options?: CipherChaCha20Poly1305Options,): CipherChaCha20Poly1305Parameters #
#algorithm: CipherChaCha20Poly1305Types #iv: BinaryLike #options: CipherChaCha20Poly1305Options Return Type #
Overload 5
function createDecipheriv
Usage in Deno
import { createDecipheriv } from "node:crypto";
Overload 1
#createDecipheriv(): DecipherCCMCreates and returns a Decipher object that uses the given algorithm, key and initialization vector (iv).
The options argument controls stream behavior and is optional except when a
cipher in CCM or OCB mode (e.g. 'aes-128-ccm') is used. In that case, the authTagLength option is required and specifies the length of the
authentication tag in bytes, see CCM mode. In GCM mode, the authTagLength option is not required but can be used to restrict accepted authentication tags
to those with the specified length.
For chacha20-poly1305, the authTagLength option defaults to 16 bytes.
The algorithm is dependent on OpenSSL, examples are 'aes192', etc. On
recent OpenSSL releases, openssl list -cipher-algorithms will
display the available cipher algorithms.
The key is the raw key used by the algorithm and iv is an initialization vector. Both arguments must be 'utf8' encoded
strings,Buffers, TypedArray, or DataViews. The key may optionally be
a KeyObject of type secret. If the cipher does not need
an initialization vector, iv may be null.
When passing strings for key or iv, please consider caveats when using strings as inputs to cryptographic APIs.
Initialization vectors should be unpredictable and unique; ideally, they will be cryptographically random. They do not have to be secret: IVs are typically just added to ciphertext messages unencrypted. It may sound contradictory that something has to be unpredictable and unique, but does not have to be secret; remember that an attacker must not be able to predict ahead of time what a given IV will be.
Parameters #
Return Type #
Overload 2
#createDecipheriv(): DecipherOCBOverload 3
#createDecipheriv(): DecipherGCMOverload 4
#createDecipheriv(algorithm: CipherChaCha20Poly1305Types,key: CipherKey,iv: BinaryLike,options?: CipherChaCha20Poly1305Options,): DecipherChaCha20Poly1305Parameters #
#algorithm: CipherChaCha20Poly1305Types #iv: BinaryLike #options: CipherChaCha20Poly1305Options Return Type #
Overload 5
function createDiffieHellman
Usage in Deno
import { createDiffieHellman } from "node:crypto";
Overload 1
#createDiffieHellman(primeLength: number,generator?: number,): DiffieHellmanCreates a DiffieHellman key exchange object using the supplied prime and an
optional specific generator.
The generator argument can be a number, string, or Buffer. If generator is not specified, the value 2 is used.
If primeEncoding is specified, prime is expected to be a string; otherwise
a Buffer, TypedArray, or DataView is expected.
If generatorEncoding is specified, generator is expected to be a string;
otherwise a number, Buffer, TypedArray, or DataView is expected.
Parameters #
Return Type #
Overload 2
#createDiffieHellman(prime: ArrayBuffer | ArrayBufferView,generator?: number
| ArrayBuffer
| ArrayBufferView,): DiffieHellmanOverload 3
#createDiffieHellman(): DiffieHellmanOverload 4
#createDiffieHellman(prime: string,primeEncoding: BinaryToTextEncoding,generator?: number
| ArrayBuffer
| ArrayBufferView,): DiffieHellmanOverload 5
#createDiffieHellman(prime: string,primeEncoding: BinaryToTextEncoding,generator: string,generatorEncoding: BinaryToTextEncoding,): DiffieHellmanParameters #
#prime: string #primeEncoding: BinaryToTextEncoding #generator: string #generatorEncoding: BinaryToTextEncoding Return Type #
function createDiffieHellmanGroup
Usage in Deno
import { createDiffieHellmanGroup } from "node:crypto";
#createDiffieHellmanGroup(name: string): DiffieHellmanGroupfunction createECDH
Usage in Deno
import { createECDH } from "node:crypto";
#createECDH(curveName: string): ECDHCreates an Elliptic Curve Diffie-Hellman (ECDH) key exchange object using a
predefined curve specified by the curveName string. Use getCurves to obtain a list of available curve names. On recent
OpenSSL releases, openssl ecparam -list_curves will also display the name
and description of each available elliptic curve.
Parameters #
#curveName: string Return Type #
function createHash
Usage in Deno
import { createHash } from "node:crypto";
#createHash(algorithm: string,options?: HashOptions,): HashCreates and returns a Hash object that can be used to generate hash digests
using the given algorithm. Optional options argument controls stream
behavior. For XOF hash functions such as 'shake256', the outputLength option
can be used to specify the desired output length in bytes.
The algorithm is dependent on the available algorithms supported by the
version of OpenSSL on the platform. Examples are 'sha256', 'sha512', etc.
On recent releases of OpenSSL, openssl list -digest-algorithms will
display the available digest algorithms.
Example: generating the sha256 sum of a file
import {
createReadStream,
} from 'node:fs';
import { argv } from 'node:process';
const {
createHash,
} = await import('node:crypto');
const filename = argv[2];
const hash = createHash('sha256');
const input = createReadStream(filename);
input.on('readable', () => {
// Only one element is going to be produced by the
// hash stream.
const data = input.read();
if (data)
hash.update(data);
else {
console.log(`${hash.digest('hex')} ${filename}`);
}
});
Parameters #
#algorithm: string #options: HashOptions stream.transform options
Return Type #
function createHmac
Usage in Deno
import { createHmac } from "node:crypto";
#createHmac(): HmacCreates and returns an Hmac object that uses the given algorithm and key.
Optional options argument controls stream behavior.
The algorithm is dependent on the available algorithms supported by the
version of OpenSSL on the platform. Examples are 'sha256', 'sha512', etc.
On recent releases of OpenSSL, openssl list -digest-algorithms will
display the available digest algorithms.
The key is the HMAC key used to generate the cryptographic HMAC hash. If it is
a KeyObject, its type must be secret. If it is a string, please consider caveats when using strings as inputs to cryptographic APIs. If it was
obtained from a cryptographically secure source of entropy, such as randomBytes or generateKey, its length should not
exceed the block size of algorithm (e.g., 512 bits for SHA-256).
Example: generating the sha256 HMAC of a file
import {
createReadStream,
} from 'node:fs';
import { argv } from 'node:process';
const {
createHmac,
} = await import('node:crypto');
const filename = argv[2];
const hmac = createHmac('sha256', 'a secret');
const input = createReadStream(filename);
input.on('readable', () => {
// Only one element is going to be produced by the
// hash stream.
const data = input.read();
if (data)
hmac.update(data);
else {
console.log(`${hmac.digest('hex')} ${filename}`);
}
});
Parameters #
#algorithm: string #key: BinaryLike | KeyObject #options: stream.TransformOptions stream.transform options
Return Type #
function createPrivateKey
Usage in Deno
import { createPrivateKey } from "node:crypto";
#createPrivateKey(key: ): KeyObjectCreates and returns a new key object containing a private key. If key is a
string or Buffer, format is assumed to be 'pem'; otherwise, key must be an object with the properties described above.
If the private key is encrypted, a passphrase must be specified. The length
of the passphrase is limited to 1024 bytes.
Parameters #
#key: Return Type #
function createPublicKey
Usage in Deno
import { createPublicKey } from "node:crypto";
#createPublicKey(key: ): KeyObjectCreates and returns a new key object containing a public key. If key is a
string or Buffer, format is assumed to be 'pem'; if key is a KeyObject with type 'private', the public key is derived from the given private key;
otherwise, key must be an object with the properties described above.
If the format is 'pem', the 'key' may also be an X.509 certificate.
Because public keys can be derived from private keys, a private key may be
passed instead of a public key. In that case, this function behaves as if createPrivateKey had been called, except that the type of the
returned KeyObject will be 'public' and that the private key cannot be
extracted from the returned KeyObject. Similarly, if a KeyObject with type 'private' is given, a new KeyObject with type 'public' will be returned
and it will be impossible to extract the private key from the returned object.
Parameters #
#key: Return Type #
function createSecretKey
Usage in Deno
import { createSecretKey } from "node:crypto";
function createSign
Usage in Deno
import { createSign } from "node:crypto";
#createSign(algorithm: string,options?: stream.WritableOptions,): SignCreates and returns a Sign object that uses the given algorithm. Use getHashes to obtain the names of the available digest algorithms.
Optional options argument controls the stream.Writable behavior.
In some cases, a Sign instance can be created using the name of a signature
algorithm, such as 'RSA-SHA256', instead of a digest algorithm. This will use
the corresponding digest algorithm. This does not work for all signature
algorithms, such as 'ecdsa-with-SHA256', so it is best to always use digest
algorithm names.
Parameters #
Return Type #
function createVerify
Usage in Deno
import { createVerify } from "node:crypto";
#createVerify(algorithm: string,options?: stream.WritableOptions,): VerifyCreates and returns a Verify object that uses the given algorithm.
Use getHashes to obtain an array of names of the available
signing algorithms. Optional options argument controls the stream.Writable behavior.
In some cases, a Verify instance can be created using the name of a signature
algorithm, such as 'RSA-SHA256', instead of a digest algorithm. This will use
the corresponding digest algorithm. This does not work for all signature
algorithms, such as 'ecdsa-with-SHA256', so it is best to always use digest
algorithm names.
Parameters #
Return Type #
function diffieHellman
Usage in Deno
import { diffieHellman } from "node:crypto";
#diffieHellman(options: { privateKey: KeyObject; publicKey: KeyObject; }): Bufferfunction generateKey
Usage in Deno
import { generateKey } from "node:crypto";
#generateKey(type: "hmac" | "aes",options: { length: number; },callback: (err: Error | null,key: KeyObject,) => void,): voidAsynchronously generates a new random secret key of the given length. The type will determine which validations will be performed on the length.
const {
generateKey,
} = await import('node:crypto');
generateKey('hmac', { length: 512 }, (err, key) => {
if (err) throw err;
console.log(key.export().toString('hex')); // 46e..........620
});
The size of a generated HMAC key should not exceed the block size of the underlying hash function. See createHmac for more information.
Parameters #
Return Type #
void function generateKeyPair
Usage in Deno
import { generateKeyPair } from "node:crypto";
Overload 1
#generateKeyPair(type: "rsa",options: RSAKeyPairOptions<"pem", "pem">,callback: (err: Error | null,publicKey: string,privateKey: string,) => void,): void
The x448 option is not supported.
Generates a new asymmetric key pair of the given type. RSA, RSA-PSS, DSA, EC,
Ed25519, Ed448, X25519, X448, and DH are currently supported.
If a publicKeyEncoding or privateKeyEncoding was specified, this function
behaves as if keyObject.export() had been called on its result. Otherwise,
the respective part of the key is returned as a KeyObject.
It is recommended to encode public keys as 'spki' and private keys as 'pkcs8' with encryption for long-term storage:
const {
generateKeyPair,
} = await import('node:crypto');
generateKeyPair('rsa', {
modulusLength: 4096,
publicKeyEncoding: {
type: 'spki',
format: 'pem',
},
privateKeyEncoding: {
type: 'pkcs8',
format: 'pem',
cipher: 'aes-256-cbc',
passphrase: 'top secret',
},
}, (err, publicKey, privateKey) => {
// Handle errors and use the generated key pair.
});
On completion, callback will be called with err set to undefined and publicKey / privateKey representing the generated key pair.
If this method is invoked as its util.promisify() ed version, it returns
a Promise for an Object with publicKey and privateKey properties.
Parameters #
#type: "rsa" Must be 'rsa', 'rsa-pss', 'dsa', 'ec', 'ed25519', 'ed448', 'x25519', 'x448', or 'dh'.
#options: RSAKeyPairOptions<"pem", "pem"> #callback: (err: Error | null,publicKey: string,privateKey: string,) => void Return Type #
void Overload 2
#generateKeyPair(type: "rsa",options: RSAKeyPairOptions<"pem", "der">,callback: (err: Error | null,publicKey: string,privateKey: Buffer,) => void,): voidOverload 3
#generateKeyPair(type: "rsa",options: RSAKeyPairOptions<"der", "pem">,callback: (err: Error | null,publicKey: Buffer,privateKey: string,) => void,): voidOverload 4
#generateKeyPair(type: "rsa",options: RSAKeyPairOptions<"der", "der">,callback: (err: Error | null,publicKey: Buffer,privateKey: Buffer,) => void,): voidOverload 5
#generateKeyPair(type: "rsa",options: RSAKeyPairKeyObjectOptions,): voidOverload 6
#generateKeyPair(type: "rsa-pss",options: RSAPSSKeyPairOptions<"pem", "pem">,callback: (err: Error | null,publicKey: string,privateKey: string,) => void,): voidOverload 7
#generateKeyPair(type: "rsa-pss",options: RSAPSSKeyPairOptions<"pem", "der">,callback: (err: Error | null,publicKey: string,privateKey: Buffer,) => void,): voidOverload 8
#generateKeyPair(type: "rsa-pss",options: RSAPSSKeyPairOptions<"der", "pem">,callback: (err: Error | null,publicKey: Buffer,privateKey: string,) => void,): voidOverload 9
#generateKeyPair(type: "rsa-pss",options: RSAPSSKeyPairOptions<"der", "der">,callback: (err: Error | null,publicKey: Buffer,privateKey: Buffer,) => void,): voidOverload 10
#generateKeyPair(type: "rsa-pss",options: RSAPSSKeyPairKeyObjectOptions,): voidOverload 11
#generateKeyPair(type: "dsa",options: DSAKeyPairOptions<"pem", "pem">,callback: (err: Error | null,publicKey: string,privateKey: string,) => void,): voidOverload 12
#generateKeyPair(type: "dsa",options: DSAKeyPairOptions<"pem", "der">,callback: (err: Error | null,publicKey: string,privateKey: Buffer,) => void,): voidOverload 13
#generateKeyPair(type: "dsa",options: DSAKeyPairOptions<"der", "pem">,callback: (err: Error | null,publicKey: Buffer,privateKey: string,) => void,): voidOverload 14
#generateKeyPair(type: "dsa",options: DSAKeyPairOptions<"der", "der">,callback: (err: Error | null,publicKey: Buffer,privateKey: Buffer,) => void,): voidOverload 15
#generateKeyPair(type: "dsa",options: DSAKeyPairKeyObjectOptions,): voidOverload 16
#generateKeyPair(type: "ec",options: ECKeyPairOptions<"pem", "pem">,callback: (err: Error | null,publicKey: string,privateKey: string,) => void,): voidOverload 17
#generateKeyPair(type: "ec",options: ECKeyPairOptions<"pem", "der">,callback: (err: Error | null,publicKey: string,privateKey: Buffer,) => void,): voidOverload 18
#generateKeyPair(type: "ec",options: ECKeyPairOptions<"der", "pem">,callback: (err: Error | null,publicKey: Buffer,privateKey: string,) => void,): voidOverload 19
#generateKeyPair(type: "ec",options: ECKeyPairOptions<"der", "der">,callback: (err: Error | null,publicKey: Buffer,privateKey: Buffer,) => void,): voidOverload 20
#generateKeyPair(type: "ec",options: ECKeyPairKeyObjectOptions,): voidOverload 21
#generateKeyPair(type: "ed25519",options: ED25519KeyPairOptions<"pem", "pem">,callback: (err: Error | null,publicKey: string,privateKey: string,) => void,): voidOverload 22
#generateKeyPair(type: "ed25519",options: ED25519KeyPairOptions<"pem", "der">,callback: (err: Error | null,publicKey: string,privateKey: Buffer,) => void,): voidOverload 23
#generateKeyPair(type: "ed25519",options: ED25519KeyPairOptions<"der", "pem">,callback: (err: Error | null,publicKey: Buffer,privateKey: string,) => void,): voidOverload 24
#generateKeyPair(type: "ed25519",options: ED25519KeyPairOptions<"der", "der">,callback: (err: Error | null,publicKey: Buffer,privateKey: Buffer,) => void,): voidOverload 25
#generateKeyPair(type: "ed25519",options: ED25519KeyPairKeyObjectOptions | undefined,): voidOverload 26
#generateKeyPair(type: "ed448",options: ED448KeyPairOptions<"pem", "pem">,callback: (err: Error | null,publicKey: string,privateKey: string,) => void,): voidOverload 27
#generateKeyPair(type: "ed448",options: ED448KeyPairOptions<"pem", "der">,callback: (err: Error | null,publicKey: string,privateKey: Buffer,) => void,): voidOverload 28
#generateKeyPair(type: "ed448",options: ED448KeyPairOptions<"der", "pem">,callback: (err: Error | null,publicKey: Buffer,privateKey: string,) => void,): voidOverload 29
#generateKeyPair(type: "ed448",options: ED448KeyPairOptions<"der", "der">,callback: (err: Error | null,publicKey: Buffer,privateKey: Buffer,) => void,): voidOverload 30
#generateKeyPair(type: "ed448",options: ED448KeyPairKeyObjectOptions | undefined,): voidOverload 31
#generateKeyPair(type: "x25519",options: X25519KeyPairOptions<"pem", "pem">,callback: (err: Error | null,publicKey: string,privateKey: string,) => void,): voidOverload 32
#generateKeyPair(type: "x25519",options: X25519KeyPairOptions<"pem", "der">,callback: (err: Error | null,publicKey: string,privateKey: Buffer,) => void,): voidOverload 33
#generateKeyPair(type: "x25519",options: X25519KeyPairOptions<"der", "pem">,callback: (err: Error | null,publicKey: Buffer,privateKey: string,) => void,): voidOverload 34
#generateKeyPair(type: "x25519",options: X25519KeyPairOptions<"der", "der">,callback: (err: Error | null,publicKey: Buffer,privateKey: Buffer,) => void,): voidOverload 35
#generateKeyPair(type: "x25519",options: X25519KeyPairKeyObjectOptions | undefined,): voidOverload 36
#generateKeyPair(type: "x448",options: X448KeyPairOptions<"pem", "pem">,callback: (err: Error | null,publicKey: string,privateKey: string,) => void,): voidOverload 37
#generateKeyPair(type: "x448",options: X448KeyPairOptions<"pem", "der">,callback: (err: Error | null,publicKey: string,privateKey: Buffer,) => void,): voidOverload 38
#generateKeyPair(type: "x448",options: X448KeyPairOptions<"der", "pem">,callback: (err: Error | null,publicKey: Buffer,privateKey: string,) => void,): voidOverload 39
#generateKeyPair(type: "x448",options: X448KeyPairOptions<"der", "der">,callback: (err: Error | null,publicKey: Buffer,privateKey: Buffer,) => void,): voidOverload 40
#generateKeyPair(type: "x448",options: X448KeyPairKeyObjectOptions | undefined,): voidfunction generateKeyPairSync
Usage in Deno
import { generateKeyPairSync } from "node:crypto";
Overload 1
#generateKeyPairSync(type: "rsa",options: RSAKeyPairOptions<"pem", "pem">,): KeyPairSyncResult<string, string>Generates a new asymmetric key pair of the given type. RSA, RSA-PSS, DSA, EC,
Ed25519, Ed448, X25519, X448, and DH are currently supported.
If a publicKeyEncoding or privateKeyEncoding was specified, this function
behaves as if keyObject.export() had been called on its result. Otherwise,
the respective part of the key is returned as a KeyObject.
When encoding public keys, it is recommended to use 'spki'. When encoding
private keys, it is recommended to use 'pkcs8' with a strong passphrase,
and to keep the passphrase confidential.
const {
generateKeyPairSync,
} = await import('node:crypto');
const {
publicKey,
privateKey,
} = generateKeyPairSync('rsa', {
modulusLength: 4096,
publicKeyEncoding: {
type: 'spki',
format: 'pem',
},
privateKeyEncoding: {
type: 'pkcs8',
format: 'pem',
cipher: 'aes-256-cbc',
passphrase: 'top secret',
},
});
The return value { publicKey, privateKey } represents the generated key pair.
When PEM encoding was selected, the respective key will be a string, otherwise
it will be a buffer containing the data encoded as DER.
Parameters #
#type: "rsa" Must be 'rsa', 'rsa-pss', 'dsa', 'ec', 'ed25519', 'ed448', 'x25519', 'x448', or 'dh'.
#options: RSAKeyPairOptions<"pem", "pem"> Return Type #
KeyPairSyncResult<string, string> Overload 2
#generateKeyPairSync(type: "rsa",options: RSAKeyPairOptions<"pem", "der">,): KeyPairSyncResult<string, Buffer>Parameters #
#type: "rsa" #options: RSAKeyPairOptions<"pem", "der"> Return Type #
KeyPairSyncResult<string, Buffer> Overload 3
#generateKeyPairSync(type: "rsa",options: RSAKeyPairOptions<"der", "pem">,): KeyPairSyncResult<Buffer, string>Parameters #
#type: "rsa" #options: RSAKeyPairOptions<"der", "pem"> Return Type #
KeyPairSyncResult<Buffer, string> Overload 4
#generateKeyPairSync(type: "rsa",options: RSAKeyPairOptions<"der", "der">,): KeyPairSyncResult<Buffer, Buffer>Parameters #
#type: "rsa" #options: RSAKeyPairOptions<"der", "der"> Return Type #
KeyPairSyncResult<Buffer, Buffer> Overload 5
#generateKeyPairSync(type: "rsa",options: RSAKeyPairKeyObjectOptions,): KeyPairKeyObjectResultParameters #
#type: "rsa" #options: RSAKeyPairKeyObjectOptions Return Type #
Overload 6
#generateKeyPairSync(type: "rsa-pss",options: RSAPSSKeyPairOptions<"pem", "pem">,): KeyPairSyncResult<string, string>Parameters #
#type: "rsa-pss" #options: RSAPSSKeyPairOptions<"pem", "pem"> Return Type #
KeyPairSyncResult<string, string> Overload 7
#generateKeyPairSync(type: "rsa-pss",options: RSAPSSKeyPairOptions<"pem", "der">,): KeyPairSyncResult<string, Buffer>Parameters #
#type: "rsa-pss" #options: RSAPSSKeyPairOptions<"pem", "der"> Return Type #
KeyPairSyncResult<string, Buffer> Overload 8
#generateKeyPairSync(type: "rsa-pss",options: RSAPSSKeyPairOptions<"der", "pem">,): KeyPairSyncResult<Buffer, string>Parameters #
#type: "rsa-pss" #options: RSAPSSKeyPairOptions<"der", "pem"> Return Type #
KeyPairSyncResult<Buffer, string> Overload 9
#generateKeyPairSync(type: "rsa-pss",options: RSAPSSKeyPairOptions<"der", "der">,): KeyPairSyncResult<Buffer, Buffer>Parameters #
#type: "rsa-pss" #options: RSAPSSKeyPairOptions<"der", "der"> Return Type #
KeyPairSyncResult<Buffer, Buffer> Overload 10
#generateKeyPairSync(type: "rsa-pss",options: RSAPSSKeyPairKeyObjectOptions,): KeyPairKeyObjectResultParameters #
#type: "rsa-pss" #options: RSAPSSKeyPairKeyObjectOptions Return Type #
Overload 11
#generateKeyPairSync(type: "dsa",options: DSAKeyPairOptions<"pem", "pem">,): KeyPairSyncResult<string, string>Parameters #
#type: "dsa" #options: DSAKeyPairOptions<"pem", "pem"> Return Type #
KeyPairSyncResult<string, string> Overload 12
#generateKeyPairSync(type: "dsa",options: DSAKeyPairOptions<"pem", "der">,): KeyPairSyncResult<string, Buffer>Parameters #
#type: "dsa" #options: DSAKeyPairOptions<"pem", "der"> Return Type #
KeyPairSyncResult<string, Buffer> Overload 13
#generateKeyPairSync(type: "dsa",options: DSAKeyPairOptions<"der", "pem">,): KeyPairSyncResult<Buffer, string>Parameters #
#type: "dsa" #options: DSAKeyPairOptions<"der", "pem"> Return Type #
KeyPairSyncResult<Buffer, string> Overload 14
#generateKeyPairSync(type: "dsa",options: DSAKeyPairOptions<"der", "der">,): KeyPairSyncResult<Buffer, Buffer>Parameters #
#type: "dsa" #options: DSAKeyPairOptions<"der", "der"> Return Type #
KeyPairSyncResult<Buffer, Buffer> Overload 15
#generateKeyPairSync(type: "dsa",options: DSAKeyPairKeyObjectOptions,): KeyPairKeyObjectResultParameters #
#type: "dsa" #options: DSAKeyPairKeyObjectOptions Return Type #
Overload 16
#generateKeyPairSync(type: "ec",options: ECKeyPairOptions<"pem", "pem">,): KeyPairSyncResult<string, string>Parameters #
#type: "ec" #options: ECKeyPairOptions<"pem", "pem"> Return Type #
KeyPairSyncResult<string, string> Overload 17
#generateKeyPairSync(type: "ec",options: ECKeyPairOptions<"pem", "der">,): KeyPairSyncResult<string, Buffer>Parameters #
#type: "ec" #options: ECKeyPairOptions<"pem", "der"> Return Type #
KeyPairSyncResult<string, Buffer> Overload 18
#generateKeyPairSync(type: "ec",options: ECKeyPairOptions<"der", "pem">,): KeyPairSyncResult<Buffer, string>Parameters #
#type: "ec" #options: ECKeyPairOptions<"der", "pem"> Return Type #
KeyPairSyncResult<Buffer, string> Overload 19
#generateKeyPairSync(type: "ec",options: ECKeyPairOptions<"der", "der">,): KeyPairSyncResult<Buffer, Buffer>Parameters #
#type: "ec" #options: ECKeyPairOptions<"der", "der"> Return Type #
KeyPairSyncResult<Buffer, Buffer> Overload 20
#generateKeyPairSync(type: "ec",options: ECKeyPairKeyObjectOptions,): KeyPairKeyObjectResultParameters #
#type: "ec" #options: ECKeyPairKeyObjectOptions Return Type #
Overload 21
#generateKeyPairSync(type: "ed25519",options: ED25519KeyPairOptions<"pem", "pem">,): KeyPairSyncResult<string, string>Parameters #
#type: "ed25519" #options: ED25519KeyPairOptions<"pem", "pem"> Return Type #
KeyPairSyncResult<string, string> Overload 22
#generateKeyPairSync(type: "ed25519",options: ED25519KeyPairOptions<"pem", "der">,): KeyPairSyncResult<string, Buffer>Parameters #
#type: "ed25519" #options: ED25519KeyPairOptions<"pem", "der"> Return Type #
KeyPairSyncResult<string, Buffer> Overload 23
#generateKeyPairSync(type: "ed25519",options: ED25519KeyPairOptions<"der", "pem">,): KeyPairSyncResult<Buffer, string>Parameters #
#type: "ed25519" #options: ED25519KeyPairOptions<"der", "pem"> Return Type #
KeyPairSyncResult<Buffer, string> Overload 24
#generateKeyPairSync(type: "ed25519",options: ED25519KeyPairOptions<"der", "der">,): KeyPairSyncResult<Buffer, Buffer>Parameters #
#type: "ed25519" #options: ED25519KeyPairOptions<"der", "der"> Return Type #
KeyPairSyncResult<Buffer, Buffer> Overload 25
#generateKeyPairSync(type: "ed25519",options?: ED25519KeyPairKeyObjectOptions,): KeyPairKeyObjectResultParameters #
#type: "ed25519" #options: ED25519KeyPairKeyObjectOptions Return Type #
Overload 26
#generateKeyPairSync(type: "ed448",options: ED448KeyPairOptions<"pem", "pem">,): KeyPairSyncResult<string, string>Parameters #
#type: "ed448" #options: ED448KeyPairOptions<"pem", "pem"> Return Type #
KeyPairSyncResult<string, string> Overload 27
#generateKeyPairSync(type: "ed448",options: ED448KeyPairOptions<"pem", "der">,): KeyPairSyncResult<string, Buffer>Parameters #
#type: "ed448" #options: ED448KeyPairOptions<"pem", "der"> Return Type #
KeyPairSyncResult<string, Buffer> Overload 28
#generateKeyPairSync(type: "ed448",options: ED448KeyPairOptions<"der", "pem">,): KeyPairSyncResult<Buffer, string>Parameters #
#type: "ed448" #options: ED448KeyPairOptions<"der", "pem"> Return Type #
KeyPairSyncResult<Buffer, string> Overload 29
#generateKeyPairSync(type: "ed448",options: ED448KeyPairOptions<"der", "der">,): KeyPairSyncResult<Buffer, Buffer>Parameters #
#type: "ed448" #options: ED448KeyPairOptions<"der", "der"> Return Type #
KeyPairSyncResult<Buffer, Buffer> Overload 30
#generateKeyPairSync(type: "ed448",options?: ED448KeyPairKeyObjectOptions,): KeyPairKeyObjectResultParameters #
#type: "ed448" #options: ED448KeyPairKeyObjectOptions Return Type #
Overload 31
#generateKeyPairSync(type: "x25519",options: X25519KeyPairOptions<"pem", "pem">,): KeyPairSyncResult<string, string>Parameters #
#type: "x25519" #options: X25519KeyPairOptions<"pem", "pem"> Return Type #
KeyPairSyncResult<string, string> Overload 32
#generateKeyPairSync(type: "x25519",options: X25519KeyPairOptions<"pem", "der">,): KeyPairSyncResult<string, Buffer>Parameters #
#type: "x25519" #options: X25519KeyPairOptions<"pem", "der"> Return Type #
KeyPairSyncResult<string, Buffer> Overload 33
#generateKeyPairSync(type: "x25519",options: X25519KeyPairOptions<"der", "pem">,): KeyPairSyncResult<Buffer, string>Parameters #
#type: "x25519" #options: X25519KeyPairOptions<"der", "pem"> Return Type #
KeyPairSyncResult<Buffer, string> Overload 34
#generateKeyPairSync(type: "x25519",options: X25519KeyPairOptions<"der", "der">,): KeyPairSyncResult<Buffer, Buffer>Parameters #
#type: "x25519" #options: X25519KeyPairOptions<"der", "der"> Return Type #
KeyPairSyncResult<Buffer, Buffer> Overload 35
#generateKeyPairSync(type: "x25519",options?: X25519KeyPairKeyObjectOptions,): KeyPairKeyObjectResultParameters #
#type: "x25519" #options: X25519KeyPairKeyObjectOptions Return Type #
Overload 36
#generateKeyPairSync(type: "x448",options: X448KeyPairOptions<"pem", "pem">,): KeyPairSyncResult<string, string>Parameters #
#type: "x448" #options: X448KeyPairOptions<"pem", "pem"> Return Type #
KeyPairSyncResult<string, string> Overload 37
#generateKeyPairSync(type: "x448",options: X448KeyPairOptions<"pem", "der">,): KeyPairSyncResult<string, Buffer>Parameters #
#type: "x448" #options: X448KeyPairOptions<"pem", "der"> Return Type #
KeyPairSyncResult<string, Buffer> Overload 38
#generateKeyPairSync(type: "x448",options: X448KeyPairOptions<"der", "pem">,): KeyPairSyncResult<Buffer, string>Parameters #
#type: "x448" #options: X448KeyPairOptions<"der", "pem"> Return Type #
KeyPairSyncResult<Buffer, string> Overload 39
#generateKeyPairSync(type: "x448",options: X448KeyPairOptions<"der", "der">,): KeyPairSyncResult<Buffer, Buffer>Parameters #
#type: "x448" #options: X448KeyPairOptions<"der", "der"> Return Type #
KeyPairSyncResult<Buffer, Buffer> Overload 40
#generateKeyPairSync(type: "x448",options?: X448KeyPairKeyObjectOptions,): KeyPairKeyObjectResultParameters #
#type: "x448" #options: X448KeyPairKeyObjectOptions Return Type #
function generateKeySync
Usage in Deno
import { generateKeySync } from "node:crypto";
#generateKeySync(type: "hmac" | "aes",options: { length: number; },): KeyObjectSynchronously generates a new random secret key of the given length. The type will determine which validations will be performed on the length.
const {
generateKeySync,
} = await import('node:crypto');
const key = generateKeySync('hmac', { length: 512 });
console.log(key.export().toString('hex')); // e89..........41e
The size of a generated HMAC key should not exceed the block size of the underlying hash function. See createHmac for more information.
Parameters #
Return Type #
function generatePrime
Usage in Deno
import { generatePrime } from "node:crypto";
Overload 1
#generatePrime(size: number,callback: (err: Error | null,prime: ArrayBuffer,) => void,): void
The safe, add and rem option is not supported.
Generates a pseudorandom prime of size bits.
If options.safe is true, the prime will be a safe prime -- that is, (prime - 1) / 2 will also be a prime.
The options.add and options.rem parameters can be used to enforce additional
requirements, e.g., for Diffie-Hellman:
- If
options.addandoptions.remare both set, the prime will satisfy the condition thatprime % add = rem. - If only
options.addis set andoptions.safeis nottrue, the prime will satisfy the condition thatprime % add = 1. - If only
options.addis set andoptions.safeis set totrue, the prime will instead satisfy the condition thatprime % add = 3. This is necessary becauseprime % add = 1foroptions.add > 2would contradict the condition enforced byoptions.safe. options.remis ignored ifoptions.addis not given.
Both options.add and options.rem must be encoded as big-endian sequences
if given as an ArrayBuffer, SharedArrayBuffer, TypedArray, Buffer, or DataView.
By default, the prime is encoded as a big-endian sequence of octets
in an ArrayBuffer. If the bigint option is true, then a
bigint is provided.
Parameters #
Return Type #
void Overload 2
#generatePrime(size: number,options: GeneratePrimeOptionsBigInt,callback: (err: Error | null,prime: bigint,) => void,): voidOverload 3
#generatePrime(size: number,options: GeneratePrimeOptionsArrayBuffer,callback: (err: Error | null,prime: ArrayBuffer,) => void,): voidOverload 4
#generatePrime(size: number,options: GeneratePrimeOptions,callback: (err: Error | null,prime: ArrayBuffer | bigint,) => void,): voidfunction generatePrimeSync
Usage in Deno
import { generatePrimeSync } from "node:crypto";
Overload 1
#generatePrimeSync(size: number): ArrayBufferGenerates a pseudorandom prime of size bits.
If options.safe is true, the prime will be a safe prime -- that is, (prime - 1) / 2 will also be a prime.
The options.add and options.rem parameters can be used to enforce additional
requirements, e.g., for Diffie-Hellman:
- If
options.addandoptions.remare both set, the prime will satisfy the condition thatprime % add = rem. - If only
options.addis set andoptions.safeis nottrue, the prime will satisfy the condition thatprime % add = 1. - If only
options.addis set andoptions.safeis set totrue, the prime will instead satisfy the condition thatprime % add = 3. This is necessary becauseprime % add = 1foroptions.add > 2would contradict the condition enforced byoptions.safe. options.remis ignored ifoptions.addis not given.
Both options.add and options.rem must be encoded as big-endian sequences
if given as an ArrayBuffer, SharedArrayBuffer, TypedArray, Buffer, or DataView.
By default, the prime is encoded as a big-endian sequence of octets
in an ArrayBuffer. If the bigint option is true, then a
bigint is provided.
Parameters #
#size: number The size (in bits) of the prime to generate.
Return Type #
ArrayBuffer Overload 2
#generatePrimeSync(size: number,options: GeneratePrimeOptionsBigInt,): bigintParameters #
#size: number #options: GeneratePrimeOptionsBigInt Return Type #
bigint Overload 3
#generatePrimeSync(size: number,options: GeneratePrimeOptionsArrayBuffer,): ArrayBufferParameters #
#size: number #options: GeneratePrimeOptionsArrayBuffer Return Type #
ArrayBuffer Overload 4
#generatePrimeSync(size: number,options: GeneratePrimeOptions,): ArrayBuffer | bigintParameters #
#size: number #options: GeneratePrimeOptions Return Type #
ArrayBuffer | bigint function getCipherInfo
Usage in Deno
import { getCipherInfo } from "node:crypto";
#getCipherInfo(nameOrNid: string | number,options?: CipherInfoOptions,): CipherInfo | undefinedReturns information about a given cipher.
Some ciphers accept variable length keys and initialization vectors. By default,
the crypto.getCipherInfo() method will return the default values for these
ciphers. To test if a given key length or iv length is acceptable for given
cipher, use the keyLength and ivLength options. If the given values are
unacceptable, undefined will be returned.
Parameters #
#nameOrNid: string | number The name or nid of the cipher to query.
#options: CipherInfoOptions Return Type #
CipherInfo | undefined function getCiphers
Usage in Deno
import { getCiphers } from "node:crypto";
function getDiffieHellman
Usage in Deno
import { getDiffieHellman } from "node:crypto";
#getDiffieHellman(groupName: string): DiffieHellmanGroupCreates a predefined DiffieHellmanGroup key exchange object. The
supported groups are listed in the documentation for DiffieHellmanGroup.
The returned object mimics the interface of objects created by createDiffieHellman, but will not allow changing
the keys (with diffieHellman.setPublicKey(), for example). The
advantage of using this method is that the parties do not have to
generate nor exchange a group modulus beforehand, saving both processor
and communication time.
Example (obtaining a shared secret):
const {
getDiffieHellman,
} = await import('node:crypto');
const alice = getDiffieHellman('modp14');
const bob = getDiffieHellman('modp14');
alice.generateKeys();
bob.generateKeys();
const aliceSecret = alice.computeSecret(bob.getPublicKey(), null, 'hex');
const bobSecret = bob.computeSecret(alice.getPublicKey(), null, 'hex');
// aliceSecret and bobSecret should be the same
console.log(aliceSecret === bobSecret);
Parameters #
#groupName: string Return Type #
function getHashes
Usage in Deno
import { getHashes } from "node:crypto";
function getRandomValues
Usage in Deno
import { getRandomValues } from "node:crypto";
#getRandomValues<T extends webcrypto.BufferSource>(typedArray: T): Tfunction hash
Usage in Deno
import { hash } from "node:crypto";
Overload 1
#hash(): stringA utility for creating one-shot hash digests of data. It can be faster than the object-based crypto.createHash() when hashing a smaller amount of data
(<= 5MB) that's readily available. If the data can be big or if it is streamed, it's still recommended to use crypto.createHash() instead. The algorithm
is dependent on the available algorithms supported by the version of OpenSSL on the platform. Examples are 'sha256', 'sha512', etc. On recent releases
of OpenSSL, openssl list -digest-algorithms will display the available digest algorithms.
Example:
import crypto from 'node:crypto';
import { Buffer } from 'node:buffer';
// Hashing a string and return the result as a hex-encoded string.
const string = 'Node.js';
// 10b3493287f831e81a438811a1ffba01f8cec4b7
console.log(crypto.hash('sha1', string));
// Encode a base64-encoded string into a Buffer, hash it and return
// the result as a buffer.
const base64 = 'Tm9kZS5qcw==';
// <Buffer 10 b3 49 32 87 f8 31 e8 1a 43 88 11 a1 ff ba 01 f8 ce c4 b7>
console.log(crypto.hash('sha1', Buffer.from(base64, 'base64'), 'buffer'));
Parameters #
#algorithm: string #data: BinaryLike When data is a string, it will be encoded as UTF-8 before being hashed. If a different input encoding is desired for a string input, user
could encode the string into a TypedArray using either TextEncoder or Buffer.from() and passing the encoded TypedArray into this API instead.
#outputEncoding: BinaryToTextEncoding = 'hex' Encoding used to encode the returned digest.
Return Type #
string Overload 2
#hash(): BufferOverload 3
function hkdf
Usage in Deno
import { hkdf } from "node:crypto";
#hkdf(digest: string,irm: BinaryLike | KeyObject,salt: BinaryLike,info: BinaryLike,keylen: number,callback: (err: Error | null,derivedKey: ArrayBuffer,) => void,): voidHKDF is a simple key derivation function defined in RFC 5869. The given ikm, salt and info are used with the digest to derive a key of keylen bytes.
The supplied callback function is called with two arguments: err and derivedKey. If an errors occurs while deriving the key, err will be set;
otherwise err will be null. The successfully generated derivedKey will
be passed to the callback as an ArrayBuffer. An error will be thrown if any
of the input arguments specify invalid values or types.
import { Buffer } from 'node:buffer';
const {
hkdf,
} = await import('node:crypto');
hkdf('sha512', 'key', 'salt', 'info', 64, (err, derivedKey) => {
if (err) throw err;
console.log(Buffer.from(derivedKey).toString('hex')); // '24156e2...5391653'
});
Parameters #
#digest: string The digest algorithm to use.
#irm: BinaryLike | KeyObject #salt: BinaryLike The salt value. Must be provided but can be zero-length.
#info: BinaryLike Additional info value. Must be provided but can be zero-length, and cannot be more than 1024 bytes.
#keylen: number The length of the key to generate. Must be greater than 0. The maximum allowable value is 255 times the number of bytes produced by the selected digest function (e.g. sha512
generates 64-byte hashes, making the maximum HKDF output 16320 bytes).
#callback: (err: Error | null,derivedKey: ArrayBuffer,) => void Return Type #
void function hkdfSync
Usage in Deno
import { hkdfSync } from "node:crypto";
#hkdfSync(): ArrayBufferProvides a synchronous HKDF key derivation function as defined in RFC 5869. The
given ikm, salt and info are used with the digest to derive a key of keylen bytes.
The successfully generated derivedKey will be returned as an ArrayBuffer.
An error will be thrown if any of the input arguments specify invalid values or types, or if the derived key cannot be generated.
import { Buffer } from 'node:buffer';
const {
hkdfSync,
} = await import('node:crypto');
const derivedKey = hkdfSync('sha512', 'key', 'salt', 'info', 64);
console.log(Buffer.from(derivedKey).toString('hex')); // '24156e2...5391653'
Parameters #
#digest: string The digest algorithm to use.
#ikm: BinaryLike | KeyObject The input keying material. Must be provided but can be zero-length.
#salt: BinaryLike The salt value. Must be provided but can be zero-length.
#info: BinaryLike Additional info value. Must be provided but can be zero-length, and cannot be more than 1024 bytes.
#keylen: number The length of the key to generate. Must be greater than 0. The maximum allowable value is 255 times the number of bytes produced by the selected digest function (e.g. sha512
generates 64-byte hashes, making the maximum HKDF output 16320 bytes).
Return Type #
ArrayBuffer function pbkdf2
Usage in Deno
import { pbkdf2 } from "node:crypto";
#pbkdf2(password: BinaryLike,salt: BinaryLike,iterations: number,keylen: number,digest: string,callback: (err: Error | null,derivedKey: Buffer,) => void,): voidProvides an asynchronous Password-Based Key Derivation Function 2 (PBKDF2)
implementation. A selected HMAC digest algorithm specified by digest is
applied to derive a key of the requested byte length (keylen) from the password, salt and iterations.
The supplied callback function is called with two arguments: err and derivedKey. If an error occurs while deriving the key, err will be set;
otherwise err will be null. By default, the successfully generated derivedKey will be passed to the callback as a Buffer. An error will be
thrown if any of the input arguments specify invalid values or types.
The iterations argument must be a number set as high as possible. The
higher the number of iterations, the more secure the derived key will be,
but will take a longer amount of time to complete.
The salt should be as unique as possible. It is recommended that a salt is
random and at least 16 bytes long. See NIST SP 800-132 for details.
When passing strings for password or salt, please consider caveats when using strings as inputs to cryptographic APIs.
const {
pbkdf2,
} = await import('node:crypto');
pbkdf2('secret', 'salt', 100000, 64, 'sha512', (err, derivedKey) => {
if (err) throw err;
console.log(derivedKey.toString('hex')); // '3745e48...08d59ae'
});
An array of supported digest functions can be retrieved using getHashes.
This API uses libuv's threadpool, which can have surprising and
negative performance implications for some applications; see the UV_THREADPOOL_SIZE documentation for more information.
Parameters #
#password: BinaryLike #salt: BinaryLike #iterations: number #keylen: number #digest: string #callback: (err: Error | null,derivedKey: Buffer,) => void Return Type #
void function pbkdf2Sync
Usage in Deno
import { pbkdf2Sync } from "node:crypto";
#pbkdf2Sync(): BufferProvides a synchronous Password-Based Key Derivation Function 2 (PBKDF2)
implementation. A selected HMAC digest algorithm specified by digest is
applied to derive a key of the requested byte length (keylen) from the password, salt and iterations.
If an error occurs an Error will be thrown, otherwise the derived key will be
returned as a Buffer.
The iterations argument must be a number set as high as possible. The
higher the number of iterations, the more secure the derived key will be,
but will take a longer amount of time to complete.
The salt should be as unique as possible. It is recommended that a salt is
random and at least 16 bytes long. See NIST SP 800-132 for details.
When passing strings for password or salt, please consider caveats when using strings as inputs to cryptographic APIs.
const {
pbkdf2Sync,
} = await import('node:crypto');
const key = pbkdf2Sync('secret', 'salt', 100000, 64, 'sha512');
console.log(key.toString('hex')); // '3745e48...08d59ae'
An array of supported digest functions can be retrieved using getHashes.
Parameters #
Return Type #
Buffer function privateDecrypt
Usage in Deno
import { privateDecrypt } from "node:crypto";
#privateDecrypt(privateKey: RsaPrivateKey | KeyLike,buffer: ArrayBufferView | string,): BufferDecrypts buffer with privateKey. buffer was previously encrypted using
the corresponding public key, for example using publicEncrypt.
If privateKey is not a KeyObject, this function behaves as if privateKey had been passed to createPrivateKey. If it is an
object, the padding property can be passed. Otherwise, this function uses RSA_PKCS1_OAEP_PADDING.
Parameters #
#privateKey: RsaPrivateKey | KeyLike #buffer: ArrayBufferView | string Return Type #
Buffer function privateEncrypt
Usage in Deno
import { privateEncrypt } from "node:crypto";
#privateEncrypt(privateKey: RsaPrivateKey | KeyLike,buffer: ArrayBufferView | string,): BufferEncrypts buffer with privateKey. The returned data can be decrypted using
the corresponding public key, for example using publicDecrypt.
If privateKey is not a KeyObject, this function behaves as if privateKey had been passed to createPrivateKey. If it is an
object, the padding property can be passed. Otherwise, this function uses RSA_PKCS1_PADDING.
Parameters #
#privateKey: RsaPrivateKey | KeyLike #buffer: ArrayBufferView | string Return Type #
Buffer function pseudoRandomBytes
Usage in Deno
import { pseudoRandomBytes } from "node:crypto";
function publicDecrypt
Usage in Deno
import { publicDecrypt } from "node:crypto";
#publicDecrypt(key: ,buffer: ArrayBufferView | string,): Buffer
This symbol is a non-functional stub.
Decrypts buffer with key.buffer was previously encrypted using
the corresponding private key, for example using privateEncrypt.
If key is not a KeyObject, this function behaves as if key had been passed to createPublicKey. If it is an
object, the padding property can be passed. Otherwise, this function uses RSA_PKCS1_PADDING.
Because RSA public keys can be derived from private keys, a private key may be passed instead of a public key.
Parameters #
Return Type #
Buffer function publicEncrypt
Usage in Deno
import { publicEncrypt } from "node:crypto";
#publicEncrypt(key: ,buffer: ArrayBufferView | string,): BufferEncrypts the content of buffer with key and returns a new Buffer with encrypted content. The returned data can be decrypted using
the corresponding private key, for example using privateDecrypt.
If key is not a KeyObject, this function behaves as if key had been passed to createPublicKey. If it is an
object, the padding property can be passed. Otherwise, this function uses RSA_PKCS1_OAEP_PADDING.
Because RSA public keys can be derived from private keys, a private key may be passed instead of a public key.
Parameters #
Return Type #
Buffer function randomBytes
Usage in Deno
import { randomBytes } from "node:crypto";
Overload 1
#randomBytes(size: number): BufferGenerates cryptographically strong pseudorandom data. The size argument
is a number indicating the number of bytes to generate.
If a callback function is provided, the bytes are generated asynchronously
and the callback function is invoked with two arguments: err and buf.
If an error occurs, err will be an Error object; otherwise it is null. The buf argument is a Buffer containing the generated bytes.
// Asynchronous
const {
randomBytes,
} = await import('node:crypto');
randomBytes(256, (err, buf) => {
if (err) throw err;
console.log(`${buf.length} bytes of random data: ${buf.toString('hex')}`);
});
If the callback function is not provided, the random bytes are generated
synchronously and returned as a Buffer. An error will be thrown if
there is a problem generating the bytes.
// Synchronous
const {
randomBytes,
} = await import('node:crypto');
const buf = randomBytes(256);
console.log(
`${buf.length} bytes of random data: ${buf.toString('hex')}`);
The crypto.randomBytes() method will not complete until there is
sufficient entropy available.
This should normally never take longer than a few milliseconds. The only time
when generating the random bytes may conceivably block for a longer period of
time is right after boot, when the whole system is still low on entropy.
This API uses libuv's threadpool, which can have surprising and
negative performance implications for some applications; see the UV_THREADPOOL_SIZE documentation for more information.
The asynchronous version of crypto.randomBytes() is carried out in a single
threadpool request. To minimize threadpool task length variation, partition
large randomBytes requests when doing so as part of fulfilling a client
request.
Parameters #
#size: number The number of bytes to generate. The size must not be larger than 2**31 - 1.
Return Type #
Buffer if the callback function is not provided.
Overload 2
function randomFill
Usage in Deno
import { randomFill } from "node:crypto";
Overload 1
#randomFill<T extends ArrayBufferView>(buffer: T,callback: (err: Error | null,buf: T,) => void,): voidThis function is similar to randomBytes but requires the first
argument to be a Buffer that will be filled. It also
requires that a callback is passed in.
If the callback function is not provided, an error will be thrown.
import { Buffer } from 'node:buffer';
const { randomFill } = await import('node:crypto');
const buf = Buffer.alloc(10);
randomFill(buf, (err, buf) => {
if (err) throw err;
console.log(buf.toString('hex'));
});
randomFill(buf, 5, (err, buf) => {
if (err) throw err;
console.log(buf.toString('hex'));
});
// The above is equivalent to the following:
randomFill(buf, 5, 5, (err, buf) => {
if (err) throw err;
console.log(buf.toString('hex'));
});
Any ArrayBuffer, TypedArray, or DataView instance may be passed as buffer.
While this includes instances of Float32Array and Float64Array, this
function should not be used to generate random floating-point numbers. The
result may contain +Infinity, -Infinity, and NaN, and even if the array
contains finite numbers only, they are not drawn from a uniform random
distribution and have no meaningful lower or upper bounds.
import { Buffer } from 'node:buffer';
const { randomFill } = await import('node:crypto');
const a = new Uint32Array(10);
randomFill(a, (err, buf) => {
if (err) throw err;
console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
.toString('hex'));
});
const b = new DataView(new ArrayBuffer(10));
randomFill(b, (err, buf) => {
if (err) throw err;
console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
.toString('hex'));
});
const c = new ArrayBuffer(10);
randomFill(c, (err, buf) => {
if (err) throw err;
console.log(Buffer.from(buf).toString('hex'));
});
This API uses libuv's threadpool, which can have surprising and
negative performance implications for some applications; see the UV_THREADPOOL_SIZE documentation for more information.
The asynchronous version of crypto.randomFill() is carried out in a single
threadpool request. To minimize threadpool task length variation, partition
large randomFill requests when doing so as part of fulfilling a client
request.
Type Parameters #
#T extends ArrayBufferView Parameters #
Return Type #
void Overload 2
#randomFill<T extends ArrayBufferView>(buffer: T,offset: number,callback: (err: Error | null,buf: T,) => void,): voidOverload 3
function randomFillSync
Usage in Deno
import { randomFillSync } from "node:crypto";
#randomFillSync<T extends ArrayBufferView>(buffer: T,offset?: number,size?: number,): TSynchronous version of randomFill.
import { Buffer } from 'node:buffer';
const { randomFillSync } = await import('node:crypto');
const buf = Buffer.alloc(10);
console.log(randomFillSync(buf).toString('hex'));
randomFillSync(buf, 5);
console.log(buf.toString('hex'));
// The above is equivalent to the following:
randomFillSync(buf, 5, 5);
console.log(buf.toString('hex'));
Any ArrayBuffer, TypedArray or DataView instance may be passed asbuffer.
import { Buffer } from 'node:buffer';
const { randomFillSync } = await import('node:crypto');
const a = new Uint32Array(10);
console.log(Buffer.from(randomFillSync(a).buffer,
a.byteOffset, a.byteLength).toString('hex'));
const b = new DataView(new ArrayBuffer(10));
console.log(Buffer.from(randomFillSync(b).buffer,
b.byteOffset, b.byteLength).toString('hex'));
const c = new ArrayBuffer(10);
console.log(Buffer.from(randomFillSync(c)).toString('hex'));
Type Parameters #
#T extends ArrayBufferView Parameters #
Return Type #
The object passed as buffer argument.
function randomInt
Usage in Deno
import { randomInt } from "node:crypto";
Overload 1
#randomInt(max: number): numberReturn a random integer n such that min <= n < max. This
implementation avoids modulo bias.
The range (max - min) must be less than 2**48. min and max must
be safe integers.
If the callback function is not provided, the random integer is
generated synchronously.
// Asynchronous
const {
randomInt,
} = await import('node:crypto');
randomInt(3, (err, n) => {
if (err) throw err;
console.log(`Random number chosen from (0, 1, 2): ${n}`);
});
// Synchronous
const {
randomInt,
} = await import('node:crypto');
const n = randomInt(3);
console.log(`Random number chosen from (0, 1, 2): ${n}`);
// With `min` argument
const {
randomInt,
} = await import('node:crypto');
const n = randomInt(1, 7);
console.log(`The dice rolled: ${n}`);
Parameters #
#max: number End of random range (exclusive).
Return Type #
number Overload 2
#randomInt(min: number,max: number,): numberOverload 3
#randomInt(max: number,callback: (err: Error | null,value: number,) => void,): voidOverload 4
function randomUUID
Usage in Deno
import { randomUUID } from "node:crypto";
#randomUUID(options?: RandomUUIDOptions): UUIDfunction scrypt
Usage in Deno
import { scrypt } from "node:crypto";
Overload 1
#scrypt(password: BinaryLike,salt: BinaryLike,keylen: number,callback: (err: Error | null,derivedKey: Buffer,) => void,): voidProvides an asynchronous scrypt implementation. Scrypt is a password-based key derivation function that is designed to be expensive computationally and memory-wise in order to make brute-force attacks unrewarding.
The salt should be as unique as possible. It is recommended that a salt is
random and at least 16 bytes long. See NIST SP 800-132 for details.
When passing strings for password or salt, please consider caveats when using strings as inputs to cryptographic APIs.
The callback function is called with two arguments: err and derivedKey. err is an exception object when key derivation fails, otherwise err is null. derivedKey is passed to the
callback as a Buffer.
An exception is thrown when any of the input arguments specify invalid values or types.
const {
scrypt,
} = await import('node:crypto');
// Using the factory defaults.
scrypt('password', 'salt', 64, (err, derivedKey) => {
if (err) throw err;
console.log(derivedKey.toString('hex')); // '3745e48...08d59ae'
});
// Using a custom N parameter. Must be a power of two.
scrypt('password', 'salt', 64, { N: 1024 }, (err, derivedKey) => {
if (err) throw err;
console.log(derivedKey.toString('hex')); // '3745e48...aa39b34'
});
Parameters #
#password: BinaryLike #salt: BinaryLike #keylen: number #callback: (err: Error | null,derivedKey: Buffer,) => void Return Type #
void Overload 2
#scrypt(password: BinaryLike,salt: BinaryLike,keylen: number,options: ScryptOptions,callback: (err: Error | null,derivedKey: Buffer,) => void,): voidParameters #
#password: BinaryLike #salt: BinaryLike #keylen: number #options: ScryptOptions #callback: (err: Error | null,derivedKey: Buffer,) => void Return Type #
void function scryptSync
Usage in Deno
import { scryptSync } from "node:crypto";
#scryptSync(): BufferProvides a synchronous scrypt implementation. Scrypt is a password-based key derivation function that is designed to be expensive computationally and memory-wise in order to make brute-force attacks unrewarding.
The salt should be as unique as possible. It is recommended that a salt is
random and at least 16 bytes long. See NIST SP 800-132 for details.
When passing strings for password or salt, please consider caveats when using strings as inputs to cryptographic APIs.
An exception is thrown when key derivation fails, otherwise the derived key is
returned as a Buffer.
An exception is thrown when any of the input arguments specify invalid values or types.
const {
scryptSync,
} = await import('node:crypto');
// Using the factory defaults.
const key1 = scryptSync('password', 'salt', 64);
console.log(key1.toString('hex')); // '3745e48...08d59ae'
// Using a custom N parameter. Must be a power of two.
const key2 = scryptSync('password', 'salt', 64, { N: 1024 });
console.log(key2.toString('hex')); // '3745e48...aa39b34'
Parameters #
Return Type #
Buffer function secureHeapUsed
Usage in Deno
import { secureHeapUsed } from "node:crypto";
#secureHeapUsed(): SecureHeapUsage
This symbol is a non-functional stub.
Return Type #
function setEngine
Usage in Deno
import { setEngine } from "node:crypto";
#setEngine(engine: string,flags?: number,): void
This symbol is a non-functional stub.
Load and set the engine for some or all OpenSSL functions (selected by flags).
engine could be either an id or a path to the engine's shared library.
The optional flags argument uses ENGINE_METHOD_ALL by default. The flags is a bit field taking one of or a mix of the following flags (defined in crypto.constants):
crypto.constants.ENGINE_METHOD_RSAcrypto.constants.ENGINE_METHOD_DSAcrypto.constants.ENGINE_METHOD_DHcrypto.constants.ENGINE_METHOD_RANDcrypto.constants.ENGINE_METHOD_ECcrypto.constants.ENGINE_METHOD_CIPHERScrypto.constants.ENGINE_METHOD_DIGESTScrypto.constants.ENGINE_METHOD_PKEY_METHScrypto.constants.ENGINE_METHOD_PKEY_ASN1_METHScrypto.constants.ENGINE_METHOD_ALLcrypto.constants.ENGINE_METHOD_NONE
Parameters #
Return Type #
void function sign
Usage in Deno
import { sign } from "node:crypto";
Overload 1
#sign(algorithm: string
| null
| undefined,data: ArrayBufferView,): BufferCalculates and returns the signature for data using the given private key and
algorithm. If algorithm is null or undefined, then the algorithm is
dependent upon the key type (especially Ed25519 and Ed448).
If key is not a KeyObject, this function behaves as if key had been
passed to createPrivateKey. If it is an object, the following
additional properties can be passed:
If the callback function is provided this function uses libuv's threadpool.
Parameters #
Return Type #
Buffer Overload 2
function timingSafeEqual
Usage in Deno
import { timingSafeEqual } from "node:crypto";
#timingSafeEqual(a: ArrayBufferView,b: ArrayBufferView,): booleanThis function compares the underlying bytes that represent the given ArrayBuffer, TypedArray, or DataView instances using a constant-time
algorithm.
This function does not leak timing information that would allow an attacker to guess one of the values. This is suitable for comparing HMAC digests or secret values like authentication cookies or capability urls.
a and b must both be Buffers, TypedArrays, or DataViews, and they
must have the same byte length. An error is thrown if a and b have
different byte lengths.
If at least one of a and b is a TypedArray with more than one byte per
entry, such as Uint16Array, the result will be computed using the platform
byte order.
When both of the inputs are Float32Arrays or Float64Arrays, this function might return unexpected results due to IEEE 754
encoding of floating-point numbers. In particular, neither x === y nor Object.is(x, y) implies that the byte representations of two floating-point
numbers x and y are equal.
Use of crypto.timingSafeEqual does not guarantee that the surrounding code
is timing-safe. Care should be taken to ensure that the surrounding code does
not introduce timing vulnerabilities.
Parameters #
Return Type #
boolean function verify
Usage in Deno
import { verify } from "node:crypto";
Overload 1
#verify(algorithm: string
| null
| undefined,data: ArrayBufferView,signature: ArrayBufferView,): booleanVerifies the given signature for data using the given key and algorithm. If algorithm is null or undefined, then the algorithm is dependent upon the
key type (especially Ed25519 and Ed448).
If key is not a KeyObject, this function behaves as if key had been
passed to createPublicKey. If it is an object, the following
additional properties can be passed:
The signature argument is the previously calculated signature for the data.
Because public keys can be derived from private keys, a private key or a public
key may be passed for key.
If the callback function is provided this function uses libuv's threadpool.
Parameters #
Return Type #
boolean Overload 2
#verify(algorithm: string
| null
| undefined,data: ArrayBufferView,signature: ArrayBufferView,callback: (error: Error | null,result: boolean,) => void,): voidinterface AsymmetricKeyDetails
Usage in Deno
import { type AsymmetricKeyDetails } from "node:crypto";
Properties #
#modulusLength: number | undefined Key size in bits (RSA, DSA).
#publicExponent: bigint | undefined Public exponent (RSA).
#hashAlgorithm: string | undefined Name of the message digest (RSA-PSS).
#mgf1HashAlgorithm: string | undefined Name of the message digest used by MGF1 (RSA-PSS).
#saltLength: number | undefined Minimal salt length in bytes (RSA-PSS).
#divisorLength: number | undefined Size of q in bits (DSA).
#namedCurve: string | undefined Name of the curve (EC).
interface CheckPrimeOptions
Usage in Deno
import { type CheckPrimeOptions } from "node:crypto";
Properties #
The number of Miller-Rabin probabilistic primality iterations to perform.
When the value is 0 (zero), a number of checks is used that yields a false positive rate of at most 2**-64 for random input.
Care must be used when selecting a number of checks.
Refer to the OpenSSL documentation for the BN_is_prime_ex function nchecks options for more details.
interface CipherCCMOptions
Usage in Deno
import { type CipherCCMOptions } from "node:crypto";
Properties #
#authTagLength: number interface CipherChaCha20Poly1305
Usage in Deno
import { type CipherChaCha20Poly1305 } from "node:crypto";
Methods #
#getAuthTag(): Buffer interface CipherChaCha20Poly1305Options
Usage in Deno
import { type CipherChaCha20Poly1305Options } from "node:crypto";
Properties #
#authTagLength: number | undefined interface CipherGCMOptions
Usage in Deno
import { type CipherGCMOptions } from "node:crypto";
Properties #
#authTagLength: number | undefined interface CipherInfo
Usage in Deno
import { type CipherInfo } from "node:crypto";
Properties #
The block size of the cipher in bytes. This property is omitted when mode is 'stream'.
The expected or default initialization vector length in bytes. This property is omitted if the cipher does not use an initialization vector.
The cipher mode.
interface CipherOCBOptions
Usage in Deno
import { type CipherOCBOptions } from "node:crypto";
Properties #
#authTagLength: number interface DecipherCCM
Usage in Deno
import { type DecipherCCM } from "node:crypto";
Methods #
#setAuthTag(buffer: ArrayBufferView): this interface DecipherChaCha20Poly1305
Usage in Deno
import { type DecipherChaCha20Poly1305 } from "node:crypto";
Methods #
#setAuthTag(buffer: ArrayBufferView): this interface DecipherGCM
Usage in Deno
import { type DecipherGCM } from "node:crypto";
Methods #
#setAuthTag(buffer: ArrayBufferView): this interface DecipherOCB
Usage in Deno
import { type DecipherOCB } from "node:crypto";
Methods #
#setAuthTag(buffer: ArrayBufferView): this interface DiffieHellmanGroupConstructor
Usage in Deno
import { type DiffieHellmanGroupConstructor } from "node:crypto";
Call Signatures #
(name: string): DiffieHellmanGroup Properties #
#prototype: DiffieHellmanGroup interface DSAKeyPairKeyObjectOptions
Usage in Deno
import { type DSAKeyPairKeyObjectOptions } from "node:crypto";
Properties #
#modulusLength: number Key size in bits
#divisorLength: number Size of q in bits
interface DSAKeyPairOptions
Usage in Deno
import { type DSAKeyPairOptions } from "node:crypto";
Type Parameters #
Properties #
#modulusLength: number Key size in bits
#divisorLength: number Size of q in bits
#publicKeyEncoding: { type: "spki"; format: PubF; } #privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & { type: "pkcs8"; } interface ECKeyPairKeyObjectOptions
Usage in Deno
import { type ECKeyPairKeyObjectOptions } from "node:crypto";
Properties #
#namedCurve: string Name of the curve to use
#paramEncoding: "explicit"
| "named"
| undefined Must be 'named' or 'explicit'. Default: 'named'.
interface ECKeyPairOptions
Usage in Deno
import { type ECKeyPairOptions } from "node:crypto";
Type Parameters #
Properties #
#publicKeyEncoding: { type: "pkcs1" | "spki"; format: PubF; } #privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & { type: "sec1" | "pkcs8"; } interface ED25519KeyPairKeyObjectOptions
Usage in Deno
import { type ED25519KeyPairKeyObjectOptions } from "node:crypto";
interface ED25519KeyPairOptions
Usage in Deno
import { type ED25519KeyPairOptions } from "node:crypto";
Type Parameters #
Properties #
#publicKeyEncoding: { type: "spki"; format: PubF; } #privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & { type: "pkcs8"; } interface ED448KeyPairKeyObjectOptions
Usage in Deno
import { type ED448KeyPairKeyObjectOptions } from "node:crypto";
interface ED448KeyPairOptions
Usage in Deno
import { type ED448KeyPairOptions } from "node:crypto";
Type Parameters #
Properties #
#publicKeyEncoding: { type: "spki"; format: PubF; } #privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & { type: "pkcs8"; } interface GeneratePrimeOptions
Usage in Deno
import { type GeneratePrimeOptions } from "node:crypto";
interface GeneratePrimeOptionsArrayBuffer
Usage in Deno
import { type GeneratePrimeOptionsArrayBuffer } from "node:crypto";
interface GeneratePrimeOptionsBigInt
Usage in Deno
import { type GeneratePrimeOptionsBigInt } from "node:crypto";
interface HashOptions
Usage in Deno
import { type HashOptions } from "node:crypto";
Properties #
#outputLength: number | undefined For XOF hash functions such as shake256, the
outputLength option can be used to specify the desired output length in bytes.
interface JsonWebKey
Usage in Deno
import { type JsonWebKey } from "node:crypto";
interface JsonWebKeyInput
Usage in Deno
import { type JsonWebKeyInput } from "node:crypto";
interface JwkKeyExportOptions
Usage in Deno
import { type JwkKeyExportOptions } from "node:crypto";
interface KeyPairKeyObjectResult
Usage in Deno
import { type KeyPairKeyObjectResult } from "node:crypto";
interface PrivateKeyInput
Usage in Deno
import { type PrivateKeyInput } from "node:crypto";
interface RandomUUIDOptions
Usage in Deno
import { type RandomUUIDOptions } from "node:crypto";
Properties #
#disableEntropyCache: boolean | undefined By default, to improve performance,
Node.js will pre-emptively generate and persistently cache enough
random data to generate up to 128 random UUIDs. To generate a UUID
without using the cache, set disableEntropyCache to true.
interface RSAKeyPairKeyObjectOptions
Usage in Deno
import { type RSAKeyPairKeyObjectOptions } from "node:crypto";
Properties #
#modulusLength: number Key size in bits
#publicExponent: number | undefined Public exponent
interface RSAKeyPairOptions
Usage in Deno
import { type RSAKeyPairOptions } from "node:crypto";
Type Parameters #
Properties #
#modulusLength: number Key size in bits
#publicExponent: number | undefined Public exponent
#publicKeyEncoding: { type: "pkcs1" | "spki"; format: PubF; } #privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & { type: "pkcs1" | "pkcs8"; } interface RSAPSSKeyPairKeyObjectOptions
Usage in Deno
import { type RSAPSSKeyPairKeyObjectOptions } from "node:crypto";
Properties #
#modulusLength: number Key size in bits
#publicExponent: number | undefined Public exponent
#hashAlgorithm: string Name of the message digest
#mgf1HashAlgorithm: string Name of the message digest used by MGF1
#saltLength: string Minimal salt length in bytes
interface RSAPSSKeyPairOptions
Usage in Deno
import { type RSAPSSKeyPairOptions } from "node:crypto";
Type Parameters #
Properties #
#modulusLength: number Key size in bits
#publicExponent: number | undefined Public exponent
#hashAlgorithm: string Name of the message digest
#mgf1HashAlgorithm: string Name of the message digest used by MGF1
#saltLength: string Minimal salt length in bytes
#publicKeyEncoding: { type: "spki"; format: PubF; } #privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & { type: "pkcs8"; } interface ScryptOptions
Usage in Deno
import { type ScryptOptions } from "node:crypto";
interface SecureHeapUsage
Usage in Deno
import { type SecureHeapUsage } from "node:crypto";
Properties #
The total allocated secure heap size as specified using the --secure-heap=n command-line flag.
The minimum allocation from the secure heap as specified using the --secure-heap-min command-line flag.
#utilization: number The calculated ratio of used to total allocated bytes.
interface SigningOptions
Usage in Deno
import { type SigningOptions } from "node:crypto";
Properties #
#saltLength: number | undefined #dsaEncoding: DSAEncoding | undefined interface SignKeyObjectInput
Usage in Deno
import { type SignKeyObjectInput } from "node:crypto";
interface VerifyJsonWebKeyInput
Usage in Deno
import { type VerifyJsonWebKeyInput } from "node:crypto";
interface VerifyKeyObjectInput
Usage in Deno
import { type VerifyKeyObjectInput } from "node:crypto";
interface webcrypto.AesCbcParams
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
interface webcrypto.AesCtrParams
Usage in Deno
import { webcrypto } from "node:crypto";
interface webcrypto.AesDerivedKeyParams
Usage in Deno
import { webcrypto } from "node:crypto";
interface webcrypto.AesGcmParams
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
interface webcrypto.AesKeyAlgorithm
Usage in Deno
import { webcrypto } from "node:crypto";
interface webcrypto.AesKeyGenParams
Usage in Deno
import { webcrypto } from "node:crypto";
interface webcrypto.Algorithm
Usage in Deno
import { webcrypto } from "node:crypto";
interface webcrypto.Crypto
Usage in Deno
import { webcrypto } from "node: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.
Properties #
#subtle: SubtleCrypto Provides access to the SubtleCrypto API.
Methods #
#getRandomValues<T extends Exclude<TypedArray, Float32Array | Float64Array>>(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(): UUID Generates a random RFC 4122 version 4 UUID. The UUID is generated using a cryptographic pseudorandom number generator.
interface webcrypto.CryptoKey
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
#algorithm: KeyAlgorithm An object detailing the algorithm for which the key can be used along with additional algorithm-specific parameters.
#extractable: boolean When true, the CryptoKey can be extracted using either subtleCrypto.exportKey() or subtleCrypto.wrapKey().
A string identifying whether the key is a symmetric ('secret') or asymmetric ('private' or 'public') key.
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 webcrypto.CryptoKeyPair
Usage in Deno
import { webcrypto } from "node:crypto";
interface webcrypto.EcdsaParams
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
interface webcrypto.EcKeyAlgorithm
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
interface webcrypto.EcKeyGenParams
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
interface webcrypto.EcKeyImportParams
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
interface webcrypto.Ed448Params
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
#context: BufferSource interface webcrypto.HkdfParams
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
interface webcrypto.HmacImportParams
Usage in Deno
import { webcrypto } from "node:crypto";
interface webcrypto.HmacKeyAlgorithm
Usage in Deno
import { webcrypto } from "node:crypto";
interface webcrypto.HmacKeyGenParams
Usage in Deno
import { webcrypto } from "node:crypto";
interface webcrypto.JsonWebKey
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
#oth: RsaOtherPrimesInfo[] interface webcrypto.KeyAlgorithm
Usage in Deno
import { webcrypto } from "node:crypto";
interface webcrypto.Pbkdf2Params
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
interface webcrypto.RsaHashedImportParams
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
interface webcrypto.RsaHashedKeyAlgorithm
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
interface webcrypto.RsaHashedKeyGenParams
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
interface webcrypto.RsaKeyAlgorithm
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
#modulusLength: number interface webcrypto.RsaKeyGenParams
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
#modulusLength: number interface webcrypto.RsaOaepParams
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
#label: BufferSource interface webcrypto.RsaPssParams
Usage in Deno
import { webcrypto } from "node:crypto";
Properties #
#saltLength: number interface webcrypto.SubtleCrypto
Usage in Deno
import { webcrypto } from "node:crypto";
Methods #
#decrypt(): Promise<ArrayBuffer> Using the method and parameters specified in algorithm and the keying material provided by key,
subtle.decrypt() 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:
'RSA-OAEP''AES-CTR''AES-CBC''AES-GCM'
#deriveBits(): Promise<ArrayBuffer> Using the method and parameters specified in algorithm and the keying material provided by baseKey,
subtle.deriveBits() 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:
'ECDH''X25519''X448''HKDF''PBKDF2'
#deriveBits(): Promise<ArrayBuffer> #deriveKey(algorithm: ,baseKey: CryptoKey,derivedKeyAlgorithm: ,extractable: boolean,keyUsages: readonly KeyUsage[],): Promise<CryptoKey> Using the method and parameters specified in algorithm, and the keying material provided by baseKey,
subtle.deriveKey() attempts to generate a new 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:
'ECDH''X25519''X448''HKDF''PBKDF2'
#digest(algorithm: AlgorithmIdentifier,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:
'SHA-1''SHA-256''SHA-384''SHA-512'
If algorithm is provided as an <Object>, it must have a name property whose value is one of the above.
#encrypt(): Promise<ArrayBuffer> Using the method and parameters specified by algorithm and the keying material provided by key,
subtle.encrypt() attempts to encipher data. If successful,
the returned promise is resolved with an <ArrayBuffer> containing the encrypted result.
The algorithms currently supported include:
'RSA-OAEP''AES-CTR''AES-CBC''AES-GCM'
#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.
#generateKey(algorithm: RsaHashedKeyGenParams | EcKeyGenParams,extractable: boolean,keyUsages: readonly KeyUsage[],): Promise<CryptoKeyPair> Using the method and parameters provided in algorithm,
subtle.generateKey() attempts to generate new keying material.
Depending the method used, the method may generate either a single <CryptoKey> or a <CryptoKeyPair>.
The <CryptoKeyPair> (public and private key) generating algorithms supported include:
-
'RSASSA-PKCS1-v1_5' -
'RSA-PSS' -
'RSA-OAEP' -
'ECDSA' -
'Ed25519' -
'Ed448' -
'ECDH' -
'X25519' -
'X448'The<CryptoKey>(secret key) generating algorithms supported include: -
'HMAC' -
'AES-CTR' -
'AES-CBC' -
'AES-GCM' -
'AES-KW'
#generateKey(): Promise<CryptoKey> #generateKey(): Promise<CryptoKeyPair | CryptoKey> #importKey(): Promise<CryptoKey> The subtle.importKey() 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 the created <CryptoKey>.
If importing a 'PBKDF2' key, extractable must be false.
#sign(): Promise<ArrayBuffer> Using the method and parameters given by algorithm and the keying material provided by key,
subtle.sign() 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:
'RSASSA-PKCS1-v1_5''RSA-PSS''ECDSA''Ed25519''Ed448''HMAC'
#unwrapKey(format: KeyFormat,wrappedKey: BufferSource,unwrappingKey: CryptoKey,unwrapAlgorithm: ,unwrappedKeyAlgorithm: ,extractable: boolean,keyUsages: KeyUsage[],): Promise<CryptoKey> In cryptography, "wrapping a key" refers to exporting and then encrypting the keying material.
The subtle.unwrapKey() 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:
'RSA-OAEP''AES-CTR''AES-CBC''AES-GCM''AES-KW'
The unwrapped key algorithms supported include:
'RSASSA-PKCS1-v1_5''RSA-PSS''RSA-OAEP''ECDSA''Ed25519''Ed448''ECDH''X25519''X448''HMAC''AES-CTR''AES-CBC''AES-GCM''AES-KW'
#verify(): Promise<boolean> Using the method and parameters given in algorithm and the keying material provided by key,
subtle.verify() 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:
'RSASSA-PKCS1-v1_5''RSA-PSS''ECDSA''Ed25519''Ed448''HMAC'
#wrapKey(): Promise<ArrayBuffer> In cryptography, "wrapping a key" refers to exporting and then encrypting the keying material.
The subtle.wrapKey() 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:
'RSA-OAEP''AES-CTR''AES-CBC''AES-GCM''AES-KW'
interface X25519KeyPairKeyObjectOptions
Usage in Deno
import { type X25519KeyPairKeyObjectOptions } from "node:crypto";
interface X25519KeyPairOptions
Usage in Deno
import { type X25519KeyPairOptions } from "node:crypto";
Type Parameters #
Properties #
#publicKeyEncoding: { type: "spki"; format: PubF; } #privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & { type: "pkcs8"; } interface X448KeyPairKeyObjectOptions
Usage in Deno
import { type X448KeyPairKeyObjectOptions } from "node:crypto";
interface X448KeyPairOptions
Usage in Deno
import { type X448KeyPairOptions } from "node:crypto";
Type Parameters #
Properties #
#publicKeyEncoding: { type: "spki"; format: PubF; } #privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & { type: "pkcs8"; } interface X509CheckOptions
Usage in Deno
import { type X509CheckOptions } from "node:crypto";
Properties #
#partialWildcards: boolean #multiLabelWildcards: boolean #singleLabelSubdomains: boolean namespace constants
Usage in Deno
import { constants } from "node:crypto";
Variables #
Specifies the active default cipher list used by the current Node.js process (colon-separated values).
Specifies the built-in default cipher list used by Node.js (colon-separated values).
Causes the salt length for RSA_PKCS1_PSS_PADDING to be determined automatically when verifying a signature.
Sets the salt length for RSA_PKCS1_PSS_PADDING to the digest size when signing or verifying.
Sets the salt length for RSA_PKCS1_PSS_PADDING to the maximum permissible value when signing data.
Applies multiple bug workarounds within OpenSSL. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html for detail.
Instructs OpenSSL to allow a non-[EC]DHE-based key exchange mode for TLS v1.3
Allows legacy insecure renegotiation between OpenSSL and unpatched clients or servers. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html.
Attempts to use the server's preferences instead of the client's when selecting a cipher. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html.
Instructs OpenSSL to use Cisco's version identifier of DTLS_BAD_VER.
Instructs OpenSSL to add server-hello extension from an early version of the cryptopro draft.
Instructs OpenSSL to disable a SSL 3.0/TLS 1.0 vulnerability workaround added in OpenSSL 0.9.6d.
Instructs OpenSSL to always start a new session when performing renegotiation.
Instructs OpenSSL server to prioritize ChaCha20-Poly1305 when the client does. This option has no effect if SSL_OP_CIPHER_SERVER_PREFERENCE is not enabled.
type alias BinaryLike
Usage in Deno
import { type BinaryLike } from "node:crypto";
Definition #
string | ArrayBufferView type alias BinaryToTextEncoding
Usage in Deno
import { type BinaryToTextEncoding } from "node:crypto";
Definition #
"base64"
| "base64url"
| "hex"
| "binary" type alias CharacterEncoding
Usage in Deno
import { type CharacterEncoding } from "node:crypto";
Definition #
"utf8"
| "utf-8"
| "utf16le"
| "utf-16le"
| "latin1" type alias CipherCCMTypes
Usage in Deno
import { type CipherCCMTypes } from "node:crypto";
Definition #
"aes-128-ccm"
| "aes-192-ccm"
| "aes-256-ccm" type alias CipherChaCha20Poly1305Types
Usage in Deno
import { type CipherChaCha20Poly1305Types } from "node:crypto";
Definition #
"chacha20-poly1305" type alias CipherGCMTypes
Usage in Deno
import { type CipherGCMTypes } from "node:crypto";
Definition #
"aes-128-gcm"
| "aes-192-gcm"
| "aes-256-gcm" type alias CipherMode
Usage in Deno
import { type CipherMode } from "node:crypto";
Definition #
"cbc"
| "ccm"
| "cfb"
| "ctr"
| "ecb"
| "gcm"
| "ocb"
| "ofb"
| "stream"
| "wrap"
| "xts" type alias CipherOCBTypes
Usage in Deno
import { type CipherOCBTypes } from "node:crypto";
Definition #
"aes-128-ocb"
| "aes-192-ocb"
| "aes-256-ocb" type alias DSAEncoding
Usage in Deno
import { type DSAEncoding } from "node:crypto";
Definition #
"der" | "ieee-p1363" type alias ECDHKeyFormat
Usage in Deno
import { type ECDHKeyFormat } from "node:crypto";
Definition #
"compressed"
| "uncompressed"
| "hybrid" type alias KeyObjectType
Usage in Deno
import { type KeyObjectType } from "node:crypto";
Definition #
"secret"
| "public"
| "private" type alias LargeNumberLike
Usage in Deno
import { type LargeNumberLike } from "node:crypto";
Definition #
ArrayBufferView
| SharedArrayBuffer
| ArrayBuffer
| bigint type alias LegacyCharacterEncoding
Usage in Deno
import { type LegacyCharacterEncoding } from "node:crypto";
Definition #
"ascii"
| "binary"
| "ucs2"
| "ucs-2" type alias webcrypto.AlgorithmIdentifier
Usage in Deno
import { webcrypto } from "node:crypto";
type alias webcrypto.BigInteger
Usage in Deno
import { webcrypto } from "node:crypto";
Definition #
Uint8Array type alias webcrypto.BufferSource
Usage in Deno
import { webcrypto } from "node:crypto";
Definition #
ArrayBufferView | ArrayBuffer type alias webcrypto.HashAlgorithmIdentifier
Usage in Deno
import { webcrypto } from "node:crypto";
Definition #
type alias webcrypto.KeyFormat
Usage in Deno
import { webcrypto } from "node:crypto";
Definition #
"jwk"
| "pkcs8"
| "raw"
| "spki" type alias webcrypto.KeyType
Usage in Deno
import { webcrypto } from "node:crypto";
Definition #
"private"
| "public"
| "secret" type alias webcrypto.KeyUsage
Usage in Deno
import { webcrypto } from "node:crypto";
Definition #
"decrypt"
| "deriveBits"
| "deriveKey"
| "encrypt"
| "sign"
| "unwrapKey"
| "verify"
| "wrapKey" type alias webcrypto.NamedCurve
Usage in Deno
import { webcrypto } from "node:crypto";
Definition #
string variable constants.defaultCipherList
Usage in Deno
import { constants } from "node:crypto";
Specifies the active default cipher list used by the current Node.js process (colon-separated values).
Type #
string variable constants.defaultCoreCipherList
Usage in Deno
import { constants } from "node:crypto";
Specifies the built-in default cipher list used by Node.js (colon-separated values).
Type #
string variable constants.DH_CHECK_P_NOT_PRIME
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.DH_CHECK_P_NOT_SAFE_PRIME
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.DH_NOT_SUITABLE_GENERATOR
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.DH_UNABLE_TO_CHECK_GENERATOR
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.ENGINE_METHOD_ALL
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.ENGINE_METHOD_CIPHERS
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.ENGINE_METHOD_DH
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.ENGINE_METHOD_DIGESTS
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.ENGINE_METHOD_DSA
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.ENGINE_METHOD_EC
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.ENGINE_METHOD_NONE
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.ENGINE_METHOD_PKEY_ASN1_METHS
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.ENGINE_METHOD_PKEY_METHS
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.ENGINE_METHOD_RAND
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.ENGINE_METHOD_RSA
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.OPENSSL_VERSION_NUMBER
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.POINT_CONVERSION_COMPRESSED
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.POINT_CONVERSION_HYBRID
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.POINT_CONVERSION_UNCOMPRESSED
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.RSA_PKCS1_OAEP_PADDING
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.RSA_PKCS1_PADDING
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.RSA_PKCS1_PSS_PADDING
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.RSA_PSS_SALTLEN_AUTO
Usage in Deno
import { constants } from "node:crypto";
Causes the salt length for RSA_PKCS1_PSS_PADDING to be determined automatically when verifying a signature.
Type #
number variable constants.RSA_PSS_SALTLEN_DIGEST
Usage in Deno
import { constants } from "node:crypto";
Sets the salt length for RSA_PKCS1_PSS_PADDING to the digest size when signing or verifying.
Type #
number variable constants.RSA_PSS_SALTLEN_MAX_SIGN
Usage in Deno
import { constants } from "node:crypto";
Sets the salt length for RSA_PKCS1_PSS_PADDING to the maximum permissible value when signing data.
Type #
number variable constants.RSA_SSLV23_PADDING
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.RSA_X931_PADDING
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.SSL_OP_ALL
Usage in Deno
import { constants } from "node:crypto";
Applies multiple bug workarounds within OpenSSL. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html for detail.
Type #
number variable constants.SSL_OP_ALLOW_NO_DHE_KEX
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to allow a non-[EC]DHE-based key exchange mode for TLS v1.3
Type #
number variable constants.SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
Usage in Deno
import { constants } from "node:crypto";
Allows legacy insecure renegotiation between OpenSSL and unpatched clients or servers. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html.
Type #
number variable constants.SSL_OP_CIPHER_SERVER_PREFERENCE
Usage in Deno
import { constants } from "node:crypto";
Attempts to use the server's preferences instead of the client's when selecting a cipher. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html.
Type #
number variable constants.SSL_OP_CISCO_ANYCONNECT
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to use Cisco's version identifier of DTLS_BAD_VER.
Type #
number variable constants.SSL_OP_COOKIE_EXCHANGE
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to turn on cookie exchange.
Type #
number variable constants.SSL_OP_CRYPTOPRO_TLSEXT_BUG
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to add server-hello extension from an early version of the cryptopro draft.
Type #
number variable constants.SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to disable a SSL 3.0/TLS 1.0 vulnerability workaround added in OpenSSL 0.9.6d.
Type #
number variable constants.SSL_OP_LEGACY_SERVER_CONNECT
Usage in Deno
import { constants } from "node:crypto";
Allows initial connection to servers that do not support RI.
Type #
number variable constants.SSL_OP_NO_COMPRESSION
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to disable support for SSL/TLS compression.
Type #
number variable constants.SSL_OP_NO_ENCRYPT_THEN_MAC
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to disable encrypt-then-MAC.
Type #
number variable constants.SSL_OP_NO_QUERY_MTU
Usage in Deno
import { constants } from "node:crypto";
Type #
number variable constants.SSL_OP_NO_RENEGOTIATION
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to disable renegotiation.
Type #
number variable constants.SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to always start a new session when performing renegotiation.
Type #
number variable constants.SSL_OP_NO_SSLv2
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to turn off SSL v2
Type #
number variable constants.SSL_OP_NO_SSLv3
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to turn off SSL v3
Type #
number variable constants.SSL_OP_NO_TICKET
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to disable use of RFC4507bis tickets.
Type #
number variable constants.SSL_OP_NO_TLSv1
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to turn off TLS v1
Type #
number variable constants.SSL_OP_NO_TLSv1_1
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to turn off TLS v1.1
Type #
number variable constants.SSL_OP_NO_TLSv1_2
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to turn off TLS v1.2
Type #
number variable constants.SSL_OP_NO_TLSv1_3
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to turn off TLS v1.3
Type #
number variable constants.SSL_OP_PRIORITIZE_CHACHA
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL server to prioritize ChaCha20-Poly1305 when the client does. This option has no effect if SSL_OP_CIPHER_SERVER_PREFERENCE is not enabled.
Type #
number variable constants.SSL_OP_TLS_ROLLBACK_BUG
Usage in Deno
import { constants } from "node:crypto";
Instructs OpenSSL to disable version rollback attack detection.
Type #
number variable crypto
Usage in Deno
import { crypto } from "node:crypto";
Type #
globalThis extends { crypto: infer T; onmessage: any; } ? T : webcrypto.Crypto type alias DiffieHellmanGroup
Usage in Deno
import { type DiffieHellmanGroup } from "node:crypto";
Definition #
Omit<DiffieHellman, "setPublicKey" | "setPrivateKey"> variable DiffieHellmanGroup
The DiffieHellmanGroup class takes a well-known modp group as its argument.
It works the same as DiffieHellman, except that it does not allow changing its keys after creation.
In other words, it does not implement setPublicKey() or setPrivateKey() methods.
const { createDiffieHellmanGroup } = await import('node:crypto');
const dh = createDiffieHellmanGroup('modp1');
The name (e.g. 'modp1') is taken from RFC 2412 (modp1 and 2) and RFC 3526:
$ perl -ne 'print "$1\n" if /"(modp\d+)"/' src/node_crypto_groups.h
modp1 # 768 bits
modp2 # 1024 bits
modp5 # 1536 bits
modp14 # 2048 bits
modp15 # etc.
modp16
modp17
modp18
Type #
namespace webcrypto
Usage in Deno
import { webcrypto } from "node:crypto";
Interfaces #
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.
The CryptoKeyPair is a simple dictionary object with publicKey and privateKey properties, representing an asymmetric key pair.
Type Aliases #
variable webcrypto
An implementation of the Web Crypto API standard.
See the Web Crypto API documentation for details.