Python version 6

BF_Constants.py

@@ -0,0 +1,89 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from enum import Enum
+
+
+class APPLICATION_CONSTANTS():
+	NAME= "Brute Force Pass"
+	VERSION = "0.6.5 - rc1"
+
+class LAN_CONSTANTS():
+	class MESSAGE_KEY(Enum):
+		NB_CORE_CLIENT = "nbCoreClient" #peramètre passé dans la requette doit etre suivit du nombre de coeur aloué pour le calcul
+		NB_CORE_TOTAL = "nbCoreTotal"
+		INDEX_CORE_MIN = "indexCoreMin"
+		CRYPTED_PASSWORD = "cryptedPassword"
+		ENCRYPTION_KEY = "encryptionKey"
+		HASH_METHOD = "hashMethode"
+		PASSWORD_MAX_LENGTH = "passwordMaxLength"
+		MESSAGE_TYPE = "type"
+		RETURN_STATE = "returnState"
+		NB_WORDS = "nbWords"
+		PROCESS_TIME = "processTime"
+		WORD = "word"
+		LOCAL_THREAD_NAME = "threadName"
+		
+	class MESSAGE_VALUE(Enum) :
+		TYPE_INFO = "info"
+		TYPE_CONFIG = "config"
+		TYPE_ERROR = "error"
+		TYPE_RESULT = "result"
+		TYPE_DEFAULT = "default"
+		STATE_OK = "OK"
+		STATE_KO = "KO"
+		
+	class MESSAGE_SPECIAL_CHAR(Enum) :
+		SEPARATOR = ','
+		ASIGNATOR = ':'
+		SAME_VALUE_SEPRATOR = ';'
+
+class PROCESS_CONSTANTS():
+	class MESSAGE_RETURN_TYPE(Enum):
+		PERFS = 1
+		RETURN = 0
+		
+class PARAMS_CONSTANTS():
+	class LONG_PARAMS(Enum):
+		VERBOSE = "--verbose"
+		HELP = "--help"
+		MODE = "--mode"
+		HASH = "--hash"
+		ENCRYPTION_KEY = "--key"
+		PORT = "--port"
+		SERVER_IP = "--ip"
+		ROLE = "--role"
+		SECRET_PARAM = "--cd"
+		CORE = "--core"
+		MAX_LENGTH = "--length"
+		
+	class SHORT_PARAMS(Enum):
+		VERBOSE = "-v"
+		HELP = "-h"
+		MODE = "-m"
+		ENCRYPTION_KEY = "-k"
+		PORT = "-p"
+		SERVER_IP = "-s"
+		ROLE = "-r"
+		CORE = "-c"
+		MAX_LENGTH = "-l"
+		
+	class PARAMS_VALUE(Enum):
+		MODE_LOCAL = "local" 
+		MODE_LAN = "lan"
+		ROLE_CLIENT = "client"
+		ROLE_SERVER = "server"
+		
+class ANSWER_STATES():
+	class MESSAGE_STATE(Enum):
+		STATE_OK = "OK"
+		STATE_KO = "KO"
+		
+class HASH_METHODS():
+	class HASH_METHOD(Enum):
+		HASH_MD5 = "md5"
+		HASH_SHA1 = "sha1"
+		HASH_SHA224 = "sha224"
+		HASH_SHA256 = "sha256"
+		HASH_SHA384 = "sha384"
+		HASH_SHA512 = "sha512"
+		HASH_NONE = "None"

BF_EasterEgg.py

@@ -0,0 +1,15 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+import os
+import ctypes
+import time
+import platform
+
+
+class EasterEgg():
+	def openTray(self):
+		if platform.system() == 'Linux':
+			os.system("eject -t cdrom")
+		else:
+			ctypes.windll.winmm.mciSendStringW("set cdaudio door open", None, 0, None)

