T.C.T

TCT
ThreaT Cracking Tutorial

Niveau: Novice expérimenté
Soft étudié: WS_Ping Propack
Type de protection: Time limit + Nag

Outil: Wdasm 8.9, Hex Workshop

WS_Ping ProPack

Le but de ce tutorial n'est pas de vous apprendre a cracker un soft.

le but de ce tutorial est de vous apprendre a raisonner, analyser et reagir en fonction des problemes que vous pourrez rencontrer lors de debuging, patch, analyse de pile, et autre ennuye qui fond le piment de la vie de tout cracker (et codeur pro).

donc, nous allons nous adonner a un cours ou l'Asm (Language des dieux) seras de rigeurs!

Allons y docteur....

WsPing Pro Pack:
Ws est un soft de traitemment IP largemment utiliser a travers la communauter underground.
etant l'un des plus puissant, nous avons decider d'allier l'utile a l'agreable en etudiant au grands complet sont schema de protection, et pouvoir ainsi agir en consequence!

1/installation du soft:
L'installation de ws est rapide et fiable, durant celle si, il est preciser que la version est en "Complete" mais limiter dans le temp!
(Je sens qu'on vas encore etre obliger de cracker)

2/Utilisation
Lors de la 1ere utilisation du soft, un Nag apparait nous felicitant de l'avoir installer, mais celui si nous precise bien que nous n'avons 30 Jours pour le tester (Et pas un de plus)

3/Observation du sujet dans son milieu naturel
Apres le 1er nag de felicitation d'installation, le soft reagit et marche normalemment.
en faisant un tour dans About, nous observons qu'aucun serial / cle de debridage n'est a inserer, donc aucune routine
n'est prevue pour unlocker le soft! iL faut achetter une version complete pour pouvoir jouir de ces possibilter aussi
longutemp que l'on veut.
Si l'on essaye de finter en changeant la date systeme pendent que le soft et en marche, nous pouvont voir que les fonction
ne marche plus! (sa ne vas pas vous faciliter la tache)
toujours en changeans la date, nous observont l'apparition d'un Nag sur les dernier jours nous disans "Attention, il ne reste plus que 2 jours! magner vous de sortir le chequier :)"
et bien sur, le dernier jour arrivant, un Death Nag (nag qui tue) vous envoye une grosse bach a travers la tronche et ferme le soft vous obligeant ainsi a aller telecharger une version complete moyennant finance.
Bien ententu, il est possible de remettre le soft en service en reculant la date systeme, mais bon!

4/Premier test, et observation
Avant de ce lancer dans la savane de l'asm pour traquer la mechante protection qui sevit sur le territoire, il est toujours nessessaire de tester les truc a la con (Fichier .ini, Base de registre, etc...), car parfois on trouve vraiment des truc bidon comme Claris Homepage ou meme le jeu Bomberman!

en jetan un oeil dans le repertoire de notre animal, nous pouvons voir un fichier appeler "Wspingpr.key" contenant les donner suivante:

-----------------------------------------
[WSPingPR]
name=Evaluation
address1=.
address2=
address3=
city=.
state=.
zip=.
country=.
company=
phone=.
fax=
email=sales@ipswitch.com
vendor=Ipswitch, Inc.
vaddress1=81 Hartwell Avenue
vaddress2=
vaddress3=
vcity=Lexington
vstate=MA
vzip=02421
vcountry=USA
vphone=(781) 676-5700
vfax=(781) 676-5710
vwww=http://www.ipswitch.com/
vemail=info@ipswitch.com
product=WS_Ping ProPack
create date=20000323 21:11
expire date=April 22, 2000
expiration=2000113
key=37C3A19C8C20268FE806502372454DA2
Executed=15
-------------------------------------

Interressant non?

Observons ce fichier:
Celui si contient plusieur champ qui attire particulierement l'oeil agard du tracker

name=Evaluation
create date=20000323 21:11
expire date=April 22, 2000
expiration=2000113
key=37C3A19C8C20268FE806502372454DA2

Apparemment, celui si contient tout ce qui nous interresse!
Seulemment voila, le sanctuaire est garder par serber, le chien a 3 tete qui encrypte tout comme un salaud, car la mantion
KEY et bien une clé calculer celon les donner contenu dans le fichier qui verifie si celui si n'a pas ete modifier!
et celle si est calculer celon un algorithme specifique et crypter (le gros truc a constiper un mangeur d'huitre morte)

Mais bon, comme on est un peu naif, on vas quand meme tanter en chageant le expire Date.

on relance le soft :)

Vous n'avez quand meme pas cru que sa allait marcher?

Bon, apparemment une routine appeller "Security Check" serait le garde du corp de notre gibier.
on note sa dans un coin de notre tete, et on continu...

Maintenant on arrete de rigoler, et on sort l'artillerie Lourde...

miam miam

Let's Go To Da OverTrack !

aller, on sort le dessassembleur, et on déasm (desassemble) le fichier wspingpr.exe, et on arrive sur le territoire du grand loup!

separement, on lance wsping (apres la date limite) et on optient ceci

hum, interressant.

allons faire un tour sous notre debuggeur, et jeton un oeil aux Data String Reference

tien! nous remarquons aux ID 30006, 30007 et 30008 toute les phrase des nags chiant! de plus 30009 30010 et 30011 contiennent des strings security check! ce qui nous laisse a penser que tout le schema de protection ce trouve ici.

bon, jeton un coup d'oeil sur le code des nag chiant :

* Reference To: KERNEL32.GetPrivateProfileStringA, Ord:00FFh
|
:0040285C FF15D4D94700 Call dword ptr [0047D9D4]
:00402862 8D45AC lea eax, dword ptr [ebp-54]
:00402865 50 push eax
:00402866 8B859CFAFFFF mov eax, dword ptr [ebp+FFFFFA9C]
:0040286C 50 push eax
:0040286D E8FEF30300 call 00441C70
:00402872 83C408 add esp, 00000008
:00402875 85C0 test eax, eax
:00402877 0F85A4010000 jne 00402A21
:0040287D 8B4514 mov eax, dword ptr [ebp+14]
:00402880 50 push eax
:00402881 8B4510 mov eax, dword ptr [ebp+10]
:00402884 50 push eax
:00402885 E899F8FFFF call 00402123                             ; Ha, voici notre procedure qui vas jeter un oeil a la date
:0040288A 83C408 add esp, 00000008                             ;
:0040288D 85C0 test eax, eax                                            ; une application de masque pour voir si eax = 0
:0040288F 0F8418000000 je 004028AD                          ; si oui, il saute pour initialiser ebp-04 a 0
:00402895 8B4514 mov eax, dword ptr [ebp+14]             ; bha sinon, la date et apparemment correct
:00402898 50 push eax                                                      ; donc il sauve eax sur la pile
:00402899 8B4510 mov eax, dword ptr [ebp+10]            ; il lui rajoute une valeur
:0040289C 50 push eax                                                      ; puis il la ressauve
:0040289D E88CF9FFFF call 0040222E                           ; la a mon avis, il va tester la 1er et la 2eme sauvegardes
:004028A2 83C408 add esp, 00000008                            ; pour voir si on a pas finter
:004028A5 8945FC mov dword ptr [ebp-04], eax            ; et Tac, on met ebp-04 a la bonne valeur
:004028A8 E907000000 jmp 004028B4                            ; puis hop, il saute pour voir quel nag il vas bien pouvoir afficher

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0040288F(C)
|
:004028AD C745FC00000000 mov [ebp-04], 00000000       ; ici c'est l'initialisation de ebp-04 si eax =/ 0

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004028A8(U)
|
:004028B4 837DFC01 cmp dword ptr [ebp-04], 00000001     ; donc la, il compart notre date avec 1
:004028B8 0F8D8A000000 jnl 00402948                                  ; si ce n'est pas inferieur, c'est que c'est
:004028BE 6800040000 push 00000400                                    ; pas le bon nag donc, il saute
:004028C3 8D85A0FBFFFF lea eax, dword ptr [ebp+FFFFFBA0]
:004028C9 50 push eax

* Possible Reference to String Resource ID=30006: "Thank you for evaluating %1!s!.
This evaluation started %2!s"
|
:004028CA 6836750000 push 00007536                                 ; Hop, si eax n'est pas inferieur a 1
:004028CF E86CDC0300 call 00440540                               ; c'est que la date d'expiration et terminer
:004028D4 83C40C add esp, 0000000C                                 ; donc il affiche le nag
:004028D7 B8B0AC4700 mov eax, 0047ACB0
:004028DC 05AA020000 add eax, 000002AA
:004028E1 50 push eax
:004028E2 B8B0AC4700 mov eax, 0047ACB0
:004028E7 05E8020000 add eax, 000002E8
:004028EC 50 push eax
:004028ED 68B0AC4700 push 0047ACB0
:004028F2 B8B0AC4700 mov eax, 0047ACB0
:004028F7 05AA020000 add eax, 000002AA
:004028FC 50 push eax
:004028FD 8D85A0FBFFFF lea eax, dword ptr [ebp+FFFFFBA0]
:00402903 50 push eax
:00402904 8B859CFAFFFF mov eax, dword ptr [ebp+FFFFFA9C]
:0040290A 50 push eax
:0040290B E8BEDC0300 call 004405CE
:00402910 83C418 add esp, 00000018
:00402913 8B859CFAFFFF mov eax, dword ptr [ebp+FFFFFA9C]
:00402919 50 push eax
:0040291A 6A10 push 00000010
:0040291C 8B4508 mov eax, dword ptr [ebp+08]
:0040291F 50 push eax
:00402920 E8FDF5FFFF call 00401F22
:00402925 83C40C add esp, 0000000C
:00402928 8B45A0 mov eax, dword ptr [ebp-60]
:0040292B 50 push eax

* Reference To: KERNEL32.LocalUnlock, Ord:0188h
|
:0040292C FF15C0D94700 Call dword ptr [0047D9C0]
:00402932 8B45A0 mov eax, dword ptr [ebp-60]
:00402935 50 push eax

* Reference To: KERNEL32.LocalFree, Ord:0182h
|
:00402936 FF15B8D94700 Call dword ptr [0047D9B8]
:0040293C 33C0 xor eax, eax
:0040293E E9C4010000 jmp 00402B07
:00402943 E9D4000000 jmp 00402A1C

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

si plus haut eax > 1 c'est que le time d'expiration n'est pas terminer
donc on ce retrouve sur cette portion de code
ps: [ebp-04] = eax

:00402948 837DFC01 cmp dword ptr [ebp-04], 00000001          ; comme tout a l'heure, il compare la date a 1
:0040294C 0F855F000000 jne 004029B1                                     ; seulement la, il saute si ce n'est pas egal
:00402952 6800040000 push 00000400
:00402957 8D85A0FBFFFF lea eax, dword ptr [ebp+FFFFFBA0]
:0040295D 50 push eax

* Possible Reference to String Resource ID=30007: "Thank you for evaluating %1!s!.
Your evaluation copy will ex"
|
:0040295E 6837750000 push 00007537                                        ; mais si c'est egal, c'est qu'il ne reste plus qu'un jour
:00402963 E8D8DB0300 call 00440540                                        ; donc, il nous affiche le nag qui nous dit qu'il ne reste
:00402968 83C40C add esp, 0000000C                                       ; plus qu'un jour (hé hé, logique)
:0040296B B8B0AC4700 mov eax, 0047ACB0
:00402970 05AA020000 add eax, 000002AA
:00402975 50 push eax
:00402976 B8B0AC4700 mov eax, 0047ACB0
:0040297B 05AA020000 add eax, 000002AA
:00402980 50 push eax
:00402981 8D85A0FBFFFF lea eax, dword ptr [ebp+FFFFFBA0]
:00402987 50 push eax
:00402988 8B859CFAFFFF mov eax, dword ptr [ebp+FFFFFA9C]
:0040298E 50 push eax
:0040298F E83ADC0300 call 004405CE
:00402994 83C410 add esp, 00000010
:00402997 8B859CFAFFFF mov eax, dword ptr [ebp+FFFFFA9C]
:0040299D 50 push eax
:0040299E 6A30 push 00000030
:004029A0 8B4508 mov eax, dword ptr [ebp+08]
:004029A3 50 push eax
:004029A4 E879F5FFFF call 00401F22
:004029A9 83C40C add esp, 0000000C
:004029AC E96B000000 jmp 00402A1C

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

la, si le code du dessus nous revelle que ebp-04 alias eax alias notre date
n'est pas egal a 1, on ce retrouve sur cette portion de code si

:004029B1 837DFC08 cmp dword ptr [ebp-04], 00000008               ;comme toujours il recompart, mais cette fois avec 8
:004029B5 0F8D61000000 jnl 00402A1C                                         ;et hop, il saute si ce n'est pas inferieur
:004029BB 6800040000 push 00000400
:004029C0 8D85A0FBFFFF lea eax, dword ptr [ebp+FFFFFBA0]
:004029C6 50 push eax

* Possible Reference to String Resource ID=30008: "Thank you for evaluating %1!s!.
Your evaluation copy will ex"
|
:004029C7 6838750000 push 00007538                                          ; bha sinon, il nous affiche un nag qui nous dit
:004029CC E86FDB0300 call 00440540                                        ; qu'il faut sortir la CB
:004029D1 83C40C add esp, 0000000C
:004029D4 B8B0AC4700 mov eax, 0047ACB0
:004029D9 05AA020000 add eax, 000002AA
:004029DE 50 push eax
:004029DF 8B45FC mov eax, dword ptr [ebp-04]
:004029E2 50 push eax
:004029E3 B8B0AC4700 mov eax, 0047ACB0
:004029E8 05AA020000 add eax, 000002AA
:004029ED 50 push eax
:004029EE 8D85A0FBFFFF lea eax, dword ptr [ebp+FFFFFBA0]
:004029F4 50 push eax
:004029F5 8B859CFAFFFF mov eax, dword ptr [ebp+FFFFFA9C]
:004029FB 50 push eax
:004029FC E8CDDB0300 call 004405CE
:00402A01 83C414 add esp, 00000014
:00402A04 8B859CFAFFFF mov eax, dword ptr [ebp+FFFFFA9C]
:00402A0A 50 push eax
:00402A0B 6A40 push 00000040
:00402A0D 8B4508 mov eax, dword ptr [ebp+08]
:00402A10 50 push eax
:00402A11 E80CF5FFFF call 00401F22
:00402A16 83C40C add esp, 0000000C
:00402A19 FF45A8 inc [ebp-58]

* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:00402943(U), :004029AC(U), :004029B5(C)

:00402A1C E964000000 jmp 00402A85     ; ben la, si la date est superieur a 8 jour, c'est que vous etes en plein dans votre
                                                                     ; droit, donc, celui si n'affiche pas de nag et vous laisse utiliser le soft                                                                        ; normalemment

simple non?
sa ce lit comme dans un livre ouvert :)

