TUT DU CRACKME DE PHOX 5.1
by ub0.g0ss
Introduction
Salut, je me suis acharné sur ce crackme et j'ai fini par trouvé un serial valide. Je n'ai pas assez de connaissances pour faire un keygen et j'ai eu beaucoup de mal à calculer le serial à la main. J'écris ce tut afin de montrer comment j'ai procédé pour trouver le serial, et surtout en espèrant que quelqu'un puisse réagir sur ce tut et le complèter de manière à faire progresser les débutants comme moi. En tout cas je tiens à remercier St Thomas car c'est grâce à ses explications que j'ai compris la démarche à appliquer pour trouver un serial crypté.
Voilà, commençons donc à étudier ce crackme!!
Le prog
On lance le prog et on entre un serial bidon et on clique sur OK. Un joli nag apparaît "wrong serial", Oups!!
On fait surgir softice (CTRL-D) et on pose notre classique BPX hmemcpy. On reviens dans le prog (CTRL-D) et on clique sur OK. Yes softice arrive en trombe,
on appuie sur F12 jusqu'à sortir des routine type user et kernel, et on arrive au prog, ici très exactement :
:0040119E E800010000 CALL USER32!GetWindowTextA
:004011A3 FF3544204000 PUSH DWORD PTR[00402044]
:004011A9 E85D000000 CALL 0040120B >> CALL de vérification du serial
:004011AE 83F801 CMP EAX,01 >> compare EAX à 1
:004011B1 751E JNZ 004011D1 >> saute si EAX différent de 1 (code incorrect)
...
On entre dans le CALL en 004011A9 et on arrive ici :
:0040120B C8000000 enter 0000, 00 :0040120F 53 push ebx :00401210 52 push edx :00401211 33C0 xor eax, eax :00401213 B8A6204000 mov eax, 004020A6 :00401218 803800 cmp byte ptr [eax], 00 >> vérifie si un serial est entré :0040121B 7460 je 0040127D >> exit si rien n'est entré :0040121D 33DB xor ebx, ebx :0040121F 33D2 xor edx, edx :00401221 8A18 mov bl, byte ptr [eax] >> met une lettre de EAX dans BL :00401223 C1C308 rol ebx, 08 >> rotation de bits vers la gauche :00401226 03D3 add edx, ebx >> ajoute EBX à EDX (EDX = EDX + EBX) :00401228 40 inc eax >> incrémente EAX :00401229 803800 cmp byte ptr [eax], 00 >> contrôle s'il reste des lettres dans EAX :0040122C 75F3 jne 00401221 >> Il en reste alors on boucle :0040122E 52 push edx :0040122F 6854204000 push 00402054 :00401234 68BF204000 push 004020BF :00401239 E88F000000 Call 004012CD :0040123E BBBF204000 mov ebx, 004020BF >> met le serial généré dans EBX :00401243 803B38 cmp byte ptr [ebx], 38 >> compare la première lettre avec 38 (8 en ASCII) :00401246 7535 jne 0040127D >> saute vers code incorrect si différent :00401248 807B0144 cmp byte ptr [ebx+01], 44 >> compare la deuxième lettre avec 44 (D en ASCII) :0040124C 752F jne 0040127D >> saute vers code incorrect si différent :0040124E 807B0243 cmp byte ptr [ebx+02], 43 >> compare la troisième lettre avec 43 (C en ASCII) :00401252 7529 jne 0040127D >> saute vers code incorrect si différent :00401254 807B0341 cmp byte ptr [ebx+03], 41 >> compare la quatrième lettre avec 41 (A en ASCII) :00401258 7523 jne 0040127D >> saute vers code incorrect si différent :0040125A 807B0446 cmp byte ptr [ebx+04], 46 >> compare la cinquième lettre avec 46 (F en ASCII) :0040125E 751D jne 0040127D >> saute vers code incorrect si différent :00401260 807B0533 cmp byte ptr [ebx+05], 33 >> compare la sixième lettre avec 33 (3 en ASCII) :00401264 7517 jne 0040127D >> saute vers code incorrect si différent :00401266 807B0636 cmp byte ptr [ebx+06], 36 >> compare la septième lettre avec 36 (6 en ASCII) :0040126A 7511 jne 0040127D >> saute vers code incorrect si différent :0040126C 807B0738 cmp byte ptr [ebx+07], 38 >> compare la huitième lettre avec 38 (8 en ASCII) :00401270 750B jne 0040127D >> saute vers code incorrect si différent :00401272 B801000000 mov eax, 00000001 >> Le code est correct alors on met EAX à 1 :00401277 5A pop edx :00401278 5B pop ebx :00401279 C9 leave :0040127A C20400 ret 0004 ...
Il y a deux routines dans ce CALL, la première s'amuse avec notre serial bidon, la deuxième va comparer le serial ainsi généré avec le vrai (byte à byte).
On voit déjà que le vrai serial est : 8DCAF368.
Il faut donc s'arranger pour que notre serial ait cette valeur à la fin du cryptage.
On regarde donc la première routine pour voir ce qu'il fazit de notre serial :
J'avais entré 12345678 comme serial, 8 lettres parce que j'avais cru qu'il vérifiait un serial de 8 lettres, mais en fait, il vérifie le résultat de l'opération de cryptage, qui elle fait 8 lettres (ou 4 valeurs hexa).
J'avais donc calculé un serial de 8 lettres en utilisant des équations, mais en fait, on peut prendre le nombre de lettres que l'on veut (mais supérieur à 4 je pense).
je vais donc expliquer ici le principe avec un serial de 4 lettres, sachant que c'est la même chose avec plus (il faut faire attention aux retenues).
Je ne pense pas être très clair dans mes explications alors je vais commencer tout de suite :
on entre le serial : 1234.
On fait notre BPX hmemcpy pour aller dans le CALL et on regarde ce qu'il va faire :
le prog place la première lettre du serial dans BL (1 en ASCII ou 31 en hexa)
il fait une rotation de EBX vers la gauche
il place le résultat dans EDX
il boucle jusqu'a ce qu'il n'y ait plus de lettres dans EAX (notre serial).
1ère boucle : EBX vaut 00 00 31 00
2ème boucle : EBX vaut 00 31 32 00
3ème boucle : EBX vaut 31 32 33 00
4ème boucle : EBX vaut 32 33 34 31
Et EDX reçoit la somme de ces valeurs, c'est à dire :
1ère boucle : EDX vaut 00 00 31 00
2ème boucle : EDX vaut 00 31 63 00
3ème boucle : EDX vaut 31 63 96 00
4ème boucle : EDX vaut 63 96 CA 31
Et lorsque l'on voit notre serial en 00401243 en faisant D EBX, on voit : 6396CA31.
Il va le comparer à 8DCAF368, on n'a pas la même chose donc le code est incorrect.
Pour trouver le vrai code, on va repartir à l'envers :
soit un code : abcd
On constate ceci :
1ère boucle : EBX vaut 00 00 a 00
2ème boucle : EBX vaut 00 a b 00
3ème boucle : EBX vaut a b c 00
4ème boucle : EBX vaut b c d a
EDX quant à lui vaut (a+b) (a+b+c) (a+b+c+d) (a)
J'espère que c'est clair parce que c'est pas évident à expliquer.
Pour le bon serial, il faut donc que :
a = 68
a+b+c+d = F3
a+b+c = CA
a+b = 8D
soit donc a = 68h ou h en ASCII
b = 8D-68 = 25h ou % en ASCII
c = 8D-CA = 3D ou = en ASCII
d = F3-3D = 29 ou ) en ASCII
Munissez vous de cracker tools pour avoir la correspondance hexa - ASCII.
On trouve donc un serial de 4 lettres : h%=)
On l'essaye, super ça marche.
Voilà, ce tut est terminé, j'espère que vous avez tout compris.
Pour info, j'ai fait un calcul pour un serial de 8 lettres, c'est un peu plus long et en plus il y a des retenues, j'ai trouvé ça : EEEET%=)
Si vous avez des questions, des suggestions ou si vous souhaitez complèter ce tut, surtout ne vous gênez pas, écrivez moi : ub0.g0ss@caramail.Com
Salut et à plus pour un nouveau tut.
ub0.g0ss