Node.js v18.18.2 文档

确定加密支持是否不可用#

Node.js 可以在不包含对 node:crypto模块的支持的情况下构建。在这种情况下，尝试从crypto执行import或调用require('node:crypto')将导致抛出错误。

使用 CommonJS 时，可以使用 try/catch 捕获抛出的错误：

let crypto;
try {
  crypto = require('node:crypto');
} catch (err) {
  console.error('crypto support is disabled!');
} copy

当使用词法 ESM import关键字时，只有在尝试加载模块之前注册了 process.on('uncaughtException') 的处理程序（例如，使用预加载），才能捕获错误模块）。

使用 ESM 时，如果代码有可能在未启用加密支持的 Node.js 版本上运行，请考虑使用 import() 函数 而不是词法import关键字：

let crypto;
try {
  crypto = await import('node:crypto');
} catch (err) {
  console.error('crypto support is disabled!');
} copy

类：Certificate#

SPKAC 是一种证书签名请求机制，最初由 Netscape 实现，并被正式指定为 HTML5 的keygen元素的一部分。

自HTML 5.2起， <keygen>已被弃用，新项目不应再使用此元素。

node:crypto模块提供了用于处理 SPKAC 数据的Certificate类。最常见的用法是处理 HTML5 <keygen>元素生成的输出。Node.js 在内部使用OpenSSL 的 SPKAC 实现。

静态方法：Certificate.exportChallenge(spkac[, encoding])#

• spkac <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• encoding <string> spkac字符串的编码。
• 返回：<Buffer> spkac数据结构的质询组件，其中包括公钥和质询。

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 stringconst { Certificate } = require('node:crypto');
const spkac = getSpkacSomehow();
const challenge = Certificate.exportChallenge(spkac);
console.log(challenge.toString('utf8'));
// Prints: the challenge as a UTF8 stringcopy

静态方法：Certificate.exportPublicKey(spkac[, encoding])#

• spkac <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• encoding <string> spkac字符串的编码。
• 返回：<Buffer> spkac数据结构的公钥组成部分，其中包括公钥和质询。

const { Certificate } = await import('node:crypto');
const spkac = getSpkacSomehow();
const publicKey = Certificate.exportPublicKey(spkac);
console.log(publicKey);
// Prints: the public key as <Buffer ...>const { Certificate } = require('node:crypto');
const spkac = getSpkacSomehow();
const publicKey = Certificate.exportPublicKey(spkac);
console.log(publicKey);
// Prints: the public key as <Buffer ...>copy

静态方法：Certificate.verifySpkac(spkac[, encoding])#

• spkac <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• encoding <string> spkac字符串的编码。
• 返回：<boolean> true如果给定的spkac数据结构有效， 则false否则。

import { Buffer } from 'node:buffer';
const { Certificate } = await import('node:crypto');

const spkac = getSpkacSomehow();
console.log(Certificate.verifySpkac(Buffer.from(spkac)));
// Prints: true or falseconst { Buffer } = require('node:buffer');
const { Certificate } = require('node:crypto');

const spkac = getSpkacSomehow();
console.log(Certificate.verifySpkac(Buffer.from(spkac)));
// Prints: true or falsecopy

旧版 API#

作为旧接口，可以创建crypto.Certificate类的新实例，如下例所示。

new crypto.Certificate()#

可以使用 new 关键字或通过将 crypto.Certificate() 作为函数调用来创建 Certificate类的实例：

const { Certificate } = await import('node:crypto');

const cert1 = new Certificate();
const cert2 = Certificate();const { Certificate } = require('node:crypto');

const cert1 = new Certificate();
const cert2 = Certificate();copy

certificate.exportChallenge(spkac[, encoding])#

• spkac <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• encoding <string> spkac字符串的编码。
• 返回：<Buffer> spkac数据结构的质询组件，其中包括公钥和质询。

const { Certificate } = await import('node:crypto');
const cert = Certificate();
const spkac = getSpkacSomehow();
const challenge = cert.exportChallenge(spkac);
console.log(challenge.toString('utf8'));
// Prints: the challenge as a UTF8 stringconst { Certificate } = require('node:crypto');
const cert = Certificate();
const spkac = getSpkacSomehow();
const challenge = cert.exportChallenge(spkac);
console.log(challenge.toString('utf8'));
// Prints: the challenge as a UTF8 stringcopy

certificate.exportPublicKey(spkac[, encoding])#

• spkac <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• encoding <string> spkac字符串的编码。
• 返回：<Buffer> spkac数据结构的公钥组成部分，其中包括公钥和质询。

const { Certificate } = await import('node:crypto');
const cert = Certificate();
const spkac = getSpkacSomehow();
const publicKey = cert.exportPublicKey(spkac);
console.log(publicKey);
// Prints: the public key as <Buffer ...>const { Certificate } = require('node:crypto');
const cert = Certificate();
const spkac = getSpkacSomehow();
const publicKey = cert.exportPublicKey(spkac);
console.log(publicKey);
// Prints: the public key as <Buffer ...>copy

certificate.verifySpkac(spkac[, encoding])#

• spkac <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• encoding <string> spkac字符串的编码。
• 返回：如果给定的spkac数据结构有效， 则返回<boolean> true ，否则返回 false。

import { Buffer } from 'node:buffer';
const { Certificate } = await import('node:crypto');

const cert = Certificate();
const spkac = getSpkacSomehow();
console.log(cert.verifySpkac(Buffer.from(spkac)));
// Prints: true or falseconst { Buffer } = require('node:buffer');
const { Certificate } = require('node:crypto');

const cert = Certificate();
const spkac = getSpkacSomehow();
console.log(cert.verifySpkac(Buffer.from(spkac)));
// Prints: true or falsecopy

类：Cipher#

• 扩展：<stream.Transform>

Cipher类的实例用于加密数据。该类可以通过以下两种方式之一使用：

• 作为可读可写的流，写入纯未加密数据以在可读端生成加密数据，或者
• 使用cipher.update()和cipher.final()方法生成加密数据。

crypto.createCipher()或crypto.createCipheriv()方法用于创建Cipher实例。不应使用new 关键字直接创建 Cipher对象。

示例：使用Cipher对象作为流：

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();
  });
});const {
  scrypt,
  randomFill,
  createCipheriv,
} = require('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();
  });
});copy

示例：使用Cipher和管道流：

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;
    });
  });
});const {
  createReadStream,
  createWriteStream,
} = require('node:fs');

const {
  pipeline,
} = require('node:stream');

const {
  scrypt,
  randomFill,
  createCipheriv,
} = require('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;
    });
  });
});copy

示例：使用cipher.update()和cipher.final()方法：

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);
  });
});const {
  scrypt,
  randomFill,
  createCipheriv,
} = require('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);
  });
});copy

cipher.final([outputEncoding])#

• outputEncoding <string>返回值的编码。
• 返回：<缓冲区> | <string>任何剩余的加密内容。如果指定了outputEncoding，则返回一个字符串。如果未提供outputEncoding ，则返回Buffer 。

一旦调用了cipher.final()方法， Cipher对象就不能再用于加密数据。尝试多次调用cipher.final()将导致抛出错误。

cipher.getAuthTag()#

• 返回：<Buffer>当使用经过身份验证的加密模式（当前支持 GCM、CCM、 OCB和chacha20-poly1305 ）时， cipher.getAuthTag()方法返回一个 Buffer，其中包含根据给定数据计算出的身份验证标记。

仅应在使用cipher.final()方法完成加密后调用cipher.getAuthTag()方法。

如果在创建cipher实例期间设置了authTagLength选项，则此函数将恰好返回authTagLength字节。

cipher.setAAD(buffer[, options])#

• buffer <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• options <对象> stream.transform选项
  • plaintextLength <数字>
  • encoding <string>当buffer是字符串时使用的字符串编码。
• 返回：<Cipher>用于方法链接。

当使用经过身份验证的加密模式（当前支持GCM、CCM、OCB和 chacha20-poly1305 ）时， cipher.setAAD()方法设置用于附加身份验证数据(AAD) 输入参数的值 。

对于GCM和OCB ， plaintextLength选项是可选的。使用CCM时，必须指定plaintextLength选项，并且其值必须与明文长度（以字节为单位）匹配。请参阅CCM 模式。

必须在cipher.update()之前调用cipher.setAAD()方法。

cipher.setAutoPadding([autoPadding])#

• autoPadding <布尔值> 默认值： true
• 返回：<Cipher>用于方法链接。

使用块加密算法时，Cipher类会自动向输入数据添加填充，以达到适当的块大小。要禁用默认填充，请调用cipher.setAutoPadding(false)。

当autoPadding为false时，整个输入数据的长度必须是密码块大小的倍数，否则cipher.final()将引发错误。禁用自动填充对于非标准填充非常有用，例如使用0x0而不是 PKCS 填充。

必须在cipher.final()之前调用 cipher.setAutoPadding()方法。

cipher.update(data[, inputEncoding][, outputEncoding])#

• data <字符串> | <缓冲区> | <类型化数组> | <数据视图>
• inputEncoding <string>数据的编码。
• outputEncoding <string>返回值的编码。
• 返回：<缓冲区> | <字符串>

