Commentaires sur une source : BRUTEFORCING D'UN CHECKSUM MD5

simsim31 Messages postés 1 Date d'inscription dimanche 18 avril 2010 Statut Membre Dernière intervention 12 mars 2011
12 mars 2011 à 16:48

moi, aussi je n'ai pas compris comment le faire fonctionner, expliquez nous svp

nicobsa Messages postés 32 Date d'inscription vendredi 10 septembre 2004 Statut Membre Dernière intervention 14 février 2016 1
4 juil. 2008 à 21:37

Bonjour a tout le monde, pardonnez moi de rouvrir cela après près d'un an, mais je souhaiterais également savoir quels paramètres passer à ce programme pour le faire fonctionner, doit ont placer le Hash dans un fichier ?

Merci de toute réponse.
A bientot sur CS :-D

edouarddu01 Messages postés 1 Date d'inscription mardi 22 août 2006 Statut Membre Dernière intervention 30 septembre 2007
30 sept. 2007 à 00:28

je suis un noob donc ma question va vous sembler idiote mais comment on fais pour ce servir de ce programme?
merci de pas trop me donner une reponse trop bete

OneHacker Messages postés 1447 Date d'inscription jeudi 2 novembre 2000 Statut Membre Dernière intervention 23 septembre 2007 2
7 août 2007 à 13:28

pourquoi alors chez moi ca fini toujours par == ? (j'utilise la lib de Codes Sources)

pthc Messages postés 2 Date d'inscription mardi 7 août 2007 Statut Membre Dernière intervention 10 août 2007
7 août 2007 à 00:51

swordfishP
Je ne sais pas, j'ai un petit doute d'avance sur les performances du C# mais à ce point...
Le code qui calcule le hash, est codé en C# ou ça fait appel à une librairie standard du C# ?

Je n'ai pas de quoi tester de codes ici vu que je n'ai que gcc, cependant le code de Clem semble correct, sachant que d'autres logiciels de crackage obtienne un résultat de 8 millions de hash testé par seconde (sur des processeurs plus modernes que l'époque bien sûr)
Il serait interessant de profiter des dual/quad cores aussi, on pourrait bénéficier d'un gain non négligeable sans trop de difficultés.

