Fixed authentication procedure for offline copy

1 files changed, 21 insertions, 6 deletions

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
@@ -1,209 +1,224 @@
 /*
 
 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.DataStore) == 'undefined') { throw ""; }} catch (e) {
         throw "Clipperz.PM.Proxy.Offline.LocalStorageDataStore depends on Clipperz.PM.Proxy.Offline.DataStore!";
 }  
 
 //=============================================================================
 
 Clipperz.PM.Proxy.Offline.LocalStorageDataStore = function(args) {
         args = args || {};
         
         //this._data = args.data || (typeof(_clipperz_dump_data_) != 'undefined' ? _clipperz_dump_data_ : null);
         this._data = JSON.parse(localStorage.getItem('clipperz_dump_data'));
 
         this._isReadOnly = (typeof(args.readOnly) == 'undefined' ? true : args.readOnly);
         this._shouldPayTolls = args.shouldPayTolls || false;
 
         this._tolls = {};
         this._currentStaticConnection = null;
 
         //Clipperz.PM.Proxy.Offline.LocalStorageDataStore.superclass.constructor.apply(this, arguments);
         
         return this;
 }
 
 Clipperz.Base.extend(Clipperz.PM.Proxy.Offline.LocalStorageDataStore, Clipperz.PM.Proxy.Offline.DataStore, {
 
         //=========================================================================
 
         '_knock': function(aConnection, someParameters) {
                 var result;
                 
                 result = {
                         toll: this.getTollForRequestType(someParameters['requestType'])
                 }
                 
                 return result;
         },
 
         //-------------------------------------------------------------------------
 
         '_registration': function(aConnection, someParameters) {
                 throw Clipperz.PM.Proxy.Offline.DataStore.exception.ReadOnly;
         },
 
         //-------------------------------------------------------------------------
 
         '_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']];