使用data更新密码。如果给出了inputEncoding参数，则 data 参数是使用指定编码的字符串。如果 未给出inputEncoding参数，则data必须是Buffer、TypedArray或 DataView。如果data是Buffer、TypedArray或DataView，则 inputEncoding会被忽略。

outputEncoding指定加密数据的输出格式。如果指定了outputEncoding ，则返回使用指定编码的字符串。如果未 提供outputEncoding ，则返回Buffer 。

可以使用新数据多次调用 cipher.update()方法，直到调用cipher.final()为止。在cipher.final()之后 调用cipher.update()将导致抛出错误。

类：Decipher#

• 扩展：<stream.Transform>

Decipher类的实例用于解密数据。该类可以通过以下两种方式之一使用：

• 作为可读可写的流，其中写入明文加密数据以在可读端生成未加密数据，或者
• 使用decipher.update()和decipher.final()方法生成未加密的数据。

crypto.createDecipher()或crypto.createDecipheriv()方法用于创建Decipher实例。Decipher对象不能直接使用new关键字创建。

示例：使用Decipher对象作为流：

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();const {
  scryptSync,
  createDecipheriv,
} = require('node:crypto');
const { Buffer } = require('node:buffer');

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

示例：使用Decipher和管道流：

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);const {
  createReadStream,
  createWriteStream,
} = require('node:fs');
const {
  scryptSync,
  createDecipheriv,
} = require('node:crypto');
const { Buffer } = require('node:buffer');

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

示例：使用decipher.update()和decipher.final()方法：

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 dataconst {
  scryptSync,
  createDecipheriv,
} = require('node:crypto');
const { Buffer } = require('node:buffer');

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 datacopy

decipher.final([outputEncoding])#

• outputEncoding <string>返回值的编码。
• 返回：<缓冲区> | <string>任何剩余的解密内容。如果指定了outputEncoding，则返回一个字符串。如果未提供outputEncoding ，则返回Buffer 。

一旦调用了decipher.final()方法， Decipher对象就不能再用于解密数据。尝试多次调用decipher.final()将导致抛出错误。

decipher.setAAD(buffer[, options])#

• buffer <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• options <对象> stream.transform选项
  • plaintextLength <数字>
  • encoding <string>当buffer是字符串时使用的字符串编码。
• 返回：<Decipher>用于方法链接。

当使用经过身份验证的加密模式（当前支持GCM、CCM、OCB和 chacha20-poly1305 ）时， decipher.setAAD()方法设置用于附加身份验证数据(AAD) 输入参数的值 。

对于GCM来说， options参数是可选的。使用CCM时， 必须指定plaintextLength选项，并且其值必须与密文长度（以字节为单位）匹配。请参阅CCM 模式。

必须在decipher.update()之前调用decipher.setAAD()方法。

将字符串作为buffer传递时，请考虑 使用字符串作为加密 API 的输入时的注意事项。

decipher.setAuthTag(buffer[, encoding])#

• buffer <字符串> | <缓冲区> | <数组缓冲区> | <类型化数组> | <数据视图>
• encoding <string>当buffer是字符串时使用的字符串编码。
• 返回：<Decipher>用于方法链接。

当使用经过身份验证的加密模式（当前支持GCM、CCM、OCB和 chacha20-poly1305 ）时， decipher.setAuthTag()方法用于传入接收到的认证标签。如果没有提供标签，或者密文被篡改，则会抛出decipher.final()，表示由于认证失败，密文应被丢弃。如果标签长度根据NIST SP 800-38D无效或与authTagLength选项的值不匹配 ，则decipher.setAuthTag()将引发错误。

对于CCM模式，必须在decipher.update()之前调用decipher.setAuthTag()方法；对于GCM和OCB模式和 chacha20-poly1305。 decipher.setAuthTag()只能调用一次。

当传递字符串作为身份验证标签时，请考虑 使用字符串作为加密 API 的输入时的注意事项。

decipher.setAutoPadding([autoPadding])#

• autoPadding <布尔值> 默认值： true
• 返回：<Decipher>用于方法链接。

当数据在没有标准块填充的情况下进行加密时，调用 decipher.setAutoPadding(false)将禁用自动填充，以防止 decipher.final()检查和删除填充。

仅当输入数据的长度是密码块大小的倍数时，关闭自动填充才有效。

必须在decipher.final()之前调用 decipher.setAutoPadding()方法。

decipher.update(data[, inputEncoding][, outputEncoding])#

• data <字符串> | <缓冲区> | <类型化数组> | <数据视图>
• inputEncoding <string> data字符串的编码。
• outputEncoding <string>返回值的编码。
• 返回：<缓冲区> | <字符串>

使用data更新解密。如果给出了inputEncoding参数，则 data 参数是使用指定编码的字符串。如果 未给出inputEncoding参数，则 data必须是Buffer。如果data是 Buffer，则inputEncoding将被忽略。

outputEncoding指定加密数据的输出格式。如果指定了outputEncoding ，则返回使用指定编码的字符串。如果未 提供outputEncoding ，则返回Buffer 。

可以使用新数据多次调用 decipher.update()方法，直到调用decipher.final()为止。在decipher.final()之后 调用decipher.update()将导致抛出错误。

类：DiffieHellman#

DiffieHellman类是用于创建 Diffie-Hellman 密钥交换的实用程序。

可以使用 crypto.createDiffieHellman()函数创建DiffieHellman类的实例。

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'));const assert = require('node:assert');

const {
  createDiffieHellman,
} = require('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'));copy

diffieHellman.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])#

• otherPublicKey <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• inputEncoding <string> otherPublicKey字符串的编码。
• outputEncoding <string>返回值的编码。
• 返回：<缓冲区> | <字符串>

使用otherPublicKey作为另一方的公钥计算共享密钥，并返回计算出的共享密钥。提供的密钥使用指定的inputEncoding进行解释，秘密使用指定的outputEncoding进行编码。如果未提供inputEncoding ，则otherPublicKey预计为Buffer、 TypedArray或DataView。

如果给定outputEncoding则返回一个字符串；否则， 返回Buffer 。

diffieHellman.generateKeys([encoding])#

• encoding <string>返回值的编码。
• 返回：<缓冲区> | <字符串>

生成私有和公共 Diffie-Hellman 密钥值（除非它们已生成或计算），并返回指定的encoding中的公钥。这个密钥应该转移给对方。如果提供了encoding，则返回一个字符串；否则 返回Buffer 。

此函数是DH_generate_key()的薄包装。特别是，一旦生成或设置了私钥，调用此函数只会更新公钥，但不会生成新的私钥。

diffieHellman.getGenerator([encoding])#

• encoding <string>返回值的编码。
• 返回：<缓冲区> | <字符串>

返回指定的encoding中的 Diffie-Hellman 生成器。如果提供了encoding，则返回一个字符串；否则返回Buffer 。

diffieHellman.getPrime([encoding])#

• encoding <string>返回值的编码。
• 返回：<缓冲区> | <字符串>

返回指定encoding中的 Diffie-Hellman 素数。如果提供了encoding，则返回一个字符串；否则返回Buffer 。

diffieHellman.getPrivateKey([encoding])#

• encoding <string>返回值的编码。
• 返回：<缓冲区> | <字符串>

返回指定的encoding中的 Diffie-Hellman 私钥。如果提供了encoding，则返回一个字符串；否则返回Buffer 。

diffieHellman.getPublicKey([encoding])#

• encoding <string>返回值的编码。
• 返回：<缓冲区> | <字符串>

返回指定encoding中的 Diffie-Hellman 公钥。如果提供了encoding，则返回一个字符串；否则返回Buffer 。

diffieHellman.setPrivateKey(privateKey[, encoding])#

• privateKey <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• encoding <string> privateKey字符串的编码。

设置 Diffie-Hellman 私钥。如果提供了 encoding参数，则privateKey应该是一个字符串。如果未提供encoding ，则privateKey预计为Buffer、TypedArray或DataView。

此函数不会自动计算关联的公钥。可以 使用diffieHellman.setPublicKey()或diffieHellman.generateKeys()手动提供公钥或自动导出公钥。

diffieHellman.setPublicKey(publicKey[, encoding])#

• publicKey <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• encoding <string> publicKey字符串的编码。

设置 Diffie-Hellman 公钥。如果提供了 encoding参数，则publicKey应该是一个字符串。如果未提供encoding ，则publicKey预计为Buffer、TypedArray或DataView。

diffieHellman.verifyError#

包含在DiffieHellman对象初始化期间执行的检查所产生的任何警告和/或错误的位字段。

以下值对此属性有效（如node:constants模块中所定义）：

• DH_CHECK_P_NOT_SAFE_PRIME
• DH_CHECK_P_NOT_PRIME
• DH_UNABLE_TO_CHECK_GENERATOR
• DH_NOT_SUITABLE_GENERATOR

类：DiffieHellmanGroup#

DiffieHellmanGroup类采用众所周知的 modp 组作为其参数。它的工作原理与DiffieHellman相同，只是它不允许在创建后更改其键。换句话说，它不实现setPublicKey() 或setPrivateKey()方法。

const { createDiffieHellmanGroup } = await import('node:crypto');
const dh = createDiffieHellmanGroup('modp16');const { createDiffieHellmanGroup } = require('node:crypto');
const dh = createDiffieHellmanGroup('modp16');copy

支持以下组：

