Криптография

Модуль crypto предоставляет криптографические функции, включающие набор обёртки для функций OpenSSL's hash, HMAC, шифрования, расшифрования, подписи и проверки.

Для доступа к этому модулю используйте require('crypto').

const crypto = require('crypto');

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

Определение отсутствия поддержки криптографии

Возможно, Node.js скомпилирован без поддержки модуля crypto. В таких случаях вызов require('crypto') приведёт к ошибке.

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

Класс: Сертификат

SPKAC — это механизм запроса подписи сертификата, первоначально реализованный Netscape и теперь формально определённый как часть элемента HTML5 keygen.

Модуль crypto предоставляет класс Certificate для работы с данными SPKAC. Наиболее распространённое использование — обработка выходных данных, генерируемых элементом HTML5 <keygen>. Node.js использует внутренне реализацию SPKAC OpenSSL.

new crypto.Certificate()

Экземпляры класса Certificate могут быть созданы с помощью ключевого слова new или вызовом crypto.Certificate() как функции:

const crypto = require('crypto');

const cert1 = new crypto.Certificate();
const cert2 = crypto.Certificate();

certificate.exportChallenge(spkac)

Структура данных spkac включает открытый ключ и вызов. Метод certificate.exportChallenge() возвращает компонент вызова в виде объекта Node.js Buffer. Аргумент spkac может быть строкой или Buffer.

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

certificate.exportPublicKey(spkac)

Структура данных spkac включает открытый ключ и вызов. Метод certificate.exportPublicKey() возвращает компонент открытого ключа в виде объекта Node.js Buffer. Аргумент spkac может быть строкой или Buffer.

const cert = require('crypto').Certificate();
const spkac = getSpkacSomehow();
const publicKey = cert.exportPublicKey(spkac);
console.log(publicKey);
// Prints: the public key as <Buffer ...>

certificate.verifySpkac(spkac)

Возвращает true, если заданная структура данных spkac валидна, false в противном случае. Аргумент spkac должен быть объектом Node.js Buffer.

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

Класс: Шифр

Экземпляры класса Cipher используются для шифрования данных. Класс может использоваться двумя способами:

• В качестве потока, который одновременно читабелен и записывается, где нешифрованные данные записываются для получения зашифрованных данных со стороны чтения, или
• Используя методы cipher.update() и cipher.final() для получения зашифрованных данных.

Методы crypto.createCipher() или crypto.createCipheriv() используются для создания экземпляров Cipher. Объекты Cipher не должны создаваться напрямую с использованием ключевого слова new

Пример: Использование объектов Cipher в качестве потоков:

const crypto = require('crypto');
const cipher = crypto.createCipher('aes192', 'a password');

let encrypted = '';
cipher.on('readable', () => {
  const data = cipher.read();
  if (data)
    encrypted += data.toString('hex');
});
cipher.on('end', () => {
  console.log(encrypted);
  // Prints: ca981be48e90867604588e75d04feabb63cc007a8f8ad89b10616ed84d815504
});

cipher.write('some clear text data');
cipher.end();

Пример: Использование объектов Cipher и потоков с перенаправлением:

const crypto = require('crypto');
const fs = require('fs');
const cipher = crypto.createCipher('aes192', 'a password');

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

input.pipe(cipher).pipe(output);

Пример: Использование методов cipher.update() и cipher.final():

const crypto = require('crypto');
const cipher = crypto.createCipher('aes192', 'a password');

let encrypted = cipher.update('some clear text data', 'utf8', 'hex');
encrypted += cipher.final('hex');
console.log(encrypted);
// Prints: ca981be48e90867604588e75d04feabb63cc007a8f8ad89b10616ed84d815504

cipher.final([output_encoding])

Возвращает все оставшиеся зашифрованные данные. Если параметр output_encoding является одним из 'latin1', 'base64' или 'hex', возвращается строка. Если параметр output_encoding не указан, возвращается Buffer.

После вызова метода cipher.final(), объект Cipher больше нельзя использовать для шифрования данных. Попытка вызвать cipher.final() более одного раза приведёт к ошибке.

cipher.setAAD(buffer)

При использовании режима аутентифицированного шифрования (в настоящее время поддерживается только GCM), метод cipher.setAAD() устанавливает значение, используемое для параметра входных данных дополнительных аутентифицированных данных (AAD).

Возвращает this для цепочки вызовов.

cipher.getAuthTag()

При использовании режима аутентифицированного шифрования (в настоящее время поддерживается только GCM), метод cipher.getAuthTag() возвращает Buffer, содержащий тег аутентификации, вычисленный из заданных данных.

Метод cipher.getAuthTag() следует вызывать только после завершения шифрования с помощью метода cipher.final().

cipher.setAutoPadding(auto_padding=true)

При использовании блочных алгоритмов шифрования класс Cipher автоматически добавит заполнение к входным данным до соответствующего размера блока. Для отключения стандартного заполнения вызовите cipher.setAutoPadding(false)

Когда auto_padding равно false, длина всех входных данных должна быть кратна размеру блока шифра, иначе метод cipher.final() выбросит ошибку. Отключение автоматического заполнения полезно для нестандартного заполнения, например, используя 0x0 вместо заполнения PKCS.

Метод cipher.setAutoPadding() должен быть вызван до cipher.final().

Возвращает this для цепочки вызовов.

cipher.update(data[, input_encoding][, output_encoding])

Обновляет шифр с использованием data. Если указан аргумент input_encoding, его значение должно быть одним из 'utf8', 'ascii', или 'latin1', а аргумент data — строкой с указанной кодировкой. Если аргумент input_encoding не указан, аргумент data должен быть Buffer. Если data — Buffer, то аргумент input_encoding игнорируется.

Параметр output_encoding задаёт формат вывода зашифрованных данных и может быть 'latin1', 'base64' или 'hex'. Если параметр output_encoding указан, возвращается строка с указанной кодировкой. Если параметр output_encoding не указан, возвращается Buffer.

Метод cipher.update() можно вызывать несколько раз с новыми данными до вызова cipher.final(). Вызов cipher.update() после cipher.final() приведёт к ошибке.

Класс: Расшифровка

