[ Hooking Windows API ]
Technics of hooking API functions on Windows
--------------------------------------------
Author: Holy_Father
Version: 1.1 english
Date: 6.10.2002
=====[ 1. Contents ]============================================================
1. Contents
2. Introduction
3. Hooking methods
3.1 Hooking before running
3.2 Hooking during running
3.2.1 Own process hooking using IAT
3.2.2 Own process hooking using entry point rewriting
3.2.3 Original function saving
3.2.4 Other process hooking
3.2.4.1 DLL Injection
3.2.4.2 Independent code
3.2.4.3 Raw change
4. Ending
=====[ 2. Introduction ]========================================================
Đây là bài viết về hooking API functions trên OS Windows. Tất cả các ví dụ
ở đây làm việc hòan tòan trên Windows systems based on NT technology version NT 4.0
and higher (Windows NT 4.0, Windows 2000, Windows XP). Có lẽ cũng sẽ làm việc trên
các Windows systems khác.
Bạn đã rất thân thuộc với các processes trên Windows, assembler, PE files
structure và vài API functions để hiểu tòan bộ bài viết này.
Khi sử dụng điều khỏan "Hooking API" ở đây, tôi chỉ có ý là thay đổi đầy đủ API.
Vì vậy, khi calling hooked API, code của chúng ta được chạy ngay lập tức. Tôi ko đề cập đến các
cases of chỉ giám sát API. Tôi sẽ viết về hooking hòa tòan.
=====[ 3. Hooking methods ]=====================================================
Đích của chúng ta nói chung là thay thế code of vài function với code của
chúng ta. Vấn đề này có thể đôi khi được giải quyết trước khi running process. Điều này
có thể được thực hiện hầu hết với các process lớp user mà chúng được run bởi chúng ta và đích cuối nghĩa là
thay đổi hành vi của chương trình. Ví dụ điều này là có thể ứng dụng trong crack.
Nghĩa là chương trình mà nó muốn đĩa CD-ROM gốc trong suốt quá trình startup (điều này trong game
Atlantis) và chúng ta muốn run nó mà ko cần CDs. Nếu chúng ta thay đổi function cho
việc lấy một drive type chúng ta sẽ có thể run chương trình này từ hard drive.
Điều này ko thể làm được hay chúng ta ko muốn làm điều này khi muốn hook
system process (e.g. services) hay trong cas chúng ta ko biết process nào sẽ
là target. Thì chúng ta sẽ sử dụng kỹ thuật hooking suốt quá trình running . Ví dụ sử dụng
điều này có thể là rootkit hay virus với các kỹ thuật anti-antivirus.
=====[ 3.1 Hooking before running ]=============================================
Đây là về thay đổi physical module (hầu hét là .exe hay .dll) khi
function, mà chúng ta muốn thay đổi. Chúng ta phải có ít nhất 3 khả năng ở đây
đề làm được điều này.
Trước tiên là tìm entry point of function đó và về cơ bản là
rewrite code của nó. Điều này bị giới hạn bởi function size nhưng chúng ta có thể load vài
modules khác một cách động dynamically (API LoadLibrary), vì vậy nó có thể đủ.
Kernel functions (kernel32.dll) có thể được sử dụng trong tất cả các cas vì
mỗi process trong windows có chính bản copy module này của nó. Thuận lợi khác
là nếu chúng ta biết OS nào sẽ bị thay đổi module run. Chúng ta có thể sử dụng các con trỏ
trực tiếp trong cas này có nghĩa là API LoadLibraryA. Điều này như thế vì address
of kernel module trong memory là tỉnh trong phạm vi một OS Windows version.
Chúng ta cũng có thể sử dụng hành vi của module được load động. Trong cas này phần khởi trị đầu
của nó được run ngay lập tức sau khi loading vào memory. Chúng ta ko bị giới hạn
trong phần khởi trị đầu của module mới.
Khả năng thứ hai của việc thay thế hàm trong module là phần mở rộng của nó.
Thì chúng ta phải chọn giữa 5 bytes đầu tiên bởi relative jump
hay rewriting IAT. Trong trường hợp relative jump, điều này sẽ redirect (chuyển tiếp) code
thực thi đến code của chúng ta. Khi calling function mà IAT record của chúng bị thay đổi,
code của chúng ta sẽ bị thực thi một cách trực tiếp sau call này. Nhưng phần mở rộng của module
vì vậy ko dễ dàng vì chúng ta phải bảo quản DLL header.
Khả năng kế tiếp là thay thế tòan module. Đìều đó có nghĩa là chúng ta cài đặt
version of của chính module mà chúng có thể load cái module gốc và call các original
functions mà chúng ta ko quan tâm đến. Nhưng các hàm quan trọng sẽ hòan tòan mới
Phương pháp này ko tốt lắm vì các modules lớn mà chúng có thể chứa hàm trăm
các exports.
=====[ 3.2 Hooking during running ]=============================================
Hooking before running hầu như rất đặc biệt và định hướng một cách thân thiện
cho các khối ứng dụng (hay module). Nếu chúng ta thay thế hàm trong kernel32.dll
hay trong ntdll.dll (chỉ trên NT OS) thì chúng ta sẽ có được sự thay thế hòan hảo hàm này
trong tất cả các processes mà chúng được run sau đó, nhưng nó cũng khó để làm được nó
vì chúng ta phải lấy cẩn thận về độ chính xác và code chính of các
functions mới hay cả modules mới, nhưng vấn đề chính chỉ process
mà nó được run sau sẽ bị hooked (vậy với tất cả các process thì chúng ta phải reboot
system). Vấn đề kế tiếp là có thể truy xuất các files này bởi vì NT OS cố bảo vệ chúng.
Quá nhiều cách giải quyết tuyệt vời cho việc hook process suốt quá trịnh running. PP này
yêu cầu nhiều kiến thức nhưng kết quả thì rất hòan hảo. Hooking during running
có thể chỉ được thực hiện trên process mà với chúng chúng ta viết truy xuất đến memory của chúng.
Đối với việc viết vào chính nó chúng ta sẽ sử dụng API function WriteProcessMemory. Chúng ta sẽ
bắt đầu từ việc hooking process của chính chúng ta trong suốt quá trình running.
=====[ 3.2.1 Own process hooking using IAT ]====================================
Có nhiều khả năng ở đây. Trước tiên tôi sẽ chỉ cho bạn như thế nào để hook
function bằng cách rewriting IAT (viết lại IAT). Following picture shows structure of PE file:
+-------------------------------+ - offset 0
| MS DOS Header ("MZ") and stub |
+-------------------------------+
| PE signature ("PE") |
+-------------------------------+
| .text | - module code
| Program Code |
| |
+-------------------------------+
| .data | - initialized (global static) data
| Initialized Data |
| |
+-------------------------------+
| .idata | - information for imported functions
| Import Table | and data
| |
+-------------------------------+
| .edata | - information for exported functions
| Export Table | and data
| |
+-------------------------------+
| Debug symbols |
+-------------------------------+
Phần quan trọng đối với chúng ta ở đây là Import Address Table (IAT) trong .idata
part. Phần này chứa các mô tả của các imports và phần lớn các imported functions
addresses. Bây giờ quan trọng để biết các PE files created như thế nào. Khi calling
bất kỳ API một cách gián tiếp trong programming language (điều đó có ý nghĩa là chúng ta call nó sử dụng
tên của nó, ko phải sử dụng địa chỉ riêng OS của nó) thì compiler ko link trực tiếp các
calls đến module nhưng nó links call đến IAT trên chỉ thị jmp mà chúng sẽ được
filled bởi process loader khi OS được loading process vào memory. Điều này là tại sao
chúng ta có thể sử dụng binary giống như vậy trên 2 version khác nhau của Windows mà ở đó các modules
có thể được loaded vào các addresses khác nhau. Process loader sẽ lấp ra fill out chỉ thị direct jmp
trong IAT mà chúng được sử dụng bởi các calls của chúng ta từ program code. Vì vậy,
nếu chúng ta có thể tìm ra function đặc trưng trong IAT mà chúng a muốn hook chúng,
chúng ta có thể dễ dàng thay đổi chỉ thị jmp ở đó và redirect (chuyển tiếp) code đến address của chúng ta.
Mọi call sau đó thực thi hàm này sẽ thực thi code của chúng ta. Tiện ích của pp này
là sự hòan chỉnh của nó. Bát tiện là thông thường phần lớn các functions mà nó được
hooked (e.g. nếu chúng ta muốn thay đổ hành vi chương trình trong file searching APIs
thì chúng ta sẽ phải thay đổi các functions FindFirstFile và FindNextFile, nhưng chúng ta phải
biết rằng các functions này có ANSI và WIDE version của nó, vì vậy chúng ta phải thay đổi
IAT address cho FindFirstFileA, FindFirstFileW, FindNextFileA và cũng như
FileNextFileW. Nhưng vẫn có vài hàm khác giống như FindFirstFileExA và WIDE
version của nó FindFirstFileExW mà chúng được gọi bởi các hàm đã nói đến trước đó.
Chúng ta biết rằng FindFirstFileW calls FindFirstFileExW nhưng điều này được thực hiện một cách trực tíep
- ko sử dụng IAT. Và vẫn vài cách khác để thực hiện. Đó là e.g. ShellAPI
functions giống như SHGetDesktopFolder mà chúng cũng calls FindFirstFileW một cách trực tiếp hay
FindFirstFileExW). Nhưng nếu chúng ta có tất cả chúng, result sẽ rất hòan hảo.
Chúng ta có thể sử dụng ImageDirectoryEntryToData từ imagehlp.dll để tìm ra IAT
một cách dễ dàng.
PVOID ImageDirectoryEntryToData(
IN LPVOID Base,
IN BOOLEAN MappedAsImage,
IN USHORT DirectoryEntry,
OUT PULONG Size
);
Chúng ta sẽ sử dụng Instance of ứng dụng của chúng ta như là Base (Instance có thể có được bằng cách calling
GetModuleHandle:
hInstance = GetModuleHandleA(NULL);
), và như DirectoryEntry chúng at sẽ sử dụng hằng số IMAGE_DIRECTORY_ENTRY_IMPORT.
#define IMAGE_DIRECTORY_ENTRY_IMPORT 1
Result của hàm này là pointer trỏ đến IAT record đầu tiên. IAT records là cấu trúc
structures mà nó được định nghĩa bởi I IMAGE_IMPORT_DESCRIPTOR. Vậy, result
là một pointer trên IMAGE_IMPORT_DESCRIPTOR.
typedef struct _IMAGE_THUNK_DATA {
union {
PBYTE ForwarderString;
PDWORD Function;
DWORD Ordinal;
PIMAGE_IMPORT_BY_NAME AddressOfData;
} ;
} IMAGE_THUNK_DATA,*PIMAGE_THUNK_DATA;
typedef struct _IMAGE_IMPORT_DESCRIPTOR {
union {
DWORD Characteristics;
PIMAGE_THUNK_DATA OriginalFirstThunk;
} ;
DWORD TimeDateStamp;
DWORD ForwarderChain;
DWORD Name;
PIMAGE_THUNK_DATA FirstThunk;
} IMAGE_IMPORT_DESCRIPTOR,*PIMAGE_IMPORT_DESCRIPTOR;
Giá trị Name trong IMAGE_IMPORT_DESCRIPTOR là một tham chiếu tương ứng với
name of module. Nếu chúng ta muốn hook một function e.g. từ kernel32.dll
chúng ta phải tìm ra trong imports mà nó phụ thuộc vào descriptor với name là
kernel32.dll. Chúng ta sẽ call ImageDirectoryEntryToData tại lúc bắt đầu và rồi chúng ta sẽ thử
tìm descriptor với name "kernel32.dll" (ở đó có thể nhiều hơn 1
descriptor với name này). Cuối cùng chúng ta sẽ phải tìm ra function của chúng ta trong
danh sách tất cả các functions trong record (address of function của chúng ta có thể có được
bởi hàm GetProcAddress function). Nếu chúng ta tìm nó chúng ta phải sử dụng VirtualProtect để thay đổi
memory page protection và sau đó thì chúng ta có thể write phần này của memory.
Sau khi rewriting address chúng ta phải thay đổi protection trở lại. Trước khi
calling VirtualProtect chúng ta phải biết vài thông tin về memory page này.
Điều này được làm nởi VirtualQuery. Chúng ta có thể thêm vài tests trong cas vài calls sẽ bị
fail (e.g. chúng ta ko tiếp tục nếu VirtualProtect call đầu tiên bị failed, etc)>
PCSTR pszHookModName = "kernel32.dll",pszSleepName = "Sleep";
HMODULE hKernel = GetModuleHandle(pszHookModName);
PROC pfnNew = (PROC)0x12345678, //new address will be here
pfnHookAPIAddr = GetProcAddress(hKernel,pszSleepName);
ULONG ulSize;
PIMAGE_IMPORT_DESCRIPTOR pImportDesc =
(PIMAGE_IMPORT_DESCRIPTOR)ImageDirectoryEntryToData(
hInstance,
TRUE,
IMAGE_DIRECTORY_ENTRY_IMPORT,
&ulSize
);
while (pImportDesc->Name)
{
PSTR pszModName = (PSTR)((PBYTE) hInstance + pImportDesc->Name);
if (stricmp(pszModName, pszHookModName) == 0)
break;
pImportDesc++;
}
PIMAGE_THUNK_DATA pThunk =
(PIMAGE_THUNK_DATA)((PBYTE) hInstance + pImportDesc->FirstThunk);
while (pThunk->u1.Function)
{
PROC* ppfn = (PROC*) &pThunk->u1.Function;
BOOL bFound = (*ppfn == pfnHookAPIAddr);
if (bFound)
{
MEMORY_BASIC_INFORMATION mbi;
VirtualQuery(
ppfn,
&mbi,
sizeof(MEMORY_BASIC_INFORMATION)
);
VirtualProtect(
mbi.BaseAddress,
mbi.RegionSize,
PAGE_READWRITE,
&mbi.Protect)
)
*ppfn = *pfnNew;
DWORD dwOldProtect;
VirtualProtect(
mbi.BaseAddress,
mbi.RegionSize,
mbi.Protect,
&dwOldProtect
);
break;
}
pThunk++;
}
Result of calling Sleep(1000) có thể cho ví dụ này:
00407BD8: 68E8030000 push 0000003E8h
00407BDD: E812FAFFFF call Sleep
Sleep: ;this is jump on address in IAT
004075F4: FF25BCA14000 jmp dword ptr [00040A1BCh]
original table:
0040A1BC: 79 67 E8 77 00 00 00 00
new table:
0040A1BC: 78 56 34 12 00 00 00 00
Vì vậy jump cuối cùng là 0x12345678.
=====[ 3.2.2 Own process hooking using entry point rewriting ]==================
PP rewriting vài chỉ thị đầu tiên trên function entry
point rất đơn giản. Như trong cas rewritng address trong IAT mà chúng ta phải
thay đổi page protection lúc đầu tiên. Ở đây nó sẽ là 5 bytes đầu tiên of hàm đã cho
mà chúng ta muốn hook chúng. Để tiền dùng sau này chúng ta sẽ sử dụng cấp phát động
cấu trúc MEMORY_BASIC_INFORMATION structure. Điểm bắt đầu hàm có được bởi gọi hàm
GetProcAddress một lần nữa. Trên addr này chúng ta sẽ insert relative jump đến
code của chúng ta. Chương trình sau đây calls Sleep(5000) (vì vậy nó sẽ chờ 5 seconds), rồi
Sleep functions bị hooked và redirected chuyển tiếp đến new_sleep, cuối cùng nó call
Sleep(5000) một lần nữa. Bởi vì new function new_sleep ko làm gì và trả về returns
ngay lập tức nguyên chương trình sẽ mất chỉ 5 trong 10 seconds.
.386p
.model flat, stdcall
includelib lib\kernel32.lib
Sleep PROTO :DWORD
GetModuleHandleA PROTO :DWORD
GetProcAddress PROTO :DWORD,:DWORD
VirtualQuery PROTO :DWORD,:DWORD,:DWORD
VirtualProtect PROTO :DWORD,:DWORD,:DWORD,:DWORD
VirtualAlloc PROTO :DWORD,:DWORD,:DWORD,:DWORD
VirtualFree PROTO :DWORD,:DWORD,:DWORD
FlushInstructionCache PROTO :DWORD,:DWORD,:DWORD
GetCurrentProcess PROTO
ExitProcess PROTO :DWORD
.data
kernel_name db "kernel32.dll",0
sleep_name db "Sleep",0
old_protect dd ?
MEMORY_BASIC_INFORMATION_SIZE equ 28
PAGE_READWRITE dd 000000004h
PAGE_EXECUTE_READWRITE dd 000000040h
MEM_COMMIT dd 000001000h
MEM_RELEASE dd 000008000h
.code
start:
push 5000
call Sleep
do_hook:
push offset kernel_name
call GetModuleHandleA
push offset sleep_name
push eax
call GetProcAddress
mov edi,eax ;finally got Sleep address
push PAGE_READWRITE
push MEM_COMMIT
push MEMORY_BASIC_INFORMATION_SIZE
push 0
call VirtualAlloc
test eax,eax
jz do_sleep
mov esi,eax ;alocation for MBI
push MEMORY_BASIC_INFORMATION_SIZE
push esi
push edi
call VirtualQuery ;inforamtion about the memory page
test eax,eax
jz free_mem
call GetCurrentProcess
push 5
push edi
push eax
call FlushInstructionCache ;just to be sure :)
lea eax,[esi+014h]
push eax
push PAGE_EXECUTE_READWRITE
lea eax,[esi+00Ch]
push [eax]
push [esi]
call VirtualProtect ;we will change protection for a moment
;so we will be able to write there
test eax,eax
jz free_mem
mov byte ptr [edi],0E9h ;to write relative jump
mov eax,offset new_sleep
sub eax,edi
sub eax,5
inc edi
stosd ;this is relative address for jump
push offset old_protect
lea eax,[esi+014h]
push [eax]
lea eax,[esi+00Ch]
push [eax]
push [esi]
call VirtualProtect ;return back the protection of page
free_mem:
push MEM_RELEASE
push 0
push esi
call VirtualFree ;free memory
do_sleep:
push 5000
call Sleep
push 0
call ExitProcess
new_sleep:
ret 004h
end start
Result of call Sleep thứ hai là như vầy:
004010A4: 6888130000 push 000001388h
004010A9: E80A000000 call Sleep
Sleep: ;toto je jump na adresu v IAT
004010B8: FF2514204000 jmp dword ptr [000402014h]
tabulka:
00402014: 79 67 E8 77 6C 7D E8 77
Kernel32.Sleep:
77E86779: E937A95788 jmp 0004010B5h
new_sleep:
004010B5: C20400 ret 004h
=====[ 3.2.3 Original function saving ]=========================================
Hầu như chúng ta cần hơn hook một hàm. Cho ví dụ, trong cas khi chúng ta
ko muốn replace hàm đã cho nhưng chỉ check result của nó, hay trong cas khi
chúng ta chỉ muốn đôi khi replace function e.g. khi nó được called với các đối số
đặc biệt. Ví dụ good về điều này là các files thật sự đã nói trước đó hiding
được làm bởi replacing FindXXXFile functions. Vì vậy nếu chúng ta muốn hide các file đặc trưng
và ko muốn thông báo thì chúng ta phải bỏ original function cho tất cả các file
khác mà ko cần thay đổi hành vi của các hàm. Điều này đon giản khi sử dụng pp
rewriting IAT. Đói với việc calling original function chúng ta có thể có original
address của nó với việc gọi hàm GetProcAddress và rồi gọi nó một cách trực tiếp. Nhưng vấn đề xảy ra
khi sử dụng rewriting entry point method. Bởi rewriting 5 bytes này tại
functions entry point chúng ta mất original function mà ko thể thu hồi được. Vì vậy chúng ta cần
save các instructions đầu tiên. Chúng ta có thể sử dụng kỹ thuật sau.
Chúng ta biết rằng chúng ta sẽ chỉ rewrite 5 bytes đầu tiên nhưng ko biết bao nhiêu
chỉ thị ở đó hay chúng dài bao nhiêu bytes. Chúng ta phải để dành đủ memory
cho các chỉ thị đầu tien. 16 bytes có thể là đủ bởi vì thường ko có
các chỉ thị dài tại lúc bắt đầu hà. Có lẽ chúng ta sử dụng ít hơn 16.
Tòan bộ vùng memory để dành được lấp với giá trị 0x90 (0x90 = nop) trong case có các
chỉ thị ngắn hơn.Kế đến 5bytes sẽ là relative jump mà nó sẽ được láp sau.
old_hook: db 090h,090h,090h,090h,090h,090h,090h,090h
db 090h,090h,090h,090h,090h,090h,090h,090h
db 0E9h,000h,000h,000h,000h
Bây giờ chúng ta sẳn sàng copy các chỉ thị đầu tiên. Nó là một stuff dài để có
chiều dài của instruction, điều này là tại sao chúng ta sẽ làm việc với một engine hòan chỉnh. Engine này
được làm bởi Z0MBiE. Nhập Input đói số vào là instruction address mà chúng ta muốn lấy chiều dài
của chúng. Output thông thường trong eax.
; LDE32, Length-Disassembler Engine, 32-bit, (x) 1999-2000 Z0MBiE
; special edition for REVERT tool
; version 1.05
C_MEM1 equ 0001h ; |
C_MEM2 equ 0002h ; |may be used simultaneously
C_MEM4 equ 0004h ; |
C_DATA1 equ 0100h ; |
C_DATA2 equ 0200h ; |may be used simultaneously
C_DATA4 equ 0400h ; |
C_67 equ 0010h ; used with C_PREFIX
C_MEM67 equ 0020h ; C_67 ? C_MEM2 : C_MEM4
C_66 equ 1000h ; used with C_PREFIX
C_DATA66 equ 2000h ; C_66 ? C_DATA2 : C_DATA4
C_PREFIX equ 0008h ; prefix. take opcode again
C_MODRM equ 4000h ; MODxxxR/M
C_DATAW0 equ 8000h ; opc&1 ? C_DATA66 : C_DATA1
p386
model flat
locals @@
.code
public disasm_main
public _disasm_main
public @disasm_main
public DISASM_MAIN
disasm_main:
_disasm_main:
@disasm_main:
DISASM_MAIN:
; returns opcode length in EAX or -1 if error
; input: pointer to opcode
; __fastcall EAX
; __cdecl [ESP+4]
;this is my first change here, it's the label only for calling this function
get_instr_len:
mov ecx, [esp+4] ; ECX = opcode ptr
xor edx, edx ; flags
xor eax, eax
@@prefix: and dl, not C_PREFIX
mov al, [ecx]
inc ecx
or edx, table_1[eax*4]
test dl, C_PREFIX
jnz @@prefix
cmp al, 0F6h
je @@test
cmp al, 0F7h
je @@test
cmp al, 0CDh
je @@int
cmp al, 0Fh
je @@0F
@@cont:
test dh, C_DATAW0 shr 8
jnz @@dataw0
@@dataw0done:
test dh, C_MODRM shr 8
jnz @@modrm
@@exitmodrm:
test dl, C_MEM67
jnz @@mem67
@@mem67done:
test dh, C_DATA66 shr 8
jnz @@data66
@@data66done:
mov eax, ecx
sub eax, [esp+4]
and edx,C_MEM1+C_MEM2+C_MEM4+C_DATA1+C_DATA2+C_DATA4
add al, dl
add al, dh
;my second change heer, there was retn only in original version
@@exit: ret 00004h
@@test: or dh, C_MODRM shr 8
test byte ptr [ecx], 00111000b ; F6/F7 -- test
jnz @@cont
or dh, C_DATAW0 shr 8
jmp @@cont
@@int: or dh, C_DATA1 shr 8
cmp byte ptr [ecx], 20h
jne @@cont
or dh, C_DATA4 shr 8
jmp @@cont
@@0F: mov al, [ecx]
inc ecx
or edx, table_0F[eax*4]
cmp edx, -1
jne @@cont
@@error: mov eax, edx
jmp @@exit
@@dataw0: xor dh, C_DATA66 shr 8
test al, 00000001b
jnz @@dataw0done
xor dh, (C_DATA66+C_DATA1) shr 8
jmp @@dataw0done
@@mem67: xor dl, C_MEM2
test dl, C_67
jnz @@mem67done
xor dl, C_MEM4+C_MEM2
jmp @@mem67done
@@data66: xor dh, C_DATA2 shr 8
test dh, C_66 shr 8
jnz @@data66done
xor dh, (C_DATA4+C_DATA2) shr 8
jmp @@data66done
@@modrm: mov al, [ecx]
inc ecx
mov ah, al ; ah=mod, al=rm
and ax, 0C007h
cmp ah, 0C0h
je @@exitmodrm
test dl, C_67
jnz @@modrm16
@@modrm32: cmp al, 04h
jne @@a
mov al, [ecx] ; sib
inc ecx
and al, 07h
@@a: cmp ah, 40h
je @@mem1
cmp ah, 80h
je @@mem4
cmp ax, 0005h
jne @@exitmodrm
@@mem4: or dl, C_MEM4
jmp @@exitmodrm
@@mem1: or dl, C_MEM1
jmp @@exitmodrm
@@modrm16: cmp ax, 0006h
je @@mem2
cmp ah, 40h
je @@mem1
cmp ah, 80h
jne @@exitmodrm
@@mem2: or dl, C_MEM2
jmp @@exitmodrm
endp
.data
;0F -- analyzed in code, no flags (i.e.flags must be 0)
;F6,F7 -- --//-- (ttt=000 -- 3 bytes, otherwise 2 bytes)
;CD -- --//-- (6 bytes if CD 20, 2 bytes otherwise)
table_1 label dword ; normal instructions
dd C_MODRM ; 00
dd C_MODRM ; 01
dd C_MODRM ; 02
dd C_MODRM ; 03
dd C_DATAW0 ; 04
dd C_DATAW0 ; 05
dd 0 ; 06
dd 0 ; 07
dd C_MODRM ; 08
dd C_MODRM ; 09
dd C_MODRM ; 0A
dd C_MODRM ; 0B
dd C_DATAW0 ; 0C
dd C_DATAW0 ; 0D
dd 0 ; 0E
dd 0 ; 0F
dd C_MODRM ; 10
dd C_MODRM ; 11
dd C_MODRM ; 12
dd C_MODRM ; 13
dd C_DATAW0 ; 14
dd C_DATAW0 ; 15
dd 0 ; 16
dd 0 ; 17
dd C_MODRM ; 18
dd C_MODRM ; 19
dd C_MODRM ; 1A
dd C_MODRM ; 1B
dd C_DATAW0 ; 1C
dd C_DATAW0 ; 1D
dd 0 ; 1E
dd 0 ; 1F
dd C_MODRM ; 20
dd C_MODRM ; 21
dd C_MODRM ; 22
dd C_MODRM ; 23
dd C_DATAW0 ; 24
dd C_DATAW0 ; 25
dd C_PREFIX ; 26
dd 0 ; 27
dd C_MODRM ; 28
dd C_MODRM ; 29
dd C_MODRM ; 2A
dd C_MODRM ; 2B
dd C_DATAW0 ; 2C
dd C_DATAW0 ; 2D
dd C_PREFIX ; 2E
dd 0 ; 2F
dd C_MODRM ; 30
dd C_MODRM ; 31
dd C_MODRM ; 32
dd C_MODRM ; 33
dd C_DATAW0 ; 34
dd C_DATAW0 ; 35
dd C_PREFIX ; 36
dd 0 ; 37
dd C_MODRM ; 38
dd C_MODRM ; 39
dd C_MODRM ; 3A
dd C_MODRM ; 3B
dd C_DATAW0 ; 3C
dd C_DATAW0 ; 3D
dd C_PREFIX ; 3E
dd 0 ; 3F
dd 0 ; 40
dd 0 ; 41
dd 0 ; 42
dd 0 ; 43
dd 0 ; 44
dd 0 ; 45
dd 0 ; 46
dd 0 ; 47
dd 0 ; 48
dd 0 ; 49
dd 0 ; 4A
dd 0 ; 4B
dd 0 ; 4C
dd 0 ; 4D
dd 0 ; 4E
dd 0 ; 4F
dd 0 ; 50
dd 0 ; 51
dd 0 ; 52
dd 0 ; 53
dd 0 ; 54
dd 0 ; 55
dd 0 ; 56
dd 0 ; 57
dd 0 ; 58
dd 0 ; 59
dd 0 ; 5A
dd 0 ; 5B
dd 0 ; 5C
dd 0 ; 5D
dd 0 ; 5E
dd 0 ; 5F
dd 0 ; 60
dd 0 ; 61
dd C_MODRM ; 62
dd C_MODRM ; 63
dd C_PREFIX ; 64
dd C_PREFIX ; 65
dd C_PREFIX+C_66 ; 66
dd C_PREFIX+C_67 ; 67
dd C_DATA66 ; 68
dd C_MODRM+C_DATA66 ; 69
dd C_DATA1 ; 6A
dd C_MODRM+C_DATA1 ; 6B
dd 0 ; 6C
dd 0 ; 6D
dd 0 ; 6E
dd 0 ; 6F
dd C_DATA1 ; 70
dd C_DATA1 ; 71
dd C_DATA1 ; 72
dd C_DATA1 ; 73
dd C_DATA1 ; 74
dd C_DATA1 ; 75
dd C_DATA1 ; 76
dd C_DATA1 ; 77
dd C_DATA1 ; 78
dd C_DATA1 ; 79
dd C_DATA1 ; 7A
dd C_DATA1 ; 7B
dd C_DATA1 ; 7C
dd C_DATA1 ; 7D
dd C_DATA1 ; 7E
dd C_DATA1 ; 7F
dd C_MODRM+C_DATA1 ; 80
dd C_MODRM+C_DATA66 ; 81
dd C_MODRM+C_DATA1 ; 82
dd C_MODRM+C_DATA1 ; 83
dd C_MODRM ; 84
dd C_MODRM ; 85
dd C_MODRM ; 86
dd C_MODRM ; 87
dd C_MODRM ; 88
dd C_MODRM ; 89
dd C_MODRM ; 8A
dd C_MODRM ; 8B
dd C_MODRM ; 8C
dd C_MODRM ; 8D
dd C_MODRM ; 8E
dd C_MODRM ; 8F
dd 0 ; 90
dd 0 ; 91
dd 0 ; 92
dd 0 ; 93
dd 0 ; 94
dd 0 ; 95
dd 0 ; 96
dd 0 ; 97
dd 0 ; 98
dd 0 ; 99
dd C_DATA66+C_MEM2 ; 9A
dd 0 ; 9B
dd 0 ; 9C
dd 0 ; 9D
dd 0 ; 9E
dd 0 ; 9F
dd C_MEM67 ; A0
dd C_MEM67 ; A1
dd C_MEM67 ; A2
dd C_MEM67 ; A3
dd 0 ; A4
dd 0 ; A5
dd 0 ; A6
dd 0 ; A7
dd C_DATA1 ; A8
dd C_DATA66 ; A9
dd 0 ; AA
dd 0 ; AB
dd 0 ; AC
dd 0 ; AD
dd 0 ; AE
dd 0 ; AF
dd C_DATA1 ; B0
dd C_DATA1 ; B1
dd C_DATA1 ; B2
dd C_DATA1 ; B3
dd C_DATA1 ; B4
dd C_DATA1 ; B5
dd C_DATA1 ; B6
dd C_DATA1 ; B7
dd C_DATA66 ; B8
dd C_DATA66 ; B9
dd C_DATA66 ; BA
dd C_DATA66 ; BB
dd C_DATA66 ; BC
dd C_DATA66 ; BD
dd C_DATA66 ; BE
dd C_DATA66 ; BF
dd C_MODRM+C_DATA1 ; C0
dd C_MODRM+C_DATA1 ; C1
dd C_DATA2 ; C2
dd 0 ; C3
dd C_MODRM ; C4
dd C_MODRM ; C5
dd C_MODRM+C_DATA1 ; C6
dd C_MODRM+C_DATA66 ; C7
dd C_DATA2+C_DATA1 ; C8
dd 0 ; C9
dd C_DATA2 ; CA
dd 0 ; CB
dd 0 ; CC
dd 0 ; CD
dd 0 ; CE
dd 0 ; CF
dd C_MODRM ; D0
dd C_MODRM ; D1
dd C_MODRM ; D2
dd C_MODRM ; D3
dd C_DATA1 ; D4
dd C_DATA1 ; D5
dd 0 ; D6
dd 0 ; D7
dd C_MODRM ; D8
dd C_MODRM ; D9
dd C_MODRM ; DA
dd C_MODRM ; DB
dd C_MODRM ; DC
dd C_MODRM ; DD
dd C_MODRM ; DE
dd C_MODRM ; DF
dd C_DATA1 ; E0
dd C_DATA1 ; E1
dd C_DATA1 ; E2
dd C_DATA1 ; E3
dd C_DATA1 ; E4
dd C_DATA1 ; E5
dd C_DATA1 ; E6
dd C_DATA1 ; E7
dd C_DATA66 ; E8
dd C_DATA66 ; E9
dd C_DATA66+C_MEM2 ; EA
dd C_DATA1 ; EB
dd 0 ; EC
dd 0 ; ED
dd 0 ; EE
dd 0 ; EF
dd C_PREFIX ; F0
dd 0 ; F1
dd C_PREFIX ; F2
dd C_PREFIX ; F3
dd 0 ; F4
dd 0 ; F5
dd 0 ; F6
dd 0 ; F7
dd 0 ; F8
dd 0 ; F9
dd 0 ; FA
dd 0 ; FB
dd 0 ; FC
dd 0 ; FD
dd C_MODRM ; FE
dd C_MODRM ; FF
table_0F label dword ; 0F-prefixed instructions
dd C_MODRM ; 00
dd C_MODRM ; 01
dd C_MODRM ; 02
dd C_MODRM ; 03
dd -1 ; 04
dd -1 ; 05
dd 0 ; 06
dd -1 ; 07
dd 0 ; 08
dd 0 ; 09
dd 0 ; 0A
dd 0 ; 0B
dd -1 ; 0C
dd -1 ; 0D
dd -1 ; 0E
dd -1 ; 0F
dd -1 ; 10
dd -1 ; 11
dd -1 ; 12
dd -1 ; 13
dd -1 ; 14
dd -1 ; 15
dd -1 ; 16
dd -1 ; 17
dd -1 ; 18
dd -1 ; 19
dd -1 ; 1A
dd -1 ; 1B
dd -1 ; 1C
dd -1 ; 1D
dd -1 ; 1E
dd -1 ; 1F
dd -1 ; 20
dd -1 ; 21
dd -1 ; 22
dd -1 ; 23
dd -1 ; 24
dd -1 ; 25
dd -1 ; 26
dd -1 ; 27
dd -1 ; 28
dd -1 ; 29
dd -1 ; 2A
dd -1 ; 2B
dd -1 ; 2C
dd -1 ; 2D
dd -1 ; 2E
dd -1 ; 2F
dd -1 ; 30
dd -1 ; 31
dd -1 ; 32
dd -1 ; 33
dd -1 ; 34
dd -1 ; 35
dd -1 ; 36
dd -1 ; 37
dd -1 ; 38
dd -1 ; 39
dd -1 ; 3A
dd -1 ; 3B
dd -1 ; 3C
dd -1 ; 3D
dd -1 ; 3E
dd -1 ; 3F
dd -1 ; 40
dd -1 ; 41
dd -1 ; 42
dd -1 ; 43
dd -1 ; 44
dd -1 ; 45
dd -1 ; 46
dd -1 ; 47
dd -1 ; 48
dd -1 ; 49
dd -1 ; 4A
dd -1 ; 4B
dd -1 ; 4C
dd -1 ; 4D
dd -1 ; 4E
dd -1 ; 4F
dd -1 ; 50
dd -1 ; 51
dd -1 ; 52
dd -1 ; 53
dd -1 ; 54
dd -1 ; 55
dd -1 ; 56
dd -1 ; 57
dd -1 ; 58
dd -1 ; 59
dd -1 ; 5A
dd -1 ; 5B
dd -1 ; 5C
dd -1 ; 5D
dd -1 ; 5E
dd -1 ; 5F
dd -1 ; 60
dd -1 ; 61
dd -1 ; 62
dd -1 ; 63
dd -1 ; 64
dd -1 ; 65
dd -1 ; 66
dd -1 ; 67
dd -1 ; 68
dd -1 ; 69
dd -1 ; 6A
dd -1 ; 6B
dd -1 ; 6C
dd -1 ; 6D
dd -1 ; 6E
dd -1 ; 6F
dd -1 ; 70
dd -1 ; 71
dd -1 ; 72
dd -1 ; 73
dd -1 ; 74
dd -1 ; 75
dd -1 ; 76
dd -1 ; 77
dd -1 ; 78
dd -1 ; 79
dd -1 ; 7A
dd -1 ; 7B
dd -1 ; 7C
dd -1 ; 7D
dd -1 ; 7E
dd -1 ; 7F
dd C_DATA66 ; 80
dd C_DATA66 ; 81
dd C_DATA66 ; 82
dd C_DATA66 ; 83
dd C_DATA66 ; 84
dd C_DATA66 ; 85
dd C_DATA66 ; 86
dd C_DATA66 ; 87
dd C_DATA66 ; 88
dd C_DATA66 ; 89
dd C_DATA66 ; 8A
dd C_DATA66 ; 8B
dd C_DATA66 ; 8C
dd C_DATA66 ; 8D
dd C_DATA66 ; 8E
dd C_DATA66 ; 8F
dd C_MODRM ; 90
dd C_MODRM ; 91
dd C_MODRM ; 92
dd C_MODRM ; 93
dd C_MODRM ; 94
dd C_MODRM ; 95
dd C_MODRM ; 96
dd C_MODRM ; 97
dd C_MODRM ; 98
dd C_MODRM ; 99
dd C_MODRM ; 9A
dd C_MODRM ; 9B
dd C_MODRM ; 9C
dd C_MODRM ; 9D
dd C_MODRM ; 9E
dd C_MODRM ; 9F
dd 0 ; A0
dd 0 ; A1
dd 0 ; A2
dd C_MODRM ; A3
dd C_MODRM+C_DATA1 ; A4
dd C_MODRM ; A5
dd -1 ; A6
dd -1 ; A7
dd 0 ; A8
dd 0 ; A9
dd 0 ; AA
dd C_MODRM ; AB
dd C_MODRM+C_DATA1 ; AC
dd C_MODRM ; AD
dd -1 ; AE
dd C_MODRM ; AF
dd C_MODRM ; B0
dd C_MODRM ; B1
dd C_MODRM ; B2
dd C_MODRM ; B3
dd C_MODRM ; B4
dd C_MODRM ; B5
dd C_MODRM ; B6
dd C_MODRM ; B7
dd -1 ; B8
dd -1 ; B9
dd C_MODRM+C_DATA1 ; BA
dd C_MODRM ; BB
dd C_MODRM ; BC
dd C_MODRM ; BD
dd C_MODRM ; BE
dd C_MODRM ; BF
dd C_MODRM ; C0
dd C_MODRM ; C1
dd -1 ; C2
dd -1 ; C3
dd -1 ; C4
dd -1 ; C5
dd -1 ; C6
dd -1 ; C7
dd 0 ; C8
dd 0 ; C9
dd 0 ; CA
dd 0 ; CB
dd 0 ; CC
dd 0 ; CD
dd 0 ; CE
dd 0 ; CF
dd -1 ; D0
dd -1 ; D1
dd -1 ; D2
dd -1 ; D3
dd -1 ; D4
dd -1 ; D5
dd -1 ; D6
dd -1 ; D7
dd -1 ; D8
dd -1 ; D9
dd -1 ; DA
dd -1 ; DB
dd -1 ; DC
dd -1 ; DD
dd -1 ; DE
dd -1 ; DF
dd -1 ; E0
dd -1 ; E1
dd -1 ; E2
dd -1 ; E3
dd -1 ; E4
dd -1 ; E5
dd -1 ; E6
dd -1 ; E7
dd -1 ; E8
dd -1 ; E9
dd -1 ; EA
dd -1 ; EB
dd -1 ; EC
dd -1 ; ED
dd -1 ; EE
dd -1 ; EF
dd -1 ; F0
dd -1 ; F1
dd -1 ; F2
dd -1 ; F3
dd -1 ; F4
dd -1 ; F5
dd -1 ; F6
dd -1 ; F7
dd -1 ; F8
dd -1 ; F9
dd -1 ; FA
dd -1 ; FB
dd -1 ; FC
dd -1 ; FD
dd -1 ; FE
dd -1 ; FF
end
Bây giờ chúng ta có thể lấy được chiều dài của chỉ thị trên address bất kỳ. chúng ta sẽ
repeat call này cho đến 5 bytes được read. Sau đó chúng ta sẽ copy các bytes này đến
old_hook. Chúng ta biết bao nhiêu bytes các chỉ thị đều tiên. vì vậy chúng ta có thể fill out the
relative (tương đối) jump address trên next instruction trong original function.
.386p
.model flat, stdcall
...
.data
kernel_name db "kernel32.dll",0
sleep_name db "Sleep",0
...
MEM_RELEASE dd 000008000h
;16 nops + one relative jump
old_sleep db 090h,090h,090h,090h,090h,090h,090h,090h,
090h,090h,090h,090h,090h,090h,090h,090h,
0E9h,000h,000h,000h,000h
.code
start:
push 5000
call Sleep
do_hook:
push offset kernel_name
call GetModuleHandleA
push offset sleep_name
push eax
call GetProcAddress
push eax
mov esi,eax
xor ecx,ecx
mov ebx,esi
get_five_bytes:
push ecx
push ebx
call get_instr_len ;calling LDE32
pop ecx
add ecx,eax
add ebx,eax
cmp ecx,5
jb get_five_bytes
mov edi,offset old_sleep ;counting relative jump address
mov [edi+011h],ebx
sub [edi+011h],edi
sub dword ptr [edi+011h],015h
rep movsb
pop edi
;following code was above, so without comments
push PAGE_READWRITE
push MEM_COMMIT
push MEMORY_BASIC_INFORMATION_SIZE
push 0
call VirtualAlloc
test eax,eax
jz do_sleep
mov esi,eax
push MEMORY_BASIC_INFORMATION_SIZE
push esi
push edi
call VirtualQuery
test eax,eax
jz free_mem
call GetCurrentProcess
push 5
push edi
push eax
call FlushInstructionCache
lea eax,[esi+014h]
push eax
push PAGE_EXECUTE_READWRITE
lea eax,[esi+00Ch]
push [eax]
push [esi]
call VirtualProtect
test eax,eax
jz free_mem
mov byte ptr [edi],0E9h
mov eax,offset new_sleep
sub eax,edi
sub eax,5
inc edi
stosd
push offset old_protect
lea eax,[esi+014h]
push [eax]
lea eax,[esi+00Ch]
push [eax]
push [esi]
call VirtualProtect
free_mem:
push MEM_RELEASE
push 0
push esi
call VirtualFree
do_sleep:
push 5000
call Sleep
push 0
call ExitProcess
new_sleep:
mov eax,dword ptr [esp+004h]
add eax,eax ;doubling timeout
push eax
mov eax,offset old_sleep ;calling old function
call eax
ret 004h
After the hook it will look like this:
004010CC: 6888130000 push 000001388h
004010D1: E818090000 call Sleep
Sleep: ;this is jump on address in IAT
004019EE: FF2514204000 jmp dword ptr [000402014h]
tabulka:
00402014: 79 67 E8 77 6C 7D E8 77
Kernel32.Sleep:
77E86779: E95FA95788 jmp 0004010DDh
new_sleep:
004010DD: 8B442404 mov eax,dword ptr [esp+4]
004010E1: 03C0 add eax,eax
004010E3: 50 push eax
004010E4: B827304000 mov eax,000403027h
004010E9: FFD0 call eax
old_sleep:
00403027: 6A00 push 0
00403029: FF742408 push dword ptr [esp+8]
0040302D: 90 nop
0040302E: 90 nop
0040302F: 90 nop
00403030: 90 nop
00403031: 90 nop
00403032: 90 nop
00403033: 90 nop
00403034: 90 nop
00403035: 90 nop
00403036: 90 nop
00403037: E94337A877 jmp Kernel32.77E8677F
;this instruction is placed 1 byte after first instruction at Kernel32.Sleep
(77E86779)
Kernel32.77E8677F:
77E8677F: E803000000 call Kernel32.SleepEx
... ;following is unimportant
To make this clearer, this is how the original version of Kernel32.Sleep looks:
Kernel32.Sleep:
77E86779: 6A00 push 0
77E8677B: FF742408 push dword ptr [esp+8]
77E8677F: E803000000 call Kernel32.SleepEx
77E86784: C20400 ret 00004h
Như bạn có thể thấy chúng ta đã copied chỉ thị đầu tiên và thứ hai (nó là 6 bytes
ở đây) và relative jump được trỏ đến trên next instruction và đó là nó sẽ như thế nào
Chúng ta phải tưởng tượng ở đây các relative jumps ko được đặt như
các bytes đầu tiên của các hàm functions. Nếu là thế chúng ta có một vấn đề. Vấn đề
kết tíep là với các hàm APIs giống như ntdll.DbgBreakPoint. Chúng quá ngắn cho pp này
để hooking. Và thấy rằng khi nó được gọi bởi Kernel32.DebugBreak, nó ko thể hook bởi
thay đổi IAT. Nhưng ai muốn hook function mà nó chỉ gọi
int 3? Nhưng ko có gì là ko thể. Bạn có thể nghĩ về nó và bạn có thể
tìm cách như thế nào để giải quyết vấn đề này . Khi bạn nghĩ về điều này bạn có thể hook hàm
sau đây sau hàm này (nó sẽ bị damaged bởi rewritng first 5 bytes of hàm trước đó).
Hàm DbgBreakPoint là 2 bytes chiều dài, vì vậy chúng ta có thể set vài
flags ở đây và thữ write conditional jump trên begining of the second
function ... Nhưng bây giờ điều ày ko phải là vấn đề của chúng ta.
Với vấn đề saving original function rồi thuật lại unhooking.
Unhooking thay đổi thay thế các bytes trở lại trạng thái gốc original state. Khi rewriting
IAT bạn sẽ phải return original address đến table nếu bạn muốn làm
unhooking. Khi sử dụng 5 byte patch bạn sẽ phải copy các chỉ thị gốc đàu tiên trở lại.
Cảc hai cách thật sự đơn giản và ko cần viết nhềiu về điều này.
=====[ 3.2.4 Other process hooking ]============================================
Bây giờ chúng ta sẽ làm vài thứ thực tế với việc hooking trong suốt quá trình running. Ai múôn
đề cập đến hooking cho chính process của nó? Đó chỉ tốt cho việc học căn bản
nhưng nó ko thực tế.
Tôi sẽ chỉ cho bạn 3 pp để hooking process khác. Hai trong chúng sử dụng
API CreateRemoteThread mà chúng chỉ có trong Windows với NT technology. Vấn đề
of hooking ko đáng quan tâm cho các older windows version đối với tôi. Sau tất cả
tôi sẽ thử giải thích pp thứ ba mà tôi ko thực hành. vì vậy nó có thể ko
họat động.
Dầu tiên nói vài diều về CreateRemoteThread. Như phần help nói rằng hàm này
creates new thread trong bất kỳ process nào và runs code của nó.
HANDLE CreateRemoteThread(
HANDLE hProcess,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
DWORD dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);
Handle hProcess có thể có bởi OpenProcess. Ở đây ch1ng ta phải có quyền
cần thiết. Pointer lpStartAddress trỏ đến memory place trong TARGET
process mà ở đó chỉ thị đầu tiên cho new thread . Bởi vì new thread được
created trong target process nó ở trong memory of target process. Con trỏ
lpParameter trỏ đến trên đối số mà nó sẽ được tham chiếu đén new thread.
=====[ 3.2.4.1 DLL Injection ]==================================================
Chúng ta có thể run new thread từ bất kỳ nơi nào trong target process memory.
Ở đây trừ phi chúng ta có chính code trong nó. PP đầu tiên cheats cho điều này.
Nó sử dụng GetProcAddress để có addr thực cho hàm LoadLibrary. Rồi định tuyến
lpStartAddress đến address of LoadLibrary. Function LoadLibary chỉ có một
parameter giống như hàm cho new thread trong target process.
HINSTANCE LoadLibrary(
LPCTSTR lpLibFileName
);
Chúng ta sẽ sử dụng sự đồng dạng này và chúng ta sẽ tham chiếu đến name of our DLL
library như là lpParameter. Sau đó running new thread lpParameter sẽ trên vị trí của
of lpLibFileName. Điều quan trọng nhất ở đây là hành vi được mô tả trước đó.
Sau khi loading new module vào trong target process memory phần khởi trị đầu đã được
thực thi. Nếu chúng ta đặt các hàm functions đặc biệt mà chúng sẽ hook các functions mà chúng ta muốn
chúng ta sẽ chiến thắng trong stuff này. Sau khi thực thi phần khởi trị đầu, thread sẽ ko có gì
dể làm và close nhưng module của chúng ta sẽ vẫn trong memory. PP này thật sự
rất đẹp và dễ thực hiện. Đây được gọi là DLL Injection. Nhưng nếu bạn thích như tôi
bạn bạn ko thích phải có nhiều DLL library. Nhưng nếu ai đó ko quan tâm
về việc có nhiều library này thì nó là pp dễ nhất và nhanh nhất (từ gốc độ
lập trình viên).
=====[ 3.2.4.2 Independent code ]===============================================
Tiếp tục với cách independent code là rất khó nhưng cũng rất ấn
tượng. Independent code là code mà ko có các addresses tỉnh nào.
Mọi thứ đều là tương đối trong nó theo hướng một nơi mốc nào đó trong nó. Code này
hầu hết được làm nếu chúng ta ko biết address mà ở đó code này sẽ được thực thi.
Chắc chắn, nó có thể có addr này và rồi relink code của chúng ta như là nó xử lý
trên new address mà ko có lỗi nào nhưng điều này ngay cả khó hơn là
coding independent code. Ví dụ về lọai code này có thể là virus code.
Virus mà chúng lây nhiễm vào các file thực thi trong cách mà nó add chính nó vào một nơi nào đó
trong file thực thi này Các file thực thi khác sẽ là virus code trên các nơi khác
mà nó phụ thuộc. e.g. on file structure on length.
Đầu tiên chúng ta phải insert code của chúng ta trong target process. Rồi function
CreateRemoteThread sẽ săn sóc running code của chúng ta. Vì vậy, đầu tiên chúng ta phải
lấy vài thông tin về target process và lấy handle với OpenProcess.
Rồi dùng VirtualAllocEx sẽ cách phát vài space trong remote process memory cho
code của chúng ta.Cuối cùng chúng ta sẽ sử dụng WriteProcessMemory để write code của chúng ta trên
memory được cấp phát và run nó. Trong CreateRemoteThread lpStartAddress sẽ tham chiếu đến
memory được cấp phát và lpParameter có thể là bất cứ gì chúng ta muốn. Bởi vì Tôi thật sự ko thích các
files ko cần thíết nào nên tôi sử dụng pp này.
=====[ 3.2.4.3 Raw change ]=====================================================
Ko có hàm CreateRemoteThread trong older windows version (ngọai trừ NT).
Vì vậy cúng ta ko thể sử dụng hàm này để hooking. Có lẽ có pp khác và tốt hơn các pp
hook tôi sẽ nói về một pp khác ngay bây giờ. Trong thực tế tôi ko biết nếu pp này
làm việc trong thực tiển (chưa có ai biết khi sử dụng Windows) nhưng về mặt lý thuyết thì mọi thứ
đều OK .
Chúng ta ko cần phải có code của chúng ta trong target process để hook các hàm functions
của nó hòan tòan. Chúng ta có hàm WriteProcessMemory (hàm này có trong all các Windows
version) và chúng ta củng có hàm OpenProcess. Sau cùng chúng ta cần là VirtualProtectEx
mà chúng có thể thay đổi truy xấut memory pages trong target process. Tôi ko thể thấy bất cứ
lý do gì mà ko hook được target process functions một cách trực tiếp từ process của chúng ta...
=====[ 4. Ending ]==============================================================
This small document ends. I will greet (đón chào) any extension which will
describe unmentionde (ko được nhắc đến ) methods of hook, I am sure there are a lot of them. I will
also greet (chào đón) any extensions in the parts which were not described so intimately (sâu sắc).
You can also send me some source codes if they are fecund (đẻ nhiều) for the problem of
hooking e.g. for parts where I was lazy to write the code. The goal of this
document is to show details of every technics of hooking. I hope I've done
the part of this.
Special thanks to Z0MBiE for his work, so I haven't to code it myself
and spend ages by studying tables for getting instruction length.
===================================[ End ]======================================
.gif)
0 nhận xét:
Đăng nhận xét