挂钩Windows API

缺乏、安全感 2021-11-04 20:54 264阅读 0赞

挂钩Windows API

作者: SoBeIt

=====\[ 1. 介绍 \]====================================================

这篇文章是有关在OS Windows下挂钩API函数的方法。所有例子都在基于NT技术的Windows版本NT 4.0及以上有效(Windows NT 4.0, Windows 2000, Windows XP)。可能在其它Windows系统也会有效。  
你应该比较熟悉Windows下的进程、汇编器、PE文件结构和一些API函数，才能明白这篇文章里的内容。  
这里使用"Hooking API"这个术语表示对API的完全修改。当调用被挂钩的API时，我们的代码能立刻被执行。我将写下完全的挂钩过程。

=====\[ 2. 挂钩方法 \]==============================================

一般来说我们的目的是用我们的代码取代一些函数里的代码。这些问题有时可以在进程运行前解决。这些大多数时候可以用我们运行的用户级进程来完成，目的可以是修改程序的行为。举个例子应用程序的破解，比方说有些程序会在启动时需要原光盘，我们想要不用光盘就启动它。如果我们修改获取驱动类型的函数我们就可以让程序从硬盘启动。  
当我们挂钩系统进程时(比如说服务)这些不可能做到或者我们不打算这么做，或者在这个例子里我们不知道哪个进程才是目标。这时我们就要用到动态挂钩(在运行时挂钩)的技术。使用的例子有rootkit或者病毒里的反杀毒软件的技术。

=====\[ 2.1 运行前挂钩 \]===========================================

这里修改我们想要修改函数来自的物理模块(大多数时候是.exe或.dll)。在这里我们至少有3种可能的做法。  
第一种可能是找到函数的入口点然后重写它的代码。这会因为函数的大小而受限制，但我们能动态加载其它一些模块(API LoadLibrary)，所以应该足够了。  
内核函数(kernel32.dll)是通用的因为Windows中每个进程都有这个模块的拷贝。另一个好处是如果我们知道哪些模块在某版本中会修改，我们可以在一些API如LoadLibraryA中使用直接的指针。这是因为kernel模块在内存中地址在相同Windows版本中是固定的。我们同样也能用动态加载的模块的作用。在这里它的初始化部分在加载进内存后立刻就运行。在新模块的初始化部分我们不受限制。  
第二种可能是在模块中被代替的函数只是原函数的扩展。然后我们选择要么修改开始的5个字节为跳转指令或者改写IAT。如果改为跳转指令，那么将会改变指令执行流程转为执行我们的代码。如果调用了IAT记录被修改的函数，我们的代码能在调用结束后被执行。但模块的扩展没那么容易，因为我们必须注意DLL首部。  
下一个是修改整个模块。这意味着我们创建自己的模块版本，它能够加载原始的模块并调用原始的函数，当然我们对这个不感兴趣，但重要的函数都是被更新的。这种方法对于有的模块过大有几百个导出函数的很不方便。

=====\[ 2.2 运行时挂钩 \]==========================================

在运行前挂钩通常都非常特殊，并且是在内部面向具体的应用程序(或模块)。如果我们更换了kernel32.dll或ntdll.dll里的函数(只在NT操作系统里)，我们就能完美地做到在所有将要运行的进程中替换这个函数。但说来容易做起来却非常难，因为我们不但得考虑精确性和需要编写比较完善的新函数或新模块，但主要问题是只有将要运行的进程才能被挂钩(要挂钩所有进程只能重启电脑)。另一个问题是如何进入这些文件，因为NT操作系统保护了它们。比较好的解决方法在进程正在运行时挂钩。这需要更多的有关知识，但最后的结果相当不错。在运行中挂钩只对能够写入它们的内存的进程能成功。为了能写入它自己我们使用API函数WriteProcessMemory。现在我们开始运行中挂钩我们的进程。

=====\[ 2.2.1 使用IAT挂钩本进程 \]===================================

这里有很多种可能性。首先介绍如何用改写IAT挂钩函数的方法。接下来这张图描述了PE文件的结构:

这里对我们比较重要的是.idata部分的导入地址表(IAT)。这个部分包含了导入的相关信息和导入函数的地址。有一点很重要的是我们必须知道PE文件是如何创建的。当在编程语言里间接调用任意API(这意味着我们是用函数的名字来调用它，而不是用它的地址)，编译器并不直接把调用连接到模块，而是用jmp指令连接调用到IAT，IAT在系统把进程调入内存时时会由进程载入器填满。这就是我们可以在两个不同版本的Windows里使用相同的二进制代码的原因，虽然模块可能会加载到不同的地址。进程载入器会在程序代码里调用所使用的IAT里填入直接跳转的jmp指令。所以我们能在IAT里找到我们想要挂钩的指定函数，我们就能很容易改变那里的jmp指令并重定向代码到我们的地址。完成之后每次调用都会执行我们的代码了。这种方法的缺点是经常有很多函数要被挂钩(比方说如果我们要在搜索文件的API中改变程序的行为我们就得修改函数FindFirstFile和FindNextFile，但我们要知道这些函数都有ANSI和WIDE版本，所以我们不得不修改FindFirstFileA、FindFirstFileW、FindNextFileA和FileNextFileW的IAT地址。但还有其它类似的函数如FindFirstFileExA和它的WIDE版本FindFirstFileExW，也都是由前面提到的函数调用的。我们知道FindFirstFileW调用FindFirstFileExW，但这是直接调用，而不是使用IAT。再比如说ShellAPI的函数SHGetDesktopFolder也会直接调用FindFirstFilwW或FindFirstFileExW)。如果我们能获得它们所有，结果就会很完美。  
我们通过使用imagehlp.dll里的ImageDirectoryEntryToData来很容易地找到IAT。

PVOID ImageDirectoryEntryToData(  
IN LPVOID Base,  
IN BOOLEAN MappedAsImage,  
IN USHORT DirectoryEntry,  
OUT PULONG Size  
);

在这里Base参数可以用我们程序的Instance(Instance通过调用GetModuleHandle获得):

hInstance = GetModuleHandleA(NULL);

DirectoryEntry我们可以使用恒量IMAGE\_DIRECTORY\_ENTRY\_IMPORT。

\#define IMAGE\_DIRECTORY\_ENTRY\_IMPORT 1

函数的结果是指向第一个IAT记录指针。IAT的所有记录是由IMAGE\_IMPORT\_DESCRIPTOR定义的结构。所以函数结果是指向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;

IMAGE\_IMPORT\_DESCRIPTOR里的Name成员变量是模块名字的指针。如果我们想要挂钩某个函数比如是来自kernel32.dll我们就在导入表里找属于名字kernel32.dll的描述符号。我们先调用ImageDirectoryEntryToData然后找到名字是"kernel32.dll"的描述符号(可能不只一个描述符号是这个名字)，最后我们在这个模块的记录里所有函数的列表里找到我们想要的函数(函数地址通过GetProcAddress函数获得)。如果我们找到了就必须用VirtualProtect函数来改变内存页面的保护属性，然后就可以在内存中的这些部分写入代码了。在改写了地址之后我们要把保护属性改回来。在调用VirtualProtect之前我们还要先知道有关页面的信息，这通过VirtualQuery来实现。我们可以加入一些测试以防某些函数会失败(比方说如果第一次调用VirtualProctect就失败了，我们就没办法继续)。

PCSTR pszHookModName = "kernel32.dll",pszSleepName = "Sleep";  
HMODULE hKernel = GetModuleHandle(pszHookModName);  
PROC pfnNew = (PROC)0x12345678, //这里存放新地址  
pfnHookAPIAddr = GetProcAddress(hKernel,pszSleepName);

ULONG ulSize;  
PIMAGE\_IMPORT\_DESCRIPTOR pImportDesc =  
(PIMAGE\_IMPORT\_DESCRIPTOR)ImageDirectoryEntryToData(  
hKernel,  
TRUE,  
IMAGE\_DIRECTORY\_ENTRY\_IMPORT,  
&ulSize  
);

