Web Crypto API#

历史
版本变更
v24.8.0

现在支持 KMAC 算法。

v24.8.0

现在支持 Argon2 算法。

v24.7.0

现在支持 AES-OCB 算法。

v24.7.0

现在支持 ML-KEM 算法。

v24.7.0

现在支持 ChaCha20-Poly1305 算法。

v24.7.0

现在支持 SHA-3 算法。

v24.7.0

现在支持 SHAKE 算法。

v24.7.0

现在支持 ML-DSA 算法。

v23.5.0, v22.13.0, v20.19.3

Ed25519 和 X25519 算法现在是稳定的。

v19.0.0

除了 Ed25519、Ed448、X25519 和 X448 算法外，不再是实验性的。

v20.0.0, v18.17.0

参数现在会根据其 WebIDL 定义进行强制转换和验证，就像在其他 Web Crypto API 实现中一样。

v18.4.0, v16.17.0

移除了专有的 'node.keyObject' 导入/导出格式。

v18.4.0, v16.17.0

移除了专有的 'NODE-DSA'、'NODE-DH' 和 'NODE-SCRYPT' 算法。

v18.4.0, v16.17.0

添加了 'Ed25519'、'Ed448'、'X25519' 和 'X448' 算法。

v18.4.0, v16.17.0

移除了专有的 'NODE-ED25519' 和 'NODE-ED448' 算法。

v18.4.0, v16.17.0

从 'ECDH' 算法中移除了专有的 'NODE-X25519' 和 'NODE-X448' 命名曲线。

稳定性：2 - 稳定

Node.js 提供了 Web Crypto API 标准的实现。

使用 globalThis.crypto 或 require('node:crypto').webcrypto 来访问此模块。

const { subtle } = globalThis.crypto;

(async function() {

  const key = await subtle.generateKey({
    name: 'HMAC',
    hash: 'SHA-256',
    length: 256,
  }, true, ['sign', 'verify']);

  const enc = new TextEncoder();
  const message = enc.encode('I love cupcakes');

  const digest = await subtle.sign({
    name: 'HMAC',
  }, key, message);

})();

Web Cryptography API 中的现代算法#

稳定性：1.1 - 活跃开发

Node.js 提供了 Web Cryptography API 中的现代算法 WICG 提案中的以下功能的实现

算法

  • 'AES-OCB'1
  • 'Argon2d'2
  • 'Argon2i'2
  • 'Argon2id'2
  • 'ChaCha20-Poly1305'
  • 'cSHAKE128'
  • 'cSHAKE256'
  • 'KMAC128'1
  • 'KMAC256'1
  • 'ML-DSA-44'3
  • 'ML-DSA-65'3
  • 'ML-DSA-87'3
  • 'ML-KEM-512'3
  • 'ML-KEM-768'3
  • 'ML-KEM-1024'3
  • 'SHA3-256'
  • 'SHA3-384'
  • 'SHA3-512'

密钥格式

  • 'raw-public'
  • 'raw-secret'
  • 'raw-seed'

方法

Web Cryptography API 中的安全曲线#

稳定性：1.1 - 活跃开发

Node.js 提供了 Web Cryptography API 中的安全曲线 WICG 提案中的以下功能的实现

算法

  • 'Ed448'
  • 'X448'

示例#

生成密钥#

<SubtleCrypto> 类可用于生成对称（私密）密钥或非对称密钥对（公钥和私钥）。

AES 密钥#
const { subtle } = globalThis.crypto;

async function generateAesKey(length = 256) {
  const key = await subtle.generateKey({
    name: 'AES-CBC',
    length,
  }, true, ['encrypt', 'decrypt']);

  return key;
}
ECDSA 密钥对#
const { subtle } = globalThis.crypto;

async function generateEcKey(namedCurve = 'P-521') {
  const {
    publicKey,
    privateKey,
  } = await subtle.generateKey({
    name: 'ECDSA',
    namedCurve,
  }, true, ['sign', 'verify']);

  return { publicKey, privateKey };
}
Ed25519/X25519 密钥对#
const { subtle } = globalThis.crypto;

async function generateEd25519Key() {
  return subtle.generateKey({
    name: 'Ed25519',
  }, true, ['sign', 'verify']);
}

async function generateX25519Key() {
  return subtle.generateKey({
    name: 'X25519',
  }, true, ['deriveKey']);
}
HMAC 密钥#
const { subtle } = globalThis.crypto;

async function generateHmacKey(hash = 'SHA-256') {
  const key = await subtle.generateKey({
    name: 'HMAC',
    hash,
  }, true, ['sign', 'verify']);

  return key;
}
RSA 密钥对#
const { subtle } = globalThis.crypto;
const publicExponent = new Uint8Array([1, 0, 1]);

async function generateRsaKey(modulusLength = 2048, hash = 'SHA-256') {
  const {
    publicKey,
    privateKey,
  } = await subtle.generateKey({
    name: 'RSASSA-PKCS1-v1_5',
    modulusLength,
    publicExponent,
    hash,
  }, true, ['sign', 'verify']);

  return { publicKey, privateKey };
}

加密和解密#

const crypto = globalThis.crypto;

async function aesEncrypt(plaintext) {
  const ec = new TextEncoder();
  const key = await generateAesKey();
  const iv = crypto.getRandomValues(new Uint8Array(16));

  const ciphertext = await crypto.subtle.encrypt({
    name: 'AES-CBC',
    iv,
  }, key, ec.encode(plaintext));

  return {
    key,
    iv,
    ciphertext,
  };
}

async function aesDecrypt(ciphertext, key, iv) {
  const dec = new TextDecoder();
  const plaintext = await crypto.subtle.decrypt({
    name: 'AES-CBC',
    iv,
  }, key, ciphertext);

  return dec.decode(plaintext);
}

导出和导入密钥#

const { subtle } = globalThis.crypto;

async function generateAndExportHmacKey(format = 'jwk', hash = 'SHA-512') {
  const key = await subtle.generateKey({
    name: 'HMAC',
    hash,
  }, true, ['sign', 'verify']);

  return subtle.exportKey(format, key);
}

async function importHmacKey(keyData, format = 'jwk', hash = 'SHA-512') {
  const key = await subtle.importKey(format, keyData, {
    name: 'HMAC',
    hash,
  }, true, ['sign', 'verify']);

  return key;
}

包装和解包密钥#

const { subtle } = globalThis.crypto;

async function generateAndWrapHmacKey(format = 'jwk', hash = 'SHA-512') {
  const [
    key,
    wrappingKey,
  ] = await Promise.all([
    subtle.generateKey({
      name: 'HMAC', hash,
    }, true, ['sign', 'verify']),
    subtle.generateKey({
      name: 'AES-KW',
      length: 256,
    }, true, ['wrapKey', 'unwrapKey']),
  ]);

  const wrappedKey = await subtle.wrapKey(format, key, wrappingKey, 'AES-KW');

  return { wrappedKey, wrappingKey };
}

