iDoc.dev

日本語

English
简体中文
Español
Français
Português
Deutsch
Italiano
한국어
Русский
العربية

日本語

English
简体中文
Español
Français
Português
Deutsch
Italiano
한국어
Русский
العربية

テーマ

Crypto ​

[Stable: 2 - 安定]

Stable: 2 安定度: 2 - 安定

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

node:cryptoモジュールは、OpenSSL のハッシュ、HMAC、暗号、復号、署名、および検証関数用のラッパーのセットを含む暗号機能を提供します。

js
const { createHmac } = await import('node:crypto')

const secret = 'abcdefg'
const hash = createHmac('sha256', secret).update('I love cupcakes').digest('hex')
console.log(hash)
// Prints:
//   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
js
const { 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 を使用してキャッチできます。

js
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()関数を使用することを検討してください。

js
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.0spkac 引数に ArrayBuffer を使用できるようになりました。spkac 引数のサイズを最大 2**31 - 1 バイトに制限しました。
v9.0.0追加: v9.0.0
js
const { Certificate } = await import('node:crypto')
const spkac = getSpkacSomehow()
const challenge = Certificate.exportChallenge(spkac)
console.log(challenge.toString('utf8'))
// Prints: チャレンジをUTF8文字列として出力
js
const { Certificate } = require('node:crypto')
const spkac = getSpkacSomehow()
const challenge = Certificate.exportChallenge(spkac)
console.log(challenge.toString('utf8'))
// Prints: チャレンジをUTF8文字列として出力

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

[履歴]

バージョン変更
v15.0.0spkac 引数に ArrayBuffer を使用できるようになりました。spkac 引数のサイズを最大 2**31 - 1 バイトに制限しました。
v9.0.0追加: v9.0.0
js
const { Certificate } = await import('node:crypto')
const spkac = getSpkacSomehow()
const publicKey = Certificate.exportPublicKey(spkac)
console.log(publicKey)
// 出力: 公開鍵を <Buffer ...> として出力
js
const { Certificate } = require('node:crypto')
const spkac = getSpkacSomehow()
const publicKey = Certificate.exportPublicKey(spkac)
console.log(publicKey)
// 出力: 公開鍵を <Buffer ...> として出力

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

[履歴]

バージョン変更
v15.0.0spkac 引数に ArrayBuffer を使用できるようになりました。エンコーディングを追加しました。spkac 引数のサイズを最大 2**31 - 1 バイトに制限しました。
v9.0.0追加: v9.0.0
js
import { Buffer } from 'node:buffer'
const { Certificate } = await import('node:crypto')

const spkac = getSpkacSomehow()
console.log(Certificate.verifySpkac(Buffer.from(spkac)))
// 出力: true または false
js
const { Buffer } = require('node:buffer')
const { Certificate } = require('node:crypto')

const spkac = getSpkacSomehow()
console.log(Certificate.verifySpkac(Buffer.from(spkac)))
// 出力: true または false

レガシー API ​

[Stable: 0 - Deprecated]

Stable: 0 安定度: 0 - 非推奨

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

new crypto.Certificate() ​

Certificate クラスのインスタンスは、new キーワードを使用するか、関数として crypto.Certificate() を呼び出すことで作成できます。

js
const { Certificate } = await import('node:crypto')

const cert1 = new Certificate()
const cert2 = Certificate()
js
const { Certificate } = require('node:crypto')

const cert1 = new Certificate()
const cert2 = Certificate()

certificate.exportChallenge(spkac[, encoding]) ​

追加: v0.11.8

js
const { Certificate } = await import('node:crypto')
const cert = Certificate()
const spkac = getSpkacSomehow()
const challenge = cert.exportChallenge(spkac)
console.log(challenge.toString('utf8'))
// Prints: チャレンジを UTF8 文字列として出力
js
const { Certificate } = require('node:crypto')
const cert = Certificate()
const spkac = getSpkacSomehow()
const challenge = cert.exportChallenge(spkac)
console.log(challenge.toString('utf8'))
// Prints: チャレンジを UTF8 文字列として出力

certificate.exportPublicKey(spkac[, encoding]) ​

追加: v0.11.8

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

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

const cert = Certificate()
const spkac = getSpkacSomehow()
console.log(cert.verifySpkac(Buffer.from(spkac)))
// Prints: true or false
js
const { Buffer } = require('node:buffer')
const { Certificate } = require('node:crypto')

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

クラス: Cipher ​

追加: v0.1.94

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

  • 可読および書き込み可能な ストリーム として。この場合、暗号化されていない平文データが書き込まれ、可読側で暗号化されたデータが生成されます。
  • cipher.update() および cipher.final() メソッドを使用して暗号化されたデータを生成します。

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

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

js
const { scrypt, randomFill, createCipheriv } = await import('node:crypto')

const algorithm = 'aes-192-cbc'
const password = 'キーを生成するために使用されるパスワード'

// まず、キーを生成します。キーの長さはアルゴリズムに依存します。
// この場合、aes192 の場合は 24 バイト (192 ビット) です。
scrypt(password, 'salt', 24, (err, key) => {
  if (err) throw err
  // 次に、ランダムな初期化ベクトルを生成します。
  randomFill(new Uint8Array(16), (err, iv) => {
    if (err) throw err

    // キーと IV が揃ったら、暗号を作成して使用できます...
    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('いくつかの平文データ')
    cipher.end()
  })
})
js
const { scrypt, randomFill, createCipheriv } = require('node:crypto')

const algorithm = 'aes-192-cbc'
const password = 'キーを生成するために使用されるパスワード'

// まず、キーを生成します。キーの長さはアルゴリズムに依存します。
// この場合、aes192 の場合は 24 バイト (192 ビット) です。
scrypt(password, 'salt', 24, (err, key) => {
  if (err) throw err
  // 次に、ランダムな初期化ベクトルを生成します。
  randomFill(new Uint8Array(16), (err, iv) => {
    if (err) throw err

    // キーと IV が揃ったら、暗号を作成して使用できます...
    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('いくつかの平文データ')
    cipher.end()
  })
})

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

js
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 = 'キーを生成するために使用されるパスワード'

// まず、キーを生成します。キーの長さはアルゴリズムに依存します。
// この場合、aes192 の場合は 24 バイト (192 ビット) です。
scrypt(password, 'salt', 24, (err, key) => {
  if (err) throw err
  // 次に、ランダムな初期化ベクトルを生成します。
  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
    })
  })
})
js
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 = 'キーを生成するために使用されるパスワード'

