PEB-动态解析API
PEB-动态解析API
一、PEB简介
基本概念
- PEB(Process Environment Block,进程环境块)是Windows操作系统在用户态为每个进程分配的一块内存结构(结构体),包含了进程运行时的各种关键全局信息
- 内核(Ring0)是公司的高管,用户态(Ring 3)是部门的普通员工
- 高管需要管理各个部门,了解部门的状态,比如:部门路径在哪?加载了哪些资源?有没有被审查/调试?
- 为了方便高管和员工之间共享这些信息,Windows为每个部门建立了一个部门信息档案,这个档案存放在用户态(Ring 3),它就是PEB

- 和PEB关系最密切的是TEB
- TEB:Thread Environment Block,线程环境块,每个线程一份
- PEB:进程环境块,每个进程一份
- 线程通过TEB指向所属进程的PEB
线程 Thread
↓
TEB(线程块,线程私有)
↓
PEB(进程块,整个进程共用)
↓
Ldr(加载器数据)
↓
已加载模块链表(exe、dll 列表)作用
- 正常写业务代码时,不需要知道PEB,因为操作系统API(如:
GetModuleHandle,IsDebuggerPresent)已经在底层帮封装好了 - 而动态解析API时就需要用到PEB:通过PEB,可以在没有任何系统API帮助的情况下,手工在内存中找出系统DLL,并解析出需要的函数地址
PEB中有什么
- 进程参数:这些信息通常在
ProcessParameters里,例如:
命令行
当前目录
环境变量
窗口标志
标准输入输出句柄等
- 加载器信息:最重要的是
Ldr,它指向PEB_LDR_DATA,里面有:
InLoadOrderModuleList(按加载顺序排列的模块链表):它记录了模块被操作系统映射进内存的先后时间顺序,也就是进程启动或运行过程中,DLL 被加载进来的先后顺序。在这个链表中,第一个节点永远是程序自身的主模块(EXE文件),紧接着的通常是底层的ntdll.dll,然后是提供基础API的kernel32.dll/kernelbase.dll(exe → ntdll → kernel32 → 其他DLL)InMemoryOrderModuleList(按内存顺序排列的模块链表):它原本的设计初衷是按模块在内存中的基地址高低来排序,但在现代Windows系统中,它的实际顺序已经与加载顺序几乎一致InInitializationOrderModuleList(按初始化顺序排列的模块链表):它记录的是模块真正开始执行初始化代码(调用入口点/DllMain)的先后顺序,也就是说,这个顺序反映的是DLL被“执行初始化代码”的先后,而不是单纯加载顺序。与前两个链表最关键的不同点在于,主程序(EXE)本身通常不会排在这个链表的头部,因为它必须等所有依赖的底层DLL都初始化完毕后才会执行自己的代码,因此这个链表排在第一位的通常直接就是ntdll.dll(万物之源,必须最先初始化),紧接着就是kernel32/kernelbase.dll


