Ce cours est un reflet fidèle du cours intégré au crack de ma création de Total Commander 6.51 fr

PEid 0.92
Pour détecter le packer qui a été utilisé pour protéger une application.

UPX 1.20
Compresseur / décompresseur de fichiers exécutables.

Ollydbg 1.10
Désassembleur / débugger

        TOTALCMD.EXE

        Avant propos

           On va s'attaquer aujourd'hui au célèbre concurrent de l'explorateur windows.

           Comme d'habitude lorsque l'on commence le craquage d'un programme on commence par le désassembler et ensuite le débugger pour y repérer les failles qui nous serviront à élaborer par la suite le crack. Le désassembleur / débuggueur que j'ai l'habitude d'utiliser et dont on va se servir c'est w32dasm. Cette introduction faite nous pouvons commencer.

           On ouvre donc le logiciel TOTALCMD.EXE dans le désassembleur w32dasm par la commande Disassembler -> Open File to disassemble -> TOTALCMD.EXE. On s'attend comme d'habitude à trouver un listing de désassemblage avec un suite de lignes de code en assembleur. Seulement voila w32dasm se ferme et aucun désassemblage n'est possible !

          1/ Trouver le packer utilisé

         Premier réflexe face à la situation présentée ci-dessus c'est de se dire que l'on est présence d'un packer. Un packer c'est quoi et ça sert à quoi vous me direz ? Eh bien c'est un programme qui recode un exécutable en compressant et cryptant certaines parties de cet exécutable (la section de code notamment).Cela a pour conséquence de réduire en taille l'exécutable ainsi généré mais surtout de le protéger contre tout désassemblage et tout déboguage que nous cracker nous menons systématiquement pour retirer les protections incluses dans le logiciel.

          Pour trouver le packer utilisé il nous faut un logiciel très bien fait qui s'appelle PEiD (version 0.92). Vous le lancez et cliquez les ...Vous allez chercher TOTALCMD.EXE. Eh là vous voyez apparaître en bas le nom du packer utilisé suivi du nom de son créateur UPX 0.89.6 - 1.02 / 1.05 - 1.24 (Delphi) stub -> Markus & Laszlo [Overlay].

          2/ Unpacker TOTALCMD.EXE

          On vient de voir (partie 1) que le packer utilisé est UPX (Universal Packer for eXecutables). On va sur http://www.exetools.com/compressors.htm et on prend la dernière version du packer la version 1.20 au 21/02/2004 pour windows (118 Ko). On met TOTALCMD.EXE et upx.exe sur le bureau et on crée sur le bureau un fichier nommé decompresser.bat contenant la ligne de commande suivante :

          upx -d -oTOTALCMD-decompresse.exe "TOTALCMD.EXE"

          On double clique sur decompresser.bat et on attend un peu et on obtient TOTALCMD-decompresse.exe.C'est la version décompressée (on dit encore unpackée) de Total commander qui fait 2.18 Mo.

          3/ Désassemblage et craquage de TOTALCMD-decompresse.exe

          Dans cette partie nous ne travaillerons uniquement qu'avec la version décompressée de TOTALCMD.EXE.

               a/ Retrait de la popup d'enregistrement au démarrage

             J'ai choisi de l'enlever en premier car elle nous gênera au moment du débugging de TOTALCMD-decompresse.exe avec w32dasm. En effet cette popup va se coller au milieu de l'écran et cacher tout le listing de déassemblage.Il n'y aura pas de possibilités pour l'enlever ou la déplacer une fois affichée.En plus elle ne sert à rien dans le programme puisque pour savoir si on est enregistré il suffit d'aller dans le menu Aide -> A propos de Total commander ... à droite dans la fenêtre de TOTALCMD-decompresse.exe.

             On commence par désassembler TOTALCMD-decompresse.exe.Pour cela on lance w32dasm et on fait  Disassembler -> Open File to disassemble -> TOTALCMD-decompresse.exe.

             Passons maintenant au débugging de TOTALCMD-decompresse.exe.Dans w32dasm chargez TOTALCMD-decompresse.exe en mémoire avec la commande CTRL L puis lancez la session de débugging de TOTALCMD-decompresse.exe en mode pas à pas avec la touche F8.Le mode pas à pas veut dire que l'on va exécuter le programme ligne de commande par ligne de commande.Après plusieurs pressions sur F8 (108 exactement) vous arrivez là.

