Crypto | Node.js v21.7.2 ドキュメント

Crypto#

ソースコード: lib/crypto.js

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:
//   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658econst { createHmac } = require('node:crypto');

const secret = 'abcdefg';
const hash = createHmac('sha256', secret)
               .update('I love cupcakes')
               .digest('hex');
console.log(hash);
// Prints:
//   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e

暗号化サポートが利用できないかどうかの判定#

Node.js が node:crypto モジュールのサポートを含まずにビルドされる可能性があります。そのような場合、crypto から import を試みるか、require('node:crypto') を呼び出すと、エラーがスローされます。

CommonJS を使用する場合、スローされたエラーは try/catch を使用してキャッチできます。

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

字句 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!');
}

クラス: `Certificate`#

追加: v0.11.8

SPKAC は、元々 Netscape によって実装された証明書署名要求メカニズムであり、HTML5 の keygen 要素の一部として正式に指定されました。

<keygen> は HTML 5.2 以降非推奨となり、新しいプロジェクトではこの要素を使用すべきではありません。

node:crypto モジュールは、SPKAC データを扱うための Certificate クラスを提供します。最も一般的な使用法は、HTML5 <keygen> 要素によって生成された出力を処理することです。Node.js は内部的に OpenSSL の SPKAC 実装を使用します。

静的メソッド: `Certificate.exportChallenge(spkac[, encoding])`#

履歴

バージョン	変更点
v15.0.0	spkac 引数は ArrayBuffer にすることができます。spkac 引数のサイズを最大 2**31 - 1 バイトに制限しました。
v9.0.0	追加: v9.0.0

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 string

静的メソッド: `Certificate.exportPublicKey(spkac[, encoding])`#

履歴

バージョン	変更点
v15.0.0	spkac 引数は ArrayBuffer にすることができます。spkac 引数のサイズを最大 2**31 - 1 バイトに制限しました。
v9.0.0	追加: v9.0.0

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

静的メソッド: `Certificate.verifySpkac(spkac[, encoding])`#

履歴

バージョン	変更点
v15.0.0	spkac 引数は ArrayBuffer にすることができます。エンコーディングを追加しました。spkac 引数のサイズを最大 2**31 - 1 バイトに制限しました。
v9.0.0	追加: v9.0.0

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 false

レガシー API#

安定度: 0 - 非推奨

レガシーインターフェイスとして、以下の例に示すように crypto.Certificate クラスの新しいインスタンスを作成できます。

`new crypto.Certificate()`#

Certificateクラスのインスタンスは、newキーワードを使用するか、関数として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();

`certificate.exportChallenge(spkac[, encoding])`#

追加: v0.11.8

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 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 string

`certificate.exportPublicKey(spkac[, encoding])`#

追加: v0.11.8

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

`certificate.verifySpkac(spkac[, encoding])`#

追加: v0.11.8

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 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 false

クラス: `Cipher`#

追加: v0.1.94

拡張: <stream.Transform>

Cipherクラスのインスタンスは、データを暗号化するために使用されます。このクラスは、次の2つの方法で使用できます。

読み取り可能かつ書き込み可能なストリームとして。プレーンな暗号化されていないデータが書き込まれ、読み取り側で暗号化されたデータが生成されます。または
cipher.update()メソッドとcipher.final()メソッドを使用して暗号化されたデータを生成します。

Cipherインスタンスを作成するには、crypto.createCipher()メソッドまたはcrypto.createCipheriv()メソッドを使用します。Cipherオブジェクトは、newキーワードを使用して直接作成することはできません。

例: Cipherオブジェクトをストリームとして使用する

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

例: Cipherとパイプされたストリームを使用する

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

例: 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);
  });
});

`cipher.final([outputEncoding])`#

追加: v0.1.94

outputEncoding <string> 返り値のエンコーディング。
戻り値: <Buffer> | <string> 暗号化された残りのコンテンツ。outputEncodingが指定されている場合は、文字列が返されます。outputEncodingが指定されていない場合は、Bufferが返されます。

cipher.final()メソッドが呼び出されると、Cipherオブジェクトはそれ以上データを暗号化するために使用できなくなります。cipher.final()を複数回呼び出そうとすると、エラーがスローされます。

`cipher.getAuthTag()`#

追加: v1.0.0

戻り値: <Buffer> 認証付き暗号化モード（現在、GCM、CCM、OCB、およびchacha20-poly1305がサポートされています）を使用する場合、cipher.getAuthTag()メソッドは、指定されたデータから計算された認証タグを含むBufferを返します。

cipher.getAuthTag()メソッドは、cipher.final()メソッドを使用して暗号化が完了した後にのみ呼び出す必要があります。

cipherインスタンスの作成時にauthTagLengthオプションが設定されている場合、この関数は正確にauthTagLengthバイトを返します。

`cipher.setAAD(buffer[, options])`#

追加: v1.0.0

buffer <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
options <Object> stream.transform オプション
- plaintextLength <number>
- encoding <string> bufferが文字列の場合に使用する文字列エンコーディング。
戻り値: <Cipher> メソッドチェーン用の同じCipherインスタンス。

認証付き暗号化モード（現在、GCM、CCM、OCB、およびchacha20-poly1305がサポートされています）を使用する場合、cipher.setAAD()メソッドは、追加認証データ（AAD）入力パラメータに使用される値を設定します。

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

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

`cipher.setAutoPadding([autoPadding])`#

追加: v0.7.1

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

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

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

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

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

履歴

バージョン	変更点
v6.0.0	デフォルトの`inputEncoding`が`binary`から`utf8`に変更されました。
v0.1.94	追加: v0.1.94

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.final()が呼び出されるまで、cipher.update()メソッドを新しいデータで複数回呼び出すことができます。cipher.final()の後にcipher.update()を呼び出すと、エラーがスローされます。

クラス: `Decipher`#

追加: v0.1.94

拡張: <stream.Transform>

Decipherクラスのインスタンスは、データを復号化するために使用されます。このクラスは、次の2つの方法で使用できます。

読み取り可能かつ書き込み可能なストリームとして。プレーンな暗号化されたデータが書き込まれ、読み取り側で暗号化されていないデータが生成されます。または
decipher.update()メソッドとdecipher.final()メソッドを使用して、暗号化されていないデータを生成します。

Decipherインスタンスを作成するには、crypto.createDecipher()メソッドまたはcrypto.createDecipheriv()メソッドを使用します。Decipherオブジェクトは、newキーワードを使用して直接作成することはできません。

例: Decipherオブジェクトをストリームとして使用する

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

例: Decipherとパイプされたストリームを使用する

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

例: 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 dataconst {
  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

`decipher.final([outputEncoding])`#

追加: v0.1.94

outputEncoding <string> 返り値のエンコーディング。
戻り値: <Buffer> | <string> 復号化された残りのコンテンツ。outputEncodingが指定されている場合は、文字列が返されます。outputEncodingが指定されていない場合は、Bufferが返されます。

decipher.final()メソッドが呼び出されると、Decipherオブジェクトはそれ以上データを復号化するために使用できなくなります。decipher.final()を複数回呼び出そうとすると、エラーがスローされます。

`decipher.setAAD(buffer[, options])`#

履歴

バージョン	変更点
v15.0.0	buffer引数は、文字列またはArrayBufferにでき、最大2 ** 31-1バイトに制限されています。
v7.2.0	このメソッドは、`decipher`への参照を返すようになりました。
v1.0.0	追加: v1.0.0

buffer <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
options <Object> stream.transform オプション
- plaintextLength <number>
- encoding <string> bufferが文字列の場合に使用する文字列エンコーディング。
戻り値: <Decipher> メソッドチェーンのために同じ Decipher を返します。

認証付き暗号化モード（現在、GCM、CCM、OCB、および chacha20-poly1305 がサポートされています）を使用する場合、decipher.setAAD() メソッドは、追加認証データ（AAD）入力パラメーターに使用する値を設定します。

options 引数は GCM ではオプションです。CCM を使用する場合、plaintextLength オプションを指定する必要があり、その値は暗号文のバイト長と一致する必要があります。「CCM モード」を参照してください。

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

buffer として文字列を渡す場合は、「暗号化 API への入力として文字列を使用する際の注意点」を考慮してください。

`decipher.setAuthTag(buffer[, encoding])`#

履歴

バージョン	変更点
v15.0.0	buffer引数は、文字列またはArrayBufferにでき、最大2 ** 31-1バイトに制限されています。
v11.0.0	このメソッドは、GCM タグの長さが無効な場合に例外をスローするようになりました。
v7.2.0	このメソッドは、`decipher`への参照を返すようになりました。
v1.0.0	追加: v1.0.0

buffer <string> | <Buffer> | <ArrayBuffer> | <TypedArray> | <DataView>
encoding <string> bufferが文字列の場合に使用する文字列エンコーディング。
戻り値: <Decipher> メソッドチェーンのために同じ 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])`#

追加: v0.7.1

autoPadding <boolean> デフォルト: true
戻り値: <Decipher> メソッドチェーンのために同じ Decipher を返します。

データが標準のブロックパディングなしで暗号化されている場合、decipher.setAutoPadding(false) を呼び出すと、decipher.final() がパディングを確認して削除するのを防ぐために、自動パディングが無効になります。

自動パディングをオフにすると、入力データの長さが暗号のブロックサイズの倍数である場合にのみ機能します。

decipher.setAutoPadding() メソッドは、decipher.final() より前に呼び出す必要があります。

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

履歴

バージョン	変更点
v6.0.0	デフォルトの`inputEncoding`が`binary`から`utf8`に変更されました。
v0.1.94	追加: v0.1.94

data <string> | <Buffer> | <TypedArray> | <DataView>
inputEncoding <string> data 文字列のエンコーディング。
outputEncoding <string> 返り値のエンコーディング。
戻り値: <Buffer> | <string>

data で復号器を更新します。inputEncoding 引数が指定されている場合、data 引数は指定されたエンコーディングを使用する文字列です。inputEncoding 引数が指定されていない場合、data は Buffer である必要があります。data が Buffer の場合、inputEncoding は無視されます。

decipher.update() メソッドは、decipher.final() が呼び出されるまで、新しいデータで複数回呼び出すことができます。 decipher.final() の後に decipher.update() を呼び出すと、エラーがスローされます。

クラス: `DiffieHellman`#

追加: v0.5.0

DiffieHellman クラスは、Diffie-Hellman 鍵交換を作成するためのユーティリティです。

DiffieHellman クラスのインスタンスは、crypto.createDiffieHellman() 関数を使用して作成できます。

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

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

追加: v0.5.0

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])`#

追加: v0.5.0

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

プライベートおよびパブリック Diffie-Hellman 鍵値がまだ生成または計算されていない場合は生成し、指定された encoding で公開鍵を返します。この鍵は相手側に転送する必要があります。encoding が指定されている場合は文字列が返されます。それ以外の場合は Buffer が返されます。

この関数は、DH_generate_key() の薄いラッパーです。特に、プライベートキーが生成または設定された後、この関数を呼び出すと公開鍵のみが更新されますが、新しいプライベートキーは生成されません。

`diffieHellman.getGenerator([encoding])`#

追加: v0.5.0

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

指定された encoding で Diffie-Hellman ジェネレーターを返します。encoding が指定されている場合は文字列が返されます。それ以外の場合は Buffer が返されます。

`diffieHellman.getPrime([encoding])`#

追加: v0.5.0

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

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

`diffieHellman.getPrivateKey([encoding])`#

追加: v0.5.0

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

指定された encoding で Diffie-Hellman プライベートキーを返します。encoding が指定されている場合は文字列が返されます。それ以外の場合は Buffer が返されます。

`diffieHellman.getPublicKey([encoding])`#

追加: v0.5.0

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

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

`diffieHellman.setPrivateKey(privateKey[, encoding])`#

