Node.js v22.22.0 文档

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

【Determining if crypto support is unavailable】

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

【It is possible for Node.js to be built without including support for the node:crypto module. In such cases, attempting to import from crypto or calling require('node:crypto') will result in an error being thrown.】

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

【When using CommonJS, the error thrown can be caught using try/catch:】

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

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

【When using the lexical ESM import keyword, the error can only be caught if a handler for process.on('uncaughtException') is registered before any attempt to load the module is made (using, for instance, a preload module).】

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

【When using ESM, if there is a chance that the code may be run on a build of Node.js where crypto support is not enabled, consider using the import() function instead of the lexical import keyword:】

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

类：Certificate#>

【Class: Certificate】

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

【SPKAC is a Certificate Signing Request mechanism originally implemented by Netscape and was specified formally as part of HTML5's keygen element.】

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

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

【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.】

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

【Static method: Certificate.exportChallenge(spkac[, encoding])】

• spkac <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• 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 string拷贝

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

【Static method: Certificate.exportPublicKey(spkac[, encoding])】

• spkac <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• 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 ...>拷贝

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

【Static method: Certificate.verifySpkac(spkac[, encoding])】

• spkac <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> spkac 字符串的 编码。
• 返回值: <boolean> 如果给定的 spkac 数据结构有效则返回 true，否则返回 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 false拷贝

旧版 API#>

【Legacy API】

作为一个遗留接口，可以像下面的示例中那样创建 crypto.Certificate 类的新实例。

【As a legacy interface, it is possible to create new instances of the crypto.Certificate class as illustrated in the examples below.】

new crypto.Certificate()#>

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

【Instances of the Certificate class can be created using the new keyword or by calling crypto.Certificate() as a function:】

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

certificate.exportChallenge(spkac[, encoding])#>

• spkac <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• 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 string拷贝

certificate.exportPublicKey(spkac[, encoding])#>

• spkac <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• 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 ...>拷贝

certificate.verifySpkac(spkac[, encoding])#>

• spkac <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> spkac 字符串的 编码。
• 返回值: <boolean> 如果给定的 spkac 数据结构有效则返回 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 false拷贝

类：Cipher#>

【Class: Cipher】

• 继承: <stream.Transform>

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

【Instances of the Cipher class are used to encrypt data. The class can be used in one of two ways:】

• 作为一个既可读又可写的 溪流，其中将未加密的普通数据写入以在可读端生成加密数据，或者
• 使用 cipher.update() 和 cipher.final() 方法生成加密数据。

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

【The crypto.createCipheriv() method is used to create Cipher instances. Cipher objects are not to be created directly using the new keyword.】

示例：将 Cipher 对象用作流：

【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();
  });
});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();
  });
});拷贝

示例：使用 Cipher 和管道流：

【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;
    });
  });
});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;
    });
  });
});拷贝

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

【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);
  });
});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);
  });
});拷贝

cipher.final([outputEncoding])#>

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

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

【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.】

cipher.getAuthTag()#>

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

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

【The cipher.getAuthTag() method should only be called after encryption has been completed using the cipher.final() method.】

如果在创建 cipher 实例时设置了 authTagLength 选项，该函数将返回正好 authTagLength 字节的数据。

【If the authTagLength option was set during the cipher instance's creation, this function will return exactly authTagLength bytes.】

cipher.setAAD(buffer[, options])#>

• buffer <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• options <Object> stream.transform 选项
  • plaintextLength <number>
  • encoding <string> 当 buffer 是字符串时使用的字符串编码。
• 返回: <Cipher> 相同的 Cipher 实例，用于方法链调用。

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

【When using an authenticated encryption mode (GCM, CCM, OCB, and chacha20-poly1305 are currently supported), the cipher.setAAD() method sets the value used for the additional authenticated data (AAD) input parameter.】

plaintextLength 选项对于 GCM 和 OCB 是可选的。使用 CCM 时，必须指定 plaintextLength 选项，并且其值必须与明文的字节长度相符。参见 CCM 模式。

【The plaintextLength option is optional for GCM and OCB. When using CCM, the plaintextLength option must be specified and its value must match the length of the plaintext in bytes. See CCM mode.】

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

【The cipher.setAAD() method must be called before cipher.update().】

cipher.setAutoPadding([autoPadding])#>

• autoPadding <boolean> 默认值: true
• 返回值: <Cipher> 返回相同的 Cipher 实例，以便方法链调用。

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

【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).】

当 autoPadding 为 false 时，整个输入数据的长度必须是加密算法块大小的倍数，否则 cipher.final() 会抛出错误。禁用自动填充对于非标准填充非常有用，例如使用 0x0 替代 PKCS 填充。

【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.】

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

【The cipher.setAutoPadding() method must be called before cipher.final().】

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

• data <string> | <Buffer> | <TypedArray> | <DataView>
• inputEncoding <string> 数据的 编码。
• outputEncoding <string> 返回值的 编码。
• 返回: <Buffer> | <string>

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

【Updates the cipher 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, TypedArray, or DataView. If data is a Buffer, TypedArray, or DataView, then inputEncoding is ignored.】

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

【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.】

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

【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.】

类：Decipher#>

【Class: Decipher】

• 继承: <stream.Transform>

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

【Instances of the Decipher class are used to decrypt data. The class can be used in one of two ways:】

• 作为一个既可读又可写的 溪流，其中写入纯加密数据会在可读端生成未加密的数据，或者
• 使用 decipher.update() 和 decipher.final() 方法生成未加密的数据。

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

【The crypto.createDecipheriv() method is used to create Decipher instances. Decipher objects are not to be created directly using the new keyword.】

示例：将 Decipher 对象用作流：