bon apres le cours de lecture, nous allons passer au cours d'ecriture, alors, a votre avis? comment pourait on reecrire
ce code afin qu'il pense que nous somme en plein dans notre temp de test?
aller je vous aide, jeter un oeil seulemment sur ces lignes

:0040288D 85C0 test eax, eax
:0040288F 0F8418000000 je 004028AD
:00402895 8B4514 mov eax, dword ptr [ebp+14]

:004028AD C745FC00000000 mov [ebp-04], 00000000

:004028B4 837DFC01 cmp dword ptr [ebp-04], 00000001
:004028B8 0F8D8A000000 jnl 00402948

:00402948 837DFC01 cmp dword ptr [ebp-04], 00000001
:0040294C 0F855F000000 jne 004029B1

:004029B1 837DFC08 cmp dword ptr [ebp-04], 00000008
:004029B5 0F8D61000000 jnl 00402A1C

:00402A1C E964000000 jmp 00402A85

je vous l'accorde, il y a plusuieur solution, mais jouons la gentleman!
nous allons faire les petit filou en retournant a notre chere procedure de test qu'il nous reste toujours disons 10 jours.
sachant que les nag ne nous font chier que jusqu'a 8 (cmp dword ptr [ebp-04], 00000008), nous allons forcer le
test a sauter sur l'initialisation de ebp-04, mais au lieu de l'initialiser a 0, nous allons l'initialiser a 10 :)

