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

3 files changed, 108 insertions, 100 deletions

diff --git a/frontend/delta/js/Clipperz/Crypto/PRNG.js b/frontend/delta/js/Clipperz/Crypto/PRNG.js
index c539f06..80d972f 100644
--- a/frontend/delta/js/Clipperz/Crypto/PRNG.js
+++ b/frontend/delta/js/Clipperz/Crypto/PRNG.js
@@ -12,24 +12,26 @@ refer to http://www.clipperz.com.
   (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!";
 }  
 
@@ -188,30 +190,24 @@ Clipperz.Crypto.PRNG.TimeRandomnessSource.prototype = MochiKit.Base.update(new C
                 
                 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;
@@ -236,30 +232,30 @@ Clipperz.Crypto.PRNG.MouseRandomnessSource.prototype = MochiKit.Base.update(new
                 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;
         },
@@ -280,114 +276,72 @@ Clipperz.Crypto.PRNG.MouseRandomnessSource.prototype = MochiKit.Base.update(new
                 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) {
@@ -626,25 +580,25 @@ Clipperz.logWarning("Fortuna generator has not enough entropy, yet!");
                 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";
                 }
@@ -732,25 +686,25 @@ Clipperz.logWarning("Fortuna generator has not enough entropy, yet!");
                                 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;
 }
@@ -775,25 +729,25 @@ Clipperz.Crypto.PRNG.Random.prototype = MochiKit.Base.update(null, {
                 }
                 
 //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;
@@ -807,34 +761,44 @@ Clipperz.Crypto.PRNG.defaultRandomGenerator = function() {
                         //      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") 
 };
 
 
diff --git a/frontend/delta/js/Clipperz/Crypto/SRP.js b/frontend/delta/js/Clipperz/Crypto/SRP.js
index 597e72d..6898dfb 100644
--- a/frontend/delta/js/Clipperz/Crypto/SRP.js
+++ b/frontend/delta/js/Clipperz/Crypto/SRP.js
@@ -35,44 +35,55 @@ try { if (typeof(Clipperz.Crypto.PRNG) == 'undefined') { throw ""; }} catch (e)
 
 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"
 
 });
 
 //#############################################################################
@@ -129,28 +140,27 @@ Clipperz.Crypto.SRP.Connection.prototype = MochiKit.Base.update(null, {
                 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;
@@ -158,98 +168,117 @@ Clipperz.Crypto.SRP.Connection.prototype = MochiKit.Base.update(null, {
 
         '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;
diff --git a/frontend/delta/js/Clipperz/PM/Proxy/Proxy.Offline.LocalStorageDataStore.js b/frontend/delta/js/Clipperz/PM/Proxy/Proxy.Offline.LocalStorageDataStore.js
index 3f16f70..d03f873 100644
--- a/frontend/delta/js/Clipperz/PM/Proxy/Proxy.Offline.LocalStorageDataStore.js
+++ b/frontend/delta/js/Clipperz/PM/Proxy/Proxy.Offline.LocalStorageDataStore.js
@@ -79,47 +79,62 @@ Clipperz.Base.extend(Clipperz.PM.Proxy.Offline.LocalStorageDataStore, Clipperz.P
                         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 {