← Back to branch summary

~ubuntu-branches/ubuntu/wily/mozjs17/wily

« back to all changes in this revision

Viewing changes to js/src/metrics/jint/sunspider/crypto-md5.js

  • Committer: Package Import Robot
  • Author(s): Rico Tzschichholz
  • Date: 2013-05-25 12:24:23 UTC
  • Revision ID: package-import@ubuntu.com-20130525122423-zmxucrhtensw90xy
Tags: upstream-17.0.0
Import upstream version 17.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
js/src/metrics/jint/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
  /* BEGIN LOOP */
 
52
  for(var i = 0; i < x.length; i += 16)
 
53
  {
 
54
    var olda = a;
 
55
    var oldb = b;
 
56
    var oldc = c;
 
57
    var oldd = d;
 
58
 
 
59
    a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
 
60
    d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
 
61
    c = md5_ff(c, d, a, b, x[i+ 2], 17,  606105819);
 
62
    b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
 
63
    a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
 
64
    d = md5_ff(d, a, b, c, x[i+ 5], 12,  1200080426);
 
65
    c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
 
66
    b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
 
67
    a = md5_ff(a, b, c, d, x[i+ 8], 7 ,  1770035416);
 
68
    d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
 
69
    c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
 
70
    b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
 
71
    a = md5_ff(a, b, c, d, x[i+12], 7 ,  1804603682);
 
72
    d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
 
73
    c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
 
74
    b = md5_ff(b, c, d, a, x[i+15], 22,  1236535329);
 
75
 
 
76
    a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
 
77
    d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
 
78
    c = md5_gg(c, d, a, b, x[i+11], 14,  643717713);
 
79
    b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
 
80
    a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
 
81
    d = md5_gg(d, a, b, c, x[i+10], 9 ,  38016083);
 
82
    c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
 
83
    b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
 
84
    a = md5_gg(a, b, c, d, x[i+ 9], 5 ,  568446438);
 
85
    d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
 
86
    c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
 
87
    b = md5_gg(b, c, d, a, x[i+ 8], 20,  1163531501);
 
88
    a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
 
89
    d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
 
90
    c = md5_gg(c, d, a, b, x[i+ 7], 14,  1735328473);
 
91
    b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);
 
92
 
 
93
    a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
 
94
    d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
 
95
    c = md5_hh(c, d, a, b, x[i+11], 16,  1839030562);
 
96
    b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
 
97
    a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
 
98
    d = md5_hh(d, a, b, c, x[i+ 4], 11,  1272893353);
 
99
    c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
 
100
    b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
 
101
    a = md5_hh(a, b, c, d, x[i+13], 4 ,  681279174);
 
102
    d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
 
103
    c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
 
104
    b = md5_hh(b, c, d, a, x[i+ 6], 23,  76029189);
 
105
    a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
 
106
    d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
 
107
    c = md5_hh(c, d, a, b, x[i+15], 16,  530742520);
 
108
    b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);
 
109
 
 
110
    a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
 
111
    d = md5_ii(d, a, b, c, x[i+ 7], 10,  1126891415);
 
112
    c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
 
113
    b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
 
114
    a = md5_ii(a, b, c, d, x[i+12], 6 ,  1700485571);
 
115
    d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
 
116
    c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
 
117
    b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
 
118
    a = md5_ii(a, b, c, d, x[i+ 8], 6 ,  1873313359);
 
119
    d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
 
120
    c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
 
121
    b = md5_ii(b, c, d, a, x[i+13], 21,  1309151649);
 
122
    a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
 
123
    d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
 
124
    c = md5_ii(c, d, a, b, x[i+ 2], 15,  718787259);
 
125
    b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);
 
126
 
 
127
    a = safe_add(a, olda);
 
128
    b = safe_add(b, oldb);
 
129
    c = safe_add(c, oldc);
 
130
    d = safe_add(d, oldd);
 
131
  }
 
132
  /* END LOOP */
 
133
  return Array(a, b, c, d);
 
134
 
 
135
}
 
136
 
 
137
/*
 
138
 * These functions implement the four basic operations the algorithm uses.
 
139
 */
 
140
function md5_cmn(q, a, b, x, s, t)
 
141
{
 
142
  return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);
 
143
}
 
144
function md5_ff(a, b, c, d, x, s, t)
 
145
{
 
146
  return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
 
147
}
 
148
function md5_gg(a, b, c, d, x, s, t)
 
149
{
 
150
  return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
 
151
}
 
152
function md5_hh(a, b, c, d, x, s, t)
 
153
{
 
154
  return md5_cmn(b ^ c ^ d, a, b, x, s, t);
 
155
}
 
156
function md5_ii(a, b, c, d, x, s, t)
 
157
{
 
158
  return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
 
159
}
 
160
 
 
161
/*
 
162
 * Calculate the HMAC-MD5, of a key and some data
 
163
 */
 
164
function core_hmac_md5(key, data)
 
165
{
 
166
  var bkey = str2binl(key);
 
167
  if(bkey.length > 16) bkey = core_md5(bkey, key.length * chrsz);
 
168
 
 
169
  var ipad = Array(16), opad = Array(16);
 
170
  /* BEGIN LOOP */
 
171
  for(var i = 0; i < 16; i++)
 
172
  {
 
173
    ipad[i] = bkey[i] ^ 0x36363636;
 
174
    opad[i] = bkey[i] ^ 0x5C5C5C5C;
 
175
  }
 
176
  /* END LOOP */
 
177
 
 
178
  var hash = core_md5(ipad.concat(str2binl(data)), 512 + data.length * chrsz);
 
179
  return core_md5(opad.concat(hash), 512 + 128);
 
180
}
 