【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();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();拷贝

示例：使用 Decipher 和管道流：

【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);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);拷贝

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

【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 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 data拷贝

decipher.final([outputEncoding])#>

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

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

【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.】

decipher.setAAD(buffer[, options])#>

• buffer <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• options <Object> stream.transform 选项
  • plaintextLength <number>
  • encoding <string> 当 buffer 是字符串时使用的字符串编码。
• 返回: <Decipher> 同一个 Decipher，用于方法链式调用。

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

【When using an authenticated encryption mode (GCM, CCM, OCB, and chacha20-poly1305 are currently supported), the decipher.setAAD() method sets the value used for the additional authenticated data (AAD) input parameter.】

options 参数对于 GCM 是可选的。使用 CCM 时，必须指定 plaintextLength 选项，并且其值必须与密文的字节长度相匹配。详见 CCM 模式。

【The options argument is optional for GCM. When using CCM, the plaintextLength option must be specified and its value must match the length of the ciphertext in bytes. See CCM mode.】

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

【The decipher.setAAD() method must be called before decipher.update().】

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

【When passing a string as the buffer, please consider caveats when using strings as inputs to cryptographic APIs.】

decipher.setAuthTag(buffer[, encoding])#>

• buffer <string> | <Buffer> | <ArrayBuffer> | <TypedArray> | <DataView>
• encoding <string> 当 buffer 是字符串时使用的字符串编码。
• 返回值: <Decipher> 相同的 Decipher，用于方法链式调用。

在使用认证加密模式（目前支持 GCM、CCM、OCB 和 chacha20-poly1305）时，decipher.setAuthTag() 方法用于传入接收到的 认证标签。如果未提供标签，或密文已被篡改，decipher.final() 将会抛出异常，表示由于认证失败，应丢弃密文。如果标签长度不符合 NIST SP 800-38D 的规定，或与 authTagLength 选项的值不匹配，decipher.setAuthTag() 将会抛出错误。

【When using an authenticated encryption mode (GCM, CCM, OCB, and chacha20-poly1305 are currently supported), the decipher.setAuthTag() method is used to pass in the received authentication tag. If no tag is provided, or if the cipher text has been tampered with, decipher.final() will throw, indicating that the cipher text should be discarded due to failed authentication. If the tag length is invalid according to NIST SP 800-38D or does not match the value of the authTagLength option, decipher.setAuthTag() will throw an error.】

decipher.setAuthTag() 方法必须在 CCM 模式下的 decipher.update() 之前调用，或在 GCM 和 OCB 模式以及 chacha20-poly1305 下的 decipher.final() 之前调用。decipher.setAuthTag() 只能调用一次。

【The decipher.setAuthTag() method must be called before decipher.update() for CCM mode or before decipher.final() for GCM and OCB modes and chacha20-poly1305. decipher.setAuthTag() can only be called once.】

在将字符串作为认证标签传递时，请考虑 将字符串用作加密 API 输入时的注意事项。

【When passing a string as the authentication tag, please consider caveats when using strings as inputs to cryptographic APIs.】

decipher.setAutoPadding([autoPadding])#>

• autoPadding <boolean> 默认值: true
• 返回: <Decipher> 相同的 Decipher 对象以支持方法链。

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

【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.】

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

【The decipher.setAutoPadding() method must be called before decipher.final().】

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

• data <string> | <Buffer> | <TypedArray> | <DataView>
• inputEncoding <string> data 字符串的 编码。
• outputEncoding <string> 返回值的 编码。
• 返回: <Buffer> | <string>

使用 data 更新解码器。如果提供了 inputEncoding 参数，data 参数就是使用指定编码的字符串。如果未提供 inputEncoding 参数，data 必须是 Buffer。如果 data 是 Buffer，则忽略 inputEncoding。

【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.】

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

【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.】

decipher.update() 方法可以多次调用以处理新数据，直到调用 decipher.final()。在调用 decipher.final() 之后再调用 decipher.update() 会导致抛出错误。

【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.】

即使底层密码实现了认证，从此函数返回的明文的真实性和完整性此时可能仍不确定。对于经过认证的加密算法，只有在应用调用 decipher.final() 时，通常才能确定其真实性。

【Even if the underlying cipher implements authentication, the authenticity and integrity of the plaintext returned from this function may be uncertain at this time. For authenticated encryption algorithms, authenticity is generally only established when the application calls decipher.final().】

类：DiffieHellman#>

【Class: DiffieHellman】

DiffieHellman 类是用于创建 Diffie-Hellman 密钥交换的工具类。

【The DiffieHellman class is a utility for creating Diffie-Hellman key exchanges.】

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

【Instances of the DiffieHellman class can be created using the crypto.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'));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'));拷贝

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

• otherPublicKey <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• inputEncoding <string> otherPublicKey 字符串的 编码。
• outputEncoding <string> 返回值的 编码。
• 返回: <Buffer> | <string>

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

【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.】

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

【If outputEncoding is given a string is returned; otherwise, a Buffer is returned.】

diffieHellman.generateKeys([encoding])#>

• encoding <string> 返回值的 编码。
• 返回: <Buffer> | <string>

生成私有和公有的 Diffie-Hellman 密钥值，除非这些密钥值已经生成或计算过，并返回指定 encoding 的公钥。此密钥应传输给另一方。如果提供了 encoding，则返回一个字符串；否则返回一个 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.】

此函数是 DH_generate_key() 的一个轻量封装。特别是，一旦生成或设置了私钥，调用此函数只会更新公钥，而不会生成新的私钥。

【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.】

diffieHellman.getGenerator([encoding])#>

