Tutorial n° 4
UltraEdit V.8 (Version Française)

Par Freud

  • Date : 31 Janvier 2001

  • Logiciel : UltraEdit V.8

  • Distributeur : IDM (Ian D. Mead)

  • Protection : AsPack 2.01, Utilisation limitée à 45 jours, NagScreen au lancement du programme

  • Outils : ProcDump, WDasm 8.93, SoftIce 4.01, Hiew

  • Pour me contacter : French_Freud@Hotmail.com

  1. Avant-Propos

    Avec beaucoup de retard, je vous souhaite à tous et tout(es ??) une bonne et heureuse année !! Quelle soit faite pour nous de nombreux défits et nouvelles protections de plus en plus intéressantes à cracker.
    C'est donc après 6 mois d'absence (pour cause de stage en Angleterre) que je reviens pour proposer un nouveau tutorial qui concerne le logiciel UltraEdit V.8 (VF). Un éditeur très puissant que j'utilise régulièrement (et crack à chaque nouvelle version aussi) pour créer et compiler des programmes en Java, C++ ou encore assembleur Win32. Auparavant, je n'avais pas fait de tutorials à propos de ce logiciel, utilisé pourtant par beaucoup de personnes, car son système de protection était, on va dire, assez facile à supprimer; c'est un peu différent avec la version 8.

    Je dédicace ce tut à : Anne-Laure, Mathilde, Mélissa, Aurélie, Sophie, Alison & Gemma (from Portsmouth - ENGLAND).

  2. Au lancement du logiciel...

    Quand on lance UltraEdit V.8, un beau NagScreen surgit nous rappelant que ceci est une copie non enregistrée du programme et que nous pouvons seulement l'utiliser dans un but d'évaluation pour une durée de maximun 45 jours. Celui reste affiché quelques secondes (très ennuyantes), et il disparait ensuite pour nous laisser la main. Pour supprimer ce NagScreen, il faut rentrer son nom et un code d'autorisation pour passer le logiciel en mode enregistré. On peut le faire soit en cliquant sur le bouton se trouvant sur le NagScreen ('Entrez le code d'autorisation') ou alors en allant dans le menu '?' et en choisissant l'item 'Enregistrer UltraEdit-32'.

  3. A la découverte de la protection

    La logique voudrait qu'on commence par désassembler l'éxécutable d'UltraEdit avec Wdasm pour essayer de trouver des String Reference à propos du NagScreen. Si on arrive à faire cela c'est pratiquement gagné...Essayons de commencer par le plus facile...Pas de chance...si on essait d'ouvrir le fichier 'uedit32.exe' avec Wdasm, ce dernier plante lamentablement.
    A ce niveau là on peut déjà s'inquiéter un peu et se dire que notre crack ne va pas être si facile à réaliser car lorsque Wdasm ne désassemble pas un programme c'est en général que ce dernier est crypté et/ou compressé par une protection du type AsPack, AsProtect, etc...
    Quand on arrive à ce point, il est bon de connaître à quelle méthode de protection nous avons affaire afin de mieux la combattre. Il existe pour cela de nombreux logiciels à savoir : PE Sniffer, File Analyser, File Scanner, etc...disponible en téléchargement sur le site de protools.
    Pour ma part j'ai utiliser ProcDump pour voir le nom des sections qui sont parfois révélatrice comme ici par exemple :

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

   Object01: .text    RVA: 00001000 Offset: 00000600 Size: 000CFC84 Flags: C0000040
   Object02: .rdata   RVA: 000D1000 Offset: 000D0400 Size: 000244C4 Flags: C0000040
   Object03: .data    RVA: 000F6000 Offset: 000F4A00 Size: 0000D13C Flags: C0000040
   Object04: .rsrc    RVA: 00112000 Offset: 00101C00 Size: 0003F610 Flags: C0000040
   Object05: .aspack  RVA: 00152000 Offset: 00141400 Size: 00002D90 Flags: C0000040
   Object06: .data    RVA: 00155000 Offset: 00144200 Size: 00000000 Flags: C0000040

    Comme vous pouvez le constater, UltraEdit est protégé par une Ready Made protection : AsPack. Je voudrais signaler que ni PE Sniffer V106, ni File Analyser, ni File Scanner n'a su me donner ce renseignement. Je pense qu'il s'agit donc de la dernière version 2.1
    Voici les informations que j'ai pu glaner sur AsPack (qui a déjà fait l'objet de nombreux tutorials dois je le préciser ?? Cependant je pense qu'il n'est pas inutile d'avoir toujours plus d'informations).

    ASPack - Executable compressor
    ASPack is an advanced Win32 executable file compressor, capable of reducing the file size of 32-bit Windows programs by as much as 70%. ASPack makes Windows 95/98/NT programs and libraries smaller, and hence faster to both load and download; it also protects programs against reverse engineering by non-professional hackers. Programs compressed with ASPack are self-contained and run exactly as before, with no runtime performance penalties.

    Features
    - advanced processing of executable files (exe, dll, ocx)
    - encoding and compression of program code, data, and resources
    - completely transparent, self-contained operation with long filename support
    - fast decompression routines deliver better performance than competing products
    - integrates directly into Windows as a shell extension for ease of use full Windows 95, Windows 98 and Windows NT compatibility

    Benefits
    - significant reduction in executable file sizes, averaging from 40-70% decrease load times across networks, and download times from the internet
    - embedded Windows applications require significantly less storage space
    - protects resources and code against peeking, disassemblers and decompilers
    - no runtime royalties for distributing compressed programs
    - compatibile with executables created by Microsoft Visual C++, Visual Basic, Inprise (Borland) Delphi and C++ Builder, and other Win32 compilers

  4. Réaliser un dump fonctionnel d'un logiciel compressé avec AsPack 2.1

    Qu'est qu'un Dump ? (Eh oui cela peut paraître trivial pour beaucoup d'entre vous cependant je suis sûr qu'il y en a un certain nombre qui reste interloqué. A ce propos, je voudrais attirer l'attention des rédacteurs de tutorials qui parfois restent très vagues sur des termes qui pour eux cela leur paraissent évidents; je pense qu'il est nécessaire d'être le plus précis possible bien qu'il y est des limites et qu'en tant que rédacteur de tutorials je sais que cela demande du temps, du travail et que l'on a tendance à vouloir aller au plus vite en supprimant des explications qui peuvent nous paraitre inutiles). Cette parenthèse étant faite je vais essayé de vous expliquer ce qu'est un Dump.

    Lorsque un programme est compressé par une protection type AsPack par exemple, un loader est intégré a celui-ci. Le loader intervient lors de l'éxécution du programme, il va s'attacher à décompresser le programme en mémoire afin qu'il puisse s'éxécuter comme un programme normal.
    Voilà donc comment s'éxécute un programme compressé :

    1. Lancement du loader (Invisible à l'oeil de l'utilisateur)
    2. Décompression du logiciel en mémoire
    3. Le loader donne la main au programme décompressé.

    Eh bien un Dump d'un logiciel compressé correspond à prendre le contrôle lorsque le loader rend la main au programme décompressé et a sauvegardé celui-ci sur le disque. Ainsi on obtient un fichier exécutable fonctionnel (dans la plupart des cas, il y a des exeptions) que l'on peut désassembler avec WDasm afin de trouver des String Reference, etc...

    Application de tout ça à UltraEdit V.8
    Pour commencer, il faut charger le logiciel avec le Symbol Loader de SoftIce. On s'aperçoit vite que SoftIce ne nous donne pas la main à l'entry_point du programme (= première instruction exécutée). Pour corriger ce problème, il suffit de rendre la première section '.text' Readable, Executable, Writable     grâce à ProcDump (code E0000020 à la place du C0000040, cf plus haut dans ce tutorial ou je montre toutes les sections et leurs caractériques).
    Une fois ce problème corrigé, SoftIce break à l'entry point. Il suffit maintenant de trouver quand est ce que le loader a fini de décompresser le logiciel en mémoire et qu'il est sur le point de lui rendre la main. C'est assez simple à trouver car il y a des signes caractéristiques (POPAD, JMP EAX, PUSH entry_point puis RET, etc...). En traçant un petit peu (F8 sous SoftIce) on arrive facilement à trouver le POPAD dans notre exemple UltraEdit. On le trouve à l'adresse :5523AA.

    REM : Contrairement aux versions précédentes de AsPack, le loader décrypte une partie de son code au début du coup le POPAD n'est pas visible tout de suite, il faut attendre un peu. Ne perdez pas courage le loader est un bout de code très petit et en général on voit arriver le POPAD très rapidement. Si vous arrivez à sentir le code vous verrez tout de suite la routine de décryption et vous ferez le le nécessaire pour la passer et arriver plus vite au POPAD.

    Voici le code qu'on trouve pour UltraEdit :

    :005523AA 61         POPAD
    :005523AB 7508       JNZ 005523B5
    :005523AD B801000000 MOV EAX,00000001
    :005523B2 C20C00     RET 000C
    :005523B5 68A8334900 PUSH 004933A8 > Entry_Point
    :005523BA C3         RET
    Comme vous pouvez le constater le programme pousse la valeur de la prremière instruction à exécuter du programme décompresser sur la pile et grâce au RET on commence l'éxécution en :004933A8

    A ce moment, sous SoftIce vous faites : a (Assemble) 005523BA et JMP EIP. Ainsi le programme tournera en rond à l'adresse :005523BA.
    Lancer ensuite ProcDump et faites un click droit sur la task uedit32.exe puis Dump full. Editer l'entry_point du dump avec ProcDump remplacer la valeur existante par     004933A8-00400000 (Image Base)=000933A8. Et voilà vous avez un dump fonctionnel du logiciel UltraEdit. N'oubliez pas de killer l'application qui tourne en rond en mémoire. Comme vous pouvez le constater le logiciel dumpé occupe environ 1,300 KB au lieu des 500 KB compressé. Un rapide calcul nous montre que le programme a perdu 62% de son poid grâce à AsPack.

  5. Cracker le logiciel devient alors un jeu d'enfant

    Ouvrez dès à présent le logiciel dumpé avec WDasm et oh miracle Wdasm désassemble ce programme sans aucun problème vous donnant par la même occasion accès a toute les String Reference dont nous avons besoin.

    Rechercher par exemple cette String Reference :
    String Resource ID=00008: "Ceci est une copie non enregistée de UltraEdit-32. Si vous c"

    Vous pouvez voir qu'il en existe un sacré paquet dans le fichier désassemblé. Avec un peu de bon sens on peut trouver le bon endroit à patcher pour supprimer le NagScreen. On sait que le logiciel est limité à 45 jours d'utilisation donc on peut se douter qu'il va y avoir dans le programme quelques chose du style CMP xxx,0000002D (2D (hex)= 45 (deci)). Faisons une recherche sur 0000002D...Bingo !! On trouve une seule référence CMP EAX,0000002D avec en dessous des String Reference du style 'String Resource ID=00068: "La période d'évaluation d'UltraEdit de 45 jours a expiré!!!"'.

    Voici ce que l'on trouve dans WDasm :

    :0047843E E8D7A80100              call 00492D1A
