Windows创建进程实例：权限及子进程监控相关-Aet

Bingliaolong 2023-10-19 18:05 Aet | 隐藏边栏 | 抢沙发 | 18 0

文章评分 1 次，平均分 5.0 ：

Windows用户权限

标准用户

普通用户的权限被限制，以防止他们进行可能影响系统稳定性、安全性或其他用户的操作
不能修改系统设置，例如时间、日期或安装新的设备驱动程序
普通用户可能无法安装或卸载应用程序
只能访问自己的文件和某些公共文件，但不能访问其他用户的文件或系统文件
普通用户不能执行需要管理员权限的系统任务，如关机计算机、管理系统服务或查看安全日志

管理员用户

具有对系统的完全控制权，可以执行任何操作
可以更改所有系统设置
可以安装、更新或卸载应用程序和设备驱动程序
可以访问、修改或删除任何文件，包括其他用户的文件和系统文件
可以创建或删除用户账户、分配用户权限和管理系统服务
在Windows Vista及更高版本中，尽管管理员有完全的系统权限，但他们仍然受到用户帐户控制（UAC）的约束，该控制要求管理员在进行可能影响系统的操作时进行确认

LocalSystem

这是一个高权限的服务账户，用于运行Windows的核心服务
LocalSystem账户的权限甚至超过了管理员
1. 它几乎可以在系统上做任何事情
尽管此账户具有广泛的权限，但它主要是为系统服务和应用程序使用的，并不建议用户或管理员使用此账户

问题

普通用户调起的程序，无法通过CreateProcess调起需要管理员权限的exe。
1. 可以使用ShellExecute或ShellExecuteEx，传runas，请求管理员权限
2. 这种调起方式会弹出UAC窗口
对于自解压程序，由于启动后，实际上它先是做了解压动作，然后调起了解压后的某个exe，导致我们创建的进程很快结束返回了，无法通过创建的进程句柄来监控目标进程。
1. 使用job内核对象对创建的进程进行关联，以完成端口来等待所有进程结束。

实例

简述

在进程A里面根据权限创建进程，来调起目标exe，如下：
1. 如果需要管理员权限，就调起这个helper.exe，并参数传过去，让helper.exe在它里面去用ShellExecute方式去请求管理员权限
2. 如果不需要管理员权限，就用CreateProcess来调起这个目标exe，有权限有成功，没权限就失败

