Craquer Readiris Pro 10.04 fr par Pifoman

Ce cours est un reflet fidèle du cours intégré au crack de ma création de Readiris Pro 10.04 fr.

Détail des modifications readiris.exe

Octet	Adresse	Offset	Original	Cracké	Effet
1	0048E2E0	8E2E0	E8	90	Suppression du nag screen.
2	0048E2E1	8E2E1	3B	90	Suppression du nag screen.
3	0048E2E2	8E2E2	92	90	Suppression du nag screen.
4	0048E2E3	8E2E3	FA	90	Suppression du nag screen.
5	0048E2E4	8E2E4	FF	90	Suppression du nag screen.
6	0045E5AD	5E5AD	29	00	Retrait du time limit.
7	0048E37E	8E37E	AE	EE	Retrait du logo.
8	0048E37F	8E37F	F1	E2	Retrait du logo.
9	0048D358	8D358	E8	90	Retrait du menu Register
10	0048D359	8D359	93	90	Retrait du menu Register
11	0048D35A	8D35A	33	90	Retrait du menu Register
12	0048D35B	8D35B	07	90	Retrait du menu Register
13	0048D35C	8D35C	00	90	Retrait du menu Register
14	007CDC00	3BDC00	00	45	Enregistré à Pifoman
...	007CDC...	3BDC...	00	...	Enregistré à Pifoman
33	007CDC13	3BDC13	00	6E	Enregistré à Pifoman
34	00401C46	1C46	8D	90	Chargement de Enregistré à Pifoman
35	00401C47	1C47	85	B8	Chargement de Enregistré à Pifoman
36	00401C48	1C48	00	00	Chargement de Enregistré à Pifoman
37	00401C49	1C49	FF	DC	Chargement de Enregistré à Pifoman
38	00401C4A	1C4A	FF	7C	Chargement de Enregistré à Pifoman
39	00401C4B	1C4B	FF	00	Chargement de Enregistré à Pifoman
40	00401C56	1C56	8D	90	Chargement de Enregistré à Pifoman
41	00401C57	1C57	8D	B8	Chargement de Enregistré à Pifoman
42	00401C58	1C58	00	00	Chargement de Enregistré à Pifoman
43	00401C59	1C59	FF	DC	Chargement de Enregistré à Pifoman
44	00401C5A	1C5A	FF	7C	Chargement de Enregistré à Pifoman
45	00401C5B	1C5B	FF	00	Chargement de Enregistré à Pifoman

Le logiciel comporte une limitation au niveau du temps d'utilisation qui est fixée à 30 jours. Si vous avancez d'un an la date du système en utilisant l'horloge en bas à droite de votre écran le logiciel ne se lancera plus.Normal vous me direz le logiciel est limité à 30 jours d'utilisation ! On se dit alors qu'en le ramenant à la date d'aujourd'hui le programme va à nouveau se lancer (c'est le cas par exemple pour certains logiciels comme paint shop pro). Le problème c'est que le logiciel est définitivement verrouillé (en apparence du moins parceque nous on va passer par là :)).

On réfléchit. Si le logiciel sait que la date d'utilisation a expiré c'est que cette information il l'a enregistrée au préalable quelque part. Ce quelque part dans une grosse majorité des cas c'est le registre (la registry pour les anglophones). Pour ceux qui ne connaissent pas le registre c'est la table de paramétrages des systèmes windows et des applications qui y sont installées.On y accède via l'utilitaire regedit.exe à partir de démarrer -> exécuter -> regedit.exe.

Une question se pose alors. Comment retouver cette information dans le registre ? Information qui est examinée par readiris.exe pour savoir s'il doit se lancer ou se fermer (passé les 30 jours d'utilisation il se ferme). Pour cela il suffit d'utiliser un petit utilitaire gratuit qui s'appelle Regmon.exe (Regmon = Registry monitoring -> en français surveillance du registre). Il est disponible an anglais sur http://www.sysinternals.com . Il est très petit (seulement 188 ko pour la version 6.06).

Comment allons nous l'utiliser ? En fait c'est assez simple. Vous le lancez et comme on veut surveiller l'activité du processus readiris.exe avec le registre vous tapez dans la case include readiris.exe.Vous avancez la date du système de 1 an (après avoir ouvert readiris.exe une première fois pour initialiser le repère de temps) et vous lancez ensuite readiris.exe. Là le logiciel readiris.exe cherche à se fermer : laissez le faire. Ensuite revenez à Regmon.exe.Vous avez alors à l'écran une colonne process avec explorer.exe et readiris.exe. Sur les lignes où apparaissent readiris.exe vous en avez plusieurs qui font référence à la clé

Sur cette même ligne vous avez les paramètres result = success et other = un nombre (chez moi 3411805061). Ca c'est très intéressant.Quand un programme interroge la clé HKCR\CLSID (HKCR pour HKEY_CLASSES_ROOT et CLSID pour Class Identifier) vous pouvez être sûr que dans beaucoup de cas l'identifiant de classe qui succède le CLSID (ici {e941a7a2-3c1f-4db7-9955-b4fb3f8f9517}) est impliqué dans la protection temporelle. C'est le cas ici.

De plus le nombre dans la colonne other ça ressemble à un timestamp c'est à dire un nombre qui après calcul donne une date (date d'expiration sûrement). Allons dans le registre et effaçons cette clé de nom rua01y et relançons readiris.exe .Eh là bien que nous ayons fait un saut dans le temps de 1 an le logiciel se lance comme si c'était la première utilisation ! Bon voila la protection est découverte. On pourrait s'arrêter là mais nous ce qu'on veut c'est que le logiciel à chaque lancement croit que c'est la première utilisation.On va donc le craquer (en supprimant aussi d'autres limitations).