追加: v0.5.0

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])`#

追加: v0.5.0

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

Diffie-Hellman 公開鍵を設定します。encoding 引数が指定されている場合、publicKey は文字列であると想定されます。encoding が指定されていない場合、publicKey は Buffer、TypedArray、または DataView であると想定されます。

`diffieHellman.verifyError`#

追加: v0.11.12

DiffieHellman オブジェクトの初期化中に実行されたチェックの結果として生じた警告やエラーを含むビットフィールド。

このプロパティには、以下の値が有効です（node:constants モジュールで定義されているとおり）。

DH_CHECK_P_NOT_SAFE_PRIME
DH_CHECK_P_NOT_PRIME
DH_UNABLE_TO_CHECK_GENERATOR
DH_NOT_SUITABLE_GENERATOR

クラス: `DiffieHellmanGroup`#

追加: v0.7.5

DiffieHellmanGroup クラスは、既知の modp グループを引数として取ります。作成後にキーの変更を許可しないことを除いて、DiffieHellman と同じように機能します。言い換えれば、setPublicKey() メソッドや setPrivateKey() メソッドは実装しません。

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

次のグループがサポートされています

'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`#

追加: v0.11.14

ECDH クラスは、楕円曲線 Diffie-Hellman (ECDH) 鍵交換を作成するためのユーティリティです。

ECDH クラスのインスタンスは、crypto.createECDH() 関数を使用して作成できます。

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'));
// OKconst 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

静的メソッド: `ECDH.convertKey(key, curve[, inputEncoding[, outputEncoding[, format]]])`#

追加: v10.0.0

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

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

履歴

バージョン	変更点
v10.0.0	無効な公開鍵エラーをより適切にサポートするようにエラー形式を変更しました。
v6.0.0	デフォルトの`inputEncoding`が`binary`から`utf8`に変更されました。
v0.11.14	追加: v0.11.14

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]])`#

追加: v0.11.14

encoding <string> 戻り値のエンコーディング。
format <string> デフォルト: 'uncompressed'
戻り値: <Buffer> | <string>

プライベートおよびパブリック EC Diffie-Hellman キー値を生成し、指定された format および encoding で公開鍵を返します。このキーは相手に転送する必要があります。

format 引数はポイントエンコーディングを指定し、'compressed' または 'uncompressed' を指定できます。format が指定されていない場合、ポイントは 'uncompressed' 形式で返されます。

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

`ecdh.getPrivateKey([encoding])`#

追加: v0.11.14

encoding <string> 戻り値のエンコーディング。
戻り値: <Buffer> | <string> 指定された encoding の EC Diffie-Hellman。

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

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

追加: v0.11.14

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

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

`ecdh.setPrivateKey(privateKey[, encoding])`#

追加: v0.11.14

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])`#

追加: v0.11.14非推奨: v5.2.0 以降

安定度: 0 - 非推奨

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

クラス: `Hash`#

追加: v0.1.92

拡張: <stream.Transform>

Hash クラスは、データのハッシュダイジェストを作成するためのユーティリティです。次の 2 つの方法で使用できます。

読み取り可能と書き込み可能の両方のストリームとして。ここで、データが書き込まれて、読み取り可能な側で計算されたハッシュダイジェストが生成されます。または
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();

例: 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);

例: 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:
//   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50const {
  createHash,
} = require('node:crypto');

const hash = createHash('sha256');

hash.update('some data to hash');
console.log(hash.digest('hex'));
// Prints:
//   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50

`hash.copy([options])`#

追加: v13.1.0

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.

`hash.digest([encoding])`#

追加: v0.1.92

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

hash.update() メソッドを使用してハッシュされるように渡されたすべてのデータのダイジェストを計算します。encoding が指定された場合、文字列が返されます。それ以外の場合は、Buffer が返されます。

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

`hash.update(data[, inputEncoding])`#

履歴

バージョン	変更点
v6.0.0	デフォルトの`inputEncoding`が`binary`から`utf8`に変更されました。
v0.1.92	追加: v0.1.92

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

指定された data でハッシュコンテンツを更新します。data のエンコーディングは inputEncoding で指定されます。encoding が指定されておらず、data が文字列の場合、'utf8' のエンコーディングが強制されます。data が Buffer、TypedArray、または DataView の場合、inputEncoding は無視されます。

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

クラス: `Hmac`#

追加: v0.1.94

拡張: <stream.Transform>

Hmac クラスは、暗号化 HMAC ダイジェストを作成するためのユーティリティです。次の 2 つの方法で使用できます。

読み取り可能と書き込み可能の両方のストリームとして。ここで、データが書き込まれて、読み取り可能な側で計算された 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();

例: 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);

例: 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:
//   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77econst {
  createHmac,
} = require('node:crypto');

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

hmac.update('some data to hash');
console.log(hmac.digest('hex'));
// Prints:
//   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e

`hmac.digest([encoding])`#

追加: v0.1.94

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

hmac.update() を使用して渡されたすべてのデータの HMAC ダイジェストを計算します。encoding が指定された場合、文字列が返されます。それ以外の場合は、Buffer が返されます。

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

`hmac.update(data[, inputEncoding])`#

履歴

バージョン	変更点
v6.0.0	デフォルトの`inputEncoding`が`binary`から`utf8`に変更されました。
v0.1.94	追加: v0.1.94

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

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

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

クラス: `KeyObject`#

履歴

バージョン	変更点
v14.5.0, v12.19.0	このクラスのインスタンスは、`postMessage` を使用してワーカースレッドに渡せるようになりました。
v11.13.0	このクラスがエクスポートされるようになりました。
v11.6.0	追加: v11.6.0

Node.js は、対称鍵または非対称鍵を表現するために KeyObject クラスを使用し、それぞれの種類の鍵は異なる関数を公開します。crypto.createSecretKey(), crypto.createPublicKey(), crypto.createPrivateKey() メソッドは、KeyObject インスタンスを作成するために使用されます。KeyObject オブジェクトは、new キーワードを使用して直接作成してはいけません。

ほとんどのアプリケーションでは、セキュリティ機能が向上しているため、鍵を文字列や Buffer として渡す代わりに、新しい KeyObject API を使用することを検討する必要があります。

KeyObject インスタンスは、postMessage() を介して他のスレッドに渡すことができます。受信側はクローンされた KeyObject を取得し、KeyObject は transferList 引数にリストする必要はありません。

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

追加: v15.0.0

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

`keyObject.asymmetricKeyDetails`#

履歴

バージョン	変更点
v16.9.0	RSA-PSS 鍵の `RSASSA-PSS-params` シーケンスパラメータを公開。
v15.7.0	追加: v15.7.0

<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`#

履歴

バージョン	変更点
v13.9.0, v12.17.0	`'dh'` のサポートが追加されました。
v12.0.0	`'rsa-pss'` のサポートが追加されました。
v12.0.0	このプロパティは、認識されない型の KeyObject インスタンスに対してアボートするのではなく、`undefined` を返すようになりました。
v12.0.0	`'x25519'` および `'x448'` のサポートが追加されました。
v12.0.0	`'ed25519'` および `'ed448'` のサポートが追加されました。
v11.6.0	追加: v11.6.0

<string>

非対称キーの場合、このプロパティはキーのタイプを表します。サポートされているキータイプは次のとおりです。

'rsa' (OID 1.2.840.113549.1.1.1)
'rsa-pss' (OID 1.2.840.113549.1.1.10)
'dsa' (OID 1.2.840.10040.4.1)
'ec' (OID 1.2.840.10045.2.1)
'x25519' (OID 1.3.101.110)
'x448' (OID 1.3.101.111)
'ed25519' (OID 1.3.101.112)
'ed448' (OID 1.3.101.113)
'dh' (OID 1.2.840.113549.1.3.1)

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

`keyObject.export([options])`#

履歴

バージョン	変更点
v15.9.0	`'jwk'` 形式のサポートが追加されました。
v11.6.0	追加: v11.6.0

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.equals(otherKeyObject)`#

追加: v17.7.0, v16.15.0

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

キーのタイプ、値、およびパラメータが完全に同じかどうかによって、true または false を返します。このメソッドは、一定時間ではありません。

`keyObject.symmetricKeySize`#

追加: v11.6.0

<number>

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

`keyObject.type`#

追加: v11.6.0

<string>

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

クラス: `Sign`#

追加: v0.1.92

拡張: <stream.Writable>

Sign クラスは、署名を生成するためのユーティリティです。次の 2 つの方法で使用できます。

署名するデータを書き込む書き込み可能なストリームとして。その場合、sign.sign() メソッドを使用して署名を生成して返します。または
sign.update() および sign.sign() メソッドを使用して署名を生成します。

crypto.createSign() メソッドは、Sign インスタンスを作成するために使用されます。引数は、使用するハッシュ関数の文字列名です。Sign オブジェクトは、new キーワードを使用して直接作成してはいけません。

例: Sign および Verify オブジェクトをストリームとして使用する

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

const { privateKey, publicKey } = generateKeyPairSync('ec', {
  namedCurve: 'sect239k1',
});

const sign = createSign('SHA256');
sign.write('some data to sign');
sign.end();
const signature = sign.sign(privateKey, 'hex');

const verify = createVerify('SHA256');
verify.write('some data to sign');
verify.end();
console.log(verify.verify(publicKey, signature, 'hex'));
// Prints: trueconst {
  generateKeyPairSync,
  createSign,
  createVerify,
} = require('node:crypto');

const { privateKey, publicKey } = generateKeyPairSync('ec', {
  namedCurve: 'sect239k1',
});

const sign = createSign('SHA256');
sign.write('some data to sign');
sign.end();
const signature = sign.sign(privateKey, 'hex');

const verify = createVerify('SHA256');
verify.write('some data to sign');
verify.end();
console.log(verify.verify(publicKey, signature, 'hex'));
// Prints: true

例: sign.update() および verify.update() メソッドを使用する

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

const { privateKey, publicKey } = generateKeyPairSync('rsa', {
  modulusLength: 2048,
});

const sign = createSign('SHA256');
sign.update('some data to sign');
sign.end();
const signature = sign.sign(privateKey);

const verify = createVerify('SHA256');
verify.update('some data to sign');
verify.end();
console.log(verify.verify(publicKey, signature));
// Prints: trueconst {
  generateKeyPairSync,
  createSign,
  createVerify,
} = require('node:crypto');

const { privateKey, publicKey } = generateKeyPairSync('rsa', {
  modulusLength: 2048,
});

const sign = createSign('SHA256');
sign.update('some data to sign');
sign.end();
const signature = sign.sign(privateKey);

const verify = createVerify('SHA256');
verify.update('some data to sign');
verify.end();
console.log(verify.verify(publicKey, signature));
// Prints: true

`sign.sign(privateKey[, outputEncoding])`#

履歴

