目录

1、动态链接库

（1）静态链接库

（2）动态链接库

（3）隐式链接

2、注入

（1）远程线程

（2）远程线程注入

（3）进程间的通信

（4）模块隐藏

（5）代码注入

1、动态链接库

（1）静态链接库

1、编写静态链接库文件

<1> 在 vs2019 中创建新项目，项目类型：静态库

<2> 在项目中创建 xxxx.h 和 xxxx.cpp ， 编写代码，然后生成即可

<3> 在项目目录中会生成 xxxx.lib 文件

2、静态链接库的使用

方法一：将生成的 xxxx.h 与 xxxx.lib 文件复制到项目根目录，然后在代码中引用

方法二：在VS的项目设置中指定 xxxx.lib 文件的位置。右键单击项目，选择 Properties（属性），然后选择左侧 VC++目录 选项卡，编辑右侧 库目录 选项，把  xxxx.lib 文件所在目录添加进来

添加完成后，右击项目中的 引用，选择 添加引用 ，把刚才的 xxxx.lib 文件添加到引用中

3、静态链接库的缺点

• 使用静态链接生成的可执行文件体积较大（ 静态库会合并到 exe 文件中）
• 包含相同的公共代码（如果多个程序引用同一个静态库，每个程序都将有一个静态库的副本），造成资源浪费

（2）动态链接库

1、什么是动态链接库

• 动态链接库（ Dynamic Link Library ，缩写为 DLL ）
• 动态链接库 是微软公司在微软 Windows 操作系统中，实现共享函数库概念的一种方式
• 这些库函数的扩展名是 dll 、ocx （ 包含 ActiveX 控制的库 ）

2、创建动态链接库，使用 _declspec(dllexport)   

• 在 vs2019 中创建新项目，项目类型：动态库
• 在项目中创建 xxxx.h 和 xxxx.cpp ，编写代码，然后生成即可

• 导出表

3、extern "C" _declspec(dllexport) 

<1> _declspec(dllexport)

_declspec(dllexport)：将一个函数声名为导出函数，就是说这个函数要被其他程序调用，即作为DLL的一个对外函数接口1. 通常与 extern "C" 合用，形式如下：extern "C" _declspec(dllexport) 返回类型 调用约定 函数名();    // 以 C语言编译2. 这是由于在制作DLL导出函数时由于C++存在函数重载，因此 _declspec(dllexport) fun(int,int) 在DLL中会被decorate3. 如被decorate成为：fun_int_int，而且不同编译器decorate的方法不同，造成使用GetProcAddress获取 fun地址时的不便4. 使用 extern "C" 时，上述的 decorate不会发生，因为C没有函数重载，如此一来被 extern"C" 修饰的函数，就不具备重载能力

<2> 以下内容摘自 MSDN

1. 在 32位编译器版本中，可以使用 _declspec(dllexport) 关键字从 DLL导出数据、函数、类或类成员函数2. _declspec(dllexport) 将导出指令添加到对象文件（obj文件）3. 若要导出函数， _declspec(dllexport) 关键字必须出现在调用约定关键字的左边（如果指定了关键字）例如：_declspec(dllexport) void _cdecl Fun(void);4. 若要导出类中的所有公共数据成员和成员函数，关键字必须出现在类名的左边，如下所示：class __declspec(dllexport) CExampleExport : public CObject{ ... class definition ... };5. 生成 DLL 时，通常创建一个包含正在导出的函数原型和头文件，并将 _declspec(dllexport) 添加到头文件中的声明6. 若要提高代码的可读性，请为 _declspec(dllexport) 定义一个宏并对正在导出的每个符号使用该宏：#define DllExport _declspec( dllexport )

<3> _declspec(dllexport) 与 .def

模块定义文件（.def）是包含一个或多个描述各种 DLL属性的 Module 语句的文本文件1. 二者的目的都是将公共符号导入到应用程序中或从 DLL 导出函数2. 添加 _declspec(dllexport) 是为了不使用 .def文件，从 .EXE 或 .DLL 导出函数3. 如果不使用 _declspec(dllimport) 或 _declspec(dllexport) 导出 DLL 函数，则 DLL 需要.def文件4. 并不是任何时候选择添加 _declspec(dllexport) 而放弃 .def 的方式都是好的5. 如果DLL是提供给VC++用户使用的，只需要把编译DLL时产生的.lib提供给用户，它可以很轻松地调用你的DLL6. 但是如果DLL是供VB、PB、Delphi用户使用，那么会产生一个小麻烦因为VC++对于 _declspec(dllexport) 声明的函数会进行名称转换如下面的函数：_declspec(dllexport) int _stdcall fun()  会转换为 fun@0 ，这样你在VB中必须这样声明：Declare Function fun Lib "my.dll" Alias "fun@0" () As Long@ 后面的数由于参数类型不同而可能不同，这显然不太方便，所以如果要想避免这种转换，就要使用.def文件方式

