def __init__(self):

self.start_time = time.monotonic()

self.process_lock = BoundedSemaphore(value=cpu_count())

self.counter_lock = threading.BoundedSemaphore(value=1)

self.banner()

self.stop = Queue(maxsize=1)

self.stop.put(False)

self.count = Queue(maxsize=1)

self.threads = []

self.name = Queue(maxsize=1)

self.name.put(str("a"))

self.process_count = 0

self.limit_process = 500

self.shot = 5000

def fun(self, string):

list = []

fer = ['-', "\\", "|", '/']

for char in string:

list.append(char)

timer = 0

pointer = 0

fer_pointer = 0

while timer < 20:

list[pointer] = list[pointer].upper()

print("\r" + self.blue("".join(str(x) for x in list) + " " + fer[fer_pointer]), end="")

list[pointer] = list[pointer].lower()

max_fer = len(fer) - 1

if fer_pointer == max_fer:

fer_pointer = -1

max = len(list) - 1

if pointer == max:

pointer = -1

pointer += 1

fer_pointer += 1

timer += 1

time.sleep(0.1)

if timer == 20:

print("\r" + self.blue(string) + "\n", end="")

return

def blue(self, string):

return colored(string, "blue", attrs=['bold'])

def green(self, string):

return colored(string, "green", attrs=['bold'])

def yellow(self, string):

return colored(string, "yellow", attrs=['bold'])

def red(self, string):

return colored(string, "red", attrs=['bold'])

def bwhite(self, string):

return colored(string, "white", attrs=['bold'])

def white(self, string):

return colored(string, "white")

def detect_file_type(self, file):

if str(file).split(".")[-1] == "rar":

return "rar"

elif str(file).split(".")[-1] == "zip":

return "zip"

elif str(file).split(".")[-1] == "pdf":

return "pdf"

else:

return "text"

def count_word(self, dict_file):

count = 0

with open(dict_file, "r") as wordlist:

for line in wordlist:

count += 1

return count

def count_possible_com(self, chars, min, max):

x = min

possible_com = 0

while x <= max:

possible_com += len(chars) ** x

x += 1

return possible_com

def counter(self, max_words):

self.counter_lock.acquire()

num = self.count.get()

# print(self.count)

# print(num)

if num != 0:

self.count.put(num - 1)

current_word = max_words - int(num) + 1

percent = (100 * current_word) / max_words

width = (current_word + 1) / (max_words / 42) # 100 / 25

bar = "\t" + self.white("Progress : [") + "#" * int(width) + " " * (42 - int(width)) \

+ "] " + self.yellow(str("%.3f" % percent) + " %")

# time.sleep(1)

sys.stdout.write(u"\t\u001b[1000D" + bar)

sys.stdout.flush()

self.counter_lock.release()

def handling_too_many_open_files_error(self):

if self.process_count == self.limit_process:

for x in self.threads:

x.join()

self.threads = []

self.limit_process += 500

def search_zip_pass(self, passwords_list, compress_file, max_words):

try:

temp_file = self.create_temporary_copy(compress_file, passwords_list[1])

for word in passwords_list:

password = word.strip('\r').strip('\n')

stop = self.stop.get()

self.stop.put(stop)

if stop is False: # if find password dont doing more

self.counter(max_words)

try:

with zipfile.ZipFile(temp_file, "r") as zfile:

zfile.extractall(pwd=bytes(password, encoding='utf-8'))

self.stop.get()

self.stop.put(True)

time.sleep(3)

print("\n\t" + self.green("[+] Password Found: " + password) + "\n")

break

except Exception as e:

# print(e)

pass

else:

break

if os.path.isfile(temp_file):

os.remove(os.path.abspath(temp_file))

# last_process_number = int(max_words / self.shot) + (max_words % self.shot > 0)

if str(self.last_process_number) in str(current_process().name):

time.sleep(20)

stop = self.stop.get()

self.stop.put(stop)

if stop is False:

print("\n\t" + self.red("[-] password not found") + "\n")

else:

pass

self.process_lock.release()

except KeyboardInterrupt:

self.process_lock.release()

def create_temporary_copy(self, file, word):

name = self.name.get()

name2 = str(word)

self.name.put(name2)

