Guida alla scrittura dei virus "Divertenti" di Dark Angel
Gli ____ _ ___ ___ __ ______ ____28-09-98
/ __/__ (_) _ \/ _ \___ / / ___ /_ __/__ ____/ _/ ASCII
_\ \/ _ \/ / ___/ ___/ _ \/ /_/ _ `// / / _ \/ __// / by
/___/ .__/_/_/ /_/ \___/____|_,_//_/ \___/_/ /___/RigoR Mortem
/_/
Presentano: Guida alla scrittura dei virus "Divertenti" di Dark Angel
Tradotto da : El Mariachi
Supervisione di : RigoR MorteM
DECLINAZIONE DI RESPONSABILITA': Il sottoscritto autore declina ogni responsabilit‡
DEDICATO: Questo manuale Ë stato scritto per rendere la vita un inferno vivente a canaglie quali Patty Hoffman, John McAffee, e Ross Greenberg.
ALTRI RINGRAZIAMENTI: Ringraziamenti vanno a The Shade of Sorrow, Demogorgon, e Orion Rouge per i loro commenti (che io occasionalmente ho anche ascoltato!).
Ringraziamenti anche a Hellraiser, che mi ha dato un esempio di codici sorgenti di alcuni virus (i suoi, naturalmente).
Guida alla scrittura dei virus "Divertenti" di Dark Angel
I virus sono meravigliose creazioni scritte per il solo scopo di propagarsi e distruggere i sistemi di insospettabili babbei. Questi eliminano i sistemi di ingenui che non possono dire che non c'Ë un problema quando un file di 100 byte repentinamente diventa un file di 1000 byte. Toh. Questi esseri inferiori non meritano di esistere, cosÏ Ë nostro sacro dovere cancellare i loro hard disk dalla faccia della terra. E per il semplice scopo di velocizzare la sopravvivenza delle specie superiori.
PerchÈ ho creato questa guida? Dopo aver scritto parecchi virus, ho saputo che i creatori di virus generalmente imparano come scrivere un virus sia da soli oppure esaminando il codice dissassemblato di altri virus. C'Ë una incredibile mancanza di informazione sul soggetto. Anche i libri pubblicati dagli stupidi come Burger sono, al massimo, delle bozze su come creare un virus. Questa guida vi mostrer‡ cosa Ë necessario per scrivere un virus e anche vi dar‡ esempi di codici sorgenti da includere nei vostri virus.
Scrivere un virus non Ë cosÏ difficile come tu puoi inizialmente immaginare. Per scrivere un vero virus, comunque, devi conoscere il linguaggio assembly. Brevit‡, compattezza di codice, sono caratteristiche del linguaggio assembly e queste sono caratteristiche desiderabili per un virus. Comunque, non Ë necessario scrivere in puro assembly. PuÚ essere anche usato il C, poichÈ consente un completo controllo del sistema e genera un codice relativamente compatto (se stai lontano dalle librerie di funzioni). Comunque, tu devi sempre accedere agli interrups, cosicchÈ Ë lo stesso richiesta la conoscenza dell'assembly. Comunque Ë ancora meglio insistere con l'assembly puro, giacchÈ molte operazioni possono essere implementate molto pi˘ semplicemente con l'assembly. Se non conosci l'assembly, ti voglio raccomandare di procurarti una copia di "The Microsoft Macro Assembler Bible (Nabajyoti Barkakati, ISBN #: 0-672-22659-6). E un libro facile da seguire che tratta in grande dettaglio l'assembly. Ancora, procurati una copia di" Undocumented DOS (Schulman, et al, ISBN #0-201-57064-5), che risulta molto utile.
Sorge spesso la questione di quale compilatore usare. Io suggerisco di usare il Borland Turbo Assembler e/o Borland C++. Io non ho una copia del Zortech C (Ë troppo grosso per scaricarlo), ma sospetto che sia anche una buona scelta. Stai lontano dai compilatori Microsoft, perchÈ non sono flessibili e nÈ efficienti come la concorrenza.
Sono pochi gli articoli che vertono sulle liste di tools utili nella costruzione di virus. L'ultima versione delle Norton Utilities Ë uno dei programmi pi˘ potenti disponibili, e immensamente utile. ASSICURATI DI AVERNE UNA COPIA! Tu lo puoi trovare su ogni desktop decente. Esso puÚ essere usato durante ogni passo del processo, dalla scrittura al testing. Serve un buon Debugger. Utilit‡ di gestione memoria come MAPMEM, PMAP, e MARK/RELEASE, sono inestimabili, specialmente quando implementi virus TSR. Sourcer disassembler che commentano sono utili quando vuoi esaminare il codice di altri virus (questo Ë un buon metodo per prendere idee/tecniche per i vostri virus).
Ora che avete i vostri tools, voi siete pronti per creare un capolavoro disegnato per spezzare i sistemi dei cretini. Ci sono tre tipi di virus:
- Virus minuscoli (sotto i 500 bytes) che sono progettati per essere non rintracciabili proprio per la loro piccolezza. TINY Ë uno di tali virus. Essi sono generalmente molto semplici poichÈ la lunghezza del loro codice Ë limitata.
- Virus larghi (oltre 1,500 bytes) che sono progettati per essere non rintracciabili perchÈ coprono le loro tracce molto bene (tutto quel codice DEVE servire!). Il migliore esempio di questi Ë il virus Whale, che Ë forse il migliore 'Stealth'o invisibile virus esistente.
- altri virus che non sono progettati per essere nascosti a tutti(gli scrittori non valgono una merda). I comuni virus sono come questi. Tutti i virus che sovrascrivono sono in questa categoria.
Tu devi decidere che genere di virus desideri scrivere. Io per lo pi˘ tratterÚ il secondo tipo (Stealth virus). Comunque, molte delle tecniche descritte possono essere facilmente applicate alla prima tipologia di virus (tiny virus). Comunque, i virus compatti generalmente non hanno molte delle "caratteristiche" dei virus pi˘ estesi, come le directory trasversali. Il terzo tipo Ë poco pi˘ di una tipologia di trojan che si replica, e garantirÚ solo una breve (molto, molto breve!) discussione pi˘ tardi.
Un virus puÚ essere diviso in tre parti: Il replicatore, l'occultatore, e la bomba. Il replicatore controlla la diffusione del virus agli altri files, l'occultatore evita che il virus venga riconosciuto, e la bomba viene eseguita solo quando le condizioni per l'attivazione del virus (il pi˘ tardi possibile) sono soddisfatte.
IL REPLICATORE
Il lavoro del replicatore Ë di diffondere il virus attraverso il sistema del babbeo che ha preso il virus. Come lo fa senza distruggere il file che infetta? Il pi˘ semplice tipo di replicatore infetta i files COM. Egli prima salva i primi pochi bytes del file infetto. Esso poi copia una piccola porzione del suo codice all'inizio del file, e il resto alla fine.
+----------------+ +------------+
| P1 | P2 | | V1 | V2 |
+----------------+ +------------+
Il file non infettato Il codice virus
Nel diagramma, P1 Ë la parte 1 del file, P2 Ë la parte 2 del file, e V1 e V2 sono le parti 1 e 2 del virus. Nota che la grandezza di P1 dovrebbe essere uguale alla dimensione di V1, ma la dimensione di P2 non necessariamente deve essere della stessa grandezza di V2. Il virus prima salva P1 e lo copia 1) o alla fine del file oppure 2) all'interno del codice del virus. Assumiamo che copia il codice alla fine del file. Il file ora appare cosÏ:
+--------------+
| P1 | P2 | P1 |
+--------------+
Poi, il virus copia la prima parte di se stesso all'inizio del file.
+--------------+
| V1 | P2 | P1 |
+--------------+
Finalmente, il virus copia la seconda parte di se stesso alla fine del file.
Il risultato finale, il file infetto appare cosÏ:
+-------------------+
| V1 | P2 | P1 | V2 |
+-------------------+
La domanda Ë: Che cazzo fanno V1 e V2? V1 trasferisce il controllo del programma a V2. Il codice Ë semplice.
JMP FAR PTR Toh ; occupa quattro bytes
Toh DW V2_Start ; occupa due bytes
Toh Ë un far pointer (Segment:Offset) che punta alla prima istruzione di V2. Nota che il valore di Toh deve essere variato per considerare la lunghezza del file che Ë infettato. Per esempio, se l'originale dimensione del file Ë 79 bytes, Toh deve essere cambiato in maniera tale che l'istruzione a CS:[155h] venga eseguita. Il valore di Toh Ë ottenuto sommando la lunghezza di V1, l'originale dimensione del file infetto, e 256 (per interpretare il PSP). In questo caso, V1= 6 e P1 + P2 = 79, cosÏ 6 + 79 + 256 = 341 decimale(155 hex).
Una alternativa, sebbene molto difficile da capire, Ë il metodo seguente:
DB 1101001b ; Codice per JMP (occupazione 2 byte)
Toh DW V2_Start - OFFSET Toh ; occupazione 2 byte
Questo inserisce il salto di offset direttamente nel codice che segue l'istruzione di salto. Puoi anche sostituire la seconda linea con:
DW V2_Start - $
Che esegue lo stesso compito.
V2 contiene il resto del codice, per esempio il resto che fa qualsiasi cosa. L'ultima parte di V2 copia P1 sopra V1 (in memoria, non sul disco) e poi trasferisce il controllo all'inizio del file (in memoria). Il programma originale girer‡ poi allegramente come se niente fosse successo. Il codice per fare ciÚ Ë anche molto semplice.
MOV SI, V2_START ; V2_START Ë un LABEL che marca dove V2 inizia
SUB SI, V1_LENGTH ; Ritorna dove P1 Ë riposto
MOV DI, 0100h ; tutto i file COM sono caricati @ CS:[100h] in memoria
MOV CX, V1_LENGTH ; muove i bytes CX
REP MOVSB ; DS:[SI] -> ES:[DI]
MOV DI, 0100h
JMP DI
Questo codice presume che P1 Ë localizzato proprio davanti V2, come in:
P1_Localizzato_Qui:
.
.
.
V2_Inizio:
Anche esso presume ES uguale a CS. Se queste assunzioni sono false, cambia il codice di conseguenza. Qui Ë un esempio:
PUSH CS ; conserva CS
POP ES ; e lo muove in ES
; Nota MOV ES, CS non Ë una istruzione valida
MOV SI, P1_START; Muove da dove P1 Ë memorizzato
MOV DI, 0100h ; a CS:[100h]
MOV CX, V1_LENGTH
REP MOVSB
MOV DI, 0100h
JMP DI
Questo codice primo muove CS in ES e poi posiziona il puntatore sorgente di MOVSB dove P1 Ë situato. Ricorda che questo ha preso posto completamente in memoria, cosÏ hai bisogno del'OFFSET DI P1, non solo l'ubicazione fisica nel file.
L'offset di P1 Ë 100h pi˘ alto dell'ubicazione fisica del file, poichË i files COM sono caricati a partire da CS:[ 100h].
CosÏ qui c'Ë un sommario delle parti del virus ed etichette dell'ubicazione:
V1_Start:
JMP FAR PTR Duh
Duh DW V2_Start
V1_End:
P2_Start:
P2_End:
P1_Start:
; Prima parte del programma immagazzinato qui per uso futuro
P1_End:
V2_Start:
; Vera Roba
V2_End:
V1_Length EQU V1_End - V1_Start
Alternativamente, potresti immagazzinare P1 in V2 come segue:
V2_Start:
P1_Start:
P1_End:
V2_End:
Qui c'Ë tutto per infettare un file COM senza distruggerlo! Semplice, no? i files EXE, comunque, sono un po' pi˘ difficile da infettare senza renderli ineseguibili - tratterÚ questo tema in file un pi˘ tardi.
Ora lascia che noi ritorniamo a prestare attenzione alla porzione replicatrice del virus.
I passi sono delineati sotto:
1) Trova un file da infettare
2) Controlla se Ë infettato gi‡
3) in tal caso, torna a 1
4) lo Infetta
5) Se infetto abbastanza, finisce
6) Altrimenti, risale a 1
Scoperto un file da infettare Ë una cosa semplice scrivere una procedura per una directory trasversale e emettendo le chiamate FINDFIRST e FINDNEXT per trovare possibili file da infettare. Una volta che tu trovi il file, aprilo e leggi i primi pochi byte. Se essi sono gli stessi come i primi pochi byte del V1, allora il file Ë gi‡ infettato. Se i primi byte di V1 non sono unici per il vostro virus, cambiateli cosÏ che lo diventino. E* estremamente* importante che il vostro virus non infetti di nuovo gli stessi archivi, cosÏ fu che Gerusalemme fu scoperto la prima volta. Se il file non Ë stato infettato gi‡, allora l'infetta!
Infezione dovrebbe prendere i passi seguenti:
1) Setto gli attributi del file a niente.
2) Salva l'attuale data/tempo del file.
3) Chiude il file.
4) lo apre di nuovo in modo read/write.
5) Salva P1 e l'aggiunge alla fine del file.
6) Copia V1 all'inizio, ma cambia l'offset che esso JMPs e cosÏ trasferisce il controllo correttamente. Vedi la parte precedente sull'infezione.
7) Aggiunge V2 alla fine del file.
8) Ripristina gli attributi/data/tempo del file.
Dovresti prendere un contatore del numero di files infettati durante questo giro. Se il numero eccede, tipo tre, allora ferma. E meglio infettare lentamente piuttosto che darti via per infettare l'intero drive in una volta.
Devi essere sicuro di coprire le tue tracce quando infetti un file. Salva la data/tempo/attributi originali del file e li ripristini quando Ë finito. QUESTO E MOLTO IMPORTANTE! Questo prende da 50 a 75 byte di codice, probabilmente meno, per fare queste poche cose semplici che possono fare meraviglie per l'occultamento del tuo programma.
IncluderÚ il codice per la funzione delle directory traversali, cosÏ come altre parti del replicatore nella prossima puntata della mia guida divertente.
OCCULTATORE
Questa Ë la parte che cela il programma all'utente quotidiano ed agli analizzatori dei virus. Il metodo pi˘ semplice per nascondere Ë il criptaggio.
Il codice per un semplice sistema di criptaggio XOR segue:
encrypt_val db ?
decrypt:
encrypt:
mov ah, encrypt_val
mov cx, part_to_encrypt_end - part_to_encrypt_start
mov si, part_to_encrypt_start
mov di, si
xor_loop:
lodsb ; DS:[SI] -> AL
xor al, ah
stosb ; AL -> ES:[DI]
loop xor_loop
ret
Nota che le procedure di criptaggio e decriptaggio sono identiche. Questo Ë dovuto alla natura soprannaturale di XOR. Poi CALL queste procedure da dovunque nel programma, ma sii sicuro di non chiamarle da dentro l'area che deve essere criptata, poichÈ il programma si crasha. Quando scrivi il virus, setta il valore di criptaggio a 0.Il codice contenuto fra [part_to_encrypt_start] e [part_to_encrypt_end] Ë l'area che desideri criptare. Usa una CALL a decriptaggio all'inizio di V2 per decriptare l'archivio cosÏ il tuo programma puÚ girare. Quando infetti un file, prima cambia encrypt_val, poi CALL criptaggio, poi scrivi V2 alla fine dell'archivio, e CALL decriptaggio. FAI BENE ATTENZIONE CHE QUESTA PARTE NON STIA NELL'AREA CHE DEVE ESSERE CRIPTATA!!!
Questo Ë come V2 apparirebbe con l'occultatore:
V2_Start:
Occultatore_Start:
.
.
.
Occultatore_End:
Replicatore_Start:
.
.
.
Replicatore_End:
Parte_Da_Cryptare_Start:
.
.
.
Parte_Da_Cryptare_End:
V2_End:
In alternativa, potresti muovere parti della roba non criptata tra
Parte_Da_Cryptare_End e V2_End.
Il valore di criptaggio Ë facilmente intuibile. La criptazione rende pi˘ difficile per gli scanner di virus localizzare il tuo virus. Esso anche nasconde alcune sequenze di testo presenti nel tuo programma.E' il modo pi˘ facile e breve per nascondere il tuo virus.
La criptazione Ë solo un metodo per occultare. Almeno uno altro tipo virus si aggancia negli interrupts del DOS ed altera l'output del comando DIR cosÏ le dimensioni dei files appaiono normali.Un'altro schema di nascondiglio (per virus TSR ) altera il DOS cosÏ le utilit‡ di memoria non scoprono il virus. Caricando il virus in certe parti di memoria gli permetti di sopravvivere ai reboots a caldo. Ci sono molte tecniche di occultamento, limitate solo dall'immaginazione dello scrittore di virus.
LA BOMBA
CosÏ ora tutta la roba noiosa Ë finita. La sgradevolezza Ë contenuta qui. La parte bomba del virus fa tutta la cancellazione/rallentamento/etc che rende i virus cosÏ irritanti. Setta alcune condizioni di attivazione del virus. Questo puÚ essere qualsiasi cosa, varia da quando Ë il tuo compleanno a quando il virus ha infetto 100 files. Quando queste condizioni sono raggiunte, allora il tuo virus fa il suo dovere. Alcuni suggerimenti di bombe possibili:
1) Rallentamento del Sistema- facile da realizzare intrappolando un'interrupt e causando una dilazione quando Ë attivato.
2) cancellazione di file- Cancella tutti i file ZIP presenti sul drive.
3) Display di messaggi- Mostra un simpatico messaggio che dice qualcosa d'effetto tipo "Tu sei fottuto"
4) Distruzione/ Sostituzione della Partition Table/Boot Sector/FAT dell'hard disk- Questo Ë molto sporco, giacchÈ la maggior parte degli stupidi non possono rimediare a questo.
Questo Ë, naturalmente, la parte divertente nella scrittura di un virus, cosÏ sii originale!
PROBLEMI DI OFFSET
C'Ë una problema riguardo il calcolo dell'offset. Dopo che hai infettato un archivio, le locazioni delle variabili cambiano. DEVI tenere conto di questo. Tutti i relativi offset possono restare gli stessi, ma devi aggiungere la dimensione del file agli offset assoluti o il tuo programma non funzioner‡. Questa Ë la parte pi˘ ingannevole nella scrittura di virus e metti in conto che spesso puÚ aumentare di molto la dimensione di un virus. QUESTO E MOLTO IMPORTANTE E TU DOVRESTI ASSICURARTI DI AVER CAPITO QUESTO PRIMA DI TENTARE DI SCRIVERE VIRUS CHE NON SOVRASCRIVONO!
Se non lo fai, sarai fottuto ed il tuo virus NON FUNZIONERA'! Una intera parte della guida sar‡ dedicata a questo soggetto.
COLLAUDO
Collaudare i virus Ë ancora una pericolosa parte essenziale del processo di creazione del virus. CiÚ serve per essere sicuri che la gente *sar‡* colpita dal virus e, con buona speranza, cancellata. Prova completamente e sii sicuro che si attivi con le condizioni da te stabilite. Sarebbe grande se ognuno avesse un secondo computer per esaminare i suoi virus fuori, ma, naturalmente, questo non Ë la normalit‡. CosÏ Ë ESSENZIALE effettuare BACKUPS dei tuoi files, partizioni, boot record, e FAT. Norton Ë abile nel fare questo. Non trascurare questo consiglio (sebbene so che lo farai in ogni modo) perchÈ tu SARAI colpito da tuo virus. Quando ho scritto il mio primo virus, il mio sistema Ë stato inattivo per due giorni perchÈ non avevo un buon backup. Fortunatamente, il virus non era estremamente distruttivo. I BACKUPS SONO UTILI! PRENDI UN PROGRAMMA DI BACKUP DAL TUO FORNITORE PIRATA LOCALE! Trovo RamDrive spesso utile nel collaudo dei virus, poichÈ il danno non Ë permanente. RamDrives Ë anche utile per testare i trojans, ma questo Ë il tema di un'altro file.
DISTRIBUZIONE
Questa Ë la parte divertente nella scrittura del virus. CiÚ comporta lo spedire il tuo programma brillantemente scritto attraverso il telefono alla tua insospettabile bbs. Quello che dovresti fare Ë infettare un file che attualmente fa qualche cosa (utilizza un'utility da un'altra BBS), infettalo, e scaricalo in un posto dove sar‡ preso da tutti gli utenti. La migliore cosa Ë che non sar‡ scoperto da un misero analizzatore-che_crede_di_essere_il_meglio da McAffee, poichË Ë nuovo! Oh sÏ, assicurati di usare un falso account (toh!). Meglio ancora, fai un falso account col nome/numero del telefono di qualcuno che non ti piace e scarica il file a suo nome. Puoi richiamare di tanto in tanto e usare una porta come ZDoor per controllare l'espansione del virus. Pi˘ sono quelli che scaricano, pi˘ saranno quelli che condivideranno l'esperienza del tuo virus!
Ho promesso una sezione breve sui virus che sovrascrivono, cosÏ eccola...
VIRUS SOVRASCRIVENTI
Tutto quello che questi virus fanno Ë diffondersi in tutto il sistema. Rendono i files infetti ineseguibili, cosÏ sono scoperti facilmente. E semplice scrivere uno:
+----------+ +-----+ +----------+
| Programma|+|Virus|=|Virus|amma|
+----------+ +-----+ +----------+
Questi virus sono piccoli arnesi da taglio semplici, ma abbastanza indegni a causa della loro facile riconoscibilit‡. ho detto abbastanza!
ALLORA, PROPRIO QUELLO CHE...
Termina qui questa puntata della guida alla scrittura dei virus divertenti di Dark Angel. Ci sar‡ (speriamolo) una futura rivista dove tratterÚ pi˘ approfonditamente i virus ed includerÚ molti pi˘ codici sorgenti (pi˘ sorgenti!). Fino a allora, felice programmazione!
