www.lanzarotecaliente.com (press control & click here)

PREMIER CRAK …by : on s’en tape … COMMENTAIRES DE PSYCHE

MESSAGE LAISSE SUR LE SITE DE FROG

Je débute et c'est pas simple ...m'enfin..je cherche à cracker systran..Même si c'est pas l’idéal pour un débutant m'en fou...ça bosse mon asm..Si qq un d'entre vous à un tuyau ou une direction à me conseiller (PAS DE SOLUTION : FAUT QUE J'ARRIVE SEUL).pour le moment j'ai réussi à avoir un "INIT OK" mais après il sort..(put..de dll exit-machin...en plus j'y connais rien), il y à au moins 3 contrôles dans ce prog, la présence d'un DUP (10) me fait penser à un passe de 10 lettres ...j'en suis la ...Ne rigolez pas si fort s.v.p., FROG va vous entendre et après il va me virer de son site... j'ai 15 jours d'asm, alors soyez indulgents..

merci

REPONSE AU MESSAGE

Salut,Bon tu ne veux pas qu'on te mâche le travail, ... d'accord :)Je vais juste te guider pour Systran.Tu as effectivement repéré les DLL dans le répertoire "PERSONAL"Je t'avertis déjà que ce n'est pas sur elles qu'il faudra s'acharner,mais sur l'executable principal, j'ai nommé "personal.exe".OK, entrons dans le vif du sujet !Oublie tes essais et voyons ce qui se passe.1. on lance personal.exe2. un messagebox s'affiche avec "AUTHORIZATION NOT PRESENT".3. on clique sur OK4. Un nouvel écran s'affiche demandant un code ...... on serait tenté de chercher le bon code ... bof, c'est épuisant :)5. on réfléchit ... à quoi ?J'explique :

en désassemblant crp32dll.dll on voit toute un série de fonctionsexportées avec des noms intéressants ...OK, qu'est-ce-qu'il demandait au 2. ? Tu vois où je veux en venir ?On réfléchit encore ...Qu'est-ce qu'une fonction ?-> on rentre un (des) paramètre(s) et il sort 1 résultat ...Souvent, ce résultat sert de flag (drapeau) et les vieilles habitudes de lemettre dans eax sont tenaces (du genre 1 ou 0 = bon, -1 = mauvais) !Tu pourrais obliger la fonction xxxxxxx (à toi de la trouver ;) ) à retourner un "bon" flag à chaque fois mais dans ce cas-ci ce ne sera pas nécessaire, il suffit de patcher à 1 endroit pour cette fonction.

ATTENTION, petit conseil : regarde ce qu'il fait avec ce flag ou tu vas être coincé.Une fois cette partie passée, on se retrouve avec le traditionnel écranindiquant le nombre de jours (ou d'utilisations, je ne sais plus) auxquelson a droit ... (j'étais à -2500 jours sur 72 à peu près :) ).Cette partie est très proche de la précédent.

Bref,1. cherche quelle fonction répond au poit 2. (avec le listing désassemblé)

[bon, je suis cool, tu vois ce qui est écrit dans la messagebox en 1. ?et ben c une string ... ! ]

2. trouve où elle est appelée3. regarde ce qui est ramené après l'appel et ce qui est fait du résultat4. patche à ce endroit5. un peu plus loin il faut sauter la vérification du nombre je jours (?)restant

A priori, c'est tout. J'avoue ne pas avoir tout vérifié en profondeur mais tu devrais déjà avancer avec ça :)

STOP arrêtez les machines, je suis revenu ...J'ai oublié qqchose.Quand tu as passé toutes ces étapes, tu vois un joli Systranqui a l'air fonctionnel mais qui ne l'est pas ...Quand tu dois sélectionner un 'language pair' il s'affiche qu'aucune n'est installée !C'est une protection (enfin un peu ;) )Cherche la string 'No language pair is installed ...'et fais ce que tu as à faire.

Maintenant ça marche ! J'ai essayé !

Mail-moi pour me dire si tu as trouvé.

Psyche

PREMIERE RECHERCHE. & CORRIGE

* Reference To: CRP32DLL.GetAuthorization, Ord:0022h

:00402549 E8B03B0000 Call 004060FE 004060FE = Jmp dword ptr [00432680] ==> va chercher un dw ?

Les appels aux fonctions sont indirects car changent d’une fois à l’autre, en fait en [00432680] tu as la véritabke adresse CRPDLL.GetAuthorizationEn tout cas tu as trouvé le bon :)