• encoding <string> 返回值的 编码。
• 返回: <Buffer> | <string>

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

【Returns the Diffie-Hellman generator in the specified encoding. If encoding is provided a string is returned; otherwise a Buffer is returned.】

diffieHellman.getPrime([encoding])#>

• encoding <string> 返回值的 编码。
• 返回: <Buffer> | <string>

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

【Returns the Diffie-Hellman prime in the specified encoding. If encoding is provided a string is returned; otherwise a Buffer is returned.】

diffieHellman.getPrivateKey([encoding])#>

• encoding <string> 返回值的 编码。
• 返回: <Buffer> | <string>

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

【Returns the Diffie-Hellman private key in the specified encoding. If encoding is provided a string is returned; otherwise a Buffer is returned.】

diffieHellman.getPublicKey([encoding])#>

• encoding <string> 返回值的 编码。
• 返回: <Buffer> | <string>

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

【Returns the Diffie-Hellman public key in the specified encoding. If encoding is provided a string is returned; otherwise a Buffer is returned.】

diffieHellman.setPrivateKey(privateKey[, encoding])#>

• privateKey <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> privateKey 字符串的 编码。

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

【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.】

此功能不会自动计算关联的公钥。可以使用 diffieHellman.setPublicKey() 或 diffieHellman.generateKeys() 手动提供公钥，或自动生成公钥。

【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.】

diffieHellman.setPublicKey(publicKey[, encoding])#>

• publicKey <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> publicKey 字符串的 编码。

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

【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.】

diffieHellman.verifyError#>

一个位域，包含在初始化 DiffieHellman 对象时进行检查所产生的任何警告和/或错误。

【A bit field containing any warnings and/or errors resulting from a check performed during initialization of the DiffieHellman object.】

此属性的有效值如下（在 node:constants 模块中定义）:

【The following values are valid for this property (as defined in node:constants module):】

• DH_CHECK_P_NOT_SAFE_PRIME 不安全素数
• DH_CHECK_P_NOT_PRIME 不是素数
• DH_UNABLE_TO_CHECK_GENERATOR 无法检查生成元
• DH_NOT_SUITABLE_GENERATOR 不合适的生成元

类：DiffieHellmanGroup#>

【Class: DiffieHellmanGroup】

DiffieHellmanGroup 类以一个众所周知的 modp 组作为其参数。它的工作方式与 DiffieHellman 相同，只是创建后不允许更改其密钥。换句话说，它不实现 setPublicKey() 或 setPrivateKey() 方法。

【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('modp16');const { createDiffieHellmanGroup } = require('node:crypto');
const dh = createDiffieHellmanGroup('modp16');拷贝

支持以下组：

【The following groups are supported:】

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

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

【The following groups are still supported but deprecated (see Caveats):】

• 'modp1' (768 bits, RFC 2409 Section 6.1)
• 'modp2' (1024 bits, RFC 2409 Section 6.2)
• 'modp5' (1536 bits, RFC 3526 Section 2)

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

【These deprecated groups might be removed in future versions of Node.js.】

类：ECDH#>

【Class: ECDH】

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

【The ECDH class is a utility for creating Elliptic Curve Diffie-Hellman (ECDH) key exchanges.】

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

【Instances of the ECDH class can be created using the crypto.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'));
// 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'));
// OK拷贝

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

【Static method: ECDH.convertKey(key, curve[, inputEncoding[, outputEncoding[, format]]])】

• key <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• curve <string>
• inputEncoding <string> key 字符串的 编码。
• outputEncoding <string> 返回值的 编码。
• format <string> 默认值： 'uncompressed'
• 返回：<Buffer> | <string>

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

【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.】

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

【Use crypto.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.】

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

【If format is not specified the point will be returned in 'uncompressed' format.】

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

【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'));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'));拷贝

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

• otherPublicKey <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• inputEncoding <string> otherPublicKey 字符串的 编码。
• outputEncoding <string> 返回值的 编码。
• 返回: <Buffer> | <string>

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

【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.】

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

【If outputEncoding is given a string will be returned; otherwise a Buffer is returned.】

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

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

• encoding <string> 返回值的 编码。
• format <string> 默认值: 'uncompressed'
• 返回: <Buffer> | <string>

生成私有和公有的 EC Diffie-Hellman 密钥值，并以指定的 format 和 encoding 返回公钥。该密钥应传输给另一方。

【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.】

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

【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.】

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

【If encoding is provided a string is returned; otherwise a Buffer is returned.】

ecdh.getPrivateKey([encoding])#>

• encoding <string> 返回值的 编码。
• 返回: <Buffer> | <string> 指定 encoding 的 EC Diffie-Hellman。

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

【If encoding is specified, a string is returned; otherwise a Buffer is returned.】

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

• encoding <string> 返回值的 编码。
• format <string> 默认值: 'uncompressed'
• 返回: <Buffer> | <string> 指定 encoding 和 format 的 EC Diffie-Hellman 公钥。

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

【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.】

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

【If encoding is specified, a string is returned; otherwise a Buffer is returned.】

ecdh.setPrivateKey(privateKey[, encoding])#>

• privateKey <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> privateKey 字符串的 编码。

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

【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.】

如果 privateKey 对 ECDH 对象创建时指定的曲线无效，将会抛出错误。在设置私钥时，相关的公钥点也会生成并设置在 ECDH 对象中。

【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.】

ecdh.setPublicKey(publicKey[, encoding])#>

• publicKey <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> publicKey 字符串的 编码。

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

【Sets the EC Diffie-Hellman public key. If encoding is provided publicKey is expected to be a string; otherwise a Buffer, TypedArray, or DataView is expected.】

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

