掛起與恢復進程是指暫停或恢復進程的工作狀態，以達到一定的控制和管理效果。在 Windows 操作系統中，可以使用系統提供的函數實現進程的掛起和恢復，以達到對進程的控制和調度。需要註意，過度使用進程掛起/恢復操作可能會造成系統性能的降低，導致死鎖等問題，因此在使用時應該謹慎而慎重。同時，通過和其他進程... ...
掛起與恢復進程是指暫停或恢復進程的工作狀態，以達到一定的控制和管理效果。在 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 許可協議。轉載請註明出處！
文章出處：https://www.cnblogs.com/LyShark/p/17725667.html
本博客所有文章除特別聲明外，均採用 BY-NC-SA 許可協議。轉載請註明出處！
