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

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

암호화 지원이 불가능한지 확인하기 ​

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

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

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

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

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

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

클래스: Certificate ​

추가된 버전: v0.11.8

SPKAC는 원래 Netscape에서 구현한 인증서 서명 요청 메커니즘이며 HTML5의 <keygen> 요소의 일부로 공식적으로 지정되었습니다.

<keygen>은 HTML 5.2 이후로 더 이상 사용되지 않으며 새로운 프로젝트에서는 이 요소를 더 이상 사용하지 않아야 합니다.

node:crypto 모듈은 SPKAC 데이터를 처리하기 위한 Certificate 클래스를 제공합니다. 가장 일반적인 용도는 HTML5 <keygen> 요소에서 생성된 출력을 처리하는 것입니다. Node.js는 내부적으로 OpenSSL의 SPKAC 구현을 사용합니다.

정적 메서드: Certificate.exportChallenge(spkac[, encoding]) ​

[기록]

버전변경 사항
v15.0.0spkac 인수는 ArrayBuffer일 수 있습니다. spkac 인수의 크기를 최대 2**31 - 1바이트로 제한했습니다.
v9.0.0추가된 버전: v9.0.0
js
const { Certificate } = await import('node:crypto');
const spkac = getSpkacSomehow();
const challenge = Certificate.exportChallenge(spkac);
console.log(challenge.toString('utf8'));
// Prints: the challenge as a UTF8 string
js
const { Certificate } = require('node:crypto');
const spkac = getSpkacSomehow();
const challenge = Certificate.exportChallenge(spkac);
console.log(challenge.toString('utf8'));
// Prints: the challenge as a UTF8 string

정적 메서드: Certificate.exportPublicKey(spkac[, encoding]) ​

[기록]

버전변경 사항
v15.0.0spkac 인수가 ArrayBuffer가 될 수 있습니다. spkac 인수의 크기를 최대 2**31 - 1바이트로 제한했습니다.
v9.0.0v9.0.0에 추가됨
js
const { Certificate } = await import('node:crypto');
const spkac = getSpkacSomehow();
const publicKey = Certificate.exportPublicKey(spkac);
console.log(publicKey);
// Prints: the public key as <Buffer ...>
js
const { Certificate } = require('node:crypto');
const spkac = getSpkacSomehow();
const publicKey = Certificate.exportPublicKey(spkac);
console.log(publicKey);
// Prints: the public key as <Buffer ...>

정적 메서드: Certificate.verifySpkac(spkac[, encoding]) ​

[기록]

버전변경 사항
v15.0.0spkac 인수가 ArrayBuffer가 될 수 있습니다. 인코딩을 추가했습니다. spkac 인수의 크기를 최대 2**31 - 1바이트로 제한했습니다.
v9.0.0v9.0.0에 추가됨
js
import { Buffer } from 'node:buffer';
const { Certificate } = await import('node:crypto');

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

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

레거시 API ​

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

안정성: 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]) ​

Added in: v0.11.8

js
const { Certificate } = await import('node:crypto');
const cert = Certificate();
const spkac = getSpkacSomehow();
const challenge = cert.exportChallenge(spkac);
console.log(challenge.toString('utf8'));
// Prints: the challenge as a UTF8 string
js
const { Certificate } = require('node:crypto');
const cert = Certificate();
const spkac = getSpkacSomehow();
const challenge = cert.exportChallenge(spkac);
console.log(challenge.toString('utf8'));
// Prints: the challenge as a UTF8 string

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 = '키를 생성하는 데 사용되는 비밀번호';

// 먼저 키를 생성합니다. 키 길이는 알고리즘에 따라 다릅니다.
// 이 경우 aes192의 경우 24바이트(192비트)입니다.
scrypt(password, 'salt', 24, (err, key) => {
  if (err) throw err;
  // 그런 다음 임의의 초기화 벡터를 생성합니다.
  randomFill(new Uint8Array(16), (err, iv) => {
    if (err) throw err;

    // 키와 iv가 있으면 암호기를 만들고 사용할 수 있습니다...
    const cipher = createCipheriv(algorithm, key, iv);

    let encrypted = '';
    cipher.setEncoding('hex');

    cipher.on('data', (chunk) => encrypted += chunk);
    cipher.on('end', () => console.log(encrypted));

    cipher.write('몇 가지 일반 텍스트 데이터');
    cipher.end();
  });
});
js
const {
  scrypt,
  randomFill,
  createCipheriv,
} = require('node:crypto');

const algorithm = 'aes-192-cbc';
const password = '키를 생성하는 데 사용되는 비밀번호';

// 먼저 키를 생성합니다. 키 길이는 알고리즘에 따라 다릅니다.
// 이 경우 aes192의 경우 24바이트(192비트)입니다.
scrypt(password, 'salt', 24, (err, key) => {
  if (err) throw err;
  // 그런 다음 임의의 초기화 벡터를 생성합니다.
  randomFill(new Uint8Array(16), (err, iv) => {
    if (err) throw err;

    // 키와 iv가 있으면 암호기를 만들고 사용할 수 있습니다...
    const cipher = createCipheriv(algorithm, key, iv);

    let encrypted = '';
    cipher.setEncoding('hex');

    cipher.on('data', (chunk) => encrypted += chunk);
    cipher.on('end', () => console.log(encrypted));

    cipher.write('몇 가지 일반 텍스트 데이터');
    cipher.end();
  });
});

예: Cipher 및 파이프 스트림 사용:

js
import {
  createReadStream,
  createWriteStream,
} from 'node:fs';

import {
  pipeline,
} from 'node:stream';

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

const algorithm = 'aes-192-cbc';
const password = '키를 생성하는 데 사용되는 비밀번호';

// 먼저 키를 생성합니다. 키 길이는 알고리즘에 따라 다릅니다.
// 이 경우 aes192의 경우 24바이트(192비트)입니다.
scrypt(password, 'salt', 24, (err, key) => {
  if (err) throw err;
  // 그런 다음 임의의 초기화 벡터를 생성합니다.
  randomFill(new Uint8Array(16), (err, iv) => {
    if (err) throw err;

    const cipher = createCipheriv(algorithm, key, iv);

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

    pipeline(input, cipher, output, (err) => {
      if (err) throw err;
    });
  });
});
js
const {
  createReadStream,
  createWriteStream,
} = require('node:fs');

const {
  pipeline,
} = require('node:stream');

const {
  scrypt,
  randomFill,
  createCipheriv,
} = require('node:crypto');

const algorithm = 'aes-192-cbc';
const password = '키를 생성하는 데 사용되는 비밀번호';

// 먼저 키를 생성합니다. 키 길이는 알고리즘에 따라 다릅니다.
// 이 경우 aes192의 경우 24바이트(192비트)입니다.
scrypt(password, 'salt', 24, (err, key) => {
  if (err) throw err;
  // 그런 다음 임의의 초기화 벡터를 생성합니다.
  randomFill(new Uint8Array(16), (err, iv) => {
    if (err) throw err;

    const cipher = createCipheriv(algorithm, key, iv);

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

    pipeline(input, cipher, output, (err) => {
      if (err) throw err;
    });
  });
});

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

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

const algorithm = 'aes-192-cbc';
const password = '키를 생성하는 데 사용되는 비밀번호';

// 먼저 키를 생성합니다. 키 길이는 알고리즘에 따라 다릅니다.
// 이 경우 aes192의 경우 24바이트(192비트)입니다.
scrypt(password, 'salt', 24, (err, key) => {
  if (err) throw err;
  // 그런 다음 임의의 초기화 벡터를 생성합니다.
  randomFill(new Uint8Array(16), (err, iv) => {
    if (err) throw err;

    const cipher = createCipheriv(algorithm, key, iv);

    let encrypted = cipher.update('몇 가지 일반 텍스트 데이터', 'utf8', 'hex');
    encrypted += cipher.final('hex');
    console.log(encrypted);
  });
});
js
const {
  scrypt,
  randomFill,
  createCipheriv,
} = require('node:crypto');

const algorithm = 'aes-192-cbc';
const password = '키를 생성하는 데 사용되는 비밀번호';

// 먼저 키를 생성합니다. 키 길이는 알고리즘에 따라 다릅니다.
// 이 경우 aes192의 경우 24바이트(192비트)입니다.
scrypt(password, 'salt', 24, (err, key) => {
  if (err) throw err;
  // 그런 다음 임의의 초기화 벡터를 생성합니다.
  randomFill(new Uint8Array(16), (err, iv) => {
    if (err) throw err;

    const cipher = createCipheriv(algorithm, key, iv);

    let encrypted = cipher.update('몇 가지 일반 텍스트 데이터', 'utf8', 'hex');
    encrypted += cipher.final('hex');
    console.log(encrypted);
  });
});

cipher.final([outputEncoding]) ​

Added in: v0.1.94

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

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

cipher.getAuthTag() ​

Added in: v1.0.0

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

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

cipher 인스턴스 생성 시 authTagLength 옵션이 설정된 경우, 이 함수는 정확히 authTagLength 바이트를 반환합니다.

cipher.setAAD(buffer[, options]) ​

Added in: v1.0.0

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

plaintextLength 옵션은 GCM 및 OCB의 경우 선택 사항입니다. CCM을 사용하는 경우, plaintextLength 옵션을 지정해야 하며 해당 값은 일반 텍스트의 바이트 길이와 일치해야 합니다. CCM 모드를 참조하십시오.

cipher.setAAD() 메서드는 cipher.update() 전에 호출해야 합니다.

cipher.setAutoPadding([autoPadding]) ​

추가된 버전: v0.7.1

  • autoPadding <boolean> 기본값: true
  • 반환: <Cipher> 메서드 체이닝을 위한 동일한 Cipher 인스턴스입니다.

블록 암호화 알고리즘을 사용할 때 Cipher 클래스는 입력 데이터에 적절한 블록 크기로 자동 패딩을 추가합니다. 기본 패딩을 비활성화하려면 cipher.setAutoPadding(false)를 호출하세요.

autoPadding이 false이면 전체 입력 데이터의 길이가 암호의 블록 크기의 배수여야 합니다. 그렇지 않으면 cipher.final()이 오류를 발생시킵니다. 자동 패딩 비활성화는 PKCS 패딩 대신 0x0을 사용하는 것과 같이 비표준 패딩에 유용합니다.

cipher.setAutoPadding() 메서드는 cipher.final() 전에 호출해야 합니다.

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

[기록]

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

data로 암호화를 업데이트합니다. inputEncoding 인수가 제공되면 data 인수는 지정된 인코딩을 사용하는 문자열입니다. inputEncoding 인수가 제공되지 않으면 data는 Buffer, TypedArray 또는 DataView여야 합니다. data가 Buffer, TypedArray 또는 DataView인 경우 inputEncoding은 무시됩니다.

