This repository has been archived on 2026-11-07. You can view files and clone it. You cannot open issues or pull requests or push a commit.
Files
my-first-apex-internal/hook.cpp
T
2026-11-05 02:19:09 +01:00

196 lines
5.6 KiB
C++

#include <include.h>
using namespace hook;
namespace u
{
bool patch_stealth(uint32_t pid, void* target, uint8_t* bytes, size_t length)
{
if (target == nullptr || bytes == nullptr || pid == 0 || length <= 0)
return false;
if (!hvi::write_virt_memory(pid, mem::addr(target).Base(), bytes, length, true))
return false;
return true;
}
bool patch(void* target, void* bytes, size_t length, bool cow_page)
{
auto process = win_api::get_current_process_id();
auto prot = ulong{};
auto backup = uint8_t{};
if (cow_page)
{
if (!hvi::protect_virt_memory(
process, (uintptr_t)target,
page_size, PAGE_EXECUTE_READWRITE, &prot
))
return false;
*(uint8_t*)((uintptr_t)target + 0x8) = 0x1;
win_api::rebuilt::sleep(1000);
*(uint8_t*)((uintptr_t)target + 0x8) = 0x0;
}
if (!patch_stealth(
process, target,
(uint8_t*)bytes, length
))
return false;
return true;
}
}
bool detour::protect_virtual_memory(void* pAddress, size_t uLength, ulong uProt, ulong* uOldProt)
{
ulong uDummy{};
ulong* puProt = (uOldProt != nullptr) ? uOldProt : &uDummy;
return hvi::protect_virt_memory(
win_api::get_current_process_id(), (uintptr_t)pAddress,
uLength, uProt, puProt
);
}
bool detour::copy_virtual_memory(void* pDst, void* pSrc, size_t uLength, bool bStealth)
{
return u::patch(pDst, (uint8_t*)pSrc, uLength, true);
}
bool detour::place(void* pTarget, void* pHandler,
void** pOriginal, size_t* uBackupLength,
void* pRealTarget,
u32* pdwErrorCode,
bool bUseSafeRegister,
bool bSmallFunction
)
{
const bool is_hooking_shadow_page = !(pRealTarget == nullptr);
const auto handler = reinterpret_cast<DWORD_PTR>(pHandler);
auto redirect_shell = instr::jump_t(handler);
auto backup_length = size_t{};
// determine if the target is eligible for hooking with this particular method and
// also how many bytes we are required to back-up in order to allow smooth transition.
constexpr size_t snippet_length = 128;
auto* const snippet_buffer = stl::mem_alloc<uint8_t*>(snippet_length);
if (snippet_buffer == nullptr)
{
if (pdwErrorCode)
*pdwErrorCode = 0xE01;
return false;
}
RtlSecureZeroMemory(snippet_buffer, snippet_length);
// copy a "snippet/piece" of the target function inside a local buffer and start processing it.
// usually, we'll come to our required instruction size by the first 128 bytes, if not, then
// we'll refuse to work. TODO: maybe change this logic to allow reading for more?
if (!copy_virtual_memory(snippet_buffer, pTarget, snippet_length))
{
if (pdwErrorCode)
*pdwErrorCode = 0xE02;
return false;
}
uint32_t disasm_sc = 0;
if (!hde::is_function_hookable(snippet_buffer, snippet_length,
&backup_length, sizeof(redirect_shell), disasm_sc))
{
if (pdwErrorCode)
*pdwErrorCode = 0xE03;
return false;
}
if (uBackupLength)
*uBackupLength = backup_length;
// that is only required for determining if it's hookable and some other things.
// but after the function has returned, we generally don't need it anymore.
stl::mem_free(snippet_buffer);
{
const size_t original_length = ((sizeof(redirect_shell) * 2) + (2 * sizeof(void*)));
auto* const original_ptr =
stl::mem_alloc<void*>(original_length);
if (original_ptr == nullptr)
{
if (pdwErrorCode)
*pdwErrorCode = 0xE04;
return false;
}
if (!protect_virtual_memory(original_ptr,
original_length, PAGE_EXECUTE_READWRITE))
return false;
void* trampoline_escape_target = (is_hooking_shadow_page ? pRealTarget : pTarget);
const auto trampoline_escape_dst =
(reinterpret_cast<uintptr_t>(trampoline_escape_target) + backup_length);
auto trampoline_shell = instr::jump_safe_t(trampoline_escape_dst);
// zero the original buffer.
RtlZeroMemory(original_ptr, original_length);
if (!bSmallFunction)
{
UINT8 backup_data[256] = { 0 };
RtlCopyMemory(&backup_data[0], pTarget, backup_length);
// copy backup bytes into the original buffer.
RtlCopyMemory(original_ptr, backup_data, backup_length);
}
// append the jump away from our trampoline at the end of here.
auto* const trampoline_dst_ptr =
reinterpret_cast<void*>(
reinterpret_cast<uintptr_t>(original_ptr)
+ backup_length);
RtlCopyMemory(trampoline_dst_ptr, &trampoline_shell,
sizeof(trampoline_shell));
// pass the original to the output parameter.
// NOTE: make sure to free this memory this when un-hooking.
if (pOriginal && !(*pOriginal))
*pOriginal = original_ptr;
}
if (!copy_virtual_memory(pTarget, &redirect_shell, sizeof(redirect_shell), true))
{
if (pdwErrorCode)
*pdwErrorCode = 0xE05;
return false;
}
return true;
}
bool detour::restore(void* pTarget, void* pOriginal, size_t uBackupLength)
{
const auto uOriginalLength = uBackupLength;
if (!copy_virtual_memory(pTarget, pOriginal, static_cast<ulong>(uOriginalLength)))
return false;
stl::mem_free(pOriginal);
return true;
}