Je suis largué ! 00432680, je n’ai pas cet EIP dans mon listing, au mieux, le goto de Wdasm m’envoie en :004221FC pour un BYTE 10 DUP ( 0 ), réserver un tableau de 10 octets initialisés à 0 ?

( Peut-être de quoi initialiser un passe de 10 signes ), quel rapport avec le DW  ? Je dois me planter…

cf.plus haut, ce 10 DUP (0) sera initialisé par window$ au lancement car les DLL n’ont pas d’adresses fixes…

:0040254E 8B4DF0 mov ecx, dword ptr [ebp-10] Copie le dw (2octs=BP) (se trouvant à l'adresse -10 du reg ebp) dans ecxOn s’en tape ;)

( Donc on ne change que la valeur de CX dans ECX ? )

:00402551 85C0 test eax, eax Si eax = eax ==> ZF=0, Si eax NON =eax ==> ZF=1Il vient d’ou cet eax ? ? ? ? Réfléchis et combien vaut-il ? ( Donc effectuera un contrôle sur cette valeur... )

:00402553 89410C mov dword ptr [ecx+0c], eax Copie le dw (2octs=AX) de eax dans l'adresse +12 du reg ecx( Donc on ne change que la valeur de CX dans ECX ? )

Relis ce que je t’ais écris l’autre fois (ATTENTION …)

:00402 556 0F84BB0000 je 00402617 Suite de XOR et LEA ( Contrôle de l'autorisation et jmp en GetRetrestrictionsinfo si non autorisé .) ( A priori, je pense qu’il faut éviter ce saut : changer le [JE] conditionnel par [JMP] inconditionnel..oui mais vers ou ? )

Quelle drôle de question … utilise SoftIce et regarde ce qui se passe normalement … si tu n’as pas l’autorisationAlors :1. que renvoie GetAuthorization ?2. qu’est-ce que le prog en fait ?3. que faut-il en faire alors (=crak)

Effectivement tu as trouvé le premier endroit …Il faut d’abord t’attarder ici et comprendre ce qui se passe.En fait ce n’est pas très compliqué.Relis mes commentaires précédents et applique la première partie à ce morceau du programme !A bientôt je suppose ;) on a encore du boulot après :)

Psyche

:0040255C 83F8F5 cmp eax, FFFFFFF5 Compare FFFFFFF5 à eax : (eax-FFFFFFF5)( Les indicateurs AF CF OF PF SF ZF sont mis à jour ), ( FFFFFFF5 : un octet avec un Bit de poids fort : c’est un chiffre négatif peut-être ? )

:0040255F 0F84B2000 je 00402617 Suite de XOR et LEA ( Contrôle de l'autorisation et jmp en GetRetrestrictions info si non autorisé.)

( Idem que plus haut, mais si je saute bien la bas, je ne me retrouverais jamais ici ...)

:00402565 50 push eax Place (sauve) eax sur la pile:00402566 6A0 push 00000001 Place (sauve) 00000001 ? sur la pile

Bon, pour cette nuit c’est raté ! vivement demain ….

SECONDE RECHERCHE. & CORRIGE

REFLEXION 1 : IL VIENT D’OU CET EAX ?

:00402551 85C0 test eax, eax PAS CELUI-LA !a) La valeur de eax est retournée après le :00402533 call 0040610A (de CRP32DLL.Initcrypkey…)b) Sa valeur est : FFFF FFFCc) FFFF FFFC signé = -4d d) le résultat du test eax, eax est ZF = 1 ?

Tu es trop haut, tu verras plus loin qu'on se fout de Initcrypkey !

( STOP A ! ) ***********************

dans le bouquin d’asm de marabout : assembleur théorie, pratique et exercices il y à l’exemple suivant :

l’instruction TEST effectue un ET logique entre les deux opérandes sans sauver le résultat, seuls les indicateurs (flags) sont modifiés.

Ex N°1 :

AX contient 83h Test ax, 81hAX contient 83hZF=0

Le résultat d’un ET logique entre 83h et 81h donne 81h, qui n’est pas nul, l’indicateur ZF(Zero flag) est donc mis à 0.

Ex N2 :

AX contient 83h Test ax, 74hAX contient 83hZF=1

Le résultat d’un ET logique entre 83h et 74h donne 0h, l’indicateur ZF(Zero flag) indiquant que le résultat d’une opération est nul est donc mis à 1.

