0) {
480 | x.rShiftTo(g,x);
481 | y.rShiftTo(g,y);
482 | }
483 | while(x.signum() > 0) {
484 | if((i = x.getLowestSetBit()) > 0) x.rShiftTo(i,x);
485 | if((i = y.getLowestSetBit()) > 0) y.rShiftTo(i,y);
486 | if(x.compareTo(y) >= 0) {
487 | x.subTo(y,x);
488 | x.rShiftTo(1,x);
489 | }
490 | else {
491 | y.subTo(x,y);
492 | y.rShiftTo(1,y);
493 | }
494 | }
495 | if(g > 0) y.lShiftTo(g,y);
496 | return y;
497 | }
498 |
499 | // (protected) this % n, n < 2^26
500 | function bnpModInt(n) {
501 | if(n <= 0) return 0;
502 | var d = this.DV%n, r = (this.s<0)?n-1:0;
503 | if(this.t > 0)
504 | if(d == 0) r = this[0]%n;
505 | else for(var i = this.t-1; i >= 0; --i) r = (d*r+this[i])%n;
506 | return r;
507 | }
508 |
509 | // (public) 1/this % m (HAC 14.61)
510 | function bnModInverse(m) {
511 | var ac = m.isEven();
512 | if((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO;
513 | var u = m.clone(), v = this.clone();
514 | var a = nbv(1), b = nbv(0), c = nbv(0), d = nbv(1);
515 | while(u.signum() != 0) {
516 | while(u.isEven()) {
517 | u.rShiftTo(1,u);
518 | if(ac) {
519 | if(!a.isEven() || !b.isEven()) { a.addTo(this,a); b.subTo(m,b); }
520 | a.rShiftTo(1,a);
521 | }
522 | else if(!b.isEven()) b.subTo(m,b);
523 | b.rShiftTo(1,b);
524 | }
525 | while(v.isEven()) {
526 | v.rShiftTo(1,v);
527 | if(ac) {
528 | if(!c.isEven() || !d.isEven()) { c.addTo(this,c); d.subTo(m,d); }
529 | c.rShiftTo(1,c);
530 | }
531 | else if(!d.isEven()) d.subTo(m,d);
532 | d.rShiftTo(1,d);
533 | }
534 | if(u.compareTo(v) >= 0) {
535 | u.subTo(v,u);
536 | if(ac) a.subTo(c,a);
537 | b.subTo(d,b);
538 | }
539 | else {
540 | v.subTo(u,v);
541 | if(ac) c.subTo(a,c);
542 | d.subTo(b,d);
543 | }
544 | }
545 | if(v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO;
546 | if(d.compareTo(m) >= 0) return d.subtract(m);
547 | if(d.signum() < 0) d.addTo(m,d); else return d;
548 | if(d.signum() < 0) return d.add(m); else return d;
549 | }
550 |
551 | 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];
552 | var lplim = (1<<26)/lowprimes[lowprimes.length-1];
553 |
554 | // (public) test primality with certainty >= 1-.5^t
555 | function bnIsProbablePrime(t) {
556 | var i, x = this.abs();
557 | if(x.t == 1 && x[0] <= lowprimes[lowprimes.length-1]) {
558 | for(i = 0; i < lowprimes.length; ++i)
559 | if(x[0] == lowprimes[i]) return true;
560 | return false;
561 | }
562 | if(x.isEven()) return false;
563 | i = 1;
564 | while(i < lowprimes.length) {
565 | var m = lowprimes[i], j = i+1;
566 | while(j < lowprimes.length && m < lplim) m *= lowprimes[j++];
567 | m = x.modInt(m);
568 | while(i < j) if(m%lowprimes[i++] == 0) return false;
569 | }
570 | return x.millerRabin(t);
571 | }
572 |
573 | // (protected) true if probably prime (HAC 4.24, Miller-Rabin)
574 | function bnpMillerRabin(t) {
575 | var n1 = this.subtract(BigInteger.ONE);
576 | var k = n1.getLowestSetBit();
577 | if(k <= 0) return false;
578 | var r = n1.shiftRight(k);
579 | t = (t+1)>>1;
580 | if(t > lowprimes.length) t = lowprimes.length;
581 | var a = nbi();
582 | for(var i = 0; i < t; ++i) {
583 | //Pick bases at random, instead of starting at 2
584 | a.fromInt(lowprimes[Math.floor(Math.random()*lowprimes.length)]);
585 | var y = a.modPow(r,this);
586 | if(y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {
587 | var j = 1;
588 | while(j++ < k && y.compareTo(n1) != 0) {
589 | y = y.modPowInt(2,this);
590 | if(y.compareTo(BigInteger.ONE) == 0) return false;
591 | }
592 | if(y.compareTo(n1) != 0) return false;
593 | }
594 | }
595 | return true;
596 | }
597 |
598 | // protected
599 | BigInteger.prototype.chunkSize = bnpChunkSize;
600 | BigInteger.prototype.toRadix = bnpToRadix;
601 | BigInteger.prototype.fromRadix = bnpFromRadix;
602 | BigInteger.prototype.fromNumber = bnpFromNumber;
603 | BigInteger.prototype.bitwiseTo = bnpBitwiseTo;
604 | BigInteger.prototype.changeBit = bnpChangeBit;
605 | BigInteger.prototype.addTo = bnpAddTo;
606 | BigInteger.prototype.dMultiply = bnpDMultiply;
607 | BigInteger.prototype.dAddOffset = bnpDAddOffset;
608 | BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo;
609 | BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo;
610 | BigInteger.prototype.modInt = bnpModInt;
611 | BigInteger.prototype.millerRabin = bnpMillerRabin;
612 |
613 | // public
614 | BigInteger.prototype.clone = bnClone;
615 | BigInteger.prototype.intValue = bnIntValue;
616 | BigInteger.prototype.byteValue = bnByteValue;
617 | BigInteger.prototype.shortValue = bnShortValue;
618 | BigInteger.prototype.signum = bnSigNum;
619 | BigInteger.prototype.toByteArray = bnToByteArray;
620 | BigInteger.prototype.equals = bnEquals;
621 | BigInteger.prototype.min = bnMin;
622 | BigInteger.prototype.max = bnMax;
623 | BigInteger.prototype.and = bnAnd;
624 | BigInteger.prototype.or = bnOr;
625 | BigInteger.prototype.xor = bnXor;
626 | BigInteger.prototype.andNot = bnAndNot;
627 | BigInteger.prototype.not = bnNot;
628 | BigInteger.prototype.shiftLeft = bnShiftLeft;
629 | BigInteger.prototype.shiftRight = bnShiftRight;
630 | BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit;
631 | BigInteger.prototype.bitCount = bnBitCount;
632 | BigInteger.prototype.testBit = bnTestBit;
633 | BigInteger.prototype.setBit = bnSetBit;
634 | BigInteger.prototype.clearBit = bnClearBit;
635 | BigInteger.prototype.flipBit = bnFlipBit;
636 | BigInteger.prototype.add = bnAdd;
637 | BigInteger.prototype.subtract = bnSubtract;
638 | BigInteger.prototype.multiply = bnMultiply;
639 | BigInteger.prototype.divide = bnDivide;
640 | BigInteger.prototype.remainder = bnRemainder;
641 | BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder;
642 | BigInteger.prototype.modPow = bnModPow;
643 | BigInteger.prototype.modInverse = bnModInverse;
644 | BigInteger.prototype.pow = bnPow;
645 | BigInteger.prototype.gcd = bnGCD;
646 | BigInteger.prototype.isProbablePrime = bnIsProbablePrime;
647 |
648 | // JSBN-specific extension
649 | BigInteger.prototype.square = bnSquare;
650 |
651 | // BigInteger interfaces not implemented in jsbn:
652 |
653 | // BigInteger(int signum, byte[] magnitude)
654 | // double doubleValue()
655 | // float floatValue()
656 | // int hashCode()
657 | // long longValue()
658 | // static BigInteger valueOf(long val)
659 |
--------------------------------------------------------------------------------
/rsa/crypto-comp-core.gs:
--------------------------------------------------------------------------------
1 | /*
2 | CryptoJS v3.1.2
3 | code.google.com/p/crypto-js
4 | (c) 2009-2013 by Jeff Mott. All rights reserved.
5 | code.google.com/p/crypto-js/wiki/License
6 | */
7 | /**
8 | * CryptoJS core components.
9 | */
10 | var CryptoJS = CryptoJS || (function (Math, undefined) {
11 | /**
12 | * CryptoJS namespace.
13 | */
14 | var C = {};
15 |
16 | /**
17 | * Library namespace.
18 | */
19 | var C_lib = C.lib = {};
20 |
21 | /**
22 | * Base object for prototypal inheritance.
23 | */
24 | var Base = C_lib.Base = (function () {
25 | function F() {}
26 |
27 | return {
28 | /**
29 | * Creates a new object that inherits from this object.
30 | *
31 | * @param {Object} overrides Properties to copy into the new object.
32 | *
33 | * @return {Object} The new object.
34 | *
35 | * @static
36 | *
37 | * @example
38 | *
39 | * var MyType = CryptoJS.lib.Base.extend({
40 | * field: 'value',
41 | *
42 | * method: function () {
43 | * }
44 | * });
45 | */
46 | extend: function (overrides) {
47 | // Spawn
48 | F.prototype = this;
49 | var subtype = new F();
50 |
51 | // Augment
52 | if (overrides) {
53 | subtype.mixIn(overrides);
54 | }
55 |
56 | // Create default initializer
57 | if (!subtype.hasOwnProperty('init')) {
58 | subtype.init = function () {
59 | subtype.$super.init.apply(this, arguments);
60 | };
61 | }
62 |
63 | // Initializer's prototype is the subtype object
64 | subtype.init.prototype = subtype;
65 |
66 | // Reference supertype
67 | subtype.$super = this;
68 |
69 | return subtype;
70 | },
71 |
72 | /**
73 | * Extends this object and runs the init method.
74 | * Arguments to create() will be passed to init().
75 | *
76 | * @return {Object} The new object.
77 | *
78 | * @static
79 | *
80 | * @example
81 | *
82 | * var instance = MyType.create();
83 | */
84 | create: function () {
85 | var instance = this.extend();
86 | instance.init.apply(instance, arguments);
87 |
88 | return instance;
89 | },
90 |
91 | /**
92 | * Initializes a newly created object.
93 | * Override this method to add some logic when your objects are created.
94 | *
95 | * @example
96 | *
97 | * var MyType = CryptoJS.lib.Base.extend({
98 | * init: function () {
99 | * // ...
100 | * }
101 | * });
102 | */
103 | init: function () {
104 | },
105 |
106 | /**
107 | * Copies properties into this object.
108 | *
109 | * @param {Object} properties The properties to mix in.
110 | *
111 | * @example
112 | *
113 | * MyType.mixIn({
114 | * field: 'value'
115 | * });
116 | */
117 | mixIn: function (properties) {
118 | for (var propertyName in properties) {
119 | if (properties.hasOwnProperty(propertyName)) {
120 | this[propertyName] = properties[propertyName];
121 | }
122 | }
123 |
124 | // IE won't copy toString using the loop above
125 | if (properties.hasOwnProperty('toString')) {
126 | this.toString = properties.toString;
127 | }
128 | },
129 |
130 | /**
131 | * Creates a copy of this object.
132 | *
133 | * @return {Object} The clone.
134 | *
135 | * @example
136 | *
137 | * var clone = instance.clone();
138 | */
139 | clone: function () {
140 | return this.init.prototype.extend(this);
141 | }
142 | };
143 | }());
144 |
145 | /**
146 | * An array of 32-bit words.
147 | *
148 | * @property {Array} words The array of 32-bit words.
149 | * @property {number} sigBytes The number of significant bytes in this word array.
150 | */
151 | var WordArray = C_lib.WordArray = Base.extend({
152 | /**
153 | * Initializes a newly created word array.
154 | *
155 | * @param {Array} words (Optional) An array of 32-bit words.
156 | * @param {number} sigBytes (Optional) The number of significant bytes in the words.
157 | *
158 | * @example
159 | *
160 | * var wordArray = CryptoJS.lib.WordArray.create();
161 | * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
162 | * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
163 | */
164 | init: function (words, sigBytes) {
165 | words = this.words = words || [];
166 |
167 | if (sigBytes != undefined) {
168 | this.sigBytes = sigBytes;
169 | } else {
170 | this.sigBytes = words.length * 4;
171 | }
172 | },
173 |
174 | /**
175 | * Converts this word array to a string.
176 | *
177 | * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
178 | *
179 | * @return {string} The stringified word array.
180 | *
181 | * @example
182 | *
183 | * var string = wordArray + '';
184 | * var string = wordArray.toString();
185 | * var string = wordArray.toString(CryptoJS.enc.Utf8);
186 | */
187 | toString: function (encoder) {
188 | return (encoder || Hex).stringify(this);
189 | },
190 |
191 | /**
192 | * Concatenates a word array to this word array.
193 | *
194 | * @param {WordArray} wordArray The word array to append.
195 | *
196 | * @return {WordArray} This word array.
197 | *
198 | * @example
199 | *
200 | * wordArray1.concat(wordArray2);
201 | */
202 | concat: function (wordArray) {
203 | // Shortcuts
204 | var thisWords = this.words;
205 | var thatWords = wordArray.words;
206 | var thisSigBytes = this.sigBytes;
207 | var thatSigBytes = wordArray.sigBytes;
208 |
209 | // Clamp excess bits
210 | this.clamp();
211 |
212 | // Concat
213 | if (thisSigBytes % 4) {
214 | // Copy one byte at a time
215 | for (var i = 0; i < thatSigBytes; i++) {
216 | var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
217 | thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
218 | }
219 | } else if (thatWords.length > 0xffff) {
220 | // Copy one word at a time
221 | for (var i = 0; i < thatSigBytes; i += 4) {
222 | thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
223 | }
224 | } else {
225 | // Copy all words at once
226 | thisWords.push.apply(thisWords, thatWords);
227 | }
228 | this.sigBytes += thatSigBytes;
229 |
230 | // Chainable
231 | return this;
232 | },
233 |
234 | /**
235 | * Removes insignificant bits.
236 | *
237 | * @example
238 | *
239 | * wordArray.clamp();
240 | */
241 | clamp: function () {
242 | // Shortcuts
243 | var words = this.words;
244 | var sigBytes = this.sigBytes;
245 |
246 | // Clamp
247 | words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
248 | words.length = Math.ceil(sigBytes / 4);
249 | },
250 |
251 | /**
252 | * Creates a copy of this word array.
253 | *
254 | * @return {WordArray} The clone.
255 | *
256 | * @example
257 | *
258 | * var clone = wordArray.clone();
259 | */
260 | clone: function () {
261 | var clone = Base.clone.call(this);
262 | clone.words = this.words.slice(0);
263 |
264 | return clone;
265 | },
266 |
267 | /**
268 | * Creates a word array filled with random bytes.
269 | *
270 | * @param {number} nBytes The number of random bytes to generate.
271 | *
272 | * @return {WordArray} The random word array.
273 | *
274 | * @static
275 | *
276 | * @example
277 | *
278 | * var wordArray = CryptoJS.lib.WordArray.random(16);
279 | */
280 | random: function (nBytes) {
281 | var words = [];
282 | for (var i = 0; i < nBytes; i += 4) {
283 | words.push((Math.random() * 0x100000000) | 0);
284 | }
285 |
286 | return new WordArray.init(words, nBytes);
287 | }
288 | });
289 |
290 | /**
291 | * Encoder namespace.
292 | */
293 | var C_enc = C.enc = {};
294 |
295 | /**
296 | * Hex encoding strategy.
297 | */
298 | var Hex = C_enc.Hex = {
299 | /**
300 | * Converts a word array to a hex string.
301 | *
302 | * @param {WordArray} wordArray The word array.
303 | *
304 | * @return {string} The hex string.
305 | *
306 | * @static
307 | *
308 | * @example
309 | *
310 | * var hexString = CryptoJS.enc.Hex.stringify(wordArray);
311 | */
312 | stringify: function (wordArray) {
313 | // Shortcuts
314 | var words = wordArray.words;
315 | var sigBytes = wordArray.sigBytes;
316 |
317 | // Convert
318 | var hexChars = [];
319 | for (var i = 0; i < sigBytes; i++) {
320 | var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
321 | hexChars.push((bite >>> 4).toString(16));
322 | hexChars.push((bite & 0x0f).toString(16));
323 | }
324 |
325 | return hexChars.join('');
326 | },
327 |
328 | /**
329 | * Converts a hex string to a word array.
330 | *
331 | * @param {string} hexStr The hex string.
332 | *
333 | * @return {WordArray} The word array.
334 | *
335 | * @static
336 | *
337 | * @example
338 | *
339 | * var wordArray = CryptoJS.enc.Hex.parse(hexString);
340 | */
341 | parse: function (hexStr) {
342 | // Shortcut
343 | var hexStrLength = hexStr.length;
344 |
345 | // Convert
346 | var words = [];
347 | for (var i = 0; i < hexStrLength; i += 2) {
348 | words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
349 | }
350 |
351 | return new WordArray.init(words, hexStrLength / 2);
352 | }
353 | };
354 |
355 | /**
356 | * Latin1 encoding strategy.
357 | */
358 | var Latin1 = C_enc.Latin1 = {
359 | /**
360 | * Converts a word array to a Latin1 string.
361 | *
362 | * @param {WordArray} wordArray The word array.
363 | *
364 | * @return {string} The Latin1 string.
365 | *
366 | * @static
367 | *
368 | * @example
369 | *
370 | * var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
371 | */
372 | stringify: function (wordArray) {
373 | // Shortcuts
374 | var words = wordArray.words;
375 | var sigBytes = wordArray.sigBytes;
376 |
377 | // Convert
378 | var latin1Chars = [];
379 | for (var i = 0; i < sigBytes; i++) {
380 | var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
381 | latin1Chars.push(String.fromCharCode(bite));
382 | }
383 |
384 | return latin1Chars.join('');
385 | },
386 |
387 | /**
388 | * Converts a Latin1 string to a word array.
389 | *
390 | * @param {string} latin1Str The Latin1 string.
391 | *
392 | * @return {WordArray} The word array.
393 | *
394 | * @static
395 | *
396 | * @example
397 | *
398 | * var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
399 | */
400 | parse: function (latin1Str) {
401 | // Shortcut
402 | var latin1StrLength = latin1Str.length;
403 |
404 | // Convert
405 | var words = [];
406 | for (var i = 0; i < latin1StrLength; i++) {
407 | words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
408 | }
409 |
410 | return new WordArray.init(words, latin1StrLength);
411 | }
412 | };
413 |
414 | /**
415 | * UTF-8 encoding strategy.
416 | */
417 | var Utf8 = C_enc.Utf8 = {
418 | /**
419 | * Converts a word array to a UTF-8 string.
420 | *
421 | * @param {WordArray} wordArray The word array.
422 | *
423 | * @return {string} The UTF-8 string.
424 | *
425 | * @static
426 | *
427 | * @example
428 | *
429 | * var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
430 | */
431 | stringify: function (wordArray) {
432 | try {
433 | return decodeURIComponent(escape(Latin1.stringify(wordArray)));
434 | } catch (e) {
435 | throw new Error('Malformed UTF-8 data');
436 | }
437 | },
438 |
439 | /**
440 | * Converts a UTF-8 string to a word array.
441 | *
442 | * @param {string} utf8Str The UTF-8 string.
443 | *
444 | * @return {WordArray} The word array.
445 | *
446 | * @static
447 | *
448 | * @example
449 | *
450 | * var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
451 | */
452 | parse: function (utf8Str) {
453 | return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
454 | }
455 | };
456 |
457 | /**
458 | * Abstract buffered block algorithm template.
459 | *
460 | * The property blockSize must be implemented in a concrete subtype.
461 | *
462 | * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
463 | */
464 | var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
465 | /**
466 | * Resets this block algorithm's data buffer to its initial state.
467 | *
468 | * @example
469 | *
470 | * bufferedBlockAlgorithm.reset();
471 | */
472 | reset: function () {
473 | // Initial values
474 | this._data = new WordArray.init();
475 | this._nDataBytes = 0;
476 | },
477 |
478 | /**
479 | * Adds new data to this block algorithm's buffer.
480 | *
481 | * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
482 | *
483 | * @example
484 | *
485 | * bufferedBlockAlgorithm._append('data');
486 | * bufferedBlockAlgorithm._append(wordArray);
487 | */
488 | _append: function (data) {
489 | // Convert string to WordArray, else assume WordArray already
490 | if (typeof data == 'string') {
491 | data = Utf8.parse(data);
492 | }
493 |
494 | // Append
495 | this._data.concat(data);
496 | this._nDataBytes += data.sigBytes;
497 | },
498 |
499 | /**
500 | * Processes available data blocks.
501 | *
502 | * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
503 | *
504 | * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
505 | *
506 | * @return {WordArray} The processed data.
507 | *
508 | * @example
509 | *
510 | * var processedData = bufferedBlockAlgorithm._process();
511 | * var processedData = bufferedBlockAlgorithm._process(!!'flush');
512 | */
513 | _process: function (doFlush) {
514 | // Shortcuts
515 | var data = this._data;
516 | var dataWords = data.words;
517 | var dataSigBytes = data.sigBytes;
518 | var blockSize = this.blockSize;
519 | var blockSizeBytes = blockSize * 4;
520 |
521 | // Count blocks ready
522 | var nBlocksReady = dataSigBytes / blockSizeBytes;
523 | if (doFlush) {
524 | // Round up to include partial blocks
525 | nBlocksReady = Math.ceil(nBlocksReady);
526 | } else {
527 | // Round down to include only full blocks,
528 | // less the number of blocks that must remain in the buffer
529 | nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
530 | }
531 |
532 | // Count words ready
533 | var nWordsReady = nBlocksReady * blockSize;
534 |
535 | // Count bytes ready
536 | var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
537 |
538 | // Process blocks
539 | if (nWordsReady) {
540 | for (var offset = 0; offset < nWordsReady; offset += blockSize) {
541 | // Perform concrete-algorithm logic
542 | this._doProcessBlock(dataWords, offset);
543 | }
544 |
545 | // Remove processed words
546 | var processedWords = dataWords.splice(0, nWordsReady);
547 | data.sigBytes -= nBytesReady;
548 | }
549 |
550 | // Return processed words
551 | return new WordArray.init(processedWords, nBytesReady);
552 | },
553 |
554 | /**
555 | * Creates a copy of this object.
556 | *
557 | * @return {Object} The clone.
558 | *
559 | * @example
560 | *
561 | * var clone = bufferedBlockAlgorithm.clone();
562 | */
563 | clone: function () {
564 | var clone = Base.clone.call(this);
565 | clone._data = this._data.clone();
566 |
567 | return clone;
568 | },
569 |
570 | _minBufferSize: 0
571 | });
572 |
573 | /**
574 | * Abstract hasher template.
575 | *
576 | * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
577 | */
578 | var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
579 | /**
580 | * Configuration options.
581 | */
582 | cfg: Base.extend(),
583 |
584 | /**
585 | * Initializes a newly created hasher.
586 | *
587 | * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
588 | *
589 | * @example
590 | *
591 | * var hasher = CryptoJS.algo.SHA256.create();
592 | */
593 | init: function (cfg) {
594 | // Apply config defaults
595 | this.cfg = this.cfg.extend(cfg);
596 |
597 | // Set initial values
598 | this.reset();
599 | },
600 |
601 | /**
602 | * Resets this hasher to its initial state.
603 | *
604 | * @example
605 | *
606 | * hasher.reset();
607 | */
608 | reset: function () {
609 | // Reset data buffer
610 | BufferedBlockAlgorithm.reset.call(this);
611 |
612 | // Perform concrete-hasher logic
613 | this._doReset();
614 | },
615 |
616 | /**
617 | * Updates this hasher with a message.
618 | *
619 | * @param {WordArray|string} messageUpdate The message to append.
620 | *
621 | * @return {Hasher} This hasher.
622 | *
623 | * @example
624 | *
625 | * hasher.update('message');
626 | * hasher.update(wordArray);
627 | */
628 | update: function (messageUpdate) {
629 | // Append
630 | this._append(messageUpdate);
631 |
632 | // Update the hash
633 | this._process();
634 |
635 | // Chainable
636 | return this;
637 | },
638 |
639 | /**
640 | * Finalizes the hash computation.
641 | * Note that the finalize operation is effectively a destructive, read-once operation.
642 | *
643 | * @param {WordArray|string} messageUpdate (Optional) A final message update.
644 | *
645 | * @return {WordArray} The hash.
646 | *
647 | * @example
648 | *
649 | * var hash = hasher.finalize();
650 | * var hash = hasher.finalize('message');
651 | * var hash = hasher.finalize(wordArray);
652 | */
653 | finalize: function (messageUpdate) {
654 | // Final message update
655 | if (messageUpdate) {
656 | this._append(messageUpdate);
657 | }
658 |
659 | // Perform concrete-hasher logic
660 | var hash = this._doFinalize();
661 |
662 | return hash;
663 | },
664 |
665 | blockSize: 512/32,
666 |
667 | /**
668 | * Creates a shortcut function to a hasher's object interface.
669 | *
670 | * @param {Hasher} hasher The hasher to create a helper for.
671 | *
672 | * @return {Function} The shortcut function.
673 | *
674 | * @static
675 | *
676 | * @example
677 | *
678 | * var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
679 | */
680 | _createHelper: function (hasher) {
681 | return function (message, cfg) {
682 | return new hasher.init(cfg).finalize(message);
683 | };
684 | },
685 |
686 | /**
687 | * Creates a shortcut function to the HMAC's object interface.
688 | *
689 | * @param {Hasher} hasher The hasher to use in this HMAC helper.
690 | *
691 | * @return {Function} The shortcut function.
692 | *
693 | * @static
694 | *
695 | * @example
696 | *
697 | * var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
698 | */
699 | _createHmacHelper: function (hasher) {
700 | return function (message, key) {
701 | return new C_algo.HMAC.init(hasher, key).finalize(message);
702 | };
703 | }
704 | });
705 |
706 | /**
707 | * Algorithm namespace.
708 | */
709 | var C_algo = C.algo = {};
710 |
711 | return C;
712 | }(Math));
713 |
--------------------------------------------------------------------------------
/Code.gs:
--------------------------------------------------------------------------------
1 | var subPanelCSS = {
2 | backgroundColor: '#f7f7f7',
3 | border: '1px solid grey',
4 | padding: '10px'
5 | };
6 |
7 | function onOpen() {
8 | var ss = SpreadsheetApp.getActiveSpreadsheet();
9 | var menuEntries = [{name: "Xero Settings", functionName: "xeroSetup"}, //This will be for adding user API settings.
10 | //{name: "Account Type", functionName: "accountType"}, // Select Payable or Receivables
11 | {name: "Manual Upload Invoices", functionName: "uploadInvoices"}, // Push through manaual upload of prices.
12 | {name: "Manual Download Invoices", functionName: "handleInvoicesDownload"}, // Push through manual download of orders.
13 | {name: "Manual Upload Payments", functionName: "uploadPayments"}, // Push through manual upload of order statuses.
14 | {name: "Manual Download Payments", functionName: "handlePaymentsDownload"},
15 | //{name: "Automation Setup", functionName: "automation"}, // Automation setup for automatic upload and download of Invoices, download of Invoices, upload of Payments, and Download of Payments. If each function could be listed with own trigger setup.
16 | {name: "Clear Data", functionName: "clearData"},
17 | //{name: "Test", functionName: "downloadInvoiceOptions"}
18 | ];
19 | ss.addMenu("XERO", menuEntries);
20 | }
21 |
22 | function doGet(e) {
23 | // https://script.google.com/macros/s/AKfycbyoJ09MtcAJFB-v31CH3sA2L5atNr4jtGW3cYWlqqpvGg_kBEY/exec?oauth_token=KNDX9LRNOC0KNAEB4PSVPDINTGSC6F&oauth_verifier=1144716&org=zX0A5sD18KgGYSSotqTKvG
24 | // Step 3. Exchange verified Request token for Access Token
25 | // var p = PropertiesService.getScriptProperties().getProperties();
26 | Xero.getSettings();
27 | var payload =
28 | {
29 | "oauth_consumer_key": Xero.getProperty('consumerKey'),
30 | "oauth_token": e.parameter.oauth_token,
31 | "oauth_signature_method": "PLAINTEXT",
32 | "oauth_signature": encodeURIComponent(Xero.getProperty('consumerSecret') + '&' + Xero.getProperty('requestTokenSecret')),
33 | "oauth_timestamp": ((new Date().getTime())/1000).toFixed(0),
34 | "oauth_nonce": generateRandomString(Math.floor(Math.round(25))),
35 | "oauth_version": "1.0",
36 | "oauth_verifier": e.parameter.oauth_verifier
37 | };
38 | var options = {"method": "post", "payload": payload, muteHttpExceptions: true};
39 | try {
40 | var response = UrlFetchApp.fetch(accessTokenURL, options);
41 | }catch(e) {
42 | Logger.log(e);
43 | return HtmlService.createHtmlOutput(""+ response.getContentText() +"
");
44 | }
45 |
46 | var reoAuthToken = /(oauth_token=)([a-zA-Z0-9]+)/;
47 | var tokenMatch = reoAuthToken.exec(response.getContentText());
48 | var reTokenSecret = /(oauth_token_secret=)([a-zA-Z0-9]+)/;
49 | var secretMatch = reTokenSecret.exec(response.getContentText()) ;
50 |
51 | if (tokenMatch && tokenMatch[2] != '') {
52 | PropertiesService.getScriptProperties().setProperty('accessToken', tokenMatch[2]);
53 | PropertiesService.getScriptProperties().setProperty('accessTokenSecret', secretMatch[2]);
54 | PropertiesService.getScriptProperties().setProperty('isConnected', true);
55 | ScriptApp.newTrigger('closeConnection').timeBased().after(30000);
56 | return HtmlService.createHtmlOutput("Your spreadsheet is now connected to Xero.com for 30 mins.");
57 | }
58 | }
59 |
60 | function closeConnection() {
61 | PropertiesService.getScriptProperties().deleteProperty('isConnected');
62 | PropertiesService.getScriptProperties().setProperty('isConnected', false);
63 | }
64 |
65 | function closeApp() {
66 | var app = UiApp.getActiveApplication();
67 | app.close();
68 | return app;
69 | }
70 |
71 | function xeroSetup() {
72 | var ss = SpreadsheetApp.getActiveSpreadsheet();
73 | var app = UiApp.createApplication();
74 | app.setHeight(400);
75 | var scriptProps = PropertiesService.getScriptProperties();
76 |
77 | var label1 = app.createLabel('XERO Settings').setStyleAttribute('font-weight', 'bold').setStyleAttribute('padding', '5px').setId('label1');
78 | var panel1 = app.createVerticalPanel().setId('panel1');
79 | var grid = app.createGrid(7, 2);
80 | var absPanel = app.createAbsolutePanel();
81 |
82 | var handler = app.createServerHandler('saveSettings');
83 | var clientHandler1 = app.createClientHandler();
84 | var clientHandler2 = app.createClientHandler();
85 | var clientHandler3 = app.createClientHandler();
86 |
87 | var btnSave = app.createButton('Save Settings', handler);
88 | var lblAppType = app.createLabel('Application Type: ');
89 | var appTypes = {Private:0, Public:1, Partner:2};
90 | var listAppType = app.createListBox().setName('appType').addItem('Private').addItem('Public').addItem('Partner').addChangeHandler(clientHandler1).
91 | addChangeHandler(clientHandler2).addChangeHandler(clientHandler3).setSelectedIndex(appTypes[(scriptProps.getProperty('appType') != null ? scriptProps.getProperty('appType'): 'Private')]);
92 | handler.addCallbackElement(listAppType);
93 |
94 | var lblAppName = app.createLabel('Application Name: ');
95 | var txtAppName = app.createTextBox().setName('userAgent').setWidth("350")
96 | .setValue((scriptProps.getProperty('userAgent') != null ? scriptProps.getProperty('userAgent'): ""));
97 | handler.addCallbackElement(txtAppName);
98 |
99 | var lblConsumerKey = app.createLabel('Consumer Key: ');
100 | var txtConsumerKey = app.createTextBox().setName('consumerKey').setWidth("350")
101 | .setValue((scriptProps.getProperty('consumerKey') != null ? scriptProps.getProperty('consumerKey'): ""));
102 | handler.addCallbackElement(txtConsumerKey);
103 |
104 | var lblConsumerSecret = app.createLabel('Consumer Secret: ');
105 | var txtConsumerSecret = app.createTextBox().setName('consumerSecret').setWidth("350")
106 | .setValue((scriptProps.getProperty('consumerSecret') != null ? scriptProps.getProperty('consumerSecret'): ""));
107 | handler.addCallbackElement(txtConsumerSecret);
108 |
109 | var lblcallBack = app.createLabel('Callback URL:');
110 | var txtcallBack = app.createTextBox().setName('callBack').setWidth("350")
111 | .setValue((scriptProps.getProperty('callbackURL') != null ? scriptProps.getProperty('callbackURL'): ""));
112 | handler.addCallbackElement(txtcallBack);
113 |
114 | var lblRSA = app.createLabel('RSA Private Key:');
115 | var txtareaRSA = app.createTextArea().setName('RSA').setWidth("350").setHeight("150")
116 | .setValue((scriptProps.getProperty('rsaKey') != null ? scriptProps.getProperty('rsaKey'): ""));
117 |
118 | if (scriptProps.getProperty('appType') == "Private" || scriptProps.getProperty('appType') == null)
119 | txtcallBack.setEnabled(false);
120 | else if (scriptProps.getProperty('appType') == "Public")
121 | txtareaRSA.setEnabled(false);
122 |
123 | handler.addCallbackElement(txtareaRSA);
124 | clientHandler1.validateMatches(listAppType, 'Private').forTargets(txtcallBack).setEnabled(false).forTargets(txtareaRSA).setEnabled(true);
125 | clientHandler2.validateMatches(listAppType, 'Public').forTargets(txtcallBack).setEnabled(true).forTargets(txtareaRSA).setEnabled(false);
126 | clientHandler3.validateMatches(listAppType, 'Partner').forTargets(txtcallBack).setEnabled(true).forTargets(txtareaRSA).setEnabled(true);
127 |
128 | grid.setBorderWidth(0);
129 | grid.setWidget(0, 0, lblAppType);
130 | grid.setWidget(0, 1, listAppType);
131 | grid.setWidget(1, 0, lblAppName);
132 | grid.setWidget(1, 1, txtAppName);
133 | grid.setWidget(2, 0, lblConsumerKey);
134 | grid.setWidget(2, 1, txtConsumerKey);
135 | grid.setWidget(3, 0, lblConsumerSecret);
136 | grid.setWidget(3, 1, txtConsumerSecret);
137 | grid.setWidget(4, 0, lblcallBack);
138 | grid.setWidget(4, 1, txtcallBack);
139 | grid.setWidget(5, 0, lblRSA);
140 | grid.setWidget(5, 1, txtareaRSA);
141 | grid.setWidget(6, 1, btnSave);
142 | panel1.add(grid).setStyleAttributes(subPanelCSS);
143 | app.add(label1);
144 | app.add(panel1);
145 | ss.show(app);
146 | }
147 |
148 | function saveSettings(e){
149 | var ss = SpreadsheetApp.getActiveSpreadsheet();
150 | var app = UiApp.getActiveApplication();
151 | // we have the settings in e.parameter
152 | var sProps = PropertiesService.getScriptProperties();
153 | var p = e.parameter;
154 | var properties = { appType: p.appType, userAgent: p.userAgent, consumerKey: p.consumerKey, consumerSecret: p.consumerSecret, rsaKey: p.RSA,
155 | callbackURL: p.callBack };
156 | if (sProps.setProperties(properties))
157 | ss.toast('Xero Settings saved.', '', 5);
158 | else
159 | ss.toast('Xero settings could not be saved.', '', 5);
160 | if (p.appType != 'Private') {
161 | app.remove(app.getElementById('label1'));
162 | app.remove(app.getElementById('panel1'));
163 | app.setHeight(50);app.setWidth(100);
164 | var link = app.createAnchor('Connect to Xero', true, Xero.connect());
165 | var handler = app.createServerHandler('closeApp');
166 | link.addClickHandler(handler);
167 | app.add(link);
168 | }
169 | else
170 | app.close();
171 | return app;
172 | }
173 |
174 | // Download Functions
175 | function downloadInvoices() {
176 | downloadOptions('Invoices');
177 | }
178 |
179 | function downloadPayments() {
180 | downloadOptions('Payments');
181 | }
182 |
183 | function downloadOptions(item) {
184 | var ss = SpreadsheetApp.getActiveSpreadsheet();
185 | var app = UiApp.createApplication();
186 | var panel = app.createAbsolutePanel().setStyleAttributes(subPanelCSS).setWidth("475");
187 | var lblHeader = app.createLabel('Download ' + item).setStyleAttribute('font-weight', 'bold');
188 | var gridMain = app.createGrid(4, 2);
189 | var optAllHandler = app.createClientHandler();
190 | var optModifiedAfterHandler = app.createClientHandler();
191 | var optAll = app.createRadioButton('optAll', 'All').setId('optAll').setValue(true).addClickHandler(optAllHandler);
192 | var optModifiedAfter = app.createRadioButton('optModifiedAfter', 'Modified After').setValue(false).addClickHandler(optModifiedAfterHandler);
193 | var modifiedAfterDate = app.createDatePicker().setVisible(false).setName('modifiedAfterDate').setValue(new Date());
194 |
195 | optAllHandler.forEventSource().setEnabled(true).forTargets(optModifiedAfter).setValue(false).forTargets(modifiedAfterDate).setVisible(false);
196 | optModifiedAfterHandler.forEventSource().setEnabled(true).forTargets(optAll).setValue(false).forTargets(modifiedAfterDate).setVisible(true);
197 |
198 | switch(item) {
199 | case 'Invoices':
200 | var clickHandler = app.createServerHandler('handleInvoicesDownload');
201 | break;
202 | case 'Payments':
203 | var clickHandler = app.createServerHandler('handlePaymentsDownload');
204 | break;
205 | }
206 | var btnHandler = app.createClientHandler().forEventSource().setEnabled(false).forTargets(optAll).setEnabled(false).forTargets(optModifiedAfter).setEnabled(false).forTargets(modifiedAfterDate).setEnabled(false);
207 | var btnDownload = app.createButton('Download', clickHandler).addClickHandler(btnHandler);
208 |
209 | // callback elements
210 | clickHandler.addCallbackElement(optAll).addCallbackElement(optModifiedAfter).addCallbackElement(modifiedAfterDate);
211 | gridMain.setWidget(0, 0, optAll);
212 | gridMain.setWidget(1, 0, optModifiedAfter);
213 | gridMain.setWidget(2, 1, modifiedAfterDate);
214 | gridMain.setWidget(3, 0, btnDownload);
215 |
216 | panel.add(gridMain);
217 | app.add(lblHeader);
218 | app.add(panel);
219 |
220 | ss.show(app);
221 | }
222 |
223 | function handleInvoicesDownload(){
224 | var ss = SpreadsheetApp.getActiveSpreadsheet();
225 | var sheet = ss.getSheetByName("Invoices Download");
226 | var li_sheet = ss.getSheetByName("Download - Invoices Line Items");
227 |
228 | if (!sheet) ss.insertSheet("Invoices Download");
229 | if (!li_sheet) ss.insertSheet("Download - Invoices Line Items");
230 |
231 | // Add headers
232 | if (sheet.getLastRow() == 0) {
233 | var arrHeaders = ['Type', 'Contact Name', 'Date', 'Due Date', 'Status', 'Line Amount Types', 'Sub Total', 'Total Tax', 'Total', 'Updated Date (UTC)',
234 | 'Currency Code', 'Invoice ID', 'Invoice Number', 'Amount Due', 'Amount Paid', 'Amount Credited'];
235 | sheet.appendRow(arrHeaders).getRange(1, 1, 1, 16).setFontWeight('bold');
236 | }
237 | if (li_sheet.getLastRow() == 0) {
238 | var liHeaders = ['Invoice ID', 'Invoice Number', 'Description', 'Quantity', 'Unit Amount', 'Tax Type', 'Tax Amount', 'Line Amount', 'Account Code'];
239 | li_sheet.appendRow(liHeaders).getRange(1, 1, 1, 9).setFontWeight('bold');
240 | }
241 |
242 | var pageNo = 1;
243 | var moreData = true;
244 |
245 | try {
246 | // Connect to Xero
247 | Xero.connect();
248 |
249 | while (moreData) {
250 | ss.toast('Downloading page ' + pageNo + ' ...');
251 | // API call
252 | var invoice_info = Xero.fetchData('Invoices', pageNo);
253 | Logger.log(invoice_info);
254 |
255 | if (invoice_info) var invoices = invoice_info.Invoices;
256 | else return false;
257 |
258 | // If less than 100 records returned, there are no more records
259 | if (invoices.length < 100) moreData = false;
260 | else pageNo++;
261 |
262 | // Processing the result and update Invoices data in the sheet
263 | for(var i=0; i < invoices.length; i++) {
264 | var invoice = invoices[i];
265 | var accType = (invoice.Type != null) ? invoice.Type : "";
266 | var contactName = (invoice.Contact != null) ? invoice.Contact.Name : "";
267 | var date = (invoice.DateString != null) ? invoice.DateString : "";
268 | var dueDate = (invoice.DueDateString != null) ? invoice.DueDateString : "";
269 | var status = (invoice.Status != null) ? invoice.Status : "";
270 | var lineAmountTypes = (invoice.LineAmountTypes != null) ? invoice.LineAmountTypes : "";
271 |
272 | // Line Items present in the Middle
273 | var subTotal = (invoice.SubTotal != null) ? invoice.SubTotal : "";
274 | var totalTax = (invoice.TotalTax != null) ? invoice.TotalTax : "";
275 | var total = (invoice.Total != null) ? invoice.Total : "";
276 | var updatedDateUTC = (invoice.UpdatedDateUTC != null) ? eval('new ' + invoice.UpdatedDateUTC.substr(1, invoice.UpdatedDateUTC.length - 2) + '.toISOString()') : "" ;
277 | var currencyCode = (invoice.CurrencyCode != null) ? invoice.CurrencyCode : "";
278 | var invoiceID = (invoice.InvoiceID != null) ? invoice.InvoiceID : "";
279 | var invoiceNumber = (invoice.InvoiceNumber != null) ? invoice.InvoiceNumber : "";
280 |
281 | // Payments present in the Middle
282 | var amountDue = (invoice.AmountDue != null) ? invoice.AmountDue : "";
283 | var amountPaid = (invoice.AmountPaid != null) ? invoice.AmountPaid : "";
284 | var AmountCredited = (invoice.AmountCredited != null) ? invoice.AmountCredited : 0;
285 |
286 | // Add Line Items to the Invoice in the end, because all other fields for invoice will be common
287 | var arr_line_items = [];
288 |
289 | var lineItems = (invoice.LineItems != null) ? invoice.LineItems : [];
290 | for(var k=0; k < lineItems.length; k++){
291 | var item = lineItems[k];
292 | var description = (item.Description != null ) ? item.Description : "";
293 | var quantity = (item.Quantity != null) ? item.Quantity : "";
294 | var unitAmount = (item.UnitAmount != null) ? item.UnitAmount : "";
295 | var taxType = (item.TaxType != null) ? item.TaxType : "";
296 | var taxAmount = (item.TaxAmount != null) ? item.TaxAmount : "";
297 | var lineAmount = (item.LineAmount != null) ? item.LineAmount : "";
298 | var accountCode = (item.AccountCode != null) ? item.AccountCode : "";
299 |
300 | var tmp = [invoiceID,invoiceNumber,description,quantity,unitAmount,taxType,taxAmount,lineAmount,accountCode];
301 | li_sheet.appendRow(tmp);
302 | }
303 | // Add data in the Spreadsheet
304 | var arr =[accType, contactName, date, dueDate, status, lineAmountTypes, subTotal, totalTax, total, updatedDateUTC, currencyCode, invoiceID, invoiceNumber,amountDue, amountPaid, AmountCredited ];
305 | sheet.appendRow(arr);
306 | }
307 | }
308 | }
309 | catch(e) {
310 | Browser.msgBox('handleInvoicesDownload: ' + e.message);
311 | }
312 | }
313 |
314 | function handlePaymentsDownload(){
315 | var ss = SpreadsheetApp.getActiveSpreadsheet();
316 | var sheet = ss.getSheetByName("Payments Download");
317 |
318 | if (!sheet) {
319 | ss.insertSheet("Payments Download");
320 | sheet = ss.getActiveSheet();
321 | }
322 | sheet.activate();
323 |
324 | // Add headers
325 | if (sheet.getLastRow() == 0) {
326 | var arrHeaders = ['Payment ID', 'Date', 'Amount', 'Currency Rate', 'Payment Type', 'Status', 'Update Date (UTC)', 'Account ID', 'Contact ID', 'Contact Name',
327 | 'Invoice Type', 'Invoice ID', 'Invoice Number'];
328 | sheet.appendRow(arrHeaders).getRange(1, 1, 1, 13).setFontWeight('bold');
329 | }
330 |
331 | var pageNo = 1;
332 | var moreData = true;
333 |
334 | try {
335 | // Connect to Xero
336 | Xero.connect();
337 |
338 | ss.toast("Downloading page " + pageNo + "...");
339 | while (moreData) {
340 | // API call
341 | var payments_info = Xero.fetchData('Payments', pageNo); // Data should retrieve in JSON format
342 |
343 | if (payments_info) var payments = payments_info.Payments;
344 | else return app;
345 |
346 | // Processing the result and update Invoices data in the sheet
347 | for(var i=0; i < payments.length; i++){
348 | var payment = payments[i];
349 | var paymentID = (payment.PaymentID != null) ? payment.PaymentID : "";
350 | var date = (payment.Date != null) ? eval('new ' + payment.Date.substr(1, payment.Date.length - 2) + '.toISOString()') : "" ;
351 | var amount = (payment.Amount != null) ? payment.Amount : "";
352 | var currencyRate = (payment.CurrencyRate != null) ? payment.CurrencyRate : "";
353 | var paymentType = (payment.PaymentType != null) ? payment.PaymentType : "";
354 | var status = (payment.Status != null) ? payment.Status : "";
355 | var updatedDateUTC = (payment.UpdatedDateUTC != null) ? eval('new ' + payment.UpdatedDateUTC.substr(1, payment.UpdatedDateUTC.length - 2) + '.toISOString()') : "" ;
356 |
357 | var accountId = "";
358 | var account = payment.Account;
359 | if (account != null && account != undefined && account != ""){
360 | accountId = ( account.AccountID != null ) ? account.AccountID : "";
361 | }
362 |
363 | var contactID = "", inv_type = "", inv_id = "", inv_number ="", contactName="";
364 | var invoice = payment.Invoice;
365 | if (invoice != undefined && invoice != null && invoice != "") {
366 | inv_type = (invoice.Type != null) ? invoice.Type : "";
367 | inv_id = (invoice.InvoiceID != null) ? invoice.InvoiceID : "";
368 | inv_number = (invoice.InvoiceNumber != null) ? invoice.InvoiceNumber : "";
369 | var contact = invoice.Contact ;
370 |
371 | if(contact != null && contact != undefined && contact != ""){
372 | contactID = (contact.ContactID != null) ? contact.ContactID : "";
373 | contactName = (contact.Name != null) ? contact.Name : "";
374 | }
375 | }
376 | // Add data in the Spreadsheet
377 | var arr = [paymentID, date, amount, currencyRate, paymentType, status, updatedDateUTC, accountId, contactID, contactName, inv_type, inv_id, inv_number];
378 | sheet.appendRow(arr);
379 | }
380 |
381 | // More data?
382 | if (payments.length < 100) moreData = false;
383 | else pageNo++;
384 | }
385 | }
386 | catch(e) {
387 | Browser.msgBox(e.message);
388 | }
389 | }
390 |
391 |
392 | // Upload Functions
393 | function uploadInvoices(){
394 | var ss = SpreadsheetApp.getActiveSpreadsheet();
395 | var sheet = ss.getSheetByName("Invoices Upload");
396 | var l_sheet = ss.getSheetByName("Upload - Invoice Line Items");
397 |
398 | if (!sheet) {
399 | ss.insertSheet('Invoices Upload');
400 | sheet = ss.getSheetByName("Invoices Upload");
401 | }
402 |
403 | if (!l_sheet) {
404 | ss.insertSheet('Upload - Invoice Line Items');
405 | l_sheet = ss.getSheetByName("Upload - Invoice Line Items");
406 | }
407 |
408 | if (sheet.getLastRow() == 0) {
409 | var arrHeaders = ['Invoice Number', 'Invoice Type', 'Contact Name', 'Contact Number', 'Issue Date', 'Due Date', 'Line Amount Types', 'Reference', 'Bid', 'URL',
410 | 'Currency Code', 'Status', 'Sent to Contact', 'Sub Total', 'Total Tax', 'Total'];
411 | sheet.appendRow(arrHeaders).getRange(1, 1, 1, 16).setFontWeight('bold');
412 | }
413 | if (l_sheet.getLastRow() == 0) {
414 | var liHeaders = ['Invoice Number', 'Description', 'Quantity', 'Unit Amount', 'Tax Type', 'Tax Amount', 'Line Amount', 'Account Code', 'Region'];
415 | l_sheet.appendRow(liHeaders).getRange(1, 1, 1, 9).setFontWeight('bold');
416 | }
417 |
418 | sheet.activate();
419 |
420 | if (sheet.getLastRow() <= 1 || l_sheet.getLastRow() <= 1) {
421 | Browser.msgBox('Error: No data to upload');
422 | return false;
423 | }
424 |
425 | var l_lrow = l_sheet.getDataRange().getLastRow();
426 | var l_data = l_sheet.getDataRange().getValues();
427 |
428 | var lrow = sheet.getDataRange().getLastRow();
429 | var lcol = 17;
430 |
431 | var data = sheet.getRange(2, 1, lrow-1, lcol).getValues();
432 | var payload = "";
433 | for(var i=0; i < data.length; i++) {
434 |
435 | var inv_number = data[i][0];
436 | var inv_type = data[i][1];
437 | var contact_name = data[i][2];
438 | var contact_number = data[i][3];
439 | var issue_date = data[i][4];
440 | var due_date = data[i][5];
441 | var line_amount_types = data[i][6];
442 | var reference = data[i][7];
443 | var bid = data[i][8];
444 | var url = data[i][9];
445 | var currency_code = data[i][10];
446 | var status = data[i][11];
447 | var sent_to_contact = data[i][12];
448 | var sub_total = data[i][13];
449 | var total_tax = data[i][14];
450 | var total = data[i][15];
451 |
452 | payload += "";
453 | payload += "" + inv_number + "";
454 | payload += "" + inv_type + "";
455 | payload += "";
456 | payload += "" + contact_name + "";
457 | payload += "" + contact_number + "";
458 | payload += "";
459 |
460 | // Removed the Address related fields in Contact. Add them as required
461 | payload += "" + Utilities.formatDate(issue_date, "GMT", "yyyy-MM-dd") + "";
462 | payload += "" + Utilities.formatDate(due_date, "GMT", "yyyy-MM-dd") + "";
463 | payload += "" + line_amount_types + "";
464 | if(inv_type == "ACCREC"){
465 | payload += "" + reference + "";
466 | }
467 | payload += "" + url + "";
468 | payload += "" + currency_code + "";
469 | payload += "" + status + "";
470 | payload += "" + sent_to_contact + "";
471 | payload += "" + sub_total + "";
472 | payload += "" + total_tax + "";
473 | payload += "" + total + "";
474 |
475 | payload += "";
476 | for(var j=2; j < l_data.length; j++){
477 | var l_inv_number = l_data[j][0];
478 | if(l_inv_number != undefined && l_inv_number != null && l_inv_number != "" && l_inv_number == inv_number){
479 | payload += "";
480 |
481 | var l_desc = l_data[j][1];
482 | var l_quantity = l_data[j][2];
483 | var l_unitamount = l_data[j][3];
484 | var l_taxtype = l_data[j][4];
485 | var l_taxamount = l_data[j][5];
486 | var l_lineamount = l_data[j][6];
487 | var l_accountcode = l_data[j][7];
488 | var l_region = l_data[j][8];
489 |
490 | payload += "" + l_desc + "";
491 | payload += "" + l_quantity + "";
492 | payload += "" + l_unitamount + "";
493 | payload += "" + l_taxtype + "";
494 | payload += "" + l_taxamount + "";
495 | payload += "" + l_lineamount + "";
496 | payload += "" + l_accountcode + "";
497 | payload += "" + l_region + "";
498 |
499 | payload += "";
500 | }
501 | }
502 | payload += "";
503 | payload += "";
504 | }
505 | payload += "";
506 |
507 | try {
508 | Xero.connect();
509 | var response = Xero.uploadData('Invoices', payload);
510 | if (response) {
511 | // request successful, Log failed invoices
512 | var invoices = response.Invoices;
513 | logFailedInvoices(invoices);
514 | }
515 | }
516 | catch(e) {
517 | Browser.msgBox(e.message);
518 | }
519 | }
520 |
521 | function logFailedInvoices(invoices){
522 | var ss = SpreadsheetApp.getActiveSpreadsheet();
523 | var errorSheet = ss.getSheetByName("Error Invoices Upload");
524 | var errorLISheet = ss.getSheetByName("Error Upload - Invoice Line Items");
525 |
526 | if (!errorSheet) ss.insertSheet("Error Invoices Upload");
527 | if (!errorLISheet) ss.insertSheet("Error Upload - Invoice Line Items");
528 |
529 | // Add headers
530 | if (errorSheet.getLastRow() == 0) {
531 | var arrHeaders = ['Type', 'Contact Name', 'Date', 'Due Date', 'Status', 'Line Amount Types', 'Sub Total', 'Total Tax', 'Total', 'Updated Date (UTC)',
532 | 'Currency Code', 'Invoice ID', 'Invoice Number', 'Amount Due', 'Amount Paid', 'Amount Credited'];
533 | errorSheet.appendRow(arrHeaders).getRange(1, 1, 1, 16).setFontWeight('bold');
534 | }
535 | if (errorLISheet.getLastRow() == 0) {
536 | var liHeaders = ['Invoice ID', 'Description', 'Quantity', 'Unit Amount', 'Tax Type', 'Tax Amount', 'Line Amount', 'Account Code'];
537 | errorLISheet.appendRow(liHeaders).getRange(1, 1, 1, 8).setFontWeight('bold');
538 | }
539 |
540 | // Processing the result and update Invoices data in the sheet
541 | var failedInvoices =0;
542 | for(var i=0; i < invoices.length; i++){
543 | var invoice = invoices[i];
544 | var StatusAttributeString = (invoice.StatusAttributeString != null) ? invoice.StatusAttributeString : "";
545 | if (StatusAttributeString == "ERROR") { // an error occured for this invoice
546 | failedInvoices++;
547 | var accType = (invoice.Type != null) ? invoice.Type : "";
548 | var contactName = (invoice.Contact.Name != null) ? invoice.Contact.Name : "";
549 | var date = (invoice.DateString != null) ? invoice.DateString : "";
550 | var dueDate = (invoice.DueDateString != null) ? invoice.DueDateString : "";
551 | var status = (invoice.Status != null) ? invoice.Status : "";
552 | var lineAmountTypes = (invoice.LineAmountTypes != null) ? invoice.LineAmountTypes : "";
553 |
554 | // Line Items present in the Middle
555 | var subTotal = (invoice.SubTotal != null) ? invoice.SubTotal : "";
556 | var totalTax = (invoice.TotalTax != null) ? invoice.TotalTax : "";
557 | var total = (invoice.Total != null) ? invoice.Total : "";
558 | var updatedDateUTC = (invoice.UpdatedDateUTC != null) ? eval('new ' + invoice.UpdatedDateUTC.substr(1, invoice.UpdatedDateUTC.length - 2) + '.toISOString()') : "" ;
559 | var currencyCode = (invoice.CurrencyCode != null) ? invoice.CurrencyCode : "";
560 | var invoiceID = (invoice.InvoiceID != null) ? invoice.InvoiceID : "";
561 | var invoiceNumber = (invoice.InvoiceNumber != null) ? invoice.InvoiceNumber : "";
562 |
563 | // Payments present in the Middle
564 | var amountDue = (invoice.AmountDue != null) ? invoice.AmountDue : "";
565 | var amountPaid = (invoice.AmountPaid != null) ? invoice.AmountPaid : "";
566 | var AmountCredited = (invoice.AmountCredited != null) ? invoice.AmountCredited : 0;
567 |
568 | // Add Line Items to the Invoice in the end, because all other fields for invoice will be common
569 | var arr_line_items = [];
570 |
571 | var lineItems = (invoice.LineItems != null) ? invoice.LineItems : [];
572 | for(var k=0; k < lineItems.length; k++){
573 | var item = lineItems[k];
574 | var description = (item.Description != null ) ? item.Description : "";
575 | var quantity = (item.Quantity != null) ? item.Quantity : "";
576 | var unitAmount = (item.UnitAmount != null) ? item.UnitAmount : "";
577 | var taxType = (item.TaxType != null) ? item.TaxType : "";
578 | var taxAmount = (item.TaxAmount != null) ? item.TaxAmount : "";
579 | var lineAmount = (item.LineAmount != null) ? item.LineAmount : "";
580 | var accountCode = (item.AccountCode != null) ? item.AccountCode : "";
581 |
582 | var tmp = [invoiceID,description,quantity,unitAmount,taxType,taxAmount,lineAmount,accountCode];
583 | errorLISheet.appendRow(tmp);
584 | }
585 | // Add data in the Spreadsheet
586 | var arr =[accType, contactName, date, dueDate, status, lineAmountTypes, subTotal, totalTax, total, updatedDateUTC, currencyCode, invoiceID, invoiceNumber,amountDue, amountPaid, AmountCredited ];
587 | errorSheet.appendRow(arr);
588 | }
589 | }
590 | if (failedInvoices > 0)
591 | Browser.msgBox(failedInvoices + " invoices could not be saved to Xero due to a validation error. See \"Error Invoices Upload\" & \"Error Invoices Upload Line Items\" sheets.");
592 | }
593 |
594 | function uploadPayments(){
595 | var ss = SpreadsheetApp.getActiveSpreadsheet();
596 | var sheet = ss.getSheetByName("Payments Upload");
597 |
598 | if (!sheet) {
599 | Browser.msgBox('Error: "Payments Upload" sheet not found.');
600 | return false;
601 | }
602 | else if (sheet.getLastRow() == 0) {
603 | Browser.msgBox('Error: "Payments Upload" sheet has no data.');
604 | var headers = ['Invoice ID', 'Invoice Number', 'Account ID', 'Account Code', 'Date', 'Currency Rate', 'Amount', 'Reference'];
605 | sheet.getRange(1, 1, 1, 8).setValues(headers).setFontWeight('bold');
606 | return false;
607 | }
608 | var lrow = sheet.getDataRange().getLastRow();
609 | var lcol = 8;
610 |
611 | var data = sheet.getRange(3, 1, lrow-2, lcol).getValues();
612 |
613 | var payload = "";
614 | for(var i=0; i < data.length; i++){
615 | var invoiceID = data[i][0];
616 | var invNumber = data[i][1];
617 | var accID = data[i][2];
618 | var accCode = data[i][3];
619 | var date = data[i][4];
620 | var cur_rate = data[i][5];
621 | var amount = data[i][6];
622 | var reference = data[i][7];
623 | payload += "";
624 |
625 | if (invoiceID != null && invoiceID != undefined && invoiceID != "" )
626 | payload += "" + invoiceID + "";
627 | else if (invNumber != null && invNumber != undefined && invNumber != "") {
628 | payload += "" + invNumber + "";
629 | } else {
630 | Browser.msgBox("Either InvoiceID or Invoice Number should be present. Please see Row:" + i+3);
631 | return;
632 | }
633 |
634 | if (accID != null && accID != undefined && accID != "")
635 | payload += "" + accID + "";
636 | else if (accCode != null && accCode != undefined && accCode != "")
637 | payload += "" + accCode + "";
638 | else {
639 | Browser.msgBox("Either AccountID or Account Code should be present. Please see Row:" + i+3);
640 | return;
641 | }
642 |
643 | payload += "" + Utilities.formatDate(date, "GMT", "yyyy-MM-dd") + "";
644 | payload += "" + cur_rate + "";
645 | payload += "" + amount + "";
646 | payload += "" + reference + "";
647 | payload += "";
648 |
649 | }
650 | payload += "";
651 |
652 | try {
653 | Xero.connect();
654 | var method = 'PUT';
655 | var response = XERO.uploadData('Payments', payload, method);
656 | if (response.code != 200) {
657 | // Log failed items if any
658 | if (response.code == 400) {
659 | Browser.msgBox(response.Message + ' . See "Error Payments Upload" sheet for details. Response Code: ' + response.code);
660 | logFailedPayments(response);
661 | }
662 | else
663 | Browser.msgBox('Error occured. Response Code: ' + response.code);
664 | }
665 | }
666 | catch(e) {
667 | Browser.msgBox(e.message);
668 | }
669 | }
670 |
671 | function logFailedPayments(response) {
672 | var ss = SpreadsheetApp.getActiveSpreadsheet();
673 | var errorPayments = ss.getSheetByName('Error Payments Upload');
674 | if (!errorPayments)
675 | ss.insertSheet('Error Payments Upload');
676 | if (errorPayments.getLastRow() == 0) {
677 | // insert column headers
678 | var colHeaders = ['Invoice ID', 'Invoice Number', 'Account ID', 'Account Code', 'Date', 'Currency Rate', 'Amount', 'Reference', 'Error Message'];
679 | var range = errorPayments.getRange(1, 1, 1, 9).setValues([colHeaders]).setFontWeight('bold');
680 | }
681 | // read response elements
682 | var elements = response.Elements;
683 | for (var i = 0; i < elements.length; i++) {
684 | var elem = elements[i];
685 | var invoiceID = elem.Invoice.InvoiceID ? elem.Invoice.InvoiceID : "";
686 | var invoiceNum = elem.Invoice.InvoiceNumber ? elem.Invoice.InvoiceNumber : "";
687 | var accID = elem.Account.AccountID ? elem.Account.AccountID : "";
688 | var accCode = elem.Account.Code ? elem.Account.Code : "";
689 | var date = elem.Date ? eval("new " + elem.Date.substr(2, elem.Date.length - 2) + ".toISOString()") : "";
690 | var curRate = elem.Invoice.CurrencyRate ? elem.Invoice.CurrencyRate : "";
691 | var amount = elem.Amount ? elem.Amount : "";
692 | var ref = elem.Invoice.Reference ? elem.Invoice.Reference : "";
693 | var errors = elem.ValidationErrors;
694 | var errorMsg = "";
695 | for (var j = 0; j < errors.length; j++)
696 | errorMsg += errors[j].Message ? errors[j].Message + ". " : "";
697 |
698 | var row = [invoiceID, invoiceNum, accID, accCode, date, curRate, amount, ref, errorMsg];
699 | errorPayments.appendRow(row);
700 | }
701 | }
702 |
703 | // Utilities
704 | function generateRandomString(n) {
705 | var chars = ['a', 'b','c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
706 | chars.push('A', 'B', 'C', 'D', 'E', 'F','G','H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z');
707 | var randomString = '';
708 | for (i=0; i < n; i++) {
709 | r = Math.random();
710 | r = r * 61;
711 | r = Math.round(r);
712 | randomString = randomString + chars[r];
713 | }
714 | return randomString;
715 | }
716 |
717 | function convertToUTC(input) {
718 | var inter = new Date(Date.parse(input));
719 | var y = inter.getFullYear();
720 | var m = inter.getMonth() + 1;
721 | var d = inter.getDate();
722 | mString = m; dString = d; yString = y;
723 | if (m < 10)
724 | var mString = '0' + m;
725 | if (d < 10)
726 | var dString = '0' + d;
727 |
728 | var output = yString + '-' + mString + '-' + dString + 'T00:00:00';
729 | Browser.msgBox('convertToUTC: ' + output);
730 | return output;
731 | }
732 |
733 | /*
734 | function download_line_items_for_invoices(){
735 | var ss = SpreadsheetApp.getActiveSpreadsheet();
736 | var sheet = ss.getSheetByName("Xero Invoices Download");
737 | var osheet = ss.getSheetByName("Download - Invoices Line Items");
738 |
739 | var line_items_status_col = 17;
740 | var lrow = sheet.getDataRange().getLastRow();
741 | var data = sheet.getRange(3, line_items_status_col, lrow-2, 1).getValues();
742 |
743 | var invoices = [];
744 | for(var i=0; i < data.length; i++){
745 | if(data[i][0] != undefined && data[i][0] != null && data[i][0] != "YES"){
746 | var invoice_id = sheet.getRange(i+3, 12).getValue();
747 |
748 | var responses = XERO.download_invoice_for_an_id(invoice_id);
749 | var x = 1;
750 |
751 | var invoice = responses.Response.Invoices.Invoice;
752 | var line_items = invoice.LineItems.LineItem;
753 |
754 | if(line_items[0] != undefined && line_items[0] != null && line_items[0] != ""){
755 |
756 | for(var z=0; z < line_items.length; z++){
757 | var line_item = line_items[z];
758 |
759 | var description = (line_item.Description != null) ? line_item.Description : "";
760 | var quantity = (line_item.Quantity != null) ? line_item.Quantity : "";
761 | var unitAmount = (line_item.UnitAmount != null) ? line_item.UnitAmount : "";
762 | var taxType = (line_item.TaxType != null) ? line_item.TaxType : "";
763 | var taxAmount = (line_item.TaxAmount != null) ? line_item.TaxAmount : "";
764 | var lineAmount = (line_item.LineAmount != null) ? line_item.LineAmount : "";
765 | var accountCode = (line_item.AccountCode != null) ? line_item.AccountCode : "";
766 |
767 | var row = [invoice_id, description, quantity, unitAmount, taxType, taxAmount, lineAmount, accountCode];
768 | osheet.appendRow(row).activate();
769 | }
770 |
771 | }else{
772 | var description = (line_items.Description != null) ? line_items.Description : "";
773 | var quantity = (line_items.Quantity != null) ? line_items.Quantity : "";
774 | var unitAmount = (line_items.UnitAmount != null) ? line_items.UnitAmount : "";
775 | var taxType = (line_items.TaxType != null) ? line_items.TaxType : "";
776 | var taxAmount = (line_items.TaxAmount != null) ? line_items.TaxAmount : "";
777 | var lineAmount = (line_items.LineAmount != null) ? line_items.LineAmount : "";
778 | var accountCode = (line_items.AccountCode != null) ? line_items.AccountCode : "";
779 |
780 | var row = [invoice_id, description, quantity, unitAmount, taxType, taxAmount, lineAmount, accountCode];
781 | osheet.appendRow(row).activate();
782 | }
783 |
784 | sheet.getRange(i+3, line_items_status_col).setValue("YES");
785 | }
786 | }
787 |
788 | }
789 | */
790 |
--------------------------------------------------------------------------------
/rsa/crypto-1.1.gs:
--------------------------------------------------------------------------------
1 | /*! crypto-1.1.5.js (c) 2013 Kenji Urushima | kjur.github.com/jsrsasign/license
2 | */
3 | /*
4 | * crypto.js - Cryptographic Algorithm Provider class
5 | *
6 | * Copyright (c) 2013 Kenji Urushima (kenji.urushima@gmail.com)
7 | *
8 | * This software is licensed under the terms of the MIT License.
9 | * http://kjur.github.com/jsrsasign/license
10 | *
11 | * The above copyright and license notice shall be
12 | * included in all copies or substantial portions of the Software.
13 | */
14 |
15 | /**
16 | * @fileOverview
17 | * @name crypto-1.1.js
18 | * @author Kenji Urushima kenji.urushima@gmail.com
19 | * @version 1.1.5 (2013-Oct-06)
20 | * @since jsrsasign 2.2
21 | * @license MIT License
22 | */
23 |
24 | /**
25 | * kjur's class library name space
26 | * @name KJUR
27 | * @namespace kjur's class library name space
28 | */
29 | if (typeof KJUR == "undefined" || !KJUR) KJUR = {};
30 | /**
31 | * kjur's cryptographic algorithm provider library name space
32 | *
33 | * This namespace privides following crytpgrahic classes.
34 | *
35 | * - {@link KJUR.crypto.MessageDigest} - Java JCE(cryptograhic extension) style MessageDigest class
36 | * - {@link KJUR.crypto.Signature} - Java JCE(cryptograhic extension) style Signature class
37 | * - {@link KJUR.crypto.Util} - cryptographic utility functions and properties
38 | *
39 | * NOTE: Please ignore method summary and document of this namespace. This caused by a bug of jsdoc2.
40 | *
41 | * @name KJUR.crypto
42 | * @namespace
43 | */
44 | if (typeof KJUR.crypto == "undefined" || !KJUR.crypto) KJUR.crypto = {};
45 |
46 | /**
47 | * static object for cryptographic function utilities
48 | * @name KJUR.crypto.Util
49 | * @class static object for cryptographic function utilities
50 | * @property {Array} DIGESTINFOHEAD PKCS#1 DigestInfo heading hexadecimal bytes for each hash algorithms
51 | * @property {Array} DEFAULTPROVIDER associative array of default provider name for each hash and signature algorithms
52 | * @description
53 | */
54 | KJUR.crypto.Util = new function() {
55 | this.DIGESTINFOHEAD = {
56 | 'sha1': "3021300906052b0e03021a05000414",
57 | 'sha224': "302d300d06096086480165030402040500041c",
58 | 'sha256': "3031300d060960864801650304020105000420",
59 | 'sha384': "3041300d060960864801650304020205000430",
60 | 'sha512': "3051300d060960864801650304020305000440",
61 | 'md2': "3020300c06082a864886f70d020205000410",
62 | 'md5': "3020300c06082a864886f70d020505000410",
63 | 'ripemd160': "3021300906052b2403020105000414",
64 | };
65 |
66 | /*
67 | * @since crypto 1.1.1
68 | */
69 | this.DEFAULTPROVIDER = {
70 | 'md5': 'cryptojs',
71 | 'sha1': 'cryptojs',
72 | 'sha224': 'cryptojs',
73 | 'sha256': 'cryptojs',
74 | 'sha384': 'cryptojs',
75 | 'sha512': 'cryptojs',
76 | 'ripemd160': 'cryptojs',
77 | 'hmacmd5': 'cryptojs',
78 | 'hmacsha1': 'cryptojs',
79 | 'hmacsha224': 'cryptojs',
80 | 'hmacsha256': 'cryptojs',
81 | 'hmacsha384': 'cryptojs',
82 | 'hmacsha512': 'cryptojs',
83 | 'hmacripemd160': 'cryptojs',
84 |
85 | 'MD5withRSA': 'cryptojs/jsrsa',
86 | 'SHA1withRSA': 'cryptojs/jsrsa',
87 | 'SHA224withRSA': 'cryptojs/jsrsa',
88 | 'SHA256withRSA': 'cryptojs/jsrsa',
89 | 'SHA384withRSA': 'cryptojs/jsrsa',
90 | 'SHA512withRSA': 'cryptojs/jsrsa',
91 | 'RIPEMD160withRSA': 'cryptojs/jsrsa',
92 |
93 | 'MD5withECDSA': 'cryptojs/jsrsa',
94 | 'SHA1withECDSA': 'cryptojs/jsrsa',
95 | 'SHA224withECDSA': 'cryptojs/jsrsa',
96 | 'SHA256withECDSA': 'cryptojs/jsrsa',
97 | 'SHA384withECDSA': 'cryptojs/jsrsa',
98 | 'SHA512withECDSA': 'cryptojs/jsrsa',
99 | 'RIPEMD160withECDSA': 'cryptojs/jsrsa',
100 |
101 | 'SHA1withDSA': 'cryptojs/jsrsa',
102 | 'SHA224withDSA': 'cryptojs/jsrsa',
103 | 'SHA256withDSA': 'cryptojs/jsrsa',
104 |
105 | 'MD5withRSAandMGF1': 'cryptojs/jsrsa',
106 | 'SHA1withRSAandMGF1': 'cryptojs/jsrsa',
107 | 'SHA224withRSAandMGF1': 'cryptojs/jsrsa',
108 | 'SHA256withRSAandMGF1': 'cryptojs/jsrsa',
109 | 'SHA384withRSAandMGF1': 'cryptojs/jsrsa',
110 | 'SHA512withRSAandMGF1': 'cryptojs/jsrsa',
111 | 'RIPEMD160withRSAandMGF1': 'cryptojs/jsrsa',
112 | };
113 |
114 | /*
115 | * @since crypto 1.1.2
116 | */
117 | this.CRYPTOJSMESSAGEDIGESTNAME = {
118 | 'md5': 'CryptoJS.algo.MD5',
119 | 'sha1': 'CryptoJS.algo.SHA1',
120 | 'sha224': 'CryptoJS.algo.SHA224',
121 | 'sha256': 'CryptoJS.algo.SHA256',
122 | 'sha384': 'CryptoJS.algo.SHA384',
123 | 'sha512': 'CryptoJS.algo.SHA512',
124 | 'ripemd160': 'CryptoJS.algo.RIPEMD160'
125 | };
126 |
127 | /**
128 | * get hexadecimal DigestInfo
129 | * @name getDigestInfoHex
130 | * @memberOf KJUR.crypto.Util
131 | * @function
132 | * @param {String} hHash hexadecimal hash value
133 | * @param {String} alg hash algorithm name (ex. 'sha1')
134 | * @return {String} hexadecimal string DigestInfo ASN.1 structure
135 | */
136 | this.getDigestInfoHex = function(hHash, alg) {
137 | if (typeof this.DIGESTINFOHEAD[alg] == "undefined")
138 | throw "alg not supported in Util.DIGESTINFOHEAD: " + alg;
139 | return this.DIGESTINFOHEAD[alg] + hHash;
140 | };
141 |
142 | /**
143 | * get PKCS#1 padded hexadecimal DigestInfo
144 | * @name getPaddedDigestInfoHex
145 | * @memberOf KJUR.crypto.Util
146 | * @function
147 | * @param {String} hHash hexadecimal hash value of message to be signed
148 | * @param {String} alg hash algorithm name (ex. 'sha1')
149 | * @param {Integer} keySize key bit length (ex. 1024)
150 | * @return {String} hexadecimal string of PKCS#1 padded DigestInfo
151 | */
152 | this.getPaddedDigestInfoHex = function(hHash, alg, keySize) {
153 | var hDigestInfo = this.getDigestInfoHex(hHash, alg);
154 | var pmStrLen = keySize / 4; // minimum PM length
155 |
156 | if (hDigestInfo.length + 22 > pmStrLen) // len(0001+ff(*8)+00+hDigestInfo)=22
157 | throw "key is too short for SigAlg: keylen=" + keySize + "," + alg;
158 |
159 | var hHead = "0001";
160 | var hTail = "00" + hDigestInfo;
161 | var hMid = "";
162 | var fLen = pmStrLen - hHead.length - hTail.length;
163 | for (var i = 0; i < fLen; i += 2) {
164 | hMid += "ff";
165 | }
166 | var hPaddedMessage = hHead + hMid + hTail;
167 | return hPaddedMessage;
168 | };
169 |
170 | /**
171 | * get hexadecimal hash of string with specified algorithm
172 | * @name hashString
173 | * @memberOf KJUR.crypto.Util
174 | * @function
175 | * @param {String} s input string to be hashed
176 | * @param {String} alg hash algorithm name
177 | * @return {String} hexadecimal string of hash value
178 | * @since 1.1.1
179 | */
180 | this.hashString = function(s, alg) {
181 | var md = new KJUR.crypto.MessageDigest({'alg': alg});
182 | return md.digestString(s);
183 | };
184 |
185 | /**
186 | * get hexadecimal hash of hexadecimal string with specified algorithm
187 | * @name hashHex
188 | * @memberOf KJUR.crypto.Util
189 | * @function
190 | * @param {String} sHex input hexadecimal string to be hashed
191 | * @param {String} alg hash algorithm name
192 | * @return {String} hexadecimal string of hash value
193 | * @since 1.1.1
194 | */
195 | this.hashHex = function(sHex, alg) {
196 | var md = new KJUR.crypto.MessageDigest({'alg': alg});
197 | return md.digestHex(sHex);
198 | };
199 |
200 | /**
201 | * get hexadecimal SHA1 hash of string
202 | * @name sha1
203 | * @memberOf KJUR.crypto.Util
204 | * @function
205 | * @param {String} s input string to be hashed
206 | * @return {String} hexadecimal string of hash value
207 | * @since 1.0.3
208 | */
209 | this.sha1 = function(s) {
210 | var md = new KJUR.crypto.MessageDigest({'alg':'sha1', 'prov':'cryptojs'});
211 | return md.digestString(s);
212 | };
213 |
214 | /**
215 | * get hexadecimal SHA256 hash of string
216 | * @name sha256
217 | * @memberOf KJUR.crypto.Util
218 | * @function
219 | * @param {String} s input string to be hashed
220 | * @return {String} hexadecimal string of hash value
221 | * @since 1.0.3
222 | */
223 | this.sha256 = function(s) {
224 | var md = new KJUR.crypto.MessageDigest({'alg':'sha256', 'prov':'cryptojs'});
225 | return md.digestString(s);
226 | };
227 |
228 | this.sha256Hex = function(s) {
229 | var md = new KJUR.crypto.MessageDigest({'alg':'sha256', 'prov':'cryptojs'});
230 | return md.digestHex(s);
231 | };
232 |
233 | /**
234 | * get hexadecimal SHA512 hash of string
235 | * @name sha512
236 | * @memberOf KJUR.crypto.Util
237 | * @function
238 | * @param {String} s input string to be hashed
239 | * @return {String} hexadecimal string of hash value
240 | * @since 1.0.3
241 | */
242 | this.sha512 = function(s) {
243 | var md = new KJUR.crypto.MessageDigest({'alg':'sha512', 'prov':'cryptojs'});
244 | return md.digestString(s);
245 | };
246 |
247 | this.sha512Hex = function(s) {
248 | var md = new KJUR.crypto.MessageDigest({'alg':'sha512', 'prov':'cryptojs'});
249 | return md.digestHex(s);
250 | };
251 |
252 | /**
253 | * get hexadecimal MD5 hash of string
254 | * @name md5
255 | * @memberOf KJUR.crypto.Util
256 | * @function
257 | * @param {String} s input string to be hashed
258 | * @return {String} hexadecimal string of hash value
259 | * @since 1.0.3
260 | */
261 | this.md5 = function(s) {
262 | var md = new KJUR.crypto.MessageDigest({'alg':'md5', 'prov':'cryptojs'});
263 | return md.digestString(s);
264 | };
265 |
266 | /**
267 | * get hexadecimal RIPEMD160 hash of string
268 | * @name ripemd160
269 | * @memberOf KJUR.crypto.Util
270 | * @function
271 | * @param {String} s input string to be hashed
272 | * @return {String} hexadecimal string of hash value
273 | * @since 1.0.3
274 | */
275 | this.ripemd160 = function(s) {
276 | var md = new KJUR.crypto.MessageDigest({'alg':'ripemd160', 'prov':'cryptojs'});
277 | return md.digestString(s);
278 | };
279 |
280 | /*
281 | * @since 1.1.2
282 | */
283 | this.getCryptoJSMDByName = function(s) {
284 |
285 | };
286 | };
287 |
288 | /**
289 | * MessageDigest class which is very similar to java.security.MessageDigest class
290 | * @name KJUR.crypto.MessageDigest
291 | * @class MessageDigest class which is very similar to java.security.MessageDigest class
292 | * @param {Array} params parameters for constructor
293 | * @description
294 | *
295 | * Currently this supports following algorithm and providers combination:
296 | *
297 | * - md5 - cryptojs
298 | * - sha1 - cryptojs
299 | * - sha224 - cryptojs
300 | * - sha256 - cryptojs
301 | * - sha384 - cryptojs
302 | * - sha512 - cryptojs
303 | * - ripemd160 - cryptojs
304 | * - sha256 - sjcl (NEW from crypto.js 1.0.4)
305 | *
306 | * @example
307 | * // CryptoJS provider sample
308 | * <script src="http://crypto-js.googlecode.com/svn/tags/3.1.2/build/components/core.js"></script>
309 | * <script src="http://crypto-js.googlecode.com/svn/tags/3.1.2/build/components/sha1.js"></script>
310 | * <script src="crypto-1.0.js"></script>
311 | * var md = new KJUR.crypto.MessageDigest({alg: "sha1", prov: "cryptojs"});
312 | * md.updateString('aaa')
313 | * var mdHex = md.digest()
314 | *
315 | * // SJCL(Stanford JavaScript Crypto Library) provider sample
316 | * <script src="http://bitwiseshiftleft.github.io/sjcl/sjcl.js"></script>
317 | * <script src="crypto-1.0.js"></script>
318 | * var md = new KJUR.crypto.MessageDigest({alg: "sha256", prov: "sjcl"}); // sjcl supports sha256 only
319 | * md.updateString('aaa')
320 | * var mdHex = md.digest()
321 | */
322 | KJUR.crypto.MessageDigest = function(params) {
323 | var md = null;
324 | var algName = null;
325 | var provName = null;
326 |
327 | /**
328 | * set hash algorithm and provider
329 | * @name setAlgAndProvider
330 | * @memberOf KJUR.crypto.MessageDigest
331 | * @function
332 | * @param {String} alg hash algorithm name
333 | * @param {String} prov provider name
334 | * @description
335 | * @example
336 | * // for SHA1
337 | * md.setAlgAndProvider('sha1', 'cryptojs');
338 | * // for RIPEMD160
339 | * md.setAlgAndProvider('ripemd160', 'cryptojs');
340 | */
341 | this.setAlgAndProvider = function(alg, prov) {
342 | if (alg != null && prov === undefined) prov = KJUR.crypto.Util.DEFAULTPROVIDER[alg];
343 |
344 | // for cryptojs
345 | if (':md5:sha1:sha224:sha256:sha384:sha512:ripemd160:'.indexOf(alg) != -1 &&
346 | prov == 'cryptojs') {
347 | try {
348 | this.md = eval(KJUR.crypto.Util.CRYPTOJSMESSAGEDIGESTNAME[alg]).create();
349 | } catch (ex) {
350 | throw "setAlgAndProvider hash alg set fail alg=" + alg + "/" + ex;
351 | }
352 | this.updateString = function(str) {
353 | this.md.update(str);
354 | };
355 | this.updateHex = function(hex) {
356 | var wHex = CryptoJS.enc.Hex.parse(hex);
357 | this.md.update(wHex);
358 | };
359 | this.digest = function() {
360 | var hash = this.md.finalize();
361 | return hash.toString(CryptoJS.enc.Hex);
362 | };
363 | this.digestString = function(str) {
364 | this.updateString(str);
365 | return this.digest();
366 | };
367 | this.digestHex = function(hex) {
368 | this.updateHex(hex);
369 | return this.digest();
370 | };
371 | }
372 | if (':sha256:'.indexOf(alg) != -1 &&
373 | prov == 'sjcl') {
374 | try {
375 | this.md = new sjcl.hash.sha256();
376 | } catch (ex) {
377 | throw "setAlgAndProvider hash alg set fail alg=" + alg + "/" + ex;
378 | }
379 | this.updateString = function(str) {
380 | this.md.update(str);
381 | };
382 | this.updateHex = function(hex) {
383 | var baHex = sjcl.codec.hex.toBits(hex);
384 | this.md.update(baHex);
385 | };
386 | this.digest = function() {
387 | var hash = this.md.finalize();
388 | return sjcl.codec.hex.fromBits(hash);
389 | };
390 | this.digestString = function(str) {
391 | this.updateString(str);
392 | return this.digest();
393 | };
394 | this.digestHex = function(hex) {
395 | this.updateHex(hex);
396 | return this.digest();
397 | };
398 | }
399 | };
400 |
401 | /**
402 | * update digest by specified string
403 | * @name updateString
404 | * @memberOf KJUR.crypto.MessageDigest
405 | * @function
406 | * @param {String} str string to update
407 | * @description
408 | * @example
409 | * md.updateString('New York');
410 | */
411 | this.updateString = function(str) {
412 | throw "updateString(str) not supported for this alg/prov: " + this.algName + "/" + this.provName;
413 | };
414 |
415 | /**
416 | * update digest by specified hexadecimal string
417 | * @name updateHex
418 | * @memberOf KJUR.crypto.MessageDigest
419 | * @function
420 | * @param {String} hex hexadecimal string to update
421 | * @description
422 | * @example
423 | * md.updateHex('0afe36');
424 | */
425 | this.updateHex = function(hex) {
426 | throw "updateHex(hex) not supported for this alg/prov: " + this.algName + "/" + this.provName;
427 | };
428 |
429 | /**
430 | * completes hash calculation and returns hash result
431 | * @name digest
432 | * @memberOf KJUR.crypto.MessageDigest
433 | * @function
434 | * @description
435 | * @example
436 | * md.digest()
437 | */
438 | this.digest = function() {
439 | throw "digest() not supported for this alg/prov: " + this.algName + "/" + this.provName;
440 | };
441 |
442 | /**
443 | * performs final update on the digest using string, then completes the digest computation
444 | * @name digestString
445 | * @memberOf KJUR.crypto.MessageDigest
446 | * @function
447 | * @param {String} str string to final update
448 | * @description
449 | * @example
450 | * md.digestString('aaa')
451 | */
452 | this.digestString = function(str) {
453 | throw "digestString(str) not supported for this alg/prov: " + this.algName + "/" + this.provName;
454 | };
455 |
456 | /**
457 | * performs final update on the digest using hexadecimal string, then completes the digest computation
458 | * @name digestHex
459 | * @memberOf KJUR.crypto.MessageDigest
460 | * @function
461 | * @param {String} hex hexadecimal string to final update
462 | * @description
463 | * @example
464 | * md.digestHex('0f2abd')
465 | */
466 | this.digestHex = function(hex) {
467 | throw "digestHex(hex) not supported for this alg/prov: " + this.algName + "/" + this.provName;
468 | };
469 |
470 | if (params !== undefined) {
471 | if (params['alg'] !== undefined) {
472 | this.algName = params['alg'];
473 | if (params['prov'] === undefined)
474 | this.provName = KJUR.crypto.Util.DEFAULTPROVIDER[this.algName];
475 | this.setAlgAndProvider(this.algName, this.provName);
476 | }
477 | }
478 | };
479 |
480 | /**
481 | * Mac(Message Authentication Code) class which is very similar to java.security.Mac class
482 | * @name KJUR.crypto.Mac
483 | * @class Mac class which is very similar to java.security.Mac class
484 | * @param {Array} params parameters for constructor
485 | * @description
486 | *
487 | * Currently this supports following algorithm and providers combination:
488 | *
489 | * - hmacmd5 - cryptojs
490 | * - hmacsha1 - cryptojs
491 | * - hmacsha224 - cryptojs
492 | * - hmacsha256 - cryptojs
493 | * - hmacsha384 - cryptojs
494 | * - hmacsha512 - cryptojs
495 | *
496 | * NOTE: HmacSHA224 and HmacSHA384 issue was fixed since jsrsasign 4.1.4.
497 | * Please use 'ext/cryptojs-312-core-fix*.js' instead of 'core.js' of original CryptoJS
498 | * to avoid those issue.
499 | * @example
500 | * var mac = new KJUR.crypto.Mac({alg: "HmacSHA1", prov: "cryptojs", "pass": "pass"});
501 | * mac.updateString('aaa')
502 | * var macHex = md.doFinal()
503 | */
504 | KJUR.crypto.Mac = function(params) {
505 | var mac = null;
506 | var pass = null;
507 | var algName = null;
508 | var provName = null;
509 | var algProv = null;
510 |
511 | this.setAlgAndProvider = function(alg, prov) {
512 | if (alg == null) alg = "hmacsha1";
513 |
514 | alg = alg.toLowerCase();
515 | if (alg.substr(0, 4) != "hmac") {
516 | throw "setAlgAndProvider unsupported HMAC alg: " + alg;
517 | }
518 |
519 | if (prov === undefined) prov = KJUR.crypto.Util.DEFAULTPROVIDER[alg];
520 | this.algProv = alg + "/" + prov;
521 |
522 | var hashAlg = alg.substr(4);
523 |
524 | // for cryptojs
525 | if (':md5:sha1:sha224:sha256:sha384:sha512:ripemd160:'.indexOf(hashAlg) != -1 &&
526 | prov == 'cryptojs') {
527 | try {
528 | var mdObj = eval(KJUR.crypto.Util.CRYPTOJSMESSAGEDIGESTNAME[hashAlg]);
529 | this.mac = CryptoJS.algo.HMAC.create(mdObj, this.pass);
530 | } catch (ex) {
531 | throw "setAlgAndProvider hash alg set fail hashAlg=" + hashAlg + "/" + ex;
532 | }
533 | this.updateString = function(str) {
534 | this.mac.update(str);
535 | };
536 | this.updateHex = function(hex) {
537 | var wHex = CryptoJS.enc.Hex.parse(hex);
538 | this.mac.update(wHex);
539 | };
540 | this.doFinal = function() {
541 | var hash = this.mac.finalize();
542 | return hash.toString(CryptoJS.enc.Hex);
543 | };
544 | this.doFinalString = function(str) {
545 | this.updateString(str);
546 | return this.doFinal();
547 | };
548 | this.doFinalHex = function(hex) {
549 | this.updateHex(hex);
550 | return this.doFinal();
551 | };
552 | }
553 | };
554 |
555 | /**
556 | * update digest by specified string
557 | * @name updateString
558 | * @memberOf KJUR.crypto.Mac
559 | * @function
560 | * @param {String} str string to update
561 | * @description
562 | * @example
563 | * md.updateString('New York');
564 | */
565 | this.updateString = function(str) {
566 | throw "updateString(str) not supported for this alg/prov: " + this.algProv;
567 | };
568 |
569 | /**
570 | * update digest by specified hexadecimal string
571 | * @name updateHex
572 | * @memberOf KJUR.crypto.Mac
573 | * @function
574 | * @param {String} hex hexadecimal string to update
575 | * @description
576 | * @example
577 | * md.updateHex('0afe36');
578 | */
579 | this.updateHex = function(hex) {
580 | throw "updateHex(hex) not supported for this alg/prov: " + this.algProv;
581 | };
582 |
583 | /**
584 | * completes hash calculation and returns hash result
585 | * @name doFinal
586 | * @memberOf KJUR.crypto.Mac
587 | * @function
588 | * @description
589 | * @example
590 | * md.digest()
591 | */
592 | this.doFinal = function() {
593 | throw "digest() not supported for this alg/prov: " + this.algProv;
594 | };
595 |
596 | /**
597 | * performs final update on the digest using string, then completes the digest computation
598 | * @name doFinalString
599 | * @memberOf KJUR.crypto.Mac
600 | * @function
601 | * @param {String} str string to final update
602 | * @description
603 | * @example
604 | * md.digestString('aaa')
605 | */
606 | this.doFinalString = function(str) {
607 | throw "digestString(str) not supported for this alg/prov: " + this.algProv;
608 | };
609 |
610 | /**
611 | * performs final update on the digest using hexadecimal string,
612 | * then completes the digest computation
613 | * @name doFinalHex
614 | * @memberOf KJUR.crypto.Mac
615 | * @function
616 | * @param {String} hex hexadecimal string to final update
617 | * @description
618 | * @example
619 | * md.digestHex('0f2abd')
620 | */
621 | this.doFinalHex = function(hex) {
622 | throw "digestHex(hex) not supported for this alg/prov: " + this.algProv;
623 | };
624 |
625 | if (params !== undefined) {
626 | if (params['pass'] !== undefined) {
627 | this.pass = params['pass'];
628 | }
629 | if (params['alg'] !== undefined) {
630 | this.algName = params['alg'];
631 | if (params['prov'] === undefined)
632 | this.provName = KJUR.crypto.Util.DEFAULTPROVIDER[this.algName];
633 | this.setAlgAndProvider(this.algName, this.provName);
634 | }
635 | }
636 | };
637 |
638 | /**
639 | * Signature class which is very similar to java.security.Signature class
640 | * @name KJUR.crypto.Signature
641 | * @class Signature class which is very similar to java.security.Signature class
642 | * @param {Array} params parameters for constructor
643 | * @property {String} state Current state of this signature object whether 'SIGN', 'VERIFY' or null
644 | * @description
645 | *
646 | * As for params of constructor's argument, it can be specify following attributes:
647 | *
648 | * - alg - signature algorithm name (ex. {MD5,SHA1,SHA224,SHA256,SHA384,SHA512,RIPEMD160}with{RSA,ECDSA,DSA})
649 | * - provider - currently 'cryptojs/jsrsa' only
650 | *
651 | * SUPPORTED ALGORITHMS AND PROVIDERS
652 | * This Signature class supports following signature algorithm and provider names:
653 | *
654 | * - MD5withRSA - cryptojs/jsrsa
655 | * - SHA1withRSA - cryptojs/jsrsa
656 | * - SHA224withRSA - cryptojs/jsrsa
657 | * - SHA256withRSA - cryptojs/jsrsa
658 | * - SHA384withRSA - cryptojs/jsrsa
659 | * - SHA512withRSA - cryptojs/jsrsa
660 | * - RIPEMD160withRSA - cryptojs/jsrsa
661 | * - MD5withECDSA - cryptojs/jsrsa
662 | * - SHA1withECDSA - cryptojs/jsrsa
663 | * - SHA224withECDSA - cryptojs/jsrsa
664 | * - SHA256withECDSA - cryptojs/jsrsa
665 | * - SHA384withECDSA - cryptojs/jsrsa
666 | * - SHA512withECDSA - cryptojs/jsrsa
667 | * - RIPEMD160withECDSA - cryptojs/jsrsa
668 | * - MD5withRSAandMGF1 - cryptojs/jsrsa
669 | * - SHA1withRSAandMGF1 - cryptojs/jsrsa
670 | * - SHA224withRSAandMGF1 - cryptojs/jsrsa
671 | * - SHA256withRSAandMGF1 - cryptojs/jsrsa
672 | * - SHA384withRSAandMGF1 - cryptojs/jsrsa
673 | * - SHA512withRSAandMGF1 - cryptojs/jsrsa
674 | * - RIPEMD160withRSAandMGF1 - cryptojs/jsrsa
675 | * - SHA1withDSA - cryptojs/jsrsa
676 | * - SHA224withDSA - cryptojs/jsrsa
677 | * - SHA256withDSA - cryptojs/jsrsa
678 | *
679 | * Here are supported elliptic cryptographic curve names and their aliases for ECDSA:
680 | *
681 | * - secp256k1
682 | * - secp256r1, NIST P-256, P-256, prime256v1
683 | * - secp384r1, NIST P-384, P-384
684 | *
685 | * NOTE1: DSA signing algorithm is also supported since crypto 1.1.5.
686 | * EXAMPLES
687 | * @example
688 | * // RSA signature generation
689 | * var sig = new KJUR.crypto.Signature({"alg": "SHA1withRSA"});
690 | * sig.init(prvKeyPEM);
691 | * sig.updateString('aaa');
692 | * var hSigVal = sig.sign();
693 | *
694 | * // DSA signature validation
695 | * var sig2 = new KJUR.crypto.Signature({"alg": "SHA1withDSA"});
696 | * sig2.init(certPEM);
697 | * sig.updateString('aaa');
698 | * var isValid = sig2.verify(hSigVal);
699 | *
700 | * // ECDSA signing
701 | * var sig = new KJUR.crypto.Signature({'alg':'SHA1withECDSA'});
702 | * sig.init(prvKeyPEM);
703 | * sig.updateString('aaa');
704 | * var sigValueHex = sig.sign();
705 | *
706 | * // ECDSA verifying
707 | * var sig2 = new KJUR.crypto.Signature({'alg':'SHA1withECDSA'});
708 | * sig.init(certPEM);
709 | * sig.updateString('aaa');
710 | * var isValid = sig.verify(sigValueHex);
711 | */
712 | KJUR.crypto.Signature = function(params) {
713 | var prvKey = null; // RSAKey/KJUR.crypto.{ECDSA,DSA} object for signing
714 | var pubKey = null; // RSAKey/KJUR.crypto.{ECDSA,DSA} object for verifying
715 |
716 | var md = null; // KJUR.crypto.MessageDigest object
717 | var sig = null;
718 | var algName = null;
719 | var provName = null;
720 | var algProvName = null;
721 | var mdAlgName = null;
722 | var pubkeyAlgName = null; // rsa,ecdsa,rsaandmgf1(=rsapss)
723 | var state = null;
724 | var pssSaltLen = -1;
725 | var initParams = null;
726 |
727 | var sHashHex = null; // hex hash value for hex
728 | var hDigestInfo = null;
729 | var hPaddedDigestInfo = null;
730 | var hSign = null;
731 |
732 | this._setAlgNames = function() {
733 | if (this.algName.match(/^(.+)with(.+)$/)) {
734 | this.mdAlgName = RegExp.$1.toLowerCase();
735 | this.pubkeyAlgName = RegExp.$2.toLowerCase();
736 | }
737 | };
738 |
739 | this._zeroPaddingOfSignature = function(hex, bitLength) {
740 | var s = "";
741 | var nZero = bitLength / 4 - hex.length;
742 | for (var i = 0; i < nZero; i++) {
743 | s = s + "0";
744 | }
745 | return s + hex;
746 | };
747 |
748 | /**
749 | * set signature algorithm and provider
750 | * @name setAlgAndProvider
751 | * @memberOf KJUR.crypto.Signature
752 | * @function
753 | * @param {String} alg signature algorithm name
754 | * @param {String} prov provider name
755 | * @description
756 | * @example
757 | * md.setAlgAndProvider('SHA1withRSA', 'cryptojs/jsrsa');
758 | */
759 | this.setAlgAndProvider = function(alg, prov) {
760 | this._setAlgNames();
761 | if (prov != 'cryptojs/jsrsa')
762 | throw "provider not supported: " + prov;
763 |
764 | if (':md5:sha1:sha224:sha256:sha384:sha512:ripemd160:'.indexOf(this.mdAlgName) != -1) {
765 | try {
766 | this.md = new KJUR.crypto.MessageDigest({'alg':this.mdAlgName});
767 | } catch (ex) {
768 | throw "setAlgAndProvider hash alg set fail alg=" +
769 | this.mdAlgName + "/" + ex;
770 | }
771 |
772 | this.init = function(keyparam, pass) {
773 | var keyObj = null;
774 | try {
775 | if (pass === undefined) {
776 | keyObj = KEYUTIL.getKey(keyparam);
777 | } else {
778 | keyObj = KEYUTIL.getKey(keyparam, pass);
779 | }
780 | } catch (ex) {
781 | throw "init failed:" + ex;
782 | }
783 |
784 | if (keyObj.isPrivate === true) {
785 | this.prvKey = keyObj;
786 | this.state = "SIGN";
787 | } else if (keyObj.isPublic === true) {
788 | this.pubKey = keyObj;
789 | this.state = "VERIFY";
790 | } else {
791 | throw "init failed.:" + keyObj;
792 | }
793 | };
794 |
795 | this.initSign = function(params) {
796 | if (typeof params['ecprvhex'] == 'string' &&
797 | typeof params['eccurvename'] == 'string') {
798 | this.ecprvhex = params['ecprvhex'];
799 | this.eccurvename = params['eccurvename'];
800 | } else {
801 | this.prvKey = params;
802 | }
803 | this.state = "SIGN";
804 | };
805 |
806 | this.initVerifyByPublicKey = function(params) {
807 | if (typeof params['ecpubhex'] == 'string' &&
808 | typeof params['eccurvename'] == 'string') {
809 | this.ecpubhex = params['ecpubhex'];
810 | this.eccurvename = params['eccurvename'];
811 | } else if (params instanceof KJUR.crypto.ECDSA) {
812 | this.pubKey = params;
813 | } else if (params instanceof RSAKey) {
814 | this.pubKey = params;
815 | }
816 | this.state = "VERIFY";
817 | };
818 |
819 | this.initVerifyByCertificatePEM = function(certPEM) {
820 | var x509 = new X509();
821 | x509.readCertPEM(certPEM);
822 | this.pubKey = x509.subjectPublicKeyRSA;
823 | this.state = "VERIFY";
824 | };
825 |
826 | this.updateString = function(str) {
827 | this.md.updateString(str);
828 | };
829 | this.updateHex = function(hex) {
830 | this.md.updateHex(hex);
831 | };
832 |
833 | this.sign = function() {
834 | this.sHashHex = this.md.digest();
835 | if (typeof this.ecprvhex != "undefined" &&
836 | typeof this.eccurvename != "undefined") {
837 | var ec = new KJUR.crypto.ECDSA({'curve': this.eccurvename});
838 | this.hSign = ec.signHex(this.sHashHex, this.ecprvhex);
839 | } else if (this.pubkeyAlgName == "rsaandmgf1") {
840 | this.hSign = this.prvKey.signWithMessageHashPSS(this.sHashHex,
841 | this.mdAlgName,
842 | this.pssSaltLen);
843 | } else if (this.pubkeyAlgName == "rsa") {
844 | this.hSign = this.prvKey.signWithMessageHash(this.sHashHex,
845 | this.mdAlgName);
846 | } else if (this.prvKey instanceof KJUR.crypto.ECDSA) {
847 | this.hSign = this.prvKey.signWithMessageHash(this.sHashHex);
848 | } else if (this.prvKey instanceof KJUR.crypto.DSA) {
849 | this.hSign = this.prvKey.signWithMessageHash(this.sHashHex);
850 | } else {
851 | throw "Signature: unsupported public key alg: " + this.pubkeyAlgName;
852 | }
853 | return this.hSign;
854 | };
855 | this.signString = function(str) {
856 | this.updateString(str);
857 | return this.sign();
858 | };
859 | this.signHex = function(hex) {
860 | this.updateHex(hex);
861 | return this.sign();
862 | };
863 | this.verify = function(hSigVal) {
864 | this.sHashHex = this.md.digest();
865 | if (typeof this.ecpubhex != "undefined" &&
866 | typeof this.eccurvename != "undefined") {
867 | var ec = new KJUR.crypto.ECDSA({curve: this.eccurvename});
868 | return ec.verifyHex(this.sHashHex, hSigVal, this.ecpubhex);
869 | } else if (this.pubkeyAlgName == "rsaandmgf1") {
870 | return this.pubKey.verifyWithMessageHashPSS(this.sHashHex, hSigVal,
871 | this.mdAlgName,
872 | this.pssSaltLen);
873 | } else if (this.pubkeyAlgName == "rsa") {
874 | return this.pubKey.verifyWithMessageHash(this.sHashHex, hSigVal);
875 | } else if (this.pubKey instanceof KJUR.crypto.ECDSA) {
876 | return this.pubKey.verifyWithMessageHash(this.sHashHex, hSigVal);
877 | } else if (this.pubKey instanceof KJUR.crypto.DSA) {
878 | return this.pubKey.verifyWithMessageHash(this.sHashHex, hSigVal);
879 | } else {
880 | throw "Signature: unsupported public key alg: " + this.pubkeyAlgName;
881 | }
882 | };
883 | }
884 | };
885 |
886 | /**
887 | * Initialize this object for signing or verifying depends on key
888 | * @name init
889 | * @memberOf KJUR.crypto.Signature
890 | * @function
891 | * @param {Object} key specifying public or private key as plain/encrypted PKCS#5/8 PEM file, certificate PEM or {@link RSAKey}, {@link KJUR.crypto.DSA} or {@link KJUR.crypto.ECDSA} object
892 | * @param {String} pass (OPTION) passcode for encrypted private key
893 | * @since crypto 1.1.3
894 | * @description
895 | * This method is very useful initialize method for Signature class since
896 | * you just specify key then this method will automatically initialize it
897 | * using {@link KEYUTIL.getKey} method.
898 | * As for 'key', following argument type are supported:
899 | * signing
900 | *
901 | * - PEM formatted PKCS#8 encrypted RSA/ECDSA private key concluding "BEGIN ENCRYPTED PRIVATE KEY"
902 | * - PEM formatted PKCS#5 encrypted RSA/DSA private key concluding "BEGIN RSA/DSA PRIVATE KEY" and ",ENCRYPTED"
903 | * - PEM formatted PKCS#8 plain RSA/ECDSA private key concluding "BEGIN PRIVATE KEY"
904 | * - PEM formatted PKCS#5 plain RSA/DSA private key concluding "BEGIN RSA/DSA PRIVATE KEY" without ",ENCRYPTED"
905 | * - RSAKey object of private key
906 | * - KJUR.crypto.ECDSA object of private key
907 | * - KJUR.crypto.DSA object of private key
908 | *
909 | * verification
910 | *
911 | * - PEM formatted PKCS#8 RSA/EC/DSA public key concluding "BEGIN PUBLIC KEY"
912 | * - PEM formatted X.509 certificate with RSA/EC/DSA public key concluding
913 | * "BEGIN CERTIFICATE", "BEGIN X509 CERTIFICATE" or "BEGIN TRUSTED CERTIFICATE".
914 | * - RSAKey object of public key
915 | * - KJUR.crypto.ECDSA object of public key
916 | * - KJUR.crypto.DSA object of public key
917 | *
918 | * @example
919 | * sig.init(sCertPEM)
920 | */
921 | this.init = function(key, pass) {
922 | throw "init(key, pass) not supported for this alg:prov=" +
923 | this.algProvName;
924 | };
925 |
926 | /**
927 | * Initialize this object for verifying with a public key
928 | * @name initVerifyByPublicKey
929 | * @memberOf KJUR.crypto.Signature
930 | * @function
931 | * @param {Object} param RSAKey object of public key or associative array for ECDSA
932 | * @since 1.0.2
933 | * @deprecated from crypto 1.1.5. please use init() method instead.
934 | * @description
935 | * Public key information will be provided as 'param' parameter and the value will be
936 | * following:
937 | *
938 | * - {@link RSAKey} object for RSA verification
939 | * - associative array for ECDSA verification
940 | * (ex.
{'ecpubhex': '041f..', 'eccurvename': 'secp256r1'})
941 | *
942 | *
943 | * @example
944 | * sig.initVerifyByPublicKey(rsaPrvKey)
945 | */
946 | this.initVerifyByPublicKey = function(rsaPubKey) {
947 | throw "initVerifyByPublicKey(rsaPubKeyy) not supported for this alg:prov=" +
948 | this.algProvName;
949 | };
950 |
951 | /**
952 | * Initialize this object for verifying with a certficate
953 | * @name initVerifyByCertificatePEM
954 | * @memberOf KJUR.crypto.Signature
955 | * @function
956 | * @param {String} certPEM PEM formatted string of certificate
957 | * @since 1.0.2
958 | * @deprecated from crypto 1.1.5. please use init() method instead.
959 | * @description
960 | * @example
961 | * sig.initVerifyByCertificatePEM(certPEM)
962 | */
963 | this.initVerifyByCertificatePEM = function(certPEM) {
964 | throw "initVerifyByCertificatePEM(certPEM) not supported for this alg:prov=" +
965 | this.algProvName;
966 | };
967 |
968 | /**
969 | * Initialize this object for signing
970 | * @name initSign
971 | * @memberOf KJUR.crypto.Signature
972 | * @function
973 | * @param {Object} param RSAKey object of public key or associative array for ECDSA
974 | * @deprecated from crypto 1.1.5. please use init() method instead.
975 | * @description
976 | * Private key information will be provided as 'param' parameter and the value will be
977 | * following:
978 | *
979 | * - {@link RSAKey} object for RSA signing
980 | * - associative array for ECDSA signing
981 | * (ex.
{'ecprvhex': '1d3f..', 'eccurvename': 'secp256r1'})
982 | *
983 | * @example
984 | * sig.initSign(prvKey)
985 | */
986 | this.initSign = function(prvKey) {
987 | throw "initSign(prvKey) not supported for this alg:prov=" + this.algProvName;
988 | };
989 |
990 | /**
991 | * Updates the data to be signed or verified by a string
992 | * @name updateString
993 | * @memberOf KJUR.crypto.Signature
994 | * @function
995 | * @param {String} str string to use for the update
996 | * @description
997 | * @example
998 | * sig.updateString('aaa')
999 | */
1000 | this.updateString = function(str) {
1001 | throw "updateString(str) not supported for this alg:prov=" + this.algProvName;
1002 | };
1003 |
1004 | /**
1005 | * Updates the data to be signed or verified by a hexadecimal string
1006 | * @name updateHex
1007 | * @memberOf KJUR.crypto.Signature
1008 | * @function
1009 | * @param {String} hex hexadecimal string to use for the update
1010 | * @description
1011 | * @example
1012 | * sig.updateHex('1f2f3f')
1013 | */
1014 | this.updateHex = function(hex) {
1015 | throw "updateHex(hex) not supported for this alg:prov=" + this.algProvName;
1016 | };
1017 |
1018 | /**
1019 | * Returns the signature bytes of all data updates as a hexadecimal string
1020 | * @name sign
1021 | * @memberOf KJUR.crypto.Signature
1022 | * @function
1023 | * @return the signature bytes as a hexadecimal string
1024 | * @description
1025 | * @example
1026 | * var hSigValue = sig.sign()
1027 | */
1028 | this.sign = function() {
1029 | throw "sign() not supported for this alg:prov=" + this.algProvName;
1030 | };
1031 |
1032 | /**
1033 | * performs final update on the sign using string, then returns the signature bytes of all data updates as a hexadecimal string
1034 | * @name signString
1035 | * @memberOf KJUR.crypto.Signature
1036 | * @function
1037 | * @param {String} str string to final update
1038 | * @return the signature bytes of a hexadecimal string
1039 | * @description
1040 | * @example
1041 | * var hSigValue = sig.signString('aaa')
1042 | */
1043 | this.signString = function(str) {
1044 | throw "digestString(str) not supported for this alg:prov=" + this.algProvName;
1045 | };
1046 |
1047 | /**
1048 | * performs final update on the sign using hexadecimal string, then returns the signature bytes of all data updates as a hexadecimal string
1049 | * @name signHex
1050 | * @memberOf KJUR.crypto.Signature
1051 | * @function
1052 | * @param {String} hex hexadecimal string to final update
1053 | * @return the signature bytes of a hexadecimal string
1054 | * @description
1055 | * @example
1056 | * var hSigValue = sig.signHex('1fdc33')
1057 | */
1058 | this.signHex = function(hex) {
1059 | throw "digestHex(hex) not supported for this alg:prov=" + this.algProvName;
1060 | };
1061 |
1062 | /**
1063 | * verifies the passed-in signature.
1064 | * @name verify
1065 | * @memberOf KJUR.crypto.Signature
1066 | * @function
1067 | * @param {String} str string to final update
1068 | * @return {Boolean} true if the signature was verified, otherwise false
1069 | * @description
1070 | * @example
1071 | * var isValid = sig.verify('1fbcefdca4823a7(snip)')
1072 | */
1073 | this.verify = function(hSigVal) {
1074 | throw "verify(hSigVal) not supported for this alg:prov=" + this.algProvName;
1075 | };
1076 |
1077 | this.initParams = params;
1078 |
1079 | if (params !== undefined) {
1080 | if (params['alg'] !== undefined) {
1081 | this.algName = params['alg'];
1082 | if (params['prov'] === undefined) {
1083 | this.provName = KJUR.crypto.Util.DEFAULTPROVIDER[this.algName];
1084 | } else {
1085 | this.provName = params['prov'];
1086 | }
1087 | this.algProvName = this.algName + ":" + this.provName;
1088 | this.setAlgAndProvider(this.algName, this.provName);
1089 | this._setAlgNames();
1090 | }
1091 |
1092 | if (params['psssaltlen'] !== undefined) this.pssSaltLen = params['psssaltlen'];
1093 |
1094 | if (params['prvkeypem'] !== undefined) {
1095 | if (params['prvkeypas'] !== undefined) {
1096 | throw "both prvkeypem and prvkeypas parameters not supported";
1097 | } else {
1098 | try {
1099 | var prvKey = new RSAKey();
1100 | prvKey.readPrivateKeyFromPEMString(params['prvkeypem']);
1101 | this.initSign(prvKey);
1102 | } catch (ex) {
1103 | throw "fatal error to load pem private key: " + ex;
1104 | }
1105 | }
1106 | }
1107 | }
1108 | };
1109 |
1110 | /**
1111 | * static object for cryptographic function utilities
1112 | * @name KJUR.crypto.OID
1113 | * @class static object for cryptography related OIDs
1114 | * @property {Array} oidhex2name key value of hexadecimal OID and its name
1115 | * (ex. '2a8648ce3d030107' and 'secp256r1')
1116 | * @since crypto 1.1.3
1117 | * @description
1118 | */
1119 |
1120 |
1121 | KJUR.crypto.OID = new function() {
1122 | this.oidhex2name = {
1123 | '2a864886f70d010101': 'rsaEncryption',
1124 | '2a8648ce3d0201': 'ecPublicKey',
1125 | '2a8648ce380401': 'dsa',
1126 | '2a8648ce3d030107': 'secp256r1',
1127 | '2b8104001f': 'secp192k1',
1128 | '2b81040021': 'secp224r1',
1129 | '2b8104000a': 'secp256k1',
1130 | '2b81040023': 'secp521r1',
1131 | '2b81040022': 'secp384r1',
1132 | '2a8648ce380403': 'SHA1withDSA', // 1.2.840.10040.4.3
1133 | '608648016503040301': 'SHA224withDSA', // 2.16.840.1.101.3.4.3.1
1134 | '608648016503040302': 'SHA256withDSA', // 2.16.840.1.101.3.4.3.2
1135 | };
1136 | };
1137 |
--------------------------------------------------------------------------------