* Reference To: KERNEL32.GetPrivateProfileIntA, Ord:0000h
:005BE0DD	E87672E4FF	Call 00405358
:005BE0E2	85C0	test eax, eax
:005BE0E4	740C	je 005BE0F2
:005BE0E6	B201	mov dl, 01
:005BE0E8	A16C555C00	mov eax, dword ptr [005C556C]
:005BE0ED	E8566EE5FF	call 00414F48
* Referenced by a (U)nconditional or (C)onditional Jump at Address: |:005BE0E4(C)
:005BE0F2	A16C555C00	mov eax, dword ptr [005C556C]

             Arrivé sur l'adresse 005BE0ED si vous faites F8 la popup apparaît.On voit tout de suite que l'on peut éviter de passer sur cette adresse en forçant le saut en 005BE0E4.Il suffit de remplacer

             :005BE0E4   740C     je 005BE0F2
             par
             :005BE0E4   EB0C    jmp 005BE0F2

            On va faire la modification directement dans TOTALCMD-decompresse.exe.Comme ça la popup ne nous gênera plus dans le désassemblage et dans le programme elle ne s'affichera plus non plus.Pour effectuer la modification on ferme w32dasm, on ouvre TOTALCMD-decompresse.exe dans l'éditeur hexadécimal winhex, on se postionne sur  l'offset 1BD4E4 (ALT G -> 1BD4E4) et on remplace le code en rouge (à savoir 740C devient EB0C).On enregistre la modification par CTRL S.

             Nb : l'offset 1BD4E4 est obtenu dans w32dasm en sélectionnant la ligne d'adresse 005BE0E4 et en regardant le nombre en bas dans la barre de statut à droite de @Offset.

            On refait un désassemblage de TOTALCMD-decompresse.exe et une fois le désassemblage terminé par sécurité on enregistre le code désassemblé avec Disassembler -> Save Disassembly Text File and Create Project File -> totalcmd.alf. Comme ça en cas de plantage vous pourrez récupérer votre listing de désassemblage par Project -> Open Project File -> TOTALCMD-decompresse.alf en moins d'une seconde au lieu d'attendre la fin des 2, 3 minutes que prend le désassemblage de TOTALCMD-decompresse.exe.

              b/ Retrait du nag-screen et des messages d'évaluation

            Je ne sais pas si vous aviez fait attention tout à l'heure au moment du débugging mais dans la popup d'enregistrement (cf 3-a) vous aviez le message NOT REGISTERED.Cela signifie que le programme sait avant d'arriver en 005BE0ED que l'on est pas enregistré.On sait donc que la vérification si on est enregistré ou non se fait entre le point d'entrée du programme (entry point en anglais) et l'adresse 005BE0ED.Ca réduit le champ d'investigation pour trouver le moyen de s'enregistrer.

            Regardons dans les strings data references de TOTALCMD-decompresse.exe en cliquant sur le bouton Strn Ref dans la barre de boutons de w32dasm pour voir si quelque chose nous parle d'enregistrement.Oui nous avons la chaîne wincmd.key.Pourquoi cette chaîne est intéressante ? Parceque le mot .key nous indique que le logiciel est enregistrable au moyen d'un fichier nommé wincmd.key contenant une clé de déverrouillage valide.On appelle ce type de fichier dans la terminologie du cracking un keyfile.