async function unwrapHmacKey(
  wrappedKey,
  wrappingKey,
  format = 'jwk',
  hash = 'SHA-512') {

  const key = await subtle.unwrapKey(
    format,
    wrappedKey,
    wrappingKey,
    'AES-KW',
    { name: 'HMAC', hash },
    true,
    ['sign', 'verify']);

  return key;
}

签名和验证#

const { subtle } = globalThis.crypto;

async function sign(key, data) {
  const ec = new TextEncoder();
  const signature =
    await subtle.sign('RSASSA-PKCS1-v1_5', key, ec.encode(data));
  return signature;
}

async function verify(key, signature, data) {
  const ec = new TextEncoder();
  const verified =
    await subtle.verify(
      'RSASSA-PKCS1-v1_5',
      key,
      signature,
      ec.encode(data));
  return verified;
}

派生比特和密钥#

const { subtle } = globalThis.crypto;

async function pbkdf2(pass, salt, iterations = 1000, length = 256) {
  const ec = new TextEncoder();
  const key = await subtle.importKey(
    'raw',
    ec.encode(pass),
    'PBKDF2',
    false,
    ['deriveBits']);
  const bits = await subtle.deriveBits({
    name: 'PBKDF2',
    hash: 'SHA-512',
    salt: ec.encode(salt),
    iterations,
  }, key, length);
  return bits;
}

async function pbkdf2Key(pass, salt, iterations = 1000, length = 256) {
  const ec = new TextEncoder();
  const keyMaterial = await subtle.importKey(
    'raw',
    ec.encode(pass),
    'PBKDF2',
    false,
    ['deriveKey']);
  const key = await subtle.deriveKey({
    name: 'PBKDF2',
    hash: 'SHA-512',
    salt: ec.encode(salt),
    iterations,
  }, keyMaterial, {
    name: 'AES-GCM',
    length,
  }, true, ['encrypt', 'decrypt']);
  return key;
}

摘要#

const { subtle } = globalThis.crypto;

async function digest(data, algorithm = 'SHA-512') {
  const ec = new TextEncoder();
  const digest = await subtle.digest(algorithm, ec.encode(data));
  return digest;
}

检查运行时算法支持#

SubtleCrypto.supports() 允许在 Web Crypto API 中进行特性检测，可用于检测给定的算法标识符（包括其参数）是否支持给定的操作。

此示例演示了如果可用，则使用 Argon2 从密码派生密钥，否则使用 PBKDF2；然后如果可用，则使用 AES-OCB 加密和解密一些文本，否则使用 AES-GCM。

const { SubtleCrypto, crypto } = globalThis;

const password = 'correct horse battery staple';
const derivationAlg =
  SubtleCrypto.supports?.('importKey', 'Argon2id') ?
    'Argon2id' :
    'PBKDF2';
const encryptionAlg =
  SubtleCrypto.supports?.('importKey', 'AES-OCB') ?
    'AES-OCB' :
    'AES-GCM';
const passwordKey = await crypto.subtle.importKey(
  derivationAlg === 'Argon2id' ? 'raw-secret' : 'raw',
  new TextEncoder().encode(password),
  derivationAlg,
  false,
  ['deriveKey'],
);
const nonce = crypto.getRandomValues(new Uint8Array(16));
const derivationParams =
  derivationAlg === 'Argon2id' ?
    {
      nonce,
      parallelism: 4,
      memory: 2 ** 21,
      passes: 1,
    } :
    {
      salt: nonce,
      iterations: 100_000,
      hash: 'SHA-256',
    };
const key = await crypto.subtle.deriveKey(
  {
    name: derivationAlg,
    ...derivationParams,
  },
  passwordKey,
  {
    name: encryptionAlg,
    length: 256,
  },
  false,
  ['encrypt', 'decrypt'],
);
const plaintext = 'Hello, world!';
const iv = crypto.getRandomValues(new Uint8Array(16));
const encrypted = await crypto.subtle.encrypt(
  { name: encryptionAlg, iv },
  key,
  new TextEncoder().encode(plaintext),
);
const decrypted = new TextDecoder().decode(await crypto.subtle.decrypt(
  { name: encryptionAlg, iv },
  key,
  encrypted,
));

算法矩阵#

下表详细说明了 Node.js Web Crypto API 实现支持的算法以及每个算法支持的 API。

密钥管理 API#

算法subtle.generateKey()subtle.exportKey()subtle.importKey()subtle.getPublicKey()
'AES-CBC'✔✔✔
'AES-CTR'✔✔✔
'AES-GCM'✔✔✔
'AES-KW'✔✔✔
'AES-OCB'✔✔✔
'Argon2d'✔
'Argon2i'✔
'Argon2id'✔
'ChaCha20-Poly1305'4✔✔✔
'ECDH'✔✔✔✔
'ECDSA'✔✔✔✔
'Ed25519'✔✔✔✔
'Ed448'5✔✔✔✔
'HKDF'✔
'HMAC'✔✔✔
'KMAC128'4✔✔✔
'KMAC256'4✔✔✔
'ML-DSA-44'4✔✔✔✔
'ML-DSA-65'4✔✔✔✔
'ML-DSA-87'4✔✔✔✔
'ML-KEM-512'4✔✔✔✔
'ML-KEM-768'4✔✔✔✔
'ML-KEM-1024'4✔✔✔✔
'PBKDF2'✔
'RSA-OAEP'✔✔✔✔
'RSA-PSS'✔✔✔✔
'RSASSA-PKCS1-v1_5'✔✔✔✔
'X25519'✔✔✔✔
'X448'5✔✔✔✔

加密操作 API#

列图例

算法加密签名和 MAC密钥或比特派生密钥包装密钥封装摘要
'AES-CBC'✔✔
'AES-CTR'✔✔
'AES-GCM'✔✔
'AES-KW'✔
'AES-OCB'✔✔
'Argon2d'✔
'Argon2i'✔
'Argon2id'✔
'ChaCha20-Poly1305'4✔✔
'cSHAKE128'4✔
'cSHAKE256'4✔
'ECDH'✔
'ECDSA'✔
'Ed25519'✔
'Ed448'5✔
'HKDF'✔
'HMAC'✔
'KMAC128'4✔
'KMAC256'4✔
'ML-DSA-44'4✔
'ML-DSA-65'4✔
'ML-DSA-87'4✔
'ML-KEM-512'4✔
'ML-KEM-768'4✔
'ML-KEM-1024'4✔
'PBKDF2'✔
'RSA-OAEP'✔✔
'RSA-PSS'✔
'RSASSA-PKCS1-v1_5'✔
'SHA-1'✔
'SHA-256'✔
'SHA-384'✔
'SHA-512'✔
'SHA3-256'4✔
'SHA3-384'4✔
'SHA3-512'4✔
'X25519'✔
'X448'5✔

