Ce cours est un reflet fidèle du cours intégré au crack de ma création de CloneCD 5.2.0.0 fr

ProcDump32 1.6.2
Pour éditer et modifier les sections d'un exécutable.

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

Stripper v2.11 rc2
Pour retirer les protection Aspack et ASprotect et obtenir un exécutable désassemblable.
Cela permet dans w32dasm d'avoir un listing de désassemblage et de voir les string data référence.

          Détail des modifications CCDDriver.dll

        CloneCD.exe

        Aujourd'hui on s'attaque à un logiciel très connu dans le monde de copie de CD.

        Comme d'habitude lorsque l'on commence le craquage d'un programme on commence par le désassembler et ensuite le débugguer 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 CloneCD.exe dans le désassembleur w32dasm par la commande Disassembler -> Open File to disassemble -> CloneCD.exe. Seulement voila le désassembleur w32dasm se ferme.Impossible pour nous de désassembler le programme.

         Premier réflexe face à ce type de situation (qui arrive systématiquement chez les logiciels distribués par slysoft) 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. Ce type de protection est aussi bien adapté aux versions de type shareware puisque un packer gère en général la durée maximum d'utilisation du logiciel (time-limit).

         Voici la méthode que nous allons suivre.On va chercher la signature du packer utilisé puis on va unpacker le programme CloneCD.exe pour ensuite pouvoir le désassembler. Nous aurons alors une liste de string data références dans le menu Ref -> String Data References de w32dasm.

           1/Analyse

              a/ Trouver le packer utilisé

          Pour cela 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 CloneCD.exe. Eh là vous voyez apparaître en bas de la fenêtre de PEiD le nom du packer utilisé suivi du nom de son créateur "ASProtect 1.2x - 1.3x [Registered] -> Alexey Solodovnikov". Tout de suite on voit qu'il ont changé le packer qu'ils utilisaient auparavant pour protéger leur programme chez slysoft. Dans les versions précédentes de CloneCD (par exemple la 5.1.0.0) le packer utilisé était en effet une autre version d'ASProtect : "ASProtect 1.23 RC4 - 1.3.08.24 -> Alexey Solodovnikov".

              b/ Présentation du packer Asprotect 1.2x -1.3x

          Asprotect est une version améliorée d'un packer existant (du même auteur) s'appelant Aspack. Il est écrit en delphi et s'adapte à n'importe quel type d'exécutable. Il protége le logiciel d'origine sur plusieurs niveaux :

                -> Il compresse et encrypte le programme original.
                -> Il détecte et empêche tout débogage avec softice (message "Debugger detected ...").
                -> Il renomme en effaçant leur nom les sections du programme d'origine (c'est le cas pour CloneCD.exe)
                -> Il détruit et redirige la table des imports des fonctions API (IAT) vers lui-même (problème en cas de dump).
                -> Il inscrit la limite de temps dans le registre dans la clé HKEY_CURRENT_USER\Software\ASProtect\.

                Quelques précisions supplémentaires

                -> IAT signifie Import Address Table : c'est une table qui contient les adresses des références aux fonctions utilisées par le programme. Ces fonctions sont encodées dans des fichiers dll par exemple la fonction MessageBoxA de la dll user32.dll.
                -> Un dump d'exécutable (en français vidage d'exécutable) est la fait de copier sur le disque dur un programme qui est en cours d'exécution dans la mémoire centrale. On fait un dump d'exe avec ProcDump en cliquant droit dans la liste des programmes affichés par ProcDump qui tournent en mémoire sur le programme qui nous intéresse et en choisissant l'option Dump Full. Le dump permet d'avoir l'exécutable décompressé. Le packer après avoir décompressé tout le programme en mémoire n'existe plus et laisse la main au programme. A savoir : tout programme tournant en mémoire centrale est décompressé.

                -> Pour une présentation plus poussée du packer dans sa version précédente (version 1.23) allez à cette adresse :
                     http://elooo.fff.free.fr/consult/Unpacking_aspr1.23_elooo/

              c/ Unpacking

          L'unpacking c'est l'art de décompresser un programme qui a été au préalable packé par un soft. Dans notre cas on va chercher à unpacker CloneCD.exe qui a été packé avec Asprotect 1.2x -1.3x. Deux approches sont possibles pour réaliser cet exercice :

                -> le manual unpacking avec le debugger ollydbg : on fait l'unpacking à la main.
                -> l'unpacking avec un unpacker : on laisse l'unpacking à un logiciel.

          En cherchant sur le net vous trouverez un unpacker pour Asprotect. C'est Stripper v2.11 rc2 crée par syd. Il est téléchargeable sur son site à l'adresse http://syd.nightmail.ru

          Si vous voulez vous initier et développer vos connaissances en unpacking je vous conseille le site de la FFF (team française très connue dans le monde du cracking) : http://unpacking.free.fr

              d/ Unpacker CloneCD

          On utilise Stripper. Rien de compliqué. Tout est automatique. Veillez à mettre Engine.sys dans le même répertoire que Stripper avant de commencer. Ensuite vous cliquez sur le bouton Open de Stripper et choisissez CloneCD.exe et vous cliquez sur Unpack. Là une erreur fatale "unpacked file was not created.." apparaît avant la fin de la procédure d'unpacking. Impossible d'unpacker CloneCD.exe (avec Stripper) !

          On change de technique. On lance CloneCD.exe. Ensuite une fois le premier écran de CloneCD.exe apparu on lance procdump 1.6.2. On clique droit sur le processus C:\Program Files\SlySoft\CloneCD 5.2.0.0\clonecd.exe en haut dans la fenêtre de procdump 1.6.2 et on fait Dump Full (adpatez le chemin d'accès à votre répertoire d'installation de CloneCD). Vous enregistrez ensuite le dump dans un fichier par exemple C:\Program Files\SlySoft\CloneCD 5.2.0.0\CloneCD_dumped.exe. Voila vous avez réalisé un dump de CloneCD.exe.Cependant il ne fonctionnera pas si vous le lancer car il faut régler plusieurs pb au prélable (remplacer l'entry point par l'original entry point, reconstruire l'IAT). Cela dépasse le cadre du cours.Nous n'aurons pas besoin d'un dump valide pour le désassemblage.Le dump obtenu suffira. Au passage on note que l'exécutable a grossi ; il est passé de 603 Ko à 1523 Ko. Cliquez sur Exit pour quitter procdump 1.6.2.

              e/ Craquage de la version unpackée de CloneCD

          On va travailler maintenant uniquement sur la version dumpée de CloneCD à savoir CloneCD_dumped.exe. On l'ouvre dans le désassembleur w32dasm par la commande ommande Disassembler -> Open File to disassemble -> CloneCD_dumped.exe. Là on voit que le programme se désassemble avec de vraies string data référence en cliquant sur le bouton Strn Ref. Enfin elles sont presques complètes.Vous comprendrez par la suite ce que je veux dire.

          Ce que nous allons maintenant faire c'est enregistrer le programme.En effet vous voyez un fois lancé CloneCD 2 fois la chaîne "NON ENREGISTRE" dans le menu Aide -> Informations et dans le menu Outils -> Registre.Ca veut dire que le logiciel est enregistrable au moyen d'une clé.Pour cela on cherche dans les string data references (clic sur le bouton Strn Ref de w32dasm une fois le désassemblage de CloneCD_dumped.exe effectué) quelque chose qui nous parle de key (clé en français).On ne voit rien.Bizarre puisque le logiciel est enregistrable ! Ouvrons donc CloneCD_dumped.exe dans winhex pour vérifier s'il n'y a effectivement rien qui nous parle de clé en cherchant par CTRL F l'expression "\key".Eh bien non. Nous avons après avoir fait F3 sur la première occurrence trouvée, l'expression "Software\SlySoft\CloneCD\Key". Si vous sélectionnez le S de Softtware vous voyez l'offset dans la barre de statut de winhex qui vaut 10D71A.

          Ce qu'on va faire maintenant c'est convertir cet offset en adresse et faire une recherche de cette adresse dans CloneCD_dumped.exe désassemblé dans w32dasm.C'est pour savoir où CloneCD_dumped.exe fait appel à cette chaîne.Pour faire cette conversion il faut regarder les sections de CloneCD_dumped.exe.Pour cela retour dans w32dasm au listing de désassemblage de CloneCD_dumped.exe.Vous voyez les 10 sections sont représentées par les Object01, Object02 , Object03 ... :

          Disassembly of File: C:\Program Files\SlySoft\CloneCD 5.2.0.0\CloneCD_dumped.exe
          Code Offset = 00000A00, Code Size = 0010963C
          Data Offset = 0015D400, Data Size = 0001F600

          Number of Objects = 0010 (dec), Imagebase = 00400000h

             Object01:             RVA: 00001000 Offset: 00000A00 Size: 0010963C Flags: E0000040
             Object02:             RVA: 0010B000 Offset: 0010A200 Size: 00034698 Flags: E0000040
             Object03:             RVA: 00140000 Offset: 0013EA00 Size: 00000000 Flags: E0000040
             Object04:             RVA: 00141000 Offset: 0013EA00 Size: 00000010 Flags: E0000040
             Object05:             RVA: 00142000 Offset: 0013EC00 Size: 000035D8 Flags: E0000040
             Object06:             RVA: 00146000 Offset: 00142200 Size: 00008490 Flags: E0000040
             Object07: .rsrc     RVA: 0014F000 Offset: 0014A800 Size: 00012BA8 Flags: E0000040
             Object08:             RVA: 00163000 Offset: 0015D400 Size: 00000000 Flags: E0000040
             Object09: .data     RVA: 00177000 Offset: 0015D400 Size: 0001F600 Flags: E0000040
             Object10: .adata   RVA: 00197000 Offset: 0017CA00 Size: 00000000 Flags: E0000040

          0010A200 < 10D71A < 0013EA00 => l'offset 10D71A appartient à la section repérée par Object02
          Pour calculer l'adresse correspondant à l'offset 10D71A on utilise la formule suivante :
          adresse recherchée =  offset trouvé - offset début de section + RVA + Imagebase

          Prenons la calculatrice de windows dans Démarrer -> exécuter -> calc.exe en mode hexadécimal (bouton hex)
          On trouve 10D71A - 0010A200 + 0010B000 + 400000 = 50E51A

          Conclusion : l'adresse dans CloneCD_dumped.exe correspondant à l'offset 10D71A est 0050E51A

          Ensuite qu'est ce qu'on fait ? On cherche avec la commande de w32dasm suivante Search -> Find Text -> 0050E51A l'adresse 0050E51A dans le code désassemblé de CloneCD_dumped.exe.On arrive ici

          :0041610B 681AE55000              push 0050E51A

          Remontons dans le code pour voir comment est ce qu'on arrive ici.

* Referenced by a (U)nconditional or (C)onditional Jump at Address: |:0041609A(C)
:004160A8	E807FEFFFF	call 00415EB4
:004160AD	85C0	test eax, eax
:004160AF	745A	je 0041610B
:004160B1	C605B4CD520002	mov byte ptr [0052CDB4], 02
:004160B8	68A0000000	push 000000A0
:004160BD	A1A0CC5200	mov eax, dword ptr [0052CCA0]
:004160C2	50	push eax
:004160C3	680ECD5200	push 0052CD0E
:004160C8	E8433B0E00	call 004F9C10
:004160CD	83C40C	add esp, 0000000C
:004160D0	C705B8CD520001000000	mov dword ptr [0052CDB8], 00000001
:004160DA	A1E0CC5200	mov eax, dword ptr [0052CCE0]
:004160DF	85C0	test eax, eax
:004160E1	7424	je 00416107
:004160E3	6815E55000	push 0050E515
:004160E8	50	push eax
:004160E9	E8DA3A0E00	call 004F9BC8
:004160EE	83C408	add esp, 00000008
:004160F1	85C0	test eax, eax
:004160F3	7512	jne 00416107
:004160F5	680ECD5200	push 0052CD0E
:004160FA	680ECD5200	push 0052CD0E
:004160FF	E88CFEFFFF	call 00415F90
:00416104	83C408	add esp, 00000008
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses: |:004160E1(C), :004160F3(C)
:00416107	33C0	xor eax, eax
:00416109	5B	pop ebx
:0041610A	C3	ret
* Referenced by a (U)nconditional or (C)onditional Jump at Address: |:004160AF(C)
:0041610B	681AE55000	push 0050E51A
:00416110	6802000080	push 80000002
:00416115	E83629FFFF	call 00408A50
:0041611A	83C408	add esp, 00000008
:0041611D	33D2	xor edx, edx
:0041611F	C705ECE4500015000000	mov dword ptr [0050E4EC], 00000015
:00416129	8915F0E45000	mov dword ptr [0050E4F0], edx
:0041612F	EB13	jmp 00416144
* Referenced by a (U)nconditional or (C)onditional Jump at Address: |:00416088(C)
:00416131	8B0DF0E45000	mov ecx, dword ptr [0050E4F0]
:00416137	85C9	test ecx, ecx
:00416139	0F94C0	sete al
:0041613C	83E001	and eax, 00000001
:0041613F	A3C0B05000	mov dword ptr [0050B0C0], eax
* Referenced by a (U)nconditional or (C)onditional Jump at Address: |:0041612F(U)
:00416144	B801000000	mov eax, 00000001
:00416149	5B	pop ebx
:0041614A	C3	ret

 

          On arrive en 0041610B par l'adresse 004160AF.Tout de suite on remarque 2 lignes de code qui laisse présager d'un enregistrement (on met des bytes dans des contenus d'adresses).

          :004160B1   C605B4CD520002                mov byte ptr [0052CDB4], 02
          :004160D0   C705B8CD520001000000    mov dword ptr [0052CDB8], 00000001

          On réfléchit et comme on ne peux pas débugguer CloneCD_dumped.exe pour les raisons exposées plus haut, on va faire le test suivant.On va positionner dans les adresses adéquates (0052CDB4 et 0052CDB8) les valeurs 02 et 00000001 directement en mémoire au démarrage de l'application CloneCD.exe (attention je ne parle plus de CloneCD_dumped.exe).

          Comment faire cela ? On recherche la section de code de CloneCD.exe qui exécute la première instruction du programme ie qui contient l'entry point (= point d'entrée en français).On lance pour cela procdump 1.6.2 et on clique sur le bouton PE Editor et on charge CloneCD.exe.Vous voyez l'entry point qui vaut 00001000. En cliquant sur le bouton Sections vous voyez dans la colonne Virtual offset que 00001000 est le début de la première section.Le premier offset de cette section est 00000600 (colonne Raw Offset) et le dernier situé avant le Raw Offset du début de la section suivante vaut 00060A00 - 1 = 609FF.Allez dans winhex et ouvrez CloneCD.exe puis faîtes ALT G -> 609FF et mettez cet offset à 01 et enregistrez la modification pour voir si au lancement le packer qui enveloppe CloneCD.exe détecte la modification de cette section.

          Pas de chance oui ! Vous avez un message apparaissant "File corrupted! CloneCD will not run, if it has been modified. Please check, if your computer is infected by a Virus.".C'est pas grave. Annulez la modification sur l'offset 609FF en remettant la valeur initiale et en enregistrant.

          On change de technique. Renommez CCDDriver.dll en CCDDriver2.dll et relancez CloneCD.exe.Un message d'erreur vous dit que le programme ne trouve pas CCDDriver.dll.On en déduit que CCDDriver.dll est nécessaire au lancement de CloneCD. Parfait ! On va positionner nos 2 suites d'octets 02 et 00000001 dans CCDDriver.dll qui par ailleurs n'est pas protégé par le packer de CloneCD.exe.

              2/ Inline patching de CCDDriver.dll

              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 positionner des bytes dans la mémoire au démarrage de l'application pour enregistrer le programme.

              Pourquoi est ce qu'on peut l'utliser ici ?
              Car notre exécutable Clonecd.exe est packé avec un packer (ici le packer Asprotect 1.2x -1.3x) et que certaines
              fonctions de CCDDriver.dll sont nécessaires au démarrage de l'application.

              b/ Redirection de l'entry point de CCDDriver.dll

              Pas compliqué. Ouvrez CCDDriver.dll dans procdump 1.6.2 (clic sur le bouton PE Editor de procdump 1.6.2). Vous voyez apparaître l'entry point = 00002016. Ce que l'on va faire c'est dérouter l'entry point de CCDDriver.dll vers notre zone de code où on va insérer notre patch. Dans CCDDriver.dll ouvert dans winhex j'ai choisi l'offset C3A0 (ALT G -> C3A0) comme étant le premier offset à recevoir mon patch. Je l'ai choisi car il est situé dans un endroit rempli de zéros successifs (ces endroits sont systématiquement inutilisés par le programme car ils sont rajoutés par le compilateur au moment de la compilation). Comme tout à l'heure si vous désassemblez CCDDriver.dll vous voyez les sections apparaître avec leur nom (la première s'appelle .text).

              Disassembly of File: C:\Program Files\SlySoft\CloneCD 5.2.0.0\CCDDriver.dll
              Code Offset = 00001000, Code Size = 00008000
              Data Offset = 0000B000, Data Size = 00001000

              Number of Objects = 0005 (dec), Imagebase = 10000000h

                 Object01: .text     RVA: 00001000 Offset: 00001000 Size: 00008000 Flags: 60000020
                 Object02: .rdata   RVA: 00009000 Offset: 00009000 Size: 00002000 Flags: 40000040
                 Object03: .data    RVA: 0000B000 Offset: 0000B000 Size: 00001000 Flags: C0000040
                 Object04: .rsrc     RVA: 0000E000 Offset: 0000C000 Size: 00001000 Flags: 40000040
                 Object05: .reloc   RVA: 0000F000 Offset: 0000D000 Size: 00001000 Flags: 42000040

              Même raisonnement que tout à l'heure C3A0 appartient à la section nommée .rsrc. L'adresse correspondant à l'offset C3A0 est 0000E3A0 = C3A0 - 0000C000 +  0000E000.On commence par rediriger l'entry point. Tapez 0000E3A0 dans la case entry point de CCDDriver.dll ouvert dans procdump 1.6.2  et enregistrez la modification en cliquant sur le bouton OK (fermez au préalable winhex si vous avez ouvert CCDDriver.dll dedans).

              c/ Mise en œuvre de l'inline patching

              Ensuite fermez procdump 1.6.2 et réouvrez CCDDriver.dll dans winhex.Faîtes ALT G -> C3A0 et recopiez le code suivant en rouge.

              C3A0   C6 05 B4 CD 52 00 02                   mov byte ptr [0052CDB4], 02
              C3A7   C7 05 B8 CD 52 00 01 00 00 00    mov dword ptr [0052CDB8], 00000001
              C3B1   E9 60 3C FF FF                              jmp 10002016
              C3B6   ...

              Vous avez remarqué que notre zone de code après avoir positionné des octets en mémoire est redirigée par un saut vers le vrai entry point 00002016 avec un  jmp 10002016. Comment ai-je calculé le code hexadécimal 60 3C FF FF ? Le début de l'instruction qui suit le jmp 10002016 est à l'offset C3B6. Le vrai entry point qui est une adresse 00002016 est situé dans la section .text de CCDDriver.dll car 00001000 < 00002016 < 00009000 (regardez les RVA plus haut).

              0000E3B6  = C3B6 - 0000C000 + 0000E000 = RVA correspondant à l'offset C3B6 (regardez la section .rsrc)
              C3A0 = 0000E3B6 - 00002016 = RVA du début du saut - RVA de la fin du saut = longueur du saut.

              Comme on saute de l'adresse 0000E3B6 (correspondant à l'offset C3B6) vers une adresse plus petite 00002016 sur une longueur C3A0 octets, le saut doit donc être négatif. Pour le rendre négatif on fait le calcul suivant

              FFFF3C60 = FFFFFFFF - 0000C3A0 + 1 <=> FFFF3C60 = - 0000C3A0 car FFFFFFFF + 1 = 00000000

              Enfin en inversant tous les bytes de FF FF 3C 60 on trouve 60 3C FF FF.

              On enregistre les modifications de CCDDriver.dll dans winhex et on lance Clonecd.exe. Le programme est maintenant enregistré. C'étaient bien ces 2 adresses (0052CDB4 et 0052CDB8) qui étaient impliquées dans l'enregistrement.

         Dans ce cours vous avez appris à craquer un logiciel protégé par le packer Asprotect 1.2x -1.3x.Ce cours a été également l'occasion de découvrir des logiciels comme PEiD, ProcDump et Stripper.

         La réelle difficulté pour craquer CloneCD est de trouver l'endroit où le programme fait sa vérification du statut enregistré.On le trouve en faisant une recherche hexadécimale dans CloneCD de la chaîne "\key" puis par un calcul d'adresse assez complexe on parvient à retrouver l'endroit où cette chaîne est appelée dans un CloneCD qu'on a au prélable unpacké avec ProcDump.

         Enfin ce cours dans sa deuxième partie vous montre comment inline patcher CloneCD en inline patchant CCDDriver.dll qui est invoquée au démarrage de CloneCD. Je vous ai pour cela décrit les calculs d'adressage à faire pour dérouter l'entry point de CCDDriver.dll vers notre zone de code où l'on a écrit nos instructions asm sous forme hexadécimale.

Bonne nuit à tous.
Et à bientôt pour de nouveaux cours.
Pifoman

 

Nombre de visites depuis le 19/04/2005