Node.js v26.0.0 文件

Crypto#

node:crypto 模組提供了加密功能，包括用於 OpenSSL 的雜湊、HMAC、加密、解密、簽名和驗證功能的一組包裝器。

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
copy

確定加密支援是否不可用#

Node.js 可能會在構建時未包含對 node:crypto 模組的支援。在這種情況下，嘗試從 crypto 匯入或呼叫 require('node:crypto') 將導致丟擲錯誤。

使用 CommonJS 時，丟擲的錯誤可以使用 try/catch 捕獲。

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

當使用詞法 ESM import 關鍵字時，只有在嘗試載入模組*之前*註冊了 process.on('uncaughtException') 的處理程式（例如，使用預載入模組），才能捕獲該錯誤。

使用 ESM 時，如果程式碼有可能在未啟用加密支援的 Node.js 版本上執行，請考慮使用 import() 函式，而不是詞法 import 關鍵字。

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

非對稱金鑰型別#

下表列出了 KeyObject API 識別的非對稱金鑰型別，以及每種金鑰型別支援的匯出/匯入格式。

金鑰格式#

非對稱金鑰可以用多種格式表示。建議的方法是將金鑰材料匯入 KeyObject 一次，並將其重用於所有後續操作，因為這可以避免重複解析並提供最佳效能。

當 KeyObject 不切實際時（例如，當金鑰材料出現在協議訊息中且僅使用一次時），大多數加密函式也接受 PEM 字串或直接指定格式和金鑰材料的物件。有關每種格式接受的完整選項，請參見 crypto.createPublicKey()、crypto.createPrivateKey() 和 keyObject.export()。

KeyObject#

KeyObject 是解析金鑰的記憶體中表示形式。它由 crypto.createPublicKey()、crypto.createPrivateKey()、crypto.createSecretKey() 或金鑰生成函式（例如 crypto.generateKeyPair()）建立。使用給定 KeyObject 的第一次加密操作可能比後續操作慢，因為 OpenSSL 在首次使用時會延遲初始化內部快取。

PEM 和 DER#

PEM 和 DER 是基於 ASN.1 結構的非對稱金鑰的傳統編碼格式。

• PEM 是一種文字編碼，它將 Base64 編碼的 DER 資料包裝在頁首和頁尾行之間（例如 -----BEGIN PUBLIC KEY-----）。PEM 字串可以直接傳遞給大多數加密操作。
• DER 是相同 ASN.1 結構的二進位制編碼。提供 DER 輸入時，必須明確指定 type（通常為 'spki' 或 'pkcs8'）。

JSON Web 金鑰 (JWK)#

JSON Web 金鑰 (JWK) 是一種基於 JSON 的金鑰表示法，在 RFC 7517 中定義。JWK 將每個金鑰元件編碼為 JSON 物件中的單個 Base64url 編碼值。對於 RSA 金鑰，JWK 避免了 ASN.1 解析開銷，是速度最快的序列化匯入格式。

原始金鑰格式#

'raw-public'、'raw-private' 和 'raw-seed' 金鑰格式允許匯入和匯出原始金鑰材料，無需任何編碼包裝。有關用法詳情，請參閱 keyObject.export()、crypto.createPublicKey() 和 crypto.createPrivateKey()。

'raw-public' 通常是匯入公鑰的最快方式。'raw-private' 和 'raw-seed' 並不總是比其他格式快，因為它們只包含私有標量或種子——匯入它們需要匯出公鑰元件（例如橢圓曲線點乘或種子擴充套件），這可能會很昂貴。其他格式同時包含私鑰和公鑰元件，避免了該計算。

選擇金鑰格式#

始終優先選擇 KeyObject——從你擁有的任何格式建立一個並重用它。以下指導僅適用於在序列化格式之間進行選擇時，無論是為了匯入 KeyObject 還是在 KeyObject 不切實際時內聯傳遞金鑰材料。

匯入金鑰#

當建立 KeyObject 以供重複使用時，匯入成本只支付一次，因此選擇更快的格式可以減少啟動延遲。

匯入成本分為兩部分：解析開銷（解碼序列化包裝）和 金鑰計算（重建完整金鑰所需的任何數學工作，例如從私有標量推導公鑰或擴充套件種子）。哪部分佔主導地位取決於金鑰型別。例如：