BF_Encryption.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+import hashlib
+import random
+
+from BF_Constants import *
+
+tabChar = list("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
+
+class Encryption():
+	def __init__(self):
+		self.passwordNonCrypte = ""
+		self.key = ""
+		self.typeCryptage = ""
+		self.passwordCrypte = ""
+		return None
+	
+	def getRandKey(self, keySize):
+		keyRand = ""
+		i = 0
+		while i < keySize:
+			keyRand = keyRand + round(randrange(0, len(tabChar)),0)
+		return keyRand
+		
+	def md5(self, string):
+		return hashlib.md5(string.encode('utf-8')).hexdigest()
+
+	def sha1(self, string):
+		return hashlib.sha1(string.encode('utf-8')).hexdigest()
+			
+	def sha224(self, string):
+		return hashlib.sha224(string.encode('utf-8')).hexdigest()
+			
+	def sha384(self, string):
+		return hashlib.sha384(string.encode('utf-8')).hexdigest()
+		
+	def sha256(self, string):
+		return hashlib.sha256(string.encode('utf-8')).hexdigest()
+		
+	def sha512(self, string):
+		return hashlib.sha512(string.encode('utf-8')).hexdigest()
+			
+	def none(self, string):
+		return string
+		
+	def hashForLambda(self, functionLambda, string):
+		return functionLambda(string)		
+		
+
+#si le fichier est lancé seul
+if __name__ == '__main__' :
+	sys.exit()

BF_GUI.py

@@ -0,0 +1,248 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+import os
+import platform
+import locale
+from datetime import datetime
+import time
+import BF_Utils
+from BF_Constants import *
+
+class GUI():
+	def __init__(self):
+		self.guiStartTime = str(datetime.now().time().strftime("%H:%M:%S"))
+		self.guiTime=time.time()
+		self.appName = APPLICATION_CONSTANTS.NAME+ " V" +APPLICATION_CONSTANTS.VERSION
+		self.headerLines = self.prepareHeader()
+		return
+		
+	def prepareHeader(self):
+		lines = list()
+		info = list()
+		lenGui = len(self.appName)
+		info.append("System family : " + str(platform.system()))
+		info.append("System release : " + str(platform.release()))
+		info.append("Processor Core : " + str(os.cpu_count()))
+		info.append("App Started at : "+self.guiStartTime)
+		for value in info:
+			if len(value) > lenGui:
+				lenGui = len(value)
+		
+		lines.append(self.separationLineCreator("+","+","-",lenGui+2))
+		lines.append(self.centredLine("| "," |"," ",self.appName,lenGui))
+		lines.append(self.separationLineCreator("+","+","-",lenGui+2))
+		
+		for content in info:
+			lines.append(str(self.leftAlignLine("| "," |"," ",content,lenGui)))
+			
+		lines.append(self.separationLineCreator("+","+","-",lenGui+2))
+		return lines
+				
+				
+	def separationLineCreator(self,leftBorder,rightBorder,separator,lenGui):
+		listSeparationLine = list()
+		listSeparationLine.append(leftBorder)
+		for i in range (0, lenGui):
+			listSeparationLine.append(separator)
+		listSeparationLine.append(rightBorder)
+		separationLine = "".join(listSeparationLine)
+		return separationLine
+	
+	def centredLine(self,leftBorder,rightBorder,offsetChar,value,lenGui):
+		lenSpace = (lenGui - len(value))/2
+		if lenSpace.is_integer():
+			lenSpaceLeft = int(lenSpace)
+			lenSpaceRight = int(lenSpace) 
+		else :
+			lenSpaceLeft = round(lenSpace)
+			if( round(lenSpace) < lenSpace ):
+				lenSpaceRight = round(lenSpace)+ 1
+			else:
+				lenSpaceRight = round(lenSpace)- 1
+			
+		listSpaceLeft = list()
+		for i in range(0,lenSpaceLeft):
+			listSpaceLeft.append(offsetChar)
+			
+		listSpaceRight = list()
+		for i in range(0,lenSpaceRight):
+			listSpaceRight.append(offsetChar)
+			
+		centeredLine = leftBorder+"".join(listSpaceLeft) + value + "".join(listSpaceRight)+rightBorder
+		return centeredLine
+		
+	def tableLine(self,offsetChar,value1,value2,lenMaxValue1):
+		tableLine = ""
+		listSpaceSeparator = list()
+		for i in range(0,lenMaxValue1 - len(value1)):
+			listSpaceSeparator.append(offsetChar)
+			
+		tableLine = value1+"".join(listSpaceSeparator)+value2
+		return tableLine
+			
+	def leftAlignLine(self,leftBorder,rightBorder,offsetChar,value,lenGui):
+		lenSpaceRight = lenGui - len(value)
+		listSpaceRight = list()
+		for i in range(0,lenSpaceRight):
+			listSpaceRight.append(offsetChar)
+			
+		leftAlignLine = leftBorder+value+"".join(listSpaceRight)+rightBorder
+		return leftAlignLine
+	
+	def clearScreen(self):
+		if platform.system() == 'Linux':
+			os.system('clear')
+		else:
+			os.system('cls')
+
+	def setLocale(self):
+		if platform.system() == 'Linux':
+			locale.setlocale(locale.LC_ALL, 'french')
+		else:
+			locale.setlocale(locale.LC_ALL, 'french_france')
+
+	def displayHeader(self):
+		self.clearScreen()
+		for line in self.headerLines:
+			print(line)
+			
+	def displayProcessPerfs(self, host, processName, WordsSeconds, curentWord):
+		self.setLocale()
+		WordsSeconds = locale.format('%d', WordsSeconds, grouping=True)
+		print("Host : " + host )
+		print("\t"+ processName+" : " + '{:>10}'.format(WordsSeconds) + " Word/s   \tCurrent word: " + curentWord)
+		return
+		
+	def displayProcessPerfsList(self, host, processName, WordsSeconds, curentWord):
+		self.setLocale()
+		print("Host : " + host )
+		for i in range(0,len(processName)):
+			WordsSeconds[i] = locale.format('%d', WordsSeconds[i], grouping=True)
+			print("\t"+ processName[i]+" : " + '{:>10}'.format(WordsSeconds[i]) + " Word/s   \tCurrent word: " + curentWord[i])
+		return
+		
+	def displayTotalPerfs(self, host,WordsSeconds):
+		self.setLocale()
+		WordsSeconds = locale.format('%d', WordsSeconds, grouping=True)
+		print("Word Per Second :    " +'{:>10}'.format(WordsSeconds)+ " Word/s")
+		
+	def displayError(self, host,errorCode, errorMessage):
+		print("Error at : " + host)
+		print("\t"+errorCode + " : " + errorMessage)
+	
+	def displayMessage(self,host,message):
+		print("From " + host + ": " + message )
+		
+	def displayResult(self,value,timeSeconds):
+		if(time.time() - timeSeconds) > 60 :
+			seconds = time.time() - timeSeconds
+			d,h,m,s = self.formatTime(seconds)
+			
+			if d != 0:
+				print("Found ! : " + value +" in " + "%d:%02d:%02d:%02d" % (d,h, m, s))
+			elif h != 0 :
+				print("Found ! : " + value +" in " + "%d:%02d:%02d" % (h, m, s))
+			else:
+				print("Found ! : " + value +" in " + "%d:%02d" % (m, s))
+		else:
+			print("Found ! : " + value +" in " + str(round(time.time() - timeSeconds,2)) + " second")
+		return
+			
+	def formatTime(self,seconds):
+		m, s = divmod(seconds, 60)
+		h, m = divmod(m, 60)
+		d ,h = divmod(h, 24)
+		return d,h,m,s
+		
+	def displayShortHelp(self):
+		print()
+		print("Usage : " )
+		leftTab = list()
+		leftTab.append("\t"+PARAMS_CONSTANTS.LONG_PARAMS.HELP.value+", "+ PARAMS_CONSTANTS.SHORT_PARAMS.HELP.value)
+		leftTab.append("\t"+PARAMS_CONSTANTS.LONG_PARAMS.HASH.value+"=[passwordSearch]")
+		leftTab.append("\t"+PARAMS_CONSTANTS.LONG_PARAMS.VERBOSE.value+", "+ PARAMS_CONSTANTS.SHORT_PARAMS.VERBOSE.value)
+		leftTab.append("\t"+PARAMS_CONSTANTS.LONG_PARAMS.MODE.value+", " +PARAMS_CONSTANTS.SHORT_PARAMS.MODE.value)
+		
+		rightTab = list()
+		rightTab.append("Display help message")
+		rightTab.append("Set hash to search")
+		rightTab.append("Set verbose mode")
+		rightTab.append("Set application mode")
+		
+		
+		maxLenLeft = 0
+		for value in leftTab:
+			if len(value) > maxLenLeft:
+				maxLenLeft = len(value)
+		
+		for i in range(0,len(leftTab)):
+			print(self.tableLine(" ",leftTab[i],rightTab[i],maxLenLeft+4))
+		print()
+		
+	def displayFullHelp(self):
+		pass
+	
+	def displayVersion(self):
+		print()
+		print(APPLICATION_CONSTANTS.NAME + " version " + APPLICATION_CONSTANTS.VERSION)
+		
+	def getStringInputValue(self,question):
+		print()
+		return input(question +" ")
+		
+	def getIntInputValue(self,question):
+		print()
+		userChoice = input(question +" ")
+		if not BF_Utils.is_int(userChoice):
+			self.displayHeader()
+			print()
+			self.displayError("localhost","EntryError","Input is not a Number !")
+			userChoice = self.getIntInputValue(question)	
+		return int(userChoice)
+		
+	def createMenu(self,title,entryList,margin):
+		print()
+		print(title)
+		print()
+		for i in range(0,len(entryList)):
+			print(margin+ str(i + 1) + " - " + entryList[i])
+		print()
+		userChoice = input()
+		if BF_Utils.is_int(userChoice):
+			if not (int(userChoice)> 0 and int(userChoice) <= len(entryList)):
+				self.displayHeader()
+				print()
+				self.displayError("localhost","EntryError","Choice not in the list !")
+				userChoice = self.displayMenu(title,entryList,margin)
+			
+		else:
+			self.displayHeader()
+			print()
+			self.displayError("localhost","EntryError","Input is not a Number !")
+			userChoice = self.displayMenu(title,entryList,margin)
+		return int(userChoice)
+	
+	def createMenuValue(self,title,entryList,margin):
+		print()
+		print(title)
+		print()
+		for i in range(0,len(entryList)):
+			print(margin+ str(i + 1) + " - " + entryList[i])
+		print()
+		userChoice = input()
+		if BF_Utils.is_int(userChoice):
+			if not (int(userChoice)> 0 and int(userChoice) <= len(entryList)):
+				self.displayHeader()
+				print()
+				self.displayError("localhost","EntryError","Choice not in the list !")
+				userChoice = self.displayMenu(title,entryList,margin)
+
+		else:
+			self.displayHeader()
+			print()
+			self.displayError("localhost","EntryError","Input is not a Number !")
+			userChoice = self.displayMenu(title,entryList,margin)
+		return entryList[int(userChoice) - 1] 
+		
+		

BF_InterfaceServer.py

@@ -0,0 +1,51 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import socketserver
+from threading import Thread
+import signal
+
+from BF_Constants import *
+from BF_EasterEgg import *
+import BF_Utils
+FOUND = False
+
+class InterfaceServerHandler(socketserver.BaseRequestHandler):
+	def handle(self):
+		self.messageType = LAN_CONSTANTS.MESSAGE_VALUE.TYPE_DEFAULT.value
+		self.messageState = LAN_CONSTANTS.MESSAGE_VALUE.STATE_OK.value
+		self.data = self.request.recv(1024).strip()
+		self.traitementResponse(self.data.decode('utf-8'),self.client_address[0])
+
+		if self.messageType == LAN_CONSTANTS.MESSAGE_VALUE.TYPE_RESULT.value:
+			if self.messageState == LAN_CONSTANTS.MESSAGE_VALUE.STATE_OK.value:
+				#self.request.sendall(bytes(BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.MESSAGE_KEY.RETURN_STATE.value,LAN_CONSTANTS.MESSAGE_VALUE.STATE_OK.value,False),"utf-8"))
+				
+				global FOUND
+				FOUND = True
+				easterEgg = EasterEgg()
+				easterEgg.openTray()
+				self.finish()
+		
+		
+	def traitementResponse(self,param,clientAdress):
+		errorMessage = list()
+		errorCode = list()
+		argvArray = param.split(LAN_CONSTANTS.MESSAGE_SPECIAL_CHAR.SEPARATOR.value)
+		for object in argvArray:
+			key,value = BF_Utils.getValueWithKey(object)
+			if key == LAN_CONSTANTS.MESSAGE_KEY.MESSAGE_TYPE.value:
+				self.messageType = value
+			elif key == LAN_CONSTANTS.MESSAGE_KEY.RETURN_STATE.value :
+				self.messageState = value
+			elif key == LAN_CONSTANTS.MESSAGE_KEY.WORD.value :
+				self.word = value
+				
+class InterfaceServer(Thread):
+	def __init__(self,port):
+		Thread.__init__(self)
+		self.port = port
+
+	def run(self):
+		server =  socketserver.TCPServer(('', self.port),  InterfaceServerHandler)
+		while not FOUND:
+			server.handle_request()

BF_InterfaceThread.py

@@ -0,0 +1,12 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+from threding import Thread,queue
+
+class DisplayThread(Threadin.thread):
+	def __init__(self,queue)
+		super.__init__()
+		self.queue = queue
+		
+	def run(self):
+		pass

BF_Main.py

@@ -0,0 +1,328 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+from multiprocessing import Queue
+import sys
+import time
+import os
+import socketserver
+
+from BF_ProcessBruteForce import *
+from BF_MultyStationClient import *
+from BF_MultyStationServer import *
+from BF_InterfaceServer import *
+from BF_GUI import *
+from BF_Constants import *
+from BF_Utils import *
+from BF_Encryption import *
+
+class App():
+	def __init__(self):
+
+		# le Gui gerre l'affichage
+		self.GUI = GUI()
+		self.GUI.displayHeader()
+		
+		#mode de fonctionement
+		self.local = False
+		self.server = False
+		self.client = False
+		
+		#verbose
+		self.verbose = False
+		
+		#parametre client mode
+		self.serverIP = ""
+		self.serverPort = 0
+		
+		#parametre porcess
+		self.password = ""
+		self.encryptionKey = ""
+		self.hashMethod=""
+		self.maxLength = 0
+		self.firstProcessIndex = 0
+		self.nbProcess = 0
+		self.nbTotalProcess = 0
+		
+		## La liste contenant nos object Processe
+		self.processes = list()
+		self.queue = multiprocessing.Queue()
+		self.infoQueue = multiprocessing.Queue()
+		self.found = False
+		self.appTime = time.time()
+		
+	def initProcess(self):
+		if(self.nbProcess > os.cpu_count()):
+			self.GUI.displayError("localhost","Ressources", "Too many process allowed for your computer")
+			sys.exit()
+		for i in range(self.firstProcessIndex, self.firstProcessIndex+self.nbProcess):
+			p=ProcessBruteForce(self.queue, i,self.nbTotalProcess , self.password, self.encryptionKey, self.maxLength, self.verbose, self.hashMethod)
+			self.processes.append(p)
+			
+	def menu(self):
+		# Mode selection
+		self.GUI.displayHeader()
+		entry = list()
+		entry.append("local Mode")
+		entry.append("lan Mode")
+		choice = self.GUI.createMenu("What 's your mode ?",entry,"\t")
+		if(choice == 1):
+			self.local=True
+		else:
+			self.local = False
+			self.GUI.displayHeader()
+			entry = list()
+			entry.append("server")
+			entry.append("client")
+			choice = self.GUI.createMenu("What 's your role ?",entry,"\t")
+			if(choice == 1):
+				self.server=True
+			else:
+				self.client=True
+		#Verbose mode
+		self.GUI.displayHeader()
+		entry = list()
+		entry.append("True")
+		entry.append("False")
+		choice = self.GUI.createMenu("Display Stats",entry,"\t")
+		if(choice == 1):
+			self.verbose=True
+		else:
+			self.verbose=False
+
+		#get server's IP address and port if client mode
+		if self.client:
+			self.GUI.displayHeader()
+			self.serverIP = self.GUI.getStringInputValue("What's the IP server address ?")
+			self.GUI.displayHeader()
+			self.serverPort = self.GUI.getIntInputValue("What's the server port ?")
+			
+		if self.server:
+			self.GUI.displayHeader()
+			self.serverPort = self.GUI.getIntInputValue("What's the server port ?")
+		#Get number of core	
+		self.GUI.displayHeader()
+		self.nbProcess = self.GUI.getIntInputValue("How many core want you allowed?")	
+		
+		if not self.client:
+			#Get max size of password
+			self.GUI.displayHeader()
+			self.maxLength = self.GUI.getIntInputValue("What 's the max size of password do you want to search?")
+			
+			#Get password
+			self.GUI.displayHeader()
+			self.password = self.GUI.getStringInputValue("What's your hash ?")
+			
+			#Get EncryptionKey
+			self.GUI.displayHeader()
+			self.encryptionKey = self.GUI.getStringInputValue("What's your encryption key ? (if you know it)")
+			
+			#Get hashMethod
+			self.GUI.displayHeader()
+			entry = list()
+			entry.append(HASH_METHODS.HASH_METHOD.HASH_MD5.value)
+			entry.append(HASH_METHODS.HASH_METHOD.HASH_SHA1.value)
+			entry.append(HASH_METHODS.HASH_METHOD.HASH_SHA224.value)
+			entry.append(HASH_METHODS.HASH_METHOD.HASH_SHA256.value)
+			entry.append(HASH_METHODS.HASH_METHOD.HASH_SHA384.value)
+			entry.append(HASH_METHODS.HASH_METHOD.HASH_SHA512.value)
+			entry.append(HASH_METHODS.HASH_METHOD.HASH_NONE.value)
+			choiceValue = self.GUI.createMenuValue("Choose a Hash Method",entry,"\t")
+			self.hashMethod = choiceValue		
+
+		#Clear screen
+		self.GUI.displayHeader()
+			
+			
+	def run(self):
+		if self.local :
+			self.localMode()
+		else:
+			if self.server:
+				self.serverMode()
+			else:
+				self.client = True
+				self.clientMode()
+	
+	def clientMode(self):
+		self.GUI.displayHeader()
+		client = MultyStationClient(self.serverIP, self.serverPort)
+		client.configToServer(str(self.nbProcess))
+		serverAnswer = client.receive()
+		key, value = BF_Utils.getValueWithKey(serverAnswer)
+		print(key)
+		if key == ANSWER_STATES.MESSAGE_STATE.STATE_KO.value:
+			print(value)
+		else:
+			#mise en attente de la range
+			self.GUI.displayMessage(self.serverIP,"Mise en attente de la range")
+			value = client.listen()
+			self.nbTotalProcess, self.firstProcessIndex, self.password, self.encryptionKey, self.maxLength, self.hashMethod = client.initParamProcessing(value)
+			self.initProcess()
+			self.executeProcess()
+		sys.exit()
+		return
+		
+	def serverMode(self):
+		server = MultyStationServer('',self.serverPort,self.nbProcess,self.password,'1234',self.maxLength,self.hashMethod)
+		server.connect()
+		server.run()
+		sys.exit()
+		return
+		
+	def localMode(self):
+		self.firstProcessIndex = 0
+		self.nbTotalProcess = self.nbProcess
+		self.initProcess()
+		self.appTime = time.time()
+		self.executeProcess()
+		
+	def initialisation(self):
+		if not self.gestionParams():
+			self.menu()
+		
+	def gestionParams(self):
+		if len(sys.argv) > 1:
+			for argv in sys.argv:
+				if PARAMS_CONSTANTS.LONG_PARAMS.HELP.value == argv or PARAMS_CONSTANTS.SHORT_PARAMS.HELP.value == argv:
+					self.GUI.displayShortHelp()
+					sys.exit()
+					
+				elif  PARAMS_CONSTANTS.LONG_PARAMS.HASH.value in argv:
+					clefParam = "".join(str.split(argv,"=")[0])
+					self.password = "".join(str.split(argv,clefParam + "="))
+					
+				elif  PARAMS_CONSTANTS.LONG_PARAMS.MODE.value in argv or PARAMS_CONSTANTS.SHORT_PARAMS.MODE.value in argv:
+					clefParam = "".join(str.split(argv,"=")[0])
+					mode = "".join(str.split(argv,clefParam + "="))
+					if mode == PARAMS_CONSTANTS.PARAMS_VALUE.MODE_LOCAL.value:
+						self.local = True
+					elif  mode == PARAMS_CONSTANTS.PARAMS_VALUE.MODE_LAN.value:
+						self.local = False
+					else:
+						self.GUI.displayError("127.0.0.1","PARAMETERS","Attribut for " + clefParam  + " no reconize : "+ mode)
+						self.GUI.displayShortHelp()
+						sys.exit()
+						
+				elif  PARAMS_CONSTANTS.LONG_PARAMS.ROLE.value in argv or PARAMS_CONSTANTS.SHORT_PARAMS.ROLE.value in argv:
+					clefParam = "".join(str.split(argv,"=")[0])
+					mode = "".join(str.split(argv,clefParam + "="))
+					if mode == PARAMS_CONSTANTS.PARAMS_VALUE.ROLE_CLIENT.value:
+						self.client = True
+						self.server = False
+					elif  mode == PARAMS_CONSTANTS.PARAMS_VALUE.ROLE_SERVER.value:
+						self.client = False
+						self.server = True
+					else:
+						self.GUI.displayError("127.0.0.1","PARAMETERS","Attribut for " + clefParam  + " no reconize : "+ mode)
+						self.GUI.displayShortHelp()
+						sys.exit()
+						
+				elif  PARAMS_CONSTANTS.LONG_PARAMS.ENCRYPTION_KEY.value in argv or PARAMS_CONSTANTS.SHORT_PARAMS.ENCRYPTION_KEY.value in argv:
+					clefParam = "".join(str.split(argv,"=")[0])
+					self.encryptionKey = "".join(str.split(argv,clefParam + "="))
+					
+				elif  PARAMS_CONSTANTS.LONG_PARAMS.SERVER_IP.value in argv or PARAMS_CONSTANTS.SHORT_PARAMS.SERVER_IP.value in argv:
+					clefParam = "".join(str.split(argv,"=")[0])
+					self.serverIP = "".join(str.split(argv,clefParam + "="))
+				
+				elif  PARAMS_CONSTANTS.LONG_PARAMS.PORT.value in argv or PARAMS_CONSTANTS.SHORT_PARAMS.PORT.value in argv:
+					clefParam = "".join(str.split(argv,"=")[0])
+					self.serverPort = int("".join(str.split(argv,clefParam + "=")))
+					
+				elif  PARAMS_CONSTANTS.LONG_PARAMS.CORE.value in argv or PARAMS_CONSTANTS.SHORT_PARAMS.CORE.value in argv:
+					clefParam = "".join(str.split(argv,"=")[0])
+					self.nbProcess = int("".join(str.split(argv,clefParam + "=")))
+					
+				elif  PARAMS_CONSTANTS.LONG_PARAMS.MAX_LENGTH.value in argv or PARAMS_CONSTANTS.SHORT_PARAMS.MAX_LENGTH.value in argv:
+					clefParam = "".join(str.split(argv,"=")[0])
+					self.maxLength = int("".join(str.split(argv,clefParam + "=")))
+					
+				elif  PARAMS_CONSTANTS.LONG_PARAMS.VERBOSE.value  == argv or PARAMS_CONSTANTS.SHORT_PARAMS.VERBOSE.value == argv:
+					self.verbose = True
+					
+				elif argv == sys.argv[0]:
+					pass
+				else:
+					self.GUI.displayError("127.0.0.1","PARAMETERS","Unknown command \t" + argv)
+					self.GUI.displayShortHelp()
+					sys.exit()
+			return True
+		else:
+			return False
+				
+		
+		
+	def executeProcess(self):
+		self.appTime = time.time()
+		for proc in self.processes:
+			proc.start()
+			
+		procAlive=True
+		totalMotParSecondes = 0
+		if self.client:
+			self.serverInterface = InterfaceServer(self.serverPort +1)
+			self.serverInterface.start()
+		
+		while procAlive:
+			totalMotParSecondes =0
+			procAlive =False
+			processTime = list()
+			words = list()
+			wordsSeconds = list()
+			currentWords = list()
+			porcessName = list()
+			if self.client:
+				if not self.serverInterface.is_alive():
+					for proc in self.processes:
+						proc.terminate()
+					sys.exit()
+				
+			for proc in self.processes:
+				#proc.join()
+				resultat = self.queue.get()
+				if resultat[0]== PROCESS_CONSTANTS.MESSAGE_RETURN_TYPE.RETURN.value : 
+					if self.client :
+						if resultat[1] == True :
+							sock = MultyStationClient(self.serverIP, self.serverPort)
+							sock.resultToServer(resultat[2])
+							self.GUI.displayResult(resultat[2],self.appTime)
+							for proc in self.processes:
+								proc.terminate()
+							sys.exit()
+
+					else :
+						if resultat[1] == True :
+							self.GUI.displayResult(resultat[2],self.appTime)
+							for proc in self.processes:
+								proc.terminate()
+							sys.exit()
+				elif resultat[0] == PROCESS_CONSTANTS.MESSAGE_RETURN_TYPE.PERFS.value :
+					words.append(resultat[1])
+					processTime.append(resultat[2])
+					currentWords.append(resultat[3])
+					porcessName.append(resultat[4])
+					wordsSeconds.append(round(resultat[1]/resultat[2]))
+					totalMotParSecondes = totalMotParSecondes + round(resultat[1]/resultat[2])
+				else:
+					self.GUI.displayError('localhost','useCase',str(resultat[0]) +" non traité")
+					
+				#on verifie qu'il y a encore des process en cours (il n'y a pas de do while en python
+				if proc.is_alive():
+					procAlive =True
+			if self.verbose:
+				if self.client :
+					sock = MultyStationClient(self.serverIP, self.serverPort)
+					sock.infoToServerList(words,processTime,currentWords,porcessName)
+				else :
+					self.GUI.displayProcessPerfsList('localhost',porcessName,wordsSeconds,currentWords)
+					self.GUI.displayTotalPerfs('localhost',totalMotParSecondes)
+					
+		return None
+		
+#si le fichier est lancé seul
+if __name__ == '__main__' :	
+	application = App()
+	application.initialisation()
+	application.run()
+	sys.exit()

BF_MultyStationClient.py

@@ -0,0 +1,124 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+import socket
+import sys
+import time
+import BF_Utils
+from BF_Constants import *
+
+
+class MultyStationClient:
+	def __init__(self, serverAdress, serveurPort):
+		super().__init__()
+		self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+		self.serverAdress = serverAdress
+		self.serveurPort = serveurPort
+		
+	def connect(self):
+		self.sock.connect((self.serverAdress, self.serveurPort))
+	
+	def listen(self):
+		newSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+		newSocket.bind(('',self.serveurPort + 1))
+		newSocket.listen(1)
+	
+		chunks = []
+		bytes_recd = 0
+		#newSocket.connect(('', self.serveurPort + 1))
+		while bytes_recd < 5:
+			conn, addr = newSocket.accept()	
+			#print("test addr: "+ str(addr))
+			chunk = conn.recv(min(2048 - bytes_recd, 2048))
+			#if chunk == b'':
+			#	raise RuntimeError("socket connection broken")
+			chunks.append(chunk)
+			bytes_recd = bytes_recd + len(chunk)
+			data = b''.join(chunks).decode("UTF-8")
+			conn.sendall(bytes(data,"UTF-8"))
+			if data:
+				break
+		return data
+	
+	def initParamProcessing(self, param):
+		errorMessage = list()
+		errorCode = list()
+		argvArray = param.split(LAN_CONSTANTS.MESSAGE_SPECIAL_CHAR.SEPARATOR.value)
+		for object in argvArray:
+			key, value = BF_Utils.getValueWithKey(object)
+			if key == LAN_CONSTANTS.MESSAGE_KEY.NB_CORE_TOTAL.value:
+				nbCoreTotal = int(value)
+			elif key == LAN_CONSTANTS.MESSAGE_KEY.INDEX_CORE_MIN.value:
+				indexCoreMin = int(value)
+			elif key == LAN_CONSTANTS.MESSAGE_KEY.CRYPTED_PASSWORD.value:
+				cryptedPassword = value
+			elif key == LAN_CONSTANTS.MESSAGE_KEY.ENCRYPTION_KEY.value:
+				encryptionKey = value
+			elif key == LAN_CONSTANTS.MESSAGE_KEY.PASSWORD_MAX_LENGTH.value:
+				passwordMaxLength = int(value)
+			elif key == LAN_CONSTANTS.MESSAGE_KEY.HASH_METHOD.value:
+				hashMethod = value
+			
+		return nbCoreTotal, indexCoreMin, cryptedPassword, encryptionKey, passwordMaxLength,hashMethod
+	
+	def send(self, msg):
+		totalsent = 0
+		while totalsent < 5:
+			sent = self.sock.send(msg[totalsent:])
+			if sent == 0:
+				raise RuntimeError("socket connection broken")
+			totalsent = totalsent + sent
+			sent = sent +1
+			
+	def configToServer(self,nbProcess):
+		self.connect()
+		msg = BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.MESSAGE_TYPE.value,LAN_CONSTANTS.MESSAGE_VALUE.TYPE_CONFIG.value,True)
+		msg = msg + BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.NB_CORE_CLIENT.value,nbProcess,False)
+		self.send(bytes(msg,"utf-8"))
+	
+	def infoToServer(self,nbWord,processTime,word,threadName):
+		self.connect()
+		msg = BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.MESSAGE_TYPE.value,LAN_CONSTANTS.MESSAGE_VALUE.TYPE_INFO.value,True)
+		msg = msg + BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.NB_WORDS.value,nbWord,True)
+		msg = msg + BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.PROCESS_TIME.value,processTime,True)
+		msg = msg + BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.WORD.value,word,True)
+		msg = msg + BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.LOCAL_THREAD_NAME.value,threadName,False)
+		self.send(bytes(msg,"utf-8"))
+		
+	def infoToServerList(self,nbWord,processTime,word,threadName):
+		self.connect()
+		msg = BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.MESSAGE_TYPE.value,LAN_CONSTANTS.MESSAGE_VALUE.TYPE_INFO.value,True)
+		msg = msg + BF_Utils.createMessageList(LAN_CONSTANTS.MESSAGE_KEY.NB_WORDS.value,nbWord,True)
+		msg = msg + BF_Utils.createMessageList(LAN_CONSTANTS.MESSAGE_KEY.PROCESS_TIME.value,processTime,True)
+		msg = msg + BF_Utils.createMessageList(LAN_CONSTANTS.MESSAGE_KEY.WORD.value,word,True)
+		msg = msg + BF_Utils.createMessageList(LAN_CONSTANTS.MESSAGE_KEY.LOCAL_THREAD_NAME.value,threadName,False)
+		self.send(bytes(msg,"utf-8"))
+		
+		#time.sleep(0.1)
+		#self.receive()
+		
+	def resultToServer(self,word):
+		self.connect()
+		msg = BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.MESSAGE_TYPE.value,LAN_CONSTANTS.MESSAGE_VALUE.TYPE_RESULT.value,True)
+		msg = msg + BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.RETURN_STATE.value,LAN_CONSTANTS.MESSAGE_VALUE.STATE_OK.value,True)
+		msg = msg + BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.WORD.value,word,False)
+		self.send(bytes(msg,"utf-8"))
+		
+	def receive(self):
+		chunks = []
+		bytes_recd = 0
+		while bytes_recd < 5:
+			chunk = self.sock.recv(min(2048 - bytes_recd, 2048))
+			#if chunk == b'':
+			#	raise RuntimeError("socket connection broken")
+			chunks.append(chunk)
+			bytes_recd = bytes_recd + len(chunk)	
+		return b''.join(chunks).decode("UTF-8")
+		
+if __name__ == '__main__' :	
+	client = MultyStationClient('127.0.0.1',2323)
+	client.connect()
+	client.send(bytes('nbCore:4','UTF-8'))
+	print(client.receive())
+	
+	sys.exit()

