TP的学习笔记：创建一个没有线程而且杀不死的进程

tangptr@126.com

不知道大家有没有听说过没有线程的进程。刚开始我是认为这种进程是不存在的，因为是深受pjf的《进程终止的内幕》的关系。不过后来，我看到了这么一篇文章，看下来我觉得这种进程实现起来其实不难。我先把这篇文章复制粘贴过来。

《PspExitThread执行流程分析》

在TerminateProcess流程追踪、PspTerminateThreadByPointer的实现中讲到，进程的终止，最终都是通过PspTerminateThreadByPointer终止线程来实现的。而PspTerminateThreadByPointer不管是通过终止本身，还是通过插APC最终都是调用PspExitThread来完成终止过程。
那来分析下PspExitThread的执行流程。

1. //通过线程来获得进程对象。
   
2. if (Process != PsGetCurrentProcessByThread (Thread)) {
   
3. KeBugCheckEx (INVALID_PROCESS_ATTACH_ATTEMPT,
   
4. (ULONG_PTR)Process,
   
5. (ULONG_PTR)Thread->Tcb.ApcState.Process,
   
6. (ULONG)Thread->Tcb.ApcStateIndex,
   
7. (ULONG_PTR)Thread);
   
8. }
   
9. KeLowerIrql(PASSIVE_LEVEL);
   
10. //判断线程是否允许终止
    
11. if (Thread->ActiveExWorker) {
    
12. KeBugCheckEx (ACTIVE_EX_WORKER_THREAD_TERMINATION,
    
13. (ULONG_PTR)Thread,
    
14. 0,
    
15. 0,
    
16. 0);
    
17. }
    
18. if (Thread->Tcb.CombinedApcDisable != 0) {
    
19. KeBugCheckEx (KERNEL_APC_PENDING_DURING_EXIT,
    
20. (ULONG_PTR)0,
    
21. (ULONG_PTR)Thread->Tcb.CombinedApcDisable,
    
22. (ULONG_PTR)0,
    
23. 1);
    
24. }
    
25. ExWaitForRundownProtectionRelease (&Thread->RundownProtect);
    
26. PoRundownThread(Thread);
    
27. //通知哪些已注册的线程删除事件接受者
    
28. PERFINFO_THREAD_DELETE(Thread);
    
29. if (PspCreateThreadNotifyRoutineCount != 0) {
    
30. ULONG i;
    
31. PEX_CALLBACK_ROUTINE_BLOCK CallBack;
    
32. PCREATE_THREAD_NOTIFY_ROUTINE Rtn;
    
33. for (i=0; i < PSP_MAX_CREATE_THREAD_NOTIFY; i++) {
    
34. CallBack = ExReferenceCallBackBlock (&PspCreateThreadNotifyRoutine[i]);
    
35. if (CallBack != NULL) {
    
36. Rtn = (PCREATE_THREAD_NOTIFY_ROUTINE) ExGetCallBackBlockRoutine (CallBack);
    
37. Rtn (Process->UniqueProcessId,
    
38. Thread->Cid.UniqueThread,
    
39. FALSE);
    
40. ExDereferenceCallBackBlock (&PspCreateThreadNotifyRoutine[i],
    
41. CallBack);
    
42. }
    
43. }
    
44. }
    
45. LastThread = FALSE;
    
46. DerefThread = NULL;
    
47. PspLockProcessExclusive (Process, Thread);
    
48. //进程的活动线程计数减1
    
49. Process->ActiveThreads—;
    
50. //如果这是最后一个线程，则必须等到该进程的线程链表中所有的线程都退出才能继续往下进行。
    