aller hop! on test sa et ho trop!

pour cela, nous allons utiliser le debuggeur de wdasm, miam miam

on click sur "debug", "load process"!
le debuggeur ce lance :)
ensuite on vas dans "Goto", "Code location" et on met le code que l'on veut patcher, en locurence 40288F
on fait un CTRL+click a gauche de l'adresse, et la ligne et surligner en jaune (c'est que le breakpoint a ete correctemment appliquer).
bon une foit ceci fait, on click sur RUN (wsping est executer en memoire) et hop, le programme s'arrette a 40288F.
maintenant, on click sur "Patch code" et on patch de la facon suivante

newbie: "pourquoi tu fait suivre ton code de plusieur nop?? on s'en fou vue que tu force le jump?"

tres simple, on fait suivre le jump de nop car a l'adresse 40288f, l'instruction "je 004028AD" tiens sur 6 octets (0F8418000000), alors que notre code ne tien que sur 2 octets (EB1C).
donc, pour faire plus propre et eviter les erreurs EIP lié a un mauvais patchage, nous remplacons les 6 octet!
mais comme notre code n'en tiens que 2, on comble par des NOP (No OPeration).
bon, si vous n'avez pas compris c'est pas grave, car la on force un jump, mais si vous patcher du code afin de fausser un
calcule (comme nous allons le faire plus loin) vous verrez que c'est assez important. Passons...

