JavaScript中最快的MD5实现

有很多MD5JavaScript实现。 有人知道哪一个是最先进、修复错误最多、速度最快的吗

---

我需要它作为工具。

我听说Joseph的Myers实现相当快。此外，他还对Javascript优化进行了详细介绍，描述了他在编写实现时学到的知识。对于任何对performant javascript感兴趣的人来说，这本书都是一本不错的读物

---

可以找到他的MD5实现

如果应用程序的性能受到MD5的Javascript实现的限制，那么您确实做错了什么。考虑架构更改（提示：使用MD5较少）

您也可以检查我的。它应该与上面发布的其他内容大致相同。不幸的是，性能受到内部循环的限制，无法进一步优化。

我找到了许多关于这个主题的文章。 他们都建议Joseph Meyers实施

参见：关于一些测试

在我寻求终极速度的过程中，我查看了这段代码，我发现它可以改进。因此，我基于Joseph Meyers代码创建了一个新的JS脚本

---

请参见

在这种情况下，我建议您使用CryptoJS

基本上，CryptoJS是一个使用最佳实践和模式在JavaScript中实现的越来越多的标准和安全加密算法的集合。它们速度快，并且具有一致且简单的界面

因此，如果要计算密码字符串的MD5哈希值，请执行以下操作：

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.1.9-1/core.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.1.9-1/md5.js"></script>
<script>
    var passhash = CryptoJS.MD5(password).toString();

    $.post(
      'includes/login.php', 
      { user: username, pass: passhash },
      onLogin, 
      'json' );
</script>