• 公鑰 - 'raw-public' 是最快的序列化格式，因為原始格式跳過了所有 ASN.1 和 Base64 解碼。
• EC 私鑰 - 'raw-private' 比 PEM 或 DER 快，因為它避免了 ASN.1 解析。然而，對於較大的曲線（例如 P-384、P-521），從私有標量匯出公點的必要計算變得昂貴，從而降低了優勢。
• RSA 金鑰 - 'jwk' 是最快的序列化格式。JWK 將 RSA 金鑰元件表示為單獨的 Base64url 編碼整數，完全避免了 ASN.1 解析的開銷。

操作中的內聯金鑰材料#

當 KeyObject 無法重用時（例如，金鑰作為協議訊息中的原始位元組到達且僅使用一次），大多數加密函式也接受 PEM 字串或直接指定格式和金鑰材料的物件。在這種情況下，總成本是金鑰匯入成本與加密計算成本之和。

對於加密計算占主導地位的操作（例如使用 RSA 簽名或使用 P-384 或 P-521 進行 ECDH 金鑰協商），序列化格式對總體吞吐量的影響微乎其微，因此請選擇最方便的格式。對於像 Ed25519 簽名或驗證這樣的輕量級操作，匯入成本佔總成本的比例較大，因此更快的格式（如 'raw-public' 或 'raw-private'）可以顯著提高吞吐量。

即使相同的金鑰材料僅使用幾次，將其匯入 KeyObject 也比反覆傳遞原始或 PEM 表示形式更值得。

示例#

示例：在簽名和驗證操作中重用 KeyObject

import { promisify } from 'node:util';
const { generateKeyPair, sign, verify } = await import('node:crypto');

const { publicKey, privateKey } = await promisify(generateKeyPair)('ed25519');

// A KeyObject holds the parsed key in memory and can be reused
// across multiple operations without re-parsing.
const data = new TextEncoder().encode('message to sign');
const signature = sign(null, data, privateKey);
verify(null, data, publicKey, signature);
copy

示例：將各種格式的金鑰匯入 KeyObject

import { promisify } from 'node:util';
const {
  createPrivateKey, createPublicKey, generateKeyPair,
} = await import('node:crypto');

const generated = await promisify(generateKeyPair)('ed25519');

// PEM
const privatePem = generated.privateKey.export({ format: 'pem', type: 'pkcs8' });
const publicPem = generated.publicKey.export({ format: 'pem', type: 'spki' });
createPrivateKey(privatePem);
createPublicKey(publicPem);

// DER - requires explicit type
const privateDer = generated.privateKey.export({ format: 'der', type: 'pkcs8' });
const publicDer = generated.publicKey.export({ format: 'der', type: 'spki' });
createPrivateKey({ key: privateDer, format: 'der', type: 'pkcs8' });
createPublicKey({ key: publicDer, format: 'der', type: 'spki' });

// JWK
const privateJwk = generated.privateKey.export({ format: 'jwk' });
const publicJwk = generated.publicKey.export({ format: 'jwk' });
createPrivateKey({ key: privateJwk, format: 'jwk' });
createPublicKey({ key: publicJwk, format: 'jwk' });

// Raw
const rawPriv = generated.privateKey.export({ format: 'raw-private' });
const rawPub = generated.publicKey.export({ format: 'raw-public' });
createPrivateKey({ key: rawPriv, format: 'raw-private', asymmetricKeyType: 'ed25519' });
createPublicKey({ key: rawPub, format: 'raw-public', asymmetricKeyType: 'ed25519' });
copy

示例：將金鑰材料直接傳遞給 crypto.sign() 和 crypto.verify()，而不先建立 KeyObject

import { promisify } from 'node:util';
const { generateKeyPair, sign, verify } = await import('node:crypto');

const generated = await promisify(generateKeyPair)('ed25519');

const data = new TextEncoder().encode('message to sign');

// PEM strings
const privatePem = generated.privateKey.export({ format: 'pem', type: 'pkcs8' });
const publicPem = generated.publicKey.export({ format: 'pem', type: 'spki' });
const sig1 = sign(null, data, privatePem);
verify(null, data, publicPem, sig1);

// JWK objects
const privateJwk = generated.privateKey.export({ format: 'jwk' });
const publicJwk = generated.publicKey.export({ format: 'jwk' });
const sig2 = sign(null, data, { key: privateJwk, format: 'jwk' });
verify(null, data, { key: publicJwk, format: 'jwk' }, sig2);

// Raw key bytes
const rawPriv = generated.privateKey.export({ format: 'raw-private' });
const rawPub = generated.publicKey.export({ format: 'raw-public' });
const sig3 = sign(null, data, {
  key: rawPriv, format: 'raw-private', asymmetricKeyType: 'ed25519',
});
verify(null, data, {
  key: rawPub, format: 'raw-public', asymmetricKeyType: 'ed25519',
}, sig3);
copy