outputEncoding은 암호화된 데이터의 출력 형식을 지정합니다. outputEncoding이 지정되면 지정된 인코딩을 사용하는 문자열이 반환됩니다. outputEncoding이 제공되지 않으면 Buffer가 반환됩니다.

cipher.final()이 호출될 때까지 cipher.update() 메서드를 새 데이터로 여러 번 호출할 수 있습니다. cipher.final() 이후에 cipher.update()를 호출하면 오류가 발생합니다.

클래스: Decipher ​

추가된 버전: v0.1.94

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

  • 읽기 및 쓰기가 모두 가능한 스트림으로, 일반 암호화된 데이터를 작성하여 읽기 가능한 쪽에 암호화되지 않은 데이터를 생성하거나,
  • decipher.update() 및 decipher.final() 메서드를 사용하여 암호화되지 않은 데이터를 생성합니다.

crypto.createDecipheriv() 메서드는 Decipher 인스턴스를 만드는 데 사용됩니다. Decipher 객체는 new 키워드를 사용하여 직접 만들 수 없습니다.

예제: Decipher 객체를 스트림으로 사용하기:

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

const algorithm = 'aes-192-cbc';
const password = '키를 생성하는 데 사용되는 비밀번호';
// 키 길이는 알고리즘에 따라 다릅니다. 이 경우 aes192의 경우
// 24바이트(192비트)입니다.
// async `crypto.scrypt()`를 대신 사용하세요.
const key = scryptSync(password, 'salt', 24);
// IV는 일반적으로 암호 텍스트와 함께 전달됩니다.
const iv = Buffer.alloc(16, 0); // 초기화 벡터.

const decipher = createDecipheriv(algorithm, key, iv);

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

// 동일한 알고리즘, 키 및 IV를 사용하여 암호화했습니다.
const encrypted =
  'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa';
decipher.write(encrypted, 'hex');
decipher.end();
js
const {
  scryptSync,
  createDecipheriv,
} = require('node:crypto');
const { Buffer } = require('node:buffer');

const algorithm = 'aes-192-cbc';
const password = '키를 생성하는 데 사용되는 비밀번호';
// 키 길이는 알고리즘에 따라 다릅니다. 이 경우 aes192의 경우
// 24바이트(192비트)입니다.
// async `crypto.scrypt()`를 대신 사용하세요.
const key = scryptSync(password, 'salt', 24);
// IV는 일반적으로 암호 텍스트와 함께 전달됩니다.
const iv = Buffer.alloc(16, 0); // 초기화 벡터.

const decipher = createDecipheriv(algorithm, key, iv);

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

// 동일한 알고리즘, 키 및 IV를 사용하여 암호화했습니다.
const encrypted =
  'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa';
decipher.write(encrypted, 'hex');
decipher.end();

예제: Decipher 및 파이프된 스트림 사용하기:

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

const algorithm = 'aes-192-cbc';
const password = '키를 생성하는 데 사용되는 비밀번호';
// async `crypto.scrypt()`를 대신 사용하세요.
const key = scryptSync(password, 'salt', 24);
// IV는 일반적으로 암호 텍스트와 함께 전달됩니다.
const iv = Buffer.alloc(16, 0); // 초기화 벡터.

const decipher = createDecipheriv(algorithm, key, iv);

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

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

const algorithm = 'aes-192-cbc';
const password = '키를 생성하는 데 사용되는 비밀번호';
// async `crypto.scrypt()`를 대신 사용하세요.
const key = scryptSync(password, 'salt', 24);
// IV는 일반적으로 암호 텍스트와 함께 전달됩니다.
const iv = Buffer.alloc(16, 0); // 초기화 벡터.

const decipher = createDecipheriv(algorithm, key, iv);

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

input.pipe(decipher).pipe(output);

예제: decipher.update() 및 decipher.final() 메서드 사용하기:

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

const algorithm = 'aes-192-cbc';
const password = '키를 생성하는 데 사용되는 비밀번호';
// async `crypto.scrypt()`를 대신 사용하세요.
const key = scryptSync(password, 'salt', 24);
// IV는 일반적으로 암호 텍스트와 함께 전달됩니다.
const iv = Buffer.alloc(16, 0); // 초기화 벡터.

const decipher = createDecipheriv(algorithm, key, iv);

// 동일한 알고리즘, 키 및 IV를 사용하여 암호화했습니다.
const encrypted =
  'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa';
let decrypted = decipher.update(encrypted, 'hex', 'utf8');
decrypted += decipher.final('utf8');
console.log(decrypted);
// 출력: some clear text data
js
const {
  scryptSync,
  createDecipheriv,
} = require('node:crypto');
const { Buffer } = require('node:buffer');

const algorithm = 'aes-192-cbc';
const password = '키를 생성하는 데 사용되는 비밀번호';
// async `crypto.scrypt()`를 대신 사용하세요.
const key = scryptSync(password, 'salt', 24);
// IV는 일반적으로 암호 텍스트와 함께 전달됩니다.
const iv = Buffer.alloc(16, 0); // 초기화 벡터.

const decipher = createDecipheriv(algorithm, key, iv);

// 동일한 알고리즘, 키 및 IV를 사용하여 암호화했습니다.
const encrypted =
  'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa';
let decrypted = decipher.update(encrypted, 'hex', 'utf8');
decrypted += decipher.final('utf8');
console.log(decrypted);
// 출력: some clear text data

decipher.final([outputEncoding]) ​

추가된 버전: 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) 입력 매개변수에 사용되는 값을 설정합니다.

options 인수는 GCM의 경우 선택 사항입니다. CCM을 사용하는 경우 plaintextLength 옵션을 지정해야 하며 해당 값은 암호문의 길이(바이트)와 일치해야 합니다. CCM 모드를 참조하세요.

decipher.setAAD() 메서드는 decipher.update() 전에 호출해야 합니다.

문자열을 buffer로 전달하는 경우 암호화 API에 대한 입력으로 문자열을 사용할 때의 주의 사항을 고려하세요.

decipher.setAuthTag(buffer[, encoding]) ​

[기록]

버전변경 사항
v22.0.0, v20.13.0decipher를 생성할 때 authTagLength 옵션을 지정하지 않고 128비트 이외의 GCM 태그 길이를 사용하는 것은 더 이상 사용되지 않습니다.
v15.0.0buffer 인수는 문자열 또는 ArrayBuffer일 수 있으며 최대 2 ** 31 - 1바이트로 제한됩니다.
v11.0.0이 메서드는 이제 GCM 태그 길이가 유효하지 않은 경우 오류를 발생시킵니다.
v7.2.0이 메서드는 이제 decipher에 대한 참조를 반환합니다.
v1.0.0추가됨: v1.0.0

인증된 암호화 모드(GCM, CCM, OCB 및 chacha20-poly1305가 현재 지원됨)를 사용하는 경우 decipher.setAuthTag() 메서드는 수신된 인증 태그를 전달하는 데 사용됩니다. 태그가 제공되지 않거나 암호 텍스트가 변조된 경우 decipher.final()이 오류를 발생시켜 인증 실패로 인해 암호 텍스트를 폐기해야 함을 나타냅니다. 태그 길이가 NIST SP 800-38D에 따라 유효하지 않거나 authTagLength 옵션 값과 일치하지 않으면 decipher.setAuthTag()가 오류를 발생시킵니다.

decipher.setAuthTag() 메서드는 CCM 모드의 경우 decipher.update() 전에, GCM 및 OCB 모드와 chacha20-poly1305의 경우 decipher.final() 전에 호출해야 합니다. decipher.setAuthTag()는 한 번만 호출할 수 있습니다.

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

decipher.setAutoPadding([autoPadding]) ​

추가된 버전: v0.7.1

  • autoPadding <boolean> 기본값: true
  • 반환: <Decipher> 메서드 체이닝을 위한 동일한 Decipher입니다.

데이터가 표준 블록 패딩 없이 암호화된 경우, decipher.setAutoPadding(false)를 호출하면 자동 패딩이 비활성화되어 decipher.final()이 패딩을 확인하고 제거하는 것을 방지합니다.

자동 패딩을 끄는 것은 입력 데이터의 길이가 암호 블록 크기의 배수인 경우에만 작동합니다.

decipher.setAutoPadding() 메서드는 decipher.final() 전에 호출해야 합니다.

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

[기록]

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

data로 해독기를 업데이트합니다. inputEncoding 인수가 주어지면 data 인수는 지정된 인코딩을 사용하는 문자열입니다. inputEncoding 인수가 주어지지 않으면 data는 Buffer여야 합니다. data가 Buffer인 경우 inputEncoding은 무시됩니다.

outputEncoding은 암호화된 데이터의 출력 형식을 지정합니다. outputEncoding이 지정되면 지정된 인코딩을 사용하는 문자열이 반환됩니다. outputEncoding이 제공되지 않으면 Buffer가 반환됩니다.

decipher.update() 메서드는 decipher.final()이 호출될 때까지 새 데이터로 여러 번 호출할 수 있습니다. decipher.final() 후에 decipher.update()를 호출하면 오류가 발생합니다.

기본 암호가 인증을 구현하더라도 이 함수에서 반환된 일반 텍스트의 진위성과 무결성은 현재 불확실할 수 있습니다. 인증된 암호화 알고리즘의 경우 일반적으로 응용 프로그램이 decipher.final()을 호출할 때만 진위성이 확립됩니다.

클래스: DiffieHellman ​

추가된 버전: v0.5.0

DiffieHellman 클래스는 Diffie-Hellman 키 교환을 생성하기 위한 유틸리티입니다.

DiffieHellman 클래스의 인스턴스는 crypto.createDiffieHellman() 함수를 사용하여 생성할 수 있습니다.

js
import assert from 'node:assert';

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

// Alice의 키 생성...
const alice = createDiffieHellman(2048);
const aliceKey = alice.generateKeys();

// Bob의 키 생성...
const bob = createDiffieHellman(alice.getPrime(), alice.getGenerator());
const bobKey = bob.generateKeys();

// 교환하고 비밀 생성...
const aliceSecret = alice.computeSecret(bobKey);
const bobSecret = bob.computeSecret(aliceKey);

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

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

// Alice의 키 생성...
const alice = createDiffieHellman(2048);
const aliceKey = alice.generateKeys();

// Bob의 키 생성...
const bob = createDiffieHellman(alice.getPrime(), alice.getGenerator());
const bobKey = bob.generateKeys();

// 교환하고 비밀 생성...
const aliceSecret = alice.computeSecret(bobKey);
const bobSecret = bob.computeSecret(aliceKey);

// OK
assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex'));

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

추가된 버전: v0.5.0

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