重要性
- 系统启动进程时会初始化PEB:进程一创建,Windows loader会构造PEB,并把
exe、ntdll、kernel32/KernelBase等模块信息写进去 - PEB是已加载模块的入口:如果想知道当前进程加载了哪些 DLL,最原始的入口就是PEB里的模块链表
- 常用于动态解析API:不依赖导入表IAT,从PEB找到DLL基址,再手工解析导出表,拿到函数地址
二、访问PEB
- 常见做法是从TEB找PEB,不同位数获取方式不同
- x86:在x86下,
FS段寄存器指向TEB,0x30位置通常能拿到PEB
PEB* peb = (PEB*)__readfsdword(0x30);- x64:在x64下,
GS段寄存器对应TEB,0x60位置通常是PEB指针
PEB* peb = (PEB*)__readgsqword(0x60);三、 使用PEB动态解析API
基本原理(windbg演示)
找DLL:获取kernel32.dll的基址
- 获取TEB(
GS:[0x60])
// 获取TEB地址
!teb
- 获取PEB(TEB偏移处)
// 通过TEB获取PEB地址
dq <TEB地址>+0x60 L1
dq 000000042a0fe000+0x60 L1
// 也可以直接打印PEB地址
r $peb
- 找到PEB中的Ldr字段 (指向
PEB_LDR_DATA结构),Ldr里面有三个双向链表,记录了加载的DLL,通常用InMemoryOrderModuleList(按内存加载顺序排序的链表)
// 查看PEB+0x18处的值,即Ldr地址
dq <PEB地址>+0x18 L1
dq 000000042a0ef000+0x18 L1
//查看Ldr+0x20处的值,即InMemoryOrderModuleList的链表头地址
dq <Ldr地址>+0x20 L1
dq 00007ffd602dc4c0+0x20 L1
- 遍历这个链表,拿到
kernel32.dll在内存中的基地址,正常情况下,Windows进程加载DLL的顺序是:
- 第1个:程序自己的EXE
- 第2个:
ntdll.dll - 第3个:
kernel32.dll(要找的就是它)
// 获取第一个条目地址
dq <链表头地址> L1
dq 000001403a3d2920 L1
// 解析结构体:输出中看FullDllName字段,它会显示字符串地址和内容,如果不是kernel32,找下一个
dt ntdll!_LDR_DATA_TABLE_ENTRY (第一个条目地址 - 0x10)
dt ntdll!_LDR_DATA_TABLE_ENTRY (000001403a3d2790 - 0x10)
// 获取第二个条目地址
dq 000001403a3d2790 L1
// 解析结构体:输出中看FullDllName字段,它会显示字符串地址和内容,如果不是kernel32,找下一个
dt ntdll!_LDR_DATA_TABLE_ENTRY (000001403a3d2de0 - 0x10)

