How To reverse : Cataloguez2k

Reverse de Cataloguez 2K Par

Aujourd'hui on s'attaque donc au reverse engineering, ou ingenieurie à rebours (arf je n'aime guère ce mot ^_^). Je vous prévient tout de suite ce n'est pas d'un haut niveau ce que je vais vous proposer, mais bon ca ma prit un ptit peu la tête pour essayer de récupérer le handle de la boite du code, ne connaissant pas d'API le faisant! La seul prétention de ce tut est d'exister, il se peut que je me trompe alors si vous voyez une erreur dans mes propos contactez moi sur le site de la FFF! Merci.

1) Recherche du serial

=====================================

Cible : Cataloguez 2k

Auteur : Mickaël Picaud

URL: Mpicaud.net

Outils :W32Dasm, Softice, The Customiser (pas indispensable), un éditeur héxa, la calculatrice Windows

============================================

Tout d'abord faites une copie de sauvegarde de On lance le prog, on obtient une boite d'enregistrement
Comme nom je met MadMickael [FFF] et comme serial 123456
Bon alors là vous avez l'habitude , on pose un bpx HMEMCPY et on clik sur "ENREGISTRER"

-----------------------copier-coller sous Windasm ------------

NB: j'ai remonter un tout ptit peu plus haut ds le source, vous verrez bien pk tout à l'heure

:004841E1 8B83F0020000            mov eax, dword ptr [ebx+000002F0]
:004841E7 E89C12FCFF              call 00445488
:004841EC 8B45F8                  mov eax, dword ptr [ebp-08] ==> eax== mon nom
:004841EF 8D55FC                  lea edx, dword ptr [ebp-04]
:004841F2 E8CD5CFEFF              call 00469EC4
:004841F7 8D55F4                  lea edx, dword ptr [ebp-0C]
:004841FA 8B83FC020000            mov eax, dword ptr [ebx+000002FC]
:00484200 E88312FCFF              call 00445488  
:00484205 837DF400                cmp dword ptr [ebp-0C], 00000000 ==>longueur du serial <4?
:00484209 741B                    je 00484226 ==> OUI alors BEEP fuck u
:0048420B 8D55F0                  lea edx, dword ptr [ebp-10]

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004841AB(C)
|
:0048420E 8B83FC020000            mov eax, dword ptr [ebx+000002FC]
:00484214 E86F12FCFF              call 00445488
:00484219 8B45F0                  mov eax, dword ptr [ebp-10]  ===> Ton serial 
:0048421C 8B55FC                  mov edx, dword ptr [ebp-04]  ===> bon serial
:0048421F E8640AF8FF              call 00404C88  ==> Call de validation
:00484224 7459                    je 0048427F  ===> Saute si Bon code 

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00484209(C)
|
:00484226 6A10                    push 00000010
:00484228 8D55EC                  lea edx, dword ptr [ebp-14]
:0048422B A1A0D24800              mov eax, dword ptr [0048D2A0]
:00484230 8B00                    mov eax, dword ptr [eax]
:00484232 E8E50BFEFF              call 00464E1C
:00484237 8B45EC                  mov eax, dword ptr [ebp-14]
:0048423A E8FD0AF8FF              call 00404D3C
:0048423F 50                      push eax
:00484240 6888434800              push 00484388
:00484245 A154F14800              mov eax, dword ptr [0048F154]
:0048424A E8B978FCFF              call 0044BB08
:0048424F 50                      push eax

* Reference To: user32.MessageBoxA, Ord:0000h
                                  |
:00484250 E83F34F8FF              Call 00407694  ==> Mauvais code!!
:00484255 8B830C030000            mov eax, dword ptr [ebx+0000030C]
:0048425B FF400C                  inc [eax+0C] => Augmente le nb de tentatives de 1
:0048425E 8B830C030000            mov eax, dword ptr [ebx+0000030C]
:00484264 83780C03                cmp dword ptr [eax+0C], 00000003  ==> 3 essais infructueux??  
:00484268 0F85CD000000            jne 0048433B   ==> NON, alors le prog saute et continue....
:0048426E A17CD14800              mov eax, dword ptr [0048D17C]==> OUI le prog se stoppe

--------------------------------fin du copier coller --------------------

Si l'on rentre un mauvais code on as droit à une zolie Messagebox "mauvais code"
Bon à ce niveau c'est vraiment trop facile. Une fois en 0048421F, on fait "d edx" et on à le bon code ! Alors Toi le crackeur qui voulais juste trouver un serial, c'est fini pour toi, je te dis au revoir!

