Node.js v25.0.0 ドキュメンテーション

静的メソッド: 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 stringconst { Certificate } = require('node:crypto');
const spkac = getSpkacSomehow();
const challenge = Certificate.exportChallenge(spkac);
console.log(challenge.toString('utf8'));
// Prints: the challenge as a UTF8 stringcopy

静的メソッド: 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 falseconst { Buffer } = require('node:buffer');
const { Certificate } = require('node:crypto');

const spkac = getSpkacSomehow();
console.log(Certificate.verifySpkac(Buffer.from(spkac)));
// Prints: true or falsecopy

レガシー API#

レガシーインターフェースとして、以下の例のように crypto.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

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 stringconst { 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 stringcopy

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

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 falseconst { 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 falsecopy

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) 入力パラメータに使用される値を設定します。

plaintextLength オプションは GCM と OCB ではオプションです。CCM を使用する場合、plaintextLength オプションを指定する必要があり、その値は平文の長さ（バイト単位）と一致する必要があります。CCM モードを参照してください。

cipher.setAAD() メソッドは cipher.update() の前に呼び出す必要があります。

cipher.setAutoPadding([autoPadding])#

• autoPadding <boolean> デフォルト: true
• 戻り値: <Cipheriv> メソッドチェーンのために同じ Cipheriv インスタンス。

ブロック暗号アルゴリズムを使用する場合、Cipheriv クラスは自動的に入力データに適切なブロックサイズまでのパディングを追加します。デフォルトのパディングを無効にするには、cipher.setAutoPadding(false) を呼び出します。

autoPadding が false の場合、入力データ全体の長さは暗号のブロックサイズの倍数でなければならず、そうでなければ cipher.final() はエラーをスローします。自動パディングの無効化は、例えば PKCS パディングの代わりに 0x0 を使用するなど、非標準のパディングに役立ちます。

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() を呼び出すと、エラーがスローされます。

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) 入力パラメータに使用される値を設定します。

options 引数は GCM ではオプションです。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() はエラーをスローします。

decipher.setAuthTag() メソッドは、CCM モードの場合は 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.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>

Diffie-Hellman 生成元を指定された encoding で返します。encoding が指定されている場合は文字列が返されます。それ以外の場合は Buffer が返されます。

diffieHellman.getPrime([encoding])#

• encoding <string> 戻り値のエンコーディング。
• 戻り値: <Buffer> | <string>

Diffie-Hellman 素数を指定された encoding で返します。encoding が指定されている場合は文字列が返されます。それ以外の場合は Buffer が返されます。

diffieHellman.getPrivateKey([encoding])#

• encoding <string> 戻り値のエンコーディング。
• 戻り値: <Buffer> | <string>

Diffie-Hellman 秘密鍵を指定された encoding で返します。encoding が指定されている場合は文字列が返されます。それ以外の場合は Buffer が返されます。

diffieHellman.getPublicKey([encoding])#

• encoding <string> 戻り値のエンコーディング。
• 戻り値: <Buffer> | <string>

Diffie-Hellman 公開鍵を指定された encoding で返します。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

静的メソッド: 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 が返されます。

ecdh.computeSecret は、otherPublicKey が楕円曲線の外にある場合に 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> EC Diffie-Hellman を指定された encoding で。

encoding が指定されている場合は文字列が返されます。それ以外の場合は Buffer が返されます。

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

• encoding <string> 戻り値のエンコーディング。
• format <string> デフォルト: 'uncompressed'
• 戻り値: <Buffer> | <string> EC Diffie-Hellman 公開鍵を指定された encoding と format で。

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 であると期待されます。

ECDH オブジェクト作成時に指定された曲線に対して privateKey が無効な場合、エラーがスローされます。秘密鍵を設定すると、関連する公開点 (鍵) も生成され、ECDH オブジェクトに設定されます。

ecdh.setPublicKey(publicKey[, encoding])#

• publicKey <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> publicKey 文字列のエンコーディング。

EC Diffie-Hellman 公開鍵を設定します。encoding が指定されている場合、publicKey は文字列であると期待されます。それ以外の場合は Buffer、TypedArray、または DataView が期待されます。

通常、このメソッドを呼び出す理由はありません。なぜなら、ECDH は共有秘密を計算するために秘密鍵と相手方の公開鍵のみを必要とするからです。通常、ecdh.generateKeys() または ecdh.setPrivateKey() のいずれかが呼び出されます。ecdh.setPrivateKey() メソッドは、設定される秘密鍵に関連付けられた公開点/鍵を生成しようとします。

例 (共有秘密の取得)

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.copy([options])#

• options <Object> stream.transform のオプション
• 戻り値: <Hash>

現在の Hash オブジェクトの内部状態のディープコピーを含む新しい Hash オブジェクトを作成します。

オプションの options 引数はストリームの動作を制御します。'shake256' などの XOF ハッシュ関数では、outputLength オプションを使用して、目的の出力長をバイト単位で指定できます。

hash.digest() メソッドが呼び出された後に Hash オブジェクトをコピーしようとすると、エラーがスローされます。

// 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.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 文字列のエンコーディング。

Hmac の内容を与えられた data で更新します。そのエンコーディングは inputEncoding で指定されます。encoding が指定されておらず、data が文字列の場合、'utf8' のエンコーディングが強制されます。data が Buffer、TypedArray、または DataView の場合、inputEncoding は無視されます。

これは、データがストリーミングされるにつれて、新しいデータで何度も呼び出すことができます。

静的メソッド: KeyObject.from(key)#

• key <CryptoKey>
• 戻り値: <KeyObject>

例: CryptoKey インスタンスを KeyObject に変換する

const { KeyObject } = await import('node:crypto');
const { subtle } = globalThis.crypto;

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

const keyObject = KeyObject.from(key);
console.log(keyObject.symmetricKeySize);
// Prints: 32 (symmetric key size in bytes)const { KeyObject } = require('node:crypto');
const { subtle } = globalThis.crypto;

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

  const keyObject = KeyObject.from(key);
  console.log(keyObject.symmetricKeySize);
  // Prints: 32 (symmetric key size in bytes)
})();copy

keyObject.asymmetricKeyDetails#

• 型: <Object>
  • modulusLength <number> 鍵サイズ（ビット単位）（RSA, DSA）。
  • publicExponent <bigint> 公開指数（RSA）。
  • hashAlgorithm <string> メッセージダイジェストの名前（RSA-PSS）。
  • mgf1HashAlgorithm <string> MGF1 で使用されるメッセージダイジェストの名前（RSA-PSS）。
  • saltLength <number> 最小ソルト長（バイト単位）（RSA-PSS）。
  • divisorLength <number> q のサイズ（ビット単位）（DSA）。
  • namedCurve <string> 曲線の名前（EC）。

このプロパティは非対称鍵にのみ存在します。鍵の種類に応じて、このオブジェクトには鍵に関する情報が含まれます。このプロパティを通じて取得された情報はいずれも、鍵を一意に識別したり、鍵のセキュリティを侵害したりするために使用することはできません。

RSA-PSS 鍵の場合、鍵マテリアルに RSASSA-PSS-params シーケンスが含まれている場合、hashAlgorithm、mgf1HashAlgorithm、および saltLength プロパティが設定されます。

他の鍵の詳細は、追加の属性を使用してこの API を介して公開される可能性があります。

keyObject.asymmetricKeyType#

• 型: <string>

非対称鍵の場合、このプロパティは鍵の種類を表します。サポートされている非対称鍵の種類を参照してください。

このプロパティは、認識されない KeyObject の種類および対称鍵に対しては undefined です。

keyObject.equals(otherKeyObject)#

• otherKeyObject <KeyObject> keyObject と比較する KeyObject。
• 戻り値: <boolean>

鍵が完全に同じ型、値、およびパラメータを持つかどうかに応じて true または false を返します。このメソッドはコンスタントタイムではありません。

keyObject.export([options])#

• options <Object>
• 戻り値: <string> | <Buffer> | <Object>

対称鍵の場合、以下のエンコーディングオプションを使用できます。

• format <string> 'buffer' (デフォルト) または 'jwk' である必要があります。

公開鍵の場合、以下のエンコーディングオプションを使用できます。

• type <string> 'pkcs1' (RSA のみ) または 'spki' のいずれかである必要があります。
• format <string> 'pem'、'der'、または 'jwk' である必要があります。

秘密鍵の場合、以下のエンコーディングオプションを使用できます。

• type <string> 'pkcs1' (RSA のみ)、'pkcs8'、または 'sec1' (EC のみ) のいずれかである必要があります。
• format <string> 'pem'、'der'、または 'jwk' である必要があります。
• cipher <string> 指定された場合、秘密鍵は PKCS#5 v2.0 パスワードベースの暗号化を使用して、与えられた cipher と passphrase で暗号化されます。
• passphrase <string> | <Buffer> 暗号化に使用するパスフレーズ。cipher を参照してください。

結果の型は、選択されたエンコーディング形式によって異なります。PEM の場合は文字列、DER の場合は DER としてエンコードされたデータを含むバッファ、JWK の場合はオブジェクトになります。

JWK エンコーディング形式が選択された場合、他のすべてのエンコーディングオプションは無視されます。