directory_path = "temp_directory"

try:

os.mkdir(directory_path)

except FileExistsError:

pass

temp_file_name = "temp" + name + "." + self.file_type

temp_file_path = directory_path + '/' + temp_file_name # linux path

shutil.copy2(file, temp_file_path)

return temp_file_path

def delete_temporary_directory(self):

if os.path.exists("temp_directory"):

shutil.rmtree("temp_directory")

def search_rar_pass(self, passwords_list, compress_file, max_words):

try:

temp_file = self.create_temporary_copy(compress_file, passwords_list[1])

for word in passwords_list:

password = word.strip('\r').strip('\n')

stop = self.stop.get()

self.stop.put(stop)

if stop is False: # if find password dont doing more

self.counter(max_words)

try:

with rarfile.RarFile(temp_file, "r") as rfile:

# print(password) very useful for trouble shooting

rfile.extractall(pwd=password)

self.stop.get()

self.stop.put(True)

time.sleep(3)

print("\n\t" + self.green("[+] Password Found: " + password + '\n'))

break

except Exception as e:

# print(e)

pass

else:

break

if os.path.isfile(temp_file):

os.remove(os.path.abspath(temp_file))

# last_process_number = int(max_words / 500) + (max_words % 500 > 0)

if str(self.last_process_number) in str(current_process().name):

time.sleep(20)

stop = self.stop.get()

self.stop.put(stop)

if stop is False:

print("\n\t" + self.red("[-] password not found") + "\n")

else:

pass

self.process_lock.release()

except KeyboardInterrupt:

self.process_lock.release()

def search_pdf_pass(self, passwords_list, file, max_words):

try:

temp_file = self.create_temporary_copy(file, passwords_list[1])

for word in passwords_list:

password = word.strip('\r').strip('\n')

stop = self.stop.get()

self.stop.put(stop)

if stop is False: # if find password dont doing more

self.counter(max_words)

proc = subprocess.Popen(['qpdf', "--password=" + password, '--decrypt', temp_file, self.decrypted_file_name], stderr=subprocess.PIPE)

proc.wait()

# output, error = proc.communicate()

status = proc.returncode

if status == 0:

self.stop.get()

self.stop.put(True)

time.sleep(3)

print("\n\t" + self.green("[+] Password Found: " + password))

print("\t" + self.blue("[*]") + self.white(" Your decrypted file is ") + self.bwhite(self.decrypted_file_name) + "\n")

# self.end_time()

break

elif status == 2:

pass

else:

break

# for thread in self.threads:

# print(thread)

# last_process_number = int(max_words / 500) + (max_words % 500 > 0)

if str(self.last_process_number) in str(current_process().name):

time.sleep(20)

stop = self.stop.get()

self.stop.put(stop)

if stop is False:

print("\n\t" + self.red("[-] password not found") + "\n")

else:

pass

self.process_lock.release()

except KeyboardInterrupt:

self.process_lock.release()

def search_shadow_pass(self, passwords_list, salt_for_crypt, crypt_pass, max_words, user):

try:

for word in passwords_list:

password = word.strip('\r').strip('\n')

stop = self.stop.get()

self.stop.put(stop)

if stop is False: # if find password dont doing more

self.counter(max_words)

cryptword = crypt.crypt(password, salt_for_crypt)

if cryptword == crypt_pass:

self.stop.get()

self.stop.put(True)

time.sleep(4)

print("\n\t" + self.green("[+] Password Found: " + password) + "\n")

break

else:

pass

else:

break

# print(last_process_number)

# print(str(current_process().name))

if str(self.last_process_number) in str(current_process().name):

time.sleep(20)

stop = self.stop.get()

self.stop.put(stop)

if stop is False:

print("\n\t" + self.red("[-] password not found") + "\n")

else:

pass

self.process_lock.release()

except KeyboardInterrupt:

self.process_lock.release()

def last_words_check(self, max_words, passwords_list, file):

while True:

if self.stop is True:

exit(0)

elif self.count == len(passwords_list):# self_cont kam mishe

if self.file_type is "rar":

self.search_rar_pass(passwords_list, file, max_words)

if self.stop is False:

print("\n\t" + self.red("[-] Password not found") + "\n")