donc voila! le premier patch est appliquer, voyons dans notre schema de protection ce qu'il nous reste a faire

:0040288D 85C0 test eax, eax
:0040288F EB1C90909090 jmp 4028AD                           ; on a patcher a ce niveau la :)
:00402895 8B4514 mov eax, dword ptr [ebp+14]

:004028AD C745FC00000000 mov [ebp-04], 00000000     ;donc logiquement, on retombe ici!
                                                                                              ;mais au lieu d'initialiser [ebp-04] a 0, nous voulons
                                                                                               ;que celui si soit initialiser a 10

:004028B4 837DFC01 cmp dword ptr [ebp-04], 00000001 ; et normalemment, toute ces conneries devrait etre
:004028B8 0F8D8A000000 jnl 00402948 ; bypasser :)

:00402948 837DFC01 cmp dword ptr [ebp-04], 00000001
:0040294C 0F855F000000 jne 004029B1

:004029B1 837DFC08 cmp dword ptr [ebp-04], 00000008
:004029B5 0F8D61000000 jnl 00402A1C

:00402A1C E964000000 jmp 00402A85 ; du moin jusqu'ici

hop, une fois qu'on a patcher le premier, on fait "apply patch", "ok","ok", et on appyue sur F7 (step over), on arrive alors
sur la ligne suivante:
mov [ebp-04], 00000000

on repatch comme tout a l'heure en cliquant sur "patch code", et on patch de la facon suivante
mov [ebp-04], 00000010

bon aller, on test tout sa!

on appuie sur RUN ou F9, et que ce passe t'il?
Ben, rien...