PKCS#1、SEC1、および PKCS#8 タイプの鍵は、cipher と format オプションの組み合わせを使用して暗号化できます。PKCS#8 type は、cipher を指定することで、任意の鍵アルゴリズム (RSA、EC、または DH) を暗号化するために任意の format と一緒に使用できます。PKCS#1 と SEC1 は、PEM format が使用されている場合に cipher を指定することによってのみ暗号化できます。最大限の互換性を得るには、暗号化された秘密鍵に PKCS#8 を使用してください。PKCS#8 は独自の暗号化メカニズムを定義しているため、PKCS#8 鍵を暗号化する場合、PEM レベルの暗号化はサポートされていません。PKCS#8 暗号化については RFC 5208 を、PKCS#1 および SEC1 暗号化については RFC 1421 を参照してください。

keyObject.symmetricKeySize#

• 型: <number>

秘密鍵の場合、このプロパティは鍵のサイズをバイト単位で表します。このプロパティは非対称鍵に対しては undefined です。

keyObject.toCryptoKey(algorithm, extractable, keyUsages)#

• algorithm <string> | <Algorithm> | <RsaHashedImportParams> | <EcKeyImportParams> | <HmacImportParams>

• extractable <boolean>
• keyUsages <string[]> 鍵の用途 を参照してください。
• 戻り値: <CryptoKey>

KeyObject インスタンスを CryptoKey に変換します。

keyObject.type#

• 型: <string>

この KeyObject の種類に応じて、このプロパティは秘密 (対称) 鍵の場合は 'secret'、公開 (非対称) 鍵の場合は 'public'、または秘密 (非対称) 鍵の場合は 'private' のいずれかになります。

sign.sign(privateKey[, outputEncoding])#

• privateKey <Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>
  • dsaEncoding <string>
  • padding <integer>
  • saltLength <integer>
• outputEncoding <string> 戻り値のエンコーディング。
• 戻り値: <Buffer> | <string>

sign.update() または sign.write() のいずれかを使用して渡されたすべてのデータの署名を計算します。

privateKey が KeyObject でない場合、この関数は privateKey が crypto.createPrivateKey() に渡されたかのように動作します。オブジェクトの場合、以下の追加プロパティを渡すことができます。

• dsaEncoding <string> DSA および ECDSA の場合、このオプションは生成される署名の形式を指定します。以下のいずれかになります。

  • 'der' (デフォルト): DER エンコードされた ASN.1 署名構造。(r, s) をエンコードします。
  • 'ieee-p1363': IEEE-P1363 で提案された署名形式 r || s。

• padding <integer> RSA のオプションのパディング値。以下のいずれかです。

  • crypto.constants.RSA_PKCS1_PADDING (デフォルト)
  • crypto.constants.RSA_PKCS1_PSS_PADDING

  RSA_PKCS1_PSS_PADDING は、RFC 4055 のセクション 3.3 に準拠してキーの一部として MGF1 ハッシュ関数が指定されていない限り、RFC 4055 のセクション 3.1 で指定されているメッセージの署名に使用されたのと同じハッシュ関数で MGF1 を使用します。

• saltLength <integer> パディングが RSA_PKCS1_PSS_PADDING の場合のソルト長。特別な値 crypto.constants.RSA_PSS_SALTLEN_DIGEST はソルト長をダイジェストサイズに設定し、crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN (デフォルト) はそれを許容される最大値に設定します。

outputEncoding が指定された場合は文字列が返されます。それ以外の場合は Buffer が返されます。

sign.sign() メソッドが呼び出された後、Sign オブジェクトを再び使用することはできません。sign.sign() を複数回呼び出すと、エラーがスローされます。

sign.update(data[, inputEncoding])#

• data <string> | <Buffer> | <TypedArray> | <DataView>
• inputEncoding <string> data 文字列のエンコーディング。

指定された data で Sign の内容を更新します。そのエンコーディングは inputEncoding で指定されます。encoding が指定されず、data が文字列の場合、'utf8' のエンコーディングが強制されます。data が Buffer、TypedArray、または DataView の場合、inputEncoding は無視されます。

これは、データがストリーミングされるにつれて、新しいデータで何度も呼び出すことができます。

verify.update(data[, inputEncoding])#

• data <string> | <Buffer> | <TypedArray> | <DataView>
• inputEncoding <string> data 文字列のエンコーディング。

指定された data で Verify の内容を更新します。そのエンコーディングは inputEncoding で指定されます。inputEncoding が指定されず、data が文字列の場合、'utf8' のエンコーディングが強制されます。data が Buffer、TypedArray、または DataView の場合、inputEncoding は無視されます。

これは、データがストリーミングされるにつれて、新しいデータで何度も呼び出すことができます。

verify.verify(object, signature[, signatureEncoding])#

• object <Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>
  • dsaEncoding <string>
  • padding <integer>
  • saltLength <integer>
• signature <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• signatureEncoding <string> signature 文字列のエンコーディング。
• 戻り値: <boolean> データと公開鍵に対する署名の有効性に応じて true または false。

指定された object と signature を使用して、提供されたデータを検証します。

object が KeyObject でない場合、この関数は object が crypto.createPublicKey() に渡されたかのように動作します。オブジェクトの場合、以下の追加プロパティを渡すことができます。

• dsaEncoding <string> DSA および ECDSA の場合、このオプションは署名のフォーマットを指定します。以下のいずれかです。

  • 'der' (デフォルト): DER エンコードされた ASN.1 署名構造。(r, s) をエンコードします。
  • 'ieee-p1363': IEEE-P1363 で提案された署名形式 r || s。

• padding <integer> RSA のオプションのパディング値。以下のいずれかです。

  • crypto.constants.RSA_PKCS1_PADDING (デフォルト)
  • crypto.constants.RSA_PKCS1_PSS_PADDING

  RSA_PKCS1_PSS_PADDING は、RFC 4055 のセクション 3.3 に準拠してキーの一部として MGF1 ハッシュ関数が指定されていない限り、RFC 4055 のセクション 3.1 で指定されているメッセージの検証に使用されたのと同じハッシュ関数で MGF1 を使用します。

• saltLength <integer> パディングが RSA_PKCS1_PSS_PADDING の場合のソルト長。特別な値 crypto.constants.RSA_PSS_SALTLEN_DIGEST はソルト長をダイジェストサイズに設定し、crypto.constants.RSA_PSS_SALTLEN_AUTO (デフォルト) は自動的に決定されるようにします。

signature 引数は、以前に計算されたデータの署名で、signatureEncoding でエンコードされています。signatureEncoding が指定されている場合、signature は文字列であることが期待されます。それ以外の場合、signature は Buffer、TypedArray、または DataView であることが期待されます。

verify.verify() が呼び出された後、verify オブジェクトを再び使用することはできません。verify.verify() を複数回呼び出すと、エラーがスローされます。

公開鍵は秘密鍵から派生させることができるため、公開鍵の代わりに秘密鍵を渡すこともできます。

new X509Certificate(buffer)#

• buffer <string> | <TypedArray> | <Buffer> | <DataView> PEM または DER でエンコードされた X509 証明書。

x509.ca#

• 型: <boolean> これが認証局 (CA) 証明書である場合は true になります。

x509.checkEmail(email[, options])#

• email <string>
• options <Object>
  • subject <string> 'default'、'always'、または 'never'。デフォルト: 'default'。
• 戻り値: <string> | <undefined> 証明書が一致する場合は email を返し、一致しない場合は undefined を返します。

証明書が指定されたメールアドレスと一致するかどうかを確認します。

'subject' オプションが未定義または 'default' に設定されている場合、証明書のサブジェクトは、サブジェクト代替名拡張が存在しないか、メールアドレスを含まない場合にのみ考慮されます。

'subject' オプションが 'always' に設定されていて、サブジェクト代替名拡張が存在しないか、一致するメールアドレスを含まない場合、証明書のサブジェクトが考慮されます。

'subject' オプションが 'never' に設定されている場合、証明書にサブジェクト代替名が含まれていなくても、証明書のサブジェクトは考慮されません。

x509.checkHost(name[, options])#

• name <string>
• options <Object>
  • subject <string> 'default'、'always'、または 'never'。デフォルト: 'default'。
  • wildcards <boolean> デフォルト: true。
  • partialWildcards <boolean> デフォルト: true。
  • multiLabelWildcards <boolean> デフォルト: false。
  • singleLabelSubdomains <boolean> デフォルト: false。
• 戻り値: <string> | <undefined> name に一致するサブジェクト名を返します。一致するサブジェクト名がない場合は undefined を返します。

証明書が指定されたホスト名と一致するかどうかを確認します。

証明書が指定されたホスト名と一致する場合、一致するサブジェクト名が返されます。返される名前は完全一致 (例: foo.example.com) かもしれませんし、ワイルドカードを含む (例: *.example.com) かもしれません。ホスト名の比較は大文字と小文字を区別しないため、返されるサブジェクト名は大文字小文字の点で指定された name と異なる場合があります。

'subject' オプションが未定義または 'default' に設定されている場合、証明書のサブジェクトは、サブジェクト代替名拡張が存在しないか、DNS 名を含まない場合にのみ考慮されます。この動作は RFC 2818 (「HTTP Over TLS」) と一致しています。

