diff --git a/猿人学练习/56js加密经典入门数据加密-RSA/f.js b/猿人学练习/56js加密经典入门数据加密-RSA/f.js
new file mode 100644
index 0000000..de1dfe1
--- /dev/null
+++ b/猿人学练习/56js加密经典入门数据加密-RSA/f.js
@@ -0,0 +1,16729 @@
+var JSEncryptExports = {};
+
+(function (p) {
+ function n(nj, nO, nt) {
+ if (null != nj) {
+ "number" == typeof nj ? this.fromNumber(nj, nO, nt) : null == nO && "string" != typeof nj ? this.fromString(nj, 256) : this.fromString(nj, nO);
+ }
+ }
+
+ function c() {
+ return new n(null);
+ }
+
+ function a(nj, nO, nt, nX, nG, nx) {
+ for (; --nx >= 0;) {
+ var nN = nO * this[nj++] + nt[nX] + nG;
+ nG = Math.floor(nN / 67108864);
+ nt[nX++] = 67108863 & nN;
+ }
+
+ return nG;
+ }
+
+ function A(nj, nO, nt, nX, nG, nx) {
+ for (var nN = 32767 & nO, nD = nO >> 15; --nx >= 0;) {
+ var ny = 32767 & this[nj];
+ var no = this[nj++] >> 15;
+ var nv = nD * ny + no * nN;
+ ny = nN * ny + ((32767 & nv) << 15) + nt[nX] + (1073741823 & nG);
+ nG = (ny >>> 30) + (nv >>> 15) + nD * no + (nG >>> 30);
+ nt[nX++] = 1073741823 & ny;
+ }
+
+ return nG;
+ }
+
+ function g(nj, nO, nt, nX, nG, nx) {
+ for (var nN = 16383 & nO, nD = nO >> 14; --nx >= 0;) {
+ var ny = 16383 & this[nj];
+ var no = this[nj++] >> 14;
+ var nv = nD * ny + no * nN;
+ ny = nN * ny + ((16383 & nv) << 14) + nt[nX] + nG;
+ nG = (ny >> 28) + (nv >> 14) + nD * no;
+ nt[nX++] = 268435455 & ny;
+ }
+
+ return nG;
+ }
+
+ function S(nj) {
+ return nW.charAt(nj);
+ }
+
+ function f(nj, nO) {
+ var nt = nl[nj.charCodeAt(nO)];
+ return null == nt ? -1 : nt;
+ }
+
+ function Y(nj) {
+ for (var nO = this.t - 1; nO >= 0; --nO) nj[nO] = this[nO];
+
+ nj.t = this.t;
+ nj.s = this.s;
+ }
+
+ function J(nj) {
+ this.t = 1;
+ 0 > nj ? this.s = -1 : this.s = 0;
+ nj > 0 ? this[0] = nj : -1 > nj ? this[0] = nj + DV : this.t = 0;
+ }
+
+ function b(nj) {
+ var nO = c();
+ return nO.fromInt(nj), nO;
+ }
+
+ function C(nj, nO) {
+ var nt;
+ if (16 == nO) nt = 4;else {
+ if (8 == nO) nt = 3;else {
+ if (256 == nO) nt = 8;else {
+ if (2 == nO) nt = 1;else {
+ if (32 == nO) nt = 5;else {
+ if (4 != nO) return void this.fromRadix(nj, nO);
+ nt = 2;
+ }
+ }
+ }
+ }
+ }
+ this.t = 0;
+ this.s = 0;
+
+ for (var nX = nj.length, nG = !1, nx = 0; --nX >= 0;) {
+ if (8 == nt) {
+ var nN = 255 & nj[nX];
+ } else {
+ var nN = f(nj, nX);
+ }
+
+ if (0 > nN) {
+ if ("-" == nj.charAt(nX)) {
+ nG = !0;
+ }
+ } else {
+ nG = !1;
+ 0 == nx ? this[this.t++] = nN : nx + nt > this.DB ? (this[this.t - 1] |= (nN & (1 << this.DB - nx) - 1) << nx, this[this.t++] = nN >> this.DB - nx) : this[this.t - 1] |= nN << nx;
+ nx += nt;
+ nx >= this.DB && (nx -= this.DB);
+ }
+ }
+
+ 8 == nt && 0 != (128 & nj[0]) && (this.s = -1, nx > 0 && (this[this.t - 1] |= (1 << this.DB - nx) - 1 << nx));
+ this.clamp();
+ nG && n.ZERO.subTo(this, this);
+ }
+
+ function V() {
+ for (var nj = this.s & this.DM; this.t > 0 && this[this.t - 1] == nj;) --this.t;
+ }
+
+ function W(nj) {
+ if (this.s < 0) return "-" + this.negate().toString(nj);
+ var nO;
+ if (16 == nj) nO = 4;else {
+ if (8 == nj) nO = 3;else {
+ if (2 == nj) nO = 1;else {
+ if (32 == nj) nO = 5;else {
+ if (4 != nj) return this.toRadix(nj);
+ nO = 2;
+ }
+ }
+ }
+ }
+ var nt;
+ var nX = (1 << nO) - 1;
+ var nG = !1;
+ var nx = "";
+ var nN = this.t;
+ var nD = this.DB - nN * this.DB % nO;
+
+ if (nN-- > 0) {
+ for (nD < this.DB && (nt = this[nN] >> nD) > 0 && (nG = !0, nx = S(nt)); nN >= 0;) {
+ nO > nD ? (nt = (this[nN] & (1 << nD) - 1) << nO - nD, nt |= this[--nN] >> (nD += this.DB - nO)) : (nt = this[nN] >> (nD -= nO) & nX, 0 >= nD && (nD += this.DB, --nN));
+ nt > 0 && (nG = !0);
+ nG && (nx += S(nt));
+ }
+ }
+
+ return nG ? nx : "0";
+ }
+
+ function l() {
+ var nj = c();
+ return n.ZERO.subTo(this, nj), nj;
+ }
+
+ function R() {
+ return this.s < 0 ? this.negate() : this;
+ }
+
+ function B(nj) {
+ var nO = this.s - nj.s;
+ if (0 != nO) return nO;
+ var nt = this.t;
+ if (nO = nt - nj.t, 0 != nO) return this.s < 0 ? -nO : nO;
+
+ for (; --nt >= 0;) if (0 != (nO = this[nt] - nj[nt])) return nO;
+
+ return 0;
+ }
+
+ function F(nj) {
+ var nO;
+ var nt = 1;
+ return 0 != (nO = nj >>> 16) && (nj = nO, nt += 16), 0 != (nO = nj >> 8) && (nj = nO, nt += 8), 0 != (nO = nj >> 4) && (nj = nO, nt += 4), 0 != (nO = nj >> 2) && (nj = nO, nt += 2), 0 != (nO = nj >> 1) && (nj = nO, nt += 1), nt;
+ }
+
+ function E() {
+ return this.t <= 0 ? 0 : this.DB * (this.t - 1) + F(this[this.t - 1] ^ this.s & this.DM);
+ }
+
+ function s(nj, nO) {
+ var nt;
+
+ for (nt = this.t - 1; nt >= 0; --nt) nO[nt + nj] = this[nt];
+
+ for (nt = nj - 1; nt >= 0; --nt) nO[nt] = 0;
+
+ nO.t = this.t + nj;
+ nO.s = this.s;
+ }
+
+ function I(nj, nO) {
+ for (var nt = nj; nt < this.t; ++nt) nO[nt - nj] = this[nt];
+
+ nO.t = Math.max(this.t - nj, 0);
+ nO.s = this.s;
+ }
+
+ function K(nj, nO) {
+ var nt;
+ var nX = nj % this.DB;
+ var nG = this.DB - nX;
+ var nx = (1 << nG) - 1;
+ var nN = Math.floor(nj / this.DB);
+ var nD = this.s << nX & this.DM;
+
+ for (nt = this.t - 1; nt >= 0; --nt) {
+ nO[nt + nN + 1] = this[nt] >> nG | nD;
+ nD = (this[nt] & nx) << nX;
+ }
+
+ for (nt = nN - 1; nt >= 0; --nt) nO[nt] = 0;
+
+ nO[nN] = nD;
+ nO.t = this.t + nN + 1;
+ nO.s = this.s;
+ nO.clamp();
+ }
+
+ function T(nj, nO) {
+ nO.s = this.s;
+ var nt = Math.floor(nj / this.DB);
+ if (nt >= this.t) return void (nO.t = 0);
+ var nX = nj % this.DB;
+ var nG = this.DB - nX;
+ var nx = (1 << nX) - 1;
+ nO[0] = this[nt] >> nX;
+
+ for (var nN = nt + 1; nN < this.t; ++nN) {
+ nO[nN - nt - 1] |= (this[nN] & nx) << nG;
+ nO[nN - nt] = this[nN] >> nX;
+ }
+
+ nX > 0 && (nO[this.t - nt - 1] |= (this.s & nx) << nG);
+ nO.t = this.t - nt;
+ nO.clamp();
+ }
+
+ function i(nj, nO) {
+ for (var nt = 0, nX = 0, nG = Math.min(nj.t, this.t); nG > nt;) {
+ nX += this[nt] - nj[nt];
+ nO[nt++] = nX & this.DM;
+ nX >>= this.DB;
+ }
+
+ if (nj.t < this.t) {
+ for (nX -= nj.s; nt < this.t;) {
+ nX += this[nt];
+ nO[nt++] = nX & this.DM;
+ nX >>= this.DB;
+ }
+
+ nX += this.s;
+ } else {
+ for (nX += this.s; nt < nj.t;) {
+ nX -= nj[nt];
+ nO[nt++] = nX & this.DM;
+ nX >>= this.DB;
+ }
+
+ nX -= nj.s;
+ }
+
+ 0 > nX ? nO.s = -1 : nO.s = 0;
+ -1 > nX ? nO[nt++] = this.DV + nX : nX > 0 && (nO[nt++] = nX);
+ nO.t = nt;
+ nO.clamp();
+ }
+
+ function e(nj, nO) {
+ var nt = this.abs();
+ var nX = nj.abs();
+ var nG = nt.t;
+
+ for (nO.t = nG + nX.t; --nG >= 0;) nO[nG] = 0;
+
+ for (nG = 0; nG < nX.t; ++nG) nO[nG + nt.t] = nt.am(0, nX[nG], nO, nG, 0, nt.t);
+
+ nO.s = 0;
+ nO.clamp();
+ this.s != nj.s && n.ZERO.subTo(nO, nO);
+ }
+
+ function Z(nj) {
+ for (var nO = this.abs(), nt = nj.t = 2 * nO.t; --nt >= 0;) nj[nt] = 0;
+
+ for (nt = 0; nt < nO.t - 1; ++nt) {
+ var nX = nO.am(nt, nO[nt], nj, 2 * nt, 0, 1);
+
+ if ((nj[nt + nO.t] += nO.am(nt + 1, 2 * nO[nt], nj, 2 * nt + 1, nX, nO.t - nt - 1)) >= nO.DV) {
+ nj[nt + nO.t] -= nO.DV;
+ nj[nt + nO.t + 1] = 1;
+ }
+ }
+
+ nj.t > 0 && (nj[nj.t - 1] += nO.am(nt, nO[nt], nj, 2 * nt, 0, 1));
+ nj.s = 0;
+ nj.clamp();
+ }
+
+ function w(nj, nO, nt) {
+ var nX = nj.abs();
+
+ if (!(nX.t <= 0)) {
+ var nG = this.abs();
+ if (nG.t < nX.t) return null != nO && nO.fromInt(0), void (null != nt && this.copyTo(nt));
+
+ if (null == nt) {
+ nt = c();
+ }
+
+ var nx = c();
+ var nN = this.s;
+ var nD = nj.s;
+ var ny = this.DB - F(nX[nX.t - 1]);
+
+ if (ny > 0) {
+ nX.lShiftTo(ny, nx);
+ nG.lShiftTo(ny, nt);
+ } else {
+ nX.copyTo(nx);
+ nG.copyTo(nt);
+ }
+
+ var no = nx.t;
+ var nv = nx[no - 1];
+
+ if (0 != nv) {
+ var nm = nv * (1 << this.F1) + (no > 1 ? nx[no - 2] >> this.F2 : 0);
+ var nd = this.FV / nm;
+ var nr = (1 << this.F1) / nm;
+ var nQ = 1 << this.F2;
+ var nP = nt.t;
+ var c0 = nP - no;
+
+ if (null == nO) {
+ var c1 = c();
+ } else {
+ var c1 = nO;
+ }
+
+ for (nx.dlShiftTo(c0, c1), nt.compareTo(c1) >= 0 && (nt[nt.t++] = 1, nt.subTo(c1, nt)), n.ONE.dlShiftTo(no, c1), c1.subTo(nx, nx); nx.t < no;) nx[nx.t++] = 0;
+
+ for (; --c0 >= 0;) {
+ var c2 = nt[--nP] == nv ? this.DM : Math.floor(nt[nP] * nd + (nt[nP - 1] + nQ) * nr);
+
+ if ((nt[nP] += nx.am(0, c2, nt, c0, 0, no)) < c2) {
+ for (nx.dlShiftTo(c0, c1), nt.subTo(c1, nt); nt[nP] < --c2;) nt.subTo(c1, nt);
+ }
+ }
+
+ null != nO && (nt.drShiftTo(no, nO), nN != nD && n.ZERO.subTo(nO, nO));
+ nt.t = no;
+ nt.clamp();
+ ny > 0 && nt.rShiftTo(ny, nt);
+ 0 > nN && n.ZERO.subTo(nt, nt);
+ }
+ }
+ }
+
+ function M(nj) {
+ var nO = c();
+ return this.abs().divRemTo(nj, null, nO), this.s < 0 && nO.compareTo(n.ZERO) > 0 && nj.subTo(nO, nO), nO;
+ }
+
+ function u(nj) {
+ this.m = nj;
+ }
+
+ function k(nj) {
+ return nj.s < 0 || nj.compareTo(this.m) >= 0 ? nj.mod(this.m) : nj;
+ }
+
+ function q(nj) {
+ return nj;
+ }
+
+ function U(nj) {
+ nj.divRemTo(this.m, null, nj);
+ }
+
+ function h(nj, nO, nt) {
+ nj.multiplyTo(nO, nt);
+ this.reduce(nt);
+ }
+
+ function H(nj, nO) {
+ nj.squareTo(nO);
+ this.reduce(nO);
+ }
+
+ function j() {
+ if (this.t < 1) return 0;
+ var nj = this[0];
+ if (0 == (1 & nj)) return 0;
+ var nO = 3 & nj;
+ return nO = nO * (2 - (15 & nj) * nO) & 15, nO = nO * (2 - (255 & nj) * nO) & 255, nO = nO * (2 - ((65535 & nj) * nO & 65535)) & 65535, nO = nO * (2 - nj * nO % this.DV) % this.DV, nO > 0 ? this.DV - nO : -nO;
+ }
+
+ function O(nj) {
+ this.m = nj;
+ this.mp = nj.invDigit();
+ this.mpl = 32767 & this.mp;
+ this.mph = this.mp >> 15;
+ this.um = (1 << nj.DB - 15) - 1;
+ this.mt2 = 2 * nj.t;
+ }
+
+ function X(nj) {
+ var nO = c();
+ return nj.abs().dlShiftTo(this.m.t, nO), nO.divRemTo(this.m, null, nO), nj.s < 0 && nO.compareTo(n.ZERO) > 0 && this.m.subTo(nO, nO), nO;
+ }
+
+ function G(nj) {
+ var nO = c();
+ return nj.copyTo(nO), this.reduce(nO), nO;
+ }
+
+ function x(nj) {
+ for (; nj.t <= this.mt2;) nj[nj.t++] = 0;
+
+ for (var nO = 0; nO < this.m.t; ++nO) {
+ var nt = 32767 & nj[nO];
+ var nX = nt * this.mpl + ((nt * this.mph + (nj[nO] >> 15) * this.mpl & this.um) << 15) & nj.DM;
+
+ for (nt = nO + this.m.t, nj[nt] += this.m.am(0, nX, nj, nO, 0, this.m.t); nj[nt] >= nj.DV;) {
+ nj[nt] -= nj.DV;
+ nj[++nt]++;
+ }
+ }
+
+ nj.clamp();
+ nj.drShiftTo(this.m.t, nj);
+ nj.compareTo(this.m) >= 0 && nj.subTo(this.m, nj);
+ }
+
+ function N(nj, nO) {
+ nj.squareTo(nO);
+ this.reduce(nO);
+ }
+
+ function D(nj, nO, nt) {
+ nj.multiplyTo(nO, nt);
+ this.reduce(nt);
+ }
+
+ function y() {
+ return 0 == (this.t > 0 ? 1 & this[0] : this.s);
+ }
+
+ function o(nj, nO) {
+ if (nj > 4294967295 || 1 > nj) return n.ONE;
+ var nt = c();
+ var nX = c();
+ var nG = nO.convert(this);
+ var nx = F(nj) - 1;
+
+ for (nG.copyTo(nt); --nx >= 0;) if (nO.sqrTo(nt, nX), (nj & 1 << nx) > 0) nO.mulTo(nX, nG, nt);else {
+ var nN = nt;
+ nt = nX;
+ nX = nN;
+ }
+
+ return nO.revert(nt);
+ }
+
+ function v(nj, nO) {
+ var nt;
+ return 256 > nj || nO.isEven() ? nt = new u(nO) : nt = new O(nO), this.exp(nj, nt);
+ }
+
+ function m() {
+ var nj = c();
+ return this.copyTo(nj), nj;
+ }
+
+ function d() {
+ if (this.s < 0) {
+ if (1 == this.t) return this[0] - this.DV;
+ if (0 == this.t) return -1;
+ } else {
+ if (1 == this.t) return this[0];
+ if (0 == this.t) return 0;
+ }
+
+ return (this[1] & (1 << 32 - this.DB) - 1) << this.DB | this[0];
+ }
+
+ function r() {
+ return 0 == this.t ? this.s : this[0] << 24 >> 24;
+ }
+
+ function Q() {
+ return 0 == this.t ? this.s : this[0] << 16 >> 16;
+ }
+
+ function P(nj) {
+ return Math.floor(Math.LN2 * this.DB / Math.log(nj));
+ }
+
+ function p0() {
+ return this.s < 0 ? -1 : this.t <= 0 || 1 == this.t && this[0] <= 0 ? 0 : 1;
+ }
+
+ function p1(nj) {
+ if (null == nj && (nj = 10), 0 == this.signum() || 2 > nj || nj > 36) return "0";
+ var nO = this.chunkSize(nj);
+ var nt = Math.pow(nj, nO);
+ var nX = b(nt);
+ var nG = c();
+ var nx = c();
+ var nN = "";
+
+ for (this.divRemTo(nX, nG, nx); nG.signum() > 0;) {
+ nN = (nt + nx.intValue()).toString(nj).substr(1) + nN;
+ nG.divRemTo(nX, nG, nx);
+ }
+
+ return nx.intValue().toString(nj) + nN;
+ }
+
+ function p2(nj, nO) {
+ this.fromInt(0);
+ null == nO && (nO = 10);
+
+ for (var nt = this.chunkSize(nO), nX = Math.pow(nO, nt), nG = !1, nx = 0, nN = 0, nD = 0; nD < nj.length; ++nD) {
+ var ny = f(nj, nD);
+
+ if (0 > ny) {
+ if ("-" == nj.charAt(nD) && 0 == this.signum()) {
+ nG = !0;
+ }
+ } else {
+ nN = nO * nN + ny;
+ ++nx >= nt && (this.dMultiply(nX), this.dAddOffset(nN, 0), nx = 0, nN = 0);
+ }
+ }
+
+ nx > 0 && (this.dMultiply(Math.pow(nO, nx)), this.dAddOffset(nN, 0));
+ nG && n.ZERO.subTo(this, this);
+ }
+
+ function p3(nj, nO, nt) {
+ if ("number" == typeof nO) {
+ if (2 > nj) this.fromInt(1);else {
+ for (this.fromNumber(nj, nt), this.testBit(nj - 1) || this.bitwiseTo(n.ONE.shiftLeft(nj - 1), pn, this), this.isEven() && this.dAddOffset(1, 0); !this.isProbablePrime(nO);) {
+ this.dAddOffset(2, 0);
+ this.bitLength() > nj && this.subTo(n.ONE.shiftLeft(nj - 1), this);
+ }
+ }
+ } else {
+ var nX = new Array();
+ var nG = 7 & nj;
+ nX.length = (nj >> 3) + 1;
+ nO.nextBytes(nX);
+ nG > 0 ? nX[0] &= (1 << nG) - 1 : nX[0] = 0;
+ this.fromString(nX, 256);
+ }
+ }
+
+ function p4() {
+ var nj = this.t;
+ var nO = new Array();
+ nO[0] = this.s;
+ var nt;
+ var nX = this.DB - nj * this.DB % 8;
+ var nG = 0;
+
+ if (nj-- > 0) {
+ for (nX < this.DB && (nt = this[nj] >> nX) != (this.s & this.DM) >> nX && (nO[nG++] = nt | this.s << this.DB - nX); nj >= 0;) {
+ 8 > nX ? (nt = (this[nj] & (1 << nX) - 1) << 8 - nX, nt |= this[--nj] >> (nX += this.DB - 8)) : (nt = this[nj] >> (nX -= 8) & 255, 0 >= nX && (nX += this.DB, --nj));
+ 0 != (128 & nt) && (nt |= -256);
+ 0 == nG && (128 & this.s) != (128 & nt) && ++nG;
+ (nG > 0 || nt != this.s) && (nO[nG++] = nt);
+ }
+ }
+
+ return nO;
+ }
+
+ function p5(nj) {
+ return 0 == this.compareTo(nj);
+ }
+
+ function p6(nj) {
+ return this.compareTo(nj) < 0 ? this : nj;
+ }
+
+ function p7(nj) {
+ return this.compareTo(nj) > 0 ? this : nj;
+ }
+
+ function p8(nj, nO, nt) {
+ var nX;
+ var nG;
+ var nx = Math.min(nj.t, this.t);
+
+ for (nX = 0; nx > nX; ++nX) nt[nX] = nO(this[nX], nj[nX]);
+
+ if (nj.t < this.t) {
+ for (nG = nj.s & this.DM, nX = nx; nX < this.t; ++nX) nt[nX] = nO(this[nX], nG);
+
+ nt.t = this.t;
+ } else {
+ for (nG = this.s & this.DM, nX = nx; nX < nj.t; ++nX) nt[nX] = nO(nG, nj[nX]);
+
+ nt.t = nj.t;
+ }
+
+ nt.s = nO(this.s, nj.s);
+ nt.clamp();
+ }
+
+ function p9(nj, nO) {
+ return nj & nO;
+ }
+
+ function pp(nj) {
+ var nO = c();
+ return this.bitwiseTo(nj, p9, nO), nO;
+ }
+
+ function pn(nj, nO) {
+ return nj | nO;
+ }
+
+ function pc(nj) {
+ var nO = c();
+ return this.bitwiseTo(nj, pn, nO), nO;
+ }
+
+ function pa(nj, nO) {
+ return nj ^ nO;
+ }
+
+ function pA(nj) {
+ var nO = c();
+ return this.bitwiseTo(nj, pa, nO), nO;
+ }
+
+ function pL(nj, nO) {
+ return nj & ~nO;
+ }
+
+ function pg(nj) {
+ var nO = c();
+ return this.bitwiseTo(nj, pL, nO), nO;
+ }
+
+ function pS() {
+ for (var nj = c(), nO = 0; nO < this.t; ++nO) nj[nO] = this.DM & ~this[nO];
+
+ return nj.t = this.t, nj.s = ~this.s, nj;
+ }
+
+ function pf(nj) {
+ var nO = c();
+ return 0 > nj ? this.rShiftTo(-nj, nO) : this.lShiftTo(nj, nO), nO;
+ }
+
+ function pY(nj) {
+ var nO = c();
+ return 0 > nj ? this.lShiftTo(-nj, nO) : this.rShiftTo(nj, nO), nO;
+ }
+
+ function pJ(nj) {
+ if (0 == nj) return -1;
+ var nO = 0;
+ return 0 == (65535 & nj) && (nj >>= 16, nO += 16), 0 == (255 & nj) && (nj >>= 8, nO += 8), 0 == (15 & nj) && (nj >>= 4, nO += 4), 0 == (3 & nj) && (nj >>= 2, nO += 2), 0 == (1 & nj) && ++nO, nO;
+ }
+
+ function pb() {
+ for (var nj = 0; nj < this.t; ++nj) if (0 != this[nj]) return nj * this.DB + pJ(this[nj]);
+
+ return this.s < 0 ? this.t * this.DB : -1;
+ }
+
+ function pC(nj) {
+ for (var nO = 0; 0 != nj;) {
+ nj &= nj - 1;
+ ++nO;
+ }
+
+ return nO;
+ }
+
+ function pV() {
+ for (var nj = 0, nO = this.s & this.DM, nt = 0; nt < this.t; ++nt) nj += pC(this[nt] ^ nO);
+
+ return nj;
+ }
+
+ function pW(nj) {
+ var nO = Math.floor(nj / this.DB);
+ return nO >= this.t ? 0 != this.s : 0 != (this[nO] & 1 << nj % this.DB);
+ }
+
+ function pl(nj, nO) {
+ var nt = n.ONE.shiftLeft(nj);
+ return this.bitwiseTo(nt, nO, nt), nt;
+ }
+
+ function pR(nj) {
+ return this.changeBit(nj, pn);
+ }
+
+ function pB(nj) {
+ return this.changeBit(nj, pL);
+ }
+
+ function pF(nj) {
+ return this.changeBit(nj, pa);
+ }
+
+ function pE(nj, nO) {
+ for (var nt = 0, nX = 0, nG = Math.min(nj.t, this.t); nG > nt;) {
+ nX += this[nt] + nj[nt];
+ nO[nt++] = nX & this.DM;
+ nX >>= this.DB;
+ }
+
+ if (nj.t < this.t) {
+ for (nX += nj.s; nt < this.t;) {
+ nX += this[nt];
+ nO[nt++] = nX & this.DM;
+ nX >>= this.DB;
+ }
+
+ nX += this.s;
+ } else {
+ for (nX += this.s; nt < nj.t;) {
+ nX += nj[nt];
+ nO[nt++] = nX & this.DM;
+ nX >>= this.DB;
+ }
+
+ nX += nj.s;
+ }
+
+ 0 > nX ? nO.s = -1 : nO.s = 0;
+ nX > 0 ? nO[nt++] = nX : -1 > nX && (nO[nt++] = this.DV + nX);
+ nO.t = nt;
+ nO.clamp();
+ }
+
+ function ps(nj) {
+ var nO = c();
+ return this.addTo(nj, nO), nO;
+ }
+
+ function pI(nj) {
+ var nO = c();
+ return this.subTo(nj, nO), nO;
+ }
+
+ function pK(nj) {
+ var nO = c();
+ return this.multiplyTo(nj, nO), nO;
+ }
+
+ function pT() {
+ var nj = c();
+ return this.squareTo(nj), nj;
+ }
+
+ function pi(nj) {
+ var nO = c();
+ return this.divRemTo(nj, nO, null), nO;
+ }
+
+ function pe(nj) {
+ var nO = c();
+ return this.divRemTo(nj, null, nO), nO;
+ }
+
+ function pZ(nj) {
+ var nO = c();
+ var nt = c();
+ return this.divRemTo(nj, nO, nt), new Array(nO, nt);
+ }
+
+ function pw(nj) {
+ this[this.t] = this.am(0, nj - 1, this, 0, 0, this.t);
+ ++this.t;
+ this.clamp();
+ }
+
+ function pM(nj, nO) {
+ if (0 != nj) {
+ for (; this.t <= nO;) this[this.t++] = 0;
+
+ for (this[nO] += nj; this[nO] >= this.DV;) {
+ this[nO] -= this.DV;
+ ++nO >= this.t && (this[this.t++] = 0);
+ ++this[nO];
+ }
+ }
+ }
+
+ function pu() {}
+
+ function pk(nj) {
+ return nj;
+ }
+
+ function pq(nj, nO, nt) {
+ nj.multiplyTo(nO, nt);
+ }
+
+ function pU(nj, nO) {
+ nj.squareTo(nO);
+ }
+
+ function pz(nj) {
+ return this.exp(nj, new pu());
+ }
+
+ function ph(nj, nO, nt) {
+ var nX = Math.min(this.t + nj.t, nO);
+
+ for (nt.s = 0, nt.t = nX; nX > 0;) nt[--nX] = 0;
+
+ var nG;
+
+ for (nG = nt.t - this.t; nG > nX; ++nX) nt[nX + this.t] = this.am(0, nj[nX], nt, nX, 0, this.t);
+
+ for (nG = Math.min(nj.t, nO); nG > nX; ++nX) this.am(0, nj[nX], nt, nX, 0, nO - nX);
+
+ nt.clamp();
+ }
+
+ function pH(nj, nO, nt) {
+ --nO;
+ var nX = nt.t = this.t + nj.t - nO;
+
+ for (nt.s = 0; --nX >= 0;) nt[nX] = 0;
+
+ for (nX = Math.max(nO - this.t, 0); nX < nj.t; ++nX) nt[this.t + nX - nO] = this.am(nO - nX, nj[nX], nt, 0, 0, this.t + nX - nO);
+
+ nt.clamp();
+ nt.drShiftTo(1, nt);
+ }
+
+ function pj(nj) {
+ this.r2 = c();
+ this.q3 = c();
+ n.ONE.dlShiftTo(2 * nj.t, this.r2);
+ this.mu = this.r2.divide(nj);
+ this.m = nj;
+ }
+
+ function pO(nj) {
+ if (nj.s < 0 || nj.t > 2 * this.m.t) return nj.mod(this.m);
+ if (nj.compareTo(this.m) < 0) return nj;
+ var nO = c();
+ return nj.copyTo(nO), this.reduce(nO), nO;
+ }
+
+ function pt(nj) {
+ return nj;
+ }
+
+ function pX(nj) {
+ for (nj.drShiftTo(this.m.t - 1, this.r2), nj.t > this.m.t + 1 && (nj.t = this.m.t + 1, nj.clamp()), this.mu.multiplyUpperTo(this.r2, this.m.t + 1, this.q3), this.m.multiplyLowerTo(this.q3, this.m.t + 1, this.r2); nj.compareTo(this.r2) < 0;) nj.dAddOffset(1, this.m.t + 1);
+
+ for (nj.subTo(this.r2, nj); nj.compareTo(this.m) >= 0;) nj.subTo(this.m, nj);
+ }
+
+ function pG(nj, nO) {
+ nj.squareTo(nO);
+ this.reduce(nO);
+ }
+
+ function px(nj, nO, nt) {
+ nj.multiplyTo(nO, nt);
+ this.reduce(nt);
+ }
+
+ function pN(nj, nO) {
+ var nt;
+ var nX;
+ var nG = nj.bitLength();
+ var nx = b(1);
+ if (0 >= nG) return nx;
+ 18 > nG ? nt = 1 : 48 > nG ? nt = 3 : 144 > nG ? nt = 4 : 768 > nG ? nt = 5 : nt = 6;
+ 8 > nG ? nX = new u(nO) : nO.isEven() ? nX = new pj(nO) : nX = new O(nO);
+ var nN = new Array();
+ var nD = 3;
+ var ny = nt - 1;
+ var no = (1 << nt) - 1;
+
+ if (nN[1] = nX.convert(this), nt > 1) {
+ var nv = c();
+
+ for (nX.sqrTo(nN[1], nv); no >= nD;) {
+ nN[nD] = c();
+ nX.mulTo(nv, nN[nD - 2], nN[nD]);
+ nD += 2;
+ }
+ }
+
+ var nm;
+ var nd;
+ var nr = nj.t - 1;
+ var nQ = !0;
+ var nP = c();
+
+ for (nG = F(nj[nr]) - 1; nr >= 0;) {
+ for (nG >= ny ? nm = nj[nr] >> nG - ny & no : (nm = (nj[nr] & (1 << nG + 1) - 1) << ny - nG, nr > 0 && (nm |= nj[nr - 1] >> this.DB + nG - ny)), nD = nt; 0 == (1 & nm);) {
+ nm >>= 1;
+ --nD;
+ }
+
+ if ((nG -= nD) < 0 && (nG += this.DB, --nr), nQ) {
+ nN[nm].copyTo(nx);
+ nQ = !1;
+ } else {
+ for (; nD > 1;) {
+ nX.sqrTo(nx, nP);
+ nX.sqrTo(nP, nx);
+ nD -= 2;
+ }
+
+ nD > 0 ? nX.sqrTo(nx, nP) : (nd = nx, nx = nP, nP = nd);
+ nX.mulTo(nP, nN[nm], nx);
+ }
+
+ for (; nr >= 0 && 0 == (nj[nr] & 1 << nG);) {
+ nX.sqrTo(nx, nP);
+ nd = nx;
+ nx = nP;
+ nP = nd;
+ --nG < 0 && (nG = this.DB - 1, --nr);
+ }
+ }
+
+ return nX.revert(nx);
+ }
+
+ function pD(nj) {
+ if (this.s < 0) {
+ var nO = this.negate();
+ } else {
+ var nO = this.clone();
+ }
+
+ if (nj.s < 0) {
+ var nt = nj.negate();
+ } else {
+ var nt = nj.clone();
+ }
+
+ if (nO.compareTo(nt) < 0) {
+ var nX = nO;
+ nO = nt;
+ nt = nX;
+ }
+
+ var nG = nO.getLowestSetBit();
+ var nx = nt.getLowestSetBit();
+ if (0 > nx) return nO;
+
+ for (nx > nG && (nx = nG), nx > 0 && (nO.rShiftTo(nx, nO), nt.rShiftTo(nx, nt)); nO.signum() > 0;) {
+ (nG = nO.getLowestSetBit()) > 0 && nO.rShiftTo(nG, nO);
+ (nG = nt.getLowestSetBit()) > 0 && nt.rShiftTo(nG, nt);
+ nO.compareTo(nt) >= 0 ? (nO.subTo(nt, nO), nO.rShiftTo(1, nO)) : (nt.subTo(nO, nt), nt.rShiftTo(1, nt));
+ }
+
+ return nx > 0 && nt.lShiftTo(nx, nt), nt;
+ }
+
+ function py(nj) {
+ if (0 >= nj) return 0;
+ var nO = this.DV % nj;
+
+ if (this.s < 0) {
+ var nt = nj - 1;
+ } else {
+ var nt = 0;
+ }
+
+ if (this.t > 0) {
+ if (0 == nO) nt = this[0] % nj;else {
+ for (var nX = this.t - 1; nX >= 0; --nX) nt = (nO * nt + this[nX]) % nj;
+ }
+ }
+
+ return nt;
+ }
+
+ function po(nj) {
+ var nO = nj.isEven();
+ if (this.isEven() && nO || 0 == nj.signum()) return n.ZERO;
+
+ for (var nt = nj.clone(), nX = this.clone(), nG = b(1), nx = b(0), nN = b(0), nD = b(1); 0 != nt.signum();) {
+ for (; nt.isEven();) {
+ nt.rShiftTo(1, nt);
+ nO ? (nG.isEven() && nx.isEven() || (nG.addTo(this, nG), nx.subTo(nj, nx)), nG.rShiftTo(1, nG)) : nx.isEven() || nx.subTo(nj, nx);
+ nx.rShiftTo(1, nx);
+ }
+
+ for (; nX.isEven();) {
+ nX.rShiftTo(1, nX);
+ nO ? (nN.isEven() && nD.isEven() || (nN.addTo(this, nN), nD.subTo(nj, nD)), nN.rShiftTo(1, nN)) : nD.isEven() || nD.subTo(nj, nD);
+ nD.rShiftTo(1, nD);
+ }
+
+ if (nt.compareTo(nX) >= 0) {
+ nt.subTo(nX, nt);
+ nO && nG.subTo(nN, nG);
+ nx.subTo(nD, nx);
+ } else {
+ nX.subTo(nt, nX);
+ nO && nN.subTo(nG, nN);
+ nD.subTo(nx, nD);
+ }
+ }
+
+ return 0 != nX.compareTo(n.ONE) ? n.ZERO : nD.compareTo(nj) >= 0 ? nD.subtract(nj) : nD.signum() < 0 ? (nD.addTo(nj, nD), nD.signum() < 0 ? nD.add(nj) : nD) : nD;
+ }
+
+ function pv(nj) {
+ var nO;
+ var nt = this.abs();
+
+ if (1 == nt.t && nt[0] <= nF[nF.length - 1]) {
+ for (nO = 0; nO < nF.length; ++nO) if (nt[0] == nF[nO]) return !0;
+
+ return !1;
+ }
+
+ if (nt.isEven()) return !1;
+
+ for (nO = 1; nO < nF.length;) {
+ for (var nX = nF[nO], nG = nO + 1; nG < nF.length && nE > nX;) nX *= nF[nG++];
+
+ for (nX = nt.modInt(nX); nG > nO;) if (nX % nF[nO++] == 0) return !1;
+ }
+
+ return nt.millerRabin(nj);
+ }
+
+ function pm(nj) {
+ var nO = this.subtract(n.ONE);
+ var nt = nO.getLowestSetBit();
+ if (0 >= nt) return !1;
+ var nX = nO.shiftRight(nt);
+ nj = nj + 1 >> 1;
+ nj > nF.length && (nj = nF.length);
+
+ for (var nG = c(), nx = 0; nj > nx; ++nx) {
+ nG.fromInt(nF[Math.floor(Math.random() * nF.length)]);
+ var nN = nG.modPow(nX, this);
+
+ if (0 != nN.compareTo(n.ONE) && 0 != nN.compareTo(nO)) {
+ for (var nD = 1; nD++ < nt && 0 != nN.compareTo(nO);) if (nN = nN.modPowInt(2, this), 0 == nN.compareTo(n.ONE)) return !1;
+
+ if (0 != nN.compareTo(nO)) return !1;
+ }
+ }
+
+ return !0;
+ }
+
+ function pd() {
+ this.i = 0;
+ this.j = 0;
+ this.S = new Array();
+ }
+
+ function pr(nj) {
+ var nO;
+ var nt;
+ var nX;
+
+ for (nO = 0; 256 > nO; ++nO) this.S[nO] = nO;
+
+ for (nt = 0, nO = 0; 256 > nO; ++nO) {
+ nt = nt + this.S[nO] + nj[nO % nj.length] & 255;
+ nX = this.S[nO];
+ this.S[nO] = this.S[nt];
+ this.S[nt] = nX;
+ }
+
+ this.i = 0;
+ this.j = 0;
+ }
+
+ function pQ() {
+ var nj;
+ return this.i = this.i + 1 & 255, this.j = this.j + this.S[this.i] & 255, nj = this.S[this.i], this.S[this.i] = this.S[this.j], this.S[this.j] = nj, this.S[nj + this.S[this.i] & 255];
+ }
+
+ function pP() {
+ return new pd();
+ }
+
+ function n0() {
+ if (null == nI) {
+ for (nI = pP(); ns > nT;) {
+ var nj = Math.floor(65536 * Math.random());
+ nK[nT++] = 255 & nj;
+ }
+
+ for (nI.init(nK), nT = 0; nT < nK.length; ++nT) nK[nT] = 0;
+
+ nT = 0;
+ }
+
+ return nI.next();
+ }
+
+ function n1(nj) {
+ var nO;
+
+ for (nO = 0; nO < nj.length; ++nO) nj[nO] = n0();
+ }
+
+ function n2() {}
+
+ function n3(nj, nO) {
+ return new n(nj, nO);
+ }
+
+ function n4(nj, nO) {
+ for (var nt = "", nX = 0; nX + nO < nj.length;) {
+ nt += nj.substring(nX, nX + nO) + "\n";
+ nX += nO;
+ }
+
+ return nt + nj.substring(nX, nj.length);
+ }
+
+ function n5(nj) {
+ return 16 > nj ? "0" + nj.toString(16) : nj.toString(16);
+ }
+
+ function n6(nj, nO) {
+ if (nO < nj.length + 11) return console.error("Message too long for RSA"), null;
+
+ for (var nt = new Array(), nX = nj.length - 1; nX >= 0 && nO > 0;) {
+ var nG = nj.charCodeAt(nX--);
+
+ if (128 > nG) {
+ nt[--nO] = nG;
+ } else {
+ if (nG > 127 && 2048 > nG) {
+ nt[--nO] = 63 & nG | 128;
+ nt[--nO] = nG >> 6 | 192;
+ } else {
+ nt[--nO] = 63 & nG | 128;
+ nt[--nO] = nG >> 6 & 63 | 128;
+ nt[--nO] = nG >> 12 | 224;
+ }
+ }
+ }
+
+ nt[--nO] = 0;
+
+ for (var nx = new n2(), nN = new Array(); nO > 2;) {
+ for (nN[0] = 0; 0 == nN[0];) nx.nextBytes(nN);
+
+ nt[--nO] = nN[0];
+ }
+
+ return nt[--nO] = 2, nt[--nO] = 0, new n(nt);
+ }
+
+ function n7() {
+ this.n = null;
+ this.e = 0;
+ this.d = null;
+ this.p = null;
+ this.q = null;
+ this.dmp1 = null;
+ this.dmq1 = null;
+ this.coeff = null;
+ }
+
+ function n8(nj, nO) {
+ if (null != nj && null != nO && nj.length > 0 && nO.length > 0) {
+ this.n = n3(nj, 16);
+ this.e = parseInt(nO, 16);
+ } else {
+ console.error("Invalid RSA public key");
+ }
+ }
+
+ function n9(nj) {
+ return nj.modPowInt(this.e, this.n);
+ }
+
+ function np(nj) {
+ var nO = n6(nj, this.n.bitLength() + 7 >> 3);
+ if (null == nO) return null;
+ var nt = this.doPublic(nO);
+ if (null == nt) return null;
+ var nX = nt.toString(16);
+ return 0 == (1 & nX.length) ? nX : "0" + nX;
+ }
+
+ function nn(nj, nO) {
+ for (var nt = nj.toByteArray(), nX = 0; nX < nt.length && 0 == nt[nX];) ++nX;
+
+ if (nt.length - nX != nO - 1 || 2 != nt[nX]) return null;
+
+ for (++nX; 0 != nt[nX];) if (++nX >= nt.length) return null;
+
+ for (var nG = ""; ++nX < nt.length;) {
+ var nx = 255 & nt[nX];
+
+ if (128 > nx) {
+ nG += String.fromCharCode(nx);
+ } else {
+ if (nx > 191 && 224 > nx) {
+ nG += String.fromCharCode((31 & nx) << 6 | 63 & nt[nX + 1]);
+ ++nX;
+ } else {
+ nG += String.fromCharCode((15 & nx) << 12 | (63 & nt[nX + 1]) << 6 | 63 & nt[nX + 2]);
+ nX += 2;
+ }
+ }
+ }
+
+ return nG;
+ }
+
+ function nc(nj, nO, nt) {
+ if (null != nj && null != nO && nj.length > 0 && nO.length > 0) {
+ this.n = n3(nj, 16);
+ this.e = parseInt(nO, 16);
+ this.d = n3(nt, 16);
+ } else {
+ console.error("Invalid RSA private key");
+ }
+ }
+
+ function na(nj, nO, nt, nX, nG, nx, nN, nD) {
+ if (null != nj && null != nO && nj.length > 0 && nO.length > 0) {
+ this.n = n3(nj, 16);
+ this.e = parseInt(nO, 16);
+ this.d = n3(nt, 16);
+ this.p = n3(nX, 16);
+ this.q = n3(nG, 16);
+ this.dmp1 = n3(nx, 16);
+ this.dmq1 = n3(nN, 16);
+ this.coeff = n3(nD, 16);
+ } else {
+ console.error("Invalid RSA private key");
+ }
+ }
+
+ function nA(nj, nO) {
+ var nt = new n2();
+ var nX = nj >> 1;
+ this.e = parseInt(nO, 16);
+
+ for (var nG = new n(nO, 16);;) {
+ for (; this.p = new n(nj - nX, 1, nt), 0 != this.p.subtract(n.ONE).gcd(nG).compareTo(n.ONE) || !this.p.isProbablePrime(10););
+
+ for (; this.q = new n(nX, 1, nt), 0 != this.q.subtract(n.ONE).gcd(nG).compareTo(n.ONE) || !this.q.isProbablePrime(10););
+
+ if (this.p.compareTo(this.q) <= 0) {
+ var nx = this.p;
+ this.p = this.q;
+ this.q = nx;
+ }
+
+ var nN = this.p.subtract(n.ONE);
+ var nD = this.q.subtract(n.ONE);
+ var ny = nN.multiply(nD);
+
+ if (0 == ny.gcd(nG).compareTo(n.ONE)) {
+ this.n = this.p.multiply(this.q);
+ this.d = nG.modInverse(ny);
+ this.dmp1 = this.d.mod(nN);
+ this.dmq1 = this.d.mod(nD);
+ this.coeff = this.q.modInverse(this.p);
+ break;
+ }
+ }
+ }
+
+ function nL(nj) {
+ if (null == this.p || null == this.q) return nj.modPow(this.d, this.n);
+
+ for (var nO = nj.mod(this.p).modPow(this.dmp1, this.p), nt = nj.mod(this.q).modPow(this.dmq1, this.q); nO.compareTo(nt) < 0;) nO = nO.add(this.p);
+
+ return nO.subtract(nt).multiply(this.coeff).mod(this.p).multiply(this.q).add(nt);
+ }
+
+ function ng(nj) {
+ var nO = n3(nj, 16);
+ var nt = this.doPrivate(nO);
+ return null == nt ? null : nn(nt, this.n.bitLength() + 7 >> 3);
+ }
+
+ function nS(nj) {
+ var nO;
+ var nt;
+ var nX = "";
+
+ for (nO = 0; nO + 3 <= nj.length; nO += 3) {
+ nt = parseInt(nj.substring(nO, nO + 3), 16);
+ nX += nw.charAt(nt >> 6) + nw.charAt(63 & nt);
+ }
+
+ for (nO + 1 == nj.length ? (nt = parseInt(nj.substring(nO, nO + 1), 16), nX += nw.charAt(nt << 2)) : nO + 2 == nj.length && (nt = parseInt(nj.substring(nO, nO + 2), 16), nX += nw.charAt(nt >> 2) + nw.charAt((3 & nt) << 4)); (3 & nX.length) > 0;) nX += nM;
+
+ return nX;
+ }
+
+ function nf(nj) {
+ var nO;
+ var nt;
+ var nX = "";
+ var nG = 0;
+
+ for (nO = 0; nO < nj.length && nj.charAt(nO) != nM; ++nO) {
+ v = nw.indexOf(nj.charAt(nO));
+ v < 0 || (0 == nG ? (nX += S(v >> 2), nt = 3 & v, nG = 1) : 1 == nG ? (nX += S(nt << 2 | v >> 4), nt = 15 & v, nG = 2) : 2 == nG ? (nX += S(nt), nX += S(v >> 2), nt = 3 & v, nG = 3) : (nX += S(nt << 2 | v >> 4), nX += S(15 & v), nG = 0));
+ }
+
+ return 1 == nG && (nX += S(nt << 2)), nX;
+ }
+
+ function nY(nj) {
+ var nO;
+ var nt = nf(nj);
+ var nX = new Array();
+
+ for (nO = 0; 2 * nO < nt.length; ++nO) nX[nO] = parseInt(nt.substring(2 * nO, 2 * nO + 2), 16);
+
+ return nX;
+ }
+
+ var nJ;
+ var nb = 244837814094590;
+ var nC = 15715070 == (16777215 & nb);
+ nC && "Microsoft Internet Explorer" == navigator.appName ? (n.prototype.am = A, nJ = 30) : nC && "Netscape" != navigator.appName ? (n.prototype.am = a, nJ = 26) : (n.prototype.am = g, nJ = 28);
+ n.prototype.DB = nJ;
+ n.prototype.DM = (1 << nJ) - 1;
+ n.prototype.DV = 1 << nJ;
+ var nV = 52;
+ n.prototype.FV = Math.pow(2, nV);
+ n.prototype.F1 = nV - nJ;
+ n.prototype.F2 = 2 * nJ - nV;
+ var nW = "0123456789abcdefghijklmnopqrstuvwxyz";
+ var nl = new Array();
+ var nR;
+ var nB;
+
+ for (nR = "0".charCodeAt(0), nB = 0; 9 >= nB; ++nB) nl[nR++] = nB;
+
+ for (nR = "a".charCodeAt(0), nB = 10; 36 > nB; ++nB) nl[nR++] = nB;
+
+ for (nR = "A".charCodeAt(0), nB = 10; 36 > nB; ++nB) nl[nR++] = nB;
+
+ u.prototype.convert = k;
+ u.prototype.revert = q;
+ u.prototype.reduce = U;
+ u.prototype.mulTo = h;
+ u.prototype.sqrTo = H;
+ O.prototype.convert = X;
+ O.prototype.revert = G;
+ O.prototype.reduce = x;
+ O.prototype.mulTo = D;
+ O.prototype.sqrTo = N;
+ n.prototype.copyTo = Y;
+ n.prototype.fromInt = J;
+ n.prototype.fromString = C;
+ n.prototype.clamp = V;
+ n.prototype.dlShiftTo = s;
+ n.prototype.drShiftTo = I;
+ n.prototype.lShiftTo = K;
+ n.prototype.rShiftTo = T;
+ n.prototype.subTo = i;
+ n.prototype.multiplyTo = e;
+ n.prototype.squareTo = Z;
+ n.prototype.divRemTo = w;
+ n.prototype.invDigit = j;
+ n.prototype.isEven = y;
+ n.prototype.exp = o;
+ n.prototype.toString = W;
+ n.prototype.negate = l;
+ n.prototype.abs = R;
+ n.prototype.compareTo = B;
+ n.prototype.bitLength = E;
+ n.prototype.mod = M;
+ n.prototype.modPowInt = v;
+ n.ZERO = b(0);
+ n.ONE = b(1);
+ pu.prototype.convert = pk;
+ pu.prototype.revert = pk;
+ pu.prototype.mulTo = pq;
+ pu.prototype.sqrTo = pU;
+ pj.prototype.convert = pO;
+ pj.prototype.revert = pt;
+ pj.prototype.reduce = pX;
+ pj.prototype.mulTo = px;
+ pj.prototype.sqrTo = pG;
+ var nF = [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 nE = 67108864 / nF[nF.length - 1];
+ n.prototype.chunkSize = P;
+ n.prototype.toRadix = p1;
+ n.prototype.fromRadix = p2;
+ n.prototype.fromNumber = p3;
+ n.prototype.bitwiseTo = p8;
+ n.prototype.changeBit = pl;
+ n.prototype.addTo = pE;
+ n.prototype.dMultiply = pw;
+ n.prototype.dAddOffset = pM;
+ n.prototype.multiplyLowerTo = ph;
+ n.prototype.multiplyUpperTo = pH;
+ n.prototype.modInt = py;
+ n.prototype.millerRabin = pm;
+ n.prototype.clone = m;
+ n.prototype.intValue = d;
+ n.prototype.byteValue = r;
+ n.prototype.shortValue = Q;
+ n.prototype.signum = p0;
+ n.prototype.toByteArray = p4;
+ n.prototype.equals = p5;
+ n.prototype.min = p6;
+ n.prototype.max = p7;
+ n.prototype.and = pp;
+ n.prototype.or = pc;
+ n.prototype.xor = pA;
+ n.prototype.andNot = pg;
+ n.prototype.not = pS;
+ n.prototype.shiftLeft = pf;
+ n.prototype.shiftRight = pY;
+ n.prototype.getLowestSetBit = pb;
+ n.prototype.bitCount = pV;
+ n.prototype.testBit = pW;
+ n.prototype.setBit = pR;
+ n.prototype.clearBit = pB;
+ n.prototype.flipBit = pF;
+ n.prototype.add = ps;
+ n.prototype.subtract = pI;
+ n.prototype.multiply = pK;
+ n.prototype.divide = pi;
+ n.prototype.remainder = pe;
+ n.prototype.divideAndRemainder = pZ;
+ n.prototype.modPow = pN;
+ n.prototype.modInverse = po;
+ n.prototype.pow = pz;
+ n.prototype.gcd = pD;
+ n.prototype.isProbablePrime = pv;
+ n.prototype.square = pT;
+ pd.prototype.init = pr;
+ pd.prototype.next = pQ;
+ var ns = 256;
+ var nI;
+ var nK;
+ var nT;
+
+ if (null == nK) {
+ nK = new Array();
+ nT = 0;
+ var ni;
+
+ if (window.crypto && window.crypto.getRandomValues) {
+ var ne = new Uint32Array(256);
+
+ for (window.crypto.getRandomValues(ne), ni = 0; ni < ne.length; ++ni) nK[nT++] = 255 & ne[ni];
+ }
+
+ var nZ = function (nj) {
+ if (this.count = this.count || 0, this.count >= 256 || nT >= ns) return void (window.removeEventListener ? window.removeEventListener("mousemove", nZ) : window.detachEvent && window.detachEvent("onmousemove", nZ));
+ this.count += 1;
+ var nO = nj.x + nj.y;
+ nK[nT++] = 255 & nO;
+ };
+
+ if (window.addEventListener) {
+ window.addEventListener("mousemove", nZ);
+ } else {
+ if (window.attachEvent) {
+ window.attachEvent("onmousemove", nZ);
+ }
+ }
+ }
+
+ n2.prototype.nextBytes = n1;
+ n7.prototype.doPublic = n9;
+ n7.prototype.setPublic = n8;
+ n7.prototype.encrypt = np;
+ n7.prototype.doPrivate = nL;
+ n7.prototype.setPrivate = nc;
+ n7.prototype.setPrivateEx = na;
+ n7.prototype.generate = nA;
+ n7.prototype.decrypt = ng;
+
+ (function () {
+ var nj = function (nX, nG, nx) {
+ var nN = new n2();
+ var nD = nX >> 1;
+ this.e = parseInt(nG, 16);
+ var ny = new n(nG, 16);
+ var no = this;
+
+ var nv = function () {
+ var nm = function () {
+ if (no.p.compareTo(no.q) <= 0) {
+ var nQ = no.p;
+ no.p = no.q;
+ no.q = nQ;
+ }
+
+ var nP = no.p.subtract(n.ONE);
+ var c0 = no.q.subtract(n.ONE);
+ var c1 = nP.multiply(c0);
+
+ if (0 == c1.gcd(ny).compareTo(n.ONE)) {
+ no.n = no.p.multiply(no.q);
+ no.d = ny.modInverse(c1);
+ no.dmp1 = no.d.mod(nP);
+ no.dmq1 = no.d.mod(c0);
+ no.coeff = no.q.modInverse(no.p);
+ setTimeout(function () {
+ nx();
+ }, 0);
+ } else {
+ setTimeout(nv, 0);
+ }
+ };
+
+ var nd = function () {
+ no.q = c();
+ no.q.fromNumberAsync(nD, 1, nN, function () {
+ no.q.subtract(n.ONE).gcda(ny, function (nQ) {
+ if (0 == nQ.compareTo(n.ONE) && no.q.isProbablePrime(10)) {
+ setTimeout(nm, 0);
+ } else {
+ setTimeout(nd, 0);
+ }
+ });
+ });
+ };
+
+ var nr = function () {
+ no.p = c();
+ no.p.fromNumberAsync(nX - nD, 1, nN, function () {
+ no.p.subtract(n.ONE).gcda(ny, function (nQ) {
+ if (0 == nQ.compareTo(n.ONE) && no.p.isProbablePrime(10)) {
+ setTimeout(nd, 0);
+ } else {
+ setTimeout(nr, 0);
+ }
+ });
+ });
+ };
+
+ setTimeout(nr, 0);
+ };
+
+ setTimeout(nv, 0);
+ };
+
+ n7.prototype.generateAsync = nj;
+
+ var nO = function (nX, nG) {
+ if (this.s < 0) {
+ var nx = this.negate();
+ } else {
+ var nx = this.clone();
+ }
+
+ if (nX.s < 0) {
+ var nN = nX.negate();
+ } else {
+ var nN = nX.clone();
+ }
+
+ if (nx.compareTo(nN) < 0) {
+ var nD = nx;
+ nx = nN;
+ nN = nD;
+ }
+
+ var ny = nx.getLowestSetBit();
+ var no = nN.getLowestSetBit();
+ if (0 > no) return void nG(nx);
+ no > ny && (no = ny);
+ no > 0 && (nx.rShiftTo(no, nx), nN.rShiftTo(no, nN));
+
+ var nv = function () {
+ (ny = nx.getLowestSetBit()) > 0 && nx.rShiftTo(ny, nx);
+ (ny = nN.getLowestSetBit()) > 0 && nN.rShiftTo(ny, nN);
+ nx.compareTo(nN) >= 0 ? (nx.subTo(nN, nx), nx.rShiftTo(1, nx)) : (nN.subTo(nx, nN), nN.rShiftTo(1, nN));
+ nx.signum() > 0 ? setTimeout(nv, 0) : (no > 0 && nN.lShiftTo(no, nN), setTimeout(function () {
+ nG(nN);
+ }, 0));
+ };
+
+ setTimeout(nv, 10);
+ };
+
+ n.prototype.gcda = nO;
+
+ var nt = function (nX, nG, nx, nN) {
+ if ("number" == typeof nG) {
+ if (2 > nX) this.fromInt(1);else {
+ this.fromNumber(nX, nx);
+ this.testBit(nX - 1) || this.bitwiseTo(n.ONE.shiftLeft(nX - 1), pn, this);
+ this.isEven() && this.dAddOffset(1, 0);
+ var nD = this;
+
+ var ny = function () {
+ nD.dAddOffset(2, 0);
+ nD.bitLength() > nX && nD.subTo(n.ONE.shiftLeft(nX - 1), nD);
+ nD.isProbablePrime(nG) ? setTimeout(function () {
+ nN();
+ }, 0) : setTimeout(ny, 0);
+ };
+
+ setTimeout(ny, 0);
+ }
+ } else {
+ var no = new Array();
+ var nv = 7 & nX;
+ no.length = (nX >> 3) + 1;
+ nG.nextBytes(no);
+ nv > 0 ? no[0] &= (1 << nv) - 1 : no[0] = 0;
+ this.fromString(no, 256);
+ }
+ };
+
+ n.prototype.fromNumberAsync = nt;
+ })();
+
+ var nw = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+ var nM = "=";
+ var nu = nu || {};
+ nu.env = nu.env || {};
+ var nk = nu;
+ var nq = Object.prototype;
+ var nU = "[object Function]";
+ var nz = ["toString", "valueOf"];
+
+ nu.env.parseUA = function (nj) {
+ var nO;
+
+ var nt = function (ny) {
+ var no = 0;
+ return parseFloat(ny.replace(/\./g, function () {
+ return 1 == no++ ? "" : ".";
+ }));
+ };
+
+ var nX = navigator;
+ var nG = {
+ "ie": 0,
+ "opera": 0,
+ "gecko": 0,
+ "webkit": 0,
+ "chrome": 0,
+ "mobile": null,
+ "air": 0,
+ "ipad": 0,
+ "iphone": 0,
+ "ipod": 0,
+ "ios": null,
+ "android": 0,
+ "webos": 0,
+ "caja": nX && nX.cajaVersion,
+ "secure": !1,
+ "os": null
+ };
+ var nx = nj || navigator && navigator.userAgent;
+ var nN = window && window.location;
+ var nD = nN && nN.href;
+ return nG.secure = nD && 0 === nD.toLowerCase().indexOf("https"), nx && (/windows|win32/i.test(nx) ? nG.os = "windows" : /macintosh/i.test(nx) ? nG.os = "macintosh" : /rhino/i.test(nx) && (nG.os = "rhino"), /KHTML/.test(nx) && (nG.webkit = 1), nO = nx.match(/AppleWebKit\/([^\s]*)/), nO && nO[1] && (nG.webkit = nt(nO[1]), / Mobile\//.test(nx) ? (nG.mobile = "Apple", nO = nx.match(/OS ([^\s]*)/), nO && nO[1] && (nO = nt(nO[1].replace("_", "."))), nG.ios = nO, nG.ipad = nG.ipod = nG.iphone = 0, nO = nx.match(/iPad|iPod|iPhone/), nO && nO[0] && (nG[nO[0].toLowerCase()] = nG.ios)) : (nO = nx.match(/NokiaN[^\/]*|Android \d\.\d|webOS\/\d\.\d/), nO && (nG.mobile = nO[0]), /webOS/.test(nx) && (nG.mobile = "WebOS", nO = nx.match(/webOS\/([^\s]*);/), nO && nO[1] && (nG.webos = nt(nO[1]))), / Android/.test(nx) && (nG.mobile = "Android", nO = nx.match(/Android ([^\s]*);/), nO && nO[1] && (nG.android = nt(nO[1])))), nO = nx.match(/Chrome\/([^\s]*)/), nO && nO[1] ? nG.chrome = nt(nO[1]) : (nO = nx.match(/AdobeAIR\/([^\s]*)/), nO && (nG.air = nO[0]))), nG.webkit || (nO = nx.match(/Opera[\s\/]([^\s]*)/), nO && nO[1] ? (nG.opera = nt(nO[1]), nO = nx.match(/Version\/([^\s]*)/), nO && nO[1] && (nG.opera = nt(nO[1])), nO = nx.match(/Opera Mini[^;]*/), nO && (nG.mobile = nO[0])) : (nO = nx.match(/MSIE\s([^;]*)/), nO && nO[1] ? nG.ie = nt(nO[1]) : (nO = nx.match(/Gecko\/([^\s]*)/), nO && (nG.gecko = 1, nO = nx.match(/rv:([^\s\)]*)/), nO && nO[1] && (nG.gecko = nt(nO[1]))))))), nG;
+ };
+
+ nu.env.ua = nu.env.parseUA();
+
+ nu.isFunction = function (nj) {
+ return "function" == typeof nj || nq.toString.apply(nj) === nU;
+ };
+
+ nu.env.ua.ie ? nu._IEEnumFix = function (nj, nO) {
+ var nt;
+ var nX;
+ var nG;
+
+ for (nt = 0; nt < nz.length; nt += 1) {
+ nX = nz[nt];
+ nG = nO[nX];
+ nk.isFunction(nG) && nG != nq[nX] && (nj[nX] = nG);
+ }
+ } : nu._IEEnumFix = function () {};
+
+ nu.extend = function (nj, nO, nt) {
+ if (!nO || !nj) throw new Error("extend failed, please check that all dependencies are included.");
+ var nX;
+
+ var nG = function () {};
+
+ if (nG.prototype = nO.prototype, nj.prototype = new nG(), nj.prototype.constructor = nj, nj.superclass = nO.prototype, nO.prototype.constructor == nq.constructor && (nO.prototype.constructor = nO), nt) {
+ for (nX in nt) if (nk.hasOwnProperty(nt, nX)) {
+ nj.prototype[nX] = nt[nX];
+ }
+
+ nk._IEEnumFix(nj.prototype, nt);
+ }
+ };
+
+ "undefined" != typeof KJUR && KJUR || (KJUR = {});
+ "undefined" != typeof KJUR.asn1 && KJUR.asn1 || (KJUR.asn1 = {});
+ KJUR.asn1.ASN1Util = new function () {
+ this.integerToByteHex = function (nj) {
+ var nO = nj.toString(16);
+ return nO.length % 2 == 1 && (nO = "0" + nO), nO;
+ };
+
+ this.bigIntToMinTwosComplementsHex = function (nj) {
+ var nO = nj.toString(16);
+ if ("-" != nO.substr(0, 1)) {
+ if (nO.length % 2 == 1) {
+ nO = "0" + nO;
+ } else {
+ nO.match(/^[0-7]/) || (nO = "00" + nO);
+ }
+ } else {
+ var nt = nO.substr(1);
+ var nX = nt.length;
+
+ if (nX % 2 == 1) {
+ nX += 1;
+ } else {
+ nO.match(/^[0-7]/) || (nX += 2);
+ }
+
+ for (var nG = "", nx = 0; nX > nx; nx++) nG += "f";
+
+ var nN = new n(nG, 16);
+ var nD = nN.xor(nj).add(n.ONE);
+ nO = nD.toString(16).replace(/^-/, "");
+ }
+ return nO;
+ };
+
+ this.getPEMStringFromHex = function (nj, nO) {
+ var nt = CryptoJS.enc.Hex.parse(nj);
+ var nX = CryptoJS.enc.Base64.stringify(nt);
+ var nG = nX.replace(/(.{64})/g, "$1\r\n");
+ return nG = nG.replace(/\r\n$/, ""), "-----BEGIN " + nO + "-----\r\n" + nG + "\r\n-----END " + nO + "-----\r\n";
+ };
+ }();
+
+ KJUR.asn1.ASN1Object = function () {
+ var nj = "";
+
+ this.getLengthHexFromValue = function () {
+ if ("undefined" == typeof this.hV || null == this.hV) throw "this.hV is null or undefined.";
+ if (this.hV.length % 2 == 1) throw "value hex must be even length: n=" + nj.length + ",v=" + this.hV;
+ var nO = this.hV.length / 2;
+ var nt = nO.toString(16);
+ if (nt.length % 2 == 1 && (nt = "0" + nt), 128 > nO) return nt;
+ var nX = nt.length / 2;
+ if (nX > 15) throw "ASN.1 length too long to represent by 8x: n = " + nO.toString(16);
+ var nG = 128 + nX;
+ return nG.toString(16) + nt;
+ };
+
+ this.getEncodedHex = function () {
+ return (null == this.hTLV || this.isModified) && (this.hV = this.getFreshValueHex(), this.hL = this.getLengthHexFromValue(), this.hTLV = this.hT + this.hL + this.hV, this.isModified = !1), this.hTLV;
+ };
+
+ this.getValueHex = function () {
+ return this.getEncodedHex(), this.hV;
+ };
+
+ this.getFreshValueHex = function () {
+ return "";
+ };
+ };
+
+ KJUR.asn1.DERAbstractString = function (nj) {
+ KJUR.asn1.DERAbstractString.superclass.constructor.call(this);
+
+ this.getString = function () {
+ return this.s;
+ };
+
+ this.setString = function (nO) {
+ this.hTLV = null;
+ this.isModified = !0;
+ this.s = nO;
+ this.hV = stohex(this.s);
+ };
+
+ this.setStringHex = function (nO) {
+ this.hTLV = null;
+ this.isModified = !0;
+ this.s = null;
+ this.hV = nO;
+ };
+
+ this.getFreshValueHex = function () {
+ return this.hV;
+ };
+
+ "undefined" != typeof nj && ("undefined" != typeof nj.str ? this.setString(nj.str) : "undefined" != typeof nj.hex && this.setStringHex(nj.hex));
+ };
+
+ nu.extend(KJUR.asn1.DERAbstractString, KJUR.asn1.ASN1Object);
+
+ KJUR.asn1.DERAbstractTime = function () {
+ KJUR.asn1.DERAbstractTime.superclass.constructor.call(this);
+
+ this.localDateToUTC = function (nj) {
+ utc = nj.getTime() + 60000 * nj.getTimezoneOffset();
+ var nO = new Date(utc);
+ return nO;
+ };
+
+ this.formatDate = function (nj, nO) {
+ var nt = this.zeroPadding;
+ var nX = this.localDateToUTC(nj);
+ var nG = String(nX.getFullYear());
+
+ if ("utc" == nO) {
+ nG = nG.substr(2, 2);
+ }
+
+ var nx = nt(String(nX.getMonth() + 1), 2);
+ var nN = nt(String(nX.getDate()), 2);
+ var nD = nt(String(nX.getHours()), 2);
+ var ny = nt(String(nX.getMinutes()), 2);
+ var no = nt(String(nX.getSeconds()), 2);
+ return nG + nx + nN + nD + ny + no + "Z";
+ };
+
+ this.zeroPadding = function (nj, nO) {
+ return nj.length >= nO ? nj : new Array(nO - nj.length + 1).join("0") + nj;
+ };
+
+ this.getString = function () {
+ return this.s;
+ };
+
+ this.setString = function (nj) {
+ this.hTLV = null;
+ this.isModified = !0;
+ this.s = nj;
+ this.hV = stohex(this.s);
+ };
+
+ this.setByDateValue = function (nj, nO, nt, nX, nG, nx) {
+ var nN = new Date(Date.UTC(nj, nO - 1, nt, nX, nG, nx, 0));
+ this.setByDate(nN);
+ };
+
+ this.getFreshValueHex = function () {
+ return this.hV;
+ };
+ };
+
+ nu.extend(KJUR.asn1.DERAbstractTime, KJUR.asn1.ASN1Object);
+
+ KJUR.asn1.DERAbstractStructured = function (nj) {
+ KJUR.asn1.DERAbstractString.superclass.constructor.call(this);
+
+ this.setByASN1ObjectArray = function (nO) {
+ this.hTLV = null;
+ this.isModified = !0;
+ this.asn1Array = nO;
+ };
+
+ this.appendASN1Object = function (nO) {
+ this.hTLV = null;
+ this.isModified = !0;
+ this.asn1Array.push(nO);
+ };
+
+ this.asn1Array = new Array();
+ "undefined" != typeof nj && "undefined" != typeof nj.array && (this.asn1Array = nj.array);
+ };
+
+ nu.extend(KJUR.asn1.DERAbstractStructured, KJUR.asn1.ASN1Object);
+
+ KJUR.asn1.DERBoolean = function () {
+ KJUR.asn1.DERBoolean.superclass.constructor.call(this);
+ this.hT = "01";
+ this.hTLV = "0101ff";
+ };
+
+ nu.extend(KJUR.asn1.DERBoolean, KJUR.asn1.ASN1Object);
+
+ KJUR.asn1.DERInteger = function (nj) {
+ KJUR.asn1.DERInteger.superclass.constructor.call(this);
+ this.hT = "02";
+
+ this.setByBigInteger = function (nO) {
+ this.hTLV = null;
+ this.isModified = !0;
+ this.hV = KJUR.asn1.ASN1Util.bigIntToMinTwosComplementsHex(nO);
+ };
+
+ this.setByInteger = function (nO) {
+ var nt = new n(String(nO), 10);
+ this.setByBigInteger(nt);
+ };
+
+ this.setValueHex = function (nO) {
+ this.hV = nO;
+ };
+
+ this.getFreshValueHex = function () {
+ return this.hV;
+ };
+
+ "undefined" != typeof nj && ("undefined" != typeof nj.bigint ? this.setByBigInteger(nj.bigint) : "undefined" != typeof nj.int ? this.setByInteger(nj.int) : "undefined" != typeof nj.hex && this.setValueHex(nj.hex));
+ };
+
+ nu.extend(KJUR.asn1.DERInteger, KJUR.asn1.ASN1Object);
+
+ KJUR.asn1.DERBitString = function (nj) {
+ KJUR.asn1.DERBitString.superclass.constructor.call(this);
+ this.hT = "03";
+
+ this.setHexValueIncludingUnusedBits = function (nO) {
+ this.hTLV = null;
+ this.isModified = !0;
+ this.hV = nO;
+ };
+
+ this.setUnusedBitsAndHexValue = function (nO, nt) {
+ if (0 > nO || nO > 7) throw "unused bits shall be from 0 to 7: u = " + nO;
+ var nX = "0" + nO;
+ this.hTLV = null;
+ this.isModified = !0;
+ this.hV = nX + nt;
+ };
+
+ this.setByBinaryString = function (nO) {
+ nO = nO.replace(/0+$/, "");
+ var nt = 8 - nO.length % 8;
+
+ if (8 == nt) {
+ nt = 0;
+ }
+
+ for (var nX = 0; nt >= nX; nX++) nO += "0";
+
+ for (var nG = "", nX = 0; nX < nO.length - 1; nX += 8) {
+ var nx = nO.substr(nX, 8);
+ var nN = parseInt(nx, 2).toString(16);
+ 1 == nN.length && (nN = "0" + nN);
+ nG += nN;
+ }
+
+ this.hTLV = null;
+ this.isModified = !0;
+ this.hV = "0" + nt + nG;
+ };
+
+ this.setByBooleanArray = function (nO) {
+ for (var nt = "", nX = 0; nX < nO.length; nX++) nt += 1 == nO[nX] ? "1" : "0";
+
+ this.setByBinaryString(nt);
+ };
+
+ this.newFalseArray = function (nO) {
+ for (var nt = new Array(nO), nX = 0; nO > nX; nX++) nt[nX] = !1;
+
+ return nt;
+ };
+
+ this.getFreshValueHex = function () {
+ return this.hV;
+ };
+
+ "undefined" != typeof nj && ("undefined" != typeof nj.hex ? this.setHexValueIncludingUnusedBits(nj.hex) : "undefined" != typeof nj.bin ? this.setByBinaryString(nj.bin) : "undefined" != typeof nj.array && this.setByBooleanArray(nj.array));
+ };
+
+ nu.extend(KJUR.asn1.DERBitString, KJUR.asn1.ASN1Object);
+
+ KJUR.asn1.DEROctetString = function (nj) {
+ KJUR.asn1.DEROctetString.superclass.constructor.call(this, nj);
+ this.hT = "04";
+ };
+
+ nu.extend(KJUR.asn1.DEROctetString, KJUR.asn1.DERAbstractString);
+
+ KJUR.asn1.DERNull = function () {
+ KJUR.asn1.DERNull.superclass.constructor.call(this);
+ this.hT = "05";
+ this.hTLV = "0500";
+ };
+
+ nu.extend(KJUR.asn1.DERNull, KJUR.asn1.ASN1Object);
+
+ KJUR.asn1.DERObjectIdentifier = function (nj) {
+ var nO = function (nX) {
+ var nG = nX.toString(16);
+ return 1 == nG.length && (nG = "0" + nG), nG;
+ };
+
+ var nt = function (nX) {
+ var nG = "";
+ var nx = new n(nX, 10);
+ var nN = nx.toString(2);
+ var nD = 7 - nN.length % 7;
+
+ if (7 == nD) {
+ nD = 0;
+ }
+
+ for (var ny = "", no = 0; nD > no; no++) ny += "0";
+
+ nN = ny + nN;
+
+ for (var no = 0; no < nN.length - 1; no += 7) {
+ var nv = nN.substr(no, 7);
+ no != nN.length - 7 && (nv = "1" + nv);
+ nG += nO(parseInt(nv, 2));
+ }
+
+ return nG;
+ };
+
+ KJUR.asn1.DERObjectIdentifier.superclass.constructor.call(this);
+ this.hT = "06";
+
+ this.setValueHex = function (nX) {
+ this.hTLV = null;
+ this.isModified = !0;
+ this.s = null;
+ this.hV = nX;
+ };
+
+ this.setValueOidString = function (nX) {
+ if (!nX.match(/^[0-9.]+$/)) throw "malformed oid string: " + nX;
+ var nG = "";
+ var nx = nX.split(".");
+ var nN = 40 * parseInt(nx[0]) + parseInt(nx[1]);
+ nG += nO(nN);
+ nx.splice(0, 2);
+
+ for (var nD = 0; nD < nx.length; nD++) nG += nt(nx[nD]);
+
+ this.hTLV = null;
+ this.isModified = !0;
+ this.s = null;
+ this.hV = nG;
+ };
+
+ this.setValueName = function (nX) {
+ if ("undefined" == typeof KJUR.asn1.x509.OID.name2oidList[nX]) throw "DERObjectIdentifier oidName undefined: " + nX;
+ var nG = KJUR.asn1.x509.OID.name2oidList[nX];
+ this.setValueOidString(nG);
+ };
+
+ this.getFreshValueHex = function () {
+ return this.hV;
+ };
+
+ "undefined" != typeof nj && ("undefined" != typeof nj.oid ? this.setValueOidString(nj.oid) : "undefined" != typeof nj.hex ? this.setValueHex(nj.hex) : "undefined" != typeof nj.name && this.setValueName(nj.name));
+ };
+
+ nu.extend(KJUR.asn1.DERObjectIdentifier, KJUR.asn1.ASN1Object);
+
+ KJUR.asn1.DERUTF8String = function (nj) {
+ KJUR.asn1.DERUTF8String.superclass.constructor.call(this, nj);
+ this.hT = "0c";
+ };
+
+ nu.extend(KJUR.asn1.DERUTF8String, KJUR.asn1.DERAbstractString);
+
+ KJUR.asn1.DERNumericString = function (nj) {
+ KJUR.asn1.DERNumericString.superclass.constructor.call(this, nj);
+ this.hT = "12";
+ };
+
+ nu.extend(KJUR.asn1.DERNumericString, KJUR.asn1.DERAbstractString);
+
+ KJUR.asn1.DERPrintableString = function (nj) {
+ KJUR.asn1.DERPrintableString.superclass.constructor.call(this, nj);
+ this.hT = "13";
+ };
+
+ nu.extend(KJUR.asn1.DERPrintableString, KJUR.asn1.DERAbstractString);
+
+ KJUR.asn1.DERTeletexString = function (nj) {
+ KJUR.asn1.DERTeletexString.superclass.constructor.call(this, nj);
+ this.hT = "14";
+ };
+
+ nu.extend(KJUR.asn1.DERTeletexString, KJUR.asn1.DERAbstractString);
+
+ KJUR.asn1.DERIA5String = function (nj) {
+ KJUR.asn1.DERIA5String.superclass.constructor.call(this, nj);
+ this.hT = "16";
+ };
+
+ nu.extend(KJUR.asn1.DERIA5String, KJUR.asn1.DERAbstractString);
+
+ KJUR.asn1.DERUTCTime = function (nj) {
+ KJUR.asn1.DERUTCTime.superclass.constructor.call(this, nj);
+ this.hT = "17";
+
+ this.setByDate = function (nO) {
+ this.hTLV = null;
+ this.isModified = !0;
+ this.date = nO;
+ this.s = this.formatDate(this.date, "utc");
+ this.hV = stohex(this.s);
+ };
+
+ "undefined" != typeof nj && ("undefined" != typeof nj.str ? this.setString(nj.str) : "undefined" != typeof nj.hex ? this.setStringHex(nj.hex) : "undefined" != typeof nj.date && this.setByDate(nj.date));
+ };
+
+ nu.extend(KJUR.asn1.DERUTCTime, KJUR.asn1.DERAbstractTime);
+
+ KJUR.asn1.DERGeneralizedTime = function (nj) {
+ KJUR.asn1.DERGeneralizedTime.superclass.constructor.call(this, nj);
+ this.hT = "18";
+
+ this.setByDate = function (nO) {
+ this.hTLV = null;
+ this.isModified = !0;
+ this.date = nO;
+ this.s = this.formatDate(this.date, "gen");
+ this.hV = stohex(this.s);
+ };
+
+ "undefined" != typeof nj && ("undefined" != typeof nj.str ? this.setString(nj.str) : "undefined" != typeof nj.hex ? this.setStringHex(nj.hex) : "undefined" != typeof nj.date && this.setByDate(nj.date));
+ };
+
+ nu.extend(KJUR.asn1.DERGeneralizedTime, KJUR.asn1.DERAbstractTime);
+
+ KJUR.asn1.DERSequence = function (nj) {
+ KJUR.asn1.DERSequence.superclass.constructor.call(this, nj);
+ this.hT = "30";
+
+ this.getFreshValueHex = function () {
+ for (var nO = "", nt = 0; nt < this.asn1Array.length; nt++) {
+ var nX = this.asn1Array[nt];
+ nO += nX.getEncodedHex();
+ }
+
+ return this.hV = nO, this.hV;
+ };
+ };
+
+ nu.extend(KJUR.asn1.DERSequence, KJUR.asn1.DERAbstractStructured);
+
+ KJUR.asn1.DERSet = function (nj) {
+ KJUR.asn1.DERSet.superclass.constructor.call(this, nj);
+ this.hT = "31";
+
+ this.getFreshValueHex = function () {
+ for (var nO = new Array(), nt = 0; nt < this.asn1Array.length; nt++) {
+ var nX = this.asn1Array[nt];
+ nO.push(nX.getEncodedHex());
+ }
+
+ return nO.sort(), this.hV = nO.join(""), this.hV;
+ };
+ };
+
+ nu.extend(KJUR.asn1.DERSet, KJUR.asn1.DERAbstractStructured);
+
+ KJUR.asn1.DERTaggedObject = function (nj) {
+ KJUR.asn1.DERTaggedObject.superclass.constructor.call(this);
+ this.hT = "a0";
+ this.hV = "";
+ this.isExplicit = !0;
+ this.asn1Object = null;
+
+ this.setASN1Object = function (nO, nt, nX) {
+ this.hT = nt;
+ this.isExplicit = nO;
+ this.asn1Object = nX;
+ this.isExplicit ? (this.hV = this.asn1Object.getEncodedHex(), this.hTLV = null, this.isModified = !0) : (this.hV = null, this.hTLV = nX.getEncodedHex(), this.hTLV = this.hTLV.replace(/^../, nt), this.isModified = !1);
+ };
+
+ this.getFreshValueHex = function () {
+ return this.hV;
+ };
+
+ "undefined" != typeof nj && ("undefined" != typeof nj.tag && (this.hT = nj.tag), "undefined" != typeof nj.explicit && (this.isExplicit = nj.explicit), "undefined" != typeof nj.obj && (this.asn1Object = nj.obj, this.setASN1Object(this.isExplicit, this.hT, this.asn1Object)));
+ };
+
+ nu.extend(KJUR.asn1.DERTaggedObject, KJUR.asn1.ASN1Object);
+
+ (function (nj) {
+ 'use strict';
+
+ var nO;
+ var nt = {};
+
+ nt.decode = function (nX) {
+ var nG;
+
+ if (nO === nj) {
+ var nx = "0123456789ABCDEF";
+ var nN = " \f\n\r\t聽\u2028\u2029";
+
+ for (nO = [], nG = 0; 16 > nG; ++nG) nO[nx.charAt(nG)] = nG;
+
+ for (nx = nx.toLowerCase(), nG = 10; 16 > nG; ++nG) nO[nx.charAt(nG)] = nG;
+
+ for (nG = 0; nG < nN.length; ++nG) nO[nN.charAt(nG)] = -1;
+ }
+
+ var nD = [];
+ var ny = 0;
+ var no = 0;
+
+ for (nG = 0; nG < nX.length; ++nG) {
+ var nv = nX.charAt(nG);
+ if ("=" == nv) break;
+
+ if (nv = nO[nv], -1 != nv) {
+ if (nv === nj) throw "Illegal character at offset " + nG;
+ ny |= nv;
+ ++no >= 2 ? (nD[nD.length] = ny, ny = 0, no = 0) : ny <<= 4;
+ }
+ }
+
+ if (no) throw "Hex encoding incomplete: 4 bits missing";
+ return nD;
+ };
+
+ window.Hex = nt;
+ })();
+
+ (function (nj) {
+ 'use strict';
+
+ var nO;
+ var nt = {};
+
+ nt.decode = function (nX) {
+ var nG;
+
+ if (nO === nj) {
+ var nx = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+ var nN = "= \f\n\r\t聽\u2028\u2029";
+
+ for (nO = [], nG = 0; 64 > nG; ++nG) nO[nx.charAt(nG)] = nG;
+
+ for (nG = 0; nG < nN.length; ++nG) nO[nN.charAt(nG)] = -1;
+ }
+
+ var nD = [];
+ var ny = 0;
+ var no = 0;
+
+ for (nG = 0; nG < nX.length; ++nG) {
+ var nv = nX.charAt(nG);
+ if ("=" == nv) break;
+
+ if (nv = nO[nv], -1 != nv) {
+ if (nv === nj) throw "Illegal character at offset " + nG;
+ ny |= nv;
+ ++no >= 4 ? (nD[nD.length] = ny >> 16, nD[nD.length] = ny >> 8 & 255, nD[nD.length] = 255 & ny, ny = 0, no = 0) : ny <<= 6;
+ }
+ }
+
+ switch (no) {
+ case 1:
+ throw "Base64 encoding incomplete: at least 2 bits missing";
+
+ case 2:
+ nD[nD.length] = ny >> 10;
+ break;
+
+ case 3:
+ nD[nD.length] = ny >> 16;
+ nD[nD.length] = ny >> 8 & 255;
+ }
+
+ return nD;
+ };
+
+ nt.re = /-----BEGIN [^-]+-----([A-Za-z0-9+\/=\s]+)-----END [^-]+-----|begin-base64[^\n]+\n([A-Za-z0-9+\/=\s]+)====/;
+
+ nt.unarmor = function (nX) {
+ var nG = nt.re.exec(nX);
+
+ if (nG) {
+ if (nG[1]) nX = nG[1];else {
+ if (!nG[2]) throw "RegExp out of sync";
+ nX = nG[2];
+ }
+ }
+
+ return nt.decode(nX);
+ };
+
+ window.Base64 = nt;
+ })();
+
+ (function (nj) {
+ 'use strict';
+
+ function nO(nN, nD) {
+ if (nN instanceof nO) {
+ this.enc = nN.enc;
+ this.pos = nN.pos;
+ } else {
+ this.enc = nN;
+ this.pos = nD;
+ }
+ }
+
+ function nt(nN, nD, ny, no, nv) {
+ this.stream = nN;
+ this.header = nD;
+ this.length = ny;
+ this.tag = no;
+ this.sub = nv;
+ }
+
+ var nX = 100;
+ var nG = "鈥�";
+ var nx = {
+ "tag": function (nN, nD) {
+ var ny = document.createElement(nN);
+ return ny.className = nD, ny;
+ },
+ "text": function (nN) {
+ return document.createTextNode(nN);
+ }
+ };
+
+ nO.prototype.get = function (nN) {
+ if (nN === nj && (nN = this.pos++), nN >= this.enc.length) throw "Requesting byte offset " + nN + " on a stream of length " + this.enc.length;
+ return this.enc[nN];
+ };
+
+ nO.prototype.hexDigits = "0123456789ABCDEF";
+
+ nO.prototype.hexByte = function (nN) {
+ return this.hexDigits.charAt(nN >> 4 & 15) + this.hexDigits.charAt(15 & nN);
+ };
+
+ nO.prototype.hexDump = function (nN, nD, ny) {
+ for (var no = "", nv = nN; nD > nv; ++nv) if (no += this.hexByte(this.get(nv)), ny !== !0) switch (15 & nv) {
+ case 7:
+ no += " ";
+ break;
+
+ case 15:
+ no += "\n";
+ break;
+
+ default:
+ no += " ";
+ }
+
+ return no;
+ };
+
+ nO.prototype.parseStringISO = function (nN, nD) {
+ for (var ny = "", no = nN; nD > no; ++no) ny += String.fromCharCode(this.get(no));
+
+ return ny;
+ };
+
+ nO.prototype.parseStringUTF = function (nN, nD) {
+ for (var ny = "", no = nN; nD > no;) {
+ var nv = this.get(no++);
+ ny += String.fromCharCode(128 > nv ? nv : nv > 191 && 224 > nv ? (31 & nv) << 6 | 63 & this.get(no++) : (15 & nv) << 12 | (63 & this.get(no++)) << 6 | 63 & this.get(no++));
+ }
+
+ return ny;
+ };
+
+ nO.prototype.parseStringBMP = function (nN, nD) {
+ for (var ny = "", no = nN; nD > no; no += 2) {
+ var nv = this.get(no);
+ var nm = this.get(no + 1);
+ ny += String.fromCharCode((nv << 8) + nm);
+ }
+
+ return ny;
+ };
+
+ nO.prototype.reTime = /^((?:1[89]|2\d)?\d\d)(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])([01]\d|2[0-3])(?:([0-5]\d)(?:([0-5]\d)(?:[.,](\d{1,3}))?)?)?(Z|[-+](?:[0]\d|1[0-2])([0-5]\d)?)?$/;
+
+ nO.prototype.parseTime = function (nN, nD) {
+ var ny = this.parseStringISO(nN, nD);
+ var no = this.reTime.exec(ny);
+ return no ? (ny = no[1] + "-" + no[2] + "-" + no[3] + " " + no[4], no[5] && (ny += ":" + no[5], no[6] && (ny += ":" + no[6], no[7] && (ny += "." + no[7]))), no[8] && (ny += " UTC", "Z" != no[8] && (ny += no[8], no[9] && (ny += ":" + no[9]))), ny) : "Unrecognized time: " + ny;
+ };
+
+ nO.prototype.parseInteger = function (nN, nD) {
+ var ny = nD - nN;
+
+ if (ny > 4) {
+ ny <<= 3;
+ var no = this.get(nN);
+ if (0 === no) ny -= 8;else {
+ for (; 128 > no;) {
+ no <<= 1;
+ --ny;
+ }
+ }
+ return "(" + ny + " bit)";
+ }
+
+ for (var nv = 0, nm = nN; nD > nm; ++nm) nv = nv << 8 | this.get(nm);
+
+ return nv;
+ };
+
+ nO.prototype.parseBitString = function (nN, nD) {
+ var ny = this.get(nN);
+ var no = (nD - nN - 1 << 3) - ny;
+ var nv = "(" + no + " bit)";
+
+ if (20 >= no) {
+ var nm = ny;
+ nv += " ";
+
+ for (var nd = nD - 1; nd > nN; --nd) {
+ for (var nr = this.get(nd), nQ = nm; 8 > nQ; ++nQ) nv += nr >> nQ & 1 ? "1" : "0";
+
+ nm = 0;
+ }
+ }
+
+ return nv;
+ };
+
+ nO.prototype.parseOctetString = function (nN, nD) {
+ var ny = nD - nN;
+ var no = "(" + ny + " byte) ";
+
+ if (ny > nX) {
+ nD = nN + nX;
+ }
+
+ for (var nv = nN; nD > nv; ++nv) no += this.hexByte(this.get(nv));
+
+ return ny > nX && (no += nG), no;
+ };
+
+ nO.prototype.parseOID = function (nN, nD) {
+ for (var ny = "", no = 0, nv = 0, nm = nN; nD > nm; ++nm) {
+ var nd = this.get(nm);
+
+ if (no = no << 7 | 127 & nd, nv += 7, !(128 & nd)) {
+ if ("" === ny) {
+ if (80 > no) {
+ var nr = 40 > no ? 0 : 1;
+ } else {
+ var nr = 2;
+ }
+
+ ny = nr + "." + (no - 40 * nr);
+ } else ny += "." + (nv >= 31 ? "bigint" : no);
+
+ no = nv = 0;
+ }
+ }
+
+ return ny;
+ };
+
+ nt.prototype.typeName = function () {
+ if (this.tag === nj) return "unknown";
+ var nN = this.tag >> 6;
+ var nD = (this.tag >> 5 & 1, 31 & this.tag);
+
+ switch (nN) {
+ case 0:
+ switch (nD) {
+ case 0:
+ return "EOC";
+
+ case 1:
+ return "BOOLEAN";
+
+ case 2:
+ return "INTEGER";
+
+ case 3:
+ return "BIT_STRING";
+
+ case 4:
+ return "OCTET_STRING";
+
+ case 5:
+ return "NULL";
+
+ case 6:
+ return "OBJECT_IDENTIFIER";
+
+ case 7:
+ return "ObjectDescriptor";
+
+ case 8:
+ return "EXTERNAL";
+
+ case 9:
+ return "REAL";
+
+ case 10:
+ return "ENUMERATED";
+
+ case 11:
+ return "EMBEDDED_PDV";
+
+ case 12:
+ return "UTF8String";
+
+ case 16:
+ return "SEQUENCE";
+
+ case 17:
+ return "SET";
+
+ case 18:
+ return "NumericString";
+
+ case 19:
+ return "PrintableString";
+
+ case 20:
+ return "TeletexString";
+
+ case 21:
+ return "VideotexString";
+
+ case 22:
+ return "IA5String";
+
+ case 23:
+ return "UTCTime";
+
+ case 24:
+ return "GeneralizedTime";
+
+ case 25:
+ return "GraphicString";
+
+ case 26:
+ return "VisibleString";
+
+ case 27:
+ return "GeneralString";
+
+ case 28:
+ return "UniversalString";
+
+ case 30:
+ return "BMPString";
+
+ default:
+ return "Universal_" + nD.toString(16);
+ }
+
+ case 1:
+ return "Application_" + nD.toString(16);
+
+ case 2:
+ return "[" + nD + "]";
+
+ case 3:
+ return "Private_" + nD.toString(16);
+ }
+ };
+
+ nt.prototype.reSeemsASCII = /^[ -~]+$/;
+
+ nt.prototype.content = function () {
+ if (this.tag === nj) return null;
+ var nN = this.tag >> 6;
+ var nD = 31 & this.tag;
+ var ny = this.posContent();
+ var no = Math.abs(this.length);
+
+ if (0 !== nN) {
+ if (null !== this.sub) return "(" + this.sub.length + " elem)";
+ var nv = this.stream.parseStringISO(ny, ny + Math.min(no, nX));
+ return this.reSeemsASCII.test(nv) ? nv.substring(0, 2 * nX) + (nv.length > 2 * nX ? nG : "") : this.stream.parseOctetString(ny, ny + no);
+ }
+
+ switch (nD) {
+ case 1:
+ return 0 === this.stream.get(ny) ? "false" : "true";
+
+ case 2:
+ return this.stream.parseInteger(ny, ny + no);
+
+ case 3:
+ return this.sub ? "(" + this.sub.length + " elem)" : this.stream.parseBitString(ny, ny + no);
+
+ case 4:
+ return this.sub ? "(" + this.sub.length + " elem)" : this.stream.parseOctetString(ny, ny + no);
+
+ case 6:
+ return this.stream.parseOID(ny, ny + no);
+
+ case 16:
+ case 17:
+ return "(" + this.sub.length + " elem)";
+
+ case 12:
+ return this.stream.parseStringUTF(ny, ny + no);
+
+ case 18:
+ case 19:
+ case 20:
+ case 21:
+ case 22:
+ case 26:
+ return this.stream.parseStringISO(ny, ny + no);
+
+ case 30:
+ return this.stream.parseStringBMP(ny, ny + no);
+
+ case 23:
+ case 24:
+ return this.stream.parseTime(ny, ny + no);
+ }
+
+ return null;
+ };
+
+ nt.prototype.toString = function () {
+ return this.typeName() + "@" + this.stream.pos + "[header:" + this.header + ",length:" + this.length + ",sub:" + (null === this.sub ? "null" : this.sub.length) + "]";
+ };
+
+ nt.prototype.print = function (nN) {
+ if (nN === nj && (nN = ""), document.writeln(nN + this), null !== this.sub) {
+ nN += " ";
+
+ for (var nD = 0, ny = this.sub.length; ny > nD; ++nD) this.sub[nD].print(nN);
+ }
+ };
+
+ nt.prototype.toPrettyString = function (nN) {
+ if (nN === nj) {
+ nN = "";
+ }
+
+ var nD = nN + this.typeName() + " @" + this.stream.pos;
+
+ if (this.length >= 0 && (nD += "+"), nD += this.length, 32 & this.tag ? nD += " (constructed)" : 3 != this.tag && 4 != this.tag || null === this.sub || (nD += " (encapsulates)"), nD += "\n", null !== this.sub) {
+ nN += " ";
+
+ for (var ny = 0, no = this.sub.length; no > ny; ++ny) nD += this.sub[ny].toPrettyString(nN);
+ }
+
+ return nD;
+ };
+
+ nt.prototype.toDOM = function () {
+ var nN = nx.tag("div", "node");
+ nN.asn1 = this;
+ var nD = nx.tag("div", "head");
+ var ny = this.typeName().replace(/_/g, " ");
+ nD.innerHTML = ny;
+ var no = this.content();
+
+ if (null !== no) {
+ no = String(no).replace(/", ny += "Length: " + this.header + "+", ny += this.length >= 0 ? this.length : -this.length + " (undefined)", 32 & this.tag ? ny += "
(constructed)" : 3 != this.tag && 4 != this.tag || null === this.sub || (ny += "
(encapsulates)"), null !== no && (ny += "
Value:
" + no + "", "object" == typeof oids && 6 == this.tag)) {
+ var nd = oids[no];
+
+ if (nd) {
+ nd.d && (ny += "
" + nd.d);
+ nd.c && (ny += "
" + nd.c);
+ nd.w && (ny += "
(warning!)");
+ }
+ }
+
+ nm.innerHTML = ny;
+ nN.appendChild(nm);
+ var nr = nx.tag("div", "sub");
+
+ if (null !== this.sub) {
+ for (var nQ = 0, nP = this.sub.length; nP > nQ; ++nQ) nr.appendChild(this.sub[nQ].toDOM());
+ }
+
+ return nN.appendChild(nr), nD.onclick = function () {
+ if ("node collapsed" == nN.className) {
+ nN.className = "node";
+ } else {
+ nN.className = "node collapsed";
+ }
+ }, nN;
+ };
+
+ nt.prototype.posStart = function () {
+ return this.stream.pos;
+ };
+
+ nt.prototype.posContent = function () {
+ return this.stream.pos + this.header;
+ };
+
+ nt.prototype.posEnd = function () {
+ return this.stream.pos + this.header + Math.abs(this.length);
+ };
+
+ nt.prototype.fakeHover = function (nN) {
+ this.node.className += " hover";
+ nN && (this.head.className += " hover");
+ };
+
+ nt.prototype.fakeOut = function (nN) {
+ var nD = / ?hover/;
+ this.node.className = this.node.className.replace(nD, "");
+ nN && (this.head.className = this.head.className.replace(nD, ""));
+ };
+
+ nt.prototype.toHexDOM_sub = function (nN, nD, ny, no, nv) {
+ if (!(no >= nv)) {
+ var nm = nx.tag("span", nD);
+ nm.appendChild(nx.text(ny.hexDump(no, nv)));
+ nN.appendChild(nm);
+ }
+ };
+
+ nt.prototype.toHexDOM = function (nN) {
+ var nD = nx.tag("span", "hex");
+ if (nN === nj && (nN = nD), this.head.hexNode = nD, this.head.onmouseover = function () {
+ this.hexNode.className = "hexCurrent";
+ }, this.head.onmouseout = function () {
+ this.hexNode.className = "hex";
+ }, nD.asn1 = this, nD.onmouseover = function () {
+ var nd = !nN.selected;
+ nd && (nN.selected = this.asn1, this.className = "hexCurrent");
+ this.asn1.fakeHover(nd);
+ }, nD.onmouseout = function () {
+ var nd = nN.selected == this.asn1;
+ this.asn1.fakeOut(nd);
+ nd && (nN.selected = null, this.className = "hex");
+ }, this.toHexDOM_sub(nD, "tag", this.stream, this.posStart(), this.posStart() + 1), this.toHexDOM_sub(nD, this.length >= 0 ? "dlen" : "ulen", this.stream, this.posStart() + 1, this.posContent()), null === this.sub) nD.appendChild(nx.text(this.stream.hexDump(this.posContent(), this.posEnd())));else {
+ if (this.sub.length > 0) {
+ var ny = this.sub[0];
+ var no = this.sub[this.sub.length - 1];
+ this.toHexDOM_sub(nD, "intro", this.stream, this.posContent(), ny.posStart());
+
+ for (var nv = 0, nm = this.sub.length; nm > nv; ++nv) nD.appendChild(this.sub[nv].toHexDOM(nN));
+
+ this.toHexDOM_sub(nD, "outro", this.stream, no.posEnd(), this.posEnd());
+ }
+ }
+ return nD;
+ };
+
+ nt.prototype.toHexString = function () {
+ return this.stream.hexDump(this.posStart(), this.posEnd(), !0);
+ };
+
+ nt.decodeLength = function (nN) {
+ var nD = nN.get();
+ var ny = 127 & nD;
+ if (ny == nD) return ny;
+ if (ny > 3) throw "Length over 24 bits not supported at position " + (nN.pos - 1);
+ if (0 === ny) return -1;
+ nD = 0;
+
+ for (var no = 0; ny > no; ++no) nD = nD << 8 | nN.get();
+
+ return nD;
+ };
+
+ nt.hasContent = function (nN, nD, ny) {
+ if (32 & nN) return !0;
+ if (3 > nN || nN > 4) return !1;
+ var no = new nO(ny);
+
+ if (3 == nN) {
+ no.get();
+ }
+
+ var nv = no.get();
+ if (nv >> 6 & 1) return !1;
+
+ try {
+ var nm = nt.decodeLength(no);
+ return no.pos - ny.pos + nm == nD;
+ } catch (nd) {
+ console.log(nd);
+ return !1;
+ }
+ };
+
+ nt.decode = function (nN) {
+ nN instanceof nO || (nN = new nO(nN, 0));
+ var nD = new nO(nN);
+ var ny = nN.get();
+ var no = nt.decodeLength(nN);
+ var nv = nN.pos - nD.pos;
+ var nm = null;
+
+ if (nt.hasContent(ny, no, nN)) {
+ var nd = nN.pos;
+
+ if (3 == ny && nN.get(), nm = [], no >= 0) {
+ for (var nr = nd + no; nN.pos < nr;) nm[nm.length] = nt.decode(nN);
+
+ if (nN.pos != nr) throw "Content size is not correct for container starting at offset " + nd;
+ } else try {
+ for (;;) {
+ var nQ = nt.decode(nN);
+ if (0 === nQ.tag) break;
+ nm[nm.length] = nQ;
+ }
+
+ no = nd - nN.pos;
+ } catch (nP) {
+ console.log(nP);
+ throw "Exception while decoding undefined length content: " + nP;
+ }
+ } else nN.pos += no;
+
+ return new nt(nD, nv, no, ny, nm);
+ };
+
+ nt.test = function () {
+ for (var nN = [{
+ "value": [39],
+ "expected": 39
+ }, {
+ "value": [129, 201],
+ "expected": 201
+ }, {
+ "value": [131, 254, 220, 186],
+ "expected": 16702650
+ }], nD = 0, ny = nN.length; ny > nD; ++nD) {
+ var no = new nO(nN[nD].value, 0);
+ var nv = nt.decodeLength(no);
+
+ if (nv != nN[nD].expected) {
+ document.write("In test[" + nD + "] expected " + nN[nD].expected + " got " + nv + "\n");
+ }
+ }
+ };
+
+ window.ASN1 = nt;
+ })();
+
+ ASN1.prototype.getHexStringValue = function () {
+ var nj = this.toHexString();
+ var nO = 2 * this.header;
+ var nt = 2 * this.length;
+ return nj.substr(nO, nt);
+ };
+
+ n7.prototype.parseKey = function (nj) {
+ try {
+ var nO = 0;
+ var nt = 0;
+ var nX = /^\s*(?:[0-9A-Fa-f][0-9A-Fa-f]\s*)+$/;
+
+ if (nX.test(nj)) {
+ var nG = Hex.decode(nj);
+ } else {
+ var nG = Base64.unarmor(nj);
+ }
+
+ var nx = ASN1.decode(nG);
+
+ if (3 === nx.sub.length && (nx = nx.sub[2].sub[0]), 9 === nx.sub.length) {
+ nO = nx.sub[1].getHexStringValue();
+ this.n = n3(nO, 16);
+ nt = nx.sub[2].getHexStringValue();
+ this.e = parseInt(nt, 16);
+ var nN = nx.sub[3].getHexStringValue();
+ this.d = n3(nN, 16);
+ var nD = nx.sub[4].getHexStringValue();
+ this.p = n3(nD, 16);
+ var ny = nx.sub[5].getHexStringValue();
+ this.q = n3(ny, 16);
+ var no = nx.sub[6].getHexStringValue();
+ this.dmp1 = n3(no, 16);
+ var nv = nx.sub[7].getHexStringValue();
+ this.dmq1 = n3(nv, 16);
+ var nm = nx.sub[8].getHexStringValue();
+ this.coeff = n3(nm, 16);
+ } else {
+ if (2 !== nx.sub.length) return !1;
+ var nd = nx.sub[1];
+ var nr = nd.sub[0];
+ nO = nr.sub[0].getHexStringValue();
+ this.n = n3(nO, 16);
+ nt = nr.sub[1].getHexStringValue();
+ this.e = parseInt(nt, 16);
+ }
+
+ return !0;
+ } catch (nQ) {
+ console.log(nQ);
+ return !1;
+ }
+ };
+
+ n7.prototype.getPrivateBaseKey = function () {
+ var nj = {
+ "array": [new KJUR.asn1.DERInteger({
+ "int": 0
+ }), new KJUR.asn1.DERInteger({
+ "bigint": this.n
+ }), new KJUR.asn1.DERInteger({
+ "int": this.e
+ }), new KJUR.asn1.DERInteger({
+ "bigint": this.d
+ }), new KJUR.asn1.DERInteger({
+ "bigint": this.p
+ }), new KJUR.asn1.DERInteger({
+ "bigint": this.q
+ }), new KJUR.asn1.DERInteger({
+ "bigint": this.dmp1
+ }), new KJUR.asn1.DERInteger({
+ "bigint": this.dmq1
+ }), new KJUR.asn1.DERInteger({
+ "bigint": this.coeff
+ })]
+ };
+ var nO = new KJUR.asn1.DERSequence(nj);
+ return nO.getEncodedHex();
+ };
+
+ n7.prototype.getPrivateBaseKeyB64 = function () {
+ return nS(this.getPrivateBaseKey());
+ };
+
+ n7.prototype.getPublicBaseKey = function () {
+ var nj = {
+ "array": [new KJUR.asn1.DERObjectIdentifier({
+ "oid": "1.2.840.113549.1.1.1"
+ }), new KJUR.asn1.DERNull()]
+ };
+ var nO = new KJUR.asn1.DERSequence(nj);
+ nj = {
+ "array": [new KJUR.asn1.DERInteger({
+ "bigint": this.n
+ }), new KJUR.asn1.DERInteger({
+ "int": this.e
+ })]
+ };
+ var nt = new KJUR.asn1.DERSequence(nj);
+ nj = {
+ "hex": "00" + nt.getEncodedHex()
+ };
+ var nX = new KJUR.asn1.DERBitString(nj);
+ nj = {
+ "array": [nO, nX]
+ };
+ var nG = new KJUR.asn1.DERSequence(nj);
+ return nG.getEncodedHex();
+ };
+
+ n7.prototype.getPublicBaseKeyB64 = function () {
+ return nS(this.getPublicBaseKey());
+ };
+
+ n7.prototype.wordwrap = function (nj, nO) {
+ if (nO = nO || 64, !nj) return nj;
+ var nt = "(.{1," + nO + "})( +|$\n?)|(.{1," + nO + "})";
+ return nj.match(RegExp(nt, "g")).join("\n");
+ };
+
+ n7.prototype.getPrivateKey = function () {
+ var nj = "-----BEGIN RSA PRIVATE KEY-----\n";
+ return nj += this.wordwrap(this.getPrivateBaseKeyB64()) + "\n", nj += "-----END RSA PRIVATE KEY-----";
+ };
+
+ n7.prototype.getPublicKey = function () {
+ var nj = "-----BEGIN PUBLIC KEY-----\n";
+ return nj += this.wordwrap(this.getPublicBaseKeyB64()) + "\n", nj += "-----END PUBLIC KEY-----";
+ };
+
+ n7.prototype.hasPublicKeyProperty = function (nj) {
+ return nj = nj || {}, nj.hasOwnProperty("n") && nj.hasOwnProperty("e");
+ };
+
+ n7.prototype.hasPrivateKeyProperty = function (nj) {
+ return nj = nj || {}, nj.hasOwnProperty("n") && nj.hasOwnProperty("e") && nj.hasOwnProperty("d") && nj.hasOwnProperty("p") && nj.hasOwnProperty("q") && nj.hasOwnProperty("dmp1") && nj.hasOwnProperty("dmq1") && nj.hasOwnProperty("coeff");
+ };
+
+ n7.prototype.parsePropertiesFrom = function (nj) {
+ this.n = nj.n;
+ this.e = nj.e;
+ nj.hasOwnProperty("d") && (this.d = nj.d, this.p = nj.p, this.q = nj.q, this.dmp1 = nj.dmp1, this.dmq1 = nj.dmq1, this.coeff = nj.coeff);
+ };
+
+ var nh = function (nj) {
+ n7.call(this);
+ nj && ("string" == typeof nj ? this.parseKey(nj) : (this.hasPrivateKeyProperty(nj) || this.hasPublicKeyProperty(nj)) && this.parsePropertiesFrom(nj));
+ };
+
+ nh.prototype = new n7();
+ nh.prototype.constructor = nh;
+
+ var nH = function (nj) {
+ nj = nj || {};
+ this.default_key_size = parseInt(nj.default_key_size) || 1024;
+ this.default_public_exponent = nj.default_public_exponent || "010001";
+ this.log = nj.log || !1;
+ this.key = null;
+ };
+
+ nH.prototype.setKey = function (nj) {
+ this.log && this.key && console.warn("A key was already set, overriding existing.");
+ this.key = new nh(nj);
+ };
+
+ nH.prototype.setPrivateKey = function (nj) {
+ this.setKey(nj);
+ };
+
+ nH.prototype.setPublicKey = function (nj) {
+ this.setKey(nj);
+ };
+
+ nH.prototype.decrypt = function (nj) {
+ try {
+ return this.getKey().decrypt(nf(nj));
+ } catch (nO) {
+ console.log(nO);
+ return !1;
+ }
+ };
+
+ nH.prototype.encrypt = function (nj) {
+ try {
+ return nS(this.getKey().encrypt(nj));
+ } catch (nO) {
+ console.log(nO);
+ return !1;
+ }
+ };
+
+ nH.prototype.getKey = function (nj) {
+ if (!this.key) {
+ if (this.key = new nh(), nj && "[object Function]" === {}.toString.call(nj)) return void this.key.generateAsync(this.default_key_size, this.default_public_exponent, nj);
+ this.key.generate(this.default_key_size, this.default_public_exponent);
+ }
+
+ return this.key;
+ };
+
+ nH.prototype.getPrivateKey = function () {
+ return this.getKey().getPrivateKey();
+ };
+
+ nH.prototype.getPrivateKeyB64 = function () {
+ return this.getKey().getPrivateBaseKeyB64();
+ };
+
+ nH.prototype.getPublicKey = function () {
+ return this.getKey().getPublicKey();
+ };
+
+ nH.prototype.getPublicKeyB64 = function () {
+ return this.getKey().getPublicBaseKeyB64();
+ };
+
+ p.JSEncrypt = nH;
+})(JSEncryptExports);
+
+var JSEncrypt = JSEncryptExports.JSEncrypt;
+if (YAHOO === undefined) var YAHOO = {};
+YAHOO.lang = {
+ "extend": function (p, n, A) {
+ if (!n || !p) throw new Error("YAHOO.lang.extend failed, please check that all dependencies are included.");
+
+ var L = function () {};
+
+ L.prototype = n.prototype;
+ p.prototype = new L();
+ p.prototype.constructor = p;
+ p.superclass = n.prototype;
+
+ if (n.prototype.constructor == Object.prototype.constructor) {
+ n.prototype.constructor = n;
+ }
+
+ if (A) {
+ var S;
+
+ for (S in A) {
+ p.prototype[S] = A[S];
+ }
+
+ var Y = function () {};
+
+ var J = ["toString", "valueOf"];
+
+ try {
+ if (/MSIE/.test(navigator.userAgent)) {
+ Y = function (C, V) {
+ for (S = 0; S < J.length; S = S + 1) {
+ var W = J[S];
+ var R = V[W];
+
+ if (typeof R === "function" && R != Object.prototype[W]) {
+ C[W] = R;
+ }
+ }
+ };
+ }
+ } catch (C) {
+ console.log(C);
+ }
+
+ Y(p.prototype, A);
+ }
+ }
+};
+PVA = "-----BEGIN RSA PRIVATE KEY-----\nMIIEpAIBAAKCAQEAy5R1R2yM5jPPvkO2F47qVqMkYj7o92DF8y1yMkCSxY1WwqG0\ndCdUZTnaoBuAz99wGt55oGLcdalV71nPUiGWs/b6GzVN5v72baz/Q2OxHtkrFKqL\nVX16LW31cW9hAntN84RCbvTeB0MNV+SHmXjIf17OQLCtDKHBZWZ5NKyqFstO+KOd\nu32d2jsw+DT5lOBzDUBk/wUw2KyFJVx7eK6sSXEyWqBk2nxMRDNYixIEN1V1EBSq\nf+OwKK5Mxi04r38+Qog8z03/t/u6CfAOWVmi+MdrD1VHXv/P7bnFlgRcLzKwK1QL\nTSLBE1PrMmNNj0oRjByhMoI9tY5X6mRBqLyDhwIDAQABAoIBAGO++RmGO6D9CNAJ\n4Bm52eKaK5UBiubOIR8NiNLLZb5qinRxg3eX35d7Wb2xzBLNwOFBWSl21trFncfY\n4qY0s+C4ZYHYQ7Om/7nsFeQAYAOj1yJYj01TXf4NTsGGF2t+W8qxZlV0H6dCOLL0\nU2YkUmRp4Le8eQVj6dyTcVaYNPxWQBnb9ZOEIEvEjeoO/DD7CCmt7LDCey9KrTQl\nAvuc2nN6uRV1Wfm0P8conKPJtVdgzMvJujNdpz+bBDqwsqgeCICjs/hSCNO81VH3\nDD7J0mG2OHqowOVqagoDHpBprHOUKxAeTs9I0KEL+hEI4zXCDL69+Xs6azuts733\nzSOmwxkCgYEA25czfPVxxcK685LhaAvwbmzWHqNp07ytRNGf+Aww6OdgWkdgPy0n\n20Gkg0HAqsxGcgZJk6cAkOy5hBLNHpHlGbeWFi+62lVNYUv3hAxumtiPyBMu7avE\nZQCTXND1H1f/2enRDJRxQsR8y/SX1ivmC5U6fx7hbpKxnXyRHnvSlk8CgYEA7VWp\nhLNkn4AEaPPW0TknwKG40At/hjecX2zWAyZVt4ydDSeKgMEOUdmvGGlSCrefAl0n\nPTfM9SdIDcO5OTa2wUayKLIsrb6TDnG6KXXN6z3HR3Q4qKJbG83eaMYDqqziPPV+\nxzRVWShI3EGwkLczASmiYy+sEAT0OkxP59xTKUkCgYBgaGjFkukJfy4fJDxsNtmv\nUX9MYkhjGrIjxbjq6UdL6dGGsVGTSxr1i0NUETkqg5bmFtaUybxY5GWqk6qUok8o\nVE7DnN73Xn4jmnun8OFagHvXxnxTApeuFGueU2tbAIKmxJ3wXPfA7Y0w6kkDUbCl\nIzZUe1VT+3mZgAgijxBsxwKBgQDNytiJ62/V6hBo3P6pPtEcdF6nb0DtpazfBaVw\n572twaywqlermzsKeCIenbx49I1ZZGLQ72C2NpCA9vTWCn5fiyiSpyScp0ImZTDS\nIIckctYoPDug5d7wdgtjeEfXp78osopyuwtCmu7Kpd8vLNt6J5raPI0K+vC22FL1\nLpOhmQKBgQCFeU448fL87N1MjMyusi8wJ5MLcn+kHbLTtpskTpfQM2p3Cnp4oL+7\nBI4AlXlKItV37rJIjZxQgLWhGoTZPplZaW4ooJCFJbazce5ua5fnsFS0oXhDN7uw\njaq+v5t8G6gFS09hEa4kz9O53t/7UGuQqh0Bxb0cJ9iNeAlhagvBDQ==\n-----END RSA PRIVATE KEY-----";
+
+var CryptoJS = CryptoJS || function (p, n) {
+ var A = {};
+ var L = A.lib = {};
+
+ var S = L.Base = function () {
+ function E() {}
+
+ return {
+ "extend": function (s) {
+ E.prototype = this;
+ var I = new E();
+ return s && I.mixIn(s), !I.hasOwnProperty("init") && (I.init = function () {
+ I.$super.init.apply(this, arguments);
+ }), I.init.prototype = I, I.$super = this, I;
+ },
+ "create": function () {
+ var s = this.extend();
+ return s.init.apply(s, arguments), s;
+ },
+ "init": function () {},
+ "mixIn": function (s) {
+ for (var I in s) {
+ if (s.hasOwnProperty(I)) {
+ this[I] = s[I];
+ }
+ }
+
+ if (s.hasOwnProperty("toString")) {
+ this.toString = s.toString;
+ }
+ },
+ "clone": function () {
+ return this.init.prototype.extend(this);
+ }
+ };
+ }();
+
+ var Y = L.WordArray = S.extend({
+ "init": function (E, s) {
+ E = this.words = E || [];
+ s != n ? this.sigBytes = s : this.sigBytes = E.length * 4;
+ },
+ "toString": function (E) {
+ return (E || C).stringify(this);
+ },
+ "concat": function (E) {
+ var I = this.words;
+ var K = E.words;
+ var T = this.sigBytes;
+ var Z = E.sigBytes;
+ this.clamp();
+ if (T % 4) for (var w = 0; w < Z; w++) {
+ var M = K[w >>> 2] >>> 24 - w % 4 * 8 & 255;
+ I[T + w >>> 2] |= M << 24 - (T + w) % 4 * 8;
+ } else for (var w = 0; w < Z; w += 4) {
+ I[T + w >>> 2] = K[w >>> 2];
+ }
+ return this.sigBytes += Z, this;
+ },
+ "clamp": function () {
+ var E = this.words;
+ var s = this.sigBytes;
+ E[s >>> 2] &= 4294967295 << 32 - s % 4 * 8;
+ E.length = p.ceil(s / 4);
+ },
+ "clone": function () {
+ var E = S.clone.call(this);
+ return E.words = this.words.slice(0), E;
+ },
+ "random": function (E) {
+ var s = [];
+
+ for (var I = 0; I < E; I += 4) {
+ s.push(p.random() * 4294967296 | 0);
+ }
+
+ return new Y.init(s, E);
+ }
+ });
+ var J = A.enc = {};
+ var C = J.Hex = {
+ "stringify": function (E) {
+ var I = E.words;
+ var K = E.sigBytes;
+ var T = [];
+
+ for (var Z = 0; Z < K; Z++) {
+ var w = I[Z >>> 2] >>> 24 - Z % 4 * 8 & 255;
+ T.push((w >>> 4).toString(16));
+ T.push((w & 15).toString(16));
+ }
+
+ return T.join("");
+ },
+ "parse": function (E) {
+ var s = E.length;
+ var I = [];
+
+ for (var K = 0; K < s; K += 2) {
+ I[K >>> 3] |= parseInt(E.substr(K, 2), 16) << 24 - K % 8 * 4;
+ }
+
+ return new Y.init(I, s / 2);
+ }
+ };
+ var V = J.Latin1 = {
+ "stringify": function (E) {
+ var I = E.words;
+ var K = E.sigBytes;
+ var T = [];
+
+ for (var Z = 0; Z < K; Z++) {
+ var w = I[Z >>> 2] >>> 24 - Z % 4 * 8 & 255;
+ T.push(String.fromCharCode(w));
+ }
+
+ return T.join("");
+ },
+ "parse": function (E) {
+ var s = E.length;
+ var I = [];
+
+ for (var K = 0; K < s; K++) {
+ I[K >>> 2] |= (E.charCodeAt(K) & 255) << 24 - K % 4 * 8;
+ }
+
+ return new Y.init(I, s);
+ }
+ };
+ var W = J.Utf8 = {
+ "stringify": function (E) {
+ try {
+ return decodeURIComponent(escape(V.stringify(E)));
+ } catch (s) {
+ console.log(s);
+ throw new Error("Malformed UTF-8 data");
+ }
+ },
+ "parse": function (E) {
+ return V.parse(unescape(encodeURIComponent(E)));
+ }
+ };
+ var R = L.BufferedBlockAlgorithm = S.extend({
+ "reset": function () {
+ this._data = new Y.init();
+ this._nDataBytes = 0;
+ },
+ "_append": function (E) {
+ typeof E == "string" && (E = W.parse(E));
+
+ this._data.concat(E);
+
+ this._nDataBytes += E.sigBytes;
+ },
+ "_process": function (E) {
+ var I = this._data;
+ var K = I.words;
+ var T = I.sigBytes;
+ var Z = this.blockSize;
+ var M = Z * 4;
+ var U = T / M;
+
+ if (E) {
+ U = p.ceil(U);
+ } else {
+ U = p.max((U | 0) - this._minBufferSize, 0);
+ }
+
+ var H = U * Z;
+ var O = p.min(H * 4, T);
+
+ if (H) {
+ for (var X = 0; X < H; X += Z) {
+ this._doProcessBlock(K, X);
+ }
+
+ var G = K.splice(0, H);
+ I.sigBytes -= O;
+ }
+
+ return new Y.init(G, O);
+ },
+ "clone": function () {
+ var E = S.clone.call(this);
+ return E._data = this._data.clone(), E;
+ },
+ "_minBufferSize": 0
+ });
+ var B = L.Hasher = R.extend({
+ "cfg": S.extend(),
+ "init": function (E) {
+ this.cfg = this.cfg.extend(E);
+ this.reset();
+ },
+ "reset": function () {
+ R.reset.call(this);
+
+ this._doReset();
+ },
+ "update": function (E) {
+ return this._append(E), this._process(), this;
+ },
+ "finalize": function (E) {
+ if (E) {
+ this._append(E);
+ }
+
+ var s = this._doFinalize();
+
+ return s;
+ },
+ "blockSize": 16,
+ "_createHelper": function (E) {
+ return function (s, I) {
+ return new E.init(I).finalize(s);
+ };
+ },
+ "_createHmacHelper": function (E) {
+ return function (s, I) {
+ return new F.HMAC.init(E, I).finalize(s);
+ };
+ }
+ });
+ var F = A.algo = {};
+ return A;
+}(Math);
+
+(function (p) {
+ var n = CryptoJS;
+ var c = n.lib;
+ var A = c.Base;
+ var L = c.WordArray;
+ var n = n.x64 = {};
+ n.Word = A.extend({
+ "init": function (S, Y) {
+ this.high = S;
+ this.low = Y;
+ }
+ });
+ n.WordArray = A.extend({
+ "init": function (S, Y) {
+ S = this.words = S || [];
+ Y != p ? this.sigBytes = Y : this.sigBytes = 8 * S.length;
+ },
+ "toX32": function () {
+ for (var S = this.words, Y = S.length, J = [], C = 0; C < Y; C++) {
+ var V = S[C];
+ J.push(V.high);
+ J.push(V.low);
+ }
+
+ return L.create(J, this.sigBytes);
+ },
+ "clone": function () {
+ for (var S = A.clone.call(this), Y = S.words = this.words.slice(0), J = Y.length, C = 0; C < J; C++) Y[C] = Y[C].clone();
+
+ return S;
+ }
+ });
+})();
+
+CryptoJS.lib.Cipher || function (c) {
+ var a = CryptoJS;
+ var A = a.lib;
+ var L = A.Base;
+ var S = A.WordArray;
+ var Y = A.BufferedBlockAlgorithm;
+ var J = a.enc.Base64;
+ var b = a.algo.EvpKDF;
+ var C = A.Cipher = Y.extend({
+ "cfg": L.extend(),
+ "createEncryptor": function (I, K) {
+ return this.create(this._ENC_XFORM_MODE, I, K);
+ },
+ "createDecryptor": function (I, K) {
+ return this.create(this._DEC_XFORM_MODE, I, K);
+ },
+ "init": function (I, K, T) {
+ this.cfg = this.cfg.extend(T);
+ this._xformMode = I;
+ this._key = K;
+ this.reset();
+ },
+ "reset": function () {
+ Y.reset.call(this);
+
+ this._doReset();
+ },
+ "process": function (I) {
+ return this._append(I), this._process();
+ },
+ "finalize": function (I) {
+ return I && this._append(I), this._doFinalize();
+ },
+ "keySize": 4,
+ "ivSize": 4,
+ "_ENC_XFORM_MODE": 1,
+ "_DEC_XFORM_MODE": 2,
+ "_createHelper": function (I) {
+ return {
+ "encrypt": function (K, T, i) {
+ return ("string" == typeof T ? E : F).encrypt(I, K, T, i);
+ },
+ "decrypt": function (K, T, i) {
+ return ("string" == typeof T ? E : F).decrypt(I, K, T, i);
+ }
+ };
+ }
+ });
+ A.StreamCipher = C.extend({
+ "_doFinalize": function () {
+ return this._process(!0);
+ },
+ "blockSize": 1
+ });
+ var V = a.mode = {};
+
+ var W = function (I, K, T) {
+ var i = this._iv;
+
+ if (i) {
+ this._iv = c;
+ } else {
+ i = this._prevBlock;
+ }
+
+ for (var Z = 0; Z < T; Z++) I[K + Z] ^= i[Z];
+ };
+
+ var R = (A.BlockCipherMode = L.extend({
+ "createEncryptor": function (I, K) {
+ return this.Encryptor.create(I, K);
+ },
+ "createDecryptor": function (I, K) {
+ return this.Decryptor.create(I, K);
+ },
+ "init": function (I, K) {
+ this._cipher = I;
+ this._iv = K;
+ }
+ })).extend();
+ R.Encryptor = R.extend({
+ "processBlock": function (I, K) {
+ var T = this._cipher;
+ var i = T.blockSize;
+ W.call(this, I, K, i);
+ T.encryptBlock(I, K);
+ this._prevBlock = I.slice(K, K + i);
+ }
+ });
+ R.Decryptor = R.extend({
+ "processBlock": function (I, K) {
+ var T = this._cipher;
+ var i = T.blockSize;
+ var Z = I.slice(K, K + i);
+ T.decryptBlock(I, K);
+ W.call(this, I, K, i);
+ this._prevBlock = Z;
+ }
+ });
+ V = V.CBC = R;
+ R = (a.pad = {}).Pkcs7 = {
+ "pad": function (I, K) {
+ for (var T = 4 * K, T = T - I.sigBytes % T, i = T << 24 | T << 16 | T << 8 | T, Z = [], w = 0; w < T; w += 4) Z.push(i);
+
+ T = S.create(Z, T);
+ I.concat(T);
+ },
+ "unpad": function (I) {
+ I.sigBytes -= I.words[I.sigBytes - 1 >>> 2] & 255;
+ }
+ };
+ A.BlockCipher = C.extend({
+ "cfg": C.cfg.extend({
+ "mode": V,
+ "padding": R
+ }),
+ "reset": function () {
+ C.reset.call(this);
+ var I = this.cfg;
+ var K = I.iv;
+ var I = I.mode;
+ if (this._xformMode == this._ENC_XFORM_MODE) var T = I.createEncryptor;else {
+ T = I.createDecryptor;
+ this._minBufferSize = 1;
+ }
+ this._mode = T.call(I, this, K && K.words);
+ },
+ "_doProcessBlock": function (I, K) {
+ this._mode.processBlock(I, K);
+ },
+ "_doFinalize": function () {
+ var I = this.cfg.padding;
+
+ if (this._xformMode == this._ENC_XFORM_MODE) {
+ I.pad(this._data, this.blockSize);
+
+ var K = this._process(!0);
+ } else {
+ K = this._process(!0);
+ I.unpad(K);
+ }
+
+ return K;
+ },
+ "blockSize": 4
+ });
+ var B = A.CipherParams = L.extend({
+ "init": function (I) {
+ this.mixIn(I);
+ },
+ "toString": function (I) {
+ return (I || this.formatter).stringify(this);
+ }
+ });
+ var V = (a.format = {}).OpenSSL = {
+ "stringify": function (I) {
+ var K = I.ciphertext;
+ return I = I.salt, (I ? S.create([1398893684, 1701076831]).concat(I).concat(K) : K).toString(J);
+ },
+ "parse": function (I) {
+ I = J.parse(I);
+ var K = I.words;
+
+ if (1398893684 == K[0] && 1701076831 == K[1]) {
+ var T = S.create(K.slice(2, 4));
+ K.splice(0, 4);
+ I.sigBytes -= 16;
+ }
+
+ return B.create({
+ "ciphertext": I,
+ "salt": T
+ });
+ }
+ };
+ var F = A.SerializableCipher = L.extend({
+ "cfg": L.extend({
+ "format": V
+ }),
+ "encrypt": function (I, K, T, i) {
+ i = this.cfg.extend(i);
+ var Z = I.createEncryptor(T, i);
+ return K = Z.finalize(K), Z = Z.cfg, B.create({
+ "ciphertext": K,
+ "key": T,
+ "iv": Z.iv,
+ "algorithm": I,
+ "mode": Z.mode,
+ "padding": Z.padding,
+ "blockSize": I.blockSize,
+ "formatter": i.format
+ });
+ },
+ "decrypt": function (I, K, T, i) {
+ return i = this.cfg.extend(i), K = this._parse(K, i.format), I.createDecryptor(T, i).finalize(K.ciphertext);
+ },
+ "_parse": function (I, K) {
+ return "string" == typeof I ? K.parse(I, this) : I;
+ }
+ });
+ var a = (a.kdf = {}).OpenSSL = {
+ "execute": function (I, K, T, i) {
+ return i || (i = S.random(8)), I = b.create({
+ "keySize": K + T
+ }).compute(I, i), T = S.create(I.words.slice(K), 4 * T), I.sigBytes = 4 * K, B.create({
+ "key": I,
+ "iv": T,
+ "salt": i
+ });
+ }
+ };
+ var E = A.PasswordBasedCipher = F.extend({
+ "cfg": F.cfg.extend({
+ "kdf": a
+ }),
+ "encrypt": function (I, K, T, i) {
+ return i = this.cfg.extend(i), T = i.kdf.execute(T, I.keySize, I.ivSize), i.iv = T.iv, I = F.encrypt.call(this, I, K, T.key, i), I.mixIn(T), I;
+ },
+ "decrypt": function (I, K, T, i) {
+ return i = this.cfg.extend(i), K = this._parse(K, i.format), T = i.kdf.execute(T, I.keySize, I.ivSize, K.salt), i.iv = T.iv, F.decrypt.call(this, I, K, T.key, i);
+ }
+ });
+}();
+
+(function () {
+ for (var p = CryptoJS, c = p.lib.BlockCipher, a = p.algo, L = [], S = [], Y = [], J = [], V = [], W = [], R = [], I = [], K = [], T = [], i = [], e = 0; 256 > e; e++) if (128 > e) {
+ i[e] = e << 1;
+ } else {
+ i[e] = e << 1 ^ 283;
+ }
+
+ for (var Z = 0, M = 0, e = 0; 256 > e; e++) {
+ var U = M ^ M << 1 ^ M << 2 ^ M << 3 ^ M << 4;
+ var U = U >>> 8 ^ U & 255 ^ 99;
+ L[Z] = U;
+ S[U] = Z;
+ var h = i[Z];
+ var H = i[h];
+ var O = i[H];
+ var X = 257 * i[U] ^ 16843008 * U;
+ Y[Z] = X << 24 | X >>> 8;
+ J[Z] = X << 16 | X >>> 16;
+ V[Z] = X << 8 | X >>> 24;
+ W[Z] = X;
+ X = 16843009 * O ^ 65537 * H ^ 257 * h ^ 16843008 * Z;
+ R[U] = X << 24 | X >>> 8;
+ I[U] = X << 16 | X >>> 16;
+ K[U] = X << 8 | X >>> 24;
+ T[U] = X;
+ Z ? (Z = h ^ i[i[i[O ^ h]]], M ^= i[i[M]]) : Z = M = 1;
+ }
+
+ var G = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54];
+ var a = a.AES = c.extend({
+ "_doReset": function () {
+ for (var N = this._key, o = N.words, m = N.sigBytes / 4, N = 4 * ((this._nRounds = m + 6) + 1), Q = this._keySchedule = [], P = 0; P < N; P++) if (P < m) Q[P] = o[P];else {
+ var p0 = Q[P - 1];
+ P % m ? 6 < m && 4 == P % m && (p0 = L[p0 >>> 24] << 24 | L[p0 >>> 16 & 255] << 16 | L[p0 >>> 8 & 255] << 8 | L[p0 & 255]) : (p0 = p0 << 8 | p0 >>> 24, p0 = L[p0 >>> 24] << 24 | L[p0 >>> 16 & 255] << 16 | L[p0 >>> 8 & 255] << 8 | L[p0 & 255], p0 ^= G[P / m | 0] << 24);
+ Q[P] = Q[P - m] ^ p0;
+ }
+
+ o = this._invKeySchedule = [];
+
+ for (m = 0; m < N; m++) {
+ P = N - m;
+ m % 4 ? p0 = Q[P] : p0 = Q[P - 4];
+ 4 > m || 4 >= P ? o[m] = p0 : o[m] = R[L[p0 >>> 24]] ^ I[L[p0 >>> 16 & 255]] ^ K[L[p0 >>> 8 & 255]] ^ T[L[p0 & 255]];
+ }
+ },
+ "encryptBlock": function (N, o) {
+ this._doCryptBlock(N, o, this._keySchedule, Y, J, V, W, L);
+ },
+ "decryptBlock": function (N, o) {
+ var m = N[o + 1];
+ N[o + 1] = N[o + 3];
+ N[o + 3] = m;
+
+ this._doCryptBlock(N, o, this._invKeySchedule, R, I, K, T, S);
+
+ m = N[o + 1];
+ N[o + 1] = N[o + 3];
+ N[o + 3] = m;
+ },
+ "_doCryptBlock": function (N, o, Q, P, p0, p1, p2, p3) {
+ for (var p4 = this._nRounds, p5 = N[o] ^ Q[0], p6 = N[o + 1] ^ Q[1], p7 = N[o + 2] ^ Q[2], p8 = N[o + 3] ^ Q[3], p9 = 4, pp = 1; pp < p4; pp++) var pn = P[p5 >>> 24] ^ p0[p6 >>> 16 & 255] ^ p1[p7 >>> 8 & 255] ^ p2[p8 & 255] ^ Q[p9++], pc = P[p6 >>> 24] ^ p0[p7 >>> 16 & 255] ^ p1[p8 >>> 8 & 255] ^ p2[p5 & 255] ^ Q[p9++], pa = P[p7 >>> 24] ^ p0[p8 >>> 16 & 255] ^ p1[p5 >>> 8 & 255] ^ p2[p6 & 255] ^ Q[p9++], p8 = P[p8 >>> 24] ^ p0[p5 >>> 16 & 255] ^ p1[p6 >>> 8 & 255] ^ p2[p7 & 255] ^ Q[p9++], p5 = pn, p6 = pc, p7 = pa;
+
+ pn = (p3[p5 >>> 24] << 24 | p3[p6 >>> 16 & 255] << 16 | p3[p7 >>> 8 & 255] << 8 | p3[p8 & 255]) ^ Q[p9++];
+ pc = (p3[p6 >>> 24] << 24 | p3[p7 >>> 16 & 255] << 16 | p3[p8 >>> 8 & 255] << 8 | p3[p5 & 255]) ^ Q[p9++];
+ pa = (p3[p7 >>> 24] << 24 | p3[p8 >>> 16 & 255] << 16 | p3[p5 >>> 8 & 255] << 8 | p3[p6 & 255]) ^ Q[p9++];
+ p8 = (p3[p8 >>> 24] << 24 | p3[p5 >>> 16 & 255] << 16 | p3[p6 >>> 8 & 255] << 8 | p3[p7 & 255]) ^ Q[p9++];
+ N[o] = pn;
+ N[o + 1] = pc;
+ N[o + 2] = pa;
+ N[o + 3] = p8;
+ },
+ "keySize": 8
+ });
+ p.AES = c._createHelper(a);
+})();
+
+(function () {
+ function c(R, B) {
+ var F = (this._lBlock >>> R ^ this._rBlock) & B;
+ this._rBlock ^= F;
+ this._lBlock ^= F << R;
+ }
+
+ function a(R, B) {
+ var F = (this._rBlock >>> R ^ this._lBlock) & B;
+ this._lBlock ^= F;
+ this._rBlock ^= F << R;
+ }
+
+ var A = CryptoJS;
+ var L = A.lib;
+ var S = L.WordArray;
+ var L = L.BlockCipher;
+ var f = A.algo;
+ var Y = [57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36, 63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4];
+ var J = [14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10, 23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2, 41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48, 44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32];
+ var b = [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28];
+ var C = [{
+ "0": 8421888,
+ 268435456: 32768,
+ 536870912: 8421378,
+ 805306368: 2,
+ 1073741824: 512,
+ 1342177280: 8421890,
+ 1610612736: 8389122,
+ 1879048192: 8388608,
+ 2147483648: 514,
+ 2415919104: 8389120,
+ 2684354560: 33280,
+ 2952790016: 8421376,
+ 3221225472: 32770,
+ 3489660928: 8388610,
+ 3758096384: 0,
+ 4026531840: 33282,
+ 134217728: 0,
+ 402653184: 8421890,
+ 671088640: 33282,
+ 939524096: 32768,
+ 1207959552: 8421888,
+ 1476395008: 512,
+ 1744830464: 8421378,
+ 2013265920: 2,
+ 2281701376: 8389120,
+ 2550136832: 33280,
+ 2818572288: 8421376,
+ 3087007744: 8389122,
+ 3355443200: 8388610,
+ 3623878656: 32770,
+ 3892314112: 514,
+ 4160749568: 8388608,
+ 1: 32768,
+ 268435457: 2,
+ 536870913: 8421888,
+ 805306369: 8388608,
+ 1073741825: 8421378,
+ 1342177281: 33280,
+ 1610612737: 512,
+ 1879048193: 8389122,
+ 2147483649: 8421890,
+ 2415919105: 8421376,
+ 2684354561: 8388610,
+ 2952790017: 33282,
+ 3221225473: 514,
+ 3489660929: 8389120,
+ 3758096385: 32770,
+ 4026531841: 0,
+ 134217729: 8421890,
+ 402653185: 8421376,
+ 671088641: 8388608,
+ 939524097: 512,
+ 1207959553: 32768,
+ 1476395009: 8388610,
+ 1744830465: 2,
+ 2013265921: 33282,
+ 2281701377: 32770,
+ 2550136833: 8389122,
+ 2818572289: 514,
+ 3087007745: 8421888,
+ 3355443201: 8389120,
+ 3623878657: 0,
+ 3892314113: 33280,
+ 4160749569: 8421378
+ }, {
+ "0": 1074282512,
+ 16777216: 16384,
+ 33554432: 524288,
+ 50331648: 1074266128,
+ 67108864: 1073741840,
+ 83886080: 1074282496,
+ 100663296: 1073758208,
+ 117440512: 16,
+ 134217728: 540672,
+ 150994944: 1073758224,
+ 167772160: 1073741824,
+ 184549376: 540688,
+ 201326592: 524304,
+ 218103808: 0,
+ 234881024: 16400,
+ 251658240: 1074266112,
+ 8388608: 1073758208,
+ 25165824: 540688,
+ 41943040: 16,
+ 58720256: 1073758224,
+ 75497472: 1074282512,
+ 92274688: 1073741824,
+ 109051904: 524288,
+ 125829120: 1074266128,
+ 142606336: 524304,
+ 159383552: 0,
+ 176160768: 16384,
+ 192937984: 1074266112,
+ 209715200: 1073741840,
+ 226492416: 540672,
+ 243269632: 1074282496,
+ 260046848: 16400,
+ 268435456: 0,
+ 285212672: 1074266128,
+ 301989888: 1073758224,
+ 318767104: 1074282496,
+ 335544320: 1074266112,
+ 352321536: 16,
+ 369098752: 540688,
+ 385875968: 16384,
+ 402653184: 16400,
+ 419430400: 524288,
+ 436207616: 524304,
+ 452984832: 1073741840,
+ 469762048: 540672,
+ 486539264: 1073758208,
+ 503316480: 1073741824,
+ 520093696: 1074282512,
+ 276824064: 540688,
+ 293601280: 524288,
+ 310378496: 1074266112,
+ 327155712: 16384,
+ 343932928: 1073758208,
+ 360710144: 1074282512,
+ 377487360: 16,
+ 394264576: 1073741824,
+ 411041792: 1074282496,
+ 427819008: 1073741840,
+ 444596224: 1073758224,
+ 461373440: 524304,
+ 478150656: 0,
+ 494927872: 16400,
+ 511705088: 1074266128,
+ 528482304: 540672
+ }, {
+ "0": 260,
+ 1048576: 0,
+ 2097152: 67109120,
+ 3145728: 65796,
+ 4194304: 65540,
+ 5242880: 67108868,
+ 6291456: 67174660,
+ 7340032: 67174400,
+ 8388608: 67108864,
+ 9437184: 67174656,
+ 10485760: 65792,
+ 11534336: 67174404,
+ 12582912: 67109124,
+ 13631488: 65536,
+ 14680064: 4,
+ 15728640: 256,
+ 524288: 67174656,
+ 1572864: 67174404,
+ 2621440: 0,
+ 3670016: 67109120,
+ 4718592: 67108868,
+ 5767168: 65536,
+ 6815744: 65540,
+ 7864320: 260,
+ 8912896: 4,
+ 9961472: 256,
+ 11010048: 67174400,
+ 12058624: 65796,
+ 13107200: 65792,
+ 14155776: 67109124,
+ 15204352: 67174660,
+ 16252928: 67108864,
+ 16777216: 67174656,
+ 17825792: 65540,
+ 18874368: 65536,
+ 19922944: 67109120,
+ 20971520: 256,
+ 22020096: 67174660,
+ 23068672: 67108868,
+ 24117248: 0,
+ 25165824: 67109124,
+ 26214400: 67108864,
+ 27262976: 4,
+ 28311552: 65792,
+ 29360128: 67174400,
+ 30408704: 260,
+ 31457280: 65796,
+ 32505856: 67174404,
+ 17301504: 67108864,
+ 18350080: 260,
+ 19398656: 67174656,
+ 20447232: 0,
+ 21495808: 65540,
+ 22544384: 67109120,
+ 23592960: 256,
+ 24641536: 67174404,
+ 25690112: 65536,
+ 26738688: 67174660,
+ 27787264: 65796,
+ 28835840: 67108868,
+ 29884416: 67109124,
+ 30932992: 67174400,
+ 31981568: 4,
+ 33030144: 65792
+ }, {
+ "0": 2151682048,
+ 65536: 2147487808,
+ 131072: 4198464,
+ 196608: 2151677952,
+ 262144: 0,
+ 327680: 4198400,
+ 393216: 2147483712,
+ 458752: 4194368,
+ 524288: 2147483648,
+ 589824: 4194304,
+ 655360: 64,
+ 720896: 2147487744,
+ 786432: 2151678016,
+ 851968: 4160,
+ 917504: 4096,
+ 983040: 2151682112,
+ 32768: 2147487808,
+ 98304: 64,
+ 163840: 2151678016,
+ 229376: 2147487744,
+ 294912: 4198400,
+ 360448: 2151682112,
+ 425984: 0,
+ 491520: 2151677952,
+ 557056: 4096,
+ 622592: 2151682048,
+ 688128: 4194304,
+ 753664: 4160,
+ 819200: 2147483648,
+ 884736: 4194368,
+ 950272: 4198464,
+ 1015808: 2147483712,
+ 1048576: 4194368,
+ 1114112: 4198400,
+ 1179648: 2147483712,
+ 1245184: 0,
+ 1310720: 4160,
+ 1376256: 2151678016,
+ 1441792: 2151682048,
+ 1507328: 2147487808,
+ 1572864: 2151682112,
+ 1638400: 2147483648,
+ 1703936: 2151677952,
+ 1769472: 4198464,
+ 1835008: 2147487744,
+ 1900544: 4194304,
+ 1966080: 64,
+ 2031616: 4096,
+ 1081344: 2151677952,
+ 1146880: 2151682112,
+ 1212416: 0,
+ 1277952: 4198400,
+ 1343488: 4194368,
+ 1409024: 2147483648,
+ 1474560: 2147487808,
+ 1540096: 64,
+ 1605632: 2147483712,
+ 1671168: 4096,
+ 1736704: 2147487744,
+ 1802240: 2151678016,
+ 1867776: 4160,
+ 1933312: 2151682048,
+ 1998848: 4194304,
+ 2064384: 4198464
+ }, {
+ "0": 128,
+ 4096: 17039360,
+ 8192: 262144,
+ 12288: 536870912,
+ 16384: 537133184,
+ 20480: 16777344,
+ 24576: 553648256,
+ 28672: 262272,
+ 32768: 16777216,
+ 36864: 537133056,
+ 40960: 536871040,
+ 45056: 553910400,
+ 49152: 553910272,
+ 53248: 0,
+ 57344: 17039488,
+ 61440: 553648128,
+ 2048: 17039488,
+ 6144: 553648256,
+ 10240: 128,
+ 14336: 17039360,
+ 18432: 262144,
+ 22528: 537133184,
+ 26624: 553910272,
+ 30720: 536870912,
+ 34816: 537133056,
+ 38912: 0,
+ 43008: 553910400,
+ 47104: 16777344,
+ 51200: 536871040,
+ 55296: 553648128,
+ 59392: 16777216,
+ 63488: 262272,
+ 65536: 262144,
+ 69632: 128,
+ 73728: 536870912,
+ 77824: 553648256,
+ 81920: 16777344,
+ 86016: 553910272,
+ 90112: 537133184,
+ 94208: 16777216,
+ 98304: 553910400,
+ 102400: 553648128,
+ 106496: 17039360,
+ 110592: 537133056,
+ 114688: 262272,
+ 118784: 536871040,
+ 122880: 0,
+ 126976: 17039488,
+ 67584: 553648256,
+ 71680: 16777216,
+ 75776: 17039360,
+ 79872: 537133184,
+ 83968: 536870912,
+ 88064: 17039488,
+ 92160: 128,
+ 96256: 553910272,
+ 100352: 262272,
+ 104448: 553910400,
+ 108544: 0,
+ 112640: 553648128,
+ 116736: 16777344,
+ 120832: 262144,
+ 124928: 537133056,
+ 129024: 536871040
+ }, {
+ "0": 268435464,
+ 256: 8192,
+ 512: 270532608,
+ 768: 270540808,
+ 1024: 268443648,
+ 1280: 2097152,
+ 1536: 2097160,
+ 1792: 268435456,
+ 2048: 0,
+ 2304: 268443656,
+ 2560: 2105344,
+ 2816: 8,
+ 3072: 270532616,
+ 3328: 2105352,
+ 3584: 8200,
+ 3840: 270540800,
+ 128: 270532608,
+ 384: 270540808,
+ 640: 8,
+ 896: 2097152,
+ 1152: 2105352,
+ 1408: 268435464,
+ 1664: 268443648,
+ 1920: 8200,
+ 2176: 2097160,
+ 2432: 8192,
+ 2688: 268443656,
+ 2944: 270532616,
+ 3200: 0,
+ 3456: 270540800,
+ 3712: 2105344,
+ 3968: 268435456,
+ 4096: 268443648,
+ 4352: 270532616,
+ 4608: 270540808,
+ 4864: 8200,
+ 5120: 2097152,
+ 5376: 268435456,
+ 5632: 268435464,
+ 5888: 2105344,
+ 6144: 2105352,
+ 6400: 0,
+ 6656: 8,
+ 6912: 270532608,
+ 7168: 8192,
+ 7424: 268443656,
+ 7680: 270540800,
+ 7936: 2097160,
+ 4224: 8,
+ 4480: 2105344,
+ 4736: 2097152,
+ 4992: 268435464,
+ 5248: 268443648,
+ 5504: 8200,
+ 5760: 270540808,
+ 6016: 270532608,
+ 6272: 270540800,
+ 6528: 270532616,
+ 6784: 8192,
+ 7040: 2105352,
+ 7296: 2097160,
+ 7552: 0,
+ 7808: 268435456,
+ 8064: 268443656
+ }, {
+ "0": 1048576,
+ 16: 33555457,
+ 32: 1024,
+ 48: 1049601,
+ 64: 34604033,
+ 80: 0,
+ 96: 1,
+ 112: 34603009,
+ 128: 33555456,
+ 144: 1048577,
+ 160: 33554433,
+ 176: 34604032,
+ 192: 34603008,
+ 208: 1025,
+ 224: 1049600,
+ 240: 33554432,
+ 8: 34603009,
+ 24: 0,
+ 40: 33555457,
+ 56: 34604032,
+ 72: 1048576,
+ 88: 33554433,
+ 104: 33554432,
+ 120: 1025,
+ 136: 1049601,
+ 152: 33555456,
+ 168: 34603008,
+ 184: 1048577,
+ 200: 1024,
+ 216: 34604033,
+ 232: 1,
+ 248: 1049600,
+ 256: 33554432,
+ 272: 1048576,
+ 288: 33555457,
+ 304: 34603009,
+ 320: 1048577,
+ 336: 33555456,
+ 352: 34604032,
+ 368: 1049601,
+ 384: 1025,
+ 400: 34604033,
+ 416: 1049600,
+ 432: 1,
+ 448: 0,
+ 464: 34603008,
+ 480: 33554433,
+ 496: 1024,
+ 264: 1049600,
+ 280: 33555457,
+ 296: 34603009,
+ 312: 1,
+ 328: 33554432,
+ 344: 1048576,
+ 360: 1025,
+ 376: 34604032,
+ 392: 33554433,
+ 408: 34603008,
+ 424: 0,
+ 440: 34604033,
+ 456: 1049601,
+ 472: 1024,
+ 488: 33555456,
+ 504: 1048577
+ }, {
+ "0": 134219808,
+ 1: 131072,
+ 2: 134217728,
+ 3: 32,
+ 4: 131104,
+ 5: 134350880,
+ 6: 134350848,
+ 7: 2048,
+ 8: 134348800,
+ 9: 134219776,
+ 10: 133120,
+ 11: 134348832,
+ 12: 2080,
+ 13: 0,
+ 14: 134217760,
+ 15: 133152,
+ 2147483648: 2048,
+ 2147483649: 134350880,
+ 2147483650: 134219808,
+ 2147483651: 134217728,
+ 2147483652: 134348800,
+ 2147483653: 133120,
+ 2147483654: 133152,
+ 2147483655: 32,
+ 2147483656: 134217760,
+ 2147483657: 2080,
+ 2147483658: 131104,
+ 2147483659: 134350848,
+ 2147483660: 0,
+ 2147483661: 134348832,
+ 2147483662: 134219776,
+ 2147483663: 131072,
+ 16: 133152,
+ 17: 134350848,
+ 18: 32,
+ 19: 2048,
+ 20: 134219776,
+ 21: 134217760,
+ 22: 134348832,
+ 23: 131072,
+ 24: 0,
+ 25: 131104,
+ 26: 134348800,
+ 27: 134219808,
+ 28: 134350880,
+ 29: 133120,
+ 30: 2080,
+ 31: 134217728,
+ 2147483664: 131072,
+ 2147483665: 2048,
+ 2147483666: 134348832,
+ 2147483667: 133152,
+ 2147483668: 32,
+ 2147483669: 134348800,
+ 2147483670: 134217728,
+ 2147483671: 134219808,
+ 2147483672: 134350880,
+ 2147483673: 134217760,
+ 2147483674: 134219776,
+ 2147483675: 0,
+ 2147483676: 133120,
+ 2147483677: 2080,
+ 2147483678: 131104,
+ 2147483679: 134350848
+ }];
+ var V = [4160749569, 528482304, 33030144, 2064384, 129024, 8064, 504, 2147483679];
+ var W = f.DES = L.extend({
+ "_doReset": function () {
+ for (var R = this._key.words, B = [], F = 0; 56 > F; F++) {
+ var E = Y[F] - 1;
+ B[F] = R[E >>> 5] >>> 31 - E % 32 & 1;
+ }
+
+ R = this._subKeys = [];
+
+ for (E = 0; 16 > E; E++) {
+ for (var I = R[E] = [], K = b[E], F = 0; 24 > F; F++) {
+ I[F / 6 | 0] |= B[(J[F] - 1 + K) % 28] << 31 - F % 6;
+ I[4 + (F / 6 | 0)] |= B[28 + (J[F + 24] - 1 + K) % 28] << 31 - F % 6;
+ }
+
+ I[0] = I[0] << 1 | I[0] >>> 31;
+
+ for (F = 1; 7 > F; F++) I[F] >>>= 4 * (F - 1) + 3;
+
+ I[7] = I[7] << 5 | I[7] >>> 27;
+ }
+
+ B = this._invSubKeys = [];
+
+ for (F = 0; 16 > F; F++) B[F] = R[15 - F];
+ },
+ "encryptBlock": function (R, B) {
+ this._doCryptBlock(R, B, this._subKeys);
+ },
+ "decryptBlock": function (R, B) {
+ this._doCryptBlock(R, B, this._invSubKeys);
+ },
+ "_doCryptBlock": function (R, B, F) {
+ this._lBlock = R[B];
+ this._rBlock = R[B + 1];
+ c.call(this, 4, 252645135);
+ c.call(this, 16, 65535);
+ a.call(this, 2, 858993459);
+ a.call(this, 8, 16711935);
+ c.call(this, 1, 1431655765);
+
+ for (var E = 0; 16 > E; E++) {
+ for (var I = F[E], K = this._lBlock, T = this._rBlock, i = 0, Z = 0; 8 > Z; Z++) i |= C[Z][((T ^ I[Z]) & V[Z]) >>> 0];
+
+ this._lBlock = T;
+ this._rBlock = K ^ i;
+ }
+
+ F = this._lBlock;
+ this._lBlock = this._rBlock;
+ this._rBlock = F;
+ c.call(this, 1, 1431655765);
+ a.call(this, 8, 16711935);
+ a.call(this, 2, 858993459);
+ c.call(this, 16, 65535);
+ c.call(this, 4, 252645135);
+ R[B] = this._lBlock;
+ R[B + 1] = this._rBlock;
+ },
+ "keySize": 2,
+ "ivSize": 2,
+ "blockSize": 2
+ });
+ A.DES = L._createHelper(W);
+ f = f.TripleDES = L.extend({
+ "_doReset": function () {
+ var R = this._key.words;
+ this._des1 = W.createEncryptor(S.create(R.slice(0, 2)));
+ this._des2 = W.createEncryptor(S.create(R.slice(2, 4)));
+ this._des3 = W.createEncryptor(S.create(R.slice(4, 6)));
+ },
+ "encryptBlock": function (R, B) {
+ this._des1.encryptBlock(R, B);
+
+ this._des2.decryptBlock(R, B);
+
+ this._des3.encryptBlock(R, B);
+ },
+ "decryptBlock": function (R, B) {
+ this._des3.decryptBlock(R, B);
+
+ this._des2.encryptBlock(R, B);
+
+ this._des1.decryptBlock(R, B);
+ },
+ "keySize": 6,
+ "ivSize": 2,
+ "blockSize": 2
+ });
+ A.TripleDES = L._createHelper(f);
+})();
+
+(function () {
+ var p = CryptoJS;
+ var n = p.lib.WordArray;
+ p.enc.Base64 = {
+ "stringify": function (A) {
+ var L = A.words;
+ var S = A.sigBytes;
+ var Y = this._map;
+ A.clamp();
+ A = [];
+
+ for (var J = 0; J < S; J += 3) for (var C = (L[J >>> 2] >>> 24 - 8 * (J % 4) & 255) << 16 | (L[J + 1 >>> 2] >>> 24 - 8 * ((J + 1) % 4) & 255) << 8 | L[J + 2 >>> 2] >>> 24 - 8 * ((J + 2) % 4) & 255, V = 0; 4 > V && J + 0.75 * V < S; V++) A.push(Y.charAt(C >>> 6 * (3 - V) & 63));
+
+ if (L = Y.charAt(64)) {
+ for (; A.length % 4;) A.push(L);
+ }
+
+ return A.join("");
+ },
+ "parse": function (A) {
+ var L = A.length;
+ var S = this._map;
+ var Y = S.charAt(64);
+
+ if (Y) {
+ Y = A.indexOf(Y);
+ -1 != Y && (L = Y);
+ }
+
+ for (var Y = [], J = 0, C = 0; C < L; C++) if (C % 4) {
+ var V = S.indexOf(A.charAt(C - 1)) << 2 * (C % 4);
+ var W = S.indexOf(A.charAt(C)) >>> 6 - 2 * (C % 4);
+ Y[J >>> 2] |= (V | W) << 24 - 8 * (J % 4);
+ J++;
+ }
+
+ return n.create(Y, J);
+ },
+ "_map": "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
+ };
+})();
+
+(function (p) {
+ function c(V, W, R, B, I, K, T) {
+ return V = V + (W & R | ~W & B) + I + T, (V << K | V >>> 32 - K) + W;
+ }
+
+ function A(V, W, R, B, I, K, T) {
+ return V = V + (W & B | R & ~B) + I + T, (V << K | V >>> 32 - K) + W;
+ }
+
+ function L(V, W, R, B, I, K, T) {
+ return V = V + (W ^ R ^ B) + I + T, (V << K | V >>> 32 - K) + W;
+ }
+
+ function g(V, W, R, B, I, K, T) {
+ return V = V + (R ^ (W | ~B)) + I + T, (V << K | V >>> 32 - K) + W;
+ }
+
+ for (var S = CryptoJS, f = S.lib, Y = f.WordArray, J = f.Hasher, f = S.algo, b = [], C = 0; 64 > C; C++) b[C] = 4294967296 * p.abs(p.sin(C + 1)) | 0;
+
+ f = f.MD5 = J.extend({
+ "_doReset": function () {
+ this._hash = new Y.init([1732584193, 4023233417, 2562383102, 271733878]);
+ },
+ "_doProcessBlock": function (V, W) {
+ for (var R = 0; 16 > R; R++) {
+ var I = W + R;
+ var K = V[I];
+ V[I] = (K << 8 | K >>> 24) & 16711935 | (K << 24 | K >>> 8) & 4278255360;
+ }
+
+ var R = this._hash.words;
+ var I = V[W + 0];
+ var K = V[W + 1];
+ var T = V[W + 2];
+ var i = V[W + 3];
+ var Z = V[W + 4];
+ var M = V[W + 5];
+ var U = V[W + 6];
+ var H = V[W + 7];
+ var O = V[W + 8];
+ var X = V[W + 9];
+ var G = V[W + 10];
+ var N = V[W + 11];
+ var o = V[W + 12];
+ var Q = V[W + 13];
+ var P = V[W + 14];
+ var p0 = V[W + 15];
+ var p1 = R[0];
+ var p2 = R[1];
+ var p3 = R[2];
+ var p4 = R[3];
+ var p1 = c(p1, p2, p3, p4, I, 7, b[0]);
+ var p4 = c(p4, p1, p2, p3, K, 12, b[1]);
+ var p3 = c(p3, p4, p1, p2, T, 17, b[2]);
+ var p2 = c(p2, p3, p4, p1, i, 22, b[3]);
+ var p1 = c(p1, p2, p3, p4, Z, 7, b[4]);
+ var p4 = c(p4, p1, p2, p3, M, 12, b[5]);
+ var p3 = c(p3, p4, p1, p2, U, 17, b[6]);
+ var p2 = c(p2, p3, p4, p1, H, 22, b[7]);
+ var p1 = c(p1, p2, p3, p4, O, 7, b[8]);
+ var p4 = c(p4, p1, p2, p3, X, 12, b[9]);
+ var p3 = c(p3, p4, p1, p2, G, 17, b[10]);
+ var p2 = c(p2, p3, p4, p1, N, 22, b[11]);
+ var p1 = c(p1, p2, p3, p4, o, 7, b[12]);
+ var p4 = c(p4, p1, p2, p3, Q, 12, b[13]);
+ var p3 = c(p3, p4, p1, p2, P, 17, b[14]);
+ var p2 = c(p2, p3, p4, p1, p0, 22, b[15]);
+ var p1 = A(p1, p2, p3, p4, K, 5, b[16]);
+ var p4 = A(p4, p1, p2, p3, U, 9, b[17]);
+ var p3 = A(p3, p4, p1, p2, N, 14, b[18]);
+ var p2 = A(p2, p3, p4, p1, I, 20, b[19]);
+ var p1 = A(p1, p2, p3, p4, M, 5, b[20]);
+ var p4 = A(p4, p1, p2, p3, G, 9, b[21]);
+ var p3 = A(p3, p4, p1, p2, p0, 14, b[22]);
+ var p2 = A(p2, p3, p4, p1, Z, 20, b[23]);
+ var p1 = A(p1, p2, p3, p4, X, 5, b[24]);
+ var p4 = A(p4, p1, p2, p3, P, 9, b[25]);
+ var p3 = A(p3, p4, p1, p2, i, 14, b[26]);
+ var p2 = A(p2, p3, p4, p1, O, 20, b[27]);
+ var p1 = A(p1, p2, p3, p4, Q, 5, b[28]);
+ var p4 = A(p4, p1, p2, p3, T, 9, b[29]);
+ var p3 = A(p3, p4, p1, p2, H, 14, b[30]);
+ var p2 = A(p2, p3, p4, p1, o, 20, b[31]);
+ var p1 = L(p1, p2, p3, p4, M, 4, b[32]);
+ var p4 = L(p4, p1, p2, p3, O, 11, b[33]);
+ var p3 = L(p3, p4, p1, p2, N, 16, b[34]);
+ var p2 = L(p2, p3, p4, p1, P, 23, b[35]);
+ var p1 = L(p1, p2, p3, p4, K, 4, b[36]);
+ var p4 = L(p4, p1, p2, p3, Z, 11, b[37]);
+ var p3 = L(p3, p4, p1, p2, H, 16, b[38]);
+ var p2 = L(p2, p3, p4, p1, G, 23, b[39]);
+ var p1 = L(p1, p2, p3, p4, Q, 4, b[40]);
+ var p4 = L(p4, p1, p2, p3, I, 11, b[41]);
+ var p3 = L(p3, p4, p1, p2, i, 16, b[42]);
+ var p2 = L(p2, p3, p4, p1, U, 23, b[43]);
+ var p1 = L(p1, p2, p3, p4, X, 4, b[44]);
+ var p4 = L(p4, p1, p2, p3, o, 11, b[45]);
+ var p3 = L(p3, p4, p1, p2, p0, 16, b[46]);
+ var p2 = L(p2, p3, p4, p1, T, 23, b[47]);
+ var p1 = g(p1, p2, p3, p4, I, 6, b[48]);
+ var p4 = g(p4, p1, p2, p3, H, 10, b[49]);
+ var p3 = g(p3, p4, p1, p2, P, 15, b[50]);
+ var p2 = g(p2, p3, p4, p1, M, 21, b[51]);
+ var p1 = g(p1, p2, p3, p4, o, 6, b[52]);
+ var p4 = g(p4, p1, p2, p3, i, 10, b[53]);
+ var p3 = g(p3, p4, p1, p2, G, 15, b[54]);
+ var p2 = g(p2, p3, p4, p1, K, 21, b[55]);
+ var p1 = g(p1, p2, p3, p4, O, 6, b[56]);
+ var p4 = g(p4, p1, p2, p3, p0, 10, b[57]);
+ var p3 = g(p3, p4, p1, p2, U, 15, b[58]);
+ var p2 = g(p2, p3, p4, p1, Q, 21, b[59]);
+ var p1 = g(p1, p2, p3, p4, Z, 6, b[60]);
+ var p4 = g(p4, p1, p2, p3, N, 10, b[61]);
+ var p3 = g(p3, p4, p1, p2, T, 15, b[62]);
+ var p2 = g(p2, p3, p4, p1, X, 21, b[63]);
+ R[0] = R[0] + p1 | 0;
+ R[1] = R[1] + p2 | 0;
+ R[2] = R[2] + p3 | 0;
+ R[3] = R[3] + p4 | 0;
+ },
+ "_doFinalize": function () {
+ var V = this._data;
+ var W = V.words;
+ var R = 8 * this._nDataBytes;
+ var B = 8 * V.sigBytes;
+ W[B >>> 5] |= 128 << 24 - B % 32;
+ var I = p.floor(R / 4294967296);
+ W[(B + 64 >>> 9 << 4) + 15] = (I << 8 | I >>> 24) & 16711935 | (I << 24 | I >>> 8) & 4278255360;
+ W[(B + 64 >>> 9 << 4) + 14] = (R << 8 | R >>> 24) & 16711935 | (R << 24 | R >>> 8) & 4278255360;
+ V.sigBytes = 4 * (W.length + 1);
+
+ this._process();
+
+ V = this._hash;
+ W = V.words;
+
+ for (R = 0; 4 > R; R++) {
+ B = W[R];
+ W[R] = (B << 8 | B >>> 24) & 16711935 | (B << 24 | B >>> 8) & 4278255360;
+ }
+
+ return V;
+ },
+ "clone": function () {
+ var V = J.clone.call(this);
+ return V._hash = this._hash.clone(), V;
+ }
+ });
+ S.MD5 = J._createHelper(f);
+ S.HmacMD5 = J._createHmacHelper(f);
+})(Math);
+
+(function () {
+ var p = CryptoJS;
+ var n = p.lib;
+ var c = n.WordArray;
+ var a = n.Hasher;
+ var A = [];
+ var n = p.algo.SHA1 = a.extend({
+ "_doReset": function () {
+ this._hash = new c.init([1732584193, 4023233417, 2562383102, 271733878, 3285377520]);
+ },
+ "_doProcessBlock": function (L, S) {
+ for (var Y = this._hash.words, J = Y[0], C = Y[1], V = Y[2], W = Y[3], R = Y[4], B = 0; 80 > B; B++) {
+ if (16 > B) A[B] = L[S + B] | 0;else {
+ var F = A[B - 3] ^ A[B - 8] ^ A[B - 14] ^ A[B - 16];
+ A[B] = F << 1 | F >>> 31;
+ }
+ F = (J << 5 | J >>> 27) + R + A[B];
+ 20 > B ? F = F + ((C & V | ~C & W) + 1518500249) : 40 > B ? F = F + ((C ^ V ^ W) + 1859775393) : 60 > B ? F = F + ((C & V | C & W | V & W) - 1894007588) : F = F + ((C ^ V ^ W) - 899497514);
+ R = W;
+ W = V;
+ V = C << 30 | C >>> 2;
+ C = J;
+ J = F;
+ }
+
+ Y[0] = Y[0] + J | 0;
+ Y[1] = Y[1] + C | 0;
+ Y[2] = Y[2] + V | 0;
+ Y[3] = Y[3] + W | 0;
+ Y[4] = Y[4] + R | 0;
+ },
+ "_doFinalize": function () {
+ var L = this._data;
+ var g = L.words;
+ var S = 8 * this._nDataBytes;
+ var f = 8 * L.sigBytes;
+ return g[f >>> 5] |= 128 << 24 - f % 32, g[(f + 64 >>> 9 << 4) + 14] = Math.floor(S / 4294967296), g[(f + 64 >>> 9 << 4) + 15] = S, L.sigBytes = 4 * g.length, this._process(), this._hash;
+ },
+ "clone": function () {
+ var L = a.clone.call(this);
+ return L._hash = this._hash.clone(), L;
+ }
+ });
+ p.SHA1 = a._createHelper(n);
+ p.HmacSHA1 = a._createHmacHelper(n);
+})();
+
+(function (p) {
+ for (var c = CryptoJS, a = c.lib, A = a.WordArray, L = a.Hasher, a = c.algo, S = [], f = [], Y = function (F) {
+ return 4294967296 * (F - (F | 0)) | 0;
+ }, J = 2, C = 0; 64 > C;) {
+ var V;
+
+ F: {
+ V = J;
+
+ for (var W = p.sqrt(V), R = 2; R <= W; R++) if (!(V % R)) {
+ V = !1;
+ break F;
+ }
+
+ V = !0;
+ }
+
+ V && (8 > C && (S[C] = Y(p.pow(J, 0.5))), f[C] = Y(p.pow(J, 0.3333333333333333)), C++);
+ J++;
+ }
+
+ var B = [];
+ var a = a.SHA256 = L.extend({
+ "_doReset": function () {
+ this._hash = new A.init(S.slice(0));
+ },
+ "_doProcessBlock": function (F, E) {
+ for (var I = this._hash.words, K = I[0], T = I[1], i = I[2], Z = I[3], M = I[4], U = I[5], H = I[6], O = I[7], X = 0; 64 > X; X++) {
+ if (16 > X) B[X] = F[E + X] | 0;else {
+ var G = B[X - 15];
+ var x = B[X - 2];
+ B[X] = ((G << 25 | G >>> 7) ^ (G << 14 | G >>> 18) ^ G >>> 3) + B[X - 7] + ((x << 15 | x >>> 17) ^ (x << 13 | x >>> 19) ^ x >>> 10) + B[X - 16];
+ }
+ G = O + ((M << 26 | M >>> 6) ^ (M << 21 | M >>> 11) ^ (M << 7 | M >>> 25)) + (M & U ^ ~M & H) + f[X] + B[X];
+ x = ((K << 30 | K >>> 2) ^ (K << 19 | K >>> 13) ^ (K << 10 | K >>> 22)) + (K & T ^ K & i ^ T & i);
+ O = H;
+ H = U;
+ U = M;
+ M = Z + G | 0;
+ Z = i;
+ i = T;
+ T = K;
+ K = G + x | 0;
+ }
+
+ I[0] = I[0] + K | 0;
+ I[1] = I[1] + T | 0;
+ I[2] = I[2] + i | 0;
+ I[3] = I[3] + Z | 0;
+ I[4] = I[4] + M | 0;
+ I[5] = I[5] + U | 0;
+ I[6] = I[6] + H | 0;
+ I[7] = I[7] + O | 0;
+ },
+ "_doFinalize": function () {
+ var F = this._data;
+ var E = F.words;
+ var I = 8 * this._nDataBytes;
+ var K = 8 * F.sigBytes;
+ return E[K >>> 5] |= 128 << 24 - K % 32, E[(K + 64 >>> 9 << 4) + 14] = p.floor(I / 4294967296), E[(K + 64 >>> 9 << 4) + 15] = I, F.sigBytes = 4 * E.length, this._process(), this._hash;
+ },
+ "clone": function () {
+ var F = L.clone.call(this);
+ return F._hash = this._hash.clone(), F;
+ }
+ });
+ c.SHA256 = L._createHelper(a);
+ c.HmacSHA256 = L._createHmacHelper(a);
+})(Math);
+
+(function () {
+ var p = CryptoJS;
+ var n = p.lib.WordArray;
+ var A = p.algo;
+ var L = A.SHA256;
+ var A = A.SHA224 = L.extend({
+ "_doReset": function () {
+ this._hash = new n.init([3238371032, 914150663, 812702999, 4144912697, 4290775857, 1750603025, 1694076839, 3204075428]);
+ },
+ "_doFinalize": function () {
+ var g = L._doFinalize.call(this);
+
+ return g.sigBytes -= 4, g;
+ }
+ });
+ p.SHA224 = L._createHelper(A);
+ p.HmacSHA224 = L._createHmacHelper(A);
+})();
+
+(function () {
+ function p() {
+ return g.create.apply(g, arguments);
+ }
+
+ for (var c = CryptoJS, A = c.lib.Hasher, L = c.x64, g = L.Word, S = L.WordArray, L = c.algo, f = [p(1116352408, 3609767458), p(1899447441, 602891725), p(3049323471, 3964484399), p(3921009573, 2173295548), p(961987163, 4081628472), p(1508970993, 3053834265), p(2453635748, 2937671579), p(2870763221, 3664609560), p(3624381080, 2734883394), p(310598401, 1164996542), p(607225278, 1323610764), p(1426881987, 3590304994), p(1925078388, 4068182383), p(2162078206, 991336113), p(2614888103, 633803317), p(3248222580, 3479774868), p(3835390401, 2666613458), p(4022224774, 944711139), p(264347078, 2341262773), p(604807628, 2007800933), p(770255983, 1495990901), p(1249150122, 1856431235), p(1555081692, 3175218132), p(1996064986, 2198950837), p(2554220882, 3999719339), p(2821834349, 766784016), p(2952996808, 2566594879), p(3210313671, 3203337956), p(3336571891, 1034457026), p(3584528711, 2466948901), p(113926993, 3758326383), p(338241895, 168717936), p(666307205, 1188179964), p(773529912, 1546045734), p(1294757372, 1522805485), p(1396182291, 2643833823), p(1695183700, 2343527390), p(1986661051, 1014477480), p(2177026350, 1206759142), p(2456956037, 344077627), p(2730485921, 1290863460), p(2820302411, 3158454273), p(3259730800, 3505952657), p(3345764771, 106217008), p(3516065817, 3606008344), p(3600352804, 1432725776), p(4094571909, 1467031594), p(275423344, 851169720), p(430227734, 3100823752), p(506948616, 1363258195), p(659060556, 3750685593), p(883997877, 3785050280), p(958139571, 3318307427), p(1322822218, 3812723403), p(1537002063, 2003034995), p(1747873779, 3602036899), p(1955562222, 1575990012), p(2024104815, 1125592928), p(2227730452, 2716904306), p(2361852424, 442776044), p(2428436474, 593698344), p(2756734187, 3733110249), p(3204031479, 2999351573), p(3329325298, 3815920427), p(3391569614, 3928383900), p(3515267271, 566280711), p(3940187606, 3454069534), p(4118630271, 4000239992), p(116418474, 1914138554), p(174292421, 2731055270), p(289380356, 3203993006), p(460393269, 320620315), p(685471733, 587496836), p(852142971, 1086792851), p(1017036298, 365543100), p(1126000580, 2618297676), p(1288033470, 3409855158), p(1501505948, 4234509866), p(1607167915, 987167468), p(1816402316, 1246189591)], Y = [], J = 0; 80 > J; J++) Y[J] = p();
+
+ L = L.SHA512 = A.extend({
+ "_doReset": function () {
+ this._hash = new S.init([new g.init(1779033703, 4089235720), new g.init(3144134277, 2227873595), new g.init(1013904242, 4271175723), new g.init(2773480762, 1595750129), new g.init(1359893119, 2917565137), new g.init(2600822924, 725511199), new g.init(528734635, 4215389547), new g.init(1541459225, 327033209)]);
+ },
+ "_doProcessBlock": function (i, o) {
+ for (var p0 = this._hash.words, p1 = p0[0], p2 = p0[1], p3 = p0[2], p4 = p0[3], p5 = p0[4], p6 = p0[5], p7 = p0[6], p0 = p0[7], p8 = p1.high, p9 = p1.low, pp = p2.high, pn = p2.low, pc = p3.high, pa = p3.low, pA = p4.high, pL = p4.low, pg = p5.high, pS = p5.low, pf = p6.high, pY = p6.low, pJ = p7.high, pb = p7.low, pC = p0.high, pV = p0.low, pW = p8, pl = p9, pR = pp, pB = pn, pF = pc, pE = pa, ps = pA, pI = pL, pK = pg, pT = pS, pi = pf, pe = pY, pZ = pJ, pw = pb, pM = pC, pu = pV, pk = 0; 80 > pk; pk++) {
+ var pq = Y[pk];
+
+ if (16 > pk) {
+ var pU = pq.high = i[o + 2 * pk] | 0;
+ var pz = pq.low = i[o + 2 * pk + 1] | 0;
+ } else {
+ var pU = Y[pk - 15];
+ var pz = pU.high;
+ var ph = pU.low;
+ var pU = (pz >>> 1 | ph << 31) ^ (pz >>> 8 | ph << 24) ^ pz >>> 7;
+ var ph = (ph >>> 1 | pz << 31) ^ (ph >>> 8 | pz << 24) ^ (ph >>> 7 | pz << 25);
+ var pH = Y[pk - 2];
+ var pz = pH.high;
+ var pj = pH.low;
+ var pH = (pz >>> 19 | pj << 13) ^ (pz << 3 | pj >>> 29) ^ pz >>> 6;
+ var pj = (pj >>> 19 | pz << 13) ^ (pj << 3 | pz >>> 29) ^ (pj >>> 6 | pz << 26);
+ var pz = Y[pk - 7];
+ var pO = pz.high;
+ var pt = Y[pk - 16];
+ var pX = pt.high;
+ var pt = pt.low;
+ var pz = ph + pz.low;
+ var pU = pU + pO + (pz >>> 0 < ph >>> 0 ? 1 : 0);
+ var pz = pz + pj;
+ var pU = pU + pH + (pz >>> 0 < pj >>> 0 ? 1 : 0);
+ var pz = pz + pt;
+ var pU = pU + pX + (pz >>> 0 < pt >>> 0 ? 1 : 0);
+ pq.high = pU;
+ pq.low = pz;
+ }
+
+ var pO = pK & pi ^ ~pK & pZ;
+ var pt = pT & pe ^ ~pT & pw;
+ var pq = pW & pR ^ pW & pF ^ pR & pF;
+ var pG = pl & pB ^ pl & pE ^ pB & pE;
+ var ph = (pW >>> 28 | pl << 4) ^ (pW << 30 | pl >>> 2) ^ (pW << 25 | pl >>> 7);
+ var pH = (pl >>> 28 | pW << 4) ^ (pl << 30 | pW >>> 2) ^ (pl << 25 | pW >>> 7);
+ var pj = f[pk];
+ var px = pj.high;
+ var pN = pj.low;
+ var pj = pu + ((pT >>> 14 | pK << 18) ^ (pT >>> 18 | pK << 14) ^ (pT << 23 | pK >>> 9));
+ var pX = pM + ((pK >>> 14 | pT << 18) ^ (pK >>> 18 | pT << 14) ^ (pK << 23 | pT >>> 9)) + (pj >>> 0 < pu >>> 0 ? 1 : 0);
+ var pj = pj + pt;
+ var pX = pX + pO + (pj >>> 0 < pt >>> 0 ? 1 : 0);
+ var pj = pj + pN;
+ var pX = pX + px + (pj >>> 0 < pN >>> 0 ? 1 : 0);
+ var pj = pj + pz;
+ var pX = pX + pU + (pj >>> 0 < pz >>> 0 ? 1 : 0);
+ var pz = pH + pG;
+ var pq = ph + pq + (pz >>> 0 < pH >>> 0 ? 1 : 0);
+ var pM = pZ;
+ var pu = pw;
+ var pZ = pi;
+ var pw = pe;
+ var pi = pK;
+ var pe = pT;
+ var pT = pI + pj | 0;
+ var pK = ps + pX + (pT >>> 0 < pI >>> 0 ? 1 : 0) | 0;
+ var ps = pF;
+ var pI = pE;
+ var pF = pR;
+ var pE = pB;
+ var pR = pW;
+ var pB = pl;
+ var pl = pj + pz | 0;
+ var pW = pX + pq + (pl >>> 0 < pj >>> 0 ? 1 : 0) | 0;
+ }
+
+ p9 = p1.low = p9 + pl;
+ p1.high = p8 + pW + (p9 >>> 0 < pl >>> 0 ? 1 : 0);
+ pn = p2.low = pn + pB;
+ p2.high = pp + pR + (pn >>> 0 < pB >>> 0 ? 1 : 0);
+ pa = p3.low = pa + pE;
+ p3.high = pc + pF + (pa >>> 0 < pE >>> 0 ? 1 : 0);
+ pL = p4.low = pL + pI;
+ p4.high = pA + ps + (pL >>> 0 < pI >>> 0 ? 1 : 0);
+ pS = p5.low = pS + pT;
+ p5.high = pg + pK + (pS >>> 0 < pT >>> 0 ? 1 : 0);
+ pY = p6.low = pY + pe;
+ p6.high = pf + pi + (pY >>> 0 < pe >>> 0 ? 1 : 0);
+ pb = p7.low = pb + pw;
+ p7.high = pJ + pZ + (pb >>> 0 < pw >>> 0 ? 1 : 0);
+ pV = p0.low = pV + pu;
+ p0.high = pC + pM + (pV >>> 0 < pu >>> 0 ? 1 : 0);
+ },
+ "_doFinalize": function () {
+ var b = this._data;
+ var C = b.words;
+ var V = 8 * this._nDataBytes;
+ var W = 8 * b.sigBytes;
+ return C[W >>> 5] |= 128 << 24 - W % 32, C[(W + 128 >>> 10 << 5) + 30] = Math.floor(V / 4294967296), C[(W + 128 >>> 10 << 5) + 31] = V, b.sigBytes = 4 * C.length, this._process(), this._hash.toX32();
+ },
+ "clone": function () {
+ var b = A.clone.call(this);
+ return b._hash = this._hash.clone(), b;
+ },
+ "blockSize": 32
+ });
+ c.SHA512 = A._createHelper(L);
+ c.HmacSHA512 = A._createHmacHelper(L);
+})();
+
+(function () {
+ var p = CryptoJS;
+ var n = p.x64;
+ var A = n.Word;
+ var L = n.WordArray;
+ var n = p.algo;
+ var g = n.SHA512;
+ var n = n.SHA384 = g.extend({
+ "_doReset": function () {
+ this._hash = new L.init([new A.init(3418070365, 3238371032), new A.init(1654270250, 914150663), new A.init(2438529370, 812702999), new A.init(355462360, 4144912697), new A.init(1731405415, 4290775857), new A.init(2394180231, 1750603025), new A.init(3675008525, 1694076839), new A.init(1203062813, 3204075428)]);
+ },
+ "_doFinalize": function () {
+ var S = g._doFinalize.call(this);
+
+ return S.sigBytes -= 16, S;
+ }
+ });
+ p.SHA384 = g._createHelper(n);
+ p.HmacSHA384 = g._createHmacHelper(n);
+})();
+
+(function () {
+ var c = CryptoJS;
+ var a = c.lib;
+ var L = a.WordArray;
+ var g = a.Hasher;
+ var a = c.algo;
+ var S = L.create([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13]);
+ var f = L.create([5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11]);
+ var Y = L.create([11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6]);
+ var J = L.create([8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11]);
+ var b = L.create([0, 1518500249, 1859775393, 2400959708, 2840853838]);
+ var V = L.create([1352829926, 1548603684, 1836072691, 2053994217, 0]);
+ var a = a.RIPEMD160 = g.extend({
+ "_doReset": function () {
+ this._hash = L.create([1732584193, 4023233417, 2562383102, 271733878, 3285377520]);
+ },
+ "_doProcessBlock": function (W, R) {
+ for (var F = 0; 16 > F; F++) {
+ var E = R + F;
+ var I = W[E];
+ W[E] = (I << 8 | I >>> 24) & 16711935 | (I << 24 | I >>> 8) & 4278255360;
+ }
+
+ var E = this._hash.words;
+ var I = b.words;
+ var K = V.words;
+ var T = S.words;
+ var i = f.words;
+ var Z = Y.words;
+ var M = J.words;
+ var U;
+ var H;
+ var O;
+ var X;
+ var G;
+ var N;
+ var D;
+ var o;
+ var Q;
+ var P;
+ N = U = E[0];
+ D = H = E[1];
+ o = O = E[2];
+ Q = X = E[3];
+ P = G = E[4];
+
+ for (var p0, F = 0; 80 > F; F += 1) {
+ p0 = U + W[R + T[F]] | 0;
+ 16 > F ? p0 = p0 + ((H ^ O ^ X) + I[0]) : 32 > F ? p0 = p0 + ((H & O | ~H & X) + I[1]) : 48 > F ? p0 = p0 + (((H | ~O) ^ X) + I[2]) : 64 > F ? p0 = p0 + ((H & X | O & ~X) + I[3]) : p0 = p0 + ((H ^ (O | ~X)) + I[4]);
+ p0 |= 0;
+ p0 = p0 << Z[F] | p0 >>> 32 - Z[F];
+ p0 = p0 + G | 0;
+ U = G;
+ G = X;
+ X = O << 10 | O >>> 22;
+ O = H;
+ H = p0;
+ p0 = N + W[R + i[F]] | 0;
+ 16 > F ? p0 = p0 + ((D ^ (o | ~Q)) + K[0]) : 32 > F ? p0 = p0 + ((D & Q | o & ~Q) + K[1]) : 48 > F ? p0 = p0 + (((D | ~o) ^ Q) + K[2]) : 64 > F ? p0 = p0 + ((D & o | ~D & Q) + K[3]) : p0 = p0 + ((D ^ o ^ Q) + K[4]);
+ p0 |= 0;
+ p0 = p0 << M[F] | p0 >>> 32 - M[F];
+ p0 = p0 + P | 0;
+ N = P;
+ P = Q;
+ Q = o << 10 | o >>> 22;
+ o = D;
+ D = p0;
+ }
+
+ p0 = E[1] + O + Q | 0;
+ E[1] = E[2] + X + P | 0;
+ E[2] = E[3] + G + N | 0;
+ E[3] = E[4] + U + D | 0;
+ E[4] = E[0] + H + o | 0;
+ E[0] = p0;
+ },
+ "_doFinalize": function () {
+ var W = this._data;
+ var l = W.words;
+ var R = 8 * this._nDataBytes;
+ var F = 8 * W.sigBytes;
+ l[F >>> 5] |= 128 << 24 - F % 32;
+ l[(F + 64 >>> 9 << 4) + 14] = (R << 8 | R >>> 24) & 16711935 | (R << 24 | R >>> 8) & 4278255360;
+ W.sigBytes = 4 * (l.length + 1);
+
+ this._process();
+
+ W = this._hash;
+ l = W.words;
+
+ for (R = 0; 5 > R; R++) {
+ F = l[R];
+ l[R] = (F << 8 | F >>> 24) & 16711935 | (F << 24 | F >>> 8) & 4278255360;
+ }
+
+ return W;
+ },
+ "clone": function () {
+ var W = g.clone.call(this);
+ return W._hash = this._hash.clone(), W;
+ }
+ });
+ c.RIPEMD160 = g._createHelper(a);
+ c.HmacRIPEMD160 = g._createHmacHelper(a);
+})(Math);
+
+(function () {
+ var p = CryptoJS;
+ var n = p.enc.Utf8;
+ p.algo.HMAC = p.lib.Base.extend({
+ "init": function (A, L) {
+ A = this._hasher = new A.init();
+ "string" == typeof L && (L = n.parse(L));
+ var S = A.blockSize;
+ var Y = 4 * S;
+ L.sigBytes > Y && (L = A.finalize(L));
+ L.clamp();
+
+ for (var J = this._oKey = L.clone(), C = this._iKey = L.clone(), V = J.words, W = C.words, l = 0; l < S; l++) {
+ V[l] ^= 1549556828;
+ W[l] ^= 909522486;
+ }
+
+ J.sigBytes = C.sigBytes = Y;
+ this.reset();
+ },
+ "reset": function () {
+ var A = this._hasher;
+ A.reset();
+ A.update(this._iKey);
+ },
+ "update": function (A) {
+ return this._hasher.update(A), this;
+ },
+ "finalize": function (A) {
+ var L = this._hasher;
+ return A = L.finalize(A), L.reset(), L.finalize(this._oKey.clone().concat(A));
+ }
+ });
+})();
+
+(function () {
+ var p = CryptoJS;
+ var n = p.lib;
+ var c = n.Base;
+ var A = n.WordArray;
+ var n = p.algo;
+ var L = n.HMAC;
+ var g = n.PBKDF2 = c.extend({
+ "cfg": c.extend({
+ "keySize": 4,
+ "hasher": n.SHA1,
+ "iterations": 1
+ }),
+ "init": function (S) {
+ this.cfg = this.cfg.extend(S);
+ },
+ "compute": function (S, Y) {
+ for (var J = this.cfg, C = L.create(J.hasher, S), V = A.create(), W = A.create([1]), R = V.words, B = W.words, F = J.keySize, J = J.iterations; R.length < F;) {
+ var E = C.update(Y).finalize(W);
+ C.reset();
+
+ for (var I = E.words, K = I.length, T = E, i = 1; i < J; i++) {
+ T = C.finalize(T);
+ C.reset();
+
+ for (var Z = T.words, w = 0; w < K; w++) I[w] ^= Z[w];
+ }
+
+ V.concat(E);
+ B[0]++;
+ }
+
+ return V.sigBytes = 4 * F, V;
+ }
+ });
+
+ p.PBKDF2 = function (S, f, Y) {
+ return g.create(Y).compute(S, f);
+ };
+})();
+
+var b64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var b64pad = "=";
+
+function hex2b64(p) {
+ var n;
+ var c;
+ var A = "";
+
+ for (n = 0; n + 3 <= p.length; n += 3) {
+ c = parseInt(p.substring(n, n + 3), 16);
+ A += b64map.charAt(c >> 6) + b64map.charAt(c & 63);
+ }
+
+ if (n + 1 == p.length) {
+ c = parseInt(p.substring(n, n + 1), 16);
+ A += b64map.charAt(c << 2);
+ } else {
+ if (n + 2 == p.length) {
+ c = parseInt(p.substring(n, n + 2), 16);
+ A += b64map.charAt(c >> 2) + b64map.charAt((c & 3) << 4);
+ }
+ }
+
+ if (b64pad) while ((A.length & 3) > 0) {
+ A += b64pad;
+ }
+ return A;
+}
+
+function b64tohex(p) {
+ var n = "";
+ var A;
+ var L = 0;
+ var g;
+ var S;
+
+ for (A = 0; A < p.length; ++A) {
+ if (p.charAt(A) == b64pad) break;
+ S = b64map.indexOf(p.charAt(A));
+ if (S < 0) continue;
+
+ if (L == 0) {
+ n += int2char(S >> 2);
+ g = S & 3;
+ L = 1;
+ } else {
+ if (L == 1) {
+ n += int2char(g << 2 | S >> 4);
+ g = S & 15;
+ L = 2;
+ } else {
+ if (L == 2) {
+ n += int2char(g);
+ n += int2char(S >> 2);
+ g = S & 3;
+ L = 3;
+ } else {
+ n += int2char(g << 2 | S >> 4);
+ n += int2char(S & 15);
+ L = 0;
+ }
+ }
+ }
+ }
+
+ return L == 1 && (n += int2char(g << 2)), n;
+}
+
+function b64toBA(p) {
+ var n = b64tohex(p);
+ var a;
+ var A = new Array();
+
+ for (a = 0; 2 * a < n.length; ++a) {
+ A[a] = parseInt(n.substring(2 * a, 2 * a + 2), 16);
+ }
+
+ return A;
+}
+
+;
+var dbits;
+var canary = 244837814094590;
+var j_lm = (canary & 16777215) == 15715070;
+
+function BigInteger(p, n, c) {
+ if (p != null) {
+ "number" == typeof p ? this.fromNumber(p, n, c) : n == null && "string" != typeof p ? this.fromString(p, 256) : this.fromString(p, n);
+ }
+}
+
+function nbi() {
+ return new BigInteger(null);
+}
+
+function am1(p, n, c, A, L, S) {
+ while (--S >= 0) {
+ var Y = n * this[p++] + c[A] + L;
+ L = Math.floor(Y / 67108864);
+ c[A++] = Y & 67108863;
+ }
+
+ return L;
+}
+
+function am2(n, c, A, L, S, Y) {
+ var J = c & 32767;
+ var C = c >> 15;
+
+ while (--Y >= 0) {
+ var V = this[n] & 32767;
+ var W = this[n++] >> 15;
+ var l = C * V + W * J;
+ V = J * V + ((l & 32767) << 15) + A[L] + (S & 1073741823);
+ S = (V >>> 30) + (l >>> 15) + C * W + (S >>> 30);
+ A[L++] = V & 1073741823;
+ }
+
+ return S;
+}
+
+function am3(n, c, A, L, S, Y) {
+ var J = c & 16383;
+ var C = c >> 14;
+
+ while (--Y >= 0) {
+ var V = this[n] & 16383;
+ var W = this[n++] >> 14;
+ var l = C * V + W * J;
+ V = J * V + ((l & 16383) << 14) + A[L] + S;
+ S = (V >> 28) + (l >> 14) + C * W;
+ A[L++] = V & 268435455;
+ }
+
+ return S;
+}
+
+if (j_lm && navigator.appName == "Microsoft Internet Explorer") {
+ BigInteger.prototype.am = am2;
+ dbits = 30;
+} else {
+ if (j_lm && navigator.appName != "Netscape") {
+ BigInteger.prototype.am = am1;
+ dbits = 26;
+ } else {
+ BigInteger.prototype.am = am3;
+ dbits = 28;
+ }
+}
+
+BigInteger.prototype.DB = dbits;
+BigInteger.prototype.DM = (1 << dbits) - 1;
+BigInteger.prototype.DV = 1 << dbits;
+var BI_FP = 52;
+BigInteger.prototype.FV = Math.pow(2, BI_FP);
+BigInteger.prototype.F1 = BI_FP - dbits;
+BigInteger.prototype.F2 = 2 * dbits - BI_FP;
+var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
+var BI_RC = new Array();
+var rr;
+var vv;
+rr = "0".charCodeAt(0);
+
+for (vv = 0; vv <= 9; ++vv) {
+ BI_RC[rr++] = vv;
+}
+
+rr = "a".charCodeAt(0);
+
+for (vv = 10; vv < 36; ++vv) {
+ BI_RC[rr++] = vv;
+}
+
+rr = "A".charCodeAt(0);
+
+for (vv = 10; vv < 36; ++vv) {
+ BI_RC[rr++] = vv;
+}
+
+function int2char(p) {
+ return BI_RM.charAt(p);
+}
+
+function intAt(p, n) {
+ var c = BI_RC[p.charCodeAt(n)];
+ return c == null ? -1 : c;
+}
+
+function bnpCopyTo(p) {
+ for (var n = this.t - 1; n >= 0; --n) {
+ p[n] = this[n];
+ }
+
+ p.t = this.t;
+ p.s = this.s;
+}
+
+function bnpFromInt(p) {
+ this.t = 1;
+ p < 0 ? this.s = -1 : this.s = 0;
+ p > 0 ? this[0] = p : p < -1 ? this[0] = p + this.DV : this.t = 0;
+}
+
+function nbv(p) {
+ var n = nbi();
+ return n.fromInt(p), n;
+}
+
+function bnpFromString(p, n) {
+ var A;
+ if (n == 16) A = 4;else {
+ if (n == 8) A = 3;else {
+ if (n == 256) A = 8;else {
+ if (n == 2) A = 1;else {
+ if (n == 32) A = 5;else {
+ if (n == 4) A = 2;else {
+ this.fromRadix(p, n);
+ return;
+ }
+ }
+ }
+ }
+ }
+ }
+ this.t = 0;
+ this.s = 0;
+ var L = p.length;
+ var S = ![];
+ var Y = 0;
+
+ while (--L >= 0) {
+ if (A == 8) {
+ var J = p[L] & 255;
+ } else {
+ var J = intAt(p, L);
+ }
+
+ if (J < 0) {
+ if (p.charAt(L) == "-") {
+ S = !![];
+ }
+
+ continue;
+ }
+
+ S = ![];
+ Y == 0 ? this[this.t++] = J : Y + A > this.DB ? (this[this.t - 1] |= (J & (1 << this.DB - Y) - 1) << Y, this[this.t++] = J >> this.DB - Y) : this[this.t - 1] |= J << Y;
+ Y += A;
+ Y >= this.DB && (Y -= this.DB);
+ }
+
+ A == 8 && (p[0] & 128) != 0 && (this.s = -1, Y > 0 && (this[this.t - 1] |= (1 << this.DB - Y) - 1 << Y));
+ this.clamp();
+ S && BigInteger.ZERO.subTo(this, this);
+}
+
+function bnpClamp() {
+ var p = this.s & this.DM;
+
+ while (this.t > 0 && this[this.t - 1] == p) {
+ --this.t;
+ }
+}
+
+function bnToString(p) {
+ if (this.s < 0) return "-" + this.negate().toString(p);
+ var n;
+ if (p == 16) n = 4;else {
+ if (p == 8) n = 3;else {
+ if (p == 2) n = 1;else {
+ if (p == 32) n = 5;else {
+ if (p == 4) n = 2;else return this.toRadix(p);
+ }
+ }
+ }
+ }
+ var A = (1 << n) - 1;
+ var L;
+ var S = ![];
+ var Y = "";
+ var J = this.t;
+ var b = this.DB - J * this.DB % n;
+
+ if (J-- > 0) {
+ if (b < this.DB && (L = this[J] >> b) > 0) {
+ S = !![];
+ Y = int2char(L);
+ }
+
+ while (J >= 0) {
+ b < n ? (L = (this[J] & (1 << b) - 1) << n - b, L |= this[--J] >> (b += this.DB - n)) : (L = this[J] >> (b -= n) & A, b <= 0 && (b += this.DB, --J));
+ L > 0 && (S = !![]);
+ S && (Y += int2char(L));
+ }
+ }
+
+ return S ? Y : "0";
+}
+
+function bnNegate() {
+ var p = nbi();
+ return BigInteger.ZERO.subTo(this, p), p;
+}
+
+function bnAbs() {
+ return this.s < 0 ? this.negate() : this;
+}
+
+function bnCompareTo(p) {
+ var n = this.s - p.s;
+ if (n != 0) return n;
+ var a = this.t;
+ n = a - p.t;
+ if (n != 0) return this.s < 0 ? -n : n;
+
+ while (--a >= 0) {
+ if ((n = this[a] - p[a]) != 0) return n;
+ }
+
+ return 0;
+}
+
+function nbits(p) {
+ var n = 1;
+ var A;
+ return (A = p >>> 16) != 0 && (p = A, n += 16), (A = p >> 8) != 0 && (p = A, n += 8), (A = p >> 4) != 0 && (p = A, n += 4), (A = p >> 2) != 0 && (p = A, n += 2), (A = p >> 1) != 0 && (p = A, n += 1), n;
+}
+
+function bnBitLength() {
+ if (this.t <= 0) return 0;
+ return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ this.s & this.DM);
+}
+
+function bnpDLShiftTo(p, n) {
+ var A;
+
+ for (A = this.t - 1; A >= 0; --A) {
+ n[A + p] = this[A];
+ }
+
+ for (A = p - 1; A >= 0; --A) {
+ n[A] = 0;
+ }
+
+ n.t = this.t + p;
+ n.s = this.s;
+}
+
+function bnpDRShiftTo(p, n) {
+ for (var A = p; A < this.t; ++A) {
+ n[A - p] = this[A];
+ }
+
+ n.t = Math.max(this.t - p, 0);
+ n.s = this.s;
+}
+
+function bnpLShiftTo(p, n) {
+ var c = p % this.DB;
+ var A = this.DB - c;
+ var L = (1 << A) - 1;
+ var S = Math.floor(p / this.DB);
+ var Y = this.s << c & this.DM;
+ var J;
+
+ for (J = this.t - 1; J >= 0; --J) {
+ n[J + S + 1] = this[J] >> A | Y;
+ Y = (this[J] & L) << c;
+ }
+
+ for (J = S - 1; J >= 0; --J) {
+ n[J] = 0;
+ }
+
+ n[S] = Y;
+ n.t = this.t + S + 1;
+ n.s = this.s;
+ n.clamp();
+}
+
+function bnpRShiftTo(p, n) {
+ n.s = this.s;
+ var A = Math.floor(p / this.DB);
+
+ if (A >= this.t) {
+ n.t = 0;
+ return;
+ }
+
+ var L = p % this.DB;
+ var S = this.DB - L;
+ var Y = (1 << L) - 1;
+ n[0] = this[A] >> L;
+
+ for (var J = A + 1; J < this.t; ++J) {
+ n[J - A - 1] |= (this[J] & Y) << S;
+ n[J - A] = this[J] >> L;
+ }
+
+ L > 0 && (n[this.t - A - 1] |= (this.s & Y) << S);
+ n.t = this.t - A;
+ n.clamp();
+}
+
+function bnpSubTo(p, n) {
+ var c = 0;
+ var a = 0;
+ var A = Math.min(p.t, this.t);
+
+ while (c < A) {
+ a += this[c] - p[c];
+ n[c++] = a & this.DM;
+ a >>= this.DB;
+ }
+
+ if (p.t < this.t) {
+ a -= p.s;
+
+ while (c < this.t) {
+ a += this[c];
+ n[c++] = a & this.DM;
+ a >>= this.DB;
+ }
+
+ a += this.s;
+ } else {
+ a += this.s;
+
+ while (c < p.t) {
+ a -= p[c];
+ n[c++] = a & this.DM;
+ a >>= this.DB;
+ }
+
+ a -= p.s;
+ }
+
+ a < 0 ? n.s = -1 : n.s = 0;
+ a < -1 ? n[c++] = this.DV + a : a > 0 && (n[c++] = a);
+ n.t = c;
+ n.clamp();
+}
+
+function bnpMultiplyTo(p, n) {
+ var a = this.abs();
+ var A = p.abs();
+ var L = a.t;
+ n.t = L + A.t;
+
+ while (--L >= 0) {
+ n[L] = 0;
+ }
+
+ for (L = 0; L < A.t; ++L) {
+ n[L + a.t] = a.am(0, A[L], n, L, 0, a.t);
+ }
+
+ n.s = 0;
+ n.clamp();
+ this.s != p.s && BigInteger.ZERO.subTo(n, n);
+}
+
+function bnpSquareTo(p) {
+ var n = this.abs();
+ var c = p.t = 2 * n.t;
+
+ while (--c >= 0) {
+ p[c] = 0;
+ }
+
+ for (c = 0; c < n.t - 1; ++c) {
+ var A = n.am(c, n[c], p, 2 * c, 0, 1);
+
+ if ((p[c + n.t] += n.am(c + 1, 2 * n[c], p, 2 * c + 1, A, n.t - c - 1)) >= n.DV) {
+ p[c + n.t] -= n.DV;
+ p[c + n.t + 1] = 1;
+ }
+ }
+
+ p.t > 0 && (p[p.t - 1] += n.am(c, n[c], p, 2 * c, 0, 1));
+ p.s = 0;
+ p.clamp();
+}
+
+function bnpDivRemTo(L, S, Y) {
+ var J = L.abs();
+ if (J.t <= 0) return;
+ var C = this.abs();
+
+ if (C.t < J.t) {
+ if (S != null) {
+ S.fromInt(0);
+ }
+
+ if (Y != null) {
+ this.copyTo(Y);
+ }
+
+ return;
+ }
+
+ if (Y == null) {
+ Y = nbi();
+ }
+
+ var V = nbi();
+ var W = this.s;
+ var R = L.s;
+ var B = this.DB - nbits(J[J.t - 1]);
+
+ if (B > 0) {
+ J.lShiftTo(B, V);
+ C.lShiftTo(B, Y);
+ } else {
+ J.copyTo(V);
+ C.copyTo(Y);
+ }
+
+ var F = V.t;
+ var E = V[F - 1];
+ if (E == 0) return;
+ var I = E * (1 << this.F1) + (F > 1 ? V[F - 2] >> this.F2 : 0);
+ var K = this.FV / I;
+ var T = (1 << this.F1) / I;
+ var i = 1 << this.F2;
+ var e = Y.t;
+ var Z = e - F;
+
+ if (S == null) {
+ var M = nbi();
+ } else {
+ var M = S;
+ }
+
+ V.dlShiftTo(Z, M);
+
+ if (Y.compareTo(M) >= 0) {
+ Y[Y.t++] = 1;
+ Y.subTo(M, Y);
+ }
+
+ BigInteger.ONE.dlShiftTo(F, M);
+ M.subTo(V, V);
+
+ while (V.t < F) {
+ V[V.t++] = 0;
+ }
+
+ while (--Z >= 0) {
+ var q = Y[--e] == E ? this.DM : Math.floor(Y[e] * K + (Y[e - 1] + i) * T);
+
+ if ((Y[e] += V.am(0, q, Y, Z, 0, F)) < q) {
+ V.dlShiftTo(Z, M);
+ Y.subTo(M, Y);
+
+ while (Y[e] < --q) {
+ Y.subTo(M, Y);
+ }
+ }
+ }
+
+ S != null && (Y.drShiftTo(F, S), W != R && BigInteger.ZERO.subTo(S, S));
+ Y.t = F;
+ Y.clamp();
+ B > 0 && Y.rShiftTo(B, Y);
+ W < 0 && BigInteger.ZERO.subTo(Y, Y);
+}
+
+function bnMod(p) {
+ var n = nbi();
+ return this.abs().divRemTo(p, null, n), this.s < 0 && n.compareTo(BigInteger.ZERO) > 0 && p.subTo(n, n), n;
+}
+
+function Classic(p) {
+ this.m = p;
+}
+
+function cConvert(p) {
+ return p.s < 0 || p.compareTo(this.m) >= 0 ? p.mod(this.m) : p;
+}
+
+function cRevert(p) {
+ return p;
+}
+
+function cReduce(p) {
+ p.divRemTo(this.m, null, p);
+}
+
+function cMulTo(p, n, A) {
+ p.multiplyTo(n, A);
+ this.reduce(A);
+}
+
+function cSqrTo(p, n) {
+ p.squareTo(n);
+ this.reduce(n);
+}
+
+Classic.prototype.convert = cConvert;
+Classic.prototype.revert = cRevert;
+Classic.prototype.reduce = cReduce;
+Classic.prototype.mulTo = cMulTo;
+Classic.prototype.sqrTo = cSqrTo;
+
+function bnpInvDigit() {
+ if (this.t < 1) return 0;
+ var p = this[0];
+ if ((p & 1) == 0) return 0;
+ var n = p & 3;
+ return n = n * (2 - (p & 15) * n) & 15, n = n * (2 - (p & 255) * n) & 255, n = n * (2 - ((p & 65535) * n & 65535)) & 65535, n = n * (2 - p * n % this.DV) % this.DV, n > 0 ? this.DV - n : -n;
+}
+
+function Montgomery(p) {
+ this.m = p;
+ this.mp = p.invDigit();
+ this.mpl = this.mp & 32767;
+ this.mph = this.mp >> 15;
+ this.um = (1 << p.DB - 15) - 1;
+ this.mt2 = 2 * p.t;
+}
+
+function montConvert(p) {
+ var n = nbi();
+ return p.abs().dlShiftTo(this.m.t, n), n.divRemTo(this.m, null, n), p.s < 0 && n.compareTo(BigInteger.ZERO) > 0 && this.m.subTo(n, n), n;
+}
+
+function montRevert(p) {
+ var n = nbi();
+ return p.copyTo(n), this.reduce(n), n;
+}
+
+function montReduce(p) {
+ while (p.t <= this.mt2) {
+ p[p.t++] = 0;
+ }
+
+ for (var n = 0; n < this.m.t; ++n) {
+ var A = p[n] & 32767;
+ var L = A * this.mpl + ((A * this.mph + (p[n] >> 15) * this.mpl & this.um) << 15) & p.DM;
+ A = n + this.m.t;
+ p[A] += this.m.am(0, L, p, n, 0, this.m.t);
+
+ while (p[A] >= p.DV) {
+ p[A] -= p.DV;
+ p[++A]++;
+ }
+ }
+
+ p.clamp();
+ p.drShiftTo(this.m.t, p);
+ p.compareTo(this.m) >= 0 && p.subTo(this.m, p);
+}
+
+function montSqrTo(p, n) {
+ p.squareTo(n);
+ this.reduce(n);
+}
+
+function montMulTo(p, n, A) {
+ p.multiplyTo(n, A);
+ this.reduce(A);
+}
+
+Montgomery.prototype.convert = montConvert;
+Montgomery.prototype.revert = montRevert;
+Montgomery.prototype.reduce = montReduce;
+Montgomery.prototype.mulTo = montMulTo;
+Montgomery.prototype.sqrTo = montSqrTo;
+
+function bnpIsEven() {
+ return (this.t > 0 ? this[0] & 1 : this.s) == 0;
+}
+
+function bnpExp(p, n) {
+ if (p > 4294967295 || p < 1) return BigInteger.ONE;
+ var A = nbi();
+ var L = nbi();
+ var g = n.convert(this);
+ var S = nbits(p) - 1;
+ g.copyTo(A);
+
+ while (--S >= 0) {
+ n.sqrTo(A, L);
+ if ((p & 1 << S) > 0) n.mulTo(L, g, A);else {
+ var Y = A;
+ A = L;
+ L = Y;
+ }
+ }
+
+ return n.revert(A);
+}
+
+function bnModPowInt(p, n) {
+ var A;
+ return p < 256 || n.isEven() ? A = new Classic(n) : A = new Montgomery(n), this.exp(p, A);
+}
+
+BigInteger.prototype.copyTo = bnpCopyTo;
+BigInteger.prototype.fromInt = bnpFromInt;
+BigInteger.prototype.fromString = bnpFromString;
+BigInteger.prototype.clamp = bnpClamp;
+BigInteger.prototype.dlShiftTo = bnpDLShiftTo;
+BigInteger.prototype.drShiftTo = bnpDRShiftTo;
+BigInteger.prototype.lShiftTo = bnpLShiftTo;
+BigInteger.prototype.rShiftTo = bnpRShiftTo;
+BigInteger.prototype.subTo = bnpSubTo;
+BigInteger.prototype.multiplyTo = bnpMultiplyTo;
+BigInteger.prototype.squareTo = bnpSquareTo;
+BigInteger.prototype.divRemTo = bnpDivRemTo;
+BigInteger.prototype.invDigit = bnpInvDigit;
+BigInteger.prototype.isEven = bnpIsEven;
+BigInteger.prototype.exp = bnpExp;
+BigInteger.prototype.toString = bnToString;
+BigInteger.prototype.negate = bnNegate;
+BigInteger.prototype.abs = bnAbs;
+BigInteger.prototype.compareTo = bnCompareTo;
+BigInteger.prototype.bitLength = bnBitLength;
+BigInteger.prototype.mod = bnMod;
+BigInteger.prototype.modPowInt = bnModPowInt;
+BigInteger.ZERO = nbv(0);
+BigInteger.ONE = nbv(1);
+
+function bnClone() {
+ var p = nbi();
+ return this.copyTo(p), p;
+}
+
+function bnIntValue() {
+ if (this.s < 0) {
+ if (this.t == 1) return this[0] - this.DV;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.DB) - 1) << this.DB | this[0];
+}
+
+function bnByteValue() {
+ return this.t == 0 ? this.s : this[0] << 24 >> 24;
+}
+
+function bnShortValue() {
+ return this.t == 0 ? this.s : this[0] << 16 >> 16;
+}
+
+function bnpChunkSize(p) {
+ return Math.floor(Math.LN2 * this.DB / Math.log(p));
+}
+
+function bnSigNum() {
+ return this.s < 0 ? -1 : this.t <= 0 || this.t == 1 && this[0] <= 0 ? 0 : 1;
+}
+
+function bnpToRadix(p) {
+ if (p == null) {
+ p = 10;
+ }
+
+ if (this.signum() == 0 || p < 2 || p > 36) return "0";
+ var n = this.chunkSize(p);
+ var a = Math.pow(p, n);
+ var A = nbv(a);
+ var L = nbi();
+ var S = nbi();
+ var Y = "";
+ this.divRemTo(A, L, S);
+
+ while (L.signum() > 0) {
+ Y = (a + S.intValue()).toString(p).substr(1) + Y;
+ L.divRemTo(A, L, S);
+ }
+
+ return S.intValue().toString(p) + Y;
+}
+
+function bnpFromRadix(p, n) {
+ this.fromInt(0);
+
+ if (n == null) {
+ n = 10;
+ }
+
+ var A = this.chunkSize(n);
+ var L = Math.pow(n, A);
+ var S = ![];
+ var Y = 0;
+ var J = 0;
+
+ for (var b = 0; b < p.length; ++b) {
+ var C = intAt(p, b);
+
+ if (C < 0) {
+ if (p.charAt(b) == "-" && this.signum() == 0) {
+ S = !![];
+ }
+
+ continue;
+ }
+
+ J = n * J + C;
+ ++Y >= A && (this.dMultiply(L), this.dAddOffset(J, 0), Y = 0, J = 0);
+ }
+
+ Y > 0 && (this.dMultiply(Math.pow(n, Y)), this.dAddOffset(J, 0));
+ S && BigInteger.ZERO.subTo(this, this);
+}
+
+function bnpFromNumber(p, n, c) {
+ if ("number" == typeof n) {
+ if (p < 2) this.fromInt(1);else {
+ this.fromNumber(p, c);
+
+ if (!this.testBit(p - 1)) {
+ this.bitwiseTo(BigInteger.ONE.shiftLeft(p - 1), op_or, this);
+ }
+
+ if (this.isEven()) {
+ this.dAddOffset(1, 0);
+ }
+
+ while (!this.isProbablePrime(n)) {
+ this.dAddOffset(2, 0);
+ this.bitLength() > p && this.subTo(BigInteger.ONE.shiftLeft(p - 1), this);
+ }
+ }
+ } else {
+ var a = new Array();
+ var A = p & 7;
+ a.length = (p >> 3) + 1;
+ n.nextBytes(a);
+ A > 0 ? a[0] &= (1 << A) - 1 : a[0] = 0;
+ this.fromString(a, 256);
+ }
+}
+
+function bnToByteArray() {
+ var p = this.t;
+ var n = new Array();
+ n[0] = this.s;
+ var A = this.DB - p * this.DB % 8;
+ var L;
+ var g = 0;
+
+ if (p-- > 0) {
+ if (A < this.DB && (L = this[p] >> A) != (this.s & this.DM) >> A) {
+ n[g++] = L | this.s << this.DB - A;
+ }
+
+ while (p >= 0) {
+ A < 8 ? (L = (this[p] & (1 << A) - 1) << 8 - A, L |= this[--p] >> (A += this.DB - 8)) : (L = this[p] >> (A -= 8) & 255, A <= 0 && (A += this.DB, --p));
+ (L & 128) != 0 && (L |= -256);
+ g == 0 && (this.s & 128) != (L & 128) && ++g;
+ (g > 0 || L != this.s) && (n[g++] = L);
+ }
+ }
+
+ return n;
+}
+
+function bnEquals(p) {
+ return this.compareTo(p) == 0;
+}
+
+function bnMin(p) {
+ return this.compareTo(p) < 0 ? this : p;
+}
+
+function bnMax(p) {
+ return this.compareTo(p) > 0 ? this : p;
+}
+
+function bnpBitwiseTo(p, n, a) {
+ var A;
+ var L;
+ var S = Math.min(p.t, this.t);
+
+ for (A = 0; A < S; ++A) {
+ a[A] = n(this[A], p[A]);
+ }
+
+ if (p.t < this.t) {
+ L = p.s & this.DM;
+
+ for (A = S; A < this.t; ++A) {
+ a[A] = n(this[A], L);
+ }
+
+ a.t = this.t;
+ } else {
+ L = this.s & this.DM;
+
+ for (A = S; A < p.t; ++A) {
+ a[A] = n(L, p[A]);
+ }
+
+ a.t = p.t;
+ }
+
+ a.s = n(this.s, p.s);
+ a.clamp();
+}
+
+function op_and(p, n) {
+ return p & n;
+}
+
+function bnAnd(p) {
+ var n = nbi();
+ return this.bitwiseTo(p, op_and, n), n;
+}
+
+function op_or(p, n) {
+ return p | n;
+}
+
+function bnOr(p) {
+ var n = nbi();
+ return this.bitwiseTo(p, op_or, n), n;
+}
+
+function op_xor(p, n) {
+ return p ^ n;
+}
+
+function bnXor(p) {
+ var n = nbi();
+ return this.bitwiseTo(p, op_xor, n), n;
+}
+
+function op_andnot(p, n) {
+ return p & ~n;
+}
+
+function bnAndNot(p) {
+ var n = nbi();
+ return this.bitwiseTo(p, op_andnot, n), n;
+}
+
+function bnNot() {
+ var p = nbi();
+
+ for (var n = 0; n < this.t; ++n) {
+ p[n] = this.DM & ~this[n];
+ }
+
+ return p.t = this.t, p.s = ~this.s, p;
+}
+
+function bnShiftLeft(p) {
+ var n = nbi();
+ return p < 0 ? this.rShiftTo(-p, n) : this.lShiftTo(p, n), n;
+}
+
+function bnShiftRight(p) {
+ var n = nbi();
+ return p < 0 ? this.lShiftTo(-p, n) : this.rShiftTo(p, n), n;
+}
+
+function lbit(p) {
+ if (p == 0) return -1;
+ var n = 0;
+ return (p & 65535) == 0 && (p >>= 16, n += 16), (p & 255) == 0 && (p >>= 8, n += 8), (p & 15) == 0 && (p >>= 4, n += 4), (p & 3) == 0 && (p >>= 2, n += 2), (p & 1) == 0 && ++n, n;
+}
+
+function bnGetLowestSetBit() {
+ for (var p = 0; p < this.t; ++p) {
+ if (this[p] != 0) return p * this.DB + lbit(this[p]);
+ }
+
+ if (this.s < 0) return this.t * this.DB;
+ return -1;
+}
+
+function cbit(p) {
+ var n = 0;
+
+ while (p != 0) {
+ p &= p - 1;
+ ++n;
+ }
+
+ return n;
+}
+
+function bnBitCount() {
+ var p = 0;
+ var n = this.s & this.DM;
+
+ for (var A = 0; A < this.t; ++A) {
+ p += cbit(this[A] ^ n);
+ }
+
+ return p;
+}
+
+function bnTestBit(p) {
+ var n = Math.floor(p / this.DB);
+ if (n >= this.t) return this.s != 0;
+ return (this[n] & 1 << p % this.DB) != 0;
+}
+
+function bnpChangeBit(p, n) {
+ var A = BigInteger.ONE.shiftLeft(p);
+ return this.bitwiseTo(A, n, A), A;
+}
+
+function bnSetBit(p) {
+ return this.changeBit(p, op_or);
+}
+
+function bnClearBit(p) {
+ return this.changeBit(p, op_andnot);
+}
+
+function bnFlipBit(p) {
+ return this.changeBit(p, op_xor);
+}
+
+function bnpAddTo(p, n) {
+ var c = 0;
+ var a = 0;
+ var A = Math.min(p.t, this.t);
+
+ while (c < A) {
+ a += this[c] + p[c];
+ n[c++] = a & this.DM;
+ a >>= this.DB;
+ }
+
+ if (p.t < this.t) {
+ a += p.s;
+
+ while (c < this.t) {
+ a += this[c];
+ n[c++] = a & this.DM;
+ a >>= this.DB;
+ }
+
+ a += this.s;
+ } else {
+ a += this.s;
+
+ while (c < p.t) {
+ a += p[c];
+ n[c++] = a & this.DM;
+ a >>= this.DB;
+ }
+
+ a += p.s;
+ }
+
+ a < 0 ? n.s = -1 : n.s = 0;
+ a > 0 ? n[c++] = a : a < -1 && (n[c++] = this.DV + a);
+ n.t = c;
+ n.clamp();
+}
+
+function bnAdd(p) {
+ var n = nbi();
+ return this.addTo(p, n), n;
+}
+
+function bnSubtract(p) {
+ var n = nbi();
+ return this.subTo(p, n), n;
+}
+
+function bnMultiply(p) {
+ var n = nbi();
+ return this.multiplyTo(p, n), n;
+}
+
+function bnSquare() {
+ var p = nbi();
+ return this.squareTo(p), p;
+}
+
+function bnDivide(p) {
+ var n = nbi();
+ return this.divRemTo(p, n, null), n;
+}
+
+function bnRemainder(p) {
+ var n = nbi();
+ return this.divRemTo(p, null, n), n;
+}
+
+function bnDivideAndRemainder(p) {
+ var n = nbi();
+ var a = nbi();
+ return this.divRemTo(p, n, a), new Array(n, a);
+}
+
+function bnpDMultiply(p) {
+ this[this.t] = this.am(0, p - 1, this, 0, 0, this.t);
+ ++this.t;
+ this.clamp();
+}
+
+function bnpDAddOffset(p, n) {
+ if (p == 0) return;
+
+ while (this.t <= n) {
+ this[this.t++] = 0;
+ }
+
+ this[n] += p;
+
+ while (this[n] >= this.DV) {
+ this[n] -= this.DV;
+ ++n >= this.t && (this[this.t++] = 0);
+ ++this[n];
+ }
+}
+
+function NullExp() {}
+
+function nNop(p) {
+ return p;
+}
+
+function nMulTo(p, n, A) {
+ p.multiplyTo(n, A);
+}
+
+function nSqrTo(p, n) {
+ p.squareTo(n);
+}
+
+NullExp.prototype.convert = nNop;
+NullExp.prototype.revert = nNop;
+NullExp.prototype.mulTo = nMulTo;
+NullExp.prototype.sqrTo = nSqrTo;
+
+function bnPow(p) {
+ return this.exp(p, new NullExp());
+}
+
+function bnpMultiplyLowerTo(p, n, a) {
+ var A = Math.min(this.t + p.t, n);
+ a.s = 0;
+ a.t = A;
+
+ while (A > 0) {
+ a[--A] = 0;
+ }
+
+ var L;
+
+ for (L = a.t - this.t; A < L; ++A) {
+ a[A + this.t] = this.am(0, p[A], a, A, 0, this.t);
+ }
+
+ for (L = Math.min(p.t, n); A < L; ++A) {
+ this.am(0, p[A], a, A, 0, n - A);
+ }
+
+ a.clamp();
+}
+
+function bnpMultiplyUpperTo(p, n, a) {
+ --n;
+ var A = a.t = this.t + p.t - n;
+ a.s = 0;
+
+ while (--A >= 0) {
+ a[A] = 0;
+ }
+
+ for (A = Math.max(n - this.t, 0); A < p.t; ++A) {
+ a[this.t + A - n] = this.am(n - A, p[A], a, 0, 0, this.t + A - n);
+ }
+
+ a.clamp();
+ a.drShiftTo(1, a);
+}
+
+function Barrett(p) {
+ this.r2 = nbi();
+ this.q3 = nbi();
+ BigInteger.ONE.dlShiftTo(2 * p.t, this.r2);
+ this.mu = this.r2.divide(p);
+ this.m = p;
+}
+
+function barrettConvert(p) {
+ if (p.s < 0 || p.t > 2 * this.m.t) return p.mod(this.m);else {
+ if (p.compareTo(this.m) < 0) return p;else {
+ var n = nbi();
+ return p.copyTo(n), this.reduce(n), n;
+ }
+ }
+}
+
+function barrettRevert(p) {
+ return p;
+}
+
+function barrettReduce(p) {
+ p.drShiftTo(this.m.t - 1, this.r2);
+
+ if (p.t > this.m.t + 1) {
+ p.t = this.m.t + 1;
+ p.clamp();
+ }
+
+ this.mu.multiplyUpperTo(this.r2, this.m.t + 1, this.q3);
+ this.m.multiplyLowerTo(this.q3, this.m.t + 1, this.r2);
+
+ while (p.compareTo(this.r2) < 0) {
+ p.dAddOffset(1, this.m.t + 1);
+ }
+
+ p.subTo(this.r2, p);
+
+ while (p.compareTo(this.m) >= 0) {
+ p.subTo(this.m, p);
+ }
+}
+
+function barrettSqrTo(p, n) {
+ p.squareTo(n);
+ this.reduce(n);
+}
+
+function barrettMulTo(p, n, A) {
+ p.multiplyTo(n, A);
+ this.reduce(A);
+}
+
+Barrett.prototype.convert = barrettConvert;
+Barrett.prototype.revert = barrettRevert;
+Barrett.prototype.reduce = barrettReduce;
+Barrett.prototype.mulTo = barrettMulTo;
+Barrett.prototype.sqrTo = barrettSqrTo;
+
+function bnModPow(n, L) {
+ var g = n.bitLength();
+ var S;
+ var Y = nbv(1);
+ var J;
+ if (g <= 0) return Y;else if (g < 18) {
+ S = 1;
+ } else {
+ if (g < 48) {
+ S = 3;
+ } else {
+ if (g < 144) {
+ S = 4;
+ } else {
+ if (g < 768) {
+ S = 5;
+ } else {
+ S = 6;
+ }
+ }
+ }
+ }
+
+ if (g < 8) {
+ J = new Classic(L);
+ } else {
+ if (L.isEven()) {
+ J = new Barrett(L);
+ } else {
+ J = new Montgomery(L);
+ }
+ }
+
+ var C = new Array();
+ var V = 3;
+ var W = S - 1;
+ var R = (1 << S) - 1;
+ C[1] = J.convert(this);
+
+ if (S > 1) {
+ var B = nbi();
+ J.sqrTo(C[1], B);
+
+ while (V <= R) {
+ C[V] = nbi();
+ J.mulTo(B, C[V - 2], C[V]);
+ V += 2;
+ }
+ }
+
+ var F = n.t - 1;
+ var E;
+ var I = !![];
+ var K = nbi();
+ var T;
+ g = nbits(n[F]) - 1;
+
+ while (F >= 0) {
+ if (g >= W) {
+ E = n[F] >> g - W & R;
+ } else {
+ E = (n[F] & (1 << g + 1) - 1) << W - g;
+ F > 0 && (E |= n[F - 1] >> this.DB + g - W);
+ }
+
+ V = S;
+
+ while ((E & 1) == 0) {
+ E >>= 1;
+ --V;
+ }
+
+ if ((g -= V) < 0) {
+ g += this.DB;
+ --F;
+ }
+
+ if (I) {
+ C[E].copyTo(Y);
+ I = ![];
+ } else {
+ while (V > 1) {
+ J.sqrTo(Y, K);
+ J.sqrTo(K, Y);
+ V -= 2;
+ }
+
+ V > 0 ? J.sqrTo(Y, K) : (T = Y, Y = K, K = T);
+ J.mulTo(K, C[E], Y);
+ }
+
+ while (F >= 0 && (n[F] & 1 << g) == 0) {
+ J.sqrTo(Y, K);
+ T = Y;
+ Y = K;
+ K = T;
+ --g < 0 && (g = this.DB - 1, --F);
+ }
+ }
+
+ return J.revert(Y);
+}
+
+function bnGCD(p) {
+ if (this.s < 0) {
+ var n = this.negate();
+ } else {
+ var n = this.clone();
+ }
+
+ if (p.s < 0) {
+ var a = p.negate();
+ } else {
+ var a = p.clone();
+ }
+
+ if (n.compareTo(a) < 0) {
+ var A = n;
+ n = a;
+ a = A;
+ }
+
+ var L = n.getLowestSetBit();
+ var g = a.getLowestSetBit();
+ if (g < 0) return n;
+
+ if (L < g) {
+ g = L;
+ }
+
+ if (g > 0) {
+ n.rShiftTo(g, n);
+ a.rShiftTo(g, a);
+ }
+
+ while (n.signum() > 0) {
+ (L = n.getLowestSetBit()) > 0 && n.rShiftTo(L, n);
+ (L = a.getLowestSetBit()) > 0 && a.rShiftTo(L, a);
+ n.compareTo(a) >= 0 ? (n.subTo(a, n), n.rShiftTo(1, n)) : (a.subTo(n, a), a.rShiftTo(1, a));
+ }
+
+ return g > 0 && a.lShiftTo(g, a), a;
+}
+
+function bnpModInt(p) {
+ if (p <= 0) return 0;
+ var n = this.DV % p;
+
+ if (this.s < 0) {
+ var A = p - 1;
+ } else {
+ var A = 0;
+ }
+
+ if (this.t > 0) {
+ if (n == 0) A = this[0] % p;else for (var L = this.t - 1; L >= 0; --L) {
+ A = (n * A + this[L]) % p;
+ }
+ }
+
+ return A;
+}
+
+function bnModInverse(p) {
+ var n = p.isEven();
+ if (this.isEven() && n || p.signum() == 0) return BigInteger.ZERO;
+ var c = p.clone();
+ var a = this.clone();
+ var A = nbv(1);
+ var L = nbv(0);
+ var S = nbv(0);
+ var Y = nbv(1);
+
+ while (c.signum() != 0) {
+ while (c.isEven()) {
+ c.rShiftTo(1, c);
+ n ? ((!A.isEven() || !L.isEven()) && (A.addTo(this, A), L.subTo(p, L)), A.rShiftTo(1, A)) : !L.isEven() && L.subTo(p, L);
+ L.rShiftTo(1, L);
+ }
+
+ while (a.isEven()) {
+ a.rShiftTo(1, a);
+ n ? ((!S.isEven() || !Y.isEven()) && (S.addTo(this, S), Y.subTo(p, Y)), S.rShiftTo(1, S)) : !Y.isEven() && Y.subTo(p, Y);
+ Y.rShiftTo(1, Y);
+ }
+
+ if (c.compareTo(a) >= 0) {
+ c.subTo(a, c);
+ n && A.subTo(S, A);
+ L.subTo(Y, L);
+ } else {
+ a.subTo(c, a);
+ n && S.subTo(A, S);
+ Y.subTo(L, Y);
+ }
+ }
+
+ if (a.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO;
+ if (Y.compareTo(p) >= 0) return Y.subtract(p);
+ if (Y.signum() < 0) Y.addTo(p, Y);else return Y;
+ return Y.signum() < 0 ? Y.add(p) : Y;
+}
+
+var lowprimes = [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 lplim = 67108864 / lowprimes[lowprimes.length - 1];
+
+function bnIsProbablePrime(p) {
+ var n;
+ var A = this.abs();
+
+ if (A.t == 1 && A[0] <= lowprimes[lowprimes.length - 1]) {
+ for (n = 0; n < lowprimes.length; ++n) {
+ if (A[0] == lowprimes[n]) return !![];
+ }
+
+ return ![];
+ }
+
+ if (A.isEven()) return ![];
+ n = 1;
+
+ while (n < lowprimes.length) {
+ var L = lowprimes[n];
+ var g = n + 1;
+
+ while (g < lowprimes.length && L < lplim) {
+ L *= lowprimes[g++];
+ }
+
+ L = A.modInt(L);
+
+ while (n < g) {
+ if (L % lowprimes[n++] == 0) return ![];
+ }
+ }
+
+ return A.millerRabin(p);
+}
+
+function bnpMillerRabin(p) {
+ var n = this.subtract(BigInteger.ONE);
+ var a = n.getLowestSetBit();
+ if (a <= 0) return ![];
+ var A = n.shiftRight(a);
+ p = p + 1 >> 1;
+
+ if (p > lowprimes.length) {
+ p = lowprimes.length;
+ }
+
+ var L = nbi();
+
+ for (var S = 0; S < p; ++S) {
+ L.fromInt(lowprimes[Math.floor(Math.random() * lowprimes.length)]);
+ var Y = L.modPow(A, this);
+
+ if (Y.compareTo(BigInteger.ONE) != 0 && Y.compareTo(n) != 0) {
+ var J = 1;
+
+ while (J++ < a && Y.compareTo(n) != 0) {
+ Y = Y.modPowInt(2, this);
+ if (Y.compareTo(BigInteger.ONE) == 0) return ![];
+ }
+
+ if (Y.compareTo(n) != 0) return ![];
+ }
+ }
+
+ return !![];
+}
+
+BigInteger.prototype.chunkSize = bnpChunkSize;
+BigInteger.prototype.toRadix = bnpToRadix;
+BigInteger.prototype.fromRadix = bnpFromRadix;
+BigInteger.prototype.fromNumber = bnpFromNumber;
+BigInteger.prototype.bitwiseTo = bnpBitwiseTo;
+BigInteger.prototype.changeBit = bnpChangeBit;
+BigInteger.prototype.addTo = bnpAddTo;
+BigInteger.prototype.dMultiply = bnpDMultiply;
+BigInteger.prototype.dAddOffset = bnpDAddOffset;
+BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo;
+BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo;
+BigInteger.prototype.modInt = bnpModInt;
+BigInteger.prototype.millerRabin = bnpMillerRabin;
+BigInteger.prototype.clone = bnClone;
+BigInteger.prototype.intValue = bnIntValue;
+BigInteger.prototype.byteValue = bnByteValue;
+BigInteger.prototype.shortValue = bnShortValue;
+BigInteger.prototype.signum = bnSigNum;
+BigInteger.prototype.toByteArray = bnToByteArray;
+BigInteger.prototype.equals = bnEquals;
+BigInteger.prototype.min = bnMin;
+BigInteger.prototype.max = bnMax;
+BigInteger.prototype.and = bnAnd;
+BigInteger.prototype.or = bnOr;
+BigInteger.prototype.xor = bnXor;
+BigInteger.prototype.andNot = bnAndNot;
+BigInteger.prototype.not = bnNot;
+BigInteger.prototype.shiftLeft = bnShiftLeft;
+BigInteger.prototype.shiftRight = bnShiftRight;
+BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit;
+BigInteger.prototype.bitCount = bnBitCount;
+BigInteger.prototype.testBit = bnTestBit;
+BigInteger.prototype.setBit = bnSetBit;
+BigInteger.prototype.clearBit = bnClearBit;
+BigInteger.prototype.flipBit = bnFlipBit;
+BigInteger.prototype.add = bnAdd;
+BigInteger.prototype.subtract = bnSubtract;
+BigInteger.prototype.multiply = bnMultiply;
+BigInteger.prototype.divide = bnDivide;
+BigInteger.prototype.remainder = bnRemainder;
+BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder;
+BigInteger.prototype.modPow = bnModPow;
+BigInteger.prototype.modInverse = bnModInverse;
+BigInteger.prototype.pow = bnPow;
+BigInteger.prototype.gcd = bnGCD;
+BigInteger.prototype.isProbablePrime = bnIsProbablePrime;
+BigInteger.prototype.square = bnSquare;
+
+function Arcfour() {
+ this.i = 0;
+ this.j = 0;
+ this.S = new Array();
+}
+
+function ARC4init(p) {
+ var n;
+ var A;
+ var L;
+
+ for (n = 0; n < 256; ++n) {
+ this.S[n] = n;
+ }
+
+ A = 0;
+
+ for (n = 0; n < 256; ++n) {
+ A = A + this.S[n] + p[n % p.length] & 255;
+ L = this.S[n];
+ this.S[n] = this.S[A];
+ this.S[A] = L;
+ }
+
+ this.i = 0;
+ this.j = 0;
+}
+
+function ARC4next() {
+ var p;
+ return this.i = this.i + 1 & 255, this.j = this.j + this.S[this.i] & 255, p = this.S[this.i], this.S[this.i] = this.S[this.j], this.S[this.j] = p, this.S[p + this.S[this.i] & 255];
+}
+
+Arcfour.prototype.init = ARC4init;
+Arcfour.prototype.next = ARC4next;
+
+function prng_newstate() {
+ return new Arcfour();
+}
+
+var rng_psize = 256;
+var rng_state;
+var rng_pool;
+var rng_pptr;
+
+function rng_seed_int(p) {
+ rng_pool[rng_pptr++] ^= p & 255;
+ rng_pool[rng_pptr++] ^= p >> 8 & 255;
+ rng_pool[rng_pptr++] ^= p >> 16 & 255;
+ rng_pool[rng_pptr++] ^= p >> 24 & 255;
+ rng_pptr >= rng_psize && (rng_pptr -= rng_psize);
+}
+
+function rng_seed_time() {
+ rng_seed_int(new Date().getTime());
+}
+
+if (rng_pool == null) {
+ rng_pool = new Array();
+ rng_pptr = 0;
+ var t;
+
+ if (window !== undefined && (window.crypto !== undefined || window.msCrypto !== undefined)) {
+ var crypto = window.crypto || window.msCrypto;
+
+ if (crypto.getRandomValues) {
+ var ua = new Uint8Array(32);
+ crypto.getRandomValues(ua);
+
+ for (t = 0; t < 32; ++t) {
+ rng_pool[rng_pptr++] = ua[t];
+ }
+ } else {
+ if (navigator.appName == "Netscape" && navigator.appVersion < "5") {
+ var z = window.crypto.random(32);
+
+ for (t = 0; t < z.length; ++t) {
+ rng_pool[rng_pptr++] = z.charCodeAt(t) & 255;
+ }
+ }
+ }
+ }
+
+ while (rng_pptr < rng_psize) {
+ t = Math.floor(65536 * Math.random());
+ rng_pool[rng_pptr++] = t >>> 8;
+ rng_pool[rng_pptr++] = t & 255;
+ }
+
+ rng_pptr = 0;
+ rng_seed_time();
+}
+
+function rng_get_byte() {
+ if (rng_state == null) {
+ rng_seed_time();
+ rng_state = prng_newstate();
+ rng_state.init(rng_pool);
+
+ for (rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr) {
+ rng_pool[rng_pptr] = 0;
+ }
+
+ rng_pptr = 0;
+ }
+
+ return rng_state.next();
+}
+
+function rng_get_bytes(p) {
+ var n;
+
+ for (n = 0; n < p.length; ++n) {
+ p[n] = rng_get_byte();
+ }
+}
+
+function SecureRandom() {}
+
+SecureRandom.prototype.nextBytes = rng_get_bytes;
+
+function parseBigInt(p, n) {
+ return new BigInteger(p, n);
+}
+
+function linebrk(p, n) {
+ var A = "";
+ var L = 0;
+
+ while (L + n < p.length) {
+ A += p.substring(L, L + n) + "\n";
+ L += n;
+ }
+
+ return A + p.substring(L, p.length);
+}
+
+function byte2Hex(p) {
+ return p < 16 ? "0" + p.toString(16) : p.toString(16);
+}
+
+function pkcs1pad2(p, n) {
+ if (n < p.length + 11) {
+ throw "Message too long for RSA";
+ return null;
+ }
+
+ var c = new Array();
+ var A = p.length - 1;
+
+ while (A >= 0 && n > 0) {
+ var L = p.charCodeAt(A--);
+
+ if (L < 128) {
+ c[--n] = L;
+ } else {
+ if (L > 127 && L < 2048) {
+ c[--n] = L & 63 | 128;
+ c[--n] = L >> 6 | 192;
+ } else {
+ c[--n] = L & 63 | 128;
+ c[--n] = L >> 6 & 63 | 128;
+ c[--n] = L >> 12 | 224;
+ }
+ }
+ }
+
+ c[--n] = 0;
+ var S = new SecureRandom();
+ var Y = new Array();
+
+ while (n > 2) {
+ Y[0] = 0;
+
+ while (Y[0] == 0) {
+ S.nextBytes(Y);
+ }
+
+ c[--n] = Y[0];
+ }
+
+ return c[--n] = 2, c[--n] = 0, new BigInteger(c);
+}
+
+function oaep_mgf1_arr(p, n, A) {
+ var L = "";
+ var g = 0;
+
+ while (L.length < n) {
+ L += A(String.fromCharCode.apply(String, p.concat([(g & 4278190080) >> 24, (g & 16711680) >> 16, (g & 65280) >> 8, g & 255])));
+ g += 1;
+ }
+
+ return L;
+}
+
+function oaep_pad(n, A, L, S) {
+ var Y = KJUR.crypto.MessageDigest;
+ var J = KJUR.crypto.Util;
+ var C = null;
+
+ if (!L) {
+ L = "sha1";
+ }
+
+ if (typeof L === "string") {
+ C = Y.getCanonicalAlgName(L);
+ S = Y.getHashLength(C);
+
+ L = function (K) {
+ return hextorstr(J.hashHex(rstrtohex(K), C));
+ };
+ }
+
+ if (n.length + 2 * S + 2 > A) throw "Message too long for RSA";
+ var V = "";
+ var W;
+
+ for (W = 0; W < A - n.length - 2 * S - 2; W += 1) {
+ V += "\0";
+ }
+
+ var R = L("") + V + "" + n;
+ var B = new Array(S);
+ new SecureRandom().nextBytes(B);
+ var F = oaep_mgf1_arr(B, R.length, L);
+ var E = [];
+
+ for (W = 0; W < R.length; W += 1) {
+ E[W] = R.charCodeAt(W) ^ F.charCodeAt(W);
+ }
+
+ var s = oaep_mgf1_arr(E, B.length, L);
+ var I = [0];
+
+ for (W = 0; W < B.length; W += 1) {
+ I[W + 1] = B[W] ^ s.charCodeAt(W);
+ }
+
+ return new BigInteger(I.concat(E));
+}
+
+function RSAKey() {
+ this.n = null;
+ this.e = 0;
+ this.d = null;
+ this.p = null;
+ this.q = null;
+ this.dmp1 = null;
+ this.dmq1 = null;
+ this.coeff = null;
+}
+
+function RSASetPublic(p, n) {
+ this.isPublic = !![];
+ this.isPrivate = ![];
+
+ if (typeof p !== "string") {
+ this.n = p;
+ this.e = n;
+ } else {
+ if (p != null && n != null && p.length > 0 && n.length > 0) {
+ this.n = parseBigInt(p, 16);
+ this.e = parseInt(n, 16);
+ } else throw "Invalid RSA public key";
+ }
+}
+
+function RSADoPublic(p) {
+ return p.modPowInt(this.e, this.n);
+}
+
+function RSAEncrypt(p) {
+ var n = pkcs1pad2(p, this.n.bitLength() + 7 >> 3);
+ if (n == null) return null;
+ var c = this.doPublic(n);
+ if (c == null) return null;
+ var A = c.toString(16);
+ return (A.length & 1) == 0 ? A : "0" + A;
+}
+
+function RSAEncryptOAEP(p, n, c) {
+ var A = oaep_pad(p, this.n.bitLength() + 7 >> 3, n, c);
+ if (A == null) return null;
+ var L = this.doPublic(A);
+ if (L == null) return null;
+ var S = L.toString(16);
+ return (S.length & 1) == 0 ? S : "0" + S;
+}
+
+RSAKey.prototype.doPublic = RSADoPublic;
+RSAKey.prototype.setPublic = RSASetPublic;
+RSAKey.prototype.encrypt = RSAEncrypt;
+RSAKey.prototype.encryptOAEP = RSAEncryptOAEP;
+RSAKey.prototype.type = "RSA";
+
+function pkcs1unpad2(p, n) {
+ var c = p.toByteArray();
+ var A = 0;
+
+ while (A < c.length && c[A] == 0) {
+ ++A;
+ }
+
+ if (c.length - A != n - 1 || c[A] != 2) return null;
+ ++A;
+
+ while (c[A] != 0) {
+ if (++A >= c.length) return null;
+ }
+
+ var L = "";
+
+ while (++A < c.length) {
+ var S = c[A] & 255;
+
+ if (S < 128) {
+ L += String.fromCharCode(S);
+ } else {
+ if (S > 191 && S < 224) {
+ L += String.fromCharCode((S & 31) << 6 | c[A + 1] & 63);
+ ++A;
+ } else {
+ L += String.fromCharCode((S & 15) << 12 | (c[A + 1] & 63) << 6 | c[A + 2] & 63);
+ A += 2;
+ }
+ }
+ }
+
+ return L;
+}
+
+function oaep_mgf1_str(p, n, A) {
+ var L = "";
+ var g = 0;
+
+ while (L.length < n) {
+ L += A(p + String.fromCharCode.apply(String, [(g & 4278190080) >> 24, (g & 16711680) >> 16, (g & 65280) >> 8, g & 255]));
+ g += 1;
+ }
+
+ return L;
+}
+
+function oaep_unpad(n, A, L, S) {
+ var Y = KJUR.crypto.MessageDigest;
+ var J = KJUR.crypto.Util;
+ var C = null;
+
+ if (!L) {
+ L = "sha1";
+ }
+
+ if (typeof L === "string") {
+ C = Y.getCanonicalAlgName(L);
+ S = Y.getHashLength(C);
+
+ L = function (i) {
+ return hextorstr(J.hashHex(rstrtohex(i), C));
+ };
+ }
+
+ n = n.toByteArray();
+ var V;
+
+ for (V = 0; V < n.length; V += 1) {
+ n[V] &= 255;
+ }
+
+ while (n.length < A) {
+ n.unshift(0);
+ }
+
+ n = String.fromCharCode.apply(String, n);
+ if (n.length < 2 * S + 2) throw "Cipher too short";
+ var W = n.substr(1, S);
+ var R = n.substr(S + 1);
+ var B = oaep_mgf1_str(R, S, L);
+ var F = [];
+ var V;
+
+ for (V = 0; V < W.length; V += 1) {
+ F[V] = W.charCodeAt(V) ^ B.charCodeAt(V);
+ }
+
+ var E = oaep_mgf1_str(String.fromCharCode.apply(String, F), n.length - S, L);
+ var I = [];
+
+ for (V = 0; V < R.length; V += 1) {
+ I[V] = R.charCodeAt(V) ^ E.charCodeAt(V);
+ }
+
+ I = String.fromCharCode.apply(String, I);
+ if (I.substr(0, S) !== L("")) throw "Hash mismatch";
+ I = I.substr(S);
+ var K = I.indexOf("");
+
+ if (K != -1) {
+ var T = I.substr(0, K).lastIndexOf("\0");
+ } else {
+ var T = -1;
+ }
+
+ if (T + 1 != K) throw "Malformed data";
+ return I.substr(K + 1);
+}
+
+function RSASetPrivate(p, n, A) {
+ this.isPrivate = !![];
+
+ if (typeof p !== "string") {
+ this.n = p;
+ this.e = n;
+ this.d = A;
+ } else {
+ if (p != null && n != null && p.length > 0 && n.length > 0) {
+ this.n = parseBigInt(p, 16);
+ this.e = parseInt(n, 16);
+ this.d = parseBigInt(A, 16);
+ } else throw "Invalid RSA private key";
+ }
+}
+
+function RSASetPrivateEx(p, n, A, L, S, Y, J, C) {
+ this.isPrivate = !![];
+ this.isPublic = ![];
+ if (p == null) throw "RSASetPrivateEx N == null";
+ if (n == null) throw "RSASetPrivateEx E == null";
+ if (p.length == 0) throw "RSASetPrivateEx N.length == 0";
+ if (n.length == 0) throw "RSASetPrivateEx E.length == 0";
+
+ if (p != null && n != null && p.length > 0 && n.length > 0) {
+ this.n = parseBigInt(p, 16);
+ this.e = parseInt(n, 16);
+ this.d = parseBigInt(A, 16);
+ this.p = parseBigInt(L, 16);
+ this.q = parseBigInt(S, 16);
+ this.dmp1 = parseBigInt(Y, 16);
+ this.dmq1 = parseBigInt(J, 16);
+ this.coeff = parseBigInt(C, 16);
+ } else throw "Invalid RSA private key in RSASetPrivateEx";
+}
+
+function RSAGenerate(p, n) {
+ var A = new SecureRandom();
+ var L = p >> 1;
+ this.e = parseInt(n, 16);
+ var S = new BigInteger(n, 16);
+
+ for (;;) {
+ for (;;) {
+ this.p = new BigInteger(p - L, 1, A);
+ if (this.p.subtract(BigInteger.ONE).gcd(S).compareTo(BigInteger.ONE) == 0 && this.p.isProbablePrime(10)) break;
+ }
+
+ for (;;) {
+ this.q = new BigInteger(L, 1, A);
+ if (this.q.subtract(BigInteger.ONE).gcd(S).compareTo(BigInteger.ONE) == 0 && this.q.isProbablePrime(10)) break;
+ }
+
+ if (this.p.compareTo(this.q) <= 0) {
+ var Y = this.p;
+ this.p = this.q;
+ this.q = Y;
+ }
+
+ var J = this.p.subtract(BigInteger.ONE);
+ var C = this.q.subtract(BigInteger.ONE);
+ var V = J.multiply(C);
+
+ if (V.gcd(S).compareTo(BigInteger.ONE) == 0) {
+ this.n = this.p.multiply(this.q);
+
+ if (this.n.bitLength() == p) {
+ this.d = S.modInverse(V);
+ this.dmp1 = this.d.mod(J);
+ this.dmq1 = this.d.mod(C);
+ this.coeff = this.q.modInverse(this.p);
+ break;
+ }
+ }
+ }
+
+ this.isPrivate = !![];
+}
+
+function RSADoPrivate(p) {
+ if (this.p == null || this.q == null) return p.modPow(this.d, this.n);
+ var n = p.mod(this.p).modPow(this.dmp1, this.p);
+ var A = p.mod(this.q).modPow(this.dmq1, this.q);
+
+ while (n.compareTo(A) < 0) {
+ n = n.add(this.p);
+ }
+
+ return n.subtract(A).multiply(this.coeff).mod(this.p).multiply(this.q).add(A);
+}
+
+function RSADecrypt(p) {
+ if (p.length != Math.ceil(this.n.bitLength() / 4)) throw new Error("wrong ctext length");
+ var n = parseBigInt(p, 16);
+ var c = this.doPrivate(n);
+ if (c == null) return null;
+ return pkcs1unpad2(c, this.n.bitLength() + 7 >> 3);
+}
+
+function RSADecryptOAEP(p, n, c) {
+ if (p.length != Math.ceil(this.n.bitLength() / 4)) throw new Error("wrong ctext length");
+ var A = parseBigInt(p, 16);
+ var L = this.doPrivate(A);
+ if (L == null) return null;
+ return oaep_unpad(L, this.n.bitLength() + 7 >> 3, n, c);
+}
+
+RSAKey.prototype.doPrivate = RSADoPrivate;
+RSAKey.prototype.setPrivate = RSASetPrivate;
+RSAKey.prototype.setPrivateEx = RSASetPrivateEx;
+RSAKey.prototype.generate = RSAGenerate;
+RSAKey.prototype.decrypt = RSADecrypt;
+RSAKey.prototype.decryptOAEP = RSADecryptOAEP;
+
+function ECFieldElementFp(p, n) {
+ this.x = n;
+ this.q = p;
+}
+
+function feFpEquals(p) {
+ if (p == this) return !![];
+ return this.q.equals(p.q) && this.x.equals(p.x);
+}
+
+function feFpToBigInteger() {
+ return this.x;
+}
+
+function feFpNegate() {
+ return new ECFieldElementFp(this.q, this.x.negate().mod(this.q));
+}
+
+function feFpAdd(p) {
+ return new ECFieldElementFp(this.q, this.x.add(p.toBigInteger()).mod(this.q));
+}
+
+function feFpSubtract(p) {
+ return new ECFieldElementFp(this.q, this.x.subtract(p.toBigInteger()).mod(this.q));
+}
+
+function feFpMultiply(p) {
+ return new ECFieldElementFp(this.q, this.x.multiply(p.toBigInteger()).mod(this.q));
+}
+
+function feFpSquare() {
+ return new ECFieldElementFp(this.q, this.x.square().mod(this.q));
+}
+
+function feFpDivide(p) {
+ return new ECFieldElementFp(this.q, this.x.multiply(p.toBigInteger().modInverse(this.q)).mod(this.q));
+}
+
+ECFieldElementFp.prototype.equals = feFpEquals;
+ECFieldElementFp.prototype.toBigInteger = feFpToBigInteger;
+ECFieldElementFp.prototype.negate = feFpNegate;
+ECFieldElementFp.prototype.add = feFpAdd;
+ECFieldElementFp.prototype.subtract = feFpSubtract;
+ECFieldElementFp.prototype.multiply = feFpMultiply;
+ECFieldElementFp.prototype.square = feFpSquare;
+ECFieldElementFp.prototype.divide = feFpDivide;
+
+function ECPointFp(p, n, A, L) {
+ this.curve = p;
+ this.x = n;
+ this.y = A;
+ L == null ? this.z = BigInteger.ONE : this.z = L;
+ this.zinv = null;
+}
+
+function pointFpGetX() {
+ return this.zinv == null && (this.zinv = this.z.modInverse(this.curve.q)), this.curve.fromBigInteger(this.x.toBigInteger().multiply(this.zinv).mod(this.curve.q));
+}
+
+function pointFpGetY() {
+ return this.zinv == null && (this.zinv = this.z.modInverse(this.curve.q)), this.curve.fromBigInteger(this.y.toBigInteger().multiply(this.zinv).mod(this.curve.q));
+}
+
+function pointFpEquals(p) {
+ if (p == this) return !![];
+ if (this.isInfinity()) return p.isInfinity();
+ if (p.isInfinity()) return this.isInfinity();
+ var n;
+ var A;
+ n = p.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(p.z)).mod(this.curve.q);
+ if (!n.equals(BigInteger.ZERO)) return ![];
+ return A = p.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(p.z)).mod(this.curve.q), A.equals(BigInteger.ZERO);
+}
+
+function pointFpIsInfinity() {
+ if (this.x == null && this.y == null) return !![];
+ return this.z.equals(BigInteger.ZERO) && !this.y.toBigInteger().equals(BigInteger.ZERO);
+}
+
+function pointFpNegate() {
+ return new ECPointFp(this.curve, this.x, this.y.negate(), this.z);
+}
+
+function pointFpAdd(A) {
+ if (this.isInfinity()) return A;
+ if (A.isInfinity()) return this;
+ var L = A.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(A.z)).mod(this.curve.q);
+ var S = A.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(A.z)).mod(this.curve.q);
+
+ if (BigInteger.ZERO.equals(S)) {
+ if (BigInteger.ZERO.equals(L)) return this.twice();
+ return this.curve.getInfinity();
+ }
+
+ var Y = new BigInteger("3");
+ var J = this.x.toBigInteger();
+ var b = this.y.toBigInteger();
+ var C = A.x.toBigInteger();
+ var V = A.y.toBigInteger();
+ var W = S.square();
+ var R = W.multiply(S);
+ var B = J.multiply(W);
+ var F = L.square().multiply(this.z);
+ var E = F.subtract(B.shiftLeft(1)).multiply(A.z).subtract(R).multiply(S).mod(this.curve.q);
+ var s = B.multiply(Y).multiply(L).subtract(b.multiply(R)).subtract(F.multiply(L)).multiply(A.z).add(L.multiply(R)).mod(this.curve.q);
+ var I = R.multiply(this.z).multiply(A.z).mod(this.curve.q);
+ return new ECPointFp(this.curve, this.curve.fromBigInteger(E), this.curve.fromBigInteger(s), I);
+}
+
+function pointFpTwice() {
+ if (this.isInfinity()) return this;
+ if (this.y.toBigInteger().signum() == 0) return this.curve.getInfinity();
+ var p = new BigInteger("3");
+ var n = this.x.toBigInteger();
+ var a = this.y.toBigInteger();
+ var A = a.multiply(this.z);
+ var L = A.multiply(a).mod(this.curve.q);
+ var S = this.curve.a.toBigInteger();
+ var Y = n.square().multiply(p);
+
+ if (!BigInteger.ZERO.equals(S)) {
+ Y = Y.add(this.z.square().multiply(S));
+ }
+
+ Y = Y.mod(this.curve.q);
+ var J = Y.square().subtract(n.shiftLeft(3).multiply(L)).shiftLeft(1).multiply(A).mod(this.curve.q);
+ var C = Y.multiply(p).multiply(n).subtract(L.shiftLeft(1)).shiftLeft(2).multiply(L).subtract(Y.square().multiply(Y)).mod(this.curve.q);
+ var V = A.square().multiply(A).shiftLeft(3).mod(this.curve.q);
+ return new ECPointFp(this.curve, this.curve.fromBigInteger(J), this.curve.fromBigInteger(C), V);
+}
+
+function pointFpMultiply(A) {
+ if (this.isInfinity()) return this;
+ if (A.signum() == 0) return this.curve.getInfinity();
+ var L = A;
+ var S = L.multiply(new BigInteger("3"));
+ var Y = this.negate();
+ var J = this;
+ var C = this.curve.q.subtract(A);
+ var V = C.multiply(new BigInteger("3"));
+ var W = new ECPointFp(this.curve, this.x, this.y);
+ var R = W.negate();
+ var B;
+
+ for (B = S.bitLength() - 2; B > 0; --B) {
+ J = J.twice();
+ var F = S.testBit(B);
+ var E = L.testBit(B);
+
+ if (F != E) {
+ J = J.add(F ? this : Y);
+ }
+ }
+
+ for (B = V.bitLength() - 2; B > 0; --B) {
+ W = W.twice();
+ var s = V.testBit(B);
+ var I = C.testBit(B);
+
+ if (s != I) {
+ W = W.add(s ? W : R);
+ }
+ }
+
+ return J;
+}
+
+function pointFpMultiplyTwo(p, n, A) {
+ var L;
+
+ if (p.bitLength() > A.bitLength()) {
+ L = p.bitLength() - 1;
+ } else {
+ L = A.bitLength() - 1;
+ }
+
+ var g = this.curve.getInfinity();
+ var S = this.add(n);
+
+ while (L >= 0) {
+ g = g.twice();
+ p.testBit(L) ? A.testBit(L) ? g = g.add(S) : g = g.add(this) : A.testBit(L) && (g = g.add(n));
+ --L;
+ }
+
+ return g;
+}
+
+ECPointFp.prototype.getX = pointFpGetX;
+ECPointFp.prototype.getY = pointFpGetY;
+ECPointFp.prototype.equals = pointFpEquals;
+ECPointFp.prototype.isInfinity = pointFpIsInfinity;
+ECPointFp.prototype.negate = pointFpNegate;
+ECPointFp.prototype.add = pointFpAdd;
+ECPointFp.prototype.twice = pointFpTwice;
+ECPointFp.prototype.multiply = pointFpMultiply;
+ECPointFp.prototype.multiplyTwo = pointFpMultiplyTwo;
+
+function ECCurveFp(p, n, a) {
+ this.q = p;
+ this.a = this.fromBigInteger(n);
+ this.b = this.fromBigInteger(a);
+ this.infinity = new ECPointFp(this, null, null);
+}
+
+function curveFpGetQ() {
+ return this.q;
+}
+
+function curveFpGetA() {
+ return this.a;
+}
+
+function curveFpGetB() {
+ return this.b;
+}
+
+function curveFpEquals(p) {
+ if (p == this) return !![];
+ return this.q.equals(p.q) && this.a.equals(p.a) && this.b.equals(p.b);
+}
+
+function curveFpGetInfinity() {
+ return this.infinity;
+}
+
+function curveFpFromBigInteger(p) {
+ return new ECFieldElementFp(this.q, p);
+}
+
+function curveFpDecodePointHex(p) {
+ switch (parseInt(p.substr(0, 2), 16)) {
+ case 0:
+ return this.infinity;
+
+ case 2:
+ case 3:
+ return null;
+
+ case 4:
+ case 6:
+ case 7:
+ var n = (p.length - 2) / 2;
+ var A = p.substr(2, n);
+ var L = p.substr(n + 2, n);
+ return new ECPointFp(this, this.fromBigInteger(new BigInteger(A, 16)), this.fromBigInteger(new BigInteger(L, 16)));
+
+ default:
+ return null;
+ }
+}
+
+ECCurveFp.prototype.getQ = curveFpGetQ;
+ECCurveFp.prototype.getA = curveFpGetA;
+ECCurveFp.prototype.getB = curveFpGetB;
+ECCurveFp.prototype.equals = curveFpEquals;
+ECCurveFp.prototype.getInfinity = curveFpGetInfinity;
+ECCurveFp.prototype.fromBigInteger = curveFpFromBigInteger;
+ECCurveFp.prototype.decodePointHex = curveFpDecodePointHex;
+
+ECFieldElementFp.prototype.getByteLength = function () {
+ return Math.floor((this.toBigInteger().bitLength() + 7) / 8);
+};
+
+ECPointFp.prototype.getEncoded = function (p) {
+ var n = function (S, Y) {
+ var J = S.toByteArrayUnsigned();
+ if (Y < J.length) J = J.slice(J.length - Y);else while (Y > J.length) {
+ J.unshift(0);
+ }
+ return J;
+ };
+
+ var A = this.getX().toBigInteger();
+ var L = this.getY().toBigInteger();
+ var g = n(A, 32);
+ return p ? L.isEven() ? g.unshift(2) : g.unshift(3) : (g.unshift(4), g = g.concat(n(L, 32))), g;
+};
+
+ECPointFp.decodeFrom = function (p, n) {
+ var A = n[0];
+ var L = n.length - 1;
+ var S = n.slice(1, 1 + L / 2);
+ var Y = n.slice(1 + L / 2, 1 + L);
+ S.unshift(0);
+ Y.unshift(0);
+ var J = new BigInteger(S);
+ var C = new BigInteger(Y);
+ return new ECPointFp(p, p.fromBigInteger(J), p.fromBigInteger(C));
+};
+
+ECPointFp.decodeFromHex = function (p, n) {
+ var A = n.substr(0, 2);
+ var L = n.length - 2;
+ var S = n.substr(2, L / 2);
+ var Y = n.substr(2 + L / 2, L / 2);
+ var J = new BigInteger(S, 16);
+ var C = new BigInteger(Y, 16);
+ return new ECPointFp(p, p.fromBigInteger(J), p.fromBigInteger(C));
+};
+
+ECPointFp.prototype.add2D = function (p) {
+ if (this.isInfinity()) return p;
+ if (p.isInfinity()) return this;
+
+ if (this.x.equals(p.x)) {
+ if (this.y.equals(p.y)) return this.twice();
+ return this.curve.getInfinity();
+ }
+
+ var n = p.x.subtract(this.x);
+ var A = p.y.subtract(this.y);
+ var L = A.divide(n);
+ var S = L.square().subtract(this.x).subtract(p.x);
+ var Y = L.multiply(this.x.subtract(S)).subtract(this.y);
+ return new ECPointFp(this.curve, S, Y);
+};
+
+ECPointFp.prototype.twice2D = function () {
+ if (this.isInfinity()) return this;
+ if (this.y.toBigInteger().signum() == 0) return this.curve.getInfinity();
+ var p = this.curve.fromBigInteger(BigInteger.valueOf(2));
+ var n = this.curve.fromBigInteger(BigInteger.valueOf(3));
+ var A = this.x.square().multiply(n).add(this.curve.a).divide(this.y.multiply(p));
+ var L = A.square().subtract(this.x.multiply(p));
+ var g = A.multiply(this.x.subtract(L)).subtract(this.y);
+ return new ECPointFp(this.curve, L, g);
+};
+
+ECPointFp.prototype.multiply2D = function (p) {
+ if (this.isInfinity()) return this;
+ if (p.signum() == 0) return this.curve.getInfinity();
+ var n = p;
+ var A = n.multiply(new BigInteger("3"));
+ var L = this.negate();
+ var S = this;
+ var Y;
+
+ for (Y = A.bitLength() - 2; Y > 0; --Y) {
+ S = S.twice();
+ var J = A.testBit(Y);
+ var C = n.testBit(Y);
+
+ if (J != C) {
+ S = S.add2D(J ? this : L);
+ }
+ }
+
+ return S;
+};
+
+ECPointFp.prototype.isOnCurve = function () {
+ var p = this.getX().toBigInteger();
+ var n = this.getY().toBigInteger();
+ var a = this.curve.getA().toBigInteger();
+ var A = this.curve.getB().toBigInteger();
+ var L = this.curve.getQ();
+ var S = n.multiply(n).mod(L);
+ var Y = p.multiply(p).multiply(p).add(a.multiply(p)).add(A).mod(L);
+ return S.equals(Y);
+};
+
+ECPointFp.prototype.toString = function () {
+ return "(" + this.getX().toBigInteger().toString() + "," + this.getY().toBigInteger().toString() + ")";
+};
+
+ECPointFp.prototype.validate = function () {
+ var p = this.curve.getQ();
+ if (this.isInfinity()) throw new Error("Point is at infinity.");
+ var n = this.getX().toBigInteger();
+ var A = this.getY().toBigInteger();
+ if (n.compareTo(BigInteger.ONE) < 0 || n.compareTo(p.subtract(BigInteger.ONE)) > 0) throw new Error("x coordinate out of bounds");
+ if (A.compareTo(BigInteger.ONE) < 0 || A.compareTo(p.subtract(BigInteger.ONE)) > 0) throw new Error("y coordinate out of bounds");
+ if (!this.isOnCurve()) throw new Error("Point is not on the curve.");
+ if (this.multiply(p).isInfinity()) throw new Error("Point is not a scalar multiple of G.");
+ return !![];
+};
+
+var jsonParse = function () {
+ var p = "(?:-?\\b(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\\b)";
+ var n = "(?:[^\\0-\\x08\\x0a-\\x1f\"\\\\]|\\\\(?:[\"/\\\\bfnrt]|u[0-9A-Fa-f]{4}))";
+ var A = "(?:\"" + n + "*\")";
+ var L = new RegExp("(?:false|true|null|[\\{\\}\\[\\]]|" + p + "|" + A + ")", "g");
+ var S = new RegExp("\\\\(?:([^u])|u(.{4}))", "g");
+ var Y = {
+ "\"": "\"",
+ "/": "/",
+ "\\": "\\",
+ "b": "\b",
+ "f": "\f",
+ "n": "\n",
+ "r": "\r",
+ "t": "\t"
+ };
+
+ function J(R, B, F) {
+ return B ? Y[B] : String.fromCharCode(parseInt(F, 16));
+ }
+
+ var C = new String("");
+ var V = "\\";
+ var W = {
+ "{": Object,
+ "[": Array
+ };
+ var l = Object.hasOwnProperty;
+ return function (R, B) {
+ var F = R.match(L);
+ var E;
+ var I = F[0];
+ var K = ![];
+
+ if ("{" === I) {
+ E = {};
+ } else {
+ if ("[" === I) {
+ E = [];
+ } else {
+ E = [];
+ K = !![];
+ }
+ }
+
+ var T;
+ var Z = [E];
+
+ for (var M = 1 - K, U = F.length; M < U; ++M) {
+ I = F[M];
+ var H;
+
+ switch (I.charCodeAt(0)) {
+ default:
+ H = Z[0];
+ H[T || H.length] = +I;
+ T = void 0;
+ break;
+
+ case 34:
+ I = I.substring(1, I.length - 1);
+
+ if (I.indexOf(V) !== -1) {
+ I = I.replace(S, J);
+ }
+
+ H = Z[0];
+
+ if (!T) {
+ if (H instanceof Array) T = H.length;else {
+ T = I || C;
+ break;
+ }
+ }
+
+ H[T] = I;
+ T = void 0;
+ break;
+
+ case 91:
+ H = Z[0];
+ Z.unshift(H[T || H.length] = []);
+ T = void 0;
+ break;
+
+ case 93:
+ Z.shift();
+ break;
+
+ case 102:
+ H = Z[0];
+ H[T || H.length] = ![];
+ T = void 0;
+ break;
+
+ case 110:
+ H = Z[0];
+ H[T || H.length] = null;
+ T = void 0;
+ break;
+
+ case 116:
+ H = Z[0];
+ H[T || H.length] = !![];
+ T = void 0;
+ break;
+
+ case 123:
+ H = Z[0];
+ Z.unshift(H[T || H.length] = {});
+ T = void 0;
+ break;
+
+ case 125:
+ Z.shift();
+ break;
+ }
+ }
+
+ if (K) {
+ if (Z.length !== 1) throw new Error();
+ E = E[0];
+ } else {
+ if (Z.length) throw new Error();
+ }
+
+ if (B) {
+ var O = function (X, G) {
+ var N = X[G];
+
+ if (N && typeof N === "object") {
+ var Q = null;
+
+ for (var P in N) {
+ if (l.call(N, P) && N !== X) {
+ var p0 = O(N, P);
+
+ if (p0 !== void 0) {
+ N[P] = p0;
+ } else {
+ !Q && (Q = []);
+ Q.push(P);
+ }
+ }
+ }
+
+ if (Q) for (var p1 = Q.length; --p1 >= 0;) {
+ delete N[Q[p1]];
+ }
+ }
+
+ return B.call(X, G, N);
+ };
+
+ E = O({
+ "": E
+ }, "");
+ }
+
+ return E;
+ };
+}();
+
+if (typeof KJUR == "undefined" || !KJUR) {
+ KJUR = {};
+}
+
+if (typeof KJUR.asn1 == "undefined" || !KJUR.asn1) {
+ KJUR.asn1 = {};
+}
+
+KJUR.asn1.ASN1Util = new function () {
+ this.integerToByteHex = function (p) {
+ var n = p.toString(16);
+ return n.length % 2 == 1 && (n = "0" + n), n;
+ };
+
+ this.bigIntToMinTwosComplementsHex = function (p) {
+ var n = p.toString(16);
+ if (n.substr(0, 1) != "-") {
+ if (n.length % 2 == 1) {
+ n = "0" + n;
+ } else {
+ if (!n.match(/^[0-7]/)) {
+ n = "00" + n;
+ }
+ }
+ } else {
+ var A = n.substr(1);
+ var L = A.length;
+
+ if (L % 2 == 1) {
+ L += 1;
+ } else {
+ if (!n.match(/^[0-7]/)) {
+ L += 2;
+ }
+ }
+
+ var S = "";
+
+ for (var Y = 0; Y < L; Y++) {
+ S += "f";
+ }
+
+ var J = new BigInteger(S, 16);
+ var C = J.xor(p).add(BigInteger.ONE);
+ n = C.toString(16).replace(/^-/, "");
+ }
+ return n;
+ };
+
+ this.getPEMStringFromHex = function (p, n) {
+ return hextopem(p, n);
+ };
+
+ this.newObject = function (a) {
+ var L = KJUR;
+ var S = L.asn1;
+ var Y = S.DERBoolean;
+ var J = S.DERInteger;
+ var V = S.DERBitString;
+ var W = S.DEROctetString;
+ var R = S.DERNull;
+ var I = S.DERObjectIdentifier;
+ var K = S.DEREnumerated;
+ var T = S.DERUTF8String;
+ var i = S.DERNumericString;
+ var Z = S.DERPrintableString;
+ var M = S.DERTeletexString;
+ var U = S.DERIA5String;
+ var H = S.DERUTCTime;
+ var O = S.DERGeneralizedTime;
+ var X = S.DERSequence;
+ var G = S.DERSet;
+ var N = S.DERTaggedObject;
+ var Q = S.ASN1Util.newObject;
+ var P = Object.keys(a);
+ if (P.length != 1) throw "key of param shall be only one.";
+ var p0 = P[0];
+ if (":bool:int:bitstr:octstr:null:oid:enum:utf8str:numstr:prnstr:telstr:ia5str:utctime:gentime:seq:set:tag:".indexOf(":" + p0 + ":") == -1) throw "undefined key: " + p0;
+ if (p0 == "bool") return new Y(a[p0]);
+ if (p0 == "int") return new J(a[p0]);
+ if (p0 == "bitstr") return new V(a[p0]);
+ if (p0 == "octstr") return new W(a[p0]);
+ if (p0 == "null") return new R(a[p0]);
+ if (p0 == "oid") return new I(a[p0]);
+ if (p0 == "enum") return new K(a[p0]);
+ if (p0 == "utf8str") return new T(a[p0]);
+ if (p0 == "numstr") return new i(a[p0]);
+ if (p0 == "prnstr") return new Z(a[p0]);
+ if (p0 == "telstr") return new M(a[p0]);
+ if (p0 == "ia5str") return new U(a[p0]);
+ if (p0 == "utctime") return new H(a[p0]);
+ if (p0 == "gentime") return new O(a[p0]);
+
+ if (p0 == "seq") {
+ var p1 = a[p0];
+ var p2 = [];
+
+ for (var p3 = 0; p3 < p1.length; p3++) {
+ var p4 = Q(p1[p3]);
+ p2.push(p4);
+ }
+
+ return new X({
+ "array": p2
+ });
+ }
+
+ if (p0 == "set") {
+ var p1 = a[p0];
+ var p2 = [];
+
+ for (var p3 = 0; p3 < p1.length; p3++) {
+ var p4 = Q(p1[p3]);
+ p2.push(p4);
+ }
+
+ return new G({
+ "array": p2
+ });
+ }
+
+ if (p0 == "tag") {
+ var p5 = a[p0];
+
+ if (Object.prototype.toString.call(p5) === "[object Array]" && p5.length == 3) {
+ var p6 = Q(p5[2]);
+ return new N({
+ "tag": p5[0],
+ "explicit": p5[1],
+ "obj": p6
+ });
+ } else {
+ var p7 = {};
+
+ if (p5.explicit !== undefined) {
+ p7.explicit = p5.explicit;
+ }
+
+ if (p5.tag !== undefined) {
+ p7.tag = p5.tag;
+ }
+
+ if (p5.obj === undefined) throw "obj shall be specified for 'tag'.";
+ return p7.obj = Q(p5.obj), new N(p7);
+ }
+ }
+ };
+
+ this.jsonToASN1HEX = function (p) {
+ var n = this.newObject(p);
+ return n.getEncodedHex();
+ };
+}();
+
+KJUR.asn1.ASN1Util.oidHexToInt = function (p) {
+ var n = "";
+ var A = parseInt(p.substr(0, 2), 16);
+ var L = Math.floor(A / 40);
+ var S = A % 40;
+ var n = L + "." + S;
+ var Y = "";
+
+ for (var J = 2; J < p.length; J += 2) {
+ var C = parseInt(p.substr(J, 2), 16);
+ var V = ("00000000" + C.toString(2)).slice(-8);
+ Y = Y + V.substr(1, 7);
+
+ if (V.substr(0, 1) == "0") {
+ var W = new BigInteger(Y, 2);
+ n = n + "." + W.toString(10);
+ Y = "";
+ }
+ }
+
+ return n;
+};
+
+KJUR.asn1.ASN1Util.oidIntToHex = function (p) {
+ var n = function (J) {
+ var C = J.toString(16);
+ return C.length == 1 && (C = "0" + C), C;
+ };
+
+ var a = function (J) {
+ var C = "";
+ var V = new BigInteger(J, 10);
+ var W = V.toString(2);
+ var R = 7 - W.length % 7;
+
+ if (R == 7) {
+ R = 0;
+ }
+
+ var B = "";
+
+ for (var F = 0; F < R; F++) {
+ B += "0";
+ }
+
+ W = B + W;
+
+ for (var F = 0; F < W.length - 1; F += 7) {
+ var E = W.substr(F, 7);
+ F != W.length - 7 && (E = "1" + E);
+ C += n(parseInt(E, 2));
+ }
+
+ return C;
+ };
+
+ if (!p.match(/^[0-9.]+$/)) throw "malformed oid string: " + p;
+ var A = "";
+ var L = p.split(".");
+ var S = parseInt(L[0]) * 40 + parseInt(L[1]);
+ A += n(S);
+ L.splice(0, 2);
+
+ for (var Y = 0; Y < L.length; Y++) {
+ A += a(L[Y]);
+ }
+
+ return A;
+};
+
+KJUR.asn1.ASN1Object = function () {
+ var p = !![];
+ var n = null;
+ var A = "00";
+ var L = "00";
+ var g = "";
+
+ this.getLengthHexFromValue = function () {
+ if (typeof this.hV == "undefined" || this.hV == null) throw "this.hV is null or undefined.";
+ if (this.hV.length % 2 == 1) throw "value hex must be even length: n=" + g.length + ",v=" + this.hV;
+ var S = this.hV.length / 2;
+ var Y = S.toString(16);
+
+ if (Y.length % 2 == 1) {
+ Y = "0" + Y;
+ }
+
+ if (S < 128) return Y;else {
+ var J = Y.length / 2;
+ if (J > 15) throw "ASN.1 length too long to represent by 8x: n = " + S.toString(16);
+ var C = 128 + J;
+ return C.toString(16) + Y;
+ }
+ };
+
+ this.getEncodedHex = function () {
+ return (this.hTLV == null || this.isModified) && (this.hV = this.getFreshValueHex(), this.hL = this.getLengthHexFromValue(), this.hTLV = this.hT + this.hL + this.hV, this.isModified = ![]), this.hTLV;
+ };
+
+ this.getValueHex = function () {
+ return this.getEncodedHex(), this.hV;
+ };
+
+ this.getFreshValueHex = function () {
+ return "";
+ };
+};
+
+KJUR.asn1.DERAbstractString = function (p) {
+ KJUR.asn1.DERAbstractString.superclass.constructor.call(this);
+ var n = null;
+ var A = null;
+
+ this.getString = function () {
+ return this.s;
+ };
+
+ this.setString = function (L) {
+ this.hTLV = null;
+ this.isModified = !![];
+ this.s = L;
+ this.hV = utf8tohex(this.s).toLowerCase();
+ };
+
+ this.setStringHex = function (L) {
+ this.hTLV = null;
+ this.isModified = !![];
+ this.s = null;
+ this.hV = L;
+ };
+
+ this.getFreshValueHex = function () {
+ return this.hV;
+ };
+
+ typeof p != "undefined" && (typeof p == "string" ? this.setString(p) : typeof p.str != "undefined" ? this.setString(p.str) : typeof p.hex != "undefined" && this.setStringHex(p.hex));
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERAbstractString, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.DERAbstractTime = function (p) {
+ KJUR.asn1.DERAbstractTime.superclass.constructor.call(this);
+ var n = null;
+ var A = null;
+
+ this.localDateToUTC = function (L) {
+ var S = L.getTime() + L.getTimezoneOffset() * 60000;
+ var Y = new Date(S);
+ return Y;
+ };
+
+ this.formatDate = function (L, S, Y) {
+ var J = this.zeroPadding;
+ var C = this.localDateToUTC(L);
+ var V = String(C.getFullYear());
+
+ if (S == "utc") {
+ V = V.substr(2, 2);
+ }
+
+ var W = J(String(C.getMonth() + 1), 2);
+ var R = J(String(C.getDate()), 2);
+ var B = J(String(C.getHours()), 2);
+ var F = J(String(C.getMinutes()), 2);
+ var E = J(String(C.getSeconds()), 2);
+ var s = V + W + R + B + F + E;
+
+ if (Y === !![]) {
+ var I = C.getMilliseconds();
+
+ if (I != 0) {
+ var K = J(String(I), 3);
+ K = K.replace(/[0]+$/, "");
+ s = s + "." + K;
+ }
+ }
+
+ return s + "Z";
+ };
+
+ this.zeroPadding = function (L, g) {
+ if (L.length >= g) return L;
+ return new Array(g - L.length + 1).join("0") + L;
+ };
+
+ this.getString = function () {
+ return this.s;
+ };
+
+ this.setString = function (L) {
+ this.hTLV = null;
+ this.isModified = !![];
+ this.s = L;
+ this.hV = stohex(L);
+ };
+
+ this.setByDateValue = function (L, S, Y, J, C, V) {
+ var W = new Date(Date.UTC(L, S - 1, Y, J, C, V, 0));
+ this.setByDate(W);
+ };
+
+ this.getFreshValueHex = function () {
+ return this.hV;
+ };
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERAbstractTime, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.DERAbstractStructured = function (p) {
+ KJUR.asn1.DERAbstractString.superclass.constructor.call(this);
+ var n = null;
+
+ this.setByASN1ObjectArray = function (A) {
+ this.hTLV = null;
+ this.isModified = !![];
+ this.asn1Array = A;
+ };
+
+ this.appendASN1Object = function (A) {
+ this.hTLV = null;
+ this.isModified = !![];
+ this.asn1Array.push(A);
+ };
+
+ this.asn1Array = new Array();
+ typeof p != "undefined" && typeof p.array != "undefined" && (this.asn1Array = p.array);
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERAbstractStructured, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.DERBoolean = function () {
+ KJUR.asn1.DERBoolean.superclass.constructor.call(this);
+ this.hT = "01";
+ this.hTLV = "0101ff";
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERBoolean, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.DERInteger = function (p) {
+ KJUR.asn1.DERInteger.superclass.constructor.call(this);
+ this.hT = "02";
+
+ this.setByBigInteger = function (n) {
+ this.hTLV = null;
+ this.isModified = !![];
+ this.hV = KJUR.asn1.ASN1Util.bigIntToMinTwosComplementsHex(n);
+ };
+
+ this.setByInteger = function (n) {
+ var A = new BigInteger(String(n), 10);
+ this.setByBigInteger(A);
+ };
+
+ this.setValueHex = function (n) {
+ this.hV = n;
+ };
+
+ this.getFreshValueHex = function () {
+ return this.hV;
+ };
+
+ typeof p != "undefined" && (typeof p.bigint != "undefined" ? this.setByBigInteger(p.bigint) : typeof p.int != "undefined" ? this.setByInteger(p.int) : typeof p == "number" ? this.setByInteger(p) : typeof p.hex != "undefined" && this.setValueHex(p.hex));
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERInteger, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.DERBitString = function (p) {
+ if (p !== undefined && typeof p.obj !== "undefined") {
+ var n = KJUR.asn1.ASN1Util.newObject(p.obj);
+ p.hex = "00" + n.getEncodedHex();
+ }
+
+ KJUR.asn1.DERBitString.superclass.constructor.call(this);
+ this.hT = "03";
+
+ this.setHexValueIncludingUnusedBits = function (A) {
+ this.hTLV = null;
+ this.isModified = !![];
+ this.hV = A;
+ };
+
+ this.setUnusedBitsAndHexValue = function (A, L) {
+ if (A < 0 || 7 < A) throw "unused bits shall be from 0 to 7: u = " + A;
+ var g = "0" + A;
+ this.hTLV = null;
+ this.isModified = !![];
+ this.hV = g + L;
+ };
+
+ this.setByBinaryString = function (A) {
+ A = A.replace(/0+$/, "");
+ var L = 8 - A.length % 8;
+
+ if (L == 8) {
+ L = 0;
+ }
+
+ for (var S = 0; S <= L; S++) {
+ A += "0";
+ }
+
+ var Y = "";
+
+ for (var S = 0; S < A.length - 1; S += 8) {
+ var J = A.substr(S, 8);
+ var C = parseInt(J, 2).toString(16);
+ C.length == 1 && (C = "0" + C);
+ Y += C;
+ }
+
+ this.hTLV = null;
+ this.isModified = !![];
+ this.hV = "0" + L + Y;
+ };
+
+ this.setByBooleanArray = function (A) {
+ var L = "";
+
+ for (var g = 0; g < A.length; g++) {
+ if (A[g] == !![]) {
+ L += "1";
+ } else {
+ L += "0";
+ }
+ }
+
+ this.setByBinaryString(L);
+ };
+
+ this.newFalseArray = function (A) {
+ var L = new Array(A);
+
+ for (var g = 0; g < A; g++) {
+ L[g] = ![];
+ }
+
+ return L;
+ };
+
+ this.getFreshValueHex = function () {
+ return this.hV;
+ };
+
+ typeof p != "undefined" && (typeof p == "string" && p.toLowerCase().match(/^[0-9a-f]+$/) ? this.setHexValueIncludingUnusedBits(p) : typeof p.hex != "undefined" ? this.setHexValueIncludingUnusedBits(p.hex) : typeof p.bin != "undefined" ? this.setByBinaryString(p.bin) : typeof p.array != "undefined" && this.setByBooleanArray(p.array));
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERBitString, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.DEROctetString = function (p) {
+ if (p !== undefined && typeof p.obj !== "undefined") {
+ var n = KJUR.asn1.ASN1Util.newObject(p.obj);
+ p.hex = n.getEncodedHex();
+ }
+
+ KJUR.asn1.DEROctetString.superclass.constructor.call(this, p);
+ this.hT = "04";
+};
+
+YAHOO.lang.extend(KJUR.asn1.DEROctetString, KJUR.asn1.DERAbstractString);
+
+KJUR.asn1.DERNull = function () {
+ KJUR.asn1.DERNull.superclass.constructor.call(this);
+ this.hT = "05";
+ this.hTLV = "0500";
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERNull, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.DERObjectIdentifier = function (p) {
+ var n = function (L) {
+ var g = L.toString(16);
+ return g.length == 1 && (g = "0" + g), g;
+ };
+
+ var A = function (L) {
+ var S = "";
+ var Y = new BigInteger(L, 10);
+ var J = Y.toString(2);
+ var C = 7 - J.length % 7;
+
+ if (C == 7) {
+ C = 0;
+ }
+
+ var V = "";
+
+ for (var W = 0; W < C; W++) {
+ V += "0";
+ }
+
+ J = V + J;
+
+ for (var W = 0; W < J.length - 1; W += 7) {
+ var R = J.substr(W, 7);
+ W != J.length - 7 && (R = "1" + R);
+ S += n(parseInt(R, 2));
+ }
+
+ return S;
+ };
+
+ KJUR.asn1.DERObjectIdentifier.superclass.constructor.call(this);
+ this.hT = "06";
+
+ this.setValueHex = function (L) {
+ this.hTLV = null;
+ this.isModified = !![];
+ this.s = null;
+ this.hV = L;
+ };
+
+ this.setValueOidString = function (L) {
+ if (!L.match(/^[0-9.]+$/)) throw "malformed oid string: " + L;
+ var S = "";
+ var Y = L.split(".");
+ var J = parseInt(Y[0]) * 40 + parseInt(Y[1]);
+ S += n(J);
+ Y.splice(0, 2);
+
+ for (var C = 0; C < Y.length; C++) {
+ S += A(Y[C]);
+ }
+
+ this.hTLV = null;
+ this.isModified = !![];
+ this.s = null;
+ this.hV = S;
+ };
+
+ this.setValueName = function (L) {
+ var g = KJUR.asn1.x509.OID.name2oid(L);
+ if (g !== "") this.setValueOidString(g);else throw "DERObjectIdentifier oidName undefined: " + L;
+ };
+
+ this.getFreshValueHex = function () {
+ return this.hV;
+ };
+
+ p !== undefined && (typeof p === "string" ? p.match(/^[0-2].[0-9.]+$/) ? this.setValueOidString(p) : this.setValueName(p) : p.oid !== undefined ? this.setValueOidString(p.oid) : p.hex !== undefined ? this.setValueHex(p.hex) : p.name !== undefined && this.setValueName(p.name));
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERObjectIdentifier, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.DEREnumerated = function (p) {
+ KJUR.asn1.DEREnumerated.superclass.constructor.call(this);
+ this.hT = "0a";
+
+ this.setByBigInteger = function (n) {
+ this.hTLV = null;
+ this.isModified = !![];
+ this.hV = KJUR.asn1.ASN1Util.bigIntToMinTwosComplementsHex(n);
+ };
+
+ this.setByInteger = function (n) {
+ var A = new BigInteger(String(n), 10);
+ this.setByBigInteger(A);
+ };
+
+ this.setValueHex = function (n) {
+ this.hV = n;
+ };
+
+ this.getFreshValueHex = function () {
+ return this.hV;
+ };
+
+ typeof p != "undefined" && (typeof p.int != "undefined" ? this.setByInteger(p.int) : typeof p == "number" ? this.setByInteger(p) : typeof p.hex != "undefined" && this.setValueHex(p.hex));
+};
+
+YAHOO.lang.extend(KJUR.asn1.DEREnumerated, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.DERUTF8String = function (p) {
+ KJUR.asn1.DERUTF8String.superclass.constructor.call(this, p);
+ this.hT = "0c";
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERUTF8String, KJUR.asn1.DERAbstractString);
+
+KJUR.asn1.DERNumericString = function (p) {
+ KJUR.asn1.DERNumericString.superclass.constructor.call(this, p);
+ this.hT = "12";
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERNumericString, KJUR.asn1.DERAbstractString);
+
+KJUR.asn1.DERPrintableString = function (p) {
+ KJUR.asn1.DERPrintableString.superclass.constructor.call(this, p);
+ this.hT = "13";
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERPrintableString, KJUR.asn1.DERAbstractString);
+
+KJUR.asn1.DERTeletexString = function (p) {
+ KJUR.asn1.DERTeletexString.superclass.constructor.call(this, p);
+ this.hT = "14";
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERTeletexString, KJUR.asn1.DERAbstractString);
+
+KJUR.asn1.DERIA5String = function (p) {
+ KJUR.asn1.DERIA5String.superclass.constructor.call(this, p);
+ this.hT = "16";
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERIA5String, KJUR.asn1.DERAbstractString);
+
+KJUR.asn1.DERUTCTime = function (p) {
+ KJUR.asn1.DERUTCTime.superclass.constructor.call(this, p);
+ this.hT = "17";
+
+ this.setByDate = function (n) {
+ this.hTLV = null;
+ this.isModified = !![];
+ this.date = n;
+ this.s = this.formatDate(this.date, "utc");
+ this.hV = stohex(this.s);
+ };
+
+ this.getFreshValueHex = function () {
+ return typeof this.date == "undefined" && typeof this.s == "undefined" && (this.date = new Date(), this.s = this.formatDate(this.date, "utc"), this.hV = stohex(this.s)), this.hV;
+ };
+
+ p !== undefined && (p.str !== undefined ? this.setString(p.str) : typeof p == "string" && p.match(/^[0-9]{12}Z$/) ? this.setString(p) : p.hex !== undefined ? this.setStringHex(p.hex) : p.date !== undefined && this.setByDate(p.date));
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERUTCTime, KJUR.asn1.DERAbstractTime);
+
+KJUR.asn1.DERGeneralizedTime = function (p) {
+ KJUR.asn1.DERGeneralizedTime.superclass.constructor.call(this, p);
+ this.hT = "18";
+ this.withMillis = ![];
+
+ this.setByDate = function (n) {
+ this.hTLV = null;
+ this.isModified = !![];
+ this.date = n;
+ this.s = this.formatDate(this.date, "gen", this.withMillis);
+ this.hV = stohex(this.s);
+ };
+
+ this.getFreshValueHex = function () {
+ return this.date === undefined && this.s === undefined && (this.date = new Date(), this.s = this.formatDate(this.date, "gen", this.withMillis), this.hV = stohex(this.s)), this.hV;
+ };
+
+ p !== undefined && (p.str !== undefined ? this.setString(p.str) : typeof p == "string" && p.match(/^[0-9]{14}Z$/) ? this.setString(p) : p.hex !== undefined ? this.setStringHex(p.hex) : p.date !== undefined && this.setByDate(p.date), p.millis === !![] && (this.withMillis = !![]));
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERGeneralizedTime, KJUR.asn1.DERAbstractTime);
+
+KJUR.asn1.DERSequence = function (p) {
+ KJUR.asn1.DERSequence.superclass.constructor.call(this, p);
+ this.hT = "30";
+
+ this.getFreshValueHex = function () {
+ var n = "";
+
+ for (var A = 0; A < this.asn1Array.length; A++) {
+ var L = this.asn1Array[A];
+ n += L.getEncodedHex();
+ }
+
+ return this.hV = n, this.hV;
+ };
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERSequence, KJUR.asn1.DERAbstractStructured);
+
+KJUR.asn1.DERSet = function (p) {
+ KJUR.asn1.DERSet.superclass.constructor.call(this, p);
+ this.hT = "31";
+ this.sortFlag = !![];
+
+ this.getFreshValueHex = function () {
+ var n = new Array();
+
+ for (var A = 0; A < this.asn1Array.length; A++) {
+ var L = this.asn1Array[A];
+ n.push(L.getEncodedHex());
+ }
+
+ return this.sortFlag == !![] && n.sort(), this.hV = n.join(""), this.hV;
+ };
+
+ typeof p != "undefined" && typeof p.sortflag != "undefined" && p.sortflag == ![] && (this.sortFlag = ![]);
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERSet, KJUR.asn1.DERAbstractStructured);
+
+KJUR.asn1.DERTaggedObject = function (p) {
+ KJUR.asn1.DERTaggedObject.superclass.constructor.call(this);
+ this.hT = "a0";
+ this.hV = "";
+ this.isExplicit = !![];
+ this.asn1Object = null;
+
+ this.setASN1Object = function (n, A, L) {
+ this.hT = A;
+ this.isExplicit = n;
+ this.asn1Object = L;
+ this.isExplicit ? (this.hV = this.asn1Object.getEncodedHex(), this.hTLV = null, this.isModified = !![]) : (this.hV = null, this.hTLV = L.getEncodedHex(), this.hTLV = this.hTLV.replace(/^../, A), this.isModified = ![]);
+ };
+
+ this.getFreshValueHex = function () {
+ return this.hV;
+ };
+
+ typeof p != "undefined" && (typeof p.tag != "undefined" && (this.hT = p.tag), typeof p.explicit != "undefined" && (this.isExplicit = p.explicit), typeof p.obj != "undefined" && (this.asn1Object = p.obj, this.setASN1Object(this.isExplicit, this.hT, this.asn1Object)));
+};
+
+YAHOO.lang.extend(KJUR.asn1.DERTaggedObject, KJUR.asn1.ASN1Object);
+var ASN1HEX = new function () {}();
+
+ASN1HEX.getLblen = function (p, n) {
+ if (p.substr(n + 2, 1) != "8") return 1;
+ var A = parseInt(p.substr(n + 3, 1));
+ if (A == 0) return -1;
+ if (0 < A && A < 10) return A + 1;
+ return -2;
+};
+
+ASN1HEX.getL = function (p, n) {
+ var A = ASN1HEX.getLblen(p, n);
+ if (A < 1) return "";
+ return p.substr(n + 2, A * 2);
+};
+
+ASN1HEX.getVblen = function (p, n) {
+ var A;
+ var L;
+ A = ASN1HEX.getL(p, n);
+ if (A == "") return -1;
+ return A.substr(0, 1) === "8" ? L = new BigInteger(A.substr(2), 16) : L = new BigInteger(A, 16), L.intValue();
+};
+
+ASN1HEX.getVidx = function (p, n) {
+ var A = ASN1HEX.getLblen(p, n);
+ if (A < 0) return A;
+ return n + (A + 1) * 2;
+};
+
+ASN1HEX.getV = function (p, n) {
+ var A = ASN1HEX.getVidx(p, n);
+ var L = ASN1HEX.getVblen(p, n);
+ return p.substr(A, L * 2);
+};
+
+ASN1HEX.getTLV = function (p, n) {
+ return p.substr(n, 2) + ASN1HEX.getL(p, n) + ASN1HEX.getV(p, n);
+};
+
+ASN1HEX.getNextSiblingIdx = function (p, n) {
+ var A = ASN1HEX.getVidx(p, n);
+ var L = ASN1HEX.getVblen(p, n);
+ return A + L * 2;
+};
+
+ASN1HEX.getChildIdx = function (p, n) {
+ var a = ASN1HEX;
+ var A = new Array();
+ var L = a.getVidx(p, n);
+
+ if (p.substr(n, 2) == "03") {
+ A.push(L + 2);
+ } else {
+ A.push(L);
+ }
+
+ var S = a.getVblen(p, n);
+ var Y = L;
+ var J = 0;
+
+ while (1) {
+ var C = a.getNextSiblingIdx(p, Y);
+ if (C == null || C - L >= S * 2) break;
+ if (J >= 200) break;
+ A.push(C);
+ Y = C;
+ J++;
+ }
+
+ return A;
+};
+
+ASN1HEX.getNthChildIdx = function (p, n, a) {
+ var A = ASN1HEX.getChildIdx(p, n);
+ return A[a];
+};
+
+ASN1HEX.getIdxbyList = function (p, n, a, A) {
+ var L = ASN1HEX;
+ var S;
+ var Y;
+
+ if (a.length == 0) {
+ if (A !== undefined) {
+ if (p.substr(n, 2) !== A) throw Error("checking tag doesn't match: " + p.substr(n, 2) + "!=" + A);
+ }
+
+ return n;
+ }
+
+ return S = a.shift(), Y = L.getChildIdx(p, n), L.getIdxbyList(p, Y[S], a, A);
+};
+
+ASN1HEX.getTLVbyList = function (p, n, A, L) {
+ var g = ASN1HEX;
+ var S = g.getIdxbyList(p, n, A);
+ if (S === undefined) throw "can't find nthList object";
+
+ if (L !== undefined) {
+ if (p.substr(S, 2) != L) throw "checking tag doesn't match: " + p.substr(S, 2) + "!=" + L;
+ }
+
+ return g.getTLV(p, S);
+};
+
+ASN1HEX.getVbyList = function (p, n, A, L, S) {
+ var Y = ASN1HEX;
+ var J;
+ var C;
+ J = Y.getIdxbyList(p, n, A, L);
+ if (J === undefined) throw "can't find nthList object";
+ return C = Y.getV(p, J), S === !![] && (C = C.substr(2)), C;
+};
+
+ASN1HEX.hextooidstr = function (p) {
+ var c = function (W, R) {
+ if (W.length >= R) return W;
+ return new Array(R - W.length + 1).join("0") + W;
+ };
+
+ var a = [];
+ var A = p.substr(0, 2);
+ var L = parseInt(A, 16);
+ a[0] = new String(Math.floor(L / 40));
+ a[1] = new String(L % 40);
+ var S = p.substr(2);
+ var Y = [];
+
+ for (var J = 0; J < S.length / 2; J++) {
+ Y.push(parseInt(S.substr(J * 2, 2), 16));
+ }
+
+ var b = [];
+ var C = "";
+
+ for (var J = 0; J < Y.length; J++) {
+ if (Y[J] & 128) {
+ C = C + c((Y[J] & 127).toString(2), 7);
+ } else {
+ C = C + c((Y[J] & 127).toString(2), 7);
+ b.push(new String(parseInt(C, 2)));
+ C = "";
+ }
+ }
+
+ var V = a.join(".");
+ return b.length > 0 && (V = V + "." + b.join(".")), V;
+};
+
+ASN1HEX.dump = function (A, L, S, Y) {
+ var J = ASN1HEX;
+ var C = J.getV;
+ var V = J.dump;
+ var W = J.getChildIdx;
+ var R = A;
+
+ if (A instanceof KJUR.asn1.ASN1Object) {
+ R = A.getEncodedHex();
+ }
+
+ var B = function (G, N) {
+ if (G.length <= N * 2) return G;else {
+ var D = G.substr(0, N) + "..(total " + G.length / 2 + "bytes).." + G.substr(G.length - N, N);
+ return D;
+ }
+ };
+
+ if (L === undefined) {
+ L = {
+ "ommit_long_octet": 32
+ };
+ }
+
+ if (S === undefined) {
+ S = 0;
+ }
+
+ if (Y === undefined) {
+ Y = "";
+ }
+
+ var F = L.ommit_long_octet;
+
+ if (R.substr(S, 2) == "01") {
+ var E = C(R, S);
+ return E == "00" ? Y + "BOOLEAN FALSE\n" : Y + "BOOLEAN TRUE\n";
+ }
+
+ if (R.substr(S, 2) == "02") {
+ var E = C(R, S);
+ return Y + "INTEGER " + B(E, F) + "\n";
+ }
+
+ if (R.substr(S, 2) == "03") {
+ var E = C(R, S);
+ return Y + "BITSTRING " + B(E, F) + "\n";
+ }
+
+ if (R.substr(S, 2) == "04") {
+ var E = C(R, S);
+
+ if (J.isASN1HEX(E)) {
+ var s = Y + "OCTETSTRING, encapsulates\n";
+ return s = s + V(E, L, 0, Y + " "), s;
+ } else return Y + "OCTETSTRING " + B(E, F) + "\n";
+ }
+
+ if (R.substr(S, 2) == "05") return Y + "NULL\n";
+
+ if (R.substr(S, 2) == "06") {
+ var I = C(R, S);
+ var K = KJUR.asn1.ASN1Util.oidHexToInt(I);
+ var T = KJUR.asn1.x509.OID.oid2name(K);
+ var i = K.replace(/\./g, " ");
+ return T != "" ? Y + "ObjectIdentifier " + T + " (" + i + ")\n" : Y + "ObjectIdentifier (" + i + ")\n";
+ }
+
+ if (R.substr(S, 2) == "0c") return Y + "UTF8String '" + hextoutf8(C(R, S)) + "'\n";
+ if (R.substr(S, 2) == "13") return Y + "PrintableString '" + hextoutf8(C(R, S)) + "'\n";
+ if (R.substr(S, 2) == "14") return Y + "TeletexString '" + hextoutf8(C(R, S)) + "'\n";
+ if (R.substr(S, 2) == "16") return Y + "IA5String '" + hextoutf8(C(R, S)) + "'\n";
+ if (R.substr(S, 2) == "17") return Y + "UTCTime " + hextoutf8(C(R, S)) + "\n";
+ if (R.substr(S, 2) == "18") return Y + "GeneralizedTime " + hextoutf8(C(R, S)) + "\n";
+
+ if (R.substr(S, 2) == "30") {
+ if (R.substr(S, 4) == "3000") return Y + "SEQUENCE {}\n";
+ var s = Y + "SEQUENCE\n";
+ var Z = W(R, S);
+ var M = L;
+
+ if ((Z.length == 2 || Z.length == 3) && R.substr(Z[0], 2) == "06" && R.substr(Z[Z.length - 1], 2) == "04") {
+ var T = J.oidname(C(R, Z[0]));
+ var U = JSON.parse(JSON.stringify(L));
+ U.x509ExtName = T;
+ M = U;
+ }
+
+ for (var H = 0; H < Z.length; H++) {
+ s = s + V(R, M, Z[H], Y + " ");
+ }
+
+ return s;
+ }
+
+ if (R.substr(S, 2) == "31") {
+ var s = Y + "SET\n";
+ var Z = W(R, S);
+
+ for (var H = 0; H < Z.length; H++) {
+ s = s + V(R, L, Z[H], Y + " ");
+ }
+
+ return s;
+ }
+
+ var O = parseInt(R.substr(S, 2), 16);
+
+ if ((O & 128) != 0) {
+ var X = O & 31;
+
+ if ((O & 32) != 0) {
+ var s = Y + "[" + X + "]\n";
+ var Z = W(R, S);
+
+ for (var H = 0; H < Z.length; H++) {
+ s = s + V(R, L, Z[H], Y + " ");
+ }
+
+ return s;
+ } else {
+ var E = C(R, S);
+
+ if (E.substr(0, 8) == "68747470") {
+ E = hextoutf8(E);
+ }
+
+ if (L.x509ExtName === "subjectAltName" && X == 2) {
+ E = hextoutf8(E);
+ }
+
+ var s = Y + "[" + X + "] " + E + "\n";
+ return s;
+ }
+ }
+
+ return Y + "UNKNOWN(" + R.substr(S, 2) + ") " + C(R, S) + "\n";
+};
+
+ASN1HEX.isASN1HEX = function (p) {
+ var n = ASN1HEX;
+ if (p.length % 2 == 1) return ![];
+ var A = n.getVblen(p, 0);
+ var L = p.substr(0, 2);
+ var g = n.getL(p, 0);
+ var S = p.length - L.length - g.length;
+ if (S == A * 2) return !![];
+ return ![];
+};
+
+ASN1HEX.checkStrictDER = function (A, L, S, Y, J) {
+ var C = ASN1HEX;
+
+ if (S === undefined) {
+ if (typeof A != "string") throw new Error("not hex string");
+ A = A.toLowerCase();
+ if (!KJUR.lang.String.isHex(A)) throw new Error("not hex string");
+ S = A.length;
+ Y = A.length / 2;
+ Y < 128 ? J = 1 : J = Math.ceil(Y.toString(16)) + 1;
+ }
+
+ var V = C.getL(A, L);
+ if (V.length > J * 2) throw new Error("L of TLV too long: idx=" + L);
+ var W = C.getVblen(A, L);
+ if (W > Y) throw new Error("value of L too long than hex: idx=" + L);
+ var R = C.getTLV(A, L);
+ var B = R.length - 2 - C.getL(A, L).length;
+ if (B !== W * 2) throw new Error("V string length and L's value not the same:" + B + "/" + W * 2);
+
+ if (L === 0) {
+ if (A.length != R.length) throw new Error("total length and TLV length unmatch:" + A.length + "!=" + R.length);
+ }
+
+ var F = A.substr(L, 2);
+
+ if (F === "02") {
+ var E = C.getVidx(A, L);
+ if (A.substr(E, 2) == "00" && A.charCodeAt(E + 2) < 56) throw new Error("not least zeros for DER INTEGER");
+ }
+
+ if (parseInt(F, 16) & 32) {
+ var I = C.getVblen(A, L);
+ var K = 0;
+ var T = C.getChildIdx(A, L);
+
+ for (var i = 0; i < T.length; i++) {
+ var Z = C.getTLV(A, T[i]);
+ K += Z.length;
+ C.checkStrictDER(A, T[i], S, Y, J);
+ }
+
+ if (I * 2 != K) throw new Error("sum of children's TLV length and L unmatch: " + I * 2 + "!=" + K);
+ }
+};
+
+ASN1HEX.oidname = function (p) {
+ var n = KJUR.asn1;
+
+ if (KJUR.lang.String.isHex(p)) {
+ p = n.ASN1Util.oidHexToInt(p);
+ }
+
+ var A = n.x509.OID.oid2name(p);
+ return A === "" && (A = p), A;
+};
+
+if (typeof KJUR == "undefined" || !KJUR) {
+ KJUR = {};
+}
+
+if (typeof KJUR.asn1 == "undefined" || !KJUR.asn1) {
+ KJUR.asn1 = {};
+}
+
+if (typeof KJUR.asn1.x509 == "undefined" || !KJUR.asn1.x509) {
+ KJUR.asn1.x509 = {};
+}
+
+KJUR.asn1.x509.Certificate = function (p) {
+ KJUR.asn1.x509.Certificate.superclass.constructor.call(this);
+ var n = null;
+ var A = null;
+ var L = null;
+ var S = null;
+ var Y = null;
+ var J = KJUR;
+ var C = J.crypto;
+ var V = J.asn1;
+ var W = V.DERSequence;
+ var l = V.DERBitString;
+
+ this.sign = function () {
+ this.asn1SignatureAlg = this.asn1TBSCert.asn1SignatureAlg;
+ var R = new KJUR.crypto.Signature({
+ "alg": this.asn1SignatureAlg.nameAlg
+ });
+ R.init(this.prvKey);
+ R.updateHex(this.asn1TBSCert.getEncodedHex());
+ this.hexSig = R.sign();
+ this.asn1Sig = new l({
+ "hex": "00" + this.hexSig
+ });
+ var B = new W({
+ "array": [this.asn1TBSCert, this.asn1SignatureAlg, this.asn1Sig]
+ });
+ this.hTLV = B.getEncodedHex();
+ this.isModified = ![];
+ };
+
+ this.setSignatureHex = function (R) {
+ this.asn1SignatureAlg = this.asn1TBSCert.asn1SignatureAlg;
+ this.hexSig = R;
+ this.asn1Sig = new l({
+ "hex": "00" + this.hexSig
+ });
+ var B = new W({
+ "array": [this.asn1TBSCert, this.asn1SignatureAlg, this.asn1Sig]
+ });
+ this.hTLV = B.getEncodedHex();
+ this.isModified = ![];
+ };
+
+ this.getEncodedHex = function () {
+ if (this.isModified == ![] && this.hTLV != null) return this.hTLV;
+ throw "not signed yet";
+ };
+
+ this.getPEMString = function () {
+ var R = hextob64nl(this.getEncodedHex());
+ return "-----BEGIN CERTIFICATE-----\r\n" + R + "\r\n-----END CERTIFICATE-----\r\n";
+ };
+
+ p !== undefined && (p.tbscertobj !== undefined && (this.asn1TBSCert = p.tbscertobj), p.prvkeyobj !== undefined && (this.prvKey = p.prvkeyobj));
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.Certificate, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.x509.TBSCertificate = function (p) {
+ KJUR.asn1.x509.TBSCertificate.superclass.constructor.call(this);
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERSequence;
+ var S = A.DERInteger;
+ var Y = A.DERTaggedObject;
+ var J = A.x509;
+ var C = J.Time;
+ var V = J.X500Name;
+ var W = J.SubjectPublicKeyInfo;
+
+ this._initialize = function () {
+ this.asn1Array = new Array();
+ this.asn1Version = new Y({
+ "obj": new S({
+ "int": 2
+ })
+ });
+ this.asn1SerialNumber = null;
+ this.asn1SignatureAlg = null;
+ this.asn1Issuer = null;
+ this.asn1NotBefore = null;
+ this.asn1NotAfter = null;
+ this.asn1Subject = null;
+ this.asn1SubjPKey = null;
+ this.extensionsArray = new Array();
+ };
+
+ this.setSerialNumberByParam = function (l) {
+ this.asn1SerialNumber = new S(l);
+ };
+
+ this.setSignatureAlgByParam = function (l) {
+ this.asn1SignatureAlg = new J.AlgorithmIdentifier(l);
+ };
+
+ this.setIssuerByParam = function (l) {
+ this.asn1Issuer = new V(l);
+ };
+
+ this.setNotBeforeByParam = function (l) {
+ this.asn1NotBefore = new C(l);
+ };
+
+ this.setNotAfterByParam = function (l) {
+ this.asn1NotAfter = new C(l);
+ };
+
+ this.setSubjectByParam = function (l) {
+ this.asn1Subject = new V(l);
+ };
+
+ this.setSubjectPublicKey = function (l) {
+ this.asn1SubjPKey = new W(l);
+ };
+
+ this.setSubjectPublicKeyByGetKey = function (R) {
+ var B = KEYUTIL.getKey(R);
+ this.asn1SubjPKey = new W(B);
+ };
+
+ this.appendExtension = function (l) {
+ this.extensionsArray.push(l);
+ };
+
+ this.appendExtensionByName = function (R, B) {
+ KJUR.asn1.x509.Extension.appendByNameToArray(R, B, this.extensionsArray);
+ };
+
+ this.getEncodedHex = function () {
+ if (this.asn1NotBefore == null || this.asn1NotAfter == null) throw "notBefore and/or notAfter not set";
+ var R = new L({
+ "array": [this.asn1NotBefore, this.asn1NotAfter]
+ });
+ this.asn1Array = new Array();
+ this.asn1Array.push(this.asn1Version);
+ this.asn1Array.push(this.asn1SerialNumber);
+ this.asn1Array.push(this.asn1SignatureAlg);
+ this.asn1Array.push(this.asn1Issuer);
+ this.asn1Array.push(R);
+ this.asn1Array.push(this.asn1Subject);
+ this.asn1Array.push(this.asn1SubjPKey);
+
+ if (this.extensionsArray.length > 0) {
+ var B = new L({
+ "array": this.extensionsArray
+ });
+ var F = new Y({
+ "explicit": !![],
+ "tag": "a3",
+ "obj": B
+ });
+ this.asn1Array.push(F);
+ }
+
+ var E = new L({
+ "array": this.asn1Array
+ });
+ return this.hTLV = E.getEncodedHex(), this.isModified = ![], this.hTLV;
+ };
+
+ this._initialize();
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.TBSCertificate, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.x509.Extension = function (p) {
+ KJUR.asn1.x509.Extension.superclass.constructor.call(this);
+ var n = null;
+ var A = KJUR;
+ var L = A.asn1;
+ var S = L.DERObjectIdentifier;
+ var Y = L.DEROctetString;
+ var J = L.DERBitString;
+ var C = L.DERBoolean;
+ var V = L.DERSequence;
+
+ this.getEncodedHex = function () {
+ var W = new S({
+ "oid": this.oid
+ });
+ var R = new Y({
+ "hex": this.getExtnValueHex()
+ });
+ var B = new Array();
+ B.push(W);
+
+ if (this.critical) {
+ B.push(new C());
+ }
+
+ B.push(R);
+ var F = new V({
+ "array": B
+ });
+ return F.getEncodedHex();
+ };
+
+ this.critical = ![];
+ p !== undefined && p.critical !== undefined && (this.critical = p.critical);
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.Extension, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.x509.Extension.appendByNameToArray = function (p, n, a) {
+ var A = p.toLowerCase();
+ var L = KJUR.asn1.x509;
+
+ if (A == "basicconstraints") {
+ var S = new L.BasicConstraints(n);
+ a.push(S);
+ } else {
+ if (A == "keyusage") {
+ var S = new L.KeyUsage(n);
+ a.push(S);
+ } else {
+ if (A == "crldistributionpoints") {
+ var S = new L.CRLDistributionPoints(n);
+ a.push(S);
+ } else {
+ if (A == "extkeyusage") {
+ var S = new L.ExtKeyUsage(n);
+ a.push(S);
+ } else {
+ if (A == "authoritykeyidentifier") {
+ var S = new L.AuthorityKeyIdentifier(n);
+ a.push(S);
+ } else {
+ if (A == "subjectkeyidentifier") {
+ var S = new L.SubjectKeyIdentifier(n);
+ a.push(S);
+ } else {
+ if (A == "authorityinfoaccess") {
+ var S = new L.AuthorityInfoAccess(n);
+ a.push(S);
+ } else {
+ if (A == "subjectaltname") {
+ var S = new L.SubjectAltName(n);
+ a.push(S);
+ } else {
+ if (A == "issueraltname") {
+ var S = new L.IssuerAltName(n);
+ a.push(S);
+ } else throw "unsupported extension name: " + p;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+};
+
+KJUR.asn1.x509.KeyUsage = function (p) {
+ KJUR.asn1.x509.KeyUsage.superclass.constructor.call(this, p);
+ var n = X509.KEYUSAGE_NAME;
+
+ this.getExtnValueHex = function () {
+ return this.asn1ExtnValue.getEncodedHex();
+ };
+
+ this.oid = "2.5.29.15";
+
+ if (p !== undefined) {
+ if (p.bin !== undefined) {
+ this.asn1ExtnValue = new KJUR.asn1.DERBitString(p);
+ }
+
+ if (p.names !== undefined && p.names.length !== undefined) {
+ var A = p.names;
+ var L = "000000000";
+
+ for (var g = 0; g < A.length; g++) {
+ for (var S = 0; S < n.length; S++) {
+ if (A[g] === n[S]) {
+ L = L.substring(0, S) + "1" + L.substring(S + 1, L.length);
+ }
+ }
+ }
+
+ this.asn1ExtnValue = new KJUR.asn1.DERBitString({
+ "bin": L
+ });
+ }
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.KeyUsage, KJUR.asn1.x509.Extension);
+
+KJUR.asn1.x509.BasicConstraints = function (p) {
+ KJUR.asn1.x509.BasicConstraints.superclass.constructor.call(this, p);
+ var n = ![];
+ var A = -1;
+
+ this.getExtnValueHex = function () {
+ var L = new Array();
+
+ if (this.cA) {
+ L.push(new KJUR.asn1.DERBoolean());
+ }
+
+ if (this.pathLen > -1) {
+ L.push(new KJUR.asn1.DERInteger({
+ "int": this.pathLen
+ }));
+ }
+
+ var g = new KJUR.asn1.DERSequence({
+ "array": L
+ });
+ return this.asn1ExtnValue = g, this.asn1ExtnValue.getEncodedHex();
+ };
+
+ this.oid = "2.5.29.19";
+ this.cA = ![];
+ this.pathLen = -1;
+ p !== undefined && (p.cA !== undefined && (this.cA = p.cA), p.pathLen !== undefined && (this.pathLen = p.pathLen));
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.BasicConstraints, KJUR.asn1.x509.Extension);
+
+KJUR.asn1.x509.CRLDistributionPoints = function (p) {
+ KJUR.asn1.x509.CRLDistributionPoints.superclass.constructor.call(this, p);
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.x509;
+
+ this.getExtnValueHex = function () {
+ return this.asn1ExtnValue.getEncodedHex();
+ };
+
+ this.setByDPArray = function (g) {
+ this.asn1ExtnValue = new A.DERSequence({
+ "array": g
+ });
+ };
+
+ this.setByOneURI = function (S) {
+ var Y = new L.GeneralNames([{
+ "uri": S
+ }]);
+ var J = new L.DistributionPointName(Y);
+ var C = new L.DistributionPoint({
+ "dpobj": J
+ });
+ this.setByDPArray([C]);
+ };
+
+ this.oid = "2.5.29.31";
+ p !== undefined && (p.array !== undefined ? this.setByDPArray(p.array) : p.uri !== undefined && this.setByOneURI(p.uri));
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.CRLDistributionPoints, KJUR.asn1.x509.Extension);
+
+KJUR.asn1.x509.ExtKeyUsage = function (p) {
+ KJUR.asn1.x509.ExtKeyUsage.superclass.constructor.call(this, p);
+ var n = KJUR;
+ var A = n.asn1;
+
+ this.setPurposeArray = function (L) {
+ this.asn1ExtnValue = new A.DERSequence();
+
+ for (var g = 0; g < L.length; g++) {
+ var S = new A.DERObjectIdentifier(L[g]);
+ this.asn1ExtnValue.appendASN1Object(S);
+ }
+ };
+
+ this.getExtnValueHex = function () {
+ return this.asn1ExtnValue.getEncodedHex();
+ };
+
+ this.oid = "2.5.29.37";
+ p !== undefined && p.array !== undefined && this.setPurposeArray(p.array);
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.ExtKeyUsage, KJUR.asn1.x509.Extension);
+
+KJUR.asn1.x509.AuthorityKeyIdentifier = function (p) {
+ KJUR.asn1.x509.AuthorityKeyIdentifier.superclass.constructor.call(this, p);
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERTaggedObject;
+ var g = A.x509.GeneralNames;
+ var S = n.crypto.Util.isKey;
+ this.asn1KID = null;
+ this.asn1CertIssuer = null;
+ this.asn1CertSN = null;
+
+ this.getExtnValueHex = function () {
+ var Y = new Array();
+
+ if (this.asn1KID) {
+ Y.push(new L({
+ "explicit": ![],
+ "tag": "80",
+ "obj": this.asn1KID
+ }));
+ }
+
+ if (this.asn1CertIssuer) {
+ Y.push(new L({
+ "explicit": ![],
+ "tag": "a1",
+ "obj": new g([{
+ "dn": this.asn1CertIssuer
+ }])
+ }));
+ }
+
+ if (this.asn1CertSN) {
+ Y.push(new L({
+ "explicit": ![],
+ "tag": "82",
+ "obj": this.asn1CertSN
+ }));
+ }
+
+ var J = new A.DERSequence({
+ "array": Y
+ });
+ return this.asn1ExtnValue = J, this.asn1ExtnValue.getEncodedHex();
+ };
+
+ this.setKIDByParam = function (Y) {
+ if (Y.str !== undefined || Y.hex !== undefined) this.asn1KID = new KJUR.asn1.DEROctetString(Y);else {
+ if (typeof Y === "object" && KJUR.crypto.Util.isKey(Y) || typeof Y === "string" && Y.indexOf("BEGIN ") != -1) {
+ var J = Y;
+
+ if (typeof Y === "string") {
+ J = KEYUTIL.getKey(Y);
+ }
+
+ var C = KEYUTIL.getKeyID(J);
+ this.asn1KID = new KJUR.asn1.DEROctetString({
+ "hex": C
+ });
+ }
+ }
+ };
+
+ this.setCertIssuerByParam = function (Y) {
+ if (Y.str !== undefined || Y.ldapstr !== undefined || Y.hex !== undefined || Y.certsubject !== undefined || Y.certissuer !== undefined) {
+ this.asn1CertIssuer = new KJUR.asn1.x509.X500Name(Y);
+ } else {
+ if (typeof Y === "string" && Y.indexOf("BEGIN ") != -1 && Y.indexOf("CERTIFICATE") != -1) {
+ this.asn1CertIssuer = new KJUR.asn1.x509.X500Name({
+ "certissuer": Y
+ });
+ }
+ }
+ };
+
+ this.setCertSNByParam = function (Y) {
+ if (Y.str !== undefined || Y.bigint !== undefined || Y.hex !== undefined) this.asn1CertSN = new KJUR.asn1.DERInteger(Y);else {
+ if (typeof Y === "string" && Y.indexOf("BEGIN ") != -1 && Y.indexOf("CERTIFICATE")) {
+ var J = new X509();
+ J.readCertPEM(Y);
+ var C = J.getSerialNumberHex();
+ this.asn1CertSN = new KJUR.asn1.DERInteger({
+ "hex": C
+ });
+ }
+ }
+ };
+
+ this.oid = "2.5.29.35";
+ p !== undefined && (p.kid !== undefined && this.setKIDByParam(p.kid), p.issuer !== undefined && this.setCertIssuerByParam(p.issuer), p.sn !== undefined && this.setCertSNByParam(p.sn), p.issuersn !== undefined && typeof p.issuersn === "string" && p.issuersn.indexOf("BEGIN ") != -1 && p.issuersn.indexOf("CERTIFICATE") && (this.setCertSNByParam(p.issuersn), this.setCertIssuerByParam(p.issuersn)));
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.AuthorityKeyIdentifier, KJUR.asn1.x509.Extension);
+
+KJUR.asn1.x509.SubjectKeyIdentifier = function (p) {
+ KJUR.asn1.x509.SubjectKeyIdentifier.superclass.constructor.call(this, p);
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DEROctetString;
+ this.asn1KID = null;
+
+ this.getExtnValueHex = function () {
+ return this.asn1ExtnValue = this.asn1KID, this.asn1ExtnValue.getEncodedHex();
+ };
+
+ this.setKIDByParam = function (S) {
+ if (S.str !== undefined || S.hex !== undefined) this.asn1KID = new L(S);else {
+ if (typeof S === "object" && KJUR.crypto.Util.isKey(S) || typeof S === "string" && S.indexOf("BEGIN") != -1) {
+ var Y = S;
+
+ if (typeof S === "string") {
+ Y = KEYUTIL.getKey(S);
+ }
+
+ var J = KEYUTIL.getKeyID(Y);
+ this.asn1KID = new KJUR.asn1.DEROctetString({
+ "hex": J
+ });
+ }
+ }
+ };
+
+ this.oid = "2.5.29.14";
+ p !== undefined && p.kid !== undefined && this.setKIDByParam(p.kid);
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.SubjectKeyIdentifier, KJUR.asn1.x509.Extension);
+
+KJUR.asn1.x509.AuthorityInfoAccess = function (p) {
+ KJUR.asn1.x509.AuthorityInfoAccess.superclass.constructor.call(this, p);
+
+ this.setAccessDescriptionArray = function (n) {
+ var A = new Array();
+ var L = KJUR;
+ var S = L.asn1;
+ var Y = S.DERSequence;
+
+ for (var J = 0; J < n.length; J++) {
+ var C = new S.DERObjectIdentifier(n[J].accessMethod);
+ var V = new S.x509.GeneralName(n[J].accessLocation);
+ var W = new Y({
+ "array": [C, V]
+ });
+ A.push(W);
+ }
+
+ this.asn1ExtnValue = new Y({
+ "array": A
+ });
+ };
+
+ this.getExtnValueHex = function () {
+ return this.asn1ExtnValue.getEncodedHex();
+ };
+
+ this.oid = "1.3.6.1.5.5.7.1.1";
+ p !== undefined && p.array !== undefined && this.setAccessDescriptionArray(p.array);
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.AuthorityInfoAccess, KJUR.asn1.x509.Extension);
+
+KJUR.asn1.x509.SubjectAltName = function (p) {
+ KJUR.asn1.x509.SubjectAltName.superclass.constructor.call(this, p);
+
+ this.setNameArray = function (n) {
+ this.asn1ExtnValue = new KJUR.asn1.x509.GeneralNames(n);
+ };
+
+ this.getExtnValueHex = function () {
+ return this.asn1ExtnValue.getEncodedHex();
+ };
+
+ this.oid = "2.5.29.17";
+ p !== undefined && p.array !== undefined && this.setNameArray(p.array);
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.SubjectAltName, KJUR.asn1.x509.Extension);
+
+KJUR.asn1.x509.IssuerAltName = function (p) {
+ KJUR.asn1.x509.IssuerAltName.superclass.constructor.call(this, p);
+
+ this.setNameArray = function (n) {
+ this.asn1ExtnValue = new KJUR.asn1.x509.GeneralNames(n);
+ };
+
+ this.getExtnValueHex = function () {
+ return this.asn1ExtnValue.getEncodedHex();
+ };
+
+ this.oid = "2.5.29.18";
+ p !== undefined && p.array !== undefined && this.setNameArray(p.array);
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.IssuerAltName, KJUR.asn1.x509.Extension);
+
+KJUR.asn1.x509.CRL = function (p) {
+ KJUR.asn1.x509.CRL.superclass.constructor.call(this);
+ var n = null;
+ var A = null;
+ var L = null;
+ var g = null;
+ var S = null;
+
+ this.sign = function () {
+ this.asn1SignatureAlg = this.asn1TBSCertList.asn1SignatureAlg;
+ sig = new KJUR.crypto.Signature({
+ "alg": this.asn1SignatureAlg.nameAlg,
+ "prov": "cryptojs/jsrsa"
+ });
+ sig.init(this.prvKey);
+ sig.updateHex(this.asn1TBSCertList.getEncodedHex());
+ this.hexSig = sig.sign();
+ this.asn1Sig = new KJUR.asn1.DERBitString({
+ "hex": "00" + this.hexSig
+ });
+ var Y = new KJUR.asn1.DERSequence({
+ "array": [this.asn1TBSCertList, this.asn1SignatureAlg, this.asn1Sig]
+ });
+ this.hTLV = Y.getEncodedHex();
+ this.isModified = ![];
+ };
+
+ this.getEncodedHex = function () {
+ if (this.isModified == ![] && this.hTLV != null) return this.hTLV;
+ throw "not signed yet";
+ };
+
+ this.getPEMString = function () {
+ var Y = hextob64nl(this.getEncodedHex());
+ return "-----BEGIN X509 CRL-----\r\n" + Y + "\r\n-----END X509 CRL-----\r\n";
+ };
+
+ p !== undefined && (p.tbsobj !== undefined && (this.asn1TBSCertList = p.tbsobj), p.prvkeyobj !== undefined && (this.prvKey = p.prvkeyobj));
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.CRL, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.x509.TBSCertList = function (p) {
+ KJUR.asn1.x509.TBSCertList.superclass.constructor.call(this);
+ var n = null;
+ var A = KJUR;
+ var L = A.asn1;
+ var S = L.DERSequence;
+ var Y = L.x509;
+ var J = Y.Time;
+
+ this.setSignatureAlgByParam = function (C) {
+ this.asn1SignatureAlg = new Y.AlgorithmIdentifier(C);
+ };
+
+ this.setIssuerByParam = function (C) {
+ this.asn1Issuer = new Y.X500Name(C);
+ };
+
+ this.setThisUpdateByParam = function (C) {
+ this.asn1ThisUpdate = new J(C);
+ };
+
+ this.setNextUpdateByParam = function (C) {
+ this.asn1NextUpdate = new J(C);
+ };
+
+ this.addRevokedCert = function (C, V) {
+ var W = {};
+
+ if (C != undefined && C != null) {
+ W.sn = C;
+ }
+
+ if (V != undefined && V != null) {
+ W.time = V;
+ }
+
+ var l = new Y.CRLEntry(W);
+ this.aRevokedCert.push(l);
+ };
+
+ this.getEncodedHex = function () {
+ this.asn1Array = new Array();
+
+ if (this.asn1Version != null) {
+ this.asn1Array.push(this.asn1Version);
+ }
+
+ this.asn1Array.push(this.asn1SignatureAlg);
+ this.asn1Array.push(this.asn1Issuer);
+ this.asn1Array.push(this.asn1ThisUpdate);
+
+ if (this.asn1NextUpdate != null) {
+ this.asn1Array.push(this.asn1NextUpdate);
+ }
+
+ if (this.aRevokedCert.length > 0) {
+ var C = new S({
+ "array": this.aRevokedCert
+ });
+ this.asn1Array.push(C);
+ }
+
+ var V = new S({
+ "array": this.asn1Array
+ });
+ return this.hTLV = V.getEncodedHex(), this.isModified = ![], this.hTLV;
+ };
+
+ this._initialize = function () {
+ this.asn1Version = null;
+ this.asn1SignatureAlg = null;
+ this.asn1Issuer = null;
+ this.asn1ThisUpdate = null;
+ this.asn1NextUpdate = null;
+ this.aRevokedCert = new Array();
+ };
+
+ this._initialize();
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.TBSCertList, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.x509.CRLEntry = function (p) {
+ KJUR.asn1.x509.CRLEntry.superclass.constructor.call(this);
+ var n = null;
+ var A = null;
+ var L = KJUR;
+ var g = L.asn1;
+
+ this.setCertSerial = function (S) {
+ this.sn = new g.DERInteger(S);
+ };
+
+ this.setRevocationDate = function (S) {
+ this.time = new g.x509.Time(S);
+ };
+
+ this.getEncodedHex = function () {
+ var S = new g.DERSequence({
+ "array": [this.sn, this.time]
+ });
+ return this.TLV = S.getEncodedHex(), this.TLV;
+ };
+
+ p !== undefined && (p.time !== undefined && this.setRevocationDate(p.time), p.sn !== undefined && this.setCertSerial(p.sn));
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.CRLEntry, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.x509.X500Name = function (p) {
+ KJUR.asn1.x509.X500Name.superclass.constructor.call(this);
+ this.asn1Array = new Array();
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.x509;
+ var g = pemtohex;
+
+ this.setByString = function (Y) {
+ var J = Y.split("/");
+ J.shift();
+ var C = [];
+
+ for (var V = 0; V < J.length; V++) {
+ if (J[V].match(/^[^=]+=.+$/)) C.push(J[V]);else {
+ var W = C.length - 1;
+ C[W] = C[W] + "/" + J[V];
+ }
+ }
+
+ for (var V = 0; V < C.length; V++) {
+ this.asn1Array.push(new L.RDN({
+ "str": C[V]
+ }));
+ }
+ };
+
+ this.setByLdapString = function (Y) {
+ var J = L.X500Name.ldapToCompat(Y);
+ this.setByString(J);
+ };
+
+ this.setByObject = function (Y) {
+ for (var J in Y) {
+ if (Y.hasOwnProperty(J)) {
+ var C = new KJUR.asn1.x509.RDN({
+ "str": J + "=" + Y[J]
+ });
+
+ if (this.asn1Array) {
+ this.asn1Array.push(C);
+ } else {
+ this.asn1Array = [C];
+ }
+ }
+ }
+ };
+
+ this.getEncodedHex = function () {
+ if (typeof this.hTLV == "string") return this.hTLV;
+ var Y = new A.DERSequence({
+ "array": this.asn1Array
+ });
+ return this.hTLV = Y.getEncodedHex(), this.hTLV;
+ };
+
+ if (p !== undefined) {
+ if (p.str !== undefined) this.setByString(p.str);else {
+ if (p.ldapstr !== undefined) this.setByLdapString(p.ldapstr);else {
+ if (p.hex !== undefined) this.hTLV = p.hex;else {
+ if (p.certissuer !== undefined) {
+ var S = new X509();
+ S.readCertPEM(p.certissuer);
+ this.hTLV = S.getIssuerHex();
+ } else {
+ if (p.certsubject !== undefined) {
+ var S = new X509();
+ S.readCertPEM(p.certsubject);
+ this.hTLV = S.getSubjectHex();
+ } else if (typeof p === "object" && p.certsubject === undefined && p.certissuer === undefined) {
+ this.setByObject(p);
+ }
+ }
+ }
+ }
+ }
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.X500Name, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.x509.X500Name.compatToLDAP = function (p) {
+ if (p.substr(0, 1) !== "/") throw "malformed input";
+ var n = "";
+ p = p.substr(1);
+ var a = p.split("/");
+ return a.reverse(), a = a.map(function (A) {
+ return A.replace(/,/, "\\,");
+ }), a.join(",");
+};
+
+KJUR.asn1.x509.X500Name.onelineToLDAP = function (p) {
+ return KJUR.asn1.x509.X500Name.compatToLDAP(p);
+};
+
+KJUR.asn1.x509.X500Name.ldapToCompat = function (p) {
+ var n = p.split(",");
+ var a = ![];
+ var A = [];
+
+ for (var L = 0; n.length > 0; L++) {
+ var S = n.shift();
+
+ if (a === !![]) {
+ var Y = A.pop();
+ var J = (Y + "," + S).replace(/\\,/g, ",");
+ A.push(J);
+ a = ![];
+ } else A.push(S);
+
+ if (S.substr(-1, 1) === "\\") {
+ a = !![];
+ }
+ }
+
+ return A = A.map(function (C) {
+ return C.replace("/", "\\/");
+ }), A.reverse(), "/" + A.join("/");
+};
+
+KJUR.asn1.x509.X500Name.ldapToOneline = function (p) {
+ return KJUR.asn1.x509.X500Name.ldapToCompat(p);
+};
+
+KJUR.asn1.x509.RDN = function (p) {
+ KJUR.asn1.x509.RDN.superclass.constructor.call(this);
+ this.asn1Array = new Array();
+
+ this.addByString = function (n) {
+ this.asn1Array.push(new KJUR.asn1.x509.AttributeTypeAndValue({
+ "str": n
+ }));
+ };
+
+ this.addByMultiValuedString = function (n) {
+ var A = KJUR.asn1.x509.RDN.parseString(n);
+
+ for (var L = 0; L < A.length; L++) {
+ this.addByString(A[L]);
+ }
+ };
+
+ this.getEncodedHex = function () {
+ var n = new KJUR.asn1.DERSet({
+ "array": this.asn1Array
+ });
+ return this.TLV = n.getEncodedHex(), this.TLV;
+ };
+
+ p !== undefined && p.str !== undefined && this.addByMultiValuedString(p.str);
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.RDN, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.x509.RDN.parseString = function (p) {
+ var n = p.split(/\+/);
+ var a = ![];
+ var A = [];
+
+ for (var L = 0; n.length > 0; L++) {
+ var S = n.shift();
+
+ if (a === !![]) {
+ var Y = A.pop();
+ var J = (Y + "+" + S).replace(/\\\+/g, "+");
+ A.push(J);
+ a = ![];
+ } else A.push(S);
+
+ if (S.substr(-1, 1) === "\\") {
+ a = !![];
+ }
+ }
+
+ var C = ![];
+ var V = [];
+
+ for (var L = 0; A.length > 0; L++) {
+ var S = A.shift();
+
+ if (C === !![]) {
+ var W = V.pop();
+
+ if (S.match(/"$/)) {
+ var J = (W + "+" + S).replace(/^([^=]+)="(.*)"$/, "$1=$2");
+ V.push(J);
+ C = ![];
+ } else V.push(W + "+" + S);
+ } else V.push(S);
+
+ if (S.match(/^[^=]+="/)) {
+ C = !![];
+ }
+ }
+
+ return V;
+};
+
+KJUR.asn1.x509.AttributeTypeAndValue = function (p) {
+ KJUR.asn1.x509.AttributeTypeAndValue.superclass.constructor.call(this);
+ var n = null;
+ var A = null;
+ var L = "utf8";
+ var g = KJUR;
+ var S = g.asn1;
+
+ this.setByString = function (Y) {
+ var J = Y.match(/^([^=]+)=(.+)$/);
+ if (J) this.setByAttrTypeAndValueStr(J[1], J[2]);else throw "malformed attrTypeAndValueStr: " + Y;
+ };
+
+ this.setByAttrTypeAndValueStr = function (Y, J) {
+ this.typeObj = KJUR.asn1.x509.OID.atype2obj(Y);
+ var C = L;
+ Y == "C" && (C = "prn");
+ this.valueObj = this.getValueObj(C, J);
+ };
+
+ this.getValueObj = function (Y, J) {
+ if (Y == "utf8") return new S.DERUTF8String({
+ "str": J
+ });
+ if (Y == "prn") return new S.DERPrintableString({
+ "str": J
+ });
+ if (Y == "tel") return new S.DERTeletexString({
+ "str": J
+ });
+ if (Y == "ia5") return new S.DERIA5String({
+ "str": J
+ });
+ throw "unsupported directory string type: type=" + Y + " value=" + J;
+ };
+
+ this.getEncodedHex = function () {
+ var Y = new S.DERSequence({
+ "array": [this.typeObj, this.valueObj]
+ });
+ return this.TLV = Y.getEncodedHex(), this.TLV;
+ };
+
+ p !== undefined && p.str !== undefined && this.setByString(p.str);
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.AttributeTypeAndValue, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.x509.SubjectPublicKeyInfo = function (p) {
+ KJUR.asn1.x509.SubjectPublicKeyInfo.superclass.constructor.call(this);
+ var A = null;
+ var L = null;
+ var S = KJUR;
+ var Y = S.asn1;
+ var J = Y.DERInteger;
+ var C = Y.DERBitString;
+ var V = Y.DERObjectIdentifier;
+ var W = Y.DERSequence;
+ var R = Y.ASN1Util.newObject;
+ var B = Y.x509;
+ var F = B.AlgorithmIdentifier;
+ var E = S.crypto;
+ var s = E.ECDSA;
+ var I = E.DSA;
+
+ this.getASN1Object = function () {
+ if (this.asn1AlgId == null || this.asn1SubjPKey == null) throw "algId and/or subjPubKey not set";
+ var K = new W({
+ "array": [this.asn1AlgId, this.asn1SubjPKey]
+ });
+ return K;
+ };
+
+ this.getEncodedHex = function () {
+ var K = this.getASN1Object();
+ return this.hTLV = K.getEncodedHex(), this.hTLV;
+ };
+
+ this.setPubKey = function (K) {
+ try {
+ if (K instanceof RSAKey) {
+ var T = R({
+ "seq": [{
+ "int": {
+ "bigint": K.n
+ }
+ }, {
+ "int": {
+ "int": K.e
+ }
+ }]
+ });
+ var Z = T.getEncodedHex();
+ this.asn1AlgId = new F({
+ "name": "rsaEncryption"
+ });
+ this.asn1SubjPKey = new C({
+ "hex": "00" + Z
+ });
+ }
+ } catch (U) {
+ console.log(U);
+ }
+
+ try {
+ if (K instanceof KJUR.crypto.ECDSA) {
+ var w = new V({
+ "name": K.curveName
+ });
+ this.asn1AlgId = new F({
+ "name": "ecPublicKey",
+ "asn1params": w
+ });
+ this.asn1SubjPKey = new C({
+ "hex": "00" + K.pubKeyHex
+ });
+ }
+ } catch (H) {
+ console.log(H);
+ }
+
+ try {
+ if (K instanceof KJUR.crypto.DSA) {
+ var w = new R({
+ "seq": [{
+ "int": {
+ "bigint": K.p
+ }
+ }, {
+ "int": {
+ "bigint": K.q
+ }
+ }, {
+ "int": {
+ "bigint": K.g
+ }
+ }]
+ });
+ this.asn1AlgId = new F({
+ "name": "dsa",
+ "asn1params": w
+ });
+ var M = new J({
+ "bigint": K.y
+ });
+ this.asn1SubjPKey = new C({
+ "hex": "00" + M.getEncodedHex()
+ });
+ }
+ } catch (O) {
+ console.log(O);
+ }
+ };
+
+ p !== undefined && this.setPubKey(p);
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.SubjectPublicKeyInfo, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.x509.Time = function (p) {
+ KJUR.asn1.x509.Time.superclass.constructor.call(this);
+ var n = null;
+ var A = null;
+ var L = KJUR;
+ var S = L.asn1;
+ var Y = S.DERUTCTime;
+ var J = S.DERGeneralizedTime;
+
+ this.setTimeParams = function (C) {
+ this.timeParams = C;
+ };
+
+ this.getEncodedHex = function () {
+ var C = null;
+ return this.timeParams != null ? this.type == "utc" ? C = new Y(this.timeParams) : C = new J(this.timeParams) : this.type == "utc" ? C = new Y() : C = new J(), this.TLV = C.getEncodedHex(), this.TLV;
+ };
+
+ this.type = "utc";
+ p !== undefined && (p.type !== undefined ? this.type = p.type : p.str !== undefined && (p.str.match(/^[0-9]{12}Z$/) && (this.type = "utc"), p.str.match(/^[0-9]{14}Z$/) && (this.type = "gen")), this.timeParams = p);
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.Time, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.x509.AlgorithmIdentifier = function (p) {
+ KJUR.asn1.x509.AlgorithmIdentifier.superclass.constructor.call(this);
+ this.nameAlg = null;
+ this.asn1Alg = null;
+ this.asn1Params = null;
+ this.paramEmpty = ![];
+ var n = KJUR;
+ var A = n.asn1;
+
+ this.getEncodedHex = function () {
+ if (this.nameAlg === null && this.asn1Alg === null) throw "algorithm not specified";
+
+ if (this.nameAlg !== null && this.asn1Alg === null) {
+ this.asn1Alg = A.x509.OID.name2obj(this.nameAlg);
+ }
+
+ var g = [this.asn1Alg];
+
+ if (this.asn1Params !== null) {
+ g.push(this.asn1Params);
+ }
+
+ var S = new A.DERSequence({
+ "array": g
+ });
+ return this.hTLV = S.getEncodedHex(), this.hTLV;
+ };
+
+ if (p !== undefined) {
+ p.name !== undefined && (this.nameAlg = p.name);
+ p.asn1params !== undefined && (this.asn1Params = p.asn1params);
+ p.paramempty !== undefined && (this.paramEmpty = p.paramempty);
+ }
+
+ if (this.asn1Params === null && this.paramEmpty === ![] && this.nameAlg !== null) {
+ var L = this.nameAlg.toLowerCase();
+
+ if (L.substr(-7, 7) !== "withdsa" && L.substr(-9, 9) !== "withecdsa") {
+ this.asn1Params = new A.DERNull();
+ }
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.AlgorithmIdentifier, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.x509.GeneralName = function (p) {
+ KJUR.asn1.x509.GeneralName.superclass.constructor.call(this);
+ var n = null;
+ var A = null;
+ var L = {
+ "rfc822": "81",
+ "dns": "82",
+ "dn": "a4",
+ "uri": "86",
+ "ip": "87"
+ };
+ var S = KJUR;
+ var Y = S.asn1;
+ var J = Y.DERSequence;
+ var C = Y.DEROctetString;
+ var V = Y.DERIA5String;
+ var W = Y.DERTaggedObject;
+ var R = Y.ASN1Object;
+ var B = Y.x509.X500Name;
+ var F = pemtohex;
+ this.explicit = ![];
+
+ this.setByParam = function (E) {
+ var I = null;
+ var K = null;
+ if (E === undefined) return;
+
+ if (E.rfc822 !== undefined) {
+ this.type = "rfc822";
+ K = new V({
+ "str": E[this.type]
+ });
+ }
+
+ if (E.dns !== undefined) {
+ this.type = "dns";
+ K = new V({
+ "str": E[this.type]
+ });
+ }
+
+ if (E.uri !== undefined) {
+ this.type = "uri";
+ K = new V({
+ "str": E[this.type]
+ });
+ }
+
+ if (E.dn !== undefined) {
+ this.type = "dn";
+ this.explicit = !![];
+ typeof E.dn === "string" ? K = new B({
+ "str": E.dn
+ }) : E.dn instanceof KJUR.asn1.x509.X500Name ? K = E.dn : K = new B(E.dn);
+ }
+
+ if (E.ldapdn !== undefined) {
+ this.type = "dn";
+ this.explicit = !![];
+ K = new B({
+ "ldapstr": E.ldapdn
+ });
+ }
+
+ if (E.certissuer !== undefined) {
+ this.type = "dn";
+ this.explicit = !![];
+ var T = E.certissuer;
+ var Z = null;
+
+ if (T.match(/^[0-9A-Fa-f]+$/)) {
+ Z == T;
+ }
+
+ if (T.indexOf("-----BEGIN ") != -1) {
+ Z = F(T);
+ }
+
+ if (Z == null) throw "certissuer param not cert";
+ var M = new X509();
+ M.hex = Z;
+ var U = M.getIssuerHex();
+ K = new R();
+ K.hTLV = U;
+ }
+
+ if (E.certsubj !== undefined) {
+ this.type = "dn";
+ this.explicit = !![];
+ var T = E.certsubj;
+ var Z = null;
+
+ if (T.match(/^[0-9A-Fa-f]+$/)) {
+ Z == T;
+ }
+
+ if (T.indexOf("-----BEGIN ") != -1) {
+ Z = F(T);
+ }
+
+ if (Z == null) throw "certsubj param not cert";
+ var M = new X509();
+ M.hex = Z;
+ var U = M.getSubjectHex();
+ K = new R();
+ K.hTLV = U;
+ }
+
+ if (E.ip !== undefined) {
+ this.type = "ip";
+ this.explicit = ![];
+ var H = E.ip;
+ var O;
+ var X = "malformed IP address";
+
+ if (H.match(/^[0-9.]+[.][0-9.]+$/)) {
+ O = intarystrtohex("[" + H.split(".").join(",") + "]");
+ if (O.length !== 8) throw X;
+ } else {
+ if (H.match(/^[0-9A-Fa-f:]+:[0-9A-Fa-f:]+$/)) O = ipv6tohex(H);else {
+ if (H.match(/^([0-9A-Fa-f][0-9A-Fa-f]){1,}$/)) O = H;else throw X;
+ }
+ }
+
+ K = new C({
+ "hex": O
+ });
+ }
+
+ if (this.type == null) throw "unsupported type in params=" + E;
+ this.asn1Obj = new W({
+ "explicit": this.explicit,
+ "tag": L[this.type],
+ "obj": K
+ });
+ };
+
+ this.getEncodedHex = function () {
+ return this.asn1Obj.getEncodedHex();
+ };
+
+ p !== undefined && this.setByParam(p);
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.GeneralName, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.x509.GeneralNames = function (p) {
+ KJUR.asn1.x509.GeneralNames.superclass.constructor.call(this);
+ var n = null;
+ var A = KJUR;
+ var L = A.asn1;
+
+ this.setByParamArray = function (S) {
+ for (var Y = 0; Y < S.length; Y++) {
+ var J = new L.x509.GeneralName(S[Y]);
+ this.asn1Array.push(J);
+ }
+ };
+
+ this.getEncodedHex = function () {
+ var g = new L.DERSequence({
+ "array": this.asn1Array
+ });
+ return g.getEncodedHex();
+ };
+
+ this.asn1Array = new Array();
+ typeof p != "undefined" && this.setByParamArray(p);
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.GeneralNames, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.x509.DistributionPointName = function (p) {
+ KJUR.asn1.x509.DistributionPointName.superclass.constructor.call(this);
+ var n = null;
+ var A = null;
+ var L = null;
+ var S = null;
+ var Y = KJUR;
+ var J = Y.asn1;
+ var C = J.DERTaggedObject;
+
+ this.getEncodedHex = function () {
+ if (this.type != "full") throw "currently type shall be 'full': " + this.type;
+ return this.asn1Obj = new C({
+ "explicit": ![],
+ "tag": this.tag,
+ "obj": this.asn1V
+ }), this.hTLV = this.asn1Obj.getEncodedHex(), this.hTLV;
+ };
+
+ if (p !== undefined) {
+ if (J.x509.GeneralNames.prototype.isPrototypeOf(p)) {
+ this.type = "full";
+ this.tag = "a0";
+ this.asn1V = p;
+ } else throw "This class supports GeneralNames only as argument";
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.DistributionPointName, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.x509.DistributionPoint = function (p) {
+ KJUR.asn1.x509.DistributionPoint.superclass.constructor.call(this);
+ var n = null;
+ var A = KJUR;
+ var L = A.asn1;
+
+ this.getEncodedHex = function () {
+ var g = new L.DERSequence();
+
+ if (this.asn1DP != null) {
+ var S = new L.DERTaggedObject({
+ "explicit": !![],
+ "tag": "a0",
+ "obj": this.asn1DP
+ });
+ g.appendASN1Object(S);
+ }
+
+ return this.hTLV = g.getEncodedHex(), this.hTLV;
+ };
+
+ p !== undefined && p.dpobj !== undefined && (this.asn1DP = p.dpobj);
+};
+
+YAHOO.lang.extend(KJUR.asn1.x509.DistributionPoint, KJUR.asn1.ASN1Object);
+KJUR.asn1.x509.OID = new function (p) {
+ this.atype2oidList = {
+ "CN": "2.5.4.3",
+ "L": "2.5.4.7",
+ "ST": "2.5.4.8",
+ "O": "2.5.4.10",
+ "OU": "2.5.4.11",
+ "C": "2.5.4.6",
+ "STREET": "2.5.4.9",
+ "DC": "0.9.2342.19200300.100.1.25",
+ "UID": "0.9.2342.19200300.100.1.1",
+ "SN": "2.5.4.4",
+ "T": "2.5.4.12",
+ "DN": "2.5.4.49",
+ "E": "1.2.840.113549.1.9.1",
+ "description": "2.5.4.13",
+ "businessCategory": "2.5.4.15",
+ "postalCode": "2.5.4.17",
+ "serialNumber": "2.5.4.5",
+ "uniqueIdentifier": "2.5.4.45",
+ "organizationIdentifier": "2.5.4.97",
+ "jurisdictionOfIncorporationL": "1.3.6.1.4.1.311.60.2.1.1",
+ "jurisdictionOfIncorporationSP": "1.3.6.1.4.1.311.60.2.1.2",
+ "jurisdictionOfIncorporationC": "1.3.6.1.4.1.311.60.2.1.3"
+ };
+ this.name2oidList = {
+ "sha1": "1.3.14.3.2.26",
+ "sha256": "2.16.840.1.101.3.4.2.1",
+ "sha384": "2.16.840.1.101.3.4.2.2",
+ "sha512": "2.16.840.1.101.3.4.2.3",
+ "sha224": "2.16.840.1.101.3.4.2.4",
+ "md5": "1.2.840.113549.2.5",
+ "md2": "1.3.14.7.2.2.1",
+ "ripemd160": "1.3.36.3.2.1",
+ "MD2withRSA": "1.2.840.113549.1.1.2",
+ "MD4withRSA": "1.2.840.113549.1.1.3",
+ "MD5withRSA": "1.2.840.113549.1.1.4",
+ "SHA1withRSA": "1.2.840.113549.1.1.5",
+ "SHA224withRSA": "1.2.840.113549.1.1.14",
+ "SHA256withRSA": "1.2.840.113549.1.1.11",
+ "SHA384withRSA": "1.2.840.113549.1.1.12",
+ "SHA512withRSA": "1.2.840.113549.1.1.13",
+ "SHA1withECDSA": "1.2.840.10045.4.1",
+ "SHA224withECDSA": "1.2.840.10045.4.3.1",
+ "SHA256withECDSA": "1.2.840.10045.4.3.2",
+ "SHA384withECDSA": "1.2.840.10045.4.3.3",
+ "SHA512withECDSA": "1.2.840.10045.4.3.4",
+ "dsa": "1.2.840.10040.4.1",
+ "SHA1withDSA": "1.2.840.10040.4.3",
+ "SHA224withDSA": "2.16.840.1.101.3.4.3.1",
+ "SHA256withDSA": "2.16.840.1.101.3.4.3.2",
+ "rsaEncryption": "1.2.840.113549.1.1.1",
+ "commonName": "2.5.4.3",
+ "countryName": "2.5.4.6",
+ "localityName": "2.5.4.7",
+ "stateOrProvinceName": "2.5.4.8",
+ "streetAddress": "2.5.4.9",
+ "organizationName": "2.5.4.10",
+ "organizationalUnitName": "2.5.4.11",
+ "domainComponent": "0.9.2342.19200300.100.1.25",
+ "userId": "0.9.2342.19200300.100.1.1",
+ "surname": "2.5.4.4",
+ "title": "2.5.4.12",
+ "distinguishedName": "2.5.4.49",
+ "emailAddress": "1.2.840.113549.1.9.1",
+ "description": "2.5.4.13",
+ "businessCategory": "2.5.4.15",
+ "postalCode": "2.5.4.17",
+ "uniqueIdentifier": "2.5.4.45",
+ "organizationIdentifier": "2.5.4.97",
+ "jurisdictionOfIncorporationL": "1.3.6.1.4.1.311.60.2.1.1",
+ "jurisdictionOfIncorporationSP": "1.3.6.1.4.1.311.60.2.1.2",
+ "jurisdictionOfIncorporationC": "1.3.6.1.4.1.311.60.2.1.3",
+ "subjectKeyIdentifier": "2.5.29.14",
+ "keyUsage": "2.5.29.15",
+ "subjectAltName": "2.5.29.17",
+ "issuerAltName": "2.5.29.18",
+ "basicConstraints": "2.5.29.19",
+ "nameConstraints": "2.5.29.30",
+ "cRLDistributionPoints": "2.5.29.31",
+ "certificatePolicies": "2.5.29.32",
+ "authorityKeyIdentifier": "2.5.29.35",
+ "policyConstraints": "2.5.29.36",
+ "extKeyUsage": "2.5.29.37",
+ "authorityInfoAccess": "1.3.6.1.5.5.7.1.1",
+ "ocsp": "1.3.6.1.5.5.7.48.1",
+ "caIssuers": "1.3.6.1.5.5.7.48.2",
+ "anyExtendedKeyUsage": "2.5.29.37.0",
+ "serverAuth": "1.3.6.1.5.5.7.3.1",
+ "clientAuth": "1.3.6.1.5.5.7.3.2",
+ "codeSigning": "1.3.6.1.5.5.7.3.3",
+ "emailProtection": "1.3.6.1.5.5.7.3.4",
+ "timeStamping": "1.3.6.1.5.5.7.3.8",
+ "ocspSigning": "1.3.6.1.5.5.7.3.9",
+ "ecPublicKey": "1.2.840.10045.2.1",
+ "secp256r1": "1.2.840.10045.3.1.7",
+ "secp256k1": "1.3.132.0.10",
+ "secp384r1": "1.3.132.0.34",
+ "pkcs5PBES2": "1.2.840.113549.1.5.13",
+ "pkcs5PBKDF2": "1.2.840.113549.1.5.12",
+ "des-EDE3-CBC": "1.2.840.113549.3.7",
+ "data": "1.2.840.113549.1.7.1",
+ "signed-data": "1.2.840.113549.1.7.2",
+ "enveloped-data": "1.2.840.113549.1.7.3",
+ "digested-data": "1.2.840.113549.1.7.5",
+ "encrypted-data": "1.2.840.113549.1.7.6",
+ "authenticated-data": "1.2.840.113549.1.9.16.1.2",
+ "tstinfo": "1.2.840.113549.1.9.16.1.4",
+ "extensionRequest": "1.2.840.113549.1.9.14"
+ };
+ this.objCache = {};
+
+ this.name2obj = function (n) {
+ if (typeof this.objCache[n] != "undefined") return this.objCache[n];
+ if (typeof this.name2oidList[n] == "undefined") throw "Name of ObjectIdentifier not defined: " + n;
+ var A = this.name2oidList[n];
+ var L = new KJUR.asn1.DERObjectIdentifier({
+ "oid": A
+ });
+ return this.objCache[n] = L, L;
+ };
+
+ this.atype2obj = function (n) {
+ if (typeof this.objCache[n] != "undefined") return this.objCache[n];
+ if (typeof this.atype2oidList[n] == "undefined") throw "AttributeType name undefined: " + n;
+ var A = this.atype2oidList[n];
+ var L = new KJUR.asn1.DERObjectIdentifier({
+ "oid": A
+ });
+ return this.objCache[n] = L, L;
+ };
+}();
+
+KJUR.asn1.x509.OID.oid2name = function (p) {
+ var n = KJUR.asn1.x509.OID.name2oidList;
+
+ for (var A in n) {
+ if (n[A] == p) return A;
+ }
+
+ return "";
+};
+
+KJUR.asn1.x509.OID.oid2atype = function (p) {
+ var n = KJUR.asn1.x509.OID.atype2oidList;
+
+ for (var A in n) {
+ if (n[A] == p) return A;
+ }
+
+ return p;
+};
+
+KJUR.asn1.x509.OID.name2oid = function (p) {
+ var n = KJUR.asn1.x509.OID.name2oidList;
+ if (n[p] === undefined) return "";
+ return n[p];
+};
+
+KJUR.asn1.x509.X509Util = {};
+
+KJUR.asn1.x509.X509Util.newCertPEM = function (p) {
+ var n = KJUR.asn1.x509;
+ var A = n.TBSCertificate;
+ var L = n.Certificate;
+ var S = new A();
+ if (p.serial !== undefined) S.setSerialNumberByParam(p.serial);else throw "serial number undefined.";
+ if (typeof p.sigalg.name === "string") S.setSignatureAlgByParam(p.sigalg);else throw "unproper signature algorithm name";
+ if (p.issuer !== undefined) S.setIssuerByParam(p.issuer);else throw "issuer name undefined.";
+ if (p.notbefore !== undefined) S.setNotBeforeByParam(p.notbefore);else throw "notbefore undefined.";
+ if (p.notafter !== undefined) S.setNotAfterByParam(p.notafter);else throw "notafter undefined.";
+ if (p.subject !== undefined) S.setSubjectByParam(p.subject);else throw "subject name undefined.";
+ if (p.sbjpubkey !== undefined) S.setSubjectPublicKeyByGetKey(p.sbjpubkey);else throw "subject public key undefined.";
+ if (p.ext !== undefined && p.ext.length !== undefined) for (var Y = 0; Y < p.ext.length; Y++) {
+ for (key in p.ext[Y]) {
+ S.appendExtensionByName(key, p.ext[Y][key]);
+ }
+ }
+ if (p.cakey === undefined && p.sighex === undefined) throw "param cakey and sighex undefined.";
+ var J = null;
+ var C = null;
+ return p.cakey && (p.cakey.isPrivate === !![] ? J = p.cakey : J = KEYUTIL.getKey.apply(null, p.cakey), C = new L({
+ "tbscertobj": S,
+ "prvkeyobj": J
+ }), C.sign()), p.sighex && (C = new L({
+ "tbscertobj": S
+ }), C.setSignatureHex(p.sighex)), C.getPEMString();
+};
+
+if (typeof KJUR == "undefined" || !KJUR) {
+ KJUR = {};
+}
+
+if (typeof KJUR.asn1 == "undefined" || !KJUR.asn1) {
+ KJUR.asn1 = {};
+}
+
+if (typeof KJUR.asn1.cms == "undefined" || !KJUR.asn1.cms) {
+ KJUR.asn1.cms = {};
+}
+
+KJUR.asn1.cms.Attribute = function (p) {
+ var n = [];
+ var A = KJUR;
+ var L = A.asn1;
+ L.cms.Attribute.superclass.constructor.call(this);
+
+ this.getEncodedHex = function () {
+ var S;
+ var Y;
+ var J;
+ S = new L.DERObjectIdentifier({
+ "oid": this.attrTypeOid
+ });
+ Y = new L.DERSet({
+ "array": this.valueList
+ });
+
+ try {
+ Y.getEncodedHex();
+ } catch (C) {
+ console.log(C);
+ throw "fail valueSet.getEncodedHex in Attribute(1)/" + C;
+ }
+
+ J = new L.DERSequence({
+ "array": [S, Y]
+ });
+
+ try {
+ this.hTLV = J.getEncodedHex();
+ } catch (V) {
+ console.log(V);
+ throw "failed seq.getEncodedHex in Attribute(2)/" + V;
+ }
+
+ return this.hTLV;
+ };
+};
+
+YAHOO.lang.extend(KJUR.asn1.cms.Attribute, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.cms.ContentType = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ A.cms.ContentType.superclass.constructor.call(this);
+ this.attrTypeOid = "1.2.840.113549.1.9.3";
+ var L = null;
+
+ if (typeof p != "undefined") {
+ var L = new A.DERObjectIdentifier(p);
+ this.valueList = [L];
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.cms.ContentType, KJUR.asn1.cms.Attribute);
+
+KJUR.asn1.cms.MessageDigest = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DEROctetString;
+ var S = A.cms;
+ S.MessageDigest.superclass.constructor.call(this);
+ this.attrTypeOid = "1.2.840.113549.1.9.4";
+
+ if (p !== undefined) {
+ if (p.eciObj instanceof S.EncapsulatedContentInfo && typeof p.hashAlg === "string") {
+ var Y = p.eciObj.eContentValueHex;
+ var J = p.hashAlg;
+ var C = n.crypto.Util.hashHex(Y, J);
+ var V = new L({
+ "hex": C
+ });
+ V.getEncodedHex();
+ this.valueList = [V];
+ } else {
+ var V = new L(p);
+ V.getEncodedHex();
+ this.valueList = [V];
+ }
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.cms.MessageDigest, KJUR.asn1.cms.Attribute);
+
+KJUR.asn1.cms.SigningTime = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ A.cms.SigningTime.superclass.constructor.call(this);
+ this.attrTypeOid = "1.2.840.113549.1.9.5";
+
+ if (p !== undefined) {
+ var L = new A.x509.Time(p);
+
+ try {
+ L.getEncodedHex();
+ } catch (g) {
+ console.log(g);
+ throw "SigningTime.getEncodedHex() failed/" + g;
+ }
+
+ this.valueList = [L];
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.cms.SigningTime, KJUR.asn1.cms.Attribute);
+
+KJUR.asn1.cms.SigningCertificate = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERSequence;
+ var g = A.cms;
+ var S = n.crypto;
+ g.SigningCertificate.superclass.constructor.call(this);
+ this.attrTypeOid = "1.2.840.113549.1.9.16.2.12";
+
+ this.setCerts = function (Y) {
+ var J = [];
+
+ for (var C = 0; C < Y.length; C++) {
+ var V = pemtohex(Y[C]);
+ var W = n.crypto.Util.hashHex(V, "sha1");
+ var R = new A.DEROctetString({
+ "hex": W
+ });
+ R.getEncodedHex();
+ var B = new g.IssuerAndSerialNumber({
+ "cert": Y[C]
+ });
+ B.getEncodedHex();
+ var F = new L({
+ "array": [R, B]
+ });
+ F.getEncodedHex();
+ J.push(F);
+ }
+
+ var E = new L({
+ "array": J
+ });
+ E.getEncodedHex();
+ this.valueList = [E];
+ };
+
+ p !== undefined && typeof p.array == "object" && this.setCerts(p.array);
+};
+
+YAHOO.lang.extend(KJUR.asn1.cms.SigningCertificate, KJUR.asn1.cms.Attribute);
+
+KJUR.asn1.cms.SigningCertificateV2 = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERSequence;
+ var S = A.x509;
+ var Y = A.cms;
+ var J = n.crypto;
+ Y.SigningCertificateV2.superclass.constructor.call(this);
+ this.attrTypeOid = "1.2.840.113549.1.9.16.2.47";
+
+ this.setCerts = function (V, W) {
+ var R = [];
+
+ for (var B = 0; B < V.length; B++) {
+ var F = pemtohex(V[B]);
+ var E = [];
+
+ if (W !== "sha256") {
+ E.push(new S.AlgorithmIdentifier({
+ "name": W
+ }));
+ }
+
+ var I = J.Util.hashHex(F, W);
+ var K = new A.DEROctetString({
+ "hex": I
+ });
+ K.getEncodedHex();
+ E.push(K);
+ var T = new Y.IssuerAndSerialNumber({
+ "cert": V[B]
+ });
+ T.getEncodedHex();
+ E.push(T);
+ var i = new L({
+ "array": E
+ });
+ i.getEncodedHex();
+ R.push(i);
+ }
+
+ var Z = new L({
+ "array": R
+ });
+ Z.getEncodedHex();
+ this.valueList = [Z];
+ };
+
+ if (p !== undefined) {
+ if (typeof p.array == "object") {
+ var C = "sha256";
+ typeof p.hashAlg == "string" && (C = p.hashAlg);
+ this.setCerts(p.array, C);
+ }
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.cms.SigningCertificateV2, KJUR.asn1.cms.Attribute);
+
+KJUR.asn1.cms.IssuerAndSerialNumber = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERInteger;
+ var S = A.cms;
+ var Y = A.x509;
+ var J = Y.X500Name;
+ var C = X509;
+ S.IssuerAndSerialNumber.superclass.constructor.call(this);
+ var V = null;
+ var W = null;
+
+ this.setByCertPEM = function (R) {
+ var B = pemtohex(R);
+ var F = new C();
+ F.hex = B;
+ var E = F.getIssuerHex();
+ this.dIssuer = new J();
+ this.dIssuer.hTLV = E;
+ var s = F.getSerialNumberHex();
+ this.dSerial = new L({
+ "hex": s
+ });
+ };
+
+ this.getEncodedHex = function () {
+ var l = new A.DERSequence({
+ "array": [this.dIssuer, this.dSerial]
+ });
+ return this.hTLV = l.getEncodedHex(), this.hTLV;
+ };
+
+ p !== undefined && (typeof p == "string" && p.indexOf("-----BEGIN ") != -1 && this.setByCertPEM(p), p.issuer && p.serial && (p.issuer instanceof J ? this.dIssuer = p.issuer : this.dIssuer = new J(p.issuer), p.serial instanceof L ? this.dSerial = p.serial : this.dSerial = new L(p.serial)), typeof p.cert == "string" && this.setByCertPEM(p.cert));
+};
+
+YAHOO.lang.extend(KJUR.asn1.cms.IssuerAndSerialNumber, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.cms.AttributeList = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.cms;
+ L.AttributeList.superclass.constructor.call(this);
+ this.list = new Array();
+ this.sortFlag = !![];
+
+ this.add = function (g) {
+ if (g instanceof L.Attribute) {
+ this.list.push(g);
+ }
+ };
+
+ this.length = function () {
+ return this.list.length;
+ };
+
+ this.clear = function () {
+ this.list = new Array();
+ this.hTLV = null;
+ this.hV = null;
+ };
+
+ this.getEncodedHex = function () {
+ if (typeof this.hTLV == "string") return this.hTLV;
+ var g = new A.DERSet({
+ "array": this.list,
+ "sortflag": this.sortFlag
+ });
+ return this.hTLV = g.getEncodedHex(), this.hTLV;
+ };
+
+ p !== undefined && typeof p.sortflag != "undefined" && p.sortflag == ![] && (this.sortFlag = ![]);
+};
+
+YAHOO.lang.extend(KJUR.asn1.cms.AttributeList, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.cms.SignerInfo = function (p) {
+ var A = KJUR;
+ var L = A.asn1;
+ var S = L.DERTaggedObject;
+ var Y = L.cms;
+ var J = Y.AttributeList;
+ var C = Y.ContentType;
+ var V = Y.EncapsulatedContentInfo;
+ var W = Y.MessageDigest;
+ var R = Y.SignedData;
+ var B = L.x509;
+ var F = B.AlgorithmIdentifier;
+ var E = A.crypto;
+ var s = KEYUTIL;
+ Y.SignerInfo.superclass.constructor.call(this);
+ this.dCMSVersion = new L.DERInteger({
+ "int": 1
+ });
+ this.dSignerIdentifier = null;
+ this.dDigestAlgorithm = null;
+ this.dSignedAttrs = new J();
+ this.dSigAlg = null;
+ this.dSig = null;
+ this.dUnsignedAttrs = new J();
+
+ this.setSignerIdentifier = function (I) {
+ if (typeof I == "string" && I.indexOf("CERTIFICATE") != -1 && I.indexOf("BEGIN") != -1 && I.indexOf("END") != -1) {
+ var K = I;
+ this.dSignerIdentifier = new Y.IssuerAndSerialNumber({
+ "cert": I
+ });
+ }
+ };
+
+ this.setForContentAndHash = function (I) {
+ if (I !== undefined) {
+ I.eciObj instanceof V && (this.dSignedAttrs.add(new C({
+ "oid": "1.2.840.113549.1.7.1"
+ })), this.dSignedAttrs.add(new W({
+ "eciObj": I.eciObj,
+ "hashAlg": I.hashAlg
+ })));
+ I.sdObj !== undefined && I.sdObj instanceof R && I.sdObj.digestAlgNameList.join(":").indexOf(I.hashAlg) == -1 && I.sdObj.digestAlgNameList.push(I.hashAlg);
+ typeof I.hashAlg == "string" && (this.dDigestAlgorithm = new F({
+ "name": I.hashAlg
+ }));
+ }
+ };
+
+ this.sign = function (I, K) {
+ this.dSigAlg = new F({
+ "name": K
+ });
+ var T = this.dSignedAttrs.getEncodedHex();
+ var Z = s.getKey(I);
+ var w = new E.Signature({
+ "alg": K
+ });
+ w.init(Z);
+ w.updateHex(T);
+ var M = w.sign();
+ this.dSig = new L.DEROctetString({
+ "hex": M
+ });
+ };
+
+ this.addUnsigned = function (I) {
+ this.hTLV = null;
+ this.dUnsignedAttrs.hTLV = null;
+ this.dUnsignedAttrs.add(I);
+ };
+
+ this.getEncodedHex = function () {
+ if (this.dSignedAttrs instanceof J && this.dSignedAttrs.length() == 0) throw "SignedAttrs length = 0 (empty)";
+ var I = new S({
+ "obj": this.dSignedAttrs,
+ "tag": "a0",
+ "explicit": ![]
+ });
+ var K = null;
+
+ if (this.dUnsignedAttrs.length() > 0) {
+ K = new S({
+ "obj": this.dUnsignedAttrs,
+ "tag": "a1",
+ "explicit": ![]
+ });
+ }
+
+ var T = [this.dCMSVersion, this.dSignerIdentifier, this.dDigestAlgorithm, I, this.dSigAlg, this.dSig];
+
+ if (K != null) {
+ T.push(K);
+ }
+
+ var Z = new L.DERSequence({
+ "array": T
+ });
+ return this.hTLV = Z.getEncodedHex(), this.hTLV;
+ };
+};
+
+YAHOO.lang.extend(KJUR.asn1.cms.SignerInfo, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.cms.EncapsulatedContentInfo = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERTaggedObject;
+ var S = A.DERSequence;
+ var Y = A.DERObjectIdentifier;
+ var J = A.DEROctetString;
+ var C = A.cms;
+ C.EncapsulatedContentInfo.superclass.constructor.call(this);
+ this.dEContentType = new Y({
+ "name": "data"
+ });
+ this.dEContent = null;
+ this.isDetached = ![];
+ this.eContentValueHex = null;
+
+ this.setContentType = function (V) {
+ if (V.match(/^[0-2][.][0-9.]+$/)) {
+ this.dEContentType = new Y({
+ "oid": V
+ });
+ } else {
+ this.dEContentType = new Y({
+ "name": V
+ });
+ }
+ };
+
+ this.setContentValue = function (V) {
+ if (V !== undefined) {
+ typeof V.hex == "string" ? this.eContentValueHex = V.hex : typeof V.str == "string" && (this.eContentValueHex = utf8tohex(V.str));
+ }
+ };
+
+ this.setContentValueHex = function (V) {
+ this.eContentValueHex = V;
+ };
+
+ this.setContentValueStr = function (V) {
+ this.eContentValueHex = utf8tohex(V);
+ };
+
+ this.getEncodedHex = function () {
+ if (typeof this.eContentValueHex != "string") throw "eContentValue not yet set";
+ var V = new J({
+ "hex": this.eContentValueHex
+ });
+ this.dEContent = new L({
+ "obj": V,
+ "tag": "a0",
+ "explicit": !![]
+ });
+ var W = [this.dEContentType];
+
+ if (!this.isDetached) {
+ W.push(this.dEContent);
+ }
+
+ var l = new S({
+ "array": W
+ });
+ return this.hTLV = l.getEncodedHex(), this.hTLV;
+ };
+};
+
+YAHOO.lang.extend(KJUR.asn1.cms.EncapsulatedContentInfo, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.cms.ContentInfo = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERTaggedObject;
+ var g = A.DERSequence;
+ var S = A.x509;
+ KJUR.asn1.cms.ContentInfo.superclass.constructor.call(this);
+ this.dContentType = null;
+ this.dContent = null;
+
+ this.setContentType = function (Y) {
+ if (typeof Y == "string") {
+ this.dContentType = S.OID.name2obj(Y);
+ }
+ };
+
+ this.getEncodedHex = function () {
+ var Y = new L({
+ "obj": this.dContent,
+ "tag": "a0",
+ "explicit": !![]
+ });
+ var J = new g({
+ "array": [this.dContentType, Y]
+ });
+ return this.hTLV = J.getEncodedHex(), this.hTLV;
+ };
+
+ p !== undefined && (p.type && this.setContentType(p.type), p.obj && p.obj instanceof A.ASN1Object && (this.dContent = p.obj));
+};
+
+YAHOO.lang.extend(KJUR.asn1.cms.ContentInfo, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.cms.SignedData = function (p) {
+ var A = KJUR;
+ var L = A.asn1;
+ var S = L.ASN1Object;
+ var Y = L.DERInteger;
+ var J = L.DERSet;
+ var C = L.DERSequence;
+ var V = L.DERTaggedObject;
+ var W = L.cms;
+ var R = W.EncapsulatedContentInfo;
+ var B = W.SignerInfo;
+ var F = W.ContentInfo;
+ var E = L.x509;
+ var s = E.AlgorithmIdentifier;
+ KJUR.asn1.cms.SignedData.superclass.constructor.call(this);
+ this.dCMSVersion = new Y({
+ "int": 1
+ });
+ this.dDigestAlgs = null;
+ this.digestAlgNameList = [];
+ this.dEncapContentInfo = new R();
+ this.dCerts = null;
+ this.certificateList = [];
+ this.crlList = [];
+ this.signerInfoList = [new B()];
+
+ this.addCertificatesByPEM = function (I) {
+ var K = pemtohex(I);
+ var T = new S();
+ T.hTLV = K;
+ this.certificateList.push(T);
+ };
+
+ this.getEncodedHex = function () {
+ if (typeof this.hTLV == "string") return this.hTLV;
+
+ if (this.dDigestAlgs == null) {
+ var I = [];
+
+ for (var K = 0; K < this.digestAlgNameList.length; K++) {
+ var T = this.digestAlgNameList[K];
+ var Z = new s({
+ "name": T
+ });
+ I.push(Z);
+ }
+
+ this.dDigestAlgs = new J({
+ "array": I
+ });
+ }
+
+ var M = [this.dCMSVersion, this.dDigestAlgs, this.dEncapContentInfo];
+
+ if (this.dCerts == null) {
+ if (this.certificateList.length > 0) {
+ var U = new J({
+ "array": this.certificateList
+ });
+ this.dCerts = new V({
+ "obj": U,
+ "tag": "a0",
+ "explicit": ![]
+ });
+ }
+ }
+
+ if (this.dCerts != null) {
+ M.push(this.dCerts);
+ }
+
+ var H = new J({
+ "array": this.signerInfoList
+ });
+ M.push(H);
+ var O = new C({
+ "array": M
+ });
+ return this.hTLV = O.getEncodedHex(), this.hTLV;
+ };
+
+ this.getContentInfo = function () {
+ this.getEncodedHex();
+ var I = new F({
+ "type": "signed-data",
+ "obj": this
+ });
+ return I;
+ };
+
+ this.getContentInfoEncodedHex = function () {
+ var I = this.getContentInfo();
+ var K = I.getEncodedHex();
+ return K;
+ };
+
+ this.getPEM = function () {
+ return hextopem(this.getContentInfoEncodedHex(), "CMS");
+ };
+};
+
+YAHOO.lang.extend(KJUR.asn1.cms.SignedData, KJUR.asn1.ASN1Object);
+KJUR.asn1.cms.CMSUtil = new function () {}();
+
+KJUR.asn1.cms.CMSUtil.newSignedData = function (A) {
+ var L = KJUR;
+ var S = L.asn1;
+ var Y = S.cms;
+ var J = Y.SignerInfo;
+ var C = Y.SignedData;
+ var V = Y.SigningTime;
+ var W = Y.SigningCertificate;
+ var R = Y.SigningCertificateV2;
+ var B = S.cades;
+ var F = B.SignaturePolicyIdentifier;
+ var E = new C();
+ E.dEncapContentInfo.setContentValue(A.content);
+
+ if (typeof A.detached == "boolean") {
+ E.dEncapContentInfo.isDetached = A.detached;
+ }
+
+ if (typeof A.certs == "object") for (var s = 0; s < A.certs.length; s++) {
+ E.addCertificatesByPEM(A.certs[s]);
+ }
+ E.signerInfoList = [];
+
+ for (var s = 0; s < A.signerInfos.length; s++) {
+ var I = A.signerInfos[s];
+ var K = new J();
+ K.setSignerIdentifier(I.signerCert);
+ K.setForContentAndHash({
+ "sdObj": E,
+ "eciObj": E.dEncapContentInfo,
+ "hashAlg": I.hashAlg
+ });
+
+ for (attrName in I.sAttr) {
+ var T = I.sAttr[attrName];
+
+ if (attrName == "SigningTime") {
+ var i = new V(T);
+ K.dSignedAttrs.add(i);
+ }
+
+ if (attrName == "SigningCertificate") {
+ var i = new W(T);
+ K.dSignedAttrs.add(i);
+ }
+
+ if (attrName == "SigningCertificateV2") {
+ var i = new R(T);
+ K.dSignedAttrs.add(i);
+ }
+
+ if (attrName == "SignaturePolicyIdentifier") {
+ var i = new F(T);
+ K.dSignedAttrs.add(i);
+ }
+ }
+
+ K.sign(I.signerPrvKey, I.sigAlg);
+ E.signerInfoList.push(K);
+ }
+
+ return E;
+};
+
+KJUR.asn1.cms.CMSUtil.verifySignedData = function (L) {
+ var S = KJUR;
+ var Y = S.asn1;
+ var J = Y.cms;
+ var V = J.SignerInfo;
+ var W = J.SignedData;
+ var R = J.SigningTime;
+ var F = J.SigningCertificate;
+ var I = J.SigningCertificateV2;
+ var K = Y.cades;
+ var T = K.SignaturePolicyIdentifier;
+ var Z = S.lang.String.isHex;
+ var M = ASN1HEX;
+ var U = M.getVbyList;
+ var H = M.getTLVbyList;
+ var O = M.getIdxbyList;
+ var X = M.getChildIdx;
+ var G = M.getTLV;
+ var N = M.oidname;
+ var Q = S.crypto.Util.hashHex;
+
+ if (L.cms === undefined && !Z(L.cms)) {}
+
+ var P = L.cms;
+
+ var p0 = function (pp, pn) {
+ var pc;
+
+ for (var pa = 3; pa < 6; pa++) {
+ pc = O(pp, 0, [1, 0, pa]);
+
+ if (pc !== undefined) {
+ var pA = pp.substr(pc, 2);
+ pA === "a0" && (pn.certsIdx = pc);
+ pA === "a1" && (pn.revinfosIdx = pc);
+ pA === "31" && (pn.signerinfosIdx = pc);
+ }
+ }
+ };
+
+ var p1 = function (pp, pn) {
+ var pc = pn.signerinfosIdx;
+ if (pc === undefined) return;
+ var pa = X(pp, pc);
+ pn.signerInfoIdxList = pa;
+
+ for (var pA = 0; pA < pa.length; pA++) {
+ var pL = pa[pA];
+ var pg = {
+ "idx": pL
+ };
+ p2(pp, pg);
+ pn.signerInfos.push(pg);
+ }
+ };
+
+ var p2 = function (pp, pn) {
+ var pc = pn.idx;
+ pn.signerid_issuer1 = H(pp, pc, [1, 0], "30");
+ pn.signerid_serial1 = U(pp, pc, [1, 1], "02");
+ pn.hashalg = N(U(pp, pc, [2, 0], "06"));
+ var pa = O(pp, pc, [3], "a0");
+ pn.idxSignedAttrs = pa;
+ p3(pp, pn, pa);
+ var pA = X(pp, pc);
+ var pL = pA.length;
+ if (pL < 6) throw "malformed SignerInfo";
+ pn.sigalg = N(U(pp, pc, [pL - 2, 0], "06"));
+ pn.sigval = U(pp, pc, [pL - 1], "04");
+ };
+
+ var p3 = function (pp, pn, pc) {
+ var pa = X(pp, pc);
+ pn.signedAttrIdxList = pa;
+
+ for (var pA = 0; pA < pa.length; pA++) {
+ var pL = pa[pA];
+ var pg = U(pp, pL, [0], "06");
+ var pS;
+
+ if (pg === "2a864886f70d010905") {
+ pS = hextoutf8(U(pp, pL, [1, 0]));
+ pn.saSigningTime = pS;
+ } else {
+ if (pg === "2a864886f70d010904") {
+ pS = U(pp, pL, [1, 0], "04");
+ pn.saMessageDigest = pS;
+ }
+ }
+ }
+ };
+
+ var p4 = function (pp, pn) {
+ if (U(pp, 0, [0], "06") !== "2a864886f70d010702") return pn;
+ pn.cmsType = "signedData";
+ pn.econtent = U(pp, 0, [1, 0, 2, 1, 0]);
+ p0(pp, pn);
+ pn.signerInfos = [];
+ p1(pp, pn);
+ };
+
+ var p5 = function (pp, pn) {
+ var pc = pn.parse.signerInfos;
+ var pa = pc.length;
+ var pA = !![];
+
+ for (var pL = 0; pL < pa; pL++) {
+ var pg = pc[pL];
+ p7(pp, pn, pg, pL);
+ !pg.isValid && (pA = ![]);
+ }
+
+ pn.isValid = pA;
+ };
+
+ var p6 = function (pp, pn, pc, pa) {
+ var pA = pn.parse.certsIdx;
+ var pL;
+
+ if (pn.certs === undefined) {
+ pL = [];
+ pn.certkeys = [];
+ var pg = X(pp, pA);
+
+ for (var pS = 0; pS < pg.length; pS++) {
+ var pf = G(pp, pg[pS]);
+ var pY = new X509();
+ pY.readCertHex(pf);
+ pL[pS] = pY;
+ pn.certkeys[pS] = pY.getPublicKey();
+ }
+
+ pn.certs = pL;
+ } else pL = pn.certs;
+
+ pn.cccc = pL.length;
+ pn.cccci = pg.length;
+
+ for (var pS = 0; pS < pL.length; pS++) {
+ var pJ = pY.getIssuerHex();
+ var pb = pY.getSerialNumberHex();
+
+ if (pc.signerid_issuer1 === pJ && pc.signerid_serial1 === pb) {
+ pc.certkey_idx = pS;
+ }
+ }
+ };
+
+ var p7 = function (pp, pn, pc, pa) {
+ pc.verifyDetail = {};
+ var pA = pc.verifyDetail;
+ var pL = pn.parse.econtent;
+ var pg = pc.hashalg;
+ var pS = pc.saMessageDigest;
+ pA.validMessageDigest = ![];
+
+ if (Q(pL, pg) === pS) {
+ pA.validMessageDigest = !![];
+ }
+
+ p6(pp, pn, pc, pa);
+ pA.validSignatureValue = ![];
+ var pf = pc.sigalg;
+ var pY = "31" + G(pp, pc.idxSignedAttrs).substr(2);
+ pc.signedattrshex = pY;
+ var pJ = pn.certs[pc.certkey_idx].getPublicKey();
+ var pb = new KJUR.crypto.Signature({
+ "alg": pf
+ });
+ pb.init(pJ);
+ pb.updateHex(pY);
+ var pC = pb.verify(pc.sigval);
+ pA.validSignatureValue_isValid = pC;
+ pC === !![] && (pA.validSignatureValue = !![]);
+ pc.isValid = ![];
+ pA.validMessageDigest && pA.validSignatureValue && (pc.isValid = !![]);
+ };
+
+ var p8 = function () {};
+
+ var p9 = {
+ "isValid": ![],
+ "parse": {}
+ };
+ return p4(P, p9.parse), p5(P, p9), p9;
+};
+
+if (typeof KJUR == "undefined" || !KJUR) {
+ KJUR = {};
+}
+
+if (typeof KJUR.asn1 == "undefined" || !KJUR.asn1) {
+ KJUR.asn1 = {};
+}
+
+if (typeof KJUR.asn1.tsp == "undefined" || !KJUR.asn1.tsp) {
+ KJUR.asn1.tsp = {};
+}
+
+KJUR.asn1.tsp.Accuracy = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERInteger;
+ var g = A.DERSequence;
+ var S = A.DERTaggedObject;
+ A.tsp.Accuracy.superclass.constructor.call(this);
+ this.seconds = null;
+ this.millis = null;
+ this.micros = null;
+
+ this.getEncodedHex = function () {
+ var Y = null;
+ var J = null;
+ var C = null;
+ var V = [];
+
+ if (this.seconds != null) {
+ Y = new L({
+ "int": this.seconds
+ });
+ V.push(Y);
+ }
+
+ if (this.millis != null) {
+ var W = new L({
+ "int": this.millis
+ });
+ J = new S({
+ "obj": W,
+ "tag": "80",
+ "explicit": ![]
+ });
+ V.push(J);
+ }
+
+ if (this.micros != null) {
+ var R = new L({
+ "int": this.micros
+ });
+ C = new S({
+ "obj": R,
+ "tag": "81",
+ "explicit": ![]
+ });
+ V.push(C);
+ }
+
+ var B = new g({
+ "array": V
+ });
+ return this.hTLV = B.getEncodedHex(), this.hTLV;
+ };
+
+ p !== undefined && (typeof p.seconds == "number" && (this.seconds = p.seconds), typeof p.millis == "number" && (this.millis = p.millis), typeof p.micros == "number" && (this.micros = p.micros));
+};
+
+YAHOO.lang.extend(KJUR.asn1.tsp.Accuracy, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.tsp.MessageImprint = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERSequence;
+ var S = A.DEROctetString;
+ var Y = A.x509;
+ var J = Y.AlgorithmIdentifier;
+ A.tsp.MessageImprint.superclass.constructor.call(this);
+ this.dHashAlg = null;
+ this.dHashValue = null;
+
+ this.getEncodedHex = function () {
+ if (typeof this.hTLV == "string") return this.hTLV;
+ var C = new L({
+ "array": [this.dHashAlg, this.dHashValue]
+ });
+ return C.getEncodedHex();
+ };
+
+ p !== undefined && (typeof p.hashAlg == "string" && (this.dHashAlg = new J({
+ "name": p.hashAlg
+ })), typeof p.hashValue == "string" && (this.dHashValue = new S({
+ "hex": p.hashValue
+ })));
+};
+
+YAHOO.lang.extend(KJUR.asn1.tsp.MessageImprint, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.tsp.TimeStampReq = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERSequence;
+ var S = A.DERInteger;
+ var Y = A.DERBoolean;
+ var J = A.DERObjectIdentifier;
+ var C = A.tsp;
+ var V = C.MessageImprint;
+ C.TimeStampReq.superclass.constructor.call(this);
+ this.dVersion = new S({
+ "int": 1
+ });
+ this.dMessageImprint = null;
+ this.dPolicy = null;
+ this.dNonce = null;
+ this.certReq = !![];
+
+ this.setMessageImprint = function (W) {
+ if (W instanceof V) {
+ this.dMessageImprint = W;
+ return;
+ }
+
+ if (typeof W == "object") {
+ this.dMessageImprint = new V(W);
+ }
+ };
+
+ this.getEncodedHex = function () {
+ if (this.dMessageImprint == null) throw "messageImprint shall be specified";
+ var W = [this.dVersion, this.dMessageImprint];
+
+ if (this.dPolicy != null) {
+ W.push(this.dPolicy);
+ }
+
+ if (this.dNonce != null) {
+ W.push(this.dNonce);
+ }
+
+ if (this.certReq) {
+ W.push(new Y());
+ }
+
+ var l = new L({
+ "array": W
+ });
+ return this.hTLV = l.getEncodedHex(), this.hTLV;
+ };
+
+ p !== undefined && (typeof p.mi == "object" && this.setMessageImprint(p.mi), typeof p.policy == "object" && (this.dPolicy = new J(p.policy)), typeof p.nonce == "object" && (this.dNonce = new S(p.nonce)), typeof p.certreq == "boolean" && (this.certReq = p.certreq));
+};
+
+YAHOO.lang.extend(KJUR.asn1.tsp.TimeStampReq, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.tsp.TSTInfo = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERSequence;
+ var S = A.DERInteger;
+ var Y = A.DERBoolean;
+ var J = A.DERGeneralizedTime;
+ var C = A.DERObjectIdentifier;
+ var V = A.tsp;
+ var W = V.MessageImprint;
+ var R = V.Accuracy;
+ var B = A.x509.X500Name;
+ V.TSTInfo.superclass.constructor.call(this);
+ this.dVersion = new S({
+ "int": 1
+ });
+ this.dPolicy = null;
+ this.dMessageImprint = null;
+ this.dSerialNumber = null;
+ this.dGenTime = null;
+ this.dAccuracy = null;
+ this.dOrdering = null;
+ this.dNonce = null;
+ this.dTsa = null;
+
+ this.getEncodedHex = function () {
+ var F = [this.dVersion];
+ if (this.dPolicy == null) throw "policy shall be specified.";
+ F.push(this.dPolicy);
+ if (this.dMessageImprint == null) throw "messageImprint shall be specified.";
+ F.push(this.dMessageImprint);
+ if (this.dSerialNumber == null) throw "serialNumber shall be specified.";
+ F.push(this.dSerialNumber);
+ if (this.dGenTime == null) throw "genTime shall be specified.";
+ F.push(this.dGenTime);
+
+ if (this.dAccuracy != null) {
+ F.push(this.dAccuracy);
+ }
+
+ if (this.dOrdering != null) {
+ F.push(this.dOrdering);
+ }
+
+ if (this.dNonce != null) {
+ F.push(this.dNonce);
+ }
+
+ if (this.dTsa != null) {
+ F.push(this.dTsa);
+ }
+
+ var E = new L({
+ "array": F
+ });
+ return this.hTLV = E.getEncodedHex(), this.hTLV;
+ };
+
+ if (p !== undefined) {
+ if (typeof p.policy == "string") {
+ if (!p.policy.match(/^[0-9.]+$/)) throw "policy shall be oid like 0.1.4.134";
+ this.dPolicy = new C({
+ "oid": p.policy
+ });
+ }
+
+ p.messageImprint !== undefined && (this.dMessageImprint = new W(p.messageImprint));
+ p.serialNumber !== undefined && (this.dSerialNumber = new S(p.serialNumber));
+ p.genTime !== undefined && (this.dGenTime = new J(p.genTime));
+ p.accuracy !== undefined && (this.dAccuracy = new R(p.accuracy));
+ p.ordering !== undefined && p.ordering == !![] && (this.dOrdering = new Y());
+ p.nonce !== undefined && (this.dNonce = new S(p.nonce));
+ p.tsa !== undefined && (this.dTsa = new B(p.tsa));
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.tsp.TSTInfo, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.tsp.TimeStampResp = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERSequence;
+ var S = A.ASN1Object;
+ var Y = A.tsp;
+ var J = Y.PKIStatusInfo;
+ Y.TimeStampResp.superclass.constructor.call(this);
+ this.dStatus = null;
+ this.dTST = null;
+
+ this.getEncodedHex = function () {
+ if (this.dStatus == null) throw "status shall be specified";
+ var C = [this.dStatus];
+
+ if (this.dTST != null) {
+ C.push(this.dTST);
+ }
+
+ var V = new L({
+ "array": C
+ });
+ return this.hTLV = V.getEncodedHex(), this.hTLV;
+ };
+
+ p !== undefined && (typeof p.status == "object" && (this.dStatus = new J(p.status)), p.tst !== undefined && p.tst instanceof S && (this.dTST = p.tst.getContentInfo()));
+};
+
+YAHOO.lang.extend(KJUR.asn1.tsp.TimeStampResp, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.tsp.PKIStatusInfo = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERSequence;
+ var S = A.tsp;
+ var Y = S.PKIStatus;
+ var J = S.PKIFreeText;
+ var C = S.PKIFailureInfo;
+ S.PKIStatusInfo.superclass.constructor.call(this);
+ this.dStatus = null;
+ this.dStatusString = null;
+ this.dFailureInfo = null;
+
+ this.getEncodedHex = function () {
+ if (this.dStatus == null) throw "status shall be specified";
+ var V = [this.dStatus];
+
+ if (this.dStatusString != null) {
+ V.push(this.dStatusString);
+ }
+
+ if (this.dFailureInfo != null) {
+ V.push(this.dFailureInfo);
+ }
+
+ var W = new L({
+ "array": V
+ });
+ return this.hTLV = W.getEncodedHex(), this.hTLV;
+ };
+
+ p !== undefined && (typeof p.status == "object" && (this.dStatus = new Y(p.status)), typeof p.statstr == "object" && (this.dStatusString = new J({
+ "array": p.statstr
+ })), typeof p.failinfo == "object" && (this.dFailureInfo = new C(p.failinfo)));
+};
+
+YAHOO.lang.extend(KJUR.asn1.tsp.PKIStatusInfo, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.tsp.PKIStatus = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERInteger;
+ var S = A.tsp;
+ var Y = S.PKIStatus;
+ S.PKIStatus.superclass.constructor.call(this);
+ var J = null;
+
+ this.getEncodedHex = function () {
+ return this.hTLV = this.dStatus.getEncodedHex(), this.hTLV;
+ };
+
+ if (p !== undefined) {
+ if (p.name !== undefined) {
+ var C = Y.valueList;
+ if (C[p.name] === undefined) throw "name undefined: " + p.name;
+ this.dStatus = new L({
+ "int": C[p.name]
+ });
+ } else this.dStatus = new L(p);
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.tsp.PKIStatus, KJUR.asn1.ASN1Object);
+KJUR.asn1.tsp.PKIStatus.valueList = {
+ "granted": 0,
+ "grantedWithMods": 1,
+ "rejection": 2,
+ "waiting": 3,
+ "revocationWarning": 4,
+ "revocationNotification": 5
+};
+
+KJUR.asn1.tsp.PKIFreeText = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERSequence;
+ var g = A.DERUTF8String;
+ var S = A.tsp;
+ S.PKIFreeText.superclass.constructor.call(this);
+ this.textList = [];
+
+ this.getEncodedHex = function () {
+ var Y = [];
+
+ for (var J = 0; J < this.textList.length; J++) {
+ Y.push(new g({
+ "str": this.textList[J]
+ }));
+ }
+
+ var C = new L({
+ "array": Y
+ });
+ return this.hTLV = C.getEncodedHex(), this.hTLV;
+ };
+
+ p !== undefined && typeof p.array == "object" && (this.textList = p.array);
+};
+
+YAHOO.lang.extend(KJUR.asn1.tsp.PKIFreeText, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.tsp.PKIFailureInfo = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERBitString;
+ var S = A.tsp;
+ var Y = S.PKIFailureInfo;
+ Y.superclass.constructor.call(this);
+ this.value = null;
+
+ this.getEncodedHex = function () {
+ if (this.value == null) throw "value shall be specified";
+ var C = new Number(this.value).toString(2);
+ var V = new L();
+ return V.setByBinaryString(C), this.hTLV = V.getEncodedHex(), this.hTLV;
+ };
+
+ if (p !== undefined) {
+ if (typeof p.name == "string") {
+ var J = Y.valueList;
+ if (J[p.name] === undefined) throw "name undefined: " + p.name;
+ this.value = J[p.name];
+ } else if (typeof p.int == "number") {
+ this.value = p.int;
+ }
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.tsp.PKIFailureInfo, KJUR.asn1.ASN1Object);
+KJUR.asn1.tsp.PKIFailureInfo.valueList = {
+ "badAlg": 0,
+ "badRequest": 2,
+ "badDataFormat": 5,
+ "timeNotAvailable": 14,
+ "unacceptedPolicy": 15,
+ "unacceptedExtension": 16,
+ "addInfoNotAvailable": 17,
+ "systemFailure": 25
+};
+
+KJUR.asn1.tsp.AbstractTSAAdapter = function (p) {
+ this.getTSTHex = function (n, A) {
+ throw "not implemented yet";
+ };
+};
+
+KJUR.asn1.tsp.SimpleTSAAdapter = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.tsp;
+ var g = n.crypto.Util.hashHex;
+ L.SimpleTSAAdapter.superclass.constructor.call(this);
+ this.params = null;
+ this.serial = 0;
+
+ this.getTSTHex = function (S, Y) {
+ var J = g(S, Y);
+ this.params.tstInfo.messageImprint = {
+ "hashAlg": Y,
+ "hashValue": J
+ };
+ this.params.tstInfo.serialNumber = {
+ "int": this.serial++
+ };
+ var C = Math.floor(Math.random() * 1000000000);
+ this.params.tstInfo.nonce = {
+ "int": C
+ };
+ var V = L.TSPUtil.newTimeStampToken(this.params);
+ return V.getContentInfoEncodedHex();
+ };
+
+ p !== undefined && (this.params = p);
+};
+
+YAHOO.lang.extend(KJUR.asn1.tsp.SimpleTSAAdapter, KJUR.asn1.tsp.AbstractTSAAdapter);
+
+KJUR.asn1.tsp.FixedTSAAdapter = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.tsp;
+ var g = n.crypto.Util.hashHex;
+ L.FixedTSAAdapter.superclass.constructor.call(this);
+ this.params = null;
+
+ this.getTSTHex = function (S, Y) {
+ var J = g(S, Y);
+ this.params.tstInfo.messageImprint = {
+ "hashAlg": Y,
+ "hashValue": J
+ };
+ var C = L.TSPUtil.newTimeStampToken(this.params);
+ return C.getContentInfoEncodedHex();
+ };
+
+ p !== undefined && (this.params = p);
+};
+
+YAHOO.lang.extend(KJUR.asn1.tsp.FixedTSAAdapter, KJUR.asn1.tsp.AbstractTSAAdapter);
+KJUR.asn1.tsp.TSPUtil = new function () {}();
+
+KJUR.asn1.tsp.TSPUtil.newTimeStampToken = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.cms;
+ var S = A.tsp;
+ var Y = A.tsp.TSTInfo;
+ var J = new L.SignedData();
+ var C = new Y(p.tstInfo);
+ var V = C.getEncodedHex();
+ J.dEncapContentInfo.setContentValue({
+ "hex": V
+ });
+ J.dEncapContentInfo.setContentType("tstinfo");
+ if (typeof p.certs == "object") for (var W = 0; W < p.certs.length; W++) {
+ J.addCertificatesByPEM(p.certs[W]);
+ }
+ var R = J.signerInfoList[0];
+ R.setSignerIdentifier(p.signerCert);
+ R.setForContentAndHash({
+ "sdObj": J,
+ "eciObj": J.dEncapContentInfo,
+ "hashAlg": p.hashAlg
+ });
+ var B = new L.SigningCertificate({
+ "array": [p.signerCert]
+ });
+ return R.dSignedAttrs.add(B), R.sign(p.signerPrvKey, p.sigAlg), J;
+};
+
+KJUR.asn1.tsp.TSPUtil.parseTimeStampReq = function (p) {
+ var n = ASN1HEX;
+ var A = n.getChildIdx;
+ var L = n.getV;
+ var S = n.getTLV;
+ var Y = {};
+ Y.certreq = ![];
+ var J = A(p, 0);
+ if (J.length < 2) throw "TimeStampReq must have at least 2 items";
+ var C = S(p, J[1]);
+ Y.mi = KJUR.asn1.tsp.TSPUtil.parseMessageImprint(C);
+
+ for (var V = 2; V < J.length; V++) {
+ var W = J[V];
+ var R = p.substr(W, 2);
+
+ if (R == "06") {
+ var B = L(p, W);
+ Y.policy = n.hextooidstr(B);
+ }
+
+ R == "02" && (Y.nonce = L(p, W));
+ R == "01" && (Y.certreq = !![]);
+ }
+
+ return Y;
+};
+
+KJUR.asn1.tsp.TSPUtil.parseMessageImprint = function (p) {
+ var n = ASN1HEX;
+ var A = n.getChildIdx;
+ var L = n.getV;
+ var S = n.getIdxbyList;
+ var Y = {};
+ if (p.substr(0, 2) != "30") throw "head of messageImprint hex shall be '30'";
+ var J = A(p, 0);
+ var C = S(p, 0, [0, 0]);
+ var V = L(p, C);
+ var W = n.hextooidstr(V);
+ var R = KJUR.asn1.x509.OID.oid2name(W);
+ if (R == "") throw "hashAlg name undefined: " + W;
+ var B = R;
+ var F = S(p, 0, [1]);
+ return Y.hashAlg = B, Y.hashValue = L(p, F), Y;
+};
+
+if (typeof KJUR == "undefined" || !KJUR) {
+ KJUR = {};
+}
+
+if (typeof KJUR.asn1 == "undefined" || !KJUR.asn1) {
+ KJUR.asn1 = {};
+}
+
+if (typeof KJUR.asn1.cades == "undefined" || !KJUR.asn1.cades) {
+ KJUR.asn1.cades = {};
+}
+
+KJUR.asn1.cades.SignaturePolicyIdentifier = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERObjectIdentifier;
+ var S = A.DERSequence;
+ var Y = A.cades;
+ var J = Y.OtherHashAlgAndValue;
+ Y.SignaturePolicyIdentifier.superclass.constructor.call(this);
+ this.attrTypeOid = "1.2.840.113549.1.9.16.2.15";
+
+ if (p !== undefined) {
+ if (typeof p.oid == "string" && typeof p.hash == "object") {
+ var C = new L({
+ "oid": p.oid
+ });
+ var V = new J(p.hash);
+ var W = new S({
+ "array": [C, V]
+ });
+ this.valueList = [W];
+ }
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.cades.SignaturePolicyIdentifier, KJUR.asn1.cms.Attribute);
+
+KJUR.asn1.cades.OtherHashAlgAndValue = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERSequence;
+ var S = A.DEROctetString;
+ var Y = A.x509;
+ var J = Y.AlgorithmIdentifier;
+ var C = A.cades;
+ var V = C.OtherHashAlgAndValue;
+ V.superclass.constructor.call(this);
+ this.dAlg = null;
+ this.dHash = null;
+
+ this.getEncodedHex = function () {
+ var W = new L({
+ "array": [this.dAlg, this.dHash]
+ });
+ return this.hTLV = W.getEncodedHex(), this.hTLV;
+ };
+
+ p !== undefined && typeof p.alg == "string" && typeof p.hash == "string" && (this.dAlg = new J({
+ "name": p.alg
+ }), this.dHash = new S({
+ "hex": p.hash
+ }));
+};
+
+YAHOO.lang.extend(KJUR.asn1.cades.OtherHashAlgAndValue, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.cades.SignatureTimeStamp = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.ASN1Object;
+ var S = A.x509;
+ var Y = A.cades;
+ Y.SignatureTimeStamp.superclass.constructor.call(this);
+ this.attrTypeOid = "1.2.840.113549.1.9.16.2.14";
+ this.tstHex = null;
+
+ if (p !== undefined) {
+ if (p.res !== undefined) {
+ if (typeof p.res == "string" && p.res.match(/^[0-9A-Fa-f]+$/)) {} else {
+ if (p.res instanceof L) {} else throw "res param shall be ASN1Object or hex string";
+ }
+ }
+
+ if (p.tst !== undefined) {
+ if (typeof p.tst == "string" && p.tst.match(/^[0-9A-Fa-f]+$/)) {
+ var J = new L();
+ this.tstHex = p.tst;
+ J.hTLV = this.tstHex;
+ J.getEncodedHex();
+ this.valueList = [J];
+ } else {
+ if (p.tst instanceof L) {} else throw "tst param shall be ASN1Object or hex string";
+ }
+ }
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.cades.SignatureTimeStamp, KJUR.asn1.cms.Attribute);
+
+KJUR.asn1.cades.CompleteCertificateRefs = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.cades;
+ L.CompleteCertificateRefs.superclass.constructor.call(this);
+ this.attrTypeOid = "1.2.840.113549.1.9.16.2.21";
+
+ this.setByArray = function (S) {
+ this.valueList = [];
+
+ for (var Y = 0; Y < S.length; Y++) {
+ var J = new L.OtherCertID(S[Y]);
+ this.valueList.push(J);
+ }
+ };
+
+ p !== undefined && typeof p == "object" && typeof p.length == "number" && this.setByArray(p);
+};
+
+YAHOO.lang.extend(KJUR.asn1.cades.CompleteCertificateRefs, KJUR.asn1.cms.Attribute);
+
+KJUR.asn1.cades.OtherCertID = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.cms;
+ var g = A.cades;
+ g.OtherCertID.superclass.constructor.call(this);
+ this.hasIssuerSerial = !![];
+ this.dOtherCertHash = null;
+ this.dIssuerSerial = null;
+
+ this.setByCertPEM = function (S) {
+ this.dOtherCertHash = new g.OtherHash(S);
+ this.hasIssuerSerial && (this.dIssuerSerial = new L.IssuerAndSerialNumber(S));
+ };
+
+ this.getEncodedHex = function () {
+ if (this.hTLV != null) return this.hTLV;
+ if (this.dOtherCertHash == null) throw "otherCertHash not set";
+ var S = [this.dOtherCertHash];
+
+ if (this.dIssuerSerial != null) {
+ S.push(this.dIssuerSerial);
+ }
+
+ var Y = new A.DERSequence({
+ "array": S
+ });
+ return this.hTLV = Y.getEncodedHex(), this.hTLV;
+ };
+
+ p !== undefined && (typeof p == "string" && p.indexOf("-----BEGIN ") != -1 && this.setByCertPEM(p), typeof p == "object" && (p.hasis === ![] && (this.hasIssuerSerial = ![]), typeof p.cert == "string" && this.setByCertPEM(p.cert)));
+};
+
+YAHOO.lang.extend(KJUR.asn1.cades.OtherCertID, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.cades.OtherHash = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.cms;
+ var S = A.cades;
+ var Y = S.OtherHashAlgAndValue;
+ var J = n.crypto.Util.hashHex;
+ S.OtherHash.superclass.constructor.call(this);
+ this.alg = "sha256";
+ this.dOtherHash = null;
+
+ this.setByCertPEM = function (C) {
+ if (C.indexOf("-----BEGIN ") == -1) throw "certPEM not to seem PEM format";
+ var V = pemtohex(C);
+ var W = J(V, this.alg);
+ this.dOtherHash = new Y({
+ "alg": this.alg,
+ "hash": W
+ });
+ };
+
+ this.getEncodedHex = function () {
+ if (this.dOtherHash == null) throw "OtherHash not set";
+ return this.dOtherHash.getEncodedHex();
+ };
+
+ if (p !== undefined) {
+ if (typeof p == "string") {
+ if (p.indexOf("-----BEGIN ") != -1) this.setByCertPEM(p);else {
+ if (p.match(/^[0-9A-Fa-f]+$/)) this.dOtherHash = new A.DEROctetString({
+ "hex": p
+ });else throw "unsupported string value for params";
+ }
+ } else if (typeof p == "object") {
+ typeof p.cert == "string" ? (typeof p.alg == "string" && (this.alg = p.alg), this.setByCertPEM(p.cert)) : this.dOtherHash = new Y(p);
+ }
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.cades.OtherHash, KJUR.asn1.ASN1Object);
+KJUR.asn1.cades.CAdESUtil = new function () {}();
+
+KJUR.asn1.cades.CAdESUtil.addSigTS = function (p, n, A) {};
+
+KJUR.asn1.cades.CAdESUtil.parseSignedDataForAddingUnsigned = function (L) {
+ var S = ASN1HEX;
+ var Y = S.getChildIdx;
+ var J = S.getTLV;
+ var C = S.getTLVbyList;
+ var V = S.getIdxbyList;
+ var W = KJUR;
+ var R = W.asn1;
+ var F = R.ASN1Object;
+ var E = R.cms;
+ var I = E.SignedData;
+ var K = R.cades;
+ var T = K.CAdESUtil;
+ var i = {};
+ if (C(L, 0, [0]) != "06092a864886f70d010702") throw "hex is not CMS SignedData";
+ var Z = V(L, 0, [1, 0]);
+ var M = Y(L, Z);
+ if (M.length < 4) throw "num of SignedData elem shall be 4 at least";
+ var U = M.shift();
+ i.version = J(L, U);
+ var H = M.shift();
+ i.algs = J(L, H);
+ var O = M.shift();
+ i.encapcontent = J(L, O);
+ i.certs = null;
+ i.revs = null;
+ i.si = [];
+ var X = M.shift();
+
+ if (L.substr(X, 2) == "a0") {
+ i.certs = J(L, X);
+ X = M.shift();
+ }
+
+ if (L.substr(X, 2) == "a1") {
+ i.revs = J(L, X);
+ X = M.shift();
+ }
+
+ var G = X;
+ if (L.substr(G, 2) != "31") throw "Can't find signerInfos";
+ var N = Y(L, G);
+
+ for (var D = 0; D < N.length; D++) {
+ var r = N[D];
+ var Q = T.parseSignerInfoForAddingUnsigned(L, r, D);
+ i.si[D] = Q;
+ }
+
+ var P = null;
+ i.obj = new I();
+ P = new F();
+ P.hTLV = i.version;
+ i.obj.dCMSVersion = P;
+ P = new F();
+ P.hTLV = i.algs;
+ i.obj.dDigestAlgs = P;
+ P = new F();
+ P.hTLV = i.encapcontent;
+ i.obj.dEncapContentInfo = P;
+ P = new F();
+ P.hTLV = i.certs;
+ i.obj.dCerts = P;
+ i.obj.signerInfoList = [];
+
+ for (var D = 0; D < i.si.length; D++) {
+ i.obj.signerInfoList.push(i.si[D].obj);
+ }
+
+ return i;
+};
+
+KJUR.asn1.cades.CAdESUtil.parseSignerInfoForAddingUnsigned = function (A, L, S) {
+ var Y = ASN1HEX;
+ var J = Y.getChildIdx;
+ var C = Y.getTLV;
+ var V = Y.getV;
+ var W = KJUR;
+ var R = W.asn1;
+ var B = R.ASN1Object;
+ var F = R.cms;
+ var E = F.AttributeList;
+ var I = F.SignerInfo;
+ var K = {};
+ var T = J(A, L);
+ if (T.length != 6) throw "not supported items for SignerInfo (!=6)";
+ var Z = T.shift();
+ K.version = C(A, Z);
+ var M = T.shift();
+ K.si = C(A, M);
+ var U = T.shift();
+ K.digalg = C(A, U);
+ var H = T.shift();
+ K.sattrs = C(A, H);
+ var O = T.shift();
+ K.sigalg = C(A, O);
+ var X = T.shift();
+ K.sig = C(A, X);
+ K.sigval = V(A, X);
+ var G = null;
+ return K.obj = new I(), G = new B(), G.hTLV = K.version, K.obj.dCMSVersion = G, G = new B(), G.hTLV = K.si, K.obj.dSignerIdentifier = G, G = new B(), G.hTLV = K.digalg, K.obj.dDigestAlgorithm = G, G = new B(), G.hTLV = K.sattrs, K.obj.dSignedAttrs = G, G = new B(), G.hTLV = K.sigalg, K.obj.dSigAlg = G, G = new B(), G.hTLV = K.sig, K.obj.dSig = G, K.obj.dUnsignedAttrs = new E(), K;
+};
+
+if (typeof KJUR.asn1.csr == "undefined" || !KJUR.asn1.csr) {
+ KJUR.asn1.csr = {};
+}
+
+KJUR.asn1.csr.CertificationRequest = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERBitString;
+ var S = A.DERSequence;
+ var Y = A.csr;
+ var J = A.x509;
+ Y.CertificationRequest.superclass.constructor.call(this);
+ var C = null;
+ var V = null;
+ var W = null;
+ var R = null;
+ var B = null;
+
+ this.sign = function (F, E) {
+ if (this.prvKey == null) {
+ this.prvKey = E;
+ }
+
+ this.asn1SignatureAlg = new J.AlgorithmIdentifier({
+ "name": F
+ });
+ var s = new n.crypto.Signature({
+ "alg": F
+ });
+ s.init(this.prvKey);
+ s.updateHex(this.asn1CSRInfo.getEncodedHex());
+ this.hexSig = s.sign();
+ this.asn1Sig = new L({
+ "hex": "00" + this.hexSig
+ });
+ var I = new S({
+ "array": [this.asn1CSRInfo, this.asn1SignatureAlg, this.asn1Sig]
+ });
+ this.hTLV = I.getEncodedHex();
+ this.isModified = ![];
+ };
+
+ this.getPEMString = function () {
+ return hextopem(this.getEncodedHex(), "CERTIFICATE REQUEST");
+ };
+
+ this.getEncodedHex = function () {
+ if (this.isModified == ![] && this.hTLV != null) return this.hTLV;
+ throw "not signed yet";
+ };
+
+ p !== undefined && p.csrinfo !== undefined && (this.asn1CSRInfo = p.csrinfo);
+};
+
+YAHOO.lang.extend(KJUR.asn1.csr.CertificationRequest, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.csr.CertificationRequestInfo = function (p) {
+ var A = KJUR;
+ var L = A.asn1;
+ var S = L.DERInteger;
+ var Y = L.DERSequence;
+ var J = L.DERSet;
+ var C = L.DERNull;
+ var V = L.DERTaggedObject;
+ var W = L.DERObjectIdentifier;
+ var R = L.csr;
+ var B = L.x509;
+ var F = B.X500Name;
+ var E = B.Extension;
+ var s = KEYUTIL;
+ R.CertificationRequestInfo.superclass.constructor.call(this);
+
+ this._initialize = function () {
+ this.asn1Array = new Array();
+ this.asn1Version = new S({
+ "int": 0
+ });
+ this.asn1Subject = null;
+ this.asn1SubjPKey = null;
+ this.extensionsArray = new Array();
+ };
+
+ this.setSubjectByParam = function (I) {
+ this.asn1Subject = new F(I);
+ };
+
+ this.setSubjectPublicKeyByGetKey = function (I) {
+ var K = s.getKey(I);
+ this.asn1SubjPKey = new B.SubjectPublicKeyInfo(K);
+ };
+
+ this.appendExtensionByName = function (I, K) {
+ E.appendByNameToArray(I, K, this.extensionsArray);
+ };
+
+ this.getEncodedHex = function () {
+ this.asn1Array = new Array();
+ this.asn1Array.push(this.asn1Version);
+ this.asn1Array.push(this.asn1Subject);
+ this.asn1Array.push(this.asn1SubjPKey);
+
+ if (this.extensionsArray.length > 0) {
+ var I = new Y({
+ "array": this.extensionsArray
+ });
+ var K = new J({
+ "array": [I]
+ });
+ var T = new Y({
+ "array": [new W({
+ "oid": "1.2.840.113549.1.9.14"
+ }), K]
+ });
+ var Z = new V({
+ "explicit": !![],
+ "tag": "a0",
+ "obj": T
+ });
+ this.asn1Array.push(Z);
+ } else {
+ var Z = new V({
+ "explicit": ![],
+ "tag": "a0",
+ "obj": new C()
+ });
+ this.asn1Array.push(Z);
+ }
+
+ var w = new Y({
+ "array": this.asn1Array
+ });
+ return this.hTLV = w.getEncodedHex(), this.isModified = ![], this.hTLV;
+ };
+
+ this._initialize();
+};
+
+YAHOO.lang.extend(KJUR.asn1.csr.CertificationRequestInfo, KJUR.asn1.ASN1Object);
+KJUR.asn1.csr.CSRUtil = new function () {}();
+
+KJUR.asn1.csr.CSRUtil.newCSRPEM = function (p) {
+ var n = KEYUTIL;
+ var A = KJUR.asn1.csr;
+ if (p.subject === undefined) throw "parameter subject undefined";
+ if (p.sbjpubkey === undefined) throw "parameter sbjpubkey undefined";
+ if (p.sigalg === undefined) throw "parameter sigalg undefined";
+ if (p.sbjprvkey === undefined) throw "parameter sbjpubkey undefined";
+ var L = new A.CertificationRequestInfo();
+ L.setSubjectByParam(p.subject);
+ L.setSubjectPublicKeyByGetKey(p.sbjpubkey);
+ if (p.ext !== undefined && p.ext.length !== undefined) for (var S = 0; S < p.ext.length; S++) {
+ for (key in p.ext[S]) {
+ L.appendExtensionByName(key, p.ext[S][key]);
+ }
+ }
+ var Y = new A.CertificationRequest({
+ "csrinfo": L
+ });
+ var J = n.getKey(p.sbjprvkey);
+ Y.sign(p.sigalg, J);
+ var C = Y.getPEMString();
+ return C;
+};
+
+KJUR.asn1.csr.CSRUtil.getInfo = function (p) {
+ var n = ASN1HEX;
+ var A = n.getTLVbyList;
+ var L = {};
+ L.subject = {};
+ L.pubkey = {};
+ if (p.indexOf("-----BEGIN CERTIFICATE REQUEST") == -1) throw "argument is not PEM file";
+ var S = pemtohex(p, "CERTIFICATE REQUEST");
+
+ try {
+ L.subject.hex = A(S, 0, [0, 1]);
+ } catch (J) {
+ console.log(J);
+ }
+
+ try {
+ L.subject.name = X509.hex2dn(L.subject.hex);
+ } catch (C) {
+ console.log(C);
+ }
+
+ L.pubkey.hex = A(S, 0, [0, 2]);
+ L.pubkey.obj = KEYUTIL.getKey(L.pubkey.hex, null, "pkcs8pub");
+
+ try {
+ L.ext = [];
+ var Y = new X509();
+ Y.parseExt(p);
+ L.ext.push({
+ "subjectAltName": {
+ "array": Y.getExtSubjectAltName2()
+ }
+ });
+ } catch (V) {
+ console.log(V);
+ }
+
+ return L;
+};
+
+if (typeof KJUR == "undefined" || !KJUR) {
+ KJUR = {};
+}
+
+if (typeof KJUR.asn1 == "undefined" || !KJUR.asn1) {
+ KJUR.asn1 = {};
+}
+
+if (typeof KJUR.asn1.ocsp == "undefined" || !KJUR.asn1.ocsp) {
+ KJUR.asn1.ocsp = {};
+}
+
+KJUR.asn1.ocsp.DEFAULT_HASH = "sha1";
+
+KJUR.asn1.ocsp.CertID = function (p) {
+ var A = KJUR;
+ var L = A.asn1;
+ var S = L.DEROctetString;
+ var Y = L.DERInteger;
+ var J = L.DERSequence;
+ var C = L.x509;
+ var V = C.AlgorithmIdentifier;
+ var W = L.ocsp;
+ var R = W.DEFAULT_HASH;
+ var B = A.crypto;
+ var F = B.Util.hashHex;
+ var E = X509;
+ var s = ASN1HEX;
+ W.CertID.superclass.constructor.call(this);
+ this.dHashAlg = null;
+ this.dIssuerNameHash = null;
+ this.dIssuerKeyHash = null;
+ this.dSerialNumber = null;
+
+ this.setByValue = function (T, Z, w, M) {
+ M === undefined && (M = R);
+ this.dHashAlg = new V({
+ "name": M
+ });
+ this.dIssuerNameHash = new S({
+ "hex": T
+ });
+ this.dIssuerKeyHash = new S({
+ "hex": Z
+ });
+ this.dSerialNumber = new Y({
+ "hex": w
+ });
+ };
+
+ this.setByCert = function (T, Z, M) {
+ if (M === undefined) {
+ M = R;
+ }
+
+ var U = new E();
+ U.readCertPEM(Z);
+ var H = new E();
+ H.readCertPEM(T);
+ var O = H.getPublicKeyHex();
+ var X = s.getTLVbyList(O, 0, [1, 0], "30");
+ var G = U.getSerialNumberHex();
+ var N = F(H.getSubjectHex(), M);
+ var D = F(X, M);
+ this.setByValue(N, D, G, M);
+ this.hoge = U.getSerialNumberHex();
+ };
+
+ this.getEncodedHex = function () {
+ if (this.dHashAlg === null && this.dIssuerNameHash === null && this.dIssuerKeyHash === null && this.dSerialNumber === null) throw "not yet set values";
+ var T = [this.dHashAlg, this.dIssuerNameHash, this.dIssuerKeyHash, this.dSerialNumber];
+ var Z = new J({
+ "array": T
+ });
+ return this.hTLV = Z.getEncodedHex(), this.hTLV;
+ };
+
+ if (p !== undefined) {
+ var I = p;
+
+ if (I.issuerCert !== undefined && I.subjectCert !== undefined) {
+ var K = R;
+ I.alg === undefined && (K = undefined);
+ this.setByCert(I.issuerCert, I.subjectCert, K);
+ } else {
+ if (I.namehash !== undefined && I.keyhash !== undefined && I.serial !== undefined) {
+ var K = R;
+ I.alg === undefined && (K = undefined);
+ this.setByValue(I.namehash, I.keyhash, I.serial, K);
+ } else throw "invalid constructor arguments";
+ }
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.ocsp.CertID, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.ocsp.Request = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERSequence;
+ var g = A.ocsp;
+ g.Request.superclass.constructor.call(this);
+ this.dReqCert = null;
+ this.dExt = null;
+
+ this.getEncodedHex = function () {
+ var Y = [];
+ if (this.dReqCert === null) throw "reqCert not set";
+ Y.push(this.dReqCert);
+ var J = new L({
+ "array": Y
+ });
+ return this.hTLV = J.getEncodedHex(), this.hTLV;
+ };
+
+ if (typeof p !== "undefined") {
+ var S = new g.CertID(p);
+ this.dReqCert = S;
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.ocsp.Request, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.ocsp.TBSRequest = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERSequence;
+ var g = A.ocsp;
+ g.TBSRequest.superclass.constructor.call(this);
+ this.version = 0;
+ this.dRequestorName = null;
+ this.dRequestList = [];
+ this.dRequestExt = null;
+
+ this.setRequestListByParam = function (S) {
+ var Y = [];
+
+ for (var J = 0; J < S.length; J++) {
+ var C = new g.Request(S[0]);
+ Y.push(C);
+ }
+
+ this.dRequestList = Y;
+ };
+
+ this.getEncodedHex = function () {
+ var S = [];
+ if (this.version !== 0) throw "not supported version: " + this.version;
+ if (this.dRequestorName !== null) throw "requestorName not supported";
+ var Y = new L({
+ "array": this.dRequestList
+ });
+ S.push(Y);
+ if (this.dRequestExt !== null) throw "requestExtensions not supported";
+ var J = new L({
+ "array": S
+ });
+ return this.hTLV = J.getEncodedHex(), this.hTLV;
+ };
+
+ p !== undefined && p.reqList !== undefined && this.setRequestListByParam(p.reqList);
+};
+
+YAHOO.lang.extend(KJUR.asn1.ocsp.TBSRequest, KJUR.asn1.ASN1Object);
+
+KJUR.asn1.ocsp.OCSPRequest = function (p) {
+ var n = KJUR;
+ var A = n.asn1;
+ var L = A.DERSequence;
+ var g = A.ocsp;
+ g.OCSPRequest.superclass.constructor.call(this);
+ this.dTbsRequest = null;
+ this.dOptionalSignature = null;
+
+ this.getEncodedHex = function () {
+ var Y = [];
+ if (this.dTbsRequest !== null) Y.push(this.dTbsRequest);else throw "tbsRequest not set";
+ if (this.dOptionalSignature !== null) throw "optionalSignature not supported";
+ var J = new L({
+ "array": Y
+ });
+ return this.hTLV = J.getEncodedHex(), this.hTLV;
+ };
+
+ if (p !== undefined) {
+ if (p.reqList !== undefined) {
+ var S = new g.TBSRequest(p);
+ this.dTbsRequest = S;
+ }
+ }
+};
+
+YAHOO.lang.extend(KJUR.asn1.ocsp.OCSPRequest, KJUR.asn1.ASN1Object);
+KJUR.asn1.ocsp.OCSPUtil = {};
+
+KJUR.asn1.ocsp.OCSPUtil.getRequestHex = function (p, n, A) {
+ var L = KJUR;
+ var S = L.asn1;
+ var Y = S.ocsp;
+
+ if (A === undefined) {
+ A = Y.DEFAULT_HASH;
+ }
+
+ var J = {
+ "alg": A,
+ "issuerCert": p,
+ "subjectCert": n
+ };
+ var C = new Y.OCSPRequest({
+ "reqList": [J]
+ });
+ return C.getEncodedHex();
+};
+
+KJUR.asn1.ocsp.OCSPUtil.getOCSPResponseInfo = function (p) {
+ var n = ASN1HEX;
+ var A = n.getVbyList;
+ var L = n.getIdxbyList;
+ var A = n.getVbyList;
+ var S = n.getV;
+ var Y = {};
+
+ try {
+ var J = A(p, 0, [0], "0a");
+ Y.responseStatus = parseInt(J, 16);
+ } catch (R) {
+ console.log(R);
+ }
+
+ if (Y.responseStatus !== 0) return Y;
+
+ try {
+ var C = L(p, 0, [1, 0, 1, 0, 0, 2, 0, 1]);
+
+ if (p.substr(C, 2) === "80") {
+ Y.certStatus = "good";
+ } else {
+ if (p.substr(C, 2) === "a1") {
+ Y.certStatus = "revoked";
+ Y.revocationTime = hextoutf8(A(p, C, [0]));
+ } else {
+ if (p.substr(C, 2) === "82") {
+ Y.certStatus = "unknown";
+ }
+ }
+ }
+ } catch (B) {
+ console.log(B);
+ }
+
+ try {
+ var V = L(p, 0, [1, 0, 1, 0, 0, 2, 0, 2]);
+ Y.thisUpdate = hextoutf8(S(p, V));
+ } catch (F) {
+ console.log(F);
+ }
+
+ try {
+ var W = L(p, 0, [1, 0, 1, 0, 0, 2, 0, 3]);
+
+ if (p.substr(W, 2) === "a0") {
+ Y.nextUpdate = hextoutf8(A(p, W, [0]));
+ }
+ } catch (E) {
+ console.log(E);
+ }
+
+ return Y;
+};
+
+var KJUR;
+
+if (typeof KJUR == "undefined" || !KJUR) {
+ KJUR = {};
+}
+
+if (typeof KJUR.lang == "undefined" || !KJUR.lang) {
+ KJUR.lang = {};
+}
+
+KJUR.lang.String = function () {};
+
+function Base64x() {}
+
+function stoBA(p) {
+ var n = new Array();
+
+ for (var a = 0; a < p.length; a++) {
+ n[a] = p.charCodeAt(a);
+ }
+
+ return n;
+}
+
+function BAtos(p) {
+ var n = "";
+
+ for (var a = 0; a < p.length; a++) {
+ n = n + String.fromCharCode(p[a]);
+ }
+
+ return n;
+}
+
+function BAtohex(p) {
+ var n = "";
+
+ for (var a = 0; a < p.length; a++) {
+ var A = p[a].toString(16);
+ A.length == 1 && (A = "0" + A);
+ n = n + A;
+ }
+
+ return n;
+}
+
+function stohex(p) {
+ return BAtohex(stoBA(p));
+}
+
+function stob64(p) {
+ return hex2b64(stohex(p));
+}
+
+function stob64u(p) {
+ return b64tob64u(hex2b64(stohex(p)));
+}
+
+function b64utos(p) {
+ return BAtos(b64toBA(b64utob64(p)));
+}
+
+function b64tob64u(p) {
+ return p = p.replace(/\=/g, ""), p = p.replace(/\+/g, "-"), p = p.replace(/\//g, "_"), p;
+}
+
+function b64utob64(p) {
+ return p.length % 4 == 2 ? p = p + "==" : p.length % 4 == 3 && (p = p + "="), p = p.replace(/-/g, "+"), p = p.replace(/_/g, "/"), p;
+}
+
+function hextob64u(p) {
+ return p.length % 2 == 1 && (p = "0" + p), b64tob64u(hex2b64(p));
+}
+
+function b64utohex(p) {
+ return b64tohex(b64utob64(p));
+}
+
+var utf8tob64u;
+var b64utoutf8;
+
+if (typeof Buffer === "function") {
+ utf8tob64u = function (p) {
+ return b64tob64u(new Buffer(p, "utf8").toString("base64"));
+ };
+
+ b64utoutf8 = function (p) {
+ return new Buffer(b64utob64(p), "base64").toString("utf8");
+ };
+} else {
+ utf8tob64u = function (p) {
+ return hextob64u(uricmptohex(encodeURIComponentAll(p)));
+ };
+
+ b64utoutf8 = function (p) {
+ return decodeURIComponent(hextouricmp(b64utohex(p)));
+ };
+}
+
+function utf8tob64(p) {
+ return hex2b64(uricmptohex(encodeURIComponentAll(p)));
+}
+
+function b64toutf8(p) {
+ return decodeURIComponent(hextouricmp(b64tohex(p)));
+}
+
+function utf8tohex(p) {
+ return uricmptohex(encodeURIComponentAll(p));
+}
+
+function hextoutf8(p) {
+ return decodeURIComponent(hextouricmp(p));
+}
+
+function hextorstr(p) {
+ var n = "";
+
+ for (var A = 0; A < p.length - 1; A += 2) {
+ n += String.fromCharCode(parseInt(p.substr(A, 2), 16));
+ }
+
+ return n;
+}
+
+function rstrtohex(p) {
+ var n = "";
+
+ for (var A = 0; A < p.length; A++) {
+ n += ("0" + p.charCodeAt(A).toString(16)).slice(-2);
+ }
+
+ return n;
+}
+
+function hextob64(p) {
+ return hex2b64(p);
+}
+
+function hextob64nl(p) {
+ var n = hextob64(p);
+ var A = n.replace(/(.{64})/g, "$1\r\n");
+ return A = A.replace(/\r\n$/, ""), A;
+}
+
+function b64nltohex(p) {
+ var n = p.replace(/[^0-9A-Za-z\/+=]*/g, "");
+ var A = b64tohex(n);
+ return A;
+}
+
+function hextopem(p, n) {
+ var A = hextob64nl(p);
+ return "-----BEGIN " + n + "-----\r\n" + A + "\r\n-----END " + n + "-----\r\n";
+}
+
+function pemtohex(p, n) {
+ if (p.indexOf("-----BEGIN ") == -1) throw "can't find PEM header: " + n;
+ return n !== undefined ? (p = p.replace(new RegExp("^[^]*-----BEGIN " + n + "-----"), ""), p = p.replace(new RegExp("-----END " + n + "-----[^]*$"), "")) : (p = p.replace(/^[^]*-----BEGIN [^-]+-----/, ""), p = p.replace(/-----END [^-]+-----[^]*$/, "")), b64nltohex(p);
+}
+
+function hextoArrayBuffer(p) {
+ if (p.length % 2 != 0) throw "input is not even length";
+ if (p.match(/^[0-9A-Fa-f]+$/) == null) throw "input is not hexadecimal";
+ var n = new ArrayBuffer(p.length / 2);
+ var A = new DataView(n);
+
+ for (var L = 0; L < p.length / 2; L++) {
+ A.setUint8(L, parseInt(p.substr(L * 2, 2), 16));
+ }
+
+ return n;
+}
+
+function ArrayBuffertohex(p) {
+ var n = "";
+ var A = new DataView(p);
+
+ for (var L = 0; L < p.byteLength; L++) {
+ n += ("00" + A.getUint8(L).toString(16)).slice(-2);
+ }
+
+ return n;
+}
+
+function zulutomsec(p) {
+ var A;
+ var L;
+ var S;
+ var Y;
+ var J;
+ var C;
+ var V;
+ var W;
+ var R;
+ var B;
+ var F;
+ var E;
+ E = p.match(/^(\d{2}|\d{4})(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)(|\.\d+)Z$/);
+ if (E) return R = E[1], A = parseInt(R), R.length === 2 && (50 <= A && A < 100 ? A = 1900 + A : 0 <= A && A < 50 && (A = 2000 + A)), L = parseInt(E[2]) - 1, S = parseInt(E[3]), Y = parseInt(E[4]), J = parseInt(E[5]), C = parseInt(E[6]), V = 0, B = E[7], B !== "" && (F = (B.substr(1) + "00").substr(0, 3), V = parseInt(F)), Date.UTC(A, L, S, Y, J, C, V);
+ throw "unsupported zulu format: " + p;
+}
+
+function zulutosec(p) {
+ var n = zulutomsec(p);
+ return ~~(n / 1000);
+}
+
+function zulutodate(p) {
+ return new Date(zulutomsec(p));
+}
+
+function datetozulu(p, n, A) {
+ var L;
+ var S = p.getUTCFullYear();
+
+ if (n) {
+ if (S < 1950 || 2049 < S) throw "not proper year for UTCTime: " + S;
+ L = ("" + S).slice(-2);
+ } else L = ("000" + S).slice(-4);
+
+ L += ("0" + (p.getUTCMonth() + 1)).slice(-2);
+ L += ("0" + p.getUTCDate()).slice(-2);
+ L += ("0" + p.getUTCHours()).slice(-2);
+ L += ("0" + p.getUTCMinutes()).slice(-2);
+ L += ("0" + p.getUTCSeconds()).slice(-2);
+
+ if (A) {
+ var Y = p.getUTCMilliseconds();
+
+ if (Y !== 0) {
+ Y = ("00" + Y).slice(-3);
+ Y = Y.replace(/0+$/g, "");
+ L += "." + Y;
+ }
+ }
+
+ return L += "Z", L;
+}
+
+function uricmptohex(p) {
+ return p.replace(/%/g, "");
+}
+
+function hextouricmp(p) {
+ return p.replace(/(..)/g, "%$1");
+}
+
+function ipv6tohex(p) {
+ var n = "malformed IPv6 address";
+ if (!p.match(/^[0-9A-Fa-f:]+$/)) throw n;
+ p = p.toLowerCase();
+ var a = p.split(":").length - 1;
+ if (a < 2) throw n;
+ var A = ":".repeat(7 - a + 2);
+ p = p.replace("::", A);
+ var L = p.split(":");
+ if (L.length != 8) throw n;
+
+ for (var S = 0; S < 8; S++) {
+ L[S] = ("0000" + L[S]).slice(-4);
+ }
+
+ return L.join("");
+}
+
+function hextoipv6(p) {
+ if (!p.match(/^[0-9A-Fa-f]{32}$/)) throw "malformed IPv6 address octet";
+ p = p.toLowerCase();
+ var n = p.match(/.{1,4}/g);
+
+ for (var a = 0; a < 8; a++) {
+ n[a] = n[a].replace(/^0+/, "");
+ n[a] == "" && (n[a] = "0");
+ }
+
+ p = ":" + n.join(":") + ":";
+ var A = p.match(/:(0:){2,}/g);
+ if (A === null) return p.slice(1, -1);
+ var L = "";
+
+ for (var a = 0; a < A.length; a++) {
+ if (A[a].length > L.length) {
+ L = A[a];
+ }
+ }
+
+ return p = p.replace(L, "::"), p.slice(1, -1);
+}
+
+function hextoip(p) {
+ var n = "malformed hex value";
+ if (!p.match(/^([0-9A-Fa-f][0-9A-Fa-f]){1,}$/)) throw n;
+
+ if (p.length == 8) {
+ var A;
+
+ try {
+ return A = parseInt(p.substr(0, 2), 16) + "." + parseInt(p.substr(2, 2), 16) + "." + parseInt(p.substr(4, 2), 16) + "." + parseInt(p.substr(6, 2), 16), A;
+ } catch (L) {
+ console.log(L);
+ throw n;
+ }
+ } else return p.length == 32 ? hextoipv6(p) : p;
+}
+
+function iptohex(p) {
+ var n = "malformed IP address";
+ p = p.toLowerCase(p);
+
+ if (p.match(/^[0-9.]+$/)) {
+ var a = p.split(".");
+ if (a.length !== 4) throw n;
+ var A = "";
+
+ try {
+ for (var L = 0; L < 4; L++) {
+ var S = parseInt(a[L]);
+ A += ("0" + S.toString(16)).slice(-2);
+ }
+
+ return A;
+ } catch (Y) {
+ console.log(Y);
+ throw n;
+ }
+ } else {
+ if (p.match(/^[0-9a-f:]+$/) && p.indexOf(":") !== -1) return ipv6tohex(p);else throw n;
+ }
+}
+
+function encodeURIComponentAll(p) {
+ var n = encodeURIComponent(p);
+ var A = "";
+
+ for (var L = 0; L < n.length; L++) {
+ if (n[L] == "%") {
+ A = A + n.substr(L, 3);
+ L = L + 2;
+ } else {
+ A = A + "%" + stohex(n[L]);
+ }
+ }
+
+ return A;
+}
+
+function newline_toUnix(p) {
+ return p = p.replace(/\r\n/mg, "\n"), p;
+}
+
+function newline_toDos(p) {
+ return p = p.replace(/\r\n/mg, "\n"), p = p.replace(/\n/mg, "\r\n"), p;
+}
+
+KJUR.lang.String.isInteger = function (p) {
+ return p.match(/^[0-9]+$/) ? !![] : p.match(/^-[0-9]+$/) ? !![] : ![];
+};
+
+KJUR.lang.String.isHex = function (p) {
+ return p.length % 2 == 0 && (p.match(/^[0-9a-f]+$/) || p.match(/^[0-9A-F]+$/)) ? !![] : ![];
+};
+
+KJUR.lang.String.isBase64 = function (p) {
+ return p = p.replace(/\s+/g, ""), p.match(/^[0-9A-Za-z+\/]+={0,3}$/) && p.length % 4 == 0 ? !![] : ![];
+};
+
+KJUR.lang.String.isBase64URL = function (p) {
+ if (p.match(/[+/=]/)) return ![];
+ return p = b64utob64(p), KJUR.lang.String.isBase64(p);
+};
+
+KJUR.lang.String.isIntegerArray = function (p) {
+ return p = p.replace(/\s+/g, ""), p.match(/^\[[0-9,]+\]$/) ? !![] : ![];
+};
+
+function hextoposhex(p) {
+ if (p.length % 2 == 1) return "0" + p;
+ if (p.substr(0, 1) > "7") return "00" + p;
+ return p;
+}
+
+function intarystrtohex(p) {
+ p = p.replace(/^\s*\[\s*/, "");
+ p = p.replace(/\s*\]\s*$/, "");
+ p = p.replace(/\s*/g, "");
+
+ try {
+ var n = p.split(/,/).map(function (A, L, S) {
+ var Y = parseInt(A);
+ if (Y < 0 || 255 < Y) throw "integer not in range 0-255";
+ var J = ("00" + Y.toString(16)).slice(-2);
+ return J;
+ }).join("");
+ return n;
+ } catch (A) {
+ console.log(A);
+ throw "malformed integer array string: " + A;
+ }
+}
+
+var strdiffidx = function (p, n) {
+ var A = p.length;
+
+ if (p.length > n.length) {
+ A = n.length;
+ }
+
+ for (var L = 0; L < A; L++) {
+ if (p.charCodeAt(L) != n.charCodeAt(L)) return L;
+ }
+
+ if (p.length != n.length) return A;
+ return -1;
+};
+
+if (typeof KJUR == "undefined" || !KJUR) {
+ KJUR = {};
+}
+
+if (typeof KJUR.crypto == "undefined" || !KJUR.crypto) {
+ KJUR.crypto = {};
+}
+
+KJUR.crypto.Util = new function () {
+ this.DIGESTINFOHEAD = {
+ "sha1": "3021300906052b0e03021a05000414",
+ "sha224": "302d300d06096086480165030402040500041c",
+ "sha256": "3031300d060960864801650304020105000420",
+ "sha384": "3041300d060960864801650304020205000430",
+ "sha512": "3051300d060960864801650304020305000440",
+ "md2": "3020300c06082a864886f70d020205000410",
+ "md5": "3020300c06082a864886f70d020505000410",
+ "ripemd160": "3021300906052b2403020105000414"
+ };
+ this.DEFAULTPROVIDER = {
+ "md5": "cryptojs",
+ "sha1": "cryptojs",
+ "sha224": "cryptojs",
+ "sha256": "cryptojs",
+ "sha384": "cryptojs",
+ "sha512": "cryptojs",
+ "ripemd160": "cryptojs",
+ "hmacmd5": "cryptojs",
+ "hmacsha1": "cryptojs",
+ "hmacsha224": "cryptojs",
+ "hmacsha256": "cryptojs",
+ "hmacsha384": "cryptojs",
+ "hmacsha512": "cryptojs",
+ "hmacripemd160": "cryptojs",
+ "MD5withRSA": "cryptojs/jsrsa",
+ "SHA1withRSA": "cryptojs/jsrsa",
+ "SHA224withRSA": "cryptojs/jsrsa",
+ "SHA256withRSA": "cryptojs/jsrsa",
+ "SHA384withRSA": "cryptojs/jsrsa",
+ "SHA512withRSA": "cryptojs/jsrsa",
+ "RIPEMD160withRSA": "cryptojs/jsrsa",
+ "MD5withECDSA": "cryptojs/jsrsa",
+ "SHA1withECDSA": "cryptojs/jsrsa",
+ "SHA224withECDSA": "cryptojs/jsrsa",
+ "SHA256withECDSA": "cryptojs/jsrsa",
+ "SHA384withECDSA": "cryptojs/jsrsa",
+ "SHA512withECDSA": "cryptojs/jsrsa",
+ "RIPEMD160withECDSA": "cryptojs/jsrsa",
+ "SHA1withDSA": "cryptojs/jsrsa",
+ "SHA224withDSA": "cryptojs/jsrsa",
+ "SHA256withDSA": "cryptojs/jsrsa",
+ "MD5withRSAandMGF1": "cryptojs/jsrsa",
+ "SHA1withRSAandMGF1": "cryptojs/jsrsa",
+ "SHA224withRSAandMGF1": "cryptojs/jsrsa",
+ "SHA256withRSAandMGF1": "cryptojs/jsrsa",
+ "SHA384withRSAandMGF1": "cryptojs/jsrsa",
+ "SHA512withRSAandMGF1": "cryptojs/jsrsa",
+ "RIPEMD160withRSAandMGF1": "cryptojs/jsrsa"
+ };
+ this.CRYPTOJSMESSAGEDIGESTNAME = {
+ "md5": CryptoJS.algo.MD5,
+ "sha1": CryptoJS.algo.SHA1,
+ "sha224": CryptoJS.algo.SHA224,
+ "sha256": CryptoJS.algo.SHA256,
+ "sha384": CryptoJS.algo.SHA384,
+ "sha512": CryptoJS.algo.SHA512,
+ "ripemd160": CryptoJS.algo.RIPEMD160
+ };
+
+ this.getDigestInfoHex = function (p, n) {
+ if (typeof this.DIGESTINFOHEAD[n] == "undefined") throw "alg not supported in Util.DIGESTINFOHEAD: " + n;
+ return this.DIGESTINFOHEAD[n] + p;
+ };
+
+ this.getPaddedDigestInfoHex = function (p, n, A) {
+ var L = this.getDigestInfoHex(p, n);
+ var S = A / 4;
+ if (L.length + 22 > S) throw "key is too short for SigAlg: keylen=" + A + "," + n;
+ var Y = "0001";
+ var J = "00" + L;
+ var C = "";
+ var V = S - Y.length - J.length;
+
+ for (var W = 0; W < V; W += 2) {
+ C += "ff";
+ }
+
+ var R = Y + C + J;
+ return R;
+ };
+
+ this.hashString = function (p, n) {
+ var A = new KJUR.crypto.MessageDigest({
+ "alg": n
+ });
+ return A.digestString(p);
+ };
+
+ this.hashHex = function (p, n) {
+ var A = new KJUR.crypto.MessageDigest({
+ "alg": n
+ });
+ return A.digestHex(p);
+ };
+
+ this.sha1 = function (p) {
+ return this.hashString(p, "sha1");
+ };
+
+ this.sha256 = function (p) {
+ return this.hashString(p, "sha256");
+ };
+
+ this.sha256Hex = function (p) {
+ return this.hashHex(p, "sha256");
+ };
+
+ this.sha512 = function (p) {
+ return this.hashString(p, "sha512");
+ };
+
+ this.sha512Hex = function (p) {
+ return this.hashHex(p, "sha512");
+ };
+
+ this.isKey = function (p) {
+ return p instanceof RSAKey || p instanceof KJUR.crypto.DSA || p instanceof KJUR.crypto.ECDSA ? !![] : ![];
+ };
+}();
+
+KJUR.crypto.Util.md5 = function (p) {
+ var n = new KJUR.crypto.MessageDigest({
+ "alg": "md5",
+ "prov": "cryptojs"
+ });
+ return n.digestString(p);
+};
+
+KJUR.crypto.Util.ripemd160 = function (p) {
+ var n = new KJUR.crypto.MessageDigest({
+ "alg": "ripemd160",
+ "prov": "cryptojs"
+ });
+ return n.digestString(p);
+};
+
+KJUR.crypto.Util.SECURERANDOMGEN = new SecureRandom();
+
+KJUR.crypto.Util.getRandomHexOfNbytes = function (p) {
+ var n = new Array(p);
+ return KJUR.crypto.Util.SECURERANDOMGEN.nextBytes(n), BAtohex(n);
+};
+
+KJUR.crypto.Util.getRandomBigIntegerOfNbytes = function (p) {
+ return new BigInteger(KJUR.crypto.Util.getRandomHexOfNbytes(p), 16);
+};
+
+KJUR.crypto.Util.getRandomHexOfNbits = function (p) {
+ var n = p % 8;
+ var A = (p - n) / 8;
+ var L = new Array(A + 1);
+ return KJUR.crypto.Util.SECURERANDOMGEN.nextBytes(L), L[0] = (255 << n & 255 ^ 255) & L[0], BAtohex(L);
+};
+
+KJUR.crypto.Util.getRandomBigIntegerOfNbits = function (p) {
+ return new BigInteger(KJUR.crypto.Util.getRandomHexOfNbits(p), 16);
+};
+
+KJUR.crypto.Util.getRandomBigIntegerZeroToMax = function (p) {
+ var n = p.bitLength();
+
+ while (1) {
+ var A = KJUR.crypto.Util.getRandomBigIntegerOfNbits(n);
+ if (p.compareTo(A) != -1) return A;
+ }
+};
+
+KJUR.crypto.Util.getRandomBigIntegerMinToMax = function (p, n) {
+ var A = p.compareTo(n);
+ if (A == 1) throw "biMin is greater than biMax";
+ if (A == 0) return p;
+ var L = n.subtract(p);
+ var g = KJUR.crypto.Util.getRandomBigIntegerZeroToMax(L);
+ return g.add(p);
+};
+
+KJUR.crypto.MessageDigest = function (p) {
+ var n = null;
+ var A = null;
+ var L = null;
+
+ this.setAlgAndProvider = function (S, Y) {
+ S = KJUR.crypto.MessageDigest.getCanonicalAlgName(S);
+
+ if (S !== null && Y === undefined) {
+ Y = KJUR.crypto.Util.DEFAULTPROVIDER[S];
+ }
+
+ if (":md5:sha1:sha224:sha256:sha384:sha512:ripemd160:".indexOf(S) != -1 && Y == "cryptojs") {
+ try {
+ this.md = KJUR.crypto.Util.CRYPTOJSMESSAGEDIGESTNAME[S].create();
+ } catch (J) {
+ console.log(J);
+ throw "setAlgAndProvider hash alg set fail alg=" + S + "/" + J;
+ }
+
+ this.updateString = function (C) {
+ this.md.update(C);
+ };
+
+ this.updateHex = function (C) {
+ var V = CryptoJS.enc.Hex.parse(C);
+ this.md.update(V);
+ };
+
+ this.digest = function () {
+ var C = this.md.finalize();
+ return C.toString(CryptoJS.enc.Hex);
+ };
+
+ this.digestString = function (C) {
+ return this.updateString(C), this.digest();
+ };
+
+ this.digestHex = function (C) {
+ return this.updateHex(C), this.digest();
+ };
+ }
+
+ if (":sha256:".indexOf(S) != -1 && Y == "sjcl") {
+ try {
+ this.md = new sjcl.hash.sha256();
+ } catch (C) {
+ console.log(C);
+ throw "setAlgAndProvider hash alg set fail alg=" + S + "/" + C;
+ }
+
+ this.updateString = function (V) {
+ this.md.update(V);
+ };
+
+ this.updateHex = function (V) {
+ var W = sjcl.codec.hex.toBits(V);
+ this.md.update(W);
+ };
+
+ this.digest = function () {
+ var V = this.md.finalize();
+ return sjcl.codec.hex.fromBits(V);
+ };
+
+ this.digestString = function (V) {
+ return this.updateString(V), this.digest();
+ };
+
+ this.digestHex = function (V) {
+ return this.updateHex(V), this.digest();
+ };
+ }
+ };
+
+ this.updateString = function (g) {
+ throw "updateString(str) not supported for this alg/prov: " + this.algName + "/" + this.provName;
+ };
+
+ this.updateHex = function (g) {
+ throw "updateHex(hex) not supported for this alg/prov: " + this.algName + "/" + this.provName;
+ };
+
+ this.digest = function () {
+ throw "digest() not supported for this alg/prov: " + this.algName + "/" + this.provName;
+ };
+
+ this.digestString = function (g) {
+ throw "digestString(str) not supported for this alg/prov: " + this.algName + "/" + this.provName;
+ };
+
+ this.digestHex = function (g) {
+ throw "digestHex(hex) not supported for this alg/prov: " + this.algName + "/" + this.provName;
+ };
+
+ p !== undefined && p.alg !== undefined && (this.algName = p.alg, p.prov === undefined && (this.provName = KJUR.crypto.Util.DEFAULTPROVIDER[this.algName]), this.setAlgAndProvider(this.algName, this.provName));
+};
+
+KJUR.crypto.MessageDigest.getCanonicalAlgName = function (p) {
+ return typeof p === "string" && (p = p.toLowerCase(), p = p.replace(/-/, "")), p;
+};
+
+KJUR.crypto.MessageDigest.getHashLength = function (p) {
+ var n = KJUR.crypto.MessageDigest;
+ var A = n.getCanonicalAlgName(p);
+ if (n.HASHLENGTH[A] === undefined) throw "not supported algorithm: " + p;
+ return n.HASHLENGTH[A];
+};
+
+KJUR.crypto.MessageDigest.HASHLENGTH = {
+ "md5": 16,
+ "sha1": 20,
+ "sha224": 28,
+ "sha256": 32,
+ "sha384": 48,
+ "sha512": 64,
+ "ripemd160": 20
+};
+
+KJUR.crypto.Mac = function (p) {
+ var n = null;
+ var A = null;
+ var L = null;
+ var g = null;
+ var S = null;
+
+ this.setAlgAndProvider = function (Y, J) {
+ Y = Y.toLowerCase();
+
+ if (Y == null) {
+ Y = "hmacsha1";
+ }
+
+ Y = Y.toLowerCase();
+ if (Y.substr(0, 4) != "hmac") throw "setAlgAndProvider unsupported HMAC alg: " + Y;
+
+ if (J === undefined) {
+ J = KJUR.crypto.Util.DEFAULTPROVIDER[Y];
+ }
+
+ this.algProv = Y + "/" + J;
+ var C = Y.substr(4);
+
+ if (":md5:sha1:sha224:sha256:sha384:sha512:ripemd160:".indexOf(C) != -1 && J == "cryptojs") {
+ try {
+ var V = KJUR.crypto.Util.CRYPTOJSMESSAGEDIGESTNAME[C];
+ this.mac = CryptoJS.algo.HMAC.create(V, this.pass);
+ } catch (W) {
+ console.log(W);
+ throw "setAlgAndProvider hash alg set fail hashAlg=" + C + "/" + W;
+ }
+
+ this.updateString = function (R) {
+ this.mac.update(R);
+ };
+
+ this.updateHex = function (R) {
+ var B = CryptoJS.enc.Hex.parse(R);
+ this.mac.update(B);
+ };
+
+ this.doFinal = function () {
+ var R = this.mac.finalize();
+ return R.toString(CryptoJS.enc.Hex);
+ };
+
+ this.doFinalString = function (R) {
+ return this.updateString(R), this.doFinal();
+ };
+
+ this.doFinalHex = function (R) {
+ return this.updateHex(R), this.doFinal();
+ };
+ }
+ };
+
+ this.updateString = function (Y) {
+ throw "updateString(str) not supported for this alg/prov: " + this.algProv;
+ };
+
+ this.updateHex = function (Y) {
+ throw "updateHex(hex) not supported for this alg/prov: " + this.algProv;
+ };
+
+ this.doFinal = function () {
+ throw "digest() not supported for this alg/prov: " + this.algProv;
+ };
+
+ this.doFinalString = function (Y) {
+ throw "digestString(str) not supported for this alg/prov: " + this.algProv;
+ };
+
+ this.doFinalHex = function (Y) {
+ throw "digestHex(hex) not supported for this alg/prov: " + this.algProv;
+ };
+
+ this.setPassword = function (Y) {
+ if (typeof Y == "string") {
+ var J = Y;
+
+ if (Y.length % 2 == 1 || !Y.match(/^[0-9A-Fa-f]+$/)) {
+ J = rstrtohex(Y);
+ }
+
+ this.pass = CryptoJS.enc.Hex.parse(J);
+ return;
+ }
+
+ if (typeof Y != "object") throw "KJUR.crypto.Mac unsupported password type: " + Y;
+ var J = null;
+
+ if (Y.hex !== undefined) {
+ if (Y.hex.length % 2 != 0 || !Y.hex.match(/^[0-9A-Fa-f]+$/)) throw "Mac: wrong hex password: " + Y.hex;
+ J = Y.hex;
+ }
+
+ if (Y.utf8 !== undefined) {
+ J = utf8tohex(Y.utf8);
+ }
+
+ if (Y.rstr !== undefined) {
+ J = rstrtohex(Y.rstr);
+ }
+
+ if (Y.b64 !== undefined) {
+ J = b64tohex(Y.b64);
+ }
+
+ if (Y.b64u !== undefined) {
+ J = b64utohex(Y.b64u);
+ }
+
+ if (J == null) throw "KJUR.crypto.Mac unsupported password type: " + Y;
+ this.pass = CryptoJS.enc.Hex.parse(J);
+ };
+
+ p !== undefined && (p.pass !== undefined && this.setPassword(p.pass), p.alg !== undefined && (this.algName = p.alg, p.prov === undefined && (this.provName = KJUR.crypto.Util.DEFAULTPROVIDER[this.algName]), this.setAlgAndProvider(this.algName, this.provName)));
+};
+
+KJUR.crypto.Signature = function (A) {
+ var L = null;
+ var S = null;
+ var Y = null;
+ var J = null;
+ var C = null;
+ var V = null;
+ var W = null;
+ var R = null;
+ var B = null;
+ var F = null;
+ var E = -1;
+ var s = null;
+ var I = null;
+ var K = null;
+ var T = null;
+ var Z = null;
+
+ this._setAlgNames = function () {
+ var w = this.algName.match(/^(.+)with(.+)$/);
+
+ if (w) {
+ this.mdAlgName = w[1].toLowerCase();
+ this.pubkeyAlgName = w[2].toLowerCase();
+ }
+ };
+
+ this._zeroPaddingOfSignature = function (M, U) {
+ var H = "";
+ var O = U / 4 - M.length;
+
+ for (var X = 0; X < O; X++) {
+ H = H + "0";
+ }
+
+ return H + M;
+ };
+
+ this.setAlgAndProvider = function (w, M) {
+ this._setAlgNames();
+
+ if (M != "cryptojs/jsrsa") throw "provider not supported: " + M;
+
+ if (":md5:sha1:sha224:sha256:sha384:sha512:ripemd160:".indexOf(this.mdAlgName) != -1) {
+ try {
+ this.md = new KJUR.crypto.MessageDigest({
+ "alg": this.mdAlgName
+ });
+ } catch (U) {
+ console.log(U);
+ throw "setAlgAndProvider hash alg set fail alg=" + this.mdAlgName + "/" + U;
+ }
+
+ this.init = function (H, O) {
+ var X = null;
+
+ try {
+ if (O === undefined) {
+ X = KEYUTIL.getKey(H);
+ } else {
+ X = KEYUTIL.getKey(H, O);
+ }
+ } catch (G) {
+ console.log(G);
+ throw "init failed:" + G;
+ }
+
+ if (X.isPrivate === !![]) {
+ this.prvKey = X;
+ this.state = "SIGN";
+ } else {
+ if (X.isPublic === !![]) {
+ this.pubKey = X;
+ this.state = "VERIFY";
+ } else throw "init failed.:" + X;
+ }
+ };
+
+ this.updateString = function (H) {
+ this.md.updateString(H);
+ };
+
+ this.updateHex = function (H) {
+ this.md.updateHex(H);
+ };
+
+ this.sign = function () {
+ this.sHashHex = this.md.digest();
+
+ if (this.prvKey === undefined && this.ecprvhex !== undefined && this.eccurvename !== undefined && KJUR.crypto.ECDSA !== undefined) {
+ this.prvKey = new KJUR.crypto.ECDSA({
+ "curve": this.eccurvename,
+ "prv": this.ecprvhex
+ });
+ }
+
+ if (this.prvKey instanceof RSAKey && this.pubkeyAlgName === "rsaandmgf1") this.hSign = this.prvKey.signWithMessageHashPSS(this.sHashHex, this.mdAlgName, this.pssSaltLen);else {
+ if (this.prvKey instanceof RSAKey && this.pubkeyAlgName === "rsa") this.hSign = this.prvKey.signWithMessageHash(this.sHashHex, this.mdAlgName);else {
+ if (this.prvKey instanceof KJUR.crypto.ECDSA) this.hSign = this.prvKey.signWithMessageHash(this.sHashHex);else {
+ if (this.prvKey instanceof KJUR.crypto.DSA) this.hSign = this.prvKey.signWithMessageHash(this.sHashHex);else throw "Signature: unsupported private key alg: " + this.pubkeyAlgName;
+ }
+ }
+ }
+ return this.hSign;
+ };
+
+ this.signString = function (H) {
+ return this.updateString(H), this.sign();
+ };
+
+ this.signHex = function (H) {
+ return this.updateHex(H), this.sign();
+ };
+
+ this.verify = function (H) {
+ this.sHashHex = this.md.digest();
+
+ if (this.pubKey === undefined && this.ecpubhex !== undefined && this.eccurvename !== undefined && KJUR.crypto.ECDSA !== undefined) {
+ this.pubKey = new KJUR.crypto.ECDSA({
+ "curve": this.eccurvename,
+ "pub": this.ecpubhex
+ });
+ }
+
+ if (this.pubKey instanceof RSAKey && this.pubkeyAlgName === "rsaandmgf1") return this.pubKey.verifyWithMessageHashPSS(this.sHashHex, H, this.mdAlgName, this.pssSaltLen);else {
+ if (this.pubKey instanceof RSAKey && this.pubkeyAlgName === "rsa") return this.pubKey.verifyWithMessageHash(this.sHashHex, H);else {
+ if (KJUR.crypto.ECDSA !== undefined && this.pubKey instanceof KJUR.crypto.ECDSA) return this.pubKey.verifyWithMessageHash(this.sHashHex, H);else {
+ if (KJUR.crypto.DSA !== undefined && this.pubKey instanceof KJUR.crypto.DSA) return this.pubKey.verifyWithMessageHash(this.sHashHex, H);else throw "Signature: unsupported public key alg: " + this.pubkeyAlgName;
+ }
+ }
+ }
+ };
+ }
+ };
+
+ this.init = function (w, M) {
+ throw "init(key, pass) not supported for this alg:prov=" + this.algProvName;
+ };
+
+ this.updateString = function (w) {
+ throw "updateString(str) not supported for this alg:prov=" + this.algProvName;
+ };
+
+ this.updateHex = function (w) {
+ throw "updateHex(hex) not supported for this alg:prov=" + this.algProvName;
+ };
+
+ this.sign = function () {
+ throw "sign() not supported for this alg:prov=" + this.algProvName;
+ };
+
+ this.signString = function (w) {
+ throw "digestString(str) not supported for this alg:prov=" + this.algProvName;
+ };
+
+ this.signHex = function (w) {
+ throw "digestHex(hex) not supported for this alg:prov=" + this.algProvName;
+ };
+
+ this.verify = function (w) {
+ throw "verify(hSigVal) not supported for this alg:prov=" + this.algProvName;
+ };
+
+ this.initParams = A;
+
+ if (A !== undefined) {
+ if (A.alg !== undefined) {
+ this.algName = A.alg;
+ A.prov === undefined ? this.provName = KJUR.crypto.Util.DEFAULTPROVIDER[this.algName] : this.provName = A.prov;
+ this.algProvName = this.algName + ":" + this.provName;
+ this.setAlgAndProvider(this.algName, this.provName);
+
+ this._setAlgNames();
+ }
+
+ if (A.psssaltlen !== undefined) {
+ this.pssSaltLen = A.psssaltlen;
+ }
+
+ if (A.prvkeypem !== undefined) {
+ if (A.prvkeypas !== undefined) throw "both prvkeypem and prvkeypas parameters not supported";else try {
+ var L = KEYUTIL.getKey(A.prvkeypem);
+ this.init(L);
+ } catch (w) {
+ console.log(w);
+ throw "fatal error to load pem private key: " + w;
+ }
+ }
+ }
+};
+
+KJUR.crypto.Cipher = function (p) {};
+
+KJUR.crypto.Cipher.encrypt = function (p, n, a) {
+ if (n instanceof RSAKey && n.isPublic) {
+ var A = KJUR.crypto.Cipher.getAlgByKeyAndName(n, a);
+ if (A === "RSA") return n.encrypt(p);
+ if (A === "RSAOAEP") return n.encryptOAEP(p, "sha1");
+ var L = A.match(/^RSAOAEP(\d+)$/);
+ if (L !== null) return n.encryptOAEP(p, "sha" + L[1]);
+ throw "Cipher.encrypt: unsupported algorithm for RSAKey: " + a;
+ } else throw "Cipher.encrypt: unsupported key or algorithm";
+};
+
+KJUR.crypto.Cipher.decrypt = function (p, n, a) {
+ if (n instanceof RSAKey && n.isPrivate) {
+ var A = KJUR.crypto.Cipher.getAlgByKeyAndName(n, a);
+ if (A === "RSA") return n.decrypt(p);
+ if (A === "RSAOAEP") return n.decryptOAEP(p, "sha1");
+ var L = A.match(/^RSAOAEP(\d+)$/);
+ if (L !== null) return n.decryptOAEP(p, "sha" + L[1]);
+ throw "Cipher.decrypt: unsupported algorithm for RSAKey: " + a;
+ } else throw "Cipher.decrypt: unsupported key or algorithm";
+};
+
+KJUR.crypto.Cipher.getAlgByKeyAndName = function (p, n) {
+ if (p instanceof RSAKey) {
+ if (":RSA:RSAOAEP:RSAOAEP224:RSAOAEP256:RSAOAEP384:RSAOAEP512:".indexOf(n) != -1) return n;
+ if (n === null || n === undefined) return "RSA";
+ throw "getAlgByKeyAndName: not supported algorithm name for RSAKey: " + n;
+ }
+
+ throw "getAlgByKeyAndName: not supported algorithm name: " + n;
+};
+
+KJUR.crypto.OID = new function () {
+ this.oidhex2name = {
+ "2a864886f70d010101": "rsaEncryption",
+ "2a8648ce3d0201": "ecPublicKey",
+ "2a8648ce380401": "dsa",
+ "2a8648ce3d030107": "secp256r1",
+ "2b8104001f": "secp192k1",
+ "2b81040021": "secp224r1",
+ "2b8104000a": "secp256k1",
+ "2b81040023": "secp521r1",
+ "2b81040022": "secp384r1",
+ "2a8648ce380403": "SHA1withDSA",
+ "608648016503040301": "SHA224withDSA",
+ "608648016503040302": "SHA256withDSA"
+ };
+}();
+
+if (typeof KJUR == "undefined" || !KJUR) {
+ KJUR = {};
+}
+
+if (typeof KJUR.crypto == "undefined" || !KJUR.crypto) {
+ KJUR.crypto = {};
+}
+
+KJUR.crypto.ECDSA = function (p) {
+ var n = "secp256r1";
+ var A = null;
+ var L = null;
+ var S = null;
+ var Y = BigInteger;
+ var J = ECPointFp;
+ var C = KJUR.crypto.ECDSA;
+ var V = KJUR.crypto.ECParameterDB;
+ var W = new SecureRandom();
+ var R = null;
+ this.type = "EC";
+ this.isPrivate = ![];
+ this.isPublic = ![];
+
+ function B(F, E, I, K) {
+ var T = Math.max(E.bitLength(), K.bitLength());
+ var Z = F.add2D(I);
+ var w = F.curve.getInfinity();
+
+ for (var M = T - 1; M >= 0; --M) {
+ w = w.twice2D();
+ w.z = Y.ONE;
+ E.testBit(M) ? K.testBit(M) ? w = w.add2D(Z) : w = w.add2D(F) : K.testBit(M) && (w = w.add2D(I));
+ }
+
+ return w;
+ }
+
+ this.getBigRandom = function (F) {
+ return new Y(F.bitLength(), W).mod(F.subtract(Y.ONE)).add(Y.ONE);
+ };
+
+ this.setNamedCurve = function (F) {
+ this.ecparams = V.getByName(F);
+ this.prvKeyHex = null;
+ this.pubKeyHex = null;
+ this.curveName = F;
+ };
+
+ this.setPrivateKeyHex = function (F) {
+ this.isPrivate = !![];
+ this.prvKeyHex = F;
+ };
+
+ this.setPublicKeyHex = function (F) {
+ this.isPublic = !![];
+ this.pubKeyHex = F;
+ };
+
+ this.getPublicKeyXYHex = function () {
+ var F = this.pubKeyHex;
+ if (F.substr(0, 2) !== "04") throw "this method supports uncompressed format(04) only";
+ var E = this.ecparams.keylen / 4;
+ if (F.length !== 2 + E * 2) throw "malformed public key hex length";
+ var s = {};
+ return s.x = F.substr(2, E), s.y = F.substr(2 + E), s;
+ };
+
+ this.getShortNISTPCurveName = function () {
+ var F = this.curveName;
+ if (F === "secp256r1" || F === "NIST P-256" || F === "P-256" || F === "prime256v1") return "P-256";
+ if (F === "secp384r1" || F === "NIST P-384" || F === "P-384") return "P-384";
+ return null;
+ };
+
+ this.generateKeyPairHex = function () {
+ var F = this.ecparams.n;
+ var E = this.getBigRandom(F);
+ var I = this.ecparams.G.multiply(E);
+ var K = I.getX().toBigInteger();
+ var T = I.getY().toBigInteger();
+ var Z = this.ecparams.keylen / 4;
+ var w = ("0000000000" + E.toString(16)).slice(-Z);
+ var M = ("0000000000" + K.toString(16)).slice(-Z);
+ var U = ("0000000000" + T.toString(16)).slice(-Z);
+ var H = "04" + M + U;
+ return this.setPrivateKeyHex(w), this.setPublicKeyHex(H), {
+ "ecprvhex": w,
+ "ecpubhex": H
+ };
+ };
+
+ this.signWithMessageHash = function (F) {
+ return this.signHex(F, this.prvKeyHex);
+ };
+
+ this.signHex = function (F, E) {
+ var s = new Y(E, 16);
+ var I = this.ecparams.n;
+ var K = new Y(F.substring(0, this.ecparams.keylen / 4), 16);
+
+ do {
+ var T = this.getBigRandom(I);
+ var Z = this.ecparams.G;
+ var M = Z.multiply(T);
+ var U = M.getX().toBigInteger().mod(I);
+ } while (U.compareTo(Y.ZERO) <= 0);
+
+ var H = T.modInverse(I).multiply(K.add(s.multiply(U))).mod(I);
+ return C.biRSSigToASN1Sig(U, H);
+ };
+
+ this.sign = function (F, E) {
+ var s = E;
+ var I = this.ecparams.n;
+ var K = Y.fromByteArrayUnsigned(F);
+
+ do {
+ var T = this.getBigRandom(I);
+ var Z = this.ecparams.G;
+ var M = Z.multiply(T);
+ var U = M.getX().toBigInteger().mod(I);
+ } while (U.compareTo(BigInteger.ZERO) <= 0);
+
+ var H = T.modInverse(I).multiply(K.add(s.multiply(U))).mod(I);
+ return this.serializeSig(U, H);
+ };
+
+ this.verifyWithMessageHash = function (F, E) {
+ return this.verifyHex(F, E, this.pubKeyHex);
+ };
+
+ this.verifyHex = function (F, E, s) {
+ try {
+ var I;
+ var K;
+ var T = C.parseSigHex(E);
+ I = T.r;
+ K = T.s;
+ var Z = J.decodeFromHex(this.ecparams.curve, s);
+ var M = new Y(F.substring(0, this.ecparams.keylen / 4), 16);
+ return this.verifyRaw(M, I, K, Z);
+ } catch (U) {
+ console.log(U);
+ return ![];
+ }
+ };
+
+ this.verify = function (F, E, s) {
+ var I;
+ var K;
+
+ if (Bitcoin.Util.isArray(E)) {
+ var T = this.parseSig(E);
+ I = T.r;
+ K = T.s;
+ } else {
+ if ("object" === typeof E && E.r && E.s) {
+ I = E.r;
+ K = E.s;
+ } else throw "Invalid value for signature";
+ }
+
+ var Z;
+ if (s instanceof ECPointFp) Z = s;else {
+ if (Bitcoin.Util.isArray(s)) Z = J.decodeFrom(this.ecparams.curve, s);else throw "Invalid format for pubkey value, must be byte array or ECPointFp";
+ }
+ var w = Y.fromByteArrayUnsigned(F);
+ return this.verifyRaw(w, I, K, Z);
+ };
+
+ this.verifyRaw = function (F, E, s, I) {
+ var K = this.ecparams.n;
+ var T = this.ecparams.G;
+ if (E.compareTo(Y.ONE) < 0 || E.compareTo(K) >= 0) return ![];
+ if (s.compareTo(Y.ONE) < 0 || s.compareTo(K) >= 0) return ![];
+ var Z = s.modInverse(K);
+ var M = F.multiply(Z).mod(K);
+ var U = E.multiply(Z).mod(K);
+ var H = T.multiply(M).add(I.multiply(U));
+ var O = H.getX().toBigInteger().mod(K);
+ return O.equals(E);
+ };
+
+ this.serializeSig = function (F, E) {
+ var s = F.toByteArraySigned();
+ var I = E.toByteArraySigned();
+ var K = [];
+ return K.push(2), K.push(s.length), K = K.concat(s), K.push(2), K.push(I.length), K = K.concat(I), K.unshift(K.length), K.unshift(48), K;
+ };
+
+ this.parseSig = function (F) {
+ var E;
+ if (F[0] != 48) throw new Error("Signature not a valid DERSequence");
+ E = 2;
+ if (F[E] != 2) throw new Error("First element in signature must be a DERInteger");
+ var s = F.slice(E + 2, E + 2 + F[E + 1]);
+ E += 2 + F[E + 1];
+ if (F[E] != 2) throw new Error("Second element in signature must be a DERInteger");
+ var I = F.slice(E + 2, E + 2 + F[E + 1]);
+ E += 2 + F[E + 1];
+ var K = Y.fromByteArrayUnsigned(s);
+ var T = Y.fromByteArrayUnsigned(I);
+ return {
+ "r": K,
+ "s": T
+ };
+ };
+
+ this.parseSigCompact = function (F) {
+ if (F.length !== 65) throw "Signature has the wrong length";
+ var E = F[0] - 27;
+ if (E < 0 || E > 7) throw "Invalid signature type";
+ var s = this.ecparams.n;
+ var I = Y.fromByteArrayUnsigned(F.slice(1, 33)).mod(s);
+ var K = Y.fromByteArrayUnsigned(F.slice(33, 65)).mod(s);
+ return {
+ "r": I,
+ "s": K,
+ "i": E
+ };
+ };
+
+ this.readPKCS5PrvKeyHex = function (F) {
+ var E = ASN1HEX;
+ var I = C.getName;
+ var K = E.getVbyList;
+ if (E.isASN1HEX(F) === ![]) throw "not ASN.1 hex string";
+ var T;
+ var Z;
+ var w;
+
+ try {
+ T = K(F, 0, [2, 0], "06");
+ Z = K(F, 0, [1], "04");
+
+ try {
+ w = K(F, 0, [3, 0], "03").substr(2);
+ } catch (M) {
+ console.log(M);
+ }
+ } catch (u) {
+ console.log(u);
+ throw "malformed PKCS#1/5 plain ECC private key";
+ }
+
+ this.curveName = I(T);
+ if (this.curveName === undefined) throw "unsupported curve name";
+ this.setNamedCurve(this.curveName);
+ this.setPublicKeyHex(w);
+ this.setPrivateKeyHex(Z);
+ this.isPublic = ![];
+ };
+
+ this.readPKCS8PrvKeyHex = function (F) {
+ var E = ASN1HEX;
+ var I = KJUR.crypto.ECDSA.getName;
+ var K = E.getVbyList;
+ if (E.isASN1HEX(F) === ![]) throw "not ASN.1 hex string";
+ var T;
+ var Z;
+ var w;
+ var M;
+
+ try {
+ T = K(F, 0, [1, 0], "06");
+ Z = K(F, 0, [1, 1], "06");
+ w = K(F, 0, [2, 0, 1], "04");
+
+ try {
+ M = K(F, 0, [2, 0, 2, 0], "03").substr(2);
+ } catch (U) {
+ console.log(U);
+ }
+ } catch (H) {
+ console.log(H);
+ throw "malformed PKCS#8 plain ECC private key";
+ }
+
+ this.curveName = I(Z);
+ if (this.curveName === undefined) throw "unsupported curve name";
+ this.setNamedCurve(this.curveName);
+ this.setPublicKeyHex(M);
+ this.setPrivateKeyHex(w);
+ this.isPublic = ![];
+ };
+
+ this.readPKCS8PubKeyHex = function (F) {
+ var E = ASN1HEX;
+ var I = KJUR.crypto.ECDSA.getName;
+ var K = E.getVbyList;
+ if (E.isASN1HEX(F) === ![]) throw "not ASN.1 hex string";
+ var T;
+ var Z;
+ var w;
+
+ try {
+ T = K(F, 0, [0, 0], "06");
+ Z = K(F, 0, [0, 1], "06");
+ w = K(F, 0, [1], "03").substr(2);
+ } catch (M) {
+ console.log(M);
+ throw "malformed PKCS#8 ECC public key";
+ }
+
+ this.curveName = I(Z);
+ if (this.curveName === null) throw "unsupported curve name";
+ this.setNamedCurve(this.curveName);
+ this.setPublicKeyHex(w);
+ };
+
+ this.readCertPubKeyHex = function (F, E) {
+ if (E !== 5) {
+ E = 6;
+ }
+
+ var I = ASN1HEX;
+ var K = C.getName;
+ var T = I.getVbyList;
+ if (I.isASN1HEX(F) === ![]) throw "not ASN.1 hex string";
+ var Z;
+ var w;
+
+ try {
+ Z = T(F, 0, [0, E, 0, 1], "06");
+ w = T(F, 0, [0, E, 1], "03").substr(2);
+ } catch (M) {
+ console.log(M);
+ throw "malformed X.509 certificate ECC public key";
+ }
+
+ this.curveName = K(Z);
+ if (this.curveName === null) throw "unsupported curve name";
+ this.setNamedCurve(this.curveName);
+ this.setPublicKeyHex(w);
+ };
+
+ p !== undefined && p.curve !== undefined && (this.curveName = p.curve);
+ this.curveName === undefined && (this.curveName = n);
+ this.setNamedCurve(this.curveName);
+ p !== undefined && (p.prv !== undefined && this.setPrivateKeyHex(p.prv), p.pub !== undefined && this.setPublicKeyHex(p.pub));
+};
+
+KJUR.crypto.ECDSA.parseSigHex = function (p) {
+ var n = KJUR.crypto.ECDSA.parseSigHexInHexRS(p);
+ var A = new BigInteger(n.r, 16);
+ var L = new BigInteger(n.s, 16);
+ return {
+ "r": A,
+ "s": L
+ };
+};
+
+KJUR.crypto.ECDSA.parseSigHexInHexRS = function (p) {
+ var n = ASN1HEX;
+ var a = n.getChildIdx;
+ var A = n.getV;
+ n.checkStrictDER(p, 0);
+ if (p.substr(0, 2) != "30") throw new Error("signature is not a ASN.1 sequence");
+ var L = a(p, 0);
+ if (L.length != 2) throw new Error("signature shall have two elements");
+ var S = L[0];
+ var Y = L[1];
+ if (p.substr(S, 2) != "02") throw new Error("1st item not ASN.1 integer");
+ if (p.substr(Y, 2) != "02") throw new Error("2nd item not ASN.1 integer");
+ var J = A(p, S);
+ var C = A(p, Y);
+ return {
+ "r": J,
+ "s": C
+ };
+};
+
+KJUR.crypto.ECDSA.asn1SigToConcatSig = function (p) {
+ var n = KJUR.crypto.ECDSA.parseSigHexInHexRS(p);
+ var A = n.r;
+ var L = n.s;
+
+ if (A.substr(0, 2) == "00" && A.length % 32 == 2) {
+ A = A.substr(2);
+ }
+
+ if (L.substr(0, 2) == "00" && L.length % 32 == 2) {
+ L = L.substr(2);
+ }
+
+ if (A.length % 32 == 30) {
+ A = "00" + A;
+ }
+
+ if (L.length % 32 == 30) {
+ L = "00" + L;
+ }
+
+ if (A.length % 32 != 0) throw "unknown ECDSA sig r length error";
+ if (L.length % 32 != 0) throw "unknown ECDSA sig s length error";
+ return A + L;
+};
+
+KJUR.crypto.ECDSA.concatSigToASN1Sig = function (p) {
+ if (p.length / 2 * 8 % 128 != 0) throw "unknown ECDSA concatinated r-s sig length error";
+ var n = p.substr(0, p.length / 2);
+ var A = p.substr(p.length / 2);
+ return KJUR.crypto.ECDSA.hexRSSigToASN1Sig(n, A);
+};
+
+KJUR.crypto.ECDSA.hexRSSigToASN1Sig = function (p, n) {
+ var A = new BigInteger(p, 16);
+ var L = new BigInteger(n, 16);
+ return KJUR.crypto.ECDSA.biRSSigToASN1Sig(A, L);
+};
+
+KJUR.crypto.ECDSA.biRSSigToASN1Sig = function (p, n) {
+ var A = KJUR.asn1;
+ var L = new A.DERInteger({
+ "bigint": p
+ });
+ var g = new A.DERInteger({
+ "bigint": n
+ });
+ var S = new A.DERSequence({
+ "array": [L, g]
+ });
+ return S.getEncodedHex();
+};
+
+KJUR.crypto.ECDSA.getName = function (p) {
+ if (p === "2b8104001f") return "secp192k1";
+ if (p === "2a8648ce3d030107") return "secp256r1";
+ if (p === "2b8104000a") return "secp256k1";
+ if (p === "2b81040021") return "secp224r1";
+ if (p === "2b81040022") return "secp384r1";
+ if ("|secp256r1|NIST P-256|P-256|prime256v1|".indexOf(p) !== -1) return "secp256r1";
+ if ("|secp256k1|".indexOf(p) !== -1) return "secp256k1";
+ if ("|secp224r1|NIST P-224|P-224|".indexOf(p) !== -1) return "secp224r1";
+ if ("|secp384r1|NIST P-384|P-384|".indexOf(p) !== -1) return "secp384r1";
+ return null;
+};
+
+if (typeof KJUR == "undefined" || !KJUR) {
+ KJUR = {};
+}
+
+if (typeof KJUR.crypto == "undefined" || !KJUR.crypto) {
+ KJUR.crypto = {};
+}
+
+KJUR.crypto.ECParameterDB = new function () {
+ var p = {};
+ var n = {};
+
+ function A(L) {
+ return new BigInteger(L, 16);
+ }
+
+ this.getByName = function (L) {
+ var g = L;
+
+ if (typeof n[g] != "undefined") {
+ g = n[L];
+ }
+
+ if (typeof p[g] != "undefined") return p[g];
+ throw "unregistered EC curve name: " + g;
+ };
+
+ this.regist = function (L, S, Y, J, C, V, W, R, B, F, E, I) {
+ p[L] = {};
+ var K = A(Y);
+ var T = A(J);
+ var i = A(C);
+ var Z = A(V);
+ var M = A(W);
+ var U = new ECCurveFp(K, T, i);
+ var h = U.decodePointHex("04" + R + B);
+ p[L].name = L;
+ p[L].keylen = S;
+ p[L].curve = U;
+ p[L].G = h;
+ p[L].n = Z;
+ p[L].h = M;
+ p[L].oid = E;
+ p[L].info = I;
+
+ for (var H = 0; H < F.length; H++) {
+ n[F[H]] = L;
+ }
+ };
+}();
+KJUR.crypto.ECParameterDB.regist("secp128r1", 128, "FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFC", "E87579C11079F43DD824993C2CEE5ED3", "FFFFFFFE0000000075A30D1B9038A115", "1", "161FF7528B899B2D0C28607CA52C5B86", "CF5AC8395BAFEB13C02DA292DDED7A83", [], "", "secp128r1 : SECG curve over a 128 bit prime field");
+KJUR.crypto.ECParameterDB.regist("secp160k1", 160, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFAC73", "0", "7", "0100000000000000000001B8FA16DFAB9ACA16B6B3", "1", "3B4C382CE37AA192A4019E763036F4F5DD4D7EBB", "938CF935318FDCED6BC28286531733C3F03C4FEE", [], "", "secp160k1 : SECG curve over a 160 bit prime field");
+KJUR.crypto.ECParameterDB.regist("secp160r1", 160, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFC", "1C97BEFC54BD7A8B65ACF89F81D4D4ADC565FA45", "0100000000000000000001F4C8F927AED3CA752257", "1", "4A96B5688EF573284664698968C38BB913CBFC82", "23A628553168947D59DCC912042351377AC5FB32", [], "", "secp160r1 : SECG curve over a 160 bit prime field");
+KJUR.crypto.ECParameterDB.regist("secp192k1", 192, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFEE37", "0", "3", "FFFFFFFFFFFFFFFFFFFFFFFE26F2FC170F69466A74DEFD8D", "1", "DB4FF10EC057E9AE26B07D0280B7F4341DA5D1B1EAE06C7D", "9B2F2F6D9C5628A7844163D015BE86344082AA88D95E2F9D", []);
+KJUR.crypto.ECParameterDB.regist("secp192r1", 192, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC", "64210519E59C80E70FA7E9AB72243049FEB8DEECC146B9B1", "FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22831", "1", "188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012", "07192B95FFC8DA78631011ED6B24CDD573F977A11E794811", []);
+KJUR.crypto.ECParameterDB.regist("secp224r1", 224, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE", "B4050A850C04B3ABF54132565044B0B7D7BFD8BA270B39432355FFB4", "FFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D", "1", "B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21", "BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34", []);
+KJUR.crypto.ECParameterDB.regist("secp256k1", 256, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", "0", "7", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", "1", "79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", "483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8", []);
+KJUR.crypto.ECParameterDB.regist("secp256r1", 256, "FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC", "5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B", "FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551", "1", "6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296", "4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5", ["NIST P-256", "P-256", "prime256v1"]);
+KJUR.crypto.ECParameterDB.regist("secp384r1", 384, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFC", "B3312FA7E23EE7E4988E056BE3F82D19181D9C6EFE8141120314088F5013875AC656398D8A2ED19D2A85C8EDD3EC2AEF", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973", "1", "AA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB7", "3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f", ["NIST P-384", "P-384"]);
+KJUR.crypto.ECParameterDB.regist("secp521r1", 521, "1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC", "051953EB9618E1C9A1F929A21A0B68540EEA2DA725B99B315F3B8B489918EF109E156193951EC7E937B1652C0BD3BB1BF073573DF883D2C34F1EF451FD46B503F00", "1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA51868783BF2F966B7FCC0148F709A5D03BB5C9B8899C47AEBB6FB71E91386409", "1", "C6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE75928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66", "011839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650", ["NIST P-521", "P-521"]);
+
+if (typeof KJUR == "undefined" || !KJUR) {
+ KJUR = {};
+}
+
+if (typeof KJUR.crypto == "undefined" || !KJUR.crypto) {
+ KJUR.crypto = {};
+}
+
+KJUR.crypto.DSA = function () {
+ this.p = null;
+ this.q = null;
+ this.g = null;
+ this.y = null;
+ this.x = null;
+ this.type = "DSA";
+ this.isPrivate = ![];
+ this.isPublic = ![];
+
+ this.setPrivate = function (p, n, A, L, g) {
+ this.isPrivate = !![];
+ this.p = p;
+ this.q = n;
+ this.g = A;
+ this.y = L;
+ this.x = g;
+ };
+
+ this.setPrivateHex = function (p, n, A, L, S) {
+ var Y;
+ var J;
+ var C;
+ var V;
+ var W;
+ Y = new BigInteger(p, 16);
+ J = new BigInteger(n, 16);
+ C = new BigInteger(A, 16);
+ typeof L === "string" && L.length > 1 ? V = new BigInteger(L, 16) : V = null;
+ W = new BigInteger(S, 16);
+ this.setPrivate(Y, J, C, V, W);
+ };
+
+ this.setPublic = function (p, n, A, L) {
+ this.isPublic = !![];
+ this.p = p;
+ this.q = n;
+ this.g = A;
+ this.y = L;
+ this.x = null;
+ };
+
+ this.setPublicHex = function (p, n, A, L) {
+ var S;
+ var Y;
+ var J;
+ var C;
+ S = new BigInteger(p, 16);
+ Y = new BigInteger(n, 16);
+ J = new BigInteger(A, 16);
+ C = new BigInteger(L, 16);
+ this.setPublic(S, Y, J, C);
+ };
+
+ this.signWithMessageHash = function (p) {
+ var A = this.p;
+ var L = this.q;
+ var g = this.g;
+ var S = this.y;
+ var Y = this.x;
+ var J = KJUR.crypto.Util.getRandomBigIntegerMinToMax(BigInteger.ONE.add(BigInteger.ONE), L.subtract(BigInteger.ONE));
+ var C = p.substr(0, L.bitLength() / 4);
+ var V = new BigInteger(C, 16);
+ var W = g.modPow(J, A).mod(L);
+ var R = J.modInverse(L).multiply(V.add(Y.multiply(W))).mod(L);
+ var B = KJUR.asn1.ASN1Util.jsonToASN1HEX({
+ "seq": [{
+ "int": {
+ "bigint": W
+ }
+ }, {
+ "int": {
+ "bigint": R
+ }
+ }]
+ });
+ return B;
+ };
+
+ this.verifyWithMessageHash = function (p, A) {
+ var L = this.p;
+ var g = this.q;
+ var S = this.g;
+ var Y = this.y;
+ var J = this.parseASN1Signature(A);
+ var C = J[0];
+ var V = J[1];
+ var W = p.substr(0, g.bitLength() / 4);
+ var R = new BigInteger(W, 16);
+ if (BigInteger.ZERO.compareTo(C) > 0 || C.compareTo(g) > 0) throw "invalid DSA signature";
+ if (BigInteger.ZERO.compareTo(V) >= 0 || V.compareTo(g) > 0) throw "invalid DSA signature";
+ var B = V.modInverse(g);
+ var F = R.multiply(B).mod(g);
+ var E = C.multiply(B).mod(g);
+ var s = S.modPow(F, L).multiply(Y.modPow(E, L)).mod(L).mod(g);
+ return s.compareTo(C) == 0;
+ };
+
+ this.parseASN1Signature = function (p) {
+ try {
+ var n = new BigInteger(ASN1HEX.getVbyList(p, 0, [0], "02"), 16);
+ var A = new BigInteger(ASN1HEX.getVbyList(p, 0, [1], "02"), 16);
+ return [n, A];
+ } catch (L) {
+ console.log(L);
+ throw "malformed ASN.1 DSA signature";
+ }
+ };
+
+ this.readPKCS5PrvKeyHex = function (p) {
+ var n;
+ var A;
+ var L;
+ var S;
+ var Y;
+ var J = ASN1HEX;
+ var C = J.getVbyList;
+ if (J.isASN1HEX(p) === ![]) throw "not ASN.1 hex string";
+
+ try {
+ n = C(p, 0, [1], "02");
+ A = C(p, 0, [2], "02");
+ L = C(p, 0, [3], "02");
+ S = C(p, 0, [4], "02");
+ Y = C(p, 0, [5], "02");
+ } catch (V) {
+ console.log(V);
+ console.log("EXCEPTION:" + V);
+ throw "malformed PKCS#1/5 plain DSA private key";
+ }
+
+ this.setPrivateHex(n, A, L, S, Y);
+ };
+
+ this.readPKCS8PrvKeyHex = function (p) {
+ var n;
+ var A;
+ var L;
+ var S;
+ var Y = ASN1HEX;
+ var J = Y.getVbyList;
+ if (Y.isASN1HEX(p) === ![]) throw "not ASN.1 hex string";
+
+ try {
+ n = J(p, 0, [1, 1, 0], "02");
+ A = J(p, 0, [1, 1, 1], "02");
+ L = J(p, 0, [1, 1, 2], "02");
+ S = J(p, 0, [2, 0], "02");
+ } catch (C) {
+ console.log(C);
+ console.log("EXCEPTION:" + C);
+ throw "malformed PKCS#8 plain DSA private key";
+ }
+
+ this.setPrivateHex(n, A, L, null, S);
+ };
+
+ this.readPKCS8PubKeyHex = function (p) {
+ var n;
+ var A;
+ var L;
+ var S;
+ var Y = ASN1HEX;
+ var J = Y.getVbyList;
+ if (Y.isASN1HEX(p) === ![]) throw "not ASN.1 hex string";
+
+ try {
+ n = J(p, 0, [0, 1, 0], "02");
+ A = J(p, 0, [0, 1, 1], "02");
+ L = J(p, 0, [0, 1, 2], "02");
+ S = J(p, 0, [1, 0], "02");
+ } catch (C) {
+ console.log(C);
+ console.log("EXCEPTION:" + C);
+ throw "malformed PKCS#8 DSA public key";
+ }
+
+ this.setPublicHex(n, A, L, S);
+ };
+
+ this.readCertPubKeyHex = function (p, n) {
+ if (n !== 5) {
+ n = 6;
+ }
+
+ var A;
+ var L;
+ var S;
+ var Y;
+ var J = ASN1HEX;
+ var C = J.getVbyList;
+ if (J.isASN1HEX(p) === ![]) throw "not ASN.1 hex string";
+
+ try {
+ A = C(p, 0, [0, n, 0, 1, 0], "02");
+ L = C(p, 0, [0, n, 0, 1, 1], "02");
+ S = C(p, 0, [0, n, 0, 1, 2], "02");
+ Y = C(p, 0, [0, n, 1, 0], "02");
+ } catch (V) {
+ console.log(V);
+ console.log("EXCEPTION:" + V);
+ throw "malformed X.509 certificate DSA public key";
+ }
+
+ this.setPublicHex(A, L, S, Y);
+ };
+};
+
+var KEYUTIL = function () {
+ var p = function (K, T, Z) {
+ return S(CryptoJS.AES, K, T, Z);
+ };
+
+ var A = function (K, T, Z) {
+ return S(CryptoJS.TripleDES, K, T, Z);
+ };
+
+ var L = function (K, T, Z) {
+ return S(CryptoJS.DES, K, T, Z);
+ };
+
+ var S = function (K, T, Z, M) {
+ var U = CryptoJS.enc.Hex.parse(T);
+ var H = CryptoJS.enc.Hex.parse(Z);
+ var O = CryptoJS.enc.Hex.parse(M);
+ var X = {};
+ X.key = H;
+ X.iv = O;
+ X.ciphertext = U;
+ var G = K.decrypt(X, H, {
+ "iv": O
+ });
+ return CryptoJS.enc.Hex.stringify(G);
+ };
+
+ var Y = function (K, T, Z) {
+ return V(CryptoJS.AES, K, T, Z);
+ };
+
+ var J = function (K, T, Z) {
+ return V(CryptoJS.TripleDES, K, T, Z);
+ };
+
+ var C = function (K, T, Z) {
+ return V(CryptoJS.DES, K, T, Z);
+ };
+
+ var V = function (K, T, Z, M) {
+ var U = CryptoJS.enc.Hex.parse(T);
+ var H = CryptoJS.enc.Hex.parse(Z);
+ var O = CryptoJS.enc.Hex.parse(M);
+ var X = K.encrypt(U, H, {
+ "iv": O
+ });
+ var G = CryptoJS.enc.Hex.parse(X.toString());
+ var N = CryptoJS.enc.Base64.stringify(G);
+ return N;
+ };
+
+ var W = {
+ "AES-256-CBC": {
+ "proc": p,
+ "eproc": Y,
+ "keylen": 32,
+ "ivlen": 16
+ },
+ "AES-192-CBC": {
+ "proc": p,
+ "eproc": Y,
+ "keylen": 24,
+ "ivlen": 16
+ },
+ "AES-128-CBC": {
+ "proc": p,
+ "eproc": Y,
+ "keylen": 16,
+ "ivlen": 16
+ },
+ "DES-EDE3-CBC": {
+ "proc": A,
+ "eproc": J,
+ "keylen": 24,
+ "ivlen": 8
+ },
+ "DES-CBC": {
+ "proc": L,
+ "eproc": C,
+ "keylen": 8,
+ "ivlen": 8
+ }
+ };
+
+ var R = function (K) {
+ return W[K].proc;
+ };
+
+ var B = function (K) {
+ var T = CryptoJS.lib.WordArray.random(K);
+ var Z = CryptoJS.enc.Hex.stringify(T);
+ return Z;
+ };
+
+ var F = function (K) {
+ var T = {};
+ var Z = K.match(new RegExp("DEK-Info: ([^,]+),([0-9A-Fa-f]+)", "m"));
+
+ if (Z) {
+ T.cipher = Z[1];
+ T.ivsalt = Z[2];
+ }
+
+ var M = K.match(new RegExp("-----BEGIN ([A-Z]+) PRIVATE KEY-----"));
+
+ if (M) {
+ T.type = M[1];
+ }
+
+ var U = -1;
+ var H = 0;
+
+ if (K.indexOf("\r\n\r\n") != -1) {
+ U = K.indexOf("\r\n\r\n");
+ H = 2;
+ }
+
+ if (K.indexOf("\n\n") != -1) {
+ U = K.indexOf("\n\n");
+ H = 1;
+ }
+
+ var O = K.indexOf("-----END");
+
+ if (U != -1 && O != -1) {
+ var X = K.substring(U + H * 2, O - H);
+ X = X.replace(/\s+/g, "");
+ T.data = X;
+ }
+
+ return T;
+ };
+
+ var E = function (K, T, Z) {
+ var M = Z.substring(0, 16);
+ var U = CryptoJS.enc.Hex.parse(M);
+ var H = CryptoJS.enc.Utf8.parse(T);
+ var O = W[K].keylen + W[K].ivlen;
+ var X = "";
+ var G = null;
+
+ for (;;) {
+ var N = CryptoJS.algo.MD5.create();
+
+ if (G != null) {
+ N.update(G);
+ }
+
+ N.update(H);
+ N.update(U);
+ G = N.finalize();
+ X = X + CryptoJS.enc.Hex.stringify(G);
+ if (X.length >= O * 2) break;
+ }
+
+ var D = {};
+ return D.keyhex = X.substr(0, W[K].keylen * 2), D.ivhex = X.substr(W[K].keylen * 2, W[K].ivlen * 2), D;
+ };
+
+ var s = function (K, T, Z, M) {
+ var U = CryptoJS.enc.Base64.parse(K);
+ var H = CryptoJS.enc.Hex.stringify(U);
+ var O = W[T].proc;
+ var X = O(H, Z, M);
+ return X;
+ };
+
+ var I = function (K, T, Z, w) {
+ var M = W[T].eproc;
+ var U = M(K, Z, w);
+ return U;
+ };
+
+ return {
+ "version": "1.0.0",
+ "parsePKCS5PEM": function (K) {
+ return F(K);
+ },
+ "getKeyAndUnusedIvByPasscodeAndIvsalt": function (K, T, Z) {
+ return E(K, T, Z);
+ },
+ "decryptKeyB64": function (K, T, Z, w) {
+ return s(K, T, Z, w);
+ },
+ "getDecryptedKeyHex": function (K, T) {
+ var Z = F(K);
+ var M = Z.type;
+ var U = Z.cipher;
+ var H = Z.ivsalt;
+ var O = Z.data;
+ var X = E(U, T, H);
+ var G = X.keyhex;
+ var N = s(O, U, G, H);
+ return N;
+ },
+ "getEncryptedPKCS5PEMFromPrvKeyHex": function (K, T, Z, M, U) {
+ var H = "";
+
+ if (typeof M == "undefined" || M == null) {
+ M = "AES-256-CBC";
+ }
+
+ if (typeof W[M] == "undefined") throw "KEYUTIL unsupported algorithm: " + M;
+
+ if (typeof U == "undefined" || U == null) {
+ var O = W[M].ivlen;
+ var X = B(O);
+ U = X.toUpperCase();
+ }
+
+ var G = E(M, Z, U);
+ var N = G.keyhex;
+ var D = I(T, M, N, U);
+ var Q = D.replace(/(.{64})/g, "$1\r\n");
+ var H = "-----BEGIN " + K + " PRIVATE KEY-----\r\n";
+ return H += "Proc-Type: 4,ENCRYPTED\r\n", H += "DEK-Info: " + M + "," + U + "\r\n", H += "\r\n", H += Q, H += "\r\n-----END " + K + " PRIVATE KEY-----\r\n", H;
+ },
+ "parseHexOfEncryptedPKCS8": function (K) {
+ var T = ASN1HEX;
+ var Z = T.getChildIdx;
+ var M = T.getV;
+ var U = {};
+ var H = Z(K, 0);
+ if (H.length != 2) throw "malformed format: SEQUENCE(0).items != 2: " + H.length;
+ U.ciphertext = M(K, H[1]);
+ var O = Z(K, H[0]);
+ if (O.length != 2) throw "malformed format: SEQUENCE(0.0).items != 2: " + O.length;
+ if (M(K, O[0]) != "2a864886f70d01050d") throw "this only supports pkcs5PBES2";
+ var X = Z(K, O[1]);
+ if (O.length != 2) throw "malformed format: SEQUENCE(0.0.1).items != 2: " + X.length;
+ var G = Z(K, X[1]);
+ if (G.length != 2) throw "malformed format: SEQUENCE(0.0.1.1).items != 2: " + G.length;
+ if (M(K, G[0]) != "2a864886f70d0307") throw "this only supports TripleDES";
+ U.encryptionSchemeAlg = "TripleDES";
+ U.encryptionSchemeIV = M(K, G[1]);
+ var N = Z(K, X[0]);
+ if (N.length != 2) throw "malformed format: SEQUENCE(0.0.1.0).items != 2: " + N.length;
+ if (M(K, N[0]) != "2a864886f70d01050c") throw "this only supports pkcs5PBKDF2";
+ var D = Z(K, N[1]);
+ if (D.length < 2) throw "malformed format: SEQUENCE(0.0.1.0.1).items < 2: " + D.length;
+ U.pbkdf2Salt = M(K, D[0]);
+ var Q = M(K, D[1]);
+
+ try {
+ U.pbkdf2Iter = parseInt(Q, 16);
+ } catch (P) {
+ console.log(P);
+ throw "malformed format pbkdf2Iter: " + Q;
+ }
+
+ return U;
+ },
+ "getPBKDF2KeyHexFromParam": function (K, T) {
+ var Z = CryptoJS.enc.Hex.parse(K.pbkdf2Salt);
+ var w = K.pbkdf2Iter;
+ var M = CryptoJS.PBKDF2(T, Z, {
+ "keySize": 6,
+ "iterations": w
+ });
+ var U = CryptoJS.enc.Hex.stringify(M);
+ return U;
+ },
+ "_getPlainPKCS8HexFromEncryptedPKCS8PEM": function (K, T) {
+ var Z = pemtohex(K, "ENCRYPTED PRIVATE KEY");
+ var M = this.parseHexOfEncryptedPKCS8(Z);
+ var U = KEYUTIL.getPBKDF2KeyHexFromParam(M, T);
+ var H = {};
+ H.ciphertext = CryptoJS.enc.Hex.parse(M.ciphertext);
+ var O = CryptoJS.enc.Hex.parse(U);
+ var X = CryptoJS.enc.Hex.parse(M.encryptionSchemeIV);
+ var G = CryptoJS.TripleDES.decrypt(H, O, {
+ "iv": X
+ });
+ var N = CryptoJS.enc.Hex.stringify(G);
+ return N;
+ },
+ "getKeyFromEncryptedPKCS8PEM": function (K, T) {
+ var Z = this._getPlainPKCS8HexFromEncryptedPKCS8PEM(K, T);
+
+ var w = this.getKeyFromPlainPrivatePKCS8Hex(Z);
+ return w;
+ },
+ "parsePlainPrivatePKCS8Hex": function (K) {
+ var T = ASN1HEX;
+ var Z = T.getChildIdx;
+ var w = T.getV;
+ var M = {};
+ M.algparam = null;
+ if (K.substr(0, 2) != "30") throw "malformed plain PKCS8 private key(code:001)";
+ var U = Z(K, 0);
+ if (U.length != 3) throw "malformed plain PKCS8 private key(code:002)";
+ if (K.substr(U[1], 2) != "30") throw "malformed PKCS8 private key(code:003)";
+ var H = Z(K, U[1]);
+ if (H.length != 2) throw "malformed PKCS8 private key(code:004)";
+ if (K.substr(H[0], 2) != "06") throw "malformed PKCS8 private key(code:005)";
+ M.algoid = w(K, H[0]);
+
+ if (K.substr(H[1], 2) == "06") {
+ M.algparam = w(K, H[1]);
+ }
+
+ if (K.substr(U[2], 2) != "04") throw "malformed PKCS8 private key(code:006)";
+ return M.keyidx = T.getVidx(K, U[2]), M;
+ },
+ "getKeyFromPlainPrivatePKCS8PEM": function (K) {
+ var T = pemtohex(K, "PRIVATE KEY");
+ var Z = this.getKeyFromPlainPrivatePKCS8Hex(T);
+ return Z;
+ },
+ "getKeyFromPlainPrivatePKCS8Hex": function (K) {
+ var T = this.parsePlainPrivatePKCS8Hex(K);
+ var Z;
+ if (T.algoid == "2a864886f70d010101") Z = new RSAKey();else {
+ if (T.algoid == "2a8648ce380401") Z = new KJUR.crypto.DSA();else {
+ if (T.algoid == "2a8648ce3d0201") Z = new KJUR.crypto.ECDSA();else throw "unsupported private key algorithm";
+ }
+ }
+ return Z.readPKCS8PrvKeyHex(K), Z;
+ },
+ "_getKeyFromPublicPKCS8Hex": function (K) {
+ var T;
+ var Z = ASN1HEX.getVbyList(K, 0, [0, 0], "06");
+ if (Z === "2a864886f70d010101") T = new RSAKey();else {
+ if (Z === "2a8648ce380401") T = new KJUR.crypto.DSA();else {
+ if (Z === "2a8648ce3d0201") T = new KJUR.crypto.ECDSA();else throw "unsupported PKCS#8 public key hex";
+ }
+ }
+ return T.readPKCS8PubKeyHex(K), T;
+ },
+ "parsePublicRawRSAKeyHex": function (K) {
+ var T = ASN1HEX;
+ var Z = T.getChildIdx;
+ var w = T.getV;
+ var M = {};
+ if (K.substr(0, 2) != "30") throw "malformed RSA key(code:001)";
+ var U = Z(K, 0);
+ if (U.length != 2) throw "malformed RSA key(code:002)";
+ if (K.substr(U[0], 2) != "02") throw "malformed RSA key(code:003)";
+ M.n = w(K, U[0]);
+ if (K.substr(U[1], 2) != "02") throw "malformed RSA key(code:004)";
+ return M.e = w(K, U[1]), M;
+ },
+ "parsePublicPKCS8Hex": function (K) {
+ var T = ASN1HEX;
+ var Z = T.getChildIdx;
+ var M = T.getV;
+ var U = {};
+ U.algparam = null;
+ var H = Z(K, 0);
+ if (H.length != 2) throw "outer DERSequence shall have 2 elements: " + H.length;
+ var O = H[0];
+ if (K.substr(O, 2) != "30") throw "malformed PKCS8 public key(code:001)";
+ var X = Z(K, O);
+ if (X.length != 2) throw "malformed PKCS8 public key(code:002)";
+ if (K.substr(X[0], 2) != "06") throw "malformed PKCS8 public key(code:003)";
+ U.algoid = M(K, X[0]);
+
+ if (K.substr(X[1], 2) == "06") {
+ U.algparam = M(K, X[1]);
+ } else {
+ if (K.substr(X[1], 2) == "30") {
+ U.algparam = {};
+ U.algparam.p = T.getVbyList(K, X[1], [0], "02");
+ U.algparam.q = T.getVbyList(K, X[1], [1], "02");
+ U.algparam.g = T.getVbyList(K, X[1], [2], "02");
+ }
+ }
+
+ if (K.substr(H[1], 2) != "03") throw "malformed PKCS8 public key(code:004)";
+ return U.key = M(K, H[1]).substr(2), U;
+ }
+ };
+}();
+
+KEYUTIL.getKey = function (p, a, g) {
+ var S = ASN1HEX;
+ var Y = S.getChildIdx;
+ var V = S.getV;
+ var W = S.getVbyList;
+ var R = KJUR.crypto;
+ var T = R.ECDSA;
+ var Z = R.DSA;
+ var q = RSAKey;
+ var U = pemtohex;
+ var h = KEYUTIL;
+ if (typeof q != "undefined" && p instanceof q) return p;
+ if (typeof T != "undefined" && p instanceof T) return p;
+ if (typeof Z != "undefined" && p instanceof Z) return p;
+ if (p.curve !== undefined && p.xy !== undefined && p.d === undefined) return new T({
+ "pub": p.xy,
+ "curve": p.curve
+ });
+ if (p.curve !== undefined && p.d !== undefined) return new T({
+ "prv": p.d,
+ "curve": p.curve
+ });
+
+ if (p.kty === undefined && p.n !== undefined && p.e !== undefined && p.d === undefined) {
+ var X = new q();
+ return X.setPublic(p.n, p.e), X;
+ }
+
+ if (p.kty === undefined && p.n !== undefined && p.e !== undefined && p.d !== undefined && p.p !== undefined && p.q !== undefined && p.dp !== undefined && p.dq !== undefined && p.co !== undefined && p.qi === undefined) {
+ var X = new q();
+ return X.setPrivateEx(p.n, p.e, p.d, p.p, p.q, p.dp, p.dq, p.co), X;
+ }
+
+ if (p.kty === undefined && p.n !== undefined && p.e !== undefined && p.d !== undefined && p.p === undefined) {
+ var X = new q();
+ return X.setPrivate(p.n, p.e, p.d), X;
+ }
+
+ if (p.p !== undefined && p.q !== undefined && p.g !== undefined && p.y !== undefined && p.x === undefined) {
+ var X = new Z();
+ return X.setPublic(p.p, p.q, p.g, p.y), X;
+ }
+
+ if (p.p !== undefined && p.q !== undefined && p.g !== undefined && p.y !== undefined && p.x !== undefined) {
+ var X = new Z();
+ return X.setPrivate(p.p, p.q, p.g, p.y, p.x), X;
+ }
+
+ if (p.kty === "RSA" && p.n !== undefined && p.e !== undefined && p.d === undefined) {
+ var X = new q();
+ return X.setPublic(b64utohex(p.n), b64utohex(p.e)), X;
+ }
+
+ if (p.kty === "RSA" && p.n !== undefined && p.e !== undefined && p.d !== undefined && p.p !== undefined && p.q !== undefined && p.dp !== undefined && p.dq !== undefined && p.qi !== undefined) {
+ var X = new q();
+ return X.setPrivateEx(b64utohex(p.n), b64utohex(p.e), b64utohex(p.d), b64utohex(p.p), b64utohex(p.q), b64utohex(p.dp), b64utohex(p.dq), b64utohex(p.qi)), X;
+ }
+
+ if (p.kty === "RSA" && p.n !== undefined && p.e !== undefined && p.d !== undefined) {
+ var X = new q();
+ return X.setPrivate(b64utohex(p.n), b64utohex(p.e), b64utohex(p.d)), X;
+ }
+
+ if (p.kty === "EC" && p.crv !== undefined && p.x !== undefined && p.y !== undefined && p.d === undefined) {
+ var x = new T({
+ "curve": p.crv
+ });
+ var y = x.ecparams.keylen / 4;
+ var Q = ("0000000000" + b64utohex(p.x)).slice(-y);
+ var p0 = ("0000000000" + b64utohex(p.y)).slice(-y);
+ var p1 = "04" + Q + p0;
+ return x.setPublicKeyHex(p1), x;
+ }
+
+ if (p.kty === "EC" && p.crv !== undefined && p.x !== undefined && p.y !== undefined && p.d !== undefined) {
+ var x = new T({
+ "curve": p.crv
+ });
+ var y = x.ecparams.keylen / 4;
+ var Q = ("0000000000" + b64utohex(p.x)).slice(-y);
+ var p0 = ("0000000000" + b64utohex(p.y)).slice(-y);
+ var p1 = "04" + Q + p0;
+ var p2 = ("0000000000" + b64utohex(p.d)).slice(-y);
+ return x.setPublicKeyHex(p1), x.setPrivateKeyHex(p2), x;
+ }
+
+ if (g === "pkcs5prv") {
+ var p3 = p;
+ var S = ASN1HEX;
+ var p4;
+ var X;
+ p4 = Y(p3, 0);
+
+ if (p4.length === 9) {
+ X = new q();
+ X.readPKCS5PrvKeyHex(p3);
+ } else {
+ if (p4.length === 6) {
+ X = new Z();
+ X.readPKCS5PrvKeyHex(p3);
+ } else {
+ if (p4.length > 2 && p3.substr(p4[1], 2) === "04") {
+ X = new T();
+ X.readPKCS5PrvKeyHex(p3);
+ } else throw "unsupported PKCS#1/5 hexadecimal key";
+ }
+ }
+
+ return X;
+ }
+
+ if (g === "pkcs8prv") {
+ var X = h.getKeyFromPlainPrivatePKCS8Hex(p);
+ return X;
+ }
+
+ if (g === "pkcs8pub") return h._getKeyFromPublicPKCS8Hex(p);
+ if (g === "x509pub") return X509.getPublicKeyFromCertHex(p);
+ if (p.indexOf("-END CERTIFICATE-", 0) != -1 || p.indexOf("-END X509 CERTIFICATE-", 0) != -1 || p.indexOf("-END TRUSTED CERTIFICATE-", 0) != -1) return X509.getPublicKeyFromCertPEM(p);
+
+ if (p.indexOf("-END PUBLIC KEY-") != -1) {
+ var p5 = pemtohex(p, "PUBLIC KEY");
+ return h._getKeyFromPublicPKCS8Hex(p5);
+ }
+
+ if (p.indexOf("-END RSA PRIVATE KEY-") != -1 && p.indexOf("4,ENCRYPTED") == -1) {
+ var p6 = U(p, "RSA PRIVATE KEY");
+ return h.getKey(p6, null, "pkcs5prv");
+ }
+
+ if (p.indexOf("-END DSA PRIVATE KEY-") != -1 && p.indexOf("4,ENCRYPTED") == -1) {
+ var p7 = U(p, "DSA PRIVATE KEY");
+ var p8 = W(p7, 0, [1], "02");
+ var p9 = W(p7, 0, [2], "02");
+ var pp = W(p7, 0, [3], "02");
+ var pn = W(p7, 0, [4], "02");
+ var pc = W(p7, 0, [5], "02");
+ var X = new Z();
+ return X.setPrivate(new BigInteger(p8, 16), new BigInteger(p9, 16), new BigInteger(pp, 16), new BigInteger(pn, 16), new BigInteger(pc, 16)), X;
+ }
+
+ if (p.indexOf("-END EC PRIVATE KEY-") != -1 && p.indexOf("4,ENCRYPTED") == -1) {
+ var p6 = U(p, "EC PRIVATE KEY");
+ return h.getKey(p6, null, "pkcs5prv");
+ }
+
+ if (p.indexOf("-END PRIVATE KEY-") != -1) return h.getKeyFromPlainPrivatePKCS8PEM(p);
+
+ if (p.indexOf("-END RSA PRIVATE KEY-") != -1 && p.indexOf("4,ENCRYPTED") != -1) {
+ var pa = h.getDecryptedKeyHex(p, a);
+ var pA = new RSAKey();
+ return pA.readPKCS5PrvKeyHex(pa), pA;
+ }
+
+ if (p.indexOf("-END EC PRIVATE KEY-") != -1 && p.indexOf("4,ENCRYPTED") != -1) {
+ var p7 = h.getDecryptedKeyHex(p, a);
+ var X = W(p7, 0, [1], "04");
+ var pL = W(p7, 0, [2, 0], "06");
+ var pg = W(p7, 0, [3, 0], "03").substr(2);
+ var pS = "";
+ if (KJUR.crypto.OID.oidhex2name[pL] !== undefined) pS = KJUR.crypto.OID.oidhex2name[pL];else throw "undefined OID(hex) in KJUR.crypto.OID: " + pL;
+ var x = new T({
+ "curve": pS
+ });
+ return x.setPublicKeyHex(pg), x.setPrivateKeyHex(X), x.isPublic = ![], x;
+ }
+
+ if (p.indexOf("-END DSA PRIVATE KEY-") != -1 && p.indexOf("4,ENCRYPTED") != -1) {
+ var p7 = h.getDecryptedKeyHex(p, a);
+ var p8 = W(p7, 0, [1], "02");
+ var p9 = W(p7, 0, [2], "02");
+ var pp = W(p7, 0, [3], "02");
+ var pn = W(p7, 0, [4], "02");
+ var pc = W(p7, 0, [5], "02");
+ var X = new Z();
+ return X.setPrivate(new BigInteger(p8, 16), new BigInteger(p9, 16), new BigInteger(pp, 16), new BigInteger(pn, 16), new BigInteger(pc, 16)), X;
+ }
+
+ if (p.indexOf("-END ENCRYPTED PRIVATE KEY-") != -1) return h.getKeyFromEncryptedPKCS8PEM(p, a);
+ throw "not supported argument";
+};
+
+KEYUTIL.generateKeypair = function (p, n) {
+ if (p == "RSA") {
+ var A = n;
+ var L = new RSAKey();
+ L.generate(A, "10001");
+ L.isPrivate = !![];
+ L.isPublic = !![];
+ var S = new RSAKey();
+ var Y = L.n.toString(16);
+ var J = L.e.toString(16);
+ S.setPublic(Y, J);
+ S.isPrivate = ![];
+ S.isPublic = !![];
+ var C = {};
+ return C.prvKeyObj = L, C.pubKeyObj = S, C;
+ } else {
+ if (p == "EC") {
+ var V = n;
+ var W = new KJUR.crypto.ECDSA({
+ "curve": V
+ });
+ var l = W.generateKeyPairHex();
+ var L = new KJUR.crypto.ECDSA({
+ "curve": V
+ });
+ L.setPublicKeyHex(l.ecpubhex);
+ L.setPrivateKeyHex(l.ecprvhex);
+ L.isPrivate = !![];
+ L.isPublic = ![];
+ var S = new KJUR.crypto.ECDSA({
+ "curve": V
+ });
+ S.setPublicKeyHex(l.ecpubhex);
+ S.isPrivate = ![];
+ S.isPublic = !![];
+ var C = {};
+ return C.prvKeyObj = L, C.pubKeyObj = S, C;
+ } else throw "unknown algorithm: " + p;
+ }
+};
+
+KEYUTIL.getPEM = function (L, S, Y, J, V, W) {
+ var R = KJUR;
+ var s = R.asn1;
+ var I = s.DERObjectIdentifier;
+ var K = s.DERInteger;
+ var T = s.ASN1Util.newObject;
+ var Z = s.x509;
+ var M = Z.SubjectPublicKeyInfo;
+ var U = R.crypto;
+ var H = U.DSA;
+ var O = U.ECDSA;
+ var X = RSAKey;
+
+ function G(pp) {
+ var pn = T({
+ "seq": [{
+ "int": 0
+ }, {
+ "int": {
+ "bigint": pp.n
+ }
+ }, {
+ "int": pp.e
+ }, {
+ "int": {
+ "bigint": pp.d
+ }
+ }, {
+ "int": {
+ "bigint": pp.p
+ }
+ }, {
+ "int": {
+ "bigint": pp.q
+ }
+ }, {
+ "int": {
+ "bigint": pp.dmp1
+ }
+ }, {
+ "int": {
+ "bigint": pp.dmq1
+ }
+ }, {
+ "int": {
+ "bigint": pp.coeff
+ }
+ }]
+ });
+ return pn;
+ }
+
+ function N(pp) {
+ var pn = T({
+ "seq": [{
+ "int": 1
+ }, {
+ "octstr": {
+ "hex": pp.prvKeyHex
+ }
+ }, {
+ "tag": ["a0", !![], {
+ "oid": {
+ "name": pp.curveName
+ }
+ }]
+ }, {
+ "tag": ["a1", !![], {
+ "bitstr": {
+ "hex": "00" + pp.pubKeyHex
+ }
+ }]
+ }]
+ });
+ return pn;
+ }
+
+ function Q(pp) {
+ var pn = T({
+ "seq": [{
+ "int": 0
+ }, {
+ "int": {
+ "bigint": pp.p
+ }
+ }, {
+ "int": {
+ "bigint": pp.q
+ }
+ }, {
+ "int": {
+ "bigint": pp.g
+ }
+ }, {
+ "int": {
+ "bigint": pp.y
+ }
+ }, {
+ "int": {
+ "bigint": pp.x
+ }
+ }]
+ });
+ return pn;
+ }
+
+ if ((X !== undefined && L instanceof X || H !== undefined && L instanceof H || O !== undefined && L instanceof O) && L.isPublic == !![] && (S === undefined || S == "PKCS8PUB")) {
+ var P = new M(L);
+ var p0 = P.getEncodedHex();
+ return hextopem(p0, "PUBLIC KEY");
+ }
+
+ if (S == "PKCS1PRV" && X !== undefined && L instanceof X && (Y === undefined || Y == null) && L.isPrivate == !![]) {
+ var P = G(L);
+ var p0 = P.getEncodedHex();
+ return hextopem(p0, "RSA PRIVATE KEY");
+ }
+
+ if (S == "PKCS1PRV" && O !== undefined && L instanceof O && (Y === undefined || Y == null) && L.isPrivate == !![]) {
+ var p1 = new I({
+ "name": L.curveName
+ });
+ var p2 = p1.getEncodedHex();
+ var p3 = N(L);
+ var p4 = p3.getEncodedHex();
+ var p5 = "";
+ return p5 += hextopem(p2, "EC PARAMETERS"), p5 += hextopem(p4, "EC PRIVATE KEY"), p5;
+ }
+
+ if (S == "PKCS1PRV" && H !== undefined && L instanceof H && (Y === undefined || Y == null) && L.isPrivate == !![]) {
+ var P = Q(L);
+ var p0 = P.getEncodedHex();
+ return hextopem(p0, "DSA PRIVATE KEY");
+ }
+
+ if (S == "PKCS5PRV" && X !== undefined && L instanceof X && Y !== undefined && Y != null && L.isPrivate == !![]) {
+ var P = G(L);
+ var p0 = P.getEncodedHex();
+ return J === undefined && (J = "DES-EDE3-CBC"), this.getEncryptedPKCS5PEMFromPrvKeyHex("RSA", p0, Y, J, W);
+ }
+
+ if (S == "PKCS5PRV" && O !== undefined && L instanceof O && Y !== undefined && Y != null && L.isPrivate == !![]) {
+ var P = N(L);
+ var p0 = P.getEncodedHex();
+ return J === undefined && (J = "DES-EDE3-CBC"), this.getEncryptedPKCS5PEMFromPrvKeyHex("EC", p0, Y, J, W);
+ }
+
+ if (S == "PKCS5PRV" && H !== undefined && L instanceof H && Y !== undefined && Y != null && L.isPrivate == !![]) {
+ var P = Q(L);
+ var p0 = P.getEncodedHex();
+ return J === undefined && (J = "DES-EDE3-CBC"), this.getEncryptedPKCS5PEMFromPrvKeyHex("DSA", p0, Y, J, W);
+ }
+
+ var p6 = function (pp, pn) {
+ var pc = p7(pp, pn);
+ var pa = new T({
+ "seq": [{
+ "seq": [{
+ "oid": {
+ "name": "pkcs5PBES2"
+ }
+ }, {
+ "seq": [{
+ "seq": [{
+ "oid": {
+ "name": "pkcs5PBKDF2"
+ }
+ }, {
+ "seq": [{
+ "octstr": {
+ "hex": pc.pbkdf2Salt
+ }
+ }, {
+ "int": pc.pbkdf2Iter
+ }]
+ }]
+ }, {
+ "seq": [{
+ "oid": {
+ "name": "des-EDE3-CBC"
+ }
+ }, {
+ "octstr": {
+ "hex": pc.encryptionSchemeIV
+ }
+ }]
+ }]
+ }]
+ }, {
+ "octstr": {
+ "hex": pc.ciphertext
+ }
+ }]
+ });
+ return pa.getEncodedHex();
+ };
+
+ var p7 = function (pp, pn) {
+ var pc = 100;
+ var pa = CryptoJS.lib.WordArray.random(8);
+ var pA = "DES-EDE3-CBC";
+ var pL = CryptoJS.lib.WordArray.random(8);
+ var pg = CryptoJS.PBKDF2(pn, pa, {
+ "keySize": 6,
+ "iterations": pc
+ });
+ var pS = CryptoJS.enc.Hex.parse(pp);
+ var pf = CryptoJS.TripleDES.encrypt(pS, pg, {
+ "iv": pL
+ }) + "";
+ var pY = {};
+ return pY.ciphertext = pf, pY.pbkdf2Salt = CryptoJS.enc.Hex.stringify(pa), pY.pbkdf2Iter = pc, pY.encryptionSchemeAlg = pA, pY.encryptionSchemeIV = CryptoJS.enc.Hex.stringify(pL), pY;
+ };
+
+ if (S == "PKCS8PRV" && X != undefined && L instanceof X && L.isPrivate == !![]) {
+ var p8 = G(L);
+ var p9 = p8.getEncodedHex();
+ var P = T({
+ "seq": [{
+ "int": 0
+ }, {
+ "seq": [{
+ "oid": {
+ "name": "rsaEncryption"
+ }
+ }, {
+ "null": !![]
+ }]
+ }, {
+ "octstr": {
+ "hex": p9
+ }
+ }]
+ });
+ var p0 = P.getEncodedHex();
+ if (Y === undefined || Y == null) return hextopem(p0, "PRIVATE KEY");else {
+ var p4 = p6(p0, Y);
+ return hextopem(p4, "ENCRYPTED PRIVATE KEY");
+ }
+ }
+
+ if (S == "PKCS8PRV" && O !== undefined && L instanceof O && L.isPrivate == !![]) {
+ var p8 = new T({
+ "seq": [{
+ "int": 1
+ }, {
+ "octstr": {
+ "hex": L.prvKeyHex
+ }
+ }, {
+ "tag": ["a1", !![], {
+ "bitstr": {
+ "hex": "00" + L.pubKeyHex
+ }
+ }]
+ }]
+ });
+ var p9 = p8.getEncodedHex();
+ var P = T({
+ "seq": [{
+ "int": 0
+ }, {
+ "seq": [{
+ "oid": {
+ "name": "ecPublicKey"
+ }
+ }, {
+ "oid": {
+ "name": L.curveName
+ }
+ }]
+ }, {
+ "octstr": {
+ "hex": p9
+ }
+ }]
+ });
+ var p0 = P.getEncodedHex();
+ if (Y === undefined || Y == null) return hextopem(p0, "PRIVATE KEY");else {
+ var p4 = p6(p0, Y);
+ return hextopem(p4, "ENCRYPTED PRIVATE KEY");
+ }
+ }
+
+ if (S == "PKCS8PRV" && H !== undefined && L instanceof H && L.isPrivate == !![]) {
+ var p8 = new K({
+ "bigint": L.x
+ });
+ var p9 = p8.getEncodedHex();
+ var P = T({
+ "seq": [{
+ "int": 0
+ }, {
+ "seq": [{
+ "oid": {
+ "name": "dsa"
+ }
+ }, {
+ "seq": [{
+ "int": {
+ "bigint": L.p
+ }
+ }, {
+ "int": {
+ "bigint": L.q
+ }
+ }, {
+ "int": {
+ "bigint": L.g
+ }
+ }]
+ }]
+ }, {
+ "octstr": {
+ "hex": p9
+ }
+ }]
+ });
+ var p0 = P.getEncodedHex();
+ if (Y === undefined || Y == null) return hextopem(p0, "PRIVATE KEY");else {
+ var p4 = p6(p0, Y);
+ return hextopem(p4, "ENCRYPTED PRIVATE KEY");
+ }
+ }
+
+ throw "unsupported object nor format";
+};
+
+KEYUTIL.getKeyFromCSRPEM = function (p) {
+ var n = pemtohex(p, "CERTIFICATE REQUEST");
+ var A = KEYUTIL.getKeyFromCSRHex(n);
+ return A;
+};
+
+KEYUTIL.getKeyFromCSRHex = function (p) {
+ var n = KEYUTIL.parseCSRHex(p);
+ var A = KEYUTIL.getKey(n.p8pubkeyhex, null, "pkcs8pub");
+ return A;
+};
+
+KEYUTIL.parseCSRHex = function (p) {
+ var n = ASN1HEX;
+ var A = n.getChildIdx;
+ var L = n.getTLV;
+ var S = {};
+ var Y = p;
+ if (Y.substr(0, 2) != "30") throw "malformed CSR(code:001)";
+ var J = A(Y, 0);
+ if (J.length < 1) throw "malformed CSR(code:002)";
+ if (Y.substr(J[0], 2) != "30") throw "malformed CSR(code:003)";
+ var C = A(Y, J[0]);
+ if (C.length < 3) throw "malformed CSR(code:004)";
+ return S.p8pubkeyhex = L(Y, C[2]), S;
+};
+
+KEYUTIL.getKeyID = function (p) {
+ var n = KEYUTIL;
+ var A = ASN1HEX;
+
+ if (typeof p === "string" && p.indexOf("BEGIN ") != -1) {
+ p = n.getKey(p);
+ }
+
+ var L = pemtohex(n.getPEM(p));
+ var g = A.getIdxbyList(L, 0, [1]);
+ var S = A.getV(L, g).substring(2);
+ return KJUR.crypto.Util.hashHex(S, "sha1");
+};
+
+KEYUTIL.getJWKFromKey = function (p) {
+ var n = {};
+ if (p instanceof RSAKey && p.isPrivate) return n.kty = "RSA", n.n = hextob64u(p.n.toString(16)), n.e = hextob64u(p.e.toString(16)), n.d = hextob64u(p.d.toString(16)), n.p = hextob64u(p.p.toString(16)), n.q = hextob64u(p.q.toString(16)), n.dp = hextob64u(p.dmp1.toString(16)), n.dq = hextob64u(p.dmq1.toString(16)), n.qi = hextob64u(p.coeff.toString(16)), n;else {
+ if (p instanceof RSAKey && p.isPublic) return n.kty = "RSA", n.n = hextob64u(p.n.toString(16)), n.e = hextob64u(p.e.toString(16)), n;else {
+ if (p instanceof KJUR.crypto.ECDSA && p.isPrivate) {
+ var A = p.getShortNISTPCurveName();
+ if (A !== "P-256" && A !== "P-384") throw "unsupported curve name for JWT: " + A;
+ var L = p.getPublicKeyXYHex();
+ return n.kty = "EC", n.crv = A, n.x = hextob64u(L.x), n.y = hextob64u(L.y), n.d = hextob64u(p.prvKeyHex), n;
+ } else {
+ if (p instanceof KJUR.crypto.ECDSA && p.isPublic) {
+ var A = p.getShortNISTPCurveName();
+ if (A !== "P-256" && A !== "P-384") throw "unsupported curve name for JWT: " + A;
+ var L = p.getPublicKeyXYHex();
+ return n.kty = "EC", n.crv = A, n.x = hextob64u(L.x), n.y = hextob64u(L.y), n;
+ }
+ }
+ }
+ }
+ throw "not supported key object";
+};
+
+RSAKey.getPosArrayOfChildrenFromHex = function (p) {
+ return ASN1HEX.getChildIdx(p, 0);
+};
+
+RSAKey.getHexValueArrayOfChildrenFromHex = function (p) {
+ var a = ASN1HEX;
+ var A = a.getV;
+ var L = RSAKey.getPosArrayOfChildrenFromHex(p);
+ var S = A(p, L[0]);
+ var Y = A(p, L[1]);
+ var J = A(p, L[2]);
+ var C = A(p, L[3]);
+ var V = A(p, L[4]);
+ var W = A(p, L[5]);
+ var R = A(p, L[6]);
+ var B = A(p, L[7]);
+ var F = A(p, L[8]);
+ var L = new Array();
+ return L.push(S, Y, J, C, V, W, R, B, F), L;
+};
+
+RSAKey.prototype.readPrivateKeyFromPEMString = function (p) {
+ var n = pemtohex(p);
+ var a = RSAKey.getHexValueArrayOfChildrenFromHex(n);
+ this.setPrivateEx(a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]);
+};
+
+RSAKey.prototype.readPKCS5PrvKeyHex = function (p) {
+ var n = RSAKey.getHexValueArrayOfChildrenFromHex(p);
+ this.setPrivateEx(n[1], n[2], n[3], n[4], n[5], n[6], n[7], n[8]);
+};
+
+RSAKey.prototype.readPKCS8PrvKeyHex = function (p) {
+ var n;
+ var A;
+ var L;
+ var S;
+ var Y;
+ var J;
+ var C;
+ var V;
+ var W = ASN1HEX;
+ var R = W.getVbyList;
+ if (W.isASN1HEX(p) === ![]) throw "not ASN.1 hex string";
+
+ try {
+ n = R(p, 0, [2, 0, 1], "02");
+ A = R(p, 0, [2, 0, 2], "02");
+ L = R(p, 0, [2, 0, 3], "02");
+ S = R(p, 0, [2, 0, 4], "02");
+ Y = R(p, 0, [2, 0, 5], "02");
+ J = R(p, 0, [2, 0, 6], "02");
+ C = R(p, 0, [2, 0, 7], "02");
+ V = R(p, 0, [2, 0, 8], "02");
+ } catch (B) {
+ console.log(B);
+ throw "malformed PKCS#8 plain RSA private key";
+ }
+
+ this.setPrivateEx(n, A, L, S, Y, J, C, V);
+};
+
+RSAKey.prototype.readPKCS5PubKeyHex = function (p) {
+ var n = ASN1HEX;
+ var A = n.getV;
+ if (n.isASN1HEX(p) === ![]) throw "keyHex is not ASN.1 hex string";
+ var L = n.getChildIdx(p, 0);
+ if (L.length !== 2 || p.substr(L[0], 2) !== "02" || p.substr(L[1], 2) !== "02") throw "wrong hex for PKCS#5 public key";
+ var g = A(p, L[0]);
+ var S = A(p, L[1]);
+ this.setPublic(g, S);
+};
+
+RSAKey.prototype.readPKCS8PubKeyHex = function (p) {
+ var n = ASN1HEX;
+ if (n.isASN1HEX(p) === ![]) throw "not ASN.1 hex string";
+ if (n.getTLVbyList(p, 0, [0, 0]) !== "06092a864886f70d010101") throw "not PKCS8 RSA public key";
+ var A = n.getTLVbyList(p, 0, [1, 0]);
+ this.readPKCS5PubKeyHex(A);
+};
+
+RSAKey.prototype.readCertPubKeyHex = function (p, n) {
+ var A;
+ var L;
+ A = new X509();
+ A.readCertHex(p);
+ L = A.getPublicKeyHex();
+ this.readPKCS8PubKeyHex(L);
+};
+
+var _RE_HEXDECONLY = new RegExp("[^0-9a-f]", "gi");
+
+function _rsasign_getHexPaddedDigestInfoForString(p, n, A) {
+ var L = function (S) {
+ return KJUR.crypto.Util.hashString(S, A);
+ };
+
+ var g = L(p);
+ return KJUR.crypto.Util.getPaddedDigestInfoHex(g, A, n);
+}
+
+function _zeroPaddingOfSignature(p, n) {
+ var A = "";
+ var L = n / 4 - p.length;
+
+ for (var g = 0; g < L; g++) {
+ A = A + "0";
+ }
+
+ return A + p;
+}
+
+RSAKey.prototype.sign = function (p, n) {
+ var A = function (g) {
+ return KJUR.crypto.Util.hashString(g, n);
+ };
+
+ var L = A(p);
+ return this.signWithMessageHash(L, n);
+};
+
+RSAKey.prototype.signWithMessageHash = function (p, n) {
+ var A = KJUR.crypto.Util.getPaddedDigestInfoHex(p, n, this.n.bitLength());
+ var L = parseBigInt(A, 16);
+ var g = this.doPrivate(L);
+ var S = g.toString(16);
+ return _zeroPaddingOfSignature(S, this.n.bitLength());
+};
+
+function pss_mgf1_str(p, n, A) {
+ var L = "";
+ var g = 0;
+
+ while (L.length < n) {
+ L += hextorstr(A(rstrtohex(p + String.fromCharCode.apply(String, [(g & 4278190080) >> 24, (g & 16711680) >> 16, (g & 65280) >> 8, g & 255]))));
+ g += 1;
+ }
+
+ return L;
+}
+
+RSAKey.prototype.signPSS = function (p, n, A) {
+ var L = function (S) {
+ return KJUR.crypto.Util.hashHex(S, n);
+ };
+
+ var g = L(rstrtohex(p));
+ return A === undefined && (A = -1), this.signWithMessageHashPSS(g, n, A);
+};
+
+RSAKey.prototype.signWithMessageHashPSS = function (A, L, S) {
+ var Y = hextorstr(A);
+ var J = Y.length;
+ var C = this.n.bitLength() - 1;
+ var V = Math.ceil(C / 8);
+ var W;
+
+ var R = function (Z) {
+ return KJUR.crypto.Util.hashHex(Z, L);
+ };
+
+ if (S === -1 || S === undefined) S = J;else {
+ if (S === -2) S = V - J - 2;else {
+ if (S < -2) throw "invalid salt length";
+ }
+ }
+ if (V < J + S + 2) throw "data too long";
+ var B = "";
+
+ if (S > 0) {
+ B = new Array(S);
+ new SecureRandom().nextBytes(B);
+ B = String.fromCharCode.apply(String, B);
+ }
+
+ var F = hextorstr(R(rstrtohex("\0\0\0\0\0\0\0\0" + Y + B)));
+ var E = [];
+
+ for (W = 0; W < V - S - J - 2; W += 1) {
+ E[W] = 0;
+ }
+
+ var s = String.fromCharCode.apply(String, E) + "" + B;
+ var I = pss_mgf1_str(F, s.length, R);
+ var K = [];
+
+ for (W = 0; W < s.length; W += 1) {
+ K[W] = s.charCodeAt(W) ^ I.charCodeAt(W);
+ }
+
+ var T = 65280 >> 8 * V - C & 255;
+ K[0] &= ~T;
+
+ for (W = 0; W < J; W++) {
+ K.push(F.charCodeAt(W));
+ }
+
+ return K.push(188), _zeroPaddingOfSignature(this.doPrivate(new BigInteger(K)).toString(16), this.n.bitLength());
+};
+
+function _rsasign_getDecryptSignatureBI(p, n, A) {
+ var L = new RSAKey();
+ L.setPublic(n, A);
+ var g = L.doPublic(p);
+ return g;
+}
+
+function _rsasign_getHexDigestInfoFromSig(p, n, A) {
+ var L = _rsasign_getDecryptSignatureBI(p, n, A);
+
+ var g = L.toString(16).replace(/^1f+00/, "");
+ return g;
+}
+
+function _rsasign_getAlgNameAndHashFromHexDisgestInfo(p) {
+ for (var n in KJUR.crypto.Util.DIGESTINFOHEAD) {
+ var a = KJUR.crypto.Util.DIGESTINFOHEAD[n];
+ var A = a.length;
+
+ if (p.substring(0, A) == a) {
+ var L = [n, p.substring(A)];
+ return L;
+ }
+ }
+
+ return [];
+}
+
+RSAKey.prototype.verify = function (p, n) {
+ n = n.replace(_RE_HEXDECONLY, "");
+ n = n.replace(/[ \n]+/g, "");
+ var A = parseBigInt(n, 16);
+ if (A.bitLength() > this.n.bitLength()) return 0;
+ var L = this.doPublic(A);
+ var S = L.toString(16).replace(/^1f+00/, "");
+
+ var Y = _rsasign_getAlgNameAndHashFromHexDisgestInfo(S);
+
+ if (Y.length == 0) return ![];
+ var J = Y[0];
+ var C = Y[1];
+
+ var V = function (l) {
+ return KJUR.crypto.Util.hashString(l, J);
+ };
+
+ var W = V(p);
+ return C == W;
+};
+
+RSAKey.prototype.verifyWithMessageHash = function (p, n) {
+ if (n.length != Math.ceil(this.n.bitLength() / 4)) return ![];
+ var A = parseBigInt(n, 16);
+ if (A.bitLength() > this.n.bitLength()) return 0;
+ var L = this.doPublic(A);
+ var S = L.toString(16).replace(/^1f+00/, "");
+
+ var Y = _rsasign_getAlgNameAndHashFromHexDisgestInfo(S);
+
+ if (Y.length == 0) return ![];
+ var J = Y[0];
+ var C = Y[1];
+ return C == p;
+};
+
+RSAKey.prototype.verifyPSS = function (p, n, A, L) {
+ var g = function (Y) {
+ return KJUR.crypto.Util.hashHex(Y, A);
+ };
+
+ var S = g(rstrtohex(p));
+ return L === undefined && (L = -1), this.verifyWithMessageHashPSS(S, n, A, L);
+};
+
+RSAKey.prototype.verifyWithMessageHashPSS = function (A, L, S, Y) {
+ if (L.length != Math.ceil(this.n.bitLength() / 4)) return ![];
+ var J = new BigInteger(L, 16);
+
+ var C = function (M) {
+ return KJUR.crypto.Util.hashHex(M, S);
+ };
+
+ var V = hextorstr(A);
+ var W = V.length;
+ var R = this.n.bitLength() - 1;
+ var B = Math.ceil(R / 8);
+ var F;
+ if (Y === -1 || Y === undefined) Y = W;else {
+ if (Y === -2) Y = B - W - 2;else {
+ if (Y < -2) throw "invalid salt length";
+ }
+ }
+ if (B < W + Y + 2) throw "data too long";
+ var E = this.doPublic(J).toByteArray();
+
+ for (F = 0; F < E.length; F += 1) {
+ E[F] &= 255;
+ }
+
+ while (E.length < B) {
+ E.unshift(0);
+ }
+
+ if (E[B - 1] !== 188) throw "encoded message does not end in 0xbc";
+ E = String.fromCharCode.apply(String, E);
+ var I = E.substr(0, B - W - 1);
+ var K = E.substr(I.length, W);
+ var T = 65280 >> 8 * B - R & 255;
+ if ((I.charCodeAt(0) & T) !== 0) throw "bits beyond keysize not zero";
+ var i = pss_mgf1_str(K, I.length, C);
+ var Z = [];
+
+ for (F = 0; F < I.length; F += 1) {
+ Z[F] = I.charCodeAt(F) ^ i.charCodeAt(F);
+ }
+
+ Z[0] &= ~T;
+ var w = B - W - Y - 2;
+
+ for (F = 0; F < w; F += 1) {
+ if (Z[F] !== 0) throw "leftmost octets not zero";
+ }
+
+ if (Z[w] !== 1) throw "0x01 marker not found";
+ return K === hextorstr(C(rstrtohex("\0\0\0\0\0\0\0\0" + V + String.fromCharCode.apply(String, Z.slice(-Y)))));
+};
+
+RSAKey.SALT_LEN_HLEN = -1;
+RSAKey.SALT_LEN_MAX = -2;
+RSAKey.SALT_LEN_RECOVER = -2;
+
+function X509() {
+ var p = ASN1HEX;
+ var n = p.getChildIdx;
+ var A = p.getV;
+ var L = p.getTLV;
+ var S = p.getVbyList;
+ var Y = p.getTLVbyList;
+ var J = p.getIdxbyList;
+ var C = p.getVidx;
+ var V = p.oidname;
+ var W = X509;
+ var l = pemtohex;
+ this.hex = null;
+ this.version = 0;
+ this.foffset = 0;
+ this.aExtInfo = null;
+
+ this.getVersion = function () {
+ if (this.hex === null || this.version !== 0) return this.version;
+ if (Y(this.hex, 0, [0, 0]) !== "a003020102") return this.version = 1, this.foffset = -1, 1;
+ return this.version = 3, 3;
+ };
+
+ this.getSerialNumberHex = function () {
+ return S(this.hex, 0, [0, 1 + this.foffset], "02");
+ };
+
+ this.getSignatureAlgorithmField = function () {
+ return V(S(this.hex, 0, [0, 2 + this.foffset, 0], "06"));
+ };
+
+ this.getIssuerHex = function () {
+ return Y(this.hex, 0, [0, 3 + this.foffset], "30");
+ };
+
+ this.getIssuerString = function () {
+ return W.hex2dn(this.getIssuerHex());
+ };
+
+ this.getSubjectHex = function () {
+ return Y(this.hex, 0, [0, 5 + this.foffset], "30");
+ };
+
+ this.getSubjectString = function () {
+ return W.hex2dn(this.getSubjectHex());
+ };
+
+ this.getNotBefore = function () {
+ var R = S(this.hex, 0, [0, 4 + this.foffset, 0]);
+ return R = R.replace(/(..)/g, "%$1"), R = decodeURIComponent(R), R;
+ };
+
+ this.getNotAfter = function () {
+ var R = S(this.hex, 0, [0, 4 + this.foffset, 1]);
+ return R = R.replace(/(..)/g, "%$1"), R = decodeURIComponent(R), R;
+ };
+
+ this.getPublicKeyHex = function () {
+ return p.getTLVbyList(this.hex, 0, [0, 6 + this.foffset], "30");
+ };
+
+ this.getPublicKeyIdx = function () {
+ return J(this.hex, 0, [0, 6 + this.foffset], "30");
+ };
+
+ this.getPublicKeyContentIdx = function () {
+ var R = this.getPublicKeyIdx();
+ return J(this.hex, R, [1, 0], "30");
+ };
+
+ this.getPublicKey = function () {
+ return KEYUTIL.getKey(this.getPublicKeyHex(), null, "pkcs8pub");
+ };
+
+ this.getSignatureAlgorithmName = function () {
+ return V(S(this.hex, 0, [1, 0], "06"));
+ };
+
+ this.getSignatureValueHex = function () {
+ return S(this.hex, 0, [2], "03", !![]);
+ };
+
+ this.verifySignature = function (R) {
+ var B = this.getSignatureAlgorithmName();
+ var F = this.getSignatureValueHex();
+ var E = Y(this.hex, 0, [0], "30");
+ var s = new KJUR.crypto.Signature({
+ "alg": B
+ });
+ return s.init(R), s.updateHex(E), s.verify(F);
+ };
+
+ this.parseExt = function (R) {
+ var B;
+ var F;
+ var E;
+
+ if (R === undefined) {
+ E = this.hex;
+ if (this.version !== 3) return -1;
+ B = J(E, 0, [0, 7, 0], "30");
+ F = n(E, B);
+ } else {
+ E = pemtohex(R);
+ var I = J(E, 0, [0, 3, 0, 0], "06");
+
+ if (A(E, I) != "2a864886f70d01090e") {
+ this.aExtInfo = new Array();
+ return;
+ }
+
+ B = J(E, 0, [0, 3, 0, 1, 0], "30");
+ F = n(E, B);
+ this.hex = E;
+ }
+
+ this.aExtInfo = new Array();
+
+ for (var K = 0; K < F.length; K++) {
+ var T = {};
+ T.critical = ![];
+ var Z = n(E, F[K]);
+ var w = 0;
+
+ if (Z.length === 3) {
+ T.critical = !![];
+ w = 1;
+ }
+
+ T.oid = p.hextooidstr(S(E, F[K], [0], "06"));
+ var M = J(E, F[K], [1 + w]);
+ T.vidx = C(E, M);
+ this.aExtInfo.push(T);
+ }
+ };
+
+ this.getExtInfo = function (R) {
+ var B = this.aExtInfo;
+ var F = R;
+
+ if (!R.match(/^[0-9.]+$/)) {
+ F = KJUR.asn1.x509.OID.name2oid(R);
+ }
+
+ if (F === "") return undefined;
+
+ for (var E = 0; E < B.length; E++) {
+ if (B[E].oid === F) return B[E];
+ }
+
+ return undefined;
+ };
+
+ this.getExtBasicConstraints = function () {
+ var R = this.getExtInfo("basicConstraints");
+ if (R === undefined) return R;
+ var B = A(this.hex, R.vidx);
+ if (B === "") return {};
+ if (B === "0101ff") return {
+ "cA": !![]
+ };
+
+ if (B.substr(0, 8) === "0101ff02") {
+ var F = A(B, 6);
+ var E = parseInt(F, 16);
+ return {
+ "cA": !![],
+ "pathLen": E
+ };
+ }
+
+ throw "basicConstraints parse error";
+ };
+
+ this.getExtKeyUsageBin = function () {
+ var R = this.getExtInfo("keyUsage");
+ if (R === undefined) return "";
+ var B = A(this.hex, R.vidx);
+ if (B.length % 2 != 0 || B.length <= 2) throw "malformed key usage value";
+ var F = parseInt(B.substr(0, 2));
+ var E = parseInt(B.substr(2), 16).toString(2);
+ return E.substr(0, E.length - F);
+ };
+
+ this.getExtKeyUsageString = function () {
+ var R = this.getExtKeyUsageBin();
+ var B = new Array();
+
+ for (var F = 0; F < R.length; F++) {
+ if (R.substr(F, 1) == "1") {
+ B.push(X509.KEYUSAGE_NAME[F]);
+ }
+ }
+
+ return B.join(",");
+ };
+
+ this.getExtSubjectKeyIdentifier = function () {
+ var R = this.getExtInfo("subjectKeyIdentifier");
+ if (R === undefined) return R;
+ return A(this.hex, R.vidx);
+ };
+
+ this.getExtAuthorityKeyIdentifier = function () {
+ var R = this.getExtInfo("authorityKeyIdentifier");
+ if (R === undefined) return R;
+ var B = {};
+ var F = L(this.hex, R.vidx);
+ var E = n(F, 0);
+
+ for (var s = 0; s < E.length; s++) {
+ if (F.substr(E[s], 2) === "80") {
+ B.kid = A(F, E[s]);
+ }
+ }
+
+ return B;
+ };
+
+ this.getExtExtKeyUsageName = function () {
+ var R = this.getExtInfo("extKeyUsage");
+ if (R === undefined) return R;
+ var B = new Array();
+ var F = L(this.hex, R.vidx);
+ if (F === "") return B;
+ var E = n(F, 0);
+
+ for (var s = 0; s < E.length; s++) {
+ B.push(V(A(F, E[s])));
+ }
+
+ return B;
+ };
+
+ this.getExtSubjectAltName = function () {
+ var R = this.getExtSubjectAltName2();
+ var B = new Array();
+
+ for (var F = 0; F < R.length; F++) {
+ if (R[F][0] === "DNS") {
+ B.push(R[F][1]);
+ }
+ }
+
+ return B;
+ };
+
+ this.getExtSubjectAltName2 = function () {
+ var R;
+ var B;
+ var F;
+ var E = this.getExtInfo("subjectAltName");
+ if (E === undefined) return E;
+ var I = new Array();
+ var K = L(this.hex, E.vidx);
+ var T = n(K, 0);
+
+ for (var Z = 0; Z < T.length; Z++) {
+ F = K.substr(T[Z], 2);
+ R = A(K, T[Z]);
+ F === "81" && (B = hextoutf8(R), I.push(["MAIL", B]));
+ F === "82" && (B = hextoutf8(R), I.push(["DNS", B]));
+ F === "84" && (B = X509.hex2dn(R, 0), I.push(["DN", B]));
+ F === "86" && (B = hextoutf8(R), I.push(["URI", B]));
+ F === "87" && (B = hextoip(R), I.push(["IP", B]));
+ }
+
+ return I;
+ };
+
+ this.getExtCRLDistributionPointsURI = function () {
+ var R = this.getExtInfo("cRLDistributionPoints");
+ if (R === undefined) return R;
+ var B = new Array();
+ var F = n(this.hex, R.vidx);
+
+ for (var E = 0; E < F.length; E++) {
+ try {
+ var s = S(this.hex, F[E], [0, 0, 0], "86");
+ var I = hextoutf8(s);
+ B.push(I);
+ } catch (K) {
+ console.log(K);
+ }
+ }
+
+ return B;
+ };
+
+ this.getExtAIAInfo = function () {
+ var R = this.getExtInfo("authorityInfoAccess");
+ if (R === undefined) return R;
+ var B = {
+ "ocsp": [],
+ "caissuer": []
+ };
+ var F = n(this.hex, R.vidx);
+
+ for (var E = 0; E < F.length; E++) {
+ var s = S(this.hex, F[E], [0], "06");
+ var I = S(this.hex, F[E], [1], "86");
+ s === "2b06010505073001" && B.ocsp.push(hextoutf8(I));
+ s === "2b06010505073002" && B.caissuer.push(hextoutf8(I));
+ }
+
+ return B;
+ };
+
+ this.getExtCertificatePolicies = function () {
+ var R = this.getExtInfo("certificatePolicies");
+ if (R === undefined) return R;
+ var B = L(this.hex, R.vidx);
+ var F = [];
+ var E = n(B, 0);
+
+ for (var I = 0; I < E.length; I++) {
+ var K = {};
+ var T = n(B, E[I]);
+ K.id = V(A(B, T[0]));
+
+ if (T.length === 2) {
+ var Z = n(B, T[1]);
+
+ for (var w = 0; w < Z.length; w++) {
+ var M = S(B, Z[w], [0], "06");
+
+ if (M === "2b06010505070201") {
+ K.cps = hextoutf8(S(B, Z[w], [1]));
+ } else {
+ if (M === "2b06010505070202") {
+ K.unotice = hextoutf8(S(B, Z[w], [1, 0]));
+ }
+ }
+ }
+ }
+
+ F.push(K);
+ }
+
+ return F;
+ };
+
+ this.readCertPEM = function (R) {
+ this.readCertHex(l(R));
+ };
+
+ this.readCertHex = function (R) {
+ this.hex = R;
+ this.getVersion();
+
+ try {
+ J(this.hex, 0, [0, 7], "a3");
+ this.parseExt();
+ } catch (B) {
+ console.log(B);
+ }
+ };
+
+ this.getInfo = function () {
+ var R = X509;
+ var F;
+ var E;
+ var s;
+ F = "Basic Fields\n";
+ F += " serial number: " + this.getSerialNumberHex() + "\n";
+ F += " signature algorithm: " + this.getSignatureAlgorithmField() + "\n";
+ F += " issuer: " + this.getIssuerString() + "\n";
+ F += " notBefore: " + this.getNotBefore() + "\n";
+ F += " notAfter: " + this.getNotAfter() + "\n";
+ F += " subject: " + this.getSubjectString() + "\n";
+ F += " subject public key info: \n";
+ E = this.getPublicKey();
+ F += " key algorithm: " + E.type + "\n";
+
+ if (E.type === "RSA") {
+ F += " n=" + hextoposhex(E.n.toString(16)).substr(0, 16) + "...\n";
+ F += " e=" + hextoposhex(E.e.toString(16)) + "\n";
+ }
+
+ s = this.aExtInfo;
+
+ if (s !== undefined && s !== null) {
+ F += "X509v3 Extensions:\n";
+
+ for (var I = 0; I < s.length; I++) {
+ var K = s[I];
+ var T = KJUR.asn1.x509.OID.oid2name(K.oid);
+
+ if (T === "") {
+ T = K.oid;
+ }
+
+ var Z = "";
+
+ if (K.critical === !![]) {
+ Z = "CRITICAL";
+ }
+
+ F += " " + T + " " + Z + ":\n";
+
+ if (T === "basicConstraints") {
+ var M = this.getExtBasicConstraints();
+
+ if (M.cA === undefined) {
+ F += " {}\n";
+ } else {
+ F += " cA=true";
+ M.pathLen !== undefined && (F += ", pathLen=" + M.pathLen);
+ F += "\n";
+ }
+ } else {
+ if (T === "keyUsage") F += " " + this.getExtKeyUsageString() + "\n";else {
+ if (T === "subjectKeyIdentifier") F += " " + this.getExtSubjectKeyIdentifier() + "\n";else {
+ if (T === "authorityKeyIdentifier") {
+ var U = this.getExtAuthorityKeyIdentifier();
+
+ if (U.kid !== undefined) {
+ F += " kid=" + U.kid + "\n";
+ }
+ } else {
+ if (T === "extKeyUsage") {
+ var H = this.getExtExtKeyUsageName();
+ F += " " + H.join(", ") + "\n";
+ } else {
+ if (T === "subjectAltName") {
+ var O = this.getExtSubjectAltName2();
+ F += " " + O + "\n";
+ } else {
+ if (T === "cRLDistributionPoints") {
+ var X = this.getExtCRLDistributionPointsURI();
+ F += " " + X + "\n";
+ } else {
+ if (T === "authorityInfoAccess") {
+ var G = this.getExtAIAInfo();
+ G.ocsp !== undefined && (F += " ocsp: " + G.ocsp.join(",") + "\n");
+ G.caissuer !== undefined && (F += " caissuer: " + G.caissuer.join(",") + "\n");
+ } else {
+ if (T === "certificatePolicies") {
+ var N = this.getExtCertificatePolicies();
+
+ for (var D = 0; D < N.length; D++) {
+ N[D].id !== undefined && (F += " policy oid: " + N[D].id + "\n");
+ N[D].cps !== undefined && (F += " cps: " + N[D].cps + "\n");
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return F += "signature algorithm: " + this.getSignatureAlgorithmName() + "\n", F += "signature: " + this.getSignatureValueHex().substr(0, 16) + "...\n", F;
+ };
+}
+
+X509.hex2dn = function (p, n) {
+ if (n === undefined) {
+ n = 0;
+ }
+
+ if (p.substr(n, 2) !== "30") throw "malformed DN";
+ var a = new Array();
+ var A = ASN1HEX.getChildIdx(p, n);
+
+ for (var L = 0; L < A.length; L++) {
+ a.push(X509.hex2rdn(p, A[L]));
+ }
+
+ return a = a.map(function (g) {
+ return g.replace("/", "\\/");
+ }), "/" + a.join("/");
+};
+
+X509.hex2rdn = function (p, n) {
+ if (n === undefined) {
+ n = 0;
+ }
+
+ if (p.substr(n, 2) !== "31") throw "malformed RDN";
+ var a = new Array();
+ var A = ASN1HEX.getChildIdx(p, n);
+
+ for (var L = 0; L < A.length; L++) {
+ a.push(X509.hex2attrTypeValue(p, A[L]));
+ }
+
+ return a = a.map(function (g) {
+ return g.replace("+", "\\+");
+ }), a.join("+");
+};
+
+X509.hex2attrTypeValue = function (p, n) {
+ var A = ASN1HEX;
+ var L = A.getV;
+
+ if (n === undefined) {
+ n = 0;
+ }
+
+ if (p.substr(n, 2) !== "30") throw "malformed attribute type and value";
+ var S = A.getChildIdx(p, n);
+
+ if (S.length !== 2 || p.substr(S[0], 2) !== "06") {
+ "malformed attribute type and value";
+ }
+
+ var Y = L(p, S[0]);
+ var J = KJUR.asn1.ASN1Util.oidHexToInt(Y);
+ var C = KJUR.asn1.x509.OID.oid2atype(J);
+ var V = L(p, S[1]);
+ var W = hextorstr(V);
+ return C + "=" + W;
+};
+
+X509.getPublicKeyFromCertHex = function (p) {
+ var n = new X509();
+ return n.readCertHex(p), n.getPublicKey();
+};
+
+X509.getPublicKeyFromCertPEM = function (p) {
+ var n = new X509();
+ return n.readCertPEM(p), n.getPublicKey();
+};
+
+X509.getPublicKeyInfoPropOfCertPEM = function (p) {
+ var n = ASN1HEX;
+ var A = n.getVbyList;
+ var L = {};
+ var S;
+ var Y;
+ var J;
+ return L.algparam = null, S = new X509(), S.readCertPEM(p), Y = S.getPublicKeyHex(), L.keyhex = A(Y, 0, [1], "03").substr(2), L.algoid = A(Y, 0, [0, 0], "06"), L.algoid === "2a8648ce3d0201" && (L.algparam = A(Y, 0, [0, 1], "06")), L;
+};
+
+X509.KEYUSAGE_NAME = ["digitalSignature", "nonRepudiation", "keyEncipherment", "dataEncipherment", "keyAgreement", "keyCertSign", "cRLSign", "encipherOnly", "decipherOnly"];
+
+if (typeof KJUR == "undefined" || !KJUR) {
+ KJUR = {};
+}
+
+if (typeof KJUR.jws == "undefined" || !KJUR.jws) {
+ KJUR.jws = {};
+}
+
+KJUR.jws.JWS = function () {
+ var p = KJUR;
+ var n = p.jws.JWS;
+ var A = n.isSafeJSONString;
+
+ this.parseJWS = function (L, S) {
+ if (this.parsedJWS !== undefined && (S || this.parsedJWS.sigvalH !== undefined)) return;
+ var Y = L.match(/^([^.]+)\.([^.]+)\.([^.]+)$/);
+ if (Y == null) throw "JWS signature is not a form of 'Head.Payload.SigValue'.";
+ var J = Y[1];
+ var C = Y[2];
+ var V = Y[3];
+ var W = J + "." + C;
+ this.parsedJWS = {};
+ this.parsedJWS.headB64U = J;
+ this.parsedJWS.payloadB64U = C;
+ this.parsedJWS.sigvalB64U = V;
+ this.parsedJWS.si = W;
+
+ if (!S) {
+ var R = b64utohex(V);
+ var B = parseBigInt(R, 16);
+ this.parsedJWS.sigvalH = R;
+ this.parsedJWS.sigvalBI = B;
+ }
+
+ var F = b64utoutf8(J);
+ var E = b64utoutf8(C);
+ this.parsedJWS.headS = F;
+ this.parsedJWS.payloadS = E;
+ if (!A(F, this.parsedJWS, "headP")) throw "malformed JSON string for JWS Head: " + F;
+ };
+};
+
+KJUR.jws.JWS.sign = function (L, S, Y, J, C) {
+ var V = KJUR;
+ var W = V.jws;
+ var R = W.JWS;
+ var B = R.readSafeJSONString;
+ var F = R.isSafeJSONString;
+ var E = V.crypto;
+ var I = E.ECDSA;
+ var K = E.Mac;
+ var T = E.Signature;
+ var Z = JSON;
+ var M;
+ var U;
+ var H;
+ if (typeof S != "string" && typeof S != "object") throw "spHeader must be JSON string or object: " + S;
+
+ if (typeof S == "object") {
+ U = S;
+ M = Z.stringify(U);
+ }
+
+ if (typeof S == "string") {
+ M = S;
+ if (!F(M)) throw "JWS Head is not safe JSON string: " + M;
+ U = B(M);
+ }
+
+ H = Y;
+
+ if (typeof Y == "object") {
+ H = Z.stringify(Y);
+ }
+
+ if ((L == "" || L == null) && U.alg !== undefined) {
+ L = U.alg;
+ }
+
+ if (L != "" && L != null && U.alg === undefined) {
+ U.alg = L;
+ M = Z.stringify(U);
+ }
+
+ if (L !== U.alg) throw "alg and sHeader.alg doesn't match: " + L + "!=" + U.alg;
+ var O = null;
+ if (R.jwsalg2sigalg[L] === undefined) throw "unsupported alg name: " + L;else O = R.jwsalg2sigalg[L];
+ var X = utf8tob64u(M);
+ var G = utf8tob64u(H);
+ var N = X + "." + G;
+ var D = "";
+
+ if (O.substr(0, 4) == "Hmac") {
+ if (J === undefined) throw "mac key shall be specified for HS* alg";
+ var Q = new K({
+ "alg": O,
+ "prov": "cryptojs",
+ "pass": J
+ });
+ Q.updateString(N);
+ D = Q.doFinal();
+ } else {
+ if (O.indexOf("withECDSA") != -1) {
+ var P = new T({
+ "alg": O
+ });
+ P.init(J, C);
+ P.updateString(N);
+ var p0 = P.sign();
+ D = KJUR.crypto.ECDSA.asn1SigToConcatSig(p0);
+ } else {
+ if (O != "none") {
+ var P = new T({
+ "alg": O
+ });
+ P.init(J, C);
+ P.updateString(N);
+ D = P.sign();
+ }
+ }
+ }
+
+ var p1 = hextob64u(D);
+ return N + "." + p1;
+};
+
+KJUR.jws.JWS.verify = function (a, L, S) {
+ var Y = KJUR;
+ var J = Y.jws;
+ var C = J.JWS;
+ var V = C.readSafeJSONString;
+ var W = Y.crypto;
+ var R = W.ECDSA;
+ var F = W.Mac;
+ var E = W.Signature;
+ var I;
+
+ if (typeof RSAKey !== undefined) {
+ I = RSAKey;
+ }
+
+ var K = a.split(".");
+ if (K.length !== 3) return ![];
+ var T = K[0];
+ var Z = K[1];
+ var M = T + "." + Z;
+ var U = b64utohex(K[2]);
+ var H = V(b64utoutf8(K[0]));
+ var O = null;
+ var X = null;
+ if (H.alg === undefined) throw "algorithm not specified in header";else {
+ O = H.alg;
+ X = O.substr(0, 2);
+ }
+
+ if (S != null && Object.prototype.toString.call(S) === "[object Array]" && S.length > 0) {
+ var G = ":" + S.join(":") + ":";
+ if (G.indexOf(":" + O + ":") == -1) throw "algorithm '" + O + "' not accepted in the list";
+ }
+
+ if (O != "none" && L === null) throw "key shall be specified to verify.";
+
+ if (typeof L == "string" && L.indexOf("-----BEGIN ") != -1) {
+ L = KEYUTIL.getKey(L);
+ }
+
+ if (X == "RS" || X == "PS") {
+ if (!(L instanceof I)) throw "key shall be a RSAKey obj for RS* and PS* algs";
+ }
+
+ if (X == "ES") {
+ if (!(L instanceof R)) throw "key shall be a ECDSA obj for ES* algs";
+ }
+
+ if (O == "none") {}
+
+ var N = null;
+ if (C.jwsalg2sigalg[H.alg] === undefined) throw "unsupported alg name: " + O;else N = C.jwsalg2sigalg[O];
+ if (N == "none") throw "not supported";else {
+ if (N.substr(0, 4) == "Hmac") {
+ var D = null;
+ if (L === undefined) throw "hexadecimal key shall be specified for HMAC";
+ var Q = new F({
+ "alg": N,
+ "pass": L
+ });
+ return Q.updateString(M), D = Q.doFinal(), U == D;
+ } else {
+ if (N.indexOf("withECDSA") != -1) {
+ var P = null;
+
+ try {
+ P = R.concatSigToASN1Sig(U);
+ } catch (p1) {
+ console.log(p1);
+ return ![];
+ }
+
+ var p0 = new E({
+ "alg": N
+ });
+ return p0.init(L), p0.updateString(M), p0.verify(P);
+ } else {
+ var p0 = new E({
+ "alg": N
+ });
+ return p0.init(L), p0.updateString(M), p0.verify(U);
+ }
+ }
+ }
+};
+
+KJUR.jws.JWS.parse = function (p) {
+ var n = p.split(".");
+ var a = {};
+ var A;
+ var L;
+ var S;
+ if (n.length != 2 && n.length != 3) throw "malformed sJWS: wrong number of '.' splitted elements";
+ return A = n[0], L = n[1], n.length == 3 && (S = n[2]), a.headerObj = KJUR.jws.JWS.readSafeJSONString(b64utoutf8(A)), a.payloadObj = KJUR.jws.JWS.readSafeJSONString(b64utoutf8(L)), a.headerPP = JSON.stringify(a.headerObj, null, " "), a.payloadObj == null ? a.payloadPP = b64utoutf8(L) : a.payloadPP = JSON.stringify(a.payloadObj, null, " "), S !== undefined && (a.sigHex = b64utohex(S)), a;
+};
+
+KJUR.jws.JWS.verifyJWT = function (a, A, L) {
+ var S = KJUR;
+ var Y = S.jws;
+ var J = Y.JWS;
+ var C = J.readSafeJSONString;
+ var V = J.inArray;
+ var W = J.includedArray;
+ var R = a.split(".");
+ var B = R[0];
+ var F = R[1];
+ var E = B + "." + F;
+ var s = b64utohex(R[2]);
+ var I = C(b64utoutf8(B));
+ var K = C(b64utoutf8(F));
+ if (I.alg === undefined) return ![];
+ if (L.alg === undefined) throw "acceptField.alg shall be specified";
+ if (!V(I.alg, L.alg)) return ![];
+
+ if (K.iss !== undefined && typeof L.iss === "object") {
+ if (!V(K.iss, L.iss)) return ![];
+ }
+
+ if (K.sub !== undefined && typeof L.sub === "object") {
+ if (!V(K.sub, L.sub)) return ![];
+ }
+
+ if (K.aud !== undefined && typeof L.aud === "object") {
+ if (typeof K.aud == "string") {
+ if (!V(K.aud, L.aud)) return ![];
+ } else {
+ if (typeof K.aud == "object") {
+ if (!W(K.aud, L.aud)) return ![];
+ }
+ }
+ }
+
+ var T = Y.IntDate.getNow();
+
+ if (L.verifyAt !== undefined && typeof L.verifyAt === "number") {
+ T = L.verifyAt;
+ }
+
+ if (L.gracePeriod === undefined || typeof L.gracePeriod !== "number") {
+ L.gracePeriod = 0;
+ }
+
+ if (K.exp !== undefined && typeof K.exp == "number") {
+ if (K.exp + L.gracePeriod < T) return ![];
+ }
+
+ if (K.nbf !== undefined && typeof K.nbf == "number") {
+ if (T < K.nbf - L.gracePeriod) return ![];
+ }
+
+ if (K.iat !== undefined && typeof K.iat == "number") {
+ if (T < K.iat - L.gracePeriod) return ![];
+ }
+
+ if (K.jti !== undefined && L.jti !== undefined) {
+ if (K.jti !== L.jti) return ![];
+ }
+
+ if (!J.verify(a, A, L.alg)) return ![];
+ return !![];
+};
+
+KJUR.jws.JWS.includedArray = function (p, n) {
+ var A = KJUR.jws.JWS.inArray;
+ if (p === null) return ![];
+ if (typeof p !== "object") return ![];
+ if (typeof p.length !== "number") return ![];
+
+ for (var L = 0; L < p.length; L++) {
+ if (!A(p[L], n)) return ![];
+ }
+
+ return !![];
+};
+
+KJUR.jws.JWS.inArray = function (p, n) {
+ if (n === null) return ![];
+ if (typeof n !== "object") return ![];
+ if (typeof n.length !== "number") return ![];
+
+ for (var a = 0; a < n.length; a++) {
+ if (n[a] == p) return !![];
+ }
+
+ return ![];
+};
+
+KJUR.jws.JWS.jwsalg2sigalg = {
+ "HS256": "HmacSHA256",
+ "HS384": "HmacSHA384",
+ "HS512": "HmacSHA512",
+ "RS256": "SHA256withRSA",
+ "RS384": "SHA384withRSA",
+ "RS512": "SHA512withRSA",
+ "ES256": "SHA256withECDSA",
+ "ES384": "SHA384withECDSA",
+ "PS256": "SHA256withRSAandMGF1",
+ "PS384": "SHA384withRSAandMGF1",
+ "PS512": "SHA512withRSAandMGF1",
+ "none": "none"
+};
+
+KJUR.jws.JWS.isSafeJSONString = function (p, n, A) {
+ var L = null;
+
+ try {
+ L = jsonParse(p);
+ if (typeof L != "object") return 0;
+ if (L.constructor === Array) return 0;
+ return n && (n[A] = L), 1;
+ } catch (g) {
+ console.log(g);
+ return 0;
+ }
+};
+
+KJUR.jws.JWS.readSafeJSONString = function (p) {
+ var n = null;
+
+ try {
+ n = jsonParse(p);
+ if (typeof n != "object") return null;
+ if (n.constructor === Array) return null;
+ return n;
+ } catch (A) {
+ console.log(A);
+ return null;
+ }
+};
+
+KJUR.jws.JWS.getEncodedSignatureValueFromJWS = function (p) {
+ var n = p.match(/^[^.]+\.[^.]+\.([^.]+)$/);
+ if (n == null) throw "JWS signature is not a form of 'Head.Payload.SigValue'.";
+ return n[1];
+};
+
+KJUR.jws.JWS.getJWKthumbprint = function (p) {
+ if (p.kty !== "RSA" && p.kty !== "EC" && p.kty !== "oct") throw "unsupported algorithm for JWK Thumprint";
+ var n = "{";
+
+ if (p.kty === "RSA") {
+ if (typeof p.n != "string" || typeof p.e != "string") throw "wrong n and e value for RSA key";
+ n += "\"e\":\"" + p.e + "\",";
+ n += "\"kty\":\"" + p.kty + "\",";
+ n += "\"n\":\"" + p.n + "\"}";
+ } else {
+ if (p.kty === "EC") {
+ if (typeof p.crv != "string" || typeof p.x != "string" || typeof p.y != "string") throw "wrong crv, x and y value for EC key";
+ n += "\"crv\":\"" + p.crv + "\",";
+ n += "\"kty\":\"" + p.kty + "\",";
+ n += "\"x\":\"" + p.x + "\",";
+ n += "\"y\":\"" + p.y + "\"}";
+ } else {
+ if (p.kty === "oct") {
+ if (typeof p.k != "string") throw "wrong k value for oct(symmetric) key";
+ n += "\"kty\":\"" + p.kty + "\",";
+ n += "\"k\":\"" + p.k + "\"}";
+ }
+ }
+ }
+
+ var A = rstrtohex(n);
+ var L = KJUR.crypto.Util.hashHex(A, "sha256");
+ var g = hextob64u(L);
+ return g;
+};
+
+KJUR.jws.IntDate = {};
+
+KJUR.jws.IntDate.get = function (p) {
+ var n = KJUR.jws.IntDate;
+ var A = n.getNow;
+ var L = n.getZulu;
+ if (p == "now") return A();else {
+ if (p == "now + 1hour") return A() + 3600;else {
+ if (p == "now + 1day") return A() + 86400;else {
+ if (p == "now + 1month") return A() + 2592000;else {
+ if (p == "now + 1year") return A() + 31536000;else {
+ if (p.match(/Z$/)) return L(p);else {
+ if (p.match(/^[0-9]+$/)) return parseInt(p);
+ }
+ }
+ }
+ }
+ }
+ }
+ throw "unsupported format: " + p;
+};
+
+KJUR.jws.IntDate.getZulu = function (p) {
+ return zulutosec(p);
+};
+
+KJUR.jws.IntDate.getNow = function () {
+ var p = ~~(new Date() / 1000);
+ return p;
+};
+
+KJUR.jws.IntDate.intDate2UTCString = function (p) {
+ var n = new Date(p * 1000);
+ return n.toUTCString();
+};
+
+KJUR.jws.IntDate.intDate2Zulu = function (p) {
+ var n = new Date(p * 1000);
+ var A = ("0000" + n.getUTCFullYear()).slice(-4);
+ var L = ("00" + (n.getUTCMonth() + 1)).slice(-2);
+ var S = ("00" + n.getUTCDate()).slice(-2);
+ var Y = ("00" + n.getUTCHours()).slice(-2);
+ var J = ("00" + n.getUTCMinutes()).slice(-2);
+ var C = ("00" + n.getUTCSeconds()).slice(-2);
+ return A + L + S + Y + J + C + "Z";
+};
+
+if (typeof KJUR == "undefined" || !KJUR) {
+ KJUR = {};
+}
+
+if (typeof KJUR.jws == "undefined" || !KJUR.jws) {
+ KJUR.jws = {};
+}
+
+KJUR.jws.JWSJS = function () {
+ var p = KJUR;
+ var n = p.jws;
+ var A = n.JWS;
+ var L = A.readSafeJSONString;
+ this.aHeader = [];
+ this.sPayload = "";
+ this.aSignature = [];
+
+ this.init = function () {
+ this.aHeader = [];
+ this.sPayload = undefined;
+ this.aSignature = [];
+ };
+
+ this.initWithJWS = function (g) {
+ this.init();
+ var S = g.split(".");
+ if (S.length != 3) throw "malformed input JWS";
+ this.aHeader.push(S[0]);
+ this.sPayload = S[1];
+ this.aSignature.push(S[2]);
+ };
+
+ this.addSignature = function (S, Y, J, C) {
+ if (this.sPayload === undefined || this.sPayload === null) throw "there's no JSON-JS signature to add.";
+ var V = this.aHeader.length;
+ if (this.aHeader.length != this.aSignature.length) throw "aHeader.length != aSignature.length";
+
+ try {
+ var W = KJUR.jws.JWS.sign(S, Y, this.sPayload, J, C);
+ var R = W.split(".");
+ var B = R[0];
+ var F = R[2];
+ this.aHeader.push(R[0]);
+ this.aSignature.push(R[2]);
+ } catch (E) {
+ console.log(E);
+
+ if (this.aHeader.length > V) {
+ this.aHeader.pop();
+ }
+
+ if (this.aSignature.length > V) {
+ this.aSignature.pop();
+ }
+
+ throw "addSignature failed: " + E;
+ }
+ };
+
+ this.verifyAll = function (S) {
+ if (this.aHeader.length !== S.length || this.aSignature.length !== S.length) return ![];
+
+ for (var Y = 0; Y < S.length; Y++) {
+ var J = S[Y];
+ if (J.length !== 2) return ![];
+ var C = this.verifyNth(Y, J[0], J[1]);
+ if (C === ![]) return ![];
+ }
+
+ return !![];
+ };
+
+ this.verifyNth = function (S, Y, J) {
+ if (this.aHeader.length <= S || this.aSignature.length <= S) return ![];
+ var C = this.aHeader[S];
+ var V = this.aSignature[S];
+ var W = C + "." + this.sPayload + "." + V;
+ var R = ![];
+
+ try {
+ R = A.verify(W, Y, J);
+ } catch (B) {
+ console.log(B);
+ return ![];
+ }
+
+ return R;
+ };
+
+ this.readJWSJS = function (S) {
+ if (typeof S === "string") {
+ var Y = L(S);
+ if (Y == null) throw "argument is not safe JSON object string";
+ this.aHeader = Y.headers;
+ this.sPayload = Y.payload;
+ this.aSignature = Y.signatures;
+ } else try {
+ if (S.headers.length > 0) this.aHeader = S.headers;else throw "malformed header";
+ if (typeof S.payload === "string") this.sPayload = S.payload;else throw "malformed signatures";
+ if (S.signatures.length > 0) this.aSignature = S.signatures;else throw "malformed signatures";
+ } catch (J) {
+ console.log(J);
+ throw "malformed JWS-JS JSON object: " + J;
+ }
+ };
+
+ this.getJSON = function () {
+ return {
+ "headers": this.aHeader,
+ "payload": this.sPayload,
+ "signatures": this.aSignature
+ };
+ };
+
+ this.isEmpty = function () {
+ if (this.aHeader.length == 0) return 1;
+ return 0;
+ };
+};
+
+var url = "/api/challenge56";
+
+call = function (p) {
+ var n = {
+ "page": String(p)
+ };
+ $.ajax({
+ "url": url,
+ "dataType": "json",
+ "async": !![],
+ "data": n,
+ "type": "POST",
+ "beforeSend": function (c) {
+ (function () {})();
+ },
+ "success": function (c) {
+ var a = "";
+ var A = new JSEncrypt();
+ A.setPrivateKey(PVA.toString("ascii"));
+ datas = JSON.parse(A.decrypt(c.result)).data;
+ $.each(datas, function (L, g) {
+ var S = "| " + g.value + " | ";
+ a += S;
+ });
+ $(".data").text("").append(a + "
");
+ },
+ "complete": function () {
+ $("#page").paging({
+ "nowPage": p,
+ "pageNum": 100,
+ "buttonNum": 7,
+ "canJump": 1,
+ "showOne": 1,
+ "callback": function (c) {
+ call(c);
+ }
+ });
+ },
+ "error": function () {
+ alert("检测到异常情况，请关闭抓包工具，使用chrome浏览器再试试");
+ location.reload();
+ }
+ });
+};
+
+call(1);
\ No newline at end of file
diff --git a/猿人学练习/56js加密经典入门数据加密-RSA/main.py b/猿人学练习/56js加密经典入门数据加密-RSA/main.py
index 2a085d5..4a17d59 100644
--- a/猿人学练习/56js加密经典入门数据加密-RSA/main.py
+++ b/猿人学练习/56js加密经典入门数据加密-RSA/main.py
@@ -1,9 +1,17 @@
import json
+
+from rsa_encrypt import RsaUtil
import requests
-def challenge59(page):
- url = "https://www.python-spider.com/api/challenge59"
+def decrypt_res(response_json):
+ rsa = RsaUtil()
+ decrypt_result = rsa.decrypt_by_private_key(response_json.get('result'))
+ return decrypt_result
+
+
+def challenge56(page):
+ url = "https://www.python-spider.com/api/challenge56"
payload = f"page={page}"
session = requests.session()
headers = {
@@ -11,18 +19,15 @@ def challenge59(page):
}
session.headers = headers
response = session.request("POST", url, data=payload)
- return response.text
+ return response.json()
def run():
data_num = 0
for page in range(1, 101):
- res_dict = json.loads(challenge59(page))
- data_list = res_dict.get('data')
-
- if page == 51:
- data_list[0]['value'] = '5734\r'
-
+ response_json = challenge56(page)
+ decrypt_result = decrypt_res(response_json)
+ data_list = json.loads(decrypt_result).get('data')
data_list_num = []
for data in data_list:
data_list_num.append(int(data.get('value')))
diff --git a/猿人学练习/56js加密经典入门数据加密-RSA/readme.md b/猿人学练习/56js加密经典入门数据加密-RSA/readme.md
index e69de29..0a50d96 100644
--- a/猿人学练习/56js加密经典入门数据加密-RSA/readme.md
+++ b/猿人学练习/56js加密经典入门数据加密-RSA/readme.md
@@ -0,0 +1,21 @@
+# 知识点： RSA加密
+
+## 解题思路
+
+RSA是非对称加密算法，非对称加密算法指的是加密和解密使用不同的密钥，除了加解密的作用，还有“签名”的作用。通常来说非对称加密比对称加密要耗时间。
+
+查看请求返回内容，发现结果加密
+
+
+
+由于此题已经说明是RSA加密，这里搜索解密关键词`setPrivateKey`
+
+
+
+发现`A.setPrivateKey(PVA.toString("ascii"))`;就是设置了私钥
+
+控制台直接打印出私钥
+
+
+
+私钥已经找到了，解密就是写代码的时间问题了
\ No newline at end of file
diff --git a/猿人学练习/56js加密经典入门数据加密-RSA/rsa_encrypt.py b/猿人学练习/56js加密经典入门数据加密-RSA/rsa_encrypt.py
index 5a79eab..c5f7e3e 100644
--- a/猿人学练习/56js加密经典入门数据加密-RSA/rsa_encrypt.py
+++ b/猿人学练习/56js加密经典入门数据加密-RSA/rsa_encrypt.py
@@ -12,8 +12,8 @@ class RsaUtil(object):
company_pub_file=PUBLIC_KEY_PATH,
company_pri_file=PRIVATE_KEY_PATH):
- if company_pub_file:
- self.company_public_key = rsa.PublicKey.load_pkcs1_openssl_pem(open(company_pub_file).read())
+ # if company_pub_file:
+ # self.company_public_key = rsa.PublicKey.load_pkcs1_openssl_pem(open(company_pub_file).read())
if company_pri_file:
self.company_private_key = rsa.PrivateKey.load_pkcs1(open(company_pri_file).read())