OneHacker
Tu confonds un peu tout là.
95ebc3c7b3b9f1d2c40fec14415d3cb8 est bien un hash md5. Ou plutôt sa représentation hexadécimale; un hash md5 est du binaire, sur 128 bits. Pour le rendre lisible dans la table ascii il y a plusieurs façons de le faire :
convertir ces 16 octets en héxadécimal, ce qui peut devenir quelque chose du genre 95ebc3c7b3b9f1d2c40fec14415d3cb8.
Mais on pourrait aussi utiliser la base64 ( http://en.wikipedia.org/wiki/Base64 ), ce qui donne quelque chose de plus court il faut l'admettre, mais aussi plus compliqué à utiliser.
La représentation en héxa est bien plus facile et du coup bien plus utilisée.

OneHacker Messages postés 1447 Date d'inscription jeudi 2 novembre 2000 Statut Membre Dernière intervention 23 septembre 2007 2
1 mai 2007 à 18:20

C'est ça que t'apelle un HASH MD5 -> 95ebc3c7b3b9f1d2c40fec14415d3cb8 ?

Car ca en est pas un, par exemple le Hast de "TEST" c'est -> cGWfZKDZJ3uz0V9SFbpQqw==

ccarniel Messages postés 23 Date d'inscription samedi 24 janvier 2004 Statut Membre Dernière intervention 17 octobre 2004
17 févr. 2007 à 11:25

quelle est ta séquence utilisée pour obtenir un tel hash ?
un hash est toujours une séquence hexadécimale de 16 octets, donc 32 caractères allant de 0 à 9 ou de A à F;

cs_Kirua Messages postés 3006 Date d'inscription dimanche 14 avril 2002 Statut Membre Dernière intervention 31 décembre 2008
17 févr. 2007 à 11:24

Ce n'est sûrement pas un hash md5: caractères alpha numérique minuscules et majuscules ainsi que / et $ ... La représentation standard d'un hash md5 c'est la valeur numérique écrite en base hexadécimale, donc sur 32 caractères pour 16 octets de données. Ca vient d'où ton machin ?

scelw Messages postés 117 Date d'inscription mercredi 3 septembre 2003 Statut Membre Dernière intervention 17 février 2007
17 févr. 2007 à 10:57

Pourquoi certains hashs md5 sont de la forme "$1$ZWnke0$1fzDBVjUcT1Mpdd4u/T961" et non "21232f297a57a5a743894a0e4a801fc3"?

A quoi correspond la forme "$1$XXXXXXXX..."?

merci pour vos indications!

f0xi Messages postés 4205 Date d'inscription samedi 16 octobre 2004 Statut Modérateur Dernière intervention 12 mars 2022 35
14 févr. 2007 à 18:15

Code marqué comme louche pour la raison de :

- mises en place et démonstration d'une technique de piratage.

merci pour votre compréhension.

par contre une ou deux precisions :

MD5 est un algorithme de hash, donc de "somme", pas de cryptage (qui n'est d'ailleur pas un terme exact, puisqu'en francais on dirait "Chiffrer" ou "Coder")
et aussi, on ne peu etre sur que le "pass" trouver est identique au "pass" original, on dirat donc qu'on a "generé une collision".

swordfishP Messages postés 2 Date d'inscription jeudi 23 juin 2005 Statut Membre Dernière intervention 24 décembre 2005
12 févr. 2007 à 01:24

Le coup des 1'331'000/s je n'y crois pas trop. Il doit y avoir une erreur
dans ta manière de mesurer le rendement :[

Avec un code en c# bien optimisé je ne dépasse pas les 80'000/s sur un p4 2.9
J'utilise la meme technique que celle cité par Kirua (la boucle commence par incrémenter à la fin et revient petit à petit vers le début)

Resultats en cherchant le pass kx5o, c197617fbb2b1201045684af36f1699e
[a-z][0-9] 9s
[a-z][A-Z][0-9] 48s
Sachant que mes 'alphabets' sont dans l'ordre

pmadfm Messages postés 2 Date d'inscription lundi 5 février 2007 Statut Membre Dernière intervention 22 juin 2007
5 févr. 2007 à 03:03

Bonjour,

Attention le rainbowcrack, semble contenir des virus.

Méfiance.

CDT

Vishnouu Messages postés 13 Date d'inscription mardi 17 mai 2005 Statut Membre Dernière intervention 13 juillet 2005
11 juil. 2005 à 14:34

Avec rainbow crack, ça va 100x plus vite! Allez voir sur ce site
http://rc.plain-text.info/view.php?action=viewallhashes
ou celui la pour rainbowcrack, je sais pas exactement comment ca fonctionne, mais c'est bien plus rapide http://www.antsight.com/zsl/rainbowcrack/

black_onix Messages postés 2 Date d'inscription mercredi 24 septembre 2003 Statut Membre Dernière intervention 26 mai 2005
26 mai 2005 à 17:07

je ne programme pas en C++ mais je voudrai me servir de ton programme, comment puije changer le MD5 crypté a trouver?

ccarniel Messages postés 23 Date d'inscription samedi 24 janvier 2004 Statut Membre Dernière intervention 17 octobre 2004
8 août 2004 à 22:22

"compare (avec memcmp) le hash de 16 octets plutôt que la conversion en char de 32 octets. ça vire printf et 16 comparaisons."

Effectivement, Kirua, je gagne encore 10% :) 1'331'000/s

Clem: Pour mon algo, ben trace le, je ne vois pas pourquoi ça tournerai dans le vide. Je ne vois qu'une différence de compilateur de possible.
Surveille surtout là-dedans:
Curseur = 0;
buffer[Curseur]++;
if( buffer[Curseur]>ChiffreFin )
{
do
{
buffer[++Curseur]++;
if( Curseur == max )
{
return ; // On a pas trouvé la combinaison
}
} while ( buffer[Curseur]>ChiffreFin );
memset(buffer,ChiffreDebut,Curseur);
}

cs_Kirua Messages postés 3006 Date d'inscription dimanche 14 avril 2002 Statut Membre Dernière intervention 31 décembre 2008
8 août 2004 à 20:08

"si tu en arrives à devoir incrémenter le tout premier caractère, c'est que t'es au bout des tests!"

je voulais dire: si tu dois remettre le tout dernier caractère à LimInf après qu'il ait été à LimSup, désolé

cs_Kirua Messages postés 3006 Date d'inscription dimanche 14 avril 2002 Statut Membre Dernière intervention 31 décembre 2008
8 août 2004 à 20:02

ben regarde pour l'itératif, tu dois considérer que tu as en fait un nombre en base 256-32 (si tu balayes de l'espace jusqu'au caractère 255). Après, tu réfléchis en comparant à la base 10 (qu'on utilise tt le temps)

1459
+1
1460
//...
1499
+1
1500

tu analyses (c facile qd même :p) la logique: tu incrémentes le dernier caractère de 1, si il excède la limite supérieur (ici 9, mais ds le prog 255), tu le remets à 0 (espace) et tu incrémentes le caractère suivant (c'est-à-dire l'avant dernier) et tu refais les mêmes tests.

si tu en arrives à devoir incrémenter le tout premier caractère, c'est que t'es au bout des tests!

voici le truc que j'ai pondu hier soir:

//on a une boucle "à l'envers": on commence par la fin
for(int i=NbCar-1; i >= 0; i--){
if(++chaine[i] <= LimSup)
break;
chaine[i] = LimInf;
if(i == 0)
GoOn = false; //met fin à la boucle du brute force
}

explication:
la boucle commence par incrémenter à la fin et revient petit à petit vers le début.
LimSup 255 et LimInf 32 (espace).

if(++chaine[i] <= LimSup)
revient à écrire:
chaine[i]++;
if(chaine[i] <= LimSup)

NB: chaine est bien sur le mot à tester, pas le hash
si c'est inférieur à LimSup, on ne doit pas incrémenter le nombre qui le précède, on termine cette boucle (break). Sinon, on remet le nombre à LimInf (0, donc 32) et on vérifie qu'il ne s'agissait pas du tt premier caractère (9999 + 1 = 10000, on est plus sur 4 chiffres mais sur 5, donc on a tt testé). Sinon, on passe au nombre qui précède etc...

cs_Clem Messages postés 282 Date d'inscription dimanche 1 avril 2001 Statut Membre Dernière intervention 12 février 2007
8 août 2004 à 19:53

Oui moi aussi j'ai penser a virer le printf comme ça et sur mon pc ça montait à 600000 au lieu de 10000 !!!
mais j'arrive pas a me débrouiller pour faire un algo sans récursiviter et celui de ccarniel semble tourner en boucle dans le vide chez moi au bout de 4 lettres

C'est clair qu'il on fait du bon boulot, ça doit être trop chaud a faire un algo aussi compliqué, senssible au moindre changement de bit, et sans pour autant qu'il mette 2h (quelques secondes au pire pour calculer le checksum de fichiers de plusieurs centaines de mo !)

cs_Kirua Messages postés 3006 Date d'inscription dimanche 14 avril 2002 Statut Membre Dernière intervention 31 décembre 2008
8 août 2004 à 19:46

bon ben puisque tlm en parle, moi j'ai une version à 400 000 (sur un PC qui faisait 150 000 avec ta version).

j'ai baqué la récursivité pour de l'itératif et je compare (avec memcmp) le hash de 16 octets plutôt que la conversion en char de 32 octets. ça vire printf et 16 comparaisons.

1,2 MK / s c'est bcp qd même, au-delà du fait que tu as super optimisé, faut féliciter les créateurs de la lib MD5, qui est super rapide!

ccarniel Messages postés 23 Date d'inscription samedi 24 janvier 2004 Statut Membre Dernière intervention 17 octobre 2004
8 août 2004 à 15:49

Voici ma version, 1'200'000/s, légèrement amélioré par rapport à tout à l'heure. J'arrête là dessus :)
J'espère que le code sera lisible.