示例：對於 EC 金鑰，匯入原始金鑰時需要 namedCurve 選項

import { promisify } from 'node:util';
const {
  createPrivateKey, createPublicKey, generateKeyPair, sign, verify,
} = await import('node:crypto');

const generated = await promisify(generateKeyPair)('ec', {
  namedCurve: 'P-256',
});

// Export the raw EC public key (uncompressed by default).
const rawPublicKey = generated.publicKey.export({ format: 'raw-public' });

// The following is equivalent.
const rawPublicKeyUncompressed = generated.publicKey.export({
  format: 'raw-public',
  type: 'uncompressed',
});

// Export compressed point format.
const rawPublicKeyCompressed = generated.publicKey.export({
  format: 'raw-public',
  type: 'compressed',
});

// Export the raw EC private key.
const rawPrivateKey = generated.privateKey.export({ format: 'raw-private' });

// Import the raw EC keys.
// Both compressed and uncompressed point formats are accepted.
const publicKey = createPublicKey({
  key: rawPublicKey,
  format: 'raw-public',
  asymmetricKeyType: 'ec',
  namedCurve: 'P-256',
});
const privateKey = createPrivateKey({
  key: rawPrivateKey,
  format: 'raw-private',
  asymmetricKeyType: 'ec',
  namedCurve: 'P-256',
});

const data = new TextEncoder().encode('message to sign');
const signature = sign('sha256', data, privateKey);
verify('sha256', data, publicKey, signature);
copy

示例：匯出原始種子並匯入它們

import { promisify } from 'node:util';
const {
  createPrivateKey, decapsulate, encapsulate, generateKeyPair,
} = await import('node:crypto');

const generated = await promisify(generateKeyPair)('ml-kem-768');

// Export the raw seed (64 bytes for ML-KEM).
const seed = generated.privateKey.export({ format: 'raw-seed' });

// Import the raw seed.
const privateKey = createPrivateKey({
  key: seed,
  format: 'raw-seed',
  asymmetricKeyType: 'ml-kem-768',
});

const { ciphertext } = encapsulate(generated.publicKey);
decapsulate(privateKey, ciphertext);
copy

類：Certificate#

SPKAC 是 Netscape 最初實現的證書籤名請求機制，並被正式指定為 HTML5 keygen 元素的一部分。

<keygen> 自 HTML 5.2 起已被棄用，新專案不應再使用此元素。

node:crypto 模組提供了 Certificate 類來處理 SPKAC 資料。最常見的用法是處理由 HTML5 <keygen> 元素生成的輸出。Node.js 內部使用 OpenSSL 的 SPKAC 實現。

靜態方法：Certificate.exportChallenge(spkac[, encoding])#

• spkac <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> spkac 字串的編碼。
• 返回：<Buffer> spkac 資料結構的質詢元件，其中包括公鑰和質詢。

const { Certificate } = await import('node:crypto');
const spkac = getSpkacSomehow();
const challenge = Certificate.exportChallenge(spkac);
console.log(challenge.toString('utf8'));
// Prints: the challenge as a UTF8 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
copy

靜態方法：Certificate.exportPublicKey(spkac[, encoding])#

• spkac <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> spkac 字串的編碼。
• 返回：<Buffer> spkac 資料結構的公鑰元件，其中包括公鑰和質詢。

const { Certificate } = await import('node:crypto');
const spkac = getSpkacSomehow();
const publicKey = Certificate.exportPublicKey(spkac);
console.log(publicKey);
// Prints: the public key as <Buffer ...>
const { Certificate } = require('node:crypto');
const spkac = getSpkacSomehow();
const publicKey = Certificate.exportPublicKey(spkac);
console.log(publicKey);
// Prints: the public key as <Buffer ...>
copy

靜態方法：Certificate.verifySpkac(spkac[, encoding])#

• spkac <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> spkac 字串的編碼。
• 返回：<boolean> 如果給定的 spkac 資料結構有效，則為 true，否則為 false。

import { Buffer } from 'node:buffer';
const { Certificate } = await import('node:crypto');

const spkac = getSpkacSomehow();
console.log(Certificate.verifySpkac(Buffer.from(spkac)));
// Prints: true or 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
copy

遺留 API#

作為遺留介面，可以按照以下示例所示建立 crypto.Certificate 類的新例項。

new crypto.Certificate()#