EST-CE QU’IL N’Y A PAS UNE COQUILLE ICI ….JE PENSE QU’IL FAUT LIRE DANS L’UN DES DEUX EXEMPLES : Test ax, 83hA MON AVIS IL S’AGIT DU SECOND …->Ne te creuse pas trop pour l'instruction TEST ...Voici ce que tu dois retenir, car c'est ça que tu verras dans les prog. :Test registre, registre -> Test eax, eax : ce qui importe est de connaître la valeur de eax : si = 0 tu auras ZF=1, si <>0 ZF=0Si tu retiens ça c'est amplement suffisant ...C'est ce qui est généralement utilisé pour des retours de fonctions afin de tester si le retour est correct ou non.

DANS TON 1ER MAIL, TU PARLES DE VALEUR POSSIBLE DE FLAG -1, JE N’AI PAS CETTE POSSIBILITE DANS MON BOUQUIN ! PEUX-TU ME DONNER UN EXEMPLE QUI DONNE LA VALEUR -(MOINS 1) AU FLAG ?

ATTENTION, il y a deux sortes de flags :1. tous les registres spéciaux des processeurs x86 (CF, ZF, OF, ...) c'est du cablé et ils varient en fonction des instructions de test effectuées auparavant, bref test eax, eax -> change ZF2. on emploie le même terme mais il faudrait dire "témoin" pour la valeur renvoyée par une fonction :ex fn tesenregistréoupas ($nom, serial) renvoie par exemple une valeur en eax, cette valeur est appelée flag (comme j'ai dit c'est plutôt témoin). Dans eax on retrouve souvent une valeur booléenne oui/non. En fonction des programmeurs oui peut correspondre à 1 et non à 0, mais certains utilisent 0 pour oui et -1 (FFFFFFFFh) pour non. Voilà (tu retrouve ça entre-autre dans les API de M$ comme Regopenkey qui renvoie 0 pour OK et FFFFFFFFh si la regkey n'a pas été trouvée ...A bientôtPsyche

( FIN STOP A ) *********************

REFLEXION 2 : RELIS CE QUE JE T’AI ECRIS L’AUTRE FOIS : (ATTENTION....)

:00402553 89410C mov dword ptr [ecx+0c], eax

Ca c’est le coup traite du flag ! je reserve la valeur eax quelque part pour l’utiliser plus tard ?

donc ecx+0C reçoit eaxdonc ecx+0C reçoit FFFF FFFCdonc ecx+0C reçoit -4d

-> Impec, rien à dire ! Ca c'est essentiel... eax est non seulement testé, mais surtout stocké !!!!

( STOP B! ) *************************

Il y a un truc dans le bouquin au sujet des modes d'adressage ...basé, indexés...

exemple : mov dword ptr var1, eaxl'emplacement mémoire de var1 reçoit de contenu de eax

je pense qu'il s'agit ici d'un adressage basé.

1. adressage immédiat : MOV AH, 12h

2. adressage direct : var1 DB 2MOV AH, var1

3.adressage basé : MOV AX, word ptr [BX]

4. adressage indexé : MOV AX, word ptr [DI] aussi avec SI

Evidemment 3 et 4 se ressemblent, mais tu comprendras mieux la différence lorsqu'on les utilise ensemble : MOV AH, [BX][SI] ou MOV AH, [BX+SI]Bref, le basé fait référence aux lignes et l'indexé aux colonnes.ex : var1 DB "B O N J O U R"

var 2 DB "O R D I N A T E U R"var3 DB "L I V R E "MOV BX, offset var1MOV SI, 4

MOV AH, byte ptr [BX+SI]

Tu piges ?En fait les termes changent car ce sont soit les registres de BASE (BX) ou d'INDEX (SI, DI) qui sont utilisés et ils ont en gros des fonctions d'absices et ordonnées.

( FIN STOP B ) *********************

REFLEXION 3) QUELLE DROLE DE QUESTION …

:00402556 0F84BB0000 je 00402617

************00402617 xor esi,esi remet esi à 0

00402619 à -->00402624 transfert d’adresses d’offset dans des registres, puis sauve le contenu de ces nouvelles adresses sur la pile.

00402625 mov dword ptr [ebp-30], esi cette adresse reçoit la valeur 0000 0000

00402628 push ebx sauve ebx

00402629 mov …, esi cette adresse reçoit la valeur 0000 00000040262C mov …, esi cette adresse reçoit la valeur 0000 00000040262F xxxxxxxxxxx déjà vu !

00402634 test eax,eax test à nouveau eax. ( JE SUIS LARGUE…., BASTA L’ASM, JE RETOURNE SUR WWW. .LAMERZBIDONS ..! )

Etc … je stop net ( HI ) je vais me retrouver avec un …on s’en tape ;)

-> on s'en tape pas du tout (au contraire) mais là tu es déjà dans la 2e partie, on n'est pas encore débarassé de GetAuthorization

M’enfin, il me semble que toutes ces lignes, jusqu'à l’ordre RET, controlent et initialisent des valeurs utilisées plus tard dans le prg..

Sauf si de conditions de saut en conditions ….une idée…plus tard….

0040255C LE RETOUR DE LA VENGEANCE DU FILS N°8 ! ! !

0040255C cmp eax, FFFF FFF5 -11d

0040255F : Je remarque qu’il recommence le cinéma… du dessus …. Si je ? ? ? ? ?

PAS POSSIBLE eax = FFFF FFFC à ce moment la …

Le prob ici, c’est je n’ai pas avancé d’un poil (à mon byte…facile je sais ! ) et si je donne la valeur FFFF FFF5 à eax (je l’ai fait sous vdasm8.93), le résultat n’est pas meilleur ….

Donc le schmilblick est plus haut : ton avertissement sur l’utilisation les drapeaux me donne une idée :

Tout ce que tu as mis plus haut (Le retour de la vengeance ...) est inutile ! Mais ça (plus bas) c'est BIEN !

a) Si le prog a stocké la valeur de eax dans [ecx+0C] : Je dois trouver une ligne concernant cette adresse plus tard dans le listing.

b) Utiliser une valeur signée pour eax a certainement une excellente raison En réfléchissant (ça m’arrive encore…) je pense que la valeur -1 provient d’un TEST VALEUR SIGNEE, VALEUR SIGNEE.

Tu dis que généralement on utilise -1 pour -1 = MAUVAIS, essayons donc de renvoyer une valeur 0 ou 1Lors du test eax,eax en 00402551.

Pour cela il faut changer la valeur de eax AVANT 00402551 !

IL EST 5H30, DODO…, TETE COMME UNE CITROUILLE…HALLOWEEN ! ! ! , TOUT POSER A PLAT ET RECOMMENCER DEMAIN….

LE LENDEMAIN …

Je vais essayer d’avoir une réflexion un peu moins scolaire quant au système de protection de ce prg. (tu iras plus loin comme ça ;) )La solution n’est pas inscrite sur une ligne de codes asm …La solution est dans l’utilisation de ces codes !Si je ne me contente que de tracer, je risque de me perdre encore une fois !Essayons de réfléchir :

CRP32DLL.InitCrypkey : Le nom de cette routine parle tout seul : (d'accord mais on s'en balance, je te dirai pq après)Enfin non, je te le dis tout de suite ... l'idée de la clé cryptée est judicieuse, mais le programmeur se torpie tout seul comme un grand par l'usage de GetAuthorization, ayant une plus grande priorité. En fait, il vérifie la clé, ce qui sera un paramètre pour GetAuthorization, mais l'accès au prog. sera UNIQUEMENT fonction de ce que renverra GetAuthorization (grosse erreur !)

Routine initialisant une clé de cryptage .

CRP32DLL.GetAutorization : Idem

Routine vérifiant l’autorisation d’accès au prg, Pour cela, cette routine vérifiera les droits de l’utilisateur. A priori, par rapport à une clé. Ces droits détermineront le type d’utilisation autorisée : aucuns, limités, durée, nb fois, fonctions inhibées. Si le programmeur est un peu rusé, il va faire en sorte que cette routine ne soit pas téléphonée, qu’elle utilise plusieursContrôles, qu’elle ne se limite pas à une seule adresse à contrôler. (nb de variables ou une seule variable stockée à plusieursAdresses.-> ça pourrait être vrai mais pas ici :)

EN CONCLUSION JE DOIS :

