Me lo contaron y lo olvidé, lo leí y lo entendí, lo hice y lo aprendí.





domingo, 19 de agosto de 2012

Tercer BOSS: Hielo-Fox

A casi cuatro meses de la última vez que toque con el proyecto, le dediqué un sábado en la tarde para crear lo que será el tercer jefe del juego: Hielo-Fox.



Haciendo una parodia en el nombre, éste tercer jefe será muy peculiar ya que será muy agresivo en sus ataques además de que no tendrá un solo ataque; y, para acabar con las ansias de comer de nuestro personaje, los ataques llegan a ser más rápidos al bajar la vida de nuestro enemigo hasta cierto punto.
El escenario será muy diferente al de los otros 2 jefes; éste será grande, Aquiles tendrá que superar su fobia por los escalones y moverse continuamente para estar esquivando los ataques del enemigo... claro, si su físico no se lo impide.
He aquí la imagen del escenario:


Y, por supuesto, lo más importante para el final, pues resulta que la debilidad de Hielo-Fox serán sus ataques y sólo sus ataques. Ya que, como este jefe no se presentará con un "cuerpo", solo se le podrá golpear a los ataques que lance; a ver si con tanto salto y esquiva, nuestro personaje baje un poco de peso. Éstos ataques son:
->Una espiral helada que aparecerá cada cierto tiempo que Aquiles se encuentre quieto, lo que obliga a estar moviéndose en cada momento (en ocasiones aparecerá incluso en el aire O_o).
->Unas aves de hielo que atacarán como torpedos desde lo alto para destruirse con el primer impacto que tengan (No serán muy rápidas, para no descalabrar a nuestro personaje).
->Y un zorro que emergerá en la parte inferior cada cierto tiempo para intentar devorar a nuestro héroe; se entiende que este zorro tiene siglos sin comer como para tener de apetito al personaje.


Será difícil, pero a éstas alturas del juego se tendrá el doble salto y, al menos, la primera magia (Kame-kame-ohm); además de que quiero que éste jefe otorgue otra magia, y que sea muy buena.


Ya estamos a poco de que Aquiles termine su aventura, ya que les recuerdo que éste será solo un mini-juego.
Nos leemos.

Apaga la TV
y enciende tu cerebro

lunes, 6 de agosto de 2012

Crack de contraseñas SHA1 en Python [Fuerza bruta]

Hace poco mostré un Script que creaba un diccionario básico para encontrar contraseñas por medio de fuerza bruta (Generador de Contraseñas [diccionario] en Pyhon) ; ahora traigo otro script que complementa al anterior, un programa que lee las contraseñas generadas, las procesa mediante la digestión SHA1 y las compara con una contraseña ya codificada para encontrar la palabra correcta.
El Script funciona con cualquier diccionario siempre y cuando las contraseñas candidatas estén separadas por un salto de línea, o sea:

contraseña1
contraseña2
contraseña3
...

Como siempre, primero el código:

# -*- coding: cp1252 -*-
import hashlib
archivo = raw_input("Archivo en donde se encuentran las contraseñas: ")
password= raw_input("Escribe la contraseña digerida: ")
try:
    diccionario = open(archivo,"r")
except:
    print "Error al abrir el archivo"
    raw_input("Presione cualquier tecla para salir...")
    exit()

print "comenzamos"


while True:

    linea = diccionario.readline()
    if not linea:
        raw_input("No se encontró la contraseña en el archivo")
        break
    linea=linea.replace("\n","")
    encriptacion=hashlib.sha1(linea).hexdigest()
    if encriptacion == password:
        print "Se encontró la contraseña: "
        print linea
        raw_input()
        break

print "Fin del programa"

raw_input("Presione cualquier tecla para salir")


  • Primero se importa el módulo "hashlib" el cual contiene varios métodos de digestión (hash).
  • Se pide al usuario el diccionario del cual se obtendrán las contraseñas candidatas y la contraseña ya digerida que se va a buscar.
  • En el bloque try-except se intenta abrir el diccionario y de no existir se lanzará una excepción.
  • En el bloque WHILE es donde se realiza la comprobación de las contraseñas:
  1. Se lee una línea del archivo, si se llegó al final de éste se lanza un mensaje diciendo que la contraseña no fue encontrada en el archivo.
  2. De ser una línea válida, a ésta se le quita el salto de línea que contiene al final (en caso de tener éste símbolo).
  3. Se le aplica la digestión a la contraseña extraía del archivo y se compara con la contraseña a buscar; de coincidir ambas, se muestra el valor de la contraseña extraída antes de ser digerida; de lo contrario se prosigue con el bucle en la siguiente línea para leer otra nueva contraseña candidata.
Como ven, los mecanismos de fuerza bruta son muy sencillos, el problema como siempre son los costos en memoria, procesador y tiempo; pero son los que dan más seguridad de encontrar alguna contraseña.
Para el caso de cualquier otro tipo de digestión que contenga el módulo hashlib no hace falta nada más que cambiar la encriptación del comando:
encriptacion=hashlib.sha1(linea).hexdigest()

