进程挂起与恢复：7.6版本的实现方法

挂起与恢复进程是指暂停或恢复进程的工作状态，以达到一定的控制和管理效果。在 Windows 操作系统中，可以使用系统提供的函数实现进程的挂起和恢复，以达到对进程的控制和调度。需要注意，过度使用进程挂起/恢复操作可能会造成系统性能的降低，导致死锁等问题，因此在使用时应该谨慎而慎重。同时，通过和其他进程之间协同工作，也可以通过更加灵活的方式，实现进程的协调、交互等相应的功能，从而实现更加高效和可靠的进程管理。

要实现挂起进程，首先我们需要实现挂起线程，因为挂起进程的实现原理是通过调用SuspendThread函数循环将进程内的所有线程全部挂起后实现的，而要实现挂起线程则我们需要先确定指定进程内的线程信息，要实现枚举进程内的线程信息则可以通过以下几个步骤实现。

首先通过CreateToolhelp32Snapshot得到当前系统下所有的进程快照，并通过遍历进程的方式寻找是否符合我们所需要枚举的进程名，如果是则调用CreateToolhelp32Snapshot并通过传入TH32CS_SNAPTHREAD代表枚举线程，通过循环的方式遍历进程内的线程，每次通过调用OpenThread打开线程，并调用ZwQueryInformationThread查询该线程的入口信息以及线程所在的模块信息，最后以此输出即可得到当前进程内的所有线程信息。

#include <iostream>#include <Windows.h>  #include <TlHelp32.h>#include <Psapi.h>using namespace std;typedef enum _THREADINFOCLASS{  ThreadBasicInformation,  ThreadTimes,  ThreadPriority,  ThreadBasePriority,  ThreadAffinityMask,  ThreadImpersonationToken,  ThreadDescriptorTableEntry,  ThreadEnableAlignmentFaultFixup,  ThreadEventPair_Reusable,  ThreadQuerySetWin32StartAddress,  ThreadZeroTlsCell,  ThreadPerformanceCount,  ThreadAmILastThread,  ThreadIdealProcessor,  ThreadPriorityBoost,  ThreadSetTlsArrayAddress,  ThreadIsIoPending,  ThreadHideFromDebugger,  ThreadBreakOnTermination,  MaxThreadInfoClass}THREADINFOCLASS;typedef struct _CLIENT_ID{  HANDLE UniqueProcess;  HANDLE UniqueThread;}CLIENT_ID;typedef struct _THREAD_BASIC_INFORMATION{  LONG ExitStatus;  PVOID TebBaseAddress;  CLIENT_ID ClientId;  LONG AffinityMask;  LONG Priority;  LONG BasePriority;}THREAD_BASIC_INFORMATION, *PTHREAD_BASIC_INFORMATION;extern "C" LONG(__stdcall * ZwQueryInformationThread)(IN HANDLE ThreadHandle,IN THREADINFOCLASS ThreadInformationClass,OUT PVOID ThreadInformation,IN ULONG ThreadInformationLength,OUT PULONG ReturnLength OPTIONAL) = NULL;// 枚举进程内的线程BOOL EnumThread(char *ProcessName){  // 进程快照句柄  HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);  PROCESSENTRY32 process = { sizeof(PROCESSENTRY32) };  // 遍历进程  while (Process32Next(hProcessSnap, &process))  {    // char* 转 string    string s_szExeFile = process.szExeFile;    if (s_szExeFile == ProcessName)    {      HANDLE hThreadSnap = INVALID_HANDLE_VALUE;      THREADENTRY32 te32;      // 创建线程快照      hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);      if (hThreadSnap == INVALID_HANDLE_VALUE)      {        return FALSE;      }      // 为快照分配内存空间      te32.dwSize = sizeof(THREADENTRY32);      // 获取第一个线程的信息      if (!Thread32First(hThreadSnap, &te32))      {        return FALSE;      }      // 遍历线程      while (Thread32Next(hThreadSnap, &te32))      {        // 判断线程是否属于本进程        if (te32.th32OwnerProcessID == process.th32ProcessID)        {          // 打开线程          HANDLE hThread = OpenThread(            THREAD_ALL_ACCESS,        // 访问权限            FALSE,                    // 由此线程创建的进程不继承线程的句柄            te32.th32ThreadID         // 线程 ID            );          if (hThread == NULL)          {            return FALSE;          }          // 将区域设置设置为从操作系统获取的ANSI代码页          setlocale(LC_ALL, ".ACP");          // 获取 ntdll.dll 的模块句柄          HINSTANCE hNTDLL = ::GetModuleHandle("ntdll");          // 从 ntdll.dll 中取出 ZwQueryInformationThread          (FARPROC&)ZwQueryInformationThread = GetProcAddress(hNTDLL, "ZwQueryInformationThread");          // 获取线程入口地址          PVOID startaddr;                          // 用来接收线程入口地址          ZwQueryInformationThread(            hThread,                              // 线程句柄            ThreadQuerySetWin32StartAddress,      // 线程信息类型 ThreadQuerySetWin32StartAddress 线程入口地址            &startaddr,                           // 指向缓冲区的指针            sizeof(startaddr),                    // 缓冲区的大小            NULL            );          // 获取线程所在模块          THREAD_BASIC_INFORMATION tbi;            // _THREAD_BASIC_INFORMATION 结构体对象          TCHAR modname[MAX_PATH];                 // 用来接收模块全路径          ZwQueryInformationThread(            hThread,                             // 线程句柄            ThreadBasicInformation,              // 线程信息类型，ThreadBasicInformation ：线程基本信息            &tbi,                                // 指向缓冲区的指针            sizeof(tbi),                         // 缓冲区的大小            NULL            );          // 检查入口地址是否位于某模块中          GetMappedFileName(            OpenProcess(                                        // 进程句柄            PROCESS_ALL_ACCESS,                                 // 访问权限            FALSE,                                              // 由此线程创建的进程不继承线程的句柄            (DWORD)tbi.ClientId.UniqueProcess                   // 唯一进程 ID            ),            startaddr,                            // 要检查的地址            modname,                              // 用来接收模块名的指针            MAX_PATH                              // 缓冲区大小            );          std::cout << "线程ID: " << te32.th32ThreadID << " 线程入口: " << startaddr << " 所在模块: " << modname << std::endl;        }      }    }  }}int main(int argc, char* argv[]){  EnumThread("lyshark.exe");  system("pause");  return 0;}

