Temas

Fue publicada hace poco, anda rulando por la red:

http://www.megaupload.com/?d=TR5ZW69D pass zeus

Seguro que a más de uno le interesa echarle un ojo al source.

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 (c) [Seleccionar] Expandir


#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;
}