Mensajes

en principio no entendia ese calculo por supongo que se trata de posiciones fijas y al restarlas da la diferencia de lo que ocupa , igual eso se aplicaria solo si fuera una funcion como en el codigo de eon pero en este son 3 .. porque asi com esta escrito se denota que lo que esta restando son dos direcciones de memoria (la de las dos funciones), el tema es como saber si su posicion es fija

Código [Seleccionar] Expandir


DWORD inyectada (datos *data)
{
         data -> apiMessageBoxA (0, data->mensaje, data->titulo, 0);
         return 0;
}
void inyectora()
{
           DWORD TamFun; // El tamaño de la función a inyectar
          TamFun = (long unsigned int) inyectora - (long unsigned int)inyectada;
}

void main()
{
       inyectora();
}


[EDITADO]

Si, se puede aunque Sleep la tenes en la API y dudo que sean necesarios numeros aleatorios  

Actualiza el compilador y podras usar __readfsdword.

JAJAJAJAJAJAJ es que iba a hacer otra cosa en primer lugar con srand y rand  

EDITADO
los tamaños de las primeras dos funciones no son correctos alguien sabe como es el calculamiento ?
por ejemplo para TestFunc

Código [Seleccionar] Expandir


DWORD proc_size1 = (DWORD)end_proc - (DWORD)TestFunc;


pero para HookFunc

Código [Seleccionar] Expandir


DWORD proc_size2 = (DWORD)end_proc - (DWORD)TestFunc - (DWORD)HookFunc;


seria asi ?

te lo mande por pm

y lo de msvcrt.dll se puede hacer loadlibrary en el proceso remoto y cargarla?
aparte me entro una duda sobre esa libreria porque existen tambien msvcrt6 y msvcrt7, etc

y lo del truco no compila sabes porque no permite ese simbolo el __readfsdword  

EDITADO
claro era para visual studio 2005 en adelante XD
http://msdn.microsoft.com/en-US/library/3887zk1s(v=VS.80).aspx

gracias amigo por tu dedicacion, pero algunos de esos trucos es la primera ves que los miro XD
sin dejarlos de lado, me podes decir porque este code no funcionaria, es solo una prueba de concepto y ni compila pero necesitaria entender algunos puntos sobre el, antes de avanzar
el codigo ha cambiado un poco eso si, pero con este ejemplo es mas figurado y si entendes ingles que me parece que si porque me recomendaste textos en ingles, etnonces vas a endender los comentarios

lo que quisiera saber sobre este code es especificamente porque no funcionaria o quedaria sin comunicacion entre el proceso local y remoto, osea si en algun momento alguna direccion es invalida a causa de esa desconexion. luego voy a pasar a los trucos

Código (c) [Seleccionar] Expandir


/*---------------------------*/
typedef struct _PROCESS_info
{
       DWORD pid;
       char* name;
       HANDLE oHandle;
} PROCESS_info, *PPROCESS_info;

/*---------------------------*/

//Structure who will be copied
struct lib_struct
{
           /* these are from kernel32.dll that is at a static virtual address */
           tLoadLibrary pLoadLibrary;//---------> pointer to function
           tGetProcAddress pGetProcAddress;//---------> pointer to function
           tGetModuleHandleA pGetModuleHandleA;//---------> pointer to function
           tCreateThread pCreateThread;//---------> pointer to function
           /*------------------------------------*/

           /* from msvcrt.dll */
           tSleep pSleep;//---------> pointer to function
           tSrand pSrand;//---------> pointer to function
           tRand; pRand;//---------> pointer to function

           /* from opengl32.dll */
           tglBegin pglBegin;//---------> pointer to the hook function
           tglBegin Orig_glBegin;//---------> return address for the hook function


           char str_glBegin[128];//will hold the name of the function
           char strOpengl32[MAX_PATH];//will hold the name of the DLL
};

/*---------------------------*/
//Function who will be copied in the remote process
void APIENTRY New_glBegin(GLenum m)
{
         lib_struct *Plib;

         Plib->Orig_glBegin(m);
}