可以使用 new 關鍵字或透過將 crypto.Certificate() 作為函式呼叫來建立 Certificate 類的例項。

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

certificate.exportChallenge(spkac[, encoding])#

• spkac <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> spkac 字串的編碼。
• 返回：<Buffer> spkac 資料結構的質詢元件，其中包括公鑰和質詢。

const { Certificate } = await import('node:crypto');
const cert = Certificate();
const spkac = getSpkacSomehow();
const challenge = cert.exportChallenge(spkac);
console.log(challenge.toString('utf8'));
// Prints: the challenge as a UTF8 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
copy

certificate.exportPublicKey(spkac[, encoding])#

• spkac <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> spkac 字串的編碼。
• 返回：<Buffer> spkac 資料結構的公鑰元件，其中包括公鑰和質詢。

const { Certificate } = await import('node:crypto');
const cert = Certificate();
const spkac = getSpkacSomehow();
const publicKey = cert.exportPublicKey(spkac);
console.log(publicKey);
// Prints: the public key as <Buffer ...>
const { Certificate } = require('node:crypto');
const cert = Certificate();
const spkac = getSpkacSomehow();
const publicKey = cert.exportPublicKey(spkac);
console.log(publicKey);
// Prints: the public key as <Buffer ...>
copy

certificate.verifySpkac(spkac[, encoding])#

• spkac <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> spkac 字串的編碼。
• 返回：<boolean> 如果給定的 spkac 資料結構有效，則為 true，否則為 false。

import { Buffer } from 'node:buffer';
const { Certificate } = await import('node:crypto');

const cert = Certificate();
const spkac = getSpkacSomehow();
console.log(cert.verifySpkac(Buffer.from(spkac)));
// Prints: true or 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
copy

類：Cipheriv#

• 繼承：<stream.Transform>

Cipheriv 類的例項用於加密資料。該類可以透過以下兩種方式之一使用

• 作為既可讀又可寫的 流，將普通未加密資料寫入，在可讀端產生加密資料，或者
• 使用 cipher.update() 和 cipher.final() 方法來產生加密資料。

crypto.createCipheriv() 方法用於建立 Cipheriv 例項。Cipheriv 物件不應使用 new 關鍵字直接建立。

示例：將 Cipheriv 物件用作流

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

示例：使用 Cipheriv 和管道流

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

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

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

cipher.final([outputEncoding])#

• outputEncoding <string> 返回值的編碼。
• 返回：<Buffer> | <string> 任何剩餘的已加密內容。如果指定了 outputEncoding，則返回字串。如果未提供 outputEncoding，則返回 Buffer。

一旦呼叫了 cipher.final() 方法，Cipheriv 物件就不能再用於加密資料。嘗試多次呼叫 cipher.final() 將導致丟擲錯誤。

cipher.getAuthTag()#

• 返回：<Buffer> 使用認證加密模式時（目前支援 GCM、CCM、OCB 和 chacha20-poly1305），cipher.getAuthTag() 方法返回一個 Buffer，其中包含從給定資料計算出的認證標籤。

cipher.getAuthTag() 方法僅應在使用 cipher.final() 方法完成加密後呼叫。

如果建立 cipher 例項時設定了 authTagLength 選項，則此函式將精確返回 authTagLength 位元組。

cipher.setAAD(buffer[, options])#

• buffer <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• options <Object> stream.transform 選項
  • plaintextLength <number>
  • encoding <string> 當 buffer 是字串時使用的字串編碼。
• 返回：<Cipheriv> 用於方法鏈的同一個 Cipheriv 例項。

使用認證加密模式時（目前支援 GCM、CCM、OCB 和 chacha20-poly1305），cipher.setAAD() 方法設定用於附加認證資料 (AAD) 輸入引數的值。

對於 GCM 和 OCB，plaintextLength 選項是可選的。使用 CCM 時，必須指定 plaintextLength 選項，並且其值必須與明文的位元組長度相匹配。請參閱 CCM 模式。

cipher.setAAD() 方法必須在 cipher.update() 之前呼叫。

cipher.setAutoPadding([autoPadding])#

• autoPadding <boolean> 預設： true
• 返回：<Cipheriv> 用於方法鏈的同一個 Cipheriv 例項。

使用分組加密演算法時，Cipheriv 類會自動將填充新增到輸入資料中，以達到適當的分組大小。要停用預設填充，請呼叫 cipher.setAutoPadding(false)。

