-
@N63.
User deleted
INTRODUZIONE: SCREAM SUPPORTA LA PIRATERIA. SUPPORTATE SCREAM! (SCHERZO EH?!)
-----------------------------------------------------------------------------
Dunque dunque dunque..... era tanto che pensavo di scrivere un qualcosa del
genere, e ora finalmente (grazie a SCREAM) ne ho la possibilità.
Sinceramente, quando ho chiesto a Swan se potevo collaborare scrivendo un
manuale di cracking, pensavo che mi avrebbe immediatamente kickato fuori dal
canale (eravamo su IRC)...... ma fortunatamente ciò non è avvenuto, anzi.....
Quindi eccomi qua !!! Premetto che di tutorial come questo, su internet, se
ne trovano a bizzeffe (io si può dire che ho imparato leggendo quelli), tutti
però con un basilare difetto: sono in INGLESE! Anche se ormai quasi tutti
conoscono questa lingua, penso che una versione italiana non dispiaccia a
nessuno. Naturalmente, sempre che questa mia versione venga su decentemente..
... Speriamo bene! (sento già che scriverò una caterva di stronzate... Bah...)
Accendiamoci una sigaretta...... via, si parte!
Il manuale è strutturato in 4 parti, trattanti i seguenti argomenti:
1) NOZIONI GENERALI E USO DEL DEBUGGER
2) DOS, DOS EXTENDERS (DOS4GW e simili)
3) WINDOWS 3.1/95/NT
4) Appendice: Patchers,TSR,Trainers
In ognuna di queste, cercherò di spiegarvi le tecniche da usare nei vari tipi
di sprotezione, nei limiti delle mie possibilità. Per semplificare le cose non
sarò troppo specifico, e tenterò di rendere il tutto capibile anche da chi di
assembler non ci capisce un accidente (io stesso non è che sia una cima nel
campo!). L'importante infatti è sapere il significato di una manciata di
istruzioni, oltre alle funzioni di alcuni dei registri AX,DX,CX,ecc...
Per ogni sezione ci sarà una guida passo passo nella sprotezione di un
programma (gioco o utility) in maniera da rendere le cose più chiare.
-----------------------------------------------------------------------------
CAPITOLO 1: NOZIONI GENERALI E USO DEL DEBUGGER
-----------------------------------------------------------------------------
Dunque, innanzitutto partiamo con le 3 doti principali dell'aspirante (e anche
del provetto) cracker:
1) Conoscenza media dell'assembler, in particolare le funzioni di JMP (nelle
sue varie forme), MOV, CALL e CMP (il vostro intervento sui programmi
"vittima" si risolverà nel 99% dei casi nella disattivazione/modifica di
queste funzioni) e della funzione dei registri principali della CPU.
2) Conoscenza dell'uso delle funzioni del debugger (SOFTICE,GAMETOOLS,
WATCOM,ecc.) necessarie alla sprotezione (STEP,TRACE,come si settano e
cosa sono i BREAKPOINT; di solito queste 3 funzioni sono le principali
che userete, il resto è utile ma non indispensabile).
3) Una dose spropositata di CULO sapientemente miscelata con intuito.
Difatti, molte volte il crack avviene per caso, magari NOPPANDO (poi vi
spiego) un'istruzione che apparentemente non c'entra nulla, oppure
forzando un JMP proprio quando si pensa che non serva a niente.
Quindi, se siete iellati tipo Paperino, meglio lasciar perdere
(scherzo eh?!)
1.1........MINI CORSO CRACKING-ORIENTED DI ASSEMBLER (ORA SI RIDE!)
Partiamo con la parte sull'assembler. Premetto che all'inizio avevo in mente
di fare solo un breve excursus (senti vi' che paroloni!), ma ciò penso che vi
avrebbe lasciato con parecchi punti interrogativi. Quindi, per evitare di
essere sommerso da e-mail sull'argomento (che se il server-administrator me
le becca, probabilmente mi manda alle Sughere, rinomato carcere livornese) ho
pensato di farmi dare una mano da MoonShadow (lui parla in assembler!)...
quindi, se un giorno andrete in galera per aver formato un cracking-group dopo
esservi esaltati a leggere questo manualino, ringraziate anche lui!
Allora...iniziamo con il funzionamento dei registri principali:
[AX].... registro accumulatore, utilizzato per le operazioni matematiche e di
I/O. Tutto passa da questo registro, le funzioni di COMPARE (CMP) di solito
avvengono confrontando un valore inserito da voi (es. un numero del serial
number, una lettera della password, il numero riferito ad una icona da
scegliere) con quello contenuto in AH, AL o in tutto il registro
(non è però una regola generale, voglio dire cioè che questi valori possono
essere anche contenuti in un'altro registro, es.BX, però nel 99% dei casi è
così).
Questo valore è qui precedentemente mosso dalla routine che vi trasferisce
uno ad uno i valori (naturalmente, in HEX o in DEC) della password o del
serial number.
[BX].... Viene utilizzato di solito come base o puntatore ad una locazione.
[CX].... Il contatore. Viene usato per i loops (cicli) e viene decrementato
o incrementato secondo le esigenze. Di solito contiene un numero (ad es. il
numero delle volte che potete provare ad inserire la password prima che il
tutto si blocchi) che viene poi decrementato (con l'istruzione DEC CX oppure
SUB CX,AX) ogni volta che sbagliate. Utile in questo caso eliminare queste
istruzioni per poter lavorare con più tranquillità.
[DX].... Funzioni simili a BX.
Da notare che ognuno di questi registri può essere suddiviso ulteriormente in
2 parti, ossia parte alta (es. AH,BH,ecc.) e parte bassa (AL,BL,ecc.). Quindi
in questa maniera ogni "parte" del registro può contenere un valore da 00 a
FF (mentre il registro "intero" contiene valori da 0000 a FFFF). Facciamo un
esempio: se muoviamo un valore in AX (MOV AX, 01AFh), il registro AL conterrà
il valore AFh ed il registro AH conterrà invece 01h. Tutto qua!
Ora, i segment-registers:
[CS].... Il code-segment, cioè l'area di memoria nella quale si trova il
codice del programma che state sodomizzando. L'indirizzo CS:IP serve ad
identificare proprio l'istruzione che state per eseguire.
[DS].... Data-segment, l'area di memoria alla quale la CPU accede in lettura.
i dati.
[ES].... Extra-segment, altra area di memoria alla quale la CPU accede, ma
questa volta in scrittura. In pratica, la CPU legge da DS:SI e và a scrivere
il byte (o la word) letta in ES:SI.
[IP]..... Istruction Pointer. Cos'è? Semplice, l'indirizzo dell'istruzione
che state per eseguire nel code segment attuale. Io di solito, durante il
crakkaggio nel debugger, modifico questo registro invece del jump, in maniera
da non danneggiare per il momento il programma. Ma è solo una mia abitudine...
[SS].... Stack-segment, area di memoria di "parcheggio" nella quale la CPU
tiene nota di tutti i return-address dalle subroutines. Usando l'istruzione
PUSH o POP, lo stack viene riempito o svuotato (questa ci stà che sia una
stronzata, comunque se non è proprio così la funzione di queste istruzioni è
simile..... chiederò a MoonShadow!).
Altri registri, ma questi li potete anche tralasciare, sono:
[SI]..... Source-index, usato insieme all'istruzione MOV. E' un puntatore
all'interno di un segment (di solito DS) che viene letto dalla CPU.
[DI]..... Destination-index, anche questo usato insieme a MOV. E' un puntatore
all'interno di un segment (di solito ES) dove la CPU và a scrivere. Andando
a vedere all'indirizzo ES:DI, se vedete che ci viene mosso qualcosa, potreste
anche capitare in locazioni interessanti... (potreste trovarci addirittura la
password che cercate.... boh, voi provate!)
[BP]..... Base-pointer, usato insieme allo Stack-segment.
[SP]..... Stack-pointer, altro pointer usato insieme allo Stack-segment
Una particolare nota merita il seguente registro:
[FLAG].. Nel vostro debugger, vedrete (di solito in cima) un'insieme di
lettere maiuscole e minuscole (oppure illuminate o no, oppure con sotto dei
numeri 0 e 1). Questi sono i flag, che servono ad indicare se un particolare
jump deve avvenire o no. Logicamente, flag=0=spento flag=1=acceso.
Agevoliamo un esempio (Agevoliamo TM of Enzino Iachetti)
CMP AL,2A......... confronta il valore di AL con 2A.
Il risultato è un cambiamento dello stato del flag
Z. Cioè, se è vero il flag viene attivato (1) sennò
viene disattivato (0).
JZ 8EDF........... salta -SE- il flag Z=1 (quindi se AL=2A)
Comunque, io di solito non li guardo mai,anche perch‚ tutti i debugger
(di solito) ti dicono con una freccetta se il jump avviene o no..... ma è
una mia abitudine.
Piaciuti i registri? Ganzi eh? (comunque non preoccupatevi, si può crakkare
bene anche senza conoscerli molto... io stesso di solito, a meno che il
programma non sia una brutta bestia, non li guardo nemmeno..... poi vi spiego)
Ora, qualcosa sulle istruzioni (altra sigaretta.... Ulp! Le ho quasi finite!)
[MOV]..... E' un'istruzione le cui funzioni sono fondamentali nel cracking.
Difatti, molte volte vi ritroverete a dover magari muovere un valore giusto
in una locazione semplicemente cambiando un CMP in un MOV (poi vi spiego....
non temete). La sua sintassi è: MOV [destination],[source]
es 1. MOV AX,BX ----------> muove il valore di BX in AX
es 2. MOV CX,[0400] ----------> muove i due bytes contenuti all'indirizzo
specificato (DS:0400) in CX. In questo caso
se dumpate a DS:0400 trovate lo stesso
valore di CX, solo rovesciato (es. se in CX
c'è 002Ah, troverete 2A00h); non sò perchè,
(stasera non ho fame), ma è così....
es 3. MOV AL,DL ----------> muove la parte bassa di DX nella parte bassa
di AX
es 4. MOV [ES:300],AX ---------> muove il valore di AX nella locazione
specificata. Notare che se ES non è
menzionato, si usa DS. Se prima di una
istruzione del genere si muove un valore
in BX (es. 03) questo viene usato come base
da aggiungere all'indirizzo specificato.
Quindi, in questo caso, il valore di AX
verrebbe mosso in ES:300+BX = ES:303.
[CMP]..... Semplicemente, confronta due valori in memoria, siano essi registri
oppure bytes, cambiando di conseguenza il flag relativo. La sintassi, secondo
i casi, può essere:
es 1. CMP AX,01 -----> confronta AX con 01
es 2. CMP AX,BX -----> confronta AX con BX
es 3. CMP AX,[0550] -----> confronta AX con i 2 bytes a DS:0550
(eccetera eccetera...)
Questa funzione funziona (bello!) come una sottrazione source-destination,
cioè:
ponendo AX=20 e BX=21, il risultato del CMP AX,BX sarà 20-21=-1. Il risultato
di questa sottrazione attiverà il flag CARRY (C), attivato quando si sottrae
un valore più grande da uno più piccolo; se invece la sottrazione non dà
risultato negativo, il flag rimane 0 (disattivato).
Dal punto di vista crakkistico, le istruzioni CMP sono usate *SEMPRE* per
verificare il vostro input, oppure per far sapere al programma se è registrato
o meno. Quindi, truffando il CMP si può benissimo far credere al tapino una
cosa per un'altra!
[JMP].... Lo troverete *SEMPRE* dopo il CMP, nelle varie forme.
La più semplice, e ovvia, è la forma JMP <indirizzo>, che naturalmente provoca
un salto all'indirizzo desiderato, quali che siano i valori dei flags dati
dal CMP. Per quanto riguarda l'indirizzo, questo può essere nello stesso
CS (JMP 0AF4) oppure in un'altro (JMP 2000:18A0 oppure JMP DWORD PTR ES:[DI],
che vi spedirà alla locazione contenuta in ES:DI. Ma sono solo alcuni esempi).
Questa comunque è l'istruzione che userete più spesso (anzi, mi sbilancio:
nel 99% dei casi) nei vostri scopi pirateschi. Difatti, se la vostra
protezione, ad esempio, controlla una locazione e poi fà un JNZ che riporta
il programma all'inserimento della password/serialnumber, basta che
sostituiate il jump condizionale con un JMP, e..... et voilà! Comunque, se
ne riparla dopo!
Ora, vi agevolo la lista dei vari jump condizionali, spudoratamente copiata
dal Cracking Manual di The Cyborg (quindi, grazie tante, leggetelo che è
bellino, ma il mio è meglio perchè è più aggiornato!).
Dunque, supponendo un CMP AX,BX, si possono avere i seguenti casi:
(Z,O,S,C,P sono i flags che i jump vanno a controllare)
Istruzione Definizione, condizione, flag
JNZ 030A (Jump if not zero, AX diverso da BX, Z=0)
JNE 030A (Jump if not equal, identico a JNZ)
JZ 030A (Jump if zero, AX=BX, Z=1)
JE 030A (Jump if equal, identico a JNZ)
JB 030A (Jump if below, AX<bx, C=1)
JA 030A (Jump if above, AX>BX, C=0)
JL 030A (Jump if less, AX<bx, S diverso da O)
JNGE 030A (Jump if not greater or equal, AX<=BX, S diverso da O)
JGE 030A (Jump if greater or equal, AX>=BX, S=O)
JNL 030A (Jump if not less, in pratica uguale a JGE)
JLE 030A (Jump if less or equal, AX<=BX Z=1 oppure S=F)
JNG 030A (Jump if not greater, come JLE)
JG 030A (Jump if greater, AX>BX Z=0 oppure S=O)
JNLE 030A (Jump if not less or equal, AX>=BX Z=0 oppure S=O)
JS 030A (Jump if sign, /, S=1)
JNS 030A (Jump if not sign, /, S=0)
JC 030A (Jump if carry, /, C=1)
JNC 030A (Jump if not carry, /, C=0)
JO 030A (Jump if overflow, /, O=1)
JNO 030A (Jump if not overflow, /, O=0)
JP 030A (Jump if parity, /, P=1)
JPE 030A (Jump if parity even, come JP)
JNP 030A (Jump if no parity, /, P=0)
JPO 030A (Jump if no parity odd, come JNP)
(ce ne sarebbero altri, ma nella lista da cui li ho copiati non
venivano menzionati.)
Puff,Puff..... spero di non aver scritto minchiate! (tanto poi lo riguarda
MoonShadow!). E comunque, non fatevici tante seghe mentali....
il funzionamento dei jump lo imparerete strada facendo.... nemmeno io mi
ricordo a memoria il funzionamento di tutti questi jmp (anzi, a dire il vero
non vado oltre le prime 5/6 righe!).
[LOOP]..... Indica un ciclo, che si ripete per CX volte (naturalmente, CX
decrementa ogni volta che trova questa istruzione). Per quanto riguarda il
formato, è LOOP <indirizzo>, che indica appunto l'inizio del LOOP dove questo
ogni volta ritorna finchè CX non diventa 0. Istruzione piuttosto pallosa da
debuggare, utile in questo caso la funzione "Breakpoint Here" dei debugger,
che permette di settare un breakpoint all'istruzione successiva e ripartire
direttamente da lì senza sorbirsi tutto il ciclo (sempre che funzioni, sennò
ve lo dovete puppare tutto).
[REP]..... Repeat. Stesso discorso del loop per quanto riguarda la pallosità
e l'uso della funzione "Here". Indica il ripetersi di istruzioni MOVS, LODS,
STOS (quindi si troverà nel formato REP MOVS, REP LODS, REP STOS). Le
istruzioni suddette vengono ripetute CX volte.
[MOVSB]..... Muove un byte dall'indirizzo DS:SI all'indirizzo ES:SI.
[MOVSW]..... Stesso discorso, ma per una word (4 bytes)
[LODSB/LODSW]..... Con queste istruzioni, viene letto un byte o una word
residenti in memoria all'indirizzo DS:SI. Il byte o la word in questione
viene messo in AL (o in tutto AX, naturalmente, se è una word)
[STOSB/STOSW]..... Se le istruzioni prima leggevano, questa cosa fà?
mah..... forse scrive! Difatti, scrive il byte (o la word) in AL (o AX se
word) all'indirizzo ES:SI.
[CALL]...... Richiama una subroutine, e dopo l'esecuzione di questa torna
all'indirizzo successivo alla CALL stessa (tramite un RET/RETF).
Esempio:
CALL 68AB ----> esegue la subroutine a CS:68AB
subroutine:
CS:68AB ......
68AE ......
68B0 ......
68B3 RET ----> torna all'istruzione successiva a CALL 68AB
Una call può essere anche nel formato CALL FAR (come anche il JMP),cioè viene
eseguita una subroutine ad un'indirizzo in un altro CS.
Nei vostri primi approcci crakkistici, se avete la fortuna di trovare la CALL
che salta *DIRETTAMENTE E SOLO* alla protezione, potete benissimo togliere
quella. Più in là sarà meglio che impariate a districarvi con i jump e i
compare, identificando e modificando quelli relativi al solo controllo della
protezione. Difatti, se per caso quella CALL chiamasse una subroutine che
contiene la protezione ma anche istruzioni necessarie al buon funzionamento
del programma, eliminandola siete fottuti.... (cosa che ho imparato dopo
mooooooooooooooolto tempo e moooooooooooolte figure penose distribuendo crack
che sì sproteggevano il programma, ma che avevano anche "alcuni" effetti
collaterali!)
[INT]...... Chiama un interrupt (tipo una CALL ma non relativa al programma)
, con una specifica funzione assegnata da un valore, di solito mosso in AX.
E' utile ad esempio monitorare l'interrupt 13 con il debugger (nel caso si
voglia sproteggere un programma che accede al floppy), oppure l'interrupt 16
con funzione 10 (AX=10) nel caso il programma attenda la pressione di un
tasto.... Utile ma non indispensabile, si crakka anche senza usare questa
funzione del debugger.....
FFFFFFFFFFFFIIIIIIIIIIIIINNNNNNNNNEEEEEEEEE!!!!!!!!!!!!!
Finalmente, che palle!!! Non ne potevo più. Non vedo l'ora di cominciare la
parte sul cracking vero e proprio. Comunque, a parte gli scherzi, un mini
corsino di assembler (MOOOOOOOLTTTOOOOO MIIIIIINIIIII!) ci voleva proprio,
sennò probabilmente non capireste niente nelle parti successive. Comunque
non è detto che se capite poco in questa sezione non andrete avanti.......
anzi! Io stesso non conosco troppo bene l'assembler, ma vi assicuro che se vi
imparate ben bene le cose scritte sopra non avrete problemi. Quello che conta
è l'intuito, la perseveranza, e ancora una volta.....il CULO! Magari, se
l'argomento vi interessa, può essere una buona scusa per impararsi l'assembler
un pò più a fondo (cosa che stò cercando di fare anch'io!).
1.2...... USO DEI VARI DEBUGGERS
Vi dico subito che qui non mi dilungherò poi tanto, visto che anche se i
programmi sono diversi, le funzioni sono sempre le stesse, e ben deducibili
dal programma stesso. Comunque, in questo tutorial farò uso di:
1) GameTools 3.2 (G3X).... MITICO e INEGUAGLIABILE debugger DOS
(purtroppo solo in modo reale) che potete usare anche per
fare dei trainers. Lo allego io, non sò se lo trovate su internet.
2) SoftICE 2.0 for Windows95 ..... Praticamente, il GameTools per
Windows, con le stesse doti di ineguagliabilità e miticità (che
discorso a culo!). A parte gli scherzi, indispensabile, anche
perchè è l'unico debugger (almeno credo) che permette di
debuggare (bel discorso,complimenti...) i programmi con
DOS4GW. Se volete potete anche usare il SoftICE x DOS al posto
del G3X.
3) Watcom Debugger..... Odiosissimo debugger indispensabile per
il cracking in DOS4GW. Fortunatamente, lo dovete usare solo
per questo..... il resto si fà con gli altri due! Dato che
questa parte l'ho aggiunta dopo, i comandi li trovate direttamente
nel paragrafo sul DOS4GW.
Beh, andiamo al dunque.....
i comandi del debugger che userete più spesso sono:
[STEP] ....... Esegue le istruzioni una alla volta, eseguendo direttamente
le CALL e i LOOP.
[TRACE] ...... Come sopra, ma permette di eseguire le istruzioni all'interno
delle CALL e dei LOOP una alla volta. Utile se dovete utilizzare la famosa
tecnica "Cynar, fino al cuore del carciofo", ossia spulciare all'interno di
una serie di CALL nidificate fino a trovare quella che chiama *SOLO* la
routine di protezione
[BREAKPOINT]..... Esegue un INT 3 al posto dell'istruzione presente all'
indirizzo da voi specificato, causando un ritorno al debugger quando questa
viene eseguita. (se però c'è la famosa trappola per il debugger...... son
cazzi! dovete individuare le istruzioni che vi impiantano il debugger e
levarle.). I breakpoint sono di vari tipi, ognuno con una funzione specifica.
Ad esempio, un breakpoint molto usato è quello che torna al debugger ogni
qualvolta si accede in lettura e/o scrittura alla locazione indicata
(utilissimo per trovare proprio le istruzioni che esaminano il vostro input).
Un altro ancora è quello che torna al debugger quando viene eseguita
l'istruzione all'indirizzo indicato (ad esempio, per stoppare il programma
in un certo punto che sappiamo essere proprio prima del controllo dell'input).
Questi sono solo 2 esempi di breakpoint.... nel G3X vi appare la lista
di quelli che potete usare, nel SoftICE dovete settarveli a mano.
La sintassi per il SoftICE non stò a scriverla,in quanto è spiegata nell'
help stesso del programma. Direte voi, dove lo trovo l'help ?
Semplice: se digitate ? <invio>, vi appare una lista di tutti i comandi
disponibili; ora, andate a vedere quelli relativi ai breakpoint, scegliete
quello che vi interessa e inserite ? <nome breakpoint (BPR,BPX,ecc.). Vi
apparirà quindi la sintassi del comando. Questo procedimento è valido anche
per tutto il resto dei comandi del SoftICE (così lo spiego una volta sola!)
[HERE]..... La funzione cui accennavo prima nel tutorial assembler, permette
di settare un breakpoint BPX (break on execution) in un punto particolare
(es. subito dopo un loop) causando il ritorno al debugger quando il programma
arriva a quel punto. In questo modo, si saltano fastidiose attese.....
Giustamente, voi mi direte: ma non è lo stesso mettere un breakpoint come
spiegato prima ? No, cioè sì (la funzione è la stessa), ma così fate prima.
Mi spiego: col G3X, ad esempio, scorrete il listato assembler, e all'indirizzo
dove volete che il programma si fermi premete "H", in modo da mandarlo in
esecuzione fino a quando non raggiunge quel punto. Per il SoftICE stesso
discorso, ma prima dovete entrare nella CodeWindow (la finestra sopra a quella
dove inserite i comandi, quella dove vedete il disassemblato del codice)
digitando "ec". Quindi, scorrete con alt+frecce e premete F7 dove volete il
breakpoint. L'unica differenza è che questo tipo di BP vale una volta sola,
ossia tutte le volte lo dovete risettare. Capito mi avete ?
[INTERRUPT MONITOR]..... Non è una vera e propria funzione, bensì un
breakpoint (nel SoftICE comando BPINT) ad uno specificato interrupt, che
causa il ritorno al debugger ogni qualvolta questo interrupt è chiamato.
Utile nel caso di protezioni che accedono al floppy,o alla porta parallela
(se se ne conoscono gli interrupt relativi, quello del floppy è il 13)....
ma come ho detto più indietro non indispensabile, serve solo a sveltire un
po' la procedura. Non vi intrippate quindi troppo a mettere breakpoint
sull'interrupt 21 o 10, chiamati per funzioni dos e apertura schermo, perchè
rischiate di perdervi nei meandri del programma. Usate questa funzione solo
nei casi in cui conoscete *ESATTAMENTE* il numero dell'interrupt e la funzione
richiesta (es. per la pressione di un tasto, INT16 con funzione 10 in AX).
Dal G3X, accedendo al menu interrupt monitor, potete settare questi breakpoint
in maniera molto semplice..... nel SoftICE dovete fare a mano.
Vabbè, le funzioni che andrete maggiormente (anzi,diciamo pure esclusivamente)
a usare nei debuggers trattati sono queste. Vi faccio ora una panoramica sui
tasti da usare nel SoftICE per accedere a queste funzioni (così evitate di
battere 200 volte "p" <return>, "p" <return> mentre debuggate). Quelli del
G3X non li metto, dato che tutto è spiegato su schermo e anche un deficiente
quale ero (e sono) io lo saprebbe far funzionare.....
F10..... P (step)
F6...... EC (enter/exit code window)
F7...... H (here) [dovete prima andare nella code window con F6 (ec)]
F8...... T (trace)
Da notare che questi tasti possono anche essere cambiati, basta andare a
modificare il file WINICE.DAT nella directory del SoftICE.
------------------------------------------------------------------------------
CAPITOLO 2: CRACKING IN DOS / ThE FuN StUfF BeGiNs! /
------------------------------------------------------------------------------
Eccoci arrivati, dopo la pallosissima (anche da scrivere) prima parte, al
succo di questo tutorial.... il cracking vero e proprio.
Cominciamo dal DOS, trattando i vari tipi di protezione che potete trovare,
ognuno spiegato in maniera (spero) abbastanza dettagliata e corredato da un
esempio..... naturalmente, questi dovranno essere presi solo come tali, anche
perchè ogni protezione è diversa dall'altra e non si può generalizzare il
tutto con una precisa tecnica. Mano a mano che poi crakkerete da soli
sicuramente saprete far fronte anche a situazioni diverse, più o meno
discostanti da quelle qui illustrate.
Una cosa che tengo a puntualizzare è questa: avrete sicuramente visto che
oggi tutti i crackers tendono a fare (per i programmi che richiedono un
serial number collegato al vostro nome) dei KeyMakers, ossia dei programmi
che, una volta scoperto l'algoritmo, prendono il vostro input e ne fanno
un numero valido per il programma. Io da parte mia preferisco sempre
SRADICARE di netto la protezione, anche perchè così non devo perder tempo
a star dietro all'algoritmo, magari complicatissimo..... Quindi, i miei
esempi saranno tutti improntati sulla COMPLETA eliminazione della routine
di protezione. Se poi volete farvi i keymaker per quel tipo di programmi,
basta che seguiate l'algoritmo di protezione, facilmente trovabile mettendo
dei breakpoint R/W (read/write) o meglio R (read) alla locazione dove trovate
il vostro ECHO (ossia, l'input che avete dato es.il vostro nome). Per cercare
l'echo, basta cercare in memoria quello che avete inserito, subito dopo essere
tornati al debugger dopo l'inserimento. A questo proposito, per quanto
riguarda il dos, ricordatevi che le locazioni buone per l'echo (ne troverete
infatti diversi) sono quelle dalle parti del CS o DS, ma non sempre...
comunque, mai quelle iniziali e finali (da C000 in poi). Con un pò di pratica,
le riconoscerete a occhio, ve lo garantisco.
Quindi, fatte queste precisazioni, LET'S START!
2.1.... Protezione con controllo dell'accesso al disco (INT13)
Questo tipo di protezione è in assoluto la più facile da eliminare. Difatti,
si basa sul controllo di settori del floppy che non vengono copiati durante
un normale processo di copia, quindi presenti solo sul floppy originale.
Data la sua facilità di sradicazione, oggi questa protezione non è quasi
più usata.... comunque, mi sembra un buon esempio per iniziare.
L'esempio che vi proporrò è il gioco "Lemmings" (spero lo abbiate, di solito
lo davano con le vecchie SoundBlaster), anche perchè non sono riuscito a
trovare qualcos'altro che usa questo tipo di protezione.
Iniziamo..... Per prima cosa, caricate il G3X, buttatevi Lemmings sull'HD
e togliete il dischetto originale dal drive (oppure mettetecene uno a caso)
in maniera da simulare il caso di una copia pirata.
Ah, ricordatevi di togliere il QEMM (o l'EMM386) se lo avete installato,
perchè nel mio caso faceva impallare il tutto (forse il gioco è troppo
vecchio, non lo supporta....).
Dunque, appena caricato il file LEMMINGS.BAT vi trovate davanti ad una
schermata in modo testo che vi permette di scegliere il computer posseduto.
A questo punto, premete PRTSCR (STAMPA,per i non inglesi) ed entrate nel
G3X. Premete "V" per entrare nel debugger, dopodichè iniziate a steppare
con "P" finchè non vi trovate nel ciclo di ripetizione che aspetta l'input.
Questo è un punto fermo nel debugging crakkistico, cioè bisogna sempre
trovare questo ciclo in modo da rientrare nel debugger una volta effettuata
la scelta.
Quindi, vi troverete in questo punto (il CS lo ometto, tanto cambia sempre):
5448 CALL 9109 < Inizio ciclo attesa input
544B PUSH BX
544C XOR BX,BX
544E CALL 7583
5451 POP BX
5452 JB 5442
5454 MOV AH,01
5456 CALL 8413
5459 JNE 8461
545B MOV AH,84
545D INT 2A
545F JMP 5448 < Torna all'inizio finchè non premete il tasto giusto
5461 XOR AH,AH < Qui premete "H" per tornare al G3X dopo aver premuto <ret>
Come vedrete, continuando con "P" non fà altro che saltare a 5448 ogni volta
che arriva a 545D, ciò indica che è un ciclo. Allora, provate a mettere il
breakpoint HERE a 5461 (andateci sopra e premete H).... hmmm, torna allo
schermo di selezione! Quindi, premete return (tanto và bene per tutti la
prima opzione) e..... magia, riecco il G3X! Era proprio il ciclo di attesa
dell'input!
Vabbè, andiamo avanti! Premete comodamente "P" fino a che non arrivate a
questa parte:
00E0 CALL 0649 < Controlla se il floppy originale è inserito,sennò esce
00E3 CALL 1591 < Fà partire il gioco
00E6 CLI
00E7 MOV CX, [1FC9]
Noterete subito che steppando la prima call, il programma esce dicendo che
il disco originale non è inserito. Primo trucchetto del cracker provetto:
quando ci sono due call una di seguito all'altra, la prima delle quali esce
se non si è azzeccato la password o simili (come in questo caso), provare
SEMPRE, una volta arrivati a questa call, a cambiare l'IP ed eseguire la
seconda..... fusse che fusse la vorta 'bbona!
Quindi, tutto da capo, fino a riarrivare all'indirizzo 00E0 (questa volta
però, salvatevi l'indirizzo andandoci sopra e premendo "TAB", almeno se
qualcosa và male poi potete metterci un BPX e ricominciare da qui). A questo
punto provate a farli saltare la call, cioè a non eseguirla proprio,
cambiando il valore del registro IP (premete R poi I, quindi scrivete 00E3, la
locazione successiva). Ora, incrociate le dita..... ricominciate a steppare
con "P", anzi per un brivido maggiore consiglio di uscire direttamente dal
G3X con "ESC". Et voilà, come dice il mago Afono del Vernacoliere, avete
fatto il vostro primo crack!!!! Naturalmente, dovete poi andare a ricercare
con un hex-editor i bytes corrispondenti alla call (quindi,segnatevi i
precedenti,quelli e i successivi) e cambiare i valori nel file (mi sembra
sia VGALEMMI.EXE) con una serie di NOP (No-Operation, in hex 90). Ma di questo
parleremo poi, nel capitolo apposta sul patcher! Intanto, godetevi la vostra
prima sprotezione!!!!
Ah,faccio notare che se provavate a monitorare l'INT13, in questo caso i
programmatori sono stati furbi implementando la cosiddetta "trappola per
debugger", cioè una serie di INT3 dopo le istruzioni "chiave" che fanno
impiantare il povero G3X.... se non ci credete, provate (tanto come si fà
lo dovreste sapere, ve l'ho spiegato prima!)
2.2. Aiuto, il mio piratone di fiducia mi ha dato il programma senza SN!
Capita sempre, specialmente col mio fornitore, di ricevere programmi bomba
che una volta installati, chiedono il serial number. Alcuni funzionano per
un pò, poi cominciano a frantumarci le palle con nag-screens vari (del
tipo : "Bei mi budiuli, ir programma E LO DOVETE PAGA'!!!). Alcuni,addirittura
non si installano nemmeno in mancanza del magico numerino. E' questo il caso
del crack che mo' vi propongo: il QEMM versione 8.0 (peraltro, non distribuito
in versione shareware ma serial-dipendente anche lui).
Dunque, come al solito, G3X in spalla e via!
Si parte con l'inserimento di tutti i dati nell'installer (nome,città,cazzi
vari) e si inserisce anche un serial number a caso (può essere anche una
parola, tanto la protezione la sodomizziamo! io di solito uso "culo", semplice
ma efficace.....). Prima di premere return, PRTSCR e entriamo nel G3X. Dato
che abbiamo inserito un input, tanto vale cercare il nostro ECHO, in modo da
settare un BP R/W (read/write) che ci farà capitombolare proprio nel bel mezzo
della routine da fottere.... Quindi si entra nel debugger, si mette in modo
testo con "U", si mette il display della memoria a 0000:0000 con "C" (change
address, sennò non trova una mazza) e si preme "F". A questo punto, inserite
il serial number che avete digitato e premete return, scegliendo la ricerca
in ASCII e il modo Case Sensitive OFF(non tiene conto delle maiuscole e
minuscole). Troverete un bel pò di echo, comunque vi ho già detto prima di
non considerare quelli troppo vicini all'inizio e quelli troppo lontani.....
in medio stat virtus (diceva Socrate,mi sembra..... sapete, studio Biologia e
questi sono solo ricordi del liceo!). Spulciando tra gli echo che trovate
vi salterà subito all'occhio quello situato a CS:000A, contenente il vostro
serial inserito e, guardando sopra, gli altri dati che avete messo. Quindi,
sicuramente, è quello giusto! Come al solito, salvatevi l'indirizzo andandoci
sopra e premendo TAB, dopodichè settateci un BPRW (tornate nella schermata
iniziale del G3X,scegliete il menu dei breakpoint,selezionatene uno,scegliete
BreakPoint ReadWrite,premete TAB e da qui selezionate l'indirizzo....puff,
puff, ma vi devo dire tutto io? basta,da ora in poi sarò più sintetico!).
A questo punto tornate al programma premendo ESC, e quando premerete invio
magicamente riapparirà il G3X. Bene, siete usciti proprio ora dalla routine
di attesa dell'input! Cominciate allora a steppare, usando tutti i trucchetti
che vi ho insegnato prima (ad es. all'indirizzo CS:3DA6 c'è un ciclo palloso
a bestia, saltatelo con l'HERE a 3DA8). Ad un certo punto arriverete qui:
1B90 TEST AX,AX < Parte finale della routine di protezione
1B92 JNE 1BA6 < Se il numero è giusto, và a 1BA6
1B94 MOV AL,F9
1B96 CALL 11BF < Beep, segnaccio!
1B99 CALL 1916 < Spiacente,avete cacato fuori dal vaso (SN errato)
1B9C POP SI
1B9D CALL 18E3 < Con queste istruzioni e le successive torna
1BA0 CMP AL,1B all'input e vi richiede il SN
..............
1BA6 POP SI
1BA7 JMP 1B56
Se eseguite la CALL 11BF e successiva, vedete che il programma dà il messaggio
di errore. Bene, è dove volevamo arrivare! Ora facciamo marcia indietro.
Qual'è il jump prima della call che da l'errore? Quello a CS:1B92 !(infatti
vedete che salta avanti, cosa IMPORTANTISSIMA da notare: difatti, cercando
di saltare la protezione, i jump che saltano avanti sono SEMPRE i PRIMI da
controllare, altro trucchetto da cracker provetto.... ci và anche di rima!)
Subito, settateci un BPX (togliete quello RW, tanto nella routine giusta ci
siete), uscite dal programma e ricaricatelo (tanto gli indirizzi in memoria
dovrebbero rimanere gli stessi, sennò vi tocca tornarci a mano.)
Vedrete che dopo aver reinserito il SN e premuto return, il G3X si ferma
proprio a CS:1B92. Cambiate quindi l'IP e mandatelo a 1BA6. Ancora qualche "P"
e arriverete qui:
1B68 JZ 1B6D < Qui dovete cambiare l'istruzione in JMP 1C25
1B6A CALL 1C26
1B6D CALL 1525 < Torna al programma e attende la pressione del return
1B70 MOV BX, [5307]
1B74 CMP BX, 3F3F < Ennesimo controllo finale della correttezza del SN
1B78 JNE 1B7D < Se è sbagliato salta a 1B7D
1B7A JMP 1C25 < Se è giusto salta a 1C25 e inizia l'installazione
Osserverete ora che eseguendo le CALL riappare lo schermo del programma,
e che premendo <return> ritorna il G3X. Bene, avanti! Vedrete che facendo
il JNE 187D si ritorna daccapo, con il beep di errore eccetera. Mettiamo
dunque un BPX (disabilitando sempre il precedente,altra regolina) a 1B78,
usciamo e ricarichiamo il programma. Una volta tornati a questo punto,
cambiamo IP mettendolo a 1B7A e continuiamo a steppare. Tadà..... altra
protezione fottuta, complimenti, avete appena fatto il vostro 2ø crack!!!
Per fare le cose ammodino, sarà meglio cambiare il JZ 1B6D a CS:1B68 in un
bel JMP 1C25, in modo da garantire che, quale che sia il SN, il programma
lo prenda per giusto. Quindi, tornando sopra, dovreste inserire l'istruzione
premendo A (assemble) e inserendo i valori esadecimali E9 <ret> BF <ret> 00
<ret>. Perchè questi? Bè, sinceramente non lo sò nemmeno io. Sò solo che
dato che il G3X purtroppo non supporta l'inserimento dell'istruzione assembler
in maniera normale (es. JMP direttamente), bisogna prendere il valore hex
dell'istruzione che si vuole inserire (in questo caso, E9 A8 00 che
corrisponde al JMP 1525 all'offset 1B7A). Quindi, copiarlo nell'offset
desiderato e giocherellare un pò con gli ultimi due valori (il primo rimane
fisso) finchè non si riottiene l'indirizzo voluto, in questo caso 1525. Fatto
questo, provate il tutto rieseguendo da capo il programma e facendo la
modifica, poi segnatevi i valori dei bytes da sostituire e continuate la
lettura del manuale, perchè come fare i patches lo spiego all'ultimo!!!
Ah, dimenticavo: inutile dire che questo procedimento è analogo in caso di
programmi che vogliono una password (es. giochi che vogliono la password
a pagina x del manuale).
2.3 Variazioni sul tema: Xoanon's Standard Cracking Algorithm (TM)
Questi due procedimenti standard sono applicabili anche ad altre situazioni,
per cui non starò a dilungarmi oltre. Un esempio è il caso della scelta di
una determinata icona per superare la protezione (come succede, ad esempio,
in molti giochi della Lucas). In questo caso, come al solito, basta riuscire
ad imbroccare il punto di entrata giusto, ossia, e non mi stancherò mai di
ripeterlo, L'ALGORITMO CHE ATTENDE IL VOSTRO INPUT. Fatto questo, in maniera
analoga a come avete fatto per Lemmings, non resta altro da fare che steppare
fino a che non succede qualcosa. Quando la routine vi butta fuori e riparte
aspettando un'altro input, segnatevi il punto (una CALL) dove il fatidico
"INCORRECT PASSWORD" appare e esaminate bene il disassemblato PRIMA di questa
istruzione. Ci sarà infatti SICURAMENTE un CMP seguito da un jump condizionale
che, in caso l'icona scelta sia quella giusta, salterà questa CALL portandovi
da un'altra parte (in genere il jump giusto da modificare vi porterà avanti,
mai indietro, ma questo mi sembra di avervelo già detto). Quindi, una volta
trovato basta modificarlo. Interessante variazione può essere quella di
non modificare il jump, ma sostituire al CMP un MOV. E'quello che si chiama
DIRTY-CRACK, e vi permette di evitare magari di ritornarci sopra se il
check viene fatto anche più avanti nel programma. Basta andare a vedere,
infatti, alla locazione di memoria dove effettua il compare (quella tra
parentesi quadre, per intendersi, oppure in AX o nel registro dove effettua
il CMP) e vedere che valore c'è. Supponiamo che la situazione sia:
........
CS:0010 CMP AX,00 < se in AX c'è 0 setta il flag a 1, sennò a 0
CS:0013 JNZ 7641 < se il flag è 0, salta a 7641
CS:0015 CALL 4328 < vi butta fuori o simili
........
CS:7641 Dovete saltare qui per saltare la protezione
Se quando andate a vedere nella locazione del compare, in caso sbagliaste
la password, ci trovate uno 00, vuol dire che quello è il valore che il
programma esamina per vedere se è registrato/sprotetto o no. Basta cambiare
il CMP in MOV in maniera da mettere nella locazione/registro un valore diverso
da quello, per far credere al prg di essere registrato effettivamente
(oppure per farli credere che avete indovinato la password).
Tutto quello che vi ho detto in questo paragrafo può benissimo essere
considerato "IL METODO STANDARD PER IL CRACKING DOS/WINDOWS", quindi.......
almeno questo dovete impiantarvelo bene nel ceppione !!!!!
Anche per quanto riguarda le protezioni con chiave hardware, stesso discorso.
L'unica cosa, come vi ho detto qualche pagina fà, è se nella protezione sono
implementati particolari accorgimenti "ANTI-DEBUGGING". In questo caso,
purtroppo, la cosa si fà complicata..... l'unica è provare ad eseguire le
istruzioni passo passo fino a quando il programma si impianta, tornare
indietro, eliminare l'istruzione dove questo accade (andando a tracciare bene
all'interno delle CALL per essere sicuri di non eliminare qualcosa di troppo)
e riprovare. Di più su questo non sò dirvi, comunque sicuramente non
troverete molti programmi di questo tipo..... lo stesso CuBase 3.0 (programma
che costa una cifra, con protezione a chiave hardware) non contiene nessuna
di queste tecniche, e la sprotezione è una vera puttanata (5 minuti) !!!
Un'ultimo cenno sulla modifica della label del floppy (o del cdrom) quando
il programma richiede un particolare nome del disco per funzionare o per
essere installato: solita zuppa! Ci sarà un punto dove troverete un CMP
con un jump condizionale seguente che vi porterà alla visualizzazione di
roba del tipo "Insert the correct disk/CD in drive". Basta individuare questo
punto e saltarlo. Tutto qua.
2.4 Cracking in ambiente DOS4GW (*FOR EXPERTS ONLY*)
Eccoci al dunque, al punto dove si vede veramente se un cracker ha le palle
o meno (ve lo immaginate un cracker con le palle, dico di quelli da mangia'!).
Premetto che le mie palle in questo campo non sono ancora molto sviluppate,
quindi..... perdonatemi se in questa sezione sarò poco chiaro!
Non vi stò a dire nemmeno che, se prima non vi leggete bene gli altri capitoli
e non vi imparate BENE BENE a destreggiare nel debugging, sviluppando un certo
intuito "crakkistico", potete benissimo saltare questa parte, tanto non ci
capirete quasi nulla! Ordunque, fatte queste precisazioni, cominciamo:
Innanzitutto, dovete usare lo strafottutissimoWDmaledettochilhainventatolopote
vanofàunpòpiùfaciledausanonsòtipoilsofticecheècomplicatoperòafàlecosesifàprest
oinvececonquestobisognastàagiràfralefinestreuncisicapisceunasega..... Capito,
a me piace MOOOOLTO il Watcom Debugger!
A parte questo mio odio recondito verso il programmino (in realtà,l'unico che
permette di debuggare il DOS4GW, che che ne dicano chi sostiene che si può
fare benissimo con il SoftICE per Windows95. Dimostratemelo!), vi spiego
subito qualche comandino:
F10..... Step
F8...... Trace
F5...... Go (esegue fino al BP specificato)
F9...... Setta il BP all'indirizzo specificato
Praticamente, il vostro debugging si ridurrà al pallosissimo steppare fino a
che non trovate una call che vi butta fuori. A questo punto:
1) Fate UNDO con CTRL+LEFT (rispondete YES alla finestra che appare)
2) Mettete un BP con F9 alla call incriminata
3) Tracciatela
4) Con le call successive, ripetete da 1 a 3 finchè non vi accorgete che
siete arrivati ad un punto nel quale un jump condizionale controlla
l'entrata o meno nel programma (password esatta,cd check).
5) Provate a saltarlo, cambiando l'EIP (uguale all'IP, ma questa volta a
32-Bit. Anche gli altri registri li trovate in formato E) andando nella
finestra REGISTERS da uno dei meno e clicckando sopra al registro.
6) Se funge, segnatevi i bytes da cambiare. Dato che nel WD non c'è la
funzione di assemble, a meno che non si tratti di NOPPARE qualcosa,
dovrete scazzarvi a cambiare i bytes clickando sul jump da cambiare
e giocherellando con i valori fino a che non avete ottenuto quello
giusto. Questo è uno dei principali motivi per cui odio questo debugger!
Non vi stò nemmeno a dire che nel debugging di questi programmi è quantomeno
ESSENZIALE avere a disposizione l'originale, per vedere come si comporta
debuggandolo, in modo da identificare il punto dove agire. Difatti, in questa
maniera potete prima provare a debuggare in condizione "pirata" (ossia, ad
esempio, sbagliando la password o non inserendo il CD). Quindi, segnatevi
tutti i breakpoint "buoni" che trovate;
A questo punto, debuggando l'originale inserendo la PWD giusta o il CD, usate
gli stessi BP partendo dall'ultimo, fino a che il programma non tornerà al
debugger. Segnatevi questo BP. Ora sapete che il check avviene in un punto
proprio dopo quella call.
Tracciate la call e steppate finchè non esce, seguendo esattamente quello che
succede, segnandovi tutti i jump condizionali. Ora basta riprovare a
debuggare in condizione "pirata", settare il BP che che vi siete segnati
precedentemente e vedere cosa fanno i jump condizionali. Sicuramente ne
troverete uno che si comporta diversamente da prima, e sarà proprio quello
da cambiare.
Questa tecnica è diciamo standard per quanto riguarda i CD-CHECK, come nel
caso di Destruction Derby che ora vi propongo.....
Dunque, iniziate il debugging caricando WD /TR=RSI /SWAP DD.EXE.
Steppate, settate BP, tracciate, eseguite e cazzi vari fino a quando non
arrivate a questo punto (naturalmente, ci arriverete dopo MOOOLTE volte che
il programma vi butta fuori, quindi dovrete ricominciare tracciando e
ritracciando.....):
(naturalmente, l'EIP che troverete voi sarà diverso!!)
[ ] 003A68F5 sub esp,0000000C
[ ] 003A68FB mov eax,[004EA78A]
[ ] 003A6900 sar eax,10
[ ] 003A6903 cmp eax,00000014
= > 003A6906 je CS:003A6916 < Con il CD originale inserito, questo
[ ] 003A6908 mov eax,00000003 JE viene eseguito. Per eliminare
[ ] 003A690D push eax il cd check, basta cambiarlo in JMP.
[ ] 003A690E call CS:003A6ABF
[ ] 003A6913 add esp,00000004
Usando le tecniche sopra descritte e controllando prima come si comporta il
gioco con il CD inserito vedrete che il JE a 3A906 (nel mio caso) viene
eseguito, mentre non inserendo il CD la call a 3A690E vi butta fuori. Quindi,
basta cambiare questo je in un JMP. Dunque, provate innanzitutto a cambiare
l'EIP in modo da simulare un JMP, per vedere se funge (tante volte mi fossi
rincoglionito......). Controllato questo, segnatevi i bytes corrispondenti
all'istruzione a 3A6906 (anche qualcuno prima e dopo) clicckando sul JE
stesso. Poi, andate al capitolo sul patcher per vedere come il tutto si
mette in pratica...... Alè, il vostro primo crack in DOS4GW!!!!!
Ah, dimenticavo: dato che il WD non stoppa i programmi che hanno un proprio
keyboard handler (praticamente, tutti) l'unica soluzione per debuggarli
è fare come in questo caso, cioè eseguirli passo passo dall'inizio, tracciando
e ritracciando (cosa PALLOSISSIMA che vi porterà via ore e ore). Sennò,
potete provare a mettere un BP (dall'apposito menu) alla locazione 0xA0000
scegliendo "Byte", il che vi riporterà al debugger ogni volta che il programma
scrive sullo schermo. Cioè, in pratica, non potete fare quello che fate col
SoftICE o col G3X, cioè magari arrivati al punto dove vi chiede la password
entrare nel debugger e fare tutto il resto. Altra ragione per cui odio il WD,
dato che il tasto per entrare nel debugger c'è (PRTSCR), ma praticamente è
inusabile per questo "cavillo"!
UPDATE:
Ho scoperto finalmente come "crakkare" il DOS4GW usando il Softice 95!!!!
Eh eh..... vi stupisco vero ?
Dunque..... premetto che è una puttanata, bastava solamente pensarci prima.
Allora, partendo dal presupposto che la parte iniziale dell'extender è sempre
la stessa (cioè, il DOS4GW che è "attaccato" all'eseguibile è sempre
il solito) basta fare in questa maniera:
1) Si carica l'EXE da crakkare con il WD
2) Ci segnamo i primi bytes (quelli iniziali, che corrispondono a quelli
subito dopo il caricamento dell'extender)
3) Usciamo dal WD, carichiamo il nostro bravo Hex-Editor e cerchiamo i
suddetti bytes nel file
4) Ai primi 2 bytes sostituiamo "CD 03", che corrisponde a INT 3, un interrupt
riservato ai debugger per prendere il controllo della situazione
5) A questo punto, carichiamo il SoftICE 95, e eseguiamo il nostro file da
crakkare. Wow...... il Softice appare proprio nel punto dove noi abbiamo
sostituito i bytes.... ganzo!
6) Al posto dell'INT3 sostituiamo i bytes che ci siamo segnati in precedenza
7) Si continua a debuggare normalmente, avendo ora passato la parte di
startup.
UPDATE 2:
Dunque dunque.... eccovi fresco fresco un altro trucchetto (forse migliore del
primo, essendo rippato brutalmente dalla guida di +ORC). C'è di meglio che
potete evitare di cercare prima i bytes con il WD.Allora:
1) Cercate con un hex-editor nel file "vittima" la parola "WATCOM" (non mi
ricordo se è WATCOM o Watcom o watcom, mettete case-insensitive). Ne
troverete 3 o 4, quella bona è quella che immediatamente prima ha EB 76
2) Al solito, sostituite questo con CD 03 (ah già.. se il softice non "poppa"
quando eseguite, ricordatevi di attivare I3HERE ON)
3) Runnate il programma normalmente e.... tadan! Siete proprio dopo lo
startup!
4) Risostituite CD03 con EB76 e divertitevi!
------------------------------------------------------------------------------
CAPITOLO 3: CRACKING IN WINDOWS
------------------------------------------------------------------------------
* IN QUESTA PARTE SARO` PIU` SBRIGATIVO, SPECIE NEI CONCETTI DETTI E RIDETTI
NELLE PARTI PRECEDENTI. SOPRATTUTTO, VI SPIEGHERO` IL FUNZIONAMENTO DEL
DEBUGGER *
Ah, dopo il cracking in dos, passiamo a Windows..... con tutti i suoi bei
programmini shareware che funzionano a metà, funzionano per 30 gg, e cazzi
vari..... BASTA!!!! Vi salverò da questo martirio !!!
Premetto che tratterò solo Windows95 con il relativo SoftICE, ma penso che
le stesse nozioni valgano anche per Windows3.1 e NT (comunque, fatemi sapere.)
Dunque, innanzitutto installatevi il SoftICE95 (lo trovate sulla rete, basta
che andiate a cercare con AltaVista la parola "Hack" o "Crack" e vi
appariranno migliaia di siti con tutti i debuggers che volete....
Una volta installato, vi conviene farvi nella vostra AUTOEXEC.BAT un'aggiunta
del tipo:
Choice /TN,10 Carico il SoftICE (S/N) ?
If ERRORLEVEL 2 goto END
:ICE
* mettete qui il comando che vi aggiunge il programma di installazione
(es. c:utilitysice95sice.exe
:END
Inoltre, andate a modificare il file WINICE.DAT nella directory dove il
debugger è installato, modificando la riga con "X;" in questo modo:
WATCH ES:DI;LINES 50;X;
A questo punto assicuratevi di settare il driver della scheda grafica dal
setup del SoftICE, dopodichè siete pronti a debuggare. Su questo, faccio
una piccola aggiunta: a me,ad esempio, il driver della S3 fornito con
l'ICE non funziona, quindi tutte le volte devo settare Windows95 a 16
colori, sennò appena entro nel debugger svalvola lo schermo......
(questo per il SoftICE 2.0, con il 3.0 tutto funziona a meraviglia. Se
avete il 2.0 andatevi a beccare i nuovi drivers al sito della NuMEGA, mi
sembra www.numega.com... ma non sono sicuro!)
3.1 Nozioncine sul funzionamento di Windows95 (penso vada bene anche per 3.1)
Iniziamo con qualche delucidazione su come Windows lavora... che è meglio!
Dunque, dovete sapere che ad ogni cosa che accade sullo schermo (come ad
esempio, l'apparire di una finestra, il click di un bottone, insomma tutto!)
corrisponde una particolare API (funzione interna) del sistema operativo.
Per farvi capire meglio, se il programma vuole aprire una finestra non farà
altro che usare le funzioni del sistema, e nel disassemblato vedrete, tra le
altre, una CALL USER!OPENWINDOW (o roba del genere, non ho il debugger qui
davanti e a mente non me lo ricordo...). Quindi, per i nostri loschi scopi
basta intercettare alcune di queste chiamate, nella maggior parte dei casi
quelle relative all'inserimento di testo oppure al click di un bottone.
Per questo ci viene in aiuto il comando dell'ICE, BMSG.
Questo comando senta un particolare BP che vi riporta al beneamato debugger
ogni volta che questo intercetta una chiamata ad una specifica funzione del
sistema. La sintassi è la seguente:
BMSG window-handle funzionedelsistema
Mi spiego meglio: il Window-Handle non è altro che il primo indirizzo che
trovate nella tabella che ottenete con HWND taskname (spiegato dopo).
Notate che accanto a questo valore, tra le altre cose, c'è il nome dell'handle
stesso. Bene, questo ci serve a identificare l'handle che vogliamo allacciare.
Ad esempio, se avete un task di nome OMAR, e la finestra mostra:
3 righe per inserire il testo (ad es. dati personali e SN)
2 bottoni (es. OK, Cancel)
Dando il comando HWND omar troverete 3 handle EDIT e 2 handle BUTTON (più
altre cose). Dato che voi dovete inserire il SN (mettiamo) il vostro bersaglio
sarà uno dei 3 EDIT, giusto? Ma quale dei 3 ? Di solito il primo, perchè
quello dove inserire il SN di solito appare per ultimo (funziona così....).
Comunque, provate, tanto se beccate quello giusto non appena premete return
vi ritorna al debugger.......
Ah già, le funzioni di sistema da intercettare....... eccone qualcuna che
vi farà sicuramente comodo:
WM_GETTEXT Come nell'esempio, quando dovete inserire qualcosa
WM_COMMAND Quando dovete cliccare un bottone
GETWINDOWTEXT Sempre per il testo, applicazioni a 16-Bit *
GETWINDOWTEXTA (o W) Come sopra, ma per applicazioni a 32-Bit *
GETDLGITEMTEXT Ancora per il testo,16-Bit *
GETDLGITEMTEXTA (o W) A 32-Bit *
WM_MOVE Per tornare al debugger quando apre una nuova finestra
(da usare se i precedenti non funzionano)
* = da usare con BPX al posto di BMSG (si ferma quando trova la call che
esegue la funzione, mentre con BMSG vi ritrovate dentro la funzione
di sistema..... vabbè, è uguale. Io uso solo WM_GETTEXT e WM_MOVE,
con BMSG, poi fate voi.....)
3.2 Esempio pratico di registrazione di uno shareware
Capito bene il paragrafo precedente? Bene, cominciamo!
Dunque, i comandi principali li sapete già (andatevi a vedere il capitolo
1 paragrafo 2).... al SoftICE si accede con CTRL-D..... cosa c'è ancora
da spiegare? Boh...... tagliamo la testa al toro e facciamo subito un
bell'esempio, così si spiega tutto senza star a fare rigirii inutili.
Dunque, prendete un bel programmino shareware di quelli che, ad esempio,
funzionano 30gg e poi non vanno più.... tipo il QuickView Plus 3.0 32-Bit.
Una volta installato, aprite un promptino del dos (infatti non vi crea l'icona
essendo un tipo-plug-in del Netscape) e caricate ORDER32.EXE. Quindi, clickate
su "Single User" poi su "Unlock by Phone". A questo punto, inserite il vostro
unlock code (senza premere return, mi raccomando!), naturalmente scazzato,
e premete CTRL-D per entrare nell'ICE.
A questo punto, il primo passo da fare è individuare il task corrispondente
all'ORDER32. Difatti, non è detto che quando stoppate con CTRL-D andiate a
finire proprio nell'area di memoria riservata al programma.... anzi, diciamo
che non ci andrete a finire mai in questa maniera!
Bisogna fare quello che in gergo si chiama "PINPOINTING", ossia dobbiamo
intercettare un messaggio che quella finestra di Windows manda al sistema
operativo, in modo da entrare così nel task. Ordunque, individuiamo il
task inserendo TASK <return>. Apparirà una lista con (fra gli altri):
TaskName SS:SP StackTop StackBot StackLow TaskDB hQueue Events
........ * GLI INDIRIZZI NATURALMENTE CAMBIANO!*
Order32 0000:0000 005ED000 005F0000 306E 30D7 0000
Spool32 0000:0000 0073D000 006C0000 246E 25D7 0000
Systray 0000:0000 00415000 003F0000 156E 2561 0000
........
A questo punto, facciamo un bel HWND Order32, per avere una lista di tutti
gli handlers del task. Otteniamo questo (sempre tra gli altri):
Window Handle hQueue SZ QOwner Name Window Procedure
........ *GLI INDIRIZZI CAMBIANO (E VE LO RIDIO!!!!)*
01AC (2) 0E3F 32 ORDER32 Static 17DF:000052FA
01A4 (2) 0E3F 32 ORDER32 Edit 17DF:00000BF4
01B4 (2) 0E3F 32 ORDER32 Button 17DF:0000102E
0C50 (2) 0E3F 32 ORDER32 Button 17DF:0000102E
........
In base alle cose spiegate nel paragrafo precedente, scegliamo come handle
da pinpointare quello EDIT a 01B4 (anche perchè è l'unico edit che vi appare).
A questo punto, tornate al debugger con CTRL-D e premete return per far
accettare il vostro input. Di colpo riapparirà l'ICE, e voi inizierete nello
steppaggio.....fino ad arrivare a:
...... (INDOVINATE UN PO'? COSA FANNO GLI INDIRIZZI?)
014F:004049C8 ADD ESP,04
014F:004049CB TEST EAX,EAX
014F:004049CD JNZ 00404A29 < Se il SN è sbagliato, non esegue il salto
014F:004049CF PUSH 20 e vi dà il messaggio di errore.
......
Bene, con le tecniche che ormai avrete appreso (ossia, cercare sempre il
jump condizionale precedente alla call che vi fà uscire) non avrete difficoltà
ad individuare nel JNZ indicato sopra la "chiave" per questo crack. Basta
cambiarlo in JMP (con A 004049CD <ret> JMP 00404A29 <ret>) e..... bravi!
Ora crakkate anche in Windows..... Azz, siete dei mostri!!!
Naturalmente, per il cracking in Windows valgono anche le regole generali
spiegate e rispiegate, potete settare dei BPX (con l'apposito comando) per
evitare tutte le volte di ricominciare da capo, ecc... Unica cosa, data la
possibilità di intercettare direttamente la chiamata alla routine di
accettazione dell'input con BMSG, non c'è bisogno tutte le volte di cercare
il loop che aspetta l'inserimento. Per quanto riguarda gli HERE, anche quello
l'ho già spiegato nelle funzioni del debugger..... cos'altro c'è ?
Ah,già: se siete nella merda fino al collo e volete cercare il vostro ECHO
in memoria, una volta tornati al debugger dopo il BMSG, fate questo:
1) inserite S 30:0 lffffffff 'il vostro SN'
2) guardate gli indirizzi che trovate. Quelli buoni sono di solito quelli
a 30:80000000 e seguenti (il 30 è fisso!). Tanto per controllare,
andate a vedere a questi indirizzi con D <indirizzo> e scorrendo la
DATA WINDOW con ctrl+frecce (o alt, non me lo ricordo. Comunque, è
la finestra dove appare l'immagine della memoria). Molte volte qui
ci trovate direttamente, oltre a quello inserito da voi, il SN
giusto già calcolato!!
3) mettete un BPR (breakpoint-on-range) ai vari indirizzi che trovate
fino a trovare quello giusto. Di solito, quello giusto è quello dove
appaiono vicino al SN anche gli altri dati inseriti.
4) da qui, procedete come sempre.
Una nota sul Loader: lo potete usare, serve a farvi entrare nel debugger
dall'inizio del programma, per eseguirlo passo passo..... ma sinceramente
io non l'ho mai usato....
Beh.... non sò cos'altro dirvi.... naturalmente, applicando queste nozioni
generali, potete anche provare a crackare qualcosa di diverso dallo shareware.
Ad esempio, provate con il Cubase 3.0, che ha la chiave hardware. Vi posso
garantire che la protezione è una vera puttanata. Basta entrare nel debugger
"di rincorsa" non appena appare l'inizio del Cubase e mettere un BMSG WM_MOVE
per farlo tornare quando appare la finestra con scritto "Chiave non inserita".
Di qui, trovate il jump condizionale ed è fatta.......
------------------------------------------------------------------------------
APPENDICE: PATCHERS, TSR, TRAINERS
------------------------------------------------------------------------------
1.1 Il PATCHER. Per distribuire i vostri crack!
Dunque, che cos'è un patcher? Semplicemente, è un programma che vi permette
di distribuire a giro il vostro crack. Cioè, contiene delle istruzioni che
vanno a scrivere sul file originale in modo da "sproteggerlo". Dunque,
bando alle ciance, via agevolo il mio PATCHER UNIVERSALE in Turbo Pascal 7,
che potete compilare e usare voi.
Premetto che, per fare dei patch dovete avere:
1) I bytes originali e quelli cambiati (deducibili come spiegato, nel
SoftICE assemblando l'istruzione voluta e andando a vedere in memoria a
quali bytes corrisponde). Più, naturalmente, un pò di bytes prima e dopo
quelli che volete cambiare.
2) Un disk-editor (uno qualsiasi, io ho l'HEXED che si trova su internet)
3) L' UNP, per scompattare gli eseguibili che, essendo crunchati, non vi danno
la possibilità di trovare al loro interno i bytes desiderati. Anche questo,
si trova su internet.
4) L'offset (cioè la posizione nel file) dei bytes da cambiare.
Lo vedete nel disk editor (mi raccomando,in decimale!)
5) La lunghezza del file bersaglio, per evitare che il patcher possa
modificare file con nome uguale, ma magari versione diversa.
//////////////////////////TAGLIATE QUI////////////////////////////////////////
{$I-}
(* Simply follow the comments inside the file to customize your patch *)
(* This proggy is TOTALLY free, i wrote it for myself to speed-up patching*)
(* However, if you keep the "written by XOANON" lines, i will be glad!*)
(* Hello to all crackerz/phreakerz/hackerz worldwide! *)
(* Compile with Borland Turbo Pascal 7 or higher *)
uses
dos, crt;
var
f : file of char;
c: char;
filnam: string [80];
filsiz: longint;
size: longint;
a, i, x : integer;
procedure drawscreen;
begin
writeln (' ----------------------------------------------------------------------------');
write (' - ');
gotoxy (69,2);
writeln (' -');
gotoxy (1,3);
writeln (' ----------------------------------------------------------------------------');
textcolor (8);
gotoxy (10,2);
write ('General Purpose Patcher 1.0 - Written by [>X0aN0n<] in 1996');
delay (140);
gotoxy (10,2);
textcolor (7);
write ('General Purpose Patcher 1.0 - Written by [>X0aN0n<] in 1996');
delay (140);
gotoxy (10,2);
textcolor (15);
write ('General Purpose Patcher 1.0 - Written by [>X0aN0n<] in 1996');
delay (140);
textcolor (7);
writeln;writeln;writeln;
write (' ');
textcolor(15);
write ('[PrOgRaM NaMe] : ');
textcolor (7);
(* Write in the line below the name of the program *)
writeln ('Cubase Score 3.0 for Windows ');
write (' ');
textcolor(15);
write ('[PaTcH DoNe By] : ');
textcolor (7);
(* Write in the line below the author of patch *)
writeln ('Xoanon ');
write (' ');
textcolor(15);
write(' [FiLe T0 RaPe] : ');
textcolor(7);
(* Write in the line below the name of the file to be patched *);
writeln ('CUBASESC.EXE ');
write (' ');
textcolor (15);
write (' [TyPe 0f PaTcH] : ');
textcolor (7);
(* Write in the line below the type of the patch *)
writeln ('Dongle Crack -100%- ');
write (' ');
textcolor (15);
(* Write in the line below the results obtained patching the file*)
write (' [ReSuLtZ] : ');
textcolor (7);
(* Write in the line below the results obtained patching the file*)
writeln ('Simply, now your Cubase works! ');
write (' ');
textcolor (15);
write (' [ByTeZ ChAnGeD] : ');
textcolor (7);
(* Write in the line below how many bytes the patch will go to change*)
writeln ('2 ');
write (' ');
textcolor (15);
write (' [NoTeZ] : ');
textcolor (7);
(* In the writeln lines below, you can add some notes (I.E. how to run the patch) *)
writeln ('Run this patch in your Cubase directory to crack it. ');
write (' ');
write (' ');
writeln ('Personally, i see my patch more stable than others, bcoz');
write (' ');
write (' ');
writeln ('using it there are less "General Protection Errors". ');
write (' ');
write (' ');
writeln ('But, try it yourself.......');
writeln;
writeln;
end;
begin
clrscr;
drawscreen;
assign (f, 'CUBASESC.EXE'); (* Write here the name of file to be patched*)
filnam := 'CUBASESC.EXE'; (* Write here the name of file to be patched*)
filsiz := 2478080; (* This is the lenght of file to be patched*)
reset (f);
size := filesize (f);
a := IOResult;
if a <> 0 then (*Error, file not found*)
begin
sound (220);
delay(120);
nosound ;
writeln ;
textcolor (15);
write ('Error 1:');
textcolor (7);
write (' File ',filnam);
writeln (' not found. Check your directory.');
writeln;
halt (1)
end else (* File found but filelenght doesn't match*)
begin
if size <> filsiz then
begin
sound (220);
delay (120);
nosound;
writeln;
textcolor (15);
write ('Error 2:');
textcolor (7);
write(' File ',filnam);
write (' must be ',filsiz);
writeln (' bytes long.');
writeln (' Probably you have an incorrect/packed version.');
writeln;
halt (1);
end else
(*Everything is OK, let's PATCH!*)
(* First, we check if the file is already patched*)
seek (f,585299); (*File offset of byte 1*)
read (f,c);
if c <> #116 then (*This is the ORIGINAL value of byte 1, decimal of course*)
begin (*Now we patch the file to its original state*)
(*The following lines depends on how many bytes you have to change*)
(*In this case, there are 3 bytes*)
(*If you have more, simply copy the first 3 lines 2,3,4,5,etc. times*)
(*The bytes must be entered in decimal format, I.E the NOP code $90 must be entered as #144*)
(*In all these line you must enter the ORIGINAL value of the bytes*)
seek (f, 585299); (* File offset of byte 1*)
c := #116; (* Byte to write *)
write (f, c);
seek (f, 585300); (* File offset of byte 2*)
c := #2; (* Byte to write*)
write (f, c);
sound (220);
delay (120);
nosound;
writeln ('File already patched. Now, back to original state.');
writeln;
end else
(*The following lines depends on how many bytes you have to change*)
(*In this case, there are 3 bytes*)
(*If you have more, simply copy the first 3 lines 2,3,4,5,etc. times*)
(*The bytes must be entered in decimal format, I.E the NOP code $90 must be entered as #144*)
begin
seek (f, 585299); (* File offset of byte 1*)
c := #144; (* Byte to write *)
write (f, c);
seek (f, 585300); (* File offset of byte 2*)
c := #144; (* Byte to write*)
write (f, c);
sound (220);
delay(120);
nosound ;
writeln ('File successfully patched.');
writeln;
end;
end;
end.
//////////////////////////TAGLIATE QUI////////////////////////////////////////
Beh, anche se i commenti sono in inglese (l'ho fatto per distribuirlo su
internet..... la traduzione mi sembra superflua....) si dovrebbe capire bene.
Basta andare a sostituire i valori indicati, se ci sono più bytes da cambiare
si deve copiare alcuni pezzi più volte.... insomma, è già tutto fatto.
L'importante è convertire i bytes in HEX in decimale, con una qualsiasi
calcolatrice.... Avete notato la funzione di unpatching? Bellina eh?
Una cosa da notare: quando non trovate i bytes nel file, può essere perchè
gli indirizzi li cambia direttamente in memoria, e quindi nel file non
trovate solo l'offset. Quindi, cercate magari qualche byte prima (magari
segnatevi i bytes delle istruzioni PUSH e POP precedenti, che quelle le
trovate sempre) e andate a occhio. Tutto qua!
1.2. I TSR. Quando il patcher non basta......
Che cos'è il TSR? è un programma che và a modificare il contenuto della
memoria in maniera dinamica, ossia mentre il programma viene eseguito.
Serve principalmente quando il file magari è compattato in una maniera
proprietaria e non potete quindi trovarvi dentro i bytes.
Premetto che un TSR non lo sò scrivere, quindi, per evitare di sbattere le
palle a Moonshadow per farmelo in assembler, vi dico come usare un programmino
che trovate insieme al G3X, il TSRCRACK.
Dunque, funziona così:
1) Create un file testo del tipo
INT numero < interrupt al quale si aggancia. Deve essere nello stesso CS
dell'istruzione. Per trovarlo, usate la funzione INT MONITOR
del G3X su un interrupt di uso comune, es. il 21
IF CS:0000:ipdell'istruzione = byte1 byte2 byte3 byte4 (....)
THEN CS:0000:ipdell'istruzione = bytenew1 bytenew2 bytenew3 bytenew4 (...)
2) Tornate al DOS e scrivete TSRCRACK nomefile.txt. Et voilà, TSR pronto.
Naturalmente, lo dovete caricare SEMPRE, prima del programma protetto.
Questo metodo vale solo per i programmi che non usano il DOS4GW, e comunque
che non usano dos-extenders. Per questi particolari programmi, bisogna creare
dei TSR ad-hoc, e io..... non sono ancora in grado. Al limite, chiedete a
Moonshadow....
Comunque, niente paura: la quasi totalità dei programmi (anzi, diciamo pure
tutti) non richiede TSR. Basta un patch!!!
1.3. Trainers, come finire i giochi senza cheat-mode!
Qui sarò sbrigativo. Il metodo descritto funziona solo con i giochi non in
protected mode (quindi niente DOS4GW o extenders vari).
1) Caricate il G3X
2) Caricate il gioco, iniziate a giocare
3) Entrate nel G3X e scegliete GLOBAL ANALYSIS, BYTE, <return>
4) Tornate al gioco e perdete una vita o fate diminuire l'energia o il tempo
5) Entrate nel G3X, GLOBAL ANALYSIS, DECREASE
6) Ripetete dal punto 4 al 5 per un pò di volte, fino a quando non trovate
una locazione giusta..... cioè, con i valori es. 04 03 02 01
7) Mettete un BP Read-Write a quella locazione
8) Tornate al gioco, riperdete una vita/energia/tempo
9) Quando torna al debugger (se la locazione è giusta) segnatevi i bytes
dell'istruzione (di solito un DEC) e da qui in poi, procedete come
se fosse un crack qualsiasi (disk editor, patcher)
Non vi allego il patcher modificato, tanto penso che la cosa sia intuitiva.
Praticamente, basta cambiare le scritte, il procedimento è lo stesso.
Considerate che quando fà il patch mette il trainer, quando fà l'unpatch
riporta il gioco in condizioni normali.
Essendo ora tutti i giochi in protected mode, comunque, questo metodo funziona
solo con i giochi vecchi..... oppure con gli emulatori tipo C64S (però in
questo caso non fate il patcher, meglio caricare il G3X in memoria ogni
volta che si vuol giocare!). Se volete fare trainer per i giochi in DOS4GW,
meglio prendere qualcosa tipo il GameWizard32 (lo trovate su internet).
------------------------------------------------------------------------------
CONCLUSIONI E CONSIDERAZIONI FINALI
------------------------------------------------------------------------------
Dunque, siamo alla fine. Spero che questo tutorial vi sia servito, io da parte
mia ho cercato di farlo nel migliore dei modi, accessibile a tutti.
Non pensate comunque di riuscire a crackare qualcosa alla prima, il tutto
richiede logicamente un pò di pratica. Man mano che proverete, comunque,
troverete tutto più facile di volta in volta.
Per trovare i programmi necessari (SoftICE x Windows95, se volete anche per
DOS, e il disk editor), basta cercare con AltaVISTA o simili la parola "Hack"
o "Crack" o "Phreak". Troverete migliaia di siti, basta cercare un minimo
e troverete quello che cercate.
Inoltre, scarivatevi *SUBITO* la guida di +ORC (la migliore al mondo e penso
nell'universo) .... le varie parti abbastanza aggiornate le trovate a
www.dodgenet.com/~kwantam nella sezione "Hacking Textz". Ci sarebbe anche il
sito quasi-ufficiale di +ORC, ma quello non ve lo dico.... vi rovinerei il
divertimento nel cercarlo..... sappiate solo che con i vari spiders non lo
troverete mai, quindi .... l'unica è rovistare tra i vari links nelle pagine
hackers per vedere se scovate qualcosa! Eh eh eh.....
Sicuramente ho tralasciato qualcosa (e chi non lo fà), ma d'altra parte non
potevo certo spiegarvi TUTTE le situazioni (cambiano sempre)....
Del resto, basta un pò di pratica e troverete da soli le risposte alle vostre
domande! Ah, dimenticavo: >>>>>NON MI E-MAILATE TANTO NON VI RISPONDO<<<<<<.
(O, swanne, mi raccomando eh? ir tegame di tu ma se mandi ir mi indirizzo a
giro..... un mi vorrai mia fà arrestà eh? sennò poi l'artiolini ganzi chi
te li scrive..... via swanne, ammodino eh, che se stai bono ti fo' anche
ir crachin manua' in livornese!). -
DarkDevil88.
User deleted
bella lì . -
MS-DOS.
User deleted
Guida Perfetta. La metto in rilievo 
.
altra guida al cracking |