类：Crypto#

新增于：v15.0.0

globalThis.crypto 是 Crypto 类的实例。Crypto 是一个单例，提供对加密 API 其余部分的访问。

crypto.subtle#

新增于：v15.0.0

提供对 SubtleCrypto API 的访问。

crypto.getRandomValues(typedArray)#

新增于：v15.0.0

生成加密强度高的随机值。给定的 typedArray 会被随机值填充，并返回对 typedArray 的引用。

给定的 typedArray 必须是基于整数的 <TypedArray> 实例，即不接受 Float32Array 和 Float64Array。

如果给定的 typedArray 大于 65,536 字节，将会抛出错误。

crypto.randomUUID()#

添加于：v16.7.0

生成一个随机的 RFC 4122 版本 4 UUID。该 UUID 使用加密伪随机数生成器生成。

类：CryptoKey#

新增于：v15.0.0

cryptoKey.algorithm#

新增于：v15.0.0

一个对象，详细说明了该密钥可用于的算法以及其他特定于算法的参数。

只读。

cryptoKey.extractable#

新增于：v15.0.0

当为 true 时，<CryptoKey> 可以使用 subtle.exportKey() 或 subtle.wrapKey() 提取。

只读。

cryptoKey.type#

新增于：v15.0.0
  • 类型：<string> 'secret'、'private' 或 'public' 之一。

一个字符串，标识该密钥是 symmetric ('secret') 还是 asymmetric ('private' 或 'public') 密钥。

cryptoKey.usages#

新增于：v15.0.0

一个字符串数组，标识了密钥可用于的操作。

可能的用法有

有效的密钥用法取决于密钥算法（由 cryptokey.algorithm.name 标识）。

列图例

支持的密钥算法加密签名和 MAC密钥或比特派生密钥包装密钥封装
'AES-CBC'✔✔
'AES-CTR'✔✔
'AES-GCM'✔✔
'AES-KW'✔
'AES-OCB'✔✔
'Argon2d'✔
'Argon2i'✔
'Argon2id'✔
'ChaCha20-Poly1305'4✔✔
'ECDH'✔
'ECDSA'✔
'Ed25519'✔
'Ed448'5✔
'HDKF'✔
'HMAC'✔
'KMAC128'4✔
'KMAC256'4✔
'ML-DSA-44'4✔
'ML-DSA-65'4✔
'ML-DSA-87'4✔
'ML-KEM-512'4✔
'ML-KEM-768'4✔
'ML-KEM-1024'4✔
'PBKDF2'✔
'RSA-OAEP'✔✔
'RSA-PSS'✔
'RSASSA-PKCS1-v1_5'✔
'X25519'✔
'X448'5✔

类：CryptoKeyPair#

新增于：v15.0.0

CryptoKeyPair 是一个简单的字典对象，具有 publicKey 和 privateKey 属性，代表一个非对称密钥对。

cryptoKeyPair.privateKey#

新增于：v15.0.0

cryptoKeyPair.publicKey#

新增于：v15.0.0

类：SubtleCrypto#

新增于：v15.0.0

静态方法：SubtleCrypto.supports(operation, algorithm[, lengthOrAdditionalAlgorithm])#

始于：v24.7.0

稳定性：1.1 - 活跃开发

  • operation <string> "encrypt"、"decrypt"、"sign"、"verify"、"digest"、"generateKey"、"deriveKey"、"deriveBits"、"importKey"、"exportKey"、"getPublicKey"、"wrapKey"、"unwrapKey"、"encapsulateBits"、"encapsulateKey"、"decapsulateBits" 或 "decapsulateKey"
  • algorithm <string> | <Algorithm>
  • lengthOrAdditionalAlgorithm <null> | <number> | <string> | <Algorithm> | <undefined> 根据操作的不同，此参数可能被忽略，或者当操作为 "deriveBits" 时是 length 参数的值，当操作为 "deriveKey" 时是待派生密钥的算法，当操作为 "wrapKey" 时是包装前待导出密钥的算法，当操作为 "unwrapKey" 时是解包后待导入密钥的算法，或者当操作为 "encapsulateKey" 或 "decapsulateKey" 时是密钥封装/解封装后待导入密钥的算法。默认值：当操作为 "deriveBits" 时为 null，否则为 undefined。
  • 返回：<boolean> 指示实现是否支持给定的操作

允许在 Web Crypto API 中进行特性检测，可用于检测给定的算法标识符（包括其参数）是否支持给定的操作。

有关此方法的示例用法，请参阅检查运行时算法支持。

subtle.decapsulateBits(decapsulationAlgorithm, decapsulationKey, ciphertext)#

始于：v24.7.0

稳定性：1.1 - 活跃开发

消息接收者使用其非对称私钥解密一个“封装的密钥”（密文），从而恢复一个临时的对称密钥（表示为 <ArrayBuffer>），然后用该密钥解密消息。

当前支持的算法包括

  • 'ML-KEM-512'4
  • 'ML-KEM-768'4
  • 'ML-KEM-1024'4

subtle.decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, usages)#

始于：v24.7.0

稳定性：1.1 - 活跃开发

消息接收者使用其非对称私钥解密一个“封装的密钥”（密文），从而恢复一个临时的对称密钥（表示为 <CryptoKey>），然后用该密钥解密消息。

当前支持的算法包括

  • 'ML-KEM-512'4
  • 'ML-KEM-768'4
  • 'ML-KEM-1024'4

subtle.decrypt(algorithm, key, data)#

历史
版本变更
v24.7.0

现在支持 AES-OCB 算法。

v24.7.0

现在支持 ChaCha20-Poly1305 算法。

v15.0.0

新增于：v15.0.0

使用 algorithm 中指定的方法和参数以及 key 提供的密钥材料，此方法尝试解密提供的 data。如果成功，返回的 promise 将以包含明文结果的 <ArrayBuffer> 来解决。

当前支持的算法包括

  • 'AES-CBC'
  • 'AES-CTR'
  • 'AES-GCM'
  • 'AES-OCB'4
  • 'ChaCha20-Poly1305'4
  • 'RSA-OAEP'

subtle.deriveBits(algorithm, baseKey[, length])#

历史
版本变更
v24.8.0

现在支持 Argon2 算法。

v22.5.0, v20.17.0, v18.20.5

对于 'ECDH'、'X25519' 和 'X448'，length 参数现在是可选的。

v18.4.0, v16.17.0

添加了 'X25519' 和 'X448' 算法。

v15.0.0

新增于：v15.0.0