4、dll 与 exe 的区别

• dll 与 exe 都是一个模块，dll 为其他模块提供函数和数据
• 每个 模块 存在一张导出表，导出表记录了 模块包含的函数名，dll 一定有导出表，exe 不一定有导出表
• dll 与 exe 都遵循 PE文件结构，dll 与 exe 本质上没有区别，exe 也可以为别的模块提供 函数和数据

5、使用 .def 文件创建 dll

• 新建 .def 文件，在 .def 文件中 指定需要导出的函数

• 生成 dll

• 查看导出表 （ 使用 def 文件，可以达到隐藏函数的目的 ）
• 序号 12 对应十六进制的 C ，13 对应十六进制的 D

6、使用动态链接库

• 将 dll 放到项目的根目录 （显示链接）

#include <stdio.h>
#include <Windows.h>// 定义函数指针
typedef int(__stdcall* lpPlus)(int, int);
typedef int(__stdcall* lpSub)(int, int);// 声明函数指针变量			
lpPlus myPlus;
lpSub mySub;int main() {
// 动态加载dll到内存中					HINSTANCE hModule = LoadLibrary(TEXT("动态库.dll"));// 获取函数地址myPlus = (lpPlus)GetProcAddress(hModule, "plus");		// 传入 函数名mySub = (lpSub)GetProcAddress(hModule, (char*)0xD);		// 传入 序号// 调用函数int a = myPlus(10, 2);int b = mySub(10, 2);// 释放动态链接库（将 dll从进程空间移除）				FreeLibrary(hModule);return 0;
}

（3）隐式链接

1、隐式链接

• 将  dll 和 lib 放到项目的根目录
• 静态库的 lib 文件包含代码，动态库的 lib 文件不包含代码，只包含描述性的信息
• 将 #pragma comment(lib,"xxxx.lib")  添加到调用文件中 
• 加入函数的声明 （只有 dll，没有 lib，则只能使用显示链接）
• 好处：不用获取函数地址

// 隐式链接
#pragma comment(lib,"动态库.lib")
// 加入函数的声明
// DLL 如果使用 _declspec(dllexport) 导出函数，函数声明需要加上 extern "C"
// 使用 def 文件导出函数，则不需要
_declspec(dllimport) int _stdcall plus(int x, int y);
_declspec(dllimport) int _stdcall sub(int x, int y);int main() {int x = plus(1, 2);int y = sub(4, 2);return 0;
}

• 注意

// 导出函数
extern "C" _declspec(dllexport) 返回类型 调用约定 函数名 (参数列表);// 导入函数
extern "C" _declspec(dllimport) 返回类型 调用约定 函数名 (参数列表);  

2、隐式链接的实现

• dll 拥有导出表，表中记录了当前模块提供了哪些函数
• 使用隐式链接生成的 exe 文件，一定拥有导入表，表中记录了当前模块需要使用 哪些 dll 和 dll 中的哪些函数
• dll 也拥有导入表， exe文件不一定拥有导出表

3、dll 的优点

1. dll 不会把自己代码合并到 exe 文件中
2. 对 dll 文件进行修改，不会影响其他进程（写拷贝）

4、DllMain 函数

• dll 和 exe 的入口函数和执行时间不同
• exe 从 main 函数开始执行，dll 从 DllMain 开始执行
• DllMain 可能执行多次

BOOL APIENTRY DllMain(HMODULE hModule,               // 当前 dll 被加载到哪个模块DWORD   ul_reason_for_call,    // reason for calling functionLPVOID  lpReserved             // reserved
)/*
DllMain 被调用的四种情况DLL_PROCESS_ATTACH： 某个进程第一次执行 LoadLibrary加载 dll到内存，会调用 DllMain函数DLL_PROCESS_DETACH： 某个进程调用 FreeLibrary释放 dll时，会调用 DllMain函数DLL_THREAD_ATTACH ： 当前进程的另一个线程执行 LoadLibrary又加载了一次 dll，会调用 DllMainDLL_THREAD_DETACH ： 当前进程的另一个线程执行结束，会调用 DllMain
*/

