- assert 断言
- async_hooks 异步钩子
- async_hooks/context 异步上下文
- buffer 缓冲区
- C++插件
- C/C++插件(使用 Node-API)
- C++嵌入器
- child_process 子进程
- cluster 集群
- CLI 命令行
- console 控制台
- Corepack 核心包
- crypto 加密
- crypto/webcrypto 网络加密
- debugger 调试器
- deprecation 弃用
- dgram 数据报
- diagnostics_channel 诊断通道
- dns 域名服务器
- domain 域
- Error 错误
- events 事件触发器
- fs 文件系统
- global 全局变量
- http 超文本传输协议
- http2 超文本传输协议 2.0
- https 安全超文本传输协议
- inspector 检查器
- Intl 国际化
- module 模块
- module/cjs CommonJS 模块
- module/esm ECMAScript 模块
- module/package 包模块
- module/typescript TS 模块
- net 网络
- os 操作系统
- path 路径
- perf_hooks 性能钩子
- permission 权限
- process 进程
- punycode 域名代码
- querystring 查询字符串
- readline 逐行读取
- repl 交互式解释器
- report 诊断报告
- sea 单个可执行应用程序
Node.js v22.11.0 文档
- Node.js v22.11.0
-
目录
- 加密
- 确定加密支持是否不可用
- 类:
Certificate
- 类:
Cipher
- 类:
Decipher
- 类:
DiffieHellman
diffieHellman.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])
diffieHellman.generateKeys([encoding])
diffieHellman.getGenerator([encoding])
diffieHellman.getPrime([encoding])
diffieHellman.getPrivateKey([encoding])
diffieHellman.getPublicKey([encoding])
diffieHellman.setPrivateKey(privateKey[, encoding])
diffieHellman.setPublicKey(publicKey[, encoding])
diffieHellman.verifyError
- 类:
DiffieHellmanGroup
- 类:
ECDH
- 静态方法:
ECDH.convertKey(key, curve[, inputEncoding[, outputEncoding[, format]]])
ecdh.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])
ecdh.generateKeys([encoding[, format]])
ecdh.getPrivateKey([encoding])
ecdh.getPublicKey([encoding][, format])
ecdh.setPrivateKey(privateKey[, encoding])
ecdh.setPublicKey(publicKey[, encoding])
- 静态方法:
- 类:
Hash
- 类:
Hmac
- 类:
KeyObject
- 类:
Sign
- 类:
Verify
- 类:
X509Certificate
new X509Certificate(buffer)
x509.ca
x509.checkEmail(email[, options])
x509.checkHost(name[, options])
x509.checkIP(ip)
x509.checkIssued(otherCert)
x509.checkPrivateKey(privateKey)
x509.fingerprint
x509.fingerprint256
x509.fingerprint512
x509.infoAccess
x509.issuer
x509.issuerCertificate
x509.extKeyUsage
x509.publicKey
x509.raw
x509.serialNumber
x509.subject
x509.subjectAltName
x509.toJSON()
x509.toLegacyObject()
x509.toString()
x509.validFrom
x509.validFromDate
x509.validTo
x509.validToDate
x509.verify(publicKey)
node:crypto
模块方法和属性crypto.constants
crypto.fips
crypto.checkPrime(candidate[, options], callback)
crypto.checkPrimeSync(candidate[, options])
crypto.createCipheriv(algorithm, key, iv[, options])
crypto.createDecipheriv(algorithm, key, iv[, options])
crypto.createDiffieHellman(prime[, primeEncoding][, generator][, generatorEncoding])
crypto.createDiffieHellman(primeLength[, generator])
crypto.createDiffieHellmanGroup(name)
crypto.createECDH(curveName)
crypto.createHash(algorithm[, options])
crypto.createHmac(algorithm, key[, options])
crypto.createPrivateKey(key)
crypto.createPublicKey(key)
crypto.createSecretKey(key[, encoding])
crypto.createSign(algorithm[, options])
crypto.createVerify(algorithm[, options])
crypto.diffieHellman(options)
crypto.hash(algorithm, data[, outputEncoding])
crypto.generateKey(type, options, callback)
crypto.generateKeyPair(type, options, callback)
crypto.generateKeyPairSync(type, options)
crypto.generateKeySync(type, options)
crypto.generatePrime(size[, options[, callback]])
crypto.generatePrimeSync(size[, options])
crypto.getCipherInfo(nameOrNid[, options])
crypto.getCiphers()
crypto.getCurves()
crypto.getDiffieHellman(groupName)
crypto.getFips()
crypto.getHashes()
crypto.getRandomValues(typedArray)
crypto.hkdf(digest, ikm, salt, info, keylen, callback)
crypto.hkdfSync(digest, ikm, salt, info, keylen)
crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)
crypto.pbkdf2Sync(password, salt, iterations, keylen, digest)
crypto.privateDecrypt(privateKey, buffer)
crypto.privateEncrypt(privateKey, buffer)
crypto.publicDecrypt(key, buffer)
crypto.publicEncrypt(key, buffer)
crypto.randomBytes(size[, callback])
crypto.randomFillSync(buffer[, offset][, size])
crypto.randomFill(buffer[, offset][, size], callback)
crypto.randomInt([min, ]max[, callback])
crypto.randomUUID([options])
crypto.scrypt(password, salt, keylen[, options], callback)
crypto.scryptSync(password, salt, keylen[, options])
crypto.secureHeapUsed()
crypto.setEngine(engine[, flags])
crypto.setFips(bool)
crypto.sign(algorithm, data, key[, callback])
crypto.subtle
crypto.timingSafeEqual(a, b)
crypto.verify(algorithm, data, key, signature[, callback])
crypto.webcrypto
- 注意事项
- 加密常量
- 加密
-
导航
- assert 断言
- async_hooks 异步钩子
- async_hooks/context 异步上下文
- buffer 缓冲区
- C++插件
- C/C++插件(使用 Node-API)
- C++嵌入器
- child_process 子进程
- cluster 集群
- CLI 命令行
- console 控制台
- Corepack 核心包
- crypto 加密
- crypto/webcrypto 网络加密
- debugger 调试器
- deprecation 弃用
- dgram 数据报
- diagnostics_channel 诊断通道
- dns 域名服务器
- domain 域
- Error 错误
- events 事件触发器
- fs 文件系统
- global 全局变量
- http 超文本传输协议
- http2 超文本传输协议 2.0
- https 安全超文本传输协议
- inspector 检查器
- Intl 国际化
- module 模块
- module/cjs CommonJS 模块
- module/esm ECMAScript 模块
- module/package 包模块
- module/typescript TS 模块
- net 网络
- os 操作系统
- path 路径
- perf_hooks 性能钩子
- permission 权限
- process 进程
- punycode 域名代码
- querystring 查询字符串
- readline 逐行读取
- repl 交互式解释器
- report 诊断报告
- sea 单个可执行应用程序
- 其他版本
加密#
¥Crypto
¥Stability: 2 - Stable
源代码: lib/crypto.js
node:crypto
模块提供了加密功能,其中包括了用于 OpenSSL 散列、HMAC、加密、解密、签名、以及验证的函数的一整套封装。
¥The node:crypto
module provides cryptographic functionality that includes a
set of wrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify
functions.
const { createHmac } = await import('node:crypto');
const secret = 'abcdefg';
const hash = createHmac('sha256', secret)
.update('I love cupcakes')
.digest('hex');
console.log(hash);
// Prints:
// c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
const { createHmac } = require('node:crypto');
const secret = 'abcdefg';
const hash = createHmac('sha256', secret)
.update('I love cupcakes')
.digest('hex');
console.log(hash);
// Prints:
// c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
确定加密支持是否不可用#
¥Determining if crypto support is unavailable
可以在不支持 node:crypto
模块的情况下构建 Node.js。在这种情况下,尝试 import
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 实现的一种 Certificate Signing Request 机制,被正式指定为 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 新项目不应再使用此元素。
¥<keygen>
is deprecated since HTML 5.2 and new projects
should not use this element anymore.
node:crypto
模块提供了用于处理 SPKAC 数据的 Certificate
类。最常见的用法是处理由 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> -
返回:<Buffer>
spkac
数据结构的挑战组件,包括公钥和挑战。¥Returns: <Buffer> The challenge component of the
spkac
data structure, which includes a public key and a challenge.
const { Certificate } = await import('node:crypto');
const spkac = getSpkacSomehow();
const challenge = Certificate.exportChallenge(spkac);
console.log(challenge.toString('utf8'));
// Prints: the challenge as a UTF8 string
const { 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> -
返回:<Buffer>
spkac
数据结构的公钥组件,包括公钥和挑战。¥Returns: <Buffer> The public key component of the
spkac
data structure, which includes a public key and a challenge.
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> -
返回:<boolean> 如果给定的
spkac
数据结构有效,则为true
,否则为false
。¥Returns: <boolean>
true
if the givenspkac
data structure is valid,false
otherwise.
import { Buffer } from 'node:buffer';
const { Certificate } = await import('node:crypto');
const spkac = getSpkacSomehow();
console.log(Certificate.verifySpkac(Buffer.from(spkac)));
// Prints: true or false
const { 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
¥Stability: 0 - Deprecated
作为旧版接口,可以创建 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> -
返回:<Buffer>
spkac
数据结构的挑战组件,包括公钥和挑战。¥Returns: <Buffer> The challenge component of the
spkac
data structure, which includes a public key and a challenge.
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 string
const { 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> -
返回:<Buffer>
spkac
数据结构的公钥组件,包括公钥和挑战。¥Returns: <Buffer> The public key component of the
spkac
data structure, which includes a public key and a challenge.
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> -
返回:<boolean> 如果给定的
spkac
数据结构有效,则为true
,否则为false
。¥Returns: <boolean>
true
if the givenspkac
data structure is valid,false
otherwise.
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 false
const { 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
-
¥Extends: <stream.Transform>
Cipher
类的实例用于加密数据。可以通过以下两种方式之一使用该类:
¥Instances of the Cipher
class are used to encrypt data. The class can be
used in one of two ways:
-
作为可读可写的 流,写入未加密的普通数据以在可读端生成加密数据,或者
¥As a stream that is both readable and writable, where plain unencrypted data is written to produce encrypted data on the readable side, or
-
使用
cipher.update()
和cipher.final()
方法生成加密的数据。¥Using the
cipher.update()
andcipher.final()
methods to produce the encrypted data.
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])
#
-
返回:<Buffer> | <string> 任何剩余的加密内容。如果指定了
outputEncoding
,则返回字符串。如果未提供outputEncoding
,则返回Buffer
。¥Returns: <Buffer> | <string> Any remaining enciphered contents. If
outputEncoding
is specified, a string is returned. If anoutputEncoding
is not provided, aBuffer
is returned.
一旦调用了 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
,其中包含根据给定数据计算出的身份验证标记。¥Returns: <Buffer> When using an authenticated encryption mode (
GCM
,CCM
,OCB
, andchacha20-poly1305
are currently supported), thecipher.getAuthTag()
method returns aBuffer
containing the authentication tag that has been computed from the given data.
只有在使用 cipher.final()
方法完成加密后才应调用 cipher.getAuthTag()
方法。
¥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
选项¥
options
<Object>stream.transform
options -
返回:<Cipher> 用于方法链接的相同
Cipher
实例。¥Returns: <Cipher> The same
Cipher
instance for method chaining.
当使用经过身份验证的加密模式(当前支持 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
¥
autoPadding
<boolean> Default:true
-
返回:<Cipher> 用于方法链接的相同
Cipher
实例。¥Returns: <Cipher> The same
Cipher
instance for method chaining.
当使用块加密算法时,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>
使用 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
-
¥Extends: <stream.Transform>
Decipher
类的实例用于解密数据。可以通过以下两种方式之一使用该类:
¥Instances of the Decipher
class are used to decrypt data. The class can be
used in one of two ways:
-
作为可读可写的 流,写入普通加密数据以在可读端生成未加密数据,或者
¥As a stream that is both readable and writable, where plain encrypted data is written to produce unencrypted data on the readable side, or
-
使用
decipher.update()
和decipher.final()
方法生成未加密的数据。¥Using the
decipher.update()
anddecipher.final()
methods to produce the unencrypted data.
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 data
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);
// 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])
#
-
返回:<Buffer> | <string> 任何剩余的解密内容。如果指定了
outputEncoding
,则返回字符串。如果未提供outputEncoding
,则返回Buffer
。¥Returns: <Buffer> | <string> Any remaining deciphered contents. If
outputEncoding
is specified, a string is returned. If anoutputEncoding
is not provided, aBuffer
is returned.
一旦调用了 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
选项¥
options
<Object>stream.transform
options -
返回:<Decipher> 方法链接的相同解密。
¥Returns: <Decipher> The same Decipher for method chaining.
当使用经过身份验证的加密模式(当前支持 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
是字符串时使用的字符串编码。¥
encoding
<string> String encoding to use whenbuffer
is a string. -
返回:<Decipher> 方法链接的相同解密。
¥Returns: <Decipher> The same Decipher for method chaining.
使用鉴权加密方式时(目前支持 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.
CCM
模式必须在 decipher.update()
之前调用 decipher.setAuthTag()
方法,对于 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
¥
autoPadding
<boolean> Default:true
-
返回:<Decipher> 方法链接的相同解密。
¥Returns: <Decipher> The same Decipher for method chaining.
当数据在没有标准块填充的情况下加密时,调用 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>
用 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
字符串的 字符编码。¥
inputEncoding
<string> The encoding of anotherPublicKey
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])
#
生成私有和公共 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
中的 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
中的 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
中的 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
中的 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>
设置 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>
设置 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 节)¥
'modp14'
(2048 bits, RFC 3526 Section 3) -
'modp15'
(3072 位,RFC 3526 第 4 节)¥
'modp15'
(3072 bits, RFC 3526 Section 4) -
'modp16'
(4096 位,RFC 3526 第 5 节)¥
'modp16'
(4096 bits, RFC 3526 Section 5) -
'modp17'
(6144 位,RFC 3526 第 6 节)¥
'modp17'
(6144 bits, RFC 3526 Section 6) -
'modp18'
(8192 位,RFC 3526 第 7 节)¥
'modp18'
(8192 bits, RFC 3526 Section 7)
以下组仍受支持但已弃用(请参阅 注意事项):
¥The following groups are still supported but deprecated (see Caveats):
-
'modp1'
(768 位,RFC 2409 第 6.1 节)¥
'modp1'
(768 bits, RFC 2409 Section 6.1) -
'modp2'
(1024 位,RFC 2409 第 6.2 节)¥
'modp2'
(1024 bits, RFC 2409 Section 6.2) -
'modp5'
(1536 位,RFC 3526 第 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'));
// OK
const 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> -
format
<string> 默认值:'uncompressed'
¥
format
<string> Default:'uncompressed'
将 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
字符串的 字符编码。¥
inputEncoding
<string> The encoding of theotherPublicKey
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.
当 otherPublicKey
位于椭圆曲线之外时,ecdh.computeSecret
将抛出 ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY
错误。由于 otherPublicKey
通常由远程用户通过不安全的网络提供,因此请务必相应地处理此异常。
¥ecdh.computeSecret
will throw an
ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY
error when otherPublicKey
lies outside of the elliptic curve. Since otherPublicKey
is
usually supplied from a remote user over an insecure network,
be sure to handle this exception accordingly.
ecdh.generateKeys([encoding[, format]])
#
生成私有和公共 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])
#
-
返回:<Buffer> | <string> 指定
encoding
中的 EC Diffie-Hellman。¥Returns: <Buffer> | <string> The EC Diffie-Hellman in the specified
encoding
.
如果指定了 encoding
,则返回一个字符串;否则返回 Buffer
。
¥If encoding
is specified, a string is returned; otherwise a Buffer
is
returned.
ecdh.getPublicKey([encoding][, format])
#
-
format
<string> 默认值:'uncompressed'
¥
format
<string> Default:'uncompressed'
-
返回:<Buffer> | <string> 指定
encoding
和format
中的 EC Diffie-Hellman 公钥。¥Returns: <Buffer> | <string> The EC Diffie-Hellman public key in the specified
encoding
andformat
.
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>
设置 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])
#
¥Stability: 0 - Deprecated
-
publicKey
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
设置 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
-
¥Extends: <stream.Transform>
Hash
类是用于创建数据的哈希摘要的实用工具。它可以通过以下两种方式之一使用:
¥The Hash
class is a utility for creating hash digests of data. It can be
used in one of two ways:
-
作为可读可写的 流,写入数据以在可读端生成计算的哈希摘要,或者
¥As a stream that is both readable and writable, where data is written to produce a computed hash digest on the readable side, or
-
使用
hash.update()
和hash.digest()
方法生成计算的哈希。¥Using the
hash.update()
andhash.digest()
methods to produce the computed hash.
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:
// 6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
const {
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
选项¥
options
<Object>stream.transform
options -
返回:<Hash>
¥Returns: <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.digest()
方法后尝试复制 Hash
对象时会引发错误。
¥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])
#
计算传给被哈希的所有数据的摘要(使用 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>
使用给定的 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
-
¥Extends: <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 摘要,或者
¥As a stream that is both readable and writable, where data is written to produce a computed HMAC digest on the readable side, or
-
使用
hmac.update()
和hmac.digest()
方法生成计算出的 HMAC 摘要。¥Using the
hmac.update()
andhmac.digest()
methods to produce the computed HMAC digest.
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:
// 7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
const {
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])
#
计算使用 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>
使用给定的 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 Buffer
s due to improved security features.
KeyObject
实例可以通过 postMessage()
传给其他线程。接收者获得克隆的 KeyObject
,KeyObject
不需要在 transferList
参数中列出。
¥KeyObject
instances can be passed to other threads via postMessage()
.
The receiver obtains a cloned KeyObject
, and the KeyObject
does not need to
be listed in the transferList
argument.
静态方法:KeyObject.from(key)
#
¥Static method: KeyObject.from(key)
-
key
<CryptoKey> -
返回:<KeyObject>
¥Returns: <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
#
-
-
modulusLength
:<number> 以位为单位的密钥大小(RSA、DSA)。¥
modulusLength
: <number> Key size in bits (RSA, DSA). -
publicExponent
:<bigint> 公共指数 (RSA)。¥
publicExponent
: <bigint> Public exponent (RSA). -
hashAlgorithm
:<string> 消息摘要的名称 (RSA-PSS)。¥
hashAlgorithm
: <string> Name of the message digest (RSA-PSS). -
mgf1HashAlgorithm
:<string> MGF1 (RSA-PSS) 使用的消息摘要的名称。¥
mgf1HashAlgorithm
: <string> Name of the message digest used by MGF1 (RSA-PSS). -
saltLength
:<number> 以字节为单位的最小盐长度 (RSA-PSS)。¥
saltLength
: <number> Minimal salt length in bytes (RSA-PSS). -
divisorLength
:<number>q
的大小(以位为单位)(DSA)。¥
divisorLength
: <number> Size ofq
in bits (DSA). -
namedCurve
:<string> 曲线的名称 (EC)。¥
namedCurve
: <string> Name of the curve (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
#
对于非对称密钥,此属性表示密钥的类型。支持的密钥类型有:
¥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.export([options])
#
对于对称密钥,可以使用以下编码选项:
¥For symmetric keys, the following encoding options can be used:
对于公钥,可以使用以下编码选项:
¥For public keys, the following encoding options can be used:
-
type
:<string> 必须是'pkcs1'
(仅限 RSA)或'spki'
之一。¥
type
: <string> Must be one of'pkcs1'
(RSA only) or'spki'
. -
format
:<string> 必须是'pem'
、'der'
或'jwk'
。¥
format
: <string> Must be'pem'
,'der'
, or'jwk'
.
对于私钥,可以使用以下编码选项:
¥For private keys, the following encoding options can be used:
-
type
:<string> 必须是'pkcs1'
(仅限 RSA)、'pkcs8'
或'sec1'
(仅限 EC)之一。¥
type
: <string> Must be one of'pkcs1'
(RSA only),'pkcs8'
or'sec1'
(EC only). -
format
:<string> 必须是'pem'
、'der'
或'jwk'
。¥
format
: <string> Must be'pem'
,'der'
, or'jwk'
. -
cipher
:<string> 如果指定,私钥将使用给定的cipher
和passphrase
使用基于 PKCS#5 v2.0 密码的加密进行加密。¥
cipher
: <string> If specified, the private key will be encrypted with the givencipher
andpassphrase
using PKCS#5 v2.0 password based encryption. -
passphrase
:<string> | <Buffer> 用于加密的密码,请参阅cipher
。¥
passphrase
: <string> | <Buffer> The passphrase to use for encryption, seecipher
.
结果类型取决于所选的编码格式,当 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.
PKCS#1、SEC1 和 PKCS#8 类型的密钥可以通过使用 cipher
和 format
选项的组合进行加密。PKCS#8 type
可以与任何 format
一起使用,通过指定 cipher
来加密任何密钥算法(RSA、EC 或 DH)。当使用 PEM format
时,PKCS#1 和 SEC1 只能通过指定 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.equals(otherKeyObject)
#
-
otherKeyObject
:<KeyObject> 用于与keyObject
进行比较的KeyObject
。¥
otherKeyObject
: <KeyObject> AKeyObject
with which to comparekeyObject
. -
返回:<boolean>
¥Returns: <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.symmetricKeySize
#
对于秘密密钥,此属性表示密钥的大小(以字节为单位)。对于非对称密钥,此属性为 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)
#
algorithm
:<AlgorithmIdentifier> | <RsaHashedImportParams> | <EcKeyImportParams> | <HmacImportParams>
-
extractable
:<boolean> -
keyUsages
:<string[]> 参见 关键用法。¥
keyUsages
: <string[]> See Key usages. -
返回:<CryptoKey>
¥Returns: <CryptoKey>
将 KeyObject
实例转换为 CryptoKey
。
¥Converts a KeyObject
instance to a CryptoKey
.
keyObject.type
#
根据此 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
-
¥Extends: <stream.Writable>
Sign
类是用于生成签名的实用工具。它可以通过以下两种方式之一使用:
¥The Sign
class is a utility for generating signatures. It can be used in one
of two ways:
-
作为一个可写的 流,其中写入要签名的数据,
sign.sign()
方法用于生成和返回签名,或者¥As a writable stream, where data to be signed is written and the
sign.sign()
method is used to generate and return the signature, or -
使用
sign.update()
和sign.sign()
方法生成签名。¥Using the
sign.update()
andsign.sign()
methods to produce the signature.
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: true
const {
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: true
const {
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>
使用 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,此选项指定生成签名的格式。它可以是以下之一:¥
dsaEncoding
<string> For DSA and ECDSA, this option specifies the format of the generated signature. It can be one of the following:-
'der'
(默认):DER 编码的 ASN.1 签名结构编码(r, s)
。¥
'der'
(default): DER-encoded ASN.1 signature structure encoding(r, s)
. -
'ieee-p1363'
:IEEE-P1363 中提议的签名格式r || s
。¥
'ieee-p1363'
: Signature formatr || s
as proposed in IEEE-P1363.
-
-
padding
<integer> RSA 的可选填充值,以下之一:¥
padding
<integer> Optional padding value for RSA, one of the following:-
crypto.constants.RSA_PKCS1_PADDING
(默认)¥
crypto.constants.RSA_PKCS1_PADDING
(default) -
crypto.constants.RSA_PKCS1_PSS_PADDING
RSA_PKCS1_PSS_PADDING
将使用 MGF1,其散列函数与 RFC 4055 第 3.1 节中指定的消息签名相同,除非 MGF1 散列函数已根据 RFC 4055 第 3.3 节指定为密钥的一部分。¥
RSA_PKCS1_PSS_PADDING
will use MGF1 with the same hash function used to sign the message as specified in section 3.1 of RFC 4055, unless an MGF1 hash function has been specified as part of the key in compliance with section 3.3 of RFC 4055. -
-
saltLength
<integer> 填充为RSA_PKCS1_PSS_PADDING
时的盐长度。特殊值crypto.constants.RSA_PSS_SALTLEN_DIGEST
将盐长度设置为摘要大小,crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN
(默认值)将其设置为最大允许值。¥
saltLength
<integer> Salt length for when padding isRSA_PKCS1_PSS_PADDING
. The special valuecrypto.constants.RSA_PSS_SALTLEN_DIGEST
sets the salt length to the digest size,crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN
(default) sets it to the maximum permissible value.
如果提供了 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>
使用给定的 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
-
¥Extends: <stream.Writable>
Verify
类是用于验证签名的实用工具。它可以通过以下两种方式之一使用:
¥The Verify
class is a utility for verifying signatures. It can be used in one
of two ways:
-
作为可写的 流,其中写入的数据用于根据提供的签名进行验证,或者
¥As a writable stream where written data is used to validate against the supplied signature, or
-
使用
verify.update()
和verify.verify()
方法来验证签名。¥Using the
verify.update()
andverify.verify()
methods to verify the signature.
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>
使用给定的 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> -
signature
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> -
signatureEncoding
<string>signature
字符串的 字符编码。¥
signatureEncoding
<string> The encoding of thesignature
string. -
返回:<boolean>
true
或false
取决于数据和公钥签名的有效性。¥Returns: <boolean>
true
orfalse
depending on the validity of the signature for the data and public key.
使用给定的 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,此选项指定签名的格式。它可以是以下之一:¥
dsaEncoding
<string> For DSA and ECDSA, this option specifies the format of the signature. It can be one of the following:-
'der'
(默认):DER 编码的 ASN.1 签名结构编码(r, s)
。¥
'der'
(default): DER-encoded ASN.1 signature structure encoding(r, s)
. -
'ieee-p1363'
:IEEE-P1363 中提议的签名格式r || s
。¥
'ieee-p1363'
: Signature formatr || s
as proposed in IEEE-P1363.
-
-
padding
<integer> RSA 的可选填充值,以下之一:¥
padding
<integer> Optional padding value for RSA, one of the following:-
crypto.constants.RSA_PKCS1_PADDING
(默认)¥
crypto.constants.RSA_PKCS1_PADDING
(default) -
crypto.constants.RSA_PKCS1_PSS_PADDING
RSA_PKCS1_PSS_PADDING
将使用具有相同哈希函数的 MGF1,用于验证 RFC 4055 第 3.1 节中指定的消息,除非 MGF1 哈希函数已根据 RFC 4055 第 3.3 节指定为密钥的一部分。¥
RSA_PKCS1_PSS_PADDING
will use MGF1 with the same hash function used to verify the message as specified in section 3.1 of RFC 4055, unless an MGF1 hash function has been specified as part of the key in compliance with section 3.3 of RFC 4055. -
-
saltLength
<integer> 填充为RSA_PKCS1_PSS_PADDING
时的盐长度。特殊值crypto.constants.RSA_PSS_SALTLEN_DIGEST
将盐长度设置为摘要大小,crypto.constants.RSA_PSS_SALTLEN_AUTO
(默认值)使其自动确定。¥
saltLength
<integer> Salt length for when padding isRSA_PKCS1_PSS_PADDING
. The special valuecrypto.constants.RSA_PSS_SALTLEN_DIGEST
sets the salt length to the digest size,crypto.constants.RSA_PSS_SALTLEN_AUTO
(default) causes it to be determined automatically.
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 证书。¥
buffer
<string> | <TypedArray> | <Buffer> | <DataView> A PEM or DER encoded X509 Certificate.
x509.ca
#
-
类型:<boolean> 如果这是证书颁发机构(CA)证书,则为
true
。¥Type: <boolean> Will be
true
if this is a Certificate Authority (CA) certificate.
x509.checkEmail(email[, options])
#
-
email
<string> -
options
<Object> -
返回:<string> | <undefined> 如果证书匹配,则返回
email
,如果不匹配,则返回undefined
。¥Returns: <string> | <undefined> Returns
email
if the certificate matches,undefined
if it does not.
检查证书是否与给定的电子邮件地址匹配。
¥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'
。¥
subject
<string>'default'
,'always'
, or'never'
. Default:'default'
. -
wildcards
<boolean> 默认值:true
。¥
wildcards
<boolean> Default:true
. -
partialWildcards
<boolean> 默认值:true
。¥
partialWildcards
<boolean> Default:true
. -
multiLabelWildcards
<boolean> 默认值:false
。¥
multiLabelWildcards
<boolean> Default:false
. -
singleLabelSubdomains
<boolean> 默认值:false
。¥
singleLabelSubdomains
<boolean> Default:false
.
-
-
返回:<string> | <undefined> 返回与
name
匹配的主题名称,如果没有主题名称与name
匹配,则返回undefined
。¥Returns: <string> | <undefined> Returns a subject name that matches
name
, orundefined
if no subject name matchesname
.
检查证书是否与给定的主机名匹配。
¥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
。¥Returns: <string> | <undefined> Returns
ip
if the certificate matches,undefined
if it does not.
检查证书是否与给定的 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>
¥Returns: <boolean>
检查此证书是否由给定的 otherCert
颁发。
¥Checks whether this certificate was issued by the given otherCert
.
x509.checkPrivateKey(privateKey)
#
-
privateKey
<KeyObject> 私钥。¥
privateKey
<KeyObject> A private key. -
返回:<boolean>
¥Returns: <boolean>
检查此证书的公钥是否与给定的私钥一致。
¥Checks whether the public key for this certificate is consistent with the given private key.
x509.fingerprint
#
此证书的 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
#
此证书的 SHA-256 指纹。
¥The SHA-256 fingerprint of this certificate.
x509.fingerprint512
#
此证书的 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
#
证书权限信息访问扩展的文本表示。
¥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
#
此证书中包含的发行人标识。
¥The issuer identification included in this certificate.
x509.issuerCertificate
#
-
¥Type: <X509Certificate>
颁发者证书或 undefined
(如果颁发者证书不可用)。
¥The issuer certificate or undefined
if the issuer certificate is not
available.
x509.extKeyUsage
#
-
类型:<string[]>
¥Type: <string[]>
详细说明此证书的关键扩展用途的数组。
¥An array detailing the key extended usages for this certificate.
x509.publicKey
#
-
类型:<KeyObject>
¥Type: <KeyObject>
此证书的公钥 <KeyObject>。
¥The public key <KeyObject> for this certificate.
x509.raw
#
包含此证书的 DER 编码的 Buffer
。
¥A Buffer
containing the DER encoding of this certificate.
x509.serialNumber
#
此证书的序列号。
¥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
#
本证书的完整主题。
¥The complete subject of this certificate.
x509.subjectAltName
#
为此证书指定的使用者备用名称。
¥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()
#
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()
#
使用旧版 证书对象 编码返回有关此证书的信息。
¥Returns information about this certificate using the legacy certificate object encoding.
x509.toString()
#
返回 PEM 编码的证书。
¥Returns the PEM-encoded certificate.
x509.validFrom
#
该证书有效的日期/时间。
¥The date/time from which this certificate is valid.
x509.validFromDate
#
此证书有效的日期/时间,封装在 Date
对象中。
¥The date/time from which this certificate is valid, encapsulated in a Date
object.
x509.validTo
#
该证书有效的日期/时间。
¥The date/time until which this certificate is valid.
x509.validToDate
#
此证书有效的日期/时间,封装在 Date
对象中。
¥The date/time until which this certificate is valid, encapsulated in a Date
object.
x509.verify(publicKey)
#
-
publicKey
<KeyObject> 公钥。¥
publicKey
<KeyObject> A public key. -
返回:<boolean>
¥Returns: <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.constants
#
包含用于加密和安全相关操作的常用常量的对象。目前定义的具体常量在 加密常量 中有说明。
¥An object containing commonly used constants for crypto and security related operations. The specific constants currently defined are described in Crypto constants.
crypto.fips
#
¥Stability: 0 - Deprecated
用于检查和控制当前是否正在使用符合 FIPS 的加密提供程序的属性。设置为 true 需要 Node.js 的 FIPS 构建。
¥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.checkPrime(candidate[, options], callback)
#
-
candidate
<ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint> 编码为任意长度的大端字节序序列的可能素数。¥
candidate
<ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint> A possible prime encoded as a sequence of big endian octets of arbitrary length. -
options
<Object>-
checks
<number> 要执行的 Miller-Rabin 概率素性迭代次数。当值为0
(零)时,将使用多次检查,对于随机输入产生最多 2-64 的误报率。选择多个检查时必须小心。有关更多详细信息,请参阅BN_is_prime_ex
函数nchecks
选项的 OpenSSL 文档。默认值:0
¥
checks
<number> The number of Miller-Rabin probabilistic primality iterations to perform. When the value is0
(zero), a number of checks is used that yields a false positive rate of at most 2-64 for random input. Care must be used when selecting a number of checks. Refer to the OpenSSL documentation for theBN_is_prime_ex
functionnchecks
options for more details. Default:0
-
-
callback
<Function>
检查 candidate
的素性。
¥Checks the primality of the candidate
.
crypto.checkPrimeSync(candidate[, options])
#
-
candidate
<ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint> 编码为任意长度的大端字节序序列的可能素数。¥
candidate
<ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint> A possible prime encoded as a sequence of big endian octets of arbitrary length. -
options
<Object>-
checks
<number> 要执行的 Miller-Rabin 概率素性迭代次数。当值为0
(零)时,将使用多次检查,对于随机输入产生最多 2-64 的误报率。选择多个检查时必须小心。有关更多详细信息,请参阅BN_is_prime_ex
函数nchecks
选项的 OpenSSL 文档。默认值:0
¥
checks
<number> The number of Miller-Rabin probabilistic primality iterations to perform. When the value is0
(zero), a number of checks is used that yields a false positive rate of at most 2-64 for random input. Care must be used when selecting a number of checks. Refer to the OpenSSL documentation for theBN_is_prime_ex
functionnchecks
options for more details. Default:0
-
-
返回:<boolean> 如果候选者是错误概率小于
0.25 ** options.checks
的素数,则为true
。¥Returns: <boolean>
true
if the candidate is a prime with an error probability less than0.25 ** options.checks
.
检查 candidate
的素性。
¥Checks the primality of the candidate
.
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
选项¥
options
<Object>stream.transform
options -
返回:<Cipher>
¥Returns: <Cipher>
使用给定的 algorithm
、key
和初始化向量(iv
)创建并返回 Cipher
对象。
¥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 DataView
s. 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
选项¥
options
<Object>stream.transform
options -
返回:<Decipher>
¥Returns: <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 DataView
s. 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> -
generator
<number> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 默认值:2
¥
generator
<number> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> Default:2
-
generatorEncoding
<string>generator
字符串的 字符编码。¥
generatorEncoding
<string> The encoding of thegenerator
string. -
¥Returns: <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
应该是一个字符串;否则应为数字 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
¥
generator
<number> Default:2
-
¥Returns: <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> -
¥Returns: <DiffieHellmanGroup>
¥An alias for crypto.getDiffieHellman()
crypto.createECDH(curveName)
#
使用 curveName
字符串指定的预定义曲线创建椭圆曲线 Diffie-Hellman (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])
#
-
algorithm
<string> -
options
<Object>stream.transform
选项¥
options
<Object>stream.transform
options -
返回:<Hash>
¥Returns: <Hash>
创建并返回 Hash
对象,该对象可用于使用给定的 algorithm
生成哈希摘要。可选的 options
参数控制流的行为。对于 XOF 哈希函数(例如 'shake256'
),可以使用 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
选项¥
options
<Object>stream.transform
options -
返回:<Hmac>
¥Returns: <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 格式。¥
key
: <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <Object> The key material, either in PEM, DER, or JWK format. -
format
:<string> 必须是'pem'
、'der'
或“'jwk'
”。默认值:'pem'
。¥
format
: <string> Must be'pem'
,'der'
, or ''jwk'
. Default:'pem'
. -
type
:<string> 必须是'pkcs1'
、'pkcs8'
或'sec1'
。仅当format
为'der'
时才需要此选项,否则将被忽略。¥
type
: <string> Must be'pkcs1'
,'pkcs8'
or'sec1'
. This option is required only if theformat
is'der'
and ignored otherwise. -
passphrase
:<string> | <Buffer> 用于解密的密码。¥
passphrase
: <string> | <Buffer> The passphrase to use for decryption. -
encoding
:<string> 当key
是字符串时使用的字符串编码。¥
encoding
: <string> The string encoding to use whenkey
is a string.
-
-
返回:<KeyObject>
¥Returns: <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 格式。¥
key
: <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <Object> The key material, either in PEM, DER, or JWK format. -
format
:<string> 必须是'pem'
、'der'
或'jwk'
。默认值:'pem'
。¥
format
: <string> Must be'pem'
,'der'
, or'jwk'
. Default:'pem'
. -
type
:<string> 必须是'pkcs1'
或'spki'
。仅当format
为'der'
时才需要此选项,否则将被忽略。¥
type
: <string> Must be'pkcs1'
or'spki'
. This option is required only if theformat
is'der'
and ignored otherwise. -
encoding
<string> 当key
是字符串时使用的字符串编码。¥
encoding
<string> The string encoding to use whenkey
is a string.
-
-
返回:<KeyObject>
¥Returns: <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
为字符串时的字符串编码。¥
encoding
<string> The string encoding whenkey
is a string. -
返回:<KeyObject>
¥Returns: <KeyObject>
创建并返回新的密钥对象,其中包含用于对称加密或 Hmac
的密钥。
¥Creates and returns a new key object containing a secret key for symmetric
encryption or Hmac
.
crypto.createSign(algorithm[, options])
#
-
algorithm
<string> -
options
<Object>stream.Writable
选项¥
options
<Object>stream.Writable
options -
返回:<Sign>
¥Returns: <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])
#
-
algorithm
<string> -
options
<Object>stream.Writable
选项¥
options
<Object>stream.Writable
options -
返回:<Verify>
¥Returns: <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.
在某些情况下,可以使用签名算法的名称(例如 'RSA-SHA256'
)而不是摘要算法来创建 Verify
实例。这将使用相应的摘要算法。这不适用于所有签名算法,例如 '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>
¥Returns: <Buffer>
基于 privateKey
和 publicKey
计算 Diffie-Hellman 秘密。两个密钥必须具有相同的 asymmetricKeyType
,它必须是 'dh'
(对于 Diffie-Hellman)、'ec'
(对于 ECDH)、'x448'
或 'x25519'
(对于 ECDH-ES)之一。
¥Computes the Diffie-Hellman secret based on a privateKey
and a publicKey
.
Both keys must have the same asymmetricKeyType
, which must be one of 'dh'
(for Diffie-Hellman), 'ec'
(for ECDH), 'x448'
, or 'x25519'
(for ECDH-ES).
crypto.hash(algorithm, data[, outputEncoding])
#
¥Stability: 1.2 - Release candidate
-
algorithm
<string> | <undefined> -
data
<string> | <Buffer> | <TypedArray> | <DataView> 当data
是字符串时,在进行哈希处理之前,它将被编码为 UTF-8。如果字符串输入需要不同的输入编码,用户可以使用TextEncoder
或Buffer.from()
将字符串编码为TypedArray
,然后将编码后的TypedArray
传递到此 API。¥
data
<string> | <Buffer> | <TypedArray> | <DataView> Whendata
is a string, it will be encoded as UTF-8 before being hashed. If a different input encoding is desired for a string input, user could encode the string into aTypedArray
using eitherTextEncoder
orBuffer.from()
and passing the encodedTypedArray
into this API instead. -
outputEncoding
<string> | <undefined> 编码 用于对返回的摘要进行编码。默认值:'hex'
。¥
outputEncoding
<string> | <undefined> Encoding used to encode the returned digest. Default:'hex'
.
一种用于创建数据的一次性哈希摘要的实用程序。当散列少量可用数据(<= 5MB)时,它比基于对象的 crypto.createHash()
更快。如果数据量很大或者是流式传输,仍然建议使用 crypto.createHash()
。
¥A utility for creating one-shot hash digests of data. It can be faster than
the object-based crypto.createHash()
when hashing a smaller amount of data
(<= 5MB) that's readily available. If the data can be big or if it is streamed,
it's still recommended to use crypto.createHash()
instead.
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.
示例:
¥Example:
const crypto = require('node:crypto');
const { Buffer } = require('node:buffer');
// Hashing a string and return the result as a hex-encoded string.
const string = 'Node.js';
// 10b3493287f831e81a438811a1ffba01f8cec4b7
console.log(crypto.hash('sha1', string));
// Encode a base64-encoded string into a Buffer, hash it and return
// the result as a buffer.
const base64 = 'Tm9kZS5qcw==';
// <Buffer 10 b3 49 32 87 f8 31 e8 1a 43 88 11 a1 ff ba 01 f8 ce c4 b7>
console.log(crypto.hash('sha1', Buffer.from(base64, 'base64'), 'buffer'));
import crypto from 'node:crypto';
import { Buffer } from 'node:buffer';
// Hashing a string and return the result as a hex-encoded string.
const string = 'Node.js';
// 10b3493287f831e81a438811a1ffba01f8cec4b7
console.log(crypto.hash('sha1', string));
// Encode a base64-encoded string into a Buffer, hash it and return
// the result as a buffer.
const base64 = 'Tm9kZS5qcw==';
// <Buffer 10 b3 49 32 87 f8 31 e8 1a 43 88 11 a1 ff ba 01 f8 ce c4 b7>
console.log(crypto.hash('sha1', Buffer.from(base64, 'base64'), 'buffer'));
crypto.generateKey(type, options, callback)
#
-
type
:<string> 生成的密钥的预期用途。当前接受的值为'hmac'
和'aes'
。¥
type
: <string> The intended use of the generated secret key. Currently accepted values are'hmac'
and'aes'
. -
options
:<Object>-
length
:<number> 要生成的密钥的位长度。这必须是一个大于 0 的值。¥
length
: <number> The bit length of the key to generate. This must be a value greater than 0.-
如果
type
是'hmac'
,则最小长度为 8,最大长度为 231-1。如果该值不是 8 的倍数,则生成的密钥将被截断为Math.floor(length / 8)
。¥If
type
is'hmac'
, the minimum is 8, and the maximum length is 231-1. If the value is not a multiple of 8, the generated key will be truncated toMath.floor(length / 8)
. -
如果
type
是'aes'
,则长度必须是128
、192
或256
之一。¥If
type
is'aes'
, the length must be one of128
,192
, or256
.
-
-
-
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'
。¥
type
: <string> Must be'rsa'
,'rsa-pss'
,'dsa'
,'ec'
,'ed25519'
,'ed448'
,'x25519'
,'x448'
, or'dh'
. -
options
:<Object>-
modulusLength
:<number> 以位为单位的密钥大小(RSA、DSA)。¥
modulusLength
: <number> Key size in bits (RSA, DSA). -
publicExponent
:<number> 公共指数 (RSA)。默认值:0x10001
。¥
publicExponent
: <number> Public exponent (RSA). Default:0x10001
. -
hashAlgorithm
:<string> 消息摘要的名称 (RSA-PSS)。¥
hashAlgorithm
: <string> Name of the message digest (RSA-PSS). -
mgf1HashAlgorithm
:<string> MGF1 (RSA-PSS) 使用的消息摘要的名称。¥
mgf1HashAlgorithm
: <string> Name of the message digest used by MGF1 (RSA-PSS). -
saltLength
:<number> 以字节为单位的最小盐长度 (RSA-PSS)。¥
saltLength
: <number> Minimal salt length in bytes (RSA-PSS). -
divisorLength
:<number>q
的大小(以位为单位)(DSA)。¥
divisorLength
: <number> Size ofq
in bits (DSA). -
namedCurve
:<string> 要使用的曲线的名称 (EC)。¥
namedCurve
: <string> Name of the curve to use (EC). -
prime
:<Buffer> 主要参数 (DH)。¥
prime
: <Buffer> The prime parameter (DH). -
primeLength
:<number> 以位 (DH) 为单位的素数长度。¥
primeLength
: <number> Prime length in bits (DH). -
generator
:<number> 自定义生成器 (DH)。默认值:2
。¥
generator
: <number> Custom generator (DH). Default:2
. -
groupName
:<string> Diffie-Hellman 组名 (DH)。参见crypto.getDiffieHellman()
。¥
groupName
: <string> Diffie-Hellman group name (DH). Seecrypto.getDiffieHellman()
. -
paramEncoding
:<string> 必须是'named'
或'explicit'
(EC)。默认值:'named'
。¥
paramEncoding
: <string> Must be'named'
or'explicit'
(EC). Default:'named'
. -
publicKeyEncoding
:<Object> 参见keyObject.export()
。¥
publicKeyEncoding
: <Object> SeekeyObject.export()
. -
privateKeyEncoding
:<Object> 参见keyObject.export()
。¥
privateKeyEncoding
: <Object> SeekeyObject.export()
.
-
-
callback
:<Function>-
err
:<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()
版本被调用,则其将为具有 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.
crypto.generateKeyPairSync(type, options)
#
-
type
:<string> 必须是'rsa'
、'rsa-pss'
、'dsa'
、'ec'
、'ed25519'
、'ed448'
、'x25519'
、'x448'
或'dh'
。¥
type
: <string> Must be'rsa'
,'rsa-pss'
,'dsa'
,'ec'
,'ed25519'
,'ed448'
,'x25519'
,'x448'
, or'dh'
. -
options
:<Object>-
modulusLength
:<number> 以位为单位的密钥大小(RSA、DSA)。¥
modulusLength
: <number> Key size in bits (RSA, DSA). -
publicExponent
:<number> 公共指数 (RSA)。默认值:0x10001
。¥
publicExponent
: <number> Public exponent (RSA). Default:0x10001
. -
hashAlgorithm
:<string> 消息摘要的名称 (RSA-PSS)。¥
hashAlgorithm
: <string> Name of the message digest (RSA-PSS). -
mgf1HashAlgorithm
:<string> MGF1 (RSA-PSS) 使用的消息摘要的名称。¥
mgf1HashAlgorithm
: <string> Name of the message digest used by MGF1 (RSA-PSS). -
saltLength
:<number> 以字节为单位的最小盐长度 (RSA-PSS)。¥
saltLength
: <number> Minimal salt length in bytes (RSA-PSS). -
divisorLength
:<number>q
的大小(以位为单位)(DSA)。¥
divisorLength
: <number> Size ofq
in bits (DSA). -
namedCurve
:<string> 要使用的曲线的名称 (EC)。¥
namedCurve
: <string> Name of the curve to use (EC). -
prime
:<Buffer> 主要参数 (DH)。¥
prime
: <Buffer> The prime parameter (DH). -
primeLength
:<number> 以位 (DH) 为单位的素数长度。¥
primeLength
: <number> Prime length in bits (DH). -
generator
:<number> 自定义生成器 (DH)。默认值:2
。¥
generator
: <number> Custom generator (DH). Default:2
. -
groupName
:<string> Diffie-Hellman 组名 (DH)。参见crypto.getDiffieHellman()
。¥
groupName
: <string> Diffie-Hellman group name (DH). Seecrypto.getDiffieHellman()
. -
paramEncoding
:<string> 必须是'named'
或'explicit'
(EC)。默认值:'named'
。¥
paramEncoding
: <string> Must be'named'
or'explicit'
(EC). Default:'named'
. -
publicKeyEncoding
:<Object> 参见keyObject.export()
。¥
publicKeyEncoding
: <Object> SeekeyObject.export()
. -
privateKeyEncoding
:<Object> 参见keyObject.export()
。¥
privateKeyEncoding
: <Object> SeekeyObject.export()
.
-
-
返回:<Object>
¥Returns: <Object>
-
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'
,并对密码进行保密。
¥When encoding public keys, it is recommended to use 'spki'
. When encoding
private keys, it is recommended to use 'pkcs8'
with a strong passphrase,
and to keep the passphrase confidential.
const {
generateKeyPairSync,
} = await import('node:crypto');
const {
publicKey,
privateKey,
} = generateKeyPairSync('rsa', {
modulusLength: 4096,
publicKeyEncoding: {
type: 'spki',
format: 'pem',
},
privateKeyEncoding: {
type: 'pkcs8',
format: 'pem',
cipher: 'aes-256-cbc',
passphrase: 'top secret',
},
});
const {
generateKeyPairSync,
} = require('node:crypto');
const {
publicKey,
privateKey,
} = generateKeyPairSync('rsa', {
modulusLength: 4096,
publicKeyEncoding: {
type: 'spki',
format: 'pem',
},
privateKeyEncoding: {
type: 'pkcs8',
format: 'pem',
cipher: 'aes-256-cbc',
passphrase: 'top secret',
},
});
返回值 { publicKey, privateKey }
表示生成的密钥对。选择 PEM 编码时,相应的密钥将是字符串,否则它将是包含编码为 DER 的数据的缓冲区。
¥The return value { publicKey, privateKey }
represents the generated key pair.
When PEM encoding was selected, the respective key will be a string, otherwise
it will be a buffer containing the data encoded as DER.
crypto.generateKeySync(type, options)
#
-
type
:<string> 生成的密钥的预期用途。当前接受的值为'hmac'
和'aes'
。¥
type
: <string> The intended use of the generated secret key. Currently accepted values are'hmac'
and'aes'
. -
options
:<Object>-
length
:<number> 要生成的密钥的位长度。¥
length
: <number> The bit length of the key to generate.-
如果
type
是'hmac'
,则最小长度为 8,最大长度为 231-1。如果该值不是 8 的倍数,则生成的密钥将被截断为Math.floor(length / 8)
。¥If
type
is'hmac'
, the minimum is 8, and the maximum length is 231-1. If the value is not a multiple of 8, the generated key will be truncated toMath.floor(length / 8)
. -
如果
type
是'aes'
,则长度必须是128
、192
或256
之一。¥If
type
is'aes'
, the length must be one of128
,192
, or256
.
-
-
-
返回:<KeyObject>
¥Returns: <KeyObject>
同步生成给定 length
的新的随机的密钥。type
将确定将在 length
上执行哪些验证。
¥Synchronously generates a new random secret key of the given length
. The
type
will determine which validations will be performed on the length
.
const {
generateKeySync,
} = await import('node:crypto');
const key = generateKeySync('hmac', { length: 512 });
console.log(key.export().toString('hex')); // e89..........41e
const {
generateKeySync,
} = require('node:crypto');
const key = generateKeySync('hmac', { length: 512 });
console.log(key.export().toString('hex')); // e89..........41e
生成的 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.generatePrime(size[, options[, callback]])
#
-
size
<number> 要生成的素数的大小(以位为单位)。¥
size
<number> The size (in bits) of the prime to generate. -
options
<Object>-
add
<ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint> -
rem
<ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint> -
safe
<boolean> 默认值:false
。¥
safe
<boolean> Default:false
. -
bigint
<boolean> 当true
时,生成的素数作为bigint
返回。¥
bigint
<boolean> Whentrue
, the generated prime is returned as abigint
.
-
-
callback
<Function>-
err
<Error> -
prime
<ArrayBuffer> | <bigint>
-
生成 size
位的伪随机素数。
¥Generates a pseudorandom prime of size
bits.
如果 options.safe
是 true
,素数将是一个安全素数 - 也就是说,(prime - 1) / 2
也将是素数。
¥If options.safe
is true
, the prime will be a safe prime -- that is,
(prime - 1) / 2
will also be a prime.
options.add
和 options.rem
参数可用于强制执行其他要求,例如,对于 Diffie-Hellman:
¥The options.add
and options.rem
parameters can be used to enforce additional
requirements, e.g., for Diffie-Hellman:
-
如果
options.add
和options.rem
都设置,素数将满足条件prime % add = rem
。¥If
options.add
andoptions.rem
are both set, the prime will satisfy the condition thatprime % add = rem
. -
如果只设置了
options.add
而options.safe
不是true
,素数将满足条件prime % add = 1
。¥If only
options.add
is set andoptions.safe
is nottrue
, the prime will satisfy the condition thatprime % add = 1
. -
如果只设置了
options.add
,而将options.safe
设置为true
,则素数将满足条件prime % add = 3
。这是必要的,因为options.add > 2
的prime % add = 1
会与options.safe
强制执行的条件相矛盾。¥If only
options.add
is set andoptions.safe
is set totrue
, the prime will instead satisfy the condition thatprime % add = 3
. This is necessary becauseprime % add = 1
foroptions.add > 2
would contradict the condition enforced byoptions.safe
. -
如果未给出
options.add
,则忽略options.rem
。¥
options.rem
is ignored ifoptions.add
is not given.
如果以 ArrayBuffer
、SharedArrayBuffer
、TypedArray
、Buffer
或 DataView
形式给出,则 options.add
和 options.rem
都必须编码为大端序列。
¥Both options.add
and options.rem
must be encoded as big-endian sequences
if given as an ArrayBuffer
, SharedArrayBuffer
, TypedArray
, Buffer
, or
DataView
.
默认情况下,素数被编码为 <ArrayBuffer> 中八位字节的大端序列。如果 bigint
选项为 true
,则提供 <bigint>。
¥By default, the prime is encoded as a big-endian sequence of octets
in an <ArrayBuffer>. If the bigint
option is true
, then a <bigint>
is provided.
crypto.generatePrimeSync(size[, options])
#
-
size
<number> 要生成的素数的大小(以位为单位)。¥
size
<number> The size (in bits) of the prime to generate. -
options
<Object>-
add
<ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint> -
rem
<ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint> -
safe
<boolean> 默认值:false
。¥
safe
<boolean> Default:false
. -
bigint
<boolean> 当true
时,生成的素数作为bigint
返回。¥
bigint
<boolean> Whentrue
, the generated prime is returned as abigint
.
-
-
返回:<ArrayBuffer> | <bigint>
¥Returns: <ArrayBuffer> | <bigint>
生成 size
位的伪随机素数。
¥Generates a pseudorandom prime of size
bits.
如果 options.safe
是 true
,素数将是一个安全素数 - 也就是说,(prime - 1) / 2
也将是素数。
¥If options.safe
is true
, the prime will be a safe prime -- that is,
(prime - 1) / 2
will also be a prime.
options.add
和 options.rem
参数可用于强制执行其他要求,例如,对于 Diffie-Hellman:
¥The options.add
and options.rem
parameters can be used to enforce additional
requirements, e.g., for Diffie-Hellman:
-
如果
options.add
和options.rem
都设置,素数将满足条件prime % add = rem
。¥If
options.add
andoptions.rem
are both set, the prime will satisfy the condition thatprime % add = rem
. -
如果只设置了
options.add
而options.safe
不是true
,素数将满足条件prime % add = 1
。¥If only
options.add
is set andoptions.safe
is nottrue
, the prime will satisfy the condition thatprime % add = 1
. -
如果只设置了
options.add
,而将options.safe
设置为true
,则素数将满足条件prime % add = 3
。这是必要的,因为options.add > 2
的prime % add = 1
会与options.safe
强制执行的条件相矛盾。¥If only
options.add
is set andoptions.safe
is set totrue
, the prime will instead satisfy the condition thatprime % add = 3
. This is necessary becauseprime % add = 1
foroptions.add > 2
would contradict the condition enforced byoptions.safe
. -
如果未给出
options.add
,则忽略options.rem
。¥
options.rem
is ignored ifoptions.add
is not given.
如果以 ArrayBuffer
、SharedArrayBuffer
、TypedArray
、Buffer
或 DataView
形式给出,则 options.add
和 options.rem
都必须编码为大端序列。
¥Both options.add
and options.rem
must be encoded as big-endian sequences
if given as an ArrayBuffer
, SharedArrayBuffer
, TypedArray
, Buffer
, or
DataView
.
默认情况下,素数被编码为 <ArrayBuffer> 中八位字节的大端序列。如果 bigint
选项为 true
,则提供 <bigint>。
¥By default, the prime is encoded as a big-endian sequence of octets
in an <ArrayBuffer>. If the bigint
option is true
, then a <bigint>
is provided.
crypto.getCipherInfo(nameOrNid[, options])
#
-
nameOrNid
:<string> | <number> 要查询的密码的名称或 nid。¥
nameOrNid
: <string> | <number> The name or nid of the cipher to query. -
options
:<Object> -
返回:<Object>
¥Returns: <Object>
-
name
<string> 密码的名称¥
name
<string> The name of the cipher -
nid
<number> 密码的 nid¥
nid
<number> The nid of the cipher -
blockSize
<number> 密码的块大小(以字节为单位)。当mode
为'stream'
时,此属性被省略。¥
blockSize
<number> The block size of the cipher in bytes. This property is omitted whenmode
is'stream'
. -
ivLength
<number> 以字节为单位的预期或默认初始化向量长度。如果密码不使用初始化向量,则省略此属性。¥
ivLength
<number> The expected or default initialization vector length in bytes. This property is omitted if the cipher does not use an initialization vector. -
keyLength
<number> 以字节为单位的预期或默认密钥长度。¥
keyLength
<number> The expected or default key length in bytes. -
mode
<string> 密码模式。'cbc'
、'ccm'
、'cfb'
、'ctr'
、'ecb'
、'gcm'
、'ocb'
、'ofb'
、'stream'
、'wrap'
、'xts'
之一。¥
mode
<string> The cipher mode. One of'cbc'
,'ccm'
,'cfb'
,'ctr'
,'ecb'
,'gcm'
,'ocb'
,'ofb'
,'stream'
,'wrap'
,'xts'
.
-
返回有关给定密码的信息。
¥Returns information about a given cipher.
一些密码接受可变长度的密钥和初始化向量。默认情况下,crypto.getCipherInfo()
方法将返回这些密码的默认值。要测试给定的密钥长度或 iv 长度对于给定的密码是否可接受,请使用 keyLength
和 ivLength
选项。如果给定的值不可接受,则返回 undefined
。
¥Some ciphers accept variable length keys and initialization vectors. By default,
the crypto.getCipherInfo()
method will return the default values for these
ciphers. To test if a given key length or iv length is acceptable for given
cipher, use the keyLength
and ivLength
options. If the given values are
unacceptable, undefined
will be returned.
crypto.getCiphers()
#
-
返回:<string[]> 包含支持的密码算法名称的数组。
¥Returns: <string[]> An array with the names of the supported cipher algorithms.
const {
getCiphers,
} = await import('node:crypto');
console.log(getCiphers()); // ['aes-128-cbc', 'aes-128-ccm', ...]
const {
getCiphers,
} = require('node:crypto');
console.log(getCiphers()); // ['aes-128-cbc', 'aes-128-ccm', ...]
crypto.getCurves()
#
-
返回:<string[]> 包含支持的椭圆曲线名称的数组。
¥Returns: <string[]> An array with the names of the supported elliptic curves.
const {
getCurves,
} = await import('node:crypto');
console.log(getCurves()); // ['Oakley-EC2N-3', 'Oakley-EC2N-4', ...]
const {
getCurves,
} = require('node:crypto');
console.log(getCurves()); // ['Oakley-EC2N-3', 'Oakley-EC2N-4', ...]
crypto.getDiffieHellman(groupName)
#
-
groupName
<string> -
¥Returns: <DiffieHellmanGroup>
创建预定义的 DiffieHellmanGroup
密钥交换对象。DiffieHellmanGroup
的文档中列出了支持的组。
¥Creates a predefined DiffieHellmanGroup
key exchange object. The
supported groups are listed in the documentation for DiffieHellmanGroup
.
返回的对象模仿 crypto.createDiffieHellman()
创建的对象的接口,但不允许更改键(例如,使用 diffieHellman.setPublicKey()
)。使用这种方法的优点是双方不必事先生成或交换组模数,既节省了处理器时间又节省了通信时间。
¥The returned object mimics the interface of objects created by
crypto.createDiffieHellman()
, but will not allow changing
the keys (with diffieHellman.setPublicKey()
, for example). The
advantage of using this method is that the parties do not have to
generate nor exchange a group modulus beforehand, saving both processor
and communication time.
示例(获取共享密钥):
¥Example (obtaining a shared secret):
const {
getDiffieHellman,
} = await import('node:crypto');
const alice = getDiffieHellman('modp14');
const bob = getDiffieHellman('modp14');
alice.generateKeys();
bob.generateKeys();
const aliceSecret = alice.computeSecret(bob.getPublicKey(), null, 'hex');
const bobSecret = bob.computeSecret(alice.getPublicKey(), null, 'hex');
/* aliceSecret and bobSecret should be the same */
console.log(aliceSecret === bobSecret);
const {
getDiffieHellman,
} = require('node:crypto');
const alice = getDiffieHellman('modp14');
const bob = getDiffieHellman('modp14');
alice.generateKeys();
bob.generateKeys();
const aliceSecret = alice.computeSecret(bob.getPublicKey(), null, 'hex');
const bobSecret = bob.computeSecret(alice.getPublicKey(), null, 'hex');
/* aliceSecret and bobSecret should be the same */
console.log(aliceSecret === bobSecret);
crypto.getFips()
#
-
返回:<number> 当且仅当当前正在使用符合 FIPS 的加密提供商时为
1
,否则为0
。未来的语义化主版本可能会将此 API 的返回类型更改为 <boolean>。¥Returns: <number>
1
if and only if a FIPS compliant crypto provider is currently in use,0
otherwise. A future semver-major release may change the return type of this API to a <boolean>.
crypto.getHashes()
#
-
返回:<string[]> 支持的哈希算法名称的数组,例如
'RSA-SHA256'
。哈希算法也称为 "digest" 算法。¥Returns: <string[]> An array of the names of the supported hash algorithms, such as
'RSA-SHA256'
. Hash algorithms are also called "digest" algorithms.
const {
getHashes,
} = await import('node:crypto');
console.log(getHashes()); // ['DSA', 'DSA-SHA', 'DSA-SHA1', ...]
const {
getHashes,
} = require('node:crypto');
console.log(getHashes()); // ['DSA', 'DSA-SHA', 'DSA-SHA1', ...]
crypto.getRandomValues(typedArray)
#
-
typedArray
<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> -
返回:<Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> 返回
typedArray
。¥Returns: <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> Returns
typedArray
.
crypto.webcrypto.getRandomValues()
的便捷别名。此实现不符合 Web 加密规范,要编写与 web 兼容的代码,则改用 crypto.webcrypto.getRandomValues()
。
¥A convenient alias for crypto.webcrypto.getRandomValues()
. This
implementation is not compliant with the Web Crypto spec, to write
web-compatible code use crypto.webcrypto.getRandomValues()
instead.
crypto.hkdf(digest, ikm, salt, info, keylen, callback)
#
-
digest
<string> 要使用的摘要算法。¥
digest
<string> The digest algorithm to use. -
ikm
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> 输入键材料。必须提供,但可以是零长度。¥
ikm
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> The input keying material. Must be provided but can be zero-length. -
salt
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 盐值。必须提供,但可以是零长度。¥
salt
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> The salt value. Must be provided but can be zero-length. -
info
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 附加信息值。必须提供但可以是零长度,并且不能超过 1024 字节。¥
info
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> Additional info value. Must be provided but can be zero-length, and cannot be more than 1024 bytes. -
keylen
<number> 要生成的密钥的长度。必须大于 0。最大允许值是所选摘要函数生成的字节数的255
倍(例如,sha512
生成 64 字节哈希,使最大 HKDF 输出为 16320 字节)。¥
keylen
<number> The length of the key to generate. Must be greater than 0. The maximum allowable value is255
times the number of bytes produced by the selected digest function (e.g.sha512
generates 64-byte hashes, making the maximum HKDF output 16320 bytes). -
callback
<Function>-
err
<Error> -
derivedKey
<ArrayBuffer>
-
HKDF 是 RFC 5869 中定义的简单密钥派生函数。给定的 ikm
、salt
和 info
与 digest
一起使用以导出 keylen
字节的密钥。
¥HKDF is a simple key derivation function defined in RFC 5869. The given ikm
,
salt
and info
are used with the digest
to derive a key of keylen
bytes.
使用两个参数调用提供的 callback
函数:err
和 derivedKey
。如果派生密钥时发生错误,err
将被设置;否则 err
将是 null
。成功生成的 derivedKey
将作为 <ArrayBuffer> 传给回调。如果任何输入参数指定了无效的值或类型,则会抛出错误。
¥The supplied callback
function is called with two arguments: err
and
derivedKey
. If an errors occurs while deriving the key, err
will be set;
otherwise err
will be null
. The successfully generated derivedKey
will
be passed to the callback as an <ArrayBuffer>. An error will be thrown if any
of the input arguments specify invalid values or types.
import { Buffer } from 'node:buffer';
const {
hkdf,
} = await import('node:crypto');
hkdf('sha512', 'key', 'salt', 'info', 64, (err, derivedKey) => {
if (err) throw err;
console.log(Buffer.from(derivedKey).toString('hex')); // '24156e2...5391653'
});
const {
hkdf,
} = require('node:crypto');
const { Buffer } = require('node:buffer');
hkdf('sha512', 'key', 'salt', 'info', 64, (err, derivedKey) => {
if (err) throw err;
console.log(Buffer.from(derivedKey).toString('hex')); // '24156e2...5391653'
});
crypto.hkdfSync(digest, ikm, salt, info, keylen)
#
-
digest
<string> 要使用的摘要算法。¥
digest
<string> The digest algorithm to use. -
ikm
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> 输入键材料。必须提供,但可以是零长度。¥
ikm
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> The input keying material. Must be provided but can be zero-length. -
salt
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 盐值。必须提供,但可以是零长度。¥
salt
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> The salt value. Must be provided but can be zero-length. -
info
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 附加信息值。必须提供但可以是零长度,并且不能超过 1024 字节。¥
info
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> Additional info value. Must be provided but can be zero-length, and cannot be more than 1024 bytes. -
keylen
<number> 要生成的密钥的长度。必须大于 0。最大允许值是所选摘要函数生成的字节数的255
倍(例如,sha512
生成 64 字节哈希,使最大 HKDF 输出为 16320 字节)。¥
keylen
<number> The length of the key to generate. Must be greater than 0. The maximum allowable value is255
times the number of bytes produced by the selected digest function (e.g.sha512
generates 64-byte hashes, making the maximum HKDF output 16320 bytes). -
¥Returns: <ArrayBuffer>
提供 RFC 5869 中定义的同步 HKDF 密钥派生函数。给定的 ikm
、salt
和 info
与 digest
一起使用以导出 keylen
字节的密钥。
¥Provides a synchronous HKDF key derivation function as defined in RFC 5869. The
given ikm
, salt
and info
are used with the digest
to derive a key of
keylen
bytes.
成功生成的 derivedKey
将作为 <ArrayBuffer> 返回。
¥The successfully generated derivedKey
will be returned as an <ArrayBuffer>.
如果任何输入参数指定无效值或类型,或者无法生成派生密钥,则会抛出错误。
¥An error will be thrown if any of the input arguments specify invalid values or types, or if the derived key cannot be generated.
import { Buffer } from 'node:buffer';
const {
hkdfSync,
} = await import('node:crypto');
const derivedKey = hkdfSync('sha512', 'key', 'salt', 'info', 64);
console.log(Buffer.from(derivedKey).toString('hex')); // '24156e2...5391653'
const {
hkdfSync,
} = require('node:crypto');
const { Buffer } = require('node:buffer');
const derivedKey = hkdfSync('sha512', 'key', 'salt', 'info', 64);
console.log(Buffer.from(derivedKey).toString('hex')); // '24156e2...5391653'
crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)
#
-
password
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> -
salt
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> -
iterations
<number> -
keylen
<number> -
digest
<string> -
callback
<Function>
提供异步基于密码的密钥派生函数 2 (PBKDF2) 实现。应用由 digest
指定的选定 HMAC 摘要算法以从 password
、salt
和 iterations
导出请求字节长度 (keylen
) 的密钥。
¥Provides an asynchronous Password-Based Key Derivation Function 2 (PBKDF2)
implementation. A selected HMAC digest algorithm specified by digest
is
applied to derive a key of the requested byte length (keylen
) from the
password
, salt
and iterations
.
使用两个参数调用提供的 callback
函数:err
和 derivedKey
。如果派生密钥时发生错误,err
将被设置;否则 err
将是 null
。默认情况下,成功生成的 derivedKey
将作为 Buffer
传给回调。如果任何输入参数指定了无效的值或类型,则会抛出错误。
¥The supplied callback
function is called with two arguments: err
and
derivedKey
. If an error occurs while deriving the key, err
will be set;
otherwise err
will be null
. By default, the successfully generated
derivedKey
will be passed to the callback as a Buffer
. An error will be
thrown if any of the input arguments specify invalid values or types.
iterations
参数必须是尽可能高的数字。迭代次数越多,派生密钥就越安全,但需要更长的时间才能完成。
¥The iterations
argument must be a number set as high as possible. The
higher the number of iterations, the more secure the derived key will be,
but will take a longer amount of time to complete.
salt
应该尽可能唯一。建议盐是随机的,长度至少为 16 字节。详见 NIST SP 800-132。
¥The salt
should be as unique as possible. It is recommended that a salt is
random and at least 16 bytes long. See NIST SP 800-132 for details.
为 password
或 salt
传递字符串时,请考虑 使用字符串作为加密 API 的输入时的注意事项。
¥When passing strings for password
or salt
, please consider
caveats when using strings as inputs to cryptographic APIs.
const {
pbkdf2,
} = await import('node:crypto');
pbkdf2('secret', 'salt', 100000, 64, 'sha512', (err, derivedKey) => {
if (err) throw err;
console.log(derivedKey.toString('hex')); // '3745e48...08d59ae'
});
const {
pbkdf2,
} = require('node:crypto');
pbkdf2('secret', 'salt', 100000, 64, 'sha512', (err, derivedKey) => {
if (err) throw err;
console.log(derivedKey.toString('hex')); // '3745e48...08d59ae'
});
可以使用 crypto.getHashes()
检索支持的摘要函数数组。
¥An array of supported digest functions can be retrieved using
crypto.getHashes()
.
该 API 使用 libuv 的线程池,这对某些应用可能具有令人惊讶的负面性能影响;有关详细信息,请参阅 UV_THREADPOOL_SIZE
文档。
¥This API uses libuv's threadpool, which can have surprising and
negative performance implications for some applications; see the
UV_THREADPOOL_SIZE
documentation for more information.
crypto.pbkdf2Sync(password, salt, iterations, keylen, digest)
#
-
password
<string> | <Buffer> | <TypedArray> | <DataView> -
salt
<string> | <Buffer> | <TypedArray> | <DataView> -
iterations
<number> -
keylen
<number> -
digest
<string> -
返回:<Buffer>
¥Returns: <Buffer>
提供同步的基于密码的密钥派生函数 2 (PBKDF2) 实现。应用由 digest
指定的选定 HMAC 摘要算法以从 password
、salt
和 iterations
导出请求字节长度 (keylen
) 的密钥。
¥Provides a synchronous Password-Based Key Derivation Function 2 (PBKDF2)
implementation. A selected HMAC digest algorithm specified by digest
is
applied to derive a key of the requested byte length (keylen
) from the
password
, salt
and iterations
.
如果发生错误,将抛出 Error
,否则派生密钥将作为 Buffer
返回。
¥If an error occurs an Error
will be thrown, otherwise the derived key will be
returned as a Buffer
.
iterations
参数必须是尽可能高的数字。迭代次数越多,派生密钥就越安全,但需要更长的时间才能完成。
¥The iterations
argument must be a number set as high as possible. The
higher the number of iterations, the more secure the derived key will be,
but will take a longer amount of time to complete.
salt
应该尽可能唯一。建议盐是随机的,长度至少为 16 字节。详见 NIST SP 800-132。
¥The salt
should be as unique as possible. It is recommended that a salt is
random and at least 16 bytes long. See NIST SP 800-132 for details.
为 password
或 salt
传递字符串时,请考虑 使用字符串作为加密 API 的输入时的注意事项。
¥When passing strings for password
or salt
, please consider
caveats when using strings as inputs to cryptographic APIs.
const {
pbkdf2Sync,
} = await import('node:crypto');
const key = pbkdf2Sync('secret', 'salt', 100000, 64, 'sha512');
console.log(key.toString('hex')); // '3745e48...08d59ae'
const {
pbkdf2Sync,
} = require('node:crypto');
const key = pbkdf2Sync('secret', 'salt', 100000, 64, 'sha512');
console.log(key.toString('hex')); // '3745e48...08d59ae'
可以使用 crypto.getHashes()
检索支持的摘要函数数组。
¥An array of supported digest functions can be retrieved using
crypto.getHashes()
.
crypto.privateDecrypt(privateKey, buffer)
#
-
privateKey
<Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>-
oaepHash
<string> 用于 OAEP 填充和 MGF1 的哈希函数。默认值:'sha1'
¥
oaepHash
<string> The hash function to use for OAEP padding and MGF1. Default:'sha1'
-
oaepLabel
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 用于 OAEP 填充的标签。如果未指定,则不使用标签。¥
oaepLabel
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> The label to use for OAEP padding. If not specified, no label is used. -
padding
<crypto.constants>crypto.constants
中定义的可选填充值,可能是:crypto.constants.RSA_NO_PADDING
、crypto.constants.RSA_PKCS1_PADDING
或crypto.constants.RSA_PKCS1_OAEP_PADDING
。¥
padding
<crypto.constants> An optional padding value defined incrypto.constants
, which may be:crypto.constants.RSA_NO_PADDING
,crypto.constants.RSA_PKCS1_PADDING
, orcrypto.constants.RSA_PKCS1_OAEP_PADDING
.
-
-
buffer
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> -
返回:<Buffer> 带有解密内容的新
Buffer
。¥Returns: <Buffer> A new
Buffer
with the decrypted content.
用 privateKey
解密 buffer
。buffer
之前使用相应的公钥加密,例如使用 crypto.publicEncrypt()
。
¥Decrypts buffer
with privateKey
. buffer
was previously encrypted using
the corresponding public key, for example using crypto.publicEncrypt()
.
如果 privateKey
不是 KeyObject
,则此函数的行为就像将 privateKey
传给 crypto.createPrivateKey()
一样。如果是对象,则可以传入 padding
属性。否则,该函数使用 RSA_PKCS1_OAEP_PADDING
。
¥If privateKey
is not a KeyObject
, this function behaves as if
privateKey
had been passed to crypto.createPrivateKey()
. If it is an
object, the padding
property can be passed. Otherwise, this function uses
RSA_PKCS1_OAEP_PADDING
.
在 crypto.privateDecrypt()
中使用 crypto.constants.RSA_PKCS1_PADDING
需要 OpenSSL 支持隐式拒绝 (rsa_pkcs1_implicit_rejection
)。如果 Node.js 使用的 OpenSSL 版本不支持此功能,则尝试使用 RSA_PKCS1_PADDING
将失败。
¥Using crypto.constants.RSA_PKCS1_PADDING
in crypto.privateDecrypt()
requires OpenSSL to support implicit rejection (rsa_pkcs1_implicit_rejection
).
If the version of OpenSSL used by Node.js does not support this feature,
attempting to use RSA_PKCS1_PADDING
will fail.
crypto.privateEncrypt(privateKey, buffer)
#
-
privateKey
<Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>-
key
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey> PEM 编码的私钥。¥
key
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey> A PEM encoded private key. -
passphrase
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 可选的私钥密码。¥
passphrase
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> An optional passphrase for the private key. -
padding
<crypto.constants>crypto.constants
中定义的可选填充值,可能是:crypto.constants.RSA_NO_PADDING
或crypto.constants.RSA_PKCS1_PADDING
。¥
padding
<crypto.constants> An optional padding value defined incrypto.constants
, which may be:crypto.constants.RSA_NO_PADDING
orcrypto.constants.RSA_PKCS1_PADDING
. -
encoding
<string> 当buffer
、key
或passphrase
是字符串时使用的字符串编码。¥
encoding
<string> The string encoding to use whenbuffer
,key
, orpassphrase
are strings.
-
-
buffer
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> -
返回:<Buffer> 带有加密内容的新
Buffer
。¥Returns: <Buffer> A new
Buffer
with the encrypted content.
用 privateKey
加密 buffer
。返回的数据可以使用相应的公钥解密,例如使用 crypto.publicDecrypt()
。
¥Encrypts buffer
with privateKey
. The returned data can be decrypted using
the corresponding public key, for example using crypto.publicDecrypt()
.
如果 privateKey
不是 KeyObject
,则此函数的行为就像将 privateKey
传给 crypto.createPrivateKey()
一样。如果是对象,则可以传入 padding
属性。否则,该函数使用 RSA_PKCS1_PADDING
。
¥If privateKey
is not a KeyObject
, this function behaves as if
privateKey
had been passed to crypto.createPrivateKey()
. If it is an
object, the padding
property can be passed. Otherwise, this function uses
RSA_PKCS1_PADDING
.
crypto.publicDecrypt(key, buffer)
#
-
key
<Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>-
passphrase
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 可选的私钥密码。¥
passphrase
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> An optional passphrase for the private key. -
padding
<crypto.constants>crypto.constants
中定义的可选填充值,可能是:crypto.constants.RSA_NO_PADDING
或crypto.constants.RSA_PKCS1_PADDING
。¥
padding
<crypto.constants> An optional padding value defined incrypto.constants
, which may be:crypto.constants.RSA_NO_PADDING
orcrypto.constants.RSA_PKCS1_PADDING
. -
encoding
<string> 当buffer
、key
或passphrase
是字符串时使用的字符串编码。¥
encoding
<string> The string encoding to use whenbuffer
,key
, orpassphrase
are strings.
-
-
buffer
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> -
返回:<Buffer> 带有解密内容的新
Buffer
。¥Returns: <Buffer> A new
Buffer
with the decrypted content.
使用 key
.buffer
解密 buffer
之前使用相应的私钥加密,例如使用 crypto.privateEncrypt()
。
¥Decrypts buffer
with key
.buffer
was previously encrypted using
the corresponding private key, for example using crypto.privateEncrypt()
.
如果 key
不是 KeyObject
,则此函数的行为就像将 key
传给 crypto.createPublicKey()
一样。如果是对象,则可以传入 padding
属性。否则,该函数使用 RSA_PKCS1_PADDING
。
¥If key
is not a KeyObject
, this function behaves as if
key
had been passed to crypto.createPublicKey()
. If it is an
object, the padding
property can be passed. Otherwise, this function uses
RSA_PKCS1_PADDING
.
由于 RSA 公钥可以从私钥派生,因此可以传入私钥而不是公钥。
¥Because RSA public keys can be derived from private keys, a private key may be passed instead of a public key.
crypto.publicEncrypt(key, buffer)
#
-
key
<Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>-
key
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey> PEM 编码的公钥或私钥、<KeyObject> 或 <CryptoKey>。¥
key
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey> A PEM encoded public or private key, <KeyObject>, or <CryptoKey>. -
oaepHash
<string> 用于 OAEP 填充和 MGF1 的哈希函数。默认值:'sha1'
¥
oaepHash
<string> The hash function to use for OAEP padding and MGF1. Default:'sha1'
-
oaepLabel
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 用于 OAEP 填充的标签。如果未指定,则不使用标签。¥
oaepLabel
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> The label to use for OAEP padding. If not specified, no label is used. -
passphrase
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 可选的私钥密码。¥
passphrase
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> An optional passphrase for the private key. -
padding
<crypto.constants>crypto.constants
中定义的可选填充值,可能是:crypto.constants.RSA_NO_PADDING
、crypto.constants.RSA_PKCS1_PADDING
或crypto.constants.RSA_PKCS1_OAEP_PADDING
。¥
padding
<crypto.constants> An optional padding value defined incrypto.constants
, which may be:crypto.constants.RSA_NO_PADDING
,crypto.constants.RSA_PKCS1_PADDING
, orcrypto.constants.RSA_PKCS1_OAEP_PADDING
. -
encoding
<string> 当buffer
、key
、oaepLabel
或passphrase
是字符串时使用的字符串编码。¥
encoding
<string> The string encoding to use whenbuffer
,key
,oaepLabel
, orpassphrase
are strings.
-
-
buffer
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> -
返回:<Buffer> 带有加密内容的新
Buffer
。¥Returns: <Buffer> A new
Buffer
with the encrypted content.
用 key
加密 buffer
的内容,并返回带有加密内容的新 Buffer
。返回的数据可以使用相应的私钥解密,例如使用 crypto.privateDecrypt()
。
¥Encrypts the content of buffer
with key
and returns a new
Buffer
with encrypted content. The returned data can be decrypted using
the corresponding private key, for example using crypto.privateDecrypt()
.
如果 key
不是 KeyObject
,则此函数的行为就像将 key
传给 crypto.createPublicKey()
一样。如果是对象,则可以传入 padding
属性。否则,该函数使用 RSA_PKCS1_OAEP_PADDING
。
¥If key
is not a KeyObject
, this function behaves as if
key
had been passed to crypto.createPublicKey()
. If it is an
object, the padding
property can be passed. Otherwise, this function uses
RSA_PKCS1_OAEP_PADDING
.
由于 RSA 公钥可以从私钥派生,因此可以传入私钥而不是公钥。
¥Because RSA public keys can be derived from private keys, a private key may be passed instead of a public key.
crypto.randomBytes(size[, callback])
#
-
size
<number> 要生成的字节数。size
不得大于2**31 - 1
。¥
size
<number> The number of bytes to generate. Thesize
must not be larger than2**31 - 1
. -
callback
<Function> -
返回:如果未提供
callback
函数,则为 <Buffer>。¥Returns: <Buffer> if the
callback
function is not provided.
生成加密强伪随机数据。size
参数是数字,指示要生成的字节数。
¥Generates cryptographically strong pseudorandom data. The size
argument
is a number indicating the number of bytes to generate.
如果提供了 callback
函数,则异步生成字节并使用两个参数调用 callback
函数:err
和 buf
。如果发生错误,err
将是一个 Error
对象;否则为 null
。buf
参数是包含生成字节的 Buffer
。
¥If a callback
function is provided, the bytes are generated asynchronously
and the callback
function is invoked with two arguments: err
and buf
.
If an error occurs, err
will be an Error
object; otherwise it is null
. The
buf
argument is a Buffer
containing the generated bytes.
// Asynchronous
const {
randomBytes,
} = await import('node:crypto');
randomBytes(256, (err, buf) => {
if (err) throw err;
console.log(`${buf.length} bytes of random data: ${buf.toString('hex')}`);
});
// Asynchronous
const {
randomBytes,
} = require('node:crypto');
randomBytes(256, (err, buf) => {
if (err) throw err;
console.log(`${buf.length} bytes of random data: ${buf.toString('hex')}`);
});
如果未提供 callback
函数,则同步生成随机字节并作为 Buffer
返回。如果生成字节出现问题,则会抛出错误。
¥If the callback
function is not provided, the random bytes are generated
synchronously and returned as a Buffer
. An error will be thrown if
there is a problem generating the bytes.
// Synchronous
const {
randomBytes,
} = await import('node:crypto');
const buf = randomBytes(256);
console.log(
`${buf.length} bytes of random data: ${buf.toString('hex')}`);
// Synchronous
const {
randomBytes,
} = require('node:crypto');
const buf = randomBytes(256);
console.log(
`${buf.length} bytes of random data: ${buf.toString('hex')}`);
crypto.randomBytes()
方法将不会完成,直到有足够的可用熵。这通常不会超过几毫秒。可以想象,生成随机字节的唯一时间可能会阻塞更长的时间是在启动之后,此时整个系统的熵仍然很低。
¥The crypto.randomBytes()
method will not complete until there is
sufficient entropy available.
This should normally never take longer than a few milliseconds. The only time
when generating the random bytes may conceivably block for a longer period of
time is right after boot, when the whole system is still low on entropy.
该 API 使用 libuv 的线程池,这对某些应用可能具有令人惊讶的负面性能影响;有关详细信息,请参阅 UV_THREADPOOL_SIZE
文档。
¥This API uses libuv's threadpool, which can have surprising and
negative performance implications for some applications; see the
UV_THREADPOOL_SIZE
documentation for more information.
crypto.randomBytes()
的异步版本是在单个线程池请求中执行的。为了最大限度地减少线程池任务长度变化,在执行客户端请求时将大型 randomBytes
请求分区。
¥The asynchronous version of crypto.randomBytes()
is carried out in a single
threadpool request. To minimize threadpool task length variation, partition
large randomBytes
requests when doing so as part of fulfilling a client
request.
crypto.randomFillSync(buffer[, offset][, size])
#
-
buffer
<ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 必须提供。所提供的buffer
的尺寸不得大于2**31 - 1
。¥
buffer
<ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> Must be supplied. The size of the providedbuffer
must not be larger than2**31 - 1
. -
offset
<number> 默认值:0
¥
offset
<number> Default:0
-
size
<number> 默认值:buffer.length - offset
。size
不得大于2**31 - 1
。¥
size
<number> Default:buffer.length - offset
. Thesize
must not be larger than2**31 - 1
. -
返回:<ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 对象作为
buffer
参数传入。¥Returns: <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> The object passed as
buffer
argument.
crypto.randomFill()
的同步版本。
¥Synchronous version of crypto.randomFill()
.
import { Buffer } from 'node:buffer';
const { randomFillSync } = await import('node:crypto');
const buf = Buffer.alloc(10);
console.log(randomFillSync(buf).toString('hex'));
randomFillSync(buf, 5);
console.log(buf.toString('hex'));
// The above is equivalent to the following:
randomFillSync(buf, 5, 5);
console.log(buf.toString('hex'));
const { randomFillSync } = require('node:crypto');
const { Buffer } = require('node:buffer');
const buf = Buffer.alloc(10);
console.log(randomFillSync(buf).toString('hex'));
randomFillSync(buf, 5);
console.log(buf.toString('hex'));
// The above is equivalent to the following:
randomFillSync(buf, 5, 5);
console.log(buf.toString('hex'));
任何 ArrayBuffer
、TypedArray
或 DataView
实例都可以作为 buffer
传入。
¥Any ArrayBuffer
, TypedArray
or DataView
instance may be passed as
buffer
.
import { Buffer } from 'node:buffer';
const { randomFillSync } = await import('node:crypto');
const a = new Uint32Array(10);
console.log(Buffer.from(randomFillSync(a).buffer,
a.byteOffset, a.byteLength).toString('hex'));
const b = new DataView(new ArrayBuffer(10));
console.log(Buffer.from(randomFillSync(b).buffer,
b.byteOffset, b.byteLength).toString('hex'));
const c = new ArrayBuffer(10);
console.log(Buffer.from(randomFillSync(c)).toString('hex'));
const { randomFillSync } = require('node:crypto');
const { Buffer } = require('node:buffer');
const a = new Uint32Array(10);
console.log(Buffer.from(randomFillSync(a).buffer,
a.byteOffset, a.byteLength).toString('hex'));
const b = new DataView(new ArrayBuffer(10));
console.log(Buffer.from(randomFillSync(b).buffer,
b.byteOffset, b.byteLength).toString('hex'));
const c = new ArrayBuffer(10);
console.log(Buffer.from(randomFillSync(c)).toString('hex'));
crypto.randomFill(buffer[, offset][, size], callback)
#
-
buffer
<ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 必须提供。所提供的buffer
的尺寸不得大于2**31 - 1
。¥
buffer
<ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> Must be supplied. The size of the providedbuffer
must not be larger than2**31 - 1
. -
offset
<number> 默认值:0
¥
offset
<number> Default:0
-
size
<number> 默认值:buffer.length - offset
。size
不得大于2**31 - 1
。¥
size
<number> Default:buffer.length - offset
. Thesize
must not be larger than2**31 - 1
. -
callback
<Function>function(err, buf) {}
。
此函数类似于 crypto.randomBytes()
,但要求第一个参数是将被填充的 Buffer
。它还要求传入回调。
¥This function is similar to crypto.randomBytes()
but requires the first
argument to be a Buffer
that will be filled. It also
requires that a callback is passed in.
如果未提供 callback
函数,则会抛出错误。
¥If the callback
function is not provided, an error will be thrown.
import { Buffer } from 'node:buffer';
const { randomFill } = await import('node:crypto');
const buf = Buffer.alloc(10);
randomFill(buf, (err, buf) => {
if (err) throw err;
console.log(buf.toString('hex'));
});
randomFill(buf, 5, (err, buf) => {
if (err) throw err;
console.log(buf.toString('hex'));
});
// The above is equivalent to the following:
randomFill(buf, 5, 5, (err, buf) => {
if (err) throw err;
console.log(buf.toString('hex'));
});
const { randomFill } = require('node:crypto');
const { Buffer } = require('node:buffer');
const buf = Buffer.alloc(10);
randomFill(buf, (err, buf) => {
if (err) throw err;
console.log(buf.toString('hex'));
});
randomFill(buf, 5, (err, buf) => {
if (err) throw err;
console.log(buf.toString('hex'));
});
// The above is equivalent to the following:
randomFill(buf, 5, 5, (err, buf) => {
if (err) throw err;
console.log(buf.toString('hex'));
});
任何 ArrayBuffer
、TypedArray
或 DataView
实例都可以作为 buffer
传入。
¥Any ArrayBuffer
, TypedArray
, or DataView
instance may be passed as
buffer
.
虽然这包括 Float32Array
和 Float64Array
的实例,但不应使用此函数生成随机浮点数。结果可能包含 +Infinity
、-Infinity
和 NaN
,即使数组只包含有限数字,它们也不是从均匀随机分布中抽取的,并且没有有意义的下限或上限。
¥While this includes instances of Float32Array
and Float64Array
, this
function should not be used to generate random floating-point numbers. The
result may contain +Infinity
, -Infinity
, and NaN
, and even if the array
contains finite numbers only, they are not drawn from a uniform random
distribution and have no meaningful lower or upper bounds.
import { Buffer } from 'node:buffer';
const { randomFill } = await import('node:crypto');
const a = new Uint32Array(10);
randomFill(a, (err, buf) => {
if (err) throw err;
console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
.toString('hex'));
});
const b = new DataView(new ArrayBuffer(10));
randomFill(b, (err, buf) => {
if (err) throw err;
console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
.toString('hex'));
});
const c = new ArrayBuffer(10);
randomFill(c, (err, buf) => {
if (err) throw err;
console.log(Buffer.from(buf).toString('hex'));
});
const { randomFill } = require('node:crypto');
const { Buffer } = require('node:buffer');
const a = new Uint32Array(10);
randomFill(a, (err, buf) => {
if (err) throw err;
console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
.toString('hex'));
});
const b = new DataView(new ArrayBuffer(10));
randomFill(b, (err, buf) => {
if (err) throw err;
console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
.toString('hex'));
});
const c = new ArrayBuffer(10);
randomFill(c, (err, buf) => {
if (err) throw err;
console.log(Buffer.from(buf).toString('hex'));
});
该 API 使用 libuv 的线程池,这对某些应用可能具有令人惊讶的负面性能影响;有关详细信息,请参阅 UV_THREADPOOL_SIZE
文档。
¥This API uses libuv's threadpool, which can have surprising and
negative performance implications for some applications; see the
UV_THREADPOOL_SIZE
documentation for more information.
crypto.randomFill()
的异步版本是在单个线程池请求中执行的。为了最大限度地减少线程池任务长度变化,在执行客户端请求时将大型 randomFill
请求分区。
¥The asynchronous version of crypto.randomFill()
is carried out in a single
threadpool request. To minimize threadpool task length variation, partition
large randomFill
requests when doing so as part of fulfilling a client
request.
crypto.randomInt([min, ]max[, callback])
#
-
min
<integer> 随机范围的开始(包括)。默认值:0
。¥
min
<integer> Start of random range (inclusive). Default:0
. -
max
<integer> 随机范围的结束(不包括)。¥
max
<integer> End of random range (exclusive). -
callback
<Function>function(err, n) {}
。
返回随机整数 n
,使得 min <= n < max
。此实现避免了 模偏差。
¥Return a random integer n
such that min <= n < max
. This
implementation avoids modulo bias.
范围 (max - min
) 必须小于 248。min
和 max
必须是 安全整数。
¥The range (max - min
) must be less than 248. min
and max
must
be safe integers.
如果不提供 callback
函数,则同步生成随机整数。
¥If the callback
function is not provided, the random integer is
generated synchronously.
// Asynchronous
const {
randomInt,
} = await import('node:crypto');
randomInt(3, (err, n) => {
if (err) throw err;
console.log(`Random number chosen from (0, 1, 2): ${n}`);
});
// Asynchronous
const {
randomInt,
} = require('node:crypto');
randomInt(3, (err, n) => {
if (err) throw err;
console.log(`Random number chosen from (0, 1, 2): ${n}`);
});
// Synchronous
const {
randomInt,
} = await import('node:crypto');
const n = randomInt(3);
console.log(`Random number chosen from (0, 1, 2): ${n}`);
// Synchronous
const {
randomInt,
} = require('node:crypto');
const n = randomInt(3);
console.log(`Random number chosen from (0, 1, 2): ${n}`);
// With `min` argument
const {
randomInt,
} = await import('node:crypto');
const n = randomInt(1, 7);
console.log(`The dice rolled: ${n}`);
// With `min` argument
const {
randomInt,
} = require('node:crypto');
const n = randomInt(1, 7);
console.log(`The dice rolled: ${n}`);
crypto.randomUUID([options])
#
-
options
<Object>-
disableEntropyCache
<boolean> 默认情况下,为了提高性能,Node.js 会生成并缓存足够多的随机数据,以生成多达 128 个随机 UUID。要在不使用缓存的情况下生成 UUID,请将disableEntropyCache
设置为true
。默认值:false
。¥
disableEntropyCache
<boolean> By default, to improve performance, Node.js generates and caches enough random data to generate up to 128 random UUIDs. To generate a UUID without using the cache, setdisableEntropyCache
totrue
. Default:false
.
-
-
返回:<string>
¥Returns: <string>
生成一个随机的 RFC 4122 版本 4 UUID。UUID 是使用加密伪随机数生成器生成的。
¥Generates a random RFC 4122 version 4 UUID. The UUID is generated using a cryptographic pseudorandom number generator.
crypto.scrypt(password, salt, keylen[, options], callback)
#
-
password
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> -
salt
<string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> -
keylen
<number> -
options
<Object>-
cost
<number> CPU/内存成本参数。必须是大于 1 的 2 的幂。默认值:16384
。¥
cost
<number> CPU/memory cost parameter. Must be a power of two greater than one. Default:16384
. -
blockSize
<number> 块大小参数。默认值:8
。¥
blockSize
<number> Block size parameter. Default:8
. -
parallelization
<number> 并行化参数。默认值:1
。¥
parallelization
<number> Parallelization parameter. Default:1
. -
N
<number>cost
的别名。只能指定两者之一。¥
N
<number> Alias forcost
. Only one of both may be specified. -
r
<number>blockSize
的别名。只能指定两者之一。¥
r
<number> Alias forblockSize
. Only one of both may be specified. -
p
<number>parallelization
的别名。只能指定两者之一。¥
p
<number> Alias forparallelization
. Only one of both may be specified. -
maxmem
<number> 内存上限。当(大约)128 * N * r > maxmem
时,则为错误。默认值:32 * 1024 * 1024
。¥
maxmem
<number> Memory upper bound. It is an error when (approximately)128 * N * r > maxmem
. Default:32 * 1024 * 1024
.
-
-
callback
<Function>
提供异步 scrypt 实现。Scrypt 是一个基于密码的密钥派生函数,其设计在计算和内存方面都非常昂贵,以使蛮力攻击毫无回报。
¥Provides an asynchronous scrypt implementation. Scrypt is a password-based key derivation function that is designed to be expensive computationally and memory-wise in order to make brute-force attacks unrewarding.
salt
应该尽可能唯一。建议盐是随机的,长度至少为 16 字节。详见 NIST SP 800-132。
¥The salt
should be as unique as possible. It is recommended that a salt is
random and at least 16 bytes long. See NIST SP 800-132 for details.
为 password
或 salt
传递字符串时,请考虑 使用字符串作为加密 API 的输入时的注意事项。
¥When passing strings for password
or salt
, please consider
caveats when using strings as inputs to cryptographic APIs.
使用两个参数调用 callback
函数:err
和 derivedKey
。当密钥派生失败时 err
为异常对象,否则 err
为 null
。derivedKey
作为 Buffer
传给回调。
¥The callback
function is called with two arguments: err
and derivedKey
.
err
is an exception object when key derivation fails, otherwise err
is
null
. derivedKey
is passed to the callback as a Buffer
.
当任何输入参数指定无效值或类型时,将抛出异常。
¥An exception is thrown when any of the input arguments specify invalid values or types.
const {
scrypt,
} = await import('node:crypto');
// Using the factory defaults.
scrypt('password', 'salt', 64, (err, derivedKey) => {
if (err) throw err;
console.log(derivedKey.toString('hex')); // '3745e48...08d59ae'
});
// Using a custom N parameter. Must be a power of two.
scrypt('password', 'salt', 64, { N: 1024 }, (err, derivedKey) => {
if (err) throw err;
console.log(derivedKey.toString('hex')); // '3745e48...aa39b34'
});
const {
scrypt,
} = require('node:crypto');
// Using the factory defaults.
scrypt('password', 'salt', 64, (err, derivedKey) => {
if (err) throw err;
console.log(derivedKey.toString('hex')); // '3745e48...08d59ae'
});
// Using a custom N parameter. Must be a power of two.
scrypt('password', 'salt', 64, { N: 1024 }, (err, derivedKey) => {
if (err) throw err;
console.log(derivedKey.toString('hex')); // '3745e48...aa39b34'
});
crypto.scryptSync(password, salt, keylen[, options])
#
-
password
<string> | <Buffer> | <TypedArray> | <DataView> -
salt
<string> | <Buffer> | <TypedArray> | <DataView> -
keylen
<number> -
options
<Object>-
cost
<number> CPU/内存成本参数。必须是大于 1 的 2 的幂。默认值:16384
。¥
cost
<number> CPU/memory cost parameter. Must be a power of two greater than one. Default:16384
. -
blockSize
<number> 块大小参数。默认值:8
。¥
blockSize
<number> Block size parameter. Default:8
. -
parallelization
<number> 并行化参数。默认值:1
。¥
parallelization
<number> Parallelization parameter. Default:1
. -
N
<number>cost
的别名。只能指定两者之一。¥
N
<number> Alias forcost
. Only one of both may be specified. -
r
<number>blockSize
的别名。只能指定两者之一。¥
r
<number> Alias forblockSize
. Only one of both may be specified. -
p
<number>parallelization
的别名。只能指定两者之一。¥
p
<number> Alias forparallelization
. Only one of both may be specified. -
maxmem
<number> 内存上限。当(大约)128 * N * r > maxmem
时,则为错误。默认值:32 * 1024 * 1024
。¥
maxmem
<number> Memory upper bound. It is an error when (approximately)128 * N * r > maxmem
. Default:32 * 1024 * 1024
.
-
-
返回:<Buffer>
¥Returns: <Buffer>
提供同步 scrypt 实现。Scrypt 是一个基于密码的密钥派生函数,其设计在计算和内存方面都非常昂贵,以使蛮力攻击毫无回报。
¥Provides a synchronous scrypt implementation. Scrypt is a password-based key derivation function that is designed to be expensive computationally and memory-wise in order to make brute-force attacks unrewarding.
salt
应该尽可能唯一。建议盐是随机的,长度至少为 16 字节。详见 NIST SP 800-132。
¥The salt
should be as unique as possible. It is recommended that a salt is
random and at least 16 bytes long. See NIST SP 800-132 for details.
为 password
或 salt
传递字符串时,请考虑 使用字符串作为加密 API 的输入时的注意事项。
¥When passing strings for password
or salt
, please consider
caveats when using strings as inputs to cryptographic APIs.
当密钥派生失败时抛出异常,否则派生的密钥作为 Buffer
返回。
¥An exception is thrown when key derivation fails, otherwise the derived key is
returned as a Buffer
.
当任何输入参数指定无效值或类型时,将抛出异常。
¥An exception is thrown when any of the input arguments specify invalid values or types.
const {
scryptSync,
} = await import('node:crypto');
// Using the factory defaults.
const key1 = scryptSync('password', 'salt', 64);
console.log(key1.toString('hex')); // '3745e48...08d59ae'
// Using a custom N parameter. Must be a power of two.
const key2 = scryptSync('password', 'salt', 64, { N: 1024 });
console.log(key2.toString('hex')); // '3745e48...aa39b34'
const {
scryptSync,
} = require('node:crypto');
// Using the factory defaults.
const key1 = scryptSync('password', 'salt', 64);
console.log(key1.toString('hex')); // '3745e48...08d59ae'
// Using a custom N parameter. Must be a power of two.
const key2 = scryptSync('password', 'salt', 64, { N: 1024 });
console.log(key2.toString('hex')); // '3745e48...aa39b34'
crypto.secureHeapUsed()
#
-
返回:<Object>
¥Returns: <Object>
-
total
<number> 使用--secure-heap=n
命令行标志指定的总分配安全堆大小。¥
total
<number> The total allocated secure heap size as specified using the--secure-heap=n
command-line flag. -
min
<number> 使用--secure-heap-min
命令行标志指定的安全堆的最小分配。¥
min
<number> The minimum allocation from the secure heap as specified using the--secure-heap-min
command-line flag. -
used
<number> 当前从安全堆分配的总字节数。¥
used
<number> The total number of bytes currently allocated from the secure heap. -
utilization
<number>used
与total
分配字节的计算比率。¥
utilization
<number> The calculated ratio ofused
tototal
allocated bytes.
-
crypto.setEngine(engine[, flags])
#
-
engine
<string> -
flags
<crypto.constants> 默认值:crypto.constants.ENGINE_METHOD_ALL
¥
flags
<crypto.constants> Default:crypto.constants.ENGINE_METHOD_ALL
为部分或所有 OpenSSL 功能(由标志选择)加载并设置 engine
。从 OpenSSL 3 开始,OpenSSL 不再支持自定义引擎。
¥Load and set the engine
for some or all OpenSSL functions (selected by flags).
Support for custom engines in OpenSSL is deprecated from OpenSSL 3.
engine
可以是 id 或引擎共享库的路径。
¥engine
could be either an id or a path to the engine's shared library.
可选的 flags
参数默认使用 ENGINE_METHOD_ALL
。flags
是采用以下标志之一或混合的位字段(在 crypto.constants
中定义):
¥The optional flags
argument uses ENGINE_METHOD_ALL
by default. The flags
is a bit field taking one of or a mix of the following flags (defined in
crypto.constants
):
-
crypto.constants.ENGINE_METHOD_RSA
-
crypto.constants.ENGINE_METHOD_DSA
-
crypto.constants.ENGINE_METHOD_DH
-
crypto.constants.ENGINE_METHOD_RAND
-
crypto.constants.ENGINE_METHOD_EC
-
crypto.constants.ENGINE_METHOD_CIPHERS
-
crypto.constants.ENGINE_METHOD_DIGESTS
-
crypto.constants.ENGINE_METHOD_PKEY_METHS
-
crypto.constants.ENGINE_METHOD_PKEY_ASN1_METHS
-
crypto.constants.ENGINE_METHOD_ALL
-
crypto.constants.ENGINE_METHOD_NONE
crypto.setFips(bool)
#
在启用 FIPS 的 Node.js 构建中启用符合 FIPS 的加密提供程序。如果 FIPS 模式不可用,则会抛出错误。
¥Enables the FIPS compliant crypto provider in a FIPS-enabled Node.js build. Throws an error if FIPS mode is not available.
crypto.sign(algorithm, data, key[, callback])
#
-
algorithm
<string> | <null> | <undefined> -
data
<ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> -
key
<Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey> -
callback
<Function> -
返回:如果未提供
callback
函数,则为 <Buffer>。¥Returns: <Buffer> if the
callback
function is not provided.
使用给定的私钥和算法计算并返回 data
的签名。如果 algorithm
是 null
或 undefined
,则算法取决于密钥类型(尤其是 Ed25519 和 Ed448)。
¥Calculates and returns the signature for data
using the given private key and
algorithm. If algorithm
is null
or undefined
, then the algorithm is
dependent upon the key type (especially Ed25519 and Ed448).
如果 key
不是 KeyObject
,则此函数的行为就像将 key
传给 crypto.createPrivateKey()
一样。如果是对象,则可以传入以下额外属性:
¥If key
is not a KeyObject
, this function behaves as if key
had been
passed to crypto.createPrivateKey()
. If it is an object, the following
additional properties can be passed:
-
dsaEncoding
<string> 对于 DSA 和 ECDSA,此选项指定生成签名的格式。它可以是以下之一:¥
dsaEncoding
<string> For DSA and ECDSA, this option specifies the format of the generated signature. It can be one of the following:-
'der'
(默认):DER 编码的 ASN.1 签名结构编码(r, s)
。¥
'der'
(default): DER-encoded ASN.1 signature structure encoding(r, s)
. -
'ieee-p1363'
:IEEE-P1363 中提议的签名格式r || s
。¥
'ieee-p1363'
: Signature formatr || s
as proposed in IEEE-P1363.
-
-
padding
<integer> RSA 的可选填充值,以下之一:¥
padding
<integer> Optional padding value for RSA, one of the following:-
crypto.constants.RSA_PKCS1_PADDING
(默认)¥
crypto.constants.RSA_PKCS1_PADDING
(default) -
crypto.constants.RSA_PKCS1_PSS_PADDING
RSA_PKCS1_PSS_PADDING
将使用 MGF1,其散列函数与 RFC 4055 第 3.1 节中指定的消息签名相同。¥
RSA_PKCS1_PSS_PADDING
will use MGF1 with the same hash function used to sign the message as specified in section 3.1 of RFC 4055. -
-
saltLength
<integer> 填充为RSA_PKCS1_PSS_PADDING
时的盐长度。特殊值crypto.constants.RSA_PSS_SALTLEN_DIGEST
将盐长度设置为摘要大小,crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN
(默认值)将其设置为最大允许值。¥
saltLength
<integer> Salt length for when padding isRSA_PKCS1_PSS_PADDING
. The special valuecrypto.constants.RSA_PSS_SALTLEN_DIGEST
sets the salt length to the digest size,crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN
(default) sets it to the maximum permissible value.
如果提供了 callback
函数,则该函数使用 libuv 的线程池。
¥If the callback
function is provided this function uses libuv's threadpool.
crypto.subtle
#
-
¥Type: <SubtleCrypto>
crypto.webcrypto.subtle
的便捷别名。
¥A convenient alias for crypto.webcrypto.subtle
.
crypto.timingSafeEqual(a, b)
#
-
a
<ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> -
b
<ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> -
返回:<boolean>
¥Returns: <boolean>
此函数使用恒定时间算法比较表示给定 ArrayBuffer
、TypedArray
或 DataView
实例的底层字节。
¥This function compares the underlying bytes that represent the given
ArrayBuffer
, TypedArray
, or DataView
instances using a constant-time
algorithm.
此函数不会泄露允许攻击者猜测其中一个值的计时信息。这适用于比较 HMAC 摘要或秘密值,如身份验证 cookie 或 能力网址。
¥This function does not leak timing information that would allow an attacker to guess one of the values. This is suitable for comparing HMAC digests or secret values like authentication cookies or capability urls.
a
和 b
必须都是 Buffer
、TypedArray
或 DataView
,并且它们的字节长度必须相同。如果 a
和 b
的字节长度不同,则抛出错误。
¥a
and b
must both be Buffer
s, TypedArray
s, or DataView
s, and they
must have the same byte length. An error is thrown if a
and b
have
different byte lengths.
如果 a
和 b
中的至少一个是每个条目超过一个字节的 TypedArray
,例如 Uint16Array
,则将使用平台字节顺序计算结果。
¥If at least one of a
and b
is a TypedArray
with more than one byte per
entry, such as Uint16Array
, the result will be computed using the platform
byte order.
当两个输入均为 Float32Array
或 Float64Array
时,由于浮点数的 IEEE 754 编码,此函数可能会返回意外结果。特别是,x === y
和 Object.is(x, y)
都不意味着两个浮点数 x
和 y
的字节表示是相等的。
¥When both of the inputs are Float32Array
s or
Float64Array
s, this function might return unexpected results due to IEEE 754
encoding of floating-point numbers. In particular, neither x === y
nor
Object.is(x, y)
implies that the byte representations of two floating-point
numbers x
and y
are equal.
使用 crypto.timingSafeEqual
并不能保证周围的代码是时序安全的。应注意确保周围的代码不会引入时序漏洞。
¥Use of crypto.timingSafeEqual
does not guarantee that the surrounding code
is timing-safe. Care should be taken to ensure that the surrounding code does
not introduce timing vulnerabilities.
crypto.verify(algorithm, data, key, signature[, callback])
#
-
algorithm
<string> | <null> | <undefined> -
data
<ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> -
key
<Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey> -
signature
<ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> -
callback
<Function> -
返回:<boolean> 如果未提供
callback
函数,则true
或false
取决于数据和公钥签名的有效性。¥Returns: <boolean>
true
orfalse
depending on the validity of the signature for the data and public key if thecallback
function is not provided.
使用给定的密钥和算法验证 data
的给定签名。如果 algorithm
是 null
或 undefined
,则算法取决于密钥类型(尤其是 Ed25519 和 Ed448)。
¥Verifies the given signature for data
using the given key and algorithm. If
algorithm
is null
or undefined
, then the algorithm is dependent upon the
key type (especially Ed25519 and Ed448).
如果 key
不是 KeyObject
,则此函数的行为就像将 key
传给 crypto.createPublicKey()
一样。如果是对象,则可以传入以下额外属性:
¥If key
is not a KeyObject
, this function behaves as if key
had been
passed to crypto.createPublicKey()
. If it is an object, the following
additional properties can be passed:
-
dsaEncoding
<string> 对于 DSA 和 ECDSA,此选项指定签名的格式。它可以是以下之一:¥
dsaEncoding
<string> For DSA and ECDSA, this option specifies the format of the signature. It can be one of the following:-
'der'
(默认):DER 编码的 ASN.1 签名结构编码(r, s)
。¥
'der'
(default): DER-encoded ASN.1 signature structure encoding(r, s)
. -
'ieee-p1363'
:IEEE-P1363 中提议的签名格式r || s
。¥
'ieee-p1363'
: Signature formatr || s
as proposed in IEEE-P1363.
-
-
padding
<integer> RSA 的可选填充值,以下之一:¥
padding
<integer> Optional padding value for RSA, one of the following:-
crypto.constants.RSA_PKCS1_PADDING
(默认)¥
crypto.constants.RSA_PKCS1_PADDING
(default) -
crypto.constants.RSA_PKCS1_PSS_PADDING
RSA_PKCS1_PSS_PADDING
将使用 MGF1,其散列函数与 RFC 4055 第 3.1 节中指定的消息签名相同。¥
RSA_PKCS1_PSS_PADDING
will use MGF1 with the same hash function used to sign the message as specified in section 3.1 of RFC 4055. -
-
saltLength
<integer> 填充为RSA_PKCS1_PSS_PADDING
时的盐长度。特殊值crypto.constants.RSA_PSS_SALTLEN_DIGEST
将盐长度设置为摘要大小,crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN
(默认值)将其设置为最大允许值。¥
saltLength
<integer> Salt length for when padding isRSA_PKCS1_PSS_PADDING
. The special valuecrypto.constants.RSA_PSS_SALTLEN_DIGEST
sets the salt length to the digest size,crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN
(default) sets it to the maximum permissible value.
signature
参数是先前为 data
计算的签名。
¥The signature
argument is the previously calculated signature for the data
.
因为公钥可以从私钥派生出来,所以可以为 key
传入私钥或公钥。
¥Because public keys can be derived from private keys, a private key or a public
key may be passed for key
.
如果提供了 callback
函数,则该函数使用 libuv 的线程池。
¥If the callback
function is provided this function uses libuv's threadpool.
crypto.webcrypto
#
类型:<Crypto> Web Crypto API 标准的实现。
¥Type: <Crypto> An implementation of the Web Crypto API standard.
有关详细信息,请参见 网络加密 API 文档。
¥See the Web Crypto API documentation for details.
注意事项#
¥Notes
使用字符串作为加密 API 的输入#
¥Using strings as inputs to cryptographic APIs
由于历史原因,Node.js 提供的许多加密 API 都接受字符串作为输入,其中底层加密算法处理字节序列。这些实例包括明文、密文、对称密钥、初始化向量、密码、盐、认证标签和额外的认证数据。
¥For historical reasons, many cryptographic APIs provided by Node.js accept strings as inputs where the underlying cryptographic algorithm works on byte sequences. These instances include plaintexts, ciphertexts, symmetric keys, initialization vectors, passphrases, salts, authentication tags, and additional authenticated data.
将字符串传给加密 API 时,请考虑以下因素。
¥When passing strings to cryptographic APIs, consider the following factors.
-
并非所有字节序列都是有效的 UTF-8 字符串。因此,当从字符串中导出长度为
n
的字节序列时,其熵通常低于随机或伪随机n
字节序列的熵。例如,没有 UTF-8 字符串将导致字节序列c0 af
。秘密密钥应该几乎完全是随机或伪随机字节序列。¥Not all byte sequences are valid UTF-8 strings. Therefore, when a byte sequence of length
n
is derived from a string, its entropy is generally lower than the entropy of a random or pseudorandomn
byte sequence. For example, no UTF-8 string will result in the byte sequencec0 af
. Secret keys should almost exclusively be random or pseudorandom byte sequences. -
同样,在将随机或伪随机字节序列转换为 UTF-8 字符串时,不代表有效代码点的子序列可能会被 Unicode 替换字符 (
U+FFFD
) 替换。因此,生成的 Unicode 字符串的字节表示可能不等于创建字符串的字节序列。¥Similarly, when converting random or pseudorandom byte sequences to UTF-8 strings, subsequences that do not represent valid code points may be replaced by the Unicode replacement character (
U+FFFD
). The byte representation of the resulting Unicode string may, therefore, not be equal to the byte sequence that the string was created from.const original = [0xc0, 0xaf]; const bytesAsString = Buffer.from(original).toString('utf8'); const stringAsBytes = Buffer.from(bytesAsString, 'utf8'); console.log(stringAsBytes); // Prints '<Buffer ef bf bd ef bf bd>'.
密码、散列函数、签名算法和密钥派生函数的输出是伪随机字节序列,不应用作 Unicode 字符串。
¥The outputs of ciphers, hash functions, signature algorithms, and key derivation functions are pseudorandom byte sequences and should not be used as Unicode strings.
-
从用户输入中获取字符串时,某些 Unicode 字符可以用多种等效方式表示,从而产生不同的字节序列。例如,将用户密码传递给密钥派生函数(例如 PBKDF2 或 scrypt)时,密钥派生函数的结果取决于字符串是使用组合字符还是分解字符。Node.js 不会规范化字符表示。在将用户输入传给加密 API 之前,开发者应考虑在用户输入上使用
String.prototype.normalize()
。¥When strings are obtained from user input, some Unicode characters can be represented in multiple equivalent ways that result in different byte sequences. For example, when passing a user passphrase to a key derivation function, such as PBKDF2 or scrypt, the result of the key derivation function depends on whether the string uses composed or decomposed characters. Node.js does not normalize character representations. Developers should consider using
String.prototype.normalize()
on user inputs before passing them to cryptographic APIs.
旧版流 API(Node.js 0.10 之前)#
¥Legacy streams API (prior to Node.js 0.10)
加密模块是在 Node.js 出现统一的流 API 概念之前添加的,在 Buffer
对象用于处理二进制数据之前。因此,许多 crypto
类具有通常在实现 流 API 的其他 Node.js 类(例如 update()
、final()
或 digest()
)上找不到的方法。此外,许多方法默认接受并返回 'latin1'
编码字符串,而不是 Buffer
。此默认值在 Node.js v0.8 之后更改为默认使用 Buffer
对象。
¥The Crypto module was added to Node.js before there was the concept of a
unified Stream API, and before there were Buffer
objects for handling
binary data. As such, many crypto
classes have methods not
typically found on other Node.js classes that implement the streams
API (e.g. update()
, final()
, or digest()
). Also, many methods accepted
and returned 'latin1'
encoded strings by default rather than Buffer
s. This
default was changed after Node.js v0.8 to use Buffer
objects by default
instead.
支持弱算法或受损算法#
¥Support for weak or compromised algorithms
node:crypto
模块仍然支持一些已经被泄露的算法,不建议使用。API 还允许使用对于安全使用来说太弱的小密钥大小的密码和散列。
¥The node:crypto
module still supports some algorithms which are already
compromised and are not recommended for use. The API also allows
the use of ciphers and hashes with a small key size that are too weak for safe
use.
用户应根据自己的安全要求对选择加密算法和密钥大小负全部责任。
¥Users should take full responsibility for selecting the crypto algorithm and key size according to their security requirements.
基于 NIST SP 800-131A 的建议:
¥Based on the recommendations of NIST SP 800-131A:
-
MD5 和 SHA-1 在需要抗冲突性(例如数字签名)的情况下不再被接受。
¥MD5 and SHA-1 are no longer acceptable where collision resistance is required such as digital signatures.
-
RSA、DSA 和 DH 算法使用的密钥建议至少 2048 位,ECDSA 和 ECDH 的曲线至少 224 位,才能安全使用几年。
¥The key used with RSA, DSA, and DH algorithms is recommended to have at least 2048 bits and that of the curve of ECDSA and ECDH at least 224 bits, to be safe to use for several years.
-
modp1
、modp2
、modp5
的 DH 组密钥长度小于 2048 位,不推荐使用。¥The DH groups of
modp1
,modp2
andmodp5
have a key size smaller than 2048 bits and are not recommended.
有关其他建议和详细信息,请参阅参考资料。
¥See the reference for other recommendations and details.
一些已知弱点且在实践中几乎没有相关性的算法只能通过 旧版提供器 获得,默认情况下不启用。
¥Some algorithms that have known weaknesses and are of little relevance in practice are only available through the legacy provider, which is not enabled by default.
CCM 模式#
¥CCM mode
CCM 是受支持的 AEAD 算法 之一。使用此模式的应用在使用密码 API 时必须遵守某些限制:
¥CCM is one of the supported AEAD algorithms. Applications which use this mode must adhere to certain restrictions when using the cipher API:
-
身份验证标签长度必须在密码创建期间通过设置
authTagLength
选项指定,并且必须是 4、6、8、10、12、14 或 16 字节之一。¥The authentication tag length must be specified during cipher creation by setting the
authTagLength
option and must be one of 4, 6, 8, 10, 12, 14 or 16 bytes. -
初始化向量 (nonce)
N
的长度必须介于 7 到 13 个字节 (7 ≤ N ≤ 13
) 之间。¥The length of the initialization vector (nonce)
N
must be between 7 and 13 bytes (7 ≤ N ≤ 13
). -
明文的长度限制为
2 ** (8 * (15 - N))
个字节。¥The length of the plaintext is limited to
2 ** (8 * (15 - N))
bytes. -
解密时,必须在调用
update()
之前通过setAuthTag()
设置认证标签。否则,解密将失败,final()
将按照 RFC 3610 的第 2.6 节抛出错误。¥When decrypting, the authentication tag must be set via
setAuthTag()
before callingupdate()
. Otherwise, decryption will fail andfinal()
will throw an error in compliance with section 2.6 of RFC 3610. -
在 CCM 模式下使用
write(data)
、end(data)
或pipe()
等流方法可能会失败,因为 CCM 无法处理每个实例的多个数据块。¥Using stream methods such as
write(data)
,end(data)
orpipe()
in CCM mode might fail as CCM cannot handle more than one chunk of data per instance. -
当传入额外的认证数据 (AAD) 时,必须通过
plaintextLength
选项将实际消息的长度(以字节为单位)传递给setAAD()
。许多加密库在密文中包含认证标签,这意味着它们产生长度为plaintextLength + authTagLength
的密文。Node.js 不包含认证标签,所以密文长度始终为plaintextLength
。如果没有使用 AAD,则这不是必需的。¥When passing additional authenticated data (AAD), the length of the actual message in bytes must be passed to
setAAD()
via theplaintextLength
option. Many crypto libraries include the authentication tag in the ciphertext, which means that they produce ciphertexts of the lengthplaintextLength + authTagLength
. Node.js does not include the authentication tag, so the ciphertext length is alwaysplaintextLength
. This is not necessary if no AAD is used. -
由于 CCM 一次处理整个消息,因此必须恰好调用
update()
一次。¥As CCM processes the whole message at once,
update()
must be called exactly once. -
即使调用
update()
足以加密/解密消息,应用也必须调用final()
来计算或验证身份验证标记。¥Even though calling
update()
is sufficient to encrypt/decrypt the message, applications must callfinal()
to compute or verify the authentication tag.
import { Buffer } from 'node:buffer';
const {
createCipheriv,
createDecipheriv,
randomBytes,
} = await import('node:crypto');
const key = 'keykeykeykeykeykeykeykey';
const nonce = randomBytes(12);
const aad = Buffer.from('0123456789', 'hex');
const cipher = createCipheriv('aes-192-ccm', key, nonce, {
authTagLength: 16,
});
const plaintext = 'Hello world';
cipher.setAAD(aad, {
plaintextLength: Buffer.byteLength(plaintext),
});
const ciphertext = cipher.update(plaintext, 'utf8');
cipher.final();
const tag = cipher.getAuthTag();
// Now transmit { ciphertext, nonce, tag }.
const decipher = createDecipheriv('aes-192-ccm', key, nonce, {
authTagLength: 16,
});
decipher.setAuthTag(tag);
decipher.setAAD(aad, {
plaintextLength: ciphertext.length,
});
const receivedPlaintext = decipher.update(ciphertext, null, 'utf8');
try {
decipher.final();
} catch (err) {
throw new Error('Authentication failed!', { cause: err });
}
console.log(receivedPlaintext);
const { Buffer } = require('node:buffer');
const {
createCipheriv,
createDecipheriv,
randomBytes,
} = require('node:crypto');
const key = 'keykeykeykeykeykeykeykey';
const nonce = randomBytes(12);
const aad = Buffer.from('0123456789', 'hex');
const cipher = createCipheriv('aes-192-ccm', key, nonce, {
authTagLength: 16,
});
const plaintext = 'Hello world';
cipher.setAAD(aad, {
plaintextLength: Buffer.byteLength(plaintext),
});
const ciphertext = cipher.update(plaintext, 'utf8');
cipher.final();
const tag = cipher.getAuthTag();
// Now transmit { ciphertext, nonce, tag }.
const decipher = createDecipheriv('aes-192-ccm', key, nonce, {
authTagLength: 16,
});
decipher.setAuthTag(tag);
decipher.setAAD(aad, {
plaintextLength: ciphertext.length,
});
const receivedPlaintext = decipher.update(ciphertext, null, 'utf8');
try {
decipher.final();
} catch (err) {
throw new Error('Authentication failed!', { cause: err });
}
console.log(receivedPlaintext);
FIPS 模式#
¥FIPS mode
使用 OpenSSL 3 时,Node.js 在与适当的 OpenSSL 3 提供程序(例如可以按照 OpenSSL 的 FIPS 自述文件 中的说明安装的 来自 OpenSSL 3 的 FIPS 提供程序)一起使用时支持 FIPS 140-2。
¥When using OpenSSL 3, Node.js supports FIPS 140-2 when used with an appropriate OpenSSL 3 provider, such as the FIPS provider from OpenSSL 3 which can be installed by following the instructions in OpenSSL's FIPS README file.
对于 Node.js 中的 FIPS 支持,你需要:
¥For FIPS support in Node.js you will need:
-
正确安装的 OpenSSL 3 FIPS 提供程序。
¥A correctly installed OpenSSL 3 FIPS provider.
-
OpenSSL 3 FIPS 模块配置文件。
¥An OpenSSL 3 FIPS module configuration file.
-
引用 FIPS 模块配置文件的 OpenSSL 3 配置文件。
¥An OpenSSL 3 configuration file that references the FIPS module configuration file.
Node.js 需要使用指向 FIPS 提供程序的 OpenSSL 配置文件进行配置。示例配置文件如下所示:
¥Node.js will need to be configured with an OpenSSL configuration file that points to the FIPS provider. An example configuration file looks like this:
nodejs_conf = nodejs_init
.include /<absolute path>/fipsmodule.cnf
[nodejs_init]
providers = provider_sect
[provider_sect]
default = default_sect
# The fips section name should match the section name inside the
# included fipsmodule.cnf.
fips = fips_sect
[default_sect]
activate = 1
其中 fipsmodule.cnf
是 FIPS 提供程序安装步骤生成的 FIPS 模块配置文件:
¥where fipsmodule.cnf
is the FIPS module configuration file generated from the
FIPS provider installation step:
openssl fipsinstall
将 OPENSSL_CONF
环境变量设置为指向你的配置文件,并将 OPENSSL_MODULES
设置为 FIPS 提供程序动态库的位置。例如
¥Set the OPENSSL_CONF
environment variable to point to
your configuration file and OPENSSL_MODULES
to the location of the FIPS
provider dynamic library. e.g.
export OPENSSL_CONF=/<path to configuration file>/nodejs.cnf
export OPENSSL_MODULES=/<path to openssl lib>/ossl-modules
然后可以通过以下方式在 Node.js 中启用 FIPS 模式:
¥FIPS mode can then be enabled in Node.js either by:
-
使用
--enable-fips
或--force-fips
命令行标志启动 Node.js。¥Starting Node.js with
--enable-fips
or--force-fips
command line flags. -
以编程方式调用
crypto.setFips(true)
。¥Programmatically calling
crypto.setFips(true)
.
可以选择通过 OpenSSL 配置文件在 Node.js 中启用 FIPS 模式。例如
¥Optionally FIPS mode can be enabled in Node.js via the OpenSSL configuration file. e.g.
nodejs_conf = nodejs_init
.include /<absolute path>/fipsmodule.cnf
[nodejs_init]
providers = provider_sect
alg_section = algorithm_sect
[provider_sect]
default = default_sect
# The fips section name should match the section name inside the
# included fipsmodule.cnf.
fips = fips_sect
[default_sect]
activate = 1
[algorithm_sect]
default_properties = fips=yes
加密常量#
¥Crypto constants
crypto.constants
导出的以下常量适用于 node:crypto
、node:tls
和 node:https
模块的各种用途,并且通常特定于 OpenSSL。
¥The following constants exported by crypto.constants
apply to various uses of
the node:crypto
, node:tls
, and node:https
modules and are generally
specific to OpenSSL.
OpenSSL 选项#
¥OpenSSL options
有关详细信息,请参见 SSL OP 标志列表。
¥See the list of SSL OP Flags for details.
常量 | 描述 |
---|---|
SSL_OP_ALL |
在 OpenSSL 中应用多个错误解决方法。详细信息请参见 https://www.openssl.org/docs/man3.0/man3/SSL_CTX_set_options.html。 |
SSL_OP_ALLOW_NO_DHE_KEX |
指示 OpenSSL 允许 TLS v1.3 的非基于 [EC]DHE 的密钥交换模式 |
SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION |
允许 OpenSSL 与未打补丁的客户端或服务器之间进行传统的不安全重新协商。参见 https://www.openssl.org/docs/man3.0/man3/SSL_CTX_set_options.html。 |
SSL_OP_CIPHER_SERVER_PREFERENCE |
选择密码时尝试使用服务器的首选项而不是客户端的首选项。行为取决于协议版本。参见 https://www.openssl.org/docs/man3.0/man3/SSL_CTX_set_options.html。 |
SSL_OP_CISCO_ANYCONNECT |
指示 OpenSSL 使用 Cisco 的版本标识符 DTLS_BAD_VER。 |
SSL_OP_COOKIE_EXCHANGE |
指示 OpenSSL 打开 cookie 交换。 |
SSL_OP_CRYPTOPRO_TLSEXT_BUG |
指示 OpenSSL 从早期版本的 cryptopro 草案中添加 server-hello 扩展。 |
SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS |
指示 OpenSSL 禁用在 OpenSSL 0.9.6d 中添加的 SSL 3.0/TLS 1.0 漏洞解决方法。 |
SSL_OP_LEGACY_SERVER_CONNECT |
允许初始连接到不支持 RI 的服务器。 |
SSL_OP_NO_COMPRESSION |
指示 OpenSSL 禁用对 SSL/TLS 压缩的支持。 |
SSL_OP_NO_ENCRYPT_THEN_MAC |
指示 OpenSSL 禁用 encrypt-then-MAC。 |
SSL_OP_NO_QUERY_MTU |
|
SSL_OP_NO_RENEGOTIATION |
指示 OpenSSL 禁用重新协商。 |
SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION |
指示 OpenSSL 在执行重新协商时始终启动新会话。 |
SSL_OP_NO_SSLv2 |
指示 OpenSSL 关闭 SSL v2 |
SSL_OP_NO_SSLv3 |
指示 OpenSSL 关闭 SSL v3 |
SSL_OP_NO_TICKET |
指示 OpenSSL 禁用 RFC4507bis 票证的使用。 |
SSL_OP_NO_TLSv1 |
指示 OpenSSL 关闭 TLS v1 |
SSL_OP_NO_TLSv1_1 |
指示 OpenSSL 关闭 TLS v1.1 |
SSL_OP_NO_TLSv1_2 |
指示 OpenSSL 关闭 TLS v1.2 |
SSL_OP_NO_TLSv1_3 |
指示 OpenSSL 关闭 TLS v1.3 |
SSL_OP_PRIORITIZE_CHACHA |
当客户端这样做时,指示 OpenSSL 服务器优先考虑 ChaCha20-Poly1305。如果未启用
SSL_OP_CIPHER_SERVER_PREFERENCE ,则此选项无效。 |
SSL_OP_TLS_ROLLBACK_BUG |
指示 OpenSSL 禁用版本回滚攻击检测。 |
OpenSSL 引擎常量#
¥OpenSSL engine constants
常量 | 描述 |
---|---|
ENGINE_METHOD_RSA |
将引擎使用限制为 RSA |
ENGINE_METHOD_DSA |
将引擎使用限制为 DSA |
ENGINE_METHOD_DH |
将引擎使用限制为 DH |
ENGINE_METHOD_RAND |
将引擎使用限制为 RAND |
ENGINE_METHOD_EC |
将引擎使用限制为 EC |
ENGINE_METHOD_CIPHERS |
将引擎使用限制为 CIPHERS |
ENGINE_METHOD_DIGESTS |
将引擎使用限制为 DIGESTS |
ENGINE_METHOD_PKEY_METHS |
将引擎使用限制为 PKEY_METHDS |
ENGINE_METHOD_PKEY_ASN1_METHS |
将引擎使用限制为 PKEY_ASN1_METHS |
ENGINE_METHOD_ALL |
|
ENGINE_METHOD_NONE |
其他 OpenSSL 常量#
¥Other OpenSSL constants
常量 | 描述 |
---|---|
DH_CHECK_P_NOT_SAFE_PRIME |
|
DH_CHECK_P_NOT_PRIME |
|
DH_UNABLE_TO_CHECK_GENERATOR |
|
DH_NOT_SUITABLE_GENERATOR |
|
RSA_PKCS1_PADDING |
|
RSA_SSLV23_PADDING |
|
RSA_NO_PADDING |
|
RSA_PKCS1_OAEP_PADDING |
|
RSA_X931_PADDING |
|
RSA_PKCS1_PSS_PADDING |
|
RSA_PSS_SALTLEN_DIGEST |
签名或验证时将 RSA_PKCS1_PSS_PADDING 的盐长度设置为摘要大小。 |
RSA_PSS_SALTLEN_MAX_SIGN |
将 RSA_PKCS1_PSS_PADDING 的盐长度设置为签名数据时允许的最大值。 |
RSA_PSS_SALTLEN_AUTO |
导致验证签名时自动确定 RSA_PKCS1_PSS_PADDING 的盐长度。 |
POINT_CONVERSION_COMPRESSED |
|
POINT_CONVERSION_UNCOMPRESSED |
|
POINT_CONVERSION_HYBRID |
Node.js 加密常量#
¥Node.js crypto constants
常量 | 描述 |
---|---|
defaultCoreCipherList |
指定 Node.js 使用的内置默认密码列表。 |
defaultCipherList |
指定当前 Node.js 进程使用的活动默认密码列表。 |