self.delete_temporary_directory()

self.end_time()

return

else:

pass

def dict_guess_password(self, dict_file, file):

last_check = 0

passwords_group = []

possible_words = self.count_word(dict_file)

self.last_process_number = int(possible_words / self.shot) + (possible_words % self.shot > 0)

self.count.put(possible_words)

self.file_type = self.detect_file_type(file)

self.fun("Starting password cracking for " + file)

print("\n " + self.blue("[*]") + self.white(" Count of possible passwords: ") + self.bwhite(str(possible_words)))

if self.file_type == "text":

file = open(file)

for line in file.readlines():

self.count.get()

self.count.put(possible_words)

crypt_pass = line.split(':')[1].strip(' ')

if crypt_pass not in ['*', '!', '!!']:

user = line.split(':')[0]

print(" " + self.blue("[**]") + self.white(" cracking Password for: ") + self.bwhite(user))

algorythm = crypt_pass.split('$')[1].strip(' ')

salt = crypt_pass.split('$')[2].strip(' ')

salt_for_crypt = '$' + algorythm + '$' + salt + '$'

with open(dict_file, "r") as wordlist:

for word in wordlist:

passwords_group.append(word)

last_check += 1

self.handling_too_many_open_files_error()

if (len(passwords_group) == self.shot) or (possible_words - last_check == 0):

passwords = passwords_group

passwords_group = []

self.process_lock.acquire()

stop = self.stop.get()

self.stop.put(stop)

if stop is False:

t = Process(target=self.search_shadow_pass,

args=(passwords, salt_for_crypt, crypt_pass, possible_words, user))

self.threads.append(t)

self.process_count += 1

t.start()

else:

self.process_lock.release()

else:

continue

for x in self.threads:

x.join()

self.last_process_number *= 2

self.end_time()

elif self.file_type == "zip":

with open(dict_file, "r") as wordlist:

for word in wordlist:

passwords_group.append(word)

last_check += 1

self.handling_too_many_open_files_error()

if (len(passwords_group) == self.shot) or (possible_words - last_check == 0):

passwords = passwords_group

passwords_group = []

self.process_lock.acquire()

stop = self.stop.get()

self.stop.put(stop)

if stop is False:

t = Process(target=self.search_zip_pass, args=(passwords, file, possible_words))

self.threads.append(t)

self.process_count += 1

t.start()

else:

self.process_lock.release()

else:

continue

for x in self.threads:

x.join()

self.delete_temporary_directory()

self.end_time()

elif self.file_type == "pdf":

self.decrypted_file_name = "decrypted_" + file.split('/')[-1]

with open(dict_file, "r") as wordlist:

for word in wordlist:

passwords_group.append(word)

last_check += 1

self.handling_too_many_open_files_error()

if (len(passwords_group) == self.shot) or (possible_words - last_check == 0):

passwords = passwords_group

passwords_group = []

self.process_lock.acquire()

stop = self.stop.get()

self.stop.put(stop)

if stop is False:

t = Process(target=self.search_pdf_pass, args=(passwords, file, possible_words))

self.threads.append(t)

self.process_count += 1

t.start()

else:

self.process_lock.release()

else:

continue

for x in self.threads:

x.join()

self.delete_temporary_directory()

self.end_time()

elif self.file_type == "rar":

with open(dict_file, "r") as wordlist:

for word in wordlist:

passwords_group.append(word)

last_check += 1

self.handling_too_many_open_files_error()

if (len(passwords_group) == self.shot) or (possible_words - last_check == 0):

passwords = passwords_group

passwords_group = []

self.process_lock.acquire()

stop = self.stop.get()

self.stop.put(stop)

if stop is False: # ok finishing all process after finding password

t = Process(target=self.search_rar_pass, args=(passwords, file, possible_words))

self.threads.append(t)

self.process_count += 1

t.start()

else:

self.process_lock.release()

else:

continue

for x in self.threads:

x.join()

self.delete_temporary_directory()

self.end_time()

def bruteforce_guess_password(self, chars, min, max, file):

last_check = 0

passwords_group = []

possible_com = self.count_possible_com(chars, int(min), int(max))

self.last_process_number = int(possible_com / self.shot) + (possible_com % self.shot > 0)