• 示例代码

// 定义 DLL 应用程序的入口点，模拟不同调用情况
BOOL APIENTRY DllMain( HMODULE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
{switch (ul_reason_for_call){case DLL_PROCESS_ATTACH:OutputDebugString(TEXT("1. DLL_PROCESS_ATTACH\n"));break;case DLL_THREAD_ATTACH:OutputDebugString(TEXT("2. DLL_THREAD_ATTACH\n"));break;case DLL_THREAD_DETACH:OutputDebugString(TEXT("3. DLL_THREAD_DETACH\n"));break;case DLL_PROCESS_DETACH:OutputDebugString(TEXT("4. DLL_PROCESS_DETACH\n"));break;}return TRUE;
}// main.cpp
DWORD WINAPI ThreadProc(LPVOID lpThreadParameter) {HINSTANCE hModule = LoadLibrary(TEXT("动态库.dll"));return 0;
}int main() {// 动态加载 dll到内存中					HINSTANCE hModule = LoadLibrary(TEXT("动态库.dll"));// 获取函数地址// 调用函数// 创建新线程，加载 dllCreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);getchar();                      // 阻塞 main线程，让新线程执行// 释放动态链接库		FreeLibrary(hModule);return 0;
}

2、注入

（1）远程线程

1、线程

• 线程是附属在进程上的执行实体，是 代码的执行流程
• 代码必须通过线程才能执行

2、创建远程线程

• 函数原型

// 在别的进程中，创建新线程
HANDLE CreateRemoteThread(HANDLE hProcess,                                // 进程句柄LPSECURITY_ATTRIBUTES lpThreadAttributes,       // SDSIZE_T dwStackSize,                             // initial stack sizeLPTHREAD_START_ROUTINE lpStartAddress,          // thread functionLPVOID  lpParameter,                            // thread argumentDWORD   dwCreationFlags,                        // creation optionLPDWORD lpThreadId                              // thread identifier
);HANDLE OpenProcess(DWORD dwDesiredAccess,        // 访问权限BOOL  bInheritHandle,         // 是否继承DWORD dwProcessId             // 进程 id
);

• 代码示例

（1） 空项目.cpp

DWORD WINAPI ThreadProc(LPVOID lpThreadParameter) {for (int i = 0; i < 10; i++) {Sleep(1000);printf("fun-------------\n");}return 0;
}int main() {
// 创建 A线程，执行 ThreadProcHANDLE hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);CloseHandle(hThread);getchar();      // 阻塞 main线程return 0;
}

（2）远程线程.cpp

// 在 空项目.exe 中创建 B线程，执行 ThreadProc
#include <stdio.h>
#include <Windows.h>// dwProcessId：进程 id，要在哪个进程中创建线程
// dwProcAddr：线程需要执行的函数
BOOL MyCreateRemoteThread(DWORD dwProcessId, DWORD dwProcAddr) {
// 1.获取进程句柄HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);if (hProcess == NULL) {OutputDebugString(TEXT("获取进程句柄失败\n"));return FALSE;}// 2.创建远程线程DWORD dwThreadId = 0;HANDLE hThread = CreateRemoteThread(hProcess,NULL,0, (LPTHREAD_START_ROUTINE)dwProcAddr,NULL,0, &dwThreadId);if (hThread == NULL) {CloseHandle(hProcess);OutputDebugString(TEXT("创建远程线程失败\n"));return FALSE;}// 3.释放资源CloseHandle(hThread);CloseHandle(hProcess);return true;
}int main() {
/*1. 第一个参数：进程 id，通过任务管理器获取2. 第二个参数：需要提供 空项目.exe 中存在的线程函数的地址在 ThreadProc函数入口处下断点，通过反汇编代码查看函数的地址
*/MyCreateRemoteThread(39808, 0x891740);return 0;
}

3、总结

• 通过 CreateRemoteThread 函数，我们可以在其他进程中创建一个新线程，并调用该进程中包含的函数

（2）远程线程注入

1、什么是注入?

• 所谓注入就是在第三方进程不知道或者不允许的情况下将 模块 或者 代码 写入对方进程空间，并设法执行的技术
• 已知的注入方式：远程线程注入、APC注入、消息钩子注入、注册表注入、导入表注入、输入法注入等等

2、远程线程注入的流程

/*线程函数和 Dll 装载函数具有相同的形式：参数 4字节，返回值 4字节两者都可以作为线程函数，被线程执行
*/
DWORD WINAPI ThreadProc(LPVOID lpThreadParameter
)HMODULE LoadLibraryA(LPCSTR lpLibFileName
);

3、注入并执行代码

• 动态库.dll 的 DllMain 函数 （注入 dll 后，通过 DllMain 函数执行代码）

DWORD WINAPI ThreadProc(LPVOID lpThreadParameter) {while (true) {Sleep(1000);printf("动态库.dll 代码执行-------------\n");}return 0;
}// 当进程首次加载 dll，循环打印输出
// 执行 LoadLibrary 会调用 DllMain 函数
BOOL APIENTRY DllMain( HMODULE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
{switch (ul_reason_for_call){case DLL_PROCESS_ATTACH:CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);break;case DLL_THREAD_ATTACH:  break;case DLL_THREAD_DETACH:  break;case DLL_PROCESS_DETACH: break;}return TRUE;
}

• 空项目.exe 代码参考：（ 空项目.cpp）
• 远程线程注入代码

// 参数：进程 id、 dll的完整路径名
BOOL LoadDll(DWORD dwProcessId, const char* szDllPathName) {BOOL bRet;HANDLE hProcess, hThread;DWORD dwLength, dwLoadAddr;LPVOID lpAllocAddr, dwThreadId;HMODULE hModule;// 1.获取进程句柄hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);if (hProcess == NULL) {OutputDebugString(TEXT("获取进程句柄失败\n"));return FALSE;}// 2.计算 DLL路径名字长度，并且要加上 0结尾的长度dwLength = strlen(szDllPathName) + 1;// 3.在目标进程分配内存// 1. VirtualAlloc   只能在自己进程中申请内存// 2. VirtualAllocEx 可以在别的进程中申请分配内存lpAllocAddr = VirtualAllocEx(hProcess, NULL, dwLength, MEM_COMMIT, PAGE_READWRITE);if (lpAllocAddr == NULL) {CloseHandle(hProcess);OutputDebugString(TEXT("内存分配失败\n"));return FALSE;}// 4.拷贝 Dll到目标进程的内存空间bRet = WriteProcessMemory(hProcess, lpAllocAddr, szDllPathName, dwLength, NULL);if (!bRet) {CloseHandle(hProcess);OutputDebugString(TEXT("写入进程失败\n"));return FALSE;}// 5.获取模块地址hModule = GetModuleHandle(TEXT("kernel32.dll"));if (!hModule) {CloseHandle(hProcess);OutputDebugString(TEXT("获取模块地址失败\n"));return FALSE;}// 6.获取 LoadLibraryA 函数地址dwLoadAddr = (DWORD)GetProcAddress(hModule, "LoadLibraryA");if (!dwLoadAddr) {CloseHandle(hModule);CloseHandle(hProcess);OutputDebugString(TEXT("获取函数地址失败\n"));return FALSE;}// 7.创建远程线程，加载 dllhThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)dwLoadAddr, lpAllocAddr, 0, NULL);if (!hThread) {CloseHandle(hModule);CloseHandle(hProcess);OutputDebugString(TEXT("创建远程线程失败\n"));return FALSE;}// 8.关闭进程句柄CloseHandle(hProcess);return TRUE;
}int main() {LoadDll(9300,"D:\\VS2019\\动态库\\Debug\\动态库.dll");return 0;
}

• 使用 OD 查找 LoadLibraryA 函数的地址

1. LoadLibraryA 位于 kernel32.dll 中，任意一个 exe 的执行都需要包含这个 dll
2. 所以我们用OD打开 扫雷.exe，选择 E（Executable Modules），双击 kernel32.dll，使用 ctrl + N ，查看此 dll 包含的函数

（3）进程间的通信

1、通信方式

• 同一台电脑 两个进程的通信方式：管道、消息队列、信号量、共享内存 （本质上都是共享内存）
• 不同的电脑 两个进程的通信方式：套接字

2、共享内存的通信方式

• 模拟游戏.cpp

void Q() {printf("----- 斩钢闪 -------\n"); return;
}
void W() {printf("----- 风之障壁 -----\n"); return;
}
void E() {printf("----- 踏前斩 -------\n"); return;
}
void R() {printf("----- 狂风绝息斩 ---\n"); return;
}int main() {printf("----- 游戏开始 -----\n");while (true) {char c = getchar();switch (c) {case 'Q': Q(); break;case 'W': W(); break;case 'E': E(); break;case 'R': R(); break;}}return 0;
}

• 控制游戏.dll

#define _MAP_  "共享内存"
#define _Q_    0x6417A0
#define _W_    0x641860
#define _E_    0x641740
#define _R_    0x641800HANDLE g_hModule, g_hMapFile;
LPTSTR lpBuff;
DWORD dwType;DWORD WINAPI ThreadProc(LPVOID lpParameter) {g_hMapFile = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, TEXT(_MAP_));if (g_hMapFile == NULL) {printf("打开映射文件失败：%d\n", GetLastError());return 0;}// 映射内存lpBuff = (LPTSTR)MapViewOfFile(g_hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, BUFSIZ);while (true) {if (lpBuff != NULL) {// 读取数据CopyMemory(&dwType, lpBuff, 4);}if (dwType == 1) {_asm {mov eax,_Q_call eax}dwType = 0;  CopyMemory(lpBuff, &dwType, 4);}if (dwType == 2) {_asm {mov eax, _W_call eax}dwType = 0;  CopyMemory(lpBuff, &dwType, 4);}if (dwType == 3) {_asm {mov eax, _E_call eax}dwType = 0;  CopyMemory(lpBuff, &dwType, 4);}if (dwType == 4) {_asm {mov eax, _R_call eax}dwType = 0;  CopyMemory(lpBuff, &dwType, 4);}if (dwType == 5) {// 卸载自己并退出FreeLibraryAndExitThread((HMODULE)g_hModule, 0);}Sleep(500);}return 0;
}BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{g_hModule = hModule;switch (ul_reason_for_call){case DLL_PROCESS_ATTACH:CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);break;case DLL_THREAD_ATTACH:  break;case DLL_THREAD_DETACH:  break;case DLL_PROCESS_DETACH: break;}return TRUE;
}