por cualquier otra deseada, como por ejemplo md5:
encriptacion=hashlib.md5(linea).hexdigest()

Sin nada más que explicar, nos leemos.

Apaga la TV
y enciende tu cerebro

jueves, 2 de agosto de 2012

Generador de Contraseñas [Diccionario] en Python

En el ámbito del Hacking los diccionarios de contraseñas son muy útiles a la hora de crackear contraseñas mediante la fuerza bruta, ya que el tener las posibles contraseñas es un archivo del cual se van obteniendo una por una y es analizada es más rápido que generar en tiempo real la "palabra candidata" para después ser probada.
El método que es más usado es tener una base de datos con palabras comunes y/o palabras claves que pueden ser usadas como contraseñas (Contraseñas comunes como "perro", "amor", "123456", "drácula", "thehungergames", etc); pero éste método no da un alto porcentaje de acierto a la hora de usar fuerza bruta, por lo cual es más conveniente usar la mayor cantidad de posibles combinaciones de letras, números y signos posibles para las contraseñas. Éste método requiere de más tiempo, más tiempo de procesamiento y, obviamente, más espacio de almacenado, pero entre más combinaciones se tengan mayor es el porcentaje de acierto a la hora de buscar una contraseña en específico.

En esta ocasión realicé un pequeño Script en Python que genera un archivo con todas las posibles contraseñas que contengan una longitud entre 1 y 20 que se puedan generar con las combinaciones de letras mayúsculas, minúsculas, números y los signos '-' (guión medio) y '_' (guión bajo).

Primero el código Pythoneano:

# -*- coding: cp1252 -*-
letras = ['','a','b','c','d','e','f','g','h','i','j','k','l','m','n','ñ','o','p','q','r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','Ñ','O','P','Q','R','S','T','U','V','W','X','Y','Z','1','2','3','4','5','6','7','8','9','0','-','_']
indices=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
#67 elementos en la lista
i=0
diccionario=open("diccionario.lis","w")
while(indices[20]==0):
cadena=""
while( j < 20  )  :
if(indices[j] > = 6 7 ) :
indices[j]=0
indices[j+1]=indices[j+1]+1
cadena=cadena+letras[indices[j]]
j=j+1
#print cadena+"\n"
diccionario.write(cadena+"\n")
indices[0]=indices[0]+1
if(indices[0]>=67):
indices[0]=0
indices[1]=indices[1]+1
diccionario.close()
print "terminado"

Como podrán notar, el código esta poco optimizado y es muy bizarro, pero cumple con su función; la explico:

Primero se crea una lista (letras) con los caracteres que quiero incluir en las combinaciones de contraseñas, tomando en cuenta la posición vacía (""). Noten que cuento que tengo 67 caracteres.

Después creo otra lista (indices) que me guardará la posición de los índices por cada posición posible y le agrego una posición más a la lista, lo cual no es del todo necesario pero no quise complicarme con validaciones.
con open('diccionario.lis','w') abro/creo un archivo con permisos de escritura en donde iré guardando las contraseñas generadas. Hago ésto antes de empezar con las iteraciones para no gastar recursos del procesador al estar abriendo y cerrando el archivo, además de que en python se sobre-escribiría el archivo si se abre de ésta manera.

Empiezo con las iteraciones, el "while(indices[20]==0)" me asegura el el último índice (el 21) de la lísta de índices será 0, ya que al vale 1 quiere decir que los demás índices ya habrán dado toda la vuelta y por consiguiente se habrán realizado las combinaciones posibles.

cadena="" crea una variable cadena que inicia vacía, esta cadena es la que contendrá la contraseña generada; poco a poco se le irán concatenando los caracteres.

while( j < 20  )  :
if(indices[j] > = 6 7 ) :
indices[j]=0
indices[j+1]=indices[j+1]+1
cadena=cadena+letras[indices[j]]
j=j+1

Esta parte de código lo que hace es concatenar el carácter que apunta cada índice a la variable cadena; el "if(indices[j] >=67)..." lo que hace es comprobar si el índice ya superó la cantidad de caracteres con los que manejo (en éste caso 67) para reiniciar a 0 la cuenta y aumentar en 1 el índice que le sigue.
Después se concatena el valor del índice a la variable "cadena".
y aumento en 1 el índice J para seguir con el siguiente, valga la redundancia, índice.

con diccionario.write(cadena+"\n") simplemente escribo la contraseña en el archivo, concatenando el salto de línea "\n".

El "if(indices[0]=..." solo comprueba que si el primer índice ya superó los 67 caracteres, para así aumentarse en 1 o bien para reiniciar a 0 y aumentar en 1 al siguiente índice.

Finalmente, cuando terminan todas las combinaciones posibles, cierro la conexión con el archivo y termino el programa.



Ésto sería todo.
Tengo pensado hacer programas que, usando el diccionario generado por este Script se puedan "desencriptar" contraseñas digeridas en MD5 y SHA1.

Por ahora nos seguiremos leyendo.


Apaga la TV
Y enciende tu cerebro