Ответ 1

Взгляните на crypto.createHash(алгоритм)

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

var md5sum = crypto.createHash('md5');

var s = fs.ReadStream(filename);
s.on('data', function(d) {
  md5sum.update(d);
});

s.on('end', function() {
  var d = md5sum.digest('hex');
  console.log(d + '  ' + filename);
});

Ответ 2

Если вы просто хотите, чтобы md5 хешировал простую строку, я нашел, что это работает для меня.

var crypto = require('crypto');
var name = 'braitsch';
var hash = crypto.createHash('md5').update(name).digest('hex');
console.log(hash); // 9b74c9897bac770ffc029102a200c5de

Ответ 3

Node API-интерфейс криптографического модуля по-прежнему нестабилен.

Начиная с версии 4.0.0, собственный Crypto-модуль уже нестабилен. Из официальной документации :

Crypto

Стабильность: 2 - Стабильный

API оказался удовлетворительным. Совместимость с экосистемой npm является высокоприоритетным и не будет нарушен, если это абсолютно необходимо.

Таким образом, следует считать безопасным использование собственной реализации без внешних зависимостей.

Для справки, упомянутые ниже модули были предложены в качестве альтернативных решений, когда модуль Crypto все еще нестабилен.

Вы также можете использовать один из модулей sha1 или md5, которые оба делают работа.

$ npm install sha1

а затем

var sha1 = require('sha1');

var hash = sha1("my message");

console.log(hash); // 104ab42f1193c336aa2cf08a2c946d5c6fd0fcdb

или

$ npm install md5

а затем

var md5 = require('md5');

var hash = md5("my message");

console.log(hash); // 8ba6c19dc1def5702ff5acbf2aeea5aa

(MD5 небезопасен, но часто используется такими услугами, как Gravatar.)

API этих модулей не изменится!

Ответ 4

sha256("string or binary");

У меня возникла проблема с другим ответом. Я советую вам установить аргумент кодирования равным binary, чтобы использовать строку байтов и предотвратить разный хэш между Javascript (NodeJS) и другими языками/сервисами, такими как Python, PHP, Github...

Если вы не используете этот код, вы можете получить другой хеш между NodeJS и Python...

Как получить тот же хеш, что и Python, PHP, Perl, Github (и предотвратить проблему):

NodeJS хэширует UTF-8 представление строки. Другие языки (например, Python, PHP или PERL...) хэшируют строку байта.

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

Код:

const crypto = require("crypto");

function sha256(data) {
    return crypto.createHash("sha256").update(data, "binary").digest("base64");
    //                                               ------  binary: hash the byte string
}

sha256("string or binary");

Документация:

• crypto.createHash(gorithm [, options]): Алгоритм зависит от доступных алгоритмов, поддерживаемых версией OpenSSL на платформе.
• hash.digest([encoding]): Кодировка может быть 'hex', 'latin1' или 'base64'. (база 64 менее длинная).

Вы можете получить проблему с помощью: sha256 ("\ xac"), "\ xd1", "\ xb9", "\ xe2", "\ xbb", "\ x93" и т.д.

• Другие языки (например, PHP, Python, Perl...) и мое решение с .update(data, "binary"):

  sha1("\xac") //39527c59247a39d18ad48b9947ea738396a3bc47
  

• Nodejs по умолчанию (без двоичного кода):

  sha1("\xac") //f50eb35d94f1d75480496e54f4b4a472a9148752
  

Ответ 5

Модуль crypto делает это очень просто.

Настройка:

const crypto = require('crypto');

const sha256 = x => crypto.createHash('sha256').update(x, 'utf8').digest('hex');

Использование:

sha256('Hello, world. ');

Ответ 6

Здесь вы можете проверить все поддерживаемые хэши на вашем оборудовании, поддерживаемые вашей версией node.js. Некоторые из них являются криптографическими, а некоторые - только для контрольной суммы. Его вычисление "Hello World" 1 миллион раз для каждого алгоритма. Для каждого алгоритма может потребоваться около 1-15 секунд (проверено на стандартном Google Computing Engine с node.js 4.2.2).

for(var i1=0;i1<crypto.getHashes().length;i1++){
  var Algh=crypto.getHashes()[i1];
  console.time(Algh);
  for(var i2=0;i2<1000000;i2++){
    crypto.createHash(Algh).update("Hello World").digest("hex");
  }
  console.timeEnd(Algh);  
}

