aotrautils-srv 0.0.55 → 0.0.58

aotrautils-srv/aotrautils-srv.build.js

@@ -1,6 +1,6 @@
 
 
-/*utils SERVER library associated with aotra version : «1.0.0.000 (11/07/2022-23:49:33)»*/
+/*utils SERVER library associated with aotra version : «1.0.0.000 (12/07/2022-23:38:30)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -337,12 +337,14 @@ WebsocketImplementation={
 							},
 						};
 						
-						// DBG
-						console.log("ADD RECEPTION ENTRY POINT channelName:«"+channelName+"»! nodeServerInstance.receptionEntryPoints.length:",nodeServerInstance.receptionEntryPoints.length);
 						
 						nodeServerInstance.receptionEntryPoints.push(receptionEntryPoint);
 						
 						
+						// DBG
+						console.log("ADD RECEPTION ENTRY POINT channelName:«"+channelName+"»! nodeServerInstance.receptionEntryPoints.length:",nodeServerInstance.receptionEntryPoints.length);
+						
+						
 						return nodeServerInstance;
 					},
 					
@@ -417,8 +419,8 @@ WebsocketImplementation={
 							console.log("SERVER : ON CONNECTION !");
 							
 							
-//							if(contains(nodeServerInstance.clientsSockets, clientSocket))	return;
-//							nodeServerInstance.clientsSockets.push(clientSocket);
+//						if(contains(nodeServerInstance.clientsSockets, clientSocket))	return;
+//						nodeServerInstance.clientsSockets.push(clientSocket);
 
 
 							// DBG
@@ -979,7 +981,7 @@ initNodeServer=function(doOnClientConnection=null, doOnFinalizeServer=null, /*OP
 	// TRACE
 	console.log("Server launched.");
 	console.log("Usage :													node <server.js> conf {port:[port], sslCertPath:[ssl certificate path | unsecure ], sslKeyPath:[ssl key path], serverConfig:[JSON server configuration]}");
-	console.log("Or (to generate password hash) :	node <server.js> hash <clientId@repositoryName> <clearText>");
+	console.log("Or (to generate password hash) :	node <server.js> hash <clientId@repositoryName> <clearTextSecretString>");
 	// 			EXAMPLE : 							node orita-srv.js hash orita.global@saltkey 1234567890
 	console.log("Server launched.");
 	
@@ -1019,8 +1021,7 @@ initNodeServer=function(doOnClientConnection=null, doOnFinalizeServer=null, /*OP
 		}
 	});
 	isForceUnsecure=(argCLCertPath==="unsecure");
-	
-	
+
 	
 	const aotraNodeServer={config:serverConfig};
 	aotraNodeServer.serverManager={ start:()=>{/*DEFAULT START FUNCTION, WILL BE OVERRIDEN LATER*/}};
