Speed up hashing in browsers.

Avoid deopts by remaining inside of string boundaries.

Author: RubenVerborgh

lib/browser/crypto.js

@@ -12,49 +12,46 @@ exports.createHash = function () {
 /*! @license MIT ©2002-2014 Chris Veness */
 /* SHA-1 implementation */
 
+// constants [§4.2.1]
+var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
+var pow2to35 = Math.pow(2, 35);
+
 /**
  * Generates SHA-1 hash of string.
  *
  * @param   {string} msg - (Unicode) string to be hashed.
  * @returns {string} Hash of msg as hex character string.
  */
 function sha1(msg) {
-  // constants [§4.2.1]
-  var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6], i, j;
-
   // PREPROCESSING
-  msg += String.fromCharCode(0x80);  // add trailing '1' bit (+ 0's padding) to string [§5.1.1]
+  msg += '\u0080';  // add trailing '1' bit (+ 0's padding) to string [§5.1.1]
 
   // convert string msg into 512-bit/16-integer blocks arrays of ints [§5.2.1]
-  var l = msg.length / 4 + 2; // length (in 32-bit integers) of msg + ‘1’ + appended length
-  var N = Math.ceil(l / 16);  // number of 16-integer-blocks required to hold 'l' ints
+  var length = msg.length;
+  var l = length / 4 + 2; // length (in 32-bit integers) of msg + ‘1’ + appended length
+  var N = ~~((l + 15) / 16);  // number of 16-integer-blocks required to hold 'l' ints
   var M = new Array(N);
 
-  for (i = 0; i < N; i++) {
+  var i, j, index;
+  for (i = 0, index = 0; i < N; i++) {
     M[i] = new Array(16);
-    for (j = 0; j < 16; j++) {  // encode 4 chars per integer, big-endian encoding
-      M[i][j] = (msg.charCodeAt(i * 64 + j * 4)     << 24) |
-                (msg.charCodeAt(i * 64 + j * 4 + 1) << 16) |
-                (msg.charCodeAt(i * 64 + j * 4 + 2) << 8)  |
-                (msg.charCodeAt(i * 64 + j * 4 + 3));
-    } // note running off the end of msg is ok 'cos bitwise ops on NaN return 0
+    for (j = 0; j < 16; j++, index++) {  // encode 4 chars per integer, big-endian encoding
+      M[i][j] =   (index < length ? msg.charCodeAt(index) << 24 : 0) |
+                (++index < length ? msg.charCodeAt(index) << 16 : 0) |
+                (++index < length ? msg.charCodeAt(index) <<  8 : 0) |
+                (++index < length ? msg.charCodeAt(index)       : 0);
+    }
   }
   // add length (in bits) into final pair of 32-bit integers (big-endian) [§5.1.1]
   // note: most significant word would be (len-1)*8 >>> 32, but since JS converts
   // bitwise-op args to 32 bits, we need to simulate this by arithmetic operators
-  M[N - 1][14] = ((msg.length - 1) * 8) / Math.pow(2, 32);
-  M[N - 1][14] = Math.floor(M[N - 1][14]);
+  M[N - 1][14] = ~~((msg.length - 1) / pow2to35);
   M[N - 1][15] = ((msg.length - 1) * 8) & 0xffffffff;
 
   // set initial hash value [§5.3.1]
-  var H0 = 0x67452301;
-  var H1 = 0xefcdab89;
-  var H2 = 0x98badcfe;
-  var H3 = 0x10325476;
-  var H4 = 0xc3d2e1f0;
+  var H0 = 0x67452301, H1 = 0xefcdab89, H2 = 0x98badcfe, H3 = 0x10325476, H4 = 0xc3d2e1f0;
 
   // HASH COMPUTATION [§6.1.2]
-
   var W = new Array(80), a, b, c, d, e, t;
   for (i = 0; i < N; i++) {
     // 1 - prepare message schedule 'W'
@@ -66,7 +63,7 @@ function sha1(msg) {
 
     // 3 - main loop
     for (t = 0; t < 80; t++) {
-      var s = Math.floor(t / 20); // seq for blocks of 'f' functions and 'K' constants
+      var s = ~~(t / 20); // seq for blocks of 'f' functions and 'K' constants
       var T = (rotl(a, 5) + f(s, b, c, d) + e + K[s] + W[t]) & 0xffffffff;
       e = d;
       d = c;