Au programme:
Introduction
Les Bases minimales requises (sauts conditionnels, nop, call
...)
Introduction à W32Dasm8x
Patcher les protections avec Registrations (serial, name /
serials)
Introduction à Soft-ice (configuration et commandes de
base)
Trouver des serials valides pour vos noms avec Soft-ice
Comment keygener pas mal de programmes (utilisation des BPR...)
Transformer un Programme en son propre keygen
Time Limits (limitation de 30 jours et autres merdes !!)
Nag et autres Splash screen (diverse méthodes...)
Keyfile
CD Check (les BPX, et techniques diverses..)
Visual Basic (keygener, serialiser, patcher, tout sur le VB !!)
JAVA Reverse Engineering
Manual Unpacking (comment unpacker, les tools, méthodes...)
Checksum (comment les contourner)
Anti Soft-ice
Divers
Greetings
Conclusion
Introduction :
Ben, voilà je me suis dit il y a quelques jours, pourquoi ne pas écrire
un cours englobant tous les types de protections les plus courantes
et comment les mettre en échec!!
Cette fois-ci, c'est donc bien un cours global de cracking et en
français en plus !!
Vous l'avez sûrement remarqué, la taille de ce cours est assez
grande !! Plusieurs dizaines de Ko! Je vous conseille donc de lire çà
au calme et avec attention !!
Je préviens de suite !! pour les personnes ayant l'habitude de faire
des remarques mal placées ! Ce n'est pas la peine de critiquer ce
cours !! Mais si vous avez plutôt des suggestions, je suis disposé
à écouter...
Ce cours a été écrit alors que j'étais très malade, il se peut qu'il y ait
quelques "âneries", je serais content si vous pouviez m'en faire part!
Merci et sur ce, bonne lecture.
[ ACiD BuRN ]
ESSAY :
*************************************************************************
** Les Bases minimales requises (sauts conditionnels, nop, call ...) **
*************************************************************************
Pour pouvoir cracker, vous devez avoir des bases en assembleur!!
Je vais ici vous énumérer les choses à savoir au départ,
différentes instructions, ce qu'elles veulent dire ..
Si vous êtes déjà habitué au cracking, vous pouvez passer à la suite
sans problème je pense, à part si vous avez de grosses lacunes!
L'assembleur est le langage qui se rapproche le plus de celui du PC,
ou plutôt que le Microprocesseur puisse comprendre:
"le langage machine."
L'asm est donc le langage de programmation de plus bas niveau qui
existe.
Ce langage retrouve sa place dans tous les programmes car il ne
faut pas oublier que n'importe quel programme, écrit dans
n'importe quel langage est finalement traduit en langage machine
pour être exécuté...
Si on désassemble n'importe quel programme, on retrouve un listing
en ASM, d'où l'utilité de connaître l'assembleur.
Passons à l'étude des instructions (Très basique) afin d'éclaircir
les problèmes.
* CALL: l'instruction CALL permet d'appeler une sous-routine.
ex: Call 00405741 <-- ceci appelle la routine qui se trouve en
00405741.
* CMP: compare. Cette instruction soustrait l'opérande source à l'opérande
de destination.
ex: CMP EAX, EDX <--- soustrait EAX à EDX = EDX - EAX
Les CMP sont généralement accompagnés de sauts conditionnels, nous les
verrons très bientôt...
* JMP: (JUMP) elle effectue un saut inconditionnel à une autre partie
du programme
ex: JMP 0040458 <--- saute à 0040458
* NOP: (no operation): cette instruction n'est pas comme les autres.
Elle ne fait tout simplement RIEN!!
Vous verrez par la suite son intérêt !
* RET: (return): instruction qui permet de revenir au programme appelant
quand une sous-routine est terminée! (très utile certaines fois)
* ADD: elle réalise une addition entre les 2 opérandes et place le
résultat dans l'opérande destination.
ex: ADD EAX, FFh --> EAX = EAX + FFh
* SUB: c'est pour effectuer une soustraction entre 2 opérandes...
ex: SUB EAX, EDX --> EAX = EAX - EDX
Il y a aussi les DIV, MUL (je vous fait pas de dessin, je pense que
devinez ce que ça fait !!
* Les saut conditionnels:
Vous rencontrez beaucoup de tests, comparaison, pendant le cracking.
Ainsi pour traiter les résultats de ceux-ci, il existe une multitude
de sauts conditionnels, je vais vous en citer quelques-uns:
JNE (jump if not equal) = jump if not equal to zero (JNZ sous Soft-ice)
JE (jump if equal) = jump if equal to zero (JZ sous Soft-ice)
JG (jump if greater) = jump si c'est supérieur
JGE (jump if greater or equal) = jump si c'est supérieur ou égal
JL (jump if less) = jump si c'est inférieur
JLE (jump if less or equal) = jump si c'est inférieur ou égal
JA (jump if Above)
JNA (jump if not above)
......
je vous conseille de lire une documentation sur l'asm si vous voulez
plus d'infos sur les types de saut ! Il en existe encore...
* MOV: l'instruction mov sert à placer une valeur dans un registre.
ex: MOV EAX, 56h ---> met 56h (86 en décimal) dans le
registre EAX.
* XOR: c'est un ou exclusif! Très utilisé dans les routines de cryptage
ou de génération de serials!
Voici la table de fonctionnement du XOR:
0 XOR 0 = 0
0 XOR 1 = 1
1 XOR 0 = 1
1 XOR 1 = 0
Le xor est utilisé pour remettre un registre à 0.
En effet quand on xor 2 mêmes valeurs, le résultat est toujours 0.
ex: XOR EAX, EAX ---> EAX = 0
* PUSH: l'instruction push permet de placer une donnée sur la pile.
Elle peut venir d'un registre ou d'un emplacement mémoire!
ex: PUSH EAX ---> pousse la valeur de EAX sur la pile
* POP: l'instruction pop permet de récupérer une donnée posée sur la
la pile.
Elle peut être placée dans un registre ou dans un emplacement
mémoire!
ex: POP EAX ---> récupère la valeur de EAX sur la pile
Voilà, ça sera tout pour les bases en ASM!!
Ces quelques descriptions ont, je l'espère, mis au clair
les qq problèmes pouvant être rencontrés du à l'incompréhension
de certaines instructions!!
Mais il serait préférable pour vous d'avoir un livre d'asm
près de vous, cela vous permettrais de chercher la description
des instructions qui vous posent problème !
(exemple de livre: ASSEMBLEUR PRATIQUE, éditions Marabout)
Introduction à W32Dasm8x:
Tout d'abord, je vais vous expliquer ce qu'est W32Dasm, à quoi il sert
et quelles sont ses principales options!
W32Dasm est un désassembleur! Il permet de désassembler n'importe quel
fichier de type EXE, DLL, OCX ... pour obtenir son équivalent
en asm!
A quoi bon ? hehe ce genre de programme vous permettra de cracker
qq jeux, de s'enregistrer dans vos programmes et encore des tas d'autres
choses !!!
Utilisation:
Après avoir dézippé W32Dasm dans un répertoire, il vous faudra configurer
la fonte car celle qui est par défaut n'est pas lisible, lol :)
Car quand vous allez l'utiliser pour la première fois, vous verrez des signes
tout à fait bizarres et qui ne veulent rien dire !!
Normal ! La fonte par défaut est : widings ou qq chose comme ça.
Changez la en : Times new roman par exemple, et vous pourrez enfin comprendre
ce que W32Dasm vous montrera après avoir désassemblé !
Changement de fonte: lancez W32Dasm, dans le menu désassembler choisissez Font.
et ensuite select Font! et là vous pouvez faire votre choix!!!
Les différents menus:
Dans Disassembler: Open file to disassemble
C'est avec ce menu que vous choisissez le fichier à désassembler!
Ouvrez le fichier Calc.exe présent dans le répertoire de Windows pour essayer
par exemple!
Après avoir désassemblé, vous pouvez sauvegarder ce fichier pour pouvoir
le réouvrir ultérieurement !! (désassembler de gros fichiers peut être parfois
TRES long !! d'où l'intérêt de sauver le fichier !)
Pour cela, allez dans le menu "Save disassembly Text files.." de Disassembler.
Juste à côté de ce menu vous pouvez voir "Project"!
Ceci sert à ouvrir les fichiers sauvegardés précédemment !
Je ne vais pas m'attarder sur la description de W32Dasm, car il est fourni
avec une aide super !!! décrivant avec précision les différentes commandes!
Pour finir cette brève description des menus, je vais vous décrire le menu
Refs!
Alors celui-là !! c'est le menu le plus utilisé dans W32Dasm !!
Après avoir clické dessus, vous devez apercevoir 3 sous-menus,
je ne vous parlerai pour l'instant que de:
String Data References!
Kesako çà ? C'est en fait une liste de tout les messages rencontrés dans le
programme disassembler!
Il vous servira notamment pour les jeux avec des messages du genre:
"Please insert your CD" ou encore les autres names / serials:
"the serial you entered is not Valid!" ....
L'utilisation sera détaillée dans la suite de ce cours !
Quelques astuces en vrac:
Pour copier-coller dans W32Dasm, il suffit de clicker sur le début de la ligne
à copier (un point rouge doit apparaître) et ensuite appuyez sur la touche
Shift. Maintenant allez sur la dernière ligne à copier, et vous verrez que
toutes les lignes entre les 2 points que vous avez sélectionnés contiennent
des points rouges !!
Cela signifie que vous pouvez maintenant copier-coller le texte qui est
sélectionné!
Ctrl+C = copie le texte
Ctrl+V = colle le texte
L'intérêt de ceci est que vous pouvez découper des bouts de codes et
les introduire dans vos tuts, ou Keygens :))
Patcher les protections avec Registrations
Nous allons voir ici l'utilisation de W32Dasm pour patcher les protections
par serials !!
Théorie:
Dans de nombreux sharewares, vous rencontrez des protections par name / serials
et les programmes souvent pas très malin vous mettent un msg disant que le
serial entre n'est pas bon !! qd vous avez rentré une connerie!
Appelons X le programme protégé par name serial.
Lancez X, et allez là où vous pouvez entrer un nom et un code d'enregistrement.
Entrez votre nom et un serial à la con style: 112233 et clickez sur le bouton
permettant de vérifier le serial style "OK" et vous verrez le message à la con
vous disant: "le serial que vous avez entré n'est pas valide"
Hehehehe, déjà si vous voyez çà vous pouvez vous dire que c'est bien parti !
Alors ouvrez W32Dasm et sélectionnez le fichier exécutable du programme à cracker
comme je vous ai montré dans la partie d'avant !!
Maintenant allez jeter un oeuil dans les String Data References et vous n'avez
plus qu'à chercher le message d'erreur rencontré lors du mauvais serial !!
Sans tarder vous le trouvez dans la liste des messages !!
Double-cliquez dessus et vous atterrissez à l'endroit dans le programme où
s'effectue le test.
Vous tomberez Très souvent sur qq chose comme çà:
:01001777 FF151C110001 Call 0100111C
:0100177D 85C0 test eax, eax
:0100177F 7512 jne 01001793
:01001781 8D856CFFFFFF lea eax, dword ptr [ebp+FFFFFF6C]
* Possible StringData Ref from Code Obj ->"le serial que vous avez entré.."
Ici on voit très bien le message d'erreur du programme !!
Si on regarde juste au dessus, on voit un Test, et un JNE!
Regardez dans la liste des fonctions asm que je vous ai donné au début
si vous avez oublié la fonction de jne...
Que fait donc ce code ?
Si le code n'est pas égal au bon code : TEXT EAX, EAX n'est pas égal
à 0 et donc le jne (jump if not equal) saute vers le message d'erreur!
Donc comment cracker ça ?
Facile, nous devons avoir EAX = 0 pour que le serial soit pris comme valide
donc la façon la plus propre est de forcer EAX à 0!
L'instruction qui met à 0 un registre est XOR.
XOR EAX, EAX = 0 (si vous ne comprenez pas pourquoi, allez voir au début du
cours dans les bases en ASM).
Le code modifié ressemble à ceci :
:01001777 FF151C110001 Call 0100111C
:0100177D 33C0 xor eax, eax
:0100177F 7512 jne 01001793
:01001781 8D856CFFFFFF lea eax, dword ptr [ebp+FFFFFF6C]
* Possible StringData Ref from Code Obj ->"le serial que vous avez entré.."
La ligne:
:0100177D 85C0 test eax, eax
est devenue:
:0100177D 33C0 xor eax, eax
Voilà !! EAX = 0 pour toujours donc le programme ne sautera plus jamais
avec le jne et le programme vous mettra le message comme quoi vous
avez entré un bon serial !!
"Merci de Votre support, vous êtes maintenant enregistré BLABLABLA "
:-) Coool tout ça !! Mais vous vous demandez sûrement comment j'ai su que
le 85C0 deviendrait 33C0 et comment on peut changer ça dans le programme ?
hehe, ça vient !!
Pour savoir à quoi ressemble le code en hexa d'une instruction vous pouvez
utiliser l'option de l'éditeur hexa Hacker view, mais bon j'aime pas cet
éditeur!! je connais ces valeurs par coeur. Donc essayez de vous en rappeler.
Pour effectuer ces modifications dans le programme, il faut utiliser un
éditeur hexadécimal. J'utilise HexWorkshop car c'est à mon avis le meilleur!
Donc lancez l'éditeur hexa, et ouvrez votre fichier à patcher avec...
Faites une recherche des octets à patcher et remplacez par les nouvelles
valeurs. Exemple dans ce cas: recherchez: 85C075128D856CFF
Vous devez trouver un seul endroit correspondant à ces octets sinon
faites une recherche avec plus d'octets!!
Une fois que vous avez trouvé, remplacez par: 33C075128D856CFF
sauvegardez le fichier et c'est prêt!!
NOTE: si vous avez ouvert le fichier et qu'il est toujours ouvert par
W32Dasm, vous ne pourez l'enregistrer car le fichier sera déjà en lecture
donc vous serez en lecture seule!!
Petite astuce pour ne pas être emmerdé :
Avant de désassembler votre exécutable, faites-en une copie et renommez
l'extension en .AB par exemple! Désassemblez le fichier avec l'extension .ab
et une fois que vous savez où il faut patcher, vous ouvrez la copie
du fichier qui a toujours l'extension .exe avec HexWorkshop!
Vous pourrez modifier l'exe et sauvegarder, tout en vous servant de W32Dasm!
Donc voilà, vous avez sauvegardé le fichier ! Relancez l'exécutable modifié
et vous entrez un nom / serial bidon, et clickez sur le bouton pour vérifier
le serial! Miracle le message : "Merci de votre support" ou autres conneries
du genre apparaît !! Vous venez de cracker votre premier name / serial.
Mais attention, il se peut que quand vous relanciez le programme, il ne
soit plus enregistré :(( pourquoi ??
Ben tout simplement car il y a un autre contrôle du serial dans la base
de registre ou même dans un fichier .ini!!
L'enculé :) heheh il est souvent très simple à patcher cela !
Dans les String Data References, si vous voyez une référence du genre:
"Licenced to:" <-- il doit avoir des tests plus haut, ou des appels par
des call ou sauts conditionnels !!
Vous avez juste à modifier le programme pour qu'il saute en version
enregistrée à tout les coups !! en remplaçant un JE en JMP
(en hexa: 74 --> EB)...
Pour en revenir à l'exemple de tout à l'heure on a modifié le TEST
en XOR, mais on aurait très bien pu nopper le saut conditionnel!!!
Explications:
:01001777 FF151C110001 Call 0100111C
:0100177D 85C0 test eax, eax
:0100177F 7512 jne 01001793
:01001781 8D856CFFFFFF lea eax, dword ptr [ebp+FFFFFF6C]
* Possible StringData Ref from Code Obj ->"le serial que vous avez entré.."
Le jne saute au mauvais message si le numéro de série n'est pas bon !!
Donc pourquoi ne pas l'empêcher de sauter tout simplement ??
Comment ? ben si vous avez jeté un oeuil au début du cours vous avez
sûrement remarqué l'instruction: NOP (no operation)!!!
Cette instruction ne fait rien du tout !! Chouette on va s'en servir
pour tuer le saut !!
Notre code devient donc:
FF151C110001 Call 0100111C
85C0 test eax, eax
90 nop
90 nop
8D856CFFFFFF lea eax, dword ptr [ebp+FFFFFF6C]
Et voilà !! plus de problèmes non plus :)
Le code hexa pour nop = 90 !! ne pas oublier ça !! Vous vous en servirez
toute votre vie (de cracker).
Modification dans l'exécutable comme tout à l'heure:
on cherche: 85C075128D856CFF et on remplace par: 85C090908D856CFF
Sauvegardez et Enjoy!!!
Pratique:
Petit exemple illustrant ce que je viens de vous apprendre:
Crack de WinRAR 2.05
On va patcher ce prog pour qu'il accepte n'importe quel numéro de
série. Nous allons voir comment faire quand un prog accepte le serial
mais dès qu'on le relance, il nous dit version non enregistrée !!
Et pour finir réactiver une fonction du prog accessible seulement en
version enregistrée !!!
donc pour ce crack on a besoin de :
- WinRAR 2.05
- W32Dasm 8.9
- éditeur hexa comme HexWorkshop
1) Analyse du prog !
On lance WinRAR et on voit dans la barre des tâches : (evaluation Copy),
dans option, general, 2 functions désactivées (Log errors to file et put
authenticity verification). Et dans option : Registration.
On rentre notre nom et numéro de série, il nous dit: Registration failed.
2) Lets kick this fucking tool !
Donc on fait une copie de sauvegarde de WinRAR95.exe puis on le désassemble
avec W32Dasm, on va dans String Data References et on trouve :
....
String Resource ID=00106: "Registration failed"
String Resource ID=00107: "Thank you for support"
....
Dons on double click sur Registration Failed et on retourne dans W32Dasm,
on remonte un peu on voit çà:
:00413c5f 7532 jne 00413c93
* Possible StringData Ref from Code Obj ->"Normal"
:00413c61 6A30 push 000000030
* Possible StringData Ref from Code Obj ->"Warning" <-- Le message d'erreur!
:00413c63 6a1a push 0000001a
:00413c65 e8fe640000 call 0041a168
:00413c6a 59 pop ecx
....
....
* Possible StringData Ref from Code Obj ->"Registration failed"
....
....
et là on voit tout de suite le saut conditionnel : jne 00413c93
jne veut dire jump if not equal, donc le prog saute au message d'erreur quand le code
est mauvais !
On le remplace par je 00413c93 et hop ! Il ira sur le mauvais message quand on rentrera
un bon code !! Il peut tjs attendre !!!
Donc on remplace le 7532 par 7432 (note: j'aurais très bien pu nopper mais
c'est pour vous montrer que les sauts sont renversables),
on sauvegarde et on relance le tout !!
On entre son nom, son code bidon, et il nous dit : Thank you for .... :)
Mais si on relance, le prog n'est plus enregistré :(
On réfléchit et on voit dans la barre des titres: (evaluation copy).
Tout à l'heure quand on a rentré un code, ce message était parti.
Donc on cherche : '(evaluation copy'), dans les String Data References.
(bien prendre celle avec parenthèses)
On trouve:
String Resource ID=00252: "(evaluation copy)"
on double click et on remonte un peu et on voit :
:00418d1e 833d5c57420000 cmp dword ptr [0042575c], 00000000
:00418d25 752f jne 0041d56 <=== Jump to BAD CRACKER !!!
Encore un chtit saut conditionnel, on le remplace en je avec un 74 à
la place du 75 on sauvegarde, on relance et on est enregistré ! :)
Mais, n'oublions pas de tester le proggy !! et on voit les 2 fonctions
désactivées citées plus haut. :(
Dans Menu\Options\general on coche une des deux cases, il nous dit :
"Available in registered version only" <=== va te faire petit !!! :)
On note le message et on le cherche dans W32Dasm, comme d'hab !
On trouve:
String Resource ID=00051: "Available in registered version only"
On double click et on voit :
:004138a9 833d5c57420000 cmp dword ptr [0042575C],00000000
:004138B0 7534 jne 004138e6 <===== jump to BAD CRACKER
* Possible StringData Ref from Code Obj -> "Normal"
:004138B2 6a30 push 00000030
* Possible StringData Ref from Code Obj -> "Warning"
:00413c63 6a1a push 0000001a
:00413c65 e8fe640000 call 0041a168
:00413c6a 59 pop ecx
:00413c6b 50 push eax
* Possible StringData Ref from Code Obj -> "Available in registered ..."
....
....
Encore un saut conditionnel vous avez compris je pense, on le remplace le jne 004138e6
par je 004138e6 !!
On enregistre et on relance WinRAR !!
On essaie de cocher les cases !! Bingo !!! CRACKED !! :)
// extrait de mon cour sur WinRAR 2.05 (j'ai patché comme un cow-boy mais
// si je commence à retoucher tout j'ai pas encore fini !!
Bon ben voilà !! C'était un exemple concret de comment patcher un programme
pour qu'il accepte tous les serials à la con, et comment réactiver
des fonctions désactivées !
Il existe des programmes BEAUCOUP plus durs à patcher et aussi encore plus
simple que celui là !!
Note: si jamais après avoir désassemblé vous ne voyez aucune String
Data References, il y a de fortes chances que le programme soit packé
(crypté grâce à un packer!!), pour savoir comment décrypter un exécutable
à la main (manual unpacking) lisez la suite du cours !! Ca arrive ;-)
Et pour finir voici une source d'un patch en Delphi que j'ai programmé
il y a déjà un bon moment :)
//-------------------------- start of sources: unit1.pas ---------------------------------
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls, ExtCtrls, Menus, jpeg;
type
TForm1 = class(TForm)
Button1: TButton;
OpenDialog1: TOpenDialog;
Label2: TLabel;
Button2: TButton;
MainMenu1: TMainMenu;
About1: TMenuItem;
Image1: TImage;
Image2: TImage;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
implementation
uses Unit2;
{$R *.DFM}
procedure TForm1.Button1Click(Sender: TObject);
Const A: Array[1..4] of Record // nombre de changements: 4 octets
A : Longint;
B : Byte;
End =
((A:$5C8A;B:$85), // (A = offset et B = valeur que l'on met a la place ) en hexa
(A:$5C93;B:$85),
(A:$5C9B;B:$EB),
(A:$7CD8;B:$EB));
Var Ch:Char;
I:Byte;
F:File;
begin
if OpenDialog1.Execute then { affiche une "Open dialog box" }
begin
AssignFile(F, OpenDialog1.FileName);
{$I-} Reset (F, 1); {$I+}
If IOResult <> 0 then
begin
MessageDlg('File write protected or used !!!', mterror,
[mbcancel], 0);
halt(1);
end;
If FileSize (F) <> 512000 Then Begin // taille du fichier
MessageDlg('Wrong File size !!!', mterror,
[mbcancel], 0);
halt(1);
end else
For I:=1 to 4 do {<---------------------- nombres de changement: 4}
Begin
Seek(F,A[I].A);
Ch:=Char(A[I].B);
Blockwrite(F,Ch,1);
end;
MessageDlg('Mem Turbo is now Cracked , enjoy !!!', mtInformation,
[mbOk], 0);
closefile(f);
end;
end;
procedure TForm1.Button2Click(Sender: TObject);
begin
close
end;
end.
//-----------------------Fin des sources: unit1.pas --------------------------------
Introduction à Soft-ice
Alors là on commence les choses plus sérieuses !!
Voici Soft-ice le débugger de chez Numega !! C'est le débugger utilisé par
tout crackers digne de ce nom.
Grâce à ce programme, la seule chose qui vous limite vraiment c'est vous
et vos connaissances, on peut cracker des dongles (AutoCAD, 3DSMax),
trouver des serials, faire des keygens (très utile pour tracer les routines
de registration) ...
Bref, je vais vous citer ici les différentes commandes utiles et nécessaires
pour pouvoir se démerder ;)
Mais d'abord, je vais vous expliquer comment configurer ce petit programme :)
La configuration de Soft-ice se passe dans le fichier Winice.dat .
Donc éditez votre fichier winice.dat avec Notepad par exemple, et voici
les choses à modifier:
PHYSMB=64 <--- mettez ici votre nombre de RAM (j'en ai que 64 !!)
Pour une meilleur lisibilité, à la ligne ou vous voyez ceci INIT, mettez:
INIT="lines 60;ww;wl;wr;wd 24;wc 24;code on;x;"
Bien entendu, ce n'est pas obligatoire, mais c'est pour que vous soyez dans
les meilleures conditions possibles!!!
Ensuite à la ligne ou vous voyez "AF4" mettez ceci:
AF4="^s 0 l ffffffff 56,57,8b,7c,24,10,8b,74,24,0c,8b,4c,24,14,33,c0,f3,66,a7;"
Ca, c'est une technique utilisée dans le Visual Basic (pour trouver des serials :)
Bon maintenant, on commence la partie qui est la plus utile car si on ne modifie
pas ça ! Niet le cracking :)
; ***** Examples of export symbols that can be included for Windows 95 *****
; Change the path to the appropriate drive and directory
;EXP=c:\windows\system\kernel32.dll
;EXP=c:\windows\system\user32.dll
;EXP=c:\windows\system\gdi32.dll
;EXP=c:\windows\system\comdlg32.dll
;EXP=c:\windows\system\shell32.dll
;EXP=c:\windows\system\advapi32.dll
;EXP=c:\windows\system\shell232.dll
;EXP=c:\windows\system\comctl32.dll
;EXP=c:\windows\system\crtdll.dll
;EXP=c:\windows\system\version.dll
;EXP=c:\windows\system\netlib32.dll
;EXP=c:\windows\system\msshrui.dll
;EXP=c:\windows\system\msnet32.dll
;EXP=c:\windows\system\mspwl32.dll
;EXP=c:\windows\system\mpr.dll
Voilà !! Cherchez ça! C'est pas bien loin dans le fichier, et vous avez
sûrement remarqué les ";" , les points virgules mettent en commentaires !
donc il faut les enlever sinon on ne pourra rien cracker car les bpx
sur les API Windows seront impossibles (si vous comprenez pas ce que je raconte ;p
ca fait rien vous comprendrez bien assez tôt !!)
Donc modifiez ça en:
; ***** Examples of export symbols that can be included for Windows 95 *****
; Change the path to the appropriate drive and directory
EXP=c:\windows\system\kernel32.dll
EXP=c:\windows\system\user32.dll
EXP=c:\windows\system\gdi32.dll
EXP=c:\windows\system\comdlg32.dll
EXP=c:\windows\system\shell32.dll
EXP=c:\windows\system\advapi32.dll
EXP=c:\windows\system\Msvbvm50.dll
EXP=c:\windows\system\Msvbvm60.dll
EXP=c:\windows\system\shell232.dll
EXP=c:\windows\system\comctl32.dll
EXP=c:\windows\system\crtdll.dll
EXP=c:\windows\system\version.dll
EXP=c:\windows\system\netlib32.dll
EXP=c:\windows\system\msshrui.dll
EXP=c:\windows\system\msnet32.dll
EXP=c:\windows\system\mspwl32.dll
EXP=c:\windows\system\mpr.dll
Vous avez sûrement remarqué que j'ai ajouté 2 fichiers dll dans la liste
ci-dessus par rapport à avant:
EXP=c:\windows\system\Msvbvm50.dll
EXP=c:\windows\system\Msvbvm60.dll
Rajoutez-les !! On en a besoin si on veut cracker les programmes en Visual
Basic :-)
Pour ceux qui s'en branlent de ce que je raconte (il y en a toujours :/), voici
le winice.dat que j'utilise actuellement, qui n'a aucune prétention si ce n'est
de marcher ;p
;************ACiD BuRN's Winice.dat copier à partir d'ici************************
PENTIUM=ON
NMI=ON
ECHOKEYS=OFF
NOLEDS=OFF
NOPAGE=OFF
SIWVIDRANGE=ON
THREADP=ON
LOWERCASE=OFF
WDMEXPORTS=OFF
MONITOR=0
PHYSMB=64
SYM=1024
HST=256
TRA=8
MACROS=32
DRAWSIZE=2048
INIT="lines 60;ww;wl;wr;wd 24;wc 24;code on;x;"
F1="h;"
F2="^wr;"
F3="^src;"
F4="^rs;"
F5="^x;"
F6="^ec;"
F7="^here;"
F8="^t;"
F9="^bpx;"
F10="^p;"
F11="^G @SS:ESP;"
F12="^p ret;"
SF3="^format;"
CF8="^XT;"
CF9="TRACE OFF;"
CF10="^XP;"
CF11="SHOW B;"
CF12="TRACE B;"
AF1="^wr;"
AF2="^wd;"
AF3="^wc;"
AF4="^s 0 l ffffffff 56,57,8b,7c,24,10,8b,74,24,0c,8b,4c,24,14,33,c0,f3,66,a7;"
AF5="CLS;"
AF8="^XT R;"
AF11="^dd dataaddr->0;"
AF12="^dd dataaddr->4;"
CF1="altscr off; lines 60; wc 32; wd 8;"
CF2="^wr;^wd;^wc;"
; WINICE.DAT
; (SIW95\WINICE.DAT)
; for use with SoftICE Versions greater than 3.0 (Windows 95)
;
; *************************************************************************
; If your have MORE than 32MB of physical memory installed, change
; the PHYSMB line to the correct # of Megabytes.
; If you have LESS than 32MB you can save a bit of memory by
; specifying the correct # of Megabytes
; Example: PHYSMB=32
; *************************************************************************
; ***** Examples of sym files that can be included if you have the SDK *****
; Change the path to the appropriate drive and directory
;LOAD=c:\windows\system\user.exe
;LOAD=c:\windows\system\gdi.exe
;LOAD=c:\windows\system\krnl386.exe
;LOAD=c:\windows\system\mmsystem.dll
;LOAD=c:\windows\system\win386.exe
; ***** Examples of export symbols that can be included *****
; Change the path to the appropriate drive and directory
;EXP=c:\windows\system\vga.drv
;EXP=c:\windows\system\vga.3gr
;EXP=c:\windows\system\sound.drv
;EXP=c:\windows\system\mouse.drv
;EXP=c:\windows\system\netware.drv
;EXP=c:\windows\system\system.drv
;EXP=c:\windows\system\keyboard.drv
;EXP=c:\windows\system\toolhelp.dll
;EXP=c:\windows\system\shell.dll
;EXP=c:\windows\system\commdlg.dll
;EXP=c:\windows\system\olesvr.dll
;EXP=c:\windows\system\olecli.dll
;EXP=c:\windows\system\mmsystem.dll
;EXP=c:\windows\system\winoldap.mod
;EXP=c:\windows\progman.exe
;EXP=c:\windows\drwatson.exe
; ***** Examples of export symbols that can be included for Windows 95 *****
; Change the path to the appropriate drive and directory
EXP=c:\windows\system\kernel32.dll
EXP=c:\windows\system\user32.dll
EXP=c:\windows\system\gdi32.dll
EXP=c:\windows\system\comdlg32.dll
EXP=c:\windows\system\shell32.dll
EXP=c:\windows\system\advapi32.dll
EXP=c:\windows\system\Msvbvm50.dll
EXP=c:\windows\system\Msvbvm60.dll
EXP=c:\windows\system\shell232.dll
EXP=c:\windows\system\comctl32.dll
EXP=c:\windows\system\crtdll.dll
EXP=c:\windows\system\version.dll
EXP=c:\windows\system\netlib32.dll
EXP=c:\windows\system\msshrui.dll
EXP=c:\windows\system\msnet32.dll
EXP=c:\windows\system\mspwl32.dll
EXP=c:\windows\system\mpr.dll
;************End of ACiD BuRN's Winice.dat fin de sélection *****************
Donc vous copier / coller ceci dans un fichier nommé winice.dat et
mettez-le à la place du vôtre !! Mais changez quand même le nombre de Ram par
celui de votre PC (pas trop dur ;p)
Voilà, ça sera tout pour la configuration de Soft-ice !!
Passons aux commandes maintenant !!!
*****************************
** Commandes de Soft-ice: **
*****************************
- pour faire apparaître Soft-ice, pressez: Ctrl+D
Tout d'abord, les points d'arrêt (Breakpoints)!
On les utilise sur les fonctions de Windows (API) mais c'est une autre histoire!
Vous verrez dans la suite du cours :]
Pour poser un breakpoint, sous Soft-ice tapez: BPX API_windows (apiwindows
représente la fonction Windows que vous voulez 'étudier')
Apres avoir mis un bpx sur une API Windows vous pouvez par exemple
voir la liste des bpx déjà posés!
Liste des bpx: BL
Editer un bpx: BE numéro_du_bpx
Effacer un bpx: BC numéro_du_bpx
Effacer tous les bpx: BC *
Désactiver un bpx: BD numéro_du_bpx
Désactiver tout: BD *
Activer un BPX: BE numero_du_bpx
Activer tous les BPX: BE *
Il y a les: BPINT (breakpoint sur les interruptions comme INT3 ...)
ex: BPINT 3
Il existe aussi les BPM et autres BPR (je vous reparle des BPR dans la partie
sur le keygening)
Je ne vois pas de commande TRES utile tout de suite! On verra bien si j'ai
oublié qq chose d'important!
Mais il existe des milliers de commandes dans Soft-ice! Le but premier
du Logiciel et de debugger gentiment ses propres programmes :)
Ce que je fais aussi, mais quand je code un keygen en asm (souvent comme un
cow-boy et que je dois tracer pour voir ce qui part en couille *grin*)
Maintenant quelques exemples d'utilisation de notre nouveau jouet !!
Trouver les serials (Serial Fishing)
Voilà, comment trouver les serials valides pour votre nom dans les programmes
telles que WinZIP, WinImage ... (WinRAR c'est pas encore pareil (v2.0 a 2.5))
On commence avec un exemple:
*******************************************
**** WWW GIF ANIMATOR 1.0 ****
*******************************************
Entrez un nom, prénom, et un numéro de série à la mord-moi-le-noeud!
On appuie sur OK.
Là le programme nous envoie chier car le numéro est bidon.
On va donc poser un point d'arrêt sur une fonction de Windows qui
est très couramment utilisée dans ce genre de protection,
en fait il y en a 2:
Getwindowtexta pour les progs 32 bits (Getwindowtext pour 16 bits)
getdlgitemtexta pour les progs 32 bits (getdlgitemtext pour 16 bits)
Pour aller sous Soft-ice, il faut presser les touches Control+D.
Une fois sous Soft-ice on tape:
si vous n'avez pas:
on appuie sur alt + R pour voir les registres (eax, edx ...)
on appuie sur alt + D pour voir la zone data.
Pour poser le point d'arrêt: BPX Getwindowtexta
BPX getdlgitemtexta
On appuie sur F5 et on retourne à Windows.
J'ai entré pour First Name: ACiD
pour Last Name : BuRN
code : 12345
on appuie sur OK.
Boum, Soft-ice est réapparu et nous dit :
'break due to BPX Getdlgitemtexta'
On tape D EAX et on voit dans la zone data : ACiD BuRN
On appuie une fois sur F5 car on est dans le 'contrôle' du nom
et que l'on veut s'occuper du serial.
Entre la zone data et la zone de code, il y a marqué : USER32 ....
Nous ne sommes donc pas dans le programme, donc on fait F12 puis il n'y a plus
rien. On est maintenant dans le programme.
On trace comme un fou avec F10 et au bout d'un moment on voit dans
la zone Registre EAX=00003039. Intéressant car si on fait :
? EAX
on voit apparaître : 00003039 0000012345 "09"
3039 c'est en hexadécimal et 12345 c'est en décimal.
12345 ce ne serait pas le code que l'on a tapé au début ? Mais si,
on ne doit pas être très loin.
On continue à tracer (avec F10) tout en surveillant EAX et après
quelques F10, eax change !!!
EAX a changé. Il est devenu : EAX=7D5F4
on tape ? EAX
on obtient: 0007D5F4 00005135314
Tiens si on essayait 513534 comme code ?
On fait control + D et on tape BC 0,1 pour effacer les 2 points d'arrêt.
F5 et nous voilà sous Windows.
Donc on entre First Name: ACiD
Last Name : BuRN
Code : 513524
Et voilà le programme ne nous envoie pas chier, nous sommes maintenant
enregistrés !!! Hihihi, trop simple n'est-ce-pas ?
Mais bon, ne vous réjouissez pas trop vite, il existe des protections
par name/serial BCP BCP plus dures, un exemple est Phrozen Crew trial crackme!
Car dans ce cas là, j'ai dû faire une équation, et le serial n'est pas tapable
au clavier directement.. je vous invite donc à lire ce cours qui se trouve sur
ma page :)
Petite astuce sur les programmes écrits en delphi:
les API précédemment citées ne marchent pas en Delphi!! car ils ne sont pas
utilisés! donc pour pouvoir Breaker:
BPX hmemcpy <-- je me sers très souvent de celui-là !! On est sûr de
stopper dans Soft-ice au moins!
Dans de nombreux programmes, la comparaison GOOD serial / BAD serial se fait
de la façon suivante:
CMP EAX, EDX
je good message
jmp get_the_fuck_outta_here!
En gros, le bon serial (dans EDX) est comparé au mauvais serial dans (EAX)
Il suffit de faire: d EAX (pour voir le faux serial)
d EDX (pour voir le bon serial)
Autre astuce, pour ce genre de contrôle de serial !!
Si le programme est en Delphi et que vous ne cherchez qu'un serial valide:
mettez un bpx Hmemcpy après avoir entré un nom et numéro de série.
Ensuite, pressez le bouton OK, et vous revenez sous Soft-ice, maintenant
pressez F5 le nombre de fois nécessaire pour quitter Soft-ice mais comptez
les !! exemple: 12 fois
Ensuite, recommencez la même chose, mais arrêtez vous une fois avant le
nombre de F5 que vous avez compté! Pour mon exemple: 12 fois - 1 = 11 fois
donc vous pressez F5 11 fois !!
Ensuite pressez F12 pour quitter les Dll tels que USER32, kernel32 une fois
que vous êtes au bon endroit (vous verrez le nom de l'exe à la place du
nom des dlls) commencez à tracer avec F10!
Vous rencontrerez une série de RET, mais ça ne fait rien !!!!
Au bout d'un moment, pas long du tout ;p vous allez vous retrouver avec
qq chose du style:
mov eax, blablabla
mov EDX, blablabla
Call blablabla <-- entrez dans ce call grâce à F8
jz blablabla
Tracez ensuite avec F10 et vous devriez voir le fameux: CMP EAX, EDX
décrit plus haut ;))
Note: en faisant: D eax et D edx sans entrer dans le call, on aurait eu les
serials aussi !!!
Et le jz (jz = je) , c'est lui qui défini si c'est ok !! Remplacez-le
par un JMP par exemple et le programme ira toujours au bon message !!
donc vous serez enregistré :) Oh my god hehe :)
Je ne vais pas encore écrire un tut pour ça ;p mais je dois avoir encore
un exemple sur un name / serial.
Cette fois-ci, c'est sur un crackme programmé en Delphi :) donc
on va utiliser BPX hmemcpy comme prévu :))
***********************************
**** Hellforge Crackme 2 ****
***********************************
Ce crackme a une protection "Name/Serial"... chargez SI!
Il y a 2 BPX utiles pour ce genre de protection :
- bpx Getwindowtexta
- bpx Getdlgitemtexta
Ctrl+D
entrez les 2 breakpoints du dessus
F5
Enter name: ACiD BuRN et serial: 1122334455.
Cliquez sur "Click here to check your serial !!!"
Wrong code .. Quoi??? Nous ne sommes pas sous SI?? !
Donc ces breakpoints ne fonctionnent pas ici!! Merde!!
On va essayer bpx hmemcpy, ça marche tout le temps!
Ok, on réentre name: ACiD BuRN et serial: 1122334455.
Cliquez sur le bouton et là on est de retour dans Soft-ice !
Cool !
Nous voyons KERNEL en bas de la fenêtre... il faut sortir d'ici.
Pressez F12 autant de fois nécessaire (7x) pour que vous voyez en bas de la fenêtre:
HF CRACKME ..
Nous sommes à la bonne place... F10 pour continuer à tracer...
EAX contient la longueur du nom : ACiD BuRN = 9
Continuez de tracer avec SI encore un peu et vous voyez que EAX=B92COC
tapez d eax dans SI et vous voyez ACiD BuRN
et un nombre: 104837121. Qu'est ce ? un serial?
On va l'essayer!
Désactivez tous les breakpoints avec BD * :
nAME: ACiD BuRN
cODE: 104837121
Cool, le message !!!
Well done, Crackme cracked !!
Comment keygener pas mal de programmes (utilisation des BPR...)
Avant de vous parler des méthodes comme l'utilisation de BPR, je vais
vous décrire ce qu'est le keygening pour ceux qui ne savent pas !!
Keygener un programme c'est quoi ?
C'est écrire un programme qui génère des clefs (serials) valides pour
un programme donné, en fonction des noms, numéro de série du
disque dur ...
Bref, on trace avec Soft-ice la génération du serial en mémoire et
on reprogramme ceci, afin que l'on obtienne les codes valides pour
ce programme très rapidement :)
C'est très intéressant, croyez moi :)
Bon tout d'abord, je vais vous montrer un exemple très simple !!
Sans méthode spécifique, et ensuite, dans un prochain exemple
vous montrer qu'utiliser les BPR est un gain de temps non négligeable !!
*******************************************************************
**** How to keygen the Cracking4newies Crackme 3 project ****
*******************************************************************
niveau: débutant
I) C'est parti !!
Ok, c'est parti, il est temps de keygener cette chiotte :) donc dans
Soft-ice, mettez vos BPX préférés !! Ceux utilisés dans les protections par
names / serials :
bpx getwindowtewta et getdlgitemtexta .
Entrez votre nom et un faux serial (name : ACiD BuRN / Serial : 12345).
Clickez sur enter et vous êtes de retour dans Soft-ice !!
Pressez F12 parce que vous n'êtes pas à la bonne place, mais dans cette merde
de user32.dll...
Maintenant, vous êtes dans le crackme ! (j'espère que vous comprenez tout,
je suis trop fatigué !)
Tracez tant que vous n'arrivez pas à ça:
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004010C6(C)
|
:004010AF 0FBE4415C0 movsx eax, byte ptr [ebp+edx-40]
; mets en eax la 1ère valeur ascii de votre nom (pour ACiD BuRN : A=41)
:004010B4 03F0 add esi, eax /
:004010B6 8D7DC0 lea edi, dword ptr [ebp-40] /
:004010B9 83C9FF or ecx, FFFFFFFF /
:004010BC 33C0 xor eax, eax /
:004010BE 42 inc edx / Boucle
:004010BF F2 repnz /
:004010C0 AE scasb /
:004010C1 F7D1 not ecx /
:004010C3 49 dec ecx /
:004010C4 3BD1 cmp edx, ecx /
:004010C6 76E7 jbe 004010AF /
Ok cool, mais que fait cette boucle ? :
movsx eax, byte ptr [ebp+edx-40] <== eax = valeur ascii du caractère à la position EDX
add esi, eax <== esi = esi + eax
inc edx <== caractère suivant
cmp edx, ecx <== compare la longueur du nom avec le compteur en edx
jbe 004010AF <== Boucle tant que tout les chars n'ont pas été faits!
Donc, cette boucle prends les valeurs ascii de chaque lettres et les ajoutes dans ESI.
Résultat pour ACiD BuRN: 2A8h
41h + 43h + 69h + 44h + 20h + 42h + 75h + 52h + 4Eh = 2A8h
A C i D space B u R N
Après cette boucle, vous arrivez ici:
:004010C8 897508 mov dword ptr [ebp+08], esi ; [ebp+8] prends la valeur d'ESI
:004010CB C1650807 shl dword ptr [ebp+08], 07 ; [ebp+8] = shl [ebp+8],7
:004010CF 8D4DF4 lea ecx, dword ptr [ebp-0C]
:004010D2 6A0A push 0000000A
:004010D4 51 push ecx
:004010D5 68E9030000 push 000003E9
:004010DA 53 push ebx
Comme vous pouvez le voir, la valeur d'ESI (pour moi: 2A8) est placée dans [ebp+8].
Ensuite, on voit : shl dword ptr [ebp+08], 07
Intéressant ;)
Ben, on continue à tracer :-]
Tant que vous n'arrivez pas à ça :
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004010E4(C)
|
:00401102 8D55F4 lea edx, dword ptr [ebp-0C]
:00401105 52 push edx
:00401106 E840010000 call 0040124B
:0040110B 8B4D08 mov ecx, dword ptr [ebp+08] ; ECX = [ebp+8] ([ebp+8]= shl esi,7)
:0040110E 83C404 add esp, 00000004
:00401111 03CE add ecx, esi ; ECX = ECX + ESI (ESI=2A8 pour moi)
:00401113 3BC8 cmp ecx, eax ; ? eax = fake serial / ? ecx = bon
:00401115 6A00 push 00000000
:00401117 751B jne 00401134 ; si c'est pas égal saute à BAD CRACKER
* Possible StringData Ref from Data Obj ->"Good!"
|
:00401119 685C504000 push 0040505C
* Possible StringData Ref from Data Obj ->"Congratulations!!"
|
:0040111E 6848504000 push 00405048
:00401123 53 push ebx
Sympa tout ça! Vous pouvez coder un keygen facilement non ? !!
Laissez-moi vous répéter l'algo:
1st part: Additionnez les valeurs ascii du nom et mettez le résultat qq part (ESI en mémoire)
2nd part: Prenez la valeur en ESI et faites un shl,7 dessus et mettez le résultat qq part
([ebp+8] en mémoire)
3rd part: Additionnez la valeur de la première partie et additionnez là à celle de la
2ème partie
4th part: Prenez le résultat en décimal et vous avez votre serial :)
Name : ACiD BuRN
sERiAL : 87720
Je vous ai tout donné pour faire votre propre keygen, mais je vous file qd même mes sources:
Je vais vous montrer 2 sources! Une en Delphi+asm et une en C+asm.
Celle en Delphi a été codée à 2h du matins !! vite fait :) mais ça marche :))
*********************SOURCES DELPHI************************
procedure TForm1.Edit1Change(Sender: TObject);
var i,ascii,result: integer;
begin
for i:=1 to length(edit1.text) do
begin
ascii:=ascii + ord(edit1.text[i]);
end;
asm
mov eax,ascii
mov ecx,ascii
shl eax,7
add eax,ecx
mov ascii,eax
end;
result:=ascii;
edit2.text:=inttostr(result);
end;
end.
*********************FIN DE SOURCES DELPHI*********************************************
Maintenant la version en C+asm (le C me sert juste pour déclarer les variables!
Bien moins chiant que l'asm direct!!)
*********************SOURCES C++ + ASM************************************************
#include
#include
#include
int main(){
int i,len;
unsigned char name[100];
unsigned long check=0;
printf("\[ Cracking4Newbies crackme3 ] *Keygen* By : ACiD BuRN / ECLiPSE 1999\n");
printf("\______________________________________________________________________\n");
printf("\nEnter your name: ");
gets(name);
len=strlen(name);
asm
{
xor ecx, ecx
xor edx, edx
xor esi, esi
xor edi, edi
mov esi, [len]
start:
movsx eax, [name+ecx]
add edi, eax
mov eax, edi
inc ecx
cmp ecx, esi
jne start
shl edi, 7
add edi,eax
mov [check], edi
}
printf("Your Serial is: %lu" ,check);
printf("\nEnjoy!");
getch();
return 0;
}
*********************FIN DE SOURCES C++ + ASM****************************************
*************************************************************************************
**** BPR: La bonne méthode :) ****
*************************************************************************************
Maintenant ! Utilisation des BPR pour keygener !
La technique que je vais vous montrer marche très très bien avec les programmes
en C++ par exemple :)
Je ne vais pas vous saouler longtemps, mais écrire directement un exemple
d'utilisation de cette commande!!
On va bosser sur un Crackme: RD116 Crackme
Ok, la protection est de type name / serial! Ca a été écrit en C++
Coool, très bien pour s'amuser avec !!
On peut keygener ce crackme sans utiliser les BPR, mais grâce aux BPR.
Vous allez voir comment tomber directement sur la routine de génération
du serial !!! Let's go:
Entrez votre nom : ACiD BuRN et serial: 112233
Sous Soft-ice mettez les bpx suivants: bpx getdlgitemtexta et
bpx getwindowtexta ....
Ensuite pressez le bouton pour vérifiez le serial et vous êtes de retour
sous Soft-ice!!
On voit "Break due to BPX USER32!GETWINDOWTEXTA ...
Ok! Alors ne pressez pas F11 ni F12 encore sinon on ne pourra pas examiner
les paramètres sur la pile !!
On va agir intelligemment plutôt ! On va examiner la pile !
Nous allons regarder les paramètres mais pour cela on va se mettre en
Dword sous Soft-ice !! Ca sera plus lisible déjà.
Sous Soft-ice: dd esp
"dd" veut dire: display dword et "esp" c'est pour le pointeur de pile!
Après avoir fait "dd esp", la fenêtre de Soft-ice change et on peut voir les paramètres :
xxxx:yyyyyyyy A B C D ................
xxxx:yyyyyyyy E F G H ................
Où A,B,C,D,E... sont du genre: XXXXXXXX
Vous devez voir qq chose qui ressemble à cela:
xxxx:yyyyyyyy 5F403504 00000098 00654250 0000000A ...........
On ne vas s'occuper que de çà !!
(donc vous l'avez remarqué, ici A=5F403504 , B=00000098 ...)
On voit ici l'adresse à laquelle notre nom se termine (00654250).
Tapez D "adresse à laquelle finis le nom"
exemple ici: D 00654250
Vous pouvez maintenant presser F11 et vous pouvez voir votre nom à l'adresse
que vous avez tapé :) C'est bon signe déjà !!
Nous allons maintenant poser un bpr (break on memory range).
Ce type de bp marche de la façon suivante:
bpr "adresse de départ" "adresse de fin" RW
RW veut dire: Read et write (lecture et écriture)
Donc, ça stoppera qd on lit ou écrit à cette adresse en mémoire !
Donc tapez ceci sous Soft-ice:
bpr 654250 654250+(longueur_du_nom - 1) rw
Dans notre exemple, cela donne pour ACiD BuRN (longueur: 9 -> 9 - 1 = 8)
bpr 654250 654250+8 rw
Vous pouvez désactiver les bpx sur getwindowtexta et getdlgitemtexta now !
Vous n'avez plus qu'à presser F5, et on se retrouvera directement dans la
routine de génération de serial !!
Notes: Pressez F5 tant que vous n'êtes pas dans le crackme !!
C'est-à-dire que les DLL on s'en branle :)
Une fois que vous êtes dans le crackme vous arrivez direct sur la
génération.
Une partie qui bosse sur le nom:
:00401580 8A18 mov bl, byte ptr [eax] ; Prends la valeur ascii (position cl)
:00401582 32D9 xor bl, cl ; XOR cette valeur avec le compteur
:00401584 8818 mov byte ptr [eax], bl ; store le résultat
:00401586 41 inc ecx ; incrémente ecx (ecx = ecx + 1 )
:00401587 40 inc eax ; incrémente eax (eax = eax + 1 )
:00401588 803800 cmp byte ptr [eax], 00 ; encore des lettres ?
:0040158B 75F3 jne 00401580 ; si oui, lettre suivante!
:0040158D 33C0 xor eax, eax ; remet à zero
:0040158F 33DB xor ebx, ebx ; les registres
:00401591 33C9 xor ecx, ecx ; EAX, EBX, ECX
:00401593 B90A000000 mov ecx, 0000000A ; ECX = Ah (10 en hexa)
:00401598 33D2 xor edx, edx ; EDX = 0
:0040159A 8B45F0 mov eax, dword ptr [ebp-10] ; on récupère les valeurs
2ème partie: sur le serial entré :
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004015A8(C)
|
:0040159D 8A18 mov bl, byte ptr [eax] ; Prends la valeur ascii (position cl)
:0040159F 32D9 xor bl, cl ; XOR cette valeur avec le compteur
:004015A1 8818 mov byte ptr [eax], bl ; store le résultat
:004015A3 41 inc ecx ; incrémente ecx (ecx = ecx + 1 )
:004015A4 40 inc eax ; incrémente eax (eax = eax + 1 )
:004015A5 803800 cmp byte ptr [eax], 00 ; encore des chiffres ?
:004015A8 75F3 jne 0040159D
:004015AA 8B45E4 mov eax, dword ptr [ebp-1C]
:004015AD 8B55F0 mov edx, dword ptr [ebp-10]
Et la dernière routine: vérification du serial
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004015BF(C)
|
:004015B0 33C9 xor ecx, ecx ; ECX = 0
:004015B2 8A18 mov bl, byte ptr [eax] ; on récupère les valeurs et on les
:004015B4 8A0A mov cl, byte ptr [edx] ; mets dans EAX et EDX
:004015B6 3AD9 cmp bl, cl ; on compare! c'est égal ?
:004015B8 7509 jne 004015C3 ; non jmp : bad cracker
:004015BA 40 inc eax ; eax = eax + 1
:004015BB 42 inc edx ; edx = edx + 1
:004015BC 803800 cmp byte ptr [eax], 00 ; on fait ça pour tout !
:004015BF 75EF jne 004015B0
:004015C1 EB16 jmp 004015D9 ; si tout est ok! GENTIL CRACKER
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:00401503(U), :0040151C(U), :004015B8(C)
|
:004015C3 6A00 push 00000000
* Possible StringData Ref from Data Obj ->"Rat"
|
:004015C5 686C304000 push 0040306C
* Possible StringData Ref from Data Obj ->"Mauvais serial, essaye encore... "
..........
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004015C1(U)
|
:004015D9 6A00 push 00000000 ; tout est ok !! on arrive ici
* Possible StringData Ref from Data Obj ->"Bien jou"
|
:004015DB 6834304000 push 00403034
* Possible StringData Ref from Data Obj ->"C' est crack"
|
:004015E0 6820304000 push 00403020
:004015E5 8B4DE0 mov ecx, dword ptr [ebp-20]
Donc voilà !! Je crois que vous avez compris ce qu'il se passe ici :)
La routine de génération est très simple !!
Je ne vais donc pas m'attarder dessus, mais je vais donner les sources du keygen
bien sûr !!
Après le C++, le Delphi, c'est au tour du VB !!
Ayant la flemme de traduire ça en ASM (très simple, mais j'ai pas le goût), je vous
propose tout de même ces sources !!
Le but de cette explication était la familiarisation avec les BPR !!
Pas de savoir keygener juste ce crackme là !!
Avec cette technique vous pouvez keygener bcp de choses, ensuite ça dépends
de votre niveau en asm et de la registration !!
Si ça fait 1000 lignes ! On fait copier-coller ;) et on programme en ASM
sans trop se poser de questions !
Bref, voici les sources:
********************** Source en VB: RDD-116 Crackme 1 Keygen***********************
Private Sub Text1_Change()
If Len(Text1.Text) < 6 Then
Text2.Text = "Le nom doit être supérieur à 6 chars"
Else
For i = 1 To Len(Text1.Text)
a = 9 + i
temp = Asc(Mid$(Text1.Text, i, 1)) Xor i Xor a
result = result & Chr(temp)
Next i
Text2.Text = result
End If
End Sub
********************** Source en VB: RDD-116 Crackme 1 Keygen***********************
Hehe simple non ?
Voilà, la partie des keygens est terminée, mais entraînez-vous avec les BPR!
C'est super et utilisé par bcp de keygeners aussi...
Pour le Delphi, il vous faut trouver l'adresse mémoire de votre nom et faire
à peu près la même chose ensuite :))
Enjoy !
Transformer un programme en son propre
keygen
Muad'dib Keygen Crackme #1
- Afficher le bon serial à la place du msg d'erreur
Introduction:
Il faut faire un keygen, les keygens c'est marrant mais on va apprendre autre chose cette fois.
On ne va pas coder un keygen (qui d'ailleurs est très simple à faire) mais forcer le crackme
à afficher le bon serial à la place du message: "try again , Blablabla.."
utils nécessaires:
- Soft-ice (it r0x)
- éditeur hexadécimal
Let's kick some ass =)
Bon, déjà on lance ce con de crackme, et on entre son nom: ACiD BuRN et un serial
à 2 francs: 0800
Ensuite dans Soft-ice (ctrl+d) on tape: Bpx hmemcpy
On click sur Register et on arrive dans Soft-ice.. F12 pour sortir dans dlls et dès
qu'on est dans le crackme on commence à tracer.
On arrive assez vite à une routine qui contrôle le type de nom entré (minuscules,
majuscules, espaces, chiffres ...) mais il y a d'abord un check sur la longueur du nom:
025F:004010A3 83F804 CMP EAX,04 <-- compare la taille du nom à 4
025F:004010A6 7304 JAE 004010AC <-- ok si supérieur ou égal à 4
025F:004010A8 C9 LEAVE
025F:004010A9 C21000 RET 0010
Apres ça, il y a le contrôle des caractères :
025F:004010AC BA00000000 MOV EDX,00000000
025F:004010B1 8A8200314000 MOV AL,[EDX+00403100]
025F:004010B7 3C00 CMP AL,00
025F:004010B9 7426 JZ 004010E1
025F:004010BB 3C20 CMP AL,20
025F:004010BD 7408 JZ 004010C7
025F:004010BF 3C41 CMP AL,41
025F:004010C1 7C07 JL 004010CA
025F:004010C3 3C5A CMP AL,5A
025F:004010C5 7F03 JG 004010CA
025F:004010C7 42 INC EDX
025F:004010C8 EBE7 JMP 004010B1
025F:004010CA 6A00 PUSH 00
025F:004010CC 687D304000 PUSH 0040307D
025F:004010D1 684D304000 PUSH 0040304D
025F:004010D6 6A00 PUSH 00
025F:004010D8 E8BD000000 CALL USER32!MessageBoxA
Cette merde check si notre nom a des minuscules, majuscules, espaces ...
Si c'est pas ok, ça jump à 4010CA, et un message box nous dit de n'enter que des majuscules
et des espaces...
Merci, mais on avait compris ;)
Donc, on sort de Soft-ice, on met: ACID BURN comme nom, et 0800 tjs pour le serial
et on y retourne. On trace et on tombe sur la comparaison finale:
025F:0040112D 68F6304000 PUSH 004030F6 <- d 4030f6 = fake serial
025F:00401132 6800314000 PUSH 00403100 <- d 403100 = bon serial
025F:00401137 E840000000 CALL KERNEL32!lstrcmp
025F:0040113C 83F800 CMP EAX,00
025F:0040113F 7517 JNZ 00401158
025F:00401141 6A00 PUSH 00
025F:00401143 68D3304000 PUSH 004030D3 <- d 4030D3 = Good (titre de la msg box)
025F:00401148 6889304000 PUSH 00403089 <- d 403089 = Bon message qd tu as le serial
025F:0040114D 6A00 PUSH 00
025F:0040114F E846000000 CALL USER32!MessageBoxA
025F:00401154 C9 LEAVE
025F:00401155 C21000 RET 0010
025F:00401158 6A00 PUSH 00
025F:0040115A 68EA304000 PUSH 004030EA <- d 4030EA = Bad (titre de la msgbox)
025F:0040115F 68DD304000 PUSH 004030DD <- d 4030DD = bad boy ;p pas le bon pass
025F:00401164 6A00 PUSH 00
025F:00401166 E82F000000 CALL USER32!MessageBoxA
En résumé, on voit une comparaison bon serial / mauvais serial exécutée par l'API
lstrcmp, qui compare des strings. On voit un CMP EAX,00 : si la comparaison est ok
le serial est bon, donc EAX = 0 et on affiche le bon messagebox :)
Sinon, ça saute à la mauvaise box !!
Ok donc pour nous, ici :
025F:0040112D 68F6304000 PUSH 004030F6 <- d 4030f6 = fake serial
025F:00401132 6800314000 PUSH 00403100 <- d 403100 = bon serial
d 4030f6 nous donne: 0800
d 403100 nous donne: XZP]P[LKW
Le bon serial ok, mais c'est pas ça qu'on veut :)
On veut forcer le prog à montrer le bon serial à la place du message d'erreur :)
Pour cela, on voit que juste avant la msg box Bad serial il y a 2 push :
le caption du titre de la title bar = push 4030EA
le texte du message du msgbox = push 4030DD
Il push ces merdes, et ensuite il affiche le message à la con !
Donc pour le faire afficher le bon serial tu prends l'adresse du push 'bon serial' et tu la
copies à la place du push 'message comme quoi tu as foiré' !!
025F:0040115A 68EA304000 PUSH 004030EA
025F:0040115F 68DD304000 PUSH 004030DD
025F:00401164 6A00 PUSH 00
025F:00401166 E82F000000 CALL USER32!MessageBoxA
cela devient:
025F:0040115A 68EA304000 PUSH 004030EA
025F:0040115F 6800314000 PUSH 00403100 <-- push bon serial
025F:00401164 6A00 PUSH 00
025F:00401166 E82F000000 CALL USER32!MessageBoxA
On a maintenant plus qu'à modifier physiquement notre crackme, et le bon pass apparaîtra
à la place de l'erreur :) et voilà notre super keygen pour branleurs :)
Hehe, c'est rapide, efficace, et on se fatigue pas :P
on cherche donc dans l'exe: 68EA30400068DD304000
on remplace dans l'exe par: 68EA3040006800314000
Tu saves le fichier, et tu lances, mets un serial en majuscules et goodie :))
Le good serial apparaît, Facile ....
Remarques on a toujours le titre : erreur code dans la msg box, rien ne vous empêche
de le changer en: Keygen ;)
***********************************************************
**** Reprogrammer la routine de Contrôle du serial ****
***********************************************************
Toujours sur le même crackme !!
On va donc recoder le check du serial dans Soft-ice pour s'occuper,
ça va prendre 10 secs, mais bon ;)
C'est juste pour montrer que on peut faire bcp de choses en fait....
notre routine de base:
025F:0040112D 68F6304000 PUSH 004030F6 <- d 4030f6 = fake serial
025F:00401132 6800314000 PUSH 00403100 <- d 403100 = bon serial
025F:00401137 E840000000 CALL KERNEL32!lstrcmp
025F:0040113C 83F800 CMP EAX,00
025F:0040113F 7517 JNZ 00401158
025F:00401141 6A00 PUSH 00
025F:00401143 68D3304000 PUSH 004030D3 <- d 4030D3 = Good (titre de la msg box)
025F:00401148 6889304000 PUSH 00403089 <- d 403089 = Bon message qd tu as le serial
025F:0040114D 6A00 PUSH 00
025F:0040114F E846000000 CALL USER32!MessageBoxA
025F:00401154 C9 LEAVE
025F:00401155 C21000 RET 0010
025F:00401158 6A00 PUSH 00
025F:0040115A 68EA304000 PUSH 004030EA <- d 4030EA = Bad (titre de la msgbox)
025F:0040115F 68DD304000 PUSH 004030DD <- d 4030DD = bad boy ;p pas le bon pass
025F:00401164 6A00 PUSH 00
025F:00401166 E82F000000 CALL USER32!MessageBoxA
Comparaison grâce à l'API lstrcmp.
On va transcrire ça en :
025F:0040112D A1F6304000 MOV EAX,[004030F6]
025F:00401132 8B1500314000 MOV EDX,[00403100]
025F:00401138 3BC2 CMP EAX,EDX
025F:0040113A 7405 JZ 00401141
025F:0040113C EB1A JMP 00401158
025F:0040113E 90 NOP
025F:0040113F 90 NOP
025F:00401140 90 NOP
025F:00401141 6A00 PUSH 00
025F:00401143 68D3304000 PUSH 004030D3
025F:00401148 6889304000 PUSH 00403089
025F:0040114D 6A00 PUSH 00
025F:0040114F E846000000 CALL USER32!MessageBoxA
025F:00401154 C9 LEAVE
025F:00401155 C21000 RET 0010
025F:00401158 6A00 PUSH 00
025F:0040115A 68EA304000 PUSH 004030EA
025F:0040115F 68DD304000 PUSH 004030DD
025F:00401164 6A00 PUSH 00
025F:00401166 E82F000000 CALL USER32!MessageBoxA
Ceci fait exactement la même chose, mais n'utilise pas d'API pour comparer.
On met en EAX: l'adresse du serial entré, et en EDX le bon serial.
On les compare via : CMP EAX, EDX
Ensuite un saut conditionnel à la con et un Jump...
Les nop n'étaient pas utiles, mais ça fais plus clean ;)
Voilà, le prog contrôle si le serial est valide d'une autre manière, ça sert à
rien, c'était juste pour montrer ce qu'on peut faire avec de l'imagination, hehe
On peut bien s'amuser donc :]
Time Limits (limitation de 30 jours et autres
merdes !!)
Comme vous l'avez sûrement remarqué, il existe des programmes
qui ne sont pas enregistrables car il n'y pas moyen de s'enregistrer !!
Ils sont en générale limités à 30 jours!!
C'est ce qu'on appelle: Time limit protection !!! Comment cracker ça ?
Il y a plusieurs façons !! Nous allons voir ça de suite !!
Méthode avec W32Dasm:
Vous avez un programme nomme X, qui après 30 jours ne marche plus :(
Mais en revanche, il nous envoie une messagebox disant:
"La période d'évaluation est terminée..." ou "Trial version expirée..."
Bref ce genre de conneries !!
Alors si vous avez ça, vous lancez W32Dasm et désassemblez le fichier à cracker.
Vous cherchez cette phrase dans les String Data References et une fois
que vous avez trouvé, double-clickez dessus afin d'aller à la place
de cette phrase dans W32Dasm !!
Et maintenant ?? Ben on étudie le code aux alentours !! Ca ne vas pas être
bien dur !!
Généralement vous devriez trouver au dessus du message d'erreur des sauts
conditionnels de type JL, JLE, JG, JGE .....
Par exemple:
CMP DWORD PTR EAX, 1E <-- 1Eh = 30 en décimal (30 jours!)
JLE 00405840 <-- jump au programme si c'est égal ou inférieur à 30 jours
Ici on voit qu'il compare le nombre de jours écoulés avec 30!
Tant que c'est inférieur ou égal à 30 jours le programme marchera !!
Mais une fois dépassé les 30 jours !! Ca marche plus :(
Donc pour cracker ça on force le programme à sauter quoi qu'il arrive en changeant
le JLE en JMP !! et le programme sautera inconditionellement comme si de rien n'étais!
Il croira tjs que l'on est encore dans la période des 30 jours heheh !!
Avec Soft-ice:
Tout d'abord regardons les API utilisées dans les time limites!! :
(eq: win32API.hlp)
Je ne traduirais pas, pour ne pas détériorer les infos données.
********************************************************************************************
* GetFileTime
The GetFileTime function retrieves the date and time that a file was created, last accessed,
and last modified.
BOOL GetFileTime(
HANDLE hFile, // identifies the file
LPFILETIME lpCreationTime, // address of creation time
LPFILETIME lpLastAccessTime, // address of last access time
LPFILETIME lpLastWriteTime // address of last write time
);
Returns
If the function succeeds, the return value is TRUE.
If the function fails, the return value is FALSE. To get extended error information, call
GetLastError
********************************************************************************************
* GetLocalTime
GetLocalTime function retrieves the current local date and time.
VOID GetLocalTime(
LPSYSTEMTIME lpSystemTime // address of system time structure
);
Returns
This function does not return a value.
********************************************************************************************
* GetSystemTime
The GetSystemTime function retrieves the current system date and time. The system time
is expressed in Coordinated Universal Time (UTC).
VOID GetSystemTime(
LPSYSTEMTIME lpSystemTime // address of system time structure
);
Returns
This function does not return a value.
********************************************************************************************
* SystemTimeToFileTime
The SystemTimeToFileTime function converts a system time to a file time.
BOOL SystemTimeToFileTime(
CONST SYSTEMTIME * lpst, // address of system time to convert
LPFILETIME lpft // address of buffer for converted file time
);
Returns
If the function succeeds, the return value is TRUE.
If the function fails, the return value is FALSE. To get extended error information,
call GetLastError.
********************************************************************************************
Voilà !! Donc ça c'était les API les plus couramment utilisées dans les protections
par time limites!
Cependant, l'API la plus souvent utilisée est : Getlocaltime
Donc vous mettez un Bpx dessus et vous lancez le programme !
Soft-ice break ! Pressez F12 pour arriver au bon endroit dans le programme et commencer
à tracer !!
Si vous voyez un saut de type: JL, JLE, JGE, JG vous savez ce qu'il vous
reste à faire !!
Je ne vais pas écrire des tonnes encore sur cette protection aussi stupide que
simple à cracker !!
Vous trouvez un exemple de Time limite mais dans la partie Visual Basic!!
Comment cracker un programme VB avec W32Dasm original !! ;-)
l33t hehe
Sinon, j'espère que vous voyez comment cracker ça maintenant ......
Nag et autres Splash screen (diverse méthodes...)
C'est la partie qui me fait le plus chier à écrire je pense !!
Pourquoi ? Car j'aime pas les nags screen !!
Je trouve ça ennuyeux ;)
Mais on doit y passer alors commençons dès maintenant !!
Qu'est-ce qu'un Nag screen ?
Un nag screen, c'est une fenêtre qui vient vous dire que vous
n'êtes pas enregistré et qu'il faut payer vite fait pour qu'elle disparaisse :)
Bref, c'est vraiment ennuyant, on peut tomber sur un NAG avec un bouton
désactivé qui se réactive après qq secondes par exemple !!
Bref casse-couilles à souhait ;)
Avant de commencer avec les trucs un peu plus compliqués avec Soft-ice et tout,
on va commencer par Simple !!
Cracker un nag screen avec seulement un éditeur hexadécimal.
Quoi ? Vous vous demandez quelle connerie je suis en train de raconter lol !!
L'exemple que vais vous montrer est comment cracker le NAG screen de WinRAR 2.6
quand la limite dans le temps à expirée !!
Vous pourrez essayer cette technique sur ICQ99 afin de kicker les 8 secs au démarrage!!
Bref assez bavardé !! Let's start :
*********************************
* Cracker le nag de WinRAR 2.6b *
*********************************
Tu lances WinRAR, après avoir mis la date en avance, style : 2002.
Là tu vois un nag screen avec 5 boutons de merdes !!
Il y en a 1, avec Close...
Tu clicks dessus et WinRAR marche normalement. Donc, on va émuler la
pression sur ce bouton.
Piner Le nag :)
~~~~~~~~~~~~~~
Donc, voici une méthode qui marche souvent, pour émuler la pression d'un
bouton... Vous avez juste besoin d'un éditeur hexadécimal (moi j'utilise hex workshop).
Donc, vous lancez WinRAR encore et regardez le caption du bouton : Close
puis ouvrez WinRAR avec un éditeur hexa et recherchez en hexa: 43006C006F0073006500
43006C006F0073006500 =
C l o s e
donc vous recherchez la valeur hexa de chaque Caractères, plus 00 entre chaque valeur.
Vous devez arrivez ici :
4600 0E00 0100 FFFF 8000 4300 6C00 6F00 F.........C.l.o. <== C l o s e ici !!! heh
7300 6500 0000 0000 0000 0150 0000 0000 s.e........P....
9500 4300 4600 0E00 0900 FFFF 8000 2600 ..C.F.........&.
4800 6500 6C00 7000 0000 0000 0700 0050 H.e.l.p........P
0000 0000 0400 0400 8B00 4D00 FFFF FFFF ..........M.....
8000 0000 0000 0000 0000 0250 0000 0000 ...........P....
0900 1000 8200 3700 FFFF FFFF 8200 5000 ......7.......P.
6C00 6500 6100 7300 6500 2000 6E00 6F00 l.e.a.s.e. .n.o.
Donc, voilà vous êtes à la bonne place, now pour émuler, vous avez juste à regardez le
FFFF82 ou FFFFFFFF82 le plus proche et changer le 82 en 7E !!!
donc :
4600 0E00 0100 FFFF 8000 4300 6C00 6F00 F.........C.l.o.
7300 6500 0000 0000 0000 0150 0000 0000 s.e........P....
9500 4300 4600 0E00 0900 FFFF 8000 2600 ..C.F.........&.
4800 6500 6C00 7000 0000 0000 0700 0050 H.e.l.p........P
0000 0000 0400 0400 8B00 4D00 FFFF FFFF ..........M.....
8000 0000 0000 0000 0000 0250 0000 0000 ...........P....
0900 1000 8200 3700 FFFF FFFF 8200 5000 ......7.......P. <== ici tu vois FFFFFFFF82 !!!
6C00 6500 6100 7300 6500 2000 6E00 6F00 l.e.a.s.e. .n.o.
COOL !! Là tu es à la bonne place, donc tu remplaces le 82 par un 7E
et hop le nag a mouru ;)
Donc :
0900 1000 8200 3700 FFFF FFFF 8200 5000 ......7.......P.
devient :
0900 1000 8200 3700 FFFF FFFF 7E00 5000 ......7.....~.P.
Tu saves ton fichier WinRAR, le relance et plus de nag du tout :)
Si tu remets la date en arrière, toujours pas de nag, donc Voilà c'est terminé.
Conseil: Ils auraient dû fermer le prog une fois le temps dépassé! Ca aurait forcé le
cracker à jouer un peu plus et cracker le time limite !
Pour le reste des protections, c'est tres simple ! Avec ce que vous avez dû lire
avant d'arriver ici, vous ne devriez pas avoir de problèmes !
On va passer à un autre type de Nag Screen !! Les messagebox.
C'est très chiant, mais quand on voit ça !! On est quand même content car ça se vire
en 10 secondes ;)
Les messageboxes se reconnaissent grâce à leurs icônes déjà !
Les icônes que l'on voit dans Windows avec comme signe: le point d'exclamation,
la croix blanche sur rond rouge.... et un message l'accompagnant !!
Comment cracker ça ? Bien je vais montrer 2 façons!!
- Avec W32Dasm (cracker like a wanker):
Vous lancez votre programme et vous voyez le message qui nous dit:
"Version Shareware! please Register" ou un truc chiant du style !!
Pour virer ça, vous ouvrez W32Dasm et désassemblez le fichier du programme!
Vous faites un tour dans les String Data References à la recherche de cette phrase!
Vous allez la trouver avec 98 % de chances !!
Donc vous double-cliquez sur cette phrase et recherchez au dessus d'un saut conditionnel
qui vous fait atterrir sur le nag ou au contraire le sauter !!
ET vous le nopez ou forcez a sauter en fonction de ce que vous trouvez !!
ex:
JE 00406280
.................
Possible String Data Reference BLABLA to: Please Register Now !...
XXXX:00406280 PUSH 00
XXXX:00406282 PUSH 004062E0 ;"Register!"
XXXX:00406287 PUSH 00406360 ;"Please Register Now!!.."
XXXX:0040628C PUSH 00
XXXX:0040628E CALL [USER32!MessageBoxA]
....................
Ici, si ce "je" nous amène à tout les coups sur le message d'erreur, on le NOP
et il ne sautera plus jamais !
Ceci est un exemple mais ça ressemble à ça en gros.
C'est pas très clean, et ça fait branleur mais bon :)
Plus ça va vite et plus vous êtes content je présume ....
- Avec Soft-ice:
Avec Soft-ice on va tout simplement poser un BPX sur MessageBoxA!
Donc Ctrl+D et tapez votre BPX!
Lancez le programme et Soft-ice break! Pressez F12 et vous retournez sous
Windows !! Là vous clickez sur le bouton OK du nag et vous vous retrouvez sous
Soft-ice encore une fois !!
Juste au dessus de votre emplacement actuel vous devez voir le Call qui appelle
le messageBox !!
On peut cracker comme un bourin en nopant ce call, mais ça fait pas très pro,
le mieux c'est de foutre un RET juste après être entré dans le CALL..
Petit exemple théorique:
XXXX:00406280 PUSH 00
XXXX:00406282 PUSH 004062E0 ;"Register!"
XXXX:00406287 PUSH 00406360 ;"Please Register Now!!.."
XXXX:0040628C PUSH 00
XXXX:0040628E CALL [USER32!MessageBoxA] <--- ici on fait F8
Après avoir fait le F8 on voit un truc comme ça :
025F:00401510 FF253C324000 JMP [USER32!MessageBoxA] <-- le F8 nous mène ici
025F:00401516 FF2540324000 JMP [USER32!MoveWindow]
025F:0040151C FF2544324000 JMP [USER32!DialogBoxParamA]
........................
Après avoir fait le F8, on est donc sur un JMP qui va appeler le MessageboxA .
Donc sur cette ligne vous faites:
A {enter}
RET {Enter}
{echap}
Le programme arrive et prends le RET et sort de cette routine en 2 temps 3 mouvements!
et hop il continue sa route sans jamais afficher aucune connerie !
Ensuite vous faites la modif dans l'exécutable lui-même et on en parle plus :]
Je vais expliquer Rapidement une méthode qui utilise un BPX qui est très rarement
utilisé pour cracker les Nags, mais plutôt dans les names / serials !
Mais c'est un plaisir de l'utiliser dans les programmes écrits en Delphi par exemple !
Le BPX est : hmemcpy
Méthode théorique:
Vous mettez ce BPX et vous lancez le programme en Delphi à cracker!
Soft-ice break! Vous pressez F5 le nombre de fois qu'il faut pour obtenir le NAG screen
et vous comptez le nombre de F5 qu'il vous a fallut bien sûr!!
On va dire: 14 fois F5 pour voir le nag !!
Alors on relance le programme et on fera F5 le nombre de fois que vous avez trouvé
moins 1 !! (14 - 1 = 13 ici)
On presse 13 fois F5 ici !! Ensuite on presse F12 pour revenir dans l'exécutable
et quitter ces dlls à la con :=)
Après avoir fait ça, vous tracez comme un dingue avec F10 et vous allez arriver sur une série
de CALL , MOV , CALL , MOV ....
Ca se voit tout de suite, il y a quasiment que ça !!
Et là vous mettez un BPX à l'emplacement où cette routine commence et vous tracez avec
F10! Le NAG screen va apparaître en passant sur un call normalement !! Vous repérez
quel CALL c'est et puis vous lui mettez un bpx une fois avoir désactivé tout les autres!
Vous breakez dessus! Première façon bourin: on nope le call comme un goret ;)
On a de la chance ça marche !! KeWl !!
Alors on peut entrer dans le Call avec F8 et mettre un ret sur le Push ebp qui doit
s'y trouver!! (c'est pas tjs un Push ebp ;p)
On presse F5 et si le nag est parti et que ça ne crash pas, c'était le bon endroit !!
Si tout ça a amené à un méchant crash :-/ , il vous faut après avoir entré ce call
chercher un autre call qui affiche le nag à l'intérieur !!
et le noper !!
Si le nag est avec timer, on doit trouver un CALL GETTICKCOUNT pas loin de celui-ci
non plus !! Cette API est souvent utilisée pour ça ;)
On peut aussi utiliser L'API: Destroywindow qui nous amène dans Soft-ice après avoir
tué le nag ! Là on presse F12 et on regarde les calls plus haut et on retrouve
souvent les calls et les movs de tout à l'heure qui sont si charmants, lol.
Bref, cette technique, je ne l'ai jamais vu dans aucun cours en français ou bien
US, mais elle permet de cracker un nag Delphi en 2 mins sans se faire chier à tracer
comme un dingue jusqu'à trouver LE CALL !!
Sinon, voici une liste d'API utilisées dans le cracking des nags screen:
pour tout ce qui est messagebox:
MessageBox
MessageBoxA
MessageBoxExA
MessageBeep
ou encore ceci pour afficher du texte!
SENDMESSAGE
WSPRINTF
et pour les générations de fenêtre:
createwindow
createwindowexa
showwindow
Voilà, je pense que vous avez déjà de quoi cracker pas mal de nags screen à la con!
La plus part du temps c'est : Posez le BPX, tracez, trouvez le CALL, killez le !
et on ne reparle plus du NAG !!
Keyfile
Qu'est ce qu'un keyfile ?
C'est un fichier licence que l'on place dans le répertoire courant du programme
pour l'enregistrer !
On a donc rien à entrer comme un name / serial!
On n'utilise pas les mêmes API mais surtout l'API CreateFileA.
Je vais montrer un exemple:
********************************
* termial Cilla's CrackMe 1.0 *
********************************
Je vous préviens de suite, ce crackme contient une protection par Key file, qui
est très simple, mais que je considère bien pour le sujet d'un cours général !
Je ne vais pas vous faire un cours sur un keyfile qui est trop long et qui va vous
perturber !!
Le crackme a besoin d'un fichier keyfile, ici il s'appelle TC1.key .
Je crée un fichier keyfile à la con contentant le texte:
"ACiD BuRN 4 EVER Ph34rs "
Si on édite en hexa on obtient ceci:
00000000: 41 43 69 44 20 42 75 52 4E 20 34 20 45 56 45 52
00000010: 52 20 50 68 33 34 72 73 20 20 20 20 20 20 20 20
Lancez le crackme et on voit qu'il y a un bouton pour checker le keyfile !!
Un open box apparaît si vous clickez dessus et vous dit de choisir un fichier, ok on va le
faire l'ami :)
Tout d'abord mettez un BPX sur createfilea et quittez Soft-ice avec F5 !
Ensuite il vous suffit de choisir le fichier et Soft-ice revient de plus belle !
Pressez F11 et vous devriez voir le code suivant:
:0040461F CALL KERNEL32!CreateFileA
:00404624 CMP EAX,-01 ; Est-ce que le fichier existe ?
:00404627 JZ 00404652 ; si il n'existe pas ça saute
:00404629 MOV [EBX],EAX
:0040462B POP EDI
:0040462C POP ESI
:0040462D POP EBX
:0040462E RET ; tout est ok! on sort d'ici!
On a notre fichier, donc le test est ok ! On continue à tracer avec F10 on passe le RET
et on trouver un code du genre:
:00429D93 CALL 00402618
:00429D98 JMP 00429DB4
:00429D9A LEA EDX,[EBP-01]
:00429D9D LEA EAX,[EBP-0150]
:00429DA3 CALL 004044E8
:00429DA8 CALL 00402618
:00429DAD XOR EAX,EAX ; EAX = 0
:00429DAF MOV AL,[EBP-01] ; Prends le caractère du keyfile (dans ebp-1)
:00429DB2 ADD EBX,EAX ; additionne la valeur à EBX
:00429DB4 LEA EAX,[EBP-0150]
:00429DBA CALL 00404494
:00429DBF CALL 00402618
:00429DC4 TEST AL,AL ; On a fait toutes les lettes ?
:00429DC6 JZ 00429D9A ; non ? alors on saute sinon on continue
:00429DC8 LEA EAX,[EBP-0150]
:00429DCE CALL 00404458
:00429DD3 CALL 00402618
:00429DD8 CMP EBX,000020A9 ; La somme des caractères = 20A9h ?
:00429DDE JNZ 00429DEE ; Si c'est égal alors le keyfile est valide
La somme de mon fichier fait: 794h
Ce n'est pas égal à 20A9h donc le keyfile n'est pas valide!!
On va rectifier ça !! 20A9h - 794h = 1915h
Il nous faut donc ajouter 1915h à notre keyfile! On va ajouter des FFh (255)
Je n'ai plus le keyfile sous la main, mais je pense que vous avez compris comment ça marche !
Alors je vous laisse vous amuser !!
Sinon, le keyfile le plus petit possible est :
00000000: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
00000010: FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF
00000020: C9
Il n'y a aucun texte dans cette keyfile, on retrouve juste la somme nécessaire: 20A9h
Alors amusez vous à faire votre propre keyfile et si vous n'avez pas compris comment
faire, essayez de compléter mon keyfile :)
Voilà, la partie keyfile fut brève !
Il existe un crackme un peu plus compliqué mais très intéressant à essayer:
Cruehead Crackme 3 !
Il est toujours simple, mais plus fin à cracker ;)
Vous devez l'essayer, et pourquoi par faire un keymaker !
Il existe d'autres crackme utilisant les keyfiles! Alors vous pouvez vous entraîner
si vous avez du mal!
Note: N'essayer pas de cracker CuteFTP juste après avoir lu ce cours, si vous n'avez jamais
cracké de keyfiles de votre vie! C'est un conseil ....
CD Check (les BPX, et techniques diverses...)
Alors là, c'est la partie cracking jeux!!
Qu'est qu'un CD check ?
Un CD check est la détection du CD dans le lecteur pour éviter aux petits
pirates en herbes de copier les jeux sur leur disque durs pour y jouer
sans CD :)
lol!! Il y a bcp de jeux protégés par CD check mais bon, les 3/4 on se pisse
de rire!!
La protection actuelle qui calme les "petits" crackers est CDilla,
cette protection est en effet d'un niveau élevé par rapport aux protections
que l'on trouve dans: Quake 2, Formula 1, King Pin et bcp d'autres !!
Mais, je vais vous montrer comment cracker les 2 avant-dernières protections
de CDilla !! N'ayant aucun jeux originaux (hehe, no way ) je n'ai pas pu
tester la toute dernière version encore, qui est soi-disant plus dure;)
Je vais aussi vous parler des protections commerciales !
Mais je ne vous décrirais que CD Lock et CDilla ! Il existe de nombreux cours
sur securom, et autres protections CD commerciales !
J'écris pas un roman lol
Alors nous allons commencer par les protections TRES TRES simples !!
Les CD check de bases:
*** Avec W32Dasm: *****
Comme exemple on va prendre Formula 1:
Il contrôle si il y a le CD du jeu et si ce n'est pas le cas il refuse
de se lancer.
Après avoir installé le jeu on le lance (après avoir retiré le CD !!!)
Et un message apparaît "Formula 1 CD NOT Found". Il n'en faut pas plus
pour le cracker.
Prenez W32Dasm et désassemblez le fichier exécutable, en l'occurrence
F1win.exe.
Cherchez dans String Data References (Menu "Refs") de W32Dasm et recherchez
la phrase. On trouve ça quelques lignes avant le message d'erreur :
00409AC3 FF5234 call [edx+34]
00409AC6 85C0 test eax, eax
00409AC8 7D50 jge 00409B1A
Là il y a un test qui ne nous envoie pas au jeu si il ne trouve pas le CD,
donc on place des NOP et il n'y a plus aucun Test et le jeu se lance
quoi qu'il arrive. Cela donne :
00409AC3 FF5234 call [edx+34]
00409AC6 90 nop
00409AC7 90 nop
00409AC8 7D50 jge 00409B1A
Donc pour le cracker il faut rechercher avec un éditeur hexadécimal
la chaîne FF 52 34 85 C0 7D 50 et la remplacer par FF 52 34 90 90 7D 50
c'est tout.
2ème exemple : Quake 2 v3.14
Après avoir installé le jeu ou après avoir mis le patch 3.14,
quand on lance Quake 2 sans le CD dans le lecteur, il marche jusqu'au
menu puis lorsqu'on lance une nouvelle partie boum! Le message
"You must have the Quake 2 CD in ..."
On désassembles le fichier avec W32Dasm puis on cherche dans String Data References
le message "You must have the Quake 2 CD in ..."
Bcp de jeux utilisent cette connerie de message !! (ils sont rares de nos jours
cependant!)
Vous marquez "Please insert the XXX CD" (vous cherchez cette phrase dans
String Data References.)
Après avoir trouvé cette phrase dans String Data References, clicker 2
fois dessus, cela vous amènera au désassembler à la ligne du message.
Remontez un peu avec la barre de défilement, vous trouverez juste au
dessus:
E82BFFFFFF call 0042F520
803800 cmp byte ptr [eax], 00
750F jne 0042F609
Là on voit un petit "750F" qui représente le "Jne" (celui dont je vous
parlais au début), il représente un saut si ce n'est pas égal. Donc si
il n'y a pas le CD dans le lecteur, ce n'est pas "égal au CD" donc le
programme saute au message d'erreur et le jeu ne marche pas!
On va noper ce con de saut !!
Le code devient:
E82BFFFFFF call 0042F520
803800 cmp byte ptr [eax], 00
90 nop
90 nop
Et c'est partie !! Les CD checks de ce type!!: That's bullshits !
Donc pour cracker définitivement le jeu on cherche la chaîne
Hexadécimale suivante avec un éditeur Hexa du style HexWorkshop, Hedit.
La chaîne : FF FF 80 38 00 75 0F et la remplacer par FF FF 80 38 00
90 90.
Fermez W32Dasm et lancez Quake 2. Bingo le jeu marche c'est cool!
Vous allez me dire !! Ca marche que sur les vieux jeux ça ;PP
Alors comme autre Exemple: KingPin version Fr
***************
*** KingPin ***
***************
Cracking part:
Qd vous lancez le jeu avec un CD gravé, on voit les super (lol) messages:
You must have the KingPin CD in the drive to play...
Hahah, j'adore ce genre de conneries!
Lancez W32Dasm et désassemblez le jeu!
Allez dans les References et cherchez la phrase du jeux!
Double click dessus et on ne voit rien de super! donc on re-double click dessus !
Et cette fois-ci!! On trouve qq chose de bien :
* Referenced by a CALL at Address:
|:0043D5F1 <== hoho :))
|
:00442030 56 push esi
:00442031 E84AFFFFFF call 00441F80
:00442036 8BF0 mov esi, eax
:00442038 85F6 test esi, esi
:0044203A 750E jne 0044204A
* Possible StringData Ref from Data Obj ->"You must have the KINGPIN CD in "
->"the drive to play."
|
:0044203C 68C8414500 push 004541C8 <== on arrive ici
:00442041 50 push eax
:00442042 E859D7FDFF call 0041F7A0
:00442047 83C408 add esp, 00000008
Donc, nous voyons le message d'erreur et un petit jne juste avant !!
Mais bon, remplacez un je en Jne et autres, ça fait branleur !!!
Réfléchissons un peu ;)
On a vu :
* Referenced by a CALL at Address:
|:0043D5F1
Donc avec W32Dasm on va regarder ce call !!
Allez dans le menu "Goto" et clickez sur "goto code location" et entrez : 43D5F1
Maintenant on arrive ici:
:0043D5E5 A184274900 mov eax, dword ptr [00492784]
:0043D5EA 83C40C add esp, 0000000C
:0043D5ED 85C0 test eax, eax
:0043D5EF 7505 jne 0043D5F6
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0043D5D2(U)
|
:0043D5F1 E83A4A0000 call 00442030 <== get the fuck outta here!
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:0043D51F(U), :0043D532(C), :0043D55A(U), :0043D5BA(C), :0043D5D0(C)
|:0043D5EF(C)
Hehehe, voilà !! C'est ce call de merde qui appelle la routine de CD check !
On va le noper et il nous tanera plus !! Promis.
Clickez sur ce call, en bas de la fenêtre de W32Dasm, vous devez voir offset : 3D5F1
Lancez votre éditeur hexa et allez à cet offset !
On remplace E83A4A0000 par 9090909090.
Enregistrez le fichier et lancez le ;)
Choisissez new game, et WOW !! Le jeu marche *grin* !
Piece of cake !!
On vient de cracker King Pin ! Un jeux super récent mais avec une protection
de merde :) (tant mieux hehe, vous allez voir CDilla, c'est autre choses)
Voilà, c'est fini pour les CD checks de bases avec W32Dasm !
**** CD check avec Soft-ice *****
Voici un exemple Très simple de CD check !
Mais cette fois-ci on utilise Soft-ice (my love)
Le but du crackme et de faire afficher le message de bon CD qd on a pas un
seul CD dans le lecteur :)
On le lance sans CD, on click sur le bouton et une messagebox de merde
arrive !! mouahah
Les BPX les plus utilisés dans le CD checks sont: GETDRIVETYPEA et
GETVOLUMEINFORMATIONA !!
Mettez un bpx sur GETDRIVETYPEA et clickez sur le bouton! Pressez F12 tant que l'on
est pas à la bonne place !!
Vous devriez voir qq chose comme ça:
025F:00401032 83F805 CMP EAX,05 <--- c'est un CD ?
025F:00401035 75DC JNZ 00401013
025F:00401037 6A00 PUSH 00
025F:00401039 6A00 PUSH 00
025F:0040103B 6A00 PUSH 00
025F:0040103D 6A00 PUSH 00
025F:0040103F 6A00 PUSH 00
025F:00401041 6A20 PUSH 20
025F:00401043 68F7214000 PUSH 004021F7
025F:00401048 685A224000 PUSH 0040225A
025F:0040104D E85E000000 CALL KERNEL32!GetVolumeInformationA
025F:00401052 0BC0 OR EAX,EAX
025F:00401054 74BD JZ 00401013 <-- JMP BAD CRACKER
025F:00401056 6A00 PUSH 00
025F:00401058 685F224000 PUSH 0040225F
025F:0040105D 6A00 PUSH 00
025F:0040105F 6A00 PUSH 00
025F:00401061 685A224000 PUSH 0040225A
Ok, c'est trop simple, il compare la valeur d'EAX avec 5!
Hmm pourquoi 5 ?
Voici un petit tableau des différents type de lecteurs et leurs références:
La valeur dans EAX veux dire:
0 Lecteur indéterminé
1 Répertoire sur la racine n'existe pas
2 Disque removable
3 Disque dur
4 Remote Drive(Network)
5 CD ROM
6 RamDisk
Donc le crackme ici compare EAX avec 5 ! Donc il veut un CD ROM arff
sinon il saute!!
025F:00401032 83F805 CMP EAX,05
025F:00401035 75DC JNZ 00401013 <-- on NOP ça
On nop ça ! Et plus jamais de problèmes avec ça hehehe !!
On ouvre le crackme avec un éditeur hexa, on cherche 83F80575DC et on remplace par
83F8059090.
Après ce contrôle de type de disque, on voit un "CALL KERNEL32!GetVolumeInformationA"
Hehe, une API souvent utilisée par les CD checks!
Ca ressemblais à ça:
025F:0040104D E85E000000 CALL KERNEL32!GetVolumeInformationA
025F:00401052 0BC0 OR EAX,EAX
025F:00401054 74BD JZ 00401013 <-- Jump to bad boy
Encore une fois ! On NOP le saut conditionnel et le CD is no more :)
Ben voilà, c'est fini, je ne vais pas faire un roman non plus sur les CD checks ehehe
********************************************
** CD CHECKS: PROTECTIONS COMMERCIALES: **
** **
** CD LOCK: TOMB RAIDER 3 FR **
********************************************
Vous êtes sûrement beaucoup à vouloir Tomb Raider III mais ce jeu est protégé
contre la copie ! Enfin, en théorie !!!!
Tout d'abord nous allons voir la protection. Un CD Vierge ne peut contenir que 650 Mo
de données et le CD original de Tomb Raider III contient 3 Go de données ?!
Oui en fait il y a 4 fichiers qui font 600 Mo chacun : Awcs.afp ; Neir.afp ; Oket.afp et
Vfaw.afp . Pour Pouvoir le graver il faut d'abord copier tous les fichiers du CD sur le
disque dur, sauf les 4 cités plus haut. Ensuite créer 4 fichiers avec le même nom avec un
caractère dedans pour que le fichier fasse 1 octet. Maintenant on grave le CD sans problème
mais le jeu ne marchera pas car il est encore protégé !!! Et c'est là qu'intervient le
cracking!
Nous sommes en présence d'un CD Check (contrôle du CD) et le jeu nous affiche le message
" Tomb Raider III CD ?" malgré la présence du CD Gravé.
Si vous avez lu le premier cours, vous vous dites comme moi, on va le désassembler et chercher
cette phrase dans String Data References. Le problème c'est que l'on ne trouve pas cette phrase,
donc il suffit de réfléchir un tout petit peu.
Il y a 4 fichiers qui ne servent à rien donc on va chercher le nom de l'un d'eux dans
les String Data References. On voit d:\Awcs.afp , d:\Neir.afp , d:\Oket.afp et d:\Vfaw.afp.
Donc on double-click dessus et on retourne dans W32Dasm, juste au code source de cette référence,
on remonte avec les barres de défilement et on trouve:
test edi, edi
jne 0048D2CE
* Possible string data reference from Obj ->"rb"
Push 004C7AD4
* Possible string data reference from Obj ->"d:\AWCS.AFP"
.......
Le Jne (Jump if not equal) fait le saut s'il ne trouve pas le fichier de 600 Mo donc on le
change en je (jump if equal) et le programme ne saute que si il trouve le fichier. Il peut
toujours chercher !!! Donc maintenant on ouvre le fichier Tomb3.exe avec un éditeur hexadécimal,
on cherche la chaîne 85FF756568D4 et on la remplace par 85FF746568D4 .
Et on enregistre le fichier. Le jne 0048D2CE est devenu Je 0048D2CE.
Maintenant on refait la même chose avec les autres fichiers.(d:\Neir.afp , d:\Oket.afp et
d:\Vfaw.afp)
Les 2 premiers seront casi-identiques mais on ne trouvera pas la même chose au fichier "D:\Vfaw.afp"
C'est normal il n'y a rien à changer. Donc vous avez changé :
- pour "Neir.afp":
0F85F9000000 par 0F84F9000000 ===> le 85 (jne) devient 84 (je)
- pour "Oket.afp":
0F85AD000000 par 0F84AD000000 ===> le 85 (jne) devient 84 (je)
- rien pour "Vfaw.afp"
Normalement, vous avez tout changé avec l'éditeur Hexadécimal et Sauvegardez. Une fois ceci
fait vous pouvez lancer le jeu avec un CD gravé dans le lecteur !!!
Tomb Raider III is Now Cracked !!!
Voilà!!
La Protection CD lock est assez stupide en fait !!
Même très simple à cracker ! Vous la retrouverez dans Commandos par exemple aussi :)
Pour le cours qui suit sur CDilla, il serait préférable d'aller jeter un oeuil
à la partie unpacking qui suit ce cours si vous ne connaissez rien en unpacking et
autres dumping !! Mais si vous êtes déjà à l'aise avec le PE, et que vous vous prenez
pour un 133t Cr4x0R hehe, lisez !! Mais ne pleurez pas si vous ne comprenez rien !!!
Voilà, let's go
************************************************************************
**** CDilla : Safe disc ****
************************************************************************
MidTown Madness version Française: Une autre approche sur CDilla
Outils nécessaires: * CD Original de Midtown Madness
* Soft-ice 3.23
* Soft-ice Tool pour patcher Soft-ice (pour dumper les sections)
* HexWorkshop
* Frogsice (pour cacher Soft-ice)
* ProcDump (comme PE Editor)
* Exescope
Introduction:
Salut à tous, je sais qu'il y a déjà un cours sur Midtown Madness par black check
mais la méthode que j'utilise n'est pas la même que lui...
Je vais expliquer le plus de choses possible et en plus c'est le 1er cours sur
CDilla en français !!!
Il serait préférable de lire le cours de black check avant, et d'avoir quelques
connaissances sur le format PE...
A Mort CDilla:
Après avoir installé le jeu, éditez le PE du fichier ".icd" avec ProcDump.
(lancez ProcDump, clickez sur PE Editor, allez où se trouve votre fichier ".icd")
Le fichier est : Midtown.icd
Maintenant, vous devez voir ceci:
- Entry Point : 00166C10
- Image Base : 00400000
Ok, nous allons avoir besoin de l'OEP (Original Entry Point) plus tard donc
nous allons le calculer dès maintenant.
Pour cela on a besoin de l'Image base et de l'Entry point que l'on obtient avec
ProcDump : 00400000 + 00166C10 = 566C10 (on les additionnes)
Maintenant, clicker sur le bouton "sections" pour voir toutes les sections du fichier.
On ne va avoir besoin que des valeurs Virtual Offset, Raw Size, et Raw Offset !
- pour la section ".text" :
Virtual Offset: 00001000
Raw Size: 18D78F
Raw Offset: 600
- pour la section ".Rdata" :
Virtual Offset: 0018F000
Raw Size: 14C99
Raw Offset: 18DE00
- pour la section ".data" :
Virtual Offset: 001A4000
Raw Size: 3D8A4
Raw Offset: 1A2C00
- pour la section ".data1" :
Virtual Offset: 00314000
Raw Size: 20
Raw Offset: 1E0600
- pour la section ".rsrc" :
Virtual Offset: 00315000
Raw Size: CB3
Raw Offset: 1E0800
Nous allons donc dumper toutes les sections du fichier ".icd" excepté la section ".Rdata"
car, c'est plus compliqué pour celle-ci !!
Il faut tout d'abord additionner l'Image base avec le Virtual Offset de toutes les sections:
.text : 400000 + 00001000 = 00401000
.rdata : 400000 + 0018F000 = 0058F000
.data : 400000 + 001A4000 = 005A4000
.data1 : 400000 + 00314000 = 00714000
.rsrc : 400000 + 00315000 = 00715000
Ok, maintenant nous allons dumper les sections...
Pour cela, mettez un breakpoint sur EOP (566C10 pour ce jeu).
Vous avez sûrement remarqué, que si vous lancez le jeu avec Soft-ice chargé,
il vous envois chier, car il y a de l'anti Soft-ice.
CDilla utilise meltice (createfilea) et l'int68h pour détecter Soft-ice.
Le mieux, c'est d'utiliser Frogsice, pour le cacher. J'utilise la version 0.20b, mais
il faut la patcher pour qu'elle cache complètement Soft-ice de la détection par int68h.
Dans le cours de black check on voit qui faut rechercher dans le fichier: FrogSice.vxd
-60 80 7d 1d 43
et le remplacer par :
-C3 80 7d 1d 43
Voilà, maintenant, plus aucun problème avec la détection de Soft-ice, on va pouvoir
s'occuper des choses sérieuses !!
Lancez votre Frogsice (version patchée) et lancez le jeu.
Pendant la vidéo, faites apparaître Soft-ice (ctrl+D) et mettez votre bpx sur l'OEP:
Bpx 56CC10 pour ce jeu...
Pressez F5, le jeu continue de se lancer, et quittez-le.
Maintenant relancez-le et Soft-ice breaks sur 56CC10. Si Soft-ice ne break pas, regardez
si vous avez bien mis votre bpx au bon endroit! (tapez bl et vous devez obtenir qq chose
comme ça #025F:56CC10)
Donc, Soft-ice break sur l'OEP, vous n'avez plus qu'à dumper les sections :)
Avant le dump, désactivez tous les bpx (bd *) car on veut pas de merdes dans nos sections
dumpées ehe !!
Grâce à Sice Tool, vous avez modifié la commande pagein qui vous permettra de dumper...
La commande pagein fonctionne donc comme ceci pour dumper:
pagein "l'adresse du début du dump" "longueur du dump" "nom du fichier"
Donc dans Soft-ice, tapez:
pagein 401000 18D78F c:\text.bin
pagein 5A4000 3D8A4 c:\data.bin
pagein 714000 20 c:\data1.bin
pagein 715000 CB3 c:\rsrc.bin
Voilà, nous avons donc nos sections sur le disque dur !!!!
Passons aux choses sérieuses !!! : La Section Rdata :
Bon, pour dumper cette section, c'est pas aussi simple =)
Tout d'abord, nous devons trouver l'adresse réelle de la fonction de décryptage et pour
cela nous allons tracer dans le call qui appelle dans la section rdata...
Après que Soft-ice ai stoppé sur l'OEP, on arrive ici :
00566C10 PUSH EBP <-- on stoppe ici sur l'entry point
00566C11 MOV EBP,ESP
00566C13 PUSH FF
00566C15 PUSH 005968D0
00566C1A PUSH 00566724
00566C1F MOV EAX,FS:[00000000]
00566C25 PUSH EAX
00566C26 MOV FS:[00000000],ESP
00566C2D ADD ESP, -5C
00566C30 PUSH EBX
00566C31 PUSH ESI
00566C32 PUSH EDI
00566C33 MOV [EBP-18],ESP
00566C36 CALL [0058F14C] <-- voici notre call, on trace dedans (F8)
Dans le call , on arrive ici :
009A6485 pushad
009A6486 push 00000031
009A6488 push 00000000 ---> 0 désigne les imports kernels, pour les users ça sera 1
009A6490 call [9A64A6] ---> l'adresse réelle de la fonction (9A64A6)
009A6496 add esp, 8
009A6499 popad
....... jmp [XXXXXXXX]
Tracez dans le call et vous allez voir que le jmp [XXXXXXXX] devient jmp [KERNEL32!GetVersion]
Ok, c'est normal, on est sur le bon chemin :o)
Nous allons bientôt programmer le Call fixer...
Mais avant tout, nous devons connaître le nombre d'import de Kernels et users qu'il y a dans
le jeu que l'on crack.
Pour cela, plusieurs méthodes, on peut désassembler le fichier ".icd" avec W32Dasm
et les compter ou bien tracer avec Soft-ice, mais j'ai utilisé un programme nommé : EXESCOPE
pour savoir le nombre d'imports...
Donc dans le fichier midtown.icd , j'ai :
- 127 imports pour kernel32
- 42 import pour user32
Ok, nous avons besoin des ses valeurs en hexadécimal, car dans Soft-ice on n'utilise pas de
décimal:
127 = 7Fh
42 = 2Ah
Ma partie préférée qd on crack CDilla: Programmer le call fixer.
Nous n'avons pas l'accès en écriture dans la section Rdata, donc nous allons la déplacer
dans la section rdata...
Pour coder le call fixer, je commence sur l'entry point, donc il faut réactiver le bpx
sur l'OEP, et relancer le jeu. Attendez que le jeu stoppe dans Soft-ice.
Maintenant on va déplacer notre rdata section à la place de la data section en mémoire.
Pour faire ça, taper :
m "le virtual offset de la section RDATA + l'image base" l "la longueur de RDATA" "le virtual offset de la section DATA"
NOTE: Pour le virtual offset de la section data, utiliser un nombre plus grand, c'est mieux...
5A4000 est notre virtual offset, j'ai utilisé 5B0000 (Plus grand comme je vous ai dit)
Vous avez donc à taper:
m 58F000 l 14C99 5B0000
Maintenant, nous allons programmer le call fixer !!
Vous êtes donc à la ligne: 566C10 PUSH EBP
Ce que nous allons taper va ressembler à cela:
00 pushad
01 push ebx
02 push 0
04 call [XXXXXXXX]
0A add esp,8
0D mov edx, XXXXXX
12 cmp eax,[edx]
14 je 20
16 inc edx
17 cmp edx, XXXXXX + XXXXX
1D jne 12
1F int 03
20 mov [edx],ecx
22 popad
23 inc ebx
24 cmp ebx, XX
2A jne 00
2C int 03
C'est partis !!!
Tapez dans Soft-ice: A "et la touche entrée"
et programmez :
566C10 pushad
566C11 push ebx
566C12 push 0
566C14 call [009A64A6] <-- adresse de la fonction trouvé en traçant dans le call
566C1A add esp,8
566C1D mov edx, 5B0000 <-- adresse où nous avons copié notre section .rdata
566C22 cmp eax,[edx]
566C24 je 566C40
566C26 inc edx
566C27 cmp edx, 5B0000 + 14C99 <-- adresse où nous avons copié notre section .rdata + rdata size
566C3D jne 566C22
566C3F int 03 <-- par sécurité, si il ne trouve rien, il stoppe ici
566C40 mov [edx],ecx
566C42 popad
566C43 inc ebx
566C44 cmp ebx, 7F <-- Nombre d'API à réparer
566C4A jne 566C10
566C4C int 03
Mettez ebx à 0 (R ebx 0) , et votre eip à la ligne 0 (ligne 0 = 566C10 ici, donc: R EIP 566C10)
tapez "i3here on" et pressez F5 pour exécuter le code, normalement on devrait stopper sur 566C4C .
Remettez votre ebx à 0, changez la ligne 02 (56CC12 ici) en "push 1" et changez la ligne 24 en
'cmp ebx, user_import_number' (2A for us) et remettez votre eip à la ligne 0 (R EIP 566C10).
Exécuter ça encore (F5). Normalement tout est ok, et on doit encore avoir stoppé sur 566C4C .
Nous pouvons maintenant dumper la section rdata sans crainte car tout est décrypté :o)
pagein 5B0000 14C99 c:\rdata.bin
Hehe !! Maintenant on va reconstruire un fichier exécutable qui va être le fichier final.
J'ai essayé ProcDump pour importer les sections, mais cette merde n'a rien changé GRR !
Donc, je l'ai fait à la main comme un grand ;)
Voilà comment faire :
En premier faites une copie du fichier ".icd" (Midtown.icd) et renommez-le en ce que vous voulez
mais avec l'extension ".exe" (ex: fuckit.exe)
Ok, lancez HexWorkshop, ouvrez "Damnit.exe", ainsi que le fichier de notre première section
dumpé :
C'était: c:\text.bin
On va avoir besoin du Raw offset de chaque section, on les trouves au début du cours mais
je vais vous les remettre pour une meilleure compréhension:
for the ".text" section : Raw Offset: 600 size : 18D78F
for the ".Rdata" section : Raw Offset: 18DE00 size : 14C99
for the ".data" section : Raw Offset: 1A2C00 size : 3D8A4
for the ".data1" section : Raw Offset: 1E0600 size : 20
for the ".rsrc" section : Raw Offset: 1E0800 size : CB3
Ok, you got all shits here !! We want to do the 1st section ".text" so :
Dans HexWorkshop, pressez alt+f5, entrez le Raw offset de la section que vous voulez importer
ici : 600 et cliquez sur ok. Allez dans le menu Edit, et cliquez sur "select block"
Entrez la longueur (size) de la section, ici : 18D78F...
Regardez le fichier ouvert (text.bin) et pressez 'ctrl+a' pour tout sélectionner..
copiez tout ça avec 'ctrl+c'.
Retournez dans la fenêtre principale de l'exécutable dans HexWorkshop (damnit.exe), et coller
ce que vous venez de copier dans le presse papier, faites: 'ctrl+v' ou menu Edit et paste.
Enregistrez votre fichier, cool !! Voilà, c'est fini pour la section '.text', elle est maintenant
décryptée!!
Ok, je vais vous montrer l'import d'une autre section et vous ferez les autres de la même façon!
2ème section : Rdata!
Vous pouvez fermer la fenêtre 'text.bin', et ouvrez le fichier: 'rdata.bin' avec HexWorkshop.
Retournez dans la fenêtre de l'exécutable et pressez 'alt+f5', entrez le Raw offset de la
section rdata: 18DE00.
Cliquer sur le menu Edit, et cliquer sur "select block" entrez la longueur (size) de la
section, ici : 14C99
Regardez la fenêtre de rdata.bin , pressez 'ctrl+a' pour sélectionner tout et copiez les bytes
avec 'ctrl+c'...
Retournez dans la fenêtre de l'exécutable (damnit.exe) dans HexWorkshop et collez avec
'ctrl+v' ou avec le menu Edit..
Ok, je pense que vous avez compris maintenant, faites de même avec toutes les sections
et enregistrez les modifications dans l'exécutable.
Vous pouvez quitter Frogsice car l'anti Soft-ice n'est plus dans notre nouvel exécutable !!
Virez le CD original de Midtown Madness et lancez 'damnit.exe'.
WOW, le jeu marche, se lance très rapidement et sans cette merde de fenêtre qui nous dit
d'attendre durant la vérification du CD.
Le jeux marche superbement bien :o)
Mais pour faire une exécutable parfait, il faut reconstruire le PE en utilisant ProcDump
afin qu'il marche avec tous les OS.
Si vous lancez le jeu sur une autre version de Windows ça va planter :(
Allez, on va réparer ça !!
- Lancez ProcDump (Merci G-RoM :)
allez dans les Options et sélectionnez:
[X]Recompute Object Size
[X]Optmize PE Structure
[X] Use actual import infos
et cliquer sur OK
Cliquez sur Rebuild PE, et cherchez notre nouveau fichier (Damnit.exe pour nous)
ProcDump nous fais une valide import table et notre exécutable est PARFAIT :o)
du moins, j'espère hehe !!
Voilà, je pense que ça suffira pour les protections CD !!
On va passer à autre choses now !! hehehe
Visual Basic
Bon je vais vous montrez une paire de tuts sur le VB!!
Comment le keygener, patcher, trouver les serials !! TOUT !!!!
Pourquoi? Parce qu'il n'y a pas beaucoup de tutorial sur le keygening de programmes VB
donc j'ai voulu en faire ...
Tout abord:
*********************************************
*** Configurer Smart Check ***
*********************************************
Qu'est-ce que Smart Check ?
C'est un programme qui permet de débugger les programmes écrits en VB
et il est très utile en cracking!!
Mais il doit être configuré correctement sinon ça marche pas !
Pour configurer il suffit juste de cocher quelques cases et après c'est parti
pour l'éclate lol !! :)
Voici comment configurer Smart Check:
Dans le menu Program Settings:
- Error Detection: cocher toutes les cases excepté "Report errors immediately".
- Advanced: cocher les 4 premières cases.
Mais surtout ne pas cocher "Suppress system API and OLE calls" is not "ticked"
- Reporting: sélectionner toutes les cases excepté "Report MouseMove events from OCX controls".
Ensuite dans le menu View, il faut que "argument" soit sélectionné ainsi que "suppressed error".
Voilà, maintenant vous allez pourvoir lire la suite du cours !
Mais pour vous aider, je vais vous décrire quelques fonctions VB que vous rencontrerez souvent
en Visual Basic !
Fonctions importantes:
* __vbasrtcmp(String:"XXXX",String:"YYYY")returns DWORD:0
Description:
__vbastrcmp est utilisé pour comparer des "Strings" comme "XXXX" et "YYYY"
Si vous rencontrez ça, et que XXXX = votre faux numéro de série, il y a de fortes chances
pour que ce qui se trouve dans YYYY soit le bon serial !!
* Mid(VARIANT:String:"ACiD BuRN", long:1, VARIANT:Integet:1)
Description:
Prends la lettre dans les "ACiD BuRN" à l'emplacement 1 en partant de la gauche!
donc ici il prends "A" dans "ACiD BuRN .
* Asc(String:"A") returns Integer:65
Description:
Prends la valeur ascii de la lettre en DECIMAL
(la valeur ascii de "A" en decimal = 65)
* __vbaVarCat(VARIANT:String:"12", VARIANT:String:"34") returns DWORD:63F974
Description:
__vbaVarCat est utilisé pour ajouter des strings ensemble, ce qui nous donne ici: 1234
(12 + 34 = 1234 c'est ajout des strings! pas une addition des valeurs)
* __vbaVarTstEq(VARIANT:XXXX, VARIANT:YYYY) returns DWORD:0
Description:
__vbaVarTstEq est utilisé pour comparer des strings aussi !!
Regardez pour __vbastrcomp , le principe est le même !
Il existe aussi: __vbaVarCmpEq
* Len(String:"ACiD BuRN") returns LONG:9
Description:
La fonction len sert à récupérer la longueur d'un string! Ici "ACiD BuRN" a pour longueur 9
(9 lettres, l'espace compte aussi)
Les opérations de bases très souvent utilisées (keygen) :
* __vbaVarAdd(VARIANT:Integer:10, VARIANT:Integer:15) returns .... (25)
Description:
Additionne 10 et 15, cela donne: 25
* __vbaVarDiv(VARIANT:Integer:100, VARIANT:Long:2) returns..... (50)
Description:
Divise 100 par 2, cela donne: 50
* __vbaVarMul(VARIANT:String:"100", VARIANT:String:"2") returns ... (200)
Description:
Multiplie 100 par 2, cela donne: 200
* __vbaVarSub(VARIANT:String:"100", VARIANT:String:"2") returns ... (98)
Description:
Soustrait 2 à 100, cela donne: 98
* __vbaVarXor
Description:
Il marche sur le même principe.. il effectue un XOR entre les valeurs
* MsgBox(VARIANT:String:"She owns Me", Integer:0, VARIANT:String:"Love",VARIANT.....)
Description:
Sert à afficher une messagebox avec le message: "She owns Me" avec comme titre: "Love"
L'API en VB pour les messages box n'est pas: MessageBoxA mais : rtcMsgBox
Méthode très utilisée pour trouver les serials:
Vous avez entré un numéro à la con, et le programme vous a envoyé chier avec un
messagebox !
Comment trouver le serial rapidement dans Beaucoup de cas ??!
Facile, il vous suffit d'aller à la ligne où on voit cette messageBox et de clicker dessus.
Ensuite clicker sur: Show all events et là on voit BCP BCP plus d'informations qu'avant,
on descends un peu et on trouve qq chose comme ça:
__vbasrtcmp(String:"112233",String:"Oui_mec_c'est_le_serial")returns DWORD:0
On voit très bien que le programme compare "112233" avec le bon serial!
Vous prenez ce que vous trouvez à la place de "Oui_mec_c'est_le_serial"!
exemple: "AC4VA4EV"
Relancez le programme et entrez ça comme serial : AC4VA4EV
Boom Registered!!
Easy, isn't it ?
Pour des choses plus complexes, lisez la suite!
****************
* VB PATCHING: *
****************
EscapeRC v1.0.1
Description : une VB5 Time_Limit!
tools utilisés : - W32Dasm89 (version de base non patchée pour le VB)
- hexeditor!
Comme vous pouvez le voir, j'utilise W32Dasm pour du VB !! et même pas Soft-ice
ou Smart Check !
Comme c'est la version non patchée de W32Dasm, on aura aucunes String Data References
!! VB oblige :p
Mais bon!! on a les imports ;) et on va s'en servir hehe!
Donc, lancez le programme après avoir avancé la date du PC en 2001 par exemple..
Boom, on voit une messagebox qui nous dit: Trial period is over, blablabla
Ok, mais les progs en VB n'utilisent pas l'API : messageboxa.
Mais qqchose de similaire: rtcmsgbox
Donc en VB, pour les messagebox, on utilise : Bpx rtcmsgbox (pour vb6 : bpx msvbvm60!rtcmsgbox)
On peut très bien utiliser Soft-ice, mais on veux aussi innover un peu !! et se servir
de W32Dasm ;)
Lancez W32Dasm, et ouvrez le fichier avec ! (EscapeRC.exe)...
Allez dans les imports et cherchez : rtcmsgbox
Clickez 2 fois car la première ne contient rien de bien important :)
Vous verrez ceci:
* Reference To: MSVBVM50.rtcMsgBox, Ord:0253h
Remontez et vous voyez :
* Referenced by a (U)nconditional or (C)onditional Jump at Address: <== Referenced at
|:0041FA39(C) 41FA39
|
:0041FB84 B904000280 mov ecx, 80020004
:0041FB89 B80A000000 mov eax, 0000000A
:0041FB8E 894DAC mov dword ptr [ebp-54], ecx
:0041FB91 894DBC mov dword ptr [ebp-44], ecx
:0041FB94 894DCC mov dword ptr [ebp-34], ecx
:0041FB97 8D5594 lea edx, dword ptr [ebp-6C]
:0041FB9A 8D4DD4 lea ecx, dword ptr [ebp-2C]
:0041FB9D 8945A4 mov dword ptr [ebp-5C], eax
:0041FBA0 8945B4 mov dword ptr [ebp-4C], eax
:0041FBA3 8945C4 mov dword ptr [ebp-3C], eax
:0041FBA6 C7459C205A4000 mov [ebp-64], 00405A20
:0041FBAD C7459408000000 mov [ebp-6C], 00000008
* Reference To: MSVBVM50.__vbaVarDup, Ord:0000h
|
:0041FBB4 FF158CD34200 Call dword ptr [0042D38C]
:0041FBBA 8D55A4 lea edx, dword ptr [ebp-5C]
:0041FBBD 8D45B4 lea eax, dword ptr [ebp-4C]
:0041FBC0 52 push edx
:0041FBC1 8D4DC4 lea ecx, dword ptr [ebp-3C]
:0041FBC4 50 push eax
:0041FBC5 51 push ecx
:0041FBC6 8D55D4 lea edx, dword ptr [ebp-2C]
:0041FBC9 6A00 push 00000000
:0041FBCB 52 push edx
* Reference To: MSVBVM50.rtcMsgBox, Ord:0253h <=== vous arrivez ici après le click
------------------------------------------------------------------------------------
Donc vous avez vu : Referenced at 0041FA39
Dans W32Dasm, menu goto, et choisissez Code location et entrez : 0041FA39
Vous arriverez ici:
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0041FA24(C)
:0041FA34 66837DEC1F cmp word ptr [ebp-14], 001F <== compare avec 1F (31 en décimal)
:0041FA39 0F8D45010000 jnl 0041FB84 <== un saut conditionnel :)
:0041FA3F 6830394000 push 00403930
* Reference To: MSVBVM50.__vbaNew, Ord:0000h
|
:0041FA44 FF15E8D24200 Call dword ptr [0042D2E8]
:0041FA4A 50 push eax
:0041FA4B 6810A04200 push 0042A010
On n'a donc qu'à patcher ce truc :)
Pour être sûr de ne pas avoir d'ennuis, j'ai patché en:
:0041FA34 66837DEC00 cmp word ptr [ebp-14], 00
:0041FA39 0F8445010000 je 0041FB84
Editez le fichier avec votre éditeur hexa:
- cherchez : 66837DEC1F et remplacez par : 66837DEC00.
- cherchez : 0F8D45010000 et remplacez par : 0F8445010000
WOW !! Plus de prob de temps :pp facile .........
Voilà, vous avez une idée de comment patcher les progs en VB, avec W32Dasm :)
VB Patching: Avec Smart Check:
Aujourd'hui je vais vous apprendre comment cracker des prog VB avec 3 nags
et un timelimit!!
Je suis sur que vous allez dire "putain c'est dur!"
Hehehe !! J'étais en train de tracer avec SI quand j'ai eu une idée...
Je vais vous expliquer en quoi ça consiste...
1) Tools requis : - Smart-Check 6
- Hex editor
- un cerveau =)
2) Comment cracker les nags !!
Bon pour cela on utilisera SC !
Chargez Oyc avec SC et exécutez-le. Clickez sur le nag, attendez
que le bouton OK soit activé et ensuite quittez cette app...
Dans SC double clickez sur : frmOYCMain_load et regardez jusqu'à
ce que vous trouviez le ".show" ... dans SC vous verrez:
+ frmStart_Load
+ frmStart.Show
....
....
....
....
....
....
frmShareware_Load
frmShareware.Show
Donc, dans ce cas la chose importante est frmstart.show
A droite de SC vous voyez l'offset où il est situé et le fichier.
Pour ce nag, nous voyons qu'il est dans OYC.EXE @ 000FDA4D
Ok!
Je suppose que vous pensez que c'est ce que je voulais vous montrer !!!
Maintenant j'utilise mon cerveau pour virer le nag, parce que je sais
que le nag peut être appelé par un call, donc je pense pourquoi n'irions
nous pas à cet offset et regarder le premier call près de là?
Prenez votre HEXEDITEUR et allez à l'offset 000FDA4D.
Ok, maintenant vous savez que ce call commence avec : E8h et sa
longueur est de 5 octets...
Après avoir fait une recherche de ce E8h vous trouvez:
E8986FF0FF :)
Remplacez-le par des NOP (90)... ce qui vous donne:
9090909090
Sauvez (faites un backup on ne sait jamais) et réexécutez le programme...
Comme par magie le premier Nag a été viré!!!!!!!
Bien!! hehe
Maintenant on va passer au suivant!
Vous voyez sur la figure ci-dessus qu'il y a un autre ".show"
Procédez de la même façon et vous virerez ainsi le timer et le nag!!
Je ne vais pas vous montrer la valeur à remplacer parce que c'est
exactement la même que dans le premier nag. Et puis c'est bien
d'avoir des ex. d'application :)
Ok... bon maintenant le dernier nag mais ce sera moins facile que les
autres...
Dans SC, double click sur : "mnuFExit_click" (vous le trouverez
à la fin du rapport de SC)
Ensuite double click sur "frmOYCMain_Unload" et descendez jusqu'à
ce que vous voyez: "frmEnd.Show". Regardez à droite et prenez
l'offset : 1001A1
Ok, maintenant vous vous dites, on va faire la même chose qu'avec les deux autres,
et ça va être ok!
Eh bien non! Ca ne marchera pas!
Ok... j'ai réfléchi un peu et je me suis remémoré que vous pouvez
chercher un jump pour virer le nag, et dans les apps VB, je jump
toujours comme ça: 0F85 or 0F84 =)
Donc utilisez votre hexéditeur et allez à l'offset : 1001A1.
Faites une recherche de "OF" vers le haut. Et nous trouvons:
0F849A000000 ... remplacez-le par 0F859A000000 (je => jne) et sauvegardez!
Maintenant, exécutez à nouveau!!
Plus de nag! plus de timelimit!
Parfait!
3) Notes:
J'ai écris ce tut pour montrer comment on peut patcher les apps VB et que
parfois un cerveau est plus utile que le traçage avec SI (j'ai bien dit : parfois).
Donc, cette façon de cracker les nags VB ne marche pas à tous les coups, mais j'ai
réussi à cracker plusieurs apps VB comme ça donc faites pas chier! :)
Si vous voyez que l'offset est dans un DLL genre MSVBVM50 ou MSVBVM60, faites
juste une copie et placez-le dans le répertoire du programme et patchez-le.
De cette manière, le prog utilisera la DLL qui est dans son répertoire et pas
celle du WINDOWS\SYSTEM.
Vous n'aurez comme ça pas de problème avec d'autres applications qui utilisent
les DLL... !!!
**********************************
** Dawai 's VB CD check crackme **
**********************************
Infos données avec le crackme:
--------------------------------------------------------
This is a VB CD-check crackme.
Patching is allowed, but it
would be cooler if you could
tell me what CD the crackme
looks for :)
Dawai
----------------------------------------------------------
I)Qu'est-ce que contrôle ce con de crackme ?
tool: Smart Check ( Que vous avez bien configuré d'après mon cours )
Si vous lancez ce crackme, vous allez voir écrit: Welcome
Quand on click sur le bouton check, si ce n'est pas le bon CD, on obtient le
super message: Unregistered
hmmm.. ok
Lancez Smart Check et ouvrez le crackme avec ! Clickez sur le bouton et fermez le crackme,
vous devez voir: + _click
Double clickez dessus pour voir ce qui se passe la dessous hehe!
On voit une liste de:
GetdrivetypeA (API utilisée pour déterminer le type de disque et renvoyer 5 si c'est un CD)
Cette API est utilisée pour cracker les CD check sur les jeux ...
Sur mon PC, j'ai vu ça:
GetdrivetypeA(blabla) UINT: 2
..
GetdrivetypeA(blabla) UINT: 1
..
GetdrivetypeA(blabla) UINT: 3
..
GetdrivetypeA(blabla) UINT: 5
..
On veut cracker un CD check, donc il cherche pour un CD, alors clickez sur celui qui renvoie: 5
Maintenant dans Smart Check clickez sur "show all events".
E