Node.js v20.2.0 文档

示例#

生成密钥#

<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/Ed448/X25519/X448 密钥对#

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: 256,
  }, 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;
} 拷贝

算法矩阵#

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

类：Crypto#

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

crypto.subtle#

• 类型： <SubtleCrypto>

提供对 SubtleCrypto API 的访问。

crypto.getRandomValues(typedArray)#

• typedArray <Buffer> | <TypedArray>
• 返回： <Buffer> | <TypedArray>

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

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

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

crypto.randomUUID()#

• 返回： <string>

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

类：CryptoKey#

cryptoKey.algorithm#

• 类型： <AesKeyGenParams> | <RsaHashedKeyGenParams> | <EcKeyGenParams> | <HmacKeyGenParams>

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

只读。

cryptoKey.extractable#

• 类型： <boolean>

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

只读。

cryptoKey.type#

• 类型： <string> 'secret'、'private' 或 'public' 之一。

标识密钥是对称 ('secret') 还是非对称（'private' 或 'public'）密钥的字符串。

cryptoKey.usages#

• 类型： <string[]>

标识可能使用键的操作的字符串数组。

可能的用法是：

• 'encrypt' - 密钥可用于加密数据。
• 'decrypt' - 密钥可用于解密数据。
• 'sign' - 该密钥可用于生成数字签名。
• 'verify' - 密钥可用于验证数字签名。
• 'deriveKey' - 该密钥可用于导出新密钥。
• 'deriveBits' - 密钥可用于导出位。
• 'wrapKey' - 该密钥可用于封装另一个密钥。
• 'unwrapKey' - 该密钥可用于解包另一个密钥。

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

类：CryptoKeyPair#

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

cryptoKeyPair.privateKey#

• 类型： <CryptoKey> <CryptoKey> 的 type 将是 'private'。

cryptoKeyPair.publicKey#

• 类型： <CryptoKey> <CryptoKey> 的 type 将是 'public'。

类：SubtleCrypto#

subtle.decrypt(algorithm, key, data)#

• algorithm: <RsaOaepParams> | <AesCtrParams> | <AesCbcParams> | <AesGcmParams>
• key: <CryptoKey>
• data: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 返回： <Promise> 包含 <ArrayBuffer>

使用 algorithm 中指定的方法和参数以及 key 提供的密钥材料，subtle.decrypt() 尝试解密提供的 data。 如果成功，返回的promise将使用包含明文结果的 <ArrayBuffer> 进行解析。

目前支持的算法包括：

• 'RSA-OAEP'
• 'AES-CTR'
• 'AES-CBC'
• 'AES-GCM'

subtle.deriveBits(algorithm, baseKey, length)#

• algorithm: <AlgorithmIdentifier> | <EcdhKeyDeriveParams> | <HkdfParams> | <Pbkdf2Params>
• baseKey: <CryptoKey>
• length: <number> | <null>
• 返回： <Promise> 包含 <ArrayBuffer>

使用 algorithm 中指定的方法和参数以及 baseKey 提供的密钥材料，subtle.deriveBits() 尝试生成 length 位。

Node.js 实现要求当 length 是一个数字时，它必须是 8 的倍数。

当 length 为 null 时，生成给定算法的最大位数。 'ECDH'、'X25519' 和 'X448' 算法允许这样做。

如果成功，返回的promise将使用包含生成数据的 <ArrayBuffer> 进行解析。

目前支持的算法包括：

• 'ECDH'
• 'X25519'[^1]
• 'X448'[^1]
• 'HKDF'
• 'PBKDF2'

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

• algorithm: <AlgorithmIdentifier> | <EcdhKeyDeriveParams> | <HkdfParams> | <Pbkdf2Params>
• baseKey: <CryptoKey>
• derivedKeyAlgorithm: <HmacKeyGenParams> | <AesKeyGenParams>
• extractable: <boolean>
• keyUsages: <string[]> 参见 关键用法。
• 返回： <Promise> 包含 <CryptoKey>

使用algorithm中指定的方法和参数，以及baseKey提供的密钥材料，subtle.deriveKey()尝试基于derivedKeyAlgorithm中的方法和参数生成新的<CryptoKey>。

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

目前支持的算法包括：

• 'ECDH'
• 'X25519'[^1]
• 'X448'[^1]
• 'HKDF'
• 'PBKDF2'

