Hola buenas, hace pocos días estuve leyendo sobre el API hooking y de allí salté a la inyección de DLL, y más adelante pasé a la inyección de código, y ayudándome con un código que encontré en rohitab fuí dando forma a mi código y puse control de errores. Este es el link por si a alguien le interesa, me fue muy útil:

http://www.rohitab.com/discuss/topic/39357-code-cave-injection-tutorial-c/

El programa inyecta un MessageBox en la aplicación objetivo, tras salir el MessageBox y pulsar aceptar se cierra la aplicación objetivo. Desconozco el porqué, os dejo el código a ver si me podéis ayudar a saber:

#pragma once
#include <windows.h>
#include <shlobj.h>
#include <wininet.h>
#include <tlhelp32.h>
#include <shlwapi.h>
 
typedef int (WINAPI* MsgBoxParam)(HWND, LPCSTR, LPCSTR, UINT);
using namespace std;
 
struct PARAMETERS{
	DWORD MessageBoxInj;
	char text[50];
	char caption[25];
	int buttons;
	//HWND handle;
};
 
DWORD GetPIDFromProcName(LPCWSTR procName);
DWORD MyFunc(PARAMETERS * myparam);
DWORD Useless();
bool Injecter();
 
DWORD GetPIDFromProcName(LPCWSTR procName)
{
	PROCESSENTRY32 pe;
	HANDLE thSnapShot;
	BOOL retval;
 
	thSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
 
	if (thSnapShot == INVALID_HANDLE_VALUE)
	{
		return 0;
	}
 
	pe.dwSize = sizeof(PROCESSENTRY32);
 
	retval = Process32First(thSnapShot, &pe);
 
	while (retval)
	{
		if (!lstrcmp(pe.szExeFile, procName))
		{
			return pe.th32ProcessID;
		}
		retval = Process32Next(thSnapShot, &pe);
	}
 
	return 0;
}
 
static DWORD MyFunc(PARAMETERS * myparam){
	MsgBoxParam MsgBox = (MsgBoxParam)myparam->MessageBoxInj;
	int result = MsgBox(0, myparam->text, myparam->caption, myparam->buttons);
	switch (result){
	case IDOK:
                //code
		break;
	case IDCANCEL:
		//code
		break;
	}
	return 0;
}
 
static DWORD useless(){
	return 0;
}
 
//debe ser static para que el compilador las ponga juntas y calcule bien el tamaño :)
bool Injecter()
{
 
	HANDLE proc = NULL;
	DWORD pID = NULL;
 
	if ((pID = GetPIDFromProcName(L"chrome.exe")) == NULL)// no GetTargetThreadIDFromProcName ^^
	{
		return false;
	}
 
	if ((proc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pID)) == NULL)
	{
		return false;
	}
 
	char * mytext = "Hello by CodeCave!";
	char * mycaption = "Injection result";
 
	PARAMETERS data;   //let's fill in a PARAMETERS struct
 
	HINSTANCE hUserModule = LoadLibraryA("user32.dll");
 
	if (hUserModule == NULL)
	{
		CloseHandle(proc);
		return false;
	}
 
	data.MessageBoxInj = (DWORD)GetProcAddress(hUserModule, "MessageBoxA");
	strcpy(data.text, mytext);
	strcpy(data.caption, mycaption);
	data.buttons = MB_OKCANCEL | MB_ICONQUESTION;
 
	DWORD_PTR size_myFunc = (DWORD_PTR)((LPBYTE)useless - (LPBYTE)MyFunc);
 
	LPVOID MyFuncAddress = NULL;
 
	if ((MyFuncAddress = VirtualAllocEx(proc, NULL, size_myFunc, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE)) == NULL)
	{
		CloseHandle(proc);
		return false;
	}
 
	if (WriteProcessMemory(proc, MyFuncAddress, (LPVOID)MyFunc, size_myFunc, NULL) == NULL)
	{
		VirtualFree(MyFuncAddress, 0, MEM_RELEASE);
		CloseHandle(proc);
		return false;
	}
 
	LPVOID DataAddress = NULL;
 
	if ((DataAddress = VirtualAllocEx(proc, NULL, sizeof(PARAMETERS), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE)) == NULL)
	{
		CloseHandle(proc);
		return false;
	}
 
	if (WriteProcessMemory(proc, DataAddress, (LPVOID)&data, sizeof(PARAMETERS), NULL) == NULL)
	{
		VirtualFree(MyFuncAddress, 0, MEM_RELEASE);
		VirtualFree(DataAddress, 0, MEM_RELEASE);
		CloseHandle(proc);
		return false;
	}
 
	HANDLE thread = NULL;
 
	if ((thread = CreateRemoteThread(proc, NULL, 0, (LPTHREAD_START_ROUTINE)MyFuncAddress, DataAddress, 0, NULL)) == NULL)
	{
		VirtualFree(MyFuncAddress, 0, MEM_RELEASE);
		VirtualFree(DataAddress, 0, MEM_RELEASE);
		CloseHandle(proc);
		return false;
	}
 
	WaitForSingleObject(thread, INFINITE);
	VirtualFree(MyFuncAddress, 0, MEM_RELEASE);
	VirtualFree(DataAddress, 0, MEM_RELEASE);
	CloseHandle(thread);
	CloseHandle(proc);
	cout << "Injection completed!" << endl;
 
	 return true;
}
 
 

