Make JetStream 2
[WebKit-https.git] / PerformanceTests / JetStream2 / SunSpider / crypto-md5.js
1 /*
2  * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
3  * Digest Algorithm, as defined in RFC 1321.
4  * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
5  * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
6  * Distributed under the BSD License
7  * See http://pajhome.org.uk/crypt/md5 for more info.
8  */
9
10 /*
11  * Configurable variables. You may need to tweak these to be compatible with
12  * the server-side, but the defaults work in most cases.
13  */
14 var hexcase = 0;  /* hex output format. 0 - lowercase; 1 - uppercase        */
15 var b64pad  = ""; /* base-64 pad character. "=" for strict RFC compliance   */
16 var chrsz   = 8;  /* bits per input character. 8 - ASCII; 16 - Unicode      */
17
18 /*
19  * These are the functions you'll usually want to call
20  * They take string arguments and return either hex or base-64 encoded strings
21  */
22 function hex_md5(s){ return binl2hex(core_md5(str2binl(s), s.length * chrsz));}
23 function b64_md5(s){ return binl2b64(core_md5(str2binl(s), s.length * chrsz));}
24 function str_md5(s){ return binl2str(core_md5(str2binl(s), s.length * chrsz));}
25 function hex_hmac_md5(key, data) { return binl2hex(core_hmac_md5(key, data)); }
26 function b64_hmac_md5(key, data) { return binl2b64(core_hmac_md5(key, data)); }
27 function str_hmac_md5(key, data) { return binl2str(core_hmac_md5(key, data)); }
28
29 /*
30  * Perform a simple self-test to see if the VM is working
31  */
32 function md5_vm_test()
33 {
34   return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";
35 }
36
37 /*
38  * Calculate the MD5 of an array of little-endian words, and a bit length
39  */
40 function core_md5(x, len)
41 {
42   /* append padding */
43   x[len >> 5] |= 0x80 << ((len) % 32);
44   x[(((len + 64) >>> 9) << 4) + 14] = len;
45
46   var a =  1732584193;
47   var b = -271733879;
48   var c = -1732584194;
49   var d =  271733878;
50
51   for(var i = 0; i < x.length; i += 16)
52   {
53     var olda = a;
54     var oldb = b;
55     var oldc = c;
56     var oldd = d;
57
58     a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
59     d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
60     c = md5_ff(c, d, a, b, x[i+ 2], 17,  606105819);
61     b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
62     a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
63     d = md5_ff(d, a, b, c, x[i+ 5], 12,  1200080426);
64     c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
65     b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
66     a = md5_ff(a, b, c, d, x[i+ 8], 7 ,  1770035416);
67     d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
68     c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
69     b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
70     a = md5_ff(a, b, c, d, x[i+12], 7 ,  1804603682);
71     d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
72     c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
73     b = md5_ff(b, c, d, a, x[i+15], 22,  1236535329);
74
75     a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
76     d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
77     c = md5_gg(c, d, a, b, x[i+11], 14,  643717713);
78     b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
79     a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
80     d = md5_gg(d, a, b, c, x[i+10], 9 ,  38016083);
81     c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
82     b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
83     a = md5_gg(a, b, c, d, x[i+ 9], 5 ,  568446438);
84     d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
85     c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
86     b = md5_gg(b, c, d, a, x[i+ 8], 20,  1163531501);
87     a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
88     d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
89     c = md5_gg(c, d, a, b, x[i+ 7], 14,  1735328473);
90     b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);
91
92     a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
93     d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
94     c = md5_hh(c, d, a, b, x[i+11], 16,  1839030562);
95     b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
96     a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
97     d = md5_hh(d, a, b, c, x[i+ 4], 11,  1272893353);
98     c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
99     b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
100     a = md5_hh(a, b, c, d, x[i+13], 4 ,  681279174);
101     d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
102     c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
103     b = md5_hh(b, c, d, a, x[i+ 6], 23,  76029189);
104     a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
105     d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
106     c = md5_hh(c, d, a, b, x[i+15], 16,  530742520);
107     b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);
108
109     a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
110     d = md5_ii(d, a, b, c, x[i+ 7], 10,  1126891415);
111     c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
112     b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
113     a = md5_ii(a, b, c, d, x[i+12], 6 ,  1700485571);
114     d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
115     c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
116     b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
117     a = md5_ii(a, b, c, d, x[i+ 8], 6 ,  1873313359);
118     d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
119     c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
120     b = md5_ii(b, c, d, a, x[i+13], 21,  1309151649);
121     a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
122     d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
123     c = md5_ii(c, d, a, b, x[i+ 2], 15,  718787259);
124     b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);
125
126     a = safe_add(a, olda);
127     b = safe_add(b, oldb);
128     c = safe_add(c, oldc);
129     d = safe_add(d, oldd);
130   }
131   return Array(a, b, c, d);
132
133 }
134
135 /*
136  * These functions implement the four basic operations the algorithm uses.
137  */
138 function md5_cmn(q, a, b, x, s, t)
139 {
140   return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);
141 }
142 function md5_ff(a, b, c, d, x, s, t)
143 {
144   return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
145 }
146 function md5_gg(a, b, c, d, x, s, t)
147 {
148   return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
149 }
150 function md5_hh(a, b, c, d, x, s, t)
151 {
152   return md5_cmn(b ^ c ^ d, a, b, x, s, t);
153 }
154 function md5_ii(a, b, c, d, x, s, t)
155 {
156   return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
157 }
158
159 /*
160  * Calculate the HMAC-MD5, of a key and some data
161  */
162 function core_hmac_md5(key, data)
163 {
164   var bkey = str2binl(key);
165   if(bkey.length > 16) bkey = core_md5(bkey, key.length * chrsz);
166
167   var ipad = Array(16), opad = Array(16);
168   for(var i = 0; i < 16; i++)
169   {
170     ipad[i] = bkey[i] ^ 0x36363636;
171     opad[i] = bkey[i] ^ 0x5C5C5C5C;
172   }
173
174   var hash = core_md5(ipad.concat(str2binl(data)), 512 + data.length * chrsz);
175   return core_md5(opad.concat(hash), 512 + 128);
176 }
177
178 /*
179  * Add integers, wrapping at 2^32. This uses 16-bit operations internally
180  * to work around bugs in some JS interpreters.
181  */
182 function safe_add(x, y)
183 {
184   var lsw = (x & 0xFFFF) + (y & 0xFFFF);
185   var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
186   return (msw << 16) | (lsw & 0xFFFF);
187 }
188
189 /*
190  * Bitwise rotate a 32-bit number to the left.
191  */
192 function bit_rol(num, cnt)
193 {
194   return (num << cnt) | (num >>> (32 - cnt));
195 }
196
197 /*
198  * Convert a string to an array of little-endian words
199  * If chrsz is ASCII, characters >255 have their hi-byte silently ignored.
200  */
201 function str2binl(str)
202 {
203   var bin = Array();
204   var mask = (1 << chrsz) - 1;
205   for(var i = 0; i < str.length * chrsz; i += chrsz)
206     bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (i%32);
207   return bin;
208 }
209
210 /*
211  * Convert an array of little-endian words to a string
212  */
213 function binl2str(bin)
214 {
215   var str = "";
216   var mask = (1 << chrsz) - 1;
217   for(var i = 0; i < bin.length * 32; i += chrsz)
218     str += String.fromCharCode((bin[i>>5] >>> (i % 32)) & mask);
219   return str;
220 }
221
222 /*
223  * Convert an array of little-endian words to a hex string.
224  */
225 function binl2hex(binarray)
226 {
227   var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
228   var str = "";
229   for(var i = 0; i < binarray.length * 4; i++)
230   {
231     str += hex_tab.charAt((binarray[i>>2] >> ((i%4)*8+4)) & 0xF) +
232            hex_tab.charAt((binarray[i>>2] >> ((i%4)*8  )) & 0xF);
233   }
234   return str;
235 }
236
237 /*
238  * Convert an array of little-endian words to a base-64 string
239  */
240 function binl2b64(binarray)
241 {
242   var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
243   var str = "";
244   for(var i = 0; i < binarray.length * 4; i += 3)
245   {
246     var triplet = (((binarray[i   >> 2] >> 8 * ( i   %4)) & 0xFF) << 16)
247                 | (((binarray[i+1 >> 2] >> 8 * ((i+1)%4)) & 0xFF) << 8 )
248                 |  ((binarray[i+2 >> 2] >> 8 * ((i+2)%4)) & 0xFF);
249     for(var j = 0; j < 4; j++)
250     {
251       if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
252       else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
253     }
254   }
255   return str;
256 }
257
258 function run() {
259     var plainText =
260 "Rebellious subjects, enemies to peace,\n\
261 Profaners of this neighbour-stained steel,--\n\
262 Will they not hear? What, ho! you men, you beasts,\n\
263 That quench the fire of your pernicious rage\n\
264 With purple fountains issuing from your veins,\n\
265 On pain of torture, from those bloody hands\n\
266 Throw your mistemper'd weapons to the ground,\n\
267 And hear the sentence of your moved prince.\n\
268 Three civil brawls, bred of an airy word,\n\
269 By thee, old Capulet, and Montague,\n\
270 Have thrice disturb'd the quiet of our streets,\n\
271 And made Verona's ancient citizens\n\
272 Cast by their grave beseeming ornaments,\n\
273 To wield old partisans, in hands as old,\n\
274 Canker'd with peace, to part your canker'd hate:\n\
275 If ever you disturb our streets again,\n\
276 Your lives shall pay the forfeit of the peace.\n\
277 For this time, all the rest depart away:\n\
278 You Capulet; shall go along with me:\n\
279 And, Montague, come you this afternoon,\n\
280 To know our further pleasure in this case,\n\
281 To old Free-town, our common judgment-place.\n\
282 Once more, on pain of death, all men depart.";
283
284     for (var i = 0; i <4; i++) {
285         plainText += plainText;
286     }
287
288     var md5Output = hex_md5(plainText);
289
290     var expected = "a831e91e0f70eddcb70dc61c6f82f6cd";
291
292     if (md5Output != expected)
293         throw "ERROR: bad result: expected " + expected + " but got " + md5Output;
294
295 }
296
297
298 class Benchmark {
299     runIteration() {
300         for (let i = 0; i < 22; ++i)
301             run();
302     }
303 }