【JS求助】调试一个js，参数短了可以，参数一长就卡死，是怎么回事啊

iamafailor

可以直接复制进去js调试工具里面进行调试，主要是第一行
return  LoginRsakey = new RSAKeyPair("010001", "", "A4DCEED2143805800FD0492910A613FBDA3D7F74C4DC917788E2B2EAEE0EF7C9458D090980C6BB0242D7A17E191685B05890C18655A96DEB3D20828C0F01E08E7A6F7CACD24F321001E6AD55398A726AAE9DAB558BF6185D4A34A81CE81*F571816E411CA2B44B7A1B108090F44168EEC88EA746F95D0EB81E58D189213AE27");

第三个参数这么长的话就会卡死

如果短一点就会运行正常

比如：

return  LoginRsakey = new RSAKeyPair("010001", "", "A4DCEED2143805800FD0492910A61");

下面放上全部js脚本

大神可以直接在js调试工具里面调试一下

我不懂为什么长了就会运行不动

恳请解答！！

1. 
   
2. function crack() {
   
3.   return  LoginRsakey = new RSAKeyPair("010001", "", "A4DCEED2143805800FD0492910A613FBDA3D7F74C4DC917788E2B2EAEE0EF7C9458D090980C6BB0242D7A17E191685B05890C18655A96DEB3D20828C0F01E08E7A6F7CACD24F321001E6AD55398A726AAE9DAB558BF6185D4A34A81CE81*F571816E411CA2B44B7A1B108090F44168EEC88EA746F95D0EB81E58D189213AE27");
   
4. }
   
5. 
   
6. 
   
7. // RSA, a suite of routines for performing RSA public-key computations in
   
8. // JavaScript.
   
9. //
   
10. // Requires BigInt.js and Barrett.js.
    
11. //
    
12. // Copyright 1998-2005 David Shapiro.
    
13. //
    
14. // You may use, re-use, abuse, copy, and modify this code to your liking, but
    
15. // please keep this header.
    
16. //
    
17. // Thanks!
    
18. //
    
19. // Dave Shapiro
    
20. // dave@ohdave.com
    
21. 
    
22. function RSAKeyPair(encryptionExponent, decryptionExponent, modulus) {
    
23.     this.e = biFromHex(encryptionExponent);
    
24.     this.d = biFromHex(decryptionExponent);
    
25.     this.m = biFromHex(modulus);
    
26. 
    
27.     // We can do two bytes per digit, so
    
28.     // chunkSize = 2 * (number of digits in modulus - 1).
    
29.     // Since biHighIndex returns the high index, not the number of digits, 1 has
    
30.     // already been subtracted.
    
31.     //this.chunkSize = 2 * biHighIndex(this.m);
    
32. 
    
33.     ////////////////////////////////// TYF
    
34.     this.digitSize = 2 * biHighIndex(this.m) + 2;
    
35.     this.chunkSize = this.digitSize - 11; // maximum, anything lower is fine
    
36.     ////////////////////////////////// TYF
    
37. 
    
38.     this.radix = 16;
    
39.     this.barrett = new BarrettMu(this.m);
    
40. }
    
41. 
    
42. function twoDigit(n) {
    
43.     return (n < 10 ? "0" : "") + String(n);
    
44. }
    
45. 
    
46. function encryptedString(key, s)
    
47. // Altered by Rob Saunders (rob@robsaunders.net). New routine pads the
    
48. // string after it has been converted to an array. This fixes an
    
49. // incompatibility with Flash MX's ActionScript.
    
50. // Altered by Tang Yu Feng for interoperability with Microsoft's
    
51. // RSACryptoServiceProvider implementation.
    
52. {
    
53.     ////////////////////////////////// TYF
    
54.     if (key.chunkSize > key.digitSize - 11) {
    
55.         return "Error";
    
56.     }
    
57.     ////////////////////////////////// TYF
    
58. 
    
59. 
    
60.     var a = new Array();
    
61.     var sl = s.length;
    
62. 
    
63.     var i = 0;
    
64.     while (i < sl) {
    
65.         a[i] = s.charCodeAt(i);
    
66.         i++;
    
67.     }
    
68. 
    
69.     //while (a.length % key.chunkSize != 0) {
    
70.     //        a[i++] = 0;
    
71.     //}
    
72. 
    
73.     var al = a.length;
    
74.     var result = "";
    
75.     var j, k, block;
    
76.     for (i = 0; i < al; i += key.chunkSize) {
    
77.         block = new BigInt();
    
78.         j = 0;
    
79. 
    
80.         //for (k = i; k < i + key.chunkSize; ++j) {
    
81.         //        block.digits[j] = a[k++];
    
82.         //        block.digits[j] += a[k++] << 8;
    
83.         //}
    
84. 
    
85.         ////////////////////////////////// TYF
    
86.         // Add PKCS#1 v1.5 padding
    
87.         // 0x00 || 0x02 || PseudoRandomNonZeroBytes || 0x00 || Message
    
88.         // Variable a before padding must be of at most digitSize-11
    
89.         // That is for 3 marker bytes plus at least 8 random non-zero bytes
    
90.         var x;
    
91.         var msgLength = (i + key.chunkSize) > al ? al % key.chunkSize : key.chunkSize;
    
92. 
    
93.         // Variable b with 0x00 || 0x02 at the highest index.
    
94.         var b = new Array();
    
95.         for (x = 0; x < msgLength; x++) {
    
96.             b[x] = a[i + msgLength - 1 - x];
    
97.         }
    
98.         b[msgLength] = 0; // marker
    
99.         var paddedSize = Math.max(8, key.digitSize - 3 - msgLength);
    
100. 
     
101.         for (x = 0; x < paddedSize; x++) {
     
102.             b[msgLength + 1 + x] = Math.floor(Math.random() * 254) + 1; // [1,255]
     
103.         }
     
104.         // It can be asserted that msgLength+paddedSize == key.digitSize-3
     
105.         b[key.digitSize - 2] = 2; // marker
     
106.         b[key.digitSize - 1] = 0; // marker
     
107. 
     
108.         for (k = 0; k < key.digitSize; ++j) {
     
109.             block.digits[j] = b[k++];
     
110.             block.digits[j] += b[k++] << 8;
     
111.         }
     
112.         ////////////////////////////////// TYF
     
113. 
     
114.         var crypt = key.barrett.powMod(block, key.e);
     
115.         var text = key.radix == 16 ? biToHex(crypt) : biToString(crypt, key.radix);
     
116.         result += text + " ";
     
117.     }
     
118.     return result.substring(0, result.length - 1); // Remove last space.
     
119. }
     
120. 
     
121. function decryptedString(key, s) {
     
122.     var blocks = s.split(" ");
     
123.     var result = "";
     
124.     var i, j, block;
     
125.     for (i = 0; i < blocks.length; ++i) {
     
126.         var bi;
     
127.         if (key.radix == 16) {
     
128.             bi = biFromHex(blocks[i]);
     
129.         }
     
130.         else {
     
131.             bi = biFromString(blocks[i], key.radix);
     
132.         }
     
133.         block = key.barrett.powMod(bi, key.d);
     
134.         for (j = 0; j <= biHighIndex(block); ++j) {
     
135.             result += String.fromCharCode(block.digits[j] & 255,
     
136.                                                       block.digits[j] >> 8);
     
137.         }
     
138.     }
     
139.     // Remove trailing null, if any.
     
140.     if (result.charCodeAt(result.length - 1) == 0) {
     
141.         result = result.substring(0, result.length - 1);
     
142.     }
     
143.     return result;
     
144. }
     
145. // BigInt, a suite of routines for performing multiple-precision arithmetic in
     
146. // JavaScript.
     
147. //
     
148. // Copyright 1998-2005 David Shapiro.
     
149. //
     
150. // You may use, re-use, abuse,
     
151. // copy, and modify this code to your liking, but please keep this header.
     
152. // Thanks!
     
153. //
     
154. // Dave Shapiro
     
155. // dave@ohdave.com
     
156. 
     
157. // IMPORTANT THING: Be sure to set maxDigits according to your precision
     
158. // needs. Use the setMaxDigits() function to do this. See comments below.
     
159. //
     
160. // Tweaked by Ian Bunning
     
161. // Alterations:
     
162. // Fix bug in function biFromHex(s) to allow
     
163. // parsing of strings of length != 0 (mod 4)
     
164. 
     
165. // Changes made by Dave Shapiro as of 12/30/2004:
     
166. //
     
167. // The BigInt() constructor doesn't take a string anymore. If you want to
     
168. // create a BigInt from a string, use biFromDecimal() for base-10
     
169. // representations, biFromHex() for base-16 representations, or
     
170. // biFromString() for base-2-to-36 representations.
     
171. //
     
172. // biFromArray() has been removed. Use biCopy() instead, passing a BigInt
     
173. // instead of an array.
     
174. //
     
175. // The BigInt() constructor now only constructs a zeroed-out array.
     
176. // Alternatively, if you pass <true>, it won't construct any array. See the
     
177. // biCopy() method for an example of this.
     
178. //
     
179. // Be sure to set maxDigits depending on your precision needs. The default
     
180. // zeroed-out array ZERO_ARRAY is constructed inside the setMaxDigits()
     
181. // function. So use this function to set the variable. DON'T JUST SET THE
     
