>= this.DB;
2135 | }
2136 | if (a.t < this.t) {
2137 | c += a.s;
2138 | while (i < this.t) {
2139 | c += this[i];
2140 | r[i++] = c & this.DM;
2141 | c >>= this.DB;
2142 | }
2143 | c += this.s;
2144 | }
2145 | else {
2146 | c += this.s;
2147 | while (i < a.t) {
2148 | c += a[i];
2149 | r[i++] = c & this.DM;
2150 | c >>= this.DB;
2151 | }
2152 | c += a.s;
2153 | }
2154 | r.s = (c < 0) ? -1 : 0;
2155 | if (c > 0) {
2156 | r[i++] = c;
2157 | }
2158 | else if (c < -1) {
2159 | r[i++] = this.DV + c;
2160 | }
2161 | r.t = i;
2162 | r.clamp();
2163 | };
2164 | // BigInteger.prototype.dMultiply = bnpDMultiply;
2165 | // (protected) this *= n, this >= 0, 1 < n < DV
2166 | BigInteger.prototype.dMultiply = function (n) {
2167 | this[this.t] = this.am(0, n - 1, this, 0, 0, this.t);
2168 | ++this.t;
2169 | this.clamp();
2170 | };
2171 | // BigInteger.prototype.dAddOffset = bnpDAddOffset;
2172 | // (protected) this += n << w words, this >= 0
2173 | BigInteger.prototype.dAddOffset = function (n, w) {
2174 | if (n == 0) {
2175 | return;
2176 | }
2177 | while (this.t <= w) {
2178 | this[this.t++] = 0;
2179 | }
2180 | this[w] += n;
2181 | while (this[w] >= this.DV) {
2182 | this[w] -= this.DV;
2183 | if (++w >= this.t) {
2184 | this[this.t++] = 0;
2185 | }
2186 | ++this[w];
2187 | }
2188 | };
2189 | // BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo;
2190 | // (protected) r = lower n words of "this * a", a.t <= n
2191 | // "this" should be the larger one if appropriate.
2192 | BigInteger.prototype.multiplyLowerTo = function (a, n, r) {
2193 | var i = Math.min(this.t + a.t, n);
2194 | r.s = 0; // assumes a,this >= 0
2195 | r.t = i;
2196 | while (i > 0) {
2197 | r[--i] = 0;
2198 | }
2199 | for (var j = r.t - this.t; i < j; ++i) {
2200 | r[i + this.t] = this.am(0, a[i], r, i, 0, this.t);
2201 | }
2202 | for (var j = Math.min(a.t, n); i < j; ++i) {
2203 | this.am(0, a[i], r, i, 0, n - i);
2204 | }
2205 | r.clamp();
2206 | };
2207 | // BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo;
2208 | // (protected) r = "this * a" without lower n words, n > 0
2209 | // "this" should be the larger one if appropriate.
2210 | BigInteger.prototype.multiplyUpperTo = function (a, n, r) {
2211 | --n;
2212 | var i = r.t = this.t + a.t - n;
2213 | r.s = 0; // assumes a,this >= 0
2214 | while (--i >= 0) {
2215 | r[i] = 0;
2216 | }
2217 | for (i = Math.max(n - this.t, 0); i < a.t; ++i) {
2218 | r[this.t + i - n] = this.am(n - i, a[i], r, 0, 0, this.t + i - n);
2219 | }
2220 | r.clamp();
2221 | r.drShiftTo(1, r);
2222 | };
2223 | // BigInteger.prototype.modInt = bnpModInt;
2224 | // (protected) this % n, n < 2^26
2225 | BigInteger.prototype.modInt = function (n) {
2226 | if (n <= 0) {
2227 | return 0;
2228 | }
2229 | var d = this.DV % n;
2230 | var r = (this.s < 0) ? n - 1 : 0;
2231 | if (this.t > 0) {
2232 | if (d == 0) {
2233 | r = this[0] % n;
2234 | }
2235 | else {
2236 | for (var i = this.t - 1; i >= 0; --i) {
2237 | r = (d * r + this[i]) % n;
2238 | }
2239 | }
2240 | }
2241 | return r;
2242 | };
2243 | // BigInteger.prototype.millerRabin = bnpMillerRabin;
2244 | // (protected) true if probably prime (HAC 4.24, Miller-Rabin)
2245 | BigInteger.prototype.millerRabin = function (t) {
2246 | var n1 = this.subtract(BigInteger.ONE);
2247 | var k = n1.getLowestSetBit();
2248 | if (k <= 0) {
2249 | return false;
2250 | }
2251 | var r = n1.shiftRight(k);
2252 | t = (t + 1) >> 1;
2253 | if (t > lowprimes.length) {
2254 | t = lowprimes.length;
2255 | }
2256 | var a = nbi();
2257 | for (var i = 0; i < t; ++i) {
2258 | // Pick bases at random, instead of starting at 2
2259 | a.fromInt(lowprimes[Math.floor(Math.random() * lowprimes.length)]);
2260 | var y = a.modPow(r, this);
2261 | if (y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {
2262 | var j = 1;
2263 | while (j++ < k && y.compareTo(n1) != 0) {
2264 | y = y.modPowInt(2, this);
2265 | if (y.compareTo(BigInteger.ONE) == 0) {
2266 | return false;
2267 | }
2268 | }
2269 | if (y.compareTo(n1) != 0) {
2270 | return false;
2271 | }
2272 | }
2273 | }
2274 | return true;
2275 | };
2276 | // BigInteger.prototype.square = bnSquare;
2277 | // (public) this^2
2278 | BigInteger.prototype.square = function () {
2279 | var r = nbi();
2280 | this.squareTo(r);
2281 | return r;
2282 | };
2283 | //#region ASYNC
2284 | // Public API method
2285 | BigInteger.prototype.gcda = function (a, callback) {
2286 | var x = (this.s < 0) ? this.negate() : this.clone();
2287 | var y = (a.s < 0) ? a.negate() : a.clone();
2288 | if (x.compareTo(y) < 0) {
2289 | var t = x;
2290 | x = y;
2291 | y = t;
2292 | }
2293 | var i = x.getLowestSetBit();
2294 | var g = y.getLowestSetBit();
2295 | if (g < 0) {
2296 | callback(x);
2297 | return;
2298 | }
2299 | if (i < g) {
2300 | g = i;
2301 | }
2302 | if (g > 0) {
2303 | x.rShiftTo(g, x);
2304 | y.rShiftTo(g, y);
2305 | }
2306 | // Workhorse of the algorithm, gets called 200 - 800 times per 512 bit keygen.
2307 | var gcda1 = function () {
2308 | if ((i = x.getLowestSetBit()) > 0) {
2309 | x.rShiftTo(i, x);
2310 | }
2311 | if ((i = y.getLowestSetBit()) > 0) {
2312 | y.rShiftTo(i, y);
2313 | }
2314 | if (x.compareTo(y) >= 0) {
2315 | x.subTo(y, x);
2316 | x.rShiftTo(1, x);
2317 | }
2318 | else {
2319 | y.subTo(x, y);
2320 | y.rShiftTo(1, y);
2321 | }
2322 | if (!(x.signum() > 0)) {
2323 | if (g > 0) {
2324 | y.lShiftTo(g, y);
2325 | }
2326 | setTimeout(function () { callback(y); }, 0); // escape
2327 | }
2328 | else {
2329 | setTimeout(gcda1, 0);
2330 | }
2331 | };
2332 | setTimeout(gcda1, 10);
2333 | };
2334 | // (protected) alternate constructor
2335 | BigInteger.prototype.fromNumberAsync = function (a, b, c, callback) {
2336 | if ("number" == typeof b) {
2337 | if (a < 2) {
2338 | this.fromInt(1);
2339 | }
2340 | else {
2341 | this.fromNumber(a, c);
2342 | if (!this.testBit(a - 1)) {
2343 | this.bitwiseTo(BigInteger.ONE.shiftLeft(a - 1), op_or, this);
2344 | }
2345 | if (this.isEven()) {
2346 | this.dAddOffset(1, 0);
2347 | }
2348 | var bnp_1 = this;
2349 | var bnpfn1_1 = function () {
2350 | bnp_1.dAddOffset(2, 0);
2351 | if (bnp_1.bitLength() > a) {
2352 | bnp_1.subTo(BigInteger.ONE.shiftLeft(a - 1), bnp_1);
2353 | }
2354 | if (bnp_1.isProbablePrime(b)) {
2355 | setTimeout(function () { callback(); }, 0); // escape
2356 | }
2357 | else {
2358 | setTimeout(bnpfn1_1, 0);
2359 | }
2360 | };
2361 | setTimeout(bnpfn1_1, 0);
2362 | }
2363 | }
2364 | else {
2365 | var x = [];
2366 | var t = a & 7;
2367 | x.length = (a >> 3) + 1;
2368 | b.nextBytes(x);
2369 | if (t > 0) {
2370 | x[0] &= ((1 << t) - 1);
2371 | }
2372 | else {
2373 | x[0] = 0;
2374 | }
2375 | this.fromString(x, 256);
2376 | }
2377 | };
2378 | return BigInteger;
2379 | }());
2380 | //#region REDUCERS
2381 | //#region NullExp
2382 | var NullExp = /** @class */ (function () {
2383 | function NullExp() {
2384 | }
2385 | // NullExp.prototype.convert = nNop;
2386 | NullExp.prototype.convert = function (x) {
2387 | return x;
2388 | };
2389 | // NullExp.prototype.revert = nNop;
2390 | NullExp.prototype.revert = function (x) {
2391 | return x;
2392 | };
2393 | // NullExp.prototype.mulTo = nMulTo;
2394 | NullExp.prototype.mulTo = function (x, y, r) {
2395 | x.multiplyTo(y, r);
2396 | };
2397 | // NullExp.prototype.sqrTo = nSqrTo;
2398 | NullExp.prototype.sqrTo = function (x, r) {
2399 | x.squareTo(r);
2400 | };
2401 | return NullExp;
2402 | }());
2403 | // Modular reduction using "classic" algorithm
2404 | var Classic = /** @class */ (function () {
2405 | function Classic(m) {
2406 | this.m = m;
2407 | }
2408 | // Classic.prototype.convert = cConvert;
2409 | Classic.prototype.convert = function (x) {
2410 | if (x.s < 0 || x.compareTo(this.m) >= 0) {
2411 | return x.mod(this.m);
2412 | }
2413 | else {
2414 | return x;
2415 | }
2416 | };
2417 | // Classic.prototype.revert = cRevert;
2418 | Classic.prototype.revert = function (x) {
2419 | return x;
2420 | };
2421 | // Classic.prototype.reduce = cReduce;
2422 | Classic.prototype.reduce = function (x) {
2423 | x.divRemTo(this.m, null, x);
2424 | };
2425 | // Classic.prototype.mulTo = cMulTo;
2426 | Classic.prototype.mulTo = function (x, y, r) {
2427 | x.multiplyTo(y, r);
2428 | this.reduce(r);
2429 | };
2430 | // Classic.prototype.sqrTo = cSqrTo;
2431 | Classic.prototype.sqrTo = function (x, r) {
2432 | x.squareTo(r);
2433 | this.reduce(r);
2434 | };
2435 | return Classic;
2436 | }());
2437 | //#endregion
2438 | //#region Montgomery
2439 | // Montgomery reduction
2440 | var Montgomery = /** @class */ (function () {
2441 | function Montgomery(m) {
2442 | this.m = m;
2443 | this.mp = m.invDigit();
2444 | this.mpl = this.mp & 0x7fff;
2445 | this.mph = this.mp >> 15;
2446 | this.um = (1 << (m.DB - 15)) - 1;
2447 | this.mt2 = 2 * m.t;
2448 | }
2449 | // Montgomery.prototype.convert = montConvert;
2450 | // xR mod m
2451 | Montgomery.prototype.convert = function (x) {
2452 | var r = nbi();
2453 | x.abs().dlShiftTo(this.m.t, r);
2454 | r.divRemTo(this.m, null, r);
2455 | if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) {
2456 | this.m.subTo(r, r);
2457 | }
2458 | return r;
2459 | };
2460 | // Montgomery.prototype.revert = montRevert;
2461 | // x/R mod m
2462 | Montgomery.prototype.revert = function (x) {
2463 | var r = nbi();
2464 | x.copyTo(r);
2465 | this.reduce(r);
2466 | return r;
2467 | };
2468 | // Montgomery.prototype.reduce = montReduce;
2469 | // x = x/R mod m (HAC 14.32)
2470 | Montgomery.prototype.reduce = function (x) {
2471 | while (x.t <= this.mt2) {
2472 | // pad x so am has enough room later
2473 | x[x.t++] = 0;
2474 | }
2475 | for (var i = 0; i < this.m.t; ++i) {
2476 | // faster way of calculating u0 = x[i]*mp mod DV
2477 | var j = x[i] & 0x7fff;
2478 | var u0 = (j * this.mpl + (((j * this.mph + (x[i] >> 15) * this.mpl) & this.um) << 15)) & x.DM;
2479 | // use am to combine the multiply-shift-add into one call
2480 | j = i + this.m.t;
2481 | x[j] += this.m.am(0, u0, x, i, 0, this.m.t);
2482 | // propagate carry
2483 | while (x[j] >= x.DV) {
2484 | x[j] -= x.DV;
2485 | x[++j]++;
2486 | }
2487 | }
2488 | x.clamp();
2489 | x.drShiftTo(this.m.t, x);
2490 | if (x.compareTo(this.m) >= 0) {
2491 | x.subTo(this.m, x);
2492 | }
2493 | };
2494 | // Montgomery.prototype.mulTo = montMulTo;
2495 | // r = "xy/R mod m"; x,y != r
2496 | Montgomery.prototype.mulTo = function (x, y, r) {
2497 | x.multiplyTo(y, r);
2498 | this.reduce(r);
2499 | };
2500 | // Montgomery.prototype.sqrTo = montSqrTo;
2501 | // r = "x^2/R mod m"; x != r
2502 | Montgomery.prototype.sqrTo = function (x, r) {
2503 | x.squareTo(r);
2504 | this.reduce(r);
2505 | };
2506 | return Montgomery;
2507 | }());
2508 | //#endregion Montgomery
2509 | //#region Barrett
2510 | // Barrett modular reduction
2511 | var Barrett = /** @class */ (function () {
2512 | function Barrett(m) {
2513 | this.m = m;
2514 | // setup Barrett
2515 | this.r2 = nbi();
2516 | this.q3 = nbi();
2517 | BigInteger.ONE.dlShiftTo(2 * m.t, this.r2);
2518 | this.mu = this.r2.divide(m);
2519 | }
2520 | // Barrett.prototype.convert = barrettConvert;
2521 | Barrett.prototype.convert = function (x) {
2522 | if (x.s < 0 || x.t > 2 * this.m.t) {
2523 | return x.mod(this.m);
2524 | }
2525 | else if (x.compareTo(this.m) < 0) {
2526 | return x;
2527 | }
2528 | else {
2529 | var r = nbi();
2530 | x.copyTo(r);
2531 | this.reduce(r);
2532 | return r;
2533 | }
2534 | };
2535 | // Barrett.prototype.revert = barrettRevert;
2536 | Barrett.prototype.revert = function (x) {
2537 | return x;
2538 | };
2539 | // Barrett.prototype.reduce = barrettReduce;
2540 | // x = x mod m (HAC 14.42)
2541 | Barrett.prototype.reduce = function (x) {
2542 | x.drShiftTo(this.m.t - 1, this.r2);
2543 | if (x.t > this.m.t + 1) {
2544 | x.t = this.m.t + 1;
2545 | x.clamp();
2546 | }
2547 | this.mu.multiplyUpperTo(this.r2, this.m.t + 1, this.q3);
2548 | this.m.multiplyLowerTo(this.q3, this.m.t + 1, this.r2);
2549 | while (x.compareTo(this.r2) < 0) {
2550 | x.dAddOffset(1, this.m.t + 1);
2551 | }
2552 | x.subTo(this.r2, x);
2553 | while (x.compareTo(this.m) >= 0) {
2554 | x.subTo(this.m, x);
2555 | }
2556 | };
2557 | // Barrett.prototype.mulTo = barrettMulTo;
2558 | // r = x*y mod m; x,y != r
2559 | Barrett.prototype.mulTo = function (x, y, r) {
2560 | x.multiplyTo(y, r);
2561 | this.reduce(r);
2562 | };
2563 | // Barrett.prototype.sqrTo = barrettSqrTo;
2564 | // r = x^2 mod m; x != r
2565 | Barrett.prototype.sqrTo = function (x, r) {
2566 | x.squareTo(r);
2567 | this.reduce(r);
2568 | };
2569 | return Barrett;
2570 | }());
2571 | //#endregion
2572 | //#endregion REDUCERS
2573 | // return new, unset BigInteger
2574 | function nbi() { return new BigInteger(null); }
2575 | function parseBigInt(str, r) {
2576 | return new BigInteger(str, r);
2577 | }
2578 | // am: Compute w_j += (x*this_i), propagate carries,
2579 | // c is initial carry, returns final carry.
2580 | // c < 3*dvalue, x < 2*dvalue, this_i < dvalue
2581 | // We need to select the fastest one that works in this environment.
2582 | // am1: use a single mult and divide to get the high bits,
2583 | // max digit bits should be 26 because
2584 | // max internal value = 2*dvalue^2-2*dvalue (< 2^53)
2585 | function am1(i, x, w, j, c, n) {
2586 | while (--n >= 0) {
2587 | var v = x * this[i++] + w[j] + c;
2588 | c = Math.floor(v / 0x4000000);
2589 | w[j++] = v & 0x3ffffff;
2590 | }
2591 | return c;
2592 | }
2593 | // am2 avoids a big mult-and-extract completely.
2594 | // Max digit bits should be <= 30 because we do bitwise ops
2595 | // on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)
2596 | function am2(i, x, w, j, c, n) {
2597 | var xl = x & 0x7fff;
2598 | var xh = x >> 15;
2599 | while (--n >= 0) {
2600 | var l = this[i] & 0x7fff;
2601 | var h = this[i++] >> 15;
2602 | var m = xh * l + h * xl;
2603 | l = xl * l + ((m & 0x7fff) << 15) + w[j] + (c & 0x3fffffff);
2604 | c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30);
2605 | w[j++] = l & 0x3fffffff;
2606 | }
2607 | return c;
2608 | }
2609 | // Alternately, set max digit bits to 28 since some
2610 | // browsers slow down when dealing with 32-bit numbers.
2611 | function am3(i, x, w, j, c, n) {
2612 | var xl = x & 0x3fff;
2613 | var xh = x >> 14;
2614 | while (--n >= 0) {
2615 | var l = this[i] & 0x3fff;
2616 | var h = this[i++] >> 14;
2617 | var m = xh * l + h * xl;
2618 | l = xl * l + ((m & 0x3fff) << 14) + w[j] + c;
2619 | c = (l >> 28) + (m >> 14) + xh * h;
2620 | w[j++] = l & 0xfffffff;
2621 | }
2622 | return c;
2623 | }
2624 | if (j_lm && (navigator.appName == "Microsoft Internet Explorer")) {
2625 | BigInteger.prototype.am = am2;
2626 | dbits = 30;
2627 | }
2628 | else if (j_lm && (navigator.appName != "Netscape")) {
2629 | BigInteger.prototype.am = am1;
2630 | dbits = 26;
2631 | }
2632 | else { // Mozilla/Netscape seems to prefer am3
2633 | BigInteger.prototype.am = am3;
2634 | dbits = 28;
2635 | }
2636 | BigInteger.prototype.DB = dbits;
2637 | BigInteger.prototype.DM = ((1 << dbits) - 1);
2638 | BigInteger.prototype.DV = (1 << dbits);
2639 | var BI_FP = 52;
2640 | BigInteger.prototype.FV = Math.pow(2, BI_FP);
2641 | BigInteger.prototype.F1 = BI_FP - dbits;
2642 | BigInteger.prototype.F2 = 2 * dbits - BI_FP;
2643 | // Digit conversions
2644 | var BI_RC = [];
2645 | var rr;
2646 | var vv;
2647 | rr = "0".charCodeAt(0);
2648 | for (vv = 0; vv <= 9; ++vv) {
2649 | BI_RC[rr++] = vv;
2650 | }
2651 | rr = "a".charCodeAt(0);
2652 | for (vv = 10; vv < 36; ++vv) {
2653 | BI_RC[rr++] = vv;
2654 | }
2655 | rr = "A".charCodeAt(0);
2656 | for (vv = 10; vv < 36; ++vv) {
2657 | BI_RC[rr++] = vv;
2658 | }
2659 | function intAt(s, i) {
2660 | var c = BI_RC[s.charCodeAt(i)];
2661 | return (c == null) ? -1 : c;
2662 | }
2663 | // return bigint initialized to value
2664 | function nbv(i) {
2665 | var r = nbi();
2666 | r.fromInt(i);
2667 | return r;
2668 | }
2669 | // returns bit length of the integer x
2670 | function nbits(x) {
2671 | var r = 1;
2672 | var t;
2673 | if ((t = x >>> 16) != 0) {
2674 | x = t;
2675 | r += 16;
2676 | }
2677 | if ((t = x >> 8) != 0) {
2678 | x = t;
2679 | r += 8;
2680 | }
2681 | if ((t = x >> 4) != 0) {
2682 | x = t;
2683 | r += 4;
2684 | }
2685 | if ((t = x >> 2) != 0) {
2686 | x = t;
2687 | r += 2;
2688 | }
2689 | if ((t = x >> 1) != 0) {
2690 | x = t;
2691 | r += 1;
2692 | }
2693 | return r;
2694 | }
2695 | // "constants"
2696 | BigInteger.ZERO = nbv(0);
2697 | BigInteger.ONE = nbv(1);
2698 |
2699 | // prng4.js - uses Arcfour as a PRNG
2700 | var Arcfour = /** @class */ (function () {
2701 | function Arcfour() {
2702 | this.i = 0;
2703 | this.j = 0;
2704 | this.S = [];
2705 | }
2706 | // Arcfour.prototype.init = ARC4init;
2707 | // Initialize arcfour context from key, an array of ints, each from [0..255]
2708 | Arcfour.prototype.init = function (key) {
2709 | var i;
2710 | var j;
2711 | var t;
2712 | for (i = 0; i < 256; ++i) {
2713 | this.S[i] = i;
2714 | }
2715 | j = 0;
2716 | for (i = 0; i < 256; ++i) {
2717 | j = (j + this.S[i] + key[i % key.length]) & 255;
2718 | t = this.S[i];
2719 | this.S[i] = this.S[j];
2720 | this.S[j] = t;
2721 | }
2722 | this.i = 0;
2723 | this.j = 0;
2724 | };
2725 | // Arcfour.prototype.next = ARC4next;
2726 | Arcfour.prototype.next = function () {
2727 | var t;
2728 | this.i = (this.i + 1) & 255;
2729 | this.j = (this.j + this.S[this.i]) & 255;
2730 | t = this.S[this.i];
2731 | this.S[this.i] = this.S[this.j];
2732 | this.S[this.j] = t;
2733 | return this.S[(t + this.S[this.i]) & 255];
2734 | };
2735 | return Arcfour;
2736 | }());
2737 | // Plug in your RNG constructor here
2738 | function prng_newstate() {
2739 | return new Arcfour();
2740 | }
2741 | // Pool size must be a multiple of 4 and greater than 32.
2742 | // An array of bytes the size of the pool will be passed to init()
2743 | var rng_psize = 256;
2744 |
2745 | // Random number generator - requires a PRNG backend, e.g. prng4.js
2746 | var rng_state;
2747 | var rng_pool = null;
2748 | var rng_pptr;
2749 | // Initialize the pool with junk if needed.
2750 | if (rng_pool == null) {
2751 | rng_pool = [];
2752 | rng_pptr = 0;
2753 | var t = void 0;
2754 | if (window.crypto && window.crypto.getRandomValues) {
2755 | // Extract entropy (2048 bits) from RNG if available
2756 | var z = new Uint32Array(256);
2757 | window.crypto.getRandomValues(z);
2758 | for (t = 0; t < z.length; ++t) {
2759 | rng_pool[rng_pptr++] = z[t] & 255;
2760 | }
2761 | }
2762 | // Use mouse events for entropy, if we do not have enough entropy by the time
2763 | // we need it, entropy will be generated by Math.random.
2764 | var onMouseMoveListener_1 = function (ev) {
2765 | this.count = this.count || 0;
2766 | if (this.count >= 256 || rng_pptr >= rng_psize) {
2767 | if (window.removeEventListener) {
2768 | window.removeEventListener("mousemove", onMouseMoveListener_1, false);
2769 | }
2770 | else if (window.detachEvent) {
2771 | window.detachEvent("onmousemove", onMouseMoveListener_1);
2772 | }
2773 | return;
2774 | }
2775 | try {
2776 | var mouseCoordinates = ev.x + ev.y;
2777 | rng_pool[rng_pptr++] = mouseCoordinates & 255;
2778 | this.count += 1;
2779 | }
2780 | catch (e) {
2781 | // Sometimes Firefox will deny permission to access event properties for some reason. Ignore.
2782 | }
2783 | };
2784 | if (window.addEventListener) {
2785 | window.addEventListener("mousemove", onMouseMoveListener_1, false);
2786 | }
2787 | else if (window.attachEvent) {
2788 | window.attachEvent("onmousemove", onMouseMoveListener_1);
2789 | }
2790 | }
2791 | function rng_get_byte() {
2792 | if (rng_state == null) {
2793 | rng_state = prng_newstate();
2794 | // At this point, we may not have collected enough entropy. If not, fall back to Math.random
2795 | while (rng_pptr < rng_psize) {
2796 | var random = Math.floor(65536 * Math.random());
2797 | rng_pool[rng_pptr++] = random & 255;
2798 | }
2799 | rng_state.init(rng_pool);
2800 | for (rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr) {
2801 | rng_pool[rng_pptr] = 0;
2802 | }
2803 | rng_pptr = 0;
2804 | }
2805 | // TODO: allow reseeding after first request
2806 | return rng_state.next();
2807 | }
2808 | var SecureRandom = /** @class */ (function () {
2809 | function SecureRandom() {
2810 | }
2811 | SecureRandom.prototype.nextBytes = function (ba) {
2812 | for (var i = 0; i < ba.length; ++i) {
2813 | ba[i] = rng_get_byte();
2814 | }
2815 | };
2816 | return SecureRandom;
2817 | }());
2818 |
2819 | // Depends on jsbn.js and rng.js
2820 | // function linebrk(s,n) {
2821 | // var ret = "";
2822 | // var i = 0;
2823 | // while(i + n < s.length) {
2824 | // ret += s.substring(i,i+n) + "\n";
2825 | // i += n;
2826 | // }
2827 | // return ret + s.substring(i,s.length);
2828 | // }
2829 | // function byte2Hex(b) {
2830 | // if(b < 0x10)
2831 | // return "0" + b.toString(16);
2832 | // else
2833 | // return b.toString(16);
2834 | // }
2835 | function pkcs1pad1(s, n) {
2836 | if (n < s.length + 22) {
2837 | console.error("Message too long for RSA");
2838 | return null;
2839 | }
2840 | var len = n - s.length - 6;
2841 | var filler = "";
2842 | for (var f = 0; f < len; f += 2) {
2843 | filler += "ff";
2844 | }
2845 | var m = "0001" + filler + "00" + s;
2846 | return parseBigInt(m, 16);
2847 | }
2848 | // PKCS#1 (type 2, random) pad input string s to n bytes, and return a bigint
2849 | function pkcs1pad2(s, n) {
2850 | if (n < s.length + 11) { // TODO: fix for utf-8
2851 | console.error("Message too long for RSA");
2852 | return null;
2853 | }
2854 | var ba = [];
2855 | var i = s.length - 1;
2856 | while (i >= 0 && n > 0) {
2857 | ba[--n] = s.charCodeAt(i--);
2858 | }
2859 | ba[--n] = 0;
2860 | var rng = new SecureRandom();
2861 | var x = [];
2862 | while (n > 2) { // random non-zero pad
2863 | x[0] = 0;
2864 | while (x[0] == 0) {
2865 | rng.nextBytes(x);
2866 | }
2867 | ba[--n] = x[0];
2868 | }
2869 | ba[--n] = 2;
2870 | ba[--n] = 0;
2871 | return new BigInteger(ba);
2872 | }
2873 | // "empty" RSA key constructor
2874 | var RSAKey = /** @class */ (function () {
2875 | function RSAKey() {
2876 | this.n = null;
2877 | this.e = 0;
2878 | this.d = null;
2879 | this.p = null;
2880 | this.q = null;
2881 | this.dmp1 = null;
2882 | this.dmq1 = null;
2883 | this.coeff = null;
2884 | }
2885 | //#region PROTECTED
2886 | // protected
2887 | // RSAKey.prototype.doPublic = RSADoPublic;
2888 | // Perform raw public operation on "x": return x^e (mod n)
2889 | RSAKey.prototype.doPublic = function (x) {
2890 | return x.modPowInt(this.e, this.n);
2891 | };
2892 | // RSAKey.prototype.doPrivate = RSADoPrivate;
2893 | // Perform raw private operation on "x": return x^d (mod n)
2894 | RSAKey.prototype.doPrivate = function (x) {
2895 | if (this.p == null || this.q == null) {
2896 | return x.modPow(this.d, this.n);
2897 | }
2898 | // TODO: re-calculate any missing CRT params
2899 | var xp = x.mod(this.p).modPow(this.dmp1, this.p);
2900 | var xq = x.mod(this.q).modPow(this.dmq1, this.q);
2901 | while (xp.compareTo(xq) < 0) {
2902 | xp = xp.add(this.p);
2903 | }
2904 | return xp.subtract(xq).multiply(this.coeff).mod(this.p).multiply(this.q).add(xq);
2905 | };
2906 | //#endregion PROTECTED
2907 | //#region PUBLIC
2908 | // RSAKey.prototype.setPublic = RSASetPublic;
2909 | // Set the public key fields N and e from hex strings
2910 | RSAKey.prototype.setPublic = function (N, E) {
2911 | if (N != null && E != null && N.length > 0 && E.length > 0) {
2912 | this.n = parseBigInt(N, 16);
2913 | this.e = parseInt(E, 16);
2914 | }
2915 | else {
2916 | console.error("Invalid RSA public key");
2917 | }
2918 | };
2919 | // RSAKey.prototype.encrypt = RSAEncrypt;
2920 | // Return the PKCS#1 RSA encryption of "text" as an even-length hex string
2921 | RSAKey.prototype.encrypt = function (text) {
2922 | var m = pkcs1pad2(text, (this.n.bitLength() + 7) >> 3);
2923 | if (m == null) {
2924 | return null;
2925 | }
2926 | var c = this.doPublic(m);
2927 | if (c == null) {
2928 | return null;
2929 | }
2930 | var h = c.toString(16);
2931 | if ((h.length & 1) == 0) {
2932 | return h;
2933 | }
2934 | else {
2935 | return "0" + h;
2936 | }
2937 | };
2938 | // RSAKey.prototype.setPrivate = RSASetPrivate;
2939 | // Set the private key fields N, e, and d from hex strings
2940 | RSAKey.prototype.setPrivate = function (N, E, D) {
2941 | if (N != null && E != null && N.length > 0 && E.length > 0) {
2942 | this.n = parseBigInt(N, 16);
2943 | this.e = parseInt(E, 16);
2944 | this.d = parseBigInt(D, 16);
2945 | }
2946 | else {
2947 | console.error("Invalid RSA private key");
2948 | }
2949 | };
2950 | // RSAKey.prototype.setPrivateEx = RSASetPrivateEx;
2951 | // Set the private key fields N, e, d and CRT params from hex strings
2952 | RSAKey.prototype.setPrivateEx = function (N, E, D, P, Q, DP, DQ, C) {
2953 | if (N != null && E != null && N.length > 0 && E.length > 0) {
2954 | this.n = parseBigInt(N, 16);
2955 | this.e = parseInt(E, 16);
2956 | this.d = parseBigInt(D, 16);
2957 | this.p = parseBigInt(P, 16);
2958 | this.q = parseBigInt(Q, 16);
2959 | this.dmp1 = parseBigInt(DP, 16);
2960 | this.dmq1 = parseBigInt(DQ, 16);
2961 | this.coeff = parseBigInt(C, 16);
2962 | }
2963 | else {
2964 | console.error("Invalid RSA private key");
2965 | }
2966 | };
2967 | // RSAKey.prototype.generate = RSAGenerate;
2968 | // Generate a new random private key B bits long, using public expt E
2969 | RSAKey.prototype.generate = function (B, E) {
2970 | var rng = new SecureRandom();
2971 | var qs = B >> 1;
2972 | this.e = parseInt(E, 16);
2973 | var ee = new BigInteger(E, 16);
2974 | for (;;) {
2975 | for (;;) {
2976 | this.p = new BigInteger(B - qs, 1, rng);
2977 | if (this.p.subtract(BigInteger.ONE).gcd(ee).compareTo(BigInteger.ONE) == 0 && this.p.isProbablePrime(10)) {
2978 | break;
2979 | }
2980 | }
2981 | for (;;) {
2982 | this.q = new BigInteger(qs, 1, rng);
2983 | if (this.q.subtract(BigInteger.ONE).gcd(ee).compareTo(BigInteger.ONE) == 0 && this.q.isProbablePrime(10)) {
2984 | break;
2985 | }
2986 | }
2987 | if (this.p.compareTo(this.q) <= 0) {
2988 | var t = this.p;
2989 | this.p = this.q;
2990 | this.q = t;
2991 | }
2992 | var p1 = this.p.subtract(BigInteger.ONE);
2993 | var q1 = this.q.subtract(BigInteger.ONE);
2994 | var phi = p1.multiply(q1);
2995 | if (phi.gcd(ee).compareTo(BigInteger.ONE) == 0) {
2996 | this.n = this.p.multiply(this.q);
2997 | this.d = ee.modInverse(phi);
2998 | this.dmp1 = this.d.mod(p1);
2999 | this.dmq1 = this.d.mod(q1);
3000 | this.coeff = this.q.modInverse(this.p);
3001 | break;
3002 | }
3003 | }
3004 | };
3005 | // RSAKey.prototype.decrypt = RSADecrypt;
3006 | // Return the PKCS#1 RSA decryption of "ctext".
3007 | // "ctext" is an even-length hex string and the output is a plain string.
3008 | RSAKey.prototype.decrypt = function (ctext) {
3009 | var c = parseBigInt(ctext, 16);
3010 | var m = this.doPrivate(c);
3011 | if (m == null) {
3012 | return null;
3013 | }
3014 | return pkcs1unpad2(m, (this.n.bitLength() + 7) >> 3);
3015 | };
3016 | // Generate a new random private key B bits long, using public expt E
3017 | RSAKey.prototype.generateAsync = function (B, E, callback) {
3018 | var rng = new SecureRandom();
3019 | var qs = B >> 1;
3020 | this.e = parseInt(E, 16);
3021 | var ee = new BigInteger(E, 16);
3022 | var rsa = this;
3023 | // These functions have non-descript names because they were originally for(;;) loops.
3024 | // I don't know about cryptography to give them better names than loop1-4.
3025 | var loop1 = function () {
3026 | var loop4 = function () {
3027 | if (rsa.p.compareTo(rsa.q) <= 0) {
3028 | var t = rsa.p;
3029 | rsa.p = rsa.q;
3030 | rsa.q = t;
3031 | }
3032 | var p1 = rsa.p.subtract(BigInteger.ONE);
3033 | var q1 = rsa.q.subtract(BigInteger.ONE);
3034 | var phi = p1.multiply(q1);
3035 | if (phi.gcd(ee).compareTo(BigInteger.ONE) == 0) {
3036 | rsa.n = rsa.p.multiply(rsa.q);
3037 | rsa.d = ee.modInverse(phi);
3038 | rsa.dmp1 = rsa.d.mod(p1);
3039 | rsa.dmq1 = rsa.d.mod(q1);
3040 | rsa.coeff = rsa.q.modInverse(rsa.p);
3041 | setTimeout(function () { callback(); }, 0); // escape
3042 | }
3043 | else {
3044 | setTimeout(loop1, 0);
3045 | }
3046 | };
3047 | var loop3 = function () {
3048 | rsa.q = nbi();
3049 | rsa.q.fromNumberAsync(qs, 1, rng, function () {
3050 | rsa.q.subtract(BigInteger.ONE).gcda(ee, function (r) {
3051 | if (r.compareTo(BigInteger.ONE) == 0 && rsa.q.isProbablePrime(10)) {
3052 | setTimeout(loop4, 0);
3053 | }
3054 | else {
3055 | setTimeout(loop3, 0);
3056 | }
3057 | });
3058 | });
3059 | };
3060 | var loop2 = function () {
3061 | rsa.p = nbi();
3062 | rsa.p.fromNumberAsync(B - qs, 1, rng, function () {
3063 | rsa.p.subtract(BigInteger.ONE).gcda(ee, function (r) {
3064 | if (r.compareTo(BigInteger.ONE) == 0 && rsa.p.isProbablePrime(10)) {
3065 | setTimeout(loop3, 0);
3066 | }
3067 | else {
3068 | setTimeout(loop2, 0);
3069 | }
3070 | });
3071 | });
3072 | };
3073 | setTimeout(loop2, 0);
3074 | };
3075 | setTimeout(loop1, 0);
3076 | };
3077 | RSAKey.prototype.sign = function (text, digestMethod, digestName) {
3078 | var header = getDigestHeader(digestName);
3079 | var digest = header + digestMethod(text).toString();
3080 | var m = pkcs1pad1(digest, this.n.bitLength() / 4);
3081 | if (m == null) {
3082 | return null;
3083 | }
3084 | var c = this.doPrivate(m);
3085 | if (c == null) {
3086 | return null;
3087 | }
3088 | var h = c.toString(16);
3089 | if ((h.length & 1) == 0) {
3090 | return h;
3091 | }
3092 | else {
3093 | return "0" + h;
3094 | }
3095 | };
3096 | RSAKey.prototype.verify = function (text, signature, digestMethod) {
3097 | var c = parseBigInt(signature, 16);
3098 | var m = this.doPublic(c);
3099 | if (m == null) {
3100 | return null;
3101 | }
3102 | var unpadded = m.toString(16).replace(/^1f+00/, "");
3103 | var digest = removeDigestHeader(unpadded);
3104 | return digest == digestMethod(text).toString();
3105 | };
3106 | return RSAKey;
3107 | }());
3108 | // Undo PKCS#1 (type 2, random) padding and, if valid, return the plaintext
3109 | function pkcs1unpad2(d, n) {
3110 | var b = d.toByteArray();
3111 | var i = 0;
3112 | while (i < b.length && b[i] == 0) {
3113 | ++i;
3114 | }
3115 | if (b.length - i != n - 1 || b[i] != 2) {
3116 | return null;
3117 | }
3118 | ++i;
3119 | while (b[i] != 0) {
3120 | if (++i >= b.length) {
3121 | return null;
3122 | }
3123 | }
3124 | var ret = "";
3125 | while (++i < b.length) {
3126 | ret += String.fromCharCode(b[i] & 255);
3127 | }
3128 | return ret;
3129 | }
3130 | // https://tools.ietf.org/html/rfc3447#page-43
3131 | var DIGEST_HEADERS = {
3132 | md2: "3020300c06082a864886f70d020205000410",
3133 | md5: "3020300c06082a864886f70d020505000410",
3134 | sha1: "3021300906052b0e03021a05000414",
3135 | sha224: "302d300d06096086480165030402040500041c",
3136 | sha256: "3031300d060960864801650304020105000420",
3137 | sha384: "3041300d060960864801650304020205000430",
3138 | sha512: "3051300d060960864801650304020305000440",
3139 | ripemd160: "3021300906052b2403020105000414",
3140 | };
3141 | function getDigestHeader(name) {
3142 | return DIGEST_HEADERS[name] || "";
3143 | }
3144 | function removeDigestHeader(str) {
3145 | for (var name_1 in DIGEST_HEADERS) {
3146 | if (DIGEST_HEADERS.hasOwnProperty(name_1)) {
3147 | var header = DIGEST_HEADERS[name_1];
3148 | var len = header.length;
3149 | if (str.substr(0, len) == header) {
3150 | return str.substr(len);
3151 | }
3152 | }
3153 | }
3154 | return str;
3155 | }
3156 | // Return the PKCS#1 RSA encryption of "text" as a Base64-encoded string
3157 | // function RSAEncryptB64(text) {
3158 | // var h = this.encrypt(text);
3159 | // if(h) return hex2b64(h); else return null;
3160 | // }
3161 | // public
3162 | // RSAKey.prototype.encrypt_b64 = RSAEncryptB64;
3163 |
3164 | /*!
3165 | Copyright (c) 2011, Yahoo! Inc. All rights reserved.
3166 | Code licensed under the BSD License:
3167 | http://developer.yahoo.com/yui/license.html
3168 | version: 2.9.0
3169 | */
3170 | var YAHOO = {};
3171 | YAHOO.lang = {
3172 | /**
3173 | * Utility to set up the prototype, constructor and superclass properties to
3174 | * support an inheritance strategy that can chain constructors and methods.
3175 | * Static members will not be inherited.
3176 | *
3177 | * @method extend
3178 | * @static
3179 | * @param {Function} subc the object to modify
3180 | * @param {Function} superc the object to inherit
3181 | * @param {Object} overrides additional properties/methods to add to the
3182 | * subclass prototype. These will override the
3183 | * matching items obtained from the superclass
3184 | * if present.
3185 | */
3186 | extend: function(subc, superc, overrides) {
3187 | if (! superc || ! subc) {
3188 | throw new Error("YAHOO.lang.extend failed, please check that " +
3189 | "all dependencies are included.");
3190 | }
3191 |
3192 | var F = function() {};
3193 | F.prototype = superc.prototype;
3194 | subc.prototype = new F();
3195 | subc.prototype.constructor = subc;
3196 | subc.superclass = superc.prototype;
3197 |
3198 | if (superc.prototype.constructor == Object.prototype.constructor) {
3199 | superc.prototype.constructor = superc;
3200 | }
3201 |
3202 | if (overrides) {
3203 | var i;
3204 | for (i in overrides) {
3205 | subc.prototype[i] = overrides[i];
3206 | }
3207 |
3208 | /*
3209 | * IE will not enumerate native functions in a derived object even if the
3210 | * function was overridden. This is a workaround for specific functions
3211 | * we care about on the Object prototype.
3212 | * @property _IEEnumFix
3213 | * @param {Function} r the object to receive the augmentation
3214 | * @param {Function} s the object that supplies the properties to augment
3215 | * @static
3216 | * @private
3217 | */
3218 | var _IEEnumFix = function() {},
3219 | ADD = ["toString", "valueOf"];
3220 | try {
3221 | if (/MSIE/.test(navigator.userAgent)) {
3222 | _IEEnumFix = function(r, s) {
3223 | for (i = 0; i < ADD.length; i = i + 1) {
3224 | var fname = ADD[i], f = s[fname];
3225 | if (typeof f === 'function' && f != Object.prototype[fname]) {
3226 | r[fname] = f;
3227 | }
3228 | }
3229 | };
3230 | }
3231 | } catch (ex) {} _IEEnumFix(subc.prototype, overrides);
3232 | }
3233 | }
3234 | };
3235 |
3236 | /* asn1-1.0.13.js (c) 2013-2017 Kenji Urushima | kjur.github.com/jsrsasign/license
3237 | */
3238 |
3239 | /**
3240 | * @fileOverview
3241 | * @name asn1-1.0.js
3242 | * @author Kenji Urushima kenji.urushima@gmail.com
3243 | * @version asn1 1.0.13 (2017-Jun-02)
3244 | * @since jsrsasign 2.1
3245 | * @license MIT License
3246 | */
3247 |
3248 | /**
3249 | * kjur's class library name space
3250 | *
3251 | * This name space provides following name spaces:
3252 | *
3253 | * - {@link KJUR.asn1} - ASN.1 primitive hexadecimal encoder
3254 | * - {@link KJUR.asn1.x509} - ASN.1 structure for X.509 certificate and CRL
3255 | * - {@link KJUR.crypto} - Java Cryptographic Extension(JCE) style MessageDigest/Signature
3256 | * class and utilities
3257 | *
3258 | *
3259 | * NOTE: Please ignore method summary and document of this namespace. This caused by a bug of jsdoc2.
3260 | * @name KJUR
3261 | * @namespace kjur's class library name space
3262 | */
3263 | var KJUR = {};
3264 |
3265 | /**
3266 | * kjur's ASN.1 class library name space
3267 | *
3268 | * This is ITU-T X.690 ASN.1 DER encoder class library and
3269 | * class structure and methods is very similar to
3270 | * org.bouncycastle.asn1 package of
3271 | * well known BouncyCaslte Cryptography Library.
3272 | *
PROVIDING ASN.1 PRIMITIVES
3273 | * Here are ASN.1 DER primitive classes.
3274 | *
3275 | * - 0x01 {@link KJUR.asn1.DERBoolean}
3276 | * - 0x02 {@link KJUR.asn1.DERInteger}
3277 | * - 0x03 {@link KJUR.asn1.DERBitString}
3278 | * - 0x04 {@link KJUR.asn1.DEROctetString}
3279 | * - 0x05 {@link KJUR.asn1.DERNull}
3280 | * - 0x06 {@link KJUR.asn1.DERObjectIdentifier}
3281 | * - 0x0a {@link KJUR.asn1.DEREnumerated}
3282 | * - 0x0c {@link KJUR.asn1.DERUTF8String}
3283 | * - 0x12 {@link KJUR.asn1.DERNumericString}
3284 | * - 0x13 {@link KJUR.asn1.DERPrintableString}
3285 | * - 0x14 {@link KJUR.asn1.DERTeletexString}
3286 | * - 0x16 {@link KJUR.asn1.DERIA5String}
3287 | * - 0x17 {@link KJUR.asn1.DERUTCTime}
3288 | * - 0x18 {@link KJUR.asn1.DERGeneralizedTime}
3289 | * - 0x30 {@link KJUR.asn1.DERSequence}
3290 | * - 0x31 {@link KJUR.asn1.DERSet}
3291 | *
3292 | * OTHER ASN.1 CLASSES
3293 | *
3294 | * - {@link KJUR.asn1.ASN1Object}
3295 | * - {@link KJUR.asn1.DERAbstractString}
3296 | * - {@link KJUR.asn1.DERAbstractTime}
3297 | * - {@link KJUR.asn1.DERAbstractStructured}
3298 | * - {@link KJUR.asn1.DERTaggedObject}
3299 | *
3300 | * SUB NAME SPACES
3301 | *
3302 | * - {@link KJUR.asn1.cades} - CAdES long term signature format
3303 | * - {@link KJUR.asn1.cms} - Cryptographic Message Syntax
3304 | * - {@link KJUR.asn1.csr} - Certificate Signing Request (CSR/PKCS#10)
3305 | * - {@link KJUR.asn1.tsp} - RFC 3161 Timestamping Protocol Format
3306 | * - {@link KJUR.asn1.x509} - RFC 5280 X.509 certificate and CRL
3307 | *
3308 | *
3309 | * NOTE: Please ignore method summary and document of this namespace.
3310 | * This caused by a bug of jsdoc2.
3311 | * @name KJUR.asn1
3312 | * @namespace
3313 | */
3314 | if (typeof KJUR.asn1 == "undefined" || !KJUR.asn1) KJUR.asn1 = {};
3315 |
3316 | /**
3317 | * ASN1 utilities class
3318 | * @name KJUR.asn1.ASN1Util
3319 | * @class ASN1 utilities class
3320 | * @since asn1 1.0.2
3321 | */
3322 | KJUR.asn1.ASN1Util = new function() {
3323 | this.integerToByteHex = function(i) {
3324 | var h = i.toString(16);
3325 | if ((h.length % 2) == 1) h = '0' + h;
3326 | return h;
3327 | };
3328 | this.bigIntToMinTwosComplementsHex = function(bigIntegerValue) {
3329 | var h = bigIntegerValue.toString(16);
3330 | if (h.substr(0, 1) != '-') {
3331 | if (h.length % 2 == 1) {
3332 | h = '0' + h;
3333 | } else {
3334 | if (! h.match(/^[0-7]/)) {
3335 | h = '00' + h;
3336 | }
3337 | }
3338 | } else {
3339 | var hPos = h.substr(1);
3340 | var xorLen = hPos.length;
3341 | if (xorLen % 2 == 1) {
3342 | xorLen += 1;
3343 | } else {
3344 | if (! h.match(/^[0-7]/)) {
3345 | xorLen += 2;
3346 | }
3347 | }
3348 | var hMask = '';
3349 | for (var i = 0; i < xorLen; i++) {
3350 | hMask += 'f';
3351 | }
3352 | var biMask = new BigInteger(hMask, 16);
3353 | var biNeg = biMask.xor(bigIntegerValue).add(BigInteger.ONE);
3354 | h = biNeg.toString(16).replace(/^-/, '');
3355 | }
3356 | return h;
3357 | };
3358 | /**
3359 | * get PEM string from hexadecimal data and header string
3360 | * @name getPEMStringFromHex
3361 | * @memberOf KJUR.asn1.ASN1Util
3362 | * @function
3363 | * @param {String} dataHex hexadecimal string of PEM body
3364 | * @param {String} pemHeader PEM header string (ex. 'RSA PRIVATE KEY')
3365 | * @return {String} PEM formatted string of input data
3366 | * @description
3367 | * This method converts a hexadecimal string to a PEM string with
3368 | * a specified header. Its line break will be CRLF("\r\n").
3369 | * @example
3370 | * var pem = KJUR.asn1.ASN1Util.getPEMStringFromHex('616161', 'RSA PRIVATE KEY');
3371 | * // value of pem will be:
3372 | * -----BEGIN PRIVATE KEY-----
3373 | * YWFh
3374 | * -----END PRIVATE KEY-----
3375 | */
3376 | this.getPEMStringFromHex = function(dataHex, pemHeader) {
3377 | return hextopem(dataHex, pemHeader);
3378 | };
3379 |
3380 | /**
3381 | * generate ASN1Object specifed by JSON parameters
3382 | * @name newObject
3383 | * @memberOf KJUR.asn1.ASN1Util
3384 | * @function
3385 | * @param {Array} param JSON parameter to generate ASN1Object
3386 | * @return {KJUR.asn1.ASN1Object} generated object
3387 | * @since asn1 1.0.3
3388 | * @description
3389 | * generate any ASN1Object specified by JSON param
3390 | * including ASN.1 primitive or structured.
3391 | * Generally 'param' can be described as follows:
3392 | *
3393 | * {TYPE-OF-ASNOBJ: ASN1OBJ-PARAMETER}
3394 | *
3395 | * 'TYPE-OF-ASN1OBJ' can be one of following symbols:
3396 | *
3397 | * - 'bool' - DERBoolean
3398 | * - 'int' - DERInteger
3399 | * - 'bitstr' - DERBitString
3400 | * - 'octstr' - DEROctetString
3401 | * - 'null' - DERNull
3402 | * - 'oid' - DERObjectIdentifier
3403 | * - 'enum' - DEREnumerated
3404 | * - 'utf8str' - DERUTF8String
3405 | * - 'numstr' - DERNumericString
3406 | * - 'prnstr' - DERPrintableString
3407 | * - 'telstr' - DERTeletexString
3408 | * - 'ia5str' - DERIA5String
3409 | * - 'utctime' - DERUTCTime
3410 | * - 'gentime' - DERGeneralizedTime
3411 | * - 'seq' - DERSequence
3412 | * - 'set' - DERSet
3413 | * - 'tag' - DERTaggedObject
3414 | *
3415 | * @example
3416 | * newObject({'prnstr': 'aaa'});
3417 | * newObject({'seq': [{'int': 3}, {'prnstr': 'aaa'}]})
3418 | * // ASN.1 Tagged Object
3419 | * newObject({'tag': {'tag': 'a1',
3420 | * 'explicit': true,
3421 | * 'obj': {'seq': [{'int': 3}, {'prnstr': 'aaa'}]}}});
3422 | * // more simple representation of ASN.1 Tagged Object
3423 | * newObject({'tag': ['a1',
3424 | * true,
3425 | * {'seq': [
3426 | * {'int': 3},
3427 | * {'prnstr': 'aaa'}]}
3428 | * ]});
3429 | */
3430 | this.newObject = function(param) {
3431 | var _KJUR = KJUR,
3432 | _KJUR_asn1 = _KJUR.asn1,
3433 | _DERBoolean = _KJUR_asn1.DERBoolean,
3434 | _DERInteger = _KJUR_asn1.DERInteger,
3435 | _DERBitString = _KJUR_asn1.DERBitString,
3436 | _DEROctetString = _KJUR_asn1.DEROctetString,
3437 | _DERNull = _KJUR_asn1.DERNull,
3438 | _DERObjectIdentifier = _KJUR_asn1.DERObjectIdentifier,
3439 | _DEREnumerated = _KJUR_asn1.DEREnumerated,
3440 | _DERUTF8String = _KJUR_asn1.DERUTF8String,
3441 | _DERNumericString = _KJUR_asn1.DERNumericString,
3442 | _DERPrintableString = _KJUR_asn1.DERPrintableString,
3443 | _DERTeletexString = _KJUR_asn1.DERTeletexString,
3444 | _DERIA5String = _KJUR_asn1.DERIA5String,
3445 | _DERUTCTime = _KJUR_asn1.DERUTCTime,
3446 | _DERGeneralizedTime = _KJUR_asn1.DERGeneralizedTime,
3447 | _DERSequence = _KJUR_asn1.DERSequence,
3448 | _DERSet = _KJUR_asn1.DERSet,
3449 | _DERTaggedObject = _KJUR_asn1.DERTaggedObject,
3450 | _newObject = _KJUR_asn1.ASN1Util.newObject;
3451 |
3452 | var keys = Object.keys(param);
3453 | if (keys.length != 1)
3454 | throw "key of param shall be only one.";
3455 | var key = keys[0];
3456 |
3457 | if (":bool:int:bitstr:octstr:null:oid:enum:utf8str:numstr:prnstr:telstr:ia5str:utctime:gentime:seq:set:tag:".indexOf(":" + key + ":") == -1)
3458 | throw "undefined key: " + key;
3459 |
3460 | if (key == "bool") return new _DERBoolean(param[key]);
3461 | if (key == "int") return new _DERInteger(param[key]);
3462 | if (key == "bitstr") return new _DERBitString(param[key]);
3463 | if (key == "octstr") return new _DEROctetString(param[key]);
3464 | if (key == "null") return new _DERNull(param[key]);
3465 | if (key == "oid") return new _DERObjectIdentifier(param[key]);
3466 | if (key == "enum") return new _DEREnumerated(param[key]);
3467 | if (key == "utf8str") return new _DERUTF8String(param[key]);
3468 | if (key == "numstr") return new _DERNumericString(param[key]);
3469 | if (key == "prnstr") return new _DERPrintableString(param[key]);
3470 | if (key == "telstr") return new _DERTeletexString(param[key]);
3471 | if (key == "ia5str") return new _DERIA5String(param[key]);
3472 | if (key == "utctime") return new _DERUTCTime(param[key]);
3473 | if (key == "gentime") return new _DERGeneralizedTime(param[key]);
3474 |
3475 | if (key == "seq") {
3476 | var paramList = param[key];
3477 | var a = [];
3478 | for (var i = 0; i < paramList.length; i++) {
3479 | var asn1Obj = _newObject(paramList[i]);
3480 | a.push(asn1Obj);
3481 | }
3482 | return new _DERSequence({'array': a});
3483 | }
3484 |
3485 | if (key == "set") {
3486 | var paramList = param[key];
3487 | var a = [];
3488 | for (var i = 0; i < paramList.length; i++) {
3489 | var asn1Obj = _newObject(paramList[i]);
3490 | a.push(asn1Obj);
3491 | }
3492 | return new _DERSet({'array': a});
3493 | }
3494 |
3495 | if (key == "tag") {
3496 | var tagParam = param[key];
3497 | if (Object.prototype.toString.call(tagParam) === '[object Array]' &&
3498 | tagParam.length == 3) {
3499 | var obj = _newObject(tagParam[2]);
3500 | return new _DERTaggedObject({tag: tagParam[0],
3501 | explicit: tagParam[1],
3502 | obj: obj});
3503 | } else {
3504 | var newParam = {};
3505 | if (tagParam.explicit !== undefined)
3506 | newParam.explicit = tagParam.explicit;
3507 | if (tagParam.tag !== undefined)
3508 | newParam.tag = tagParam.tag;
3509 | if (tagParam.obj === undefined)
3510 | throw "obj shall be specified for 'tag'.";
3511 | newParam.obj = _newObject(tagParam.obj);
3512 | return new _DERTaggedObject(newParam);
3513 | }
3514 | }
3515 | };
3516 |
3517 | /**
3518 | * get encoded hexadecimal string of ASN1Object specifed by JSON parameters
3519 | * @name jsonToASN1HEX
3520 | * @memberOf KJUR.asn1.ASN1Util
3521 | * @function
3522 | * @param {Array} param JSON parameter to generate ASN1Object
3523 | * @return hexadecimal string of ASN1Object
3524 | * @since asn1 1.0.4
3525 | * @description
3526 | * As for ASN.1 object representation of JSON object,
3527 | * please see {@link newObject}.
3528 | * @example
3529 | * jsonToASN1HEX({'prnstr': 'aaa'});
3530 | */
3531 | this.jsonToASN1HEX = function(param) {
3532 | var asn1Obj = this.newObject(param);
3533 | return asn1Obj.getEncodedHex();
3534 | };
3535 | };
3536 |
3537 | /**
3538 | * get dot noted oid number string from hexadecimal value of OID
3539 | * @name oidHexToInt
3540 | * @memberOf KJUR.asn1.ASN1Util
3541 | * @function
3542 | * @param {String} hex hexadecimal value of object identifier
3543 | * @return {String} dot noted string of object identifier
3544 | * @since jsrsasign 4.8.3 asn1 1.0.7
3545 | * @description
3546 | * This static method converts from hexadecimal string representation of
3547 | * ASN.1 value of object identifier to oid number string.
3548 | * @example
3549 | * KJUR.asn1.ASN1Util.oidHexToInt('550406') → "2.5.4.6"
3550 | */
3551 | KJUR.asn1.ASN1Util.oidHexToInt = function(hex) {
3552 | var s = "";
3553 | var i01 = parseInt(hex.substr(0, 2), 16);
3554 | var i0 = Math.floor(i01 / 40);
3555 | var i1 = i01 % 40;
3556 | var s = i0 + "." + i1;
3557 |
3558 | var binbuf = "";
3559 | for (var i = 2; i < hex.length; i += 2) {
3560 | var value = parseInt(hex.substr(i, 2), 16);
3561 | var bin = ("00000000" + value.toString(2)).slice(- 8);
3562 | binbuf = binbuf + bin.substr(1, 7);
3563 | if (bin.substr(0, 1) == "0") {
3564 | var bi = new BigInteger(binbuf, 2);
3565 | s = s + "." + bi.toString(10);
3566 | binbuf = "";
3567 | }
3568 | }
3569 | return s;
3570 | };
3571 |
3572 | /**
3573 | * get hexadecimal value of object identifier from dot noted oid value
3574 | * @name oidIntToHex
3575 | * @memberOf KJUR.asn1.ASN1Util
3576 | * @function
3577 | * @param {String} oidString dot noted string of object identifier
3578 | * @return {String} hexadecimal value of object identifier
3579 | * @since jsrsasign 4.8.3 asn1 1.0.7
3580 | * @description
3581 | * This static method converts from object identifier value string.
3582 | * to hexadecimal string representation of it.
3583 | * @example
3584 | * KJUR.asn1.ASN1Util.oidIntToHex("2.5.4.6") → "550406"
3585 | */
3586 | KJUR.asn1.ASN1Util.oidIntToHex = function(oidString) {
3587 | var itox = function(i) {
3588 | var h = i.toString(16);
3589 | if (h.length == 1) h = '0' + h;
3590 | return h;
3591 | };
3592 |
3593 | var roidtox = function(roid) {
3594 | var h = '';
3595 | var bi = new BigInteger(roid, 10);
3596 | var b = bi.toString(2);
3597 | var padLen = 7 - b.length % 7;
3598 | if (padLen == 7) padLen = 0;
3599 | var bPad = '';
3600 | for (var i = 0; i < padLen; i++) bPad += '0';
3601 | b = bPad + b;
3602 | for (var i = 0; i < b.length - 1; i += 7) {
3603 | var b8 = b.substr(i, 7);
3604 | if (i != b.length - 7) b8 = '1' + b8;
3605 | h += itox(parseInt(b8, 2));
3606 | }
3607 | return h;
3608 | };
3609 |
3610 | if (! oidString.match(/^[0-9.]+$/)) {
3611 | throw "malformed oid string: " + oidString;
3612 | }
3613 | var h = '';
3614 | var a = oidString.split('.');
3615 | var i0 = parseInt(a[0]) * 40 + parseInt(a[1]);
3616 | h += itox(i0);
3617 | a.splice(0, 2);
3618 | for (var i = 0; i < a.length; i++) {
3619 | h += roidtox(a[i]);
3620 | }
3621 | return h;
3622 | };
3623 |
3624 |
3625 | // ********************************************************************
3626 | // Abstract ASN.1 Classes
3627 | // ********************************************************************
3628 |
3629 | // ********************************************************************
3630 |
3631 | /**
3632 | * base class for ASN.1 DER encoder object
3633 | * @name KJUR.asn1.ASN1Object
3634 | * @class base class for ASN.1 DER encoder object
3635 | * @property {Boolean} isModified flag whether internal data was changed
3636 | * @property {String} hTLV hexadecimal string of ASN.1 TLV
3637 | * @property {String} hT hexadecimal string of ASN.1 TLV tag(T)
3638 | * @property {String} hL hexadecimal string of ASN.1 TLV length(L)
3639 | * @property {String} hV hexadecimal string of ASN.1 TLV value(V)
3640 | * @description
3641 | */
3642 | KJUR.asn1.ASN1Object = function() {
3643 | var hV = '';
3644 |
3645 | /**
3646 | * get hexadecimal ASN.1 TLV length(L) bytes from TLV value(V)
3647 | * @name getLengthHexFromValue
3648 | * @memberOf KJUR.asn1.ASN1Object#
3649 | * @function
3650 | * @return {String} hexadecimal string of ASN.1 TLV length(L)
3651 | */
3652 | this.getLengthHexFromValue = function() {
3653 | if (typeof this.hV == "undefined" || this.hV == null) {
3654 | throw "this.hV is null or undefined.";
3655 | }
3656 | if (this.hV.length % 2 == 1) {
3657 | throw "value hex must be even length: n=" + hV.length + ",v=" + this.hV;
3658 | }
3659 | var n = this.hV.length / 2;
3660 | var hN = n.toString(16);
3661 | if (hN.length % 2 == 1) {
3662 | hN = "0" + hN;
3663 | }
3664 | if (n < 128) {
3665 | return hN;
3666 | } else {
3667 | var hNlen = hN.length / 2;
3668 | if (hNlen > 15) {
3669 | throw "ASN.1 length too long to represent by 8x: n = " + n.toString(16);
3670 | }
3671 | var head = 128 + hNlen;
3672 | return head.toString(16) + hN;
3673 | }
3674 | };
3675 |
3676 | /**
3677 | * get hexadecimal string of ASN.1 TLV bytes
3678 | * @name getEncodedHex
3679 | * @memberOf KJUR.asn1.ASN1Object#
3680 | * @function
3681 | * @return {String} hexadecimal string of ASN.1 TLV
3682 | */
3683 | this.getEncodedHex = function() {
3684 | if (this.hTLV == null || this.isModified) {
3685 | this.hV = this.getFreshValueHex();
3686 | this.hL = this.getLengthHexFromValue();
3687 | this.hTLV = this.hT + this.hL + this.hV;
3688 | this.isModified = false;
3689 | //alert("first time: " + this.hTLV);
3690 | }
3691 | return this.hTLV;
3692 | };
3693 |
3694 | /**
3695 | * get hexadecimal string of ASN.1 TLV value(V) bytes
3696 | * @name getValueHex
3697 | * @memberOf KJUR.asn1.ASN1Object#
3698 | * @function
3699 | * @return {String} hexadecimal string of ASN.1 TLV value(V) bytes
3700 | */
3701 | this.getValueHex = function() {
3702 | this.getEncodedHex();
3703 | return this.hV;
3704 | };
3705 |
3706 | this.getFreshValueHex = function() {
3707 | return '';
3708 | };
3709 | };
3710 |
3711 | // == BEGIN DERAbstractString ================================================
3712 | /**
3713 | * base class for ASN.1 DER string classes
3714 | * @name KJUR.asn1.DERAbstractString
3715 | * @class base class for ASN.1 DER string classes
3716 | * @param {Array} params associative array of parameters (ex. {'str': 'aaa'})
3717 | * @property {String} s internal string of value
3718 | * @extends KJUR.asn1.ASN1Object
3719 | * @description
3720 | *
3721 | * As for argument 'params' for constructor, you can specify one of
3722 | * following properties:
3723 | *
3724 | * - str - specify initial ASN.1 value(V) by a string
3725 | * - hex - specify initial ASN.1 value(V) by a hexadecimal string
3726 | *
3727 | * NOTE: 'params' can be omitted.
3728 | */
3729 | KJUR.asn1.DERAbstractString = function(params) {
3730 | KJUR.asn1.DERAbstractString.superclass.constructor.call(this);
3731 |
3732 | /**
3733 | * get string value of this string object
3734 | * @name getString
3735 | * @memberOf KJUR.asn1.DERAbstractString#
3736 | * @function
3737 | * @return {String} string value of this string object
3738 | */
3739 | this.getString = function() {
3740 | return this.s;
3741 | };
3742 |
3743 | /**
3744 | * set value by a string
3745 | * @name setString
3746 | * @memberOf KJUR.asn1.DERAbstractString#
3747 | * @function
3748 | * @param {String} newS value by a string to set
3749 | */
3750 | this.setString = function(newS) {
3751 | this.hTLV = null;
3752 | this.isModified = true;
3753 | this.s = newS;
3754 | this.hV = stohex(this.s);
3755 | };
3756 |
3757 | /**
3758 | * set value by a hexadecimal string
3759 | * @name setStringHex
3760 | * @memberOf KJUR.asn1.DERAbstractString#
3761 | * @function
3762 | * @param {String} newHexString value by a hexadecimal string to set
3763 | */
3764 | this.setStringHex = function(newHexString) {
3765 | this.hTLV = null;
3766 | this.isModified = true;
3767 | this.s = null;
3768 | this.hV = newHexString;
3769 | };
3770 |
3771 | this.getFreshValueHex = function() {
3772 | return this.hV;
3773 | };
3774 |
3775 | if (typeof params != "undefined") {
3776 | if (typeof params == "string") {
3777 | this.setString(params);
3778 | } else if (typeof params['str'] != "undefined") {
3779 | this.setString(params['str']);
3780 | } else if (typeof params['hex'] != "undefined") {
3781 | this.setStringHex(params['hex']);
3782 | }
3783 | }
3784 | };
3785 | YAHOO.lang.extend(KJUR.asn1.DERAbstractString, KJUR.asn1.ASN1Object);
3786 | // == END DERAbstractString ================================================
3787 |
3788 | // == BEGIN DERAbstractTime ==================================================
3789 | /**
3790 | * base class for ASN.1 DER Generalized/UTCTime class
3791 | * @name KJUR.asn1.DERAbstractTime
3792 | * @class base class for ASN.1 DER Generalized/UTCTime class
3793 | * @param {Array} params associative array of parameters (ex. {'str': '130430235959Z'})
3794 | * @extends KJUR.asn1.ASN1Object
3795 | * @description
3796 | * @see KJUR.asn1.ASN1Object - superclass
3797 | */
3798 | KJUR.asn1.DERAbstractTime = function(params) {
3799 | KJUR.asn1.DERAbstractTime.superclass.constructor.call(this);
3800 |
3801 | // --- PRIVATE METHODS --------------------
3802 | this.localDateToUTC = function(d) {
3803 | utc = d.getTime() + (d.getTimezoneOffset() * 60000);
3804 | var utcDate = new Date(utc);
3805 | return utcDate;
3806 | };
3807 |
3808 | /*
3809 | * format date string by Data object
3810 | * @name formatDate
3811 | * @memberOf KJUR.asn1.AbstractTime;
3812 | * @param {Date} dateObject
3813 | * @param {string} type 'utc' or 'gen'
3814 | * @param {boolean} withMillis flag for with millisections or not
3815 | * @description
3816 | * 'withMillis' flag is supported from asn1 1.0.6.
3817 | */
3818 | this.formatDate = function(dateObject, type, withMillis) {
3819 | var pad = this.zeroPadding;
3820 | var d = this.localDateToUTC(dateObject);
3821 | var year = String(d.getFullYear());
3822 | if (type == 'utc') year = year.substr(2, 2);
3823 | var month = pad(String(d.getMonth() + 1), 2);
3824 | var day = pad(String(d.getDate()), 2);
3825 | var hour = pad(String(d.getHours()), 2);
3826 | var min = pad(String(d.getMinutes()), 2);
3827 | var sec = pad(String(d.getSeconds()), 2);
3828 | var s = year + month + day + hour + min + sec;
3829 | if (withMillis === true) {
3830 | var millis = d.getMilliseconds();
3831 | if (millis != 0) {
3832 | var sMillis = pad(String(millis), 3);
3833 | sMillis = sMillis.replace(/[0]+$/, "");
3834 | s = s + "." + sMillis;
3835 | }
3836 | }
3837 | return s + "Z";
3838 | };
3839 |
3840 | this.zeroPadding = function(s, len) {
3841 | if (s.length >= len) return s;
3842 | return new Array(len - s.length + 1).join('0') + s;
3843 | };
3844 |
3845 | // --- PUBLIC METHODS --------------------
3846 | /**
3847 | * get string value of this string object
3848 | * @name getString
3849 | * @memberOf KJUR.asn1.DERAbstractTime#
3850 | * @function
3851 | * @return {String} string value of this time object
3852 | */
3853 | this.getString = function() {
3854 | return this.s;
3855 | };
3856 |
3857 | /**
3858 | * set value by a string
3859 | * @name setString
3860 | * @memberOf KJUR.asn1.DERAbstractTime#
3861 | * @function
3862 | * @param {String} newS value by a string to set such like "130430235959Z"
3863 | */
3864 | this.setString = function(newS) {
3865 | this.hTLV = null;
3866 | this.isModified = true;
3867 | this.s = newS;
3868 | this.hV = stohex(newS);
3869 | };
3870 |
3871 | /**
3872 | * set value by a Date object
3873 | * @name setByDateValue
3874 | * @memberOf KJUR.asn1.DERAbstractTime#
3875 | * @function
3876 | * @param {Integer} year year of date (ex. 2013)
3877 | * @param {Integer} month month of date between 1 and 12 (ex. 12)
3878 | * @param {Integer} day day of month
3879 | * @param {Integer} hour hours of date
3880 | * @param {Integer} min minutes of date
3881 | * @param {Integer} sec seconds of date
3882 | */
3883 | this.setByDateValue = function(year, month, day, hour, min, sec) {
3884 | var dateObject = new Date(Date.UTC(year, month - 1, day, hour, min, sec, 0));
3885 | this.setByDate(dateObject);
3886 | };
3887 |
3888 | this.getFreshValueHex = function() {
3889 | return this.hV;
3890 | };
3891 | };
3892 | YAHOO.lang.extend(KJUR.asn1.DERAbstractTime, KJUR.asn1.ASN1Object);
3893 | // == END DERAbstractTime ==================================================
3894 |
3895 | // == BEGIN DERAbstractStructured ============================================
3896 | /**
3897 | * base class for ASN.1 DER structured class
3898 | * @name KJUR.asn1.DERAbstractStructured
3899 | * @class base class for ASN.1 DER structured class
3900 | * @property {Array} asn1Array internal array of ASN1Object
3901 | * @extends KJUR.asn1.ASN1Object
3902 | * @description
3903 | * @see KJUR.asn1.ASN1Object - superclass
3904 | */
3905 | KJUR.asn1.DERAbstractStructured = function(params) {
3906 | KJUR.asn1.DERAbstractString.superclass.constructor.call(this);
3907 |
3908 | /**
3909 | * set value by array of ASN1Object
3910 | * @name setByASN1ObjectArray
3911 | * @memberOf KJUR.asn1.DERAbstractStructured#
3912 | * @function
3913 | * @param {array} asn1ObjectArray array of ASN1Object to set
3914 | */
3915 | this.setByASN1ObjectArray = function(asn1ObjectArray) {
3916 | this.hTLV = null;
3917 | this.isModified = true;
3918 | this.asn1Array = asn1ObjectArray;
3919 | };
3920 |
3921 | /**
3922 | * append an ASN1Object to internal array
3923 | * @name appendASN1Object
3924 | * @memberOf KJUR.asn1.DERAbstractStructured#
3925 | * @function
3926 | * @param {ASN1Object} asn1Object to add
3927 | */
3928 | this.appendASN1Object = function(asn1Object) {
3929 | this.hTLV = null;
3930 | this.isModified = true;
3931 | this.asn1Array.push(asn1Object);
3932 | };
3933 |
3934 | this.asn1Array = new Array();
3935 | if (typeof params != "undefined") {
3936 | if (typeof params['array'] != "undefined") {
3937 | this.asn1Array = params['array'];
3938 | }
3939 | }
3940 | };
3941 | YAHOO.lang.extend(KJUR.asn1.DERAbstractStructured, KJUR.asn1.ASN1Object);
3942 |
3943 |
3944 | // ********************************************************************
3945 | // ASN.1 Object Classes
3946 | // ********************************************************************
3947 |
3948 | // ********************************************************************
3949 | /**
3950 | * class for ASN.1 DER Boolean
3951 | * @name KJUR.asn1.DERBoolean
3952 | * @class class for ASN.1 DER Boolean
3953 | * @extends KJUR.asn1.ASN1Object
3954 | * @description
3955 | * @see KJUR.asn1.ASN1Object - superclass
3956 | */
3957 | KJUR.asn1.DERBoolean = function() {
3958 | KJUR.asn1.DERBoolean.superclass.constructor.call(this);
3959 | this.hT = "01";
3960 | this.hTLV = "0101ff";
3961 | };
3962 | YAHOO.lang.extend(KJUR.asn1.DERBoolean, KJUR.asn1.ASN1Object);
3963 |
3964 | // ********************************************************************
3965 | /**
3966 | * class for ASN.1 DER Integer
3967 | * @name KJUR.asn1.DERInteger
3968 | * @class class for ASN.1 DER Integer
3969 | * @extends KJUR.asn1.ASN1Object
3970 | * @description
3971 | *
3972 | * As for argument 'params' for constructor, you can specify one of
3973 | * following properties:
3974 | *
3975 | * - int - specify initial ASN.1 value(V) by integer value
3976 | * - bigint - specify initial ASN.1 value(V) by BigInteger object
3977 | * - hex - specify initial ASN.1 value(V) by a hexadecimal string
3978 | *
3979 | * NOTE: 'params' can be omitted.
3980 | */
3981 | KJUR.asn1.DERInteger = function(params) {
3982 | KJUR.asn1.DERInteger.superclass.constructor.call(this);
3983 | this.hT = "02";
3984 |
3985 | /**
3986 | * set value by Tom Wu's BigInteger object
3987 | * @name setByBigInteger
3988 | * @memberOf KJUR.asn1.DERInteger#
3989 | * @function
3990 | * @param {BigInteger} bigIntegerValue to set
3991 | */
3992 | this.setByBigInteger = function(bigIntegerValue) {
3993 | this.hTLV = null;
3994 | this.isModified = true;
3995 | this.hV = KJUR.asn1.ASN1Util.bigIntToMinTwosComplementsHex(bigIntegerValue);
3996 | };
3997 |
3998 | /**
3999 | * set value by integer value
4000 | * @name setByInteger
4001 | * @memberOf KJUR.asn1.DERInteger
4002 | * @function
4003 | * @param {Integer} integer value to set
4004 | */
4005 | this.setByInteger = function(intValue) {
4006 | var bi = new BigInteger(String(intValue), 10);
4007 | this.setByBigInteger(bi);
4008 | };
4009 |
4010 | /**
4011 | * set value by integer value
4012 | * @name setValueHex
4013 | * @memberOf KJUR.asn1.DERInteger#
4014 | * @function
4015 | * @param {String} hexadecimal string of integer value
4016 | * @description
4017 | *
4018 | * NOTE: Value shall be represented by minimum octet length of
4019 | * two's complement representation.
4020 | * @example
4021 | * new KJUR.asn1.DERInteger(123);
4022 | * new KJUR.asn1.DERInteger({'int': 123});
4023 | * new KJUR.asn1.DERInteger({'hex': '1fad'});
4024 | */
4025 | this.setValueHex = function(newHexString) {
4026 | this.hV = newHexString;
4027 | };
4028 |
4029 | this.getFreshValueHex = function() {
4030 | return this.hV;
4031 | };
4032 |
4033 | if (typeof params != "undefined") {
4034 | if (typeof params['bigint'] != "undefined") {
4035 | this.setByBigInteger(params['bigint']);
4036 | } else if (typeof params['int'] != "undefined") {
4037 | this.setByInteger(params['int']);
4038 | } else if (typeof params == "number") {
4039 | this.setByInteger(params);
4040 | } else if (typeof params['hex'] != "undefined") {
4041 | this.setValueHex(params['hex']);
4042 | }
4043 | }
4044 | };
4045 | YAHOO.lang.extend(KJUR.asn1.DERInteger, KJUR.asn1.ASN1Object);
4046 |
4047 | // ********************************************************************
4048 | /**
4049 | * class for ASN.1 DER encoded BitString primitive
4050 | * @name KJUR.asn1.DERBitString
4051 | * @class class for ASN.1 DER encoded BitString primitive
4052 | * @extends KJUR.asn1.ASN1Object
4053 | * @description
4054 | *
4055 | * As for argument 'params' for constructor, you can specify one of
4056 | * following properties:
4057 | *
4058 | * - bin - specify binary string (ex. '10111')
4059 | * - array - specify array of boolean (ex. [true,false,true,true])
4060 | * - hex - specify hexadecimal string of ASN.1 value(V) including unused bits
4061 | * - obj - specify {@link KJUR.asn1.ASN1Util.newObject}
4062 | * argument for "BitString encapsulates" structure.
4063 | *
4064 | * NOTE1: 'params' can be omitted.
4065 | * NOTE2: 'obj' parameter have been supported since
4066 | * asn1 1.0.11, jsrsasign 6.1.1 (2016-Sep-25).
4067 | * @example
4068 | * // default constructor
4069 | * o = new KJUR.asn1.DERBitString();
4070 | * // initialize with binary string
4071 | * o = new KJUR.asn1.DERBitString({bin: "1011"});
4072 | * // initialize with boolean array
4073 | * o = new KJUR.asn1.DERBitString({array: [true,false,true,true]});
4074 | * // initialize with hexadecimal string (04 is unused bits)
4075 | * o = new KJUR.asn1.DEROctetString({hex: "04bac0"});
4076 | * // initialize with ASN1Util.newObject argument for encapsulated
4077 | * o = new KJUR.asn1.DERBitString({obj: {seq: [{int: 3}, {prnstr: 'aaa'}]}});
4078 | * // above generates a ASN.1 data like this:
4079 | * // BIT STRING, encapsulates {
4080 | * // SEQUENCE {
4081 | * // INTEGER 3
4082 | * // PrintableString 'aaa'
4083 | * // }
4084 | * // }
4085 | */
4086 | KJUR.asn1.DERBitString = function(params) {
4087 | if (params !== undefined && typeof params.obj !== "undefined") {
4088 | var o = KJUR.asn1.ASN1Util.newObject(params.obj);
4089 | params.hex = "00" + o.getEncodedHex();
4090 | }
4091 | KJUR.asn1.DERBitString.superclass.constructor.call(this);
4092 | this.hT = "03";
4093 |
4094 | /**
4095 | * set ASN.1 value(V) by a hexadecimal string including unused bits
4096 | * @name setHexValueIncludingUnusedBits
4097 | * @memberOf KJUR.asn1.DERBitString#
4098 | * @function
4099 | * @param {String} newHexStringIncludingUnusedBits
4100 | */
4101 | this.setHexValueIncludingUnusedBits = function(newHexStringIncludingUnusedBits) {
4102 | this.hTLV = null;
4103 | this.isModified = true;
4104 | this.hV = newHexStringIncludingUnusedBits;
4105 | };
4106 |
4107 | /**
4108 | * set ASN.1 value(V) by unused bit and hexadecimal string of value
4109 | * @name setUnusedBitsAndHexValue
4110 | * @memberOf KJUR.asn1.DERBitString#
4111 | * @function
4112 | * @param {Integer} unusedBits
4113 | * @param {String} hValue
4114 | */
4115 | this.setUnusedBitsAndHexValue = function(unusedBits, hValue) {
4116 | if (unusedBits < 0 || 7 < unusedBits) {
4117 | throw "unused bits shall be from 0 to 7: u = " + unusedBits;
4118 | }
4119 | var hUnusedBits = "0" + unusedBits;
4120 | this.hTLV = null;
4121 | this.isModified = true;
4122 | this.hV = hUnusedBits + hValue;
4123 | };
4124 |
4125 | /**
4126 | * set ASN.1 DER BitString by binary string
4127 | * @name setByBinaryString
4128 | * @memberOf KJUR.asn1.DERBitString#
4129 | * @function
4130 | * @param {String} binaryString binary value string (i.e. '10111')
4131 | * @description
4132 | * Its unused bits will be calculated automatically by length of
4133 | * 'binaryValue'.
4134 | * NOTE: Trailing zeros '0' will be ignored.
4135 | * @example
4136 | * o = new KJUR.asn1.DERBitString();
4137 | * o.setByBooleanArray("01011");
4138 | */
4139 | this.setByBinaryString = function(binaryString) {
4140 | binaryString = binaryString.replace(/0+$/, '');
4141 | var unusedBits = 8 - binaryString.length % 8;
4142 | if (unusedBits == 8) unusedBits = 0;
4143 | for (var i = 0; i <= unusedBits; i++) {
4144 | binaryString += '0';
4145 | }
4146 | var h = '';
4147 | for (var i = 0; i < binaryString.length - 1; i += 8) {
4148 | var b = binaryString.substr(i, 8);
4149 | var x = parseInt(b, 2).toString(16);
4150 | if (x.length == 1) x = '0' + x;
4151 | h += x;
4152 | }
4153 | this.hTLV = null;
4154 | this.isModified = true;
4155 | this.hV = '0' + unusedBits + h;
4156 | };
4157 |
4158 | /**
4159 | * set ASN.1 TLV value(V) by an array of boolean
4160 | * @name setByBooleanArray
4161 | * @memberOf KJUR.asn1.DERBitString#
4162 | * @function
4163 | * @param {array} booleanArray array of boolean (ex. [true, false, true])
4164 | * @description
4165 | * NOTE: Trailing falses will be ignored in the ASN.1 DER Object.
4166 | * @example
4167 | * o = new KJUR.asn1.DERBitString();
4168 | * o.setByBooleanArray([false, true, false, true, true]);
4169 | */
4170 | this.setByBooleanArray = function(booleanArray) {
4171 | var s = '';
4172 | for (var i = 0; i < booleanArray.length; i++) {
4173 | if (booleanArray[i] == true) {
4174 | s += '1';
4175 | } else {
4176 | s += '0';
4177 | }
4178 | }
4179 | this.setByBinaryString(s);
4180 | };
4181 |
4182 | /**
4183 | * generate an array of falses with specified length
4184 | * @name newFalseArray
4185 | * @memberOf KJUR.asn1.DERBitString
4186 | * @function
4187 | * @param {Integer} nLength length of array to generate
4188 | * @return {array} array of boolean falses
4189 | * @description
4190 | * This static method may be useful to initialize boolean array.
4191 | * @example
4192 | * o = new KJUR.asn1.DERBitString();
4193 | * o.newFalseArray(3) → [false, false, false]
4194 | */
4195 | this.newFalseArray = function(nLength) {
4196 | var a = new Array(nLength);
4197 | for (var i = 0; i < nLength; i++) {
4198 | a[i] = false;
4199 | }
4200 | return a;
4201 | };
4202 |
4203 | this.getFreshValueHex = function() {
4204 | return this.hV;
4205 | };
4206 |
4207 | if (typeof params != "undefined") {
4208 | if (typeof params == "string" && params.toLowerCase().match(/^[0-9a-f]+$/)) {
4209 | this.setHexValueIncludingUnusedBits(params);
4210 | } else if (typeof params['hex'] != "undefined") {
4211 | this.setHexValueIncludingUnusedBits(params['hex']);
4212 | } else if (typeof params['bin'] != "undefined") {
4213 | this.setByBinaryString(params['bin']);
4214 | } else if (typeof params['array'] != "undefined") {
4215 | this.setByBooleanArray(params['array']);
4216 | }
4217 | }
4218 | };
4219 | YAHOO.lang.extend(KJUR.asn1.DERBitString, KJUR.asn1.ASN1Object);
4220 |
4221 | // ********************************************************************
4222 | /**
4223 | * class for ASN.1 DER OctetString
4224 | * @name KJUR.asn1.DEROctetString
4225 | * @class class for ASN.1 DER OctetString
4226 | * @param {Array} params associative array of parameters (ex. {'str': 'aaa'})
4227 | * @extends KJUR.asn1.DERAbstractString
4228 | * @description
4229 | * This class provides ASN.1 OctetString simple type.
4230 | * Supported "params" attributes are:
4231 | *
4232 | * - str - to set a string as a value
4233 | * - hex - to set a hexadecimal string as a value
4234 | * - obj - to set a encapsulated ASN.1 value by JSON object
4235 | * which is defined in {@link KJUR.asn1.ASN1Util.newObject}
4236 | *
4237 | * NOTE: A parameter 'obj' have been supported
4238 | * for "OCTET STRING, encapsulates" structure.
4239 | * since asn1 1.0.11, jsrsasign 6.1.1 (2016-Sep-25).
4240 | * @see KJUR.asn1.DERAbstractString - superclass
4241 | * @example
4242 | * // default constructor
4243 | * o = new KJUR.asn1.DEROctetString();
4244 | * // initialize with string
4245 | * o = new KJUR.asn1.DEROctetString({str: "aaa"});
4246 | * // initialize with hexadecimal string
4247 | * o = new KJUR.asn1.DEROctetString({hex: "616161"});
4248 | * // initialize with ASN1Util.newObject argument
4249 | * o = new KJUR.asn1.DEROctetString({obj: {seq: [{int: 3}, {prnstr: 'aaa'}]}});
4250 | * // above generates a ASN.1 data like this:
4251 | * // OCTET STRING, encapsulates {
4252 | * // SEQUENCE {
4253 | * // INTEGER 3
4254 | * // PrintableString 'aaa'
4255 | * // }
4256 | * // }
4257 | */
4258 | KJUR.asn1.DEROctetString = function(params) {
4259 | if (params !== undefined && typeof params.obj !== "undefined") {
4260 | var o = KJUR.asn1.ASN1Util.newObject(params.obj);
4261 | params.hex = o.getEncodedHex();
4262 | }
4263 | KJUR.asn1.DEROctetString.superclass.constructor.call(this, params);
4264 | this.hT = "04";
4265 | };
4266 | YAHOO.lang.extend(KJUR.asn1.DEROctetString, KJUR.asn1.DERAbstractString);
4267 |
4268 | // ********************************************************************
4269 | /**
4270 | * class for ASN.1 DER Null
4271 | * @name KJUR.asn1.DERNull
4272 | * @class class for ASN.1 DER Null
4273 | * @extends KJUR.asn1.ASN1Object
4274 | * @description
4275 | * @see KJUR.asn1.ASN1Object - superclass
4276 | */
4277 | KJUR.asn1.DERNull = function() {
4278 | KJUR.asn1.DERNull.superclass.constructor.call(this);
4279 | this.hT = "05";
4280 | this.hTLV = "0500";
4281 | };
4282 | YAHOO.lang.extend(KJUR.asn1.DERNull, KJUR.asn1.ASN1Object);
4283 |
4284 | // ********************************************************************
4285 | /**
4286 | * class for ASN.1 DER ObjectIdentifier
4287 | * @name KJUR.asn1.DERObjectIdentifier
4288 | * @class class for ASN.1 DER ObjectIdentifier
4289 | * @param {Array} params associative array of parameters (ex. {'oid': '2.5.4.5'})
4290 | * @extends KJUR.asn1.ASN1Object
4291 | * @description
4292 | *
4293 | * As for argument 'params' for constructor, you can specify one of
4294 | * following properties:
4295 | *
4296 | * - oid - specify initial ASN.1 value(V) by a oid string (ex. 2.5.4.13)
4297 | * - hex - specify initial ASN.1 value(V) by a hexadecimal string
4298 | *
4299 | * NOTE: 'params' can be omitted.
4300 | */
4301 | KJUR.asn1.DERObjectIdentifier = function(params) {
4302 | var itox = function(i) {
4303 | var h = i.toString(16);
4304 | if (h.length == 1) h = '0' + h;
4305 | return h;
4306 | };
4307 | var roidtox = function(roid) {
4308 | var h = '';
4309 | var bi = new BigInteger(roid, 10);
4310 | var b = bi.toString(2);
4311 | var padLen = 7 - b.length % 7;
4312 | if (padLen == 7) padLen = 0;
4313 | var bPad = '';
4314 | for (var i = 0; i < padLen; i++) bPad += '0';
4315 | b = bPad + b;
4316 | for (var i = 0; i < b.length - 1; i += 7) {
4317 | var b8 = b.substr(i, 7);
4318 | if (i != b.length - 7) b8 = '1' + b8;
4319 | h += itox(parseInt(b8, 2));
4320 | }
4321 | return h;
4322 | };
4323 |
4324 | KJUR.asn1.DERObjectIdentifier.superclass.constructor.call(this);
4325 | this.hT = "06";
4326 |
4327 | /**
4328 | * set value by a hexadecimal string
4329 | * @name setValueHex
4330 | * @memberOf KJUR.asn1.DERObjectIdentifier#
4331 | * @function
4332 | * @param {String} newHexString hexadecimal value of OID bytes
4333 | */
4334 | this.setValueHex = function(newHexString) {
4335 | this.hTLV = null;
4336 | this.isModified = true;
4337 | this.s = null;
4338 | this.hV = newHexString;
4339 | };
4340 |
4341 | /**
4342 | * set value by a OID string
4343 | * @name setValueOidString
4344 | * @memberOf KJUR.asn1.DERObjectIdentifier#
4345 | * @function
4346 | * @param {String} oidString OID string (ex. 2.5.4.13)
4347 | * @example
4348 | * o = new KJUR.asn1.DERObjectIdentifier();
4349 | * o.setValueOidString("2.5.4.13");
4350 | */
4351 | this.setValueOidString = function(oidString) {
4352 | if (! oidString.match(/^[0-9.]+$/)) {
4353 | throw "malformed oid string: " + oidString;
4354 | }
4355 | var h = '';
4356 | var a = oidString.split('.');
4357 | var i0 = parseInt(a[0]) * 40 + parseInt(a[1]);
4358 | h += itox(i0);
4359 | a.splice(0, 2);
4360 | for (var i = 0; i < a.length; i++) {
4361 | h += roidtox(a[i]);
4362 | }
4363 | this.hTLV = null;
4364 | this.isModified = true;
4365 | this.s = null;
4366 | this.hV = h;
4367 | };
4368 |
4369 | /**
4370 | * set value by a OID name
4371 | * @name setValueName
4372 | * @memberOf KJUR.asn1.DERObjectIdentifier#
4373 | * @function
4374 | * @param {String} oidName OID name (ex. 'serverAuth')
4375 | * @since 1.0.1
4376 | * @description
4377 | * OID name shall be defined in 'KJUR.asn1.x509.OID.name2oidList'.
4378 | * Otherwise raise error.
4379 | * @example
4380 | * o = new KJUR.asn1.DERObjectIdentifier();
4381 | * o.setValueName("serverAuth");
4382 | */
4383 | this.setValueName = function(oidName) {
4384 | var oid = KJUR.asn1.x509.OID.name2oid(oidName);
4385 | if (oid !== '') {
4386 | this.setValueOidString(oid);
4387 | } else {
4388 | throw "DERObjectIdentifier oidName undefined: " + oidName;
4389 | }
4390 | };
4391 |
4392 | this.getFreshValueHex = function() {
4393 | return this.hV;
4394 | };
4395 |
4396 | if (params !== undefined) {
4397 | if (typeof params === "string") {
4398 | if (params.match(/^[0-2].[0-9.]+$/)) {
4399 | this.setValueOidString(params);
4400 | } else {
4401 | this.setValueName(params);
4402 | }
4403 | } else if (params.oid !== undefined) {
4404 | this.setValueOidString(params.oid);
4405 | } else if (params.hex !== undefined) {
4406 | this.setValueHex(params.hex);
4407 | } else if (params.name !== undefined) {
4408 | this.setValueName(params.name);
4409 | }
4410 | }
4411 | };
4412 | YAHOO.lang.extend(KJUR.asn1.DERObjectIdentifier, KJUR.asn1.ASN1Object);
4413 |
4414 | // ********************************************************************
4415 | /**
4416 | * class for ASN.1 DER Enumerated
4417 | * @name KJUR.asn1.DEREnumerated
4418 | * @class class for ASN.1 DER Enumerated
4419 | * @extends KJUR.asn1.ASN1Object
4420 | * @description
4421 | *
4422 | * As for argument 'params' for constructor, you can specify one of
4423 | * following properties:
4424 | *
4425 | * - int - specify initial ASN.1 value(V) by integer value
4426 | * - hex - specify initial ASN.1 value(V) by a hexadecimal string
4427 | *
4428 | * NOTE: 'params' can be omitted.
4429 | * @example
4430 | * new KJUR.asn1.DEREnumerated(123);
4431 | * new KJUR.asn1.DEREnumerated({int: 123});
4432 | * new KJUR.asn1.DEREnumerated({hex: '1fad'});
4433 | */
4434 | KJUR.asn1.DEREnumerated = function(params) {
4435 | KJUR.asn1.DEREnumerated.superclass.constructor.call(this);
4436 | this.hT = "0a";
4437 |
4438 | /**
4439 | * set value by Tom Wu's BigInteger object
4440 | * @name setByBigInteger
4441 | * @memberOf KJUR.asn1.DEREnumerated#
4442 | * @function
4443 | * @param {BigInteger} bigIntegerValue to set
4444 | */
4445 | this.setByBigInteger = function(bigIntegerValue) {
4446 | this.hTLV = null;
4447 | this.isModified = true;
4448 | this.hV = KJUR.asn1.ASN1Util.bigIntToMinTwosComplementsHex(bigIntegerValue);
4449 | };
4450 |
4451 | /**
4452 | * set value by integer value
4453 | * @name setByInteger
4454 | * @memberOf KJUR.asn1.DEREnumerated#
4455 | * @function
4456 | * @param {Integer} integer value to set
4457 | */
4458 | this.setByInteger = function(intValue) {
4459 | var bi = new BigInteger(String(intValue), 10);
4460 | this.setByBigInteger(bi);
4461 | };
4462 |
4463 | /**
4464 | * set value by integer value
4465 | * @name setValueHex
4466 | * @memberOf KJUR.asn1.DEREnumerated#
4467 | * @function
4468 | * @param {String} hexadecimal string of integer value
4469 | * @description
4470 | *
4471 | * NOTE: Value shall be represented by minimum octet length of
4472 | * two's complement representation.
4473 | */
4474 | this.setValueHex = function(newHexString) {
4475 | this.hV = newHexString;
4476 | };
4477 |
4478 | this.getFreshValueHex = function() {
4479 | return this.hV;
4480 | };
4481 |
4482 | if (typeof params != "undefined") {
4483 | if (typeof params['int'] != "undefined") {
4484 | this.setByInteger(params['int']);
4485 | } else if (typeof params == "number") {
4486 | this.setByInteger(params);
4487 | } else if (typeof params['hex'] != "undefined") {
4488 | this.setValueHex(params['hex']);
4489 | }
4490 | }
4491 | };
4492 | YAHOO.lang.extend(KJUR.asn1.DEREnumerated, KJUR.asn1.ASN1Object);
4493 |
4494 | // ********************************************************************
4495 | /**
4496 | * class for ASN.1 DER UTF8String
4497 | * @name KJUR.asn1.DERUTF8String
4498 | * @class class for ASN.1 DER UTF8String
4499 | * @param {Array} params associative array of parameters (ex. {'str': 'aaa'})
4500 | * @extends KJUR.asn1.DERAbstractString
4501 | * @description
4502 | * @see KJUR.asn1.DERAbstractString - superclass
4503 | */
4504 | KJUR.asn1.DERUTF8String = function(params) {
4505 | KJUR.asn1.DERUTF8String.superclass.constructor.call(this, params);
4506 | this.hT = "0c";
4507 | };
4508 | YAHOO.lang.extend(KJUR.asn1.DERUTF8String, KJUR.asn1.DERAbstractString);
4509 |
4510 | // ********************************************************************
4511 | /**
4512 | * class for ASN.1 DER NumericString
4513 | * @name KJUR.asn1.DERNumericString
4514 | * @class class for ASN.1 DER NumericString
4515 | * @param {Array} params associative array of parameters (ex. {'str': 'aaa'})
4516 | * @extends KJUR.asn1.DERAbstractString
4517 | * @description
4518 | * @see KJUR.asn1.DERAbstractString - superclass
4519 | */
4520 | KJUR.asn1.DERNumericString = function(params) {
4521 | KJUR.asn1.DERNumericString.superclass.constructor.call(this, params);
4522 | this.hT = "12";
4523 | };
4524 | YAHOO.lang.extend(KJUR.asn1.DERNumericString, KJUR.asn1.DERAbstractString);
4525 |
4526 | // ********************************************************************
4527 | /**
4528 | * class for ASN.1 DER PrintableString
4529 | * @name KJUR.asn1.DERPrintableString
4530 | * @class class for ASN.1 DER PrintableString
4531 | * @param {Array} params associative array of parameters (ex. {'str': 'aaa'})
4532 | * @extends KJUR.asn1.DERAbstractString
4533 | * @description
4534 | * @see KJUR.asn1.DERAbstractString - superclass
4535 | */
4536 | KJUR.asn1.DERPrintableString = function(params) {
4537 | KJUR.asn1.DERPrintableString.superclass.constructor.call(this, params);
4538 | this.hT = "13";
4539 | };
4540 | YAHOO.lang.extend(KJUR.asn1.DERPrintableString, KJUR.asn1.DERAbstractString);
4541 |
4542 | // ********************************************************************
4543 | /**
4544 | * class for ASN.1 DER TeletexString
4545 | * @name KJUR.asn1.DERTeletexString
4546 | * @class class for ASN.1 DER TeletexString
4547 | * @param {Array} params associative array of parameters (ex. {'str': 'aaa'})
4548 | * @extends KJUR.asn1.DERAbstractString
4549 | * @description
4550 | * @see KJUR.asn1.DERAbstractString - superclass
4551 | */
4552 | KJUR.asn1.DERTeletexString = function(params) {
4553 | KJUR.asn1.DERTeletexString.superclass.constructor.call(this, params);
4554 | this.hT = "14";
4555 | };
4556 | YAHOO.lang.extend(KJUR.asn1.DERTeletexString, KJUR.asn1.DERAbstractString);
4557 |
4558 | // ********************************************************************
4559 | /**
4560 | * class for ASN.1 DER IA5String
4561 | * @name KJUR.asn1.DERIA5String
4562 | * @class class for ASN.1 DER IA5String
4563 | * @param {Array} params associative array of parameters (ex. {'str': 'aaa'})
4564 | * @extends KJUR.asn1.DERAbstractString
4565 | * @description
4566 | * @see KJUR.asn1.DERAbstractString - superclass
4567 | */
4568 | KJUR.asn1.DERIA5String = function(params) {
4569 | KJUR.asn1.DERIA5String.superclass.constructor.call(this, params);
4570 | this.hT = "16";
4571 | };
4572 | YAHOO.lang.extend(KJUR.asn1.DERIA5String, KJUR.asn1.DERAbstractString);
4573 |
4574 | // ********************************************************************
4575 | /**
4576 | * class for ASN.1 DER UTCTime
4577 | * @name KJUR.asn1.DERUTCTime
4578 | * @class class for ASN.1 DER UTCTime
4579 | * @param {Array} params associative array of parameters (ex. {'str': '130430235959Z'})
4580 | * @extends KJUR.asn1.DERAbstractTime
4581 | * @description
4582 | *
4583 | * As for argument 'params' for constructor, you can specify one of
4584 | * following properties:
4585 | *
4586 | * - str - specify initial ASN.1 value(V) by a string (ex.'130430235959Z')
4587 | * - hex - specify initial ASN.1 value(V) by a hexadecimal string
4588 | * - date - specify Date object.
4589 | *
4590 | * NOTE: 'params' can be omitted.
4591 | * EXAMPLES
4592 | * @example
4593 | * d1 = new KJUR.asn1.DERUTCTime();
4594 | * d1.setString('130430125959Z');
4595 | *
4596 | * d2 = new KJUR.asn1.DERUTCTime({'str': '130430125959Z'});
4597 | * d3 = new KJUR.asn1.DERUTCTime({'date': new Date(Date.UTC(2015, 0, 31, 0, 0, 0, 0))});
4598 | * d4 = new KJUR.asn1.DERUTCTime('130430125959Z');
4599 | */
4600 | KJUR.asn1.DERUTCTime = function(params) {
4601 | KJUR.asn1.DERUTCTime.superclass.constructor.call(this, params);
4602 | this.hT = "17";
4603 |
4604 | /**
4605 | * set value by a Date object
4606 | * @name setByDate
4607 | * @memberOf KJUR.asn1.DERUTCTime#
4608 | * @function
4609 | * @param {Date} dateObject Date object to set ASN.1 value(V)
4610 | * @example
4611 | * o = new KJUR.asn1.DERUTCTime();
4612 | * o.setByDate(new Date("2016/12/31"));
4613 | */
4614 | this.setByDate = function(dateObject) {
4615 | this.hTLV = null;
4616 | this.isModified = true;
4617 | this.date = dateObject;
4618 | this.s = this.formatDate(this.date, 'utc');
4619 | this.hV = stohex(this.s);
4620 | };
4621 |
4622 | this.getFreshValueHex = function() {
4623 | if (typeof this.date == "undefined" && typeof this.s == "undefined") {
4624 | this.date = new Date();
4625 | this.s = this.formatDate(this.date, 'utc');
4626 | this.hV = stohex(this.s);
4627 | }
4628 | return this.hV;
4629 | };
4630 |
4631 | if (params !== undefined) {
4632 | if (params.str !== undefined) {
4633 | this.setString(params.str);
4634 | } else if (typeof params == "string" && params.match(/^[0-9]{12}Z$/)) {
4635 | this.setString(params);
4636 | } else if (params.hex !== undefined) {
4637 | this.setStringHex(params.hex);
4638 | } else if (params.date !== undefined) {
4639 | this.setByDate(params.date);
4640 | }
4641 | }
4642 | };
4643 | YAHOO.lang.extend(KJUR.asn1.DERUTCTime, KJUR.asn1.DERAbstractTime);
4644 |
4645 | // ********************************************************************
4646 | /**
4647 | * class for ASN.1 DER GeneralizedTime
4648 | * @name KJUR.asn1.DERGeneralizedTime
4649 | * @class class for ASN.1 DER GeneralizedTime
4650 | * @param {Array} params associative array of parameters (ex. {'str': '20130430235959Z'})
4651 | * @property {Boolean} withMillis flag to show milliseconds or not
4652 | * @extends KJUR.asn1.DERAbstractTime
4653 | * @description
4654 | *
4655 | * As for argument 'params' for constructor, you can specify one of
4656 | * following properties:
4657 | *
4658 | * - str - specify initial ASN.1 value(V) by a string (ex.'20130430235959Z')
4659 | * - hex - specify initial ASN.1 value(V) by a hexadecimal string
4660 | * - date - specify Date object.
4661 | * - millis - specify flag to show milliseconds (from 1.0.6)
4662 | *
4663 | * NOTE1: 'params' can be omitted.
4664 | * NOTE2: 'withMillis' property is supported from asn1 1.0.6.
4665 | */
4666 | KJUR.asn1.DERGeneralizedTime = function(params) {
4667 | KJUR.asn1.DERGeneralizedTime.superclass.constructor.call(this, params);
4668 | this.hT = "18";
4669 | this.withMillis = false;
4670 |
4671 | /**
4672 | * set value by a Date object
4673 | * @name setByDate
4674 | * @memberOf KJUR.asn1.DERGeneralizedTime#
4675 | * @function
4676 | * @param {Date} dateObject Date object to set ASN.1 value(V)
4677 | * @example
4678 | * When you specify UTC time, use 'Date.UTC' method like this:
4679 | * o1 = new DERUTCTime();
4680 | * o1.setByDate(date);
4681 | *
4682 | * date = new Date(Date.UTC(2015, 0, 31, 23, 59, 59, 0)); #2015JAN31 23:59:59
4683 | */
4684 | this.setByDate = function(dateObject) {
4685 | this.hTLV = null;
4686 | this.isModified = true;
4687 | this.date = dateObject;
4688 | this.s = this.formatDate(this.date, 'gen', this.withMillis);
4689 | this.hV = stohex(this.s);
4690 | };
4691 |
4692 | this.getFreshValueHex = function() {
4693 | if (this.date === undefined && this.s === undefined) {
4694 | this.date = new Date();
4695 | this.s = this.formatDate(this.date, 'gen', this.withMillis);
4696 | this.hV = stohex(this.s);
4697 | }
4698 | return this.hV;
4699 | };
4700 |
4701 | if (params !== undefined) {
4702 | if (params.str !== undefined) {
4703 | this.setString(params.str);
4704 | } else if (typeof params == "string" && params.match(/^[0-9]{14}Z$/)) {
4705 | this.setString(params);
4706 | } else if (params.hex !== undefined) {
4707 | this.setStringHex(params.hex);
4708 | } else if (params.date !== undefined) {
4709 | this.setByDate(params.date);
4710 | }
4711 | if (params.millis === true) {
4712 | this.withMillis = true;
4713 | }
4714 | }
4715 | };
4716 | YAHOO.lang.extend(KJUR.asn1.DERGeneralizedTime, KJUR.asn1.DERAbstractTime);
4717 |
4718 | // ********************************************************************
4719 | /**
4720 | * class for ASN.1 DER Sequence
4721 | * @name KJUR.asn1.DERSequence
4722 | * @class class for ASN.1 DER Sequence
4723 | * @extends KJUR.asn1.DERAbstractStructured
4724 | * @description
4725 | *
4726 | * As for argument 'params' for constructor, you can specify one of
4727 | * following properties:
4728 | *
4729 | * - array - specify array of ASN1Object to set elements of content
4730 | *
4731 | * NOTE: 'params' can be omitted.
4732 | */
4733 | KJUR.asn1.DERSequence = function(params) {
4734 | KJUR.asn1.DERSequence.superclass.constructor.call(this, params);
4735 | this.hT = "30";
4736 | this.getFreshValueHex = function() {
4737 | var h = '';
4738 | for (var i = 0; i < this.asn1Array.length; i++) {
4739 | var asn1Obj = this.asn1Array[i];
4740 | h += asn1Obj.getEncodedHex();
4741 | }
4742 | this.hV = h;
4743 | return this.hV;
4744 | };
4745 | };
4746 | YAHOO.lang.extend(KJUR.asn1.DERSequence, KJUR.asn1.DERAbstractStructured);
4747 |
4748 | // ********************************************************************
4749 | /**
4750 | * class for ASN.1 DER Set
4751 | * @name KJUR.asn1.DERSet
4752 | * @class class for ASN.1 DER Set
4753 | * @extends KJUR.asn1.DERAbstractStructured
4754 | * @description
4755 | *
4756 | * As for argument 'params' for constructor, you can specify one of
4757 | * following properties:
4758 | *
4759 | * - array - specify array of ASN1Object to set elements of content
4760 | * - sortflag - flag for sort (default: true). ASN.1 BER is not sorted in 'SET OF'.
4761 | *
4762 | * NOTE1: 'params' can be omitted.
4763 | * NOTE2: sortflag is supported since 1.0.5.
4764 | */
4765 | KJUR.asn1.DERSet = function(params) {
4766 | KJUR.asn1.DERSet.superclass.constructor.call(this, params);
4767 | this.hT = "31";
4768 | this.sortFlag = true; // item shall be sorted only in ASN.1 DER
4769 | this.getFreshValueHex = function() {
4770 | var a = new Array();
4771 | for (var i = 0; i < this.asn1Array.length; i++) {
4772 | var asn1Obj = this.asn1Array[i];
4773 | a.push(asn1Obj.getEncodedHex());
4774 | }
4775 | if (this.sortFlag == true) a.sort();
4776 | this.hV = a.join('');
4777 | return this.hV;
4778 | };
4779 |
4780 | if (typeof params != "undefined") {
4781 | if (typeof params.sortflag != "undefined" &&
4782 | params.sortflag == false)
4783 | this.sortFlag = false;
4784 | }
4785 | };
4786 | YAHOO.lang.extend(KJUR.asn1.DERSet, KJUR.asn1.DERAbstractStructured);
4787 |
4788 | // ********************************************************************
4789 | /**
4790 | * class for ASN.1 DER TaggedObject
4791 | * @name KJUR.asn1.DERTaggedObject
4792 | * @class class for ASN.1 DER TaggedObject
4793 | * @extends KJUR.asn1.ASN1Object
4794 | * @description
4795 | *
4796 | * Parameter 'tagNoNex' is ASN.1 tag(T) value for this object.
4797 | * For example, if you find '[1]' tag in a ASN.1 dump,
4798 | * 'tagNoHex' will be 'a1'.
4799 | *
4800 | * As for optional argument 'params' for constructor, you can specify *ANY* of
4801 | * following properties:
4802 | *
4803 | * - explicit - specify true if this is explicit tag otherwise false
4804 | * (default is 'true').
4805 | * - tag - specify tag (default is 'a0' which means [0])
4806 | * - obj - specify ASN1Object which is tagged
4807 | *
4808 | * @example
4809 | * d1 = new KJUR.asn1.DERUTF8String({'str':'a'});
4810 | * d2 = new KJUR.asn1.DERTaggedObject({'obj': d1});
4811 | * hex = d2.getEncodedHex();
4812 | */
4813 | KJUR.asn1.DERTaggedObject = function(params) {
4814 | KJUR.asn1.DERTaggedObject.superclass.constructor.call(this);
4815 | this.hT = "a0";
4816 | this.hV = '';
4817 | this.isExplicit = true;
4818 | this.asn1Object = null;
4819 |
4820 | /**
4821 | * set value by an ASN1Object
4822 | * @name setString
4823 | * @memberOf KJUR.asn1.DERTaggedObject#
4824 | * @function
4825 | * @param {Boolean} isExplicitFlag flag for explicit/implicit tag
4826 | * @param {Integer} tagNoHex hexadecimal string of ASN.1 tag
4827 | * @param {ASN1Object} asn1Object ASN.1 to encapsulate
4828 | */
4829 | this.setASN1Object = function(isExplicitFlag, tagNoHex, asn1Object) {
4830 | this.hT = tagNoHex;
4831 | this.isExplicit = isExplicitFlag;
4832 | this.asn1Object = asn1Object;
4833 | if (this.isExplicit) {
4834 | this.hV = this.asn1Object.getEncodedHex();
4835 | this.hTLV = null;
4836 | this.isModified = true;
4837 | } else {
4838 | this.hV = null;
4839 | this.hTLV = asn1Object.getEncodedHex();
4840 | this.hTLV = this.hTLV.replace(/^../, tagNoHex);
4841 | this.isModified = false;
4842 | }
4843 | };
4844 |
4845 | this.getFreshValueHex = function() {
4846 | return this.hV;
4847 | };
4848 |
4849 | if (typeof params != "undefined") {
4850 | if (typeof params['tag'] != "undefined") {
4851 | this.hT = params['tag'];
4852 | }
4853 | if (typeof params['explicit'] != "undefined") {
4854 | this.isExplicit = params['explicit'];
4855 | }
4856 | if (typeof params['obj'] != "undefined") {
4857 | this.asn1Object = params['obj'];
4858 | this.setASN1Object(this.isExplicit, this.hT, this.asn1Object);
4859 | }
4860 | }
4861 | };
4862 | YAHOO.lang.extend(KJUR.asn1.DERTaggedObject, KJUR.asn1.ASN1Object);
4863 |
4864 | /**
4865 | * Create a new JSEncryptRSAKey that extends Tom Wu's RSA key object.
4866 | * This object is just a decorator for parsing the key parameter
4867 | * @param {string|Object} key - The key in string format, or an object containing
4868 | * the parameters needed to build a RSAKey object.
4869 | * @constructor
4870 | */
4871 | var JSEncryptRSAKey = /** @class */ (function (_super) {
4872 | __extends(JSEncryptRSAKey, _super);
4873 | function JSEncryptRSAKey(key) {
4874 | var _this = _super.call(this) || this;
4875 | // Call the super constructor.
4876 | // RSAKey.call(this);
4877 | // If a key key was provided.
4878 | if (key) {
4879 | // If this is a string...
4880 | if (typeof key === "string") {
4881 | _this.parseKey(key);
4882 | }
4883 | else if (JSEncryptRSAKey.hasPrivateKeyProperty(key) ||
4884 | JSEncryptRSAKey.hasPublicKeyProperty(key)) {
4885 | // Set the values for the key.
4886 | _this.parsePropertiesFrom(key);
4887 | }
4888 | }
4889 | return _this;
4890 | }
4891 | /**
4892 | * Method to parse a pem encoded string containing both a public or private key.
4893 | * The method will translate the pem encoded string in a der encoded string and
4894 | * will parse private key and public key parameters. This method accepts public key
4895 | * in the rsaencryption pkcs #1 format (oid: 1.2.840.113549.1.1.1).
4896 | *
4897 | * @todo Check how many rsa formats use the same format of pkcs #1.
4898 | *
4899 | * The format is defined as:
4900 | * PublicKeyInfo ::= SEQUENCE {
4901 | * algorithm AlgorithmIdentifier,
4902 | * PublicKey BIT STRING
4903 | * }
4904 | * Where AlgorithmIdentifier is:
4905 | * AlgorithmIdentifier ::= SEQUENCE {
4906 | * algorithm OBJECT IDENTIFIER, the OID of the enc algorithm
4907 | * parameters ANY DEFINED BY algorithm OPTIONAL (NULL for PKCS #1)
4908 | * }
4909 | * and PublicKey is a SEQUENCE encapsulated in a BIT STRING
4910 | * RSAPublicKey ::= SEQUENCE {
4911 | * modulus INTEGER, -- n
4912 | * publicExponent INTEGER -- e
4913 | * }
4914 | * it's possible to examine the structure of the keys obtained from openssl using
4915 | * an asn.1 dumper as the one used here to parse the components: http://lapo.it/asn1js/
4916 | * @argument {string} pem the pem encoded string, can include the BEGIN/END header/footer
4917 | * @private
4918 | */
4919 | JSEncryptRSAKey.prototype.parseKey = function (pem) {
4920 | try {
4921 | var modulus = 0;
4922 | var public_exponent = 0;
4923 | var reHex = /^\s*(?:[0-9A-Fa-f][0-9A-Fa-f]\s*)+$/;
4924 | var der = reHex.test(pem) ? Hex.decode(pem) : Base64.unarmor(pem);
4925 | var asn1 = ASN1.decode(der);
4926 | // Fixes a bug with OpenSSL 1.0+ private keys
4927 | if (asn1.sub.length === 3) {
4928 | asn1 = asn1.sub[2].sub[0];
4929 | }
4930 | if (asn1.sub.length === 9) {
4931 | // Parse the private key.
4932 | modulus = asn1.sub[1].getHexStringValue(); // bigint
4933 | this.n = parseBigInt(modulus, 16);
4934 | public_exponent = asn1.sub[2].getHexStringValue(); // int
4935 | this.e = parseInt(public_exponent, 16);
4936 | var private_exponent = asn1.sub[3].getHexStringValue(); // bigint
4937 | this.d = parseBigInt(private_exponent, 16);
4938 | var prime1 = asn1.sub[4].getHexStringValue(); // bigint
4939 | this.p = parseBigInt(prime1, 16);
4940 | var prime2 = asn1.sub[5].getHexStringValue(); // bigint
4941 | this.q = parseBigInt(prime2, 16);
4942 | var exponent1 = asn1.sub[6].getHexStringValue(); // bigint
4943 | this.dmp1 = parseBigInt(exponent1, 16);
4944 | var exponent2 = asn1.sub[7].getHexStringValue(); // bigint
4945 | this.dmq1 = parseBigInt(exponent2, 16);
4946 | var coefficient = asn1.sub[8].getHexStringValue(); // bigint
4947 | this.coeff = parseBigInt(coefficient, 16);
4948 | }
4949 | else if (asn1.sub.length === 2) {
4950 | // Parse the public key.
4951 | var bit_string = asn1.sub[1];
4952 | var sequence = bit_string.sub[0];
4953 | modulus = sequence.sub[0].getHexStringValue();
4954 | this.n = parseBigInt(modulus, 16);
4955 | public_exponent = sequence.sub[1].getHexStringValue();
4956 | this.e = parseInt(public_exponent, 16);
4957 | }
4958 | else {
4959 | return false;
4960 | }
4961 | return true;
4962 | }
4963 | catch (ex) {
4964 | return false;
4965 | }
4966 | };
4967 | /**
4968 | * Translate rsa parameters in a hex encoded string representing the rsa key.
4969 | *
4970 | * The translation follow the ASN.1 notation :
4971 | * RSAPrivateKey ::= SEQUENCE {
4972 | * version Version,
4973 | * modulus INTEGER, -- n
4974 | * publicExponent INTEGER, -- e
4975 | * privateExponent INTEGER, -- d
4976 | * prime1 INTEGER, -- p
4977 | * prime2 INTEGER, -- q
4978 | * exponent1 INTEGER, -- d mod (p1)
4979 | * exponent2 INTEGER, -- d mod (q-1)
4980 | * coefficient INTEGER, -- (inverse of q) mod p
4981 | * }
4982 | * @returns {string} DER Encoded String representing the rsa private key
4983 | * @private
4984 | */
4985 | JSEncryptRSAKey.prototype.getPrivateBaseKey = function () {
4986 | var options = {
4987 | array: [
4988 | new KJUR.asn1.DERInteger({ int: 0 }),
4989 | new KJUR.asn1.DERInteger({ bigint: this.n }),
4990 | new KJUR.asn1.DERInteger({ int: this.e }),
4991 | new KJUR.asn1.DERInteger({ bigint: this.d }),
4992 | new KJUR.asn1.DERInteger({ bigint: this.p }),
4993 | new KJUR.asn1.DERInteger({ bigint: this.q }),
4994 | new KJUR.asn1.DERInteger({ bigint: this.dmp1 }),
4995 | new KJUR.asn1.DERInteger({ bigint: this.dmq1 }),
4996 | new KJUR.asn1.DERInteger({ bigint: this.coeff })
4997 | ]
4998 | };
4999 | var seq = new KJUR.asn1.DERSequence(options);
5000 | return seq.getEncodedHex();
5001 | };
5002 | /**
5003 | * base64 (pem) encoded version of the DER encoded representation
5004 | * @returns {string} pem encoded representation without header and footer
5005 | * @public
5006 | */
5007 | JSEncryptRSAKey.prototype.getPrivateBaseKeyB64 = function () {
5008 | return hex2b64(this.getPrivateBaseKey());
5009 | };
5010 | /**
5011 | * Translate rsa parameters in a hex encoded string representing the rsa public key.
5012 | * The representation follow the ASN.1 notation :
5013 | * PublicKeyInfo ::= SEQUENCE {
5014 | * algorithm AlgorithmIdentifier,
5015 | * PublicKey BIT STRING
5016 | * }
5017 | * Where AlgorithmIdentifier is:
5018 | * AlgorithmIdentifier ::= SEQUENCE {
5019 | * algorithm OBJECT IDENTIFIER, the OID of the enc algorithm
5020 | * parameters ANY DEFINED BY algorithm OPTIONAL (NULL for PKCS #1)
5021 | * }
5022 | * and PublicKey is a SEQUENCE encapsulated in a BIT STRING
5023 | * RSAPublicKey ::= SEQUENCE {
5024 | * modulus INTEGER, -- n
5025 | * publicExponent INTEGER -- e
5026 | * }
5027 | * @returns {string} DER Encoded String representing the rsa public key
5028 | * @private
5029 | */
5030 | JSEncryptRSAKey.prototype.getPublicBaseKey = function () {
5031 | var first_sequence = new KJUR.asn1.DERSequence({
5032 | array: [
5033 | new KJUR.asn1.DERObjectIdentifier({ oid: "1.2.840.113549.1.1.1" }),
5034 | new KJUR.asn1.DERNull()
5035 | ]
5036 | });
5037 | var second_sequence = new KJUR.asn1.DERSequence({
5038 | array: [
5039 | new KJUR.asn1.DERInteger({ bigint: this.n }),
5040 | new KJUR.asn1.DERInteger({ int: this.e })
5041 | ]
5042 | });
5043 | var bit_string = new KJUR.asn1.DERBitString({
5044 | hex: "00" + second_sequence.getEncodedHex()
5045 | });
5046 | var seq = new KJUR.asn1.DERSequence({
5047 | array: [
5048 | first_sequence,
5049 | bit_string
5050 | ]
5051 | });
5052 | return seq.getEncodedHex();
5053 | };
5054 | /**
5055 | * base64 (pem) encoded version of the DER encoded representation
5056 | * @returns {string} pem encoded representation without header and footer
5057 | * @public
5058 | */
5059 | JSEncryptRSAKey.prototype.getPublicBaseKeyB64 = function () {
5060 | return hex2b64(this.getPublicBaseKey());
5061 | };
5062 | /**
5063 | * wrap the string in block of width chars. The default value for rsa keys is 64
5064 | * characters.
5065 | * @param {string} str the pem encoded string without header and footer
5066 | * @param {Number} [width=64] - the length the string has to be wrapped at
5067 | * @returns {string}
5068 | * @private
5069 | */
5070 | JSEncryptRSAKey.wordwrap = function (str, width) {
5071 | width = width || 64;
5072 | if (!str) {
5073 | return str;
5074 | }
5075 | var regex = "(.{1," + width + "})( +|$\n?)|(.{1," + width + "})";
5076 | return str.match(RegExp(regex, "g")).join("\n");
5077 | };
5078 | /**
5079 | * Retrieve the pem encoded private key
5080 | * @returns {string} the pem encoded private key with header/footer
5081 | * @public
5082 | */
5083 | JSEncryptRSAKey.prototype.getPrivateKey = function () {
5084 | var key = "-----BEGIN RSA PRIVATE KEY-----\n";
5085 | key += JSEncryptRSAKey.wordwrap(this.getPrivateBaseKeyB64()) + "\n";
5086 | key += "-----END RSA PRIVATE KEY-----";
5087 | return key;
5088 | };
5089 | /**
5090 | * Retrieve the pem encoded public key
5091 | * @returns {string} the pem encoded public key with header/footer
5092 | * @public
5093 | */
5094 | JSEncryptRSAKey.prototype.getPublicKey = function () {
5095 | var key = "-----BEGIN PUBLIC KEY-----\n";
5096 | key += JSEncryptRSAKey.wordwrap(this.getPublicBaseKeyB64()) + "\n";
5097 | key += "-----END PUBLIC KEY-----";
5098 | return key;
5099 | };
5100 | /**
5101 | * Check if the object contains the necessary parameters to populate the rsa modulus
5102 | * and public exponent parameters.
5103 | * @param {Object} [obj={}] - An object that may contain the two public key
5104 | * parameters
5105 | * @returns {boolean} true if the object contains both the modulus and the public exponent
5106 | * properties (n and e)
5107 | * @todo check for types of n and e. N should be a parseable bigInt object, E should
5108 | * be a parseable integer number
5109 | * @private
5110 | */
5111 | JSEncryptRSAKey.hasPublicKeyProperty = function (obj) {
5112 | obj = obj || {};
5113 | return (obj.hasOwnProperty("n") &&
5114 | obj.hasOwnProperty("e"));
5115 | };
5116 | /**
5117 | * Check if the object contains ALL the parameters of an RSA key.
5118 | * @param {Object} [obj={}] - An object that may contain nine rsa key
5119 | * parameters
5120 | * @returns {boolean} true if the object contains all the parameters needed
5121 | * @todo check for types of the parameters all the parameters but the public exponent
5122 | * should be parseable bigint objects, the public exponent should be a parseable integer number
5123 | * @private
5124 | */
5125 | JSEncryptRSAKey.hasPrivateKeyProperty = function (obj) {
5126 | obj = obj || {};
5127 | return (obj.hasOwnProperty("n") &&
5128 | obj.hasOwnProperty("e") &&
5129 | obj.hasOwnProperty("d") &&
5130 | obj.hasOwnProperty("p") &&
5131 | obj.hasOwnProperty("q") &&
5132 | obj.hasOwnProperty("dmp1") &&
5133 | obj.hasOwnProperty("dmq1") &&
5134 | obj.hasOwnProperty("coeff"));
5135 | };
5136 | /**
5137 | * Parse the properties of obj in the current rsa object. Obj should AT LEAST
5138 | * include the modulus and public exponent (n, e) parameters.
5139 | * @param {Object} obj - the object containing rsa parameters
5140 | * @private
5141 | */
5142 | JSEncryptRSAKey.prototype.parsePropertiesFrom = function (obj) {
5143 | this.n = obj.n;
5144 | this.e = obj.e;
5145 | if (obj.hasOwnProperty("d")) {
5146 | this.d = obj.d;
5147 | this.p = obj.p;
5148 | this.q = obj.q;
5149 | this.dmp1 = obj.dmp1;
5150 | this.dmq1 = obj.dmq1;
5151 | this.coeff = obj.coeff;
5152 | }
5153 | };
5154 | return JSEncryptRSAKey;
5155 | }(RSAKey));
5156 |
5157 | /**
5158 | *
5159 | * @param {Object} [options = {}] - An object to customize JSEncrypt behaviour
5160 | * possible parameters are:
5161 | * - default_key_size {number} default: 1024 the key size in bit
5162 | * - default_public_exponent {string} default: '010001' the hexadecimal representation of the public exponent
5163 | * - log {boolean} default: false whether log warn/error or not
5164 | * @constructor
5165 | */
5166 | var JSEncrypt = /** @class */ (function () {
5167 | function JSEncrypt(options) {
5168 | options = options || {};
5169 | this.default_key_size = parseInt(options.default_key_size, 10) || 1024;
5170 | this.default_public_exponent = options.default_public_exponent || "010001"; // 65537 default openssl public exponent for rsa key type
5171 | this.log = options.log || false;
5172 | // The private and public key.
5173 | this.key = null;
5174 | }
5175 | /**
5176 | * Method to set the rsa key parameter (one method is enough to set both the public
5177 | * and the private key, since the private key contains the public key paramenters)
5178 | * Log a warning if logs are enabled
5179 | * @param {Object|string} key the pem encoded string or an object (with or without header/footer)
5180 | * @public
5181 | */
5182 | JSEncrypt.prototype.setKey = function (key) {
5183 | if (this.log && this.key) {
5184 | console.warn("A key was already set, overriding existing.");
5185 | }
5186 | this.key = new JSEncryptRSAKey(key);
5187 | };
5188 | /**
5189 | * Proxy method for setKey, for api compatibility
5190 | * @see setKey
5191 | * @public
5192 | */
5193 | JSEncrypt.prototype.setPrivateKey = function (privkey) {
5194 | // Create the key.
5195 | this.setKey(privkey);
5196 | };
5197 | /**
5198 | * Proxy method for setKey, for api compatibility
5199 | * @see setKey
5200 | * @public
5201 | */
5202 | JSEncrypt.prototype.setPublicKey = function (pubkey) {
5203 | // Sets the public key.
5204 | this.setKey(pubkey);
5205 | };
5206 | /**
5207 | * Proxy method for RSAKey object's decrypt, decrypt the string using the private
5208 | * components of the rsa key object. Note that if the object was not set will be created
5209 | * on the fly (by the getKey method) using the parameters passed in the JSEncrypt constructor
5210 | * @param {string} str base64 encoded crypted string to decrypt
5211 | * @return {string} the decrypted string
5212 | * @public
5213 | */
5214 | JSEncrypt.prototype.decrypt = function (str) {
5215 | // Return the decrypted string.
5216 | try {
5217 | return this.getKey().decrypt(b64tohex(str));
5218 | }
5219 | catch (ex) {
5220 | return false;
5221 | }
5222 | };
5223 | /**
5224 | * Proxy method for RSAKey object's encrypt, encrypt the string using the public
5225 | * components of the rsa key object. Note that if the object was not set will be created
5226 | * on the fly (by the getKey method) using the parameters passed in the JSEncrypt constructor
5227 | * @param {string} str the string to encrypt
5228 | * @return {string} the encrypted string encoded in base64
5229 | * @public
5230 | */
5231 | JSEncrypt.prototype.encrypt = function (str) {
5232 | // Return the encrypted string.
5233 | try {
5234 | return hex2b64(this.getKey().encrypt(str));
5235 | }
5236 | catch (ex) {
5237 | return false;
5238 | }
5239 | };
5240 | /**
5241 | * Proxy method for RSAKey object's sign.
5242 | * @param {string} str the string to sign
5243 | * @param {function} digestMethod hash method
5244 | * @param {string} digestName the name of the hash algorithm
5245 | * @return {string} the signature encoded in base64
5246 | * @public
5247 | */
5248 | JSEncrypt.prototype.sign = function (str, digestMethod, digestName) {
5249 | // return the RSA signature of 'str' in 'hex' format.
5250 | try {
5251 | return hex2b64(this.getKey().sign(str, digestMethod, digestName));
5252 | }
5253 | catch (ex) {
5254 | return false;
5255 | }
5256 | };
5257 | /**
5258 | * Proxy method for RSAKey object's verify.
5259 | * @param {string} str the string to verify
5260 | * @param {string} signature the signature encoded in base64 to compare the string to
5261 | * @param {function} digestMethod hash method
5262 | * @return {boolean} whether the data and signature match
5263 | * @public
5264 | */
5265 | JSEncrypt.prototype.verify = function (str, signature, digestMethod) {
5266 | // Return the decrypted 'digest' of the signature.
5267 | try {
5268 | return this.getKey().verify(str, b64tohex(signature), digestMethod);
5269 | }
5270 | catch (ex) {
5271 | return false;
5272 | }
5273 | };
5274 | /**
5275 | * Getter for the current JSEncryptRSAKey object. If it doesn't exists a new object
5276 | * will be created and returned
5277 | * @param {callback} [cb] the callback to be called if we want the key to be generated
5278 | * in an async fashion
5279 | * @returns {JSEncryptRSAKey} the JSEncryptRSAKey object
5280 | * @public
5281 | */
5282 | JSEncrypt.prototype.getKey = function (cb) {
5283 | // Only create new if it does not exist.
5284 | if (!this.key) {
5285 | // Get a new private key.
5286 | this.key = new JSEncryptRSAKey();
5287 | if (cb && {}.toString.call(cb) === "[object Function]") {
5288 | this.key.generateAsync(this.default_key_size, this.default_public_exponent, cb);
5289 | return;
5290 | }
5291 | // Generate the key.
5292 | this.key.generate(this.default_key_size, this.default_public_exponent);
5293 | }
5294 | return this.key;
5295 | };
5296 | /**
5297 | * Returns the pem encoded representation of the private key
5298 | * If the key doesn't exists a new key will be created
5299 | * @returns {string} pem encoded representation of the private key WITH header and footer
5300 | * @public
5301 | */
5302 | JSEncrypt.prototype.getPrivateKey = function () {
5303 | // Return the private representation of this key.
5304 | return this.getKey().getPrivateKey();
5305 | };
5306 | /**
5307 | * Returns the pem encoded representation of the private key
5308 | * If the key doesn't exists a new key will be created
5309 | * @returns {string} pem encoded representation of the private key WITHOUT header and footer
5310 | * @public
5311 | */
5312 | JSEncrypt.prototype.getPrivateKeyB64 = function () {
5313 | // Return the private representation of this key.
5314 | return this.getKey().getPrivateBaseKeyB64();
5315 | };
5316 | /**
5317 | * Returns the pem encoded representation of the public key
5318 | * If the key doesn't exists a new key will be created
5319 | * @returns {string} pem encoded representation of the public key WITH header and footer
5320 | * @public
5321 | */
5322 | JSEncrypt.prototype.getPublicKey = function () {
5323 | // Return the private representation of this key.
5324 | return this.getKey().getPublicKey();
5325 | };
5326 | /**
5327 | * Returns the pem encoded representation of the public key
5328 | * If the key doesn't exists a new key will be created
5329 | * @returns {string} pem encoded representation of the public key WITHOUT header and footer
5330 | * @public
5331 | */
5332 | JSEncrypt.prototype.getPublicKeyB64 = function () {
5333 | // Return the private representation of this key.
5334 | return this.getKey().getPublicBaseKeyB64();
5335 | };
5336 | JSEncrypt.version = "3.0.0-rc.1";
5337 | return JSEncrypt;
5338 | }());
5339 |
5340 | window.JSEncrypt = JSEncrypt;
5341 |
5342 | exports.JSEncrypt = JSEncrypt;
5343 | exports.default = JSEncrypt;
5344 |
5345 | Object.defineProperty(exports, '__esModule', { value: true });
5346 |
5347 | })));
5348 |
--------------------------------------------------------------------------------