/*---------------------------*/
//Function who will be copied in the remote process
static DWORD WINAPI HookFunction(LPVOID libs_struct)
{
            lib_struct *Plib=(lib_struct)libs_struct;

            HMODULE load_lib = Plib->pLoadLibrary(plib->strOpengl32);

           //Initialize the original address for glBegin hook return
           Plib->Orig_glBegin= (tglBegin)Plib->pGetProcAddress(load_lib, plib->str_glBegin);

           /* detour on glBegin at remote process (pseudocode) */

           *glBegin=Plib->pglBegin;//pglBegin is the address of the hook function in the remote process

           return 0;
}

/*---------------------------*/
//Function who will be copied in the remote process
static int WINAPI test_func(LPVOID libs_struct)
{
             lib_struct *Plib=(lib_struct)libs_struct;

            //this function will be copied in the remote process; I would like to start a thread here
           //and the hooking thread will hook glBegin.
           //in order to do that I need to copy New_glBegin and init pointer pglBegin to locate it
           //in the remote process
           //I also need to init Orig_glBegin so the hook can return to the original glBegin
           //but the pointer value has to be the glBegin address in the remote process

            PLib->pCreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Plib->HookFunction, libs_struct, 0, NULL);

            return 1;
}

/*---------------------------*/

static void __declspec(naked) end_proc() {}

/*---------------------------*/