self.count.put(possible_com)

self.file_type = self.detect_file_type(file)

self.fun("Starting password cracking for " + file)

print("\n " + self.blue("[*]") + self.white(" Count of possible passwords: ") + self.bwhite(str(possible_com)))

if self.file_type == "text":

file = open(file)

for line in file.readlines():

self.count.get()

self.count.put(possible_com)

crypt_pass = line.split(':')[1].strip(' ')

if crypt_pass not in ['*', '!', '!!']:

user = line.split(':')[0]

print(" " + self.blue("[**]") + self.white(" cracking Password for: ") + self.bwhite(user))

algorythm = crypt_pass.split('$')[1].strip(' ')

salt = crypt_pass.split('$')[2].strip(' ')

salt_for_crypt = '$' + algorythm + '$' + salt + '$'

for password_length in range(int(min), int(max) + 1):

for guess in itertools.product(chars, repeat=password_length):

guess = ''.join(guess)

passwords_group.append(guess)

last_check += 1

self.handling_too_many_open_files_error()

if (len(passwords_group) == self.shot) or (possible_com - last_check == 0):

passwords = passwords_group

passwords_group = []

self.process_lock.acquire()

stop = self.stop.get()

self.stop.put(stop)

if stop is False:

t = Process(target=self.search_shadow_pass, args=(passwords, salt_for_crypt, crypt_pass, possible_com, user))

self.threads.append(t)

self.process_count += 1

t.start()

else:

self.process_lock.release()

else:

continue

for x in self.threads:

x.join()

self.last_process_number *= 2

self.end_time()

elif self.file_type == "zip":

for password_length in range(int(min), int(max) + 1):

for guess in itertools.product(chars, repeat=password_length):

guess = ''.join(guess)

passwords_group.append(guess)

last_check += 1

self.handling_too_many_open_files_error()

if (len(passwords_group) == self.shot) or (possible_com - last_check == 0):

passwords = passwords_group

passwords_group = []

self.process_lock.acquire()

stop = self.stop.get()

self.stop.put(stop)

if stop is False:

t = Process(target=self.search_zip_pass, args=(passwords, file, possible_com))

self.threads.append(t)

self.process_count += 1

t.start()

else:

self.process_lock.release()

else:

continue

for x in self.threads:

x.join()

self.delete_temporary_directory()

self.end_time()

elif self.file_type == "pdf":

self.decrypted_file_name = "decrypted_" + file.split('/')[-1]

for password_length in range(int(min), int(max) + 1):

for guess in itertools.product(chars, repeat=password_length):

guess = ''.join(guess)

passwords_group.append(guess)

last_check += 1

self.handling_too_many_open_files_error()

if (len(passwords_group) == self.shot) or (possible_com - last_check == 0):

passwords = passwords_group

passwords_group = []

self.process_lock.acquire()

stop = self.stop.get()

self.stop.put(stop)

if stop is False:

t = Process(target=self.search_pdf_pass, args=(passwords, file, possible_com))

self.threads.append(t)

self.process_count += 1

t.start()

else:

self.process_lock.release()

else:

continue

for x in self.threads:

x.join()

self.delete_temporary_directory()

self.end_time()

elif self.file_type == "rar":

for password_length in range(int(min), int(max) + 1):

for guess in itertools.product(chars, repeat=password_length):

guess = ''.join(guess)

passwords_group.append(guess)

last_check += 1

self.handling_too_many_open_files_error()

if (len(passwords_group) == self.shot) or (possible_com - last_check == 0):

passwords = passwords_group

passwords_group = []

self.process_lock.acquire()

stop = self.stop.get()

self.stop.put(stop)

if stop is False: # ok finishing all process after finding password

t = Process(target=self.search_rar_pass, args=(passwords, file, possible_com))

self.threads.append(t)

self.process_count += 1

t.start()

else:

self.process_lock.release()

else:

continue

for x in self.threads:

x.join()

self.delete_temporary_directory()

self.end_time()

def make_chars(self, char_type):

chartype_list = char_type.split(",")

chars = ""

for chartype in chartype_list:

if chartype == "lowercase":

chars += string.ascii_lowercase

elif chartype == "uppercase":

