PE 自注入

ivi

shadow 蛇矛实验室 2023-11-24 13:00


默认的 Windows API 函数（LoadLibrary、LoadLibraryEx）只能加载文件系统中的外部库，无法直接从内存中加载 DLL，并且无法正确地加载 EXE。有时候，确实需要这种功能（例如，不想分发大量文件或者想增加反汇编的难度）。解决这个问题的常见方法是先将 DLL 写入临时文件，然后从临时文件中导入。当程序终止时，临时文件会被删除。另一种方式是直接将所需的 DLL/EXE 文件数据直接存储在内存中，通过模拟 Windows 映像加载程序的功能，完全从内存中加载，而不需要先存储到磁盘上。



PE 格式简介

为了模拟 Windows 映像加载程序的功能，首先需要了解 Windows 的可执行程序格式（PE 文件格式），由以下几部分组成：

• DOS 头：包含用于早期 DOS 兼容性的信息，并标识该文件是否是有效的 PE 文件。
• PE头：包括 PE 标识、文件头和可选头。
• PE标识：指示该文件是一个PE（Portable Executable，可移植可执行）文件。
• 文件头：包含关于文件本身的基本信息，如文件类型、目标平台、时间戳等。
• 可选头：包含更详细的文件信息，如内存布局、入口点地址、数据目录等。
• 节表：描述了文件中各个节（sections）的属性和位置，每个节都包含特定类型的数据，如代码、数据、导入表等。
• 节表数据：实际存储文件中的数据和代码，每个节都有自己的属性，如可执行性、可读性、可写性等。
  

这几部分共同构成了 Windows 可执行文件的结构。下图显示了 PE 结构的简图：


这些组成部分对应的结构体大多可在头文件 winnt.h 中找到。


PE自注入流程

对 PE 文件格式有了一定的了解，现在来看一下 PE 自注入的流程，也就是模拟 Window 加载器的步骤。

• 分配足够内存用来保存注入的 PE 文件。
• 拷贝节表数据。
• 进行基址重定位。
• 填充导入地址表 (IAT)。
• 设置节表数据对应内存区域的权限。
• 转到入口点执行。
  

这是基本的流程，如果 PE 文件还包含 TLS 回调和异常处理程序，还需要对这些情况进行处理。


PE自注入实现流程

准备工作
获取载荷数据，这里直接采用从文件中读取载荷文件内容到内存中。编写 ReadFileContents 函数从文件中获取载荷数据。

1. BOOL ReadFileContents(LPCSTR cFileName, PBYTE* ppBuffer, PDWORD pdwFileSize)
   
2. {
   
3.     DWORD dwNumberOfBytesRead = 0;
   
4. 
   
5.     HANDLE hFile = CreateFileA(cFileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
   
6.     DWORD dwFileSize = GetFileSize(hFile, 0);
   
7.     PBYTE pBufer = (PBYTE)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwFileSize);
   
8.     DWORD dwFileSize = ReadFile(hFile, pBufer, dwFileSize, &dwNumberOfBytesRead, NULL);
   
9.     CloseHandle(hFile);
   
10. 
    
11.     *ppBuffer = pBufer;
    
12.     *pdwFileSize = dwFileSize;
    
13.     return ((*ppBuffer != NULL) && (*pdwFileSize != 0x00)) ? TRUE : FALSE;
    
14. }

复制代码

在获取载荷数据后，对载荷文件 (PE文件)进行解析，并创建一个结构体来保存解析后的 PE 相关结构。

1. typedef struct _PE_HDRS
   