:00478443 83F82D                  cmp eax, 0000002D
:00478446 59                      pop ecx
:00478447 7F0C                    jg 00478455 > Si EAX > 45 (2D) alors fin d'évaluation
:00478449 399E48010000            cmp dword ptr [esi+00000148], ebx
:0047844F 0F8576FFFFFF            jne 004783CB  > Saute toujours sinon affiche fin d'évaluation
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00478447(C)
|
:00478455 E8CDFBF8FF              call 00408027
:0047845A 391DB0735000            cmp dword ptr [005073B0], ebx
:00478460 758A                    jne 004783EC
:00478462 A12CED4F00              mov eax, dword ptr [004FED2C]
:00478467 894510                  mov dword ptr [ebp+10], eax
:0047846A 894514                  mov dword ptr [ebp+14], eax

* Possible Reference to String Resource ID=00068: "La période d'évaluation d'UltraEdit de 45 jours a expiré!!!"
                                  |
:0047846D 6A44                    push 00000044
:0047846F 8D4D10                  lea ecx, dword ptr [ebp+10]
:00478472 C645FC02                mov [ebp-04], 02
:00478476 E871FA0200              call 004A7EEC

* Possible Reference to String Resource ID=00069: "Pour continuer à utiliser UltraEdit vous devez envoyer votre"
                                  |