Faire en sorte que InitCrypkey envoie une clé identifiée comme valable par GetAutorization.(NAN !) OUBluffer GetAutorization en identifiant les contrôles, en les évitant ou en inversant leurs conclusions afin que non autorisé entrez code Devienne autorisé accès programme. (OUIIIIII ! d'ailleurs retiens bien cette technique elle te sera encore utile)

Quand tu rencontre ce genre de fonctions, trace-les jusqu'au RET, regarde quel(s) registre(s) est (sont) testé(s) au retour puis retournevoir le listing et cherche les valeurs possibles pour ces registres. Traçage sous vdasm 8.93 de CRP32DLL.Initkey -> utilise SoftIce, avec WDasm, tu ne connais pas toutes les variables ...

Load process, pose de BP, Step into + Step over, surveillance de l’état des flags.

______________________________________________________* Reference To CRP32DLL.InitCrypkey

00402533 call 004061A Stepinto… 0040610A

0040610A pas d’informations exploitables à priori, eax prends la valeur 2710 puis 01D308AB.

Traçage jusqu’au retour

0040253B test eax,eax eax = 0000 0000 INTERRESSANT Z = 10040253D mov dword ptr [ecx+0C], eax INTERRESSANT : SAUVEGARDE EAX AVEC UNE VALEUR Z=1 A CETTE ADRESSE !00402540 jne 004027A Condition de non égalité

Chez moi, cette partie ne s'est pas présentée, mais je soupçonne que dans certains cas elle doit jouer des toursSi tu expérimente des problèmes par là tu pourras reprendre la même stratégie que pour GetAuthorizationL'important est qu'il renvoie 0 dans eax, ce qu'il semble faire également quand il n'y a pas de clé ...______________________________________________________

Plus loin

Reference To CRP32DLL.GetAuthorization (OK on attaque !)

00402549 call 004060FE step over INTERRESSANT : Au retour EAX = FFFF FFFC00402551 test eax,eax INTERRESSANT Z = 0 (LOGIQUE ! tu t'attendais à quoi comme résultat avec eax =FFFFFFFC ?)00402553 mov dword ptr [ecx+0C], eax INTERRESSANT : Sauvegarde EAX avec une valeur Z= 0 à cette adresse ! (pour info le fait que Z=0 n'a RIEN à voir)00402556 je 00402617

je 00402617 : Le saut ne peut pas se faire : La condition EQUAL n’est pas remplie : puisque Z = 0 maintenant alors qu’il était à Z = 1 auparavant .

0040255C cmp eax, FFFF FFF5 **** ( eax = FFFF FFFC )0040255F je 00402617 **** La condition n’est pas remplie : le saut n’est pas effectué !00402565 push eax **** On sauve eax (FFFF FFFC)00402566 push 0000 0001 **** On sauve la valeur 1, marqueur d’erreur, compteur, autre  ? je ne sais pas encore ….

A ce stade de la compétition :

Je pense avoir fait une ENORMEUHHHEU erreur dans mon précédent mail en cherchant à éviter les sauts je conditionnels !-> Exact !C’est le contraire qu’il faut faire : les forcer …. Tu as du bien rigoler … (Non ;) )En effet ces sauts envoient à une routine qui initialisent les droit d’accès !

Trop simple de remplacer un je par un jne ou cmp eax, FFFF FFF5 par cmp eax, FFFF FFFC, j’ai essayé cela ne marche pas.

Il faut donc jouer en aval et donner la possibilité à la ligne 00402553 de placer un flag z = 0

00402553 mov dword ptr [ecx+0C], eax

Je sais que lors du test de la ligne 0040253B la valeur du flag z renvoyée etait 1

La valeur de eax était alors 0000 0000 .

Dans le cour CRACK #2 de FROG’S, il explique à un moment :Virez le test ‘Eax, Eax’ et remplacez-le par un ‘Xor Eax,Eax’ (méthode la PLUS rapide pour remettre un registre a zéro), ça fait plus pro.

HE HE ! m’en fou moi d’avoir l’air pro … par contre je remettrais bien Eax à 0000 0000 !

Avant de me précipiter une petite réflexion : si j’ai raison, le je en 00402556 sera effectué ! -> BRAVO tu as trouvé !Je fini de frapper ce texte te je vais tester un Xor Eax, Eax en 00402551 à la place du Test Eax, Eax …..

Je reviens tout de suite ….

AAAARHHH , bon ok pour le saut mais je sort directement ….Tu n'as pas bien réfléchis ... je pense que FP a oublié un petit détail : c'est évidemment le patch optimal que l'on peut faire, transformer un Test eax, eax en Xor eax, eax MAIS ... allé ... y a rien qui te chiffonne ?Un peu de théorie (rapidos)Un saut conditionnel, ça a besoin de quoi pour sauter ? Ben ouais, une condition ! Et en zappant le test eax,eax elle s'est volatilisée la condition ... et c'est le résultat de la dernière condition effectuée qui est prise en compte ... (parfois ça tombe bien et parfois pas ! :( )Donc, quand tu fais ce genre de truc, n'oublie pas de forcer ton jump (s'il doit l'être évidemment)Ici le je (74h) devient jmp (0ebh)