バージョン	変更点
v15.0.0	privateKey は、ArrayBuffer および CryptoKey にすることもできます。
v13.2.0, v12.16.0	この関数は、IEEE-P1363 DSA および ECDSA 署名をサポートするようになりました。
v12.0.0	この関数は、RSA-PSS キーをサポートするようになりました。
v11.6.0	この関数は、キーオブジェクトをサポートするようになりました。
v8.0.0	RSASSA-PSS のサポートと追加オプションが追加されました。
v0.1.92	追加: v0.1.92

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.1 で指定されているメッセージの署名に使用されるのと同じハッシュ関数を持つ MGF1 を使用します。ただし、MGF1 ハッシュ関数が RFC 4055 のセクション 3.3 に準拠したキーの一部として指定されている場合は除きます。
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])`#

履歴

バージョン	変更点
v6.0.0	デフォルトの`inputEncoding`が`binary`から`utf8`に変更されました。
v0.1.92	追加: v0.1.92

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

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

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

クラス: `Verify`#

追加: v0.1.92

拡張: <stream.Writable>

Verify クラスは、署名を検証するためのユーティリティです。次の 2 つの方法で使用できます。

書き込み可能なストリームとして。ここで、書き込まれたデータは、提供された署名に対して検証するために使用されます。または
verify.update() および verify.verify() メソッドを使用して署名を検証します。

crypto.createVerify() メソッドは、Verify インスタンスを作成するために使用されます。Verify オブジェクトは、new キーワードを使用して直接作成することはできません。

例については、Sign を参照してください。

`verify.update(data[, inputEncoding])`#

履歴

バージョン	変更点
v6.0.0	デフォルトの`inputEncoding`が`binary`から`utf8`に変更されました。
v0.1.92	追加: v0.1.92

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

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

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

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

履歴

バージョン	変更点
v15.0.0	オブジェクトは ArrayBuffer および CryptoKey にすることもできます。
v13.2.0, v12.16.0	この関数は、IEEE-P1363 DSA および ECDSA 署名をサポートするようになりました。
v12.0.0	この関数は、RSA-PSS キーをサポートするようになりました。
v11.7.0	キーは、秘密鍵にすることもできるようになりました。
v8.0.0	RSASSA-PSS のサポートと追加オプションが追加されました。
v0.1.92	追加: v0.1.92

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.1 で指定されているメッセージの検証に使用されるのと同じハッシュ関数を持つ MGF1 を使用します。ただし、MGF1 ハッシュ関数が RFC 4055 のセクション 3.3 に準拠したキーの一部として指定されている場合は除きます。
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() を複数回呼び出すと、エラーがスローされます。

公開鍵は秘密鍵から導出できるため、公開鍵の代わりに秘密鍵を渡すことができます。

クラス: `X509Certificate`#

追加: v15.6.0

X509 証明書をカプセル化し、その情報への読み取り専用アクセスを提供します。

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

const x509 = new X509Certificate('{... pem encoded cert ...}');

console.log(x509.subject);const { X509Certificate } = require('node:crypto');

const x509 = new X509Certificate('{... pem encoded cert ...}');

console.log(x509.subject);

`new X509Certificate(buffer)`#

追加: v15.6.0

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

`x509.ca`#

追加: v15.6.0

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

`x509.checkEmail(email[, options])`#

履歴

バージョン	変更点
v18.0.0	subject オプションは、デフォルトで `'default'` になりました。
v17.5.0、v16.15.0	subject オプションを `'default'` に設定できるようになりました。
v17.5.0、v16.14.1	`wildcards`、`partialWildcards`、`multiLabelWildcards`、および `singleLabelSubdomains` オプションは、効果がないため削除されました。
v15.6.0	追加: v15.6.0

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

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

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

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

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

`x509.checkHost(name[, options])`#

履歴

バージョン	変更点
v18.0.0	subject オプションは、デフォルトで `'default'` になりました。
v17.5.0、v16.15.0	subject オプションを `'default'` に設定できるようになりました。
v15.6.0	追加: v15.6.0

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 に一致するサブジェクト名を返し、サブジェクト名が name に一致しない場合は undefined を返します。

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

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

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

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

`x509.checkIP(ip)`#

履歴

バージョン	変更点
v17.5.0、v16.14.1	`options` 引数は効果がないため削除されました。
v15.6.0	追加: v15.6.0

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

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

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

`x509.checkIssued(otherCert)`#

追加: v15.6.0

otherCert <X509Certificate>
戻り値: <boolean>

この証明書が指定された otherCert によって発行されたかどうかを確認します。

`x509.checkPrivateKey(privateKey)`#

追加: v15.6.0

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

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

`x509.fingerprint`#

追加: v15.6.0

型: <string>

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

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

`x509.fingerprint256`#

追加: v15.6.0

型: <string>

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

`x509.fingerprint512`#

追加: v17.2.0, v16.14.0

型: <string>

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

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

`x509.infoAccess`#

履歴

バージョン	変更点
v17.3.1, v16.13.2	CVE-2021-44532への対応として、この文字列の一部がJSON文字列リテラルとしてエンコードされる場合があります。
v15.6.0	追加: v15.6.0

型: <string>

証明書の認証局情報アクセス拡張のテキスト表現。

これは、アクセス記述の改行区切りリストです。各行は、アクセス方法とアクセス場所の種類で始まり、コロンとアクセス場所に関連付けられた値が続きます。

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

`x509.issuer`#

追加: v15.6.0

型: <string>

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

`x509.issuerCertificate`#

追加: v15.9.0

型: <X509Certificate>

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

`x509.extKeyUsage`#

追加: v15.6.0

型: <string[]>

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

`x509.publicKey`#

追加: v15.6.0

型: <KeyObject>

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

`x509.raw`#

追加: v15.6.0

型: <Buffer>

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

`x509.serialNumber`#

追加: v15.6.0

型: <string>

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

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

`x509.subject`#

追加: v15.6.0

型: <string>

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

`x509.subjectAltName`#

履歴

バージョン	変更点
v17.3.1, v16.13.2	CVE-2021-44532への対応として、この文字列の一部がJSON文字列リテラルとしてエンコードされる場合があります。
v15.6.0	追加: v15.6.0

型: <string>

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

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

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

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

`x509.toJSON()`#

追加: v15.6.0

型: <string>

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

`x509.toLegacyObject()`#

追加: v15.6.0

型: <Object>

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

`x509.toString()`#

追加: v15.6.0

型: <string>

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

`x509.validFrom`#

追加: v15.6.0

型: <string>

この証明書が有効になる日付/時刻。

`x509.validTo`#

追加: v15.6.0

型: <string>

この証明書が有効期限切れになる日付/時刻。

`x509.verify(publicKey)`#

追加: v15.6.0

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

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

`node:crypto` モジュールのメソッドとプロパティ#

`crypto.constants`#

追加: v6.3.0

<Object>

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

`crypto.fips`#

追加: v6.0.0非推奨: v10.0.0以降

安定度: 0 - 非推奨

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

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

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

履歴

バージョン	変更点
v18.0.0	`callback` 引数に無効なコールバックを渡すと、`ERR_INVALID_CALLBACK` ではなく、`ERR_INVALID_ARG_TYPE` がスローされるようになりました。
v15.8.0	追加: v15.8.0

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

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

`crypto.checkPrimeSync(candidate[, options])`#

追加: v15.8.0

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

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

`crypto.createCipher(algorithm, password[, options])`#

履歴

バージョン	変更点
v17.9.0, v16.17.0	`chacha20-poly1305`暗号を使用する際の`authTagLength`オプションがオプションになり、デフォルトで16バイトになりました。
v15.0.0	password引数はArrayBufferにすることができ、最大2 ** 31 - 1バイトに制限されます。
v10.10.0	OCBモードの暗号がサポートされるようになりました。
v10.2.0	`authTagLength`オプションを使用して、GCMモードでより短い認証タグを生成できるようになり、デフォルトで16バイトになりました。
v10.0.0	非推奨: v10.0.0以降
v0.1.94	追加: v0.1.94

安定性: 0 - 非推奨: 代わりにcrypto.createCipheriv()を使用してください。

algorithm <string>
password <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
options <Object> stream.transform オプション
戻り値: <Cipher>

指定されたalgorithmとpasswordを使用するCipherオブジェクトを作成して返します。

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

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

passwordは、暗号鍵と初期化ベクトル（IV）を導出するために使用されます。値は、'latin1'エンコードされた文字列、Buffer、TypedArray、またはDataViewのいずれかである必要があります。

この関数は、サポートされているすべての暗号に対して意味的に安全ではなく、カウンタモード（CTR、GCM、CCMなど）の暗号に対しては致命的な欠陥があります。

crypto.createCipher()の実装では、OpenSSL関数EVP_BytesToKeyを使用して、ダイジェストアルゴリズムをMD5に設定し、1回の反復処理、ソルトなしでキーを導出します。ソルトがないと、同じパスワードで常に同じキーが作成されるため、辞書攻撃が可能になります。反復回数が少なく、暗号学的に安全でないハッシュアルゴリズムを使用すると、パスワードを非常に迅速にテストできます。

EVP_BytesToKeyの代わりに、よりモダンなアルゴリズムを使用するというOpenSSLの推奨に従い、開発者はcrypto.scrypt()を使用してキーとIVを独自に導出し、crypto.createCipheriv()を使用してCipherオブジェクトを作成することを推奨します。ユーザーは、crypto.createCipher()でカウンターモード（CTR、GCM、CCMなど）の暗号を使用しないでください。脆弱性を引き起こすIVの再利用のリスクを回避するために、使用時に警告が発せられます。 GCMでIVが再利用された場合の詳細については、Nonce-Disrespecting Adversariesを参照してください。

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

履歴

バージョン	変更点
v17.9.0, v16.17.0	`chacha20-poly1305`暗号を使用する際の`authTagLength`オプションがオプションになり、デフォルトで16バイトになりました。
v15.0.0	passwordとiv引数はArrayBufferにすることができ、それぞれ最大2 ** 31 - 1バイトに制限されます。
v11.6.0	`key`引数は、`KeyObject`にすることができるようになりました。
v11.2.0, v10.17.0	暗号`chacha20-poly1305`（ChaCha20-Poly1305のIETFバリアント）がサポートされるようになりました。
v10.10.0	OCBモードの暗号がサポートされるようになりました。
v10.2.0	`authTagLength`オプションを使用して、GCMモードでより短い認証タグを生成できるようになり、デフォルトで16バイトになりました。
v9.9.0	初期化ベクトルを必要としない暗号では、`iv`パラメーターを`null`にできるようになりました。
v0.1.94	追加: v0.1.94

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

指定されたalgorithm、key、初期化ベクトル（iv）を使用して、Cipherオブジェクトを作成して返します。

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

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

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

`crypto.createDecipher(algorithm, password[, options])`#

履歴

バージョン	変更点
v17.9.0, v16.17.0	`chacha20-poly1305`暗号を使用する際の`authTagLength`オプションがオプションになり、デフォルトで16バイトになりました。
v10.10.0	OCBモードの暗号がサポートされるようになりました。
v10.0.0	非推奨: v10.0.0以降
v0.1.94	追加: v0.1.94

安定性: 0 - 非推奨: 代わりにcrypto.createDecipheriv()を使用してください。

algorithm <string>
password <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
options <Object> stream.transform オプション
戻り値: <Decipher>

指定されたalgorithmとpassword（キー）を使用するDecipherオブジェクトを作成して返します。

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

crypto.createDecipher()の実装では、OpenSSL関数EVP_BytesToKeyを使用して、ダイジェストアルゴリズムをMD5に設定し、1回の反復処理、ソルトなしでキーを導出します。ソルトがないと、同じパスワードで常に同じキーが作成されるため、辞書攻撃が可能になります。反復回数が少なく、暗号学的に安全でないハッシュアルゴリズムを使用すると、パスワードを非常に迅速にテストできます。

EVP_BytesToKeyの代わりに、よりモダンなアルゴリズムを使用するというOpenSSLの推奨に従い、開発者はcrypto.scrypt()を使用してキーとIVを独自に導出し、crypto.createDecipheriv()を使用してDecipherオブジェクトを作成することを推奨します。

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

履歴

バージョン	変更点
v17.9.0, v16.17.0	`chacha20-poly1305`暗号を使用する際の`authTagLength`オプションがオプションになり、デフォルトで16バイトになりました。
v11.6.0	`key`引数は、`KeyObject`にすることができるようになりました。
v11.2.0, v10.17.0	暗号`chacha20-poly1305`（ChaCha20-Poly1305のIETFバリアント）がサポートされるようになりました。
v10.10.0	OCBモードの暗号がサポートされるようになりました。
v10.2.0	`authTagLength`オプションを使用して、受け入れられるGCM認証タグの長さを制限できるようになりました。
v9.9.0	初期化ベクトルを必要としない暗号では、`iv`パラメーターを`null`にできるようになりました。
v0.1.94	追加: v0.1.94

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

指定されたalgorithm、key、初期化ベクトル（iv）を使用するDecipherオブジェクトを作成して返します。

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

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

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

履歴

バージョン	変更点
v8.0.0	`prime`引数は、任意の`TypedArray`または`DataView`にすることができるようになりました。
v8.0.0	`prime`引数は、`Uint8Array`にすることができるようになりました。
v6.0.0	エンコードパラメーターのデフォルトが`binary`から`utf8`に変更されました。
v0.11.12	追加: v0.11.12

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])`#

追加: v0.5.0

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

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

`crypto.createDiffieHellmanGroup(name)`#

追加: v0.9.3

name <string>
戻り値: <DiffieHellmanGroup>

crypto.getDiffieHellman()のエイリアスです。

`crypto.createECDH(curveName)`#

追加: v0.11.14

curveName <string>
戻り値: <ECDH>

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

`crypto.createHash(algorithm[, options])`#

履歴

バージョン	変更点
v12.8.0	XOFハッシュ関数用に`outputLength`オプションが追加されました。
v0.1.92	追加: v0.1.92

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

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

履歴

バージョン	変更点
v15.0.0	キーは、ArrayBufferまたはCryptoKeyにすることもできます。エンコーディングオプションが追加されました。キーには2 ** 32 - 1バイトを超えることはできません。
v11.6.0	`key`引数は、`KeyObject`にすることができるようになりました。
v0.1.94	追加: v0.1.94

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

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

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

