|
|
@@ -0,0 +1,3632 @@
|
|
|
+/********************************************/
|
|
|
+/* */
|
|
|
+/* Copyright (c) 2020 Aostar */
|
|
|
+/* @author bgu */
|
|
|
+/* @version 2.9 */
|
|
|
+/* */
|
|
|
+/********************************************/
|
|
|
+
|
|
|
+function K(src, ei, ed, eo, dm) {
|
|
|
+ var gX = dm;
|
|
|
+ if (ei + dm > src.length && eo + dm <= ed.length) {
|
|
|
+ gX = src.length - ei;
|
|
|
+ } else if (eo + dm > ed.length && ei + dm <= src.length) {
|
|
|
+ gX = ed.length - eo;
|
|
|
+ } else if (ei + dm <= src.length && eo + dm <= ed.length) {
|
|
|
+ gX = dm;
|
|
|
+ } else if (ed.length < src.length) {
|
|
|
+ gX = ed.length - eo;
|
|
|
+ } else {
|
|
|
+ gX = src.length - eo;
|
|
|
+ }
|
|
|
+ for (var i = 0; i < gX; i++) {
|
|
|
+ ed[i + eo] = src[i + ei];
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+function co(jr, ei, ij, eo, dm) {
|
|
|
+ if (jr.length - ei < dm) {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ if (ij.length - eo < dm) {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ for (var i = 0; i < dm; i++) {
|
|
|
+ if (jr[ei++] != ij[eo++]) {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+};
|
|
|
+
|
|
|
+function F(hA) {
|
|
|
+ return new Array((hA >> 24) & 0x000000FF, (hA >> 16) & 0x000000FF, (hA >> 8) & 0x000000FF, (hA) & 0x000000FF);
|
|
|
+};
|
|
|
+
|
|
|
+function ap(gL) {
|
|
|
+ var b = new Array(gL.length * 4);
|
|
|
+ for (var i = 0; i < gL.length; i++) {
|
|
|
+ K(F(gL[i]), 0, b, i * 4, 4);
|
|
|
+ }
|
|
|
+ return b;
|
|
|
+};
|
|
|
+
|
|
|
+function bB(b, pos) {
|
|
|
+ if (pos + 3 < b.length) {
|
|
|
+ return ((b[pos]) << 24) | ((b[pos + 1]) << 16) | ((b[pos + 2]) << 8) | ((b[pos + 3]));
|
|
|
+ } else if (pos + 2 < b.length) {
|
|
|
+ return ((b[pos + 1]) << 16) | ((b[pos + 2]) << 8) | ((b[pos + 3]));
|
|
|
+ } else if (pos + 1 < b.length) {
|
|
|
+ return ((b[pos]) << 8) | ((b[pos + 1]));
|
|
|
+ } else {
|
|
|
+ return ((b[pos]));
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+function aI(b) {
|
|
|
+ var kF = Math.ceil(b.length / 4);
|
|
|
+ var out = new Array(kF);
|
|
|
+ for (var i = 0; i < b.length; i++) {
|
|
|
+ b[i] = b[i] & 0xFF;
|
|
|
+ }
|
|
|
+ for (var i = 0; i < out.length; i++) {
|
|
|
+ out[i] = bB(b, i * 4);
|
|
|
+ }
|
|
|
+ return out;
|
|
|
+};
|
|
|
+var CommonUtils = {
|
|
|
+ bytesToHex: function (ev) {
|
|
|
+ var dm = ev.length;
|
|
|
+ var dg = new Array(dm * 2);
|
|
|
+ var ju = new Array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F');
|
|
|
+ for (var i = 0, j = 0; i < dm; i++, j++) {
|
|
|
+ dg[j] = ju[(ev[i] & 0xFF) >> 4];
|
|
|
+ dg[++j] = ju[(ev[i] & 0x0F)];
|
|
|
+ }
|
|
|
+ return dg.join('');
|
|
|
+ },
|
|
|
+ hexToBytes: function (hC) {
|
|
|
+ if (hC == null || hC == '') {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (hC.length % 2 != 0) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var il = hC.length / 2;
|
|
|
+ var dg = this.jY(hC);
|
|
|
+ var eG = new Array(il);
|
|
|
+ for (var i = 0; i < il; i++) {
|
|
|
+ if (dg[2 * i] >= 0x30 && dg[2 * i] <= 0x39) {
|
|
|
+ eG[i] = ((dg[2 * i] - 0x30) << 4);
|
|
|
+ } else if (dg[2 * i] >= 0x41 && dg[2 * i] <= 0x46) {
|
|
|
+ eG[i] = ((dg[2 * i] - 0x41 + 10) << 4);
|
|
|
+ } else if (dg[2 * i] >= 0x61 && dg[2 * i] <= 0x66) {
|
|
|
+ eG[i] = ((dg[2 * i] - 0x61 + 10) << 4);
|
|
|
+ } else {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (dg[2 * i + 1] >= 0x30 && dg[2 * i + 1] <= 0x39) {
|
|
|
+ eG[i] = (eG[i] | (dg[2 * i + 1] - 0x30));
|
|
|
+ } else if (dg[2 * i + 1] >= 0x41 && dg[2 * i + 1] <= 0x46) {
|
|
|
+ eG[i] = (eG[i] | (dg[2 * i + 1] - 0x41 + 10));
|
|
|
+ } else if (dg[2 * i + 1] >= 0x61 && dg[2 * i + 1] <= 0x66) {
|
|
|
+ eG[i] = (eG[i] | (dg[2 * i + 1] - 0x61 + 10));
|
|
|
+ } else {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return eG;
|
|
|
+ },
|
|
|
+ utf8StrToHex: function (fT) {
|
|
|
+ var iG = encodeURIComponent(fT);
|
|
|
+ var gA = unescape(iG);
|
|
|
+ var iY = gA.length;
|
|
|
+ var eN = [];
|
|
|
+ for (var i = 0; i < iY; i++) {
|
|
|
+ eN[i] = (gA.charCodeAt(i).toString(16)).toUpperCase();
|
|
|
+ }
|
|
|
+ return eN.join('');
|
|
|
+ },
|
|
|
+ utf8StrToBytes: function (fT) {
|
|
|
+ var iG = encodeURIComponent(fT);
|
|
|
+ var gA = unescape(iG);
|
|
|
+ var iY = gA.length;
|
|
|
+ var eN = [];
|
|
|
+ for (var i = 0; i < iY; i++) {
|
|
|
+ eN[i] = gA.charCodeAt(i);
|
|
|
+ }
|
|
|
+ return eN;
|
|
|
+ },
|
|
|
+ hexToUtf8Str: function (fT) {
|
|
|
+ var gn = CommonUtils.hexToBytes(fT);
|
|
|
+ var gE = [];
|
|
|
+ for (var i = 0; i < gn.length; i++) {
|
|
|
+ gE.push(String.fromCharCode(gn[i]));
|
|
|
+ }
|
|
|
+ return decodeURIComponent(escape(gE.join('')));
|
|
|
+ },
|
|
|
+ bytesToUtf8Str: function (kt) {
|
|
|
+ var gn = kt;
|
|
|
+ var gE = [];
|
|
|
+ for (var i = 0; i < gn.length; i++) {
|
|
|
+ gE.push(String.fromCharCode(gn[i]));
|
|
|
+ }
|
|
|
+ return decodeURIComponent(escape(gE.join('')));
|
|
|
+ },
|
|
|
+ jY: function (hN) {
|
|
|
+ var iW = new Array(hN.length);
|
|
|
+ for (var i = 0; i < hN.length; i++) {
|
|
|
+ iW[i] = hN.charCodeAt(i);
|
|
|
+ }
|
|
|
+ return iW;
|
|
|
+ },
|
|
|
+ isHexString: function (fL) {
|
|
|
+ var pattern = new RegExp(/^[A-Za-z0-9]+$/);
|
|
|
+ return fL != null && pattern.test(fL);
|
|
|
+ },
|
|
|
+ randomWord: function (dm) {
|
|
|
+ var fL = "";
|
|
|
+ var hF = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
|
|
|
+ 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E',
|
|
|
+ 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
|
|
|
+ '~', '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_'
|
|
|
+ ];
|
|
|
+ for (var i = 0; i < dm; i++) {
|
|
|
+ pos = Math.round(Math.random() * (hF.length - 1));
|
|
|
+ fL += hF[pos];
|
|
|
+ }
|
|
|
+ return fL;
|
|
|
+ },
|
|
|
+ randomHex: function (dm) {
|
|
|
+ var fL = "";
|
|
|
+ var hF = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
|
|
|
+ for (var i = 0; i < dm; i++) {
|
|
|
+ pos = Math.round(Math.random() * (hF.length - 1));
|
|
|
+ fL += hF[pos];
|
|
|
+ }
|
|
|
+ return fL;
|
|
|
+ },
|
|
|
+ equals: function (eH, fv) {
|
|
|
+ for (fK in eH) {
|
|
|
+ if (eH.hasOwnProperty(fK) != fv.hasOwnProperty(fK)) {
|
|
|
+ return false;
|
|
|
+ } else if (typeof eH[fK] != typeof fv[fK]) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ for (fK in fv) {
|
|
|
+ if (eH.hasOwnProperty(fK) != fv.hasOwnProperty(fK)) {
|
|
|
+ return false;
|
|
|
+ } else if (typeof eH[fK] != typeof fv[fK]) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (!eH.hasOwnProperty(fK)) continue;
|
|
|
+ if (eH[fK] instanceof Array && fv[fK] instanceof Array) {
|
|
|
+ if (!eH[fK].equals(fv[fK])) return false;
|
|
|
+ } else if (eH[fK] instanceof Object && fv[fK] instanceof Object) {
|
|
|
+ if (!eH[fK].equals(fv[fK])) return false;
|
|
|
+ } else if (eH[fK] != fv[fK]) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ },
|
|
|
+ v_ltd: function () {
|
|
|
+ var word = new jW.mG.mP.gD([-442786843, -1214389064, -1377332043, -443502618, -1735465320, -1612398687, -
|
|
|
+ 427708442, -1971263844, -1343841143, -375811867, -2052266609, -1207959552
|
|
|
+ ]);
|
|
|
+ var text = word.toString(jW.ey.nj);
|
|
|
+ return text;
|
|
|
+ }
|
|
|
+};
|
|
|
+var ep;
|
|
|
+var kK = 0xdeadbeefcafe;
|
|
|
+var iL = ((kK & 0xffffff) == 0xefcafe);
|
|
|
+
|
|
|
+function L(a, b, c) {
|
|
|
+ if (a != null)
|
|
|
+ if ("number" == typeof a) this.iM(a, b, c);
|
|
|
+ else if (b == null && "string" != typeof a) this.hK(a, 256);
|
|
|
+ else this.hK(a, b);
|
|
|
+};
|
|
|
+
|
|
|
+function C() {
|
|
|
+ return new L(null);
|
|
|
+};
|
|
|
+
|
|
|
+function al(i, x, w, j, c, n) {
|
|
|
+ while (--n >= 0) {
|
|
|
+ var v = x * this[i++] + w[j] + c;
|
|
|
+ c = Math.floor(v / 0x4000000);
|
|
|
+ w[j++] = v & 0x3ffffff;
|
|
|
+ }
|
|
|
+ return c;
|
|
|
+};
|
|
|
+
|
|
|
+function bD(i, x, w, j, c, n) {
|
|
|
+ var gw = x & 0x7fff,
|
|
|
+ gl = x >> 15;
|
|
|
+ while (--n >= 0) {
|
|
|
+ var l = this[i] & 0x7fff;
|
|
|
+ var h = this[i++] >> 15;
|
|
|
+ var m = gl * l + h * gw;
|
|
|
+ l = gw * l + ((m & 0x7fff) << 15) + w[j] + (c & 0x3fffffff);
|
|
|
+ c = (l >>> 30) + (m >>> 15) + gl * h + (c >>> 30);
|
|
|
+ w[j++] = l & 0x3fffffff;
|
|
|
+ }
|
|
|
+ return c;
|
|
|
+};
|
|
|
+
|
|
|
+function dK(i, x, w, j, c, n) {
|
|
|
+ var gw = x & 0x3fff,
|
|
|
+ gl = x >> 14;
|
|
|
+ while (--n >= 0) {
|
|
|
+ var l = this[i] & 0x3fff;
|
|
|
+ var h = this[i++] >> 14;
|
|
|
+ var m = gl * l + h * gw;
|
|
|
+ l = gw * l + ((m & 0x3fff) << 14) + w[j] + c;
|
|
|
+ c = (l >> 28) + (m >> 14) + gl * h;
|
|
|
+ w[j++] = l & 0xfffffff;
|
|
|
+ }
|
|
|
+ return c;
|
|
|
+};
|
|
|
+if (iL && (navigator.appName == "Microsoft Internet Explorer")) {
|
|
|
+ L.prototype.eZ = bD;
|
|
|
+ ep = 30;
|
|
|
+} else if (iL && (navigator.appName != "Netscape")) {
|
|
|
+ L.prototype.eZ = al;
|
|
|
+ ep = 26;
|
|
|
+} else {
|
|
|
+ L.prototype.eZ = dK;
|
|
|
+ ep = 28;
|
|
|
+}
|
|
|
+L.prototype.ct = ep;
|
|
|
+L.prototype.fi = ((1 << ep) - 1);
|
|
|
+L.prototype.ez = (1 << ep);
|
|
|
+var im = 52;
|
|
|
+L.prototype.ku = Math.pow(2, im);
|
|
|
+L.prototype.iR = im - ep;
|
|
|
+L.prototype.io = 2 * ep - im;
|
|
|
+var jV = "0123456789abcdefghijklmnopqrstuvwxyz";
|
|
|
+var gQ = new Array();
|
|
|
+var gr = "0".charCodeAt(0);
|
|
|
+for (var ej = 0; ej <= 9; ++ej) gQ[gr++] = ej;
|
|
|
+gr = "a".charCodeAt(0);
|
|
|
+for (var ej = 10; ej < 36; ++ej) gQ[gr++] = ej;
|
|
|
+gr = "A".charCodeAt(0);
|
|
|
+for (var ej = 10; ej < 36; ++ej) gQ[gr++] = ej;
|
|
|
+
|
|
|
+function bk(n) {
|
|
|
+ return jV.charAt(n);
|
|
|
+};
|
|
|
+
|
|
|
+function bw(s, i) {
|
|
|
+ var c = gQ[s.charCodeAt(i)];
|
|
|
+ return (c == null) ? -1 : c;
|
|
|
+};
|
|
|
+
|
|
|
+function dQ(r) {
|
|
|
+ for (var i = this.t - 1; i >= 0; --i) r[i] = this[i];
|
|
|
+ r.t = this.t;
|
|
|
+ r.s = this.s;
|
|
|
+};
|
|
|
+
|
|
|
+function cS(x) {
|
|
|
+ this.t = 1;
|
|
|
+ this.s = (x < 0) ? -1 : 0;
|
|
|
+ if (x > 0) this[0] = x;
|
|
|
+ else if (x < -1) this[0] = x + this.ez;
|
|
|
+ else this.t = 0;
|
|
|
+};
|
|
|
+
|
|
|
+function H(i) {
|
|
|
+ var r = C();
|
|
|
+ r.eT(i);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function dc(s, b) {
|
|
|
+ var k;
|
|
|
+ if (b == 16) k = 4;
|
|
|
+ else if (b == 8) k = 3;
|
|
|
+ else if (b == 256) k = 8;
|
|
|
+ else if (b == 2) k = 1;
|
|
|
+ else if (b == 32) k = 5;
|
|
|
+ else if (b == 4) k = 2;
|
|
|
+ else {
|
|
|
+ this.jP(s, b);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ this.t = 0;
|
|
|
+ this.s = 0;
|
|
|
+ var i = s.length,
|
|
|
+ gO = false,
|
|
|
+ fr = 0;
|
|
|
+ while (--i >= 0) {
|
|
|
+ var x = (k == 8) ? s[i] & 0xff : bw(s, i);
|
|
|
+ if (x < 0) {
|
|
|
+ if (s.charAt(i) == "-") gO = true;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ gO = false;
|
|
|
+ if (fr == 0) this[this.t++] = x;
|
|
|
+ else if (fr + k > this.ct) {
|
|
|
+ this[this.t - 1] |= (x & ((1 << (this.ct - fr)) - 1)) << fr;
|
|
|
+ this[this.t++] = (x >> (this.ct - fr));
|
|
|
+ } else this[this.t - 1] |= x << fr;
|
|
|
+ fr += k;
|
|
|
+ if (fr >= this.ct) fr -= this.ct;
|
|
|
+ }
|
|
|
+ if (k == 8 && (s[0] & 0x80) != 0) {
|
|
|
+ this.s = -1;
|
|
|
+ if (fr > 0) this[this.t - 1] |= ((1 << (this.ct - fr)) - 1) << fr;
|
|
|
+ }
|
|
|
+ this.ff();
|
|
|
+ if (gO) L.ZERO.cp(this, this);
|
|
|
+};
|
|
|
+
|
|
|
+function cf() {
|
|
|
+ var c = this.s & this.fi;
|
|
|
+ while (this.t > 0 && this[this.t - 1] == c) --this.t;
|
|
|
+};
|
|
|
+
|
|
|
+function aH(b) {
|
|
|
+ if (this.s < 0) return "-" + this.el().toString(b);
|
|
|
+ var k;
|
|
|
+ if (b == 16) k = 4;
|
|
|
+ else if (b == 8) k = 3;
|
|
|
+ else if (b == 2) k = 1;
|
|
|
+ else if (b == 32) k = 5;
|
|
|
+ else if (b == 4) k = 2;
|
|
|
+ else return this.eD(b);
|
|
|
+ var hx = (1 << k) - 1,
|
|
|
+ d, m = false,
|
|
|
+ r = "",
|
|
|
+ i = this.t;
|
|
|
+ var p = this.ct - (i * this.ct) % k;
|
|
|
+ if (i-- > 0) {
|
|
|
+ if (p < this.ct && (d = this[i] >> p) > 0) {
|
|
|
+ m = true;
|
|
|
+ r = bk(d);
|
|
|
+ }
|
|
|
+ while (i >= 0) {
|
|
|
+ if (p < k) {
|
|
|
+ d = (this[i] & ((1 << p) - 1)) << (k - p);
|
|
|
+ d |= this[--i] >> (p += this.ct - k);
|
|
|
+ } else {
|
|
|
+ d = (this[i] >> (p -= k)) & hx;
|
|
|
+ if (p <= 0) {
|
|
|
+ p += this.ct;
|
|
|
+ --i;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (d > 0) m = true;
|
|
|
+ if (m) r += bk(d);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return m ? r : "0";
|
|
|
+};
|
|
|
+
|
|
|
+function aL() {
|
|
|
+ var r = C();
|
|
|
+ L.ZERO.cp(this, r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function cn() {
|
|
|
+ return (this.s < 0) ? this.el() : this;
|
|
|
+};
|
|
|
+
|
|
|
+function aD(a) {
|
|
|
+ var r = this.s - a.s;
|
|
|
+ if (r != 0) return r;
|
|
|
+ var i = this.t;
|
|
|
+ r = i - a.t;
|
|
|
+ if (r != 0) return (this.s < 0) ? -r : r;
|
|
|
+ while (--i >= 0)
|
|
|
+ if ((r = this[i] - a[i]) != 0) return r;
|
|
|
+ return 0;
|
|
|
+};
|
|
|
+
|
|
|
+function bN(x) {
|
|
|
+ var r = 1,
|
|
|
+ t;
|
|
|
+ if ((t = x >>> 16) != 0) {
|
|
|
+ x = t;
|
|
|
+ r += 16;
|
|
|
+ }
|
|
|
+ if ((t = x >> 8) != 0) {
|
|
|
+ x = t;
|
|
|
+ r += 8;
|
|
|
+ }
|
|
|
+ if ((t = x >> 4) != 0) {
|
|
|
+ x = t;
|
|
|
+ r += 4;
|
|
|
+ }
|
|
|
+ if ((t = x >> 2) != 0) {
|
|
|
+ x = t;
|
|
|
+ r += 2;
|
|
|
+ }
|
|
|
+ if ((t = x >> 1) != 0) {
|
|
|
+ x = t;
|
|
|
+ r += 1;
|
|
|
+ }
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function dI() {
|
|
|
+ if (this.t <= 0) return 0;
|
|
|
+ return this.ct * (this.t - 1) + bN(this[this.t - 1] ^ (this.s & this.fi));
|
|
|
+};
|
|
|
+
|
|
|
+function da(n, r) {
|
|
|
+ var i;
|
|
|
+ for (i = this.t - 1; i >= 0; --i) r[i + n] = this[i];
|
|
|
+ for (i = n - 1; i >= 0; --i) r[i] = 0;
|
|
|
+ r.t = this.t + n;
|
|
|
+ r.s = this.s;
|
|
|
+};
|
|
|
+
|
|
|
+function cP(n, r) {
|
|
|
+ for (var i = n; i < this.t; ++i) r[i - n] = this[i];
|
|
|
+ r.t = Math.max(this.t - n, 0);
|
|
|
+ r.s = this.s;
|
|
|
+};
|
|
|
+
|
|
|
+function cq(n, r) {
|
|
|
+ var fD = n % this.ct;
|
|
|
+ var gC = this.ct - fD;
|
|
|
+ var hD = (1 << gC) - 1;
|
|
|
+ var eL = Math.floor(n / this.ct),
|
|
|
+ c = (this.s << fD) & this.fi,
|
|
|
+ i;
|
|
|
+ for (i = this.t - 1; i >= 0; --i) {
|
|
|
+ r[i + eL + 1] = (this[i] >> gC) | c;
|
|
|
+ c = (this[i] & hD) << fD;
|
|
|
+ }
|
|
|
+ for (i = eL - 1; i >= 0; --i) r[i] = 0;
|
|
|
+ r[eL] = c;
|
|
|
+ r.t = this.t + eL + 1;
|
|
|
+ r.s = this.s;
|
|
|
+ r.ff();
|
|
|
+};
|
|
|
+
|
|
|
+function dM(n, r) {
|
|
|
+ r.s = this.s;
|
|
|
+ var eL = Math.floor(n / this.ct);
|
|
|
+ if (eL >= this.t) {
|
|
|
+ r.t = 0;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ var fD = n % this.ct;
|
|
|
+ var gC = this.ct - fD;
|
|
|
+ var hD = (1 << fD) - 1;
|
|
|
+ r[0] = this[eL] >> fD;
|
|
|
+ for (var i = eL + 1; i < this.t; ++i) {
|
|
|
+ r[i - eL - 1] |= (this[i] & hD) << gC;
|
|
|
+ r[i - eL] = this[i] >> fD;
|
|
|
+ }
|
|
|
+ if (fD > 0) r[this.t - eL - 1] |= (this.s & hD) << gC;
|
|
|
+ r.t = this.t - eL;
|
|
|
+ r.ff();
|
|
|
+};
|
|
|
+
|
|
|
+function de(a, r) {
|
|
|
+ var i = 0,
|
|
|
+ c = 0,
|
|
|
+ m = Math.min(a.t, this.t);
|
|
|
+ while (i < m) {
|
|
|
+ c += this[i] - a[i];
|
|
|
+ r[i++] = c & this.fi;
|
|
|
+ c >>= this.ct;
|
|
|
+ }
|
|
|
+ if (a.t < this.t) {
|
|
|
+ c -= a.s;
|
|
|
+ while (i < this.t) {
|
|
|
+ c += this[i];
|
|
|
+ r[i++] = c & this.fi;
|
|
|
+ c >>= this.ct;
|
|
|
+ }
|
|
|
+ c += this.s;
|
|
|
+ } else {
|
|
|
+ c += this.s;
|
|
|
+ while (i < a.t) {
|
|
|
+ c -= a[i];
|
|
|
+ r[i++] = c & this.fi;
|
|
|
+ c >>= this.ct;
|
|
|
+ }
|
|
|
+ c -= a.s;
|
|
|
+ }
|
|
|
+ r.s = (c < 0) ? -1 : 0;
|
|
|
+ if (c < -1) r[i++] = this.ez + c;
|
|
|
+ else if (c > 0) r[i++] = c;
|
|
|
+ r.t = i;
|
|
|
+ r.ff();
|
|
|
+};
|
|
|
+
|
|
|
+function bX(a, r) {
|
|
|
+ var x = this.abs(),
|
|
|
+ y = a.abs();
|
|
|
+ var i = x.t;
|
|
|
+ r.t = i + y.t;
|
|
|
+ while (--i >= 0) r[i] = 0;
|
|
|
+ for (i = 0; i < y.t; ++i) r[i + x.t] = x.eZ(0, y[i], r, i, 0, x.t);
|
|
|
+ r.s = 0;
|
|
|
+ r.ff();
|
|
|
+ if (this.s != a.s) L.ZERO.cp(r, r);
|
|
|
+};
|
|
|
+
|
|
|
+function cr(r) {
|
|
|
+ var x = this.abs();
|
|
|
+ var i = r.t = 2 * x.t;
|
|
|
+ while (--i >= 0) r[i] = 0;
|
|
|
+ for (i = 0; i < x.t - 1; ++i) {
|
|
|
+ var c = x.eZ(i, x[i], r, 2 * i, 0, 1);
|
|
|
+ if ((r[i + x.t] += x.eZ(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >= x.ez) {
|
|
|
+ r[i + x.t] -= x.ez;
|
|
|
+ r[i + x.t + 1] = 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (r.t > 0) r[r.t - 1] += x.eZ(i, x[i], r, 2 * i, 0, 1);
|
|
|
+ r.s = 0;
|
|
|
+ r.ff();
|
|
|
+};
|
|
|
+
|
|
|
+function dJ(m, q, r) {
|
|
|
+ var hz = m.abs();
|
|
|
+ if (hz.t <= 0) return;
|
|
|
+ var pt = this.abs();
|
|
|
+ if (pt.t < hz.t) {
|
|
|
+ if (q != null) q.eT(0);
|
|
|
+ if (r != null) this.eh(r);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (r == null) r = C();
|
|
|
+ var y = C(),
|
|
|
+ jb = this.s,
|
|
|
+ ms = m.s;
|
|
|
+ var gP = this.ct - bN(hz[hz.t - 1]);
|
|
|
+ if (gP > 0) {
|
|
|
+ hz.gx(gP, y);
|
|
|
+ pt.gx(gP, r);
|
|
|
+ } else {
|
|
|
+ hz.eh(y);
|
|
|
+ pt.eh(r);
|
|
|
+ }
|
|
|
+ var fG = y.t;
|
|
|
+ var gb = y[fG - 1];
|
|
|
+ if (gb == 0) return;
|
|
|
+ var jA = gb * (1 << this.iR) + ((fG > 1) ? y[fG - 2] >> this.io : 0);
|
|
|
+ var kA = this.ku / jA,
|
|
|
+ ko = (1 << this.iR) / jA,
|
|
|
+ e = 1 << this.io;
|
|
|
+ var i = r.t,
|
|
|
+ j = i - fG,
|
|
|
+ t = (q == null) ? C() : q;
|
|
|
+ y.gS(j, t);
|
|
|
+ if (r.dw(t) >= 0) {
|
|
|
+ r[r.t++] = 1;
|
|
|
+ r.cp(t, r);
|
|
|
+ }
|
|
|
+ L.ONE.gS(fG, t);
|
|
|
+ t.cp(y, y);
|
|
|
+ while (y.t < fG) y[y.t++] = 0;
|
|
|
+ while (--j >= 0) {
|
|
|
+ var gc = (r[--i] == gb) ? this.fi : Math.floor(r[i] * kA + (r[i - 1] + e) * ko);
|
|
|
+ if ((r[i] += y.eZ(0, gc, r, j, 0, fG)) < gc) {
|
|
|
+ y.gS(j, t);
|
|
|
+ r.cp(t, r);
|
|
|
+ while (r[i] < --gc) r.cp(t, r);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (q != null) {
|
|
|
+ r.gJ(fG, q);
|
|
|
+ if (jb != ms) L.ZERO.cp(q, q);
|
|
|
+ }
|
|
|
+ r.t = fG;
|
|
|
+ r.ff();
|
|
|
+ if (gP > 0) r.dY(gP, r);
|
|
|
+ if (jb < 0) L.ZERO.cp(r, r);
|
|
|
+};
|
|
|
+
|
|
|
+function aZ(a) {
|
|
|
+ var r = C();
|
|
|
+ this.abs().fw(a, null, r);
|
|
|
+ if (this.s < 0 && r.dw(L.ZERO) > 0) a.cp(r, r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function af(m) {
|
|
|
+ this.m = m;
|
|
|
+};
|
|
|
+
|
|
|
+function ak(x) {
|
|
|
+ if (x.s < 0 || x.dw(this.m) >= 0) return x.cl(this.m);
|
|
|
+ else return x;
|
|
|
+};
|
|
|
+
|
|
|
+function aj(x) {
|
|
|
+ return x;
|
|
|
+};
|
|
|
+
|
|
|
+function aU(x) {
|
|
|
+ x.fw(this.m, null, x);
|
|
|
+};
|
|
|
+
|
|
|
+function bM(x, y, r) {
|
|
|
+ x.gG(y, r);
|
|
|
+ this.reduce(r);
|
|
|
+};
|
|
|
+
|
|
|
+function bE(x, r) {
|
|
|
+ x.hc(r);
|
|
|
+ this.reduce(r);
|
|
|
+};
|
|
|
+af.prototype.convert = ak;
|
|
|
+af.prototype.revert = aj;
|
|
|
+af.prototype.reduce = aU;
|
|
|
+af.prototype.fO = bM;
|
|
|
+af.prototype.eO = bE;
|
|
|
+
|
|
|
+function dh() {
|
|
|
+ if (this.t < 1) return 0;
|
|
|
+ var x = this[0];
|
|
|
+ if ((x & 1) == 0) return 0;
|
|
|
+ var y = x & 3;
|
|
|
+ y = (y * (2 - (x & 0xf) * y)) & 0xf;
|
|
|
+ y = (y * (2 - (x & 0xff) * y)) & 0xff;
|
|
|
+ y = (y * (2 - (((x & 0xffff) * y) & 0xffff))) & 0xffff;
|
|
|
+ y = (y * (2 - x * y % this.ez)) % this.ez;
|
|
|
+ return (y > 0) ? this.ez - y : -y;
|
|
|
+};
|
|
|
+
|
|
|
+function O(m) {
|
|
|
+ this.m = m;
|
|
|
+ this.ik = m.kC();
|
|
|
+ this.jB = this.ik & 0x7fff;
|
|
|
+ this.kl = this.ik >> 15;
|
|
|
+ this.lf = (1 << (m.ct - 15)) - 1;
|
|
|
+ this.kV = 2 * m.t;
|
|
|
+};
|
|
|
+
|
|
|
+function bC(x) {
|
|
|
+ var r = C();
|
|
|
+ x.abs().gS(this.m.t, r);
|
|
|
+ r.fw(this.m, null, r);
|
|
|
+ if (x.s < 0 && r.dw(L.ZERO) > 0) this.m.cp(r, r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function ax(x) {
|
|
|
+ var r = C();
|
|
|
+ x.eh(r);
|
|
|
+ this.reduce(r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function au(x) {
|
|
|
+ while (x.t <= this.kV) x[x.t++] = 0;
|
|
|
+ for (var i = 0; i < this.m.t; ++i) {
|
|
|
+ var j = x[i] & 0x7fff;
|
|
|
+ var kh = (j * this.jB + (((j * this.kl + (x[i] >> 15) * this.jB) & this.lf) << 15)) & x.fi;
|
|
|
+ j = i + this.m.t;
|
|
|
+ x[j] += this.m.eZ(0, kh, x, i, 0, this.m.t);
|
|
|
+ while (x[j] >= x.ez) {
|
|
|
+ x[j] -= x.ez;
|
|
|
+ x[++j]++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ x.ff();
|
|
|
+ x.gJ(this.m.t, x);
|
|
|
+ if (x.dw(this.m) >= 0) x.cp(this.m, x);
|
|
|
+};
|
|
|
+
|
|
|
+function aC(x, r) {
|
|
|
+ x.hc(r);
|
|
|
+ this.reduce(r);
|
|
|
+};
|
|
|
+
|
|
|
+function bi(x, y, r) {
|
|
|
+ x.gG(y, r);
|
|
|
+ this.reduce(r);
|
|
|
+};
|
|
|
+O.prototype.convert = bC;
|
|
|
+O.prototype.revert = ax;
|
|
|
+O.prototype.reduce = au;
|
|
|
+O.prototype.fO = bi;
|
|
|
+O.prototype.eO = aC;
|
|
|
+
|
|
|
+function cz() {
|
|
|
+ return ((this.t > 0) ? (this[0] & 1) : this.s) == 0;
|
|
|
+};
|
|
|
+
|
|
|
+function df(e, z) {
|
|
|
+ if (e > 0xffffffff || e < 1) return L.ONE;
|
|
|
+ var r = C(),
|
|
|
+ r2 = C(),
|
|
|
+ g = z.convert(this),
|
|
|
+ i = bN(e) - 1;
|
|
|
+ g.eh(r);
|
|
|
+ while (--i >= 0) {
|
|
|
+ z.eO(r, r2);
|
|
|
+ if ((e & (1 << i)) > 0) z.fO(r2, g, r);
|
|
|
+ else {
|
|
|
+ var t = r;
|
|
|
+ r = r2;
|
|
|
+ r2 = t;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return z.revert(r);
|
|
|
+};
|
|
|
+
|
|
|
+function bH(e, m) {
|
|
|
+ var z;
|
|
|
+ if (e < 256 || m.ef()) z = new af(m);
|
|
|
+ else z = new O(m);
|
|
|
+ return this.exp(e, z);
|
|
|
+};
|
|
|
+L.prototype.eh = dQ;
|
|
|
+L.prototype.eT = cS;
|
|
|
+L.prototype.hK = dc;
|
|
|
+L.prototype.ff = cf;
|
|
|
+L.prototype.gS = da;
|
|
|
+L.prototype.gJ = cP;
|
|
|
+L.prototype.gx = cq;
|
|
|
+L.prototype.dY = dM;
|
|
|
+L.prototype.cp = de;
|
|
|
+L.prototype.gG = bX;
|
|
|
+L.prototype.hc = cr;
|
|
|
+L.prototype.fw = dJ;
|
|
|
+L.prototype.kC = dh;
|
|
|
+L.prototype.ef = cz;
|
|
|
+L.prototype.exp = df;
|
|
|
+L.prototype.toString = aH;
|
|
|
+L.prototype.el = aL;
|
|
|
+L.prototype.abs = cn;
|
|
|
+L.prototype.dw = aD;
|
|
|
+L.prototype.fg = dI;
|
|
|
+L.prototype.cl = aZ;
|
|
|
+L.prototype.kr = bH;
|
|
|
+L.ZERO = H(0);
|
|
|
+L.ONE = H(1);
|
|
|
+
|
|
|
+function an() {
|
|
|
+ var r = C();
|
|
|
+ this.eh(r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function bK() {
|
|
|
+ if (this.s < 0) {
|
|
|
+ if (this.t == 1) return this[0] - this.ez;
|
|
|
+ else if (this.t == 0) return -1;
|
|
|
+ } else if (this.t == 1) return this[0];
|
|
|
+ else if (this.t == 0) return 0;
|
|
|
+ return ((this[1] & ((1 << (32 - this.ct)) - 1)) << this.ct) | this[0];
|
|
|
+};
|
|
|
+
|
|
|
+function cI() {
|
|
|
+ return (this.t == 0) ? this.s : (this[0] << 24) >> 24;
|
|
|
+};
|
|
|
+
|
|
|
+function dn() {
|
|
|
+ return (this.t == 0) ? this.s : (this[0] << 16) >> 16;
|
|
|
+};
|
|
|
+
|
|
|
+function ca(r) {
|
|
|
+ return Math.floor(Math.LN2 * this.ct / Math.log(r));
|
|
|
+};
|
|
|
+
|
|
|
+function aF() {
|
|
|
+ if (this.s < 0) return -1;
|
|
|
+ else if (this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0;
|
|
|
+ else return 1;
|
|
|
+};
|
|
|
+
|
|
|
+function dk(b) {
|
|
|
+ if (b == null) b = 10;
|
|
|
+ if (this.eJ() == 0 || b < 2 || b > 36) return "0";
|
|
|
+ var gf = this.iw(b);
|
|
|
+ var a = Math.pow(b, gf);
|
|
|
+ var d = H(a),
|
|
|
+ y = C(),
|
|
|
+ z = C(),
|
|
|
+ r = "";
|
|
|
+ this.fw(d, y, z);
|
|
|
+ while (y.eJ() > 0) {
|
|
|
+ r = (a + z.hs()).toString(b).substr(1) + r;
|
|
|
+ y.fw(d, y, z);
|
|
|
+ }
|
|
|
+ return z.hs().toString(b) + r;
|
|
|
+};
|
|
|
+
|
|
|
+function bY(s, b) {
|
|
|
+ this.eT(0);
|
|
|
+ if (b == null) b = 10;
|
|
|
+ var gf = this.iw(b);
|
|
|
+ var d = Math.pow(b, gf),
|
|
|
+ gO = false,
|
|
|
+ j = 0,
|
|
|
+ w = 0;
|
|
|
+ for (var i = 0; i < s.length; ++i) {
|
|
|
+ var x = bw(s, i);
|
|
|
+ if (x < 0) {
|
|
|
+ if (s.charAt(i) == "-" && this.eJ() == 0) gO = true;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ w = b * w + x;
|
|
|
+ if (++j >= gf) {
|
|
|
+ this.ja(d);
|
|
|
+ this.hJ(w, 0);
|
|
|
+ j = 0;
|
|
|
+ w = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (j > 0) {
|
|
|
+ this.ja(Math.pow(b, j));
|
|
|
+ this.hJ(w, 0);
|
|
|
+ }
|
|
|
+ if (gO) L.ZERO.cp(this, this);
|
|
|
+};
|
|
|
+
|
|
|
+function cX(a, b, c) {
|
|
|
+ if ("number" == typeof b) {
|
|
|
+ if (a < 2) this.eT(1);
|
|
|
+ else {
|
|
|
+ this.iM(a, c);
|
|
|
+ if (!this.en(a - 1)) this.gj(L.ONE.shiftLeft(a - 1), ay, this);
|
|
|
+ if (this.ef()) this.hJ(1, 0);
|
|
|
+ while (!this.kv(b)) {
|
|
|
+ this.hJ(2, 0);
|
|
|
+ if (this.fg() > a) this.cp(L.ONE.shiftLeft(a - 1), this);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ var x = new Array(),
|
|
|
+ t = a & 7;
|
|
|
+ x.length = (a >> 3) + 1;
|
|
|
+ b.kj(x);
|
|
|
+ if (t > 0) x[0] &= ((1 << t) - 1);
|
|
|
+ else x[0] = 0;
|
|
|
+ this.hK(x, 256);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+function bv() {
|
|
|
+ var i = this.t,
|
|
|
+ r = new Array();
|
|
|
+ r[0] = this.s;
|
|
|
+ var p = this.ct - (i * this.ct) % 8,
|
|
|
+ d, k = 0;
|
|
|
+ if (i-- > 0) {
|
|
|
+ if (p < this.ct && (d = this[i] >> p) != (this.s & this.fi) >> p) r[k++] = d | (this.s << (this.ct - p));
|
|
|
+ while (i >= 0) {
|
|
|
+ if (p < 8) {
|
|
|
+ d = (this[i] & ((1 << p) - 1)) << (8 - p);
|
|
|
+ d |= this[--i] >> (p += this.ct - 8);
|
|
|
+ } else {
|
|
|
+ d = (this[i] >> (p -= 8)) & 0xff;
|
|
|
+ if (p <= 0) {
|
|
|
+ p += this.ct;
|
|
|
+ --i;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if ((d & 0x80) != 0) d |= -256;
|
|
|
+ if (k == 0 && (this.s & 0x80) != (d & 0x80)) ++k;
|
|
|
+ if (k > 0 || d != this.s) r[k++] = d;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function ab(a) {
|
|
|
+ return (this.dw(a) == 0);
|
|
|
+};
|
|
|
+
|
|
|
+function aw(a) {
|
|
|
+ return (this.dw(a) < 0) ? this : a;
|
|
|
+};
|
|
|
+
|
|
|
+function ao(a) {
|
|
|
+ return (this.dw(a) > 0) ? this : a;
|
|
|
+};
|
|
|
+
|
|
|
+function cC(a, hv, r) {
|
|
|
+ var i, f, m = Math.min(a.t, this.t);
|
|
|
+ for (i = 0; i < m; ++i) r[i] = hv(this[i], a[i]);
|
|
|
+ if (a.t < this.t) {
|
|
|
+ f = a.s & this.fi;
|
|
|
+ for (i = m; i < this.t; ++i) r[i] = hv(this[i], f);
|
|
|
+ r.t = this.t;
|
|
|
+ } else {
|
|
|
+ f = this.s & this.fi;
|
|
|
+ for (i = m; i < a.t; ++i) r[i] = hv(f, a[i]);
|
|
|
+ r.t = a.t;
|
|
|
+ }
|
|
|
+ r.s = hv(this.s, a.s);
|
|
|
+ r.ff();
|
|
|
+};
|
|
|
+
|
|
|
+function aR(x, y) {
|
|
|
+ return x & y;
|
|
|
+};
|
|
|
+
|
|
|
+function dN(a) {
|
|
|
+ var r = C();
|
|
|
+ this.gj(a, aR, r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function ay(x, y) {
|
|
|
+ return x | y;
|
|
|
+};
|
|
|
+
|
|
|
+function bW(a) {
|
|
|
+ var r = C();
|
|
|
+ this.gj(a, ay, r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function aT(x, y) {
|
|
|
+ return x ^ y;
|
|
|
+};
|
|
|
+
|
|
|
+function aQ(a) {
|
|
|
+ var r = C();
|
|
|
+ this.gj(a, aT, r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function ag(x, y) {
|
|
|
+ return x & ~y;
|
|
|
+};
|
|
|
+
|
|
|
+function cg(a) {
|
|
|
+ var r = C();
|
|
|
+ this.gj(a, ag, r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function db() {
|
|
|
+ var r = C();
|
|
|
+ for (var i = 0; i < this.t; ++i) r[i] = this.fi & ~this[i];
|
|
|
+ r.t = this.t;
|
|
|
+ r.s = ~this.s;
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function cA(n) {
|
|
|
+ var r = C();
|
|
|
+ if (n < 0) this.dY(-n, r);
|
|
|
+ else this.gx(n, r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function dv(n) {
|
|
|
+ var r = C();
|
|
|
+ if (n < 0) this.gx(-n, r);
|
|
|
+ else this.dY(n, r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function aA(x) {
|
|
|
+ if (x == 0) return -1;
|
|
|
+ var r = 0;
|
|
|
+ if ((x & 0xffff) == 0) {
|
|
|
+ x >>= 16;
|
|
|
+ r += 16;
|
|
|
+ }
|
|
|
+ if ((x & 0xff) == 0) {
|
|
|
+ x >>= 8;
|
|
|
+ r += 8;
|
|
|
+ }
|
|
|
+ if ((x & 0xf) == 0) {
|
|
|
+ x >>= 4;
|
|
|
+ r += 4;
|
|
|
+ }
|
|
|
+ if ((x & 3) == 0) {
|
|
|
+ x >>= 2;
|
|
|
+ r += 2;
|
|
|
+ }
|
|
|
+ if ((x & 1) == 0) ++r;
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function aq() {
|
|
|
+ for (var i = 0; i < this.t; ++i)
|
|
|
+ if (this[i] != 0) return i * this.ct + aA(this[i]);
|
|
|
+ if (this.s < 0) return this.t * this.ct;
|
|
|
+ return -1;
|
|
|
+};
|
|
|
+
|
|
|
+function ad(x) {
|
|
|
+ var r = 0;
|
|
|
+ while (x != 0) {
|
|
|
+ x &= x - 1;
|
|
|
+ ++r;
|
|
|
+ }
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function cj() {
|
|
|
+ var r = 0,
|
|
|
+ x = this.s & this.fi;
|
|
|
+ for (var i = 0; i < this.t; ++i) r += ad(this[i] ^ x);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function aM(n) {
|
|
|
+ var j = Math.floor(n / this.ct);
|
|
|
+ if (j >= this.t) return (this.s != 0);
|
|
|
+ return ((this[j] & (1 << (n % this.ct))) != 0);
|
|
|
+};
|
|
|
+
|
|
|
+function dE(n, hv) {
|
|
|
+ var r = L.ONE.shiftLeft(n);
|
|
|
+ this.gj(r, hv, r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function cc(n) {
|
|
|
+ return this.hY(n, ay);
|
|
|
+};
|
|
|
+
|
|
|
+function cT(n) {
|
|
|
+ return this.hY(n, ag);
|
|
|
+};
|
|
|
+
|
|
|
+function bb(n) {
|
|
|
+ return this.hY(n, aT);
|
|
|
+};
|
|
|
+
|
|
|
+function ce(a, r) {
|
|
|
+ var i = 0,
|
|
|
+ c = 0,
|
|
|
+ m = Math.min(a.t, this.t);
|
|
|
+ while (i < m) {
|
|
|
+ c += this[i] + a[i];
|
|
|
+ r[i++] = c & this.fi;
|
|
|
+ c >>= this.ct;
|
|
|
+ }
|
|
|
+ if (a.t < this.t) {
|
|
|
+ c += a.s;
|
|
|
+ while (i < this.t) {
|
|
|
+ c += this[i];
|
|
|
+ r[i++] = c & this.fi;
|
|
|
+ c >>= this.ct;
|
|
|
+ }
|
|
|
+ c += this.s;
|
|
|
+ } else {
|
|
|
+ c += this.s;
|
|
|
+ while (i < a.t) {
|
|
|
+ c += a[i];
|
|
|
+ r[i++] = c & this.fi;
|
|
|
+ c >>= this.ct;
|
|
|
+ }
|
|
|
+ c += a.s;
|
|
|
+ }
|
|
|
+ r.s = (c < 0) ? -1 : 0;
|
|
|
+ if (c > 0) r[i++] = c;
|
|
|
+ else if (c < -1) r[i++] = this.ez + c;
|
|
|
+ r.t = i;
|
|
|
+ r.ff();
|
|
|
+};
|
|
|
+
|
|
|
+function cO(a) {
|
|
|
+ var r = C();
|
|
|
+ this.hG(a, r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function bQ(a) {
|
|
|
+ var r = C();
|
|
|
+ this.cp(a, r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function bF(a) {
|
|
|
+ var r = C();
|
|
|
+ this.gG(a, r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function aa() {
|
|
|
+ var r = C();
|
|
|
+ this.hc(r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function bd(a) {
|
|
|
+ var r = C();
|
|
|
+ this.fw(a, r, null);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function cQ(a) {
|
|
|
+ var r = C();
|
|
|
+ this.fw(a, null, r);
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function bI(a) {
|
|
|
+ var q = C(),
|
|
|
+ r = C();
|
|
|
+ this.fw(a, q, r);
|
|
|
+ return new Array(q, r);
|
|
|
+};
|
|
|
+
|
|
|
+function dp(n) {
|
|
|
+ this[this.t] = this.eZ(0, n - 1, this, 0, 0, this.t);
|
|
|
+ ++this.t;
|
|
|
+ this.ff();
|
|
|
+};
|
|
|
+
|
|
|
+function cJ(n, w) {
|
|
|
+ if (n == 0) return;
|
|
|
+ while (this.t <= w) this[this.t++] = 0;
|
|
|
+ this[w] += n;
|
|
|
+ while (this[w] >= this.ez) {
|
|
|
+ this[w] -= this.ez;
|
|
|
+ if (++w >= this.t) this[this.t++] = 0;
|
|
|
+ ++this[w];
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+function bj() { };
|
|
|
+
|
|
|
+function aY(x) {
|
|
|
+ return x;
|
|
|
+};
|
|
|
+
|
|
|
+function aG(x, y, r) {
|
|
|
+ x.gG(y, r);
|
|
|
+};
|
|
|
+
|
|
|
+function bA(x, r) {
|
|
|
+ x.hc(r);
|
|
|
+};
|
|
|
+bj.prototype.convert = aY;
|
|
|
+bj.prototype.revert = aY;
|
|
|
+bj.prototype.fO = aG;
|
|
|
+bj.prototype.eO = bA;
|
|
|
+
|
|
|
+function cG(e) {
|
|
|
+ return this.exp(e, new bj());
|
|
|
+};
|
|
|
+
|
|
|
+function cW(a, n, r) {
|
|
|
+ var i = Math.min(this.t + a.t, n);
|
|
|
+ r.s = 0;
|
|
|
+ r.t = i;
|
|
|
+ while (i > 0) r[--i] = 0;
|
|
|
+ var j;
|
|
|
+ for (j = r.t - this.t; i < j; ++i) r[i + this.t] = this.eZ(0, a[i], r, i, 0, this.t);
|
|
|
+ for (j = Math.min(a.t, n); i < j; ++i) this.eZ(0, a[i], r, i, 0, n - i);
|
|
|
+ r.ff();
|
|
|
+};
|
|
|
+
|
|
|
+function ci(a, n, r) {
|
|
|
+ --n;
|
|
|
+ var i = r.t = this.t + a.t - n;
|
|
|
+ r.s = 0;
|
|
|
+ while (--i >= 0) r[i] = 0;
|
|
|
+ for (i = Math.max(n - this.t, 0); i < a.t; ++i) r[this.t + i - n] = this.eZ(n - i, a[i], r, 0, 0, this.t + i - n);
|
|
|
+ r.ff();
|
|
|
+ r.gJ(1, r);
|
|
|
+};
|
|
|
+
|
|
|
+function bh(m) {
|
|
|
+ this.r2 = C();
|
|
|
+ this.jx = C();
|
|
|
+ L.ONE.gS(2 * m.t, this.r2);
|
|
|
+ this.jQ = this.r2.divide(m);
|
|
|
+ this.m = m;
|
|
|
+};
|
|
|
+
|
|
|
+function bu(x) {
|
|
|
+ if (x.s < 0 || x.t > 2 * this.m.t) return x.cl(this.m);
|
|
|
+ else if (x.dw(this.m) < 0) return x;
|
|
|
+ else {
|
|
|
+ var r = C();
|
|
|
+ x.eh(r);
|
|
|
+ this.reduce(r);
|
|
|
+ return r;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+function aN(x) {
|
|
|
+ return x;
|
|
|
+};
|
|
|
+
|
|
|
+function bS(x) {
|
|
|
+ x.gJ(this.m.t - 1, this.r2);
|
|
|
+ if (x.t > this.m.t + 1) {
|
|
|
+ x.t = this.m.t + 1;
|
|
|
+ x.ff();
|
|
|
+ }
|
|
|
+ this.jQ.ld(this.r2, this.m.t + 1, this.jx);
|
|
|
+ this.m.lx(this.jx, this.m.t + 1, this.r2);
|
|
|
+ while (x.dw(this.r2) < 0) x.hJ(1, this.m.t + 1);
|
|
|
+ x.cp(this.r2, x);
|
|
|
+ while (x.dw(this.m) >= 0) x.cp(this.m, x);
|
|
|
+};
|
|
|
+
|
|
|
+function dq(x, r) {
|
|
|
+ x.hc(r);
|
|
|
+ this.reduce(r);
|
|
|
+};
|
|
|
+
|
|
|
+function bU(x, y, r) {
|
|
|
+ x.gG(y, r);
|
|
|
+ this.reduce(r);
|
|
|
+};
|
|
|
+bh.prototype.convert = bu;
|
|
|
+bh.prototype.revert = aN;
|
|
|
+bh.prototype.reduce = bS;
|
|
|
+bh.prototype.fO = bU;
|
|
|
+bh.prototype.eO = dq;
|
|
|
+
|
|
|
+function aE(e, m) {
|
|
|
+ var i = e.fg(),
|
|
|
+ k, r = H(1),
|
|
|
+ z;
|
|
|
+ if (i <= 0) return r;
|
|
|
+ else if (i < 18) k = 1;
|
|
|
+ else if (i < 48) k = 3;
|
|
|
+ else if (i < 144) k = 4;
|
|
|
+ else if (i < 768) k = 5;
|
|
|
+ else k = 6;
|
|
|
+ if (i < 8) z = new af(m);
|
|
|
+ else if (m.ef()) z = new bh(m);
|
|
|
+ else z = new O(m);
|
|
|
+ var g = new Array(),
|
|
|
+ n = 3,
|
|
|
+ hh = k - 1,
|
|
|
+ hx = (1 << k) - 1;
|
|
|
+ g[1] = z.convert(this);
|
|
|
+ if (k > 1) {
|
|
|
+ var jg = C();
|
|
|
+ z.eO(g[1], jg);
|
|
|
+ while (n <= hx) {
|
|
|
+ g[n] = C();
|
|
|
+ z.fO(jg, g[n - 2], g[n]);
|
|
|
+ n += 2;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var j = e.t - 1,
|
|
|
+ w, iZ = true,
|
|
|
+ r2 = C(),
|
|
|
+ t;
|
|
|
+ i = bN(e[j]) - 1;
|
|
|
+ while (j >= 0) {
|
|
|
+ if (i >= hh) w = (e[j] >> (i - hh)) & hx;
|
|
|
+ else {
|
|
|
+ w = (e[j] & ((1 << (i + 1)) - 1)) << (hh - i);
|
|
|
+ if (j > 0) w |= e[j - 1] >> (this.ct + i - hh);
|
|
|
+ }
|
|
|
+ n = k;
|
|
|
+ while ((w & 1) == 0) {
|
|
|
+ w >>= 1;
|
|
|
+ --n;
|
|
|
+ }
|
|
|
+ if ((i -= n) < 0) {
|
|
|
+ i += this.ct;
|
|
|
+ --j;
|
|
|
+ }
|
|
|
+ if (iZ) {
|
|
|
+ g[w].eh(r);
|
|
|
+ iZ = false;
|
|
|
+ } else {
|
|
|
+ while (n > 1) {
|
|
|
+ z.eO(r, r2);
|
|
|
+ z.eO(r2, r);
|
|
|
+ n -= 2;
|
|
|
+ }
|
|
|
+ if (n > 0) z.eO(r, r2);
|
|
|
+ else {
|
|
|
+ t = r;
|
|
|
+ r = r2;
|
|
|
+ r2 = t;
|
|
|
+ }
|
|
|
+ z.fO(r2, g[w], r);
|
|
|
+ }
|
|
|
+ while (j >= 0 && (e[j] & (1 << i)) == 0) {
|
|
|
+ z.eO(r, r2);
|
|
|
+ t = r;
|
|
|
+ r = r2;
|
|
|
+ r2 = t;
|
|
|
+ if (--i < 0) {
|
|
|
+ i = this.ct - 1;
|
|
|
+ --j;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return z.revert(r);
|
|
|
+};
|
|
|
+
|
|
|
+function aV(a) {
|
|
|
+ var x = (this.s < 0) ? this.el() : this.clone();
|
|
|
+ var y = (a.s < 0) ? a.el() : a.clone();
|
|
|
+ if (x.dw(y) < 0) {
|
|
|
+ var t = x;
|
|
|
+ x = y;
|
|
|
+ y = t;
|
|
|
+ }
|
|
|
+ var i = x.gg(),
|
|
|
+ g = y.gg();
|
|
|
+ if (g < 0) return x;
|
|
|
+ if (i < g) g = i;
|
|
|
+ if (g > 0) {
|
|
|
+ x.dY(g, x);
|
|
|
+ y.dY(g, y);
|
|
|
+ }
|
|
|
+ while (x.eJ() > 0) {
|
|
|
+ if ((i = x.gg()) > 0) x.dY(i, x);
|
|
|
+ if ((i = y.gg()) > 0) y.dY(i, y);
|
|
|
+ if (x.dw(y) >= 0) {
|
|
|
+ x.cp(y, x);
|
|
|
+ x.dY(1, x);
|
|
|
+ } else {
|
|
|
+ y.cp(x, y);
|
|
|
+ y.dY(1, y);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (g > 0) y.gx(g, y);
|
|
|
+ return y;
|
|
|
+};
|
|
|
+
|
|
|
+function di(n) {
|
|
|
+ if (n <= 0) return 0;
|
|
|
+ var d = this.ez % n,
|
|
|
+ r = (this.s < 0) ? n - 1 : 0;
|
|
|
+ if (this.t > 0)
|
|
|
+ if (d == 0) r = this[0] % n;
|
|
|
+ else
|
|
|
+ for (var i = this.t - 1; i >= 0; --i) r = (d * r + this[i]) % n;
|
|
|
+ return r;
|
|
|
+};
|
|
|
+
|
|
|
+function ah(m) {
|
|
|
+ var fY = m.ef();
|
|
|
+ if ((this.ef() && fY) || m.eJ() == 0) return L.ZERO;
|
|
|
+ var u = m.clone(),
|
|
|
+ v = this.clone();
|
|
|
+ var a = H(1),
|
|
|
+ b = H(0),
|
|
|
+ c = H(0),
|
|
|
+ d = H(1);
|
|
|
+ while (u.eJ() != 0) {
|
|
|
+ while (u.ef()) {
|
|
|
+ u.dY(1, u);
|
|
|
+ if (fY) {
|
|
|
+ if (!a.ef() || !b.ef()) {
|
|
|
+ a.hG(this, a);
|
|
|
+ b.cp(m, b);
|
|
|
+ }
|
|
|
+ a.dY(1, a);
|
|
|
+ } else if (!b.ef()) b.cp(m, b);
|
|
|
+ b.dY(1, b);
|
|
|
+ }
|
|
|
+ while (v.ef()) {
|
|
|
+ v.dY(1, v);
|
|
|
+ if (fY) {
|
|
|
+ if (!c.ef() || !d.ef()) {
|
|
|
+ c.hG(this, c);
|
|
|
+ d.cp(m, d);
|
|
|
+ }
|
|
|
+ c.dY(1, c);
|
|
|
+ } else if (!d.ef()) d.cp(m, d);
|
|
|
+ d.dY(1, d);
|
|
|
+ }
|
|
|
+ if (u.dw(v) >= 0) {
|
|
|
+ u.cp(v, u);
|
|
|
+ if (fY) a.cp(c, a);
|
|
|
+ b.cp(d, b);
|
|
|
+ } else {
|
|
|
+ v.cp(u, v);
|
|
|
+ if (fY) c.cp(a, c);
|
|
|
+ d.cp(b, d);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (v.dw(L.ONE) != 0) return L.ZERO;
|
|
|
+ if (d.dw(m) >= 0) return d.cv(m);
|
|
|
+ if (d.eJ() < 0) d.hG(m, d);
|
|
|
+ else return d;
|
|
|
+ if (d.eJ() < 0) return d.add(m);
|
|
|
+ else return d;
|
|
|
+};
|
|
|
+var eb = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107,
|
|
|
+ 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233,
|
|
|
+ 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373,
|
|
|
+ 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509,
|
|
|
+ 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659,
|
|
|
+ 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823,
|
|
|
+ 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983,
|
|
|
+ 991, 997
|
|
|
+];
|
|
|
+var kE = (1 << 26) / eb[eb.length - 1];
|
|
|
+
|
|
|
+function as(t) {
|
|
|
+ var i, x = this.abs();
|
|
|
+ if (x.t == 1 && x[0] <= eb[eb.length - 1]) {
|
|
|
+ for (i = 0; i < eb.length; ++i)
|
|
|
+ if (x[0] == eb[i]) return true;
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (x.ef()) return false;
|
|
|
+ i = 1;
|
|
|
+ while (i < eb.length) {
|
|
|
+ var m = eb[i],
|
|
|
+ j = i + 1;
|
|
|
+ while (j < eb.length && m < kE) m *= eb[j++];
|
|
|
+ m = x.kq(m);
|
|
|
+ while (i < j)
|
|
|
+ if (m % eb[i++] == 0) return false;
|
|
|
+ }
|
|
|
+ return x.kJ(t);
|
|
|
+};
|
|
|
+
|
|
|
+function dR(t) {
|
|
|
+ var gV = this.cv(L.ONE);
|
|
|
+ var k = gV.gg();
|
|
|
+ if (k <= 0) return false;
|
|
|
+ var r = gV.ic(k);
|
|
|
+ t = (t + 1) >> 1;
|
|
|
+ if (t > eb.length) t = eb.length;
|
|
|
+ var a = C();
|
|
|
+ for (var i = 0; i < t; ++i) {
|
|
|
+ a.eT(eb[Math.floor(Math.random() * eb.length)]);
|
|
|
+ var y = a.lb(r, this);
|
|
|
+ if (y.dw(L.ONE) != 0 && y.dw(gV) != 0) {
|
|
|
+ var j = 1;
|
|
|
+ while (j++ < k && y.dw(gV) != 0) {
|
|
|
+ y = y.kr(2, this);
|
|
|
+ if (y.dw(L.ONE) == 0) return false;
|
|
|
+ }
|
|
|
+ if (y.dw(gV) != 0) return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+};
|
|
|
+L.prototype.iw = ca;
|
|
|
+L.prototype.eD = dk;
|
|
|
+L.prototype.jP = bY;
|
|
|
+L.prototype.iM = cX;
|
|
|
+L.prototype.gj = cC;
|
|
|
+L.prototype.hY = dE;
|
|
|
+L.prototype.hG = ce;
|
|
|
+L.prototype.ja = dp;
|
|
|
+L.prototype.hJ = cJ;
|
|
|
+L.prototype.lx = cW;
|
|
|
+L.prototype.ld = ci;
|
|
|
+L.prototype.kq = di;
|
|
|
+L.prototype.kJ = dR;
|
|
|
+L.prototype.clone = an;
|
|
|
+L.prototype.hs = bK;
|
|
|
+L.prototype.lQ = cI;
|
|
|
+L.prototype.lZ = dn;
|
|
|
+L.prototype.eJ = aF;
|
|
|
+L.prototype.gv = bv;
|
|
|
+L.prototype.equals = ab;
|
|
|
+L.prototype.min = aw;
|
|
|
+L.prototype.max = ao;
|
|
|
+L.prototype.and = dN;
|
|
|
+L.prototype.jw = bW;
|
|
|
+L.prototype.xor = aQ;
|
|
|
+L.prototype.mg = cg;
|
|
|
+L.prototype.not = db;
|
|
|
+L.prototype.shiftLeft = cA;
|
|
|
+L.prototype.ic = dv;
|
|
|
+L.prototype.gg = aq;
|
|
|
+L.prototype.nx = cj;
|
|
|
+L.prototype.en = aM;
|
|
|
+L.prototype.nu = cc;
|
|
|
+L.prototype.mR = cT;
|
|
|
+L.prototype.nc = bb;
|
|
|
+L.prototype.add = cO;
|
|
|
+L.prototype.cv = bQ;
|
|
|
+L.prototype.multiply = bF;
|
|
|
+L.prototype.divide = bd;
|
|
|
+L.prototype.mU = cQ;
|
|
|
+L.prototype.lH = bI;
|
|
|
+L.prototype.lb = aE;
|
|
|
+L.prototype.fZ = ah;
|
|
|
+L.prototype.pow = cG;
|
|
|
+L.prototype.mN = aV;
|
|
|
+L.prototype.kv = as;
|
|
|
+L.prototype.square = aa;
|
|
|
+
|
|
|
+function J(q, x) {
|
|
|
+ this.x = x;
|
|
|
+ this.q = q;
|
|
|
+};
|
|
|
+
|
|
|
+function bx(other) {
|
|
|
+ if (other == this) return true;
|
|
|
+ return (this.q.equals(other.q) && this.x.equals(other.x));
|
|
|
+};
|
|
|
+
|
|
|
+function av() {
|
|
|
+ return this.x;
|
|
|
+};
|
|
|
+
|
|
|
+function aO() {
|
|
|
+ return new J(this.q, this.x.el().cl(this.q));
|
|
|
+};
|
|
|
+
|
|
|
+function bz(b) {
|
|
|
+ return new J(this.q, this.x.add(b.cR()).cl(this.q));
|
|
|
+};
|
|
|
+
|
|
|
+function be(b) {
|
|
|
+ return new J(this.q, this.x.cv(b.cR()).cl(this.q));
|
|
|
+};
|
|
|
+
|
|
|
+function bf(b) {
|
|
|
+ return new J(this.q, this.x.multiply(b.cR()).cl(this.q));
|
|
|
+};
|
|
|
+
|
|
|
+function aJ() {
|
|
|
+ return new J(this.q, this.x.square().cl(this.q));
|
|
|
+};
|
|
|
+
|
|
|
+function ar(b) {
|
|
|
+ return new J(this.q, this.x.multiply(b.cR().fZ(this.q)).cl(this.q));
|
|
|
+};
|
|
|
+J.prototype.equals = bx;
|
|
|
+J.prototype.cR = av;
|
|
|
+J.prototype.el = aO;
|
|
|
+J.prototype.add = bz;
|
|
|
+J.prototype.cv = be;
|
|
|
+J.prototype.multiply = bf;
|
|
|
+J.prototype.square = aJ;
|
|
|
+J.prototype.divide = ar;
|
|
|
+
|
|
|
+function G(dP, x, y, z) {
|
|
|
+ this.dP = dP;
|
|
|
+ this.x = x;
|
|
|
+ this.y = y;
|
|
|
+ if (z == null) {
|
|
|
+ this.z = L.ONE;
|
|
|
+ } else {
|
|
|
+ this.z = z;
|
|
|
+ }
|
|
|
+ this.gH = null;
|
|
|
+};
|
|
|
+
|
|
|
+function az() {
|
|
|
+ if (this.gH == null) {
|
|
|
+ this.gH = this.z.fZ(this.dP.q);
|
|
|
+ }
|
|
|
+ return this.dP.fm(this.x.cR().multiply(this.gH).cl(this.dP.q));
|
|
|
+};
|
|
|
+
|
|
|
+function bP() {
|
|
|
+ if (this.gH == null) {
|
|
|
+ this.gH = this.z.fZ(this.dP.q);
|
|
|
+ }
|
|
|
+ return this.dP.fm(this.y.cR().multiply(this.gH).cl(this.dP.q));
|
|
|
+};
|
|
|
+
|
|
|
+function bV(other) {
|
|
|
+ if (other == this) return true;
|
|
|
+ if (this.eg()) return other.eg();
|
|
|
+ if (other.eg()) return this.eg();
|
|
|
+ var u, v;
|
|
|
+ u = other.y.cR().multiply(this.z).cv(this.y.cR().multiply(other.z)).cl(this.dP.q);
|
|
|
+ if (!u.equals(L.ZERO)) return false;
|
|
|
+ v = other.x.cR().multiply(this.z).cv(this.x.cR().multiply(other.z)).cl(this.dP.q);
|
|
|
+ return v.equals(L.ZERO);
|
|
|
+};
|
|
|
+
|
|
|
+function bp() {
|
|
|
+ if ((this.x == null) && (this.y == null)) return true;
|
|
|
+ return this.z.equals(L.ZERO) && !this.y.cR().equals(L.ZERO);
|
|
|
+};
|
|
|
+
|
|
|
+function aX() {
|
|
|
+ return new G(this.dP, this.x, this.y.el(), this.z);
|
|
|
+};
|
|
|
+
|
|
|
+function aB(b) {
|
|
|
+ if (this.eg()) return b;
|
|
|
+ if (b.eg()) return this;
|
|
|
+ var u = b.y.cR().multiply(this.z).cv(this.y.cR().multiply(b.z)).cl(this.dP.q);
|
|
|
+ var v = b.x.cR().multiply(this.z).cv(this.x.cR().multiply(b.z)).cl(this.dP.q);
|
|
|
+ if (L.ZERO.equals(v)) {
|
|
|
+ if (L.ZERO.equals(u)) {
|
|
|
+ return this.gI();
|
|
|
+ }
|
|
|
+ return this.dP.gy();
|
|
|
+ }
|
|
|
+ var hm = new L("3");
|
|
|
+ var x1 = this.x.cR();
|
|
|
+ var y1 = this.y.cR();
|
|
|
+ var iT = v.square();
|
|
|
+ var hq = iT.multiply(v);
|
|
|
+ var iy = x1.multiply(iT);
|
|
|
+ var iq = u.square().multiply(this.z);
|
|
|
+ var eE = iq.cv(iy.shiftLeft(1)).multiply(b.z).cv(hq).multiply(v).cl(this.dP.q);
|
|
|
+ var fE = iy.multiply(hm).multiply(u).cv(y1.multiply(hq)).cv(iq.multiply(u)).multiply(b.z).add(u.multiply(hq)).cl(this
|
|
|
+ .dP.q);
|
|
|
+ var js = hq.multiply(this.z).multiply(b.z).cl(this.dP.q);
|
|
|
+ return new G(this.dP, this.dP.fm(eE), this.dP.fm(fE), js);
|
|
|
+};
|
|
|
+
|
|
|
+function bq() {
|
|
|
+ if (this.eg()) return this;
|
|
|
+ if (this.y.cR().eJ() == 0) return this.dP.gy();
|
|
|
+ var hm = new L("3");
|
|
|
+ var x1 = this.x.cR();
|
|
|
+ var y1 = this.y.cR();
|
|
|
+ var gz = y1.multiply(this.z);
|
|
|
+ var jp = gz.multiply(y1).cl(this.dP.q);
|
|
|
+ var a = this.dP.a.cR();
|
|
|
+ var w = x1.square().multiply(hm);
|
|
|
+ if (!L.ZERO.equals(a)) {
|
|
|
+ w = w.add(this.z.square().multiply(a));
|
|
|
+ }
|
|
|
+ w = w.cl(this.dP.q);
|
|
|
+ var eE = w.square().cv(x1.shiftLeft(3).multiply(jp)).shiftLeft(1).multiply(gz).cl(this.dP.q);
|
|
|
+ var fE = w.multiply(hm).multiply(x1).cv(jp.shiftLeft(1)).shiftLeft(2).multiply(jp).cv(w.square().multiply(w)).cl(this
|
|
|
+ .dP.q);
|
|
|
+ var js = gz.square().multiply(gz).shiftLeft(3).cl(this.dP.q);
|
|
|
+ return new G(this.dP, this.dP.fm(eE), this.dP.fm(fE), js);
|
|
|
+};
|
|
|
+
|
|
|
+function ai(k) {
|
|
|
+ if (this.eg()) return this;
|
|
|
+ if (k.eJ() == 0) return this.dP.gy();
|
|
|
+ var e = k;
|
|
|
+ var h = e.multiply(new L("3"));
|
|
|
+ var hw = this.el();
|
|
|
+ var R = this;
|
|
|
+ var i;
|
|
|
+ for (i = h.fg() - 2; i > 0; --i) {
|
|
|
+ R = R.gI();
|
|
|
+ var gm = h.en(i);
|
|
|
+ var hV = e.en(i);
|
|
|
+ if (gm != hV) {
|
|
|
+ R = R.add(gm ? this : hw);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return R;
|
|
|
+};
|
|
|
+
|
|
|
+function aS(j, x, k) {
|
|
|
+ var i;
|
|
|
+ if (j.fg() > k.fg()) i = j.fg() - 1;
|
|
|
+ else i = k.fg() - 1;
|
|
|
+ var R = this.dP.gy();
|
|
|
+ var both = this.add(x);
|
|
|
+ while (i >= 0) {
|
|
|
+ R = R.gI();
|
|
|
+ if (j.en(i)) {
|
|
|
+ if (k.en(i)) {
|
|
|
+ R = R.add(both);
|
|
|
+ } else {
|
|
|
+ R = R.add(this);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (k.en(i)) {
|
|
|
+ R = R.add(x);
|
|
|
+ }
|
|
|
+ } --i;
|
|
|
+ }
|
|
|
+ return R;
|
|
|
+};
|
|
|
+G.prototype.fI = az;
|
|
|
+G.prototype.ec = bP;
|
|
|
+G.prototype.equals = bV;
|
|
|
+G.prototype.eg = bp;
|
|
|
+G.prototype.el = aX;
|
|
|
+G.prototype.add = aB;
|
|
|
+G.prototype.gI = bq;
|
|
|
+G.prototype.multiply = ai;
|
|
|
+G.prototype.nb = aS;
|
|
|
+
|
|
|
+function V(q, a, b) {
|
|
|
+ this.q = q;
|
|
|
+ this.a = this.fm(a);
|
|
|
+ this.b = this.fm(b);
|
|
|
+ this.jz = new G(this, null, null);
|
|
|
+};
|
|
|
+
|
|
|
+function bO() {
|
|
|
+ return this.q;
|
|
|
+};
|
|
|
+
|
|
|
+function aW() {
|
|
|
+ return this.a;
|
|
|
+};
|
|
|
+
|
|
|
+function bc() {
|
|
|
+ return this.b;
|
|
|
+};
|
|
|
+
|
|
|
+function bJ(other) {
|
|
|
+ if (other == this) return true;
|
|
|
+ return (this.q.equals(other.q) && this.a.equals(other.a) && this.b.equals(other.b));
|
|
|
+};
|
|
|
+
|
|
|
+function bn() {
|
|
|
+ return this.jz;
|
|
|
+};
|
|
|
+
|
|
|
+function ae(x) {
|
|
|
+ return new J(this.q, x);
|
|
|
+};
|
|
|
+
|
|
|
+function by(s) {
|
|
|
+ switch (parseInt(s.substr(0, 2), 16)) {
|
|
|
+ case 0:
|
|
|
+ return this.jz;
|
|
|
+ case 2:
|
|
|
+ case 3:
|
|
|
+ return null;
|
|
|
+ case 4:
|
|
|
+ case 6:
|
|
|
+ case 7:
|
|
|
+ var dm = (s.length - 2) / 2;
|
|
|
+ var hf = s.substr(2, dm);
|
|
|
+ var ih = s.substr(dm + 2, dm);
|
|
|
+ return new G(this, this.fm(new L(hf, 16)), this.fm(new L(ih, 16)));
|
|
|
+ default:
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+function bG(x, y) {
|
|
|
+ return new G(this, this.fm(x), this.fm(y));
|
|
|
+};
|
|
|
+V.prototype.jh = bO;
|
|
|
+V.prototype.kH = aW;
|
|
|
+V.prototype.kB = bc;
|
|
|
+V.prototype.equals = bJ;
|
|
|
+V.prototype.gy = bn;
|
|
|
+V.prototype.fm = ae;
|
|
|
+V.prototype.kR = by;
|
|
|
+V.prototype.kU = bG;
|
|
|
+J.prototype.lO = function () {
|
|
|
+ return Math.floor((this.cR().fg() + 7) / 8);
|
|
|
+};
|
|
|
+G.prototype.mj = function (jG) {
|
|
|
+ var hM = function (i, dm) {
|
|
|
+ var ev = i.lW();
|
|
|
+ if (dm < ev.length) {
|
|
|
+ ev = ev.slice(ev.length - dm);
|
|
|
+ } else
|
|
|
+ while (dm > ev.length) {
|
|
|
+ ev.unshift(0);
|
|
|
+ }
|
|
|
+ return ev;
|
|
|
+ };
|
|
|
+ var x = this.fI().cR();
|
|
|
+ var y = this.ec().cR();
|
|
|
+ var ey = hM(x, 32);
|
|
|
+ if (jG) {
|
|
|
+ if (y.ef()) {
|
|
|
+ ey.unshift(0x02);
|
|
|
+ } else {
|
|
|
+ ey.unshift(0x03);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ ey.unshift(0x04);
|
|
|
+ ey = ey.concat(hM(y, 32));
|
|
|
+ }
|
|
|
+ return ey;
|
|
|
+};
|
|
|
+G.jZ = function (dP, ey) {
|
|
|
+ var ea = ey.length - 1;
|
|
|
+ var iP = ey.slice(1, 1 + ea / 2);
|
|
|
+ var je = ey.slice(1 + ea / 2, 1 + ea);
|
|
|
+ iP.unshift(0);
|
|
|
+ je.unshift(0);
|
|
|
+ var x = new L(iP);
|
|
|
+ var y = new L(je);
|
|
|
+ return new G(dP, dP.fm(x), dP.fm(y));
|
|
|
+};
|
|
|
+G.hQ = function (dP, hU) {
|
|
|
+ var ea = hU.length - 2;
|
|
|
+ var hf = hU.substr(2, ea / 2);
|
|
|
+ var ih = hU.substr(2 + ea / 2, ea / 2);
|
|
|
+ var x = new L(hf, 16);
|
|
|
+ var y = new L(ih, 16);
|
|
|
+ return new G(dP, dP.fm(x), dP.fm(y));
|
|
|
+};
|
|
|
+G.prototype.jK = function (b) {
|
|
|
+ if (this.eg()) return b;
|
|
|
+ if (b.eg()) return this;
|
|
|
+ if (this.x.equals(b.x)) {
|
|
|
+ if (this.y.equals(b.y)) {
|
|
|
+ return this.gI();
|
|
|
+ }
|
|
|
+ return this.dP.gy();
|
|
|
+ }
|
|
|
+ var kW = b.x.cv(this.x);
|
|
|
+ var la = b.y.cv(this.y);
|
|
|
+ var hl = la.divide(kW);
|
|
|
+ var eE = hl.square().cv(this.x).cv(b.x);
|
|
|
+ var fE = hl.multiply(this.x.cv(eE)).cv(this.y);
|
|
|
+ return new G(this.dP, eE, fE);
|
|
|
+};
|
|
|
+G.prototype.mV = function () {
|
|
|
+ if (this.eg()) return this;
|
|
|
+ if (this.y.cR().eJ() == 0) {
|
|
|
+ return this.dP.gy();
|
|
|
+ }
|
|
|
+ var jF = this.dP.fm(L.valueOf(2));
|
|
|
+ var hm = this.dP.fm(L.valueOf(3));
|
|
|
+ var hl = this.x.square().multiply(hm).add(this.dP.a).divide(this.y.multiply(jF));
|
|
|
+ var eE = hl.square().cv(this.x.multiply(jF));
|
|
|
+ var fE = hl.multiply(this.x.cv(eE)).cv(this.y);
|
|
|
+ return new G(this.dP, eE, fE);
|
|
|
+};
|
|
|
+G.prototype.nl = function (k) {
|
|
|
+ if (this.eg()) return this;
|
|
|
+ if (k.eJ() == 0) return this.dP.gy();
|
|
|
+ var e = k;
|
|
|
+ var h = e.multiply(new L("3"));
|
|
|
+ var hw = this.el();
|
|
|
+ var R = this;
|
|
|
+ var i;
|
|
|
+ for (i = h.fg() - 2; i > 0; --i) {
|
|
|
+ R = R.gI();
|
|
|
+ var gm = h.en(i);
|
|
|
+ var hV = e.en(i);
|
|
|
+ if (gm != hV) {
|
|
|
+ R = R.jK(gm ? this : hw);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return R;
|
|
|
+};
|
|
|
+G.prototype.kM = function () {
|
|
|
+ var x = this.fI().cR();
|
|
|
+ var y = this.ec().cR();
|
|
|
+ var a = this.dP.kH().cR();
|
|
|
+ var b = this.dP.kB().cR();
|
|
|
+ var n = this.dP.jh();
|
|
|
+ var lhs = y.multiply(y).cl(n);
|
|
|
+ var rhs = x.multiply(x).multiply(x).add(a.multiply(x)).add(b).cl(n);
|
|
|
+ return lhs.equals(rhs);
|
|
|
+};
|
|
|
+G.prototype.toString = function () {
|
|
|
+ return '(' + this.fI().cR().toString() + ',' + this.ec().cR().toString() + ')';
|
|
|
+};
|
|
|
+G.prototype.mY = function () {
|
|
|
+ var n = this.dP.jh();
|
|
|
+ if (this.eg()) {
|
|
|
+ throw new Error("Point is at jz.");
|
|
|
+ }
|
|
|
+ var x = this.fI().cR();
|
|
|
+ var y = this.ec().cR();
|
|
|
+ if (x.dw(L.ONE) < 0 || x.dw(n.cv(L.ONE)) > 0) {
|
|
|
+ throw new Error('x coordinate out of bounds');
|
|
|
+ }
|
|
|
+ if (y.dw(L.ONE) < 0 || y.dw(n.cv(L.ONE)) > 0) {
|
|
|
+ throw new Error('y coordinate out of bounds');
|
|
|
+ }
|
|
|
+ if (!this.kM()) {
|
|
|
+ throw new Error("Point is not on the dP.");
|
|
|
+ }
|
|
|
+ if (this.multiply(n).eg()) {
|
|
|
+ throw new Error("Point is not a scalar multiple of G.");
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+};
|
|
|
+
|
|
|
+function bo() {
|
|
|
+ this.fB = null;
|
|
|
+ this.et = null;
|
|
|
+ this.iA = null;
|
|
|
+ this.hb = 256;
|
|
|
+ this.ho = 0;
|
|
|
+ this.gR = 0;
|
|
|
+ this.eu = new Array();
|
|
|
+ if (this.fB == null) {
|
|
|
+ this.fB = new Array();
|
|
|
+ this.et = 0;
|
|
|
+ if (navigator.appName == "Netscape" && navigator.appVersion < "5" && window.crypto) {
|
|
|
+ var z = window.crypto.random(32);
|
|
|
+ for (var t = 0; t < z.length; ++t) {
|
|
|
+ this.fB[this.et++] = z.charCodeAt(t) & 255;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ while (this.et < this.hb) {
|
|
|
+ t = Math.floor(65536 * Math.random());
|
|
|
+ this.fB[this.et++] = t >>> 8;
|
|
|
+ this.fB[this.et++] = t & 255;
|
|
|
+ }
|
|
|
+ this.et = 0;
|
|
|
+ this.jj();
|
|
|
+ }
|
|
|
+};
|
|
|
+bo.prototype = {
|
|
|
+ ka: function (x) {
|
|
|
+ this.fB[this.et++] ^= x & 255;
|
|
|
+ this.fB[this.et++] ^= (x >> 8) & 255;
|
|
|
+ this.fB[this.et++] ^= (x >> 16) & 255;
|
|
|
+ this.fB[this.et++] ^= (x >> 24) & 255;
|
|
|
+ if (this.et >= this.hb) this.et -= this.hb;
|
|
|
+ },
|
|
|
+ jj: function () {
|
|
|
+ this.ka(new Date().getTime());
|
|
|
+ },
|
|
|
+ kg: function () {
|
|
|
+ if (this.iA == null) {
|
|
|
+ this.jj();
|
|
|
+ this.iA = 1;
|
|
|
+ this.gD(this.fB);
|
|
|
+ for (var et = 0; et < this.fB.length; ++et) {
|
|
|
+ this.fB[et] = 0;
|
|
|
+ }
|
|
|
+ this.et = 0;
|
|
|
+ }
|
|
|
+ return this.next();
|
|
|
+ },
|
|
|
+ kj: function (iQ) {
|
|
|
+ var i;
|
|
|
+ for (i = 0; i < iQ.length; ++i) iQ[i] = this.kg();
|
|
|
+ },
|
|
|
+ gD: function (key) {
|
|
|
+ var i, j, t;
|
|
|
+ for (i = 0; i < 256; ++i) this.eu[i] = i;
|
|
|
+ j = 0;
|
|
|
+ for (i = 0; i < 256; ++i) {
|
|
|
+ j = (j + this.eu[i] + key[i % key.length]) & 255;
|
|
|
+ t = this.eu[i];
|
|
|
+ this.eu[i] = this.eu[j];
|
|
|
+ this.eu[j] = t;
|
|
|
+ }
|
|
|
+ this.ho = 0;
|
|
|
+ this.gR = 0;
|
|
|
+ },
|
|
|
+ next: function () {
|
|
|
+ var t;
|
|
|
+ this.ho = (this.ho + 1) & 255;
|
|
|
+ this.gR = (this.gR + this.eu[this.ho]) & 255;
|
|
|
+ t = this.eu[this.ho];
|
|
|
+ this.eu[this.ho] = this.eu[this.gR];
|
|
|
+ this.eu[this.gR] = t;
|
|
|
+ return this.eu[(t + this.eu[this.ho]) & 255];
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+function aP() {
|
|
|
+ this.dX = new Array(0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7, 0x16, 0xb6, 0x14, 0xc2, 0x28, 0xfb, 0x2c, 0x05,
|
|
|
+ 0x2b, 0x67, 0x9a, 0x76, 0x2a, 0xbe, 0x04, 0xc3, 0xaa, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99, 0x9c, 0x42, 0x50,
|
|
|
+ 0xf4, 0x91, 0xef, 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43, 0xed, 0xcf, 0xac, 0x62, 0xe4, 0xb3, 0x1c, 0xa9, 0xc9, 0x08,
|
|
|
+ 0xe8, 0x95, 0x80, 0xdf, 0x94, 0xfa, 0x75, 0x8f, 0x3f, 0xa6, 0x47, 0x07, 0xa7, 0xfc, 0xf3, 0x73, 0x17, 0xba, 0x83,
|
|
|
+ 0x59, 0x3c, 0x19, 0xe6, 0x85, 0x4f, 0xa8, 0x68, 0x6b, 0x81, 0xb2, 0x71, 0x64, 0xda, 0x8b, 0xf8, 0xeb, 0x0f, 0x4b,
|
|
|
+ 0x70, 0x56, 0x9d, 0x35, 0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, 0xd1, 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78,
|
|
|
+ 0x87, 0xd4, 0x00, 0x46, 0x57, 0x9f, 0xd3, 0x27, 0x52, 0x4c, 0x36, 0x02, 0xe7, 0xa0, 0xc4, 0xc8, 0x9e, 0xea, 0xbf,
|
|
|
+ 0x8a, 0xd2, 0x40, 0xc7, 0x38, 0xb5, 0xa3, 0xf7, 0xf2, 0xce, 0xf9, 0x61, 0x15, 0xa1, 0xe0, 0xae, 0x5d, 0xa4, 0x9b,
|
|
|
+ 0x34, 0x1a, 0x55, 0xad, 0x93, 0x32, 0x30, 0xf5, 0x8c, 0xb1, 0xe3, 0x1d, 0xf6, 0xe2, 0x2e, 0x82, 0x66, 0xca, 0x60,
|
|
|
+ 0xc0, 0x29, 0x23, 0xab, 0x0d, 0x53, 0x4e, 0x6f, 0xd5, 0xdb, 0x37, 0x45, 0xde, 0xfd, 0x8e, 0x2f, 0x03, 0xff, 0x6a,
|
|
|
+ 0x72, 0x6d, 0x6c, 0x5b, 0x51, 0x8d, 0x1b, 0xaf, 0x92, 0xbb, 0xdd, 0xbc, 0x7f, 0x11, 0xd9, 0x5c, 0x41, 0x1f, 0x10,
|
|
|
+ 0x5a, 0xd8, 0x0a, 0xc1, 0x31, 0x88, 0xa5, 0xcd, 0x7b, 0xbd, 0x2d, 0x74, 0xd0, 0x12, 0xb8, 0xe5, 0xb4, 0xb0, 0x89,
|
|
|
+ 0x69, 0x97, 0x4a, 0x0c, 0x96, 0x77, 0x7e, 0x65, 0xb9, 0xf1, 0x09, 0xc5, 0x6e, 0xc6, 0x84, 0x18, 0xf0, 0x7d, 0xec,
|
|
|
+ 0x3a, 0xdc, 0x4d, 0x20, 0x79, 0xee, 0x5f, 0x3e, 0xd7, 0xcb, 0x39, 0x48);
|
|
|
+ this.gi = new Array(0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc);
|
|
|
+ this.kw = new Array(0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269, 0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
|
|
|
+ 0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249, 0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9, 0xc0c7ced5,
|
|
|
+ 0xdce3eaf1, 0xf8ff060d, 0x141b2229, 0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299, 0xa0a7aeb5, 0xbcc3cad1,
|
|
|
+ 0xd8dfe6ed, 0xf4fb0209, 0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279);
|
|
|
+};
|
|
|
+aP.prototype = {
|
|
|
+ hy: function (key) {
|
|
|
+ var k = new Array(36);
|
|
|
+ var gM = aI(key);
|
|
|
+ k[0] = gM[0] ^ this.gi[0];
|
|
|
+ k[1] = gM[1] ^ this.gi[1];
|
|
|
+ k[2] = gM[2] ^ this.gi[2];
|
|
|
+ k[3] = gM[3] ^ this.gi[3];
|
|
|
+ var fH = new Array(32);
|
|
|
+ for (var i = 0; i < 32; i++) {
|
|
|
+ k[(i + 4)] = (k[i] ^ this.jO(k[(i + 1)] ^ k[(i + 2)] ^ k[(i + 3)] ^ this.kw[i]));
|
|
|
+ fH[i] = k[(i + 4)];
|
|
|
+ }
|
|
|
+ return fH;
|
|
|
+ },
|
|
|
+ jO: function (fS) {
|
|
|
+ var b = new Array(4);
|
|
|
+ var a = F(fS);
|
|
|
+ b[0] = this.dX[a[0] & 0xFF];
|
|
|
+ b[1] = this.dX[a[1] & 0xFF];
|
|
|
+ b[2] = this.dX[a[2] & 0xFF];
|
|
|
+ b[3] = this.dX[a[3] & 0xFF];
|
|
|
+ var ek = bB(b, 0);
|
|
|
+ var fH = ek ^ (ek << 13 | (ek >>> (32 - 13))) ^ (ek << 23 | (ek >>> (32 - 23)));
|
|
|
+ return fH;
|
|
|
+ },
|
|
|
+ eA: function (fH, data) {
|
|
|
+ var x = new Array(36);
|
|
|
+ x[0] = bB(data, 0);
|
|
|
+ x[1] = bB(data, 4);
|
|
|
+ x[2] = bB(data, 8);
|
|
|
+ x[3] = bB(data, 12);
|
|
|
+ for (var i = 0; i < 32; i++) {
|
|
|
+ x[(i + 4)] = x[i] ^ this.kN(x[(i + 1)] ^ x[(i + 2)] ^ x[(i + 3)] ^ fH[i]);
|
|
|
+ }
|
|
|
+ var iI = new Array(4);
|
|
|
+ for (var i = 35; i >= 32; i--) {
|
|
|
+ iI[35 - i] = x[i];
|
|
|
+ }
|
|
|
+ var kS = ap(iI);
|
|
|
+ return kS;
|
|
|
+ },
|
|
|
+ kN: function (fS) {
|
|
|
+ var a = F(fS);
|
|
|
+ var b = new Array(4);
|
|
|
+ b[0] = this.dX[a[0] & 0xFF];
|
|
|
+ b[1] = this.dX[a[1] & 0xFF];
|
|
|
+ b[2] = this.dX[a[2] & 0xFF];
|
|
|
+ b[3] = this.dX[a[3] & 0xFF];
|
|
|
+ var ek = bB(b, 0);
|
|
|
+ var c = ek ^ (ek << 2 | (ek >>> (32 - 2))) ^ (ek << 10 | (ek >>> (32 - 10))) ^ (ek << 18 | (ek >>> (32 - 18))) ^
|
|
|
+ (ek << 24 | (ek >>> (32 - 24)));
|
|
|
+ return c;
|
|
|
+ },
|
|
|
+ gY: function (input, mode) {
|
|
|
+ if (input == null) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var gT = null;
|
|
|
+ if (mode == 1) {
|
|
|
+ var p = 16 - input.length % 16;
|
|
|
+ gT = new Array(input.length + p);
|
|
|
+ K(input, 0, gT, 0, input.length);
|
|
|
+ for (var i = 0; i < p; i++) {
|
|
|
+ gT[input.length + i] = p;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ var p = input[input.length - 1];
|
|
|
+ gT = new Array(input.length - p);
|
|
|
+ K(input, 0, gT, 0, input.length - p);
|
|
|
+ }
|
|
|
+ return gT;
|
|
|
+ },
|
|
|
+ lk: function (data, key) {
|
|
|
+ if (data == undefined || data == null || data.length <= 0) {
|
|
|
+ dB.log("data is error!");
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (key == undefined || key == null || key.length % 16 != 0) {
|
|
|
+ dB.log("dV key is error!");
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var fH = this.hy(key);
|
|
|
+ var cU = 16;
|
|
|
+ var loop = parseInt(data.length / cU);
|
|
|
+ var cw = new Array((loop + 1) * cU);
|
|
|
+ var dF = new Array(cU);
|
|
|
+ var hk = null;
|
|
|
+ for (var i = 0; i < loop; i++) {
|
|
|
+ K(data, i * cU, dF, 0, cU);
|
|
|
+ hk = this.eA(fH, dF);
|
|
|
+ K(hk, 0, cw, i * cU, cU);
|
|
|
+ }
|
|
|
+ var eR = new Array(data.length % cU);
|
|
|
+ if (eR.length > 0) {
|
|
|
+ K(data, loop * cU, eR, 0, data.length % cU);
|
|
|
+ }
|
|
|
+ var padding = this.gY(eR, 1);
|
|
|
+ hk = this.eA(fH, padding);
|
|
|
+ K(hk, 0, cw, loop * cU, cU);
|
|
|
+ return cw;
|
|
|
+ },
|
|
|
+ kY: function (data, key) {
|
|
|
+ if (data == undefined || data == null || data.length % 16 != 0) {
|
|
|
+ dB.log("data is error!");
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (key == undefined || key == null || key.length % 16 != 0) {
|
|
|
+ dB.log("dV key is error!");
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var fH = this.hy(key);
|
|
|
+ var gW = new Array(32);
|
|
|
+ for (var i = 0; i < fH.length; i++) {
|
|
|
+ gW[i] = fH[32 - i - 1];
|
|
|
+ }
|
|
|
+ var cU = 16;
|
|
|
+ var loop = data.length / cU - 1;
|
|
|
+ var dF = new Array(cU);
|
|
|
+ var fh = null;
|
|
|
+ var fz = null;
|
|
|
+ K(data, loop * cU, dF, 0, cU);
|
|
|
+ fh = this.eA(gW, dF);
|
|
|
+ var eY = this.gY(fh, 0);
|
|
|
+ fz = new Array(loop * cU + eY.length);
|
|
|
+ K(eY, 0, fz, loop * cU, eY.length);
|
|
|
+ for (var i = 0; i < loop; i++) {
|
|
|
+ K(data, i * cU, dF, 0, cU);
|
|
|
+ fh = this.eA(gW, dF);
|
|
|
+ K(fh, 0, fz, i * cU, cU);
|
|
|
+ }
|
|
|
+ return fz;
|
|
|
+ },
|
|
|
+ ll: function (data, key, cd) {
|
|
|
+ if (cd == undefined || cd == null || cd.length % 16 != 0) {
|
|
|
+ dB.log("cd is error!");
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (key == undefined || key == null || key.length % 16 != 0) {
|
|
|
+ dB.log("dV key is error!");
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (data == undefined || data == null || data.length <= 0) {
|
|
|
+ dB.log("data is error!");
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var fH = this.hy(key);
|
|
|
+ var cU = 16;
|
|
|
+ var loop = parseInt(data.length / cU);
|
|
|
+ var cw = new Array((loop + 1) * cU);
|
|
|
+ var dF = new Array(cU);
|
|
|
+ for (var i = 0; i < loop; i++) {
|
|
|
+ K(data, i * cU, dF, 0, cU);
|
|
|
+ for (var j = 0; j < cU; j++) {
|
|
|
+ dF[j] = dF[j] ^ cd[j];
|
|
|
+ }
|
|
|
+ cd = this.eA(fH, dF);
|
|
|
+ K(cd, 0, cw, i * cU, cU);
|
|
|
+ }
|
|
|
+ var eR = new Array(data.length % cU);
|
|
|
+ if (eR.length > 0) {
|
|
|
+ K(data, loop * cU, eR, 0, data.length % cU);
|
|
|
+ }
|
|
|
+ var padding = this.gY(eR, 1);
|
|
|
+ for (var i = 0; i < cU; i++) {
|
|
|
+ padding[i] = padding[i] ^ cd[i];
|
|
|
+ }
|
|
|
+ cd = this.eA(fH, padding);
|
|
|
+ K(cd, 0, cw, loop * cU, cU);
|
|
|
+ return cw;
|
|
|
+ },
|
|
|
+ kD: function (data, key, cd) {
|
|
|
+ if (cd == undefined || cd == null || cd.length % 16 != 0) {
|
|
|
+ dB.log("cd is error!");
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (key == undefined || key == null || key.length % 16 != 0) {
|
|
|
+ dB.log("dV key is error!");
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (data == undefined || data == null || data.length % 16 != 0) {
|
|
|
+ dB.log("data is error!");
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var fH = this.hy(key);
|
|
|
+ var gW = new Array(32);
|
|
|
+ for (var i = 0; i < fH.length; i++) {
|
|
|
+ gW[i] = fH[32 - i - 1];
|
|
|
+ }
|
|
|
+ var cU = 16;
|
|
|
+ var loop = data.length / cU;
|
|
|
+ var dF = new Array(cU);
|
|
|
+ var fh = null;
|
|
|
+ var fz = null;
|
|
|
+ fz = new Array(data.length);
|
|
|
+ for (var i = 0; i < loop; i++) {
|
|
|
+ K(data, i * cU, dF, 0, cU);
|
|
|
+ fh = this.eA(gW, dF);
|
|
|
+ for (var j = 0; j < cU; j++) {
|
|
|
+ fh[j] = fh[j] ^ cd[j];
|
|
|
+ }
|
|
|
+ K(dF, 0, cd, 0, cU);
|
|
|
+ K(fh, 0, fz, i * cU, cU);
|
|
|
+ }
|
|
|
+ var eY = this.gY(fh, 0);
|
|
|
+ var gq = new Array(fz.length - cU + eY.length);
|
|
|
+ K(fz, 0, gq, 0, fz.length - cU);
|
|
|
+ K(eY, 0, gq, fz.length - cU, eY.length);
|
|
|
+ return gq;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+function T() {
|
|
|
+ this.ft = new Array();
|
|
|
+ this.eW = 0;
|
|
|
+ this.hB = 0;
|
|
|
+ this.hZ = 32;
|
|
|
+ this.gU = [0x7380166f, 0x4914b2b9, 0x172442d7, 0xda8a0600, 0xa96f30bc, 0x163138aa, 0xe38dee4d, 0xb0fb0e4e];
|
|
|
+ this.gU = [0x7380166f, 0x4914b2b9, 0x172442d7, -628488704, -1452330820, 0x163138aa, -477237683, -1325724082];
|
|
|
+ this.v = new Array(8);
|
|
|
+ this.jJ = new Array(8);
|
|
|
+ this.fU = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
|
|
|
+ this.X = new Array(68);
|
|
|
+ this.eI = 0;
|
|
|
+ this.lw = 0x79cc4519;
|
|
|
+ this.lz = 0x7a879d8a;
|
|
|
+ if (arguments.length > 0) {
|
|
|
+ this.lc(arguments[0]);
|
|
|
+ } else {
|
|
|
+ this.gD();
|
|
|
+ }
|
|
|
+};
|
|
|
+T.prototype = {
|
|
|
+ dj: {
|
|
|
+ ki: -parseInt('10000000000000000000000000000000', 2),
|
|
|
+ ir: parseInt('1111111111111111111111111111111', 2),
|
|
|
+ parse: function (n) {
|
|
|
+ if (n < this.ki) {
|
|
|
+ var fa = new Number(-n);
|
|
|
+ var fe = fa.toString(2);
|
|
|
+ var dU = fe.substr(fe.length - 31, 31);
|
|
|
+ var fC = '';
|
|
|
+ for (var i = 0; i < dU.length; i++) {
|
|
|
+ var hE = dU.substr(i, 1);
|
|
|
+ fC += hE == '0' ? '1' : '0';
|
|
|
+ }
|
|
|
+ var result = parseInt(fC, 2);
|
|
|
+ return (result + 1);
|
|
|
+ } else if (n > this.ir) {
|
|
|
+ var fa = Number(n);
|
|
|
+ var fe = fa.toString(2);
|
|
|
+ var dU = fe.substr(fe.length - 31, 31);
|
|
|
+ var fC = '';
|
|
|
+ for (var i = 0; i < dU.length; i++) {
|
|
|
+ var hE = dU.substr(i, 1);
|
|
|
+ fC += hE == '0' ? '1' : '0';
|
|
|
+ }
|
|
|
+ var result = parseInt(fC, 2);
|
|
|
+ return -(result + 1);
|
|
|
+ } else {
|
|
|
+ return n;
|
|
|
+ }
|
|
|
+ },
|
|
|
+ gK: function (n) {
|
|
|
+ if (n < 0) {
|
|
|
+ var fa = new Number(-n);
|
|
|
+ var fe = fa.toString(2);
|
|
|
+ var dU = fe.substr(fe.length - 8, 8);
|
|
|
+ var fC = '';
|
|
|
+ for (var i = 0; i < dU.length; i++) {
|
|
|
+ var hE = dU.substr(i, 1);
|
|
|
+ fC += hE == '0' ? '1' : '0';
|
|
|
+ }
|
|
|
+ var result = parseInt(fC, 2);
|
|
|
+ return (result + 1);
|
|
|
+ } else if (n > 255) {
|
|
|
+ var fa = Number(n);
|
|
|
+ var fe = fa.toString(2);
|
|
|
+ return parseInt(fe.substr(fe.length - 8, 8), 2);
|
|
|
+ } else {
|
|
|
+ return n;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ gD: function () {
|
|
|
+ this.ft = new Array(4);
|
|
|
+ this.reset();
|
|
|
+ },
|
|
|
+ lc: function (t) {
|
|
|
+ this.ft = [].concat(t.ft);
|
|
|
+ this.eW = t.eW;
|
|
|
+ this.hB = t.hB;
|
|
|
+ K(t.X, 0, this.X, 0, t.X.length);
|
|
|
+ this.eI = t.eI;
|
|
|
+ K(t.v, 0, this.v, 0, t.v.length);
|
|
|
+ },
|
|
|
+ hL: function () {
|
|
|
+ return this.hZ;
|
|
|
+ },
|
|
|
+ reset: function () {
|
|
|
+ this.hB = 0;
|
|
|
+ this.eW = 0;
|
|
|
+ for (var kc in this.ft) this.ft[kc] = null;
|
|
|
+ K(this.gU, 0, this.v, 0, this.gU.length);
|
|
|
+ this.eI = 0;
|
|
|
+ K(this.fU, 0, this.X, 0, this.fU.length);
|
|
|
+ },
|
|
|
+ hS: function () {
|
|
|
+ var i;
|
|
|
+ var fs = this.X;
|
|
|
+ var gu = new Array(64);
|
|
|
+ for (i = 16; i < 68; i++) {
|
|
|
+ fs[i] = this.kT(fs[i - 16] ^ fs[i - 9] ^ (this.rotate(fs[i - 3], 15))) ^ (this.rotate(fs[i - 13], 7)) ^ fs[i -
|
|
|
+ 6];
|
|
|
+ }
|
|
|
+ for (i = 0; i < 64; i++) {
|
|
|
+ gu[i] = fs[i] ^ fs[i + 4];
|
|
|
+ }
|
|
|
+ var ej = this.v;
|
|
|
+ var dr = this.jJ;
|
|
|
+ K(ej, 0, dr, 0, this.gU.length);
|
|
|
+ var fj, fV, hI, fQ, fW;
|
|
|
+ for (i = 0; i < 16; i++) {
|
|
|
+ fW = this.rotate(dr[0], 12);
|
|
|
+ fj = this.dj.parse(this.dj.parse(fW + dr[4]) + this.rotate(this.lw, i));
|
|
|
+ fj = this.rotate(fj, 7);
|
|
|
+ fV = fj ^ fW;
|
|
|
+ hI = this.dj.parse(this.dj.parse(this.lu(dr[0], dr[1], dr[2]) + dr[3]) + fV) + gu[i];
|
|
|
+ fQ = this.dj.parse(this.dj.parse(this.ky(dr[4], dr[5], dr[6]) + dr[7]) + fj) + fs[i];
|
|
|
+ dr[3] = dr[2];
|
|
|
+ dr[2] = this.rotate(dr[1], 9);
|
|
|
+ dr[1] = dr[0];
|
|
|
+ dr[0] = hI;
|
|
|
+ dr[7] = dr[6];
|
|
|
+ dr[6] = this.rotate(dr[5], 19);
|
|
|
+ dr[5] = dr[4];
|
|
|
+ dr[4] = this.ii(fQ);
|
|
|
+ }
|
|
|
+ for (i = 16; i < 64; i++) {
|
|
|
+ fW = this.rotate(dr[0], 12);
|
|
|
+ fj = this.dj.parse(this.dj.parse(fW + dr[4]) + this.rotate(this.lz, i));
|
|
|
+ fj = this.rotate(fj, 7);
|
|
|
+ fV = fj ^ fW;
|
|
|
+ hI = this.dj.parse(this.dj.parse(this.kk(dr[0], dr[1], dr[2]) + dr[3]) + fV) + gu[i];
|
|
|
+ fQ = this.dj.parse(this.dj.parse(this.jL(dr[4], dr[5], dr[6]) + dr[7]) + fj) + fs[i];
|
|
|
+ dr[3] = dr[2];
|
|
|
+ dr[2] = this.rotate(dr[1], 9);
|
|
|
+ dr[1] = dr[0];
|
|
|
+ dr[0] = hI;
|
|
|
+ dr[7] = dr[6];
|
|
|
+ dr[6] = this.rotate(dr[5], 19);
|
|
|
+ dr[5] = dr[4];
|
|
|
+ dr[4] = this.ii(fQ);
|
|
|
+ }
|
|
|
+ for (i = 0; i < 8; i++) {
|
|
|
+ ej[i] ^= this.dj.parse(dr[i]);
|
|
|
+ }
|
|
|
+ this.eI = 0;
|
|
|
+ K(this.fU, 0, this.X, 0, this.fU.length);
|
|
|
+ },
|
|
|
+ iC: function (hg, ee) {
|
|
|
+ var n = hg[ee] << 24;
|
|
|
+ n |= (hg[++ee] & 0xff) << 16;
|
|
|
+ n |= (hg[++ee] & 0xff) << 8;
|
|
|
+ n |= (hg[++ee] & 0xff);
|
|
|
+ this.X[this.eI] = n;
|
|
|
+ if (++this.eI == 16) {
|
|
|
+ this.hS();
|
|
|
+ }
|
|
|
+ },
|
|
|
+ ly: function (fg) {
|
|
|
+ if (this.eI > 14) {
|
|
|
+ this.hS();
|
|
|
+ }
|
|
|
+ this.X[14] = (this.ke(fg, 32));
|
|
|
+ this.X[15] = (fg & (0xffffffff));
|
|
|
+ },
|
|
|
+ kP: function (n, fD, off) {
|
|
|
+ fD[off] = this.dj.gK(this.hu(n, 24)) & 0x000000FF;
|
|
|
+ fD[++off] = this.dj.gK(this.hu(n, 16)) & 0x000000FF;
|
|
|
+ fD[++off] = this.dj.gK(this.hu(n, 8)) & 0x000000FF;
|
|
|
+ fD[++off] = this.dj.gK(n) & 0x000000FF;
|
|
|
+ },
|
|
|
+ gN: function (lm, lv) {
|
|
|
+ this.finish();
|
|
|
+ for (var i = 0; i < 8; i++) {
|
|
|
+ this.kP(this.v[i], lm, lv + i * 4);
|
|
|
+ }
|
|
|
+ this.reset();
|
|
|
+ return this.hZ;
|
|
|
+ },
|
|
|
+ update: function (input) {
|
|
|
+ this.ft[this.eW++] = input;
|
|
|
+ if (this.eW == this.ft.length) {
|
|
|
+ this.iC(this.ft, 0);
|
|
|
+ this.eW = 0;
|
|
|
+ }
|
|
|
+ this.hB++;
|
|
|
+ },
|
|
|
+ fc: function (input, ee, length) {
|
|
|
+ while ((this.eW != 0) && (length > 0)) {
|
|
|
+ this.update(input[ee]);
|
|
|
+ ee++;
|
|
|
+ length--;
|
|
|
+ }
|
|
|
+ while (length > this.ft.length) {
|
|
|
+ this.iC(input, ee);
|
|
|
+ ee += this.ft.length;
|
|
|
+ length -= this.ft.length;
|
|
|
+ this.hB += this.ft.length;
|
|
|
+ }
|
|
|
+ while (length > 0) {
|
|
|
+ this.update(input[ee]);
|
|
|
+ ee++;
|
|
|
+ length--;
|
|
|
+ }
|
|
|
+ },
|
|
|
+ finish: function () {
|
|
|
+ var fg = (this.hB << 3);
|
|
|
+ this.update((128));
|
|
|
+ while (this.eW != 0) this.update((0));
|
|
|
+ this.ly(fg);
|
|
|
+ this.hS();
|
|
|
+ },
|
|
|
+ rotate: function (x, n) {
|
|
|
+ return (x << n) | (this.hu(x, (32 - n)));
|
|
|
+ },
|
|
|
+ ii: function (X) {
|
|
|
+ return ((X) ^ this.rotate((X), 9) ^ this.rotate((X), 17));
|
|
|
+ },
|
|
|
+ kT: function (X) {
|
|
|
+ return ((X) ^ this.rotate((X), 15) ^ this.rotate((X), 23));
|
|
|
+ },
|
|
|
+ lu: function (X, Y, Z) {
|
|
|
+ return (X ^ Y ^ Z);
|
|
|
+ },
|
|
|
+ kk: function (X, Y, Z) {
|
|
|
+ return ((X & Y) | (X & Z) | (Y & Z));
|
|
|
+ },
|
|
|
+ ky: function (X, Y, Z) {
|
|
|
+ return (X ^ Y ^ Z);
|
|
|
+ },
|
|
|
+ jL: function (X, Y, Z) {
|
|
|
+ return ((X & Y) | (~X & Z));
|
|
|
+ },
|
|
|
+ hu: function (number, fu) {
|
|
|
+ if (number > this.dj.ir || number < this.dj.ki) {
|
|
|
+ number = this.dj.parse(number);
|
|
|
+ }
|
|
|
+ if (number >= 0) {
|
|
|
+ return number >> fu;
|
|
|
+ } else {
|
|
|
+ return (number >> fu) + (2 << ~fu);
|
|
|
+ }
|
|
|
+ },
|
|
|
+ ke: function (number, fu) {
|
|
|
+ var fR;
|
|
|
+ var big = new L();
|
|
|
+ big.eT(number);
|
|
|
+ if (big.eJ() >= 0) {
|
|
|
+ fR = big.ic(fu).hs();
|
|
|
+ } else {
|
|
|
+ var jm = new L();
|
|
|
+ jm.eT(2);
|
|
|
+ var iU = ~fu;
|
|
|
+ var gh = '';
|
|
|
+ if (iU < 0) {
|
|
|
+ var jS = 64 + iU;
|
|
|
+ for (var i = 0; i < jS; i++) {
|
|
|
+ gh += '0';
|
|
|
+ }
|
|
|
+ var jE = new L();
|
|
|
+ jE.eT(number >> fu);
|
|
|
+ var jC = new L("10" + gh, 2);
|
|
|
+ gh = jC.eD(10);
|
|
|
+ var r = jC.add(jE);
|
|
|
+ fR = r.eD(10);
|
|
|
+ } else {
|
|
|
+ gh = jm.shiftLeft((~fu)).hs();
|
|
|
+ fR = (number >> fu) + gh;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return fR;
|
|
|
+ },
|
|
|
+ jN: function (g, kz) {
|
|
|
+ var jf = new Array(32);
|
|
|
+ var iz = new Array(32);
|
|
|
+ K(kz, 1, jf, 0, 32);
|
|
|
+ K(kz, 33, iz, 0, 32);
|
|
|
+ var iB = CommonUtils.utf8StrToHex('1234567812345678');
|
|
|
+ var dm = iB.length * 4;
|
|
|
+ this.update((dm >> 8 & 0x00ff));
|
|
|
+ this.update((dm & 0x00ff));
|
|
|
+ var ia = this.gB(iB);
|
|
|
+ this.fc(ia, 0, ia.length);
|
|
|
+ var it = this.gB(g.dP.a.cR().eD(16));
|
|
|
+ var ip = this.gB(g.dP.b.cR().eD(16));
|
|
|
+ var jl = this.gB(g.fI().cR().eD(16));
|
|
|
+ var ie = this.gB(g.ec().cR().eD(16));
|
|
|
+ var ig = jf;
|
|
|
+ var iu = iz;
|
|
|
+ this.fc(it, 0, it.length);
|
|
|
+ this.fc(ip, 0, ip.length);
|
|
|
+ this.fc(jl, 0, jl.length);
|
|
|
+ this.fc(ie, 0, ie.length);
|
|
|
+ this.fc(ig, 0, ig.length);
|
|
|
+ this.fc(iu, 0, iu.length);
|
|
|
+ var hX = new Array(this.hL());
|
|
|
+ this.gN(hX, 0);
|
|
|
+ return hX;
|
|
|
+ },
|
|
|
+ gB: function (jq) {
|
|
|
+ var eN = [];
|
|
|
+ var lp = jq.length;
|
|
|
+ for (var i = 0; i < lp; i += 2) {
|
|
|
+ eN.push(parseInt(jq.substr(i, 2), 16));
|
|
|
+ }
|
|
|
+ return eN;
|
|
|
+ }
|
|
|
+};
|
|
|
+window.CipherMode = {
|
|
|
+ C1C2C3: 0,
|
|
|
+ C1C3C2: 1,
|
|
|
+ c1c2c3: 0,
|
|
|
+ c1c3c2: 1
|
|
|
+};
|
|
|
+
|
|
|
+function aK(eV, eC) {
|
|
|
+ if (typeof (eV) != 'undefined' && eV === 1) {
|
|
|
+ this.eV = CipherMode.C1C3C2;
|
|
|
+ } else {
|
|
|
+ this.eV = CipherMode.C1C2C3;
|
|
|
+ }
|
|
|
+ if (typeof (eC) != 'undefined' && CommonUtils.isHexString(eC)) {
|
|
|
+ this.eC = eC;
|
|
|
+ } else {
|
|
|
+ this.eC = null;
|
|
|
+ }
|
|
|
+ this.kQ = new L("FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF", 16);
|
|
|
+ this.ks = new L("FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC", 16);
|
|
|
+ this.kG = new L("28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93", 16);
|
|
|
+ this.eB = new L("FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123", 16);
|
|
|
+ this.jX = new L("32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7", 16);
|
|
|
+ this.kI = new L("BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0", 16);
|
|
|
+ this.lK = 256;
|
|
|
+ this.jM = new bo();
|
|
|
+ this.gZ = new V(this.kQ, this.ks, this.kG);
|
|
|
+ this.ha = G.hQ(this.gZ, "04" + this.jX.toString(16) + this.kI.toString(16));
|
|
|
+};
|
|
|
+aK.prototype = {
|
|
|
+ jU: function (jo) {
|
|
|
+ return new L(jo.fg(), this.jM).cl(jo.cv(L.ONE)).add(L.ONE);
|
|
|
+ },
|
|
|
+ generateKeyPair: function () {
|
|
|
+ var eF = this.jt();
|
|
|
+ var cZ = eF['gk'].gv();
|
|
|
+ var jd = eF['fb'].fI().cR();
|
|
|
+ var jn = eF['fb'].ec().cR();
|
|
|
+ var jH = this.fN(jd, 32);
|
|
|
+ var lj = this.fN(jn, 32);
|
|
|
+ var dC = new Array(65);
|
|
|
+ dC[0] = 0x04;
|
|
|
+ K(jH, 0, dC, 1, 32);
|
|
|
+ K(lj, 0, dC, 33, 32);
|
|
|
+ return {
|
|
|
+ 'gk': cZ,
|
|
|
+ 'fb': dC
|
|
|
+ };
|
|
|
+ },
|
|
|
+ kX: function () {
|
|
|
+ var eF = this.generateKeyPair();
|
|
|
+ var lo = eF.fb;
|
|
|
+ var lA = eF.gk;
|
|
|
+ return {
|
|
|
+ 'prvkeyhex': CommonUtils.bytesToHex(lA),
|
|
|
+ 'pubkeyhex': CommonUtils.bytesToHex(lo)
|
|
|
+ };
|
|
|
+ },
|
|
|
+ jt: function (eC) {
|
|
|
+ var iJ = this.eB;
|
|
|
+ var gF = null;
|
|
|
+ var iV = null;
|
|
|
+ if (CommonUtils.isHexString(eC)) {
|
|
|
+ gF = new L(eC, 16);
|
|
|
+ } else {
|
|
|
+ do {
|
|
|
+ gF = this.jU(iJ);
|
|
|
+ } while (gF.equals(L.ZERO) || gF.dw(iJ) >= 0);
|
|
|
+ }
|
|
|
+ iV = this.ha.multiply(gF);
|
|
|
+ return {
|
|
|
+ 'gk': gF,
|
|
|
+ "fb": iV
|
|
|
+ };
|
|
|
+ },
|
|
|
+ jR: function (cZ) {
|
|
|
+ var hn = this.ha.multiply(new L(CommonUtils.bytesToHex(cZ), 16));
|
|
|
+ var x = this.fN(hn.fI().cR(), 32);
|
|
|
+ var y = this.fN(hn.ec().cR(), 32);
|
|
|
+ var dC = new Array(65);
|
|
|
+ dC[0] = 0x04;
|
|
|
+ K(x, 0, dC, 1, 32);
|
|
|
+ K(y, 0, dC, 33, 32);
|
|
|
+ return dC;
|
|
|
+ },
|
|
|
+ jT: function () {
|
|
|
+ var eF = this.jt();
|
|
|
+ var jd = eF['fb'].fI().cR();
|
|
|
+ var jn = eF['fb'].ec().cR();
|
|
|
+ var hn = this.gZ.kU(jd, jn);
|
|
|
+ eF.x1 = hn.fI().cR();
|
|
|
+ return eF;
|
|
|
+ },
|
|
|
+ fN: function (kb, hH) {
|
|
|
+ var dF = new Array(hH);
|
|
|
+ for (var i = 0; i < dF.length; i++) {
|
|
|
+ dF[i] = 0;
|
|
|
+ }
|
|
|
+ var eK = kb.gv();
|
|
|
+ if (eK == null) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (eK.length > hH) {
|
|
|
+ K(eK, eK.length - hH, dF, 0, hH);
|
|
|
+ } else if (eK.length == hH) {
|
|
|
+ dF = eK;
|
|
|
+ } else {
|
|
|
+ K(eK, 0, dF, hH - eK.length, eK.length);
|
|
|
+ }
|
|
|
+ return dF;
|
|
|
+ },
|
|
|
+ iH: function (eU, data) {
|
|
|
+ var loop = Math.ceil(data.length / 32);
|
|
|
+ var eP;
|
|
|
+ var hash = new Array(32);
|
|
|
+ for (var i = 0; i < loop; i++) {
|
|
|
+ eP = new T();
|
|
|
+ eP.fc(eU, 0, eU.length);
|
|
|
+ eP.fc(F(i + 1), 0, 4);
|
|
|
+ eP.gN(hash, 0);
|
|
|
+ for (var j = 0; j < hash.length && (i * 32 + j) < data.length; j++) {
|
|
|
+ data[i * 32 + j] ^= hash[j];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+ },
|
|
|
+ iO: function (data, dC) {
|
|
|
+ var hi = new T();
|
|
|
+ var iK = new T().jN(this.ha, dC);
|
|
|
+ var hO = data;
|
|
|
+ var eQ = new Array(hi.hL());
|
|
|
+ hi.fc(iK, 0, iK.length);
|
|
|
+ hi.fc(hO, 0, hO.length);
|
|
|
+ hi.gN(eQ, 0);
|
|
|
+ return eQ;
|
|
|
+ },
|
|
|
+ er: function (data, cZ, bZ) {
|
|
|
+ var dC = this.jR(cZ);
|
|
|
+ var eQ = this.iO(data, dC);
|
|
|
+ var iE = new L(CommonUtils.bytesToHex(cZ), 16);
|
|
|
+ var e = new L(CommonUtils.bytesToHex(eQ), 16);
|
|
|
+ var k = null;
|
|
|
+ var r = null;
|
|
|
+ var s = null;
|
|
|
+ do {
|
|
|
+ do {
|
|
|
+ var ib = this.jT();
|
|
|
+ k = ib.gk;
|
|
|
+ r = e.add(ib.x1).cl(this.eB);
|
|
|
+ } while (r.equals(L.ZERO) || r.add(k).equals(this.eB));
|
|
|
+ s = iE.add(L.ONE).fZ(this.eB).multiply(k.cv(r.multiply(iE))).cl(this.eB);
|
|
|
+ } while (s.equals(L.ZERO));
|
|
|
+ if (typeof (bZ) != 'undefined' && bZ == true) {
|
|
|
+ var kx = this.kd(r.gv(), s.gv());
|
|
|
+ return kx;
|
|
|
+ } else {
|
|
|
+ var kO = this.fN(r, 32);
|
|
|
+ var jI = this.fN(s, 32);
|
|
|
+ return CommonUtils.hexToBytes(CommonUtils.bytesToHex(kO) + CommonUtils.bytesToHex(jI));
|
|
|
+ }
|
|
|
+ },
|
|
|
+ ga: function (data, cB, dC, bZ) {
|
|
|
+ var eQ = this.iO(data, dC);
|
|
|
+ var r = null;
|
|
|
+ var s = null;
|
|
|
+ if (typeof (bZ) != 'undefined' && bZ == true) {
|
|
|
+ var cN = this.le(cB);
|
|
|
+ var hW = new Array(cN["r"].length);
|
|
|
+ var iF = new Array(cN["s"].length);
|
|
|
+ K(cN["r"], 0, hW, 0, cN["r"].length);
|
|
|
+ K(cN["s"], 0, iF, 0, cN["s"].length);
|
|
|
+ r = new L(CommonUtils.bytesToHex(hW), 16);
|
|
|
+ s = new L(CommonUtils.bytesToHex(iF), 16);
|
|
|
+ } else {
|
|
|
+ var dW = CommonUtils.bytesToHex(cB);
|
|
|
+ r = new L(dW.substring(0, 64), 16);
|
|
|
+ s = new L(dW.substring(64), 16);
|
|
|
+ }
|
|
|
+ var hn = this.gZ.kR(CommonUtils.bytesToHex(dC));
|
|
|
+ var e = new L(CommonUtils.bytesToHex(eQ), 16);
|
|
|
+ var t = r.add(s).cl(this.eB);
|
|
|
+ if (t.equals(L.ZERO)) return false;
|
|
|
+ var lB = this.ha.multiply(s).add(hn.multiply(t));
|
|
|
+ var R = e.add(lB.fI().cR()).cl(this.eB);
|
|
|
+ return r.equals(R);
|
|
|
+ },
|
|
|
+ gd: function (dC, data, bZ) {
|
|
|
+ if (dC == null || dC.length == 0 || data == null || data.length == 0) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var lq = G.jZ(this.gZ, dC);
|
|
|
+ var cL = null;
|
|
|
+ var fA = null;
|
|
|
+ var x2 = null;
|
|
|
+ var y2 = null;
|
|
|
+ var ji = this.jt(this.eC);
|
|
|
+ fA = ji['fb'];
|
|
|
+ var iS = lq.multiply(ji['gk']);
|
|
|
+ x2 = this.fN(iS.fI().cR(), 32);
|
|
|
+ y2 = this.fN(iS.ec().cR(), 32);
|
|
|
+ cL = new Array(data.length);
|
|
|
+ K(data, 0, cL, 0, data.length);
|
|
|
+ var eU = new Array(x2.length + y2.length);
|
|
|
+ K(x2, 0, eU, 0, x2.length);
|
|
|
+ K(y2, 0, eU, x2.length, y2.length);
|
|
|
+ this.iH(eU, cL);
|
|
|
+ var cD = new Array(32);
|
|
|
+ var eP = new T();
|
|
|
+ eP.fc(x2, 0, x2.length);
|
|
|
+ eP.fc(data, 0, data.length);
|
|
|
+ eP.fc(y2, 0, y2.length);
|
|
|
+ eP.gN(cD, 0);
|
|
|
+ if (typeof (bZ) != 'undefined' && bZ == true) {
|
|
|
+ var ln = fA.fI().cR().gv();
|
|
|
+ var kf = fA.ec().cR().gv();
|
|
|
+ var kn = this.kZ(ln, kf, cL, cD);
|
|
|
+ return kn;
|
|
|
+ } else {
|
|
|
+ var dG = this.fN(fA.fI().cR(), 32);
|
|
|
+ var cF = this.fN(fA.ec().cR(), 32);
|
|
|
+ var cw = new Array(97 + cL.length);
|
|
|
+ cw[0] = 0x04;
|
|
|
+ K(dG, 0, cw, 1, dG.length);
|
|
|
+ K(cF, 0, cw, 1 + dG.length, cF.length);
|
|
|
+ if (this.eV === CipherMode.C1C2C3) {
|
|
|
+ K(cL, 0, cw, 1 + dG.length + cF.length, cL.length);
|
|
|
+ K(cD, 0, cw, 1 + dG.length + cF.length + cL.length, cD.length);
|
|
|
+ } else {
|
|
|
+ K(cD, 0, cw, 1 + dG.length + cF.length, cD.length);
|
|
|
+ K(cL, 0, cw, 1 + dG.length + cF.length + cD.length, cL.length);
|
|
|
+ }
|
|
|
+ return cw;
|
|
|
+ }
|
|
|
+ },
|
|
|
+ ht: function (cZ, dH, bZ) {
|
|
|
+ if (cZ == null || cZ.length == 0 || dH == null || dH.length == 0) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var fA = new Array(64 + 1);
|
|
|
+ var cL = null;
|
|
|
+ var cD = new Array(32);
|
|
|
+ if (typeof (bZ) != 'undefined' && bZ == true) {
|
|
|
+ var cN = this.lh(dH);
|
|
|
+ cL = new Array(cN["cL"].length);
|
|
|
+ for (var i = 0; i < fA.length; i++) {
|
|
|
+ fA[i] = 0;
|
|
|
+ }
|
|
|
+ fA[0] = 0x04;
|
|
|
+ if (cN["dG"].length <= 32) {
|
|
|
+ K(cN["dG"], 0, fA, 1 + (32 - cN["dG"].length), cN["dG"].length);
|
|
|
+ } else {
|
|
|
+ K(cN["dG"], cN["dG"].length - 32, fA, 1, 32);
|
|
|
+ }
|
|
|
+ if (cN["cF"].length <= 32) {
|
|
|
+ K(cN["cF"], 0, fA, 1 + 32 + (32 - cN["cF"].length), cN["cF"].length);
|
|
|
+ } else {
|
|
|
+ K(cN["cF"], cN["cF"].length - 32, fA, 1 + 32, 32);
|
|
|
+ }
|
|
|
+ K(cN["cL"], 0, cL, 0, cL.length);
|
|
|
+ K(cN["cD"], 0, cD, 0, 32);
|
|
|
+ } else {
|
|
|
+ cL = new Array(dH.length - 97);
|
|
|
+ K(dH, 0, fA, 0, 65);
|
|
|
+ if (this.eV === CipherMode.C1C2C3) {
|
|
|
+ K(dH, 65, cL, 0, dH.length - 97);
|
|
|
+ K(dH, dH.length - 32, cD, 0, 32);
|
|
|
+ } else {
|
|
|
+ K(dH, 65, cD, 0, 32);
|
|
|
+ K(dH, 97, cL, 0, dH.length - 97);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var lg = G.hQ(this.gZ, CommonUtils.bytesToHex(fA));
|
|
|
+ var jc = lg.multiply(new L(CommonUtils.bytesToHex(cZ), 16));
|
|
|
+ var x2 = this.fN(jc.fI().cR(), 32);
|
|
|
+ var y2 = this.fN(jc.ec().cR(), 32);
|
|
|
+ var eU = new Array(x2.length + y2.length);
|
|
|
+ K(x2, 0, eU, 0, x2.length);
|
|
|
+ K(y2, 0, eU, x2.length, y2.length);
|
|
|
+ var jv = new Array(cL.length);
|
|
|
+ K(cL, 0, jv, 0, cL.length);
|
|
|
+ this.iH(eU, cL);
|
|
|
+ if (co(jv, 0, cL, 0, cL.length) == 0) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var eP = new T();
|
|
|
+ var hash = new Array(32);
|
|
|
+ eP.fc(x2, 0, x2.length);
|
|
|
+ eP.fc(cL, 0, cL.length);
|
|
|
+ eP.fc(y2, 0, y2.length);
|
|
|
+ eP.gN(hash, 0);
|
|
|
+ var hT = CommonUtils.bytesToHex(cD);
|
|
|
+ var ix = CommonUtils.bytesToHex(hash);
|
|
|
+ if (!hT || !ix || hT != ix) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ return cL;
|
|
|
+ },
|
|
|
+ kd: function (r, s) {
|
|
|
+ var fl = r.length + s.length + 4;
|
|
|
+ var ew = [];
|
|
|
+ ew[0] = 0x30;
|
|
|
+ if (fl < 0x80) {
|
|
|
+ ew[1] = fl;
|
|
|
+ } else {
|
|
|
+ var fp = F(fl);
|
|
|
+ var i = 0;
|
|
|
+ while (fp[i] == 0 && i < fp.length) {
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ ew[1] = 0x80 | (fp.length - i);
|
|
|
+ for (var j = 2; i < fp.length; i++, j++) {
|
|
|
+ ew[j] = fp[i];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var bZ = new Array(fl + ew.length);
|
|
|
+ var cY = 0;
|
|
|
+ K(ew, 0, bZ, 0, ew.length);
|
|
|
+ cY += ew.length;
|
|
|
+ bZ[cY++] = 0x02;
|
|
|
+ bZ[cY++] = r.length;
|
|
|
+ K(r, 0, bZ, cY, r.length);
|
|
|
+ cY += r.length;
|
|
|
+ bZ[cY++] = 0x02;
|
|
|
+ bZ[cY++] = s.length;
|
|
|
+ K(s, 0, bZ, cY, s.length);
|
|
|
+ cY += s.length;
|
|
|
+ return bZ;
|
|
|
+ },
|
|
|
+ kZ: function (dG, cF, cL, cD) {
|
|
|
+ var fJ = cL.length;
|
|
|
+ var dS = [];
|
|
|
+ if (fJ < 0x80) {
|
|
|
+ dS[0] = 0x04;
|
|
|
+ dS[1] = fJ;
|
|
|
+ } else {
|
|
|
+ dS[0] = 0x04;
|
|
|
+ var gs = F(fJ);
|
|
|
+ var i = 0;
|
|
|
+ while (gs[i] == 0 && i < gs.length) {
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ dS[1] = 0x80 | (gs.length - i);
|
|
|
+ for (var j = 2; i < gs.length; i++, j++) {
|
|
|
+ dS[j] = gs[i];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var fl = dG.length + cF.length + cL.length + cD.length + 6 + dS.length;
|
|
|
+ var ew = [];
|
|
|
+ ew[0] = 0x30;
|
|
|
+ if (fl < 0x80) {
|
|
|
+ ew[1] = fl;
|
|
|
+ } else {
|
|
|
+ var fp = F(fl);
|
|
|
+ var i = 0;
|
|
|
+ while (fp[i] == 0 && i < fp.length) {
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ ew[1] = 0x80 | (fp.length - i);
|
|
|
+ for (var j = 2; i < fp.length; i++, j++) {
|
|
|
+ ew[j] = fp[i];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var bZ = new Array(fl + ew.length);
|
|
|
+ var cY = 0;
|
|
|
+ K(ew, 0, bZ, 0, ew.length);
|
|
|
+ cY += ew.length;
|
|
|
+ bZ[cY++] = 0x02;
|
|
|
+ bZ[cY++] = dG.length;
|
|
|
+ K(dG, 0, bZ, cY, dG.length);
|
|
|
+ cY += dG.length;
|
|
|
+ bZ[cY++] = 0x02;
|
|
|
+ bZ[cY++] = cF.length;
|
|
|
+ K(cF, 0, bZ, cY, cF.length);
|
|
|
+ cY += cF.length;
|
|
|
+ bZ[cY++] = 0x04;
|
|
|
+ bZ[cY++] = cD.length;
|
|
|
+ K(cD, 0, bZ, cY, cD.length);
|
|
|
+ cY += cD.length;
|
|
|
+ K(dS, 0, bZ, cY, dS.length);
|
|
|
+ cY += dS.length;
|
|
|
+ K(cL, 0, bZ, cY, cL.length);
|
|
|
+ return bZ;
|
|
|
+ },
|
|
|
+ le: function (bZ) {
|
|
|
+ var pos = 0;
|
|
|
+ if (bZ[pos++] != 0x30) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if ((bZ[pos] & 0xFF) <= 0x7F) {
|
|
|
+ pos++;
|
|
|
+ } else {
|
|
|
+ pos += (bZ[pos] & 0x7F) + 1;
|
|
|
+ }
|
|
|
+ pos++;
|
|
|
+ var fX = bZ[pos];
|
|
|
+ var r = new Array(fX);
|
|
|
+ K(bZ, ++pos, r, 0, fX);
|
|
|
+ pos += fX;
|
|
|
+ pos++;
|
|
|
+ var he = bZ[pos];
|
|
|
+ var s = new Array(he);
|
|
|
+ K(bZ, ++pos, s, 0, he);
|
|
|
+ pos += he;
|
|
|
+ return {
|
|
|
+ 'r': r,
|
|
|
+ "s": s
|
|
|
+ };
|
|
|
+ },
|
|
|
+ lh: function (bZ) {
|
|
|
+ var pos = 0;
|
|
|
+ if (bZ[pos++] != 0x30) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if ((bZ[pos] & 0xFF) <= 0x7F) {
|
|
|
+ pos++;
|
|
|
+ } else {
|
|
|
+ pos += (bZ[pos] & 0x7F) + 1;
|
|
|
+ }
|
|
|
+ pos++;
|
|
|
+ var jk = bZ[pos];
|
|
|
+ var dG = new Array(jk);
|
|
|
+ K(bZ, ++pos, dG, 0, jk);
|
|
|
+ pos += jk;
|
|
|
+ pos++;
|
|
|
+ var iX = bZ[pos];
|
|
|
+ var cF = new Array(iX);
|
|
|
+ K(bZ, ++pos, cF, 0, iX);
|
|
|
+ pos += iX;
|
|
|
+ pos++;
|
|
|
+ var jD = bZ[pos];
|
|
|
+ var cD = new Array(jD);
|
|
|
+ K(bZ, ++pos, cD, 0, jD);
|
|
|
+ pos += jD;
|
|
|
+ pos++;
|
|
|
+ var fJ = 0;
|
|
|
+ if ((bZ[pos] & 0xFF) <= 0x7F) {
|
|
|
+ fJ = bZ[pos] & 0xFF;
|
|
|
+ } else {
|
|
|
+ for (var i = 0, j = (bZ[pos] & 0x7F) - 1; i < (bZ[pos] & 0x7F); i++, j--) {
|
|
|
+ fJ = fJ | ((bZ[pos + i + 1] & 0xFF) << (j * 8));
|
|
|
+ }
|
|
|
+ pos += (bZ[pos] & 0x7F);
|
|
|
+ }
|
|
|
+ var cL = new Array(fJ);
|
|
|
+ K(bZ, ++pos, cL, 0, fJ);
|
|
|
+ pos += fJ;
|
|
|
+ return {
|
|
|
+ 'dG': dG,
|
|
|
+ "cF": cF,
|
|
|
+ "cL": cL,
|
|
|
+ "cD": cD
|
|
|
+ };
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+function bL() { };
|
|
|
+bL.prototype = {
|
|
|
+ source: function (source) {
|
|
|
+ if (!source) {
|
|
|
+ dB.error("source is empty!");
|
|
|
+ return false;
|
|
|
+ } else {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ },
|
|
|
+ fd: function (eS) {
|
|
|
+ if (typeof (eS) == 'undefined') {
|
|
|
+ dB.error("eS type undefined!");
|
|
|
+ } else if (eS instanceof Array) {
|
|
|
+ eS = CommonUtils.bytesToHex(eS);
|
|
|
+ }
|
|
|
+ if (this.ge(eS, "04") && eS.length == 130) {
|
|
|
+ return true;
|
|
|
+ } else {
|
|
|
+ dB.error("eS length error!");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ },
|
|
|
+ fo: function (fM) {
|
|
|
+ if (typeof (fM) == 'undefined') {
|
|
|
+ dB.error("fM type undefined!");
|
|
|
+ } else if (fM instanceof Array) {
|
|
|
+ fM = CommonUtils.bytesToHex(fM);
|
|
|
+ }
|
|
|
+ if (fM.length % 2 == 0) {
|
|
|
+ return true;
|
|
|
+ } else {
|
|
|
+ dB.error("fM length error!");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ },
|
|
|
+ gp: function (cw) {
|
|
|
+ if (typeof (cw) == 'undefined') {
|
|
|
+ dB.error("cw type undefined!");
|
|
|
+ } else if (cw instanceof Array) {
|
|
|
+ cw = CommonUtils.bytesToHex(cw);
|
|
|
+ }
|
|
|
+ if (this.ge(cw, "04") && cw.length % 2 == 0 && cw.length > 194) {
|
|
|
+ return true;
|
|
|
+ } else if (this.ge(cw, "30") && cw.length % 2 == 0 && cw.length > 216) {
|
|
|
+ return true;
|
|
|
+ } else {
|
|
|
+ dB.error("cw format jw length error!");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ },
|
|
|
+ fP: function (er) {
|
|
|
+ if (typeof (er) == 'undefined') {
|
|
|
+ dB.error("er type undefined!");
|
|
|
+ } else if (er instanceof Array) {
|
|
|
+ er = CommonUtils.bytesToHex(er);
|
|
|
+ }
|
|
|
+ if (er.length == 128) {
|
|
|
+ return true;
|
|
|
+ } else if (this.ge(er, "30") && er.length % 2 == 0) {
|
|
|
+ return true;
|
|
|
+ } else {
|
|
|
+ dB.error("er format jw length error!");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ },
|
|
|
+ fF: function (key) {
|
|
|
+ if (typeof (key) == 'undefined') {
|
|
|
+ dB.error("key type undefined!");
|
|
|
+ } else if (key instanceof Array) {
|
|
|
+ key = CommonUtils.bytesToHex(key);
|
|
|
+ }
|
|
|
+ if (key.length == 32) {
|
|
|
+ return true;
|
|
|
+ } else {
|
|
|
+ dB.error("key length error!");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ },
|
|
|
+ hj: function (cd) {
|
|
|
+ if (typeof (cd) == 'undefined') {
|
|
|
+ dB.error("cd type undefined!");
|
|
|
+ } else if (cd instanceof Array) {
|
|
|
+ cd = CommonUtils.bytesToHex(cd);
|
|
|
+ }
|
|
|
+ if (cd.length == 32) {
|
|
|
+ return true;
|
|
|
+ } else {
|
|
|
+ dB.error("cd length error!");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ },
|
|
|
+ hd: function (cw) {
|
|
|
+ if (typeof (cw) == 'undefined') {
|
|
|
+ dB.error("cw type undefined!");
|
|
|
+ } else if (cw instanceof Array) {
|
|
|
+ cw = CommonUtils.bytesToHex(cw);
|
|
|
+ }
|
|
|
+ if (cw && cw.length % 16 == 0) {
|
|
|
+ return true;
|
|
|
+ } else {
|
|
|
+ dB.error("cw format jw length error!");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ },
|
|
|
+ ge: function (fL, start) {
|
|
|
+ var reg = new RegExp("^" + start);
|
|
|
+ return reg.test(fL);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+function Sm2Utils(eV, eC) {
|
|
|
+ if (typeof (eV) != 'undefined') {
|
|
|
+ this.eV = eV;
|
|
|
+ } else {
|
|
|
+ this.eV = CipherMode.C1C2C3;
|
|
|
+ }
|
|
|
+ if (typeof (eC) != 'undefined' && CommonUtils.isHexString(eC)) {
|
|
|
+ this.eC = eC;
|
|
|
+ } else {
|
|
|
+ this.eC = null;
|
|
|
+ }
|
|
|
+ this.cw = new aK(this.eV, this.eC);
|
|
|
+ this.smValidate = new bL();
|
|
|
+};
|
|
|
+Sm2Utils.prototype = {
|
|
|
+ generateKeyPair: function () {
|
|
|
+ return this.cw.kX();
|
|
|
+ },
|
|
|
+ getPublicKey: function (kL) {
|
|
|
+ var cZ = CommonUtils.hexToBytes(kL);
|
|
|
+ var dC = this.cw.jR(cZ);
|
|
|
+ return CommonUtils.bytesToHex(dC);
|
|
|
+ },
|
|
|
+ encryptFromText: function (cV, cb) {
|
|
|
+ if (!this.smValidate.fd(cV)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(cb)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var dC = CommonUtils.hexToBytes(cV);
|
|
|
+ var cu = CommonUtils.utf8StrToBytes(cb);
|
|
|
+ var dH = this.cw.gd(dC, cu, false);
|
|
|
+ return CommonUtils.bytesToHex(dH);
|
|
|
+ },
|
|
|
+ decryptToText: function (du, cE) {
|
|
|
+ if (!this.smValidate.fo(du)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.gp(cE)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cZ = CommonUtils.hexToBytes(du);
|
|
|
+ var dH = CommonUtils.hexToBytes(cE);
|
|
|
+ var cu = this.cw.ht(cZ, dH, false);
|
|
|
+ return CommonUtils.bytesToUtf8Str(cu);
|
|
|
+ },
|
|
|
+ encryptFromHex: function (cV, dO) {
|
|
|
+ if (!this.smValidate.fd(cV)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(dO)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var dC = CommonUtils.hexToBytes(cV);
|
|
|
+ var cu = CommonUtils.hexToBytes(dO);
|
|
|
+ var dH = this.cw.gd(dC, cu, false);
|
|
|
+ return CommonUtils.bytesToHex(dH);
|
|
|
+ },
|
|
|
+ decryptToHex: function (du, cE) {
|
|
|
+ if (!this.smValidate.fo(du)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.gp(cE)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cZ = CommonUtils.hexToBytes(du);
|
|
|
+ var dH = CommonUtils.hexToBytes(cE);
|
|
|
+ var cu = this.cw.ht(cZ, dH, false);
|
|
|
+ return CommonUtils.bytesToHex(cu);
|
|
|
+ },
|
|
|
+ encryptFromData: function (dC, cu) {
|
|
|
+ if (!this.smValidate.fd(dC)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(cu)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ return this.cw.gd(dC, cu, false);
|
|
|
+ },
|
|
|
+ decryptToData: function (cZ, dH) {
|
|
|
+ if (!this.smValidate.fo(cZ)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.gp(dH)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ return this.cw.ht(cZ, dH, false);
|
|
|
+ },
|
|
|
+ encryptASN1FromText: function (cV, cb) {
|
|
|
+ if (!this.smValidate.fd(cV)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(cb)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var dC = CommonUtils.hexToBytes(cV);
|
|
|
+ var cu = CommonUtils.utf8StrToBytes(cb);
|
|
|
+ var dH = this.cw.gd(dC, cu, true);
|
|
|
+ return CommonUtils.bytesToHex(dH);
|
|
|
+ },
|
|
|
+ decryptASN1ToText: function (du, cE) {
|
|
|
+ if (!this.smValidate.fo(du)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.gp(cE)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cZ = CommonUtils.hexToBytes(du);
|
|
|
+ var dH = CommonUtils.hexToBytes(cE);
|
|
|
+ var cu = this.cw.ht(cZ, dH, true);
|
|
|
+ return CommonUtils.bytesToUtf8Str(cu);
|
|
|
+ },
|
|
|
+ encryptASN1FromHex: function (cV, dO) {
|
|
|
+ if (!this.smValidate.fd(cV)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(dO)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var dC = CommonUtils.hexToBytes(cV);
|
|
|
+ var cu = CommonUtils.hexToBytes(dO);
|
|
|
+ var dH = this.cw.gd(dC, cu, true);
|
|
|
+ return CommonUtils.bytesToHex(dH);
|
|
|
+ },
|
|
|
+ decryptASN1ToHex: function (du, cE) {
|
|
|
+ if (!this.smValidate.fo(du)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.gp(cE)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cZ = CommonUtils.hexToBytes(du);
|
|
|
+ var dH = CommonUtils.hexToBytes(cE);
|
|
|
+ var cu = this.cw.ht(cZ, dH, true);
|
|
|
+ return CommonUtils.bytesToHex(cu);
|
|
|
+ },
|
|
|
+ encryptASN1FromData: function (dC, cu) {
|
|
|
+ if (!this.smValidate.fd(dC)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(cu)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ return this.cw.gd(dC, cu, true);
|
|
|
+ },
|
|
|
+ decryptASN1ToData: function (cZ, dH) {
|
|
|
+ if (!this.smValidate.fo(cZ)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.gp(dH)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ return this.cw.ht(cZ, dH, true);
|
|
|
+ },
|
|
|
+ signFromText: function (du, cb) {
|
|
|
+ if (!this.smValidate.fo(du)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(cb)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cZ = CommonUtils.hexToBytes(du);
|
|
|
+ var cu = CommonUtils.utf8StrToBytes(cb);
|
|
|
+ var cB = this.cw.er(cu, cZ, false);
|
|
|
+ return CommonUtils.bytesToHex(cB);
|
|
|
+ },
|
|
|
+ verifySignFromText: function (cV, cb, dW) {
|
|
|
+ if (!this.smValidate.fd(cV)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(cb)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fP(dW)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var dC = CommonUtils.hexToBytes(cV);
|
|
|
+ var cu = CommonUtils.utf8StrToBytes(cb);
|
|
|
+ var cB = CommonUtils.hexToBytes(dW);
|
|
|
+ return this.cw.ga(cu, cB, dC, false);
|
|
|
+ },
|
|
|
+ signFromHex: function (du, dO) {
|
|
|
+ if (!this.smValidate.fo(du)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(dO)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cZ = CommonUtils.hexToBytes(du);
|
|
|
+ var cu = CommonUtils.hexToBytes(dO);
|
|
|
+ var cB = this.cw.er(cu, cZ, false);
|
|
|
+ return CommonUtils.bytesToHex(cB);
|
|
|
+ },
|
|
|
+ verifySignFromHex: function (cV, dO, dW) {
|
|
|
+ if (!this.smValidate.fd(cV)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(dO)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fP(dW)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var dC = CommonUtils.hexToBytes(cV);
|
|
|
+ var cu = CommonUtils.hexToBytes(dO);
|
|
|
+ var cB = CommonUtils.hexToBytes(dW);
|
|
|
+ return this.cw.ga(cu, cB, dC, false);
|
|
|
+ },
|
|
|
+ signFromData: function (cZ, cu) {
|
|
|
+ if (!this.smValidate.fo(cZ)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(cu)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ return this.cw.er(cu, cZ, false);
|
|
|
+ },
|
|
|
+ verifySignFromData: function (dC, cu, cB) {
|
|
|
+ if (!this.smValidate.fd(dC)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(cu)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fP(cB)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ return this.cw.ga(cu, cB, dC, false);
|
|
|
+ },
|
|
|
+ signASN1FromText: function (du, cb) {
|
|
|
+ if (!this.smValidate.fo(du)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(cb)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cZ = CommonUtils.hexToBytes(du);
|
|
|
+ var cu = CommonUtils.utf8StrToBytes(cb);
|
|
|
+ var cB = this.cw.er(cu, cZ, true);
|
|
|
+ return CommonUtils.bytesToHex(cB);
|
|
|
+ },
|
|
|
+ verifySignASN1FromText: function (cV, cb, dW) {
|
|
|
+ if (!this.smValidate.fd(cV)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(cb)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fP(dW)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var dC = CommonUtils.hexToBytes(cV);
|
|
|
+ var cu = CommonUtils.utf8StrToBytes(cb);
|
|
|
+ var cB = CommonUtils.hexToBytes(dW);
|
|
|
+ return this.cw.ga(cu, cB, dC, true);
|
|
|
+ },
|
|
|
+ signASN1FromHex: function (du, dO) {
|
|
|
+ if (!this.smValidate.fo(du)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(dO)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cZ = CommonUtils.hexToBytes(du);
|
|
|
+ var cu = CommonUtils.hexToBytes(dO);
|
|
|
+ var cB = this.cw.er(cu, cZ, true);
|
|
|
+ return CommonUtils.bytesToHex(cB);
|
|
|
+ },
|
|
|
+ verifySignASN1FromHex: function (cV, dO, dW) {
|
|
|
+ if (!this.smValidate.fd(cV)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(dO)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fP(dW)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var dC = CommonUtils.hexToBytes(cV);
|
|
|
+ var cu = CommonUtils.hexToBytes(dO);
|
|
|
+ var cB = CommonUtils.hexToBytes(dW);
|
|
|
+ return this.cw.ga(cu, cB, dC, true);
|
|
|
+ },
|
|
|
+ signASN1FromData: function (cZ, cu) {
|
|
|
+ if (!this.smValidate.fo(cZ)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(cu)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ return this.cw.er(cu, cZ, true);
|
|
|
+ },
|
|
|
+ verifySignASN1FromData: function (dC, cu, cB) {
|
|
|
+ if (!this.smValidate.fd(dC)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.source(cu)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fP(cB)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ return this.cw.ga(cu, cB, dC, true);
|
|
|
+ }
|
|
|
+};
|
|
|
+var Sm3Utils = {
|
|
|
+ smValidate: new bL(),
|
|
|
+ encryptFromText: function (cb) {
|
|
|
+ if (!this.smValidate.source(cb)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cu = CommonUtils.utf8StrToBytes(cb);
|
|
|
+ var eQ = this.encryptFromData(cu);
|
|
|
+ return CommonUtils.bytesToHex(eQ);
|
|
|
+ },
|
|
|
+ encryptFromHex: function (dO) {
|
|
|
+ if (!this.smValidate.source(dO)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cu = CommonUtils.hexToBytes(dO);
|
|
|
+ var eQ = this.encryptFromData(cu);
|
|
|
+ return CommonUtils.bytesToHex(eQ);
|
|
|
+ },
|
|
|
+ encryptFromData: function (cu) {
|
|
|
+ if (!this.smValidate.source(cu)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var eQ = new Array(32);
|
|
|
+ var jy = new T();
|
|
|
+ jy.fc(cu, 0, cu.length);
|
|
|
+ jy.gN(eQ, 0);
|
|
|
+ return eQ;
|
|
|
+ }
|
|
|
+};
|
|
|
+var Sm4Utils = {
|
|
|
+ ECB: {
|
|
|
+ smValidate: new bL(),
|
|
|
+ encryptFromText: function (cb, dz) {
|
|
|
+ if (!this.smValidate.source(cb)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fF(dz)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cK = CommonUtils.hexToBytes(dz);
|
|
|
+ var cu = CommonUtils.utf8StrToBytes(cb);
|
|
|
+ var dH = this.encryptFromData(cu, cK);
|
|
|
+ return CommonUtils.bytesToHex(dH);
|
|
|
+ },
|
|
|
+ encryptFromHex: function (dO, dz) {
|
|
|
+ if (!this.smValidate.source(dO)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fF(dz)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cK = CommonUtils.hexToBytes(dz);
|
|
|
+ var cu = CommonUtils.hexToBytes(dO);
|
|
|
+ var dH = this.encryptFromData(cu, cK);
|
|
|
+ return CommonUtils.bytesToHex(dH);
|
|
|
+ },
|
|
|
+ encryptFromData: function (cu, cK) {
|
|
|
+ if (!this.smValidate.source(cu)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fF(cK)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ var dV = new aP();
|
|
|
+ return dV.lk(cu, cK);
|
|
|
+ } catch (e) {
|
|
|
+ dB.error(e);
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ },
|
|
|
+ decryptToText: function (cE, dz) {
|
|
|
+ if (!this.smValidate.hd(cE)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fF(dz)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cK = CommonUtils.hexToBytes(dz);
|
|
|
+ var dH = CommonUtils.hexToBytes(cE);
|
|
|
+ var cu = this.decryptToData(dH, cK);
|
|
|
+ return CommonUtils.bytesToUtf8Str(cu);
|
|
|
+ },
|
|
|
+ decryptToHex: function (cE, dz) {
|
|
|
+ if (!this.smValidate.hd(cE)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fF(dz)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cK = CommonUtils.hexToBytes(dz);
|
|
|
+ var dH = CommonUtils.hexToBytes(cE);
|
|
|
+ var cu = this.decryptToData(dH, cK);
|
|
|
+ return CommonUtils.bytesToHex(cu);
|
|
|
+ },
|
|
|
+ decryptToData: function (dH, cK) {
|
|
|
+ if (!this.smValidate.hd(dH)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fF(cK)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ var dV = new aP();
|
|
|
+ return dV.kY(dH, cK);
|
|
|
+ } catch (e) {
|
|
|
+ dB.error(e);
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ CBC: {
|
|
|
+ smValidate: new bL(),
|
|
|
+ encryptFromText: function (cb, dz, dZ) {
|
|
|
+ if (!this.smValidate.source(cb)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fF(dz)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.hj(dZ)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cK = CommonUtils.hexToBytes(dz);
|
|
|
+ var fq = CommonUtils.hexToBytes(dZ);
|
|
|
+ var cu = CommonUtils.utf8StrToBytes(cb);
|
|
|
+ var dH = this.encryptFromData(cu, cK, fq);
|
|
|
+ return CommonUtils.bytesToHex(dH);
|
|
|
+ },
|
|
|
+ encryptFromHex: function (dO, dz, dZ) {
|
|
|
+ if (!this.smValidate.source(dO)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fF(dz)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.hj(dZ)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cK = CommonUtils.hexToBytes(dz);
|
|
|
+ var fq = CommonUtils.hexToBytes(dZ);
|
|
|
+ var cu = CommonUtils.hexToBytes(dO);
|
|
|
+ var dH = this.encryptFromData(cu, cK, fq);
|
|
|
+ return CommonUtils.bytesToHex(dH);
|
|
|
+ },
|
|
|
+ encryptFromData: function (cu, cK, fq) {
|
|
|
+ if (!this.smValidate.source(cu)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fF(cK)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.hj(fq)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ var dV = new aP();
|
|
|
+ return dV.ll(cu, cK, fq);
|
|
|
+ } catch (e) {
|
|
|
+ dB.error(e);
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ },
|
|
|
+ decryptToText: function (cE, dz, dZ) {
|
|
|
+ if (!this.smValidate.hd(cE)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fF(dz)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.hj(dZ)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cK = CommonUtils.hexToBytes(dz);
|
|
|
+ var fq = CommonUtils.hexToBytes(dZ);
|
|
|
+ var dH = CommonUtils.hexToBytes(cE);
|
|
|
+ var cu = this.decryptToData(dH, cK, fq);
|
|
|
+ return CommonUtils.bytesToUtf8Str(cu);
|
|
|
+ },
|
|
|
+ decryptToHex: function (cE, dz, dZ) {
|
|
|
+ if (!this.smValidate.hd(cE)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fF(dz)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.hj(dZ)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ var cK = CommonUtils.hexToBytes(dz);
|
|
|
+ var fq = CommonUtils.hexToBytes(dZ);
|
|
|
+ var dH = CommonUtils.hexToBytes(cE);
|
|
|
+ var cu = this.decryptToData(dH, cK, fq);
|
|
|
+ return CommonUtils.bytesToHex(cu);
|
|
|
+ },
|
|
|
+ decryptToData: function (dH, cK, fq) {
|
|
|
+ if (!this.smValidate.hd(dH)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.fF(cK)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ if (!this.smValidate.hj(fq)) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ var dV = new aP();
|
|
|
+ return dV.kD(dH, cK, fq);
|
|
|
+ } catch (e) {
|
|
|
+ dB.error(e);
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+// export {
|
|
|
+// Sm3Utils,
|
|
|
+// Sm4Utils,
|
|
|
+// Sm2Utils
|
|
|
+// }
|
|
|
+
|
|
|
+Sm3Utils,
|
|
|
+ Sm4Utils,
|
|
|
+ Sm2Utils
|
韩洋
hace 3 meses
