1 (function(global, factory) {2 typeof exports === ‘object‘ && typeof module !== ‘undefined‘ ?factory(exports) :3 typeof define === ‘function‘ && define.amd ? define([‘exports‘], factory) :4 (factory((global.JSEncrypt ={})));5 }(this, (function (exports) { ‘use strict‘;6
7 var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";8 functionint2char(n) {9 returnBI_RM.charAt(n);10 }11 //#region BIT_OPERATIONS
12 //(public) this & a
13 functionop_and(x, y) {14 return x &y;15 }16 //(public) this | a
17 functionop_or(x, y) {18 return x |y;19 }20 //(public) this ^ a
21 functionop_xor(x, y) {22 return x ^y;23 }24 //(public) this & ~a
25 functionop_andnot(x, y) {26 return x & ~y;27 }28 //return index of lowest 1-bit in x, x < 2^31
29 functionlbit(x) {30 if (x == 0) {31 return -1;32 }33 var r = 0;34 if ((x & 0xffff) == 0) {35 x >>= 16;36 r += 16;37 }38 if ((x & 0xff) == 0) {39 x >>= 8;40 r += 8;41 }42 if ((x & 0xf) == 0) {43 x >>= 4;44 r += 4;45 }46 if ((x & 3) == 0) {47 x >>= 2;48 r += 2;49 }50 if ((x & 1) == 0) {51 ++r;52 }53 returnr;54 }55 //return number of 1 bits in x
56 functioncbit(x) {57 var r = 0;58 while (x != 0) {59 x &= x - 1;60 ++r;61 }62 returnr;63 }64 //#endregion BIT_OPERATIONS
65
66 var b64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";67 var b64pad = "=";68 functionhex2b64(h) {69 vari;70 varc;71 var ret = "";72 for (i = 0; i + 3 <= h.length; i += 3) {73 c = parseInt(h.substring(i, i + 3), 16);74 ret += b64map.charAt(c >> 6) + b64map.charAt(c & 63);75 }76 if (i + 1 ==h.length) {77 c = parseInt(h.substring(i, i + 1), 16);78 ret += b64map.charAt(c << 2);79 }80 else if (i + 2 ==h.length) {81 c = parseInt(h.substring(i, i + 2), 16);82 ret += b64map.charAt(c >> 2) + b64map.charAt((c & 3) << 4);83 }84 while ((ret.length & 3) > 0) {85 ret +=b64pad;86 }87 returnret;88 }89 //convert a base64 string to hex
90 functionb64tohex(s) {91 var ret = "";92 vari;93 var k = 0; //b64 state, 0-3
94 var slop = 0;95 for (i = 0; i < s.length; ++i) {96 if (s.charAt(i) ==b64pad) {97 break;98 }99 var v =b64map.indexOf(s.charAt(i));100 if (v < 0) {101 continue;102 }103 if (k == 0) {104 ret += int2char(v >> 2);105 slop = v & 3;106 k = 1;107 }108 else if (k == 1) {109 ret += int2char((slop << 2) | (v >> 4));110 slop = v & 0xf;111 k = 2;112 }113 else if (k == 2) {114 ret +=int2char(slop);115 ret += int2char(v >> 2);116 slop = v & 3;117 k = 3;118 }119 else{120 ret += int2char((slop << 2) | (v >> 4));121 ret += int2char(v & 0xf);122 k = 0;123 }124 }125 if (k == 1) {126 ret += int2char(slop << 2);127 }128 returnret;129 }130
131 /*! *****************************************************************************132 Copyright (c) Microsoft Corporation. All rights reserved.133 Licensed under the Apache License, Version 2.0 (the "License"); you may not use134 this file except in compliance with the License. You may obtain a copy of the135 License at http://www.apache.org/licenses/LICENSE-2.0136
137 THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY138 KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED139 WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,140 MERCHANTABLITY OR NON-INFRINGEMENT.141
142 See the Apache Version 2.0 License for specific language governing permissions143 and limitations under the License.144 ******************************************************************************/
145 /*global Reflect, Promise*/
146
147 var extendStatics = function(d, b) {148 extendStatics = Object.setPrototypeOf ||
149 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
150 function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] =b[p]; };151 returnextendStatics(d, b);152 };153
154 function__extends(d, b) {155 extendStatics(d, b);156 function __() { this.constructor =d; }157 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new__());158 }159
160 //Hex JavaScript decoder
161 //Copyright (c) 2008-2013 Lapo Luchini
162 //Permission to use, copy, modify, and/or distribute this software for any
163 //purpose with or without fee is hereby granted, provided that the above
164 //copyright notice and this permission notice appear in all copies.
165 //166 //THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
167 //WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
168 //MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
169 //ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
170 //WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
171 //ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
172 //OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
173 /*jshint browser: true, strict: true, immed: true, latedef: true, undef: true, regexdash: false*/
174 vardecoder;175 var Hex ={176 decode: function(a) {177 vari;178 if (decoder ===undefined) {179 var hex = "0123456789ABCDEF";180 var ignore = " \f\n\r\t\u00A0\u2028\u2029";181 decoder ={};182 for (i = 0; i < 16; ++i) {183 decoder[hex.charAt(i)] =i;184 }185 hex =hex.toLowerCase();186 for (i = 10; i < 16; ++i) {187 decoder[hex.charAt(i)] =i;188 }189 for (i = 0; i < ignore.length; ++i) {190 decoder[ignore.charAt(i)] = -1;191 }192 }193 var out =[];194 var bits = 0;195 var char_count = 0;196 for (i = 0; i < a.length; ++i) {197 var c =a.charAt(i);198 if (c == "=") {199 break;200 }201 c =decoder[c];202 if (c == -1) {203 continue;204 }205 if (c ===undefined) {206 throw new Error("Illegal character at offset " +i);207 }208 bits |=c;209 if (++char_count >= 2) {210 out[out.length] =bits;211 bits = 0;212 char_count = 0;213 }214 else{215 bits <<= 4;216 }217 }218 if(char_count) {219 throw new Error("Hex encoding incomplete: 4 bits missing");220 }221 returnout;222 }223 };224
225 //Base64 JavaScript decoder
226 //Copyright (c) 2008-2013 Lapo Luchini
227 //Permission to use, copy, modify, and/or distribute this software for any
228 //purpose with or without fee is hereby granted, provided that the above
229 //copyright notice and this permission notice appear in all copies.
230 //231 //THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
232 //WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
233 //MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
234 //ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
235 //WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
236 //ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
237 //OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
238 /*jshint browser: true, strict: true, immed: true, latedef: true, undef: true, regexdash: false*/
239 var decoder$1;240 var Base64 ={241 decode: function(a) {242 vari;243 if (decoder$1 ===undefined) {244 var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";245 var ignore = "= \f\n\r\t\u00A0\u2028\u2029";246 decoder$1 = Object.create(null);247 for (i = 0; i < 64; ++i) {248 decoder$1[b64.charAt(i)] =i;249 }250 for (i = 0; i < ignore.length; ++i) {251 decoder$1[ignore.charAt(i)] = -1;252 }253 }254 var out =[];255 var bits = 0;256 var char_count = 0;257 for (i = 0; i < a.length; ++i) {258 var c =a.charAt(i);259 if (c == "=") {260 break;261 }262 c = decoder$1[c];263 if (c == -1) {264 continue;265 }266 if (c ===undefined) {267 throw new Error("Illegal character at offset " +i);268 }269 bits |=c;270 if (++char_count >= 4) {271 out[out.length] = (bits >> 16);272 out[out.length] = (bits >> 8) & 0xFF;273 out[out.length] = bits & 0xFF;274 bits = 0;275 char_count = 0;276 }277 else{278 bits <<= 6;279 }280 }281 switch(char_count) {282 case 1:283 throw new Error("Base64 encoding incomplete: at least 2 bits missing");284 case 2:285 out[out.length] = (bits >> 10);286 break;287 case 3:288 out[out.length] = (bits >> 16);289 out[out.length] = (bits >> 8) & 0xFF;290 break;291 }292 returnout;293 },294 re: /-----BEGIN [^-]+-----([A-Za-z0-9+\/=\s]+)-----END [^-]+-----|begin-base64[^\n]+\n([A-Za-z0-9+\/=\s]+)====/,295 unarmor: function(a) {296 var m =Base64.re.exec(a);297 if(m) {298 if (m[1]) {299 a = m[1];300 }301 else if (m[2]) {302 a = m[2];303 }304 else{305 throw new Error("RegExp out of sync");306 }307 }308 returnBase64.decode(a);309 }310 };311
312 //Big integer base-10 printing library
313 //Copyright (c) 2014 Lapo Luchini
314 //Permission to use, copy, modify, and/or distribute this software for any
315 //purpose with or without fee is hereby granted, provided that the above
316 //copyright notice and this permission notice appear in all copies.
317 //318 //THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
319 //WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
320 //MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
321 //ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
322 //WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
323 //ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
324 //OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
325 /*jshint browser: true, strict: true, immed: true, latedef: true, undef: true, regexdash: false*/
326 var max = 10000000000000; //biggest integer that can still fit 2^53 when multiplied by 256
327 var Int10 = /** @class*/ (function() {328 functionInt10(value) {329 this.buf = [+value || 0];330 }331 Int10.prototype.mulAdd = function(m, c) {332 //assert(m <= 256)
333 var b = this.buf;334 var l =b.length;335 vari;336 vart;337 for (i = 0; i < l; ++i) {338 t = b[i] * m +c;339 if (t 0) {349 b[i] =c;350 }351 };352 Int10.prototype.sub = function(c) {353 //assert(m <= 256)
354 var b = this.buf;355 var l =b.length;356 vari;357 vart;358 for (i = 0; i < l; ++i) {359 t = b[i] -c;360 if (t < 0) {361 t +=max;362 c = 1;363 }364 else{365 c = 0;366 }367 b[i] =t;368 }369 while (b[b.length - 1] === 0) {370 b.pop();371 }372 };373 Int10.prototype.toString = function(base) {374 if ((base || 10) != 10) {375 throw new Error("only base 10 is supported");376 }377 var b = this.buf;378 var s = b[b.length - 1].toString();379 for (var i = b.length - 2; i >= 0; --i) {380 s += (max + b[i]).toString().substring(1);381 }382 returns;383 };384 Int10.prototype.valueOf = function() {385 var b = this.buf;386 var v = 0;387 for (var i = b.length - 1; i >= 0; --i) {388 v = v * max +b[i];389 }390 returnv;391 };392 Int10.prototype.simplify = function() {393 var b = this.buf;394 return (b.length == 1) ? b[0] : this;395 };396 returnInt10;397 }());398
399 //ASN.1 JavaScript decoder
400 var ellipsis = "\u2026";401 var reTimeS = /^(\d\d)(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])([01]\d|2[0-3])(?:([0-5]\d)(?:([0-5]\d)(?:[.,](\d{1,3}))?)?)?(Z|[-+](?:[0]\d|1[0-2])([0-5]\d)?)?$/;402 var reTimeL = /^(\d\d\d\d)(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])([01]\d|2[0-3])(?:([0-5]\d)(?:([0-5]\d)(?:[.,](\d{1,3}))?)?)?(Z|[-+](?:[0]\d|1[0-2])([0-5]\d)?)?$/;403 functionstringCut(str, len) {404 if (str.length >len) {405 str = str.substring(0, len) +ellipsis;406 }407 returnstr;408 }409 var Stream = /** @class*/ (function() {410 functionStream(enc, pos) {411 this.hexDigits = "0123456789ABCDEF";412 if (enc instanceofStream) {413 this.enc =enc.enc;414 this.pos =enc.pos;415 }416 else{417 //enc should be an array or a binary string
418 this.enc =enc;419 this.pos =pos;420 }421 }422 Stream.prototype.get = function(pos) {423 if (pos ===undefined) {424 pos = this.pos++;425 }426 if (pos >= this.enc.length) {427 throw new Error("Requesting byte offset " + pos + " on a stream of length " + this.enc.length);428 }429 return ("string" === typeof this.enc) ? this.enc.charCodeAt(pos) : this.enc[pos];430 };431 Stream.prototype.hexByte = function(b) {432 return this.hexDigits.charAt((b >> 4) & 0xF) + this.hexDigits.charAt(b & 0xF);433 };434 Stream.prototype.hexDump = function(start, end, raw) {435 var s = "";436 for (var i = start; i < end; ++i) {437 s += this.hexByte(this.get(i));438 if (raw !== true) {439 switch (i & 0xF) {440 case 0x7:441 s += " ";442 break;443 case 0xF:444 s += "\n";445 break;446 default:447 s += " ";448 }449 }450 }451 returns;452 };453 Stream.prototype.isASCII = function(start, end) {454 for (var i = start; i < end; ++i) {455 var c = this.get(i);456 if (c < 32 || c > 176) {457 return false;458 }459 }460 return true;461 };462 Stream.prototype.parseStringISO = function(start, end) {463 var s = "";464 for (var i = start; i < end; ++i) {465 s += String.fromCharCode(this.get(i));466 }467 returns;468 };469 Stream.prototype.parseStringUTF = function(start, end) {470 var s = "";471 for (var i = start; i 191) && (c < 224)) {477 s += String.fromCharCode(((c & 0x1F) << 6) | (this.get(i++) & 0x3F));478 }479 else{480 s += String.fromCharCode(((c & 0x0F) << 12) | ((this.get(i++) & 0x3F) << 6) | (this.get(i++) & 0x3F));481 }482 }483 returns;484 };485 Stream.prototype.parseStringBMP = function(start, end) {486 var str = "";487 varhi;488 varlo;489 for (var i = start; i
504 //it will conform with ITU X.400 [-10, +40] sliding window until 2030
505 m[1] = +m[1];506 m[1] += (+m[1] < 70) ? 2000 : 1900;507 }508 s = m[1] + "-" + m[2] + "-" + m[3] + " " + m[4];509 if (m[5]) {510 s += ":" + m[5];511 if (m[6]) {512 s += ":" + m[6];513 if (m[7]) {514 s += "." + m[7];515 }516 }517 }518 if (m[8]) {519 s += " UTC";520 if (m[8] != "Z") {521 s += m[8];522 if (m[9]) {523 s += ":" + m[9];524 }525 }526 }527 returns;528 };529 Stream.prototype.parseInteger = function(start, end) {530 var v = this.get(start);531 var neg = (v > 127);532 var pad = neg ? 255 : 0;533 varlen;534 var s = "";535 //skip unuseful bits (not allowed in DER)
536 while (v == pad && ++start
544 if (len > 4) {545 s =v;546 len <<= 3;547 while (((+s ^ pad) & 0x80) == 0) {548 s = +s << 1;549 --len;550 }551 s = "(" + len + " bit)\n";552 }553 //decode the integer
554 if(neg) {555 v = v - 256;556 }557 var n = newInt10(v);558 for (var i = start + 1; i < end; ++i) {559 n.mulAdd(256, this.get(i));560 }561 return s +n.toString();562 };563 Stream.prototype.parseBitString = function(start, end, maxLength) {564 var unusedBit = this.get(start);565 var lenBit = ((end - start - 1) << 3) -unusedBit;566 var intro = "(" + lenBit + " bit)\n";567 var s = "";568 for (var i = start + 1; i < end; ++i) {569 var b = this.get(i);570 var skip = (i == end - 1) ? unusedBit : 0;571 for (var j = 7; j >= skip; --j) {572 s += (b >> j) & 1 ? "1" : "0";573 }574 if (s.length >maxLength) {575 return intro +stringCut(s, maxLength);576 }577 }578 return intro +s;579 };580 Stream.prototype.parseOctetString = function(start, end, maxLength) {581 if (this.isASCII(start, end)) {582 return stringCut(this.parseStringISO(start, end), maxLength);583 }584 var len = end -start;585 var s = "(" + len + " byte)\n";586 maxLength /= 2; // we work inbytes587 if (len >maxLength) {588 end = start +maxLength;589 }590 for (var i = start; i < end; ++i) {591 s += this.hexByte(this.get(i));592 }593 if (len >maxLength) {594 s +=ellipsis;595 }596 returns;597 };598 Stream.prototype.parseOID = function(start, end, maxLength) {599 var s = "";600 var n = newInt10();601 var bits = 0;602 for (var i = start; i < end; ++i) {603 var v = this.get(i);604 n.mulAdd(128, v & 0x7F);605 bits += 7;606 if (!(v & 0x80)) { //finished
607 if (s === "") {608 n =n.simplify();609 if (n instanceofInt10) {610 n.sub(80);611 s = "2." +n.toString();612 }613 else{614 var m = n < 80 ? n < 40 ? 0 : 1 : 2;615 s = m + "." + (n - m * 40);616 }617 }618 else{619 s += "." +n.toString();620 }621 if (s.length >maxLength) {622 returnstringCut(s, maxLength);623 }624 n = newInt10();625 bits = 0;626 }627 }628 if (bits > 0) {629 s += ".incomplete";630 }631 returns;632 };633 returnStream;634 }());635 var ASN1 = /** @class*/ (function() {636 functionASN1(stream, header, length, tag, sub) {637 if (!(tag instanceofASN1Tag)) {638 throw new Error("Invalid tag value.");639 }640 this.stream =stream;641 this.header =header;642 this.length =length;643 this.tag =tag;644 this.sub =sub;645 }646 ASN1.prototype.typeName = function() {647 switch (this.tag.tagClass) {648 case 0: //universal
649 switch (this.tag.tagNumber) {650 case 0x00:651 return "EOC";652 case 0x01:653 return "BOOLEAN";654 case 0x02:655 return "INTEGER";656 case 0x03:657 return "BIT_STRING";658 case 0x04:659 return "OCTET_STRING";660 case 0x05:661 return "NULL";662 case 0x06:663 return "OBJECT_IDENTIFIER";664 case 0x07:665 return "ObjectDescriptor";666 case 0x08:667 return "EXTERNAL";668 case 0x09:669 return "REAL";670 case 0x0A:671 return "ENUMERATED";672 case 0x0B:673 return "EMBEDDED_PDV";674 case 0x0C:675 return "UTF8String";676 case 0x10:677 return "SEQUENCE";678 case 0x11:679 return "SET";680 case 0x12:681 return "NumericString";682 case 0x13:683 return "PrintableString"; //ASCII subset
684 case 0x14:685 return "TeletexString"; //aka T61String
686 case 0x15:687 return "VideotexString";688 case 0x16:689 return "IA5String"; //ASCII
690 case 0x17:691 return "UTCTime";692 case 0x18:693 return "GeneralizedTime";694 case 0x19:695 return "GraphicString";696 case 0x1A:697 return "VisibleString"; //ASCII subset
698 case 0x1B:699 return "GeneralString";700 case 0x1C:701 return "UniversalString";702 case 0x1E:703 return "BMPString";704 }705 return "Universal_" + this.tag.tagNumber.toString();706 case 1:707 return "Application_" + this.tag.tagNumber.toString();708 case 2:709 return "[" + this.tag.tagNumber.toString() + "]"; //Context
710 case 3:711 return "Private_" + this.tag.tagNumber.toString();712 }713 };714 ASN1.prototype.content = function(maxLength) {715 if (this.tag ===undefined) {716 return null;717 }718 if (maxLength ===undefined) {719 maxLength =Infinity;720 }721 var content = this.posContent();722 var len = Math.abs(this.length);723 if (!this.tag.isUniversal()) {724 if (this.sub !== null) {725 return "(" + this.sub.length + " elem)";726 }727 return this.stream.parseOctetString(content, content +len, maxLength);728 }729 switch (this.tag.tagNumber) {730 case 0x01: //BOOLEAN
731 return (this.stream.get(content) === 0) ? "false" : "true";732 case 0x02: //INTEGER
733 return this.stream.parseInteger(content, content +len);734 case 0x03: //BIT_STRING
735 return this.sub ? "(" + this.sub.length + " elem)":736 this.stream.parseBitString(content, content +len, maxLength);737 case 0x04: //OCTET_STRING
738 return this.sub ? "(" + this.sub.length + " elem)":739 this.stream.parseOctetString(content, content +len, maxLength);740 //case 0x05: // NULL
741 case 0x06: //OBJECT_IDENTIFIER
742 return this.stream.parseOID(content, content +len, maxLength);743 //case 0x07: // ObjectDescriptor
744 //case 0x08: // EXTERNAL
745 //case 0x09: // REAL
746 //case 0x0A: // ENUMERATED
747 //case 0x0B: // EMBEDDED_PDV
748 case 0x10: //SEQUENCE
749 case 0x11: //SET
750 if (this.sub !== null) {751 return "(" + this.sub.length + " elem)";752 }753 else{754 return "(no elem)";755 }756 case 0x0C: //UTF8String
757 return stringCut(this.stream.parseStringUTF(content, content +len), maxLength);758 case 0x12: //NumericString
759 case 0x13: //PrintableString
760 case 0x14: //TeletexString
761 case 0x15: //VideotexString
762 case 0x16: //IA5String
763 //case 0x19: // GraphicString
764 case 0x1A: //VisibleString
765 //case 0x1B: // GeneralString
766 //case 0x1C: // UniversalString
767 return stringCut(this.stream.parseStringISO(content, content +len), maxLength);768 case 0x1E: //BMPString
769 return stringCut(this.stream.parseStringBMP(content, content +len), maxLength);770 case 0x17: //UTCTime
771 case 0x18: //GeneralizedTime
772 return this.stream.parseTime(content, content + len, (this.tag.tagNumber == 0x17));773 }774 return null;775 };776 ASN1.prototype.toString = function() {777 return this.typeName() + "@" + this.stream.pos + "[header:" + this.header + ",length:" + this.length + ",sub:" + ((this.sub === null) ? "null" : this.sub.length) + "]";778 };779 ASN1.prototype.toPrettyString = function(indent) {780 if (indent ===undefined) {781 indent = "";782 }783 var s = indent + this.typeName() + " @" + this.stream.pos;784 if (this.length >= 0) {785 s += "+";786 }787 s += this.length;788 if (this.tag.tagConstructed) {789 s += " (constructed)";790 }791 else if ((this.tag.isUniversal() && ((this.tag.tagNumber == 0x03) || (this.tag.tagNumber == 0x04))) && (this.sub !== null)) {792 s += " (encapsulates)";793 }794 s += "\n";795 if (this.sub !== null) {796 indent += " ";797 for (var i = 0, max = this.sub.length; i < max; ++i) {798 s += this.sub[i].toPrettyString(indent);799 }800 }801 returns;802 };803 ASN1.prototype.posStart = function() {804 return this.stream.pos;805 };806 ASN1.prototype.posContent = function() {807 return this.stream.pos + this.header;808 };809 ASN1.prototype.posEnd = function() {810 return this.stream.pos + this.header + Math.abs(this.length);811 };812 ASN1.prototype.toHexString = function() {813 return this.stream.hexDump(this.posStart(), this.posEnd(), true);814 };815 ASN1.decodeLength = function(stream) {816 var buf =stream.get();817 var len = buf & 0x7F;818 if (len ==buf) {819 returnlen;820 }821 //no reason to use Int10, as it would be a huge buffer anyways
822 if (len > 6) {823 throw new Error("Length over 48 bits not supported at position " + (stream.pos - 1));824 }825 if (len === 0) {826 return null;827 } //undefined
828 buf = 0;829 for (var i = 0; i < len; ++i) {830 buf = (buf * 256) +stream.get();831 }832 returnbuf;833 };834 /**835 * Retrieve the hexadecimal value (as a string) of the current ASN.1 element836 * @returns {string}837 * @public838 */
839 ASN1.prototype.getHexStringValue = function() {840 var hexString = this.toHexString();841 var offset = this.header * 2;842 var length = this.length * 2;843 returnhexString.substr(offset, length);844 };845 ASN1.decode = function(str) {846 varstream;847 if (!(str instanceofStream)) {848 stream = new Stream(str, 0);849 }850 else{851 stream =str;852 }853 var streamStart = newStream(stream);854 var tag = newASN1Tag(stream);855 var len =ASN1.decodeLength(stream);856 var start =stream.pos;857 var header = start -streamStart.pos;858 var sub = null;859 var getSub = function() {860 var ret =[];861 if (len !== null) {862 //definite length
863 var end = start +len;864 while (stream.pos
873 try{874 for(;;) {875 var s =ASN1.decode(stream);876 if(s.tag.isEOC()) {877 break;878 }879 ret[ret.length] =s;880 }881 len = start - stream.pos; //undefined lengths are represented as negative values
882 }883 catch(e) {884 throw new Error("Exception while decoding undefined length content: " +e);885 }886 }887 returnret;888 };889 if(tag.tagConstructed) {890 //must have valid content
891 sub =getSub();892 }893 else if (tag.isUniversal() && ((tag.tagNumber == 0x03) || (tag.tagNumber == 0x04))) {894 //sometimes BitString and OctetString are used to encapsulate ASN.1
895 try{896 if (tag.tagNumber == 0x03) {897 if (stream.get() != 0) {898 throw new Error("BIT STRINGs with unused bits cannot encapsulate.");899 }900 }901 sub =getSub();902 for (var i = 0; i < sub.length; ++i) {903 if(sub[i].tag.isEOC()) {904 throw new Error("EOC is not supposed to be actual content.");905 }906 }907 }908 catch(e) {909 //but silently ignore when they don‘t
910 sub = null;911 }912 }913 if (sub === null) {914 if (len === null) {915 throw new Error("We can‘t skip over an invalid tag with undefined length at offset " +start);916 }917 stream.pos = start +Math.abs(len);918 }919 return newASN1(streamStart, header, len, tag, sub);920 };921 returnASN1;922 }());923 var ASN1Tag = /** @class*/ (function() {924 functionASN1Tag(stream) {925 var buf =stream.get();926 this.tagClass = buf >> 6;927 this.tagConstructed = ((buf & 0x20) !== 0);928 this.tagNumber = buf & 0x1F;929 if (this.tagNumber == 0x1F) { //long tag
930 var n = newInt10();931 do{932 buf =stream.get();933 n.mulAdd(128, buf & 0x7F);934 } while (buf & 0x80);935 this.tagNumber =n.simplify();936 }937 }938 ASN1Tag.prototype.isUniversal = function() {939 return this.tagClass === 0x00;940 };941 ASN1Tag.prototype.isEOC = function() {942 return this.tagClass === 0x00 && this.tagNumber === 0x00;943 };944 returnASN1Tag;945 }());946
947 //Copyright (c) 2005 Tom Wu
948 //Bits per digit
949 vardbits;950 //JavaScript engine analysis
951 var canary = 0xdeadbeefcafe;952 var j_lm = ((canary & 0xffffff) == 0xefcafe);953 //#region
954 var lowprimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997];955 var lplim = (1 << 26) / lowprimes[lowprimes.length - 1];956 //#endregion
957 //(public) Constructor
958 var BigInteger = /** @class*/ (function() {959 functionBigInteger(a, b, c) {960 if (a != null) {961 if ("number" == typeofa) {962 this.fromNumber(a, b, c);963 }964 else if (b == null && "string" != typeofa) {965 this.fromString(a, 256);966 }967 else{968 this.fromString(a, b);969 }970 }971 }972 //#region PUBLIC
973 //BigInteger.prototype.toString = bnToString;
974 //(public) return string representation in given radix
975 BigInteger.prototype.toString = function(b) {976 if (this.s < 0) {977 return "-" + this.negate().toString(b);978 }979 vark;980 if (b == 16) {981 k = 4;982 }983 else if (b == 8) {984 k = 3;985 }986 else if (b == 2) {987 k = 1;988 }989 else if (b == 32) {990 k = 5;991 }992 else if (b == 4) {993 k = 2;994 }995 else{996 return this.toRadix(b);997 }998 var km = (1 << k) - 1;999 vard;1000 var m = false;1001 var r = "";1002 var i = this.t;1003 var p = this.DB - (i * this.DB) %k;1004 if (i-- > 0) {1005 if (p < this.DB && (d = this[i] >> p) > 0) {1006 m = true;1007 r =int2char(d);1008 }1009 while (i >= 0) {1010 if (p > (p += this.DB -k);1013 }1014 else{1015 d = (this[i] >> (p -= k)) &km;1016 if (p <= 0) {1017 p += this.DB;1018 --i;1019 }1020 }1021 if (d > 0) {1022 m = true;1023 }1024 if(m) {1025 r +=int2char(d);1026 }1027 }1028 }1029 return m ? r : "0";1030 };1031 //BigInteger.prototype.negate = bnNegate;
1032 //(public) -this
1033 BigInteger.prototype.negate = function() {1034 var r =nbi();1035 BigInteger.ZERO.subTo(this, r);1036 returnr;1037 };1038 //BigInteger.prototype.abs = bnAbs;
1039 //(public) |this|
1040 BigInteger.prototype.abs = function() {1041 return (this.s < 0) ? this.negate() : this;1042 };1043 //BigInteger.prototype.compareTo = bnCompareTo;
1044 //(public) return + if this > a, - if this < a, 0 if equal
1045 BigInteger.prototype.compareTo = function(a) {1046 var r = this.s -a.s;1047 if (r != 0) {1048 returnr;1049 }1050 var i = this.t;1051 r = i -a.t;1052 if (r != 0) {1053 return (this.s < 0) ? -r : r;1054 }1055 while (--i >= 0) {1056 if ((r = this[i] - a[i]) != 0) {1057 returnr;1058 }1059 }1060 return 0;1061 };1062 //BigInteger.prototype.bitLength = bnBitLength;
1063 //(public) return the number of bits in "this"
1064 BigInteger.prototype.bitLength = function() {1065 if (this.t <= 0) {1066 return 0;1067 }1068 return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ (this.s & this.DM));1069 };1070 //BigInteger.prototype.mod = bnMod;
1071 //(public) this mod a
1072 BigInteger.prototype.mod = function(a) {1073 var r =nbi();1074 this.abs().divRemTo(a, null, r);1075 if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) {1076 a.subTo(r, r);1077 }1078 returnr;1079 };1080 //BigInteger.prototype.modPowInt = bnModPowInt;
1081 //(public) this^e % m, 0 <= e < 2^32
1082 BigInteger.prototype.modPowInt = function(e, m) {1083 varz;1084 if (e < 256 ||m.isEven()) {1085 z = newClassic(m);1086 }1087 else{1088 z = newMontgomery(m);1089 }1090 return this.exp(e, z);1091 };1092 //BigInteger.prototype.clone = bnClone;
1093 //(public)
1094 BigInteger.prototype.clone = function() {1095 var r =nbi();1096 this.copyTo(r);1097 returnr;1098 };1099 //BigInteger.prototype.intValue = bnIntValue;
1100 //(public) return value as integer
1101 BigInteger.prototype.intValue = function() {1102 if (this.s < 0) {1103 if (this.t == 1) {1104 return this[0] - this.DV;1105 }1106 else if (this.t == 0) {1107 return -1;1108 }1109 }1110 else if (this.t == 1) {1111 return this[0];1112 }1113 else if (this.t == 0) {1114 return 0;1115 }1116 //assumes 16 < DB < 32
1117 return ((this[1] & ((1 << (32 - this.DB)) - 1)) << this.DB) | this[0];1118 };1119 //BigInteger.prototype.byteValue = bnByteValue;
1120 //(public) return value as byte
1121 BigInteger.prototype.byteValue = function() {1122 return (this.t == 0) ? this.s : (this[0] << 24) >> 24;1123 };1124 //BigInteger.prototype.shortValue = bnShortValue;
1125 //(public) return value as short (assumes DB>=16)
1126 BigInteger.prototype.shortValue = function() {1127 return (this.t == 0) ? this.s : (this[0] << 16) >> 16;1128 };1129 //BigInteger.prototype.signum = bnSigNum;
1130 //(public) 0 if this == 0, 1 if this > 0
1131 BigInteger.prototype.signum = function() {1132 if (this.s < 0) {1133 return -1;1134 }1135 else if (this.t <= 0 || (this.t == 1 && this[0] <= 0)) {1136 return 0;1137 }1138 else{1139 return 1;1140 }1141 };1142 //BigInteger.prototype.toByteArray = bnToByteArray;
1143 //(public) convert to bigendian byte array
1144 BigInteger.prototype.toByteArray = function() {1145 var i = this.t;1146 var r =[];1147 r[0] = this.s;1148 var p = this.DB - (i * this.DB) % 8;1149 vard;1150 var k = 0;1151 if (i-- > 0) {1152 if (p < this.DB && (d = this[i] >> p) != (this.s & this.DM) >>p) {1153 r[k++] = d | (this.s << (this.DB -p));1154 }1155 while (i >= 0) {1156 if (p < 8) {1157 d = (this[i] & ((1 << p) - 1)) << (8 -p);1158 d |= this[--i] >> (p += this.DB - 8);1159 }1160 else{1161 d = (this[i] >> (p -= 8)) & 0xff;1162 if (p <= 0) {1163 p += this.DB;1164 --i;1165 }1166 }1167 if ((d & 0x80) != 0) {1168 d |= -256;1169 }1170 if (k == 0 && (this.s & 0x80) != (d & 0x80)) {1171 ++k;1172 }1173 if (k > 0 || d != this.s) {1174 r[k++] =d;1175 }1176 }1177 }1178 returnr;1179 };1180 //BigInteger.prototype.equals = bnEquals;
1181 BigInteger.prototype.equals = function(a) {1182 return (this.compareTo(a) == 0);1183 };1184 //BigInteger.prototype.min = bnMin;
1185 BigInteger.prototype.min = function(a) {1186 return (this.compareTo(a) < 0) ? this: a;1187 };1188 //BigInteger.prototype.max = bnMax;
1189 BigInteger.prototype.max = function(a) {1190 return (this.compareTo(a) > 0) ? this: a;1191 };1192 //BigInteger.prototype.and = bnAnd;
1193 BigInteger.prototype.and = function(a) {1194 var r =nbi();1195 this.bitwiseTo(a, op_and, r);1196 returnr;1197 };1198 //BigInteger.prototype.or = bnOr;
1199 BigInteger.prototype.or = function(a) {1200 var r =nbi();1201 this.bitwiseTo(a, op_or, r);1202 returnr;1203 };1204 //BigInteger.prototype.xor = bnXor;
1205 BigInteger.prototype.xor = function(a) {1206 var r =nbi();1207 this.bitwiseTo(a, op_xor, r);1208 returnr;1209 };1210 //BigInteger.prototype.andNot = bnAndNot;
1211 BigInteger.prototype.andNot = function(a) {1212 var r =nbi();1213 this.bitwiseTo(a, op_andnot, r);1214 returnr;1215 };1216 //BigInteger.prototype.not = bnNot;
1217 //(public) ~this
1218 BigInteger.prototype.not = function() {1219 var r =nbi();1220 for (var i = 0; i < this.t; ++i) {1221 r[i] = this.DM & ~this[i];1222 }1223 r.t = this.t;1224 r.s = ~this.s;1225 returnr;1226 };1227 //BigInteger.prototype.shiftLeft = bnShiftLeft;
1228 //(public) this << n
1229 BigInteger.prototype.shiftLeft = function(n) {1230 var r =nbi();1231 if (n < 0) {1232 this.rShiftTo(-n, r);1233 }1234 else{1235 this.lShiftTo(n, r);1236 }1237 returnr;1238 };1239 //BigInteger.prototype.shiftRight = bnShiftRight;
1240 //(public) this >> n
1241 BigInteger.prototype.shiftRight = function(n) {1242 var r =nbi();1243 if (n < 0) {1244 this.lShiftTo(-n, r);1245 }1246 else{1247 this.rShiftTo(n, r);1248 }1249 returnr;1250 };1251 //BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit;
1252 //(public) returns index of lowest 1-bit (or -1 if none)
1253 BigInteger.prototype.getLowestSetBit = function() {1254 for (var i = 0; i < this.t; ++i) {1255 if (this[i] != 0) {1256 return i * this.DB + lbit(this[i]);1257 }1258 }1259 if (this.s < 0) {1260 return this.t * this.DB;1261 }1262 return -1;1263 };1264 //BigInteger.prototype.bitCount = bnBitCount;
1265 //(public) return number of set bits
1266 BigInteger.prototype.bitCount = function() {1267 var r = 0;1268 var x = this.s & this.DM;1269 for (var i = 0; i < this.t; ++i) {1270 r += cbit(this[i] ^x);1271 }1272 returnr;1273 };1274 //BigInteger.prototype.testBit = bnTestBit;
1275 //(public) true iff nth bit is set
1276 BigInteger.prototype.testBit = function(n) {1277 var j = Math.floor(n / this.DB);1278 if (j >= this.t) {1279 return (this.s != 0);1280 }1281 return ((this[j] & (1 << (n % this.DB))) != 0);1282 };1283 //BigInteger.prototype.setBit = bnSetBit;
1284 //(public) this | (1<
1285 BigInteger.prototype.setBit = function(n) {1286 return this.changeBit(n, op_or);1287 };1288 //BigInteger.prototype.clearBit = bnClearBit;
1289 //(public) this & ~(1<
1290 BigInteger.prototype.clearBit = function(n) {1291 return this.changeBit(n, op_andnot);1292 };1293 //BigInteger.prototype.flipBit = bnFlipBit;
1294 //(public) this ^ (1<
1295 BigInteger.prototype.flipBit = function(n) {1296 return this.changeBit(n, op_xor);1297 };1298 //BigInteger.prototype.add = bnAdd;
1299 //(public) this + a
1300 BigInteger.prototype.add = function(a) {1301 var r =nbi();1302 this.addTo(a, r);1303 returnr;1304 };1305 //BigInteger.prototype.subtract = bnSubtract;
1306 //(public) this - a
1307 BigInteger.prototype.subtract = function(a) {1308 var r =nbi();1309 this.subTo(a, r);1310 returnr;1311 };1312 //BigInteger.prototype.multiply = bnMultiply;
1313 //(public) this * a
1314 BigInteger.prototype.multiply = function(a) {1315 var r =nbi();1316 this.multiplyTo(a, r);1317 returnr;1318 };1319 //BigInteger.prototype.divide = bnDivide;
1320 //(public) this / a
1321 BigInteger.prototype.divide = function(a) {1322 var r =nbi();1323 this.divRemTo(a, r, null);1324 returnr;1325 };1326 //BigInteger.prototype.remainder = bnRemainder;
1327 //(public) this % a
1328 BigInteger.prototype.remainder = function(a) {1329 var r =nbi();1330 this.divRemTo(a, null, r);1331 returnr;1332 };1333 //BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder;
1334 //(public) [this/a,this%a]
1335 BigInteger.prototype.divideAndRemainder = function(a) {1336 var q =nbi();1337 var r =nbi();1338 this.divRemTo(a, q, r);1339 return[q, r];1340 };1341 //BigInteger.prototype.modPow = bnModPow;
1342 //(public) this^e % m (HAC 14.85)
1343 BigInteger.prototype.modPow = function(e, m) {1344 var i =e.bitLength();1345 vark;1346 var r = nbv(1);1347 varz;1348 if (i <= 0) {1349 returnr;1350 }1351 else if (i < 18) {1352 k = 1;1353 }1354 else if (i < 48) {1355 k = 3;1356 }1357 else if (i < 144) {1358 k = 4;1359 }1360 else if (i < 768) {1361 k = 5;1362 }1363 else{1364 k = 6;1365 }1366 if (i < 8) {1367 z = newClassic(m);1368 }1369 else if(m.isEven()) {1370 z = newBarrett(m);1371 }1372 else{1373 z = newMontgomery(m);1374 }1375 //precomputation
1376 var g =[];1377 var n = 3;1378 var k1 = k - 1;1379 var km = (1 << k) - 1;1380 g[1] = z.convert(this);1381 if (k > 1) {1382 var g2 =nbi();1383 z.sqrTo(g[1], g2);1384 while (n <=km) {1385 g[n] =nbi();1386 z.mulTo(g2, g[n - 2], g[n]);1387 n += 2;1388 }1389 }1390 var j = e.t - 1;1391 varw;1392 var is1 = true;1393 var r2 =nbi();1394 vart;1395 i = nbits(e[j]) - 1;1396 while (j >= 0) {1397 if (i >=k1) {1398 w = (e[j] >> (i - k1)) &km;1399 }1400 else{1401 w = (e[j] & ((1 << (i + 1)) - 1)) << (k1 -i);1402 if (j > 0) {1403 w |= e[j - 1] >> (this.DB + i -k1);1404 }1405 }1406 n =k;1407 while ((w & 1) == 0) {1408 w >>= 1;1409 --n;1410 }1411 if ((i -= n) < 0) {1412 i += this.DB;1413 --j;1414 }1415 if (is1) { //ret == 1, don‘t bother squaring or multiplying it
1416 g[w].copyTo(r);1417 is1 = false;1418 }1419 else{1420 while (n > 1) {1421 z.sqrTo(r, r2);1422 z.sqrTo(r2, r);1423 n -= 2;1424 }1425 if (n > 0) {1426 z.sqrTo(r, r2);1427 }1428 else{1429 t =r;1430 r =r2;1431 r2 =t;1432 }1433 z.mulTo(r2, g[w], r);1434 }1435 while (j >= 0 && (e[j] & (1 << i)) == 0) {1436 z.sqrTo(r, r2);1437 t =r;1438 r =r2;1439 r2 =t;1440 if (--i < 0) {1441 i = this.DB - 1;1442 --j;1443 }1444 }1445 }1446 returnz.revert(r);1447 };1448 //BigInteger.prototype.modInverse = bnModInverse;
1449 //(public) 1/this % m (HAC 14.61)
1450 BigInteger.prototype.modInverse = function(m) {1451 var ac =m.isEven();1452 if ((this.isEven() && ac) || m.signum() == 0) {1453 returnBigInteger.ZERO;1454 }1455 var u =m.clone();1456 var v = this.clone();1457 var a = nbv(1);1458 var b = nbv(0);1459 var c = nbv(0);1460 var d = nbv(1);1461 while (u.signum() != 0) {1462 while(u.isEven()) {1463 u.rShiftTo(1, u);1464 if(ac) {1465 if (!a.isEven() || !b.isEven()) {1466 a.addTo(this, a);1467 b.subTo(m, b);1468 }1469 a.rShiftTo(1, a);1470 }1471 else if (!b.isEven()) {1472 b.subTo(m, b);1473 }1474 b.rShiftTo(1, b);1475 }1476 while(v.isEven()) {1477 v.rShiftTo(1, v);1478 if(ac) {1479 if (!c.isEven() || !d.isEven()) {1480 c.addTo(this, c);1481 d.subTo(m, d);1482 }1483 c.rShiftTo(1, c);1484 }1485 else if (!d.isEven()) {1486 d.subTo(m, d);1487 }1488 d.rShiftTo(1, d);1489 }1490 if (u.compareTo(v) >= 0) {1491 u.subTo(v, u);1492 if(ac) {1493 a.subTo(c, a);1494 }1495 b.subTo(d, b);1496 }1497 else{1498 v.subTo(u, v);1499 if(ac) {1500 c.subTo(a, c);1501 }1502 d.subTo(b, d);1503 }1504 }1505 if (v.compareTo(BigInteger.ONE) != 0) {1506 returnBigInteger.ZERO;1507 }1508 if (d.compareTo(m) >= 0) {1509 returnd.subtract(m);1510 }1511 if (d.signum() < 0) {1512 d.addTo(m, d);1513 }1514 else{1515 returnd;1516 }1517 if (d.signum() < 0) {1518 returnd.add(m);1519 }1520 else{1521 returnd;1522 }1523 };1524 //BigInteger.prototype.pow = bnPow;
1525 //(public) this^e
1526 BigInteger.prototype.pow = function(e) {1527 return this.exp(e, newNullExp());1528 };1529 //BigInteger.prototype.gcd = bnGCD;
1530 //(public) gcd(this,a) (HAC 14.54)
1531 BigInteger.prototype.gcd = function(a) {1532 var x = (this.s < 0) ? this.negate() : this.clone();1533 var y = (a.s < 0) ?a.negate() : a.clone();1534 if (x.compareTo(y) < 0) {1535 var t =x;1536 x =y;1537 y =t;1538 }1539 var i =x.getLowestSetBit();1540 var g =y.getLowestSetBit();1541 if (g < 0) {1542 returnx;1543 }1544 if (i 0) {1548 x.rShiftTo(g, x);1549 y.rShiftTo(g, y);1550 }1551 while (x.signum() > 0) {1552 if ((i = x.getLowestSetBit()) > 0) {1553 x.rShiftTo(i, x);1554 }1555 if ((i = y.getLowestSetBit()) > 0) {1556 y.rShiftTo(i, y);1557 }1558 if (x.compareTo(y) >= 0) {1559 x.subTo(y, x);1560 x.rShiftTo(1, x);1561 }1562 else{1563 y.subTo(x, y);1564 y.rShiftTo(1, y);1565 }1566 }1567 if (g > 0) {1568 y.lShiftTo(g, y);1569 }1570 returny;1571 };1572 //BigInteger.prototype.isProbablePrime = bnIsProbablePrime;
1573 //(public) test primality with certainty >= 1-.5^t
1574 BigInteger.prototype.isProbablePrime = function(t) {1575 vari;1576 var x = this.abs();1577 if (x.t == 1 && x[0] <= lowprimes[lowprimes.length - 1]) {1578 for (i = 0; i < lowprimes.length; ++i) {1579 if (x[0] ==lowprimes[i]) {1580 return true;1581 }1582 }1583 return false;1584 }1585 if(x.isEven()) {1586 return false;1587 }1588 i = 1;1589 while (i
1605 //#region PROTECTED
1606 //BigInteger.prototype.copyTo = bnpCopyTo;
1607 //(protected) copy this to r
1608 BigInteger.prototype.copyTo = function(r) {1609 for (var i = this.t - 1; i >= 0; --i) {1610 r[i] = this[i];1611 }1612 r.t = this.t;1613 r.s = this.s;1614 };1615 //BigInteger.prototype.fromInt = bnpFromInt;
1616 //(protected) set from integer value x, -DV <= x < DV
1617 BigInteger.prototype.fromInt = function(x) {1618 this.t = 1;1619 this.s = (x < 0) ? -1 : 0;1620 if (x > 0) {1621 this[0] =x;1622 }1623 else if (x < -1) {1624 this[0] = x + this.DV;1625 }1626 else{1627 this.t = 0;1628 }1629 };1630 //BigInteger.prototype.fromString = bnpFromString;
1631 //(protected) set from string and radix
1632 BigInteger.prototype.fromString = function(s, b) {1633 vark;1634 if (b == 16) {1635 k = 4;1636 }1637 else if (b == 8) {1638 k = 3;1639 }1640 else if (b == 256) {1641 k = 8;1642 /*byte array*/
1643 }1644 else if (b == 2) {1645 k = 1;1646 }1647 else if (b == 32) {1648 k = 5;1649 }1650 else if (b == 4) {1651 k = 2;1652 }1653 else{1654 this.fromRadix(s, b);1655 return;1656 }1657 this.t = 0;1658 this.s = 0;1659 var i =s.length;1660 var mi = false;1661 var sh = 0;1662 while (--i >= 0) {1663 var x = (k == 8) ? (+s[i]) & 0xff: intAt(s, i);1664 if (x < 0) {1665 if (s.charAt(i) == "-") {1666 mi = true;1667 }1668 continue;1669 }1670 mi = false;1671 if (sh == 0) {1672 this[this.t++] =x;1673 }1674 else if (sh + k > this.DB) {1675 this[this.t - 1] |= (x & ((1 << (this.DB - sh)) - 1)) <> (this.DB -sh));1677 }1678 else{1679 this[this.t - 1] |= x <= this.DB) {1683 sh -= this.DB;1684 }1685 }1686 if (k == 8 && ((+s[0]) & 0x80) != 0) {1687 this.s = -1;1688 if (sh > 0) {1689 this[this.t - 1] |= ((1 << (this.DB - sh)) - 1) <
1698 //(protected) clamp off excess high words
1699 BigInteger.prototype.clamp = function() {1700 var c = this.s & this.DM;1701 while (this.t > 0 && this[this.t - 1] ==c) {1702 --this.t;1703 }1704 };1705 //BigInteger.prototype.dlShiftTo = bnpDLShiftTo;
1706 //(protected) r = this << n*DB
1707 BigInteger.prototype.dlShiftTo = function(n, r) {1708 vari;1709 for (i = this.t - 1; i >= 0; --i) {1710 r[i + n] = this[i];1711 }1712 for (i = n - 1; i >= 0; --i) {1713 r[i] = 0;1714 }1715 r.t = this.t +n;1716 r.s = this.s;1717 };1718 //BigInteger.prototype.drShiftTo = bnpDRShiftTo;
1719 //(protected) r = this >> n*DB
1720 BigInteger.prototype.drShiftTo = function(n, r) {1721 for (var i = n; i < this.t; ++i) {1722 r[i - n] = this[i];1723 }1724 r.t = Math.max(this.t - n, 0);1725 r.s = this.s;1726 };1727 //BigInteger.prototype.lShiftTo = bnpLShiftTo;
1728 //(protected) r = this << n
1729 BigInteger.prototype.lShiftTo = function(n, r) {1730 var bs = n % this.DB;1731 var cbs = this.DB -bs;1732 var bm = (1 << cbs) - 1;1733 var ds = Math.floor(n / this.DB);1734 var c = (this.s << bs) & this.DM;1735 for (var i = this.t - 1; i >= 0; --i) {1736 r[i + ds + 1] = (this[i] >> cbs) |c;1737 c = (this[i] & bm) <= 0; --i) {1740 r[i] = 0;1741 }1742 r[ds] =c;1743 r.t = this.t + ds + 1;1744 r.s = this.s;1745 r.clamp();1746 };1747 //BigInteger.prototype.rShiftTo = bnpRShiftTo;
1748 //(protected) r = this >> n
1749 BigInteger.prototype.rShiftTo = function(n, r) {1750 r.s = this.s;1751 var ds = Math.floor(n / this.DB);1752 if (ds >= this.t) {1753 r.t = 0;1754 return;1755 }1756 var bs = n % this.DB;1757 var cbs = this.DB -bs;1758 var bm = (1 << bs) - 1;1759 r[0] = this[ds] >>bs;1760 for (var i = ds + 1; i < this.t; ++i) {1761 r[i - ds - 1] |= (this[i] & bm) <>bs;1763 }1764 if (bs > 0) {1765 r[this.t - ds - 1] |= (this.s & bm) <
1771 //(protected) r = this - a
1772 BigInteger.prototype.subTo = function(a, r) {1773 var i = 0;1774 var c = 0;1775 var m = Math.min(a.t, this.t);1776 while (i >= this.DB;1780 }1781 if (a.t < this.t) {1782 c -=a.s;1783 while (i < this.t) {1784 c += this[i];1785 r[i++] = c & this.DM;1786 c >>= this.DB;1787 }1788 c += this.s;1789 }1790 else{1791 c += this.s;1792 while (i >= this.DB;1796 }1797 c -=a.s;1798 }1799 r.s = (c < 0) ? -1 : 0;1800 if (c < -1) {1801 r[i++] = this.DV +c;1802 }1803 else if (c > 0) {1804 r[i++] =c;1805 }1806 r.t =i;1807 r.clamp();1808 };1809 //BigInteger.prototype.multiplyTo = bnpMultiplyTo;
1810 //(protected) r = this * a, r != this,a (HAC 14.12)
1811 //"this" should be the larger one if appropriate.
1812 BigInteger.prototype.multiplyTo = function(a, r) {1813 var x = this.abs();1814 var y =a.abs();1815 var i =x.t;1816 r.t = i +y.t;1817 while (--i >= 0) {1818 r[i] = 0;1819 }1820 for (i = 0; i < y.t; ++i) {1821 r[i + x.t] = x.am(0, y[i], r, i, 0, x.t);1822 }1823 r.s = 0;1824 r.clamp();1825 if (this.s !=a.s) {1826 BigInteger.ZERO.subTo(r, r);1827 }1828 };1829 //BigInteger.prototype.squareTo = bnpSquareTo;
1830 //(protected) r = this^2, r != this (HAC 14.16)
1831 BigInteger.prototype.squareTo = function(r) {1832 var x = this.abs();1833 var i = r.t = 2 *x.t;1834 while (--i >= 0) {1835 r[i] = 0;1836 }1837 for (i = 0; i < x.t - 1; ++i) {1838 var c = x.am(i, x[i], r, 2 * i, 0, 1);1839 if ((r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >=x.DV) {1840 r[i + x.t] -=x.DV;1841 r[i + x.t + 1] = 1;1842 }1843 }1844 if (r.t > 0) {1845 r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1);1846 }1847 r.s = 0;1848 r.clamp();1849 };1850 //BigInteger.prototype.divRemTo = bnpDivRemTo;
1851 //(protected) divide this by m, quotient and remainder to q, r (HAC 14.20)
1852 //r != q, this != m. q or r may be null.
1853 BigInteger.prototype.divRemTo = function(m, q, r) {1854 var pm =m.abs();1855 if (pm.t <= 0) {1856 return;1857 }1858 var pt = this.abs();1859 if (pt.t
1875 if (nsh > 0) {1876 pm.lShiftTo(nsh, y);1877 pt.lShiftTo(nsh, r);1878 }1879 else{1880 pm.copyTo(y);1881 pt.copyTo(r);1882 }1883 var ys =y.t;1884 var y0 = y[ys - 1];1885 if (y0 == 0) {1886 return;1887 }1888 var yt = y0 * (1 << this.F1) + ((ys > 1) ? y[ys - 2] >> this.F2 : 0);1889 var d1 = this.FV /yt;1890 var d2 = (1 << this.F1) /yt;1891 var e = 1 << this.F2;1892 var i =r.t;1893 var j = i -ys;1894 var t = (q == null) ?nbi() : q;1895 y.dlShiftTo(j, t);1896 if (r.compareTo(t) >= 0) {1897 r[r.t++] = 1;1898 r.subTo(t, r);1899 }1900 BigInteger.ONE.dlShiftTo(ys, t);1901 t.subTo(y, y); //"negative" y so we can replace sub with am later
1902 while (y.t = 0) {1906 //Estimate quotient digit
1907 var qd = (r[--i] == y0) ? this.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) *d2);1908 if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) { //Try it out
1909 y.dlShiftTo(j, t);1910 r.subTo(t, r);1911 while (r[i] < --qd) {1912 r.subTo(t, r);1913 }1914 }1915 }1916 if (q != null) {1917 r.drShiftTo(ys, q);1918 if (ts !=ms) {1919 BigInteger.ZERO.subTo(q, q);1920 }1921 }1922 r.t =ys;1923 r.clamp();1924 if (nsh > 0) {1925 r.rShiftTo(nsh, r);1926 } //Denormalize remainder
1927 if (ts < 0) {1928 BigInteger.ZERO.subTo(r, r);1929 }1930 };1931 //BigInteger.prototype.invDigit = bnpInvDigit;
1932 //(protected) return "-1/this % 2^DB"; useful for Mont. reduction
1933 //justification:
1934 //xy == 1 (mod m)
1935 //xy = 1+km
1936 //xy(2-xy) = (1+km)(1-km)
1937 //x[y(2-xy)] = 1-k^2m^2
1938 //x[y(2-xy)] == 1 (mod m^2)
1939 //if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
1940 //should reduce x and y(2-xy) by m^2 at each step to keep size bounded.
1941 //JS multiply "overflows" differently from C/C++, so care is needed here.
1942 BigInteger.prototype.invDigit = function() {1943 if (this.t < 1) {1944 return 0;1945 }1946 var x = this[0];1947 if ((x & 1) == 0) {1948 return 0;1949 }1950 var y = x & 3; //y == 1/x mod 2^2
1951 y = (y * (2 - (x & 0xf) * y)) & 0xf; //y == 1/x mod 2^4
1952 y = (y * (2 - (x & 0xff) * y)) & 0xff; //y == 1/x mod 2^8
1953 y = (y * (2 - (((x & 0xffff) * y) & 0xffff))) & 0xffff; //y == 1/x mod 2^16
1954 //last step - calculate inverse mod DV directly;
1955 //assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
1956 y = (y * (2 - x * y % this.DV)) % this.DV; //y == 1/x mod 2^dbits
1957 //we really want the negative inverse, and -DV < y < DV
1958 return (y > 0) ? this.DV - y : -y;1959 };1960 //BigInteger.prototype.isEven = bnpIsEven;
1961 //(protected) true iff this is even
1962 BigInteger.prototype.isEven = function() {1963 return ((this.t > 0) ? (this[0] & 1) : this.s) == 0;1964 };1965 //BigInteger.prototype.exp = bnpExp;
1966 //(protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
1967 BigInteger.prototype.exp = function(e, z) {1968 if (e > 0xffffffff || e < 1) {1969 returnBigInteger.ONE;1970 }1971 var r =nbi();1972 var r2 =nbi();1973 var g = z.convert(this);1974 var i = nbits(e) - 1;1975 g.copyTo(r);1976 while (--i >= 0) {1977 z.sqrTo(r, r2);1978 if ((e & (1 << i)) > 0) {1979 z.mulTo(r2, g, r);1980 }1981 else{1982 var t =r;1983 r =r2;1984 r2 =t;1985 }1986 }1987 returnz.revert(r);1988 };1989 //BigInteger.prototype.chunkSize = bnpChunkSize;
1990 //(protected) return x s.t. r^x < DV
1991 BigInteger.prototype.chunkSize = function(r) {1992 return Math.floor(Math.LN2 * this.DB /Math.log(r));1993 };1994 //BigInteger.prototype.toRadix = bnpToRadix;
1995 //(protected) convert to radix string
1996 BigInteger.prototype.toRadix = function(b) {1997 if (b == null) {1998 b = 10;1999 }2000 if (this.signum() == 0 || b < 2 || b > 36) {2001 return "0";2002 }2003 var cs = this.chunkSize(b);2004 var a =Math.pow(b, cs);2005 var d =nbv(a);2006 var y =nbi();2007 var z =nbi();2008 var r = "";2009 this.divRemTo(d, y, z);2010 while (y.signum() > 0) {2011 r = (a + z.intValue()).toString(b).substr(1) +r;2012 y.divRemTo(d, y, z);2013 }2014 return z.intValue().toString(b) +r;2015 };2016 //BigInteger.prototype.fromRadix = bnpFromRadix;
2017 //(protected) convert from radix string
2018 BigInteger.prototype.fromRadix = function(s, b) {2019 this.fromInt(0);2020 if (b == null) {2021 b = 10;2022 }2023 var cs = this.chunkSize(b);2024 var d =Math.pow(b, cs);2025 var mi = false;2026 var j = 0;2027 var w = 0;2028 for (var i = 0; i < s.length; ++i) {2029 var x =intAt(s, i);2030 if (x < 0) {2031 if (s.charAt(i) == "-" && this.signum() == 0) {2032 mi = true;2033 }2034 continue;2035 }2036 w = b * w +x;2037 if (++j >=cs) {2038 this.dMultiply(d);2039 this.dAddOffset(w, 0);2040 j = 0;2041 w = 0;2042 }2043 }2044 if (j > 0) {2045 this.dMultiply(Math.pow(b, j));2046 this.dAddOffset(w, 0);2047 }2048 if(mi) {2049 BigInteger.ZERO.subTo(this, this);2050 }2051 };2052 //BigInteger.prototype.fromNumber = bnpFromNumber;
2053 //(protected) alternate constructor
2054 BigInteger.prototype.fromNumber = function(a, b, c) {2055 if ("number" == typeofb) {2056 //new BigInteger(int,int,RNG)
2057 if (a < 2) {2058 this.fromInt(1);2059 }2060 else{2061 this.fromNumber(a, c);2062 if (!this.testBit(a - 1)) {2063 //force MSB set
2064 this.bitwiseTo(BigInteger.ONE.shiftLeft(a - 1), op_or, this);2065 }2066 if (this.isEven()) {2067 this.dAddOffset(1, 0);2068 } //force odd
2069 while (!this.isProbablePrime(b)) {2070 this.dAddOffset(2, 0);2071 if (this.bitLength() >a) {2072 this.subTo(BigInteger.ONE.shiftLeft(a - 1), this);2073 }2074 }2075 }2076 }2077 else{2078 //new BigInteger(int,RNG)
2079 var x =[];2080 var t = a & 7;2081 x.length = (a >> 3) + 1;2082 b.nextBytes(x);2083 if (t > 0) {2084 x[0] &= ((1 << t) - 1);2085 }2086 else{2087 x[0] = 0;2088 }2089 this.fromString(x, 256);2090 }2091 };2092 //BigInteger.prototype.bitwiseTo = bnpBitwiseTo;
2093 //(protected) r = this op a (bitwise)
2094 BigInteger.prototype.bitwiseTo = function(a, op, r) {2095 vari;2096 varf;2097 var m = Math.min(a.t, this.t);2098 for (i = 0; i < m; ++i) {2099 r[i] = op(this[i], a[i]);2100 }2101 if (a.t < this.t) {2102 f = a.s & this.DM;2103 for (i = m; i < this.t; ++i) {2104 r[i] = op(this[i], f);2105 }2106 r.t = this.t;2107 }2108 else{2109 f = this.s & this.DM;2110 for (i = m; i < a.t; ++i) {2111 r[i] =op(f, a[i]);2112 }2113 r.t =a.t;2114 }2115 r.s = op(this.s, a.s);2116 r.clamp();2117 };2118 //BigInteger.prototype.changeBit = bnpChangeBit;
2119 //(protected) this op (1<
2120 BigInteger.prototype.changeBit = function(n, op) {2121 var r =BigInteger.ONE.shiftLeft(n);2122 this.bitwiseTo(r, op, r);2123 returnr;2124 };2125 //BigInteger.prototype.addTo = bnpAddTo;
2126 //(protected) r = this + a
2127 BigInteger.prototype.addTo = function(a, r) {2128 var i = 0;2129 var c = 0;2130 var m = Math.min(a.t, this.t);2131 while (i >= 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 >= 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 returnr;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 returnr;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 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" == typeofb) {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 returnBigInteger;2379 }());2380 //#region REDUCERS
2381 //#region NullExp
2382 var NullExp = /** @class*/ (function() {2383 functionNullExp() {2384 }2385 //NullExp.prototype.convert = nNop;
2386 NullExp.prototype.convert = function(x) {2387 returnx;2388 };2389 //NullExp.prototype.revert = nNop;
2390 NullExp.prototype.revert = function(x) {2391 returnx;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 returnNullExp;2402 }());2403 //Modular reduction using "classic" algorithm
2404 var Classic = /** @class*/ (function() {2405 functionClassic(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 returnx;2415 }2416 };2417 //Classic.prototype.revert = cRevert;
2418 Classic.prototype.revert = function(x) {2419 returnx;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 returnClassic;2436 }());2437 //#endregion
2438 //#region Montgomery
2439 //Montgomery reduction
2440 var Montgomery = /** @class*/ (function() {2441 functionMontgomery(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 returnr;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 returnr;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 returnMontgomery;2507 }());2508 //#endregion Montgomery
2509 //#region Barrett
2510 //Barrett modular reduction
2511 var Barrett = /** @class*/ (function() {2512 functionBarrett(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 returnx;2527 }2528 else{2529 var r =nbi();2530 x.copyTo(r);2531 this.reduce(r);2532 returnr;2533 }2534 };2535 //Barrett.prototype.revert = barrettRevert;
2536 Barrett.prototype.revert = function(x) {2537 returnx;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 returnBarrett;2570 }());2571 //#endregion
2572 //#endregion REDUCERS
2573 //return new, unset BigInteger
2574 function nbi() { return new BigInteger(null); }2575 functionparseBigInt(str, r) {2576 return newBigInteger(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 functionam1(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 returnc;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 functionam2(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 returnc;2608 }2609 //Alternately, set max digit bits to 28 since some
2610 //browsers slow down when dealing with 32-bit numbers.
2611 functionam3(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 returnc;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 <
2644 var BI_RC =[];2645 varrr;2646 varvv;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 functionintAt(s, i) {2660 var c =BI_RC[s.charCodeAt(i)];2661 return (c == null) ? -1: c;2662 }2663 //return bigint initialized to value
2664 functionnbv(i) {2665 var r =nbi();2666 r.fromInt(i);2667 returnr;2668 }2669 //returns bit length of the integer x
2670 functionnbits(x) {2671 var r = 1;2672 vart;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 returnr;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 functionArcfour() {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 vari;2710 varj;2711 vart;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 vart;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 returnArcfour;2736 }());2737 //Plug in your RNG constructor here
2738 functionprng_newstate() {2739 return newArcfour();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 varrng_state;2747 var rng_pool = null;2748 varrng_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 functionrng_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
2806 returnrng_state.next();2807 }2808 var SecureRandom = /** @class*/ (function() {2809 functionSecureRandom() {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 returnSecureRandom;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 functionpkcs1pad1(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 functionpkcs1pad2(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 var c = s.charCodeAt(i--);2858 if (c < 128) { //encode using utf-8
2859 ba[--n] =c;2860 }2861 else if ((c > 127) && (c < 2048)) {2862 ba[--n] = (c & 63) | 128;2863 ba[--n] = (c >> 6) | 192;2864 }2865 else{2866 ba[--n] = (c & 63) | 128;2867 ba[--n] = ((c >> 6) & 63) | 128;2868 ba[--n] = (c >> 12) | 224;2869 }2870 }2871 ba[--n] = 0;2872 var rng = newSecureRandom();2873 var x =[];2874 while (n > 2) { //random non-zero pad
2875 x[0] = 0;2876 while (x[0] == 0) {2877 rng.nextBytes(x);2878 }2879 ba[--n] = x[0];2880 }2881 ba[--n] = 2;2882 ba[--n] = 0;2883 return newBigInteger(ba);2884 }2885 //"empty" RSA key constructor
2886 var RSAKey = /** @class*/ (function() {2887 functionRSAKey() {2888 this.n = null;2889 this.e = 0;2890 this.d = null;2891 this.p = null;2892 this.q = null;2893 this.dmp1 = null;2894 this.dmq1 = null;2895 this.coeff = null;2896 }2897 //#region PROTECTED
2898 //protected
2899 //RSAKey.prototype.doPublic = RSADoPublic;
2900 //Perform raw public operation on "x": return x^e (mod n)
2901 RSAKey.prototype.doPublic = function(x) {2902 return x.modPowInt(this.e, this.n);2903 };2904 //RSAKey.prototype.doPrivate = RSADoPrivate;
2905 //Perform raw private operation on "x": return x^d (mod n)
2906 RSAKey.prototype.doPrivate = function(x) {2907 if (this.p == null || this.q == null) {2908 return x.modPow(this.d, this.n);2909 }2910 //TODO: re-calculate any missing CRT params
2911 var xp = x.mod(this.p).modPow(this.dmp1, this.p);2912 var xq = x.mod(this.q).modPow(this.dmq1, this.q);2913 while (xp.compareTo(xq) < 0) {2914 xp = xp.add(this.p);2915 }2916 return xp.subtract(xq).multiply(this.coeff).mod(this.p).multiply(this.q).add(xq);2917 };2918 //#endregion PROTECTED
2919 //#region PUBLIC
2920 //RSAKey.prototype.setPublic = RSASetPublic;
2921 //Set the public key fields N and e from hex strings
2922 RSAKey.prototype.setPublic = function(N, E) {2923 if (N != null && E != null && N.length > 0 && E.length > 0) {2924 this.n = parseBigInt(N, 16);2925 this.e = parseInt(E, 16);2926 }2927 else{2928 console.error("Invalid RSA public key");2929 }2930 };2931 //RSAKey.prototype.encrypt = RSAEncrypt;
2932 //Return the PKCS#1 RSA encryption of "text" as an even-length hex string
2933 RSAKey.prototype.encrypt = function(text) {2934 var m = pkcs1pad2(text, (this.n.bitLength() + 7) >> 3);2935 if (m == null) {2936 return null;2937 }2938 var c = this.doPublic(m);2939 if (c == null) {2940 return null;2941 }2942 var h = c.toString(16);2943 if ((h.length & 1) == 0) {2944 returnh;2945 }2946 else{2947 return "0" +h;2948 }2949 };2950 //RSAKey.prototype.setPrivate = RSASetPrivate;
2951 //Set the private key fields N, e, and d from hex strings
2952 RSAKey.prototype.setPrivate = function(N, E, D) {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 }2958 else{2959 console.error("Invalid RSA private key");2960 }2961 };2962 //RSAKey.prototype.setPrivateEx = RSASetPrivateEx;
2963 //Set the private key fields N, e, d and CRT params from hex strings
2964 RSAKey.prototype.setPrivateEx = function(N, E, D, P, Q, DP, DQ, C) {2965 if (N != null && E != null && N.length > 0 && E.length > 0) {2966 this.n = parseBigInt(N, 16);2967 this.e = parseInt(E, 16);2968 this.d = parseBigInt(D, 16);2969 this.p = parseBigInt(P, 16);2970 this.q = parseBigInt(Q, 16);2971 this.dmp1 = parseBigInt(DP, 16);2972 this.dmq1 = parseBigInt(DQ, 16);2973 this.coeff = parseBigInt(C, 16);2974 }2975 else{2976 console.error("Invalid RSA private key");2977 }2978 };2979 //RSAKey.prototype.generate = RSAGenerate;
2980 //Generate a new random private key B bits long, using public expt E
2981 RSAKey.prototype.generate = function(B, E) {2982 var rng = newSecureRandom();2983 var qs = B >> 1;2984 this.e = parseInt(E, 16);2985 var ee = new BigInteger(E, 16);2986 for(;;) {2987 for(;;) {2988 this.p = new BigInteger(B - qs, 1, rng);2989 if (this.p.subtract(BigInteger.ONE).gcd(ee).compareTo(BigInteger.ONE) == 0 && this.p.isProbablePrime(10)) {2990 break;2991 }2992 }2993 for(;;) {2994 this.q = new BigInteger(qs, 1, rng);2995 if (this.q.subtract(BigInteger.ONE).gcd(ee).compareTo(BigInteger.ONE) == 0 && this.q.isProbablePrime(10)) {2996 break;2997 }2998 }2999 if (this.p.compareTo(this.q) <= 0) {3000 var t = this.p;3001 this.p = this.q;3002 this.q =t;3003 }3004 var p1 = this.p.subtract(BigInteger.ONE);3005 var q1 = this.q.subtract(BigInteger.ONE);3006 var phi =p1.multiply(q1);3007 if (phi.gcd(ee).compareTo(BigInteger.ONE) == 0) {3008 this.n = this.p.multiply(this.q);3009 this.d =ee.modInverse(phi);3010 this.dmp1 = this.d.mod(p1);3011 this.dmq1 = this.d.mod(q1);3012 this.coeff = this.q.modInverse(this.p);3013 break;3014 }3015 }3016 };3017 //RSAKey.prototype.decrypt = RSADecrypt;
3018 //Return the PKCS#1 RSA decryption of "ctext".
3019 //"ctext" is an even-length hex string and the output is a plain string.
3020 RSAKey.prototype.decrypt = function(ctext) {3021 var c = parseBigInt(ctext, 16);3022 var m = this.doPrivate(c);3023 if (m == null) {3024 return null;3025 }3026 return pkcs1unpad2(m, (this.n.bitLength() + 7) >> 3);3027 };3028 //Generate a new random private key B bits long, using public expt E
3029 RSAKey.prototype.generateAsync = function(B, E, callback) {3030 var rng = newSecureRandom();3031 var qs = B >> 1;3032 this.e = parseInt(E, 16);3033 var ee = new BigInteger(E, 16);3034 var rsa = this;3035 //These functions have non-descript names because they were originally for(;;) loops.
3036 //I don‘t know about cryptography to give them better names than loop1-4.
3037 var loop1 = function() {3038 var loop4 = function() {3039 if (rsa.p.compareTo(rsa.q) <= 0) {3040 var t =rsa.p;3041 rsa.p =rsa.q;3042 rsa.q =t;3043 }3044 var p1 =rsa.p.subtract(BigInteger.ONE);3045 var q1 =rsa.q.subtract(BigInteger.ONE);3046 var phi =p1.multiply(q1);3047 if (phi.gcd(ee).compareTo(BigInteger.ONE) == 0) {3048 rsa.n =rsa.p.multiply(rsa.q);3049 rsa.d =ee.modInverse(phi);3050 rsa.dmp1 =rsa.d.mod(p1);3051 rsa.dmq1 =rsa.d.mod(q1);3052 rsa.coeff =rsa.q.modInverse(rsa.p);3053 setTimeout(function () { callback(); }, 0); //escape
3054 }3055 else{3056 setTimeout(loop1, 0);3057 }3058 };3059 var loop3 = function() {3060 rsa.q =nbi();3061 rsa.q.fromNumberAsync(qs, 1, rng, function() {3062 rsa.q.subtract(BigInteger.ONE).gcda(ee, function(r) {3063 if (r.compareTo(BigInteger.ONE) == 0 && rsa.q.isProbablePrime(10)) {3064 setTimeout(loop4, 0);3065 }3066 else{3067 setTimeout(loop3, 0);3068 }3069 });3070 });3071 };3072 var loop2 = function() {3073 rsa.p =nbi();3074 rsa.p.fromNumberAsync(B - qs, 1, rng, function() {3075 rsa.p.subtract(BigInteger.ONE).gcda(ee, function(r) {3076 if (r.compareTo(BigInteger.ONE) == 0 && rsa.p.isProbablePrime(10)) {3077 setTimeout(loop3, 0);3078 }3079 else{3080 setTimeout(loop2, 0);3081 }3082 });3083 });3084 };3085 setTimeout(loop2, 0);3086 };3087 setTimeout(loop1, 0);3088 };3089 RSAKey.prototype.sign = function(text, digestMethod, digestName) {3090 var header =getDigestHeader(digestName);3091 var digest = header +digestMethod(text).toString();3092 var m = pkcs1pad1(digest, this.n.bitLength() / 4);3093 if (m == null) {3094 return null;3095 }3096 var c = this.doPrivate(m);3097 if (c == null) {3098 return null;3099 }3100 var h = c.toString(16);3101 if ((h.length & 1) == 0) {3102 returnh;3103 }3104 else{3105 return "0" +h;3106 }3107 };3108 RSAKey.prototype.verify = function(text, signature, digestMethod) {3109 var c = parseBigInt(signature, 16);3110 var m = this.doPublic(c);3111 if (m == null) {3112 return null;3113 }3114 var unpadded = m.toString(16).replace(/^1f+00/, "");3115 var digest =removeDigestHeader(unpadded);3116 return digest ==digestMethod(text).toString();3117 };3118 returnRSAKey;3119 }());3120 //Undo PKCS#1 (type 2, random) padding and, if valid, return the plaintext
3121 functionpkcs1unpad2(d, n) {3122 var b =d.toByteArray();3123 var i = 0;3124 while (i < b.length && b[i] == 0) {3125 ++i;3126 }3127 if (b.length - i != n - 1 || b[i] != 2) {3128 return null;3129 }3130 ++i;3131 while (b[i] != 0) {3132 if (++i >=b.length) {3133 return null;3134 }3135 }3136 var ret = "";3137 while (++i
3140 ret +=String.fromCharCode(c);3141 }3142 else if ((c > 191) && (c < 224)) {3143 ret += String.fromCharCode(((c & 31) << 6) | (b[i + 1] & 63));3144 ++i;3145 }3146 else{3147 ret += String.fromCharCode(((c & 15) << 12) | ((b[i + 1] & 63) << 6) | (b[i + 2] & 63));3148 i += 2;3149 }3150 }3151 returnret;3152 }3153 //https://tools.ietf.org/html/rfc3447#page-43
3154 var DIGEST_HEADERS ={3155 md2: "3020300c06082a864886f70d020205000410",3156 md5: "3020300c06082a864886f70d020505000410",3157 sha1: "3021300906052b0e03021a05000414",3158 sha224: "302d300d06096086480165030402040500041c",3159 sha256: "3031300d060960864801650304020105000420",3160 sha384: "3041300d060960864801650304020205000430",3161 sha512: "3051300d060960864801650304020305000440",3162 ripemd160: "3021300906052b2403020105000414",3163 };3164 functiongetDigestHeader(name) {3165 return DIGEST_HEADERS[name] || "";3166 }3167 functionremoveDigestHeader(str) {3168 for (var name_1 inDIGEST_HEADERS) {3169 if(DIGEST_HEADERS.hasOwnProperty(name_1)) {3170 var header =DIGEST_HEADERS[name_1];3171 var len =header.length;3172 if (str.substr(0, len) ==header) {3173 returnstr.substr(len);3174 }3175 }3176 }3177 returnstr;3178 }3179 //Return the PKCS#1 RSA encryption of "text" as a Base64-encoded string
3180 //function RSAEncryptB64(text) {
3181 //var h = this.encrypt(text);
3182 //if(h) return hex2b64(h); else return null;
3183 //}
3184 //public
3185 //RSAKey.prototype.encrypt_b64 = RSAEncryptB64;
3186
3187 /*!3188 Copyright (c) 2011, Yahoo! Inc. All rights reserved.3189 Code licensed under the BSD License:3190 http://developer.yahoo.com/yui/license.html3191 version: 2.9.03192 */
3193 var YAHOO ={};3194 YAHOO.lang ={3195 /**3196 * Utility to set up the prototype, constructor and superclass properties to3197 * support an inheritance strategy that can chain constructors and methods.3198 * Static members will not be inherited.3199 *3200 * @method extend3201 * @static3202 * @param {Function} subc the object to modify3203 * @param {Function} superc the object to inherit3204 * @param {Object} overrides additional properties/methods to add to the3205 * subclass prototype. These will override the3206 * matching items obtained from the superclass3207 * if present.3208 */
3209 extend: function(subc, superc, overrides) {3210 if (! superc || !subc) {3211 throw new Error("YAHOO.lang.extend failed, please check that " +
3212 "all dependencies are included.");3213 }3214
3215 var F = function() {};3216 F.prototype =superc.prototype;3217 subc.prototype = newF();3218 subc.prototype.constructor =subc;3219 subc.superclass =superc.prototype;3220
3221 if (superc.prototype.constructor ==Object.prototype.constructor) {3222 superc.prototype.constructor =superc;3223 }3224
3225 if(overrides) {3226 vari;3227 for (i inoverrides) {3228 subc.prototype[i] =overrides[i];3229 }3230
3231 /*
3232 * IE will not enumerate native functions in a derived object even if the3233 * function was overridden. This is a workaround for specific functions3234 * we care about on the Object prototype.3235 * @property _IEEnumFix3236 * @param {Function} r the object to receive the augmentation3237 * @param {Function} s the object that supplies the properties to augment3238 * @static3239 * @private3240 */
3241 var _IEEnumFix = function() {},3242 ADD = ["toString", "valueOf"];3243 try{3244 if (/MSIE/.test(navigator.userAgent)) {3245 _IEEnumFix = function(r, s) {3246 for (i = 0; i < ADD.length; i = i + 1) {3247 var fname = ADD[i], f =s[fname];3248 if (typeof f === ‘function‘ && f !=Object.prototype[fname]) {3249 r[fname] =f;3250 }3251 }3252 };3253 }3254 } catch(ex) {} _IEEnumFix(subc.prototype, overrides);3255 }3256 }3257 };3258
3259 /*asn1-1.0.13.js (c) 2013-2017 Kenji Urushima | kjur.github.com/jsrsasign/license3260 */
3261
3262 /**3263 * @fileOverview3264 * @name asn1-1.0.js3265 * @author Kenji Urushima [email protected]3266 * @version asn1 1.0.13 (2017-Jun-02)3267 * @since jsrsasign 2.13268 * @license MIT License3269 */
3270
3271 /**3272 * kjur‘s class library name space3273 *
3274 * This name space provides following name spaces:3275 *
- 3276 *
- [email protected] KJUR.asn1} - ASN.1 primitive hexadecimal encoder3277 *
- [email protected] KJUR.asn1.x509} - ASN.1 structure for X.509 certificate and CRL3278 *
- [email protected] KJUR.crypto} - Java Cryptographic Extension(JCE) style MessageDigest/Signature3279 * class and utilities3280 *
3286 var KJUR ={};3287
3288 /**3289 * kjur‘s ASN.1 class library name space3290 *
3291 * This is ITU-T X.690 ASN.1 DER encoder class library and3292 * class structure and methods is very similar to3293 * org.bouncycastle.asn1 package of3294 * well known BouncyCaslte Cryptography Library.3295 *
PROVIDING ASN.1 PRIMITIVES
3296 * Here are ASN.1 DER primitive classes.3297 *- 3298 *
- 0x01 [email protected] KJUR.asn1.DERBoolean}3299 *
- 0x02 [email protected] KJUR.asn1.DERInteger}3300 *
- 0x03 [email protected] KJUR.asn1.DERBitString}3301 *
- 0x04 [email protected] KJUR.asn1.DEROctetString}3302 *
- 0x05 [email protected] KJUR.asn1.DERNull}3303 *
- 0x06 [email protected] KJUR.asn1.DERObjectIdentifier}3304 *
- 0x0a [email protected] KJUR.asn1.DEREnumerated}3305 *
- 0x0c [email protected] KJUR.asn1.DERUTF8String}3306 *
- 0x12 [email protected] KJUR.asn1.DERNumericString}3307 *
- 0x13 [email protected] KJUR.asn1.DERPrintableString}3308 *
- 0x14 [email protected] KJUR.asn1.DERTeletexString}3309 *
- 0x16 [email protected] KJUR.asn1.DERIA5String}3310 *
- 0x17 [email protected] KJUR.asn1.DERUTCTime}3311 *
- 0x18 [email protected] KJUR.asn1.DERGeneralizedTime}3312 *
- 0x30 [email protected] KJUR.asn1.DERSequence}3313 *
- 0x31 [email protected] KJUR.asn1.DERSet}3314 *
OTHER ASN.1 CLASSES
3316 *- 3317 *
- [email protected] KJUR.asn1.ASN1Object}3318 *
- [email protected] KJUR.asn1.DERAbstractString}3319 *
- [email protected] KJUR.asn1.DERAbstractTime}3320 *
- [email protected] KJUR.asn1.DERAbstractStructured}3321 *
- [email protected] KJUR.asn1.DERTaggedObject}3322 *
SUB NAME SPACES
3324 *- 3325 *
- [email protected] KJUR.asn1.cades} - CAdES long term signature format3326 *
- [email protected] KJUR.asn1.cms} - Cryptographic Message Syntax3327 *
- [email protected] KJUR.asn1.csr} - Certificate Signing Request (CSR/PKCS#10)3328 *
- [email protected] KJUR.asn1.tsp} - RFC 3161 Timestamping Protocol Format3329 *
- [email protected] KJUR.asn1.x509} - RFC 5280 X.509 certificate and CRL3330 *
3337 if (typeof KJUR.asn1 == "undefined" || !KJUR.asn1) KJUR.asn1 ={};3338
3339 /**3340 * ASN1 utilities class3341 * @name KJUR.asn1.ASN1Util3342 * @class ASN1 utilities class3343 * @since asn1 1.0.23344 */
3345 KJUR.asn1.ASN1Util = new function() {3346 this.integerToByteHex = function(i) {3347 var h = i.toString(16);3348 if ((h.length % 2) == 1) h = ‘0‘ +h;3349 returnh;3350 };3351 this.bigIntToMinTwosComplementsHex = function(bigIntegerValue) {3352 var h = bigIntegerValue.toString(16);3353 if (h.substr(0, 1) != ‘-‘) {3354 if (h.length % 2 == 1) {3355 h = ‘0‘ +h;3356 } else{3357 if (! h.match(/^[0-7]/)) {3358 h = ‘00‘ +h;3359 }3360 }3361 } else{3362 var hPos = h.substr(1);3363 var xorLen =hPos.length;3364 if (xorLen % 2 == 1) {3365 xorLen += 1;3366 } else{3367 if (! h.match(/^[0-7]/)) {3368 xorLen += 2;3369 }3370 }3371 var hMask = ‘‘;3372 for (var i = 0; i < xorLen; i++) {3373 hMask += ‘f‘;3374 }3375 var biMask = new BigInteger(hMask, 16);3376 var biNeg =biMask.xor(bigIntegerValue).add(BigInteger.ONE);3377 h = biNeg.toString(16).replace(/^-/, ‘‘);3378 }3379 returnh;3380 };3381 /**3382 * get PEM string from hexadecimal data and header string3383 * @name getPEMStringFromHex3384 * @memberOf KJUR.asn1.ASN1Util3385 * @function3386 * @param {String} dataHex hexadecimal string of PEM body3387 * @param {String} pemHeader PEM header string (ex. ‘RSA PRIVATE KEY‘)3388 * @return {String} PEM formatted string of input data3389 * @description3390 * This method converts a hexadecimal string to a PEM string with3391 * a specified header. Its line break will be CRLF("\r\n").3392 * @example3393 * var pem = KJUR.asn1.ASN1Util.getPEMStringFromHex(‘616161‘, ‘RSA PRIVATE KEY‘);3394 * // value of pem will be:3395 * -----BEGIN PRIVATE KEY-----3396 * YWFh3397 * -----END PRIVATE KEY-----3398 */
3399 this.getPEMStringFromHex = function(dataHex, pemHeader) {3400 returnhextopem(dataHex, pemHeader);3401 };3402
3403 /**3404 * generate ASN1Object specifed by JSON parameters3405 * @name newObject3406 * @memberOf KJUR.asn1.ASN1Util3407 * @function3408 * @param {Array} param JSON parameter to generate ASN1Object3409 * @return {KJUR.asn1.ASN1Object} generated object3410 * @since asn1 1.0.33411 * @description3412 * generate any ASN1Object specified by JSON param3413 * including ASN.1 primitive or structured.3414 * Generally ‘param‘ can be described as follows:3415 *
3416 * {TYPE-OF-ASNOBJ: ASN1OBJ-PARAMETER}3417 *3418 * ‘TYPE-OF-ASN1OBJ‘ can be one of following symbols:3419 *
- 3420 *
- ‘bool‘ - DERBoolean3421 *
- ‘int‘ - DERInteger3422 *
- ‘bitstr‘ - DERBitString3423 *
- ‘octstr‘ - DEROctetString3424 *
- ‘null‘ - DERNull3425 *
- ‘oid‘ - DERObjectIdentifier3426 *
- ‘enum‘ - DEREnumerated3427 *
- ‘utf8str‘ - DERUTF8String3428 *
- ‘numstr‘ - DERNumericString3429 *
- ‘prnstr‘ - DERPrintableString3430 *
- ‘telstr‘ - DERTeletexString3431 *
- ‘ia5str‘ - DERIA5String3432 *
- ‘utctime‘ - DERUTCTime3433 *
- ‘gentime‘ - DERGeneralizedTime3434 *
- ‘seq‘ - DERSequence3435 *
- ‘set‘ - DERSet3436 *
- ‘tag‘ - DERTaggedObject3437 *
3453 this.newObject = function(param) {3454 var _KJUR =KJUR,3455 _KJUR_asn1 =_KJUR.asn1,3456 _DERBoolean =_KJUR_asn1.DERBoolean,3457 _DERInteger =_KJUR_asn1.DERInteger,3458 _DERBitString =_KJUR_asn1.DERBitString,3459 _DEROctetString =_KJUR_asn1.DEROctetString,3460 _DERNull =_KJUR_asn1.DERNull,3461 _DERObjectIdentifier =_KJUR_asn1.DERObjectIdentifier,3462 _DEREnumerated =_KJUR_asn1.DEREnumerated,3463 _DERUTF8String =_KJUR_asn1.DERUTF8String,3464 _DERNumericString =_KJUR_asn1.DERNumericString,3465 _DERPrintableString =_KJUR_asn1.DERPrintableString,3466 _DERTeletexString =_KJUR_asn1.DERTeletexString,3467 _DERIA5String =_KJUR_asn1.DERIA5String,3468 _DERUTCTime =_KJUR_asn1.DERUTCTime,3469 _DERGeneralizedTime =_KJUR_asn1.DERGeneralizedTime,3470 _DERSequence =_KJUR_asn1.DERSequence,3471 _DERSet =_KJUR_asn1.DERSet,3472 _DERTaggedObject =_KJUR_asn1.DERTaggedObject,3473 _newObject =_KJUR_asn1.ASN1Util.newObject;3474
3475 var keys =Object.keys(param);3476 if (keys.length != 1)3477 throw "key of param shall be only one.";3478 var key = keys[0];3479
3480 if (":bool:int:bitstr:octstr:null:oid:enum:utf8str:numstr:prnstr:telstr:ia5str:utctime:gentime:seq:set:tag:".indexOf(":" + key + ":") == -1)3481 throw "undefined key: " +key;3482
3483 if (key == "bool") return new_DERBoolean(param[key]);3484 if (key == "int") return new_DERInteger(param[key]);3485 if (key == "bitstr") return new_DERBitString(param[key]);3486 if (key == "octstr") return new_DEROctetString(param[key]);3487 if (key == "null") return new_DERNull(param[key]);3488 if (key == "oid") return new_DERObjectIdentifier(param[key]);3489 if (key == "enum") return new_DEREnumerated(param[key]);3490 if (key == "utf8str") return new_DERUTF8String(param[key]);3491 if (key == "numstr") return new_DERNumericString(param[key]);3492 if (key == "prnstr") return new_DERPrintableString(param[key]);3493 if (key == "telstr") return new_DERTeletexString(param[key]);3494 if (key == "ia5str") return new_DERIA5String(param[key]);3495 if (key == "utctime") return new_DERUTCTime(param[key]);3496 if (key == "gentime") return new_DERGeneralizedTime(param[key]);3497
3498 if (key == "seq") {3499 var paramList =param[key];3500 var a =[];3501 for (var i = 0; i < paramList.length; i++) {3502 var asn1Obj =_newObject(paramList[i]);3503 a.push(asn1Obj);3504 }3505 return new _DERSequence({‘array‘: a});3506 }3507
3508 if (key == "set") {3509 var paramList =param[key];3510 var a =[];3511 for (var i = 0; i < paramList.length; i++) {3512 var asn1Obj =_newObject(paramList[i]);3513 a.push(asn1Obj);3514 }3515 return new _DERSet({‘array‘: a});3516 }3517
3518 if (key == "tag") {3519 var tagParam =param[key];3520 if (Object.prototype.toString.call(tagParam) === ‘[object Array]‘ &&
3521 tagParam.length == 3) {3522 var obj = _newObject(tagParam[2]);3523 return new _DERTaggedObject({tag: tagParam[0],3524 explicit: tagParam[1],3525 obj: obj});3526 } else{3527 var newParam ={};3528 if (tagParam.explicit !==undefined)3529 newParam.explicit =tagParam.explicit;3530 if (tagParam.tag !==undefined)3531 newParam.tag =tagParam.tag;3532 if (tagParam.obj ===undefined)3533 throw "obj shall be specified for ‘tag‘.";3534 newParam.obj =_newObject(tagParam.obj);3535 return new_DERTaggedObject(newParam);3536 }3537 }3538 };3539
3540 /**3541 * get encoded hexadecimal string of ASN1Object specifed by JSON parameters3542 * @name jsonToASN1HEX3543 * @memberOf KJUR.asn1.ASN1Util3544 * @function3545 * @param {Array} param JSON parameter to generate ASN1Object3546 * @return hexadecimal string of ASN1Object3547 * @since asn1 1.0.43548 * @description3549 * As for ASN.1 object representation of JSON object,3550 * please see [email protected] newObject}.3551 * @example3552 * jsonToASN1HEX({‘prnstr‘: ‘aaa‘});3553 */
3554 this.jsonToASN1HEX = function(param) {3555 var asn1Obj = this.newObject(param);3556 returnasn1Obj.getEncodedHex();3557 };3558 };3559
3560 /**3561 * get dot noted oid number string from hexadecimal value of OID3562 * @name oidHexToInt3563 * @memberOf KJUR.asn1.ASN1Util3564 * @function3565 * @param {String} hex hexadecimal value of object identifier3566 * @return {String} dot noted string of object identifier3567 * @since jsrsasign 4.8.3 asn1 1.0.73568 * @description3569 * This static method converts from hexadecimal string representation of3570 * ASN.1 value of object identifier to oid number string.3571 * @example3572 * KJUR.asn1.ASN1Util.oidHexToInt(‘550406‘) → "2.5.4.6"3573 */
3574 KJUR.asn1.ASN1Util.oidHexToInt = function(hex) {3575 var s = "";3576 var i01 = parseInt(hex.substr(0, 2), 16);3577 var i0 = Math.floor(i01 / 40);3578 var i1 = i01 % 40;3579 var s = i0 + "." +i1;3580
3581 var binbuf = "";3582 for (var i = 2; i < hex.length; i += 2) {3583 var value = parseInt(hex.substr(i, 2), 16);3584 var bin = ("00000000" + value.toString(2)).slice(- 8);3585 binbuf = binbuf + bin.substr(1, 7);3586 if (bin.substr(0, 1) == "0") {3587 var bi = new BigInteger(binbuf, 2);3588 s = s + "." + bi.toString(10);3589 binbuf = "";3590 }3591 }3592 returns;3593 };3594
3595 /**3596 * get hexadecimal value of object identifier from dot noted oid value3597 * @name oidIntToHex3598 * @memberOf KJUR.asn1.ASN1Util3599 * @function3600 * @param {String} oidString dot noted string of object identifier3601 * @return {String} hexadecimal value of object identifier3602 * @since jsrsasign 4.8.3 asn1 1.0.73603 * @description3604 * This static method converts from object identifier value string.3605 * to hexadecimal string representation of it.3606 * @example3607 * KJUR.asn1.ASN1Util.oidIntToHex("2.5.4.6") → "550406"3608 */
3609 KJUR.asn1.ASN1Util.oidIntToHex = function(oidString) {3610 var itox = function(i) {3611 var h = i.toString(16);3612 if (h.length == 1) h = ‘0‘ +h;3613 returnh;3614 };3615
3616 var roidtox = function(roid) {3617 var h = ‘‘;3618 var bi = new BigInteger(roid, 10);3619 var b = bi.toString(2);3620 var padLen = 7 - b.length % 7;3621 if (padLen == 7) padLen = 0;3622 var bPad = ‘‘;3623 for (var i = 0; i < padLen; i++) bPad += ‘0‘;3624 b = bPad +b;3625 for (var i = 0; i < b.length - 1; i += 7) {3626 var b8 = b.substr(i, 7);3627 if (i != b.length - 7) b8 = ‘1‘ +b8;3628 h += itox(parseInt(b8, 2));3629 }3630 returnh;3631 };3632
3633 if (! oidString.match(/^[0-9.]+$/)) {3634 throw "malformed oid string: " +oidString;3635 }3636 var h = ‘‘;3637 var a = oidString.split(‘.‘);3638 var i0 = parseInt(a[0]) * 40 + parseInt(a[1]);3639 h +=itox(i0);3640 a.splice(0, 2);3641 for (var i = 0; i < a.length; i++) {3642 h +=roidtox(a[i]);3643 }3644 returnh;3645 };3646
3647
3648 //********************************************************************
3649 //Abstract ASN.1 Classes
3650 //********************************************************************
3651
3652 //********************************************************************
3653
3654 /**3655 * base class for ASN.1 DER encoder object3656 * @name KJUR.asn1.ASN1Object3657 * @class base class for ASN.1 DER encoder object3658 * @property {Boolean} isModified flag whether internal data was changed3659 * @property {String} hTLV hexadecimal string of ASN.1 TLV3660 * @property {String} hT hexadecimal string of ASN.1 TLV tag(T)3661 * @property {String} hL hexadecimal string of ASN.1 TLV length(L)3662 * @property {String} hV hexadecimal string of ASN.1 TLV value(V)3663 * @description3664 */
3665 KJUR.asn1.ASN1Object = function() {3666 var hV = ‘‘;3667
3668 /**3669 * get hexadecimal ASN.1 TLV length(L) bytes from TLV value(V)3670 * @name getLengthHexFromValue3671 * @memberOf KJUR.asn1.ASN1Object#3672 * @function3673 * @return {String} hexadecimal string of ASN.1 TLV length(L)3674 */
3675 this.getLengthHexFromValue = function() {3676 if (typeof this.hV == "undefined" || this.hV == null) {3677 throw "this.hV is null or undefined.";3678 }3679 if (this.hV.length % 2 == 1) {3680 throw "value hex must be even length: n=" + hV.length + ",v=" + this.hV;3681 }3682 var n = this.hV.length / 2;3683 var hN = n.toString(16);3684 if (hN.length % 2 == 1) {3685 hN = "0" +hN;3686 }3687 if (n < 128) {3688 returnhN;3689 } else{3690 var hNlen = hN.length / 2;3691 if (hNlen > 15) {3692 throw "ASN.1 length too long to represent by 8x: n = " + n.toString(16);3693 }3694 var head = 128 +hNlen;3695 return head.toString(16) +hN;3696 }3697 };3698
3699 /**3700 * get hexadecimal string of ASN.1 TLV bytes3701 * @name getEncodedHex3702 * @memberOf KJUR.asn1.ASN1Object#3703 * @function3704 * @return {String} hexadecimal string of ASN.1 TLV3705 */
3706 this.getEncodedHex = function() {3707 if (this.hTLV == null || this.isModified) {3708 this.hV = this.getFreshValueHex();3709 this.hL = this.getLengthHexFromValue();3710 this.hTLV = this.hT + this.hL + this.hV;3711 this.isModified = false;3712 //alert("first time: " + this.hTLV);
3713 }3714 return this.hTLV;3715 };3716
3717 /**3718 * get hexadecimal string of ASN.1 TLV value(V) bytes3719 * @name getValueHex3720 * @memberOf KJUR.asn1.ASN1Object#3721 * @function3722 * @return {String} hexadecimal string of ASN.1 TLV value(V) bytes3723 */
3724 this.getValueHex = function() {3725 this.getEncodedHex();3726 return this.hV;3727 };3728
3729 this.getFreshValueHex = function() {3730 return ‘‘;3731 };3732 };3733
3734 //== BEGIN DERAbstractString ================================================
3735 /**3736 * base class for ASN.1 DER string classes3737 * @name KJUR.asn1.DERAbstractString3738 * @class base class for ASN.1 DER string classes3739 * @param {Array} params associative array of parameters (ex. {‘str‘: ‘aaa‘})3740 * @property {String} s internal string of value3741 * @extends KJUR.asn1.ASN1Object3742 * @description3743 *
3744 * As for argument ‘params‘ for constructor, you can specify one of3745 * following properties:3746 *
- 3747 *
- str - specify initial ASN.1 value(V) by a string3748 *
- hex - specify initial ASN.1 value(V) by a hexadecimal string3749 *
3752 KJUR.asn1.DERAbstractString = function(params) {3753 KJUR.asn1.DERAbstractString.superclass.constructor.call(this);3754
3755 /**3756 * get string value of this string object3757 * @name getString3758 * @memberOf KJUR.asn1.DERAbstractString#3759 * @function3760 * @return {String} string value of this string object3761 */
3762 this.getString = function() {3763 return this.s;3764 };3765
3766 /**3767 * set value by a string3768 * @name setString3769 * @memberOf KJUR.asn1.DERAbstractString#3770 * @function3771 * @param {String} newS value by a string to set3772 */
3773 this.setString = function(newS) {3774 this.hTLV = null;3775 this.isModified = true;3776 this.s =newS;3777 this.hV = stohex(this.s);3778 };3779
3780 /**3781 * set value by a hexadecimal string3782 * @name setStringHex3783 * @memberOf KJUR.asn1.DERAbstractString#3784 * @function3785 * @param {String} newHexString value by a hexadecimal string to set3786 */
3787 this.setStringHex = function(newHexString) {3788 this.hTLV = null;3789 this.isModified = true;3790 this.s = null;3791 this.hV =newHexString;3792 };3793
3794 this.getFreshValueHex = function() {3795 return this.hV;3796 };3797
3798 if (typeof params != "undefined") {3799 if (typeof params == "string") {3800 this.setString(params);3801 } else if (typeof params[‘str‘] != "undefined") {3802 this.setString(params[‘str‘]);3803 } else if (typeof params[‘hex‘] != "undefined") {3804 this.setStringHex(params[‘hex‘]);3805 }3806 }3807 };3808 YAHOO.lang.extend(KJUR.asn1.DERAbstractString, KJUR.asn1.ASN1Object);3809 //== END DERAbstractString ================================================
3810
3811 //== BEGIN DERAbstractTime ==================================================
3812 /**3813 * base class for ASN.1 DER Generalized/UTCTime class3814 * @name KJUR.asn1.DERAbstractTime3815 * @class base class for ASN.1 DER Generalized/UTCTime class3816 * @param {Array} params associative array of parameters (ex. {‘str‘: ‘130430235959Z‘})3817 * @extends KJUR.asn1.ASN1Object3818 * @description3819 * @see KJUR.asn1.ASN1Object - superclass3820 */
3821 KJUR.asn1.DERAbstractTime = function(params) {3822 KJUR.asn1.DERAbstractTime.superclass.constructor.call(this);3823
3824 //--- PRIVATE METHODS --------------------
3825 this.localDateToUTC = function(d) {3826 utc = d.getTime() + (d.getTimezoneOffset() * 60000);3827 var utcDate = newDate(utc);3828 returnutcDate;3829 };3830
3831 /*
3832 * format date string by Data object3833 * @name formatDate3834 * @memberOf KJUR.asn1.AbstractTime;3835 * @param {Date} dateObject3836 * @param {string} type ‘utc‘ or ‘gen‘3837 * @param {boolean} withMillis flag for with millisections or not3838 * @description3839 * ‘withMillis‘ flag is supported from asn1 1.0.6.3840 */
3841 this.formatDate = function(dateObject, type, withMillis) {3842 var pad = this.zeroPadding;3843 var d = this.localDateToUTC(dateObject);3844 var year =String(d.getFullYear());3845 if (type == ‘utc‘) year = year.substr(2, 2);3846 var month = pad(String(d.getMonth() + 1), 2);3847 var day = pad(String(d.getDate()), 2);3848 var hour = pad(String(d.getHours()), 2);3849 var min = pad(String(d.getMinutes()), 2);3850 var sec = pad(String(d.getSeconds()), 2);3851 var s = year + month + day + hour + min +sec;3852 if (withMillis === true) {3853 var millis =d.getMilliseconds();3854 if (millis != 0) {3855 var sMillis = pad(String(millis), 3);3856 sMillis = sMillis.replace(/[0]+$/, "");3857 s = s + "." +sMillis;3858 }3859 }3860 return s + "Z";3861 };3862
3863 this.zeroPadding = function(s, len) {3864 if (s.length >= len) returns;3865 return new Array(len - s.length + 1).join(‘0‘) +s;3866 };3867
3868 //--- PUBLIC METHODS --------------------
3869 /**3870 * get string value of this string object3871 * @name getString3872 * @memberOf KJUR.asn1.DERAbstractTime#3873 * @function3874 * @return {String} string value of this time object3875 */
3876 this.getString = function() {3877 return this.s;3878 };3879
3880 /**3881 * set value by a string3882 * @name setString3883 * @memberOf KJUR.asn1.DERAbstractTime#3884 * @function3885 * @param {String} newS value by a string to set such like "130430235959Z"3886 */
3887 this.setString = function(newS) {3888 this.hTLV = null;3889 this.isModified = true;3890 this.s =newS;3891 this.hV =stohex(newS);3892 };3893
3894 /**3895 * set value by a Date object3896 * @name setByDateValue3897 * @memberOf KJUR.asn1.DERAbstractTime#3898 * @function3899 * @param {Integer} year year of date (ex. 2013)3900 * @param {Integer} month month of date between 1 and 12 (ex. 12)3901 * @param {Integer} day day of month3902 * @param {Integer} hour hours of date3903 * @param {Integer} min minutes of date3904 * @param {Integer} sec seconds of date3905 */
3906 this.setByDateValue = function(year, month, day, hour, min, sec) {3907 var dateObject = new Date(Date.UTC(year, month - 1, day, hour, min, sec, 0));3908 this.setByDate(dateObject);3909 };3910
3911 this.getFreshValueHex = function() {3912 return this.hV;3913 };3914 };3915 YAHOO.lang.extend(KJUR.asn1.DERAbstractTime, KJUR.asn1.ASN1Object);3916 //== END DERAbstractTime ==================================================
3917
3918 //== BEGIN DERAbstractStructured ============================================
3919 /**3920 * base class for ASN.1 DER structured class3921 * @name KJUR.asn1.DERAbstractStructured3922 * @class base class for ASN.1 DER structured class3923 * @property {Array} asn1Array internal array of ASN1Object3924 * @extends KJUR.asn1.ASN1Object3925 * @description3926 * @see KJUR.asn1.ASN1Object - superclass3927 */
3928 KJUR.asn1.DERAbstractStructured = function(params) {3929 KJUR.asn1.DERAbstractString.superclass.constructor.call(this);3930
3931 /**3932 * set value by array of ASN1Object3933 * @name setByASN1ObjectArray3934 * @memberOf KJUR.asn1.DERAbstractStructured#3935 * @function3936 * @param {array} asn1ObjectArray array of ASN1Object to set3937 */
3938 this.setByASN1ObjectArray = function(asn1ObjectArray) {3939 this.hTLV = null;3940 this.isModified = true;3941 this.asn1Array =asn1ObjectArray;3942 };3943
3944 /**3945 * append an ASN1Object to internal array3946 * @name appendASN1Object3947 * @memberOf KJUR.asn1.DERAbstractStructured#3948 * @function3949 * @param {ASN1Object} asn1Object to add3950 */
3951 this.appendASN1Object = function(asn1Object) {3952 this.hTLV = null;3953 this.isModified = true;3954 this.asn1Array.push(asn1Object);3955 };3956
3957 this.asn1Array = newArray();3958 if (typeof params != "undefined") {3959 if (typeof params[‘array‘] != "undefined") {3960 this.asn1Array = params[‘array‘];3961 }3962 }3963 };3964 YAHOO.lang.extend(KJUR.asn1.DERAbstractStructured, KJUR.asn1.ASN1Object);3965
3966
3967 //********************************************************************
3968 //ASN.1 Object Classes
3969 //********************************************************************
3970
3971 //********************************************************************
3972 /**3973 * class for ASN.1 DER Boolean3974 * @name KJUR.asn1.DERBoolean3975 * @class class for ASN.1 DER Boolean3976 * @extends KJUR.asn1.ASN1Object3977 * @description3978 * @see KJUR.asn1.ASN1Object - superclass3979 */
3980 KJUR.asn1.DERBoolean = function() {3981 KJUR.asn1.DERBoolean.superclass.constructor.call(this);3982 this.hT = "01";3983 this.hTLV = "0101ff";3984 };3985 YAHOO.lang.extend(KJUR.asn1.DERBoolean, KJUR.asn1.ASN1Object);3986
3987 //********************************************************************
3988 /**3989 * class for ASN.1 DER Integer3990 * @name KJUR.asn1.DERInteger3991 * @class class for ASN.1 DER Integer3992 * @extends KJUR.asn1.ASN1Object3993 * @description3994 *
3995 * As for argument ‘params‘ for constructor, you can specify one of3996 * following properties:3997 *
- 3998 *
- int - specify initial ASN.1 value(V) by integer value3999 *
- bigint - specify initial ASN.1 value(V) by BigInteger object4000 *
- hex - specify initial ASN.1 value(V) by a hexadecimal string4001 *
4004 KJUR.asn1.DERInteger = function(params) {4005 KJUR.asn1.DERInteger.superclass.constructor.call(this);4006 this.hT = "02";4007
4008 /**4009 * set value by Tom Wu‘s BigInteger object4010 * @name setByBigInteger4011 * @memberOf KJUR.asn1.DERInteger#4012 * @function4013 * @param {BigInteger} bigIntegerValue to set4014 */
4015 this.setByBigInteger = function(bigIntegerValue) {4016 this.hTLV = null;4017 this.isModified = true;4018 this.hV =KJUR.asn1.ASN1Util.bigIntToMinTwosComplementsHex(bigIntegerValue);4019 };4020
4021 /**4022 * set value by integer value4023 * @name setByInteger4024 * @memberOf KJUR.asn1.DERInteger4025 * @function4026 * @param {Integer} integer value to set4027 */
4028 this.setByInteger = function(intValue) {4029 var bi = new BigInteger(String(intValue), 10);4030 this.setByBigInteger(bi);4031 };4032
4033 /**4034 * set value by integer value4035 * @name setValueHex4036 * @memberOf KJUR.asn1.DERInteger#4037 * @function4038 * @param {String} hexadecimal string of integer value4039 * @description4040 *
4041 * NOTE: Value shall be represented by minimum octet length of4042 * two‘s complement representation.4043 * @example4044 * new KJUR.asn1.DERInteger(123);4045 * new KJUR.asn1.DERInteger({‘int‘: 123});4046 * new KJUR.asn1.DERInteger({‘hex‘: ‘1fad‘});4047 */
4048 this.setValueHex = function(newHexString) {4049 this.hV =newHexString;4050 };4051
4052 this.getFreshValueHex = function() {4053 return this.hV;4054 };4055
4056 if (typeof params != "undefined") {4057 if (typeof params[‘bigint‘] != "undefined") {4058 this.setByBigInteger(params[‘bigint‘]);4059 } else if (typeof params[‘int‘] != "undefined") {4060 this.setByInteger(params[‘int‘]);4061 } else if (typeof params == "number") {4062 this.setByInteger(params);4063 } else if (typeof params[‘hex‘] != "undefined") {4064 this.setValueHex(params[‘hex‘]);4065 }4066 }4067 };4068 YAHOO.lang.extend(KJUR.asn1.DERInteger, KJUR.asn1.ASN1Object);4069
4070 //********************************************************************
4071 /**4072 * class for ASN.1 DER encoded BitString primitive4073 * @name KJUR.asn1.DERBitString4074 * @class class for ASN.1 DER encoded BitString primitive4075 * @extends KJUR.asn1.ASN1Object4076 * @description4077 *
4078 * As for argument ‘params‘ for constructor, you can specify one of4079 * following properties:4080 *
- 4081 *
- bin - specify binary string (ex. ‘10111‘)4082 *
- array - specify array of boolean (ex. [true,false,true,true])4083 *
- hex - specify hexadecimal string of ASN.1 value(V) including unused bits4084 *
- obj - specify [email protected] KJUR.asn1.ASN1Util.newObject}4085 * argument for "BitString encapsulates" structure.4086 *
4088 * NOTE2: ‘obj‘ parameter have been supported since4089 * asn1 1.0.11, jsrsasign 6.1.1 (2016-Sep-25).
4090 * @example4091 * // default constructor4092 * o = new KJUR.asn1.DERBitString();4093 * // initialize with binary string4094 * o = new KJUR.asn1.DERBitString({bin: "1011"});4095 * // initialize with boolean array4096 * o = new KJUR.asn1.DERBitString({array: [true,false,true,true]});4097 * // initialize with hexadecimal string (04 is unused bits)4098 * o = new KJUR.asn1.DEROctetString({hex: "04bac0"});4099 * // initialize with ASN1Util.newObject argument for encapsulated4100 * o = new KJUR.asn1.DERBitString({obj: {seq: [{int: 3}, {prnstr: ‘aaa‘}]}});4101 * // above generates a ASN.1 data like this:4102 * // BIT STRING, encapsulates {4103 * // SEQUENCE {4104 * // INTEGER 34105 * // PrintableString ‘aaa‘4106 * // }4107 * // }4108 */
4109 KJUR.asn1.DERBitString = function(params) {4110 if (params !== undefined && typeof params.obj !== "undefined") {4111 var o =KJUR.asn1.ASN1Util.newObject(params.obj);4112 params.hex = "00" +o.getEncodedHex();4113 }4114 KJUR.asn1.DERBitString.superclass.constructor.call(this);4115 this.hT = "03";4116
4117 /**4118 * set ASN.1 value(V) by a hexadecimal string including unused bits4119 * @name setHexValueIncludingUnusedBits4120 * @memberOf KJUR.asn1.DERBitString#4121 * @function4122 * @param {String} newHexStringIncludingUnusedBits4123 */
4124 this.setHexValueIncludingUnusedBits = function(newHexStringIncludingUnusedBits) {4125 this.hTLV = null;4126 this.isModified = true;4127 this.hV =newHexStringIncludingUnusedBits;4128 };4129
4130 /**4131 * set ASN.1 value(V) by unused bit and hexadecimal string of value4132 * @name setUnusedBitsAndHexValue4133 * @memberOf KJUR.asn1.DERBitString#4134 * @function4135 * @param {Integer} unusedBits4136 * @param {String} hValue4137 */
4138 this.setUnusedBitsAndHexValue = function(unusedBits, hValue) {4139 if (unusedBits < 0 || 7
4148 /**4149 * set ASN.1 DER BitString by binary string
4150 * @name setByBinaryString4151 * @memberOf KJUR.asn1.DERBitString#4152 * @function4153 * @param {String} binaryString binary value string (i.e. ‘10111‘)4154 * @description4155 * Its unused bits will be calculated automatically by length of4156 * ‘binaryValue‘.
4157 * NOTE: Trailing zeros ‘0‘ will be ignored.4158 * @example4159 * o = new KJUR.asn1.DERBitString();4160 * o.setByBooleanArray("01011");4161 */
4162 this.setByBinaryString = function(binaryString) {4163 binaryString = binaryString.replace(/0+$/, ‘‘);4164 var unusedBits = 8 - binaryString.length % 8;4165 if (unusedBits == 8) unusedBits = 0;4166 for (var i = 0; i <= unusedBits; i++) {4167 binaryString += ‘0‘;4168 }4169 var h = ‘‘;4170 for (var i = 0; i < binaryString.length - 1; i += 8) {4171 var b = binaryString.substr(i, 8);4172 var x = parseInt(b, 2).toString(16);4173 if (x.length == 1) x = ‘0‘ +x;4174 h +=x;4175 }4176 this.hTLV = null;4177 this.isModified = true;4178 this.hV = ‘0‘ + unusedBits +h;4179 };4180
4181 /**4182 * set ASN.1 TLV value(V) by an array of boolean
4183 * @name setByBooleanArray4184 * @memberOf KJUR.asn1.DERBitString#4185 * @function4186 * @param {array} booleanArray array of boolean (ex. [true, false, true])4187 * @description4188 * NOTE: Trailing falses will be ignored in the ASN.1 DER Object.4189 * @example4190 * o = new KJUR.asn1.DERBitString();4191 * o.setByBooleanArray([false, true, false, true, true]);4192 */
4193 this.setByBooleanArray = function(booleanArray) {4194 var s = ‘‘;4195 for (var i = 0; i < booleanArray.length; i++) {4196 if (booleanArray[i] == true) {4197 s += ‘1‘;4198 } else{4199 s += ‘0‘;4200 }4201 }4202 this.setByBinaryString(s);4203 };4204
4205 /**4206 * generate an array of falses with specified length
4207 * @name newFalseArray4208 * @memberOf KJUR.asn1.DERBitString4209 * @function4210 * @param {Integer} nLength length of array to generate4211 * @return {array} array of boolean falses4212 * @description4213 * This static method may be useful to initialize boolean array.4214 * @example4215 * o = new KJUR.asn1.DERBitString();4216 * o.newFalseArray(3) → [false, false, false]4217 */
4218 this.newFalseArray = function(nLength) {4219 var a = newArray(nLength);4220 for (var i = 0; i < nLength; i++) {4221 a[i] = false;4222 }4223 returna;4224 };4225
4226 this.getFreshValueHex = function() {4227 return this.hV;4228 };4229
4230 if (typeof params != "undefined") {4231 if (typeof params == "string" && params.toLowerCase().match(/^[0-9a-f]+$/)) {4232 this.setHexValueIncludingUnusedBits(params);4233 } else if (typeof params[‘hex‘] != "undefined") {4234 this.setHexValueIncludingUnusedBits(params[‘hex‘]);4235 } else if (typeof params[‘bin‘] != "undefined") {4236 this.setByBinaryString(params[‘bin‘]);4237 } else if (typeof params[‘array‘] != "undefined") {4238 this.setByBooleanArray(params[‘array‘]);4239 }4240 }4241 };4242 YAHOO.lang.extend(KJUR.asn1.DERBitString, KJUR.asn1.ASN1Object);4243
4244 //********************************************************************
4245 /**4246 * class for ASN.1 DER OctetString
4247 * @name KJUR.asn1.DEROctetString4248 * @class class for ASN.1 DER OctetString4249 * @param {Array} params associative array of parameters (ex. {‘str‘: ‘aaa‘})4250 * @extends KJUR.asn1.DERAbstractString4251 * @description4252 * This class provides ASN.1 OctetString simple type.
4253 * Supported "params" attributes are:4254 *
- 4255 *
- str - to set a string as a value4256 *
- hex - to set a hexadecimal string as a value4257 *
- obj - to set a encapsulated ASN.1 value by JSON object4258 * which is defined in [email protected] KJUR.asn1.ASN1Util.newObject}4259 *
4281 KJUR.asn1.DEROctetString = function(params) {4282 if (params !== undefined && typeof params.obj !== "undefined") {4283 var o =KJUR.asn1.ASN1Util.newObject(params.obj);4284 params.hex =o.getEncodedHex();4285 }4286 KJUR.asn1.DEROctetString.superclass.constructor.call(this, params);4287 this.hT = "04";4288 };4289 YAHOO.lang.extend(KJUR.asn1.DEROctetString, KJUR.asn1.DERAbstractString);4290
4291 //********************************************************************
4292 /**4293 * class for ASN.1 DER Null4294 * @name KJUR.asn1.DERNull4295 * @class class for ASN.1 DER Null4296 * @extends KJUR.asn1.ASN1Object4297 * @description4298 * @see KJUR.asn1.ASN1Object - superclass4299 */
4300 KJUR.asn1.DERNull = function() {4301 KJUR.asn1.DERNull.superclass.constructor.call(this);4302 this.hT = "05";4303 this.hTLV = "0500";4304 };4305 YAHOO.lang.extend(KJUR.asn1.DERNull, KJUR.asn1.ASN1Object);4306
4307 //********************************************************************
4308 /**4309 * class for ASN.1 DER ObjectIdentifier4310 * @name KJUR.asn1.DERObjectIdentifier4311 * @class class for ASN.1 DER ObjectIdentifier4312 * @param {Array} params associative array of parameters (ex. {‘oid‘: ‘2.5.4.5‘})4313 * @extends KJUR.asn1.ASN1Object4314 * @description4315 *
4316 * As for argument ‘params‘ for constructor, you can specify one of4317 * following properties:4318 *
- 4319 *
- oid - specify initial ASN.1 value(V) by a oid string (ex. 2.5.4.13)4320 *
- hex - specify initial ASN.1 value(V) by a hexadecimal string4321 *
4324 KJUR.asn1.DERObjectIdentifier = function(params) {4325 var itox = function(i) {4326 var h = i.toString(16);4327 if (h.length == 1) h = ‘0‘ +h;4328 returnh;4329 };4330 var roidtox = function(roid) {4331 var h = ‘‘;4332 var bi = new BigInteger(roid, 10);4333 var b = bi.toString(2);4334 var padLen = 7 - b.length % 7;4335 if (padLen == 7) padLen = 0;4336 var bPad = ‘‘;4337 for (var i = 0; i < padLen; i++) bPad += ‘0‘;4338 b = bPad +b;4339 for (var i = 0; i < b.length - 1; i += 7) {4340 var b8 = b.substr(i, 7);4341 if (i != b.length - 7) b8 = ‘1‘ +b8;4342 h += itox(parseInt(b8, 2));4343 }4344 returnh;4345 };4346
4347 KJUR.asn1.DERObjectIdentifier.superclass.constructor.call(this);4348 this.hT = "06";4349
4350 /**4351 * set value by a hexadecimal string4352 * @name setValueHex4353 * @memberOf KJUR.asn1.DERObjectIdentifier#4354 * @function4355 * @param {String} newHexString hexadecimal value of OID bytes4356 */
4357 this.setValueHex = function(newHexString) {4358 this.hTLV = null;4359 this.isModified = true;4360 this.s = null;4361 this.hV =newHexString;4362 };4363
4364 /**4365 * set value by a OID string
4366 * @name setValueOidString4367 * @memberOf KJUR.asn1.DERObjectIdentifier#4368 * @function4369 * @param {String} oidString OID string (ex. 2.5.4.13)4370 * @example4371 * o = new KJUR.asn1.DERObjectIdentifier();4372 * o.setValueOidString("2.5.4.13");4373 */
4374 this.setValueOidString = function(oidString) {4375 if (! oidString.match(/^[0-9.]+$/)) {4376 throw "malformed oid string: " +oidString;4377 }4378 var h = ‘‘;4379 var a = oidString.split(‘.‘);4380 var i0 = parseInt(a[0]) * 40 + parseInt(a[1]);4381 h +=itox(i0);4382 a.splice(0, 2);4383 for (var i = 0; i < a.length; i++) {4384 h +=roidtox(a[i]);4385 }4386 this.hTLV = null;4387 this.isModified = true;4388 this.s = null;4389 this.hV =h;4390 };4391
4392 /**4393 * set value by a OID name4394 * @name setValueName4395 * @memberOf KJUR.asn1.DERObjectIdentifier#4396 * @function4397 * @param {String} oidName OID name (ex. ‘serverAuth‘)4398 * @since 1.0.14399 * @description4400 * OID name shall be defined in ‘KJUR.asn1.x509.OID.name2oidList‘.4401 * Otherwise raise error.4402 * @example4403 * o = new KJUR.asn1.DERObjectIdentifier();4404 * o.setValueName("serverAuth");4405 */
4406 this.setValueName = function(oidName) {4407 var oid =KJUR.asn1.x509.OID.name2oid(oidName);4408 if (oid !== ‘‘) {4409 this.setValueOidString(oid);4410 } else{4411 throw "DERObjectIdentifier oidName undefined: " +oidName;4412 }4413 };4414
4415 this.getFreshValueHex = function() {4416 return this.hV;4417 };4418
4419 if (params !==undefined) {4420 if (typeof params === "string") {4421 if (params.match(/^[0-2].[0-9.]+$/)) {4422 this.setValueOidString(params);4423 } else{4424 this.setValueName(params);4425 }4426 } else if (params.oid !==undefined) {4427 this.setValueOidString(params.oid);4428 } else if (params.hex !==undefined) {4429 this.setValueHex(params.hex);4430 } else if (params.name !==undefined) {4431 this.setValueName(params.name);4432 }4433 }4434 };4435 YAHOO.lang.extend(KJUR.asn1.DERObjectIdentifier, KJUR.asn1.ASN1Object);4436
4437 //********************************************************************
4438 /**4439 * class for ASN.1 DER Enumerated4440 * @name KJUR.asn1.DEREnumerated4441 * @class class for ASN.1 DER Enumerated4442 * @extends KJUR.asn1.ASN1Object4443 * @description4444 *
4445 * As for argument ‘params‘ for constructor, you can specify one of4446 * following properties:4447 *
- 4448 *
- int - specify initial ASN.1 value(V) by integer value4449 *
- hex - specify initial ASN.1 value(V) by a hexadecimal string4450 *
4457 KJUR.asn1.DEREnumerated = function(params) {4458 KJUR.asn1.DEREnumerated.superclass.constructor.call(this);4459 this.hT = "0a";4460
4461 /**4462 * set value by Tom Wu‘s BigInteger object4463 * @name setByBigInteger4464 * @memberOf KJUR.asn1.DEREnumerated#4465 * @function4466 * @param {BigInteger} bigIntegerValue to set4467 */
4468 this.setByBigInteger = function(bigIntegerValue) {4469 this.hTLV = null;4470 this.isModified = true;4471 this.hV =KJUR.asn1.ASN1Util.bigIntToMinTwosComplementsHex(bigIntegerValue);4472 };4473
4474 /**4475 * set value by integer value4476 * @name setByInteger4477 * @memberOf KJUR.asn1.DEREnumerated#4478 * @function4479 * @param {Integer} integer value to set4480 */
4481 this.setByInteger = function(intValue) {4482 var bi = new BigInteger(String(intValue), 10);4483 this.setByBigInteger(bi);4484 };4485
4486 /**4487 * set value by integer value4488 * @name setValueHex4489 * @memberOf KJUR.asn1.DEREnumerated#4490 * @function4491 * @param {String} hexadecimal string of integer value4492 * @description4493 *
4494 * NOTE: Value shall be represented by minimum octet length of4495 * two‘s complement representation.4496 */
4497 this.setValueHex = function(newHexString) {4498 this.hV =newHexString;4499 };4500
4501 this.getFreshValueHex = function() {4502 return this.hV;4503 };4504
4505 if (typeof params != "undefined") {4506 if (typeof params[‘int‘] != "undefined") {4507 this.setByInteger(params[‘int‘]);4508 } else if (typeof params == "number") {4509 this.setByInteger(params);4510 } else if (typeof params[‘hex‘] != "undefined") {4511 this.setValueHex(params[‘hex‘]);4512 }4513 }4514 };4515 YAHOO.lang.extend(KJUR.asn1.DEREnumerated, KJUR.asn1.ASN1Object);4516
4517 //********************************************************************
4518 /**4519 * class for ASN.1 DER UTF8String4520 * @name KJUR.asn1.DERUTF8String4521 * @class class for ASN.1 DER UTF8String4522 * @param {Array} params associative array of parameters (ex. {‘str‘: ‘aaa‘})4523 * @extends KJUR.asn1.DERAbstractString4524 * @description4525 * @see KJUR.asn1.DERAbstractString - superclass4526 */
4527 KJUR.asn1.DERUTF8String = function(params) {4528 KJUR.asn1.DERUTF8String.superclass.constructor.call(this, params);4529 this.hT = "0c";4530 };4531 YAHOO.lang.extend(KJUR.asn1.DERUTF8String, KJUR.asn1.DERAbstractString);4532
4533 //********************************************************************
4534 /**4535 * class for ASN.1 DER NumericString4536 * @name KJUR.asn1.DERNumericString4537 * @class class for ASN.1 DER NumericString4538 * @param {Array} params associative array of parameters (ex. {‘str‘: ‘aaa‘})4539 * @extends KJUR.asn1.DERAbstractString4540 * @description4541 * @see KJUR.asn1.DERAbstractString - superclass4542 */
4543 KJUR.asn1.DERNumericString = function(params) {4544 KJUR.asn1.DERNumericString.superclass.constructor.call(this, params);4545 this.hT = "12";4546 };4547 YAHOO.lang.extend(KJUR.asn1.DERNumericString, KJUR.asn1.DERAbstractString);4548
4549 //********************************************************************
4550 /**4551 * class for ASN.1 DER PrintableString4552 * @name KJUR.asn1.DERPrintableString4553 * @class class for ASN.1 DER PrintableString4554 * @param {Array} params associative array of parameters (ex. {‘str‘: ‘aaa‘})4555 * @extends KJUR.asn1.DERAbstractString4556 * @description4557 * @see KJUR.asn1.DERAbstractString - superclass4558 */
4559 KJUR.asn1.DERPrintableString = function(params) {4560 KJUR.asn1.DERPrintableString.superclass.constructor.call(this, params);4561 this.hT = "13";4562 };4563 YAHOO.lang.extend(KJUR.asn1.DERPrintableString, KJUR.asn1.DERAbstractString);4564
4565 //********************************************************************
4566 /**4567 * class for ASN.1 DER TeletexString4568 * @name KJUR.asn1.DERTeletexString4569 * @class class for ASN.1 DER TeletexString4570 * @param {Array} params associative array of parameters (ex. {‘str‘: ‘aaa‘})4571 * @extends KJUR.asn1.DERAbstractString4572 * @description4573 * @see KJUR.asn1.DERAbstractString - superclass4574 */
4575 KJUR.asn1.DERTeletexString = function(params) {4576 KJUR.asn1.DERTeletexString.superclass.constructor.call(this, params);4577 this.hT = "14";4578 };4579 YAHOO.lang.extend(KJUR.asn1.DERTeletexString, KJUR.asn1.DERAbstractString);4580
4581 //********************************************************************
4582 /**4583 * class for ASN.1 DER IA5String4584 * @name KJUR.asn1.DERIA5String4585 * @class class for ASN.1 DER IA5String4586 * @param {Array} params associative array of parameters (ex. {‘str‘: ‘aaa‘})4587 * @extends KJUR.asn1.DERAbstractString4588 * @description4589 * @see KJUR.asn1.DERAbstractString - superclass4590 */
4591 KJUR.asn1.DERIA5String = function(params) {4592 KJUR.asn1.DERIA5String.superclass.constructor.call(this, params);4593 this.hT = "16";4594 };4595 YAHOO.lang.extend(KJUR.asn1.DERIA5String, KJUR.asn1.DERAbstractString);4596
4597 //********************************************************************
4598 /**4599 * class for ASN.1 DER UTCTime4600 * @name KJUR.asn1.DERUTCTime4601 * @class class for ASN.1 DER UTCTime4602 * @param {Array} params associative array of parameters (ex. {‘str‘: ‘130430235959Z‘})4603 * @extends KJUR.asn1.DERAbstractTime4604 * @description4605 *
4606 * As for argument ‘params‘ for constructor, you can specify one of4607 * following properties:4608 *
- 4609 *
- str - specify initial ASN.1 value(V) by a string (ex.‘130430235959Z‘)4610 *
- hex - specify initial ASN.1 value(V) by a hexadecimal string4611 *
- date - specify Date object.4612 *
EXAMPLES
4615 * @example4616 * d1 = new KJUR.asn1.DERUTCTime();4617 * d1.setString(‘130430125959Z‘);4618 *4619 * d2 = new KJUR.asn1.DERUTCTime({‘str‘: ‘130430125959Z‘});4620 * d3 = new KJUR.asn1.DERUTCTime({‘date‘: new Date(Date.UTC(2015, 0, 31, 0, 0, 0, 0))});4621 * d4 = new KJUR.asn1.DERUTCTime(‘130430125959Z‘);4622 */4623 KJUR.asn1.DERUTCTime = function(params) {4624 KJUR.asn1.DERUTCTime.superclass.constructor.call(this, params);4625 this.hT = "17";4626
4627 /**4628 * set value by a Date object
4629 * @name setByDate4630 * @memberOf KJUR.asn1.DERUTCTime#4631 * @function4632 * @param {Date} dateObject Date object to set ASN.1 value(V)4633 * @example4634 * o = new KJUR.asn1.DERUTCTime();4635 * o.setByDate(new Date("2016/12/31"));4636 */
4637 this.setByDate = function(dateObject) {4638 this.hTLV = null;4639 this.isModified = true;4640 this.date =dateObject;4641 this.s = this.formatDate(this.date, ‘utc‘);4642 this.hV = stohex(this.s);4643 };4644
4645 this.getFreshValueHex = function() {4646 if (typeof this.date == "undefined" && typeof this.s == "undefined") {4647 this.date = newDate();4648 this.s = this.formatDate(this.date, ‘utc‘);4649 this.hV = stohex(this.s);4650 }4651 return this.hV;4652 };4653
4654 if (params !==undefined) {4655 if (params.str !==undefined) {4656 this.setString(params.str);4657 } else if (typeof params == "string" && params.match(/^[0-9]{12}Z$/)) {4658 this.setString(params);4659 } else if (params.hex !==undefined) {4660 this.setStringHex(params.hex);4661 } else if (params.date !==undefined) {4662 this.setByDate(params.date);4663 }4664 }4665 };4666 YAHOO.lang.extend(KJUR.asn1.DERUTCTime, KJUR.asn1.DERAbstractTime);4667
4668 //********************************************************************
4669 /**4670 * class for ASN.1 DER GeneralizedTime4671 * @name KJUR.asn1.DERGeneralizedTime4672 * @class class for ASN.1 DER GeneralizedTime4673 * @param {Array} params associative array of parameters (ex. {‘str‘: ‘20130430235959Z‘})4674 * @property {Boolean} withMillis flag to show milliseconds or not4675 * @extends KJUR.asn1.DERAbstractTime4676 * @description4677 *
4678 * As for argument ‘params‘ for constructor, you can specify one of4679 * following properties:4680 *
- 4681 *
- str - specify initial ASN.1 value(V) by a string (ex.‘20130430235959Z‘)4682 *
- hex - specify initial ASN.1 value(V) by a hexadecimal string4683 *
- date - specify Date object.4684 *
- millis - specify flag to show milliseconds (from 1.0.6)4685 *
4689 KJUR.asn1.DERGeneralizedTime = function(params) {4690 KJUR.asn1.DERGeneralizedTime.superclass.constructor.call(this, params);4691 this.hT = "18";4692 this.withMillis = false;4693
4694 /**4695 * set value by a Date object4696 * @name setByDate4697 * @memberOf KJUR.asn1.DERGeneralizedTime#4698 * @function4699 * @param {Date} dateObject Date object to set ASN.1 value(V)4700 * @example4701 * When you specify UTC time, use ‘Date.UTC‘ method like this:
4702 * o1 = new DERUTCTime();4703 * o1.setByDate(date);4704 *4705 * date = new Date(Date.UTC(2015, 0, 31, 23, 59, 59, 0)); #2015JAN31 23:59:594706 */
4707 this.setByDate = function(dateObject) {4708 this.hTLV = null;4709 this.isModified = true;4710 this.date =dateObject;4711 this.s = this.formatDate(this.date, ‘gen‘, this.withMillis);4712 this.hV = stohex(this.s);4713 };4714
4715 this.getFreshValueHex = function() {4716 if (this.date === undefined && this.s ===undefined) {4717 this.date = newDate();4718 this.s = this.formatDate(this.date, ‘gen‘, this.withMillis);4719 this.hV = stohex(this.s);4720 }4721 return this.hV;4722 };4723
4724 if (params !==undefined) {4725 if (params.str !==undefined) {4726 this.setString(params.str);4727 } else if (typeof params == "string" && params.match(/^[0-9]{14}Z$/)) {4728 this.setString(params);4729 } else if (params.hex !==undefined) {4730 this.setStringHex(params.hex);4731 } else if (params.date !==undefined) {4732 this.setByDate(params.date);4733 }4734 if (params.millis === true) {4735 this.withMillis = true;4736 }4737 }4738 };4739 YAHOO.lang.extend(KJUR.asn1.DERGeneralizedTime, KJUR.asn1.DERAbstractTime);4740
4741 //********************************************************************
4742 /**4743 * class for ASN.1 DER Sequence4744 * @name KJUR.asn1.DERSequence4745 * @class class for ASN.1 DER Sequence4746 * @extends KJUR.asn1.DERAbstractStructured4747 * @description4748 *
4749 * As for argument ‘params‘ for constructor, you can specify one of4750 * following properties:4751 *
- 4752 *
- array - specify array of ASN1Object to set elements of content4753 *
4756 KJUR.asn1.DERSequence = function(params) {4757 KJUR.asn1.DERSequence.superclass.constructor.call(this, params);4758 this.hT = "30";4759 this.getFreshValueHex = function() {4760 var h = ‘‘;4761 for (var i = 0; i < this.asn1Array.length; i++) {4762 var asn1Obj = this.asn1Array[i];4763 h +=asn1Obj.getEncodedHex();4764 }4765 this.hV =h;4766 return this.hV;4767 };4768 };4769 YAHOO.lang.extend(KJUR.asn1.DERSequence, KJUR.asn1.DERAbstractStructured);4770
4771 //********************************************************************
4772 /**4773 * class for ASN.1 DER Set4774 * @name KJUR.asn1.DERSet4775 * @class class for ASN.1 DER Set4776 * @extends KJUR.asn1.DERAbstractStructured4777 * @description4778 *
4779 * As for argument ‘params‘ for constructor, you can specify one of4780 * following properties:4781 *
- 4782 *
- array - specify array of ASN1Object to set elements of content4783 *
- sortflag - flag for sort (default: true). ASN.1 BER is not sorted in ‘SET OF‘.4784 *
4786 * NOTE2: sortflag is supported since 1.0.5.4787 */
4788 KJUR.asn1.DERSet = function(params) {4789 KJUR.asn1.DERSet.superclass.constructor.call(this, params);4790 this.hT = "31";4791 this.sortFlag = true; //item shall be sorted only in ASN.1 DER
4792 this.getFreshValueHex = function() {4793 var a = newArray();4794 for (var i = 0; i < this.asn1Array.length; i++) {4795 var asn1Obj = this.asn1Array[i];4796 a.push(asn1Obj.getEncodedHex());4797 }4798 if (this.sortFlag == true) a.sort();4799 this.hV = a.join(‘‘);4800 return this.hV;4801 };4802
4803 if (typeof params != "undefined") {4804 if (typeof params.sortflag != "undefined" &&
4805 params.sortflag == false)4806 this.sortFlag = false;4807 }4808 };4809 YAHOO.lang.extend(KJUR.asn1.DERSet, KJUR.asn1.DERAbstractStructured);4810
4811 //********************************************************************
4812 /**4813 * class for ASN.1 DER TaggedObject4814 * @name KJUR.asn1.DERTaggedObject4815 * @class class for ASN.1 DER TaggedObject4816 * @extends KJUR.asn1.ASN1Object4817 * @description4818 *
4819 * Parameter ‘tagNoNex‘ is ASN.1 tag(T) value for this object.4820 * For example, if you find ‘[1]‘ tag in a ASN.1 dump,4821 * ‘tagNoHex‘ will be ‘a1‘.4822 *
4823 * As for optional argument ‘params‘ for constructor, you can specify *ANY* of4824 * following properties:4825 *
- 4826 *
- explicit - specify true if this is explicit tag otherwise false4827 * (default is ‘true‘).4828 *
- tag - specify tag (default is ‘a0‘ which means [0])4829 *
- obj - specify ASN1Object which is tagged4830 *
4836 KJUR.asn1.DERTaggedObject = function(params) {4837 KJUR.asn1.DERTaggedObject.superclass.constructor.call(this);4838 this.hT = "a0";4839 this.hV = ‘‘;4840 this.isExplicit = true;4841 this.asn1Object = null;4842
4843 /**4844 * set value by an ASN1Object4845 * @name setString4846 * @memberOf KJUR.asn1.DERTaggedObject#4847 * @function4848 * @param {Boolean} isExplicitFlag flag for explicit/implicit tag4849 * @param {Integer} tagNoHex hexadecimal string of ASN.1 tag4850 * @param {ASN1Object} asn1Object ASN.1 to encapsulate4851 */
4852 this.setASN1Object = function(isExplicitFlag, tagNoHex, asn1Object) {4853 this.hT =tagNoHex;4854 this.isExplicit =isExplicitFlag;4855 this.asn1Object =asn1Object;4856 if (this.isExplicit) {4857 this.hV = this.asn1Object.getEncodedHex();4858 this.hTLV = null;4859 this.isModified = true;4860 } else{4861 this.hV = null;4862 this.hTLV =asn1Object.getEncodedHex();4863 this.hTLV = this.hTLV.replace(/^../, tagNoHex);4864 this.isModified = false;4865 }4866 };4867
4868 this.getFreshValueHex = function() {4869 return this.hV;4870 };4871
4872 if (typeof params != "undefined") {4873 if (typeof params[‘tag‘] != "undefined") {4874 this.hT = params[‘tag‘];4875 }4876 if (typeof params[‘explicit‘] != "undefined") {4877 this.isExplicit = params[‘explicit‘];4878 }4879 if (typeof params[‘obj‘] != "undefined") {4880 this.asn1Object = params[‘obj‘];4881 this.setASN1Object(this.isExplicit, this.hT, this.asn1Object);4882 }4883 }4884 };4885 YAHOO.lang.extend(KJUR.asn1.DERTaggedObject, KJUR.asn1.ASN1Object);4886
4887 /**4888 * Create a new JSEncryptRSAKey that extends Tom Wu‘s RSA key object.4889 * This object is just a decorator for parsing the key parameter4890 * @param {string|Object} key - The key in string format, or an object containing4891 * the parameters needed to build a RSAKey object.4892 * @constructor4893 */
4894 var JSEncryptRSAKey = /** @class*/ (function(_super) {4895 __extends(JSEncryptRSAKey, _super);4896 functionJSEncryptRSAKey(key) {4897 var _this = _super.call(this) || this;4898 //Call the super constructor.
4899 //RSAKey.call(this);
4900 //If a key key was provided.
4901 if(key) {4902 //If this is a string...
4903 if (typeof key === "string") {4904 _this.parseKey(key);4905 }4906 else if (JSEncryptRSAKey.hasPrivateKeyProperty(key) ||
4907 JSEncryptRSAKey.hasPublicKeyProperty(key)) {4908 //Set the values for the key.
4909 _this.parsePropertiesFrom(key);4910 }4911 }4912 return_this;4913 }4914 /**4915 * Method to parse a pem encoded string containing both a public or private key.4916 * The method will translate the pem encoded string in a der encoded string and4917 * will parse private key and public key parameters. This method accepts public key4918 * in the rsaencryption pkcs #1 format (oid: 1.2.840.113549.1.1.1).4919 *4920 * @todo Check how many rsa formats use the same format of pkcs #1.4921 *4922 * The format is defined as:4923 * PublicKeyInfo ::= SEQUENCE {4924 * algorithm AlgorithmIdentifier,4925 * PublicKey BIT STRING4926 * }4927 * Where AlgorithmIdentifier is:4928 * AlgorithmIdentifier ::= SEQUENCE {4929 * algorithm OBJECT IDENTIFIER, the OID of the enc algorithm4930 * parameters ANY DEFINED BY algorithm OPTIONAL (NULL for PKCS #1)4931 * }4932 * and PublicKey is a SEQUENCE encapsulated in a BIT STRING4933 * RSAPublicKey ::= SEQUENCE {4934 * modulus INTEGER, -- n4935 * publicExponent INTEGER -- e4936 * }4937 * it‘s possible to examine the structure of the keys obtained from openssl using4938 * an asn.1 dumper as the one used here to parse the components: http://lapo.it/asn1js/4939 * @argument {string} pem the pem encoded string, can include the BEGIN/END header/footer4940 * @private4941 */
4942 JSEncryptRSAKey.prototype.parseKey = function(pem) {4943 try{4944 var modulus = 0;4945 var public_exponent = 0;4946 var reHex = /^\s*(?:[0-9A-Fa-f][0-9A-Fa-f]\s*)+$/;4947 var der = reHex.test(pem) ?Hex.decode(pem) : Base64.unarmor(pem);4948 var asn1 =ASN1.decode(der);4949 //Fixes a bug with OpenSSL 1.0+ private keys
4950 if (asn1.sub.length === 3) {4951 asn1 = asn1.sub[2].sub[0];4952 }4953 if (asn1.sub.length === 9) {4954 //Parse the private key.
4955 modulus = asn1.sub[1].getHexStringValue(); //bigint
4956 this.n = parseBigInt(modulus, 16);4957 public_exponent = asn1.sub[2].getHexStringValue(); //int
4958 this.e = parseInt(public_exponent, 16);4959 var private_exponent = asn1.sub[3].getHexStringValue(); //bigint
4960 this.d = parseBigInt(private_exponent, 16);4961 var prime1 = asn1.sub[4].getHexStringValue(); //bigint
4962 this.p = parseBigInt(prime1, 16);4963 var prime2 = asn1.sub[5].getHexStringValue(); //bigint
4964 this.q = parseBigInt(prime2, 16);4965 var exponent1 = asn1.sub[6].getHexStringValue(); //bigint
4966 this.dmp1 = parseBigInt(exponent1, 16);4967 var exponent2 = asn1.sub[7].getHexStringValue(); //bigint
4968 this.dmq1 = parseBigInt(exponent2, 16);4969 var coefficient = asn1.sub[8].getHexStringValue(); //bigint
4970 this.coeff = parseBigInt(coefficient, 16);4971 }4972 else if (asn1.sub.length === 2) {4973 //Parse the public key.
4974 var bit_string = asn1.sub[1];4975 var sequence = bit_string.sub[0];4976 modulus = sequence.sub[0].getHexStringValue();4977 this.n = parseBigInt(modulus, 16);4978 public_exponent = sequence.sub[1].getHexStringValue();4979 this.e = parseInt(public_exponent, 16);4980 }4981 else{4982 return false;4983 }4984 return true;4985 }4986 catch(ex) {4987 return false;4988 }4989 };4990 /**4991 * Translate rsa parameters in a hex encoded string representing the rsa key.4992 *4993 * The translation follow the ASN.1 notation :4994 * RSAPrivateKey ::= SEQUENCE {4995 * version Version,4996 * modulus INTEGER, -- n4997 * publicExponent INTEGER, -- e4998 * privateExponent INTEGER, -- d4999 * prime1 INTEGER, -- p5000 * prime2 INTEGER, -- q5001 * exponent1 INTEGER, -- d mod (p1)5002 * exponent2 INTEGER, -- d mod (q-1)5003 * coefficient INTEGER, -- (inverse of q) mod p5004 * }5005 * @returns {string} DER Encoded String representing the rsa private key5006 * @private5007 */
5008 JSEncryptRSAKey.prototype.getPrivateBaseKey = function() {5009 var options ={5010 array: [5011 new KJUR.asn1.DERInteger({ int: 0}),5012 new KJUR.asn1.DERInteger({ bigint: this.n }),5013 new KJUR.asn1.DERInteger({ int: this.e }),5014 new KJUR.asn1.DERInteger({ bigint: this.d }),5015 new KJUR.asn1.DERInteger({ bigint: this.p }),5016 new KJUR.asn1.DERInteger({ bigint: this.q }),5017 new KJUR.asn1.DERInteger({ bigint: this.dmp1 }),5018 new KJUR.asn1.DERInteger({ bigint: this.dmq1 }),5019 new KJUR.asn1.DERInteger({ bigint: this.coeff })5020 ]5021 };5022 var seq = newKJUR.asn1.DERSequence(options);5023 returnseq.getEncodedHex();5024 };5025 /**5026 * base64 (pem) encoded version of the DER encoded representation5027 * @returns {string} pem encoded representation without header and footer5028 * @public5029 */
5030 JSEncryptRSAKey.prototype.getPrivateBaseKeyB64 = function() {5031 return hex2b64(this.getPrivateBaseKey());5032 };5033 /**5034 * Translate rsa parameters in a hex encoded string representing the rsa public key.5035 * The representation follow the ASN.1 notation :5036 * PublicKeyInfo ::= SEQUENCE {5037 * algorithm AlgorithmIdentifier,5038 * PublicKey BIT STRING5039 * }5040 * Where AlgorithmIdentifier is:5041 * AlgorithmIdentifier ::= SEQUENCE {5042 * algorithm OBJECT IDENTIFIER, the OID of the enc algorithm5043 * parameters ANY DEFINED BY algorithm OPTIONAL (NULL for PKCS #1)5044 * }5045 * and PublicKey is a SEQUENCE encapsulated in a BIT STRING5046 * RSAPublicKey ::= SEQUENCE {5047 * modulus INTEGER, -- n5048 * publicExponent INTEGER -- e5049 * }5050 * @returns {string} DER Encoded String representing the rsa public key5051 * @private5052 */
5053 JSEncryptRSAKey.prototype.getPublicBaseKey = function() {5054 var first_sequence = newKJUR.asn1.DERSequence({5055 array: [5056 new KJUR.asn1.DERObjectIdentifier({ oid: "1.2.840.113549.1.1.1"}),5057 newKJUR.asn1.DERNull()5058 ]5059 });5060 var second_sequence = newKJUR.asn1.DERSequence({5061 array: [5062 new KJUR.asn1.DERInteger({ bigint: this.n }),5063 new KJUR.asn1.DERInteger({ int: this.e })5064 ]5065 });5066 var bit_string = newKJUR.asn1.DERBitString({5067 hex: "00" +second_sequence.getEncodedHex()5068 });5069 var seq = newKJUR.asn1.DERSequence({5070 array: [5071 first_sequence,5072 bit_string5073 ]5074 });5075 returnseq.getEncodedHex();5076 };5077 /**5078 * base64 (pem) encoded version of the DER encoded representation5079 * @returns {string} pem encoded representation without header and footer5080 * @public5081 */
5082 JSEncryptRSAKey.prototype.getPublicBaseKeyB64 = function() {5083 return hex2b64(this.getPublicBaseKey());5084 };5085 /**5086 * wrap the string in block of width chars. The default value for rsa keys is 645087 * characters.5088 * @param {string} str the pem encoded string without header and footer5089 * @param {Number} [width=64] - the length the string has to be wrapped at5090 * @returns {string}5091 * @private5092 */
5093 JSEncryptRSAKey.wordwrap = function(str, width) {5094 width = width || 64;5095 if (!str) {5096 returnstr;5097 }5098 var regex = "(.{1," + width + "})( +|$\n?)|(.{1," + width + "})";5099 return str.match(RegExp(regex, "g")).join("\n");5100 };5101 /**5102 * Retrieve the pem encoded private key5103 * @returns {string} the pem encoded private key with header/footer5104 * @public5105 */
5106 JSEncryptRSAKey.prototype.getPrivateKey = function() {5107 var key = "-----BEGIN RSA PRIVATE KEY-----\n";5108 key += JSEncryptRSAKey.wordwrap(this.getPrivateBaseKeyB64()) + "\n";5109 key += "-----END RSA PRIVATE KEY-----";5110 returnkey;5111 };5112 /**5113 * Retrieve the pem encoded public key5114 * @returns {string} the pem encoded public key with header/footer5115 * @public5116 */
5117 JSEncryptRSAKey.prototype.getPublicKey = function() {5118 var key = "-----BEGIN PUBLIC KEY-----\n";5119 key += JSEncryptRSAKey.wordwrap(this.getPublicBaseKeyB64()) + "\n";5120 key += "-----END PUBLIC KEY-----";5121 returnkey;5122 };5123 /**5124 * Check if the object contains the necessary parameters to populate the rsa modulus5125 * and public exponent parameters.5126 * @param {Object} [obj={}] - An object that may contain the two public key5127 * parameters5128 * @returns {boolean} true if the object contains both the modulus and the public exponent5129 * properties (n and e)5130 * @todo check for types of n and e. N should be a parseable bigInt object, E should5131 * be a parseable integer number5132 * @private5133 */
5134 JSEncryptRSAKey.hasPublicKeyProperty = function(obj) {5135 obj = obj ||{};5136 return (obj.hasOwnProperty("n") &&
5137 obj.hasOwnProperty("e"));5138 };5139 /**5140 * Check if the object contains ALL the parameters of an RSA key.5141 * @param {Object} [obj={}] - An object that may contain nine rsa key5142 * parameters5143 * @returns {boolean} true if the object contains all the parameters needed5144 * @todo check for types of the parameters all the parameters but the public exponent5145 * should be parseable bigint objects, the public exponent should be a parseable integer number5146 * @private5147 */
5148 JSEncryptRSAKey.hasPrivateKeyProperty = function(obj) {5149 obj = obj ||{};5150 return (obj.hasOwnProperty("n") &&
5151 obj.hasOwnProperty("e") &&
5152 obj.hasOwnProperty("d") &&
5153 obj.hasOwnProperty("p") &&
5154 obj.hasOwnProperty("q") &&
5155 obj.hasOwnProperty("dmp1") &&
5156 obj.hasOwnProperty("dmq1") &&
5157 obj.hasOwnProperty("coeff"));5158 };5159 /**5160 * Parse the properties of obj in the current rsa object. Obj should AT LEAST5161 * include the modulus and public exponent (n, e) parameters.5162 * @param {Object} obj - the object containing rsa parameters5163 * @private5164 */
5165 JSEncryptRSAKey.prototype.parsePropertiesFrom = function(obj) {5166 this.n =obj.n;5167 this.e =obj.e;5168 if (obj.hasOwnProperty("d")) {5169 this.d =obj.d;5170 this.p =obj.p;5171 this.q =obj.q;5172 this.dmp1 =obj.dmp1;5173 this.dmq1 =obj.dmq1;5174 this.coeff =obj.coeff;5175 }5176 };5177 returnJSEncryptRSAKey;5178 }(RSAKey));5179
5180 /**5181 *5182 * @param {Object} [options = {}] - An object to customize JSEncrypt behaviour5183 * possible parameters are:5184 * - default_key_size {number} default: 1024 the key size in bit5185 * - default_public_exponent {string} default: ‘010001‘ the hexadecimal representation of the public exponent5186 * - log {boolean} default: false whether log warn/error or not5187 * @constructor5188 */
5189 var JSEncrypt = /** @class*/ (function() {5190 functionJSEncrypt(options) {5191 options = options ||{};5192 this.default_key_size = parseInt(options.default_key_size, 10) || 1024;5193 this.default_public_exponent = options.default_public_exponent || "010001"; //65537 default openssl public exponent for rsa key type
5194 this.log = options.log || false;5195 //The private and public key.
5196 this.key = null;5197 }5198 /**5199 * Method to set the rsa key parameter (one method is enough to set both the public5200 * and the private key, since the private key contains the public key paramenters)5201 * Log a warning if logs are enabled5202 * @param {Object|string} key the pem encoded string or an object (with or without header/footer)5203 * @public5204 */
5205 JSEncrypt.prototype.setKey = function(key) {5206 if (this.log && this.key) {5207 console.warn("A key was already set, overriding existing.");5208 }5209 this.key = newJSEncryptRSAKey(key);5210 };5211 /**5212 * Proxy method for setKey, for api compatibility5213 * @see setKey5214 * @public5215 */
5216 JSEncrypt.prototype.setPrivateKey = function(privkey) {5217 //Create the key.
5218 this.setKey(privkey);5219 };5220 /**5221 * Proxy method for setKey, for api compatibility5222 * @see setKey5223 * @public5224 */
5225 JSEncrypt.prototype.setPublicKey = function(pubkey) {5226 //Sets the public key.
5227 this.setKey(pubkey);5228 };5229 /**5230 * Proxy method for RSAKey object‘s decrypt, decrypt the string using the private5231 * components of the rsa key object. Note that if the object was not set will be created5232 * on the fly (by the getKey method) using the parameters passed in the JSEncrypt constructor5233 * @param {string} str base64 encoded crypted string to decrypt5234 * @return {string} the decrypted string5235 * @public5236 */
5237 JSEncrypt.prototype.decrypt = function(str) {5238 //Return the decrypted string.
5239 try{5240 return this.getKey().decrypt(b64tohex(str));5241 }5242 catch(ex) {5243 return false;5244 }5245 };5246 /**5247 * Proxy method for RSAKey object‘s encrypt, encrypt the string using the public5248 * components of the rsa key object. Note that if the object was not set will be created5249 * on the fly (by the getKey method) using the parameters passed in the JSEncrypt constructor5250 * @param {string} str the string to encrypt5251 * @return {string} the encrypted string encoded in base645252 * @public5253 */
5254 JSEncrypt.prototype.encrypt = function(str) {5255 //Return the encrypted string.
5256 try{5257 return hex2b64(this.getKey().encrypt(str));5258 }5259 catch(ex) {5260 return false;5261 }5262 };5263 /**5264 * Proxy method for RSAKey object‘s sign.5265 * @param {string} str the string to sign5266 * @param {function} digestMethod hash method5267 * @param {string} digestName the name of the hash algorithm5268 * @return {string} the signature encoded in base645269 * @public5270 */
5271 JSEncrypt.prototype.sign = function(str, digestMethod, digestName) {5272 //return the RSA signature of ‘str‘ in ‘hex‘ format.
5273 try{5274 return hex2b64(this.getKey().sign(str, digestMethod, digestName));5275 }5276 catch(ex) {5277 return false;5278 }5279 };5280 /**5281 * Proxy method for RSAKey object‘s verify.5282 * @param {string} str the string to verify5283 * @param {string} signature the signature encoded in base64 to compare the string to5284 * @param {function} digestMethod hash method5285 * @return {boolean} whether the data and signature match5286 * @public5287 */
5288 JSEncrypt.prototype.verify = function(str, signature, digestMethod) {5289 //Return the decrypted ‘digest‘ of the signature.
5290 try{5291 return this.getKey().verify(str, b64tohex(signature), digestMethod);5292 }5293 catch(ex) {5294 return false;5295 }5296 };5297 /**5298 * Getter for the current JSEncryptRSAKey object. If it doesn‘t exists a new object5299 * will be created and returned5300 * @param {callback} [cb] the callback to be called if we want the key to be generated5301 * in an async fashion5302 * @returns {JSEncryptRSAKey} the JSEncryptRSAKey object5303 * @public5304 */
5305 JSEncrypt.prototype.getKey = function(cb) {5306 //Only create new if it does not exist.
5307 if (!this.key) {5308 //Get a new private key.
5309 this.key = newJSEncryptRSAKey();5310 if (cb && {}.toString.call(cb) === "[object Function]") {5311 this.key.generateAsync(this.default_key_size, this.default_public_exponent, cb);5312 return;5313 }5314 //Generate the key.
5315 this.key.generate(this.default_key_size, this.default_public_exponent);5316 }5317 return this.key;5318 };5319 /**5320 * Returns the pem encoded representation of the private key5321 * If the key doesn‘t exists a new key will be created5322 * @returns {string} pem encoded representation of the private key WITH header and footer5323 * @public5324 */
5325 JSEncrypt.prototype.getPrivateKey = function() {5326 //Return the private representation of this key.
5327 return this.getKey().getPrivateKey();5328 };5329 /**5330 * Returns the pem encoded representation of the private key5331 * If the key doesn‘t exists a new key will be created5332 * @returns {string} pem encoded representation of the private key WITHOUT header and footer5333 * @public5334 */
5335 JSEncrypt.prototype.getPrivateKeyB64 = function() {5336 //Return the private representation of this key.
5337 return this.getKey().getPrivateBaseKeyB64();5338 };5339 /**5340 * Returns the pem encoded representation of the public key5341 * If the key doesn‘t exists a new key will be created5342 * @returns {string} pem encoded representation of the public key WITH header and footer5343 * @public5344 */
5345 JSEncrypt.prototype.getPublicKey = function() {5346 //Return the private representation of this key.
5347 return this.getKey().getPublicKey();5348 };5349 /**5350 * Returns the pem encoded representation of the public key5351 * If the key doesn‘t exists a new key will be created5352 * @returns {string} pem encoded representation of the public key WITHOUT header and footer5353 * @public5354 */
5355 JSEncrypt.prototype.getPublicKeyB64 = function() {5356 //Return the private representation of this key.
5357 return this.getKey().getPublicBaseKeyB64();5358 };5359 JSEncrypt.version = "3.0.0-rc.1";5360 returnJSEncrypt;5361 }());5362
5363 window.JSEncrypt =JSEncrypt;5364
5365 exports.JSEncrypt =JSEncrypt;5366 exports.default =JSEncrypt;5367
5368 Object.defineProperty(exports, ‘__esModule‘, { value: true});5369
5370 })));
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
