************************************************************************************
* CRACKING par Tipiax *
************************************************************************************
1 - Explications sur le cracking
Salut a tous, moi je vais tenter de vous expliquer les bases du cracking. Ce cours s'adresse donc aux
débutants en la matière. Tout d'abord il faut bien mettre les choses au point : quesque le cracking ?
Eh Bien c'est simple, vous avez du remarquer que certains logiciels étaient limités a une certaine
période d'utilisation (les sharewares) ou alors que certains jeux, une fois copiés vous indiquent
que votre CD n'est pas valide ! Eh bien le but du cracking est de modifier la source du programme
pour enlever les vérifications d'authenticités.
Mais comment peut-on procéder pour réaliser une telle chose ?
Il faut tout d'abord se familiariser avec un language appellé l'assembleur (asm). Ce language est la
traduction des instructions qui sont envoyées au processeur lors de l'éxécution d'un programme. Il nous
faudra trouver dans le programme un test quelque part qui regarde si notre logiciel est REGISTER ou
si notre CD est valide dans le cas d'un jeu et il ne restera plus qu'a modifier ce test a notre convenance.
Pour pouvoir vous adonner a cette discpline qu'est le cracking il faut tout d'abord posséder un certain
nombre de logiciels. Vous aurez besoin de certains programmes indispensables. En voici une liste :
(On verra leur utilité dans ce qui va suivre)
- W32dasm - un désassembleur idéal pour débuter
- SOFTice4 - Le débugger de NuMega - INDISPENSABLE !
- Un éditeur hexadécimal tel que FxEdit ou HexWorkshop.
- Procdump
- Borland resource workshop
(essayez : http://www.crackstore.com pour les trouver)
Je vais vous expliquez l'utilité du désassembleur et du débugger par la suite mais commençons déja
par l'éditeur hexadecimal. Tout programme informatique est en fait une suite de 0 et de 1. Pour que ce soit plus
compréhensible, nous pouvons le lire en hexadecimal. L'hexadecimal est une numérotation avec une base de 16.
Mais rassurez vous, vous n'aurez pas besoin de savoir convertir les bits en hexa. Les opcodes en hexadécimal
correspondent à ce qui est envoyé réellement au processeur. Nous chercherons donc a comprendre le
fonctionnement d'un programme en regardant sa traduction en assembleur (car ce language est
compréhensible par l'homme contrairement a l'hexadécimal) puis lorsque nous aurons trouvé ou il faut agir
nous prendrons l'éditeur hexadécimal et nous modifierons ce que bon nous semble.
Il convient donc d'apprendre déjà quelques instructions et leurs correspondance en hexa.
Les plus utilisées lors de vos débuts seront les instructions de saut. Elles permettent de déplacer le pointeur
d'execution vers un endroit du programme en fonction d'une condition(cela peut aussi être un saut prédéfini).
Le saut basique est l'instruction JMP(saut prédéfini) qui correspond a EB en hexadécimal (il existe aussi E9
si le saut est plus long).
Mais la plupart des sauts rencontrés seront conditionnels. C'est à dire qu'ils sauteront si une condition
déterminée au dessus est vrai.
Par exemple le saut JE ne sautera que si les deux valeurs testées aux dessus sont égales ou valent 0.
( JE = 74 en hexa).
A l'inverse le saut JNE ne saute que lorsque les valeurs sont différentes et non égales a 0.
(JNE = 75 en hexa)
Il vous sera donc fréquent d'intervertir ces 2 sauts. Prenons un exemple : vous voulez enregistrer un
shareware a votre nom. Vous indiquez donc votre nom et un faux numéro. En traçant le programme
(voir la partie d'après) vous trouver que c'est un JE qui vous envoie a l'endroit du programme où
celui-ci indique que le code est faux par une boite de message. (genre : "INVALID REGISTRATION
CODE :!"). Vous devinez donc que ce saut est effectué seulement si votre sérial est faux. En le changeant
en un JNE les conditions se veront inversées et lorsque vous entrerez de fausses informations, le programme
croira que votre sérial est bon et ainsi vous aurez accès à toutes les fonctions du logiciel.
Rassurez vous c'est normal si vous comprenez pas encore tout cela, mais ça va venir, persévérez dans votre apprentissage.
2 - Principe de fonctionnement d'un debugger (SoftIce)
Là nous commençons les choses sérieuses. Nous allons apprendre a se servir de softice et aussi a quoi cela
va nous servir. SOFTice est donc un débugger crée par NuMega qui vaut assez cher (qui a dit que
vous deviez l'acheter :). Il faut tout d'abord que vous l'installiez convenablement. Le processus
d'installation s'est considérablement amélioré avec le temps si bien que ce sera très simple à installer.
Vous commencez donc par éxécuter le setup.exe puis vous spécifiez quel type de souris vous avez.
(ps2 ...) puis vous cliquez sur "tester" pour faire accepter votre carte graphique.
Cependant il reste une petite manipulation a ne pas oublier. Allez dans votre répertoire de SOFTice
et éditez "winice.dat" avec le bloc-note. Ensuite enlevez tous les ";" devant les EXP=!!!. Cela
permet de placer plus de breakpoints (pas de panique je vais vous expliquer ce que c'est).
Bon voila SOFTice est installé. Il vous suffit de rebooter le pc et si tout a bien fonctionné vous allez
le voir se mettre en route en même temps que windows. Il tournera en fond sans que vous vous
en rendiez compte. Pour l'appeler, rien de plus simple, faites CTRL + D .
Avant de rentrer dans les détails voyons plutôt a quoi ce programme va nous servir. Un débugger
intercepte tout le code qui est envoyé au processeur et nous le montre a l'écran quand nous le désirons.
Il nous permet aussi de tracer un programme ligne de code par ligne de code. De plus il convertit
le code hexadécimal en assembleur ce qui nous permet de comprendre comment foncionne un
programme. Un débugger permet aussi de placer des breakpoints. Un breakpoint est une chose que
l'on place a n'importe quel endroit d'un programme et qui arretera tout le système dès que cet endroit
sera lu par le processeur.
On peut placer aussi des breakpoints sur les APIs de windows. Par exemple si vous placez un breakpoint
sur l'api MessageBoxA qui permet l'affichage de boite de messages le système s'arretera dés qu'une boite
de messages fera son apparition a l'écran et SOFTice vous montrera où l'appel a cette API a été éffectuée.
Passons directement aux commandes utilisées pour faire fonctionner SOFTice :
-------------------------------------------------------------------------------------------------------------------
CTRL+D >> faire apparaitre ou disparaitre SOFTice
F5 >> Continuez l'éxécution après un breakpoint
F10 >> Tracer pas à pas (step over)
F8 >> Tracer pas à pas en rentrant dans les calls (step into)
F12 >> Revenir d'un call
-------------------------------------------------------------------------------------------------------------------
Voila pour les touches importantes. Voyons maintenant les commandes :
-------------------------------------------------------------------------------------------------------------------
Placer un breakpoint à une adresse : "bpx <adresse>" Par exemple : bpx 00405400
Voir les registres du processeur : "r"
Voir le code hexadécimal : "code on"
Voir la mémoire : "data"
Voir la liste des bpx (breakpoints) posés : "bl"
Effacer un bpx : "bc <numero>" ou numéro est le chiffre attribué au bpx
Effacer tous les bpx : "bc*"
-------------------------------------------------------------------------------------------------------------------
Voila qui devrait suffir pour le début. Pour de plus amples informations consulter le fichier
d'aide qui devrait être disponible sur le site de NuMega.
3 - Principe de fonctionnement d'un désassembleur
Le désassembleur est l'outil idéal pour débuter quand nous ne maitrisons par encore beaucoup l'asm.
Un désassembleur tel que W32dasm va lire en héxadécimal le programme a désassembler
puis convertir tout le programme en assembleur pour finalement vous afficher le résultat à
l'écran. L'avantage de W32dasm est ses "Strings Datas References". En fait ce sont des chaînes
de caractères trouvées dans le programme qui se révellent très utiles. Par exemple il n'est pas
rare de voir apparaître des phrases telles que "INVALID REGISTRATION CODE" ou encore
"THANK YOU FOR REGISTER" qui vous donnent des renseignements sur l'endroit ou nous allons agir.
Cependant le désassembleur peut paraître assez limité. Il existe des protections contre ceux-ci.
Par exemple si vous désassemblez un .exe crypté le code sera imcompréhensible (crypté par
PeShield - Aspack etc...). C'est pourquoi nous utilisons le désassembleur que lorsque le programme
à cracker est simple. Sinon l'utilisation du débugger se révèlera bien plus judicieuse.
On ne va pas s'attarder sur tout ceci car je suis sur que vous mourrez d'envie de passer a l'action.
4 - Exemple de crack: un programme(niveau débutant)
Pour apprendre il faut commencer par des programmes simples. Alors je sors mon CD de PcTeam
de ce mois (un peu de pub :) et je cherche une cible. J'ai mis longtemps à trouver un truc sympa
mais il y a un prog qui me paraît bien. Il s'appelle HD TACH et il sert a faire des benchmarks de vos
disques-durs. (je l'ai choisi car il y a un gros bouton "REGISTER" :)
On attaque donc le fichier hdtach.exe. Nous cliquons sur le gros bouton "REGISTER" puis dans name
or company nous mettons "HackerStorm" puis nous mettons un sérial bidon (beh oui nous le connaissons pas ;) et
nous cliquons enfin sur "FINISH". La réponse ne se fait pas attendre :
"Error"
"Registration code is not valid. Try again"
On se fait une copie de l'exe et nous le désassemblons avec W32dasm. Puis nous allons dans les "Strings Datas
References". Bingo nous trouvons : "Registration code is not valid. Try again". Nous cliquons dessus et
voila ce qui apparait à l'écran :
-------------------------------------------------------------------------------------------------------------------
:0046DAA8 8D85E0FEFFFF lea eax, dword ptr [ebp+FFFFFEE0]
:0046DAAE E8EDBAFDFF call 004495A0
:0046DAB3 3BD8 cmp ebx, eax
:0046DAB5 0F85CA000000 jne 0046DB85 <<<<héhé !!!!
:0046DABB 6A00 push 00000000
:0046DABD 668B0DF4DB4600 mov cx, word ptr [0046DBF4]
:0046DAC4 B202 mov dl, 02
* Possible StringData Ref from Code Obj ->"HD Tach is now registered. Write "
->"test enabled. Thank you!"
|
:0046DAC6 B830DC4600 mov eax, 0046DC30
:0046DACB E87CB6FDFF call 0044914C
:0046DAD0 8D45F0 lea eax, dword ptr [ebp-10]
:0046DAD3 50 push eax
//puis un peu plus loin:
* Referenced by a (U)nconditional or (C)onditional Jump at Address: <<<<héhé !!!!
|:0046DAB5(C)
|
:0046DB85 6A00 push 00000000
:0046DB87 668B0DF4DB4600 mov cx, word ptr [0046DBF4]
:0046DB8E B201 mov dl, 01
* Possible StringData Ref from Code Obj ->"Registration code is not valid. "
->" Try again."
|
:0046DB90 B8BCDC4600 mov eax, 0046DCBC
:0046DB95 E8B2B5FDFF call 0044914C
:0046DB9A EB0D jmp 0046DBA9
-------------------------------------------------------------------------------------------------------------------
Le saut JNE en 0046DAB5 nous met sur Registration code is not valid alors que s'il n'a pas lieu
nous avons HD Tach is now registered. Il suffit donc d'inverser le saut et ç'est bon.
Vous pouvez tester en faisant Debug -> Load Process. Faites Goto code location et mettez l'adresse
du code à modifier. Et faites ensuite Patch code. Entrez la fonction qui va remplacer l'ancienne.
Faites entrer et Apply patch. Faites ensuite Run
Ce JNE est de la forme 0F85 en hexa. Pour l'inverser nous mettrons 0F84.
Grace à notre éditeur hexadecimal, nous recherchons donc : 0F85CA0000006A00 que nous changeons en:
0F84CA0000006A00
(on rajoute 6A00 pour être sûr de trouver la bonne chaîne hexadécimale. Si vous ne comprenez
pas d'où vient cette valeur regardez dans le désassemblage en bleu)
Nous relançons, nous nous enregistrons, et ça marche il nous dit merci mais il reste un texte qui dit que nous
sommes unregistered. Il y a donc 2 vérifications.
regardons deux lignes au dessus de notre JNE :
:0046DAAE E8EDBAFDFF call 004495A0
C'est la routine qui vérifie si nous sommes registered. Cliquons dessus :
-------------------------------------------------------------------------------------------------------------------
* Referenced by a CALL at Addresses:
|:0046DAAE , :0046FE7B
-------------------------------------------------------------------------------------------------------------------
Par ceci, vous remarquez que 2 adresses appellent la procédure de vérification.
Allons donc voir à l'adresse 0046FE7B :
-------------------------------------------------------------------------------------------------------------------
:0046FE7B E82097FDFF call 004495A0
:0046FE80 3BD8 cmp ebx, eax
:0046FE82 0F85C6000000 jne 0046FF4E <<<héhé !!!
:0046FE88 BAA8FF4600 mov edx, 0046FFA8
............
-------------------------------------------------------------------------------------------------------------------
Eh oui nous avons exactement la même chose :) Le programme appelle la routine de vérification,
compare 2 valeurs puis saute en fonction de celles ci. Il suffit donc, une fois de plus
d'inverser le saut de la même façon que le premier. Avec notre éditeur hexadecimal nous
recherchons donc : 0F85C6000000BAA8 que nous changeons en:
0F84C6000000BAA8
Nous relancons le programme et celui ci nous indique que nous sommes bel et bien enregistré !
Objectif réussi ! Retour a la base.
J'espère que vous avez compris ce tutorial mais si c'est pas le cas ne passez pas au reste
sans bien avoir assimilé cette manipulation de base. En attendant nous allons voir une
autre cible mais cette fois ci nous allons utiliser SoftIce en partie car il se révèlera plus approprié.
5 - Crack de Conseal Pc FireWall
KOP m'a pourtant dit que les firewalls ne servent pas à grand chose face à un élite. Le miens me
sert pas mal et après ce crack que je viens de faire pour vous(ayant du avancer mon horloge
pour faire des tests) la période d'évaluation de Conseal Pc est terminée :-(
Il va donc falloir y remédier.
Nous lanceons le programme. Il nous affiche une boite de message informations :
"ConSeal Pc FireWall"
"The trial Period has expired..."
Nous avons dit que nous le faisions en partie avec SoftIce. Nous faisons donc CTRL+D puis
nous nous préparons en tapant ceci :
"code on"
"data"
"r" (si vous avez un vieux SoftIce)
puis nous allons mettre un breakpoint sur cette boite de message:
"bpx messageboxa"
Nous sortons de SoftIce en faisant CTRL+D. Il ne nous reste plus qu'a relancer le programme et à attendre (2 secondes :)
bingo SoftIce break. Voila ce que vous devez voir apparaître:
"break due to bpx USER!32MessageBoxA" mais si vous regardez la ligne verte au dessus il y a marqué :
------- USER32!text+322B -------
On est donc dans les apis de windows. Revenez dans le prog avec F12 (car l'api est appelée par un call)
------- FRW!text+4F0A -------
Voila c'est bon. Nous regardons l'adresse où nous nous trouvons : 00405F19 puis nous enlevons les breakpoints:
"bc*"
Nous serions tenté de le désassembler avec W32dasm, eh bien devinez quoi il, est crypté.
C'est là que va nous servir un des meilleurs programmes au monde.... j'ai nommé...... Procdump !
Ce programme est distribué en tant que freeware. Vous faites PE EDITOR et choisissez FRW.exe.
Allez dans sections. Vous voyez : WWP32 à la fin. C'est le crypteur utilisé.
Quittez tout ça et choississez "UNPACK" puis dans la liste WWPack32 puis ok.
Le firewall va se lancer, cliquez alors sur "OK" et laissez faire Procdump. ProcDump décrypte
le programme. Enregistrez le programme décrypté en frwd.exe.
Qu'aurions nous fait sans lui ?Je vous le demande :)
Nous reprenons SoftIce et nous placeons un "bpx messageboxa" mais cette fois ci nous lanceons frwd.exe
et nous regardons où est l'appel à cette boite de message. Cela a pas changé depuis tout à l'heure (ce qui montre qu'en fait
ProcDump a dumpé l'exe). Arrivé où nous sommes, nous faisons un autre F12 pour remonter car nous ne voyons pas
beaucoup de sauts conditionnels. Nous arrivons ici :
-------------------------------------------------------------------------------------------------------------------
:0041135C 6A01 push 00000001
:0041135E E846220100 call 004235A9 <<<suspect ?!
:00411363 83C404 add esp, 00000004
:00411366 8845F0 mov byte ptr [ebp-10], al
:00411369 8A45F0 mov al, byte ptr [ebp-10]
:0041136C A200EB4300 mov byte ptr [0043EB00], al
:00411371 33C0 xor eax, eax
:00411373 A004EB4300 mov al, byte ptr [0043EB04]
:00411378 85C0 test eax, eax
:0041137A 0F841C010000 je 0041149C
:00411380 33C0 xor eax, eax
:00411382 A000EB4300 mov al, byte ptr [0043EB00]
:00411387 85C0 test eax, eax
:00411389 0F842A000000 je 004113B9 <<<intéressant
:0041138F A1E4EA4300 mov eax, dword ptr [0043EAE4]
:00411394 50 push eax
:00411395 8B45F4 mov eax, dword ptr [ebp-0C]
:00411398 50 push eax
:00411399 E8354AFFFF call 00405DD3 <<<On arrive ici !!!
:0041139E 83C408 add esp, 00000008
-------------------------------------------------------------------------------------------------------------------
Regardez donc tout ça avec W32dasm. Vous verrez que le 2eme call sert seulement a afficher
des messages comme quoi la licence n'est pas bonne. Nous voyons un JE au dessus du CALL.
Habituellement, je n'attaque pas comme ceci mais comme il faut faire simple...
On va forcer ce JE en le transformant en JMP.
Il n'existe pas de JMP de la forme 0F!! mais celui qui le remplace est E9.
Nous avons donc une instruction en trop c'est pourquoi nous mettons 90 qui correspond a NOP c'est à
dire no operation. Nous recherchons donc avec notre éditeur hexadécimal :
0F842A000000A1E4EA4300 que nous modifions en:
90E92A000000A1E4EA4300
On relance le programme et cela fonctionne ! miracle. Cependant quelques secondes après le menu,
rules se grise. Nous sortons la doc des apis Win32 (vous la trouverez sur crackstore) et nous voyons
quelle API fait cela.On trouve l'API : EnableMenuItem. Voyez le commentaire par vous mêmes :
The EnableMenuItem function enables, disables, or grays the given menu item.
ça à l'air d'être cela qui s'est produit. Nous reprenons SoftIce et nous tapons :
bpx enablemenuitem
Puis nous relançons Conseal. L'api est utilisée plusieurs fois alors nous faisons F5 pour continuer jusqu'à voir
notre menu rules grisé. A l'arrivé nous trouvons ceci :
-------------------------------------------------------------------------------------------------------------------
:004114E0 33C0 xor eax, eax
:004114E2 8A45F8 mov al, byte ptr [ebp-08]
:004114E5 85C0 test eax, eax
:004114E7 0F858D000000 jne 0041157A <<<ahahah
* Possible Reference to String Resource ID=00001: "Description"
|
:004114ED 6A01 push 00000001
* Possible Ref to Menu: CONSEAL_FW, Item: "Change Ruleset File.."
|
:004114EF 68429C0000 push 00009C42
:004114F4 A1E0EA4300 mov eax, dword ptr [0043EAE0]
:004114F9 50 push eax
* Reference To: USER32.EnableMenuItem, Ord:00B0h <<<notre API
|
:004114FA FF1540874600 Call dword ptr [00468740]
* Possible Reference to String Resource ID=00001: "Description"
|
:00411500 6A01 push 00000001
* Possible Ref to Menu: CONSEAL_FW, Item: "Rules" <<<héhéhé
-------------------------------------------------------------------------------------------------------------------
Bon ici aussi il n'y a rien de plus simple. Si les informations sont fausses le programme ne saute pas
et si elles sont bonnes, il saute et notre menu reste opérationnel.
Nous recherchons donc avec notre éditeur hexadécimal :
0F858D0000006A01 que nous modifions en:
90E98D0000006A01
Décidement ils aiment bien les 0F... Bon nous relançons ! bingo ça RuLeZ. Et maintenant que nous l'avons cracké
nous allons signer notre oeuvre avec un peu de reverse engineering. Dans la barre status, il y a marqué
"Firewall is up". Nous allons le changer en "HackerStorm". C'est pas bien difficile, nous prenons notre éditeur hexa
et nous recherchons cette string. C'est la deuxième. "la première servant dans le log". Vous écrivez
HackerStorm à la place et vous effacer les lettres en trop avec des espaces.
Il reste encore quelquechose. Dans la fenêtre "about" il y a marqué :" licensed to : Trial User".
Cependant là cette string se trouve dans la base de registre:
HKEY_LOCAL_MACHINE\\security\\Signal9\\FIREWALL\\1.3\\UserName
Il suffit de mettre la valeur avec votre nom. Je vous expliquerai bien comment faire pour que cette
valeur soit toujours la même quelque soit la base de registre mais cela va devenir trop difficile
a comprendre et ce tut s'adresse aux débutants alors.... De plus cela n'a absolument aucune utilité.
C'est ici que s'achève ce tutorial sur Conseal Pc Firewall. Je suis certain que vous avez aussi envie
de cracker des jeux, donc voici un petit extra : le crack de Half-Life 1.1.0.0 :
6 - Crack de Half-Life 1.1.0.0
Petit crack en passant.
Je veux installer les bots pour counter strike. Malheureusement, il faut passer par
"nouvelle partie" dans half-life.
En faisant cela : "Veuillez insérer le CD-ROM...", fait 3 fois d'affilé.
Classique quoi.
Nous ne nous embêtons pas, nous prenons direct SOFTICE et nous plaçons un:
bpx GetDiskFreeSpaceA
C'est une api utilisée dans la détection des CD originaux.
Puis nous lançons une partie. SI apparait. Nous traçons avec F10 jusqu'à l'apparition du message.
Lorsque le message apparaît, nous faisons Ok et nous nous retrouvons de nouveau sous softice.
Nous sommes sur un call en 0040EF69 :
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
:0040EF69 E8F2D4FFFF call 0040C460
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
Cela peut nous servir et nous permet de nous situer dans le proggy.
En tracant un peu par des F12 et des F10, nous tombons la dessus:
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
:0040F05B 46 inc esi
:0040F05C 83FE03 cmp esi, 00000003
:0040F05F 0F8CC9FEFFFF jl 0040EF2E
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
Ces quelques lignes de codes permettent de faire boucler le prog 3 fois.
Comme pour vérifier s'il y a le CD.
Voila le listing complet:
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0040F05F(C)
|
:0040EF2E 8B442414 mov eax, dword ptr [esp+14]
:0040EF32 50 push eax
:0040EF33 FFD7 call edi
:0040EF35 6A00 push 00000000
:0040EF37 6A02 push 00000002
:0040EF39 8D4C2424 lea ecx, dword ptr [esp+24]
:0040EF3D E84E8F0400 call 00457E90
:0040EF42 6854010000 push 00000154
:0040EF47 C784246806000000000000 mov dword ptr [esp+00000668], 00000000
:0040EF52 E809520500 call 00464160
:0040EF57 8D4C2420 lea ecx, dword ptr [esp+20]
:0040EF5B 50 push eax
:0040EF5C 51 push ecx
:0040EF5D E8BE940400 call 00458420
:0040EF62 83C40C add esp, 0000000C
:0040EF65 8D4C241C lea ecx, dword ptr [esp+1C]
:0040EF69 E8F2D4FFFF call 0040C460
:0040EF6E 83F801 cmp eax, 00000001
:0040EF71 0F85FA000000 jne 0040F071
:0040EF77 E8847DFFFF call 00406D00 <<<<test la présence du cd
:0040EF7C 85C0 test eax, eax
:0040EF7E 0F85AF010000 jne 0040F133 <<<< saut en cas de non égalité
:0040EF84 A148CC4D00 mov eax, dword ptr [004DCC48]
:0040EF89 85C0 test eax, eax
:0040EF8B 7405 je 0040EF92
:0040EF8D E87E52FFFF call 00404210
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0040EF8B(C)
|
:0040EF92 8B542418 mov edx, dword ptr [esp+18]
:0040EF96 52 push edx
:0040EF97 FFD7 call edi
:0040EF99 68D0070000 push 000007D0
:0040EF9E FFD3 call ebx
:0040EFA0 C784246406000011000000 mov dword ptr [esp+00000664], 00000011
:0040EFAB 8D8424B8030000 lea eax, dword ptr [esp+000003B8]
:0040EFB2 89AC24B8030000 mov dword ptr [esp+000003B8], ebp
:0040EFB9 89442410 mov dword ptr [esp+10], eax
:0040EFBD 8D8C24B8030000 lea ecx, dword ptr [esp+000003B8]
:0040EFC4 C684246406000017 mov byte ptr [esp+00000664], 17
:0040EFCC E8B6A30800 call 00499387
:0040EFD1 8D8C24AC030000 lea ecx, dword ptr [esp+000003AC]
:0040EFD8 89AC24AC030000 mov dword ptr [esp+000003AC], ebp
:0040EFDF 894C2410 mov dword ptr [esp+10], ecx
:0040EFE3 8D8C24AC030000 lea ecx, dword ptr [esp+000003AC]
:0040EFEA C684246406000018 mov byte ptr [esp+00000664], 18
:0040EFF2 E890A30800 call 00499387
:0040EFF7 8D8C24A4030000 lea ecx, dword ptr [esp+000003A4]
:0040EFFE C684246406000014 mov byte ptr [esp+00000664], 14
:0040F006 E8076A0800 call 00495A12
:0040F00B 8D8C24A4020000 lea ecx, dword ptr [esp+000002A4]
:0040F012 C684246406000013 mov byte ptr [esp+00000664], 13
:0040F01A E801E60200 call 0043D620
:0040F01F 8D8C24B4010000 lea ecx, dword ptr [esp+000001B4]
:0040F026 C684246406000012 mov byte ptr [esp+00000664], 12
:0040F02E E8EDE50200 call 0043D620
:0040F033 8D8C2484000000 lea ecx, dword ptr [esp+00000084]
:0040F03A C684246406000011 mov byte ptr [esp+00000664], 11
:0040F042 E8A9150300 call 004405F0
:0040F047 8D4C241C lea ecx, dword ptr [esp+1C]
:0040F04B C7842464060000FFFFFFFF mov dword ptr [esp+00000664], FFFFFFFF
:0040F056 E805D6FFFF call 0040C660
:0040F05B 46 inc esi <<<<
:0040F05C 83FE03 cmp esi, 00000003 <<<< boucle 3 fois
:0040F05F 0F8CC9FEFFFF jl 0040EF2E <<<<
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
Mais même avant cela il y a un premier test :
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
* Referenced by a CALL at Address:
|:0040F717
|
:0040EED0 64A100000000 mov eax, dword ptr fs:[00000000]
:0040EED6 6AFF push FFFFFFFF
:0040EED8 6853024A00 push 004A0253
:0040EEDD 50 push eax
:0040EEDE 64892500000000 mov dword ptr fs:[00000000], esp
:0040EEE5 81EC4C060000 sub esp, 0000064C
:0040EEEB 53 push ebx
:0040EEEC 55 push ebp
:0040EEED 56 push esi
:0040EEEE 57 push edi
:0040EEEF E80C7EFFFF call 00406D00 <<<<appel du test
:0040EEF4 85C0 test eax, eax
:0040EEF6 0F85FB020000 jne 0040F1F7 <<<<saute si CD valide
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
Nous trouvons cette partie de code grâce a la routine de vérification trouvée avant.
En effet W32dasm donne l'endroit où ces routines sont appelées.
Pour notre patch, c'est très facile. Nous transformons :
jne 0040F1F7 <<<<saute si OK en:
je 0040F1F7 <<<<saute pour la condition inverse
pour que ce saut ait lieu et que le CD soit considéré valide.
(ps: vous auriez sans doute voulu mettre un jmp, mais cela implique d'écraser
0F par un nop (90) puis de mettre E9. Car il n'y a pas de jmp de la forme
0F .)
soit en hexa:
0F85FB020000 en 0F84FB020000 a l'offset EEF6h (cf barre des taches de W32dasm)
Tout pourrait aller pour le mieux mais non. Il y a une protection de forme checksum :
"Half-Life"
"l'éxecutable d'half-life a subit une modification..."
Voila comment est se qu'il nous accueil!
Nous reprennons softice et nous plaçons ceci:
bpx MessageBoxA
Nous relançons et il break. Un petit F12 et nous revoila dans HL.EXE en 0049A9E6 :
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
:0049A9D8 53 push ebx
:0049A9D9 57 push edi
:0049A9DA FF7508 push [ebp+08]
:0049A9DD FF75F4 push [ebp-0C]
* Reference To: USER32.MessageBoxA, Ord:01BEh
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
Deux autres petits F12 sous Softice pour remonter et voila ce que nous avons:
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
:0042258B 7420 je 004225AD <<<<lorsque tout est OK, il fait un saute et continue
:0042258D 6A00 push 00000000
:0042258F 6A30 push 00000030
:00422591 68D9010000 push 000001D9
:00422596 E8C51B0400 call 00464160
:0042259B 83C404 add esp, 00000004
:0042259E 50 push eax
:0042259F E871840700 call 0049AA15
:004225A4 E8C7160000 call 00423C70 <<<<là il affiche l'erreur
:004225A9 33C0 xor eax, eax
:004225AB EB05 jmp 004225B2
¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
Il suffit donc de modifier :
je 004225AD en:
Jmp 004225AD
Soit en Hexa a l'offset 2258Bh :
7420 en EB20
Pour résumer : première solution:
offset EEF7h : 84 (décimal: 61175 - 132)
offset 2258Bh : EB (décimal: 140683 - 235)
deuxième solution plus convenable: (avec jmp, voir plus haut)
offset EEF6h : 90 (décimal: 61174 - 144)
offset EEF7h : E9 (décimal: 61175 - 233)
offset 2258Bh : EB (décimal: 140683 - 235)
Vraiment c'est pas très difficile. Je l'ai d'ailleurs cracké pour un pote qui ne m'en croyait
pas capable ! héhé. Half-Life RuLeZ.
ps: n'ayez pas peur de cracker des jeux, ce n'est pas plus compliqué :)
ps2: Half-Life est le meilleur jeu ! je vous le dis.
FIN
J'ai un petit message à passer : Mist va te faire enculer ! et emmène tout #crack.fr avec toi