• 注入dll.cpp

#include <stdio.h>
#include <Windows.h>
#include <TlHelp32.h>
#define _MAP_ "共享内存"HANDLE g_hMapFile;
LPTSTR lpBuff;// 参数：进程 id、 dll的完整路径名
BOOL LoadDll(DWORD dwProcessId, const char* szDllPathName) {// 代码参考：远程线程注入
}BOOL init() {// 创建事件、创建共享内存g_hMapFile = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 0x1000, TEXT(_MAP_));if (g_hMapFile == NULL) {printf("创建映射文件失败\n");return FALSE;}// 映射内存lpBuff = (LPTSTR)MapViewOfFile(g_hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, BUFSIZ);if (lpBuff == NULL) {printf("关联文件失败\n");return FALSE;}return TRUE;
}DWORD GetPid(CONST WCHAR* szName) {HANDLE hProcessSnap = NULL;PROCESSENTRY32 pe32 = { 0 };hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);if (hProcessSnap == (HANDLE)-1) {return 0;}pe32.dwSize = sizeof(PROCESSENTRY32);if(Process32First(hProcessSnap,&pe32)) {do {if (!wcscmp(szName, pe32.szExeFile)) {return (int)pe32.th32ProcessID;}} while (Process32Next(hProcessSnap, &pe32));}elseCloseHandle(hProcessSnap);return 0;
}int main() {DWORD dwCtrlCode, dwOrdeList[10];// 1.初始化 2.注入 DLLif(init())LoadDll(GetPid(L"模拟游戏.exe"), "D:\\VS2019\\游戏控制\\Debug\\游戏控制.dll");// 3.命令队列dwOrdeList[0] = 1;  dwOrdeList[1] = 1;  dwOrdeList[2] = 2;dwOrdeList[3] = 2;  dwOrdeList[4] = 3;  dwOrdeList[5] = 3;dwOrdeList[6] = 4;  dwOrdeList[7] = 4;  dwOrdeList[8] = 4;  dwOrdeList[9] = 5;for (int i = 0; i < 10; i++) {dwCtrlCode = dwOrdeList[i];CopyMemory(lpBuff, &dwCtrlCode, 4);Sleep(1000);}return 0;
}