找API:解析PE文件的导出表
- 既然拿到了
kernel32.dll在内存中的基址,这其实就是一个完整的PE文件 - 解析DOS头(
IMAGE_DOS_HEADER),找到NT头 (IMAGE_NT_HEADERS)
// 查看DOS头前两个字节,应该是MZ(5A4D)
dw <kernel32.dll基址> L1
dw 0x00007ffd5fed0000 L1
// 获取NT头偏移(e_lfanew位于DOS头 + 0x3C)
dd <kernel32.dll基址 + 0x3c> L1
dd 0x00007ffd5fed0000+0x3c L1
- 在NT头的数据目录表(Data Directory)中找到 导出表(Export Directory)
- 导出表位于数据目录的第0项,64位PE结构如下:
Optional Header起始于NT头 + 0x18DataDirectory起始于Optional Header + 0x70(即NT头 + 0x88)- 导出表RVA在
DataDirectory的第一个QWORD
// NT头地址
NT头地址 = 基址 + NT头偏移
// 查看 DataDirectory[0] 的RVA 和 Size
// dd 基址+ NT头偏移 + 0x88 L2
dd 0x00007ffd5fed0000 + 0xF8 + 0x88 L2
// 导出表在内存中的地址 = kernel32.dll基址 + RVA
0x00007ffd5fed0000 + 0009d2d0 = 0x00007ffd5ff6d2d0
- 导出表里有三个核心数组:
- 函数名数组(AddressOfNames):存着
LoadLibraryA,、GetProcAddress等名字 - 函数地址数组(AddressOfFunctions):存着函数真正的内存地址(偏移)
- 序号数组 (AddressOfNameOrdinals):负责把名字和地址对应起来
- 遍历函数名数组,对比字符串,如果找到了
GetProcAddress,通过序号数组找到它在函数地址数组中的索引,最终算出函数真正的内存地址
// 获取三个数组的 RVA
dd 导出表在内存中的地址 + 对应偏移 L1
dd 0x00007ffd5ff6d2d0 + 0x1c L1 // AddressOfFunctions RVA
dd 0x00007ffd5ff6d2d0 + 0x20 L1 // AddressOfNames RVA
dd 0x00007ffd5ff6d2d0 + 0x24 L1 // AddressOfNameOrdinals RVA数组名称 | 偏移 | RVA | 真实内存地址 (基址+RVA) |
AddressOfFunctions |
|
|
|
AddressOfNames |
|
|
|
AddressOfNameOrdinals |
|
|
|
// 先查看前20个名称的RVA,此时会得到一堆RVA数值
dd AddressOfNames的真实内存地址 L20
dd 0x00007ffd5ff6ec88 L20
// 验证这些 RVA 指向的字符串,找到GetProcAddress(第一个RVA不是就看下一个,找到为止),找到后记住索引(第几个)
da kernel32.dll基址 + RVA
da 0x00007ffd5fed0000 + 0x000a57dd
// 快速方法
// 在AddressOfNames找到GetProcAddress,此时会找到GetProcAddress在当前内存中的绝对地址(基址 + RVA)
s -a kernel32.dll基址 L?告诉WinDbg从起点开始往后扫描的字节数 "GetProcAddress"
s -a 00007ffd5fed0000 L?0x120000 "GetProcAddress"
// 算出RVA
RVA = GetProcAddress在当前内存中的绝对地址 - kernel32.dll基址
RVA = 0x00007ffd5ff757dd - 0x00007ffd5fed0000 = 0x000a57dd
// 找到GetProcAddress的索引
.foreach (hit { s -[1]d AddressOfNames的真实内存地址 L?向后扫描字节的字节数 RVA }) { ? (${hit} - AddressOfNames的真实内存地址) / 4 }
.foreach (hit { s -[1]d 0x00007ffd5ff6ec88 L?0x2000 0x000a57dd }) { ? (${hit} - 0x00007ffd5ff6ec88) / 4 }
// 序号地址 = AddressOfNameOrdinals基址 + (索引 * 2)
// 索引=0x2B8,则偏移为0x2B8 * 2 = 0x570
// 使用dw查看,会得到一个数字,这就是序号
dw AddressOfNameOrdinals的真实内存地址 + 偏移
dw 0x00007ffd5ff70618 + 0x570 L1
// 现在去AddressOfFunctions中,利用刚才拿到的序号作为索引,取出GetProcAddress的RVA
// 函数地址RVA = AddressOfFunctions基址 + (序号 * 4)
// 序号是0x02b8,则偏移为0x02b8 * 4 = 0x0AE0
dd AddressOfFunctions真实内存地址 + 偏移
dd 0x00007ffd5ff6d2f8 + 0x0AE0 L1
// 最后,kernel32.dll基址 + 得到的RVA,就是GetProcAddress在内存中的真实地址
u kernel32.dll基址 得到的RVA
u 0x00007ffd5fed0000 + 0x1b200
四、代码实现
- 代码逻辑
程序启动
↓
main()
程序入口,开始执行解析 API 的整体流程
↓
GetKernel32Base()
自定义函数:不调用 GetModuleHandle,直接从进程内部结构中寻找 kernel32.dll
↓
__readgsqword(0x60)
从 GS:[0x60] 读取当前进程的 PEB 地址
↓
PEB
进程环境块,保存模块加载等关键信息
↓
PEB->Ldr
从 PEB 中取出加载器数据结构 PEB_LDR_DATA
↓
PEB_LDR_DATA
保存了进程已加载模块的多个链表
↓
InMemoryOrderModuleList
链表结构:获取按内存顺序组织的模块双向链表
↓
EXE
第一个节点,通常是当前程序本身
↓
ntdll.dll
第二个节点,通常是 ntdll.dll
↓
kernel32.dll
第三个节点,通常是 kernel32.dll
↓
LDR_DATA_TABLE_ENTRY->DllBase
从模块项中取出 kernel32.dll 的加载基址
↓
kernel32.dll 基址
后续据此解析 PE 导出表
↓
常规方式:GetProcAddress(kernel32, "LoadLibraryA")
系统函数,仅作对比:一般情况下可以用它直接获取函数地址
↓
本程序未调用系统 GetProcAddress
为了演示底层原理,改为手工解析导出表
↓
MyGetProcAddress(kernel32, "LoadLibraryA")
自定义函数,自实现 GetProcAddress 功能:手工解析 kernel32.dll 导出表,查找 LoadLibraryA
↓
DOS Header -> NT Headers
手工解析 PE 结构:验证模块是合法 PE 文件,并定位 NT 头
↓
Export Directory
PE 导出表结构:获取导出表目录
↓
AddressOfNames / AddressOfNameOrdinals / AddressOfFunctions
PE 导出表数据:获取函数名表、序号表、函数地址表
↓
遍历导出名并匹配 LoadLibraryA
逐个比较导出函数名
↓
得到 LoadLibraryA 地址
动态解析得到的系统函数地址:LoadLibraryA 本体是系统函数,但地址由程序手工解析获得
↓
LoadLibraryA("user32.dll")
动态加载 user32.dll
↓
user32.dll 基址
返回 user32.dll 在当前进程中的模块基址
↓
常规方式:GetProcAddress(user32, "MessageBoxA")
系统函数,仅作对比说明:一般情况下可以用它直接获取 MessageBoxA 地址
↓
本程序未调用系统 GetProcAddress
而是继续使用自定义函数手工解析导出表
↓
MyGetProcAddress(user32, "MessageBoxA")
自定义函数,自实现 GetProcAddress:再次手工解析 user32.dll 导出表
↓
解析 user32.dll 导出表
重复解析 DOS 头、NT 头和导出表
↓
匹配 MessageBoxA
在名称表中找到目标函数
↓
动态解析得到 MessageBoxA 地址
MessageBoxA 是系统函数,但地址由程序手工解析获得
↓
MessageBoxA(NULL, "PEB动态解析API成功", "PEB", MB_OK)
调用解析出的函数,弹出对话框验证成功
↓
结束:程序正常返回- 详细代码
#include <windows.h>
#include <iostream>
// --- 通过 PEB 寻找 Kernel32.dll 的基址 ---
HMODULE GetKernel32Base() {
// 1. 获取 PEB 地址 (x64)
ULONG_PTR peb = __readgsqword(0x60);
// 2. 获取 PEB_LDR_DATA (PEB 偏移 0x18)
ULONG_PTR ldr = *(ULONG_PTR*)(peb + 0x18);
// 3. 获取 InMemoryOrderModuleList 链表头 (LDR 偏移 0x20)
// 链表的节点结构是 LDR_DATA_TABLE_ENTRY
LIST_ENTRY* moduleList = (LIST_ENTRY*)(ldr + 0x20);
// 4. 遍历链表
LIST_ENTRY* currentModule = moduleList->Flink; // 指向第一个模块 (通常是自己EXE)
// 正常的加载顺序:1. EXE 2. ntdll.dll 3. kernel32.dll
// 所以往后跳两次
currentModule = currentModule->Flink; // 现在指向 ntdll.dll
currentModule = currentModule->Flink; // 现在指向 kernel32.dll
// 5. 获取 kernel32.dll 的基址
// 当前指针指向的是 LDR_DATA_TABLE_ENTRY 中的 InMemoryOrderLinks 字段
// 在 x64 下,DllBase 在 LDR_DATA_TABLE_ENTRY 结构的首地址偏移 0x30 处
// 因为 InMemoryOrderLinks 本身在偏移 0x10 处,所以 DllBase 相对于当前指针的偏移是 0x20
HMODULE kernel32Base = (HMODULE)(*(ULONG_PTR*)((BYTE*)currentModule + 0x20));
return kernel32Base;
}
// --- 手工解析 PE 导出表,自实现 GetProcAddress ---
FARPROC MyGetProcAddress(HMODULE moduleBase, const char* functionName) {
// 把模块基址转成 BYTE* 方便加减偏移
BYTE* base = (BYTE*)moduleBase;
// 1. 获取 DOS 头
IMAGE_DOS_HEADER* dosHeader = (IMAGE_DOS_HEADER*)base;
if (dosHeader->e_magic != IMAGE_DOS_SIGNATURE) return NULL; // 不是 'MZ'
// 2. 获取 NT 头
IMAGE_NT_HEADERS* ntHeaders = (IMAGE_NT_HEADERS*)(base + dosHeader->e_lfanew);
if (ntHeaders->Signature != IMAGE_NT_SIGNATURE) return NULL; // 不是 'PE\0\0'
// 3. 获取数据目录表中的导出表目录
IMAGE_DATA_DIRECTORY exportDir = ntHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
if (exportDir.Size == 0) return NULL; // 没有导出表
// 4. 定位到真正的导出表结构
IMAGE_EXPORT_DIRECTORY* exportTable = (IMAGE_EXPORT_DIRECTORY*)(base + exportDir.VirtualAddress);
// 5. 获取导出表的三个关键数组 (它们存的都是RVA,也就是相对虚拟地址,需要加上模块基址)
DWORD* addressOfNames = (DWORD*)(base + exportTable->AddressOfNames);
WORD* addressOfNameOrdinals = (WORD*)(base + exportTable->AddressOfNameOrdinals);
DWORD* addressOfFunctions = (DWORD*)(base + exportTable->AddressOfFunctions);
// 6. 遍历名称数组,寻找目标函数
for (DWORD i = 0; i < exportTable->NumberOfNames; ++i) {
// 获取当前遍历到的函数名
char* currentFuncName = (char*)(base + addressOfNames[i]);
// 对比字符串是否相等 (手工实现简单的 strcmp)
int j = 0;
while (functionName[j] != '\0' && currentFuncName[j] != '\0' && functionName[j] == currentFuncName[j]) {
j++;
}
// 如果完全匹配
if (functionName[j] == '\0' && currentFuncName[j] == '\0') {
// 找到了!通过名称序号数组(Ordinals)找到真正的函数地址索引
WORD ordinal = addressOfNameOrdinals[i];
// 计算函数的绝对内存地址
FARPROC functionAddress = (FARPROC)(base + addressOfFunctions[ordinal]);
return functionAddress;
}
}
return NULL;
}
// --- 测试结果 ---
int main() {
// 1. 无需调用任何系统API,获取 kernel32.dll 基址
HMODULE hKernel32 = GetKernel32Base();
std::cout << "Kernel32 Base Address: " << hKernel32 << std::endl;
// 2. 无需调用 GetProcAddress,手工解析导出表获取 LoadLibraryA 的地址
// 定义 LoadLibraryA 的函数指针类型
typedef HMODULE(WINAPI* PFN_LoadLibraryA)(LPCSTR);
PFN_LoadLibraryA myLoadLibraryA = (PFN_LoadLibraryA)MyGetProcAddress(hKernel32, "LoadLibraryA");
std::cout << "LoadLibraryA Address: " << (void*)myLoadLibraryA << std::endl;
// 3. 测试解析出来的函数能不能正常工作
if (myLoadLibraryA) {
// 动态加载 user32.dll
HMODULE hUser32 = myLoadLibraryA("user32.dll");
// 再用自己的解析函数找出 MessageBoxA
typedef int(WINAPI* PFN_MessageBoxA)(HWND, LPCSTR, LPCSTR, UINT);
PFN_MessageBoxA myMessageBoxA = (PFN_MessageBoxA)MyGetProcAddress(hUser32, "MessageBoxA");
if (myMessageBoxA) {
// 弹出对话框
myMessageBoxA(NULL, "PEB动态解析API成功", "PEB", MB_OK);
}
}
return 0;
}