MinHook memcpy

[Exfazo]

Попробуй, но технически ничего не мешает "модулю защиты" периодически проверять и восстанавливать свои хуки. Ну либо валить процесс, если его хук куда-то пропал.

ДА не я же потоки останавливаю, ничего он не сделает

 

[Apocalypse]

А как ты адрес memcpy определяешь? Нужно GetModuleHandle -> GetProcAddress

 

[varwar]

Не спец по хукам, но сваял на коленке по документации MinHook'а пример с memcpy, использующий подмену входящего буфера. Кстати в таблице экспорта vcruntime140.dll и ntdll.dll memcpy указывает на реализацию memmove. Самой реализации memcpy там нет. Может быть имеет смысл хукать memmove сразу. Код memcpy, как было сказано выше, инлайнится при использовании О2 оптимизации (в релизной версии Visual Studio устанавливается по дефолту).

#include <Windows.h>
#include <stdio.h>
#include "./include/MinHook.h"

#if defined _M_X64
#pragma comment(lib, "libMinHook.x64.lib")
#elif defined _M_IX86
#pragma comment(lib, "libMinHook.x86.lib")
#endif

#pragma warning(disable:26812)

// Prototypes
void HexDump(const void* data, size_t size);

// Type def's
typedef void (WINAPIV *MEMCPY)(void* dest, const void* src, size_t count);

// Pointer for calling original memmove.
MEMCPY fpmemcpy = NULL;
// Detour function which overrides memmove.
void WINAPIV DetourMemcpy(void* dest, const void* src, size_t count)
{
    const char hooked_buf[] = "Hooked buffer!...";
    return fpmemcpy(dest, hooked_buf, 0x20); // fake buffer
}

int main()
{
    // Initialize MinHook.
    if (MH_Initialize() != MH_OK)
    {
        printf("Cant' initialize minhook\n");
        return 1;
    }

     //Create a hook for memmove, in disabled state.
    if (MH_CreateHook(&memcpy, &DetourMemcpy,
        reinterpret_cast<LPVOID*>(&fpmemcpy)) != MH_OK)
    {
        return 1;
    }

    // Enable the hook for memmove.
    if (MH_EnableHook(&memcpy) != MH_OK)
    {
        printf("Can't enable hook\n");
        return 1;
    }

    // Expected to write buffer with "Hooked buffer!".
    char* dest = (char*)malloc(0x100);
    const char src[] = "Not hooked buffer";
    memcpy(dest, src, 0x20);
    // print hooked buffer
    printf("Buf addr: %p\n", &dest);
    HexDump(dest, 0x20);
    printf("\n");

    // Disable the hook for memmove.
    if (MH_DisableHook(&memcpy) != MH_OK)
    {
        return 1;
    }

    // Expected to dump "Not hooked buffer"
    memcpy(dest, src, 0x20);
    printf("Buf addr: %p\n", &dest);
    HexDump(dest, 0x20);

    // Uninitialize MinHook.
    if (MH_Uninitialize() != MH_OK)
    {
        return 1;
    }
    free(dest);
    return 0;
}

void HexDump(const void* data, size_t size) {
    char ascii[17];
    size_t i, j;
    ascii[16] = '\0';
    for (i = 0; i < size; ++i) {
        printf("%02X ", ((unsigned char*)data)[i]);
        if (((unsigned char*)data)[i] >= ' ' && ((unsigned char*)data)[i] <= '~') {
            ascii[i % 16] = ((unsigned char*)data)[i];
        }
        else {
            ascii[i % 16] = '.';
        }
        if ((i + 1) % 8 == 0 || i + 1 == size) {
            printf(" ");
            if ((i + 1) % 16 == 0) {
                printf("|  %s \n", ascii);
            }
            else if (i + 1 == size) {
                ascii[(i + 1) % 16] = '\0';
                if ((i + 1) % 16 <= 8) {
                    printf(" ");
                }
                for (j = (i + 1) % 16; j < 16; ++j) {
                    printf("   ");
                }
                printf("|  %s \n", ascii);
            }
        }
    }
}