修改windows注册表

DWORD get_user_process_id()
{
PROCESSENTRY32 proc_entry;
DWORD explorer_pid = 0;
DWORD agent_session_id;

if (!ProcessIdToSessionId(GetCurrentProcessId(), &agent_session_id)) {
printf("ProcessIdToSessionId for current process failed %lu", GetLastError());
return 0;
}

HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (snap == INVALID_HANDLE_VALUE) {
printf("CreateToolhelp32Snapshot() failed %lu", GetLastError());
return 0;
}
ZeroMemory(&proc_entry, sizeof(proc_entry));
proc_entry.dwSize = sizeof(PROCESSENTRY32);
if (!Process32First(snap, &proc_entry)) {
printf("Process32First() failed %lu", GetLastError());
CloseHandle(snap);
return 0;
}
do {
if (_tcsicmp(proc_entry.szExeFile, TEXT("explorer.exe")) == 0) {
DWORD explorer_session_id;
if (!ProcessIdToSessionId(proc_entry.th32ProcessID, &explorer_session_id)) {
printf("ProcessIdToSessionId for explorer failed %lu", GetLastError());
break;
}

if (explorer_session_id == agent_session_id) {
explorer_pid = proc_entry.th32ProcessID;
break;
}
}
} while (Process32Next(snap, &proc_entry));

CloseHandle(snap);
if (explorer_pid == 0) {
printf("explorer.exe not found");
return 0;
}
return explorer_pid;
}
//
//获取用户sid
//
bool GetAccountSid(LPSTR AccountName, PSID *Sid)
{
PSID pSID = NULL;
DWORD cbSid = 0;
LPSTR DomainName = NULL;
DWORD cbDomainName = 0;
SID_NAME_USE SIDNameUse;
BOOL  bDone = FALSE;

try
{
if(!LookupAccountNameA(NULL,
AccountName,
pSID,
&cbSid,
DomainName,
&cbDomainName,
&SIDNameUse))
{
pSID = (PSID)malloc(cbSid);
DomainName = (LPSTR)malloc(cbDomainName * sizeof(TCHAR));
if(!pSID || !DomainName)
{
throw;
}
if(!LookupAccountNameA(NULL,
AccountName,
pSID,
&cbSid,
DomainName,
&cbDomainName,
&SIDNameUse))
{
throw;
}
bDone = TRUE;
}
}
catch(...)
{
//nothing
}

if(DomainName)
{
free(DomainName);
}

if(!bDone && pSID)
{
free(pSID);
}
if(bDone)
{
*Sid = pSID;
}

return bDone;
}
bool Set_HKCU_Value(string RegKeyPath,char* RegKeyName,DWORD dwType, void* KeyValue,DWORD KeyValueLen)
{
DWORD user_pid; 
<span style="white-space:pre">	</span>HKEY hkey_cur_user = NULL;
<span style="white-space:pre">	</span>LONG status;   
<span style="white-space:pre">	</span>user_pid = get_user_process_id();
<span style="white-space:pre">	</span>if (!user_pid) 
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>log_error("get_user_process_id failed = %d",GetLastError());
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	HANDLE</span> m_hprocess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, user_pid);
<span style="white-space:pre">	</span>if (NULL == m_hprocess)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>log_error("OpenProcess failed = %d",GetLastError());
<span style="white-space:pre">	</span>}

