2.10 PE结构：重建重定位表结构

Relocation（重定位）是一种将程序中的一些地址修正为运行时可用的实际地址的机制。在程序编译过程中，由于程序中使用了各种全局变量和函数，这些变量和函数的地址还没有确定，因此它们的地址只能暂时使用一个相对地址。当程序被加载到内存中运行时，这些相对地址需要被修正为实际的绝对地址，这个过程就是重定位。
在Windows操作系统中，程序被加载到内存中运行时，需要将程序中的各种内存地址进行重定位，以使程序能够正确地运行。Windows系统使用PE（Portable Executable）文件格式来存储可执行程序，其中包括重定位信息。当程序被加载到内存中时，系统会解析这些重定位信息，并将程序中的各种内存地址进行重定位。
重定位表一般出现在DLL中，因为DLL都是动态加载，所以地址不固定，DLL的入口点在整个执行过程中至少要执行2次，一次是在开始时执行初始化工作，一次则是在结束时做最后的收尾工作，重定位表则是解决DLL的地址问题，为了能找到重定位表首先我们需要使用PeView工具查询DataDirectory数据目录表，在其中找到Base relocation字段，里面的0x00001800则是重定位表基地址；

我们通过使用WinHex工具定位到0x00001800即可看到重定位表信息，如下图中的1000代表的是重定位RVA地址，绿色的0104代表的则是重定位块的长度，后面则是每两个字节代表一个重定位块，0A是重定位地址，30则是重定位的类型，以此顺序向下排列。

重定位表也是分页排列的，每一页大小都是1000字节，通过使用FixRelocPage命令即可查询到当前程序中的重定位块信息，并以第一个为例，查询一下起始地址RVA为1000的页上，有哪些重定位结构，如下图所示；

其中的重定位RVA地址0000100A是用标黄色的1000加上标蓝色的0xA得到的。而修正RVA地址00003000加上模块基地址63FF0000+3000得到的则是第一个被修正的内存地址，读者可使用x64dbg跳转到该程序内自行确认。
重定位表的修复原理与IAT修复完全一致，我们需要分别读入脱壳前与脱壳后的两个程序，接着通过循环正确的重定位表信息，并依次覆盖到脱壳后的程序内，以此实现对重定位表的修复功能，实现代码如下所示；