outputEncoding이 주어지면 문자열이 반환됩니다. 그렇지 않으면 Buffer가 반환됩니다.

diffieHellman.generateKeys([encoding]) ​

추가된 버전: v0.5.0

아직 생성 또는 계산되지 않은 경우 개인 및 공개 Diffie-Hellman 키 값을 생성하고 지정된 encoding으로 공개 키를 반환합니다. 이 키는 상대방에게 전송되어야 합니다. encoding이 제공되면 문자열이 반환됩니다. 그렇지 않으면 Buffer가 반환됩니다.

이 함수는 DH_generate_key()의 얇은 래퍼입니다. 특히 개인 키가 생성되거나 설정되면 이 함수를 호출하면 공개 키만 업데이트되고 새 개인 키는 생성되지 않습니다.

diffieHellman.getGenerator([encoding]) ​

추가된 버전: v0.5.0

지정된 encoding으로 Diffie-Hellman 생성기를 반환합니다. encoding이 제공되면 문자열이 반환됩니다. 그렇지 않으면 Buffer가 반환됩니다.

diffieHellman.getPrime([encoding]) ​

추가된 버전: v0.5.0

지정된 encoding으로 Diffie-Hellman 소수를 반환합니다. encoding이 제공되면 문자열이 반환됩니다. 그렇지 않으면 Buffer가 반환됩니다.

diffieHellman.getPrivateKey([encoding]) ​

추가된 버전: v0.5.0

지정된 encoding으로 Diffie-Hellman 개인 키를 반환합니다. encoding이 제공되면 문자열이 반환됩니다. 그렇지 않으면 Buffer가 반환됩니다.

diffieHellman.getPublicKey([encoding]) ​

추가된 버전: v0.5.0

지정된 encoding으로 Diffie-Hellman 공개 키를 반환합니다. encoding이 제공되면 문자열이 반환됩니다. 그렇지 않으면 Buffer가 반환됩니다.

diffieHellman.setPrivateKey(privateKey[, encoding]) ​

추가된 버전: v0.5.0

Diffie-Hellman 개인 키를 설정합니다. encoding 인수가 제공되면 privateKey는 문자열로 예상됩니다. encoding이 제공되지 않으면 privateKey는 Buffer, TypedArray 또는 DataView로 예상됩니다.

이 함수는 연결된 공개 키를 자동으로 계산하지 않습니다. diffieHellman.setPublicKey() 또는 diffieHellman.generateKeys()를 사용하여 공개 키를 수동으로 제공하거나 자동으로 파생시킬 수 있습니다.

diffieHellman.setPublicKey(publicKey[, encoding]) ​

추가된 버전: v0.5.0

Diffie-Hellman 공개 키를 설정합니다. encoding 인수가 제공되면 publicKey는 문자열이어야 합니다. encoding이 제공되지 않으면 publicKey는 Buffer, TypedArray 또는 DataView여야 합니다.

diffieHellman.verifyError ​

추가된 버전: v0.11.12

DiffieHellman 객체 초기화 중에 수행된 검사로 인해 발생한 경고 및/또는 오류를 포함하는 비트 필드입니다.

이 속성에 유효한 값은 다음과 같습니다 (node:constants 모듈에 정의됨).

  • DH_CHECK_P_NOT_SAFE_PRIME
  • DH_CHECK_P_NOT_PRIME
  • DH_UNABLE_TO_CHECK_GENERATOR
  • DH_NOT_SUITABLE_GENERATOR

클래스: DiffieHellmanGroup ​

추가된 버전: v0.7.5

DiffieHellmanGroup 클래스는 잘 알려진 modp 그룹을 인수로 사용합니다. 생성 후 키를 변경할 수 없다는 점을 제외하면 DiffieHellman과 동일하게 작동합니다. 즉, setPublicKey() 또는 setPrivateKey() 메서드를 구현하지 않습니다.

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

다음 그룹이 지원됩니다.

  • 'modp14' (2048 비트, RFC 3526 섹션 3)
  • 'modp15' (3072 비트, RFC 3526 섹션 4)
  • 'modp16' (4096 비트, RFC 3526 섹션 5)
  • 'modp17' (6144 비트, RFC 3526 섹션 6)
  • 'modp18' (8192 비트, RFC 3526 섹션 7)

다음 그룹은 여전히 지원되지만 더 이상 사용되지 않습니다(주의 사항 참조).

  • 'modp1' (768 비트, RFC 2409 섹션 6.1)
  • 'modp2' (1024 비트, RFC 2409 섹션 6.2)
  • 'modp5' (1536 비트, RFC 3526 섹션 2)

이러한 더 이상 사용되지 않는 그룹은 Node.js의 향후 버전에서 제거될 수 있습니다.

클래스: ECDH ​

추가된 버전: v0.11.14

ECDH 클래스는 Elliptic Curve Diffie-Hellman (ECDH) 키 교환을 생성하기 위한 유틸리티입니다.

ECDH 클래스의 인스턴스는 crypto.createECDH() 함수를 사용하여 생성할 수 있습니다.

js
import assert from 'node:assert';

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

// Alice의 키 생성...
const alice = createECDH('secp521r1');
const aliceKey = alice.generateKeys();

// Bob의 키 생성...
const bob = createECDH('secp521r1');
const bobKey = bob.generateKeys();

// 교환 및 비밀 생성...
const aliceSecret = alice.computeSecret(bobKey);
const bobSecret = bob.computeSecret(aliceKey);

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

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

// Alice의 키 생성...
const alice = createECDH('secp521r1');
const aliceKey = alice.generateKeys();

// Bob의 키 생성...
const bob = createECDH('secp521r1');
const bobKey = bob.generateKeys();

// 교환 및 비밀 생성...
const aliceSecret = alice.computeSecret(bobKey);
const bobSecret = bob.computeSecret(aliceKey);

assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex'));
// OK

정적 메서드: ECDH.convertKey(key, curve[, inputEncoding[, outputEncoding[, format]]]) ​

추가된 버전: v10.0.0

key 및 curve로 지정된 EC Diffie-Hellman 공개 키를 format으로 지정된 형식으로 변환합니다. format 인수는 포인트 인코딩을 지정하며 'compressed', 'uncompressed' 또는 'hybrid'일 수 있습니다. 제공된 키는 지정된 inputEncoding을 사용하여 해석되고 반환된 키는 지정된 outputEncoding을 사용하여 인코딩됩니다.

사용 가능한 곡선 이름 목록을 얻으려면 crypto.getCurves()를 사용하세요. 최신 OpenSSL 릴리스에서는 openssl ecparam -list_curves도 사용 가능한 각 타원 곡선의 이름과 설명을 표시합니다.

format이 지정되지 않은 경우 포인트는 'uncompressed' 형식으로 반환됩니다.

inputEncoding이 제공되지 않으면 key는 Buffer, TypedArray 또는 DataView여야 합니다.

예 (키 압축 해제):

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

const ecdh = createECDH('secp256k1');
ecdh.generateKeys();

const compressedKey = ecdh.getPublicKey('hex', 'compressed');

const uncompressedKey = ECDH.convertKey(compressedKey,
                                        'secp256k1',
                                        'hex',
                                        'hex',
                                        'uncompressed');

// 변환된 키와 압축 해제된 공개 키는 동일해야 합니다.
console.log(uncompressedKey === ecdh.getPublicKey('hex'));
js
const {
  createECDH,
  ECDH,
} = require('node:crypto');

const ecdh = createECDH('secp256k1');
ecdh.generateKeys();

const compressedKey = ecdh.getPublicKey('hex', 'compressed');

const uncompressedKey = ECDH.convertKey(compressedKey,
                                        'secp256k1',
                                        'hex',
                                        'hex',
                                        'uncompressed');

// 변환된 키와 압축 해제된 공개 키는 동일해야 합니다.
console.log(uncompressedKey === ecdh.getPublicKey('hex'));

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

[기록]

버전변경 사항
v10.0.0잘못된 공개 키 오류를 더 잘 지원하도록 오류 형식이 변경되었습니다.
v6.0.0기본 inputEncoding이 binary에서 utf8로 변경되었습니다.
v0.11.14v0.11.14에 추가됨

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

outputEncoding이 주어지면 문자열이 반환됩니다. 그렇지 않으면 Buffer가 반환됩니다.

otherPublicKey가 타원 곡선 외부에 있는 경우 ecdh.computeSecret은 ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY 오류를 발생시킵니다. otherPublicKey는 일반적으로 안전하지 않은 네트워크를 통해 원격 사용자로부터 제공되므로 이 예외를 적절하게 처리해야 합니다.

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

추가된 버전: v0.11.14

개인 및 공개 EC Diffie-Hellman 키 값을 생성하고 지정된 format과 encoding으로 공개 키를 반환합니다. 이 키는 상대방에게 전송되어야 합니다.

format 인수는 포인트 인코딩을 지정하며 'compressed' 또는 'uncompressed'일 수 있습니다. format을 지정하지 않으면 포인트가 'uncompressed' 형식으로 반환됩니다.

encoding이 제공되면 문자열이 반환되고, 그렇지 않으면 Buffer가 반환됩니다.

ecdh.getPrivateKey([encoding]) ​

추가된 버전: v0.11.14

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

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

추가된 버전: v0.11.14

format 인수는 포인트 인코딩을 지정하며 'compressed' 또는 'uncompressed'일 수 있습니다. format을 지정하지 않으면 포인트가 'uncompressed' 형식으로 반환됩니다.

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

ecdh.setPrivateKey(privateKey[, encoding]) ​

추가된 버전: v0.11.14

EC Diffie-Hellman 개인 키를 설정합니다. encoding이 제공되면 privateKey는 문자열이어야 합니다. 그렇지 않으면 privateKey는 Buffer, TypedArray 또는 DataView여야 합니다.

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

ecdh.setPublicKey(publicKey[, encoding]) ​

추가된 버전: v0.11.14

더 이상 사용되지 않음: v5.2.0 이후

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

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

EC Diffie-Hellman 공개 키를 설정합니다. encoding이 제공되면 publicKey는 문자열이어야 합니다. 그렇지 않으면 Buffer, TypedArray 또는 DataView여야 합니다.

ECDH는 공유 비밀을 계산하는 데 개인 키와 상대방의 공개 키만 필요하므로 일반적으로 이 메서드를 호출할 이유가 없습니다. 일반적으로 ecdh.generateKeys() 또는 ecdh.setPrivateKey()가 호출됩니다. ecdh.setPrivateKey() 메서드는 설정된 개인 키와 관련된 공개 지점/키를 생성하려고 시도합니다.

예제 (공유 비밀 획득):

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

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

// 이것은 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]) ​

Added in: 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]) ​

Added in: v0.1.92