使用 algorithm 中指定的方法和参数以及 baseKey 提供的密钥材料，此方法尝试生成 length 个比特。

当未提供 length 或为 null 时，将生成给定算法的最大比特数。这对于 'ECDH'、'X25519' 和 'X448'5 算法是允许的，对于其他算法，length 必须是数字。

如果成功，返回的 promise 将以包含生成数据的 <ArrayBuffer> 来解决。

当前支持的算法包括

  • 'Argon2d'4
  • 'Argon2i'4
  • 'Argon2id'4
  • 'ECDH'
  • 'HKDF'
  • 'PBKDF2'
  • 'X25519'
  • 'X448'5

subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)#

历史
版本变更
v24.8.0

现在支持 Argon2 算法。

v18.4.0, v16.17.0

添加了 'X25519' 和 'X448' 算法。

v15.0.0

新增于：v15.0.0

使用 algorithm 中指定的方法和参数，以及 baseKey 提供的密钥材料，此方法尝试根据 derivedKeyAlgorithm 中的方法和参数生成一个新的 <CryptoKey>。

调用此方法等同于调用 subtle.deriveBits() 来生成原始密钥材料，然后将结果传递给 subtle.importKey() 方法，并使用 deriveKeyAlgorithm、extractable 和 keyUsages 参数作为输入。

当前支持的算法包括

  • 'Argon2d'4
  • 'Argon2i'4
  • 'Argon2id'4
  • 'ECDH'
  • 'HKDF'
  • 'PBKDF2'
  • 'X25519'
  • 'X448'5

subtle.digest(algorithm, data)#

历史
版本变更
v24.7.0

现在支持 SHA-3 算法。

v24.7.0

现在支持 SHAKE 算法。

v15.0.0

新增于：v15.0.0

使用 algorithm 标识的方法，此方法尝试生成 data 的摘要。如果成功，返回的 promise 将以包含计算出的摘要的 <ArrayBuffer> 来解决。

如果 algorithm 以 <string> 形式提供，它必须是以下之一

  • 'cSHAKE128'4
  • 'cSHAKE256'4
  • 'SHA-1'
  • 'SHA-256'
  • 'SHA-384'
  • 'SHA-512'
  • 'SHA3-256'4
  • 'SHA3-384'4
  • 'SHA3-512'4

如果 algorithm 以 <Object> 形式提供，它必须有一个 name 属性，其值是上述之一。

subtle.encapsulateBits(encapsulationAlgorithm, encapsulationKey)#

始于：v24.7.0

稳定性：1.1 - 活跃开发

使用消息接收者的非对称公钥加密一个临时的对称密钥。这个加密后的密钥就是“封装的密钥”，表示为 <EncapsulatedBits>。

当前支持的算法包括

  • 'ML-KEM-512'4
  • 'ML-KEM-768'4
  • 'ML-KEM-1024'4

subtle.encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, usages)#

始于：v24.7.0

稳定性：1.1 - 活跃开发

使用消息接收者的非对称公钥加密一个临时的对称密钥。这个加密后的密钥就是“封装的密钥”，表示为 <EncapsulatedKey>。

当前支持的算法包括

  • 'ML-KEM-512'4
  • 'ML-KEM-768'4
  • 'ML-KEM-1024'4

subtle.encrypt(algorithm, key, data)#

历史
版本变更
v24.7.0

现在支持 AES-OCB 算法。

v24.7.0

现在支持 ChaCha20-Poly1305 算法。

v15.0.0

新增于：v15.0.0

使用 algorithm 指定的方法和参数以及 key 提供的密钥材料，此方法尝试加密 data。如果成功，返回的 promise 将以包含加密结果的 <ArrayBuffer> 来解决。

当前支持的算法包括

  • 'AES-CBC'
  • 'AES-CTR'
  • 'AES-GCM'
  • 'AES-OCB'4
  • 'ChaCha20-Poly1305'4
  • 'RSA-OAEP'

subtle.exportKey(format, key)#

历史
版本变更
v24.8.0

现在支持 KMAC 算法。

v24.7.0

现在支持 ML-KEM 算法。

v24.7.0

现在支持 ChaCha20-Poly1305 算法。

v24.7.0

现在支持 ML-DSA 算法。

v18.4.0, v16.17.0

添加了 'Ed25519'、'Ed448'、'X25519' 和 'X448' 算法。

v15.9.0

移除了 'NODE-DSA' JWK 导出。

v15.0.0

新增于：v15.0.0

将给定的密钥导出为指定的格式（如果支持）。

如果 <CryptoKey> 不可提取，返回的 promise 将会拒绝。

当 format 是 'pkcs8' 或 'spki' 且导出成功时，返回的 promise 将以包含导出密钥数据的 <ArrayBuffer> 来解决。

当 format 是 'jwk' 且导出成功时，返回的 promise 将以一个符合 JSON Web Key 规范的 JavaScript 对象来解决。

支持的密钥算法'spki''pkcs8''jwk''raw''raw-secret''raw-public''raw-seed'
'AES-CBC'✔✔✔
'AES-CTR'✔✔✔
'AES-GCM'✔✔✔
'AES-KW'✔✔✔
'AES-OCB'4✔✔
'ChaCha20-Poly1305'4✔✔
'ECDH'✔✔✔✔✔
'ECDSA'✔✔✔✔✔
'Ed25519'✔✔✔✔✔
'Ed448'5✔✔✔✔✔
'HMAC'✔✔✔
'KMAC128'4✔✔
'KMAC256'4✔✔
'ML-DSA-44'4✔✔✔✔✔
'ML-DSA-65'4✔✔✔✔✔
'ML-DSA-87'4✔✔✔✔✔
'ML-KEM-512'4✔✔✔✔
'ML-KEM-768'4✔✔✔✔
'ML-KEM-1024'4✔✔✔✔
'RSA-OAEP'✔✔✔
'RSA-PSS'✔✔✔
'RSASSA-PKCS1-v1_5'✔✔✔

subtle.getPublicKey(key, keyUsages)#

始于：v24.7.0

稳定性：1.1 - 活跃开发

从给定的私钥派生公钥。

subtle.generateKey(algorithm, extractable, keyUsages)#

历史
版本变更
v24.8.0

现在支持 KMAC 算法。

v24.7.0

现在支持 ML-KEM 算法。

v24.7.0

现在支持 ChaCha20-Poly1305 算法。

v24.7.0

现在支持 ML-DSA 算法。

v15.0.0

新增于：v15.0.0

使用 algorithm 中提供的参数，此方法尝试生成新的密钥材料。根据所用算法的不同，会生成一个 <CryptoKey> 或一个 <CryptoKeyPair>。