'subject' オプションが 'always' に設定されていて、サブジェクト代替名拡張が存在しないか、一致する DNS 名を含まない場合、証明書のサブジェクトが考慮されます。

'subject' オプションが 'never' に設定されている場合、証明書にサブジェクト代替名が含まれていなくても、証明書のサブジェクトは考慮されません。

x509.checkIP(ip)#

• ip <string>
• 戻り値: <string> | <undefined> 証明書が一致する場合は ip を返し、一致しない場合は undefined を返します。

証明書が指定された IP アドレス (IPv4 または IPv6) と一致するかどうかを確認します。

RFC 5280 の iPAddress サブジェクト代替名のみが考慮され、指定された ip アドレスと完全に一致する必要があります。他のサブジェクト代替名および証明書のサブジェクトフィールドは無視されます。

x509.checkIssued(otherCert)#

• otherCert <X509Certificate>
• 戻り値: <boolean>

証明書のメタデータを比較することにより、この証明書が指定された otherCert によって発行された可能性があるかどうかを確認します。

これは、より基本的なフィルタリングルーチン (つまり、サブジェクト名と発行者名のみに基づく) を使用して選択された、考えられる発行者証明書のリストを絞り込むのに役立ちます。

最後に、この証明書の署名が otherCert の公開鍵に対応する秘密鍵によって生成されたことを確認するには、otherCert の公開鍵を KeyObject として表現し、x509.verify(publicKey) を次のように使用します。

if (!x509.verify(otherCert.publicKey)) {
  throw new Error('otherCert did not issue x509');
} copy

x509.checkPrivateKey(privateKey)#

• privateKey <KeyObject> 秘密鍵。
• 戻り値: <boolean>

この証明書の公開鍵が指定された秘密鍵と一致するかどうかを確認します。

x509.fingerprint#

• 型: <string>

この証明書の SHA-1 フィンガープリント。

SHA-1 は暗号学的に破られており、SHA-1 のセキュリティは証明書の署名に一般的に使用されるアルゴリズムよりも著しく劣るため、代わりに x509.fingerprint256 の使用を検討してください。

x509.fingerprint256#

• 型: <string>

この証明書の SHA-256 フィンガープリント。

x509.fingerprint512#

• 型: <string>

この証明書の SHA-512 フィンガープリント。

通常、SHA-256 フィンガープリントの計算はより速く、SHA-512 フィンガープリントの半分のサイズであるため、x509.fingerprint256 の方が良い選択かもしれません。SHA-512 は一般により高いレベルのセキュリティを提供すると考えられていますが、SHA-256 のセキュリティは証明書の署名に一般的に使用されるほとんどのアルゴリズムに匹敵します。

x509.infoAccess#

• 型: <string>

証明書の Authority Information Access 拡張のテキスト表現。

これは、改行で区切られたアクセス記述のリストです。各行は、アクセスメソッドとアクセスロケーションの種類で始まり、コロンとアクセスロケーションに関連付けられた値が続きます。

アクセスメソッドとアクセスロケーションの種類を示す接頭辞の後、各行の残りの部分は、値が JSON 文字列リテラルであることを示すために引用符で囲まれる場合があります。後方互換性のために、Node.js は曖昧さを避けるために必要な場合にのみこのプロパティ内で JSON 文字列リテラルを使用します。サードパーティのコードは、両方の可能なエントリ形式を処理できるように準備する必要があります。

x509.issuer#

• 型: <string>

この証明書に含まれる発行者識別情報。

x509.issuerCertificate#

• 型: <X509Certificate>

発行者証明書、または発行者証明書が利用できない場合は undefined。

x509.keyUsage#

• 型: <string[]>

この証明書のキーの拡張用途を詳述する配列。

x509.publicKey#

• 型: <KeyObject>

この証明書の公開鍵 <KeyObject>。

x509.raw#

• 型: <Buffer>

この証明書の DER エンコーディングを含む Buffer。

x509.serialNumber#

• 型: <string>

この証明書のシリアル番号。

シリアル番号は認証局によって割り当てられ、証明書を一意に識別するものではありません。代わりに一意の識別子として x509.fingerprint256 の使用を検討してください。

x509.subject#

• 型: <string>

この証明書の完全なサブジェクト。

x509.subjectAltName#

• 型: <string>

この証明書に指定されたサブジェクト代替名。

これは、コンマで区切られたサブジェクト代替名のリストです。各エントリは、サブジェクト代替名の種類を識別する文字列で始まり、コロンとエントリに関連付けられた値が続きます。

以前のバージョンの Node.js は、このプロパティを2文字のシーケンス ', ' で分割するのが安全であると誤って仮定していました (CVE-2021-44532 を参照)。しかし、悪意のある証明書と正当な証明書の両方が、文字列として表現された場合にこのシーケンスを含むサブジェクト代替名を含む可能性があります。

エントリのタイプを示す接頭辞の後、各エントリの残りの部分は、値が JSON 文字列リテラルであることを示すために引用符で囲まれる場合があります。後方互換性のために、Node.js は曖昧さを避けるために必要な場合にのみこのプロパティ内で JSON 文字列リテラルを使用します。サードパーティのコードは、両方の可能なエントリ形式を処理できるように準備する必要があります。

x509.toJSON()#

• 型: <string>

X509 証明書には標準的な JSON エンコーディングはありません。toJSON() メソッドは、PEM エンコードされた証明書を含む文字列を返します。

x509.toLegacyObject()#

• 型: <Object>

従来の 証明書オブジェクト エンコーディングを使用して、この証明書に関する情報を返します。

x509.toString()#

• 型: <string>

PEM エンコードされた証明書を返します。

x509.validFrom#

• 型: <string>

この証明書が有効である開始日時。

x509.validFromDate#

• 型: <Date>

この証明書が有効である開始日時。Date オブジェクトにカプセル化されています。

x509.validTo#

• 型: <string>

この証明書が有効である終了日時。

x509.validToDate#

• 型: <Date>

この証明書が有効である終了日時。Date オブジェクトにカプセル化されています。

x509.signatureAlgorithm#

• 型: <string> | <undefined>

証明書の署名に使用されたアルゴリズム、または署名アルゴリズムが OpenSSL によって不明な場合は undefined。

x509.signatureAlgorithmOid#

• 型: <string>

証明書の署名に使用されたアルゴリズムの OID。

x509.verify(publicKey)#

• publicKey <KeyObject> 公開鍵。
• 戻り値: <boolean>

この証明書が指定された公開鍵によって署名されたことを検証します。証明書に対する他の検証チェックは行いません。

crypto.argon2(algorithm, parameters, callback)#

• algorithm <string> Argon2 のバリアント。"argon2d"、"argon2i"、または "argon2id" のいずれか。
• parameters <Object>
  • message <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 必須。これは Argon2 のパスワードハッシュアプリケーションのパスワードです。
  • nonce <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 必須。少なくとも8バイトの長さでなければなりません。これは Argon2 のパスワードハッシュアプリケーションのソルトです。
  • parallelism <number> 必須。並列度は、実行できる計算チェーン (レーン) の数を決定します。1 より大きく、2**24-1 未満でなければなりません。
  • tagLength <number> 必須。生成するキーの長さ。4 より大きく、2**32-1 未満でなければなりません。
  • memory <number> 必須。1KiB ブロック単位のメモリコスト。8 * parallelism より大きく、2**32-1 未満でなければなりません。実際のブロック数は、4 * parallelism の最も近い倍数に切り捨てられます。
  • passes <number> 必須。パス (反復) の回数。1 より大きく、2**32-1 未満でなければなりません。
  • secret <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <undefined> オプション。ソルトに似た、派生キーと一緒に保存されるべきではないランダムな追加入力。これはパスワードハッシュアプリケーションではペッパーとして知られています。使用する場合、長さは 2**32-1 バイトを超えてはなりません。
  • associatedData <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <undefined> オプション。ハッシュに追加される追加データ。機能的にはソルトやシークレットと同等ですが、ランダムでないデータ向けです。使用する場合、長さは 2**32-1 バイトを超えてはなりません。
• callback <Function>
  • `err` <Error>
  • derivedKey <Buffer>

非同期の Argon2 実装を提供します。Argon2 は、ブルートフォース攻撃を価値のないものにするために、計算上およびメモリ上で高コストになるように設計された、パスワードベースの鍵導出関数です。

nonce は可能な限り一意であるべきです。nonce はランダムで、少なくとも16バイトの長さであることが推奨されます。詳細については NIST SP 800-132 を参照してください。

message、nonce、secret、または associatedData に文字列を渡す場合は、暗号 API への入力として文字列を使用する際の注意点 を考慮してください。

callback 関数は2つの引数、err と derivedKey で呼び出されます。err は鍵導出が失敗した場合の例外オブジェクトで、それ以外の場合は null です。derivedKey は Buffer としてコールバックに渡されます。

いずれかの入力引数が無効な値または型を指定した場合、例外がスローされます。

const { argon2, randomBytes } = await import('node:crypto');

const parameters = {
  message: 'password',
  nonce: randomBytes(16),
  parallelism: 4,
  tagLength: 64,
  memory: 65536,
  passes: 3,
};

