驱动DLL注入源码

爱民

您可以在此找到代码。注:你需要编写NtProcDrv NTDDK被安装在您的计算机上。运行编译样品,地方tunew20。在任意的文件夹,dll的时候,在路径被指定变量(窗口/ system32的例子)。然后就跑HookDemo.exe。 开始后,所有进程创建程序被截取。按“输入”键和钩将被卸掉。注:你应该有一个管理员权限的合理运行的应用程序。
如果它很管用来验证后尝试启动任何应用HookDemo已经跑了。你应该看看消息框”开始之前的过程。“在启动过程和“在结束。“权利之前的过程将会结束。

1. #include <ntddk.h>
   
2. #include "Undocumented.h"
   
3. #include "NTProcDrv.h"
   
4. #include "DrvUtils.h"
   
5. 
   
6. 
   
7. 
   
8. PDEVICE_OBJECT g_pDeviceObject = NULL;
   
9. 
   
10. //
    
11. // The main entry point of the driver module
    
12. //
    
13. NTSTATUS __stdcall DriverEntry(
    
14.         IN PDRIVER_OBJECT DriverObject,
    
15.         IN PUNICODE_STRING RegistryPath
    
16.         )
    
17. {
    
18.     NTSTATUS        ntStatus;
    
19.     UNICODE_STRING  uszDriverString;
    
20.     UNICODE_STRING  uszDeviceString;
    
21. 
    
22.     PDEVICE_OBJECT    pDeviceObject;
    
23.     PDEVICE_EXTENSION extension;
    
24.    
    
25.         DBGPRINT(("In DriverEntry\n"));
    
26.         
    
27.         // Point uszDriverString at the driver name
    
28.     RtlInitUnicodeString(&uszDriverString, uszDriverName);
    
29. 
    
30.     // Create and initialize device object
    
31.     ntStatus = IoCreateDevice(
    
32.                 DriverObject,
    
33.         sizeof(DEVICE_EXTENSION),
    
34.         &uszDriverString,
    
35.         FILE_DEVICE_UNKNOWN,
    
36.         0,
    
37.         FALSE,
    
38.         &pDeviceObject
    
39.                 );
    
40.     if(ntStatus != STATUS_SUCCESS)
    
41.         return ntStatus;
    
42.    
    
43.         // Assign extension variable
    
44.     extension = pDeviceObject->DeviceExtension;
    
45.         RtlZeroMemory(&extension->AddrInfo,sizeof(CAddrInfo));
    
46.    
    
47.         // Point uszDeviceString at the device name
    
48.     RtlInitUnicodeString(&uszDeviceString, uszDeviceName);
    
49.    
    
50.         // Create symbolic link to the user-visible name
    
51.     ntStatus = IoCreateSymbolicLink(&uszDeviceString, &uszDriverString);
    
52. 
    
53.     if(ntStatus != STATUS_SUCCESS)
    
54.     {
    
55.         // Delete device object if not successful
    
56.         IoDeleteDevice(pDeviceObject);
    
57.         return ntStatus;
    
58.     }
    
59. 
    
60.     // Assign global pointer to the device object for use by the callback functions
    
61.     g_pDeviceObject = pDeviceObject;
    
62. 
    
63.     // Load structure to point to IRP handlers
    
64.     DriverObject->DriverUnload                         = UnloadDriver;
    
65.     DriverObject->MajorFunction[IRP_MJ_CREATE]         = DispatchCreateClose;
    
66.     DriverObject->MajorFunction[IRP_MJ_CLOSE]          = DispatchCreateClose;
    
67.     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchIoctl;
    
68. 
    
69. 
    
70.         if (InitializeMemoryPool()==STATUS_SUCCESS)
    
71.         {
    
72.                 DBGPRINT(("Memory for Pool successfully initialized\n"));
    
73.         }
    
74.         else
    
75.         {
    
76.                 DBGPRINT(("Memory Pool Initialization failed\n"));
    
77.         }
    
78. 
    
79.     // Return success
    
80.     return ntStatus;
    
81. }
    
82. 
    
83. //
    
84. // Create and close routine
    
85. //
    
