Code:
#ifndef __MEMORY__
class Memory
{
private:
HANDLE pHandle;
int pID;
uint64_t BaseAddress;
std::string FilePath;
uint64_t iSize;
public:
Memory(const char*, const char* = nullptr);
~Memory();
bool isHex(char c);
std::string getFilePath();
uint64_t getBaseAddress();
int getProcessId();
uint64_t getImageSize();
HANDLE getHandle();
void Memory::initVars(MODULEENTRY32);
MODULEENTRY32 getModule(const char*, PROCESSENTRY32);
PROCESSENTRY32 getProcess(const char*);
uint64_t getAddress(uint64_t, std::vector<uint64_t>);
uint64_t patternScan(char* sig, std::string, uint64_t = 0);
uint64_t patternScan(const std::string&, uint64_t = 0);
bool createPattern(const std::string&, std::string&, std::string&);
template<typename T> T read(uint64_t Address, std::vector<uint64_t> offsets = {})
{
uint64_t nAddress = getAddress(Address, offsets);
T ret;
ReadProcessMemory(pHandle, (void*)nAddress, &ret, sizeof(T), 0);
return ret;
}
template<typename T> void write(uint64_t Address, T value, std::vector<uint64_t> offsets = {})
{
uint64_t nAddress = getAddress(Address, offsets);
WriteProcessMemory(pHandle, (void*)nAddress, &value, sizeof(T), 0);
}
std::string readString(uint64_t, int, std::vector<uint64_t> = {});
void writeString(uint64_t, std::string&, std::vector<uint64_t> = {});
};
#define __MEMORY__
#endif
mem.cpp
Code:
#include "stdafx.h"
Memory::Memory(const char* processName, const char* moduleName)
{
Memory::pID = 0;
Memory::BaseAddress = 0;
Memory::iSize = 0;
Memory::initVars(Memory::getModule(moduleName == nullptr ? processName : moduleName, Memory::getProcess(processName)));
Memory::pHandle = OpenProcess(PROCESS_ALL_ACCESS, 0, pID);
}
Memory::~Memory()
{
CloseHandle(pHandle);
}
std::string Memory::getFilePath()
{
return FilePath;
}
uint64_t Memory::getBaseAddress()
{
return BaseAddress;
}
int Memory::getProcessId()
{
return pID;
}
uint64_t Memory::getImageSize()
{
return iSize;
}
HANDLE Memory::getHandle()
{
return pHandle;
}
void Memory::initVars(MODULEENTRY32 m)
{
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>, wchar_t> w2sConverter;
Memory::FilePath = w2sConverter.to_bytes(m.szExePath).c_str();
Memory::BaseAddress = (uint64_t)m.modBaseAddr;
Memory::pID = m.th32ProcessID;
Memory::iSize = m.modBaseSize;
}
PROCESSENTRY32 Memory::getProcess(const char* processName)
{
PROCESSENTRY32 pe32;
std::wstring wprocessName;
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> s2wconverter;
HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hSnap != INVALID_HANDLE_VALUE)
{
pe32.dwSize = sizeof(PROCESSENTRY32);
if (Process32First(hSnap, &pe32) == 0)
CloseHandle(hSnap);
do
{
wprocessName = s2wconverter.from_bytes(processName);
if (lstrcmp(pe32.szExeFile, wprocessName.c_str()) == 0)
{
CloseHandle(hSnap);
return pe32;
}
} while (Process32Next(hSnap, &pe32));
CloseHandle(hSnap);
}
return pe32;
}
MODULEENTRY32 Memory::getModule(const char* moduleName, PROCESSENTRY32 process)
{
MODULEENTRY32 xModule;
std::wstring wmoduleName;
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> s2wconverter;
HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, process.th32ProcessID);
if (hSnap != INVALID_HANDLE_VALUE)
{
xModule.dwSize = sizeof(MODULEENTRY32);
if (Module32First(hSnap, &xModule) == 0)
CloseHandle(hSnap);
do
{
wmoduleName = s2wconverter.from_bytes(moduleName);
if (lstrcmp(xModule.szModule, wmoduleName.c_str()) == 0)
{
return xModule;
}
} while (Module32Next(hSnap, &xModule));
CloseHandle(hSnap);
}
return xModule;
}
bool Memory::isHex(char c)
{
return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
}
bool Memory::createPattern(const std::string& pattern, std::string& pattern_result, std::string& mask_result)
{
bool result = false;
size_t l = pattern.size();
if (l-- > 0)
{
char buffer[2];
std::stringstream pattern_s;
std::stringstream mask_s;
for (size_t i = 0; i < l; i++)
{
if (!Memory::isHex(pattern[i]))
{
if (pattern[i] == '?')
{
pattern_s << "\x90";
mask_s << '?';
}
}
else
{
buffer[0] = pattern[i];
buffer[1] = (l >= i + 1 && Memory::isHex(pattern[i + 1])) ? pattern[++i] : 0;
pattern_s << (char)strtol(buffer, nullptr, 16);
mask_s << 'x';
}
}
result = true;
pattern_result = pattern_s.str();
mask_result = mask_s.str();
}
return result;
}
uint64_t Memory::patternScan(const std::string& pattern, uint64_t startAddress)
{
std::string sub_ptr;
std::string sub_mask;
Memory::createPattern(pattern, sub_ptr, sub_mask);
return Memory::patternScan(&sub_ptr[0], sub_mask, startAddress);
}
uint64_t Memory::patternScan(char* sig, std::string pattern, uint64_t startAddress)
{
if (startAddress < Memory::BaseAddress || startAddress > (Memory::BaseAddress + Memory::iSize))
startAddress = Memory::BaseAddress;
char* cBuffer = new char[Memory::iSize];
ReadProcessMemory(Memory::pHandle, (void*)startAddress, cBuffer, Memory::iSize, 0);
size_t patternLength = pattern.size() - 1;
for (size_t i = 0, j = 0, matches = 0; i != Memory::iSize; i++)
{
if (cBuffer[i] == sig[j] || pattern[j] == '?')
{
if (++matches == patternLength)
{
delete cBuffer;
return (startAddress + i - j);
}
j++;
}
else if (cBuffer[i] == sig[0] || pattern[0] == '?')
{
matches = 1;
j = 1;
}
else
{
matches = 0;
j = 0;
}
}
delete[] cBuffer;
return 0;
}
uint64_t Memory::getAddress(uint64_t Address, std::vector<uint64_t> offsets)
{
uint64_t nAddress = Address;
size_t size = offsets.size();
if (size)
{
size--;
ReadProcessMemory(Memory::pHandle, (void*)nAddress, &nAddress, sizeof(nAddress), 0);
for (size_t i = 0; i != size; i++)
ReadProcessMemory(Memory::pHandle, (void*)(nAddress + offsets[i]), &nAddress, sizeof(nAddress), 0);
nAddress = nAddress + offsets[size];
}
return nAddress;
}
std::string Memory::readString(uint64_t Address, int size, std::vector<uint64_t> offsets)
{
std::string ret;
uint64_t nAddress = Memory::getAddress(Address, offsets);
char* buffer = new char[size];
ReadProcessMemory(Memory::pHandle, (void*)nAddress, buffer, size, 0);
ret = buffer;
delete[] buffer;
return ret;
}
void Memory::writeString(uint64_t Address, std::string& str, std::vector<uint64_t> offsets)
{
uint64_t nAddress = Memory::getAddress(Address, offsets);
WriteProcessMemory(Memory::pHandle, (void*)nAddress, &str[0], str.size(), 0);
return;
}
Code:
#include "stdafx.h"
int main()
{
Memory GTA("GTA5.exe");
uint64_t world = GTA.patternScan("48 8B 05 ? ? ? ? 45 ? ? ? ? 48 8B 48 08 48 85 C9 74 07");
world = world + GTA.read<int>(world + 3) + 7;
float Health = GTA.read<float>(world, { 8, 0x280 });
printf("Health is %.2f\n", Health);
std::string name = GTA.readString(world, 12, { 8, 0x10B8, 0x7C });
printf("Playername: %s\n", &name[0]);
_gettchar();
return 0;
}
Originally Posted by MikeRohsoft
