Inproved PRNG configuration

1 files changed, 2 insertions, 2 deletions

diff --git a/frontend/beta/js/Clipperz/Crypto/PRNG.js b/frontend/beta/js/Clipperz/Crypto/PRNG.js
index 92966d0..6fdeca4 100644
--- a/frontend/beta/js/Clipperz/Crypto/PRNG.js
+++ b/frontend/beta/js/Clipperz/Crypto/PRNG.js
@@ -127,387 +127,387 @@ Clipperz.Crypto.PRNG.RandomnessSource.prototype = MochiKit.Base.update(null, {
 
 	'setSourceId': function(aValue) {
 		this._sourceId = aValue;
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'nextPoolIndex': function() {
 		return this._nextPoolIndex;
 	},
 	
 	'incrementNextPoolIndex': function() {
 		this._nextPoolIndex = ((this._nextPoolIndex + 1) % this.generator().numberOfEntropyAccumulators());
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'updateGeneratorWithValue': function(aRandomValue) {
 		if (this.generator() != null) {
 			this.generator().addRandomByte(this.sourceId(), this.nextPoolIndex(), aRandomValue);
 			this.incrementNextPoolIndex();
 		}
 	},
 	
 	//-------------------------------------------------------------------------
 	__syntaxFix__: "syntax fix"
 });
 
 //#############################################################################
 	
 Clipperz.Crypto.PRNG.TimeRandomnessSource = function(args) {
 	args = args || {};
 //	MochiKit.Base.bindMethods(this);
 
 	this._intervalTime = args.intervalTime || 1000;
 	
 	Clipperz.Crypto.PRNG.RandomnessSource.call(this, args);
 
 	this.collectEntropy();
 	return this;
 }
 
 Clipperz.Crypto.PRNG.TimeRandomnessSource.prototype = MochiKit.Base.update(new Clipperz.Crypto.PRNG.RandomnessSource, {
 
 	'intervalTime': function() {
 		return this._intervalTime;
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'collectEntropy': function() {
 		var	now;
 		var	entropyByte;
 		var intervalTime;
 		now = new Date();
 		entropyByte = (now.getTime() & 0xff);
 		
 		intervalTime = this.intervalTime();
 		if (this.boostMode() == true) {
 			intervalTime = intervalTime / 9;
 		}
 		
 		this.updateGeneratorWithValue(entropyByte);
 		setTimeout(this.collectEntropy, intervalTime);
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'numberOfRandomBits': function() {
 		return 5;
 	},
 	
 	//-------------------------------------------------------------------------
 	__syntaxFix__: "syntax fix"
 });
 
 //*****************************************************************************
 
 Clipperz.Crypto.PRNG.MouseRandomnessSource = function(args) {
 	args = args || {};
 
 	Clipperz.Crypto.PRNG.RandomnessSource.call(this, args);
 
 	this._numberOfBitsToCollectAtEachEvent = 4;
 	this._randomBitsCollector = 0;
 	this._numberOfRandomBitsCollected = 0;
 	
 	MochiKit.Signal.connect(document, 'onmousemove', this, 'collectEntropy');
 
 	return this;
 }
 
 Clipperz.Crypto.PRNG.MouseRandomnessSource.prototype = MochiKit.Base.update(new Clipperz.Crypto.PRNG.RandomnessSource, {
 
 	//-------------------------------------------------------------------------
 
 	'numberOfBitsToCollectAtEachEvent': function() {
 		return this._numberOfBitsToCollectAtEachEvent;
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'randomBitsCollector': function() {
 		return this._randomBitsCollector;
 	},
 
 	'setRandomBitsCollector': function(aValue) {
 		this._randomBitsCollector = aValue;
 	},
 
 	'appendRandomBitsToRandomBitsCollector': function(aValue) {
 		var collectedBits;
 		var numberOfRandomBitsCollected;
 		
 		numberOfRandomBitsCollected = this.numberOfRandomBitsCollected();
 		collectedBits = this.randomBitsCollector() | (aValue << numberOfRandomBitsCollected);
 		this.setRandomBitsCollector(collectedBits);
 		numberOfRandomBitsCollected += this.numberOfBitsToCollectAtEachEvent();
 		
 		if (numberOfRandomBitsCollected == 8) {
 			this.updateGeneratorWithValue(collectedBits);
 			numberOfRandomBitsCollected = 0;
 			this.setRandomBitsCollector(0);
 		}
 		
 		this.setNumberOfRandomBitsCollected(numberOfRandomBitsCollected)
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'numberOfRandomBitsCollected': function() {
 		return this._numberOfRandomBitsCollected;
 	},
 
 	'setNumberOfRandomBitsCollected': function(aValue) {
 		this._numberOfRandomBitsCollected = aValue;
 	},
 
 	//-------------------------------------------------------------------------
 
 	'collectEntropy': function(anEvent) {
 		var mouseLocation;
 		var randomBit;
 		var mask;
 		
 		mask = 0xffffffff >>> (32 - this.numberOfBitsToCollectAtEachEvent());
 		
 		mouseLocation = anEvent.mouse().client;
 		randomBit = ((mouseLocation.x ^ mouseLocation.y) & mask);
 		this.appendRandomBitsToRandomBitsCollector(randomBit)
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'numberOfRandomBits': function() {
 		return 1;
 	},
 	
 	//-------------------------------------------------------------------------
 	__syntaxFix__: "syntax fix"
 });
 
 //*****************************************************************************
 
 Clipperz.Crypto.PRNG.CryptoRandomRandomnessSource = function(args) {
 	args = args || {};
 
 	this._intervalTime = args.intervalTime || 1000;
 	this._browserCrypto = args.browserCrypto;
 	
 	Clipperz.Crypto.PRNG.RandomnessSource.call(this, args);
 
 	this.collectEntropy();
 	return this;
 }
 
 Clipperz.Crypto.PRNG.CryptoRandomRandomnessSource.prototype = MochiKit.Base.update(new Clipperz.Crypto.PRNG.RandomnessSource, {
 
 	'intervalTime': function() {
 		return this._intervalTime;
 	},
 	
 	'browserCrypto': function () {
 		return this._browserCrypto;
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'collectEntropy': function() {
 		var	bytesToCollect;
 
 		if (this.boostMode() == true) {
-			bytesToCollect = 8;
+			bytesToCollect = 64;
 		} else {
-			bytesToCollect = 32;
+			bytesToCollect = 8;
 		}
 
 		var randomValuesArray = new Uint8Array(bytesToCollect);
 		this.browserCrypto().getRandomValues(randomValuesArray);
 		for (var i = 0; i < randomValuesArray.length; i++) {
 			this.updateGeneratorWithValue(randomValuesArray[i]);
 		}
 
 		setTimeout(this.collectEntropy, this.intervalTime());
 	},
 	
 	//-------------------------------------------------------------------------
 	__syntaxFix__: "syntax fix"
 });
 
 //#############################################################################
 
 Clipperz.Crypto.PRNG.Fortuna = function(args) {
 	var	i,c;
 	
 	args = args || {};
 
 	this._key = args.seed || null;
 	if (this._key == null) {
 		this._counter = 0;
 		this._key = new Clipperz.ByteArray();
 	} else {
 		this._counter = 1;
 	}
 	
 	this._aesKey = null;
 	
 	this._firstPoolReseedLevel = args.firstPoolReseedLevel || 32 || 64;
 	this._numberOfEntropyAccumulators = args.numberOfEntropyAccumulators || 32;
 	
 	this._accumulators = [];
 	c = this.numberOfEntropyAccumulators();
 	for (i=0; i<c; i++) {
 		this._accumulators.push(new Clipperz.Crypto.PRNG.EntropyAccumulator());
 	}
 
 	this._randomnessSources = [];
 	this._reseedCounter = 0;
 	
 	return this;
 }
 
 Clipperz.Crypto.PRNG.Fortuna.prototype = MochiKit.Base.update(null, {
 
 	'toString': function() {
 		return "Clipperz.Crypto.PRNG.Fortuna";
 	},
 
 	//-------------------------------------------------------------------------
 
 	'key': function() {
 		return this._key;
 	},
 
 	'setKey': function(aValue) {
 		this._key = aValue;
 		this._aesKey = null;
 	},
 	
 	'aesKey': function() {
 		if (this._aesKey == null) {
 			this._aesKey = new Clipperz.Crypto.AES.Key({key:this.key()});
 		}
 		
 		return this._aesKey;
 	},
 	
 	'accumulators': function() {
 		return this._accumulators;
 	},
 	
 	'firstPoolReseedLevel': function() {
 		return this._firstPoolReseedLevel;
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'reseedCounter': function() {
 		return this._reseedCounter;
 	},
 
 	'incrementReseedCounter': function() {
 		this._reseedCounter = this._reseedCounter +1;
 	},
 
 	//-------------------------------------------------------------------------
 
 	'reseed': function() {
 		var	newKeySeed;
 		var reseedCounter;
 		var	reseedCounterMask;
 		var i, c;
 		
 		newKeySeed = this.key();
 		this.incrementReseedCounter();
 		reseedCounter = this.reseedCounter();
 		
 		c = this.numberOfEntropyAccumulators();
 		reseedCounterMask = 0xffffffff >>> (32 - c);
 		for (i=0; i<c; i++) {
 			if ((i == 0) || ((reseedCounter & (reseedCounterMask >>> (c - i))) == 0)) {
 				newKeySeed.appendBlock(this.accumulators()[i].stack());
 				this.accumulators()[i].resetStack();
 			} 
 		}
 		
 		if (reseedCounter == 1) {
 			c = this.randomnessSources().length;
 			for (i=0; i<c; i++) {
 				this.randomnessSources()[i].setBoostMode(false);
 			}
 		}
 		
 		this.setKey(Clipperz.Crypto.SHA.sha_d256(newKeySeed));
 		if (reseedCounter == 1) {
 MochiKit.Logging.logDebug("### PRNG.readyToGenerateRandomBytes");
 			MochiKit.Signal.signal(this, 'readyToGenerateRandomBytes');
 		}
 		MochiKit.Signal.signal(this, 'reseeded');
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'isReadyToGenerateRandomValues': function() {
 		return this.reseedCounter() != 0;
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'entropyLevel': function() {
 		return this.accumulators()[0].stack().length() + (this.reseedCounter() * this.firstPoolReseedLevel());
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'counter': function() {
 		return this._counter;
 	},
 	
 	'incrementCounter': function() {
 		this._counter += 1;
 	},
 	
 	'counterBlock': function() {
 		var result;
 
 		result = new Clipperz.ByteArray().appendWords(this.counter(), 0, 0, 0);
 		
 		return result;
 	},
 
 	//-------------------------------------------------------------------------
 
 	'getRandomBlock': function() {
 		var result;
 
 		result = new Clipperz.ByteArray(Clipperz.Crypto.AES.encryptBlock(this.aesKey(), this.counterBlock().arrayValues()));
 		this.incrementCounter();
 		
 		return result;
 	},
 	
 	//-------------------------------------------------------------------------
 
 	'getRandomBytes': function(aSize) {
 		var result;
 
 		if (this.isReadyToGenerateRandomValues()) {
 			var i,c;
 			var newKey;
 			
 			result = new Clipperz.ByteArray();
 		
 			c = Math.ceil(aSize / (128 / 8));
 			for (i=0; i<c; i++) {
 				result.appendBlock(this.getRandomBlock());
 			}
 
 			if (result.length() != aSize) {
 				result = result.split(0, aSize);
 			}
 			
 			newKey = this.getRandomBlock().appendBlock(this.getRandomBlock());
 			this.setKey(newKey);
 		} else {
 MochiKit.Logging.logWarning("Fortuna generator has not enough entropy, yet!");
 			throw Clipperz.Crypto.PRNG.exception.NotEnoughEntropy;