[Solucionado] Hook sin DLL

Finalmente lo arreglé con algo de ayuda. Cambié la forma: en lugar de escribir la dirección a una distancia fija del comienzo de la función de reemplazo, la pongo en una variable, al principio de la misma, editándolo antes de escribirla en el proceso.
Código
#include <stdio.h>
#include <windows.h>
#include <Tlhelp32.h>
 
void error(char *err);
static DWORD WINAPI hookear(LPVOID data);
static INT WINAPI hookFunc(HWND hwnd, LPCSTR tit, LPCSTR txt, UINT flag, WORD ww);
void foo(void);
 
HANDLE myProc=NULL;
 
typedef int (WINAPI *datLoadLibrary)(LPCTSTR);
typedef int (WINAPI *datGetProcAddress)(HMODULE, LPCSTR);
 
int main(int argc, char *argv[])
{
    if(argc<2) error("Uso: hook.exe PROCESO\n");
    struct {
       datLoadLibrary apiLoadLibrary;
       datGetProcAddress apiGetProcAddress;
       char libNames[5][16];
       char funNames[5][16];
       char MSG[50];
       void *hook;
       void *orApi;
       } thData;
    strcpy(thData.MSG, "Hola!");
    strcpy(thData.libNames[0], "User32.dll");
    strcpy(thData.libNames[1], "msvcrt.dll");
    strcpy(thData.libNames[2], "Kernel32.dll");
    strcpy(thData.funNames[0], "MessageBoxExA");
    strcpy(thData.funNames[1], "malloc");
    strcpy(thData.funNames[2], "memcpy");
    strcpy(thData.funNames[3], "VirtualProtect");
    strcpy(thData.funNames[4], "printf");
    thData.apiLoadLibrary=GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA");
    thData.apiGetProcAddress=GetProcAddress(GetModuleHandle("kernel32.dll"), "GetProcAddress");
 
    HANDLE lista=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    PROCESSENTRY32 pInfo;
    BOOL st=TRUE;
    pInfo.dwSize=sizeof(PROCESSENTRY32);
    Process32First(lista, &pInfo);
    int myPid=0;
    do
    {
        if(strcmp(pInfo.szExeFile, argv[1])==0)
        {
            myPid=pInfo.th32ProcessID;
            break;
        }
        Process32Next(lista, &pInfo);
    }
    while(st!=FALSE);
 
    int hookSize=(int)&hookFunc - (int)&hookear;
    int reemSize=(int)&foo - (int)&hookFunc;
 
    // Abrir proceso
    printf("[+] Abriendo proceso %i\n", myPid);
    myProc=OpenProcess(PROCESS_ALL_ACCESS, FALSE, myPid);
    if(myProc==NULL) error("[-] Error abriendo proceso.\n");
    else printf("[+] Proceso abierto.\n");
 
    SIZE_T written=0;
 
    // Reservar memoria para funcion de hookeo
    LPVOID dirToHook=VirtualAllocEx(myProc, NULL, reemSize, MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    if(dirToHook==NULL) error("[-] Error reservando hookeo.\n");
    else printf("[+] Memoria reservada para funcion de reemplazo (%i bytes).\n", reemSize);
 
    // Reservar memoria para argumento
    LPVOID dirToArg=VirtualAllocEx(myProc, NULL, sizeof(thData), MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    if(dirToArg==NULL) error("[-] Error reservando memoria para arg.\n");
    else printf("[+] Memoria reservada para arg (%i bytes).\n", sizeof(thData));  
 
    // Poner en funcion de hookeo la direccion a los args
    DWORD prot;
    BYTE *funcDir=(BYTE *)&hookFunc;
    while(*(++funcDir) != 0x90);
    VirtualProtect((LPVOID)funcDir, 4, PAGE_EXECUTE_READWRITE, &prot);
    signed int *ddir=(signed int *)funcDir; // Puntero a donde escribimos
    *ddir=(signed int)dirToArg;           // Escritura
 
    // Reservar memoria para codigo
    LPVOID dirToWrite=VirtualAllocEx(myProc, NULL, hookSize, MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    if(dirToWrite==NULL) error("[-] Error reservando memoria para codigo.\n");
    else printf("[+] Memoria reservada para codigo (%i bytes).\n", hookSize);   
 
    // Escribir funcion de hookeo
    if(WriteProcessMemory(myProc, dirToHook, (LPVOID)&hookFunc, reemSize, &written)==0) error("[-] Error escribiendo hookeo.\n");
    else printf("[+] Memoria escrita (funcion reemplazo %i bytes -> %.8X).\n", written, dirToHook);
    thData.hook=dirToHook;
 
    // Escribir argumentos 
    if(WriteProcessMemory(myProc, dirToArg, (LPVOID)&thData, sizeof(thData), &written)==0) error("[-] Error escribiendo memoria.\n");
    else printf("[+] Memoria escrita (arg %i bytes -> %.8X).\n", written, dirToArg);
 
    // Escribir el codigo en el proceso
    if(WriteProcessMemory(myProc, dirToWrite, (LPVOID)&hookear, hookSize, &written) == 0) error("[-] Error escribiendo memoria.\n");
    else printf("[+] Memoria escrita (codigo -> %.8X).\n", dirToWrite);
 
    // Lanzar el hilo a nuestro codigo
    HANDLE rThread=CreateRemoteThread(myProc, NULL, 0, (LPTHREAD_START_ROUTINE)dirToWrite, dirToArg, 0, NULL);
    if(rThread==NULL) error("[-] Error iniciando thread.\n");
    else printf("[+] Thread iniciado.\n");
    CloseHandle(myProc);
 
    return 0;
}
 
void error(char *err)
{
     if(myProc!=NULL) CloseHandle(myProc);
     printf("%s", err);
     exit(0);
}
 
static DWORD WINAPI hookear(LPVOID data)
{
     struct {
         datLoadLibrary apiLoadLibrary;
         datGetProcAddress apiGetProcAddress;
         char libNames[5][16];
         char funNames[5][16];
         char MSG[50];
         void *hook;
         void *orApi;
     } *thData;
     thData=data;
 
     // Test Hook a MessageBoxA
     void *dirApi=(void *)thData->apiGetProcAddress((HANDLE)thData->apiLoadLibrary(thData->libNames[0]), thData->funNames[0]);
     // VirtualProtect
     BOOL WINAPI (*myVirtualProtect)(LPVOID, SIZE_T, DWORD, PDWORD) = (void *)thData->apiGetProcAddress((HANDLE)thData->apiLoadLibrary(thData->libNames[2]), thData->funNames[3]);
     // malloc
     void *(*myMalloc)(size_t) = (void *)thData->apiGetProcAddress((HANDLE)thData->apiLoadLibrary(thData->libNames[1]), thData->funNames[1]);
     // memcpy
     void *(*myMemcpy)(void *, const void*, size_t) = (void *)thData->apiGetProcAddress((HANDLE)thData->apiLoadLibrary(thData->libNames[1]), thData->funNames[2]);
     DWORD prot;
     BYTE *dirYo;
     dirYo=thData->hook;
     BYTE *buffer = (BYTE *)myMalloc(10);
     myVirtualProtect((void *)buffer, 12, PAGE_EXECUTE_READWRITE, &prot);
     myMemcpy(buffer, dirApi, 5);
     buffer+=5;
     *buffer=0xE9;
     buffer++;
     *((signed int *)buffer)=((BYTE *)dirApi+1)-buffer;
     myVirtualProtect((void *)dirApi, 5, PAGE_EXECUTE_READWRITE, &prot);
     *((BYTE *)dirApi)=0xE9;
     dirApi++;
     *((signed int *)dirApi)=dirYo - ((BYTE *)dirApi+4);
     thData->orApi=buffer-6;
 
     return;
}        
 
static INT WINAPI hookFunc(HWND hwnd, LPCSTR tit, LPCSTR txt, UINT flag, WORD ww)
{
     signed int dataDir=(signed int)0x90909090;                
     struct {
         datLoadLibrary apiLoadLibrary;
         datGetProcAddress apiGetProcAddress;
         char libNames[5][16];
         char funNames[5][16];
         char MSG[50];
         void *hook;
         void *orApi;
     } *thData;
     thData=(void*)dataDir;
 
     INT WINAPI (*realMbox)(HWND, LPCSTR, LPCSTR, UINT, WORD) = (void *)thData->orApi;
     return realMbox(hwnd, thData->MSG, thData->MSG, flag, ww);
}
 
void foo(void)
{
     return;
}