181
 
 
182
/*
 
183
 * Add integers, wrapping at 2^32. This uses 16-bit operations internally
 
184
 * to work around bugs in some JS interpreters.
 
185
 */
 
186
function safe_add(x, y)
 
187
{
 
188
  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
 
189
  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
 
190
  return (msw << 16) | (lsw & 0xFFFF);
 
191
}
 
192
 
 
193
/*
 
194
 * Bitwise rotate a 32-bit number to the left.
 
195
 */
 
196
function bit_rol(num, cnt)
 
197
{
 
198
  return (num << cnt) | (num >>> (32 - cnt));
 
199
}
 
200
 
 
201
/*
 
202
 * Convert a string to an array of little-endian words
 
203
 * If chrsz is ASCII, characters >255 have their hi-byte silently ignored.
 
204
 */
 
205
function str2binl(str)
 
206
{
 
207
  var bin = Array();
 
208
  var mask = (1 << chrsz) - 1;
 
209
  /* BEGIN LOOP */
 
210
  for(var i = 0; i < str.length * chrsz; i += chrsz)
 
211
    bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (i%32);
 
212
  /* END LOOP */
 
213
  return bin;
 
214
}
 
215
 
 
216
/*
 
217
 * Convert an array of little-endian words to a string
 
218
 */
 
219
function binl2str(bin)
 
220
{
 
221
  var str = "";
 
222
  var mask = (1 << chrsz) - 1;
 
223
  /* BEGIN LOOP */
 
224
  for(var i = 0; i < bin.length * 32; i += chrsz)
 
225
    str += String.fromCharCode((bin[i>>5] >>> (i % 32)) & mask);
 
226
  /* END LOOP */
 
227
  return str;
 
228
}
 
229
 
 
230
/*
 
231
 * Convert an array of little-endian words to a hex string.
 
232
 */
 
233
function binl2hex(binarray)
 
234
{
 
235
  var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
 
236
  var str = "";
 
237
  /* BEGIN LOOP */
 
238
  for(var i = 0; i < binarray.length * 4; i++)
 
239
  {
 
240
    str += hex_tab.charAt((binarray[i>>2] >> ((i%4)*8+4)) & 0xF) +
 
241
           hex_tab.charAt((binarray[i>>2] >> ((i%4)*8  )) & 0xF);
 
242
  }
 
243
  /* END LOOP */
 
244
  return str;
 
245
}
 
246
 
 
247
/*
 
248
 * Convert an array of little-endian words to a base-64 string
 
249
 */
 
250
function binl2b64(binarray)
 
251
{
 
252
  var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
253
  var str = "";
 
254
  /* BEGIN LOOP */
 
255
  for(var i = 0; i < binarray.length * 4; i += 3)
 
256
  {
 
257
    var triplet = (((binarray[i   >> 2] >> 8 * ( i   %4)) & 0xFF) << 16)
 
258
                | (((binarray[i+1 >> 2] >> 8 * ((i+1)%4)) & 0xFF) << 8 )
 
259
                |  ((binarray[i+2 >> 2] >> 8 * ((i+2)%4)) & 0xFF);
 
260
    /* BEGIN LOOP */
 
261
    for(var j = 0; j < 4; j++)
 
262
    {
 
263
      if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
 
264
      else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
 
265
    }
 
266
    /* END LOOP */
 
267
  }
 
268
  /* END LOOP */
 
269
  return str;
 
270
}
 
271
 
 
272
var plainText = "Rebellious subjects, enemies to peace,\n\
 
273
Profaners of this neighbour-stained steel,--\n\
 
274
Will they not hear? What, ho! you men, you beasts,\n\
 
275
That quench the fire of your pernicious rage\n\
 
276
With purple fountains issuing from your veins,\n\
 
277
On pain of torture, from those bloody hands\n\
 
278
Throw your mistemper'd weapons to the ground,\n\
 
279
And hear the sentence of your moved prince.\n\
 
280
Three civil brawls, bred of an airy word,\n\
 
281
By thee, old Capulet, and Montague,\n\
 
282
Have thrice disturb'd the quiet of our streets,\n\
 
283
And made Verona's ancient citizens\n\
 
284
Cast by their grave beseeming ornaments,\n\
 
285
To wield old partisans, in hands as old,\n\
 
286
Canker'd with peace, to part your canker'd hate:\n\
 
287
If ever you disturb our streets again,\n\
 
288
Your lives shall pay the forfeit of the peace.\n\
 
289
For this time, all the rest depart away:\n\
 
290
You Capulet; shall go along with me:\n\
 
291
And, Montague, come you this afternoon,\n\
 
292
To know our further pleasure in this case,\n\
 
293
To old Free-town, our common judgment-place.\n\
 
294
Once more, on pain of death, all men depart."
 
295
 
 
296
    /* BEGIN LOOP */
 
297
for (var i = 0; i <4; i++) {
 
298
    plainText += plainText;
 
299
}
 
300
    /* END LOOP */
 
301
 
 
302
var md5Output = hex_md5(plainText);