// *************************************************************
// Created with BCX -- The BASIC To C Translator (ver 4.25)
// BCX (c) 1999, 2000, 2001, 2002, 2003 by Kevin Diggins
// *************************************************************
#include <windows.h> // Win32 Header File
#include <stdio.h>
#include "md5.h"

// *************************************************
// System Variables
// *************************************************

COORD cursor;
HANDLE hConsole;
int color_fg = 7;
int color_bg = 0;

// *************************************************
// Run Time Functions
// *************************************************

void locate (int row,int col,int bVisible=1,int dwSize=12)
{
CONSOLE_CURSOR_INFO cci = {0};
cursor.X = col-1;
cursor.Y = row-1;
SetConsoleCursorPosition(hConsole,cursor);
cci.bVisible = bVisible;
cci.dwSize = dwSize;
SetConsoleCursorInfo(hConsole,&cci);
}

void cls (void)
{
COORD coordScreen = {0,0};
DWORD cCharsWritten;
CONSOLE_SCREEN_BUFFER_INFO csbi = {0};
DWORD dwConSize;
register int attr;
cursor.X = 0;
cursor.Y = 0;
GetConsoleScreenBufferInfo( hConsole, &csbi );
dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
FillConsoleOutputCharacter (hConsole, 32, dwConSize,coordScreen, &cCharsWritten);
attr = color_fg + color_bg * 16;
FillConsoleOutputAttribute (hConsole, attr, dwConSize,coordScreen, &cCharsWritten);
locate(1,1,1);
}