`crypto.createPrivateKey(key)`#

履歴

バージョン	変更点
v15.12.0	キーはJWKオブジェクトにもできます。
v15.0.0	キーはArrayBufferにすることもできます。エンコーディングオプションが追加されました。キーには2 ** 32 - 1バイトを超えることはできません。
v11.6.0	追加: v11.6.0

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)`#

履歴

バージョン	変更点
v15.12.0	キーはJWKオブジェクトにもできます。
v15.0.0	キーはArrayBufferにすることもできます。エンコーディングオプションが追加されました。キーには2 ** 32 - 1バイトを超えることはできません。
v11.13.0	`key`引数は、タイプが`private`の`KeyObject`にすることができます。
v11.7.0	`key`引数は秘密鍵にすることができます。
v11.6.0	追加: v11.6.0

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証明書にすることもできます。

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

`crypto.createSecretKey(key[, encoding])`#

履歴

バージョン	変更点
v18.8.0、v16.18.0	キーはゼロ長にすることができます。
v15.0.0	キーは、ArrayBufferまたは文字列にすることもできます。エンコーディング引数が追加されました。キーには2 ** 32 - 1バイトを超えることはできません。
v11.6.0	追加: v11.6.0

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

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

`crypto.createSign(algorithm[, options])`#

追加: v0.1.92

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

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

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

`crypto.createVerify(algorithm[, options])`#

追加: v0.1.92

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

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

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

`crypto.diffieHellman(options)`#

追加: v13.9.0、v12.17.0

options: <Object>
- privateKey: <KeyObject>
- publicKey: <KeyObject>
戻り値: <Buffer>

privateKeyとpublicKeyに基づいてDiffie-Hellmanシークレットを計算します。両方のキーは、asymmetricKeyTypeが同じである必要があり、'dh'（Diffie-Hellmanの場合）、'ec'（ECDHの場合）、'x448'、または'x25519'（ECDH-ESの場合）のいずれかである必要があります。

`crypto.hash(algorithm, data[, outputEncoding])`#

追加: v21.7.0

安定性: 1.2 - リリース候補

algorithm <string> | <undefined>
data <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> data が文字列の場合、ハッシュ化される前に UTF-8 としてエンコードされます。文字列入力に異なる入力エンコーディングが必要な場合は、TextEncoder または Buffer.from() を使用して文字列を TypedArray にエンコードし、エンコードされた TypedArray を代わりにこの API に渡すことができます。
outputEncoding <string> | <undefined> エンコーディングは、返されるダイジェストをエンコードするために使用されます。デフォルト: 'hex'。
戻り値: <string> | <Buffer>

データのワンショットハッシュダイジェストを作成するためのユーティリティです。比較的小さいデータ（<= 5MB）がすぐに利用可能な場合、オブジェクトベースの crypto.createHash() よりも高速になる場合があります。データが大きい場合やストリーム化される場合は、代わりに crypto.createHash() を使用することをお勧めします。

例

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

`crypto.generateKey(type, options, callback)`#

履歴

バージョン	変更点
v18.0.0	`callback` 引数に無効なコールバックを渡すと、`ERR_INVALID_CALLBACK` ではなく、`ERR_INVALID_ARG_TYPE` がスローされるようになりました。
v15.0.0	追加: v15.0.0

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

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

`crypto.generateKeyPair(type, options, callback)`#

履歴

バージョン	変更点
v18.0.0	`callback` 引数に無効なコールバックを渡すと、`ERR_INVALID_CALLBACK` ではなく、`ERR_INVALID_ARG_TYPE` がスローされるようになりました。
v16.10.0	RSA-PSS キーペアの `RSASSA-PSS-params` シーケンスパラメータを定義する機能を追加しました。
v13.9.0, v12.17.0	Diffie-Hellman のサポートを追加しました。
v12.0.0	RSA-PSS キーペアのサポートを追加しました。
v12.0.0	X25519 および X448 キーペアを生成する機能を追加しました。
v12.0.0	Ed25519 および Ed448 キーペアを生成する機能を追加しました。
v11.6.0	`generateKeyPair` および `generateKeyPairSync` 関数は、エンコーディングが指定されていない場合、キーオブジェクトを生成するようになりました。
v10.12.0	追加: v10.12.0

type: <string> 'rsa'、'rsa-pss'、'dsa'、'ec'、'ed25519'、'ed448'、'x25519'、'x448'、または 'dh' である必要があります。
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.
});

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

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

`crypto.generateKeyPairSync(type, options)`#

履歴

バージョン	変更点
v16.10.0	RSA-PSS キーペアの `RSASSA-PSS-params` シーケンスパラメータを定義する機能を追加しました。
v13.9.0, v12.17.0	Diffie-Hellman のサポートを追加しました。
v12.0.0	RSA-PSS キーペアのサポートを追加しました。
v12.0.0	X25519 および X448 キーペアを生成する機能を追加しました。
v12.0.0	Ed25519 および Ed448 キーペアを生成する機能を追加しました。
v11.6.0	`generateKeyPair` および `generateKeyPairSync` 関数は、エンコーディングが指定されていない場合、キーオブジェクトを生成するようになりました。
v10.12.0	追加: v10.12.0

type: <string> 'rsa'、'rsa-pss'、'dsa'、'ec'、'ed25519'、'ed448'、'x25519'、'x448'、または 'dh' である必要があります。
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 がサポートされています。

公開鍵をエンコードする場合は、'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',
  },
});

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

`crypto.generateKeySync(type, options)`#

追加: v15.0.0

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..........41e

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

履歴

バージョン	変更点
v18.0.0	`callback` 引数に無効なコールバックを渡すと、`ERR_INVALID_CALLBACK` ではなく、`ERR_INVALID_ARG_TYPE` がスローされるようになりました。
v15.8.0	追加: v15.8.0

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> が提供されます。

`crypto.generatePrimeSync(size[, options])`#

追加: v15.8.0

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 は無視されます。

`crypto.getCipherInfo(nameOrNid[, options])`#

追加: v15.0.0

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()`#

追加: v0.9.3

戻り値: <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', ...]

`crypto.getCurves()`#

追加: v2.3.0

戻り値: <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', ...]

`crypto.getDiffieHellman(groupName)`#

追加: v0.7.5

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

`crypto.getFips()`#

追加: v10.0.0

戻り値: <number> FIPS 準拠の暗号プロバイダーが現在使用中の場合にのみ 1、それ以外の場合は 0。今後のセムバーメジャーリリースでは、この API の戻り値の型が <boolean> に変更される可能性があります。

`crypto.getHashes()`#

追加: v0.9.3

戻り値: <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', ...]

`crypto.getRandomValues(typedArray)`#

追加: v17.4.0

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

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

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

履歴

バージョン	変更点
v18.0.0	`callback` 引数に無効なコールバックを渡すと、`ERR_INVALID_CALLBACK` ではなく、`ERR_INVALID_ARG_TYPE` がスローされるようになりました。
v18.8.0、v16.18.0	入力鍵マテリアルはゼロ長にすることができます。
v15.0.0	追加: v15.0.0

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

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

履歴

バージョン	変更点
v18.8.0、v16.18.0	入力鍵マテリアルはゼロ長にすることができます。
v15.0.0	追加: v15.0.0

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'

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

履歴

バージョン	変更点
v18.0.0	`callback` 引数に無効なコールバックを渡すと、`ERR_INVALID_CALLBACK` ではなく、`ERR_INVALID_ARG_TYPE` がスローされるようになりました。
v15.0.0	password および salt 引数は、ArrayBuffer インスタンスにすることもできます。
v14.0.0	`iterations` パラメーターは、正の値に制限されるようになりました。以前のリリースでは、他の値は 1 として扱われていました。
v8.0.0	`digest` パラメーターは常に必須になりました。
v6.0.0	`digest` パラメーターを渡さずにこの関数を呼び出すことは非推奨となり、警告が表示されるようになりました。
v6.0.0	文字列の場合の `password` のデフォルトのエンコードが、`binary` から `utf8` に変更されました。
v0.5.5	追加: v0.5.5

password <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
salt <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
iterations <number>
keylen <number>
digest <string>
callback <Function>
- err <Error>
- derivedKey <Buffer>

非同期のパスワードベース鍵導出関数2（PBKDF2）の実装を提供します。digestで指定された選択されたHMACダイジェストアルゴリズムが、password、salt、およびiterationsから、要求されたバイト長（keylen）の鍵を導出するために適用されます。

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

iterations引数は、できるだけ高い数に設定された数値である必要があります。反復回数が大きいほど、導出された鍵はより安全になりますが、完了までに時間がかかります。

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

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

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

pbkdf2('secret', 'salt', 100000, 64, 'sha512', (err, derivedKey) => {
  if (err) throw err;
  console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'
});const {
  pbkdf2,
} = require('node:crypto');

pbkdf2('secret', 'salt', 100000, 64, 'sha512', (err, derivedKey) => {
  if (err) throw err;
  console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'
});

サポートされているダイジェスト関数の配列は、crypto.getHashes()を使用して取得できます。

このAPIはlibuvのスレッドプールを使用します。これは一部のアプリケーションで驚くべき悪影響を与える可能性があります。詳細については、UV_THREADPOOL_SIZEのドキュメントを参照してください。

`crypto.pbkdf2Sync(password, salt, iterations, keylen, digest)`#

履歴

バージョン	変更点
v14.0.0	`iterations` パラメーターは、正の値に制限されるようになりました。以前のリリースでは、他の値は 1 として扱われていました。
v6.0.0	`digest` パラメーターを渡さずにこの関数を呼び出すことは非推奨となり、警告が表示されるようになりました。
v6.0.0	文字列の場合の `password` のデフォルトのエンコードが、`binary` から `utf8` に変更されました。
v0.9.3	追加: v0.9.3

password <string> | <Buffer> | <TypedArray> | <DataView>
salt <string> | <Buffer> | <TypedArray> | <DataView>
iterations <number>
keylen <number>
digest <string>
戻り値: <Buffer>

同期のパスワードベース鍵導出関数2（PBKDF2）の実装を提供します。digestで指定された選択されたHMACダイジェストアルゴリズムが、password、salt、およびiterationsから、要求されたバイト長（keylen）の鍵を導出するために適用されます。

エラーが発生した場合はErrorがスローされます。それ以外の場合は、導出された鍵がBufferとして返されます。

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

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

const key = pbkdf2Sync('secret', 'salt', 100000, 64, 'sha512');
console.log(key.toString('hex'));  // '3745e48...08d59ae'const {
  pbkdf2Sync,
} = require('node:crypto');

const key = pbkdf2Sync('secret', 'salt', 100000, 64, 'sha512');
console.log(key.toString('hex'));  // '3745e48...08d59ae'

サポートされているダイジェスト関数の配列は、crypto.getHashes()を使用して取得できます。

`crypto.privateDecrypt(privateKey, buffer)`#

履歴

バージョン	変更点
v21.6.2, v20.11.1, v18.19.1	OpenSSLビルドが暗黙の拒否をサポートしていない限り、`RSA_PKCS1_PADDING`パディングは無効になりました。
v15.0.0	キータイプとして、string、ArrayBuffer、およびCryptoKeyが許可されるようになりました。oaepLabelはArrayBufferにすることができます。bufferはstringまたはArrayBufferにできます。バッファを受け入れるすべての型は、最大2 ** 31 - 1バイトに制限されています。
v12.11.0	`oaepLabel`オプションが追加されました。
v12.9.0	`oaepHash`オプションが追加されました。
v11.6.0	この関数は、キーオブジェクトをサポートするようになりました。
v0.11.14	追加: v0.11.14

privateKey <Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>
- oaepHash <string> OAEPパディングとMGF1に使用するハッシュ関数。デフォルト: 'sha1'
- oaepLabel <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> OAEPパディングに使用するラベル。指定しない場合、ラベルは使用されません。
- padding <crypto.constants> crypto.constantsで定義されたオプションのパディング値。これは、crypto.constants.RSA_NO_PADDING、crypto.constants.RSA_PKCS1_PADDING、またはcrypto.constants.RSA_PKCS1_OAEP_PADDINGである可能性があります。
buffer <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
戻り値: <Buffer> 復号化されたコンテンツを含む新しいBuffer。