argon2('argon2id', parameters, (err, derivedKey) => {
  if (err) throw err;
  console.log(derivedKey.toString('hex'));  // 'af91dad...9520f15'
});const { argon2, randomBytes } = require('node:crypto');

const parameters = {
  message: 'password',
  nonce: randomBytes(16),
  parallelism: 4,
  tagLength: 64,
  memory: 65536,
  passes: 3,
};

argon2('argon2id', parameters, (err, derivedKey) => {
  if (err) throw err;
  console.log(derivedKey.toString('hex'));  // 'af91dad...9520f15'
});copy

crypto.argon2Sync(algorithm, parameters)#

• algorithm <string> Argon2 のバリアント。"argon2d"、"argon2i"、または "argon2id" のいずれか。
• parameters <Object>
  • message <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 必須。これは Argon2 のパスワードハッシュアプリケーションのパスワードです。
  • nonce <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 必須。少なくとも8バイトの長さでなければなりません。これは Argon2 のパスワードハッシュアプリケーションのソルトです。
  • parallelism <number> 必須。並列度は、実行できる計算チェーン (レーン) の数を決定します。1 より大きく、2**24-1 未満でなければなりません。
  • tagLength <number> 必須。生成するキーの長さ。4 より大きく、2**32-1 未満でなければなりません。
  • memory <number> 必須。1KiB ブロック単位のメモリコスト。8 * parallelism より大きく、2**32-1 未満でなければなりません。実際のブロック数は、4 * parallelism の最も近い倍数に切り捨てられます。
  • passes <number> 必須。パス (反復) の回数。1 より大きく、2**32-1 未満でなければなりません。
  • secret <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <undefined> オプション。ソルトに似た、派生キーと一緒に保存されるべきではないランダムな追加入力。これはパスワードハッシュアプリケーションではペッパーとして知られています。使用する場合、長さは 2**32-1 バイトを超えてはなりません。
  • associatedData <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <undefined> オプション。ハッシュに追加される追加データ。機能的にはソルトやシークレットと同等ですが、ランダムでないデータ向けです。使用する場合、長さは 2**32-1 バイトを超えてはなりません。
• 戻り値: <Buffer>

同期の Argon2 実装を提供します。Argon2 は、ブルートフォース攻撃を価値のないものにするために、計算上およびメモリ上で高コストになるように設計された、パスワードベースの鍵導出関数です。

nonce は可能な限り一意であるべきです。nonce はランダムで、少なくとも16バイトの長さであることが推奨されます。詳細については NIST SP 800-132 を参照してください。

message、nonce、secret、または associatedData に文字列を渡す場合は、暗号 API への入力として文字列を使用する際の注意点 を考慮してください。

鍵導出が失敗した場合、例外がスローされます。それ以外の場合、派生キーは Buffer として返されます。

いずれかの入力引数が無効な値または型を指定した場合、例外がスローされます。

const { argon2Sync, randomBytes } = await import('node:crypto');

const parameters = {
  message: 'password',
  nonce: randomBytes(16),
  parallelism: 4,
  tagLength: 64,
  memory: 65536,
  passes: 3,
};

const derivedKey = argon2Sync('argon2id', parameters);
console.log(derivedKey.toString('hex'));  // 'af91dad...9520f15'const { argon2Sync, randomBytes } = require('node:crypto');

const parameters = {
  message: 'password',
  nonce: randomBytes(16),
  parallelism: 4,
  tagLength: 64,
  memory: 65536,
  passes: 3,
};

const derivedKey = argon2Sync('argon2id', parameters);
console.log(derivedKey.toString('hex'));  // 'af91dad...9520f15'copy

crypto.checkPrime(candidate[, options], callback)#

• candidate <ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint> 任意の長さのビッグエンディアンのオクテットシーケンスとしてエンコードされた素数の候補。
• options <Object>
  • checks <number> 実行するミラー-ラビン確率的素数性テストの反復回数。値が 0 (ゼロ) の場合、ランダムな入力に対して最大で 2^-64 の偽陽性率を生じるチェック回数が使用されます。チェック回数を選択する際には注意が必要です。詳細については、OpenSSL ドキュメントの BN_is_prime_ex 関数の nchecks オプションを参照してください。デフォルト: 0
• callback <Function>
  • err <Error> チェック中にエラーが発生した場合、<Error> オブジェクトに設定されます。
  • result <boolean> 候補が 0.25 ** options.checks 未満のエラー確率で素数である場合は true。

candidate の素数性をチェックします。

crypto.checkPrimeSync(candidate[, options])#

• candidate <ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint> 任意の長さのビッグエンディアンのオクテットシーケンスとしてエンコードされた素数の候補。
• options <Object>
  • checks <number> 実行するミラー-ラビン確率的素数性テストの反復回数。値が 0 (ゼロ) の場合、ランダムな入力に対して最大で 2^-64 の偽陽性率を生じるチェック回数が使用されます。チェック回数を選択する際には注意が必要です。詳細については、OpenSSL ドキュメントの BN_is_prime_ex 関数の nchecks オプションを参照してください。デフォルト: 0
• 戻り値: <boolean> 候補が 0.25 ** options.checks 未満のエラー確率で素数である場合は true。

candidate の素数性をチェックします。

crypto.constants#

• 型: <Object>

暗号およびセキュリティ関連の操作で一般的に使用される定数を含むオブジェクト。現在定義されている特定の定数は、暗号定数で説明されています。

crypto.createCipheriv(algorithm, key, iv[, options])#

• algorithm <string>
• key <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>
• iv <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <null>
• options <Object> stream.transform のオプション
• 戻り値: <Cipheriv>

指定された algorithm、key、および初期化ベクトル (iv) で Cipheriv オブジェクトを作成して返します。

options 引数はストリームの動作を制御し、CCM または OCB モードの暗号 (例: 'aes-128-ccm') が使用される場合を除き、オプションです。その場合、authTagLength オプションは必須であり、認証タグの長さをバイト単位で指定します。CCM モードを参照してください。GCM モードでは、authTagLength オプションは必須ではありませんが、getAuthTag() によって返される認証タグの長さを設定するために使用でき、デフォルトは 16 バイトです。chacha20-poly1305 の場合、authTagLength オプションはデフォルトで 16 バイトです。

algorithm は OpenSSL に依存します。例としては 'aes192' などがあります。最近の OpenSSL リリースでは、openssl list -cipher-algorithms で利用可能な暗号アルゴリズムが表示されます。

key は algorithm で使用される生のキーで、iv は初期化ベクトルです。両方の引数は 'utf8' エンコードされた文字列、Buffer、TypedArray、または DataView でなければなりません。key はオプションで型が secret の KeyObject にすることもできます。暗号が初期化ベクトルを必要としない場合、iv は null にすることができます。

key または iv に文字列を渡す場合は、暗号 API への入力として文字列を使用する際の注意点 を考慮してください。

初期化ベクトルは予測不可能で一意であるべきです。理想的には、暗号学的にランダムであるべきです。秘密にする必要はありません。IV は通常、暗号化されていない暗号文メッセージに追加されるだけです。何かが予測不可能で一意である必要があるが、秘密である必要はないというのは矛盾しているように聞こえるかもしれません。攻撃者が特定の IV が何であるかを事前に予測できてはならないことを覚えておいてください。

crypto.createDecipheriv(algorithm, key, iv[, options])#

• algorithm <string>
• key <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>
• iv <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <null>
• options <Object> stream.transform のオプション
• 戻り値: <Decipheriv>

指定された algorithm、key、および初期化ベクトル (iv) を使用する Decipheriv オブジェクトを作成して返します。

options 引数はストリームの動作を制御し、CCM または OCB モードの暗号 (例: 'aes-128-ccm') が使用される場合を除き、オプションです。その場合、authTagLength オプションは必須であり、認証タグの長さをバイト単位で指定します。CCM モードを参照してください。AES-GCM および chacha20-poly1305 の場合、authTagLength オプションはデフォルトで 16 バイトであり、異なる長さが使用される場合は別の値に設定する必要があります。

algorithm は OpenSSL に依存します。例としては 'aes192' などがあります。最近の OpenSSL リリースでは、openssl list -cipher-algorithms で利用可能な暗号アルゴリズムが表示されます。

key は algorithm で使用される生のキーで、iv は初期化ベクトルです。両方の引数は 'utf8' エンコードされた文字列、Buffer、TypedArray、または DataView でなければなりません。key はオプションで型が secret の KeyObject にすることもできます。暗号が初期化ベクトルを必要としない場合、iv は null にすることができます。

key または iv に文字列を渡す場合は、暗号 API への入力として文字列を使用する際の注意点 を考慮してください。

初期化ベクトルは予測不可能で一意であるべきです。理想的には、暗号学的にランダムであるべきです。秘密にする必要はありません。IV は通常、暗号化されていない暗号文メッセージに追加されるだけです。何かが予測不可能で一意である必要があるが、秘密である必要はないというのは矛盾しているように聞こえるかもしれません。攻撃者が特定の IV が何であるかを事前に予測できてはならないことを覚えておいてください。

crypto.createDiffieHellman(prime[, primeEncoding][, generator][, generatorEncoding])#

• prime <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• primeEncoding <string> prime 文字列のエンコーディング。
• generator <number> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> デフォルト: 2
• generatorEncoding <string> generator 文字列のエンコーディング。
• 戻り値: <DiffieHellman>