void color (int fg, int bg)
{
SetConsoleTextAttribute (hConsole,fg+bg*16);
color_fg = fg;
color_bg = bg;
}

// *************************************************
// Main Program
// *************************************************

DWORD BrutesMade=0;
DWORD NumberFounds=0;
BOOL Tourne=TRUE;
char buffer[1024];
DWORD nForceChars=0;

char *HexValues =
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627\
28292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f\
505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f7071727374757677\
78797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f\
a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7\
c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeef\
f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";

#define HexStringCopy(Dst,Src) { *Dst++=*(Src); *Dst++=(Src)[1]; }

//Une fonction récursive qui cherche tous les pass de 'max' charactères.
void brute_force(DWORD max, char * searched)
{
char md5buf[33];
unsigned char ChiffreDebut ' ', ChiffreFin 'z';
int Curseur;
bool Termine = false;

// Combinaison = new unsigned char[max+1];
memset(buffer,ChiffreDebut,(sizeof(char))*max);

while( !Termine )
{
BrutesMade++; //On ajoute 1 au compteur de 'pass' testés
//On fait un checksum md5 sur le buffer
md5_state_t state;
md5_byte_t digest[16];
md5_init(&state);
md5_append(&state,(const md5_byte_t *)buffer, max);
md5_finish(&state, digest);

register char *TmpMD5Buf = md5buf;
md5_byte_t *TmpDigest = digest;

HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;

//On compare de md5 a celui qui correspond au pass que l'on recherche
if (!memcmp(searched, md5buf, 32))
{ //memcmp est bcp plus rapide que strcmp, mais ne fait pas de comparaisons entre les minusucules et les majusucules, attention a ça quand vous mettez votre md5 a 'décrypter' !
locate(++NumberFounds, 29); //Si trouvé, on place le curseur a droite dans la console
buffer[max]='\0';
printf(": md5('%s')='%s'\n", buffer, md5buf); //On affiche le md5 et le pass qui correspond (c'est vrai il y a des chances de pas trouver le vrai mot de passe, mais on s'en fout, si on entre ça l'ordi va le comprendre comme le vrai mot de passe !!!)
Tourne=FALSE; //On arrête le thread de monitoring
ExitProcess(0); //Et on quite
}
Curseur = 0;
buffer[Curseur]++;
if( buffer[Curseur]>ChiffreFin )
{
do
{
buffer[++Curseur]++;
if( Curseur == max )
{
return ; // On a pas trouvé la combinaison
}
} while ( buffer[Curseur]>ChiffreFin );
memset(buffer,ChiffreDebut,Curseur);
}
}
}

