1 files changed, 10 insertions, 13 deletions

diff --git a/frontend/gamma/js/Clipperz/Crypto/BigInt.js b/frontend/gamma/js/Clipperz/Crypto/BigInt.js
index 41483a3..031ed30 100644
--- a/frontend/gamma/js/Clipperz/Crypto/BigInt.js
+++ b/frontend/gamma/js/Clipperz/Crypto/BigInt.js
@@ -1,118 +1,116 @@
 /*
 
-Copyright 2008-2011 Clipperz Srl
+Copyright 2008-2013 Clipperz Srl
 
-This file is part of Clipperz Community Edition.
-Clipperz Community Edition is an online password manager.
+This file is part of Clipperz, the online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
-* Clipperz Community Edition is free software: you can redistribute
-  it and/or modify it under the terms of the GNU Affero General Public
-  License as published by the Free Software Foundation, either version
-  3 of the License, or (at your option) any later version.
+* Clipperz is free software: you can redistribute it and/or modify it
+  under the terms of the GNU Affero General Public License as published
+  by the Free Software Foundation, either version 3 of the License, or 
+  (at your option) any later version.
 
-* Clipperz Community Edition is distributed in the hope that it will
-  be useful, but WITHOUT ANY WARRANTY; without even the implied
-  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+* Clipperz is distributed in the hope that it will be useful, but 
+  WITHOUT ANY WARRANTY; without even the implied warranty of 
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
-  License along with Clipperz Community Edition.  If not, see
-  <http://www.gnu.org/licenses/>.
+  License along with Clipperz. If not, see http://www.gnu.org/licenses/.
 
 */
 
 if (typeof(Clipperz) == 'undefined') { Clipperz = {}; }
 if (typeof(Clipperz.Crypto) == 'undefined') { Clipperz.Crypto = {}; }
 
 //#############################################################################
         //Downloaded on March 05, 2007 from http://www.leemon.com/crypto/BigInt.js
 //#############################################################################
 
 
 ////////////////////////////////////////////////////////////////////////////////////////
 // Big Integer Library v. 5.0
 // Created 2000, last modified 2006
 // Leemon Baird
 // www.leemon.com
 //
 // This file is public domain.   You can use it for any purpose without restriction.
 // I do not guarantee that it is correct, so use it at your own risk.  If you use 
 // it for something interesting, I'd appreciate hearing about it.  If you find 
 // any bugs or make any improvements, I'd appreciate hearing about those too.
 // It would also be nice if my name and address were left in the comments.
 // But none of that is required.
 //
 // This code defines a bigInt library for arbitrary-precision integers.
 // A bigInt is an array of integers storing the value in chunks of bpe bits, 
 // little endian (buff[0] is the least significant word).
 // Negative bigInts are stored two's complement.
 // Some functions assume their parameters have at least one leading zero element.
 // Functions with an underscore at the end of the name have unpredictable behavior in case of overflow, 
 // so the caller must make sure overflow won't happen.
 // For each function where a parameter is modified, that same 
 // variable must not be used as another argument too.
 // So, you cannot square x by doing multMod_(x,x,n).  
 // You must use squareMod_(x,n) instead, or do y=dup(x); multMod_(x,y,n).
 //
 // These functions are designed to avoid frequent dynamic memory allocation in the inner loop.
 // For most functions, if it needs a BigInt as a local variable it will actually use
 // a global, and will only allocate to it when it's not the right size.  This ensures
 // that when a function is called repeatedly with same-sized parameters, it only allocates
 // memory on the first call.
 //
 // Note that for cryptographic purposes, the calls to Math.random() must 
 // be replaced with calls to a better pseudorandom number generator.
 //
 // In the following, "bigInt" means a bigInt with at least one leading zero element,
 // and "integer" means a nonnegative integer less than radix.  In some cases, integer 
 // can be negative.  Negative bigInts are 2s complement.
 // 
 // The following functions do not modify their inputs, but dynamically allocate memory every time they are called:
 // 
 // function bigInt2str(x,base)     //convert a bigInt into a string in a given base, from base 2 up to base 95
 // function dup(x)                 //returns a copy of bigInt x
 // function findPrimes(n)          //return array of all primes less than integer n
 // function int2bigInt(t,n,m)      //convert integer t to a bigInt with at least n bits and m array elements
 // function int2bigInt(s,b,n,m)    //convert string s in base b to a bigInt with at least n bits and m array elements
 // function trim(x,k)              //return a copy of x with exactly k leading zero elements
 //
 // The following functions do not modify their inputs, so there is never a problem with the result being too big:
 //
 // function bitSize(x)             //returns how many bits long the bigInt x is, not counting leading zeros
 // function equals(x,y)            //is the bigInt x equal to the bigint y?
 // function equalsInt(x,y)         //is bigint x equal to integer y?
 // function greater(x,y)           //is x>y?  (x and y are nonnegative bigInts)
 // function greaterShift(x,y,shift)//is (x <<(shift*bpe)) > y?
 // function isZero(x)              //is the bigInt x equal to zero?
 // function millerRabin(x,b)       //does one round of Miller-Rabin base integer b say that bigInt x is possibly prime (as opposed to definitely composite)?
 // function modInt(x,n)            //return x mod n for bigInt x and integer n.
 // function negative(x)            //is bigInt x negative?
 //
 // The following functions do not modify their inputs, but allocate memory and call functions with underscores
 //
 // function add(x,y)                //return (x+y) for bigInts x and y.  
 // function addInt(x,n)             //return (x+n) where x is a bigInt and n is an integer.
 // function expand(x,n)             //return a copy of x with at least n elements, adding leading zeros if needed
 // function inverseMod(x,n)         //return (x**(-1) mod n) for bigInts x and n.  If no inverse exists, it returns null
 // function mod(x,n)                //return a new bigInt equal to (x mod n) for bigInts x and n.
 // function mult(x,y)               //return x*y for bigInts x and y. This is faster when y<x.
 // function multMod(x,y,n)          //return (x*y mod n) for bigInts x,y,n.  For greater speed, let y<x.
 // function powMod(x,y,n)           //return (x**y mod n) where x,y,n are bigInts and ** is exponentiation.  0**0=1. Faster for odd n.
 // function randTruePrime(k)        //return a new, random, k-bit, true prime using Maurer's algorithm.
 // function sub(x,y)                //return (x-y) for bigInts x and y.  Negative answers will be 2s complement
 //
 // The following functions write a bigInt result to one of the parameters, but
 // the result is never bigger than the original, so there can't be overflow problems:
 //
 // function divInt_(x,n)            //do x=floor(x/n) for bigInt x and integer n, and return the remainder
 // function GCD_(x,y)               //set x to the greatest common divisor of bigInts x and y, (y is destroyed).
 // function halve_(x)               //do x=floor(|x|/2)*sgn(x) for bigInt x in 2's complement
 // function mod_(x,n)               //do x=x mod n for bigInts x and n.
 // function rightShift_(x,n)        //right shift bigInt x by n bits.  0 <= n < bpe.
 //
 // The following functions write a bigInt result to one of the parameters.  The caller is responsible for
 // ensuring it is large enough to hold the result.
 // 
 // function addInt_(x,n)            //do x=x+n where x is a bigInt and n is an integer