• 'modp14'（2048 位，RFC 3526第 3 节）
• 'modp15'（3072 位，RFC 3526第 4 节）
• 'modp16'（4096 位，RFC 3526第 5 节）
• 'modp17'（6144 位，RFC 3526第 6 节）
• 'modp18'（8192 位，RFC 3526第 7 节）

以下组仍然受支持但已弃用（请参阅注意事项）：

• 'modp1'（768 位，RFC 2409第 6.1 节）
• 'modp2'（1024 位，RFC 2409第 6.2 节）
• 'modp5'（1536 位，RFC 3526第 2 部分）

这些已弃用的组可能会在 Node.js 的未来版本中删除。

类：ECDH#

ECDH类是用于创建椭圆曲线 Diffie-Hellman (ECDH) 密钥交换的实用程序。

可以使用 crypto.createECDH()函数创建ECDH 类的实例。

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'));
// OKconst assert = require('node:assert');

const {
  createECDH,
} = require('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'));
// OKcopy

静态方法：ECDH.convertKey(key, curve[, inputEncoding[, outputEncoding[, format]]])#

• key <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• curve <字符串>
• inputEncoding <string> key字符串的编码。
• outputEncoding <string>返回值的编码。
• format <字符串> 默认： 'uncompressed'
• 返回：<缓冲区> | <字符串>

将key和curve指定的 EC Diffie-Hellman 公钥转换为format指定的格式。format参数指定点编码，可以是'compressed'、'uncompressed'或'hybrid'。提供的密钥使用指定的inputEncoding进行解释，返回的密钥使用指定的outputEncoding进行编码。

使用crypto.getCurves()获取可用曲线名称的列表。在最近的 OpenSSL 版本中，openssl ecparam -list_curves还将显示每个可用椭圆曲线的名称和描述。

如果未指定format，则点将以'uncompressed' 格式返回。

如果未提供inputEncoding ，则key预计为Buffer、 TypedArray或DataView。

示例（解压缩密钥）：

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'));const {
  createECDH,
  ECDH,
} = require('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'));copy

ecdh.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])#

• otherPublicKey <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• inputEncoding <string> otherPublicKey字符串的编码。
• outputEncoding <string>返回值的编码。
• 返回：<缓冲区> | <字符串>

使用otherPublicKey作为另一方的公钥计算共享密钥，并返回计算出的共享密钥。提供的密钥使用指定的inputEncoding进行解释，返回的密钥使用指定的outputEncoding进行编码。如果未提供inputEncoding ，则otherPublicKey预计为Buffer、TypedArray或 DataView。

如果给出outputEncoding将返回一个字符串；否则 返回Buffer 。

当otherPublicKey 位于椭圆曲线之外时， ecdh.computeSecret将抛出 ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY错误。由于otherPublicKey通常是由远程用户通过不安全的网络提供的，因此请务必相应地处理此异常。

ecdh.generateKeys([encoding[, format]])#

• encoding <string>返回值的编码。
• format <字符串> 默认值： 'uncompressed'
• 返回：<缓冲区> | <字符串>

生成私有和公共 EC Diffie-Hellman 密钥值，并返回指定的format和encoding中的公钥。这个密钥应该转移给对方。

format参数指定点编码，可以是'compressed'或 'uncompressed'。如果未指定format，则该点将以 'uncompressed'格式返回。

如果提供了encoding，则返回一个字符串；否则 返回Buffer 。

ecdh.getPrivateKey([encoding])#

• encoding <string>返回值的编码。
• 返回：<缓冲区> | <string>指定encoding中的 EC Diffie-Hellman 。

如果指定了encoding，则返回一个字符串；否则返回Buffer 。

ecdh.getPublicKey([encoding][, format])#

• encoding <string>返回值的编码。
• format <字符串> 默认值： 'uncompressed'
• 返回：<缓冲区> | <string>指定的encoding和format中的 EC Diffie-Hellman 公钥 。

format参数指定点编码，可以是'compressed'或 'uncompressed'。如果未指定format ，则点将以 'uncompressed'格式返回。

如果指定了encoding，则返回一个字符串；否则返回Buffer 。

ecdh.setPrivateKey(privateKey[, encoding])#

• privateKey <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• encoding <string> privateKey字符串的编码。

设置 EC Diffie-Hellman 私钥。如果提供了encoding ，则privateKey应该是一个字符串；否则privateKey预计为Buffer、 TypedArray或DataView。

如果privateKey对于创建ECDH对象时指定的曲线无效，则会引发错误。设置私钥后，还会生成关联的公共点（密钥）并将其设置在ECDH对象中。

ecdh.setPublicKey(publicKey[, encoding])#

• publicKey <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• encoding <string> publicKey字符串的编码。

设置 EC Diffie-Hellman 公钥。如果提供了encoding，则publicKey应该是一个字符串；否则应为Buffer、TypedArray或DataView 。

通常没有理由调用此方法，因为ECDH 仅需要私钥和另一方的公钥来计算共享秘密。通常会调用ecdh.generateKeys()或 ecdh.setPrivateKey() 。ecdh.setPrivateKey()方法尝试生成与所设置的私钥关联的公共点/密钥。

示例（获取共享秘密）：

const {
  createECDH,
  createHash,
} = await import('node:crypto');

const alice = createECDH('secp256k1');
const bob = createECDH('secp256k1');

// This is a shortcut way of specifying one of Alice's previous private
// keys. It would be unwise to use such a predictable private key in a real
// application.
alice.setPrivateKey(
  createHash('sha256').update('alice', 'utf8').digest(),
);

// Bob uses a newly generated cryptographically strong
// pseudorandom key pair
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 shared secret value
console.log(aliceSecret === bobSecret);const {
  createECDH,
  createHash,
} = require('node:crypto');

const alice = createECDH('secp256k1');
const bob = createECDH('secp256k1');

// This is a shortcut way of specifying one of Alice's previous private
// keys. It would be unwise to use such a predictable private key in a real
// application.
alice.setPrivateKey(
  createHash('sha256').update('alice', 'utf8').digest(),
);

// Bob uses a newly generated cryptographically strong
// pseudorandom key pair
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 shared secret value
console.log(aliceSecret === bobSecret);copy

类：Hash#

• 扩展：<stream.Transform>

Hash类是用于创建数据哈希摘要的实用程序。它可以通过以下两种方式之一使用：

• 作为可读可写的流，其中写入数据以在可读端生成计算的哈希摘要，或者
• 使用hash.update()和hash.digest()方法生成计算的哈希值。

crypto.createHash()方法用于创建Hash实例。 不应使用new关键字直接创建 Hash 对象。

示例：使用Hash对象作为流：

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();const {
  createHash,
} = require('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();copy

示例：使用Hash和管道流：

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);const { createReadStream } = require('node:fs');
const { createHash } = require('node:crypto');
const { stdout } = require('node:process');

const hash = createHash('sha256');

const input = createReadStream('test.js');
input.pipe(hash).setEncoding('hex').pipe(stdout);copy

示例：使用hash.update()和hash.digest()方法：

const {
  createHash,
} = await import('node:crypto');

const hash = createHash('sha256');

hash.update('some data to hash');
console.log(hash.digest('hex'));
// Prints:
//   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50const {
  createHash,
} = require('node:crypto');

const hash = createHash('sha256');

hash.update('some data to hash');
console.log(hash.digest('hex'));
// Prints:
//   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50copy

hash.copy([options])#

• options <对象> stream.transform选项
• 返回：<哈希值>

创建一个新的Hash对象，其中包含当前Hash对象的内部状态的深层副本。

可选的options参数控制流行为。对于 XOF 哈希函数（例如'shake256' ），可以使用outputLength选项指定所需的输出长度（以字节为单位）。

在调用hash.digest()方法后尝试复制Hash对象时，会引发错误。

// 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.// Calculate a rolling hash.
const {
  createHash,
} = require('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.copy

hash.digest([encoding])#

• encoding <string>返回值的编码。
• 返回：<缓冲区> | <字符串>

计算要进行哈希处理的所有数据的摘要（使用 hash.update()方法）。如果提供了encoding将返回一个字符串；否则返回Buffer 。

调用hash.digest()方法后，无法再次使用Hash对象。多次调用将导致抛出错误。

hash.update(data[, inputEncoding])#

• data <字符串> | <缓冲区> | <类型化数组> | <数据视图>
• inputEncoding <string> data字符串的编码。

使用给定的data更新哈希内容，其编码在inputEncoding中给出。如果未提供encoding ，并且data是字符串，则强制执行'utf8'编码。如果data是Buffer、TypedArray或 DataView，则inputEncoding会被忽略。

当新数据流式传输时，可以多次调用此方法。

类：Hmac#

• 扩展：<stream.Transform>

Hmac类是用于创建加密 HMAC 摘要的实用程序。它可以通过以下两种方式之一使用：

• 作为可读可写的流，写入数据以在可读端生成计算出的 HMAC 摘要，或者
• 使用hmac.update()和hmac.digest()方法生成计算的 HMAC 摘要。

crypto.createHmac()方法用于创建Hmac实例。Hmac 对象不能直接使用new关键字创建。

示例：使用Hmac对象作为流：

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();const {
  createHmac,
} = require('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();copy

示例：使用Hmac和管道流：

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);const {
  createReadStream,
} = require('node:fs');
const {
  createHmac,
} = require('node:crypto');
const { stdout } = require('node:process');

const hmac = createHmac('sha256', 'a secret');

const input = createReadStream('test.js');
input.pipe(hmac).pipe(stdout);copy

示例：使用hmac.update()和hmac.digest()方法：

const {
  createHmac,
} = await import('node:crypto');

const hmac = createHmac('sha256', 'a secret');

hmac.update('some data to hash');
console.log(hmac.digest('hex'));
// Prints:
//   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77econst {
  createHmac,
} = require('node:crypto');