* Referenced by a CALL at Addresses: |:004CB577 , :004CBE4D
...
* Possible StringData Ref from Code Obj ->"wincmd.key"
:004CB2B7	8B1588F85B00	mov edx, dword ptr [005BF888]
:004CB2BD	8BC3	mov eax, ebx
:004CB2BF	E85CBDF3FF	call 00407020
...
:004CB2F2	C3	ret

 

            Ce que nous allons faire maintenant c'est mettre un point d'arrêt sur la ligne d'adresse 004CB2B7.Pour cela faites CTRL L puis rendez-vous par SHIFT -> F12 -> 004CB2B7 à la ligne d'adresse 004CB2B7 ; sélectionnez la puis faites F2. Démarrez le débugger avec F9 et dès que w32dasm s'arrête sur 004CB2B7 traçez le programme en mode pas à pas avec des F8 (on va suivre ce qui se passe après 004CB2B7). Faites F7 puis des F8 si F8 provoque le lancement du programme.

            Le programme arrive sur l'instruction ret (ret = return = fin d'un call) à l'adresse 004CB2F2 et se positionne sur l'instruction qui suit le call dans lequel on se trouvait (là où il y avait le wincmd.key) c'est à dire l'adresse 004CB57C.A partir de ce moment là activez en les cochant toutes les options dans la petite fenêtre du débugger (surtout l'option Enable Local Function Details).Cela va nous permettre de savoir ce qui se passe dans les call que l'on va survoler par la suite avec des F8.

:004CB577	E8DCFCFFFF	call 004CB258
:004CB57C	8BF8	mov edi, eax
...
:004CB90C	8D8550F7FFFF	lea eax, dword ptr [ebp+FFFFF750]
:004CB912	50	push eax
:004CB913	8B85FCFEFFFF	mov eax, dword ptr [ebp+FFFFFEFC]
:004CB919	50	push eax
* Reference To: user32.GetWindowTextA, Ord:0000h
:004CB91A	E811A3F3FF	Call 00405C30
:004CB91F	BAF8BD4C00	mov edx, 004CBDF8
:004CB924	8D8550F7FFFF	lea eax, dword ptr [ebp+FFFFF750]
:004CB92A	E8D5B6F3FF	call 00407004
:004CB92F	84DB	test bl, bl
:004CB931	745F	je 004CB992
...
* Referenced by a (U)nconditional or (C)onditional Jump at Address: |:004CB931(C)
:004CB992	84DB	test bl, bl
:004CB994	0F84F8010000	je 004CBB92
:004CB99A	8D8586FEFFFF	lea eax, dword ptr [ebp+FFFFFE86]
:004CB9A0	B27C	mov dl, 7C
:004CB9A2	E885E50E00	call 005B9F2C
...
:004CBAF9	E806B5F3FF	call 00407004
:004CBAFE	6683BD7FFEFFFF01	cmp word ptr [ebp+FFFFFE7F], 0001
:004CBB06	7512	jne 004CBB1A
* Possible StringData Ref from Code Obj ->"Personal licence"
...
* Possible StringData Ref from Code Obj ->" User licence"
:004CBB44	BA20BE4C00	mov edx, 004CBE20
:004CBB49	8D8554F8FFFF	lea eax, dword ptr [ebp+FFFFF854]
:004CBB4F	E8B0B4F3FF	call 00407004
...
* Referenced by a (U)nconditional or (C)onditional Jump at Address: |:004CB994(C)
:004CBB92	8D8550F7FFFF	lea eax, dword ptr [ebp+FFFFF750]
...
* Possible Reference to String Resource ID=00016: "Specify file type"
:004CBC7B	B910000000	mov ecx, 00000010
:004CBC80	E8BB6DF3FF	call 00402A40
:004CBC85	7402	je 004CBC89
:004CBC87	33DB	xor ebx, ebx
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses: |:004CBC11(C), :004CBC85(C)
:004CBC89	8B85F8FEFFFF	mov eax, dword ptr [ebp+FFFFFEF8]

            La fenêtre intitulée w32dasm API details nous indique que le message "Total Commander 6.51" que l'on retrouvera plus tard dans le titre de la fenêtre principale est chargé en 004CB90C depuis l'adresse [ebp+FFFFF750] =  [ebp-000008B0] (FFFFF750 = FFFFFFFF - 000008B0 + 00000001 = - 000008B0 + 00000000).Pour retrouver cette valeur regardez dans la grande fenêtre du débuggeur (celle apparue quand vous aviez fait CTRL L dans w32dasm) au moment où êtes arrivé avec des F8 sur l'adresse 004CB90C puis cliquez sur le bouton ebp et remontez à l'aide de l'ascenseur à droite de cette zone jusqu'à  [ebp-000008B0].

            En 004CB92A c'est le message "Total Commander 6.51 - " qui est chargé.

            En 004CB994 le programme saute vers 004CBB92 en passant par dessus les expressions "Personal licence" et "User licence".Il faut donc absoluement empêcher ce saut puisque l'on veut être enregistré (ie avoir une licence).Seulement est-ce que si vous vous contentez d'annuler le saut en remplaçant

            :004CB994   0F84F8010000   je 004CBB92
            par
            :004CB994   0F84F8010000   je 004CB99A

            Vous ne retirez pas le nag-screen.Réfléchissons.Le saut depuis 004CB994 ne s'effectue que si le test bl, bl en 004CB992 rend 0 c'est à dire si bl vaut 0.Eh bien nous n'avons qu'à mettre bl à 01 et le tour est joué (par exemple en incrémentant ebx de 1).En effet si ebx =XXYYZZTT avec X,Y,Z,T dans {0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F} alors bl=TT. Pour cela on va utiliser la fonction d'assemblage de w32dasm.Dans w32dasm annuler tous les breakpoints posés en cliquant sur le bouton clear à droite dans la grande fenêtre du debugger puis terminer la session de debugging courante par CTRL T (T pour terminate) puis relancez en une avec CTRL L puis SHIT F12 -> 004CB992 -> F2 -> F9.Cliquez sur le bouton patch code dans la petite fenêtre du debuggeur et tapez les ligne suivantes suivie d'un entrée pour chacune d'elle (sans taper le // et le commentaire qui suit).

             inc ebx                     // On incrémente ebx de 1 ie ebx = 00000001
             nop                          // Equilibrage du code
             nop                          // Equilibrage du code
             nop                          // Equilibrage du code
             nop                          // Equilibrage du code
             nop                          // Equilibrage du code
             nop                          // Equilibrage du code
             nop                          // Equilibrage du code
 

            Ensuite Apply Patch -> Close -> oui -> oui.Appuyons ensuite sur F8 plusieurs fois pour voir ce qui se passe.Arrivé en 004CBC85 TOTALCMD-decompresse.exe s'apprête à exécuter un xor ebx, ebx assez suspect.On va forcer le saut vers 004CBC89 en mettant le flag ZF à 1.Pour cela cliquez sur le bouton modify Data de la grande fenêtre du debugger puis cliquez sur le 0 en dessous de la lettre Z dans la fenêtre qui vient d'apparaître.Le 0 est passé à 1.Valider la modification en pressant les boutons modify puis close.

              Remarque  : les 2 modifications (celle avec le bouton patch code et celle avec le bouton modify Data) ne seront valables que le temps de la sesssion de debugging courante.Si vous en relancez une nouvelle il faudra refaire la manipulation.

              Faisons F9 pour lancer le programme et voir ce qui a changé.Le nag-screen avec les 3 boutons a disparu ainsi que le NOT REGISTERED dans la barre de titre qui est remplacé par @. Dans le menu Aide -> A propos de Total Commander les expressions "Copie d'évaluation non enregistrée" et "Enregistrez votre copie svp" ont disparu et ont été remplacées par @.

              Ce qu'on va faire c'est enlever le - @ dans la barre de titre de TOTALCMD-decompresse.exe et le code # 2097168 43264 user licence du menu Aide -> A propos de Total Commander

              Terminez la session de debugging par CTRL T puis relançez en une nouvelle avec CTRL L.Mettez des points d'arrêt sur le adresse 004CB91A et 004CB992 en activant les 5 cases dans la petite fenêtre du debugger puis F9 puis F8 plusieurs fois.Vous voyez qu'à l'adresse 004CB91F l'adresse 004CBDF8 contient le - de - @.Eh bien pour supprimer les  "-" ouvrez Copie de TOTALCMD-decompresse.exe dans winhex puis faites -> ALT G -> CAD1F et remplacez le code en rouge suivant :

              :004CB91F       BAF8BD4C00      mov edx, 004CBDF8
              par
              :004CB91F       BAFFBD4C00      mov edx, 004CBDFF

             Enregistrez et lancer Copie de TOTALCMD-decompresse.exe. Le - a disparu.Comment est-ce que je sais que qu'il faut remplacer F8 par FF ? Eh bien la grande fenêtre du debuggeur nous dit en tapant sous la case User Addr1 l'adresse 004CBDFF puis en cliquant sur le bouton UA1 juste à droite qu'à cette adresse nous avons le code hexadécimal 20 00 00 00 (autrement dit un espace suivi de caractères nuls).Cette chaîne est intéressante car elle correspond à une chaîne avec un blanc.Elle convient parfaitement dans notre situation puisque on veut effacer le -.On ne fait que remplacer la chaîne "-" par " ".

              Faites ensuite F9 pour arriver sur l'adresse 004CB992 puis refaites l'assemblage des instructions de tout à l'heure.On voit que le @ dans  - @ est chargé une fois passé sur la cette ligne de code d'adresse 004CB99A.

              Donc il suffit de mettre 00 à la place de 40 (code hexadécimal correspondant à @) dans [ebp+FFFFFE86] et nous aurons une chaîne vide au lieu de @ dans la barre de titre de Total Commander et dans le menu A propos.Ouvrez Copie de TOTALCMD-decompresse.exe dans winhex et faites le remplacement (du code en rouge) suivant à partir de l'offset CAD92

              :004CB992    84DB                           test bl, bl
              :004CB994    0F84F8010000            je 004CBB92
              :004CB99A   8D8586FEFFFF           lea eax, dword ptr [ebp+FFFFFE86]
              remplacé par
              :004CB992    33C0                            xor eax, eax
              :004CB994    43                                 inc ebx
              :004CB995    E900000000                jmp 004CB99A
              :004CB99A   898586FEFFFF           mov dword ptr [ebp+FFFFFE86], eax

              Dans le nouveau code successivment on met eax à 0,on ajoute 1 à ebx, on annule le saut vers 004CBB92 et on met 0 dans [ebp+FFFFFE86].N'oublions pas à l'offset CB085 de forcer le saut pour retirer le nag-screen (vu précédemment).

              :004CBC85   7402                            je 004CBC89
              remplacé par
              :004CBC85   EB02                           jmp 004CBC89

              Arrivé avec des F8 sur la ligne d'adresse 004CBB4F (juste en dessous user license) et si vous l'exécuter avec F8 vous avez dans la grande fenêtre du debugger en cliquant sur le bouton eax

              [eax-00000004] - 77d4c076      v..w
              [eax+00000000] - 230d0d20     ..#
              [eax+00000004] - 37393032    2097
              [eax+00000008] - 20383631    168
              [eax+0000000C] - 36323334   4326
              [eax+00000010] - 73552034    4 Us
              [eax+00000014] - 6c207265    er l
              [eax+00000018] - 6e656369    icen
              [eax+0000001C] - 00006563   ce..
              [eax+00000020] - 00000000    ....

             Pour supprimer # 2097168 43264 user licence du menu Aide -> A propos de Total Commander il suffit de d'ouvrir Copie de TOTALCMD-decompresse.exe dans winhex et faire le remplacement (du code en rouge) suivant à partir de l'offset CAF4F :

              :004CBB4F    E8B0B4F3FF                call 00407004
              remplacé par
              :004CBB4F    C60000                         mov byte ptr [eax], 00
              :004CBB52    90                                  nop
              :004CBB53    90                                  nop

             Explication : on met 00 au début de la chaîne [eax] = "# 2097168 43264 user licence" ce qui permet de la vider.

              c/ Retrait du contrôle CRC

              Un CRC (Contrôle de Redondance Cyclique : Cyclical Redundancy Control) est un fragment de code qui permet de s'assurer de l'intégrité d'un fichier en associant à un fichier un nombre hexadécimal unique qu'on appelle une clé.Cette clé est en général codé sur 4 octets (32 bits) par exemple 84C3A8DC et n'est calculée qu'après la lecture complète du fichier.Ensuite une simple comparaison entre le CRC calculé du fichier et la valeur attendue stockée dans l'exécutable permet de prévenir toute modification de cet exécutable.

              Dans le cas de TOTALCMD-decompresse.exe toute modification se traduit par un message d'alerte "WARNING: The TOTALCMD executable file is corrupted, possible VIRUS! Totalcmd will close.Please run a virus scanner as soon as possible" puis par la fermeture de Total Commander.

              Petite précision notre exécutable TOTALCMD-decompresse.exe.Celui-ci provient de l'unpacking de TOTALCMD.EXE. TOTALCMD-decompresse.exe est donc reconnu par lui-même comme étant un fichier ayant été modifié  même si physiquement vous n'avez pas touché à un seul de ses octets avec winhex.En effet l'unpacking modifie le code en restituant celui d'origine avant le packing qui a été effectué ici avec le packer UPX.

              Comment retirer cette protection ? Désassemblons dans w32dasm le programme TOTALCMD-decompresse.exe et regardons les fonctions API importées dans TOTALCMD-decompresse.exe en cliquant sur le bouton Imp Fn dans la barre d'outils de w32dasm .Voyons s'il y a des fonctions qui nous parlent de lecture de fichier.Oui une.KERNEL32.ReadFile

              Ce qu'on va faire c'est mettre un point d'arrêt sur chaque occurence de cette fonction ReadFile dans le code de TOTALCMD-decompresse.exe.Pour cela dans w32dasm CTRL L, CTRL S , search -> find text -> ReadFile -> entrée.Vous sélectionnez alors la ligne de code en dessous (d'adresse 00401288) puis vous posez le point d'arrêt avec F2.Faites ensuite F3 pour passer à l'occurence suivante puis F2 sur la ligne suivante en la sélectionnant au prélalable et ainsi de suite jusqu'à la fin.Vous devez avoir posé 6 points d'arrêt sur les adresses suivantes: 0040422D, 0040436F, 00406AFC, 0043DB01, 0043DB72, 0056BD61.Les 2 autres adresses 00401288, 004054B0 ne nous intéressent pas car elles sont en effet incluses dans l'appel à la fonction Readfile (elles ne sont pas suivies plus bas d'une instruction ret).On va surveiller maintenant les instructions assembleur de type mov reg,nb ou xor reg,nb avec reg un registre par exemple eax ou ebx ou ecx ou edx ou ebp et nb un nombre hexadécimal sur 4 octets (ce nombre c'est la clé correspondant au CRC que l'on cherche).

              C'est parti.On lance la session de debugging avec F9.Dès que w32dasm break vous faites des F8 : debugging en mode pas à pas (on exécute les call sans descendre dedans) jusqu'à arriver à la fin de la fonction Readfile (la fin d'une fonction est symbolisée par une instruction asm ret).Dès que vous faites F8 sur le ret ou le ret 0004 vous arrivez à l'endroit d'appel de la fonction Readfile que l'on vient d'exécuter.A ce moment regardez le code aux alentours pour voir si on y trouve le mov reg,nb ou un xor reg,nb de tout à l'heure.La première fois on ne voit rien.On continue avec des F9 (exécution du programme).Au total au bout de 7 pressions sur F9 depuis le lancement de la session de debugging vous arrivez à l'adresse 0045953B (une fois passé sur le ret).

* Referenced by a (U)nconditional or (C)onditional Jump at Address: |:00459565(C)
:00459514	817DE000800000	cmp dword ptr [ebp-20], 00008000
:0045951B	7E08	jle 00459525
:0045951D	66C745EE0080	mov [ebp-12], 8000
:00459523	EB08	jmp 0045952D
...
* Referenced by a (U)nconditional or (C)onditional Jump at Address: |:00459523(U)
...
:0045953B	E8A845FEFF	call 0043DAE8
...
:0045955A	3D00800000	cmp eax, 00008000
:0045955F	7506	jne 00459567
:00459561	837DE000	cmp dword ptr [ebp-20], 00000000
:00459565	75AD	jne 00459514
* Referenced by a (U)nconditional or (C)onditional Jump at Address: |:0045955F(C)
:00459567	BA01800000	mov edx, 00008001
...
:00459597	3565BE672A	xor eax, 2A67BE65
:0045959C	8945F8	mov dword ptr [ebp-08], eax
:0045959F	55	push ebp
:004595A0	E857FEFFFF	call 004593FC

 

              Ca y est on l'a l'adresse du calcul du CRC c'est l'adresse 00459597 (on y voit la fameuse clé sur 4 octets : 2A67BE65 dont je parlais plus haut).Dans la session de debugging courante mettons un bp (point d'arrêt) sur la ligne d'adresse 00459597 en sélectionnant cette ligne puis en appuyant sur F2.Mettez en un aussi sur 004595A0.Ensuite faites des F9 autant de fois que nécessaire pour arriver sur l'adresse 00459597.Ensuite F8 pour arriver jusqu'au call 004593FC.A ce moment là on relève dans la grande fenêtre du débugger la valeur de [ebp-08] qui vaut 84c3a8dc.Arrivé sur le call 004593FC on fait F7 pour voir ce qu'il y a à l'intérieur

* Referenced by a CALL at Address: |:004595A0
...
:0045942A	8B4508	mov eax, dword ptr [ebp+08]
:0045942D	8170FC89E2A3F5	xor dword ptr [eax-04], F5A3E289
:00459434	55	push ebp
:00459435	E8BAFEFFFF	call 004592F4

 

               Arrivé avec des F8 sur l'adresse 00459435 vous avez [eax-04] = af7e89ef (regardez dans la grande fenêtre du débuggeur pour voir cette valeur en cliquant sur le bouton eax et en lisant la valeur à droite de [eax - 00000004]). Descendons dans le call 004592F4 avec F7.

* Referenced by a CALL at Address: |:00459435
:004592F4	55	push ebp
:004592F5	8BEC	mov ebp, esp
:004592F7	8B4508	mov eax, dword ptr [ebp+08]
:004592FA	8B4008	mov eax, dword ptr [eax+08]
:004592FD	8B40FC	mov eax, dword ptr [eax-04]
:00459300	8B5508	mov edx, dword ptr [ebp+08]
:00459303	8B5208	mov edx, dword ptr [edx+08]
:00459306	3B42F8	cmp eax, dword ptr [edx-08]
:00459309	0F94C0	sete al
:0045930C	E85BF31500	call 005B866C

 

                La clé du contrôle d'intégrité est à l'adresse 00459306.

               :00459306   3B42F8    cmp eax, dword ptr [edx-08]

                En effet si vous regardez les valeurs comparées en 00459306 vous voyez eax = af7e89ef et dword ptr [edx-08] =  = 84c3a8dc.Vous avez compris ? Il suffit que  [ebp-08]  = 84c3a8dc à l'adresse 0045959C et  [eax-04] = af7e89ef à l'adresse 0045942D soient égaux pour retirer le CRC et faire croire à TOTALCMD-decompresse.exe que le programme n'a pas été modifié.Le pb maintenant c'est de savoir entre [ebp-08] et [eax-04] lequel correspond au CRC attendu et lequel correspond au CRC calculé ? Et bien faites une copie de TOTALCMD-decompresse.exe et ouvez la dans winhex et mettez 01 à l'offset 1C4700 (avec ALT G -> 1C4700), enregistrez puis désassemblez la dans w32dasm et mettez un bp (avec CTRL L -> SHIT F12 -> 0045959C -> OK -> F2) sur la ligne d'adresse 0045959C puis comme tout à l'heure faites un relevé des valeurs.Vous avez  [ebp-08] = 84c3a8dc à l'adresse 0045959C et [eax-04] = f9e589ee à l'adresse 0045942D.

                Conclusion : [eax-04] = CRC calculé et [ebp-08] = CRC attendu.Pourquoi ? Parceque le CRC calculé d'un fichier change dès que l'on change au moins un octet.Ici on a changé un octet à l'offset 1C4700 et comme [eax-04] a changé de valeur c'est donc bien lui notre CRC calculé.

                Il nous faut donc mettre dans [eax-04] la valeur du CRC attendu à savoir 84c3a8dc et fini les alertes aux virus.Il faut donc dans Copie de TOTALCMD-decompresse.exe remplacer le code suivant en rouge dans winhex à l'offset 5882D (sélectionnez la ligne d'adresse 0045942D dans w32dasm et regardez en bas à droite de @Offset).

               :0045942D    8170FC89E2A3F5     xor dword ptr [eax-04], F5A3E289
               remplacé par
               :0045942D   C740FCDCA8C384   mov dword ptr [eax-04], 84C3A8DC

                Enregistrez et lancez Copie de TOTALCMD-decompresse.exe.Le CRC a disparu.Mais ce n'est encore fini.Eh oui si vous faites une recherche sur la clé d'encodage du CRC 2A67BE65 que l'on avait en 00459597 vous en trouvez encore une à l'adresse 00459EE9 :

:00459ED8	E89B3BFEFF	call 0043DA78
:00459EDD	8175EC89E2A3F5	xor dword ptr [ebp-14], F5A3E289
:00459EE4	8B45E4	mov eax, dword ptr [ebp-1C]
:00459EE7	8B00	mov eax, dword ptr [eax]
:00459EE9	3565BE672A	xor eax, 2A67BE65
:00459EEE	8945E8	mov dword ptr [ebp-18], eax
:00459EF1	FF05C8075C00	inc dword ptr [005C07C8]
:00459EF7	8B45EC	mov eax, dword ptr [ebp-14]
:00459EFA	3B45E8	cmp eax, dword ptr [ebp-18]
:00459EFD	7431	je 00459F30

               Par mesure de sécurité on va la craquer aussi.On remplace dans winhex à l'offset 592DD (correspondant à l'adresse 00459EDD dans w32dasm) le code en rouge suivant.

               :00459EDD    8175EC89E2A3F5     xor dword ptr [ebp-14], F5A3E289
               remplacé par
               :00459EDD   C745ECDCA8C384   mov dword ptr [ebp-14], 84C3A8DC

          4/ Inline patching de TOTALCMD.EXE

              a/ Questions / réponses

              L'inline patching c'est quoi ?
              C'est une méthode qui vous permet de modifier des octets en mémoire avant le lancement d'un programme.

              A quoi ça nous sert ici ?
              A diffuser sur internet un crack (10 - 15 ko) qui ne contient que les octets à modifier et pas le gros fichier en entier
              TOTALCMD-decompresse.exe craqué qui fait 2239 ko.

              Pourquoi est ce qu'on peut l'utliser ici ?
              Car notre exécutable TOTALCMD.EXE est packé avec un packer (ici le packer UPX).

              Comment ça marche ?
              Quand vous lancez TOTALCMD.EXE le packer qui avait compressé TOTALCMD.EXE le décompresse
              en mémoire et lui donne la main dès qu'il a fini son travail en sautant dans le code à une adresse appelée l'OEP
              A l'OEP (Original Entry Point) le packer n'existe plus et le programme est prêt à démarrer.

              b/ Détermination de l'OEP

              Comme w32dasm se ferme quand on lui demande de désassembler TOTALCMD.EXE on va utiliser un autre désassembleur / debuggeur : le très connu ollydbg.Désassemblez TOTALCMD.EXE dans ollydg par File -> Open ->  TOTALCMD.EXE.Une fenêtre dont le titre est "Compressed code ?" apparaît.Cliquez sur OK.Vous voyez ensuite dans la fenêtre en haut à gauche le point d'entrée du packer (entry point) :

              00645A40 > $ 60                       PUSHAD

              Ce qu'il faut ensuite c'est dérouler le code vers le bas depuis 00645A40 avec la flèche du clavier et mettre un point d'arrêt en sélectionnant la ligne puis F2 sur la première instruction asm POPAD trouvée (c'est en général juste après cette instruction que le packer donne la main au programme en sautant à l'OEP).

              00645BAA   > 61                      POPAD
              00645BAB   .^E9 A881F7FF    JMP TOTALCMD.005BDD58

              Démarrez le débugging avec F9 puis F8.Vous êtes sur l'adresse 00645BAB.Si vous faites F8 vous arrivez ici :

              005BDD58   > 55                      PUSH EBP

              Conclusion : l'OEP vaut 005BDD58.

              Remarque  : l'OEP peut aussi être trouvé en chargeant TOTALCMD.EXE dans PEiD 0.92 et en cliquant sur la flèche en bas à droite puis plugins -> Generic OEP Finder.Après un petit moment vous obtenez OEP = 005BDD58.

              c/ Mise en oeuvre

              Pour pouvoir insérer notre code qui va modifier TOTALCMD.EXE et le faire passer en version complète il suffit simplement d'insérer notre code entre le moment où le packer a fini son travail (à l'adresse 00645BAA) et le moment où il saute à l'OEP (le jmp à l'adresse 00645BAB).Pour cela il faut détourner le saut en 00645BAB vers une zone de code non utilisée (par exemple la fin d'une section de l'exécutable où il y a plein de 00).C'est dans cette zone que l'on va mettre notre code.Notre code sera terminé par un simple saut vers l'OEP qui assurera le lancement du programme.

              En ouvrant TOTALCMD.EXE dans winhex et en cherchant par CTRL ALT F -> 61E9A881F7FF le code hexadécimal obtenu à partir du POPAD trouvé précédemment on voit notre code puis un peu plus loin une suite de 00 à partir de l'offset BBFBC.Pourquoi pas BBFBB ? Parceque ollydbg nous affiche

              00645BB8     D0335C00       DD TOTALCMD.005C33D0
              00645BBC     00                    DB 00
              00645BBD     00                    DB 00

              Le 00 à l'offset BBFBB appartient à une instruction assembleur : DD TOTALCMD.005C33D0

             Une question naturelle se pose ? Pourquoi y a t'il autant de 00.C'est dû au complilateur qui a compilé TOTALCMD.EXE. Les compilateurs ont pour habitude de rajouter de octets à 00 inutiles à la fin de chaque sections.Ici on est bien à la fin d'une section de TOTALCMD.EXE. On est en fait à la fin de la section UPX1 du programme comme le confirme procdump.Si vous ouvrez avec le bouton PE Editor de procdump le programme TOTALCMD.EXE et cliquez ensuite sur le bouton Sections vous voyez que l'offset BBFBC est compris entre le raw offset = 400 de la section UPX1 et le raw offset = BC800 de la section .rsrc.

              On a l'embarras du choix pour le premier offset qui va accueillir notre code.On peut choisir cet offset dans l'intervalle BBFBC et BC7FF (qui est juste avant le début de la section suivante : la section .rsrc qui commence à l'offset BC800) en sachant néanmoins que l'on a besoin de plusieurs octets à écrire à la queue leu leu.Donc les offsets trop proches de BC7FF ne nous intéressent pas car on écrit les octets de gauche à doite.J'ai choisi l'offset BC000.

              Récapitulatif des modifications effectuées (voir la partie 3).

              :005BE0E4  EB0C                  jmp 005BE0F2          // suppression popup d'enregistrement
              :004CB91F  BAFFBD4C00    mov edx, 004CBDFF// suppression - dans la barre de titre
              :004CB992  33C0                   xor eax, eax               // @ dans la barre de titre + @ dans A propos de
              :004CB994  43                        inc ebx                      // suppression nag
              :004CB995  E900000000        jmp 004CB99A        // suppression nag + messages d'évaluation dans A propos de
              :004CB99A 898586FEFFFF   mov dword ptr [ebp+FFFFFE86], eax // @ dans la barre de titre + A propos de
              :004CBC85 EB02                   jmp 004CBC89         // suppression nag
              :004CBB4F C60000               mov byte ptr [eax], 00// suppression code + user license dans A propos de
              :004CBB52 90                        nop                            // équilibrage du code
              :004CBB53 90                        nop                            // équilibrage du code
              :0045942D  C740FCDCA8C384   mov dword ptr [eax-04], 84C3A8DC    // vérification n°1 du CRC
              :00459EDD C745ECDCA8C384   mov dword ptr [ebp-14], 84C3A8DC   // vérification n°2 du CRC

              Voici comment on va procéder pour chacune des lignes de code précédentes.Par exemple pour la première à l'adresse 005BE0E4 on veut transformer 74 en EB pour supprimer la popup d'enregistrement.On va donc entrer le code suivant en rouge à l'offset BC000.

              BC000   C605E4E05B00EB          mov byte ptr [005BE0E4], EB

              Au total vous ouvrez TOTALCMD.EXE dans winhex et tapez tout le code suivant en rouge à la queue leu leu (le bleu ciel c'est pour l'offset) à partir de l'offset BC000 :

              BC000   C6 05 E4 E0 5B 00 EB                        mov byte ptr [005BE0E4], EB
              BC007   C6 05 20 B9 4C 00 FF                        mov byte ptr [004CB920], FF
              BC00E   C7 05 92 B9 4C 00 33 C0 43 E9        mov dword ptr [004CB992], E943C033
              BC018   66 C7 05 96 B9 4C 00 00 00               mov word ptr [004CB996], 0000
              BC021   C6 05 9A B9 4C 00 89                        mov byte ptr [004CB99A], 89
              BC028   C6 05 85 BC 4C 00 EB                        mov byte ptr [004CBC85], EB
              BC02F   C7 05 4F BB 4C 00 C6 00 00 90         mov dword ptr [004CBB4F], 900000C6
              BC039   C6 05 53 BB 4C 00 90                         mov byte ptr [004CBB53], 90
              BC040   66 C7 05 2D 94 45 00 C7 40               mov word ptr [0045942D], 40C7
              BC049   C7 05 30 94 45 00 DC A8 C3 84         mov dword ptr [00459430], 84C3A8DC
              BC053   66 C7 05 DD 9E 45 00 C7 40              mov word ptr [00459EDD], 40C7
              BC05C  C7 05 E0 9E 45 00 DC A8 C3 84        mov dword ptr [00459EE0], 84C3A8DC

              On ajoute ensuite le saut vers l'OEP à la fin de notre zone de code

              BC066   E9ED80F7FF                                       jmp 005BDD58

              Enfin on redirige le saut d'origine vers l'OEP vers notre zone de code (qui commence à l'offset BC000).

              BBFAB   EB53                                                   jmp 00645C00

              Détail d'un calcul (code hexadécimal du saut vers l'OEP)
              Saut 00645C6B -> 005BDD58 : 00645C6B - 005BDD58 = 87F13 ; FFFFFFFF- 87F13 + 1 = FFF780ED
              00645C6B = adresse qui suit le jmp 005BDD58 quand tout le code a été écrit dans TOTALCMD.EXE et que
              vous l'avez désassemblé dans ollydbg.

         Voila ce cours est terminé.Il est très long.C'est le plus long que j'ai écrit jusqu'à présent.J'espère que vous avez réussi à suivre les différentes parties de ce cours qui ne sont pas toujours simples à comprendre.

         Dans ce tutorial vous avez appris successivement
         -> supprimer un logo au démarrage
         -> supprimer un nag-screen à 3 boutons au démarrage
         -> supprimer des messages d'évaluation dans la barre de titre de l'interface et dans le menu A propos de
         -> annuler un CRC.

         Mais aussi je vous ai montré comment utiliser la fonction d'assemblage de w32dasm et surtout comment inline patcher  Total Commander. Cette dernière technique vous permet d'insérer un morceau de code dans le programme qui va ensuite modifier certains octets dans la mémoire avant le démarrage de l'application.Elle vous évite aussi la diffusion de tout le programme en entier dans sa version crackée.

Nombre de visites depuis le 26/02/2005