Экземпляры класса Decipher используются для расшифрования данных. Класс может использоваться двумя способами:

• В качестве потока, который одновременно читабелен и записывается, где зашифрованные данные записываются для получения незашифрованных данных со стороны чтения, или
• Используя методы decipher.update() и decipher.final() для получения незашифрованных данных.

Методы crypto.createDecipher() или crypto.createDecipheriv() используются для создания экземпляров Decipher. Объекты Decipher не должны создаваться напрямую с использованием ключевого слова new

Пример: Использование объектов Decipher в качестве потоков:

const crypto = require('crypto');
const decipher = crypto.createDecipher('aes192', 'a password');

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

const encrypted =
  'ca981be48e90867604588e75d04feabb63cc007a8f8ad89b10616ed84d815504';
decipher.write(encrypted, 'hex');
decipher.end();

Пример: Использование объектов Decipher и потоков с перенаправлением:

const crypto = require('crypto');
const fs = require('fs');
const decipher = crypto.createDecipher('aes192', 'a password');

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

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

Пример: Использование методов decipher.update() и decipher.final():

const crypto = require('crypto');
const decipher = crypto.createDecipher('aes192', 'a password');

const encrypted =
  'ca981be48e90867604588e75d04feabb63cc007a8f8ad89b10616ed84d815504';
let decrypted = decipher.update(encrypted, 'hex', 'utf8');
decrypted += decipher.final('utf8');
console.log(decrypted);
// Prints: some clear text data

decipher.final([output_encoding])

Возвращает все оставшиеся расшифрованные данные. Если параметр output_encoding является одним из 'latin1', 'ascii' или 'utf8', возвращается строка. Если параметр output_encoding не указан, возвращается Buffer.

После вызова метода decipher.final(), объект Decipher больше нельзя использовать для расшифрования данных. Попытка вызвать decipher.final() более одного раза приведёт к ошибке.

decipher.setAAD(buffer)

При использовании режима аутентифицированного шифрования (в настоящее время поддерживается только GCM), метод decipher.setAAD() устанавливает значение, используемое для параметра входных данных дополнительных аутентифицированных данных (AAD).

Возвращает this для цепочки вызовов.

decipher.setAuthTag(buffer)

При использовании режима аутентифицированного шифрования (в настоящее время поддерживается только GCM), метод decipher.setAuthTag() используется для передачи полученного тега аутентификации. Если тег не предоставлен или шифрованный текст был изменён, decipher.final() будет брошен, указывая, что шифрованный текст должен быть отброшен из-за неудачной аутентификации.

Возвращает this для цепочки методов.

decipher.setAutoPadding(auto_padding=true)

Когда данные были зашифрованы без стандартного заполнения блоков, вызов decipher.setAutoPadding(false) отключит автоматическое заполнение, чтобы предотвратить decipher.final() от проверки и удаления заполнения.

Отключение автоматического заполнения будет работать только в том случае, если длина входных данных кратна размеру блока шифра.

Метод decipher.setAutoPadding() должен быть вызван перед decipher.update().

Возвращает this для цепочки методов.

decipher.update(data[, input_encoding][, output_encoding])

Обновляет дешифратор с data. Если аргумент input_encoding указан, его значение должно быть одним из 'latin1', 'base64', или 'hex', а аргумент data — строкой, использующей указанное кодирование. Если аргумент input_encoding не указан, data должен быть Buffer. Если data является Buffer, то input_encoding игнорируется.

output_encoding определяет формат вывода зашифрованных данных и может быть 'latin1', 'ascii' или 'utf8'. Если output_encoding указан, возвращается строка, использующая указанное кодирование. Если output_encoding не указан, возвращается Buffer.

Метод decipher.update() может быть вызван несколько раз с новыми данными, пока не будет вызван decipher.final(). Вызов decipher.update() после decipher.final() приведёт к ошибке.

Класс: DiffieHellman

Класс DiffieHellman — это утилита для создания обменов ключами Диффи-Хеллмана.

Экземпляры класса DiffieHellman можно создать с помощью функции crypto.createDiffieHellman().

const crypto = require('crypto');
const assert = require('assert');

// Generate Alice's keys...
const alice = crypto.createDiffieHellman(2048);
const aliceKey = alice.generateKeys();

// Generate Bob's keys...
const bob = crypto.createDiffieHellman(alice.getPrime(), alice.getGenerator());
const bobKey = bob.generateKeys();

// Exchange and generate the secret...
const aliceSecret = alice.computeSecret(bobKey);
const bobSecret = bob.computeSecret(aliceKey);

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

diffieHellman.computeSecret(other_public_key[, input_encoding][, output_encoding])

Вычисляет общую тайну, используя other_public_key в качестве открытого ключа другой стороны и возвращает вычисленную общую тайну. Предоставленный ключ интерпретируется с использованием указанного input_encoding, а тайна кодируется с использованием указанного output_encoding. Кодирования могут быть 'latin1', 'hex', или 'base64'. Если input_encoding не указан, other_public_key ожидается как Buffer.

Если output_encoding указан, возвращается строка; в противном случае возвращается Buffer.

diffieHellman.generateKeys([encoding])

Генерирует значения закрытого и открытого ключей Диффи-Хеллмана и возвращает открытый ключ в указанном encoding. Этот ключ должен быть передан другой стороне. Кодирование может быть 'latin1', 'hex', или 'base64'. Если encoding указан, возвращается строка; в противном случае возвращается Buffer.

diffieHellman.getGenerator([encoding])

Возвращает генератор Диффи-Хеллмана в указанном encoding, который может быть 'latin1', 'hex', или 'base64'. Если encoding указан, возвращается строка; в противном случае возвращается Buffer.

diffieHellman.getPrime([encoding])

Возвращает простое число Диффи-Хеллмана в указанном encoding, которое может быть 'latin1', 'hex', или 'base64'. Если encoding указан, возвращается строка; в противном случае возвращается Buffer.

diffieHellman.getPrivateKey([encoding])

Возвращает закрытый ключ Диффи-Хеллмана в указанном encoding, который может быть 'latin1', 'hex', или 'base64'. Если encoding указан, возвращается строка; в противном случае возвращается Buffer.