bufferをprivateKeyで復号化します。bufferは、たとえばcrypto.publicEncrypt()を使用して、対応する公開鍵を使用して以前に暗号化されました。

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

crypto.privateDecrypt()でcrypto.constants.RSA_PKCS1_PADDINGを使用するには、OpenSSLが暗黙の拒否（rsa_pkcs1_implicit_rejection）をサポートしている必要があります。Node.jsで使用されているOpenSSLのバージョンがこの機能をサポートしていない場合、RSA_PKCS1_PADDINGを使用しようとすると失敗します。

`crypto.privateEncrypt(privateKey, buffer)`#

履歴

バージョン	変更点
v15.0.0	キータイプとして、string、ArrayBuffer、およびCryptoKeyが許可されるようになりました。パスフレーズはArrayBufferにすることができます。bufferはstringまたはArrayBufferにできます。バッファを受け入れるすべての型は、最大2 ** 31 - 1バイトに制限されています。
v11.6.0	この関数は、キーオブジェクトをサポートするようになりました。
v1.1.0	追加: v1.1.0

privateKey <Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>
- key <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey> PEMエンコードされた秘密鍵。
- passphrase <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 秘密鍵のオプションのパスフレーズ。
- padding <crypto.constants> crypto.constantsで定義されたオプションのパディング値。これは、crypto.constants.RSA_NO_PADDINGまたはcrypto.constants.RSA_PKCS1_PADDINGである可能性があります。
- encoding <string> buffer、key、またはpassphraseが文字列の場合に使用する文字列エンコーディング。
buffer <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
戻り値: <Buffer> 暗号化されたコンテンツを含む新しいBuffer。

bufferをprivateKeyで暗号化します。返されたデータは、たとえばcrypto.publicDecrypt()を使用して、対応する公開鍵を使用して復号化できます。

`crypto.publicDecrypt(key, buffer)`#

履歴

バージョン	変更点
v15.0.0	キータイプとして、string、ArrayBuffer、およびCryptoKeyが許可されるようになりました。パスフレーズはArrayBufferにすることができます。bufferはstringまたはArrayBufferにできます。バッファを受け入れるすべての型は、最大2 ** 31 - 1バイトに制限されています。
v11.6.0	この関数は、キーオブジェクトをサポートするようになりました。
v1.1.0	追加: v1.1.0

key <Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>
- passphrase <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 秘密鍵のオプションのパスフレーズ。
- padding <crypto.constants> crypto.constantsで定義されたオプションのパディング値。これは、crypto.constants.RSA_NO_PADDINGまたはcrypto.constants.RSA_PKCS1_PADDINGである可能性があります。
- encoding <string> buffer、key、またはpassphraseが文字列の場合に使用する文字列エンコーディング。
buffer <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
戻り値: <Buffer> 復号化されたコンテンツを含む新しいBuffer。

keyを使用してbufferを復号化します。bufferは、たとえばcrypto.privateEncrypt()を使用して、対応する秘密鍵を使用して以前に暗号化されました。

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

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

`crypto.publicEncrypt(key, buffer)`#

履歴

バージョン	変更点
v15.0.0	キータイプとして、string、ArrayBuffer、およびCryptoKeyが許可されるようになりました。oaepLabelとパスフレーズはArrayBufferにすることができます。bufferはstringまたはArrayBufferにできます。バッファを受け入れるすべての型は、最大2 ** 31 - 1バイトに制限されています。
v12.11.0	`oaepLabel`オプションが追加されました。
v12.9.0	`oaepHash`オプションが追加されました。
v11.6.0	この関数は、キーオブジェクトをサポートするようになりました。
v0.11.14	追加: v0.11.14

key <Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>
- key <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey> PEMエンコードされた公開鍵または秘密鍵、<KeyObject>、または<CryptoKey>。
- oaepHash <string> OAEPパディングとMGF1に使用するハッシュ関数。デフォルト: 'sha1'
- oaepLabel <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> OAEPパディングに使用するラベル。指定しない場合、ラベルは使用されません。
- passphrase <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 秘密鍵のオプションのパスフレーズ。
- padding <crypto.constants> crypto.constantsで定義されたオプションのパディング値。これは、crypto.constants.RSA_NO_PADDING、crypto.constants.RSA_PKCS1_PADDING、またはcrypto.constants.RSA_PKCS1_OAEP_PADDINGである可能性があります。
- encoding <string> buffer、key、oaepLabel、またはpassphraseが文字列の場合に使用する文字列エンコーディング。
buffer <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
戻り値: <Buffer> 暗号化されたコンテンツを含む新しいBuffer。

bufferの内容をkeyで暗号化し、暗号化されたコンテンツを含む新しいBufferを返します。返されたデータは、たとえばcrypto.privateDecrypt()を使用して、対応する秘密鍵を使用して復号化できます。

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

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

`crypto.randomBytes(size[, callback])`#

履歴

バージョン	変更点
v18.0.0	`callback` 引数に無効なコールバックを渡すと、`ERR_INVALID_CALLBACK` ではなく、`ERR_INVALID_ARG_TYPE` がスローされるようになりました。
v9.0.0	`callback` 引数として `null` を渡すと、`ERR_INVALID_CALLBACK` がスローされるようになりました。
v0.5.8	追加: v0.5.8

size <number> 生成するバイト数。size は 2**31 - 1 より大きくすることはできません。
callback <Function>
- err <Error>
- buf <Buffer>
戻り値: callback 関数が提供されていない場合は <Buffer>。

暗号学的に強力な擬似乱数データを生成します。size 引数は、生成するバイト数を示す数値です。

callback 関数が提供されている場合、バイトは非同期的に生成され、callback 関数は 2 つの引数 err と buf で呼び出されます。エラーが発生した場合、err は Error オブジェクトになります。それ以外の場合は null です。buf 引数は、生成されたバイトを含む Buffer です。

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

randomBytes(256, (err, buf) => {
  if (err) throw err;
  console.log(`${buf.length} bytes of random data: ${buf.toString('hex')}`);
});// Asynchronous
const {
  randomBytes,
} = require('node:crypto');

randomBytes(256, (err, buf) => {
  if (err) throw err;
  console.log(`${buf.length} bytes of random data: ${buf.toString('hex')}`);
});

callback 関数が提供されていない場合、乱数は同期的に生成され、Buffer として返されます。バイトの生成中に問題が発生した場合、エラーがスローされます。

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

const buf = randomBytes(256);
console.log(
  `${buf.length} bytes of random data: ${buf.toString('hex')}`);// Synchronous
const {
  randomBytes,
} = require('node:crypto');

const buf = randomBytes(256);
console.log(
  `${buf.length} bytes of random data: ${buf.toString('hex')}`);

crypto.randomBytes() メソッドは、十分なエントロピーが利用可能になるまで完了しません。通常、これには数ミリ秒以上かかることはありません。乱数の生成がより長い時間ブロックされる可能性のある唯一のケースは、システム全体がまだエントロピーが少ない起動直後です。

crypto.randomBytes() の非同期バージョンは、単一のスレッドプールリクエストで実行されます。スレッドプールタスクの長さの変動を最小限に抑えるために、クライアントリクエストの一部として実行する場合は、大きな randomBytes リクエストを分割してください。

`crypto.randomFillSync(buffer[, offset][, size])`#

履歴

バージョン	変更点
v9.0.0	`buffer` 引数は、任意の `TypedArray` または `DataView` を指定できます。
v7.10.0, v6.13.0	追加: v7.10.0, v6.13.0

buffer <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 必須。提供された buffer のサイズは、2**31 - 1 より大きくすることはできません。
offset <number> デフォルト: 0
size <number> デフォルト: buffer.length - offset。size は 2**31 - 1 より大きくすることはできません。
戻り値: <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> buffer 引数として渡されたオブジェクト。

crypto.randomFill() の同期バージョン。

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

const buf = Buffer.alloc(10);
console.log(randomFillSync(buf).toString('hex'));

randomFillSync(buf, 5);
console.log(buf.toString('hex'));

// The above is equivalent to the following:
randomFillSync(buf, 5, 5);
console.log(buf.toString('hex'));const { randomFillSync } = require('node:crypto');
const { Buffer } = require('node:buffer');

const buf = Buffer.alloc(10);
console.log(randomFillSync(buf).toString('hex'));

randomFillSync(buf, 5);
console.log(buf.toString('hex'));

// The above is equivalent to the following:
randomFillSync(buf, 5, 5);
console.log(buf.toString('hex'));

任意の ArrayBuffer、TypedArray、または DataView インスタンスを buffer として渡すことができます。

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

const a = new Uint32Array(10);
console.log(Buffer.from(randomFillSync(a).buffer,
                        a.byteOffset, a.byteLength).toString('hex'));

const b = new DataView(new ArrayBuffer(10));
console.log(Buffer.from(randomFillSync(b).buffer,
                        b.byteOffset, b.byteLength).toString('hex'));

const c = new ArrayBuffer(10);
console.log(Buffer.from(randomFillSync(c)).toString('hex'));const { randomFillSync } = require('node:crypto');
const { Buffer } = require('node:buffer');

const a = new Uint32Array(10);
console.log(Buffer.from(randomFillSync(a).buffer,
                        a.byteOffset, a.byteLength).toString('hex'));

const b = new DataView(new ArrayBuffer(10));
console.log(Buffer.from(randomFillSync(b).buffer,
                        b.byteOffset, b.byteLength).toString('hex'));

const c = new ArrayBuffer(10);
console.log(Buffer.from(randomFillSync(c)).toString('hex'));

`crypto.randomFill(buffer[, offset][, size], callback)`#

履歴

バージョン	変更点
v18.0.0	`callback` 引数に無効なコールバックを渡すと、`ERR_INVALID_CALLBACK` ではなく、`ERR_INVALID_ARG_TYPE` がスローされるようになりました。
v9.0.0	`buffer` 引数は、任意の `TypedArray` または `DataView` を指定できます。
v7.10.0, v6.13.0	追加: v7.10.0, v6.13.0

buffer <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> 必須。提供された buffer のサイズは、2**31 - 1 より大きくすることはできません。
offset <number> デフォルト: 0
size <number> デフォルト: buffer.length - offset。size は 2**31 - 1 より大きくすることはできません。
callback <Function> function(err, buf) {}。

この関数は crypto.randomBytes() に似ていますが、最初の引数として、入力される Buffer である必要があります。また、コールバックを渡す必要があります。

callback 関数が提供されていない場合、エラーがスローされます。

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

const buf = Buffer.alloc(10);
randomFill(buf, (err, buf) => {
  if (err) throw err;
  console.log(buf.toString('hex'));
});

randomFill(buf, 5, (err, buf) => {
  if (err) throw err;
  console.log(buf.toString('hex'));
});

// The above is equivalent to the following:
randomFill(buf, 5, 5, (err, buf) => {
  if (err) throw err;
  console.log(buf.toString('hex'));
});const { randomFill } = require('node:crypto');
const { Buffer } = require('node:buffer');

const buf = Buffer.alloc(10);
randomFill(buf, (err, buf) => {
  if (err) throw err;
  console.log(buf.toString('hex'));
});

randomFill(buf, 5, (err, buf) => {
  if (err) throw err;
  console.log(buf.toString('hex'));
});

// The above is equivalent to the following:
randomFill(buf, 5, 5, (err, buf) => {
  if (err) throw err;
  console.log(buf.toString('hex'));
});

任意の ArrayBuffer、TypedArray、または DataView インスタンスを buffer として渡すことができます。

これは Float32Array および Float64Array のインスタンスも含まれますが、この関数はランダムな浮動小数点数を生成するために使用しないでください。結果には、+Infinity、-Infinity、および NaN が含まれる場合があり、配列に有限数のみが含まれている場合でも、それらは均一な乱数分布から描画されておらず、意味のある下限または上限がありません。

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

const a = new Uint32Array(10);
randomFill(a, (err, buf) => {
  if (err) throw err;
  console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
    .toString('hex'));
});

const b = new DataView(new ArrayBuffer(10));
randomFill(b, (err, buf) => {
  if (err) throw err;
  console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
    .toString('hex'));
});

const c = new ArrayBuffer(10);
randomFill(c, (err, buf) => {
  if (err) throw err;
  console.log(Buffer.from(buf).toString('hex'));
});const { randomFill } = require('node:crypto');
const { Buffer } = require('node:buffer');