const hmac = createHmac('sha256', 'a secret');

hmac.update('some data to hash');
console.log(hmac.digest('hex'));
// Prints:
//   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77ecopy

hmac.digest([encoding])#

• encoding <string>返回值的编码。
• 返回：<缓冲区> | <字符串>

计算使用hmac.update()传递的所有数据的 HMAC 摘要。如果提供了encoding，则返回一个字符串；否则返回Buffer ；

调用hmac.digest()后，不能再次使用Hmac对象。多次调用hmac.digest()将导致抛出错误。

hmac.update(data[, inputEncoding])#

• data <字符串> | <缓冲区> | <类型化数组> | <数据视图>
• inputEncoding <string> data字符串的编码。

使用给定的data更新Hmac内容，其编码在inputEncoding中给出。如果未提供encoding ，并且data是字符串，则强制执行'utf8'编码。如果data是Buffer、TypedArray或 DataView，则inputEncoding会被忽略。

当新数据流式传输时，可以多次调用此方法。

类：KeyObject#

Node.js 使用KeyObject类来表示对称或非对称密钥，每种密钥公开不同的函数。 crypto.createSecretKey()、crypto.createPublicKey()和 crypto.createPrivateKey()方法用于创建KeyObject 实例。不应使用new 关键字直接创建 KeyObject对象 。

由于改进的安全功能，大多数应用程序应考虑使用新的KeyObject API，而不是将密钥作为字符串或Buffer传递。

KeyObject实例可以通过postMessage()传递给其他线程。接收方获得克隆的KeyObject，并且KeyObject不需要在transferList参数中列出。

静态方法：KeyObject.from(key)#

• key <加密密钥>
• 返回：<KeyObject>

示例：将CryptoKey实例转换为KeyObject：

const { webcrypto, KeyObject } = await import('node:crypto');
const { subtle } = webcrypto;

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)const {
  webcrypto: {
    subtle,
  },
  KeyObject,
} = require('node:crypto');

(async function() {
  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)
})();copy

keyObject.asymmetricKeyDetails#

• <对象>
  • modulusLength：<number>密钥大小（以位为单位）（RSA、DSA）。
  • publicExponent：<bigint>公共索引 (RSA)。
  • hashAlgorithm：<string>消息摘要的名称 (RSA-PSS)。
  • mgf1HashAlgorithm：<string> MGF1 (RSA-PSS) 使用的消息摘要的名称。
  • saltLength：<number>最小盐长度（以字节为单位）(RSA-PSS)。
  • divisorLength：<number> q的大小（以位 (DSA) 为单位）。
  • namedCurve : <string>曲线名称 (EC)。

此属性仅存在于非对称密钥上。根据密钥的类型，该对象包含有关密钥的信息。通过此属性获得的任何信息都不能用于唯一标识密钥或损害密钥的安全性。

对于 RSA-PSS 密钥，如果密钥材料包含RSASSA-PSS-params序列，则将设置 hashAlgorithm、mgf1HashAlgorithm和saltLength属性。

其他关键细节可能会通过此 API 使用附加属性公开。

keyObject.asymmetricKeyType#

• <字符串>

对于非对称密钥，此属性表示密钥的类型。支持的密钥类型有：

• '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）

对于无法识别的KeyObject类型和对称密钥，此属性为undefined 。

keyObject.export([options])#

• options：<对象>
• 返回：<字符串> | <缓冲区> | <对象>

对于对称密钥，可以使用以下编码选项：

• format：<string>必须为'buffer'（默认）或'jwk'。

对于公钥，可以使用以下编码选项：

• type：<string>必须是'pkcs1'（仅限 RSA）或'spki'之一。
• format：<string>必须是'pem'、'der'或'jwk'。

对于私钥，可以使用以下编码选项：

• type：<string>必须是'pkcs1'（仅限 RSA）、'pkcs8'或 'sec1'（仅限 EC）之一。
• format：<string>必须是'pem'、'der'或'jwk'。
• cipher：<string>如果指定，则将使用基于 PKCS#5 v2.0 密码的加密，使用给定的cipher和passphrase来加密私钥。
• passphrase : <字符串> | <Buffer>用于加密的密码，请参阅 cipher。

结果类型取决于所选的编码格式，当 PEM 时结果是字符串，当 DER 时结果将是包含编码为 DER 的数据的缓冲区，当JWK时结果将是对象。

当选择JWK编码格式时，所有其他编码选项都将被忽略。

可以使用cipher和format选项的组合来加密 PKCS#1、SEC1 和 PKCS#8 类型密钥。PKCS#8 type可以与任何format一起使用 ，通过指定cipher来加密任何密钥算法（RSA、EC 或 DH） 。当使用 PEM format时，只能通过指定cipher来加密 PKCS#1 和 SEC1 。为了获得最大兼容性，请使用 PKCS#8 作为加密私钥。由于 PKCS#8 定义了自己的加密机制，因此在加密 PKCS#8 密钥时不支持 PEM 级加密。有关 PKCS#8 加密的信息，请参阅RFC 5208 ；有关 PKCS#1 和 SEC1 加密的信息，请参阅RFC 1421。

keyObject.equals(otherKeyObject)#

• otherKeyObject：<KeyObject>与KeyObject进行比较的keyObject。
• 返回：<布尔值>

根据键是否具有完全相同的类型、值和参数，返回true或false 。此方法不是 常数时间。

keyObject.symmetricKeySize#

• <数字>

对于秘密密钥，此属性表示密钥的大小（以字节为单位）。对于非对称密钥，此属性为undefined。

keyObject.type#

• <字符串>

根据此KeyObject的类型，此属性 对于秘密（对称）密钥为'secret' ，对于公共（非对称）密钥为'public'或'private'用于私钥（非对称）。

类：Sign#

• 扩展：<stream.Writable>

Sign类是用于生成签名的实用程序。它可以通过以下两种方式之一使用：

• 作为可写流，写入要签名的数据，并 使用sign.sign()方法生成并返回签名，或者
• 使用sign.update()和sign.sign()方法生成签名。

crypto.createSign()方法用于创建Sign实例。参数是要使用的哈希函数的字符串名称。Sign对象不能直接使用new关键字创建。