while (pImportDesc->Name)  
\{  
PSTR pszModName = (PSTR)((PBYTE) hKernel + pImportDesc->Name);  
if (stricmp(pszModName, pszHookModName) == 0)  
break;  
pImportDesc++;  
\}

PIMAGE\_THUNK\_DATA pThunk =  
(PIMAGE\_THUNK\_DATA)((PBYTE) hKernel + 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++;  
\}

调用Sleep(1000)的结果如例子所示:

00407BD8: 68E8030000 push 0000003E8h  
00407BDD: E812FAFFFF call Sleep

Sleep: ;这是跳转到IAT里的地址  
004075F4: FF25BCA14000 jmp dword ptr \[00040A1BCh\]

原始表:  
0040A1BC: 79 67 E8 77 00 00 00 00

新表:  
0040A1BC: 78 56 34 12 00 00 00 00

所以最后会跳转到0x12345678。

=====\[ 2.2.2 改写入口点挂钩本进程 \]==================

改写函数入口点开始的一些字节这种方法相当简单。就象改变IAT里的地址一样，我们也要先修改页面属性。在这里对我们想要挂钩的函数是一开始的5个字节。为了之后的使用我们用动态分配MEMORY\_BASIC\_INFORMATION结构。函数的起始地址也是用GetProcAddress来获得。我们在这个地址里插入指向我们代码的跳转指令。接下来程序调用Sleep(5000)(所以它会等待5秒钟)，然后Sleep函数被挂钩并重定向到new\_sleep，最后它再次调用Sleep(5000)。因为新的函数new\_sleep什么都不做并直接返回，所以整个程序只需要5秒钟而不是10秒种。

.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 ;最后获得Sleep地址

push PAGE\_READWRITE  
push MEM\_COMMIT  
push MEMORY\_BASIC\_INFORMATION\_SIZE  
push 0  
call VirtualAlloc  
test eax,eax  
jz do\_sleep  
mov esi,eax ;为MBI结构分配内存

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:  
ret 004h  
end start

第二次调用Sleep的结果是这样:

004010A4: 6888130000 push 000001388h  
004010A9: E80A000000 call Sleep

Sleep: ;这里是跳转到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

=====\[ 2.2.3 保存原始函数 \]=====================================

更多时候我们需要的不仅仅是挂钩函数。比方说也许我们并不想取代给定的函数而只是想检查一下它的结果，或者也许我们只是想在函数被使用特定的参数来调用时才取代原函数。比较好的例子有前面提过的通过取代FindXXXFile函数来完成隐藏文件。所以如果我们想要隐藏指定的文件并且不想被注意的话，就得对其它所有文件只调用没有被修改过的原始函数。这对使用修改IAT的方法时是很简单的，为调用原始函数我们可以用GetProcAddress获得它的原始地址，然后直接调用。但修改入口点的方法就会有问题，因为修改了函数入口点的5个字节，使我们破坏了原函数。所以我们必须保存开始的那些指令。这将用到以下的技术。  
我们知道我们要修改开始的5个字节但不知道里面包含多少条指令以及指令的长度。我们得为开始那些指令保留足够的内存空间。16个字节应该足够了，因为函数开始时通常没有多长的指令，很可能根本就用不到16个字节。整个被保留的内存用0x90(0x90=nop)来填满。下一个5个字节预留给将在之后填入的跳转指令。

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

现在我们已准备好拷贝开始的指令。为获得指令长度的代码相当麻烦，这就是我们得使用已完成的引擎的原因。它是由Z0MBiE写的。传入参数是我们要获得长度的指令的地址。输出参数在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:

; \_\_fastcall EAX  
; \_\_cdecl \[ESP+4\]

;这是我的第一处修改，它只是这个函数的声明  
get\_instr\_len:

mov ecx, \[esp+4\] ; ECX = opcode ptr

xor edx, edx ; 标志  
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