int main()
{
          lib_struct libs;

           //PASO 1
           PROCESS_info process;
           process.pid = GetProcessPid(process.name
           printf("[*] Getting full access...");

           //PASO 2
           libs.pLoadLibrary = (pLoadLibrary)GetProcAddress(kernel32, "LoadLibraryA");
           libs.pGetProcAddress = (pGetProcAddress)GetProcAddress(kernel32, "GetProcAddress");
           strcpy(libs.strOpeng32, "opengl32.dll");
           strcpy(libs.str_glBegin, "glBegin");
           printf("[*] Filling up lib_struct...");

           //PASO 3
           process.oHandle = OpenProcess(PROCESS_CREATE_THREAD|PROCESS_QUERY_INFORMATION|PROCESS_VM_OPERATION|PROCESS_VM_READ|PROCESS_VM_WRITE, FALSE, process.pid);
           printf("[*] Opening process %s...", process.name);

           //PASO 4
           DWORD proc_size = (DWORD)end_proc - (DWORD)test_func;
           printf("[*] Function size: %d\n", proc_size);

           //PASO 5
           LPVOID [b]glbeginhook_addr[/b] = VirtualAllocEx(process.oHandle, NULL, proc_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
           LPVOID [b]hookfunction_addr[/b] = VirtualAllocEx(process.oHandle, NULL, proc_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
           LPVOID [b]testfunc_addr[/b] = VirtualAllocEx(process.oHandle, NULL, proc_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);

           printf("[*] Allocating memory space in %s for test_func...", process.name);


           //PASO 6 (getting the addreses where I alloc'ed memory for New_glBegin)
           [b]libs.Orig_glBegin[/b] = *(tglBegin)glbeginhook_addr;
           printf("[*] Filling up lib_struct again!!!!! ...");

           //PASO 7
           LPVOID struct_addr = VirtualAllocEx(process.oHandle, NULL, sizeof(libs), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
           printf("[*] Allocating memory space in %s for lib_struct libs...", process.name);

           //PASO 8 (writting the 3 functions)
           WriteProcessMemory(process.oHandle, [b]glbeginhook_addr[/b], New_glBegin, proc_size, &written_bytes);
           WriteProcessMemory(process.oHandle, [b]hookfunction_addr[/b], HookFunc, proc_size, &written_bytes);
           WriteProcessMemory(process.oHandle, [b]testfunc_addr[/b], test_func, proc_size, &written_bytes);

           printf("[*] Writing \'test_func\' in %s...", process.name);

           //PASO 9 (writting the structure)
           WriteProcessMemory(process.oHandle, struct_addr, &libs, sizeof(libs), &written_bytes);
           printf("[*] Writing \'lib_struct libs\' in %s...", process.name);

           //PASO 10
           DWORD thread_id;
           HANDLE remote_thread = CreateRemoteThread(process.oHandle, NULL, 0, (LPTHREAD_START_ROUTINE)func_addr, struct_addr, 0, &thread_id);
           printf("[*] Creating remote thread for test_func in %s...", process.name);

           //PASO 11
           printf(" done\n[*] Thread id: %d\n", thread_id);
}
[/quote]

obviamente el primer problema a primera impresion es en New_glBegin porque no tiene la address de la struct como para retornar Orig_glBegin :(


[EDITADO]

suponemos que en la struct principal tenemos los punteros a funciones de myHook, B y de Func, y por su puesto tambien de Orig_myHook (porque es el valor de retorno de myHook), suponemos que las 3 funciones fueron escritas en la memoria remota osea (myHook, B y Func), entonces yo lo qye necesito es tener un hilo que se ejecute en el proceso remoto y que me inicialize los 4 punteros antes mecionados, los primeros 3 corresponden a las funciones mapeadas digamos, y el cuarto corresponde a una direccion que se encuentra en el proceso remoto, por decir "loadlibrary", usando getprocaddress como en el ejemplo de eon. la pregunta seria los pasos en el tiempo digamos en qe momento deberia inicializar los 4 punteros, y si debo usar ese mismo hilo. obviamente deben ser inicializados despues de la copia de las 3 funciones claramente.

lo que se deduce de esto es que solo seran miembros de la struct los 4 punteros a funciones, las definiciones de las 3 funciones no son de la struct sino que son separadas y son copiadas a parte.

esto esta bien en teoria?

EDITADO
me faltaba el peqenio detalle de que si myHook no es de la struct no accede al puntero a funcion Orig_myHook para poder retornar a la original, se debe implementar algun truqillo como el que mostraste.. asi no es necesario agregar argumentos ni modificar la declaracion del hook

[EDITADO]

http://foro.elhacker.net/net/inyeccion_dll_sin_dll_by_e0n_problema_edicion_de_memoria_convertir_a_c-t267355.0.html

http://www.infomalware.net/t62-inyeccion-de-codigo-sin-dll

si con dll ya esta hecho pero es mucho mas facil, y como encontre el codigo este se me ocurrio hacerlo de esta forma... como es por aprendizaje nada mas ..
supongamos que estan las 3 funciones en la memoria remota (A,B y myHook), Inyectada ya fue copiada, pero el problema es myHook porque las 3 van a transformarse en 3 punteros a funciones:

Código [Seleccionar] Expandir


struct EstructIny
{
       TipoCT pCT;
       TipoS pSleep;

       //esto no sirve porque no son direcciones remotas sino locales
       /*
       void WINAPI myHook(int i);
       void B();
       static DWORD WINAPI Func(LPVOID lpParameter);*/

       //estos punteros a funciones deben guardar direcciones remotas de las funciones
       TipoMH pmyHook;// =&myHook
       TipoMH Orig_myHook;
       TipoB pB;// =&B
       TipoFunc pFunc;// =&Func
};

///Si estan afuera de la struct
//
void WINAPI myHook(int i)
{
     //El problema es myHook porque necesita llamar algunas funciones de la struct
     //como pSleep o pLoadLibrary, pGetModuleHandle, etc
     //y aparte debe retornar la direccion original de la api en cuestion y dicha direccion
     //es remota tambien

     //y siendo Orig_myHook miembro de la struct y myHook no siendolo se complica
     //porque no puedo modificar la definicion de myHook porque es el reemplazo de una api
    //osea no puedo agregar argumentos , etc entonces myHook deberia estar dentro de la struct
   //pero entonces como va a ser copiada por separado  :huh:

     Orig_myHook(i);
}
void B()
{
}
static DWORD WINAPI Func(LPVOID lpParameter)
{
       EstructIny *ptrThis = (EstructIny*)lpParameter;
       ptrThis->pSleep(2000);    
       return 0;
}


//SI son parte de la struct (punteros a funciones en la struct, pero con direcciones locales)
/*
void WINAPI EstructIny::myHook(int i)
{
     Orig_myHook(i);
}
void EstructIny::B()
{
}
static DWORD WINAPI EstructIny::Func(LPVOID lpParameter)
{
       EstructIny *ptrThis = (EstructIny*)lpParameter;
       ptrThis->pSleep(2000);    
       return 0;
}*/

/////

//La función que inyectaremos (Esta ya esta en el otro proceso)
DWORD Inyectada ( EstructIny *data)
{
     data->pCT(NULL, 0, (LPTHREAD_START_ROUTINE)data->Func, data, 0, NULL);
     return 0;
}

osea lo que no entiendo es como asignarle al myHook remoto el valor de retorno, aparte de que me doy cuenta de lo complicado del metodo sin embargo ya es tarde para dejarlo XD

EDITADO
asi es tal cual el codigo de eon solo que usa messagebox solamente pero calculado localmente

Código [Seleccionar] Expandir



//Función que nos devuelve un DWORD con la dirección de una api
DWORD GetAddress(char*module, char*function)
{
HMODULE dh = LoadLibrary(module);
DWORD pf = (DWORD)GetProcAddress(dh,function);
FreeLibrary(dh);
return pf;
}


//La función inyectora
void Inyectora()
{
int      pid;                   // Este es el pid del proceso en el que nos queremos inyectar
HANDLE  proc;                   // El handle del proceso en el que inyectaremos
EstructIny    dat;     // El tipo de dato de la estructura
DWORD    TamFun;                // El tamaño de la función a inyectar
void*esp;                   // Lugar de memoria donde copiaremos nuestra función

HANDLE handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0); //Obtenemos el pid
PROCESSENTRY32 procinfo = { sizeof(PROCESSENTRY32) };
while(Process32Next(handle, &procinfo))
{
 if(!strcmp(procinfo.szExeFile, "notepad.exe"))
 {
 CloseHandle(handle);
         pid = procinfo.th32ProcessID;
 }
}
CloseHandle(handle);

//Abrimos el proceso en el que nos inyectaremos
proc = OpenProcess(PROCESS_CREATE_THREAD | PROCESS_VM_OPERATION | PROCESS_VM_WRITE, false, pid);

//---------------------------
//Metemos la dirección de la api en la estructura llamando a la función GetAddress
       //estas son direcciones locales!
// dat.pCreateThread = (CreateThread_t)GetAddress("KERNEL32.DLL", "CreateThread");
// dat.pSleep = (Sleep_t)GetAddress("KERNEL32.DLL", "Sleep");
//--------------------------------------


//Reservamos espacio para nuestra estructura en el proceso a inyectar y la escribimos
EstructIny*dat_ = (EstructIny*)VirtualAllocEx(proc, 0, sizeof(EstructIny), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
WriteProcessMemory(proc, dat_, &dat, sizeof(EstructIny), NULL);

//Calculamos el tamaño de la función a inyectar
TamFun = (long unsigned int) Inyectora - (long unsigned int)Inyectada;

//Reservamos espacio para la función, escribimos en él y creamos un hilo
esp = VirtualAllocEx(proc, 0, TamFun, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
WriteProcessMemory(proc, esp, (void*)Inyectada, TamFun, NULL);
CreateRemoteThread(proc, NULL, 0, (LPTHREAD_START_ROUTINE) esp, dat_, 0, NULL);
}


Tene en cuenta que las funciones NO estan junto a los miembros de la estructura eh, las vas a tener que copiar por separado. Ahi en tiempo de ejecucion cuando reserves la memoria para myHook en el otro proceso vas a tener su direccion ... tampoco podes llamar a B asi directamente ... es mas, ni siquiera podes llamar a Func asi al ser otro proceso. A Func podrias copiarla en remoto y ejecutarla (lo acabo de hacer de prueba, tu codigo fallaria al llamar a Func que es una direccion de tu proceso) pero llamar a B ya no funcionaria salvo que tambien la hicieras estatica ... en definitiva si deberias hacer a myHook estatica, en realidad solo de esa manera podrias respetar la verdadera funcion que no es un metodo seguramente.

claro, etntiendo que en una struct se guardan direcciones osea ya sea de punteros, punteros a funciones o direcciones de datos. en el caso de poner funciones dentro de structs estas quedarian traducidas a direcciones o mejor dicho traducidas a punteros a funciones, y las direcciones de esas funciones estarian en el codigo del inyector y no en el remoto. entonces debo copiar cada funcion con writeprocesmemory en el remoto pero,  supongo que debo seguir manteniendo el control desde la struct primaria en la cual ahora debere poner algunos punteros a funciones  por ejemplo, un puntero a funcion para A) otro para B) y para el myHook, es esto correcto?,
el problema viene a la integridad de myHook porque suponemos que el gancho va a ser sobre una api no se digamos, loadlibrary por decir cualquiera, entonces como hago para hacerla estatica pero ademas tener acceso a otros miembros de la struct, porque dentro de ese myHook se necesitan hacer algunas cosas, algunas llamadas y todo eso deben ser punteros a funciones guardados en mi struct.

lo que no entiendo tambien de tu comentario es porque el createthread fallaria al crear el hilo y llamar a "Func" sabiendo que createthread se usa mediante a un puntero a funcion y la direccion que tiene es valida (segun el metodo del user eon)... o sino me confundi y lo que dirias es que falla al llamar a "Func" porque en la struct en realidad se guardaria una direccion de "Func" pero el cuerpo de la funcion tiene una start address que en realidad esta en el proceso del inyector y no en el remoto... eso tiene sentido, y en tal caso se deberia copiar al proceso remoto cada funcion de la struct ( A() B() y Func() y myHook() ) y solo guardar los punteros a funciones dentro de la struct, es eso lo que decis ?

Código [Seleccionar] Expandir


struct EstructIny
{
       TipoCT pCT;
       TipoS pSleep;

       void WINAPI myHook(int i)//ESTE ES UN HOOK de cualquier funcion, una api, ETC
       {
              pmyHook(i);
       }

       void B()//B solo quiere la direccion de myHook
       {
            //El problema es que estos casts no sirven, y aparte no permite usar el operador
            // & es ilegal en este caso

            DWORD* dir;
            *dir = (DWORD)&myHook;
       }

       static DWORD WINAPI Func(LPVOID lpParameter)
       {
              EstructIny *ptrThis = (EstructIny*)lpParameter;
              ptrThis->pSleep(2000);

              ptrThis->B();//LLAMO a B() , bien porque este es el objetivo  ::)
             
              return 0;
       }
};

//La función que inyectaremos
DWORD Inyectada ( EstructIny *data)
{
     data->pCT(NULL, 0, (LPTHREAD_START_ROUTINE)data->Func, data, 0, NULL);
     return 0;
}


que soluciones tendria para el myHook porque debo respetar su declaracion porque va usarce de reemplazo para la verdadera funcion. acaso debo hacer static a myHook o hay otra forma ?

a muy bueno   esto no lo sabia lo del cuarto parametro lo estaba mirando en tus posts
http://www.forosdelweb.com/f96/metodo-clase-como-parametro-c-474946/
http://solocodigo.com/8895/esperar-a-un-evento-sin-bloquear-el-programa/

#include <windows.h>

class ClaseEjemplo
{
   public:
      static DWORD WINAPI FromClassHello(LPVOID lpParameter);
      char msg[1024];
};

DWORD WINAPI ClaseEjemplo::FromClassHello(LPVOID lpParameter)
{
   ClaseEjemplo *ptrThis = (ClaseEjemplo*)lpParameter;
   MessageBox(0,"Hello world desde una clase en un thread xp",ptrThis->msg,0);
   return 0;
}

int WINAPI WinMain(HINSTANCE,HINSTANCE,LPSTR,int)
{
   ClaseEjemplo ej1;
   strcpy(ej1.msg, "ejemplo");
   HANDLE h1 = CreateThread(0,0, (LPTHREAD_START_ROUTINE)&ClaseEjemplo::FromClassHello, (LPVOID)&ej1,0,0);
   if(h1 == INVALID_HANDLE_VALUE)
      MessageBox(0,"Meeec Maaal","windows dice:",0);
   Sleep(5000);
   CloseHandle(h1);
}

no hay una forma sin tener que ahcerla static? es que necesito llamar algunas cosas de la struct dentro de la funcion "Func", por ejemplo
en tu ejemplo llamas a "Messagebox" pero eso es un simbolo valido solo para tu programa inyector y no para el bloqe de memoria (struct) que se ineycta en el otro proceso no es asi?

Código [Seleccionar] Expandir


struct EstructIny
{
       TipoCT pCT;
       TipoS pSleep;

       "static" void Func(void)//no puede ser static porque debe llamar pSleep (entre otrsa cosas)
       {
            pSleep(2000);
       }
}

//La función que inyectaremos
DWORD Inyectada ( EstructIny *data)
{
     data->pCT(NULL, 0, (LPTHREAD_START_ROUTINE)data->Func, NULL, 0, NULL);
     return 0;
}


lo que ocurre es que en "Func" debo instalar un gancho (hook) y por lo tanto debo usar elementos de la struct misma, porqe estare ejecutando esta struct en otro proceso.....