diffieHellman.getPublicKey([encoding])

Возвращает открытый ключ Диффи-Хеллмана в указанном encoding, который может быть 'latin1', 'hex', или 'base64'. Если encoding указан, возвращается строка; в противном случае возвращается Buffer.

diffieHellman.setPrivateKey(private_key[, encoding])

Устанавливает закрытый ключ Диффи-Хеллмана. Если аргумент encoding указан и равен 'latin1', 'hex', или 'base64', ожидается, что private_key будет строкой. Если encoding не указан, ожидается, что private_key будет Buffer.

diffieHellman.setPublicKey(public_key[, encoding])

Устанавливает открытый ключ Диффи-Хеллмана. Если аргумент encoding указан и равен 'latin1', 'hex', или 'base64', ожидается, что public_key будет строкой. Если encoding не указан, ожидается, что public_key будет Buffer.

diffieHellman.verifyError

Поле битов, содержащее любые предупреждения и/или ошибки, полученные в результате проверки, выполненной во время инициализации объекта DiffieHellman.

Следующие значения допустимы для этого свойства (как определено в модуле constants):

• DH_CHECK_P_NOT_SAFE_PRIME
• DH_CHECK_P_NOT_PRIME
• DH_UNABLE_TO_CHECK_GENERATOR
• DH_NOT_SUITABLE_GENERATOR

Класс: ECDH

Класс ECDH — это утилита для создания обменов ключами Эллиптической кривой Диффи-Хеллмана (ECDH).

Экземпляры класса ECDH можно создать с помощью функции crypto.createECDH().

const crypto = require('crypto');
const assert = require('assert');

// Generate Alice's keys...
const alice = crypto.createECDH('secp521r1');
const aliceKey = alice.generateKeys();

// Generate Bob's keys...
const bob = crypto.createECDH('secp521r1');
const bobKey = bob.generateKeys();

// Exchange and generate the secret...
const aliceSecret = alice.computeSecret(bobKey);
const bobSecret = bob.computeSecret(aliceKey);

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

ecdh.computeSecret(other_public_key[, input_encoding][, output_encoding])

Вычисляет общую тайну, используя other_public_key в качестве открытого ключа другой стороны и возвращает вычисленную общую тайну. Предоставленный ключ интерпретируется с использованием указанного input_encoding, а возвращаемая тайна кодируется с использованием указанного output_encoding. Кодирования могут быть 'latin1', 'hex', или 'base64'. Если input_encoding не указан, other_public_key ожидается как Buffer.

Если output_encoding указан, возвращается строка; в противном случае возвращается Buffer.

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

Генерирует значения закрытого и открытого ключей EC Диффи-Хеллмана и возвращает открытый ключ в указанных format и encoding. Этот ключ должен быть передан другой стороне.

Аргумент format задает кодирование точки и может быть 'compressed', 'uncompressed', или 'hybrid'. Если format не указан, точка будет возвращена в формате 'uncompressed'.

Аргумент encoding может быть 'latin1', 'hex', или 'base64'. Если encoding указан, возвращается строка; в противном случае возвращается Buffer.

ecdh.getPrivateKey([encoding])

Возвращает закрытый ключ EC Диффи-Хеллмана в указанном encoding, который может быть 'latin1', 'hex', или 'base64'. Если encoding указан, возвращается строка; в противном случае возвращается Buffer.

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

Возвращает открытый ключ EC Диффи-Хеллмана в указанных encoding и format.

Аргумент format задаёт кодирование точки и может быть 'compressed', 'uncompressed', или 'hybrid'. Если format не указан, точка будет возвращена в формате 'uncompressed'.

Аргумент encoding может быть 'latin1', 'hex', или 'base64'. Если encoding указан, возвращается строка; в противном случае возвращается Buffer.

ecdh.setPrivateKey(private_key[, encoding])

Устанавливает закрытый ключ EC Diffie-Hellman. Кодировка encoding может быть 'latin1', 'hex' или 'base64'. Если указана encoding, ожидается, что private_key будет строкой; в противном случае private_key ожидается в виде Buffer. Если private_key не соответствует кривой, указанной при создании объекта ECDH, возникает ошибка. При установке закрытого ключа связанная открытая точка (ключ) также генерируется и устанавливается в объекте ECDH.

ecdh.setPublicKey(public_key[, encoding])

Устанавливает открытый ключ EC Diffie-Hellman. Кодировка ключа может быть 'latin1', 'hex' или 'base64'. Если указана encoding, ожидается, что public_key будет строкой; в противном случае ожидается Buffer.

Обратите внимание, что обычно нет необходимости вызывать этот метод, так как для вычисления общего секрета ECDH требуется только закрытый ключ и открытый ключ другой стороны. Обычно вызывается либо ecdh.generateKeys(), либо ecdh.setPrivateKey(). Метод ecdh.setPrivateKey() пытается сгенерировать открытую точку/ключ, связанную с устанавливаемым закрытым ключом.

Пример (получение общего секрета):

const crypto = require('crypto');
const alice = crypto.createECDH('secp256k1');
const bob = crypto.createECDH('secp256k1');

// Note: This is a shortcut way to specify one of Alice's previous private
// keys. It would be unwise to use such a predictable private key in a real
// application.
alice.setPrivateKey(
  crypto.createHash('sha256').update('alice', 'utf8').digest()
);

// Bob uses a newly generated cryptographically strong
// pseudorandom key pair
bob.generateKeys();

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

// aliceSecret and bobSecret should be the same shared secret value
console.log(aliceSecret === bobSecret);

Класс: Hash

Класс Hash — это утилита для создания хэш-дайджестов данных. Он может использоваться двумя способами:

• В качестве потока stream, который является одновременно читаемым и записываемым, где данные записываются для вычисления хэш-дайджеста на стороне чтения, или
• Используя методы hash.update() и hash.digest() для вычисления хэша.

Метод crypto.createHash() используется для создания экземпляров Hash. Экземпляры Hash не должны создаваться напрямую с помощью ключевого слова new.

Пример: Использование объектов Hash в качестве потоков:

const crypto = require('crypto');
const hash = crypto.createHash('sha256');

hash.on('readable', () => {
  const data = hash.read();
  if (data) {
    console.log(data.toString('hex'));
    // Prints:
    //   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
  }
});

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

Пример: Использование объектов Hash и конвейерных потоков:

const crypto = require('crypto');
const fs = require('fs');
const hash = crypto.createHash('sha256');

const input = fs.createReadStream('test.js');
input.pipe(hash).pipe(process.stdout);

Пример: Использование методов hash.update() и hash.digest():

const crypto = require('crypto');
const hash = crypto.createHash('sha256');

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

hash.digest([encoding])

Вычисляет дайджест всех данных, переданных для хэширования (используя метод hash.update()). Кодировка encoding может быть 'hex', 'latin1' или 'base64'. Если указана encoding, возвращается строка; в противном случае возвращается Buffer.

Объект Hash не может быть использован повторно после вызова метода hash.digest(). Несколько вызовов приведут к ошибке.

hash.update(data[, input_encoding])

Обновляет содержимое хэша с использованием заданных data, кодировка которых задается в input_encoding и может быть 'utf8', 'ascii' или 'latin1'. Если encoding не указано и data является строкой, используется кодировка 'utf8'. Если data — Buffer, то input_encoding игнорируется.

Это можно вызывать многократно с новыми данными по мере их потоковой передачи.

Класс: Hmac

Класс Hmac — это утилита для создания криптографических дайджестов HMAC. Он может использоваться двумя способами:

• В качестве потока stream, который одновременно читаем и записываем, где данные записываются для вычисления дайджеста HMAC на стороне чтения, или
• Используя методы hmac.update() и hmac.digest() для вычисления дайджеста HMAC.

Метод crypto.createHmac() используется для создания экземпляров Hmac. Экземпляры Hmac не должны создаваться напрямую с помощью ключевого слова new.

Пример: Использование объектов Hmac в качестве потоков:

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

hmac.on('readable', () => {
  const data = hmac.read();
  if (data) {
    console.log(data.toString('hex'));
    // Prints:
    //   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
  }
});

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

Пример: Использование объектов Hmac и конвейерных потоков:

const crypto = require('crypto');
const fs = require('fs');
const hmac = crypto.createHmac('sha256', 'a secret');

const input = fs.createReadStream('test.js');
input.pipe(hmac).pipe(process.stdout);

Пример: Использование методов hmac.update() и hmac.digest():

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

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

hmac.digest([encoding])

Вычисляет дайджест HMAC всех переданных данных, используя hmac.update(). Кодировка encoding может быть 'hex', 'latin1' или 'base64'. Если указана encoding, возвращается строка; в противном случае — Buffer.

Объект Hmac не может быть использован повторно после вызова hmac.digest(). Несколько вызовов hmac.digest() приведут к ошибке.

hmac.update(data[, input_encoding])

Обновляет содержимое Hmac с помощью заданных data, кодировка которых задана в input_encoding и может быть 'utf8', 'ascii' или 'latin1'. Если encoding не задано и data является строкой, используется кодировка 'utf8'. Если data является Buffer, то input_encoding игнорируется.

Это можно вызывать многократно с новыми данными по мере их потоковой передачи.

Класс: Sign

Класс Sign — это утилита для генерации подписей. Он может использоваться двумя способами:

• В качестве записываемого потока stream, куда записываются данные для подписи, и метод sign.sign() используется для генерации и возвращения подписи, или
• Используя методы sign.update() и sign.sign() для вычисления подписи.

Метод crypto.createSign() используется для создания экземпляров Sign. Аргументом является строковое имя используемой функции хэширования. Экземпляры Sign не должны создаваться напрямую с помощью ключевого слова new.

Пример: Использование объектов Sign в качестве потоков:

const crypto = require('crypto');
const sign = crypto.createSign('SHA256');

sign.write('some data to sign');
sign.end();

const privateKey = getPrivateKeySomehow();
console.log(sign.sign(privateKey, 'hex'));
// Prints: the calculated signature using the specified private key and
// SHA-256. For RSA keys, the algorithm is RSASSA-PKCS1-v1_5 (see padding
// parameter below for RSASSA-PSS). For EC keys, the algorithm is ECDSA.

Пример: Использование методов sign.update() и sign.sign():

const crypto = require('crypto');
const sign = crypto.createSign('SHA256');

sign.update('some data to sign');

const privateKey = getPrivateKeySomehow();
console.log(sign.sign(privateKey, 'hex'));
// Prints: the calculated signature

В некоторых случаях экземпляр Sign также может быть создан путем передачи имени алгоритма подписи, такого как 'RSA-SHA256'. Это будет использовать соответствующий алгоритм дайджеста. Это не работает для всех алгоритмов подписи, таких как 'ecdsa-with-SHA256'. Используйте имена дайджестов вместо этого.

Пример: подписание с использованием устаревшего имени алгоритма подписи

const crypto = require('crypto');
const sign = crypto.createSign('RSA-SHA256');

sign.update('some data to sign');

const privateKey = getPrivateKeySomehow();
console.log(sign.sign(privateKey, 'hex'));
// Prints: the calculated signature

sign.sign(private_key[, output_format])

Вычисляет подпись на всех данных, переданных через sign.update() или sign.write().

Аргумент private_key может быть объектом или строкой. Если private_key — строка, она обрабатывается как сырой ключ без парольной фразы. Если private_key — объект, он должен содержать одну или несколько из следующих свойств:

• key: <строка> — PEM-закодированный закрытый ключ (необходимый)
• passphrase: <строка> — парольная фраза для закрытого ключа

• padding: <целое число> — необязательное значение заполнения для RSA, одно из следующих:

  • crypto.constants.RSA_PKCS1_PADDING (по умолчанию)
  • crypto.constants.RSA_PKCS1_PSS_PADDING

  Обратите внимание, что RSA_PKCS1_PSS_PADDING будет использовать MGF1 с той же функцией хэширования, которая использовалась для подписи сообщения, как указано в разделе 3.1 RFC 4055.