2) Affichage du Bon code

A ce moment je me suis demandé si la messagebox pouvait afficher le bon serial à la place de la chaine "Mauvais code"! Ca ferait un bon keygen pour branleurs ;-). Bon voyons voir ce que je sais sur l'API Messageboxa.

int MessageBox(

    HWND  hWnd,	        // handle de la fenêtre propriétaire
    LPCTSTR  lpText,	// adresse du message
    LPCTSTR  lpCaption,	// adresse du titre  
    UINT  uType 	// style de la boite (icônes, boutons)
   );

Comment un programme passe t'il ses paramètres avant d'appeler l'API?
Avec des PUSH ! Mais suivant la régle de la pile (1er entré, dernier sortit), les push doivent être passés dans l'autre sens. Notre procédure va donc ressembler à ceci :

Push [Style de la boite]
Push [Adresse du titre]
Push [Adresse du message]=== Ou plutôt [Adresse_du_bon_code]
Push [handle de la fenetre proprio] 
Call User32!MessageBoxa

Le style de la Boite, c'est un chiffre (on va mettre 00 ca met juste le bouton OK)
Quelle est l'adresse du titre? Reprenez le listing...

--------------------------------------------

:00484226 6A10                    push 00000010 ==> Push [Style de la boite]
:00484228 8D55EC                  lea edx, dword ptr [ebp-14]
:0048422B A1A0D24800              mov eax, dword ptr [0048D2A0]
:00484230 8B00                    mov eax, dword ptr [eax]
:00484232 E8E50BFEFF              call 00464E1C
:00484237 8B45EC                  mov eax, dword ptr [ebp-14]
:0048423A E8FD0AF8FF              call 00404D3C==> à la sortie eax="Cataloguez..." (Titre]
:0048423F 50                      push eax ==> Push [adresse du titre]
:00484240 6888434800              push 00484388 => Push [adresse du message] ("Mauvais code")
:00484245 A154F14800              mov eax, dword ptr [0048F154]
:0048424A E8B978FCFF              call 0044BB08 
:0048424F 50                      push eax  ==> Push [handle de la boite proprio]
:00484250 E83F34F8FF              Call user32!MessageBoxa

-------------------------------------------

Bon, tous ca c'est bien joli mais ou est l'adresse du bon N°?
Allez on y retourne!
------------------------------------------

:0048421C 8B55FC                  mov edx, dword ptr [ebp-04]  ===> bon serial
:0048421F E8640AF8FF              call 00404C88 
:00484224 7459                    je 0048427F

-----------------------------------------
Donc le bon sérial est dans [EBP-04]!
On va donc patcher :

:00484226 6A10                    push 10
:00484228 8D55EC                  lea edx, dword ptr [ebp-14]
:0048422B A1A0D24800              mov eax, dword ptr [0048D2A0]
:00484230 8B00                    mov eax, dword ptr [eax]
:00484232 E8E50BFEFF              call 00464E1C
:00484237 8B45EC                  mov eax, [ebp-14]
:0048423A E8FD0AF8FF              call 00404D3C
:0048423F 50                      push eax 
:00484240 6888434800              push 00484388 
:00484245 A154F14800              mov eax, dword ptr [0048F154]
:0048424A E8B978FCFF              call 0044BB08
:0048424F 50                      push eax 
:00484250 E83F34F8FF              Call user32!MessageBoxa

par

:00484226 6A00                    push 00 ==> bouton OK
:00484228 6888434800              push 00484388 ==> "Mauvais code..."
:0048422D 8B45FC                  mov eax, [ebp-04] ==> addr du bon serial dans eax
:00484230 50                      push eax
:00484231 6A00                    push 00
:00484233 EB1B                    jmp  00484250 ==> saute vers la fonction Messageboxa
:00484235 90                      nop
:00484236 90                      nop
:00484237 8B45EC                  mov eax, [ebp-14]
:0048423A E8FD0AF8FF              call 00404D3C
:0048423F 50                      push eax 
:00484240 6888434800              push 00484388 
:00484245 A154F14800              mov eax, dword ptr [0048F154]
:0048424A E8B978FCFF              call 0044BB08
:0048424F 50                      push eax 
:00484250 E83F34F8FF              Call user32!MessageBoxa