@@ -1384,193 +1382,192 @@ function mont_(x,y,n,np) {
     }    
     for (;j<kn;j++) { 
       c+=sa[j]+ui*n[j];
       sa[j-1]=c & mask;
       c>>=bpe;
     }    
     sa[j-1]=c & mask;
   }
 
   if (!greater(n,sa))
     sub_(sa,n);
   copy_(x,sa);
 }
 
 
 
 
 //#############################################################################
 //#############################################################################
 //#############################################################################
 //#############################################################################
 //#############################################################################
 //#############################################################################
 //#############################################################################
 
 
 
 
 
 //#############################################################################
 
 Clipperz.Crypto.BigInt = function (aValue, aBase) {
                 varbase;
                 varvalue;
         
         if (typeof(aValue) == 'object') {
                 this._internalValue = aValue;
         } else {
                 if (typeof(aValue) == 'undefined') {
                         value = "0";
                 } else {
                         value = aValue + "";
                 }
         
                 if (typeof(aBase) == 'undefined') {
                         base = 10;
                 } else {
                         base = aBase;
                 }
 
                 this._internalValue = str2bigInt(value, base, 1, 1);
         }
         
         return this;
 }
 
 //=============================================================================
 
 MochiKit.Base.update(Clipperz.Crypto.BigInt.prototype, {
 
         'clone': function() {
                 return new Clipperz.Crypto.BigInt(this.internalValue());
         },
         
         //-------------------------------------------------------------------------
 
         'internalValue': function () {
                 return this._internalValue;
         },
         
         //-------------------------------------------------------------------------
 
         'isBigInt': true,
         
         //-------------------------------------------------------------------------
 
         'toString': function(aBase) {
                 return this.asString(aBase);
         },
 
         //-------------------------------------------------------------------------
 
         'asString': function (aBase, minimumLength) {
                         varresult;
                         varbase;
 
                 if (typeof(aBase) == 'undefined') {
                         base = 10;
                 } else {
                         base = aBase;
                 }
                 
                 result = bigInt2str(this.internalValue(), base).toLowerCase();
 
                 if ((typeof(minimumLength) != 'undefined') && (result.length < minimumLength)) {
                         var i, c;
-        //MochiKit.Logging.logDebug(">>> FIXING BigInt.asString length issue")          
                         c = (minimumLength - result.length);
                         for (i=0; i<c; i++) {
                                 result = '0' + result;
                         }
                 }
                 
                 return result;
         },
 
         //-------------------------------------------------------------------------
 
         'asByteArray': function() {
                 return new Clipperz.ByteArray("0x" + this.asString(16), 16);
         },
         
         //-------------------------------------------------------------------------
 
         'equals': function (aValue) {
                 var result;
                 
                 if (aValue.isBigInt) {
                          result = equals(this.internalValue(), aValue.internalValue());
                 } else if (typeof(aValue) == "number") {
                         result = equalsInt(this.internalValue(), aValue);
                 } else {
                         throw Clipperz.Crypt.BigInt.exception.UnknownType;
                 }
                 
                 return result;
         },
 
         //-------------------------------------------------------------------------
 
         'compare': function(aValue) {
 /*
                 var result;
                 var thisAsString;
                 var aValueAsString;
                 
                 thisAsString = this.asString(10);
                 aValueAsString = aValue.asString(10);
                 
                 result = MochiKit.Base.compare(thisAsString.length, aValueAsString.length);
                 if (result == 0) {
                         result = MochiKit.Base.compare(thisAsString, aValueAsString);
                 }
                 
                 return result;
 */
                 var result;
                 
                 if (equals(this.internalValue(), aValue.internalValue())) {
                         result = 0;
                 } else if (greater(this.internalValue(), aValue.internalValue())) {
                         result = 1;
                 } else {
                         result = -1;
                 }
                 
                 return result;
         },
         
         //-------------------------------------------------------------------------
 
         'add': function (aValue) {
                 var result;
 
                 if (aValue.isBigInt) {
                          result = add(this.internalValue(), aValue.internalValue());
                 } else {
                         result = addInt(this.internalValue(), aValue);
                 }
                 
                 return new Clipperz.Crypto.BigInt(result);
         },
         
         //-------------------------------------------------------------------------
 
         'subtract': function (aValue) {
                 var result;
                 var value;
 
                 if (aValue.isBigInt) {
                         value = aValue;
                 } else {
                         value = new Clipperz.Crypto.BigInt(aValue);
                 }
 
                  result = sub(this.internalValue(), value.internalValue());
 
                 return new Clipperz.Crypto.BigInt(result);
         },
         
         //-------------------------------------------------------------------------
 
         'multiply': function (aValue, aModule) {