• saltLength: <целое число> — длина соли при использовании заполнения RSA_PKCS1_PSS_PADDING. Специальное значение crypto.constants.RSA_PSS_SALTLEN_DIGEST устанавливает длину соли равной размеру дайджеста, crypto.constants.RSA_PSS_SALTLEN_MAX_SIGN (по умолчанию) устанавливает её максимальному допустимому значению.

output_format может указать одну из 'latin1', 'hex' или 'base64'. Если output_format задан, возвращается строка; в противном случае — Buffer.

Объект Sign больше не может быть использован после вызова метода sign.sign(). Несколько вызовов sign.sign() приведут к ошибке.

sign.update(data[, input_encoding])

Обновляет Sign содержимое заданным data, кодировка которого указана в input_encoding и может быть 'utf8', 'ascii' или 'latin1'. Если encoding не указано, и data является строкой, применяется кодировка 'utf8'. Если data является Buffer, то input_encoding игнорируется.

Этот метод можно вызывать многократно с новыми данными по мере их поступления.

Класс: Verify

Класс Verify — это утилита для проверки подписей. Его можно использовать двумя способами:

• Как записываемый поток, где записанные данные используются для проверки против предоставленной подписи;
• Используя методы verify.update() и verify.verify() для проверки подписи.

Метод crypto.createVerify() используется для создания экземпляров Verify. Экземпляры Verify не должны создаваться напрямую с использованием ключевого слова new.

Пример: использование объектов Verify в качестве потоков:

const crypto = require('crypto');
const verify = crypto.createVerify('SHA256');

verify.write('some data to sign');
verify.end();

const publicKey = getPublicKeySomehow();
const signature = getSignatureToVerify();
console.log(verify.verify(publicKey, signature));
// Prints: true or false

Пример: использование методов verify.update() и verify.verify():

const crypto = require('crypto');
const verify = crypto.createVerify('SHA256');

verify.update('some data to sign');

const publicKey = getPublicKeySomehow();
const signature = getSignatureToVerify();
console.log(verify.verify(publicKey, signature));
// Prints: true or false

verifier.update(data[, input_encoding])

Обновляет Verify содержимое заданным data, кодировка которого указана в input_encoding и может быть 'utf8', 'ascii' или 'latin1'. Если encoding не указано, и data является строкой, применяется кодировка 'utf8'. Если data является Buffer, то input_encoding игнорируется.

Этот метод можно вызывать многократно с новыми данными по мере их поступления.

verifier.verify(object, signature[, signature_format])

• object <строка> | <объект>
• signature <строка> | <Буфер> | <Uint8 массив>
• signature_format <строка>

Проверяет предоставленные данные с использованием заданного object и signature. Аргумент object может быть строкой, содержащей PEM-кодированный объект, который может быть открытым ключом RSA, открытым ключом DSA или сертификатом X.509, или объектом с одним или несколькими из следующих свойств:

• key: <строка> - PEM-кодированный открытый ключ (обязательно)

• padding: <целое число> - необязательное значение заполнения для RSA, одно из следующих:

  • crypto.constants.RSA_PKCS1_PADDING (по умолчанию)
  • crypto.constants.RSA_PKCS1_PSS_PADDING

  Обратите внимание, что RSA_PKCS1_PSS_PADDING будет использовать MGF1 с той же функцией хеширования, которая используется для проверки сообщения, как указано в разделе 3.1 RFC 4055.

• saltLength: <целое число> - длина соли для случая, когда padding RSA_PKCS1_PSS_PADDING. Специальное значение crypto.constants.RSA_PSS_SALTLEN_DIGEST устанавливает длину соли в размер дайджеста, crypto.constants.RSA_PSS_SALTLEN_AUTO (по умолчанию) вызывает ее автоматическое определение.

Аргумент signature — это ранее вычисленная подпись для данных в signature_format, которая может быть 'latin1', 'hex' или 'base64'. Если указан signature_format, ожидается, что signature будет строкой; в противном случае signature ожидается как Buffer.

Возвращает true или false в зависимости от валидности подписи для данных и открытого ключа.

Объект verifier не может быть использован повторно после вызова verify.verify(). Несколько вызовов verify.verify() приведут к ошибке.

crypto методы и свойства модуля

crypto.constants

Возвращает объект, содержащий часто используемые константы для операций с криптографией и безопасностью. Конкретные константы, которые в настоящее время определены, описаны в Криптографические константы.

crypto.DEFAULT_ENCODING

Кодировка по умолчанию для функций, которые могут принимать строки или буферы. Значение по умолчанию 'buffer', что делает методы по умолчанию Buffer объектами.

Механизм crypto.DEFAULT_ENCODING предоставляется для обратной совместимости со старыми программами, которые ожидают 'latin1' в качестве кодировки по умолчанию.

Новые приложения должны ожидать, что по умолчанию будет 'buffer'. Это свойство может быть устаревшим в будущих выпусках Node.js.

crypto.fips

Свойство для проверки и управления тем, используется ли в настоящее время совместимый с FIPS криптографический провайдер. Установка в значение true требует сборки Node.js с FIPS.

crypto.createCipher(algorithm, password)

Создаёт и возвращает объект Cipher , использующий указанный algorithm и password.

algorithm зависит от OpenSSL, примерами являются 'aes192', и т. д. В последних выпусках OpenSSL openssl list-cipher-algorithms отобразит доступные алгоритмы шифрования.

password используется для вывода ключа шифрования и вектора инициализации (IV). Значение должно быть строкой, закодированной в 'latin1', или Buffer.

Реализация crypto.createCipher() выводит ключи с помощью функции OpenSSL EVP_BytesToKey с алгоритмом дайджеста MD5, одной итерацией и без соли. Отсутствие соли допускает атаки по словарю, так как один и тот же пароль всегда создает один и тот же ключ. Низкое число итераций и некриптографически безопасный алгоритм хеширования позволяют очень быстро проверять пароли.

