Editing md5-typed-array

This edit will create a new revision.

Your details (optional)

Name

Email (won’t be displayed; might be used for Gravatar)

URL

Test case details

Title *

Published (uncheck if you want to fiddle around before making the page public)

Description (in case you feel further explanation is needed)(Markdown syntax is allowed)

Are you a spammer? (just answer the question)

Preparation code

Preparation code HTML (this will be inserted in the <body> of a valid HTML5 document in standards mode) (useful when testing DOM operations or including libraries)

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

/* 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.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(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));
}

/* this function is much faster,
so if possible we use it. Some IEs
are the only ones I know of that
need the idiotic second function,
generated by an if clause.  */

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

if (md5('hello') != '5d41402abc4b2a76b9719d911017c592')
{
  function add32(x, y)
  {
    var lsw = (x & 0xFFFF) + (y & 0xFFFF),
      msw = (x >> 16) + (y >> 16) + (lsw >> 16);
    return (msw << 16) | (lsw & 0xFFFF);
  }
}
return md5;
});

( // Module boilerplate to support browser globals, node.js and AMD.
  (typeof module !== "undefined" && function (m) { module.exports = m(); }) ||
  (typeof define === "function" && function (m) { define("md5", m); }) ||
  (function (m) { window.md5 = m(); })
)(function () {
  "use strict";

// based on Alexander Peslyak's public domain MD5 C code
  // http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5

// The MD5 transformation for all four rounds.
  function common(a, b, m, k, s, f) {
    a += f + m + k;
    return ((a << s) | (a >>> (32 - s))) + b;
  }

// The basic MD5 functions.
  // F and G are optimized from to their RFC 1321 definitions to use XOR.
  function F(a, b, c, d, m, k, s) { return common(a, b, m, k, s, d ^ (b & (c ^ d))); }
  function G(a, b, c, d, m, k, s) { return common(a, b, m, k, s, c ^ (d & (b ^ c))); }
  function H(a, b, c, d, m, k, s) { return common(a, b, m, k, s, b ^ c ^ d); }
  function I(a, b, c, d, m, k, s) { return common(a, b, m, k, s, c ^ (b | ~d)); }

function cycle(state, block) {
    var a = state[0],
        b = state[1],
        c = state[2],
        d = state[3];

a = F(a, b, c, d, block[0],  0xd76aa478, 7);
      d = F(d, a, b, c, block[1],  0xe8c7b756, 12);
      c = F(c, d, a, b, block[2],  0x242070db, 17);
      b = F(b, c, d, a, block[3],  0xc1bdceee, 22);
      a = F(a, b, c, d, block[4],  0xf57c0faf, 7);
      d = F(d, a, b, c, block[5],  0x4787c62a, 12);
      c = F(c, d, a, b, block[6],  0xa8304613, 17);
      b = F(b, c, d, a, block[7],  0xfd469501, 22);
      a = F(a, b, c, d, block[8],  0x698098d8, 7);
      d = F(d, a, b, c, block[9],  0x8b44f7af, 12);
      c = F(c, d, a, b, block[10], 0xffff5bb1, 17);
      b = F(b, c, d, a, block[11], 0x895cd7be, 22);
      a = F(a, b, c, d, block[12], 0x6b901122, 7);
      d = F(d, a, b, c, block[13], 0xfd987193, 12);
      c = F(c, d, a, b, block[14], 0xa679438e, 17);
      b = F(b, c, d, a, block[15], 0x49b40821, 22);

a = G(a, b, c, d, block[1],  0xf61e2562, 5);
      d = G(d, a, b, c, block[6],  0xc040b340, 9);
      c = G(c, d, a, b, block[11], 0x265e5a51, 14);
      b = G(b, c, d, a, block[0],  0xe9b6c7aa, 20);
      a = G(a, b, c, d, block[5],  0xd62f105d, 5);
      d = G(d, a, b, c, block[10], 0x02441453, 9);
      c = G(c, d, a, b, block[15], 0xd8a1e681, 14);
      b = G(b, c, d, a, block[4],  0xe7d3fbc8, 20);
      a = G(a, b, c, d, block[9],  0x21e1cde6, 5);
      d = G(d, a, b, c, block[14], 0xc33707d6, 9);
      c = G(c, d, a, b, block[3],  0xf4d50d87, 14);
      b = G(b, c, d, a, block[8],  0x455a14ed, 20);
      a = G(a, b, c, d, block[13], 0xa9e3e905, 5);
      d = G(d, a, b, c, block[2],  0xfcefa3f8, 9);
      c = G(c, d, a, b, block[7],  0x676f02d9, 14);
      b = G(b, c, d, a, block[12], 0x8d2a4c8a, 20);

a = H(a, b, c, d, block[5],  0xfffa3942, 4);
      d = H(d, a, b, c, block[8],  0x8771f681, 11);
      c = H(c, d, a, b, block[11], 0x6d9d6122, 16);
      b = H(b, c, d, a, block[14], 0xfde5380c, 23);
      a = H(a, b, c, d, block[1],  0xa4beea44, 4);
      d = H(d, a, b, c, block[4],  0x4bdecfa9, 11);
      c = H(c, d, a, b, block[7],  0xf6bb4b60, 16);
      b = H(b, c, d, a, block[10], 0xbebfbc70, 23);
      a = H(a, b, c, d, block[13], 0x289b7ec6, 4);
      d = H(d, a, b, c, block[0],  0xeaa127fa, 11);
      c = H(c, d, a, b, block[3],  0xd4ef3085, 16);
      b = H(b, c, d, a, block[6],  0x04881d05, 23);
      a = H(a, b, c, d, block[9],  0xd9d4d039, 4);
      d = H(d, a, b, c, block[12], 0xe6db99e5, 11);
      c = H(c, d, a, b, block[15], 0x1fa27cf8, 16);
      b = H(b, c, d, a, block[2],  0xc4ac5665, 23);

a = I(a, b, c, d, block[0],  0xf4292244, 6);
      d = I(d, a, b, c, block[7],  0x432aff97, 10);
      c = I(c, d, a, b, block[14], 0xab9423a7, 15);
      b = I(b, c, d, a, block[5],  0xfc93a039, 21);
      a = I(a, b, c, d, block[12], 0x655b59c3, 6);
      d = I(d, a, b, c, block[3],  0x8f0ccc92, 10);
      c = I(c, d, a, b, block[10], 0xffeff47d, 15);
      b = I(b, c, d, a, block[1],  0x85845dd1, 21);
      a = I(a, b, c, d, block[8],  0x6fa87e4f, 6);
      d = I(d, a, b, c, block[15], 0xfe2ce6e0, 10);
      c = I(c, d, a, b, block[6],  0xa3014314, 15);
      b = I(b, c, d, a, block[13], 0x4e0811a1, 21);
      a = I(a, b, c, d, block[4],  0xf7537e82, 6);
      d = I(d, a, b, c, block[11], 0xbd3af235, 10);
      c = I(c, d, a, b, block[2],  0x2ad7d2bb, 15);
      b = I(b, c, d, a, block[9],  0xeb86d391, 21);

state[0] += a;
      state[1] += b;
      state[2] += c;
      state[3] += d;
  }

var block = new Uint32Array(16);
  var bblock = new Uint8Array(block.buffer);
  var state = new Uint32Array(4);
  var bstate = new Uint8Array(state.buffer);

// Process a one or more 512-bit chunks of data.
  // Expects an array-like value as input.
  function md5(data) {
    var dataLength = data.length;

// Pad the input string.
    var length = dataLength + 9;
    length += 64 - (length % 64);

state[0] = 0x67452301;
    state[1] = 0xefcdab89;
    state[2] = 0x98badcfe;
    state[3] = 0x10325476;

for (var offset = 0; offset < length; offset += 64) {
      for (var i = 0; i < 64; i++) {
        var o = offset + i;
        if (o < dataLength) {
          bblock[i] = data[i];
          continue;
        }
        if (o === dataLength) {
          bblock[i] = 0x80;
          continue;
        }
        var x = o - length + 8;
        if (x >= 0 && x < 4) {
          bblock[i] = (dataLength << 3 >>> (x * 8)) & 0xff;
          continue;
        }
        bblock[i] = 0;
      }
      cycle(state, block);
    }

return bstate;

}

return md5;
});

// Convert a JS string into a UTF-8 encoded byte array.
  function stringToBuffer(string) {
    // Convert the unicode string to be the ASCII representation of
    // the UTF-8 bytes.
    string = unescape(encodeURIComponent(string));
    var length = string.length;
    var buf = new Uint8Array(length);
    for (var i = 0; i < length; i++) {
      buf[i] = string.charCodeAt(i);
    }
    return buf;
  }
</script>

Include JavaScript libraries as follows: <script src="//cdn.ext/library.js"></script>

Define setup for all tests (variables, functions, arrays or other objects that will be used in the tests) (runs before each clocked test loop, outside of the timed code region) (e.g. define local test variables, reset global variables, clear canvas, etc.) (see FAQ)

Define teardown for all tests (runs after each clocked test loop, outside of the timed code region) (see FAQ)

Code snippets to compare

Test 1

Title

Async (check if this is an asynchronous test)

Code

output = md5(input);

Test 2

Title

Async (check if this is an asynchronous test)

Code

output = other("Hello World\n");