Fixed an issue on the AES-CTR block mode

The previous version of the CTR encoding was incrementing the counter in a weird way, mixing up data from the previous block.
The current fix can correctly decrypt data encoded with AES-CTR using other libraries/languages (currently tested only with Python).

5 files changed, 924 insertions, 38 deletions

diff --git a/frontend/gamma/js/Clipperz/Crypto/AES_2.js b/frontend/gamma/js/Clipperz/Crypto/AES_2.js
new file mode 100644
index 0000000..1627f39
--- a/dev/null
+++ b/frontend/gamma/js/Clipperz/Crypto/AES_2.js
@@ -0,0 +1,843 @@
+/*
+
+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.AES_2 depends on Clipperz.ByteArray!";
+}  
+
+//	Dependency commented to avoid a circular reference
+//try { if (typeof(Clipperz.Crypto.PRNG) == 'undefined') { throw ""; }} catch (e) {
+//	throw "Clipperz.Crypto.AES_2 depends on Clipperz.Crypto.PRNG!";
+//}  
+
+if (typeof(Clipperz.Crypto.AES_2) == 'undefined') { Clipperz.Crypto.AES_2 = {}; }
+
+//#############################################################################
+
+Clipperz.Crypto.AES_2.DeferredExecutionContext = function(args) {
+	args = args || {};
+
+	this._key = args.key;
+	this._message = args.message;
+	this._result = args.message.clone();
+	this._nonce = args.nonce;
+	this._messageLength = this._message.length();
+	
+	this._messageArray = this._message.arrayValues();
+	this._resultArray = this._result.arrayValues();
+	this._nonceArray = this._nonce.arrayValues();
+	
+	this._executionStep = 0;
+	
+//	this._elaborationChunkSize = 1024;	//	4096;	//	16384;	//	4096;
+	this._elaborationChunks = 10;
+	this._pauseTime = 0.02;				//	0.02	//	0.2;
+
+	return this;
+}
+
+Clipperz.Crypto.AES_2.DeferredExecutionContext.prototype = MochiKit.Base.update(null, {
+
+	'key': function() {
+		return this._key;
+	},
+	
+	'message': function() {
+		return this._message;
+	},
+	
+	'messageLength': function() {
+		return this._messageLength;
+	},
+	
+	'result': function() {
+		return new Clipperz.ByteArray(this.resultArray());
+	},
+	
+	'nonce': function() {
+		return this._nonce;
+	},
+
+	'messageArray': function() {
+		return this._messageArray;
+	},
+	
+	'resultArray': function() {
+		return this._resultArray;
+	},
+	
+	'nonceArray': function() {
+		return this._nonceArray;
+	},
+
+	'elaborationChunkSize': function() {
+//		return Clipperz.Crypto.AES_2.DeferredExecution.chunkSize;
+//		return this._elaborationChunkSize;
+		return (this._elaborationChunks * 1024);
+	},
+	
+	'executionStep': function() {
+		return this._executionStep;
+	},
+	
+	'setExecutionStep': function(aValue) {
+		this._executionStep = aValue;
+	},
+	
+	'tuneExecutionParameters': function (anElapsedTime) {
+//var originalChunks = this._elaborationChunks;
+		if (anElapsedTime > 0) {
+			this._elaborationChunks = Math.round(this._elaborationChunks * ((anElapsedTime + 1000)/(anElapsedTime * 2)));
+		}
+//Clipperz.log("tuneExecutionParameters - elapsedTime: " +  anElapsedTime + /*originalChunks,*/ " chunks # " + this._elaborationChunks + " [" + this._executionStep + " / " + this._messageLength + "]");
+	},
+	
+	'pause': function(aValue) {
+//		return MochiKit.Async.wait(Clipperz.Crypto.AES_2.DeferredExecution.pauseTime, aValue);
+		return MochiKit.Async.wait(this._pauseTime, aValue);
+	},
+	
+	'isDone': function () {
+		return (this._executionStep >= this._messageLength);
+	},
+
+	//-----------------------------------------------------------------------------
+	__syntaxFix__: "syntax fix"
+
+});
+
+//#############################################################################
+
+Clipperz.Crypto.AES_2.Key = function(args) {
+	args = args || {};
+
+	this._key = args.key;
+	this._keySize = args.keySize || this.key().length();
+	
+	if (this.keySize() == 128/8) {
+		this._b = 176;
+		this._numberOfRounds = 10;
+ 	} else if (this.keySize() == 256/8) {
+		this._b = 240;
+		this._numberOfRounds = 14;
+	} else {
+		Clipperz.logError("AES unsupported key size: " + (this.keySize() * 8) + " bits");
+		throw Clipperz.Crypto.AES_2.exception.UnsupportedKeySize;
+	}
+	
+	this._stretchedKey = null;
+	
+	return this;
+}
+
+Clipperz.Crypto.AES_2.Key.prototype = MochiKit.Base.update(null, {
+
+	'asString': function() {
+		return "Clipperz.Crypto.AES_2.Key (" + this.key().toHexString() + ")";
+	},
+	
+	//-----------------------------------------------------------------------------
+
+	'key': function() {
+		return this._key;
+	},
+
+	'keySize': function() {
+		return this._keySize;
+	},
+	
+	'b': function() {
+		return this._b;
+	},
+	
+	'numberOfRounds': function() {
+		return this._numberOfRounds;
+	},
+	//=========================================================================
+
+	'keyScheduleCore': function(aWord, aRoundConstantsIndex) {
+		var	result;
+		var sbox;
+
+		sbox = Clipperz.Crypto.AES_2.sbox();
+
+		result = [	sbox[aWord[1]] ^ Clipperz.Crypto.AES_2.roundConstants()[aRoundConstantsIndex],
+					sbox[aWord[2]],
+					sbox[aWord[3]],
+					sbox[aWord[0]]	];
+
+		return result;
+	},
+
+	//-----------------------------------------------------------------------------
+
+	'xorWithPreviousStretchValues': function(aKey, aWord, aPreviousWordIndex) {
+		var	result;
+		var i,c;
+		
+		result = [];
+		c = 4;
+		for (i=0; i<c; i++) {
+			result[i] = aWord[i] ^ aKey.byteAtIndex(aPreviousWordIndex + i);
+		}
+		
+		return result;
+	},
+
+	//-----------------------------------------------------------------------------
+
+	'sboxShakeup': function(aWord) {
+		var result;
+		var sbox;
+		var i,c;
+		
+		result = [];
+		sbox = Clipperz.Crypto.AES_2.sbox();
+		c =4;
+		for (i=0; i<c; i++) {
+			result[i] = sbox[aWord[i]];
+		}
+		
+		return result;
+	},
+
+	//-----------------------------------------------------------------------------
+
+	'stretchKey': function(aKey) {
+		var	currentWord;
+		var	keyLength;
+		var	previousStretchIndex;
+		var i,c;
+		
+		keyLength = aKey.length();
+		previousStretchIndex = keyLength - this.keySize();
+
+		currentWord = [	aKey.byteAtIndex(keyLength - 4),
+						aKey.byteAtIndex(keyLength - 3),
+						aKey.byteAtIndex(keyLength - 2),
+						aKey.byteAtIndex(keyLength - 1)	];
+		currentWord = this.keyScheduleCore(currentWord, keyLength / this.keySize());
+
+		if (this.keySize() == 256/8) {
+			c = 8;
+		} else if (this.keySize() == 128/8){
+			c = 4;
+		}
+		
+		for (i=0; i<c; i++) {
+			if (i == 4) {
+				//	fifth streatch word
+				currentWord = this.sboxShakeup(currentWord);
+			}
+
+			currentWord = this.xorWithPreviousStretchValues(aKey, currentWord, previousStretchIndex + (i*4));
+			aKey.appendBytes(currentWord);
+		}
+
+		return aKey;
+	},
+
+	//-----------------------------------------------------------------------------
+
+	'stretchedKey': function() {
+		if (this._stretchedKey == null) {
+			var stretchedKey;
+			
+			stretchedKey = this.key().clone();
+
+			while (stretchedKey.length() < this.keySize()) {
+				stretchedKey.appendByte(0);
+			}
+
+			while (stretchedKey.length() < this.b()) {
+				stretchedKey = this.stretchKey(stretchedKey);
+			}
+			
+			this._stretchedKey = stretchedKey.split(0, this.b());
+		}
+		
+		return this._stretchedKey;
+	},
+
+	//=========================================================================
+	__syntaxFix__: "syntax fix"
+});
+
+//#############################################################################
+
+Clipperz.Crypto.AES_2.State = function(args) {
+	args = args || {};
+
+	this._data = args.block.slice(0);
+	this._key = args.key;
+	
+	return this;
+}
+
+Clipperz.Crypto.AES_2.State.prototype = MochiKit.Base.update(null, {
+
+	'key': function() {
+		return this._key;
+	},
+	
+	//-----------------------------------------------------------------------------
+
+	'data': function() {
+		return this._data;
+	},
+
+	'setData': function(aValue) {
+		this._data = aValue;
+	},
+
+	//=========================================================================
+
+	'addRoundKey': function(aRoundNumber) {
+	 	//	each byte of the state is combined with the round key; each round key is derived from the cipher key using a key schedule.
+		var	data;
+		var	stretchedKey;
+		var	firstStretchedKeyIndex;
+		var i,c;
+
+		data = this.data();
+		stretchedKey = this.key().stretchedKey();
+		firstStretchedKeyIndex = aRoundNumber * (128/8);
+		c = 128/8;
+		for (i=0; i<c; i++) {
+			data[i] = data[i] ^ stretchedKey.byteAtIndex(firstStretchedKeyIndex + i);
+		}
+	},
+	
+	//-----------------------------------------------------------------------------
+
+	'subBytes': function() {
+		//	 a non-linear substitution step where each byte is replaced with another according to a lookup table.
+		var i,c;
+		var	data;
+		var sbox;
+		
+		data = this.data();
+		sbox = Clipperz.Crypto.AES_2.sbox();
+		
+		c = 16;
+		for (i=0; i<c; i++) {
+			data[i] = sbox[data[i]];
+		}
+	},
+
+	//-----------------------------------------------------------------------------
+
+	'shiftRows': function() {
+		//	a transposition step where each row of the state is shifted cyclically a certain number of steps.
+		var	newValue;
+		var	data;
+		var	shiftMapping;
+		var	i,c;
+		
+		newValue = new Array(16);
+		data = this.data();
+		shiftMapping = Clipperz.Crypto.AES_2.shiftRowMapping();
+//		[0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, 1, 6, 11];
+		c = 16;
+		for (i=0; i<c; i++) {
+			newValue[i] = data[shiftMapping[i]];
+		}
+		for (i=0; i<c; i++) {
+			data[i] = newValue[i];
+		}
+	},
+
+	//-----------------------------------------------------------------------------
+/*
+	'mixColumnsWithValues': function(someValues) {
+		var	result;
+		var	a;
+		var i,c;
+		
+		c = 4;
+		result = [];
+		a = [];
+		for (i=0; i<c; i++) {
+			a[i] = [];
+			a[i][1] = someValues[i]
+			if ((a[i][1] & 0x80) == 0x80) {
+				a[i][2] = (a[i][1] << 1) ^ 0x11b;
+			} else {
+				a[i][2] = a[i][1] << 1;
+			}
+			
+			a[i][3] = a[i][2] ^ a[i][1];
+		}
+	
+		for (i=0; i<c; i++) {
+			var	x;
+
+			x = Clipperz.Crypto.AES_2.mixColumnsMatrix()[i];
+			result[i] = a[0][x[0]] ^ a[1][x[1]] ^ a[2][x[2]] ^ a[3][x[3]];
+		}
+
+		return result;
+	},
+	
+	'mixColumns': function() {
+		//	a mixing operation which operates on the columns of the state, combining the four bytes in each column using a linear transformation.
+		var data;
+		var i, c;
+		
+		data = this.data();
+		c = 4;
+		for(i=0; i<c; i++) {
+			var	blockIndex;
+			var mixedValues;
+			
+			blockIndex = i * 4;
+			mixedValues = this.mixColumnsWithValues([	data[blockIndex + 0],
+														data[blockIndex + 1],
+														data[blockIndex + 2],
+														data[blockIndex + 3]]);
+			data[blockIndex + 0] = mixedValues[0];
+			data[blockIndex + 1] = mixedValues[1];
+			data[blockIndex + 2] = mixedValues[2];
+			data[blockIndex + 3] = mixedValues[3];
+		}
+	},
+*/
+
+	'mixColumns': function() {
+		//	a mixing operation which operates on the columns of the state, combining the four bytes in each column using a linear transformation.
+		var data;
+		var i, c;
+		var a_1;
+		var a_2;
+
+		a_1 = new Array(4);
+		a_2 = new Array(4);
+		
+		data = this.data();
+		c = 4;
+		for(i=0; i<c; i++) {
+			var	blockIndex;
+			var ii, cc;
+			
+			blockIndex = i * 4;
+
+			cc = 4;
+			for (ii=0; ii<cc; ii++) {
+				var value;
+				
+				value = data[blockIndex + ii];
+				a_1[ii] = value;
+				a_2[ii] = (value & 0x80) ? ((value << 1) ^ 0x011b) : (value << 1);
+			}
+
+			data[blockIndex + 0] = a_2[0] ^ a_1[1] ^ a_2[1] ^ a_1[2] ^ a_1[3];
+			data[blockIndex + 1] = a_1[0] ^ a_2[1] ^ a_1[2] ^ a_2[2] ^ a_1[3];
+			data[blockIndex + 2] = a_1[0] ^ a_1[1] ^ a_2[2] ^ a_1[3] ^ a_2[3];
+			data[blockIndex + 3] = a_1[0] ^ a_2[0] ^ a_1[1] ^ a_1[2] ^ a_2[3];
+		}
+	},
+
+	//=========================================================================
+	
+	'spinRound': function(aRoundNumber) {
+		this.addRoundKey(aRoundNumber);
+		this.subBytes();
+		this.shiftRows();
+		this.mixColumns();
+	},
+
+	'spinLastRound': function() {
+		this.addRoundKey(this.key().numberOfRounds() - 1);
+		this.subBytes();
+		this.shiftRows();
+		this.addRoundKey(this.key().numberOfRounds());
+	},
+
+	//=========================================================================
+
+	'encrypt': function() {
+		var	i,c;
+
+		c = this.key().numberOfRounds() - 1;
+		for (i=0; i<c; i++) {
+			this.spinRound(i);
+		}
+
+		this.spinLastRound();
+	},
+	
+	//=========================================================================
+	__syntaxFix__: "syntax fix"
+});
+
+//#############################################################################
+
+Clipperz.Crypto.AES_2.VERSION = "0.1";
+Clipperz.Crypto.AES_2.NAME = "Clipperz.Crypto.AES_2";
+
+MochiKit.Base.update(Clipperz.Crypto.AES_2, {
+
+//	http://www.cs.eku.edu/faculty/styer/460/Encrypt/JS-AES.html
+//	http://en.wikipedia.org/wiki/Advanced_Encryption_Standard
+//	http://en.wikipedia.org/wiki/Rijndael_key_schedule 
+//	http://en.wikipedia.org/wiki/Rijndael_S-box
+		
+	'__repr__': function () {
+		return "[" + this.NAME + " " + this.VERSION + "]";
+	},
+
+	'toString': function () {
+		return this.__repr__();
+	},
+
+	//=============================================================================
+	
+	'_sbox': null,
+	'sbox': function() {
+		if (Clipperz.Crypto.AES_2._sbox == null) {
+			Clipperz.Crypto.AES_2._sbox = [
+0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
+0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
+0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
+0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
+0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
+0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
+0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
+0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
+0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
+0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
+0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
+0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
+0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
+0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
+0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
+0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
+			];
+		}
+		
+		return Clipperz.Crypto.AES_2._sbox;
+	},
+
+	//-----------------------------------------------------------------------------
+	//
+	//		0	4	8	12				0	4	8	12
+	//		1	5	9	13		=>		5	9	13	1
+	//		2	6	10	14				10	14	2	6
+	//		3	7	11	15				15	3	7	11
+	//
+	'_shiftRowMapping': null,
+	'shiftRowMapping': function() {
+		if (Clipperz.Crypto.AES_2._shiftRowMapping == null) {
+			Clipperz.Crypto.AES_2._shiftRowMapping = [0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, 1, 6, 11];
+		}
+		
+		return Clipperz.Crypto.AES_2._shiftRowMapping;
+	},
+
+	//-----------------------------------------------------------------------------
+
+	'_mixColumnsMatrix': null,
+	'mixColumnsMatrix': function() {
+		if (Clipperz.Crypto.AES_2._mixColumnsMatrix == null) {
+			Clipperz.Crypto.AES_2._mixColumnsMatrix = [	[2, 3, 1 ,1],
+														[1, 2, 3, 1],
+														[1, 1, 2, 3],
+														[3, 1, 1, 2]   ];
+		}
+		
+		return Clipperz.Crypto.AES_2._mixColumnsMatrix;
+	},
+
+	'_roundConstants': null,
+	'roundConstants': function() {
+		if (Clipperz.Crypto.AES_2._roundConstants == null) {
+			Clipperz.Crypto.AES_2._roundConstants = [ , 1, 2, 4, 8, 16, 32, 64, 128, 27, 54, 108, 216, 171, 77, 154];
+//			Clipperz.Crypto.AES_2._roundConstants = [ , 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a];
+		}
+		
+		return Clipperz.Crypto.AES_2._roundConstants;
+	},
+	
+	//=============================================================================
+
+	'incrementNonce': function(nonce) {
+		var i;
+		var done;
+
+		done = false;
+		i = nonce.length - 1;
+		
+		while ((i>=0) && (done == false)) {
+			var currentByteValue;
+			
+			currentByteValue = nonce[i];
+			
+			if (currentByteValue == 0xff) {
+				nonce[i] = 0;
+				if (i>= 0) {
+					i --;
+				} else {
+					done = true;
+				}
+			} else {
+				nonce[i] = currentByteValue + 1;
+				done = true;
+			}
+		}
+	},
+	
+	//-----------------------------------------------------------------------------
+
+	'encryptBlock': function(aKey, aBlock) {
+		var	result;
+		var	state;
+
+		state = new Clipperz.Crypto.AES_2.State({block:aBlock, key:aKey});
+//is(state.data(), 'before');
+		state.encrypt();
+		result = state.data(); 
+		
+		return result;
+	},
+
+	//-----------------------------------------------------------------------------
+
+	'encryptBlocks': function(aKey, aMessage, aNonce) {
+		var	result;
+		var nonce;
+		var self;
+		var	messageIndex;
+		var	messageLength;
+		var blockSize;		
+		
+		self = Clipperz.Crypto.AES_2;
+		blockSize = 128/8;
+		messageLength = aMessage.length;
+		nonce = aNonce;
+
+		result = aMessage;
+		messageIndex = 0;
+		while (messageIndex < messageLength) {
+			var encryptedBlock;
+			var i,c;
+
+			encryptedBlock = self.encryptBlock(aKey, nonce);
+			
+			if ((messageLength - messageIndex) > blockSize) {
+				c = blockSize;
+			} else {
+				c = messageLength - messageIndex;
+			}
+			
+			for (i=0; i<c; i++) {
+				result[messageIndex + i] = result[messageIndex + i] ^ encryptedBlock[i];
+			}
+			
+			messageIndex += blockSize;
+//			nonce = self.incrementNonce(nonce);
+			self.incrementNonce(nonce)
+		}
+		
+		return result;
+	},
+	
+	//-----------------------------------------------------------------------------
+
+	'encrypt': function(aKey, someData, aNonce) {
+		var result;
+		var nonce;
+		var	encryptedData;
+		var key;
+
+		key = new Clipperz.Crypto.AES_2.Key({key:aKey});
+		nonce = aNonce ? aNonce.clone() : Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(128/8);
+
+		encryptedData = Clipperz.Crypto.AES_2.encryptBlocks(key, someData.arrayValues(), nonce.arrayValues());
+
+		result = nonce.appendBytes(encryptedData);
+		
+		return result;
+	},
+
+	//-----------------------------------------------------------------------------
+
+	'decrypt': function(aKey, someData) {
+		var result;
+		var nonce;
+		var encryptedData;
+		var decryptedData;
+		var	dataIterator;
+		var key;
+
+		key = new Clipperz.Crypto.AES_2.Key({key:aKey});
+
+		encryptedData = someData.arrayValues();
+		nonce = encryptedData.slice(0, (128/8));
+		encryptedData = encryptedData.slice(128/8);
+		decryptedData = Clipperz.Crypto.AES_2.encryptBlocks(key, encryptedData, nonce);
+
+		result = new Clipperz.ByteArray(decryptedData);
+		
+		return result;
+	},
+	
+	//=============================================================================
+
+	'deferredEncryptExecutionChunk': function(anExecutionContext) {
+		var	result;
+		var nonce;
+		var self;
+		var	messageIndex;
+		var	messageLength;
+		var blockSize;	
+		var executionLimit;
+		var startTime, endTime;
+
+		self = Clipperz.Crypto.AES_2;
+		startTime = new Date();
+		blockSize = 128/8;
+		messageLength = anExecutionContext.messageArray().length;
+		nonce = anExecutionContext.nonceArray();
+		result = anExecutionContext.resultArray();
+
+		messageIndex = anExecutionContext.executionStep();
+		executionLimit = messageIndex + anExecutionContext.elaborationChunkSize();
+		executionLimit = Math.min(executionLimit, messageLength);
+		
+		while (messageIndex < executionLimit) {
+			var encryptedBlock;
+			var i,c;
+			
+//console.log("+++ nonce: [" + nonce + "]")
+			encryptedBlock = self.encryptBlock(anExecutionContext.key(), nonce);
+			
+			if ((executionLimit - messageIndex) > blockSize) {
+				c = blockSize;
+			} else {
+				c = executionLimit - messageIndex;
+			}
+			
+			for (i=0; i<c; i++) {
+				result[messageIndex + i] = result[messageIndex + i] ^ encryptedBlock[i];
+			}
+			
+			messageIndex += blockSize;
+//			nonce = self.incrementNonce(nonce);
+			self.incrementNonce(nonce);
+		}
+		anExecutionContext.setExecutionStep(messageIndex);
+		endTime = new Date();
+		anExecutionContext.tuneExecutionParameters(endTime - startTime);
+		
+		return anExecutionContext;
+	},
+
+	//-----------------------------------------------------------------------------
+
+	'deferredEncryptBlocks': function(anExecutionContext) {
+		var	deferredResult;
+
+//console.log("executionContext", anExecutionContext)
+//console.log(" --- nonce: " + anExecutionContext.nonceArray())
+		if (! anExecutionContext.isDone()) {
+			deferredResult = Clipperz.Async.callbacks("Clipperz.Crypto.AES_2.deferredEncryptBloks", [
+				Clipperz.Crypto.AES_2.deferredEncryptExecutionChunk,
+				MochiKit.Base.method(anExecutionContext, 'pause'),
+				Clipperz.Crypto.AES_2.deferredEncryptBlocks
+			], {trace:false}, anExecutionContext);
+		} else {
+			deferredResult = MochiKit.Async.succeed(anExecutionContext);
+		}
+		
+		return deferredResult;
+	},
+
+	//-----------------------------------------------------------------------------
+	
+	'deferredEncrypt': function(aKey, someData, aNonce) {
+		var deferredResult;
+		var	executionContext;
+		var result;
+		var nonce;
+		var key;
+
+		key = new Clipperz.Crypto.AES_2.Key({key:aKey});
+		nonce = aNonce ? aNonce.clone() : Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(128/8);
+
+		executionContext = new Clipperz.Crypto.AES_2.DeferredExecutionContext({key:key, message:someData, nonce:nonce});
+
+		deferredResult = new Clipperz.Async.Deferred("AES.deferredEncrypt");
+		deferredResult.addCallback(Clipperz.Crypto.AES_2.deferredEncryptBlocks);
+		deferredResult.addCallback(function(anExecutionContext) {
+			var result;
+			
+			result = anExecutionContext.nonce().clone();
+			result.appendBytes(anExecutionContext.resultArray());
+
+			return result;
+		});
+		deferredResult.callback(executionContext)
+
+		return deferredResult;
+	},
+
+	//-----------------------------------------------------------------------------
+
+	'deferredDecrypt': function(aKey, someData) {
+		var deferredResult
+		var nonce;
+		var message;
+		var key;
+
+		key = new Clipperz.Crypto.AES_2.Key({key:aKey});
+		nonce = someData.split(0, (128/8));
+//console.log("nonce: [" + nonce.arrayValues() + "]")
+		message = someData.split(128/8);
+//console.log("message: [" + message.arrayValues() + "]")
+		executionContext = new Clipperz.Crypto.AES_2.DeferredExecutionContext({key:key, message:message, nonce:nonce});
+
+		deferredResult = new Clipperz.Async.Deferred("AES.deferredDecrypt");
+		deferredResult.addCallback(Clipperz.Crypto.AES_2.deferredEncryptBlocks);
+		deferredResult.addCallback(function(anExecutionContext) {
+			return anExecutionContext.result();
+		});
+		deferredResult.callback(executionContext);
+
+		return deferredResult;
+	},
+	
+	//-----------------------------------------------------------------------------
+	__syntaxFix__: "syntax fix"
+	
+});
+
+//#############################################################################
+
+//Clipperz.Crypto.AES_2.DeferredExecution = {
+//	'chunkSize': 16384,	//	4096,	//	1024	4096	8192	16384	32768;
+//	'pauseTime': 0.02	//	0.2
+//}
+
+Clipperz.Crypto.AES_2.exception = {
+	'UnsupportedKeySize':    new MochiKit.Base.NamedError("Clipperz.Crypto.AES_2.exception.UnsupportedKeySize") 
+};
diff --git a/frontend/gamma/js/Clipperz/PM/Crypto.js b/frontend/gamma/js/Clipperz/PM/Crypto.js
index cd10e33..7edf17f 100644
--- a/frontend/gamma/js/Clipperz/PM/Crypto.js
+++ b/frontend/gamma/js/Clipperz/PM/Crypto.js
@@ -1,508 +1,546 @@
 /*
 
 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/.
 
 */
 
 if (typeof(Clipperz) == 'undefined') { Clipperz = {}; }
 if (typeof(Clipperz.PM) == 'undefined') { Clipperz.PM = {}; }
 if (typeof(Clipperz.PM.Crypto) == 'undefined') { Clipperz.PM.Crypto = {}; }
 
 Clipperz.PM.Crypto.VERSION = "0.2";
 Clipperz.PM.Crypto.NAME = "Clipperz.PM.Crypto";
 
 Clipperz.PM.Crypto.encryptingFunctions = {};
 
 MochiKit.Base.update(Clipperz.PM.Crypto, {
 
 	'__repr__': function () {
 		return "[" + this.NAME + " " + this.VERSION + "]";
 	},
 
 	//-------------------------------------------------------------------------
 
 	'toString': function () {
 		return this.__repr__();
 	},
 
 	//-------------------------------------------------------------------------
 /*
 	'communicationProtocol': {
 		'currentVersion': '0.2',
 		'versions': {
 			'0.1': Clipperz.PM.Connection.SRP['1.0'],	//Clipperz.Crypto.SRP.versions['1.0'].Connection,
 			'0.2': Clipperz.PM.Connection.SRP['1.1']	//Clipperz.Crypto.SRP.versions['1.1'].Connection
 		},
 		'fallbackVersions': {
 			'current':	'0.1',
 			'0.2':		'0.1',
 			'0.1':		null
 		}
 	},
 */
 	//-------------------------------------------------------------------------
 
 	'encryptingFunctions': {
-		'currentVersion': '0.3',
+		'currentVersion': '0.4',
 		'versions': {
 
 		//#####################################################################
 
 			'0.1': {
 				'encrypt': function(aKey, aValue) {
 					return Clipperz.Crypto.Base.encryptUsingSecretKey(aKey, Clipperz.Base.serializeJSON(aValue));
 				},
 			
 				'deferredEncrypt': function(aKey, aValue) {
 					var deferredResult;
 					
 					deferredResult = new Clipperz.Async.Deferred("Crypto[0.1].deferredEncrypt");
 					deferredResult.addCallback(Clipperz.PM.Crypto.encryptingFunctions.versions['0.1'].encrypt, aKey, aValue);
 					deferredResult.callback();
 					
 					return deferredResult;
 				},
 				
 				'decrypt': function(aKey, aValue) {
 					var result;
 				
 					if (aValue != null) {
 						result = Clipperz.Base.evalJSON(Clipperz.Crypto.Base.decryptUsingSecretKey(aKey, aValue));
 					} else {
 						result = null;
 					}
 				
 					return result;
 				},
 				
 				'deferredDecrypt': function(aKey, aValue) {
 					var deferredResult;
 					
 					deferredResult = new Clipperz.Async.Deferred("Crypto.[0.1].deferredDecrypt");
 					deferredResult.addCallback(Clipperz.PM.Crypto.encryptingFunctions.versions['0.1'].decrypt, aKey, aValue);
 					deferredResult.callback();
 					
 					return deferredResult;
 				},
 			
 				'hash': function(aValue) {
 					var result;
 					var strngResult;
 				
 					stringResult = Clipperz.Crypto.Base.computeHashValue(aValue.asString());	//	!!!!!!!
 					result = new Clipperz.ByteArray("0x" + stringResult);
 				
 					return result;
 				},
 				
 				'deriveKey': function(aStringValue) {
 					return Clipperz.Crypto.Base.computeHashValue(aStringValue);
 				}
 			},
 
 		//#####################################################################
 
 			'0.2': {
 				'encrypt': function(aKey, aValue, aNonce) {
 					var result;
 					var	key, value;
 					var dataToEncrypt;
 					var encryptedData;
 				
 					key = Clipperz.Crypto.SHA.sha_d256(new Clipperz.ByteArray(aKey));
 					value = new Clipperz.ByteArray(Clipperz.Base.serializeJSON(aValue));
 					dataToEncrypt = Clipperz.Crypto.SHA.sha_d256(value).appendBlock(value);
 					encryptedData = Clipperz.Crypto.AES.encrypt(key, dataToEncrypt, aNonce);
 					result = encryptedData.toBase64String();
 				
 					return result;
 				},
 
 				'deferredEncrypt': function(aKey, aValue, aNonce) {
 					var deferredResult;
 					var	key, value;
 					var dataToEncrypt;
 //					var encryptedData;
 				
 					key = Clipperz.Crypto.SHA.sha_d256(new Clipperz.ByteArray(aKey));
 					value = new Clipperz.ByteArray(Clipperz.Base.serializeJSON(aValue));
 					dataToEncrypt = Clipperz.Crypto.SHA.sha_d256(value).appendBlock(value);
 					
 					deferredResult = new Clipperz.Async.Deferred("Crypto[0.2].deferredEncrypt")
 					deferredResult.addCallback(Clipperz.Crypto.AES.deferredEncrypt, key, dataToEncrypt, aNonce);
 					deferredResult.addCallback(function(aResult) {
 						return aResult.toBase64String();
 					})
 					deferredResult.callback();
 					
 					return deferredResult;
 				},
 			
 				'decrypt': function(aKey, aValue) {
 					var result;
 					
 					if (aValue != null) {
 						var key, value;
 						var decryptedData;
 						var decryptedValue;
 
 						key = Clipperz.Crypto.SHA.sha_d256(new Clipperz.ByteArray(aKey));
 						value = new Clipperz.ByteArray().appendBase64String(aValue);
 				
 						decryptedData = Clipperz.Crypto.AES.decrypt(key, value);
 						decryptedValue = decryptedData.split((256/8));
 
 						try {
 							result = Clipperz.Base.evalJSON(decryptedValue.asString());
 						} catch (exception) {
 							Clipperz.logError("Error while decrypting data [1]");
 							throw Clipperz.Crypto.Base.exception.CorruptedMessage;
 						}
 					} else {
 						result = null;
 					}
 					
 					return result;
 				},
 
 				'deferredDecrypt': function(aKey, aValue) {
 					var result;
 
 					if (aValue != null) {
 						var deferredResult;
 						var key, value;
 //						var decryptedData;
 
 						key = Clipperz.Crypto.SHA.sha_d256(new Clipperz.ByteArray(aKey));
 						value = new Clipperz.ByteArray().appendBase64String(aValue);
 
 						deferredResult = new Clipperz.Async.Deferred("Crypto.[0.2].deferredDecrypt");
 						deferredResult.addCallback(Clipperz.Crypto.AES.deferredDecrypt, key, value);
 						deferredResult.addCallback(function(aResult) {
 							var result;
 							var decryptedData;
 
 							decryptedData = aResult.split((256/8));
 							
 							try {
 								result = Clipperz.Base.evalJSON(decryptedData.asString());
 							} catch (exception) {
 								Clipperz.logError("Error while decrypting data [2]");
 								throw Clipperz.Crypto.Base.exception.CorruptedMessage;
 							}
 
 							return result;
 						})
 						deferredResult.callback();
 						
 						result = deferredResult;
 					} else {
 						result = MochiKit.Async.succeed(null);
 					}
 					
 					return result;
 				},
 			
 				'hash': Clipperz.Crypto.SHA.sha_d256,
 				
 				'deriveKey': function(aStringValue) {
 					var	byteData;
 					var result;
 					
 					byteData = new Clipperz.ByteArray(aStringValue);
 					result = Clipperz.Crypto.SHA.sha_d256(byteData);
 					
 					return result;
 				}
 			},
 
 		//#####################################################################
 
 			'0.3': {
 				'encrypt': function(aKey, aValue, aNonce) {
 					var result;
 					var	key, value;
 					var data;
 					var dataToEncrypt;
 					var encryptedData;
 				
 					key = Clipperz.Crypto.SHA.sha_d256(new Clipperz.ByteArray(aKey));
 					value = Clipperz.Base.serializeJSON(aValue);
 					data = new Clipperz.ByteArray(value);
 					encryptedData = Clipperz.Crypto.AES.encrypt(key, data, aNonce);
 					result = encryptedData.toBase64String();
 				
 					return result;
 				},
 				
 				'deferredEncrypt': function(aKey, aValue, aNonce) {
 					var deferredResult;
 					var	key, value;
 					var data;
 					var dataToEncrypt;
 					var encryptedData;
 				
 					key = Clipperz.Crypto.SHA.sha_d256(new Clipperz.ByteArray(aKey));
 					value = Clipperz.Base.serializeJSON(aValue);
 					data = new Clipperz.ByteArray(value);
 					
 					deferredResult = new Clipperz.Async.Deferred("Crypto[0.3].deferredEncrypt")
 					deferredResult.addCallback(Clipperz.Crypto.AES.deferredEncrypt, key, data, aNonce);
 					deferredResult.addCallback(function(aResult) {
 						return aResult.toBase64String();
 					})
 					deferredResult.callback();
 					
 					return deferredResult;
 				},
 			
 				'decrypt': function(aKey, aValue) {
 					var result;
 					
 					if (aValue != null) {
 						var key, value;
 						var decryptedData;
 
 						key = Clipperz.Crypto.SHA.sha_d256(new Clipperz.ByteArray(aKey));
 						value = new Clipperz.ByteArray().appendBase64String(aValue);
 				
 						decryptedData = Clipperz.Crypto.AES.decrypt(key, value);
 
 						value = decryptedData.asString();
 						try {
 							result = Clipperz.Base.evalJSON(value);
 						} catch (exception) {
 							Clipperz.logError("Error while decrypting data [3]");
 							throw Clipperz.Crypto.Base.exception.CorruptedMessage;
 						}
 					} else {
 						result = null;
 					}
 					
 					return result;
 				},
 			
 				'deferredDecrypt': function(aKey, aValue) {
 					var deferredResult;
 					
 					deferredResult = new Clipperz.Async.Deferred("Crypto[0.3].deferredDecrypt", {trace: false});
 //					now = new Date;
 					
 					if (aValue != null) {
 						var key, value;
 //						var decryptedData;
 
 						key = Clipperz.Crypto.SHA.sha_d256(new Clipperz.ByteArray(aKey));
 						value = new Clipperz.ByteArray().appendBase64String(aValue);
 
 						deferredResult.addCallback(Clipperz.Crypto.AES.deferredDecrypt, key, value);
 						deferredResult.addCallback(MochiKit.Async.wait, 0.1);
 						deferredResult.addCallback(function(aResult) {
 							return aResult.asString();
 						});
 						deferredResult.addCallback(MochiKit.Async.wait, 0.1);
 						deferredResult.addCallback(Clipperz.Base.evalJSON);
 						deferredResult.addErrback(function(anError) {
+console.log("PIPPO_1", anError)
 							Clipperz.logError("Error while decrypting data [4]");
 							throw Clipperz.Crypto.Base.exception.CorruptedMessage;
 						})
 					} else {
 						deferredResult.addCallback(function() {
 							return null;
 						});
 					}
 					deferredResult.callback();
 					
 					return deferredResult;
 				},
 				
 				'hash': Clipperz.Crypto.SHA.sha_d256,
 
 				'deriveKey': function(aStringValue) {
 					var	byteData;
 					var result;
 					
 					byteData = new Clipperz.ByteArray(aStringValue);
 					result = Clipperz.Crypto.SHA.sha_d256(byteData);
 					
 					return result;
 				}
-
 			},
 
 		//#####################################################################
-/*
+
 			'0.4': {
 				'encrypt': function(aKey, aValue, aNonce) {
 					var result;
 					var	key, value;
 					var data;
 					var dataToEncrypt;
 					var encryptedData;
 				
-//Clipperz.logDebug(">>> [" + (new Date()).valueOf() + "] Clipperz.PM.Crypto.versions[0.3].encrypt");
 					key = Clipperz.Crypto.SHA.sha_d256(new Clipperz.ByteArray(aKey));
-//Clipperz.logDebug("--- [" + (new Date()).valueOf() + "] Clipperz.PM.Crypto.versions[0.3].encrypt - 1");
 					value = Clipperz.Base.serializeJSON(aValue);
-//Clipperz.logDebug("--- [" + (new Date()).valueOf() + "] Clipperz.PM.Crypto.versions[0.3].encrypt - 2");
-/ *
-//Clipperz.logDebug("--> encrypt.fullSize: " + value.length);
-					value = value.replace(/":{"label":"/g,		'":{l:"');
-					value = value.replace(/":{"key":"/g,		'":{k:"');
-					value = value.replace(/":{"notes":"/g,		'":{n:"');
-					value = value.replace(/":{"record":"/g,		'":{r:"');
-					value = value.replace(/", "label":"/g,		'",l:"');
-					value = value.replace(/", "favicon":"/g,	'",f:"');
-//Clipperz.logDebug("<-- encrypt.compressed: " + value.length);
-* /
 					data = new Clipperz.ByteArray(value);
-//Clipperz.logDebug("--- [" + (new Date()).valueOf() + "] Clipperz.PM.Crypto.versions[0.3].encrypt - 3");
-					encryptedData = Clipperz.Crypto.AES.encrypt(key, data, aNonce);
-//Clipperz.logDebug("--- [" + (new Date()).valueOf() + "] Clipperz.PM.Crypto.versions[0.3].encrypt - 4");
+					encryptedData = Clipperz.Crypto.AES_2.encrypt(key, data, aNonce);
 					result = encryptedData.toBase64String();
-//Clipperz.logDebug("<<< [" + (new Date()).valueOf() + "] Clipperz.PM.Crypto.versions[0.3].encrypt");
 				
 					return result;
 				},
+				
+				'deferredEncrypt': function(aKey, aValue, aNonce) {
+					var deferredResult;
+					var	key, value;
+					var data;
+					var dataToEncrypt;
+					var encryptedData;
+				
+					key = Clipperz.Crypto.SHA.sha_d256(new Clipperz.ByteArray(aKey));
+					value = Clipperz.Base.serializeJSON(aValue);
+					data = new Clipperz.ByteArray(value);
+					
+					deferredResult = new Clipperz.Async.Deferred("Crypto[0.4].deferredEncrypt")
+					deferredResult.addCallback(Clipperz.Crypto.AES_2.deferredEncrypt, key, data, aNonce);
+					deferredResult.addCallback(function(aResult) {
+						return aResult.toBase64String();
+					})
+					deferredResult.callback();
+					
+					return deferredResult;
+				},
 			
 				'decrypt': function(aKey, aValue) {
 					var result;
 					
 					if (aValue != null) {
 						var key, value;
 						var decryptedData;
 
 						key = Clipperz.Crypto.SHA.sha_d256(new Clipperz.ByteArray(aKey));
 						value = new Clipperz.ByteArray().appendBase64String(aValue);
 				
-						decryptedData = Clipperz.Crypto.AES.decrypt(key, value);
+						decryptedData = Clipperz.Crypto.AES_2.decrypt(key, value);
 
 						value = decryptedData.asString();
-/ *
-						value = value.replace(/":{l:"/g,	'":{"label":"');
-						value = value.replace(/":{k:"/g,	'":{"key":"');
-						value = value.replace(/":{n:"/g,	'":{"notes":"');
-						value = value.replace(/":{r:"/g,	'":{"record":"');
-						value = value.replace(/",l:"/g,		'", "label":"');
-						value = value.replace(/",f:"/g,		'", "favicon":"');
-* /
 						try {
 							result = Clipperz.Base.evalJSON(value);
 						} catch (exception) {
-							Clipperz.logError("Error while decrypting data");
+							console.log("PIPPO_2", anError)
+							Clipperz.logError("Error while decrypting data [4]");
 							throw Clipperz.Crypto.Base.exception.CorruptedMessage;
 						}
-						
-						
 					} else {
 						result = null;
 					}
 					
 					return result;
 				},
 			
-				'hash': Clipperz.Crypto.SHA.sha_d256
+				'deferredDecrypt': function(aKey, aValue) {
+					var deferredResult;
+					
+					deferredResult = new Clipperz.Async.Deferred("Crypto[0.4].deferredDecrypt", {trace: false});
+					
+					if (aValue != null) {
+						var key, value;
+
+						key = Clipperz.Crypto.SHA.sha_d256(new Clipperz.ByteArray(aKey));
+						value = new Clipperz.ByteArray().appendBase64String(aValue);
+
+						deferredResult.addCallback(Clipperz.Crypto.AES_2.deferredDecrypt, key, value);
+						deferredResult.addCallback(MochiKit.Async.wait, 0.1);
+						deferredResult.addCallback(function(aResult) {
+							return aResult.asString();
+						});
+						deferredResult.addCallback(MochiKit.Async.wait, 0.1);
+						deferredResult.addCallback(Clipperz.Base.evalJSON);
+						deferredResult.addErrback(function(anError) {
+							Clipperz.logError("Error while decrypting data [4]");
+							throw Clipperz.Crypto.Base.exception.CorruptedMessage;
+						})
+					} else {
+						deferredResult.addCallback(function() {
+							return null;
+						});
+					}
+					deferredResult.callback();
+					
+					return deferredResult;
+				},
+				
+				'hash': Clipperz.Crypto.SHA.sha_d256,
+
+				'deriveKey': function(aStringValue) {
+					var	byteData;
+					var result;
+					
+					byteData = new Clipperz.ByteArray(aStringValue);
+					result = Clipperz.Crypto.SHA.sha_d256(byteData);
+					
+					return result;
+				}
 			},
-*/
+
 		//#####################################################################
 			__syntaxFix__: "syntax fix"
 		}
 	},
 	
 	//-------------------------------------------------------------------------
 	
 	'encrypt': function(aKey, aValue, aVersion) {
 		return Clipperz.PM.Crypto.encryptingFunctions.versions[aVersion].encrypt(aKey, aValue);
 	},
 
 	'deferredEncrypt': function(someParameters) {
 		return Clipperz.PM.Crypto.encryptingFunctions.versions[someParameters['version']].deferredEncrypt(someParameters['key'], someParameters['value']);
 	},
 
 	//.........................................................................
 
 	'decrypt': function(aKey, aValue, aVersion) {
 		return Clipperz.PM.Crypto.encryptingFunctions.versions[aVersion].decrypt(aKey, aValue);
 	},
 
 	'deferredDecrypt': function(someParameters) {
 		return Clipperz.PM.Crypto.encryptingFunctions.versions[someParameters['version']].deferredDecrypt(someParameters['key'], someParameters['value']);
 	},
 
 	//-------------------------------------------------------------------------
 
 	'hash': function(aValue) {
 		return Clipperz.PM.Crypto.encryptingFunctions.versions[Clipperz.PM.Crypto.encryptingFunctions.currentVersion]['hash'](aValue);
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'randomKey': function() {
 		return Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(32).toHexString().substring(2);
 	},
 
 	//-------------------------------------------------------------------------
 
 	'deriveKey': function(aValue) {
 		return Clipperz.PM.Crypto.encryptingFunctions.versions[Clipperz.PM.Crypto.encryptingFunctions.currentVersion].deriveKey(aValue);
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'passwordEntropy': function(aValue) {
 		var result;
 		var	bitPerChar;
 		
 		bitPerChar = 4;
 		if (/[a-z]/.test(aValue)) {
 			bitPerChar ++;
 		}
 		if (/[A-Z]/.test(aValue)) {
 			bitPerChar ++;
 		}
 		if (/[^a-zA-Z0-9]/.test(aValue)) {
 			bitPerChar ++;
 		}
 
 		result = aValue.length * bitPerChar;
 		
 		return result;
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'nullValue': '####',
 
 	//-------------------------------------------------------------------------
 	__syntaxFix__: "syntax fix"
 
 });
 
 //*****************************************************************************
 
 //MochiKit.Base.update(Clipperz.PM.Connection.communicationProtocol.versions, {
 //	'current': Clipperz.PM.Connection.communicationProtocol.versions[Clipperz.PM.Connection.communicationProtocol.currentVersion]
 //});
 
 MochiKit.Base.update(Clipperz.PM.Crypto.encryptingFunctions.versions, {
 	'current': Clipperz.PM.Crypto.encryptingFunctions.versions[Clipperz.PM.Crypto.encryptingFunctions.currentVersion]
 });
 
 //*****************************************************************************
diff --git a/frontend/gamma/js/Clipperz/PM/DataModel/User.js b/frontend/gamma/js/Clipperz/PM/DataModel/User.js
index fd18faf..b94fe4c 100644
--- a/frontend/gamma/js/Clipperz/PM/DataModel/User.js
+++ b/frontend/gamma/js/Clipperz/PM/DataModel/User.js
@@ -345,466 +345,466 @@ Clipperz.Base.extend(Clipperz.PM.DataModel.User, Object, {
 //					'encryptedVersionKeypath':		'version',
 					'retrieveRecordDetailFunction':	MochiKit.Base.method(this, 'getRecordDetail')
 				});
 
 				recordsIndex		= legacyHeader;
 				preferences			= legacyHeader;
 				oneTimePasswords	= legacyHeader;
 				break;
 			case '0.1':
 				var	headerData;
 				
 				headerData = Clipperz.Base.evalJSON(someServerData['header']);
 
 				recordsIndex = new Clipperz.PM.DataModel.User.Header.RecordIndex({
 					'retrieveKeyFunction':			MochiKit.Base.method(this, 'getPassphrase'),
 					'recordsData':					headerData['records'],
 					'recordsStats':					someServerData['recordsStats'],
 					'directLoginsData':				headerData['directLogins'],
 					'encryptedDataVersion':			someServerData['version'],
 					'retrieveRecordDetailFunction':	MochiKit.Base.method(this, 'getRecordDetail')
 				});
 
 				//	Still missing a test case that actually fais with the old version of the code, where the check for undefined was missing
 				if (typeof(headerData['preferences']) != 'undefined') {
 					preferences	= new Clipperz.PM.DataModel.User.Header.Preferences({
 						'name':	'preferences',
 						'retrieveKeyFunction': MochiKit.Base.method(this, 'getPassphrase'),
 						'remoteData': {
 							'data': headerData['preferences']['data'],
 							'version': someServerData['version']
 						}
 					});
 				} else {
 					preferences	= new Clipperz.PM.DataModel.User.Header.Preferences({
 						'name':	'preferences',
 						'retrieveKeyFunction': MochiKit.Base.method(this, 'getPassphrase')
 					});
 				}
 
 				if (typeof(headerData['oneTimePasswords']) != 'undefined') {
 					oneTimePasswords = new Clipperz.PM.DataModel.User.Header.OneTimePasswords({
 						'name':	'preferences',
 						'retrieveKeyFunction': MochiKit.Base.method(this, 'getPassphrase'),
 						'remoteData': {
 							'data': headerData['oneTimePasswords']['data'],
 							'version': someServerData['version']
 						}
 					});
 				} else {
 					oneTimePasswords = new Clipperz.PM.DataModel.User.Header.OneTimePasswords({
 						'name':	'preferences',
 						'retrieveKeyFunction': MochiKit.Base.method(this, 'getPassphrase')
 					});
 				}
 				
 				break;
 		}
 
 		unpackedData = {
 			'version': someServerData['version'],
 			'statistics': someServerData['statistics'],
 			'header': {
 				'data': someServerData['header'],
 				'version': headerVersion,
 				
 				'recordsIndex': recordsIndex,
 				'preferences': preferences,
 				'oneTimePasswords': oneTimePasswords
 			}
 		};
 
 		this._serverData = unpackedData;
 		
 		return this._serverData;
 	},
 
 	//-------------------------------------------------------------------------
 
 	'getServerData': function() {
 		var deferredResult;
 
 		deferredResult = new Clipperz.Async.Deferred("User.getServerData", {trace:false});
 		deferredResult.acquireLock(this.deferredLockForSection('serverData'));
 		deferredResult.addCallback(MochiKit.Base.bind(function(aResult) {
 			var innerDeferredResult;
 		
 			innerDeferredResult = new Clipperz.Async.Deferred("User.getUserDetails.innerDeferred", {trace:false});
 			if (this._serverData == null) {
 				innerDeferredResult.addCallbackPass(MochiKit.Signal.signal, this, 'loadingUserDetails');
 				innerDeferredResult.addMethod(this.connection(), 'message', 'getUserDetails');
 				innerDeferredResult.addMethod(this, 'unpackServerData');
 				innerDeferredResult.addCallbackPass(MochiKit.Signal.signal, this, 'loadedUserDetails');
 			}
 
 			innerDeferredResult.addCallback(MochiKit.Base.bind(function () {
 				return this._serverData;
 			},this));
 			innerDeferredResult.callback();
 
 			return innerDeferredResult;
 		}, this));
 		deferredResult.releaseLock(this.deferredLockForSection('serverData'));
 		deferredResult.callback();
 
 		return deferredResult;
 	},
 
 	//-------------------------------------------------------------------------
 
 	'connectionVersion': function() {
 		return this._connectionVersion;
 	},
 	
 	'setConnectionVersion': function(aValue) {
 		if (this._connectionVersion != aValue) {
 			this.resetConnection();
 		}
 		this._connectionVersion = aValue;
 	},
 
 	//-------------------------------------------------------------------------
 
 	'connection': function() {
 		if ((this._connection == null) && (this.connectionVersion() != null) ){
 			this._connection = new Clipperz.PM.Connection.communicationProtocol.versions[this.connectionVersion()]({
 				getCredentialsFunction: MochiKit.Base.method(this, 'getCredentials')
 			});
 		}
 				
 		return this._connection;
 	},
 
 	'resetConnection': function(aValue) {
 		if (this._connection != null) {
 			this._connection.reset();
 		}
 
 		this._connection = null;
 	},
 
 	//=========================================================================
 	
 	'getHeaderIndex': function (aKey) {
 		return Clipperz.Async.callbacks("User.getHeaderIndex", [
 			MochiKit.Base.method(this, 'getServerData'),
 			MochiKit.Base.itemgetter('header'),
 			MochiKit.Base.itemgetter(aKey)
 		], {trace:false})
 	},
 
 	//=========================================================================
 
 	'getRecords': function () {
 		return Clipperz.Async.callbacks("User.getRecords", [
 			MochiKit.Base.method(this, 'getHeaderIndex', 'recordsIndex'),
 			MochiKit.Base.methodcaller('records'),
 			MochiKit.Base.values
 		], {trace:false});
 	},
 
 	'recordWithLabel': function (aLabel) {
 		return Clipperz.Async.callbacks("User.recordWithLabel", [
 			MochiKit.Base.method(this, 'getRecords'),
 			MochiKit.Base.partial(Clipperz.Async.deferredFilter, function (aRecord) {
 				return Clipperz.Async.callbacks("User.recordWithLabel - check record label", [
 					MochiKit.Base.methodcaller('label'),
 					MochiKit.Base.partial(MochiKit.Base.operator.eq, aLabel)
 				], {trace:false}, aRecord);
 			}),
 			function (someFilteredResults) {
 				var result;
 
 				switch (someFilteredResults.length) {
 					case 0:
 						result = null;
 						break;
 					case 1:
 						result = someFilteredResults[0];
 						break;
 					default:
 						WTF = TODO;
 						break;
 				}
 				
 				return result;
 			}
 		], {trace:false});
 	},
 
 	//-------------------------------------------------------------------------
 
 	'getRecord': function (aRecordReference) {
 		return Clipperz.Async.callbacks("User.getRecord", [
 			MochiKit.Base.method(this, 'getHeaderIndex', 'recordsIndex'),
 			MochiKit.Base.methodcaller('records'),
 			MochiKit.Base.itemgetter(aRecordReference),
 			
 			Clipperz.Async.deferredIf("record != null", [
 				MochiKit.Base.operator.identity
 			], [
 				function () { throw "Record does not exists"}
 			])
 		], {trace:false});
 	},
 
 	//-------------------------------------------------------------------------
 
 	'getRecordDetail': function (aRecordReference) {
 		return this.connection().message('getRecordDetail', {reference: aRecordReference});
 	},
 
 	//-------------------------------------------------------------------------
 
 	'deleteRecord': function (aRecord) {
 		return Clipperz.Async.callbacks("User.deleteRecord", [
 			MochiKit.Base.method(this, 'getHeaderIndex', 'recordsIndex'),
 			MochiKit.Base.methodcaller('deleteRecord', aRecord)
 		], {trace:false});
 	},
 
 	//-------------------------------------------------------------------------
 
 	'createNewRecord': function () {
 		return Clipperz.Async.callbacks("User.createNewRecord", [
 			MochiKit.Base.method(this, 'getHeaderIndex', 'recordsIndex'),
 			MochiKit.Base.methodcaller('createNewRecord')
 		], {trace:false});
 	},
 
 	//=========================================================================
 
 	'getDirectLogins': function() {
 		var deferredResult;
 		
 		deferredResult = new Clipperz.Async.Deferred("User.getDirectLogins", {trace:false});
 		deferredResult.addMethod(this, 'getRecords');
 		deferredResult.addCallback(MochiKit.Base.map, MochiKit.Base.compose(MochiKit.Base.values, MochiKit.Base.methodcaller('directLogins')));
 		deferredResult.addCallback(MochiKit.Base.flattenArray);
 		deferredResult.callback();
 
 		return deferredResult;
 	},
 
 	//=========================================================================
 
 	'getOneTimePasswords': function () {
 		return Clipperz.Async.callbacks("User.getOneTimePasswords", [
 			MochiKit.Base.method(this, 'getHeaderIndex', 'oneTimePasswords'),
 			MochiKit.Base.methodcaller('oneTimePasswords'),
 			MochiKit.Base.values
 		], {trace:false});
 	},
 
 	//=========================================================================
 
 	'invokeMethodNamedOnHeader': function (aMethodName, aValue) {
 		return Clipperz.Async.collectResults("User.invokeMethodNamedOnHeader [" + aMethodName + "]", {
 			'recordIndex': [
 				MochiKit.Base.method(this, 'getHeaderIndex', 'recordsIndex'),
 				MochiKit.Base.methodcaller(aMethodName, aValue)
 			],
 			'preferences': [
 				MochiKit.Base.method(this, 'getHeaderIndex', 'preferences'),
 				MochiKit.Base.methodcaller(aMethodName, aValue)
 			],
 			'oneTimePasswords': [
 				MochiKit.Base.method(this, 'getHeaderIndex', 'oneTimePasswords'),
 				MochiKit.Base.methodcaller(aMethodName, aValue)
 			]//,
 //			'statistics': [
 //				MochiKit.Base.method(this, 'getStatistics'),
 //				MochiKit.Base.methodcaller(aMethodName, aValue)
 //			]
 		}, {trace:false})();
 	},
 
 	//-------------------------------------------------------------------------
 
 	'invokeMethodNamedOnRecords': function (aMethodName, aValue) {
 		return Clipperz.Async.callbacks("User.invokeMethodNamedOnRecords[" + aMethodName + "]", [
 			MochiKit.Base.method(this, 'getRecords'),
 			MochiKit.Base.partial(MochiKit.Base.map, MochiKit.Base.methodcaller(aMethodName, aValue)),
 			Clipperz.Async.collectAll
 		], {trace:false});
 	},
 
 	//=========================================================================
 
 	'hasPendingChanges': function () {
 		var	deferredResult;
 		
 		deferredResult = new Clipperz.Async.Deferred("User.hasPendingChanges", {trace:false});
 		deferredResult.collectResults({
 			'header': [
 				MochiKit.Base.method(this, 'invokeMethodNamedOnHeader', 'hasPendingChanges'),
 				MochiKit.Base.values
 			],
 			'records': MochiKit.Base.method(this, 'invokeMethodNamedOnRecords', 'hasPendingChanges')
 		});
 		deferredResult.addCallback(Clipperz.Async.or);
 		deferredResult.callback();
 //		recordsIndex		= legacyHeader;
 //		preferences			= legacyHeader;
 //		oneTimePasswords	= legacyHeader;
 		
 		return deferredResult;
 	},
 
 	//=========================================================================
 
 	'commitTransientState': function () {
 		return Clipperz.Async.callbacks("User.commitTransientState", [
 			MochiKit.Base.method(this, 'invokeMethodNamedOnHeader', 'commitTransientState'),
 			MochiKit.Base.method(this, 'invokeMethodNamedOnRecords', 'commitTransientState'),
 
 			MochiKit.Base.method(this, 'transientState'),
 //			MochiKit.Base.itemgetter('lock'),
 //			MochiKit.Base.method(this, 'setServerLockValue'),
 			MochiKit.Base.method(this, 'resetTransientState', true)
 		], {trace:false});
 	},
 
 	//-------------------------------------------------------------------------
 
 	'revertChanges': function () {
 		return Clipperz.Async.callbacks("User.revertChanges", [
 			MochiKit.Base.method(this, 'invokeMethodNamedOnHeader', 'revertChanges'),
 			MochiKit.Base.method(this, 'invokeMethodNamedOnRecords', 'revertChanges'),
 			MochiKit.Base.method(this, 'resetTransientState', false)
 		], {trace:false});
 	},
 
 	//=========================================================================
 
 	'deleteAllCleanTextData': function () {
 		return Clipperz.Async.callbacks("User.deleteAllCleanTextData", [
 			MochiKit.Base.method(this, 'invokeMethodNamedOnRecords', 'deleteAllCleanTextData'),
 			MochiKit.Base.method(this, 'invokeMethodNamedOnHeader',  'deleteAllCleanTextData'),
 
 			MochiKit.Base.method(this.data(), 'removeAllData'),
 			MochiKit.Base.method(this, 'resetTransientState', false)
 		], {trace:false});
 	},
 
 	//-------------------------------------------------------------------------
 
 	'hasAnyCleanTextData': function () {
 		var	deferredResult;
 		
 		deferredResult = new Clipperz.Async.Deferred("User.hasAnyCleanTextData", {trace:false});
 		deferredResult.collectResults({
 			'header':	[
 				MochiKit.Base.method(this, 'invokeMethodNamedOnHeader',  'hasAnyCleanTextData'),
 				MochiKit.Base.values
 			],
 			'records':	MochiKit.Base.method(this, 'invokeMethodNamedOnRecords', 'hasAnyCleanTextData'),
 			'data':		MochiKit.Base.bind(function () {
 							return MochiKit.Async.succeed(! this.data().isEmpty());
 						}, this),
 			'transientState':	MochiKit.Base.bind(function () {
 							return MochiKit.Async.succeed(MochiKit.Base.keys(this.transientState()).length != 0);
 						}, this)
 		});
 		deferredResult.addCallback(Clipperz.Async.or);
 		deferredResult.callback();
 
 		return deferredResult;
 	},
 
 	//=========================================================================
 
 	'prepareRemoteDataWithKey': function (aKey /*, aCurrentKey*/) {
 		var deferredResult;
 		var	result;
 
 		result = {};
 		deferredResult = new Clipperz.Async.Deferred("User.prepareRemoteDataWithKey", {trace:false});
 		deferredResult.addMethod(this, 'invokeMethodNamedOnHeader', 'prepareRemoteDataWithKey', aKey /*, aCurrentKey*/);
 		deferredResult.addCallback(MochiKit.Base.bind(function (aResult, someHeaderPackedData) {
 			var header;
 
 			header = {};
 			header['records']			= someHeaderPackedData['recordIndex']['records'];
 			header['directLogins']		= someHeaderPackedData['recordIndex']['directLogins'];
-			header['preferences']		= {'data': someHeaderPackedData['preferences']['data']};		//	this._serverData['header']['preferences'];		//	Clipperz.Base.evalJSON(this._serverData['header']['data'])['preferences'];		//	???????????
-			header['oneTimePasswords']	= {'data': someHeaderPackedData['oneTimePasswords']['data']};	//	this._serverData['header']['oneTimePasswords'];	//	Clipperz.Base.evalJSON(this._serverData['header']['data'])['oneTimePasswords'];	//	???????????
+			header['preferences']		= {'data': someHeaderPackedData['preferences']['data']};
+			header['oneTimePasswords']	= {'data': someHeaderPackedData['oneTimePasswords']['data']};
 			header['version']			= '0.1';
 
 			aResult['header']		= Clipperz.Base.serializeJSON(header);
 			aResult['statistics']	= this._serverData['statistics'];	//	"someHeaderPackedData['statistics']['data']";
 			
 			return aResult;
 		}, this), result);
 		deferredResult.addCallback(Clipperz.Async.setItem, result, 'version', Clipperz.PM.Crypto.encryptingFunctions.currentVersion);
 //		deferredResult.addCallback(Clipperz.Async.setItem, result, 'lock', this.serverLockValue());
 		deferredResult.callback();
 
 		return deferredResult;
 	},
 
 	//=========================================================================
 
 	'saveChanges': function () {
 		var	deferredResult;
 		var messageParameters;
 		
 		messageParameters = {};
 
 		deferredResult = new Clipperz.Async.Deferred("User.saveChangaes", {trace:false});
 
 		deferredResult.addMethod(this, 'getHeaderIndex', 'recordsIndex');
 		deferredResult.addCallback(MochiKit.Base.methodcaller('prepareRemoteDataForChangedRecords'));
 		deferredResult.addCallback(Clipperz.Async.setItem, messageParameters, 'records');
 		deferredResult.addCallbackPass(MochiKit.Signal.signal, Clipperz.Signal.NotificationCenter, 'advanceProgress');
 
 		deferredResult.addMethod(this, 'getPassphrase');
 		deferredResult.addMethod(this, 'prepareRemoteDataWithKey');
 		deferredResult.addCallback(Clipperz.Async.setItem, messageParameters, 'user');
 		deferredResult.addCallbackPass(MochiKit.Signal.signal, Clipperz.Signal.NotificationCenter, 'advanceProgress');
 
 		deferredResult.addCallback(MochiKit.Async.succeed, messageParameters);
 		deferredResult.addMethod(this.connection(), 'message', 'saveChanges');
 		deferredResult.addCallback(MochiKit.Base.update, this.transientState())
 		deferredResult.addCallbackPass(MochiKit.Signal.signal, Clipperz.Signal.NotificationCenter, 'advanceProgress');
 
 		deferredResult.addMethod(this, 'commitTransientState');
 		deferredResult.addCallbackPass(MochiKit.Signal.signal, Clipperz.Signal.NotificationCenter, 'advanceProgress');
 		deferredResult.addCallbackPass(MochiKit.Signal.signal, Clipperz.Signal.NotificationCenter, 'userDataSuccessfullySaved');
 
 		deferredResult.addErrbackPass(MochiKit.Base.method(this, 'revertChanges'));
 		deferredResult.addErrbackPass(MochiKit.Signal.signal, Clipperz.Signal.NotificationCenter, 'failureWhileSavingUserData');
 
 		deferredResult.callback();
 
 		return deferredResult;
 	},
 
 	//=========================================================================
 	__syntaxFix__: "syntax fix"
 });
 
 //-----------------------------------------------------------------------------
 
 Clipperz.PM.DataModel.User.registerNewAccount = function (anUsername, aPassphraseFunction) {
 	var	deferredResult;
 	var user;
 	
 	user = new Clipperz.PM.DataModel.User({'username':anUsername, 'getPassphraseFunction':aPassphraseFunction});
 
 	deferredResult = new Clipperz.Async.Deferred("Clipperz.PM.DataModel.User.registerNewAccount", {trace:false});
 	deferredResult.addMethod(user, 'registerAsNewAccount');
 	deferredResult.addMethod(user, 'login');
 	deferredResult.addCallback(MochiKit.Async.succeed, user);
 	deferredResult.callback();
 	
 	return deferredResult;
 }
 
 //-----------------------------------------------------------------------------
 
 Clipperz.PM.DataModel.User.exception = {
 	LoginFailed:				new MochiKit.Base.NamedError("Clipperz.PM.DataModel.User.exception.LoginFailed"),
 	CredentialUpgradeFailed:	new MochiKit.Base.NamedError("Clipperz.PM.DataModel.User.exception.CredentialUpgradeFailed") 
 };
 	
 //-----------------------------------------------------------------------------
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 326022c..b806cb7 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,788 @@
 /*
 
 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++) {
 			var	newConnection;
 			var	recordConfiguration;
 
 			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) {
 		var	result;
 		var	targetValue;
 		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;
 			var	tollParameters;
 			
 			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) {
 		var	result;
 
 		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;
 		var	connection;
 
 		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(),
+//					'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;
 		}
 
 		result = {
 			result: {
 				'lock':		this.data()['users'][someParameters['credentials']['C']]['lock'],
 				'result':	'done'
 			},
 			toll:   this.getTollForRequestType('CONNECT')
 		}
 
 		return result;
 	},
 
 	//-------------------------------------------------------------------------
 
 	'_handshake': function(aConnection, someParameters) {
 		var result;
 		var	nextTollRequestType;
 
 		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['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;
 			
 			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);
 			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);
 
 			M1 = Clipperz.PM.Crypto.encryptingFunctions.versions[someParameters.version].hash(new Clipperz.ByteArray(A.asString(10) + aConnection['B'].asString(10) + K)).toHexString().slice(2);
 			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);
 				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) {
 				var	lock;
 				
 				if (typeof(aConnection['userData']['lock']) == 'undefined') {
 					aConnection['userData']['lock'] = "<<LOCK>>";
 				}
 				
 				result['lock'] = aConnection['userData']['lock'];
 			}
 
 		//=====================================================================
 		} else if (someParameters.message == 'getRecordDetail') {
 /*
 			var	recordData;
 			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 {
 					var	oldCValue;
 					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']['userDetailsVersions']	= someParameters['parameters']['user']['version'];
+				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
diff --git a/frontend/gamma/js/Clipperz/PM/Proxy/Proxy.Test.js b/frontend/gamma/js/Clipperz/PM/Proxy/Proxy.Test.js
index d459726..1a860c5 100644
--- a/frontend/gamma/js/Clipperz/PM/Proxy/Proxy.Test.js
+++ b/frontend/gamma/js/Clipperz/PM/Proxy/Proxy.Test.js
@@ -1,156 +1,161 @@
 /*
 
 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/.
 
 */
 
 if (typeof(Clipperz) == 'undefined') { Clipperz = {}; }
 if (typeof(Clipperz.PM) == 'undefined') { Clipperz.PM = {}; }
 if (typeof(Clipperz.PM.Proxy) == 'undefined') { Clipperz.PM.Proxy = {}; }
 
 //=============================================================================
 
 Clipperz.PM.Proxy.Test = function(args) {
 	Clipperz.PM.Proxy.Test.superclass.constructor.call(this, args);
 
 	args = args || {};
 
 	this._expectedRequests = (args.shouldCheckExpectedRequests === true) ? [] : null;
 	this._isExpectingRequests = true;
 	this._unexpectedRequests = [];
 
 	this.dataStore().resetData();
 
 	return this;
 }
 
 Clipperz.Base.extend(Clipperz.PM.Proxy.Test, Clipperz.PM.Proxy.Offline, {
 
 	'toString': function() {
 		return "Clipperz.PM.Proxy.Test";
 	},
 
 	//=========================================================================
 
 	'expectedRequests': function () {
 		return this._expectedRequests;
 	},
 
 	//-------------------------------------------------------------------------
 
 	'shouldCheckExpectedRequests': function () {
 		return (this._expectedRequests != null);
 	},
 
 	'setShouldCheckExpectedRequests': function(aValue) {
 		if (aValue) {
 			this._expectedRequests = aValue;
 		} else {
 			this._expectedRequests = null;
 		}
 	},
 
 	//-------------------------------------------------------------------------
 
 	'shouldNotReceiveAnyFurtherRequest': function () {
 		this._isExpectingRequests = false;
 	},
 
 	'mayReceiveMoreRequests': function () {
 		this._isExpectingRequests = true;
 		this.resetUnexpectedRequests();
 	},
 
 	'isExpectingRequests': function () {
 		return this._isExpectingRequests;
 	},
 
 	//-------------------------------------------------------------------------
 
 	'unexpectedRequests': function () {
 		return this._unexpectedRequests;
 	},
 
 	'resetUnexpectedRequests': function () {
 		this._unexpectedRequests = [];
 	},
 
 	//-------------------------------------------------------------------------
 
 	'testExpectedRequestParameters': function (aPath, anActualRequest, anExpectedRequest) {
 		var aKey;
 		for (aKey in anExpectedRequest) {
 			if (typeof(anActualRequest[aKey]) == 'undefined') {
 				throw "the expected paramter [" + aKey + "] is missing from the actual request";
 			}
 			if (typeof(anExpectedRequest[aKey]) == 'object') {
 				this.testExpectedRequestParameters(aPath + "." + aKey,  anActualRequest[aKey], anExpectedRequest[aKey])
 			} else {
 				if (! anExpectedRequest[aKey](anActualRequest[aKey])) {
 					throw "wrong value for paramter [" + aKey + "]; got '" + anActualRequest[aKey] + "'";
 				}
 			}
 		}
 	},
 
 	//-------------------------------------------------------------------------
 
 	'checkRequest': function(aFunctionName, someParameters) {
 		if (this.shouldCheckExpectedRequests()) {
 			var expectedRequest;
 
 			expectedRequest = this.expectedRequests().pop();
 			if (expectedRequest == null) {
 				throw "Proxy.Test.sentMessage: no expected result specified. Got request '" + aFunctionName + "': " + someParameters;
 			}
 
 			try {
 				if (aFunctionName != expectedRequest.functionName) {
 					throw "wrong function name. Got '" + aFunctionName + "', expected '" + expectedRequest.request.functionName + "'";
 				}
 
 				this.testExpectedRequestParameters("parameters", someParameters, expectedRequest.parameters);
 			} catch(exception) {
 				throw "Proxy.Test.sentMessage[" + expectedRequest.name + "]: " + exception;
 			}
 		}
 	},
 
 	//=========================================================================
 
 	'sendMessage': function(aFunctionName, someParameters) {
 		var result;
 
 		if (this.isExpectingRequests() == false) {
 //			throw Clipperz.PM.Connection.exception.UnexpectedRequest;
 Clipperz.log("UNEXPECTED REQUEST " + aFunctionName /* + ": " + Clipperz.Base.serializeJSON(someParameters) */);
 			this.unexpectedRequests().push({'functionName':aFunctionName, 'someParameters': someParameters});
 		};
+//if (aFunctionName == 'knock') {
+//	console.log(">>> send message - " + aFunctionName, someParameters);
+//} else {
+//	console.log(">>> SEND MESSAGE - " + aFunctionName + " [" + someParameters['parameters']['message'] + "]", someParameters['parameters']['parameters']);
+//}
 		this.checkRequest(aFunctionName, someParameters);
 		result = Clipperz.PM.Proxy.Test.superclass.sendMessage.call(this, aFunctionName, someParameters);
 
 		return result;
 	},
 	
 	//=========================================================================
 	__syntaxFix__: "syntax fix"
 	
 });