On désassemble readiris.exe dans w32dasm par la commande Disassembler -> Open File to Disassemble -> readiris.exe. On inspecte ensuite les string data référence dans w32dasm comme d'habitude. On clique pour cela sur le bouton dans la barre de boutons nommé Strn Ref et ensuite on clique sur le bouton Copy All dans la fenêtre qui apparaît.On colle le tout avec CTRL V dans l'éditeur de texte wordpad.exe (accessible par démarrer -> exécuter -> wordpad). On cherche une chaîne que nous parle de register (par exemple regist). L'avantage de cherche regist c'est que vous trouvez à la fois registered et enregistré (si les messages sont en français).

On cherche mais on ne trouve rien d'intéressant. On va donc utiliser une de mes techniques préférées celle du point d'arrêt (et pas celle du point d'arrête comme j'ai souvent l'habitude d'écrire en tapant trop vite au clavier) sur la fonction MessageBox de l'API user32.dll (c'est cette fonction qui appelle les nags screen en général).

On y va. On charge readiris.exe en mémoire depuis w32dasm par CTRL L (L pour load en anglais).Ensuite on se met au début de la zone de code de readiris.exe par CTRL S et on met un point d'arrêt sur chaque ligne ou apparaît MessageBox. Pour mettre le point d'arrêt vous faîtes search -> find text -> MessageBox ,vous sélectionnez la ligne de code qui succède le MessageBox et vous faîtes F2. Le premier bp (breakpoint ou encore point d'arrêt) par exemple est mis sur la ligne de code d'adresse 00437599.

* Reference To: USER32.MessageBoxA, Ord:01BEh

`:00437599`	`FF1508EB6500`	`Call dword ptr [0065EB08]`

Un carré jaune apparaît alors à gauche du bp posé.Vous faîtes F3 pour passer à l'occurence suivante et vous alternez ainsi les F2 et les F3.Vous avez à poser au total 8 bp (sur les adresses suivantes 00437599, 0048B463, 0049B1DA, 0049B551, 0049B569, 004E0B7A, 00505D0E, 00520269). Cette liste de bp apparaît dans la grande fenêtre du debuggeur à droite où c'est marqué Bpts (Bpts = breakpoints).

Une fois tous ces bp posés on lance le programme avec F9. Attention je me place dans la configuration du programme où il est encore évaluable (regardez l'avant-propos plus haut qui dit comment revenir au premier jour d'utilisation si vous avez avancé la pendule de plus d'un mois). w32dasm break alors sur la ligne de code d'adresse 00437599 (voir au dessus)

Si vous cliquez sur le bouton OK dans la boîte de dialogue "Cette version fonctionnera seulement pendant 30 jours" de readiris.exe et que vous faîtes F9 le programme est lancé. Il n'y a donc qu'un seul appel à la fonction MessageBox sur les 8 potentiels dans le listing de désassemblage qui est impliqué dans le nag à l'ouverture de programme (c'est normal vous me direz puisqu'il n'y a qu'un seul nag-screen à apparaître).Terminons la session de debugging par CTRL T (T pour terminate) et regardons comment on est arrivé à exécuter cette fonction.

* Referenced by a (U)nconditional or (C)onditional Jump at Address: \|:00437539(C)

`:00437589`	`8B4514`	`mov eax, dword ptr [ebp+14]`
`:0043758C`	`50`	`push eax`
`:0043758D`	`8B4D10`	`mov ecx, dword ptr [ebp+10]`
`:00437590`	`51`	`push ecx`
`:00437591`	`8B550C`	`mov edx, dword ptr [ebp+0C]`
`:00437594`	`52`	`push edx`
`:00437595`	`8B4508`	`mov eax, dword ptr [ebp+08]`
`:00437598`	`50`	`push eax`

* Reference To: USER32.MessageBoxA, Ord:01BEh

`:00437599`	`FF1508EB6500`	`Call dword ptr [0065EB08]`

Je crois que c'est clair : la seule manière d'arriver ici en 00437589 c'est par l'adresse 00437539 (le C indique que le saut depuis 00437539 s'est fait de façon conditionnelle ie c'est un je ou un jne qui nous a amené en 00437589).Allons en 00437539 par shift F12 -> 00437539. On voit alors ça

`:00437530`	`0FBE05ACCE6400`	`movsx eax, byte ptr [0064CEAC]`
`:00437537`	`85C0`	`test eax, eax`
`:00437539`	`744E`	`je 00437589`
`:0043753B`	`8B4D10`	`mov ecx, dword ptr [ebp+10]`

On va donc annuler le saut en 00437539 en remplaçant dans copie de readiris.exe ouvert dans winhex (ALT G -> 37539) le code hexadécimal 744E par 7400, comme ça le programme sautera en 0043753B au lieu de sauter en 00437589 et évitera ainsi de nous afficher le nag-screen. Ca c'était ma réflexion avant de tester le programme ainsi modifié. En effet il s'avère que si vous lancez le programme copie de readiris.exe et que vous cliquez sur le lien nommé "Numériser" un problème apparaît quelques instants plus tard une fois le document numérisé apparu. Il vous est alors impossible de quitter le programme aussi bien par la commande Fichier -> Quitter qu'en utilisant la croix de fermeture de la fenêtre.

Qu'est ce que ça veut dire ? Eh bien ça veut dire que si l'on se contente d'annuler le saut 00437539 ; le programme va en plus de nous supprimer le message "Cette version fonctionnera seulement pendant 30 jours" nous supprimer également le message "Ces pages numérisées n'ont pas encore été reconnues.Voulez-vous quand même quitter l'application ?" qui s'affiche quand on quitte le programme après une numérisation sans faire reconnaître + enregistrer.Ce n'est pas du tout ce qu'on veut ! On veut seulement supprimer le 1 ^ier message (l'annulation du second message empêche le fermeture de l'application après un scan de fichier en ne proposant plus la boîte de dialogue contenant le deuxième message).Remontons dans le code pour voir comment on est arrivé ici.

* Referenced by a CALL at Addresses: \|:00402CF3 , :0040302B , :00404DFF , :004066A9 , :004068FE \|:0040718B , :0040C9B3 , :0040CC7F , :004123B0 , :0041DEEC \|:0041E465 , :0041EDBB , :0041F7CD , :0041F87D , :00438489 \|:004385E0 , :00450AD4 , :00450C13 , :00453914 , :0045392F \|:0045DA6D , :0045DD2E , :0045E015 , :0045E2EA , :0045E384 \|:004691DE , :00469272 , :00482779 , :00484573 , :00485A59 \|:00485C95 , :00488482 , :00489B61 , :00489CCA , :0048A778 \|:0048A83F , :0048B5D0 , :0048BB8E , :0048C4A8 , :0048C891 \|:0048E2E0 , :0048E3C5 , :0048E41F , :0048E474 , :0048ECAE \|:0048F44A , :0048F6FA , :0048F91D , :00490002 , :00490130 \|:0049021E , :004902CA , :00490816 , :00490BBA , :00491937 \|:00491D3B , :0049306D , :00493457 , :00494D02 , :00494DDA \|:004967B4 , :00496F54 , :0049728B , :0049764D , :00497808 \|:00498494 , :00498843 , :00499939 , :0049B24F , :0049B269 \|:0049B283 , :0049B29D , :0049B480 , :0049B4D3 , :0049B4ED \|:0049C54B , :0049EB71 , :0049F03B , :004A689A , :004B546C \|:004B5B9B

`:00437520`	`55`	`push ebp`
`:00437521`	`8BEC`	`mov ebp, esp`
`:00437523`	`83EC48`	`sub esp, 00000048`
`:00437526`	`53`	`push ebx`
`:00437527`	`56`	`push esi`
`:00437528`	`57`	`push edi`
`:00437529`	`C745FC00000000`	`mov [ebp-04], 00000000`
`:00437530`	`0FBE05ACCE6400`	`movsx eax, byte ptr [0064CEAC]`
`:00437537`	`85C0`	`test eax, eax`
`:00437539`	`744E`	`je 00437589`

On est arrivé à exécuter le saut en 00437539 par un saut depuis l'une des 81 adresses suivantes 00402CF3, 0040302B, 00404DFF, 004066A9, 004068FE ... Relançons une nouvelle session de debugging dans w32dasm => CTRL T puis CTRL L et cliquez sur le bouton clear dans la grande fenêtre du debugger pour annuler tous les points d'arrêts (breakpoints) posés.On se place au début de la zone de code de readiris.exe avec CTRL S dans w32dasm .Ce qu'on pourrait faire pour trouver cette fameuse adresse (qui retire le nag-screen de démarrage) parmi les 81 c'est faire SHIFT F12 -> adresse suivi de F2 (pour poser un bp) avec adresse valant successivement l'une des 81 adresses suivantes : 00402CF3, 0040302B, 00404DFF, 004066A9, 004068FE ...

Comme c'est trop fastidieux à faire et que la solution la plus simple est toujours la meilleure il suffit de se dire que l'arrivée dans cette zone de code (qui commence à l'adresse 00437520 et se termine par un ret) est certainement provoquée par une instruction asm call.Ce que l'on va faire c'est dans w32dasm mettre un bp sur 00437539 (sélection dans w32dasm de la ligne de code correspondant à cette adresse puis F2) puis F9.Ensuite avec des F8 (exécution ligne de code par ligne de code sans entrer dans les call mais en les exécutant quand même) vous arrivez sur 00437599 qui affiche le message "Cette version fonctionnera seulement pendant 30 jours".

* Reference To: USER32.MessageBoxA, Ord:01BEh

`:00437599`	`FF1508EB6500`	`Call dword ptr [0065EB08]`
`:0043759F`	`8945FC`	`mov dword ptr [ebp-04], eax`
`:004375A2`	`8B45FC`	`mov eax, dword ptr [ebp-04]`

* Referenced by a (U)nconditional or (C)onditional Jump at Addresses: \|:00437572(U), :00437579(U), :00437580(U), :00437587(U)

`:004375A5`	`5F`	`pop edi`
`:004375A6`	`5E`	`pop esi`
`:004375A7`	`5B`	`pop ebx`
`:004375A8`	`8BE5`	`mov esp, ebp`
`:004375AA`	`5D`	`pop ebp`
`:004375AB`	`C3`	`ret`

Faîtes OK dans cette boîte de dialogue puis retournez à w32dasm et faîtes des F8.Vous arrivez alors sur l'instruction asm ret en 004375AB.Un F8 dessus et on arrive au call qui a appelé l'adresse 00437520 (voir plus haut la signification de cette adresse).

`:0048E2E0`	`E83B92FAFF`	`call 00437520`
`:0048E2E5`	`83C410`	`add esp, 00000010`
`:0048E2E8`	`C7052C70650001000000`	`mov dword ptr [0065702C], 00000001`

On était donc dans le call à l'adresse 0048E2E0.Pour supprimer définitivement le nag-screen "Cette version fonctionnera seulement pendant 30 jours" sans toucher aux autres messages de l'application il faut donc nopper le call en 0048E2E0 ie remplacer le code en rouge suivant dans copie de readiris.exe ouvert dans winhex à l'offset 8E2E0 (ALT G -> 8E2E0).

:0048E2E0 E83B92FAFF call 00437520
remplacé par
:0048E2E0 90 nop
:0048E2E1 90 nop
:0048E2E2 90 nop
:0048E2E3 90 nop
:0048E2E4 90 nop

Enregistrez et lancer cette copie. Le nag-screen " Cette version ne fonctionnera que pendant 30 jours" a disparu. Si vous avancez d'un an la pendule de windows le nag disant que "La période d'évaluation de 30 jours est terminée.Veuillez contacter votre revendeur" n'est cependant pas retiré. On va le retirer en s'attaquant au time limit qui passé 30 jours ferme le programme.

Quand on lance le programme il nous affiche le nag et ensuite il reste ouvert ou se ferme si on a dépassé les 30 jours. Nous ce que l'on va chercher à faire maintenant c'est maintenir la fenêtre ouverte tout le temps (avant et après les 30 jours).

Pour cela il faut un peu de connaissances sur les API windows en particulier sur la fonction ShowWindow de l'API USER32.dll. Comme son nom l'indique ShowWindow est la fonction qui est appelée dans de nombreux cas pour afficher une fenêtre. Les paramètres de cette même fenêtre comme ses dimensions (position du coin supérieur gauche, largeur, hauteur) sont positionnés au préalable avec par exemple la fonction CreateWindow.Je vous invite à ce sujet à regarder mon article sur le code source de mes cracks en C++ disponible sur mon site dans la rubrique http://pifoman.free.fr/cours_cracking/cours_pif_source_C2.htm. Vous verrez à la fin du code un appel à la fonction ShowWindow. C'est une fonction indispensable au programme sinon rien ne s'affiche même si vous avez fait votre CreateWindow au préalable. Cette règle on va l'appliquer dans le cas de readiris.exe.

Ce que l'on va faire c'est d'abord avancer la pendule de 1 an et mettre un point d'arrêt sur tous les appels à cette fonction ShowWindow.Pour cela faîtes CTRL T (pour terminer la session courante de debugging) CTRL L puis effacez les breakpoints existants dans la grande fenêtre du debugger qui vient d'apparaître en cliquant sur le bouton clear à droite de la zone Bpts. Ensuite plaçez vous au début de la zone de code de readiris.exe par CTRL S et mettez avec F2 un breakpoint (bp) sur toutes les occurences de ShowWindow trouvées avec search -> find text -> ShowWindow (F3 pour passer aux occurences suivantes).

Le problème c'est qu'il y en a beaucoup de références à l'API ShowWindow. On va faire plus simple et plus rapide encore une fois. ShowWindow est une fonction encodée dans la dll qui s'appelle USER32.dll (répertoire C:\WINDOWS\system32).Au lieu de mettre un bp sur toutes les références de ShowWindow dans readiris.exe désassemblé dans w32dasm on va directement mettre un point d'arrêt sur la fonction ShowWindow de USER32.dll. Comment faire ça dans w32dasm ? Eh bien dans la grande fenêtre du débugger qui est apparue quand vous aviez fait CTRL L tout à l'heure vous avez une case Actives DLLs en bas à droite contenant la liste des dll appelées par readiris.exe (pour son exécution). Faîtes défiler les dll. Vous voyez alors USER32.dll. Double-cliquez dessus.Le désassemblage de USER32.dll commence dans w32dasm (le programme readiris.exe qu'on avait désassemblé restant caché en arrière-plan dans le débugger w32dasm). Ensuite faîtes une recherche de la chaîne par Search -> Find Text -> Exported fn(): ShowWindow (en langage technique on dit que la fonction ShowWindow est une fonction système exportée de user32.dll dans readiris.exe). Vous arrivez ici :

Exported fn(): ShowWindow - Ord:0293h
`:77D17D27`	`B82B120000`	`mov eax, 0000122B`
`:77D17D2C`	`BA0003FE7F`	`mov edx, 7FFE0300`
`:77D17D31`	`FFD2`	`call edx`
`:77D17D33`	`C20800`	`ret 0008`

Notre point d'arrêt on va le poser en 77D17D27 (en sélectionnant la ligne puis F2).Faîtes F9 pour démarrer le débugging du programme.w32dasm break alors sur 77D17D27. Faîtes des F8. Le F8 sur la ligne de code 77D17D33 donne ceci dans la petite fenêtre du debugger (qui s'est aussi ouverte quand on avait fait CTRL L).

Puis avec un F9 et des F8 on arrive ici (et on voit la fenêtre de readiris apparaître dans la barre de tâches).

L'adresse d'appel de la fonction ShowWindow est donc l'adresse 0048E1F1. Redésassemblons readiris.exe avec la commande Disassembler -> Open File to Disassemble -> readiris.exe et allons à l'adresse 0048E1F1 par SHIFT F12 -> 0048E1F1 et posons un bp dessus avec F2.

* Reference To: USER32.ShowWindow, Ord:026Ah

`:0048E1F1`	`FF15A8EB6500`	`Call dword ptr [0065EBA8]`
`:0048E1F7`	`A13C6D6500`	`mov eax, dword ptr [00656D3C]`
`:0048E1FC`	`50`	`push eax`

* Reference To: USER32.UpdateWindow, Ord:0291h

`:0048E1FD`	`FF155CEB6500`	`Call dword ptr [0065EB5C]`
...
`:0048E233`	`E84803FDFF`	`call 0045E580`
`:0048E238`	`85C0`	`test eax, eax`
`:0048E23A`	`7558`	`jne 0048E294`
...
`:0048E257`	`6A1E`	`push 0000001E`
`:0048E259`	`8D85F4FAFFFF`	`lea eax, dword ptr [ebp+FFFFFAF4]`
`:0048E25F`	`50`	`push eax`
`:0048E260`	`8D8DF0FBFFFF`	`lea ecx, dword ptr [ebp+FFFFFBF0]`
`:0048E266`	`51`	`push ecx`

* Reference To: USER32.wsprintfA, Ord:02ACh

`:0048E267`	`FF15F8EB6500`	`Call dword ptr [0065EBF8]`
...

* Reference To: USER32.GetFocus, Ord:0107h

`:0048E27E`	`FF15ACEB6500`	`Call dword ptr [0065EBAC]`
`:0048E284`	`50`	`push eax`
`:0048E285`	`E83693FAFF`	`call 004375C0`
`:0048E28A`	`83C410`	`add esp, 00000010`
`:0048E28D`	`33C0`	`xor eax, eax`
`:0048E28F`	`E94A040000`	`jmp 0048E6DE`

* Referenced by a (U)nconditional or (C)onditional Jump at Address: \|:0048E23A(C)

`:0048E294`	`68FA000000`	`push 000000FA`

Les W32dasm API details qui apparaissent successivement à l'écran quand on fait des F8 nous indiquent que

-> En 0048E267 la chaîne "Période d'évaluation de 30 jours terminée.Veuillez contacter votre revendeur" est chargée via la fonction USER32.wsprintfA et le %i prend la valeur 30 en cliquant sur le bouton GET API RESULT de la fenêtre W32dasm API details qui vient d'apparaître. Le 30 est chargé en 0048E257 (0000001E en hexadécimal = 30 en décimal).
-> En 0048E285 affichage dans une messageBox du message "Période d'évaluation de 30 jours terminée.Veuillez contacter votre revendeur".

On réfléchit à la vue de ces éléments et on se dit qu'il nous faut absolument éviter ce message d'erreur. Comment faire ? Remontons dans le code pour voir si on peut éviter de passer sur cette zone qui provoque la fermeture de la fenêtre. On voit que cette zone peut être évitée si on force le saut en 0048E23A (en remplaçant dans winhex à l'offset 8E23A le code 7558 par EB58). Malheureusement il s'avère après vérification que le forçage du saut ne suffit pas à retirer complètement le time-limit car si vous avancez la pendule de windows de 1 an et que vous relancez readiris.exe vous constaterez que la fenêtre principale de readiris.exe reste bien ouverte au dela des 30 jours mais que les boutons (en particulier Numériser) ne sont plus cliquables !.

La vérification si les 30 jours d'évaluation sont passés ou non se fait avant dans le call au dessus à l'adresse 0048E233. Descendons dans le call qui est à cette adresse.On arrive ici.

* Referenced by a CALL at Addresses: \|:004641B1 , :00484580 , :00485108 , :0048E233

`:0045E580`	`55`	`push ebp`
...
`:0045E5A2`	`83C404`	`add esp, 00000004`
`:0045E5A5`	`8945F0`	`mov dword ptr [ebp-10], eax`
`:0045E5A8`	`837DF000`	`cmp dword ptr [ebp-10], 00000000`
`:0045E5AC`	`7529`	`jne 0045E5D7`
...
`:0045E5BA`	`8D45DC`	`lea eax, dword ptr [ebp-24]`
`:0045E5BD`	`50`	`push eax`
`:0045E5BE`	`6A01`	`push 00000001`
`:0045E5C0`	`E8FBDDFFFF`	`call 0045C3C0`
...

* Referenced by a (U)nconditional or (C)onditional Jump at Address: \|:0045E5AC(C)

`:0045E5D7`	`837DF00A`	`cmp dword ptr [ebp-10], 0000000A`
...
`:0045E6FC`	`7C07`	`jl 0045E705`
`:0045E6FE`	`B801000000`	`mov eax, 00000001`
`:0045E703`	`EB26`	`jmp 0045E72B`

* Referenced by a (U)nconditional or (C)onditional Jump at Address: \|:0045E6FC(C)

`:0045E705`	`C645DC30`	`mov [ebp-24], 30`
...
`:0045E646`	`33C0`	`xor eax, eax`
`:0045E648`	`E9DE000000`	`jmp 0045E72B`
...

* Referenced by a (U)nconditional or (C)onditional Jump at Addresses: \|:0045E5DF(U), :0045E618(U), :0045E638(U), :0045E648(U), :0045E658(U), \|:0045E668(U), :0045E67F(U), :0045E703(U)

`:0045E72B`	`5F`	`pop edi`
`:0045E72C`	`5E`	`pop esi`
`:0045E72D`	`5B`	`pop ebx`
`:0045E72E`	`8BE5`	`mov esp, ebp`
`:0045E730`	`5D`	`pop ebp`
`:0045E731`	`C3`	`ret`

Ce qu'on va faire c'est faire une trace de la séquence de code 0045E580 -> 0045E731. Il s'agit de débugguer ligne de code par ligne de code cette zone en étant une première fois sorti de la période d'évalution et une seconde fois en étant période d'évaluation. La comparaison des 2 traces nous permettra de localiser l'endroit où est invoqué le time-limit.

Dans les 2 traces on pose un bp sur l'adresse 0045E580 (après avoir fait CTRL T -> CTRL L -> SHIFT F12 -> 0045E580 -> OK -> F2).

Trace 1 : période d'évaluation dépassée :
-> 0045E5AC : le programme saute.
-> 0045E6FC : le programme saute.
-> 0045E646 : eax est mis à 00000000.
-> 0045E731 : on sort de la routine.

Trace 2 : évaluation (effacer la clé HKCR\CLSID\{e941a7a2-3c1f-4db7-9955-b4fb3f8f9517}\ClassData\rua01y)
-> 0045E5AC : le programme ne saute pas.
-> 0045E6FC : le programme ne saute pas.
-> 0045E6FE : eax est mis à 00000001.
-> 0045E731 : on sort de la routine.

Il suffit d'annuler le saut en 0045E5AC et le time-limit est retiré (cette fois-ci les boutons dans l'interface seront actifs au dela des 30 jours); eax valant 00000001 arrivé au ret en 0045E731.

Rappel : pour effectuer physiquement la modification (ie 7529 remplacé par 7500) allez dans winhex ,ouvrez copie de readiris.exe et faîtes ALT G -> 5E5AC. Enregistrez, avancez la pendule d'un an et lancez le programme. Il tourne correctement au dela des 30 jours.

Remarque : le message disant "Période d'évaluation de 30 jours terminée.Veuillez contacter votre revendeur." n'apparaîtra donc plus puisque le programme n'expire plus (une pierre 2 coups !).

A chaque chaque chargement de readiris.exe un logo se charge nous obligeant à cliquer sur celui-ci pour afficher l'interface du logiciel.A la longue c'est pénible.On va l'enlever.Pour cela on fait appel à l'artillerie lourde : softice.Je suppose que vous savez installer ce logiciel sinon consultez mon cours sur photoimpact 8.5 fr de présentation et d'installation de softice.Avant de commencer 2 choses importantes

-> On va travailler avec readiris.exe patché (nag screen de la partie 1 et time-limit de la partie 2 retirés).
-> La fonction showwindow sur laquelle on va poser des breakpoints sous softice est une fonction très utilisée par windows. Si vous ne voulez par être harcelé toutes les secondes par softice qui break sur showwindow tapez dans la barre de commande de softice la commande bc* pour annuler tous les breakpoints posés.

On démarrer donc softice (clic sur le lien Start Softice dans le menu démarrer) et on l'affiche avec CTRL D et on va lui demander de s'arrêter dès que readiris.exe exécute le chargement du logo.Pour cela on sélectionne readiris.exe sans le lancer et on passe sous softice avec CTRL D puis on tape dans la zone de commande de softice en bas.

Cette commande signifie breakpoint on execution (bpx) on showwindow function.En français dès que readiris exécute la fonction User32.showwindow (showwindow est codée dans C:\WINDOWS\system32\User32.dll) softice va stopper (à cause du breakpoint = point d'arrêt en français) l'exécution de readiris et nous l'indiquer.On repasse sous windows en tapant CTRL D puis on lance readiris.exe avec la touche entrée du clavier.

A ce moment softice surgit.On atterrit dans user32 (il y a marqué user32!.text sur la dernière ligne en vert à doite en partant du bas de la fenêtre de softice).Ca ne nous intéresse pas puisque cette dll appartient au système windows et pas au programme.On fait F12 pour remonter à l'endroit de l'appel de user32.Cette fois ci on est dans readiris (readiris!.text sur la dernière ligne en vert à doite en partant du bas de la fenêtre de softice).

On commence à tracer le programme en mode pas à pas en appuyant sur F10 plusieurs fois et l'on voit l'interface de readiris.exe qui se construit progressivement (faîtes F12 plusieurs fois si nécessaire dès que vous êtes ailleurs que dans readiris!.text puis des F10 dès que vous êtes revenu dans readiris). Tapez F4 pour voir ce qui se passe sous windows et F4 pour revenir sous softice.Si vous avez un pb d'affichage de softice à cause de l'interface de readiris qui se construit tapez 2 fois F4 dans softice et votre affichage dans softice redeviendra correct.A un moment donnée le logo apparaît.Relevez sur un papier l'adresse de la ligne de code.

Tapez bc* suivi de entrée dans softice puis CTRL D et désassemblez readiris.exe patché (partie 1 + partie 2) dans w32dasm. Dès que le désassemblage est terminé faîtes SHIFT F12 -> 0048D563 pour voir ce qu'on a en 0048D563.

* Referenced by a CALL at Addresses: \|:0048C6C3 , :0048E37D

`:0048D530`	`55`	`push ebp`
...

* Reference To: USER32.CreateDialogParamA, Ord:004Fh

`:0048D563`	`FF1548EB6500`	`Call dword ptr [0065EB48]`
...
`:0048D574`	`C3`	`ret`

Le logo est donc affiché avec la fonction CreateDialogParamA.On arrive à l'adresse par 2 adresses 0048C6C3, 0048E37D. Parmi ces 2 adresses il n'y a que l'adresse 0048E37D qui appelle au démarrage l'adresse 0048D530 (démarrer une nouvelle session de debugging dans w32dasm avec CTRL T -> CTRL L puis mettez un bp sur 0048D530 pour vous en convaincre et faîtes des F9). D'ailleurs comme par hasard l'adresse 0048E37D se trouve dans la zone du showwindow qui affichait la fenêtre principale de readiris (remontez de quelques lignes dans w32dasm et vous retouverez le listing de la partie 2).

* Referenced by a (U)nconditional or (C)onditional Jump at Address: \|:0048E374(C)

`:0048E37D`	`E8AEF1FFFF`	`call 0048D530`

* Referenced by a CALL at Addresses: \|:00401468 , :00402197 , :0040886B , :00408948 , :0040994F \|:00410434 , :0045236E , :004524D9 , :004556FC , :0045638C \|:0047B4F1 , :0047C1A9 , :004846FC , :0048EC06 , :0048ECD6 \|:0048F084 , :004A04A8 , :004A1978

`:0048C670`	`55`	`push ebp`
...

* Reference To: USER32.GetWindowLongA, Ord:0156h

`:0048C69A`	`FF15F8EA6500`	`Call dword ptr [0065EAF8]`
...

* Reference To: USER32.DestroyWindow, Ord:008Eh

`:0048C6AA`	`FF15E8EB6500`	`Call dword ptr [0065EBE8]`
...

* Reference To: USER32.UpdateWindow, Ord:0291h

`:0048C70E`	`FF155CEB6500`	`Call dword ptr [0065EB5C]`
...
`:0048C759`	`E8B2750200`	`call 004B3D10`
...
`:0048C771`	`C3`	`ret`

A priori rien d'intéressant ! Enlevons tous les bp posés (bouton Clear à droite dans la grande fenêtre du débugger) et mettons-en un quand même sur l'adresse 0048C670 (CTRL L -> SHIFT F12 -> 0048C670 -> F2) pour voir comment est ce qu'on arrive ici. Puis lançons readiris.exe avec F9 et là en cliquant sur le logo w32dasm break sur 0048C670. Ensuite avec des F8 on voit l'interface qui est complètement chargée arrivé en 0048C759.

Une interface complètement chargée avec la barre de boutons verticale à droite.C'est ce qu'on veut non ! Ce que nous allons faire c'est faire sauter readiris.exe depuis l'adresse 0048E37D (qui appelle la fonction CreateDialogParamA) vers 0048C670 (où l'on charge complètement l'interface).

Dans w32dasm l'offset associé à l'adresse 0048E37D est 8E37D.Fermez w32dasm et ouvrez votre readiris.exe patché (partie 1 + partie 2) puis ALT G -> 8E37D et remplacez le code hexadécimal en rouge par sa nouvelle valeur (à savoir E8AEF1FFFF remplacé par E8EEE2FFFF). Lancez et voila le time-limit est retiré.

Remarque : comment ai-je calculé le code E8 EE E2 FF FF correspondant à l'instruction call 0048C670 ?
Voici la manipulation à faire :
-> Retirez tous les bp posés dans w32dasm
-> CTRL L
-> Posez un bp sur l'adresse 0048E37D (sélection de la ligne 0048E37D -> F2)
-> F9
-> Clic sur le bouton Patch Code de la petite fenêtre du debugger.
-> Tapez call 0048C670
-> Entrée

Le code hexadécimal apparaît alors en dessous. Il suffit alors de faire cliquez sur le bouton Copy de la fenêtre courante.

On repasse d'abord le logiciel en anglais (menu Configuration -> Langue interface utilisateur ...).Pour éditer les ressources de readiris.exe on a besoin Resource Hacker 3.4.0.79. Ouvrez readiris.exe (patch partie 1, 2, 3 appliqué) dans ResHacker.exe (Resource Hacker). Puis faîtes une recherche de la chaîne Purchase. C'est la chaîne qui apparaît dans le menu Register -> Purchase Info.... Vous arrivez ici (chemin String Table -> 414 -> 0)

  STRINGTABLE
  LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL
  {
6608, "&Register"
6609, "Registration &Wizard..."
6610, "Purchase &Info..."
6611, "&Upgrade..."
//...//
  }

Le //... // signifie que j'ai tronqué ce qui est affiché.Ce qu'il faut savoir c'est que les menus (par exemple "&Register") et les items de menus (par exemple "Purchase &Info...") sont identifés par un numéro ici écrit en décimal. Pour "&Register" c'est 6608 soit 19D0 en hexadécimal (utiliser la calculatrice de windows démarrer -> exécuter -> calc -> 6608 -> clic sur bouton hex). Ensuite prenez le listing de désassemblage de readiris.exe donné par w32dasm et cherchez l'endroit où cet identifiant est appelé avec Search -> Find Text -> 000019D0. Vous arrivez ici

`:0048D346`	`83C410`	`add esp, 00000010`
`:0048D349`	`68D0190000`	`push 000019D0`
`:0048D34E`	`8B55F8`	`mov edx, dword ptr [ebp-08]`
`:0048D351`	`52`	`push edx`
`:0048D352`	`6A10`	`push 00000010`
`:0048D354`	`8B45FC`	`mov eax, dword ptr [ebp-04]`
`:0048D357`	`50`	`push eax`
`:0048D358`	`E893330700`	`call 005006F0`
`:0048D35D`	`83C410`	`add esp, 00000010`

* Reference To: USER32.CreatePopupMenu, Ord:0058h

`:0048D360`	`FF157CEA6500`	`Call dword ptr [0065EA7C]`

L'appel est situé en 0048D349. C'est le call 005006F0 en 0048D358 qui crée le menu déroulant (et pas comme on pourrait le croire au vue du code l'appel à USER32.CreatePopupMenu en 0048D360). Il suffit donc de nopper (remplacer par une suite de nop) ce call et le menu "Register" disparaîtra.

Ouvrez readiris.exe dans winhex et replacez le code hexadécimal suivant en rouge (ALT G -> 8D358) à partir de l'offset 8D358

  :0048D358   E893330700 call 005006F0
  remplacé par
  :0048D358   90   nop
  :0048D359   90   nop
  :0048D35A 90   nop
  :0048D35B 90   nop
  :0048D35C 90   nop

Dans ce chapitre nous allons travailler uniquement avec la version française de readiris.exe sur laquelle on a appliqué les patchs des parties 1, 2 et 3. Pour avoir la version française on fait Settings -> User Interface Language dans readiris.exe.On va appeler ce fichier patché le fichier readiris123.exe.

En regardant le menu Aide -> A propos de readiris123.exe on remarque qu'il n'y a pas de mention du propriétaire du logiciel. Cela n'a pas été prévu dans le logiciel à l'origine car le logiciel n'est pas enregistrable. Ca pourrait être bien de faire figurer dans la fenêtre qui apparaît à la suite d'un clic sur ce menu par exemple la mention "Enregistré à Pifoman". Pour cela on peut remplacer dans la fenêtre la chaîne All rights reserved par notre chaîne "Enregistré à Pifoman". Comment réaliser cela ? On va utiliser ma technique préférée. On ouvre readiris.exe dans winhex et on cherche la mention All rights reserved par CTRL F -> All rights reserved (option jeu de caractères unicode cochée). On relève alors l'offset trouvé de la première lettre de la chaîne All rights reserved en bas de winhex. C'est 39D55A. Ensuite on revient à readiris123.exe désassemblé dans w32dasm et on regarde les sections tout en haut du listing de désassemblage

Disassembly of File: C:\Program Files\Readiris Pro 10\readiris123.exe
Code Offset = 00001000, Code Size = 00165000
Data Offset = 0017B000, Data Size = 000D2000

Object01: .text RVA: 00001000 Offset: 00001000 Size: 00165000 Flags: 60000020
    Object02: .rdata RVA: 00166000 Offset: 00166000 Size: 00015000 Flags: 40000040
Object03: .data RVA: 0017B000 Offset: 0017B000 Size: 000D2000 Flags: C0000040
    Object04: .idata RVA: 0025D000 Offset: 0024D000 Size: 00006000 Flags: C0000040
Object05: .rsrc   RVA: 00263000 Offset: 00253000   Size: 00156000 Flags: 40000040
Object06: .reloc RVA: 003B9000 Offset: 003A9000 Size: 00015000 Flags: 42000040

On voit que 00253000 < 39D55A < 003A9000. Donc l'offset 39D55A appartient à la section .rsrc.Comment trouver l'adresse correspondant cet offset dans w32dasm.Il suffit de faire le calcul suivant.

offset trouvé - offset début section + RVA début section + Imagebase = adresse cherchée
39D55A - 00253000 + 00263000 + 400000 = 7AD55A.

L'adresse équivalente à l'offset 39D55A est donc 007AD55A.Pour trouver où est appelé cette adresse dans w32dasm on fait Search -> Find Text -> 007AD55A -> OK. Mais on ne trouve rien ! On en déduit que l'adresse n'est pas appelée directement mais est calculée par le programme en utilisant les registres.

On change de technique.On regarde les fonctions importées par le programme en cliquant sur le bouton Imp Fn dans la barre de boutons de w32dasm.On en voit une qui est souvent utilisée pour afficher du texte dans les fenêtres. Il s'agit de la fonction TextOutA.Ce qu'on va faire c'est mettre un bp (CTRL S puis répétition de F2 -> F3) sur toutes les occurences de la fonction TextOutA dans w32dasm (après avoir fait CTRL T -> CTRL L).On coche toutes les cases dans la petites fenêtre du débugger (qui est apparue quand on a fait CTRL L). Vous avez 18 bp de posés (le premier sur l'adresse 00401961). Démarrons le débugging avec F9. La fenêtre W32dasm API details apparaît ensuite. Faîtes autant de F9 que nécessaire jusqu'à obtenir ceci

API BOOL Arg00 = TextOutA(Arg01,Arg02,Arg03,Arg04,Arg05)
API Address=00401C85, API Return Address=00401C8B
Arg01 = (HDC) 01010055
Arg02 = (int) 00000004
Arg03 = (int) 000000e5
Arg04 = (LPCTSTR) 0012ee70 -> "Tous droits réservés"
Arg05 = (int) 00000014

On ferme w32dasm et on ouvre readiris123.exe puis on cherche ensuite une zone de 00 consécutifs inutilisés à la fin du fichier où mettre notre phrase "Enregistré à Pifoman". J'ai choisi l'offset 3BDC00.On écrit alors chacune des lettres de notre phrase à la queue leu leu et on enregistre le fichier sous le nom readiris1235c.exe.En utilisant les sections de readiris.exe détaillées plus haut on a que l'offset 3BDC00 appartient à la section .reloc

offset trouvé - offset début section + RVA début section + Imagebase = adresse cherchée
3BDC00 - 003A9000 + 003B9000 + 400000 = 7CDC00.

`:00401C46`	`8D8500FFFFFF`	`lea eax, dword ptr [ebp+FFFFFF00]`
`:00401C4C`	`50`	`push eax`
`:00401C4D`	`E86ECF0B00`	`call 004BEBC0`
`:00401C52`	`83C404`	`add esp, 00000004`
`:00401C55`	`50`	`push eax`
`:00401C56`	`8D8D00FFFFFF`	`lea ecx, dword ptr [ebp+FFFFFF00]`
`:00401C5C`	`51`	`push ecx`
...
`:00401C63`	`52`	`push edx`
...
`:00401C7D`	`51`	`push ecx`
...
`:00401C84`	`52`	`push edx`

* Reference To: GDI32.TextOutA, Ord:0205h

`:00401C85`	`FF153CE16500`	`Call dword ptr [0065E13C]`

La fonction TextOutA(Arg01,Arg02,Arg03,Arg04,Arg05) a 5 arguments : Arg01, Arg02, Arg03, Arg04, Arg05.

On voit tout de suite que c'est la variable [ebp+FFFFFF00] en 00401C56 qui pointe sur le début de la chaîne "Tous droits réservés".Si on change le contenu du registre ecx en 00401C56 par l'adresse 007CDC00 qui pointe vers notre chaîne "Enregistré à Pifoman" le remplacement dans le menu Aide -> A propos de readiris1235c.exe de ne se fait pas. En fait il faut aussi patcher en 00401C46 et mettre dans eax l'adresse 007CDC00. Comment est ce que je sais ça ?

Effaçons tous les bp posés (clic sur le boutons Clear dans la grande fenêtre du debugger à droite de BPts) puis redémarrons une session de debugging avec CTRL T -> CTRL S et posons un bp sur l'adresse 00401C46 et 00401C56.Ensuite F9 et allez dans le menu Aide -> A propos de readiris1235c.exe. w32dasm break sur l'adresse 00401C46. Cliquez sur le nouton Patch Code de la grande fenêtre du debugger.Une fenêtre apparaît.Tapez ces 2 lignes de code suivies chacune de entrée.

Puis Apply Patch -> Close -> Oui -> Oui -> F9. Refaîtes la même manipulation pour l'adresse 00401C56. Désactivez ensuite les bp posés en cliquant sur le bouton DA (à droite de BPts de la grande fenêtre du debugger).Faîtes F9. La fenêtre Aide -> A propos de readiris1235c.exe affiche "Enregistré à Pifoman" à la place de "Tous droits réservés".

Ouvrez readiris1235c.exe dans winhex et replacez le code hexadécimal suivant en rouge

:00401C46 8D8500FFFFFF lea eax, dword ptr [ebp+FFFFFF00]
remplacé par
:00401C46 90 nop
:00401C47 B800DC7C00 mov eax, 007CDC00

:00401C56   8D8D00FFFFFF   lea ecx, dword ptr [ebp+FFFFFF00]
remplacé par
:00401C56   90 nop
:00401C57   B800DC7C00 mov eax, 007CDC00

En conclusion vous avez appris dans cette leçon à localiser un nag-screen grâce à la fonction messageBox de l'API User32.dll (partie 1) puis à retirer un time-limit (partie 2). Je vous ai montré ensuite à l'aide de softice à localiser l'endroit où est crée la fenêtre contenant le logo de démarrage en posant un point d'arrêt sur la fonction showwindow. Enfin nous avons retiré le menu Register de la barre de menu à l'aide d'une analyse avec Resource Hacker et ajouté la mention Enregistré à Pifoman dans le menu Aide -> A propos.

Le programme n'est pas simple à priori à craquer car les erreurs sont facilement possibles si on n'effectue pas les tests suffisants (partie 1 et 2). En plus certaines parties comme la suppression du logo sont réservées aux gens qui ont une bonne expérience du cracking (on a crée par exemple un saut dans le code qui n'existait pas !).