:0047847B 6A45                    push 00000045
.
.
.
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0047844F(C)
|
:004783CB 391DB0735000            cmp dword ptr [005073B0], ebx
:004783D1 7519                    jne 004783EC > Affiche le NagScreen

    Analyse :
    Le programme a chaque utilisation vérifie si la période d'évaluation est expirée ou pas si oui il affiche que le logiciel n'est plus utilisable et se ferme. Dans le cas contraire, il affiche le NagScreen avec le nombre de jours restant. C'est la que nous intervenons !! Nous allons remplacer l'instruction jg 00478455 par un jmp 004783EC. Ainsi, on saute la vérification de la date et l'affichage du NagScreen.
    Si on remplace donc le jg 00478455 par jmp 004783EC dans le programme dumpé avec un éditeur hexa style Hiew, tout se passe très bien !! UltraEdit est cracké !!

    REM :     En fait pour être un tout petit peu plus précis, le logiciel commence par regarder au lancement si vous avez rentré un code d'enregistrement dans le fichier uedit32.reg (Ce fichier qu'après avoir rentré un code d'enregistrement). Si il existe il regarde si le code est bon et lance le programme normalement, sinon c'est à ce moment qu'il vérifie que le nombre de jours restant (dans une clé registre) est inférieur à 45 et affiche le NagScreen.

    Vous allez me dire c'est bien de savoir comment cracker le logiciel dumpé; c'est pas dure les octets à modifier son directement accessible dans le fichier sur le disque ce qui est loin d'être le cas dans le fichier qui se décompresse.

  6. Comment faire pour que le fichier compresé s'auto-patch au démarrage


    Patcher un logiciel compressé avec AsPack a déjà été expliqué dans beaucoup d'autres tuts (je l'avais moi-même décrit pour le logiciel AddWeb 3.15). Cependant, pour cette version d'AsPack cela diffère un peu du fait qu'il décrypte une partie de son code au lancement...cela complique un peu les choses.

    Le principe :
    Une fois qu'AsPack a fini de se décrypter, modifier le code vers le POPAD pour prendre le contrôle à ce moment et ainsi patcher le logiciel qui je le rappelle est complètement décompressé en mémoire et est prêt à être exécuté.
    Le but ici est je le redit de remplacer l'instruction jg 00478455 par jmp 004783EC.

    Il faut donc trouver pour commencer l'endroit du programme où la décryption a lieu (cet endroit est présent physiquement sur le disque évidement et permettra qu'il soit modifier par un éditeur héxa).
    En posant un BPM (Break Point On Memory Access) en :5523AA c'est à dire la ou le POPAD va être décrypté, on trouve facilement la routine de décryptage.
    Elle se termine à l'adresse :552553. L'instruction codé à cet endroit est un jmp 553887 ca tombe bien. on modifie ce jump vers notre_routine1 c'est à dire un jmp 5538B1.
    En effet, à partir de 5538B1 on a une suite 00 qui vont nous servir à insérer notre patch puisque ces octets ne servent à rien. Auparavant je m'en suis assuer en posant un BPM.
    A ce moment, il faut modifier l'instruction situer juste après le POPAD par un jmp notre_routine2, ce sont les intructions de notre_routine1 qui vont s'en charger.
    Ensuite, dans notre_routine2 il ne faudra pas oublier de rajouter les instructions effacées (push...) et d'insérer notre patch pour modifier l'instruction jg 00478455 par jmp 004783EC.
    Mes explications sont des plus succinctes mais vous pourrez trouver des informations complémentaires dans beaucoup d'autres tuts sur les logiciels compressés.
    En attendant voici le code source commenté de mon patch cela vous fera certainement mieux comprendre que des explications longues et ennuyeuses :

    :552553 JMP 553887 > On prend la main a la fin de la décryption, jmp notre_routine1

    Notre_Routine1 > On place un jmp notre_routine2, après le POPAD
    :553887
    mov dword ptr [5523AB], 001501E9 > Correspond au jmp notre_routine2 en assembleur
    mov word ptr [5523AF], 9000
    mov byte ptr [5523B0], 90
    JMP 55243B > retour prog. normal apres décryption

    Notre_Routine2 > le patch pour le crack
    :5538B1
    mov word ptr [478447], EBA3
    mov byte ptr [407CFA], 75
    push 004933A8 > comme si on était en fin de décompression
    ret > le prog. décompressé prend la main

  7. Conclusion

    Héhé mais mais mais tu dors ???!!! :) Réveille toi bordel !! Bon j'espère que j'ai été assez clair dans mes explications et si vous avez appris quelques trucs ben c'est super car les tutorials sont fait pour ça : le partage des connaissances.

    Merci à Christal.

    Au passage, si vous trouvez des absurdités,des erreurs dans ce tut (ce qui est loin d'être impossible) ou que vous avez une remarque a faire, n'hésitez surtout pas à prendre contact avec moi (French_Freud@Hotmail.com).

    Don't give up the fight

    Freud

    "Plus vous roulez sur un chat mort, plus il est plat."