1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 | 'use strict';
|
13 | (function (Y) {
|
14 | function C(c, a, b) {
|
15 | var e = 0, h = [], n = 0, g, l, d, f, m, q, u, r, I = !1, v = [], w = [], t,
|
16 | y = !1, z = !1, x = -1;
|
17 | b = b || {};
|
18 | g = b.encoding || "UTF8";
|
19 | t = b.numRounds || 1;
|
20 | if (t !== parseInt(t, 10) || 1 > t) {
|
21 | throw Error(
|
22 | "numRounds must a integer >= 1");
|
23 | }
|
24 | if ("SHA-1" === c) {
|
25 | m = 512, q = K, u = Z, f = 160, r = function (a) {
|
26 | return a.slice()
|
27 | };
|
28 | } else if (0 === c.lastIndexOf("SHA-", 0)) {
|
29 | if (q = function (a, b) {
|
30 | return L(a, b, c)
|
31 | }, u = function (a, b, h, e) {
|
32 | var k, f;
|
33 | if ("SHA-224" === c || "SHA-256" === c) {
|
34 | k = (b + 65 >>> 9 << 4)
|
35 | + 15, f = 16;
|
36 | } else if ("SHA-384" === c || "SHA-512" === c) {
|
37 | k = (b
|
38 | + 129 >>> 10 <<
|
39 | 5) + 31, f = 32;
|
40 | } else {
|
41 | throw Error(
|
42 | "Unexpected error in SHA-2 implementation");
|
43 | }
|
44 | for (; a.length <= k;) {
|
45 | a.push(0);
|
46 | }
|
47 | a[b >>> 5] |= 128 << 24 - b % 32;
|
48 | b = b + h;
|
49 | a[k] = b & 4294967295;
|
50 | a[k - 1] = b / 4294967296 | 0;
|
51 | h = a.length;
|
52 | for (b = 0; b < h; b += f) {
|
53 | e = L(a.slice(b, b + f), e, c);
|
54 | }
|
55 | if ("SHA-224" === c) {
|
56 | a = [e[0], e[1], e[2], e[3], e[4], e[5],
|
57 | e[6]];
|
58 | } else if ("SHA-256" === c) {
|
59 | a = e;
|
60 | } else if ("SHA-384"
|
61 | === c) {
|
62 | a = [e[0].a, e[0].b, e[1].a, e[1].b, e[2].a, e[2].b,
|
63 | e[3].a, e[3].b, e[4].a, e[4].b, e[5].a, e[5].b];
|
64 | } else if ("SHA-512"
|
65 | === c) {
|
66 | a = [e[0].a, e[0].b, e[1].a, e[1].b, e[2].a, e[2].b,
|
67 | e[3].a, e[3].b, e[4].a,
|
68 | e[4].b, e[5].a, e[5].b, e[6].a, e[6].b, e[7].a,
|
69 | e[7].b];
|
70 | } else {
|
71 | throw Error(
|
72 | "Unexpected error in SHA-2 implementation");
|
73 | }
|
74 | return a
|
75 | }, r = function (a) {
|
76 | return a.slice()
|
77 | }, "SHA-224" === c) {
|
78 | m = 512, f = 224;
|
79 | } else if ("SHA-256"
|
80 | === c) {
|
81 | m = 512, f = 256;
|
82 | } else if ("SHA-384"
|
83 | === c) {
|
84 | m = 1024, f = 384;
|
85 | } else if ("SHA-512"
|
86 | === c) {
|
87 | m = 1024, f = 512;
|
88 | } else {
|
89 | throw Error(
|
90 | "Chosen SHA variant is not supported");
|
91 | }
|
92 | } else if (0 === c.lastIndexOf(
|
93 | "SHA3-", 0) || 0 === c.lastIndexOf("SHAKE", 0)) {
|
94 | var F = 6;
|
95 | q = D;
|
96 | r = function (a) {
|
97 | var c = [], e;
|
98 | for (e = 0; 5 > e; e += 1) {
|
99 | c[e] = a[e].slice();
|
100 | }
|
101 | return c
|
102 | };
|
103 | x = 1;
|
104 | if ("SHA3-224" ===
|
105 | c) {
|
106 | m = 1152, f = 224;
|
107 | } else if ("SHA3-256"
|
108 | === c) {
|
109 | m = 1088, f = 256;
|
110 | } else if ("SHA3-384"
|
111 | === c) {
|
112 | m = 832, f = 384;
|
113 | } else if ("SHA3-512"
|
114 | === c) {
|
115 | m = 576, f = 512;
|
116 | } else if ("SHAKE128"
|
117 | === c) {
|
118 | m = 1344, f = -1, F = 31, z = !0;
|
119 | } else if ("SHAKE256"
|
120 | === c) {
|
121 | m = 1088, f = -1, F = 31, z = !0;
|
122 | } else {
|
123 | throw Error(
|
124 | "Chosen SHA variant is not supported");
|
125 | }
|
126 | u = function (a, c, e, b, h) {
|
127 | e = m;
|
128 | var k = F, f, g = [], n = e >>> 5, l = 0, d = c >>> 5;
|
129 | for (f = 0; f < d && c >= e; f += n) {
|
130 | b = D(a.slice(f, f + n),
|
131 | b), c -= e;
|
132 | }
|
133 | a = a.slice(f);
|
134 | for (c %= e; a.length < n;) {
|
135 | a.push(0);
|
136 | }
|
137 | f = c >>> 3;
|
138 | a[f >> 2] ^= k << f % 4 * 8;
|
139 | a[n - 1] ^= 2147483648;
|
140 | for (b = D(a, b); 32 * g.length < h;) {
|
141 | a = b[l %
|
142 | 5][l / 5 | 0];
|
143 | g.push(a.b);
|
144 | if (32 * g.length >= h) {
|
145 | break;
|
146 | }
|
147 | g.push(a.a);
|
148 | l += 1;
|
149 | 0 === 64 * l % e && D(null, b)
|
150 | }
|
151 | return g
|
152 | }
|
153 | } else {
|
154 | throw Error("Chosen SHA variant is not supported");
|
155 | }
|
156 | d = M(a, g, x);
|
157 | l = A(c);
|
158 | this.setHMACKey = function (a, b, h) {
|
159 | var k;
|
160 | if (!0 === I) {
|
161 | throw Error("HMAC key already set");
|
162 | }
|
163 | if (!0 === y) {
|
164 | throw Error("Cannot set HMAC key after calling update");
|
165 | }
|
166 | if (!0 === z) {
|
167 | throw Error("SHAKE is not supported for HMAC");
|
168 | }
|
169 | g = (h || {}).encoding || "UTF8";
|
170 | b = M(b, g, x)(a);
|
171 | a = b.binLen;
|
172 | b = b.value;
|
173 | k = m >>> 3;
|
174 | h = k / 4 - 1;
|
175 | if (k < a / 8) {
|
176 | for (b = u(b, a, 0, A(c), f); b.length <= h;) {
|
177 | b.push(0);
|
178 | }
|
179 | b[h] &= 4294967040
|
180 | } else if (k > a / 8) {
|
181 | for (; b.length <= h;) {
|
182 | b.push(0);
|
183 | }
|
184 | b[h] &= 4294967040
|
185 | }
|
186 | for (a = 0; a <= h; a += 1) {
|
187 | v[a] = b[a] ^ 909522486, w[a] = b[a]
|
188 | ^ 1549556828;
|
189 | }
|
190 | l = q(v, l);
|
191 | e = m;
|
192 | I = !0
|
193 | };
|
194 | this.update = function (a) {
|
195 | var c, b, k, f = 0, g = m >>> 5;
|
196 | c = d(a, h, n);
|
197 | a = c.binLen;
|
198 | b = c.value;
|
199 | c = a >>> 5;
|
200 | for (k = 0; k < c; k += g) {
|
201 | f + m <= a && (l = q(b.slice(k, k + g),
|
202 | l), f += m);
|
203 | }
|
204 | e += f;
|
205 | h = b.slice(f >>> 5);
|
206 | n = a % m;
|
207 | y = !0
|
208 | };
|
209 | this.getHash = function (a, b) {
|
210 | var k, g, d, m;
|
211 | if (!0 === I) {
|
212 | throw Error("Cannot call getHash after setting HMAC key");
|
213 | }
|
214 | d = N(b);
|
215 | if (!0 === z) {
|
216 | if (-1 === d.shakeLen) {
|
217 | throw Error(
|
218 | "shakeLen must be specified in options");
|
219 | }
|
220 | f = d.shakeLen
|
221 | }
|
222 | switch (a) {
|
223 | case "HEX":
|
224 | k = function (a) {
|
225 | return O(a, f, x, d)
|
226 | };
|
227 | break;
|
228 | case "B64":
|
229 | k = function (a) {
|
230 | return P(a, f, x, d)
|
231 | };
|
232 | break;
|
233 | case "BYTES":
|
234 | k = function (a) {
|
235 | return Q(a, f, x)
|
236 | };
|
237 | break;
|
238 | case "ARRAYBUFFER":
|
239 | try {
|
240 | g = new ArrayBuffer(0)
|
241 | } catch (p) {
|
242 | throw Error("ARRAYBUFFER not supported by this environment");
|
243 | }
|
244 | k = function (a) {
|
245 | return R(a, f, x)
|
246 | };
|
247 | break;
|
248 | default:
|
249 | throw Error("format must be HEX, B64, BYTES, or ARRAYBUFFER");
|
250 | }
|
251 | m = u(h.slice(), n, e, r(l), f);
|
252 | for (g = 1; g < t; g += 1) {
|
253 | !0 === z && 0 !== f % 32 && (m[m.length
|
254 | - 1] &= 16777215 >>> 24 - f % 32), m = u(m, f,
|
255 | 0, A(c), f);
|
256 | }
|
257 | return k(m)
|
258 | };
|
259 | this.getHMAC = function (a, b) {
|
260 | var k, g, d, p;
|
261 | if (!1 === I) {
|
262 | throw Error(
|
263 | "Cannot call getHMAC without first setting HMAC key");
|
264 | }
|
265 | d = N(b);
|
266 | switch (a) {
|
267 | case "HEX":
|
268 | k = function (a) {
|
269 | return O(a, f, x, d)
|
270 | };
|
271 | break;
|
272 | case "B64":
|
273 | k = function (a) {
|
274 | return P(a, f, x, d)
|
275 | };
|
276 | break;
|
277 | case "BYTES":
|
278 | k = function (a) {
|
279 | return Q(a, f, x)
|
280 | };
|
281 | break;
|
282 | case "ARRAYBUFFER":
|
283 | try {
|
284 | k = new ArrayBuffer(0)
|
285 | } catch (v) {
|
286 | throw Error("ARRAYBUFFER not supported by this environment");
|
287 | }
|
288 | k = function (a) {
|
289 | return R(a, f, x)
|
290 | };
|
291 | break;
|
292 | default:
|
293 | throw Error("outputFormat must be HEX, B64, BYTES, or ARRAYBUFFER");
|
294 | }
|
295 | g = u(h.slice(), n, e, r(l), f);
|
296 | p = q(w, A(c));
|
297 | p = u(g, f, m, p, f);
|
298 | return k(p)
|
299 | }
|
300 | }
|
301 |
|
302 | function b(c, a) {
|
303 | this.a = c;
|
304 | this.b = a
|
305 | }
|
306 |
|
307 | function O(c, a, b, e) {
|
308 | var h = "";
|
309 | a /= 8;
|
310 | var n, g, d;
|
311 | d = -1 === b ? 3 : 0;
|
312 | for (n = 0; n < a; n += 1) {
|
313 | g = c[n >>> 2] >>> 8 * (d + n % 4
|
314 | * b), h += "0123456789abcdef".charAt(g >>> 4 & 15)
|
315 | + "0123456789abcdef".charAt(g & 15);
|
316 | }
|
317 | return e.outputUpper ? h.toUpperCase() : h
|
318 | }
|
319 |
|
320 | function P(c, a, b, e) {
|
321 | var h = "", n = a / 8, g, d, p, f;
|
322 | f = -1 === b ? 3 : 0;
|
323 | for (g = 0; g < n; g += 3) {
|
324 | for (d = g + 1 < n ? c[g + 1 >>> 2] : 0, p = g
|
325 | + 2 < n ? c[g + 2 >>> 2] : 0, p = (c[g >>> 2] >>> 8 * (f + g % 4 * b)
|
326 | & 255)
|
327 | << 16 | (d >>> 8 * (f + (g + 1) % 4 * b) & 255) << 8 | p >>> 8 * (f +
|
328 | (g + 2) % 4 * b) & 255, d = 0; 4 > d; d += 1) {
|
329 | 8 * g + 6 * d <= a
|
330 | ? h += "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(p
|
331 | >>> 6 * (3 - d) & 63) : h += e.b64Pad;
|
332 | }
|
333 | }
|
334 | return h
|
335 | }
|
336 |
|
337 | function Q(c, a, b) {
|
338 | var e = "";
|
339 | a /= 8;
|
340 | var h, d, g;
|
341 | g = -1 === b ? 3 : 0;
|
342 | for (h = 0; h < a; h += 1) {
|
343 | d = c[h >>> 2] >>> 8 * (g + h % 4 * b)
|
344 | & 255, e += String.fromCharCode(d);
|
345 | }
|
346 | return e
|
347 | }
|
348 |
|
349 | function R(c, a, b) {
|
350 | a /= 8;
|
351 | var e, h = new ArrayBuffer(a), d, g;
|
352 | g = new Uint8Array(h);
|
353 | d = -1 === b ? 3 : 0;
|
354 | for (e = 0; e < a; e += 1) {
|
355 | g[e] = c[e >>> 2] >>> 8 * (d + e % 4 * b) & 255;
|
356 | }
|
357 | return h
|
358 | }
|
359 |
|
360 | function N(c) {
|
361 | var a = {outputUpper: !1, b64Pad: "=", shakeLen: -1};
|
362 | c = c || {};
|
363 | a.outputUpper = c.outputUpper || !1;
|
364 | !0 === c.hasOwnProperty("b64Pad") && (a.b64Pad = c.b64Pad);
|
365 | if (!0 === c.hasOwnProperty("shakeLen")) {
|
366 | if (0 !== c.shakeLen % 8) {
|
367 | throw Error("shakeLen must be a multiple of 8");
|
368 | }
|
369 | a.shakeLen = c.shakeLen
|
370 | }
|
371 | if ("boolean" !== typeof a.outputUpper) {
|
372 | throw Error(
|
373 | "Invalid outputUpper formatting option");
|
374 | }
|
375 | if ("string" !== typeof a.b64Pad) {
|
376 | throw Error(
|
377 | "Invalid b64Pad formatting option");
|
378 | }
|
379 | return a
|
380 | }
|
381 |
|
382 | function M(c, a, b) {
|
383 | switch (a) {
|
384 | case "UTF8":
|
385 | case "UTF16BE":
|
386 | case "UTF16LE":
|
387 | break;
|
388 | default:
|
389 | throw Error("encoding must be UTF8, UTF16BE, or UTF16LE");
|
390 | }
|
391 | switch (c) {
|
392 | case "HEX":
|
393 | c = function (a, c, d) {
|
394 | var g = a.length, l, p, f, m, q, u;
|
395 | if (0 !== g % 2) {
|
396 | throw Error(
|
397 | "String of HEX type must be in byte increments");
|
398 | }
|
399 | c = c || [0];
|
400 | d = d || 0;
|
401 | q = d >>> 3;
|
402 | u = -1 === b ? 3 : 0;
|
403 | for (l = 0; l < g; l += 2) {
|
404 | p = parseInt(a.substr(l, 2), 16);
|
405 | if (isNaN(p)) {
|
406 | throw Error(
|
407 | "String of HEX type contains invalid characters");
|
408 | }
|
409 | m = (l >>> 1) + q;
|
410 | for (f = m >>> 2; c.length <= f;) {
|
411 | c.push(0);
|
412 | }
|
413 | c[f] |= p << 8 * (u + m % 4 * b)
|
414 | }
|
415 | return {value: c, binLen: 4 * g + d}
|
416 | };
|
417 | break;
|
418 | case "TEXT":
|
419 | c = function (c, h, d) {
|
420 | var g, l, p = 0, f, m, q, u, r, t;
|
421 | h = h || [0];
|
422 | d = d || 0;
|
423 | q = d >>> 3;
|
424 | if ("UTF8" === a) {
|
425 | for (t = -1 ===
|
426 | b ? 3 : 0, f = 0; f < c.length; f += 1) {
|
427 | for (g = c.charCodeAt(
|
428 | f), l = [], 128 > g ? l.push(g) : 2048 > g ? (l.push(192 | g
|
429 | >>> 6), l.push(128 | g & 63)) : 55296 > g || 57344 <= g
|
430 | ? l.push(224 | g >>> 12, 128 | g >>> 6 & 63, 128 | g & 63)
|
431 | : (f += 1, g = 65536 + ((g & 1023) << 10 | c.charCodeAt(f)
|
432 | & 1023), l.push(240 | g >>> 18, 128 | g >>> 12 & 63, 128
|
433 | | g
|
434 | >>> 6 & 63, 128 | g & 63)), m = 0; m < l.length; m += 1) {
|
435 | r = p + q;
|
436 | for (u = r >>> 2; h.length <= u;) {
|
437 | h.push(0);
|
438 | }
|
439 | h[u] |= l[m] << 8 * (t + r % 4 * b);
|
440 | p += 1
|
441 | }
|
442 | }
|
443 | } else if ("UTF16BE" === a || "UTF16LE" === a) {
|
444 | for (t = -1 === b ? 2
|
445 | : 0, l = "UTF16LE" === a && 1 !== b || "UTF16LE" !== a && 1
|
446 | === b, f = 0; f < c.length; f += 1) {
|
447 | g = c.charCodeAt(f);
|
448 | !0 === l && (m = g & 255, g = m << 8 | g >>> 8);
|
449 | r = p + q;
|
450 | for (u = r >>> 2; h.length <= u;) {
|
451 | h.push(0);
|
452 | }
|
453 | h[u] |= g << 8 * (t + r % 4 * b);
|
454 | p += 2
|
455 | }
|
456 | }
|
457 | return {value: h, binLen: 8 * p + d}
|
458 | };
|
459 | break;
|
460 | case "B64":
|
461 | c = function (a, c, d) {
|
462 | var g = 0, l, p, f, m, q, u, r, t;
|
463 | if (-1 === a.search(/^[a-zA-Z0-9=+\/]+$/)) {
|
464 | throw Error(
|
465 | "Invalid character in base-64 string");
|
466 | }
|
467 | p = a.indexOf("=");
|
468 | a = a.replace(/\=/g, "");
|
469 | if (-1 !== p && p < a.length) {
|
470 | throw Error(
|
471 | "Invalid '=' found in base-64 string");
|
472 | }
|
473 | c = c || [0];
|
474 | d = d || 0;
|
475 | u = d >>> 3;
|
476 | t = -1 === b ? 3 : 0;
|
477 | for (p = 0; p < a.length; p += 4) {
|
478 | q = a.substr(p, 4);
|
479 | for (f = m = 0; f < q.length;
|
480 | f += 1) {
|
481 | l = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".indexOf(
|
482 | q[f]),
|
483 | m |= l << 18 - 6 * f;
|
484 | }
|
485 | for (f = 0; f < q.length - 1; f += 1) {
|
486 | r = g + u;
|
487 | for (l = r >>> 2; c.length <= l;) {
|
488 | c.push(0);
|
489 | }
|
490 | c[l] |= (m >>> 16 - 8 * f & 255) << 8 * (t + r % 4 * b);
|
491 | g += 1
|
492 | }
|
493 | }
|
494 | return {value: c, binLen: 8 * g + d}
|
495 | };
|
496 | break;
|
497 | case "BYTES":
|
498 | c = function (a, c, d) {
|
499 | var g, l, p, f, m, q;
|
500 | c = c || [0];
|
501 | d = d || 0;
|
502 | p = d >>> 3;
|
503 | q = -1 === b ? 3 : 0;
|
504 | for (l = 0; l < a.length; l += 1) {
|
505 | g = a.charCodeAt(l), m = l
|
506 | + p, f = m >>> 2, c.length <= f && c.push(0), c[f] |= g << 8
|
507 | * (q
|
508 | + m % 4 * b);
|
509 | }
|
510 | return {value: c, binLen: 8 * a.length + d}
|
511 | };
|
512 | break;
|
513 | case "ARRAYBUFFER":
|
514 | try {
|
515 | c = new ArrayBuffer(0)
|
516 | } catch (e) {
|
517 | throw Error("ARRAYBUFFER not supported by this environment");
|
518 | }
|
519 | c =
|
520 | function (a, c, d) {
|
521 | var g, l, p, f, m, q;
|
522 | c = c || [0];
|
523 | d = d || 0;
|
524 | l = d >>> 3;
|
525 | m = -1 === b ? 3 : 0;
|
526 | q = new Uint8Array(a);
|
527 | for (g = 0; g < a.byteLength; g += 1) {
|
528 | f = g + l, p = f
|
529 | >>> 2, c.length <= p && c.push(0), c[p] |= q[g] << 8 * (m
|
530 | + f
|
531 | % 4 * b);
|
532 | }
|
533 | return {value: c, binLen: 8 * a.byteLength + d}
|
534 | };
|
535 | break;
|
536 | default:
|
537 | throw Error("format must be HEX, TEXT, B64, BYTES, or ARRAYBUFFER");
|
538 | }
|
539 | return c
|
540 | }
|
541 |
|
542 | function y(c, a) {
|
543 | return c << a | c >>> 32 - a
|
544 | }
|
545 |
|
546 | function S(c, a) {
|
547 | return 32 < a ? (a -= 32, new b(c.b << a | c.a >>> 32 - a, c.a << a | c.b
|
548 | >>> 32 - a)) : 0 !== a ? new b(c.a << a | c.b >>> 32 - a, c.b << a | c.a
|
549 | >>> 32 - a) : c
|
550 | }
|
551 |
|
552 | function w(c, a) {
|
553 | return c >>>
|
554 | a | c << 32 - a
|
555 | }
|
556 |
|
557 | function t(c, a) {
|
558 | var k = null, k = new b(c.a, c.b);
|
559 | return k = 32 >= a ? new b(k.a >>> a | k.b << 32 - a & 4294967295, k.b >>> a
|
560 | | k.a << 32 - a & 4294967295) : new b(k.b >>> a - 32 | k.a << 64 - a
|
561 | & 4294967295, k.a >>> a - 32 | k.b << 64 - a & 4294967295)
|
562 | }
|
563 |
|
564 | function T(c, a) {
|
565 | var k = null;
|
566 | return k = 32 >= a ? new b(c.a >>> a, c.b >>> a | c.a << 32 - a
|
567 | & 4294967295) : new b(0, c.a >>> a - 32)
|
568 | }
|
569 |
|
570 | function aa(c, a, b) {
|
571 | return c & a ^ ~c & b
|
572 | }
|
573 |
|
574 | function ba(c, a, k) {
|
575 | return new b(c.a & a.a ^ ~c.a & k.a, c.b & a.b ^ ~c.b & k.b)
|
576 | }
|
577 |
|
578 | function U(c, a, b) {
|
579 | return c & a ^ c & b ^ a & b
|
580 | }
|
581 |
|
582 | function ca(c, a, k) {
|
583 | return new b(c.a & a.a ^ c.a & k.a ^ a.a &
|
584 | k.a, c.b & a.b ^ c.b & k.b ^ a.b & k.b)
|
585 | }
|
586 |
|
587 | function da(c) {
|
588 | return w(c, 2) ^ w(c, 13) ^ w(c, 22)
|
589 | }
|
590 |
|
591 | function ea(c) {
|
592 | var a = t(c, 28), k = t(c, 34);
|
593 | c = t(c, 39);
|
594 | return new b(a.a ^ k.a ^ c.a, a.b ^ k.b ^ c.b)
|
595 | }
|
596 |
|
597 | function fa(c) {
|
598 | return w(c, 6) ^ w(c, 11) ^ w(c, 25)
|
599 | }
|
600 |
|
601 | function ga(c) {
|
602 | var a = t(c, 14), k = t(c, 18);
|
603 | c = t(c, 41);
|
604 | return new b(a.a ^ k.a ^ c.a, a.b ^ k.b ^ c.b)
|
605 | }
|
606 |
|
607 | function ha(c) {
|
608 | return w(c, 7) ^ w(c, 18) ^ c >>> 3
|
609 | }
|
610 |
|
611 | function ia(c) {
|
612 | var a = t(c, 1), k = t(c, 8);
|
613 | c = T(c, 7);
|
614 | return new b(a.a ^ k.a ^ c.a, a.b ^ k.b ^ c.b)
|
615 | }
|
616 |
|
617 | function ja(c) {
|
618 | return w(c, 17) ^ w(c, 19) ^ c >>> 10
|
619 | }
|
620 |
|
621 | function ka(c) {
|
622 | var a = t(c, 19), k = t(c, 61);
|
623 | c = T(c, 6);
|
624 | return new b(a.a ^ k.a ^ c.a, a.b ^ k.b ^ c.b)
|
625 | }
|
626 |
|
627 | function G(c, a) {
|
628 | var b = (c & 65535) + (a & 65535);
|
629 | return ((c >>> 16) + (a >>> 16) + (b >>> 16) & 65535) << 16 | b & 65535
|
630 | }
|
631 |
|
632 | function la(c, a, b, e) {
|
633 | var h = (c & 65535) + (a & 65535) + (b & 65535) + (e & 65535);
|
634 | return ((c >>> 16) + (a >>> 16) + (b >>> 16) + (e >>> 16) + (h >>> 16)
|
635 | & 65535) << 16 | h & 65535
|
636 | }
|
637 |
|
638 | function H(c, a, b, e, h) {
|
639 | var d = (c & 65535) + (a & 65535) + (b & 65535) + (e & 65535) + (h & 65535);
|
640 | return ((c >>> 16) + (a >>> 16) + (b >>> 16) + (e >>> 16) + (h >>> 16) + (d
|
641 | >>> 16) & 65535) << 16 | d & 65535
|
642 | }
|
643 |
|
644 | function ma(c, a) {
|
645 | var d, e, h;
|
646 | d = (c.b & 65535) + (a.b & 65535);
|
647 | e = (c.b >>> 16) +
|
648 | (a.b >>> 16) + (d >>> 16);
|
649 | h = (e & 65535) << 16 | d & 65535;
|
650 | d = (c.a & 65535) + (a.a & 65535) + (e >>> 16);
|
651 | e = (c.a >>> 16) + (a.a >>> 16) + (d >>> 16);
|
652 | return new b((e & 65535) << 16 | d & 65535, h)
|
653 | }
|
654 |
|
655 | function na(c, a, d, e) {
|
656 | var h, n, g;
|
657 | h = (c.b & 65535) + (a.b & 65535) + (d.b & 65535) + (e.b & 65535);
|
658 | n = (c.b >>> 16) + (a.b >>> 16) + (d.b >>> 16) + (e.b >>> 16) + (h >>> 16);
|
659 | g = (n & 65535) << 16 | h & 65535;
|
660 | h = (c.a & 65535) + (a.a & 65535) + (d.a & 65535) + (e.a & 65535) + (n
|
661 | >>> 16);
|
662 | n = (c.a >>> 16) + (a.a >>> 16) + (d.a >>> 16) + (e.a >>> 16) + (h >>> 16);
|
663 | return new b((n & 65535) << 16 | h & 65535, g)
|
664 | }
|
665 |
|
666 | function oa(c, a, d, e, h) {
|
667 | var n, g, l;
|
668 | n = (c.b &
|
669 | 65535) + (a.b & 65535) + (d.b & 65535) + (e.b & 65535) + (h.b & 65535);
|
670 | g = (c.b >>> 16) + (a.b >>> 16) + (d.b >>> 16) + (e.b >>> 16) + (h.b >>> 16)
|
671 | + (n >>> 16);
|
672 | l = (g & 65535) << 16 | n & 65535;
|
673 | n = (c.a & 65535) + (a.a & 65535) + (d.a & 65535) + (e.a & 65535) + (h.a
|
674 | & 65535) + (g >>> 16);
|
675 | g = (c.a >>> 16) + (a.a >>> 16) + (d.a >>> 16) + (e.a >>> 16) + (h.a >>> 16)
|
676 | + (n >>> 16);
|
677 | return new b((g & 65535) << 16 | n & 65535, l)
|
678 | }
|
679 |
|
680 | function B(c, a) {
|
681 | return new b(c.a ^ a.a, c.b ^ a.b)
|
682 | }
|
683 |
|
684 | function A(c) {
|
685 | var a = [], d;
|
686 | if ("SHA-1" === c) {
|
687 | a = [1732584193, 4023233417, 2562383102, 271733878,
|
688 | 3285377520];
|
689 | } else if (0 === c.lastIndexOf("SHA-", 0)) {
|
690 | switch (a =
|
691 | [3238371032, 914150663, 812702999, 4144912697, 4290775857, 1750603025,
|
692 | 1694076839, 3204075428], d = [1779033703, 3144134277, 1013904242,
|
693 | 2773480762, 1359893119, 2600822924, 528734635, 1541459225], c) {
|
694 | case "SHA-224":
|
695 | break;
|
696 | case "SHA-256":
|
697 | a = d;
|
698 | break;
|
699 | case "SHA-384":
|
700 | a = [new b(3418070365, a[0]), new b(1654270250, a[1]),
|
701 | new b(2438529370, a[2]), new b(355462360, a[3]),
|
702 | new b(1731405415, a[4]), new b(41048885895, a[5]),
|
703 | new b(3675008525, a[6]), new b(1203062813, a[7])];
|
704 | break;
|
705 | case "SHA-512":
|
706 | a = [new b(d[0], 4089235720), new b(d[1], 2227873595),
|
707 | new b(d[2], 4271175723), new b(d[3], 1595750129),
|
708 | new b(d[4], 2917565137), new b(d[5], 725511199),
|
709 | new b(d[6], 4215389547), new b(d[7], 327033209)];
|
710 | break;
|
711 | default:
|
712 | throw Error("Unknown SHA variant");
|
713 | }
|
714 | } else if (0 === c.lastIndexOf("SHA3-", 0) || 0 === c.lastIndexOf("SHAKE",
|
715 | 0)) {
|
716 | for (c = 0; 5 > c; c += 1) {
|
717 | a[c] = [new b(0, 0), new b(0, 0),
|
718 | new b(0, 0), new b(0, 0), new b(0, 0)];
|
719 | }
|
720 | } else {
|
721 | throw Error(
|
722 | "No SHA variants supported");
|
723 | }
|
724 | return a
|
725 | }
|
726 |
|
727 | function K(c, a) {
|
728 | var b = [], e, d, n, g, l, p, f;
|
729 | e = a[0];
|
730 | d = a[1];
|
731 | n = a[2];
|
732 | g = a[3];
|
733 | l = a[4];
|
734 | for (f = 0; 80 > f; f += 1) {
|
735 | b[f] = 16 > f ? c[f] : y(b[f -
|
736 | 3] ^ b[f - 8] ^ b[f - 14] ^ b[f - 16], 1), p = 20 > f ? H(y(e, 5), d & n
|
737 | ^ ~d & g, l, 1518500249, b[f]) : 40 > f ? H(y(e, 5), d ^ n ^ g, l,
|
738 | 1859775393, b[f]) : 60 > f ? H(y(e, 5), U(d, n, g), l, 2400959708,
|
739 | b[f])
|
740 | : H(y(e, 5), d ^ n ^ g, l, 3395469782, b[f]), l = g, g = n, n = y(d,
|
741 | 30), d = e, e = p;
|
742 | }
|
743 | a[0] = G(e, a[0]);
|
744 | a[1] = G(d, a[1]);
|
745 | a[2] = G(n, a[2]);
|
746 | a[3] = G(g, a[3]);
|
747 | a[4] = G(l, a[4]);
|
748 | return a
|
749 | }
|
750 |
|
751 | function Z(c, a, b, e) {
|
752 | var d;
|
753 | for (d = (a + 65 >>> 9 << 4) + 15; c.length <= d;) {
|
754 | c.push(0);
|
755 | }
|
756 | c[a >>> 5] |= 128 << 24 - a % 32;
|
757 | a += b;
|
758 | c[d] = a & 4294967295;
|
759 | c[d - 1] = a / 4294967296 | 0;
|
760 | a = c.length;
|
761 | for (d = 0; d < a; d += 16) {
|
762 | e = K(c.slice(d, d + 16), e);
|
763 | }
|
764 | return e
|
765 | }
|
766 |
|
767 | function L(c,
|
768 | a, k) {
|
769 | var e, h, n, g, l, p, f, m, q, u, r, t, v, w, y, A, z, x, F, B, C, D,
|
770 | E = [], J;
|
771 | if ("SHA-224" === k || "SHA-256"
|
772 | === k) {
|
773 | u = 64, t = 1, D = Number, v = G, w = la, y = H, A = ha, z = ja, x = da, F = fa, C = U, B = aa, J = d;
|
774 | } else if ("SHA-384"
|
775 | === k || "SHA-512"
|
776 | === k) {
|
777 | u = 80, t = 2, D = b, v = ma, w = na, y = oa, A = ia, z = ka, x = ea, F = ga, C = ca, B = ba, J = V;
|
778 | } else {
|
779 | throw Error(
|
780 | "Unexpected error in SHA-2 implementation");
|
781 | }
|
782 | k = a[0];
|
783 | e = a[1];
|
784 | h = a[2];
|
785 | n = a[3];
|
786 | g = a[4];
|
787 | l = a[5];
|
788 | p = a[6];
|
789 | f = a[7];
|
790 | for (r = 0; r < u; r += 1) {
|
791 | 16 > r ? (q = r * t, m = c.length <= q ? 0
|
792 | : c[q], q = c.length <= q + 1 ? 0 : c[q + 1], E[r] = new D(m, q))
|
793 | : E[r] = w(z(E[r - 2]), E[r - 7], A(E[r - 15]), E[r -
|
794 | 16]), m = y(f, F(g), B(g, l, p), J[r], E[r]), q = v(x(k),
|
795 | C(k, e, h)), f = p, p = l, l = g, g = v(n,
|
796 | m), n = h, h = e, e = k, k = v(m, q);
|
797 | }
|
798 | a[0] = v(k, a[0]);
|
799 | a[1] = v(e, a[1]);
|
800 | a[2] = v(h, a[2]);
|
801 | a[3] = v(n, a[3]);
|
802 | a[4] = v(g, a[4]);
|
803 | a[5] = v(l, a[5]);
|
804 | a[6] = v(p, a[6]);
|
805 | a[7] = v(f, a[7]);
|
806 | return a
|
807 | }
|
808 |
|
809 | function D(c, a) {
|
810 | var d, e, h, n, g = [], l = [];
|
811 | if (null !== c) {
|
812 | for (e = 0; e < c.length; e += 2) {
|
813 | a[(e >>> 1) % 5][(e >>> 1)
|
814 | / 5 | 0] = B(a[(e >>> 1) % 5][(e >>> 1) / 5 | 0],
|
815 | new b(c[e + 1], c[e]));
|
816 | }
|
817 | }
|
818 | for (d = 0; 24 > d; d += 1) {
|
819 | n = A("SHA3-");
|
820 | for (e = 0; 5 > e; e += 1) {
|
821 | h = a[e][0];
|
822 | var p = a[e][1], f = a[e][2], m = a[e][3], q = a[e][4];
|
823 | g[e] = new b(h.a ^ p.a ^ f.a ^
|
824 | m.a ^ q.a, h.b ^ p.b ^ f.b ^ m.b ^ q.b)
|
825 | }
|
826 | for (e = 0; 5 > e; e += 1) {
|
827 | l[e] = B(g[(e + 4) % 5], S(g[(e + 1) % 5], 1));
|
828 | }
|
829 | for (e = 0; 5 > e; e += 1) {
|
830 | for (h = 0; 5 > h; h += 1) {
|
831 | a[e][h] = B(a[e][h],
|
832 | l[e]);
|
833 | }
|
834 | }
|
835 | for (e = 0; 5 > e; e += 1) {
|
836 | for (h = 0; 5 > h; h += 1) {
|
837 | n[h][(2 * e + 3 * h)
|
838 | % 5] = S(a[e][h], W[e][h]);
|
839 | }
|
840 | }
|
841 | for (e = 0; 5 > e; e += 1) {
|
842 | for (h = 0; 5 > h; h += 1) {
|
843 | a[e][h] = B(n[e][h],
|
844 | new b(~n[(e + 1) % 5][h].a & n[(e + 2) % 5][h].a, ~n[(e + 1)
|
845 | % 5][h].b
|
846 | & n[(e + 2) % 5][h].b));
|
847 | }
|
848 | }
|
849 | a[0][0] = B(a[0][0], X[d])
|
850 | }
|
851 | return a
|
852 | }
|
853 |
|
854 | var d, V, W, X;
|
855 | d = [1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993,
|
856 | 2453635748, 2870763221, 3624381080, 310598401, 607225278,
|
857 | 1426881987, 1925078388, 2162078206, 2614888103, 3248222580, 3835390401,
|
858 | 4022224774, 264347078, 604807628, 770255983, 1249150122, 1555081692,
|
859 | 1996064986, 2554220882, 2821834349, 2952996808, 3210313671, 3336571891,
|
860 | 3584528711, 113926993, 338241895, 666307205, 773529912, 1294757372,
|
861 | 1396182291, 1695183700, 1986661051, 2177026350, 2456956037, 2730485921,
|
862 | 2820302411, 3259730800, 3345764771, 3516065817, 3600352804, 4094571909,
|
863 | 275423344, 430227734, 506948616, 659060556, 883997877, 958139571,
|
864 | 1322822218, 1537002063, 1747873779, 1955562222, 2024104815,
|
865 | 2227730452, 2361852424, 2428436474, 2756734187, 3204031479, 3329325298];
|
866 | V = [new b(d[0], 3609767458), new b(d[1], 602891725), new b(d[2], 3964484399),
|
867 | new b(d[3], 2173295548), new b(d[4], 4081628472), new b(d[5], 3053834265),
|
868 | new b(d[6], 2937671579), new b(d[7], 3664609560), new b(d[8], 2734883394),
|
869 | new b(d[9], 1164996542), new b(d[10], 1323610764), new b(d[11], 3590304994),
|
870 | new b(d[12], 4068182383), new b(d[13], 991336113), new b(d[14], 633803317),
|
871 | new b(d[15], 3479774868), new b(d[16], 2666613458), new b(d[17], 944711139),
|
872 | new b(d[18], 2341262773),
|
873 | new b(d[19], 2007800933), new b(d[20], 1495990901),
|
874 | new b(d[21], 1856431235), new b(d[22], 3175218132),
|
875 | new b(d[23], 2198950837), new b(d[24], 3999719339), new b(d[25], 766784016),
|
876 | new b(d[26], 2566594879), new b(d[27], 3203337956),
|
877 | new b(d[28], 1034457026), new b(d[29], 2466948901),
|
878 | new b(d[30], 3758326383), new b(d[31], 168717936), new b(d[32], 1188179964),
|
879 | new b(d[33], 1546045734), new b(d[34], 1522805485),
|
880 | new b(d[35], 2643833823), new b(d[36], 2343527390),
|
881 | new b(d[37], 1014477480), new b(d[38], 1206759142), new b(d[39], 344077627),
|
882 | new b(d[40], 1290863460), new b(d[41], 3158454273),
|
883 | new b(d[42], 3505952657), new b(d[43], 106217008), new b(d[44], 3606008344),
|
884 | new b(d[45], 1432725776), new b(d[46], 1467031594), new b(d[47], 851169720),
|
885 | new b(d[48], 3100823752), new b(d[49], 1363258195),
|
886 | new b(d[50], 3750685593), new b(d[51], 3785050280),
|
887 | new b(d[52], 3318307427), new b(d[53], 3812723403),
|
888 | new b(d[54], 2003034995), new b(d[55], 3602036899),
|
889 | new b(d[56], 1575990012), new b(d[57], 1125592928),
|
890 | new b(d[58], 2716904306), new b(d[59], 442776044), new b(d[60], 593698344),
|
891 | new b(d[61],
|
892 | 3733110249), new b(d[62], 2999351573), new b(d[63], 3815920427),
|
893 | new b(3391569614, 3928383900), new b(3515267271, 566280711),
|
894 | new b(3940187606, 3454069534), new b(4118630271, 4000239992),
|
895 | new b(116418474, 1914138554), new b(174292421, 2731055270),
|
896 | new b(289380356, 3203993006), new b(460393269, 320620315),
|
897 | new b(685471733, 587496836), new b(852142971, 1086792851),
|
898 | new b(1017036298, 365543100), new b(1126000580, 2618297676),
|
899 | new b(1288033470, 3409855158), new b(1501505948, 4234509866),
|
900 | new b(1607167915, 987167468), new b(1816402316,
|
901 | 1246189591)];
|
902 | X = [new b(0, 1), new b(0, 32898), new b(2147483648, 32906),
|
903 | new b(2147483648, 2147516416), new b(0, 32907), new b(0, 2147483649),
|
904 | new b(2147483648, 2147516545), new b(2147483648, 32777), new b(0, 138),
|
905 | new b(0, 136), new b(0, 2147516425), new b(0, 2147483658),
|
906 | new b(0, 2147516555), new b(2147483648, 139), new b(2147483648, 32905),
|
907 | new b(2147483648, 32771), new b(2147483648, 32770), new b(2147483648, 128),
|
908 | new b(0, 32778), new b(2147483648, 2147483658),
|
909 | new b(2147483648, 2147516545), new b(2147483648, 32896),
|
910 | new b(0, 2147483649),
|
911 | new b(2147483648, 2147516424)];
|
912 | W = [[0, 36, 3, 41, 18], [1, 44, 10, 45, 2], [62, 6, 43, 15, 61],
|
913 | [28, 55, 25, 21, 56], [27, 20, 39, 8, 14]];
|
914 | "function" === typeof define && define.amd ? define(function () {
|
915 | return C
|
916 | }) : "undefined" !== typeof exports ? ("undefined" !== typeof module
|
917 | && module.exports && (module.exports = C), exports = C) : Y.jsSHA = C
|
918 | })(this);
|