Je ne suis pas très loin de la vérité …. D’autres contrôles doivent être fait après …Tu as déjà fait un grand pas, je te laisse paufinner cette première partie, tu sais tout maintenant et après on s'acharne sur la suite.C'est assez facile, quand tu auras fait le saut en 00402617 tu rencontrera un ami sympatique appelé GetRestrictioninfo et qui est le véritable petit frère de GetAuthorization (y a juste une toute petite subtilité et encore ... c'est même pas subtil, il faut faire un peu attention)VOILA OU J’EN SUIS ! J’HESITE A ALLER PLUS LOIN, SI JE ME SUIS TROMPE CELA NE VA QUE M’EMBROUILLER LES PINCEAUX.

J’ESPERE NE PAS TE DECEVOIR ET MERITER LES EFFORTS QUE TU VEUX BIEN M’ACCORDER.A TRES BIENTOT :-)))

Je te félicite, tu es acharné, même plus que moi ... je viens de me casser les dents sur xxxxxx.xxxxxx 3.52 (pour lequel un crack existe déjà, mais la beauté du geste, tu sais ...) et ça me prend la tête, mais c'est une autre histoire !

Garde bien toutes tes notes, car quand tu auras réussi, je te demanderai qqchose en échange du temps passé à te guider ...J'ai créé un site de crack pour les Newbies avec 2 potes rencontrés chez FP (Artex et Taz), il est encore en chantier pour le moment, mais devrait s'étoffer. La contrepartie, donc, sera un cours écrit par toi sur Systran à publier sur mon site, avec les questions, les balbutiements et tutti quanti. Bref, une véritable approche de newbie qui enrichira certainement les autres.Ceci n'est pas obligatoire et si tu ne veux pas je t'aiderai quand même jusqu'au bout, mais disons que ce serait cool :)

Voilà, j'attends ta réussite sur GetAuthorization et tes commentaires sur GetRestrictioninfo !

A +Psyche

TROISIEME RECHERCHE ET FIN

Lundi : Il faut avancer !, ma façon d’analyser ne me satisfait pas : Je dois impérativement pousser mes raisonnements sous peine de m’égarer plus encore.

Un petit retour en arrière pour comprendre mes hésitations : Au tout début, mon attention s’est uniquement portée Sur la routine CRP32DLL.InitCrypkey.

Tout neuf de mes lectures de différents tut. de crack, ignorant en ASM, je me suis précipité sur le JNE de la ligne :00402540.En effet le schéma paraissait simple : Une clé est initialisée en :00402533, elle est testée en :0040253B, si elle est bonne le saut en :00402540 ne se fait pas et le programme se lance.  ;))

Changer le JNE en JE fut ma première erreur, un message INIT OK puis une sortie directe du prg m’ont laissé croire que la solution se trouvait dans la clé. J’étais donc vacciné contre tout changement des sauts conditionnels. Dés lors je me suis acharné à vouloir changer des valeurs alors qu’il était plus simple d’inverser les contrôles de ces dernières.

J’avais de façon intuitive compris l’importance de la routine CRP32DLL.GetAuthorization, mais je continuais a vouloir forcer la condition de saut JE en :00402556 en changeant la valeur du flag Z en 0.

Plus que jamais ignorant en ASM, j’ai cru qu’un XOR Eax, Eax suffisait à remplir la condition : puisqu’il donnait la valeur 0000 0000 à Eax.

Le mail de PSYCHE me démontrera plus tard mon erreur. 8-{) :-*

J’ai donc décidé de forcer le saut par un JMP.Avant d’attaquer la suite un petit break :******************************************************************************************

J’utilise ici principalement Wdasm8.93, je ne maîtrise pas encore les fonctions de Softice ,

Sous Wd après avoir désasemblé le fichier : Menu Disassembler, / Open File to Disassemble

1) Je sauvegarde ce dernier : Menu Disassembler, / Save Disassembly Text File and Create Project File2) J’utiliserai dorénavant ce fichier.wpj : Menu Project / Open Project File.. 3) Je me prépare à le tracer : Menu Debug / Load Process4) Apparaissent plusieurs planches de contrôle ( la touche F1 pour l’aide…. ;)) )

NB : Ces planches de bord permettent la surveillance en direct d’une foule d’informations.