• FreeLibrary                                     卸载某个某块，不能卸载自己
• FreeLibraryAndExitThread            卸载模块，可以卸载自己

（4）模块隐藏

1、TEB 和 PEB

• TEB（Thread Environment Block ），它记录的相关线程的信息，每一个线程都有自己的TEB，FS:[0] 即是当前线程的TEB
• PEB（Process Environment Block，进程环境块）存放进程信息，每个进程都有自己的PEB，TEB偏移 0x30 即当前进程的PEB
• TEB 与 PEB 都在用户空间（用户层结构体）

2、获取 TEB 结构体的步骤

（1）用 OD 打开 扫雷.exe，打开后会在 winmine.exe 模块 处发生中断，此时 TEB的地址存储在 FS 寄存器

（2）使用 dd 命令跳转到对应的内存地址，该地址存储着当前线程的 TEB 对象

（3）TEB 结构体图解

续：

（4）在OD中解析 TEB 结构体：双击入口地址，查看内存的相对偏移量

（4）使用代码获取 TEB 首地址

// 使用汇编代码，将首地址存入 eax中mov eax,fs:[0]

3、获取 PEB 结构体的步骤

（1）TEB 结构体首地址偏移 0x30 的内存地址，存放着 PEB 的首地址

（2）在 OD 中右键此地址，Fllow in Dump 找到 PEB 的首地址（和 dd 命令效果相同）