【There is not normally a reason to call this method because ECDH only requires a private key and the other party's public key to compute the shared secret. Typically either ecdh.generateKeys() or ecdh.setPrivateKey() will be called. The ecdh.setPrivateKey() method attempts to generate the public point/key associated with the private key being set.】

示例（获取共享密钥）：

【Example (obtaining a shared secret):】

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

类：Hash#>

【Class: Hash】

• 继承: <stream.Transform>

Hash 类是一个用于创建数据哈希摘要的工具类。它可以用两种方式使用：

【The Hash class is a utility for creating hash digests of data. It can be used in one of two ways:】

• 作为一个既可读又可写的 溪流，数据写入后会在可读端生成计算出的哈希摘要，或
• 使用 hash.update() 和 hash.digest() 方法生成计算出的哈希。

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

【The crypto.createHash() method is used to create Hash instances. Hash objects are not to be created directly using the new keyword.】

示例：将 Hash 对象用作流：

【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();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();拷贝

示例：使用 Hash 和管道流：

【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);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);拷贝

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

【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:
//   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50const {
  createHash,
} = require('node:crypto');

const hash = createHash('sha256');

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

hash.copy([options])#>

• options <Object> stream.transform 选项
• 返回: <Hash>

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

【Creates a new Hash object that contains a deep copy of the internal state of the current Hash object.】

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

【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.】

在调用 Hash 对象的 hash.digest() 方法后，如果尝试复制该对象，将会抛出错误。

【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.// 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.拷贝

hash.digest([encoding])#>

• encoding <string> 返回值的 编码。
• 返回: <Buffer> | <string>

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

【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.】

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

【The Hash object can not be used again after hash.digest() method has been called. Multiple calls will cause an error to be thrown.】

hash.update(data[, inputEncoding])#>

• data <string> | <Buffer> | <TypedArray> | <DataView>
• inputEncoding <string> data 字符串的 编码。

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

【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, or DataView, then inputEncoding is ignored.】

这可以在流式传输时使用新数据多次调用。

【This can be called many times with new data as it is streamed.】

类：Hmac#>

【Class: Hmac】

• 继承: <stream.Transform>

Hmac 类是用于创建加密 HMAC 摘要的工具类。它可以通过以下两种方式使用：

【The Hmac class is a utility for creating cryptographic HMAC digests. It can be used in one of two ways:】

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

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

【The crypto.createHmac() method is used to create Hmac instances. Hmac objects are not to be created directly using the new keyword.】

示例：将 Hmac 对象用作流：

【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();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();拷贝

示例：使用 Hmac 和管道流：

【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);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);拷贝

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

【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:
//   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77econst {
  createHmac,
} = require('node:crypto');

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

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

hmac.digest([encoding])#>

• encoding <string> 返回值的 编码。
• 返回: <Buffer> | <string>

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

【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;】

Hmac 对象在调用 hmac.digest() 之后无法再次使用。多次调用 hmac.digest() 会导致抛出错误。

【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.】

hmac.update(data[, inputEncoding])#>

• data <string> | <Buffer> | <TypedArray> | <DataView>
• inputEncoding <string> data 字符串的 编码。

使用给定的 data 更新 Hmac 内容，其编码由 inputEncoding 指定。如果未提供 encoding，且 data 是字符串，则默认使用 'utf8' 编码。如果 data 是 Buffer、TypedArray 或 DataView，则忽略 inputEncoding。

【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, or DataView, then inputEncoding is ignored.】

这可以在流式传输时使用新数据多次调用。

【This can be called many times with new data as it is streamed.】

类：KeyObject#>

【Class: KeyObject】

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

【Node.js uses a KeyObject class to represent a symmetric or asymmetric key, and each kind of key exposes different functions. The crypto.createSecretKey(), crypto.createPublicKey() and crypto.createPrivateKey() methods are used to create KeyObject instances. KeyObject objects are not to be created directly using the new keyword.】

大多数应用应考虑使用新的 KeyObject API，而不是将密钥作为字符串或 Buffer 传递，因为它具有更高的安全性特性。

【Most applications should consider using the new KeyObject API instead of passing keys as strings or Buffers due to improved security features.】

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

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

【Static method: KeyObject.from(key)】

• key <CryptoKey>
• 返回: <KeyObject>

示例：将 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)const { KeyObject } = require('node:crypto');
const { subtle } = globalThis.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)
})();拷贝

keyObject.asymmetricKeyDetails#>

• 类型: <Object>
  • 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)。

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

【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.】

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

【For RSA-PSS keys, if the key material contains a RSASSA-PSS-params sequence, the hashAlgorithm, mgf1HashAlgorithm, and saltLength properties will be set.】

其他密钥细节可能会使用额外属性通过此 API 暴露。

【Other key details might be exposed via this API using additional attributes.】

keyObject.asymmetricKeyType#>

• 类型: <string>

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

【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）

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

【This property is undefined for unrecognized KeyObject types and symmetric keys.】

keyObject.equals(otherKeyObject)#>

• otherKeyObject <KeyObject> 用来与 keyObject 进行比较的 KeyObject。
• 返回值: <boolean>

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

【Returns true or false depending on whether the keys have exactly the same type, value, and parameters. This method is not constant time.】

keyObject.export([options])#>

• options <Object>
• 返回: <string> | <Buffer> | <Object>

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

【For symmetric keys, the following encoding options can be used:】

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

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

【For public keys, the following encoding options can be used:】

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

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

【For private keys, the following encoding options can be used:】