182. // VALUE. USE THE FUNCTION.
     
183. //
     
184. // ZERO_ARRAY exists to hopefully speed up construction of BigInts(). By
     
185. // precalculating the zero array, we can just use slice(0) to make copies of
     
186. // it. Presumably this calls faster native code, as opposed to setting the
     
187. // elements one at a time. I have not done any timing tests to verify this
     
188. // claim.
     
189. 
     
190. // Max number = 10^16 - 2 = 9999999999999998;
     
191. //               2^53     = 9007199254740992;
     
192. 
     
193. var biRadixBase = 2;
     
194. var biRadixBits = 16;
     
195. var bitsPerDigit = biRadixBits;
     
196. var biRadix = 1 << 16; // = 2^16 = 65536
     
197. var biHalfRadix = biRadix >>> 1;
     
198. var biRadixSquared = biRadix * biRadix;
     
199. var maxDigitVal = biRadix - 1;
     
200. var maxInteger = 9999999999999998;
     
201. 
     
202. // maxDigits:
     
203. // Change this to accommodate your largest number size. Use setMaxDigits()
     
204. // to change it!
     
205. //
     
206. // In general, if you're working with numbers of size N bits, you'll need 2*N
     
207. // bits of storage. Each digit holds 16 bits. So, a 1024-bit key will need
     
208. //
     
209. // 1024 * 2 / 16 = 128 digits of storage.
     
210. //
     
211. 
     
212. var maxDigits;
     
213. var ZERO_ARRAY;
     
214. var bigZero, bigOne;
     
215. 
     
216. function setMaxDigits(value)
     
217. {
     
218.         maxDigits = value;
     
219.         ZERO_ARRAY = new Array(maxDigits);
     
220.         for (var iza = 0; iza < ZERO_ARRAY.length; iza++) ZERO_ARRAY[iza] = 0;
     
221.         bigZero = new BigInt();
     
222.         bigOne = new BigInt();
     
223.         bigOne.digits[0] = 1;
     
224. }
     
225. 
     
226. setMaxDigits(20);
     
227. 
     
228. // The maximum number of digits in base 10 you can convert to an
     
229. // integer without JavaScript throwing up on you.
     
230. var dpl10 = 15;
     
231. // lr10 = 10 ^ dpl10
     
232. var lr10 = biFromNumber(1000000000000000);
     
233. 
     
234. function BigInt(flag)
     
235. {
     
236.         if (typeof flag == "boolean" && flag == true) {
     
237.                 this.digits = null;
     
238.         }
     
239.         else {
     
240.                 this.digits = ZERO_ARRAY.slice(0);
     
241.         }
     
242.         this.isNeg = false;
     
243. }
     
244. 
     
245. function biFromDecimal(s)
     
246. {
     
247.         var isNeg = s.charAt(0) == '-';
     
248.         var i = isNeg ? 1 : 0;
     
249.         var result;
     
250.         // Skip leading zeros.
     
251.         while (i < s.length && s.charAt(i) == '0') ++i;
     
252.         if (i == s.length) {
     
253.                 result = new BigInt();
     
254.         }
     
255.         else {
     
256.                 var digitCount = s.length - i;
     
257.                 var fgl = digitCount % dpl10;
     
258.                 if (fgl == 0) fgl = dpl10;
     
259.                 result = biFromNumber(Number(s.substr(i, fgl)));
     
260.                 i += fgl;
     
261.                 while (i < s.length) {
     
262.                         result = biAdd(biMultiply(result, lr10),
     
263.                                        biFromNumber(Number(s.substr(i, dpl10))));
     
264.                         i += dpl10;
     
265.                 }
     
266.                 result.isNeg = isNeg;
     
267.         }
     
268.         return result;
     
269. }
     
270. 
     
271. function biCopy(bi)
     
272. {
     
273.         var result = new BigInt(true);
     
274.         result.digits = bi.digits.slice(0);
     
275.         result.isNeg = bi.isNeg;
     
276.         return result;
     
277. }
     
278. 
     
279. function biFromNumber(i)
     
280. {
     
281.         var result = new BigInt();
     
282.         result.isNeg = i < 0;
     
283.         i = Math.abs(i);
     
284.         var j = 0;
     
285.         while (i > 0) {
     
286.                 result.digits[j++] = i & maxDigitVal;
     
287.                 i = Math.floor(i / biRadix);
     
288.         }
     
289.         return result;
     
290. }
     
291. 
     
292. function reverseStr(s)
     
293. {
     
294.         var result = "";
     
295.         for (var i = s.length - 1; i > -1; --i) {
     
296.                 result += s.charAt(i);
     
297.         }
     
298.         return result;
     
299. }
     
300. 
     
301. var hexatrigesimalToChar = new Array(
     
302. '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
     
303. 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
     
304. 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
     
305. 'u', 'v', 'w', 'x', 'y', 'z'
     
306. );
     
307. 
     
308. function biToString(x, radix)
     
309.         // 2 <= radix <= 36
     
310. {
     
311.         var b = new BigInt();
     
312.         b.digits[0] = radix;
     
313.         var qr = biDivideModulo(x, b);
     
314.         var result = hexatrigesimalToChar[qr[1].digits[0]];
     
315.         while (biCompare(qr[0], bigZero) == 1) {
     
316.                 qr = biDivideModulo(qr[0], b);
     
317.                 digit = qr[1].digits[0];
     
318.                 result += hexatrigesimalToChar[qr[1].digits[0]];
     
319.         }
     
320.         return (x.isNeg ? "-" : "") + reverseStr(result);
     
321. }
     
322. 
     
323. function biToDecimal(x)
     
324. {
     
325.         var b = new BigInt();
     
326.         b.digits[0] = 10;
     
327.         var qr = biDivideModulo(x, b);
     
328.         var result = String(qr[1].digits[0]);
     
329.         while (biCompare(qr[0], bigZero) == 1) {
     
330.                 qr = biDivideModulo(qr[0], b);
     
331.                 result += String(qr[1].digits[0]);
     
332.         }
     
333.         return (x.isNeg ? "-" : "") + reverseStr(result);
     
334. }
     
335. 
     
336. var hexToChar = new Array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
     
337.                           'a', 'b', 'c', 'd', 'e', 'f');
     
338. 
     
339. function digitToHex(n)
     
340. {
     
341.         var mask = 0xf;
     
342.         var result = "";
     
343.         for (i = 0; i < 4; ++i) {
     
344.                 result += hexToChar[n & mask];
     
345.                 n >>>= 4;
     
346.         }
     
347.         return reverseStr(result);
     
348. }
     
349. 
     
350. function biToHex(x)
     
351. {
     
352.         var result = "";
     
353.         var n = biHighIndex(x);
     
354.         for (var i = biHighIndex(x); i > -1; --i) {
     
355.                 result += digitToHex(x.digits[i]);
     
356.         }
     
357.         return result;
     
358. }
     
359. 
     
360. function charToHex(c)
     
361. {
     
362.         var ZERO = 48;
     
363.         var NINE = ZERO + 9;
     
364.         var littleA = 97;
     
365.         var littleZ = littleA + 25;
     
366.         var bigA = 65;
     
367.         var bigZ = 65 + 25;
     
368.         var result;
     
369. 
     
370.         if (c >= ZERO && c <= NINE) {
     
371.                 result = c - ZERO;
     
372.         } else if (c >= bigA && c <= bigZ) {
     
373.                 result = 10 + c - bigA;
     
374.         } else if (c >= littleA && c <= littleZ) {
     
375.                 result = 10 + c - littleA;
     
376.         } else {
     
377.                 result = 0;
     
378.         }
     
379.         return result;
     
380. }
     
381. 
     
382. function hexToDigit(s)
     
383. {
     
384.         var result = 0;
     
385.         var sl = Math.min(s.length, 4);
     
386.         for (var i = 0; i < sl; ++i) {
     
387.                 result <<= 4;
     
388.                 result |= charToHex(s.charCodeAt(i))
     
389.         }
     
390.         return result;
     
391. }
     
392. 
     
393. function biFromHex(s)
     
394. {
     
395.         var result = new BigInt();
     
396.         var sl = s.length;
     
397.         for (var i = sl, j = 0; i > 0; i -= 4, ++j) {
     
398.                 result.digits[j] = hexToDigit(s.substr(Math.max(i - 4, 0), Math.min(i, 4)));
     
399.         }
     
400.         return result;
     
401. }
     
402. 
     
403. function biFromString(s, radix)
     
404. {
     
405.         var isNeg = s.charAt(0) == '-';
     
406.         var istop = isNeg ? 1 : 0;
     
407.         var result = new BigInt();
     
408.         var place = new BigInt();
     
409.         place.digits[0] = 1; // radix^0
     
410.         for (var i = s.length - 1; i >= istop; i--) {
     
411.                 var c = s.charCodeAt(i);
     
412.                 var digit = charToHex(c);
     
413.                 var biDigit = biMultiplyDigit(place, digit);
     
414.                 result = biAdd(result, biDigit);
     
415.                 place = biMultiplyDigit(place, radix);
     
416.         }
     
417.         result.isNeg = isNeg;
     
418.         return result;
     
419. }
     
420. 
     
421. function biDump(b)
     
422. {
     
423.         return (b.isNeg ? "-" : "") + b.digits.join(" ");
     
424. }
     
425. 
     