// まず、キーを生成します。キーの長さはアルゴリズムに依存します。
// この場合、aes192 の場合は 24 バイト (192 ビット) です。
scrypt(password, 'salt', 24, (err, key) => {
  if (err) throw err
  // 次に、ランダムな初期化ベクトルを生成します。
  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() メソッドを使用する:

js
const { scrypt, randomFill, createCipheriv } = await import('node:crypto')

const algorithm = 'aes-192-cbc'
const password = 'キーを生成するために使用されるパスワード'

// まず、キーを生成します。キーの長さはアルゴリズムに依存します。
// この場合、aes192 の場合は 24 バイト (192 ビット) です。
scrypt(password, 'salt', 24, (err, key) => {
  if (err) throw err
  // 次に、ランダムな初期化ベクトルを生成します。
  randomFill(new Uint8Array(16), (err, iv) => {
    if (err) throw err

    const cipher = createCipheriv(algorithm, key, iv)

    let encrypted = cipher.update('いくつかの平文データ', 'utf8', 'hex')
    encrypted += cipher.final('hex')
    console.log(encrypted)
  })
})
js
const { scrypt, randomFill, createCipheriv } = require('node:crypto')

const algorithm = 'aes-192-cbc'
const password = 'キーを生成するために使用されるパスワード'

// まず、キーを生成します。キーの長さはアルゴリズムに依存します。
// この場合、aes192 の場合は 24 バイト (192 ビット) です。
scrypt(password, 'salt', 24, (err, key) => {
  if (err) throw err
  // 次に、ランダムな初期化ベクトルを生成します。
  randomFill(new Uint8Array(16), (err, iv) => {
    if (err) throw err

    const cipher = createCipheriv(algorithm, key, iv)

    let encrypted = cipher.update('いくつかの平文データ', '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

認証付き暗号化モード（現在、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 で暗号を更新します。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 で追加

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

  • 可読ストリームと書き込み可能ストリームの両方であるストリームとして使用する場合、暗号化されたプレーンデータが書き込まれ、可読側で復号化されたデータが生成されます。
  • decipher.update()メソッドとdecipher.final()メソッドを使用して、復号化されたデータを生成します。

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

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

js
import { Buffer } from 'node:buffer'
const { scryptSync, createDecipheriv } = await import('node:crypto')

const algorithm = 'aes-192-cbc'
const password = 'キーの生成に使用するパスワード'
// キーの長さはアルゴリズムに依存します。この場合、aes192では、
// 24バイト（192ビット）です。
// 代わりに非同期の`crypto.scrypt()`を使用してください。
const key = scryptSync(password, 'salt', 24)
// IVは通常、暗号文と一緒に渡されます。
const iv = Buffer.alloc(16, 0) // 初期化ベクトル。

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)
  // 出力: some clear text data
})

// 同じアルゴリズム、キー、IVで暗号化。
const encrypted = 'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa'
decipher.write(encrypted, 'hex')
decipher.end()
js
const { scryptSync, createDecipheriv } = require('node:crypto')
const { Buffer } = require('node:buffer')

const algorithm = 'aes-192-cbc'
const password = 'キーの生成に使用するパスワード'
// キーの長さはアルゴリズムに依存します。この場合、aes192では、
// 24バイト（192ビット）です。
// 代わりに非同期の`crypto.scrypt()`を使用してください。
const key = scryptSync(password, 'salt', 24)
// IVは通常、暗号文と一緒に渡されます。
const iv = Buffer.alloc(16, 0) // 初期化ベクトル。

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)
  // 出力: some clear text data
})

// 同じアルゴリズム、キー、IVで暗号化。
const encrypted = 'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa'
decipher.write(encrypted, 'hex')
decipher.end()

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

js
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 = 'キーの生成に使用するパスワード'
// 代わりに非同期の`crypto.scrypt()`を使用してください。
const key = scryptSync(password, 'salt', 24)
// IVは通常、暗号文と一緒に渡されます。
const iv = Buffer.alloc(16, 0) // 初期化ベクトル。

const decipher = createDecipheriv(algorithm, key, iv)

const input = createReadStream('test.enc')
const output = createWriteStream('test.js')

input.pipe(decipher).pipe(output)
js
const { createReadStream, createWriteStream } = require('node:fs')
const { scryptSync, createDecipheriv } = require('node:crypto')
const { Buffer } = require('node:buffer')

const algorithm = 'aes-192-cbc'
const password = 'キーの生成に使用するパスワード'
// 代わりに非同期の`crypto.scrypt()`を使用してください。
const key = scryptSync(password, 'salt', 24)
// IVは通常、暗号文と一緒に渡されます。
const iv = Buffer.alloc(16, 0) // 初期化ベクトル。

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()メソッドを使用する:

js
import { Buffer } from 'node:buffer'
const { scryptSync, createDecipheriv } = await import('node:crypto')

const algorithm = 'aes-192-cbc'
const password = 'キーの生成に使用するパスワード'
// 代わりに非同期の`crypto.scrypt()`を使用してください。
const key = scryptSync(password, 'salt', 24)
// IVは通常、暗号文と一緒に渡されます。
const iv = Buffer.alloc(16, 0) // 初期化ベクトル。

const decipher = createDecipheriv(algorithm, key, iv)

// 同じアルゴリズム、キー、IVを使用して暗号化。
const encrypted = 'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa'
let decrypted = decipher.update(encrypted, 'hex', 'utf8')
decrypted += decipher.final('utf8')
console.log(decrypted)
// 出力: some clear text data
js
const { scryptSync, createDecipheriv } = require('node:crypto')
const { Buffer } = require('node:buffer')

const algorithm = 'aes-192-cbc'
const password = 'キーの生成に使用するパスワード'
// 代わりに非同期の`crypto.scrypt()`を使用してください。
const key = scryptSync(password, 'salt', 24)
// IVは通常、暗号文と一緒に渡されます。
const iv = Buffer.alloc(16, 0) // 初期化ベクトル。

const decipher = createDecipheriv(algorithm, key, iv)

// 同じアルゴリズム、キー、IVを使用して暗号化。
const encrypted = 'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa'
let decrypted = decipher.update(encrypted, 'hex', 'utf8')
decrypted += decipher.final('utf8')
console.log(decrypted)
// 出力: some clear text data

decipher.final([outputEncoding]) ​

Added in: v0.1.94

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

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

decipher.setAAD(buffer[, options]) ​

[History]

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

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

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

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

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

decipher.setAuthTag(buffer[, encoding]) ​

[履歴]

バージョン変更
v22.0.0, v20.13.0decipher の作成時に authTagLength オプションを指定せずに 128 ビット以外の GCM タグ長を使用することは非推奨になりました。
v15.0.0buffer 引数は、文字列または ArrayBuffer にすることができ、最大 2 ** 31 - 1 バイトに制限されています。
v11.0.0このメソッドは、GCM タグ長が無効な場合にスローするようになりました。
v7.2.0このメソッドは decipher への参照を返すようになりました。
v1.0.0追加: v1.0.0

認証付き暗号化モード (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 で更新します。 inputEncoding 引数が与えられた場合、data 引数は指定されたエンコーディングを使用した文字列になります。 inputEncoding 引数が与えられなかった場合、data は Buffer である必要があります。 data が Buffer の場合、inputEncoding は無視されます。

outputEncoding は、暗号化されたデータの出力形式を指定します。 outputEncoding が指定されている場合、指定されたエンコーディングを使用した文字列が返されます。 outputEncoding が指定されていない場合は、Buffer が返されます。

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

基盤となる暗号が認証を実装している場合でも、この関数から返されるプレーンテキストの信頼性と整合性は、この時点では不確実である可能性があります。認証付き暗号化アルゴリズムの場合、認証は通常、アプリケーションが decipher.final() を呼び出した場合にのみ確立されます。

クラス: DiffieHellman ​

追加: v0.5.0

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

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

js
import assert from 'node:assert'

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

// Aliceの鍵を生成...
const alice = createDiffieHellman(2048)
const aliceKey = alice.generateKeys()

// Bobの鍵を生成...
const bob = createDiffieHellman(alice.getPrime(), alice.getGenerator())
const bobKey = bob.generateKeys()

// 交換して秘密を生成...
const aliceSecret = alice.computeSecret(bobKey)
const bobSecret = bob.computeSecret(aliceKey)

// OK
assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex'))
js
const assert = require('node:assert')

const { createDiffieHellman } = require('node:crypto')

// Aliceの鍵を生成...
const alice = createDiffieHellman(2048)
const aliceKey = alice.generateKeys()

// Bobの鍵を生成...
const bob = createDiffieHellman(alice.getPrime(), alice.getGenerator())
const bobKey = bob.generateKeys()

// 交換して秘密を生成...
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 を相手側の公開鍵として使用して共有秘密を計算し、計算された共有秘密を返します。指定されたキーは、指定された inputEncoding を使用して解釈され、秘密は指定された outputEncoding を使用してエンコードされます。inputEncoding が指定されていない場合、otherPublicKey は Buffer、TypedArray、または DataView であると想定されます。

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

diffieHellman.generateKeys([encoding]) ​

追加: v0.5.0

まだ生成または計算されていない場合、Diffie-Hellman の秘密鍵と公開鍵の値を生成し、指定されたencodingで公開鍵を返します。この鍵は相手に転送する必要があります。encodingが提供された場合は文字列が返され、そうでない場合はBufferが返されます。

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

diffieHellman.getGenerator([encoding]) ​

追加: v0.5.0

指定されたencodingで Diffie-Hellman ジェネレーターを返します。encodingが提供された場合は文字列が返され、そうでない場合はBufferが返されます。

diffieHellman.getPrime([encoding]) ​

追加: v0.5.0

指定されたencodingで Diffie-Hellman 素数を返します。encodingが提供された場合は文字列が返され、そうでない場合はBufferが返されます。

diffieHellman.getPrivateKey([encoding]) ​

追加: v0.5.0

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

diffieHellman.getPublicKey([encoding]) ​

追加: v0.5.0

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

diffieHellman.setPrivateKey(privateKey[, encoding]) ​

追加: v0.5.0

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

この関数は、関連付けられた公開鍵を自動的に計算しません。diffieHellman.setPublicKey() または diffieHellman.generateKeys() を使用して、手動で公開鍵を提供するか、自動的に導出することができます。

diffieHellman.setPublicKey(publicKey[, encoding]) ​

追加: v0.5.0

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()メソッドを実装していません。

js
const { createDiffieHellmanGroup } = await import('node:crypto')
const dh = createDiffieHellmanGroup('modp16')
js
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() 関数を使用して作成できます。

js
import assert from 'node:assert'

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

// Aliceの鍵を生成...
const alice = createECDH('secp521r1')
const aliceKey = alice.generateKeys()

// Bobの鍵を生成...
const bob = createECDH('secp521r1')
const bobKey = bob.generateKeys()

// 交換して秘密鍵を生成...
const aliceSecret = alice.computeSecret(bobKey)
const bobSecret = bob.computeSecret(aliceKey)

assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex'))
// OK
js
const assert = require('node:assert')

const { createECDH } = require('node:crypto')

// Aliceの鍵を生成...
const alice = createECDH('secp521r1')
const aliceKey = alice.generateKeys()

// Bobの鍵を生成...
const bob = createECDH('secp521r1')
const bobKey = bob.generateKeys()

// 交換して秘密鍵を生成...
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 と 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 であると想定されます。

例（キーの非圧縮）：

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

// 変換されたキーと非圧縮の公開キーは同じである必要があります
console.log(uncompressedKey === ecdh.getPublicKey('hex'))
js
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')

// 変換されたキーと非圧縮の公開キーは同じである必要があります
console.log(uncompressedKey === ecdh.getPublicKey('hex'))

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

[履歴]

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

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

EC Diffie-Hellman の秘密鍵と公開鍵の値を生成し、指定されたformatとencodingで公開鍵を返します。この鍵は相手に転送する必要があります。

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

encodingが指定されている場合は文字列が返されます。そうでない場合はBufferが返されます。

ecdh.getPrivateKey([encoding]) ​

追加: v0.11.14

encodingが指定されている場合は文字列が返されます。そうでない場合はBufferが返されます。

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

追加: v0.11.14

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

encodingが指定されている場合は文字列が返されます。そうでない場合はBufferが返されます。

ecdh.setPrivateKey(privateKey[, encoding]) ​

追加: v0.11.14

EC Diffie-Hellman の秘密鍵を設定します。encoding が提供されている場合、privateKey は文字列であると想定されます。それ以外の場合、privateKey は Buffer、TypedArray、または DataView であると想定されます。

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

ecdh.setPublicKey(publicKey[, encoding]) ​

追加: v0.11.14

非推奨: v5.2.0 以降

[安定版: 0 - 非推奨]

安定版: 0 安定度: 0 - 非推奨

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

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

例（共有秘密を取得）：

js
const { createECDH, createHash } = await import('node:crypto')

const alice = createECDH('secp256k1')
const bob = createECDH('secp256k1')

// これはアリスの以前の秘密鍵の1つを指定するショートカットの方法です。
// 実際のアプリケーションでこのような予測可能な秘密鍵を使用することは賢明ではありません。
alice.setPrivateKey(createHash('sha256').update('alice', 'utf8').digest())

// ボブは、新しく生成された暗号的に強力な疑似乱数鍵ペアを使用します
bob.generateKeys()

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

// aliceSecret と bobSecret は同じ共有秘密の値である必要があります
console.log(aliceSecret === bobSecret)
js
const { createECDH, createHash } = require('node:crypto')

const alice = createECDH('secp256k1')
const bob = createECDH('secp256k1')

// これはアリスの以前の秘密鍵の1つを指定するショートカットの方法です。
// 実際のアプリケーションでこのような予測可能な秘密鍵を使用することは賢明ではありません。
alice.setPrivateKey(createHash('sha256').update('alice', 'utf8').digest())

// ボブは、新しく生成された暗号的に強力な疑似乱数鍵ペアを使用します
bob.generateKeys()

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

// aliceSecret と bobSecret は同じ共有秘密の値である必要があります
console.log(aliceSecret === bobSecret)

クラス: Hash ​

追加バージョン: v0.1.92

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

  • 読み取り可能かつ書き込み可能なストリームとして、データが書き込まれると読み取り側で計算されたハッシュダイジェストが生成されます。
  • hash.update()およびhash.digest()メソッドを使用して、計算されたハッシュを生成します。

crypto.createHash()メソッドは、Hashインスタンスを作成するために使用されます。Hashオブジェクトは、newキーワードを使用して直接作成しないでください。

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

js
const { createHash } = await import('node:crypto')

const hash = createHash('sha256')

hash.on('readable', () => {
  // ハッシュストリームによって生成される要素は1つだけです。
  const data = hash.read()
  if (data) {
    console.log(data.toString('hex'))
    // 出力:
    //   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
  }
})

hash.write('some data to hash')
hash.end()
js
const { createHash } = require('node:crypto')

const hash = createHash('sha256')

hash.on('readable', () => {
  // ハッシュストリームによって生成される要素は1つだけです。
  const data = hash.read()
  if (data) {
    console.log(data.toString('hex'))
    // 出力:
    //   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
  }
})

hash.write('some data to hash')
hash.end()

例: Hashとパイプストリームを使用する:

js
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)
js
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()メソッドを使用する:

js
const { createHash } = await import('node:crypto')

const hash = createHash('sha256')

hash.update('some data to hash')
console.log(hash.digest('hex'))
// 出力:
//   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
js
const { createHash } = require('node:crypto')

const hash = createHash('sha256')

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

hash.copy([options]) ​

追加: v13.1.0

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

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

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

js
// ローリングハッシュを計算します。
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'))

// など
js
// ローリングハッシュを計算します。
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'))

// など

hash.digest([encoding]) ​

追加: v0.1.92

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

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

hash.update(data[, inputEncoding]) ​

[履歴]

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

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

ストリームとして新しいデータが来るたびに、これを複数回呼び出すことができます。

クラス: Hmac ​

追加: v0.1.94

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

  • 読み取り可能かつ書き込み可能な ストリーム として、書き込まれたデータが読み取り側で計算された HMAC ダイジェストを生成するように使用します。
  • hmac.update() および hmac.digest() メソッドを使用して、計算された HMAC ダイジェストを生成します。

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

例: ストリームとしての Hmac オブジェクトの使用:

js
const { createHmac } = await import('node:crypto')

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

hmac.on('readable', () => {
  // ハッシュ ストリームによって生成されるのは 1 つの要素のみです。
  const data = hmac.read()
  if (data) {
    console.log(data.toString('hex'))
    // 出力:
    //   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
  }
})

hmac.write('some data to hash')
hmac.end()
js
const { createHmac } = require('node:crypto')

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

hmac.on('readable', () => {
  // ハッシュ ストリームによって生成されるのは 1 つの要素のみです。
  const data = hmac.read()
  if (data) {
    console.log(data.toString('hex'))
    // 出力:
    //   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
  }
})

hmac.write('some data to hash')
hmac.end()

例: Hmac とパイプされたストリームの使用:

js
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)
js
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() メソッドの使用:

js
const { createHmac } = await import('node:crypto')

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

hmac.update('some data to hash')
console.log(hmac.digest('hex'))
// 出力:
//   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
js
const { createHmac } = require('node:crypto')

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

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

hmac.digest([encoding]) ​

Added in: v0.1.94

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

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

hmac.update(data[, inputEncoding]) ​

[履歴]

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

与えられた data で Hmac のコンテンツを更新します。data のエンコーディングは inputEncoding で与えられます。encoding が提供されず、data が文字列である場合、'utf8' のエンコーディングが強制されます。data が Buffer、TypedArray、または DataView の場合、inputEncoding は無視されます。

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

クラス: KeyObject ​

[履歴]

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

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

js
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)
js
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.0RSA-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.0v11.6.0 で追加されました。

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

  • '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.equals(otherKeyObject) ​

追加: v17.7.0, v16.15.0

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

keyObject.export([options]) ​

[履歴]

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

対称キーの場合、次のエンコードオプションを使用できます。

  • 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 を指定することにより、任意の format で任意のキーアルゴリズム (RSA、EC、または DH) を暗号化するために使用できます。PKCS#1 および SEC1 は、PEM format が使用されている場合に cipher を指定することによってのみ暗号化できます。最大の互換性を得るには、暗号化された秘密キーには PKCS#8 を使用してください。PKCS#8 は独自の暗号化メカニズムを定義しているため、PKCS#8 キーを暗号化する場合、PEM レベルの暗号化はサポートされていません。PKCS#8 暗号化については RFC 5208 を、PKCS#1 および SEC1 暗号化については RFC 1421 を参照してください。