（3）win32API 可以遍历当前进程所有的模块，实际上这些 API查询的是 PEB的 Ldr 成员

（4）在 PEB 结构体首地址偏移 0x0C 的内存地址，Fllow in Dump，找到 _PEB_LDR_DATA 结构体

（5）在 _PEB_LDR_DATA 结构体的 0x0C 偏移处，Fllow in Dump，找到 _LDR_DATA_TABLE_ENTRY 结构体

（6）结构体图解

• PEB 和 _PEB_LDR_DATA

• PEB续

• _LDR_DATA_TABLE_ENTRY

（7）使用代码获取 PEB

mov eax,fs:[0x30]mov PEB,eax

4、代码示例

// 通过断链的方式，可以使通过 Win32API 查询模块的方式失效
typedef struct _UNICODE_STRING {USHORT Length;USHORT MaximumLength;PWSTR  Buffer;
} UNICODE_STRING,*PUNICODE_STRING;typedef struct _PEB_LDR_DATA {ULONG       Length;BOOLEAN     Initialized;PVOID       SsHandle;LIST_ENTRY  InLoadOrderModuleList;LIST_ENTRY  InMemoryOrderModuleList;LIST_ENTRY  InInitializationOrderModuleList;
} PEB_LDR_DATA, *PPEB_LDR_DATA;typedef struct _LDR_DATA_TABLE_ENTRY {LIST_ENTRY		InLoadOrderModuleList;LIST_ENTRY		InMemoryOrderModuleList;LIST_ENTRY		InInitializationOrderModuleList;void*			BaseAddress;				// 模块的句柄void*		    EntryPoint;ULONG           SizeOfImage;UNICODE_STRING  FullDllName;UNICODE_STRING  BaseDllName;ULONG           Flags;SHORT           LoadCount;SHORT           TlsIndex;HANDLE          SectionHandle;ULONG           CheckSum;ULONG           TimeBaseStamp;
} LDR_MODULE, *PLDR_MODULE;void HideModule(CONST WCHAR* szModuleName) {HMODULE hMod = ::GetModuleHandle(szModuleName);PLIST_ENTRY Head, Cur;		// 双链表PPEB_LDR_DATA ldr;PLDR_MODULE ldm;_asm {mov eax, fs:[0x30]mov ecx, [eax+0x0c]mov ldr, ecx}Head = &(ldr->InLoadOrderModuleList);Cur = Head->Flink;do {// 宏 CONTAINING_RECORD 根据结构体中的某成员的地址来推算处该结构体整体的地址ldm = CONTAINING_RECORD(Cur, LDR_MODULE, InLoadOrderModuleList);if (hMod == ldm->BaseAddress) {// 双向链表断链ldm->InLoadOrderModuleList.Blink->Flink = ldm->InLoadOrderModuleList.Flink;ldm->InLoadOrderModuleList.Flink->Blink = ldm->InLoadOrderModuleList.Blink;ldm->InInitializationOrderModuleList.Blink->Flink = ldm->InInitializationOrderModuleList.Flink;ldm->InInitializationOrderModuleList.Flink->Blink = ldm->InInitializationOrderModuleList.Blink;ldm->InMemoryOrderModuleList.Blink->Flink = ldm->InMemoryOrderModuleList.Flink;ldm->InMemoryOrderModuleList.Flink->Blink = ldm->InMemoryOrderModuleList.Blink;break;}Cur = Cur->Flink;} while (Head != Cur);
}int main() {printf("按任意键隐藏模块\n");getchar();HideModule(L"kernel32.dll");printf("隐藏已模块\n");getchar();return 0;
}

5、内核层 —— VAD树