Al ejecutar el programa ejecuta todo sin errore y muestra "Injection completed!", pero al cerrar el MessageBox que invoco el la aplicación a la que inyecto esta se me cierra también.

Creo que se debe al calculo del tamaño de la función a inyectar, quizás dependiendo de un compilador pueda variar el resultado.

Saludos y gracias.

Hola fary, gracias por la respuesta.

GetTargetThreadIDFromProcName es GetPIDFromProcName que lo cambié el nombre para que fuera más sencillo, eso ha sido un fallo de edición, es simplemente una función que devuelve el PID de un proceso que le pasas como argumento. Es GetPIDFromProcName vamos XD.

El caso es el compilador y que no se como usar el debugger para pillar las direcciones de las funciones y en qué puede ayudarme a pesar de que he estado buscando sobre ello.

Uso visual studio 2013 (v120). El compilador es derivado de g++ es propio de VS.  Calculo el tamaño de la función con delimitandola con otra función static, pero ese método inestable para calcular el tamaño de la función dependiendo del compilador. Es probable que el mismo código funcione en codeblocks sin problemas. Pero en caso de ser eso lo que falle, ¿como puedo arreglarlo?, ¿dónde debería de inspeccionar?.

Seguiré probando más adelante con la versión release y otros compiladores, pero tengo que hacerlo con el de VS.

Un saludo.

Edito: Buenas acabo de probar el código en codeblocks y funciona sin problemas, codeblocks usa g++ y para C gcc si no mal recuerdo.  Luego no es problema del código, es del compilador.

Bueno solucionado todavía no está, aunque si he confirmado que el problema tiene que ver con el compilador como suponía, luego el código está bien.

Ahora, creo que se puede solucionar de las siguientes maneras:

- Cargando el código a inyectar ya compilado en una variable e inyectar desde ella (no  me acaba de gustar, pero ahí esta).

- Cambiando de compilador, el compilador de visual studio creo que ofusca el código y es por eso que falla, con otro funcionaría. Pero aún así no se podrian usar crypters ni nada por el estilo con el ejecutable, ya que al acceder al código a inyectar si esta ofuscado no funcionaría (aunque dependería del crypter algunos si), y eso es buena **.

- Como tú dices abriendo el ejecutable con el ollydbg, pero si por cada vez que lo vuelvo a compilar o cada cambio que añado tengo que estar haciendo eso para que funcione y buscando las direcciones de memoria y tal, tampoco me parece un buen método, pero es lo que más me convence aunque ahora mismo no sabría como hacerlo.

El problema de la inyección de código es: ¿es compatible con crypters?.

Luego me pondré a mirar como va eso del ollydbg a ver si encuentro algo X"D

Saludos!.

No se trata del compilador exactamente, sino de características del código compilado (el compilador añade cosas caprichosamente que se pueden desactivar/remover [?]).

Deberías revisar las instrucciones de la función a inyectar mediante IDA o algún debugger. Lo más probable es que encuentres al menos un CALL a una dirección de memoria, situado posteriormente al MessageBoxA, "perteneciente" al 'inyector' y no a chrome.exe.

La función a la que intenta llamar el thread corresponde a _RTC_CheckEsp (al menos en VS2015). Pertenece a un conjunto de funciones que agrega el compilador para reportar errores en run-time, y se encuentra dentro del mismo ejecutable compilado.

Te recomiendo visitar este enlace para que conozcas con más detalle sobre lo que es RTC (Run-Time Error Checking) y cómo desactivarlo: https://msdn.microsoft.com/en-us/library/8wtf2dfz.aspx

  no entiendo tu post :s

Lo más fácil y mejor es que suba el ejecutable que genera y lo revisamos desde un debugger...

Saludos!!