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.