Disclaimer
Ne io ne lo Staff di Sciax2 si assume alcuna responsabilità per quanto riguarda questo contenuto. Tutto è solamente a scopo informativo.Prima di iniziare suggerisco di leggere un manuale di Assembly 8086 facilmente reperibile sul web per comprendere meglio la lettura dei codici ;)
Scrivo questa guida per tutti quelli che come me all'inizio avevano problemi con i virus e non sapevano tanto bene cos'erano xD
Iniziamo:
1)Cos'è un virus informatico
Come ai virus biologici, un virus informatico è un programma che replica se stesso. Detto così però non può apparire tutto chiaro xD. Sui libri specifici troverete le definizioni di virus che via via sono nate che per, coem tutte le definizioni, sono molto difficili da capire. Facciamo un esempio mettendo a confronto i virus biologici e informatici: un virus biologico è un essere che attacca una cellula si replica dentro la cellula e manda il suo clone ad attaccare un altra cellula (se lo legge la mia prof rimarrà sbalordita xD). Ora pensiamo alle nostre cellule come se fossero file eseguibili (e nn solo xk poi vedremo il xk!) e al virus come ad un virus informatico. Tuttavia esiste una radicale differenza: il virus per agire deve essere eseguito. Infatti un virus informatico è del tutto simile ad un normale programma che contiene normalissime istruzioni per la macchina! Proprio per questo motivo è impossibile, per la CPU, riconoscere il codice di un virus. Tuttavia ci sono dei "segni distintivi" che possono aiutare a riconoscerlo ma ne parleremo piu' avanti. Al momento basta sapere che un virus (da quì in poi per "virus" intendo virus informatico tanto x capirci meglio xD) e' un programma e deve essere eseguito (non sempre vero, ma poi spegherò xk).
2) Proprietà comuni dei virus
Un virus per essere tale deve fondamentalmente essere in grado di replicare se stesso. All'atto pratico, nella maggioranza dei casi, ciò non è sufficente. Infatti esso deve, per quanto possibile, deve seguire le seguenti regole:
- Essere invisibile
- Non provocare errori che possano insospettire l'utente
- Non occupare troppo tempo macchina
- E non occupare molto spazio
La prima regola è propria dei virus STEALTH, che vedremo in seguito, riescono a nascondersi dall'utente
3)Classi dei virus
Classi di virus ce ne sn tante e quindi non tutti i virus si comportano allo stesso modo. Ecco una distinzione "gerarchica" xD dei virus
Virus Binari: Companion, Overwrite, Filling, Append, Boot.
Virus Non Binari: Hoax, Macro virus, "Exploit" virus
Avverto che alcune classi non hanno i nomi che ho indicato: questo xk alcune classi NON hanno un nome specifico ;)
Partiamo ad analizzarli
3.1) Virus Binari
Con la dicitura "Virus Binari" mi riferisco a tutti i virus scritti in un linguaggio di programmazione (generalmente Assembly o anche C) e compilati. I Virus Binari sono percui dei veri e propri programmi da eseguire in linguaggio macchina.
3.1.1) Companion
I virus Companion sono dei virus strani: essi si replicano senza danneggiare alcun file ma utilizzano una tecnica propria del MS-DOS.
La priorita' di esecuzione dei file sotto MS-DOS e':
1) .BAT
2) .COM
3) .EXE
I virus Companion utilizzano prorpio questa caratteristica, ovvero se noi
abbiamo in una directory X un file chiamato X.EXE, il virus copia se
stesso in un file X.COM in modo che se noi eseguiamo 'X' lanciamo il .COM
ovvero il virus! xD Naturalmente all'interno del virus ci saranno delle
routine specifiche per eseguire anche X.EXE per evitare "sospetti".E' ovvio
che il file X.COM e' spesso settato con l'attributi HIDDEN cosicchè con
un eventuale 'dir' non vediamo il nostro "amico" :smile:.
3.1.2) Overwrite
Questa classe di virus è la più criticata: in pratica il nostro virus sovrascrive in maniera irreversibile il file originale, andando contro la
regola 2(NOn provocare errori che possono insospettire l'utente). In pratica se X.EXE prima dell'infezione è un "editor" dopo l'infezione, sarà solo il virus. Percui se dovete scrivere una
lettera e lanciate X nessun editor vi apparirà! La domanda che un utente
si pone a questo punto è: "Perche' ?" ed è ciò che bisogna evitare in
un virus. Proprio per questo non affatto consigliabile scrivere virus di tipo Overwrite.
Prima dell'infezione:
X.EXE -> [CODICE DEL FILE X.EXE]
Size: 10345 Byte
Dopo l'infezione:
X.EXE -> [CODICE DEL VIRUS][PARTE RESTANTE DI X.EXE]
Size: n Bytes Size: 10345-n Bytes
solo che la parte restante non viene mai eseguita. L'unico vantaggio di questo tipo di virus è che la dimenzioen del file rimane, spesso,
invariata.
3.1.3) Filling
Questa classe è a mio avviso la più affascinate di tuttexD. Un virus di tipo FILLING è spesso, per ragioni di sicurezza, anche APPEND. Poi vedremo xk.
Questo tipo di virus, solitamente di dimensioni molto piccole, cerca nel
file da "infettare" uno spazio vuoto in cui nascondersi. Spesso infatti nei programmi ci sono degli spazi vuoti usati in fase di esecuzione come stack e non contenenti alcun dato utile. Il virus ci si copia dentro senza che nessuno noti nulla: anche la dimensione del file ospite rimane invariata. In fase di esecuzione,poi, viene eseguito prima il virus e poi il programma originale. Ecco un esempio in ASM:
[file TEST.COM non infetto]
start: JUMP main
stack DB 100 DUP(00h)
main: NOP
[codice del programma]
una volta compilato il codice binario sara' qualcosa tipo:
[0000] E9 00 10 [un ipotetico JUMP a main:]
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
...
00 00 00 00 00 00 00 00
[0100] 90 [Mnemonico del NOP, prima istruzione di main:]
il virus si annida nei 100 bytes a 00 (ammesso che il virus sia grande <=
100Bytes) e dopo l'infezione il file TEST.COM sara':
N.B. XX sta' per codice del virus.
[0000] E9 00 01 (Ora JMP salta al codice del virus, sara' poi compito del
virus stesso di eseguire il codice originale)
XX XX XX XX XX XX XX XX
...
XX XX XX XX XX XX XX XX
[0100] 90 [Mnemonico del NOP, prima istruzione di main:]
in fase di esecuzione:
[ESEGUI CODICE DEL VIRUS]->[ESEGUI CODICE ORIGINALE]
cosi' l'utente non si accorge di nulla in quanto il programma funziona
ancora perfettamente perche'il virus ha usato lo spazio per i DATI e non
per il CODICE.
Un ipotetico diagramma di flusso di un file FILLING sara':
(START) -> APRO FILE -> CERCO n BYTES a 00h (che non corrispondono ad
alcun mnemonico e che sono, proprio per questo motivo, dati) -> COPIATI
DENTRO ALLO SPAZIO -> PRELEVA PUNTO DI ESCUZIONE ORIGINALE -> SCRIVI IL
TUO PUNTO DI ESECUZIONE -> (FINE)
3.1.4) Append (Non Overwriting virus)
Eccoci alla classe di virus più diffusa, quella APPEND. Questo particolare tipo di virus si attacca al programma originale conservandone le proprietà. Funziona analogamente al tipo FILLING solo che questo tipo si copia esclusivamente alla fine del file.
Non infetto:
TEST.COM [DATI E CODICE DI TEST.COM]
Size: n Bytes
Dopo l'Infezione:
TEST.COM [DATI E CODICE DI TEST.COM][DATI E CODICE DEL VIRUS]
Size: n + v_size Bytes
Come avrete notato si ha un aumento in dimensioni del file contrastando la
regola 1. Infatti un utente con un semplice 'DIR' puo' notare che il file
è cresciuto
ed e' per questo che bisogna attenersi il piu' possibilealla regola 4. C'e' anche una seconda soluzione: lo STEALTH di cui
parlerò più avanti. Ecco un esempio di come funziona un virus APPEND (Non Overwriting Virus).
TEST.COM Originale Size: n Bytes
start: JUMP main
data DB 20 DUP(00)
main:
nop
nop
nop
int 20h [Fine del programma]
TEST.COM Infetto Size: n + virus_size Bytes
start: JUMP inizio_virus
data DB 20 DUP(00)
main:
nop
nop
nop
int 20h
inizio_virus:
[mi_faccio_i_cavolazzi_miei]
JUMP main
Come potete osservare per l'utente che esegueil programma infetto non
cambia assolutamente nulla: il codice del programma originale è sempre
eseguito e siamo ok per la regola 2.
Un ipotetico diagramma di flusso potrebbe essere il seguente:
(START)->MI COPIO ALLA FINE DEL FILE OSPITE->GUARDO IL SUO PUNTO DI INIZIO ESECUZIONE->ME LO ANNOTO->SCRIVO IL MIO PUNTO DI ESECUZIONE->(FINE)
In fase di esecuzione il virus, alla fine dei suoi lavori, fa' un JUMP al programma originale et voilà, le jeux son fait xD
3.1.5)Boot virus
Adesso parlo(x correttezza xD) della calsse di virus che in passato ha
causato più danni. Adesso solo pochi scrivono questi virus ma è giusto sapere che anche loro esistono. Famosissimo di questa classe è il Virus Michelangelo.
Il loro principio di funzionamento e' semplice: un tempo gli HD costavano
molto e i CD manco si conoscevano. I Floppy-disk erano molto comuni e si
usavano spesso come System Disk. All'avvio del computer (ancora oggi e'
cosi) il BIOS cerca se un dischetto nel floppy-drive e' presente. Se c'e' esso carica ed esegue il primo settore che dovrebbe contenere il Bootstrap Loader (ovvero lanciare il sistema, come nei dischi di ripistino di Windoze). Il Bootstrap Loader e' un programma "particolare" che viene eseguito come un qualsiasi altro programma.
Il seguente esempio è tratto dal virus Terror2: :O
boot_start:
db 0E9h <<
db 9Dh << QUESTI 3 BYTES SONO IL JUMP A str_end:
db 00h <<
db "TERROR2" << ETICHETTA DEL DISCO
str_boot:
db " << The Terror II Virus >> ",13,10
db "PolyMorphic Stealth Boot Virus.",13,10
db " Created by Dark Monk.",13,10
db " '' Fuck MS-DOS ! ,, ",13,10
str_end:
db 29 DUP (90h) ; Scrivi 30 NOP
mov ax,0001h ; 320 * 200
int 10h ; Video
mov ah,0Fh
int 10h
...
Il settore di BOOT ha una specie di HEADER che serve al BIOS per capire
che dischetto e'. Al momento non ne ho le specifiche sotto mano ma
comunque in rete ci sono, cercate ! ;)
Allora cosa succede ?
Inserisci il dischetto nel drive, accendi il PC, il BIOS carica il codice della traccia 0 e lo esegue....e se e' un virus ? Se e' un virus esso ha il controllo della macchina. Certo, sono necessari accorgimenti
particolari: primo fra tutti è che il settore è 512 Bytes, di cui circa
400 utilizzabili percui un virus, prima di tutto, carichera' il suo corpo
principale in memoria e lo eseguirà. In pratica nel settore di BOOT non
c'e' il VIRUS ma il LOADER del VIRUS. Il VIRUS vero e proprio si occuperà
poi di ripistinare, in modo da seguire le regole 1 e 2, il vero boot record e di eseguirlo.
3.2) Virus non binari
I Virus Non Binari (molti mi criticheranno ma non importa) sono quelle
cose che per replicarsi non devono essere, necessariamente, eseguite.
Una annotazione a parte per i virus "EXPLOIT": questo tipo di virus si
basa su errori di un particolare programma. Mi riferisco, in questo caso,
a Microsoft Outlook Express che i n una versione, in particolari
condizioni, eseguiva un file in ATTACH senza il permesso e/o la richiesta
dell'utente. Ovvio che un ipotetico file in ATTACH poteva infettare un
sistema semplicemente inviandolo tramite E-Mail. ;) In generale i VIRUS NON BINARI sono quei virus non il linguaggio macchina.
3.2.1) Hoax
Gli HOAX (Bufale) sono una nuova classe di virus apparsa su Internet e
diffusa grazie alla 'lameraggine' degli utenti:mad. Ho gia detto che un virus,
per essere tale, deve replicare se stesso. Per questa proprietà
fondamentale, un qualsiasi messaggio che riporti una dicitura del tipo:
SE INVII QUESTO MESSAGGIO AD ALTRE 5 PERSONE VINCERAI 1 MILIONE DI EURO!
i piu' boccaloni invieranno subito, senz esitare, questo messaggio ad altre 5 persone provocando una crescita del "virus" di ragione 5 ovvero:
START
|
+-----+-----+-----+-----+
| | | | |
+++++ +++++ +++++ +++++ +++++
||||| ||||| ||||| ||||| |||||
|
+-----+-----+-----+-----+
| | | | |
+++++ +++++ +++++ +++++ +++++
||||| ||||| ||||| ||||| |||||
quindi in 2 passaggi si hanno gia' 5*5 copie del messaggio creando una vera e propria infezione >.<. In 100 passaggi si hanno ben 5^100 messaggi causando uno SPAM di dimensioni enormi !
3.2.2) Macro virus
I Macro Virus sono nati grazie ad una fatale caratteristica dei prodotti
Microsoft Office. Per velocizzare alcune operazioni frequenti e' possibile creare delle Macro (chi programma sa' cosa sono) per velocizzare queste
operazioni. Nelle macro di MS Office e' possibile specificare di tutto: apertura dei file, cancellazione, formattazione, etc..Una delle cose che
non permettono, per fortuna,e' la ripartizione del disco (ref. Melissa Virus). Immaginatevi percui se invio ad un mio amico un documento .doc con
una macro (le macro sono dento i documenti !) con l'ordine di cancellare
tutto l'HD ! Fortunatamente i Macro Virus sono diffusi solo su sistemi Microsoft, e piu' che virus sembrano vendette !!! xD
3.2.3) Exploit virus
COme già accennato gli EXPLOIT virus sfruttano delle particolari proprieta' dei Sistemi Operativi per diffondersi. Anche i VERMI di Internet utilizzano questa caratteristica ma non sono virus percui non ne parlo
. Il piu' famoso e' stato quello relativo ad Outlook Express che, se inviavi un file infetto in ATTACH con un nuone piu' lungo di 255 caratteri si provocava un Buffer Overflow con conseguente esecuzione del codice del file in ATTACH.[E-MAIL+ATTACH]->[OUTLOOK EXPRESS]->[BUFFER OVERFLOW & CRASH]->[ESEGUI
ATTACH]
Se ATTACH e' un virus appositamente progettato, ci ritroviamo con il
sistema infetto.
Non aggiungo altro all'argomento anche xche non sono molto ferrato sulla
questione. xD xD
4) Stealth
I virus stealth sono tra i piu' pericolosi. Analogamente all'F117
(Quell'aereo caccia-bombardiere stealth) i virus stealth sono "invisibili" e cercano in ogni modo di coprirele proprie tracce. Per riuscirci utilizzano delle caratteristiche base del sistema. Per esempio un virus Dir Stealth (cheriesce a non far notare l'incremento di dimensione di un file con il comando 'dir') si basa sul fatto che il COMMAND.COM, all'arrivo di un 'dir' esegue un certo comnado sull'INT 21h (Interrupt 21h) e ne visualizza la risposta. Il nostro virus, di conseguenza, cerchera' di modificare la risposta. Ma come ?
Ecco uns asemplice rappresentazione dell atabella degli interrupt in un sistema "sano":
[DOS] -> [INT 01h] -> Routine Int 01h -> Ret
[INT 02h] -> Routine Int 02h -> Ret
[INT ...] -> Routine Int ... -> Ret
[INT 21h] -> Routine Int 21h -> Ret
N.B. 'Ret' significa "ritorno al chiamante, o al DOS".
ed adesso in un sistema inefftato da uno *pseudo* virus steath (e non
solo):
[DOS] -> [INT 01h] -> Routine Int 01h -> Ret
[INT 02h] -> Routine Int 02h -> Ret
[INT ...] -> Routine Int ... -> Ret
[INT 21h] -> Virus -> Routine Int 21h -> Virus -> Ret
Come vediamo il nostro virus *filtra* le chiamate in ingresso ed in uscita. Se esso rileva una chiamata di 'dir' (poi entrero' nei particolari) chiama l'INT 21h originale e ne attende la risposta, indi modifica il risultato in modo che l'utente non noti nulla e ritorna al chiamante. Il chiamante, ovviamente, non si accorge di nulla. Per capire come funziona il modo di intercettazione delle chiamate di Interrupt bisogna capire cosa sono gli Interrupt !
Ecco com'e' strutturata la tabella degli interrupt locata nella posizione
0000:0000 (Segmento 0 Offset 0) della memoria di sistema:
Offs | 4b | 4b |
-----+----+----+
0000 OffA SegA
0004 OffB SegB
0008 OffC SegC
...
In pratica chiamando l'INT 00 faccio una Call assoluta all'indirizzo SegA:OffA. Con l'INT 01 a SegB:OffB e cosi' via. Per accedere ad un elemento della tabella di interrupt basta scrivere queste righe:
xor ax,ax
mov es,ax ; ES = AX = 0
mov bx,word ptr es:[4*21h+0] ; OffSet
mov ax,word ptr es:[4*21h+2] ; Segmento
mov word ptr ds:[INT21h],bx ; Offset
mov word ptr ds:[INT21h[2]],ax ; Segmento
cli ; Disabilita INT
*** ADESSO METTO NEL VETTORE IL PUNTATORE ALLA NOSTRA ROUTINE:
mov word ptr es:[4*21h+0],offset newint21h ; OffSet della routine
mov word ptr es:[4*21h+2],ds ; Segmento della routine
sti ; Riabilita INT
Per semplicita' basta pensare che un Interrupt e' una Call ad una routine
particolare. Ecco una breve lista delle funzioni comuni dei primi
interrupt:
INT 00 - CPU-generated - DIVIDE ERROR
INT 01 - CPU-generated - SINGLE STEP; (80386+) - DEBUGGING EXCEPTIONS
INT 02 - external hardware - NON-MASKABLE INTERRUPT
INT 03 - CPU-generated - BREAKPOINT
INT 04 - CPU-generated - INTO DETECTED OVERFLOW
INT 05 - PRINT SCREEN; CPU-generated (80186+) - BOUND RANGE EXCEEDED
INT 06 - CPU-generated (80286+) - INVALID OPCODE
INT 07 - CPU-generated (80286+) - PROCESSOR EXTENSION NOT AVAILABLE
INT 08 - IRQ0 - SYSTEM TIMER; CPU-generated (80286+)
INT 09 - IRQ1 - KEYBOARD DATA READY; CPU-generated (80286,80386)
INT 0A - IRQ2 - LPT2/EGA,VGA/IRQ9; CPU-generated (80286+)
INT 0B - IRQ3 - SERIAL COMMUNICATIONS (COM2); CPU-generated (80286+)
INT 0C - IRQ4 - SERIAL COMMUNICATIONS (COM1); CPU-generated (80286+)
INT 0D - IRQ5 - FIXED DISK/LPT2/reserved; CPU-generated (80286+)
INT 0E - IRQ6 - DISKETTE CONTROLLER; CPU-generated (80386+)
INT 0F - IRQ7 - PARALLEL PRINTER
INT 10 - VIDEO; CPU-generated (80286+)
INT 11 - BIOS - GET EQUIPMENT LIST; CPU-generated (80486+)
INT 12 - BIOS - GET MEMORY SIZE
INT 13 - DISK
INT 14 - SERIAL
INT 15 - CASSETTE
INT 16 - KEYBOARD
INT 17 - PRINTER
INT 18 - DISKLESS BOOT HOOK (START CASSETTE BASIC)
INT 19 - SYSTEM - BOOTSTRAP LOADER
INT 1A - TIME
INT 1B - KEYBOARD - CONTROL-BREAK HANDLER
INT 1C - TIME - SYSTEM TIMER TICK
INT 1D - SYSTEM DATA - VIDEO PARAMETER TABLES
INT 1E - SYSTEM DATA - DISKETTE PARAMETERS
INT 1F - SYSTEM DATA - 8x8 GRAPHICS FONT
INT 20 - DOS 1+ - TERMINATE PROGRAM
INT 21 - DOS 1+ - Function Calls
INT 22 - DOS 1+ - PROGRAM TERMINATION ADDRESS
INT 23 - DOS 1+ - CONTROL-C/CONTROL-BREAK HANDLER
INT 24 - DOS 1+ - CRITICAL ERROR HANDLER
INT 25 - DOS 1+ - ABSOLUTE DISK READ
INT 26 - DOS 1+ - ABSOLUTE DISK WRITE
INT 27 - DOS 1+ - TERMINATE AND STAY RESIDENT
INT 28 - DOS 2+ - DOS IDLE INTERRUPT
INT 29 - DOS 2+ - FAST CONSOLE OUTPUT
Naturalmente 'newint21h' e' un puntatore alla nostra routine, alla routine
del virus:
INT21H dd ?
newint21h proc far
Assume CS:CODE_SEG, DS:Nothing
cmp ah,4Bh ; Load and Execute ?
je load_execute
cmp ah,11h ; Find First Matching File (Dir Stealth)
je dir_stealth
cmp ah,12h ; Find Next Matching File (Dir Stealth)
je dir_stealth
cmp ax,4300h ; Get File Attributes
je load_execute
cmp ax,4301h ; Set File Attributes
je load_execute
cmp ah,3Dh ; Open File
je load_execute
cmp ah,4Eh ; Find First Matching File (Dir Stealth)
je newdir_stealth
cmp ah,4Fh ; Find First Matching File (Dir Stealth)
je newdir_stealth
jmp do_int_now
Ecco, per capire questa parte di codice è opportuno addentrarsi ancora di
più delle chiamate di sistema: L'interrupt 21h *contiene* tutte le chiamate importanti del nostro MS-DOS. Consultando le RalphBrown Interrupt List si vede che l'INT2h e' quello che conta più funzioni di tutti gli altri Int.
comunque ce ne sono veramente tante. Vale la pena cercare su Internet le
Ralph Brown Interrupt list e dargli uno sguardo: sono affascinanti.
Non e' scopo di questo documento insegnarvi a scrivere virusma di imparare
a conoscerli percui non mi addentrero' nei possibili utilizzi delle
chiamate ne sui dettagli tecnici. Spero che abbiate compreso cosa sono gli
Interrupt, come si usano e a cosa servono. xD
Per concludere questo affascinante argomento eccovi un breve diagramma di
flusso di una procedura DIR STEALTH:
(INIZIO) --> <FIND FIRST ?> -Yes->[Chiama INT21h originale]--+
| | |
+-No--> <FIND NEXT ?> -Yes-+ <File Infetto ?>
| | |
(FINE)<---------------No-+ |
^--[Modifica risultati]<--Yes-+
| | |
+-No--> <FIND NEXT ?> -Yes-+ <File Infetto ?>
| | |
(FINE)<---------------No-+ |
^--[Modifica risultati]<--Yes-+
5) Encription
Questa curiosa ed interessante caratteristica ha fatto si' che gli Anti Virus avessero un "problemuccio" in più. Infatti con questa carateristica, spesso, i 'Pattern Matching AV' fallivano. Questa tecnica consiste di rendere un virus invisibile crittandone i contenuti. Ovviamente deve rimanere inalterata quella parte di codice che permette la successiva decrittazione e proprio questo gli rende facilmente intercettabili. Tuttavia vale la pena vedere come funziona. Le tecniche per la codifica/decodifica sono infinite, anche se per semplicita' e
velocità (ricordate regole 3 e 4 ?) sono preferite quelle simmetrice con lo XOR. Guardiamoci la tabella della verita' di una funzione XOR:
A | B | O
---+---+--- ___
0 0 0 A -\ \
1 0 1 | >-- O
0 1 1 B -/___/
1 1 0
Immaginiamoci questo dato: 00010010 da codificare con XOR con questa
chiave: 01100110
00010010 XOR
01100110
-----------
01110100
adesso proviamo a "codificare" il isultato (01110100) con la stessa chiave
(01100110):
01110100 XOR
01100110
---------
00010010
Magia !xD Come vedete il risultato è assolutamente il dato originale
(00010010) ed ecco xche la funzione XOR e' chiamata simmetrica: con due
codifiche successive si ottiene il risutato iniziale.
Ecco che allora la routine di codifica/decodifica è la stessa.
Ma in dettaglio come funziona un virus crittato ?
[INIZIO VIRUS]
start_enc:
[ROTUINES_VARIE_DEL_VIRUS]
end_enc:
[CRIPT_DECRIPT_ROUTINE]
noi crittiamo solo il codice tra start_enc e end_enc in quanto un codice macchina crittato non e' piu' esegubile ! Ecco che allora , al monento dell'esecuzione, dobbiamo prima richiamare la funzione CRIPT_DECRIPT_ROUTINE per rendere il virus esegubile. Il problema sta' nel
fatto che la CRIPT_DECRIPT_ROUTINE non e' codificabile e quindi rilevabile
dagli antivirus.
6) Anti A.V
Questa categoria di trucchi e'molto divertente da applicare.Lo scopo
principale è fare in modo che l'AntiVirus non riconosca che quel codice è un virus ;). I metodi per farlo sono molti e si basano essenzialmente su alcune "pecche" degli AV. Sulla rivista specializzata VLAD ci sono moltissime tecniche ben descrite.
Ecco un esempio di cm "tentare" utilizzando delle Garbage Instruction (istruzioni spazzatura)
get_offs:
pop bp
inc ax ; << Garbage Instruction (confuse AV)
sub bp,offset get_offs ; In BP offset
; Check if encrypt
mov si,ds:[34h] ; << Garbage Instruction (confuse AV)
lea si,(encrypt_start + bp)
xchg di,si ; << Garbage Instruction (confuse AV)
xchg di,si ; << Garbage Instruction (confuse AV)
cmp byte ptr cs:[si],90h ; Encrypted ?
je encrypt_start ; Seems to be not
; Decryption Routine
lea si,(Key + bp)
add si,2 ; << Garbage Instruction (confuse AV)
xchg bx,si ; << Garbage Instruction (confuse AV)
dec bx ; << Garbage Instruction (confuse AV)
xchg bx,si ; << Garbage Instruction (confuse AV)
mov bx,ds:[si] ; BX = Key
lea si,(encrypt_start + bp) ; SI = Start of encrypted part
mov cx,((offset encrypt_end - offset encrypt_start)/2)+1 ; CX Size
dec_loop:
mov ax,word ptr ds:[si] ; 16-Bit simple XOR encryption
int 03h ; << Garbage Instruction (confuse AV)
xor ah,bl
int 03h ; << Garbage Instruction (confuse AV)
xor al,bh
mov word ptr ds:[si],ax
inc si
int 03h ; << Garbage Instruction (confuse AV)
inc si
loop dec_loop
Le righe commentate con "Garbage Instruction..." si riferiscono ad
istruzioni *dummy* che rendono insensato (o,perlomeno, ci provano !) il
codice confondendo l'AntiVirus. Con questa metodologia si va' contro la
regola 4 ma bisogna cercare di trovare un buon compromesso tra difese e
offese.
Vorrei parlare dei polimorfici ma sono rari e cmq il polimorfismo nn è alla portata di tutti (nn è portata neanche alla mia xD)
Spero Vi sia servita questa guida e leggete bene il Disclaimer ;P
E dopo 2 ore e mezzo di stesura ecco fatto xD
FONTE :
Perfavore,
Entra
oppure
Registrati
per vedere i Link!
:ciao:
Ultima modifica da un moderatore:
