← Back to branch summary

~ubuntu-branches/ubuntu/quantal/enigmail/quantal-security

« back to all changes in this revision

Viewing changes to build/pgo/js-input/crypto-md5.html

  • Committer: Package Import Robot
  • Author(s): Chris Coulson
  • Date: 2013-09-13 16:02:15 UTC
  • mfrom: (0.12.16)
  • Revision ID: package-import@ubuntu.com-20130913160215-u3g8nmwa0pdwagwc
Tags: 2:1.5.2-0ubuntu0.12.10.1
* New upstream release v1.5.2 for Thunderbird 24

* Build enigmail using a stripped down Thunderbird 17 build system, as it's
  now quite difficult to build the way we were doing previously, with the
  latest Firefox build system
* Add debian/patches/no_libxpcom.patch - Don't link against libxpcom, as it
  doesn't exist anymore (but exists in the build system)
* Add debian/patches/use_sdk.patch - Use the SDK version of xpt.py and
  friends
* Drop debian/patches/ipc-pipe_rename.diff (not needed anymore)
* Drop debian/patches/makefile_depth.diff (not needed anymore)

Show diffs side-by-side

added added

removed removed

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