通过暴搜DRIVER_OBJECT枚举驱动

丛林宝宝

技术可能有点老了，不过希望能够给和我一样的初学者一点参考。

  先来捣鼓几句，几年前，在内核中战争的焦点总是检测与隐藏，通过内核的特权，我们能够肆意妄为，想改什么就该什么，似乎能想到的，就能够做到。对于进程的隐藏，方法多的已经数不过来了。曾经，修改内核对象是一件很时髦的事，无论是做隐藏还是检测，无论是好人还是坏人，无论是男人还是女人（哦，说漏嘴了）,无论是...是...? 但是不管多牛X，而仅仅few years的时间，一切好像都过时了。

  后来又出现了暴力搜索这个东西，当进程被通过修改各种各样的内核对象被隐藏时，各种依赖于这些对象的检测方法也渐渐失效，暴力搜索EPROCESS或KPROCESS，EHTREAD或KTHREAD,SECTION 对象等，只要能能够跟进程扯上关系的，一个也不放过，研究这些成为了大家的最爱。而后驱动也想通过类似的方法来隐藏自己，即通过断掉LDR_DATA_TABLE_ENTRY的驱动加载链表，以使利用ZwQuerySystemInformation的11号功能枚举驱动失效。但是又可以打开驱动对象目录查找驱动的方法来检测到断这种链表的隐藏驱动。而邪恶者们又能够通过断掉目录对象的的hash链来自我隐身，当然一旦这种技术爆料后，我们又有新的方法来搜索——搜索TypeList来搜索隐藏驱动，不过这种方法有个缺点，需要当NtGlobalFlag设置了MaintainTypeList标志时，此链表才有效。到这里，你自然能够想到断掉此链来攻击。我们也不能够束手就擒呀，战争任在继续....

  最后我们自然想到了暴搜，暴力搜索DRIVER_OBJECT，这种方法能够很有效地检测出以上的各种方法隐藏的驱动。当然还可以通过搜索内存中的PE镜像来搜索，不过没有绝对有效的方法，暴搜驱动对象和PE镜像任然不能够检测到通过抹掉驱动对象和抹掉PE头，或者伪造驱动对象和PE头的rootkit。自然还有一些好的方法来检测，如内存搜索FileObject，SectionObject等等。
  
  好了，废话完了，回到主题吧，百度，谷歌上找了一下暴搜驱动可是没有找到一个完整的，于是就自己来实现了。原来也是如此的简单，估计大牛们要笑话了。不过为了学习交流，我也讲讲吧，不过初学者一个，可能有错误的地方，为了不至于误人子弟，望大牛尽快指出。

  要暴力搜索驱动对象，自然关注的焦点是驱动对象的结构，只要会驱动编程的人，对此也再熟悉不过了。NTDDK.H中有，我从windbg上dump下来这个结构：

1. // nt!_DRIVER_OBJECT
   
2. // +0x000 Type             : Int2B
   
3. // +0x002 Size             : Int2B
   
4. // 0x004 DeviceObject     : Ptr32 _DEVICE_OBJECT
   
5. // 0x008 Flags            : Uint4B
   
6. // +0x00c DriverStart      : Ptr32 Void
   
7. // +0x010 DriverSize       : Uint4B
   
8. // +0x014 DriverSection    : Ptr32 Void
   
9. // +0x018 DriverExtension  : Ptr32 _DRIVER_EXTENSION
   
10. // +0x01c DriverName       : _UNICODE_STRING
    
11. // +0x024 HardwareDatabase : Ptr32 _UNICODE_STRING
    
12. // +0x028 FastIoDispatch   : Ptr32 _FAST_IO_DISPATCH
    
13. // +0x02c DriverInit       : Ptr32     long
    
14. // +0x030 DriverStartIo    : Ptr32     void
    
15. // +0x034 DriverUnload     : Ptr32     void
    
16. // +0x038 MajorFunction    : [28] Ptr32     long