5) Dans la planche de droite, je patch le code désiré6) Une fois ce code patché, je retourne IMPERATIVEMENT toujours dans la planche de droite a l’adresse patchée7) J’utilise la planche de gauche pour également aller à l’adresse patchée8) De cette façon j’ai à gauche un guide, à droite le nouveau listing. CQFD9) Attention pour remplacer un JE par un JMP ( :00402556 ), tenir compte du message renvoyé par WD !

Aller patcher un NOP en :0040255B

De façon à éviter de planter WD et de devoir rebooter le PC ! pour continuer à tracer le soft.

Il faut vérifier la cohérence du listing de droite (par rapport à gauche) à chaque patch : en effet les différents codes ASM ne s’écrivent pas sur un même nombre d’octets.

Sinon on aura ça (MAUVAIS) :

A comparer avec ça (BON) :

******************************************************************************************Fin du break, en avant la musique …

* Reference To: CRP32DLL.InitCrypkey, Ord:002Ch |:00402533 E8D23B0000 Call 0040610A :00402538 8B4DF0 mov ecx, dword ptr [ebp-10]:0040253B 85C0 test eax, eax:0040253D 89410C mov dword ptr [ecx+0C], eax:00402540 0F85C4010000 jne 0040270A:00402546 6A00 push 00000000:00402548 57 push edi

* Reference To: CRP32DLL.GetAuthorization, Ord:0022h |:00402549 E8B03B0000 Call 004060FE ; le Call renvoie la valeur Eax = FFFF FFFC Z=0:0040254E 8B4DF0 mov ecx, dword ptr [ebp-10]:00402551 85C0 test eax, eax:00402553 89410C mov dword ptr [ecx+0C], eax:00402556 0F84BB000000 je 00402617 ; remplacé par JMP:0040255C 83F8F5 cmp eax, FFFFFFF5:0040255F 0F84B2000000 je 00402617

:00402565 50 push eax:00402566 6A01 push 00000001

Une fois le je 00402617 effectué, on arrive :

* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:|:00402556(C), :0040255F(C)|:00402617 33F6 xor esi, esi:00402619 8D45E0 lea eax, dword ptr [ebp-20] ; le Call renvoie la valeur Eax = 006CFAEC:0040261C 50 push eax:0040261D 8D4DEC lea ecx, dword ptr [ebp-14]:00402620 51 push ecx:00402621 8D55D0 lea edx, dword ptr [ebp-30]:00402624 52 push edx:00402625 8975D0 mov dword ptr [ebp-30], esi:00402628 53 push ebx:00402629 8975EC mov dword ptr [ebp-14], esi:0040262C 8975E0 mov dword ptr [ebp-20], esi

Une lecture rapide m’envoie rapidement à la procédure CRP32DLL.GetRestrictionInfo. (des calls, test, cmp des conditions de sauts ! ).

je décide de tracer chaque condition d’en apprendre un peu plus.

* Reference To: CRP32DLL.GetRestrictionInfo, Ord:0029h |:0040262F E8D03A0000 Call 00406104 ; Eax = FFFF FFFF :00402634 85C0 test eax, eax:00402636 0F8550010000 jne 0040278C ; le saut se fait, de step en step on sort  …:0040263C 3933 cmp dword ptr [ebx], esi ; donc inverser la condition par un JE :0040263E 7511 jne 00402651 ; idem au dessus:00402640 8B4DF0 mov ecx, dword ptr [ebp-10]:00402643 C70101000000 mov dword ptr [ecx], 00000001:00402649 897110 mov dword ptr [ecx+10], esi:0040264C E93B010000 jmp 0040278C

NB les JNE sont remplacés par des JE de façon à faciliter ma relecture, j’ai sur mon bureau une main courante sur laquelle je note les adresses patchées. Si je ne fait pas de commentaires il s’agit d’une simple inversion. Ca m’évite de tout réécrire …

Le JMP en :0040264C est inconditionnel, je laisse faire et oh bonheur ;))) un petit menu donnant accés à divers fonctions de Systran apparaît.

Fonction 1 Drapeaux : Select Language Pair Fonction 2 Translate : Translate ?Fonction 3 ? : HelpLe hic dans l’histoire c’est que je ne suis pas au bout de mes problèmes, en effet lorsque je sollicite Select Language Pair, un joli petit message apparaît.

Translate servira certainement à valider le choix de langue …

Tiens donc ! … encore une protection…..Je recommence ma lecture du listing…remonter…tracer…, quel condition amene à cette routine ? ou et que dois-je patcher ?