2. {
   
3.     PBYTE pFileBuffer; // 指向载荷文件缓冲区的指针
   
4.     DWORD dwFileSize; // 载荷文件大小
   
5.     BOOL bIsDLLFile; // 是否为DLL文件
   
6. 
   
7.     PIMAGE_NT_HEADERS pImgNtHdrs; // 指向NT头的指针
   
8.     PIMAGE_SECTION_HEADER pImgSecHdr; // 指向节表的指针
   
9. 
   
10.     PIMAGE_DATA_DIRECTORY pEntryImportDataDir; // 指向导入数据目录的指针
    
11.     PIMAGE_DATA_DIRECTORY pEntryBaseRelocDataDir; // 指向重定位数据目录的指针
    
12.     PIMAGE_DATA_DIRECTORY pEntryTLSDataDir; // 指向TLS数据目录的指针
    
13.     PIMAGE_DATA_DIRECTORY pEntryExceptionDataDir; // 指向异常数据目录的指针
    
14.     PIMAGE_DATA_DIRECTORY pEntryExportDataDir; // 指向导出数据目录的指针
    
15. } PE_HDRS, *PPE_HDRS, *LPPE_HDRS;

复制代码

InitPeStruct 函数负责解析载荷文件进而初始化 PE_HDRS 结构。

1. BOOL InitPeStruct(PPE_HDRS pPeHdrs, PBYTE pFileBuffer, DWORD dwFileSize)
   
2. {
   
3.     if (!pPeHdrs || !pFileBuffer || !dwFileSize)
   
4.         return FALSE;
   
5. 
   
6.     pPeHdrs->pFileBuffer = pFileBuffer;
   
7.     pPeHdrs->dwFileSize = dwFileSize;
   
8.     pPeHdrs->pImgNtHdrs = (PIMAGE_NT_HEADERS)(pFileBuffer + ((PIMAGE_DOS_HEADER)pFileBuffer)->e_lfanew);
   
9. 
   
10.     if (pPeHdrs->pImgNtHdrs->Signature != IMAGE_NT_SIGNATURE)
    
11.         return FALSE;
    
12. 
    
13.     pPeHdrs->bIsDLLFile = (pPeHdrs->pImgNtHdrs->FileHeader.Characteristics & IMAGE_FILE_DLL) ? TRUE : FALSE;
    
14.     pPeHdrs->pImgSecHdr = IMAGE_FIRST_SECTION(pPeHdrs->pImgNtHdrs);
    
15.     pPeHdrs->pEntryImportDataDir = &pPeHdrs->pImgNtHdrs->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
    
16.     pPeHdrs->pEntryBaseRelocDataDir =
    
17.         &pPeHdrs->pImgNtHdrs->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
    
18.     pPeHdrs->pEntryTLSDataDir = &pPeHdrs->pImgNtHdrs->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS];
    
19.     pPeHdrs->pEntryExceptionDataDir =
    
20.         &pPeHdrs->pImgNtHdrs->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION];
    
21.     pPeHdrs->pEntryExportDataDir = &pPeHdrs->pImgNtHdrs->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
    
22. 
    
23.     return TRUE;
    
24. }

复制代码

分配内存

载荷文件所需的内存使用 VirtualAlloc 进行分配，Windows 提供了函数来保护这些内存块，从而可以为这块内存进行权限设置。OptionalHeader 结构中定义了 PE 文件所需的内存块大小，如果可能的话，必须在 ImageBase 指定的地址上保留该内存块，如果保留的内存与 ImageBase 中给出的地址不同，则需要进行基址重定位。

1. PBYTE pPeBaseAddress = NULL;
   
2. 
   
3. pPeBaseAddress = (PBYTE)VirtualAlloc((LPVOID)(pPeHdrs->pImgNtHdrs->OptionalHeader.ImageBase),
   
4.                                            pPeHdrs->pImgNtHdrs->OptionalHeader.SizeOfImage,
   
5.                                            MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);

复制代码

拷贝节表数据

FileHeader 结构 (IMAGE_FILE_HEADER)中给出了节表的数量，通过循环将 PE 文件中的所有节表数据拷贝 (memcpy)到分配的内存中，每个节表数据从 IMAGE_SECTION_HEADER.PointerToRawData 开始复制，复制的大小为 IMAGE_SECTION_HEADER.SizeOfRawData，复制到分配内存基地址偏移为 IMAGE_SECTION_HEADER.VirtualAddress 处。

