MD5 Double Hash crack

Recentemente mi sono accorto che alcuni servizi di hosting conservano nel database le passwords degli accounts in doppia hash md5.
Per doppia hash intendo

MD5(MD5(password)).

Un tentativo di forzare una password in questo stato facendo uso dei servizi online come Md5Crack o come Gdata,sarebbe totalmente inutile.
Il sistema che ho implementato è banale,prevede la ricerca della password a partire da una hash doppia,facendo uso di un dizionario: di ogni voce del dizionario viene calcolata la hash doppia e viene confrontata con l’input,se vi è un match il programma si arresta e fornisce la voce ottenuta.
Sicuramente una ricerca lineare non è il massimo,l’ideale è implementare un database distribuito come il celebre rainbow tables,ma per le hashes doppie attualmente non sembra esserci altro.
Facendo uso di un buon dizionario di passwords,come questo,il programmino impiega un tempo nell’ordine di 30 secondi per scorrere un tale dizionario,e parliamo di circa 40MB.
Nel codice faccio uso di una funzione molto importante per la gestione dei files da applicativi in C :
la funzione mmap,tale funzione consente di mappare un file sullo spazio di indirizzamento virtuale del processo,in pratica vi muoverete sul file come su un vettore void* ,fate il cast a char*e avrete una vera e propria stringa:potete dimenticarvi quindi delle odiose fseek,fwrite etc…
La funzione MD5,presa dalla libreria libssl, con header in

openssl/md5.h

ha 3 argomenti:stringa da criptare,dimensione in bytes della stringa da criptare,stringa su cui riporre l’hash.

La stringa su cui viene calcolato l’hash si presenta come un vettore di caratteri ascii,poichè non sembra esserci una funzione di libreria atoh,che converta da stringa ascii a stringa esadecimale,l’ho dovuta implementare.
Compilate tutto con

 gcc -O3 -lssl md5doublecrack.c -o md5doublecrack
Ecco il codice:

#include <openssl /md5.h>
#include <string .h>
#include <stdlib .h>
#include <sys /types.h>
#include </sys><sys /stat.h>
#include <fcntl .h>
#include <stdio .h>
#include <sys /mman.h>

#define SIZEOF_HMD 32
#define SIZEOF_AMD 16
#define FALSE 0
#define TRUE 1

void crack(char*,const char*);
int filelength(const char*);
void atoh(char*,const char*);
int match(const char* input,const char* token);
void check_parameters(int,char**);

int main(int argc,char* argv[])
{
	const char* double_hash_input;
	char* file_name;
	int fd;
	void* file_memory;
	void* file_dump;
	int file_length;

	check_parameters(argc,argv);

	double_hash_input=argv[1];
	file_name=argv[2];

	if(strlen(double_hash_input)!=32)
		exit(1);

	file_length=filelength(file_name);
	fd=open(argv[2],O_RDONLY, S_IRUSR);
	file_memory = mmap (0, file_length, PROT_READ, MAP_SHARED, fd, 0);
	close(fd);

	memcpy(file_dump=malloc(sizeof(char)*file_length),file_memory,file_length);
	munmap(file_memory,file_length);

	crack((char*)file_dump,double_hash_input);
	return;
}

void crack(char* file,const char* input_hash)
{
	char* token;
	int cracked=FALSE;
	char a_hashed_entry[SIZEOF_AMD];
	char a_double_hashed_entry[SIZEOF_AMD];
	char h_hashed_entry[SIZEOF_HMD];
	char h_double_hashed_entry[SIZEOF_HMD];
	int string_length;

	token=strtok(file,"\n");
	cracked=match(input_hash,token);	

	while(token != NULL && cracked == FALSE )
		{
			token=strtok(NULL,"\n");
			if(token == NULL)
				break;

			string_length=strlen(token);

			MD5(token,string_length,a_hashed_entry);
			atoh(h_hashed_entry,a_hashed_entry);
			MD5(h_hashed_entry,SIZEOF_HMD,a_double_hashed_entry);
			atoh(h_double_hashed_entry,a_double_hashed_entry);

			if(strncmp(h_double_hashed_entry,input_hash,SIZEOF_HMD)==0)
				cracked=TRUE;
		}

		if(cracked == TRUE)
			printf("Match found with entry %s\n",token);
		else
			printf("Sorry,no match found\n");

			free(file);
}

int filelength(const char* file_name)
{
	FILE * file = fopen (file_name,"rb");

	/*obtain the file size*/
	fseek (file , 0 , SEEK_END);
	long int size = ftell(file);
	rewind (file);
	fclose(file);
	return size;
}

int match(const char* input_hash,const char* token)
{
	char a_hashed_entry[SIZEOF_AMD];
	char a_double_hashed_entry[SIZEOF_AMD];
	char h_hashed_entry[SIZEOF_HMD];
	char h_double_hashed_entry[SIZEOF_HMD];
	int string_length;

	if(token == NULL)
		exit(1);

	string_length=strlen(token);
	MD5(token,string_length,a_hashed_entry);
	atoh(h_hashed_entry,a_hashed_entry);
	MD5(h_hashed_entry,SIZEOF_HMD,a_double_hashed_entry);
	atoh(h_double_hashed_entry,a_double_hashed_entry);
	return strncmp(h_double_hashed_entry,input_hash,SIZEOF_HMD)==0 ? TRUE : FALSE;
}

void atoh(char* string,const char* bytes)
{
	register int i;
	for(i=0;i< SIZEOF_AMD ;i++)
	{
	        sprintf(string++,"%x",(bytes[i]&0xff)>>4);
                sprintf(string++,"%x",bytes[i]&0xf);

	}
}

void check_parameters(int argc,char* argv[])
{
	if(argc-1 != 2 || strlen(argv[1])!=SIZEOF_HMD)
	{
	printf("Usage : %s [double hash] [dictionary]\n",argv[0]);
	exit(1);
	}
}