Merge remote-tracking branch 'github/master' into nmaster

3 files changed, 112 insertions, 104 deletions

diff --git a/frontend/gamma/js/Clipperz/Crypto/PRNG.js b/frontend/gamma/js/Clipperz/Crypto/PRNG.js
index c539f06..80d972f 100644
--- a/frontend/gamma/js/Clipperz/Crypto/PRNG.js
+++ b/frontend/gamma/js/Clipperz/Crypto/PRNG.js
@@ -1,841 +1,805 @@
 /*
 
 Copyright 2008-2013 Clipperz Srl
 
 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 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 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. If not, see http://www.gnu.org/licenses/.
 
 */
 
+"use strict";
+
 try { if (typeof(Clipperz.ByteArray) == 'undefined') { throw ""; }} catch (e) {
         throw "Clipperz.Crypto.PRNG depends on Clipperz.ByteArray!";
 }  
 
 try { if (typeof(Clipperz.Crypto.SHA) == 'undefined') { throw ""; }} catch (e) {
         throw "Clipperz.Crypto.PRNG depends on Clipperz.Crypto.SHA!";
 }  
 
 try { if (typeof(Clipperz.Crypto.AES) == 'undefined') { throw ""; }} catch (e) {
         throw "Clipperz.Crypto.PRNG depends on Clipperz.Crypto.AES!";
 }  
 
 if (typeof(Clipperz.Crypto.PRNG) == 'undefined') { Clipperz.Crypto.PRNG = {}; }
 
 //#############################################################################
 
 Clipperz.Crypto.PRNG.EntropyAccumulator = function(args) {
         args = args || {};
         //MochiKit.Base.bindMethods(this);
 
         this._stack = new Clipperz.ByteArray();
         this._maxStackLengthBeforeHashing = args.maxStackLengthBeforeHashing || 256;
         return this;
 }
 
 Clipperz.Crypto.PRNG.EntropyAccumulator.prototype = MochiKit.Base.update(null, {
 
         'toString': function() {
                 return "Clipperz.Crypto.PRNG.EntropyAccumulator";
         },
 
         //-------------------------------------------------------------------------
 
         'stack': function() {
                 return this._stack;
         },
         
         'setStack': function(aValue) {
                 this._stack = aValue;
         },
 
         'resetStack': function() {
                 this.stack().reset();
         },
         
         'maxStackLengthBeforeHashing': function() {
                 return this._maxStackLengthBeforeHashing;
         },
 
         //-------------------------------------------------------------------------
 
         'addRandomByte': function(aValue) {
                 this.stack().appendByte(aValue);
                                 
                 if (this.stack().length() > this.maxStackLengthBeforeHashing()) {
                         this.setStack(Clipperz.Crypto.SHA.sha_d256(this.stack()));
                 }
         },
         
         //-------------------------------------------------------------------------
         __syntaxFix__: "syntax fix"
 });
 
 //#############################################################################
 
 Clipperz.Crypto.PRNG.RandomnessSource = function(args) {
         args = args || {};
         MochiKit.Base.bindMethods(this);
 
         this._generator = args.generator || null;
         this._sourceId = args.sourceId || null;
         this._boostMode = args.boostMode || false;
         
         this._nextPoolIndex = 0;
         
         return this;
 }
 
 Clipperz.Crypto.PRNG.RandomnessSource.prototype = MochiKit.Base.update(null, {
 
         'generator': function() {
                 return this._generator;
         },
 
         'setGenerator': function(aValue) {
                 this._generator = aValue;
         },
 
         //-------------------------------------------------------------------------
 
         'boostMode': function() {
                 return this._boostMode;
         },
         
         'setBoostMode': function(aValue) {
                 this._boostMode = aValue;
         },
         
         //-------------------------------------------------------------------------
         
         'sourceId': function() {
                 return this._sourceId;
         },
 
         'setSourceId': function(aValue) {
                 this._sourceId = aValue;
         },
         
         //-------------------------------------------------------------------------
 
         'nextPoolIndex': function() {
                 return this._nextPoolIndex;
         },
         
         'incrementNextPoolIndex': function() {
                 this._nextPoolIndex = ((this._nextPoolIndex + 1) % this.generator().numberOfEntropyAccumulators());
         },
         
         //-------------------------------------------------------------------------
 
         'updateGeneratorWithValue': function(aRandomValue) {
                 if (this.generator() != null) {
                         this.generator().addRandomByte(this.sourceId(), this.nextPoolIndex(), aRandomValue);
                         this.incrementNextPoolIndex();
                 }
         },
         
         //-------------------------------------------------------------------------
         __syntaxFix__: "syntax fix"
 });
 
 //#############################################################################
         
 Clipperz.Crypto.PRNG.TimeRandomnessSource = function(args) {
         args = args || {};
         //MochiKit.Base.bindMethods(this);
 
         this._intervalTime = args.intervalTime || 1000;
         
         Clipperz.Crypto.PRNG.RandomnessSource.call(this, args);
 
         this.collectEntropy();
         return this;
 }
 
 Clipperz.Crypto.PRNG.TimeRandomnessSource.prototype = MochiKit.Base.update(new Clipperz.Crypto.PRNG.RandomnessSource, {
 
         'intervalTime': function() {
                 return this._intervalTime;
         },
         
         //-------------------------------------------------------------------------
 
         'collectEntropy': function() {
                         varnow;
                         varentropyByte;
                 var intervalTime;
                 now = new Date();
                 entropyByte = (now.getTime() & 0xff);
                 
                 intervalTime = this.intervalTime();
                 if (this.boostMode() == true) {
                         intervalTime = intervalTime / 9;
                 }
                 
                 this.updateGeneratorWithValue(entropyByte);
                 setTimeout(this.collectEntropy, intervalTime);
         },
         
         //-------------------------------------------------------------------------
 
         'numberOfRandomBits': function() {
                 return 5;
         },
         
         //-------------------------------------------------------------------------
-
-        'pollingFrequency': function() {
-                return 10;
-        },
-
-        //-------------------------------------------------------------------------
         __syntaxFix__: "syntax fix"
 });
 
 //*****************************************************************************
 
 Clipperz.Crypto.PRNG.MouseRandomnessSource = function(args) {
         args = args || {};
 
         Clipperz.Crypto.PRNG.RandomnessSource.call(this, args);
 
         this._numberOfBitsToCollectAtEachEvent = 4;
         this._randomBitsCollector = 0;
         this._numberOfRandomBitsCollected = 0;
         
         MochiKit.Signal.connect(document, 'onmousemove', this, 'collectEntropy');
 
         return this;
 }
 
 Clipperz.Crypto.PRNG.MouseRandomnessSource.prototype = MochiKit.Base.update(new Clipperz.Crypto.PRNG.RandomnessSource, {
 
         //-------------------------------------------------------------------------
 
         'numberOfBitsToCollectAtEachEvent': function() {
                 return this._numberOfBitsToCollectAtEachEvent;
         },
         
         //-------------------------------------------------------------------------
 
         'randomBitsCollector': function() {
                 return this._randomBitsCollector;
         },
 
         'setRandomBitsCollector': function(aValue) {
                 this._randomBitsCollector = aValue;
         },
 
         'appendRandomBitsToRandomBitsCollector': function(aValue) {
                 var collectedBits;
                 var numberOfRandomBitsCollected;
                 
                 numberOfRandomBitsCollected = this.numberOfRandomBitsCollected();
-                collectetBits = this.randomBitsCollector() | (aValue << numberOfRandomBitsCollected);
-                this.setRandomBitsCollector(collectetBits);
+                collectedBits = this.randomBitsCollector() | (aValue << numberOfRandomBitsCollected);
+                this.setRandomBitsCollector(collectedBits);
                 numberOfRandomBitsCollected += this.numberOfBitsToCollectAtEachEvent();
                 
                 if (numberOfRandomBitsCollected == 8) {
-                        this.updateGeneratorWithValue(collectetBits);
+                        this.updateGeneratorWithValue(collectedBits);
                         numberOfRandomBitsCollected = 0;
                         this.setRandomBitsCollector(0);
                 }
                 
                 this.setNumberOfRandomBitsCollected(numberOfRandomBitsCollected)
         },
         
         //-------------------------------------------------------------------------
 
         'numberOfRandomBitsCollected': function() {
                 return this._numberOfRandomBitsCollected;
         },
 
         'setNumberOfRandomBitsCollected': function(aValue) {
                 this._numberOfRandomBitsCollected = aValue;
         },
 
         //-------------------------------------------------------------------------
 
         'collectEntropy': function(anEvent) {
                 var mouseLocation;
                 var randomBit;
                 var mask;
                 
                 mask = 0xffffffff >>> (32 - this.numberOfBitsToCollectAtEachEvent());
                 
                 mouseLocation = anEvent.mouse().client;
                 randomBit = ((mouseLocation.x ^ mouseLocation.y) & mask);
                 this.appendRandomBitsToRandomBitsCollector(randomBit)
         },
         
         //-------------------------------------------------------------------------
 
         'numberOfRandomBits': function() {
                 return 1;
         },
         
         //-------------------------------------------------------------------------
-
-        'pollingFrequency': function() {
-                return 10;
-        },
-
-        //-------------------------------------------------------------------------
         __syntaxFix__: "syntax fix"
 });
 
 //*****************************************************************************
 