當 autoPadding 為 false 時，整個輸入資料的長度必須是加密演算法分組大小的倍數，否則 cipher.final() 將丟擲錯誤。停用自動填充對於非標準填充很有用，例如使用 0x0 代替 PKCS 填充。

cipher.setAutoPadding() 方法必須在 cipher.final() 之前呼叫。

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

• data <string> | <Buffer> | <TypedArray> | <DataView>
• inputEncoding <string> 資料的編碼。
• outputEncoding <string> 返回值的編碼。
• 返回：<Buffer> | <string>

使用 data 更新加密演算法。如果給定了 inputEncoding 引數，則 data 引數是使用指定編碼的字串。如果未給定 inputEncoding 引數，則 data 必須是 Buffer、TypedArray 或 DataView。如果 data 是 Buffer、TypedArray 或 DataView，則忽略 inputEncoding。

outputEncoding 指定已加密資料的輸出格式。如果指定了 outputEncoding，則返回使用指定編碼的字串。如果未提供 outputEncoding，則返回 Buffer。

cipher.update() 方法可以多次呼叫新資料，直到呼叫 cipher.final() 為止。在 cipher.final() 之後呼叫 cipher.update() 將導致丟擲錯誤。

類：Decipheriv#

• 繼承：<stream.Transform>

Decipheriv 類的例項用於解密資料。該類可以透過以下兩種方式之一使用

• 作為既可讀又可寫的 流，將普通加密資料寫入，在可讀端產生未加密資料，或者
• 使用 decipher.update() 和 decipher.final() 方法來產生未加密資料。

crypto.createDecipheriv() 方法用於建立 Decipheriv 例項。Decipheriv 物件不應使用 new 關鍵字直接建立。

示例：將 Decipheriv 物件用作流

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

示例：使用 Decipheriv 和管道流

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

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

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
copy

decipher.final([outputEncoding])#

• outputEncoding <string> 返回值的編碼。
• 返回：<Buffer> | <string> 任何剩餘的已解密內容。如果指定了 outputEncoding，則返回字串。如果未提供 outputEncoding，則返回 Buffer。

一旦呼叫了 decipher.final() 方法，Decipheriv 物件就不能再用於解密資料。嘗試多次呼叫 decipher.final() 將導致丟擲錯誤。

decipher.setAAD(buffer[, options])#

• buffer <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• options <Object> stream.transform 選項
  • plaintextLength <number>
  • encoding <string> 當 buffer 是字串時使用的字串編碼。
• 返回：<Decipheriv> 用於方法鏈的同一個 Decipher。

使用認證加密模式時（目前支援 GCM、CCM、OCB 和 chacha20-poly1305），decipher.setAAD() 方法設定用於附加認證資料 (AAD) 輸入引數的值。

對於 GCM，options 引數是可選的。使用 CCM 時，必須指定 plaintextLength 選項，並且其值必須與密文的位元組長度相匹配。請參閱 CCM 模式。

decipher.setAAD() 方法必須在 decipher.update() 之前呼叫。

將字串作為 buffer 傳遞時，請考慮將字串用作加密 API 輸入時的注意事項。

decipher.setAuthTag(buffer[, encoding])#

• buffer <string> | <Buffer> | <ArrayBuffer> | <TypedArray> | <DataView>
• encoding <string> 當 buffer 是字串時使用的字串編碼。
• 返回：<Decipheriv> 用於方法鏈的同一個 Decipher。

使用認證加密模式時（目前支援 GCM、CCM、OCB 和 chacha20-poly1305），decipher.setAuthTag() 方法用於傳入接收到的認證標籤。如果沒有提供標籤，或者密文被篡改，decipher.final() 將丟擲錯誤，表示由於認證失敗應丟棄密文。如果標籤長度根據 NIST SP 800-38D 無效，或者與 authTagLength 選項的值不匹配，decipher.setAuthTag() 將丟擲錯誤。

對於 CCM 模式，decipher.setAuthTag() 方法必須在 decipher.update() 之前呼叫；對於 GCM 和 OCB 模式以及 chacha20-poly1305，必須在 decipher.final() 之前呼叫。decipher.setAuthTag() 只能呼叫一次。

將字串作為認證標籤傳遞時，請考慮將字串用作加密 API 輸入時的注意事項。

decipher.setAutoPadding([autoPadding])#

• autoPadding <boolean> 預設： true
• 返回：<Decipheriv> 用於方法鏈的同一個 Decipher。

當資料在沒有標準分組填充的情況下加密時，呼叫 decipher.setAutoPadding(false) 將停用自動填充，以防止 decipher.final() 檢查並刪除填充。

