修改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;
}