C++ 获取进程启动参数

已于 2024-07-29 16:05:50 修改
阅读量1.4k 收藏 2
点赞数 1
分类专栏： C++ 随笔 文章标签： C++ 启动参数 ProcessMemory
于 2022-09-21 15:43:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CAir2/article/details/126974067
版权

博客参考：获取进程的信息

下面代码为获取进程启动参数代码：ProcUtils.h

#pragma once

#define NT_SUCCESS(x) ((x) >= 0)
#define ProcessBasicInformation 0

typedef NTSTATUS(NTAPI *pfnNtWow64QueryInformationProcess64)(
	IN HANDLE ProcessHandle,
	IN ULONG ProcessInformationClass,
	OUT PVOID ProcessInformation,
	IN ULONG ProcessInformationLength,
	OUT PULONG ReturnLength OPTIONAL
	);

typedef LONG(WINAPI* pfnNtReadVirtualMemory)(
			HANDLE ProcessHandle, PVOID BaseAddress,
			PVOID Buffer,
			ULONG NumberOfBytesToRead,
			PULONG NumberOfBytesReaded);
			
typedef NTSTATUS(NTAPI *pfnNtWow64ReadVirtualMemory64)(
	IN HANDLE ProcessHandle,
	IN PVOID64 BaseAddress,
	OUT PVOID Buffer,
	IN ULONG64 Size,
	OUT PULONG64 NumberOfBytesRead
	);

typedef
NTSTATUS(WINAPI *pfnNtQueryInformationProcess)
(HANDLE ProcessHandle, ULONG ProcessInformationClass,
PVOID ProcessInformation, UINT32 ProcessInformationLength,
UINT32* ReturnLength);

typedef struct _PROCESS_BASIC_INFORMATION32 {
	NTSTATUS ExitStatus;
	UINT32 PebBaseAddress;
	UINT32 AffinityMask;
	UINT32 BasePriority;
	UINT32 UniqueProcessId;
	UINT32 InheritedFromUniqueProcessId;
} PROCESS_BASIC_INFORMATION32;

typedef struct _UNICODE_STRING32
{
	USHORT Length;
	USHORT MaximumLength;
	PWSTR Buffer;
} UNICODE_STRING32, *PUNICODE_STRING32;

typedef struct _PEB32
{
	UCHAR InheritedAddressSpace;
	UCHAR ReadImageFileExecOptions;
	UCHAR BeingDebugged;
	UCHAR BitField;
	ULONG Mutant;
	ULONG ImageBaseAddress;
	ULONG Ldr;
	ULONG ProcessParameters;
	ULONG SubSystemData;
	ULONG ProcessHeap;
	ULONG FastPebLock;
	ULONG AtlThunkSListPtr;
	ULONG IFEOKey;
	ULONG CrossProcessFlags;
	ULONG UserSharedInfoPtr;
	ULONG SystemReserved;
	ULONG AtlThunkSListPtr32;
	ULONG ApiSetMap;
} PEB32, *PPEB32;

typedef struct _RTL_USER_PROCESS_PARAMETERS32 {
	BYTE Reserved1[16];
	ULONG Reserved2[10];
	UNICODE_STRING32 ImagePathName;
	UNICODE_STRING32 CommandLine;
} RTL_USER_PROCESS_PARAMETERS32, *PRTL_USER_PROCESS_PARAMETERS32;

typedef struct _PEB_LDR_DATA32
{
	ULONG Length;
	BOOLEAN Initialized;
	ULONG SsHandle;
	LIST_ENTRY32 InLoadOrderModuleList;
	LIST_ENTRY32 InMemoryOrderModuleList;
	LIST_ENTRY32 InInitializationOrderModuleList;
	ULONG EntryInProgress;
} PEB_LDR_DATA32, *PPEB_LDR_DATA32;