426. function biAdd(x, y)
     
427. {
     
428.         var result;
     
429. 
     
430.         if (x.isNeg != y.isNeg) {
     
431.                 y.isNeg = !y.isNeg;
     
432.                 result = biSubtract(x, y);
     
433.                 y.isNeg = !y.isNeg;
     
434.         }
     
435.         else {
     
436.                 result = new BigInt();
     
437.                 var c = 0;
     
438.                 var n;
     
439.                 for (var i = 0; i < x.digits.length; ++i) {
     
440.                         n = x.digits[i] + y.digits[i] + c;
     
441.                         result.digits[i] = n % biRadix;
     
442.                         c = Number(n >= biRadix);
     
443.                 }
     
444.                 result.isNeg = x.isNeg;
     
445.         }
     
446.         return result;
     
447. }
     
448. 
     
449. 
     
450. function biHighIndex(x)
     
451. {
     
452.         var result = x.digits.length - 1;
     
453.         while (result > 0 && x.digits[result] == 0) --result;
     
454.         return result;
     
455. }
     
456. 
     
457. function biNumBits(x)
     
458. {
     
459.         var n = biHighIndex(x);
     
460.         var d = x.digits[n];
     
461.         var m = (n + 1) * bitsPerDigit;
     
462.         var result;
     
463.         for (result = m; result > m - bitsPerDigit; --result) {
     
464.                 if ((d & 0x8000) != 0) break;
     
465.                 d <<= 1;
     
466.         }
     
467.         return result;
     
468. }
     
469. 
     
470. function biMultiply(x, y)
     
471. {
     
472.         var result = new BigInt();
     
473.         var c;
     
474.         var n = biHighIndex(x);
     
475.         var t = biHighIndex(y);
     
476.         var u, uv, k;
     
477. 
     
478.         for (var i = 0; i <= t; ++i) {
     
479.                 c = 0;
     
480.                 k = i;
     
481.                 for (j = 0; j <= n; ++j, ++k) {
     
482.                         uv = result.digits[k] + x.digits[j] * y.digits[i] + c;
     
483.                         result.digits[k] = uv & maxDigitVal;
     
484.                         c = uv >>> biRadixBits;
     
485.                         //c = Math.floor(uv / biRadix);
     
486.                 }
     
487.                 result.digits[i + n + 1] = c;
     
488.         }
     
489.         // Someone give me a logical xor, please.
     
490.         result.isNeg = x.isNeg != y.isNeg;
     
491.         return result;
     
492. }
     
493. 
     
494. function biMultiplyDigit(x, y)
     
495. {
     
496.         var n, c, uv;
     
497. 
     
498.         result = new BigInt();
     
499.         n = biHighIndex(x);
     
500.         c = 0;
     
501.         for (var j = 0; j <= n; ++j) {
     
502.                 uv = result.digits[j] + x.digits[j] * y + c;
     
503.                 result.digits[j] = uv & maxDigitVal;
     
504.                 c = uv >>> biRadixBits;
     
505.                 //c = Math.floor(uv / biRadix);
     
506.         }
     
507.         result.digits[1 + n] = c;
     
508.         return result;
     
509. }
     
510. 
     
511. function arrayCopy(src, srcStart, dest, destStart, n)
     
512. {
     
513.         var m = Math.min(srcStart + n, src.length);
     
514.         for (var i = srcStart, j = destStart; i < m; ++i, ++j) {
     
515.                 dest[j] = src[i];
     
516.         }
     
517. }
     
518. 
     
519. var highBitMasks = new Array(0x0000, 0x8000, 0xC000, 0xE000, 0xF000, 0xF800,
     
520.                              0xFC00, 0xFE00, 0xFF00, 0xFF80, 0xFFC0, 0xFFE0,
     
521.                              0xFFF0, 0xFFF8, 0xFFFC, 0xFFFE, 0xFFFF);
     
522. 
     
523. function biShiftLeft(x, n)
     
524. {
     
525.         var digitCount = Math.floor(n / bitsPerDigit);
     
526.         var result = new BigInt();
     
527.         arrayCopy(x.digits, 0, result.digits, digitCount,
     
528.                   result.digits.length - digitCount);
     
529.         var bits = n % bitsPerDigit;
     
530.         var rightBits = bitsPerDigit - bits;
     
531.         for (var i = result.digits.length - 1, i1 = i - 1; i > 0; --i, --i1) {
     
532.                 result.digits[i] = ((result.digits[i] << bits) & maxDigitVal) |
     
533.                                    ((result.digits[i1] & highBitMasks[bits]) >>>
     
534.                                     (rightBits));
     
535.         }
     
536.         result.digits[0] = ((result.digits[i] << bits) & maxDigitVal);
     
537.         result.isNeg = x.isNeg;
     
538.         return result;
     
539. }
     
540. 
     
541. var lowBitMasks = new Array(0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F,
     
542.                             0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF,
     
543.                             0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF);
     
544. 
     
545. function biShiftRight(x, n)
     
546. {
     
547.         var digitCount = Math.floor(n / bitsPerDigit);
     
548.         var result = new BigInt();
     
549.         arrayCopy(x.digits, digitCount, result.digits, 0,
     
550.                   x.digits.length - digitCount);
     
551.         var bits = n % bitsPerDigit;
     
552.         var leftBits = bitsPerDigit - bits;
     
553.         for (var i = 0, i1 = i + 1; i < result.digits.length - 1; ++i, ++i1) {
     
554.                 result.digits[i] = (result.digits[i] >>> bits) |
     
555.                                    ((result.digits[i1] & lowBitMasks[bits]) << leftBits);
     
556.         }
     
557.         result.digits[result.digits.length - 1] >>>= bits;
     
558.         result.isNeg = x.isNeg;
     
559.         return result;
     
560. }
     
561. 
     
562. function biMultiplyByRadixPower(x, n)
     
563. {
     
564.         var result = new BigInt();
     
565.         arrayCopy(x.digits, 0, result.digits, n, result.digits.length - n);
     
566.         return result;
     
567. }
     
568. 
     
569. function biDivideByRadixPower(x, n)
     
570. {
     
571.         var result = new BigInt();
     
572.         arrayCopy(x.digits, n, result.digits, 0, result.digits.length - n);
     
573.         return result;
     
574. }
     
575. 
     
576. function biModuloByRadixPower(x, n)
     
577. {
     
578.         var result = new BigInt();
     
579.         arrayCopy(x.digits, 0, result.digits, 0, n);
     
580.         return result;
     
581. }
     
582. 
     
583. function biCompare(x, y)
     
584. {
     
585.         if (x.isNeg != y.isNeg) {
     
586.                 return 1 - 2 * Number(x.isNeg);
     
587.         }
     
588.         for (var i = x.digits.length - 1; i >= 0; --i) {
     
589.                 if (x.digits[i] != y.digits[i]) {
     
590.                         if (x.isNeg) {
     
591.                                 return 1 - 2 * Number(x.digits[i] > y.digits[i]);
     
592.                         } else {
     
593.                                 return 1 - 2 * Number(x.digits[i] < y.digits[i]);
     
594.                         }
     
595.                 }
     
596.         }
     
597.         return 0;
     
598. }
     
599. 
     
600. function biDivideModulo(x, y)
     