해시될 데이터에 전달된 모든 데이터의 다이제스트를 계산합니다 (hash.update() 메서드 사용). encoding이 제공되면 문자열이 반환됩니다. 그렇지 않으면 Buffer가 반환됩니다.

Hash 객체는 hash.digest() 메서드가 호출된 후 다시 사용할 수 없습니다. 여러 번 호출하면 오류가 발생합니다.

hash.update(data[, inputEncoding]) ​

[History]

VersionChanges
v6.0.0The default inputEncoding changed from binary to utf8.
v0.1.92Added in: v0.1.92

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

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

클래스: Hmac ​

Added in: 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) ​

Added in: v15.0.0

예제: CryptoKey 인스턴스를 KeyObject로 변환:

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

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

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

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

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

keyObject.asymmetricKeyDetails ​

[History]

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

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

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

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

keyObject.asymmetricKeyType ​

[기록]

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

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

  • '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: <string> 'buffer' (기본값) 또는 'jwk'여야 합니다.

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

  • type: <string> 'pkcs1'(RSA만 해당) 또는 'spki' 중 하나여야 합니다.
  • format: <string> 'pem', 'der' 또는 'jwk'여야 합니다.

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

  • type: <string> 'pkcs1'(RSA만 해당), 'pkcs8' 또는 'sec1'(EC만 해당) 중 하나여야 합니다.
  • format: <string> 'pem', 'der' 또는 'jwk'여야 합니다.
  • cipher: <string> 지정된 경우 개인 키는 PKCS#5 v2.0 암호 기반 암호화를 사용하여 지정된 cipher 및 passphrase로 암호화됩니다.
  • passphrase: <string> | <Buffer> 암호화에 사용할 암호 구절입니다. cipher를 참조하십시오.

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

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

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

keyObject.symmetricKeySize ​

추가된 버전: v11.6.0

비밀 키의 경우 이 속성은 키 크기를 바이트 단위로 나타냅니다. 비대칭 키의 경우 이 속성은 undefined입니다.

keyObject.toCryptoKey(algorithm, extractable, keyUsages) ​

추가된 버전: v23.0.0

KeyObject 인스턴스를 CryptoKey로 변환합니다.

keyObject.type ​

추가된 버전: v11.6.0

이 KeyObject의 유형에 따라 이 속성은 비밀(대칭) 키의 경우 'secret', 공개(비대칭) 키의 경우 'public', 개인(비대칭) 키의 경우 'private'입니다.

클래스: Sign ​

추가된 버전: v0.1.92

Sign 클래스는 서명을 생성하기 위한 유틸리티입니다. 다음과 같은 두 가지 방법 중 하나로 사용할 수 있습니다.

  • 서명할 데이터가 작성되는 쓰기 가능한 스트림으로, 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.92v0.1.92에 추가됨

sign.update() 또는 sign.write()를 사용하여 전달된 모든 데이터에 대한 서명을 계산합니다.

privateKey가 KeyObject가 아니면 이 함수는 privateKey가 crypto.createPrivateKey()에 전달된 것처럼 작동합니다. 객체인 경우 다음 추가 속성을 전달할 수 있습니다.

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

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

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

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

RSA_PKCS1_PSS_PADDING은 RFC 4055의 3.1절에 지정된 대로 메시지에 서명하는 데 사용된 것과 동일한 해시 함수로 MGF1을 사용합니다. 단, MGF1 해시 함수가 RFC 4055의 3.3절에 따라 키의 일부로 지정된 경우는 예외입니다.

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

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

sign.sign() 메서드가 호출된 후에는 Sign 객체를 다시 사용할 수 없습니다. sign.sign()을 여러 번 호출하면 오류가 발생합니다.

sign.update(data[, inputEncoding]) ​

[히스토리]

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

제공된 data로 Sign 콘텐츠를 업데이트합니다. 여기서 인코딩은 inputEncoding으로 지정됩니다. 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]) ​

[히스토리]

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

제공된 data로 Verify 콘텐츠를 업데이트합니다. 여기서 인코딩은 inputEncoding으로 지정됩니다. inputEncoding이 제공되지 않고 data가 문자열이면 'utf8' 인코딩이 적용됩니다. data가 Buffer, TypedArray 또는 DataView인 경우 inputEncoding은 무시됩니다.

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

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

[기록]

버전변경 사항
v15.0.0객체는 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을 사용합니다. 단, MGF1 해시 함수가 RFC 4055의 섹션 3.3에 따라 키의 일부로 지정된 경우는 예외입니다.

  • saltLength <integer> 패딩이 RSA_PKCS1_PSS_PADDING인 경우의 솔트 길이입니다. 특수 값 crypto.constants.RSA_PSS_SALTLEN_DIGEST는 솔트 길이를 다이제스트 크기로 설정하고, crypto.constants.RSA_PSS_SALTLEN_AUTO (기본값)는 자동으로 결정되도록 합니다.

signature 인수는 데이터에 대해 이전에 계산된 서명이며, signatureEncoding에 있습니다. signatureEncoding이 지정된 경우 signature는 문자열이어야 합니다. 그렇지 않으면 signature는 Buffer, TypedArray 또는 DataView여야 합니다.

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

공개 키는 개인 키에서 파생될 수 있으므로 공개 키 대신 개인 키를 전달할 수 있습니다.

클래스: X509Certificate ​

추가된 버전: v15.6.0

X509 인증서를 캡슐화하고 해당 정보에 대한 읽기 전용 액세스를 제공합니다.

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

const x509 = new X509Certificate('{... pem 인코딩된 인증서 ...}');

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

const x509 = new X509Certificate('{... pem 인코딩된 인증서 ...}');

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.0이제 subject 옵션의 기본값이 'default'입니다.
v17.5.0, v16.15.0이제 subject 옵션을 'default'로 설정할 수 있습니다.
v15.6.0추가됨: v15.6.0

  • name <string>

  • options <Object>

    • subject <string> 'default', 'always', 또는 'never'. 기본값: 'default'.
    • wildcards <boolean> 기본값: true.
    • partialWildcards <boolean> 기본값: true.
    • multiLabelWildcards <boolean> 기본값: false.
    • singleLabelSubdomains <boolean> 기본값: false.

  • 반환: <string> | <undefined> name과 일치하는 주체 이름을 반환하고, name과 일치하는 주체 이름이 없으면 undefined를 반환합니다.

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

인증서가 주어진 호스트 이름과 일치하면 일치하는 주체 이름이 반환됩니다. 반환된 이름은 정확히 일치할 수도 있고(예: foo.example.com), 와일드카드를 포함할 수도 있습니다(예: *.example.com). 호스트 이름 비교는 대소문자를 구분하지 않기 때문에 반환된 주체 이름의 대소문자가 주어진 name과 다를 수도 있습니다.

'subject' 옵션이 정의되지 않았거나 'default'로 설정된 경우, 주체 대체 이름 확장이 존재하지 않거나 DNS 이름이 포함되어 있지 않은 경우에만 인증서 주체가 고려됩니다. 이 동작은 RFC 2818 ("HTTP Over TLS")와 일치합니다.

'subject' 옵션이 'always'로 설정되어 있고 주체 대체 이름 확장이 존재하지 않거나 일치하는 DNS 이름이 포함되어 있지 않으면 인증서 주체가 고려됩니다.

'subject' 옵션이 'never'로 설정된 경우, 인증서에 주체 대체 이름이 없더라도 인증서 주체는 고려되지 않습니다.

x509.checkIP(ip) ​

[기록]

버전변경 사항
v17.5.0, v16.14.1options 인수가 효과가 없으므로 제거되었습니다.
v15.6.0추가됨: v15.6.0
  • ip <string>
  • 반환: <string> | <undefined> 인증서가 일치하면 ip를 반환하고, 그렇지 않으면 undefined를 반환합니다.

인증서가 주어진 IP 주소(IPv4 또는 IPv6)와 일치하는지 확인합니다.

RFC 5280 iPAddress 주체 대체 이름만 고려되며, 주어진 ip 주소와 정확히 일치해야 합니다. 다른 주체 대체 이름과 인증서의 주체 필드는 무시됩니다.

x509.checkIssued(otherCert) ​

추가됨: v15.6.0

이 인증서가 주어진 otherCert에 의해 발급되었는지 확인합니다.

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 ​

Added in: v15.6.0

이 인증서의 SHA-256 지문입니다.

x509.fingerprint512 ​

Added in: 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.2이 문자열의 일부는 CVE-2021-44532에 대한 응답으로 JSON 문자열 리터럴로 인코딩될 수 있습니다.
v15.6.0Added in: v15.6.0

인증서의 기관 정보 액세스 확장 프로그램의 텍스트 표현입니다.

이는 줄 바꿈으로 구분된 액세스 설명 목록입니다. 각 줄은 액세스 방법과 액세스 위치 종류로 시작하고 콜론과 액세스 위치와 관련된 값이 뒤따릅니다.

액세스 방법과 액세스 위치 종류를 나타내는 접두사 뒤에 각 줄의 나머지 부분은 값이 JSON 문자열 리터럴임을 나타내기 위해 따옴표로 묶일 수 있습니다. 이전 버전과의 호환성을 위해 Node.js는 모호성을 피하기 위해 필요한 경우에만 이 속성 내에서 JSON 문자열 리터럴을 사용합니다. 타사 코드는 가능한 두 가지 항목 형식을 모두 처리할 준비가 되어 있어야 합니다.

x509.issuer ​

Added in: v15.6.0

이 인증서에 포함된 발급자 식별자입니다.

x509.issuerCertificate ​

Added in: v15.9.0

발급자 인증서이거나 발급자 인증서를 사용할 수 없는 경우 undefined입니다.

x509.publicKey ​

Added in: v15.6.0

이 인증서에 대한 공개 키 <KeyObject>입니다.

x509.raw ​

Added in: v15.6.0

이 인증서의 DER 인코딩을 포함하는 Buffer입니다.

x509.serialNumber ​

Added in: v15.6.0

이 인증서의 일련 번호입니다.

일련 번호는 인증 기관에서 할당하며 인증서를 고유하게 식별하지 않습니다. 대신 고유 식별자로 x509.fingerprint256을 사용하는 것이 좋습니다.

x509.subject ​

Added in: v15.6.0

이 인증서의 전체 제목입니다.

x509.subjectAltName ​

[기록]

버전변경 사항
v17.3.1, v16.13.2CVE-2021-44532에 대한 응답으로 이 문자열의 일부가 JSON 문자열 리터럴로 인코딩될 수 있습니다.
v15.6.0Added in: v15.6.0

이 인증서에 지정된 주체 대체 이름입니다.

이는 쉼표로 구분된 주체 대체 이름 목록입니다. 각 항목은 주체 대체 이름의 종류를 식별하는 문자열로 시작하고 콜론과 항목과 관련된 값이 뒤따릅니다.