示例：使用Sign和Verify对象作为流：

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: trueconst {
  generateKeyPairSync,
  createSign,
  createVerify,
} = require('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: truecopy

示例：使用sign.update()和verify.update()方法：

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: trueconst {
  generateKeyPairSync,
  createSign,
  createVerify,
} = require('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: truecopy

sign.sign(privateKey[, outputEncoding])#

• privateKey <对象> | <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图> | <关键对象> | <加密密钥>
  • dsaEncoding <字符串>
  • padding <整数>
  • saltLength <整数>
• outputEncoding <string>返回值的编码。
• 返回：<缓冲区> | <字符串>

使用sign.update()或sign.write()计算传递的所有数据的签名 。

如果privateKey不是KeyObject，则此函数的行为就像 privateKey已传递给crypto.createPrivateKey()。如果它是一个对象，可以传递以下附加属性：

• dsaEncoding <string>对于 DSA 和 ECDSA，此选项指定生成的签名的格式。它可以是以下之一：

  • 'der'（默认）：DER 编码的 ASN.1 签名结构编码(r, s)。
  • 'ieee-p1363' ： IEEE-P1363 中建议的签名格式r || s 。

• padding <integer> RSA 的可选填充值，以下之一：

  • crypto.constants.RSA_PKCS1_PADDING（默认）
  • crypto.constants.RSA_PKCS1_PSS_PADDING

  RSA_PKCS1_PSS_PADDING将使用 MGF1，其哈希函数与用于对RFC 4055第 3.1 节中指定的消息进行签名的哈希函数相同，除非已按照RFC 4055第 3.3 节的规定将 MGF1 哈希函数指定为密钥的一部分。

• saltLength <integer>当填充为 RSA_PKCS1_PSS_PADDING时的盐长度。特殊值 crypto.constants.RSA_PSS_SALTLEN_DIGEST将盐长度设置为摘要大小，crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN（默认）将其设置为最大允许值。

如果提供了outputEncoding，则返回一个字符串；否则 返回Buffer 。

调用 sign.sign() 方法后，不能再次使用Sign对象。多次调用sign.sign()将导致抛出错误。

sign.update(data[, inputEncoding])#

• data <字符串> | <缓冲区> | <类型化数组> | <数据视图>
• inputEncoding <string> data字符串的编码。

使用给定的data更新Sign内容，其编码在inputEncoding中给出。如果未提供encoding ，并且data是字符串，则强制执行'utf8'编码。如果data是Buffer、TypedArray或 DataView，则inputEncoding会被忽略。

当新数据流式传输时，可以多次调用此方法。

类：Verify#

• 扩展：<stream.Writable>

Verify类是用于验证签名的实用程序。它可以通过以下两种方式之一使用：

• 作为可写流，其中写入的数据用于根据提供的签名进行验证，或者
• 使用verify.update()和verify.verify()方法来验证签名。

crypto.createVerify()方法用于创建Verify实例。 Verify对象不能直接使用new关键字创建。

有关示例，请参阅Sign。

verify.update(data[, inputEncoding])#

• data <字符串> | <缓冲区> | <类型化数组> | <数据视图>
• inputEncoding <string> data字符串的编码。

使用给定的data更新Verify内容，其编码在inputEncoding中给出。如果未提供inputEncoding ，并且data是字符串，则强制执行'utf8'编码。如果data是Buffer、TypedArray或 DataView，则inputEncoding会被忽略。

当新数据流式传输时，可以多次调用此方法。

verify.verify(object, signature[, signatureEncoding])#

• object <对象> | <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图> | <关键对象> | <加密密钥>
  • dsaEncoding <字符串>
  • padding <整数>
  • saltLength <整数>
• signature <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• signatureEncoding <string> signature字符串的编码。
• 返回：<boolean> true或false，具体取决于数据和公钥签名的有效性。

使用给定的object和signature验证提供的数据。

如果object不是KeyObject，则此函数的行为就像 object已传递给crypto.createPublicKey()。如果它是一个对象，可以传递以下附加属性：

• dsaEncoding <string>对于 DSA 和 ECDSA，此选项指定签名的格式。它可以是以下之一：

  • 'der'（默认）：DER 编码的 ASN.1 签名结构编码(r, s)。
  • 'ieee-p1363' ： IEEE-P1363 中建议的签名格式r || s 。

• padding <integer> RSA 的可选填充值，以下之一：

  • crypto.constants.RSA_PKCS1_PADDING（默认）
  • crypto.constants.RSA_PKCS1_PSS_PADDING

  RSA_PKCS1_PSS_PADDING将使用 MGF1，其哈希函数与RFC 4055第 3.1 节中指定的用于验证消息的哈希函数相同，除非已按照RFC 4055第 3.3 节的规定将 MGF1 哈希函数指定为密钥的一部分。

• saltLength <integer>当填充为 RSA_PKCS1_PSS_PADDING时的盐长度。特殊值 crypto.constants.RSA_PSS_SALTLEN_DIGEST将盐长度设置为摘要大小，crypto.constants.RSA_PSS_SALTLEN_AUTO（默认）会自动确定它。

signature参数是先前计算的数据签名，位于signatureEncoding中。如果指定了signatureEncoding ，则signature应该是一个字符串；否则signature预计为Buffer、 TypedArray或DataView。

调用verify.verify()后，无法再次使用verify对象。多次调用verify.verify()将导致抛出错误。

由于公钥可以从私钥导出，因此可以传递私钥而不是公钥。

类：X509Certificate#

封装 X509 证书并提供对其信息的只读访问。

const { X509Certificate } = await import('node:crypto');

const x509 = new X509Certificate('{... pem encoded cert ...}');

console.log(x509.subject);const { X509Certificate } = require('node:crypto');

const x509 = new X509Certificate('{... pem encoded cert ...}');

console.log(x509.subject);copy

new X509Certificate(buffer)#

• buffer <字符串> | <类型化数组> | <缓冲区> | <Da​​taView> PEM 或 DER 编码的 X509 证书。

x509.ca#

• 类型：<boolean>如果这是证书颁发机构 (CA) 证书，则将为true 。

x509.checkEmail(email[, options])#

• email <字符串>
• options <对象>
  • subject <字符串> 'default'、'always'或'never'。 默认值： 'default'。
• 返回：<字符串> | <undefined>如果证书匹配，则 返回email ，如果不匹配，则返回 undefined 。

检查证书是否与给定的电子邮件地址匹配。

如果'subject'选项未定义或设置为'default'，则仅当主题备用名称扩展不存在或不包含任何电子邮件地址时才考虑证书主题。

如果'subject'选项设置为'always'，并且主题备用名称扩展不存在或不包含匹配的电子邮件地址，则将考虑证书主题。

如果'subject'选项设置为'never'，则永远不会考虑证书主题，即使证书不包含主题备用名称。

x509.checkHost(name[, options])#

• name <字符串>
• options <对象>
  • subject <字符串> 'default'、'always'或'never'。 默认值： 'default'。
  • wildcards <布尔值> 默认值： true。
  • partialWildcards <布尔值> 默认值： true。
  • multiLabelWildcards <布尔值> 默认值： false。
  • singleLabelSubdomains <布尔值> 默认值： false。
• 返回：<字符串> | <undefined>返回与name匹配的主题名称，如果没有主题名称与name匹配，则返回 undefined。

检查证书是否与给定的主机名匹配。

如果证书与给定的主机名匹配，则返回匹配的主题名称。返回的名称可能是完全匹配的（例如，foo.example.com），也可能包含通配符（例如，*.example.com）。由于主机名比较不区分大小写，因此返回的使用者名称的大小写也可能与给定的name不同。

如果'subject'选项未定义或设置为'default'，则仅当主题备用名称扩展不存在或不包含任何 DNS 名称时才考虑证书主题。此行为与RFC 2818 （“HTTP Over TLS”）一致 。

如果'subject'选项设置为'always'，并且使用者备用名称扩展不存在或不包含匹配的 DNS 名称，则将考虑证书使用者。

如果'subject'选项设置为'never'，则永远不会考虑证书主题，即使证书不包含主题备用名称。

x509.checkIP(ip)#

• ip <字符串>
• 返回：<字符串> | <undefined>如果证书匹配，则 返回ip ，如果不匹配，则返回 undefined 。

检查证书是否与给定的 IP 地址（IPv4 或 IPv6）匹配。

仅考虑RFC 5280 iPAddress主题备用名称，并且它们必须与给定的ip地址完全匹配。其他主题备用名称以及证书的主题字段将被忽略。

x509.checkIssued(otherCert)#

• otherCert <X509证书>
• 返回：<布尔值>

检查此证书是否由给定的otherCert颁发。

x509.checkPrivateKey(privateKey)#

• privateKey <KeyObject>私钥。
• 返回：<布尔值>

检查此证书的公钥与给定的私钥是否一致。

x509.fingerprint#

• 类型：<字符串>

该证书的 SHA-1 指纹。

由于 SHA-1 在加密上已被破坏，并且 SHA-1 的安全性明显比常用的证书签名算法差，因此请考虑改用x509.fingerprint256。

x509.fingerprint256#

• 类型：<字符串>

该证书的 SHA-256 指纹。

x509.fingerprint512#

• 类型：<字符串>

该证书的 SHA-512 指纹。

由于计算 SHA-256 指纹通常速度更快，而且其大小仅为 SHA-512 指纹的一半，因此x509.fingerprint256可能是更好的选择。虽然 SHA-512 通常可以提供更高级别的安全性，但 SHA-256 的安全性与大多数常用于签署证书的算法的安全性相匹配。

x509.infoAccess#

• 类型：<字符串>

证书的权限信息访问扩展的文本表示。

这是一个换行分隔的访问描述列表。每行以访问方法和访问位置的类型开头，后跟冒号和与访问位置关联的值。

在表示访问方法和访问位置类型的前缀之后，每行的其余部分可能会用引号引起来，以指示该值是 JSON 字符串文字。为了向后兼容，Node.js 仅在必要时在此属性中使用 JSON 字符串文字以避免歧义。第三方代码应准备好处理两种可能的条目格式。

x509.issuer#

• 类型：<字符串>

该证书中包含颁发者标识。

x509.issuerCertificate#

• 类型：<X509证书>

颁发者证书或undefined（如果颁发者证书不可用）。

x509.keyUsage#

• 类型：<字符串[]>

详细说明此证书的密钥用法的数组。

x509.publicKey#

• 类型：<关键对象>

此证书的公钥<KeyObject> 。

x509.raw#

• 类型：<缓冲区>

包含此证书的 DER 编码的Buffer 。

x509.serialNumber#

• 类型：<字符串>

该证书的序列号。

序列号由证书颁发机构分配，并不唯一标识证书。考虑使用x509.fingerprint256作为唯一标识符。

x509.subject#

• 类型：<字符串>

本证书的完整主题。

x509.subjectAltName#

• 类型：<字符串>

为此证书指定的使用者备用名称。

这是一个以逗号分隔的主题备用名称列表。每个条目都以一个字符串开头，该字符串标识主题备用名称的类型，后跟冒号和与该条目关联的值。

早期版本的 Node.js 错误地认为以两个字符序列', '分割此属性是安全的（请参阅CVE-2021-44532）。但是，恶意证书和合法证书都可能包含主题备用名称，这些备用名称在表示为字符串时包含此序列。

在表示条目类型的前缀之后，每个条目的其余部分可能会用引号引起来，以指示该值是 JSON 字符串文字。为了向后兼容，Node.js 仅在必要时在此属性中使用 JSON 字符串文字以避免歧义。第三方代码应准备好处理两种可能的条目格式。

x509.toJSON()#

• 类型：<字符串>

X509 证书没有标准的 JSON 编码。toJSON()方法 返回包含 PEM 编码证书的字符串。

x509.toLegacyObject()#

• 类型：<对象>

使用旧 证书对象编码返回有关此证书的信息。

x509.toString()#

• 类型：<字符串>

返回 PEM 编码的证书。

x509.validFrom#

• 类型：<字符串>

该证书被视为有效的日期/时间。

x509.validTo#

• 类型：<字符串>

该证书被视为有效的日期/时间。

x509.verify(publicKey)#

• publicKey <KeyObject>公钥。
• 返回：<布尔值>

验证此证书是否由给定的公钥签名。不对证书执行任何其他验证检查。

node:crypto模块方法和属性#

crypto.constants#

• <对象>

包含用于加密和安全相关操作的常用常量的对象。当前定义的具体常量在加密常量中描述 。

crypto.DEFAULT_ENCODING#

用于可以采用字符串或缓冲区的函数的默认编码。默认值为'buffer'，这使得方法默认为Buffer对象。

提供crypto.DEFAULT_ENCODING机制是为了向后兼容那些期望'latin1'作为默认编码的旧程序。

新应用程序的默认值应为'buffer'。

该属性已被弃用。

crypto.fips#

用于检查和控制当前是否正在使用符合 FIPS 的加密提供程序的属性。设置为 true 需要 Node.js 的 FIPS 构建。

该属性已被弃用。请改用crypto.setFips()和 crypto.getFips()。

crypto.checkPrime(candidate[, options], callback)#

• candidate <ArrayBuffer> | <共享数组缓冲区> | <类型化数组> | <缓冲区> | <数据视图> | <bigint> 可能的素数，编码为任意长度的大端字节序序列。
• options <对象>
  • checks <number>要执行的 Miller-Rabin 概率素性迭代的次数。当值为0 （零）时，将使用多次检查，对于随机输入产生最多 2 ^-64的误报率。选择多种支票时必须小心。 有关更多详细信息，请参阅 OpenSSL 文档中的BN_is_prime_ex函数nchecks选项。默认值： 0
• callback <函数>
  • err <Error>如果检查期间发生错误，则设置为<Error>对象。
  • result <boolean> true如果候选者是错误概率小于0.25 ** options.checks的素数。

检查candidate的素数。

crypto.checkPrimeSync(candidate[, options])#

• candidate <ArrayBuffer> | <共享数组缓冲区> | <类型化数组> | <缓冲区> | <数据视图> | <bigint> 可能的素数，编码为任意长度的大端字节序序列。
• options <对象>
  • checks <number>要执行的 Miller-Rabin 概率素性迭代的次数。当值为0 （零）时，将使用多次检查，对于随机输入产生最多 2 ^-64的误报率。选择多种支票时必须小心。 有关更多详细信息，请参阅 OpenSSL 文档中的BN_is_prime_ex函数nchecks选项。默认值： 0
• 返回：<boolean> true如果候选者是错误概率小于0.25 ** options.checks的素数。

检查candidate的素数。

crypto.createCipher(algorithm, password[, options])#

• algorithm <字符串>
• password <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• options <对象> stream.transform选项
• 返回：<密码>

创建并返回一个使用给定algorithm和password 的 Cipher对象。

options参数控制流行为，并且是可选的，除非使用CCM 或 OCB 模式下的密码（例如'aes-128-ccm' ）。在这种情况下， 需要authTagLength选项，并指定身份验证标记的长度（以字节为单位），请参阅CCM 模式。在 GCM 模式下， 不需要authTagLength选项，但可用于设置getAuthTag()返回的身份验证标记的长度，默认为 16 字节。对于chacha20-poly1305，authTagLength选项默认为 16 个字节。

algorithm依赖于 OpenSSL，例如'aes192'等。在最近的 OpenSSL 版本中，openssl list -cipher-algorithms将显示可用的密码算法。

password用于导出密钥和初始化向量 (IV)。该值必须是'latin1'编码字符串、Buffer、 TypedArray或DataView。

此函数在语义上对于所有受支持的密码来说都是不安全的，并且对于计数器模式（例如 CTR、GCM 或 CCM）下的密码来说存在致命缺陷。

crypto.createCipher()的实现使用 OpenSSL 函数EVP_BytesToKey派生密钥，摘要算法设置为 MD5，一次迭代，无盐。缺少盐允许字典攻击，因为相同的密码总是创建相同的密钥。低迭代次数和非加密安全散列算法允许非常快速地测试密码。

根据 OpenSSL 使用更现代的算法而不是 EVP_BytesToKey的建议，建议开发人员使用crypto.scrypt()自行派生密钥和 IV ，并使用crypto.createCipheriv() 创建Cipher对象。用户不应在crypto.createCipher()中使用具有计数器模式的密码（例如 CTR、GCM 或 CCM） 。使用它们时会发出警告，以避免 IV 重用导致漏洞的风险。对于 GCM 中重用 IV 的情况，请参阅Nonce-Disrespecting Adversaries了解详细信息。

crypto.createCipheriv(algorithm, key, iv[, options])#

• algorithm <字符串>
• key <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图> | <关键对象> | <加密密钥>
• iv <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图> | <空>
• options <对象> stream.transform选项
• 返回：<密码>

使用给定的algorithm、key和初始化向量 ( iv )创建并返回一个Cipher对象。

options参数控制流行为，并且是可选的，除非使用CCM 或 OCB 模式下的密码（例如'aes-128-ccm' ）。在这种情况下， 需要authTagLength选项，并指定身份验证标记的长度（以字节为单位），请参阅CCM 模式。在 GCM 模式下， 不需要authTagLength选项，但可用于设置getAuthTag()返回的身份验证标记的长度，默认为 16 字节。对于chacha20-poly1305，authTagLength选项默认为 16 个字节。

algorithm依赖于 OpenSSL，例如'aes192'等。在最近的 OpenSSL 版本中，openssl list -cipher-algorithms将显示可用的密码算法。

key是algorithm使用的原始密钥，而iv是 初始化向量。两个参数都必须是'utf8'编码的字符串、 Buffers、TypedArray或DataView。key可以选择是类型为secret的KeyObject。如果密码不需要初始化向量，则iv可以是null。

传递key或iv的字符串时，请考虑 使用字符串作为加密 API 的输入时的注意事项。

初始化向量应该是不可预测的且唯一的；理想情况下，它们在加密上是随机的。它们不必是秘密的：IV 通常只是添加到未加密的密文消息中。有些东西必须是不可预测的和独特的，但不一定是秘密的，这听起来可能很矛盾。请记住，攻击者不能提前预测给定的 IV 是什么。

crypto.createDecipher(algorithm, password[, options])#

• algorithm <字符串>
• password <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• options <对象> stream.transform选项
• 返回：<解密>

创建并返回一个使用给定algorithm和 password（键）的Decipher对象。

options参数控制流行为，并且是可选的，除非使用CCM 或 OCB 模式下的密码（例如'aes-128-ccm' ）。在这种情况下， 需要authTagLength选项，并指定身份验证标记的长度（以字节为单位），请参阅CCM 模式。对于chacha20-poly1305，authTagLength选项默认为 16 个字节。

此函数在语义上对于所有受支持的密码来说都是不安全的，并且对于计数器模式（例如 CTR、GCM 或 CCM）下的密码来说存在致命缺陷。

crypto.createDecipher()的实现使用 OpenSSL 函数EVP_BytesToKey派生密钥，摘要算法设置为 MD5，一次迭代，无盐。缺少盐允许字典攻击，因为相同的密码总是创建相同的密钥。低迭代次数和非加密安全散列算法允许非常快速地测试密码。

根据 OpenSSL 使用更现代的算法而不是 EVP_BytesToKey的建议，建议开发人员使用crypto.scrypt()自行派生密钥和 IV ，并使用crypto.createDecipheriv() 创建Decipher对象。

crypto.createDecipheriv(algorithm, key, iv[, options])#

• algorithm <字符串>
• key <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图> | <关键对象> | <加密密钥>
• iv <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图> | <空>
• options <对象> stream.transform选项
• 返回：<解密>

创建并返回一个使用给定的 algorithm 、 key 和初始化向量 ( iv ) 的Decipher对象。

options参数控制流行为，并且是可选的，除非使用CCM 或 OCB 模式下的密码（例如'aes-128-ccm' ）。在这种情况下， 需要authTagLength选项，并指定身份验证标记的长度（以字节为单位），请参阅CCM 模式。在 GCM 模式下， 不需要authTagLength选项，但可用于将接受的身份验证标记限制为具有指定长度的标记。对于chacha20-poly1305，authTagLength选项默认为 16 个字节。

algorithm依赖于 OpenSSL，例如'aes192'等。在最近的 OpenSSL 版本中，openssl list -cipher-algorithms将显示可用的密码算法。

key是algorithm使用的原始密钥，而iv是 初始化向量。两个参数都必须是'utf8'编码的字符串、 Buffers、TypedArray或DataView。key可以选择是类型为secret的KeyObject。如果密码不需要初始化向量，则iv可以是null。

传递key或iv的字符串时，请考虑 使用字符串作为加密 API 的输入时的注意事项。

初始化向量应该是不可预测的且唯一的；理想情况下，它们在加密上是随机的。它们不必是秘密的：IV 通常只是添加到未加密的密文消息中。有些东西必须是不可预测的和独特的，但不一定是秘密的，这听起来可能很矛盾。请记住，攻击者不能提前预测给定的 IV 是什么。

crypto.createDiffieHellman(prime[, primeEncoding][, generator][, generatorEncoding])#

• prime <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• primeEncoding <string> prime字符串的编码。
• generator <数字> | <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图> 默认： 2
• generatorEncoding <string> generator字符串的编码。
• 返回：<迪菲赫尔曼>

使用提供的prime和可选的特定generator创建一个DiffieHellman密钥交换对象。

generator参数可以是数字、字符串或Buffer。如果 未指定generator ，则使用值2 。

如果指定了primeEncoding ，则prime应该是一个字符串；否则需要Buffer、TypedArray或DataView 。

如果指定了generatorEncoding ，则generator应该是一个字符串；否则应为数字Buffer、TypedArray或DataView 。

crypto.createDiffieHellman(primeLength[, generator])#

• primeLength <数字>
• generator <数字> 默认值： 2
• 返回：<迪菲赫尔曼>

创建一个DiffieHellman密钥交换对象，并使用可选的特定数字generator生成 primeLength 位的质 数。如果未指定generator ，则使用值2 。

crypto.createDiffieHellmanGroup(name)#

• name <字符串>
• 返回：<DiffieHellmanGroup>

crypto.getDiffieHellman()的别名

crypto.createECDH(curveName)#

• curveName <字符串>
• 返回：<ECDH>

使用由 curveName 字符串指定的预定义曲线创建椭圆曲线 Diffie-Hellman ( ECDH ) 密钥交换对象。使用 crypto.getCurves()获取可用曲线名称的列表。在最近的 OpenSSL 版本中，openssl ecparam -list_curves还将显示每个可用椭圆曲线的名称和描述。

crypto.createHash(algorithm[, options])#

• algorithm <字符串>
• options <对象> stream.transform选项
• 返回：<哈希值>

创建并返回一个Hash对象，该对象可用于使用给定的algorithm生成哈希摘要。可选的options参数控制流行为。对于 XOF 哈希函数（例如'shake256' ），可以使用outputLength选项指定所需的输出长度（以字节为单位）。

algorithm取决于平台上 OpenSSL 版本支持的可用算法。例如'sha256'、'sha512'等。在 OpenSSL 的最新版本中，openssl list -digest-algorithms将显示可用的摘要算法。

示例：生成文件的 sha256 和

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}`);
  }
});const {
  createReadStream,
} = require('node:fs');
const {
  createHash,
} = require('node:crypto');
const { argv } = require('node:process');

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}`);
  }
});copy

