#include <windows.h>
#include <tlhelp32.h>
#include <iostream>
#include <vector>
#include <string>
#include <cstdlib>
using
namespace
std;
DWORD
GetModuleBase(
DWORD
pid,
const
char
* moduleName) {
HANDLE
hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);
if
(hSnapshot == INVALID_HANDLE_VALUE) {
cerr <<
"CreateToolhelp32Snapshot failed: "
<< GetLastError() << endl;
return
0;
}
MODULEENTRY32 me;
me.dwSize =
sizeof
(MODULEENTRY32);
if
(!Module32First(hSnapshot, &me)) {
cerr <<
"Module32First failed: "
<< GetLastError() << endl;
CloseHandle(hSnapshot);
return
0;
}
do
{
if
(_stricmp(me.szModule, moduleName) == 0) {
CloseHandle(hSnapshot);
return
(
DWORD
)me.modBaseAddr;
}
}
while
(Module32Next(hSnapshot, &me));
CloseHandle(hSnapshot);
return
0;
}
struct
MemoryPattern {
BYTE
byte;
bool
wildcard;
};
vector<MemoryPattern> HexToPattern(
const
string& hex) {
vector<MemoryPattern> pattern;
string buffer;
for
(
size_t
i = 0; i < hex.size(); ++i) {
char
c = hex[i];
if
(c ==
' '
) {
if
(!buffer.empty()) {
if
(buffer ==
"??"
) {
MemoryPattern mp = {0,
true
};
pattern.push_back(mp);
}
else
{
MemoryPattern mp = {
static_cast
<
BYTE
>(
strtol
(buffer.c_str(), NULL, 16)),
false
};
pattern.push_back(mp);
}
buffer.clear();
}
}
else
{
buffer += c;
}
}
if
(!buffer.empty()) {
if
(buffer ==
"??"
) {
MemoryPattern mp = {0,
true
};
pattern.push_back(mp);
}
else
{
MemoryPattern mp = {
static_cast
<
BYTE
>(
strtol
(buffer.c_str(), NULL, 16)),
false
};
pattern.push_back(mp);
}
}
return
pattern;
}
DWORD
FindPattern(
HANDLE
hProcess,
DWORD
baseAddr,
DWORD
size,
const
vector<MemoryPattern>& pattern) {
BYTE
* buffer =
new
BYTE
[size];
SIZE_T
bytesRead;
if
(!ReadProcessMemory(hProcess, (
LPCVOID
)baseAddr, buffer, size, &bytesRead)) {
delete
[] buffer;
return
0;
}
for
(
DWORD
i = 0; i < bytesRead - pattern.size(); ++i) {
bool
match =
true
;
for
(
size_t
j = 0; j < pattern.size(); ++j) {
if
(!pattern[j].wildcard && buffer[i + j] != pattern[j].byte) {
match =
false
;
break
;
}
}
if
(match) {
DWORD
result = baseAddr + i;
delete
[] buffer;
return
result;
}
}
delete
[] buffer;
return
0;
}
bool
WriteToMemory(
HANDLE
hProcess,
DWORD
address,
const
vector<
BYTE
>& data) {
DWORD
oldProtect;
if
(!VirtualProtectEx(hProcess, (
LPVOID
)address, data.size(), PAGE_EXECUTE_READWRITE, &oldProtect)) {
cerr <<
"VirtualProtectEx failed: "
<< GetLastError() << endl;
return
false
;
}
SIZE_T
written;
if
(!WriteProcessMemory(hProcess, (
LPVOID
)address, &data[0], data.size(), &written)) {
cerr <<
"WriteProcessMemory failed: "
<< GetLastError() << endl;
return
false
;
}
VirtualProtectEx(hProcess, (
LPVOID
)address, data.size(), oldProtect, &oldProtect);
return
written == data.size();
}
int
main() {
STARTUPINFO si = {
sizeof
(si) };
PROCESS_INFORMATION pi;
char
exePath[] =
"D:\\target32.exe"
;
if
(!CreateProcess(NULL, exePath, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
cerr <<
"CreateProcess failed: "
<< GetLastError() << endl;
return
1;
}
WaitForInputIdle(pi.hProcess, 3000);
DWORD
baseAddr = GetModuleBase(pi.dwProcessId,
"target32.exe"
);
if
(baseAddr == 0) {
cerr <<
"Failed to get base address"
<< endl;
return
1;
}
cout <<
"Base address: 0x"
<< hex << baseAddr << endl;
HANDLE
hProcess = OpenProcess(PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION,
FALSE, pi.dwProcessId);
if
(!hProcess) {
cerr <<
"OpenProcess failed: "
<< GetLastError() << endl;
return
1;
}
string pattern =
"55 8B EC 83 EC 20 53 56 57"
;
string replacement =
"90 90 90 90 90 90 90 90 90"
;
vector<MemoryPattern> searchPattern = HexToPattern(pattern);
vector<
BYTE
> replaceData = HexToPattern(replacement);
MODULEINFO modInfo;
if
(!GetModuleInformation(hProcess, (
HMODULE
)baseAddr, &modInfo,
sizeof
(modInfo))) {
cerr <<
"GetModuleInformation failed: "
<< GetLastError() << endl;
return
1;
}
DWORD
foundAddr = FindPattern(hProcess, baseAddr, modInfo.SizeOfImage, searchPattern);
if
(foundAddr == 0) {
cerr <<
"Pattern not found"
<< endl;
return
1;
}
cout <<
"Found pattern at: 0x"
<< hex << foundAddr << endl;
if
(WriteToMemory(hProcess, foundAddr, replaceData)) {
cout <<
"Memory modified successfully!"
<< endl;
}
else
{
cerr <<
"Memory modification failed"
<< endl;
}
CloseHandle(hProcess);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
return
0;
}