HOOK NtCreateSection （另类阻止驱动加载）

jinfu

原作者： czcqq ，我只是应用在VB上了。





作者原文:对于 在WINDOWS启动的时候加载 和 感染系统文件 我们暂时不讨论，玩么只讨论动态加载


一般的加载流程，是这样的:打开服务管理器->创建服务->启动服务->(系统加载驱动)
这个过程系统最终会调用NtLoadDriver来加载驱动(也可以用Ntdll.dll里面的NtSetSystemInformation来加载)


而NtLoadDriver 会向系统插入一个作业，然后等待另外一个系统线程来加载驱动，并等待驱动的加载完成(NtSetSystemInformation也是一样的)，然后返回
这样我们就可以HOOK NtLoadDriver和NtSetSystemInformation来阻止驱动加载，但是这个方法已经用烂了，这里我HOOK NtCreateSection来阻止驱动加载
为什么HOOK NtCreateSection呢？？？
因为在另外一个线程取得消息加载驱动的时候会调用NtCreateSection来映射驱动到内核内存空间



(流程:大概是这样 IoCreateFile(打开驱动文件，将它的第二个参数设置为FILE_EXECUTE | SYNCHRONIZE) -> NtCreateSection(为驱动在内核内存空间创建一个节) ->NtMapViewOfSection(映射驱动到内核内存空间) -> 寻找驱动的DriverEntry，并调用 -> ZwClose(关闭文件句柄) ->然后通知NtLoadDriver(或者NtSetSystemInformation)驱动加载完成->NtLoadDriver(或者NtSetSystemInformation)返回用户层，并通知用户驱动加载完成)


在驱动加载流程中，我们可以看到我们有很多机会劫持驱动的加载
我们可以HOOK NtCreateSection 或者 NtMapViewOfSection 来阻止驱动加载
这里我采用HOOK NtCreateSection的办法阻止驱动加载

以下为驱动代码:

1. #include <ntifs.h>
   
2. 
   
3. //声明用到的头文件和结构 宏等
   
4. #include "NtCreateSection.h"
   
5. #if DBG
   
6. #define DriversUnload(Address, p) \
   
7. Address->DriverUnload=p;
   
8. #else
   
9. #define DriversUnload(Address, p) \
   
10. Address->DriverUnload=NULL;
    
11. #endif
    
12. typedef int BOOL;
    
13. typedef unsigned int UINT;
    
14. typedef unsigned long DWORD;
    
15. typedef unsigned short WORD;
    
16. typedef void *LPVOID;
    
17. typedef unsigned char BYTE;
    
18. typedef DWORD *PDWORD;
    
19. typedef BYTE *PBYTE;
    
20. typedef WORD *PWORD;
    
21. #define PAGE_NOACCESS 0x01
    
22. #define PAGE_READONLY 0x02
    
23. #define PAGE_READWRITE 0x04
    
24. #define PAGE_WRITECOPY 0x08
    
25. #define PAGE_EXECUTE 0x10
    
26. #define PAGE_EXECUTE_READ 0x20
    
27. #define PAGE_EXECUTE_READWRITE 0x40
    
28. #define PAGE_EXECUTE_WRITECOPY 0x80
    
29. #define PAGE_GUARD 0x100
    
30. #define PAGE_NOCACHE 0x200
    
31. #define PAGE_WRITECOMBINE 0x400
    
32. #define MEM_COMMIT 0x1000
    
33. #define MEM_RESERVE 0x2000
    
34. #define MEM_DECOMMIT 0x4000
    
35. #define MEM_RELEASE 0x8000
    
36. #define MEM_FREE 0x10000
    
37. #define MEM_PRIVATE 0x20000
    
38. #define MEM_MAPPED 0x40000
    
39. #define MEM_RESET 0x80000
    
40. #define MEM_TOP_DOWN 0x100000
    
41. #define MEM_4MB_PAGES 0x80000000
    
42. #define SEC_FILE 0x800000
    
43. #define SEC_IMAGE 0x1000000
    
44. #define SEC_VLM 0x2000000
    
45. #define SEC_RESERVE 0x4000000
    
46. #define SEC_COMMIT 0x8000000
    
47. #define SEC_NOCACHE 0x10000000
    
48. #define MEM_IMAGE SEC_IMAGE
    
49. PVOID WriteAddress=NULL;
    
50. PMDL pMdl=NULL;
    
51. //声明所需要的函数
    
52. NTSYSAPI
    
53. NTSTATUS
    
54. NTAPI
    
55. ZwYieldExecution(
    
56. VOID
    
57. );
    