• type <string> 必须是 'pkcs1'（仅限 RSA）、'pkcs8' 或 'sec1'（仅限 EC）之一。
• format <string> 必须是 'pem'、'der' 或 'jwk'。
• cipher <string> 如果指定，私钥将使用给定的 cipher 和 passphrase 通过 PKCS#5 v2.0 基于密码的加密进行加密。
• passphrase <string> | <Buffer> 用于加密的密码，详见 cipher。

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

【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.】

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

【When JWK encoding format was selected, all other encoding options are ignored.】

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

【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 any format to encrypt any key algorithm (RSA, EC, or DH) by specifying a cipher. PKCS#1 and SEC1 can only be encrypted by specifying a cipher when 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.】

keyObject.symmetricKeySize#>

• 类型: <number>

对于秘密密钥，此属性表示密钥的字节大小。对于非对称密钥，该属性为 undefined。

【For secret keys, this property represents the size of the key in bytes. This property is undefined for asymmetric keys.】

keyObject.toCryptoKey(algorithm, extractable, keyUsages)#>

• 算法 <string> | <RsaHashedImportParams> | <EcKeyImportParams> | <HmacImportParams>

• extractable <boolean>
• keyUsages <string[]> 参见 主要用途。
• 返回值: <CryptoKey>

将 KeyObject 实例转换为 CryptoKey。

【Converts a KeyObject instance to a CryptoKey.】

keyObject.type#>

• 类型: <string>

根据此 KeyObject 的类型，此属性可以是秘密（对称）密钥的 'secret'，公钥（非对称）密钥的 'public'，或私钥（非对称）密钥的 'private'。

【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.】

类：Sign#>

【Class: Sign】

• 继承: <stream.Writable>

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

【The Sign class is a utility for generating signatures. It can be used in one of two ways:】

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

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

【The crypto.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.】

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

【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: 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: true拷贝

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

【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: 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: true拷贝

sign.sign(privateKey[, outputEncoding])#>

• privateKey <Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>
  • dsaEncoding <string>
  • padding <integer>
  • saltLength <integer>
• outputEncoding <string> 返回值的 编码。
• 返回: <Buffer> | <string>

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

【Calculates the signature on all the data passed through using either sign.update() or sign.write().】

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

【If privateKey is not a KeyObject, this function behaves as if privateKey had been passed to crypto.createPrivateKey(). If it is an object, the following additional properties can be passed:】

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

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

• 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。

【If outputEncoding is provided a string is returned; otherwise a Buffer is returned.】

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

【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.update(data[, inputEncoding])#>

• data <string> | <Buffer> | <TypedArray> | <DataView>
• inputEncoding <string> data 字符串的 编码。

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

【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, or DataView, then inputEncoding is ignored.】

这可以在流式传输时使用新数据多次调用。

【This can be called many times with new data as it is streamed.】

类：Verify#>

【Class: Verify】

• 继承: <stream.Writable>

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

【The Verify class is a utility for verifying signatures. It can be used in one of two ways:】

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

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

【The crypto.createVerify() method is used to create Verify instances. Verify objects are not to be created directly using the new keyword.】

参见 Sign 示例。

【See Sign for examples.】

verify.update(data[, inputEncoding])#>

• data <string> | <Buffer> | <TypedArray> | <DataView>
• inputEncoding <string> data 字符串的 编码。

使用给定的 data 更新 Verify 内容，其编码由 inputEncoding 指定。如果未提供 inputEncoding，且 data 是字符串，则默认使用 'utf8' 编码。如果 data 是 Buffer、TypedArray 或 DataView，则忽略 inputEncoding。

【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.】

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

• object <Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>
  • dsaEncoding <string>
  • padding <integer>
  • saltLength <integer>
• signature <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• signatureEncoding <string> signature 字符串的 编码。
• 返回值: <boolean> 根据数据和公钥的有效性返回 true 或 false。

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

【Verifies the provided data using the given object and signature.】

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

【If object is not a KeyObject, this function behaves as if object had been passed to crypto.createPublicKey(). If it is an object, the following additional properties can be passed:】

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

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

• 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。

【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.】

verify 对象在调用 verify.verify() 之后不能再次使用。多次调用 verify.verify() 会导致抛出错误。

【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.】

类：X509Certificate#>

【Class: X509Certificate】

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

【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);const { X509Certificate } = require('node:crypto');

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

console.log(x509.subject);拷贝

new X509Certificate(buffer)#>

• buffer <string> | <TypedArray> | <Buffer> | <DataView> 一个 PEM 或 DER 编码的 X509 证书。

x509.ca#>

• 类型: <boolean> 如果这是一个证书颁发机构 (CA) 证书，该值将为 true。

x509.checkEmail(email[, options])#>

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

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

【Checks whether the certificate matches the given email address.】

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

【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.】

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

【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.】

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

【If the 'subject' option is set to 'never', the certificate subject is never considered, even if the certificate contains no subject alternative names.】

x509.checkHost(name[, options])#>

• name <string>
• options <Object>
  • subject <string> 'default'、 'always' 或 'never'。 默认值: 'default'。
  • wildcards <boolean> 默认值: true。
  • partialWildcards <boolean> 默认值: true。
  • multiLabelWildcards <boolean> 默认值: false。
  • singleLabelSubdomains <boolean> 默认值: false。
• 返回值: <string> | <undefined> 返回与 name 匹配的主题名称， 如果没有主题名称匹配 name，则返回 undefined。

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

【Checks whether the certificate matches the given host name.】

如果证书与给定的主机名匹配，则会返回匹配的主题名称。返回的名称可能是完全匹配（例如，foo.example.com），也可能包含通配符（例如，*.example.com）。由于主机名比较不区分大小写，返回的主题名称在大小写上可能也与给定的 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.】

