node.js哈希字符串？

Answers:

224

看看crypto.createHash（algorithm）

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);
});
— 德里克
source
s.on（）函数在做什么？是否在每次从ReadStream中读取数据时注册md5sum.update（d）函数以执行？
— DucRP
@YoniDor您尝试过fs.readsync吗？-消解在一个典型的while循环，那么可以肯定，它的工作...➝ stackoverflow.com/a/21219407/444255
— 弗兰克Nocke
8
OP希望对字符串而不是文件进行哈希处理。
— blimpse
698

如果您只想对md5哈希一个简单的字符串，我发现这对我有用。

var crypto = require('crypto');
var name = 'braitsch';
var hash = crypto.createHash('md5').update(name).digest('hex');
console.log(hash); // 9b74c9897bac770ffc029102a200c5de
— 布赖特施
source
181
哇，如果你愿意的话，你会require('crypto').createHash('md5').update(STRING_TO_BE_HASHED).digest("hex")得到一线。队友的欢呼声！
— balupton
3
尝试使用的解决方案时，.update多次使用（github.com/joyent/node/issues/749）遇到了一些问题，使用了单线timbooo修复（因为每次都会重新创建哈希对象）。
— 2013年
有什么办法改变字符串的长度吗？不仅32个字符，64或128个字符或其他数字。
— Mikel
@Mikel尝试是否还有其他适合您需要的哈希算法，md5始终为32个字符。
— 领带
如果我有很多要哈希的字符串，那么继续调用crypto.createHash而不是以某种方式重新使用结果会降低效率？
— 迈克尔
81

Node的加密模块API仍然不稳定。

从4.0.0版开始，本地Crypto模块不再不稳定。从官方文档中：

加密货币

稳定性：2-稳定

该API已证明令人满意。与npm生态系统的兼容性是当务之急，除非绝对必要，否则不会破坏兼容性。

因此，在没有外部依赖的情况下使用本机实现应该被认为是安全的。

作为参考，当加密模块仍然不稳定时，下面提到的模块被建议作为替代解决方案。

您也可以使用均可完成此任务的模块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不会改变！

— vor
source
9
我认为使用Crypto而不是引入一个全新的模块要容易得多，效率更高。
— Valjas 2013年
6
来自当前的Node.js文档：“稳定性：2-不稳定；正在讨论将来版本的API更改。将最大程度地减少重大更改。” 我模块的API不会更改。当我最初编写模块时，平台中没有 crypto内置模块。另一个优点是您可以在服务器以及客户端上使用我的模块。但是，使用哪种库完全取决于您。
— pvorb
7
加密散列的构建不断给我“哈希更新失败” BS。最终，我转到了MD5模块，它工作得很好。也更容易调用（略）。谢谢。
— 2013年
2
+1表示选项远离（2）-Crypto API的不稳定特性！
— Geek Stocks 2013年
1
通过交换此模块的标准加密使用，我已经在Windows计算机上的节点0.11.x上解决了一个奇怪的sha1问题。
— Bartvds 2014年
24 
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（algorithm [，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
— A-312
source
15

该crypto模块使此操作非常容易。

设定： 

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

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

用法： 

sha256('Hello, world. ');
— sdgfsdh
source
10

在这里，您可以对您的硬件上所有受支持的哈希进行基准测试，并由您的node.js版本支持。有些是加密的，有些仅用于校验和。它为每种算法计算“ Hello World”一百万次。每种算法可能需要1到15秒左右的时间（在带有Node.js 4.2.2的标准Google计算引擎上测试）。

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：1960ms
DSA-SHA1：2062ms
DSA-SHA1-old：2124ms
RSA-MD4：1893ms
RSA-MD5：1982ms
RSA-MDC2：2797ms
RSA-RIPEMD160：2101ms
RSA-SHA：1948ms
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-与-SHA1：1880ms
MD4： 1833ms
md4WithRSA 加密：1925ms
md5：1863ms md5WithRSA
加密：1923ms
mdc2：2729ms
mdc2WithRSA：2890ms
maturemd：2101ms
熟的md160：2153ms 熟的md160有
RSA：2210ms
rmd160：2146ms
sha：1929ms
sha1：1880ms sha1WithRSA
加密：1957ms
sha224：2121ms
sha224WithRSA加密：2290ms
sha256：2134ms
sha256WithRSA
加密：2190ms
sha3842：2181ms
sha384With371：
512ms：
ShamsWith384：
512 md5：1853ms
ssl3-md5：1868ms
ssl3-sha1：1971ms
漩涡：2578ms

— 用户名
source
1
什么的RSA-前缀呢？
— balupton
7

简单的一线：

如果要使用UTF8文本哈希：

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

如果要使用Python，PHP，Perl，Github获得相同的哈希值：

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

您也可以替换'sha256'使用'sha1'，'md5'，'sha256'，'sha512'

— 鸡
source
1

考虑到http://www.thoughtcrime.org/blog/the-cryptographic-doom-principle/的想法 （总之：先加密，然后进行身份验证。先进行验证，然后解密），我在节点中实现了以下解决方案。 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));

希望这可以帮助 ：-）

— 巴托马乌斯
source
1

我使用blueimp-md5，它“与Node.js之类的服务器端环境，RequireJS，Browserify或webpack之类的模块加载器以及所有Web浏览器兼容。”

像这样使用它：

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

var myHashedString = createHash('GreensterRox');

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

如果在公开场合传递散列值，将它们加盐总是一个好主意，这样人们很难重新创建它们：

createHash(myString){
    var salt = 'HnasBzbxH9';
    return md5(myString+salt);
}
— 格林斯特·罗克斯
source
1 
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));
— hap
source
-1

即使哈希不是出于安全考虑，您也可以使用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')
— 黑手党
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.