51. if (Process->ActiveThreads == 0) {
    
52. PS_SET_BITS (&Process->Flags, PS_PROCESS_FLAGS_PROCESS_DELETE);
    
53. LastThread = TRUE;
    
54. if (ExitStatus == STATUS_THREAD_IS_TERMINATING) {
    
55. if (Process->ExitStatus == STATUS_PENDING) {
    
56. Process->ExitStatus = Process->LastThreadExitStatus;
    
57. }
    
58. } else {
    
59. Process->ExitStatus = ExitStatus;
    
60. }
    
61. for (Entry = Process->ThreadListHead.Flink;
    
62. Entry != &Process->ThreadListHead;
    
63. Entry = Entry->Flink) {
    
64. WaitThread = CONTAINING_RECORD (Entry, ETHREAD, ThreadListEntry);
    
65. if (WaitThread != Thread &&
    
66. !KeReadStateThread (&WaitThread->Tcb) &&
    
67. ObReferenceObjectSafe (WaitThread)) {
    
68. PspUnlockProcessExclusive (Process, Thread);
    
69. KeWaitForSingleObject (WaitThread,
    
70. Executive,
    
71. KernelMode,
    
72. FALSE,
    
73. NULL);
    
74. 
    
75. if (DerefThread != NULL) {
    
76. ObDereferenceObject (DerefThread);
    
77. }
    
78. DerefThread = WaitThread;
    
79. PspLockProcessExclusive (Process, Thread);
    
80. }
    
81. }
    
82. } else {
    
83. if (ExitStatus != STATUS_THREAD_IS_TERMINATING) {
    
84. Process->LastThreadExitStatus = ExitStatus;
    
85. }
    
86. }
    
87. PspUnlockProcessExclusive (Process, Thread);
    
88. if (DerefThread != NULL) {
    
89. ObDereferenceObject (DerefThread);
    
90. }

复制代码

如有必要发送调试信息

1. 
   
2. if (Process->DebugPort != NULL) {
   
3. if (!IS_SYSTEM_THREAD (Thread)) {
   
4. if (LastThread) {
   
5. DbgkExitProcess (Process->ExitStatus);
   
6. } else {
   
7. DbgkExitThread (ExitStatus);
   
8. }
   
9. }
   
10. }
    
11. if (KD_DEBUGGER_ENABLED) {
    
12. if (Thread->CrossThreadFlags & PS_CROSS_THREAD_FLAGS_BREAK_ON_TERMINATION) {
    
13. PspCatchCriticalBreak (“Critical thread 0x%p (in %s) exited\n”,
    
14. Thread,
    
15. Process->ImageFileName);
    
16. }
    
17. } // End of critical thread/process exit detect
    
18. if (LastThread &&
    
19. (Process->Flags & PS_PROCESS_FLAGS_BREAK_ON_TERMINATION)) {
    
20. if (KD_DEBUGGER_ENABLED) {
    
21. PspCatchCriticalBreak (“Critical process 0x%p (%s) exited\n”,
    
22. Process,
    
23. Process->ImageFileName);
    
24. } else {
    
25. KeBugCheckEx (CRITICAL_PROCESS_DIED,
    
26. (ULONG_PTR)Process,
    
27. 0,
    
28. 0,
    
29. 0);
    
30. }
    
31. }
    
32. ASSERT(Thread->Tcb.CombinedApcDisable == 0);

复制代码

处理TerminationPort，向所有已经登记过要接受终止通知的线程发送终止消息

1. TerminationPort = Thread->TerminationPort;
   