读者可自行运行上述代码片段，即可枚举出当前运行进程lyshark.exe中所有的后动线程信息，如下图所示；

当我们能够得到当前进程内的线程信息后，接下来就是实现如何挂起或恢复进程内的特定线程，挂起线程可以使用SuspendThread 其函数声明如下：

DWORD SuspendThread(  HANDLE hThread);

其中，hThread 是一个指向线程句柄的指针，指向要挂起的线程的句柄，该函数返回挂起前线程的线程计数器值，表示被挂起线程在挂起前还未执行的指令数目。

可以多次调用 SuspendThread 函数将同一个线程进行多次挂起，每次返回被挂起前线程的线程计数器值，每调用一次则会阻塞该线程，其状态会变为挂起状态。当该线程被 ResumeThread 恢复时，它将继续从上次挂起时的位置开始执行。

ResumeThread 函数声明如下：

DWORD ResumeThread(  HANDLE hThread);

其中，hThread 是线程句柄，指向要恢复的线程的句柄。

调用 ResumeThread 函数可以让一个被挂起的线程从上次挂起的位置开始继续执行，函数返回值是被恢复的线程的先前挂起次数。当被恢复的线程的挂起计数器归零时，其状态将自动变为非挂起状态，并开始继续执行。

当有了上述两个函数的支持那么挂起线程将变得很容易实现了，首先后去所有进程快照，接着就是直接打开OpenThread()符合要求的线程，此时只需要调用SuspendThread(hThread)即可挂起一个线程，调用ResumeThread(hThread)则可以恢复一个线程，具体实现代码如下所示；

#include <windows.h>#include <stdio.h>#include <TlHelp32.h>int Start_Stop_Thread(DWORD Pid, DWORD ThreadID, BOOL flag){    THREADENTRY32 te32 = { 0 };    te32.dwSize = sizeof(THREADENTRY32);    // 获取全部线程快照    HANDLE hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);    if (INVALID_HANDLE_VALUE != hThreadSnap)    {        // 获取快照中第一条信息        BOOL bRet = Thread32First(hThreadSnap, &te32);        while (bRet)        {            // 只过滤出 pid 里面的线程            if (Pid == te32.th32OwnerProcessID)            {                // 判断是否为ThreadID,暂停指定的TID                if (ThreadID == te32.th32ThreadID)                {                    // 打开线程                    HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, FALSE, te32.th32ThreadID);                    if (flag == TRUE)                    {                        ResumeThread(hThread);     // 恢复线程                    }                    else                    {                        SuspendThread(hThread);     // 暂停线程                    }                    CloseHandle(hThreadSnap);                }            }            // 获取快照中下一条信息            bRet = Thread32Next(hThreadSnap, &te32);        }        return 0;    }    return -1;}int main(int argc, char* argv[]){    // 暂停或恢复进程ID = 4204 里面的线程ID = 10056    int ret = Start_Stop_Thread(4204, 10056, TRUE);    // TRUE = 恢复线程 FALSE = 挂起线程    printf("状态: %d \n", ret);    system("pause");    return 0;}

