pmemory.cpp

// Memory Reading/Writing

#include "pmemory.h"
#include <Psapi.h>
#include <cstring>

#pragma comment(lib, "Psapi.lib")

#define MEM_WRITE (PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)
#define MEM_EXEC_WRITE (PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)

UINT_PTR GetDMA(UINT_PTR BaseAddress, UINT_PTR* Offsets, UINT PointerLevel)
{
	BaseAddress = Read<UINT_PTR>(BaseAddress);

	--PointerLevel;

	for (; PointerLevel && BaseAddress; --PointerLevel, ++Offsets)
		BaseAddress = Read<UINT_PTR>(BaseAddress + *Offsets);

	if (BaseAddress)
		return (BaseAddress + *Offsets);

	return 0;
}

UINT_PTR GetDMA_s(UINT_PTR BaseAddress, UINT_PTR* Offsets, UINT PointerLevel)
{
	BaseAddress = Read_s<UINT_PTR>(BaseAddress);

	--PointerLevel;

	for (; PointerLevel && BaseAddress; --PointerLevel, ++Offsets)
		BaseAddress = Read_s<UINT_PTR>(BaseAddress + *Offsets);

	if (BaseAddress)
		return (BaseAddress + *Offsets);

	return 0;
}

bool IsValidWritePtr(void* Ptr)
{
	if (!Ptr)
		return false;

	MEMORY_BASIC_INFORMATION MBI{ 0 };
	if (!VirtualQuery(Ptr, &MBI, sizeof(MEMORY_BASIC_INFORMATION)))
		return false;

	return (MBI.State == MEM_COMMIT && (MBI.Protect & MEM_WRITE) != 0);
}

bool IsValidReadPtr(void* Ptr)
{
	if (!Ptr)
		return false;

	MEMORY_BASIC_INFORMATION MBI{ 0 };
	if (!VirtualQuery(Ptr, &MBI, sizeof(MEMORY_BASIC_INFORMATION)))
		return false;

	if (MBI.State == MEM_COMMIT && !(MBI.Protect & PAGE_NOACCESS))
		return true;
	return false;
}

HANDLE CreateThreadAtAddress(PTHREAD_START_ROUTINE pFunc, void* pArg, BYTE* pAddress)
{
	if (!pFunc)
		return nullptr;

	bool Restore = false;
	if (pAddress)
		Restore = true;

	DWORD dwOld = 0;
	if (!pAddress)
		pAddress = reinterpret_cast<BYTE*>(VirtualAlloc(nullptr, 0x10, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE));
	else if (!VirtualProtect(pAddress, 0x10, PAGE_EXECUTE_READWRITE, &dwOld))
		return nullptr;
	if (!pAddress)
		return nullptr;

	BYTE Buffer[0x10];
	if (Restore)
		memcpy(Buffer, pAddress, 0x10);

#ifdef _WIN64

	* pAddress = 0x48;
	*(pAddress + 1) = 0xB8;
	*reinterpret_cast<PTHREAD_START_ROUTINE*>(pAddress + 2) = pFunc;
	*(pAddress + 0xA) = 0xFF;
	*(pAddress + 0xB) = 0xE0;

#else

	* pAddress = 0xE9;
	*reinterpret_cast<DWORD*>(pAddress + 1) = (BYTE*)pFunc - pAddress - 5;

#endif

	HANDLE hThread = CreateThread(nullptr, 0, (PTHREAD_START_ROUTINE)pAddress, pArg, 0, nullptr);
	if (!hThread)
		VirtualFree(pAddress, 0x10, MEM_DECOMMIT);

	Sleep(100);
	if (Restore)
	{
		memcpy(pAddress, Buffer, 0x10);
		VirtualProtect(pAddress, 0x10, dwOld, &dwOld);
	}
	else
		VirtualFree(pAddress, 0x10, MEM_DECOMMIT);

	return hThread;
}

BYTE* ReadBytes(UINT_PTR address, int size)
{
	BYTE* byteArr = new BYTE[size];
	for (auto i = 0; i < size; i++)
	{
		byteArr[i] = Read<BYTE>(address++);
	}

	return byteArr;
}

uintptr_t FindPattern(HMODULE module, const unsigned char* pattern, const char* mask)
{
	MODULEINFO info = { };
	GetModuleInformation(GetCurrentProcess(), module, &info, sizeof(MODULEINFO));

	return FindPattern(reinterpret_cast<uintptr_t>(module), info.SizeOfImage, pattern, mask);
}

uintptr_t FindPattern(uintptr_t start, size_t length, const unsigned char* pattern, const char* mask)
{
	size_t pos = 0;
	auto maskLength = std::strlen(mask) - 1;

	auto startAdress = start;
	for (auto it = startAdress; it < startAdress + length; ++it)
	{
		if (*reinterpret_cast<unsigned char*>(it) == pattern[pos] || mask[pos] == '?')
		{
			if (mask[pos + 1] == '\0')
			{
				return it - maskLength;
			}

			pos++;
		}
		else
		{
			pos = 0;
		}
	}

	return -1;
}