Script para generar diccionarios de fuerza bruta

Ultima modificación : miércoles, 10 de diciembre de 2009

Necesitaba abrir un pdf protegido por contraseña. Era un pdf con las notas de mi novia, y el cual el profesor se iba equivocado metiendo la contraseña y la pobre se iba a quedar todas las navidades sin saber la nota, asi que intentamos hacer fuerza bruta sobre el fichero, con exito.

Desarrolle un script en python que generara palabras de una longitud máxima a partir de un cadena que define un alfabeto. En mi ejemplo configuro las variables con estos valores:

LONGITUD = 6
ALFABETO = "abcdefghijklmnopqrstuvwxyz0123456789_-."

Generar todas las combinaciones posibles conlleva no solo considerar las de longitud 6, si no tambien las de longitud 5,4,3,2 e incluso 1. El alfabeto tiene 39 caracteres por tanto todas las combinaciones posibles son:

cálculo de combinaciones

Contraseñas de longitud mayor que 8 son muy costosas computacionalmente, por ello el script que he realizado me interesa que de mucha información de cuanto queda y cuanto lleva. En concreto 3 cosas:

• El porcentaje que lleva del total.
• Tiempo estimado restante (en horas, lo he puesto).
• Velocidad: en palabras generadas por segundo

Con el dual core de mi portatil a 2.2 Ghz y con el ejemplo que pongo de palabras de hasta 6 caracteres y un alfabeto de 39 caracteres, los tiempos son muy buenos (aunque queda pendiente el uso de paralelización por MPI o algo así):

• Velocidad media aprox: 610.000 palabras generadas / seg
• Tiempo total : 1 hora 50 min

A continuación os pasteo el script (abrir un gedit generarDiccionario ):

#!/usr/bin/python
#
# :: Invasion Tux
# :: Ultima modificacion : miercoles, 10 de diciembre de 2009
# :: Script realizado por makiolo (makiolo@gmail.com) (Licencia Creative Commons con reconocimiento)
# :: Ultima version : https://blogricardo.wordpress.com/2008/12/28/script-para-generar-diccionarios-de-fuerza-bruta/
# :: Dependencias : python 2.5
#

import sys, math, hashlib
from time import time, localtime, strftime
from hashlib import md5, sha1, sha224, sha256, sha384

########################### CONFIGURACION BASICA #########################

LONGITUD = 5
ALFABETO = "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789_-."

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

########################### CONFIGURACION EXTRA ####################

CALCULAR_TIEMPO_RESTANTE = True

LLAMAR_EVENTO = False

GENERAR_FICHERO = True
DESTINO_FICHERO = "diccionario.txt"

BUSCAR_HASH = True
HASH_ALGORITMO = md5 # Opciones: md5, sha1, sha224, sha256, sha384
HASH_BUSCADO = "6091ece73d7b32b63e2f7db82e3bfe9d"

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

########################## CALLBACK ###############################

# ES UN CALLBACK MODIFICABLE SEGUN LA FUNCIONALIDAD A IMPLEMENTAR
def eventoPalabraGenerada(palabra):
  print palabra

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

########################## 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

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

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

variacionesConRepeticion = getVariacionesConRepeticion(ALFABETO , LONGITUD)
PERIODO_MOSTRAR_ESTADISTICAS = 600000
inicioReloj = time()
cont = 0
progreso = 0

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

if GENERAR_FICHERO:
  f = open(DESTINO_FICHERO,"w")