601. {
     
602.         var nb = biNumBits(x);
     
603.         var tb = biNumBits(y);
     
604.         var origYIsNeg = y.isNeg;
     
605.         var q, r;
     
606.         if (nb < tb) {
     
607.                 // |x| < |y|
     
608.                 if (x.isNeg) {
     
609.                         q = biCopy(bigOne);
     
610.                         q.isNeg = !y.isNeg;
     
611.                         x.isNeg = false;
     
612.                         y.isNeg = false;
     
613.                         r = biSubtract(y, x);
     
614.                         // Restore signs, 'cause they're references.
     
615.                         x.isNeg = true;
     
616.                         y.isNeg = origYIsNeg;
     
617.                 } else {
     
618.                         q = new BigInt();
     
619.                         r = biCopy(x);
     
620.                 }
     
621.                 return new Array(q, r);
     
622.         }
     
623. 
     
624.         q = new BigInt();
     
625.         r = x;
     
626. 
     
627.         // Normalize Y.
     
628.         var t = Math.ceil(tb / bitsPerDigit) - 1;
     
629.         var lambda = 0;
     
630.         while (y.digits[t] < biHalfRadix) {
     
631.                 y = biShiftLeft(y, 1);
     
632.                 ++lambda;
     
633.                 ++tb;
     
634.                 t = Math.ceil(tb / bitsPerDigit) - 1;
     
635.         }
     
636.         // Shift r over to keep the quotient constant. We'll shift the
     
637.         // remainder back at the end.
     
638.         r = biShiftLeft(r, lambda);
     
639.         nb += lambda; // Update the bit count for x.
     
640.         var n = Math.ceil(nb / bitsPerDigit) - 1;
     
641. 
     
642.         var b = biMultiplyByRadixPower(y, n - t);
     
643.         while (biCompare(r, b) != -1) {
     
644.                 ++q.digits[n - t];
     
645.                 r = biSubtract(r, b);
     
646.         }
     
647.         for (var i = n; i > t; --i) {
     
648.     var ri = (i >= r.digits.length) ? 0 : r.digits[i];
     
649.     var ri1 = (i - 1 >= r.digits.length) ? 0 : r.digits[i - 1];
     
650.     var ri2 = (i - 2 >= r.digits.length) ? 0 : r.digits[i - 2];
     
651.     var yt = (t >= y.digits.length) ? 0 : y.digits[t];
     
652.     var yt1 = (t - 1 >= y.digits.length) ? 0 : y.digits[t - 1];
     
653.                 if (ri == yt) {
     
654.                         q.digits[i - t - 1] = maxDigitVal;
     
655.                 } else {
     
656.                         q.digits[i - t - 1] = Math.floor((ri * biRadix + ri1) / yt);
     
657.                 }
     
658. 
     
659.                 var c1 = q.digits[i - t - 1] * ((yt * biRadix) + yt1);
     
660.                 var c2 = (ri * biRadixSquared) + ((ri1 * biRadix) + ri2);
     
661.                 while (c1 > c2) {
     
662.                         --q.digits[i - t - 1];
     
663.                         c1 = q.digits[i - t - 1] * ((yt * biRadix) | yt1);
     
664.                         c2 = (ri * biRadix * biRadix) + ((ri1 * biRadix) + ri2);
     
665.                 }
     
666. 
     
667.                 b = biMultiplyByRadixPower(y, i - t - 1);
     
668.                 r = biSubtract(r, biMultiplyDigit(b, q.digits[i - t - 1]));
     
669.                 if (r.isNeg) {
     
670.                         r = biAdd(r, b);
     
671.                         --q.digits[i - t - 1];
     
672.                 }
     
673.         }
     
674.         r = biShiftRight(r, lambda);
     
675.         // Fiddle with the signs and stuff to make sure that 0 <= r < y.
     
676.         q.isNeg = x.isNeg != origYIsNeg;
     
677.         if (x.isNeg) {
     
678.                 if (origYIsNeg) {
     
679.                         q = biAdd(q, bigOne);
     
680.                 } else {
     
681.                         q = biSubtract(q, bigOne);
     
682.                 }
     
683.                 y = biShiftRight(y, lambda);
     
684.                 r = biSubtract(y, r);
     
685.         }
     
686.         // Check for the unbelievably stupid degenerate case of r == -0.
     
687.         if (r.digits[0] == 0 && biHighIndex(r) == 0) r.isNeg = false;
     
688. 
     
689.         return new Array(q, r);
     
690. }
     
691. 
     
692. function biDivideModulo(x, y)
     
693. {
     
694.         var nb = biNumBits(x);
     
695.         var tb = biNumBits(y);
     
696.         var origYIsNeg = y.isNeg;
     
697.         var q, r;
     
698.         if (nb < tb) {
     
699.                 // |x| < |y|
     
700.                 if (x.isNeg) {
     
701.                         q = biCopy(bigOne);
     
702.                         q.isNeg = !y.isNeg;
     
703.                         x.isNeg = false;
     
704.                         y.isNeg = false;
     
705.                         r = biSubtract(y, x);
     
706.                         // Restore signs, 'cause they're references.
     
707.                         x.isNeg = true;
     
708.                         y.isNeg = origYIsNeg;
     
709.                 } else {
     
710.                         q = new BigInt();
     
711.                         r = biCopy(x);
     
712.                 }
     
713.                 return new Array(q, r);
     
714.         }
     
715. 
     
716.         q = new BigInt();
     
717.         r = x;
     
718. 
     
719.         // Normalize Y.
     
720.         var t = Math.ceil(tb / bitsPerDigit) - 1;
     
721.         var lambda = 0;
     
722.         while (y.digits[t] < biHalfRadix) {
     
723.                 y = biShiftLeft(y, 1);
     
724.                 ++lambda;
     
725.                 ++tb;
     
726.                 t = Math.ceil(tb / bitsPerDigit) - 1;
     
727.         }
     
728.         // Shift r over to keep the quotient constant. We'll shift the
     
729.         // remainder back at the end.
     
730.         r = biShiftLeft(r, lambda);
     
731.         nb += lambda; // Update the bit count for x.
     
732.         var n = Math.ceil(nb / bitsPerDigit) - 1;
     
733. 
     
734.         var b = biMultiplyByRadixPower(y, n - t);
     
735.         while (biCompare(r, b) != -1) {
     
736.                 ++q.digits[n - t];
     
737.                 r = biSubtract(r, b);
     
738.         }
     
739.         for (var i = n; i > t; --i) {
     
740.     var ri = (i >= r.digits.length) ? 0 : r.digits[i];
     
741.     var ri1 = (i - 1 >= r.digits.length) ? 0 : r.digits[i - 1];
     
742.     var ri2 = (i - 2 >= r.digits.length) ? 0 : r.digits[i - 2];
     
743.     var yt = (t >= y.digits.length) ? 0 : y.digits[t];
     
744.     var yt1 = (t - 1 >= y.digits.length) ? 0 : y.digits[t - 1];
     
745.                 if (ri == yt) {
     
746.                         q.digits[i - t - 1] = maxDigitVal;
     
747.                 } else {
     
748.                         q.digits[i - t - 1] = Math.floor((ri * biRadix + ri1) / yt);
     
749.                 }
     
750. 
     
751.                 var c1 = q.digits[i - t - 1] * ((yt * biRadix) + yt1);
     
752.                 var c2 = (ri * biRadixSquared) + ((ri1 * biRadix) + ri2);
     
753.                 while (c1 > c2) {
     
754.                         --q.digits[i - t - 1];
     
755.                         c1 = q.digits[i - t - 1] * ((yt * biRadix) | yt1);
     
756.                         c2 = (ri * biRadix * biRadix) + ((ri1 * biRadix) + ri2);
     
757.                 }
     
758. 
     
759.                 b = biMultiplyByRadixPower(y, i - t - 1);
     
760.                 r = biSubtract(r, biMultiplyDigit(b, q.digits[i - t - 1]));
     
761.                 if (r.isNeg) {
     
762.                         r = biAdd(r, b);
     
763.                         --q.digits[i - t - 1];
     
764.                 }
     
765.         }
     
766.         r = biShiftRight(r, lambda);
     
767.         // Fiddle with the signs and stuff to make sure that 0 <= r < y.
     
768.         q.isNeg = x.isNeg != origYIsNeg;
     
769.         if (x.isNeg) {
     
770.                 if (origYIsNeg) {
     
771.                         q = biAdd(q, bigOne);
     
772.                 } else {
     
773.                         q = biSubtract(q, bigOne);
     
774.                 }
     
775.                 y = biShiftRight(y, lambda);
     
776.                 r = biSubtract(y, r);
     
777.         }
     
778.         // Check for the unbelievably stupid degenerate case of r == -0.
     
779.         if (r.digits[0] == 0 && biHighIndex(r) == 0) r.isNeg = false;
     
780. 
     
781.         return new Array(q, r);
     
782. }
     
783. 
     
784. function biDivide(x, y)
     
785. {
     
786.         return biDivideModulo(x, y)[0];
     
787. }
     
788. 
     
789. function biModulo(x, y)
     
790. {
     
791.         return biDivideModulo(x, y)[1];
     
792. }
     
793. 
     
794. function biMultiplyMod(x, y, m)
     
795. {
     
796.         return biModulo(biMultiply(x, y), m);
     
797. }
     
798. 
     
799. function biPow(x, y)
     
800. {
     
801.         var result = bigOne;
     
802.         var a = x;
     
803.         while (true) {
     
804.                 if ((y & 1) != 0) result = biMultiply(result, a);
     
805.                 y >>= 1;
     
806.                 if (y == 0) break;
     
807.                 a = biMultiply(a, a);
     
808.         }
     
809.         return result;
     
810. }
     
811. 
     
812. function biPowMod(x, y, m)
     
813. {
     
814.         var result = bigOne;
     
815.         var a = x;
     
816.         var k = y;
     
817.         while (true) {
     
818.                 if ((k.digits[0] & 1) != 0) result = biMultiplyMod(result, a, m);
     
819.                 k = biShiftRight(k, 1);
     
820.                 if (k.digits[0] == 0 && biHighIndex(k) == 0) break;
     
821.                 a = biMultiplyMod(a, a, m);
     
822.         }
     
823.         return result;
     
824. }
     
825. 
     
826. // BarrettMu, a class for performing Barrett modular reduction computations in
     
827. // JavaScript.
     
828. //
     
829. // Requires BigInt.js.
     
830. //
     
831. // Copyright 2004-2005 David Shapiro.
     
832. //
     
833. // You may use, re-use, abuse, copy, and modify this code to your liking, but
     
834. // please keep this header.
     
835. //
     
836. // Thanks!
     
837. //
     
838. // Dave Shapiro
     
839. // dave@ohdave.com
     
840. 
     
841. function BarrettMu(m)
     
842. {
     
843.         this.modulus = biCopy(m);
     
844.         this.k = biHighIndex(this.modulus) + 1;
     
845.         var b2k = new BigInt();
     
846.         b2k.digits[2 * this.k] = 1; // b2k = b^(2k)
     
847.         this.mu = biDivide(b2k, this.modulus);
     
848.         this.bkplus1 = new BigInt();
     
849.         this.bkplus1.digits[this.k + 1] = 1; // bkplus1 = b^(k+1)
     
850.         this.modulo = BarrettMu_modulo;
     
851.         this.multiplyMod = BarrettMu_multiplyMod;
     
852.         this.powMod = BarrettMu_powMod;
     
853. }
     