1. for (int i = 0; i < pPeHdrs->pImgNtHdrs->FileHeader.NumberOfSections; i++) {
   
2.     memcpy(
   
3.         (PVOID)(pPeBaseAddress + pPeHdrs->pImgSecHdr[i].VirtualAddress),
   
4.         (PVOID)((ULONG_PTR)pPeHdrs->pFileBuffer + pPeHdrs->pImgSecHdr[i].PointerToRawData),
   
5.         pPeHdrs->pImgSecHdr[i].SizeOfRawData
   
6.     );
   
7. }

复制代码

这里不拷贝的 DOS 头和 PE 头的原因是防止杀软等安全产品将这个作为一个特征点。

下图显示了各节表复制到分配内存中的状态：




基址重定位

将 PE 节表数据拷贝到分配的内存后，下一步是进行基址重定位，当 PE 映像在加载时的地址与其默认基址 (IMAGE_OPTIONAL_HEADER.ImageBase)不同时，需要进行重定位以调整可执行映像中的硬编码地址。在大多数情况下，PE 被映射到与 IMAGE_OPTIONAL_HEADER.ImageBase 不同的地址，因此需要调整 PE 映像中特定的硬编码地址。在 PE 文件中，重定位表位于 ". reloc" 节。下图形象的描述了 PE 为什么要重定位，只要 PE 模块没有加载到默认基址，都会发生重定位。




在重定位的过程中，需要找到需要修复的硬编码数据，计算公式如下：

修复结果 = 需要重定位的数据 + 当前的ImageBase - 以前的ImageBase;



重定位表是由多个重定位块组合而成的，每个块描述了一个 4KB (0x1000) 大小的内存页中，需要进行重定位的位置，每个重定位块都以 IMAGE_BASE_RELOCATION 结构开始，该结构定义如下：

1. typedef struct _IMAGE_BASE_RELOCATION {
   
2.     DWORD VirtualAddress;
   
3.     DWORD SizeOfBlock;
   
4.     // WORD TypeOffset[1];
   
5. } IMAGE_BASE_RELOCATION, *PIMAGE_BASE_RELOCATION;

复制代码

块的剩余部分是一个重定位数据项的数组，这个数据项占 2 个字节 (16 bit)，其中高 4 位表示该重定位数据项的类型，低12位表示重定位数据项偏移 (相对于当前重定位块的偏移)，由低 12 位与 VirtualAddress 相加就是需要进行重定位数据项的 RVA 地址。这个重定位数据项可以用下述结构表示：

1. typedef struct _BASE_RELOCATION_ENTRY {
   
2.   WORD Offset : 12; // 低12位：大小为12Bit的重定位数据项偏移，Offset就是相对于VirtualAddress的一个偏移。
   
3.   WORD Type : 4; // 高4位：大小为4Bit的重定位数据项类型值，Type是一个类型，一般情况下是 3，说明需要重定位
   
4. } BASE_RELOCATION_ENTRY, * PBASE_RELOCATION_ENTRY;

复制代码

重定位类型由如下几种，可在 winnt.h 头文件中找到，详细的描述信息可在官方文档中获取。

1. //
   
2. // Based relocation types.
   
3. //
   
4. 
   
5. #define IMAGE_REL_BASED_ABSOLUTE 0
   
6. #define IMAGE_REL_BASED_HIGH 1
   
7. #define IMAGE_REL_BASED_LOW 2
   
8. #define IMAGE_REL_BASED_HIGHLOW 3
   
9. #define IMAGE_REL_BASED_HIGHADJ 4
   
10. #define IMAGE_REL_BASED_MIPS_JMPADDR 5
    
11. #define IMAGE_REL_BASED_MIPS_JMPADDR16 9
    
12. #define IMAGE_REL_BASED_IA64_IMM64 9
    
13. #define IMAGE_REL_BASED_DIR64 10

复制代码

为了执行重定位，需要遍历所有重定位块，获取所有重定位数据项，根据其类型和偏移，进行必要修复，PerformBaseReloc 函数实现了这个过程。

1. BOOL PerformBaseReloc(PIMAGE_DATA_DIRECTORY pEntryBaseRelocDataDir, ULONG_PTR pPeBaseAddress, ULONG_PTR pOldAddress)
   
