iDoc.dev

한국어

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

한국어

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

테마

암호화 ​

[안정적: 2 - 안정적]

안정적: 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)
// 출력:
//   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
js
const { createHmac } = require('node:crypto')

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

암호화 지원이 없는지 확인 ​

Node.js는 node:crypto 모듈에 대한 지원을 포함하지 않고 빌드될 수 있습니다. 이러한 경우 crypto에서 import하거나 require('node:crypto')를 호출하려고 하면 오류가 발생합니다.

CommonJS를 사용하는 경우 try/catch를 사용하여 발생하는 오류를 catch할 수 있습니다.

js
let crypto
try {
  crypto = require('node:crypto')
} catch (err) {
  console.error('암호화 지원이 비활성화되었습니다!')
}

어휘적 ESM import 키워드를 사용하는 경우 모듈을 로드하려는 시도 전에 process.on('uncaughtException')에 대한 처리기가 등록된 경우에만(예를 들어, 프리로드 모듈을 사용하는 경우) 오류를 catch할 수 있습니다.

ESM을 사용하는 경우 코드가 암호화 지원이 활성화되지 않은 Node.js 빌드에서 실행될 가능성이 있는 경우 어휘적 import 키워드 대신 import() 함수를 사용하는 것을 고려하십시오.

js
let crypto
try {
  crypto = await import('node:crypto')
} catch (err) {
  console.error('암호화 지원이 비활성화되었습니다!')
}

클래스: 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'))
// 출력: UTF8 문자열로 된 챌린지
js
const { Certificate } = require('node:crypto')
const spkac = getSpkacSomehow()
const challenge = Certificate.exportChallenge(spkac)
console.log(challenge.toString('utf8'))
// 출력: 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가 될 수 있습니다. encoding 추가. 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 ​

[안정성: 0 - 더 이상 사용되지 않음]

안정성: 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'))
// 출력: UTF8 문자열로 된 챌린지
js
const { Certificate } = require('node:crypto')
const cert = Certificate()
const spkac = getSpkacSomehow()
const challenge = cert.exportChallenge(spkac)
console.log(challenge.toString('utf8'))
// 출력: 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)
// 출력: <Buffer ...> 형식의 공개 키
js
const { Certificate } = require('node:crypto')
const cert = Certificate()
const spkac = getSpkacSomehow()
const publicKey = cert.exportPublicKey(spkac)
console.log(publicKey)
// 출력: <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)))
// 출력: true 또는 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)))
// 출력: true 또는 false

클래스: Cipher ​

추가됨: v0.1.94

Cipher 클래스의 인스턴스는 데이터를 암호화하는 데 사용됩니다. 이 클래스는 다음 두 가지 방법 중 하나로 사용할 수 있습니다.

  • 읽기 및 쓰기가 모두 가능한 스트림으로, 일반 암호화되지 않은 데이터를 작성하여 읽기 측에 암호화된 데이터를 생성하거나,
  • 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 = 'Password used to generate key'

// 먼저 키를 생성합니다. 키 길이는 알고리즘에 따라 다릅니다.
// 이 경우 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('some clear text data')
    cipher.end()
  })
})
js
const { scrypt, randomFill, createCipheriv } = require('node:crypto')

const algorithm = 'aes-192-cbc'
const password = 'Password used to generate key'

// 먼저 키를 생성합니다. 키 길이는 알고리즘에 따라 다릅니다.
// 이 경우 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('some clear text data')
    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 = 'Password used to generate key'

// 먼저 키를 생성합니다. 키 길이는 알고리즘에 따라 다릅니다.
// 이 경우 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 = 'Password used to generate key'

// 먼저 키를 생성합니다. 키 길이는 알고리즘에 따라 다릅니다.
// 이 경우 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 = 'Password used to generate key'

// 먼저 키를 생성합니다. 키 길이는 알고리즘에 따라 다릅니다.
// 이 경우 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('some clear text data', 'utf8', 'hex')
    encrypted += cipher.final('hex')
    console.log(encrypted)
  })
})
js
const { scrypt, randomFill, createCipheriv } = require('node:crypto')

const algorithm = 'aes-192-cbc'
const password = 'Password used to generate key'

// 먼저 키를 생성합니다. 키 길이는 알고리즘에 따라 다릅니다.
// 이 경우 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('some clear text data', 'utf8', 'hex')
    encrypted += cipher.final('hex')
    console.log(encrypted)
  })
})

cipher.final([outputEncoding]) ​

추가됨: v0.1.94

  • outputEncoding <string> 반환값의 인코딩.
  • 반환값: <Buffer> | <string> 암호화된 나머지 콘텐츠. outputEncoding이 지정되면 문자열이 반환됩니다. outputEncoding이 제공되지 않으면 Buffer가 반환됩니다.

cipher.final() 메서드가 호출된 후에는 Cipher 객체를 더 이상 데이터 암호화에 사용할 수 없습니다. cipher.final()을 두 번 이상 호출하려고 하면 오류가 발생합니다.

cipher.getAuthTag() ​

추가됨: v1.0.0

  • 반환값: <Buffer> 인증된 암호화 모드(GCM, CCM, OCB, chacha20-poly1305 현재 지원)를 사용하는 경우 cipher.getAuthTag() 메서드는 주어진 데이터에서 계산된 인증 태그가 포함된 Buffer를 반환합니다.

cipher.getAuthTag() 메서드는 cipher.final() 메서드를 사용하여 암호화가 완료된 후에만 호출해야 합니다.