@@ -1299,7 +1300,7 @@ function getListManager(config){
 
 
 
-/*utils COMMONS library associated with aotra version : «1.0.0.000 (11/07/2022-23:49:33)»*/
+/*utils COMMONS library associated with aotra version : «1.0.0.000 (12/07/2022-23:38:30)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -2743,6 +2744,299 @@ aotest.profile=function(rootObject,methodName,visited=[]){
 
 
 
+
+//================================================================
+//================= Cryptography utility methods =================
+//================================================================
+
+
+// NOT AOTESTABLE !
+//TODO : develop :
+//getHashedString=monitorProgression(100000,
+window.getHashedString=function(str,/*OPTIONAL*/isHeavyTreatment){
+	
+	//CAUTION : YOU MUST *NOT* CHANGE THIS VALUE, UNLESS THE HASH HEAVY TREATMENT VALUE IN YOUR AOTRA SERVER-SIDE CODEIS THE SAME !
+	const HEAVY_TREATMENT_LOOP_COUNT=100000;
+	
+	if(isHeavyTreatment){
+
+		// If needed, we make sure the hashing will take a long time, so that
+		// if the private salt key is leaked, it will be fairly difficult to crack
+		// password write protection and content encryption :
+		
+		let result=str;
+		for(var i=0;i<HEAVY_TREATMENT_LOOP_COUNT;i++){
+			result=getHashedString(result,false);
+		}
+
+		
+		return result;
+		
+	}else{
+	
+		
+		// SHA-256 hash (sucks less) :
+		// DEPENDENCY : SJCL JS libray (Stanford Javascript Crypto Library)
+		if(typeof(sjcl)!="undefined"){
+			let result=sjcl.codec.hex.fromBits(sjcl.hash.sha256.hash(str));
+			
+			// TODO : develop :
+//			hash.progressionMonitor.progress(1);
+	
+			
+			return result;
+		}
+		
+		// if not found : MD5 hash (sucks) :
+		//TRACE
+		log("WARN : Could not find SHA hashing, using MD5. This sucks, and this very likely will prevent your aotra client to be able to write data to aotra server.");
+		
+		return hex_md5(str);
+	}
+}
+//);
+
+function encrypt(strToEncrypt,key,/*OPTIONAL*/mode){
+	if(!mode || typeof(sjcl)=="undefined")	mode="xor";
+	mode=mode.trim();
+
+	if(contains(mode,"aes") && contains(mode,"xor")){
+
+		// XOR :
+		var xorStr=btoa(encodeXORNoPattern(strToEncrypt,key));	
+		
+		var aesStr=
+			// AES
+			sjcl.encrypt(key,xorStr);
+
+		return aesStr;
+	}
+	
+	//	DEPENDENCY : SJCL JS libray (Stanford Javascript Crypto Library)
+	if(mode==="aes")
+		return sjcl.encrypt(key,strToEncrypt);
+	return btoa(encodeXORNoPattern(strToEncrypt,key));
+
+}
+
+function decrypt(strToDecrypt,key,/*OPTIONAL*/mode){
+	if(!mode || typeof(sjcl)=="undefined")	mode="xor";
+	mode=mode.trim();
+
+	if(contains(mode,"aes") && contains(mode,"xor")){
+		
+		// AES
+		var aesStr=sjcl.decrypt(key,strToDecrypt);
+		
+		var xorStr=
+			// XOR :
+			encodeXORNoPattern(atob(aesStr),key);
+
+		return xorStr;
+		
+	}
+	
+	//	DEPENDENCY : SJCL JS libray (Stanford Javascript Crypto Library)
+	if(mode==="aes")
+		return sjcl.decrypt(key,strToDecrypt);
+	return encodeXORNoPattern(atob(strToDecrypt),key);
+	
+	
+}
+
+function encodeXORNoPattern(strToEncode,key){
+	let result="";
+	let keyChunk=key;
+	let keyLength=keyChunk.length;
+	let previousChars="";
+	let cnt=0;
+	for(let i=0;i<strToEncode.length;i++){
+		let char=strToEncode.charAt(i);
+		let keyByte=keyChunk.charAt(cnt);
+		
+		result+=String.fromCharCode(char.charCodeAt(0)^keyByte.charCodeAt(0));
+		
+		if(cnt%keyLength===(keyLength-1)){
+			cnt=0;
+			// NO : TOO LONG TREATMENT !: We hash with all the previous blocks too :
+			// We hash with a character of the previous chunk (they add up at each new chunk):
+			keyChunk=getHashedString(previousChars+keyChunk);
+		
+			previousChars+=keyChunk.charAt(keyChunk.length-1);
+		}else{
+			cnt++;
+		}
+	}
+	return result;
+}
+
+function generateRandomString(length,/*NULLABLE*/mode){
+	
+	// This list must be very conservative, because  we want to be able to pass it through GET URLs !
+	// OLD (not enough conservative ?) : const ALLOWED_CHARS="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0912346789_-£¢¤¬²³¼½¾";
+	const ALLOWED_CHARS="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0912346789!-:;";
+	
+	
+	if(typeof(length)==="string"){
+		if(contains(length,"->")){
+			length=Math.getRandomInRange(length);
+		}else{
+			length=64;
+		}
+	}
+	
+	var result="";
+
+	if(mode==="simple"){
+		
+		for(var i=0;i<length;i++){
+			var	value=Math.getRandomInArray(ALLOWED_CHARS);
+			result+=value;
+		}
+		
+		return result;
+	}else if(mode==="human"){
+		
+		const markovGraph={
+			// For simplicity sakes, we ignore the consonants and vowels doubling possibilities:
+			consonants:{// They always accept vowels at their following
+				// Indicate ^ to specify wich of the other group letter to exclude as direct follower of the given letter :
+				"b":["r","l"],
+				"c":["h","t","k","l","r"],
+				"d":["r"],
+				"f":["r","l"],
+				"g":["r","l"],
+				"h":[],
+				"j":["r"],
+				"k":["r","l","t","h"],
+				"l":["t"],
+				"m":["b","p"],
+				"n":["t","d"],
+				"p":["h","r","s","t","l"],
+				"q":["r","l"],
+				"r":["t","c","d","k","q","h"],
+				"s":["t","c","d","k","q","h"],
+				"t":["r","h"],
+				"v":["r","l"],
+				"w":["r"],
+				"x":["p"],
+				"z":["r","h"],
+			},
+			vowels:{// They always accept consonants at their following
+				"a":["i","u","y"],
+				"e":["i","u","y"],
+				"i":["e","o"],
+				"o":["i","u"],
+				"u":["i"],
+				"y":[],
+			},
+		};
+		
+		const LETTERS_TYPES=Object.keys(markovGraph);
+
+		const CURR_LETTER_MODE=Math.getRandomInArray(LETTERS_TYPES);
+		const POSSIBLE_LETTERS=Object.keys(markovGraph[CURR_LETTER_MODE]);
+		const CURR_LETTER=Math.getRandomInArray(POSSIBLE_LETTERS);
+		
+		var automataState={
+			currentLetterMode:CURR_LETTER_MODE,
+			possibleLetters:POSSIBLE_LETTERS,
+			currentLetter:CURR_LETTER,
+			
+			calculateLetter:function(){
+				
+				this.currentLetter=Math.getRandomInArray(this.possibleLetters);
+				
+				var sameLetters=Object.keys( markovGraph[this.currentLetterMode] );
+				if(!contains(sameLetters,this.currentLetter)){
+					// If we picked from the same group : we don't change of group to pick
+					// If we picked from the other group : we do change of group to pick
+					
+					var otherLetterMode=foreach(LETTERS_TYPES,(item)=>{
+						if(item!==this.currentLetterMode)	return item;
+					});
+					
+					this.currentLetterMode=otherLetterMode;
+				}
+
+			},
+			
+			updatePossibleLettersForLetter:function(){
+				
+				var nextPossibleLetters=[];
+				var nextNotPossibleLetters=[];
+
+				// We store those of the other group marked «^»
+				foreach(markovGraph[this.currentLetterMode][this.currentLetter],(letter)=>{
+					if(letter.charAt(0)==="^"){
+						nextNotPossibleLetters.push(letter.charAt(1));
+					}else{
+						nextPossibleLetters.push(letter);
+					}
+				});
+				
+				var otherLetterMode=foreach(LETTERS_TYPES,(item)=>{
+					if(item!==this.currentLetterMode)	return item;
+				});
+				var otherLetters=Object.keys(markovGraph[otherLetterMode]);
+				
+				// We exclude those marked «^»
+				foreach( otherLetters ,(letter)=>{
+					if(!contains(nextNotPossibleLetters,letter)){
+						nextPossibleLetters.push(letter);
+					}
+				});
+
+				this.possibleLetters=nextPossibleLetters;
+			}
+		};
+		
+		var i=0;
+		do{
+
+			result+=automataState.currentLetter;
+			
+			automataState.updatePossibleLettersForLetter();
+			automataState.calculateLetter();
+			
+			i++;
+		}while(i<length);
+		
+		return result;
+	}
+	
+	for(var i=0;i<length;i++){
+		var	value=Math.getRandomInt(255,0);
+		result+=String.fromCharCode(value);
+	}
+	
+	if(mode==="base64"){
+		return btoa(result);
+	}
+	
+	return result;
+}
+
+
+
+// NOT AOTESTABLE !
+function getUniqueIdWithDate(){
+	return getHashedString(getNow() + "");
+}
+
+
+
+
+
+
+//================================================================
+//================= Miscelanneous utility methods =================
+//================================================================
+
+
+
+
+
 // NOT AOTESTABLE !
 
 // This function is for simple variables, like strings, booleans, or Objects you

aotrautils-srv/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "aotrautils-srv",
-	"version": "0.0.55",
+	"version": "0.0.58",
 	"main": "aotrautils-srv.build.js",
 	"description": "A library for vanilla javascript utils (server-side) used in aotra javascript CMS",
 	"author": "Jeremie Ratomposon <info@alqemia.com> (https://alqemia.com)",