subtle.digest(algorithm, data)#

• algorithm: <string> | <Object>
• data: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 返回： <Promise> 包含 <ArrayBuffer>

使用 algorithm 标识的方法，subtle.digest() 尝试生成 data 的摘要。 如果成功，返回的promise将使用包含计算摘要的 <ArrayBuffer> 进行解析。

如果 algorithm 作为 <string> 提供，则它必须是以下之一：

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

如果 algorithm 作为 <Object> 提供，则它必须具有值为上述之一的 name 属性。

subtle.encrypt(algorithm, key, data)#

• algorithm: <RsaOaepParams> | <AesCtrParams> | <AesCbcParams> | <AesGcmParams>
• key: <CryptoKey>
• 返回： <Promise> 包含 <ArrayBuffer>

使用 algorithm 指定的方法和参数以及 key 提供的密钥材料，subtle.encrypt() 尝试对 data 进行加密。 如果成功，返回的promise将使用包含加密结果的 <ArrayBuffer> 进行解析。

目前支持的算法包括：

• 'RSA-OAEP'
• 'AES-CTR'
• 'AES-CBC'
• 'AES-GCM'

subtle.exportKey(format, key)#

• format: <string> 必须是 'raw'、'pkcs8'、'spki' 或 'jwk' 之一。
• key: <CryptoKey>
• 返回： <Promise> 包含 <ArrayBuffer> | <Object>。

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

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

当 format 为 'pkcs8' 或 'spki' 且导出成功时，返回的promise将使用包含导出密钥数据的 <ArrayBuffer> 进行解析。

当format为'jwk'且导出成功时，返回的promise将使用符合JSON 网络密钥规范的JavaScript对象解析。

subtle.generateKey(algorithm, extractable, keyUsages)#

• algorithm: <AlgorithmIdentifier> | <RsaHashedKeyGenParams> | <EcKeyGenParams> | <HmacKeyGenParams> | <AesKeyGenParams>

• extractable: <boolean>
• keyUsages: <string[]> 参见 关键用法。
• 返回： <Promise> 包含 <CryptoKey> | <CryptoKeyPair>

使用 algorithm 中提供的方法和参数，subtle.generateKey() 尝试生成新的密钥材料。 根据使用的方法，该方法可能会生成单个 <CryptoKey> 或 <CryptoKeyPair>。

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

• 'RSASSA-PKCS1-v1_5'
• 'RSA-PSS'
• 'RSA-OAEP'
• 'ECDSA'
• 'Ed25519'[^1]
• 'Ed448'[^1]
• 'ECDH'
• 'X25519'[^1]
• 'X448'[^1]

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

• 'HMAC'
• 'AES-CTR'
• 'AES-CBC'
• 'AES-GCM'
• 'AES-KW'

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

• format: <string> 必须是 'raw'、'pkcs8'、'spki' 或 'jwk' 之一。
• keyData: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer> | <Object>

• algorithm: <AlgorithmIdentifier> | <RsaHashedImportParams> | <EcKeyImportParams> | <HmacImportParams>

• extractable: <boolean>
• keyUsages: <string[]> 参见 关键用法。
• 返回： <Promise> 包含 <CryptoKey>

subtle.importKey() 方法尝试将提供的 keyData 解释为给定的 format，以使用提供的 algorithm、extractable 和 keyUsages 参数创建 <CryptoKey> 实例。 如果导入成功，返回的 promise 将使用创建的 <CryptoKey> 进行解析。

如果导入 'PBKDF2' 密钥，extractable 必须是 false。

目前支持的算法包括：

subtle.sign(algorithm, key, data)#

• algorithm: <AlgorithmIdentifier> | <RsaPssParams> | <EcdsaParams> | <Ed448Params>
• key: <CryptoKey>
• data: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 返回： <Promise> 包含 <ArrayBuffer>

使用 algorithm 给出的方法和参数以及 key 提供的密钥材料，subtle.sign() 尝试生成 data 的加密签名。 如果成功，返回的promise将使用包含生成的签名的 <ArrayBuffer> 进行解析。

目前支持的算法包括：

• 'RSASSA-PKCS1-v1_5'
• 'RSA-PSS'
• 'ECDSA'
• 'Ed25519'[^1]
• 'Ed448'[^1]
• 'HMAC'

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

