使用Process Hacker从内存中提取pe文件

梦幻的彼岸

原文地址：https://rioasmara.com/2022/08/05/extracting-pe-from-memory-using-process-hacker/

翻译：梦幻的彼岸

我正在创建一个非常简单的教程，从内存中提取恶意软件。我做了两个简单的应用程序，第一个将从一个文本文件中加载第二个应用程序的二进制文件，该文件是用based64编码的。

下面是第一个应用程序的代码，它将把上述base64解码成PE文件，并将它们加载到内存中

1. #include <stdio.h>
   
2. #include <string.h>
   
3. #include <Windows.h>
   
4. 
   
5. const char b64chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
   
6. 
   
7. int b64invs[] = { 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58,
   
8.     59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5,
   
9.     6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
   
10.     21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28,
    
11.     29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
    
12.     43, 44, 45, 46, 47, 48, 49, 50, 51 };
    
13. 
    
14. size_t b64_decoded_size(const char* in)
    
15. {
    
16.     size_t len;
    
17.     size_t ret;
    
18.     size_t i;
    
19. 
    
20.     if (in == NULL)
    
21.         return 0;
    
22. 
    
23.     len = strlen(in);
    
24.     ret = len / 4 * 3;
    
25. 
    
26.     for (i = len; i-- > 0; ) {
    
27.         if (in[i] == '=') {
    
28.             ret--;
    
29.         }
    
30.         else {
    
31.             break;
    
32.         }
    
33.     }
    
34. 
    
35.     return ret;
    
36. }
    
37. 
    
38. int b64_isvalidchar(char c)
    
39. {
    
40.     if (c >= '0' && c <= '9')
    
41.         return 1;
    
42.     if (c >= 'A' && c <= 'Z')
    
43.         return 1;
    
44.     if (c >= 'a' && c <= 'z')
    
45.         return 1;
    
46.     if (c == '+' || c == '/' || c == '=')
    
47.         return 1;
    
48.     return 0;
    
49. }
    
50. 
    
51. int b64_decode(const char* in, unsigned char* out, size_t outlen)
    
52. {
    
53.     size_t len;
    
54.     size_t i;
    
55.     size_t j;
    
56.     int    v;
    
57. 
    
58.     if (in == NULL || out == NULL)
    
59.         return 0;
    
60. 
    
61.     len = strlen(in);
    
62.     if (outlen < b64_decoded_size(in) || len % 4 != 0)
    
63.         return 0;
    
64. 
    
65.     for (i = 0; i < len; i++) {
    
66.         if (!b64_isvalidchar(in[i])) {
    
67.             return 0;
    
68.         }
    
69.     }
    
70. 
    
71.     for (i = 0, j = 0; i < len; i += 4, j += 3) {
    
72.         v = b64invs[in[i] - 43];
    
73.         v = (v << 6) | b64invs[in[i + 1] - 43];
    
74.         v = in[i + 2] == '=' ? v << 6 : (v << 6) | b64invs[in[i + 2] - 43];
    
75.         v = in[i + 3] == '=' ? v << 6 : (v << 6) | b64invs[in[i + 3] - 43];
    
76. 
    
77.         out[j] = (v >> 16) & 0xFF;
    
78.         if (in[i + 2] != '=')
    
79.             out[j + 1] = (v >> 8) & 0xFF;
    
80.         if (in[i + 3] != '=')
    
81.             out[j + 2] = v & 0xFF;
    
82.     }
    
83. 
    
84.     return 1;
    
85. }
    
86. 
    
87. int main()
    
88. {
    
89.     char str1[20];
    
90.     FILE* fp;
    
91.     char buff[70317];
    
92.     fp = fopen("C:\\Temp\\payload.txt", "r");
    
93.     fscanf(fp, "%s", buff);
    
94.     fclose(fp);
    
95.     printf("64Base Payload Loaded\n");
    
96. 
    
97.     char* out;
    
98.     size_t out_len;
    
99. 
    
100.     out_len = b64_decoded_size(buff) + 1;
     
101.     out = (char*)malloc(out_len);
     
102. 
     
103.     printf("Decoding ...\n");
     
104.     b64_decode(buff, (unsigned char*)out, out_len);
     
105. 
     
106. 
     
107.     printf("Preparinig RWX Memory Space ...\n");
     
108.     SIZE_T shellSize = sizeof(buff);
     
109.     LPVOID shellAddress = VirtualAlloc(NULL, out_len, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
     
110. 
     
111.     printf("Ready to Decrypt Payload \n");
     
112.     scanf("%19s", str1);
     
113. 
     
114.     WriteProcessMemory(GetCurrentProcess(), shellAddress, out, out_len, NULL);
     
115. 
     
116.     printf("PE Payload Loaded Pause \n");
     
117.     scanf("%19s", str1);
     
118. 
     
119. }

复制代码

运行第一个应用程序，直到它准备将有效载荷加载到内存中。


让我们打开Process Hacker，找出有效载荷将被复制到哪里。提示是找到具有保护功能的RWX的内存区域。让我们打开进程黑客，找到这个进程


右键点击进程并暂停它，以防止恶意软件进一步运行。请注意，你不应该在你的主操作系统中运行该恶意软件。


双击MalWrapper.exe，进入内存标签，找到带有RWX的内存地址。为什么是RWX，因为该内存区域必须允许有效载荷从该内存区域执行。


在加载有效载荷之前
我们可以看到，带有RWX保护的内存范围现在是空的，因为我们在有效载荷被复制到内存空间之前就停止了


在应用程序上按Yes，它将继续把PE复制到新分配的内存区域。在有效载荷被加载后。我们可以看到，一个PE被加载到了内存中


现在，一旦有效载荷被完全复制到内存空间，我们就可以将其保存或转储到一个文件中。点击 "保存 "按钮


在IDA中打开输出文件。你可以直接用IDA加载你刚刚保存的文件。


你需要重新建立IDA的基数，因此应用程序的开始将与我们刚刚复制的二进制文件相同。在进程黑客中，右击有效载荷被复制到的内存区域，点击“Copy Base Address”


一旦你复制了，那么就把它作为IDA中的分段重置基准（ segment rebase）。


下面是应用程序的代码，现在我们可以看到有效载荷已被解包，我们可以进行静态分析