Cracking manual
by S2
1. Prefazione
Per iniziare vorrei subito dire che tutto quello che segue
non è assolutamente da prendere sul serio e non è assolutamente
da fare o provare. Anzi, è assolutamente illegale, e quindi, se
non volete dire "ciao" a un pulotto che suona al vostro
campanello>
Trasferimento interrotto.
diventati
pirati informatici non fatelo.
Bene bene bene... Detto questo un ciao a tutti voi che avete una gran voglia di fottere tutti quei programmini Shareware del cazzo che dopo trenta giorni di evaluation non funzionano più, o quelli che danno possibilità limitate a meno che non inseriate la mistica password associata all'user name inserito ecc... vi siete proprio rotti le balle... vero? Io almeno, confesso che me le sono rotte, e quindi... aguzzo l'ingegno e inculo tutte quelle softwarehouse che ti chiedono 20$ per il loro programma. Ma se vi devo dire la verità non lo faccio solo per questo, ma anche per un altro motivo: Quando riesco a mettere insieme tutti i pezzi del puzzle, e vedo sullo schermo del mio bel pc una finestrella che mi dice "Tnx for registering" mi sento un grande. Perché penso di essere uno dei pochi su questa faccia della terra a essere in grado di farlo, e quindi mi sento un figo. Comunque, quando poi ripenso ai 20$ risparmiati sono ancora più felice... Quindi questo manuale non è da vedere come un manuale al crackaggio, ma più come un manuale della felicità... che umorista che sono... io non devo passare tutte queste ore davanti al pc... poi mi metto a scrivere stronzate del genere... sono proprio fuso... vabbè... mi accendo una cicca, va'.
In ogni caso questo non è un manuale di Assembler, quindi non aspettatevi particolari sull'asm, quelli li trovate in inglese in giro per Internet, ma è una guida al crackaggio. Quello che voglio insegnare non è come trovare le password associate agli user name, ma semplicemente come avere l'accesso. Per riuscire a scoprire la password, avete bisogno di conoscere un sacco di asm e soprattutto dovete farvi un pacco così di matematica... ma questo è un altro file... forse in futuro ve lo scriverò... Adesso andiamo al sodo e cominciamo:
2. Breve introduzione all'Assembler
Allora. Per crackare un programma bisogna disassemblarlo,
cioè tradurre il programma .exe o .com in una lista di
istruzioni da noi comprensibili, per poi modificarlo in modo da
fargli credere di aver inserito la password giusta, o che i 30
giorni non sono passati e così via. Siccome per disassemblare i
programmi da crackare si usa il SoftIce, che disassembla i
programmi in Assembler (asm), bisogna sapere questo linguaggio.
Voi direte, "ma non possiamo tradurre il programma in
italiano, così lo capiscono tutti?". E io vi rispondo, ci
sto lavorando, ma quando avrò finito lo distribuirò in una
versione Shareware incrackabile! Tjè!
Ok. Ora vi spiego un po' come funziona l'Assembler:
2.1 I registri
La CPU del computer è divisa in diversi registri, che ora vi
spiego uno per uno cosa sono e come si chiamano, e servono per
memorizzarci dei dati. I registri in tutto sono quattro, e si
chiamano
AX - Accumulatore
BX - Base register
CX - Contatore
DX - Data register
Ognuno di questi registri può essere suddiviso in una parte alta e una bassa. Per esempio AX si suddivide in AL (Low) e AH (High). Nella CPU del Pentium, che lavora a 32 bit, i registri si chiamano EAX, EBX e così via. Mi spiego meglio con questo schemino:
AL = 8 Bit (parte bassa del registro AX)
AH = 8 Bit (parte alta del registro AX)
AX = 16 Bit (formato da AL e AH messi insieme)
EAX = 32 Bit (formato da AX e altri 16 Bit che però non sono
direttamente acessibili dall'utente)
Ovviamente questa suddivisione vale anche per
BX, CX e DX.
Poi ci sono i segment register:
CS - Vuol dire Code segment. E' l'area di memoria nella quale si trova il programma che state modificando. L'indirizzo CS:IP è l'istruzzione che state per eseguire.
DS - Il Data segment. La parte di memoria nella quale si trovano i dati. La CPU di solito vi accede solo in lettura.
ES - Extra segment. In questa area di memoria la CPU vi accede in scrittura.
IP - Instruction pointer. E' l'indirizzo dell'istruzione che state per eseguire.
SS - Stack segment. Questa è roba complicate... non vi serve per i vostri scopi crackistici.
SI - Source Index. E' un puntatore.
DI - Destination index. Un'altro puntatore.
BP - Base pointer. Questo viene usato insieme allo SS.
SP - Stack pointer. Serve a puntare una locazione all'interno dello Stack. E' usato insieme a SS.
Questi sono i registri della CPU, le informazioni qui riportate, non sono complete, ma non starò neanche quì a completarle, perché per i nostri loschi scopi non sono di importanza rilevante. Se proprio volete saperne di più andate a leggervi una delle tante guide sull'Assembler che si trovano in giro per Internet, o forse, se avete culo, nella sezione links di questo sito.
2.2 I flag
Servono ad indicare se un jump condizionale (vedi sezione
istruzioni) deve essere eseguito o no. Per esempio
CMP AL, BL ........... Confronta il registro al
con bl
JZ 3F1D ................... Salta se zero a 3F1D
La prima istruzione esegue un confronto tra AL
e BL. Se sono uguali il flag Z diventa 1 (attivo), nel caso
contrario invece, 0 (disattivo).
La seconda istruzione salta all'indirizzo specificato se il flag
Z è 0.
Se per esempio in AL abbiamo il numero di giorni da quando stiamo
usando il programma, e in BL, il numero di giorni che il
programma deve funzionare, modificando il flag zero possiamo far
credere al programma che i giorni ancora non sono finiti, e
quindi possiamo continuare ad usare il programma. Capito?
Mettiamo il caso:
AL = 3 .................... Stiamo usando il
prog. da 3 giorni
BL = 1E .................. (1E = 30 in Hex) Per quanti giorni
possiamo usare il prog.
Premesso questo, ora eseguiamo i comandi:
CMP AL, BL ........... Confronta il 3 con il
30d
JZ 3F1D .................. Se i due sono uguali (tutti e due 30,
flag Z = 1) salta a 3F1D e ci dice di registrare il programma
Tutto chiaro? Penso di si... queste sono cazzate da capire in fondo, credo.
2.3 Le istruzioni
MOV Dest. Source - Sposta un valore da Source a Dest. Per
esempio MOV AL, BL - Sposta il contenuto di BL in AL.
CMP var1, var2 - Confronta i due valori di var1
e var2. Per esempio CMP AL, BL - Confronta il contenuto di AL con
quello in BL. Semplice no? Bè... questa istruzione funziona come
una sottrazione: il valore in var2 viene sottratto da var1.
Cioè, se ho 3 in AL, e 8 in BL, il risultato sarà 3 - 8 = -5.
Il flag Carry (C) si attiverà (questo flag si attiva ogni volta
che il numero è negativo).
Nel 99,9% dei casi questo comando viene usato per confrontare la
password da voi inserita e quella giusta, oppure come
nell'esempio sopra, i giorni trascorsi, e quelli trascorribili
(ma esiste questa parola?).
JMP label - Questa è l'istruzione più bella.
Esegue un salto all'indirizzo specificato. Lo troverete, di
solito dopo un CMP. Ci sono diverse variazioni di questo comando,
che ora vi elencherò, e vanno tutte a controllare i flag Z, O,
S, C e P. Nella sua forma più semplice è JMP label, cioè,
salta a label qualsiasi siano i valori dei flag.
Ponendo il comando CMP AX, BX, abbiamo:
JNZ - Jump if not zero, AX diverso da BX
JZ - Jump if zero, AX uguale a BX
JB - Jump if below, AX < BX, C = 1
JA - Jump if above, AX > BX, C = 0
JNGE - Jump if not greater or equal, AX<=BX, S diverso da 0
JGE - Jump if greater or equal, AX=>BX, S = 0
JLE - Jump if less or equal, AX<=BX, Z=1 o S=F
Che palle! Vabbè... cen'è altri di 'stì JMP, ma non credo che vi servano per i vostri loschi scopi, quindi non preoccupatevi... anche se non li sapete non cambia un cazzo. Comunque, se proprio vi interessano li trovate in un qualsiasi manuale di Assembler in giro per Internet, o comunque nella lista dei link di questo sito qualcosa per voi c'è...
CALL label - Richiama una routine che si trova all'indirizzo specificato con label. Per esempio CALL 1F3D, esegue la routine a CS:1F3D. Poi, eseguendo la routine, quando trova un'istruzione RET torna all'istruzione dopo CALL. Facile no? Di solito, quelle chiamate con CALL sono delle routine che controllano il testo da voi inserito, oppure criptano la password che avete inserito ecc.
INT n - Esegue un'interruzione. Un'interruzione è come una routine, però non è nel programma, ma da qualche parte nel DOS, o nel BIOS, dipende dalla n. Per esempio quei giochini vecchissimi che chiedevano il KeyDisk inserito usavano l'int 13 per vedere se c'èra il dischetto inserito o no ecc. Comunque cazzate... in Windows gli INT non esistono quasi più.
That's it. Questi sono i comandi principali dell'asm. Spero che gli abbiate capiti, perchè senza questi poi non ci capirete una minchia nel SoftIce. Anzi... se volete approfondire, c'è il Assembly language foundamentals tutorial che aspetta solo di essere letto e studiato. I comandi che vi ho dato qui sono pure pochi, ma comunque quelli più importanti.
3. L'uso del debugger
Ok. Aspettate un'attimo che mi accendo una cicca... fumo
troppo... ma vabbò. Per spiegarvi come funziona il SoftIce vi
traduco semplicemente le parti più importanti della guida che
trovate anche compattata nel file SoftIce.zip. Così risparmio la
fatica di pensare ai comandi.
Allora... intanto i consiglio di mettere una robe del genere alla
fine del vostro Autoexec.bat:
choice /tn,2 Caricare softice?
if errorlevel 2 goto win
c:\softice\winice (quì mettete la righa che vi aggiunge il
SoftIce nell'installazione)
goto end
:win
choice /ts,1 Caricare windows?
if errorlevel 2 goto end
win
:end
Ed ora passiamo ai comandi principali del SoftIce:
3.1 I comandi del SoftIce
E' impossibile debuggare bene senza sapere come funzionano i
BreakPoints (Bp). Un bp è un'istruzione per la cpu che le dice
di fermare l'esecuzione del programma dopo un accesso ad una
certa locazione di memoria, oppure dopo certi eventi del
programma stesso e dà il controllo al debugger. Quando setti un
bp del SoftIce e poi torni al programma che stai usando, SoftIce
compare automaticamente quando la condizione per la quale è
settato il bp è verificata.
3.1.2 BreakPoint
Bc # : Clear Breakpoint--elimina un breakpoint messo in
precedenza nel Soft-Ice; devi sapere il numero del bp...
Bd # : Disable Breakpoint--disabilita il bp ma non lo cancella; devi sapere il numero del bp...
Be # : Enable Breakpoint--abilita il bp che hai disabilitato in precedenza; devi sapere il numero del bp...
Bl : List Breakpoints--mostra una lista di tutti i bp settati nel softice, il loro stato (abilitato, disabilitato), e il loro numero.
Bmsg : Break on Windows Message. Sintassi: BMSG window handle L begin-message end-message
Bpint : Break on Interrupt. Funziona solo con le interruzioni trattate da IDT (95/NT). Sintassi: BPINT int-number
Bpio: Si ferma quando c'è un accesso in lettura o scrittura ad una porta I/O con un certo indirizzio. Sintassi: BPIO port [R|W|RW] [EQ|NE|GT|LT|M value] [c=count]
Bpm: Si ferma quando c'è un accesso alla memoria in lettura (read), strittura (write), o esecuzione (execution). Sintassi: BPM[B|W|DW] address [R|W|RW|X]
Bpx : Break on execution. Sintassi: BPX address/symbol [c=count] [EQ|NE|GT|LT|M value] [c=count]
Bpr : Break on memory range. Sintassi: BPR start-address end-address [R|W|RW|T|TW] [expression]
Bprw : Break on program/code segment. Sintassi: BPRW module-name|selector [R|W|RW|T|TW] [expression]
3.1.2 Steppare attraverso il programma
Debuggare in sé vuol dire eseguite una istruzione alla volta
di un programma in modo da poter vedere come cambiano la memoria,
i registri, i flags e le variabili. I principali comandi per
farlo sono:
P : Esegue una istruzzione e vede le CALL come una istruzzone sola. Shortcut: il tasto F10.
P RET : Esegue il programma finche non trova un'istruzione RET. Shortcut: il tasto F12.
T : Esegue una istruzzione. Shortcut: il tasto F8.
3.1.3 Visualizzare informazioni sul sistema
Addr : Visualizza o cambia ad un contesto di indirizzi.
Class : Visualizza informazioni sui Windows Classes.
CPU : Visualizza i registri della CPU.
Exp : Carica/Visualizza i simboli esportati da un DLL.
GDT : Visualizza la Global Descriptor Table.
Heap : Visualizza i Global Heap di Windows.
Heap32 : Visualizza/attraversa i Global Heap di Windows.
HWND : Visualizza informazioni sui Windows Handles.
IDT : Visualizza la Interrupt Descriptor Table.
LDT : Visualizza la Local Descriptor Table.
LHeap : Visualizza i Windows Local Heap.
Map32 : Visualizza una mappa di memoria di tutti i moduli a 32bit caricati in memoria.
MapV86 : Visualizza la mappa di memoria DOS memory della macchina virtuale corrente.
Mod : Mostra la Windows Module List.
Page : Mostra le Page Table information.
Proc : Visualizza informazioni su un processo.
Stack : Visualizza una call stack.
Sym : Imposta o visualizza un Symbol.
Task : Mostra Windows Task List.
VCall : Mostra i nome e indirizzi di una routine VxD chiamabile con CALL.
VM : Visualizza informazioni sulle macchine virtuali.
VXD : Visualizza la mappa Windows VXD.
.VMM : Chiama il VMM Debug Informational Services menu.
.VPICD : Chiama il VPICD Debug Information Menu.
.VXDLDR : Mostra informazioni VXD.
WMSG : Visualizza i nomi e numeri dei messaggi Windows.
Comunque, se questi dati non vi bastano,
troverete la guida citata sopra compattata nel zip che potete
scaricare dalla pagina Utilitys di questo sito.
Inoltre, cosa molto importante, che stavo quasi per dimenticarmi,
c'è da dire che nel SoftIce ci entrate con CTRL-D. Figo, no?
4. Iniziamo a crackare
Benebenebene... adesso che vi siete sorbiti tutte le cazzate
qui sopra citate, sapete come funziona il SoftIce e anche un po'
di asm, contenti? Ok. Possiamo iniziare con una cosa molto
semplice e anche abbastanza inutile: la password dello Screen
Saver di Windows. E' l'unica cosa che penso abbiano tutti nel
loro Windows, così evitate di andare a scaricare prog. che
magari neanche volete, solo per provare ad crackarlo. Ok? Sono un
bravo ragazzo o no?
Iniziamo. Caricate il SoftIce, andate nel pannello di controllo,
scegliete vi uno screen saver e impostate una password... una a
caso, tanto ora la rendiamo inutile. Aspettate che lo SS (polizia
militare tedesca) entri in funzione, inserite una pw sbagliata e
entrate nel Softice con CTRL-D. Ok. Ora siamo nel Debugger.
Adesso c'è un problema... dobbiamo intercettare una funzione di
Windows. Cioè quella che legga il testo da noi inserito nella
casella di testo della pw. Per fare questo innanzitutto dobbiamo
sapere in che programma è la finestrella con la casella di testo
interessata. Digitiamo TASK e il SoftIce ci da una lista di
programmi al momento attivi. Uno di questi è (nel mio caso)
"oggetti volanti". Io ho scelto questo ss, ma immagino
che il vostro sia un'altro. Comunque, se non siete proprio
cretini, nella lista di prog. che vi da, troverete quello dello
ss. Fatto questo, c'è da fare una piccola nota sul funzionamento
di Windows. Qualsiasi cosa vedete sullo schermo (un pulsante di
Ok, la X nella parte destra-alta delle finestrelle di Win, una
casella di testo, ...) è un handle di Windows. Sono chiamati
così. La casella di testo nella quale noi abbiamo inserito la pw
è un handle. Nel SoftIce è possibile visualizzare tutti gli
handle attivi al momento con il comando HWND. Digitandolo,
vedrete una lista di tutti gli hwnd attivi di tutti i programmi.
Di ogni hwnd il SoftIce da informazioni sull'numero del hwnd, il
programma nel quale si trova e il suo nome. Noi siamo a caccia di
un hwnd chiamato EDIT, visto che è una casella di testo. Nella
lista troverete proprio l'edit che vi serve (il prog.
"Oggetti Volanti" ne visualizza uno solo).
Ora dobbiamo solo intercettare la funzione di Windows che legge
il testo contenuto in quella casella e ci ritroveremo esattamente
nella routine da fottere. Per fare questo settiamo un bp con il
seguente comando: BMSG num_hwnd WM_GETTEXT per num_hwnd,
ovviamente, dovrete inserire il numero del handle che vi da
SoftIce (il primo a sinistra). WM_GETTEXT invece è un messaggio
di Windows che legge un testo da una casella di testo.
Dopo che avete inserito il comando nella righa di comando del
SoftIce, date l'invio e tornate allo Screen Saver con CTRL-D.
Cliccate su Ok per confermare la vostra pw sbagliata e... magia!
Riappare il SoftIce e vi trovate nella routine BOZOSLIVEHERE (un
piccolo scherzo della MicroSoft, credo... cretini...) di USER.
Però, come potete vedere nella parte bassa della finestra del
codice, non siamo nel programma da noi desiderato (quello dello
Screen Saver) ma in USER, del quale non ce ne frega un cazzo, e
quindi steppiamo attraverso il codice, premendo F12, fino ad
arrivare a Kernel.Alloc. Ogni volta che arrivate a Kernel.Alloc,
sappiate che dopo il prossimon F12 che premete siete nel vostro
programma. Premiamo un'altra volta l'F12 e ci troviamo nel bel
mezzo di PASSWORD!.text. Così ora sappiamo anche che lo Screen
Saver usa l'estensione del Pannello di Controllo PASSWORD.CPL per
gestire le password. Iniziate già un po' a sentirvi dei fighi?
Andiamo avanti. Guardatevi bene il codice:
0137:7C45428F CALL [7C4582BC] ......................... La call dalla quale siamo appena usciti
0137:7C454295 TEST EDI, EDI ................................ Controlla cosa c'è in EDI
0137:7C454297 JNZ 7C4542B1 ................................ Un JMP condizionale
0137:7C454299 LEA EAX, [EBP-04]
0137:7C45429C LEA ECX, [EBP-14]
0137:7C45429F PUSH EAX
0137:7C4542A0 PUSH ECX
0137:7C4542A1 CALL 7C454536 ............................... Chiama una Routine
0137:7C4542A6 TEST EAX, EAX ............................... Controlla cosa c'è in EAX
0137:7C4542A8 JZ 7C4542DE ..................................... Un'altro JMP condizionale
0137:7C4542AA MOV EAX,00000001
0137:7C4542AF JMP 7C454322 .................................. Con questo JMPi sicuramente...
Ok... Ci sono due CALL, e subito dopo le
rispettive CALL, i rispettivi JMP. A me viene da pensare (a me
perché di programmi ne ho visti tanti...) che una controlla la
lunghezza della pw e l'altra i caratteri. Ma ovviamente questo
non si può sapere... è solo un'intuizione che viene dopo kili
di programmi sorbiti con il passare degli anni. Ma tanto a noi
non ci frega di cosa fanno le call. Steppando attraverso il
codice vediamo che almeno uno dei due jump ci fa saltare, quindi
probabilmente, la parte del programma che ci ridà accesso al
Desktop si trova all'indirizzo 0137:7C4542AF (l'ultimo JMP).
Quindi, arrivati al primo JMP (JNZ 7C4542B1) noi non vogliamo
saltare: premiamo F10 fino a quell'istruzione e mettiamo il flag
Z a 0. Andiamo avanti con F10 fino al secondo JMP (JZ 7C4542DE) e
settiamo il flag Z a 1 per non saltare neanche questa volta. Ok.
Fatto. Ora possiamo tornare al programma premendo CTRL-D. Lo
Screen Saver è sparito e noi abbiamo riguadagnato l'accesso
all'Desktop anche se abbiamo inserito la pw sbagliata.
Dite la verità. Vi sentite dei grandi ora o mi sbaglio?
Ora forse non avrete capito perfettamente tutto quello che c'è scritto quì sopra, ma vi assicuro che se seguite i passi nell'esempio, piano piano capirete come fare a crackare anche altri programmi. Ora vi chiederete: "cosa sarà mai quel WM_GETTEXT???". E' un message brake di Windows. Nel senso che c'è una parte in Windows che usa questo simbolo per leggere il testo da voi inserito nella casella di testo. Comunque ora vene do anche altri, per i pulsanti di Ok e altre cose.
5. BreakPoints utili
Per prima cosa, per poter usare i seguenti bp (WM_GETTEXT
compreso) dovete editare il file WINICE.DAT nella directory di
SoftIce e includere gli exports di
gdi32.dll
kernel32.dll
user32.dll
questi tre per ora dovrebbero bastare, comunque
sappiate che potete aggiungere anche gli altri dll e exe che vi
interessano.
I bp che seguono sono tutti da settare con Bpx nel SoftIce.
5.1 Lettura e scrittura sui file
Questi che seguono sono gli API calls di Windows più comuni.
Sono CALL generiche di accesso a file (di solito in binario) in
lettura e scrittura
ReadFile
WriteFile
L'accesso ai file avviene con le seguenti routine
SetFilePointer
GetSytemDirectory
GetSytemDirectoryA
Per leggere e scrivere sui file INI le CALL da
intercettare sono le seguenti:
per applicazioni a 16bit
GetPrivateProfileString
GetPrivatProfileInt
WritePrivateProfileString
WritePrivatProfileInt
per applicazioni a 32bit
GetPrivateProfileStringA
GetPrivatProfileIntA
WritePrivateProfileStringA
WritePrivatProfileIntA
5.2 Interrupt
Accesso ad un file
bpint 21 - con ah = 3d
bpint 2f - con ah = 01
5.3 Il Registry
Crea o elimina una key nel registry (quelle con A alla fine
sono per applicazioni a 32 bit)
RegCreateKey
RegDeleteKey
RegCreateKeyA
RegDeleteKeyA
Leggi un valore da una Key correntemente aperta nel registry
RegQueryValue
RegQueryValueA
Apre o chiude una Key nel registry
RegCloseKey
RegOpenKey
RegCloseKeyA
RegOpenKeyA
5.4 Finestre di dialogo
Legge testo o un numero da una finestra di dialogo edit
(quelle con A alla fine sono per applicazioni a 32 bit)
GetWindowText
GetDlgItemText
GetWindowTextA
GetDlgItemTextA
GetDlgItemInt
Quando si apre una finestrella di messaggio, di solito una di quelle che dice "registrazione non valida" o qualcosa del genere, dovete intercettare queste CALLs
MessageBox
MessageBoxA
MessageBoxExA
MessageBeep
5.5 Data e ora
Queste sono particolarmente utili per i programmi che non
funzionano più dopo un paio di giorni
GetSystemTime
GetLocalTime
SytemTimeToFileTime
5.6 Creazione di una finestra
CreateWindow
CreateWindowExA
ShowWindow
bitblt (è una roba simile a hmemcpy... sposta e muove memoria in giro)
5.7 CD-ROM
Molto utili per i check del CD-ROM.
GetDriveType (se EAX è 5, allora è un CD-ROM check)
GetDriveTypeA (per le app. a 32 bit)
eseguite le CALL, in EAX c'è un valore, ed è da interpretare nel seguente modo:
0 ............. Drive cannot be determinated
1 ............. root dir does not exist
2 ............. DriveRemoveable
3 ............. A fixed disk (HD)
4 ............. Remote drive (NetWork)
5 ............. Cd-Rom drive
6 ............. RamDisk
5.8 Altri BreakPoints
Questi li potete usare quando il resto non funziona... sono
dei bp, che, in generale, funzionano
BozosLiveHere (ve lo ricordate?)
HMemCpy (quello citato sopra. sposta variabili, di solito stringhe, in giro per la memoria)
GlobalGetAtomName
5.8 I messaggi
Questi sono da settare con BMSG nel SoftIce (non con BPX).
WM_GETTEXT (un handle di testo)
WM_COMMAND (quando premi un pulsante di Ok)
Penso che sappiate come usarli questi... ve lo
ho spiegato sopra... comunque lo ripeto:
BMSG hwnd_num WM_COMMAND, per esempio. Per hwnd_num, ovviamente,
dovete inserire il numero dell'handle trovato con il comando HWND
del SoftIce.
Questi sono i bp più utili che potete settare. Non dovete impararli a memoria... dopo un pò li saprete per i cazzi vostri. Ma sarebbe bene che ve li leggiate, così sapete che esistono e sapete che potete usarli quando vi servono.
6. Il patch
Cos'è un patch? Semplicemente un programma che faccia da
solo il cracking di un prog. Nel esempio dello Screen Saver per
esempio, il programma deve cambiare in NOP (No operation) i due
jump condizionali. Il risultato finale sarà:
0137:7C45428F CALL [7C4582BC] ......................... La call dalla quale siamo appena usciti
0137:7C454295 TEST EDI, EDI ................................ Controlla cosa c'è in EDI
0137:7C454297 NOP ................................................. Niente più jmp condizionale, ma un nop (non dobbiamo saltare).
0137:7C454298 NOP ................................................. I NOP sono due perché i byte che occupa l'istruzione che c'era prima erano il doppio di un NOP
0137:7C454299 LEA EAX, [EBP-04]
0137:7C45429C LEA ECX, [EBP-14]
0137:7C45429F PUSH EAX
0137:7C4542A0 PUSH ECX
0137:7C4542A1 CALL 7C454536 ............................... Chiama una Routine
0137:7C4542A6 TEST EAX, EAX ............................... Controlla cosa c'è in EAX
0137:7C4542A8 NOP .................................................. Stesso discorso di sopra
0137:7C4542A9 NOP
0137:7C4542AA MOV EAX,00000001
0137:7C4542AF JMP 7C454322 .................................. Il jmp che ci fa saltare alla routine di sbloccaggio
Questo è il programma come dovrebbe essere dopo il crack, quando lo disassemblate. Chiaro? Ora... per cambiare il jmp con un NOP, non dobbiamo fare altro che prendere nota dei byte originai, cioè quelli con i jmp come erano all'inizio, poi cambiarli con i nop, e prendere nota del cambiamento dei byte. Per vedere l'istruzione disassemblata, in SoftIce, si usa il comando CODE ON, che vicino ad ogni istruzione, vi mostra i byte che le rappresentano. Facile no? Ho scritto, solo per voi, un patch universale in Basic (linguaggio del cazzo ma veloce, intuitivo, e soprattutto facile, per voi che non ci capite una sega) che vi riporto qui sotto, così lo compilate diversamente ogni volta che crackate un programma. Per usarlo dovete conoscere l'offset dei byte da cambiare, che potete trovare con un Hex editor (lo trovate nella pagina Utilitys di questo sito), i byte del file originale e quelli dopo il crackaggio. Ok. In oltre vi sarei molto grato se lasciaste le righe in cui ci sono i crediti (S2)... o se proprio non volete, almeno mettete un "tnx to S2" o qualcosa del genere... vene sarei grati. Let's patch!
'---VARIABLE DEFINITIONS---
'---File Name of the file to crack---
FileName$ = "GOLDWAVE.EXE"
'---Number of bytes to change---
NBC = 6
'---15, 133, 156... are the original bytes of the file (in
decimal!!!)---
OB$ = CHR$(15) + CHR$(133) + CHR$(156) + CHR$(0) + CHR$(0) +
CHR$(0)
'---233, 157, 0... are the changed bytes of the file (in
decimal!!!)---
CB$ = CHR$(233) + CHR$(157) + CHR$(0) + CHR$(0) + CHR$(0) +
CHR$(144)
'---The offset where the bytes to change are---
'---you can find 'em with a Hex editor---
'---the first byte of the file is 1---
OS = 147393
'---The file size in bytes---
FS = 946176
'---CREDIZ & INFO---
CLS
PRINT "Patch for Goldwave v3.24 written by S2"
PRINT ""
PRINT "This Patch allows you to enter ANY password"
PRINT "you like, and the program will register"
PRINT "itselve."
PRINT "If the file is already patched, it will return"
PRINT "to it's original state."
PRINT "Have fun!"
PRINT ""
DO: LOOP WHILE INKEY$ = ""
'---FILE CHECK & VERSION CHECK---
PRINT "Opening file "; FileName$; "..."
PRINT ""
ON ERROR GOTO OpenFileErr
OPEN FileName$ FOR INPUT AS #1
IF NOT LOF(1) = FS THEN
PRINT "The file has not the right size."
PRINT "Check if it is the correct version."
PRINT ""
END
END IF
CLOSE #1
ON ERROR GOTO 0
'---FILE PATCH & UNPATCH---
ON ERROR GOTO PatchFileErr
OPEN FileName$ FOR BINARY ACCESS READ WRITE AS #1
PRINT "Checking file..."
PRINT ""
Data$ = STRING$(NBC, " ")
GET #1, OS, Data$
IF Data$ = CB$ THEN
PRINT "File already patched."
PRINT "Back to it's original state..."
PRINT ""
PUT #1, OS, OB$
PRINT "Now the file is unpatched!"
ELSE
PRINT "File not patched."
PRINT "Let's patch..."
PRINT ""
PUT #1, OS, CB$
PRINT "Now the file is patched!"
PRINT "Registration for FREE now!"
END IF
END
OpenFileErr:
PRINT "There was an error while opening the file."
PRINT "run-time errorcode "; ERR
PRINT ""
END
PatchFileErr:
PRINT "There was an error while patching the file."
PRINT "run-time errorcode "; ERR
PRINT ""
END
Ho scritto i commenti in inglese per mettere il
programma in Internet, ma comunque non penso che ci voglia tanto
a capire come funziona.
Quando volete creare un patch per un altro file, tutto quello che
dovete modificare è contenuto nelle variabili all'inizio del
programma. Li rielenco in italiano con alcuni commenti per farvi
capire meglio:
FileName$ = "GOLDWAVE.EXE"
In questo punto, al posto di GOLDWAVE.EXE inserite il nome del
file da crackare.
NBC = 6
6 è il numero di byte da modificare. In questo caso 6.
OB$ = CHR$(15) + CHR$(133) + CHR$(156) +
CHR$(0) + CHR$(0) + CHR$(0)
Al posto di 15, 133, 156... dovete inserire i byte originali del
file che volete crackare.
Se i byte sono di più o di meno di 6, semplicemente aggiungete o
togliete i CHR$() che sono in meno o di troppo.
CB$ = CHR$(233) + CHR$(157) + CHR$(0) + CHR$(0)
+ CHR$(0) + CHR$(144)
Stesso discorso di sopra, solamente, questa volta, i byte
inseriti tra le parentesi sono quelli che volete siano scritti.
OS = 147393
L'offset dei byte da cambiare. Come trovarlo? Se come Hex editor
usate l'Hexworks, per esempio, tutto quello che dovete fare è
andare a ricercare (nel Hexworks, ovviamente) dove si trovano i
byte che volete modificare. Trovati quelli, sulla sinistra (o
sulla barra di stato) troverete scritto l'offset dei byte.
Attenzione però! In Hexworks, il primo byte nel file è 0,
mentre secondo il Basic, il primo byte nel file è 1. Quindi,
all'offset che troverete in Hexworks dovrete aggiungere 1.
Abbastanza ovvio, no?
FS = 946176
E' la grandezza del file in byte. Se non sapete come trovare
questa da soli siete degli incompetenti, e aggiungerei anche
imbecilli :-))))
Notate che se volete fare un patch per la password dello screen saver, dovrete cambiare un pò il codice, perchè i byte da cambiare non sono in fila, ma iniziano a due indirizzi diversi, quindi due offset diversi. Per cui, ci sarà da aggiungere una variabile OS1$, per il secondo offset, OB1$, per i byte originali nella seconda posizione e CB1$, per i byte cambiati nella seconda posizione. E poi dovrete aggiungere il codice per il cambiamento dei byte nella seconda posizione (al secondo offset). Chiaro no? No? Studiate il basic, o scrivete il patch in un linguaggio che conoscete.
E questo è quanto.
7. Conclusione
Bene raga. Ho finito. Penso che di tutta sta roba, se non
sapevate veramente un cazzo, abbiate capito molto poco, ma non vi
preoccupate... se provate a mettere in pratica ci riuscirete
piano piano a crackare il vostro primo shareware da soli... ci
vuole solo un pò di esperienza... Da parte mia ho cercato di
darvi tutte le informazioni più utili che ho potuto trovare in
Internet, e di spiegarmi in maniera più o meno capibile. Spero
che questo manualetto vi serva e che vi ricordiate di S2 in
futuro... In oltre vorrei ringraziare Extasy per avermi dato
l'idea, anche se in modo implicito, di scrivere una roba del
genere... E ringraziamenti vanno anche alla fabbrichetta di
Plastica nella quale ho lavorato, per le sigarette che grazie a
loro posso permettermi.
Un'altra cosa: NON MANDATE MAIL!!! TANTO NON RISPONDO!!!
Prima di andarvene dal sito andate a visitare la parte
"required programs". Troverete non solo i programmi che
vi servono, ma anche i patch per i programmi stessi. E non
dimenticate, di tanto in tanto, di tornare su queste pagine per
le ultime novità.
Ok raga... questo è tutto, e un buon cracking a tutti.