chars += string.ascii_uppercase

elif chartype == "letters":

chars += string.ascii_letters

elif chartype == "digits":

chars += string.digits

elif chartype == "symbols":

chars += string.punctuation

elif chartype == "space":

chars += " "

else:

return False

return chars

def banner(self):

term.clear()

term.pos(1, 1)

banner = pyfiglet.figlet_format("ZYDRA", font="epic").replace("\n", "\n\t\t", 7)

cprint("\r\n\t" + "@" * 61, "blue", end="")

cprint("\n\t\t" + banner + "\t\tAuthor : Hamed Hosseini", "blue", attrs=['bold'])

cprint("\t" + "@" * 61 + "\n", "blue")

def end_time(self):

self.stop = True

end_time_show = time.asctime()

end_time = time.monotonic()

execution_time = (timedelta(seconds=end_time - self.start_time))

print(self.blue("End time ==> ") + self.white(end_time_show))

print(self.blue("Execution time ==> ") + self.white(str(execution_time)) + "\n")

term.saveCursor()

term.pos(7, 15)

term.writeLine("ok", term.green, term.blink)

term.restoreCursor()

exit(0)

def main(self):

start_time_show = time.asctime()

usage = "%prog [options] [args]" \

"\n\nDictionary Mode:" \

"\n %prog -f <file> -d <wordlist>" \

"\n\nBrute force Mode:" \

"\n %prog -f <file> -b <char_type> -m <min_length> -x <max_length>" \

"\n\n Available char_type:" \

"\n\t<lowercase> The lowercase letters abcdefghijklmnopqrstuvwxyz" \

"\n\t<uppercase> The uppercase letters ABCDEFGHIJKLMNOPQRSTUVWXYZ" \

"\n\t<letters> The concatenation of the lowercase and uppercase"\

"\n\t<digits> numbers 0123456789" \

"\n\t<symbols> punctuation characters !#$%&'()*+,-./:;<=>?@[\]^_`{|}~'" + '"' \

"\n\t<space> space character" \

"\n You can select multiple character types." \

"\n\tExample: %prog -f <file> -b <space,digits> -m 1 -x 8"

parser = optparse.OptionParser(usage)

parser.add_option("-d", dest="dictfile", type='string', help="Specifies dictionary file")

parser.add_option("-f", dest="file", type='string', help="Specifies the file")

parser.add_option("-b", dest="chartype", type='string', help="Specifies the character type")

parser.add_option("-m", dest="minlength", type='string', help="Specifies minimum length of password")

parser.add_option("-x", dest="maxlength", type='string', help="Specifies maximum length of password")

(options, args) = parser.parse_args()

try:

if options.file:

if os.path.isfile(options.file):

file = os.path.abspath(options.file)

if options.dictfile:

if os.path.isfile(options.dictfile):

dictfile = os.path.abspath(options.dictfile)

print(self.blue("Start time ==> ") + self.white(start_time_show) + "\n")

self.dict_guess_password(dictfile, file)

else:

parser.error(" " + options.dictfile + " dictionary file does not exist")

exit(0)

elif options.chartype:

chars = self.make_chars(options.chartype)

if chars is False:

parser.error(" " + options.chartype + " character type is not valid, Use --help for more info")

if options.minlength is None:

parser.error(" Enter minimum length of password")

exit(0)

if options.maxlength is None:

parser.error(" Enter maximum length of password")

exit(0)

if options.minlength > options.maxlength:

parser.error(" Min and Max must be numbers and Min must be \nless than Max or be the same"

", Use --help for more info")

exit(0)

else:

print(self.blue("Start time ==> ") + self.white(start_time_show) + "\n")

self.bruteforce_guess_password(chars, options.minlength, options.maxlength, file)

else:

parser.error(" Choose a wordlist or bruteforce method, Use --help for more info")

exit(0)

else:

parser.error("" + options.file + " file does not exist")

exit(0)

else:

parser.error(" Choose a file, Use --help for more info")

exit(0)

except KeyboardInterrupt:

time.sleep(1)

self.delete_temporary_directory()

print(self.red("\n\n [-] Detected CTRL+C") + self.white("\n closing app...\n Finish\n"))

# self.end_time()