支持的生成 <CryptoKeyPair>（公钥和私钥）的算法包括

  • 'ECDH'
  • 'ECDSA'
  • 'Ed25519'
  • 'Ed448'5
  • 'ML-DSA-44'4
  • 'ML-DSA-65'4
  • 'ML-DSA-87'4
  • 'ML-KEM-512'4
  • 'ML-KEM-768'4
  • 'ML-KEM-1024'4
  • 'RSA-OAEP'
  • 'RSA-PSS'
  • 'RSASSA-PKCS1-v1_5'
  • 'X25519'
  • 'X448'5

支持的生成 <CryptoKey>（私密密钥）的算法包括

  • 'AES-CBC'
  • 'AES-CTR'
  • 'AES-GCM'
  • 'AES-KW'
  • 'AES-OCB'4
  • 'ChaCha20-Poly1305'4
  • 'HMAC'
  • 'KMAC128'4
  • 'KMAC256'4

subtle.importKey(format, keyData, algorithm, extractable, keyUsages)#

历史
版本变更
v24.8.0

现在支持 KMAC 算法。

v24.7.0

现在支持 ML-KEM 算法。

v24.7.0

现在支持 ChaCha20-Poly1305 算法。

v24.7.0

现在支持 ML-DSA 算法。

v18.4.0, v16.17.0

添加了 'Ed25519'、'Ed448'、'X25519' 和 'X448' 算法。

v15.9.0

移除了 'NODE-DSA' JWK 导入。

v15.0.0

新增于：v15.0.0

此方法尝试将提供的 keyData 解释为给定的 format，以使用提供的 algorithm、extractable 和 keyUsages 参数创建一个 <CryptoKey> 实例。如果导入成功，返回的 promise 将以密钥材料的 <CryptoKey> 表示来解决。

如果导入 KDF 算法密钥，extractable 必须为 false。

当前支持的算法包括

支持的密钥算法'spki''pkcs8''jwk''raw''raw-secret''raw-public''raw-seed'
'AES-CBC'✔✔✔
'AES-CTR'✔✔✔
'AES-GCM'✔✔✔
'AES-KW'✔✔✔
'AES-OCB'4✔✔
'Argon2d'4✔
'Argon2i'4✔
'Argon2id'4✔
'ChaCha20-Poly1305'4✔✔
'ECDH'✔✔✔✔✔
'ECDSA'✔✔✔✔✔
'Ed25519'✔✔✔✔✔
'Ed448'5✔✔✔✔✔
'HDKF'✔✔
'HMAC'✔✔✔
'KMAC128'4✔✔
'KMAC256'4✔✔
'ML-DSA-44'4✔✔✔✔✔
'ML-DSA-65'4✔✔✔✔✔
'ML-DSA-87'4✔✔✔✔✔
'ML-KEM-512'4✔✔✔✔
'ML-KEM-768'4✔✔✔✔
'ML-KEM-1024'4✔✔✔✔
'PBKDF2'✔✔
'RSA-OAEP'✔✔✔
'RSA-PSS'✔✔✔
'RSASSA-PKCS1-v1_5'✔✔✔
'X25519'✔✔✔✔✔
'X448'5✔✔✔✔✔

subtle.sign(algorithm, key, data)#

历史
版本变更
v24.8.0

现在支持 KMAC 算法。

v24.7.0

现在支持 ML-DSA 算法。

v18.4.0, v16.17.0

添加了 'Ed25519' 和 'Ed448' 算法。

v15.0.0

新增于：v15.0.0

使用 algorithm 给定的方法和参数以及 key 提供的密钥材料，此方法尝试生成 data 的加密签名。如果成功，返回的 promise 将以包含生成签名的 <ArrayBuffer> 来解决。

当前支持的算法包括

  • 'ECDSA'
  • 'Ed25519'
  • 'Ed448'5
  • 'HMAC'
  • 'KMAC128'4
  • 'KMAC256'4
  • 'ML-DSA-44'4
  • 'ML-DSA-65'4
  • 'ML-DSA-87'4
  • 'RSA-PSS'
  • 'RSASSA-PKCS1-v1_5'

subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgo, unwrappedKeyAlgo, extractable, keyUsages)#

历史
版本变更
v24.7.0

现在支持 AES-OCB 算法。

v24.7.0

现在支持 ChaCha20-Poly1305 算法。

v15.0.0

新增于：v15.0.0

在密码学中，“包装密钥”是指导出然后加密密钥材料。此方法尝试解密一个包装的密钥并创建一个 <CryptoKey> 实例。它等同于首先对加密的密钥数据调用 subtle.decrypt()（使用 wrappedKey、unwrapAlgo 和 unwrappingKey 参数作为输入），然后将结果传递给 subtle.importKey() 方法，并使用 unwrappedKeyAlgo、extractable 和 keyUsages 参数作为输入。如果成功，返回的 promise 将以一个 <CryptoKey> 对象来解决。

当前支持的包装算法包括

  • 'AES-CBC'
  • 'AES-CTR'
  • 'AES-GCM'
  • 'AES-KW'
  • 'AES-OCB'4
  • 'ChaCha20-Poly1305'4
  • 'RSA-OAEP'

支持的解包密钥算法包括

  • 'AES-CBC'
  • 'AES-CTR'
  • 'AES-GCM'
  • 'AES-KW'
  • 'AES-OCB'4
  • 'ChaCha20-Poly1305'4
  • 'ECDH'
  • 'ECDSA'
  • 'Ed25519'
  • 'Ed448'5
  • 'HMAC'
  • 'KMAC128'5
  • 'KMAC256'5
  • 'ML-DSA-44'4
  • 'ML-DSA-65'4
  • 'ML-DSA-87'4
  • 'ML-KEM-512'4
  • 'ML-KEM-768'4
  • 'ML-KEM-1024'4v
  • 'RSA-OAEP'
  • 'RSA-PSS'
  • 'RSASSA-PKCS1-v1_5'
  • 'X25519'
  • 'X448'5

subtle.verify(algorithm, key, signature, data)#

历史
版本变更
v24.8.0

现在支持 KMAC 算法。

v24.7.0

现在支持 ML-DSA 算法。

v18.4.0, v16.17.0

添加了 'Ed25519' 和 'Ed448' 算法。

v15.0.0

新增于：v15.0.0

该方法使用 algorithm 中给定的方法和参数以及 key 提供的密钥材料，尝试验证 signature 是否是 data 的有效加密签名。返回的 Promise 将解析为 true 或 false。

当前支持的算法包括

  • 'ECDSA'
  • 'Ed25519'
  • 'Ed448'5
  • 'HMAC'
  • 'KMAC128'5
  • 'KMAC256'5
  • 'ML-DSA-44'4
  • 'ML-DSA-65'4
  • 'ML-DSA-87'4
  • 'RSA-PSS'
  • 'RSASSA-PKCS1-v1_5'

subtle.wrapKey(format, key, wrappingKey, wrapAlgo)#