이전 버전의 Node.js는 두 문자 시퀀스 ', '에서 이 속성을 분할하는 것이 안전하다고 잘못 가정했습니다(CVE-2021-44532 참조). 그러나 악성 및 합법적인 인증서 모두 문자열로 표현될 때 이 시퀀스를 포함하는 주체 대체 이름을 포함할 수 있습니다.

항목 유형을 나타내는 접두사 다음에 각 항목의 나머지는 값이 JSON 문자열 리터럴임을 나타내기 위해 따옴표로 묶일 수 있습니다. 이전 버전과의 호환성을 위해 Node.js는 모호성을 피하기 위해 필요한 경우에만 이 속성 내에서 JSON 문자열 리터럴을 사용합니다. 타사 코드는 가능한 두 가지 항목 형식을 모두 처리할 준비가 되어 있어야 합니다.

x509.toJSON() ​

Added in: v15.6.0

X509 인증서에 대한 표준 JSON 인코딩은 없습니다. toJSON() 메서드는 PEM 인코딩된 인증서를 포함하는 문자열을 반환합니다.

x509.toLegacyObject() ​

Added in: v15.6.0

레거시 인증서 객체 인코딩을 사용하여 이 인증서에 대한 정보를 반환합니다.

x509.toString() ​

Added in: v15.6.0

PEM으로 인코딩된 인증서를 반환합니다.

x509.validFrom ​

Added in: v15.6.0

이 인증서가 유효한 날짜/시간입니다.

x509.validFromDate ​

Added in: v23.0.0

이 인증서가 유효한 날짜/시간으로, Date 객체에 캡슐화되어 있습니다.

x509.validTo ​

Added in: v15.6.0

이 인증서가 유효한 날짜/시간입니다.

x509.validToDate ​

Added in: v23.0.0

이 인증서가 유효한 날짜/시간으로, Date 객체에 캡슐화되어 있습니다.

x509.verify(publicKey) ​

Added in: v15.6.0

이 인증서가 주어진 퍼블릭 키로 서명되었는지 확인합니다. 인증서에 대한 다른 유효성 검사는 수행하지 않습니다.

node:crypto 모듈 메서드 및 속성 ​

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

[기록]

버전변경 사항
v18.0.0callback 인수에 유효하지 않은 콜백을 전달하면 이제 ERR_INVALID_CALLBACK 대신 ERR_INVALID_ARG_TYPE이 발생합니다.
v15.8.0v15.8.0에서 추가됨

  • candidate <ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint> 임의 길이의 빅 엔디안 옥텟 시퀀스로 인코딩된 가능한 소수.

  • options <Object>

    • checks <number> 수행할 밀러-라빈 확률적 소수성 반복 횟수. 값이 0(영)이면 무작위 입력에 대해 최대 2의 위양성 비율을 생성하는 검사 횟수가 사용됩니다. 검사 횟수를 선택할 때 주의해야 합니다. 자세한 내용은 OpenSSL 설명서의 BN_is_prime_ex 함수 nchecks 옵션을 참조하세요. 기본값: 0

  • callback <Function>

    • err <Error> 검사 중 오류가 발생한 경우 <Error> 객체로 설정됩니다.
    • result <boolean> 후보가 오류 확률이 0.25 ** options.checks보다 작은 소수이면 true입니다.

candidate의 소수성을 확인합니다.

crypto.checkPrimeSync(candidate[, options]) ​

Added in: v15.8.0

  • candidate <ArrayBuffer> | <SharedArrayBuffer> | <TypedArray> | <Buffer> | <DataView> | <bigint> 임의 길이의 빅 엔디안 옥텟 시퀀스로 인코딩된 가능한 소수입니다.

  • options <Object>

    • checks <number> 수행할 밀러-라빈 확률적 소수성 반복 횟수입니다. 값이 0 (영)이면 임의 입력에 대해 최대 2의 오탐율을 생성하는 검사 횟수가 사용됩니다. 검사 횟수를 선택할 때 주의해야 합니다. 자세한 내용은 OpenSSL 설명서의 BN_is_prime_ex 함수 nchecks 옵션을 참조하십시오. 기본값: 0

  • 반환: <boolean> 후보가 0.25 ** options.checks보다 작은 오류 확률로 소수이면 true입니다.

candidate의 소수성을 확인합니다.

crypto.constants ​

Added in: v6.3.0

암호화 및 보안 관련 작업에 일반적으로 사용되는 상수가 포함된 객체입니다. 현재 정의된 특정 상수는 암호화 상수에 설명되어 있습니다.

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

[기록]

버전변경 사항
v17.9.0, v16.17.0authTagLength 옵션은 이제 chacha20-poly1305 암호화 방법을 사용할 때 선택 사항이며 기본값은 16바이트입니다.
v15.0.0password 및 iv 인수는 ArrayBuffer가 될 수 있으며 각각 최대 2 ** 31 - 1바이트로 제한됩니다.
v11.6.0key 인수는 이제 KeyObject가 될 수 있습니다.
v11.2.0, v10.17.0암호화 방법 chacha20-poly1305(ChaCha20-Poly1305의 IETF 변형)가 이제 지원됩니다.
v10.10.0OCB 모드의 암호화 방법이 이제 지원됩니다.
v10.2.0authTagLength 옵션을 사용하여 GCM 모드에서 더 짧은 인증 태그를 생성할 수 있으며 기본값은 16바이트입니다.
v9.9.0초기화 벡터가 필요하지 않은 암호화 방법의 경우 iv 매개변수는 이제 null이 될 수 있습니다.
v0.1.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.94v0.1.94에 추가됨

지정된 algorithm, key 및 초기화 벡터(iv)를 사용하는 Decipher 객체를 생성하여 반환합니다.

options 인수는 스트림 동작을 제어하며 CCM 또는 OCB 모드(예: 'aes-128-ccm')의 암호화 방식을 사용하는 경우를 제외하고는 선택 사항입니다. 이 경우 authTagLength 옵션이 필요하며 바이트 단위로 인증 태그의 길이를 지정합니다. CCM 모드를 참조하세요. AES-GCM 및 chacha20-poly1305의 경우 authTagLength 옵션의 기본값은 16바이트이며 다른 길이를 사용하는 경우 다른 값으로 설정해야 합니다.

algorithm은 OpenSSL에 따라 다르며, 예시는 'aes192' 등입니다. 최신 OpenSSL 릴리스에서 openssl list -cipher-algorithms는 사용 가능한 암호화 알고리즘을 표시합니다.

key는 algorithm에서 사용하는 원시 키이고 iv는 초기화 벡터입니다. 두 인수 모두 'utf8'로 인코딩된 문자열, Buffers, 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.0XOF 해시 함수에 outputLength 옵션이 추가되었습니다.
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', () => {
  // Only one element is going to be produced by the
  // hash stream.
  const data = input.read();
  if (data)
    hash.update(data);
  else {
    console.log(`${hash.digest('hex')} ${filename}`);
  }
});
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', () => {
  // Only one element is going to be produced by the
  // hash stream.
  const data = input.read();
  if (data)
    hash.update(data);
  else {
    console.log(`${hash.digest('hex')} ${filename}`);
  }
});

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

[기록]

버전변경 사항
v15.0.0키는 ArrayBuffer 또는 CryptoKey일 수도 있습니다. encoding 옵션이 추가되었습니다. 키는 2 ** 32 - 1바이트를 초과할 수 없습니다.
v11.6.0이제 key 인수가 KeyObject일 수 있습니다.
v0.1.94v0.1.94에 추가됨

주어진 algorithm과 key를 사용하는 Hmac 객체를 생성하고 반환합니다. 선택적 options 인수는 스트림 동작을 제어합니다.

algorithm은 플랫폼의 OpenSSL 버전에서 지원하는 사용 가능한 알고리즘에 따라 다릅니다. 예로는 'sha256', 'sha512' 등이 있습니다. 최신 OpenSSL 릴리스에서는 openssl list -digest-algorithms가 사용 가능한 다이제스트 알고리즘을 표시합니다.

key는 암호화 HMAC 해시를 생성하는 데 사용되는 HMAC 키입니다. KeyObject인 경우 유형은 secret이어야 합니다. 문자열인 경우 암호화 API에 문자열을 입력으로 사용할 때 주의 사항을 고려하십시오. crypto.randomBytes() 또는 crypto.generateKey()와 같은 암호화 안전 엔트로피 소스에서 가져온 경우 길이는 algorithm의 블록 크기(예: SHA-256의 경우 512비트)를 초과하지 않아야 합니다.

예: 파일의 sha256 HMAC 생성

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

const filename = argv[2];

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

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

crypto.createPrivateKey(key) ​

[히스토리]

버전변경 사항
v15.12.0키는 JWK 객체일 수도 있습니다.
v15.0.0키는 ArrayBuffer일 수도 있습니다. 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.0이제 key 인수는 private 유형의 KeyObject일 수 있습니다.
v11.7.0이제 key 인수는 개인 키일 수 있습니다.
v11.6.0v11.6.0에 추가됨

공개 키를 포함하는 새로운 키 객체를 생성하고 반환합니다. key가 문자열 또는 Buffer이면 format은 'pem'으로 간주됩니다. key가 'private' 유형의 KeyObject이면 공개 키는 주어진 개인 키에서 파생됩니다. 그렇지 않으면 key는 위에 설명된 속성이 있는 객체여야 합니다.

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

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

crypto.createSecretKey(key[, encoding]) ​

[히스토리]

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

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

crypto.createSign(algorithm[, options]) ​

추가된 버전: v0.1.92

주어진 algorithm을 사용하는 Sign 객체를 생성하고 반환합니다. 사용 가능한 다이제스트 알고리즘의 이름을 얻으려면 crypto.getHashes()를 사용하세요. 선택적 options 인수는 stream.Writable 동작을 제어합니다.

경우에 따라 Sign 인스턴스는 다이제스트 알고리즘 대신 'RSA-SHA256'과 같은 서명 알고리즘의 이름을 사용하여 생성할 수 있습니다. 이는 해당 다이제스트 알고리즘을 사용합니다. 이는 'ecdsa-with-SHA256'과 같은 모든 서명 알고리즘에 대해 작동하지 않으므로 항상 다이제스트 알고리즘 이름을 사용하는 것이 가장 좋습니다.

crypto.createVerify(algorithm[, options]) ​

추가된 버전: v0.1.92

주어진 알고리즘을 사용하는 Verify 객체를 생성하고 반환합니다. 사용 가능한 서명 알고리즘의 이름 배열을 얻으려면 crypto.getHashes()를 사용하세요. 선택적 options 인수는 stream.Writable 동작을 제어합니다.