typedef struct _LDR_DATA_TABLE_ENTRY32
{
	LIST_ENTRY32 InLoadOrderLinks;
	LIST_ENTRY32 InMemoryOrderModuleList;
	LIST_ENTRY32 InInitializationOrderModuleList;
	ULONG DllBase;
	ULONG EntryPoint;
	ULONG SizeOfImage;
	UNICODE_STRING32 FullDllName;
	UNICODE_STRING32 BaseDllName;
	ULONG Flags;
	USHORT LoadCount;
	USHORT TlsIndex;
	union
	{
		LIST_ENTRY32 HashLinks;
		ULONG SectionPointer;
	};
	ULONG CheckSum;
	union
	{
		ULONG TimeDateStamp;
		ULONG LoadedImports;
	};
	ULONG EntryPointActivationContext;
	ULONG PatchInformation;
} LDR_DATA_TABLE_ENTRY32, *PLDR_DATA_TABLE_ENTRY32;

typedef struct _PROCESS_BASIC_INFORMATION64 {
	NTSTATUS ExitStatus;
	UINT32 Reserved0;
	UINT64 PebBaseAddress;
	UINT64 AffinityMask;
	UINT32 BasePriority;
	UINT32 Reserved1;
	UINT64 UniqueProcessId;
	UINT64 InheritedFromUniqueProcessId;
} PROCESS_BASIC_INFORMATION64;

typedef struct _PEB64
{
	UCHAR InheritedAddressSpace;
	UCHAR ReadImageFileExecOptions;
	UCHAR BeingDebugged;
	UCHAR BitField;
	ULONG64 Mutant;
	ULONG64 ImageBaseAddress;
	ULONG64 Ldr;
	ULONG64 ProcessParameters;
	ULONG64 SubSystemData;
	ULONG64 ProcessHeap;
	ULONG64 FastPebLock;
	ULONG64 AtlThunkSListPtr;
	ULONG64 IFEOKey;
	ULONG64 CrossProcessFlags;
	ULONG64 UserSharedInfoPtr;
	ULONG SystemReserved;
	ULONG AtlThunkSListPtr32;
	ULONG64 ApiSetMap;
} PEB64, *PPEB64;

typedef struct _PEB_LDR_DATA64
{
	ULONG Length;
	BOOLEAN Initialized;
	ULONG64 SsHandle;
	LIST_ENTRY64 InLoadOrderModuleList;
	LIST_ENTRY64 InMemoryOrderModuleList;
	LIST_ENTRY64 InInitializationOrderModuleList;
	ULONG64 EntryInProgress;
} PEB_LDR_DATA64, *PPEB_LDR_DATA64;

typedef struct _UNICODE_STRING64
{
	USHORT Length;
	USHORT MaximumLength;
	ULONG64 Buffer;
} UNICODE_STRING64, *PUNICODE_STRING64;

typedef struct _LDR_DATA_TABLE_ENTRY64
{
	LIST_ENTRY64 InLoadOrderLinks;
	LIST_ENTRY64 InMemoryOrderModuleList;
	LIST_ENTRY64 InInitializationOrderModuleList;
	ULONG64 DllBase;
	ULONG64 EntryPoint;
	ULONG SizeOfImage;
	UNICODE_STRING64 FullDllName;
	UNICODE_STRING64 BaseDllName;
	ULONG Flags;
	USHORT LoadCount;
	USHORT TlsIndex;
	union
	{
		LIST_ENTRY64 HashLinks;
		ULONG64 SectionPointer;
	};
	ULONG CheckSum;
	union
	{
		ULONG TimeDateStamp;
		ULONG64 LoadedImports;
	};
	ULONG64 EntryPointActivationContext;
	ULONG64 PatchInformation;
} LDR_DATA_TABLE_ENTRY64, *PLDR_DATA_TABLE_ENTRY64;

typedef struct _RTL_USER_PROCESS_PARAMETERS64 {
	BYTE Reserved1[16];
	ULONG64 Reserved2[10];
	UNICODE_STRING64 ImagePathName;
	UNICODE_STRING64 CommandLine;
} RTL_USER_PROCESS_PARAMETERS64, *PRTL_USER_PROCESS_PARAMETERS64;

class ProcUtils
{
public:
	static bool get_proc_id(const std::string& proc_name, DWORD &pid);
	static int get_proc_command(DWORD pid, std::string& cmd_line);
};