如果 'subject' 选项未定义或设置为 'default'，只有在主题备用名称扩展不存在或不包含任何 DNS 名称时，才会考虑证书主题。这种行为与 RFC 2818（“通过 TLS 的 HTTP”）一致。

【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").】

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

【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.】

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

【If the 'subject' option is set to 'never', the certificate subject is never considered, even if the certificate contains no subject alternative names.】

x509.checkIP(ip)#>

• ip <string>
• 返回值: <string> | <undefined> 如果证书匹配则返回 ip，如果不匹配则返回 undefined。

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

【Checks whether the certificate matches the given IP address (IPv4 or IPv6).】

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

【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.】

x509.checkIssued(otherCert)#>

• otherCert <X509Certificate>
• 返回: <boolean>

通过比较证书元数据，检查此证书是否可能由给定的 otherCert 签发。

【Checks whether this certificate was potentially issued by the given otherCert by comparing the certificate metadata.】

这对于修剪可能的发行者证书列表很有用，这些证书是通过更基本的筛选方法选择的，即仅根据主体和发行者名称。

【This is useful for pruning a list of possible issuer certificates which have been selected using a more rudimentary filtering routine, i.e. just based on subject and issuer names.】

最后，要验证该证书的签名是否由与 otherCert 的公钥对应的私钥生成，使用 x509.verify(publicKey)，并将 otherCert 的公钥表示为 KeyObject，如下所示

【Finally, to verify that this certificate's signature was produced by a private key corresponding to otherCert's public key use x509.verify(publicKey) with otherCert's public key represented as a KeyObject like so】

if (!x509.verify(otherCert.publicKey)) {
  throw new Error('otherCert did not issue x509');
} 拷贝

x509.checkPrivateKey(privateKey)#>

• privateKey <KeyObject> 私钥。
• 返回值: <boolean>

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

【Checks whether the public key for this certificate is consistent with the given private key.】

x509.fingerprint#>

• 类型: <string>

此证书的 SHA-1 指纹。

【The SHA-1 fingerprint of this certificate.】

由于 SHA-1 在密码学上已被破解，并且 SHA-1 的安全性明显不如常用于签署证书的算法，因此建议考虑使用 x509.fingerprint256 替代。

【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.】

x509.fingerprint256#>

• 类型: <string>

此证书的 SHA-256 指纹。

【The SHA-256 fingerprint of this certificate.】

x509.fingerprint512#>

• 类型: <string>

此证书的 SHA-512 指纹。

【The SHA-512 fingerprint of this certificate.】

由于计算 SHA-256 指纹通常更快，并且其大小只有 SHA-512 指纹的一半，x509.fingerprint256 可能是更好的选择。虽然 SHA-512 通常被认为提供更高水平的安全性，但 SHA-256 的安全性与大多数常用来签发证书的算法相匹配。

【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.】

x509.infoAccess#>

• 类型: <string>

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

【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.】

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

【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.】

x509.issuer#>

• 类型: <string>

此证书中包含的发行人标识。

【The issuer identification included in this certificate.】

x509.issuerCertificate#>

• 类型: <X509Certificate>

颁发者证书，如果无法获得颁发者证书，则为 undefined。

【The issuer certificate or undefined if the issuer certificate is not available.】

x509.keyUsage#>

• 类型: <string[]>

详细说明此证书的关键扩展用途的数组。

【An array detailing the key extended usages for this certificate.】

x509.publicKey#>

• 类型: <KeyObject>

此证书的公钥 <KeyObject>。

【The public key <KeyObject> for this certificate.】

x509.raw#>

• 类型: <Buffer>

一个包含该证书 DER 编码的 Buffer。

【A Buffer containing the DER encoding of this certificate.】

x509.serialNumber#>

• 类型: <string>

此证书的序列号。

【The serial number of this certificate.】

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

【Serial numbers are assigned by certificate authorities and do not uniquely identify certificates. Consider using x509.fingerprint256 as a unique identifier instead.】

x509.subject#>

• 类型: <string>

本证书的完整主题。

【The complete subject of this certificate.】

x509.subjectAltName#>

• 类型: <string>

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

【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.】

Node.js 的早期版本错误地认为将此属性按照两个字符的序列 ', ' 分割是安全的（见 CVE-2021-44532）。然而，无论是恶意的还是合法的证书，其主题备用名称在以字符串表示时都可能包含该序列。

【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.】

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

【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.】

x509.toJSON()#>

• 类型: <string>

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

【There is no standard JSON encoding for X509 certificates. The toJSON() method returns a string containing the PEM encoded certificate.】

x509.toLegacyObject()#>

• 类型: <Object>

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

【Returns information about this certificate using the legacy certificate object encoding.】

x509.toString()#>

• 类型: <string>

返回 PEM 编码的证书。

【Returns the PEM-encoded certificate.】

x509.validFrom#>

• 类型: <string>

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

【The date/time from which this certificate is valid.】

x509.validFromDate#>

• 类型: <Date>

此证书有效的日期/时间，封装在一个 Date 对象中。

【The date/time from which this certificate is valid, encapsulated in a Date object.】

x509.validTo#>

• 类型: <string>

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

【The date/time until which this certificate is valid.】

x509.validToDate#>

• 类型: <Date>

此证书有效的日期/时间，封装在一个 Date 对象中。

【The date/time until which this certificate is valid, encapsulated in a Date object.】

x509.verify(publicKey)#>

• publicKey <KeyObject> 公钥。
• 返回: <boolean>

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

【Verifies that this certificate was signed by the given public key. Does not perform any other validation checks on the certificate.】

node:crypto 模块的方法和属性#>

【node:crypto module methods and properties】

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