复制代码

既然我们要在内存中搜索驱动对象，那么我们必须找出几乎所有驱动的_DRIVER_OBJECT都具备的共有特征，以此来准确地识别出此内存段是否是合法的驱动对象。以上用红色标记的是我们要作为驱动对象标记的成员，我们来看看这些成员：

Type:标识对象的类型，其值为04;

size:驱动对象的大小，其值为0xA8;

DriverStart:其值表示驱动pe映像的基地址,因为驱动的映像必定处于高端内存，所以不能小于0X80000000或空，同时它的值必须是8的倍数;

DriverSize:表示驱动的大小，其值不能为0；

DriverSection:驱动节，其实是一个指向LDR_DATA_TABLE_ENTRY结构的指针，此结构也必在高端内存，也不能小于0X80000000；

就这几条，足够我们唯一标示驱动对象了，我想也应该不难的写出辨别出驱动对象的代码来，代码如下：

1. BOOLEAN IsRealDriver( ULONG pAddr )
   
2. {
   
3.    PDRIVER_OBJECT pTempDriver;
   
4.    pTempDriver=(PDRIVER_OBJECT)pAddr;
   
5. 
   
6.     if(*(ULONG *)pAddr!=0x00A80004)//将类型和大小一起验证
   
7.     {
   
8.       return FALSE;
   
9.     }
   
10.    if (pTempDriver->DriverSize==0)
    
11.    {
    
12.      return FALSE;
    
13.    }
    
14.    if (/*pTempDriver->DriverStart==NULL||没有必要*/(ULONG)(pTempDriver->DriverStart)<0x80000000)
    
15.    {
    
16.      return FALSE;
    
17.    }
    
18.    if ((ULONG)pTempDriver->DriverSection<0x80000000)
    
19.    {
    
20.      return FALSE;
    
21.    }
    
22.   if (((ULONG)(pTempDriver->DriverStart)&7)!=0)
    
23.   {
    
24.     return FALSE;
    
25.   }
    
26.   return TRUE;
    
27. }

复制代码

很简单吧，接下来我们应该确定如何来搜索内存，自然我们要从高端内存开始搜了。关于搜索范围，根据我的观察，驱动对象几乎都在0x8000000到0x82000000之间，当然如果要想快速的话，就只搜索这段内存，如果想要保险的话，还是0x8000000-0xfffff000都搜索下吧，这里我还是把所有高端内存都搜一下。

  为了能尽快地进行搜索，关于地址的验证，我用了网上的一段用于搜索隐藏进程的地址验证代码来验证，另外由于我们的对象的地址是8字节对齐的，因而可以以8为增量搜索。当我们搜到了对象，那就好办了，我原本想直接通过对象中的DriverName来显示驱动名，可是好像大部分的驱动名要么没有后缀，要么名字后面出现乱码（在我的另一个查看系统内核对象的工具中也出现类似的情况，希望哪位大牛有好的解决方法），但是这里无关紧要，我们还有DriverSection呢，他指向一个LDR_DATA_TABLE_ENTRY的结构，大家也再熟悉不过了，定义在代码中，我也不废话了，估计大家也嫌我啰嗦，再说，就要飞砖头了（就这点东东，还这么多废话，我仍....）。

基本的思路就这么简单，与菜鸟们共同学习交流，我也是菜菜儿，不足之处望大家指出。

其中的函数
ULONG IsValidAddr( ULONG uAddr );
是完全照抄过来的，实现代码如下（在xp sp3上测试通过）：

1. #include <ntddk.h>
   
2. #define  VALID_PAGE 1
   
3. #define  INVALID_PAGE 0
   
4. #define  PDEINVALID 2
   
5. #define  PTEINVALID 3
   