• 遍历 VAD树（是一棵搜索二叉树），可以查询当前进程虚拟内存占用情况
• VAD树 每个成员都是一个结构体，其中包含指针成员指向 dll 的名称
• 把指针置空，VAD树 遍历也无法找到对应的 dll

6、模块隐藏之 PE指纹

• 任何模块都有 PE 指纹

1. 先找前2个字节，对应的值是 MZ
2. 在找第 64个字节，对应的值为 D8
3. 再找第 0xD8 个字节，对应的值为 PE，这就是一个 PE指纹，说明该内存地址中存放着一个模块

• 通过 PE指纹找模块

1. 遍历程序内存，如果找到 MZ 字符，则加上第64字节存放的偏移量
2. 在对应偏移处存放的是 PE 字符，则说明该处存放着一个模块
3. 将 PE指纹 置0，可监控 LoadLibrary 函数的调用，仍能发现模块的载入

7、最好的隐藏：代码注入

（5）代码注入

1、代码注入的思路

• 将自己定义的函数复制到进程内存空间

• 复制到目标进程的内容

将想要执行函数的 机器码 复制到目标进程的内存空间

• 复制代码的编写原则

// 不能有全局变量int g;int Fun(int x.int y){g = 1;C7 05 38 A1 46 00 01       mov  dword ptr [g (046A138h)],1return x+y;}// 不能使用常量字符串int Fun(int x.int y){char* c = (char*)"china";C7 45 F8 D0 7B E9 00       mov  dword ptr [c],offset string "china" (0E97BD0h)return x+y;}// 不能使用系统调用（ Win32API ）// 导入表 会告诉编译器 MessageBox 的地址，在目标进程的导入表中 MessageBox 可能不存在int Fun(int x.int y){MessageBox(0,0,0,0);8B F4                mov       esi,esp  6A 00                push      0  6A 00                push      0  6A 00                push      0  6A 00                push      0  FF 15 98 B0 34 00    call      dword ptr [__imp__MessageBoxW@16 (034B098h)]  3B F4                cmp       esi,esp  E8 D8 FA FF FF       call      __RTC_CheckEsp (0341217h)return x+y;}// 不能嵌套调用其他函数int Fun(int x, int y) {Test();// E8 52 FC FF FF       call      Test (042137Fh)return x + y;}

2、向目标进程复制函数，并传递参数

3、代码示例