경우에 따라 Verify 인스턴스는 다이제스트 알고리즘 대신 'RSA-SHA256'과 같은 서명 알고리즘의 이름을 사용하여 생성할 수 있습니다. 이는 해당 다이제스트 알고리즘을 사용합니다. 이는 'ecdsa-with-SHA256'과 같은 모든 서명 알고리즘에 대해 작동하지 않으므로 항상 다이제스트 알고리즘 이름을 사용하는 것이 가장 좋습니다.

crypto.diffieHellman(options) ​

추가된 버전: v13.9.0, v12.17.0

privateKey와 publicKey를 기반으로 Diffie-Hellman 비밀을 계산합니다. 두 키 모두 동일한 asymmetricKeyType을 가져야 하며, 이는 'dh'(Diffie-Hellman의 경우), 'ec', 'x448' 또는 'x25519'(ECDH의 경우) 중 하나여야 합니다.

crypto.fips ​

추가된 버전: v6.0.0

지원 중단된 버전: v10.0.0

[안정성: 0 - 지원 중단됨]

안정성: 0 안정성: 0 - 지원 중단됨

FIPS 규격 암호화 제공자가 현재 사용 중인지 확인하고 제어하는 속성입니다. true로 설정하려면 Node.js의 FIPS 빌드가 필요합니다.

이 속성은 더 이상 사용되지 않습니다. 대신 crypto.setFips() 및 crypto.getFips()를 사용하십시오.

crypto.generateKey(type, options, callback) ​

[연혁]

버전변경 사항
v18.0.0callback 인수에 유효하지 않은 콜백을 전달하면 ERR_INVALID_CALLBACK 대신 ERR_INVALID_ARG_TYPE이 발생합니다.
v15.0.0v15.0.0에 추가됨

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

  • options: <Object>

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

  • callback: <Function>

주어진 length의 새로운 임의 비밀 키를 비동기적으로 생성합니다. type은 length에 대해 수행될 유효성 검사를 결정합니다.

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

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

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

생성된 HMAC 키의 크기는 기본 해시 함수의 블록 크기를 초과해서는 안 됩니다. 자세한 내용은 crypto.createHmac()을 참조하세요.

crypto.generateKeyPair(type, options, callback) ​

[연혁]

버전변경 사항
v18.0.0callback 인수에 유효하지 않은 콜백을 전달하면 이제 ERR_INVALID_CALLBACK 대신 ERR_INVALID_ARG_TYPE이 발생합니다.
v16.10.0RSA-PSS 키 쌍에 대한 RSASSA-PSS-params 시퀀스 매개변수를 정의하는 기능 추가.
v13.9.0, v12.17.0Diffie-Hellman 지원 추가.
v12.0.0RSA-PSS 키 쌍 지원 추가.
v12.0.0X25519 및 X448 키 쌍 생성 기능 추가.
v12.0.0Ed25519 및 Ed448 키 쌍 생성 기능 추가.
v11.6.0generateKeyPair 및 generateKeyPairSync 함수는 인코딩이 지정되지 않은 경우 키 객체를 생성합니다.
v10.12.0v10.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()ed 버전으로 호출되면 publicKey 및 privateKey 속성이 있는 Object에 대한 Promise를 반환합니다.

crypto.generateKeyPairSync(type, options) ​

[연혁]

버전변경 사항
v16.10.0RSA-PSS 키 쌍에 대한 RSASSA-PSS-params 시퀀스 매개변수를 정의하는 기능 추가.
v13.9.0, v12.17.0Diffie-Hellman 지원 추가.
v12.0.0RSA-PSS 키 쌍 지원 추가.
v12.0.0X25519 및 X448 키 쌍을 생성하는 기능 추가.
v12.0.0Ed25519 및 Ed448 키 쌍을 생성하는 기능 추가.
v11.6.0generateKeyPair 및 generateKeyPairSync 함수는 인코딩이 지정되지 않은 경우 키 객체를 생성합니다.
v10.12.0v10.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) ​

Added in: 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]]) ​

[History]

VersionChanges
v18.0.0callback 인수에 유효하지 않은 콜백을 전달하면 이제 ERR_INVALID_CALLBACK 대신 ERR_INVALID_ARG_TYPE이 발생합니다.
v15.8.0Added in: v15.8.0

size 비트의 의사 난수 소수를 생성합니다.

options.safe가 true이면 소수는 안전한 소수가 됩니다. 즉, (prime - 1) / 2도 소수입니다.

options.add 및 options.rem 매개변수를 사용하여 Diffie-Hellman과 같은 추가 요구 사항을 적용할 수 있습니다.

  • options.add 및 options.rem이 모두 설정된 경우, 소수는 prime % add = rem 조건을 만족합니다.
  • options.add만 설정되고 options.safe가 true가 아닌 경우, 소수는 prime % add = 1 조건을 만족합니다.
  • options.add만 설정되고 options.safe가 true로 설정된 경우, 소수는 대신 prime % add = 3 조건을 만족합니다. 이는 options.add > 2에 대해 prime % add = 1이 options.safe에 의해 적용되는 조건과 모순되기 때문에 필요합니다.
  • options.add가 제공되지 않으면 options.rem은 무시됩니다.

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

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

crypto.generatePrimeSync(size[, options]) ​

추가된 버전: v15.8.0

size 비트의 유사 난수 소수를 생성합니다.

options.safe가 true이면, 소수는 안전한 소수, 즉 (prime - 1) / 2도 소수입니다.

options.add 및 options.rem 매개 변수는 Diffie-Hellman과 같이 추가 요구 사항을 적용하는 데 사용할 수 있습니다.

  • options.add와 options.rem이 모두 설정된 경우, 소수는 prime % add = rem 조건을 만족합니다.
  • options.add만 설정되고 options.safe가 true가 아닌 경우, 소수는 prime % add = 1 조건을 만족합니다.
  • options.add만 설정되고 options.safe가 true로 설정된 경우, 소수는 대신 prime % add = 3 조건을 만족합니다. 이는 options.add \> 2에 대해 prime % add = 1이 options.safe에 의해 적용되는 조건과 모순되기 때문에 필요합니다.
  • options.add가 주어지지 않으면 options.rem은 무시됩니다.

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

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

crypto.getCipherInfo(nameOrNid[, options]) ​

추가된 버전: 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() ​

Added in: v10.0.0

  • 반환값: <number> FIPS 준수 암호화 제공자가 현재 사용 중인 경우에만 1, 그렇지 않으면 0을 반환합니다. 향후 semver-major 릴리스에서는 이 API의 반환 유형을 <boolean>으로 변경할 수 있습니다.

crypto.getHashes() ​

Added in: 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) ​

Added in: v17.4.0

crypto.webcrypto.getRandomValues()의 편리한 별칭입니다. 이 구현은 웹 암호 스펙을 준수하지 않으므로 웹 호환 코드를 작성하려면 대신 crypto.webcrypto.getRandomValues()를 사용하십시오.

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

Added in: v21.7.0, v20.12.0

[Stable: 1 - Experimental]

Stable: 1 안정성: 1.2 - 릴리스 후보

  • algorithm <string> | <undefined>
  • data <string> | <Buffer> | <TypedArray> | <DataView> data가 문자열인 경우 해싱되기 전에 UTF-8로 인코딩됩니다. 문자열 입력에 다른 입력 인코딩이 필요한 경우 사용자는 TextEncoder 또는 Buffer.from()을 사용하여 문자열을 TypedArray로 인코딩하고 인코딩된 TypedArray를 이 API에 전달할 수 있습니다.
  • outputEncoding <string> | <undefined> 반환된 다이제스트를 인코딩하는 데 사용되는 인코딩. 기본값: 'hex'.
  • 반환: <string> | <Buffer>

데이터의 일회성 해시 다이제스트를 생성하는 유틸리티입니다. 더 적은 양의 데이터(<= 5MB)를 해싱할 때 객체 기반 crypto.createHash()보다 빠를 수 있습니다. 데이터가 크거나 스트리밍되는 경우 crypto.createHash()를 대신 사용하는 것이 좋습니다.

algorithm은 플랫폼의 OpenSSL 버전에 의해 지원되는 사용 가능한 알고리즘에 따라 다릅니다. 예는 'sha256', 'sha512' 등입니다. 최신 버전의 OpenSSL에서는 openssl list -digest-algorithms가 사용 가능한 다이제스트 알고리즘을 표시합니다.

예제:

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

// 문자열을 해싱하고 결과를 16진수로 인코딩된 문자열로 반환합니다.
const string = 'Node.js';
// 10b3493287f831e81a438811a1ffba01f8cec4b7
console.log(crypto.hash('sha1', string));

// base64로 인코딩된 문자열을 버퍼로 인코딩하고 해싱한 다음
// 결과를 버퍼로 반환합니다.
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로 인코딩된 문자열을 버퍼로 인코딩하고 해싱한 다음
// 결과를 버퍼로 반환합니다.
const base64 = 'Tm9kZS5qcw==';
// <Buffer 10 b3 49 32 87 f8 31 e8 1a 43 88 11 a1 ff ba 01 f8 ce c4 b7>
console.log(crypto.hash('sha1', Buffer.from(base64, 'base64'), 'buffer'));

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

[기록]

버전변경 사항
v18.0.0callback 인수에 잘못된 콜백을 전달하면 이제 ERR_INVALID_CALLBACK 대신 ERR_INVALID_ARG_TYPE 오류가 발생합니다.
v18.8.0, v16.18.0이제 입력 키 자료를 길이가 0일 수 있습니다.
v15.0.0v15.0.0에 추가됨

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

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

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

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

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

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

[연혁]

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

비동기 암호 기반 키 유도 함수 2(PBKDF2) 구현을 제공합니다. digest로 지정된 선택된 HMAC 다이제스트 알고리즘은 password, salt 및 iterations에서 요청된 바이트 길이(keylen)의 키를 유도하는 데 적용됩니다.

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

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의 스레드 풀을 사용하며, 일부 애플리케이션에서는 놀랍고 부정적인 성능 영향을 미칠 수 있습니다. 자세한 내용은 UV_THREADPOOL_SIZE 문서를 참조하십시오.

crypto.pbkdf2Sync(password, salt, iterations, keylen, digest) ​

[내역]

버전변경 사항
v14.0.0이제 iterations 매개변수는 양수 값으로 제한됩니다. 이전 릴리스에서는 다른 값을 1로 처리했습니다.
v6.0.0이제 digest 매개변수를 전달하지 않고 이 함수를 호출하면 더 이상 사용되지 않으며 경고가 발생합니다.
v6.0.0문자열인 경우 password의 기본 인코딩이 binary에서 utf8로 변경되었습니다.
v0.9.3추가됨: v0.9.3