2. {
   
3.   PIMAGE_BASE_RELOCATION pImgBaseRelocation = (PIMAGE_BASE_RELOCATION)(pPeBaseAddress + pEntryBaseRelocDataDir->VirtualAddress);
   
4.   ULONG_PTR uDeltaOffset = pPeBaseAddress - pOldAddress;
   
5.   PBASE_RELOCATION_ENTRY pEntry = NULL;
   
6. 
   
7.   // 遍历重定位块
   
8.   while (pImgBaseRelocation->VirtualAddress)
   
9.   {
   
10.     pEntry = (PBASE_RELOCATION_ENTRY)(pImgBaseRelocation + 1);
    
11. 
    
12.     while ((PBYTE) pEntry != (PBYTE) pImgBaseRelocation + pImgBaseRelocation->SizeOfBlock)
    
13.     {
    
14.       // 处理重定位数据项
    
15.       switch (pEntry->Type)
    
16.       {
    
17.       case IMAGE_REL_BASED_DIR64:
    
18.         *((ULONG_PTR*)(pPeBaseAddress + pImgBaseRelocation->VirtualAddress + pEntry->Offset)) += uDeltaOffset;
    
19.         break;
    
20.       case IMAGE_REL_BASED_HIGHLOW:
    
21.         *((DWORD*)(pPeBaseAddress + pImgBaseRelocation->VirtualAddress + pEntry->Offset)) += (DWORD) uDeltaOffset;
    
22.         break;
    
23.       case IMAGE_REL_BASED_HIGH:
    
24.         *((WORD*)(pPeBaseAddress + pImgBaseRelocation->VirtualAddress + pEntry->Offset)) += HIWORD (uDeltaOffset);
    
25.         break;
    
26.       case IMAGE_REL_BASED_LOW:
    
27.         *((WORD*)(pPeBaseAddress + pImgBaseRelocation->VirtualAddress + pEntry->Offset)) += LOWORD (uDeltaOffset);
    
28.         break;
    
29.       case IMAGE_REL_BASED_ABSOLUTE:
    
30.         break;
    
31.       default:
    
32.         return FALSE;
    
33.       }
    
34.       // 定位下一个重定位数据项
    
35.       pEntry++;
    
36.     }
    
37. 
    
38.     // 定位下一个重定位块
    
39.     pImgBaseRelocation = (PIMAGE_BASE_RELOCATION) pEntry;
    
40.   }
    
41. 
    
42.   return TRUE;
    
43. }

复制代码

填充 IAT

Windows 映像加载程序在处理 PE 映像的时候，其中一个步骤就是，加载所需的 DLL，并从中获取导入函数的地址写入其导入地址表(IAT)中，这个填充的过程需要手动的实现。

PE 文件的导入表记录当前程序使用了哪些模块的哪些函数，如果使用了多个模块，相应的也会存在多张导入表，最终会以一个全 0 的导入表结构结尾。当 PE 文件没有加载到内存时，IAT 和 INT 中保存的通常序号或导入名称结构的 RVA，一旦程序被加载到内存中，Windows 映像加载程序就会为 IAT 填充函数的真实地址，填充的过程如下可以使用下面的图进行描述：



填充 IAT 需要遍历导入表，这个过程需要使用两个循环来进行枚举，外层循环枚举所有的 DLL，内层循环枚举所导入的该 DLL 的所有函数名及函数地址。