指定された prime とオプションの特定の generator を使用して、DiffieHellman 鍵交換オブジェクトを作成します。

generator 引数は、数値、文字列、または Buffer にすることができます。generator が指定されていない場合、値 2 が使用されます。

primeEncoding が指定されている場合、prime は文字列であることが期待されます。それ以外の場合は、Buffer、TypedArray、または DataView が期待されます。

generatorEncoding が指定されている場合、generator は文字列であることが期待されます。それ以外の場合は、数値、Buffer、TypedArray、または DataView が期待されます。

crypto.createDiffieHellman(primeLength[, generator])#

• primeLength <number>
• generator <number> デフォルト: 2
• 戻り値: <DiffieHellman>

DiffieHellman 鍵交換オブジェクトを作成し、オプションの特定の数値 generator を使用して primeLength ビットの素数を生成します。generator が指定されていない場合、値 2 が使用されます。

crypto.createDiffieHellmanGroup(name)#

• name <string>
• 戻り値: <DiffieHellmanGroup>

crypto.getDiffieHellman() のエイリアス

crypto.createECDH(curveName)#

• curveName <string>
• 戻り値: <ECDH>

curveName 文字列で指定された定義済みの曲線を使用して、楕円曲線ディフィー・ヘルマン (ECDH) 鍵交換オブジェクトを作成します。利用可能な曲線名のリストを取得するには crypto.getCurves() を使用してください。最近の OpenSSL リリースでは、openssl ecparam -list_curves でも、利用可能な各楕円曲線の名前と説明が表示されます。

crypto.createHash(algorithm[, options])#

• algorithm <string>
• options <Object> stream.transform のオプション
• 戻り値: <Hash>

指定された algorithm を使用してハッシュダイジェストを生成するために使用できる Hash オブジェクトを作成して返します。オプションの options 引数はストリームの動作を制御します。'shake256' のような XOF ハッシュ関数の場合、outputLength オプションを使用して、希望する出力長をバイト単位で指定できます。

algorithm は、プラットフォーム上の OpenSSL のバージョンでサポートされている利用可能なアルゴリズムに依存します。例としては 'sha256'、'sha512' などがあります。最近の OpenSSL リリースでは、openssl list -digest-algorithms で利用可能なダイジェストアルゴリズムが表示されます。

例: ファイルの sha256 サムを生成する

import {
  createReadStream,
} from 'node:fs';
import { argv } from 'node:process';
const {
  createHash,
} = await import('node:crypto');

const filename = argv[2];

const hash = createHash('sha256');

const input = createReadStream(filename);
input.on('readable', () => {
  // Only one element is going to be produced by the
  // hash stream.
  const data = input.read();
  if (data)
    hash.update(data);
  else {
    console.log(`${hash.digest('hex')} ${filename}`);
  }
});const {
  createReadStream,
} = require('node:fs');
const {
  createHash,
} = require('node:crypto');
const { argv } = require('node:process');

const filename = argv[2];

const hash = createHash('sha256');

const input = createReadStream(filename);
input.on('readable', () => {
  // Only one element is going to be produced by the
  // hash stream.
  const data = input.read();
  if (data)
    hash.update(data);
  else {
    console.log(`${hash.digest('hex')} ${filename}`);
  }
});copy

crypto.createHmac(algorithm, key[, options])#

• algorithm <string>
• key <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>
• options <Object> stream.transform のオプション
  • encoding <string> key が文字列の場合に使用する文字列エンコーディング。
• 戻り値: <Hmac>

指定された algorithm と key を使用する Hmac オブジェクトを作成して返します。オプションの options 引数はストリームの動作を制御します。

algorithm は、プラットフォーム上の OpenSSL のバージョンでサポートされている利用可能なアルゴリズムに依存します。例としては 'sha256'、'sha512' などがあります。最近の OpenSSL リリースでは、openssl list -digest-algorithms で利用可能なダイジェストアルゴリズムが表示されます。

key は、暗号化 HMAC ハッシュを生成するために使用される HMAC キーです。KeyObject の場合、その型は secret でなければなりません。文字列の場合は、暗号 API への入力として文字列を使用する際の注意点 を考慮してください。crypto.randomBytes() や crypto.generateKey() のような暗号学的に安全なエントロピー源から取得された場合、その長さは algorithm のブロックサイズ (例: SHA-256 の場合は 512 ビット) を超えるべきではありません。

例: ファイルの sha256 HMAC を生成する

import {
  createReadStream,
} from 'node:fs';
import { argv } from 'node:process';
const {
  createHmac,
} = await import('node:crypto');

const filename = argv[2];

const hmac = createHmac('sha256', 'a secret');

const input = createReadStream(filename);
input.on('readable', () => {
  // Only one element is going to be produced by the
  // hash stream.
  const data = input.read();
  if (data)
    hmac.update(data);
  else {
    console.log(`${hmac.digest('hex')} ${filename}`);
  }
});const {
  createReadStream,
} = require('node:fs');
const {
  createHmac,
} = require('node:crypto');
const { argv } = require('node:process');

const filename = argv[2];

const hmac = createHmac('sha256', 'a secret');

const input = createReadStream(filename);
input.on('readable', () => {
  // Only one element is going to be produced by the
  // hash stream.
  const data = input.read();
  if (data)
    hmac.update(data);
  else {
    console.log(`${hmac.digest('hex')} ${filename}`);
  }
});copy

crypto.createPrivateKey(key)#

• key <Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
  • key <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <Object> PEM、DER、または JWK 形式のキーマテリアル。
  • format <string> 'pem'、'der'、または ''jwk' でなければなりません。デフォルト: 'pem'。
  • type <string> 'pkcs1'、'pkcs8'、または 'sec1' でなければなりません。このオプションは format が 'der' の場合にのみ必須で、それ以外の場合は無視されます。
  • passphrase <string> | <Buffer> 復号に使用するパスフレーズ。
  • encoding <string> key が文字列の場合に使用する文字列エンコーディング。
• 戻り値: <KeyObject>

秘密鍵を含む新しいキーオブジェクトを作成して返します。key が文字列または Buffer の場合、format は 'pem' と見なされます。それ以外の場合、key は上記のプロパティを持つオブジェクトでなければなりません。

秘密鍵が暗号化されている場合、passphrase を指定する必要があります。パスフレーズの長さは 1024 バイトに制限されています。

crypto.createPublicKey(key)#

• key <Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
  • key <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <Object> PEM、DER、または JWK 形式のキーマテリアル。
  • format <string> 'pem'、'der'、または 'jwk' でなければなりません。デフォルト: 'pem'。
  • type <string> 'pkcs1' または 'spki' でなければなりません。このオプションは format が 'der' の場合にのみ必須で、それ以外の場合は無視されます。
  • encoding <string> key が文字列の場合に使用する文字列エンコーディング。
• 戻り値: <KeyObject>

公開鍵を含む新しいキーオブジェクトを作成して返します。key が文字列または Buffer の場合、format は 'pem' と見なされます。key が型 'private' の KeyObject の場合、公開鍵は指定された秘密鍵から派生します。それ以外の場合、key は上記のプロパティを持つオブジェクトでなければなりません。

フォーマットが 'pem' の場合、'key' は X.509 証明書にすることもできます。

公開鍵は秘密鍵から派生させることができるため、公開鍵の代わりに秘密鍵を渡すこともできます。その場合、この関数は、返される KeyObject の型が 'public' であり、返された KeyObject から秘密鍵を抽出できないことを除いて、crypto.createPrivateKey() が呼び出されたかのように動作します。同様に、型 'private' の KeyObject が指定された場合、型 'public' の新しい KeyObject が返され、返されたオブジェクトから秘密鍵を抽出することはできなくなります。

crypto.createSecretKey(key[, encoding])#

• key <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• encoding <string> key が文字列の場合の文字列エンコーディング。
• 戻り値: <KeyObject>

対称暗号化または Hmac 用の秘密鍵を含む新しいキーオブジェクトを作成して返します。

crypto.createSign(algorithm[, options])#

• algorithm <string>
• options <Object> stream.Writable のオプション
• 戻り値: <Sign>

指定された algorithm を使用する Sign オブジェクトを作成して返します。利用可能なダイジェストアルゴリズムの名前を取得するには crypto.getHashes() を使用してください。オプションの options 引数は stream.Writable の動作を制御します。

場合によっては、ダイジェストアルゴリズムの代わりに 'RSA-SHA256' のような署名アルゴリズムの名前を使用して Sign インスタンスを作成できます。これにより、対応するダイジェストアルゴリズムが使用されます。これは 'ecdsa-with-SHA256' のようなすべての署名アルゴリズムで機能するわけではないため、常にダイジェストアルゴリズム名を使用するのが最善です。

crypto.createVerify(algorithm[, options])#

• algorithm <string>
• options <Object> stream.Writable のオプション
• 戻り値: <Verify>

指定されたアルゴリズムを使用する Verify オブジェクトを作成して返します。利用可能な署名アルゴリズムの名前の配列を取得するには crypto.getHashes() を使用してください。オプションの options 引数は stream.Writable の動作を制御します。

