c++ readIntger writeIntger

类似CE的read/writeIntger函数(外部)

#include <iostream>
#include <Windows.h>
#include <TlHelp32.h>
#include <vector>
#include <regex>
#include <sstream>
#include <string>

// global
DWORD pid = 0;
HANDLE hProcess = 0;

// 获取进程名的pid
DWORD getPID(const wchar_t* name)
{
	DWORD pid = 0;
	HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	if (hSnap != INVALID_HANDLE_VALUE)
	{
		PROCESSENTRY32 pe;
		pe.dwSize = sizeof(pe);
		if (Process32First(hSnap, &pe))
		{
			do {
				if (!_wcsicmp(pe.szExeFile, name)) {
					pid = pe.th32ProcessID;
					break;
				}
			} while (Process32Next(hSnap, &pe));
		}
	}
	CloseHandle(hSnap);
	return pid;
}

// 获取模块基址
uintptr_t getModuleBaseAddress(DWORD pid, const wchar_t* modName)
{
	uintptr_t modBaseAddr = 0;
	HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, pid);

	if (hSnap != INVALID_HANDLE_VALUE)
	{
		MODULEENTRY32 me;
		me.dwSize = sizeof(me);
		if (Module32First(hSnap, &me))
		{
			do {
				if (!_wcsicmp(me.szModule, modName)) {
					modBaseAddr = (uintptr_t)me.modBaseAddr;
					break;
				}
			} while (Module32Next(hSnap, &me));
		}
	}
	CloseHandle(hSnap);
	return modBaseAddr;
}

std::string replaceString(std::string origenString, std::string replaceString, std::string newValue)
{
	int startIndex = origenString.find(replaceString);
	int endIndex = replaceString.size();
	return origenString.replace(startIndex - 1, endIndex + 2, newValue);
}

uintptr_t hexStr2Hex(std::string hexStr)
{
	uintptr_t r;
	std::stringstream(hexStr) >> std::hex >> r;
	return r;
}

struct SplitListItem
{
	std::string key;
	std::string value;
};

std::vector<SplitListItem> splitString(std::string origenString, std::regex pattern)
{
	std::smatch result;
	std::string::const_iterator iterStart = origenString.begin();
	std::string::const_iterator iterEnd = origenString.end();

	std::vector<std::string> splitList = {};
	std::vector<std::string> splitKeys = {};
	std::vector<SplitListItem> resultSplitList = {};

	while (regex_search(iterStart, iterEnd, result, pattern))
	{
		splitList.emplace_back(iterStart, result[0].first);
		splitKeys.push_back(result[0].str());
		iterStart = result[0].second;
	}
	splitList.emplace_back(iterStart, iterEnd);

	for (size_t i = 0; i < splitList.size(); i++)
	{
		resultSplitList.push_back(SplitListItem{ i > 0 ? splitKeys[i - 1] : "",  splitList[i] });
	}
	return resultSplitList;
}

uintptr_t getOffsetsAddress(std::string address, uintptr_t nextValue = 0)
{

	std::string str = std::regex_replace(address, (std::regex)"\\s", "") ;
	std::smatch result;
	std::regex pattern(".*\\[([^\\[\\]]+)\\].*");
	std::regex_match(str, result, pattern);
	if (result.size() == 0)
	{
		if (str.size() == 0) {
			return nextValue;
		}

		std::vector<SplitListItem>  r = splitString(str, (std::regex)"[+-]");

		uintptr_t a = hexStr2Hex(r[0].value);
		if (a == 0 && r[0].value != "0")
		{
			// 符号
			a = getModuleBaseAddress(
				pid,
				std::wstring(r[0].value.begin(), r[0].value.end()).c_str()
			);
		}
		uintptr_t b = hexStr2Hex(r[1].value);

		if (r[1].key == "+") a += b;
		if (r[1].key == "-") a -= b;
		return a;
	}

	std::vector<SplitListItem>  r = splitString(result[1], (std::regex)"[+-]");
	uintptr_t data = 0;
	for (size_t i = 0; i < r.size(); i++)
	{

		uintptr_t v = hexStr2Hex(r[i].value);

		if (v == 0 && r[i].value != "0")
		{
			// 符号
			data += getModuleBaseAddress(
				pid,
				std::wstring(r[i].value.begin(), r[i].value.end()).c_str()
			);
		}
		else
		{
			if (r[i].key == "+") data += v;
			if (r[i].key == "-") data -= v;
			ReadProcessMemory(hProcess, (LPCVOID)data, &data, 4, 0);
		}
	}

	std::stringstream hexData;
	hexData << std::hex << data;
	std::string newOrigenString = replaceString(str, result[1], hexData.str());
	return getOffsetsAddress(newOrigenString, data);
}

uintptr_t readIntger(std::string address)
{
	uintptr_t r = getOffsetsAddress(address);
	if (r == 0) return 0;
	ReadProcessMemory(hProcess, (LPCVOID)r, &r, 4, 0);
	return r;
}

uintptr_t writeIntger(std::string address, uintptr_t newInt)
{
	uintptr_t r = getOffsetsAddress(address);
	if (r == 0) return 0;
	WriteProcessMemory(hProcess, (LPVOID)r, (LPCVOID)&newInt, 4, 0);
	return r;
}

int main()
{

	// 地址: [game.exe+009E820C]+338

	std::string mainname = "game.exe";

	pid = getPID(std::wstring(mainname.begin(), mainname.end()).c_str());

	hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
	if (hProcess == NULL) return 0;

	std::cout << readIntger("game.exe+009E820C") << std::endl;
	std::cout << readIntger("[game.exe + 009E820C] + 338") << std::endl;

	writeIntger("[game.exe+ 009E820C] + 338", 20);

	CloseHandle(hProcess);
	return 0;
}