const a = new Uint32Array(10);
randomFill(a, (err, buf) => {
  if (err) throw err;
  console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
    .toString('hex'));
});

const b = new DataView(new ArrayBuffer(10));
randomFill(b, (err, buf) => {
  if (err) throw err;
  console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
    .toString('hex'));
});

const c = new ArrayBuffer(10);
randomFill(c, (err, buf) => {
  if (err) throw err;
  console.log(Buffer.from(buf).toString('hex'));
});

crypto.randomFill() の非同期バージョンは、単一のスレッドプールリクエストで実行されます。スレッドプールタスクの長さの変動を最小限に抑えるために、クライアントリクエストの一部として実行する場合は、大きな randomFill リクエストを分割してください。

`crypto.randomInt([min, ]max[, callback])`#

履歴

バージョン	変更点
v18.0.0	`callback` 引数に無効なコールバックを渡すと、`ERR_INVALID_CALLBACK` ではなく、`ERR_INVALID_ARG_TYPE` がスローされるようになりました。
v14.10.0, v12.19.0	追加: v14.10.0, v12.19.0

min <integer> ランダム範囲の開始 (両端を含む)。デフォルト: 0。
max <integer> ランダム範囲の終了 (両端を含まない)。
callback <Function> function(err, n) {}。

min <= n < max となるような乱数整数 n を返します。この実装ではモジュロバイアスを回避します。

範囲 (max - min) は 2⁴⁸ 未満である必要があります。min と max は安全な整数である必要があります。

callback 関数が提供されていない場合、乱数整数は同期的に生成されます。

// Asynchronous
const {
  randomInt,
} = await import('node:crypto');

randomInt(3, (err, n) => {
  if (err) throw err;
  console.log(`Random number chosen from (0, 1, 2): ${n}`);
});// Asynchronous
const {
  randomInt,
} = require('node:crypto');

randomInt(3, (err, n) => {
  if (err) throw err;
  console.log(`Random number chosen from (0, 1, 2): ${n}`);
});

// Synchronous
const {
  randomInt,
} = await import('node:crypto');

const n = randomInt(3);
console.log(`Random number chosen from (0, 1, 2): ${n}`);// Synchronous
const {
  randomInt,
} = require('node:crypto');

const n = randomInt(3);
console.log(`Random number chosen from (0, 1, 2): ${n}`);

// With `min` argument
const {
  randomInt,
} = await import('node:crypto');

const n = randomInt(1, 7);
console.log(`The dice rolled: ${n}`);// With `min` argument
const {
  randomInt,
} = require('node:crypto');

const n = randomInt(1, 7);
console.log(`The dice rolled: ${n}`);

`crypto.randomUUID([options])`#

追加: v15.6.0, v14.17.0

options <Object>
- disableEntropyCache <boolean> デフォルトでは、パフォーマンスを向上させるために、Node.js は最大 128 個のランダム UUID を生成するのに十分な乱数データを生成してキャッシュします。キャッシュを使用せずに UUID を生成するには、disableEntropyCache を true に設定します。デフォルト: false。
戻り値: <string>

ランダムな RFC 4122 バージョン 4 UUID を生成します。UUID は、暗号化擬似乱数ジェネレーターを使用して生成されます。

`crypto.scrypt(password, salt, keylen[, options], callback)`#

履歴

バージョン	変更点
v18.0.0	`callback` 引数に無効なコールバックを渡すと、`ERR_INVALID_CALLBACK` ではなく、`ERR_INVALID_ARG_TYPE` がスローされるようになりました。
v15.0.0	password および salt 引数は、ArrayBuffer インスタンスにすることもできます。
v12.8.0, v10.17.0	`maxmem` の値は、任意の安全な整数にできるようになりました。
v10.9.0	`cost`、`blockSize`、`parallelization` オプション名が追加されました。
v10.5.0	追加: v10.5.0

password <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
salt <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
keylen <number>
options <Object>
- cost <number> CPU/メモリコストパラメータ。1 より大きい 2 のべき乗である必要があります。デフォルト: 16384。
- blockSize <number> ブロックサイズパラメータ。デフォルト: 8。
- parallelization <number> 並列化パラメータ。デフォルト: 1。
- N <number> cost のエイリアス。どちらか一方のみを指定できます。
- r <number> blockSize のエイリアス。どちらか一方のみを指定できます。
- p <number> parallelization のエイリアス。どちらか一方のみを指定できます。
- maxmem <number> メモリの上限。(およそ) 128 * N * r > maxmem の場合、エラーになります。デフォルト: 32 * 1024 * 1024。
callback <Function>
- err <Error>
- derivedKey <Buffer>

非同期の scrypt 実装を提供します。Scrypt は、ブルートフォース攻撃を無駄にするために、計算とメモリの両面でコストが高くなるように設計されたパスワードベースのキー導出関数です。

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

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

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

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

// Using the factory defaults.
scrypt('password', 'salt', 64, (err, derivedKey) => {
  if (err) throw err;
  console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'
});
// Using a custom N parameter. Must be a power of two.
scrypt('password', 'salt', 64, { N: 1024 }, (err, derivedKey) => {
  if (err) throw err;
  console.log(derivedKey.toString('hex'));  // '3745e48...aa39b34'
});const {
  scrypt,
} = require('node:crypto');

// Using the factory defaults.
scrypt('password', 'salt', 64, (err, derivedKey) => {
  if (err) throw err;
  console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'
});
// Using a custom N parameter. Must be a power of two.
scrypt('password', 'salt', 64, { N: 1024 }, (err, derivedKey) => {
  if (err) throw err;
  console.log(derivedKey.toString('hex'));  // '3745e48...aa39b34'
});

`crypto.scryptSync(password, salt, keylen[, options])`#

履歴

バージョン	変更点
v12.8.0, v10.17.0	`maxmem` の値は、任意の安全な整数にできるようになりました。
v10.9.0	`cost`、`blockSize`、`parallelization` オプション名が追加されました。
v10.5.0	追加: v10.5.0

password <string> | <Buffer> | <TypedArray> | <DataView>
salt <string> | <Buffer> | <TypedArray> | <DataView>
keylen <number>
options <Object>
- cost <number> CPU/メモリコストパラメータ。1 より大きい 2 のべき乗である必要があります。デフォルト: 16384。
- blockSize <number> ブロックサイズパラメータ。デフォルト: 8。
- parallelization <number> 並列化パラメータ。デフォルト: 1。
- N <number> cost のエイリアス。どちらか一方のみを指定できます。
- r <number> blockSize のエイリアス。どちらか一方のみを指定できます。
- p <number> parallelization のエイリアス。どちらか一方のみを指定できます。
- maxmem <number> メモリの上限。(およそ) 128 * N * r > maxmem の場合、エラーになります。デフォルト: 32 * 1024 * 1024。
戻り値: <Buffer>

同期の scrypt 実装を提供します。Scrypt は、ブルートフォース攻撃を無駄にするために、計算とメモリの両面でコストが高くなるように設計されたパスワードベースのキー導出関数です。

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

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

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

const {
  scryptSync,
} = await import('node:crypto');
// Using the factory defaults.

const key1 = scryptSync('password', 'salt', 64);
console.log(key1.toString('hex'));  // '3745e48...08d59ae'
// Using a custom N parameter. Must be a power of two.
const key2 = scryptSync('password', 'salt', 64, { N: 1024 });
console.log(key2.toString('hex'));  // '3745e48...aa39b34'const {
  scryptSync,
} = require('node:crypto');
// Using the factory defaults.

const key1 = scryptSync('password', 'salt', 64);
console.log(key1.toString('hex'));  // '3745e48...08d59ae'
// Using a custom N parameter. Must be a power of two.
const key2 = scryptSync('password', 'salt', 64, { N: 1024 });
console.log(key2.toString('hex'));  // '3745e48...aa39b34'

`crypto.secureHeapUsed()`#

追加: v15.6.0

戻り値: <Object>
- total <number> --secure-heap=n コマンドラインフラグを使用して指定された、割り当てられたセキュアヒープの合計サイズ。
- min <number> --secure-heap-min コマンドラインフラグを使用して指定された、セキュアヒープからの最小割り当て。
- used <number> 現在セキュアヒープから割り当てられているバイト数の合計。
- utilization <number> 割り当てられたバイトの used と total の計算された比率。

`crypto.setEngine(engine[, flags])`#

追加: v0.11.11

engine <string>
flags <crypto.constants> デフォルト: crypto.constants.ENGINE_METHOD_ALL

一部またはすべての OpenSSL 関数 (フラグによって選択) の engine をロードして設定します。

engine は、エンジン共有ライブラリの ID またはパスのいずれかになります。

オプションの flags 引数は、デフォルトで ENGINE_METHOD_ALL を使用します。flags は、次のフラグのいずれかまたは組み合わせ (crypto.constants で定義) を使用するビットフィールドです。

crypto.constants.ENGINE_METHOD_RSA
crypto.constants.ENGINE_METHOD_DSA
crypto.constants.ENGINE_METHOD_DH
crypto.constants.ENGINE_METHOD_RAND
crypto.constants.ENGINE_METHOD_EC
crypto.constants.ENGINE_METHOD_CIPHERS
crypto.constants.ENGINE_METHOD_DIGESTS
crypto.constants.ENGINE_METHOD_PKEY_METHS
crypto.constants.ENGINE_METHOD_PKEY_ASN1_METHS
crypto.constants.ENGINE_METHOD_ALL
crypto.constants.ENGINE_METHOD_NONE

`crypto.setFips(bool)`#

追加: v10.0.0

bool <boolean> true にすると FIPS モードが有効になります。

FIPS 対応の Node.js ビルドで、FIPS 準拠の暗号化プロバイダーを有効にします。FIPS モードが利用できない場合は、エラーがスローされます。

`crypto.sign(algorithm, data, key[, callback])`#

履歴

バージョン	変更点
v18.0.0	`callback` 引数に無効なコールバックを渡すと、`ERR_INVALID_CALLBACK` ではなく、`ERR_INVALID_ARG_TYPE` がスローされるようになりました。
v15.12.0	オプションのコールバック引数が追加されました。
v13.2.0, v12.16.0	この関数は、IEEE-P1363 DSA および ECDSA 署名をサポートするようになりました。
v12.0.0	追加: v12.0.0

algorithm <string> | <null> | <undefined>
data <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
key <Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>
callback <Function>
- err <Error>
- signature <Buffer>
戻り値: callback 関数が提供されていない場合は <Buffer>。

指定された秘密鍵とアルゴリズムを使用して、data の署名を計算して返します。algorithm が null または undefined の場合、アルゴリズムはキータイプ（特に Ed25519 および Ed448）に依存します。

key が KeyObject でない場合、この関数は key が 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.1 で指定されているように、メッセージに署名するために使用されるのと同じハッシュ関数で MGF1 を使用します。
saltLength <integer> パディングが RSA_PKCS1_PSS_PADDING の場合のソルト長。特別な値 crypto.constants.RSA_PSS_SALTLEN_DIGEST はソルト長をダイジェストサイズに設定し、crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN (デフォルト) は許容される最大値に設定します。

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

`crypto.subtle`#

追加: v17.4.0

型: <SubtleCrypto>

crypto.webcrypto.subtle の便利なエイリアスです。

`crypto.timingSafeEqual(a, b)`#

履歴

バージョン	変更点
v15.0.0	a および b 引数は ArrayBuffer にすることもできます。
v6.6.0	追加: v6.6.0

a <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
b <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
戻り値: <boolean>

この関数は、定数時間アルゴリズムを使用して、指定された ArrayBuffer、TypedArray、または DataView インスタンスを表す基になるバイトを比較します。

この関数は、攻撃者が値を推測することを可能にするタイミング情報をリークしません。これは、HMACダイジェストまたは認証クッキーやcapability urlsのような秘密値を比較するのに適しています。

a と b は両方とも Buffer、TypedArray、または DataView である必要があり、同じバイト長である必要があります。a と b のバイト長が異なる場合、エラーがスローされます。

a と b の少なくとも1つが、Uint16Arrayのようにエントリごとに複数のバイトを持つTypedArrayである場合、結果はプラットフォームのバイト順序を使用して計算されます。

