Académique Documents
Professionnel Documents
Culture Documents
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 ...) **
*************************************************************************
ex: CMP EAX, EDX <--- soustrait EAX à EDX = EDX - EAX
* 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 !
Il y a aussi les DIV, MUL (je vous fait pas de dessin, je pense que
devinez ce que ça fait !!
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...
ex: MOV EAX, 56h ---> met 56h (86 en décimal) dans le
registre EAX.
0 XOR 0 = 0
0 XOR 1 = 1
1 XOR 0 = 1
1 XOR 1 = 0
Introduction à W32Dasm8x:
Tout d'abord, je vais vous expliquer ce qu'est W32Dasm, à quoi il sert
et quelles sont ses principales options!
Utilisation:
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 !
L'intérêt de ceci est que vous pouvez découper des bouts de codes et
les introduire dans vos tuts, ou Keygens :))
Théorie:
Maintenant allez jeter un oeil dans les String Data References et vous
n'avez plus qu'à chercher le message d'erreur rencontré lors du mauvais
serial !!
* Possible StringData Ref from Code Obj ->"le serial que vous avez entré.."
* Possible StringData Ref from Code Obj ->"le serial que vous avez entré.."
La ligne:
est devenue:
:-) 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 pourrez pas l'enregistrer car le fichier sera déjà en
lecture donc vous serez en lecture seule!!
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)...
* Possible StringData Ref from Code Obj ->"le serial que vous avez entré.."
Pratique:
- WinRAR 2.05
- W32Dasm 8.9
- éditeur hexa comme HexWorkshop
1) Analyse du prog !
....
String Resource ID=00106: "Registration failed"
String Resource ID=00107: "Thank you for support"
....
....
....
....
....
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 trouve:
* Possible StringData Ref from Code Obj -> "Available in registered ..."
....
....
// 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 !!
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}
End =
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;
end.
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:
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 :)
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 !!)
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
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
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
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
*****************************
** Commandes de Soft-ice: **
*****************************
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*)
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 ****
*******************************************
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 ?
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:
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)
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 ****
***********************************
Ctrl+D
entrez les 2 breakpoints du dessus
F5
*******************************************************************
**** 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:
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
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************************
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*********************************************
*********************SOURCES C++ +
ASM************************************************
#include
#include
#include
int main(){
int i,len;
asm
{
xor ecx, ecx
xor edx, edx
xor esi, esi
xor edi, edi
mov esi, [len]
start:
shl edi, 7
add edi,eax
mov [check], edi
***************************************************************************
**********
**** BPR: La bonne méthode :)
****
***************************************************************************
**********
xxxx:yyyyyyyy A B C D ................
xxxx:yyyyyyyy E F G H ................
Vous pouvez maintenant presser F11 et vous pouvez voir votre nom à
l'adresse
que vous avez tapé :) C'est bon signe déjà !!
Dans notre exemple, cela donne pour ACiD BuRN (longueur: 9 -> 9 - 1 = 8)
Une fois que vous êtes dans le crackme vous arrivez direct sur la
génération.
* Possible StringData Ref from Data Obj ->"Mauvais serial, essaye encore...
"
..........
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 !!
Text2.Text = result
End If
End Sub
Introduction:
utils nécessaires:
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:
cela devient:
***********************************************************
**** Reprogrammer la routine de Contrôle du serial ****
***********************************************************
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 :]
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
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
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
Avant de commencer avec les trucs un peu plus compliqués avec Soft-ice et
tout,
on va commencer par Simple !!
*********************************
* Cracker le nag de WinRAR 2.6b *
*********************************
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
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 :
devient :
Vous lancez votre programme et vous voyez le message qui nous dit:
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:
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 est donc sur un JMP qui va appeler le
MessageboxA .
Donc sur cette ligne vous faites:
A {enter}
RET {Enter}
{echap}
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:
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:
MessageBox
MessageBoxA
MessageBoxExA
MessageBeep
SENDMESSAGE
WSPRINTF
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 !!
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
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 !!
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
Alors nous allons commencer par les protections TRES TRES simples !!
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:
Le code devient:
***************
*** 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...
* 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
On a vu :
Mettez un bpx sur GETDRIVETYPEA et clickez sur le bouton! Pressez F12 tant
que l'on
est pas à la bonne place !!
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!!
Ca ressemblais à ça:
********************************************
** 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!
Push 004C7AD4
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"
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 ****
************************************************************************
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:
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 !
Nous allons donc dumper toutes les sections du fichier ".icd" excepté la
section ".Rdata"
car, c'est plus compliqué pour celle-ci !!
-60 80 7d 1d 43
et le remplacer par :
-C3 80 7d 1d 43
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:
Voilà, nous avons donc nos sections sur le disque dur !!!!
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 :
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
5A4000 est notre virtual offset, j'ai utilisé 5B0000 (Plus grand comme je
vous ai dit)
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
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
C'était: c:\text.bin
Ok, you got all shits here !! We want to do the 1st section ".text" so :
Ok, je vais vous montrer l'import d'une autre section et vous ferez les
autres de la même façon!
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)
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 !!
Visual Basic
Bon je vais vous montrez une paire de tuts sur le VB!!
Comment le keygener, patcher, trouver les serials !! TOUT !!!!
Tout abord:
*********************************************
*** Configurer Smart Check ***
*********************************************
Ensuite dans le menu View, il faut que "argument" soit sélectionné ainsi
que "suppressed error".
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:
Description:
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)
Description:
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)
Description:
Additionne 10 et 15, cela donne: 25
Description:
Description:
Description:
* __vbaVarXor
Description:
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
__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"
Easy, isn't it ?
****************
* VB PATCHING: *
****************
EscapeRC v1.0.1
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 ;)
---------------------------------------------------------------------------
---------
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...
+ frmStart_Load
+ frmStart.Show
....
....
....
....
....
....
frmShareware_Load
frmShareware.Show
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à?
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!
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 **
**********************************
--------------------------------------------------------
Dawai
----------------------------------------------------------
tool: Smart Check ( Que vous avez bien configuré d'après mon cours )
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
Ensuite commencez à scroller vers le bas avec les flèches et regardez dans
la fenêtre de
droite!
Descendez tant que vous ne verrez pas qq chose qui commence comme ça:
W
..
Wi
..
Win
..
Win9
..
Win98
..
Win98 S
..
Win98 SE
..
Mais de toutes façon, je me sert tjs de mes jeux sans CD! Alors je veux pas
avoir de CD
dans le lecteur !
Sux0r :)
Patcher un prog en Visual Basic est plutôt simple quand on sait comment
faire...
Lancez W32Dasm, et clickez sur le menu goto et prenez goto code location...
Additionnez 400000 a l'offset et on obtient l'emplacement dans W32Dasm !
(400000 = image base)
400000 + CB68 = 40CB68
Entrez ça dans Goto Code location
On arrive ici :
devient
***************************************************************************
**************
** Pour finir avec le VB: comment réactiver un Bouton, rendre une fenêtre
invisible... **
***************************************************************************
**************
Boutons:
Cette méthode marche pour activer les : boutons donc, les menus, check box,
labels
et autres ... :
*****************************
*** MIZ CRACKME 2 ***
*****************************
2) Trouver le serial !
label3_Click
Nous allons essayer de le trouver avec SI parce qu'il n'y rien de bien avec
SC!
On va utiliser bpx __vbastrcomp parce que on le retrouve couramment dans
les prog VB!
ctrl + D et tapez bpx __vbastrcomp. F5 pour retourner au programme et
tapez: 123456
comme serial.
Cliquez sur check et on est de retour dans SI Cool!!!
Pressez F12 pour sortir du call __vbastrcomp !
Vous devriez voir ESP en couleur et c'est bon signe!
Maintenant tapez dd esp (pour afficher la memoire en esp),
vous voyez: aaaaaaaa bbbbbbbb cccccccc dddddddd
Essayez de faire d aaaaaaaa , mais vous ne voyez rien d'intéressant alors
essayez d bbbbbbbb , et vous obtenez une phrase qui n'est pas
votre serial et vous voyez __vbar8str.
Hey !! C'est break points ? On va essayer!!
ctrl+D et tapez bc * pour supprimer tous les bpx.
Tapez __vbar8str puis pressez F5.
Entrez 123456 comme serial et clickez sur check !
Cool on est dans SI!!!
Tapez WF pour afficher la fenêtre concernant la pile à virgule flottante.
Vous voyez:
*****************************
*** MIZ CRACKME 3 ***
*****************************
Protections :
1) Code
2) Anti SmartCheck
Il existe un bonne BPX pour les app VB c'est __vbastrcomp!
Donc on va essayer celui-ci dans Soft-ice!
Tapez ctrl+D
puis
BPX __vbastrcomp
F5
Essayez de faire:
d aaaaaaaa , et vous ne devriez pas voir des choses intéressantes.
donc essayez ça:
d bbbbbbbb , et vous obtenez dans mon cas: Oy!iYt^LK
et ça marche !!!!!!!!
Après les BPX sur les fonctions couramment utilisées en VB, voici une autre
méthode
simple et rapide pour trouver un serial en VB:
*********************
*** HDMorph ***
*********************
S 0 L ffffffff 56,57,8b,7c,24,10,8b,74,24,0c,8b,4c,24,14,33,c0,f3,66,a7
ctrl+D
Soft-ice arrive et tapez
bpx hmemcpy.
F5
Click sur Ok et nous sommes de retour dans SI! Bien!...
Maintenant tapez F11 et F12 jusqu'à ce que vous voyez MSVBVM50 en bas de la
fenêtre
de SI.
Nous somme au bon endroit... ALT F4 pour rechercher l'emplacement de
comparaison!!
Vous devriez voir:
"search pattern found at XXX:XXXXXXXX".
Chez moi les XXX:XXXXXX sont
25F:7B1DD9EA.
Placez un BPX sur cette adresse et enlevez le bpx hmemcpy (BD 0)
F11 et nous sommes arrêtés à cause de 25F:7B1DD9EA .
C'est là où il y a la comparaison, on voit:
: 56 push esi
: 57 push edi
: 8B7C2410 mov edi, [esp + 10] ; Move real serial into edi
: 8B7C240C mov esi, [esp + 0C] ; Move fake serial into esi
: 8B4C2414 mov ecx, [esp + 14]
Tapez F10 pour passer "mov edi, [esp + 10]" et tapez d edi pour voir le bon
serial !
pour ACiD BuRN nous voyons:
1.3.0.2.6.8.6.3.0.5.4.4.3.2.0.7.9.2.1.6.3.8.1.3.1.2.1.4.0.4
Parce que c'est un programme VB nous avons des espaces (nul) entre chaque
chiffre.
Donc le bon code est :130268630544320792163813121404
On vérifie:
nAME: ACiD BuRN
cODE: 130268630544320792163813121404
Pressez OK mais rien ne nous dit que c'est le bon serial... Redémarrez....
Allez dans ABOUT et vous voyez : Registered to: ACiD BuRN
No comment ;)
****************************************************
**** VB KEYGENING: ****
****************************************************
*******************************************
*** Eternal Bliss 's Camouflage Crackme ***
*******************************************
Comment l'éviter?
Si vous voulez cracker la plupart des applications avec un anti SC, c'est
préférable de
patcher directement l'exécutable SC. Pour cela, utilisez un hexéditeur et
cherchez NuMega SmartCheck. Ensuite changez-le en ce que vous voulez!
Pour patcher l'ID de la fenêtre, c'est plus difficile parce que vous ne le
voyez pas
avec un hexéditeur!
Vous pouvez utiliser le programme de CyberBlade (un ami): UPK.
Tout d'abord, j'ai mis un BPX sur l'API avant le MessageBox qui dit "you
are not registered
blabla...". Ensuite, vous devrez charger le crackme dans SC et
l'exécuter!!!
On retourne dans Soft-ice et vous allez rechercher:
s 0 l ffffffff 'NMSC' (je n'ai pas recherché NMSCWM50... soyez sûr que vous
trouverez le bon)
tapez S jusqu'à ce que vous trouviez NMSCVM50. La première fois que vous le
verrez, réécrivez
par dessus des 00000000. Hehe, le crackme continue son exécution sous SC!!
2) Comment l'enregistrer?
--------------Start of SC cut--------------------------------
Ici:
Essayons:
name : ACiD BuRN
serial : 343210396733224945
3) Keygen it
Nous trouvons: 99
hehe !!
Si nous trouvons la même valeur avec 67 XOR 32 alors on a de quoi faire un
keygen!
Regardez!!
67 XoR 32 = 99 !
Cool!! On l'a fait!!
4) Source du Keygen:
Fini!
Crackme Cracked!! =)
**************************
* Keygen de Lan-Box 1.01 *
**************************
Clickez sur le bouton pour contrôler le serial et cet enculé nous sort bad
serial
blablabla...
Heh, fermez lan-box et faites une research de texte sur: ACiD
Pour voir ce que fait ce putain de programme, on click sur : "Show all
event" dans le menu
View..
En 1er, il ajoute "65" a "0" car il n'y avait pas de lettre avant!
On voit ça dans Smart Check avec la ligne suivante:
__vbavaradd(VARIANT:Empty,VARIANT:Integer:65)
Ceci ajoute 65 à 0 (empty veut dire : pas encore de valeur donc vide)
Si on regarde plus bas, on voit la même chose avec la lettre d'après "C" (C
de ACiD BuRN)
__vbavaradd(VARIANT:65,VARIANT:Integer:67)
Résultat:
_vbavarmove(VARIANT:integer:132,VARIANT:Integer:65)
Le résultat est: 132 et la valeur: 65 est l'ancienne valeur. Donc il efface
la valeur qu'il avait
mis de côté et la remplace par la nouvelle valeur: 132..
Bien il fait ceci avec chaque valeur ascii, et cette boucle prends les
valeurs ascii du nom
et les additionnes entre elle!
--------------------------------
A = 65 + 0
C = 67 + 65 = 132
i = 132 + 105 = 237
D = 237 + 68 = 305
space = 305 + 32 = 337
B = 337 + 66 = 403
u = 403 + 117 = 520
R = 520 + 82 = 602
N = 602 + 78 = 680
---------------------------------
Maintenant descendez tant que vous n'aurez pas atteint la fin de la boucle
sur
les valeurs ascii, c'est là où vous verrez la valeur: "680" :)
Le résultat est: 4403345.947558817 (on vois cette valeur dans Smart Check)
et finalement on trouve:
__vbavarmove(VARIANT:Double:4.40335e+006,VARIANT:Integer:680)
Cela déplace le résultat final (bon serial) où la valeur "680" a été écrite
! Il l'ecrase donc!
Donc la première fois, j'ai cru que c'était le bon serial!! Mais c'était
pas le bon !
J'ai entré: 4403345.947558817 , putain c'est pas le bon !
Mauvaise message box de merde!
Donc j'ai généré un serial avec le nom: ACiD BuRN et il m'a donné:
4403345,94755882
Cooooool ! Je sais pas pkoi ça marche, sûrement à cause des fonctions VB :)
D'où l'intérêt encore une fois du keygen en VB!
Bref, ça marche, je suis fatigué et je vais pas me poser des questions 30
ans !
--------------------------ALGO---------------------------------
1st : additionne toutes les valeurs ascii du nom
2nd : multiplie la valeur (de la 1ere partie de l'algo) avec 232354
3rd : multiplie la valeur (de la 2eme partie de l'algo) avec 653435
4th : et divise la valeur (de la 3eme partie de l'algo) avec 23446534
---------------------END OF ALGO-------------------------------
-----------------------------START OF SOURCE-----------------
For i = 1 To Len(Text1.Text)
temp = Asc(Mid(Text1.Text, i, 1))
final = final + temp
Next i
final = final * 232354
final = final * 653435
final = final / 23446534
Text2.Text = final
-----------------------------END OF SOURCE--------------------
Dernier Exemple:
*******************
*The Power 1.0 fr *
*******************
"Le numéro de votre disque (celui à partir duquel vous avez lancé the
power)
est : (il vous donne le numéro)
Si vous souhaitez vous enregistrez, notez ce numéro et blablablabla"
Donc on voit que le programme nous demande de noter ce numéro basé sur
notre
disque dur! et de l'envoyer si on veut s'enregistrer !! ok ok !!
Donc ce programme nécessite un keygen car le serial valid pour votre PC ne
marchera
pas sur les autres ordis !
GetVolumeInformationA(LPSTR:00413BA4....)
2 lignes plus bas on voit : Right(VARIANT:Double:8.92936e+008,long:8)
Cela veut dire qu'il prends les valeurs à partir de la droite avec une
longeur de: 8
les 8 valeurs a partir de la droite de 892935893 sont 92935893 .
Ne serait-ce pas le serial que l'on voit dans la boite de dialogue au début
?
mais si ! Tout à fait :)
Vous n'aurez pas les mêmes valeurs chez vous car ça dépend du disque dur !!
Len(String:"92935893")returns LONG:8
Mid$(String:"92935893",long:1,VARIANT:Integer:1)
....
String("9") --> Double (9)
Double (9) --> Integer (9)
......
Mid$(String:"92935893",long:2,VARIANT:Integer:1)
....
String("2") --> Double (2)
Double (11) --> Integer (11)
......
Mid$(String:"92935893",long:3,VARIANT:Integer:1)
....
String("9") --> Double (9)
Double (20) --> Integer (20)
......
Mid$(String:"92935893",long:4,VARIANT:Integer:1)
....
String("3") --> Double (3)
Double (23) --> Integer (23)
......
Mid$(String:"92935893",long:5,VARIANT:Integer:1)
....
String("5") --> Double (5)
Double (28) --> Integer (28)
......
Mid$(String:"92935893",long:6,VARIANT:Integer:1)
....
String("8") --> Double (8)
Double (36) --> Integer (36)
......
Mid$(String:"92935893",long:7,VARIANT:Integer:1)
....
String("9") --> Double (9)
Double (45) --> Integer (45)
......
Mid$(String:"92935893",long:8,VARIANT:Integer:1)
....
String("3") --> Double (3)
Double (48) --> Integer (48)
......
Il prends les valeurs une par une du serial (la version modifiée de celui
du disque dur)
et les ajoutes au résultat de l'addition d'avant !
Voici l'exemple, c'est plus clair:
0 + 9 = 9 (0 car 9 est le 1er nombre donc rien à ajouter encore!)
9 + 2 = 11
11 + 9 = 20
20 + 3 = 23
23 + 5 = 28
28 + 8 = 36
36 + 9 = 45
45 + 3 = 48
Mid$(String:"92935893",long:8,VARIANT:Integer:1)
....
String("3") --> Double (3)
Double (48) --> Integer (48)
et il y a :
Hex(VARIANT:integer:19952)
__vbastrVarMove(VARIANT:String:"4DF0") ....
.....
Mid$(String:"92935893",long:8,VARIANT:Integer:1)
....
Double (48) --> Integer (48)
Hex(VARIANT:integer:19952)
__vbastrVarMove(VARIANT:String:"4DF0") ....
20000 - 48 = 19952
---------------------------------------------------------------------------
-----
The keygen:
Pour cela on utilise les API Windows pour récupérer le numéro de série
du disque dur..
et ensuite on fait le reste des calculs !
Je vais montrer la partie calculation car celle qui récupère le numéro du
disque n'est pas très importante, mais très longue :/
Voici les sources en VB:
-----------------------------little cut of
source---------------------------------
serial = Right(Format$(lngVolumeSerialNumber), 8)
Label1.Caption = "The value from your hard drive is: " + serial
For i = 1 To Len(serial)
temp = temp + Val(Mid(serial, i, 1))
Next i
On a besoin de:
- JAD (java decompiler)
- rien de plus :)
URLS:
www.lawrencegoetz.com/ (Trucs à cracker)
http://www.acidburn2000.com (le décompilateur java)
Dans ce cours nous allons cracker 3 choses: Goetz's Banner V 2.0 , Goetz's
Marquee 1.1,
et ManKind java crackme !
--------------------------------------
gbanner.JAD------------------------------------------
import java.applet.Applet;
import java.applet.AppletContext;
import java.awt.*;
import java.io.*;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Vector;
public gbanner()
{
m_background = "white";
test_it = "";
drawn = true;
zoom = true;
pausable = true;
m_target = "_self";
}
return ai;
}
if(shuffle)
loadImage = ai[j1];
if(!shuffle)
loadImage = j1;
images[loadImage] = getImage(getDocumentBase(),
getParameter("image" + Integer.toString(loadImage + 1)));
MediaTracker mediatracker = new MediaTracker(this);
mediatracker.addImage(images[loadImage], 0);
try
{
mediatracker.waitForID(0);
}
catch(InterruptedException _ex) { }
drawn = false;
drawable = false;
if(!zoom)
i = 1;
image_w = images[loadImage].getWidth(this);
image_h = images[loadImage].getHeight(this);
int j = image_w / i;
int k = image_h / i;
int l = d.width / 2 - j / 2;
int i1 = d.height / 2 - k / 2;
setMyColor(offGraphics, m_background);
offGraphics.fillRect(0, 0, d.width, d.height);
if(i != 1)
offGraphics.drawImage(images[loadImage], l, i1, j, k,
this);
else
if(i == 1)
offGraphics.drawImage(images[loadImage], l, i1, this);
if(!good)
{
setMyColor(offGraphics, "blue");
offGraphics.fillRect(0, 5, 200, 100);
setMyColor(offGraphics, "yellow");
offGraphics.drawString("UNREGISTERED VERSION!!!", 5, 25);
offGraphics.drawString("Please Register this applet.", 5,
50);
offGraphics.drawString("Registration is only $5.", 5, 80);
}
drawable = true;
try
{
Thread.sleep(50L);
}
catch(InterruptedException _ex) { }
if(i > 1)
i -= 2;
if(i <= 0)
i = 1;
else
if(i == 1)
i = 20;
repaint();
displaying = true;
if(i == 20)
{
if(pause[loadImage] > 0)
try
{
Thread.sleep(pause[loadImage] * 1000);
}
catch(InterruptedException _ex) { }
while(pausable && mouseInside)
try
{
Thread.sleep(100L);
}
catch(InterruptedException _ex) { }
if(++j1 == images.length)
{
j1 = 0;
if(shuffle)
ai = shuffle();
}
}
Thread.yield();
}
String s3 = getParameter("target");
if(s3 != null && !s3.equals(""))
m_target = s3;
info = new String[amount];
for(int k = 0; k < amount; k++)
{
info[k] = getParameter("info" + Integer.toString(k + 1));
if(info[k] == null)
info[k] = getParameter("info");
}
String s5 = getParameter("background");
if(s5 != null)
m_background = s5;
s3 = getParameter("zoom");
if(s3 != null && s3.equalsIgnoreCase("false"))
zoom = false;
s3 = getParameter("pauseable");
if(s3 != null && s3.equalsIgnoreCase("false"))
pausable = false;
s3 = getParameter("shuffle");
if(s3 != null && s3.equalsIgnoreCase("true"))
shuffle = true;
s3 = getParameter("one");
if(s3 != null && s3.equalsIgnoreCase("true"))
one = true;
d = size();
place = 0;
offImage = createImage(d.width, d.height);
offGraphics = offImage.getGraphics();
resize(d.width, d.height);
}
-------------------------------------------End of jad
file---------------------------------
Ok balaise huh ?
Donc pour les prochains fichier, je ne vous montrerai que les parties
importantes!
Donc, vous avez jeté un oeil à la source ci-dessus, et vous avez (j'espère
;p) repéré la
protection ! Un petit keyfile à la mord-moi-le-noeud :p *grin*
Donc, on cherche qq chose qui ressemble à un contrôle de fichiers:
try
{
myInfo = new URL(getDocumentBase(), "gboption.ini"); <---
eheheh! Nom du keyfile
}
catch(MalformedURLException _ex)
{
good = false;
}
if(myInfo != null)
try
{
input = myInfo.openStream();
dataInput = new DataInputStream(input);
test_it = dataInput.readLine();
dataInput.close();
}
catch(IOException _ex) { }
if(test_it.equals("InFeb")) <--- hmm ! on dirait qu'il compare le
texte dans du fichier
good = true; <--- si le texte = InFeb donc c'est OK
running = true; // sinon Get the fuck outta here!!
if(animate == null)
-------------------------------------cut from
gmarquee.jad--------------------------------
public void start()
{
if(offImage == null)
{
offImage = createImage(d.width, d.height);
offGraphics = offImage.getGraphics();
}
if(f == null)
{
f = new Font("Helvetica", 0, m_font);
fm = offGraphics.getFontMetrics(f);
}
try
{
myInfo = new URL(getDocumentBase(), "gmoption.ini"); <----
hehe :p
}
catch(MalformedURLException _ex)
{
good = false;
}
if(myInfo != null)
try
{
input = myInfo.openStream();
dataInput = new DataInputStream(input);
test_it = dataInput.readLine();
dataInput.close();
}
catch(IOException _ex) { }
if(test_it.equals("Eggplant")) <--- si le cracker a mit Eggplant
jmp goodboy
good = true; // sinon: jmp GET the fuck outta
here :p
if(!good)
try
{
reg = new register(300, 200, "Please Register Goetz's
Marquee",
"http://www.lawrencegoetz.com/programs/nettools.htm",
this);
}
catch(Exception _ex)
{
System.err.println("You are missing the file
register.class");
return;
}
if(animate == null)
Ph43R !!
---------------------------------Start of
CrackMe.jad--------------------------------------
public CrackMe()
{
}
public static void main(String args[])
{
if(args.length != 1)
{
System.out.println("Usage: java CrackMe Registration Code");
System.exit(0);
}
System.out.println("");
System.out.println("");
System.out.println("Welcome to ManKind's Java CrackMe 0.1");
System.out.println("=====================================");
System.out.println("This is an Alpha Test of ManKind's Java
CrackMe, please do send your comments,
suggestions, opinions, feedbacks and
support words to me!");
System.out.println("");
System.out.println("");
int i = Integer.valueOf(args[0]).intValue();
if(i == 0x7f42b)
System.out.println("Congratulations, you succeeded in cracking
this!");
if(i != 0x7f42b)
System.out.println("Sorry, invalid registration code. Please
try again!");
System.out.println("");
System.out.println("");
System.out.println("This program is Copyright \251 1999 ManKind");
System.out.println("Service for Mankind");
System.out.println("mankind001@bigfoot.com");
System.exit(0);
}
}
---------------------------------End of
CrackMe.jad-------------------------------------------
Ctrl+d
? 7b42b
FACILE non ??
Bon, je n'ai plus d'autre fichier protégé en java, donc je m'en vais finir
ce tut :-(
J'espère que le reversion du java est plus claire maintenant pour vous !!
C'est quelque chose de très simple les 3/4 du temps :
Bien sûr, c'est grâce au décompilateur !!
+-------------------+
| DOS-stub |
+-------------------+
| file-header |
+-------------------+
| optional header |
|- - - - - - - - - -|
| |
| data directories |
| |
+-------------------+
| |
| section headers |
| |
+-------------------+
| |
| section 1 |
| |
+-------------------+
| |
| section 2 |
| |
+-------------------+
| |
| ... |
| |
+-------------------+
| |
| section n |
| |
+-------------------+
Je vais pas m'attarder trop sur le format lui-même, mais je vais vous
donner quelques
infos sur les sections et autres caractéristiques !!
Vous avez sûrement remarqué que dans ProcDump (unpacker), il y a un PE
editor (éditeur
de PE) très très utile, vous le verrez plus tard...
Que se passe-t-il si on édite un fichier ??
On peut récupérer l'entry point, l'image base, les caractéristiques des
sections ...
Voilà, je ne vais pas faire un cours sur le PE, car mes connaissances sont
plutôt limitées
à ce sujet! Je cherche donc de la doc sur le PE en français !!!
J'ai vraiment pas le goût de traduire les Docs disponibles en anglais !
Si quelqu'un sait où trouver ça, merci de me mailer ;-)
Bon assez de blablabla, on va commencer par un cours sur ASPACK:
******************************
**** ASPACK ****
******************************
- Soft-ice 3.x or 4
Pour des questions à propos de ce geste, lisez les infos plus haut sur les
caractéristiques des sections !!
Ok, donc vous avez tout juste arrêté l'exécution dans SI, vous voyez
naturellement
les INVALID mais ça ne pose pas de problème. Tracez avec F10 et vous
arrivez ici:
............
............
.......
JMP EIP {enter} <== c'est pour faire une boucle infinie sans avoir à
dumper n'importe quoi
{escape}
F5
Ok, regardez le nouvel EXE que l'on vient de dumper et vous voyez
que sa taille est plus grande que celle du fichier crypté... bien! :)
Mais attendez! Si vous l'exécutez le prog va crasher comme un chien! :(
Ok... vous vous souvenez, vous avez noté le OEP (Original Entry Point) sur
un papier, cette valeur que vous avez trouvé dans EAX.
Dans ce cas, c'était 43F0A0. Ok, exécutez ProcDump PE Editor et changez
le point d'entrée en 0x0003F0A0. (OEP - the image base : 43F0A0-
400000=3F0A0)
Voilà pour Aspack!! Maintenant que vous êtes déjà plus familier avec
l'unpacking,
on continue avec un cours sur Armadillo!!
Protection commerciale avec anti debugging =)
Nous allons voir comment kicker cette merde de l'exe :)
**********************************************************************
**** Unpacker un exécutable protégé par Armadillo v1.76 *****
**********************************************************************
Tout d'abord voici une description d'Armadillo trouvée sur leur site
officiel:
---------------------------------------------------------------------------
----------------
.....
Armadillo modifies your program's EXE file, using a key you select and
state-of-the-art
compression and encryption tools to foil any attack relying on a decompiler
-- all they can
decompile is the code for the Armadillo decompressor itself, not your
program. Your program
is decrypted in memory when it is run, after Armadillo is satisfied that
it's safe to do so
and that the user has a valid license (more on licenses below). This, along
with some advanced
snoop-detection functions, prevents most patch/bypass attacks -- it would
require far more
knowledge (and a great deal more work) to patch your program while it's
encrypted.
---------------------------------------------------------------------------
----------------
0) Introduction:
Comme vous pouvez vous en douter, les exécutables protégés disposent d'un
anti Soft-ice
Il y a en fait 3 détections :
Vous voyez sûrement CMP EAX,EBX et le saut conditionnel juste après. Ici il
faut
inverser le Zero Flag et le programme va pourvoir s'exécuter normalement...
Pour inverser le Zero Flag, il suffit de taper: R FL Z sous Soft-ice une
fois
que vous êtes à la bonne ligne.
A partir de maintenant, il suffit de tracer avec F10, comme un fou, et nous
allons voir le fameux int3h arriver ;)
Mais avant, étant donné que la version que j'ai utilisé de Armadillo n'est
pas
enregistrée (pas encore ;p ) , nous allons voir une messagebox qui nous le
rappelle
Donc cliquez sur le bouton OK, et continuez à tracer..
Ce nag screen est très simple à cracker, il suffit de mettre un ret dans le
call
et c'est fini, mais nous allons virer tous cette merde du fichier
exécutable, donc
en s'en tape !
Mais, je ne peux m'empêcher de faire un petite remarque:
-------
Remarque:------------------------------------------------------------------
-----------
Comme vous l'avez sûrement remarqué, il est possible de protéger l'exe avec
un
name / serial au démarrage, ce qui peut être assez chiant à virer, car nous
voulons
exécuter le programme en mémoire...
Je vous racontes ça, car le fichier que nous sommes en train d'étudier ne
comporte
pas de name / serial , j'ai packé le fichier avec les options de bases,
mais en voulant
cracker le nag screen, je me suis trompé de call, je suis entré dans le
mauvais
et j'ai mis un RET, sur un push EDI, il me semble, bref la première
instruction.
Ensuite, je suis sortis automatiquement du call (RET) et j'ai tracé avec
F10.
Tout à coup, une dialog box est apparue me demandant un name / serial !!
What the fuck ? C'est quoi ce bordel, cet Armadillo me semble bizarre, mais
vraiment!!
Il semblerait que quoi que l'on fasse, l'exe contient la vérification nom
et code.
Il me semble bizarre, mais j'en conclus que ca doit âtre hyper simple à
virer, juste un call
à modifier, pour ne pas afficher ça, et on se retrouverais avec un exe
crypté de
base...
Je n'ai pas eu le temps de bien regarder, mais ça peut être intéressant.
Tout me pousse à dire que ces protections dites commerciales sont vraiment
stupides...
-------Fin des
Remarques:-----------------------------------------------------------------
----
C'est cette partie qui m'a posée le plus de probs, car j'avais une
erreur au moment
de reconstruire un exécutable valide ;(
J'ai recommencé plusieurs fois, et voilà comment je me suis pris.
(Ayant demandé de l'aide sur le forum de l'ATP team, j'ai donc lus leur
cours, ma
méthode semble être celle qu'utilise Alsindor, mais Artex utilise une
approche
différente, donc je vous recommande de lire leur superbe cours sur
MP3Wizard V1.2 par
Psyché, Artex et Alsindor... J'ai trouvé mon erreur de toute façon, je
n'utilisais
pas la bonne taille de section ".text". (Leur cours est basé sur Armadillo
1.0 je crois)
Donc, vous avez votre programme qui est lancé, si vous regardez dans le
répertoire
courant (où a été lancé le fichier exe, on trouve un fichier temporaire)
Copiez ce fichier, il va nous servir.
Ensuite, lancez ProcDump et regarder dans la liste des process, vous devez
voir
le fichier calc.exe, mais aussi le temporaire.
Faites un click droit dessus (on veut dumper le fichier TEMP !! pas l'exe)
et faites
un dump full.
Nous avons donc un fichier exécutable sur le disque, c'est le dump, et nous
avons encore le fichier temp récupéré dans le répertoire où a été lancé le
programme
crypté.
Mais pour être sûr que le fichier marche bien, on peut reconstruire le PE
avec ProcDump,
cela ne coûte rien de toutes manière :
ProcDump nous fais une valide import table et notre exécutable est
désormais plus sûr ;o)
Checksum
Imaginez que vous venez de cracker une messagebox en mémoire ou autre
merdes et
que après avoir modifié le programme en hexa, le fichier ne se lance plus
du tout, mais quitte directe !! Ou encore qu'il vous dise: "CRC ERROR
blablablaa"
Et là vous dites!! Merde!!!!! C'est quoi ce bordel! Je peux même pas
patcher ;(
Alors soit vous utilisez un mem patcher (patch qui ne patch qu'en mémoire
donc le programme
est tjs intacte, mais a besoin d'être lancé avec ça) soit vous réfléchissez
:)
exemple à 2 francs:
Il y avait un:
JE XXXXXXXXXX
et vous l'avez remplacé par un JNE (BEURK, mais ça sera plus simple pour
kicker le
checksum).
157 est différent de 156 donc en additionnant tout les octets un à un, le
programme trouvera
une différence et ne se lancera PAS :)
Comment contourner ça ?
// les sources
***************************************************************************
*****************
{-------------------------------------------------------------
This unit is freeware. I found it somewhere on CIS, I think.
Peter Tiemann
-------------------------------------------------------------}
Unit Crc32;
interface
uses
Dialogs,
SysUtils,
WinTypes,
WinProcs;
implementation
type
CRCTable = Array[0..255] of LongInt;
const
BufferLength = 16384;
CRC32Table: CRCTable = (
$000000000, $077073096, $0ee0e612c, $0990951ba,
$0076dc419, $0706af48f, $0e963a535, $09e6495a3,
$00edb8832, $079dcb8a4, $0e0d5e91e, $097d2d988,
$009b64c2b, $07eb17cbd, $0e7b82d07, $090bf1d91,
var
Buffer: Array[1..BufferLength] of Byte;
{$ifndef WIN32}
type
DWORD = longint;
{$endif}
end.
Cette source est freeware, c'est juste pour vous montrer un exemple
d'utilisation!
Elle ne vient pas de moi non plus comme vous avez pu le voir...
Ce qui peut nous faire chier aussi est le Test du nombre de NOP!!
En effet il est possible qu'un programme se scan à la recherche de NOPs
trop répétitif
donc une façon "d'effacer" est de mettre des INC et des DEC !!
exemple:
Voilà, je ne sais plus trop quoi ajouter sur la partie des checksums!!
Anti Soft-ice
Bon, je ne vais pas m'attarder sur ce chapitre non plus !! car il existe
déjà un SUPERBE tool pour cacher Soft-ice!
FrogsICE par +Frog's Print !
On trouve dedans de la Doc sur les méthodes de détection donc, je ne
saurais
que vous incitez à télécharger ce magnifique programme !!
Désolé si je ne détaille pas des masses cette partie, mais ça fait déjà 4
jours que
je suis malade et ça va pas super :'(
* Melt ice:
BOOL IsSoftIce95Loaded()
{
HANDLE hFile;
hFile = CreateFile( "\\\\.\\SICE", GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if( hFile != INVALID_HANDLE_VALUE )
{
CloseHandle(hFile);
return TRUE;
}
return FALSE;
}
***************************************************************************
*******************
procedure DetectICE;
var ACiD:Thandle;
s,s2:string;
begin
end;
***************************************************************************
*******************
Encore une fois, allez voir la doc de frogsICE qui vous donne des info
complémentaires.
Je ne suis pas là pour "pomper" les autres donc, je ne le mettrai pas ici
:P
mov ah,43h
int 68h
cmp ax,0F386h
jz Soft_ice_est_la_:P
***************************************************************************
**************
procedure INT68;
label Ure_Good_Guy;
label I_Got_You;
Begin
asm
mov ah,43h
int 68h
cmp ax,0f386h
jz I_Got_You
jmp Ure_Good_Guy
end;
I_Got_You:
showmessage('Soft-ice est chargé!!');
Ure_Good_Guy:
// Gentil lol pas de Soft-ice (ou je me suis fait cracker *g*)
end;
end.
***************************************************************************
***************
On ne peut pas mettre de Bpint sur 68, voici une façon de contourner:
Ben vous pouvez noper le je par exemple et il sautera tjs au bon endroit !!
sans jamais se douter que Soft-ice est chargé :]
Pour en revenir à notre code de base pour la détection par int 3, il suffit
aussi
de jouer avec le saut conditionnel pour résoudre tout nos probs :]
Pas besoin de vous faire un dessin je pense!
Divers :
******************************************************************
*** Changer l'image d'un programme en Delphi par exemple ***
******************************************************************
Voici la méthode!
Ouvrez le fichier dont vous vous voulez changer l'image de fond avec votre
éditeur
hexa.
L'image est soit au format BMP ou JPEG!
Le genre le plus couramment utilisé est le jpeg car il prends moins de
place
et dans mon crackme, j'ai mis un JPEG aussi ...
Bref ouvrez un fichier jpg avec votre éditeur hexadécimal pour regardez par
quoi il commence
et par quoi il finit!
......
Si on ouvre plusieurs fichiers jpeg on se rends compte que le début est tjs
le même!
Ils commencent tjs par : FFD8 FFE0 0010 4A46 4946
On voit que ça finis par FFD9 (le 00 n'est pas très important)
C'est la longueur de l'image!! Donc celle qu'on veut insérer doit être
inférieure
à cette taille !!
Je cherche sur mon disque dur un de mes logos et je l'ouvre avec mon
éditeur hexa !
(en JPEG aussi l'image à insérer)
Ensuite je sélectionne tout les octets de l'image avec HexWorkshop
(Ctrl+A) et je fais un
copier: ctrl + C ... ( après avoir fait sélectionner tout, je vois en bas
le nombre d'octets
de l'image à insérer -> sel: 4f2fh )
Je me remet à la fenêtre HexWorkshop qui s'occupe de mon crackme et je vais
à
l'offset où l'image commence: 64C2A
Et là dans le menu edit, select block, j'entre la longueur de l'image
entrée en hexa !
Il sélectionne dans l'ancienne image la place que va prendre la nouvelle
image!
Ensuite on fait coller (Ctrl+V) et si il vous pose un question répondez
oui!! ou OK
l'image est plus petite donc il reste un morceau de l'ancienne mais on s'en
fous pas mal
car ce qu'on vient de coller contient le code qui dit que l'image est
finie: FFD9
On sauvegarde notre fichier, et on relance!
Youpi!! on a maintenant une nouvelle image dans mon crackme !! hehe c'est
marrant et très
simple à faire !!
Greetings :
Group greetings: ID - ECLiPSE - CiA - ODT - EXEC - PWA - PC - UCF- CORE -
CC -
Nova2000 - PDM
Conclusion :
Et voilà ainsi se termine ce *petit* cours de cracking ;)
J'espère avoir été assez précis dans mes explications ainsi que mes
exemples
et que ce cours vous a apporté quelque chose ...
Ce tut n'a aucune prétention si ce n'est d'exister, les commentaires et
appréciations
sont donc les bienvenues...
Certaines parties n'ont pas été développées car, je ne veux pas écrire un
cours
de 1000 pages quand même.
J'ai été assez malade ces derniers temps, alors si il y a des petites
erreurs,
ou oublis, merci de m'avertir !
Pour toutes remarques, critiques, encouragements: Cracking@acidburn2000.com
TUTORIAL DEDICATED TO: Victoria (You rule baby and you own me :P )
AND I
^
| |
@#####@
(### ###)-.
.(### ###) \
/ (### ###) )
(=- .@#####@|_--"
/\ \_|l|_/ (\
(=-\ |l| /
\ \.___|l|___/
/\ |_| /
(=-\._________/\
\ /
\._________/
# ---- #
# __ #
\########/
SHOOT YOU
Tutorial par ACiD BuRN [Immortal Descendants ]
Copyright 1999 ACiD BuRN and the Immortal Descendants (c) All rights reversed :)
ACiD BuRN's home page