;这里是我的第二处修改，只有在原始版本这里是retn  
@@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 -- 在代码中分析,不需要标志(也就是标志(flag)必须为0)  
;F6,F7 -- --//-- (ttt=000 -- 3 字节, 否则为2字节)  
;CD -- --//-- (如果为 CD 20 为6字节, 否则为2字节)

table\_1 label dword ; 一般的指令

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为前缀的指令

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

现在我们可以获取任意地址的指令长度。我们重复调用这个函数直到读取了5个字节。完成后把这些字节拷贝到old\_hook。我们知道了开始这些指令的长度，所以我们可以在原始函数的下条指令填入跳转地址。

.386p  
.model flat, stdcall

...

.data

kernel\_name db "kernel32.dll",0  
sleep\_name db "Sleep",0

...

MEM\_RELEASE dd 000008000h

;16 nops + 一个跳转指令  
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 ;调用LDE32  
pop ecx  
add ecx,eax  
add ebx,eax  
cmp ecx,5  
jb get\_five\_bytes  
mov edi,offset old\_sleep ;计算跳转地址  
mov \[edi+011h\],ebx  
sub \[edi+011h\],edi  
sub dword ptr \[edi+011h\],015h  
rep movsb  
pop edi

;下面的代码都是前面有的，所以不需要注解了

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 ;重复延时  
push eax  
mov eax,offset old\_sleep ;调用原函数  
call eax  
ret 004h

挂钩后看起来想这样:

004010CC: 6888130000 push 000001388h  
004010D1: E818090000 call Sleep

Sleep: ;跳转到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

;这个指令在Kernel32.Sleep(77E86779)后1个字节

Kernel32.77E8677F:  
77E8677F: E803000000 call Kernel32.SleepEx  
... ;后面的已不重要

为了让这些看起来更清楚，这是原始版本的Kernel32.Sleep:

Kernel32.Sleep:  
77E86779: 6A00 push 0  
77E8677B: FF742408 push dword ptr \[esp+8\]  
77E8677F: E803000000 call Kernel32.SleepEx  
77E86784: C20400 ret 00004h

就象你看到的，在我们已经拷贝了第1和第2个指令(这里总共6个字节)和指向下一条指令的跳转指令后应该是怎样。这里我们得假设跳转指令并不象函数开始的指令那么放置，否则我们就会遇到问题。下一个问题就是诸如ntdll.DbgBreakPoint这样的API，它们太短了，所以不能用这种挂钩的方法。并且它是由Kernel32.DebugBreak调用，所以也不能通过修改IAT来挂钩。虽然说没有谁会去挂钩这个只有int 3的函数，但没有什么是做不到的，只要认真想想就能找到解决的方法。我的方法是挂钩它之后的那个函数(它可能会因为修改了前一个函数的开始5个字节而被破坏)。DbgBreakPoint函数长度为2个字节，所以这里我们可以设置一些标志，然后试着在第二个函数的开始写入条件跳转指令...但这不是我们现在的问题。  
保存原始函数的问题已经叙述完了，就到解除挂钩(unhook)。解除挂钩就是把被修改的字节恢复为原始状态。修改IAT的方法里，如果你想解除挂钩的话，你就需要在表里恢复原始的地址。修改入口点的方法里，你要做的就是把原始函数的开始指令拷贝回去。两种做法都很简单，所以不需要再讲了。

=====\[ 2.2.4 挂钩其它进程 \]========================================

现在我们来实践一下运行中挂钩。试想，谁会想只挂钩自己进程?这显然是非常不实用的。  
我来演示3种不同的挂钩其它进程的方法。其中两种都使用了CreateRemoteThread这个API，它只在使用了NT技术的Windows版本里有效。对我来说在较老的Windows里挂钩没那么有趣。忘了说我将介绍的这3个方法我都没有实践过，所以可能会出点问题。  
先介绍CreateRemoteThread。就象帮助里说的，这个函数可以在任意进程里创建新线程并运行它的代码。

HANDLE CreateRemoteThread(  
HANDLE hProcess,  
LPSECURITY\_ATTRIBUTES lpThreadAttributes,  
DWORD dwStackSize,  
LPTHREAD\_START\_ROUTINE lpStartAddress,  
LPVOID lpParameter,  
DWORD dwCreationFlags,  
LPDWORD lpThreadId  
);