• format: <string> 必须是 'raw'、'pkcs8'、'spki' 或 'jwk' 之一。
• wrappedKey: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• unwrappingKey: <CryptoKey>

• unwrapAlgo: <AlgorithmIdentifier> | <RsaOaepParams> | <AesCtrParams> | <AesCbcParams> | <AesGcmParams>
• unwrappedKeyAlgo: <AlgorithmIdentifier> | <RsaHashedImportParams> | <EcKeyImportParams> | <HmacImportParams>

• extractable: <boolean>
• keyUsages: <string[]> 参见 关键用法。
• 返回： <Promise> 包含 <CryptoKey>

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

目前支持的环绕算法包括：

• 'RSA-OAEP'
• 'AES-CTR'
• 'AES-CBC'
• 'AES-GCM'
• 'AES-KW'

支持的解包密钥算法包括：

• 'RSASSA-PKCS1-v1_5'
• 'RSA-PSS'
• 'RSA-OAEP'
• 'ECDSA'
• 'Ed25519'[^1]
• 'Ed448'[^1]
• 'ECDH'
• 'X25519'[^1]
• 'X448'[^1]
• 'HMAC'
• 'AES-CTR'
• 'AES-CBC'
• 'AES-GCM'
• 'AES-KW'

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

• algorithm: <AlgorithmIdentifier> | <RsaPssParams> | <EcdsaParams> | <Ed448Params>
• key: <CryptoKey>
• signature: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• data: <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 返回： <Promise> 包含 <boolean>

使用 algorithm 中给出的方法和参数以及 key 提供的密钥材料，subtle.verify() 尝试验证 signature 是 data 的有效密码签名。 返回的promise通过 true 或 false 解决。

目前支持的算法包括：

• 'RSASSA-PKCS1-v1_5'
• 'RSA-PSS'
• 'ECDSA'
• 'Ed25519'[^1]
• 'Ed448'[^1]
• 'HMAC'

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

• format: <string> 必须是 'raw'、'pkcs8'、'spki' 或 'jwk' 之一。
• key: <CryptoKey>
• wrappingKey: <CryptoKey>
• wrapAlgo: <AlgorithmIdentifier> | <RsaOaepParams> | <AesCtrParams> | <AesCbcParams> | <AesGcmParams>
• 返回： <Promise> 包含 <ArrayBuffer>

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

目前支持的环绕算法包括：

• 'RSA-OAEP'
• 'AES-CTR'
• 'AES-CBC'
• 'AES-GCM'
• 'AES-KW'

算法参数#

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

类：AlgorithmIdentifier#

algorithmIdentifier.name#

• 类型： <string>

类：AesCbcParams#

aesCbcParams.iv#

• 类型： <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

提供初始化向量。 它的长度必须恰好为 16 个字节，并且应该是不可预测的并且在密码学上是随机的。

aesCbcParams.name#

• 类型： <string> 必须是 'AES-CBC'。

类：AesCtrParams#

aesCtrParams.counter#

• 类型： <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

计数器块的初始值。 这必须正好是 16 个字节长。

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

aesCtrParams.length#

• 类型： <number> aesCtrParams.counter 中用作计数器的位数。

aesCtrParams.name#

• 类型： <string> 必须是 'AES-CTR'。

类：AesGcmParams#

aesGcmParams.additionalData#

• 类型： <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer> | <undefined>

使用 AES-GCM 方法时，additionalData 是未加密但包含在数据验证中的额外输入。 additionalData 的使用是可选的。

aesGcmParams.iv#

• 类型： <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

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

理想情况下，这是一个确定性的 12 字节值，其计算方式保证在使用相同密钥的所有调用中都是唯一的。 或者，初始化向量可以由至少 12 个加密随机字节组成。 有关为 AES-GCM 构造初始化向量的更多信息，请参阅 NIST SP 800-38D 的第 8 节。

aesGcmParams.name#

• 类型： <string> 必须是 'AES-GCM'。

aesGcmParams.tagLength#

• 类型： <number> 生成的身份验证标记的大小（以位为单位）。 此值必须是 32、64、96、104、112、120 或 128 之一。 默认值: 128。

类：AesKeyGenParams#

aesKeyGenParams.length#

• 类型： <number>

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

aesKeyGenParams.name#