В соответствии с рекомендацией OpenSSL использовать PBKDF2 вместо EVP_BytesToKey рекомендуется, чтобы разработчики самостоятельно вычисляли ключ и IV с использованием crypto.pbkdf2() и использовать crypto.createCipheriv() для создания объекта Cipher. Пользователи не должны использовать шифры с режимом счётчика (например, CTR, GCM или CCM) в crypto.createCipher(). Выводится предупреждение, чтобы избежать риска повторного использования IV, что приводит к уязвимости. В случае повторного использования IV в GCM см. Nonce-Disrespecting Adversaries для получения подробной информации.

crypto.createCipheriv(algorithm, key, iv)

Создаёт и возвращает объект Cipher, с заданным algorithm, key и вектором инициализации (iv).

algorithm зависит от OpenSSL, примерами являются 'aes192', и т. д. В последних выпусках OpenSSL openssl list-cipher-algorithms отобразит доступные алгоритмы шифрования.

key — это исходный ключ, используемый algorithm, и iv — вектор инициализации. Оба аргумента должны быть строками, закодированными в 'utf8', или буферами.

crypto.createCredentials(details)

• details <объект> Идентично tls.createSecureContext().

Метод crypto.createCredentials() — это устаревшая функция для создания и возврата объекта tls.SecureContext. Его не следует использовать. Замените его на tls.createSecureContext(), который имеет те же аргументы и возвращаемое значение.

Возвращает tls.SecureContext, как если бы был вызван tls.createSecureContext().

crypto.createDecipher(algorithm, password)

Создаёт и возвращает объект Decipher , использующий указанный algorithm и password (ключ).

Реализация crypto.createDecipher() извлекает ключи с помощью функции OpenSSL EVP_BytesToKey с алгоритмом хеширования MD5, одной итерацией и без соли. Отсутствие соли позволяет проводить атаки методом подбора словарей, так как один и тот же пароль всегда создаёт один и тот же ключ. Низкое число итераций и некриптографически безопасный алгоритм хеширования позволяют очень быстро проверять пароли.

В соответствии с рекомендацией OpenSSL использовать PBKDF2 вместо EVP_BytesToKey, рекомендуется, чтобы разработчики самостоятельно извлекали ключ и IV, используя crypto.pbkdf2(), и использовать crypto.createDecipheriv() для создания объекта Decipher.

crypto.createDecipheriv(algorithm, key, iv)

Создаёт и возвращает объект Decipher, использующий указанный алгоритм algorithm, ключ key и вектор инициализации (iv).

Объект algorithm зависит от OpenSSL; примерами являются 'aes192', и т. д. В последних версиях OpenSSL openssl list-cipher-algorithms отобразит доступные алгоритмы шифрования.

Ключ key является исходным ключом, используемым algorithm, а iv — вектором инициализации. Оба аргумента должны быть строками в кодировке 'utf8', буферами, TypedArray, или DataView.

crypto.createDiffieHellman(prime[, prime_encoding][, generator][, generator_encoding])

Создаёт объект для обмена ключами Диффи-Хеллмана DiffieHellman с предоставленным prime и необязательным конкретным generator.

Аргумент generator может быть числом, строкой или Buffer. Если generator не указан, используется значение 2.

Аргументы prime_encoding и generator_encoding могут быть 'latin1', 'hex', или 'base64'.

Если prime_encoding указан, prime ожидается в виде строки; в противном случае ожидается Buffer.

Если generator_encoding указан, generator ожидается в виде строки; в противном случае ожидается число или Buffer.

crypto.createDiffieHellman(prime_length[, generator])

Создаёт объект для обмена ключами Диффи-Хеллмана DiffieHellman и генерирует простое число длиной prime_length бит с использованием необязательного конкретного числового generator Если generator не указан, используется значение 2.

crypto.createECDH(curve_name)

Создаёт объект для обмена ключами Диффи-Хеллмана Эллиптических кривых (ECDH) с использованием предопределённой кривой, заданной строкой curve_name Используйте crypto.getCurves() для получения списка доступных имён кривых. В последних версиях OpenSSL openssl ecparam -list_curves также отобразит имя и описание каждой доступной эллиптической кривой.

crypto.createHash(algorithm)

Создаёт и возвращает объект Hash, который можно использовать для генерации хэш-значений с заданным algorithm.

Объект algorithm зависит от поддерживаемых алгоритмов, доступных в версии OpenSSL на платформе. Примеры: 'sha256', 'sha512', и т. д. В последних версиях OpenSSL openssl list-message-digest-algorithms отобразит доступные алгоритмы хеширования.

Пример: генерация sha256 суммы файла

const filename = process.argv[2];
const crypto = require('crypto');
const fs = require('fs');

const hash = crypto.createHash('sha256');

const input = fs.createReadStream(filename);
input.on('readable', () => {
  const data = input.read();
  if (data)
    hash.update(data);
  else {
    console.log(`${hash.digest('hex')} ${filename}`);
  }
});

crypto.createHmac(algorithm, key)

Создаёт и возвращает объект Hmac, использующий заданный algorithm и key.

Объект algorithm зависит от поддерживаемых алгоритмов, доступных в версии OpenSSL на платформе. Примеры: 'sha256', 'sha512', и т. д. В последних версиях OpenSSL openssl list-message-digest-algorithms отобразит доступные алгоритмы хеширования.

key — ключ HMAC, используемый для генерации криптографического HMAC-хэша.

Пример: генерация sha256 HMAC файла

const filename = process.argv[2];
const crypto = require('crypto');
const fs = require('fs');

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

const input = fs.createReadStream(filename);
input.on('readable', () => {
  const data = input.read();
  if (data)
    hmac.update(data);
  else {
    console.log(`${hmac.digest('hex')} ${filename}`);
  }
});

crypto.createSign(algorithm)

Создаёт и возвращает объект Sign, использующий указанный algorithm Используйте crypto.getHashes() для получения массива имён доступных алгоритмов подписи.

crypto.createVerify(algorithm)

Создаёт и возвращает объект Verify, использующий заданный алгоритм. Используйте crypto.getHashes() для получения массива имён доступных алгоритмов подписи.

crypto.getCiphers()

Возвращает массив с именами поддерживаемых алгоритмов шифрования.

Пример:

const ciphers = crypto.getCiphers();
console.log(ciphers); // ['aes-128-cbc', 'aes-128-ccm', ...]

crypto.getCurves()

