.cpp

#include "Memory.h"

DWORD Memory::hPID = 0;
BOOL Memory::bPOn = false, Memory::bIOn = false, Memory::bProt = false;
HANDLE Memory::hProc = NULL;

bool Memory::DataCompare(const BYTE* pData, const BYTE* pMask, const char* pszMask) {
    for (; *pszMask; ++pszMask, ++pData, ++pMask) {
        if (*pszMask == 'x' && *pData != *pMask) {
            return false;
        }
    }
    return (*pszMask == NULL);
}

DWORD Memory::FindPattern(DWORD start, DWORD size, const char* sig, const char* mask) {
    BYTE* data = new BYTE[size];

    unsigned long bytesRead;
    if (!ReadProcessMemory(hProc, (LPVOID)start, data, size, &bytesRead)) {
        return NULL;
    }

    for (DWORD i = 0; i < size; i++) {
        if (DataCompare((const BYTE*)(data + i), (const BYTE*)sig, mask)) {
            return start + i;
        }
    }
    return NULL;
}

DWORD Memory::FindPatternArr(DWORD start, DWORD size, const char* mask, int count, ...) {
    char* sig = new char[count + 1];
    va_list ap;
    va_start(ap, count);
    for (int i = 0; i < count; i++) {
        char read = va_arg(ap, char);
        sig[i] = read;
    }
    va_end(ap);
    sig[count] = '\0';
    return FindPattern(start, size, sig, mask);
}


bool Memory::Process(char * ProcessName) {
    HANDLE hhPID = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
    PROCESSENTRY32 ProcEntry;
    ProcEntry.dwSize = sizeof(ProcEntry);


    do
        if (!strcmp(ProcEntry.szExeFile, ProcessName))
        {


            Memory::hPID = ProcEntry.th32ProcessID;
            CloseHandle(hhPID);


            Memory::hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, Memory::hPID);
            return true;
        }
    while (Process32Next(hhPID, &ProcEntry));
    return false;
}

DWORD Memory::Module(LPSTR ModuleName, DWORD& modSizeTo) {
    HANDLE hModule = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, Memory::hPID);
    MODULEENTRY32 mEntry;
    mEntry.dwSize = sizeof(mEntry);


    do
        if (!strcmp(mEntry.szModule, ModuleName))
        {
            CloseHandle(hModule);
            modSizeTo = mEntry.modBaseSize;
            return (DWORD)mEntry.modBaseAddr;
        }
    while (Module32Next(hModule, &mEntry));
    return 0;
}