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時則代表為恢復一個進程，當一個進程被掛起後其會出現卡死的現象，當恢復後一切都會變得正常。

本文作者： 王瑞
本文鏈接： https://www.lyshark.com/post/5fbc3082.html
版權聲明： 本博客所有文章除特別聲明外，均採用 BY-NC-SA 許可協議。轉載請註明出處！