Pour l'instant en mémoire ca marche! ON NE PATCHERA LE FICHIER QUE QUAND JE LE DIRAIS! C'est bien joli mais ca fait pas esthétique d'afficher "Mauvais code!" comme titre.
Je mettrait bien "Cracked by MadMickael" à la place.

Donc là il faut placer ca dans le programme dans un espace vide, et changer mon PUSH 00484388 en PUSH [Addresse de mon texte]. Mais comment la localiser en mémoire alors que je vais patcher en hexa? Euh on magouille ! Explications

J'ouvre Catalog2k.exe dans mon éditeur héxa, et je cherche des séries de 00000000000000. Oh, y'en as une belle série de l'offset 0xb47f0 à l'offset 0xb4ba4. Ca fait de la place tout ca!

Je choisit de me placer en 0xb4b20.
A cette adresse je tape mon texte "Cracked by Madmickael", terminé par un NULL c'est à dire la valeur hex 00

J'enregistre mon fichier.
Et pour trouver l'adresse mémoire, il doit y avoir surement un calcul mais honnêtement, j'ai fais comme cela, car le calcul que j'avais imaginé me donnait un décalage de 500h et quelques bytes
J'ai lancé le programme, posé un bpx hmemcpy afin de retourner sous catalog, tapé d 00400000 et j'ai fait défiler la fenêtre des datas pour arriver à l'adresse où j'apercois "Cracked by MadMickael" (oui je sais c'est une méthode de merde!). Si vous avez mieux mailez-moi

L'adresse à pusher est donc 004BB520

===========Simulation du patch==========

:00484226 6A00                    push 00 ==> bouton OK
:00484228 6888434800              push 00484388 ==> "Mauvais code..."
:0048422D 8B45FC                  mov eax, [ebp-04] ==> addr du bon serial dans eax
:00484230 50                      push eax
:00484231 6A00                    push 00
:00484233 EB1B                    jmp  00484250 ==> saute vers la fonction Messageboxa
:00484235 90                      nop
:00484236 90                      nop
:00484237 8B45EC                  mov eax, [ebp-14]
:0048423A E8FD0AF8FF              call 00404D3C
:0048423F 50                      push eax 
:00484240 6888434800              push 00484388 
:00484245 A154F14800              mov eax, dword ptr [0048F154]
:0048424A E8B978FCFF              call 0044BB08
:0048424F 50                      push eax 
:00484250 E83F34F8FF              Call user32!MessageBoxa

devient

:00484226 6A00                    push 00 ==> bouton OK
:00484228 6888434800              push 004BB520 ==> "Cracked by MadMickael"
:0048422D 8B45FC                  mov eax, [ebp-04] ==> addr du bon serial dans eax
:00484230 50                      push eax
:00484231 6A00                    push 00
:00484233 EB1B                    jmp  00484250 ==> saute vers la fonction Messageboxa
:00484235 90                      nop
:00484236 90                      nop
:00484237 8B45EC                  mov eax, [ebp-14]
:0048423A E8FD0AF8FF              call 00404D3C
:0048423F 50                      push eax 
:00484240 6888434800              push 00484388 
:00484245 A154F14800              mov eax, dword ptr [0048F154]
:0048424A E8B978FCFF              call 0044BB08
:0048424F 50                      push eax 
:00484250 E83F34F8FF              Call user32!MessageBoxa

================================
je patche le fichier, j'enregistre et ca marche!!

3) Affichage du Bon code (2)

Faisont le point
On est content, le serial est affiché dans une MessageBox qui porte notre signature. Mais le serial est bien long à taper pour l'utilisateur. Et si je faisait en sorte que la boite de texte qui recueille le code tapé affiche le bon code? Mais dites moi c'est une idée à creuser ca!
Pour cela, l'API SetWindowTexta est toute indiquée :

BOOL SetWindowText(

    HWND hWnd,          // handle de la fenêtre
    LPCTSTR lpString   // adresse de la string qui devra être affichée
   );

Elle met le texte contenu à l'adresse lpString dans la fenetre qui à pour handle hWnd. 

A retenir, la notion de fenêtre est très large : bouton, editBox, etc...

Toujours pareil, notre procédure ressemblera à ceci :