BF_MultyStationServer.py

@@ -0,0 +1,265 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+import socketserver
+import socket
+import sys
+import time
+import signal
+import BF_Utils
+from BF_Constants import *
+from BF_GUI import *
+
+COEUR_CONNECTE = 0
+IP_CONNECTE = list()
+CLIENT = list()
+NB_COEUR = 0
+PASSWORD_FOUND = ""
+FOUND = False
+
+class MultyStationServerHandler(socketserver.BaseRequestHandler):
+	"""
+	The RequestHandler class for our server.
+	
+	It is instantiated once per connection to the server, and must
+	override the handle() method to implement communication to the
+	client.
+	"""
+	
+		
+	def __init__(self, request, client_address, server):
+		self.request = request
+		self.client_address = client_address
+		self.server = server
+		self.setup()
+		self.coreClient = 0
+		self.client = list()
+		self.GUI = GUI()
+		self.messageType = LAN_CONSTANTS.MESSAGE_VALUE.TYPE_DEFAULT.value
+		
+		global COEUR_CONNECTE
+		global CLIENT
+		try:
+			self.handle()
+			COEUR_CONNECTE = COEUR_CONNECTE + self.coreClient
+			CLIENT = CLIENT + self.client
+		finally:
+			self.finish()
+		
+	def handle(self):	
+		# self.request is the TCP socket connected to the client
+		self.data = self.request.recv(1024).strip()
+		#self.GUI.displayMessage("".join(self.client_address[0]),self.data.decode('utf-8'))
+		
+		errorCode, errorMessage = self.traitementResponse(self.data.decode('utf-8'),self.client_address[0])
+		if self.messageType == LAN_CONSTANTS.MESSAGE_VALUE.TYPE_CONFIG.value:
+			self.sendResponse(errorCode, errorMessage)
+		elif self.messageType == LAN_CONSTANTS.MESSAGE_VALUE.TYPE_INFO.value:
+			self.managmentInfo(self.data.decode('utf-8'),"".join(self.client_address[0]))
+		elif self.messageType == LAN_CONSTANTS.MESSAGE_VALUE.TYPE_RESULT.value:
+			if self.messageState == LAN_CONSTANTS.MESSAGE_VALUE.STATE_OK.value:
+				#print(self.data.decode('utf-8'))
+				global FOUND
+				FOUND = True
+				#self.finish()
+		return 
+		
+	def setup(self):
+		pass
+	
+	def finish(self):
+		pass
+		
+	def managmentInfo(self,data,clientAdress):	
+		argvArray = data.split(LAN_CONSTANTS.MESSAGE_SPECIAL_CHAR.SEPARATOR.value)
+		processName = list()
+		WordsSeconds = list()
+		curentWord = list()
+		processTime = list()
+		nbWord = list()
+		for object in argvArray:
+			key,value = BF_Utils.getValueWithKey(object)
+			if LAN_CONSTANTS.MESSAGE_SPECIAL_CHAR.SAME_VALUE_SEPRATOR.value in value:
+				
+				contentList = value.split(LAN_CONSTANTS.MESSAGE_SPECIAL_CHAR.SAME_VALUE_SEPRATOR.value)
+				if key == LAN_CONSTANTS.MESSAGE_KEY.LOCAL_THREAD_NAME.value :
+					for content in contentList:
+						processName.append(content)
+				elif key == LAN_CONSTANTS.MESSAGE_KEY.WORD.value:
+					for content in contentList:
+						curentWord.append(content)
+				elif key == LAN_CONSTANTS.MESSAGE_KEY.PROCESS_TIME.value:
+					for content in contentList:
+						processTime.append(float(content))
+				elif key == LAN_CONSTANTS.MESSAGE_KEY.NB_WORDS.value:
+					for content in contentList:
+						nbWord.append(int(content))
+				
+		for i in range(0,len(nbWord)):
+			WordsSeconds.append(round(nbWord[i]/processTime[i]))			
+		self.GUI.displayProcessPerfsList( clientAdress, processName, WordsSeconds, curentWord)
+		"""else:
+				if key == LAN_CONSTANTS.MESSAGE_KEY.LOCAL_THREAD_NAME.value :
+					processName = value
+				elif key == LAN_CONSTANTS.MESSAGE_KEY.WORD.value:
+					curentWord = value
+				elif key == LAN_CONSTANTS.MESSAGE_KEY.PROCESS_TIME.value:
+					processTime = float(value)
+				elif key == LAN_CONSTANTS.MESSAGE_KEY.NB_WORDS.value:
+					nbWord = int(value)
+		WordsSeconds = round(nbWord/processTime)
+		self.GUI.displayProcessPerfs( clientAdress, processName, WordsSeconds, curentWord)"""
+		
+		
+	def sendResponse(self, errorCode, errorMessage):
+		message = list()
+		for i in range(0,len(errorCode)):
+			if not i == (len(errorCode) -1):
+				message.append(errorCode[i]+':'+errorMessage[i]+',')
+			else:
+				message.append(errorCode[i]+':'+errorMessage[i])
+		self.request.sendall(bytes("".join(message),'utf-8'))
+		
+			
+	def traitementResponse(self,param,clientAdress):
+		errorMessage = list()
+		errorCode = list()
+		argvArray = param.split(LAN_CONSTANTS.MESSAGE_SPECIAL_CHAR.SEPARATOR.value)
+		for object in argvArray:
+			key,value = BF_Utils.getValueWithKey(object)
+			if key == LAN_CONSTANTS.MESSAGE_KEY.NB_CORE_CLIENT.value :
+				code, message = self.coreProcessing(value,clientAdress)
+				errorCode = errorCode + code
+				errorMessage = errorMessage + message
+			elif key == LAN_CONSTANTS.MESSAGE_KEY.MESSAGE_TYPE.value:
+				self.messageType = value
+			elif key == LAN_CONSTANTS.MESSAGE_KEY.RETURN_STATE.value:
+				self.messageState = value	
+			elif key == LAN_CONSTANTS.MESSAGE_KEY.WORD.value:
+				global PASSWORD_FOUND
+				PASSWORD_FOUND = value
+			else:
+				errorCode.append(ANSWER_STATES.MESSAGE_STATE.STATE_KO.value)
+				errorMessage.append('protocol key not recognize')
+		return errorCode,errorMessage
+		
+	def coreProcessing(self,value,clientAdress):
+		global IP_CONNECTE
+
+		errorMessage = list()
+		errorCode = list()
+		if BF_Utils.is_int(value):
+			if clientAdress not in IP_CONNECTE:
+				coeurClient = int(value)
+				if coeurClient > 0:
+					if coeurClient <= NB_COEUR:
+						self.coreClient = coeurClient
+						IP_CONNECTE.append(clientAdress)
+						self.client.append((clientAdress,coeurClient))
+						errorMessage.append("core added")
+						errorCode.append(ANSWER_STATES.MESSAGE_STATE.STATE_OK.value)
+					else:
+						errorCode.append(ANSWER_STATES.MESSAGE_STATE.STATE_KO.value)
+						errorMessage.append("Please insert " + str(NB_COEUR - self.coreClient)+ " core max")
+				else:
+					errorCode.append(ANSWER_STATES.MESSAGE_STATE.STATE_KO.value)
+					errorMessage.append("Please insert at least 1 core")
+			else:
+				errorCode.append(ANSWER_STATES.MESSAGE_STATE.STATE_KO.value)
+				errorMessage.append("client already conected")
+		else:
+			errorCode.append(ANSWER_STATES.MESSAGE_STATE.STATE_KO.value)
+			errorMessage.append("Value is not integer")
+			
+		return errorCode,errorMessage
+		
+		
+class MultyStationServer():
+	def __init__(self,host,port,nbCoeur,password,key,passwordLength,hashMethod):
+		global NB_COEUR
+		self.nbCoeur=nbCoeur
+		NB_COEUR = nbCoeur
+		self.serverTime = time.time()
+		self.host = host
+		self.port = port
+		self.coreConnected = 0
+		self.password = password
+		self.passwordLength = passwordLength
+		self.hashMethod=hashMethod
+		self.key = key
+		self.GUI = GUI()
+		signal.signal(signal.SIGINT, self.signal_handler)
+		return
+		
+			
+	def signal_handler(self, signal, frame):
+		self.serverHandler.shutdown()
+		sys.exit(0)
+		
+	def connect(self):
+		self.serverHandler = socketserver.TCPServer((self.host, self.port ),  MultyStationServerHandler)
+		return
+		
+	
+	def run(self):
+		global IP_CONNECTE
+		global FOUND
+		if NB_COEUR < 1:
+			self.GUI.displayError("127.0.0.1","INIT","too low processor core") 
+			sys.exit()
+		while COEUR_CONNECTE < NB_COEUR:
+			self.serverHandler.handle_request()
+			
+			self.GUI.displayMessage(IP_CONNECTE[len(IP_CONNECTE) -1],str(COEUR_CONNECTE) +"/" +str(NB_COEUR))
+		time.sleep(0.1)
+		
+		indexCore = 0
+		for pc in CLIENT:
+			#print("ip : " + pc[0] + "\t Nombre de core offert : " + str(pc[1]))
+			sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+			sock.connect((pc[0],self.port+1))
+			msg = BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.MESSAGE_TYPE.value,LAN_CONSTANTS.MESSAGE_VALUE.TYPE_CONFIG.value,True)
+			msg = msg + BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.NB_CORE_TOTAL.value, str(self.nbCoeur),True)
+			msg = msg + BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.INDEX_CORE_MIN.value, str(indexCore),True)
+			msg = msg + BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.CRYPTED_PASSWORD.value, str(self.password),True)
+			msg = msg + BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.ENCRYPTION_KEY.value, str(self.key),True)
+			msg = msg + BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.HASH_METHOD.value, str(self.hashMethod),True)
+			msg = msg + BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.PASSWORD_MAX_LENGTH.value, str(self.passwordLength),False)
+			#self.GUI.displayMessage("127.0.0.1","Message envoyé : "+msg)
+			sock.send(bytes(msg,"UTF-8"))
+			indexCore = indexCore +pc[1]
+			sock.recv(min(2048, 2048))
+			sock.close()
+			
+		self.serverTime = time.time()
+		self.GUI.displayMessage("SERVER","Start ! ")
+		global FOUND
+		while not FOUND:
+			self.serverHandler.handle_request()
+			
+		self.GUI.displayMessage("SERVER","Found ! ")
+		self.GUI.displayResult(PASSWORD_FOUND,self.serverTime )
+		
+		for pc in CLIENT:
+			sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+			sock.connect((pc[0],self.port+1))
+			msg = BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.MESSAGE_TYPE.value,LAN_CONSTANTS.MESSAGE_VALUE.TYPE_RESULT.value,True)
+			msg = msg + BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.RETURN_STATE.value,LAN_CONSTANTS.MESSAGE_VALUE.STATE_OK.value,True)
+			msg = msg + BF_Utils.createMessage(LAN_CONSTANTS.MESSAGE_KEY.WORD.value,PASSWORD_FOUND,False)
+			sock.send(bytes(msg,"utf-8"))
+			sock.recv(min(2048, 2048))
+			sock.close()
+			
+		for pc in range(0,len(CLIENT)-1):	
+			self.serverHandler.handle_request()
+
+		
+if __name__ == "__main__":
+	HOST = ''
+	PORT = 2323
+	nbCoeur = 8
+	server = MultyStationServer(HOST,PORT,nbCoeur,"azert","",6)
+	server.connect()
+	server.run()
+	sys.exit()
+	