#include <stdio.h>
#include <Windows.h>typedef struct {// CreateFile 函数的地址DWORD   dwCreateAPIAddr;// CreateFile 函数的参数LPCSTR  lpFileName;DWORD   dwDesireAccess;DWORD   daShareMode;LPSECURITY_ATTRIBUTES lpSecurityAttributes;DWORD   dwCreationDispositon;DWORD   dwFlagsAndAttributes;HANDLE  hTemplateFile;
} CREATEFILE_PARAM;// CreateFile的函数指针
typedef HANDLE(WINAPI* PFN_CreateFile)(LPCSTR  lpFileName,DWORD   dwDesireAccess,DWORD   daShareMode,LPSECURITY_ATTRIBUTES lpSecurityAttributes,DWORD   dwCreationDispositon,DWORD   dwFlagsAndAttributes,HANDLE  hTemplateFile
);// 要复制到目标进程的函数，参数：结构体指针
DWORD _stdcall CreateFileThreadProc(LPVOID lParam) {CREATEFILE_PARAM* Gcreate = (CREATEFILE_PARAM*)lParam;// 获取 CreateFile函数地址PFN_CreateFile pfnCreateFile= (PFN_CreateFile)Gcreate->dwCreateAPIAddr;pfnCreateFile(Gcreate->lpFileName,Gcreate->dwDesireAccess,Gcreate->daShareMode,Gcreate->lpSecurityAttributes,Gcreate->dwCreationDispositon,Gcreate->dwFlagsAndAttributes,Gcreate->hTemplateFile);return 0;
}// 远程创建文件
BOOL RemotCreateFile(DWORD dwProcessID, char* szFilePathName) {BOOL     bRet = 0;DWORD    dwThread;HANDLE   hProcess = 0;HANDLE   hThread;DWORD    dwThreadFunSize = 0x400;CREATEFILE_PARAM GCreateFile;LPVOID   lpFilePathName;LPVOID   lpRemotThreadAddr;LPVOID   lpFileParamAddr;DWORD    dwFunAddr;HMODULE  hModule;// 1.获取进程句柄hProcess = OpenProcess(PROCESS_AFFINITY_ENABLE_AUTO_UPDATE, FALSE, dwProcessID);if (hProcess == NULL)    return FALSE;// 2.分配3段内存：存储参数、线程函数、文件// 2.1用来存储文件名lpFilePathName = VirtualAllocEx(hProcess, NULL, strlen(szFilePathName) + 1, MEM_COMMIT, PAGE_READWRITE);// 2.2用来存储线程函数lpRemotThreadAddr = VirtualAllocEx(hProcess, NULL, dwThreadFunSize, MEM_COMMIT, PAGE_READWRITE);// 2.3用来存储参数lpFileParamAddr = VirtualAllocEx(hProcess, NULL, sizeof(CREATEFILE_PARAM), MEM_COMMIT, PAGE_READWRITE);// 3.初始化 CreateFile 参数GCreateFile.dwDesireAccess = GENERIC_READ | GENERIC_WRITE;GCreateFile.daShareMode = 0;GCreateFile.lpSecurityAttributes = NULL;GCreateFile.dwCreationDispositon = OPEN_ALWAYS;GCreateFile.dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;GCreateFile.hTemplateFile = NULL;// 4.获取 CreateFile 函数地址hModule = LoadLibrary(TEXT("kernel32.dll"));GCreateFile.dwCreateAPIAddr = (DWORD)GetProcAddress(hModule, "CreaeteFileA");FreeLibrary(hModule);// 5.初始化 CreateFile 文件名，文件名存储在目标进程的内存空间GCreateFile.lpFileName = (LPSTR)lpFilePathName;// 6.修正线程函数起始地址// 6.1在 main中调用的函数地址，与真正的函数地址有一个 jmp 指令dwFunAddr = (DWORD)CreateFileThreadProc;if (*(BYTE*)dwFunAddr == 0xE9) {dwFunAddr = dwFunAddr + 5 + *(DWORD*)(dwFunAddr + 1);}// 7.开始复制// 7.1拷贝文件名WriteProcessMemory(hProcess, lpFilePathName, szFilePathName, strlen(szFilePathName) + 1, 0);// 7.2拷贝线程函数WriteProcessMemory(hProcess, lpRemotThreadAddr, (LPVOID)dwFunAddr, dwThreadFunSize, 0);// 7.3拷贝线程参数WriteProcessMemory(hProcess, lpFileParamAddr, &GCreateFile, sizeof(CREATEFILE_PARAM), 0);// 8.创建远程线程hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)lpRemotThreadAddr,lpFileParamAddr, 0, &dwThread);// 9.关闭进程句柄CloseHandle(hProcess);return TRUE;
}int main() {// 目标进程创建文件后，要等待目标进程关闭，创建的文件才能删除RemotCreateFile(160, (char*)"D:\\a.txt");return 0;
}

4、修正线程函数起始地址

void Test(){
// 此处才是真实的函数地址，所以要进行修正000A1700   55                   push        ebp  000A1701   8B EC                mov         ebp,esp  000A1703   81 EC C0 00 00 00    sub         esp,0C0h  000A1709   53                   push        ebx  000A170A   56                   push        esi  000A170B   57                   push        edi  000A170C   8D BD 40 FF FF FF    lea         edi,[ebp-0C0h]  000A1712   B9 30 00 00 00       mov         ecx,30h  000A1717   B8 CC CC CC CC       mov         eax,0CCCCCCCCh  000A171C   F3 AB                rep stos    dword ptr es:[edi]  000A171E   B9 15 C0 0A 00       mov         ecx,offset _43B7F706_源@cpp (0AC015h)  000A1723   E8 E0 FA FF FF       call        @__CheckForDebuggerJustMyCode@4 (0A1208h)return;  000A1728   5F                   pop         edi  000A1729   5E                   pop         esi  000A172A   5B                   pop         ebx  000A172B   81 C4 C0 00 00 00    add         esp,0C0h  000A1731   3B EC                cmp         ebp,esp  000A1733   E8 DF FA FF FF       call        __RTC_CheckEsp (0A1217h)  000A1738   8B E5                mov         esp,ebp  000A173A   5D                   pop         ebp  000A173B   C3                   ret  
}int main() {Test();000A1768    E8 12 FC FF FF       call   Fun (0A137Fh)    
/*call 与真实的函数地址之间还有一个 jmp指令，E9是 jmp，7C是相对偏移000A137F    E9 7C 03 00 00       jmp    Test (0A1700h)000A1384 + 037C = 000A1700    
*/return 0;
}