Copy Link
Add to Bookmark
Report
Beef13 e-mag 01 03 Cracks Tips
/*************************************************************************/
/* Cracks tips */
/* by GonE */
/* */
/* public vise : tous ceux qui s'interessent au crack */
/*************************************************************************/
1) D'abord, il faut savoir comment pensent les programmeurs, et connaitre
les methodes qu'ils utilisent pour proteger un prog : Les methodes anti-hack
(note : c'est strictement impossible d'empecher un hack, mais on peut
le freiner).
Ben il doit y en avoir des chiees mais voici celles que j'ai trouvees
(je les ai pas toutes testees, et bcp sont sans effets) :
** Les methodes anti-debugging
- On lit l'heure, on fait un petit truc, on lit a nouveau l'heure,
et si il y a une difference de plus de 100 ms, on quitte discretement.
- On peut essayer de detourner l'interruption 3 (Pas a pas) qui pourrait
empecher un debugger de fonctionner (mais je suis pas sur, j'ai pas essaye).
- Chercher dans toute la memoire (enfin, 640 Ko) une chaine du genre
"Turbo Debugger", ou "Debug" et dans ce k, quitter. (je c, ca peut
etre un prog qui ct fini mais ca doit etre verifiable en regardant
la table d'allocation de la memoire).
- On cherche la variable d'environnement du dos CMDLINE. Si c'est par exemple
"td prog.exe", eh ben ca quitte. Malin, non ?
- On pklite le prog et on note sa taille pklite. Alors on le reecrit en testant
sa taille. S'il est superieur a un certain quotat, ben il quitte.
- Apres les fonctions pour quitter on met quelques fonctions pour faire
tout planter, histoire de faire chier le hacker.
- On teste la memoire disponible. Si elle est anormalement basse (si par ex
td est en memoire), en on quitte.
** Les methodes anti-decompile (aussi antidebug parfois)
- On code son code et ses data (par exemple par un not tout con, ou un add),
sauf la routine pour le decoder, au debut. On peut aussi le pkliter, cela
revient plus ou moins au meme.
- On met plein d'octets compliques (choisis au prealable), entre 2 lignes
de code qui font croire a des mnemoniques de la mort qui tue, et avec
de la chance, la 2e ligne de code sera associee avec des octets
precedents pour faire une supermnemonique.
- On se fabrique un programme pour masquer le nom des fonctions et des
variables, si votre compilateur a la mauvaise habitude de les stoquer
dans le exe. (c'est le k du BC31)
- Mettre du code un peu partout, par exemple dans les donnees, le stack,
le far heap, ou un autre fichier carrement. Mais bon c pa vraiment pratique.
** Les methodes anti-crack
- On a plein de variables globales qui sont modifiees lors de
l'appel de fonctions. Si apres l'appel de la fonction, on ne remarque
pas de modif, on quitte discretement.
** Les methodes anti-copy
- (Si on veut bien s'encombrer d'une disquette) on formate une disquette
non formatee (dur a trouver je c) sauf 1 secteur, le dernier, ou un
autre... Le prog verifie que ce secteur soit illisible.
- Ben mettre un dongle mais bon c'est depasse ca !
Dans les 2 k, il faut savoir modifier le .EXE et non pas la disquette, ou
se creer un dongle a la con.
** Les autres methodes
- Essayer de foutre la merde discretement chez le hacker quand on decouvre
une modif. Par ex, effacer toutes les fat du disque dur. Mais bon ils ne
font jamais ca, c'est vraiment salop. (mais efficace!!) Le hacker finira
bien par prendre sa revenche... Ou alors, on peut faire planter son
systeme totalement (DEF Bond pourra vous dire comment).
- S'envoyer un mail donnant les coordonnees du hacker (mais bon s'il a un
modem, ca se voit. Pas s'il est sur numeris ou cable)...
- Et puis si ca vous suffit pas, allez voir les methodes de ce programme, qui
detourne pas mal d'interruptions. Remercions son auteur anonyme. 'parait
que ca stoppe td.
>> ANTIDEBUG.ASM qui doit etre linke avec un prog en pascal
.386p
.MODEL TPASCAL
.DATA
oldint3 dd ?
anc_interrupt3 dd ?
.CODE
public PIQ_Stop_System
public Keyboard_off
public Keyboard_on
public No_Stepping
keyb_off macro
push ax
in al,21h
or al,02
out 21h,al
pop ax
endm
keyb_on macro
push ax
in al,21h
and al,0Fdh
out 21h,al
pop ax
endm
PIQ_Stop_System proc near
push ds
push ax
push bx
push cs
pop ds ; CS en DS
mov cs:word ptr [@int_21_fonct],4CB4h ; Fonction arreter le Programme
@int_21_fonct:
mov ah,30h ; Fonction lire la version du DOS
int 21h
pop bx
pop ax
pop ds
ret
PIQ_Stop_System endp
Keyboard_off proc near
keyb_off
ret
Keyboard_off endp
Keyboard_on proc near
keyb_on
ret
Keyboard_on endp
No_Stepping proc near
push ax
jmp @Nostep+2
@Nostep:
mov ds:byte ptr [06EBh],00
mov ax,4C01h
int 21h
pop ax
ret
No_Stepping endp
public protected_stopping
protected_stopping proc pascal
pusha
cli ; inhibe les interruptions
mov eax,cr0 ; active le mode prot,g,
or eax,1
mov cr0,eax
jmp PROTECTION_ENABLED ; efface le canal d'ex,cution
PROTECTION_ENABLED:
and al,0FEh ; r,tablit le mode r,el
mov cr0,eax ; ne remet pas _ z,ro le processeur
jmp PROTECTION_DISABLED ; efface le canal d'ex,cution
PROTECTION_DISABLED:
sti ; restaure les interruptions
popa
ret
protected_stopping endp
public Check_vector
Check_vector proc pascal check : dword;
mov bx,0
mov es,bx
mov bx,18
mov eax,es:[bx]
mov oldint3,eax
mov eax,check
mov es:[bx],eax
ret
Check_vector endp
public Vector_ok
Vector_ok proc pascal check : dword;
mov bx,0
mov es,bx
mov bx,18
mov eax,es:[bx]
cmp eax,check
je @check_ok
mov al,0
jmp @check_fin
@check_ok:
mov al,1
@check_fin:
ret
Vector_ok endp
public restore_Checkvector
restore_Checkvector proc pascal
mov bx,0
mov es,bx
mov bx,18
mov eax,oldint3
mov es:[bx],eax
ret
restore_Checkvector endp
public Copy_int21_int3
Copy_int21_int3 proc pascal
mov bx,0
mov es,bx
mov bx,18
mov eax,es:[bx]
mov anc_interrupt3,eax ; sauvegarde l'ancienne int 3
mov bx,84 ; charge l'int 21
mov eax,es:[bx]
mov bx,18 ; et la m,morise en int3
mov es:[bx],eax
ret
Copy_int21_int3 endp
end
>> Le .PAS qui y lie
BEGIN
clrscr;
writeln('Checksum sur Int3-Vector');
check_Vector(12345678);
writeln('desactiver Keyboard');
keyboard_off;
writeln('Stepping-piege');
no_stepping;
writeln('PIQ-Trick');
PIQ_Stop_System;
writeln('Protected-Mode switching');
Protected_stopping;
writeln('Vector-Checking');
If NOT Vector_Ok(12345678) then begin;
clrscr;
writeln('Non non, n''allez pas debugger !');
halt(0);
end;
writeln('retablir check-Vector');
Restore_checkVector;
writeln('Keyboard reconnecte');
keyboard_on;
writeln('Et voila ! Nous sommes dans le programme');
readln;
end.
2) Cracker un EXE, c'est aussi reperer quelques fonctions elementaires.
/* */
/*** Borland C++ DOS *******************************************/
/* */
//// REPERER MAIN
En general, il est assez proche du debut du fichier exe.
void main(int argc,char **argv)
cs:03AC 55 push bp
cs:03AD 8BEC mov bp,sp
il se finit par
cs:03B6 5D pop bp
cs:03B7 C3 ret
bon, je c presque toutes les fonctions se finissent comme ca..
ou alors
void main(void)
cs:034B C8120000 enter 0012,00 <- locals
cs:034F 56 push si
cs:0350 57 push di
il se finit par
cs:040A 5F pop di
cs:040B 5E pop si
cs:040C C9 leave
cs:040D C3 ret
attention : apres le ret de main(), en general, il y a plein de trucs
qui ne signifient rien.
//// QUAND ON QUITTE MAIN
fonction de sortie du programme : apres le ret de main
cs:015B 50 push ax
cs:015C E80303 call _exit
void exit(int status) c'est la fonction la plus rentable a reconnaitre.
cs:0462 55 push bp
cs:0463 8BEC mov bp,sp
cs:0465 33C0 xor ax,ax
cs:0467 50 push ax // bien noter les 2 push ax et push pile
cs:0468 50 push ax
cs:0469 FF7604 push word ptr [bp+04]
cs:046C E8A6FF call 0415 <- varie // et encore une fct..
cs:046F 5D pop bp
cs:0470 C3 ret
/// QUELQUES FONCTIONS CLEFS
int printf(...);
cs:1EC8 55 push bp
cs:1EC9 8BEC mov bp,sp
cs:1ECB B82E20 mov ax,202E
cs:1ECE 50 push ax
cs:1ECF B81402 mov ax,0214
cs:1ED2 50 push ax
cs:1ED3 FF7604 push word ptr [bp+04]
cs:1ED6 8D4606 lea ax,[bp+06]
cs:1ED9 50 push ax
cs:1EDA E852E8 call __VPRINTER
cs:1EDD 5D pop bp
cs:1EDE C3 ret
int getch();
cs:101A 803E8E0400 cmp byte ptr [__cFlag],00
cs:101F 740A je 102B
cs:1021 C6068E0400 mov byte ptr [__cFlag],00
cs:1026 A08F04 mov al,[__cChar]
cs:1029 EB05 jmp 1030
cs:102B B80007 mov ax,0700
cs:102E CD21 int 21
cs:1030 B400 mov ah,00
cs:1032 C3 ret
et si on cherche B8??4C, on a des chances de trouver ou le programme
quitte.
.. et vous pouvez continuer si ca vous amuse. Moi je prefere essayer de
debugger les progs a la con de defbond...
/*************************************************************************/
/* CONCLUSION ET MORALE */
/* */
/* Proverbe d'outrequeben : pierre qui roule n'amasse pas mousse */
/* Si vous elucidez la quadrature du cercle, emailez-moi */
/* Et reportez les bugs et les conseils a gone@caramail.com */
/**************************************************** GonE98 *************/