历史
版本变更
v24.7.0

现在支持 AES-OCB 算法。

v24.7.0

现在支持 ChaCha20-Poly1305 算法。

v15.0.0

新增于：v15.0.0

在密码学中，“包装密钥”指的是导出密钥材料然后对其进行加密。此方法将密钥材料导出为 format 标识的格式，然后使用 wrapAlgo 指定的方法和参数以及 wrappingKey 提供的密钥材料对其进行加密。这相当于使用 format 和 key 作为参数调用 subtle.exportKey()，然后将结果传递给 subtle.encrypt() 方法，并使用 wrappingKey 和 wrapAlgo 作为输入。如果成功，返回的 Promise 将解析为一个包含加密密钥数据的 <ArrayBuffer>。

当前支持的包装算法包括

  • 'AES-CBC'
  • 'AES-CTR'
  • 'AES-GCM'
  • 'AES-KW'
  • 'AES-OCB'4
  • 'ChaCha20-Poly1305'4
  • 'RSA-OAEP'

算法参数#

算法参数对象定义了各种 <SubtleCrypto> 方法所使用的方法和参数。虽然这里描述为“类”，但它们是简单的 JavaScript 字典对象。

类：Algorithm#

新增于：v15.0.0
Algorithm.name#
新增于：v15.0.0

类：AeadParams#

新增于：v15.0.0
aeadParams.additionalData#
新增于：v15.0.0

未加密但包含在数据认证中的额外输入。additionalData 的使用是可选的。

aeadParams.iv#
新增于：v15.0.0

对于使用给定密钥的每次加密操作，初始化向量必须是唯一的。

aeadParams.name#
新增于：v15.0.0
  • 类型：<string> 必须是 'AES-GCM'、'AES-OCB' 或 'ChaCha20-Poly1305'。
aeadParams.tagLength#
新增于：v15.0.0
  • 类型：<number> 生成的认证标签的大小（以比特为单位）。

类：AesDerivedKeyParams#

新增于：v15.0.0
aesDerivedKeyParams.name#
新增于：v15.0.0
  • 类型：<string> 必须是 'AES-CBC'、'AES-CTR'、'AES-GCM'、'AES-OCB' 或 'AES-KW' 之一
aesDerivedKeyParams.length#
新增于：v15.0.0

要派生的 AES 密钥的长度。该值必须是 128、192 或 256。

类：AesCbcParams#

新增于：v15.0.0
aesCbcParams.iv#
新增于：v15.0.0

提供初始化向量。其长度必须正好为 16 字节，并且应该是不可预测且加密安全的随机值。

aesCbcParams.name#
新增于：v15.0.0
  • 类型：<string> 必须是 'AES-CBC'。

类：AesCtrParams#

新增于：v15.0.0
aesCtrParams.counter#
新增于：v15.0.0

计数器块的初始值。该值必须正好为 16 字节长。

AES-CTR 方法使用块的最右侧 length 位作为计数器，其余位作为 nonce。

aesCtrParams.length#
新增于：v15.0.0
  • 类型：<number> aesCtrParams.counter 中用作计数器的比特数。
aesCtrParams.name#
新增于：v15.0.0
  • 类型：<string> 必须是 'AES-CTR'。

类：AesKeyAlgorithm#

新增于：v15.0.0
aesKeyAlgorithm.length#
新增于：v15.0.0

AES 密钥的长度（以比特为单位）。

aesKeyAlgorithm.name#
新增于：v15.0.0

类：AesKeyGenParams#

新增于：v15.0.0
aesKeyGenParams.length#
新增于：v15.0.0

要生成的 AES 密钥的长度。该值必须是 128、192 或 256。

aesKeyGenParams.name#
新增于：v15.0.0
  • 类型：<string> 必须是 'AES-CBC'、'AES-CTR'、'AES-GCM' 或 'AES-KW' 之一

类：Argon2Params#

于 v24.8.0 版本中添加
argon2Params.associatedData#
于 v24.8.0 版本中添加

表示可选的关联数据。

argon2Params.memory#
于 v24.8.0 版本中添加

表示内存大小（单位为千字节）。它必须至少是并行度的 8 倍。

argon2Params.name#
于 v24.8.0 版本中添加
  • 类型：<string> 必须是 'Argon2d'、'Argon2i' 或 'Argon2id' 之一。
argon2Params.nonce#
于 v24.8.0 版本中添加

表示 nonce，它是用于密码哈希应用的盐值。

argon2Params.parallelism#
于 v24.8.0 版本中添加

表示并行度。

argon2Params.passes#
于 v24.8.0 版本中添加

表示遍数。

argon2Params.secretValue#
于 v24.8.0 版本中添加

表示可选的秘密值。

argon2Params.version#
于 v24.8.0 版本中添加

表示 Argon2 的版本号。默认且当前唯一定义的版本是 19 (0x13)。

类：ContextParams#

始于：v24.7.0
contextParams.name#
始于：v24.7.0
  • 类型：<string> 必须是 Ed4485、'ML-DSA-44'4、'ML-DSA-65'4 或 'ML-DSA-87'4。
contextParams.context#
历史
版本变更
v24.8.0

现在支持非空上下文。

v24.7.0

始于：v24.7.0

context 成员表示要与消息关联的可选上下文数据。

类：CShakeParams#

始于：v24.7.0
cShakeParams.customization#
始于：v24.7.0

customization 成员表示定制化字符串。Node.js Web Crypto API 实现仅支持零长度的定制化，这等同于完全不提供定制化。

cShakeParams.functionName#
始于：v24.7.0

functionName 成员表示函数名，NIST 使用它来定义基于 cSHAKE 的函数。Node.js Web Crypto API 实现仅支持零长度的 functionName，这等同于完全不提供 functionName。

cShakeParams.length#
始于：v24.7.0
  • 类型：<number> 表示请求的输出长度（以比特为单位）。
cShakeParams.name#
始于：v24.7.0
  • 类型：<string> 必须是 'cSHAKE128'4 或 'cSHAKE256'4

类：EcdhKeyDeriveParams#

新增于：v15.0.0
ecdhKeyDeriveParams.name#
新增于：v15.0.0
  • 类型：<string> 必须是 'ECDH'、'X25519' 或 'X448'5。
ecdhKeyDeriveParams.public#
新增于：v15.0.0

ECDH 密钥派生的操作方式是，将一方的私钥和另一方的公钥作为输入——使用两者生成一个共同的共享密钥。ecdhKeyDeriveParams.public 属性被设置为另一方的公钥。

类：EcdsaParams#

新增于：v15.0.0
ecdsaParams.hash#
历史
版本变更
v24.7.0

现在支持 SHA-3 算法。

v15.0.0

新增于：v15.0.0