//Un ptit thread pour savoir où en est le prog parce que sinon on se fait un peu chier lol
void ThreadMonitor(void) {
DWORD LastBrutes=0, Secs=0;

#if defined (_MSC_VER) && (_MSC_VER >= 1020)
__int64 Freq,StartTime,CurTime;
#else
unsigned long StartTime,CurTime;
#endif // defined (_MSC_VER) && (_MSC_VER >= 1020)

#if defined (_MSC_VER) && (_MSC_VER >= 1020)
QueryPerformanceFrequency((LARGE_INTEGER*)&Freq);
QueryPerformanceCounter((LARGE_INTEGER*)&StartTime);
#else
StartTime = GetTickCount();
#endif // defined (_MSC_VER) && (_MSC_VER >= 1020)

do {
//Secs = GetTickCount() - Start;
#if defined (_MSC_VER) && (_MSC_VER >= 1020)
QueryPerformanceCounter((LARGE_INTEGER*)&CurTime);
Secs = (CurTime - StartTime)*1000/Freq;
#else
CurTime = GetTickCount();
Secs = (CurTime - StartTime);
#endif // defined (_MSC_VER) && (_MSC_VER >= 1020)
if( Secs >= 1000 )
{
cls(); //On efface l'écran et on met le curseur en haut a gauche. Ok j'avoue la fonction vient tout droit de BCX j'ai pas eu le courage d'aller mieux chercher et g pri le premier truc qui m'est tombé sous la main
printf("%d décryptés.\n",BrutesMade);
printf("%d/s (%dms écoulée(s)) \n",BrutesMade/(Secs/1000),Secs);
printf("Le mot de passe a au moins %d chars.\n\n== %s ==\n\n\n", nForceChars, buffer); //On affiche les stats
LastBrutes=BrutesMade; //9a c'est pour le compteur de pass par secondes
}
Sleep(1000); //On attenton une seconde
} while (Tourne==TRUE); //Une boucle jusqu'a se que un pass correct soit trouvé
}

void PrintMD5(const char *mdp)
{
char md5buf[64];

md5_state_t state;
md5_byte_t digest[16];
md5_init(&state);
md5_append(&state,(const md5_byte_t *)mdp,strlen(mdp));
md5_finish(&state, digest);
char *TmpMD5Buf = md5buf;
md5_byte_t *TmpDigest = digest;

HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;
HexStringCopy( TmpMD5Buf , HexValues + *TmpDigest*2 ); TmpDigest++;

printf("(%s)=%s\n",mdp,md5buf);
}

int main(int argc, char *argv[]) {
hConsole = GetStdHandle (STD_OUTPUT_HANDLE);
char * searched = "02c425157ecd32f259548b33402ff6d3"; //Le md5 dont on cherche un pass correct
// "aa36dc6e81e2ac7ad03e12fedcb6a2c0" = mdp
// "1eec414adf814acbc887f59327db58fb" = ?
// 95ebc3c7b3b9f1d2c40fec14415d3cb8 = zzzzz
// 02c425157ecd32f259548b33402ff6d3 = zzzz
bool Recursif=false;

//PrintMD5("zzzz"); exit(0);

DWORD MaxSize=16; //Le nb maximum de caractères que le pass peut faire
CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadMonitor, NULL, 0, NULL); //On démarre le monitoring en tant que thread seconde ==> comme ça, ça ralenti a peine le scanning, et c'est plus simple pour les fénéants^^
for (nForceChars=1; nForceChars<=MaxSize; nForceChars++) {
ZeroMemory(buffer, MaxSize+1); //On efface le buffer pour plus de sécurité
brute_force(nForceChars, searched); //Et on brute force ça
}

return 0;
}

ccarniel Messages postés 23 Date d'inscription samedi 24 janvier 2004 Statut Membre Dernière intervention 17 octobre 2004
8 août 2004 à 11:56

J'ai fait quelques modifs dans ton code et j'arrive à tester plus de 1'100'000 mdp par seconde sur un athlon XP1700 (un vieux truc quoi...)
Mes estimations ne concordent pas du tout avec tes calculs, bizarre:
Lettres durée
4 61"
5 92 minutes
6 5 jours et 20h
7 17 mois et 12 jours
8 132 ans
9 12 009 ans
10 1 100 000 ans