crypto.createHmac(algorithm, key[, options])#

• algorithm <字符串>
• key <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图> | <关键对象> | <加密密钥>
• options <对象> stream.transform选项
  • encoding <string>当key是字符串时使用的字符串编码。
• 返回：<Hmac>

创建并返回一个使用给定algorithm和key 的 Hmac对象。可选的options参数控制流行为。

algorithm取决于平台上 OpenSSL 版本支持的可用算法。例如'sha256'、'sha512'等。在 OpenSSL 的最新版本中，openssl list -digest-algorithms将显示可用的摘要算法。

key是用于生成加密 HMAC 哈希的 HMAC 密钥。如果它是KeyObject，则其类型必须是secret。如果它是字符串，请 在使用字符串作为加密 API 的输入时考虑注意事项。如果它是从加密安全的熵源获取的，例如 crypto.randomBytes()或crypto.generateKey()，则其长度不应超过algorithm的块大小（例如 512 SHA-256 位）。

示例：生成文件的 sha256 HMAC

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}`);
  }
});const {
  createReadStream,
} = require('node:fs');
const {
  createHmac,
} = require('node:crypto');
const { argv } = require('node:process');

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}`);
  }
});copy

crypto.createPrivateKey(key)#

• key <对象> | <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
  • key：<字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图> | <对象>密钥材料，采用 PEM、DER 或 JWK 格式。
  • format：<string>必须是'pem'、'der'或 ' 'jwk'。 默认值： 'pem'。
  • type：<string>必须是'pkcs1'、'pkcs8'或'sec1'。仅当format为'der'时才需要此选项，否则将被忽略。
  • passphrase : <字符串> | <Buffer>用于解密的密码。
  • encoding : <string>当key是字符串时使用的字符串编码。