authTagLength 옵션이 cipher 인스턴스 생성 중에 설정된 경우 이 함수는 정확히 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()이 오류를 throw합니다. 자동 패딩을 비활성화하는 것은 비표준 패딩(예: 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.update() 메서드는 cipher.final()이 호출될 때까지 새 데이터로 여러 번 호출할 수 있습니다. cipher.final() 후에 cipher.update()를 호출하면 오류가 발생합니다.

클래스: Decipher ​

추가됨: v0.1.94

Decipher 클래스의 인스턴스는 데이터를 복호화하는 데 사용됩니다. 이 클래스는 두 가지 방법 중 하나로 사용할 수 있습니다.

  • 읽기 및 쓰기가 모두 가능한 스트림으로, 평문 암호화된 데이터를 작성하여 읽기 쪽에 암호화되지 않은 데이터를 생성하거나,
  • 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 = 'Password used to generate key'
// Key length is dependent on the algorithm. In this case for aes192, it is
// 24 bytes (192 bits).
// Use the async `crypto.scrypt()` instead.
const key = scryptSync(password, 'salt', 24)
// The IV is usually passed along with the ciphertext.
const iv = Buffer.alloc(16, 0) // Initialization vector.

const decipher = createDecipheriv(algorithm, key, iv)

let decrypted = ''
decipher.on('readable', () => {
  let chunk
  while (null !== (chunk = decipher.read())) {
    decrypted += chunk.toString('utf8')
  }
})
decipher.on('end', () => {
  console.log(decrypted)
  // Prints: some clear text data
})

// Encrypted with same algorithm, key and iv.
const encrypted = 'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa'
decipher.write(encrypted, 'hex')
decipher.end()
js
const { scryptSync, createDecipheriv } = require('node:crypto')
const { Buffer } = require('node:buffer')

const algorithm = 'aes-192-cbc'
const password = 'Password used to generate key'
// Key length is dependent on the algorithm. In this case for aes192, it is
// 24 bytes (192 bits).
// Use the async `crypto.scrypt()` instead.
const key = scryptSync(password, 'salt', 24)
// The IV is usually passed along with the ciphertext.
const iv = Buffer.alloc(16, 0) // Initialization vector.

const decipher = createDecipheriv(algorithm, key, iv)

let decrypted = ''
decipher.on('readable', () => {
  let chunk
  while (null !== (chunk = decipher.read())) {
    decrypted += chunk.toString('utf8')
  }
})
decipher.on('end', () => {
  console.log(decrypted)
  // Prints: some clear text data
})

// Encrypted with same algorithm, key and iv.
const encrypted = 'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa'
decipher.write(encrypted, 'hex')
decipher.end()

예시: Decipher 및 파이프된 스트림 사용:

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 = 'Password used to generate key'
// Use the async `crypto.scrypt()` instead.
const key = scryptSync(password, 'salt', 24)
// The IV is usually passed along with the ciphertext.
const iv = Buffer.alloc(16, 0) // Initialization vector.

const decipher = createDecipheriv(algorithm, key, iv)

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

input.pipe(decipher).pipe(output)
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 = 'Password used to generate key'
// Use the async `crypto.scrypt()` instead.
const key = scryptSync(password, 'salt', 24)
// The IV is usually passed along with the ciphertext.
const iv = Buffer.alloc(16, 0) // Initialization vector.

const decipher = createDecipheriv(algorithm, key, iv)

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

input.pipe(decipher).pipe(output)

예시: decipher.update() 및 decipher.final() 메서드 사용:

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

const algorithm = 'aes-192-cbc'
const password = 'Password used to generate key'
// Use the async `crypto.scrypt()` instead.
const key = scryptSync(password, 'salt', 24)
// The IV is usually passed along with the ciphertext.
const iv = Buffer.alloc(16, 0) // Initialization vector.

const decipher = createDecipheriv(algorithm, key, iv)

// Encrypted using same algorithm, key and iv.
const encrypted = 'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa'
let decrypted = decipher.update(encrypted, 'hex', 'utf8')
decrypted += decipher.final('utf8')
console.log(decrypted)
// Prints: some clear text data
js
const { scryptSync, createDecipheriv } = require('node:crypto')
const { Buffer } = require('node:buffer')

const algorithm = 'aes-192-cbc'
const password = 'Password used to generate key'
// Use the async `crypto.scrypt()` instead.
const key = scryptSync(password, 'salt', 24)
// The IV is usually passed along with the ciphertext.
const iv = Buffer.alloc(16, 0) // Initialization vector.

const decipher = createDecipheriv(algorithm, key, iv)

// Encrypted using same algorithm, key and iv.
const encrypted = 'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa'
let decrypted = decipher.update(encrypted, 'hex', 'utf8')
decrypted += decipher.final('utf8')
console.log(decrypted)
// Prints: some clear text data

decipher.final([outputEncoding]) ​

추가됨: v0.1.94

  • outputEncoding <string> 반환 값의 인코딩.
  • 반환값: <Buffer> | <string> 복호화된 나머지 콘텐츠. outputEncoding이 지정되면 문자열이 반환됩니다. outputEncoding이 제공되지 않으면 Buffer가 반환됩니다.

decipher.final() 메서드가 호출되면 Decipher 객체는 더 이상 데이터를 복호화하는 데 사용할 수 없습니다. decipher.final()을 두 번 이상 호출하려고 하면 오류가 발생합니다.

decipher.setAAD(buffer[, options]) ​

[이력]

버전변경 사항
v15.0.0buffer 인수는 문자열 또는 ArrayBuffer일 수 있으며 최대 2 ** 31 - 1바이트로 제한됩니다.
v7.2.0이 메서드는 이제 decipher에 대한 참조를 반환합니다.
v1.0.0추가됨: v1.0.0

인증된 암호화 모드(GCM, CCM, OCB, chacha20-poly1305가 현재 지원됨)를 사용하는 경우 decipher.setAAD() 메서드는 추가 인증 데이터(AAD) 입력 매개변수에 사용되는 값을 설정합니다.

GCM의 경우 options 인수는 선택 사항입니다. 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.0GCM 태그 길이가 잘못된 경우 이 메서드는 이제 예외를 throw합니다.
v7.2.0이 메서드는 이제 decipher에 대한 참조를 반환합니다.
v1.0.0추가됨: v1.0.0

인증된 암호화 모드(GCM, CCM, OCB, chacha20-poly1305가 현재 지원됨)를 사용하는 경우, decipher.setAuthTag() 메서드는 수신된 인증 태그를 전달하는 데 사용됩니다. 태그가 제공되지 않거나 암호 텍스트가 변조된 경우 decipher.final()은 예외를 throw하여 인증 실패로 인해 암호 텍스트를 삭제해야 함을 나타냅니다. NIST SP 800-38D에 따라 태그 길이가 잘못되었거나 authTagLength 옵션의 값과 일치하지 않는 경우 decipher.setAuthTag()는 오류를 throw합니다.

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.final()이 호출될 때까지 decipher.update() 메서드를 새 데이터로 여러 번 호출할 수 있습니다. 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 클래스는 타원 곡선 디피-헬만(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 디피-헬만 공개 키를 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.14추가됨: v0.11.14

상대방의 공개 키로 otherPublicKey를 사용하여 공유 비밀을 계산하고 계산된 공유 비밀을 반환합니다. 제공된 키는 지정된 inputEncoding을 사용하여 해석되고, 반환된 비밀은 지정된 outputEncoding을 사용하여 인코딩됩니다. inputEncoding이 제공되지 않으면 otherPublicKey는 Buffer, TypedArray 또는 DataView가 되어야 합니다.

outputEncoding에 문자열이 지정되면 문자열이 반환됩니다. 그렇지 않으면 Buffer가 반환됩니다.

otherPublicKey가 타원 곡선 외부에 있으면 ecdh.computeSecret은 ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY 오류를 throw합니다. 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여야 합니다.

privateKey가 ECDH 객체가 생성될 때 지정된 곡선에 유효하지 않으면 오류가 발생합니다. 개인 키를 설정하면 연결된 공개 지점(키)도 생성되어 ECDH 객체에 설정됩니다.

ecdh.setPublicKey(publicKey[, encoding]) ​

추가됨: v0.11.14

사용 중단됨: v5.2.0

[Stable: 0 - 사용 중단됨]

Stable: 0 Stability: 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')

// 이것은 Alice의 이전 개인 키 중 하나를 지정하는 바로 가기 방법입니다. 실제 애플리케이션에서 이러한 예측 가능한 개인 키를 사용하는 것은 현명하지 않습니다.
alice.setPrivateKey(createHash('sha256').update('alice', 'utf8').digest())

// Bob은 새로 생성된 암호화적으로 강력한 의사 난수 키 쌍을 사용합니다.
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')

// 이것은 Alice의 이전 개인 키 중 하나를 지정하는 바로 가기 방법입니다. 실제 애플리케이션에서 이러한 예측 가능한 개인 키를 사용하는 것은 현명하지 않습니다.
alice.setPrivateKey(createHash('sha256').update('alice', 'utf8').digest())

// Bob은 새로 생성된 암호화적으로 강력한 의사 난수 키 쌍을 사용합니다.
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 클래스는 데이터의 해시 다이제스트를 생성하기 위한 유틸리티입니다. 다음 두 가지 방법 중 하나로 사용할 수 있습니다.

  • 읽기 및 쓰기가 모두 가능한 스트림으로서, 데이터를 작성하여 읽기 쪽에서 계산된 해시 다이제스트를 생성하거나,
  • hash.update() 및 hash.digest() 메서드를 사용하여 계산된 해시를 생성합니다.

crypto.createHash() 메서드는 Hash 인스턴스를 생성하는 데 사용됩니다. Hash 객체는 new 키워드를 사용하여 직접 생성해서는 안 됩니다.

예시: Hash 객체를 스트림으로 사용:

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

const hash = createHash('sha256')

hash.on('readable', () => {
  // 해시 스트림에서 생성될 요소는 하나뿐입니다.
  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', () => {
  // 해시 스트림에서 생성될 요소는 하나뿐입니다.
  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.digest() 메서드가 호출된 후에는 Hash 객체를 다시 사용할 수 없습니다. 여러 번 호출하면 오류가 발생합니다.

hash.update(data[, inputEncoding]) ​

[히스토리]

버전변경 사항
v6.0.0기본 inputEncoding이 binary에서 utf8로 변경되었습니다.
v0.1.92추가됨: v0.1.92

주어진 data의 해시 내용을 업데이트합니다. data의 인코딩은 inputEncoding에 지정됩니다. encoding이 제공되지 않고 data가 문자열인 경우 'utf8' 인코딩이 적용됩니다. data가 Buffer, TypedArray 또는 DataView인 경우 inputEncoding은 무시됩니다.

스트리밍되는 새로운 데이터로 여러 번 호출할 수 있습니다.

클래스: Hmac ​

추가됨: v0.1.94

Hmac 클래스는 암호화 HMAC 다이제스트를 생성하기 위한 유틸리티입니다. 다음 두 가지 방법 중 하나로 사용할 수 있습니다.

  • 읽기 및 쓰기가 모두 가능한 스트림으로, 데이터를 작성하여 읽기 측면에서 계산된 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', () => {
  // 해시 스트림에서 생성될 요소는 하나뿐입니다.
  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', () => {
  // 해시 스트림에서 생성될 요소는 하나뿐입니다.
  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]) ​

추가됨: v0.1.94

hmac.update()를 사용하여 전달된 모든 데이터의 HMAC 다이제스트를 계산합니다. encoding이 제공되면 문자열이 반환되고 그렇지 않으면 Buffer가 반환됩니다.

hmac.digest()가 호출된 후에는 Hmac 객체를 다시 사용할 수 없습니다. hmac.digest()를 여러 번 호출하면 오류가 발생합니다.

hmac.update(data[, inputEncoding]) ​

[히스토리]

버전변경 사항
v6.0.0기본 inputEncoding이 binary에서 utf8로 변경되었습니다.
v0.1.94추가됨: v0.1.94

주어진 data로 Hmac 콘텐츠를 업데이트합니다. data의 인코딩은 inputEncoding에 지정됩니다. encoding이 제공되지 않고 data가 문자열인 경우 'utf8' 인코딩이 적용됩니다. data가 Buffer, TypedArray 또는 DataView인 경우 inputEncoding은 무시됩니다.

스트리밍될 때 새로운 데이터로 여러 번 호출할 수 있습니다.

클래스: KeyObject ​

[히스토리]

버전변경 사항
v14.5.0, v12.19.0이 클래스의 인스턴스를 이제 postMessage를 사용하여 워커 스레드에 전달할 수 있습니다.
v11.13.0이 클래스가 이제 내보내집니다.
v11.6.0추가됨: v11.6.0

Node.js는 대칭 또는 비대칭 키를 나타내는 KeyObject 클래스를 사용하며, 각 종류의 키는 다른 함수를 노출합니다. crypto.createSecretKey(), crypto.createPublicKey() 및 crypto.createPrivateKey() 메서드는 KeyObject 인스턴스를 생성하는 데 사용됩니다. KeyObject 객체는 new 키워드를 사용하여 직접 생성해서는 안 됩니다.

대부분의 애플리케이션에서는 향상된 보안 기능으로 인해 문자열 또는 Buffer로 키를 전달하는 대신 새로운 KeyObject API를 사용하는 것이 좋습니다.

KeyObject 인스턴스는 postMessage()를 통해 다른 스레드로 전달할 수 있습니다. 수신자는 복제된 KeyObject를 얻고 KeyObject를 transferList 인수에 나열할 필요가 없습니다.

정적 메서드: KeyObject.from(key) ​

추가됨: v15.0.0

예시: 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)
// 출력: 32 (바이트 단위의 대칭 키 크기)
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)
  // 출력: 32 (바이트 단위의 대칭 키 크기)
})()