854. 
     
855. function BarrettMu_modulo(x)
     
856. {
     
857.         var q1 = biDivideByRadixPower(x, this.k - 1);
     
858.         var q2 = biMultiply(q1, this.mu);
     
859.         var q3 = biDivideByRadixPower(q2, this.k + 1);
     
860.         var r1 = biModuloByRadixPower(x, this.k + 1);
     
861.         var r2term = biMultiply(q3, this.modulus);
     
862.         var r2 = biModuloByRadixPower(r2term, this.k + 1);
     
863.         var r = biSubtract(r1, r2);
     
864.         if (r.isNeg) {
     
865.                 r = biAdd(r, this.bkplus1);
     
866.         }
     
867.         var rgtem = biCompare(r, this.modulus) >= 0;
     
868.         while (rgtem) {
     
869.                 r = biSubtract(r, this.modulus);
     
870.                 rgtem = biCompare(r, this.modulus) >= 0;
     
871.         }
     
872.         return r;
     
873. }
     
874. 
     
875. function BarrettMu_multiplyMod(x, y)
     
876. {
     
877.         /*
     
878.         x = this.modulo(x);
     
879.         y = this.modulo(y);
     
880.         */
     
881.         var xy = biMultiply(x, y);
     
882.         return this.modulo(xy);
     
883. }
     
884. 
     
885. function BarrettMu_powMod(x, y)
     
886. {
     
887.         var result = new BigInt();
     
888.         result.digits[0] = 1;
     
889.         var a = x;
     
890.         var k = y;
     
891.         while (true) {
     
892.                 if ((k.digits[0] & 1) != 0) result = this.multiplyMod(result, a);
     
893.                 k = biShiftRight(k, 1);
     
894.                 if (k.digits[0] == 0 && biHighIndex(k) == 0) break;
     
895.                 a = this.multiplyMod(a, a);
     
896.         }
     
897.         return result;
     
898. }
     
899. 
     
900. function biSubtract(x, y)
     
901. {
     
902.         var result;
     
903.         if (x.isNeg != y.isNeg) {
     
904.                 y.isNeg = !y.isNeg;
     
905.                 result = biAdd(x, y);
     
906.                 y.isNeg = !y.isNeg;
     
907.         } else {
     
908.                 result = new BigInt();
     
909.                 var n, c;
     
910.                 c = 0;
     
911.                 for (var i = 0; i < x.digits.length; ++i) {
     
912.                         n = x.digits[i] - y.digits[i] + c;
     
913.                         result.digits[i] = n % biRadix;
     
914.                         // Stupid non-conforming modulus operation.
     
915.                         if (result.digits[i] < 0) result.digits[i] += biRadix;
     
916.                         c = 0 - Number(n < 0);
     
917.                 }
     
918.                 // Fix up the negative sign, if any.
     
919.                 if (c == -1) {
     
920.                         c = 0;
     
921.                         for (var i = 0; i < x.digits.length; ++i) {
     
922.                                 n = 0 - result.digits[i] + c;
     
923.                                 result.digits[i] = n % biRadix;
     
924.                                 // Stupid non-conforming modulus operation.
     
925.                                 if (result.digits[i] < 0) result.digits[i] += biRadix;
     
926.                                 c = 0 - Number(n < 0);
     
927.                         }
     
928.                         // Result is opposite sign of arguments.
     
929.                         result.isNeg = !x.isNeg;
     
930.                 } else {
     
931.                         // Result is same sign.
     
932.                         result.isNeg = x.isNeg;
     
933.                 }
     
934.         }
     
935.         return result;
     
936. }

复制代码

峰生水起之林

看图插入句十六进制位数代码即可解决你的问题了
setMaxDigits(130);

ymf213896

秘钥长会卡死？？？？

ymf213896

你这个秘钥 你确定正确吗？？

飞翔软件开发

  