동기식 PBKDF2(Password-Based Key Derivation Function 2) 구현을 제공합니다. 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.0string, ArrayBuffer, CryptoKey가 허용되는 키 유형으로 추가되었습니다. 암호 구문은 ArrayBuffer일 수 있습니다. 버퍼는 string 또는 ArrayBuffer일 수 있습니다. 버퍼를 허용하는 모든 유형은 최대 2 ** 31 - 1바이트로 제한됩니다.
v11.6.0이제 이 함수가 키 객체를 지원합니다.
v1.1.0v1.1.0에 추가됨

privateKey를 사용하여 buffer를 암호화합니다. 반환된 데이터는 해당 공개 키를 사용하여 해독할 수 있습니다(예: crypto.publicDecrypt() 사용).

privateKey가 KeyObject가 아니면 이 함수는 privateKey가 crypto.createPrivateKey()에 전달된 것처럼 작동합니다. 객체인 경우 padding 속성을 전달할 수 있습니다. 그렇지 않으면 이 함수는 RSA_PKCS1_PADDING을 사용합니다.

crypto.publicDecrypt(key, buffer) ​

[기록]

버전변경 사항
v15.0.0string, ArrayBuffer 및 CryptoKey가 허용 가능한 키 유형으로 추가되었습니다. 암호구는 ArrayBuffer일 수 있습니다. 버퍼는 string 또는 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일 수 있습니다. 버퍼는 문자열 또는 ArrayBuffer일 수 있습니다. 버퍼를 허용하는 모든 유형은 최대 2 ** 31 - 1바이트로 제한됩니다.
v12.11.0oaepLabel 옵션이 추가되었습니다.
v12.9.0oaepHash 옵션이 추가되었습니다.
v11.6.0이제 이 함수가 키 객체를 지원합니다.
v0.11.14추가됨: v0.11.14

buffer의 내용을 key로 암호화하고 암호화된 콘텐츠가 있는 새로운 Buffer를 반환합니다. 반환된 데이터는 해당 개인 키를 사용하여 해독할 수 있습니다(예: crypto.privateDecrypt() 사용).

key가 KeyObject가 아니면 이 함수는 key가 crypto.createPublicKey()에 전달된 것처럼 동작합니다. 객체인 경우 padding 속성을 전달할 수 있습니다. 그렇지 않으면 이 함수는 RSA_PKCS1_OAEP_PADDING을 사용합니다.

RSA 공개 키는 개인 키에서 파생될 수 있으므로 공개 키 대신 개인 키를 전달할 수 있습니다.

crypto.randomBytes(size[, callback]) ​

[히스토리]

버전변경 사항
v18.0.0callback 인수에 유효하지 않은 콜백을 전달하면 이제 ERR_INVALID_CALLBACK 대신 ERR_INVALID_ARG_TYPE을 던집니다.
v9.0.0callback 인수로 null을 전달하면 이제 ERR_INVALID_CALLBACK을 던집니다.
v0.5.8v0.5.8에 추가됨

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

  • callback <Function>

  • 반환: callback 함수가 제공되지 않은 경우 <Buffer>입니다.

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

