Ich habe eine Zeichenfolge, die ich hashen möchte. Was ist der einfachste Weg, um den Hash in node.js zu generieren?

Der Hash dient der Versionierung, nicht der Sicherheit.

Schauen Sie sich crypto.createHash (Algorithmus) an.

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);
});

Wenn Sie nur einen einfachen String mit md5 hashen möchten, hat dies für mich funktioniert.

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

Die Kryptomodul-API des Knotens ist immer noch instabil.

Ab Version 4.0.0 ist das native Crypto-Modul nicht mehr instabil. Aus der offiziellen Dokumentation :

Krypto

Stabilität: 2 - Stabil

Die API hat sich als zufriedenstellend erwiesen. Die Kompatibilität mit dem npm-Ökosystem hat hohe Priorität und wird nur dann unterbrochen, wenn dies unbedingt erforderlich ist.

Daher sollte es als sicher angesehen werden, die native Implementierung ohne externe Abhängigkeiten zu verwenden.

Als Referenz wurden die unten genannten Module als alternative Lösungen vorgeschlagen, als das Crypto-Modul noch instabil war.

Sie können auch eines der Module sha1 oder md5 verwenden, die beide die Aufgabe übernehmen.

$ npm install sha1

und dann

var sha1 = require('sha1');

var hash = sha1("my message");

console.log(hash); // 104ab42f1193c336aa2cf08a2c946d5c6fd0fcdb

oder

$ npm install md5

und dann

var md5 = require('md5');

var hash = md5("my message");

console.log(hash); // 8ba6c19dc1def5702ff5acbf2aeea5aa

(MD5 ist unsicher, wird aber häufig von Diensten wie Gravatar verwendet.)

Die API dieser Module wird sich nicht ändern!

sha256("string or binary");

Ich hatte Probleme mit anderen Antworten. Ich rate Ihnen, ein Codierungsargument binaryfestzulegen, um die Byte-Zeichenfolge zu verwenden und unterschiedliche Hashs zwischen Javascript (NodeJS) und anderen Sprachen / Diensten wie Python, PHP, Github ... zu verhindern.

Wenn Sie diesen Code nicht verwenden, können Sie einen anderen Hash zwischen NodeJS und Python erhalten ...

So erhalten Sie denselben Hash wie Python, PHP, Perl, Github (und verhindern ein Problem):

NodeJS hasht die UTF-8-Darstellung des Strings. Andere Sprachen (wie Python, PHP oder PERL ...) haben die Byte-Zeichenfolge gehasht.

Wir können ein binäres Argument hinzufügen , um die Byte-Zeichenfolge zu verwenden.

Code:

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");

Dokumentation:

• crypto.createHash (Algorithmus [, Optionen]): Der Algorithmus hängt von den verfügbaren Algorithmen ab, die von der OpenSSL-Version auf der Plattform unterstützt werden.
• hash.digest ([Kodierung]): Die Kodierung kann 'hex', 'latin1' oder 'base64' sein. (Basis 64 ist weniger länger).

Sie können das Problem erhalten mit: sha256 ("\ xac"), "\ xd1", "\ xb9", "\ xe2", "\ xbb", "\ x93" usw.

• Andere Sprachen (wie PHP, Python, Perl ...) und meine Lösung mit .update(data, "binary"):

  sha1("\xac") //39527c59247a39d18ad48b9947ea738396a3bc47

• Nodejs standardmäßig (ohne Binärdatei):

  sha1("\xac") //f50eb35d94f1d75480496e54f4b4a472a9148752

Das cryptoModul macht dies sehr einfach.

Installieren:

// import crypto from 'crypto';
const crypto = require('crypto');

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

Verwendungszweck:

sha256('Hello, world. ');

Hier können Sie alle unterstützten Hashes auf Ihrer Hardware vergleichen, die von Ihrer Version von node.js unterstützt werden. Einige sind kryptografisch, andere dienen nur einer Prüfsumme. Es berechnet "Hello World" 1 Million Mal für jeden Algorithmus. Es kann ungefähr 1-15 Sekunden für jeden Algorithmus dauern (getestet auf der Standard Google Computing Engine mit 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);  
}

Ergebnis:
DSA: 1992 ms
DSA-SHA: 1960 ms
DSA-SHA1: 2062 ms
DSA-SHA1-alt: 2124 ms
RSA-MD4: 1893 ms
RSA-MD5: 1982 ms
RSA-MDC2: 2797 ms
RSA-RIPEMD160: 2101 ms
RSA-SHA: 1948 ms
RSA-SHA1 : 1908 ms
RSA-SHA1-2: 2042 ms
RSA-SHA224: 2176 ms
RSA-SHA256: 2158 ms
RSA-SHA384: 2290 ms
RSA-SHA512: 2357
ms
dsaEncryption: 1936
ms
dsaWithSHA: 1910
ms dsaWithSHA1: 1926 ms
dss1: 1833
ms md4WithRSAEncryption
: 1925 ms md5: 1863
ms
md5WithRSAEncryption: 1923
ms mdc2: 2729 ms mdc2WithRSA: 2890 ms
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: 1853 ms
ssl3-md5: 1868
ms ssl3-sha1: 1971 ms
Whirlpool: 2578 ms

