elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Curso de javascript por TickTack


  Mostrar Temas
Páginas: [1]
1  Seguridad Informática / Análisis y Diseño de Malware / Zeus botnet source en: 12 Mayo 2011, 16:14 pm
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.
2  Programación / Programación C/C++ / [Solucionado] Hook sin DLL en: 24 Enero 2011, 20:08 pm
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
  1. #include <stdio.h>
  2. #include <windows.h>
  3. #include <Tlhelp32.h>
  4.  
  5. void error(char *err);
  6. static DWORD WINAPI hookear(LPVOID data);
  7. static INT WINAPI hookFunc(HWND hwnd, LPCSTR tit, LPCSTR txt, UINT flag, WORD ww);
  8. void foo(void);
  9.  
  10. HANDLE myProc=NULL;
  11.  
  12. typedef int (WINAPI *datLoadLibrary)(LPCTSTR);
  13. typedef int (WINAPI *datGetProcAddress)(HMODULE, LPCSTR);
  14.  
  15. int main(int argc, char *argv[])
  16. {
  17.    if(argc<2) error("Uso: hook.exe PROCESO\n");
  18.    struct {
  19.       datLoadLibrary apiLoadLibrary;
  20.       datGetProcAddress apiGetProcAddress;
  21.       char libNames[5][16];
  22.       char funNames[5][16];
  23.       char MSG[50];
  24.       void *hook;
  25.       void *orApi;
  26.       } thData;
  27.    strcpy(thData.MSG, "Hola!");
  28.    strcpy(thData.libNames[0], "User32.dll");
  29.    strcpy(thData.libNames[1], "msvcrt.dll");
  30.    strcpy(thData.libNames[2], "Kernel32.dll");
  31.    strcpy(thData.funNames[0], "MessageBoxExA");
  32.    strcpy(thData.funNames[1], "malloc");
  33.    strcpy(thData.funNames[2], "memcpy");
  34.    strcpy(thData.funNames[3], "VirtualProtect");
  35.    strcpy(thData.funNames[4], "printf");
  36.    thData.apiLoadLibrary=GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA");
  37.    thData.apiGetProcAddress=GetProcAddress(GetModuleHandle("kernel32.dll"), "GetProcAddress");
  38.  
  39.    HANDLE lista=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  40.    PROCESSENTRY32 pInfo;
  41.    BOOL st=TRUE;
  42.    pInfo.dwSize=sizeof(PROCESSENTRY32);
  43.    Process32First(lista, &pInfo);
  44.    int myPid=0;
  45.    do
  46.    {
  47.        if(strcmp(pInfo.szExeFile, argv[1])==0)
  48.        {
  49.            myPid=pInfo.th32ProcessID;
  50.            break;
  51.        }
  52.        Process32Next(lista, &pInfo);
  53.    }
  54.    while(st!=FALSE);
  55.  
  56.    int hookSize=(int)&hookFunc - (int)&hookear;
  57.    int reemSize=(int)&foo - (int)&hookFunc;
  58.  
  59.    // Abrir proceso
  60.    printf("[+] Abriendo proceso %i\n", myPid);
  61.    myProc=OpenProcess(PROCESS_ALL_ACCESS, FALSE, myPid);
  62.    if(myProc==NULL) error("[-] Error abriendo proceso.\n");
  63.    else printf("[+] Proceso abierto.\n");
  64.  
  65.    SIZE_T written=0;
  66.  
  67.    // Reservar memoria para funcion de hookeo
  68.    LPVOID dirToHook=VirtualAllocEx(myProc, NULL, reemSize, MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
  69.    if(dirToHook==NULL) error("[-] Error reservando hookeo.\n");
  70.    else printf("[+] Memoria reservada para funcion de reemplazo (%i bytes).\n", reemSize);
  71.  
  72.    // Reservar memoria para argumento
  73.    LPVOID dirToArg=VirtualAllocEx(myProc, NULL, sizeof(thData), MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
  74.    if(dirToArg==NULL) error("[-] Error reservando memoria para arg.\n");
  75.    else printf("[+] Memoria reservada para arg (%i bytes).\n", sizeof(thData));  
  76.  
  77.    // Poner en funcion de hookeo la direccion a los args
  78.    DWORD prot;
  79.    BYTE *funcDir=(BYTE *)&hookFunc;
  80.    while(*(++funcDir) != 0x90);
  81.    VirtualProtect((LPVOID)funcDir, 4, PAGE_EXECUTE_READWRITE, &prot);
  82.    signed int *ddir=(signed int *)funcDir; // Puntero a donde escribimos
  83.    *ddir=(signed int)dirToArg;           // Escritura
  84.  
  85.    // Reservar memoria para codigo
  86.    LPVOID dirToWrite=VirtualAllocEx(myProc, NULL, hookSize, MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
  87.    if(dirToWrite==NULL) error("[-] Error reservando memoria para codigo.\n");
  88.    else printf("[+] Memoria reservada para codigo (%i bytes).\n", hookSize);  
  89.  
  90.    // Escribir funcion de hookeo
  91.    if(WriteProcessMemory(myProc, dirToHook, (LPVOID)&hookFunc, reemSize, &written)==0) error("[-] Error escribiendo hookeo.\n");
  92.    else printf("[+] Memoria escrita (funcion reemplazo %i bytes -> %.8X).\n", written, dirToHook);
  93.    thData.hook=dirToHook;
  94.  
  95.    // Escribir argumentos
  96.    if(WriteProcessMemory(myProc, dirToArg, (LPVOID)&thData, sizeof(thData), &written)==0) error("[-] Error escribiendo memoria.\n");
  97.    else printf("[+] Memoria escrita (arg %i bytes -> %.8X).\n", written, dirToArg);
  98.  
  99.    // Escribir el codigo en el proceso
  100.    if(WriteProcessMemory(myProc, dirToWrite, (LPVOID)&hookear, hookSize, &written) == 0) error("[-] Error escribiendo memoria.\n");
  101.    else printf("[+] Memoria escrita (codigo -> %.8X).\n", dirToWrite);
  102.  
  103.    // Lanzar el hilo a nuestro codigo
  104.    HANDLE rThread=CreateRemoteThread(myProc, NULL, 0, (LPTHREAD_START_ROUTINE)dirToWrite, dirToArg, 0, NULL);
  105.    if(rThread==NULL) error("[-] Error iniciando thread.\n");
  106.    else printf("[+] Thread iniciado.\n");
  107.    CloseHandle(myProc);
  108.  
  109.    return 0;
  110. }
  111.  
  112. void error(char *err)
  113. {
  114.     if(myProc!=NULL) CloseHandle(myProc);
  115.     printf("%s", err);
  116.     exit(0);
  117. }
  118.  
  119. static DWORD WINAPI hookear(LPVOID data)
  120. {
  121.     struct {
  122.         datLoadLibrary apiLoadLibrary;
  123.         datGetProcAddress apiGetProcAddress;
  124.         char libNames[5][16];
  125.         char funNames[5][16];
  126.         char MSG[50];
  127.         void *hook;
  128.         void *orApi;
  129.     } *thData;
  130.     thData=data;
  131.  
  132.     // Test Hook a MessageBoxA
  133.     void *dirApi=(void *)thData->apiGetProcAddress((HANDLE)thData->apiLoadLibrary(thData->libNames[0]), thData->funNames[0]);
  134.     // VirtualProtect
  135.     BOOL WINAPI (*myVirtualProtect)(LPVOID, SIZE_T, DWORD, PDWORD) = (void *)thData->apiGetProcAddress((HANDLE)thData->apiLoadLibrary(thData->libNames[2]), thData->funNames[3]);
  136.     // malloc
  137.     void *(*myMalloc)(size_t) = (void *)thData->apiGetProcAddress((HANDLE)thData->apiLoadLibrary(thData->libNames[1]), thData->funNames[1]);
  138.     // memcpy
  139.     void *(*myMemcpy)(void *, const void*, size_t) = (void *)thData->apiGetProcAddress((HANDLE)thData->apiLoadLibrary(thData->libNames[1]), thData->funNames[2]);
  140.     DWORD prot;
  141.     BYTE *dirYo;
  142.     dirYo=thData->hook;
  143.     BYTE *buffer = (BYTE *)myMalloc(10);
  144.     myVirtualProtect((void *)buffer, 12, PAGE_EXECUTE_READWRITE, &prot);
  145.     myMemcpy(buffer, dirApi, 5);
  146.     buffer+=5;
  147.     *buffer=0xE9;
  148.     buffer++;
  149.     *((signed int *)buffer)=((BYTE *)dirApi+1)-buffer;
  150.     myVirtualProtect((void *)dirApi, 5, PAGE_EXECUTE_READWRITE, &prot);
  151.     *((BYTE *)dirApi)=0xE9;
  152.     dirApi++;
  153.     *((signed int *)dirApi)=dirYo - ((BYTE *)dirApi+4);
  154.     thData->orApi=buffer-6;
  155.  
  156.     return;
  157. }        
  158.  
  159. static INT WINAPI hookFunc(HWND hwnd, LPCSTR tit, LPCSTR txt, UINT flag, WORD ww)
  160. {
  161.     signed int dataDir=(signed int)0x90909090;                
  162.     struct {
  163.         datLoadLibrary apiLoadLibrary;
  164.         datGetProcAddress apiGetProcAddress;
  165.         char libNames[5][16];
  166.         char funNames[5][16];
  167.         char MSG[50];
  168.         void *hook;
  169.         void *orApi;
  170.     } *thData;
  171.     thData=(void*)dataDir;
  172.  
  173.     INT WINAPI (*realMbox)(HWND, LPCSTR, LPCSTR, UINT, WORD) = (void *)thData->orApi;
  174.     return realMbox(hwnd, thData->MSG, thData->MSG, flag, ww);
  175. }
  176.  
  177. void foo(void)
  178. {
  179.     return;
  180. }
  181.  
Páginas: [1]
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines