← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to www/media/common/md5.js

Dispatch now generates an index for each plugin type, allowing plugins to
be written which are aware of other plugins, and other plugin types.

All view plugins now subclass from ivle.webapp.base.plugins.ViewPlugin,
as opposed to subclassing BasePlugin directly. This will allow us to
easily re-write console as an OverlayPlugin, and allow future new
plugins types to be created.

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/media/common/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
}