var passhash=CryptoJS.MD5（密码）.toString（）；
美元邮政(
'includes/login.php'，
{user:username，pass:passhash}，
昂洛金，
“json”）；

因此，此脚本将把密码字符串的哈希值发布到服务器

有关其他哈希计算算法的更多信息和支持，请访问：

---

我只需要支持支持类型化数组（DataView、ArrayBuffer等）的HTML5浏览器 我想我采用了Joseph Myers代码并对其进行了修改，以支持传入Uint8Array。我没有看到所有的改进，可能还有一些char（）数组工件可以改进。我需要这个来添加到数据库项目中

var PouchUtils = {};
PouchUtils.Crypto = {};
(function () {
    PouchUtils.Crypto.MD5 = function (uint8Array) {
        function md5cycle(x, k) {
            var a = x[0], b = x[1], c = x[2], d = x[3];

            a = ff(a, b, c, d, k[0], 7, -680876936);
            d = ff(d, a, b, c, k[1], 12, -389564586);
            c = ff(c, d, a, b, k[2], 17, 606105819);
            b = ff(b, c, d, a, k[3], 22, -1044525330);
            a = ff(a, b, c, d, k[4], 7, -176418897);
            d = ff(d, a, b, c, k[5], 12, 1200080426);
            c = ff(c, d, a, b, k[6], 17, -1473231341);
            b = ff(b, c, d, a, k[7], 22, -45705983);
            a = ff(a, b, c, d, k[8], 7, 1770035416);
            d = ff(d, a, b, c, k[9], 12, -1958414417);
            c = ff(c, d, a, b, k[10], 17, -42063);
            b = ff(b, c, d, a, k[11], 22, -1990404162);
            a = ff(a, b, c, d, k[12], 7, 1804603682);
            d = ff(d, a, b, c, k[13], 12, -40341101);
            c = ff(c, d, a, b, k[14], 17, -1502002290);
            b = ff(b, c, d, a, k[15], 22, 1236535329);

            a = gg(a, b, c, d, k[1], 5, -165796510);
            d = gg(d, a, b, c, k[6], 9, -1069501632);
            c = gg(c, d, a, b, k[11], 14, 643717713);
            b = gg(b, c, d, a, k[0], 20, -373897302);
            a = gg(a, b, c, d, k[5], 5, -701558691);
            d = gg(d, a, b, c, k[10], 9, 38016083);
            c = gg(c, d, a, b, k[15], 14, -660478335);
            b = gg(b, c, d, a, k[4], 20, -405537848);
            a = gg(a, b, c, d, k[9], 5, 568446438);
            d = gg(d, a, b, c, k[14], 9, -1019803690);
            c = gg(c, d, a, b, k[3], 14, -187363961);
            b = gg(b, c, d, a, k[8], 20, 1163531501);
            a = gg(a, b, c, d, k[13], 5, -1444681467);
            d = gg(d, a, b, c, k[2], 9, -51403784);
            c = gg(c, d, a, b, k[7], 14, 1735328473);
            b = gg(b, c, d, a, k[12], 20, -1926607734);

            a = hh(a, b, c, d, k[5], 4, -378558);
            d = hh(d, a, b, c, k[8], 11, -2022574463);
            c = hh(c, d, a, b, k[11], 16, 1839030562);
            b = hh(b, c, d, a, k[14], 23, -35309556);
            a = hh(a, b, c, d, k[1], 4, -1530992060);
            d = hh(d, a, b, c, k[4], 11, 1272893353);
            c = hh(c, d, a, b, k[7], 16, -155497632);
            b = hh(b, c, d, a, k[10], 23, -1094730640);
            a = hh(a, b, c, d, k[13], 4, 681279174);
            d = hh(d, a, b, c, k[0], 11, -358537222);
            c = hh(c, d, a, b, k[3], 16, -722521979);
            b = hh(b, c, d, a, k[6], 23, 76029189);
            a = hh(a, b, c, d, k[9], 4, -640364487);
            d = hh(d, a, b, c, k[12], 11, -421815835);
            c = hh(c, d, a, b, k[15], 16, 530742520);
            b = hh(b, c, d, a, k[2], 23, -995338651);

            a = ii(a, b, c, d, k[0], 6, -198630844);
            d = ii(d, a, b, c, k[7], 10, 1126891415);
            c = ii(c, d, a, b, k[14], 15, -1416354905);
            b = ii(b, c, d, a, k[5], 21, -57434055);
            a = ii(a, b, c, d, k[12], 6, 1700485571);
            d = ii(d, a, b, c, k[3], 10, -1894986606);
            c = ii(c, d, a, b, k[10], 15, -1051523);
            b = ii(b, c, d, a, k[1], 21, -2054922799);
            a = ii(a, b, c, d, k[8], 6, 1873313359);
            d = ii(d, a, b, c, k[15], 10, -30611744);
            c = ii(c, d, a, b, k[6], 15, -1560198380);
            b = ii(b, c, d, a, k[13], 21, 1309151649);
            a = ii(a, b, c, d, k[4], 6, -145523070);
            d = ii(d, a, b, c, k[11], 10, -1120210379);
            c = ii(c, d, a, b, k[2], 15, 718787259);
            b = ii(b, c, d, a, k[9], 21, -343485551);

            x[0] = add32(a, x[0]);
            x[1] = add32(b, x[1]);
            x[2] = add32(c, x[2]);
            x[3] = add32(d, x[3]);

        }

        function cmn(q, a, b, x, s, t) {
            a = add32(add32(a, q), add32(x, t));
            return add32((a << s) | (a >>> (32 - s)), b);
        }

        function ff(a, b, c, d, x, s, t) {
            return cmn((b & c) | ((~b) & d), a, b, x, s, t);
        }

        function gg(a, b, c, d, x, s, t) {
            return cmn((b & d) | (c & (~d)), a, b, x, s, t);
        }

        function hh(a, b, c, d, x, s, t) {
            return cmn(b ^ c ^ d, a, b, x, s, t);
        }

        function ii(a, b, c, d, x, s, t) {
            return cmn(c ^ (b | (~d)), a, b, x, s, t);
        }

        function md51(s) {
            txt = '';
            var n = s.length,
            state = [1732584193, -271733879, -1732584194, 271733878], i;
            for (i = 64; i <= s.length; i += 64) {
                md5cycle(state, md5blk(s.subarray(i - 64, i)));
            }
            s = s.subarray(i - 64);
            var tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
            for (i = 0; i < s.length; i++)
                tail[i >> 2] |= s[i] << ((i % 4) << 3);
            tail[i >> 2] |= 0x80 << ((i % 4) << 3);
            if (i > 55) {
                md5cycle(state, tail);
                for (i = 0; i < 16; i++) tail[i] = 0;
            }
            tail[14] = n * 8;
            md5cycle(state, tail);
            return state;
        }

        /* there needs to be support for Unicode here,
         * unless we pretend that we can redefine the MD-5
         * algorithm for multi-byte characters (perhaps
         * by adding every four 16-bit characters and
         * shortening the sum to 32 bits). Otherwise
         * I suggest performing MD-5 as if every character
         * was two bytes--e.g., 0040 0025 = @%--but then
         * how will an ordinary MD-5 sum be matched?
         * There is no way to standardize text to something
         * like UTF-8 before transformation; speed cost is
         * utterly prohibitive. The JavaScript standard
         * itself needs to look at this: it should start
         * providing access to strings as preformed UTF-8
         * 8-bit unsigned value arrays.
         */
        function md5blk(s) { /* I figured global was faster.   */
            var md5blks = [], i; /* Andy King said do it this way. */
            for (i = 0; i < 64; i += 4) {
                md5blks[i >> 2] = s[i]
                + (s[i + 1] << 8)
                + (s[i + 2] << 16)
                + (s[i + 3] << 24);
            }
            return md5blks;
        }

        var hex_chr = '0123456789abcdef'.split('');

        function rhex(n) {
            var s = '', j = 0;
            for (; j < 4; j++)
                s += hex_chr[(n >> (j * 8 + 4)) & 0x0F]
                + hex_chr[(n >> (j * 8)) & 0x0F];
            return s;
        }

        function hex(x) {
            for (var i = 0; i < x.length; i++)
                x[i] = rhex(x[i]);
            return x.join('');
        }

        function md5(s) {
            return hex(md51(s));
        }

        function add32(a, b) {
            return (a + b) & 0xFFFFFFFF;
        }

        return md5(uint8Array);
    };
})();

var-pockutils={}；
buckutils.Crypto={}；
（功能（）{
backutils.Crypto.MD5=函数（uint8Array）{
函数MD5循环（x，k）{
变量a=x[0]，b=x[1]，c=x[2]，d=x[3]；
a=ff（a，b，c，d，k[0]，7，-680876936）；
d=ff（d，a，b，c，k[1]，12，-389564586）；
c=ff（c，d，a，b，k[2]，17，606105819）；
b=ff（b，c，d，a，k[3]，22，-1044525330）；
a=ff（a，b，c，d，k[4]，7，-176418897）；
d=ff（d，a，b，c，k[5]，11200080426）；
c=ff（c，d，a，b，k[6]，17，-1473231341）；
b=ff（b，c，d，a，k[7]，22，-45705983）；
a=ff（a，b，c，d，k[8]，71770035416）；
d=ff（d，a，b，c，k[9]，12，-1958414417）；
c=ff（c，d，a，b，k[10]，17，-42063）；
b=ff（b，c，d，a，k[11]，22，-1990404162）；
a=ff（a，b，c，d，k[12]，71804603682）；
d=ff（d，a，b，c，k[13]，12，-40341101）；
c=ff（c，d，a，b，k[14]，17，-1502002290）；
b=ff（b，c，d，a，k[15]，221236535329）；
a=gg（a，b，c，d，k[1]，5，-165796510）；
d=gg（d，a，b，c，k[6]，9，-1069501632）；
c=gg（c，d，a，b，k[11]，14643717713）；
b=gg（b，c，d，a，k[0]，20，-373897302）；
a=gg（a，b，c，d，k[5]，5，-701558691）；
d=gg（d，a，b，c，k[10]，938016083）；
c=gg（c，d，a，b，k[15]，14，-660478335）；
b=gg（b，c，d，a，k[4]，20，-405537848）；
a=gg（a，b，c，d，k[9]，55684438）；
d=gg（d，a，b，c，k[14]，9，-1019803690）；
c=gg（c，d，a，b，k[3]，14，-187363961）；
b=gg（b，c，d，a，k[8]，20163531501）；
a=gg（a，b，c，d，k[13]，5，-1444681467）；
d=gg（d，a，b，c，k[2]，9，-51403784）；
c=gg（c，d，a，b，k[7]，141735328473）；
b=gg（b，c，d，a，k[12]，20，-1926607734）；
a=hh（a，b，c，d，k[5]，4，-378558）；
d=hh（d，a，b，c，k[8]，11，-2022574463）；
c=hh（c，d，a，b，k[11]，161839030562）；
b=hh（b，c，d，a，k[14]，23，-35309556）；
a=hh（a，b，c，d，k[1]，4，-1530992060）；
d=hh（d，a，b，c，k[4]，11272893353）；
c=hh（c，d，a，b，k[7]，16，-155497632）；
b=hh（b，c，d，a，k[10]，23，-1094730640）；
a=hh（a，b，c，d，k[13]，4681279174）；
d=hh（d，a，b，c，k[0]，11，-358537222）；
c=hh（c，d，a，b，k[3]，16，-722521979）；
b=hh（b，c，d，a，k[6]，2376029189）；
a=hh（a，b，c，d，k[9]，4，-640364487）；
d=hh（d，a，b，c，k[12]，11，-421815835）；
c=hh（c，d，a，b，k[15]，16530742520）；
b=hh（b，c，d，a，k[2]，23，-995338651）；
a=ii（a，b，c，d，k[0]，6，-198630844）；
d=ii（d，a，b，c，k[7]，101126891415）；
c=ii（c，d，a，b，k[14]，15，-1416354905）；
b=ii（b，c，d，a，k[5]，21，-57434055）；
a=ii（a，b，c，d，k[12]，61700485571）；
d=ii（d，a，b，c，k[3]，10，-1894986606）；
c=ii（c，d，a，b，k[10]，15，-1051523）；
b=ii（b，c，d，a，k[1]，21，-2054922799）；
a=ii（a，b，c，d，k[8]，61873359）；
d=ii（d，a，b，c，k[15]，10，-30611744）；
c=ii（c，d，a，b，k[6]，15，-1560198380）；
b=ii（b，c，d，a，k[13]，211309151649）；
a=ii（a，b，c，d，k[4]，6，-145523070）；
d=ii（d，a，b，c，k[11]，10，-1120210379）；
c=ii（c，d，a，b，k[2]，157187259）；
b=ii（b，c，d，a，k[9]，21，-3485551）；
x[0]=add32（a，x[0]）；
x[1]=add32（b，
//just include md5.js from the CryptoJS rollups folder
var hash = CryptoJS.MD5("Message");
console.log(hash.toString()); 

const crypto = require('crypto')
crypto.createHash('md5').update('hello world').digest('hex')

npm i hash-wasm

<script src="https://cdn.jsdelivr.net/npm/hash-wasm"></script>

async function run() {
  console.log('MD5:', await hashwasm.md5('The quick brown fox jumps over the lazy dog'));
}

run();

MD5: 9e107d9d372bb6826bd81d3542a419d6