当有了上述功能的支持以后，那么实现挂起进程将变得很容易，读者只需要在特定一个进程内枚举出所有的活动线程，并通过循环的方式逐个挂起即可实现挂起整个进程的效果，这段完整代码如下所示；

#include <windows.h>#include <iostream>#include <tlhelp32.h>#include <Psapi.h>#pragma comment(lib,"psapi.lib")#define NT_SUCCESS(Status) ((NTSTATUS)(Status) >= 0)#define SystemProcessesAndThreadsInformation    5       // 功能号typedef DWORD(WINAPI* PQUERYSYSTEM)(UINT, PVOID, DWORD, PDWORD);// 线程状态的枚举常量typedef enum _THREAD_STATE{  StateInitialized,    // 初始化状态  StateReady,          // 准备状态  StateRunning,        // 运行状态  StateStandby,  StateTerminated,     // 关闭  StateWait,           // 等待  StateTransition,     // 切换  StateUnknown}THREAD_STATE;// 线程处于等待的原因的枚举常量typedef enum _KWAIT_REASON{  Executive,  FreePage,  PageIn,  PoolAllocation,  DelayExecution,  Suspended,  UserRequest,  WrExecutive,  WrFreePage,  WrPageIn,  WrPoolAllocation,  WrDelayExecution,  WrSuspended,  WrUserRequest,  WrEventPair,  WrQueue,  WrLpcReceive,  WrLpcReply,  WrVirtualMemory,  WrPageOut,  WrRendezvous,  Spare2,  Spare3,  Spare4,  Spare5,  Spare6,  WrKernel,  MaximumWaitReason}KWAIT_REASON;typedef LONG   NTSTATUS;typedef LONG   KPRIORITY;typedef struct _CLIENT_ID{  DWORD        UniqueProcess;  DWORD        UniqueThread;} CLIENT_ID, * PCLIENT_ID;typedef struct _VM_COUNTERS{  SIZE_T        PeakVirtualSize;  SIZE_T        VirtualSize;  ULONG         PageFaultCount;  SIZE_T        PeakWorkingSetSize;  SIZE_T        WorkingSetSize;  SIZE_T        QuotaPeakPagedPoolUsage;  SIZE_T        QuotaPagedPoolUsage;  SIZE_T        QuotaPeakNonPagedPoolUsage;  SIZE_T        QuotaNonPagedPoolUsage;  SIZE_T        PagefileUsage;  SIZE_T        PeakPagefileUsage;} VM_COUNTERS;// 线程信息结构体typedef struct _SYSTEM_THREAD_INFORMATION{  LARGE_INTEGER   KernelTime;  LARGE_INTEGER   UserTime;  LARGE_INTEGER   CreateTime;  ULONG           WaitTime;  PVOID           StartAddress;  CLIENT_ID       ClientId;  KPRIORITY       Priority;  KPRIORITY       BasePriority;  ULONG           ContextSwitchCount;  LONG            State;// 状态,是THREAD_STATE枚举类型中的一个值  LONG            WaitReason;//等待原因, KWAIT_REASON中的一个值} SYSTEM_THREAD_INFORMATION, * PSYSTEM_THREAD_INFORMATION;typedef struct _UNICODE_STRING{  USHORT Length;  USHORT MaximumLength;  PWSTR  Buffer;} UNICODE_STRING, * PUNICODE_STRING;// 进程信息结构体typedef struct _SYSTEM_PROCESS_INFORMATION{  ULONG            NextEntryDelta;    // 指向下一个结构体的指针  ULONG            ThreadCount;       // 本进程的总线程数  ULONG            Reserved1[6];      // 保留  LARGE_INTEGER    CreateTime;        // 进程的创建时间  LARGE_INTEGER    UserTime;          // 在用户层的使用时间  LARGE_INTEGER    KernelTime;        // 在内核层的使用时间  UNICODE_STRING   ProcessName;       // 进程名  KPRIORITY        BasePriority;  ULONG            ProcessId;         // 进程ID  ULONG            InheritedFromProcessId;  ULONG            HandleCount;       // 进程的句柄总数  ULONG            Reserved2[2];      // 保留  VM_COUNTERS      VmCounters;  IO_COUNTERS      IoCounters;  SYSTEM_THREAD_INFORMATION Threads[5];    // 子线程信息数组}SYSTEM_PROCESS_INFORMATION, * PSYSTEM_PROCESS_INFORMATION;// 获取线程是被是否被挂起 1=表示线程被挂起  0=表示线程正常 -1=未知状态int IsThreadSuspend(DWORD dwProcessID, DWORD dwThreadID){  int nRet = 0;  NTSTATUS Status = 0;  PQUERYSYSTEM NtQuerySystemInformation = NULL;  PSYSTEM_PROCESS_INFORMATION pInfo = { 0 };  // 获取函数地址  NtQuerySystemInformation = (PQUERYSYSTEM) GetProcAddress(LoadLibrary("ntdll.dll"), "NtQuerySystemInformation");  DWORD   dwSize = 0;  // 获取信息所需的缓冲区大小  Status = NtQuerySystemInformation(SystemProcessesAndThreadsInformation,// 要获取的信息的类型    NULL, // 用于接收信息的缓冲区    0,  // 缓冲区大小    &dwSize  );  // 申请缓冲区  char* pBuff = new char[dwSize];  pInfo = (PSYSTEM_PROCESS_INFORMATION)pBuff;  if (pInfo == NULL)    return -1;  // 再次调用函数, 获取信息  Status = NtQuerySystemInformation(SystemProcessesAndThreadsInformation, // 要获取的信息的类型    pInfo, // 用于接收信息的缓冲区    dwSize,  // 缓冲区大小    &dwSize  );  if (!NT_SUCCESS(Status))  {    /*如果函数执行失败*/    delete[] pInfo;    return -1;  }  // 遍历结构体,找到对应的进程  while (1)  {    // 判断是否还有下一个进程    if (pInfo->NextEntryDelta == 0)      break;    // 判断是否找到了ID    if (pInfo->ProcessId == dwProcessID)    {      // 找到该进程下的对应的线程,也就是遍历所有线程      for (DWORD i = 0; i < pInfo->ThreadCount; i++)      {        if (pInfo->Threads[i].ClientId.UniqueThread == dwThreadID)        {          // 找到线程           // 如果线程被挂起          if (pInfo->Threads[i].State == StateWait&& pInfo->Threads[i].WaitReason == Suspended)          {            nRet = 1;            break;          }        }      }      break;    }    // 迭代到下一个节点    pInfo = (PSYSTEM_PROCESS_INFORMATION)(((PUCHAR)pInfo) + pInfo->NextEntryDelta);  }  delete[] pBuff;  return nRet;}// 设置进程状态 挂起/非挂起int SuspendProcess(DWORD dwProcessID, BOOL fSuspend){  HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, dwProcessID);  if (hSnapshot != INVALID_HANDLE_VALUE)  {    THREADENTRY32 te = { sizeof(te) };    BOOL fOk = Thread32First(hSnapshot, &te);    for (; fOk; fOk = Thread32Next(hSnapshot, &te))    {      if (te.th32OwnerProcessID == dwProcessID)      {        HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME,FALSE, te.th32ThreadID);        if (hThread != NULL)        {          if (fSuspend)          {            if (IsThreadSuspend(dwProcessID, te.th32ThreadID) == 0)            {              SuspendThread(hThread);            }            else            {              return 0;            }          }          else          {            if (IsThreadSuspend(dwProcessID, te.th32ThreadID) == 1)            {              ResumeThread(hThread);            }            else            {              return 0;            }          }        }        CloseHandle(hThread);      }    }  }  CloseHandle(hSnapshot);  return 1;}int main(int argc, char *argv[]){  // 挂起进程  SuspendProcess(20308, TRUE);  // 恢复进程  SuspendProcess(20308, FALSE);  return 0;}

读者可自行编译并运行上述代码，通过调用SuspendProcess函数并以此传入需要挂起的进程PID以及一个状态，当该状态为TRUE时则代表挂起进程，而当状态值为FALSE时则代表为恢复一个进程，当一个进程被挂起后其会出现卡死的现象，当恢复后一切都会变得正常。