58. PVOID NTAPI GetJmpAddress(PVOID Fun,BOOL *Call_Code);
    
59. NTSTATUS
    
60. NTAPI
    
61. CallBack_NtCreateSection (
    
62. OUT PHANDLE SectionHandle,
    
63. IN ACCESS_MASK DesiredAccess,
    
64. IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
    
65. IN PLARGE_INTEGER MaximumSize OPTIONAL,
    
66. IN ULONG SectionPageProtection,
    
67. IN ULONG AllocationAttributes,
    
68. IN HANDLE FileHandle OPTIONAL
    
69. );
    
70. NTSTATUS
    
71. NTAPI
    
72. OldNtCreateSection (
    
73. OUT PHANDLE SectionHandle,
    
74. IN ACCESS_MASK DesiredAccess,
    
75. IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
    
76. IN PLARGE_INTEGER MaximumSize OPTIONAL,
    
77. IN ULONG SectionPageProtection,
    
78. IN ULONG AllocationAttributes,
    
79. IN HANDLE FileHandle OPTIONAL
    
80. );
    
81. void makejmp(LPVOID Fun1,LPVOID Fun2,LPVOID jmp);
    
82. #pragma alloc_text(PAGE,makejmp)
    
83. #pragma alloc_text(PAGE,OldNtCreateSection)
    
84. #pragma alloc_text(PAGE,CallBack_NtCreateSection)
    
85. #pragma alloc_text(PAGE,GetJmpAddress)
    
86. 
    
87. //所有声明结束
    
88. 
    
89. 
    
90. //驱动入口
    
91. 
    
92. NTSTATUS DriverEntry(
    
93. IN PDRIVER_OBJECT DriverObject,
    
94. IN PUNICODE_STRING RegistryPath
    
95. )
    
96. {
    
97. NTSTATUS Status = 0;
    
98. PDEVICE_OBJECT pDeviceObject = NULL;
    
99. //创建设备，这个就不讲解了，大家明白就好，我重点讲解HOOK过程
    
100. Status = IoCreateDevice(
     
101. DriverObject,
     
102. 0,
     
103. NULL,
     
104. FILE_DEVICE_UNKNOWN,
     
105. 0,
     
106. FALSE,
     
107. &pDeviceObject
     
108. );
     
109. 
     
110. if ( NT_SUCCESS(Status) ) {
     
111. KIRQL oldIrql;
     
112. PVOID HookAddress = NULL;
     
113. 
     
114. BOOL Hook=0;
     
115. PVOID JmpData=ExAllocatePool(NonPagedPool,5);//申请内存，用来保存内容为Jmp CallBack_NtCreateSection的代码
     
116. DriversUnload(DriverObject,Unload);//设置DriverObject->DriverUnload = Unload;这个宏只有在调试版本的时候才会设置
     
117. //DriverObject->DriverUnload = Unload;如果不是调试版本，就会设置DriverObject->DriverUnload = NULL;
     
118. if(JmpData==NULL)
     
119. {
     
120. DbgPrint("HOOK NtCreateSection失败! 内存申请失败\n");
     
121. return Status;
     
122. }
     
123. memset(JmpData,0x90,5);//初始化JmpData内容为NOP
     
124. //将NtCreateSection的头7个字节复制到OldNtCreateSection中来
     
125. pMdl=IoCreateWriteMdlForAddress(OldNtCreateSection,&WriteAddress,7);
     
126. if(pMdl==NULL)
     
127. {
     
128. DbgPrint("HOOK NtCreateSection失败! OldNtCreateSection 写入失败\n");
     
129. ExFreePool(JmpData);
     
130. JmpData=NULL;
     
131. WriteAddress=NULL;
     
132. pMdl=NULL;
     
133. return Status;
     
134. }
     
135. memcpy(WriteAddress,NtCreateSection,7);
     
136. IoFreeMdlForAddress(WriteAddress,pMdl);
     
137. WriteAddress=NULL;
     
138. //将NtCreateSection的头5字节变成可写
     
139. pMdl=IoCreateWriteMdlForAddress(NtCreateSection,&WriteAddress,7);
     
140. if(pMdl==NULL)
     
141. {
     
142. DbgPrint("HOOK NtCreateSection失败! NtCreateSection 写入失败\n");
     
143. ExFreePool(JmpData);
     
144. JmpData=NULL;
     
145. WriteAddress=NULL;
     
146. pMdl=NULL;
     
147. return Status;
     
148. }
     
149. //检查是否已经被别人HOOK，如果已经被别人HOOK则我们退出HOOK，这里是可以改进的，但是我没有时间写，只能退出HOOK
     
150. HookAddress=GetJmpAddress(NtCreateSection,&Hook);
     
151. if(HookAddress!=NULL)
     
152. {
     
153. DbgPrint("HOOK NtCreateSection失败! 发现NtCreateSection已经被别人HOOK 所以本HOOK退出\n");
     
154. ExFreePool(JmpData);
     
155. JmpData=NULL;
     
156. IoFreeMdlForAddress(WriteAddress,pMdl);
     
157. WriteAddress=NULL;
     
158. pMdl=NULL;
     
159. return Status;
     
160. }
     
161. //HOOK NtCreateSection
     
162. if(NT_SUCCESS(ZwYieldExecution()))//先向系统申请CPU时间
     
163. {
     
164. _asm cli//关闭中断
     
165. oldIrql = KeRaiseIrqlToDpcLevel();//提升到DPC级别
     
166. memset(WriteAddress,0x90,7);//修改NtCreateSection的前7个字节为NOP指令
     
167. makejmp(NtCreateSection,CallBack_NtCreateSection,JmpData);//取得 Jmp CallBack_NtCreateSection的代码，代码保存在JmpData中
     
168. memcpy(WriteAddress,JmpData,5);//修改NtCreateSection前5个字节为 Jmp CallBack_NtCreateSection
     
169. KeLowerIrql(oldIrql);//还原到原来的IRQL级别
     
170. _asm sti//开中断
     
171. 
     
172. }else
     
173. {
     
174. DbgPrint("申请CPU时间失败，HOOK退出\n");
     
175. }
     
176. ExFreePool(JmpData);
     
177. JmpData=NULL;
     
178. 
     
179. }
     
180. 
     
181. return Status;
     
182. }
     