6. typedef struct _LDR_DATA_TABLE_ENTRY {
   
7.   LIST_ENTRY InLoadOrderLinks;
   
8.   LIST_ENTRY InMemoryOrderLinks;
   
9.   LIST_ENTRY InInitializationOrderLinks;
   
10.     PVOID DllBase;
    
11.     PVOID EntryPoint;
    
12.     ULONG SizeOfImage;
    
13.     UNICODE_STRING FullDllName;
    
14.     UNICODE_STRING BaseDllName;
    
15.     ULONG Flags;
    
16.     USHORT LoadCount;
    
17.     USHORT TlsIndex;
    
18.     union {
    
19.     LIST_ENTRY HashLinks;
    
20.     struct {
    
21.             PVOID SectionPointer;
    
22.             ULONG CheckSum;
    
23.     };
    
24.   };
    
25.     union {
    
26.     struct {
    
27.             ULONG TimeDateStamp;
    
28.     };
    
29.     struct {
    
30.             PVOID LoadedImports;
    
31.     };
    
32.   };
    
33.   //struct _ACTIVATION_CONTEXT * EntryPointActivationContext;
    
34.   PVOID EntryPointActivationContext;
    
35.     PVOID PatchInformation;
    
36. } LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;
    
37. 
    
38. typedef struct _DRIVER_ARRAY
    
39. {
    
40.   PVOID pDriverStart;
    
41.   PVOID DllBase;
    
42.   ULONG SizeOfImage;
    
43. }DRIVER_ARRAY,*PDRIVER_ARRAY;
    
44. 
    
45. int number=0;
    
46. BOOLEAN IsRealDriver( ULONG pAddr);
    
47. ULONG IsValidAddr( ULONG uAddr);
    
48. void ShowHidedDriver();
    
49. void UnLoad( PDRIVER_OBJECT pDriverObject )
    
50. {
    
51.   DbgPrint("Driver Unload..\n");
    
52. }
    
53. NTSTATUS DriverEntry( PDRIVER_OBJECT pDriverObject, PUNICODE_STRING pRegPath )
    
54. {
    
55.   NTSTATUS Status = STATUS_SUCCESS;
    
56.   pDriverObject->DriverUnload = UnLoad;
    
57.   KdPrint(("Driver object Address:0x%08x\n",pDriverObject));
    
58.   KdPrint(("CURRENT DRIVER %S\n",pDriverObject->DriverName.Buffer));
    
59.   ShowHidedDriver();
    
60.   return Status;
    
61. }
    
62. //以下这个函数抄的网上的，直接拿来主义....
    
63. ULONG IsValidAddr( ULONG uAddr )
    
64. {
    
65.   ULONG uInfo;
    
66.   ULONG uCr4;
    
67.   ULONG uPdeAddr;
    
68.   ULONG uPteAddr;
    
69.   _asm
    
70.   {
    
71.     cli
    
72.     push eax
    
73. 
    
74.     _emit 0x0F
    
75.     _emit 0x20
    
76.     _emit 0xE0//mov eax,cr4
    
77. 
    
78.     mov [uCr4], eax
    
79.     pop eax
    
80.   }
    
81. 
    
82.   _asm sti
    
83. 
    
84.   uInfo = uCr4 & 0x20;
    
85.   if( uInfo != 0 )
    
86.   {
    
87.     uPdeAddr = (uAddr>>21)*8+0xC0600000;
    
88.   }
    
89.   else
    
90.     uPdeAddr = (uAddr>>22)*4+0xc0300000;
    
91.   if( (*(PULONG)uPdeAddr & 0x1) != 0 )
    
92.   {
    
93.     if( (*(PULONG)uPdeAddr & 0x80) != 0 )
    
94.     {
    
95.       return VALID_PAGE;
    
96.     }
    
97.     else
    
98.     {
    
99.       if( uInfo != 0 )
    
100.       {
     
101.         uPteAddr = (uAddr>>12)*8+0xc0000000;
     
102.       }
     
103.       else
     
104.       {
     
105.         uPteAddr = (uAddr>>12)*4+0xc0000000;
     
106.       }
     
107. 
     
108.       if( (*(PULONG)uPteAddr & 0x1) != 0 )
     
109.         return VALID_PAGE;
     
110.       else
     
111.         return PTEINVALID;
     
112.     }
     
113.   }
     
114.   else
     
115.     return PDEINVALID;
     
116. 
     
117. }
     