Einfache Einzeiler:

Wenn Sie UTF8-Text-Hash möchten:

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

Wenn Sie den gleichen Hash mit Python, PHP, Perl, Github erhalten möchten:

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

Sie können auch ersetzen 'sha256'mit 'sha1', 'md5', 'sha256','sha512'

In Anbetracht der Gedanken von http://www.thoughtcrime.org/blog/the-cryptographic-doom-principle/ (kurz: ERSTE Verschlüsselung, DANN Authentifizierung. Danach ERSTE Überprüfung, DANN Entschlüsselung) habe ich die folgende Lösung in Node implementiert. 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); 
    }
}

Es kann getestet werden mit:

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

Hoffe das hilft :-)

Ich benutze blueimp-md5 das "kompatibel mit serverseitigen Umgebungen wie Node.js, Modulladern wie RequireJS, Browserify oder Webpack und allen Webbrowsern" ist.

Verwenden Sie es so:

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

var myHashedString = createHash('GreensterRox');

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

Wenn Sie Hash-Werte offen weitergeben, ist es immer eine gute Idee, sie zu salzen, damit es für die Menschen schwieriger ist, sie neu zu erstellen:

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

function md5(a) {
    var r = 0,
        c = "";
    return h(a);

    function h(t) {
        return u(l(m(t)))
    }

    function l(t) {
        return p(g(f(t), 8 * t.length))
    }

    function u(t) {
        for (var e, i = r ? "0123456789ABCDEF" : "0123456789abcdef", n = "", o = 0; o < t.length; o++)
            e = t.charCodeAt(o),
            n += i.charAt(e >>> 4 & 15) + i.charAt(15 & e);
        return n
    }

    function m(t) {
        for (var e, i, n = "", o = -1; ++o < t.length;)
            e = t.charCodeAt(o),
            i = o + 1 < t.length ? t.charCodeAt(o + 1) : 0,
            55296 <= e && e <= 56319 && 56320 <= i && i <= 57343 && (e = 65536 + ((1023 & e) << 10) + (1023 & i),
                o++),
            e <= 127 ? n += String.fromCharCode(e) : e <= 2047 ? n += String.fromCharCode(192 | e >>> 6 & 31, 128 | 63 & e) : e <= 65535 ? n += String.fromCharCode(224 | e >>> 12 & 15, 128 | e >>> 6 & 63, 128 | 63 & e) : e <= 2097151 && (n += String.fromCharCode(240 | e >>> 18 & 7, 128 | e >>> 12 & 63, 128 | e >>> 6 & 63, 128 | 63 & e));
        return n
    }

    function f(t) {
        for (var e = Array(t.length >> 2), i = 0; i < e.length; i++)
            e[i] = 0;
        for (i = 0; i < 8 * t.length; i += 8)
            e[i >> 5] |= (255 & t.charCodeAt(i / 8)) << i % 32;
        return e
    }

    function p(t) {
        for (var e = "", i = 0; i < 32 * t.length; i += 8)
            e += String.fromCharCode(t[i >> 5] >>> i % 32 & 255);
        return e
    }

    function g(t, e) {
        t[e >> 5] |= 128 << e % 32,
            t[14 + (e + 64 >>> 9 << 4)] = e;
        for (var i = 1732584193, n = -271733879, o = -1732584194, s = 271733878, a = 0; a < t.length; a += 16) {
            var r = i,
                c = n,
                h = o,
                l = s;
            n = E(n = E(n = E(n = E(n = N(n = N(n = N(n = N(n = C(n = C(n = C(n = C(n = S(n = S(n = S(n = S(n, o = S(o, s = S(s, i = S(i, n, o, s, t[a + 0], 7, -680876936), n, o, t[a + 1], 12, -389564586), i, n, t[a + 2], 17, 606105819), s, i, t[a + 3], 22, -1044525330), o = S(o, s = S(s, i = S(i, n, o, s, t[a + 4], 7, -176418897), n, o, t[a + 5], 12, 1200080426), i, n, t[a + 6], 17, -1473231341), s, i, t[a + 7], 22, -45705983), o = S(o, s = S(s, i = S(i, n, o, s, t[a + 8], 7, 1770035416), n, o, t[a + 9], 12, -1958414417), i, n, t[a + 10], 17, -42063), s, i, t[a + 11], 22, -1990404162), o = S(o, s = S(s, i = S(i, n, o, s, t[a + 12], 7, 1804603682), n, o, t[a + 13], 12, -40341101), i, n, t[a + 14], 17, -1502002290), s, i, t[a + 15], 22, 1236535329), o = C(o, s = C(s, i = C(i, n, o, s, t[a + 1], 5, -165796510), n, o, t[a + 6], 9, -1069501632), i, n, t[a + 11], 14, 643717713), s, i, t[a + 0], 20, -373897302), o = C(o, s = C(s, i = C(i, n, o, s, t[a + 5], 5, -701558691), n, o, t[a + 10], 9, 38016083), i, n, t[a + 15], 14, -660478335), s, i, t[a + 4], 20, -405537848), o = C(o, s = C(s, i = C(i, n, o, s, t[a + 9], 5, 568446438), n, o, t[a + 14], 9, -1019803690), i, n, t[a + 3], 14, -187363961), s, i, t[a + 8], 20, 1163531501), o = C(o, s = C(s, i = C(i, n, o, s, t[a + 13], 5, -1444681467), n, o, t[a + 2], 9, -51403784), i, n, t[a + 7], 14, 1735328473), s, i, t[a + 12], 20, -1926607734), o = N(o, s = N(s, i = N(i, n, o, s, t[a + 5], 4, -378558), n, o, t[a + 8], 11, -2022574463), i, n, t[a + 11], 16, 1839030562), s, i, t[a + 14], 23, -35309556), o = N(o, s = N(s, i = N(i, n, o, s, t[a + 1], 4, -1530992060), n, o, t[a + 4], 11, 1272893353), i, n, t[a + 7], 16, -155497632), s, i, t[a + 10], 23, -1094730640), o = N(o, s = N(s, i = N(i, n, o, s, t[a + 13], 4, 681279174), n, o, t[a + 0], 11, -358537222), i, n, t[a + 3], 16, -722521979), s, i, t[a + 6], 23, 76029189), o = N(o, s = N(s, i = N(i, n, o, s, t[a + 9], 4, -640364487), n, o, t[a + 12], 11, -421815835), i, n, t[a + 15], 16, 530742520), s, i, t[a + 2], 23, -995338651), o = E(o, s = E(s, i = E(i, n, o, s, t[a + 0], 6, -198630844), n, o, t[a + 7], 10, 1126891415), i, n, t[a + 14], 15, -1416354905), s, i, t[a + 5], 21, -57434055), o = E(o, s = E(s, i = E(i, n, o, s, t[a + 12], 6, 1700485571), n, o, t[a + 3], 10, -1894986606), i, n, t[a + 10], 15, -1051523), s, i, t[a + 1], 21, -2054922799), o = E(o, s = E(s, i = E(i, n, o, s, t[a + 8], 6, 1873313359), n, o, t[a + 15], 10, -30611744), i, n, t[a + 6], 15, -1560198380), s, i, t[a + 13], 21, 1309151649), o = E(o, s = E(s, i = E(i, n, o, s, t[a + 4], 6, -145523070), n, o, t[a + 11], 10, -1120210379), i, n, t[a + 2], 15, 718787259), s, i, t[a + 9], 21, -343485551),
                i = v(i, r),
                n = v(n, c),
                o = v(o, h),
                s = v(s, l)
        }
        return [i, n, o, s]
    }

    function _(t, e, i, n, o, s) {
        return v((a = v(v(e, t), v(n, s))) << (r = o) | a >>> 32 - r, i);
        var a, r
    }

    function S(t, e, i, n, o, s, a) {
        return _(e & i | ~e & n, t, e, o, s, a)
    }

    function C(t, e, i, n, o, s, a) {
        return _(e & n | i & ~n, t, e, o, s, a)
    }

    function N(t, e, i, n, o, s, a) {
        return _(e ^ i ^ n, t, e, o, s, a)
    }

    function E(t, e, i, n, o, s, a) {
        return _(i ^ (e | ~n), t, e, o, s, a)
    }

    function v(t, e) {
        var i = (65535 & t) + (65535 & e);
        return (t >> 16) + (e >> 16) + (i >> 16) << 16 | 65535 & i
    }
}
string = 'hello';
console.log(md5(string));

Auch wenn der Hash nicht der Sicherheit dient, können Sie sha anstelle von md5 verwenden. Meiner Meinung nach sollten die Leute md5 vorerst vergessen, es ist in der Vergangenheit!

Der normale Knoten js sha256 ist veraltet. Sie haben also vorerst zwei Alternativen:

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

Ich bevorzuge die Verwendung shajsanstelle von hash, weil ich sha heutzutage für die beste Hash-Funktion halte und Sie vorerst keine andere Hash-Funktion benötigen. Um also etwas Hash in Hex zu bekommen, sollten Sie Folgendes tun:

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