關閉自動填充僅在輸入資料的長度是加密演算法分組大小的倍數時才有效。

decipher.setAutoPadding() 方法必須在 decipher.final() 之前呼叫。

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

• data <string> | <Buffer> | <TypedArray> | <DataView>
• inputEncoding <string> data 字串的編碼。
• outputEncoding <string> 返回值的編碼。
• 返回：<Buffer> | <string>

使用 data 更新解密演算法。如果給定了 inputEncoding 引數，則 data 引數是使用指定編碼的字串。如果未給定 inputEncoding 引數，則 data 必須是 Buffer。如果 data 是 Buffer，則忽略 inputEncoding。

outputEncoding 指定已加密資料的輸出格式。如果指定了 outputEncoding，則返回使用指定編碼的字串。如果未提供 outputEncoding，則返回 Buffer。

decipher.update() 方法可以多次呼叫新資料，直到呼叫 decipher.final() 為止。在 decipher.final() 之後呼叫 decipher.update() 將導致丟擲錯誤。

即使底層加密演算法實現了認證，從此函式返回的明文的真實性和完整性此時也可能不確定。對於認證加密演算法，真實性通常僅在應用程式呼叫 decipher.final() 時確立。

類：DiffieHellman#

DiffieHellman 類是用於建立 Diffie-Hellman 金鑰交換的工具。

可以使用 crypto.createDiffieHellman() 函式建立 DiffieHellman 類的例項。

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

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

• otherPublicKey <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• inputEncoding <string> otherPublicKey 字串的編碼。
• outputEncoding <string> 返回值的編碼。
• 返回：<Buffer> | <string>

使用 otherPublicKey 作為對方的公鑰計算共享金鑰，並返回計算出的共享金鑰。所提供的金鑰使用指定的 inputEncoding 進行解釋，並且金鑰使用指定的 outputEncoding 進行編碼。如果未提供 inputEncoding，則期望 otherPublicKey 為 Buffer、TypedArray 或 DataView。

如果給定了 outputEncoding，則返回字串；否則，返回 Buffer。

diffieHellman.generateKeys([encoding])#

• encoding <string> 返回值的編碼。
• 返回：<Buffer> | <string>

生成私有和公共 Diffie-Hellman 金鑰值（除非它們已經生成或計算過），並以指定的 encoding 返回公鑰。此金鑰應傳輸給對方。如果提供了 encoding，則返回字串；否則返回 Buffer。

此函式是 DH_generate_key() 的一個精簡包裝器。特別是，一旦生成或設定了私鑰，呼叫此函式僅更新公鑰，但不會生成新的私鑰。

diffieHellman.getGenerator([encoding])#

• encoding <string> 返回值的編碼。
• 返回：<Buffer> | <string>

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

diffieHellman.getPrime([encoding])#

• encoding <string> 返回值的編碼。
• 返回：<Buffer> | <string>

以指定的 encoding 返回 Diffie-Hellman 素數。如果提供了 encoding，則返回字串；否則返回 Buffer。

diffieHellman.getPrivateKey([encoding])#

• encoding <string> 返回值的編碼。
• 返回：<Buffer> | <string>

以指定的 encoding 返回 Diffie-Hellman 私鑰。如果提供了 encoding，則返回字串；否則返回 Buffer。

diffieHellman.getPublicKey([encoding])#

• encoding <string> 返回值的編碼。
• 返回：<Buffer> | <string>

以指定的 encoding 返回 Diffie-Hellman 公鑰。如果提供了 encoding，則返回字串；否則返回 Buffer。

diffieHellman.setPrivateKey(privateKey[, encoding])#

• privateKey <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> privateKey 字串的編碼。

設定 Diffie-Hellman 私鑰。如果提供了 encoding 引數，則期望 privateKey 為字串。如果沒有提供 encoding，則期望 privateKey 為 Buffer、TypedArray 或 DataView。

此函式不會自動計算關聯的公鑰。可以使用 diffieHellman.setPublicKey() 或 diffieHellman.generateKeys() 來手動提供公鑰或自動推導它。

diffieHellman.setPublicKey(publicKey[, encoding])#

• publicKey <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> publicKey 字串的編碼。

設定 Diffie-Hellman 公鑰。如果提供了 encoding 引數，則期望 publicKey 為字串。如果沒有提供 encoding，則期望 publicKey 為 Buffer、TypedArray 或 DataView。

diffieHellman.verifyError#