LONGITUD_MAXIMA = LONGITUD
LONGITUD = 1
while LONGITUD <= LONGITUD_MAXIMA:
  try:
    contadores = []                                   # ponemos los contadores a 0
    for i in range(LONGITUD):
      contadores.append(0)

    fin = False
    while not fin:

      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
      palabra_formada = "".join(palabra)

      if GENERAR_FICHERO:
        f.write("%s\n" % palabra_formada)

      if LLAMAR_EVENTO:
        eventoPalabraGenerada(palabra_formada)        # Envias a tu callback tada la lista unida

      if BUSCAR_HASH:
        # algorimos disponibles:
        HASH = HASH_ALGORITMO(palabra_formada).hexdigest()
        if HASH == HASH_BUSCADO:
          print "\n\nDesencriptado el HASH %s !!!!\n" % HASH
          print "Su valor desencriptado es \"%s\"\n\n" % palabra_formada
          raise KeyboardInterrupt

      if CALCULAR_TIEMPO_RESTANTE:
        if (cont % PERIODO_MOSTRAR_ESTADISTICAS == 0) and (cont != 0):
          try:
            progreso = cont*100.0 / variacionesConRepeticion              # porcentaje hasta ahora
            finReloj = time() - inicioReloj                               # finReloj es lo que esta tardando el calculo
            velocidad = cont / finReloj                                   # palabras procesadas por segundo
            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
            if restante > 60:
              restante = restante / 60                                    # lo pasamos a minutos
              if restante > 60:
                restante = restante / 60                                 # lo pasamos a horas
                unidad = "horas"
              else:
                unidad = "mins"
            else:
              unidad = "segs"
            sys.stderr.write("%.2f%% - Quedan %.2f %s. La velocidad es de %.2f palabras/seg\n" % (progreso, restante, unidad, velocidad))
          except ZeroDivisionError:
            pass

      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

    LONGITUD = LONGITUD + 1                                             # combinaciones para uno menos

  except KeyboardInterrupt:
    sys.stderr.write("Proceso interrumpido\n")
    fin = True                                                          # Fuerzo las condiciones de salida
    LONGITUD = LONGITUD_MAXIMA+1

if cont == variacionesConRepeticion:
  sys.stderr.write("Terminado al 100%\n")
else:
  if CALCULAR_TIEMPO_RESTANTE:
    sys.stderr.write("Terminado al %.2f%%\n" % progreso)
  sys.stderr.write("Realizadas %d combinaciones de %d\n" % (cont, variacionesConRepeticion))

if GENERAR_FICHERO:
  f.close()

Importante cosas que teneis que tener en cuenta:

• P0deis configurar perfectamente la longitud máxima y el alfabeto a uno de vuestro gusto.
• No hace falta decir, que como script debeis darle permisos.
• Tampoco hace falta decir que el uso de este script es con fines didácticos.
• Lo importante es que las palabras salen por el stdout
• Toda la información de cuanto queda para acabar, velocidad … Todo lo «verbose» o «debug» sale por stderr
• Como consecuencia de lo anterior surgen 2 comandos útiles:

1. Generar un diccionario:stdout a un ficherostderr a la basura(/dev/null) o mejor no lo redireccionas y va a la pantallaPara estar informados del proceso os recomiento :./generarDiccionario > diccionario.txt
2. Es interesante combinarlo con awk pero aqui si que debemos mandar a la basura toda la información de cuanto queda. Probar esto :./generarDiccionario 2> /dev/null | awk ‘{print «La password es » $1}’Bueno, print es un comando de salida de awk, otro comando más interesante es system(), mirar un ejemplo para ver si conecto a mi propio servidor mysql por fuerza bruta:

   ./generarDiccionario 2> /dev/null | awk '{print "Probando con " $1;system("mysql -h\"localhost\" -u\"root\" -p\"" $1 "\" -e\"quit\" && echo Password " $1 " CORRECTA >> ataque.log");}'

   Si consiguiera conectarse con alguna contraseña quedaría registrado en ataque.log . Para cortar la ejecución os recomiendo Ctrl + Z y poner kill %1

   Esta es una posibilidad de miles, al ser un script, su verdadero potencial esta en combinarlo con otros programas de shell, ya os digo yo realmente lo uso con «pdftotext fichero.pdf -upw PASSWORD» combinando igual awk + comando de shell.

EDITO: En vista a algunos comentarios he decidido añadir algunas modificaciones:

• Refaztorizado parte del código. Variables con más semántica, redondeos mediante %.2f, lista de parametros en los print. Limpieza de código.
• Para facilitar la tarea a los usuarios de windows, que no suelen estar tan acostumbrados a la redirección a archivos, ahora se genera el diccionario en un txt.
• He añadido soporte para dado un Hash en alguno de los siguientes algoritmos: md5, sha1, sha224, sha256, sha384. Por fuerza bruta se encuentre la semilla del hash.
• Todo esto es configurable en las seccion CONFIGURACION BÁSICA Y EXTRAS.