Node.js v21.7.2 文件

範例#

產生金鑰#

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

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

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

HMAC 金鑰#

const { subtle } = globalThis.crypto;

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

  return key;
} copy

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

加密和解密#

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

匯出和匯入金鑰#

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

封裝和解封金鑰#

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

簽署和驗證#

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

衍生位元和金鑰#

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

摘要#

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

演算法矩陣#

此表格詳細說明 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 時，<CryptoKey> 可使用 subtleCrypto.exportKey() 或 subtleCrypto.wrapKey() 萃取。

唯讀。

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> type 為 'private' 的 <CryptoKey>。

cryptoKeyPair.publicKey#

• 類型：<CryptoKey> type 為 'public' 的 <CryptoKey>。

類別：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。如果成功，傳回的承諾會以包含純文字結果的 <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' 演算法。

如果成功，回傳的承諾會以包含產生資料的 <ArrayBuffer> 來解決。

目前支援的演算法包括

• 'ECDH'
• 'X25519' ¹
• 'X448' ¹
• '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> 完成

subtle.deriveKey() 使用 algorithm 中指定的演算法和參數，以及 baseKey 提供的金鑰素材，嘗試根據 derivedKeyAlgorithm 中的演算法和參數產生新的 <CryptoKey>。

呼叫 subtle.deriveKey() 等於呼叫 subtle.deriveBits() 產生原始金鑰素材，然後使用 deriveKeyAlgorithm、extractable 和 keyUsages 參數作為輸入，將結果傳入 subtle.importKey() 方法。

目前支援的演算法包括

• 'ECDH'
• 'X25519' ¹
• 'X448' ¹
• 'HKDF'
• 'PBKDF2'

subtle.digest(algorithm, data)#

• algorithm：<string> | <Object>
• data：<ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 傳回：<Promise> 以 <ArrayBuffer> 履行

subtle.digest() 使用由 algorithm 識別的演算法，嘗試產生 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>
• data：<ArrayBuffer> | <TypedArray> | <DataView> | <Buffer>
• 傳回：<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 Web Key 規範的 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' ¹
• 'Ed448' ¹
• 'ECDH'
• 'X25519' ¹
• 'X448' ¹

支援的 <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> 執行個體。如果匯入成功，傳回的承諾會使用建立的 <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 的密碼簽章。如果成功，已回傳的承諾將會以包含已產生簽章的 <ArrayBuffer> 來解決。

目前支援的演算法包括

• 'RSASSA-PKCS1-v1_5'
• 'RSA-PSS'
• 'ECDSA'
• 'Ed25519' ¹
• 'Ed448' ¹
• '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> 完成

在密碼學中，「封裝金鑰」是指匯出並加密金鑰資料。subtle.unwrapKey() 方法嘗試解密封裝的金鑰並建立 <CryptoKey> 執行個體。這等於先對加密的金鑰資料呼叫 subtle.decrypt()（使用 wrappedKey、unwrapAlgo 和 unwrappingKey 參數作為輸入），然後使用 unwrappedKeyAlgo、extractable 和 keyUsages 參數作為輸入將結果傳入 subtle.importKey() 方法。如果成功，傳回的承諾會以 <CryptoKey> 物件解決。

目前支援的封裝演算法包括

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

支援的未封裝金鑰演算法包括

• 'RSASSA-PKCS1-v1_5'
• 'RSA-PSS'
• 'RSA-OAEP'
• 'ECDSA'
• 'Ed25519' ¹
• 'Ed448' ¹
• 'ECDH'
• 'X25519' ¹
• 'X448' ¹
• '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 的有效密碼簽章。已回傳的承諾會以 true 或 false 來解決。

目前支援的演算法包括

• 'RSASSA-PKCS1-v1_5'
• 'RSA-PSS'
• 'ECDSA'
• 'Ed25519' ¹
• 'Ed448' ¹
• '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> 履行

在密碼學中，「包裝金鑰」是指匯出金鑰材料，然後對其進行加密。subtle.wrapKey() 方法會將金鑰材料匯出成 format 所識別的格式，然後使用 wrapAlgo 指定的方法和參數，以及 wrappingKey 提供的金鑰材料，對其進行加密。這等同於使用 format 和 key 作為參數呼叫 subtle.exportKey()，然後使用 wrappingKey 和 wrapAlgo 作為輸入，將結果傳遞給 subtle.encrypt() 方法。如果成功，已回傳的承諾會以包含加密金鑰資料的 <ArrayBuffer> 來解決。

目前支援的封裝演算法包括

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

演算法參數#

演算法參數物件會定義各種 <SubtleCrypto> 方法所使用的演算法和參數。雖然在此說明為「類別」，但它們只是簡單的 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#

• 類型：<數字>所產生驗證標記的位元大小。此值必須為下列之一：32、64、96、104、112、120 或 128。預設：128。

類別：AesKeyGenParams#

aesKeyGenParams.length#

• 類型：<數字>

要產生的 AES 金鑰長度。這必須是 128、192 或 256。

aesKeyGenParams.name#

• 類型：<字串>必須是下列之一：'AES-CBC'、'AES-CTR'、'AES-GCM' 或 'AES-KW'

類別：EcdhKeyDeriveParams#

ecdhKeyDeriveParams.name#

• 類型：<字串>必須是 '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#

• 類型：<數字>

HMAC 金鑰中位元數的選項。這項選項是可省略的，在大部分情況下都應該省略。

hmacImportParams.name#

• 類型：<string> 必須為 'HMAC'。

類別：HmacKeyGenParams#

hmacKeyGenParams.hash#

• 類型：<string> | <Object>

如果表示為 <string>，值必須為下列之一

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

如果表示為 <Object>，物件必須具有 name 屬性，其值為上面列出的值之一。

hmacKeyGenParams.length#

• 類型：<數字>

為 HMAC 金鑰產生的位元數。如果省略，長度將由使用的雜湊演算法決定。這項選項是可省略的，在大部分情況下都應該省略。

hmacKeyGenParams.name#

• 類型：<string> 必須為 'HMAC'。

類別：Pbkdf2Params#

pbkdb2Params.hash#

• 類型：<string> | <Object>

如果表示為 <string>，值必須為下列之一

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

如果表示為 <Object>，物件必須具有 name 屬性，其值為上面列出的值之一。

pbkdf2Params.iterations#

• 類型：<數字>

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#

• 類型：<字串> 必須為下列之一：'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#

• 類型：<數字>

RSA 模數的長度（以位元為單位）。建議至少為 2048。

rsaHashedKeyGenParams.name#

• 類型：<字串> 必須為下列之一：'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#

• 類型：<數字>

要使用的隨機鹽的長度（以位元組為單位）。