sync_status installer_helper::create_process(const wchar_t* path) {

DWORD exitCode;

sync_status syst(sync_status::em_syst_install_default);

std::wstring par = path;

std::wstring tmp_str = to_wstr(m_param.c_str());

std::wstring cmd = par + L" " + tmp_str;

wchar_t buf[MAX_PATH];

wcscpy_s(buf, cmd.c_str());

if (m_level > RunLevel::asInvoker) {

TCHAR szPath[MAX_PATH];

if (GetCurrentDllPath(szPath, sizeof(szPath) / sizeof(TCHAR)) == FALSE) {

return sync_status::em_syst_create_ist_process_failed;

}

PathRemoveFileSpec(szPath);

std::wstring tPath = szPath;

tPath.append(L"\\AppCenterHelper.exe");

SHELLEXECUTEINFO execInfo = { 0 };

execInfo.cbSize = sizeof(SHELLEXECUTEINFO);

execInfo.fMask = SEE_MASK_NOCLOSEPROCESS;

execInfo.hwnd = NULL;

execInfo.lpVerb = L"runas";

execInfo.lpFile = tPath.c_str();

execInfo.lpParameters = buf;

execInfo.lpDirectory = NULL;

execInfo.nShow = SW_SHOW;

execInfo.hInstApp = NULL;

execInfo.hProcess = NULL;

do {

if (!ShellExecuteEx(&execInfo)) {

DWORD dwError = GetLastError();

if (dwError == ERROR_ACCESS_DENIED) {

return sync_status::em_syst_ist_no_permissions;

} else if (dwError == ERROR_BAD_FORMAT) {

return sync_status::em_syst_ist_bad_format_exe;

} else {

return sync_status::em_syst_create_ist_process_failed;

}

if (execInfo.hProcess == NULL) {

return sync_status::em_syst_create_process_failed;

}

WaitForSingleObject(execInfo.hProcess, INFINITE);

if (GetExitCodeProcess(execInfo.hProcess, &exitCode)) {

syst = (exitCode == 0) ? sync_status::em_syst_install_success

: sync_status::em_syst_install_failed;

}

CloseHandle(execInfo.hProcess);

} while (false);

} else {

STARTUPINFO si = { sizeof(si) };

PROCESS_INFORMATION pi;

ZeroMemory(&si, sizeof(si));

si.cb = sizeof(si);

ZeroMemory(&pi, sizeof(pi));

if (!CreateProcess(NULL, buf, NULL, NULL, FALSE, NULL, NULL, NULL, &si, &pi)) {

DWORD dwError = GetLastError();

if (dwError == ERROR_ACCESS_DENIED) {

return sync_status::em_syst_ist_no_permissions;

} else if (dwError == ERROR_BAD_FORMAT) {

return sync_status::em_syst_ist_bad_format_exe;

} else {

return sync_status::em_syst_create_ist_process_failed;

}

if (pi.hProcess == NULL || pi.hProcess == INVALID_HANDLE_VALUE) {

return sync_status::em_syst_create_process_failed;

}

WaitForSingleObject(pi.hProcess, INFINITE);

if (GetExitCodeProcess(pi.hProcess, &exitCode)) {

syst = (exitCode == 0) ? sync_status::em_syst_install_success

: sync_status::em_syst_install_failed;

}

CloseHandle(pi.hThread);

CloseHandle(pi.hProcess);

}

return syst;

}

管理员权限

为什么管理员权限通过helper.exe来调？
1. 因为直接在上面使用ShellExecute来请求管理员权限，返回的是创建的进程的句柄。这对于普通程序来说是够用了
2. 但是我这里去操作的是安装，卸载程序。我在调试过程中发现，部分安装包，卸载程序是自解压程序，也就是调起该程序后，它会调起其他的exe，而它调起的其他的exe，我们获取句柄是比较麻烦的
3. 而我的需求是调起这个程序后，要阻塞到它完全结束。所以直接用ShellExecute方式来创建的进程，在面对自解压程序时，表现为：我们创建的程序马上结束返回了，但是该进程在结束之前创建了一个其他的进程来真正的做事情。这样的话，用WaitForSingleObject监控不了，因为不知道那个子进程的句柄。
4. 当然也可以创建进程快照，匹配进程名以及命令行参数的方式来定位的目标进程，但是这样的方式又繁琐，还涉及权限，如果我们一开始调起的进程是普通用户权限的话，后面在通过ReadProcessMemory读取进程命令行参数什么的，会失败。
5. 所以呢，得使用CreateProcess来创建目标进程，在创建的时候，传参数CREATE_SUSPENDED，让进程先暂停，等我们把创建的进程和job对象关联后，再让进程ResumeThread。
6. 这样，该进程创建的子进程，我们就可以跟踪到了。

普通权限

这个比较清晰，就是去创建进程，成功就成功，失败就失败

helper.exe

设置了一个单实例
然后验证了命令行，因为主要靠命令行来调起
创建了job内核对象和一个JOBOBJECT_ASSOCIATE_COMPLETION_PORT对象，并把他们关联到了一起
1. 这使得程序可以接收关于Job状态的通知
这样目标exe启动后创建的所有进程，job都有感知
而当这些所有的进程都结束后，通过这个GetQueuedCompletionStatus来感知状态
1. 使用GetQueuedCompletionStatus来等待Job的完成状态。
2. 当所有的进程都完成时，它将收到JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO消息

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

#include <windows.h>

#include <set>

#include <vector>

HANDLE InitAppMutex() {

HANDLE hMutex = NULL;

SECURITY_ATTRIBUTES SecurityAttributes;

SECURITY_DESCRIPTOR SecurityDesc;

memset(&SecurityAttributes, 0, sizeof(SECURITY_ATTRIBUTES));

BOOL bRet = InitializeSecurityDescriptor(&SecurityDesc,

SECURITY_DESCRIPTOR_REVISION);

if (bRet == FALSE) {

return NULL;

}

bRet = SetSecurityDescriptorDacl(&SecurityDesc, TRUE, NULL, FALSE);

if (bRet == FALSE) {

return NULL;

}

SecurityAttributes.nLength = sizeof(SECURITY_ATTRIBUTES);

SecurityAttributes.bInheritHandle = FALSE;

SecurityAttributes.lpSecurityDescriptor = &SecurityDesc;

hMutex = CreateMutex(&SecurityAttributes,

FALSE,

L"Local\\appcenter_helper_fuck");

if (hMutex == NULL) {

return NULL;

}

DWORD dwLastError = GetLastError();

if (dwLastError == ERROR_ALREADY_EXISTS) {

CloseHandle(hMutex);

return NULL;

}

return hMutex;

}

int WINAPI wWinMain(_In_ HINSTANCE hInstance,

_In_opt_ HINSTANCE hPrevInstance,

_In_ LPWSTR lpCmdLine,

_In_ int nCmdShow) {

if (lpCmdLine == NULL) {

return -1;

}

if (!*lpCmdLine) {

return -1;

}

HANDLE hd = InitAppMutex();

if (hd == NULL) {

return -1;

}

HANDLE hJob = CreateJobObject(NULL, NULL);

if (hJob == NULL) {

return -1;

}

JOBOBJECT_ASSOCIATE_COMPLETION_PORT port;

port.CompletionKey = hJob;

port.CompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 1);

SetInformationJobObject(hJob, JobObjectAssociateCompletionPortInformation, &port, sizeof(port));

STARTUPINFO si = { sizeof(si) };

PROCESS_INFORMATION pi;

ZeroMemory(&si, sizeof(si));

si.cb = sizeof(si);

ZeroMemory(&pi, sizeof(pi));

if (!CreateProcess(NULL, lpCmdLine, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi)) {

CloseHandle(hJob);

return -1;

}

AssignProcessToJobObject(hJob, pi.hProcess);

ResumeThread(pi.hThread);

HANDLE hProc = pi.hProcess;

if (hProc == NULL || hProc == INVALID_HANDLE_VALUE) {

CloseHandle(hJob);

return -1;

}

std::set<unsigned long> processHandles;

DWORD dwBytesReturned = 0;

JOBOBJECT_BASIC_PROCESS_ID_LIST pidList;

PJOBOBJECT_BASIC_PROCESS_ID_LIST ppTmp = NULL;

do {

if (QueryInformationJobObject(hJob, JobObjectBasicProcessIdList, &pidList, sizeof(pidList), &dwBytesReturned)) {

break;

}

if (GetLastError() == ERROR_MORE_DATA) {

DWORD dwSize = sizeof(JOBOBJECT_BASIC_PROCESS_ID_LIST) + sizeof(DWORD_PTR) * (pidList.NumberOfAssignedProcesses - 1);

auto pPidList = (PJOBOBJECT_BASIC_PROCESS_ID_LIST)malloc(dwSize);

if (pPidList && QueryInformationJobObject(hJob, JobObjectBasicProcessIdList, pPidList, dwSize, &dwBytesReturned)) {

ppTmp = pPidList;

break;

}

} else {

CloseHandle(pi.hThread);

CloseHandle(pi.hProcess);

CloseHandle(hJob);

return -1;

}

} while (false);

if (ppTmp) {

for (DWORD i = 0; i < ppTmp->NumberOfProcessIdsInList; ++i) {

processHandles.insert(ppTmp->ProcessIdList[i]);

}

free(ppTmp);

} else {

for (DWORD i = 0; i < pidList.NumberOfProcessIdsInList; ++i) {

processHandles.insert(pidList.ProcessIdList[i]);

}

if (processHandles.empty()) {

CloseHandle(pi.hThread);

CloseHandle(pi.hProcess);

CloseHandle(hJob);

return -1;

}

DWORD dwBytes;

ULONG_PTR key;

OVERLAPPED* pOv;

int res = 0;

std::vector<int> resVec;

while (GetQueuedCompletionStatus(port.CompletionPort, &dwBytes, &key, &pOv, INFINITE)) {

if (dwBytes == JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO) {

for (auto fuck : processHandles) {

HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, fuck);

if (hProcess == NULL) {

continue;

}

DWORD exitCode;

if (GetExitCodeProcess(hProcess, &exitCode)) {

resVec.push_back(exitCode);

}

break;

}

for (auto itm : resVec) {

if (itm != 0) {

res = 1;

}

CloseHandle(pi.hThread);

CloseHandle(pi.hProcess);

CloseHandle(hd);

return res;

}

Windows用户权限
标准用户
管理员用户
LocalSystem
问题
实例
简述
管理员权限
普通权限
helper.exe

本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！

Bingliaolong 关注：0 粉丝：0 最后编辑于：2023-11-12

Everything will be better.

Windows用户权限

标准用户

管理员用户

LocalSystem

问题

实例

简述

管理员权限

普通权限

helper.exe

你可能也喜欢

热评文章

发表评论

标签云集

2025年 4月
一	二	三	四	五	六	日
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31