mov eax, [ebp-04]==> vous vous rappelez? [ebp-04] est l'adresse du serial
push eax
mov eax [handle de la boite de texte du code] (que l'on appelera désormais CodeBOX)
push eax
Call User32!SetWindowTexta

The quechtionne ize : Comment récupérer le Handle de CodeBOX?
Alors là je sort mon arme secrète, The Customizer.
Avec ce programme, on peut sniffer l'handle, l'ID, les infos sur les boites de dialogues et les controles, rien quand passant la souris dessus. C'est mieux que HWND sous Sice! Donc je passe sur CodeBOX, et Bingo ==> Handle = 0x2f8

Donc ca donne :

mov eax, [ebp-04]
push eax
mov eax, 2f8
push eax
Call User32!SetWindowTexta

Toujours pareil, je patche d'abord en mémoire! :
==========================================

:00484226 6A00                    push 00 ==> bouton OK
:00484228 6888434800              push 004BB520 ==> "Cracked by MadMickael"
:0048422D 8B45FC                  mov eax, [ebp-04] ==> addr du bon serial dans eax
:00484230 50                      push eax
:00484231 6A00                    push 00
:00484233 EB1B                    jmp  00484250 ==> saute vers la fonction Messageboxa
:00484235 90                      nop
:00484236 90                      nop
:00484237 8B45EC                  mov eax, [ebp-14]
:0048423A E8FD0AF8FF              call 00404D3C
:0048423F 50                      push eax 
:00484240 6888434800              push 00484388 
:00484245 A154F14800              mov eax, dword ptr [0048F154]
:0048424A E8B978FCFF              call 0044BB08
:0048424F 50                      push eax 
:00484250 E83F34F8FF              Call user32!MessageBoxa

devient

:00484226 8B45FC                  mov eax, [ebp-04]==> adresse serial dans eax
:00484229 50                      push eax ==> [adresse texte]
:0048422A B8FC0200                mov eax, 2f8 ==> valeur du handle
:0048422E 6A00                    push eax
:00484230 E899D9ACBF              Call User32!SetWindowTexta 
:00484235 EB1E                    jmp 00484255 ==> saute juste après la messagebox
:00484237 8B45EC                  mov eax, [ebp-14]
:0048423A E8FD0AF8FF              call 00404D3C
:0048423F 50                      push eax 
:00484240 6888434800              push 00484388 
:00484245 A154F14800              mov eax, dword ptr [0048F154]
:0048424A E8B978FCFF              call 0044BB08
:0048424F 50                      push eax 
:00484250 E83F34F8FF              Call user32!MessageBoxa
:00484255 8B830C030000            mov eax, dword ptr [ebx+0000030C] *Arrive ici

Et tant que le prog n'est pas fermé, ca marche! Je patche le fichier et bizarre, ca marche plus! Etant newbie en reverse je ne savait pas que l'handle était toujours différent!!!
Aie c'est mal barré! Il faut donc qu'avant de pusher eax la deuxième fois, je récupère l'handle de CodeBox et le mette dans eax!!! Euh oui docteur y'a un pb!

Et puis je me suis dit : "voyons, voyons, si le prg recupere les contenus des boites de texte, il doit veiller à calculer leur handle pour......Taratata! Je divague! Hé, mais la fonction messageboxa doit avoir comme dernier paramètre un handle existant! Aaaah ca avance !!! :

:00484245 A154F14800              mov eax, dword ptr [0048F154]
:0048424A E8B978FCFF              call 0044BB08 ==> donc logiquement calcule l'handle!!!
:0048424F 50                      push eax ===> push l'handle de la fenetre proprio (relever la valeur)
:00484250 E83F34F8FF              Call user32!MessageBoxa

Retour sous The customiser, cette fois ci je sélectionne la fenetre entière "Catalogue 2k- shareware". Tient tient, mais eax=handle_donné_par_customizer!! Ma supposition est bonne!

Après étude de ce call il semble que la valeur de l'handle dépende du Mov eax, dword ptr [0048F154] situé juste avant ! Valeur désignée par [0048F154] pour la fenetre principale, donc une autre adresse doit permettre de calculer le handle de ma CodeBox!

Maintenant vous allez comprendre pourquoi j'ai gardé du code au début! :

:004841E1 8B83F0020000            mov eax, dword ptr [ebx+000002F0]==> Magic valeur 1
:004841E7 E89C12FCFF              call 00445488 ==> Magouille mon nom car .....instruction suivante
:004841EC 8B45F8                  mov eax, dword ptr [ebp-08] ==> eax== mon nom
:004841EF 8D55FC                  lea edx, dword ptr [ebp-04]
:004841F2 E8CD5CFEFF              call 00469EC4
:004841F7 8D55F4                  lea edx, dword ptr [ebp-0C]
:004841FA 8B83FC020000            mov eax, dword ptr [ebx+000002FC]==> Magic valeur 2
:00484200 E88312FCFF              call 00445488  ==> magouille sur le serial, car teste la longueur (rentrez y vous verrez!)
:00484205 837DF400                cmp dword ptr [ebp-0C], 00000000 ==>longueur du serial <4?
:00484209 741B                    je 00484226 ==> OUI alors BEEP fuck u

|
:0048420E 8B83FC020000            mov eax, dword ptr [ebx+000002FC] ==>  Magic valeur 2
:00484214 E86F12FCFF              call 00445488 ==> triffouille encore avec mon serial
:00484219 8B45F0                  mov eax, dword ptr [ebp-10]  ===> Ton serial 
:0048421C 8B55FC                  mov edx, dword ptr [ebp-04]  ===> bon serial

Il semblerait que [ebx+000002FC] soit en rapport avec la gestion du serial!
je vais donc essayer de mettre [ebx+000002FC] en eax, appeler le call calculateur 0044BB08, puis prier pour que le nombre sortit en eax soit le handle de la CodeBox! On va essayer en mémoire! On doit changer ceci :

:00484226 8B45FC                  mov eax, [ebp-04]==> adresse serial dans eax
:00484229 50                      push eax ==> [adresse texte]
:0048422A B8FC0200                mov eax, 2f8 ==> valeur du handle
:0048422E 6A00                    push eax
:00484230 E899D9ACBF              Call User32!SetWindowTexta 
:00484235 EB1E                    jmp 00484255 ==> saute juste après la messagebox
:00484237 8B45EC                  mov eax, [ebp-14]
:0048423A E8FD0AF8FF              call 00404D3C
:0048423F 50                      push eax 
:00484240 6888434800              push 00484388 
:00484245 A154F14800              mov eax, dword ptr [0048F154]
:0048424A E8B978FCFF              call 0044BB08
:0048424F 50                      push eax 
:00484250 E83F34F8FF              Call user32!MessageBoxa
:00484255 8B830C030000            mov eax, dword ptr [ebx+0000030C] *Arrive ici

:00484226 8B45FC                  mov eax, [ebp-04]
:00484229 50                      push eax 
:0048422A 8B83FC020000            mov eax, [ebx+000002FC] ==>magic valeur 2
:00484230 E8D378FCFF              call 0044BB08 ===> call de calcul
:00484235 50                      push eax ==> push le handle
:00484236 E899D9ACBF              call User32!SetWindowTexta
:00484241 EB18                    jmp 00484255 ==> saute après la messagebox (on en as plus besoin)
:00484243 90                      nop
:00484244 90                      nop
:00484245 A154F14800              mov eax, dword ptr [0048F154]
:0048424A E8B978FCFF              call 0044BB08
:0048424F 50                      push eax
:00484250 E83F34F8FF              Call user32!MessageBoxa
:00484255 8B830C030000            mov eax, dword ptr [ebx+0000030C] *Arrive ici

On patche le fichier et ca marche! Groovy! Pour faire faire travailler un peut vos neurones vous pouvez essayer d'afficher une messagebox ayant pour titre "Cracké par.." et comme message "Veillez maintenant cliquez sur 'Enregistrer'" APRES avoir mit le bon code dans la boite de texte! Ce que j'ai fait sur le crack que je distribue! Mais ca n'a aucun interêt si vous pompez la manière de faire en l'étudiant !

-----------------------Greetz--------------------------

Special Thanks to Freud, sans son super tut sur Web Construction Kit je n'aurais rien fait.
La scène francaise en général, et en particulier les membres du Craking France Forum,
de (feu) L'IRIP (une chtite larme), tous ceux qui font progresser le millieu, et aussi
+R!sc, G-Rom, Christal, Izcelion, +Fravia, +Frog's Print, Teeji, TaMaMbolo (Vive Drapeaux Noir!)
ACiD BUrN , Lucifer48 (un frenchie ds la Phrozen Crew la classe!), et bien sur pour finir toute l'équipe de FiGHTiNG FOR FUN

--------------------------- Voilaaaaaaaaa c'est finit----------------------------------------
Je m'ouvre une petite DESPE pour féter ca! BuuRrrrRrrrrPPpppPppP

DISCLAIMER

Ce tut est uniquement à but informatif !! Si vous aimez un shareware achetez-le! L'utilisation des cracks est illégale!

http://www.fighting-for-fun.fr.st