var dbits, canary = 244837814094590,
j_lm = 15715070 == (canary & 16777215);
navigator = {};
window = this;
function BigInteger (b, a, c) {
null != b && ("number" == typeof b ? this.fromNumber (b, a, c) : null == a && "string" != typeof b ? this.fromString (b, 256) : this.fromString (b, a))
}
function nbi () {
return new BigInteger (null)
}
function am1 (b, a, c, d, e, f) {
for (; 0 <= --f;) {
var g = a * this[b++] + c[d] + e,
e = Math.floor (g / 67108864);
c[d++] = g & 67108863
}
return e
}
function am2 (b, a, c, d, e, f) {
for (var g = a & 32767, a = a >> 15; 0 <= --f;) {
var h = this[b] & 32767,
i = this[b++] >> 15,
k = a * h + i * g,
h = g * h + ( (k & 32767) << 15) + c[d] + (e & 1073741823),
e = (h >>> 30) + (k >>> 15) + a * i + (e >>> 30);
c[d++] = h & 1073741823
}
return e
}
function am3 (b, a, c, d, e, f) {
for (var g = a & 16383, a = a >> 14; 0 <= --f;) {
var h = this[b] & 16383,
i = this[b++] >> 14,
k = a * h + i * g,
h = g * h + ( (k & 16383) << 14) + c[d] + e,
e = (h >> 28) + (k >> 14) + a * i;
c[d++] = h & 268435455
}
return e
}
j_lm && "Microsoft Internet Explorer" == navigator.appName ? (BigInteger.prototype.am = am2,
dbits = 30) : j_lm && "Netscape" != navigator.appName ? (BigInteger.prototype.am = am1,
dbits = 26) : (BigInteger.prototype.am = am3,
dbits = 28);
BigInteger.prototype.DB = dbits;
BigInteger.prototype.DM = (1 << dbits) - 1;
BigInteger.prototype.DV = 1 << dbits;
var BI_FP = 52;
BigInteger.prototype.FV = Math.pow (2, BI_FP);
BigInteger.prototype.F1 = BI_FP - dbits;
BigInteger.prototype.F2 = 2 * dbits - BI_FP;
var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz",
BI_RC = [],
rr, vv;
rr = 48;
for (vv = 0; 9 >= vv; ++vv)
BI_RC[rr++] = vv;
rr = 97;
for (vv = 10; 36 > vv; ++vv)
BI_RC[rr++] = vv;
rr = 65;
for (vv = 10; 36 > vv; ++vv)
BI_RC[rr++] = vv;
function int2char (b) {
return BI_RM.charAt (b)
}
function intAt (b, a) {
var c = BI_RC[b.charCodeAt (a)];
return null == c ? -1 : c
}
function bnpCopyTo (b) {
for (var a = this.t - 1; 0 <= a; --a)
b[a] = this[a];
b.t = this.t;
b.s = this.s
}
function bnpFromInt (b) {
this.t = 1;
this.s = 0 > b ? -1 : 0;
0 < b ? this[0] = b : -1 > b ? this[0] = b + this.DV : this.t = 0
}
function nbv (b) {
var a = nbi ();
a.fromInt (b);
return a
}
function bnpFromString (b, a) {
var c;
if (16 == a) c = 4;
else if (8 == a) c = 3;
else if (256 == a) c = 8;
else if (2 == a) c = 1;
else if (32 == a) c = 5;
else if (4 == a) c = 2;
else {
this.fromRadix (b, a);
return
}
this.s = this.t = 0;
for (var d = b.length, e = !1, f = 0; 0 <= --d;) {
var g = 8 == c ? b[d] & 255 : intAt (b, d);
0 > g ? "-" == b.charAt (d) && (e = !0) : (e = !1,
0 == f ? this[this.t++] = g : f + c > this.DB ? (this[this.t - 1] |= (g & (1 << this.DB - f) - 1) << f,
this[this.t++] = g >> this.DB - f) : this[this.t - 1] |= g << f,
f += c,
f >= this.DB && (f -= this.DB))
}
if (8 == c && 0 != (b[0] & 128)) this.s = -1,
0 < f && (this[this.t - 1] |= (1 << this.DB - f) - 1 << f);
this.clamp ();
e && BigInteger.ZERO.subTo (this, this)
}
function bnpClamp () {
for (var b = this.s & this.DM; 0 < this.t && this[this.t - 1] == b;)--this.t
}
function bnToString (b) {
if (0 > this.s) return "-" + this.negate ().toString (b);
if (16 == b) b = 4;
else if (8 == b) b = 3;
else if (2 == b) b = 1;
else if (32 == b) b = 5;
else if (4 == b) b = 2;
else return this.toRadix (b);
var a = (1 << b) - 1,
c, d = !1,
e = "",
f = this.t,
g = this.DB - f * this.DB % b;
if (0 < f--) {
if (g < this.DB && 0 < (c = this[f] >> g)) d = !0,
e = int2char (c);
for (; 0 <= f;)
g < b ? (c = (this[f] & (1 << g) - 1) << b - g,
c |= this[--f] >> (g += this.DB - b)) : (c = this[f] >> (g -= b) & a,
0 >= g && (g += this.DB, --f)),
0 < c && (d = !0),
d && (e += int2char (c))
}
return d ? e : "0"
}
function bnNegate () {
var b = nbi ();
BigInteger.ZERO.subTo (this, b);
return b
}
function bnAbs () {
return 0 > this.s ? this.negate () : this
}
function bnCompareTo (b) {
var a = this.s - b.s;
if (0 != a) return a;
var c = this.t,
a = c - b.t;
if (0 != a) return 0 > this.s ? -a : a;
for (; 0 <= --c;)
if (0 != (a = this[c] - b[c])) return a;
return 0
}
function nbits (b) {
var a = 1,
c;
if (0 != (c = b >>> 16)) b = c,
a += 16;
if (0 != (c = b >> 8)) b = c,
a += 8;
if (0 != (c = b >> 4)) b = c,
a += 4;
if (0 != (c = b >> 2)) b = c,
a += 2;
0 != b >> 1 && (a += 1);
return a
}
function bnBitLength () {
return 0 >= this.t ? 0 : this.DB * (this.t - 1) + nbits (this[this.t - 1] ^ this.s & this.DM)
}
function bnpDLShiftTo (b, a) {
var c;
for (c = this.t - 1; 0 <= c; --c)
a[c + b] = this[c];
for (c = b - 1; 0 <= c; --c)
a[c] = 0;
a.t = this.t + b;
a.s = this.s
}
function bnpDRShiftTo (b, a) {
for (var c = b; c < this.t; ++c)
a[c - b] = this[c];
a.t = Math.max (this.t - b, 0);
a.s = this.s
}
function bnpLShiftTo (b, a) {
var c = b % this.DB,
d = this.DB - c,
e = (1 << d) - 1,
f = Math.floor (b / this.DB),
g = this.s << c & this.DM,
h;
for (h = this.t - 1; 0 <= h; --h)
a[h + f + 1] = this[h] >> d | g,
g = (this[h] & e) << c;
for (h = f - 1; 0 <= h; --h)
a[h] = 0;
a[f] = g;
a.t = this.t + f + 1;
a.s = this.s;
a.clamp ()
}
function bnpRShiftTo (b, a) {
a.s = this.s;
var c = Math.floor (b / this.DB);
if (c >= this.t) a.t = 0;
else {
var d = b % this.DB,
e = this.DB - d,
f = (1 << d) - 1;
a[0] = this[c] >> d;
for (var g = c + 1; g < this.t; ++g)
a[g - c - 1] |= (this[g] & f) << e,
a[g - c] = this[g] >> d;
0 < d && (a[this.t - c - 1] |= (this.s & f) << e);
a.t = this.t - c;
a.clamp ()
}
}
function bnpSubTo (b, a) {
for (var c = 0, d = 0, e = Math.min (b.t, this.t); c < e;)
d += this[c] - b[c],
a[c++] = d & this.DM,
d >>= this.DB;
if (b.t < this.t) {
for (d -= b.s; c < this.t;)
d += this[c],
a[c++] = d & this.DM,
d >>= this.DB;
d += this.s
} else {
for (d += this.s; c < b.t;)
d -= b[c],
a[c++] = d & this.DM,
d >>= this.DB;
d -= b.s
}
a.s = 0 > d ? -1 : 0; - 1 > d ? a[c++] = this.DV + d : 0 < d && (a[c++] = d);
a.t = c;
a.clamp ()
}
function bnpMultiplyTo (b, a) {
var c = this.abs (),
d = b.abs (),
e = c.t;
for (a.t = e + d.t; 0 <= --e;)
a[e] = 0;
for (e = 0; e < d.t; ++e)
a[e + c.t] = c.am (0, d[e], a, e, 0, c.t);
a.s = 0;
a.clamp ();
this.s != b.s && BigInteger.ZERO.subTo (a, a)
}
function bnpSquareTo (b) {
for (var a = this.abs (), c = b.t = 2 * a.t; 0 <= --c;)
b[c] = 0;
for (c = 0; c < a.t - 1; ++c) {
var d = a.am (c, a[c], b, 2 * c, 0, 1);
if ( (b[c + a.t] += a.am (c + 1, 2 * a[c], b, 2 * c + 1, d, a.t - c - 1)) >= a.DV) b[c + a.t] -= a.DV,
b[c + a.t + 1] = 1
}
0 < b.t && (b[b.t - 1] += a.am (c, a[c], b, 2 * c, 0, 1));
b.s = 0;
b.clamp ()
}
function bnpDivRemTo (b, a, c) {
var d = b.abs ();
if (! (0 >= d.t)) {
var e = this.abs ();
if (e.t < d.t) null != a && a.fromInt (0),
null != c && this.copyTo (c);
else {
null == c && (c = nbi ());
var f = nbi (),
g = this.s,
b = b.s,
h = this.DB - nbits (d[d.t - 1]);
0 < h ? (d.lShiftTo (h, f),
e.lShiftTo (h, c)) : (d.copyTo (f),
e.copyTo (c));
d = f.t;
e = f[d - 1];
if (0 != e) {
var i = e * (1 << this.F1) + (1 < d ? f[d - 2] >> this.F2 : 0),
k = this.FV / i,
i = (1 << this.F1) / i,
o = 1 << this.F2,
l = c.t,
m = l - d,
j = null == a ? nbi () : a;
f.dlShiftTo (m, j);
0 <= c.compareTo (j) && (c[c.t++] = 1,
c.subTo (j, c));
BigInteger.ONE.dlShiftTo (d, j);
for (j.subTo (f, f); f.t < d;)
f[f.t++] = 0;
for (; 0 <= --m;) {
var n = c[--l] == e ? this.DM : Math.floor (c[l] * k + (c[l - 1] + o) * i);
if ( (c[l] += f.am (0, n, c, m, 0, d)) < n) {
f.dlShiftTo (m, j);
for (c.subTo (j, c); c[l] < --n;)
c.subTo (j, c)
}
}
null != a && (c.drShiftTo (d, a),
g != b && BigInteger.ZERO.subTo (a, a));
c.t = d;
c.clamp ();
0 < h && c.rShiftTo (h, c);
0 > g && BigInteger.ZERO.subTo (c, c)
}
}
}
}
function bnMod (b) {
var a = nbi ();
this.abs ().divRemTo (b, null, a);
0 > this.s && 0 < a.compareTo (BigInteger.ZERO) && b.subTo (a, a);
return a
}
function Classic (b) {
this.m = b
}
function cConvert (b) {
return 0 > b.s || 0 <= b.compareTo (this.m) ? b.mod (this.m) : b
}
function cRevert (b) {
return b
}
function cReduce (b) {
b.divRemTo (this.m, null, b)
}
function cMulTo (b, a, c) {
b.multiplyTo (a, c);
this.reduce (c)
}
function cSqrTo (b, a) {
b.squareTo (a);
this.reduce (a)
}
Classic.prototype.convert = cConvert;
Classic.prototype.revert = cRevert;
Classic.prototype.reduce = cReduce;
Classic.prototype.mulTo = cMulTo;
Classic.prototype.sqrTo = cSqrTo;
function bnpInvDigit () {
if (1 > this.t) return 0;
var b = this[0];
if (0 == (b & 1)) return 0;
var a = b & 3,
a = a * (2 - (b & 15) * a) & 15,
a = a * (2 - (b & 255) * a) & 255,
a = a * (2 - ( (b & 65535) * a & 65535)) & 65535,
a = a * (2 - b * a % this.DV) % this.DV;
return 0 < a ? this.DV - a : -a
}
function Montgomery (b) {
this.m = b;
this.mp = b.invDigit ();
this.mpl = this.mp & 32767;
this.mph = this.mp >> 15;
this.um = (1 << b.DB - 15) - 1;
this.mt2 = 2 * b.t
}
function montConvert (b) {
var a = nbi ();
b.abs ().dlShiftTo (this.m.t, a);
a.divRemTo (this.m, null, a);
0 > b.s && 0 < a.compareTo (BigInteger.ZERO) && this.m.subTo (a, a);
return a
}
function montRevert (b) {
var a = nbi ();
b.copyTo (a);
this.reduce (a);
return a
}
function montReduce (b) {
for (; b.t <= this.mt2;)
b[b.t++] = 0;
for (var a = 0; a < this.m.t; ++a) {
var c = b[a] & 32767,
d = c * this.mpl + ( (c * this.mph + (b[a] >> 15) * this.mpl & this.um) << 15) & b.DM,
c = a + this.m.t;
for (b[c] += this.m.am (0, d, b, a, 0, this.m.t); b[c] >= b.DV;)
b[c] -= b.DV,
b[++c]++
}
b.clamp ();
b.drShiftTo (this.m.t, b);
0 <= b.compareTo (this.m) && b.subTo (this.m, b)
}
function montSqrTo (b, a) {
b.squareTo (a);
this.reduce (a)
}
function montMulTo (b, a, c) {
b.multiplyTo (a, c);
this.reduce (c)
}
Montgomery.prototype.convert = montConvert;
Montgomery.prototype.revert = montRevert;
Montgomery.prototype.reduce = montReduce;
Montgomery.prototype.mulTo = montMulTo;
Montgomery.prototype.sqrTo = montSqrTo;
function bnpIsEven () {
return 0 == (0 < this.t ? this[0] & 1 : this.s)
}
function bnpExp (b, a) {
if (4294967295 < b || 1 > b) return BigInteger.ONE;
var c = nbi (),
d = nbi (),
e = a.convert (this),
f = nbits (b) - 1;
for (e.copyTo (c); 0 <=

var dbits, canary = 244837814094590,<br />     j_lm = 15715070 == (canary & 16777215);<br /> navigator = {};<br /> window = this;<br /> function BigInteger(b, a, c) {<br />     null != b && ("number" == typeof b ? this.fromNumber(b, a, c) : null == a && "string" != typeof b ? this.fromString(b, 256) : this.fromString(b, a))<br /> }<br /> <br /> function nbi() {<br />     return new BigInteger(null)<br /> }<br /> <br /> function am1(b, a, c, d, e, f) {<br />     for (; 0 <= --f;) {<br />         var g = a * this[b++] + c[d] + e,<br />             e = Math.floor(g / 67108864);<br />         c[d++] = g & 67108863<br />     }<br />     return e<br /> }<br /> <br /> function am2(b, a, c, d, e, f) {<br />     for (var g = a & 32767, a = a >> 15; 0 <= --f;) {<br />         var h = this<strong> & 32767,<br />             i = this[b++] >> 15,<br />             k = a * h + i * g,<br />             h = g * h + ((k & 32767) << 15) + c[d] + (e & 1073741823),<br />             e = (h >>> 30) + (k >>> 15) + a * i + (e >>> 30);<br />         c[d++] = h & 1073741823<br />     }<br />     return e<br /> }<br /> <br /> function am3(b, a, c, d, e, f) {<br />     for (var g = a & 16383, a = a >> 14; 0 <= --f;) {<br />         var h = this<strong> & 16383,<br />             i = this[b++] >> 14,<br />             k = a * h + i * g,<br />             h = g * h + ((k & 16383) << 14) + c[d] + e,<br />             e = (h >> 28) + (k >> 14) + a * i;<br />         c[d++] = h & 268435455<br />     }<br />     return e<br /> }<br /> j_lm && "Microsoft Internet Explorer" == navigator.appName ? (BigInteger.prototype.am = am2,<br /> dbits = 30) : j_lm && "Netscape" != navigator.appName ? (BigInteger.prototype.am = am1,<br /> dbits = 26) : (BigInteger.prototype.am = am3,<br /> dbits = 28);<br /> BigInteger.prototype.DB = dbits;<br /> BigInteger.prototype.DM = (1 << dbits) - 1;<br /> BigInteger.prototype.DV = 1 << dbits;<br /> var BI_FP = 52;<br /> BigInteger.prototype.FV = Math.pow(2, BI_FP);<br /> BigInteger.prototype.F1 = BI_FP - dbits;<br /> BigInteger.prototype.F2 = 2 * dbits - BI_FP;<br /> var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz",<br />     BI_RC = [],<br />     rr, vv;<br /> rr = 48;<br /> for (vv = 0; 9 >= vv; ++vv)<br /> BI_RC[rr++] = vv;<br /> rr = 97;<br /> for (vv = 10; 36 > vv; ++vv)<br /> BI_RC[rr++] = vv;<br /> rr = 65;<br /> for (vv = 10; 36 > vv; ++vv)<br /> BI_RC[rr++] = vv;<br /> <br /> function int2char(b) {<br />     return BI_RM.charAt(b)<br /> }<br /> <br /> function intAt(b, a) {<br />     var c = BI_RC[b.charCodeAt(a)];<br />     return null == c ? -1 : c<br /> }<br /> <br /> function bnpCopyTo(b) {<br />     for (var a = this.t - 1; 0 <= a; --a)<br />     b[a] = this[a];<br />     b.t = this.t;<br />     b.s = this.s<br /> }<br /> <br /> function bnpFromInt(b) {<br />     this.t = 1;<br />     this.s = 0 > b ? -1 : 0;<br />     0 < b ? this[0] = b : -1 > b ? this[0] = b + this.DV : this.t = 0<br /> }<br /> <br /> function nbv(b) {<br />     var a = nbi();<br />     a.fromInt(b);<br />     return a<br /> }<br /> <br /> function bnpFromString(b, a) {<br />     var c;<br />     if (16 == a) c = 4;<br />     else if (8 == a) c = 3;<br />     else if (256 == a) c = 8;<br />     else if (2 == a) c = 1;<br />     else if (32 == a) c = 5;<br />     else if (4 == a) c = 2;<br />     else {<br />         this.fromRadix(b, a);<br />         return<br />     }<br />     this.s = this.t = 0;<br />     for (var d = b.length, e = !1, f = 0; 0 <= --d;) {<br />         var g = 8 == c ? b[d] & 255 : intAt(b, d);<br />         0 > g ? "-" == b.charAt(d) && (e = !0) : (e = !1,<br />         0 == f ? this[this.t++] = g : f + c > this.DB ? (this[this.t - 1] |= (g & (1 << this.DB - f) - 1) << f,<br />         this[this.t++] = g >> this.DB - f) : this[this.t - 1] |= g << f,<br />         f += c,<br />         f >= this.DB && (f -= this.DB))<br />     }<br />     if (8 == c && 0 != (b[0] & 128)) this.s = -1,<br />     0 < f && (this[this.t - 1] |= (1 << this.DB - f) - 1 << f);<br />     this.clamp();<br />     e && BigInteger.ZERO.subTo(this, this)<br /> }<br /> <br /> function bnpClamp() {<br />     for (var b = this.s & this.DM; 0 < this.t && this[this.t - 1] == b;)--this.t<br /> }<br /> <br /> function bnToString(b) {<br />     if (0 > this.s) return "-" + this.negate().toString(b);<br />     if (16 == b) b = 4;<br />     else if (8 == b) b = 3;<br />     else if (2 == b) b = 1;<br />     else if (32 == b) b = 5;<br />     else if (4 == b) b = 2;<br />     else return this.toRadix(b);<br />     var a = (1 << b) - 1,<br />         c, d = !1,<br />         e = "",<br />         f = this.t,<br />         g = this.DB - f * this.DB % b;<br />     if (0 < f--) {<br />         if (g < this.DB && 0 < (c = this[f] >> g)) d = !0,<br />         e = int2char(c);<br />         for (; 0 <= f;)<br />         g < b ? (c = (this[f] & (1 << g) - 1) << b - g,<br />         c |= this[--f] >> (g += this.DB - b)) : (c = this[f] >> (g -= b) & a,<br />         0 >= g && (g += this.DB, --f)),<br />         0 < c && (d = !0),<br />         d && (e += int2char(c))<br />     }<br />     return d ? e : "0"<br /> }<br /> <br /> function bnNegate() {<br />     var b = nbi();<br />     BigInteger.ZERO.subTo(this, b);<br />     return b<br /> }<br /> <br /> function bnAbs() {<br />     return 0 > this.s ? this.negate() : this<br /> }<br /> <br /> function bnCompareTo(b) {<br />     var a = this.s - b.s;<br />     if (0 != a) return a;<br />     var c = this.t,<br />         a = c - b.t;<br />     if (0 != a) return 0 > this.s ? -a : a;<br />     for (; 0 <= --c;)<br />     if (0 != (a = this[c] - b[c])) return a;<br />     return 0<br /> }<br /> <br /> function nbits(b) {<br />     var a = 1,<br />         c;<br />     if (0 != (c = b >>> 16)) b = c,<br />     a += 16;<br />     if (0 != (c = b >> 8)) b = c,<br />     a += 8;<br />     if (0 != (c = b >> 4)) b = c,<br />     a += 4;<br />     if (0 != (c = b >> 2)) b = c,<br />     a += 2;<br />     0 != b >> 1 && (a += 1);<br />     return a<br /> }<br /> <br /> function bnBitLength() {<br />     return 0 >= this.t ? 0 : this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ this.s & this.DM)<br /> }<br /> <br /> function bnpDLShiftTo(b, a) {<br />     var c;<br />     for (c = this.t - 1; 0 <= c; --c)<br />     a[c + b] = this[c];<br />     for (c = b - 1; 0 <= c; --c)<br />     a[c] = 0;<br />     a.t = this.t + b;<br />     a.s = this.s<br /> }<br /> <br /> function bnpDRShiftTo(b, a) {<br />     for (var c = b; c < this.t; ++c)<br />     a[c - b] = this[c];<br />     a.t = Math.max(this.t - b, 0);<br />     a.s = this.s<br /> }<br /> <br /> function bnpLShiftTo(b, a) {<br />     var c = b % this.DB,<br />         d = this.DB - c,<br />         e = (1 << d) - 1,<br />         f = Math.floor(b / this.DB),<br />         g = this.s << c & this.DM,<br />         h;<br />     for (h = this.t - 1; 0 <= h; --h)<br />     a[h + f + 1] = this[h] >> d | g,<br />     g = (this[h] & e) << c;<br />     for (h = f - 1; 0 <= h; --h)<br />     a[h] = 0;<br />     a[f] = g;<br />     a.t = this.t + f + 1;<br />     a.s = this.s;<br />     a.clamp()<br /> }<br /> <br /> function bnpRShiftTo(b, a) {<br />     a.s = this.s;<br />     var c = Math.floor(b / this.DB);<br />     if (c >= this.t) a.t = 0;<br />     else {<br />         var d = b % this.DB,<br />             e = this.DB - d,<br />             f = (1 << d) - 1;<br />         a[0] = this[c] >> d;<br />         for (var g = c + 1; g < this.t; ++g)<br />         a[g - c - 1] |= (this[g] & f) << e,<br />         a[g - c] = this[g] >> d;<br />         0 < d && (a[this.t - c - 1] |= (this.s & f) << e);<br />         a.t = this.t - c;<br />         a.clamp()<br />     }<br /> }<br /> <br /> function bnpSubTo(b, a) {<br />     for (var c = 0, d = 0, e = Math.min(b.t, this.t); c < e;)<br />     d += this[c] - b[c],<br />     a[c++] = d & this.DM,<br />     d >>= this.DB;<br />     if (b.t < this.t) {<br />         for (d -= b.s; c < this.t;)<br />         d += this[c],<br />         a[c++] = d & this.DM,<br />         d >>= this.DB;<br />         d += this.s<br />     } else {<br />         for (d += this.s; c < b.t;)<br />         d -= b[c],<br />         a[c++] = d & this.DM,<br />         d >>= this.DB;<br />         d -= b.s<br />     }<br />     a.s = 0 > d ? -1 : 0; - 1 > d ? a[c++] = this.DV + d : 0 < d && (a[c++] = d);<br />     a.t = c;<br />     a.clamp()<br /> }<br /> <br /> function bnpMultiplyTo(b, a) {<br />     var c = this.abs(),<br />         d = b.abs(),<br />         e = c.t;<br />     for (a.t = e + d.t; 0 <= --e;)<br />     a[e] = 0;<br />     for (e = 0; e < d.t; ++e)<br />     a[e + c.t] = c.am(0, d[e], a, e, 0, c.t);<br />     a.s = 0;<br />     a.clamp();<br />     this.s != b.s && BigInteger.ZERO.subTo(a, a)<br /> }<br /> <br /> function bnpSquareTo(b) {<br />     for (var a = this.abs(), c = b.t = 2 * a.t; 0 <= --c;)<br />     b[c] = 0;<br />     for (c = 0; c < a.t - 1; ++c) {<br />         var d = a.am(c, a[c], b, 2 * c, 0, 1);<br />         if ((b[c + a.t] += a.am(c + 1, 2 * a[c], b, 2 * c + 1, d, a.t - c - 1)) >= a.DV) b[c + a.t] -= a.DV,<br />         b[c + a.t + 1] = 1<br />     }<br />     0 < b.t && (b[b.t - 1] += a.am(c, a[c], b, 2 * c, 0, 1));<br />     b.s = 0;<br />     b.clamp()<br /> }<br /> <br /> function bnpDivRemTo(b, a, c) {<br />     var d = b.abs();<br />     if (!(0 >= d.t)) {<br />         var e = this.abs();<br />         if (e.t < d.t) null != a && a.fromInt(0),<br />         null != c && this.copyTo(c);<br />         else {<br />             null == c && (c = nbi());<br />             var f = nbi(),<br />                 g = this.s,<br />                 b = b.s,<br />                 h = this.DB - nbits(d[d.t - 1]);<br />             0 < h ? (d.lShiftTo(h, f),<br />             e.lShiftTo(h, c)) : (d.copyTo(f),<br />             e.copyTo(c));<br />             d = f.t;<br />             e = f[d - 1];<br />             if (0 != e) {<br />                 var i = e * (1 << this.F1) + (1 < d ? f[d - 2] >> this.F2 : 0),<br />                     k = this.FV / i,<br />                     i = (1 << this.F1) / i,<br />                     o = 1 << this.F2,<br />                     l = c.t,<br />                     m = l - d,<br />                     j = null == a ? nbi() : a;<br />                 f.dlShiftTo(m, j);<br />                 0 <= c.compareTo(j) && (c[c.t++] = 1,<br />                 c.subTo(j, c));<br />                 BigInteger.ONE.dlShiftTo(d, j);<br />                 for (j.subTo(f, f); f.t < d;)<br />                 f[f.t++] = 0;<br />                 for (; 0 <= --m;) {<br />                     var n = c[--l] == e ? this.DM : Math.floor(c[l] * k + (c[l - 1] + o) * i);<br />                     if ((c[l] += f.am(0, n, c, m, 0, d)) < n) {<br />                         f.dlShiftTo(m, j);<br />                         for (c.subTo(j, c); c[l] < --n;)<br />                         c.subTo(j, c)<br />                     }<br />                 }<br />                 null != a && (c.drShiftTo(d, a),<br />                 g != b && BigInteger.ZERO.subTo(a, a));<br />                 c.t = d;<br />                 c.clamp();<br />                 0 < h && c.rShiftTo(h, c);<br />                 0 > g && BigInteger.ZERO.subTo(c, c)<br />             }<br />         }<br />     }<br /> }<br /> <br /> function bnMod(b) {<br />     var a = nbi();<br />     this.abs().divRemTo(b, null, a);<br />     0 > this.s && 0 < a.compareTo(BigInteger.ZERO) && b.subTo(a, a);<br />     return a<br /> }<br /> <br /> function Classic(b) {<br />     this.m = b<br /> }<br /> <br /> function cConvert(b) {<br />     return 0 > b.s || 0 <= b.compareTo(this.m) ? b.mod(this.m) : b<br /> }<br /> <br /> function cRevert(b) {<br />     return b<br /> }<br /> <br /> function cReduce(b) {<br />     b.divRemTo(this.m, null, b)<br /> }<br /> <br /> function cMulTo(b, a, c) {<br />     b.multiplyTo(a, c);<br />     this.reduce(c)<br /> }<br /> <br /> function cSqrTo(b, a) {<br />     b.squareTo(a);<br />     this.reduce(a)<br /> }<br /> Classic.prototype.convert = cConvert;<br /> Classic.prototype.revert = cRevert;<br /> Classic.prototype.reduce = cReduce;<br /> Classic.prototype.mulTo = cMulTo;<br /> Classic.prototype.sqrTo = cSqrTo;<br /> <br /> function bnpInvDigit() {<br />     if (1 > this.t) return 0;<br />     var b = this[0];<br />     if (0 == (b & 1)) return 0;<br />     var a = b & 3,<br />         a = a * (2 - (b & 15) * a) & 15,<br />         a = a * (2 - (b & 255) * a) & 255,<br />         a = a * (2 - ((b & 65535) * a & 65535)) & 65535,<br />         a = a * (2 - b * a % this.DV) % this.DV;<br />     return 0 < a ? this.DV - a : -a<br /> }<br /> <br /> function Montgomery(b) {<br />     this.m = b;<br />     this.mp = b.invDigit();<br />     this.mpl = this.mp & 32767;<br />     this.mph = this.mp >> 15;<br />     this.um = (1 << b.DB - 15) - 1;<br />     this.mt2 = 2 * b.t<br /> }<br /> <br /> function montConvert(b) {<br />     var a = nbi();<br />     b.abs().dlShiftTo(this.m.t, a);<br />     a.divRemTo(this.m, null, a);<br />     0 > b.s && 0 < a.compareTo(BigInteger.ZERO) && this.m.subTo(a, a);<br />     return a<br /> }<br /> <br /> function montRevert(b) {<br />     var a = nbi();<br />     b.copyTo(a);<br />     this.reduce(a);<br />     return a<br /> }<br /> <br /> function montReduce(b) {<br />     for (; b.t <= this.mt2;)<br />     b[b.t++] = 0;<br />     for (var a = 0; a < this.m.t; ++a) {<br />         var c = b[a] & 32767,<br />             d = c * this.mpl + ((c * this.mph + (b[a] >> 15) * this.mpl & this.um) << 15) & b.DM,<br />             c = a + this.m.t;<br />         for (b[c] += this.m.am(0, d, b, a, 0, this.m.t); b[c] >= b.DV;)<br />         b[c] -= b.DV,<br />         b[++c]++<br />     }<br />     b.clamp();<br />     b.drShiftTo(this.m.t, b);<br />     0 <= b.compareTo(this.m) && b.subTo(this.m, b)<br /> }<br /> <br /> function montSqrTo(b, a) {<br />     b.squareTo(a);<br />     this.reduce(a)<br /> }<br /> <br /> function montMulTo(b, a, c) {<br />     b.multiplyTo(a, c);<br />     this.reduce(c)<br /> }<br /> Montgomery.prototype.convert = montConvert;<br /> Montgomery.prototype.revert = montRevert;<br /> Montgomery.prototype.reduce = montReduce;<br /> Montgomery.prototype.mulTo = montMulTo;<br /> Montgomery.prototype.sqrTo = montSqrTo;<br /> <br /> function bnpIsEven() {<br />     return 0 == (0 < this.t ? this[0] & 1 : this.s)<br /> }<br /> <br /> function bnpExp(b, a) {<br />     if (4294967295 < b || 1 > b) return BigInteger.ONE;<br />     var c = nbi(),<br />         d = nbi(),<br />         e = a.convert(this),<br />         f = nbits(b) - 1;<br />     for (e.copyTo(c); 0 <=

飞翔软件开发

自己不会就不要误导大家，你都吧我给绕进去了，你的js有问题，你抓的不对；getPwd(pwd)
1.txt (21.13 KB, 下载次数: 2)

2018-12-19 23:18 上传

点击文件名下载附件

iamafailor

峰生水起之林 发表于 2018-12-19 23:59
看图插入句十六进制位数代码即可解决你的问题了
setMaxDigits(130);

对了老哥 可以了

请问一下原因好嘛？

能解释一下吗？  

最佳已经妥妥是你的了

繁华似梦

楼主这刷屏神器