#!/usr/bin/python -W ignore::DeprecationWarning

#

# :: Invasion Tux

# :: Ultima modificacion : miercoles, 24 de nov de 2009

# :: Script realizado por makiolo (makiolo@gmail.com) (Licencia Creative Commons con reconocimiento)

# :: Ultima version : http://blogricardo.wordpress.com/2008/12/28/script-para-generar-diccionarios-de-fuerza-bruta/

# :: Dependencias : python

# ::

# :: Modificado por Marcelo M... gracias a makiolo

# :: Objetivo: Generar MD5 para desencriptar passwords por fuerza bruta

# :: Uso: test.py HASH OPCIONES

# :: Opciones:  -r     Alafabeto en reverso

# :: TODO:

# ::    * Hacer que pueda funcionar entre rango de x a x cantidad de carcteres

# ::    * Hacer que grabe cada x cantidad de lineas es estado para luego poder retomar la busqueda



import sys, math, hashlib

import os

from time import time, localtime, strftime

from hashlib import md5, sha1, sha224, sha256, sha384



########################### CONFIGURACION #########################



LONGITUD = 8

ALFABETO = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_-.:,"



####################################################################



########################## FUNCIONES ###############################

def getVariacionesConRepeticion(ALFABETO , LONGITUD):

 sumatorio = 0

 for i in range(LONGITUD):

   producto = 1

   for j in range(i+1):

     producto = producto * len(ALFABETO)

   sumatorio = sumatorio + producto

 return sumatorio



def eventoPalabraGenerada(palabra, buscado, tiempo):

 hash = md5(palabra)

 password = hash.hexdigest()

 print "MD5:    "  + palabra + " - " + password +" - " + tiempo

 if password == buscado:

       print "\n\n\nDesencriptado MD5["+palabra + "] = " + buscado+"\n\n\n"

       sys.exit()

 hash = sha1(palabra)

 password = hash.hexdigest()

 print "SHA1:   "  + palabra + " - " + password +" - " + tiempo

 if password == buscado:

       print "\n\n\nDesencriptado SHA1["+palabra + "] = " + buscado+"\n\n\n"

       sys.exit()

 hash = sha224(palabra)

 password = hash.hexdigest()

 print "SHA224: "  + palabra + " - " + password +" - " + tiempo

 if password == buscado:

       print "\n\n\nDesencriptado SHA224["+palabra + "] = " + buscado+"\n\n\n"

       sys.exit()

 hash = sha256(palabra)

 password = hash.hexdigest()

 print "SHA256: "  + palabra + " - " + password +" - " + tiempo

 if password == buscado:

       print "\n\n\nDesencriptado SHA256["+palabra + "] = " + buscado+"\n\n\n"

       sys.exit()

####################################################################



##################### VARS AUXILIARES ##############################

DEBUG = True

VERBOSE = True

variacionesConRepeticion = getVariacionesConRepeticion(ALFABETO , LONGITUD)

inicioReloj = time()

cont = 0

progreso = 0

tiempo =  ""

calculo = False

##################### OPCIONES #####################################

entrada = sys.argv

buscado = entrada[1]

filename = 'status.decode'



if (len(sys.argv) >= 3):

       if (entrada[2] == "-r"):

               ALFABETO = ALFABETO[::-1]

               filename = 'status.decode.inv'



####################################################################





contadores = []



if os.path.exists(filename):

       print "viejo"

       infile = open(filename,"r")

       for linea in infile.readlines():

               contadores.append(int(linea.strip()))

       infile.close()

else:

       print "nuevo"



print contadores

#os.exit()



while LONGITUD > 0:

 try:

                                                        # ponemos los contadores a 0

   for i in range(LONGITUD):

       contadores.append(0)





   fin = False

   while not fin:



     if VERBOSE == True:

                       if calculo == True:

                               if (cont % 600000 == 0) and (cont != 0):

                                       progreso = cont*100.0/variacionesConRepeticion                # porcentaje hasta ahora

                                       progreso = round(progreso , 2)

                                       finReloj = time() - inicioReloj                               # finReloj es lo que esta tardando el calculo

                                       velocidad = cont / finReloj                                   # palabras procesadas por segundo

                                       velocidad = round(velocidad , 2)

                                       estimado = finReloj * variacionesConRepeticion / cont         # es lo que se estima en realizar todo el proceso

                                       restante = estimado - finReloj                                # es lo que se estima en realizar lo restante

                                       restante = restante / 60 / 60                                 # lo pasamos a horas

                                       restante = round(restante , 2)

                                       unidad = "horas"



                                       if(restante >=24):

                                               restante = restante/24

                                               unidad = "dias"

                                               if(restante >=365):

                                                       restante = restante/24

                                                       unidad = "anios"



                               tiempo = str(progreso)+"% -  "+str(restante)+" "+unidad+". "+str(velocidad)+" palabras/seg"

                       #sys.stderr.write(str(progreso)+"% - Quedan "+str(restante)+" horas. La velocidad es de "+str(velocidad)+" palabras/seg\n")

                       else:

                               tiempo = ""



     if DEBUG == True:

       palabra=[]                                                                                                              # Creas una lista vacia (y liberas de paso)

       for i in range(LONGITUD):

         palabra.append(ALFABETO[contadores[i]])                                               # Vas metiendo al final letra a letra

       eventoPalabraGenerada("".join(palabra),buscado, tiempo)                 # Envias a tu callback tada la lista unida



     cont = cont + 1

     actual = LONGITUD - 1                                             # Pongo actual a la derecha del todo

     contadores[actual] = contadores[actual] + 1                       # Sumo 1 a las unidades



     while(contadores[actual] == len(ALFABETO)) and not fin:           # Propago el carry

       if(actual == 0):

         fin = True                                                    # FIN

       else:

                       contadores[actual] = 0                                        # reinicia el actual contador

                       actual = actual - 1                                           # avanza a la izquierda



                       contadores[actual] = contadores[actual] + 1                   # y le sumo 1

                       if os.path.exists(filename):

                               os.unlink(filename)

                       FILE = open(filename,"w")

                       if (len(contadores)>=1):

                               for i in contadores:

                                       FILE.write(str(i)+"\n")

                       FILE.close()



   LONGITUD = LONGITUD - 1                                             # combinaciones para uno menos







 except KeyboardInterrupt:

   sys.stderr.write("Interrumpido por el usuario\n")

   fin = True                                                          # Fuerzo las condiciones de salida

   LONGITUD = 0



if VERBOSE == True:

 sys.stderr.write("Terminado al "+str(progreso)+"% - Realizadas "+str(cont)+" combinaciones de "+str(variacionesConRepeticion)+"\n")