• 返回：<KeyObject>

创建并返回包含私钥的新密钥对象。如果key是字符串或Buffer，则format被假定为'pem'；否则，key 必须是具有上述属性的对象。

如果私钥已加密，则必须指定passphrase 。密码短语的长度限制为 1024 字节。

crypto.createPublicKey(key)#

• key <对象> | <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
  • key：<字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图> | <对象>密钥材料，采用 PEM、DER 或 JWK 格式。
  • format：<string>必须为'pem'、'der'或'jwk'。 默认值： 'pem'。
  • type：<string>必须是'pkcs1'或'spki'。仅当format为'der'时才需要此选项，否则将被忽略。
  • encoding <string>当key是字符串时使用的字符串编码。
• 返回：<KeyObject>

创建并返回包含公钥的新密钥对象。如果key是字符串或Buffer，则format被假定为'pem'；如果key是 类型为'private'的KeyObject，则公钥源自给定的私钥；否则，key必须是具有上述属性的对象。

如果格式为'pem'，则'key'也可能是 X.509 证书。

由于公钥可以从私钥导出，因此可以传递私钥而不是公钥。在这种情况下，该函数的行为就像 调用了crypto.createPrivateKey() ，只不过返回的KeyObject的类型将为'public'并且私钥不能被调用。从返回的KeyObject中提取。同样，如果给出类型为 'private'的 KeyObject，则将返回类型为'public' 的新 KeyObject，并且不可能从返回的对象中提取私钥。

crypto.createSecretKey(key[, encoding])#

• key <字符串> | <数组缓冲区> | <缓冲区> | <类型化数组> | <数据视图>
• encoding <string>当key为字符串时的字符串编码。
• 返回：<KeyObject>

创建并返回一个新的密钥对象，其中包含用于对称加密或Hmac的密钥。

crypto.createSign(algorithm[, options])#

• algorithm <字符串>
• options <对象> stream.Writable选项
• 返回：<标志>

创建并返回一个使用给定algorithm的 Sign对象。使用 crypto.getHashes()获取可用摘要算法的名称。可选的options参数控制stream.Writable行为。

在某些情况下，可以使用签名算法的名称（例如'RSA-SHA256' ）而不是摘要算法来创建Sign实例。这将使用相应的摘要算法。这并不适用于所有签名算法，例如'ecdsa-with-SHA256'，因此最好始终使用摘要算法名称。

crypto.createVerify(algorithm[, options])#

• algorithm <字符串>
• options <对象> stream.Writable选项
• 返回：<验证>

创建并返回使用给定算法的Verify对象。使用crypto.getHashes()获取可用签名算法的名称数组。可选的options参数控制 stream.Writable行为。

在某些情况下，可以使用签名算法的名称（例如'RSA-SHA256' ）而不是摘要算法来创建Verify实例。这将使用相应的摘要算法。这并不适用于所有签名算法，例如'ecdsa-with-SHA256'，因此最好始终使用摘要算法名称。

crypto.diffieHellman(options)#

• options：<对象>
  • privateKey : <KeyObject>
  • publicKey : <KeyObject>
• 返回：<缓冲区>

基于privateKey和publicKey计算 Diffie-Hellman 密钥。两个密钥必须具有相同的asymmetricKeyType，它必须是'dh' （对于 Diffie-Hellman）、'ec'（对于 ECDH）、'x448'或'x25519'（对于 ECDH-ES）。

crypto.generateKey(type, options, callback)#

• type：<string>生成的密钥的预期用途。目前接受的值为'hmac'和'aes'。
• options：<对象>
  • length：<number>要生成的密钥的位长度。该值必须是大于 0 的值。
    • 如果type为'hmac'，则最小值为 8，最大长度为 2 ³¹ -1。如果该值不是 8 的倍数，则生成的密钥将被截断为Math.floor(length / 8)。
    • 如果type为'aes'，则长度必须为128、192或256之一。
• callback : <函数>
  • err：<错误>
  • key：<KeyObject>

异步生成给定length的新随机密钥。type将确定将在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
});const {
  generateKey,
} = require('node:crypto');

generateKey('hmac', { length: 512 }, (err, key) => {
  if (err) throw err;
  console.log(key.export().toString('hex'));  // 46e..........620
});copy

生成的 HMAC 密钥的大小不应超过底层哈希函数的块大小。请参阅crypto.createHmac()了解更多信息。

crypto.generateKeyPair(type, options, callback)#

• type：<string>必须为'rsa'、'rsa-pss'、'dsa'、'ec'、'ed25519'、 'ed448'、'x25519'、'x448'或'dh'。
• options：<对象>
  • modulusLength：<number>密钥大小（以位为单位）（RSA、DSA）。
  • publicExponent：<number>公共索引 (RSA)。默认值： 0x10001。
  • hashAlgorithm：<string>消息摘要的名称 (RSA-PSS)。
  • mgf1HashAlgorithm：<string> MGF1 (RSA-PSS) 使用的消息摘要的名称。
  • saltLength：<number>最小盐长度（以字节为单位）(RSA-PSS)。
  • divisorLength：<number> q的大小（以位 (DSA) 为单位）。
  • namedCurve : <string>要使用的曲线名称 (EC)。
  • prime：<Buffer>主要参数 (DH)。
  • primeLength：<number>素数长度（以位 (DH) 为单位）。
  • generator：<number>自定义生成器 (DH)。默认值： 2。
  • groupName：<字符串> Diffie-Hellman 组名称 (DH)。请参阅 crypto.getDiffieHellman()。
  • paramEncoding：<string>必须为'named'或'explicit' (EC)。 默认值： 'named'。
  • publicKeyEncoding：<对象>请参阅keyObject.export()。
  • privateKeyEncoding：<对象>请参阅keyObject.export()。