1. #include <windows.h>
2. #include <stdio.h>
4. struct TypeOffset
5. {
6.   WORD Offset : 12;       // 低12位代表重定位地址
7.   WORD Type : 4;          // 高4位代表重定位类型
8. };
10. DWORD FileSize = 0;  // 定义文件大小
11. DWORD FileBase = 0;  // 保存文件的基地址
13. // 定义全局变量,来存储DOS,NT,Section头
14. PIMAGE_DOS_HEADER DosHeader = nullptr;
15. PIMAGE_NT_HEADERS NtHeader = nullptr;
16. PIMAGE_FILE_HEADER FileHead = nullptr;
18. // 将RVA转换为FOA的函数
19. DWORD RVAtoFOA(DWORD rva)
20. {
21.   auto SectionTables = IMAGE_FIRST_SECTION(NtHeader);    // 获取区段表
22.   WORD Count = NtHeader->FileHeader.NumberOfSections;    // 获取区段数量
24.   for (int i = 0; i < Count; ++i)
25.   {
26.     // 判断是否存在于区段中
27.     DWORD Section_Start = SectionTables[i].VirtualAddress;
28.     DWORD Section_Ends = SectionTables[i].VirtualAddress + SectionTables[i].SizeOfRawData;
29.     if (rva >= Section_Start && rva < Section_Ends)
30.     {
31.       // 找到之后计算位置并返回值
32.       return rva - SectionTables[i].VirtualAddress + SectionTables[i].PointerToRawData;
33.     }
34.   }
35.   return -1;
36. }
38. // 打开PE文件
39. bool OpenPeFile(LPCSTR FileName)
40. {
41.   // 打开文件
42.   HANDLE Handle = CreateFileA(FileName, GENERIC_READ, NULL,NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
43.   if (Handle == INVALID_HANDLE_VALUE)
44.     return false;
46.   // 获取文件大小
47.   FileSize = GetFileSize(Handle, NULL);
49.   // 读取文件数据
50.   DWORD OperSize = 0;
51.   FileBase = (DWORD)new BYTE[FileSize];
52.   ReadFile(Handle, (LPVOID)FileBase, FileSize, &OperSize, NULL);
54.   // 获取DOS头并判断是不是一个有效的DOS文件
55.   DosHeader = (PIMAGE_DOS_HEADER)FileBase;
56.   if (DosHeader->e_magic != IMAGE_DOS_SIGNATURE)
57.     return false;
59.   // 获取 NT 头并判断是不是一个有效的PE文件
60.   NtHeader = (PIMAGE_NT_HEADERS)(FileBase + DosHeader->e_lfanew);
61.   if (NtHeader->Signature != IMAGE_NT_SIGNATURE)
62.     return false;
64.   // 判断是不是一个32位文件
65.   if (NtHeader->OptionalHeader.Magic != 0x010B)
66.     return false;
67.   
68.   CloseHandle(Handle);
69.   return true;
70. }
72. // 修复重定位表
73. void RepairFixReloc(char new_file[])
74. {
75.   DWORD base = NtHeader->OptionalHeader.ImageBase;
76.   // 1. 获取重定位表的 rva
77.   DWORD RelocRVA = NtHeader->OptionalHeader.DataDirectory[5].VirtualAddress;
78.   // 2. 获取重定位表
79.   auto Reloc = (PIMAGE_BASE_RELOCATION)(FileBase + RVAtoFOA(RelocRVA));
81.   // 3. 遍历重定位表中的重定位块，以0结尾
82.   while (Reloc->SizeOfBlock != 0)
83.   {
84.     // 3.1 输出分页基址
85.     printf("[↓] 分页基址: 0x%08X \n\n", Reloc->VirtualAddress);
86.     // 3.2 找到重定位项
87.     auto Offset = (TypeOffset*)(Reloc + 1);
89.     // 3.3 计算重定位项的个数
90.     // Reloc->SizeOfBlock 保存的是整个重定位块的大小 结构体 + 重定位项数组
91.     // Reloc->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION) 得到单个数组大小
92.     // 上面的结果 \ 2 = 重定位项的个数，原因是重定位项的大小为两个字节
93.     DWORD Size = (Reloc->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / 2;
95.     // 3.4 遍历所有的重定位项
96.     for (DWORD i = 0; i < Size; ++i)
97.     {
98.       DWORD Type = Offset[i].Type;                  // 获取重定位类型，只关心为3的类型
99.       DWORD pianyi = Offset[i].Offset;              // 获取重定位的偏移值
100.       DWORD rva = pianyi + Reloc->VirtualAddress;   // 获取要重定位的地址所在的RVA
101.       DWORD foa = RVAtoFOA(rva);                    // 获取要重定位的地址所在的FOA
102.       DWORD fa = foa + FileBase;                    // 获取要重定位的地址所在的fa
103.       DWORD addr = *(DWORD*)fa;                     // 获取要重定位的地址
104.       DWORD new_addr = addr - base + 0x1500000;     // 计算重定位后的数据: addr - oldbase + newbase
106.       // 将重定位后的数据写回缓冲区(文件)
107.       if (Offset[i].Type == 3)
108.         *(DWORD*)fa = new_addr;
110.       printf("\t [->] 重定位RVA: 0x%08X | 重定位FOA: 0x%08X | 重定位地址: 0x%08X | 修正地址: 0x%08X \n", rva, foa, addr, new_addr);
111.     }
112.     // 找到下一个重定位块
113.     Reloc = (PIMAGE_BASE_RELOCATION)((DWORD)Reloc + Reloc->SizeOfBlock);
114.   }
115.   // 保存修正后的文件
116.   NtHeader->OptionalHeader.ImageBase = 0x1500000;
118.   // 打开一个新文件
119.   HANDLE new_handle = CreateFileA(new_file, GENERIC_WRITE, NULL, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
120.   if (new_handle == INVALID_HANDLE_VALUE)
121.     return;
123.   DWORD OperSize = 0;
124.   // 保存修正好的程序
125.   BOOL ret = WriteFile(new_handle, (LPVOID)FileBase, FileSize, &OperSize, NULL);
126.   if (ret == TRUE)
127.   {
128.     printf("\n\n");
129.     CloseHandle(new_handle);
131.     printf("[*] 修复 %s 文件 \t 写入基址: %08X \t 总长度: %d \t 写入长度: %d \n", new_file, FileBase, FileSize, OperSize);
132.   }
133. }
135. void Banner()
136. {
137.   printf(" ____        _ _     _   ____      _            \n");
138.   printf("| __ ) _   _(_) | __| | |  _ \\ ___| | ___   ___ \n");
139.   printf("|  _ \\| | | | | |/ _` | | |_) / _ \\ |/ _ \\ / __|\n");
140.   printf("| |_) | |_| | | | (_| | |  _ <  __/ | (_) | (__ \n");
141.   printf("|____/ \\__,_|_|_|\\__,_| |_| \\_\\___|_|\\___/ \\___|\n");
142.   printf("                                                \n");
143.   printf("Reloc 重定位表快速修复工具 \t By: LyShark \n");
144.   printf("Usage: BuildFix [原文件位置] [修复后文件位置] \n\n\n");
145. }
147. int main(int argc, char* argv[])
148. {
149.   Banner();
150.   if (argc == 3)
151.   {
152.     bool flag = OpenPeFile(argv[1]);
153.     if (true == flag)
154.     {
155.       RepairFixReloc(argv[2]);
156.     }
157.   }
158.   return 0;
159. }

复制代码

运行上述程序，读者可自行传入脱壳前的程序与脱壳后的程序，此时则会实现自动替换，如下图所示；

本文作者： 王瑞
本文链接： https://www.lyshark.com/post/3c1b31b5.html
版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！