一個位域，包含在初始化 DiffieHellman 物件期間執行的檢查所導致的任何警告和/或錯誤。

以下值對於此屬性有效（定義在 node:constants 模組中）

• DH_CHECK_P_NOT_SAFE_PRIME
• DH_CHECK_P_NOT_PRIME
• DH_UNABLE_TO_CHECK_GENERATOR
• DH_NOT_SUITABLE_GENERATOR

類：DiffieHellmanGroup#

DiffieHellmanGroup 類將眾所周知的 modp 組作為其引數。它的工作方式與 DiffieHellman 相同，不同之處在於它不允許在建立後更改其金鑰。換句話說，它不實現 setPublicKey() 或 setPrivateKey() 方法。

const { createDiffieHellmanGroup } = await import('node:crypto');
const dh = createDiffieHellmanGroup('modp16');
const { createDiffieHellmanGroup } = require('node:crypto');
const dh = createDiffieHellmanGroup('modp16');
copy

支援以下組

• 'modp14' (2048 位，RFC 3526 第 3 節)
• 'modp15' (3072 位，RFC 3526 第 4 節)
• 'modp16' (4096 位，RFC 3526 第 5 節)
• 'modp17' (6144 位，RFC 3526 第 6 節)
• 'modp18' (8192 位，RFC 3526 第 7 節)

以下組仍受支援但已棄用（請參閱注意事項）

• 'modp1' (768 位，RFC 2409 第 6.1 節)
• 'modp2' (1024 位，RFC 2409 第 6.2 節)
• 'modp5' (1536 位，RFC 3526 第 2 節)

這些已棄用的組可能會在 Node.js 的未來版本中刪除。

類：ECDH#

ECDH 類是用於建立橢圓曲線 Diffie-Hellman (ECDH) 金鑰交換的工具。

可以使用 crypto.createECDH() 函式建立 ECDH 類的例項。

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
copy

靜態方法：ECDH.convertKey(key, curve[, inputEncoding[, outputEncoding[, format]]])#

• key <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• curve <string>
• inputEncoding <string> key 字串的編碼。
• outputEncoding <string> 返回值的編碼。
• format <string> 預設： 'uncompressed'
• 返回：<Buffer> | <string>

將由 key 和 curve 指定的 EC Diffie-Hellman 公鑰轉換為由 format 指定的格式。format 引數指定點編碼，可以是 'compressed'、'uncompressed' 或 'hybrid'。所提供的金鑰使用指定的 inputEncoding 進行解釋，並且返回的金鑰使用指定的 outputEncoding 進行編碼。

使用 crypto.getCurves() 獲取可用曲線名稱列表。在較新的 OpenSSL 發行版中，openssl ecparam -list_curves 也會顯示每條可用橢圓曲線的名稱和描述。

如果未指定 format，則點將以 'uncompressed' 格式返回。

如果未提供 inputEncoding，則期望 key 為 Buffer、TypedArray 或 DataView。

示例（解壓縮金鑰）

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

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

• otherPublicKey <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• inputEncoding <string> otherPublicKey 字串的編碼。
• outputEncoding <string> 返回值的編碼。
• 返回：<Buffer> | <string>

使用 otherPublicKey 作為對方的公鑰計算共享金鑰，並返回計算出的共享金鑰。所提供的金鑰使用指定的 inputEncoding 進行解釋，並且返回的金鑰使用指定的 outputEncoding 進行編碼。如果未提供 inputEncoding，則期望 otherPublicKey 為 Buffer、TypedArray 或 DataView。

如果給定了 outputEncoding，則返回字串；否則返回 Buffer。

當 otherPublicKey 位於橢圓曲線之外時，ecdh.computeSecret 將丟擲 ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY 錯誤。由於 otherPublicKey 通常是從遠端使用者透過不安全網路提供的，請務必相應地處理此異常。

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

• encoding <string> 返回值的編碼。
• format <string> 預設： 'uncompressed'
• 返回：<Buffer> | <string>

生成私有和公共 EC Diffie-Hellman 金鑰值，並以指定的 format 和 encoding 返回公鑰。此金鑰應傳輸給對方。

format 引數指定點編碼，可以是 'compressed' 或 'uncompressed'。如果未指定 format，則點將以 'uncompressed' 格式返回。

如果提供了 encoding，則返回字串；否則返回 Buffer。

ecdh.getPrivateKey([encoding])#

• encoding <string> 返回值的編碼。
• 返回：<Buffer> | <string> 以指定 encoding 返回的 EC Diffie-Hellman 私鑰。