場合によっては、ダイジェストアルゴリズムの代わりに 'RSA-SHA256' のような署名アルゴリズムの名前を使用して Verify インスタンスを作成できます。これにより、対応するダイジェストアルゴリズムが使用されます。これは 'ecdsa-with-SHA256' のようなすべての署名アルゴリズムで機能するわけではないため、常にダイジェストアルゴリズム名を使用するのが最善です。

crypto.decapsulate(key, ciphertext[, callback])#

• key <Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> 秘密鍵
• ciphertext <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
• callback <Function>
  • `err` <Error>
  • sharedKey <Buffer>
• 戻り値: callback 関数が提供されない場合は <Buffer>。

秘密鍵を持つ KEM アルゴリズムを使用した鍵のカプセル化解除。

サポートされているキーの種類とその KEM アルゴリズムは次のとおりです。

• 'rsa'² RSA 秘密値カプセル化
• 'ec'³ DHKEM(P-256, HKDF-SHA256), DHKEM(P-384, HKDF-SHA256), DHKEM(P-521, HKDF-SHA256)
• 'x25519'³ DHKEM(X25519, HKDF-SHA256)
• 'x448'³ DHKEM(X448, HKDF-SHA512)
• 'ml-kem-512'¹ ML-KEM
• 'ml-kem-768'¹ ML-KEM
• 'ml-kem-1024'¹ ML-KEM

key が KeyObject でない場合、この関数は key が crypto.createPrivateKey() に渡されたかのように動作します。

callback 関数が提供された場合、この関数は libuv のスレッドプールを使用します。

crypto.diffieHellman(options[, callback])#

• options <Object>
  • privateKey <KeyObject>
  • publicKey <KeyObject>
• callback <Function>
  • `err` <Error>
  • secret <Buffer>
• 戻り値: callback 関数が提供されない場合は <Buffer>。

privateKey と publicKey に基づいてディフィー・ヘルマン共有秘密鍵を計算します。両方の鍵は同じ asymmetricKeyType を持ち、DH または ECDH 操作のいずれかをサポートしている必要があります。

callback 関数が提供された場合、この関数は libuv のスレッドプールを使用します。

crypto.encapsulate(key[, callback])#

• key <Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> 公開鍵
• callback <Function>
  • `err` <Error>
  • result <Object>
    • sharedKey <Buffer>
    • ciphertext <Buffer>
• 戻り値: callback 関数が提供されない場合は <Object>。
  • sharedKey <Buffer>
  • ciphertext <Buffer>

公開鍵を持つ KEM アルゴリズムを使用した鍵のカプセル化。

サポートされているキーの種類とその KEM アルゴリズムは次のとおりです。

• 'rsa'² RSA 秘密値カプセル化
• 'ec'³ DHKEM(P-256, HKDF-SHA256), DHKEM(P-384, HKDF-SHA256), DHKEM(P-521, HKDF-SHA256)
• 'x25519'³ DHKEM(X25519, HKDF-SHA256)
• 'x448'³ DHKEM(X448, HKDF-SHA512)
• 'ml-kem-512'¹ ML-KEM
• 'ml-kem-768'¹ ML-KEM
• 'ml-kem-1024'¹ ML-KEM

key が KeyObject でない場合、この関数は key が crypto.createPublicKey() に渡されたかのように動作します。

callback 関数が提供された場合、この関数は libuv のスレッドプールを使用します。

crypto.fips#

FIPS 準拠の暗号プロバイダが現在使用されているかどうかを確認および制御するためのプロパティ。true に設定するには Node.js の FIPS ビルドが必要です。

このプロパティは非推奨です。代わりに crypto.setFips() と crypto.getFips() を使用してください。

crypto.generateKey(type, options, callback)#

• type <string> 生成された秘密鍵の意図された用途。現在受け入れられている値は 'hmac' と 'aes' です。
• options <Object>
  • length <number> 生成するキーのビット長。これは 0 より大きい値でなければなりません。
    • type が 'hmac' の場合、最小値は 8、最大長は 2³¹-1 です。値が 8 の倍数でない場合、生成されたキーは Math.floor(length / 8) に切り捨てられます。
    • type が 'aes' の場合、長さは 128、192、または 256 のいずれかでなければなりません。
• callback <Function>
  • `err` <Error>
  • key <KeyObject>

指定された length の新しいランダムな秘密鍵を非同期で生成します。type は、length に対して実行される検証を決定します。

const {
  generateKey,
} = await import('node:crypto');

generateKey('hmac', { length: 512 }, (err, key) => {
  if (err) throw err;
  console.log(key.export().toString('hex'));  // 46e..........620
});const {
  generateKey,
} = require('node:crypto');

generateKey('hmac', { length: 512 }, (err, key) => {
  if (err) throw err;
  console.log(key.export().toString('hex'));  // 46e..........620
});copy

生成された HMAC キーのサイズは、基礎となるハッシュ関数のブロックサイズを超えてはなりません。詳細については crypto.createHmac() を参照してください。

crypto.generateKeyPair(type, options, callback)#

• type <string> 生成する非対称鍵の種類。サポートされている非対称鍵の種類を参照してください。
• options <Object>
  • modulusLength <number> 鍵サイズ（ビット単位）（RSA, DSA）。
  • publicExponent <number> 公開指数 (RSA)。デフォルト: 0x10001。
  • hashAlgorithm <string> メッセージダイジェストの名前（RSA-PSS）。
  • mgf1HashAlgorithm <string> MGF1 で使用されるメッセージダイジェストの名前（RSA-PSS）。
  • saltLength <number> 最小ソルト長（バイト単位）（RSA-PSS）。
  • divisorLength <number> q のサイズ（ビット単位）（DSA）。
  • namedCurve <string> 使用する曲線の名前 (EC)。
  • prime <Buffer> 素数パラメータ (DH)。
  • primeLength <number> ビット単位の素数の長さ (DH)。
  • generator <number> カスタムジェネレータ (DH)。デフォルト: 2。
  • groupName <string> Diffie-Hellman グループ名 (DH)。crypto.getDiffieHellman() を参照してください。
  • paramEncoding <string> 'named' または 'explicit' でなければなりません (EC)。デフォルト: 'named'。
  • publicKeyEncoding <Object> keyObject.export() を参照してください。
  • privateKeyEncoding <Object> keyObject.export() を参照してください。
• callback <Function>
  • `err` <Error>
  • publicKey <string> | <Buffer> | <KeyObject>
  • privateKey <string> | <Buffer> | <KeyObject>

指定された type の新しい非対称鍵ペアを生成します。現在、RSA、RSA-PSS、DSA、EC、Ed25519、Ed448、X25519、X448、および DH がサポートされています。

publicKeyEncoding または privateKeyEncoding が指定された場合、この関数は、その結果に対して keyObject.export() が呼び出されたかのように動作します。それ以外の場合、鍵のそれぞれの部分は KeyObject として返されます。

長期保存のためには、公開鍵は 'spki' として、秘密鍵は 'pkcs8' と暗号化を用いてエンコードすることが推奨されます。

const {
  generateKeyPair,
} = await import('node:crypto');

generateKeyPair('rsa', {
  modulusLength: 4096,
  publicKeyEncoding: {
    type: 'spki',
    format: 'pem',
  },
  privateKeyEncoding: {
    type: 'pkcs8',
    format: 'pem',
    cipher: 'aes-256-cbc',
    passphrase: 'top secret',
  },
}, (err, publicKey, privateKey) => {
  // Handle errors and use the generated key pair.
});const {
  generateKeyPair,
} = require('node:crypto');

generateKeyPair('rsa', {
  modulusLength: 4096,
  publicKeyEncoding: {
    type: 'spki',
    format: 'pem',
  },
  privateKeyEncoding: {
    type: 'pkcs8',
    format: 'pem',
    cipher: 'aes-256-cbc',
    passphrase: 'top secret',
  },
}, (err, publicKey, privateKey) => {
  // Handle errors and use the generated key pair.
});copy

完了すると、err が undefined に設定され、生成された鍵ペアを表す publicKey / privateKey と共に callback が呼び出されます。

このメソッドが util.promisify() 化されたバージョンとして呼び出された場合、publicKey と privateKey プロパティを持つ Object の Promise を返します。

crypto.generateKeyPairSync(type, options)#

• type <string> 生成する非対称鍵の種類。サポートされている非対称鍵の種類を参照してください。
• options <Object>
  • modulusLength <number> 鍵サイズ（ビット単位）（RSA, DSA）。
  • publicExponent <number> 公開指数 (RSA)。デフォルト: 0x10001。
  • hashAlgorithm <string> メッセージダイジェストの名前（RSA-PSS）。
  • mgf1HashAlgorithm <string> MGF1 で使用されるメッセージダイジェストの名前（RSA-PSS）。
  • saltLength <number> 最小ソルト長（バイト単位）（RSA-PSS）。
  • divisorLength <number> q のサイズ（ビット単位）（DSA）。
  • namedCurve <string> 使用する曲線の名前 (EC)。
  • prime <Buffer> 素数パラメータ (DH)。
  • primeLength <number> ビット単位の素数の長さ (DH)。
  • generator <number> カスタムジェネレータ (DH)。デフォルト: 2。
  • groupName <string> Diffie-Hellman グループ名 (DH)。crypto.getDiffieHellman() を参照してください。
  • paramEncoding <string> 'named' または 'explicit' でなければなりません (EC)。デフォルト: 'named'。
  • publicKeyEncoding <Object> keyObject.export() を参照してください。
  • privateKeyEncoding <Object> keyObject.export() を参照してください。