ProcUtils.cpp

#include "stdafx.h"
#include "ProcUtils.h"
#include <algorithm>
#include <Tlhelp32.h>
#include "StringUtil.h"

bool ProcUtils::get_proc_id(const std::string& proc_name, DWORD& pid)
{
	pid = 0;
	HANDLE proc_snap = INVALID_HANDLE_VALUE;
	bool ret_value = false;
	do {
		if (!proc_name.length()) break;
		std::string proc_name_tmp = proc_name;
		std::transform(proc_name_tmp.begin(), proc_name_tmp.end(), proc_name_tmp.begin(), ::tolower);
		proc_snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
		if (INVALID_HANDLE_VALUE == proc_snap) break;
		PROCESSENTRY32 pe32;
		pe32.dwSize = sizeof(pe32);
		BOOL flag = ::Process32First(proc_snap, &pe32);
		while (flag)
		{
			std::string exe_name = pe32.szExeFile;
			std::transform(exe_name.begin(), exe_name.end(), exe_name.begin(), ::tolower);
			if (exe_name == proc_name_tmp)
			{
				ret_value = true;
				pid = pe32.th32ProcessID;
				break;
			}
			flag = ::Process32Next(proc_snap, &pe32);
		}
	} while (0);

	if (INVALID_HANDLE_VALUE != proc_snap)
	{
		CloseHandle(proc_snap);
		proc_snap = INVALID_HANDLE_VALUE;
	}
	return ret_value;
}