BF_ProcessBruteForce.py

@@ -0,0 +1,109 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+import multiprocessing
+import sys
+import time
+import os
+
+from BF_Encryption import *
+
+tabChar = list("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ")
+		
+class ProcessBruteForce(multiprocessing.Process):
+	def __init__(self,queue, idx, nbInstence,hash, clef, limite, verbose, hashMethode):
+		super().__init__()
+		self.queue = queue
+		self.idx = idx
+		self.nbInstence = nbInstence
+		
+		#la queue contien 3 valeur :int useCase = 0, boolean found, list passTrouve
+		#la queue contien 5 valeur :int useCase = 1,  nbMots, time secondes , list motEnCours nom du thread
+			#useCase = 0, on remonte les information contenant le mot Trouvé ou non  
+			#useCase = 1, on remonte des information sur les performances
+		#gestion du temps
+		self.nbMot = 0
+		self.procTime = time.time()
+		self.verbose = verbose
+		self.hashMethodeFunction = self.getFunctionHash(hashMethode)
+		self.hash = hash
+		if(clef != None):
+			self.keySet = True
+		else:
+			self.keySet = False
+			
+		self.clef = clef
+		self.limite = limite
+		self.password = ''
+		self.isFound  = False
+				
+		self.encryptionObject = Encryption()
+		return
+		
+	def getFunctionHash(self, hashMethode):
+			
+		function = None
+		cryptClass = Encryption()
+		
+		if hashMethode == HASH_METHODS.HASH_METHOD.HASH_MD5.value:
+			function = (cryptClass.md5)
+		elif hashMethode == HASH_METHODS.HASH_METHOD.HASH_SHA1.value:
+			function = (cryptClass.sha1)
+		elif hashMethode == HASH_METHODS.HASH_METHOD.HASH_SHA224.value:
+			function = (cryptClass.sha224)
+		elif hashMethode == HASH_METHODS.HASH_METHOD.HASH_SHA256.value:
+			function = (cryptClass.sha256)
+		elif hashMethode == HASH_METHODS.HASH_METHOD.HASH_SHA384.value:
+			function = (cryptClass.sha384)
+		elif hashMethode == HASH_METHODS.HASH_METHOD.HASH_SHA512.value:
+			function = (cryptClass.sha512)
+		else:
+			function = (cryptClass.none)		
+		return (function)
+		
+	def testSpeed(self):
+		self.nbMot = self.nbMot+1
+		if  (time.time() - self.procTime) > 5 :
+			self.queue.put([1,self.nbMot,time.time() - self.procTime, "".join(self.password),multiprocessing.current_process().name])
+			self.nbMot = 0
+			self.procTime = time.time()
+
+	def md5(self,string):
+		return hashlib.md5(string.encode('utf-8')).hexdigest()
+	
+	def run(self):
+		self.bruteForce(self.hash)
+		
+	def recursiveFunction(self,characters, size , isLast):
+		self.testSpeed()
+		if size == 0:
+			yield []
+		
+		elif not isLast:
+			for i in range(len(characters)):
+				for j in self.recursiveFunction(characters[:i] + characters[i:], size - 1,False):
+					yield [characters[i]] + j
+		else:
+			indexMin = round((len(characters)/self.nbInstence)*self.idx)
+			indexMax = round(indexMin + (len(characters)/self.nbInstence))
+			if( self.idx == self.nbInstence - 1 ):
+				indexMax = len(tabChar)
+			for i in range(indexMin,indexMax):
+				for j in self.recursiveFunction(characters[:i] + characters[i:], size - 1,False):
+					yield [characters[i]] + j
+					
+	def bruteForce(self,hash):
+		workRange = range(0,self.limite)
+		stringBuilder = ''
+		encryptWord = Encryption()
+		for length in workRange:
+			for i in self.recursiveFunction(tabChar, length,True):
+				self.password = stringBuilder + ''.join(i)
+				if encryptWord.hashForLambda(self.hashMethodeFunction,self.password) == hash:
+					self.queue.put([0,True, self.password])
+					return
+					
+		self.queue.put([0,False, self.password])
+#si le fichier est lancé seul
+if __name__ == '__main__' :
+	sys.exit()