• 类型： <string> 必须是 'AES-CBC'、'AES-CTR'、'AES-GCM' 或 'AES-KW' 之一

类：EcdhKeyDeriveParams#

ecdhKeyDeriveParams.name#

• 类型： <string> 必须是 'ECDH'、'X25519' 或 'X448'。

ecdhKeyDeriveParams.public#

• 类型： <CryptoKey>

ECDH 密钥派生通过将一方的私钥和另一方的公钥作为输入来运行——使用两者来生成一个共同的共享秘密。 ecdhKeyDeriveParams.public 属性设置为其他方的公钥。

类：EcdsaParams#

ecdsaParams.hash#

• 类型： <string> | <Object>

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

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

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

ecdsaParams.name#

• 类型： <string> 必须是 'ECDSA'。

类：EcKeyGenParams#

ecKeyGenParams.name#

• 类型： <string> 必须是 'ECDSA' 或 'ECDH' 之一。

ecKeyGenParams.namedCurve#

• 类型： <string> 必须是 'P-256'、'P-384'、'P-521' 之一。

类：EcKeyImportParams#

ecKeyImportParams.name#

• 类型： <string> 必须是 'ECDSA' 或 'ECDH' 之一。

ecKeyImportParams.namedCurve#

• 类型： <string> 必须是 'P-256'、'P-384'、'P-521' 之一。

类：Ed448Params#

ed448Params.name#

• 类型： <string> 必须是 'Ed448'。

ed448Params.context#

• 类型： <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer> | <undefined>

context 成员表示与消息关联的可选上下文数据。 Node.js Web Crypto API 实现仅支持零长度上下文，相当于根本不提供上下文。

类：HkdfParams#

hkdfParams.hash#

• 类型： <string> | <Object>

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

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

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

hkdfParams.info#

• 类型： <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

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

hkdfParams.name#

• 类型： <string> 必须是 'HKDF'。

hkdfParams.salt#

• 类型： <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

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

类：HmacImportParams#

hmacImportParams.hash#

• 类型： <string> | <Object>

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

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

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

hmacImportParams.length#

• 类型： <number>

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

hmacImportParams.name#

• 类型： <string> 必须是 'HMAC'。

类：HmacKeyGenParams#

hmacKeyGenParams.hash#

• 类型： <string> | <Object>

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

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

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

hmacKeyGenParams.length#

• 类型： <number>

为 HMAC 密钥生成的位数。 如果省略，长度将由使用的散列算法确定。 这是可选的，在大多数情况下应该省略。

hmacKeyGenParams.name#

• 类型： <string> 必须是 'HMAC'。

类：Pbkdf2Params#

pbkdb2Params.hash#

• 类型： <string> | <Object>

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

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

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

pbkdf2Params.iterations#

• 类型： <number>

PBKDF2 算法在导出位时应进行的迭代次数。

pbkdf2Params.name#

• 类型： <string> 必须是 'PBKDF2'。

pbkdf2Params.salt#

• 类型： <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

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

类：RsaHashedImportParams#

rsaHashedImportParams.hash#

• 类型： <string> | <Object>

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

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

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

rsaHashedImportParams.name#

• 类型： <string> 必须是 'RSASSA-PKCS1-v1_5'、'RSA-PSS' 或 'RSA-OAEP' 之一。

类：RsaHashedKeyGenParams#

rsaHashedKeyGenParams.hash#

• 类型： <string> | <Object>

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

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

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

rsaHashedKeyGenParams.modulusLength#

• 类型： <number>

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

rsaHashedKeyGenParams.name#

• 类型： <string> 必须是 'RSASSA-PKCS1-v1_5'、'RSA-PSS' 或 'RSA-OAEP' 之一。

rsaHashedKeyGenParams.publicExponent#

• 类型： <Uint8Array>

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

类：RsaOaepParams#

rsaOaepParams.label#

• 类型： <ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>

不会加密但会绑定到生成的密文的额外字节集合。

rsaOaepParams.label 参数是可选的。

rsaOaepParams.name#

• 类型： <string> 必须是 'RSA-OAEP'。

类：RsaPssParams#

rsaPssParams.name#

• 类型： <string> 必须是 'RSA-PSS'。

rsaPssParams.saltLength#

• 类型： <number>

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

[^1]： 截至 2022 年 5 月 5 日的 Web Cryptography API 中的安全曲线 实验性实现