• 戻り値: <Object>
  • publicKey <string> | <Buffer> | <KeyObject>
  • privateKey <string> | <Buffer> | <KeyObject>

指定された type の新しい非対称鍵ペアを生成します。現在、RSA、RSA-PSS、DSA、EC、Ed25519、Ed448、X25519、X448、DH、および ML-DSA¹ がサポートされています。

publicKeyEncoding または privateKeyEncoding が指定された場合、この関数は、その結果に対して keyObject.export() が呼び出されたかのように動作します。それ以外の場合、鍵のそれぞれの部分は KeyObject として返されます。

公開鍵をエンコードする際には 'spki' を使用することが推奨されます。秘密鍵をエンコードする際には、強力なパスフレーズと共に 'pkcs8' を使用し、パスフレーズを秘密に保つことが推奨されます。

const {
  generateKeyPairSync,
} = await import('node:crypto');

const {
  publicKey,
  privateKey,
} = generateKeyPairSync('rsa', {
  modulusLength: 4096,
  publicKeyEncoding: {
    type: 'spki',
    format: 'pem',
  },
  privateKeyEncoding: {
    type: 'pkcs8',
    format: 'pem',
    cipher: 'aes-256-cbc',
    passphrase: 'top secret',
  },
});const {
  generateKeyPairSync,
} = require('node:crypto');

const {
  publicKey,
  privateKey,
} = generateKeyPairSync('rsa', {
  modulusLength: 4096,
  publicKeyEncoding: {
    type: 'spki',
    format: 'pem',
  },
  privateKeyEncoding: {
    type: 'pkcs8',
    format: 'pem',
    cipher: 'aes-256-cbc',
    passphrase: 'top secret',
  },
});copy

戻り値 { publicKey, privateKey } は生成された鍵ペアを表します。PEM エンコーディングが選択された場合、それぞれの鍵は文字列になります。それ以外の場合は、DER としてエンコードされたデータを含むバッファになります。

crypto.generateKeySync(type, options)#

• type <string> 生成された秘密鍵の意図された用途。現在受け入れられている値は 'hmac' と 'aes' です。
• options <Object>
  • length <number> 生成する鍵のビット長。
    • type が 'hmac' の場合、最小値は 8、最大長は 2³¹-1 です。値が 8 の倍数でない場合、生成されたキーは Math.floor(length / 8) に切り捨てられます。
    • type が 'aes' の場合、長さは 128、192、または 256 のいずれかでなければなりません。
• 戻り値: <KeyObject>

指定された length の新しいランダムな秘密鍵を同期的に生成します。type は、length に対してどの検証が実行されるかを決定します。

const {
  generateKeySync,
} = await import('node:crypto');

const key = generateKeySync('hmac', { length: 512 });
console.log(key.export().toString('hex'));  // e89..........41econst {
  generateKeySync,
} = require('node:crypto');

const key = generateKeySync('hmac', { length: 512 });
console.log(key.export().toString('hex'));  // e89..........41ecopy

生成された HMAC キーのサイズは、基礎となるハッシュ関数のブロックサイズを超えてはなりません。詳細については crypto.createHmac() を参照してください。

crypto.generatePrime(size[, options], callback)#

• size <number> 生成する素数のサイズ (ビット単位)。
• options <Object>
  • add <ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint>
  • rem <ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint>
  • safe <boolean> デフォルト: false。
  • bigint <boolean> true の場合、生成された素数は bigint として返されます。
• callback <Function>
  • `err` <Error>
  • prime <ArrayBuffer> | <bigint>

size ビットの擬似ランダムな素数を生成します。

options.safe が true の場合、素数は安全素数になります。つまり、(prime - 1) / 2 も素数になります。

options.add と options.rem パラメータは、例えば Diffie-Hellman のための追加要件を強制するために使用できます。

• options.add と options.rem の両方が設定されている場合、素数は prime % add = rem という条件を満たします。
• options.add のみが設定され、options.safe が true でない場合、素数は prime % add = 1 という条件を満たします。
• options.add のみが設定され、options.safe が true に設定されている場合、素数は代わりに prime % add = 3 という条件を満たします。これは、options.add > 2 の場合に prime % add = 1 となると、options.safe によって強制される条件と矛盾するため必要です。
• options.add が与えられていない場合、options.rem は無視されます。

options.add と options.rem の両方は、ArrayBuffer、SharedArrayBuffer、TypedArray、Buffer、または DataView として与えられた場合、ビッグエンディアンシーケンスとしてエンコードされなければなりません。

デフォルトでは、素数は <ArrayBuffer> 内のオクテットのビッグエンディアンシーケンスとしてエンコードされます。bigint オプションが true の場合、<bigint> が提供されます。

素数の size は、素数を生成するのにかかる時間に直接影響します。サイズが大きくなるほど、時間がかかります。私たちは OpenSSL の BN_generate_prime_ex 関数を使用しており、これは生成プロセスを中断する能力を最小限しか制御できないため、過度に大きな素数を生成することは推奨されません。そうするとプロセスが応答しなくなる可能性があります。

crypto.generatePrimeSync(size[, options])#

• size <number> 生成する素数のサイズ (ビット単位)。
• options <Object>
  • add <ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint>
  • rem <ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint>
  • safe <boolean> デフォルト: false。
  • bigint <boolean> true の場合、生成された素数は bigint として返されます。
• 戻り値: <ArrayBuffer> | <bigint>

size ビットの擬似ランダムな素数を生成します。

options.safe が true の場合、素数は安全素数になります。つまり、(prime - 1) / 2 も素数になります。

options.add と options.rem パラメータは、例えば Diffie-Hellman のための追加要件を強制するために使用できます。

• options.add と options.rem の両方が設定されている場合、素数は prime % add = rem という条件を満たします。
• options.add のみが設定され、options.safe が true でない場合、素数は prime % add = 1 という条件を満たします。
• options.add のみが設定され、options.safe が true に設定されている場合、素数は代わりに prime % add = 3 という条件を満たします。これは、options.add > 2 の場合に prime % add = 1 となると、options.safe によって強制される条件と矛盾するため必要です。
• options.add が与えられていない場合、options.rem は無視されます。

options.add と options.rem の両方は、ArrayBuffer、SharedArrayBuffer、TypedArray、Buffer、または DataView として与えられた場合、ビッグエンディアンシーケンスとしてエンコードされなければなりません。

デフォルトでは、素数は <ArrayBuffer> 内のオクテットのビッグエンディアンシーケンスとしてエンコードされます。bigint オプションが true の場合、<bigint> が提供されます。

素数の size は、素数を生成するのにかかる時間に直接影響します。サイズが大きくなるほど、時間がかかります。私たちは OpenSSL の BN_generate_prime_ex 関数を使用しており、これは生成プロセスを中断する能力を最小限しか制御できないため、過度に大きな素数を生成することは推奨されません。そうするとプロセスが応答しなくなる可能性があります。

crypto.getCipherInfo(nameOrNid[, options])#

• nameOrNid <string> | <number> 問い合わせる暗号の名前または nid。
• options <Object>
  • keyLength <number> テスト用の鍵長。
  • ivLength <number> テスト用の IV 長。
• 戻り値: <Object>
  • name <string> 暗号の名前
  • nid <number> 暗号の nid
  • blockSize <number> 暗号のブロックサイズ (バイト単位)。このプロパティは mode が 'stream' の場合は省略されます。
  • ivLength <number> 期待される、またはデフォルトの初期化ベクトルの長さ (バイト単位)。このプロパティは、暗号が初期化ベクトルを使用しない場合は省略されます。
  • keyLength <number> 期待される、またはデフォルトの鍵長 (バイト単位)。
  • mode <string> 暗号モード。'cbc'、'ccm'、'cfb'、'ctr'、'ecb'、'gcm'、'ocb'、'ofb'、'stream'、'wrap'、'xts' のいずれか。

指定された暗号に関する情報を返します。

一部の暗号は可変長の鍵と初期化ベクトルを受け入れます。デフォルトでは、crypto.getCipherInfo() メソッドはこれらの暗号のデフォルト値を返します。特定の鍵長または IV 長が特定の暗号で許容されるかどうかをテストするには、keyLength および ivLength オプションを使用します。指定された値が許容されない場合、undefined が返されます。

crypto.getCiphers()#

• 戻り値: <string[]> サポートされている暗号アルゴリズムの名前を持つ配列。

const {
  getCiphers,
} = await import('node:crypto');

console.log(getCiphers()); // ['aes-128-cbc', 'aes-128-ccm', ...]const {
  getCiphers,
} = require('node:crypto');

console.log(getCiphers()); // ['aes-128-cbc', 'aes-128-ccm', ...]copy

crypto.getCurves()#

• 戻り値: <string[]> サポートされている楕円曲線の名前を持つ配列。

const {
  getCurves,
} = await import('node:crypto');

console.log(getCurves()); // ['Oakley-EC2N-3', 'Oakley-EC2N-4', ...]const {
  getCurves,
} = require('node:crypto');