1. BOOL FixIAT(PIMAGE_DATA_DIRECTORY pEntryImportDataDir, PBYTE pPeBaseAddress) {
   
2. 
   
3.   PIMAGE_IMPORT_DESCRIPTOR pImgImportDesc = NULL;
   
4. 
   
5.   // 外层循环枚举所有的 DLL
   
6.   for (SIZE_T i = 0; i < pEntryImportDataDir->Size; i += sizeof(IMAGE_IMPORT_DESCRIPTOR))
   
7.   {
   
8.     pImgImportDesc = (PIMAGE_IMPORT_DESCRIPTOR)(pPeBaseAddress + pEntryImportDataDir->VirtualAddress + i);
   
9.     if (pImgImportDesc->OriginalFirstThunk == NULL && pImgImportDesc->FirstThunk == NULL)
   
10.       break;
    
11. 
    
12.     LPSTR cDllName = (LPSTR)(pPeBaseAddress + pImgImportDesc->Name);
    
13.     ULONG_PTR uOriginalFirstThunkRVA = pImgImportDesc->OriginalFirstThunk;
    
14.     ULONG_PTR uFirstThunkRVA = pImgImportDesc->FirstThunk;
    
15.     SIZE_T ImgThunkSize = 0;
    
16.     HMODULE hModule = NULL;
    
17. 
    
18.     hModule = LoadLibraryA(cDllName);
    
19. 
    
20.     // 内层循环枚举所导入的该 DLL 的所有函数名及函数地址
    
21.     while (TRUE)
    
22.     {
    
23.       PIMAGE_THUNK_DATA pOriginalFirstThunk = (PIMAGE_THUNK_DATA)(pPeBaseAddress + uOriginalFirstThunkRVA + ImgThunkSize);
    
24.       PIMAGE_THUNK_DATA pFirstThunk = (PIMAGE_THUNK_DATA)(pPeBaseAddress + uFirstThunkRVA + ImgThunkSize);
    
25.       PIMAGE_IMPORT_BY_NAME pImgImportByName = NULL;
    
26.       ULONG_PTR pFuncAddress = NULL;
    
27. 
    
28.       if (pOriginalFirstThunk->u1.Function == NULL && pFirstThunk->u1.Function == NULL) {
    
29.         break;
    
30.       }
    
31. 
    
32.       if (IMAGE_SNAP_BY_ORDINAL(pOriginalFirstThunk->u1.Ordinal)) {
    
33.         if (!(pFuncAddress = (ULONG_PTR)GetProcAddress(hModule, (LPCSTR)(IMAGE_ORDINAL(pOriginalFirstThunk->u1.Ordinal))))) {
    
34.           return FALSE;
    
35.         }
    
36.       }
    
37.       else {
    
38.         pImgImportByName = (PIMAGE_IMPORT_BY_NAME)(pPeBaseAddress + pOriginalFirstThunk->u1.AddressOfData);
    
39.         // 获取函数地址
    
40.         pFuncAddress = (ULONG_PTR)GetProcAddress(hModule, pImgImportByName->Name);
    
41.       
    
42.       }
    
43. 
    
44.       // 进行填充
    
45.       pFirstThunk->u1.Function = (ULONGLONG)pFuncAddress;
    
46. 
    
47.       // 定位下一个项
    
48.       ImgThunkSize += sizeof(IMAGE_THUNK_DATA);
    
49.     }
    
50.   }
    
51. 
    
52.   return TRUE;
    
53. }

复制代码

设置节表数据对应内存区域的权限

在执行完重定位和填充了 IAT 之后，需要根据 IMAGE_SECTION_HEADER.Characteristics 字段设置正确的内存权限。

1. BOOL SetMemoryPermission(ULONG_PTR pPeBaseAddress, PIMAGE_NT_HEADERS pImgNtHdrs, PIMAGE_SECTION_HEADER pImgSecHdr)
   
2. {
   
3.   for (DWORD i = 0; i < pImgNtHdrs->FileHeader.NumberOfSections; i++)
   
4.   {
   
5.     DWORD dwProtection = 0;
   
6.     DWORD dwOldProtection = 0;
   
7. 
   
8.     if (!pImgSecHdr[i].SizeOfRawData || !pImgSecHdr[i].VirtualAddress)
   
9.       continue;
   
10. 
    
11.     if (pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_WRITE)
    
12.       dwProtection = PAGE_WRITECOPY;
    
13. 
    
14.     if (pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_READ)
    
15.       dwProtection = PAGE_READONLY;
    
16. 
    
17.     if ((pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_WRITE) && (pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_READ))
    
18.       dwProtection = PAGE_READWRITE;
    
19. 
    
20.     if (pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_EXECUTE)
    
21.       dwProtection = PAGE_EXECUTE;
    
22. 
    
23.     if ((pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_EXECUTE) && (pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_WRITE))
    
24.       dwProtection = PAGE_EXECUTE_WRITECOPY;
    
25. 
    
26.     if ((pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_EXECUTE) && (pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_READ))
    
27.       dwProtection = PAGE_EXECUTE_READ;
    
28. 
    
29.     if ((pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_EXECUTE) && (pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_WRITE) && (pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_READ))
    
30.       dwProtection = PAGE_EXECUTE_READWRITE;
    
31. 
    
32.     VirtualProtect((PVOID)(pPeBaseAddress + pImgSecHdr[i].VirtualAddress), pImgSecHdr[i].SizeOfRawData, dwProtection, &dwOldProtection);
    
33.   
    
34.   }
    
35. 
    
36.   return TRUE;
    
37. }