En faite si :), grace a notre petit tour de force, le nag chiant qui nous dit qu'on a depasser la date limite n'apparait pas!
seulemment le soft ne ce lance pas, ce qui veut dire que le soft est predeterminer a etre fermer avant meme l'apparition
du nag :(, il vas donc falloir partir a la recherche de cette instruction...

afin d'etre sur de prendre le probleme a la base, nous allons rechercher l'API qui ce charge du temp systeme afin de voir comment celle ci reagit. les API qui nous interresse sont getsystemtime, et getlocaltime!

sitot dit sitot fait, on click sur "Search", "find text" et on met "getlocaltime", et bout de 2 "find next", on tombe sur ce code

* Reference To: KERNEL32.GetLocalTime, Ord:00E2h                                ;voici notre Api qui vas prendre la date local
|
:00441EDC FF1524D84700 Call dword ptr [0047D824]
:00441EE2 8D4C2404 lea ecx, dword ptr [esp+04]
:00441EE6 51 push ecx

* Reference To: KERNEL32.GetSystemTime, Ord:0121h                           ;et voici l'API qui vas prendre la date systeme
|
:00441EE7 FF1520D84700 Call dword ptr [0047D820]
:00441EED 668B0DBAA84700 mov cx, word ptr [0047A8BA]                 ;apparement celle ci est stocker
:00441EF4 66394C240E cmp word ptr [esp+0E], cx
:00441EF9 753C jne 00441F37
:00441EFB 66A1B8A84700 mov ax, word ptr [0047A8B8]                      ;dans une adresse memoire
:00441F01 663944240C cmp word ptr [esp+0C], ax
:00441F06 752F jne 00441F37
:00441F08 66A1B6A84700 mov ax, word ptr [0047A8B6]                      ;commancent par 47A8B
:00441F0E 663944240A cmp word ptr [esp+0A], ax
:00441F13 7522 jne 00441F37
:00441F15 66A1B2A84700 mov ax, word ptr [0047A8B2]
:00441F1B 6639442406 cmp word ptr [esp+06], ax                                 ;et subit des tests bit par bit
:00441F20 7515 jne 00441F37
:00441F22 66A1B0A84700 mov ax, word ptr [0047A8B0]
:00441F28 6639442404 cmp word ptr [esp+04], ax
:00441F2D 7508 jne 00441F37
:00441F2F 8B15A8A84700 mov edx, dword ptr [0047A8A8]
:00441F35 EB46 jmp 00441F7D

;Tout ceci est tres interressant, mais au lieu de fausser 2 pages de codes, concentrons nous sur les dernieres fonction
;qui serons remvoyer lors de l'appelle de procedure time!

:allons directemment au RET le plus proche situer a l'adresse 441FD0

* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:00441EF9(C), :00441F06(C), :00441F13(C), :00441F20(C), :00441F2D(C)
|
:00441F37 8D442424 lea eax, dword ptr [esp+24]
:00441F3B 50 push eax

* Reference To: KERNEL32.GetTimeZoneInformation, Ord:0133h ; sa on s'en fou...
|
:00441F3C FF151CD84700 Call dword ptr [0047D81C]
:00441F42 BA01000000 mov edx, 00000001
:00441F47 83F802 cmp eax, 00000002
:00441F4A 740C je 00441F58
:00441F4C 48 dec eax
:00441F4D BA00000000 mov edx, 00000000
:00441F52 83F801 cmp eax, 00000001
:00441F55 83D2FF adc edx, FFFFFFFF

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00441F4A(C)
|
:00441F58 8D4C2404 lea ecx, dword ptr [esp+04]                            ; sa aussi on s'en fou...
:00441F5C BEB0A84700 mov esi, 0047A8B0
:00441F61 8915A8A84700 mov dword ptr [0047A8A8], edx
:00441F67 8B01 mov eax, dword ptr [ecx]
:00441F69 8906 mov dword ptr [esi], eax
:00441F6B 8B4104 mov eax, dword ptr [ecx+04]
:00441F6E 894604 mov dword ptr [esi+04], eax
:00441F71 8B4108 mov eax, dword ptr [ecx+08]
:00441F74 8B490C mov ecx, dword ptr [ecx+0C]
:00441F77 894608 mov dword ptr [esi+08], eax
:00441F7A 894E0C mov dword ptr [esi+0C], ecx

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00441F35(U)
|
:00441F7D 8B442420 mov eax, dword ptr [esp+20]                    ; on s'en fou toujours...
:00441F81 52 push edx
:00441F82 25FFFF0000 and eax, 0000FFFF
:00441F87 50 push eax
:00441F88 33C0 xor eax, eax
:00441F8A 668B442426 mov ax, word ptr [esp+26]
:00441F8F 50 push eax
:00441F90 8B442428 mov eax, dword ptr [esp+28]
:00441F94 25FFFF0000 and eax, 0000FFFF
:00441F99 50 push eax
:00441F9A 33C0 xor eax, eax
:00441F9C 668B44242A mov ax, word ptr [esp+2A]
:00441FA1 50 push eax
:00441FA2 33C0 xor eax, eax
:00441FA4 668B44242A mov ax, word ptr [esp+2A]
:00441FA9 50 push eax
:00441FAA 8B44242C mov eax, dword ptr [esp+2C]
:00441FAE 25FFFF0000 and eax, 0000FFFF
:00441FB3 50 push eax
:00441FB4 E817440000 call 004463D0                                                ;STOP, sa devient interressant
:00441FB9 8B8C24F0000000 mov ecx, dword ptr [esp+000000F0] ;ecx est mis a une valeur
:00441FC0 83C41C add esp, 0000001C
:00441FC3 85C9 test ecx, ecx                                              ; tiens bizzard, si ecx = 0 on ce casse de la fonction
:00441FC5 7402 je 00441FC9
:00441FC7 8901 mov dword ptr [ecx], eax                          ;sinon ecx est initialiser a eax

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00441FC5(C)
|
:00441FC9 5E pop esi
:00441FCA 81C4CC000000 add esp, 000000CC
:00441FD0 C3 ret

passons en observation!
nous allons regarder comment reagit cette portion de code

:00441FB4 E817440000 call 004463D0
:00441FB9 8B8C24F0000000 mov ecx, dword ptr [esp+000000F0]
:00441FC0 83C41C add esp, 0000001C
:00441FC3 85C9 test ecx, ecx
:00441FC5 7402 je 00441FC9
:00441FC7 8901 mov dword ptr [ecx], eax

afin de determiner si ecx doit etre egal ou non a 0 pour pouvoir entrer dans notre soft!

aller hop! "debug", "load process", ptit BP sur 441FB9 et RUN.
le soft s'arrete sur le BreakPoint.

on click sur Step over plusieur fois...

tak, on remarque que le saut n'a pas operer, vue que l'on est passer de je 00441FC9 a mov dword ptr [ecx], eax.

donc, il faut que ecx = 0 pour que le soft soit considerer dans le bon time limite......
....ben qu'est ce que vous attender, il faut patcher, aller go!

nous allons patcher a l'adresse 441FB9 comme suit:

tiens! vous avez vue, j'ai rajouter 2 NOP apres le patch, mais pourquoi?
comme je l'ai dit plus haut nous allons remplacer une instruction qui comporte 7 octets (8B8C24F0000000)
par une instruction qui n'en comporte que 5 (B900000000).
pour pallier a ce manque, et etre sur que le patch colle bien, il faut imperativemment que celui si comporte le meme
nombre d'octet que l'instruction remplacer. d'ou l'interet de rajouter des NOP
les nop sont des instructions qui font un octet, et qui n'execute occune interpelation processeur.

voyons ce qu'il ce serait passer si un cracker debutant avait homi de combler le manque par des NOP

tiens! un probleme at EIP 441FBE? mais, ce ne serait pas l'instruction qui suit celle que l'on vient de patcher?
bizzars non?

j'espere que vous aver compris pourquoi il faut rajouter des nop lorsque l'instruction de patch n'est pas de taille.

fermons la paranthese, et revenons a notre moutons.

une foit le patch bien appliquer (avec les nop) on click sur RUN.

la, on voit apparaitre le nag chiant que l'on a patcher tout a l'heure (ce nag a ete patcher en memoire, c'est pour cela
que celui si reaparrait) et tak, ho joie, le soft ce lance :)

hé hé, oui mai non!
le soft ce lance, c'est bien, mais allons faire un tour dans une de ces fonction, par exemple sur scan...
on lance le scanner, et oups, on revient sous windasm (embetant sa) on appuye sur f9, mais non, sa revient sous dasm!
Merde fait chier! on desactive le BP, on scan, ben non, la fonction ne marche pas :(
chié, changeons de fonction pour voir...
on essaye de ce pinger sur 127.0.0.1, ben nan, sa marche pas!
en faite, nous venons de changer une valeur de temps dans l'API, mais cette valeur et aussi utiliser par les fonctions du soft,
car comme on a pris pour cible un soft de traitemment d'ip, celui si ce refere sur les temps pour pouvoir fonctionner!
ce qui fait que notre patch fausse tout les calculs

donc on c'est taper tout sa pour rien :(

vous etes content hein :)