callback 함수가 제공되면 바이트가 비동기적으로 생성되고 callback 함수는 두 개의 인수 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} bytes of random data: ${buf.toString('hex')}`);
});
js
// 비동기
const {
  randomBytes,
} = require('node:crypto');

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

callback 함수가 제공되지 않으면 난수 바이트가 동기적으로 생성되어 Buffer로 반환됩니다. 바이트 생성에 문제가 있으면 오류가 발생합니다.

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

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

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

crypto.randomBytes() 메서드는 충분한 엔트로피가 확보될 때까지 완료되지 않습니다. 일반적으로 몇 밀리초 이상 걸리지 않습니다. 난수 바이트 생성이 더 오랜 시간 동안 차단될 수 있는 유일한 경우는 전체 시스템의 엔트로피가 여전히 낮은 부팅 직후입니다.

이 API는 libuv의 스레드 풀을 사용하며, 이는 일부 애플리케이션에 놀랍고 부정적인 성능 영향을 미칠 수 있습니다. 자세한 내용은 UV_THREADPOOL_SIZE 설명서를 참조하세요.

crypto.randomBytes()의 비동기 버전은 단일 스레드 풀 요청에서 수행됩니다. 스레드 풀 작업 길이 변동을 최소화하려면 클라이언트 요청을 처리하는 과정에서 큰 randomBytes 요청을 분할하세요.

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

[내역]

버전변경 사항
v18.0.0callback 인수에 유효하지 않은 콜백을 전달하면 이제 ERR_INVALID_CALLBACK 대신 ERR_INVALID_ARG_TYPE이 발생합니다.
v9.0.0buffer 인수는 모든 TypedArray 또는 DataView가 될 수 있습니다.
v7.10.0, v6.13.0추가됨: v7.10.0, v6.13.0

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

callback 함수가 제공되지 않으면 오류가 발생합니다.

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

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

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

// 위 코드는 다음과 같습니다:
randomFill(buf, 5, 5, (err, buf) => {
  if (err) throw err;
  console.log(buf.toString('hex'));
});
js
const { randomFill } = require('node:crypto');
const { Buffer } = require('node:buffer');

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

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

// 위 코드는 다음과 같습니다:
randomFill(buf, 5, 5, (err, buf) => {
  if (err) throw err;
  console.log(buf.toString('hex'));
});

임의의 ArrayBuffer, TypedArray 또는 DataView 인스턴스를 buffer로 전달할 수 있습니다.

여기에는 Float32Array 및 Float64Array의 인스턴스가 포함되지만 이 함수는 임의의 부동 소수점 숫자를 생성하는 데 사용해서는 안 됩니다. 결과에는 +Infinity, -Infinity 및 NaN이 포함될 수 있으며, 배열에 유한한 숫자만 포함되어 있더라도 균일한 임의 분포에서 가져오지 않으며 의미 있는 하한 또는 상한이 없습니다.

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

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

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

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

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

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

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

이 API는 libuv의 스레드 풀을 사용하며, 이는 일부 애플리케이션에 놀랍고 부정적인 성능 영향을 미칠 수 있습니다. 자세한 내용은 UV_THREADPOOL_SIZE 문서를 참조하십시오.

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

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

[연혁]

버전변경 사항
v9.0.0buffer 인수는 모든 TypedArray 또는 DataView가 될 수 있습니다.
v7.10.0, v6.13.0추가됨: v7.10.0, v6.13.0

crypto.randomFill()의 동기 버전입니다.

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

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

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

// 위는 다음과 동일합니다:
randomFillSync(buf, 5, 5);
console.log(buf.toString('hex'));
js
const { randomFillSync } = require('node:crypto');
const { Buffer } = require('node:buffer');

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

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

// 위는 다음과 동일합니다:
randomFillSync(buf, 5, 5);
console.log(buf.toString('hex'));

임의의 ArrayBuffer, TypedArray 또는 DataView 인스턴스를 buffer로 전달할 수 있습니다.

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

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

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

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

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

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

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

crypto.randomInt([min, ]max[, callback]) ​

[History]

VersionChanges
v18.0.0callback 인수에 유효하지 않은 콜백을 전달하면 ERR_INVALID_CALLBACK 대신 ERR_INVALID_ARG_TYPE이 발생합니다.
v14.10.0, v12.19.0추가됨: v14.10.0, v12.19.0
  • min <integer> 난수 범위의 시작 (포함). 기본값: 0.
  • max <integer> 난수 범위의 끝 (제외).
  • callback <Function> function(err, n) {}.

min \<= n < max를 만족하는 난수 정수 n을 반환합니다. 이 구현은 모듈로 편향을 피합니다.

범위 (max - min)는 2보다 작아야 합니다. min 및 max는 안전한 정수여야 합니다.

callback 함수가 제공되지 않으면 난수 정수가 동기적으로 생성됩니다.

js
// 비동기
const {
  randomInt,
} = await import('node:crypto');

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

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

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

const n = randomInt(3);
console.log(`Random number chosen from (0, 1, 2): ${n}`);
js
// `min` 인수를 사용하여
const {
  randomInt,
} = await import('node:crypto');

const n = randomInt(1, 7);
console.log(`The dice rolled: ${n}`);
js
// `min` 인수를 사용하여
const {
  randomInt,
} = require('node:crypto');

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

crypto.randomUUID([options]) ​

추가된 버전: v15.6.0, v14.17.0

  • options <Object>

    • disableEntropyCache <boolean> 기본적으로 성능 향상을 위해 Node.js는 최대 128개의 임의 UUID를 생성할 수 있을 만큼의 충분한 임의 데이터를 생성하고 캐시합니다. 캐시를 사용하지 않고 UUID를 생성하려면 disableEntropyCache를 true로 설정하십시오. 기본값: false.

  • 반환: <string>

임의의 RFC 4122 버전 4 UUID를 생성합니다. UUID는 암호화 의사 난수 생성기를 사용하여 생성됩니다.

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

[기록]

버전변경 사항
v18.0.0callback 인수에 잘못된 콜백을 전달하면 ERR_INVALID_CALLBACK 대신 ERR_INVALID_ARG_TYPE 오류가 발생합니다.
v15.0.0password 및 salt 인수는 ArrayBuffer 인스턴스일 수도 있습니다.
v12.8.0, v10.17.0이제 maxmem 값은 안전한 정수일 수 있습니다.
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로 콜백에 전달됩니다.

입력 인수가 유효하지 않은 값 또는 유형을 지정하면 예외가 발생합니다.

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]) ​

[History]

VersionChanges
v12.8.0, v10.17.0이제 maxmem 값은 안전한 정수가 될 수 있습니다.
v10.9.0cost, blockSize 및 parallelization 옵션 이름이 추가되었습니다.
v10.5.0Added in: v10.5.0

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

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

  • keylen <number>

  • options <Object>

    • cost <number> CPU/메모리 비용 매개변수입니다. 2보다 큰 2의 거듭제곱이어야 합니다. 기본값: 16384.
    • blockSize <number> 블록 크기 매개변수입니다. 기본값: 8.
    • parallelization <number> 병렬화 매개변수입니다. 기본값: 1.
    • N <number> cost의 별칭입니다. 둘 중 하나만 지정할 수 있습니다.
    • r <number> blockSize의 별칭입니다. 둘 중 하나만 지정할 수 있습니다.
    • p <number> parallelization의 별칭입니다. 둘 중 하나만 지정할 수 있습니다.
    • maxmem <number> 메모리 상한입니다. (대략) 128 * N * r > maxmem일 때 오류가 발생합니다. 기본값: 32 * 1024 * 1024.

  • 반환값: <Buffer>

동기식 scrypt 구현을 제공합니다. Scrypt는 암호 기반 키 파생 함수로, 무차별 대입 공격이 보람 없도록 계산 및 메모리 측면에서 비용이 많이 들도록 설계되었습니다.

salt는 가능한 한 고유해야 합니다. 솔트는 무작위이고 최소 16바이트 길이로 하는 것이 좋습니다. 자세한 내용은 NIST SP 800-132를 참조하십시오.

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

키 파생에 실패하면 예외가 발생하고, 그렇지 않으면 파생된 키가 Buffer로 반환됩니다.

입력 인수 중 하나라도 유효하지 않은 값 또는 유형을 지정하면 예외가 발생합니다.

js
const {
  scryptSync,
} = await import('node:crypto');
// 팩토리 기본값을 사용합니다.

const key1 = scryptSync('password', 'salt', 64);
console.log(key1.toString('hex'));  // '3745e48...08d59ae'
// 사용자 지정 N 매개변수를 사용합니다. 2의 거듭제곱이어야 합니다.
const key2 = scryptSync('password', 'salt', 64, { N: 1024 });
console.log(key2.toString('hex'));  // '3745e48...aa39b34'
js
const {
  scryptSync,
} = require('node:crypto');
// 팩토리 기본값을 사용합니다.

const key1 = scryptSync('password', 'salt', 64);
console.log(key1.toString('hex'));  // '3745e48...08d59ae'
// 사용자 지정 N 매개변수를 사용합니다. 2의 거듭제곱이어야 합니다.
const key2 = scryptSync('password', 'salt', 64, { N: 1024 });
console.log(key2.toString('hex'));  // '3745e48...aa39b34'

crypto.secureHeapUsed() ​

Added in: v15.6.0

  • 반환값: <Object>
    • total <number> --secure-heap=n 명령줄 플래그를 사용하여 지정된 총 할당된 보안 힙 크기입니다.
    • min <number> --secure-heap-min 명령줄 플래그를 사용하여 지정된 보안 힙에서 최소 할당입니다.
    • used <number> 현재 보안 힙에서 할당된 총 바이트 수입니다.
    • utilization <number> used와 total 할당된 바이트의 계산된 비율입니다.

crypto.setEngine(engine[, flags]) ​

[기록]

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

일부 또는 모든 OpenSSL 함수에 대해 engine을 로드하고 설정합니다(플래그로 선택됨). OpenSSL의 사용자 정의 엔진 지원은 OpenSSL 3부터 더 이상 사용되지 않습니다.

engine은 ID 또는 엔진 공유 라이브러리의 경로일 수 있습니다.

선택적 flags 인수는 기본적으로 ENGINE_METHOD_ALL을 사용합니다. flags는 다음 플래그( crypto.constants에 정의됨) 중 하나 또는 혼합을 사용하는 비트 필드입니다.

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

crypto.setFips(bool) ​

Added in: v10.0.0

  • bool <boolean> FIPS 모드를 활성화하려면 true입니다.

FIPS가 활성화된 Node.js 빌드에서 FIPS 호환 암호화 제공자를 활성화합니다. FIPS 모드를 사용할 수 없는 경우 오류를 발생시킵니다.

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

[History]

VersionChanges
v18.0.0callback 인수에 유효하지 않은 콜백을 전달하면 ERR_INVALID_CALLBACK 대신 ERR_INVALID_ARG_TYPE이 발생합니다.
v15.12.0선택적 콜백 인수가 추가되었습니다.
v13.2.0, v12.16.0이제 이 함수는 IEEE-P1363 DSA 및 ECDSA 서명을 지원합니다.
v12.0.0Added in: v12.0.0

주어진 개인 키와 알고리즘을 사용하여 data에 대한 서명을 계산하고 반환합니다. algorithm이 null 또는 undefined이면 알고리즘은 키 유형(특히 Ed25519 및 Ed448)에 따라 달라집니다.

key가 KeyObject가 아니면 이 함수는 key가 crypto.createPrivateKey()에 전달된 것처럼 동작합니다. 객체인 경우 다음 추가 속성을 전달할 수 있습니다.

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

    • 'der' (기본값): (r, s)를 인코딩하는 DER 인코딩 ASN.1 서명 구조입니다.
    • '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 ​

Added in: 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 다이제스트 또는 인증 쿠키 또는 기능 URL과 같은 비밀 값을 비교하는 데 적합합니다.

a와 b는 모두 Buffers, TypedArrays 또는 DataViews여야 하며 바이트 길이가 동일해야 합니다. a와 b의 바이트 길이가 다르면 오류가 발생합니다.

Uint16Array와 같이 항목당 1바이트보다 많은 바이트를 갖는 TypedArray가 a와 b 중 적어도 하나에 있으면 결과는 플랫폼 바이트 순서를 사용하여 계산됩니다.

두 입력이 모두 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이 발생합니다.
v15.12.0선택적 콜백 인수가 추가되었습니다.
v15.0.0데이터, 키 및 서명 인수는 ArrayBuffer일 수도 있습니다.
v13.2.0, v12.16.0이제 이 함수는 IEEE-P1363 DSA 및 ECDSA 서명을 지원합니다.
v12.0.0v12.0.0에 추가됨

주어진 키와 알고리즘을 사용하여 data에 대한 주어진 서명을 확인합니다. algorithm이 null 또는 undefined인 경우 알고리즘은 키 유형(특히 Ed25519 및 Ed448)에 따라 달라집니다.

key가 KeyObject이 아닌 경우 이 함수는 key가 crypto.createPublicKey()에 전달된 것처럼 작동합니다. 객체인 경우 다음 추가 속성을 전달할 수 있습니다.

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

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

  • padding <integer> RSA에 대한 선택적 패딩 값입니다. 다음 중 하나입니다.

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

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

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

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

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

callback 함수가 제공되면 이 함수는 libuv의 스레드 풀을 사용합니다.

crypto.webcrypto ​

Added in: v15.0.0

Type: <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를 구현하는 다른 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()를 통해 인증 태그를 설정해야 합니다. 그렇지 않으면 암호 해독에 실패하고 final()은 RFC 3610의 2.6절에 따라 오류를 발생시킵니다.
  • CCM 모드에서 write(data), end(data) 또는 pipe()와 같은 스트림 메서드를 사용하면 CCM이 인스턴스당 둘 이상의 데이터 청크를 처리할 수 없기 때문에 실패할 수 있습니다.
  • 추가 인증된 데이터(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 섹션 이름은 {#the-fips-section-name-should-match-the-section-name-inside-the}
# 포함된 fipsmodule.cnf 내부의 섹션 이름과 일치해야 합니다.
fips = fips_sect

[default_sect]
activate = 1

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

bash
openssl fipsinstall

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

bash
export OPENSSL_CONF=/<구성 파일 경로>/nodejs.cnf
export OPENSSL_MODULES=/<openssl 라이브러리 경로>/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 섹션 이름은 {#included-fipsmodulecnf}
# 포함된 fipsmodule.cnf 내부의 섹션 이름과 일치해야 합니다.
fips = fips_sect

[default_sect]
activate = 1

[algorithm_sect]
default_properties = fips=yes

암호화 상수 ​

crypto.constants에서 내보낸 다음 상수는 node:crypto, node:tls 및 node:https 모듈의 다양한 용도에 적용되며 일반적으로 OpenSSL에 특화되어 있습니다.

OpenSSL 옵션 ​

자세한 내용은 SSL OP 플래그 목록을 참조하세요.

상수설명
SSL_OP_ALLOpenSSL 내에서 여러 버그 수정 사항을 적용합니다. 자세한 내용은 https://www.openssl.org/docs/man3.0/man3/SSL_CTX_set_options.html을 참조하세요.
SSL_OP_ALLOW_NO_DHE_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에게 encrypt-then-MAC을 비활성화하도록 지시합니다.
SSL_OP_NO_QUERY_MTU
SSL_OP_NO_RENEGOTIATIONOpenSSL에게 재협상을 비활성화하도록 지시합니다.
SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATIONOpenSSL에게 재협상을 수행할 때 항상 새 세션을 시작하도록 지시합니다.
SSL_OP_NO_SSLv2OpenSSL에게 SSL v2를 끄도록 지시합니다.
SSL_OP_NO_SSLv3OpenSSL에게 SSL v3를 끄도록 지시합니다.
SSL_OP_NO_TICKETOpenSSL에게 RFC4507bis 티켓 사용을 비활성화하도록 지시합니다.
SSL_OP_NO_TLSv1OpenSSL에게 TLS v1을 끄도록 지시합니다.
SSL_OP_NO_TLSv1_1OpenSSL에게 TLS v1.1을 끄도록 지시합니다.
SSL_OP_NO_TLSv1_2OpenSSL에게 TLS v1.2를 끄도록 지시합니다.
SSL_OP_NO_TLSv1_3OpenSSL에게 TLS v1.3을 끄도록 지시합니다.
SSL_OP_PRIORITIZE_CHACHA클라이언트가 ChaCha20-Poly1305를 수행할 때 OpenSSL 서버에게 우선 순위를 지정하도록 지시합니다. SSL_OP_CIPHER_SERVER_PREFERENCE가 활성화되지 않은 경우 이 옵션은 아무런 효과가 없습니다.
SSL_OP_TLS_ROLLBACK_BUGOpenSSL에게 버전 롤백 공격 감지를 비활성화하도록 지시합니다.

OpenSSL 엔진 상수 ​

상수설명
ENGINE_METHOD_RSARSA로 엔진 사용 제한
ENGINE_METHOD_DSADSA로 엔진 사용 제한
ENGINE_METHOD_DHDH로 엔진 사용 제한
ENGINE_METHOD_RANDRAND로 엔진 사용 제한
ENGINE_METHOD_ECEC로 엔진 사용 제한
ENGINE_METHOD_CIPHERSCIPHERS로 엔진 사용 제한
ENGINE_METHOD_DIGESTSDIGESTS로 엔진 사용 제한
ENGINE_METHOD_PKEY_METHSPKEY_METHS로 엔진 사용 제한
ENGINE_METHOD_PKEY_ASN1_METHSPKEY_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_DIGESTRSA_PKCS1_PSS_PADDING의 솔트 길이를 서명 또는 검증 시 다이제스트 크기로 설정합니다.
RSA_PSS_SALTLEN_MAX_SIGNRSA_PKCS1_PSS_PADDING의 솔트 길이를 데이터 서명 시 허용되는 최대값으로 설정합니다.
RSA_PSS_SALTLEN_AUTORSA_PKCS1_PSS_PADDING의 솔트 길이가 서명 검증 시 자동으로 결정되도록 합니다.
POINT_CONVERSION_COMPRESSED
POINT_CONVERSION_UNCOMPRESSED
POINT_CONVERSION_HYBRID

Node.js crypto 상수 ​

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