diff --git a/BF_Constants.py b/BF_Constants.py new file mode 100644 index 0000000..e394619 --- /dev/null +++ b/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" \ No newline at end of file diff --git a/BF_EasterEgg.py b/BF_EasterEgg.py new file mode 100644 index 0000000..1def3b9 --- /dev/null +++ b/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) \ No newline at end of file diff --git a/BF_Encryption.py b/BF_Encryption.py new file mode 100644 index 0000000..103522c --- /dev/null +++ b/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() \ No newline at end of file diff --git a/BF_GUI.py b/BF_GUI.py new file mode 100644 index 0000000..cc3f58c --- /dev/null +++ b/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] + + diff --git a/BF_InterfaceServer.py b/BF_InterfaceServer.py new file mode 100644 index 0000000..d1ed2c8 --- /dev/null +++ b/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() \ No newline at end of file diff --git a/BF_InterfaceThread.py b/BF_InterfaceThread.py new file mode 100644 index 0000000..be1f66e --- /dev/null +++ b/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 \ No newline at end of file diff --git a/BF_Main.py b/BF_Main.py new file mode 100644 index 0000000..9a4b8ec --- /dev/null +++ b/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() diff --git a/BF_MultyStationClient.py b/BF_MultyStationClient.py new file mode 100644 index 0000000..eef829b --- /dev/null +++ b/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() \ No newline at end of file diff --git a/BF_MultyStationServer.py b/BF_MultyStationServer.py new file mode 100644 index 0000000..694b318 --- /dev/null +++ b/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() + diff --git a/BF_ProcessBruteForce.py b/BF_ProcessBruteForce.py new file mode 100644 index 0000000..6c98a8b --- /dev/null +++ b/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() diff --git a/BF_Utils.py b/BF_Utils.py new file mode 100644 index 0000000..6396654 --- /dev/null +++ b/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 + \ No newline at end of file diff --git a/Main.py b/Main.py deleted file mode 100644 index 3a0c9a2..0000000 --- a/Main.py +++ /dev/null @@ -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() \ No newline at end of file diff --git a/ProcessBruteForce.py b/ProcessBruteForce.py deleted file mode 100644 index f1e5808..0000000 --- a/ProcessBruteForce.py +++ /dev/null @@ -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() \ No newline at end of file diff --git a/cryptPassV1.py b/cryptPassV1.py new file mode 100644 index 0000000..0e3b5e6 --- /dev/null +++ b/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() \ No newline at end of file