2. if (TerminationPort != NULL) {
   
3. CdMsg.PortMsg.u1.s1.DataLength = sizeof(LARGE_INTEGER);
   
4. CdMsg.PortMsg.u1.s1.TotalLength = sizeof(LPC_CLIENT_DIED_MSG);
   
5. CdMsg.PortMsg.u2.s2.Type = LPC_CLIENT_DIED;
   
6. CdMsg.PortMsg.u2.s2.DataInfoOffset = 0;
   
7. do {
   
8. CdMsg.CreateTime.QuadPart = PS_GET_THREAD_CREATE_TIME (Thread);
   
9. while (1) {
   
10. Status = LpcRequestPort (TerminationPort->Port, (PPORT_MESSAGE)&CdMsg);
    
11. if (Status == STATUS_NO_MEMORY || Status == STATUS_INSUFFICIENT_RESOURCES) {
    
12. KeDelayExecutionThread (KernelMode, FALSE, &ShortTime);
    
13. continue;
    
14. }
    
15. break;
    
16. }
    
17. ObDereferenceObject (TerminationPort->Port);
    
18. NextPort = TerminationPort->Next;
    
19. ExFreePoolWithTag (TerminationPort, ‘pTsP’|PROTECTED_POOL);
    
20. TerminationPort = NextPort;
    
21. } while (TerminationPort != NULL);
    
22. } else {
    
23. if ((ExitStatus == STATUS_THREAD_IS_TERMINATING &&
    
24. (Thread->CrossThreadFlags&PS_CROSS_THREAD_FLAGS_DEADTHREAD)) ||
    
25. !(Thread->CrossThreadFlags&PS_CROSS_THREAD_FLAGS_DEADTHREAD)) {
    
26. CdMsg.PortMsg.u1.s1.DataLength = sizeof (LARGE_INTEGER);
    
27. CdMsg.PortMsg.u1.s1.TotalLength = sizeof (LPC_CLIENT_DIED_MSG);
    
28. CdMsg.PortMsg.u2.s2.Type = LPC_CLIENT_DIED;
    
29. CdMsg.PortMsg.u2.s2.DataInfoOffset = 0;
    
30. if (Process->ExceptionPort != NULL) {
    
31. //向异常端口发送终止消息
    
32. CdMsg.CreateTime.QuadPart = PS_GET_THREAD_CREATE_TIME (Thread);
    
33. while (1) {
    
34. Status = LpcRequestPort (Process->ExceptionPort, (PPORT_MESSAGE)&CdMsg);
    
35. if (Status == STATUS_NO_MEMORY || Status == STATUS_INSUFFICIENT_RESOURCES) {
    
36. KeDelayExecutionThread (KernelMode, FALSE, &ShortTime);
    
37. continue;
    
38. }
    
39. break;
    
40. }
    
41. }
    
42. }
    
43. }

复制代码

通知Windows子系统当前线程退出，如果这是进程的最后一个线程，还要通知Windows子系统当前进程退出。

1. if (Thread->Tcb.Win32Thread) {
   
2. (PspW32ThreadCallout) (Thread, PsW32ThreadCalloutExit);
   
3. }
   
4. if (LastThread && Process->Win32Process) {
   
5. (PspW32ProcessCallout) (Process, FALSE);
   
6. }

复制代码

取消I/O，取消定时器，清除任何尚未完成的注册表通知请求，释放当前线程所拥有的突变体内核对象（mutant）

1. IoCancelThreadIo (Thread);
   
2. ExTimerRundown ();
   
3. CmNotifyRunDown (Thread);
   
4. KeRundownThread ();

复制代码

释放TEB。

1. Teb = Thread->Tcb.Teb;
   
2. if (Teb != NULL) {
   
3. Peb = Process->Peb;
   
4. try {
   
5. if ((Thread->CrossThreadFlags&PS_CROSS_THREAD_FLAGS_DEADTHREAD) == 0) {
   
6. SIZE_T Zero;
   
7. PVOID BaseAddress;
   
8. if (Teb->FreeStackOnTermination) {
   
9. Zero = 0;
   
10. BaseAddress = Teb->DeallocationStack;
    
11. ZwFreeVirtualMemory (NtCurrentProcess (),
    
12. &BaseAddress,
    
13. &Zero,
    
14. MEM_RELEASE);
    
15. }
    
16. #if defined(_WIN64)
    
17. if (Process->Wow64Process != NULL) {
    
18. PTEB32 Teb32;
    
19. Teb32 = WOW64_GET_TEB32_SAFE (Teb);
    
20. if (Teb32->FreeStackOnTermination) {
    
21. Zero = 0;
    
22. BaseAddress = UlongToPtr (Teb32->DeallocationStack);
    
23. ZwFreeVirtualMemory (NtCurrentProcess (),
    
24. &BaseAddress,
    
25. &Zero,
    
26. MEM_RELEASE);
    
27. }
    
28. }
    
29. #endif
    
30. }
    
31. if (Teb->DbgSsReserved[1] != NULL) {
    
32. ObCloseHandle (Teb->DbgSsReserved[1], UserMode);
    
33. }
    
34. } except (EXCEPTION_EXECUTE_HANDLER) {
    
35. }
    
36. MmDeleteTeb (Process, Teb);
    
37. Thread->Tcb.Teb = NULL;
    
38. }

复制代码

调用LpcExitThread以便让LPC组件来处理LPC应答消息。

1. LpcExitThread (Thread);

复制代码

设置线程的退出时间和退出状态

1. Thread->ExitStatus = ExitStatus;
   
2. KeQuerySystemTime (&Thread->ExitTime);