如果表示为 <string>，该值必须是以下之一：

  • 'SHA-1'
  • 'SHA-256'
  • 'SHA-384'
  • 'SHA-512'
  • 'SHA3-256'4
  • 'SHA3-384'4
  • 'SHA3-512'4

如果表示为 <Algorithm>，对象的 name 属性必须是上面列出的值之一。

ecdsaParams.name#
新增于：v15.0.0
  • 类型：<string> 必须是 'ECDSA'。

类：EcKeyAlgorithm#

新增于：v15.0.0
ecKeyAlgorithm.name#
新增于：v15.0.0
ecKeyAlgorithm.namedCurve#
新增于：v15.0.0

类：EcKeyGenParams#

新增于：v15.0.0
ecKeyGenParams.name#
新增于：v15.0.0
  • 类型：<string> 必须是 'ECDSA' 或 'ECDH' 之一。
ecKeyGenParams.namedCurve#
新增于：v15.0.0
  • 类型：<string> 必须是 'P-256'、'P-384' 或 'P-521' 之一。

类：EcKeyImportParams#

新增于：v15.0.0
ecKeyImportParams.name#
新增于：v15.0.0
  • 类型：<string> 必须是 'ECDSA' 或 'ECDH' 之一。
ecKeyImportParams.namedCurve#
新增于：v15.0.0
  • 类型：<string> 必须是 'P-256'、'P-384' 或 'P-521' 之一。

类：EncapsulatedBits#

始于：v24.7.0

一个用于消息加密的临时对称密钥（表示为 <ArrayBuffer>）和由该共享密钥加密的密文（可与消息一起传输给消息接收者）。接收者使用其私钥来确定共享密钥是什么，然后可以解密消息。

encapsulatedBits.ciphertext#
始于：v24.7.0
encapsulatedBits.sharedKey#
始于：v24.7.0

类：EncapsulatedKey#

始于：v24.7.0

一个用于消息加密的临时对称密钥（表示为 <CryptoKey>）和由该共享密钥加密的密文（可与消息一起传输给消息接收者）。接收者使用其私钥来确定共享密钥是什么，然后可以解密消息。

encapsulatedKey.ciphertext#
始于：v24.7.0
encapsulatedKey.sharedKey#
始于：v24.7.0

类：HkdfParams#

新增于：v15.0.0
hkdfParams.hash#
历史
版本变更
v24.7.0

现在支持 SHA-3 算法。

v15.0.0

新增于：v15.0.0

如果表示为 <string>，该值必须是以下之一：

  • 'SHA-1'
  • 'SHA-256'
  • 'SHA-384'
  • 'SHA-512'
  • 'SHA3-256'4
  • 'SHA3-384'4
  • 'SHA3-512'4

如果表示为 <Algorithm>，对象的 name 属性必须是上面列出的值之一。

hkdfParams.info#
新增于：v15.0.0

为 HKDF 算法提供特定于应用程序的上下文输入。此输入可以为零长度，但必须提供。

hkdfParams.name#
新增于：v15.0.0
hkdfParams.salt#
新增于：v15.0.0

盐值显著提高了 HKDF 算法的强度。它应该是随机或伪随机的，并且应与摘要函数的输出长度相同（例如，如果使用 'SHA-256' 作为摘要，盐值应为 256 比特的随机数据）。

类：HmacImportParams#

新增于：v15.0.0
hmacImportParams.hash#
历史
版本变更
v24.7.0

现在支持 SHA-3 算法。

v15.0.0

新增于：v15.0.0

如果表示为 <string>，该值必须是以下之一：

  • 'SHA-1'
  • 'SHA-256'
  • 'SHA-384'
  • 'SHA-512'
  • 'SHA3-256'4
  • 'SHA3-384'4
  • 'SHA3-512'4

如果表示为 <Algorithm>，对象的 name 属性必须是上面列出的值之一。

hmacImportParams.length#
新增于：v15.0.0

HMAC 密钥的可选比特数。这是可选的，在大多数情况下应省略。

hmacImportParams.name#
新增于：v15.0.0

类：HmacKeyAlgorithm#

新增于：v15.0.0
hmacKeyAlgorithm.hash#
新增于：v15.0.0
hmacKeyAlgorithm.length#
新增于：v15.0.0

HMAC 密钥的长度（以比特为单位）。

hmacKeyAlgorithm.name#
新增于：v15.0.0

类：HmacKeyGenParams#

新增于：v15.0.0
hmacKeyGenParams.hash#
历史
版本变更
v24.7.0

现在支持 SHA-3 算法。

v15.0.0

新增于：v15.0.0

如果表示为 <string>，该值必须是以下之一：

  • 'SHA-1'
  • 'SHA-256'
  • 'SHA-384'
  • 'SHA-512'
  • 'SHA3-256'4
  • 'SHA3-384'4
  • 'SHA3-512'4

如果表示为 <Algorithm>，对象的 name 属性必须是上面列出的值之一。

hmacKeyGenParams.length#
新增于：v15.0.0

为 HMAC 密钥生成的比特数。如果省略，长度将由所使用的哈希算法确定。这是可选的，在大多数情况下应省略。

hmacKeyGenParams.name#
新增于：v15.0.0

类：KeyAlgorithm#

新增于：v15.0.0
keyAlgorithm.name#
新增于：v15.0.0

类：KmacImportParams#

于 v24.8.0 版本中添加
kmacImportParams.length#
于 v24.8.0 版本中添加

KMAC 密钥的可选比特数。这是可选的，在大多数情况下应省略。

kmacImportParams.name#
于 v24.8.0 版本中添加
  • 类型：<string> 必须是 'KMAC128' 或 'KMAC256'。

类：KmacKeyAlgorithm#

于 v24.8.0 版本中添加
kmacKeyAlgorithm.length#
于 v24.8.0 版本中添加

KMAC 密钥的长度（以比特为单位）。

kmacKeyAlgorithm.name#
于 v24.8.0 版本中添加

类：KmacKeyGenParams#

于 v24.8.0 版本中添加
kmacKeyGenParams.length#
于 v24.8.0 版本中添加

为 KMAC 密钥生成的比特数。如果省略，长度将由所使用的 KMAC 算法确定。这是可选的，在大多数情况下应省略。

kmacKeyGenParams.name#
于 v24.8.0 版本中添加
  • 类型：<string> 必须是 'KMAC128' 或 'KMAC256'。

类：KmacParams#

于 v24.8.0 版本中添加
kmacParams.algorithm#
于 v24.8.0 版本中添加
  • 类型：<string> 必须是 'KMAC128' 或 'KMAC256'。
kmacParams.customization#
于 v24.8.0 版本中添加

customization 成员表示可选的定制化字符串。

kmacParams.length#
于 v24.8.0 版本中添加

输出的长度（以字节为单位）。必须是正整数。

