Primero de todo vamos a hacer un programa que nos permita calcular el hash md5 de un string que se le pase y luego ya pasaremos al crackeador.

Sería más fácil hacer un script en bash o perl gracias a la utilidad CLI de OpenSSL, a la hora de calcular un solo hash no importa mucho la velocidad pero si luego queremos hacer un pequeño crackeador no podemos partir de algo que ya sabemos que va a ser mucho más lento. Así que lo que vamos a usar es C y la librería de OpenSSL.

Si no sabemos por donde empezar un extracto del man:

$ man md5
...
SYNOPSIS
 
#include <openssl/md2.h>
 
        unsigned char *MD5(const unsigned char *d, unsigned long n,
                         unsigned char *md);
 
        int MD5_Init(MD5_CTX *c);
        int MD5_Update(MD5_CTX *c, const void *data,
                         unsigned long len);
        int MD5_Final(unsigned char *md, MD5_CTX *c);
...
DESCRIPTION
...
Applications should use the higher level functions EVP_DigestInit(3) etc. instead of calling the hash functions directly.
...

Vemos que podríamos añadir esa librería y usar las funciones MD5_Init(), MD5_Update y MD5_Final pero ya nos avisan que deberíamos usar unas funciones de más alto nivel así que: EVP_DigestInit

$ man EVP_DigestInit
...
SYNOPSIS
        #include <openssl/evp.h>
 
        void EVP_MD_CTX_init(EVP_MD_CTX *ctx);
        EVP_MD_CTX *EVP_MD_CTX_create(void);
 
        int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl);
        int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *d, size_t cnt);
        int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md,
               unsigned int *s);

De paso, aprovecho para desaconsejar el uso de MD5 a día de hoy y como mínimo usar SHA1 o incluso dejarte de monsergas y pasar a SHA256, SHA512.

He intentado que el programa sea bastante fácil de entender y seguir, ahí va:

#include <stdio.h>
#include <string.h>
 
#include <openssl/evp.h>
 
#ifdef DEBUG
#define DBG 1
#else
#define DBG 0
#endif
 
#define MAX_SIZE_WORD 200
 
unsigned char *simple_digest(char *algth, char *buffer, unsigned int len, int *olen){
 
	EVP_MD *m;
	EVP_MD_CTX ctx;
	unsigned char *ret;
 
	OpenSSL_add_all_digests ();
	if (!(m = (EVP_MD*) EVP_get_digestbyname(algth)))
		return NULL;
 
	if (!(ret = (unsigned char *) malloc(EVP_MAX_MD_SIZE)))
		return NULL;
 
	EVP_DigestInit(&ctx, m);
	EVP_DigestUpdate(&ctx, buffer, len);
	EVP_DigestFinal(&ctx, ret, olen);
 
	return ret;
}
 
void hex_print(unsigned char *buff,int len){
	int i;
	for(i=0;i<len;i++)
		printf("%02x",(unsigned char)(buff[i]&0xFF));	
}
 
int main(int argc, char **argv){
 
	unsigned char buff[MAX_SIZE_WORD];
	int olen;
	char *out;
 
	if(!argv[1]) {
	        printf("Usage: mymd5 word\n");
        	exit(1);
	}
 
	// copy arg string into a buffer
	if (strlen(argv[1]) < MAX_SIZE_WORD ){
 
		strncpy(buff, argv[1], strlen(argv[1]));
 
		// calculate string's md5 hash
		out = simple_digest("md5",buff,strlen(argv[1]),&olen);
 
		// print results	
		if (DBG){
			printf("Word: %s\n",argv[1]);
			printf("Hash: ");
		}
		hex_print(out,olen);
		printf("\n");
 
		return 0;
	}
 
	printf("\nNot computing hash\n");
	printf("\nI can feel your dark side... ;)\n");
 
	return -1;
}

Compilamos y probamos:

$ gcc mymd5.c -o mymd5 -l ssl
$ ./mymd5 passworddeelite
5b4f50aa173b977e4cd0850cf7c52bd0

Podemos comprobar su correcto funcionamiento comparando con webs online que ofrecen utilidades para calcular hashes MD5 [1], [2].

Y ahora a por el crackeador. No vamos a intentar buscar colisiones sino a partir de un diccionario sacar la clave. Le pasaremos como parámetros un fichero con el hash y un diccionario con una palabra por línea.

#include <stdio.h>
#include <string.h>
 