复制代码

如果是进程的最后一个线程，还要调用PspExitProcess以退出进程，并设置进程退出的相关属性，以及销毁句柄表和解除对进程的内存区对象的引用。

1. if (LastThread) {
   
2. Process->ExitTime = Thread->ExitTime;
   
3. PspExitProcess (TRUE, Process);
   
4. ProcessToken = PsReferencePrimaryToken (Process);
   
5. if (SeDetailedAuditingWithToken (ProcessToken)) {
   
6. SeAuditProcessExit (Process);
   
7. }
   
8. PsDereferencePrimaryTokenEx (Process, ProcessToken);
   
9. #if defined(_X86_)
   
10. if (Process->VdmObjects != NULL) {
    
11. VdmRundownDpcs (Process);
    
12. }
    
13. #endif
    
14. ObKillProcess (Process);
    
15. if (Process->SectionObject != NULL) {
    
16. ObDereferenceObject (Process->SectionObject);
    
17. Process->SectionObject = NULL;
    
18. }
    
19. if (Process->Job != NULL) {
    
20. PspExitProcessFromJob (Process->Job, Process);
    
21. }
    
22. }

复制代码

强制恢复线程运行，以便处理可能有的APC，遍历用户模式APC，如果此APC有一个终止函数（RundownRountine），则执行此函数，否则直接扔掉此APC。

1. KeForceResumeThread (&Thread->Tcb);
   
2. KeLeaveCriticalRegionThread (&Thread->Tcb);
   
3. //
   
4. // flush user-mode APC queue
   
5. //
   
6. FirstEntry = KeFlushQueueApc (&Thread->Tcb, UserMode);
   
7. if (FirstEntry != NULL) {
   
8. Entry = FirstEntry;
   
9. do {
   
10. Apc = CONTAINING_RECORD (Entry, KAPC, ApcListEntry);
    
11. Entry = Entry->Flink;
    
12. //
    
13. // If the APC has a rundown routine then call it. Otherwise
    
14. // deallocate the APC
    
15. //
    
16. if (Apc->RundownRoutine) {
    
17. (Apc->RundownRoutine) (Apc);
    
18. } else {
    
19. ExFreePool (Apc);
    
20. }
    
21. } while (Entry != FirstEntry);
    
22. }

复制代码

如果是该进程最后一个线程，则清除当前进程的地址空间。

1. if (LastThread) {
   
2. MmCleanProcessAddressSpace (Process);
   
3. }

复制代码

将进程对象的状态设置为有信号状态，以唤醒那些可能在等待此进程对象的线程。

1. if (LastThread) {
   
2. KeSetProcess (&Process->Pcb, 0, FALSE);
   
3. }

复制代码

最后调用KeTerminateThread，设置线程状态为有信号状态，并设置线程的调度状态为“已终止”。
处理将执行新选择的线程，以后调度算法再也不会选择这一已终止的线程。




下面是我的正文了
不知道大家有没有注意到调用PspExitProcess和ObKillProcess的那段代码，这是PspExitThread结束最后一个线程的时候退出进程用的代码，这就意味着要结束最后一个线程不让进程退出，就必须跳过PspExitProcess和ObKillProcess这两个函数。而要跳过这两个函数，最好的办法就是不执行PspExitThread。那么不执行PspExitThread该怎么结束线程呢？请看原文的倒数第二行。

最后调用KeTerminateThread，设置线程状态为有信号状态，并设置线程的调度状态为“已终止”。

可见调用KeTerminateThread是既可以实现结束线程，又可以跳过PspExitProcess/ObKillProcess的过程。
值得一提的是，KeTerminateThread在NT5系列Windows系统中导出，而在NT6系列系统中没有导出，因此本文提供的附件只支持Windows NT5。
首先看看KeTerminateThread的原型：
NTKERNELAPI VOID KeTerminateThread(IN KPRIORITY Increment);
这里的Increment参数填零就行了。
但是注意了直接调用这个函数就是自杀，所以我们要让别的线程调用这个函数。而让这个线程执行这个函数，有两种办法：
1.调用Ke(i)InsertQueueApc给目标线程插APC，在APC里执行KeTerminateThread。
2.挂钩ObOpenObjectByPointer（或者KeUsermodeCallback，KiSwapContext，KiFastCallEntry等其他调用极其频繁的函数），判断执行此函数的线程是不是目标线程，若是，执行KeTerminateThread，反之，执行原函数。
第二个方法其实思路是来自于syf大牛的《WS方法结束线程》一文。但个人认为这个方法貌似不好使，主要是什么时候恢复钩子的问题。于是我就选择第一条路。
给线程插APC已经是老技术了，只不过要先用MmIsAddressValid检查ETHREAD地址是否合法，代码如下：