类：Pbkdf2Params#

新增于：v15.0.0
pbkdf2Params.hash#
历史
版本变更
v24.7.0

现在支持 SHA-3 算法。

v15.0.0

新增于：v15.0.0

如果表示为 <string>，该值必须是以下之一：

  • 'SHA-1'
  • 'SHA-256'
  • 'SHA-384'
  • 'SHA-512'
  • 'SHA3-256'4
  • 'SHA3-384'4
  • 'SHA3-512'4

如果表示为 <Algorithm>，对象的 name 属性必须是上面列出的值之一。

pbkdf2Params.iterations#
新增于：v15.0.0

PBKDF2 算法在派生比特时应执行的迭代次数。

pbkdf2Params.name#
新增于：v15.0.0
  • 类型：<string> 必须是 'PBKDF2'。
pbkdf2Params.salt#
新增于：v15.0.0

应至少为 16 个随机或伪随机字节。

类：RsaHashedImportParams#

新增于：v15.0.0
rsaHashedImportParams.hash#
历史
版本变更
v24.7.0

现在支持 SHA-3 算法。

v15.0.0

新增于：v15.0.0

如果表示为 <string>，该值必须是以下之一：

  • 'SHA-1'
  • 'SHA-256'
  • 'SHA-384'
  • 'SHA-512'
  • 'SHA3-256'4
  • 'SHA3-384'4
  • 'SHA3-512'4

如果表示为 <Algorithm>，对象的 name 属性必须是上面列出的值之一。

rsaHashedImportParams.name#
新增于：v15.0.0
  • 类型：<string> 必须是 'RSASSA-PKCS1-v1_5'、'RSA-PSS' 或 'RSA-OAEP' 之一。

类：RsaHashedKeyAlgorithm#

新增于：v15.0.0
rsaHashedKeyAlgorithm.hash#
新增于：v15.0.0
rsaHashedKeyAlgorithm.modulusLength#
新增于：v15.0.0

RSA 模数的长度（以比特为单位）。

rsaHashedKeyAlgorithm.name#
新增于：v15.0.0
rsaHashedKeyAlgorithm.publicExponent#
新增于：v15.0.0

RSA 公共指数。

类：RsaHashedKeyGenParams#

新增于：v15.0.0
rsaHashedKeyGenParams.hash#
历史
版本变更
v24.7.0

现在支持 SHA-3 算法。

v15.0.0

新增于：v15.0.0

如果表示为 <string>，该值必须是以下之一：

  • 'SHA-1'
  • 'SHA-256'
  • 'SHA-384'
  • 'SHA-512'
  • 'SHA3-256'4
  • 'SHA3-384'4
  • 'SHA3-512'4

如果表示为 <Algorithm>，对象的 name 属性必须是上面列出的值之一。

rsaHashedKeyGenParams.modulusLength#
新增于：v15.0.0

RSA 模数的长度（以比特为单位）。作为最佳实践，该值应至少为 2048。

rsaHashedKeyGenParams.name#
新增于：v15.0.0
  • 类型：<string> 必须是 'RSASSA-PKCS1-v1_5'、'RSA-PSS' 或 'RSA-OAEP' 之一。
rsaHashedKeyGenParams.publicExponent#
新增于：v15.0.0

RSA 公共指数。这必须是一个 <Uint8Array>，其中包含一个大端序、无符号且必须在 32 位内表示的整数。<Uint8Array> 可能包含任意数量的前导零位。该值必须是素数。除非有理由使用不同的值，否则请使用 new Uint8Array([1, 0, 1]) (65537) 作为公共指数。

类：RsaOaepParams#

新增于：v15.0.0
rsaOaepParams.label#
新增于：v15.0.0

一组额外的字节，这些字节不会被加密，但会与生成的密文绑定。

rsaOaepParams.label 参数是可选的。

rsaOaepParams.name#
新增于：v15.0.0
  • 类型：<string> 必须是 'RSA-OAEP'。

类：RsaPssParams#

新增于：v15.0.0
rsaPssParams.name#
新增于：v15.0.0
  • 类型：<string> 必须是 'RSA-PSS'。
rsaPssParams.saltLength#
新增于：v15.0.0

要使用的随机盐的长度（以字节为单位）。

脚注

  1. 需要 OpenSSL >= 3.0 ↩ ↩2 ↩3

  2. 需要 OpenSSL >= 3.2 ↩ ↩2 ↩3

  3. 需要 OpenSSL >= 3.5 ↩ ↩2 ↩3 ↩4 ↩5 ↩6

  4. 参见 Web Cryptography API 中的现代算法 ↩ ↩2 ↩3 ↩4 ↩5 ↩6 ↩7 ↩8 ↩9 ↩10 ↩11 ↩12 ↩13 ↩14 ↩15 ↩16 ↩17 ↩18 ↩19 ↩20 ↩21 ↩22 ↩23 ↩24 ↩25 ↩26 ↩27 ↩28 ↩29 ↩30 ↩31 ↩32 ↩33 ↩34 ↩35 ↩36 ↩37 ↩38 ↩39 ↩40 ↩41 ↩42 ↩43 ↩44 ↩45 ↩46 ↩47 ↩48 ↩49 ↩50 ↩51 ↩52 ↩53 ↩54 ↩55 ↩56 ↩57 ↩58 ↩59 ↩60 ↩61 ↩62 ↩63 ↩64 ↩65 ↩66 ↩67 ↩68 ↩69 ↩70 ↩71 ↩72 ↩73 ↩74 ↩75 ↩76 ↩77 ↩78 ↩79 ↩80 ↩81 ↩82 ↩83 ↩84 ↩85 ↩86 ↩87 ↩88 ↩89 ↩90 ↩91 ↩92 ↩93 ↩94 ↩95 ↩96 ↩97 ↩98 ↩99 ↩100 ↩101 ↩102 ↩103 ↩104 ↩105 ↩106 ↩107 ↩108 ↩109 ↩110 ↩111 ↩112 ↩113 ↩114 ↩115 ↩116 ↩117 ↩118 ↩119 ↩120 ↩121 ↩122 ↩123 ↩124 ↩125 ↩126 ↩127 ↩128 ↩129 ↩130 ↩131 ↩132 ↩133 ↩134 ↩135 ↩136 ↩137 ↩138 ↩139 ↩140 ↩141 ↩142 ↩143 ↩144 ↩145 ↩146 ↩147 ↩148 ↩149 ↩150

  5. 参见 Web Cryptography API 中的安全曲线 ↩ ↩2 ↩3 ↩4 ↩5 ↩6 ↩7 ↩8 ↩9 ↩10 ↩11 ↩12 ↩13 ↩14 ↩15 ↩16 ↩17 ↩18 ↩19 ↩20 ↩21 ↩22 ↩23 ↩24