-Clipperz.Crypto.PRNG.KeyboardRandomnessSource = function(args) {
+Clipperz.Crypto.PRNG.CryptoRandomRandomnessSource = function(args) {
         args = args || {};
-        Clipperz.Crypto.PRNG.RandomnessSource.call(this, args);
 
-        this._randomBitsCollector = 0;
-        this._numberOfRandomBitsCollected = 0;
+        this._intervalTime = args.intervalTime || 1000;
+        this._browserCrypto = args.browserCrypto;
         
-        MochiKit.Signal.connect(document, 'onkeypress', this, 'collectEntropy');
+        Clipperz.Crypto.PRNG.RandomnessSource.call(this, args);
 
+        this.collectEntropy();
         return this;
 }
 
-Clipperz.Crypto.PRNG.KeyboardRandomnessSource.prototype = MochiKit.Base.update(new Clipperz.Crypto.PRNG.RandomnessSource, {
+Clipperz.Crypto.PRNG.CryptoRandomRandomnessSource.prototype = MochiKit.Base.update(new Clipperz.Crypto.PRNG.RandomnessSource, {
 
-        //-------------------------------------------------------------------------
-
-        'randomBitsCollector': function() {
-                return this._randomBitsCollector;
-        },
-
-        'setRandomBitsCollector': function(aValue) {
-                this._randomBitsCollector = aValue;
+        'intervalTime': function() {
+                return this._intervalTime;
         },
-
-        'appendRandomBitToRandomBitsCollector': function(aValue) {
-                var collectedBits;
-                var numberOfRandomBitsCollected;
-                
-                numberOfRandomBitsCollected = this.numberOfRandomBitsCollected();
-                collectetBits = this.randomBitsCollector() | (aValue << numberOfRandomBitsCollected);
-                this.setRandomBitsCollector(collectetBits);
-                numberOfRandomBitsCollected ++;
-                
-                if (numberOfRandomBitsCollected == 8) {
-                        this.updateGeneratorWithValue(collectetBits);
-                        numberOfRandomBitsCollected = 0;
-                        this.setRandomBitsCollector(0);
-                }
-                
-                this.setNumberOfRandomBitsCollected(numberOfRandomBitsCollected)
+        
+        'browserCrypto': function () {
+                return this._browserCrypto;
         },
         
         //-------------------------------------------------------------------------
 
-        'numberOfRandomBitsCollected': function() {
-                return this._numberOfRandomBitsCollected;
-        },
-
-        'setNumberOfRandomBitsCollected': function(aValue) {
-                this._numberOfRandomBitsCollected = aValue;
-        },
+        'collectEntropy': function() {
+                        varbytesToCollect;
 
-        //-------------------------------------------------------------------------
+                if (this.boostMode() == true) {
+                        bytesToCollect = 64;
+                } else {
+                        bytesToCollect = 8;
+                }
 
-        'collectEntropy': function(anEvent) {
-/*
-                var mouseLocation;
-                var randomBit;
-                
-                mouseLocation = anEvent.mouse().client;
-                        
-                randomBit = ((mouseLocation.x ^ mouseLocation.y) & 0x1);
-                this.appendRandomBitToRandomBitsCollector(randomBit);
-*/
-        },
-        
-        //-------------------------------------------------------------------------
+                var randomValuesArray = new Uint8Array(bytesToCollect);
+                this.browserCrypto().getRandomValues(randomValuesArray);
+                for (var i = 0; i < randomValuesArray.length; i++) {
+                        this.updateGeneratorWithValue(randomValuesArray[i]);
+                }
 
-        'numberOfRandomBits': function() {
-                return 1;
+                setTimeout(this.collectEntropy, this.intervalTime());
         },
         
         //-------------------------------------------------------------------------
-
-        'pollingFrequency': function() {
-                return 10;
-        },
-
-        //-------------------------------------------------------------------------
         __syntaxFix__: "syntax fix"
 });
 
 //#############################################################################
 
 Clipperz.Crypto.PRNG.Fortuna = function(args) {
                 vari,c;
         
         args = args || {};
 
         this._key = args.seed || null;
         if (this._key == null) {
                 this._counter = 0;
                 this._key = new Clipperz.ByteArray();
         } else {
                 this._counter = 1;
         }
         
         this._aesKey = null;
         
         this._firstPoolReseedLevel = args.firstPoolReseedLevel || 32 || 64;
         this._numberOfEntropyAccumulators = args.numberOfEntropyAccumulators || 32;
         
         this._accumulators = [];
         c = this.numberOfEntropyAccumulators();
         for (i=0; i<c; i++) {
                 this._accumulators.push(new Clipperz.Crypto.PRNG.EntropyAccumulator());
         }
 
         this._randomnessSources = [];
         this._reseedCounter = 0;
         
         return this;
 }
 
 Clipperz.Crypto.PRNG.Fortuna.prototype = MochiKit.Base.update(null, {
 
         'toString': function() {
                 return "Clipperz.Crypto.PRNG.Fortuna";
         },
 
         //-------------------------------------------------------------------------
 
         'key': function() {
                 return this._key;
         },
 
         'setKey': function(aValue) {
                 this._key = aValue;
                 this._aesKey = null;
         },
         
         'aesKey': function() {
                 if (this._aesKey == null) {
                         this._aesKey = new Clipperz.Crypto.AES.Key({key:this.key()});
                 }
                 
                 return this._aesKey;
         },
         
         'accumulators': function() {
                 return this._accumulators;
         },
         
         'firstPoolReseedLevel': function() {
                 return this._firstPoolReseedLevel;
         },
         
         //-------------------------------------------------------------------------
 
         'reseedCounter': function() {
                 return this._reseedCounter;
         },
 
         'incrementReseedCounter': function() {
                 this._reseedCounter = this._reseedCounter +1;
         },
 
         //-------------------------------------------------------------------------
 
         'reseed': function() {
                         varnewKeySeed;
                 var reseedCounter;
                         varreseedCounterMask;
                 var i, c;
                 
                 newKeySeed = this.key();
                 this.incrementReseedCounter();
                 reseedCounter = this.reseedCounter();
                 
                 c = this.numberOfEntropyAccumulators();
                 reseedCounterMask = 0xffffffff >>> (32 - c);
                 for (i=0; i<c; i++) {
                         if ((i == 0) || ((reseedCounter & (reseedCounterMask >>> (c - i))) == 0)) {
                                 newKeySeed.appendBlock(this.accumulators()[i].stack());
                                 this.accumulators()[i].resetStack();
                         } 
                 }
                 
                 if (reseedCounter == 1) {
                         c = this.randomnessSources().length;
                         for (i=0; i<c; i++) {
                                 this.randomnessSources()[i].setBoostMode(false);
                         }
                 }
                 
                 this.setKey(Clipperz.Crypto.SHA.sha_d256(newKeySeed));
                 if (reseedCounter == 1) {
 Clipperz.log("### PRNG.readyToGenerateRandomBytes");
                         MochiKit.Signal.signal(this, 'readyToGenerateRandomBytes');
                 }
                 MochiKit.Signal.signal(this, 'reseeded');
         },
         
         //-------------------------------------------------------------------------
 
         'isReadyToGenerateRandomValues': function() {
                 return this.reseedCounter() != 0;
         },
         
         //-------------------------------------------------------------------------
 
         'entropyLevel': function() {
                 return this.accumulators()[0].stack().length() + (this.reseedCounter() * this.firstPoolReseedLevel());
         },
         
         //-------------------------------------------------------------------------
 
         'counter': function() {
                 return this._counter;
         },
         
         'incrementCounter': function() {
                 this._counter += 1;
         },
         
         'counterBlock': function() {
                 var result;
 
                 result = new Clipperz.ByteArray().appendWords(this.counter(), 0, 0, 0);
                 
                 return result;
         },
 
         //-------------------------------------------------------------------------
 
         'getRandomBlock': function() {
                 var result;
 
                 result = new Clipperz.ByteArray(Clipperz.Crypto.AES.encryptBlock(this.aesKey(), this.counterBlock().arrayValues()));
                 this.incrementCounter();
                 
                 return result;
         },
         
         //-------------------------------------------------------------------------
 
         'getRandomBytes': function(aSize) {
                 var result;
 
                 if (this.isReadyToGenerateRandomValues()) {
                         var i,c;
                         var newKey;
                         
                         result = new Clipperz.ByteArray();
                 
                         c = Math.ceil(aSize / (128 / 8));
                         for (i=0; i<c; i++) {
                                 result.appendBlock(this.getRandomBlock());
                         }
 
                         if (result.length() != aSize) {
                                 result = result.split(0, aSize);
                         }
                         
                         newKey = this.getRandomBlock().appendBlock(this.getRandomBlock());
                         this.setKey(newKey);
                 } else {
 Clipperz.logWarning("Fortuna generator has not enough entropy, yet!");
                         throw Clipperz.Crypto.PRNG.exception.NotEnoughEntropy;
                 }
 
                 return result;
         },
 
         //-------------------------------------------------------------------------
 
         'addRandomByte': function(aSourceId, aPoolId, aRandomValue) {
                         varselectedAccumulator;
 
                 selectedAccumulator = this.accumulators()[aPoolId];
                 selectedAccumulator.addRandomByte(aRandomValue);
 
                 if (aPoolId == 0) {
                         MochiKit.Signal.signal(this, 'addedRandomByte')
                         if (selectedAccumulator.stack().length() > this.firstPoolReseedLevel()) {
                                 this.reseed();
                         }
                 }
         },
 
         //-------------------------------------------------------------------------
         
         'numberOfEntropyAccumulators': function() {
                 return this._numberOfEntropyAccumulators;
         },
 
         //-------------------------------------------------------------------------
 
         'randomnessSources': function() {
                 return this._randomnessSources;
         },
         
         'addRandomnessSource': function(aRandomnessSource) {
                 aRandomnessSource.setGenerator(this);
                 aRandomnessSource.setSourceId(this.randomnessSources().length);
                 this.randomnessSources().push(aRandomnessSource);
                 
                 if (this.isReadyToGenerateRandomValues() == false) {
                         aRandomnessSource.setBoostMode(true);
                 }
         },
 
         //-------------------------------------------------------------------------
 
         'deferredEntropyCollection': function(aValue) {
                 var result;
 
 
                 if (this.isReadyToGenerateRandomValues()) {
                         result = aValue;
                 } else {
                         var deferredResult;
 
                         deferredResult = new Clipperz.Async.Deferred("PRNG.deferredEntropyCollection");
                         deferredResult.addCallback(MochiKit.Base.partial(MochiKit.Async.succeed, aValue));
                         MochiKit.Signal.connect(this,
                                                                         'readyToGenerateRandomBytes',
                                                                         deferredResult,
                                                                         'callback');
                                                                         
                         result = deferredResult;
                 }
 
                 return result;
         },
         
         //-------------------------------------------------------------------------
 
         'fastEntropyAccumulationForTestingPurpose': function() {
                 while (! this.isReadyToGenerateRandomValues()) {
                         this.addRandomByte(Math.floor(Math.random() * 32), Math.floor(Math.random() * 32), Math.floor(Math.random() * 256));
                 }
         },
         
         //-------------------------------------------------------------------------
-
+/*
         'dump': function(appendToDoc) {
                 var tbl;
                 var i,c;
                 
                 tbl = document.createElement("table");
                 tbl.border = 0;
                 with (tbl.style) {
                         border = "1px solid lightgrey";
                         fontFamily = 'Helvetica, Arial, sans-serif';
                         fontSize = '8pt';
                         //borderCollapse = "collapse";
                 }
                 var hdr = tbl.createTHead();
                 var hdrtr = hdr.insertRow(0);
                 // document.createElement("tr");
                 {
                         var ntd;
                         
                         ntd = hdrtr.insertCell(0);
                         ntd.style.borderBottom = "1px solid lightgrey";
                         ntd.style.borderRight = "1px solid lightgrey";
                         ntd.appendChild(document.createTextNode("#"));
 
                         ntd = hdrtr.insertCell(1);
                         ntd.style.borderBottom = "1px solid lightgrey";
                         ntd.style.borderRight = "1px solid lightgrey";
                         ntd.appendChild(document.createTextNode("s"));
 
                         ntd = hdrtr.insertCell(2);
                         ntd.colSpan = this.firstPoolReseedLevel();
                         ntd.style.borderBottom = "1px solid lightgrey";
                         ntd.style.borderRight = "1px solid lightgrey";
                         ntd.appendChild(document.createTextNode("base values"));
                         
                         ntd = hdrtr.insertCell(3);
                         ntd.colSpan = 20;
                         ntd.style.borderBottom = "1px solid lightgrey";
                         ntd.appendChild(document.createTextNode("extra values"));
 
                 }
 
                 c = this.accumulators().length;
                 for (i=0; i<c ; i++) {
                                 varcurrentAccumulator;
                         var bdytr;
                         var bdytd;
                         var ii, cc;
 
                         currentAccumulator = this.accumulators()[i]
                         
                         bdytr = tbl.insertRow(true);
                         
                         bdytd = bdytr.insertCell(0);
                         bdytd.style.borderRight = "1px solid lightgrey";
                         bdytd.style.color = "lightgrey";
                         bdytd.appendChild(document.createTextNode("" + i));
 
                         bdytd = bdytr.insertCell(1);
                         bdytd.style.borderRight = "1px solid lightgrey";
                         bdytd.style.color = "gray";
                         bdytd.appendChild(document.createTextNode("" + currentAccumulator.stack().length()));
 
 
                         cc = Math.max(currentAccumulator.stack().length(), this.firstPoolReseedLevel());
                         for (ii=0; ii<cc; ii++) {
                                 var cellText;
                                 
                                 bdytd = bdytr.insertCell(ii + 2);
                                 
                                 if (ii < currentAccumulator.stack().length()) {
                                         cellText = Clipperz.ByteArray.byteToHex(currentAccumulator.stack().byteAtIndex(ii));
                                 } else {
                                         cellText = "_";
                                 }
                                 
                                 if (ii == (this.firstPoolReseedLevel() - 1)) {
                                         bdytd.style.borderRight = "1px solid lightgrey";
                                 }
                                 
                                 bdytd.appendChild(document.createTextNode(cellText));
                         }
                         
                 }
                 
 
                 if (appendToDoc) {
                         var ne = document.createElement("div");
                         ne.id = "entropyGeneratorStatus";
                         with (ne.style) {
                                 fontFamily = "Courier New, monospace";
                                 fontSize = "12px";
                                 lineHeight = "16px";
                                 borderTop = "1px solid black";
                                 padding = "10px";
                         }
                         if (document.getElementById(ne.id)) {
                                 MochiKit.DOM.swapDOM(ne.id, ne);
                         } else {
                                 document.body.appendChild(ne);
                         }
                         ne.appendChild(tbl);
                 }
 
                 return tbl;
         },
-
+*/
         //-----------------------------------------------------------------------------
         __syntaxFix__: "syntax fix"
 });
 
 //#############################################################################
 
 Clipperz.Crypto.PRNG.Random = function(args) {
         args = args || {};
         //MochiKit.Base.bindMethods(this);
 
         return this;
 }
 
 Clipperz.Crypto.PRNG.Random.prototype = MochiKit.Base.update(null, {
 
         'toString': function() {
                 return "Clipperz.Crypto.PRNG.Random";
         },
 
         //-------------------------------------------------------------------------
 
         'getRandomBytes': function(aSize) {
 //Clipperz.Profile.start("Clipperz.Crypto.PRNG.Random.getRandomBytes");
                         varresult;
                 var i,c;
                 
                 result = new Clipperz.ByteArray()
                 c = aSize || 1;
                 for (i=0; i<c; i++) {
                         result.appendByte((Math.random()*255) & 0xff);
                 }
                 
 //Clipperz.Profile.stop("Clipperz.Crypto.PRNG.Random.getRandomBytes");
                 return result;
         },
 
         //-------------------------------------------------------------------------
         __syntaxFix__: "syntax fix"
 });
 
 //#############################################################################
 
-_clipperz_crypt_prng_defaultPRNG = null;
+var _clipperz_crypt_prng_defaultPRNG = null;
 
 Clipperz.Crypto.PRNG.defaultRandomGenerator = function() {
         if (_clipperz_crypt_prng_defaultPRNG == null) {
                 _clipperz_crypt_prng_defaultPRNG = new Clipperz.Crypto.PRNG.Fortuna();
 
                 //.............................................................
                 //
                         //      TimeRandomnessSource
                 //
                 //.............................................................
                 {
                         var newRandomnessSource;
                 
                         newRandomnessSource = new Clipperz.Crypto.PRNG.TimeRandomnessSource({intervalTime:111});
                         _clipperz_crypt_prng_defaultPRNG.addRandomnessSource(newRandomnessSource);
                 }
 
                 //.............................................................
                 //
                         //      MouseRandomnessSource
                 //
                 //.............................................................
                 {
                                 varnewRandomnessSource;
                         
                         newRandomnessSource = new Clipperz.Crypto.PRNG.MouseRandomnessSource();
                         _clipperz_crypt_prng_defaultPRNG.addRandomnessSource(newRandomnessSource);
                 }
 
                 //.............................................................
                 //
-                        //      KeyboardRandomnessSource
+                        //      CryptoRandomRandomnessSource
                 //
                 //.............................................................
                 {
                                 varnewRandomnessSource;
+                                varbrowserCrypto;
                         
-                        newRandomnessSource = new Clipperz.Crypto.PRNG.KeyboardRandomnessSource();
-                        _clipperz_crypt_prng_defaultPRNG.addRandomnessSource(newRandomnessSource);
+                        if (window.crypto && window.crypto.getRandomValues) {
+                                browserCrypto = window.crypto;
+                        } else if (window.msCrypto && window.msCrypto.getRandomValues) {
+                                browserCrypto = window.msCrypto;
+                        } else {
+                                browserCrypto = null;
+                        }
+        
+                        if (browserCrypto != null) {
+                                newRandomnessSource = new Clipperz.Crypto.PRNG.CryptoRandomRandomnessSource({'browserCrypto':browserCrypto});
+                                _clipperz_crypt_prng_defaultPRNG.addRandomnessSource(newRandomnessSource);
+                        }
                 }
-
         }
 
         return _clipperz_crypt_prng_defaultPRNG;
 };
 
 //#############################################################################
 
 Clipperz.Crypto.PRNG.exception =  {
         NotEnoughEntropy: new MochiKit.Base.NamedError("Clipperz.Crypto.PRNG.exception.NotEnoughEntropy") 
 };
 
 
 MochiKit.DOM.addLoadEvent(Clipperz.Crypto.PRNG.defaultRandomGenerator);
diff --git a/frontend/gamma/js/Clipperz/Crypto/SRP.js b/frontend/gamma/js/Clipperz/Crypto/SRP.js
index 597e72d..6898dfb 100644
--- a/frontend/gamma/js/Clipperz/Crypto/SRP.js
+++ b/frontend/gamma/js/Clipperz/Crypto/SRP.js
@@ -1,316 +1,345 @@
 /*
 
 Copyright 2008-2013 Clipperz Srl
 
 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 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 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. If not, see http://www.gnu.org/licenses/.
 
 */
 
 try { if (typeof(Clipperz.ByteArray) == 'undefined') { throw ""; }} catch (e) {
         throw "Clipperz.Crypto.PRNG depends on Clipperz.ByteArray!";
 }  
 
 try { if (typeof(Clipperz.Crypto.BigInt) == 'undefined') { throw ""; }} catch (e) {
         throw "Clipperz.Crypto.SRP depends on Clipperz.Crypto.BigInt!";
 }  
 
 try { if (typeof(Clipperz.Crypto.PRNG) == 'undefined') { throw ""; }} catch (e) {
         throw "Clipperz.Crypto.SRP depends on Clipperz.Crypto.PRNG!";
 }  
 
 if (typeof(Clipperz.Crypto.SRP) == 'undefined') { Clipperz.Crypto.SRP = {}; }
 
 Clipperz.Crypto.SRP.VERSION = "0.1";
 Clipperz.Crypto.SRP.NAME = "Clipperz.Crypto.SRP";
 
 //#############################################################################
 
 MochiKit.Base.update(Clipperz.Crypto.SRP, {
 
         '_n': null,
         '_g': null,
+        '_k': null,
+        
         //-------------------------------------------------------------------------
 
         'n': function() {
                 if (Clipperz.Crypto.SRP._n == null) {
                          Clipperz.Crypto.SRP._n = new Clipperz.Crypto.BigInt("115b8b692e0e045692cf280b436735c77a5a9e8a9e7ed56c965f87db5b2a2ece3", 16);
                 }
                 
                 return Clipperz.Crypto.SRP._n;
         },
 
         //-------------------------------------------------------------------------
 
         'g': function() {
                 if (Clipperz.Crypto.SRP._g == null) {
                                 Clipperz.Crypto.SRP._g = new Clipperz.Crypto.BigInt(2);         //eventually 5 (as suggested on the Diffi-Helmann documentation)
                 }
                 
                 return Clipperz.Crypto.SRP._g;
         },
 
+        'k': function() {
+                if (Clipperz.Crypto.SRP._k == null) {
+        //              Clipperz.Crypto.SRP._k = new Clipperz.Crypto.BigInt(this.stringHash(this.n().asString() + this.g().asString()), 16);
+                        Clipperz.Crypto.SRP._k = new Clipperz.Crypto.BigInt("64398bff522814e306a97cb9bfc4364b7eed16a8c17c5208a40a2bad2933c8e", 16);
+                }
+                
+                return Clipperz.Crypto.SRP._k;
+        },
+        
         //-----------------------------------------------------------------------------
 
         'exception': {
                 'InvalidValue': new MochiKit.Base.NamedError("Clipperz.Crypto.SRP.exception.InvalidValue") 
         },
 
         //-------------------------------------------------------------------------
         __syntaxFix__: "syntax fix"
 
 });
 
 //#############################################################################
 //
         //      S R P   C o n n e c t i o n     version 1.0
 //
 //=============================================================================
 Clipperz.Crypto.SRP.Connection = function (args) {
         args = args || {};
 
         this._C = args.C;
         this._P = args.P;
         this.hash = args.hash;
 
         this._a = null;
         this._A = null;
         
         this._s = null;
         this._B = null;
 
         this._x = null;
         
         this._u = null;
         this._K = null;
         this._M1 = null;
         this._M2 = null;
         
         this._sessionKey = null;
 
         return this;
 }
 
 Clipperz.Crypto.SRP.Connection.prototype = MochiKit.Base.update(null, {
 
         'toString': function () {
                 return "Clipperz.Crypto.SRP.Connection (username: " + this.username() + "). Status: " + this.statusDescription();
         },
 
         //-------------------------------------------------------------------------
 
         'C': function () {
                 return this._C;
         },
 
         //-------------------------------------------------------------------------
 
         'P': function () {
                 return this._P;
         },
 
         //-------------------------------------------------------------------------
 
         'a': function () {
                 if (this._a == null) {
                         this._a = new Clipperz.Crypto.BigInt(Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(32).toHexString().substring(2), 16);
         //              this._a = new Clipperz.Crypto.BigInt("37532428169486597638072888476611365392249575518156687476805936694442691012367", 10);
                 }
                 
                 return this._a;
         },
 
         //-------------------------------------------------------------------------
 
         'A': function () {
                 if (this._A == null) {
-                                //Warning: this value should be strictly greater than zero: how should we perform this check?
+                                //Warning: this value should be strictly greater than zero
                         this._A = Clipperz.Crypto.SRP.g().powerModule(this.a(), Clipperz.Crypto.SRP.n());
-                        
-                        if (this._A.equals(0)) {
+                        if (this._A.equals(0) || negative(this._A)) {
                                 Clipperz.logError("Clipperz.Crypto.SRP.Connection: trying to set 'A' to 0.");
                                 throw Clipperz.Crypto.SRP.exception.InvalidValue;
                         }
                 }
                 
                 return this._A;
         },
 
         //-------------------------------------------------------------------------
 
         's': function () {
                 return this._s;
         },
 
         'set_s': function(aValue) {
                 this._s = aValue;
         },
         
         //-------------------------------------------------------------------------
 
         'B': function () {
                 return this._B;
         },
 
         'set_B': function(aValue) {
-                        //Warning: this value should be strictly greater than zero: how should we perform this check?
-                if (! aValue.equals(0)) {
-                        this._B = aValue;
-                } else {
+                        //Warning: this value should be strictly greater than zero
+                this._B = aValue;
+                if (this._B.equals(0) || negative(this._B)) {
                         Clipperz.logError("Clipperz.Crypto.SRP.Connection: trying to set 'B' to 0.");
                         throw Clipperz.Crypto.SRP.exception.InvalidValue;
                 }
         },
         
         //-------------------------------------------------------------------------
 
         'x': function () {
                 if (this._x == null) {
                         this._x = new Clipperz.Crypto.BigInt(this.stringHash(this.s().asString(16, 64) + this.P()), 16);
                 }
                 
                 return this._x;
         },
 
         //-------------------------------------------------------------------------
 
         'u': function () {
                 if (this._u == null) {
-                        this._u = new Clipperz.Crypto.BigInt(this.stringHash(this.B().asString()), 16);
+                        this._u = new Clipperz.Crypto.BigInt(this.stringHash(this.A().asString() + this.B().asString()), 16);
                 }
                 
                 return this._u;
         },
 
         //-------------------------------------------------------------------------
 
         'S': function () {
                 if (this._S == null) {
                         var bigint;
                                 varsrp;
 
                         bigint = Clipperz.Crypto.BigInt;
                                 srp =  Clipperz.Crypto.SRP;
 
                                 this._S =bigint.powerModule(
-                                                                bigint.subtract(this.B(), bigint.powerModule(srp.g(), this.x(), srp.n())),
-                                                                bigint.add(this.a(), bigint.multiply(this.u(), this.x())),
-                                                                srp.n()
+                                                        bigint.subtract(
+                                                                this.B(),
+                                                                bigint.multiply(
+                                                                        Clipperz.Crypto.SRP.k(),
+                                                                        bigint.powerModule(srp.g(), this.x(), srp.n())
+                                                                )
+                                                        ),
+                                                        bigint.add(this.a(), bigint.multiply(this.u(), this.x())),
+                                                        srp.n()
                                                 )
                 }
                 
                 return this._S;
         },
 
         //-------------------------------------------------------------------------
 
         'K': function () {
                 if (this._K == null) {
                         this._K = this.stringHash(this.S().asString());
                 }
                 
                 return this._K;
         },
 
         //-------------------------------------------------------------------------
 
         'M1': function () {
                 if (this._M1 == null) {
-                        this._M1 = this.stringHash(this.A().asString(10) + this.B().asString(10) + this.K());
+        //              this._M1 = this.stringHash(this.A().asString(10) + this.B().asString(10) + this.K());
+
+                                //http://srp.stanford.edu/design.html
+                                //User -> Host:  M = H(H(N) xor H(g), H(I), s, A, B, K)
+
+                        this._M1 = this.stringHash(
+                                "597626870978286801440197562148588907434001483655788865609375806439877501869636875571920406529" +
+                                this.stringHash(this.C()) +
+                                this.s().asString() +
+                                this.A().asString() +
+                                this.B().asString() +
+                                this.K()
+                        );
+//console.log("M1", this._M1);
                 }
                 
                 return this._M1;
         },
 
         //-------------------------------------------------------------------------
 
         'M2': function () {
                 if (this._M2 == null) {
                         this._M2 = this.stringHash(this.A().asString(10) + this.M1() + this.K());
+//console.log("M2", this._M2);
                 }
                 
                 return this._M2;
         },
 
         //=========================================================================
 
         'serverSideCredentialsWithSalt': function(aSalt) {
                 var result;
                 var s, x, v;
                 
                 s = aSalt;
                 x = this.stringHash(s + this.P());
                 v = Clipperz.Crypto.SRP.g().powerModule(new Clipperz.Crypto.BigInt(x, 16), Clipperz.Crypto.SRP.n());
 
                 result = {};
                 result['C'] = this.C();
                 result['s'] = s;
                 result['v'] = v.asString(16);
                 
                 return result;
         },
         
         'serverSideCredentials': function() {
                 var result;
                 var s;
                 
                 s = Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(32).toHexString().substring(2);
 
                 result = this.serverSideCredentialsWithSalt(s);
                 
                 return result;
         },
         
         //=========================================================================
 /*
         'computeServerSide_S': function(b) {
                 var result;
                 var v;
                 var bigint;
                         varsrp;
 
                 bigint = Clipperz.Crypto.BigInt;
                         srp =  Clipperz.Crypto.SRP;
 
                 v = new Clipperz.Crypto.BigInt(srpConnection.serverSideCredentialsWithSalt(this.s().asString(16, 64)).v, 16);
         //      _S =  (this.A().multiply(this.v().modPow(this.u(), this.n()))).modPow(this.b(), this.n());
                 result = bigint.powerModule(
                                         bigint.multiply(
                                                 this.A(),
                                                 bigint.powerModule(v, this.u(), srp.n())
                                         ), new Clipperz.Crypto.BigInt(b, 10), srp.n()
                                 );
 
                 return result;
         },
 */
         //=========================================================================
 
         'stringHash': function(aValue) {
                         varresult;
 
                 result = this.hash(new Clipperz.ByteArray(aValue)).toHexString().substring(2);
                 
                 return result;
         },
         
         //=========================================================================
         __syntaxFix__: "syntax fix"
         
 });
 
 //#############################################################################
diff --git a/frontend/gamma/js/Clipperz/PM/Proxy/Proxy.Offline.DataStore.js b/frontend/gamma/js/Clipperz/PM/Proxy/Proxy.Offline.DataStore.js
index b806cb7..e5f68a8 100644
--- a/frontend/gamma/js/Clipperz/PM/Proxy/Proxy.Offline.DataStore.js
+++ b/frontend/gamma/js/Clipperz/PM/Proxy/Proxy.Offline.DataStore.js
@@ -1,788 +1,803 @@
 /*
 
 Copyright 2008-2013 Clipperz Srl
 
 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 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 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. If not, see http://www.gnu.org/licenses/.
 
 */
 
 try { if (typeof(Clipperz.PM.Proxy.Offline) == 'undefined') { throw ""; }} catch (e) {
         throw "Clipperz.PM.Proxy.Offline.DataStore depends on Clipperz.PM.Proxy.Offline!";
 }  
 
 //=============================================================================
 
 Clipperz.PM.Proxy.Offline.DataStore = function(args) {
         args = args || {};
         
         this._data = args.data || (typeof(_clipperz_dump_data_) != 'undefined' ? _clipperz_dump_data_ : null);
         this._isReadOnly = (typeof(args.readOnly) == 'undefined' ? true : args.readOnly);
         this._shouldPayTolls = args.shouldPayTolls || false;
 
         this._tolls = {};
         this._currentStaticConnection = null;
-        
+
         return this;
 }
 
 Clipperz.Base.extend(Clipperz.PM.Proxy.Offline.DataStore, Object, {
 
         //-------------------------------------------------------------------------
 
         'isReadOnly': function () {
                 return this._isReadOnly;
         },
         
         //-------------------------------------------------------------------------
 
         'shouldPayTolls': function() {
                 return this._shouldPayTolls;
         },
 
         //-------------------------------------------------------------------------
 
         'data': function () {
                 return this._data;
         },
 
         //-------------------------------------------------------------------------
 
         'tolls': function () {
                 return this._tolls;
         },
 
         //=========================================================================
 
         'resetData': function() {
                 this._data = {
                         'users': {
                                 'catchAllUser': {
                                         __masterkey_test_value__: 'masterkey',
                                         s: '112233445566778899aabbccddeeff00112233445566778899aabbccddeeff00',
                                         v: '112233445566778899aabbccddeeff00112233445566778899aabbccddeeff00'
                                 }
                         }
                 };
         },
 
         //-------------------------------------------------------------------------
 
         'setupWithEncryptedData': function(someData) {
                 this._data = Clipperz.Base.deepClone(someData);
         },
 
         //-------------------------------------------------------------------------
 
         'setupWithData': function(someData) {
                 var deferredResult;
                 var resultData;
                 var i, c;
 
 //Clipperz.log(">>> Proxy.Test.setupWithData");
                 resultData = this._data;
 
                 deferredResult = new Clipperz.Async.Deferred("Proxy.Test.seupWithData", {trace:false});
                 c = someData['users'].length;
 
                 for (i=0; i<c; i++) {
                                 varnewConnection;
                                 varrecordConfiguration;
 
                         deferredResult.addMethod(this, 'userSerializedEncryptedData', someData['users'][i]);
                         deferredResult.addCallback(MochiKit.Base.bind(function(aUserSerializationContext) {
                                 resultData['users'][aUserSerializationContext['credentials']['C']] = {
                                                 's':    aUserSerializationContext['credentials']['s'],
                                                 'v':    aUserSerializationContext['credentials']['v'],
                                                 'version':                      aUserSerializationContext['data']['connectionVersion'],
                                                 'userDetails':          aUserSerializationContext['encryptedData']['user']['header'],
                                                 'userDetailsVersion':aUserSerializationContext['encryptedData']['user']['version'],
                                                 'statistics':           aUserSerializationContext['encryptedData']['user']['statistics'],
                                                 'lock':                                 aUserSerializationContext['encryptedData']['user']['lock'],
                                                 'records':                      this.rearrangeRecordsData(aUserSerializationContext['encryptedData']['records'])
                                 }
                         }, this));
                 }
                 
                 deferredResult.addCallback(MochiKit.Base.bind(function() {
                         this._data = resultData;
                 }, this));
                 
                 deferredResult.callback();
 //Clipperz.log("<<< Proxy.Test.setupWithData");
 
                 return deferredResult;
         },
 
         //=========================================================================
 
         'getTollForRequestType': function (aRequestType) {
                         varresult;
                         vartargetValue;
                 var cost;
                 
                 targetValue = Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(32).toHexString().substring(2);
                 switch (aRequestType) {
                         case 'REGISTER':
                                 cost = 5;
                                 break;
                         case 'CONNECT':
                                 cost = 5;
                                 break;
                         case 'MESSAGE':
                                 cost = 2;
                                 break;
                 }
                 
                 result = {
                                 requestType: aRequestType,
                                 targetValue: targetValue,
                                 cost: cost
                 }
 
                 if (this.shouldPayTolls()) {
                         this.tolls()[targetValue] = result;
                 }
 
                 return result;
         },
 
         //-------------------------------------------------------------------------
 
         'checkToll': function (aFunctionName, someParameters) {
                 if (this.shouldPayTolls()) {
                         var localToll;
                                 vartollParameters;
                         
                         tollParameters = someParameters['toll'];
                         localToll = this.tolls()[tollParameters['targetValue']];
                         
                         if (localToll != null) {
                                 if (! Clipperz.PM.Toll.validate(tollParameters['targetValue'], tollParameters['toll'], localToll['cost'])) {
                                         throw "Toll value too low.";
                                 };
                         } else {
                                 throw "Missing toll";
                         }
                 }
         },
 
         //=========================================================================
 
         'currentStaticConnection': function () {
                 if (this._currentStaticConnection == null) {
                         this._currentStaticConnection = {};
                 }
                 
                 return this._currentStaticConnection;
         },
 
         //-------------------------------------------------------------------------
 
         'getConnectionForRequest': function (aFunctionName, someParameters) {
                         varresult;
 
                 if (this.shouldPayTolls()) {
                         if ((typeof(someParameters['toll']) != 'undefined') && (typeof(someParameters['toll']['targetValue']) != 'undefined')) {
                                 result = this.tolls()[someParameters['toll']['targetValue']]['connection'];
                                 if (typeof(result) == 'undefined') {
                                         result = {};
                                 }
                         } else {
                                 result = {};
                         }
                 } else {
                         result = this.currentStaticConnection();
                 }
 
                 return result;
         },
 
         //-------------------------------------------------------------------------
 
         'storeConnectionForRequestWithConnectionAndResponse': function (aFunctionName, someParameters, aConnection, aResponse) {
                 if (this.shouldPayTolls()) {
                         if ((typeof(aResponse['toll']) != 'undefined')
                                  &&(typeof(aResponse['toll']['targetValue']) != 'undefined')
                                  &&(typeof(this.tolls()[aResponse['toll']['targetValue']]) != 'undefined')
                         ) {
                                 this.tolls()[aResponse['toll']['targetValue']]['connection'] = aConnection;
                         }
                 }
         },
 
         //=========================================================================
 
         'processMessage': function (aFunctionName, someParameters) {
                 var result;
                         varconnection;
 
                 connection = this.getConnectionForRequest(aFunctionName, someParameters);
 
                 switch(aFunctionName) {
                         case 'knock':
                                 result = this._knock(connection, someParameters);
                                 break;
                         case 'registration':
                                 this.checkToll(aFunctionName, someParameters);
                                 result = this._registration(connection, someParameters.parameters);
                                 break;
                         case 'handshake':
                                 this.checkToll(aFunctionName, someParameters);
                                 result = this._handshake(connection, someParameters.parameters);
                                 break;
                         case 'message':
                                 this.checkToll(aFunctionName, someParameters);
                                 result = this._message(connection, someParameters.parameters);
                                 break;
                         case 'logout':
                                 this._currentStaticConnection = null;
                                 result = this._logout(connection, someParameters.parameters);
                                 break;
                 }
 
                 this.storeConnectionForRequestWithConnectionAndResponse(aFunctionName, someParameters, connection, result);
 
                 return MochiKit.Async.succeed(result);
         },
 
         //=========================================================================
 
         '_knock': function(aConnection, someParameters) {
                 var result;
                 
                 result = {
                         toll: this.getTollForRequestType(someParameters['requestType'])
                 }
                 
                 return result;
         },
 
         //-------------------------------------------------------------------------
 
         '_registration': function(aConnection, someParameters) {
                 if (this.isReadOnly() == false) {
                         if (typeof(this.data()['users'][someParameters['credentials']['C']]) == 'undefined') {
                                 this.data()['users'][someParameters['credentials']['C']] = {
                                                 's':    someParameters['credentials']['s'],
                                                 'v':    someParameters['credentials']['v'],
                                                 'version':someParameters['credentials']['version'],
         //                                      'lock':         Clipperz.Crypto.Base.generateRandomSeed(),
                                                 'userDetails':          someParameters['user']['header'],
                                                 'statistics':           someParameters['user']['statistics'],
                                                 'userDetailsVersion':someParameters['user']['version'],
                                                 'records':{}
                                 }
                         } else {
                                 throw "user already exists";
                         }
                 } else {
-                        throw Clipperz.PM.Proxy.Offline.DataStore.exception.ReadOnly;
+                throw Clipperz.PM.Proxy.Offline.DataStore.exception.ReadOnly;
                 }
 
                 result = {
                         result: {
                                         'lock':         this.data()['users'][someParameters['credentials']['C']]['lock'],
                                         'result':'done'
-                        },
+        },
                         toll:   this.getTollForRequestType('CONNECT')
                 }
 
                 return result;
         },
 
         //-------------------------------------------------------------------------
 
         '_handshake': function(aConnection, someParameters) {
                 var result;
                         varnextTollRequestType;
 
                 result = {};
                 if (someParameters.message == "connect") {
                         var userData;
                         var randomBytes;
                         var v;
 
                         userData = this.data()['users'][someParameters.parameters.C];
                         
                         if ((typeof(userData) != 'undefined') && (userData['version'] == someParameters.version)) {
                                 aConnection['userData'] = userData;
                                 aConnection['C'] = someParameters.parameters.C;
                         } else {
                                 aConnection['userData'] = this.data()['users']['catchAllUser'];
                         }
 
                         randomBytes = Clipperz.Crypto.Base.generateRandomSeed();
                         aConnection['b'] = new Clipperz.Crypto.BigInt(randomBytes, 16);
                         v = new Clipperz.Crypto.BigInt(aConnection['userData']['v'], 16);
-                        aConnection['B'] = v.add(Clipperz.Crypto.SRP.g().powerModule(aConnection['b'], Clipperz.Crypto.SRP.n()));
+                        aConnection['B'] = (Clipperz.Crypto.SRP.k().multiply(v)).add(Clipperz.Crypto.SRP.g().powerModule(aConnection['b'], Clipperz.Crypto.SRP.n()));
                         
                         aConnection['A'] = someParameters.parameters.A;
                         
                         result['s'] = aConnection['userData']['s'];
                         result['B'] = aConnection['B'].asString(16);
                         
                         nextTollRequestType = 'CONNECT';
                 } else if (someParameters.message == "credentialCheck") {
-                        var v, u, S, A, K, M1;
-                        
+                        var v, u, s, S, A, K, M1;
+                        var stringHash = function (aValue) {
+                                return Clipperz.PM.Crypto.encryptingFunctions.versions[someParameters.version].hash(new Clipperz.ByteArray(aValue)).toHexString().substring(2);
+                        };
+
                         v = new Clipperz.Crypto.BigInt(aConnection['userData']['v'], 16);
-                        u = new Clipperz.Crypto.BigInt(Clipperz.PM.Crypto.encryptingFunctions.versions[someParameters.version].hash(new Clipperz.ByteArray(aConnection['B'].asString(10))).toHexString(), 16);
                         A = new Clipperz.Crypto.BigInt(aConnection['A'], 16);
+                        u = new Clipperz.Crypto.BigInt(Clipperz.PM.Crypto.encryptingFunctions.versions[someParameters.version].hash(new Clipperz.ByteArray(A.asString(10) + aConnection['B'].asString(10))).toHexString(), 16);
+                        s = new Clipperz.Crypto.BigInt(aConnection['userData']['s'], 16);
                         S = (A.multiply(v.powerModule(u, Clipperz.Crypto.SRP.n()))).powerModule(aConnection['b'], Clipperz.Crypto.SRP.n());
 
-                        K = Clipperz.PM.Crypto.encryptingFunctions.versions[someParameters.version].hash(new Clipperz.ByteArray(S.asString(10))).toHexString().slice(2);
+                        K = stringHash(S.asString(10));
 
-                        M1 = Clipperz.PM.Crypto.encryptingFunctions.versions[someParameters.version].hash(new Clipperz.ByteArray(A.asString(10) + aConnection['B'].asString(10) + K)).toHexString().slice(2);
+                        M1 = stringHash(
+                                "597626870978286801440197562148588907434001483655788865609375806439877501869636875571920406529" +
+                                stringHash(aConnection['C']) +
+                                s.asString(10) +
+                                A.asString(10) +
+                                aConnection['B'].asString(10) +
+                                K
+                        );
                         if (someParameters.parameters.M1 == M1) {
                                 var M2;
                                 
-                                M2 = Clipperz.PM.Crypto.encryptingFunctions.versions[someParameters.version].hash(new Clipperz.ByteArray(A.asString(10) + someParameters.parameters.M1 + K)).toHexString().slice(2);
+                                M2 = stringHash(
+                                        A.asString(10) +
+                                        someParameters.parameters.M1 +
+                                        K
+                                );
                                 result['M2'] = M2;
                         } else {
                                 throw new Error("Client checksum verification failed! Expected <" + M1 + ">, received <" + someParameters.parameters.M1 + ">.", "Error");
                         }
 
                         nextTollRequestType = 'MESSAGE';
                 } else if (someParameters.message == "oneTimePassword") {
                         var otpData;
                         
                         otpData = this.data()['onetimePasswords'][someParameters.parameters.oneTimePasswordKey];
 
                         try {
                                 if (typeof(otpData) != 'undefined') {
                                         if (otpData['status'] == 'ACTIVE') {
                                                 if (otpData['key_checksum'] == someParameters.parameters.oneTimePasswordKeyChecksum) {
                                                         result = {
                                                                         'data':         otpData['data'],
                                                                         'version':otpData['version']
                                                         }
 
                                                         otpData['status'] = 'REQUESTED';
                                                 } else {
                                                         otpData['status'] = 'DISABLED';
                                                         throw "The requested One Time Password has been disabled, due to a wrong keyChecksum";
                                                 }
                                         } else {
                                                 throw "The requested One Time Password was not active";
                                         }
                                 } else {
                                         throw "The requested One Time Password has not been found"
                                 }
                         } catch (exception) {
                                 result = {
                                                 'data':         Clipperz.PM.Crypto.randomKey(),
                                                 'version':Clipperz.PM.Connection.communicationProtocol.currentVersion
                                 }
                         }
                         nextTollRequestType = 'CONNECT';
                 } else {
                         Clipperz.logError("Clipperz.PM.Proxy.Test.handshake - unhandled message: " + someParameters.message);
                 }
 
                 result = {
                         result: result,
                         toll:   this.getTollForRequestType(nextTollRequestType)
                 }
 
                 return result;
         },
 
         //-------------------------------------------------------------------------
 
         '_message': function(aConnection, someParameters) {
                 var result;
 
                 result = {};
 
                 //=====================================================================
                 //
                         //              R       E       A       D       -       O       N       L       Y       M e t h o d s
                 //
                 //=====================================================================
                 if (someParameters.message == 'getUserDetails') {
                         var recordsStats;
                         var recordReference;
 
                         recordsStats = {};
                         for (recordReference in aConnection['userData']['records']) {
                                 recordsStats[recordReference] = {
                                         'updateDate': aConnection['userData']['records'][recordReference]['updateDate']
                                 }
                         }
 
                         result['header'] =  this.userDetails(aConnection);
                         result['statistics'] = this.statistics(aConnection);
                         result['maxNumberOfRecords'] = aConnection['userData']['maxNumberOfRecords'];
                         result['version'] = aConnection['userData']['userDetailsVersion'];
                         result['recordsStats'] = recordsStats;
                         
                         if (this.isReadOnly() == false) {
                                         varlock;
                                 
                                 if (typeof(aConnection['userData']['lock']) == 'undefined') {
                                         aConnection['userData']['lock'] = "<<LOCK>>";
                                 }
                                 
                                 result['lock'] = aConnection['userData']['lock'];
                         }
 
                 //=====================================================================
                 } else if (someParameters.message == 'getRecordDetail') {
 /*
                                 varrecordData;
                         var currentVersionData;
                         
                         recordData = this.userData()['records'][someParameters['parameters']['reference']];
                         result['reference'] = someParameters['parameters']['reference'];
                         result['data'] = recordData['data'];
                         result['version'] = recordData['version'];
                         result['creationData'] = recordData['creationDate'];
                         result['updateDate'] = recordData['updateDate'];
                         result['accessDate'] = recordData['accessDate'];
 
                         currentVersionData = recordData['versions'][recordData['currentVersion']];
 
                         result['currentVersion'] = {};
                         result['currentVersion']['reference'] = recordData['currentVersion'];
                         result['currentVersion']['version'] = currentVersionData['version'];
                         result['currentVersion']['header'] = currentVersionData['header'];
                         result['currentVersion']['data'] = currentVersionData['data'];
                         result['currentVersion']['creationData'] = currentVersionData['creationDate'];
                         result['currentVersion']['updateDate'] = currentVersionData['updateDate'];
                         result['currentVersion']['accessDate'] = currentVersionData['accessDate'];
                         if (typeof(currentVersionData['previousVersion']) != 'undefined') {
                                 result['currentVersion']['previousVersionKey'] = currentVersionData['previousVersionKey'];
                                 result['currentVersion']['previousVersion'] = currentVersionData['previousVersion'];
                         }
 */
                         MochiKit.Base.update(result, aConnection['userData']['records'][someParameters['parameters']['reference']]);
                         result['reference'] = someParameters['parameters']['reference'];
 
                 //=====================================================================
                 //
                         //              R       E       A       D       -       W       R       I       T       E       M e t h o d s
                 //
                 //=====================================================================
                 } else if (someParameters.message == 'upgradeUserCredentials') {
                         if (this.isReadOnly() == false) {
                                 var parameters;
                                 var credentials;
 
                                 parameters = someParameters['parameters'];
                                 credentials = parameters['credentials'];
 
                                 if ((credentials['C'] == null)
                                         ||(credentials['s'] == null)
                                         ||(credentials['v'] == null)
                                         ||(credentials['version'] != Clipperz.PM.Connection.communicationProtocol.currentVersion)
                                 ) {
                                         result = Clipperz.PM.DataModel.User.exception.CredentialUpgradeFailed;
                                 } else {
                                                 varoldCValue;
                                         oldCValue = aConnection['C'];
 
                                         this.data()['users'][credentials['C']] = aConnection['userData'];
                                         aConnection['C'] = credentials['C'];
 
                                         aConnection['userData']['s'] = credentials['s'];
                                         aConnection['userData']['v'] = credentials['v'];
                                         aConnection['userData']['version'] = credentials['version'];
 
                                         aConnection['userData']['userDetails'] = parameters['user']['header'];
                                         aConnection['userData']['userDetailsVersion'] = parameters['user']['version'];
                                         aConnection['userData']['statistics'] = parameters['user']['statistics'];
 
                                         aConnection['userData']['lock'] = parameters['user']['lock'];
                                         
                                         delete this.data()['users'][oldCValue];
 
                                         result = {result:"done", parameters:parameters};
                                 }
                         } else {
                                 throw Clipperz.PM.Proxy.Offline.DataStore.exception.ReadOnly;
                         }
                 //=====================================================================
         /*      } else if (someParameters.message == 'updateData') {
                         if (this.isReadOnly() == false) {
                                 var i, c;
 
                                         if (this.userData()['lock']!= someParameters['parameters']['user']['lock']) {
                                         throw "the lock attribute is not processed correctly"
                                 }
 
                                         this.userData()['userDetails']          = someParameters['parameters']['user']['header'];
                                         this.userData()['statistics']           = someParameters['parameters']['user']['statistics'];
                                         this.userData()['userDetailsVersions']= someParameters['parameters']['user']['version'];
 
                                 c = someParameters['parameters']['records'].length;
                                 for (i=0; i<c; i++) {
                                         var currentRecord;
                                         var currentRecordData;
 
                                         currentRecordData = someParameters['parameters']['records'][i];
                                         currentRecord = this.userData()['records'][currentRecordData['record']['reference']];
                                         
                                         if (currentRecord == null) {
                                         }
                                         
                                         currentRecord['data'] = currentRecordData['record']['data'];
                                         currentRecord['version'] = currentRecordData['record']['version'];
                                         currentRecord['currentVersion'] = currentRecordData['currentRecordVersion']['reference'];
                                         
                                         currentRecord['versions'][currentRecordData['currentRecordVersion']['reference']] = {
                                                         'data':                                 currentRecordData['currentRecordVersion']['data'],
                                                         'version':                      currentRecordData['currentRecordVersion']['version'],
                                                         'previousVersion':      currentRecordData['currentRecordVersion']['previousVersion'],
                                                         'previousVersionKey':currentRecordData['currentRecordVersion']['previousVersionKey']
                                         }
                                 }
 
                                 this.userData()['lock'] = Clipperz.PM.Crypto.randomKey();
                                 result['lock'] = this.userData()['lock'];
                                 result['result'] = 'done';
                         } else {
                                 throw Clipperz.PM.Proxy.Offline.DataStore.exception.ReadOnly;
                         }
         */      //=====================================================================
                 } else if (someParameters.message == 'saveChanges') {
                         if (this.isReadOnly() == false) {
                                 var i, c;
 
                                         if (aConnection['userData']['lock']!= someParameters['parameters']['user']['lock']) {
                                         throw "the lock attribute is not processed correctly"
                                 }
 
                                         aConnection['userData']['userDetails']          = someParameters['parameters']['user']['header'];
                                         aConnection['userData']['statistics']           = someParameters['parameters']['user']['statistics'];
                                         aConnection['userData']['userDetailsVersion']= someParameters['parameters']['user']['version'];
 
                                 c = someParameters['parameters']['records']['updated'].length;
                                 for (i=0; i<c; i++) {
                                         var currentRecord;
                                         var currentRecordData;
 
                                         currentRecordData = someParameters['parameters']['records']['updated'][i];
                                         currentRecord = aConnection['userData']['records'][currentRecordData['record']['reference']];
 
                                         if (
                                                 (typeof(aConnection['userData']['records'][currentRecordData['record']['reference']]) == 'undefined')
                                                 &&
                                                 (typeof(currentRecordData['currentRecordVersion']) == 'undefined')
                                         ) {
                                                 throw "Record added without a recordVersion";
                                         }
 
                                         if (currentRecord == null) {
                                                 currentRecord = {};
                                                 currentRecord['versions'] = {};
                                                         currentRecord['creationDate']= Clipperz.PM.Date.formatDateWithUTCFormat(new Date());
                                                         currentRecord['accessDate']     = Clipperz.PM.Date.formatDateWithUTCFormat(new Date());
 
                                                 aConnection['userData']['records'][currentRecordData['record']['reference']] = currentRecord;
                                         }
                                         
                                                 currentRecord['data']   = currentRecordData['record']['data'];
                                                 currentRecord['version']= currentRecordData['record']['version'];
                                                 currentRecord['updateDate']= Clipperz.PM.Date.formatDateWithUTCFormat(new Date());
 
                                         if (typeof(currentRecordData['currentRecordVersion']) != 'undefined') {
                                                 currentRecord['currentVersion'] = currentRecordData['currentRecordVersion']['reference'];
                                                 currentRecord['versions'][currentRecordData['currentRecordVersion']['reference']] = {
                                                                 'data':                                 currentRecordData['currentRecordVersion']['data'],
                                                                 'version':                      currentRecordData['currentRecordVersion']['version'],
                                                                 'previousVersion':      currentRecordData['currentRecordVersion']['previousVersion'],
                                                                 'previousVersionKey':currentRecordData['currentRecordVersion']['previousVersionKey'],
                                                                 'creationDate':Clipperz.PM.Date.formatDateWithUTCFormat(new Date()),
                                                                 'updateDate':Clipperz.PM.Date.formatDateWithUTCFormat(new Date()),
                                                                 'accessDate':Clipperz.PM.Date.formatDateWithUTCFormat(new Date())
                                                 }
                                         }
                                 }
 
                                 c = someParameters['parameters']['records']['deleted'].length;
                                 for (i=0; i<c; i++) {
                                         var currentRecordReference;
 
                                         currentRecordReference = someParameters['parameters']['records']['deleted'][i];
                                         delete aConnection['userData']['records'][currentRecordReference];
                                 }
 
                                 aConnection['userData']['lock'] = Clipperz.PM.Crypto.randomKey();
                                 result['lock'] = aConnection['userData']['lock'];
                                 result['result'] = 'done';
                         } else {
                                 throw Clipperz.PM.Proxy.Offline.DataStore.exception.ReadOnly;
                         }
 
                 //=====================================================================
                 //
                         //              U       N       H       A       N       D       L       E       D       M e t h o d
                 //
                 //=====================================================================
                 } else {
                         Clipperz.logError("Clipperz.PM.Proxy.Test.message - unhandled message: " + someParameters.message);
                 }
         
                 result = {
                         result: result,
                         toll:   this.getTollForRequestType('MESSAGE')
                 }
 
         //      return MochiKit.Async.succeed(result);
                 return result;
         },
 
         //-------------------------------------------------------------------------
 
         '_logout': function(someParameters) {
         //      return MochiKit.Async.succeed({result: 'done'});
                 return {result: 'done'};
         },
 
         //=========================================================================
         //#########################################################################
 
         'isTestData': function(aConnection) {
                 return (typeof(aConnection['userData']['__masterkey_test_value__']) != 'undefined');
         },
 
         'userDetails': function(aConnection) {
                 var result;
                 
                 if (this.isTestData(aConnection)) {
                         var serializedHeader;
                         var version;
 
 //Clipperz.logDebug("### test data");
                         version = aConnection['userData']['userDetailsVersion'];
                         serializedHeader = Clipperz.Base.serializeJSON(aConnection['userData']['userDetails']);
                         result = Clipperz.PM.Crypto.encryptingFunctions.versions[version].encrypt(aConnection['userData']['__masterkey_test_value__'], serializedHeader);
                 } else {
 //Clipperz.logDebug("### NOT test data");
                         result = aConnection['userData']['userDetails'];
                 }
                 
                 return result;
         },
         
         'statistics': function(aConnection) {
                 var result;
 
                 if (aConnection['userData']['statistics'] != null) {
                         if (this.isTestData(aConnection)) {
                                 var serializedStatistics;
                                 var version;
 
                                 version = aConnection['userData']['userDetailsVersion'];
                                 serializedStatistics = Clipperz.Base.serializeJSON(aConnection['userData']['statistics']);
                                 result = Clipperz.PM.Crypto.encryptingFunctions.versions[version].encrypt(aConnection['userData']['__masterkey_test_value__'], serializedStatistics);
                         } else {
                                  result = aConnection['userData']['statistics'];
                         }
                 } else {
                         result = null;
                 }
                 
                 return result;
         },
 
 /*
         'userSerializedEncryptedData': function(someData) {
                 var deferredResult;
                 var deferredContext;
                 
                 deferredContext = { 'data': someData };
                 
                 deferredResult = new Clipperz.Async.Deferred('Proxy.Test.serializeUserEncryptedData', {trace:false});
                 deferredResult.addCallback(MochiKit.Base.bind(function(aDeferredContext) {
                         aDeferredContext['user'] = this.createUserUsingConfigurationData(aDeferredContext['data']);
                         return aDeferredContext;
                 }, this));
                 deferredResult.addCallback(function(aDeferredContext) {
         //              return aDeferredContext['user'].encryptedDataUsingVersion(aDeferredContext['data']['version']);
                         return aDeferredContext['user'].serializedDataUsingVersion(MochiKit.Base.values(aDeferredContext['user'].records()), aDeferredContext['data']['version']);
                 });
                 deferredResult.addCallback(function(aUserEncryptedData) {
                         deferredContext['encryptedData'] = aUserEncryptedData;
                         return deferredContext;
                 });
                 deferredResult.addCallback(function(aDeferredContext) {
                         var connection;
 
                         connection = new Clipperz.PM.Connection.communicationProtocol.versions[aDeferredContext['data']['connectionVersion']]()
                         aDeferredContext['credentials'] = connection.serverSideUserCredentials(aDeferredContext['user'].username(),aDeferredContext['user'].passphrase());
 
                         return aDeferredContext;
                 });
 
         //      deferredResult.addCallback(function(aDeferredContext) {
         //              return aDeferredContext['user'].serializedDataUsingVersion(MochiKit.Base.values(aDeferredContext['user'].records()), aDeferredContext['data']['version']);
         //      }, deferredContext);
         //      deferredResult.addCallback(function(aUserSerializedData) {
         //      });
 //
         //      deferredResult.addCallback(MochiKit.Async.succeed, deferredContext);
                 deferredResult.callback(deferredContext);
                 
                 return deferredResult;
         },
 
         'createUserUsingConfigurationData': function(someData) {
                 var result;
                 var user;
                 var recordLabel;
 
                 user = new Clipperz.PM.DataModel.User();
                 user.initForTests();
                 user.setUsername(someData['username']);
                 user.setPassphrase(someData['passphrase']);
 
                 for (recordLabel in someData['records']) {
                         var recordData;
                         var record;
                         var i, c;
                         
                         recordData = someData['records'][recordLabel];
                         record = new Clipperz.PM.DataModel.Record({user:user, label:recordLabel});
                         record.setNotes(recordData['notes']);
                         
                         c = recordData['fields'].length;
                         for (i=0; i<c; i++) {
                                 var recordField;
                                 
                                 recordField = new Clipperz.PM.DataModel.RecordField();
                                 recordField.setLabel(recordData['fields'][i]['name']);
                                 recordField.setValue(recordData['fields'][i]['value']);
                                 recordField.setType(recordData['fields'][i]['type']);
                                 record.addField(recordField);
                         }
                         user.addRecord(record, true);
                 }
                 
                 result = user;
                 
                 return result;
         },
 */
         //=========================================================================
         __syntaxFix__: "syntax fix"
 });
 
 Clipperz.PM.Proxy.Offline.DataStore['exception'] = {
                 'ReadOnly':     new MochiKit.Base.NamedError("Clipperz.PM.Proxy.Offline.DataStore.exception.ReadOnly")
 };
\ No newline at end of file