<span style="white-space:pre">	</span>bool ret = TRUE;
HKEY hKey;
HANDLE  htoken;
if (!OpenProcessToken(m_hprocess, TOKEN_ALL_ACCESS, &htoken))
{
::CloseHandle(htoken);
log_error("OpenProcessToken failed = %d",GetLastError());
ret = false;
}
else
{
ImpersonateLoggedOnUser(htoken);

char szBuf[MAX_PATH] = "";
DWORD dwRet = MAX_PATH;
GetUserNameA(szBuf, &dwRet);
PSID pSid = NULL;
LPSTR sid;

GetAccountSid(szBuf, &pSid);
ConvertSidToStringSidA(pSid, &sid);
string reginfo;
reginfo = sid;
reginfo += RegKeyPath;
long size;
char buf[128];
if (0 == RegQueryValueA(HKEY_USERS, reginfo.c_str(), buf, &size))
{
int returnvalue = RegOpenKeyExA(HKEY_USERS,
reginfo.c_str(),
0,
KEY_ALL_ACCESS,
&hKey);
if(returnvalue == ERROR_SUCCESS)
{
returnvalue= RegSetValueExA(
hKey,
RegKeyName,
NULL,
dwType,
(LPBYTE)KeyValue,
KeyValueLen);
if( ERROR_SUCCESS != returnvalue)
{
log_error("RegSetValueEx %s failed = %d",RegKeyName,returnvalue);
ret = FALSE;
}
else
{
log_printf("RegSetValueEx %s Success",RegKeyName);
}
}
else
{
log_error("RegOpenKeyExA %s failed = %d",RegKeyName,returnvalue);
ret = FALSE;
}
}
else
{
int returnvalue =RegCreateKeyA(HKEY_USERS, reginfo.c_str(), &hKey);
if(ERROR_SUCCESS == returnvalue)
{
returnvalue= RegSetValueExA(
hKey,
RegKeyName,
NULL,
dwType,
(LPBYTE)KeyValue,
KeyValueLen);
if( ERROR_SUCCESS != returnvalue)
{
log_error("RegSetValueEx %s failed = %d",RegKeyName,returnvalue);
ret = FALSE;
}
else
{
log_printf("RegSetValueEx %s Success",RegKeyName);
}
}
else
{
log_error("RegCreateKeyA %s\\%s failed = %d",reginfo.c_str(),RegKeyName,returnvalue);
}
}
}

::CloseHandle(htoken);
RegCloseKey(hKey);
return ret;
}
bool Set_HKLM_Value(std::string RegKeyPath, char* RegKeyName, DWORD dwType, void* KeyValue ,DWORD KeyValueLen)
{
bool ret = TRUE;
HKEY hKey;
long size;
char buf[128];
if (0 == RegQueryValueA(HKEY_LOCAL_MACHINE, RegKeyPath.c_str(), buf, &size))
{
int returnvalue = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
RegKeyPath.c_str(),
0,
KEY_ALL_ACCESS,
&hKey);
if(returnvalue == ERROR_SUCCESS)
{
returnvalue= RegSetValueExA(
hKey,
RegKeyName,
NULL,
dwType,
(LPBYTE)KeyValue,
KeyValueLen);
if( ERROR_SUCCESS != returnvalue)
{
log_error("RegSetValueEx %s failed = %d",RegKeyName,returnvalue);
ret = FALSE;
}
else
{
log_printf("RegSetValueEx %s Success",RegKeyName);
}
}
else
{
log_error("RegOpenKeyExA %s failed = %d",RegKeyName,returnvalue);
ret = FALSE;
}
}
else
{
int returnvalue =RegCreateKeyA(HKEY_LOCAL_MACHINE, RegKeyPath.c_str(), &hKey);
if(ERROR_SUCCESS == returnvalue)
{
const DWORD FileName = 0;
returnvalue= RegSetValueExA(
hKey,
RegKeyName,
NULL,
dwType,
(LPBYTE)KeyValue,
KeyValueLen);
if( ERROR_SUCCESS != returnvalue)
{
log_error("RegSetValueEx %s failed = %d",RegKeyName,returnvalue);
ret = FALSE;
}
else
{
log_printf("RegSetValueEx %s Success",RegKeyName);
}
}
else
{
log_error("RegCreateKeyA %s\\%s failed = %d",RegKeyPath.c_str(),RegKeyName,returnvalue);
}
}
RegCloseKey(hKey);
return ret;
}