keyObject.symmetricKeySize ​

追加: v11.6.0

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

keyObject.toCryptoKey(algorithm, extractable, keyUsages) ​

追加: v23.0.0

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

keyObject.type ​

追加: v11.6.0

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

クラス: Sign ​

追加: v0.1.92

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

  • 書き込み可能な ストリーム として、署名するデータが書き込まれ、sign.sign() メソッドを使用して署名を生成して返すか、
  • sign.update() および sign.sign() メソッドを使用して署名を生成します。

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

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

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

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

const sign = createSign('SHA256')
sign.write('署名するデータ')
sign.end()
const signature = sign.sign(privateKey, 'hex')

const verify = createVerify('SHA256')
verify.write('署名するデータ')
verify.end()
console.log(verify.verify(publicKey, signature, 'hex'))
// Prints: true
js
const { generateKeyPairSync, createSign, createVerify } = require('node:crypto')

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

const sign = createSign('SHA256')
sign.write('署名するデータ')
sign.end()
const signature = sign.sign(privateKey, 'hex')

const verify = createVerify('SHA256')
verify.write('署名するデータ')
verify.end()
console.log(verify.verify(publicKey, signature, 'hex'))
// Prints: true

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

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

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

const sign = createSign('SHA256')
sign.update('署名するデータ')
sign.end()
const signature = sign.sign(privateKey)

const verify = createVerify('SHA256')
verify.update('署名するデータ')
verify.end()
console.log(verify.verify(publicKey, signature))
// Prints: true
js
const { generateKeyPairSync, createSign, createVerify } = require('node:crypto')

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

const sign = createSign('SHA256')
sign.update('署名するデータ')
sign.end()
const signature = sign.sign(privateKey)

const verify = createVerify('SHA256')
verify.update('署名するデータ')
verify.end()
console.log(verify.verify(publicKey, signature))
// Prints: true

sign.sign(privateKey[, outputEncoding]) ​

[履歴]

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

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 を使用します。ただし、RFC 4055 のセクション 3.3 に準拠して、キーの一部として MGF1 ハッシュ関数が指定されている場合を除きます。

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

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

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

sign.update(data[, inputEncoding]) ​

[履歴]

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

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

これはストリームとして新しいデータが供給されるため、複数回呼び出すことができます。

クラス: Verify ​

追加: v0.1.92

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

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

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

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

verify.update(data[, inputEncoding]) ​

[履歴]

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

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

これはストリームとして新しいデータが供給されるため、複数回呼び出すことができます。

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

[履歴]

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

指定された 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 を使用します。ただし、RFC 4055 の 3.3 節に準拠して、MGF1 ハッシュ関数がキーの一部として指定されている場合は除きます。

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

signature 引数は、signatureEncoding でデータに対して以前に計算された署名です。signatureEncoding が指定されている場合、signature は文字列であると予想されます。それ以外の場合、signature は Buffer、TypedArray、または DataView であると予想されます。

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

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

クラス: X509Certificate ​

追加バージョン: v15.6.0

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

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

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

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

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

console.log(x509.subject)

new X509Certificate(buffer) ​

追加バージョン: v15.6.0

x509.ca ​

追加バージョン: v15.6.0

  • タイプ: <boolean> これが認証局（CA）証明書である場合はtrueになります。

x509.checkEmail(email[, options]) ​

[履歴]

バージョン変更点
v18.0.0subject オプションのデフォルトが'default'になりました。
v17.5.0, v16.15.0subject オプションを'default'に設定できるようになりました。
v17.5.0, v16.14.1wildcards、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.0subject オプションのデフォルトが'default'になりました。
v17.5.0, v16.15.0subject オプションに'default'を設定できるようになりました。
v15.6.0v15.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 名が含まれていない場合、証明書のサブジェクトが考慮されます。

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

x509.checkIP(ip) ​

[履歴]

バージョン変更点
v17.5.0, v16.14.1options 引数は効果がなかったため削除されました。
v15.6.0v15.6.0 で追加されました。
  • ip <string>
  • 戻り値: <string> | <undefined> 証明書が一致する場合は ip を返し、一致しない場合は undefined を返します。

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

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

x509.checkIssued(otherCert) ​

追加: v15.6.0

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

x509.checkPrivateKey(privateKey) ​