BF_Utils.py

@@ -0,0 +1,46 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+from BF_Constants import *
+
+def is_int(stringInteger):
+	try: 
+		int(stringInteger)
+		return True
+	except ValueError:
+		return False
+		
+def is_float(stringFloat):
+	try: 
+		float(stringFloat)
+		return True
+	except ValueError:
+		return False
+		
+def getValueWithKey(value):
+	value = str(value)
+	argvArray = value.split(LAN_CONSTANTS.MESSAGE_SPECIAL_CHAR.SEPARATOR.value)
+	for argv in argvArray:
+		key = argv.split(LAN_CONSTANTS.MESSAGE_SPECIAL_CHAR.ASIGNATOR.value)
+		key = key[0]
+		value = argv.split(LAN_CONSTANTS.MESSAGE_SPECIAL_CHAR.ASIGNATOR.value)
+		value = value[1]			
+	return key, value
+	
+def createMessage(key,value,isNotLast):
+	value = str(value)
+	message = key + LAN_CONSTANTS.MESSAGE_SPECIAL_CHAR.ASIGNATOR.value + value
+	if isNotLast:
+		message = message + LAN_CONSTANTS.MESSAGE_SPECIAL_CHAR.SEPARATOR.value
+	return message
+		
+def createMessageList(key,content,isNotLast):
+	message = key + LAN_CONSTANTS.MESSAGE_SPECIAL_CHAR.ASIGNATOR.value
+	for i  in range(0,len(content)):
+		message = message + str(content[i])	
+		if i < len(content) -1:
+			message = message + LAN_CONSTANTS.MESSAGE_SPECIAL_CHAR.SAME_VALUE_SEPRATOR.value
+	if isNotLast:
+		message = message + LAN_CONSTANTS.MESSAGE_SPECIAL_CHAR.SEPARATOR.value
+	return message
+	