Результат:
DSA: 1992ms
DSA-SHA: 1960 мс
DSA-SHA1: 2062ms
DSA-SHA1-old: 2124ms
RSA-MD4: 1893ms
RSA-MD5: 1982ms
RSA-MDC2: 2797ms
RSA-RIPEMD160: 2101ms
RSA-SHA: 1948мс
RSA-SHA1:1908ms
RSA-SHA1-2: 2042ms
RSA-SHA224: 2176ms
RSA-SHA256: 2158ms
RSA-SHA384: 2290ms
RSA-SHA512: 2357ms
dsaEncryption: 1936ms
dsaWithSHA: 1910ms
dsaWithSHA1:1926ms
dss1:1928ms
ecdsa-with-SHA1:1880ms
md4: 1833ms
md4WithRSAEncryption: 1925ms
md5: 1863ms
md5WithRSAEncryption: 1923ms
mdc2: 2729ms
mdc2WithRSA: 2890ms
ripemd: 2101ms
ripemd160: 2153ms
ripemd160WithRSA: 2210ms
rmd160: 2146ms
sha: 1929ms
sha1:1880ms
sha1WithRSAEncryption: 1957ms
sha224: 2121ms
sha224WithRSAEncryption: 2290ms
sha256: 2134ms
sha256WithRSAEncryption: 2190ms
sha384: 2181ms
sha384WithRSAEncryption: 2343ms
sha512: 2371ms
sha512WithRSAEncryption: 2434ms
shaWithRSAEncryption: 1966ms
ssl2-md5: 1853ms
ssl3-md5: 1868ms
ssl3-sha1:1971ms
водоворот: 2578мс

Ответ 7

Учитывая мысли из http://www.thoughtcrime.org/blog/the-cryptographic-doom-principle/ (короче: FIRST encrypt, THEN authenticate. После этого FIRST проверяет, THEN расшифровывает) Я выполнил следующее решение в node.js:

function encrypt(text,password){
  var cipher = crypto.createCipher(algorithm,password)
  var crypted = cipher.update(text,'utf8','hex')
  crypted += cipher.final('hex');
  return crypted;
}

function decrypt(text,password){
  var decipher = crypto.createDecipher(algorithm,password)
  var dec = decipher.update(text,'hex','utf8')
  dec += decipher.final('utf8');
  return dec;
}

function hashText(text){
    var hash = crypto.createHash('md5').update(text).digest("hex");
    //console.log(hash); 
    return hash;
}

function encryptThenAuthenticate(plainText,pw)
{
    var encryptedText = encrypt(plainText,pw);
    var hash = hashText(encryptedText);
    return encryptedText+"$"+hash;
}
function VerifyThenDecrypt(encryptedAndAuthenticatedText,pw)
{
    var encryptedAndHashArray = encryptedAndAuthenticatedText.split("$");
    var encrypted = encryptedAndHashArray[0];
    var hash = encryptedAndHashArray[1];
    var hash2Compare = hashText(encrypted);
    if (hash === hash2Compare)
    {
        return decrypt(encrypted,pw); 
    }
}

Он может быть протестирован с помощью:

var doom = encryptThenAuthenticate("The encrypted text",user.cryptoPassword);
console.log(VerifyThenDecrypt(doom,user.cryptoPassword));

Надеюсь, что это поможет: -)

Ответ 8

Я использую blueimp-md5, который "Совместим с такими серверными средами, как Node.js, загрузчики модулей, такие как RequireJS, Browserify или веб-пакет и все веб-браузеры."

Используйте его следующим образом:

var md5 = require("blueimp-md5");

var myHashedString = createHash('GreensterRox');

createHash(myString){
    return md5(myString);
}

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

createHash(myString){
    var salt = 'HnasBzbxH9';
    return md5(myString+salt);
}

Ответ 9

Даже если хеш не для безопасности, вы можете использовать sha вместо md5. На мой взгляд, люди должны забыть о md5 на данный момент, это в прошлом!

Нормальный nodejs sha256 устарел. Итак, у вас есть две альтернативы:

var shajs = require('sha.js')  - https://www.npmjs.com/package/sha.js (used by Browserify)

var hash = require('hash.js')  - https://github.com/indutny/hash.js

Я предпочитаю использовать shajs вместо hash, потому что я считаю sha лучшей хэш-функцией в настоящее время, и вам пока не нужна другая хеш-функция. Таким образом, чтобы получить хеш в шестнадцатеричном виде, вы должны сделать что-то вроде следующего:

sha256.update('hello').digest('hex')

Ответ 10

Если вы хотите использовать текстовый хеш UTF8:

const crypto = require('crypto');

const hash = crypto.createHash('sha256').update('Hash this text', 'utf8').digest('hex');

Если вы хотите получить тот же хеш с Python, PHP, Perl, Github

const crypto = require('crypto');

const hash = crypto.createHash('sha256').update('Hash this text', 'binary').digest('hex');

Вы также можете использовать заменить 'sha256' на 'sha1', 'md5', 'sha256', 'sha512'