keyObject.asymmetricKeyDetails ​

[히스토리]

버전변경 사항
v16.9.0RSA-PSS 키에 대한 RSASSA-PSS-params 시퀀스 매개변수 노출
v15.7.0v15.7.0에 추가됨
  • <Object>
    • modulusLength: <number> 비트 단위 키 크기 (RSA, DSA).
    • publicExponent: <bigint> 공개 지수 (RSA).
    • hashAlgorithm: <string> 메시지 다이제스트 이름 (RSA-PSS).
    • mgf1HashAlgorithm: <string> MGF1에서 사용하는 메시지 다이제스트 이름 (RSA-PSS).
    • saltLength: <number> 바이트 단위 최소 솔트 길이 (RSA-PSS).
    • divisorLength: <number> 비트 단위 q 크기 (DSA).
    • namedCurve: <string> 곡선 이름 (EC).

이 속성은 비대칭 키에만 존재합니다. 키의 유형에 따라 이 객체에는 키에 대한 정보가 포함됩니다. 이 속성을 통해 얻은 정보는 키를 고유하게 식별하거나 키의 보안을 손상시키는 데 사용할 수 없습니다.

RSA-PSS 키의 경우 키 자료에 RSASSA-PSS-params 시퀀스가 포함되어 있으면 hashAlgorithm, mgf1HashAlgorithm 및 saltLength 속성이 설정됩니다.