Main.py

@@ -1,88 +0,0 @@
-#!/usr/bin/python3
-# -*- coding: utf-8 -*-
-
-import multiprocessing
-import sys
-import time
-import locale
-from ProcessBruteForce import *
-
-nbProcess = 4
-verbose = False
-
-class App():
-	def __init__(self):
-
-		## La liste contenant nos object Processe
-		self.processes = list()
-		self.queue = multiprocessing.Queue()
-		self.infoQueue = multiprocessing.Queue()
-		self.found = False
-		self.appTime = time.time()
-		global nbProcess
-		global verbose
-		
-		for i in range(0,nbProcess):
-			p=ProcessBrurteForce(self.queue, i,nbProcess , "azerty","",6,verbose)
-			self.processes.append(p)
-			
-	def run(self):
-		for proc in self.processes:
-			proc.start()
-			
-		procAlive=True
-		totalMotParSecondes =0
-		while procAlive:
-			totalMotParSecondes =0
-			procAlive =False
-			for proc in self.processes:
-				#proc.join()
-				resultat = self.queue.get()
-				if resultat[0]== 0 : 
-					if resultat[1] == True :
-						#print("RESULT: %s" % resultat[2])
-						self.displayResult(resultat[2])
-						for proc in self.processes:
-							proc.terminate()
-						sys.exit()
-				elif resultat[0] == 1:
-					WordsSeconds = round(resultat[1]/resultat[2])
-					totalMotParSecondes = totalMotParSecondes + WordsSeconds
-					locale.setlocale(locale.LC_ALL, 'french_france')
-					WordsSeconds = locale.format('%d', WordsSeconds, grouping=True)
-					print(resultat[4]+" : " + '{:>30}'.format(WordsSeconds) + " Mots/s   \tMot actuel : " + resultat[3])
-					
-				else:
-					print("/!\ useCase" + resultat[0] +"non traité") 
-					
-					
-				#on verifie qu'il y a encore des process en cours (il n'y ap aps de do while en python
-				if proc.is_alive():
-					procAlive =True
-			if verbose:
-				locale.setlocale(locale.LC_ALL, 'french_france')
-				totalMotParSecondes = locale.format('%d', totalMotParSecondes, grouping=True)
-				print("Mots Par Secondes :    " +'{:>30}'.format(totalMotParSecondes)+ " Mots/s")
-					
-		return None
-		
-	def displayResult(self,passTrouve):
-		if(time.time() - self.appTime) > 60 :
-			seconds = time.time() - self.appTime
-			m, s = divmod(seconds, 60)
-			h, m = divmod(m, 60)
-			d ,h = divmod(h, 24)
-			if d != 0:
-				print("Found ! : " + passTrouve +" en " + "%d:%02d:%02d:%02d" % (d,h, m, s))
-			elif h != 0 :
-				print("Found ! : " + passTrouve +" en " + "%d:%02d:%02d" % (h, m, s))
-			else:
-				print("Found ! : " + passTrouve +" en " + "%d:%02d" % (m, s))
-		else:
-			print("Found ! : " + passTrouve +" en " + str(time.time() - self.appTime) + " secondes")
-		
-#si le fichier est lancé seul
-if __name__ == '__main__' :	
-	application = App()
-	application.run()
-	sys.exit()