• candidate <ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint> 一个可能的素数，编码为任意长度的大端字节序列。
• options <Object>
  • checks <number> 要执行的 Miller-Rabin 概率素性检验的次数。当值为 0（零）时，将使用一种在随机输入下产生最多 2^-64 假阳性概率的检验次数。在选择检验次数时必须谨慎。有关详细信息，请参阅 OpenSSL 文档中 BN_is_prime_ex 函数 nchecks 选项。默认值: 0
• callback <Function>
  • err <Error> 如果在检查期间发生错误，则设置为一个 <Error> 对象。
  • result <boolean> 如果候选数是素数且错误概率小于 0.25 ** options.checks，则值为 true。

检查 candidate 是否为质数。

【Checks the primality of the candidate.】

crypto.checkPrimeSync(candidate[, options])#>

• candidate <ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint> 一个可能的素数，以大端字节序的任意长度字节序列编码。
• options <Object>
  • checks <number> 要执行的 Miller-Rabin 概率素性测试迭代次数。当值为 0（零）时，将使用足够的测试次数，使随机输入的假阳性率最大为 2^-64 。选择测试次数时需要小心。有关更多详细信息，请参阅 OpenSSL 文档中 BN_is_prime_ex 函数 nchecks 的选项说明。默认值： 0
• 返回值: <boolean> 如果候选数是素数且错误概率小于 0.25 ** options.checks，则返回 true。

检查 candidate 是否为质数。

【Checks the primality of the candidate.】

crypto.constants#>

• 类型: <Object>

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

【An object containing commonly used constants for crypto and security related operations. The specific constants currently defined are described in Crypto constants.】

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

• algorithm <string>
• key <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>
• iv <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <null>
• options <Object> stream.transform 选项
• 返回：<Cipher>

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

【Creates and returns a Cipher object, with the given algorithm, key and initialization vector (iv).】

options 参数控制流的行为，通常是可选的，除非使用 CCM 或 OCB 模式的加密算法（例如 'aes-128-ccm'）。在这种情况下，authTagLength 选项是必需的，用于指定认证标签的字节长度，详见 CCM 模式。在 GCM 模式下，authTagLength 选项不是必需的，但可以用来设置 getAuthTag() 返回的认证标签长度，默认值为 16 字节。对于 chacha20-poly1305，authTagLength 选项默认为 16 字节。

【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 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.】

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

【The algorithm is dependent on OpenSSL, examples are 'aes192', etc. On recent OpenSSL releases, openssl list -cipher-algorithms will display the available cipher algorithms.】

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

【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.】

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

【When passing strings for key or iv, please consider caveats when using strings as inputs to cryptographic APIs.】

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

【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.】

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

• algorithm <string>
• key <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>
• iv <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <null>
• options <Object> stream.transform 选项
• 返回：<Decipher>

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

【Creates and returns a Decipher object that uses the given algorithm, key and initialization vector (iv).】

options 参数用于控制流的行为，通常是可选的，除非使用 CCM 或 OCB 模式的加密算法（例如 'aes-128-ccm'）。在这种情况下，authTagLength 选项是必需的，用于指定认证标签的字节长度，详见 CCM 模式。在 GCM 模式下，authTagLength 选项不是必需的，但可以用来限制接受的认证标签必须具有指定长度。对于 chacha20-poly1305，authTagLength 选项默认为 16 字节。

【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.】

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

【The algorithm is dependent on OpenSSL, examples are 'aes192', etc. On recent OpenSSL releases, openssl list -cipher-algorithms will display the available cipher algorithms.】

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

【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.】

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

【When passing strings for key or iv, please consider caveats when using strings as inputs to cryptographic APIs.】

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

【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.】

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

• prime <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• primeEncoding <string> prime 字符串的 编码。
• generator <number> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 默认值: 2
• generatorEncoding <string> generator 字符串的 编码。
• 返回: <DiffieHellman>

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

【Creates a DiffieHellman key exchange object using the supplied prime and an optional specific generator.】

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

【The generator argument can be a number, string, or Buffer. If generator is not specified, the value 2 is used.】

如果指定了 primeEncoding，则 prime 应为字符串；否则，应为 Buffer、TypedArray 或 DataView。

【If primeEncoding is specified, prime is expected to be a string; otherwise a Buffer, TypedArray, or DataView is expected.】

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

【If generatorEncoding is specified, generator is expected to be a string; otherwise a number, Buffer, TypedArray, or DataView is expected.】

crypto.createDiffieHellman(primeLength[, generator])#>

• primeLength <number>
• generator <number> 默认值: 2
• 返回: <DiffieHellman>

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

【Creates a DiffieHellman key exchange object and generates a prime of primeLength bits using an optional specific numeric generator. If generator is not specified, the value 2 is used.】

crypto.createDiffieHellmanGroup(name)#>

• name <string>
• 返回: <DiffieHellmanGroup>

crypto.getDiffieHellman() 的别名

【An alias for crypto.getDiffieHellman()】

crypto.createECDH(curveName)#>

• curveName <string>
• 返回值: <ECDH>

使用由 curveName 字符串指定的预定义曲线创建一个椭圆曲线迪菲-赫尔曼（ECDH）密钥交换对象。使用 crypto.getCurves() 可以获取可用曲线名称的列表。在最近的 OpenSSL 版本中，openssl ecparam -list_curves 也会显示每个可用椭圆曲线的名称和描述。

【Creates an Elliptic Curve Diffie-Hellman (ECDH) key exchange object using a predefined curve specified by the curveName string. Use crypto.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.】

crypto.createHash(algorithm[, options])#>

• 算法 <string>
• 选项 <Object> stream.transform 选项
• 返回: <Hash>

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

【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.】

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

【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.】

示例：生成文件的 sha256 校验和