复制代码

转到入口点执行

基本步骤完成后，如果载荷文件不存在异常目录和 TLS 目录，那么就只需要跳转到入口点执行了。如果需要注入执行的文件是 EXE 文件，通过以下代码来执行。

1. typedef BOOL(WINAPI* MAIN)();
   
2. 
   
3. MAIN pMain = (MAIN)EntryPoint;
   
4. pMain();

复制代码

如果需要注入执行的文件是 DLL 文件，可按照如下方式运行。

1. typedef BOOL(WINAPI* DLLMAIN)(HINSTANCE, DWORD, LPVOID);
   
2. 
   
3. DLLMAIN pDllMain = (DLLMAIN)EntryPoint;
   
4. pDllMain((HINSTANCE)pPeBaseAddress, DLL_PROCESS_ATTACH, NULL);

复制代码

到这里，能够将 PE 程序的加载执行了，但是如果目标 PE 程序存在异常表和 TLS 表，那么还需要对其进行处理，不然自注入的 PE 程序可能存在问题。



注册异常处理程序
PE 文件头可选映像头中数据目录表的第 4 个成员指向异常处理表，它保存在 PE 文件中，通常在".pdata"区段。其 RVA 指向的是一个 IMAGE_IA64_RUNTIME_FUNCTION_ENTRY 的结构体，其结构如下：

1. typedef struct _IMAGE_RUNTIME_FUNCTION_ENTRY {
   
2.   DWORD BeginAddress;
   
3.   DWORD EndAddress;
   
4.   union {
   
5.     DWORD UnwindInfoAddress;
   
6.     DWORD UnwindData;
   
7.   } DUMMYUNIONNAME;
   
8. } RUNTIME_FUNCTION, *PRUNTIME_FUNCTION, _IMAGE_RUNTIME_FUNCTION_ENTRY, *_PIMAGE_RUNTIME_FUNCTION_ENTRY;

复制代码

在进行 PE 自注入的过程中，可以使用 RtlAddFunctionTable 这个 API 来向运行时函数表中添加函数表条目，具体过程如下：

1. BOOL RegisterExceptionFunctionTable(PPE_HDRS pPeHdrs, ULONG_PTR pPeBaseAddress)
   
2. {
   
3.     if (!pPeHdrs)
   
4.         return FALSE;
   
5. 
   
6.     if (pPeHdrs->pEntryExceptionDataDir->Size == 0)
   
7.         return FALSE;
   
8. 
   
9.     PIMAGE_RUNTIME_FUNCTION_ENTRY pImgRuntimeFuncEntry = (PIMAGE_RUNTIME_FUNCTION_ENTRY)(pPeBaseAddress + pPeHdrs->pEntryExceptionDataDir->VirtualAddress);
   
10.     RtlAddFunctionTable(pImgRuntimeFuncEntry, (pPeHdrs->pEntryExceptionDataDir->Size / sizeof(IMAGE_RUNTIME_FUNCTION_ENTRY)), pPeBaseAddress);
    
11. 
    
12.     return TRUE;
    
13. }

复制代码

执行 TLS 回调

Thread Local Storage(TLS)是一种线程本地存储的机制。它用于为每个线程分配独立的内存空间，使得每个线程都可以独立地访问和修改自己的局部变量，而不会与其他线程的变量发生冲突。在多线程程序中，每个线程都有自己的栈、寄存器等资源，但是全局变量是共享的，可能会导致并发访问的竞争条件。为了解决这个问题，TLS 提供了一种线程专用的存储区域，使得每个线程都可以拥有自己的变量副本，互不干扰。