ProcessBruteForce.py

@@ -1,96 +0,0 @@
-#!/usr/bin/python3
-# -*- coding: utf-8 -*-
-
-import multiprocessing
-import sys
-import time
-
-tabChar = list("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ")
-		
-class ProcessBrurteForce(multiprocessing.Process):
-	def __init__(self,queue, idx, nbInstence,password, clef, limite, verbose):
-		super().__init__()
-		self.queue = queue
-		self.idx = idx
-		self.nbInstence = nbInstence
-		
-		#la queue contien 3 valeur :int useCase = 0, boolean found, list passTrouve
-		#la queue contien 5 valeur :int useCase = 1,  nbMots, time secondes , list motEnCours nom du thread
-			#useCase = 0, on remonte les information contenant le mot Trouvé ou non  
-			#useCase = 1, on remonte des information sur les performances
-		#gestion du temps
-		self.nbMot = 0
-		self.procTime = time.time()
-		self.verbose = verbose
-
-		self.password = password
-		self.clef = clef
-		self.limite = limite
-		self.tabPass = list("a")
-		self.isFound  = False
-		return
-		
-	def testSpeed(self):
-		self.nbMot = self.nbMot+1
-		if  (time.time() - self.procTime) > 5 :
-			self.queue.put([1,self.nbMot,time.time() - self.procTime, "".join(self.tabPass),multiprocessing.current_process().name])
-			self.nbMot = 0
-			self.procTime = time.time()
-			
-	def run(self):
-		#print(multiprocessing.current_process().name + "\tStart")
-		found , passTrouve = self.checkChar(0)
-		if not found:
-		
-			while not found and len(self.tabPass) < self.limite:
-				indexMin = round((len(tabChar)/self.nbInstence)*self.idx)
-				indexMax = round(indexMin + (len(tabChar)/self.nbInstence))
-				self.tabPass = self.tabPass + list(tabChar[indexMin])
-				if( self.idx == self.nbInstence - 1 ):
-					indexMax = len(tabChar)
-				for i in range(indexMin,indexMax):
-					self.tabPass[len(self.tabPass)-1] = tabChar[i]
-					found,passTrouve =self.recursiveFunction(len(self.tabPass)-2)
-					if found == True:
-						#la queue contien 2 valeur :  boolean found, list passTrouve
-						#la queue contien 4 valeur :  nbMots, time secondes , list motEnCours nom du thread
-						self.queue.put([0,found, passTrouve])
-						return None
-
-		print(multiprocessing.current_process().name + "\tStop")
-		#la queue contien 2 valeur :  boolean found, list passTrouve
-		#la queue contien 4 valeur :  nbMots, time secondes , list motEnCours nom du thread
-		self.queue.put([0,found, passTrouve])
-		return None
-	
-	def recursiveFunction(self,index):
-		found , passTrouve = self.checkChar(index)
-		if index > 0 and not found:
-			for char in tabChar :
-				self.tabPass[index] = char
-				found, passTrouve =self.recursiveFunction(index-1)
-				if found == True :
-					passTrouve = "".join(self.tabPass)
-					return found, passTrouve
-		
-		return found, passTrouve
-					
-	#Cette fonction permet de replacer le dernier caractère de la Chaine
-	def checkChar(self,index):
-		found = False
-		passTrouve = ""	
-		for char in tabChar:
-			if self.verbose:
-				self.testSpeed()
-			self.tabPass[index] = char
-			if "".join(self.tabPass) == self.password:
-				found=True
-				passTrouve = "".join(self.tabPass)
-				return found, passTrouve
-			#print("".join(self.tabPass))
-		return found, passTrouve
-
-		
-#si le fichier est lancé seul
-if __name__ == '__main__' :
-	sys.exit()