추가 속성을 사용하여 이 API를 통해 다른 키 세부 정보를 노출할 수 있습니다.

keyObject.asymmetricKeyType ​

[히스토리]

버전변경 사항
v13.9.0, v12.17.0'dh' 지원 추가
v12.0.0'rsa-pss' 지원 추가
v12.0.0이 속성은 이제 인식할 수 없는 유형의 KeyObject 인스턴스에 대해 중단하는 대신 undefined를 반환합니다.
v12.0.0'x25519' 및 'x448' 지원 추가
v12.0.0'ed25519' 및 'ed448' 지원 추가
v11.6.0추가됨: v11.6.0

비대칭 키의 경우 이 속성은 키의 유형을 나타냅니다. 지원되는 키 유형은 다음과 같습니다.

  • '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.0추가됨: v11.6.0

대칭 키의 경우 다음 인코딩 옵션을 사용할 수 있습니다.

  • format: <문자열> 'buffer' (기본값) 또는 'jwk'이어야 합니다.

공개 키의 경우 다음 인코딩 옵션을 사용할 수 있습니다.

  • type: <문자열> 'pkcs1' (RSA 전용) 또는 'spki' 중 하나여야 합니다.
  • format: <문자열> 'pem', 'der' 또는 'jwk'이어야 합니다.

개인 키의 경우 다음 인코딩 옵션을 사용할 수 있습니다.

  • type: <문자열> 'pkcs1' (RSA 전용), 'pkcs8' 또는 'sec1' (EC 전용) 중 하나여야 합니다.
  • format: <문자열> 'pem', 'der' 또는 'jwk'이어야 합니다.
  • cipher: <문자열> 지정된 경우 개인 키는 지정된 cipher 및 passphrase를 사용하여 PKCS#5 v2.0 암호 기반 암호화로 암호화됩니다.
  • passphrase: <문자열> | <버퍼> 암호화에 사용할 암호, cipher 참조.

결과 유형은 선택한 인코딩 형식에 따라 다릅니다. PEM의 경우 결과는 문자열이고, DER의 경우 DER로 인코딩된 데이터를 포함하는 버퍼가 되며, JWK의 경우 객체가 됩니다.

JWK 인코딩 형식이 선택된 경우 다른 모든 인코딩 옵션은 무시됩니다.

PKCS#1, SEC1 및 PKCS#8 유형 키는 cipher 및 format 옵션의 조합을 사용하여 암호화할 수 있습니다. PKCS#8 type은 cipher를 지정하여 모든 키 알고리즘(RSA, EC 또는 DH)을 암호화하기 위해 모든 format과 함께 사용할 수 있습니다. PKCS#1 및 SEC1은 PEM format이 사용될 때 cipher를 지정하여서만 암호화할 수 있습니다. 최대 호환성을 위해 암호화된 개인 키에는 PKCS#8을 사용하십시오. PKCS#8은 자체 암호화 메커니즘을 정의하므로 PKCS#8 키를 암호화할 때 PEM 수준 암호화는 지원되지 않습니다. PKCS#8 암호화에 대한 RFC 5208과 PKCS#1 및 SEC1 암호화에 대한 RFC 1421을 참조하십시오.

keyObject.symmetricKeySize ​

추가됨: 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 클래스는 서명을 생성하기 위한 유틸리티입니다. 다음 두 가지 방법 중 하나로 사용할 수 있습니다.

  • 서명할 데이터를 작성하고 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('some data to sign')
sign.end()
const signature = sign.sign(privateKey, 'hex')

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

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

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

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

예시: sign.update() 및 verify.update() 메서드 사용:

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

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

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

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

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

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

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

sign.sign(privateKey[, outputEncoding]) ​

[히스토리]

버전변경 사항
v15.0.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]) ​

[History]

버전변경 사항
v6.0.0기본 inputEncoding이 binary에서 utf8로 변경되었습니다.
v0.1.92추가됨: v0.1.92

주어진 data의 인코딩이 inputEncoding에 지정된 대로 Sign 콘텐츠를 업데이트합니다. encoding이 제공되지 않고 data가 문자열인 경우 'utf8' 인코딩이 적용됩니다. data가 Buffer, TypedArray 또는 DataView인 경우 inputEncoding은 무시됩니다.

스트리밍될 때 새로운 데이터로 여러 번 호출할 수 있습니다.

클래스: Verify ​

추가됨: v0.1.92

Verify 클래스는 서명을 검증하기 위한 유틸리티입니다. 다음 두 가지 방법 중 하나로 사용할 수 있습니다.

  • 작성된 데이터가 제공된 서명과 유효성을 검사하는 데 사용되는 쓰기 가능한 스트림으로서, 또는
  • verify.update() 및 verify.verify() 메서드를 사용하여 서명을 검증합니다.

crypto.createVerify() 메서드는 Verify 인스턴스를 생성하는 데 사용됩니다. Verify 객체는 new 키워드를 사용하여 직접 생성해서는 안 됩니다.

예시는 Sign을 참조하십시오.

verify.update(data[, inputEncoding]) ​

[History]

버전변경 사항
v6.0.0기본 inputEncoding이 binary에서 utf8로 변경되었습니다.
v0.1.92추가됨: v0.1.92

주어진 data의 인코딩이 inputEncoding에 지정된 대로 Verify 콘텐츠를 업데이트합니다. 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.92추가됨: v0.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.0추가됨: v15.6.0

인증서가 지정된 호스트 이름과 일치하는지 확인합니다.