両方の入力がFloat32ArrayまたはFloat64Arrayの場合、この関数は浮動小数点数のIEEE 754エンコーディングにより、予期しない結果を返す可能性があります。特に、x === yもObject.is(x, y)も、2つの浮動小数点数xとyのバイト表現が等しいことを意味するわけではありません。

crypto.timingSafeEqualの使用は、*周辺*コードがタイミングセーフであることを保証するものではありません。周辺コードがタイミングの脆弱性を導入しないように注意する必要があります。

`crypto.verify(algorithm, data, key, signature[, callback])`#

履歴

バージョン	変更点
v18.0.0	`callback` 引数に無効なコールバックを渡すと、`ERR_INVALID_CALLBACK` ではなく、`ERR_INVALID_ARG_TYPE` がスローされるようになりました。
v15.12.0	オプションのコールバック引数が追加されました。
v15.0.0	data、key、および signature 引数は ArrayBuffer にすることもできます。
v13.2.0, v12.16.0	この関数は、IEEE-P1363 DSA および ECDSA 署名をサポートするようになりました。
v12.0.0	追加: v12.0.0

algorithm <string> | <null> | <undefined>
data <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
key <Object> | <string> | <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView> | <KeyObject> | <CryptoKey>
signature <ArrayBuffer> | <Buffer> | <TypedArray> | <DataView>
callback <Function>
- err <Error>
- result <boolean>
返り値: <boolean> callback 関数が提供されていない場合、データと公開鍵に対する署名の有効性に応じて、true または false を返します。

指定されたキーとアルゴリズムを使用して、data の指定された署名を検証します。algorithm が null または undefined の場合、アルゴリズムはキータイプ（特に Ed25519 および Ed448）に依存します。

key が KeyObject でない場合、この関数は key が 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.1 で指定されているように、メッセージに署名するために使用されるのと同じハッシュ関数で MGF1 を使用します。
saltLength <integer> パディングが RSA_PKCS1_PSS_PADDING の場合のソルト長。特別な値 crypto.constants.RSA_PSS_SALTLEN_DIGEST はソルト長をダイジェストサイズに設定し、crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN (デフォルト) は許容される最大値に設定します。

signature 引数は、data に対して以前に計算された署名です。

公開鍵は秘密鍵から導出できるため、key には秘密鍵または公開鍵を渡すことができます。

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

`crypto.webcrypto`#

追加: v15.0.0

型: <Crypto> Web Crypto API 標準の実装です。

詳細については、Web Crypto API ドキュメントを参照してください。

注意#

暗号化 API への入力としての文字列の使用#

歴史的な理由から、Node.js によって提供される多くの暗号化 API は、基になる暗号化アルゴリズムがバイトシーケンスで動作する場所で、文字列を入力として受け入れます。これらのインスタンスには、平文、暗号文、対称鍵、初期化ベクトル、パスフレーズ、ソルト、認証タグ、および追加の認証データが含まれます。

文字列を暗号化APIに渡す場合は、次の要因を考慮してください。

すべてのバイトシーケンスが有効なUTF-8文字列であるとは限りません。したがって、長さnのバイトシーケンスが文字列から派生した場合、そのエントロピーは通常、ランダムまたは疑似ランダムなnバイトシーケンスのエントロピーよりも低くなります。たとえば、UTF-8文字列ではバイトシーケンスc0 afは生成されません。秘密鍵は、ほとんどの場合、ランダムまたは疑似ランダムなバイトシーケンスである必要があります。
同様に、ランダムまたは疑似ランダムなバイトシーケンスをUTF-8文字列に変換すると、有効なコードポイントを表さないサブシーケンスがUnicode置換文字（U+FFFD）に置き換えられる場合があります。したがって、結果として得られるUnicode文字列のバイト表現は、文字列の作成元のバイトシーケンスと等しくない場合があります。
```
const original = [0xc0, 0xaf];
const bytesAsString = Buffer.from(original).toString('utf8');
const stringAsBytes = Buffer.from(bytesAsString, 'utf8');
console.log(stringAsBytes);
// Prints '<Buffer ef bf bd ef bf bd>'. 
```
暗号、ハッシュ関数、署名アルゴリズム、および鍵導出関数の出力は、疑似ランダムなバイトシーケンスであり、Unicode文字列として使用しないでください。
文字列がユーザー入力から取得される場合、一部のUnicode文字は、異なるバイトシーケンスになる複数の同等の方法で表現できます。たとえば、PBKDF2やscryptなどのキー導出関数にユーザーパスフレーズを渡す場合、キー導出関数の結果は、文字列が合成文字と分解文字のどちらを使用しているかによって異なります。Node.jsは文字表現を正規化しません。開発者は、暗号化APIに渡す前に、ユーザー入力に対してString.prototype.normalize()を使用することを検討する必要があります。

レガシーストリームAPI（Node.js 0.10より前）#

Cryptoモジュールは、統一されたStream APIの概念がなく、バイナリデータを処理するためのBufferオブジェクトがなかったNode.jsに追加されました。そのため、多くのcryptoクラスには、streams APIを実装する他のNode.jsクラスには通常見られないメソッド（update()、final()、またはdigest()など）があります。また、多くのメソッドは、デフォルトでBufferではなく、デフォルトで'latin1'エンコードされた文字列を受け入れて返しました。このデフォルトは、Node.js v0.8以降、デフォルトでBufferオブジェクトを使用するように変更されました。

脆弱または侵害されたアルゴリズムのサポート#

node:cryptoモジュールは、すでに侵害されており、使用が推奨されない一部のアルゴリズムを依然としてサポートしています。APIでは、安全に使用するには弱すぎる小さなキーサイズの暗号とハッシュを使用することもできます。

ユーザーは、セキュリティ要件に応じて、暗号アルゴリズムとキーサイズを選択する全責任を負う必要があります。

NIST SP 800-131Aの推奨事項に基づいています。

MD5とSHA-1は、デジタル署名など、衝突耐性が必要な場合には受け入れられなくなりました。
RSA、DSA、およびDHアルゴリズムで使用されるキーは、少なくとも2048ビット、ECDSAおよびECDHの曲線のキーは少なくとも224ビットにすることを推奨します。これにより、数年間安全に使用できます。
modp1、modp2、およびmodp5のDHグループは、キーサイズが2048ビット未満であり、推奨されません。

他の推奨事項と詳細については、リファレンスを参照してください。

既知の弱点があり、実際にはほとんど関連性のない一部のアルゴリズムは、デフォルトでは有効になっていないレガシープロバイダーでのみ使用できます。

CCMモード#

CCMは、サポートされているAEADアルゴリズムの1つです。このモードを使用するアプリケーションは、暗号APIを使用する際に特定の制限に従う必要があります。

認証タグの長さは、暗号の作成時にauthTagLengthオプションを設定して指定する必要があり、4、6、8、10、12、14、または16バイトのいずれかである必要があります。
初期化ベクトル（nonce）Nの長さは、7〜13バイト（7 ≤ N ≤ 13）の間である必要があります。
平文の長さは、2 ** (8 * (15 - N)) バイトに制限されます。
復号化する際、認証タグは update() を呼び出す前に setAuthTag() を介して設定する必要があります。そうしない場合、復号化は失敗し、RFC 3610 のセクション 2.6 に準拠して final() がエラーをスローします。
CCM モードでは、write(data)、end(data)、pipe() などのストリームメソッドを使用すると、CCM がインスタンスごとに複数のデータチャンクを処理できないため、失敗する可能性があります。
追加認証データ（AAD）を渡す場合、実際のメッセージの長さをバイト単位で plaintextLength オプションを介して setAAD() に渡す必要があります。多くの暗号ライブラリでは、認証タグが暗号文に含まれており、plaintextLength + authTagLength の長さの暗号文が生成されます。Node.js は認証タグを含まないため、暗号文の長さは常に plaintextLength になります。AAD を使用しない場合は、これは不要です。
CCM はメッセージ全体を一度に処理するため、update() は正確に一度だけ呼び出す必要があります。
update() の呼び出しはメッセージの暗号化/復号化に十分ですが、アプリケーションは認証タグを計算または検証するために必ず final() を呼び出す必要があります。

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

const key = 'keykeykeykeykeykeykeykey';
const nonce = randomBytes(12);

const aad = Buffer.from('0123456789', 'hex');

const cipher = createCipheriv('aes-192-ccm', key, nonce, {
  authTagLength: 16,
});
const plaintext = 'Hello world';
cipher.setAAD(aad, {
  plaintextLength: Buffer.byteLength(plaintext),
});
const ciphertext = cipher.update(plaintext, 'utf8');
cipher.final();
const tag = cipher.getAuthTag();

// Now transmit { ciphertext, nonce, tag }.

const decipher = createDecipheriv('aes-192-ccm', key, nonce, {
  authTagLength: 16,
});
decipher.setAuthTag(tag);
decipher.setAAD(aad, {
  plaintextLength: ciphertext.length,
});
const receivedPlaintext = decipher.update(ciphertext, null, 'utf8');

try {
  decipher.final();
} catch (err) {
  throw new Error('Authentication failed!', { cause: err });
}

console.log(receivedPlaintext);const { Buffer } = require('node:buffer');
const {
  createCipheriv,
  createDecipheriv,
  randomBytes,
} = require('node:crypto');

const key = 'keykeykeykeykeykeykeykey';
const nonce = randomBytes(12);

const aad = Buffer.from('0123456789', 'hex');

const cipher = createCipheriv('aes-192-ccm', key, nonce, {
  authTagLength: 16,
});
const plaintext = 'Hello world';
cipher.setAAD(aad, {
  plaintextLength: Buffer.byteLength(plaintext),
});
const ciphertext = cipher.update(plaintext, 'utf8');
cipher.final();
const tag = cipher.getAuthTag();

// Now transmit { ciphertext, nonce, tag }.

const decipher = createDecipheriv('aes-192-ccm', key, nonce, {
  authTagLength: 16,
});
decipher.setAuthTag(tag);
decipher.setAAD(aad, {
  plaintextLength: ciphertext.length,
});
const receivedPlaintext = decipher.update(ciphertext, null, 'utf8');

try {
  decipher.final();
} catch (err) {
  throw new Error('Authentication failed!', { cause: err });
}

console.log(receivedPlaintext);

FIPS モード#

OpenSSL 3 を使用している場合、Node.js は、OpenSSL 3 の FIPS プロバイダーなどの適切な OpenSSL 3 プロバイダーとともに使用すると、FIPS 140-2 をサポートします。これは、OpenSSL の FIPS README ファイルの手順に従ってインストールできます。

Node.js で FIPS をサポートするには、以下が必要です。

正しくインストールされた OpenSSL 3 FIPS プロバイダー。
OpenSSL 3 FIPS モジュール構成ファイル。
FIPS モジュール構成ファイルを参照する OpenSSL 3 構成ファイル。

Node.js は、FIPS プロバイダーを指す OpenSSL 構成ファイルで構成する必要があります。構成ファイルの例は次のようになります。

nodejs_conf = nodejs_init

.include /<absolute path>/fipsmodule.cnf

[nodejs_init]
providers = provider_sect

[provider_sect]
default = default_sect
# The fips section name should match the section name inside the
# included fipsmodule.cnf.
fips = fips_sect

[default_sect]
activate = 1

ここで、fipsmodule.cnf は、FIPS プロバイダーのインストール手順で生成された FIPS モジュール構成ファイルです。

openssl fipsinstall

構成ファイルを指すように OPENSSL_CONF 環境変数を設定し、FIPS プロバイダーの動的ライブラリの場所を指すように OPENSSL_MODULES を設定します。例：

export OPENSSL_CONF=/<path to configuration file>/nodejs.cnf
export OPENSSL_MODULES=/<path to openssl lib>/ossl-modules

Node.js で FIPS モードを有効にするには、次のいずれかの方法があります。

--enable-fips または --force-fips コマンドラインフラグを指定して Node.js を起動します。
プログラムで crypto.setFips(true) を呼び出します。

オプションで、OpenSSL 構成ファイルを使用して Node.js で FIPS モードを有効にすることができます。例：

nodejs_conf = nodejs_init

.include /<absolute path>/fipsmodule.cnf

[nodejs_init]
providers = provider_sect
alg_section = algorithm_sect

[provider_sect]
default = default_sect
# The fips section name should match the section name inside the
# included fipsmodule.cnf.
fips = fips_sect

[default_sect]
activate = 1