cryptPassV1.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+import hashlib
+import random
+import sys
+
+tabChar = list("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
+
+class CryptPass():
+	def __init__(self):
+		self.passwordNonCrypte = ""
+		self.key = ""
+		self.typeCryptage = ""
+		self.passwordCrypte = ""
+		return None
+
+	def getHash(self, passwordNonCrypteWithKey, typeCryptage):
+		self.passwordCrypte = ""
+		passwordNonCrypteWithKey = passwordNonCrypteWithKey.encode()
+		if typeCryptage == "md5":
+			passwordCrypte = hashlib.md5(passwordNonCrypteWithKey).hexdigest()
+		elif typeCryptage == "sha1":
+			passwordCrypte = hashlib.sha1(passwordNonCrypteWithKey).hexdigest()
+		elif typeCryptage == "sha224":
+			passwordCrypte = hashlib.sha224(passwordNonCrypteWithKey).hexdigest()
+		elif typeCryptage == "sha256":
+			passwordCrypte = hashlib.sha256(passwordNonCrypteWithKey).hexdigest()
+		elif typeCryptage == "sha384":
+			passwordCrypte = hashlib.sha384(passwordNonCrypteWithKey).hexdigest()
+		elif typeCryptage == "sha512":
+			passwordCrypte = hashlib.sha512(passwordNonCrypteWithKey).hexdigest()	
+		self.passwordCrypte = passwordCrypte
+		return self.passwordCrypte
+		
+
+#si le fichier est lancé seul
+if __name__ == '__main__' :
+	app = CryptPass()
+	print(app.getHash(sys.argv[1],"md5"))
+	sys.exit()