int ProcUtils::get_proc_command(DWORD pid, std::wstring& cmd_line) 
{
	
	commandline.clear();
			DWORD dwProcessId = -1;
			GetProcessId(szProcessName, dwProcessId);
			if (dwProcessId == -1) return -1;
			HANDLE proc = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_ALL_ACCESS, false, dwProcessId);
			int err = GetLastError();
			if (NULL == proc) return err;

			BOOL bTarget = FALSE;
			BOOL bSource = FALSE;
			IsWow64Process(GetCurrentProcess(), &bSource);
			IsWow64Process(proc, &bTarget);

			//self x64
			if (!bSource)
			{
				HMODULE NtdllModule = GetModuleHandle(_T("ntdll.dll"));
				pfnNtQueryInformationProcess NtQueryInformationProcess = (pfnNtQueryInformationProcess)GetProcAddress(NtdllModule, "NtQueryInformationProcess");
				pfnNtReadVirtualMemory NtReadVirtualMemory = (pfnNtReadVirtualMemory)GetProcAddress(GetModuleHandle(_T("ntdll.dll")), "NtReadVirtualMemory");
				PROCESS_BASIC_INFORMATION64 pbi64 = { 0 };
				if (NT_SUCCESS(NtQueryInformationProcess(proc, ProcessBasicInformation, &pbi64, sizeof(pbi64), NULL)))
				{
					PEB64 peb = { 0 };
					if (NT_SUCCESS(NtReadVirtualMemory(proc, (PVOID64)(pbi64.PebBaseAddress), &peb, sizeof(peb), NULL)))
					{
						RTL_USER_PROCESS_PARAMETERS64 user_proc_params = { 0 };
						if (NT_SUCCESS(NtReadVirtualMemory(proc, (PVOID64)(peb.ProcessParameters), &user_proc_params, sizeof(user_proc_params), NULL)))
						{
							wchar_t buf[4096] = { 0 };
							DWORD data_size = user_proc_params.CommandLine.Length > 4090 ? 4090 : user_proc_params.CommandLine.Length;
							if (NT_SUCCESS(NtReadVirtualMemory(proc, (PVOID64)(user_proc_params.CommandLine.Buffer), &buf, data_size, NULL)))
							{
								commandline = std::wstring(buf + 1);
							}
						}
					}
				}
			}
			//self x86
			else
			{
				//target x86
				if (bTarget)
				{
					HMODULE NtdllModule = GetModuleHandle(_T("ntdll.dll"));
					pfnNtQueryInformationProcess NtQueryInformationProcess = (pfnNtQueryInformationProcess)GetProcAddress(NtdllModule, "NtQueryInformationProcess");
					PROCESS_BASIC_INFORMATION32 pbi32 = { 0 };
					if (NT_SUCCESS(NtQueryInformationProcess(proc, ProcessBasicInformation, &pbi32, sizeof(pbi32), NULL)))
					{
						PEB32 peb = { 0 };
						if (ReadProcessMemory(proc, (PVOID)(pbi32.PebBaseAddress), &peb, sizeof(peb), NULL))
						{
							RTL_USER_PROCESS_PARAMETERS32 user_proc_params = { 0 };
							if (ReadProcessMemory(proc, (PVOID)(peb.ProcessParameters), &user_proc_params, sizeof(user_proc_params), NULL))
							{
								wchar_t buf[4096] = { 0 };
								DWORD data_size = user_proc_params.CommandLine.Length > 4090 ? 4090 : user_proc_params.CommandLine.Length;
								if (ReadProcessMemory(proc, (PVOID)(user_proc_params.CommandLine.Buffer), &buf, data_size, NULL))
								{
									commandline = std::wstring(buf + 1);
								}
							}
						}
					}
				}
				//target x64
				else
				{
					HMODULE NtdllModule = GetModuleHandle(_T("ntdll.dll"));
					pfnNtWow64QueryInformationProcess64 NtWow64QueryInformationProcess64 = (pfnNtWow64QueryInformationProcess64)GetProcAddress(NtdllModule, "NtWow64QueryInformationProcess64");
					pfnNtWow64ReadVirtualMemory64 NtWow64ReadVirtualMemory64 = (pfnNtWow64ReadVirtualMemory64)GetProcAddress(NtdllModule, "NtWow64ReadVirtualMemory64");
					PROCESS_BASIC_INFORMATION64 pbi64 = { 0 };
					if (NT_SUCCESS(NtWow64QueryInformationProcess64(proc, ProcessBasicInformation, &pbi64, sizeof(pbi64), NULL)))
					{
						PEB64 peb = { 0 };
						if (NT_SUCCESS(NtWow64ReadVirtualMemory64(proc, (PVOID64)(pbi64.PebBaseAddress), &peb, sizeof(peb), NULL)))
						{
							RTL_USER_PROCESS_PARAMETERS64 user_proc_params = { 0 };
							if (NT_SUCCESS(NtWow64ReadVirtualMemory64(proc, (PVOID64)(peb.ProcessParameters), &user_proc_params, sizeof(user_proc_params), NULL)))
							{
								wchar_t buf[4096] = { 0 };
								DWORD data_size = user_proc_params.CommandLine.Length > 4090 ? 4090 : user_proc_params.CommandLine.Length;
								if (NT_SUCCESS(NtWow64ReadVirtualMemory64(proc, (PVOID64)(user_proc_params.CommandLine.Buffer), &buf, data_size, NULL)))
								{
									commandline = std::wstring(buf + 1);
								}
							}
						}
					}
				}
			}
			CloseHandle(proc);
			return 0;
}
CAir2
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++语言获取进程id,C\C++下获取系统进程或线程ID（转）
weixin_35684578的博客
05-21 4695
在程序开发时有时需要获取线程和进程ID以分析程序运行()windows下获取进程或线程ID通过调用系统提供的GetCurProcessId或GetNowThreadID来获取当前程序代码运行时的进程或线程ID示例代码：#include "windows.h"printf("now pid is %d", GetCurrentProcessId());printf("now tid is %d", ...
C++实现进程隐藏
04-22
如果需要在运行后隐藏已存在的进程，可以使用`OpenProcess`函数获取进程句柄，然后调用`SetWindowLong`和`ShowWindow`来改变窗口属性。 然而，值得注意的是，隐藏进程并不意味着它完全不可检测。高级的系统监控工具...
获取其他进程启动参数方法
07-21
获取其他进程启动参数方法 c++代码 IFEO办法等
C++获取进程启动参数
05-24 6528
#include "stdafx.h" #include #include #define ProcessBasicInformation 0 typedef struct { USHORT Length; USHORT MaximumLength; PWSTR Buffer; } UNICODE_STRING, *PUNICODE_STRING; typedef struct
c++ 在任意库中获取进程启动参数和参数个数
最新发布
asiwxy的博客
03-07 437
【代码】c++ 在任意库中获取进程启动参数和参数个数。
C++传入启动参数
hzxhxyj1的博客
07-09 423
1.存入文件test.cpp，用g++编译test.exe。2.Windows+R，输入cmd打开命令提示符。实际上，第0个参数是test。,看到如下界面调试成功。注意：为什么多一个参数？
C++ 获取其它进程命令行参数
DeathMemory的专栏
12-11 7400
wintenl.h 下载地址 #include "stdafx.h" #include "winternl.h" typedef NTSTATUS (WINAPI *NtQueryInformationProcessFake)(HANDLE, DWORD, PVOID, ULONG, PULONG); NtQueryInformationProcessFake ntQ = NU
Windows下C++解析程序的启动参数
r5014的博客[Eosin_Sky]
11-24 999
为了方便控制程序的各种功能的开关和特性 我们往往会在程序启动的时候加入各种参数来控制程序的某些特性，或是传入一些数据。 本例提供了比较方便的代码段来供处理这些事宜。 代码段是[CmdlineParser]类的具体实现 CmdlineParser.hpp #pragma once #include <string> //#include <tchar.h> #include <stdint.h> #include <map> #include &l
C++ 获取进程信息
qq_38933606的博客
08-28 1984
通常对于一个正在执行的进程而言，我们会关注进程的内存/CPU占用，网络连接，启动参数，映像路径，线程，堆栈等信息。windows平台没有直接提供获取进程启动参数的接口，但是可以通过解析进程的PEB（进程环境块）地址，获取信息。：这个文件包含了有关进程状态的各种信息，如进程ID、父进程ID、运行状态、内存使用情况等。：这个文件包含了进程的内存映射信息，显示了进程所使用的内存地址范围及其对应的权限。：这是一个文件夹，包含了进程当前打开的文件描述符列表。：这是每个正在运行的进程都有一个对应的目录，其中。
C++ Windows 下获取进程名、可执行文件路径
biangechengxu的博客
11-18 3127
GetModuleFileNameEx: DWORD GetModuleFileNameEx(HANDLE hProcess,HMODULE hModule,LPTSTR lpFilename,DWORD nSize) hProcess是目标进程的句柄、hModule是目标模块的句柄(当此参数为NULL时函数返回的是进程可执行文件的路径)、lpFilename是存放路径的字符串缓冲区、nSize表示缓冲区的大小。函数调用失败将返回0。注：进程的句柄须有PROCESS_QUERY_INFORMATIO
C++程序的启动与命令行参数
u011770223的博客
06-12 2725
1.C++目录 用命令行启动C++程序时的目录即为当前目录，比如在build中启动程序main，main中代码的目录即为build。 2.命令行参数 C/C++语言中的main函数，经常带有参数argc，argv，如下： int main(int argc, char** argv) int main(int argc, char* argv[]) 其中 argc 表示参数个数，arg...
如何得到其它进程的启动命令行参数.vc这个程序可以得到其他进程的命令行参数_NtQueryInformationProcess第二个参数为0
03-20
总结来说，这个程序通过调用Windows API中的NtQueryInformationProcess函数，并设置适当的参数，实现了获取其他进程启动时的命令行参数的功能。这对于系统监控、程序调试或自动化脚本编写有着重要的实用价值。通过...
Windows傀儡进程实现C++代码
04-28
1. 包含必要的Windows头文件，如`Windows.h`，获取进程和线程相关的API。 2. 使用`CreateProcess`函数创建傀儡进程，传递必要的参数。 3. 通过进程句柄对傀儡进程进行操作，如`WaitForSingleObject`等待其结束，`...
获取进程启动时间函数测试工具
12-11
总的来说，"获取进程启动时间函数测试工具"是一个实用的开发辅助工具，它帮助开发者验证和优化获取进程启动时间的代码，确保其在复杂环境下的稳定性和效率。通过深入理解和使用此类工具，我们可以提升系统监控和故障...
c++ win32 启动进程并传命令行参数，杀死进程
u011737099的专栏
08-25 1110
获取当前dll路径 static HMODULE GetSelfModuleHandle() { MEMORY_BASIC_INFORMATION mbi; return ((::VirtualQuery(GetSelfModuleHandle, &mbi, sizeof(mbi)) != 0) ? (HMODULE)mbi.AllocationBase : NULL); } std::string GetCurDllPath() { WCHAR szModuleFileName[MAX
String Hex互相转换
CAir2的专栏
08-22 5418
String和Hex互相转换。 1.String转Hex，由于String元素本身就是数字，所以我们可以直接Format16进制。但是需要注意char是有符号的，所以我们需要转化为无符号的。whacr不需要转化 2.Hex转String。在转之前我们需要知道Hex是由wchar源转换的还是char转的。因为wchar占2个字节。而char一个字节。转换为对应的字符串的时候，wchar对应4个字符。...
Error 193:%1 不是合法的Win32 应用程序 &&查看程序是x86还是x64
CAir2的专栏
10-15 4892
ErrCode=193 %1 不是合法的Win32 应用程序 当64bit的应用程序exe加载32bit编译的动态库，提示报错 LoadLibrary ErrCode=193 %1 不是合法的Win32 应用程序，原因如下： exe是否是64bit的 dll是否是64bit编译 dll所依赖的库是不是相应位数的 怎么查看应用程序是否为32或者64位？ 直接用记事本或者notepad++打开应用...
获取电脑硬件信息
CAir2的专栏
05-27 4335
获取设备硬件信息
VMMAP定位内存泄露
CAir2的专栏
03-28 4247
1.启动VMMAP，配置运行程序pdb位置：Options-&gt;Configure Symbols 2.通过VMMAP，启动应用程序：File-&gt;Select Process 3.分析应用程序堆数据 注意：如果内存泄露随着时间推移，肯定相同的内存会越来越多，此时我们可以通过调用堆栈分析，如下 4.如果通过堆栈还是比较难以定位，或者VMMAP崩溃了，那么只能结合VS...
LINUX C++ 在 进程 XXX 中 启动 进程YYY 并获取 YYY的PID
06-11
在 Linux 平台上，可以使用 `fork()` 系统调用创建子进程，并使用 `getpid()` 函数获取父进程的 PID 和获取子进程的 PID。如果要在进程 XXX 中启动进程 YYY，可以使用 `fork()` 创建子进程，然后在子进程中使用 `execvp()` 函数启动进程 YYY。以下是一个示例代码： ```c++ #include <iostream> #include <unistd.h> #include <sys/types.h> #include <sys/wait.h> int main() { pid_t pid = fork(); if (pid == 0) { // 子进程 char* args[] = {"./YYY", NULL}; execvp(args[0], args); // 如果 execvp() 返回，则启动进程 YYY 失败 std::cerr << "启动进程 YYY 失败" << std::endl; return 1; } else if (pid > 0) { // 父进程 std::cout << "父进程的 PID: " << getpid() << std::endl; std::cout << "子进程的 PID: " << pid << std::endl; int status; waitpid(pid, &status, 0); std::cout << "子进程退出状态: " << WEXITSTATUS(status) << std::endl; } else { // fork() 失败 std::cerr << "fork() 失败" << std::endl; return 1; } return 0; } ``` 在上述代码中，我们使用 `fork()` 创建了一个子进程。在子进程中，我们使用 `execvp()` 函数启动进程 YYY；在父进程中，我们使用 `waitpid()` 函数等待子进程退出，并使用 `WEXITSTATUS()` 函数获取子进程的退出状态并输出到控制台。需要注意的是，`execvp()` 函数如果返回则启动进程 YYY 失败，因此需要在子进程中处理启动失败的情况。在调用 `waitpid()` 函数时，第三个参数为 0 表示等待子进程退出，如果传入 WNOHANG 则表示非阻塞等待，即如果子进程没有退出，则立即返回。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值