句柄hProcess可以通过OpenProcess获得。这里我们必须获得足够权限。lpStartAddress是指向目标进程地址空间里存放新线程第一条指令地址的指针，因为新线程是在目标进程里创建，所以它存在于目标进程的地址空间里。lpParameter是指向提交给新线程的参数的指针。

=====\[ 2.2.4.1 DLL注入 \]==================================================

我们可以在目标进程地址空间里任意地方运行我们的新线程。这看起来没什么用，除非在里面有我们完整的代码。第一种方法就是这么实现。它调用GetProcAddress获取LoadLibrary地址。然后把LoadLibrary赋值给参数lpStartAddress。LoadLibrary函数只有一个参数，就和目标进程里新线程的函数一样。

HINSTANCE LoadLibrary(  
LPCTSTR lpLibFileName  
);

我们可以使用这点相似性，把lpParameter参数赋为我们的DLL库的名字。在新线程运行后lpParameter的位置就是lpLibFileName的位置。这里最重要的东西前面已经讲过了。在加载了新的模块到目标进程后就开始执行初始化部分。如果我们在这里放置了能够挂钩其它函数的特殊函数就OK了。在执行了初始化部分后，这个线程就什么都不做并被关闭，但我们的模块仍然在地址空间中。这种方法很不错而且很容易实现，它的名字叫DLL注入。但如果你和我一样不喜欢还得多个DLL库的话，请看下面的方法。但如果不介意多个DLL库的话这确实是最快的方法(从程序员的角度来看)。

=====\[ 2.2.4.2 独立的代码 \]===============================================

实现独立的代码比较困难，但也容易给人深刻印象。独立的代码是不需要任何静态地址的代码。它里面所有东西都是互相联系地指向代码里面某些特定的地方。如果我们不知道这段代码开始执行的地址它也能自己完成 。当然，也有可能先获得地址然后重新链接我们的代码这样它可以完全正常地在新地址工作，但这比编写独立的代码更困难。这类型代码的例子比方说病毒的代码。病毒通过这种方法感染可执行文件，它把它自己的代码加入到可执行文件中的某个地方。在不同的可执行文件中放置病毒代码的位置也不一样，这取决于比方说文件结构的长度。  
首先将我们的代码插入目标进程，然后CreateRemoteThread函数就会负责运行我们的代码。所以第一步我们要做的就是通过OpenProcess函数获取目标进程的信息和句柄，接着调用VirtualAllocEx在目标进程地址空间里分配一些内存给我们的代码，最后调用WriteProcessMemory把我们的代码写入分配的内存里并运行它。调用CreateRemoteThread的参数lpStartAddress设置为分配的内存地址，lpParameter可以随便设置。因为我不喜欢附加什么不必要的文件所以我使用了这种方法。

=====\[ 2.2.4.3 原始修改 \]=====================================================

在非NT内核的老版本Windows里是没有CreateRemoteThread函数的，所以我们不能用以上的方法。可能会有比我现在介绍的这种方法好很多的方法，事实上我的这种方法还没有经过实践，但理论上来说是可行的。  
我们其实根本不需要把我们代码放到目标进程里来挂钩它的函数。有两个函数WriteProcessMemory和OpenProcess，它们在所有版本的Windows中都有效。我们还需要的函数是VirtualProtectEx，用来修改进入目标进程的内存页。我找不到任何不直接从我们的进程挂钩目标进程的的理由...

=====\[ 3. 结束语 \]================================================

我欢迎任何人提出更多的这里没有提到的挂钩方法，我肯定那会有很多。同样欢迎补充我介绍得不是很详细的方法。也可以把我懒得写的代码部分完成，把源代码发给我。这篇文档的目的是演示挂钩技术的细节，我希望我做到了。  
特别感谢Z0MBiE的代码，为我节省了很多宝贵的时间。

============================\[ End \]========================

转载于:https://www.cnblogs.com/F4ncy/archive/2005/05/16/156673.html