追加: v15.6.0

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

x509.extKeyUsage ​

追加: v15.6.0

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

x509.fingerprint ​

追加: v15.6.0

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

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

x509.fingerprint256 ​

追加: v15.6.0

この証明書の SHA-256 指紋。

x509.fingerprint512 ​

追加: v17.2.0, v16.14.0

この証明書の SHA-512 指紋。

SHA-256 指紋の計算は通常より高速であり、SHA-512 指紋の半分程度のサイズであるため、x509.fingerprint256 の方が良い選択肢となる可能性があります。SHA-512 は一般的にセキュリティレベルが高いと考えられますが、SHA-256 のセキュリティは、証明書の署名によく使用されるほとんどのアルゴリズムと同等です。

x509.infoAccess ​

[履歴]

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

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

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

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

x509.issuer ​

追加: v15.6.0

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

x509.issuerCertificate ​

追加: v15.9.0

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

x509.publicKey ​

追加: v15.6.0

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

x509.raw ​

追加: v15.6.0

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

x509.serialNumber ​

追加: v15.6.0

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

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

x509.subject ​

追加: v15.6.0

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

x509.subjectAltName ​

[履歴]

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

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

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

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

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

x509.toJSON() ​

追加: v15.6.0

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

x509.toLegacyObject() ​

追加: v15.6.0

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

x509.toString() ​

追加: v15.6.0

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

x509.validFrom ​

追加: v15.6.0

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

x509.validFromDate ​

追加: v23.0.0

この証明書が有効になる日時をDateオブジェクトでカプセル化したもの。

x509.validTo ​

追加: v15.6.0

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

x509.validToDate ​

追加: v23.0.0

この証明書が有効期限切れになる日時をDateオブジェクトでカプセル化したもの。

x509.verify(publicKey) ​

追加: v15.6.0

この証明書が与えられた公開鍵で署名されたことを検証します。証明書に対する他の検証チェックは行いません。

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

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

[履歴]

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

  • candidate <ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint> 任意の長さのビッグエンディアンオクテットのシーケンスとしてエンコードされた、素数の候補。

  • options <Object>

    • checks <number> 実行するミラー・ラビン確率的素数判定の反復回数。値が 0 (ゼロ) の場合、ランダムな入力に対して最大 2 の偽陽性率を生成するチェック数が使用されます。チェック数を選択する際には注意が必要です。詳細については、OpenSSL の BN_is_prime_ex 関数の nchecks オプションのドキュメントを参照してください。デフォルト: 0

  • callback <Function>

    • err <Error> チェック中にエラーが発生した場合、<Error> オブジェクトに設定されます。
    • result <boolean> candidate が素数であり、エラー確率が 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 の偽陽性率を生成するチェック数が使用されます。チェック数を選択する際には注意が必要です。詳細については、OpenSSL ドキュメントのBN_is_prime_ex関数の nchecks オプションを参照してください。 デフォルト: 0

  • 戻り値: <boolean> candidate が 0.25 ** options.checks 未満のエラー確率を持つ素数の場合は true。

candidate の素数性を確認します。

crypto.constants ​

追加: v6.3.0

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

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

[履歴]

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

指定されたalgorithm、key、および初期化ベクトル（iv）を使用して、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で利用可能な暗号アルゴリズムが表示されます。

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

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

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

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

[履歴]

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

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

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

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

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

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

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

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

[履歴]

バージョン変更点
v8.0.0prime 引数に TypedArray または DataView を指定できるようになりました。
v8.0.0prime 引数に Uint8Array を指定できるようになりました。
v6.0.0エンコーディングパラメーターのデフォルトが binary から utf8 に変更されました。
v0.11.12v0.11.12 で追加。

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

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

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

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

crypto.createDiffieHellman(primeLength[, generator]) ​

Added in: v0.5.0

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

crypto.createDiffieHellmanGroup(name) ​

Added in: v0.9.3

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

crypto.createECDH(curveName) ​

Added in: v0.11.14

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

crypto.createHash(algorithm[, options]) ​

[History]

VersionChanges
v12.8.0outputLengthオプションが XOF ハッシュ関数に追加されました。
v0.1.92Added in: v0.1.92

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

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

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

js
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', () => {
  // ハッシュストリームによって生成される要素は1つだけです。
  const data = input.read()
  if (data) hash.update(data)
  else {
    console.log(`${hash.digest('hex')} ${filename}`)
  }
})
js
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', () => {
  // ハッシュストリームによって生成される要素は1つだけです。
  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 でも可能になりました。encoding オプションが追加されました。キーは 2 ** 32 - 1 バイトを超えることはできません。
v11.6.0key 引数が KeyObject になりました。
v0.1.94v0.1.94 で追加されました。

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

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

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

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

js
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', () => {
  // ハッシュストリームによって生成される要素は 1 つだけです。
  const data = input.read()
  if (data) hmac.update(data)
  else {
    console.log(`${hmac.digest('hex')} ${filename}`)
  }
})
js
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', () => {
  // ハッシュストリームによって生成される要素は 1 つだけです。
  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 にもできます。encoding オプションが追加されました。キーには 2 ** 32 - 1 バイトを超えることはできません。
v11.6.0v11.6.0 で追加されました。

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

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

crypto.createPublicKey(key) ​

[履歴]

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

公開鍵を含む新しいキーオブジェクトを作成して返します。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]) ​

[History]

VersionChanges
v18.8.0, v16.18.0The key can now be zero-length.
v15.0.0The key can also be an ArrayBuffer or string. The encoding argument was added. The key cannot contain more than 2 ** 32 - 1 bytes.
v11.6.0Added in: v11.6.0

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

crypto.createSign(algorithm[, options]) ​

Added in: v0.1.92

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

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

crypto.createVerify(algorithm[, options]) ​

追加: v0.1.92

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

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

crypto.diffieHellman(options) ​

追加: v13.9.0, v12.17.0

privateKey と publicKey に基づいて Diffie-Hellman 秘密を計算します。両方のキーは同じ asymmetricKeyType を持つ必要があり、それは 'dh' (Diffie-Hellman 用)、'ec'、'x448'、または 'x25519' (ECDH 用) のいずれかである必要があります。

crypto.fips ​

追加: v6.0.0

非推奨: v10.0.0

[安定度: 0 - 非推奨]

安定度: 0 安定度: 0 - 非推奨

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

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

crypto.generateKey(type, options, callback) ​

[履歴]

バージョン変更点
v18.0.0callback引数に無効なコールバックを渡すと、ERR_INVALID_CALLBACKではなくERR_INVALID_ARG_TYPEがスローされるようになりました。
v15.0.0v15.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>

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

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

generateKey('hmac', { length: 512 }, (err, key) => {
  if (err) throw err
  console.log(key.export().toString('hex')) // 46e..........620
})
js
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.0callback 引数に無効なコールバックを渡すと、ERR_INVALID_CALLBACK の代わりに ERR_INVALID_ARG_TYPE がスローされるようになりました。
v16.10.0RSA-PSS キーペアの RSASSA-PSS-params シーケンスパラメータを定義する機能を追加しました。
v13.9.0, v12.17.0Diffie-Hellman のサポートを追加しました。
v12.0.0RSA-PSS キーペアのサポートを追加しました。
v12.0.0X25519 および X448 キーペアを生成する機能を追加しました。
v12.0.0Ed25519 および Ed448 キーペアを生成する機能を追加しました。
v11.6.0エンコーディングが指定されていない場合、generateKeyPair および generateKeyPairSync 関数はキーオブジェクトを生成するようになりました。
v10.12.0v10.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>

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

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

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

js
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) => {
    // エラーを処理し、生成されたキーペアを使用します。
  }
)
js
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) => {
    // エラーを処理し、生成されたキーペアを使用します。
  }
)

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

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

crypto.generateKeyPairSync(type, options) ​

[履歴]

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

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

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

公開鍵をエンコードする場合、'spki' を使用することをお勧めします。秘密鍵をエンコードする場合、強力なパスフレーズを使用して 'pkcs8' を使用し、パスフレーズを秘密にしておくことをお勧めします。

js
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',
  },
})
js
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 に対して実行される検証を決定します。

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

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

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

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

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

[履歴]

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

size ビットの擬似乱数素数を生成します。

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

options.add および options.rem パラメーターを使用して、Diffie-Hellman などの追加要件を強制できます。

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

ArrayBuffer、SharedArrayBuffer、TypedArray、Buffer、または DataView として指定された場合、options.add と options.rem の両方をビッグエンディアンシーケンスとしてエンコードする必要があります。

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

crypto.generatePrimeSync(size[, options]) ​

追加: v15.8.0

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.getCipherInfo(nameOrNid[, options]) ​

Added in: v15.0.0

  • nameOrNid: <string> | <number> クエリ対象の暗号の名前または NID。
  • options: <Object>
    • keyLength: <number> テスト用の鍵長。
    • ivLength: <number> テスト用の IV 長。
  • Returns: <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[] サポートされている暗号アルゴリズムの名前の配列。
js
const { getCiphers } = await import('node:crypto')

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

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

crypto.getCurves() ​

追加: v2.3.0

  • 戻り値: string[] サポートされている楕円曲線の名前の配列。
js
const { getCurves } = await import('node:crypto')

console.log(getCurves()) // ['Oakley-EC2N-3', 'Oakley-EC2N-4', ...]
js
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() など）は許可しません。このメソッドを使用する利点は、当事者が事前にグループモジュラスを生成したり交換したりする必要がなく、プロセッサと通信時間の両方を節約できることです。

例（共有秘密の取得）:

js
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とbobSecretは同じであるべきです */
console.log(aliceSecret === bobSecret)
js
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とbobSecretは同じであるべきです */
console.log(aliceSecret === bobSecret)

crypto.getFips() ​

追加: v10.0.0

  • 戻り値: <number> FIPS 準拠の暗号化プロバイダーが現在使用されている場合にのみ1、それ以外の場合は0を返します。将来の semver メジャーリリースでは、この API の戻り値の型が<boolean>に変更される可能性があります。

crypto.getHashes() ​

追加: v0.9.3

  • 戻り値: <string[]> サポートされているハッシュアルゴリズムの名前の配列。例：'RSA-SHA256'。ハッシュアルゴリズムは、「ダイジェスト」アルゴリズムとも呼ばれます。
js
const { getHashes } = await import('node:crypto')

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

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

crypto.getRandomValues(typedArray) ​

追加: v17.4.0

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

crypto.hash(algorithm, data[, outputEncoding]) ​

追加: v21.7.0, v20.12.0

[安定: 1 - 試験的]

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

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

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

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

例：

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

// 文字列をハッシュ化し、結果を16進エンコードされた文字列として返します。
const string = 'Node.js'
// 10b3493287f831e81a438811a1ffba01f8cec4b7
console.log(crypto.hash('sha1', string))

// base64エンコードされた文字列を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'))
js
import crypto from 'node:crypto'
import { Buffer } from 'node:buffer'

// 文字列をハッシュ化し、結果を16進エンコードされた文字列として返します。
const string = 'Node.js'
// 10b3493287f831e81a438811a1ffba01f8cec4b7
console.log(crypto.hash('sha1', string))

// base64エンコードされた文字列を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.hkdf(digest, ikm, salt, info, keylen, callback) ​

[履歴]

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

HKDF は、RFC 5869 で定義されている単純なキー導出関数です。指定された ikm、salt、info が、digest とともに使用され、keylen バイトのキーを導出します。

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

js
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'
})
js
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.0v15.0.0 で追加

RFC 5869 で定義されている同期 HKDF キー導出関数を提供します。指定された ikm、salt、および info は、digest とともに使用され、keylen バイトのキーを導出します。

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

入力引数に無効な値または型が指定されている場合、または導出キーを生成できない場合は、エラーがスローされます。

js
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'
js
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.0callback 引数に無効なコールバックを渡すと、ERR_INVALID_CALLBACK ではなく ERR_INVALID_ARG_TYPE がスローされるようになりました。
v15.0.0password および salt 引数に ArrayBuffer インスタンスも使用できるようになりました。
v14.0.0iterations パラメータが正の値に制限されるようになりました。以前のリリースでは、他の値は 1 として扱われていました。
v8.0.0digest パラメータが常に必須になりました。
v6.0.0digest パラメータを渡さずにこの関数を呼び出すことは非推奨となり、警告が発行されるようになりました。
v6.0.0文字列である場合の password のデフォルトエンコーディングが binary から utf8 に変更されました。
v0.5.5v0.5.5 で追加されました。

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

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

iterations 引数は、できるだけ高い数値に設定する必要があります。イテレーションの回数が多くなるほど、導出された鍵はより安全になりますが、完了までに時間がかかります。

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

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

js
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'
})
js
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.0iterations パラメーターは正の値に制限されるようになりました。以前のリリースでは、他の値は 1 として扱われていました。
v6.0.0digest パラメーターを渡さずにこの関数を呼び出すことは非推奨となり、警告を発するようになりました。
v6.0.0文字列の場合の password のデフォルトエンコーディングが binary から utf8 に変更されました。
v0.9.3v0.9.3 で追加

同期的な Password-Based Key Derivation Function 2 (PBKDF2) の実装を提供します。digest で指定された選択された HMAC ダイジェストアルゴリズムが、password、salt、および iterations から要求されたバイト長 (keylen) のキーを導出するために適用されます。

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

iterations 引数は、できるだけ高い数値に設定する必要があります。イテレーションの数が多いほど、導出されたキーはより安全になりますが、完了するまでに時間がかかります。

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

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

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

const key = pbkdf2Sync('secret', 'salt', 100000, 64, 'sha512')
console.log(key.toString('hex')) // '3745e48...08d59ae'
js
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.1OpenSSL ビルドが暗黙的な拒否をサポートしていない場合、RSA_PKCS1_PADDINGパディングは無効になりました。
v15.0.0キータイプとして文字列、ArrayBuffer、CryptoKey が許可されるようになりました。oaepLabel は ArrayBuffer にすることができます。バッファーは文字列または ArrayBuffer にすることができます。バッファーを受け入れるすべての型は、最大 2 ** 31 - 1 バイトに制限されます。
v12.11.0oaepLabelオプションが追加されました。
v12.9.0oaepHashオプションが追加されました。
v11.6.0この関数はキーオブジェクトをサポートするようになりました。
v0.11.14v0.11.14 で追加されました。

privateKeyを使用してbufferを復号化します。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文字列、ArrayBuffer、および CryptoKey を許可されるキータイプとして追加。パスフレーズは ArrayBuffer にできます。バッファーは文字列または ArrayBuffer にできます。バッファーを受け入れるすべての型は最大 2 ** 31 - 1 バイトに制限されています。
v11.6.0この関数はキーオブジェクトをサポートするようになりました。
v1.1.0v1.1.0 で追加。

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

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