인증서가 지정된 호스트 이름과 일치하는 경우, 일치하는 주체 이름이 반환됩니다. 반환된 이름은 정확히 일치할 수도 있고(예: 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.1효과가 없었던 options 인수가 제거되었습니다.
v15.6.0추가됨: v15.6.0

인증서가 지정된 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는 두 문자 시퀀스 ', '에서 이 속성을 분할하는 것이 안전하다고 잘못 가정했습니다(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를 throw합니다.
v15.8.0추가됨: v15.8.0

  • candidate <ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint> 임의 길이의 big endian octet 시퀀스로 인코딩된 가능한 소수.

  • options <Object>

    • checks <number> 수행할 Miller-Rabin 확률적 소수성 반복 횟수. 값이 0(영)이면 무작위 입력에 대해 최대 2의 오류 확률을 생성하는 검사 횟수가 사용됩니다. 검사 횟수를 선택할 때는 주의해야 합니다. 자세한 내용은 BN_is_prime_ex 함수의 nchecks 옵션에 대한 OpenSSL 설명서를 참조하십시오. 기본값: 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> 수행할 Miller-Rabin 확률적 소수성 반복 횟수. 값이 0이면 임의 입력에 대한 오탐률이 최대 2⁻ⁿ인 검사 수가 사용됩니다. 검사 수를 선택할 때는 주의해야 합니다. 자세한 내용은 BN_is_prime_ex 함수의 nchecks 옵션에 대한 OpenSSL 설명서를 참조하십시오. 기본값: 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.0chacha20-poly1305 (ChaCha20-Poly1305의 IETF 변형) 암호화 방식이 지원됩니다.
v10.10.0OCB 모드의 암호화 방식이 지원됩니다.
v10.2.0authTagLength 옵션을 사용하여 GCM 모드에서 더 짧은 인증 태그를 생성할 수 있으며 기본값은 16바이트입니다.
v9.9.0초기화 벡터가 필요 없는 암호화 방식의 경우 iv 매개변수가 null이 될 수 있습니다.
v0.1.94추가됨: v0.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'로 인코딩된 문자열, Buffers, 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.0chacha20-poly1305 (ChaCha20-Poly1305의 IETF 변형) 암호가 이제 지원됩니다.
v10.10.0OCB 모드의 암호가 이제 지원됩니다.
v10.2.0authTagLength 옵션을 사용하여 허용되는 GCM 인증 태그 길이를 제한할 수 있습니다.
v9.9.0초기화 벡터가 필요 없는 암호의 경우 iv 매개변수가 이제 null이 될 수 있습니다.
v0.1.94추가됨: v0.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'로 인코딩된 문자열, 버퍼, 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.12추가됨: v0.11.12

제공된 prime과 선택적 특정 generator를 사용하여 DiffieHellman 키 교환 객체를 생성합니다.

generator 인수는 숫자, 문자열 또는 Buffer일 수 있습니다. generator가 지정되지 않으면 값 2가 사용됩니다.

primeEncoding이 지정되면 prime은 문자열이어야 합니다. 그렇지 않으면 Buffer, TypedArray 또는 DataView가 예상됩니다.

generatorEncoding이 지정되면 generator는 문자열이어야 합니다. 그렇지 않으면 숫자, Buffer, TypedArray 또는 DataView가 예상됩니다.

crypto.createDiffieHellman(primeLength[, generator]) ​

추가됨: v0.5.0

DiffieHellman 키 교환 객체를 생성하고 선택적 숫자 generator를 사용하여 primeLength 비트의 소수를 생성합니다. generator가 지정되지 않으면 값 2가 사용됩니다.

crypto.createDiffieHellmanGroup(name) ​

추가됨: v0.9.3

crypto.getDiffieHellman()의 별칭입니다.

crypto.createECDH(curveName) ​

추가됨: v0.11.14

curveName 문자열로 지정된 미리 정의된 곡선을 사용하여 타원 곡선 Diffie-Hellman(ECDH) 키 교환 객체를 생성합니다. 사용 가능한 곡선 이름 목록을 얻으려면 crypto.getCurves()를 사용하십시오. 최신 OpenSSL 릴리스에서는 openssl ecparam -list_curves를 사용하여 사용 가능한 각 타원 곡선의 이름과 설명을 표시할 수도 있습니다.

crypto.createHash(algorithm[, options]) ​

[히스토리]

버전변경 사항
v12.8.0outputLength 옵션이 XOF 해시 함수에 추가되었습니다.
v0.1.92추가됨: 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', () => {
  // 해시 스트림에서 생성될 요소는 하나뿐입니다.
  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', () => {
  // 해시 스트림에서 생성될 요소는 하나뿐입니다.
  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.94추가됨: v0.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', () => {
  // 해시 스트림에서 생성될 요소는 하나뿐입니다.
  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', () => {
  // 해시 스트림에서 생성될 요소는 하나뿐입니다.
  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.0추가됨: v11.6.0

개인 키를 포함하는 새 키 객체를 생성하고 반환합니다. key가 문자열 또는 Buffer인 경우 format은 'pem'으로 간주됩니다. 그렇지 않으면 key는 위에 설명된 속성을 가진 객체여야 합니다.

개인 키가 암호화된 경우 passphrase를 지정해야 합니다. 암호의 길이는 1024바이트로 제한됩니다.

crypto.createPublicKey(key) ​

[히스토리]

버전변경 사항
v15.12.0키가 JWK 객체일 수도 있습니다.
v15.0.0키가 ArrayBuffer일 수도 있습니다. encoding 옵션이 추가되었습니다. 키는 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는 위에 설명된 속성을 가진 객체여야 합니다.

format이 'pem'인 경우 'key'는 X.509 인증서일 수도 있습니다.

공개 키는 개인 키에서 파생될 수 있으므로 공개 키 대신 개인 키를 전달할 수 있습니다. 이 경우 이 함수는 crypto.createPrivateKey()가 호출된 것처럼 동작하지만 반환된 KeyObject의 유형은 'public'이 되고 반환된 KeyObject에서 개인 키를 추출할 수 없습니다. 마찬가지로, 'private' 유형의 KeyObject가 주어지면 'public' 유형의 새 KeyObject가 반환되고 반환된 객체에서 개인 키를 추출할 수 없습니다.

crypto.createSecretKey(key[, encoding]) ​

[히스토리]

버전변경 사항
v18.8.0, v16.18.0키의 길이가 0일 수 있습니다.
v15.0.0키는 ArrayBuffer 또는 문자열일 수도 있습니다. encoding 인수가 추가되었습니다. 키는 2 ** 32 - 1바이트를 초과할 수 없습니다.
v11.6.0추가됨: v11.6.0

대칭 암호화 또는 Hmac에 대한 비밀 키를 포함하는 새 키 객체를 생성하고 반환합니다.

crypto.createSign(algorithm[, options]) ​

추가됨: 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

[Stable: 0 - 더 이상 사용되지 않음]

Stable: 0 Stability: 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를 throw합니다.
v15.0.0추가됨: v15.0.0

  • type: <string> 생성된 비밀 키의 의도된 용도입니다. 현재 허용되는 값은 'hmac' 및 'aes'입니다.

  • options: <Object>

    • length: <number> 생성할 키의 비트 길이입니다. 0보다 큰 값이어야 합니다.
    • type이 'hmac'인 경우 최소값은 8이고 최대 길이는 2-1입니다. 값이 8의 배수가 아니면 생성된 키는 Math.floor(length / 8)로 잘립니다.
    • type이 'aes'인 경우 길이는 128, 192 또는 256 중 하나여야 합니다.

  • callback: <Function>

주어진 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를 throw합니다.
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.0generateKeyPair 및 generateKeyPairSync 함수는 이제 인코딩이 지정되지 않은 경우 키 객체를 생성합니다.
v10.12.0추가됨: v10.12.0

주어진 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.0디피-헬먼 지원 추가
v12.0.0RSA-PSS 키 쌍 지원 추가
v12.0.0X25519 및 X448 키 쌍 생성 기능 추가
v12.0.0Ed25519 및 Ed448 키 쌍 생성 기능 추가
v11.6.0generateKeyPair 및 generateKeyPairSync 함수는 이제 인코딩이 지정되지 않은 경우 키 객체를 생성합니다.
v10.12.0추가됨: v10.12.0

주어진 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를 throw합니다.
v15.8.0추가됨: 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은 무시됩니다.

ArrayBuffer, SharedArrayBuffer, TypedArray, Buffer 또는 DataView로 지정된 경우 options.add 및 options.rem은 모두 big-endian 시퀀스로 인코딩되어야 합니다.

기본적으로 소수는 <ArrayBuffer>의 big-endian 시퀀스로 인코딩됩니다. 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은 무시됩니다.

ArrayBuffer, SharedArrayBuffer, TypedArray, Buffer 또는 DataView로 지정된 경우 options.add 및 options.rem은 모두 빅 엔디안 시퀀스로 인코딩되어야 합니다.

기본적으로 소수는 <ArrayBuffer>의 빅 엔디안 옥텟 시퀀스로 인코딩됩니다. bigint 옵션이 true이면 <bigint>가 제공됩니다.

crypto.getCipherInfo(nameOrNid[, options]) ​

추가됨: v15.0.0

  • nameOrNid: <string> | <number> 조회할 암호의 이름 또는 nid.

  • options: <Object>

    • keyLength: <number> 테스트 키 길이.
    • ivLength: <number> 테스트 IV 길이.

  • 반환값: <Object>

    • name <string> 암호의 이름
    • nid <number> 암호의 nid
    • blockSize <number> 바이트 단위 암호의 블록 크기. mode가 'stream'일 경우 이 속성은 생략됩니다.
    • ivLength <number> 바이트 단위 예상 또는 기본 초기화 벡터 길이. 암호가 초기화 벡터를 사용하지 않는 경우 이 속성은 생략됩니다.
    • keyLength <number> 바이트 단위 예상 또는 기본 키 길이.
    • mode <string> 암호 모드. 'cbc', 'ccm', 'cfb', 'ctr', 'ecb', 'gcm', 'ocb', 'ofb', 'stream', 'wrap', 'xts' 중 하나.

주어진 암호에 대한 정보를 반환합니다.

일부 암호는 가변 길이 키와 초기화 벡터를 허용합니다. 기본적으로 crypto.getCipherInfo() 메서드는 이러한 암호에 대한 기본값을 반환합니다. 주어진 암호에 대해 특정 키 길이 또는 iv 길이가 허용되는지 테스트하려면 keyLength 및 ivLength 옵션을 사용하십시오. 주어진 값이 허용되지 않으면 undefined가 반환됩니다.

crypto.getCiphers() ​

추가됨: v0.9.3

  • 반환값: <string[]> 지원되는 암호 알고리즘의 이름을 포함하는 배열입니다.
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

미리 정의된 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 사양을 준수하지 않습니다. 웹 호환 코드를 작성하려면 대신 crypto.webcrypto.getRandomValues()를 사용하십시오.

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

추가됨: v21.7.0, v20.12.0

[Stable: 1 - Experimental]

Stable: 1 Stability: 1.2 - Release candidate

  • 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로 인코딩하고, 해싱한 후 결과를 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로 인코딩하고, 해싱한 후 결과를 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가 throw됩니다.
v18.8.0, v16.18.0입력 키 자료가 이제 0 길이일 수 있습니다.
v15.0.0추가됨: v15.0.0

HKDF는 RFC 5869에 정의된 간단한 키 파생 함수입니다. 제공된 ikm, salt 및 info는 digest와 함께 사용되어 keylen 바이트의 키를 파생합니다.

제공된 callback 함수는 두 개의 인수(err 및 derivedKey)로 호출됩니다. 키를 파생하는 동안 오류가 발생하면 err이 설정됩니다. 그렇지 않으면 err은 null이 됩니다. 성공적으로 생성된 derivedKey는 <ArrayBuffer>로 콜백에 전달됩니다. 입력 인수 중 하나라도 잘못된 값이나 유형을 지정하면 오류가 throw됩니다.

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입력 키잉 자료가 이제 0 길이일 수 있습니다.
v15.0.0추가됨: v15.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를 throw합니다.
v15.0.0password 및 salt 인수는 ArrayBuffer 인스턴스일 수도 있습니다.
v14.0.0iterations 매개변수는 이제 양수로 제한됩니다. 이전 릴리스에서는 다른 값을 1로 처리했습니다.
v8.0.0digest 매개변수는 이제 항상 필요합니다.
v6.0.0digest 매개변수를 전달하지 않고 이 함수를 호출하는 것은 이제 더 이상 사용되지 않으며 경고를 발생시킵니다.
v6.0.0문자열인 password의 기본 인코딩이 binary에서 utf8로 변경되었습니다.
v0.5.5추가됨: v0.5.5

비동기 Password-Based Key Derivation Function 2(PBKDF2) 구현을 제공합니다. digest로 지정된 선택된 HMAC 다이제스트 알고리즘이 password, salt 및 iterations에서 요청된 바이트 길이(keylen)의 키를 파생하는 데 적용됩니다.

제공된 callback 함수는 두 개의 인수(err 및 derivedKey)로 호출됩니다. 키를 파생하는 동안 오류가 발생하면 err이 설정되고 그렇지 않으면 err은 null이 됩니다. 기본적으로 성공적으로 생성된 derivedKey는 Buffer로 콜백에 전달됩니다. 입력 인수 중 하나가 잘못된 값이나 유형을 지정하면 오류가 throw됩니다.

iterations 인수는 가능한 한 높게 설정된 숫자여야 합니다. 반복 횟수가 많을수록 파생된 키가 더 안전해지지만 완료하는 데 더 오래 걸립니다.

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의 threadpool을 사용하며, 일부 애플리케이션의 경우 놀랍고 부정적인 성능 영향을 미칠 수 있습니다. 자세한 내용은 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.3추가됨: v0.9.3

동기식 Password-Based Key Derivation Function 2(PBKDF2) 구현을 제공합니다. digest로 지정된 선택된 HMAC 다이제스트 알고리즘을 적용하여 password, salt 및 iterations에서 요청된 바이트 길이(keylen)의 키를 도출합니다.

오류가 발생하면 Error가 throw되고, 그렇지 않으면 도출된 키가 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.14추가됨: v0.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.0추가됨: v1.1.0

privateKey를 사용하여 buffer를 암호화합니다. 반환된 데이터는 해당 공개 키를 사용하여 암호 해독할 수 있습니다. 예를 들어 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.0추가됨: v1.1.0

key를 사용하여 buffer를 복호화합니다. 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.14추가됨: v0.11.14

key를 사용하여 buffer의 콘텐츠를 암호화하고 암호화된 콘텐츠가 포함된 새 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를 throw합니다.
v9.0.0callback 인수에 null을 전달하면 ERR_INVALID_CALLBACK를 throw합니다.
v0.5.8추가됨: v0.5.8

  • size <number> 생성할 바이트 수입니다. size는 2**31 - 1보다 클 수 없습니다.

  • callback <Function>

  • 반환값: callback 함수가 제공되지 않으면 <Buffer>를 반환합니다.

암호화적으로 강력한 의사 난수 데이터를 생성합니다. size 인수는 생성할 바이트 수를 나타내는 숫자입니다.

callback 함수가 제공되면 바이트가 비동기적으로 생성되고 callback 함수가 두 개의 인수(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로 반환됩니다. 바이트 생성에 문제가 발생하면 오류가 throw됩니다.

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의 threadpool을 사용하며, 일부 애플리케이션의 성능에 예상치 못한 부정적인 영향을 미칠 수 있습니다. 자세한 내용은 UV_THREADPOOL_SIZE 설명서를 참조하십시오.

crypto.randomBytes()의 비동기 버전은 단일 threadpool 요청에서 수행됩니다. threadpool 작업 길이 변화를 최소화하려면 클라이언트 요청을 처리하는 과정에서 대규모 randomBytes 요청을 분할하십시오.

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

[히스토리]

버전변경 사항
v18.0.0callback 인수에 잘못된 콜백을 전달하면 ERR_INVALID_CALLBACK 대신 ERR_INVALID_ARG_TYPE를 throw합니다.
v9.0.0buffer 인수는 모든 TypedArray 또는 DataView가 될 수 있습니다.
v7.10.0, v6.13.0추가됨: v7.10.0, v6.13.0

이 함수는 crypto.randomBytes()와 유사하지만 첫 번째 인수로 채워질 Buffer가 필요합니다. 또한 콜백이 전달되어야 합니다.

callback 함수가 제공되지 않으면 오류가 throw됩니다.

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를 throw합니다.
v14.10.0, v12.19.0추가됨: v14.10.0, v12.19.0
  • min <정수> 난수 범위의 시작(포함). 기본값: 0.
  • max <정수> 난수 범위의 끝(제외).
  • callback <함수> 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를 throw합니다.
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는 가능한 한 고유해야 합니다. 솔트는 임의적이고 최소 16바이트 길이인 것이 좋습니다. 자세한 내용은 NIST SP 800-132를 참조하십시오.

password 또는 salt에 문자열을 전달할 때는 암호화 API에 입력으로 문자열을 사용할 때의 주의 사항을 고려하십시오.

callback 함수는 두 개의 인수(err 및 derivedKey)를 사용하여 호출됩니다. 키 파생이 실패하면 err은 예외 개체이고, 그렇지 않으면 err은 null입니다. derivedKey는 Buffer로 콜백에 전달됩니다.

입력 인수 중 하나라도 잘못된 값이나 유형을 지정하면 예외가 throw됩니다.

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.0추가됨: v10.5.0

동기식 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> 할당된 총 바이트에 대한 used의 계산된 비율.

crypto.setEngine(engine[, flags]) ​

[히스토리]

버전변경 사항
v22.4.0, v20.16.0OpenSSL 3에서 사용자 엔진 지원이 더 이상 사용되지 않습니다.
v0.11.11추가됨: v0.11.11

일부 또는 모든 OpenSSL 함수(플래그로 선택됨)에 대해 engine을 로드하고 설정합니다. 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> FIPS 모드를 활성화하려면 true로 설정합니다.

FIPS 지원 Node.js 빌드에서 FIPS 호환 암호화 공급자를 활성화합니다. FIPS 모드를 사용할 수 없는 경우 오류를 throw합니다.

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

[이력]

버전변경 사항
v18.0.0callback 인수에 잘못된 콜백을 전달하면 이제 ERR_INVALID_CALLBACK 대신 ERR_INVALID_ARG_TYPE를 throw합니다.
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 인스턴스를 나타내는 기본 바이트를 비교합니다.

이 함수는 공격자가 값 중 하나를 추측할 수 있도록 하는 타이밍 정보를 누출하지 않습니다. 이는 HMAC 다이제스트 또는 인증 쿠키 또는 capability url과 같은 비밀 값을 비교하는 데 적합합니다.

a와 b는 모두 Buffer, TypedArray 또는 DataView여야 하며, 바이트 길이가 같아야 합니다. a와 b의 바이트 길이가 다르면 오류가 발생합니다.

a와 b 중 하나라도 Uint16Array와 같이 항목당 바이트가 둘 이상인 TypedArray인 경우 결과는 플랫폼 바이트 순서를 사용하여 계산됩니다.

두 입력이 모두 Float32Array 또는 Float64Array인 경우, IEEE 754 부동 소수점 숫자 인코딩으로 인해 이 함수는 예상치 못한 결과를 반환할 수 있습니다. 특히, x === y 또는 Object.is(x, y)는 두 부동 소수점 숫자 x와 y의 바이트 표현이 같다는 것을 의미하지 않습니다.

crypto.timingSafeEqual의 사용은 주변 코드가 타이밍 안전하다는 것을 보장하지 않습니다. 주변 코드가 타이밍 취약성을 도입하지 않도록 주의해야 합니다.

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

[이력]

버전변경 사항
v18.0.0callback 인수에 잘못된 콜백을 전달하면 ERR_INVALID_CALLBACK 대신 ERR_INVALID_ARG_TYPE를 throw합니다.
v15.12.0선택적 콜백 인수 추가
v15.0.0data, key 및 signature 인수는 ArrayBuffer일 수도 있습니다.
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.createPublicKey()에 전달된 것처럼 동작합니다. 객체인 경우 다음과 같은 추가 속성을 전달할 수 있습니다.

  • dsaEncoding <문자열> DSA 및 ECDSA의 경우 이 옵션은 서명의 형식을 지정합니다. 다음 중 하나일 수 있습니다.

    • 'der' (기본값): DER로 인코딩된 ASN.1 서명 구조 인코딩 (r, s).
    • 'ieee-p1363': IEEE-P1363에서 제안한 서명 형식 r || s.

  • padding <정수> RSA에 대한 선택적 패딩 값으로, 다음 중 하나입니다.

    • crypto.constants.RSA_PKCS1_PADDING (기본값)
    • crypto.constants.RSA_PKCS1_PSS_PADDING

RSA_PKCS1_PSS_PADDING은 RFC 4055의 3.1절에 지정된 대로 메시지에 서명하는 데 사용되는 것과 동일한 해시 함수를 사용하여 MGF1을 사용합니다.

  • saltLength <정수> 패딩이 RSA_PKCS1_PSS_PADDING인 경우의 솔트 길이입니다. 특수 값 crypto.constants.RSA_PSS_SALTLEN_DIGEST는 솔트 길이를 다이제스트 크기로 설정하고, crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN (기본값)은 최대 허용 값으로 설정합니다.

signature 인수는 이전에 data에 대해 계산된 서명입니다.

공개 키는 비밀 키에서 파생될 수 있으므로 비밀 키 또는 공개 키를 key로 전달할 수 있습니다.

callback 함수가 제공되면 이 함수는 libuv의 threadpool을 사용합니다.

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 문자열로 변환할 때 유효한 코드 포인트를 나타내지 않는 하위 시퀀스는 유니코드 바꾸기 문자(U+FFFD)로 바뀔 수 있습니다. 따라서 결과 유니코드 문자열의 바이트 표현은 문자열이 생성된 바이트 시퀀스와 같지 않을 수 있습니다. 암호, 해시 함수, 서명 알고리즘 및 키 파생 함수의 출력은 의사 랜덤 바이트 시퀀스이며 유니코드 문자열로 사용해서는 안 됩니다.
  • 사용자 입력에서 문자열을 가져올 때 일부 유니코드 문자는 서로 다른 바이트 시퀀스를 생성하는 여러 가지 동등한 방식으로 표현될 수 있습니다. 예를 들어, PBKDF2 또는 scrypt와 같은 키 파생 함수에 사용자 암호를 전달할 때 키 파생 함수의 결과는 문자열이 합성 문자 또는 분해된 문자를 사용하는지 여부에 따라 달라집니다. Node.js는 문자 표현을 정규화하지 않습니다. 개발자는 암호화 API에 전달하기 전에 사용자 입력에 대해 String.prototype.normalize()를 사용하는 것을 고려해야 합니다.

레거시 스트림 API (Node.js 0.10 이전) ​

Crypto 모듈은 통합 스트림 API 개념이 등장하기 전과 바이너리 데이터 처리를 위한 Buffer 객체가 생기기 전에 Node.js에 추가되었습니다. 따라서 많은 crypto 클래스는 스트림 API(/api/stream)를 구현하는 다른 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 알고리즘 중 하나입니다. 이 모드를 사용하는 애플리케이션은 암호 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()이 오류를 throw합니다.
  • CCM은 인스턴스당 하나 이상의 데이터 청크를 처리할 수 없으므로 CCM 모드에서 write(data), end(data) 또는 pipe()와 같은 스트림 메서드를 사용하면 실패할 수 있습니다.
  • 추가 인증 데이터(AAD)를 전달할 때 실제 메시지의 길이(바이트)를 plaintextLength 옵션을 통해 setAAD()에 전달해야 합니다. 많은 암호화 라이브러리는 암호문에 인증 태그를 포함하므로 plaintextLength + authTagLength 길이의 암호문을 생성합니다. Node.js는 인증 태그를 포함하지 않으므로 암호문 길이는 항상 plaintextLength입니다. AAD를 사용하지 않는 경우에는 필요하지 않습니다.
  • CCM은 전체 메시지를 한 번에 처리하므로 update()를 정확히 한 번 호출해야 합니다.
  • 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 섹션 이름은 포함된 fipsmodule.cnf 내의 섹션 이름과 일치해야 합니다. {#the-fips-section-name-should-match-the-section-name-inside-the}
fips = fips_sect

[default_sect]
activate = 1

여기서 fipsmodule.cnf는 FIPS 제공자 설치 단계에서 생성된 FIPS 모듈 구성 파일입니다.

bash
openssl fipsinstall

구성 파일을 가리키도록 OPENSSL_CONF 환경 변수를 설정하고, FIPS 제공자 동적 라이브러리의 위치를 가리키도록 OPENSSL_MODULES를 설정합니다. 예:

bash
export OPENSSL_CONF=/<구성 파일 경로>/nodejs.cnf
export OPENSSL_MODULES=/<openssl lib 경로>/ossl-modules

그러면 다음 방법 중 하나로 Node.js에서 FIPS 모드를 활성화할 수 있습니다.

  • --enable-fips 또는 --force-fips 명령줄 플래그를 사용하여 Node.js를 시작합니다.
  • 프로그래밍 방식으로 crypto.setFips(true)를 호출합니다.

선택적으로 OpenSSL 구성 파일을 통해 Node.js에서 FIPS 모드를 활성화할 수 있습니다. 예:

text
nodejs_conf = nodejs_init

.include /<절대 경로>/fipsmodule.cnf

[nodejs_init]
providers = provider_sect
alg_section = algorithm_sect

[provider_sect]
default = default_sect
# fips 섹션 이름은 포함된 fipsmodule.cnf 내의 섹션 이름과 일치해야 합니다. {#included-fipsmodulecnf}
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_KEXOpenSSL에 TLS v1.3에 대해 [EC]DHE 기반이 아닌 키 교환 모드를 허용하도록 지시합니다.
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에 Cisco의 DTLS_BAD_VER 버전 식별자를 사용하도록 지시합니다.
SSL_OP_COOKIE_EXCHANGEOpenSSL에 쿠키 교환을 켜도록 지시합니다.
SSL_OP_CRYPTOPRO_TLSEXT_BUGOpenSSL에 초기 버전의 cryptopro 초안에서 서버-hello 확장을 추가하도록 지시합니다.
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에 암호화 후 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 암호 상수 ​

상수설명
defaultCoreCipherListNode.js에서 사용하는 기본 내장 암호 목록을 지정합니다.
defaultCipherList현재 Node.js 프로세스에서 사용하는 활성 기본 암호 목록을 지정합니다.