• callback : <函数>
  • err：<错误>
  • publicKey : <字符串> | <缓冲区> | <关键对象>
  • privateKey：<字符串> | <缓冲区> | <关键对象>

生成给定type的新非对称密钥对。目前支持 RSA、RSA-PSS、DSA、EC、Ed25519、Ed448、X25519、X448 和 DH。

如果指定了publicKeyEncoding或privateKeyEncoding，则此函数的行为就好像已对其结果调用了keyObject.export() 。否则，键的相应部分将作为KeyObject返回。

建议将公钥编码为'spki'，私钥编码为 'pkcs8'，并进行加密以便长期存储：

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.
});const {
  generateKeyPair,
} = require('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.
});copy

完成后，将调用callback ，并将err设置为undefined和 publicKey / privateKey表示生成的密钥一对。

如果此方法作为其util.promisify() ed 版本调用，它将返回一个Promise，其中包含publicKey和privateKey特性。

crypto.generateKeyPairSync(type, options)#

• type：<string>必须为'rsa'、'rsa-pss'、'dsa'、'ec'、'ed25519'、 'ed448'、'x25519'、'x448'或'dh'。
• options：<对象>
  • modulusLength：<number>密钥大小（以位为单位）（RSA、DSA）。
  • publicExponent：<number>公共索引 (RSA)。默认值： 0x10001。
  • hashAlgorithm：<string>消息摘要的名称 (RSA-PSS)。
  • mgf1HashAlgorithm：<string> MGF1 (RSA-PSS) 使用的消息摘要的名称。
  • saltLength：<number>最小盐长度（以字节为单位）(RSA-PSS)。
  • divisorLength：<number> q的大小（以位 (DSA) 为单位）。
  • namedCurve : <string>要使用的曲线名称 (EC)。
  • prime : <Buffer>主参数 (DH)。
  • primeLength：<number>素数长度（以位 (DH) 为单位）。
  • generator：<number>自定义生成器 (DH)。默认值： 2。
  • groupName：<字符串> Diffie-Hellman 组名称 (DH)。请参阅 crypto.getDiffieHellman()。
  • paramEncoding：<string>必须为'named'或'explicit' (EC)。 默认值： 'named'。
  • publicKeyEncoding：<对象>请参阅keyObject.export()。
  • privateKeyEncoding：<对象>请参阅keyObject.export()。
• 返回：<对象>
  • publicKey：<字符串> | <缓冲区> | <关键对象>
  • privateKey : <字符串> | <缓冲区> | <关键对象>

生成给定type的新非对称密钥对。目前支持 RSA、RSA-PSS、DSA、EC、Ed25519、Ed448、X25519、X448 和 DH。

如果指定了publicKeyEncoding或privateKeyEncoding，则此函数的行为就好像已对其结果调用了keyObject.export() 。否则，键的相应部分将作为KeyObject返回。

对公钥进行编码时，建议使用'spki'。对私钥进行编码时，建议使用具有强密码的'pkcs8'，并对密码保密。

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',
  },
});const {
  generateKeyPairSync,
} = require('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',
  },
});copy

返回值{ publicKey, privateKey }代表生成的密钥对。当选择 PEM 编码时，相应的密钥将是一个字符串，否则它将是一个包含编码为 DER 的数据的缓冲区。

crypto.generateKeySync(type, options)#

• type : <string>生成的密钥的预期用途。目前接受的值为'hmac'和'aes'。
• options：<对象>
  • length：<number>要生成的密钥的位长度。
    • 如果type为'hmac'，则最小值为 8，最大长度为 2 ³¹ -1。如果该值不是 8 的倍数，则生成的密钥将被截断为Math.floor(length / 8)。
    • 如果type为'aes'，则长度必须为128、192或256之一。
• 返回：<KeyObject>

同步生成给定length的新随机密钥。type将确定将在length上执行哪些验证。

const {
  generateKeySync,
} = await import('node:crypto');

const key = generateKeySync('hmac', { length: 512 });
console.log(key.export().toString('hex'));  // e89..........41econst {
  generateKeySync,
} = require('node:crypto');

const key = generateKeySync('hmac', { length: 512 });
console.log(key.export().toString('hex'));  // e89..........41ecopy

生成的 HMAC 密钥的大小不应超过底层哈希函数的块大小。请参阅crypto.createHmac()了解更多信息。

crypto.generatePrime(size[, options[, callback]])#

• size <number>要生成的素数的大小（以位为单位）。
• options <对象>
  • add <ArrayBuffer> | <共享数组缓冲区> | <类型化数组> | <缓冲区> | <数据视图> | <bigint>
  • rem <ArrayBuffer> | <共享数组缓冲区> | <类型化数组> | <缓冲区> | <数据视图> | <bigint>
  • safe <布尔值> 默认值： false。
  • bigint <boolean>当true时，生成的素数作为bigint返回。
• callback <函数>
  • err <错误>
  • prime <ArrayBuffer> | <bigint>

生成size位的伪随机素数。

如果options.safe是true，则素数将是安全素数 - 也就是说， (prime - 1) / 2也将是素数。

options.add和options.rem参数可用于强制执行附加要求，例如，对于 Diffie-Hellman：

• 如果options.add和options.rem均已设置，则质数将满足prime % add = rem的条件。
• 如果仅设置了options.add并且options.safe不是true ，则素数将满足prime % add = 1条件。
• 如果仅设置了options.add且options.safe设置为true ，则质数将满足prime % add = 3条件。这是必要的，因为options.add > 2的prime % add = 1会与options.safe强制执行的条件相矛盾。
• 如果未给出options.add ，则忽略 options.rem。

如果以ArrayBuffer、SharedArrayBuffer、 TypedArray 形式给出，则options.add 和options.rem 都必须编码为大端序列}、Buffer或 DataView。

默认情况下，素数在<ArrayBuffer>中被编码为八位字节的大端序列。如果bigint选项为true，则 提供<bigint> 。

crypto.generatePrimeSync(size[, options])#

• size <number>要生成的素数的大小（以位为单位）。
• options <对象>
  • add <ArrayBuffer> | <共享数组缓冲区> | <类型化数组> | <缓冲区> | <数据视图> | <bigint>
  • rem <ArrayBuffer> | <共享数组缓冲区> | <类型化数组> | <缓冲区> | <数据视图> | <bigint>
  • safe <布尔值> 默认值： false。
  • bigint <boolean>当true时，生成的素数作为bigint返回。
• 返回：<ArrayBuffer> | <bigint>

生成size位的伪随机素数。

如果options.safe是true，则素数将是安全素数 - 也就是说， (prime - 1) / 2也将是素数。

options.add和options.rem参数可用于强制执行附加要求，例如对于 Diffie-Hellman：

• 如果options.add和options.rem均已设置，则素数将满足prime % add = rem的条件。
• 如果仅设置了options.add并且options.safe不是true ，则素数将满足prime % add = 1条件。
• 如果仅设置了options.add且options.safe设置为true ，则质数将满足prime % add = 3条件。这是必要的，因为options.add > 2的prime % add = 1会与options.safe强制执行的条件相矛盾。
• 如果未给出options.add ，则忽略 options.rem。

如果以ArrayBuffer、SharedArrayBuffer、 TypedArray 形式给出，则options.add和options.rem 都必须编码为大端序列}、Buffer或 DataView。

默认情况下，素数在<ArrayBuffer>中被编码为八位字节的大端序列。如果bigint选项为true，则 提供<bigint> 。

crypto.getCipherInfo(nameOrNid[, options])#

• nameOrNid：<字符串> | <number>要查询的密码的名称或 nid。
• options：<对象>
  • keyLength：<number>测试密钥长度。
  • ivLength：<number>测试 IV 长度。
• 返回：<对象>
  • name <string>密码的名称
  • nid <number>密码的 nid
  • blockSize <number>密码的块大小（以字节为单位）。当mode为'stream'时，此属性被省略。
  • ivLength <number>预期或默认初始化向量长度（以字节为单位）。如果密码不使用初始化向量，则忽略此属性。
  • keyLength <number>预期或默认密钥长度（以字节为单位）。
  • mode <string>密码模式。'cbc'、'ccm'、'cfb'、'ctr'、 'ecb'、'gcm'之一，'ocb'、'ofb'、'stream'、'wrap'、'xts'。

返回有关给定密码的信息。

一些密码接受可变长度密钥和初始化向量。默认情况下，crypto.getCipherInfo()方法将返回这些密码的默认值。要测试给定密钥长度或 iv 长度对于给定密码是否可接受，请使用keyLength和ivLength选项。如果给定的值不可接受，则返回undefined 。

crypto.getCiphers()#