vous venez de vivre en direct live une crise de cracker ;)

Mais bien sur, telle un chat, vous retomber toujours sur vos patte! la protetion a gagner une battaille, mais elle n'a pas gagner la guerre, une flamme de resistance s'allume dans vos yeux, et prennant votre courage a la main droite, et votre desassembleur a la main gauche, vous reparter traquer la bete, un combat spirituelle, qui ne s'arreteras que quand le soft seras cracker...

arretons de dire des conneries et repartons y...

bon, ben la, on est tomber sur le cul!
mais attend? n'y a t'il pas quelque chose a laquelle nous ne nous aurions pas interresser? si bien sur, le "SecurityCheck"
rappeller vous au debut :) l'ID 30011!

aller go, on y jette un oeil

* Referenced by a CALL at Addresses:
|:0043EEC5 , :0043EF9A
|
:004025B9 55 push ebp
:004025BA 8BEC mov ebp, esp
:004025BC 81EC64050000 sub esp, 00000564
:004025C2 53 push ebx
:004025C3 56 push esi
:004025C4 57 push edi
:004025C5 6800010000 push 00000100
:004025CA 8D85A0FAFFFF lea eax, dword ptr [ebp+FFFFFAA0]
:004025D0 50 push eax

* Possible Reference to String Resource ID=30011: "Security Check"
|
:004025D1 683B750000 push 0000753B
:004025D6 E865DF0300 call 00440540
:004025DB 83C40C add esp, 0000000C
:004025DE 6A5C push 0000005C
:004025E0 8B4510 mov eax, dword ptr [ebp+10]
:004025E3 50 push eax
:004025E4 E827FC0300 call 00442210
:004025E9 83C408 add esp, 00000008
:004025EC 85C0 test eax, eax
:004025EE 0F8581000000 jne 00402675
:004025F4 6A2F push 0000002F
:004025F6 8B4510 mov eax, dword ptr [ebp+10]
:004025F9 50 push eax
:004025FA E811FC0300 call 00442210
:004025FF 83C408 add esp, 00000008
:00402602 85C0 test eax, eax
:00402604 0F856B000000 jne 00402675
:0040260A 6804010000 push 00000104
:0040260F 68D8124700 push 004712D8
:00402614 8B450C mov eax, dword ptr [ebp+0C]
:00402617 50 push eax

Je vous rassure tout de suite, on va pas analyser tout sa, nous allons plutot nous interresser a ce qui ecrit en rouge, c'est
a dire aux fonction qui font appelle a la fonction

|:0043EEC5 , :0043EF9A

adonnons nous a une petite experiance :)
nous allons tracer le soft en appliquant un breakpoint sur ces 2 adresses, puis nous allons le lancer une fois
le time limit ok (grace a la commande "date" de DOS) et une fois le time limite pas ok

hum hum!

qu'est ce que l'on remarque?

lorsque le soft a sont time limit OK, "Security check" est appeller depuis 43EEC5 :)
mais lorsuqe celui si est or time limit, "Security Check" est appeller depuis 43EF9A

ce qui veut dire qu'il faut qu'on ce demerde pour que "Security Check" soit appeller depuis 43EEC5 tout le temp ;)

et ben aller, au boulot...
on click sur "goto", "code location" 43EEC5,

voici toute la portion de code qui nous interressent

:0043EDF3 68305B4700 push 00475B30
:0043EDF8 8B8504F8FFFF mov eax, dword ptr [ebp+FFFFF804]
:0043EDFE 8B4060 mov eax, dword ptr [eax+60]
:0043EE01 50 push eax
:0043EE02 6A00 push 00000000
:0043EE04 E8033DFCFF call 00402B0C                  ;voici la vrai procedure qui determine si on est dans le time limite
:0043EE09 83C410 add esp, 00000010
:0043EE0C 85C0 test eax, eax                                   ;car si eax = 0
:0043EE0E 0F84BE000000 je 0043EED2                 ; on saute a 43EED2 ce qui nous fait bypasser 43EEC5
:0043EE14 6A00 push 00000000

* Possible StringData Ref from Data Obj ->"98.04.27"
|
:0043EE16 68405B4700 push 00475B40                       ;donc, notre but et de reussir a arriver
:0043EE1B 8B45E8 mov eax, dword ptr [ebp-18]        ; jusqu'a cette portion de code
:0043EE1E 50 push eax
:0043EE1F E86846FCFF call 0040348C
:0043EE24 83C40C add esp, 0000000C
:0043EE27 83F801 cmp eax, 00000001                       ; et vue que eax = 0
:0043EE2A 0F857F000000 jne 0043EEAF                ; on sautras cache a 43EEAF (qui est proche de 43EEC5)
:0043EE30 6A01 push 00000001

* Possible StringData Ref from Data Obj ->"98.04.27"
|
:0043EE32 684C5B4700 push 00475B4C                      ; ce qui fait que sa, c'est bypasser
:0043EE37 8B45E8 mov eax, dword ptr [ebp-18]
:0043EE3A 50 push eax
:0043EE3B E84C46FCFF call 0040348C
:0043EE40 83C40C add esp, 0000000C
:0043EE43 83F801 cmp eax, 00000001
:0043EE46 0F8563000000 jne 0043EEAF

* Possible Reference to String Resource ID=00125: "It doesn't appear this application was
installed properly wi"
|
:0043EE4C 6A7D push 0000007D                                    ; sa aussi c'est bypasser
:0043EE4E 8D4DEC lea ecx, dword ptr [ebp-14]
:0043EE51 E8FAAD0100 call 00459C50

