Mensajes

Para iniciar sesión en algún sitio, además de mandar los datos correctos, vas a tener que guardar y utilizar la cookie que el servidor te mande cada vez que quieras interactuar logueado.

Yo nunca usé esas APIs, siempre tiré de sockets para hacer la interacción HTTP con un ciclo de limpieza para sacar los headers. Con lo que usas sería con ésto:
http://msdn.microsoft.com/en-us/library/aa385373%28v=vs.85%29.aspx

Vete a Firefox. Descarga el plug-in "Tamper Data". Ve al foro en cuestión. Ve a nuevo post, y escribe lo que sea. No lo envíes. Activa tamper data, y trata de no tener más conexiones activas mientras capturas. Haz el post. Tamper data te mostrará los campos POST que se envían y a que dirección.

Chachi, grupo 2.
Cuando los horarios y tal?
Ah, tendré problemas por seguir el taller con un slack de 64 bits? Si no, me instalo una virtual.

int fprintf ( FILE * stream, const char * format, ... );

No pides ayuda, pides la tarea entera.
Pon tus intentos a ver que pasa.

Apuntame.
Zona: España.
Horario: 18:00 21:00
Buen proyecto.

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


voy a mirarlo en la pagina esa que subes el archivo y te lo escanea por un monton de Av... ¿como se llamaba esa página? xDD

Código [Seleccionar] Expandir


http://vscan.novirusthanks.org/
http://www.virustotal.com/index.html


Se puede perfectamente y sin permisos de administrador, dependiendo de donde quieras inyectar... Solo asegurate de que pasas todas las cadenas necesarias en la estructura de datos, así como la dirección de LoadLibrary y GetProcAddress para obtener las demás funciones que vayas a usar. Yo mismo lo hice ayer por primera vez XD

El archivo que contiene eso es pasado al motor PHP.
PHP envía al cliente (a tí, a tu navegador) lo que no hay entre "<?php" y "?>", y lo que está entre eso lo interpreta, no siendo visible nunca para el cliente.
Es lo que te han dicho sobre que PHP trabaja del lado del server, pero mas explicadito.