183. 
     
184. //我们的NtCreateSection过滤函数
     
185. NTSTATUS
     
186. NTAPI
     
187. CallBack_NtCreateSection (
     
188. OUT PHANDLE SectionHandle,
     
189. IN ACCESS_MASK DesiredAccess,
     
190. IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
     
191. IN PLARGE_INTEGER MaximumSize OPTIONAL,
     
192. IN ULONG SectionPageProtection,
     
193. IN ULONG AllocationAttributes,
     
194. IN HANDLE FileHandle OPTIONAL
     
195. )
     
196. {
     
197. NTSTATUS Status = 0;
     
198. Status = OldNtCreateSection(
     
199. SectionHandle,
     
200. DesiredAccess,
     
201. ObjectAttributes ,
     
202. MaximumSize ,
     
203. SectionPageProtection,
     
204. AllocationAttributes,
     
205. FileHandle);
     
206. if ( NT_SUCCESS(Status) )
     
207. {
     
208. //进行行为判断,如果是要加载驱动，我们就直接返回错误，并关闭句柄,如果不是就返回原来的结果
     
209. if(((DWORD)PsGetCurrentProcessId()==(DWORD)4)|((DWORD)PsGetCurrentProcessId()==(DWORD)8)|((DWORD)PsGetCurrentProcessId()==(DWORD)0))
     
210. {
     
211. 
     
212. if((FlagOn(DesiredAccess,SECTION_MAP_EXECUTE))||(FlagOn(DesiredAccess,PAGE_EXECUTE_READ)))
     
213. if((PAGE_EXECUTE==SectionPageProtection)|(AllocationAttributes==SEC_IMAGE))
     
214. {
     
215. ZwClose(*SectionHandle);
     
216. *SectionHandle=NULL;
     
217. return STATUS_ACCESS_DENIED;
     
218. }
     
219. }
     
220. }
     
221. return Status;
     
222. }
     
223. //用来跳转到原函数的一个裸函数
     
224. __declspec(naked)NTSTATUS
     
225. NTAPI
     
226. OldNtCreateSection (
     
227. OUT PHANDLE SectionHandle,
     
228. IN ACCESS_MASK DesiredAccess,
     
229. IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
     
230. IN PLARGE_INTEGER MaximumSize OPTIONAL,
     
231. IN ULONG SectionPageProtection,
     
232. IN ULONG AllocationAttributes,
     
233. IN HANDLE FileHandle OPTIONAL
     
234. )
     
235. {
     
236. _asm
     
237. {
     
238. nop
     
239. nop
     
240. nop
     
241. nop
     
242. nop
     
243. nop
     
244. nop
     
245. nop
     
246. nop
     
247. nop
     
248. nop
     
249. nop
     
250. nop
     
251. nop
     
252. nop
     
253. nop
     
254. nop
     
255. nop
     
256. mov eax,NtCreateSection //将原函数地址送入eax
     
257. add eax,7 //eax加7，用来跳过我们的HOOK
     
258. push eax //将eax压入
     
259. ret //跳回原函数
     
260. }
     
261. }
     