86. NTSTATUS DispatchCreateClose(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
    
87. {
    
88.     Irp->iOStatus.Status = STATUS_SUCCESS;
    
89.     Irp->IoStatus.Information=0;
    
90. 
    
91.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
    
92.     return STATUS_SUCCESS;
    
93. }
    
94. 
    
95. 
    
96. NTSTATUS DispatchIoctl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
    
97. {
    
98.     NTSTATUS              ntStatus = STATUS_UNSUCCESSFUL;
    
99.     PIO_STACK_LOCATION    irpStack  = IoGetCurrentIrpStackLocation(Irp);
    
100.     PDEVICE_EXTENSION     extension = DeviceObject->DeviceExtension;
     
101.     PAddrInfo        pAddrInfo;
     
102.         
     
103.         //
     
104.     // These IOCTL handlers get the current data out of the device
     
105.     // extension structure.  
     
106.         //
     
107.     switch(irpStack->Parameters.DeviceIoControl.IoControlCode)
     
108.     {
     
109.         case IOCTL_NTPROCDRV_SET_ADDRNFO:
     
110.                         if (irpStack->Parameters.DeviceIoControl.InputBufferLength>= sizeof(CAddrInfo))
     
111.                         {
     
112.                                 DBGPRINT(("receiving IOCTL_NTPROCDRV_SET_ADDRNFO ok!\n"));
     
113. 
     
114.                                 pAddrInfo = Irp->AssociatedIrp.SystemBuffer;
     
115. 
     
116.                                 if (pAddrInfo->isInitialized)
     
117.                                 {
     
118. 
     
119.                                         extension->AddrInfo.SSTIndexNtCreateProcess = pAddrInfo->SSTIndexNtCreateProcess;
     
120.                                         extension->AddrInfo.SSTIndexNtCreateThread = pAddrInfo->SSTIndexNtCreateThread;
     
121.                                         extension->AddrInfo.SSTIndexNtTerminateProcess = pAddrInfo->SSTIndexNtTerminateProcess;
     
122.                                         extension->AddrInfo.pfnLoadLibrary = pAddrInfo->pfnLoadLibrary;
     
123.                                         extension->AddrInfo.SSTIndexNtCreateProcessEx = pAddrInfo->SSTIndexNtCreateProcessEx;
     
124.                                         extension->AddrInfo.isInitialized = TRUE;
     
125. 
     
126.                                         DBGPRINT(("Trying to hook srvices\n"));
     
127.                                         HookServices(&extension->AddrInfo, extension->isHookedState);
     
128.                                         extension->isHookedState = TRUE;
     
129.                                 }
     
130.                                 else
     
131.                                 {
     
132.                                         DBGPRINT(("Trying to unhook srvices\n"));
     
133.                                         UnHookServices(&extension->AddrInfo,extension->isHookedState);
     
134.                                         extension->isHookedState = FALSE;
     
135.                                         RtlZeroMemory(&extension->AddrInfo,sizeof(CAddrInfo));
     
136.                                 }
     
137. 
     
138.                                 ntStatus = STATUS_SUCCESS;
     
139. 
     
140.                         }
     
141.             break;
     
142.         default:
     
143.             break;
     
144.     }
     
145. 
     
146.     Irp->IoStatus.Status = ntStatus;
     
147.    
     
148.     Irp->IoStatus.Information = 0;
     
149. 
     
150.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
151.     return ntStatus;
     
152. }
     
153. 
     
154. 
     
155. //
     
156. // Driver unload routine
     
157. //
     
158. void UnloadDriver(IN PDRIVER_OBJECT DriverObject)
     
159. {
     
160.     UNICODE_STRING  uszDeviceString;
     
161.         PDEVICE_EXTENSION extension = DriverObject->DeviceObject->DeviceExtension;
     
162. 
     
163.         UnHookServices(&extension->AddrInfo,extension->isHookedState);
     
164. 
     
165.         UnitializeMemoryPool();
     
166. 
     
167. 
     
168.     IoDeleteDevice(DriverObject->DeviceObject);
     
169. 
     
170.     RtlInitUnicodeString(&uszDeviceString, uszDeviceName);
     
171.     IoDeleteSymbolicLink(&uszDeviceString);
     
172. }
     
173. 
     
174. 
     
175. NTSTATUS NewNtCreateProcess(
     
176.     OUT PHANDLE ProcessHandle,
     
177.     IN ACCESS_MASK DesiredAccess,
     
178.     IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
     
179.     IN HANDLE ParentProcess,
     
180.     IN BOOLEAN InheritObjectTable,
     
181.     IN HANDLE SectionHandle OPTIONAL,
     
182.     IN HANDLE DebugPort OPTIONAL,
     
183.     IN HANDLE ExceptionPort OPTIONAL
     
184.     )
     
185. {
     
186.         NTSTATUS ResultStatus;
     
187. 
     
188.         DBGPRINT(("In NtCreateProcess\n"));
     
189. 
     
190.         
     
191.         ResultStatus = OldNtCreateProcess(
     
192.             ProcessHandle,
     
193.             DesiredAccess,
     
194.                 ObjectAttributes,
     
195.                 ParentProcess,
     
196.                 InheritObjectTable,
     
197.                 SectionHandle,
     
198.                 DebugPort ,
     
199.                 ExceptionPort);
     
200. 
     
201.         
     
202. 
     
203.         if (ResultStatus==STATUS_SUCCESS)
     
204.         {
     
205. 
     
206.                 DBGPRINT(("Kernel successfully create NtCreateProcess.\n----->ProcessHandle = 0x%x\n",*ProcessHandle));
     
207.             
     
208.                 if (SetNewProcessInfo(*ProcessHandle)==STATUS_SUCCESS)
     
209.                 {
     
210.                         DBGPRINT(("Successfully added process handle to Queue\n"));
     
211.                 }
     
212.                 else
     
213.                 {
     
214.                         DBGPRINT(("Unable to add process handle to Queue\n"));
     
215.                 }
     
216.         }
     
217. 
     
218.         return ResultStatus;
     
219. 
     
220. }
     
221. 
     
222. NTSTATUS NewNtCreateProcessEx(
     
223.     OUT PHANDLE ProcessHandle,
     
224.     IN ACCESS_MASK DesiredAccess,
     
225.     IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
     
226.     IN HANDLE ParentProcess,
     
227.     IN BOOLEAN InheritObjectTable,
     
228.     IN HANDLE SectionHandle OPTIONAL,
     
229.     IN HANDLE DebugPort OPTIONAL,
     
230.     IN HANDLE ExceptionPort OPTIONAL,
     
231.     IN HANDLE Unknown )
     
232. {
     
233.         NTSTATUS ResultStatus;
     
234. 
     
235.         DBGPRINT(("In NtCreateProcessEx\n"));
     
236.         
     
237.         ResultStatus = OldNtCreateProcessEx(
     
238.             ProcessHandle,
     
239.             DesiredAccess,
     
240.                 ObjectAttributes,
     
241.                 ParentProcess,
     
242.                 InheritObjectTable,
     
243.                 SectionHandle,
     
244.                 DebugPort ,
     
245.                 ExceptionPort,
     
246.                 Unknown);
     
247. 
     
248.         
     
249. 
     
250.         if (ResultStatus==STATUS_SUCCESS)
     
251.         {
     
252. 
     
253.                 DBGPRINT(("Kernel successfully create NtCreateProcessEx.\n----->ProcessHandle = 0x%x\n",*ProcessHandle));
     
254.             
     
255.                 if (SetNewProcessInfo(*ProcessHandle)==STATUS_SUCCESS)
     
256.                 {
     
257.                         DBGPRINT(("Successfully added process handle to Queue\n"));
     
258.                 }
     
259.                 else
     
260.                 {
     
261.                         DBGPRINT(("Unable to add process handle to Queue\n"));
     
262.                 }
     
263.         }
     
264. 
     
265.         return ResultStatus;
     
266. }
     
267. 
     
268. 
     
269. NTSTATUS NewNtCreateThread(
     
270.     OUT PHANDLE ThreadHandle,
     
271.     IN ACCESS_MASK DesiredAccess,
     
272.     IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
     
273.     IN HANDLE ProcessHandle,
     
274.     OUT PCLIENT_ID ClientId,
     
275.     IN PCONTEXT ThreadContext,
     
276.     IN PINITIAL_TEB InitialTeb,
     
277.     IN BOOLEAN CreateSuspended)
     
278. {
     
279.         NTSTATUS ResultStatus;
     
280. 
     
281. #pragma message("must verify user mode parameters before using")
     
282. 
     
283.         if (
     
284.                 ThreadContext &&
     
285.                 CreateSuspended &&
     
286.                 ProcessHandle &&
     
287.                 ProcessHandle!=(void *)0xffffffff &&
     
288.                 FindLockProcessInQueue(ProcessHandle)
     
289.                 )
     
290.         {
     
291. 
     
292.                 //kernel creates thread
     
293.                 //trying to get PEPROCESS
     
294. 
     
295.                 NTSTATUS ObjectStatus;
     
296.                 PEPROCESS pProcess;
     
297.                 POBJECT_TYPE PsProcessType;
     
298. 
     
299.                 DBGPRINT(("Kernel trying to CreateThread(from User Mode) for ProcessHandle = 0x%X\n",ProcessHandle));
     
300. 
     
301.                 PsProcessType = NULL;
     
302.                 ObjectStatus = ObReferenceObjectByHandle(
     
303.                         ProcessHandle,
     
304.                         PROCESS_ALL_ACCESS,
     
305.                         PsProcessType,
     
306.                         UserMode,
     
307.                         (PVOID *)&pProcess,
     
308.                         NULL);
     
309.                 if (ObjectStatus!=STATUS_SUCCESS)
     
310.                 {
     
311.                         DBGPRINT(("Fail to RefernceObject. Stopping Injecting Technique.\n"));
     
312.                 }
     
313.                 else
     
314.                 {
     
315.                         NTSTATUS AllocStatus;
     
316.                         UCHAR * BaseAddr;
     
317.                         SIZE_T RegionSize;
     
318.                         ULONG Win32StartAddr;
     
319.                         ULONG LoadLibraryAddr;
     
320. 
     
321.                         RegionSize = 100;
     
322.                         BaseAddr = NULL;
     
323.                         PsProcessType = NULL;
     
324. 
     
325.                         LoadLibraryAddr = (ULONG)((PDEVICE_EXTENSION)g_pDeviceObject->DeviceExtension)->AddrInfo.pfnLoadLibrary;
     
326.                         DBGPRINT(("Address of LoadLibraryW = 0x%08X\n",LoadLibraryAddr));
     
327. 
     
328. 
     
329.                         if (ThreadContext)
     
330.                         {
     
331.                                 //remembering value of ThreadContext->Eax
     
332.                                 //it contains process staring address in user mode
     
333. 
     
334.                                 Win32StartAddr = ThreadContext->Eax;
     
335.                                 
     
336.                                 if (!Win32StartAddr)
     
337.                                 {
     
338.                                         DBGPRINT(("--------------Win32StartAddr not set--------------------\n"));
     
339.                                 }
     
340.                                 else
     
341.                                 {
     
342. 
     
343.                                         //"jumping" to context of new process
     
344.                                         KeDetachProcess();
     
345.                                         KeAttachProcess((void *)pProcess);
     
346. 
     
347.                                         //allocating memory with PAGE_EXECUTE_READWRITE access rights
     
348. 
     
349.                                         AllocStatus = ZwAllocateVirtualMemory(
     
350.                                                 NtCurrentProcess(),
     
351.                                                 &BaseAddr,
     
352.                                                 0,
     
353.                                                 &RegionSize,
     
354.                                                 MEM_COMMIT        ,
     
355.                                                 PAGE_EXECUTE_READWRITE);
     
356.                                         if (AllocStatus!=STATUS_SUCCESS)
     
357.                                         {
     
358.                                                 DBGPRINT(("---------------Fail to Allocate memory! AllocStatus = 0x%x\n",AllocStatus));
     
359.                                         }
     
360.                                         else
     
361.                                         {
     
362.                                                 ULONG Offset = 0;
     
363.                                                 ULONG OffsetStrAddr = 0;
     
364. 
     
365.                                                 DBGPRINT(("---------------Memory allocation OK! BaseAddr = 0x%x\n",BaseAddr));
     
366. 
     
367.                                                 BaseAddr[Offset] = 0x68; //push
     
368.                                                 ++Offset;
     
369.                                                 OffsetStrAddr = Offset;
     
370.                                                 Offset += 4; //reserving 4 byte for string address. will be filled late
     
371. 
     
372.                                                 BaseAddr[Offset] = 0xbb; //mov ebx,LoadLibraryAddr
     
373.                                                 ++Offset;
     
374. 
     
375.                                                 *(ULONG *)(BaseAddr+Offset) = LoadLibraryAddr;
     
376.                                                 Offset += 4;
     
377. 
     
378.                                                 BaseAddr[Offset] = 0xff; //call ebx
     
379.                                                 ++Offset;
     
380.                                                 BaseAddr[Offset] = 0xd3;
     
381.                                                 ++Offset;
     
382. 
     
383.                                                 BaseAddr[Offset] = 0xb8;                                                 //mov eax,Win32StartAddr
     
384.                                                 ++Offset;
     
385.                                                 *(ULONG *)(BaseAddr+Offset) = Win32StartAddr;
     
386.                                                 Offset += 4;
     
387. 
     
388.                                                 BaseAddr[Offset] = 0x50; //push eax
     
389.                                                 ++Offset;
     
390. 
     
391.                                                 BaseAddr[Offset] = 0xc3; //ret
     
392.                                                 ++Offset;
     
393. 
     
394.                                                 *(ULONG *)(BaseAddr+OffsetStrAddr) = (ULONG)(BaseAddr + Offset); // parameter for LoadLibraryW
     
395. 
     
396.                                                 //forming string with DLL name - tunew20.dll
     
397. 
     
398.                                                 BaseAddr[Offset] = 't';
     
399.                                                 ++Offset;
     
400.                                                 BaseAddr[Offset] = 0x0;
     
401.                                                 ++Offset;
     
402.                                                 BaseAddr[Offset] = 'u';
     
403.                                                 ++Offset;
     
404.                                                 BaseAddr[Offset] = 0x0;
     
405.                                                 ++Offset;
     
406.                                                 BaseAddr[Offset] = 'n';
     
407.                                                 ++Offset;
     
408.                                                 BaseAddr[Offset] = 0x0;
     
409.                                                 ++Offset;
     
410.                                                 BaseAddr[Offset] = 'e';
     
411.                                                 ++Offset;
     
412.                                                 BaseAddr[Offset] = 0x0;
     
413.                                                 ++Offset;
     
414.                                                 BaseAddr[Offset] = 'w';
     
415.                                                 ++Offset;
     
416.                                                 BaseAddr[Offset] = 0x0;
     
417.                                                 ++Offset;
     
418.                                                 BaseAddr[Offset] = '2';
     
419.                                                 ++Offset;
     
420.                                                 BaseAddr[Offset] = 0x0;
     
421.                                                 ++Offset;
     
422.                                                 BaseAddr[Offset] = '0';
     
423.                                                 ++Offset;
     
424.                                                 BaseAddr[Offset] = 0x0;
     
425.                                                 ++Offset;
     
426.                                                 BaseAddr[Offset] = '.';
     
427.                                                 ++Offset;
     
428.                                                 BaseAddr[Offset] = 0x0;
     
429.                                                 ++Offset;
     
430.                                                 BaseAddr[Offset] = 'd';
     
431.                                                 ++Offset;
     
432.                                                 BaseAddr[Offset] = 0x0;
     
433.                                                 ++Offset;
     
434.                                                 BaseAddr[Offset] = 'l';
     
435.                                                 ++Offset;
     
436.                                                 BaseAddr[Offset] = 0x0;
     
437.                                                 ++Offset;
     
438.                                                 BaseAddr[Offset] = 'l';
     
439.                                                 ++Offset;
     
440.                                                 BaseAddr[Offset] = 0x0;
     
441.                                                 ++Offset;
     
442.                                                 BaseAddr[Offset] = 0x0;
     
443.                                                 ++Offset;
     
444.                                                 BaseAddr[Offset] = 0x0;
     
445.                                                 ++Offset;
     
446. 
     
447. 
     
448.                                                 DBGPRINT(("---------------Old EAX Value = 0x%08x\n",Win32StartAddr));
     
449.                                                 Win32StartAddr = (ULONG)BaseAddr;
     
450.                                                 
     
451. 
     
452. 
     
453.                                         }
     
454.                                         //"jumping" back to previos contex.
     
455. 
     
456.                                         KeDetachProcess();
     
457. 
     
458.                                         //setting process start address to allocated memory
     
459.                                         ThreadContext->Eax = Win32StartAddr;
     
460.                                 }
     
461.                         
     
462.                         }
     
463. 
     
464.                         ObDereferenceObject(pProcess);
     
465.                         
     
466.                 }
     
467. 
     
468.                 UnlockProcessQueue();
     
469. 
     
470.                 RemoveProcessFromQueue(ProcessHandle);
     
471.         
     
472.         }
     
473. 
     
474.         ResultStatus = OldNtCreateThread(
     
475.                 ThreadHandle,
     
476.                 DesiredAccess,
     
477.                 ObjectAttributes,
     
478.                 ProcessHandle,
     
479.                 ClientId,
     
480.                 ThreadContext,
     
481.                 InitialTeb,
     
482.                 CreateSuspended);
     
483. 
     
484.         if (ResultStatus == STATUS_SUCCESS && CreateSuspended)
     
485.         {
     
486.                 DBGPRINT(("Kernel sucessfully create new thread.\n----->ThreadHandle = 0x%xh for ProcessHandle = 0x%x\n",*ThreadHandle,ProcessHandle));
     
487.         }
     
488. 
     
489.         return ResultStatus;
     
490. }
     
491. 
     
492. 
     
493. 
     
494. NTSTATUS NewNtTerminateProcess(
     
495.     IN HANDLE ProcessHandle OPTIONAL,
     
496.     IN NTSTATUS ExitStatus)
     
497. {
     
498.         NTSTATUS ResultStatus;
     
499. 
     
500. #pragma message("must verify user mode parameters before use")
     
501.         
     
502.         DBGPRINT(("Called NtTerminateProcess\n"));
     
503. 
     
504.         if(ProcessHandle && ProcessHandle!=(void *)0xffffffff)
     
505.         {
     
506.                 RemoveProcessFromQueue(ProcessHandle);
     
507.         }
     
508. 
     
509.         ResultStatus = OldNtTerminateProcess(ProcessHandle,ExitStatus);
     
510.         if (ResultStatus == STATUS_SUCCESS)
     
511.         {
     
512.                 DBGPRINT(("Kernel sucessfully terminate Process.\n----->ProcessHandle = 0x%xh\n",ProcessHandle));
     
513.         }
     
514. 
     
515. 
     
516.         return ResultStatus;
     
517. }
     
518. 
     
519. 
     
520. NTSTATUS HookServices(PAddrInfo        pAddrInfo, BOOLEAN isHookedState)
     
521. {
     
522. 
     
523.         if (pAddrInfo && pAddrInfo->isInitialized)
     
524.         {
     
525.                 BOOLEAN isNeedHookEx = FALSE;
     
526.                 if (pAddrInfo->SSTIndexNtCreateProcessEx)
     
527.                 {
     
528.                         isNeedHookEx = TRUE;
     
529.                 }
     
530. 
     
531.                 DBGPRINT(("Setting hook on SSTIndexNtCreateProcess = 0x%08X\n",pAddrInfo->SSTIndexNtCreateProcess));
     
532.                 DBGPRINT(("Setting hook on SSTIndexNtCreateThread = 0x%08X\n",pAddrInfo->SSTIndexNtCreateThread));
     
533.                 DBGPRINT(("Setting hook on SSTIndexNtTerminateProcess = 0x%08X\n",pAddrInfo->SSTIndexNtTerminateProcess));
     
534.                 DBGPRINT(("Setting hook on pfnLoadLibrary = 0x%08X\n",pAddrInfo->pfnLoadLibrary));
     
535.                 if (isNeedHookEx)
     
536.                         DBGPRINT(("Setting hook on SSTIndexNtCreateProcessEx = 0x%08X\n",pAddrInfo->SSTIndexNtCreateProcessEx));
     
537. 
     
538.         
     
539.                 OldNtCreateProcess = (NTCREATEPROCESS)(KeServiceDescriptorTable[0].Base[pAddrInfo->SSTIndexNtCreateProcess]);
     
540.                 OldNtCreateThread = (NTCREATETHREAD)(KeServiceDescriptorTable[0].Base[pAddrInfo->SSTIndexNtCreateThread]);
     
541.                 OldNtTerminateProcess = (NTTERMINATEPROCESS)(KeServiceDescriptorTable[0].Base[pAddrInfo->SSTIndexNtTerminateProcess]);
     
542.                 if (isNeedHookEx)
     
543.                         OldNtCreateProcessEx = (NTCREATEPROCESSEX)(KeServiceDescriptorTable[0].Base[pAddrInfo->SSTIndexNtCreateProcessEx]);
     
544. 
     
545.                 _asm cli
     
546. 
     
547.                 (NTCREATEPROCESS)(KeServiceDescriptorTable[0].Base[pAddrInfo->SSTIndexNtCreateProcess]) = NewNtCreateProcess;
     
548.                 (NTCREATETHREAD)(KeServiceDescriptorTable[0].Base[pAddrInfo->SSTIndexNtCreateThread]) = NewNtCreateThread;
     
549.                 (NTTERMINATEPROCESS)(KeServiceDescriptorTable[0].Base[pAddrInfo->SSTIndexNtTerminateProcess]) = NewNtTerminateProcess;
     
550. 
     
551.                 if (isNeedHookEx)
     
552.                         (NTCREATEPROCESSEX)(KeServiceDescriptorTable[0].Base[pAddrInfo->SSTIndexNtCreateProcessEx]) = NewNtCreateProcessEx;
     
553. 
     
554.                 _asm sti
     
555.         }
     
556. 
     
557.         return STATUS_SUCCESS;
     
558. 
     
559. }
     
560. 
     
561. void UnHookServices(PAddrInfo pAddrInfo, BOOLEAN isHookedState)
     
562. {
     
563. 
     
564.         if (pAddrInfo && pAddrInfo->isInitialized && isHookedState)
     
565.         {
     
566.                 DBGPRINT(("Unhook service functions\n"));
     
567.                 DBGPRINT(("SSTIndexNtCreateProcess = 0x%08X\n",pAddrInfo->SSTIndexNtCreateProcess));
     
568.                 DBGPRINT(("SSTIndexNtCreateThread = 0x%08X\n",pAddrInfo->SSTIndexNtCreateThread));
     
569.                 DBGPRINT(("SSTIndexNtTerminateProcess = 0x%08X\n",pAddrInfo->SSTIndexNtTerminateProcess));
     
570.                 DBGPRINT(("pfnLoadLibrary = 0x%08X\n",pAddrInfo->pfnLoadLibrary));
     
571. 
     
572.                 _asm cli
     
573. 
     
574.                 (NTCREATEPROCESS)(KeServiceDescriptorTable[0].Base[pAddrInfo->SSTIndexNtCreateProcess])=OldNtCreateProcess;
     
575.                 (NTCREATETHREAD)(KeServiceDescriptorTable[0].Base[pAddrInfo->SSTIndexNtCreateThread])=OldNtCreateThread;
     
576.                 (NTTERMINATEPROCESS)(KeServiceDescriptorTable[0].Base[pAddrInfo->SSTIndexNtTerminateProcess])=OldNtTerminateProcess;
     
577.                 if (pAddrInfo->SSTIndexNtCreateProcessEx)
     
578.                         (NTCREATEPROCESSEX)(KeServiceDescriptorTable[0].Base[pAddrInfo->SSTIndexNtCreateProcessEx])=OldNtCreateProcessEx;
     
579. 
     
580.                 _asm sti
     
581.         }
     
582. 
     
583.         return;
     
584. 
     
585. }

复制代码

飘云

这个中文翻译有点蛋疼。。。。

爱民

英文...翻译是这样
表达不出很好的内涵

xdnice

翻译的有点看不懂。。。

qq339190184

确实很蛋疼……何止是蛋疼，简直就是蛋疼……我是小白，完全看不懂……

风轻云淡

驱动 不是初学者的菜

月清晖

明显是翻译的，貌似还是用工具翻译的，不太顺溜...

pyg_wang

不知道它是如何注入dll的？

纸蝴蝶

看一下学习学习