118. //判定是否是真正的驱动结构
     
119. BOOLEAN IsRealDriver( ULONG pAddr )
     
120. {
     
121.    PDRIVER_OBJECT pTempDriver;
     
122.    pTempDriver=(PDRIVER_OBJECT)pAddr;
     
123. 
     
124.     if(*(ULONG *)pAddr!=0x00A80004)//类型和大小一起验证了
     
125.     {
     
126.       return FALSE;
     
127.     }
     
128.    if (pTempDriver->DriverSize==0)//驱动大小不能为0
     
129.    {
     
130.      return FALSE;
     
131.    }
     
132.    if (/*pTempDriver->DriverStart==NULL||可以不要*/(ULONG)(pTempDriver->DriverStart)<0x80000000)
     
133.    {
     
134.      return FALSE;
     
135.    }
     
136.    if ((ULONG)pTempDriver->DriverSection<0x80000000)
     
137.    {
     
138.      return FALSE;
     
139.    }
     
140.   if (((ULONG)(pTempDriver->DriverStart)&7)!=0)
     
141.   {
     
142.     return FALSE;
     
143.   }
     
144.   return TRUE;
     
145. }
     
146. void ShowHidedDriver()
     
147. {
     
148.   ULONG uStartAddr = 0x80000000;
     
149.   ULONG PEStart;
     
150.   PDRIVER_OBJECT TempDriver;
     
151.   PLDR_DATA_TABLE_ENTRY Ldr = NULL;
     
152.   ULONG Count = 0;
     
153.   KdPrint(("show Information.....\n"));
     
154.   for(; uStartAddr<=(ULONG)0xfffff000;uStartAddr+=8)
     
155.   {
     
156.     ULONG uRet = IsValidAddr( uStartAddr );
     
157.     if( uRet == VALID_PAGE)
     
158.     {
     
159.       if(IsRealDriver(uStartAddr))
     
160.       {
     
161.         KdPrint(("Driver object Address:0x%08x\n",uStartAddr));
     
162.         TempDriver=(PDRIVER_OBJECT)uStartAddr;
     
163.         Ldr = (PLDR_DATA_TABLE_ENTRY)TempDriver->DriverSection;
     
164.         if ( MmIsAddressValid(Ldr) )
     
165.         {
     
166.           DbgPrint("DriveName : %S\n",Ldr->FullDllName.Buffer);
     
167.           DbgPrint("ImageBase : 0x%08X.\n",Ldr->DllBase);
     
168.           DbgPrint("ImageSize : 0x%08X.\n",Ldr->SizeOfImage);
     
169.           DbgPrint("EntryPoint : 0x%08X.\n",Ldr->EntryPoint);
     
170.           DbgPrint("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
     
171.           Count++;
     
172.         }
     
173.         uStartAddr+=sizeof(DRIVER_OBJECT);
     
174.       }
     
175.     }
     
176.     else if( uRet == PDEINVALID )
     
177.     {
     
178.       uStartAddr-=8;
     
179.       uStartAddr += 0x400000;
     
180.     }
     
181.     else
     
182.     {
     
183.       uStartAddr-=8;
     
184.       uStartAddr += 0x1000;
     
185.     }
     
186.    
     
187.   }
     
188.   DbgPrint("Driver Number %d",Count);
     
189. }

复制代码

到此，一切都完成了，如果你感觉不保险的话，就验证一下PE头,其中DriverStart就是基址。
代码比较简单，我都没有做多少注释，我想应该讲清楚了吧。