262. 
     
263. //用来生成跳转代码的函数
     
264. void makejmp(LPVOID Fun1,LPVOID Fun2,LPVOID jmp)
     
265. {
     
266. BYTE *data=(BYTE *)jmp;
     
267. long dFun1=(long)Fun1;
     
268. long dFun2=(long)Fun2;
     
269. DWORD H;
     
270. data[0]=0xe9;
     
271. 
     
272. 
     
273. _asm
     
274. {
     
275. 
     
276. mov eax,dFun1
     
277. mov edx,dFun2
     
278. sub edx,eax
     
279. sub edx,5
     
280. mov H,edx
     
281. }
     
282. 
     
283. memcpy(&data[1],(void *)&H,4);
     
284. 
     
285. }
     
286. VOID Unload(
     
287. IN PDRIVER_OBJECT DriverObject
     
288. )
     
289. {
     
290. KIRQL oldIrql;
     
291. while(!NT_SUCCESS(ZwYieldExecution()))//取得CPU时间，如果取得失败，就一直获取，直到成功
     
292. {
     
293. }
     
294. if(pMdl!=NULL)//检查我们是否已经进行过HOOK，//如果我们进行过HOOK 就还原
     
295. {
     
296. oldIrql = KeRaiseIrqlToDpcLevel();
     
297. memcpy(WriteAddress,OldNtCreateSection,7);
     
298. KeLowerIrql(oldIrql);
     
299. IoFreeMdlForAddress(WriteAddress,pMdl);
     
300. }
     
301. IoDeleteDevice(DriverObject->DeviceObject);//删除设备
     
302. 
     
303. pMdl=NULL;
     
304. WriteAddress=NULL;
     
305. }
     
306. PVOID NTAPI GetJmpAddress(PVOID Fun,BOOL *Call_Code)
     
307. {
     
308. PVOID Return=NULL;
     
309. BYTE *data=(BYTE *)Fun;
     
310. DWORD Old=0;
     
311. if(data[0]==0xe9)
     
312. {
     
313. *Call_Code=0;
     
314. }else if (data[0]==0xe8)
     
315. {
     
316. *Call_Code=1;
     
317. }else
     
318. {
     
319. *Call_Code=2;
     
320. return NULL;
     
321. }
     
322. 
     
323. memcpy((void *)&Old,&data[1],4);
     
324. _asm
     
325. {
     
326. mov eax,Old
     
327. mov edx,Fun
     
328. add eax,edx
     
329. add eax,5
     
330. mov Return,eax
     
331. }
     
332. return Return;
     
333. }

复制代码

这个驱动只支持单核心CPU 多核心CPU请自行修改（将所有CPU都提升到DPC级别 以后再进行HOOK）驱动加载流程是看了WIN2K的代码来讲的，WIN2K的代码很长，所以就简单的讲了一下

Tesla.Angela

LZ现在做的事跟我三年前做的事差不多，天天拿别人写的驱动玩。。。

不过也支持一下，毕竟我也是这么过来的。

Tesla.Angela

sb666 发表于 2012-4-23 18:09
晕死……这不是修改了一个加载方式而已吗？ 额……
我还能改成bat呢……调用debug就ok……

MmCheckSystemImage拦截更爽，能肯定得到驱动文件的路径。

可惜得到的PID一定是4。

最不爽的是，此函数在WIN7上返回失败会蓝。。。不知道怎么回事。。。

watchsky

支持下，hook这个函数也可以监控进程的创建，不过说实话不算另类，老技术了。另外通过IoCreateDriver这种函数创建的无映像驱动也未必能拦截。

diddom

偶也來學習{:soso_e113:}

Xor

Tesla.Angela 发表于 2012-4-23 20:34
MmCheckSystemImage拦截更爽，能肯定得到驱动文件的路径。

可惜得到的PID一定是4。

最不爽的是，此函数在WIN7上返回失败会蓝。。。不知道怎么回事。。。

在VISTA今后的操作系统，系统利用MmLoadSystemImage加载驱动之前，会挪用MmCheckSystemImage函数来检查镜像准确性，在VISTA及今后的操作系统中，MmCheckSystemImage发生了一个有意思的转变.
　　原本MmCheckSystemImage(vista以前的系统上)，会利用SEC_IMAGE作为AllocationAttributes来挪用ZwCreateSection为驱动文件建立Section，可是VISTA今后的系统上，该参数被换成了一个未公开的值: 0x100000(注重,SEC_IMAGE是0x1000000，6个0)。

这大概就是蓝的原因吧