TLS 回调是指 PE 文件的 TLS 目录中指定的一组回调函数。这些回调在创建线程之前由 Windows 映像加载器执行，这意味着 TLS 回调可以在 PE 的入口点之前运行。TLS 回调用于在程序或线程的主要逻辑开始之前初始化特定于线程的资源或配置。TLS 回调机制也可以用于反调试技术。

如果需要自注入的 PE 载荷包含 TLS 回调，可通过检索 TLS 目录（ IMAGE_TLS_DIRECTORY ）在入口点之前执行它们。这个目录包含一个由 PIMAGE_TLS_CALLBACK 函数指针定义的回调函数数组。IMAGE_TLS_DIRECTORY 结构可在 winnt.h 头文件中找到，其中 IMAGE_TLS_DIRECTORY64 结构如下，它描述 64 位程序 TLS 的相关信息。

1. typedef struct _IMAGE_TLS_DIRECTORY64 {
   
2.     ULONGLONG StartAddressOfRawData;
   
3.     ULONGLONG EndAddressOfRawData;
   
4.     ULONGLONG AddressOfIndex; // PDWORD
   
5.     ULONGLONG AddressOfCallBacks; // PIMAGE_TLS_CALLBACK *;
   
6.     DWORD SizeOfZeroFill;
   
7.     union {
   
8.         DWORD Characteristics;
   
9.         struct {
   
10.             DWORD Reserved0 : 20;
    
11.             DWORD Alignment : 4;
    
12.             DWORD Reserved1 : 8;
    
13.         } DUMMYSTRUCTNAME;
    
14.     } DUMMYUNIONNAME;
    
15. 
    
16. } IMAGE_TLS_DIRECTORY64;
    

复制代码

32 位程序 TLS 结构如下：

1. typedef struct _IMAGE_TLS_DIRECTORY32 {
   
2.     DWORD StartAddressOfRawData;
   
3.     DWORD EndAddressOfRawData;
   
4.     DWORD AddressOfIndex; // PDWORD
   
5.     DWORD AddressOfCallBacks; // PIMAGE_TLS_CALLBACK *
   
6.     DWORD SizeOfZeroFill;
   
7.     union {
   
8.         DWORD Characteristics;
   
9.         struct {
   
10.             DWORD Reserved0 : 20;
    
11.             DWORD Alignment : 4;
    
12.             DWORD Reserved1 : 8;
    
13.         } DUMMYSTRUCTNAME;
    
14.     } DUMMYUNIONNAME;
    
15. 
    
16. } IMAGE_TLS_DIRECTORY32;

复制代码

通过 IMAGE_TLS_DIRECTORY.AddressOfCallBacks 成员，可以检索 PIMAGE_TLS_CALLBACK 函数指针的数组。PIMAGE_TLS_CALLBACK 类型的函数指针指向一个 TLS 回调函数，其函数原型为：

1. typedef VOID (NTAPI *PIMAGE_TLS_CALLBACK) (
   
2.     PVOID hModule,
   
3.     DWORD dwReason,
   
4.     PVOID pContext
   
5. );

复制代码

TLS 回调函数的构造方式类似于 DLL 的 DllMain 函数，它接受一个 dwReason 参数，根据该参数决定在 TLS 回调函数内执行什么操作。下面是一个示例，演示了如何构造 TLS 回调函数：

1. VOID NTAPI MyTlsCallback(PVOID DllHandle, DWORD Reason, PVOID Reserved) {
   
2.     switch (Reason) {
   
3.         case DLL_PROCESS_ATTACH: // DLL加载时
   
4.             break;
   
5.         case DLL_THREAD_ATTACH: // 线程创建时
   
6.             break;
   
7.         case DLL_THREAD_DETACH: // 线程终止时
   
8.             break;
   
9.         case DLL_PROCESS_DETACH: // DLL卸载时
   
10.             break;
    
11.         default:
    
12.             // 其他情况下
    
13.             break;
    
14.     }
    
15. }

复制代码