1. NTSTATUS TerminateThread(PETHREAD Thread)
   
2. {
   
3.         NTSTATUS st = STATUS_UNSUCCESSFUL;
   
4.         PKAPC pApc = 0;
   
5.         if ( MmIsAddressValid((PVOID)Thread) == TRUE)
   
6.         {
   
7.                 pApc = ExAllocatePool(NonPagedPool, sizeof(KAPC));
   
8.                 //If APC is OK
   
9.                 if (pApc)
   
10.                 {
    
11.                         KeInitializeApc(pApc, Thread, OriginalApcEnvironment, ApcRT, 0, 0, KernelMode, 0);
    
12.                         KeInsertQueueApc(pApc,NULL,NULL,0);
    
13.                 }
    
14.                 st = STATUS_SUCCESS;
    
15.         }
    
16.         return st;       
    
17. }

复制代码

要执行的APC例程也很简单，只不过别忘了用ExFreePool释放掉APC。

1. VOID ApcRT(PKAPC Apc,PKNORMAL_ROUTINE *NormalRoutine,PVOID *NormalContext,PVOID *SystemArgument1,PVOID *SystemArgument2)
   
2. {
   
3.         ExFreePool(Apc);
   
4.         KeTerminateThread(0);
   
5. }

复制代码

要给进程进程内所有线程插APC，可以用PsLookupThreadByThreadId+IoThreadToProcess方式枚举线程，也可以遍历ThreadListHead。这里选择第一种方案。代码如下：

1. NTSTATUS TerminateProcess(PEPROCESS Process)
   
2. {
   
3.         ULONG i;
   
4.         PETHREAD txtd;
   
5.         PEPROCESS txps;
   
6.         NTSTATUS st = STATUS_UNSUCCESSFUL;
   
7.         for (i=8;i<=65536;i=i+4)
   
8.         {
   
9.                 st = PsLookupThreadByThreadId(i,&txtd);
   
10.                 if ( NT_SUCCESS(st) )
    
11.                 {
    
12.                         txps=IoThreadToProcess(txtd);
    
13.                         if ( txps == Process )
    
14.                         {
    
15.                                 TerminateThread(txtd);
    
16.                         }
    
17.                 }
    
18.         }
    
19.         return STATUS_SUCCESS;
    
20. }

复制代码

这样，我们就创建了一个无敌的进程，经测试，IceSword，IceLight，PsNull，XueTr(PCHunter)，WTool，任务管理器，UTM4XP均杀不死我们的进程。但由于KeTerminateThread是把线程的调度链表摘掉，因此，线程调度机制的算法不会再选择这个进程内任何线程，也就意味着，这个进程死到了一半，再也活不过来了。
注：若要在NT6系列系统上使用这种方法创建无线程进程，请先查找到KeTerminateThread的地址。
方法很简单：先获得导出函数PsTerminateSystemThread的地址，查找其唯一的call指令，后面跟着的就是PspTerminateThreadByPointer的相对地址。取得地址后，查找第三个push指令，注意我指的这个push指令的机器码是0x68。后面跟着的地址是PsExitSpecialApc的绝对地址。取得地址后查找其第二个call指令，后面跟着的，就是PspExitThread。而PspExitThread的倒数第二个指令就是KeTerminateThread。
此外，不要妄想创建远程线程的方式杀进程，我测试过，无效。
p.s:本文附带的附件，其附件描述摘自Hovi.Delphic的帖子。

tangptr@126.com

刚才拿着这篇帖子的内容核心到处装逼，结果某群的某Y冒了这么句，没搞懂啥意思。懂得解释下并测试是否可行。把结果发到楼下就行。

截图

搞不懂的地方就是杀进程和MD5有个卵关系啊！

Tesla.Angela

进程真可怜，半死不活。