* Possible Reference to String Resource ID=00126: "WS_Ping ProPack"
|
:0043EE56 6A7E push 0000007E
:0043EE58 8D4DF0 lea ecx, dword ptr [ebp-10]
:0043EE5B E8F0AD0100 call 00459C50
:0043EE60 6A10 push 00000010
:0043EE62 8D4DF0 lea ecx, dword ptr [ebp-10]
:0043EE65 E8060CFDFF call 0040FA70
:0043EE6A 50 push eax
:0043EE6B 8D4DEC lea ecx, dword ptr [ebp-14]
:0043EE6E E8FD0BFDFF call 0040FA70
:0043EE73 50 push eax
:0043EE74 6A00 push 00000000

* Reference To: USER32.MessageBoxA, Ord:0188h
|
:0043EE76 FF151CDC4700 Call dword ptr [0047DC1C]
:0043EE7C C78520F8FFFF00000000 mov dword ptr [ebp+FFFFF820], 00000000
:0043EE86 C645FC01 mov [ebp-04], 01
:0043EE8A E8EB060000 call 0043F57A
:0043EE8F C645FC00 mov [ebp-04], 00
:0043EE93 E8EB060000 call 0043F583
:0043EE98 C745FCFFFFFFFF mov [ebp-04], FFFFFFFF
:0043EE9F E8E8060000 call 0043F58C
:0043EEA4 8B8520F8FFFF mov eax, dword ptr [ebp+FFFFF820]
:0043EEAA E9F0060000 jmp 0043F59F

* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:0043EE2A(C), :0043EE46(C)
|

* Possible StringData Ref from Data Obj ->"WSPingPR"
|
:0043EEAF 68585B4700 push 00475B58                 ;et voila! nous arrivons sur la bonne portion de code

* Possible StringData Ref from Data Obj ->"wspingpr.key"
|
:0043EEB4 68645B4700 push 00475B64
:0043EEB9 8B8504F8FFFF mov eax, dword ptr [ebp+FFFFF804]
:0043EEBF 8B4060 mov eax, dword ptr [eax+60]
:0043EEC2 50 push eax
:0043EEC3 6A00 push 00000000
:0043EEC5 E8EF36FCFF call 004025B9              ; et notre procedure call et executer
:0043EECA 83C410 add esp, 00000010
:0043EECD E903010000 jmp 0043EFD5            ; et hop, maintenant on peut jumper au lancement du soft :)

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0043EE0E(C)
|
:0043EED2 6A00 push 00000000                          ;ce qui fait que toute cette portion de code
:0043EED4 68D8124700 push 004712D8           ; n'est pas executer
:0043EED9 E8323F0100 call 00452E10
:0043EEDE 83C408 add esp, 00000008
:0043EEE1 85C0 test eax, eax
:0043EEE3 0F859B000000 jne 0043EF84
:0043EEE9 6A00 push 00000000

* Possible StringData Ref from Data Obj ->"98.04.27"
|
:0043EEEB 68745B4700 push 00475B74
:0043EEF0 8B45E8 mov eax, dword ptr [ebp-18]
:0043EEF3 50 push eax
:0043EEF4 E89345FCFF call 0040348C
:0043EEF9 83C40C add esp, 0000000C
:0043EEFC 83F801 cmp eax, 00000001
:0043EEFF 0F857F000000 jne 0043EF84
:0043EF05 6A01 push 00000001

* Possible StringData Ref from Data Obj ->"98.04.27"
|
:0043EF07 68805B4700 push 00475B80
:0043EF0C 8B45E8 mov eax, dword ptr [ebp-18]
:0043EF0F 50 push eax
:0043EF10 E87745FCFF call 0040348C
:0043EF15 83C40C add esp, 0000000C
:0043EF18 83F801 cmp eax, 00000001
:0043EF1B 0F8563000000 jne 0043EF84

* Possible Reference to String Resource ID=00125: "It doesn't appear this application was
installed properly wi"
|
:0043EF21 6A7D push 0000007D
:0043EF23 8D4DEC lea ecx, dword ptr [ebp-14]
:0043EF26 E825AD0100 call 00459C50

* Possible Reference to String Resource ID=00126: "WS_Ping ProPack"
|
:0043EF2B 6A7E push 0000007E
:0043EF2D 8D4DF0 lea ecx, dword ptr [ebp-10]
:0043EF30 E81BAD0100 call 00459C50
:0043EF35 6A10 push 00000010
:0043EF37 8D4DF0 lea ecx, dword ptr [ebp-10]
:0043EF3A E8310BFDFF call 0040FA70
:0043EF3F 50 push eax
:0043EF40 8D4DEC lea ecx, dword ptr [ebp-14]
:0043EF43 E8280BFDFF call 0040FA70
:0043EF48 50 push eax
:0043EF49 6A00 push 00000000

* Reference To: USER32.MessageBoxA, Ord:0188h
|
:0043EF4B FF151CDC4700 Call dword ptr [0047DC1C]
:0043EF51 C7851CF8FFFF00000000 mov dword ptr [ebp+FFFFF81C], 00000000
:0043EF5B C645FC01 mov [ebp-04], 01
:0043EF5F E816060000 call 0043F57A
:0043EF64 C645FC00 mov [ebp-04], 00
:0043EF68 E816060000 call 0043F583
:0043EF6D C745FCFFFFFFFF mov [ebp-04], FFFFFFFF
:0043EF74 E813060000 call 0043F58C
:0043EF79 8B851CF8FFFF mov eax, dword ptr [ebp+FFFFF81C]
:0043EF7F E91B060000 jmp 0043F59F

* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:0043EEE3(C), :0043EEFF(C), :0043EF1B(C)
|

* Possible StringData Ref from Data Obj ->"WSPingPR"
|
:0043EF84 688C5B4700 push 00475B8C