Mes modifs sont assez simples:
1. J'ai viré la récursivité.
2. Quand tu construits le mdp de 4 lettres, tu testes s'il est bon à chaque lettre or tu ne devrais le faire que quand il a atteint la taille nécessaire if( i==max)
3. J'ai viré for (int di = 0; di < 16; ++di) sprintf(md5buf + di * 2, "%02x", digest[di]); et remplacé par 16 lignes de macros qui font les calculs sans appel à des fonctions aussi lentes que sprintf.

cs_AlexMAN Messages postés 1536 Date d'inscription samedi 21 décembre 2002 Statut Membre Dernière intervention 24 mai 2009 1
8 août 2004 à 11:16

le char comme "incrémenteur", jette le, utilise un entier, car lors de l'execution, conversion de char en int donc perte de temps alors si on peut s'en passer (on peut TJRS s'en passer), on en profite !
voila, ct juste pour dire ca..

++

ccarniel Messages postés 23 Date d'inscription samedi 24 janvier 2004 Statut Membre Dernière intervention 17 octobre 2004
8 août 2004 à 10:37

Concernant le 'z' comme dernier caractère testé, c'est plutôt light.... Personnellement, j'ai l'habitude d'utiliser des caractères étendus (>128) dans mes mots de passe, et en plus ils font toujours au minimum 10 caractères.

Si tu veux pouvoir décoder un tel mot de passe (mis à part le temps), tu dois modifier cette ligne:
for (char c=' '; c<'z'; c++)
par
for (unsigned char c=' '; c<=255 ; c++)

Ainsi tu balaieras tout le spectre (enfin presque). Les char vont de -128 à +127, donc quand tu écrivais 132 par exemple, ben il prenait ça pour une valeur négative...

PS: Attention aux tests c<'z' ne testera jamais 'z', il faudrait écrire c<='z' !!!!

cs_Clem Messages postés 282 Date d'inscription dimanche 1 avril 2001 Statut Membre Dernière intervention 12 février 2007
8 août 2004 à 04:25

En écrans plat ça consomme moins :p
C'est vrai que c'est sympa cette lib, j'ai eu du mal a la trouver mais maintenant j'ai du mal a m'en séparer lol, vérification de non crackage du programme, mise à jour automatique, répertoriage de fichiers classés par le md5, bref...

ahhhh les alloc dynamiques, un autre truc dont j'ai du mal a me passer depuis que je l'ai connu, résultats: bourrage de ram et plantages a mort^^

les classes c'est vrai que c'est utile, mais il faut réfléchir a quels cas seulement ça peut servir, je me retrouve souvent a faire une classe pour simplifier le boulet, et puis après me dire "ben c'est bien bio ça, mais jpe faire exactement le même sans class, et ça tournera mieux"

euh je serais pas un hors sujet la ?
bon jme rattrape !

essaye de voir si tu peux corriger ça, si t'obtient une meilleure vitesse que moi c'est toujours intéréssant

oui c'est possible que ça a mit 287s, ça dépent déjà sensiblement du proc, mais aussi c'est un temps moyen, et donc un mot de passe commençant en 'a' sera plus rapide a trouver qu'un passe en 'z', en 4 lettres il met bien une petite dizaine pour scanner toutes les possibilités sur la seule première lettre (scanner toutes les aXXX en clair), moi mon essai c'était avec un mot de passe en C, alors que Nico est 10 lettres plus loin, a raison de 1s par lettre, ça fait 100s et une impréssision de 7s !
ah vi et le mien aussi augmente les char de la fin d'abord, puis augmente le suivant

ça te dit qu'on mette en commun la puissance de nos pc pour trouver les pass de la naza ? :D

cs_Kirua Messages postés 3006 Date d'inscription dimanche 14 avril 2002 Statut Membre Dernière intervention 31 décembre 2008
8 août 2004 à 02:58

(je viens de mettre 287s pour bruteforcer "Nico", ça fait long par rapport à tes 3 minutes :(, tes chiffres ils sont en moyenne ou ds le pire des cas? )

à savoir que je commence par augmenter les caractères à la fin, comme pour des chiffres, donc ici j'ai du chercher jusque 'o', ce qui est bien pire que 'O' ou encore ' '...

cs_Kirua Messages postés 3006 Date d'inscription dimanche 14 avril 2002 Statut Membre Dernière intervention 31 décembre 2008
8 août 2004 à 02:56

bof, ce qui bouffe de l'électricité c'est surtout les écrans, hors les "super-ordinateurs" de calcul n'en ont pas, aucune utilité, on leur demande juste de calculer et de f* leur g* ;)

je joue avec la lib md5 depuis plus d'une heure là, j'ai écrit un algo bien à moi pour le brute force, mais en itératif, je pense que ça doit être plus rapide sur le principe, seulement j'ai des allocations dynamiques partout et des conversions md5 byte <-> char à tout va, bof bof tout ça, c'est pas la meilleure idée du siècle :) j'penserais bien à écrire une classe "wrapper" autour de la lib, histoire de rendre ces conversions et ces allocs transparentes, mais le procédural ça reste qd même plus rapide que l'orienté objet, alors pr un brute force je sais pas si c'est ma deuxième idée du sicèle ^^

cs_Clem Messages postés 282 Date d'inscription dimanche 1 avril 2001 Statut Membre Dernière intervention 12 février 2007
8 août 2004 à 01:51

Vi c'est mon convertisseur basic => c qui avait fait tout ça et j'ai pas eu le courage de trier tout ça, promis je revois mieux le tout bientot. (Je me suis servit de BCX pour les fonctions d'affichage a l'écran a tel position précise avec locate, et effacement avec cls)

Je n'utilise pas tout les caractères visible de la table ascii (je sais pas pourquoi si je les mets tous mon algo ce met a bugger, cf les commentaires dans la fonction brute_force), mais il scanne quand même du code ascii 32 au 122, autant dire que ça inclue déjà pas mal de monde si on regarde la table ascii (http://asciitable.com/)

Je vois pas comment faire fonctionner un tel programme en clusturing, mais c'est sur que ça augmenterai bien la vitesse.
Réquisitionnez une salle entière de LAN (enfin surtout leurs pcs^___^), montez ça en réseau, et 'crackage' assuré dans un temps raisonable (non non, la facture EDF c'est pas moi qui m'en occupe, c'est le gentil monsieur la bas :p)

cs_Kirua Messages postés 3006 Date d'inscription dimanche 14 avril 2002 Statut Membre Dernière intervention 31 décembre 2008
8 août 2004 à 01:40

à propos de la liste de md5, une équipe de "hacker" (pr les appeler comme ça) a fait tourner il y a un certain temps une batterie de PC pdt 6 mois pr créer un catalogue de md5 (autant dire que ça prend des Go à stocker). ce que ça veut dire en clair, c'est qu'un organisme organisé (oui oui ^^) passe à travers du md5 "raisonnable" (pas "trop" de caractères) sans problème. prudence donc, si vous travaillez professionnellement. pour un site perso ça change rien ^^

cs_Kirua Messages postés 3006 Date d'inscription dimanche 14 avril 2002 Statut Membre Dernière intervention 31 décembre 2008
8 août 2004 à 01:36

un conseil: n'utilisez pas "000000000" comme mot de passe :p

question: pourquoi tous ces en-têtes? t'as pas besoin de tt ça qd même, c'est ton convertisseur Basic -> C qui crée toutes ces crasses? :( c'est dommage.

4j pour décoder un passe c'est raisonnable, donc on peut dire qu'un passe de 6 lettres c'est VRMNT pas sécurisé :/

tu comptes que le mot de passe contient quels caractères? alpha-numériques ou tous les caractères visibles de la table ASCII? (bcp ça :/)

cs_Clem Messages postés 282 Date d'inscription dimanche 1 avril 2001 Statut Membre Dernière intervention 12 février 2007
7 août 2004 à 22:47

Alors j'ai fait quelques petits test sur un autre pc (qui tourne a 15000/s), et ça donne
4 secondes pour trouver un pass de 3 lettres (calculs moyens très aproximatifs, ça dépent bien sur de quelles lettres le pass est fait)
3mins=> 4 lettres
2h30 => 5 lettres
4j => 6 lettres
6mois => 7 lettres
23 ans => 8 lettres
1 siècle => 9 lettres

Pas encore découragés ? lol

BRUTEFORCING D'UN CHECKSUM MD5

Votre réponse

Discussions similaires