在执行 TLS 回调函数时，需要指定执行的原因，例如 DLL_PROCESS_ATTACH（DLL 加载时执行）等。但是，由于是自己写的加载器，在调用 TLS 回调函数之前，无法确定 dwReason 参数的值。



解决办法是使用一个固定的标志，但这限制了 TLS 回调函数的能力，但它仍然优于完全忽略 TLS 回调函数。下面的代码片段通过获取 TLS 表中的回调函数地址，并传递 DLL_PROCESS_ATTACH 标志来执行它们。

1. BOOL ExecuteTlsCallbacks(PPE_HDRS pPeHdrs, ULONG_PTR pPeBaseAddress)
   
2. {
   
3.     if (!pPeHdrs)
   
4.         return FALSE;
   
5. 
   
6.     if (pPeHdrs->pEntryTLSDataDir->Size == 0)
   
7.         return FALSE;
   
8. 
   
9.     PIMAGE_TLS_DIRECTORY pImgTlsDirectory = (PIMAGE_TLS_DIRECTORY)(pPeBaseAddress + pPeHdrs->pEntryTLSDataDir->VirtualAddress);
   
10.     PIMAGE_TLS_CALLBACK* pImgTlsCallback = (PIMAGE_TLS_CALLBACK*)(pImgTlsDirectory->AddressOfCallBacks);
    
11.     CONTEXT ctx = {0};
    
12. 
    
13.     // 指向TLS回调，传递固定标志 DLL_PROCESS_ATTACH
    
14.     for (int i = 0; pImgTlsCallback[i] != NULL; i++) {
    
15.         pImgTlsCallback[i]((LPVOID)pPeBaseAddress, DLL_PROCESS_ATTACH, &ctx);
    
16.     }
    
17. }

复制代码

还有一种需求就是不仅仅需要执行入口点代码，如果针对一个 DLL，它通常存在导出函数，有时候需要这个自注入的加载器拥有能够执行该导出函数的能力。这可通过遍历 PE 载荷的导出表来获取该导出函数的地址，下面的代码片段通过解析 PE 载荷的导出表来获取载荷导出函数的地址。

1. PVOID GetExportedFunctionAddress(PIMAGE_DATA_DIRECTORY pEntryExportDataDir, ULONG_PTR pPeBaseAddress, LPCSTR cFunctionName)
   
2. {
   
3.     PIMAGE_EXPORT_DIRECTORY pImgExportDir = (PIMAGE_EXPORT_DIRECTORY)(pPeBaseAddress + pEntryExportDataDir->VirtualAddress);
   
4.     PDWORD pENT = (PDWORD)(pPeBaseAddress + pImgExportDir->AddressOfNames);
   
5.     PDWORD pEAT = (PDWORD)(pPeBaseAddress + pImgExportDir->AddressOfFunctions);
   
6.     PWORD pEOT = (PWORD)(pPeBaseAddress + pImgExportDir->AddressOfNameOrdinals);
   
7. 
   
8.     for (DWORD i = 0; i < pImgExportDir->NumberOfFunctions; i++)
   
9.     {
   
10.         LPCSTR pFunctionName = (LPCSTR)(pPeBaseAddress + pENT[i]);
    
11.         PVOID pFunctionAddress = (PVOID)(pPeBaseAddress + pEAT[pEOT[i]]);
    
12. 
    
13.         if (strcmp(cFunctionName, pFunctionName) == 0)
    
14.         {
    
15.             return pFunctionAddress;
    
16.         }
    
17.     }
    
18. 
    
19.     return NULL;
    
20. }

复制代码

可能有些情况待注入 PE 载荷执行需要命令行参数，这就需要自注入的加载能够用于 Patch 注入载荷命令行参数的能力，这可通过解析 PEB 结构中命令行相关字段来实现。



检测

自注入的 PE 载荷在运行时会暴露在内存中，可使用 Pesieve 或者 Moneta 等内存扫描工具针对被加载的 PE 载荷进行运行时检测。



总结

本文首先简单的介绍了 PE 文件结构，之后列出了 PE 自注入的流程，随后根据这个流程进行了具体的实现，并进行了简单的规避操作（擦除 PE 特征），最后提出了检测方式。