Tutorial N°2 10-2-1999
Il nostro primo crack!!!
- Eccoci di nuovo qui, in questo secondo tutorial crackeremo il
nostro primo programa, ma quale?
- Bhè la risposta mi sembra ovvia, crackeremo uno dei nostri
tools, cioè Hex Workshop 2.54, ma bando alle ciance ed iniziamo....
- Avete insallato Softice e Hex Workshop? Se no l'avete fatto
allora provvedete.
- Avviate il programma e un nag-screen vi dirà che questa è
la prima volta che usate questo prodotto e che deve essere registrato, cliccate su ok e
vedrete in alto a destra una scritta: "Demonstration version" passateci sopra
con il mouse e vedrete che in realtà è un pulsante, bene bene cliccateci sopra e un box
farà la sua comparsa chiedendovi un serial number; questa è la protezione che andremo a
rimuovere...
- Premete ctrl+d e softice popperà sul monitor, come
potrete subito constatare il mouse non c'è ma è sostituito da un quadratino bianco, se
quel quandratino non si muove significa che avete sbagliato a settare la porta di
comunicazione durante il setup, riavviate l'installazione e cambiate, tornate di nuovo in
Softice (ctrl+d) e gurdatelo attenamente, noterete sicuramente delgli strani simboli e
vedrete anche che durante l'esecuzione del debugger non potrete interagire con Windows, la
prima cosa da fare è ottimizzare la finestra, per farlo potrete scaricare qui il mio file "winice.dat" e sostituirlo al vostro,
oppure potrete scrivere sempre in softice questi comandi: line 60
invio
-
wl invio
-
wc 45 invio
-
code on invio
-
wr invio
-
faults off invio
- Se non vorrete scrivere tutto questo ogni volta che riavviate
windows vi consiglio di scaricare il mio file oppure di modificare il vostro, sull
l'ottimizzazione e l'uso di Softice dedicherò il mio prossimo tutorial.
- Torniamo a noi, come si inizia a sbirciare il codice?
- E' semplicissimo, per prima cosa dovete identificare un
possibile punto d'attacco, ma noi questo l'abbiamo già fatto (mi riferisco al box che
chiede il serial number), poi dovete scoprire quale funzione utilizza il prg per prelevare
il testo dall'edit box, cercherò di essere più chiaro; allora, quando scriviamo un
numero e premiamo "Register" il programma và a "guardare" ciò che è
stato scritto, confronta quel risultato con quello reale e se sono uguali procede alla
registrazione, per carpire il testo si usa in genere una funzione chiamata
"GetWindowTextA", la "A" finale stà ad indicare che la funzione presa
in considerazione è quella a 32-bit e non a 16.
- Come si fà a sapere se un prog. usa una funzione oppure
un'altra?
- Per scoprirlo possiamo fare due cose: andare a tentoni oppure
cliccare col pulsante destro del topo sul file e andare su anteprima (se non c'è si deve
installare e si trova sul cd di windows), apparirà tutta una lista delle funzioni che
utilizza.
- Ma andiamo a registrare il prg, premiamo ctrl+d (da ora in
poi scriverò ^D) e scriviamo: bpx getwindowtexta.
- ***
- Ma cosa significa questo oscuro comando?
- Bhè vediamolo: bpx significa breakpoint on execution e
getwindowtexta è la funzione sulla quale vogliamo brekkare, in parole povere non facciamo
altro che chiedere a Sice di generare un'interruzione (che farà apparire la schermata del
debugger) quando Hex-Workshop giunge su quella funzione, in pratica il breakpoint è una
"trappola" che useremo praticamente sempre per fare ingresso nel codice di
qualunque prg.
- Tanto per capirci possiamo dire che spesso useremo
l'istruzionebpx messageboxA per far poppare Sice quando ci viene mandato il box con su
scritto: Insert the correct password.....The number is incorrect ecc.....
- Se avete problemi o non avete capito qualcosa scrivetemi ed
io cercherò di aiutarvi.
- ***
- Premiamo invio e poi scriviamo X oppure premiamo F5 per
tornare a win. A questo punto utilizziamo un cosidetto dummy number, cioè un numero che
utilzzeremo spesso come "fake number", io uso sempre 666111666, inseriamo quindi
questo numero nell box e premiamo ok!
- Come speravamo vediamo Softice che fa la sua comparsa, adesso
ci saranno una serie di numeri e scritte probabilmente incomprensibili, non vi preoccupate
perchè presto impareremo a conoscerle.
- Premiamo una volta F11 (serve per tornare da una chiamata ad
una routine), 3 volte F12 (questo comando esegue una funzione finchè non trova
l'istruzione "RET" che significa return),, 22 volte F10 (questo serve per fare
single-step in una funzione, in pratica con F10 si procede passo passo nel codice)
- e scriviamo: r fl z.
- ***
- Riassumiamo il tutto:
- F12: Esegue una funzione finchè non trova un'istruzione di
ritorno
- F11: Torna da una chiamata alla rispettiva routine
- F10: Esegue ogni singola istruzione, in questo modo
procediamo passo passo nel codice.
- F8: Esegue semplicemente un'istruzione, viene in genere usato
per seguire qualche chiamata (CALL) importante.
- Una volta che saremo nel codice premeremo quasi sempre F11
come primo tasto e poi a seconda dei casi utilizzeremo F12 e F10.
- F5: Torna a Winzoz.
- r fl z: Questa istruzione è parecchio importante ed userò
un breve esempio per spiegarla: quando la barra bianca del debugger passa su un jump (sono
tutti jump quelle istruzioni che iniziano con la "J" come JMP, JNE, JAE, JB,
JC...) sulla destra appare una scritta del tipo: "JUMP" oppure "NO
JUMP", bene, con questa istruzione cambiamo il valore del flag Z, cioè trasformiamo
la scritta "JUMP" in "NO JUMP" e viceversa, tutto ciò è molto utile
nel caso che ci sia un salto dopo un'istruzione che controlla l'esattezza di un numero
seriale (cioè la funzione salta se il seriale è esatto oppure non salta e ci manda
il messaggio di errore), infatti con r fl z potremmo costringere la funzione a saltare e
quindi anche a registrare il prg....;))
- ***
-
- Premiamo F5 (scriviamo un user name e una company a piacere)
e possiamo felicemente constatare che il programma è stato registrato.
- Adesso vi spiegherò il codice che avete visto cosa
significava.
- Dopo aver premuto tutti quei tasti vi siete trovati davanti a
delle righe simili a queste:
- Attenzione i numeri prima dei due punti non sono stati
inseriti poichè i vostri saranno sicuramente diversi. Ricordate anche che le istruzioni
JZ (jump if zero) e JE (jump if equal) oppure JNZ (jump if not zero) e JNE (jump if not
equal) sono equivalenti e che il W32DASM sostituisce sempre JZ con JE e JNZ con JNE.
- # significa: "numero" quindi #3 è = a
"numero 3"
- :0042625B
E8CC4E0200 call 0044B12C
- :00426260 8B8DFCFEFFFF mov
ecx, dword ptr [ebp+FFFFFEFC]
- :00426266 83C164
add ecx, 00000064
- :00426269
E812BAFDFF call 00401C80
- :0042626E 50
push eax
- :0042626F 8D45DC
lea eax, dword
ptr [ebp-24]
- :00426272 50
push eax
- :00426273
E8C82D0100 call 00439040
- :00426278 83C408
add esp, 00000008
- :0042627B
68E8F74700 push 0047F7E8
- :00426280 8D45DC
lea eax, dword
ptr [ebp-24]
- :00426283 50
push eax
- :00426284
E867450100 call 0043A7F0
- :00426289 83C408
add esp, 00000008
- :0042628C 85C0
test
eax, eax<--- controlla il # vero con il nostro
- :0042628E 0F8414000000
je 004262B3<-- se il # è vero salta a 004262B3 (ricordate l'esempio dell'istruzione
"r fl z" ?)
- :00426294 8D45DC
lea eax, dword
ptr [ebp-24]
- :00426297 50
push eax
- :00426298
E823110100 call 004373C0
- :0042629D 83C404
add esp, 00000004
- :004262A0 8945EC
mov dword ptr
[ebp-14], eax
- :004262A3
E907000000 jmp 004262AF
- :004262AF
837DEC00 cmp dword ptr
[ebp-14], 00000000
- :004262B3 0F8479000000 je
00426332<--ricontrollalo e registra se vero
- :004262B9 8B8DFCFEFFFF mov
ecx, dword ptr [ebp+FFFFFEFC]
- :004262BF 83C164
add ecx, 00000064
-
- Bene bene, vediamo cosa abbiamo fatto: immaginate un omino
che di mestiere fa il corridore, qualcuno (la funzione) gli dice dove deve andare, gli dà
un foglio con un numero (666111666) e gli dice anche di seguire le indicazioni, l'omino
parte e trova una lettera, la apre e controlla (test eax, eax) il suo numero con quello
della busta, un indicazione (je 004262B3) gli dice di saltare ad un altro pezzo di strada
se il suo numero è uguale a quello della busta, nel nostro caso l'omino continua a
correre finchè non incontra un'altra indicazione (cmp dword ptr....., 00000000) che gli
dice dice di controllare "SE" il suo numero è sbagliato, se non lo è un'altra
indicazione (je 00426332) gli comunica che può arrivare al traguardo usando qualche
scorciatoia (va bene così aLoNg3x? ;) ), questa spiegazione credo sia stata più
facile da capire.
- Potremmo riassumere la storia dell'omino in questo modo: il
corridore arrivato al segnale je 00426332 (je= jz e jz= jump if zero) è stato
gabbato da un furfantello (io il cracker) che ho cambiato momentaneamente le lettere
trasformando "je" in "jmp" cioè jump, che significa: "Qualunque
numero hai prendi una scorciatoia!"
- Bello ehh? Si, un'ultima cosa e poi vi faccio
riposare: il comando "r fl z"
cambia solo momentaneamente il valore del flag, in pratica solo fino al riavvio
del programma, se volessimo diffondere un crack, dovremmo creare un file che
cambi il "je" in "jmp" ciò può essere fatto anche con l'editor
esadecimale (ma nel nostro caso non è necessario) vi spiegherò tutte le tecniche
nei prossimi tutorial.
- Ciao e buon crack a tutti.
- Piccola nota:
- In genere tutti i prog. hanno un # check all'avvio,
in pratica controllano che il numero di registrazione sia esatto, questo serve
ad evitare che chiunque possa inserire un numero qualsiasi e registare il prg.
- Hex-Workshop a registrazione esatta crea un file di
registro (Hexworks.reg) dove inserisce tutte le informazioni, il file assume
questa forma:
- *********************************************
- * 666111666 Quequero
*
- *
CrackZ Corp. *
- *
KîÒ *
- ***************************************
- Ovviamente asterischi esclusi!!!
- Una volta creato il file il prg non mostra più la scritta
"Unregistered" ne il pulsante di registrazione "Demo Version".
-
Quequero
-
- Vorrei ringraziare aLoNg3x per
avermi
- dato acluni consigli su questo
tute...
- Grazie aLo ;)))