aboutsummaryrefslogtreecommitdiff
path: root/primedev/core/memory.cpp
diff options
context:
space:
mode:
authorJack <66967891+ASpoonPlaysGames@users.noreply.github.com>2023-12-27 00:32:01 +0000
committerGitHub <noreply@github.com>2023-12-27 01:32:01 +0100
commitf5ab6fb5e8be7b73e6003d4145081d5e0c0ce287 (patch)
tree90f2c6a4885dbd181799e2325cf33588697674e1 /primedev/core/memory.cpp
parentbb8ed59f6891b1196c5f5bbe7346cd171c8215fa (diff)
downloadNorthstarLauncher-f5ab6fb5e8be7b73e6003d4145081d5e0c0ce287.tar.gz
NorthstarLauncher-f5ab6fb5e8be7b73e6003d4145081d5e0c0ce287.zip
Folder restructuring from primedev (#624)v1.21.2-rc3v1.21.2
Copies of over the primedev folder structure for easier cherry-picking of further changes Co-authored-by: F1F7Y <filip.bartos07@proton.me>
Diffstat (limited to 'primedev/core/memory.cpp')
-rw-r--r--primedev/core/memory.cpp347
1 files changed, 347 insertions, 0 deletions
diff --git a/primedev/core/memory.cpp b/primedev/core/memory.cpp
new file mode 100644
index 00000000..3770586f
--- /dev/null
+++ b/primedev/core/memory.cpp
@@ -0,0 +1,347 @@
+#include "memory.h"
+
+CMemoryAddress::CMemoryAddress() : m_nAddress(0) {}
+CMemoryAddress::CMemoryAddress(const uintptr_t nAddress) : m_nAddress(nAddress) {}
+CMemoryAddress::CMemoryAddress(const void* pAddress) : m_nAddress(reinterpret_cast<uintptr_t>(pAddress)) {}
+
+// operators
+CMemoryAddress::operator uintptr_t() const
+{
+ return m_nAddress;
+}
+
+CMemoryAddress::operator void*() const
+{
+ return reinterpret_cast<void*>(m_nAddress);
+}
+
+CMemoryAddress::operator bool() const
+{
+ return m_nAddress != 0;
+}
+
+bool CMemoryAddress::operator==(const CMemoryAddress& other) const
+{
+ return m_nAddress == other.m_nAddress;
+}
+
+bool CMemoryAddress::operator!=(const CMemoryAddress& other) const
+{
+ return m_nAddress != other.m_nAddress;
+}
+
+bool CMemoryAddress::operator==(const uintptr_t& addr) const
+{
+ return m_nAddress == addr;
+}
+
+bool CMemoryAddress::operator!=(const uintptr_t& addr) const
+{
+ return m_nAddress != addr;
+}
+
+CMemoryAddress CMemoryAddress::operator+(const CMemoryAddress& other) const
+{
+ return Offset(other.m_nAddress);
+}
+
+CMemoryAddress CMemoryAddress::operator-(const CMemoryAddress& other) const
+{
+ return CMemoryAddress(m_nAddress - other.m_nAddress);
+}
+
+CMemoryAddress CMemoryAddress::operator+(const uintptr_t& addr) const
+{
+ return Offset(addr);
+}
+
+CMemoryAddress CMemoryAddress::operator-(const uintptr_t& addr) const
+{
+ return CMemoryAddress(m_nAddress - addr);
+}
+
+CMemoryAddress CMemoryAddress::operator*() const
+{
+ return Deref();
+}
+
+// traversal
+CMemoryAddress CMemoryAddress::Offset(const uintptr_t nOffset) const
+{
+ return CMemoryAddress(m_nAddress + nOffset);
+}
+
+CMemoryAddress CMemoryAddress::Deref(const int nNumDerefs) const
+{
+ uintptr_t ret = m_nAddress;
+ for (int i = 0; i < nNumDerefs; i++)
+ ret = *reinterpret_cast<uintptr_t*>(ret);
+
+ return CMemoryAddress(ret);
+}
+
+// patching
+void CMemoryAddress::Patch(const uint8_t* pBytes, const size_t nSize)
+{
+ if (nSize)
+ WriteProcessMemory(GetCurrentProcess(), reinterpret_cast<LPVOID>(m_nAddress), pBytes, nSize, NULL);
+}
+
+void CMemoryAddress::Patch(const std::initializer_list<uint8_t> bytes)
+{
+ uint8_t* pBytes = new uint8_t[bytes.size()];
+
+ int i = 0;
+ for (const uint8_t& byte : bytes)
+ pBytes[i++] = byte;
+
+ Patch(pBytes, bytes.size());
+ delete[] pBytes;
+}
+
+inline std::vector<uint8_t> HexBytesToString(const char* pHexString)
+{
+ std::vector<uint8_t> ret;
+
+ int size = strlen(pHexString);
+ for (int i = 0; i < size; i++)
+ {
+ // If this is a space character, ignore it
+ if (isspace(pHexString[i]))
+ continue;
+
+ if (i < size - 1)
+ {
+ BYTE result = 0;
+ for (int j = 0; j < 2; j++)
+ {
+ int val = 0;
+ char c = *(pHexString + i + j);
+ if (c >= 'a')
+ {
+ val = c - 'a' + 0xA;
+ }
+ else if (c >= 'A')
+ {
+ val = c - 'A' + 0xA;
+ }
+ else if (isdigit(c))
+ {
+ val = c - '0';
+ }
+ else
+ {
+ assert_msg(false, "Failed to parse invalid hex string.");
+ val = -1;
+ }
+
+ result += (j == 0) ? val * 16 : val;
+ }
+ ret.push_back(result);
+ }
+
+ i++;
+ }
+
+ return ret;
+}
+
+void CMemoryAddress::Patch(const char* pBytes)
+{
+ std::vector<uint8_t> vBytes = HexBytesToString(pBytes);
+ Patch(vBytes.data(), vBytes.size());
+}
+
+void CMemoryAddress::NOP(const size_t nSize)
+{
+ uint8_t* pBytes = new uint8_t[nSize];
+
+ memset(pBytes, 0x90, nSize);
+ Patch(pBytes, nSize);
+
+ delete[] pBytes;
+}
+
+bool CMemoryAddress::IsMemoryReadable(const size_t nSize)
+{
+ static SYSTEM_INFO sysInfo;
+ if (!sysInfo.dwPageSize)
+ GetSystemInfo(&sysInfo);
+
+ MEMORY_BASIC_INFORMATION memInfo;
+ if (!VirtualQuery(reinterpret_cast<LPCVOID>(m_nAddress), &memInfo, sizeof(memInfo)))
+ return false;
+
+ return memInfo.RegionSize >= nSize && memInfo.State & MEM_COMMIT && !(memInfo.Protect & PAGE_NOACCESS);
+}
+
+CModule::CModule(const HMODULE pModule)
+{
+ MODULEINFO mInfo {0};
+
+ if (pModule && pModule != INVALID_HANDLE_VALUE)
+ GetModuleInformation(GetCurrentProcess(), pModule, &mInfo, sizeof(MODULEINFO));
+
+ m_nModuleSize = static_cast<size_t>(mInfo.SizeOfImage);
+ m_pModuleBase = reinterpret_cast<uintptr_t>(mInfo.lpBaseOfDll);
+ m_nAddress = m_pModuleBase;
+
+ if (!m_nModuleSize || !m_pModuleBase)
+ return;
+
+ m_pDOSHeader = reinterpret_cast<IMAGE_DOS_HEADER*>(m_pModuleBase);
+ m_pNTHeaders = reinterpret_cast<IMAGE_NT_HEADERS64*>(m_pModuleBase + m_pDOSHeader->e_lfanew);
+
+ const IMAGE_SECTION_HEADER* hSection = IMAGE_FIRST_SECTION(m_pNTHeaders); // Get first image section.
+
+ for (WORD i = 0; i < m_pNTHeaders->FileHeader.NumberOfSections; i++) // Loop through the sections.
+ {
+ const IMAGE_SECTION_HEADER& hCurrentSection = hSection[i]; // Get current section.
+
+ ModuleSections_t moduleSection = ModuleSections_t(
+ std::string(reinterpret_cast<const char*>(hCurrentSection.Name)),
+ static_cast<uintptr_t>(m_pModuleBase + hCurrentSection.VirtualAddress),
+ hCurrentSection.SizeOfRawData);
+
+ if (!strcmp((const char*)hCurrentSection.Name, ".text"))
+ m_ExecutableCode = moduleSection;
+ else if (!strcmp((const char*)hCurrentSection.Name, ".pdata"))
+ m_ExceptionTable = moduleSection;
+ else if (!strcmp((const char*)hCurrentSection.Name, ".data"))
+ m_RunTimeData = moduleSection;
+ else if (!strcmp((const char*)hCurrentSection.Name, ".rdata"))
+ m_ReadOnlyData = moduleSection;
+
+ m_vModuleSections.push_back(moduleSection); // Push back a struct with the section data.
+ }
+}
+
+CModule::CModule(const char* pModuleName) : CModule(GetModuleHandleA(pModuleName)) {}
+
+CMemoryAddress CModule::GetExport(const char* pExportName)
+{
+ return CMemoryAddress(reinterpret_cast<uintptr_t>(GetProcAddress(reinterpret_cast<HMODULE>(m_nAddress), pExportName)));
+}
+
+CMemoryAddress CModule::FindPattern(const uint8_t* pPattern, const char* pMask)
+{
+ if (!m_ExecutableCode.IsSectionValid())
+ return CMemoryAddress();
+
+ uint64_t nBase = static_cast<uint64_t>(m_ExecutableCode.m_pSectionBase);
+ uint64_t nSize = static_cast<uint64_t>(m_ExecutableCode.m_nSectionSize);
+
+ const uint8_t* pData = reinterpret_cast<uint8_t*>(nBase);
+ const uint8_t* pEnd = pData + static_cast<uint32_t>(nSize) - strlen(pMask);
+
+ int nMasks[64]; // 64*16 = enough masks for 1024 bytes.
+ int iNumMasks = static_cast<int>(ceil(static_cast<float>(strlen(pMask)) / 16.f));
+
+ memset(nMasks, '\0', iNumMasks * sizeof(int));
+ for (intptr_t i = 0; i < iNumMasks; ++i)
+ {
+ for (intptr_t j = strnlen(pMask + i * 16, 16) - 1; j >= 0; --j)
+ {
+ if (pMask[i * 16 + j] == 'x')
+ {
+ _bittestandset(reinterpret_cast<LONG*>(&nMasks[i]), j);
+ }
+ }
+ }
+ __m128i xmm1 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pPattern));
+ __m128i xmm2, xmm3, msks;
+ for (; pData != pEnd; _mm_prefetch(reinterpret_cast<const char*>(++pData + 64), _MM_HINT_NTA))
+ {
+ if (pPattern[0] == pData[0])
+ {
+ xmm2 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pData));
+ msks = _mm_cmpeq_epi8(xmm1, xmm2);
+ if ((_mm_movemask_epi8(msks) & nMasks[0]) == nMasks[0])
+ {
+ for (uintptr_t i = 1; i < static_cast<uintptr_t>(iNumMasks); ++i)
+ {
+ xmm2 = _mm_loadu_si128(reinterpret_cast<const __m128i*>((pData + i * 16)));
+ xmm3 = _mm_loadu_si128(reinterpret_cast<const __m128i*>((pPattern + i * 16)));
+ msks = _mm_cmpeq_epi8(xmm2, xmm3);
+ if ((_mm_movemask_epi8(msks) & nMasks[i]) == nMasks[i])
+ {
+ if ((i + 1) == iNumMasks)
+ {
+ return CMemoryAddress(const_cast<uint8_t*>(pData));
+ }
+ }
+ else
+ goto CONTINUE;
+ }
+
+ return CMemoryAddress((&*(const_cast<uint8_t*>(pData))));
+ }
+ }
+
+ CONTINUE:;
+ }
+
+ return CMemoryAddress();
+}
+
+inline std::pair<std::vector<uint8_t>, std::string> MaskedBytesFromPattern(const char* pPatternString)
+{
+ std::vector<uint8_t> vRet;
+ std::string sMask;
+
+ int size = strlen(pPatternString);
+ for (int i = 0; i < size; i++)
+ {
+ // If this is a space character, ignore it
+ if (isspace(pPatternString[i]))
+ continue;
+
+ if (pPatternString[i] == '?')
+ {
+ // Add a wildcard
+ vRet.push_back(0);
+ sMask.append("?");
+ }
+ else if (i < size - 1)
+ {
+ BYTE result = 0;
+ for (int j = 0; j < 2; j++)
+ {
+ int val = 0;
+ char c = *(pPatternString + i + j);
+ if (c >= 'a')
+ {
+ val = c - 'a' + 0xA;
+ }
+ else if (c >= 'A')
+ {
+ val = c - 'A' + 0xA;
+ }
+ else if (isdigit(c))
+ {
+ val = c - '0';
+ }
+ else
+ {
+ assert_msg(false, "Failed to parse invalid pattern string.");
+ val = -1;
+ }
+
+ result += (j == 0) ? val * 16 : val;
+ }
+
+ vRet.push_back(result);
+ sMask.append("x");
+ }
+
+ i++;
+ }
+
+ return std::make_pair(vRet, sMask);
+}
+
+CMemoryAddress CModule::FindPattern(const char* pPattern)
+{
+ const auto pattern = MaskedBytesFromPattern(pPattern);
+ return FindPattern(pattern.first.data(), pattern.second.c_str());
+}