Au passage, un petit tour dans l’aide de Systran…

Bon, le programme propose plusieurs langues. Par défaut rien n’est initialisé, je ne crois pas qu’il s’agisse ici d’une protection, ou alors le programmeur de ce soft est vicieux, si c’était le cas il avait d’autres possibilités….

Il me faut :

1) Trouver ou est appelé le message NO LANGAGE PAIR

2) Trouver quelle routine contrôle la langue de traduction installé. ( Cela reviens au même …)

3) Je ne pense pas devoir jumper cette routine de choix de langage, il me faut installer une langue et la prochaine fois que le soft se lancera, ce test n’aura pas lieu. Je vais devoir peut-être forcer l’installation d’une langue par qq jmp, mais il faudra alors les retirer une fois ce choix initialisé.

Traçage pour la routine NO LANGAGE PAIR :

Un petit tour dans Strn Ref et l’on trouve : NO LANGAGE PAIR IS INSTALLED…..Je clic dessus et hop en ligne 0040303D

* Possible Reference to String Resource ID=32773: "No Language Pair is installed.Please consult your User's Gu" |:0040303D 6805800000 push:00403042 8D4DE8 lea ecx, dword ptr [ebp-18]:00403045 C745FC03000000 mov [ebp-04], 00000003:0040304C E8DC5C0100 call 00418D2D:00403051 8D4DE4 lea ecx, dword ptr [ebp-1C]:00403054 E8BE570100 call 00418817:00403059 8D45E4 lea eax, dword ptr [ebp-1C]:0040305C 8B55EC mov edx, dword ptr [ebp-14]:0040305F C645FC04 mov [ebp-04], 04:00403063 50 push eax:00403064 8B4A1C mov ecx, dword ptr [edx+1C]:00403067 51 push ecx

Reference To: USER32.GetParent, Ord:0115h

Etc….

Je remonte dans le listing trouve une condition en :0040302F jg 004030EC ?Je pose un BP à la ligne :00403027Je relance le soft. Arrêt bien sur au BP, je trace over et je constate que la condition jg de :0040302F n’est pas remplie, je remplace le jg par un JMP et un NOP en :00403034 ( voir plus haut ).

* Reference To: USER32.SendMessageA, Ord:01C6h |:00403027 FF154C2A4300 Call dword ptr [00432A4C]:0040302D 85C0 test eax, eax:0040302F E9B8000000 jmp 004030EC :00403034 90 nop:00403035 8D4DE8 lea ecx, dword ptr [ebp-18]:00403038 E8DA570100 call 00418817 Je relance le soft… et voilà … je vais pouvoir choisir une langue …

Si je clic sur ok, le soft se plante ! , normal non …

Je clique sur la flèche du menu …Bingo !

Une liste vide, pas de langue à choisir … Recommencer le traçage …

Le dernier JMP patché : 0040302F jmp :004030EC arrive ici :

* Referenced by a (U)nconditional or (C)onditional Jump at Address:|:0040302F(U)|:004030EC 837DDC00 cmp dword ptr [ebp-24], 00000000:004030F0 751E jne 00403110:004030F2 8B45E0 mov eax, dword ptr [ebp-20]:004030F5 8B55EC mov edx, dword ptr [ebp-14]:004030F8 6A00 push 00000000:004030FA 50 push eax:004030FB 684E010000 push 0000014E:00403100 8B4A78 mov ecx, dword ptr [edx+78]:00403103 51 push ecx:00403104 898298000000 mov dword ptr [edx+00000098], eax

…………….…………….

Au bout de pas mal d’heures infructueuses, alors que je manipulais un fichier texte de cour de crak de PYRACY.FR (http://www.geocities.com/CollegePark/Quad/3354/) sous WordPad, histoire de voir si je ne pouvais pas en tirer quelque chose, la solution est apparue !

Bon dieu ! mais c’est bien sur !

Le prog fonctionnait …explications : Quand on charge un fichier dans le tampon, le bouton Translate s’active, il suffit de cliquer dessus pour que la traduction se fasse ( dans le tampon ), dés lors il suffit de copier ce dernier dans un fichier texte tout neuf . CQFD ; -))

FIN ET GRAND MERCI A PSYCHE.

Et à toute l’équipe : le réalisateur, le perchman, ma sœur, la votre,…snif snif, je ne pensais pas être choisi par la profession….je n’ai pas préparé de discours…