如果指定了 encoding，則返回字串；否則返回 Buffer。

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

• encoding <string> 返回值的編碼。
• format <string> 預設： 'uncompressed'
• 返回：<Buffer> | <string> 以指定 encoding 和 format 返回的 EC Diffie-Hellman 公鑰。

format 引數指定點編碼，可以是 'compressed' 或 'uncompressed'。如果未指定 format，則點將以 'uncompressed' 格式返回。

如果指定了 encoding，則返回字串；否則返回 Buffer。

ecdh.setPrivateKey(privateKey[, encoding])#

• privateKey <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> privateKey 字串的編碼。

設定 EC Diffie-Hellman 私鑰。如果提供了 encoding，則期望 privateKey 為字串；否則期望 privateKey 為 Buffer、TypedArray 或 DataView。

如果 privateKey 對於建立 ECDH 物件時指定的曲線無效，則丟擲錯誤。設定私鑰後，關聯的公點（金鑰）也會生成並設定在 ECDH 物件中。

ecdh.setPublicKey(publicKey[, encoding])#

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

類：Hash#

• 繼承：<stream.Transform>

Hash 類是用於建立資料雜湊摘要的工具。它可以透過以下兩種方式之一使用

• 作為既可讀又可寫的 流，將資料寫入，在可讀端產生計算出的雜湊摘要，或者
• 使用 hash.update() 和 hash.digest() 方法來產生計算出的雜湊。

crypto.createHash() 方法用於建立 Hash 例項。Hash 物件不應使用 new 關鍵字直接建立。

示例：將 Hash 物件用作流

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

示例：使用 Hash 和管道流

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

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

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
copy

hash.copy([options])#

• options <Object> stream.transform 選項
• 返回：<Hash>

建立一個包含當前 Hash 物件內部狀態深複製的新 Hash 物件。

可選的 options 引數控制流行為。對於 XOF 雜湊函式（例如 'shake256'），可以使用 outputLength 選項指定所需的位元組輸出長度。

當在呼叫 Hash 物件的 hash.digest() 方法後嘗試複製它時，會丟擲錯誤。

// 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.
copy

hash.digest([encoding])#

• encoding <string> 返回值的編碼。
• 返回：<Buffer> | <string>

計算所有已透過（使用 hash.update() 方法）傳遞的雜湊資料的摘要。如果提供了 encoding，則返回字串；否則返回 Buffer。

在呼叫 hash.digest() 方法後，Hash 物件不能再使用。多次呼叫將導致丟擲錯誤。

hash.update(data[, inputEncoding])#

• data <string> | <Buffer> | <TypedArray> | <DataView>
• inputEncoding <string> data 字串的編碼。

使用給定的 data 更新雜湊內容，其編碼在 inputEncoding 中給出。如果未提供 encoding 且 data 為字串，則強制使用 'utf8' 編碼。如果 data 為 Buffer、TypedArray 或 DataView，則忽略 inputEncoding。

這可以隨著資料的流式傳輸多次呼叫新資料。

類：Hmac#

• 繼承：<stream.Transform>

Hmac 類是用於建立加密 HMAC 摘要的工具。它可以透過以下兩種方式之一使用

• 作為既可讀又可寫的 流，將資料寫入，在可讀端產生計算出的 HMAC 摘要，或者
• 使用 hmac.update() 和 hmac.digest() 方法來產生計算出的 HMAC 摘要。

crypto.createHmac() 方法用於建立 Hmac 例項。Hmac 物件不應使用 new 關鍵字直接建立。

示例：將 Hmac 物件用作流

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

示例：使用 Hmac 和管道流

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

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

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
copy

hmac.digest([encoding])#

• encoding <string> 返回值的編碼。
• 返回：<Buffer> | <string>

計算所有已透過 hmac.update() 傳遞的資料的 HMAC 摘要。如果提供了 encoding，則返回字串；否則返回 Buffer；

在呼叫 hmac.digest() 後，Hmac 物件不能再使用。多次呼叫 hmac.digest() 將導致丟擲錯誤。

hmac.update(data[, inputEncoding])#

• data <string> | <Buffer> | <TypedArray> | <DataView>
• inputEncoding <string> data 字串的編碼。

使用給定的 data 更新 Hmac 內容，其編碼在 inputEncoding 中給出。如果未提供 encoding 且 data 為字串，則強制使用 'utf8' 編碼。如果 data 為 Buffer、TypedArray 或 DataView，則忽略 inputEncoding。

這可以隨著資料的流式傳輸多次呼叫新資料。