crypto.publicDecrypt(key, buffer) ​

[履歴]

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

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

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

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

crypto.publicEncrypt(key, buffer) ​

[履歴]

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

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

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

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

crypto.randomBytes(size[, callback]) ​

[履歴]

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

  • size <number> 生成するバイト数。size は 2**31 - 1 より大きくすることはできません。

  • callback <Function>

  • 戻り値: callback 関数が提供されていない場合は、<Buffer>。

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

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

js
// 非同期
const { randomBytes } = await import('node:crypto')

randomBytes(256, (err, buf) => {
  if (err) throw err
  console.log(`${buf.length} バイトのランダムデータ: ${buf.toString('hex')}`)
})
js
// 非同期
const { randomBytes } = require('node:crypto')

randomBytes(256, (err, buf) => {
  if (err) throw err
  console.log(`${buf.length} バイトのランダムデータ: ${buf.toString('hex')}`)
})

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

js
// 同期
const { randomBytes } = await import('node:crypto')

const buf = randomBytes(256)
console.log(`${buf.length} バイトのランダムデータ: ${buf.toString('hex')}`)
js
// 同期
const { randomBytes } = require('node:crypto')

const buf = randomBytes(256)
console.log(`${buf.length} バイトのランダムデータ: ${buf.toString('hex')}`)

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

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

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

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

[履歴]

バージョン変更点
v18.0.0callback 引数に無効なコールバックを渡すと、ERR_INVALID_CALLBACK ではなく ERR_INVALID_ARG_TYPE がスローされるようになりました。
v9.0.0buffer 引数には任意の 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 関数が提供されていない場合は、エラーがスローされます。

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

// 上記は下記と同等です:
randomFill(buf, 5, 5, (err, buf) => {
  if (err) throw err
  console.log(buf.toString('hex'))
})
js
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'))
})

// 上記は下記と同等です:
randomFill(buf, 5, 5, (err, buf) => {
  if (err) throw err
  console.log(buf.toString('hex'))
})

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

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

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

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

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

crypto.randomFillSync(buffer[, offset][, size]) ​

[履歴]

バージョン変更点
v9.0.0buffer 引数に任意の TypedArray または DataView を指定できるようになりました。
v7.10.0, v6.13.0追加: v7.10.0, v6.13.0

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

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

// 上記は以下と同等です:
randomFillSync(buf, 5, 5)
console.log(buf.toString('hex'))
js
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'))

// 上記は以下と同等です:
randomFillSync(buf, 5, 5)
console.log(buf.toString('hex'))

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

js
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'))
js
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.randomInt([min, ]max[, callback]) ​

[履歴]

バージョン変更
v18.0.0callback 引数に無効なコールバックを渡すと、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 関数が提供されない場合、乱数整数は同期的に生成されます。

js
// 非同期
const { randomInt } = await import('node:crypto')

randomInt(3, (err, n) => {
  if (err) throw err
  console.log(`(0, 1, 2) から選ばれた乱数: ${n}`)
})
js
// 非同期
const { randomInt } = require('node:crypto')

randomInt(3, (err, n) => {
  if (err) throw err
  console.log(`(0, 1, 2) から選ばれた乱数: ${n}`)
})
js
// 同期
const { randomInt } = await import('node:crypto')

const n = randomInt(3)
console.log(`(0, 1, 2) から選ばれた乱数: ${n}`)
js
// 同期
const { randomInt } = require('node:crypto')

const n = randomInt(3)
console.log(`(0, 1, 2) から選ばれた乱数: ${n}`)
js
// `min` 引数付き
const { randomInt } = await import('node:crypto')

const n = randomInt(1, 7)
console.log(`サイコロの目は: ${n}`)
js
// `min` 引数付き
const { randomInt } = require('node:crypto')

