Initial commit
This commit is contained in:
@@ -0,0 +1,195 @@
|
||||
#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;
|
||||
}
|
||||
Reference in New Issue
Block a user