Возвращает массив с именами поддерживаемых эллиптических кривых.

Пример:

const curves = crypto.getCurves();
console.log(curves); // ['Oakley-EC2N-3', 'Oakley-EC2N-4', ...]

crypto.getDiffieHellman(group_name)

Создаёт предварительно определённый объект DiffieHellman обмена ключами. Поддерживаемые группы: 'modp1', 'modp2', 'modp5' (определён в RFC 2412, но см. Примечания) и 'modp14', 'modp15', 'modp16', 'modp17', 'modp18' (определён в RFC 3526). Возвращаемый объект имитирует интерфейс объектов, созданных с помощью crypto.createDiffieHellman(), но не позволит изменять ключи (например, с помощью diffieHellman.setPublicKey()). Преимущество использования этого метода заключается в том, что сторонам не нужно предварительно генерировать и обмениваться модулем группы, экономя время процессора и связи.

Пример (получение общего секрета):

const crypto = require('crypto');
const alice = crypto.getDiffieHellman('modp14');
const bob = crypto.getDiffieHellman('modp14');

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

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

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

crypto.getHashes()

Возвращает массив имён поддерживаемых алгоритмов хэширования, таких как RSA-SHA256.

Пример:

const hashes = crypto.getHashes();
console.log(hashes); // ['DSA', 'DSA-SHA', 'DSA-SHA1', ...]

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

Обеспечивает асинхронную реализацию функции вывода парольных ключей PBKDF2. Выбранный алгоритм HMAC-хеширования, заданный digest, применяется для получения ключа запрошенной длины байтов (keylen) из password, salt и iterations.

Поставленная функция callback вызывается с двумя аргументами: err и derivedKey. В случае ошибки err устанавливается, в противном случае err будет null. Полученный успешно derivedKey будет передан в виде Buffer.

Аргумент iterations должен быть числом, заданным максимально возможным значением. Чем выше число итераций, тем безопаснее полученный ключ, но тем дольше займёт вычисление.

salt также должен быть максимально уникальным. Рекомендуется, чтобы соли были случайными, а их длина составляла не менее 16 байтов. Подробнее см. NIST SP 800-132.

Пример:

const crypto = require('crypto');
crypto.pbkdf2('secret', 'salt', 100000, 512, 'sha512', (err, key) => {
  if (err) throw err;
  console.log(key.toString('hex'));  // '3745e48...aa39b34'
});

Массив поддерживаемых функций хеширования можно получить с помощью crypto.getHashes().

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

Обеспечивает синхронную реализацию функции вывода парольных ключей PBKDF2. Выбранный алгоритм HMAC-хеширования, заданный digest, применяется для получения ключа запрошенной длины байтов (keylen) из password, salt и iterations.

В случае ошибки будет выброшено исключение Error, в противном случае полученный ключ будет возвращён как Buffer.

Аргумент iterations должен быть числом, заданным максимально возможным значением. Чем выше число итераций, тем безопаснее полученный ключ, но тем дольше займёт вычисление.

salt также должен быть максимально уникальным. Рекомендуется, чтобы соли были случайными, а их длина составляла не менее 16 байтов. Подробнее см. NIST SP 800-132.

Пример:

const crypto = require('crypto');
const key = crypto.pbkdf2Sync('secret', 'salt', 100000, 512, 'sha512');
console.log(key.toString('hex'));  // '3745e48...aa39b34'

Массив поддерживаемых функций хеширования можно получить с помощью crypto.getHashes().

crypto.privateDecrypt(private_key, buffer)

Дешифрует buffer с помощью private_key.

private_key может быть объектом или строкой. Если private_key является строкой, она обрабатывается как ключ без пароля и будет использовать RSA_PKCS1_OAEP_PADDING. Если private_key является объектом, он интерпретируется как объект хэша с ключами:

• key: <строка> - закрытый ключ в формате PEM
• passphrase: <строка> - необязательный пароль для закрытого ключа
• padding: Необязательное значение заполнения, одно из следующих:
  • crypto.constants.RSA_NO_PADDING
  • crypto.constants.RSA_PKCS1_PADDING
  • crypto.constants.RSA_PKCS1_OAEP_PADDING

Все значения заполнения определены в crypto.constants.

crypto.timingSafeEqual(a, b)

Эта функция основана на алгоритме постоянного времени. Возвращает true, если a равно b, без утечки информации о времени выполнения, что позволило бы злоумышленнику угадать одно из значений. Это подходит для сравнения дайджестов HMAC или секретных значений, таких как аутентификационные куки или URL-адреса разрешений.

a и b должны быть Buffer и иметь одинаковую длину.

Примечание: Использование crypto.timingSafeEqual не гарантирует, что окружающий код является безопасным по времени. Необходимо позаботиться о том, чтобы окружающий код не вводил уязвимости, связанные с временем выполнения.

crypto.privateEncrypt(private_key, buffer)

Шифрует buffer с помощью private_key.

private_key может быть объектом или строкой. Если private_key является строкой, она обрабатывается как ключ без пароля и будет использовать RSA_PKCS1_PADDING. Если private_key является объектом, он интерпретируется как объект хэша с ключами:

• key: <строка> - закрытый ключ в формате PEM
• passphrase: <строка> - необязательный пароль для закрытого ключа
• padding: Необязательное значение заполнения, одно из следующих:
  • crypto.constants.RSA_NO_PADDING
  • crypto.constants.RSA_PKCS1_PADDING

Все значения заполнения определены в crypto.constants.

crypto.publicDecrypt(public_key, buffer)

Расшифровывает buffer с помощью public_key.

public_key может быть объектом или строкой. Если public_key является строкой, она обрабатывается как ключ без пароля и будет использовать RSA_PKCS1_PADDING. Если public_key является объектом, он интерпретируется как объект хэша с ключами:

• key: <строка> - открытый ключ в формате PEM
• passphrase: <строка> - необязательный пароль для закрытого ключа
• padding: Необязательное значение заполнения, одно из следующих:
  • crypto.constants.RSA_NO_PADDING
  • crypto.constants.RSA_PKCS1_PADDING
  • crypto.constants.RSA_PKCS1_OAEP_PADDING

Поскольку открытые ключи RSA могут быть получены из закрытых ключей, вместо открытого ключа может быть передан закрытый ключ.

Все значения заполнения определены в crypto.constants.

crypto.publicEncrypt(public_key, buffer)

Шифрует buffer с помощью public_key.

public_key может быть объектом или строкой. Если public_key является строкой, она обрабатывается как ключ без пароля и будет использовать RSA_PKCS1_OAEP_PADDING. Если public_key является объектом, он интерпретируется как объект хэша с ключами:

• key: <строка> - открытый ключ в формате PEM
• passphrase: <строка> - необязательный пароль для закрытого ключа
• padding: Необязательное значение заполнения, одно из следующих:
  • crypto.constants.RSA_NO_PADDING
  • crypto.constants.RSA_PKCS1_PADDING
  • crypto.constants.RSA_PKCS1_OAEP_PADDING

Поскольку открытые ключи RSA могут быть получены из закрытых ключей, вместо открытого ключа может быть передан закрытый ключ.

Все значения заполнения определены в crypto.constants.

crypto.randomBytes(size[, callback])

Генерирует криптографически сильные псевдослучайные данные. Аргумент size — это число, указывающее количество байтов для генерации.

Если предоставлена функция callback, байты генерируются асинхронно, и функция callback вызывается с двумя аргументами: err и buf. Если произошла ошибка, err будет объектом Error; в противном случае — null. Аргумент buf — это Buffer, содержащий сгенерированные байты.

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

Если функция callback не предоставлена, случайные байты генерируются синхронно и возвращаются как Buffer. Если при генерации произошла ошибка, будет выброшено исключение.

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

Метод crypto.randomBytes() завершается только после получения достаточного количества энтропии. Обычно это занимает несколько миллисекунд. Единственное время, когда генерация случайных байтов может заблокироваться на более длительный период, — это сразу после загрузки, когда вся система всё ещё имеет низкий уровень энтропии.

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

• buffer <Буфер> | <Uint8 массив> Обязателен.
• offset <число> По умолчанию 0.
• size <число> По умолчанию buffer.length - offset.

Синхронная версия crypto.randomFill().

Возвращает buffer

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

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

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

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

• buffer <Буфер> | <Uint8 массив> Обязателен.
• offset <число> По умолчанию 0.
• size <число> По умолчанию buffer.length - offset.
• callback <Функция> function(err, buf) {}.

Эта функция похожа на crypto.randomBytes(), но требует в качестве первого аргумента Buffer, который будет заполнен. Она также требует передачи обратного вызова.

Если функция callback не предоставлена, будет выброшено исключение.

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

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

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

crypto.setEngine(engine[, flags])

Загрузка и установка engine для некоторых или всех функций OpenSSL (выбираемых по флагам).

engine может быть идентификатором или путем к библиотеке с разделяемой загрузкой движка.

Необязательный аргумент 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_ECDH
• crypto.constants.ENGINE_METHOD_ECDSA
• crypto.constants.ENGINE_METHOD_CIPHERS
• crypto.constants.ENGINE_METHOD_DIGESTS
• crypto.constants.ENGINE_METHOD_STORE
• crypto.constants.ENGINE_METHOD_PKEY_METHS
• crypto.constants.ENGINE_METHOD_PKEY_ASN1_METHS
• crypto.constants.ENGINE_METHOD_ALL
• crypto.constants.ENGINE_METHOD_NONE

Примечания

API устаревших потоков (до Node.js v0.10)

Модуль Crypto был добавлен в Node.js до появления концепции унифицированного API потоков и до появления объектов Buffer для обработки двоичных данных. В связи с этим многие из определенных классов crypto имеют методы, которые не типичны для других классов Node.js, реализующих API потоков streams (например, update(), final(), или digest()). Кроме того, многие методы принимали и возвращали строки в кодировке 'latin1' по умолчанию вместо буферов. По умолчанию это было изменено после Node.js v0.8 на использование объектов Buffer.

Последние изменения в ECDH

Использование ECDH с парами ключей, не генерируемыми динамически, было упрощено. Теперь ecdh.setPrivateKey() может быть вызван с предварительно выбранным закрытым ключом, и связанная открытая точка (ключ) будет вычислена и сохранена в объекте. Это позволяет коду хранить и предоставлять только частную часть пары ключей EC. ecdh.setPrivateKey() теперь также проверяет, что закрытый ключ действителен для выбранной кривой.

Метод ecdh.setPublicKey() теперь устарел, так как его включение в API не имеет смысла. Следует установить предварительно сохранённый закрытый ключ, который автоматически сгенерирует соответствующий открытый ключ, или вызвать ecdh.generateKeys(). Основной недостаток использования ecdh.setPublicKey() заключается в том, что он может привести к несогласованному состоянию пары ключей ECDH.

Поддержка слабых или скомпрометированных алгоритмов

Модуль crypto всё ещё поддерживает некоторые алгоритмы, которые уже скомпрометированы и в настоящее время не рекомендуются для использования. API также позволяет использовать шифры и хэши с небольшим размером ключа, которые считаются слишком слабыми для безопасного использования.

Пользователи несут полную ответственность за выбор криптографического алгоритма и размера ключа в соответствии со своими требованиями безопасности.

В соответствии с рекомендациями NIST SP 800-131A:

• MD5 и SHA-1 больше не приемлемы там, где требуется стойкость к коллизиям, например, при цифровых подписях.
• Для безопасного использования в течение нескольких лет рекомендуется, чтобы ключ, используемый с алгоритмами RSA, DSA и DH, имел не менее 2048 бит, а ключ кривой ECDSA и ECDH — не менее 224 бит.
• Группы DH modp1, modp2 и modp5 имеют размер ключа меньше 2048 бит и не рекомендуются.

См. справку для получения других рекомендаций и подробностей.

Постоянные значения Crypto

Следующие константы, экспортируемые crypto.constants, применимы к различным использованиям модулей crypto, tls, и https и, как правило, специфичны для OpenSSL.

Параметры OpenSSL

Постоянные значения двигателя OpenSSL

Другие константы OpenSSL

Константы Node.js Crypto