5 files changed, 61 insertions, 125 deletions

diff --git a/frontend/gamma/js/Clipperz/Crypto/ECC/BinaryField/Curve.js b/frontend/gamma/js/Clipperz/Crypto/ECC/BinaryField/Curve.js
index 19f19c2..0d76b9c 100644
--- a/frontend/gamma/js/Clipperz/Crypto/ECC/BinaryField/Curve.js
+++ b/frontend/gamma/js/Clipperz/Crypto/ECC/BinaryField/Curve.js
@@ -1,378 +1,336 @@
 /*
 
-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/.
 
 */
 
 //try { if (typeof(Clipperz.ByteArray) == 'undefined') { throw ""; }} catch (e) {
         //throw "Clipperz.Crypto.ECC depends on Clipperz.ByteArray!";
 //}  
 if (typeof(Clipperz.Crypto.ECC) == 'undefined') { Clipperz.Crypto.ECC = {}; }
 if (typeof(Clipperz.Crypto.ECC.BinaryField) == 'undefined') { Clipperz.Crypto.ECC.BinaryField = {}; }
 
 Clipperz.Crypto.ECC.BinaryField.Curve = function(args) {
         args = args || {};
 
         this._modulus = args.modulus;
         
         this._a = args.a;
         this._b = args.b;
         this._G = args.G;
         this._r = args.r;
         this._h = args.h;
 
         this._finiteField = null;
         
         return this;
 }
 
 Clipperz.Crypto.ECC.BinaryField.Curve.prototype = MochiKit.Base.update(null, {
 
         'asString': function() {
                 return "Clipperz.Crypto.ECC.BinaryField.Curve";
         },
 
         //-----------------------------------------------------------------------------
 
         'modulus': function() {
                 return this._modulus;
         },
         
         'a': function() {
                 return this._a;
         },
         
         'b': function() {
                 return this._b;
         },
         
         'G': function() {
                 return this._G;
         },
         
         'r': function() {
                 return this._r;
         },
         
         'h': function() {
                 return this._h;
         },
         
         //-----------------------------------------------------------------------------
 
         'finiteField': function() {
                 if (this._finiteField == null) {
                         this._finiteField = new Clipperz.Crypto.ECC.BinaryField.FiniteField({modulus:this.modulus()})
                 }
                 
                 return this._finiteField;
         },
 
         //-----------------------------------------------------------------------------
 
         'negate': function(aPointA) {
                 var result;
 
                 result = new Clipperz.Crypto.ECC.Point({x:aPointA.x(), y:this.finiteField().add(aPointA.y(), aPointA.x())})
                 
                 return result;
         },
         
         //-----------------------------------------------------------------------------
 
         'add': function(aPointA, aPointB) {
                 var result;
 
-//console.log(">>> ECC.BinaryField.Curve.add");
                 if (aPointA.isZero()) {
-//console.log("--- pointA == zero");
                         result = aPointB;
                 } else if (aPointB.isZero()) {
-//console.log("--- pointB == zero");
                         result = aPointA;
                         } else if ((aPointA.x().compare(aPointB.x()) == 0) && ((aPointA.y().compare(aPointB.y()) != 0) || aPointB.x().isZero())) {
-//console.log("compare A.x - B.x: ", aPointA.x().compare(aPointB.x()));
-//console.log("compare A.y - B.y: ", (aPointA.y().compare(aPointB.y()) != 0));
-//console.log("compare B.x.isZero(): ", aPointB.x().isZero());
-
-//console.log("--- result = zero");
                         result = new Clipperz.Crypto.ECC.BinaryField.Point({x:Clipperz.Crypto.ECC.BinaryField.Value.O, y:Clipperz.Crypto.ECC.BinaryField.Value.O});
                 } else {
-//console.log("--- result = ELSE");
                                 varf2m;
                         var x, y;
                         var lambda;
                         var aX, aY, bX, bY;
                 
                         aX = aPointA.x()._value;
                         aY = aPointA.y()._value;
                         bX = aPointB.x()._value;
                         bY = aPointB.y()._value;
 
                         f2m = this.finiteField();
                         
                         if (aPointA.x().compare(aPointB.x()) != 0) {
-//console.log(" a.x != b.x");
                                         lambda =f2m._fastMultiply(
                                                                 f2m._add(aY, bY),
                                                                 f2m._inverse(f2m._add(aX, bX))
                                                         );
                                 x = f2m._add(this.a()._value, f2m._square(lambda));
                                 f2m._overwriteAdd(x, lambda);
                                 f2m._overwriteAdd(x, aX);
                                 f2m._overwriteAdd(x, bX);
                         } else {
-//console.log(" a.x == b.x");
                                 lambda = f2m._add(bX, f2m._fastMultiply(bY, f2m._inverse(bX)));
-//console.log(" lambda: " + lambda.asString(16));
                                 x = f2m._add(this.a()._value, f2m._square(lambda));
-//console.log(" x (step 1): " + x.asString(16));
                                 f2m._overwriteAdd(x, lambda);
-//console.log(" x (step 2): " + x.asString(16));
                         }
                         
                         y = f2m._fastMultiply(f2m._add(bX, x), lambda);
-//console.log(" y (step 1): " + y.asString(16));
                         f2m._overwriteAdd(y, x);
-//console.log(" y (step 2): " + y.asString(16));
                         f2m._overwriteAdd(y, bY);
-//console.log(" y (step 3): " + y.asString(16));
 
                         result = new Clipperz.Crypto.ECC.BinaryField.Point({x:new Clipperz.Crypto.ECC.BinaryField.Value(x), y:new Clipperz.Crypto.ECC.BinaryField.Value(y)})
                 }
-//console.log("<<< ECC.BinaryField.Curve.add");
                 
                 return result;
         },
 
         //-----------------------------------------------------------------------------
 
         'addTwice': function(aPointA) {
                 return this.add(aPointA, aPointA);
         },
         
         //-----------------------------------------------------------------------------
 
         'overwriteAdd': function(aPointA, aPointB) {
                 if (aPointA.isZero()) {
         //              result = aPointB;
                         aPointA._x._value = aPointB._x._value;
                         aPointA._y._value = aPointB._y._value;
                 } else if (aPointB.isZero()) {
         //              result = aPointA;
                         } else if ((aPointA.x().compare(aPointB.x()) == 0) && ((aPointA.y().compare(aPointB.y()) != 0) || aPointB.x().isZero())) {
         //              result = new Clipperz.Crypto.ECC.BinaryField.Point({x:Clipperz.Crypto.ECC.BinaryField.Value.O, y:Clipperz.Crypto.ECC.BinaryField.Value.O});
                         aPointA._x = Clipperz.Crypto.ECC.BinaryField.Value.O;
                         aPointA._y = Clipperz.Crypto.ECC.BinaryField.Value.O;
                 } else {
                                 varf2m;
                         var x, y;
                         var lambda;
                         var aX, aY, bX, bY;
                 
                         aX = aPointA.x()._value;
                         aY = aPointA.y()._value;
                         bX = aPointB.x()._value;
                         bY = aPointB.y()._value;
 
                         f2m = this.finiteField();
                         
                         if (aPointA.x().compare(aPointB.x()) != 0) {
-//console.log(" a.x != b.x");
                                         lambda =f2m._fastMultiply(
                                                                 f2m._add(aY, bY),
                                                                 f2m._inverse(f2m._add(aX, bX))
                                                         );
                                 x = f2m._add(this.a()._value, f2m._square(lambda));
                                 f2m._overwriteAdd(x, lambda);
                                 f2m._overwriteAdd(x, aX);
                                 f2m._overwriteAdd(x, bX);
                         } else {
-//console.log(" a.x == b.x");
                                 lambda = f2m._add(bX, f2m._fastMultiply(bY, f2m._inverse(bX)));
-//console.log(" lambda: " + lambda.asString(16));
                                 x = f2m._add(this.a()._value, f2m._square(lambda));
-//console.log(" x (step 1): " + x.asString(16));
                                 f2m._overwriteAdd(x, lambda);
-//console.log(" x (step 2): " + x.asString(16));
                         }
                         
                         y = f2m._fastMultiply(f2m._add(bX, x), lambda);
-//console.log(" y (step 1): " + y.asString(16));
                         f2m._overwriteAdd(y, x);
-//console.log(" y (step 2): " + y.asString(16));
                         f2m._overwriteAdd(y, bY);
-//console.log(" y (step 3): " + y.asString(16));
 
         //              result = new Clipperz.Crypto.ECC.BinaryField.Point({x:new Clipperz.Crypto.ECC.BinaryField.Value(x), y:new Clipperz.Crypto.ECC.BinaryField.Value(y)})
                         aPointA._x._value = x;
                         aPointA._y._value = y;
 
                 }
-//console.log("<<< ECC.BinaryField.Curve.add");
                 
                 return result;
         },
         
         //-----------------------------------------------------------------------------
 
         'multiply': function(aValue, aPoint) {
                 var result;
 
 //console.profile();
                 result = new Clipperz.Crypto.ECC.BinaryField.Point({x:Clipperz.Crypto.ECC.BinaryField.Value.O, y:Clipperz.Crypto.ECC.BinaryField.Value.O});
                 
                 if (aValue.isZero() == false) {
                         var k, Q;
                         var i;
                         var countIndex; countIndex = 0;
                         
                         if (aValue.compare(Clipperz.Crypto.ECC.BinaryField.Value.O) > 0) {
                                 k = aValue;
                                 Q = aPoint;
                         } else {
-MochiKit.Logging.logError("The Clipperz.Crypto.ECC.BinaryFields.Value does not work with negative values!!!!");
+                                Clipperz.logError("The Clipperz.Crypto.ECC.BinaryFields.Value does not work with negative values!!!!");
                                 k = aValue.negate();
                                 Q = this.negate(aPoint);
                         }
 
-//console.log("k: " + k.toString(16));
-//console.log("k.bitSize: " + k.bitSize());
                         for (i=k.bitSize()-1; i>=0; i--) {
                                 result = this.add(result, result);
         //                      this.overwriteAdd(result, result);
                                 if (k.isBitSet(i)) {
                                         result = this.add(result, Q);
         //                              this.overwriteAdd(result, Q);
                                 }
                                 
-        //                      if (countIndex==100) {console.log("multiply.break"); break;} else countIndex++;
+        //                      if (countIndex==100) {Clipperz.log("multiply.break"); break;} else countIndex++;
                         }
                 }
 //console.profileEnd();
                 
                 return result;
         },
 
         //-----------------------------------------------------------------------------
 
         'deferredMultiply': function(aValue, aPoint) {
                 var deferredResult;
                 var result;
 
-MochiKit.Logging.logDebug(">>> deferredMultiply - value: " + aValue + ", point: " + aPoint);
+Clipperz.log(">>> deferredMultiply - value: " + aValue + ", point: " + aPoint);
 //console.profile("ECC.Curve.multiply");
                 deferredResult = new MochiKit.Async.Deferred();
 //deferredResult.addCallback(function(res) {console.profile("ECC.Curve.deferredMultiply"); return res;} );
-//deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("# 1: " + res); return res;});
+//deferredResult.addBoth(function(res) {Clipperz.logDebug("# 1: " + res); return res;});
                 
                 result = new Clipperz.Crypto.ECC.BinaryField.Point({x:Clipperz.Crypto.ECC.BinaryField.Value.O, y:Clipperz.Crypto.ECC.BinaryField.Value.O});
-//deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("# 2: " + res); return res;});
+//deferredResult.addBoth(function(res) {Clipperz.logDebug("# 2: " + res); return res;});
 
                 if (aValue.isZero() == false) {
                         var k, Q;
                         var i;
                         var countIndex; countIndex = 0;
                         
                         if (aValue.compare(Clipperz.Crypto.ECC.BinaryField.Value.O) > 0) {
                                 k = aValue;
                                 Q = aPoint;
                         } else {
-MochiKit.Logging.logError("The Clipperz.Crypto.ECC.BinaryFields.Value does not work with negative values!!!!");
+                                Clipperz.logError("The Clipperz.Crypto.ECC.BinaryFields.Value does not work with negative values!!!!");
                                 k = aValue.negate();
                                 Q = this.negate(aPoint);
                         }
 
-//console.log("k: " + k.toString(16));
-//console.log("k.bitSize: " + k.bitSize());
 
-//deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("# 3: " + res); return res;});
                         for (i=k.bitSize()-1; i>=0; i--) {
-//MochiKit.Logging.logDebug("====> " + i);
-//deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("# 4 > i = " + i + ": " + res); return res;});
                                 deferredResult.addMethod(this, "addTwice");
         //#                     result = this.add(result, result);
         //                      this.overwriteAdd(result, result);
                                 if (k.isBitSet(i)) {
                                         deferredResult.addMethod(this, "add", Q);
         //#                             result = this.add(result, Q);
         //                              this.overwriteAdd(result, Q);
                                 }
                                 if (i%20 == 0) {deferredResult.addCallback(MochiKit.Async.wait, 0.1);}
-                                
-        //                      if (countIndex==100) {console.log("multiply.break"); break;} else countIndex++;
-//deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("# 4 < i = " + i + ": " + res); return res;});
                         }
-//deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("# 4: " + res); return res;});
                 }
 //#console.profileEnd();
-//deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("# 5: " + res); return res;});
 //deferredResult.addBoth(function(res) {console.profileEnd(); return res;});
-//deferredResult.addBoth(function(res) {MochiKit.Logging.logDebug("# 6: " + res); return res;});
                 deferredResult.callback(result);
                 
         //#     return result;
                 return deferredResult;
         },
 
         //-----------------------------------------------------------------------------
         __syntaxFix__: "syntax fix"
 });
 
 
 //#############################################################################
 
 Clipperz.Crypto.ECC.StandardCurves = {};
 
 MochiKit.Base.update(Clipperz.Crypto.ECC.StandardCurves, {
 /*
         '_K571': null,
         'K571': function() {
                 if (Clipperz.Crypto.ECC.StandardCurves._K571 == null) {
                         Clipperz.Crypto.ECC.StandardCurves._K571 = new Clipperz.Crypto.ECC.BinaryField.Curve({
                                 modulus: new Clipperz.Crypto.ECC.BinaryField.Value('08000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000425', 16),
                                 a: new Clipperz.Crypto.ECC.BinaryField.Value('0', 16),
                                 b: new Clipperz.Crypto.ECC.BinaryField.Value('1', 16),
                                 G: new Clipperz.Crypto.ECC.BinaryField.Point({
                                         x: new Clipperz.Crypto.ECC.BinaryField.Value('026eb7a8 59923fbc 82189631 f8103fe4 ac9ca297 0012d5d4 60248048 01841ca4 43709584 93b205e6 47da304d b4ceb08c bbd1ba39 494776fb 988b4717 4dca88c7 e2945283 a01c8972', 16),
                                         y: new Clipperz.Crypto.ECC.BinaryField.Value('0349dc80 7f4fbf37 4f4aeade 3bca9531 4dd58cec 9f307a54 ffc61efc 006d8a2c 9d4979c0 ac44aea7 4fbebbb9 f772aedc b620b01a 7ba7af1b 320430c8 591984f6 01cd4c14 3ef1c7a3', 16)
                                 }),
                                 r: new Clipperz.Crypto.ECC.BinaryField.Value('02000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 131850e1 f19a63e4 b391a8db 917f4138 b630d84b e5d63938 1e91deb4 5cfe778f 637c1001', 16),
                                 h: new Clipperz.Crypto.ECC.BinaryField.Value('4', 16)
                         });
                 }
                 
                 return Clipperz.Crypto.ECC.StandardCurves._K571;
         },
 
 
 
         '_K283': null,
                 'K283': function() {    //f(z) = z^283 + z^12 + z^7 + z^5 + 1
                 if (Clipperz.Crypto.ECC.StandardCurves._K283 == null) {
                         Clipperz.Crypto.ECC.StandardCurves._K283 = new Clipperz.Crypto.ECC.BinaryField.Curve({
                                 modulus: new Clipperz.Crypto.ECC.BinaryField.Value('08000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 000010a1', 16),
                                 a: new Clipperz.Crypto.ECC.BinaryField.Value('0', 16),
                                 b: new Clipperz.Crypto.ECC.BinaryField.Value('1', 16),
                                 G: new Clipperz.Crypto.ECC.BinaryField.Point({
                                         x: new Clipperz.Crypto.ECC.BinaryField.Value('0503213f 78ca4488 3f1a3b81 62f188e5 53cd265f 23c1567a 16876913 b0c2ac24 58492836', 16),
                                         y: new Clipperz.Crypto.ECC.BinaryField.Value('01ccda38 0f1c9e31 8d90f95d 07e5426f e87e45c0 e8184698 e4596236 4e341161 77dd2259', 16)
@@ -396,152 +354,147 @@ MochiKit.Base.update(Clipperz.Crypto.ECC.StandardCurves, {
                                 b: new Clipperz.Crypto.ECC.BinaryField.Value('02f40e7e2221f295de297117b7f3d62f5c6a97ffcb8ceff1cd6ba8ce4a9a18ad84ffabbd8efa59332be7ad6756a66e294afd185a78ff12aa520e4de739baca0c7ffeff7f2955727a', 16),
                                 G: new Clipperz.Crypto.ECC.BinaryField.Point({
                                         x: new Clipperz.Crypto.ECC.BinaryField.Value('0303001d 34b85629 6c16c0d4 0d3cd775 0a93d1d2 955fa80a a5f40fc8 db7b2abd bde53950 f4c0d293 cdd711a3 5b67fb14 99ae6003 8614f139 4abfa3b4 c850d927 e1e7769c 8eec2d19', 16),
                                         y: new Clipperz.Crypto.ECC.BinaryField.Value('037bf273 42da639b 6dccfffe b73d69d7 8c6c27a6 009cbbca 1980f853 3921e8a6 84423e43 bab08a57 6291af8f 461bb2a8 b3531d2f 0485c19b 16e2f151 6e23dd3c 1a4827af 1b8ac15b', 16)
                                 }),
                                 r: new Clipperz.Crypto.ECC.BinaryField.Value('03ffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff e661ce18 ff559873 08059b18 6823851e c7dd9ca1 161de93d 5174d66e 8382e9bb 2fe84e47', 16),
                                 h: new Clipperz.Crypto.ECC.BinaryField.Value('2', 16)
 
         //                      S: new Clipperz.Crypto.ECC.BinaryField.Value('2aa058f73a0e33ab486b0f610410c53a7f132310', 10),
         //                      n: new Clipperz.Crypto.ECC.BinaryField.Value('03ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe661ce18ff55987308059b186823851ec7dd9ca1161de93d5174d66e8382e9bb2fe84e47', 16)
                         });
                         
                         //-----------------------------------------------------------------------------
                         //
                                 //Guide to Elliptic Curve Cryptography
                                 //Darrel Hankerson, Alfred Menezes, Scott Vanstone
                                 //- Pag: 56, Alorithm 2.45 (with a typo!!!)
                                 //
                         //-----------------------------------------------------------------------------
                         //
                                 //      http://www.milw0rm.com/papers/136
                         //
                                 //      -------------------------------------------------------------------------
                                 //        Polynomial Reduction Algorithm Modulo f571 
                                 //      -------------------------------------------------------------------------
                                 //      
                                 //        Input:  Polynomial p(x) of degree 1140 or less, stored as 
                                 //                an array of 2T machinewords.
                                 //        Output: p(x) mod f571(x)
                                 //      
                                 //        FOR i = T-1, ..., 0 DO
                                 //            SET X  := P[i+T]
                                 //            P[i]   := P[i]   ^ (X<<5) ^ (X<<7) ^ (X<<10) ^ (X<<15)
                                 //            P[i+1] := P[i+1] ^ (X>>17) ^ (X>>22) ^ (X>>25) ^ (X>>27)
                                 //      
                                 //        SET X  := P[T-1] >> 27
                                 //        P[0]   := P[0] ^ X ^ (X<<2) ^ (X<<5) ^ (X<<10)
                                 //        P[T-1] := P[T-1] & 0x07ffffff
                                 //      
                                 //        RETURN P[T-1],...,P[0]
                                 //      
                                 //      -------------------------------------------------------------------------
                                 //      
                         Clipperz.Crypto.ECC.StandardCurves._B571.finiteField().slowModule = Clipperz.Crypto.ECC.StandardCurves._B571.finiteField().module;
                         Clipperz.Crypto.ECC.StandardCurves._B571.finiteField().module = function(aValue) {
                                         varresult;
                                 
                                 if (aValue.bitSize() > 1140) {
-                                        MochiKit.Logging.logWarning("ECC.StandarCurves.B571.finiteField().module: falling back to default implementation");
+                                        Clipperz.logWarning("ECC.StandarCurves.B571.finiteField().module: falling back to default implementation");
                                         result = Clipperz.Crypto.ECC.StandardCurves._B571.finiteField().slowModule(aValue);
                                 } else {
                                                 varC, T;
                                         var i;
                 
-//console.log(">>> binaryField.finiteField.(improved)module");
-        //                              C = aValue.value().slice(0);
                                         C = aValue._value.slice(0);
                                         for (i=35; i>=18; i--) {
                                                 T = C[i];
                                                 C[i-18] = (((C[i-18] ^ (T<<5) ^ (T<<7) ^ (T<<10) ^ (T<<15)) & 0xffffffff) >>> 0);
                                                 C[i-17] = ((C[i-17] ^ (T>>>27) ^ (T>>>25) ^ (T>>>22) ^ (T>>>17)) >>> 0);
                                         }
                                         T = (C[17] >>> 27);
                                         C[0] = ((C[0] ^ T ^ ((T<<2) ^ (T<<5) ^ (T<<10)) & 0xffffffff) >>> 0);
                                         C[17] = (C[17] & 0x07ffffff);
 
                                         for(i=18; i<=35; i++) {
                                                 C[i] = 0;
                                         }
                                 
                                         result = new Clipperz.Crypto.ECC.BinaryField.Value(C);
-//console.log("<<< binaryField.finiteField.(improved)module");
                                 }
                         
                                 return result;
                         };
                 }
                 
                 return Clipperz.Crypto.ECC.StandardCurves._B571;
         },
 
         //-----------------------------------------------------------------------------
 
         '_B283': null,
                 'B283': function() {    //f(z) = z^283 + z^12 + z^7 + z^5 + 1
                 if (Clipperz.Crypto.ECC.StandardCurves._B283 == null) {
                         Clipperz.Crypto.ECC.StandardCurves._B283 = new Clipperz.Crypto.ECC.BinaryField.Curve({
         //                      modulus: new Clipperz.Crypto.ECC.BinaryField.Value('10000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 000010a1', 16),
                                 modulus: new Clipperz.Crypto.ECC.BinaryField.Value('08000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 000010a1', 16),
                                 a: new Clipperz.Crypto.ECC.BinaryField.Value('1', 16),
                                 b: new Clipperz.Crypto.ECC.BinaryField.Value('027b680a c8b8596d a5a4af8a 19a0303f ca97fd76 45309fa2 a581485a f6263e31 3b79a2f5', 16),
                                 G: new Clipperz.Crypto.ECC.BinaryField.Point({
                                         x: new Clipperz.Crypto.ECC.BinaryField.Value('05f93925 8db7dd90 e1934f8c 70b0dfec 2eed25b8 557eac9c 80e2e198 f8cdbecd 86b12053', 16),
                                         y: new Clipperz.Crypto.ECC.BinaryField.Value('03676854 fe24141c b98fe6d4 b20d02b4 516ff702 350eddb0 826779c8 13f0df45 be8112f4', 16)
                                 }),
                                 r: new Clipperz.Crypto.ECC.BinaryField.Value('03ffffff ffffffff ffffffff ffffffff ffffef90 399660fc 938a9016 5b042a7c efadb307', 16),
                                 h: new Clipperz.Crypto.ECC.BinaryField.Value('2', 16)
 
         //                      S: new Clipperz.Crypto.ECC.BinaryField.Value('2aa058f73a0e33ab486b0f610410c53a7f132310', 10),
         //                      n: new Clipperz.Crypto.ECC.BinaryField.Value('03ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe661ce18ff55987308059b186823851ec7dd9ca1161de93d5174d66e8382e9bb2fe84e47', 16)
                         });
                         
                         //-----------------------------------------------------------------------------
                         //
                                 //Guide to Elliptic Curve Cryptography
                                 //Darrel Hankerson, Alfred Menezes, Scott Vanstone
                                 //- Pag: 56, Alorithm 2.43
                                 //
                         //-----------------------------------------------------------------------------
                         Clipperz.Crypto.ECC.StandardCurves._B283.finiteField().slowModule = Clipperz.Crypto.ECC.StandardCurves._B283.finiteField().module;
                         Clipperz.Crypto.ECC.StandardCurves._B283.finiteField().module = function(aValue) {
                                         varresult;
 
                                 if (aValue.bitSize() > 564) {
-                                        MochiKit.Logging.logWarning("ECC.StandarCurves.B283.finiteField().module: falling back to default implementation");
+                                        Clipperz.logWarning("ECC.StandarCurves.B283.finiteField().module: falling back to default implementation");
                                         result = Clipperz.Crypto.ECC.StandardCurves._B283.finiteField().slowModule(aValue);
                                 } else {
                                                 varC, T;
                                         var i;
                                         
-//console.log(">>> binaryField.finiteField.(improved)module");
                                         C = aValue._value.slice(0);
                                         for (i=17; i>=9; i--) {
                                                 T = C[i];
                                                 C[i-9] = (((C[i-9] ^ (T<<5) ^ (T<<10) ^ (T<<12) ^ (T<<17)) & 0xffffffff) >>> 0);
                                                 C[i-8] = ((C[i-8] ^ (T>>>27) ^ (T>>>22) ^ (T>>>20) ^ (T>>>15)) >>> 0);
                                         }
                                         T = (C[8] >>> 27);
                                         C[0] = ((C[0] ^ T ^ ((T<<5) ^ (T<<7) ^ (T<<12)) & 0xffffffff) >>> 0);
                                         C[8] = (C[8] & 0x07ffffff);
 
                                         for(i=9; i<=17; i++) {
                                                 C[i] = 0;
                                         }
                                 
                                         result = new Clipperz.Crypto.ECC.BinaryField.Value(C);
-//console.log("<<< binaryField.finiteField.(improved)module");
                                 }
                                 
                                 return result;
                         };
                 }
                 
                 return Clipperz.Crypto.ECC.StandardCurves._B283;
         },
 
         //-----------------------------------------------------------------------------
         __syntaxFix__: "syntax fix"
 });
 
 //#############################################################################
 
diff --git a/frontend/gamma/js/Clipperz/Crypto/ECC/BinaryField/FiniteField.js b/frontend/gamma/js/Clipperz/Crypto/ECC/BinaryField/FiniteField.js
index 56f257a..7b7c2c6 100644
--- a/frontend/gamma/js/Clipperz/Crypto/ECC/BinaryField/FiniteField.js
+++ b/frontend/gamma/js/Clipperz/Crypto/ECC/BinaryField/FiniteField.js
@@ -1,126 +1,122 @@
 /*
 
-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/.
 
 */
 
 //try { if (typeof(Clipperz.ByteArray) == 'undefined') { throw ""; }} catch (e) {
         //throw "Clipperz.Crypto.ECC depends on Clipperz.ByteArray!";
 //}  
 if (typeof(Clipperz.Crypto.ECC) == 'undefined') { Clipperz.Crypto.ECC = {}; }
 if (typeof(Clipperz.Crypto.ECC.BinaryField) == 'undefined') { Clipperz.Crypto.ECC.BinaryField = {}; }
 
 Clipperz.Crypto.ECC.BinaryField.FiniteField = function(args) {
         args = args || {};
         this._modulus = args.modulus;
 
         return this;
 }
 
 Clipperz.Crypto.ECC.BinaryField.FiniteField.prototype = MochiKit.Base.update(null, {
 
         'asString': function() {
                 return "Clipperz.Crypto.ECC.BinaryField.FiniteField (" + this.modulus().asString() + ")";
         },
 
         //-----------------------------------------------------------------------------
 
         'modulus': function() {
                 return this._modulus;
         },
         
         //-----------------------------------------------------------------------------
 
         '_module': function(aValue) {
                         varresult;
                 var modulusComparison;
-//console.log(">>> binaryField.finiteField.(standard)module");
                 
                 modulusComparison = Clipperz.Crypto.ECC.BinaryField.Value._compare(aValue, this.modulus()._value);
 
                 if (modulusComparison < 0) {
                         result = aValue;
                 } else if (modulusComparison == 0) {
                         result = [0];
                 } else {
                         var modulusBitSize;
                         var resultBitSize;
                         
                         result = aValue;
 
                         modulusBitSize = this.modulus().bitSize();
                         resultBitSize = Clipperz.Crypto.ECC.BinaryField.Value._bitSize(result);
                         while (resultBitSize >= modulusBitSize) {
                                 Clipperz.Crypto.ECC.BinaryField.Value._overwriteXor(result, Clipperz.Crypto.ECC.BinaryField.Value._shiftLeft(this.modulus()._value, resultBitSize - modulusBitSize));
                                 resultBitSize = Clipperz.Crypto.ECC.BinaryField.Value._bitSize(result);
                         }
                 }
-//console.log("<<< binaryField.finiteField.(standard)module");
-                
+
                 return result;
         },
         
         'module': function(aValue) {
                 return new Clipperz.Crypto.ECC.BinaryField.Value(this._module(aValue._value.slice(0)));
         },
         
         //-----------------------------------------------------------------------------
 
         '_add': function(a, b) {
                 return Clipperz.Crypto.ECC.BinaryField.Value._xor(a, b);
         },
 
         '_overwriteAdd': function(a, b) {
                 Clipperz.Crypto.ECC.BinaryField.Value._overwriteXor(a, b);
         },
         
         'add': function(a, b) {
                 return new Clipperz.Crypto.ECC.BinaryField.Value(this._add(a._value, b._value));
         },
         
         //-----------------------------------------------------------------------------
 
         'negate': function(aValue) {
                 return aValue.clone();
         },
 
         //-----------------------------------------------------------------------------
 
         '_multiply': function(a, b) {
                 var result;
                 var valueToXor;
                 var i,c;
 
                 result = [0];
                 valueToXor = b;
                 c = Clipperz.Crypto.ECC.BinaryField.Value._bitSize(a);
                 for (i=0; i<c; i++) {
                         if (Clipperz.Crypto.ECC.BinaryField.Value._isBitSet(a, i) === true) {
                                 Clipperz.Crypto.ECC.BinaryField.Value._overwriteXor(result, valueToXor);
                         }
                         valueToXor = Clipperz.Crypto.ECC.BinaryField.Value._overwriteShiftLeft(valueToXor, 1);
                 }
                 result = this._module(result);
 
                 return result;
         },
 
diff --git a/frontend/gamma/js/Clipperz/Crypto/ECC/BinaryField/Point.js b/frontend/gamma/js/Clipperz/Crypto/ECC/BinaryField/Point.js
index ffe287b..fef3220 100644
--- a/frontend/gamma/js/Clipperz/Crypto/ECC/BinaryField/Point.js
+++ b/frontend/gamma/js/Clipperz/Crypto/ECC/BinaryField/Point.js
@@ -1,64 +1,62 @@
 /*
 
-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/.
 
 */
 
 //try { if (typeof(Clipperz.ByteArray) == 'undefined') { throw ""; }} catch (e) {
         //throw "Clipperz.Crypto.ECC depends on Clipperz.ByteArray!";
 //}  
 if (typeof(Clipperz.Crypto.ECC) == 'undefined') { Clipperz.Crypto.ECC = {}; }
 if (typeof(Clipperz.Crypto.ECC.BinaryField) == 'undefined') { Clipperz.Crypto.ECC.BinaryField = {}; }
 
 Clipperz.Crypto.ECC.BinaryField.Point = function(args) {
         args = args || {};
         this._x = args.x;
         this._y = args.y;
         
         return this;
 }
 
 Clipperz.Crypto.ECC.BinaryField.Point.prototype = MochiKit.Base.update(null, {
 
         'asString': function() {
                 return "Clipperz.Crypto.ECC.BinaryField.Point (" + this.x() + ", " + this.y() + ")";
         },
 
         //-----------------------------------------------------------------------------
 
         'x': function() {
                 return this._x;
         },
         
         'y': function() {
                 return this._y;
         },
 
         //-----------------------------------------------------------------------------
 
         'isZero': function() {
                 return (this.x().isZero() && this.y().isZero())
         },
         
         //-----------------------------------------------------------------------------
         __syntaxFix__: "syntax fix"
 });
diff --git a/frontend/gamma/js/Clipperz/Crypto/ECC/BinaryField/Value.js b/frontend/gamma/js/Clipperz/Crypto/ECC/BinaryField/Value.js
index b705a20..634772a 100644
--- a/frontend/gamma/js/Clipperz/Crypto/ECC/BinaryField/Value.js
+++ b/frontend/gamma/js/Clipperz/Crypto/ECC/BinaryField/Value.js
@@ -1,70 +1,68 @@
 /*
 
-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/.
 
 */
 
 //try { if (typeof(Clipperz.ByteArray) == 'undefined') { throw ""; }} catch (e) {
         //throw "Clipperz.Crypto.ECC depends on Clipperz.ByteArray!";
 //}  
 if (typeof(Clipperz) == 'undefined') { Clipperz = {}; }
 if (typeof(Clipperz.Crypto) == 'undefined') { Clipperz.Crypto = {}; }
 if (typeof(Clipperz.Crypto.ECC) == 'undefined') { Clipperz.Crypto.ECC = {}; }
 if (typeof(Clipperz.Crypto.ECC.BinaryField) == 'undefined') { Clipperz.Crypto.ECC.BinaryField = {}; }
 
 Clipperz.Crypto.ECC.BinaryField.Value = function(aValue, aBase, aBitSize) {
         if (aValue.constructor == String) {
                         varvalue;
                         varstringLength;
                 var numberOfWords;
                         vari,c;
         
                 if (aBase != 16) {
                         throw Clipperz.Crypto.ECC.BinaryField.Value.exception.UnsupportedBase;
                 }
 
                 value = aValue.replace(/ /g, '');
                 stringLength = value.length;
                 numberOfWords = Math.ceil(stringLength / 8);
                 this._value = new Array(numberOfWords);
         
                 c = numberOfWords;
                 for (i=0; i<c; i++) {
                                 varword;
                 
                         if (i < (c-1)) {
                                 word = parseInt(value.substr(stringLength-((i+1)*8), 8), 16);
                         } else {
                                 word = parseInt(value.substr(0, stringLength-(i*8)), 16);
                         }
                         
                         this._value[i] = word;
                 }
         } else if (aValue.constructor == Array) {
                 var itemsToCopy;
 
                 itemsToCopy = aValue.length;
                 while (aValue[itemsToCopy - 1] == 0) {
                         itemsToCopy --;
                 }
 
                 this._value = aValue.slice(0, itemsToCopy);
@@ -323,61 +321,59 @@ Clipperz.Crypto.ECC.BinaryField.Value._bitSize = function(aWordArray) {
         } else {
                         notNullElements --;
                 while((notNullElements > 0) && (aWordArray[notNullElements] == 0)) {
                         notNullElements --;
                 }
         
                 result = notNullElements * 32;
                 mostValuableWord = aWordArray[notNullElements];
 
                 matchingBits = 32;
                 mask = 0x80000000;
         
                 while ((matchingBits > 0) && ((mostValuableWord & mask) == 0)) {
                         matchingBits --;
                         mask >>>= 1;
                 }
         
                 result += matchingBits;
         }
         
         return result;
 };
 
 Clipperz.Crypto.ECC.BinaryField.Value._isBitSet = function(aWordArray, aBitPosition) {
         var result;
                 varbyteIndex;
         var bitIndexInSelectedByte;
 
         byteIndex = Math.floor(aBitPosition / 32);
         bitIndexInSelectedByte = aBitPosition % 32;
         
         if (byteIndex <= aWordArray.length) {
                 result = ((aWordArray[byteIndex] & (1 << bitIndexInSelectedByte)) != 0);
         } else {
                 result = false;
         }
 
         return result;
 };
 
 Clipperz.Crypto.ECC.BinaryField.Value._compare = function(a,b) {
                 varresult;
         var i,c;
         
         result = MochiKit.Base.compare(a.length, b.length);
 
         c = a.length;
         for (i=0; (i<c) && (result==0); i++) {
-//console.log("compare[" + c + " - " + i + " - 1] " + this.value()[c-i-1] + ", " + aValue.value()[c-i-1]);
-        //      result = MochiKit.Base.compare(this.value()[c-i-1], aValue.value()[c-i-1]);
                 result = MochiKit.Base.compare(a[c-i-1], b[c-i-1]);
         }
         
         return result;
 };
 
 
 Clipperz.Crypto.ECC.BinaryField.Value['exception']= {
                 'UnsupportedBase':                              new MochiKit.Base.NamedError("Clipperz.Crypto.ECC.BinaryField.Value.exception.UnsupportedBase"),
                 'UnsupportedConstructorValueType':new MochiKit.Base.NamedError("Clipperz.Crypto.ECC.BinaryField.Value.exception.UnsupportedConstructorValueType")
 };
diff --git a/frontend/gamma/js/Clipperz/Crypto/ECC/StandardCurves.js b/frontend/gamma/js/Clipperz/Crypto/ECC/StandardCurves.js
index be197e3..239e264 100644
--- a/frontend/gamma/js/Clipperz/Crypto/ECC/StandardCurves.js
+++ b/frontend/gamma/js/Clipperz/Crypto/ECC/StandardCurves.js
@@ -1,70 +1,68 @@
 /*
 
-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/.
 
 */
 
 //try { if (typeof(Clipperz.Crypto.ECC.BinaryField.Curve) == 'undefined') { throw ""; }} catch (e) {
         //throw "Clipperz.Crypto.ECC depends on Clipperz.Crypto.ECC.BinaryField.Curve!";
 //}
 //try { if (typeof(Clipperz.Crypto.ECC.Koblitz.Curve) == 'undefined') { throw ""; }} catch (e) {
         //throw "Clipperz.Crypto.ECC depends on Clipperz.Crypto.ECC.Koblitz.Curve!";
 //}
 
 Clipperz.Crypto.ECC.StandardCurves = {};
 
 MochiKit.Base.update(Clipperz.Crypto.ECC.StandardCurves, {
 
         //==============================================================================
 
         '_K571': null,
                 'K571': function() {    //f(z) = z^571 + z^10 + z^5 + z^2 + 1
                 if ((Clipperz.Crypto.ECC.StandardCurves._K571 == null) && (typeof(Clipperz.Crypto.ECC.Koblitz.Curve) != 'undefined')) {
                         Clipperz.Crypto.ECC.StandardCurves._K571 = new Clipperz.Crypto.ECC.Koblitz.Curve({
                                 modulus: new Clipperz.Crypto.ECC.Koblitz.Value('08000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000425', 16),
                                 a: new Clipperz.Crypto.ECC.Koblitz.Value('0', 16),
                                 b: new Clipperz.Crypto.ECC.Koblitz.Value('1', 16),
                                 G: new Clipperz.Crypto.ECC.Koblitz.Point({
                                         x: new Clipperz.Crypto.ECC.Koblitz.Value('026eb7a8 59923fbc 82189631 f8103fe4 ac9ca297 0012d5d4 60248048 01841ca4 43709584 93b205e6 47da304d b4ceb08c bbd1ba39 494776fb 988b4717 4dca88c7 e2945283 a01c8972', 16),
                                         y: new Clipperz.Crypto.ECC.Koblitz.Value('0349dc80 7f4fbf37 4f4aeade 3bca9531 4dd58cec 9f307a54 ffc61efc 006d8a2c 9d4979c0 ac44aea7 4fbebbb9 f772aedc b620b01a 7ba7af1b 320430c8 591984f6 01cd4c14 3ef1c7a3', 16)
                                 }),
                                 r: new Clipperz.Crypto.ECC.Koblitz.Value('02000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 131850e1 f19a63e4 b391a8db 917f4138 b630d84b e5d63938 1e91deb4 5cfe778f 637c1001', 16),
                                 h: new Clipperz.Crypto.ECC.Koblitz.Value('4', 16),
                                 primeFactor: new Clipperz.Crypto.ECC.Koblitz.Value('02000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 131850e1 f19a63e4 b391a8db 917f4138 b630d84b e5d63938 1e91deb4 5cfe778f 637c1001', 16)
                         });
                 }
                 
                 return Clipperz.Crypto.ECC.StandardCurves._K571;
         },
 
         //-----------------------------------------------------------------------------
 
         '_K283': null,
                 'K283': function() {    //f(z) = z^283 + z^12 + z^7 + z^5 + 1
                 if ((Clipperz.Crypto.ECC.StandardCurves._K283 == null) && (typeof(Clipperz.Crypto.ECC.Koblitz.Curve) != 'undefined')) {
                         Clipperz.Crypto.ECC.StandardCurves._K283 = new Clipperz.Crypto.ECC.Koblitz.Curve({
                                 modulus: new Clipperz.Crypto.ECC.Koblitz.Value('08000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 000010a1', 16),
                                 a: new Clipperz.Crypto.ECC.Koblitz.Value('0', 16),
                                 b: new Clipperz.Crypto.ECC.Koblitz.Value('1', 16),
                                 G: new Clipperz.Crypto.ECC.Koblitz.Point({
                                         x: new Clipperz.Crypto.ECC.Koblitz.Value('0503213f 78ca4488 3f1a3b81 62f188e5 53cd265f 23c1567a 16876913 b0c2ac24 58492836', 16),
                                         y: new Clipperz.Crypto.ECC.Koblitz.Value('01ccda38 0f1c9e31 8d90f95d 07e5426f e87e45c0 e8184698 e4596236 4e341161 77dd2259', 16)
@@ -89,148 +87,143 @@ MochiKit.Base.update(Clipperz.Crypto.ECC.StandardCurves, {
                                 b: new Clipperz.Crypto.ECC.BinaryField.Value('02f40e7e 2221f295 de297117 b7f3d62f 5c6a97ff cb8ceff1 cd6ba8ce 4a9a18ad 84ffabbd 8efa5933 2be7ad67 56a66e29 4afd185a 78ff12aa 520e4de7 39baca0c 7ffeff7f 2955727a', 16),
                                 G: new Clipperz.Crypto.ECC.BinaryField.Point({
                                         x: new Clipperz.Crypto.ECC.BinaryField.Value('0303001d 34b85629 6c16c0d4 0d3cd775 0a93d1d2 955fa80a a5f40fc8 db7b2abd bde53950 f4c0d293 cdd711a3 5b67fb14 99ae6003 8614f139 4abfa3b4 c850d927 e1e7769c 8eec2d19', 16),
                                         y: new Clipperz.Crypto.ECC.BinaryField.Value('037bf273 42da639b 6dccfffe b73d69d7 8c6c27a6 009cbbca 1980f853 3921e8a6 84423e43 bab08a57 6291af8f 461bb2a8 b3531d2f 0485c19b 16e2f151 6e23dd3c 1a4827af 1b8ac15b', 16)
                                 }),
                                 r: new Clipperz.Crypto.ECC.BinaryField.Value('03ffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff e661ce18 ff559873 08059b18 6823851e c7dd9ca1 161de93d 5174d66e 8382e9bb 2fe84e47', 16),
                                 h: new Clipperz.Crypto.ECC.BinaryField.Value('2', 16)
 
         //                      S: new Clipperz.Crypto.ECC.BinaryField.Value('2aa058f73a0e33ab486b0f610410c53a7f132310', 10),
         //                      n: new Clipperz.Crypto.ECC.BinaryField.Value('03ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe661ce18ff55987308059b186823851ec7dd9ca1161de93d5174d66e8382e9bb2fe84e47', 16)
                         });
                         
                         //-----------------------------------------------------------------------------
                         //
                                 //Guide to Elliptic Curve Cryptography
                                 //Darrel Hankerson, Alfred Menezes, Scott Vanstone
                                 //- Pag: 56, Alorithm 2.45 (with a typo!!!)
                                 //
                         //-----------------------------------------------------------------------------
                         //
                                 //      http://www.milw0rm.com/papers/136
                         //
                                 //      -------------------------------------------------------------------------
                                 //        Polynomial Reduction Algorithm Modulo f571 
                                 //      -------------------------------------------------------------------------
                                 //      
                                 //        Input:  Polynomial p(x) of degree 1140 or less, stored as 
                                 //                an array of 2T machinewords.
                                 //        Output: p(x) mod f571(x)
                                 //      
                                 //        FOR i = T-1, ..., 0 DO
                                 //            SET X  := P[i+T]
                                 //            P[i]   := P[i]   ^ (X<<5) ^ (X<<7) ^ (X<<10) ^ (X<<15)
                                 //            P[i+1] := P[i+1] ^ (X>>17) ^ (X>>22) ^ (X>>25) ^ (X>>27)
                                 //      
                                 //        SET X  := P[T-1] >> 27
                                 //        P[0]   := P[0] ^ X ^ (X<<2) ^ (X<<5) ^ (X<<10)
                                 //        P[T-1] := P[T-1] & 0x07ffffff
                                 //      
                                 //        RETURN P[T-1],...,P[0]
                                 //      
                                 //      -------------------------------------------------------------------------
                                 //      
                         Clipperz.Crypto.ECC.StandardCurves._B571.finiteField().slowModule = Clipperz.Crypto.ECC.StandardCurves._B571.finiteField().module;
                         Clipperz.Crypto.ECC.StandardCurves._B571.finiteField().module = function(aValue) {
                                         varresult;
                                 
                                 if (aValue.bitSize() > 1140) {
-                                        MochiKit.Logging.logWarning("ECC.StandarCurves.B571.finiteField().module: falling back to default implementation");
+                                        Clipperz.logWarning("ECC.StandarCurves.B571.finiteField().module: falling back to default implementation");
                                         result = Clipperz.Crypto.ECC.StandardCurves._B571.finiteField().slowModule(aValue);
                                 } else {
                                                 varC, T;
                                         var i;
                 
-//console.log(">>> binaryField.finiteField.(improved)module");
-        //                              C = aValue.value().slice(0);
                                         C = aValue._value.slice(0);
                                         for (i=35; i>=18; i--) {
                                                 T = C[i];
                                                 C[i-18] = (((C[i-18] ^ (T<<5) ^ (T<<7) ^ (T<<10) ^ (T<<15)) & 0xffffffff) >>> 0);
                                                 C[i-17] = ((C[i-17] ^ (T>>>27) ^ (T>>>25) ^ (T>>>22) ^ (T>>>17)) >>> 0);
                                         }
                                         T = (C[17] >>> 27);
                                         C[0] = ((C[0] ^ T ^ ((T<<2) ^ (T<<5) ^ (T<<10)) & 0xffffffff) >>> 0);
                                         C[17] = (C[17] & 0x07ffffff);
 
                                         for(i=18; i<=35; i++) {
                                                 C[i] = 0;
                                         }
                                 
                                         result = new Clipperz.Crypto.ECC.BinaryField.Value(C);
-//console.log("<<< binaryField.finiteField.(improved)module");
                                 }
                         
                                 return result;
                         };
                 }
                 
                 return Clipperz.Crypto.ECC.StandardCurves._B571;
         },
 
         //-----------------------------------------------------------------------------
 
         '_B283': null,
                 'B283': function() {    //f(z) = z^283 + z^12 + z^7 + z^5 + 1
                 if ((Clipperz.Crypto.ECC.StandardCurves._B283 == null) && (typeof(Clipperz.Crypto.ECC.BinaryField.Curve) != 'undefined')) {
                         Clipperz.Crypto.ECC.StandardCurves._B283 = new Clipperz.Crypto.ECC.BinaryField.Curve({
                                 modulus: new Clipperz.Crypto.ECC.BinaryField.Value('08000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 000010a1', 16),
                                 a: new Clipperz.Crypto.ECC.BinaryField.Value('1', 16),
                                 b: new Clipperz.Crypto.ECC.BinaryField.Value('027b680a c8b8596d a5a4af8a 19a0303f ca97fd76 45309fa2 a581485a f6263e31 3b79a2f5', 16),
                                 G: new Clipperz.Crypto.ECC.BinaryField.Point({
                                         x: new Clipperz.Crypto.ECC.BinaryField.Value('05f93925 8db7dd90 e1934f8c 70b0dfec 2eed25b8 557eac9c 80e2e198 f8cdbecd 86b12053', 16),
                                         y: new Clipperz.Crypto.ECC.BinaryField.Value('03676854 fe24141c b98fe6d4 b20d02b4 516ff702 350eddb0 826779c8 13f0df45 be8112f4', 16)
                                 }),
                                 r: new Clipperz.Crypto.ECC.BinaryField.Value('03ffffff ffffffff ffffffff ffffffff ffffef90 399660fc 938a9016 5b042a7c efadb307', 16),
                                 h: new Clipperz.Crypto.ECC.BinaryField.Value('2', 16)
                         });
                         
                         //-----------------------------------------------------------------------------
                         //
                                 //Guide to Elliptic Curve Cryptography
                                 //Darrel Hankerson, Alfred Menezes, Scott Vanstone
                                 //- Pag: 56, Alorithm 2.43
                                 //
                         //-----------------------------------------------------------------------------
                         Clipperz.Crypto.ECC.StandardCurves._B283.finiteField().slowModule = Clipperz.Crypto.ECC.StandardCurves._B283.finiteField().module;
                         Clipperz.Crypto.ECC.StandardCurves._B283.finiteField().module = function(aValue) {
                                         varresult;
 
                                 if (aValue.bitSize() > 564) {
-                                        MochiKit.Logging.logWarning("ECC.StandarCurves.B283.finiteField().module: falling back to default implementation");
+                                        Clipperz.logWarning("ECC.StandarCurves.B283.finiteField().module: falling back to default implementation");
                                         result = Clipperz.Crypto.ECC.StandardCurves._B283.finiteField().slowModule(aValue);
                                 } else {
                                                 varC, T;
                                         var i;
                                         
-//console.log(">>> binaryField.finiteField.(improved)module");
                                         C = aValue._value.slice(0);
                                         for (i=17; i>=9; i--) {
                                                 T = C[i];
                                                 C[i-9] = (((C[i-9] ^ (T<<5) ^ (T<<10) ^ (T<<12) ^ (T<<17)) & 0xffffffff) >>> 0);
                                                 C[i-8] = ((C[i-8] ^ (T>>>27) ^ (T>>>22) ^ (T>>>20) ^ (T>>>15)) >>> 0);
                                         }
                                         T = (C[8] >>> 27);
                                         C[0] = ((C[0] ^ T ^ ((T<<5) ^ (T<<7) ^ (T<<12)) & 0xffffffff) >>> 0);
                                         C[8] = (C[8] & 0x07ffffff);
 
                                         for(i=9; i<=17; i++) {
                                                 C[i] = 0;
                                         }
                                 
                                         result = new Clipperz.Crypto.ECC.BinaryField.Value(C);
-//console.log("<<< binaryField.finiteField.(improved)module");
                                 }
                                 
                                 return result;
                         };
                 }
                 
                 return Clipperz.Crypto.ECC.StandardCurves._B283;
         },
 
         //==============================================================================
         __syntaxFix__: "syntax fix"
 });