驱动开发：内核强制结束进程运行

通常使用Windows系统自带的任务管理器可以正常地结束掉一般进程，而某些特殊的进程在应用层很难被结束掉，例如某些系统核心进程其权限是在0环内核态，但有时我们不得不想办法结束掉这些特殊的进程，当然某些正常进程在特殊状态下也会无法被正常结束，此时使用驱动前行在内核态将其结束掉就变得很有用了，驱动结束进程有多种方法。

• 1.标准方法就是使用ZwOpenProcess打开进程获得句柄，然后使用ZwTerminateProcess这个内核API实现结束进程，最后使用ZwClose关闭句柄。
  
• 2.第二种方法，通过动态定位的方式找到PspTerminateThreadByPointer这个内核函数地址，然后调用该函数结束掉进程中所有的线程，当线程为空则进程也就消亡了。
  
• 3.第三种方法，我将其称作是内存清零法，其核心原理是通过打开进程，得到进程的基址，通过内存填充的方式将对端内存全部置0实现类似于结束的效果。
  

首先是第一种方法结束进程，封装实现KillProcess函数，用户传入lyshark.exe进程名，进程内执行PsGetProcessImageFileName判断是否是我们要结束的如果是则，调用ZwOpenProcess打开进程，并发送ZwTerminateProcess终止信号从而正常结束，其核心代码如下所示。

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: [email protected]
5. #include <ntifs.h>
7. NTKERNELAPI UCHAR* PsGetProcessImageFileName(IN PEPROCESS Process);
9. // 根据进程ID返回进程EPROCESS结构体,失败返回NULL
10. PEPROCESS GetProcessNameByProcessId(HANDLE pid)
11. {
12.         PEPROCESS ProcessObj = NULL;
13.         NTSTATUS Status = STATUS_UNSUCCESSFUL;
14.         Status = PsLookupProcessByProcessId(pid, &ProcessObj);
15.         if (NT_SUCCESS(Status))
16.                 return ProcessObj;
17.         return NULL;
18. }
20. // 根据ProcessName获取到进程的PID号
21. HANDLE GetPidByProcessName(char *ProcessName)
22. {
23.         PEPROCESS pCurrentEprocess = NULL;
24.         HANDLE pid = 0;
25.         for (int i = 0; i < 1000000000; i += 4)
26.         {
27.                 pCurrentEprocess = GetProcessNameByProcessId((HANDLE)i);
28.                 if (pCurrentEprocess != NULL)
29.                 {
30.                         pid = PsGetProcessId(pCurrentEprocess);
31.                         if (strstr(PsGetProcessImageFileName(pCurrentEprocess), ProcessName) != NULL)
32.                         {
33.                                 ObDereferenceObject(pCurrentEprocess);
34.                                 return pid;
35.                         }
36.                         ObDereferenceObject(pCurrentEprocess);
37.                 }
38.         }
39.         return (HANDLE)-1;
40. }
42. // 传入进程名称,终止掉该进程
43. BOOLEAN KillProcess(PCHAR ProcessName)
44. {
45.         PEPROCESS pCurrentEprocess = NULL;
46.         HANDLE pid = 0;
47.         HANDLE Handle = NULL;
48.         OBJECT_ATTRIBUTES obj;
49.         CLIENT_ID cid = { 0 };
50.         NTSTATUS Status = STATUS_UNSUCCESSFUL;
52.         for (int i = 0; i < 10000000; i += 4)
53.         {
54.                 pCurrentEprocess = GetProcessNameByProcessId((HANDLE)i);
55.                 if (pCurrentEprocess != NULL)
56.                 {
57.                         pid = PsGetProcessId(pCurrentEprocess);
59.                         // 判断当前镜像名称是否是需要结束的进程
60.                         if (strstr(PsGetProcessImageFileName(pCurrentEprocess), ProcessName) != NULL)
61.                         {
62.                                 ObDereferenceObject(pCurrentEprocess);
64.                                 // 找到后开始结束
65.                                 InitializeObjectAttributes(&obj, NULL, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
66.                                 cid.UniqueProcess = (HANDLE)pid;
67.                                 cid.UniqueThread = 0;
69.                                 // 打开进程
70.                                 Status = ZwOpenProcess(&Handle, GENERIC_ALL, &obj, &cid);
71.                                 if (NT_SUCCESS(Status))
72.                                 {
73.                                         // 发送终止信号
74.                                         ZwTerminateProcess(Handle, 0);
75.                                         ZwClose(Handle);
76.                                 }
77.                                 ZwClose(Handle);
78.                                 return TRUE;
79.                         }
80.                         ObDereferenceObject(pCurrentEprocess);
81.                 }
82.         }
83.         return FALSE;
84. }
86. VOID UnDriver(PDRIVER_OBJECT driver)
87. {
88.         DbgPrint("驱动已卸载 \n");
89. }
91. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
92. {
93.         DbgPrint("hello lyshark.com \n");
95.         BOOLEAN Retn;
96.         Retn = KillProcess("lyshark.exe");
97.         DbgPrint("结束状态: %d \n", Retn);
99.         Driver->DriverUnload = UnDriver;
100.         return STATUS_SUCCESS;
101. }

复制代码

我们运行这个驱动，当进程lyshark.exe存在时则可以看到结束效果，当然这种方式只是在内核层面调用了结束进程函数，其本质上还是正常结束，只是这种方式权限要大一些仅此而已。

第二种方法，其原理就是将进程内的线程全部结束掉从而让进程自动结束，由于PspTerminateThreadByPointer没有被导出，所以我们需要动态的这个内存地址，然后动态调用即可，这个寻找方法可以总结为以下步骤。

• 1.寻找PsTerminateSystemThread函数地址，这个地址可以直接通过MmGetSystemRoutineAddress函数得到。
  
• 2.在PsTerminateSystemThread函数地址内向下扫描特征e80cb6f6ff得到call nt!PspTerminateThreadByPointer地址。
  

根据《驱动开发：内核枚举LoadImage映像回调》中使用的SearchMemory函数实现搜索PspTerminateThreadByPointer内存地址。

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: [email protected]
5. #include <ntifs.h>
7. // 得到PspTerminateThreadByPointer内存地址
8. PVOID PspTerminateThreadByPointer()
9. {
10.         UNICODE_STRING ustrFuncName;
11.         PVOID pAddress = NULL;
12.         LONG lOffset = 0;
13.         PVOID pPsTerminateSystemThread = NULL;
14.         PVOID pPspTerminateThreadByPointer = NULL;
16.         // 获取 PsTerminateSystemThread 函数地址
17.         RtlInitUnicodeString(&ustrFuncName, L"PsTerminateSystemThread");
18.         pPsTerminateSystemThread = MmGetSystemRoutineAddress(&ustrFuncName);
19.        
20.         DbgPrint("pPsTerminateSystemThread = 0x%p \n", pPsTerminateSystemThread);
21.         if (NULL == pPsTerminateSystemThread)
22.         {
23.                 return 0;
24.         }
26.         // 查找 PspTerminateThreadByPointer 函数地址
28.         /*
29.         1: kd> uf PsTerminateSystemThread
30.                         nt!PsTerminateSystemThread:
31.                         fffff802`254e6a90 4883ec28        sub     rsp,28h
32.                         fffff802`254e6a94 8bd1            mov     edx,ecx
33.                         fffff802`254e6a96 65488b0c2588010000 mov   rcx,qword ptr gs:[188h]
34.                         fffff802`254e6a9f f7417400040000  test    dword ptr [rcx+74h],400h
35.                         fffff802`254e6aa6 0f8444081100    je      nt!PsTerminateSystemThread+0x110860 (fffff802`255f72f0)  Branch
37.                         nt!PsTerminateSystemThread+0x1c:
38.                         fffff802`254e6aac 41b001          mov     r8b,1
39.                         fffff802`254e6aaf e80cb6f6ff      call    nt!PspTerminateThreadByPointer (fffff802`254520c0)
41.                         nt!PsTerminateSystemThread+0x24:
42.                         fffff802`254e6ab4 4883c428        add     rsp,28h
43.                         fffff802`254e6ab8 c3              ret
45.                         nt!PsTerminateSystemThread+0x110860:
46.                         fffff802`255f72f0 b80d0000c0      mov     eax,0C000000Dh
47.                         fffff802`255f72f5 e9baf7eeff      jmp     nt!PsTerminateSystemThread+0x24 (fffff802`254e6ab4)  Branch
48.         */
50.         UCHAR pSpecialData[50] = { 0 };
51.         ULONG ulSpecialDataSize = 0;
53.         // fffff802`254e6aaf e80cb6f6ff      call    nt!PspTerminateThreadByPointer (fffff802`254520c0)
54.         pSpecialData[0] = 0xE8;
55.         ulSpecialDataSize = 1;
57.         // 搜索地址 PsTerminateSystemThread --> PsTerminateSystemThread + 0xff 查找 e80cb6f6ff
58.         pAddress = SearchMemory(pPsTerminateSystemThread, (PVOID)((PUCHAR)pPsTerminateSystemThread + 0xFF), pSpecialData, ulSpecialDataSize);
59.         if (NULL == pAddress)
60.         {
61.                 return 0;
62.         }
64.         // 先获取偏移,再计算地址
65.         lOffset = *(PLONG)pAddress;
66.         pPspTerminateThreadByPointer = (PVOID)((PUCHAR)pAddress + sizeof(LONG) + lOffset);
67.         if (NULL == pPspTerminateThreadByPointer)
68.         {
69.                 return 0;
70.         }
72.         return pPspTerminateThreadByPointer;
73. }
75. VOID UnDriver(PDRIVER_OBJECT driver)
76. {
77.         DbgPrint("驱动已卸载 \n");
78. }
80. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
81. {
82.         DbgPrint("hello lyshark.com \n");
84.         PVOID address = PspTerminateThreadByPointer();
86.         DbgPrint("PspTerminateThreadByPointer = 0x%p \n", address);
88.         Driver->DriverUnload = UnDriver;
89.         return STATUS_SUCCESS;
90. }

复制代码

运行驱动程序，首先得到PspTerminateThreadByPointer的内存地址，效果如下。

得到内存地址以后直接将地址typedef转为指针函数，调用并批量结束进程内的线程即可。

1. // 署名权
2. // right to sign one's name on a piece of work
3. // PowerBy: LyShark
4. // Email: [email protected]
5. #include <ntifs.h>
7. typedef NTSTATUS(__fastcall *PSPTERMINATETHREADBYPOINTER) (PETHREAD pEThread, NTSTATUS ntExitCode, BOOLEAN bDirectTerminate);
9. VOID UnDriver(PDRIVER_OBJECT driver)
10. {
11.         DbgPrint("驱动已卸载 \n");
12. }
14. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
15. {
16.         DbgPrint("hello lyshark.com \n");
18.         PVOID pPspTerminateThreadByPointerAddress = 0xFFFFF802254520C0;
19.         HANDLE hProcessId = 6956;
21.         PEPROCESS pEProcess = NULL;
22.         PETHREAD pEThread = NULL;
23.         PEPROCESS pThreadEProcess = NULL;
24.         NTSTATUS status = STATUS_SUCCESS;
25.         ULONG i = 0;
27.         // 获取结束进程的进程结构对象EPROCESS
28.         status = PsLookupProcessByProcessId(hProcessId, &pEProcess);
29.         if (!NT_SUCCESS(status))
30.         {
31.                 return status;
32.         }
33.         // 遍历所有线程, 并结束所有指定进程的线程
34.         for (i = 4; i < 0x80000; i = i + 4)
35.         {
36.                 status = PsLookupThreadByThreadId((HANDLE)i, &pEThread);
37.                 if (NT_SUCCESS(status))
38.                 {
39.                         // 获取线程对应的进程结构对象
40.                         pThreadEProcess = PsGetThreadProcess(pEThread);
42.                         // 结束进程中的线程
43.                         if (pEProcess == pThreadEProcess)
44.                         {
45.                                 ((PSPTERMINATETHREADBYPOINTER)pPspTerminateThreadByPointerAddress)(pEThread, 0, 1);
46.                                 DbgPrint("结束线程: %d \n", i);
47.                         }
48.                         ObDereferenceObject(pEThread);
49.                 }
50.         }
51.         ObDereferenceObject(pEProcess);
53.         Driver->DriverUnload = UnDriver;
54.         return STATUS_SUCCESS;
55. }

复制代码

循环结束进程6956内的所有线程信息，效果如下；