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

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

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

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