【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}`);
  }
});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}`);
  }
});拷贝

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

• algorithm <string>
• key <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>
• options <Object> stream.transform 选项
  • encoding <string> 当 key 为字符串时使用的字符串编码。
• 返回: <Hmac>

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

【Creates and returns an Hmac object that uses the given algorithm and key. Optional options argument controls stream behavior.】

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

【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.】

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

【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 crypto.randomBytes() or crypto.generateKey(), its length should not exceed the block size of algorithm (e.g., 512 bits for SHA-256).】

示例：生成文件的 sha256 HMAC

【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}`);
  }
});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}`);
  }
});拷贝

crypto.createPrivateKey(key)#>

• key <Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
  • key <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <Object> 密钥材料，可以是 PEM、DER 或 JWK 格式。
  • format <string> 必须是 'pem'、'der' 或 'jwk'。默认值： 'pem'。
  • type <string> 必须是 'pkcs1'、'pkcs8' 或 'sec1'。仅当 format 为 'der' 时此选项为必填，否则会被忽略。
  • passphrase <string> | <Buffer> 用于解密的密码。
  • encoding <string> 当 key 为字符串时使用的字符串编码。* 返回：<KeyObject>

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

【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.】

如果私钥被加密，必须指定 passphrase。口令的长度限制为 1024 字节。

【If the private key is encrypted, a passphrase must be specified. The length of the passphrase is limited to 1024 bytes.】

crypto.createPublicKey(key)#>

• key <Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
  • key <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <Object> 密钥材料，可以是 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 必须是具有上述属性的对象。

【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.】

如果格式为‘pem’，‘key’也可以是 X.509 证书。

【If the format is 'pem', the 'key' may also be an X.509 certificate.】

由于公钥可以从私钥派生，因此可以传递私钥而不是公钥。在这种情况下，该函数的行为就像调用了 crypto.createPrivateKey()，只是返回的 KeyObject 的类型将是 'public'，且无法从返回的 KeyObject 中提取私钥。类似地，如果提供了类型为 'private' 的 KeyObject，将返回一个类型为 'public' 的新 KeyObject，并且无法从返回的对象中提取私钥。

【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 crypto.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.】

crypto.createSecretKey(key[, encoding])#>

• key <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> 当 key 是字符串时的字符串编码。
• 返回: <KeyObject>

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

【Creates and returns a new key object containing a secret key for symmetric encryption or Hmac.】

crypto.createSign(algorithm[, options])#>

• 算法 <string>
• 选项 <Object> stream.Writable 选项
• 返回: <Sign>

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

【Creates and returns a Sign object that uses the given algorithm. Use crypto.getHashes() to obtain the names of the available digest algorithms. Optional options argument controls the stream.Writable behavior.】

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

【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.】

crypto.createVerify(algorithm[, options])#>

• 算法 <string>
• 选项 <Object> stream.Writable 选项
• 返回: <Verify>

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

【Creates and returns a Verify object that uses the given algorithm. Use crypto.getHashes() to obtain an array of names of the available signing algorithms. Optional options argument controls the stream.Writable behavior.】

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

【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.】

crypto.diffieHellman(options)#>

• options：<Object>
  • privateKey：<KeyObject>
  • publicKey：<KeyObject>
• 返回值：<Buffer>

基于 privateKey 和 publicKey 计算 Diffie-Hellman 密钥。两把密钥必须具有相同的 asymmetricKeyType，其类型必须为 'dh'（用于 Diffie-Hellman）、'ec'、'x448' 或 'x25519'（用于 ECDH）。

【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', 'x448', or 'x25519' (for ECDH).】

crypto.fips#>

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

【Property for checking and controlling whether a FIPS compliant crypto provider is currently in use. Setting to true requires a FIPS build of Node.js.】

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

【This property is deprecated. Please use crypto.setFips() and crypto.getFips() instead.】

crypto.generateKey(type, options, callback)#>

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

异步生成一个指定 length 的新随机密钥。type 将决定对 length 执行哪些验证。

【Asynchronously 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
});const {
  generateKey,
} = require('node:crypto');

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

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

【The size of a generated HMAC key should not exceed the block size of the underlying hash function. See crypto.createHmac() for more information.】

crypto.generateKeyPair(type, options, callback)#>

• type <string> 必须是 'rsa'、'rsa-pss'、'dsa'、'ec'、'ed25519'、'ed448'、'x25519'、'x448' 或 'dh'。
• options <Object>
  • '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 <string> Diffie-Hellman 组名称 (DH)。参见 crypto.getDiffieHellman()。
  • paramEncoding <string> 必须是 'named' 或 'explicit'（EC）。 默认值： 'named'。
  • publicKeyEncoding <Object> 参见 keyObject.export()。
  • privateKeyEncoding <Object> 参见 keyObject.export()。
• 回调 <Function>
  • 错误 <Error>
  • publicKey <string> | <Buffer> | <KeyObject>
  • privateKey <string> | <Buffer> | <KeyObject>

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

【Generates a new asymmetric key pair of the given type. RSA, RSA-PSS, DSA, EC, Ed25519, Ed448, X25519, X448, and DH are currently supported.】

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

【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.】

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

【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.
});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.
});拷贝

完成后，callback 将被调用，err 的值为 undefined，publicKey / privateKey 表示生成的密钥对。

【On completion, callback will be called with err set to undefined and publicKey / privateKey representing the generated key pair.】

如果以其 util.promisify()ed 版本调用此方法，它将返回一个包含 publicKey 和 privateKey 属性的 Object 的 Promise。

【If this method is invoked as its util.promisify()ed version, it returns a Promise for an Object with publicKey and privateKey properties.】