const n = randomInt(1, 7)
console.log(`サイコロの目は: ${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.0callback引数に無効なコールバックを渡すと、ERR_INVALID_CALLBACKではなくERR_INVALID_ARG_TYPEがスローされるようになりました。
v15.0.0password と salt 引数に ArrayBuffer インスタンスも使用できるようになりました。
v12.8.0, v10.17.0maxmemの値は安全な整数であればどのような値でも使用できるようになりました。
v10.9.0cost, blockSize, parallelizationオプション名が追加されました。
v10.5.0追加: v10.5.0

非同期scryptの実装を提供します。Scrypt はパスワードベースの鍵導出関数であり、ブルートフォース攻撃を不利にするために、計算とメモリの両方で負荷が高くなるように設計されています。

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

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

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

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

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

// ファクトリのデフォルトを使用する。
scrypt('password', 'salt', 64, (err, derivedKey) => {
  if (err) throw err
  console.log(derivedKey.toString('hex')) // '3745e48...08d59ae'
})
// カスタムのNパラメータを使用する。2のべき乗でなければならない。
scrypt('password', 'salt', 64, { N: 1024 }, (err, derivedKey) => {
  if (err) throw err
  console.log(derivedKey.toString('hex')) // '3745e48...aa39b34'
})
js
const { scrypt } = require('node:crypto')

// ファクトリのデフォルトを使用する。
scrypt('password', 'salt', 64, (err, derivedKey) => {
  if (err) throw err
  console.log(derivedKey.toString('hex')) // '3745e48...08d59ae'
})
// カスタムのNパラメータを使用する。2のべき乗でなければならない。
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.0maxmem の値が任意の安全な整数にできるようになりました。
v10.9.0cost, blockSize, および parallelization オプション名が追加されました。
v10.5.0v10.5.0 で追加されました。

  • password <string> | <Buffer> | <TypedArray> | <DataView>

  • salt <string> | <Buffer> | <TypedArray> | <DataView>

  • keylen <number>

  • options <Object>

    • cost <number> CPU/メモリコストパラメータ。2 より大きい 2 のべき乗でなければなりません。デフォルト: 16384。
    • blockSize <number> ブロックサイズパラメータ。デフォルト: 8。
    • parallelization <number> 並列化パラメータ。デフォルト: 1。
    • N <number> cost のエイリアス。両方のうちの 1 つのみを指定できます。
    • r <number> blockSize のエイリアス。両方のうちの 1 つのみを指定できます。
    • p <number> parallelization のエイリアス。両方のうちの 1 つのみを指定できます。
    • maxmem <number> メモリの上限。(おおよそ) 128 * N * r > maxmem の場合、エラーになります。デフォルト: 32 * 1024 * 1024。

  • 戻り値: <Buffer>

同期的な scrypt 実装を提供します。Scrypt は、ブルートフォース攻撃を無意味にするために、計算上およびメモリ上でコストがかかるように設計されたパスワードベースの鍵導出関数です。

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

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

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

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

js
const { scryptSync } = await import('node:crypto')
// ファクトリーデフォルトを使用します。

const key1 = scryptSync('password', 'salt', 64)
console.log(key1.toString('hex')) // '3745e48...08d59ae'
// カスタム N パラメータを使用します。2 のべき乗である必要があります。
const key2 = scryptSync('password', 'salt', 64, { N: 1024 })
console.log(key2.toString('hex')) // '3745e48...aa39b34'
js
const { scryptSync } = require('node:crypto')
// ファクトリーデフォルトを使用します。

const key1 = scryptSync('password', 'salt', 64)
console.log(key1.toString('hex')) // '3745e48...08d59ae'
// カスタム N パラメータを使用します。2 のべき乗である必要があります。
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> 割り当てられたtotalバイトに対するusedの計算された比率。

crypto.setEngine(engine[, flags]) ​

[履歴]

バージョン変更点
v22.4.0, v20.16.0OpenSSL 3 でのカスタムエンジンサポートは非推奨になりました。
v0.11.11追加: v0.11.11

OpenSSL 関数のいくつかまたはすべて（フラグで選択）に対して engine をロードおよび設定します。OpenSSL でのカスタムエンジンのサポートは、OpenSSL 3 以降非推奨になっています。

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.0callback引数に無効なコールバックを渡すと、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

指定された秘密鍵とアルゴリズムを使用して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

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

crypto.timingSafeEqual(a, b) ​

[履歴]

バージョン変更点
v15.0.0a と b の引数に ArrayBuffer も使用可能になりました。
v6.6.0追加: v6.6.0

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

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

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

a と b の少なくとも一方が、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.0callback 引数に無効なコールバックを渡すと、ERR_INVALID_CALLBACK の代わりに ERR_INVALID_ARG_TYPE がスローされるようになりました。
v15.12.0オプションの callback 引数が追加されました。
v15.0.0data、key、signature 引数に ArrayBuffer も使用できるようになりました。
v13.2.0, v12.16.0この関数は、IEEE-P1363 DSA および ECDSA 署名をサポートするようになりました。
v12.0.0v12.0.0 で追加されました

指定された鍵とアルゴリズムを使用して、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 文字列のバイト表現は、文字列の作成元のバイトシーケンスと等しくない可能性があります。暗号、ハッシュ関数、署名アルゴリズム、および鍵導出関数の出力は、擬似ランダムなバイトシーケンスであり、Unicode 文字列として使用しないでください。
  • 文字列がユーザー入力から取得される場合、一部の Unicode 文字は、異なるバイトシーケンスになる複数の同等の方法で表現できます。たとえば、PBKDF2 や scrypt などの鍵導出関数にユーザーパスフレーズを渡す場合、鍵導出関数の結果は、文字列が合成文字を使用するか分解文字を使用するかによって異なります。Node.js は文字表現を正規化しません。開発者は、暗号 API に渡す前に、ユーザー入力で String.prototype.normalize() を使用することを検討する必要があります。

レガシーストリーム API (Node.js 0.10 より前) ​

Crypto モジュールは、統一されたストリーム API の概念や、バイナリデータを処理するためのBufferオブジェクトができる前に Node.js に追加されました。そのため、多くのcryptoクラスには、ストリーム 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()は正確に 1 回呼び出す必要があります。
  • update()の呼び出しはメッセージの暗号化/復号化に十分ですが、アプリケーションは認証タグを計算または検証するために必ずfinal()を呼び出す必要があります。
js
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)
js
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 構成ファイルで構成する必要があります。構成ファイルの例は次のとおりです。

text
nodejs_conf = nodejs_init

.include /<絶対パス>/fipsmodule.cnf

[nodejs_init]
providers = provider_sect

[provider_sect]
default = default_sect
# fips セクション名は、 {#the-fips-section-name-should-match-the-section-name-inside-the}
# インクルードされた fipsmodule.cnf 内のセクション名と一致する必要があります。
fips = fips_sect

[default_sect]
activate = 1

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

bash
openssl fipsinstall

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

bash
export OPENSSL_CONF=/<構成ファイルへのパス>/nodejs.cnf
export OPENSSL_MODULES=/<openssl libへのパス>/ossl-modules

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

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

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

text
nodejs_conf = nodejs_init

.include /<絶対パス>/fipsmodule.cnf

[nodejs_init]
providers = provider_sect
alg_section = algorithm_sect

[provider_sect]
default = default_sect
# fips セクション名は、 {#included-fipsmodulecnf}
# インクルードされた 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_ALLOpenSSL 内で複数のバグ回避策を適用します。詳細については、https://www.openssl.org/docs/man3.0/man3/SSL_CTX_set_options.html を参照してください。
SSL_OP_ALLOW_NO_DHE_KEXTLS v1.3 に対して、[EC]DHE ベースではない鍵交換モードを許可するように OpenSSL に指示します。
SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATIONOpenSSL とパッチが適用されていないクライアントまたはサーバー間のレガシーの安全でない再ネゴシエーションを許可します。 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_ANYCONNECTOpenSSL に、DTLS_BAD_VER の Cisco のバージョン識別子を使用するように指示します。
SSL_OP_COOKIE_EXCHANGEOpenSSL に、クッキー交換を有効にするように指示します。
SSL_OP_CRYPTOPRO_TLSEXT_BUGOpenSSL に、初期バージョンの cryptopro ドラフトからのサーバーハロー拡張を追加するように指示します。
SSL_OP_DONT_INSERT_EMPTY_FRAGMENTSOpenSSL に、OpenSSL 0.9.6d で追加された SSL 3.0/TLS 1.0 の脆弱性の回避策を無効にするように指示します。
SSL_OP_LEGACY_SERVER_CONNECTRI をサポートしていないサーバーへの初期接続を許可します。
SSL_OP_NO_COMPRESSIONOpenSSL に、SSL/TLS 圧縮のサポートを無効にするように指示します。
SSL_OP_NO_ENCRYPT_THEN_MACOpenSSL に、encrypt-then-MAC を無効にするように指示します。
SSL_OP_NO_QUERY_MTU
SSL_OP_NO_RENEGOTIATIONOpenSSL に、再ネゴシエーションを無効にするように指示します。
SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATIONOpenSSL に、再ネゴシエーションを実行するときは常に新しいセッションを開始するように指示します。
SSL_OP_NO_SSLv2OpenSSL に、SSL v2 を無効にするように指示します。
SSL_OP_NO_SSLv3OpenSSL に、SSL v3 を無効にするように指示します。
SSL_OP_NO_TICKETOpenSSL に、RFC4507bis チケットの使用を無効にするように指示します。
SSL_OP_NO_TLSv1OpenSSL に、TLS v1 を無効にするように指示します。
SSL_OP_NO_TLSv1_1OpenSSL に、TLS v1.1 を無効にするように指示します。
SSL_OP_NO_TLSv1_2OpenSSL に、TLS v1.2 を無効にするように指示します。
SSL_OP_NO_TLSv1_3OpenSSL に、TLS v1.3 を無効にするように指示します。
SSL_OP_PRIORITIZE_CHACHAクライアントがそうする場合、OpenSSL サーバーに ChaCha20-Poly1305 を優先するように指示します。このオプションは、SSL_OP_CIPHER_SERVER_PREFERENCE が有効になっていない場合は効果がありません。
SSL_OP_TLS_ROLLBACK_BUGOpenSSL に、バージョンロールバック攻撃検出を無効にするように指示します。

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_METHS に制限
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 のソルト長をダイジェストサイズに設定します。
RSA_PSS_SALTLEN_MAX_SIGNデータ署名時に RSA_PKCS1_PSS_PADDING のソルト長を許容される最大値に設定します。
RSA_PSS_SALTLEN_AUTO署名の検証時に RSA_PKCS1_PSS_PADDING のソルト長を自動的に決定させます。
POINT_CONVERSION_COMPRESSED
POINT_CONVERSION_UNCOMPRESSED
POINT_CONVERSION_HYBRID

Node.js crypto 定数 ​

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