Au programme:
Introduction
Les Bases minimales requises (sauts conditionels , nop , call ...)
Introduction a Wdasm8x
Patcher les protections avec registrations (serial , name / serials)
Introduction a Soft ice (configuration et commandes de bases)
Trouver des serials valides pour vos noms avec soft ice
Comment keygener pas mal de programmes (utilisation ds des BPR...)
Transformer un Programme en son propre keygen
Time Limits (limitation de 30 jours et autres merdes !!)
Nag et autres Splash screen (diverse methodes...)
Keyfiles
CD Check (les BPX , et technique diverses..)
Visual Basic (keygener , serialiser , patcher , tout sur le VB !!)
JAVA REVERSE ENGINEERING
Manual Unpacking (comment unpacker , les tools , methodes...)
Checksum (comment les contourner)
Anti Soft ice
diver
Greetings
Conclusion:
Introduction:
Ben, voila je me suis dis il y a quelques jours pourquoi pas ecrire
un cours englobant tous les types de protections les plus courantes
et comment les mettre en echec!!
Cette fois ci , c'est donc bien un cours global de cracking et en
francais en plus !!
vous l'avez surement remarque, la taille de ce cours est assez
grande !! plusieurs dizaines de Ko! je vous conseille donc de lire ca
au calme et avec attention !!
Je previens de suite !! pour les personnes ayant l'habitude de faire
des remarques mal placees ! ce n'est pas la peine de critiquer ce
cours !! mais si vous avez plutot des suggestions , je suis
dispose a ecouter...
Ce cour a ete ecrit alors que j'etais tres malade , il se peut qu'il y est
quelques "anneries" , je serais content si vous pouviez m'en faire part!
Merci et sur ce , bonne lecture
[ ACiD BuRN ]
ESSAY:
*************************************************************************
** Les Bases minimales requises (sauts conditionels , nop , call ...) **
*************************************************************************
Pour pouvoir cracker, vous devez avoir des bases en assembleur!!
je vais ici vous enumerer les choses a savoir au depart.
differentes intructions, ce qu'elles veulent dire ..
Si vous etes deja habitue au cracking , vous pouvez passez a la suite
sans probleme je pense , a part si vous avez de grosses lacunes!
l'assembleur est le language qui se rapproche le plus de celui que
le PC, ou plutot que le Micro processeur puisse comprendre:
"le language machine."
l'asm est donc le language de programmation de plus bas niveau qui
existe.
Ce language retrouve sa place dans tous les programmes car il ne
faut pas oublier que n'importe quel programme , ecrit dans
n'importe quel language est finalement traduit en language machine
pour etre execute...
Si on desassemble n'importe quel programme , on retrouve un listing
en ASM, d'ou l'utilite de connaitre l'assembleur.
Passons a l'etude des instructions (Tres basique) afin d'eclaircir
les probs.
* CALL: l'instuction CALL permet d'appeler une sous routine.
exemple: Call 00405741 <-- ceci appelle la routine qui se trouve en
00405741.
* CMP: compare. Cette instruction soustrait l'operande source à l'operande
de destination.
exemple: CMP EAX, EDX <--- soustrait EAX a EDX = EDX - EAX
Les CMP sont generalement accompagnes de sauts conditionnels, nous les
verrons tres bientot...
* JMP: (JUMP) elle effectue un saut inconditionnel a une autre partie
du programme
exemple: jmp 0040458 <--- saute a 0040458
* NOP: (no operation): cette instruction n'est pas comme les autres.
Elle ne fait tout simplement RIEN!!
vous verrez par la suite son interet !
* RET: (return): instruction qui permet de revenir au programme appelant
quand une sous routine est terminee! (tres utile certaines fois)
* ADD: elle realise une addition entre les 2 operandes et place le
resultat dans l'operande destination.
ex: Add EAX, FFh --> EAX = EAX + FFh
* SUB: c'est pour effectuer une soustraction entre 2 operandes...
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 ca fait !!
* Les saut conditionnels:
vous rencontrez beaucoup de tests , comparaison pendant le cracking
ainsi pour traiter les resultats de ceci , 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 superieur
JGE (jump if greater or equal) = jump si c'est superieur ou egal
JL (jump if less) = jump si c'est inferieur
JLE (jump if less or equal) = jump si c'est inferieur ou egal
JA (jump if Above)
JNA (jump if not above)
......
je vous conseille de lire une documentation sur l'asm si vous voulez
plus d'info sur les types de saut ! il en existe encore
* MOV: l'instruction mov sert a placer une valeur dans un registre.
ex: MOV EAX, 56h ---> met 56h (86 en decimal) dans le
registre EAX.
* XOR: c'est un ou exclusif! tres utilise dans les routines de cryptage
ou de generation 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 utilise pour remettre un registre a 0
en effet, qd un xor 2 memes valeurs le resultat est toujours 0
ex: XOR EAX, EAX ---> EAX = 0
* PUSH: l'instruction push permet de placer une donnee sur la pile.
elle peut venir d'un registre ou d'un emplacement memoire!
ex: Push eax ---> pousse la valeur de EAX sur la pile
* POP: l'instruction Pop permet de recuperer une donnée posée sur la
la pile.
elle peut etre placee dans un registre ou dans un emplacement
memoire!
ex: Pop eax ---> recupere la valeur de EAX sur la pile
Voila , ca sera tout pour les bases en ASM!!
ces quelques descriptions ont , je l'espere, mis au clair
les qq problemes pouvant etre rencontres du a l'incomprehension
de certaines instructions!!
Mais il serait preferable pour vous d'avoir un livre d'asm
pres de vous , cela vous permettrais de chercher la description
des instructions qui vous posent probleme !
exemple de livre: ASSEMBLEUR PRATIQUE edition Marabout
Introduction a Wdasm8x:
Tout d'abord, je vais vous expliquer ce qu'est Wdasm, a quoi il sert
et quelles sont ses principales options!
Wdasm est un desassembleur! il permet de desassembler n'importe quel
fichier de type EXE , DLL , OCX ... pour obtenir son equivalent
en asm!
A quoi bon ? hehe ce genre de programme vous permettra de cracker
qq jeux, de s'enregister dans vos programmes et encore des tas d'autres
choses !!!
utilisation:
Apres avoir dezippe Wdasm dans un repertoire , il vous faudra configurer
la font car celle qui est par defaut n'est pas lisible lol :)
Car qd vous allez l'uliliser pour la premiere fois, vous verrez des signes
tout a fait bizarres et qui ne veulent rien dire !!
normal ! la font par defaut est : widings ou qq chose comme ca .
Changez la en : Times new roman par exemple , et vous pourrez enfin comprendre
ce que Wdasm vous montrera apres avoir desassemble !
changement de font: lancez Wdasm, dans le menu desassembler choisissez Font.
et ensuite select Font! et la vous pouvez faire votre choix!!!
les differents menus:
Dans Disassembler: Open file to disassemble
c'est avec ce menu que vous choisissez le fichier a desassembler!
ouvrez le fichier Calc.exe present dans le repertoire de Windows pour essayer
par exemple!
apres avoir desassemble , vous pouvez sauvegarder ce fichier pour pouvoir
le réouvrir ulterieurement !! (desassembler de gros fichiers peut etre parfois
TRES long !! d'ou l'interet de sauver le fichier !)
Pour cela , allez dans le menu "Save disassembly Text files.." de
Disassembleur.
Juste a cote de ce menu vous pouvez voir "Project"!
ceci sert a ouvrir les fichiers sauvegardes precedemment !
Je ne vais pas m'attarder sur la description de Wdasm , car il est fourni
avec une aide super !!! decrivant avec precision les differentes commandes!
Pour finir cette breve description des menus, je vais vous decrire le menu
Refs!
Alors celui la !! c'est le menu les plus utilise dans Wdasm !!
apres avoir clique dessus , vous devez apercevoir 3 sous menus.
je ne vous parlerai pour l'instant que de:
String Data References!
kesako ca ? c'est en fait une liste de tout les messages rencontres 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 detaillee dans la suite de ce cours !
quelques astuces en vrac:
pour copier coller dans Wdasm il suffit de clicker sur le debut de la ligne
a copier (un point rouge doit apparaitre) et ensuite appuyer sur la touche
Shift.Maintenant allez sur la derniere ligne a copier , et vous verrez que
toutes les lignes entre les 2 points que vous avez selectionnes contiennent
des points rouges !!
Cela signifie que vous pouvez maintenant copier coller ce texte qui est
selectionne!
Ctrl+C = copie le text
Ctrl+V = colle le text
l'interet de ceci est que vous pouvez decouper des bouts de codes et
les introduire dans vos tuts , ou Keygens :))
Patcher les protections avec Registrations
Nous allons voir ici l'utilisation de Wdasm pour patcher les protections
par serials !!
Theorie:
Dans de nombreux sharewares, vous rencontrez des protections par name / serials
et les programmes souvant pas tres malin vous mettent un msg disant que le
serial entre n'est pas bon !! qd vous avez rentre une connerie!
Appellons X le programme protege par name serial!
lancez X , et allez la ou vous pouvez entrer un nom et un code d'enregistrement
Entrez votre nom et un serial a la con style: 112233 et clicker sur le bouton
permettant de verifier le serial style "OK" et vous verrez le message a la con
vous disant: "le serial que vous avez entre n'est pas valide"
hehehehe, deja si vous voyez ca vous pouvez vous dire que c'est bien parti !
Alors ouvrez Wdasm et selectionnez le fichier executable du programme a cracker
comme je vous ai montre dans la partie d'avant !!
Maintenant allez jeter un oeil dans les String Data references et vous avez
plus qu'a chercher le message d'erreur rencontre lors du mauvais serial !!
Sans tarder vous le trouvez dans la liste des messages !!
Double cliquer dessus et vous atterrissez a l'endroit dans le programme ou
s'effectue le test.
vous tomberez Tres souvent sur qq choses comme ca:
: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 entre.."
Ici on voit tres 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 donne au debut
si vous avez oublie la fonction de jne...
que fait donc ce code ?
si le code n'est pas egal au bon code : TEXT EAX, EAX n'est pas egal
a 0 et donc le jne (jump if not equal) saute vers le message d'erreur!
Donc comment cracker ca ?
Facile, nous devons avoir EAX = 0 pour que le serial soit pris comme valide
donc la facon la plus propre est de forcer EAX a 0!
L'instruction qui met a 0 un registre est XOR
XOR EAX, EAX = 0 (si vous comprenez pas pourquoi , allez voir au debut du
cours dans les bases en ASM).
le code modifie ressemble a 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 entre.."
la ligne:
:0100177D 85C0 test eax, eax
est devenue:
:0100177D 33C0 xor eax, eax
Voila !! 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 entre un bon serial !!
"Merci de Votre support , vous etes maintenant enregistre BLABLABLA "
:-) coool tout ca !! Mais vous vous demandez surement comment j'ai su que
le 85C0 deviendrait 33C0 et comment on peut changer ca dans le programme ?
hehe , ca vient !!
pour savoir a quoi ressemble le code en hexa d'une instruction vous pouvez
utiliser l'option de l'editeur hexa Hacker view, mais bon j'aime pas cet
editeur!! je connais ces valeurs par coeur.Donc essayez de vous en rappeler
Pour effectuer ces modifications dans le programme , il faut utiliser un
editeur hexadecimal.J'utilise Hexworkshop car c'est a mon avis le meilleur!
Donc lancez l'editeur hexa , et ouvrez votre fichier a patcher avec...
Faites une recherche des octets a patcher et remplacez par les nouvelles
valeurs. exemple dans ce cas: recherchez: 85C075128D856CFF
Vous devez trouver un seul endroit correspondant a ces octets sinon
faites une recherche avec plus d'octets!!
une fois que vous avez trouvé, remplacer par: 33C075128D856CFF
sauvegardez le fichier et c'est pres!!
NOTE: si vous avez ouvert le fichier et qu'il est toujours ouvert par
Wdasm, vous ne pourez l'enregistrer car le fichier sera deja en lecture
donc vous serez en lecture seule!!
Petite astuce pour ne pas etre emmerde :
Avant de desassembler votre executable, faites en une copie et renommez
l'extension en .AB par exemple! desassembler le fichier a l'extension .ab
et une fois que vous savez ou 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 Wdasm!
Donc voila vous avez sauvegarde le fichier ! relancez l'executable modifie
et vous entrez un nom / serial bidon, et clickez sur le bouton pour verifier
le serial! Miracle le message : "Merci de votre support" ou autres conneries
du genre apparait !! 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 simplemement car il y a un autre controle du serial dans la base
de registre ou meme dans un fichier ini!!
L'encule :) heheh il est souvent tres simple a patcher ca !
Dans les strings data references , si vous voyez une reference du genre:
"Licenced to:" <-- il doit avoir des tests plus haut , ou des appels par
des call ou sauts conditionnels !!
vous avez juste a modifier le programme pour qu'il saute en version
Enregistre a tout les coups !! en remplacant un JE en JMP
(en hexa: 74 --> EB)...
Pour en revenir a l'exemple de tout a l'heure on a modifie le TEST
en XOR, mais on aurait tres 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 entre.."
le jne saute au mauvais message si le numero de serie n'est pas bon !!
donc pourquoi ne pas l'empecher de sauter tout simplement ??
Comment ? ben si vous avez jete un oeil au debut du cours vous avez
surement remarque 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 voila !! plus de problemes non plus :)
Le code hexa pour nop = 90 !! ne pas oublier ca !! vous vous en servirez
toute votre vie (de cracker)
Modification dans l'executable comme tout a 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 en prog pour qu'il accepte n'importe quel numero de
serie.nous allons voir comment faire quand un prog accepte le serial
mais des qu'on le relance , il nous dit version non enregistree !!
Et pour finir reactiver une fonction du prog accessible qu'en version
enregistree !!!
donc pour ce crack on a besoin de :
- WinRAR 2.05
- Wdasm 8.9
- editeur hexa comme HexWorkshop
1) Analyse du prog !
on lance WinRaR et on voit dans la barre des taches : (evaluation Copy),
dans option, general , 2 functions desactivees (Log errors to file et put
authenticity verification).Et dans option : Registration.
on rentre notre nom et numero de serie: il nous dit: Registration failed
2)Lets kick this fucking tool !
Donc on fait une copie de sauvegarde de Winrar95.exe puis on le desassemble
avec Wdasm.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 Wdasm
on remonte un peu on voit ca:
: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 la on voit tous de suite le saut conditionnel : jne 00413c93
jne veut dir jump if not equal donc le prog saute au message d'erreur qd le code
est mauvais !
on le remplace par je 00413c93 et hop ! il ira sur le mauvais message qd on rentrera
un bon code !! il peut tjs attendre !!!
donc on remplace le 7532 par 7432 (note: j'aurais tres 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 enregistre :(
On reflechit et on voit dans la barre des titres: (evaluation copy).
tous a l'heure qd on a rentre un code ce message etait parti.
Donc on cherche : '(evaluation copy'), dans les strings data reference.
bien prendre celle avec parentheses.
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 !!!
enore un chtit saut conditionnel , on le remplace en je avec un 74 a
la place du 75 on sauvegarde , on relance et on est enregistre ! :)
Mais , n'oublions pas de tester le proggy !! et on voit les 2 fonctions
desactivees citees 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 patche comme un cowboy mais
// si je commence a retoucher tout j'ai pas encore fini !!
Bon ben voila !! c'etait un exemple concret de comment patcher un programme
pour qu'il accepte tous les serials a la con , et comment reactiver
des fonctions desactivees !
Il existe des programmes BCP plus durs a patcher et aussi encore plus
simple que celui la !!
Note: si jamais apres avoir desassemble vous ne voyez aucune string
data reference il y a de fortes chances que le programme soit packer
(crypter grace a un packer!!) pour savoir comment decrypter un executable
a la main (manual unpacking) lisez la suite du cour !! ca arrive ;-)
Et pour finir voici une source d'un patch en delphi que j'ai programme
il y a deja 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 a Soft ice
Alors la on commence les choses plus serieuses !!
Voice Soft ice le debugger de chez Numega !! C'est le debugger utilise par
tout crackers digne de ce nom
Grace a 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 (tres utiles pour tracer les routines
de registration) ...
Bref, je vais vous citer ici les differentes commandes utiles et necessaires
pour pouvoir se demmerder ;)
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 editez votre fichier winice.dat avec notepad par exemple, et voici
les choses a modifier:
PHYSMB=64 <--- mettez ici votre nombre de RAM (j'en ai que 64 !!)
pour une meilleur lisibilite , a 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 a 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 ca ! 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
voila !! cherchez ca! c'est pas bien loin dans le fichier, et vous avez
surement remarque les ";" les points virgules mettent en commentaires !
donc il faut les enlever sinon on ne pourra rien cracker car les bpx
sur les API windowns impossibles (si vous comprenez pas ce que je raconte ;p
ca fait rien vous comprendrez bien assez tot !!)
donc modifiez ca 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 surement remarque que j'ai ajoute 2 fichiers dll dans la liste ci
dessus par rapport a 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 pretention si ce n'est
de marcher ;p
;************ACiD BuRN's Winice.dat copier a 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 selection *****************
Donc vous copier / coller ceci dans un fichier nommé winice.dat et
mettez le a la place du votre !! Mais changez qd meme le nombre de Ram par
celui de votre PC (pas trop dur ;p)
voila, ca sera tout pour la configuration de soft ice !!
passons aux commandes maintenant !!!
*****************************
** Commandes de Soft ice: **
*****************************
-pour faire apparaitre soft ice, pressez: Ctrl+D
Tout d'abord , les points d'arret (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
represente la fonction windows que vous voulez 'etudier')
Apres avoir mis un bpx sur une API windows vous pouvez par exemple
voir la liste des bpx deja poses!
Liste des bpx: BL
Editer un bpx: BE numero_du_bpx
Effacer un bpx: BC numero_du_bpx
Effacer tous les bpx: BC *
Désactiver un bpx: BD numero_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 :)
ceux que je fais aussi , mais qd 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)
Voila , comment trouver les serials valident 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 , prenom , et un numero de serie a la mort moi le noeud!
on appuie sur OK.
la le programme nous envoie chier car le numero est bidon.
on va donc poser un point d'arret sur une fonction de windows qui
est tres couramment utilisée pour 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 S-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'arret: BPX Getwindowtexta
BPX getdlgitemtexta
on appuie sur F5 et on retourne a windows.
j'ai entré pour First Name: ACiD
pour Last Name : BuRN
code : 12345
on appuie sur OK.
Boum, S-ice est reapparu 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 'controle' 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.interressant car si on fait :
? EAX
on voit apparaitre : 00003039 0000012345 "09"
3039 c'est en hexadecimal et 12345 c'est en Decimal.
12345 ce ne serait pas le code que l'on a tape au debut ? mais si
on ne doit pas être tres loin.
on continue a tracer (avec F10) tout en surveillant EAX et apres
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'arret.
F5 et nous voila sous Windows.
Donc on entre First Name: ACiD
Last Name : BuRN
Code : 513524
Et voila le programme ne nous envoie pas chier nous sommes maintenant
enregistrés !!! hihihi , trop simple n'est ce pas ?
mais bon , ne vous rejouissez 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 la , j'ai du faire une equation , et le serial n'est pas tapable
au clavier directement.. je vous invite donc a lire ce cours qui se trouve sur
ma page :)
Petite astuce sur les programmes programmes en delphi:
les API precedemment cites ne marchent pas en delphi!! car ils ne sont pas
utilises! donc pour pouvoir Breaker:
BPX hmemcpy <-- je me sers tres souvent de celui la !! on est sur de
stopper dans soft ice au moins!
Dans de nombreux programmes, la comparaison GOOD serial / BAD serial se fait
de la facon suivante:
CMP EAX, EDX
je good message
jmp get_the_fuck_outta_here!
En gros, le bon serial (dans EDX) est compare 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 controle de serial !!
si le programme est en delphi et que vous ne cherchez qu'un serial valide:
mettez un bpx Hmemcpy apres avoir entré un nom et numero de serie.
ensuite, pressez le boutton OK, et vous revenez sous soft ice, maintenant
pressez F5 le nombre de fois necessaire pour quitter soft ice mais comptez
les !! exemple: 12 fois
ensuite , recommencez la meme chose, mais arretez 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 etes au bon endroit (vous verrez le nom de l'exe a la place du
nom des dlls) commencez a tracer avec F10!
vous rencontrerez une serie de RET, mais ca 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 grace a F8
jz blablabla
Tracez ensuite avec F10 et vous devriez voir le fameux: CMP EAX, EDX
decrit 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 defini si c'est ok !! remplacez le
par un JMP par exemple et le programme ira toujours au bon message !!
donc vous serez enregistre :) oh my god hehe
je ne vais pas encore ecrire un tut pour ca ;p mais je dois avoir encore
un exemple sur un name / serial
cette fois ci , c'est sur un crackme programme en delphi :) donc
on va utiliser BPX hemecpy comme prevu :))
*************************************
** 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 and 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, ca marche tout le temps!
ok, on reentre name: ACiD BuRN and serial: 1122334455.
Cliquez sur le bouton et la on est de retour dans Sice !
Cool !
Nous voyons KERNEL en bas de la fenetre... il faut sortir d'ici.
Pressez F12 autant de fois necessaire (7x) pour que vous voyez en bas de la fenetre:
HF CRACKME ..
Nous sommes a la bonne place... F10 pour continuer a 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!
Desactivez 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 methodes comme l'utilisation de BPR, je vais
vous decrire ce qu'est le keygening pour ceux qui ne savent pas !!
Keygener un programme c'est quoi ?
c'est ecrire un programme qui genere des clefs (serials) valides pour
un programme donnes , en fonction des noms , numero de serie du
disque dur ...
Bref, on trace avec soft ice la generation du serial en memoire et
on reprogramme ceci , afin que l'on obtiene les codes valides pour
ce programme tres rapidement :)
C'est tres interressant , croyez moi :)
bon tout d'abord , je vais vous montrer un exemple tres simple !!
sans methode specifique , et ensuite , dans un prochain exemple
vous montrez qu'utilisez les BPR est un gain de temps non negligable !!
************************************************************************
** How to keygen the Cracking4newies Crackme 3 project **
************************************************************************
niveau: debutant
I)C'est parti !!
Ok, c'est partie , il est temps de keygener cette chiotte :) donc dans soft
ice , mettez vos BPX preferes !! ceus utiliser dans les protections par
names / serials :
bpx getwindowtewta et getdlgitemtexta.
Entrez votre nom et un faut serial (name : ACiD BuRN / Serial : 12345).
Clickez sur enter et vous etes de retour dans soft ice !!
pressez F12 parce que vous n'etes pas a la bonne place , mais dans cette merde
de user32.dll...
Maitentant , vous etes dans le crackme ! (j'espere que vous comprendez tout,
je suis trop fatigue !)
Tracez tant que vous n'arrivez pas a ca:
* 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 1ere 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 caractere a la position EDX
add esi, eax <== esi = esi + eax
inc edx <== caractere suivant
cmp edx, ecx <== compare la longeur du nom avec le compter en edx
jbe 004010AF <== Boucle tant que tout les chars n'ont pas ete fait!
Donc , cette boucle prends les valuers ascii de chaque lettres et les ajoutes dans ESI.
Resulat pour ACiD BuRN: 2A8h
41h + 43h + 69h + 44h + 20h + 42h + 75h + 52h + 4E = 2A8h
A C i D space B u R N
Apres 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 place dans [ebp+8].
ensuite,on voit : shl dword ptr [ebp+08], 07
Interessant ;)
Ben, on continu a tracer :-]
tant que vous n'arrivez pas a ca :
* 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 egal saute a 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 ca! vous pouvez coder un keygen facilement non ? !!
laissez moi vous repetez l'algo:
1st part: additionez les valeurs ascii du nom et mettre le resulat qq part (ESI en memoire)
2nd part: Prendez la valeur en ESI et fait un shl,7 dessus et met le resultat qq part
([ebp+8] en memoire)
3rd part: additionez la valeur de la premiere partie et additionez la a celle de la
2eme partie.
4th part: Prenez le resultat en decimal et vous avez votre serial :)
Name : ACiD BuRN
sERiAL : 87720
Je vous ai tout donner pour faire votre propre keygen, mais je vous file qd meme mes sources:
je vais vous montrer 2 sources! une en delphi+asm et une en C+asm
celle en delphi a ete codé a 2h du matins !! vite fait :) mais ca 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 declarer les variables!
Bien moin chiant que l'asm directe!!)
*********************SOURCES C++ + ASM************************************************
#include <stdio.h>
#include <string.h>
#include <conio.h>
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 methode :) ****
*************************************************************************************
Maintenant ! utilisation des BPR pour keygener !
La technique je vais vous montrer marche tres tres bien avec les programmes
en C++ par exemple :)
je ne vais pas vous saoulez longtemps , mais ecrire 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 ete ecrit en C++
Coool, tres bien pour s'amuser avec !!
On peut keygener ce crackme sans utiliser les BPR , mais grace aux BPR
vous allez voir comment tomber directement sur la routine de generation
du serial !!! let's go:
Entre votre nom : ACiD BuRN et serial: 112233
Sous soft ice mettez les bpx suivants: bpx getdlgitemtexta et
bpx getwindowtexta ....
Ensuite pressez le bouton pour verifiez le serial et vous etes 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 poura pas exainer
les parametres sur la pile !!
On va agir inteligement plutot ! On va examnier la pile !
Nous allons regarder les parametres et mais pour cela on va se mettre en
Dword sous soft ice !! ca sera plus lisible deja.
Sous soft ice: dd esp
"dd" veut dire: display dword et "esp" c'est pour le pointeur de pile!
Apres avoir fait "dd esp" la fenetre de soft ice change et on peut voir les parametres :
xxxx:yyyyyyyy A B C D ................
xxxx:yyyyyyyy E F G H ................
Ou A,B,C,D,E... sont du genre: XXXXXXXX
vous devez voir qq chose qui ressemble a cela:
xxxx:yyyyyyyy 5F403504 00000098 00654250 0000000A ...........
on ne vas s'occuper que de ca !!
(donc vous l'avez remarque , ici A=5F403504 , B=00000098 ...)
on voit ici l'addresse a laquelle notre nom se termine (00654250)
Tapez D "addresse a laquelle finis le nom"
exemple ici: D 00654250
vous pouvez maintenant pressez F11 et vous pourvez voir votre nom a l'addresse
que vous avez tapez :) c bon signe deja !!
Nous allons maintentant poser un bpr (break on memory range)
cette type de bp marche de la facon suivante:
bpr "adresse de depart" "addresse de fin" RW
RW veut dire: Read et writte (lecture et ecriture)
Donc, sa stopera qd on lit ou ecrit a cette addresse en memoire !
Donc tapez ceci sous soft ice:
bpr 654250 654250+(longeur_du_nom - 1) rw
Dans notre exemple cela donne pour ACiD BuRN (longeur: 9 -> 9 - 1 = 8)
bpr 654250 654250+8 rw
Vous pouvez desactiver les bpx sur getwindowtexta et getdlgitemtexta now !
Vous n'avez plus qu'a presser F5, et on se retrouvera directement dans la
routine de generation de serial !!
Notes: Pressez F5 tant que vous n'etes pas dans le crackme !!
c'est a dire que les DLL on s'en branle :)
Une fois que vous etes dans le crackme vous arrivez directe sur la
generation.
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 resultat
:00401586 41 inc ecx ; incremente ecx (ecx = ecx + 1 )
:00401587 40 inc eax ; incremente 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 a 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 recupere les valeurs
2eme partie: sur le serial entre :
* 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 resultat
:004015A3 41 inc ecx ; incremente ecx (ecx = ecx + 1 )
:004015A4 40 inc eax ; incremente 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 derniere routine: verification 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 recupere 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 egale ?
: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 ca 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 voila !! je crois que vous avez compris ce qu'il se passe ici :)
La routine de genearation est tres simple !!
je ne vais donc pas m'attarder dessus , mais je vais donner les sources du keygen
bien sur !!
Apres le C++ , le delphi , c'est autour du VB !!
Ayant la flemme de traduire ca en ASM (tres simple , mais j'ai pas le gout) je vous
propose tout de meme ces sources !!
Le but de cette explication etait la familiarisation avec les BPR !!
Pas de savoir keygener juste ce crackme la !!
Avec cette technique vous pouvez keygener bcp de choses , ensuite ca depends
de votre niveau en asm et de la registration !!
si ca 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 etre superieur à 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 ?
voila, la partie des keygens est terminee, mais entrainez vous avec les BPR!
c'est super et utilise par bcp de keygners aussi...
Pour le delphi, il vous faut trouver l'addresse memoire de votre nom et faire
a peu pres la meme chose ensuite :))
Enjoy !
CD Check (les BPX , et techniques diverses..)
Alors la , c'est la partie cracking jeux!!
qu'est qu'un CD check ?
un cd check est la detection du cd dans le lecteur pour eviter 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 proteger 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 eleve 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 dernieres protection
de cdilla !! n'ayant aucun jeux originaux (hehe ,no way ) je n'ai pas pu
tester la toute derniere version encore , qui est sois disant plus dure;)
je vais aussi vous parler des protections commerciales !
Mais je vous decrirez que CD LOCK et CD illa ! il existe de nombreux cours sur securom, et autres protections CD commercial !
j'ecris pas un roman lol
Alors nous allons commencer par les protections TRES TRES simple !!
LES CD check de bases:
*** Avec Wdasm: *****
Comme exemple on va prendre Formula 1:
il controle si il y a le CD du jeux et si ce n'est pas le cas il refuse
de se lancer.
Apres avoir installer le jeux on le lance (apres avoir retité le CD !!!)
Et un message aparait "Formula 1 CD NOT Found".Il n'en faut pas plus
Pour le cracker.
Prenez Wdasm et desassembler le fichier executable en l'occurence
F1win.exe.
Chercher Dans String Data Référence (Menu "Refs") de Wdasm 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
la il y a un test qui ne nous envoie pas au jeu si il ne trouve pas le
CD donc on place de 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 recherchez avec un editeur hexadécimal
la chaine FF 52 34 85 C0 7D 50 et la remplacer par FF 52 34 90 90 7D 50
c'est tout.
2eme exemple : Quake 2 v3.14
apres avoir installer le jeux ou apres 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 desassembles le fichier avec Wdasm puis on cherche dans Sting Data References
le message "You must have the Quake 2 CD in ..."
Bcp de jeux utilisent cette connerie de messages !! (ils sont rares de nos jours
cependant!)
vous marques "Please insert the XXX CD" vous cherchez cette phrase dans
String data reference.)
Apres avoir trouver cette phrase dans string data reference clicker 2
fois dessus cela vous amenera au desassembler a la ligne du message.
Remontez un peu avec la bare de defilement vous trouverez juste au
dessus:
E82BFFFFFF call 0042F520
803800 cmp byte ptr [eax], 00
750F jne 0042F609
la on voit un petit "750F" qui represente le "Jne" (celui que je vous
parler au debut) il represente un saut si ce n'est pas egale.Donc si
il n'y a pas le CD dans le lecteur ce n'est pas "egale au CD" donc le
programme saute au message d'erreur et le jeux 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 definitivement le jeux on cherche la chaine
Hexadecimale suivante avec un editeur Hexa du style Hexworkshop, Hedit.
la chaine : FF FF 80 38 00 75 0F et la remplacer par FF FF 80 38 00
90 90.
Fermez Wdasm et lancez Quake 2. Bingo le jeux marche c'est cool!
Vous allez me dire !! ca marche que sur les vieux jeux ca ;PP
alors comme autre Exemple: KING PIN Fr version
***************
*** KingPin ***
***************
Cracking part:
Qd vous lancez le jeux avec un CD grave , on voit les super (lol) message:
You must have the KingPin CD in the drive to play...
hahah, j'adore ce genre de conneries!
Lancez Wdasm et desassembler le jeux!
Allez dans les references et cherchez la phrase du jeux!
Double click dessus et on ne voit rien ne 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 ca fait branleur !!!
Reflechissons un peu ;)
on a vu :
* Referenced by a CALL at Address:
|:0043D5F1
Donc avec Wdasm 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, voila !! c'est ce call de merdes qui appel la routine de cd check !
on va le noper et il nous tanera plus !! promis
clickez sur ce call , en bas de la fenetre de wdasm vous devez voir offset : 3D5F1
Lancez votre editeur hexa et allez a cette offset !
On remplace E83A4A0000 par 9090909090.
Enregistrez le fichier et lancez le ;)
Choisissez new game , et WOW !! le jeux marche *grin* !
Piece of cake !!
on vient de cracker King Pin ! un jeux super, recent mais avec une protection
de merdes :) (tant mieux hehe, vous allez voir cdilla , c'est autre choses)
voila , c finis pour les CD checks de bases avec Wdasm !
**** CD check Avec Soft ice *****
Voici un exemple Tres 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 utilises 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 a la bonne place !!
vous devriez voir qq chose comme ca:
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 differents type de lecteur et leurs references:
la valeur dans EAX veus dire:
0 Lecteur indetermine
1 repertoir sur la racine n'existe pas
2 Disque removable
3 Disque dure
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 ca
on nop ca ! et plus jamais de problemes avec ca hehehe !!
on ouvre le crackme avec un editeur hexa et on cherche 83F80575DC et on remplace par
83F8059090.
Apres ce controle de type de disque on voit un "CALL KERNEL32!GetVolumeInformationA"
hehe , une API souvent utilise par les CD checks!
ca ressemblais a ca:
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 conditionel et le CD is no more :)
Ben voila , c'est finis , 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 surement beaucoup a vouloir Tomb Raider III mais ce jeux est protégé
contre la copie ! en fin, en theorie !!!!
Tous 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 chaqun : Awcs.afp ; Neir.afp ; Oket.afp et
Vfaw.afp.Pour Pouvoir le graver il faut d'abord copiez tous les fichiers du CD sur le
disque dur , sauf les 4 cités plus haut.Ensuite creer 4 fichiers avec le meme nom avec un
caractere dedans pour que le fichier fasse 1 octet.Maintenant on graver le CD sans probleme
mais le jeux ne marcheras pas car il est encore protegé !!! Et c'est là qu'intervient le
cracking!
Nous sommes en presence d'un Cd Check (controle du CD) et le jeux nous affiche le message
" Tomb Raider III CD ?" malgré la presence du CD Gravé.
Si Vous avez lu le premier cour, vous vous dites comme moi , on va le desassembler et chercher
cette phrase dans String data reference.Le probleme c'est que l'on ne trouve pas cette phrase
donc il suffit de reflechir un tout petit peu.
Il y a 4 fichiers qui servent à rien donc on va chercher le nom de l'un d'eux dans les Sring data
reference.on voit d:\Awcs.afp , d:\Neir.afp , d:\Oket.afp et d:\Vfaw.afp.
Donc on double click dessus et on retourne dans Wdasm ,juste au code source de cet reference
on remonte avec les barres de defilements 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 saute que si il trouve le fichier. il peut
toujours chercher !!!Donc maintenant on ouvre le fichier Tomb3.exe avec un editeur hexadecimal
et on cherche la chaine 85FF756568D4 et on la remplace par 85FF746568D4 .
et on enregistre le fichier. Le jne 0048D2CE est devenue Je 0048D2CE.
Maintenant on refait pareille 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 pareille au fichier "D:\Vfaw.afp"
C'est normal il n'y a rien à changer.Donc Vous avez changer :
- 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 tous changer Avec l'editeur Hexadecimal et Sauvegardez.Une fois ceci
fait vous pouvez lancer le jeux avec un Cd gravé dans le lecteur !!!
Tomb Raider III is Now Cracked !!!
voila!!
la Protection CD lock est assez stupide en fait !!
meme tres simple a cracker ! vous la retrouverez dans Commandos par exemple aussi :)
Pour le cour qui suit sur cdilla , il serait preferable d'aller jeter un oeil
a la partie unpacking qui suit ce cour si vous ne connaissez rien en unpacking et
autres dumping !! Mais si vous etes deja a 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 !!!
voila , let's go
************************************************************************
*** CDilla : Safe disc ****
************************************************************************
MidTown Madness version Francaise: Une autre approche sur cdilla
Outils nescessaires: * CD Original de Midtown madness
* Soft ice 3.23
* soft ice tool pour patcher soft ice (pour dumper les sections)
* Hexworkshop
* Frog ice (pour cacher soft ice)
* Procdump (comme PE Editor)
* Exescope
Introduction:
salut a tous , je sais qu'il y a deja un cour sur Midtown madness par black check
mais la methode que j'utilise n'est pas la meme que lui...
Je vais expliquer le plus de choses possible et en plus c'est le 1er cour sur
cdilla en francais !!!
il serait preferable de lire le cour de black check avant , et d'avoir quelques
connaissances sur le format PE...
A Mort cdilla:
Apres avoir installer le jeux , editer le PE du fichier ".icd" avec procdump.
(lancez procdump , clicker sur PE Editor , allez ou 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 la calculer des 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 additiones)
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" excepter la section ".Rdata"
car , c'est plus complique pour celle ci !!
il faut tout abord additioner 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 jeux ).
Vous avez surement remarque , que si vous lancez le jeux avec soft ice charge , il
vous envois chier , car il y an de l'anti soft ice.
cdilla utilise meltice (createfilea) et l'int68h pour detecter sice.
Le mieux , c d'utiliser frogice , pour le cacher.J'utlise la version 0.20b , mais
il faut la patcher pour qu'il cache completement soft ice de la detection par int68h.
dans le cour 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
voila , maintenant , plus aucun problem avec la detection de soft ice , on va pouvoir
s'occuper des choses serieuses !!
Lancez votre frog ice (version patche) et lancer le jeux.
Pendant la video , faites apparaitre soft ice (ctrl+D) et mettez votre bpx sur l'OEP:
Bpx 56CC10 pour ce jeux...
presser F5 , le jeux continue de se lancer, et quitter le.
Maintenant relancez le et soft ice breaks sur 56CC10. Si soft ice ce break pas , regardez
si vous avez bien mis votre bpx au bon endroit!(tapez bl et vous devez obtenir qq chose
comme ca #025F:56CC10)
Donc , soft ice break sur l' OEP , vous avez plus qu'a dumper les sections :)
Avant le dump desactiver tous les bpx (bd *) car on veut pas de merdes dans nos sections
dumpes ehe !!
grace a sice tool , vous avez modifie la commande pagein qui vous permettra de dumper...
la commande pagein fonctionne donc comme ceci pour dumper:
pagein "l'addresse du debut du dump" "longeur 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
Voila , nous avons donc nos sections sur le disque dur !!!!
Passons aux choses serieuses !!! : La Section Rdata :
Bon , pour dumper cette section , c'est pas aussi simple =)
Tout d'abord , nous devons trouver l'adresse reelle de la fonction de decryptage et pour
cela nous allons tracer dans le call qui appelle dans la section rdata...
Apres que soft ice est stope sur l'OEP, on arrive ici :
00566C10 PUSH EBP <-- on stop 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 designe les imports kernels , pour les users ca sera 1
009A6490 call [9A64A6] ---> l'addresse reelle de la fonction (9A64A6)
009A6496 add esp, 8
009A6499 popad
....... jmp [XXXXXXXX]
Tracer 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 bientot programmer le Call fixer...
mais avant tout, nous devons connaitre le nombre d'import de Kernels and users qu'il y a dans
le jeux que l'on crack.
Pour cela , plusieurs methode , on peut desassembler le fichier ".icd" avec wdasm
et les compter ou bien tracer avec soft ice , mais j'ai utiliser un programme nommé : EXESCOPE
pour savoir le nombre d'import ...
Donc dans le fichier midtown.icd j'ai :
- 127 imports pour kernel32
- 42 import pour user32
Ok , nous avons besoin des ses valeurs en hexadecimal, car dans soft ice on n'utilise pas de
decimal:
127 = 7Fh
42 = 2Ah
Ma partie preferée qd on crack cdilla: Programmer le call fixer.
Nous n'avons pas l'access en ecriture dans la section Rdata , donc nous allons la deplacer
dans la section rdata...
Pour coder le call fixer , je commence sur l'entry point , donc il faut reactiver le bpx
sur l'OEP , et relancer le jeux.Attendez que le jeux stop dans soft ice.
Maintenant on va deplacer notre rdata section a la place de la data section en memoire.
Pour faire ca : taper :
m "le virtual offset de la section RDATA + l'image base" l "la longeur 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 utilise 5B0000 (Plus grand comme je vous ai dis)
Vous avez donc a taper:
m 58F000 l 14C99 5B0000
Maintenant, Nous allons programmer le call fixer !!
Vous etes donc a la ligne: 566C10 PUSH EBP
ce que nous allons taper va ressembler a 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 entrer"
et programmer :
566C10 pushad
566C11 push ebx
566C12 push 0
566C14 call [009A64A6] <-- addresse de la fonction trouvé en tracant dans le call
566C1A add esp,8
566C1D mov edx, 5B0000 <-- addresse ou nous avons copié notre section .rdata
566C22 cmp eax,[edx]
566C24 je 566C40
566C26 inc edx
566C27 cmp edx, 5B0000 + 14C99 <-- addresse ou nous avons copié notre section .rdata + rdata size
566C3D jne 566C22
566C3F int 03 <-- par securite, si il ne trouve rien , il stop ici
566C40 mov [edx],ecx
566C42 popad
566C43 inc ebx
566C44 cmp ebx, 7F <-- Nombre d'API a reparer
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 executer le code, normalement on devrait stopper sur 566C4C
remettez votre ebx a 0, changez la ligne 02 (56CC12 ici) en "push 1" et changer la ligne 24 en
'cmp ebx, user_import_number' (2A for us) et remettez votre eip à la ligne 0 (R EIP 566C10).
executer ca encore (F5).Normalement tout est ok , et on doit encore avoir stoper sur 566C4C
Nous pouvons maintenant dumper la section rdata sans crainte car tous est decrypter :o)
pagein 5B0000 14C99 c:\rdata.bin
hehe !! maintenant on va reconstruire un fichier executable qui va etre le fichier final.
j'ai essayer Procdump pour importer les sections , mais cette merde n'a rien changer GRR !
Donc, je l'ai fais a la main comme un grand ;)
voila comment faire :
En premier faites une copy du fichier ".icd" (Midtown.icd) et renomer le en ce que vous voulez
mais avec l"extension ".exe" ex: fuckit.exe
Ok , lancez hexworkshop , ouvrez "Damnit.exe" ,ansi que le fichier de notre premier section
dumpé :
c'etais: c:\text.bin
On va avoir besoin du Raw offset de chaque section , on les trouves au debut du cour mais
je vais vous les remettres pour une meilleur comprehension:
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 cliquer sur ok. Allez dans le menu Edit, et cliquer sur "select block"
entrez la longeur (size) de la section , ici : 18D78F...
Regardez le fichier ouvert (text.bin) et pressez 'ctrl+a' pour tout selectioner..
copiez tout ca avec 'ctrl+c'.
Retournez dans la fenetre principal de l'executable dans hexworkshop (damnit.exe), et coller
ce que vous venez de copier dans le press papier , faites: 'ctrl+v' ou menu Edit et paste.
Enregistrez votre fichier , cool !! voila , c finis pour la section '.text' elle est maintenant
decrypter!!
ok , je vais vous montrer l'import d'une autre section et vous ferez les autres de la meme facon!
2eme section : Rdata!
Vous pouvez fermer la fenetre 'text.bin' , et ouvrez le fichier: 'rdata.bin' avec hexworkshop
Retournez dans la fenetre de l'executable 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 longeur (size) de la
section , ici : 14C99
regardez la fenetre de rdata.bin , pressez 'ctrl+a' pour selectioner tout et copier les bytes
avec 'ctrl+c'...
retournez dans la fenetre de l'executable (damnit.exe) dans hexworkshop et coller avec
'ctrl+v' ou avec le menu Edit..
ok , je pensse que vous avez compris maintenant , faites de memes avec toutes les sections
et enregistrez les modifications dans l'executable..
Vous puvez quitter frog ice car l'anti sice n'est plus dans notre nouvel executable !!
Virez le cd original de midtown madness et lancez 'damnit.exe'.
WOW , le jeux marche se lance tres rapidement et sans cette merde de fenetre qui nous dis
d'attendre durant la verification du CD.
Le jeux marche superbement bien :o)
Mais pour faire une executable parfait, il faut reconstruire le PE en utilistant Procdump
afin qu'il marche avec tous les OS.
Si vous lancez le jeux sur une autre version de Windows ca va planter :(
Allez , on va reparer ca !!
-Lancez Procdump (Merci G-RoM :)
allez dans les Options et selectioner:
[X]Recompute Object Size
[X]Optmize PE Structure
[X] Use actual import infos
et cliquer sur OK
Cliquer sur Rebuild PE , et cherchez notre nouveau fichier (Damnit.exe pour nous)
Procdump nous fais une valide import table et notre executable est PARFAIT :o)
du moins , j'espere hehe !!
voila , je pense que ca suffira pour les protections CD !!
On va passer a autre choses now !! hehehe
Manual Unpacking (comment unpacker , les tools , methodes...)
Qu'est-ce que le manual unpacking ??
Vous avez surement remarque que certaine fois qd on desassemble un fichier
on ne trouve plus de strings data references !!!
c'est car le fichier est crypte ou compressé !!
Merde alors.... Ben il existe des unpackers me direz vous , mais c'est pas
marrant qd ca fait tout tous seul !! :-o
donc, je vais tenter de vous expliquer comment , et avec quoi decrypter les fichiers...
Je vais vous montrer quelques exemples comme : ASPACK , ARMADILLO , UPX , NEOLITE ....
(note: lisez aussi le cour sur cdilla dans la section CD check)
Tout d'abord qq infos sur le format PE !!
Schema pour vous donner une idee de la bestiole ;) :
(from PE.txt)
+-------------------+
| 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 meme , mais je vais vous donner quelques
infos sur les sections et autres caracteristiques !!
Vous aves surment remarque que dans Procdump (unpacker) il y a un PE editor (editeur
de PE) tres tres utile vous le vairez plus tard...
Que ce passe t'il si on edit un fichier ??
on peut recuperer l'entry point , l'image base, les caracteristiques des sections ...
A propos des caracteritiques:
0x20...... : Cela Veut dire executable
0x40...... : Cela Veut dire Readable (lisable)
0x80...... : Cela Veut dire Writeable (ecriture possible)
exemple 0x60.. -> executable + lisable
0x......20 : Cela Veut dire contains Code
0x......40 : Cela Veut dire Initialized data
0x......80 : Cela Veut dire Unitialized data
(pris d'une doc sur le PE)
voila, je ne vais pas faire un cour sur le PE , car mes connaissances sont plutot limites
a ce sujet! je cherche donc de la doc sur le PE en francais !!!
j'ai vraiment pas le gout de traduire les Doc disponibles en anglais !
si qq1 sait ou trouver ca , merci de me mailer ;-)
Bon assez de blablabla, on va commencer par un cour sur ASPACK:
***************************************
**** ASPACK ******
***************************************
ce tut est pour apprendre a unpacker ! vous apprendrez les bases !!
mais je vais prendre une application, freeware, compactee avec aspack
(on s'en fout de toutes facons! hehe !!)
Je ne vous montrerais que comment on retrouve les String Data Reference
dans l'app donc pas de table d'import, car ce tut a pour but de mettre
a l'aise avec l'unpacking !! (pour des imports table: lisez tut sur cdilla)
Vous pourez donc patcher le programme comme si il etait normal :)
On a besoin de:
- Soft ice 3.x or 4
- Procdump 1.5 (seulement pour dumper)
Premiere partie: le loader!
Vous devrez utiliser le loader de SI pour decompacter, donc exécutez le!
et choisissez l'exe que vous voulez!
Pour nous, ce sera : Konix.exe.
Ok, executez le avec le loader mais le probleme c'est que cette
application ne veut pas s'interrompre... :(
hehe, no problem!, executez Proc Dump et utilisez un editeur PE!
Editez la section du Code de l'executable.
(PE editor: choisissez le fichier, sections, CODE et bouton droit "EDIT SECTION")
ok, vous voyez dans section caracteristic : C0000040
ok , changez le en : E0000020
Pour des questions a propos de ce geste , lisez les infos plus haut sur les
caracteristiques des sections !!
Maintenant, executez le Loader de SI et ca marche! :))
super , ca a marche hehe
deuxieme partie: tracer et dumper le fichier de la memoire vers le disque!
Ok, donc vous avez tout juste arrete l'execution ds SI, vous voyez naturellement
les INVALID mais ca ne pose pas de probleme. Tracez avec F10 et vous
arrivez ici:
XXXXXXXX PUSHAD <-- interessant...
XXXXXXXX CALL 45A006
XXXXXXXX POP EBP
XXXXXXXX SUB EBP,43D93E
............
XXXXXXXX CALL 0045A051
XXXXXXXX CALL 0045A2B2
XXXXXXXX CALL 0045A350
............
XXXXXXXX POPAD <-- Tres interessant ca !!!
XXXXXXXX JMP EAX <-- Arretez de tracer ici !! ca saute vers le programme decrypter!
.......
Donc... quand vous decompactez vous voyez un POPAD et un JMP, regardez celui
qui jump vers un registre comme EAX,ECX, EDX...
mais le plus souvent c'est EAX!
Ok, donc quand vous etes au niveau du JMP EAX, regardez la valeur de EAX et
ecrivez la sur un bout de papier: pour moi c'etait: 43F0A0.
Vous l'utiliserez sous peu croyez moi!! hehe
Pour savoir si vous etes a la bonne place, essayer de tracer avec F10 une
fois et regardez si il jump vers la vrai entree du programme.
Pour nous , il l'a fait, alors c ok!
Maintenant, sortez de SI et reexecutez l'EXE avec le loader de SI.
Et tracez jusqu'au JMP.
Maintenant, tapez :
A {enter} <== pour assembler le code
JMP EIP {enter} <== c'est pour faire une boucle infine sans avoir a dumper n'importe quoi
{escape}
F5
Maintenant le programme est entrain de faire une boucle infinie en memoire
et on peut le dumper!!!
Ok, executez ProcDump et vous voyez dans la liste les taches en cours.
Clickez sur celle contenant Konix.exe. Maintenant douton droit et choisissez
FULL DUMP. Savez le nouveau EXE avec le nom que vous voulez.
ex: KonixDumped.exe
Maintenant, cliquez avec le bouton droit comme tout a l'heure mais
choisissez KILL TASK au lieu de FULL DUMP sinon le programme
continuerait sa boucle infinie!
Troisieme partie: Fixer le point d'entree du programme!
Ok, regardez le nouvel EXE que l'on vient de dumper et vous voyez
que sa taille est plus grande que celle di fichier crypté... bien! :)
Mais attendez! si vous l'executez le prog va crasher comme un chien! :(
ok... vous vous souvenez vous avez note le OEP (Original Entry Point) sur
un papier, cette valeur que vous avez trouver dans EAX.
Dans ce cas, c'etait 43F0A0. Ok executez ProcDump PE Editor et changez
le point d'entre en 0x0003F0A0. (OEP - the image base : 43F0A0-400000=3F0A0)
Quand je disais que ce nombre allait nous aider!! hehe
maintenant, fermez procdump , et le programme compacte/crypte
CA MARCHE!!!!!!!!!!!!!!!!!!!!
desassemblez le !! et oui on voit les strings data references !!! cool
on peut donc patcher et tout et tout :)
Voila pour aspack!! maintenant que vous etes deja plus families avec l'unpacking
on continu avec un cour sur armadillo!!
Protection commercial avec anti debugging =)
Nous allons voir comment kicker cette merde de l'exe :)
**********************************************************************
**** Unpacker un executable protegé par Armadillo v1.76 *****
**********************************************************************
tout d'abord voici une description d'armadillo trouve sur leur site officiel:
-------------------------------------------------------------------------------------------
Armadillo is a powerful software protection system. It wraps around your program like an
armored shell, defending your work from pirates and program crackers with state-of-the-art
encryption, data compression, and other security features. It also allows you to add a
complete software protection and registration-key system to your existing programs in five
minutes or less, with no changes to your program's code! And it works with any language
that produces a 32-bit Windows EXE file.
.....
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.
-------------------------------------------------------------------------------------------
ca a l'air cool ;P (du moin ca avait l'air heheheh)
0)Introduction:
Bon, en passant sur le site officiel ou on peut donwloader la version shareware
d'Armadillo , j'ai vus toutes les options possibles de ce petit truc et je me suis
dis que j'allais voir ca d'un peu plus pres...
Donc, apres l'avoir installe , j'ai pris calc.exe et je l'ai crypter avec les options par
defaults, pour voir un peut la bete ;p
1)Lancer l'executable avec Soft ice charge:
Comme vous pouvez vous en douter , les executables proteges disposent d'un anti soft-ice
Il y a en fait 3 detections :
- la premiere est tres connu meltice.(Createfila \\.\SICE, \\.\NTICE and \\.\SIWDEBUG)
- la seconde est connu sous le nom de:IsDebuggerPresent. on trouve l'appel a l'API
getprocaddress.
- et pour finir , c un petit int 3h :p
Comment bypasser toutes ce conneries ??
il va falloire lancer l'executable avec le loader de soft ice.Donc charger le fichier
avec le loader , et lancer le calc.exe.
Soft ice doit revenir et vous devez surement voir des petits: INVALID
A ce moment la , mettez votre BPX Createfilea. pressez F5 3 fois et vous arrivez sur les
checks , qui ressemblent a ca:
025F:10003895 FF1520A00010 CALL [KERNEL32!CreateFileA]
025F:1000389B 83F8FF CMP EAX,-01
025F:1000389E 7409 JZ 100038A9 <-- ici changer le en jmp 100038A9
025F:100038A0 50 PUSH EAX
025F:100038A1 FF1538A00010 CALL [KERNEL32!CloseHandle]
025F:100038A7 EB0B JMP 100038B4
025F:100038A9 FF1544A00010 CALL [KERNEL32!GetLastError]
025F:100038AF 83F802 CMP EAX,02
025F:100038B2 7404 JZ 100038B8
025F:100038B4 C645FF01 MOV BYTE PTR [EBP-01],01
025F:100038B8 8B4604 MOV EAX,[ESI+04]
il faut changer le JZ 100038A9 en JMP 100038A9
pour cela il suffit de se position a la ligne du JZ , et ensuite tapez sous soft ice:
A "presser entrer"
JMP 100038A9 "presser entre"
"presser echap"
et voila , la ligne est devnu un jump , maintenat on trace avec F10 , et on execute le
CALL [KERNEL32!GetLastError] , apres l'avoir passe on voit un CMP EAX,2.
En gros il faut que EAX = 2 pour que tous soit OK , sinon c pas bon..
regardez dans EAX , vous verrez EAX = 2 donc c bon.
Pressez F5 , on retrouve la meme chose , comparaison EAX , 2 , c'est toujours bon donc
tous est OK.
On presse une dernier fois F5 pour le dernier check , mais cette fois au moment du
CMP EAX,2 on voit EAX = 32. Ce n'est donc pas bon , il faut mettre EAX a 2.
pour cela dans soft ice , tapes: R EAX 2
et voila EAX passe a 2 , la comparaison EAX a 2 est donc bonne , tous est OK.
Une fois ceci fait , on va s'occuper du 2eme check de soft ice.Il se sert de
GetProcAddress , Donc mettez un breakpoint dessus , et pressez F5.
il suffit de presser une fois F12 pour sortir du call , et vous devez rencontrer
quelque chose comme ca:
025F:XXXXXXXX XXXXXXXXXXXX CALL [KERNEL32!GetProcAddress]
025F:100038ED 3BC3 CMP EAX,EBX
025F:100038EF 740A JZ 100038FB <--- faites un R FL Z
025F:100038F1 FFD0 CALL EAX
025F:100038F3 85C0 TEST EAX,EAX
025F:100038F5 7404 JZ 100038FB
025F:100038F7 C645FF01 MOV BYTE PTR [EBP-01],01
025F:100038FB 56 PUSH ESI
025F:100038FC FF1548A00010 CALL [KERNEL32!FreeLibrary]
Vous voyez surement CMP EAX,EBX et le saut conditionel juste apres.Ici il faut
inverser le Zero Flag et le programme va pourvoir s'executer normallement...
pour inverser le zero flag , i l suffit de taper: R FL Z sous soft ice une fois
que vous etes a la bonne ligne.
A partir de maintenant , il suffit de tracer avec F10 , commet un fou , et nous
allons voir le fameux int3h arriver ;)
Mais avant , etant donner que la version que j'ai utiliser de armadillo n'est pas
enregistrer (pas encore ;p ) nous allons voir une messagebox qui nous le rappel
Donc cliquez sur le boutton OK , et continuez a tracer..
Cette nag screen est tres simple a cracker , il suffit de mettre un ret dans le call
et c'est finis , mais nous allons virer tous cette merde du fichier executable, donc
en s'en tape !
Mais , je ne peus m'empecher de faire un petite remarque:
-------Remarque:-----------------------------------------------------------------------------
Comme vous l'avez surement remarque, il est possbile de proteger l'exe avec un
name / serial au demarage , ce qui peut etre assez chiant a virer , car nous voulons
executer le programme en memoire...
Je vous racontes ca , car le fichier que nous sommes en train d'etudier ne comporte
pas de name/ serial , j'ai packe le fichier avec les options de bases, mais en voulant
cracker le nag screen, je me suis tromper de call , je suis entre dans le mauvais
et j'ai mis un RET , sur un push EDI , il me semble, bref la premiere instruction.
ensuite , je suis sortis automatiquement du call (RET) et j'ai trace avec F10.
Tous a coup, une dialog box est apparu me demandant un name / serial !!
what the fuck ? c quoi ce bordel, cet armadillo me semble bizzare , mais vraiment!!
il semblerait que quoi que l'on fasse , l'exe contient la verification nom et code.
Il me semble bizzare , mais j'en conclus que ca doit hyper simple a virer , juste un call
a modifier , pour ne pas afficher ca , et on se retrouverais avec un exe crypter de
base...
Je n'ai pas eu le temps de bien regarder , mais ca peut etre inressant.
Tous me pousse a dire que ces protections dites commerciales sont vraiment stupides...
-------Fin des Remarques:---------------------------------------------------------------------
Bref, revenons a nos moutons , hehe
on continue donc de tracer avec F10 s'en reflechir , il faut juste controler le code
on cherche un "int3".
Apres avoir tracer, on trouve ceci:
025F:00402241 2401 AND AL,01
025F:00402243 8885B8FEFFFF MOV [EBP-0148],AL
025F:00402249 BA6D447546 MOV EDX,4675446D
025F:0040224E 8995B0FEFFFF MOV [EBP-0150],EDX
025F:00402254 C785C4FEFFFF260C3604MOV DWORD PTR [EBP-013C],04360C26
025F:0040225E 895DFC MOV [EBP-04],EBX
025F:00402261 8B85C4FEFFFF MOV EAX,[EBP-013C]
025F:00402267 3385B0FEFFFF XOR EAX,[EBP-0150]
025F:0040226D 8BE8 MOV EBP,EAX
025F:0040226F B804000000 MOV EAX,00000004
025F:00402274 CC INT 3 <----- le chtit
025F:00402275 3115148D4000 XOR [00408D14],EDX
025F:0040227B A180804000 MOV EAX,[00408080]
025F:00402280 310584804000 XOR [00408084],EAX
025F:00402286 834DFCFF OR DWORD PTR [EBP-04],-01
025F:0040228A EB18 JMP 004022A4
La protection est vraiment semblable a la 1.73. les Gas de chez armadillo se sont
pas trop fouler pour une protection sois disant Tres fiables.
Bref, vous avez surement remarque le "MOV EAX, 00000004"
Pour passer ce control , il suffit de se mettre a la ligne du MOV.
dans soft ice , tapez:
A "entrer"
JMP 0 "entrer"
"echap"
voila , nous venons de remplacer le mov eax,4 en un jmp 0.
Ceci va provoquer une exception et le programme va croire que le debugger (soft ice)
n'est pas charge , donc ce qui va s'occuper de l'execption et le programme se lance!!
Nous avons donc calc.exe charge , on peut s'en serire normalement.
2)Virer completement Armadillo de l'executable proteger:
A) recuperer et dumper ce que nous avons besoin:
C'est cette partie qui m'a poser le plus de prob , car j'avais une erreur au moment
de reconstruire un executable valide ;(
J'ai recommence plusieurs fois , et voila comment je me suis pris.
(Ayant demander de l'aider sur le forum de l'ATP team , j'ai donc lus leur cour , ma
methode semble etre celle qu'utilise Alsindor, mais Artex utilise une approche
different , donc je vous recommande de lire leur superbe cour sur MP3Wizard V1.2 par
Psyché, Artex et Alsindor... J'ai trouver mon erreur de toute facon , je n'utilisais
pas la bonne taille de section ".text". Leur cour est base sur armadillo 1.0 je crois)
Donc, vous avez votre programme qui est lance, si vous regardez dans le repertoire
courant (ou a etre lance le fichier exe , on trouve un fichier temporaire)
Copier 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 une fichier executable sur le disque , c'est le dump , et nous
avons encore le fichier temp recuperé dans le repertoire ou a ete lance le programme
crypte.
B)Faire un executable qui marche , et qui n'a plus de armadillo ;)
si vous renommer le fichier temporaire en executable et que vous l'executer il va crasher!
C normal car dans la premiere Section , on se rend compte qu'elle est pleine de "XX"
hmm , si on lance le fichier dumper, il ne marche pas non plus et crash comme un goret ;)
GogogadgetauProcdump lol , vous l'avez compris lancez procdump et servez vous du PE editor
pour editer le fichier dump, vous devez voir les sections du fichier.il faut regarder
la premiere !
Pour ma part , j'avais ceci:
- pour la section ".text" :
Virtual Offset: 00001000
Raw Size: 11A0E
Raw Offset: 1000
ok , gardez ces chiffres en tete nous allons y revenir!!
avec procdump , click droit sur la section "text" et faites saves to file pour dumper
le fichier dur le disque ! (exemple: text.bin).Car cette section est completement decrypter
tandis que le fichier temporaire contient des XX.En effet armadillo re "ecris" la section
a la vollée ..
Une fois le fichier dumpé sur le disque, ouvrez votre fichier exe (le fichier Temp renomé)
avec un editeur hexadecimal , j'utilise hexworkshop pour cela.ouvez egalement la section
que vous avez dumper
Maintenant dans hexworkshop , pressez alt+f5 , entrez le Raw offset de la section
que vous voulez importer. ici : 1000 et cliquer sur ok. Allez dans le menu Edit, et cliquer
sur "select block" entrez la longeur (size) de la section , ici : 11A0E...
Regardez le fichier ouvert (text.bin) et pressez 'ctrl+a' pour tout selectioner..
copiez tout ca avec 'ctrl+c'.
Retournez dans la fenetre principal de l'executable dans hexworkshop (celui que vous avez
renomme l'ex fichier temporaire donc), et coller ce que vous venez de copier dans le
press papier , faites: 'ctrl+v' ou menu Edit et paste.
Enregistrez votre fichier, et vous avez maintenant une section '.text' valable qui ne
contient donc plus de "XX" hehe...
Lancez votre executable et oh !! miracle cela marche !!
Mais pour etre sur que le fichier marche bien , on peut reconstruire le pe avec Procdump
cela ne coute rien de toutes maniers :
-Lancez Procdump (Merci G-RoM :)
allez dans les Options et selecttioner:
[X]Recompute Object Size
[X]Optmize PE Structure
[X] Use actual import infos
et cliquer sur OK
Cliquer sur Rebuild PE , et cherchez notre nouveau fichier (calc_finis.exe pour nous)
Procdump nous fais une valide import table et notre executable est desorme plus sure ;o)
Voila !! j'ai d'ailleurs programme un unpacker avec un pote pour Armadillo
Il sera disponible sur mon site d'ici quelque temps !! (qd j'aurais le gout lol)
Notes supplementaires sur les PACKERS:
Pour unpacker neolite , c'est vraiment tres ressemblant avec Aspack !!
Donc tracez et cherchez pour un JMP EAX (si mes souvenirs sont bons !!!)
Bref rien de bien dure, ca s'unpack les doights dans le nez ;-D
hihihihihi! donc pour UPX !!
UPX utilise un JUMP fixe (JUMP 401000) il suffit de le trouver et de dumper
je ne vais pas ecrire des cours sur tout les packers lol !!
Il existe deja pas mal de cour sur l'unpacking sur le net si vraiment cela ne vous
suffisez pas!!
Time Limits (limitation de 30 jours et autres merdes !!)
Comme vous l'avez surement remarque , il existe des programmes
qui ne sont pas enregistrables car il n'y pas moyen de s'enregister !!
Ils sont en generals limites a 30 jours!!
C'est ce qu'on appele: Time limit protection !!! Comment cracker ca ?
il y a plusieurs facon !! nous allons voir ca dessuite !!
Methode avec Wdasm:
Vous avez un programme nomme X , qui apres 30 jours ne marche plus :(
Mais en revenche , il nous envoit une messagebox disans:
"La periode d'evaluation est terminee..." ou "Trial version expirer..."
Bref ce genre de conneries !!
Alors si vous avez ca , vous lancez Wdasm et desassembler le fichier a cracker
Vous cherchez cette phrase dans les string data references et une fois
que vous avez trouvez, double clickez dessus a fin d'aller a la place
de cette phrase dans Wdasm !!
et maintenant ?? ben on etudit le code aux alentours !! ca ne vas etre
bien dur !!
generalement vous devriez trouve au dessus du message d'erreur des sauts
conditionels de type JL , JLE, JG, JGE .....
par exemple:
CMP DWORD PTR EAX, 1E <-- 1Eh = 30 en decimal (30 jours!)
JLE 00405840 <-- jump au programme si c'est egal ou inferieur a 30 jours
ici on voit qu'il compare le nombre de jours ecoules avec 30!
Tant que c'est inferieur ou egale a 30 jours le programme marchera !!
mais une fois depasse les 30 jours !! ca marche plus :(
Donc pour cracker ca on force le programme a sauter quoi qu'il arrive en changeant
le JLE en JMP !! et le programme sautera inconditionellement comme si de rien n'etais!
il croira tjs que l'on est encore dans la periode des 30 jours heheh !!
Avec Soft ice:
tout d'abord regardons les API utilises dans les time limites!! :
(eq: win32API.hlp)
je ne traduirais pas , pour ne pas deteriorer les infos donnees.
********************************************************************************************
* 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.
********************************************************************************************
voila !! donc ca c'etait les API les plus courement utilises dans les protections
par time limites!
Cependant , l'API la plus souvent utilisee est : Getlocaltime
donc vous mettez un Bpx dessus et vous lancez le programme !
Soft ice break ! pressez F12 pour arrivez au bon endroit dans le programme et commencer
a tracer !!
si vous voyez un saut de type: JL , JLE , JGE , JG vous savez ce qu'il vous
reste a faire !!
Je ne vais pas ecrire des tonnes encore sur cettre protection aussi stupide que
simple a cracker !!
Vous trouvez un exemple de Time limite mais dans la partie Visual basic!!
comment cracker un programme VB avec Wdasm orignial !! ;-)
l33t hehe
sinon , j'espere que vous voyez comment cracker ca maintenant ......
JAVA REVERSE ENGINEERING
Cracker du java peut etre extremement facile a condition d'avoir un decompileur
je vais donc vous montrez comme quoi reverse du java , ca peut tres simple !
il existe des protections java beaucoup plus dure bien sur , mais c'est juste une
Approche sur le reverse du java !!
on a besoin de:
- JAD (java decompiler)
- rien de plus :)
URLS:
www.lawrencegoetz.com/ (Trucs a cracker)
http://www.acidburn2000.com (le decompiler java)
Dans ce cour nous allons cracker 3 choses: Goetz's Banner V 2.0 , Goetz's Marquee 1.1,
et ManKind java crackme !
Let's kick some ass !
dézipez l'archive de Goetz's Banner V 2.0 dans un repertoire quelquonque.vous devez voir
des fichiers de type .class et html en autres!
Lancez the fichier d'exmple exemple.html), et vouz verrez l'effet de banniere sur ce
petit truc en java ! Mais un Putain de UNREGISTERED a la con pointe son nez hehe Doh!
Donc, les fichiers java sont de type: .class.Apres avoir recuperé le decompileur java
sur mon site, et l'avoir place dans le repertoire ou vous venez de dezipper ces applets
deplacez le fichier .class sur le decompiler (jad.exe) pour qu'il le decompile!!
Mais , il est preferable de faire un fichier Bat , pour definir le chemin de destination
du fichier decompilé , car il peut se retrouver dans le repertoire de windows par exemple!
Bref, une vois que vous l'avez (les fichiers decompiles portent l'extension ".jad")
editez le avec un editeur de textes, et vous devriez voir qq chose comme ca:
--------------------------------------gbanner.JAD------------------------------------------
// Decompiled by Jad v1.5.7. Copyright 1997-99 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3)
// Source File Name: gbanner.java
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 class gbanner extends Applet
implements Runnable
{
public boolean mouseEnter(Event event, int i, int j)
{
if(info[place] != null && displaying)
getAppletContext().showStatus(info[place]);
mouseInside = true;
return true;
}
public void stop()
{
running = false;
if(animate != null)
{
animate.stop();
animate = null;
}
}
public gbanner()
{
m_background = "white";
test_it = "";
drawn = true;
zoom = true;
pausable = true;
m_target = "_self";
}
public boolean mouseExit(Event event, int i, int j)
{
mouseInside = false;
getAppletContext().showStatus("");
return true;
}
public void paint(Graphics g)
{
if(drawable)
{
g.drawImage(offImage, 0, 0, this);
place = loadImage;
}
drawn = true;
}
public String[][] getParameterInfo()
{
String as[][] = {
{
"image", "String", "lineN where N is the line number"
}, {
"background", "String", "Background color"
}, {
"URL", "String", "URLN where N is the URL for the image N."
}, {
"target", "String", "Target of URL"
}, {
"info", "String", "infoN where N is the infomation for the image N."
}, {
"pause", "String", "pauseN where N is the pause time for the image N."
}, {
"zoom", "String", "Zoom the images or not."
}, {
"shuffle", "String", "Shuffle the images or not."
}, {
"pauseable", "String", "Pause the applet when the mouse is in it."
}, {
"one", "String", "Display only one image. Good for use with shuffle to display one random image."
}
};
return as;
}
public void destroy()
{
running = false;
if(animate != null)
{
animate.stop();
animate = null;
}
}
public int[] shuffle()
{
Vector vector = new Vector();
int ai[] = new int[amount];
for(int j = 0; j < amount; j++)
vector.addElement(new Integer(j));
for(int k = 0; k < amount; k++)
{
int i = (int)(Math.random() * (double)(amount - k));
Integer integer = (Integer)vector.elementAt(i);
ai[k] = integer.intValue();
vector.removeElementAt(i);
}
return ai;
}
public void update(Graphics g)
{
paint(g);
}
public void start()
{
place = 0;
if(offImage == null)
{
offImage = createImage(d.width, d.height);
offGraphics = offImage.getGraphics();
}
try
{
myInfo = new URL(getDocumentBase(), "gboption.ini");
}
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"))
good = true;
running = true;
if(animate == null)
{
animate = new Thread(this);
animate.start();
}
}
public String getAppletInfo()
{
return "Title: Goetz's Banner\r\n" + "Author: Lawrence Goetz\r\n" + "E-mail: goetz@lawrencegoetz.com\r\n" + "Web: http://www.lawrencegoetz.com/\r\n" + "Copyright Lawrence Goetz 1998";
}
public boolean mouseDown(Event event, int i, int j)
{
if(locations[place] != null && displaying)
getAppletContext().showDocument(locations[place], m_target);
return true;
}
public void run()
{
int i = 20;
int ai[] = null;
if(shuffle)
ai = shuffle();
int j1 = 0;
if(!shuffle)
loadImage = j1;
setMyColor(offGraphics, "blue");
offGraphics.fillRect(0, 5, 110, 20);
setMyColor(offGraphics, "yellow");
offGraphics.drawString("Loading Image", 5, 20);
drawable = true;
repaint();
try
{
Thread.sleep(100L);
}
catch(InterruptedException _ex) { }
Thread.yield();
images = new Image[amount];
while(running)
{
while(!drawn)
try
{
Thread.sleep(10L);
}
catch(InterruptedException _ex) { }
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) { }
while(one && running)
{
drawable = true;
repaint();
try
{
Thread.sleep(100L);
}
catch(InterruptedException _ex) { }
}
if(++j1 == images.length)
{
j1 = 0;
if(shuffle)
ai = shuffle();
}
}
Thread.yield();
}
}
public void init()
{
int i = 1;
String s4 = "image" + Integer.toString(i);
for(String s = getParameter(s4); s != null; s = getParameter(s4))
{
amount++;
i++;
s4 = "image" + Integer.toString(i);
}
locations = new URL[amount];
for(int j = 0; j < amount; j++)
{
String s1 = getParameter("URL" + Integer.toString(j + 1));
if(s1 != null)
{
try
{
locations[j] = new URL(getDocumentBase(), s1);
}
catch(MalformedURLException _ex) { }
}
else
{
String s2 = getParameter("URL");
try
{
locations[j] = new URL(getDocumentBase(), s2);
}
catch(MalformedURLException _ex) { }
}
}
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");
}
pause = new int[amount];
for(int l = 0; l < amount; l++)
{
String s6 = getParameter("pause" + Integer.toString(l + 1));
if(s6 != null && !s6.equals(""))
{
pause[l] = Integer.parseInt(s6);
}
else
{
String s7 = getParameter("pause");
if(s7 != null && !s7.equals(""))
pause[l] = Integer.parseInt(s7);
}
}
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);
}
public void setMyColor(Graphics g, String s)
{
if(s.equals("white"))
{
g.setColor(Color.white);
return;
}
if(s.equals("black"))
{
g.setColor(Color.black);
return;
}
if(s.equals("light gray"))
{
g.setColor(Color.lightGray);
return;
}
if(s.equals("gray"))
{
g.setColor(Color.gray);
return;
}
if(s.equals("dark gray"))
{
g.setColor(Color.darkGray);
return;
}
if(s.equals("red"))
{
g.setColor(Color.red);
return;
}
if(s.equals("pink"))
{
g.setColor(Color.pink);
return;
}
if(s.equals("orange"))
{
g.setColor(Color.orange);
return;
}
if(s.equals("yellow"))
{
g.setColor(Color.yellow);
return;
}
if(s.equals("green"))
{
g.setColor(Color.green);
return;
}
if(s.equals("magenta"))
{
g.setColor(Color.magenta);
return;
}
if(s.equals("cyan"))
{
g.setColor(Color.cyan);
return;
}
if(s.equals("blue"))
g.setColor(Color.blue);
}
private String m_background;
private final String PARAM_imageN = "image";
private final String PARAM_background = "background";
private final String PARAM_URLN = "URL";
private final String PARAM_infoN = "info";
private final String PARAM_pauseN = "pause";
private final String PARAM_zoom = "zoom";
private final String PARAM_shuffle = "shuffle";
private final String PARAM_target = "target";
private final String PARAM_pausable = "pauseable";
private final String PARAM_one = "one";
private Dimension d;
private boolean running;
private Image images[];
private int place;
private Image offImage;
private Graphics offGraphics;
private boolean good;
private URL locations[];
private URL myInfo;
private String test_it;
private final String option = "InFeb";
private InputStream input;
private DataInputStream dataInput;
private Thread animate;
private boolean drawable;
private boolean drawn;
private MediaTracker imageTracker;
private int image_w;
private int image_h;
private String info[];
private int pause[];
private int amount;
private boolean zoom;
private boolean shuffle;
private boolean pausable;
private String m_target;
private int loadImage;
private boolean displaying;
private boolean mouseInside;
private boolean one;
}
-------------------------------------------End of jad file---------------------------------
ok balaise huh ?
Donc pour les prochains fichier, je vous montrerez que les parties importantes!
Donc, vous avez jetez un oeil a la source si dessus, et vous avez (j'espere ;p) reperé la
protection ! un petit keyfile a la mort moi le noeud :p *grin*
Donc, on cherche qq chose qui ressemble a un controle 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)
w0w , ca craint! creez un fichier nommé gboption.ini et mettez 'InFeb' dedans!!
(sans les ' ' biensur), enregistrez ce fichier , copier le dans le repertoire de l'applet
et lancez le fichier exemple.hml!
Kewl !! voila le Putain D'UNREGISTERED texte a mouru lol :)
Facile non ??
Part2: Goetz's Marquee V 1.1
Toujours la meme chose! Keyfile based protection
Decompile fichier class et ouvre le avec notepad par exemple !
je vous montre les parties importantes seulement, car c'est exactement la meme merde!
-------------------------------------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)
-----------------------------End of quotes from marquee.jad---------------------------------
Encore , creez un fichier nommé gmoption.ini et mettez 'Eggplant' dedans !
(sans les ' ' ) Enregistrez les fichiers , et lancez le fichier d'exemple!
et voila , plus de mechant Texte hehe !
C'est maintenant enregistré et vous pouvez apprecier ce petit applet java :p
Ok, assez avec ces conneries de keyfile a la mort moi le noeud , regardons ce petit crackme
coder par notre ami MandKind en java!
il n'y a aucun fichier html fournis pour tester le serial , mais on en a pas besoin hehe!!
Ph43R !!
Comme d'hab , decompilez le fichier class , et ouvrez le avec notepad !!
On peut voir cette merde:
---------------------------------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-------------------------------------------
hehe, ca a l'air marrant!
nous voyons:
" 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(""); "
En visual basic ca donerait ceci:
IF serial= $7f42b then
msgbox "Congratulations, you succeeded in cracking this!"
Else
msgbox "Sorry, invalid registration code. Please try again!"
End if
"0x7f42b" est en hexadecimal (0x nous le montre) mais nous voulons le bon serial donc on
le convertit en decimal! si vous avez soft ice chargé:
Ctrl+d
? 7b42b
on voit donc: 521259
FACILE non ??
Bon, je n'ai plus d'autre fichier proteger en java, donc je m'en vais finir ce tut :-(
j'espere que le reversion du java est plus claire mainteneant pour vous !!
c'est quelque chose de tres simple les 3/4 du temps :
biensur , c'est grace au decompileur !!
Visual Basic
Bon je vais vous montrez une paires 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 faires ...
Tout abord:
*********************************************
*** Configurer Smart Check ***
*********************************************
Qu'est-ce que smart check ?
c'est un programme qui permet de debugger les programmes ecrit en VB
et il est tres utile en cracking!!
Mais il doit etre configure corectement sinon ca marche pas !
A configurer il suffit juste de cocher quelques cases et apres c parti
pour l'eclate lol !! :)
voici comment le configurer smart check
Dans le menu Program Settings:
- Error Detection: cocher toutes les cases excepter "Report errors immediately".
- Advanced: cocher les 4 premiere cases.
Mais surtout pas cocher "Suppress system API and OLE calls" is not "ticked"
- Reporting: selectioner toutes les cases excepter "Report MouseMove events from OCX controls".
Ensuite dans le menu View, il faut que "argument" soit selectioner ainsi que "suppressed error"
Voila , maintenant vous allez pourvoir lire la suite du cour !
Mais pour vois aider , je vais vous decrire quelque fonction VB que vous rencontrez souvent
en Visual basic !
Fonctions importantes:
* __vbasrtcmp(String:"XXXX",String:"YYYY")returns DWORD:0
Description:
__vbastrcmp est utilise pour comparer des "Strings" comme "XXXX" and "YYYY"
Si vous recontrez ca , et que XXXX = votre faux numero de serie il y a de fortes chances
pour 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" a 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 utilise pour ajouter des strings ensemble, ceux 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 utilise pour comparer des strings aussi !!
regardez pour __vbastrcomp , le principe est le meme !
il existe aussi: __vbaVarCmpEq
* Len(String:"ACiD BuRN") returns LONG:9
Description:
la function len sert a recuperer la longeur d'un string! ici "ACiD BuRN" a pour longeur 9
(9 lettres , l'espace compte aussi)
Les opartions de bases tres souvent utilises (keygen) :
* __vbaVarAdd(VARIANT:Integer:10, VARIANT:Integer:15) returns .... (25)
Description:
Additione 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 a 100 , cela donne: 98
* __vbaVarXor
Description:
il marche sur le meme principe.. il effectue un XOR entre les valeurs
* MsgBox(VARIANT:String:"She owns Me", Integer:0, VARIANT:String:"Love",VARIANT.....)
Description:
Sert a affichier 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
Methode tres utilise pour trouver les serials:
Vous avez entrez un numero a la con , et le programme vous a envoye chier avec un
messagebox !
Comment trouver le serial rapidement dans Beaucoup de cas ??!
Facile , il vous suffit d'aller a la ligne ou on voit cette messageBox et de cliker dessus
Ensuite clicker sur: Show all events et la on voit BCP BCP plus d'informations qu'avant
on descends un peu et on trouve qq chose comme ca:
__vbasrtcmp(String:"112233",String:"Oui_mec_c'est_le_serial")returns DWORD:0
on voit tres bien que le programme compare "112233" avec le bon serial!
vous prenez ce que vous trouvez a la place de "Oui_mec_c'est_le_serial"!
exemple: "AC4VA4EV"
Relancez le programme et entrez ca comme serial : AC4VA4EV
Boom Registered!!
Easy, isn't it ?
Pour des choses plus complexes , lisez la suite!
***************
*VB PATCHING: *
***************
EscapeRC v1.0.1
Description : a VB5 Time_Limit!
tools used : - Wdasm89 (version de base non patché pour le VB)
- hexeditor!
Comme vous pouvez le voir, j'utilise Wdasm pour du vb !! et meme pas soft ice
ou Smart check !
Comme c'est la version non patche de Wdasm , 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 apres avoir avance la date du PC en 2001 par exemple..
Boom, on voit une messagebox qui nous dis: Trial period is over, blablabla
ok , mais les progs en VB n'utilise 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 tres bien utilise soft ice , mais on veut aussi inover un peu !! et se servir
de Wdasm ;)
Lancez Wdasm , et ouvrez le fichier avec ! (EscapeRC.exe)...
Allez dans les imports et cherchez : rtcmsgbox
Clickez 2 fois car la premiere ne contient rien de bien important :)
vouz verrez ceci:
* Reference To: MSVBVM50.rtcMsgBox, Ord:0253h
scroll up and you see :
* 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 apres le click
------------------------------------------------------------------------------------
Donc vous avez vu : Referenced at 0041FA39
Dans Wdasm, 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 deci)
:0041FA39 0F8D45010000 jnl 0041FB84 <== un saut saut conditionel :)
: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 va donc qu'a patcher ce truc :)
Pour etre sur de ne pas avoir d'ennuie j'ai patche en:
:0041FA34 66837DEC00 cmp word ptr [ebp-14], 00
:0041FA39 0F8445010000 je 0041FB84
editez le fichier avec voctre editeur hexa:
- cherchez : 66837DEC1F et remplacez par : 66837DEC00.
- cherchez : 0F8D45010000 et remplacez par : 0F8445010000
WOW !! Plus de prob de temps :pp facile .........
Voila , vous avez une idee de comment patcher les progs en VB, avec Wdasm :)
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'etais entrain de tracer avec SI quand j'ai eu une
idée...
Je vais vous expliquer en quoi ca consiste...
1)tools required : - Smart-check 6
- Hex editor
- un cerveau =)
2)comment cracker les nags !!
Bon pour cela on utilisera SC !
Chargez Oyc avec SC et executez le. Clicker sur le nag, attendez
que le boutton OK soit active et ensuite quittez cette app...
Dans SC double clicker sur : frmOYCMain_load et regardez jusqu'à
ce que vous trouviez le ".show" ... dans SC vous verez:
+ 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 ou il est situe et le fichier.
Pour ce nag, nous voyons qu'il est dans OYC.EXE @ 000FDA4D
Ok!
Je suppose que vous pensez qu'est ce que je voulais vous montrer !!!
Maintenant j'utilise mon cerveau pour virer le nag, parce que je sais
que le nag peut etre appele par un call, donc je pense pourquoi n'irions
nous pas a cet offset et regarde le premier call pres de la?
Prenez votre HEXEDITEUR et allez a l'offset 000FDA4D.
Ok, maintenant vous savez que ce call commence avec : E8h et sa
longueur est de 5 octets...
Apres 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 reexecutez le programme...
Comme par magie le premier Nag a ete vire!!!!!!!
Bien!! hehe
Maintenant on va passer au suivant!
Vous voyez sur la figure ci dessus qu'il y a un autre ".show"
Procedez de la meme facon et vous virerez ainsi le timer et le nag!!
Je ne vais pas vous montrer la valeur a remplacer parce que c'est
exactement la meme 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
a la fin du rapport de SC)
Ensuite double click sur "frmOYCMain_Unload" and descendez jusqu'à
ce que vous voyez: "frmEnd.Show". Regardez a droite et prenez
l'offset : 1001A1
Ok, maintenant vous vous dites, on va faire pareil qu'avec les deux autres,
et ca va etre ok!
Eh bien non! Ca ne marchera pas!
Ok... j'ai reflechi un peu et je me suis rememore que vous pouvez
chercher un jump pour virer le nag, et dans les apps VB, je jump
toujours comme ca: 0F85 or 0F84 =)
Donc utilisez votre hexediteur et allez a l'offset : 1001A1.
Faites une recherche de "OF" vers le haut. And nous trouvons:
0F849A000000 ... remplacez le par 0F859A000000 (je => jne) et sauvegardez!
Maintenant , executez a nouveau!!
Plus de nag! plus de timelimit!
Parfait!
3)Notes:
J'ai ecris ce tut pour montrer comment on peut patcher les apps VB et que
parfois un cerveau est plus utile que le tracage avec SI (j'ai bien dit : parfois).
Donc, cette facon de cracker les nags VB ne marche pas a tous les coups, mais j'ai
reussi a cracker plusieurs app VB comme ca 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 repertoire du programme et patchez le.
De cette maniere, le prog utilisera la DLL qui est dans son repertoire et pas
celle du WINDOWS\SYSTEM.
Vous n'aurez comme ca pas de probleme 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 controle ce con de crackme ?
tool: Smart check ( Que vous avez bien configure d'apres mon cour )
Si vous lancez ce crackme , vous allez voir ecrit: Welcome
Qd on click sur le bouton check , si ce n'est pas bon le CD , on obtient le
super message: Unregistered
hmmm.. ok
Lancez smart check et ouvre 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 utilise pour determniner le type de disque et renvois 5 si c'est un CD)
Cette API est utilisee pour cracker les CD check sur les jeux ...
Sur mon PC , j'ai vu ca:
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 renvois: 5
Maintenant dans smart check clickez sur "show all events".
Ensuite commencez a scroller vers le bas avec les fleches et regardez dans la fenetre de
droite!
Descendez tant que vous ne verrez pas qq chose qui commence comme ca:
W
..
Wi
..
Win
..
Win9
..
Win98
..
Win98 S
..
Win98 SE
..
hmm ! on dirait qu'il verifie le label de CD hehe
mort de rire , descendons un peu pour voir cela de plus pres:
__vbaStrCmp(String:"Win98 SE", String:") returns DWORD: FFFFFFFF
Kewl! it compare vraiment le label! je n'avais pas mis de CD donc il compare avec rien
ici !
Cher ami dawai , ton VB cd check crackme verifie le label du CD ROM !
Si c'est: Win98 SE Alors c'est correct (windows 98 second edition)
Mais de toutes facon, je me sert tjs de mes jeux sans CD! alors je veux pas avoir de CD
dans le lecteur !
Sux0r :)
II)How to Patch it:
Patcher un prog en visual basic est plutot simple qd on sait comment faire...
Donc clickez sur: __vbaStrCmp(String:"Win98 SE", String:") returns DWORD: FFFFFFFF
prenez l'offset dans la fenetre de droite, on voit: CRACKME2!0000CB68
Lancez wdasm , et clickez sur le menu goto et prenez goto code location...
Additionez 400000 a l'offset et on obtient l'emplacement dans wdasm ! (400000 = image base)
400000 + CB68 = 40CB68
Entrez ca dans Goto Code location
On arrive ici :
* Reference To: MSVBVM60.__vbaStrCmp, Ord:0000h
|
:0040CB68 E89346FFFF Call 00401200 <--- ici!
:0040CB6D 8BF0 mov esi, eax
:0040CB6F 8D4584 lea eax, dword ptr [ebp-7C]
:0040CB72 F7DE neg esi
:0040CB74 50 push eax
:0040CB75 8D4588 lea eax, dword ptr [ebp-78]
:0040CB78 1BF6 sbb esi, esi
:0040CB7A 50 push eax
:0040CB7B 46 inc esi
:0040CB7C 8D458C lea eax, dword ptr [ebp-74]
:0040CB7F F7DE neg esi
:0040CB81 23B534FFFFFF and esi, dword ptr [ebp+FFFFFF34]
:0040CB87 50 push eax
:0040CB88 6A03 push 00000003
* Reference To: MSVBVM60.__vbaFreeStrList, Ord:0000h
|
:0040CB8A E87746FFFF Call 00401206
:0040CB8F 83C410 add esp, 00000010
:0040CB92 663BF3 cmp si, bx
:0040CB95 751F jne 0040CBB6 <-- hmm :) interessant!
:0040CB97 6A02 push 00000002
:0040CB99 5E pop esi
Comme on peut le voir , on voit une petite comparaison et juste en dessous un saut conditionel!
Changeez le jne en jmp !
:0040CB95 751F jne 0040CBB6
devient
:0040CB95 EB1F jmp 0040CBB6
Faites les modification dans le fichier et sauvegardez!
Relancez le crackme et clickez sur le bouton! jezuz :) ca marche heh
REGISTERED
Oh my god , c'etait simple :)
*****************************************************************************************
** Pour finir avec le VB: comment reactiver un Bouton , rendre une fenetre invisible... **
*****************************************************************************************
Boutons:
Pour un boutton on cherche qq chose comme ca dans Smart check:
Command1.Enabled <-- False (Boolean)
clickez dessus et regardez dans la fenetre de droite sous smart check pour recuperer
l'offest , on l'ajoute a l'image base comme j'ai decrit plus haut et on va dans
Wdasm !
on retrouve quelque chose comme ca :
6A00 push 00000000
50 push eax
8945E4 mov dword ptr [ebp-1C], eax
FF928C000000 call dword ptr [edx+0000008C]
on voit le Push 00 (false) et on veut reactiver le bouton donc il faut mettre en (True)
c'est pas push 01 :P , mais push FF
donc on remplace ca en:
6AFF push FFFFFFFF
50 push eax
8945E4 mov dword ptr [ebp-1C], eax
FF928C000000 call dword ptr [edx+0000008C]
on sauvegarde le fichier et hope la , le bouton est enabled !
notes: des fois on trouve pas de: Command1.Enabled
pas encore etudier ce problem yet !
donc on prends the customizer pour ca et on en parle plus :)
cette methode marche pour activer les : boutons donc , les menus, check box , labels
et autres ... :
Command1.Enabled <-- False (Boolean)
Text1.Enabled <-- False (Boolean)
Label1.Visible <-- False (Boolean)
.....
ca marche aussi pour cracker un nag screen!
on click sur le form1.visible .... on prends l'offset et on se rend sur les lieux:)
on examine le code! on doit voir un: Push FFFFFFFFF (enabled) donc visible
On le remplace par un Push 0000000 (disabled) donc invisible ...
Et hope la , finis les problemes de nags screen :)
Bon assez sur le patching en VB sinon on va pas finir hehe
un peu de serial fishing a present et ensuite du keygening ;)
************************************************************************
** Serial Fishing **
************************************************************************
*****************************
*** MIZ CRACKME 2 ***
*****************************
Quelles sont les protections?
Il y a 2 protections dans ce crackme :
1)anti Smart check
2)Serial
1)Comment supprimer la protection anti smart check ?
La protection anti SC est placee au début du crackme
et quand le crackme est execute, il verifie la presence de SC avec un
timer!
Apres avec regarde avec SI si l'anti SC etait base sur la verification
de "NMSCWM50" (l'ID de la fenetre de SC), j'ai regarde
le crackme avec un hexediteur pour cette chaine et je l'ai trouvee.
Mais si vous ne cherchez que NMSCWM50, vous ne trouverez
rien parce que c'est un programme VB qui utilise le format WIDE donc:
w.i.d.e. .c.h.a.r.a.c.t.e.r. .f.o.r.m.a.t
Regardez cette chaine: 4E004D00530043004D005700350030 en hex
Cool! vous l'avez trouver! remplacez par des 0 par exemple et sauvez.
Maintenant la protection anti SC est eliminee!
On peut donc executer SC dessus!
2)trouver le serial !
Executez SC et le prog. entrez un serial: 123456 et pressez
"Check Now" puis sortez du programme.
Retournez dans SC et vous verez un timer et apres:
label3_Click
Mais il n'y a rien de bien ici...
Mais quand j'ai vu GetVolumeInformationA j'ia pense que le serial
depend surement du PC ! on verra ca apres ...
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 ds 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 ds 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'interessant 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.
entrer 123456 comme serial et clickez sur check !
cool on est dans SI!!!
tapez WF pour afficher la fenetre concernant la pile a virgule flottante.
vous voyez:
ST0 empty ST4 empty
ST1 empty ST5 empty
ST2 empty ST6 empty
ST3 empty ST7 empty
Commencez a tracer avec F12 pour aller dans la fonction:__vbaR8str !
Vous devriez voir:: ST0 123456 !!
cool , continuez avec F10 et ST0 devient : 892935893 !!! <== qu'est ce que c'est?
Essayons!! bd * pour desactiver tous les bpx et entrez ce nombre!
Et la message box apparait: Mail the solution to : ...
Cool crackme Cracked !!!
Mais attendez, nous voyons dans SC que ca dependait du PC avec
GetVolumeInformationA !!
Ok, je vais essayer ce nombre sur mon second PC et ca ne marche pas!!!
J'avais donc raison, ce nombre depend de la machine !!
Donc ce nombre ne fonctionnera pas chez vous, essayez de le trouver
c'est un bon moyen de savoir si vous avez tout compris!!!
Avant de passer au keygen pure et dure (plus complique que le premier exemple)
je vais vous montrer 2 facons de recuperer les serials pour les programmes en
VB 5 ou 6 :)
En effet , il existe une API tres souvent utilise dans les controles des serials!
--> __vbastrcomp
nous allons voir cela de plus pres !
*****************************
*** 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 SoftIce!
Tapez ctrl+D
puis
BPX __vbastrcomp
F5
nAME: ACiD BuRN
cODE: 123456
Entrez serial nom et cliquez sur Check !
Nous sommes de retour dans SI grace a la BPX! cool!
Pressez F12 pour sortir du call
vous devriez voir EBP en couleur! c'est bon signe!
tapez maintenant:
dd esp (on examine la pile)
vous devriez voir: aaaaaaaa bbbbbbbb cccccccc dddddddd
essayez de faire:
d aaaaaaaa , et vous ne devriez pas voir des choses interessantes.
donc essayez ca:
d bbbbbbbb , et vous obtenez dans mon cas: Oy!iYt^LK
Ca ressemble a un code! on va l'essayer...
nAME: ACiD BuRN
cODE: Oy!iYt^LK
et ca marche !!!!!!!!
Apres les BPX sur les fonctions courement utilises en VB, voici une autre methode
simple et rapide pour trouver un serial en VB:
**********
*HDMorph *
**********
Il change l'icone du disque dur... c'est pas vraiment utile mais
c'est pas ReGGed!!
On va s'amuse un peu avec!!
Tout d'abord, c'est une bonne idée lorsque vous voulez cracker des programmes
VB de chercher:
S 0 L ffffffff 56,57,8b,7c,24,10,8b,74,24,0c,8b,4c,24,14,33,c0,f3,66,a7
NOTE: le mieux etant de le mettre dans le WINICE.DAT.
Alt F4 etant rarement utilise, vous pouvez l'utiliser comme bon vous semble:
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 vous evitera de tout retaper... Redemarrer le PC pour que les changements prennent effet!
Quand c'est fait on peut commencer a cracker le programme!
Lancez le et allez dans register.
Entrer nAME: ACiD BuRN
sERIAL: 123456
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 fenetre
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 arretes a cause de 25F:7B1DD9EA .
C'est la ou 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... Redemarrez....
Allez dans ABOUT et vous voyez : Registered to: ACiD BuRN
No comment ;)
****************************************************
**** VB KEYGENING: ****
****************************************************
********************************************
*** Eternal Bliss 's Coumouflage Crackme ***
********************************************
Protections : - anti smartcheck
- serial / name
1)anti smartcheck (SC):
Il y a plusieurs façons de détecter si SC est acitvé. Je vais vous donner la plus courante:
Le programme regarde la barre des titres de SC et il trouve:
"NuMega SmartCheck"
Puis se faire tout seul! merde!
La deuxième façon et de regarde l'ID de le fenetre de SC: NMSCVM50
Et si il le trouve alors il se ferme aussi tout seul!
Comment l'eviter?
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 fenetre, 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.
Mais je ne l'ai pas et je vais vous dire comment j'ai fait!
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 SoftIce et vous allez rechercher:
s 0 l ffffffff 'NMSC' (je n'ai pas recherche NMSCWM50... soyez sur que vous trouverez le bon)
tapez S jusqu' a ce que vous trouviez NMSCVM50. La premiere fois que vous le verez, reecrivez
par dessus des 00000000.hehe , le crackme continue son exécution sous SC!!
2) Comment l'enregistrer?
Clicker sur Register et entrez un nom et un serial au hasard genre 123456
and cliquez sur "Check It": vous verez :
Wrong Try again a l'emplacement de votre nom...
Donc ce n'est pas le bon =)!!
Ok. quittez le crackme et retournez dans SC.
D'abord, sauvez votre projet, avec File/Save as...
parce que je pense que vous ne voudrez pas refaire cette premiere partie du tut plusieurs fois!
Vous verez command5_click, double click and regardez cette chose interessante:
Maintenant allez sous SC et regardez votre nom, you verez:
--------------Start of SC cut--------------------------------
Mid(varian:byReF String:"ACiD BuRN",long1,VARIANT:Integer:1)
Asc(string:"A")returns Integer:65
Trim(VARIANT:Integer:34)
Mid(varian:byReF String:"ACiD BuRN",long2,VARIANT:Integer:1)
Asc(string:"C")returns Integer:67
Trim(VARIANT:Integer:32)
Mid(varian:byReF String:"ACiD BuRN",long3,VARIANT:Integer:1)
Asc(string:"i")returns Integer:105
Trim(VARIANT:Integer:10)
Mid(varian:byReF String:"ACiD BuRN",long4,VARIANT:Integer:1)
Asc(string:"D")returns Integer:68
Trim(VARIANT:Integer:39)
Mid(varian:byReF String:"ACiD BuRN",long5,VARIANT:Integer:1)
Asc(string:" ")returns Integer:32
Trim(VARIANT:Integer:67)
Mid(varian:byReF String:"ACiD BuRN",long6,VARIANT:Integer:1)
Asc(string:"B")returns Integer:66
Trim(VARIANT:Integer:33)
Mid(varian:byReF String:"ACiD BuRN",long7,VARIANT:Integer:1)
Asc(string:"u")returns Integer:117
Trim(VARIANT:Integer:22)
Mid(varian:byReF String:"ACiD BuRN",long8,VARIANT:Integer:1)
Asc(string:"R")returns Integer:82
Trim(VARIANT:Integer:49)
Mid(varian:byReF String:"ACiD BuRN",long8,VARIANT:Integer:1)
Asc(string:"N")returns Integer:78
Trim(VARIANT:Integer:45)
------------------End of Smartcheck cut----------------------
Regardez maintenant le code : avez vous trouve un truc cool?
ici:
Mid(varian:byReF String:"ACiD BuRN",long1,VARIANT:Integer:1) <= 1er caractere
Asc(string:"A")returns Integer:65 <=== Valeur ASCII -> décimal
Trim(VARIANT:Integer:34) <=== la valeur de seiral??
Pourquoi pas essayer toutes ces valeurs comme un serial?
Donc prenez toutes les valeurs pour chaque lettre et ca donne:
Essayons:
name : ACiD BuRN
serial : 343210396733224945
clickez sur "Check It" et ca marche!!!!! Bon on l'a cracké!!! Maintenant je vais vous
expliquer comment le keygener.
3)Keygen it
Bon... Comment a t il trouve cette putain de valeur?!!!
hehe!! laissez moi voir...
Pourquoi pas un XOR?
Asc(string:"A")returns Integer:65 <== 1st ascii value
Trim(VARIANT:Integer:34) <== 1st good key
Asc(string:"C")returns Integer:67 <== 2nd ascii value
Trim(VARIANT:Integer:32) <== 2nd good key
.....
Si nous faisons 65 XOR 34 (a l'aide la calculatrice Windows en mode scientifique)
nous trouvons: 99
hehe !!
Si nous trouvons la meme valeur avec 67 XOR 32 alors on a de quoi faire un keygen!
regardez!!
67 XoR 32 = 99 !
cool!! on l'a fait!!
parce que si nous faisons 67 XOR 99=32 =) La bonne valeur de la cle!
Donc pour faire un bon serial de votre nom vous devrez prendre la valeur
ASCII de chaque lettre et le XOR 99. Sauvegarder cette valeur et ajouter
a cote le prochain resultat pour chaque lettre de votre nom!!
Comment le coder? Voici le code source VB5:
4)source du Keygen:
--------------Start of the source-------------
Private Sub Command1_Click()
For i = 1 To Len(Text1.Text)
code = Asc(Mid$(Text1.Text, i, 1)) Xor 99
Text2.Text = Text2.Text & code
Next i
End Sub
----------------End of the source-------------
Pour le tester, creez un nouveau projet avec un boutton et 2 textbox
double clicquez sur le boutton et copiez le code!
hehe !!
Fini!
Crackme Cracked!! =)
c'etait un keygen tres simple a faire !! mais il y en a des pires !!!
vous verrez ca bien assez tot !! croiez moi :)
**************************
* Keygen de Lan-Box 1.01 *
**************************
type: Visual Basic 6 app
level: very easy
tools needed: Smart check 6 , VB for coding the keygen
URL: http://members.tripod.com/LAN-BOX
Lancez smart check , et lancez le programme avec :)
Clickez sur le bouton Info et ensuite sur Register!
Entrez votre name : ACiD BuRN
et votre serial : 112233
Clickez sur le bouton pour controler le serial et cet encule nous sort bad serial
blablabla...
heh, fermez lan-box et faites une research de text sur: ACiD
Nous allons atterir la ou l'algo commence!!
regardez un peu et vous verrez qu'il prends les valeurs ascii de chaque lettres
du nom entre...
clickez sur la ligne:
asc(String:"A") returns Integer:65
Pour voir ce que fait ce putain de programme, on click sur : "Show all event" dans le menu
View..
Ensuite on voit ceci:
asc(String:"A") returns Integer:65 on voit le programme prendre la valeur ascii de la
premiere lettre (1ere lettre: "A" provenant d'ACiD BuRN)
Ensuite il ajoute aux autres...
en 1er il ajoute "65" a "0" car il n'y avait pas lettre avant!
On voit ca dans smart check avec la ligne suivante:
__vbavaradd(VARIANT:Empty,VARIANT:Integer:65)
ceci ajoute 65 a 0 (empty veut dire : pas encore de valeur donc vide)
Si on regarde plus bas, on voit la meme chose avec la lettre d'apres "C" (C de ACiD BuRN)
Asc(String("C") returns Integer: 67 <== prends la valeur ascii de la lettre ou nous
somme actuelement , ici on a "C"
Ensuite ajoute cette valeur au resultat de l'anciene addition!
__vbavaradd(VARIANT:65,VARIANT:Integer:67)
Resultat:
__vbavarmove(VARIANT:integer:132,VARIANT:Integer:65)
le resultat est: 132 et la valeur: 65 est l'anciene valeur. donc il efface la valeur qu'il avait
mis de cote 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 additiones entre elle!
cela donne ceci:
--------------------------------
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
---------------------------------
Donc la valeur final de ces operations est 680 en decimal ....
Maintenant descendez tant que vous n'aurez pas atteind la fin de la boucle sur
les valeurs ascii, c'est la ou vous verrez la valeur: "680" :)
heh, maintenant on regarde un peu plus et si on descend encore on voit:
__vbavarmul(VARIANT:680,VARIANT:232354) : multiplie le resultat des valeurs ascii avec 232354
le resulat est : 158000720
__vbavarmul(VARIANT:158000720,VARIANT:653435) : multiplie le resultat de la premiere
multiplication avec 653435
le resultat est: 103243200473200
__vbavardiv(VARIANT:1.03243e014,VARIANT:23446534) : divise le resultat de la 2nd multiplication
avec 23446534 (note: 1.03243e014 est la meme chose que 103243200473200
c'est pour cela qu'il est bon de faire les calcules pour verifier les valeurs :)
le resultat est: 4403345.947558817 (on voite cette valeur dans smart check)
et finalement on trouve:
__vbavarmove(VARIANT:Double:4.40335e+006,VARIANT:Integer:680)
cela deplace le resultat final (bon serial) ou la valeue "680" ete ecrite ! il l'ecrase donc!
Donc la premiere fois , j'ai cru que ct le bon serial!! mais ct pas le bon !
j'ai entre: 4403345.947558817 putain c pas le bon !
Mauvaise message box de merde!
Si on descend encore un peu, on voit la valeur: 4403345,94755882
Essayons le: Ca marche :)
Donc , je me demandais comment 4403345.947558817 est devenu 4403345,94755882 ..
J'ai commence a programmer le keygen pour voir comment je pourais reparer le probleme ...
Je l'ai programme en VB5 (c tjs bien les keygens en VB , sur des programmes VB car
on utilise les memes operations et fonction que le programme lui meme)
Donc j'ai genera un serial avec le nom: ACiD BuRN et il m'a donne: 4403345,94755882
Cooooool ! je sais pas pkoi ca marche , surement a cause des fonctions VB :)
d'ou l'interet encore une fois du keygen en VB!
Bref , ca marche , je suis fatigue et je vais pas me poser des questions 30 ans !
Explication global de l'algo:
--------------------------ALGO---------------------------------
1st : addtione 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-------------------------------
le resultat en 4 est le serial valide !!!!!!!!
3)BONUS SOURCE : le keygen en VB
-----------------------------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 *
*******************
Apres Le keygen d'un programme en name / serial !! voici celui
sur un serial only!
on a besoin de:
- Smart check 6 : doit etre bien configure
- Visual Basic : pour programmer le keygen (un autre language fera l'affaire aussi)
- le programme: http://www.ifrance.com/vbandjava
- un cerveau ;)
Lancez smart check et ouvrez le programme avec !!
On voit apparaitre : "the power est un shareware...."
C'est juste un nag screen, on s'en tape!
on click sur OK, et on voit maitenant une INPUT BOX avec le texte suivant:
"Le numero de votre disque (celui a partir duquel vous avez lancé the power)
est : (il vous donne le numero)
Si vous souhaitez vous enreistrez , notez ce numero et blablablabla"
Donc on voit que le programme nous demande de noter ce numero base sur notre
disque dure! et de l'envoyer si on veut s'enregistrer !! ok ok !!
Donc ce programme nescsite un keygen car le serial valid pour votre PC ne marchera
pas sur les autres ordis !
Donc entrez un serial a la con: 112233 et clicker sur OK!
on a le sale msg d'erreur *grin* : "Vous vous etes trompé(e) blablabla" (pas pour tres longtemps
lol )
Donc on ferme le programme et on retourne sous smart check pour etudier tout ca !
on va examiner l'algo :)
Dans smart check , double clickez sur : Form1_load
Donc on va d'abord cherchez qq chose qui se sert de notre disque dur
(l' api la plus utilise est GetvolumeinformationA) rapelez vous des CD checks!
regardez donc un peu plus bas et on trouve:
GetVolumeInformationA(LPSTR:00413BA4....)
2 lignes plus bas on voit : Right(VARIANT:Double:8.92936e+008,long:8)
Terrible ! ca l'air sympatique tout ca ! clickez dessus et regardez la valeur dans la fenetre
de droite!!
on voit : 892935893 <== c'est notre numero de disque dur
donc "Right(VARIANT:Double:8.92936e+008,long:8)" est egal a :
"Right(VARIANT:Double:892935893,long:8)"
cela veut dire qu'il prends les valeurs a partir de la droite avec une longeur de: 8
les 8 valeurs a partir de la droite de 892935893 sont 92935893
ne serais-ce pas le serial que l'on voit dans la boite de dialogue au debut ?
mais si ! tout a fait :)
vous n'aurez pas les memes valeurs chez vous car ca depends du disque dur !!
environ 2 lignes plus bas on trouve:
Len(String:"92935893")returns LONG:8
click dessus et dans le menu View, faites: show all events...
Maintenant on voit qqchose comme ceci :
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)
......
Hmm!! vous devez vous demander ce que ce truc fait !!!
et comment les valeurs sont calculees
laissez moi vous eclaircir:
Il prends les valeurs une par une du serial (la version modifie de celui du disque dur)
et les ajoutes au resultat de l'addtion d'avant !
voici l'exemple , c plus clair:
0 + 9 = 9 (0 car 9 est 1er nombre donc rien a ajouter encore!)
9 + 2 = 11
11 + 9 = 20
20 + 3 = 23
23 + 5 = 28
28 + 8 = 36
36 + 9 = 45
45 + 3 = 48
Donc vous voyez comment ces valeurs sont calculees!!
Pas tres complique , il faut juste reflechir!
Bref , ensuite on voit:
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") ....
.....
Donc il prends la valaue hexa de 19952 (4DF0)
et si on descend plus bas on voit la comparaison:
__vbaStrCmp(String:"4DF0",String:"112233") returns DWORD: FFFFFFFF
c'est celle qui est le plus utilise pour comparer!!
ici il comprare: 4DF0 with 112233
112233 = faux serial , celui qu'on a entre
4DF0 = le serial en hexadecimal qu'on a vu !! c le serial valid
Mais le probleme est : d'ou vient ce peutain de 19952 ?!
Regardons encore ce que nous avons vu avec smart check:
Mid$(String:"92935893",long:8,VARIANT:Integer:1)
....
Double (48) --> Integer (48)
Hex(VARIANT:integer:19952)
__vbastrVarMove(VARIANT:String:"4DF0") ....
hmm , si on ajoute 48 à 19952, on obtient: 20000
hoho !! on dirait que le programme soustrait la valeur calculer a partir
du serial provenant du disque dure a 20000
48 = valeur venant du disk dure
20000 = constante
20000 - 48 = 19952
Et apres ca, il convertit le resultat en hexadecimal:
19952(d) = 4DF0(h)
And on obtient le bon serial: 4DF0
c'est le code valid !!! donc si on faisait un petit keygen:
--------------------------------------------------------------------------------
The keygen:
Pour cela on utilise les API windows pour recuperer le numero de serie
du disque dur..
et ensuite on fait le reste des calcules !
Je vais montrer la partie calculation car celle qui recupere le numero du
disque n'est pas tres importante , mais tres longue :/
Voici les sources en VB:
-----------------------------little cut of source---------------------------------
'ici il y a les sources pour recuperer les numero di disque normalement
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
Text1.Text = "Your personal unlocking code is :" + Hex(20000 - temp)
-------------------------end of little cut of source-------------------------------
Et voila !! c'est terminé pour les keygens des programmes en VB!!
Mais je vous invite a lire les nombreux autres cours que j'ai ecrit
a ce sujet !!
May the Force be with you ;p
Nag et autres Splash screen (diverse methodes...)
C'est la partie qui le fait le plus chier a ecrire je pense !!
pourquoi ? car j'aime pas les nags screen !!
Je trouve a ennuyeux ;)
Mais on doit y passer alors commencons des maintenant !!
qu'est qu'un Nag screen ?
Un nag screen , c'est une fenetre qui vient vous dire que vous
n'etes pas enregistre et qu'il faut payer vite fais pour qu'elle disparaisse :)
Bref , c vraiment ennuyant , on peut tomber sur un NAG avec un bouton
desactiver qui se reactive apres qq seconds par exemple !!
Bref casse couille a souhait ;)
Avant de commencer avec les trucs un peu plus complique avec soft ice et tout
on va commencer par Simple !!
Cracker un nag screen avec seulement un editeur hexa decimal
quoi ? vous vous demandez quelle connerie je suis entrain de raconter lol !!
l'exemple que vais vous montrer et comment cracker le NAG screen de WinRAR 2.6
qd la limite dans le temps a expiré !!
Vous pourez essayer cette technique sur ICQ99 afin de kicker les 8 secs au demarage!!
Bref assez bavardé !! let's start :
*********************************
* Cracker le nag de Winrar 2.6b *
*********************************
Tu lances winrar , apres avoir mis la date en avance : style : 2002.
la 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 emuler la
pression sur ce bouton.
Piner Le nag :)
~~~~~~~~~~~~~~
donc , voici une methode qui marche souvent, pour emuler la pression d'un
bouton... Vous avez juste besoin d'un editeur hexadecimal (moi j'utlise hex workshop).
donc , vous lancez Winrar encore et regardez le caption du bouton : Close
donc ouvrez winrar avec un editeur hexa et recherchez en hexa: 43006C006F0073006500
43006C006F0073006500 =
C l o s e
donc vous recherchez la valeur hexa de chaque Caracteres , 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 , voila vouz etez a la bonne place , now pour emuler , vous aves juste a regardez le
FFFF82 ou FFFFFFFF82 le pus 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 !! la tu es a la bonne place , donc tu remplace 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 arriere , toujours pas de nag , donc Voila c'est termine
Conseil: Ils auraient du fermer le prog une fois le temps depasser! ca aurait forcer le
cracker a jouer un peu plus et cracker le time limite !
Pour le reste des protections ,c'est tres simple ! avec ce que vous avez du lire
avant d'arriver ici , vous ne devriez pas avoir de problemes !
On va passer a un autre type de nag Sreen !! Les messagebox
C'est tres chiant , mais qd on voit ca !! on est qd meme content car ca se vire
en 10 secondes ;)
Les messageboxes se reconnaissent grace a leur icones deja !
Les icones que l'on boit dans windows avec comme signe: le point d'exclamation ,
la croix blanche sur rond rouge.... et un message l'accompagnant !!
Comment cracker ca ? bien je vais montrer 2 facons!!
- Avec wdasm (cracker like a wanker):
Vous lancez votre programme et vous voyez le message qui nous dis:
"Version Shareware! please Register" ou un truc chiant du style !!
Pour virer ca , vous ouvrez Wdasm et desassembler le fichier du programme!
Vous faites un tour dans les string data references a la recherche de cette phrase!
Vous allez la trouver avec 98 % de chances !!
Donc vous double cliquez sur cettre phrase et recherchez au dessus un saut conditionel
qui vous fait atterir sur le nag ou au contraire le sauter !!
ET vous le noper ou forcer 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 amene a tout les coups sur le message d'erreur on le NOP
et il ne sautera plus jamais !
Ceci est un exemple mais ca ressemble a ca en gros
C'est pas tres clean, et ca fait branleur mais bon :)
Plus ca va vite et plus vous etes content je presume ....
- 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 !! la 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 appel
le messageBox !!
On peut cracker comme un bourin en nopant ce call , mais ca fait pas tres pros
le mieux c'est de foutre un RET juste apres etre enter dans le CALL..
petit exemple theorique:
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
apres avoir fait le F8 on voit un truc comme ca :
025F:00401510 FF253C324000 JMP [USER32!MessageBoxA] <-- le F8 nous mene ici
025F:00401516 FF2540324000 JMP [USER32!MoveWindow]
025F:0040151C FF2544324000 JMP [USER32!DialogBoxParamA]
........................
Apres avoir fait le F8, on est donc sur un JMP qui va appeller 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 hope il continue ca route sans jamais affiche aucune connerie !
Ensuite vous faites la modif dans l'executable lui meme et on en parle plus :]
Je vais expliquez Rapidement une methode qui utilise un BPX qui est tres rarement
utilise pour cracker les Nags, mais plutot dans les names / serials !
Mais c'est un plaisir de l'utiliser dans les programmes ecrit en delphi par exemple !
Le BPX est : hmemcpy
Methode theorique:
Vous mettre ce BPX et vous lancez le programme en delphi a cracker!
Soft ice break! Vous pressez F5 le nombre de fois qu'il faut pour obtenir le NAG screen
et vous contez le nombre de F5 qu'il vous a fallut bien sur!!
on va dire: 14 Fois F5 pour voir le nag !!
alors On relance le programme et on faira F5 le nombre de fois que vous avez trouve
moins 1 !! (14 - 1 = 13 ici)
On presse 13 fois F5 ici !! ensuite on presse F12 pour revenir dans l'executable
et quitter ces dlls a la con :=)
Apres avoir fait ca , vous tracer comme un dingue avec F10 et vous allez arriver sur une serie
de CALL , MOV , CALL , MOV ....
Ca se voit tout de suite , il y a casiment que ca !!
et la vous mettez un BPX a l'emplacement ou cette routine commence et vous tracer avec
F10! le NAG screen va apparaitre en passant sur un call normalement !! vous reperez
quel CALL c'est et puis vous lui mettez un bpx une fois avoir desactiver tout les autres!
Vous breaker dessus! premiere facon bourin: on nope le call comme un goret ;)
On a de la chance ca 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 partie et que ca ne crash pas , ct le bon endroit !!
Si tous ca a amener a un mechant crash :-/ il vous faut apres avoir entre ce call
cherchez un autre call qui affiche le nag a l'interieur !!
et le noper !!
Si le nag est avec timer , on doit trouver un CALL GETTICKCOUNT pas loin de celui ci
non plus !! cette API gere est souvent utilise pour ca ;)
On peut aussi utiliser L'API: Detroywindow qui nous amene dans Soft ice apres avoir
tuer le nag ! la on presse F12 et on regarde les calls plus haut et on retrouve
souvent les calls et les movs de tout a l'heure qui sont si charmants lol
Bref , cette technique , je ne l'ai jamais vu dans aucun cour en francais ou bien
US , mais elle permet de cracker un nag delphi en 2 mins sans se faire chier a tracer
comme un dingue jusqu'a trouver LE CALL !!
sinon , voici une liste d'API utilise 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 generations de fnetre:
createwindow
createwindowexa
showwindow
Voila , je pense que vous deja de quoi cracker pas mal de nags screen a la con!
La plus part du temps c'est : Posez le BPX, tracer , trouvez le CALL , killez le !
et on ne reparle plus du NAG !!
CheckSum divers
Imaginez que vous venez de cracker un messagebox en memoire ou autre medres et
que apres avoir modifie le programme en hexa , le fichier ne se lance plus
de tout , mais quitte directe !! ou encore qu'il vous dise: "CRC ERROR blablablaa"
Et la vous dites!! merde!!!!! c quoi ce bordel! je peus meme pas patcher ;(
allors sois vous utilise un mem patcher (patch qui ne patch qu'en memoire donc le programme
est tjs intacte, mais a besoin d'etre lancer avec ca) sois vous reflechissez :)
Ca peut tres bien etre plusieurs choses en fait !!
on va commencer par le checksum !
c quoi ?
en fait , le programme fait une somme des valeurs ascii du programme et les compares
a une constante par exemple!
Et tant que c'est egale a cette constante, le programme se lance sans broncher!
Mais vous , vous venez de patcher avec des NOP , je , JMP ou autres !!
et ces instructions n'ont pas le meme poids !
exemple a 2 francs:
il y avait un:
JE XXXXXXXXXX
et vous l'avez remplacer par un JNE (BEURK , mais ca sera plus simple pour kicker le
checksum).
on dira que ca ressemblait a ca en hexa:
7428 (pour le "je") == 74h + 28h = 9Ch = 156
donc 156 en decimal !! et vous avez patchez en JNE:
7528 (pour le "jne") == 75h + 28 h = 9Dh = 157
157 est different de 156 donc en additionant tout les octets un a un , le programme trouvera
une difference et se ne se lancera PAS :)
comment contourner ca ?
Ben , moi je modifierais ca en :
7527 = 75h + 27h = 9Ch = 156
on s'en fou de la valeur apres le jne car il ne sautera pas!!
et le resultat est donc egale a 156 et il croit que tout est OK :P
Bref c tout con mais ca marche tres bien !
Si par bonheur le programme vous annonce que le fichier avait ete modifie pas la peine
de jouer avec les octets comme ca mais desassembler le fichier plutot et regardez
dans les strings data references le message qu'il nous donnait et cracker moi ca
siou plait ;p
Il peut y avoir aussi un CRC, c plus complique et je ne vais pas expliquer le fonctionnement
de celui ;)
Il utilise une table qui est la suivante pour les programmes en Win32:
CRC-32 Table
00h 00000000 77073096 EE0E612C 990951BA
04h 076DC419 706AF48F E963A535 9E6495A3
08h 0EDB8832 79DCB8A4 E0D5E91E 97D2D988
0Ch 09B64C2B 7EB17CBD E7B82D07 90BF1D91
10h 1DB71064 6AB020F2 F3B97148 84BE41DE
14h 1ADAD47D 6DDDE4EB F4D4B551 83D385C7
18h 136C9856 646BA8C0 FD62F97A 8A65C9EC
1Ch 14015C4F 63066CD9 FA0F3D63 8D080DF5
20h 3B6E20C8 4C69105E D56041E4 A2677172
24h 3C03E4D1 4B04D447 D20D85FD A50AB56B
28h 35B5A8FA 42B2986C DBBBC9D6 ACBCF940
2Ch 32D86CE3 45DF5C75 DCD60DCF ABD13D59
30h 26D930AC 51DE003A C8D75180 BFD06116
34h 21B4F4B5 56B3C423 CFBA9599 B8BDA50F
38h 2802B89E 5F058808 C60CD9B2 B10BE924
3Ch 2F6F7C87 58684C11 C1611DAB B6662D3D
40h 76DC4190 01DB7106 98D220BC EFD5102A
44h 71B18589 06B6B51F 9FBFE4A5 E8B8D433
48h 7807C9A2 0F00F934 9609A88E E10E9818
4Ch 7F6A0DBB 086D3D2D 91646C97 E6635C01
50h 6B6B51F4 1C6C6162 856530D8 F262004E
54h 6C0695ED 1B01A57B 8208F4C1 F50FC457
58h 65B0D9C6 12B7E950 8BBEB8EA FCB9887C
5Ch 62DD1DDF 15DA2D49 8CD37CF3 FBD44C65
60h 4DB26158 3AB551CE A3BC0074 D4BB30E2
64h 4ADFA541 3DD895D7 A4D1C46D D3D6F4FB
68h 4369E96A 346ED9FC AD678846 DA60B8D0
6Ch 44042D73 33031DE5 AA0A4C5F DD0D7CC9
70h 5005713C 270241AA BE0B1010 C90C2086
74h 5768B525 206F85B3 B966D409 CE61E49F
78h 5EDEF90E 29D9C998 B0D09822 C7D7A8B4
7Ch 59B33D17 2EB40D81 B7BD5C3B C0BA6CAD
80h EDB88320 9ABFB3B6 03B6E20C 74B1D29A
84h EAD54739 9DD277AF 04DB2615 73DC1683
88h E3630B12 94643B84 0D6D6A3E 7A6A5AA8
8Ch E40ECF0B 9309FF9D 0A00AE27 7D079EB1
90h F00F9344 8708A3D2 1E01F268 6906C2FE
94h F762575D 806567CB 196C3671 6E6B06E7
98h FED41B76 89D32BE0 10DA7A5A 67DD4ACC
9Ch F9B9DF6F 8EBEEFF9 17B7BE43 60B08ED5
A0h D6D6A3E8 A1D1937E 38D8C2C4 4FDFF252
A4h D1BB67F1 A6BC5767 3FB506DD 48B2364B
A8h D80D2BDA AF0A1B4C 36034AF6 41047A60
ACh DF60EFC3 A867DF55 316E8EEF 4669BE79
B0h CB61B38C BC66831A 256FD2A0 5268E236
B4h CC0C7795 BB0B4703 220216B9 5505262F
B8h C5BA3BBE B2BD0B28 2BB45A92 5CB36A04
BCh C2D7FFA7 B5D0CF31 2CD99E8B 5BDEAE1D
C0h 9B64C2B0 EC63F226 756AA39C 026D930A
C4h 9C0906A9 EB0E363F 72076785 05005713
C8h 95BF4A82 E2B87A14 7BB12BAE 0CB61B38
CCh 92D28E9B E5D5BE0D 7CDCEFB7 0BDBDF21
D0h 86D3D2D4 F1D4E242 68DDB3F8 1FDA836E
D4h 81BE16CD F6B9265B 6FB077E1 18B74777
D8h 88085AE6 FF0F6A70 66063BCA 11010B5C
DCh 8F659EFF F862AE69 616BFFD3 166CCF45
E0h A00AE278 D70DD2EE 4E048354 3903B3C2
E4h A7672661 D06016F7 4969474D 3E6E77DB
E8h AED16A4A D9D65ADC 40DF0B66 37D83BF0
ECh A9BCAE53 DEBB9EC5 47B2CF7F 30B5FFE9
F0h BDBDF21C CABAC28A 53B39330 24B4A3A6
F4h BAD03605 CDD70693 54DE5729 23D967BF
F8h B3667A2E C4614AB8 5D681B02 2A6F2B94
FCh B40BBE37 C30C8EA1 5A05DF1B 2D02EF8D
Voici un exemple trouve sur comment utilise cette table!
Je ne vais pas expliquez , je donne ca juste pour ceux qui en veulents tjs plus !
car il existe deja un super tut sur les CRC ! en anglais mais tres cool qd meme:
*CRC and how to Reverse it* by Anarchriz/DREAD (www.dread.cjb.net <-- pas trop sure)
Mais vous trouverez un lien vers ce site sur ma page sans probleme si ce n'est pas la bonne
// les sources
********************************************************************************************
{-------------------------------------------------------------
This unit is freeware. I found it somewhere on CIS, I think.
Peter Tiemann
-------------------------------------------------------------}
Unit Crc32;
interface
uses
Dialogs,
SysUtils,
WinTypes,
WinProcs;
function UpdateCRC32(InitCRC: LongInt; Buffer: Pointer; BufferLength: WORD): LongInt;
function ComputeFileCRC32(const FileName: string): LongInt;
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,
$01db71064, $06ab020f2, $0f3b97148, $084be41de,
$01adad47d, $06ddde4eb, $0f4d4b551, $083d385c7,
$0136c9856, $0646ba8c0, $0fd62f97a, $08a65c9ec,
$014015c4f, $063066cd9, $0fa0f3d63, $08d080df5,
$03b6e20c8, $04c69105e, $0d56041e4, $0a2677172,
$03c03e4d1, $04b04d447, $0d20d85fd, $0a50ab56b,
$035b5a8fa, $042b2986c, $0dbbbc9d6, $0acbcf940,
$032d86ce3, $045df5c75, $0dcd60dcf, $0abd13d59,
$026d930ac, $051de003a, $0c8d75180, $0bfd06116,
$021b4f4b5, $056b3c423, $0cfba9599, $0b8bda50f,
$02802b89e, $05f058808, $0c60cd9b2, $0b10be924,
$02f6f7c87, $058684c11, $0c1611dab, $0b6662d3d,
$076dc4190, $001db7106, $098d220bc, $0efd5102a,
$071b18589, $006b6b51f, $09fbfe4a5, $0e8b8d433,
$07807c9a2, $00f00f934, $09609a88e, $0e10e9818,
$07f6a0dbb, $0086d3d2d, $091646c97, $0e6635c01,
$06b6b51f4, $01c6c6162, $0856530d8, $0f262004e,
$06c0695ed, $01b01a57b, $08208f4c1, $0f50fc457,
$065b0d9c6, $012b7e950, $08bbeb8ea, $0fcb9887c,
$062dd1ddf, $015da2d49, $08cd37cf3, $0fbd44c65,
$04db26158, $03ab551ce, $0a3bc0074, $0d4bb30e2,
$04adfa541, $03dd895d7, $0a4d1c46d, $0d3d6f4fb,
$04369e96a, $0346ed9fc, $0ad678846, $0da60b8d0,
$044042d73, $033031de5, $0aa0a4c5f, $0dd0d7cc9,
$05005713c, $0270241aa, $0be0b1010, $0c90c2086,
$05768b525, $0206f85b3, $0b966d409, $0ce61e49f,
$05edef90e, $029d9c998, $0b0d09822, $0c7d7a8b4,
$059b33d17, $02eb40d81, $0b7bd5c3b, $0c0ba6cad,
$0edb88320, $09abfb3b6, $003b6e20c, $074b1d29a,
$0ead54739, $09dd277af, $004db2615, $073dc1683,
$0e3630b12, $094643b84, $00d6d6a3e, $07a6a5aa8,
$0e40ecf0b, $09309ff9d, $00a00ae27, $07d079eb1,
$0f00f9344, $08708a3d2, $01e01f268, $06906c2fe,
$0f762575d, $0806567cb, $0196c3671, $06e6b06e7,
$0fed41b76, $089d32be0, $010da7a5a, $067dd4acc,
$0f9b9df6f, $08ebeeff9, $017b7be43, $060b08ed5,
$0d6d6a3e8, $0a1d1937e, $038d8c2c4, $04fdff252,
$0d1bb67f1, $0a6bc5767, $03fb506dd, $048b2364b,
$0d80d2bda, $0af0a1b4c, $036034af6, $041047a60,
$0df60efc3, $0a867df55, $0316e8eef, $04669be79,
$0cb61b38c, $0bc66831a, $0256fd2a0, $05268e236,
$0cc0c7795, $0bb0b4703, $0220216b9, $05505262f,
$0c5ba3bbe, $0b2bd0b28, $02bb45a92, $05cb36a04,
$0c2d7ffa7, $0b5d0cf31, $02cd99e8b, $05bdeae1d,
$09b64c2b0, $0ec63f226, $0756aa39c, $0026d930a,
$09c0906a9, $0eb0e363f, $072076785, $005005713,
$095bf4a82, $0e2b87a14, $07bb12bae, $00cb61b38,
$092d28e9b, $0e5d5be0d, $07cdcefb7, $00bdbdf21,
$086d3d2d4, $0f1d4e242, $068ddb3f8, $01fda836e,
$081be16cd, $0f6b9265b, $06fb077e1, $018b74777,
$088085ae6, $0ff0f6a70, $066063bca, $011010b5c,
$08f659eff, $0f862ae69, $0616bffd3, $0166ccf45,
$0a00ae278, $0d70dd2ee, $04e048354, $03903b3c2,
$0a7672661, $0d06016f7, $04969474d, $03e6e77db,
$0aed16a4a, $0d9d65adc, $040df0b66, $037d83bf0,
$0a9bcae53, $0debb9ec5, $047b2cf7f, $030b5ffe9,
$0bdbdf21c, $0cabac28a, $053b39330, $024b4a3a6,
$0bad03605, $0cdd70693, $054de5729, $023d967bf,
$0b3667a2e, $0c4614ab8, $05d681b02, $02a6f2b94,
$0b40bbe37, $0c30c8ea1, $05a05df1b, $02d02ef8d);
var
Buffer: Array[1..BufferLength] of Byte;
{$ifndef WIN32}
type
DWORD = longint;
{$endif}
function UpdateCRC32(InitCRC: LongInt; Buffer: Pointer; BufferLength: WORD): LongInt;
var
crc: LongInt;
index: integer;
i: integer;
begin
crc := InitCRC;
for i := 0 to BufferLength-1 do
begin
index := (crc xor Integer(Pointer(DWORD(Buffer)+i)^)) and $000000FF;
crc := ((crc shr 8) and $00FFFFFF) xor CRC32Table[index];
end;
Result := crc;
end;
function ComputeFileCRC32(const FileName : string): LongInt;
var
InputFile: File;
Crc32: LongInt;
ResultLength: Integer;
BufPtr: Pointer;
begin
BufPtr := @Buffer;
Assign(InputFile, FileName);
Reset(InputFile, 1);
Crc32 := $FFFFFFFF; { 32 bit crc starts with all bits on }
Repeat
BlockRead(InputFile, Buffer, BufferLength, ResultLength);
Crc32 := UpdateCrc32(Crc32, BufPtr, ResultLength);
Until Eof(InputFile);
Close(InputFile);
Crc32 := Not(Crc32); { Finish 32 bit crc by inverting all bits }
Result := CRC32;
end;
end.
// fin des sources
********************************************************************************************
cette source est freeware , c'est juste pour vous montrez 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 a la recherche de NOPs trop repetitif
donc une facon "d'effacer" est de metre des INC et des DEC !!
exemple:
7428 --> 9090 (le nop de base)
7428 --> 4041 (INC , DEC)
cela ne fait rien de mal et ca a efface le saut !! et on a pas utiliser de nops :)
mais il faut tjs increment autant de fois que vous decrementez !!
si on aurait eu 5 bits a patcher : 4041404190
Un seul nop passera si le programme cherche au minimum 2 ou 3 nops consecutifs!
Voila , 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
deja un SUPERBE tool pour cacher Soft ice!
FrogsICE par +Frog's Print !
On trouve dedans de la Doc sur les methodes de detection donc , je ne saurais
que vous incitez a telecharger ce magnifique programme !!
Desole si je ne detail pas des masses cette partie, mais ca fait deja 4 jours que
je suis malade et ca vas pas super :'(
je vais juste vous presenter les detections les plus courantes :
* Melt ice:
La methode utilise pour detecter Soft ice est la suivante:
il utilise l'API createfilea "afin de detecter le VXD" !
desole , je ne sais pas trop comment expliquer:
il peut detecter Soft ice avec: SICE , SIWVID pour win9x et NTICE pour winNT
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;
}
// Pris de la doc de Frogsice
Voici 1 exemple en delphi de comment programmer ca:
**********************************************************************************************
procedure DetectICE;
var ACiD:Thandle;
s,s2:string;
begin
s:='\' + '\' + '.' + '\' + 'S' + 'I' + 'C' + 'E';
s2:='\\.\SICE';
if s <> s2 then begin ShowMessage('NO PATCH'); ExitProcess(0); end ;
ACiD:=CreateFileA(PChar(s2),GENERIC_READ or GENERIC_WRITE,FILE_SHARE_READ or FILE_SHARE_WRITE,nil,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
if ACiD <> INVALID_HANDLE_VALUE then begin ShowMessage('Kick Soft Ice and come back ! =)'); ExitProcess(0); end ;
s:='\' + '\' + '.' + '\' + 'N' + 'T' + 'I' + 'C' + 'E';
s2:='\\.\NTICE';
if s <> s2 then begin ShowMessage('NO PATCH'); ExitProcess(0); end ;
ACiD:=CreateFileA(PChar(s2),GENERIC_READ or GENERIC_WRITE,FILE_SHARE_READ or FILE_SHARE_WRITE,nil,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
if( ACiD <> INVALID_HANDLE_VALUE ) then begin ShowMessage('Kick Soft Ice and come back ! =)'); ExitProcess(0); end;
end;
**********************************************************************************************
voila, vous voyez ca ressemble bcp a ce qu'on a plus haut !!
Donc comment cracker ca maintenan ?
Tres simple, Vous mettez un bpx createfilea
Vous lancez le programme proteger et vous devez arriver sous soft ice!!
F12 une fois et vous devez trouver qq chose qui ressemble a ca:
XXXXXXXX FF1520A00010 CALL [KERNEL32!CreateFileA]
XXXXXXXX 83F8FF CMP EAX,-01 <- si EAX= -1 sice n'est pas charge
XXXXXXXX 7409 JZ 100038A9 <-- ca saute vers le programme :)
Donc si on veut le lancer quoi qu'il arrive on remplace le "JZ" en "JMP" et on n'en parle
plus :)
Encore une fois , allez voir la doc de frogsICE qui vous donne des info complementaires
Je ne suis pas la pour "pomper" les autres donc, je ne le mettrez pas ici :P
* detection par INT 68h:
mov ah,43h
int 68h
cmp ax,0F386h
jz Soft_ice_est_la_:P
Voila a quoi ressemble le monstre ;P
un petit exemple de programmation en delphi :
*****************************************************************************************
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.
******************************************************************************************
il existe differentes facon de cracker ca:
on ne peut pas mettre de Bpint sur 68, voici une facon de contourner:
BPX exec_int if ax==68
il existe d'autre facon , mais je n'en rappel plus actuellement :'(
je dois retrouver mes notes donc cette partie se remis a jour plus tard (lol on dirait
Krosoft ;)
Don apres avoir breaker sous soft ice grace a ce BPX on va trouver un code qui ressemble
a ca:
XXXXXXXX mov ah,43h
XXXXXXXX int 68h
XXXXXXXX cmp ax,0f386h
XXXXXxXX je XXXXXXXX <--- saute au mauvais endroit (BAD CRACKER SICE LOADED)
XXXXXXXX jmp XXXXXXXX <-- Gentil cracker !! on se sert pas de soft ice lol
Ben vous pouvez noper le je par exemple et il sautera tjs au bon endroit !!
sans jamais se douter que soft ice est charge :]
* detection par Int 3 (cherche la signature de boundcheck dans soft ice)
mov ebp, 04243484Bh ; 'BCHK'
mov ax, 04h
int 3
cmp al,4
jnz Soft_ice_est_la_:P
On retrouve une detection par int3 dans Armadillo aussi :
025F:00402243 8885B8FEFFFF MOV [EBP-0148],AL
025F:00402249 BA6D447546 MOV EDX,4675446D
025F:0040224E 8995B0FEFFFF MOV [EBP-0150],EDX
025F:00402254 C785C4FEFFFF260C3604MOV DWORD PTR [EBP-013C],04360C26
025F:0040225E 895DFC MOV [EBP-04],EBX
025F:00402261 8B85C4FEFFFF MOV EAX,[EBP-013C]
025F:00402267 3385B0FEFFFF XOR EAX,[EBP-0150]
025F:0040226D 8BE8 MOV EBP,EAX
025F:0040226F B804000000 MOV EAX,00000004
025F:00402274 CC INT 3 <----- le chti INT :p
025F:00402275 3115148D4000 XOR [00408D14],EDX
025F:0040227B A180804000 MOV EAX,[00408080]
025F:00402280 310584804000 XOR [00408084],EAX
025F:00402286 834DFCFF OR DWORD PTR [EBP-04],-01
025F:0040228A EB18 JMP 004022A4
on se met sur le "MOV EAX, 00000004"
Pour passer ce control , il suffit de se mettre a la ligne du MOV.
dans soft ice , tapez:
A "entrer"
JMP 0 "entrer"
"echap"
c'etait juste un exemple....
Pour en revenir a notre code de base pour la detection par int 3 il suffit aussi
de jouer avec le saut conditionel pour resoudre tout nos probs :]
pas besoin de vous faire un dessin je pense!
Voila, je vous ai decrit (tres vite) les 3 detections de soft ice que je recontre
dans les programmes!
Elles sont tres courantes!
Je vous conseil donc encore une fois d'aller lire la documentation fournit avec FrogsICE
afin d'en apprendre plus!!
Je suis pas la pour faire du copier / coller lol
Frog's Print
Ici se termine la partie anti soft ice...
Transformer un programme en son propre keygen
Muad'dib Keygen Crackme #1
- Afficher le bon serial a 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'ailleur est tres simple a faire) mais forcer le crackme
a afficher le bon serial a la place du message: "try again , Blablabla.."
utils nescessaires:
- soft ice (it r0x)
- editeur hexadecimal
Let's kick some ass =)
Bon , deja on lance ce con de crackme , et on entre son nom: ACiD BuRN et un serial
a 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 des
qu'on est dans le crackme on commence a tracer.
On arrive assez vite a une routine qui controle le type de nom entree (miniscules,
majuscules , spaces , chiffres ...) mais il y a d'abord un check sur la longeur du nom:
025F:004010A3 83F804 CMP EAX,04 <-- compare la taille du nom a 4
025F:004010A6 7304 JAE 004010AC <-- ok si superieur ou egal a 4
025F:004010A8 C9 LEAVE
025F:004010A9 C21000 RET 0010
Apres ca , il y a le control des caracteres :
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 , minuscules , spaces ...
Si c pas ok , ca jump a 4010CA , et un message box nous dis d'enter que des majuscules
et spaces...
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 final:
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 resume , on voit une comparaison bon serial / mauvais serial execute 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 , ca saute a 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 pas ca qu'on veut :)
on veut forcer le prog a montrer le bon serial a 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 a la con !
donc pour le faire afficher le bon serial tu prends l'address du push 'bon serial' et tu la
copies a la place du push 'message comme quoi tu as foire' !!
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'a midifier physiquement notre crackme , et le bon pass apparaitra
a la place de l'erreur :) et voila notre super keygen pour branleurs :)
hehe , c 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, met un serial en majuscules et goodie :))
le good serial apparait , Facile ....
remarques on a toujours le titre : erreur code dans la msg box , rien ne vous empeche
de le changer en: Keygen ;)
*********************************************************
** Rprogrammer la routine de Controle du serial **
*********************************************************
toujours sur le meme crackme !!
on va donc recoder le check du serial dans soft ice pour s'occuper
ca vas 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
Compaison grace a l'api lstrcmp.
on va transcrire ca 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 fais exactement la meme chose , mais n'utilise pas d'API pour comparer
on met en EAX: l'addresse du serial entre , et en EDX le bon serial.
on les compare via : CMP EAX, EDX
ensuite un saut conditionel a la con et un Jump...
Les nop n'etaient pas utile , mais ca fais plus clean ;)
Voila , le prog controle si le serial est valide d'une autre maniere, ca sert a
rien , c'etais juste pour montrer ce qu'on peut faire avec de l'imagination , hehe
On peut bien s'amuser donc :]
Diver :
******************************************************************
*** Changer l'image d'un programme en delphi par exemple ***
******************************************************************
Cette partie est juste a but educatif!!
J'ai pris mon dernier crackme en delphi qui contient une image de fond!
Et je me suis dis , comment faire pour modifier cette image si on a pas les sources
et sans utiliser de compilateur , decompilateur ou autres editeurs de resources !
Voici la methode!
tool nescessaire: Editeur hexadecimal: HEXWORKSHOP
ouvrez le fichier dont vous vous voulez changer l'image de fond avec votre editeur
hexa.
L'image est sois au format BMP ou JPEG!
le genre le plus courement utilise est de 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 editeur hexadecimal pour regradez par quoi il commence
et par quoi il commence!
exemple d'un fichier JPEG edite en mode hexadecimal:
FFD8 FFE0 0010 4A46 4946 0001 0100 0001 ......JFIF......
0001 0000 FFDB 0043 0005 0304 0404 0305 .......C........
0404 0405 0505 0607 0C08 0707 0707 0F0B ................
0B09 0C11 0F12 1211 0F11 1113 161C 1713 ................
141A 1511 1118 2118 1A1D 1D1F 1F1F 1317 ......!.........
......
Si on ouvre plusieurs fichier jpeg on se rends compte que le debut est tjs le meme!
Ils commencent tjs par : FFD8 FFE0 0010 4A46 4946
si on regarde la fin d'un fichier JPEG on voit ceci:
777F A758 0937 097F A99F 81E5 3FFF D900 w..X.7......?..
on va que ca finis par FFD9 (le 00 n'est pas tres important)
Donc on se dit si on cherchait ces infos dans le fichier ou est l'image
a changer!!
Alors on fait une recherche des octetes suivant: FFD8 FFE0 0010 4A46 4946
et on trouve ca a l'offset: 64C2A
on le note sur un papier au cas ou !! et on cherche: FFD9 et on trouve ca
a l'offset: 70A65
70A66 - 64C2A = BE3Ch = 48700 en decimal
c'est la longeur de l'image!! donc celle qu'on veut inserer doit etre inferieur
ca cette taile !!
je cherche sur mon dique dur un de mes logos et je l'ouvre avec mon editeur hexa !
(en JPEG aussi l'image a inserer)
Ensuite je selectione tout les octets de l'image avec hexworkshop (Ctrl+A) et je fais un
copier: ctrl + C ... ( apres avoir fait selectioner tout , je vois en bas le nombre d'octet
de l'image a inserer -> sel: 4f2fh )
je me remet a la fenetre hexworshop qui s'occupe de mon crackme et je vais a
l'offset ou l'image commence: 64C2A
Et la dans le menu edit , select block j'entre la longeur de l'image entree en hexa !
Il selectione dans l'anciene image la place que va prendre la nouvelle image!
Ensuite on fait coller (Ctrl+V) et si il vous pose un question repondez oui!! ou OK
l'image est plus petite donc il reste un morceau de l'anciene mais on s'en fou pas mal
car ceux qu'on vient de coller contient le code qui dit que l'image est finis: FFD9
On sauvegarde notre fichier , et on relance!
Youpi!! on a maintenant une nouvelle image dans mon crackme !! hehe c marrant et tres
simple a faire !!
Vous pouvez faire ca avec des images GIF , BMP ou autres !!
Just for knowledge purpose ;]
Keyfile
Qu'est ce qu'un keyfile ?
c'est un fichier licence que l'on place dans le repertoire courant du programme
pour l'enregister !
on a donc rien a entrer comme un name / serial!
on n'utilise pas les memes API mais surtout l'API CreateFileA
je vais montrer un exemple:
********************************
* termial Cilla's CrackMe 1.0 *
********************************
Je vous previens de suite , ce crackme contient une protection par Key file , qui
est tres simple , mais que je considere bien pour le sujet d'un cour general !
je ne vais pas vous faire un cour sur un keyfile qui est trop long et qui va vous
perturber !!
Le crackme a besoin d'un fichier keyfile , ici il s'appel TC1.key
je cree un fichier keyfile a la con contentant le texte:
"ACiD BuRN 4 EVER Ph34rs "
si on edite 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 boutton pour checker le keyfile !!
Un open box apparait si vous clickez dessus et vous dis de choisir un fichier , ok on va le
faire l'ami :)
Tout d'abord mettez un BPX sur createfilea et quitter 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 ca 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 a 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 caractere du keyfile (dans ebp-1)
:00429DB2 ADD EBX,EAX ; additione la valeur a 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 continu
:00429DC8 LEA EAX,[EBP-0150]
:00429DCE CALL 00404458
:00429DD3 CALL 00402618
:00429DD8 CMP EBX,000020A9 ; La domme des caracteres = 20A9h ?
:00429DDE JNZ 00429DEE ; Si c'est egal alors le keyfile est valide
La somme de mon fichier fait: 794h
Ce n'est pas egal a 20A9h donc le keyfile n'est pas valid!!
On va rectifier ca !! 20A9h - 794h = 1915h
il nous faut donc ajouter 1915h a 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 ca marche !
alors je vous laisse vous amusez !!
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 nescessaire: 20A9h
Alors amusez vous a faire votre propre keyfile et si vous n'avez pas compris comment
faire essayer de completer mon keyfile :)
Voila , la partie keyfile fut breve !
Il existe un crackme un peu plus complique mais tres interressants a essayer:
Cruehead Crackme 3 !
Il est toujours simple , mais plus fins a cracker ;)
Vous devez l'essayer , et pourquoi par faire un keymaker !
Il existe d'autres crackme utilisant les keyfiles! Alors vous pouvez vous entrainez
si vous avez du mal!
note: N'essayer pas de cracker CuteFTP juste apres avoir lu ce cour , si vous n'avez jamais
cracker de keyfiles de votre vie! c'est un conseil ....
Greetings:
Group greetings: ID - ECLiPSE - CiA - ODT - EXEC - PWA - PC - UCF- CORE - CC -
Nova2000 - PDM
Also greetingz to: (no specific order)
Victoria , R!SC, ^INFeRNo^, AB4DS, Cyber Blade, Klefz, , Volatility,
TORN@DO, T4D , Jeff, [Virus], JaNe , Appbusta , Duelist , tKC , BuLLeT ,
Lucifer48 , MiZ , DnNuke , Bjanes , Skymarshall , afkayas , elmopio ,
SiFLyiNG , Fire Worx , CrackZ , neural_en , WarezPup , _y , SiONIDE ,
SKORPIEN, Lazarus , Eternal_Bliss , Magic Raphoun , DEZM , Bisoux ,
Carpathia , K17 , theMc , noos , Xmen , TeeJi , JB007 , Arobas , T0AD ,ytc
Kwai_lo , Killer_3K, TaMaMBoLo , gizmo , Gota , ExtaBrain , Alpine ,
WarezPup, zoltan , [yAtes], TarGon , Icecream , Punkguy2 , Sortof,
TRDdonjuan, Lord Soth, Judged, G-Rom, Quantico, Christal, psike, Leo0n,
Albator, +Spath, +Frog's Print, toutim ,Pulsar , Night , psike, Uno , F|SH
Lixus , LosT, RD-116 , Ben0 , Whizkid , [MandKind], alpine , Alsindor ,
Stone , Elraizer , Fravia+ , Iczelion , nody , Asphalt , Rhythm ,
rudeboy ,X-Calibre , Cirus , shaoni...
...
"Mettez votre nom la! :P" ...
J'en ai surement oublier des tonnes de noms , desole ;)
Conclusion:
Et voila ainsi se termine ce *petit* cour de cracking ;)
J'espere avoir ete assez precis dans mes explications ainsi que mes exemples
et que ce cour vous as apporte quelque chose ...
Ce tut n'a aucune pretention si ce n'est d'exister , les commentaires et appreciations
sont donc les biens venus...
Certaines parties n'ont pas ete develope car , je veux pas ecrire un cour de 1000 pages
quand meme.
j'ai ete 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
Bonne année et bon bugs :P
TUTORIAL DEDICATED TO: Victoria (You rule baby and you own me :P )
"Mess with the best , die like the rest..."
MAIL ME CRACKS REQUESTS
AND I
^
| |
@#####@
(### ###)-.
.(### ###) \
/ (### ###) )
(=- .@#####@|_--"
/\ \_|l|_/ (\
(=-\ |l| /
\ \.___|l|___/
/\ |_| /
(=-\._________/\
\ /
\._________/
# ---- #
# __ #
\########/
SHOOT YOU
Tutorial par ACiD BuRN [Immortal Descendants ]
"Je crois que je vais aller dormir now :)"
ACiD BuRN's home page