chrome/test/data/dromaeo/tests/sunspider-crypto-sha1.html

   1 <html>
   2 <head>
   3 <script src="../htmlrunner.js"></script>
   4 <script>
   5 /*
   6  * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
   7  * in FIPS PUB 180-1
   8  * Version 2.1a Copyright Paul Johnston 2000 - 2002.
   9  * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
  10  * Distributed under the BSD License
  11  * See http://pajhome.org.uk/crypt/md5 for details.
  12  */
  13
  14 /*
  15  * Configurable variables. You may need to tweak these to be compatible with
  16  * the server-side, but the defaults work in most cases.
  17  */
  18 var hexcase = 0;  /* hex output format. 0 - lowercase; 1 - uppercase        */
  19 var b64pad  = ""; /* base-64 pad character. "=" for strict RFC compliance   */
  20 var chrsz   = 8;  /* bits per input character. 8 - ASCII; 16 - Unicode      */
  21
  22 /*
  23  * These are the functions you'll usually want to call
  24  * They take string arguments and return either hex or base-64 encoded strings
  25  */
  26 function hex_sha1(s){return binb2hex(core_sha1(str2binb(s),s.length * chrsz));}
  27 function b64_sha1(s){return binb2b64(core_sha1(str2binb(s),s.length * chrsz));}
  28 function str_sha1(s){return binb2str(core_sha1(str2binb(s),s.length * chrsz));}
  29 function hex_hmac_sha1(key, data){ return binb2hex(core_hmac_sha1(key, data));}
  30 function b64_hmac_sha1(key, data){ return binb2b64(core_hmac_sha1(key, data));}
  31 function str_hmac_sha1(key, data){ return binb2str(core_hmac_sha1(key, data));}
  32
  33 /*
  34  * Perform a simple self-test to see if the VM is working
  35  */
  36 function sha1_vm_test()
  37 {
  38   return hex_sha1("abc") == "a9993e364706816aba3e25717850c26c9cd0d89d";
  39 }
  40
  41 /*
  42  * Calculate the SHA-1 of an array of big-endian words, and a bit length
  43  */
  44 function core_sha1(x, len)
  45 {
  46   /* append padding */
  47   x[len >> 5] |= 0x80 << (24 - len % 32);
  48   x[((len + 64 >> 9) << 4) + 15] = len;
  49
  50   var w = Array(80);
  51   var a =  1732584193;
  52   var b = -271733879;
  53   var c = -1732584194;
  54   var d =  271733878;
  55   var e = -1009589776;
  56
  57   for(var i = 0; i < x.length; i += 16)
  58   {
  59     var olda = a;
  60     var oldb = b;
  61     var oldc = c;
  62     var oldd = d;
  63     var olde = e;
  64
  65     for(var j = 0; j < 80; j++)
  66     {
  67       if(j < 16) w[j] = x[i + j];
  68       else w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);
  69       var t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)),
  70                        safe_add(safe_add(e, w[j]), sha1_kt(j)));
  71       e = d;
  72       d = c;
  73       c = rol(b, 30);
  74       b = a;
  75       a = t;
  76     }
  77
  78     a = safe_add(a, olda);
  79     b = safe_add(b, oldb);
  80     c = safe_add(c, oldc);
  81     d = safe_add(d, oldd);
  82     e = safe_add(e, olde);
  83   }
  84   return Array(a, b, c, d, e);
  85
  86 }
  87
  88 /*
  89  * Perform the appropriate triplet combination function for the current
  90  * iteration
  91  */
  92 function sha1_ft(t, b, c, d)
  93 {
  94   if(t < 20) return (b & c) | ((~b) & d);
  95   if(t < 40) return b ^ c ^ d;
  96   if(t < 60) return (b & c) | (b & d) | (c & d);
  97   return b ^ c ^ d;
  98 }
  99
 100 /*
 101  * Determine the appropriate additive constant for the current iteration
 102  */
 103 function sha1_kt(t)
 104 {
 105   return (t < 20) ?  1518500249 : (t < 40) ?  1859775393 :
 106          (t < 60) ? -1894007588 : -899497514;
 107 }
 108
 109 /*
 110  * Calculate the HMAC-SHA1 of a key and some data
 111  */
 112 function core_hmac_sha1(key, data)
 113 {
 114   var bkey = str2binb(key);
 115   if(bkey.length > 16) bkey = core_sha1(bkey, key.length * chrsz);
 116
 117   var ipad = Array(16), opad = Array(16);
 118   for(var i = 0; i < 16; i++)
 119   {
 120     ipad[i] = bkey[i] ^ 0x36363636;
 121     opad[i] = bkey[i] ^ 0x5C5C5C5C;
 122   }
 123
 124   var hash = core_sha1(ipad.concat(str2binb(data)), 512 + data.length * chrsz);
 125   return core_sha1(opad.concat(hash), 512 + 160);
 126 }
 127
 128 /*
 129  * Add integers, wrapping at 2^32. This uses 16-bit operations internally
 130  * to work around bugs in some JS interpreters.
 131  */
 132 function safe_add(x, y)
 133 {
 134   var lsw = (x & 0xFFFF) + (y & 0xFFFF);
 135   var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
 136   return (msw << 16) | (lsw & 0xFFFF);
 137 }
 138
 139 /*
 140  * Bitwise rotate a 32-bit number to the left.
 141  */
 142 function rol(num, cnt)
 143 {
 144   return (num << cnt) | (num >>> (32 - cnt));
 145 }
 146
 147 /*
 148  * Convert an 8-bit or 16-bit string to an array of big-endian words
 149  * In 8-bit function, characters >255 have their hi-byte silently ignored.
 150  */
 151 function str2binb(str)
 152 {
 153   var bin = Array();
 154   var mask = (1 << chrsz) - 1;
 155   for(var i = 0; i < str.length * chrsz; i += chrsz)
 156     bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (32 - chrsz - i%32);
 157   return bin;
 158 }
 159
 160 /*
 161  * Convert an array of big-endian words to a string
 162  */
 163 function binb2str(bin)
 164 {
 165   var str = "";
 166   var mask = (1 << chrsz) - 1;
 167   for(var i = 0; i < bin.length * 32; i += chrsz)
 168     str += String.fromCharCode((bin[i>>5] >>> (32 - chrsz - i%32)) & mask);
 169   return str;
 170 }
 171
 172 /*
 173  * Convert an array of big-endian words to a hex string.
 174  */
 175 function binb2hex(binarray)
 176 {
 177   var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
 178   var str = "";
 179   for(var i = 0; i < binarray.length * 4; i++)
 180   {
 181     str += hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8+4)) & 0xF) +
 182            hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8  )) & 0xF);
 183   }
 184   return str;
 185 }
 186
 187 /*
 188  * Convert an array of big-endian words to a base-64 string
 189  */
 190 function binb2b64(binarray)
 191 {
 192   var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 193   var str = "";
 194   for(var i = 0; i < binarray.length * 4; i += 3)
 195   {
 196     var triplet = (((binarray[i   >> 2] >> 8 * (3 -  i   %4)) & 0xFF) << 16)
 197                 | (((binarray[i+1 >> 2] >> 8 * (3 - (i+1)%4)) & 0xFF) << 8 )
 198                 |  ((binarray[i+2 >> 2] >> 8 * (3 - (i+2)%4)) & 0xFF);
 199     for(var j = 0; j < 4; j++)
 200     {
 201       if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
 202       else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
 203     }
 204   }
 205   return str;
 206 }
 207
 208
 209 var plainText = "Two households, both alike in dignity,\n\
 210 In fair Verona, where we lay our scene,\n\
 211 From ancient grudge break to new mutiny,\n\
 212 Where civil blood makes civil hands unclean.\n\
 213 From forth the fatal loins of these two foes\n\
 214 A pair of star-cross'd lovers take their life;\n\
 215 Whole misadventured piteous overthrows\n\
 216 Do with their death bury their parents' strife.\n\
 217 The fearful passage of their death-mark'd love,\n\
 218 And the continuance of their parents' rage,\n\
 219 Which, but their children's end, nought could remove,\n\
 220 Is now the two hours' traffic of our stage;\n\
 221 The which if you with patient ears attend,\n\
 222 What here shall miss, our toil shall strive to mend.";
 223
 224 for (var i = 0; i <2; i++) {
 225     plainText += plainText;
 226 }
 227
 228 window.onload = function(){ startTest("sunspider-crypto-sha1", 'b1fc168a');
 229
 230 test("SHA1 Hashing", function(){
 231         var sha1Output = hex_sha1(plainText);
 232 });
 233
 234 endTest(); };
 235 </script>
 236 </head>
 237 <body></body>
 238 </html>