console.log(getCurves()); // ['Oakley-EC2N-3', 'Oakley-EC2N-4', ...]copy

crypto.getDiffieHellman(groupName)#

• groupName <string>
• 戻り値: <DiffieHellmanGroup>

事前定義された DiffieHellmanGroup 鍵交換オブジェクトを作成します。サポートされているグループは、DiffieHellmanGroup のドキュメントにリストされています。

返されたオブジェクトは crypto.createDiffieHellman() によって作成されたオブジェクトのインターフェースを模倣しますが、(例えば diffieHellman.setPublicKey() を使って) 鍵を変更することはできません。このメソッドを使用する利点は、当事者が事前にグループモジュラスを生成したり交換したりする必要がなく、プロセッサと通信時間の両方を節約できることです。

例 (共有秘密の取得)

const {
  getDiffieHellman,
} = await import('node:crypto');
const alice = getDiffieHellman('modp14');
const bob = getDiffieHellman('modp14');

alice.generateKeys();
bob.generateKeys();

const aliceSecret = alice.computeSecret(bob.getPublicKey(), null, 'hex');
const bobSecret = bob.computeSecret(alice.getPublicKey(), null, 'hex');

/* aliceSecret and bobSecret should be the same */
console.log(aliceSecret === bobSecret);const {
  getDiffieHellman,
} = require('node:crypto');

const alice = getDiffieHellman('modp14');
const bob = getDiffieHellman('modp14');

alice.generateKeys();
bob.generateKeys();

const aliceSecret = alice.computeSecret(bob.getPublicKey(), null, 'hex');
const bobSecret = bob.computeSecret(alice.getPublicKey(), null, 'hex');

/* aliceSecret and bobSecret should be the same */
console.log(aliceSecret === bobSecret);copy

crypto.getFips()#

• 戻り値: <number> FIPS 準拠の暗号プロバイダが現在使用されている場合に限り 1、それ以外の場合は 0。将来のセマンティックバージョニングのメジャーリリースで、この API の戻り値の型が <boolean> に変更される可能性があります。

crypto.getHashes()#

• 戻り値: <string[]> 'RSA-SHA256' のような、サポートされているハッシュアルゴリズムの名前の配列。ハッシュアルゴリズムは「ダイジェスト」アルゴリズムとも呼ばれます。

const {
  getHashes,
} = await import('node:crypto');

console.log(getHashes()); // ['DSA', 'DSA-SHA', 'DSA-SHA1', ...]const {
  getHashes,
} = require('node:crypto');

console.log(getHashes()); // ['DSA', 'DSA-SHA', 'DSA-SHA1', ...]copy

crypto.getRandomValues(typedArray)#

• typedArray <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer>
• 戻り値: <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> typedArray を返します。

crypto.webcrypto.getRandomValues() の便利なエイリアスです。この実装は Web Crypto 仕様に準拠していません。Web 互換のコードを書くには、代わりに crypto.webcrypto.getRandomValues() を使用してください。

crypto.hash(algorithm, data[, options])#

• algorithm <string> | <undefined>
• data <string> | <Buffer> | <TypedArray> | <DataView> data が文字列の場合、ハッシュ化される前に UTF-8 としてエンコードされます。文字列の入力に対して異なる入力エンコーディングが必要な場合、ユーザーは TextEncoder または Buffer.from() を使用して文字列を TypedArray にエンコードし、エンコードされた TypedArray をこの API に渡すことができます。
• options <Object> | <string>
  • outputEncoding <string> 返されたダイジェストをエンコードするために使用されるエンコーディング。デフォルト: 'hex'。
  • outputLength <number> 'shake256' などの XOF ハッシュ関数では、outputLength オプションを使用して、希望する出力長をバイト単位で指定できます。
• 戻り値: <string> | <Buffer>

データのワンショットハッシュダイジェストを作成するためのユーティリティです。すぐに利用可能な少量のデータ（5MB 以下）をハッシュ化する場合、オブジェクトベースの crypto.createHash() よりも高速になることがあります。データが大きい場合やストリーミングされる場合は、引き続き crypto.createHash() を使用することが推奨されます。

algorithm は、プラットフォーム上の OpenSSL のバージョンでサポートされている利用可能なアルゴリズムに依存します。例としては 'sha256'、'sha512' などがあります。最近の OpenSSL リリースでは、openssl list -digest-algorithms で利用可能なダイジェストアルゴリズムが表示されます。

options が文字列の場合、それは outputEncoding を指定します。

例

const crypto = require('node:crypto');
const { Buffer } = require('node:buffer');

// Hashing a string and return the result as a hex-encoded string.
const string = 'Node.js';
// 10b3493287f831e81a438811a1ffba01f8cec4b7
console.log(crypto.hash('sha1', string));

// Encode a base64-encoded string into a Buffer, hash it and return
// the result as a buffer.
const base64 = 'Tm9kZS5qcw==';
// <Buffer 10 b3 49 32 87 f8 31 e8 1a 43 88 11 a1 ff ba 01 f8 ce c4 b7>
console.log(crypto.hash('sha1', Buffer.from(base64, 'base64'), 'buffer'));import crypto from 'node:crypto';
import { Buffer } from 'node:buffer';

// Hashing a string and return the result as a hex-encoded string.
const string = 'Node.js';
// 10b3493287f831e81a438811a1ffba01f8cec4b7
console.log(crypto.hash('sha1', string));

// Encode a base64-encoded string into a Buffer, hash it and return
// the result as a buffer.
const base64 = 'Tm9kZS5qcw==';
// <Buffer 10 b3 49 32 87 f8 31 e8 1a 43 88 11 a1 ff ba 01 f8 ce c4 b7>
console.log(crypto.hash('sha1', Buffer.from(base64, 'base64'), 'buffer'));copy

crypto.hkdf(digest, ikm, salt, info, keylen, callback)#

• digest <string> 使用するダイジェストアルゴリズム。
• ikm <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> 入力キーイングマテリアル。提供する必要がありますが、ゼロ長でもかまいません。
• salt <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> ソルト値。提供する必要がありますが、ゼロ長でもかまいません。
• info <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 追加の情報値。提供する必要がありますが、ゼロ長でもかまいません。また、1024バイトを超えることはできません。
• keylen <number> 生成する鍵の長さ。0 より大きくなければなりません。許容される最大値は、選択されたダイジェスト関数によって生成されるバイト数の 255 倍です（例: sha512 は 64 バイトのハッシュを生成し、最大の HKDF 出力は 16320 バイトになります）。
• callback <Function>
  • `err` <Error>
  • derivedKey <ArrayBuffer>

HKDF は RFC 5869 で定義されている単純な鍵導出関数です。与えられた ikm、salt、info は、digest と共に使用され、keylen バイトの鍵を導出します。

提供された callback 関数は、2つの引数 err と derivedKey で呼び出されます。鍵の導出中にエラーが発生した場合、err が設定されます。それ以外の場合、err は null になります。正常に生成された derivedKey は、<ArrayBuffer> としてコールバックに渡されます。いずれかの入力引数が無効な値または型を指定した場合、エラーがスローされます。

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

hkdf('sha512', 'key', 'salt', 'info', 64, (err, derivedKey) => {
  if (err) throw err;
  console.log(Buffer.from(derivedKey).toString('hex'));  // '24156e2...5391653'
});const {
  hkdf,
} = require('node:crypto');
const { Buffer } = require('node:buffer');

hkdf('sha512', 'key', 'salt', 'info', 64, (err, derivedKey) => {
  if (err) throw err;
  console.log(Buffer.from(derivedKey).toString('hex'));  // '24156e2...5391653'
});copy

crypto.hkdfSync(digest, ikm, salt, info, keylen)#

• digest <string> 使用するダイジェストアルゴリズム。
• ikm <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> 入力キーイングマテリアル。提供する必要がありますが、ゼロ長でもかまいません。
• salt <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> ソルト値。提供する必要がありますが、ゼロ長でもかまいません。
• info <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 追加の情報値。提供する必要がありますが、ゼロ長でもかまいません。また、1024バイトを超えることはできません。
• keylen <number> 生成する鍵の長さ。0 より大きくなければなりません。許容される最大値は、選択されたダイジェスト関数によって生成されるバイト数の 255 倍です（例: sha512 は 64 バイトのハッシュを生成し、最大の HKDF 出力は 16320 バイトになります）。
• 戻り値: <ArrayBuffer>

RFC 5869 で定義されている同期的な HKDF 鍵導出関数を提供します。与えられた ikm、salt、info は、digest と共に使用され、keylen バイトの鍵を導出します。

正常に生成された derivedKey は、<ArrayBuffer> として返されます。

いずれかの入力引数が無効な値または型を指定した場合、または派生鍵が生成できない場合、エラーがスローされます。

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

const derivedKey = hkdfSync('sha512', 'key', 'salt', 'info', 64);
console.log(Buffer.from(derivedKey).toString('hex'));  // '24156e2...5391653'const {
  hkdfSync,
} = require('node:crypto');
const { Buffer } = require('node:buffer');

const derivedKey = hkdfSync('sha512', 'key', 'salt', 'info', 64);
console.log(Buffer.from(derivedKey).toString('hex'));  // '24156e2...5391653'copy

crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)#