#include <openssl/evp.h>
 
#ifdef DEBUG
#define DBG 1
#else
#define DBG 0
#endif
 
#define MAX_SIZE_BUFF 200
 
unsigned char *simple_digest(char *algth, char *buffer, unsigned int len, int *olen){
 
	EVP_MD *m;
	EVP_MD_CTX ctx;
	unsigned char *ret;
 
	OpenSSL_add_all_digests ();
	if (!(m = (EVP_MD*) EVP_get_digestbyname(algth)))
		return NULL;
 
	if (!(ret = (unsigned char *) malloc(EVP_MAX_MD_SIZE)))
		return NULL;
 
	EVP_DigestInit(&ctx, m);
	EVP_DigestUpdate(&ctx, buffer, len);
	EVP_DigestFinal(&ctx, ret, olen);
 
	return ret;
}
 
void hex_print(unsigned char *buff,int len){
	int i;
	for(i=0;i<len;i++)
		printf("%02x",(unsigned char)(buff[i]&0xFF));	
}
 
void strtohex(unsigned char *in, unsigned char *out,int len){
	int i;
	char tmp[3];
	tmp[2]=0;
	for(i=0;i<len/2;i++){
		tmp[0]=in[2*i];
		tmp[1]=in[2*i+1];
		out[i]=strtol(tmp,NULL,16);
	}
}
 
int main(int argc, char **argv){
 
	int tries=0;
	unsigned char buff_words[MAX_SIZE_BUFF];
	unsigned char hash[16];
	unsigned char *line=NULL;
	int len=100,read;
	int olen;
	char *out;
 
	if(argc<3) {
	        printf("Usage: mymd5crack /path/to/hashfile /path/to/dictfile\n");
        	exit(1);
	}
 
	FILE *hashfile;
	hashfile = fopen(argv[1],"r");
	if(!hashfile){
		perror(argv[1]);
	return -1;
	}
 
 
	FILE *dictfile;
	dictfile = fopen(argv[2],"r");
	if(!dictfile){
		perror(argv[2]);
	return -1;
	}
 
	read = getline(&line, &len, hashfile);
	if(strlen(line)!=33){
		fprintf(stderr,"ERROR: Invalid hash length %d\n",strlen(line));
		return -1;
	}	
 
	strtohex(line,hash,32);
 
	if(DBG){
			printf("Input hash: %s\n", line);
			printf("Input buffer from hash: ");
			hex_print(hash,16);
			printf("\n\n");
	}
 
	//Read words in a loop
	while((read = getline(&line, &len, dictfile)) != -1){
		if( strlen(line) < 200){
			tries++;	
 
			//Copy word into buffer
			strcpy(buff_words,line);
 
			if(DBG)
				printf("Input buffer from dict: %s \n",buff_words);
			// compute md5
			out = simple_digest("md5",buff_words,strlen(line)-1,&olen);
 
			if(DBG){	
				printf("For password %s MD5 is: ",line);
				hex_print(out,olen);
				printf("\n\n");	
			}
 
			//Compare computed md5 with hash
			if(memcmp(out,hash,16) == 0){
 
				printf("PASSWORD FOUND!! in %d tries: %s\n",tries,line);
 
				fclose(hashfile);
				fclose(dictfile);
				free(out);
				if(line)
					free(line);
 
				return 0;	
			}
			free(out);
		}else{
			printf("\nWords from dict too long... cough*, cough*...\n");
		}
	}
 
	printf("Password not found in %d tries!\n",tries);
 
	if(line)
		free(line);
 
	fclose(hashfile);
	fclose(dictfile);
 
	return 0;
}

Y comprobamos su funcionamiento metiendo en /tmp/hash el hash obtenido anteriormente:

$ gcc mymd5cracker.c -o mymd5cracker -l ssl
$ ./mymd5cracker /tmp/hash /tmp/dict
PASSWORD FOUND!! in 6 tries: passworddeelite

Premio! Podéis ir en paz.

Para descargar mymd5.c y mymd5cracker.c

Gracias a TuXeD que siempre está ahí para echar una mano.

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Descifrando un reto del FBI
• Soluciones del reto de criptografía – Parte 2
• Port-Knocking y Crypt-Port-Knocking

El driver está desarrollado en C, como no, ¿por qué? pues porque:

• es adecuado para programar drivers porque nos proporciona funcionalidad a ‘bajo nivel’ siendo un lenguaje de ‘alto nivel’.
• facilmente podremos crear bindings en c++, java, python, ruby, …
• será fácil luego adaptarlo a sistema embebidos (empotrados, embedded o como se les quieran llamar)

Está implementado en forma de librería y recibe el nombre de libfprint y depende de otras librerías como:

• libusb: nos proporciona I/O al bus USB y además es portable a FreeBSD, Mac OSX, Windows y más.
• glib: un gran librería de rutinas en C de las cuales usaremos unas poquitas (listas enlazadas, operaciones sobre strings, para reservar memoria, etc)

A continuación os pongo un esquema de como está estructurado:

Como se puede ver, tendremos una API de alto nivel donde se nos proporcionan funciones para registrar huellas de dedos (enrollment), verificar (comprobar que la huella escaneada coincide con la almacenada contra la que se ha pedido confirmación) y identificar (encontrar entre las huellas almacenadas una que coincida con la escaneada). La diferencia entre verificar y identificar sería la misma que entre elegir tu nombre de usuario y escanear tu dedo y en lugar de eso escanear tu huella y que el sistema reconozca tu usuario y te confirme.

De estas funciones tendríamos 2 variantes, la que nos devuelve la imagen por si además si quisiéramos hacer alguna cosa con ella y que simplemente realiza su función:

- fp_enroll_finger( )
- fp_verify_finger( )
- fp_identify_finger( )
- fp_enroll_finger_img( )
- …

luego podríamos usar un trozo de código similar a esto:

if (is_imaging_device(dev))
fp_enroll_finger_img(&data, &img);
else
fp_enroll_finger(&data);

Para empezar a usar los dispositivos tendremos disponibles las siguiente funciones que son bastante autoexplicativas:

- fp_discover_devices()
- fp_dev_open() / fp_dev_close()

Para detectar qué dispositivo tenemos es fácil ya que el descriptor del dispositivo incluye un código con el Vendor (fabricante) y el Product ID (identificación de producto) que lo identifica inequívocamente. Por ejemplo, podremos obtener ese código con un simple  ‘lsusb’.

Por debajo de la capa “Imaging layer” para escanear necesitaremos las funciones para detectar la presencia del dedo, escanear y detectar la ausencia de dedo.

Como ya hemos contado en otros posts, el dispositivo upek al ser autónomo no requerirá de estas funciones.

Igualmente dispondremos de una serie de funciones para el almacenamiento.

Para el que quiera entretenerse un rato aquí hay más información sobre la API disponible: http://www.reactivated.net/fprint/api/

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• [Fprint] Mejoras en el driver y algunos extras
• [Fprint] Los dispositivos
• [Fprint] Procesado de la imagen – Huellas dactilares

Hace unas semanas me apunté al curso introductorio a OpenGL que daba Egon directo desde la rama de IEEE de Valencia. Este curso pretendía ser algo básico, partiendo desde cero, aunque bastante condensado para que puedas sacarle jugo más adelante a lo visto. La verdad es que me gustó mucho y me ha dejado un buen sabor de boca, con ganas de más.

Desde un principio estuvimos probando todas las cosas que se iban comentando en clase y se dejó un ejercicio propuesto para que nos entretuviéramos un poquito más. Era una escena de un planeta tierra y demás cositas dando vueltas que teníamos que copiar así que me he decidido a publicar mi solución para generar esa escena. Aunque la idea era la misma, he cambiado objetos, modelos, órbitas, rotaciones, etc, así me ha resultado más entretenido.

Para no aburrir con un rollo largo sobre OpenGL a continuación os pondré el código con bastantes comentarios de modo que quede bastante claro. Está programado en C++ usando librerías de SDL y alguna más para otras funcionalidades.

Alguna parte del código es un poco cerda pero para que sirva de ejemplo ya os sobra!!

Como creo que debe ser bastante incómodo leer el código en un post aquí tenéis el main.cpp comentado y si queréis ver el resultado aquí tenéis un .rar para ejecutarlo sobre tarjetas nVIDIA y ATI y aquí sobre Intel. Se podía poner una función que detectara que hacer en cada caso pero soy un perro. Os dejo por ahí dentro también las librerías por si queréis echarles un vistazo.

Espero que os guste!

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• [Fprint] La implemetación del driver
• Soluciones del reto de criptografía – Parte 2
• Crackeador de hashes MD5 en C y OpenSSL