[algorithm_sect]
default_properties = fips=yes

暗号定数#

crypto.constants によってエクスポートされる次の定数は、node:crypto、node:tls、および node:https モジュールのさまざまな用途に適用され、一般的に OpenSSL に固有のものです。

OpenSSL オプション#

詳細については、SSL OP フラグのリストを参照してください。

定数	説明
`SSL_OP_ALL`	OpenSSL 内の複数のバグ回避策を適用します。詳細については、https://www.openssl.org/docs/man3.0/man3/SSL_CTX_set_options.html を参照してください。
`SSL_OP_ALLOW_NO_DHE_KEX`	TLS v1.3 で非 [EC] DHE ベースの鍵交換モードを許可するように OpenSSL に指示します。
`SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION`	OpenSSL とパッチが適用されていないクライアントまたはサーバー間のレガシーの安全でない再ネゴシエーションを許可します。https://www.openssl.org/docs/man3.0/man3/SSL_CTX_set_options.html を参照してください。
`SSL_OP_CIPHER_SERVER_PREFERENCE`	暗号を選択する際に、クライアントの優先順位ではなく、サーバーの優先順位を使用しようとします。動作はプロトコルバージョンに依存します。https://www.openssl.org/docs/man3.0/man3/SSL_CTX_set_options.html を参照してください。
`SSL_OP_CISCO_ANYCONNECT`	Cisco の "特別な" DTLS_BAD_VER バージョンを使用するように OpenSSL に指示します。
`SSL_OP_COOKIE_EXCHANGE`	Cookie 交換をオンにするように OpenSSL に指示します。
`SSL_OP_CRYPTOPRO_TLSEXT_BUG`	初期バージョンの cryptopro ドラフトからサーバーハロー拡張を追加するように OpenSSL に指示します。
`SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS`	OpenSSL 0.9.6d で追加された SSL 3.0 / TLS 1.0 の脆弱性回避策を無効にするように OpenSSL に指示します。
`SSL_OP_LEGACY_SERVER_CONNECT`	RI をサポートしていないサーバーへの最初の接続を許可します。
`SSL_OP_NO_COMPRESSION`	SSL / TLS 圧縮のサポートを無効にするように OpenSSL に指示します。
`SSL_OP_NO_ENCRYPT_THEN_MAC`	encrypt-then-MAC を無効にするように OpenSSL に指示します。
`SSL_OP_NO_QUERY_MTU`
`SSL_OP_NO_RENEGOTIATION`	再ネゴシエーションを無効にするように OpenSSL に指示します。
`SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION`	再ネゴシエーションを実行するときは常に新しいセッションを開始するように OpenSSL に指示します。
`SSL_OP_NO_SSLv2`	SSL v2 をオフにするように OpenSSL に指示します
`SSL_OP_NO_SSLv3`	SSL v3 をオフにするように OpenSSL に指示します
`SSL_OP_NO_TICKET`	RFC4507bis チケットの使用を無効にするように OpenSSL に指示します。
`SSL_OP_NO_TLSv1`	TLS v1 をオフにするように OpenSSL に指示します
`SSL_OP_NO_TLSv1_1`	TLS v1.1 をオフにするように OpenSSL に指示します
`SSL_OP_NO_TLSv1_2`	TLS v1.2 をオフにするように OpenSSL に指示します
`SSL_OP_NO_TLSv1_3`	TLS v1.3 をオフにするように OpenSSL に指示します
`SSL_OP_PRIORITIZE_CHACHA`	クライアントが実行する場合、ChaCha20-Poly1305 を優先するように OpenSSL サーバーに指示します。`SSL_OP_CIPHER_SERVER_PREFERENCE` が有効になっていない場合、このオプションは効果がありません。
`SSL_OP_TLS_ROLLBACK_BUG`	バージョンロールバック攻撃の検出を無効にするように OpenSSL に指示します。

OpenSSL エンジン定数#

定数	説明
`ENGINE_METHOD_RSA`	エンジン使用を RSA に制限します
`ENGINE_METHOD_DSA`	エンジン使用を DSA に制限します
`ENGINE_METHOD_DH`	エンジン使用を DH に制限します
`ENGINE_METHOD_RAND`	エンジン使用を RAND に制限します
`ENGINE_METHOD_EC`	エンジン使用を EC に制限します
`ENGINE_METHOD_CIPHERS`	エンジン使用を CIPHERS に制限します
`ENGINE_METHOD_DIGESTS`	エンジン使用を DIGESTS に制限します
`ENGINE_METHOD_PKEY_METHS`	エンジン使用を PKEY_METHDS に制限します
`ENGINE_METHOD_PKEY_ASN1_METHS`	エンジン使用を PKEY_ASN1_METHS に制限します
`ENGINE_METHOD_ALL`
`ENGINE_METHOD_NONE`

その他の OpenSSL 定数#

定数	説明
`DH_CHECK_P_NOT_SAFE_PRIME`
`DH_CHECK_P_NOT_PRIME`
`DH_UNABLE_TO_CHECK_GENERATOR`
`DH_NOT_SUITABLE_GENERATOR`
`RSA_PKCS1_PADDING`
`RSA_SSLV23_PADDING`
`RSA_NO_PADDING`
`RSA_PKCS1_OAEP_PADDING`
`RSA_X931_PADDING`
`RSA_PKCS1_PSS_PADDING`
`RSA_PSS_SALTLEN_DIGEST`	署名または検証時に、`RSA_PKCS1_PSS_PADDING` の salt 長さをダイジェストサイズに設定します。
`RSA_PSS_SALTLEN_MAX_SIGN`	データの署名時に、`RSA_PKCS1_PSS_PADDING` の salt 長さを許容される最大値に設定します。
`RSA_PSS_SALTLEN_AUTO`	署名を検証する際に、`RSA_PKCS1_PSS_PADDING` の salt 長さを自動的に決定するようにします。
`POINT_CONVERSION_COMPRESSED`
`POINT_CONVERSION_UNCOMPRESSED`
`POINT_CONVERSION_HYBRID`

Node.js 暗号定数#

定数	説明
`defaultCoreCipherList`	Node.js で使用される組み込みのデフォルトの暗号リストを指定します。
`defaultCipherList`	現在の Node.js プロセスで使用されるアクティブなデフォルトの暗号リストを指定します。

Crypto#

暗号化サポートが利用できないかどうかの判定#

クラス: Certificate#

静的メソッド: Certificate.exportChallenge(spkac[, encoding])#

静的メソッド: Certificate.exportPublicKey(spkac[, encoding])#

静的メソッド: Certificate.verifySpkac(spkac[, encoding])#

レガシー API#

new crypto.Certificate()#

certificate.exportChallenge(spkac[, encoding])#

certificate.exportPublicKey(spkac[, encoding])#

certificate.verifySpkac(spkac[, encoding])#

クラス: Cipher#

cipher.final([outputEncoding])#

cipher.getAuthTag()#

cipher.setAAD(buffer[, options])#

cipher.setAutoPadding([autoPadding])#

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

クラス: Decipher#

decipher.final([outputEncoding])#

decipher.setAAD(buffer[, options])#

decipher.setAuthTag(buffer[, encoding])#

decipher.setAutoPadding([autoPadding])#

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

クラス: DiffieHellman#

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

diffieHellman.generateKeys([encoding])#

diffieHellman.getGenerator([encoding])#

diffieHellman.getPrime([encoding])#

diffieHellman.getPrivateKey([encoding])#

diffieHellman.getPublicKey([encoding])#

diffieHellman.setPrivateKey(privateKey[, encoding])#

diffieHellman.setPublicKey(publicKey[, encoding])#

diffieHellman.verifyError#

クラス: DiffieHellmanGroup#

クラス: ECDH#

静的メソッド: ECDH.convertKey(key, curve[, inputEncoding[, outputEncoding[, format]]])#

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

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

ecdh.getPrivateKey([encoding])#

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

ecdh.setPrivateKey(privateKey[, encoding])#

ecdh.setPublicKey(publicKey[, encoding])#

クラス: Hash#

hash.copy([options])#

hash.digest([encoding])#

hash.update(data[, inputEncoding])#

クラス: Hmac#

hmac.digest([encoding])#

hmac.update(data[, inputEncoding])#

クラス: KeyObject#

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

keyObject.asymmetricKeyDetails#

keyObject.asymmetricKeyType#

keyObject.export([options])#

keyObject.equals(otherKeyObject)#

keyObject.symmetricKeySize#

keyObject.type#

クラス: Sign#

sign.sign(privateKey[, outputEncoding])#

sign.update(data[, inputEncoding])#

クラス: Verify#

verify.update(data[, inputEncoding])#

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

クラス: X509Certificate#

new X509Certificate(buffer)#

x509.ca#

x509.checkEmail(email[, options])#

x509.checkHost(name[, options])#

x509.checkIP(ip)#

x509.checkIssued(otherCert)#

x509.checkPrivateKey(privateKey)#

x509.fingerprint#

x509.fingerprint256#

x509.fingerprint512#

x509.infoAccess#

x509.issuer#

x509.issuerCertificate#

x509.extKeyUsage#

x509.publicKey#

x509.raw#

クラス: `Certificate`#

静的メソッド: `Certificate.exportChallenge(spkac[, encoding])`#

静的メソッド: `Certificate.exportPublicKey(spkac[, encoding])`#

静的メソッド: `Certificate.verifySpkac(spkac[, encoding])`#

`new crypto.Certificate()`#

`certificate.exportChallenge(spkac[, encoding])`#

`certificate.exportPublicKey(spkac[, encoding])`#

`certificate.verifySpkac(spkac[, encoding])`#

クラス: `Cipher`#

`cipher.final([outputEncoding])`#

`cipher.getAuthTag()`#

`cipher.setAAD(buffer[, options])`#

`cipher.setAutoPadding([autoPadding])`#

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

クラス: `Decipher`#

`decipher.final([outputEncoding])`#

`decipher.setAAD(buffer[, options])`#

`decipher.setAuthTag(buffer[, encoding])`#

`decipher.setAutoPadding([autoPadding])`#

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

クラス: `DiffieHellman`#

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

`diffieHellman.generateKeys([encoding])`#

`diffieHellman.getGenerator([encoding])`#

`diffieHellman.getPrime([encoding])`#

`diffieHellman.getPrivateKey([encoding])`#

`diffieHellman.getPublicKey([encoding])`#

`diffieHellman.setPrivateKey(privateKey[, encoding])`#

`diffieHellman.setPublicKey(publicKey[, encoding])`#

`diffieHellman.verifyError`#

クラス: `DiffieHellmanGroup`#

クラス: `ECDH`#

静的メソッド: `ECDH.convertKey(key, curve[, inputEncoding[, outputEncoding[, format]]])`#

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

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

`ecdh.getPrivateKey([encoding])`#

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

`ecdh.setPrivateKey(privateKey[, encoding])`#

`ecdh.setPublicKey(publicKey[, encoding])`#

クラス: `Hash`#

`hash.copy([options])`#

`hash.digest([encoding])`#

`hash.update(data[, inputEncoding])`#

クラス: `Hmac`#

`hmac.digest([encoding])`#

`hmac.update(data[, inputEncoding])`#

クラス: `KeyObject`#

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

`keyObject.asymmetricKeyDetails`#

`keyObject.asymmetricKeyType`#

`keyObject.export([options])`#

`keyObject.equals(otherKeyObject)`#

`keyObject.symmetricKeySize`#

`keyObject.type`#

クラス: `Sign`#

`sign.sign(privateKey[, outputEncoding])`#

`sign.update(data[, inputEncoding])`#

クラス: `Verify`#

`verify.update(data[, inputEncoding])`#

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

クラス: `X509Certificate`#

`new X509Certificate(buffer)`#

`x509.ca`#

`x509.checkEmail(email[, options])`#

`x509.checkHost(name[, options])`#

`x509.checkIP(ip)`#

`x509.checkIssued(otherCert)`#

`x509.checkPrivateKey(privateKey)`#

`x509.fingerprint`#

`x509.fingerprint256`#

`x509.fingerprint512`#

`x509.infoAccess`#

`x509.issuer`#

`x509.issuerCertificate`#

`x509.extKeyUsage`#

`x509.publicKey`#

`x509.raw`#

`x509.serialNumber`#

`x509.subject`#

`x509.subjectAltName`#