* Possible StringData Ref from Data Obj ->"wspingpr.key"
|
:0043EF89 68985B4700 push 00475B98
:0043EF8E 8B8504F8FFFF mov eax, dword ptr [ebp+FFFFF804]
:0043EF94 8B4060 mov eax, dword ptr [eax+60]
:0043EF97 50 push eax
:0043EF98 6A00 push 00000000
:0043EF9A E81A36FCFF call 004025B9                        ; et ce call ne seras jamais appeller :)

Patching
ben voila! tout a ete dit! il ne reste plus qu'a patcher
nous allons attaquer sur cette partie

:0043EE04 E8033DFCFF call 00402B0C                  ;on vas rentrer dans cette procedure pour y inserer un RET
:0043EE09 83C410 add esp, 00000010                     ; afin que la fonction ne nous fasse plus chié
:0043EE0C 85C0 test eax, eax                                   ;mais vue que eax=0 et qu' il faut empecher le jump, donc...
:0043EE0E 0F84BE000000 je 0043EED2                 ;on vas noper cette instruction pour que le jmp ne s'applique jamais

et ben alors? qu'est ce que vous attendez? aller on patch, on test, on y est presque bordel!

comme d'hab, "debug", load prossess" on applique le BP sur 43EE04, on appyue sur F9, tak, dasm s'arrete!
la, on clique sur "Step Into" pour entrer dans la fonction, puis on fait "patch code", et on patch par RET

ps: Ret est l'instruction qui stipule la fin du call, ce qui veut dire que l'on met fin a la fonction de test de la date prematurement.

hop, on continue en cliquant sur step into, et on revient sur 43EE09, on continue jusqu'a "je 43EED2", et la, on repatch
pour que ce jump ne soit jamait executer.

question: par combien de nop vai'je remplacer "je 0043EED2" ?

j'espere que vous avez la reponse...

une fois tout ceci fait, on click sur run, et Ho joiE :) le soft ce lance, malgrer le nag qui nous dit qu'on est plus enregistrer ::))
et en plus, toute les fonction marche :::))) mais c'est le PIED!

nous venons de faire la parti theorique, c'est a dire que nous avons deplomber le soft, mais seulement en memoire!
maintenant, il faut le modifier physiquemment, (le meilleur moment)

aller, on sort l'editeur hexa...

bon alors, rappellons nous de ce qu'il faut patcher.

voici le code que l'on a modifier pour entrer dans le soft, meme quand la date limite est depasser

0043EE04 E8033DFCFF call 00402B0C
on a placer un RET dans cette fonction ce qui fait que l'instruction seras placer a cette ligne si

:00402B0C 55 push ebp ; a remplacer par RET

on a noper ce saut
:0043EE0E 0F84BE000000 je 0043EED2 ; a remplacer par nop nop nop nop nop nop

ok, trouvons les offset

newbie: "kesako les offset?"

les offsets sont les adresses hexadecimal qui pointe sur l'instruction dans le programme compiler (non desassembler)
pour les trouver, rien de plus simple, avec wdasm, placer vous sur la ligne desirer, par exemple :00402B0C 55 push ebp
et l'offset, et noter en bas! voila

donc pour :
00402B0C 55 push ebp offset = 1F0Ch
:0043EE0E 0F84BE000000 je 0043EED2 offset = 3E20Eh

voila, donc dans l'editeur hexa, on click sur "edit", "goto", on coche bien le petit rond "hexa" et on entre notre 1er
offset (1F0C). on click sur "GO" et ho miracle! hex workshop pointe sur un byte "55" (55 = push ebp)
on remplace le "push ebp" par "ret", donc 55 par C3 (l'instruction ret = C3 en hexa), sa doit donner a peut pres ceci...

on pointe sur l'offset 1F0C, et on y vois bien le 55

que l'on remplace par C3

on fait pareil pour 0043EE0E 0F84BE000000 je 0043EED2 offset = 3E20Eh
que l'on vas remplacer par 6 nop (nop = 90 en hexa)!
donc normalemment, on doit trouver a l'offset 3E20E la chaine 0F84BE000000 que l'on vas remplacer par
909090909090.

on verifi sa tout de suite :)

ok, c'est tout bon!
ben aller, on sauvegarde (en oubliant pas de faire une copie de wspingpr.exe) et on execute tout sa :)

tiens, un nag qui nous dit que notre temp d'essaye est expirer lol

a noter que l'on a expirer le 22 mars 2000, on click sur ok

hop, le soft ce lance quand meme :)

et si vous regarder la date du soft, on remarque que l'on a peter le time limite, vue que celui ci est est executer le 2000/05/15!

tout cela est tres bien, mais le nag du debut et chiant! et en plus sa fait pas pro!
mais n'avons nous pas deja traiter cette partie? si bien sur, rappeller vous!

:0040288F 0F8418000000 je 004028AD
:00402895 8B4514 mov eax, dword ptr [ebp+14]

:004028AD C745FC00000000 mov [ebp-04], 00000000

hé hé, pour voir si vous avez compris, je vais vous laisser faire cette partie avec l'editeur hexa!
une fois ceci fait, votre soft et parfaitemment cracker, il ne reste plus qu'a faire le crack :)

voila, c'est fini! au cours de ce tuto, vous avez apris a debugger, analyser du code, patcher en memoire, patcher en hexa,
taper une crise pour avoir bosser pour rien, vous avez eu des notion sur la transition asm hexa (ex: ret = C3), et en plus
vous avez cracker un soft pas si mal que sa ;)

si vous etes archi debutant, et que vous n'avez rien compris, c'est que vous ne vous etes pas encore mis a l'asm!
et oui, il vas falloir s'y mettre lol

sur ceux, et je vous souhaite une bonne journée...