Parchear la EAT para interceptar GPA

NIVEL: Beginner
TEST: win XP SP3

Esta es la continuación de esta especie de tutorial que había
comenzado en este hilo:

http://foro.elhacker.net/programacion_cc/parchear_la_iat_para_interceptar_gpa-t384232.0.html

En este caso, vamos a utilizar el desensamblador que veníamos usando
para obtener ciertos datos acerca de una librería llamada kernel32.dll
para los que no la conocen, es una librería (DLL) del sistema Windows
y la pueden encontrar en la carpeta system32.
Más información:
http://en.wikipedia.org/wiki/Microsoft_Windows_library_files

Usamos el desensamblador (O un explorador PE) para observar los detalles del archivo. Y también cierta información que vamos a utilizar.

Luego el código del programa..
En este programa contamos con dos rutinas que realizan el mismo
objetivo: Parchear la EAT de kernel32.dll

La diferencia es que la primera hace las operaciones automáticamente
valiéndose de cierta información obtenida del siguiente tutorial:
http://www.mediafire.com/?6nzmp28x2pb9b4n

y de esto:
http://www.cyvera.com/how-injected-code-finds-exported-functions/

Realiza algunas operaciones con ensamblador en línea y luego parchea la EAT.

La segunda rutina cumple con el objetivo pero sin usar ensamblador
en línea.

Con respecto al por qué de usar ASM, es para mostrar algo diferente
del anterior tutorial en el que se hacía todo automáticamente y con
C/C++.
http://foro.elhacker.net/programacion_cc/parcheo_de_eat_y_de_iat_automatico-t384486.0.html

NOTA: El objetivo es como se puede usar una herramienta como puede
ser un explorador de PE, o un desensamblador cualquiera, para obtener
estos datos.

Inclusive este tipo de cosas se puede hacer sin necesidad de código, es decir simplemente usando este tipo de herramientas pero para parchear los archivos en disco. Pero la idea era codificar algo XD

El código del programa:

Código

 
//
// By 85
// elhacker.net
// etalking.com.ar
// boyscout_arg@hotmail.com
// 2013
//
 
#include<windows.h>
#include<stdio.h>
 
//
FARPROC (WINAPI* pGetProcAddress) ( HMODULE hModule, LPCSTR lpProcName );
 
typedef FARPROC (WINAPI* GetProcAddress_t) ( HMODULE hModule, LPCSTR lpProcName );
 
//
FARPROC WINAPI newGetProcAddress(HMODULE hModule, LPCSTR lpProcName)
{
	FARPROC nResult;
	nResult=pGetProcAddress(hModule, lpProcName);
	if (HIWORD(lpProcName))
	{
		if (!lstrcmp(lpProcName, "GetProcAddress"))
		{
			return (FARPROC) &newGetProcAddress;
		}
	}
	return nResult;
}
 
//
DWORD PatchEAT( DWORD pOrgFunction, DWORD pNewFunction )
{
	DWORD dwOldProtect;
	DWORD dwOldProtect2;
	DWORD pOldFunction = ((DWORD*)pOrgFunction)[0];
 
	VirtualProtect( reinterpret_cast< void * >( pOrgFunction ), sizeof( DWORD ), PAGE_EXECUTE_READWRITE, &dwOldProtect );
	((DWORD*)pOrgFunction)[0] = pNewFunction;
	VirtualProtect( reinterpret_cast< void * >( pOrgFunction ), sizeof( DWORD ), dwOldProtect, &dwOldProtect2 );
	return pOldFunction;
}
 
//
void PatchEatConInlineASM(){
 
	char* gpastr = "GetProcAddress";
	DWORD k32base = (DWORD)GetModuleHandle("kernel32.dll");
 
	// Logs
    DWORD peheader=0;
	DWORD rva_exports_dir=0;
	DWORD rva_exports_funcs=0;
	DWORD rva_exports_fnames=0;
	DWORD va_exports_fnames=0;
	DWORD va_eat=0;
	int savedeax;
	DWORD rEDX;
 
	__asm{
		mov ebx, k32base                      //EBX = kernel32.dll's base address
		mov edx,dword ptr ds:[ebx+3Ch]        //PE header
		mov peheader, edx
		mov edx,dword ptr ds:[edx+ebx+78h]    //EDX = kernel32.dll's export directory (RVA)
		mov rva_exports_dir, edx
		mov eax,dword ptr ds:[edx+ebx+1Ch]    //Address of exported funcs (EAX = EAT (RVA))
		mov rva_exports_funcs, eax
		mov edx,dword ptr ds:[edx+ebx+20h]    //EDX = Address of function names (RVA)
		mov rva_exports_fnames, edx
		add edx,ebx                           //EDX = Address of function names (VA)
		mov va_exports_fnames, edx
		add eax,ebx                           //EAX = EAT (VA)
		mov va_eat, eax
	}
 
	__asm{
 
	get_exports:
		xor ecx, ecx
		mov esi,gpastr              //Address of string "GetProcAddress" (not null-terminated)
		mov edi,dword ptr ds:[edx]  //EDI = *(EDX = VA of function names)
		add edi,ebx                 //Address of string (Exported function name) (k32+offs en edi)
		mov cl,0Eh                  //14 chars
		repe cmpsb                  //recibe dos direcciones de 2 strings (ESI,EDI)
		je short found_set_context  //Jump if this is our function
		add edx,4                   //Next function name
		add eax,4                   //Next function address
		jmp short get_exports
	found_set_context:
		mov savedeax, eax
		mov edx,dword ptr ds:[eax]
		add edx,ebx  
		mov rEDX, edx
	}
 
 
	printf("k32 0x%X\n",k32base);
	printf("peheader 0x%X\n",peheader);
	printf("rva_exports_dir 0x%X\n",rva_exports_dir);
	printf("rva_exports_funcs 0x%X\n",rva_exports_funcs);
	printf("rva_exports_fnames 0x%X\n",rva_exports_fnames);
	printf("va_exports_fnames 0x%X\n",va_exports_fnames);
	printf("va_eat 0x%X\n",va_eat);
	printf("primer entrada de va_eat 0x%X\n",*(DWORD*)va_eat);//da un rva
	printf("savedeax 0x%X\n",savedeax);// eat entry para gpa
	printf("savedeax 0x%X\n",*(DWORD*)savedeax);// el rva en el eat entry correspondiente a gpa
	printf("GetProcAddress 0x%X\n",GetProcAddress);
	printf("rEDX 0x%X\n",rEDX);
	system("pause");
 
	/////////////////////////////////////////////////
 
	// Calcular el rva con mi gpa
	DWORD rvaMiGPA = (((DWORD)newGetProcAddress)-DWORD(k32base));
 
	// Inicializar puntero de retorno a la original
	pGetProcAddress = (GetProcAddress_t)rEDX;
 
	// Parche
	PatchEAT( savedeax, rvaMiGPA );// savedeax = eat entry para gpa
 
	printf("newGetProcAddress 0x%X\n",newGetProcAddress);
//	printf("GetProcAddress 0x%X\n",GetProcAddress);
	system("pause");
}
 
//
void PatchEatSinInlineASM(){
 
	DWORD k32base = (DWORD)GetModuleHandle("kernel32.dll");
	DWORD exports = k32base+0x262C;
	DWORD* dwEAT = (DWORD*)(exports+0x28);//953 entradas
	printf("EAT 0x%X\n",dwEAT);
 
	//for(int i=0;i<409-1;i++) dwEAT+=0x1;
	//printf("GPA EAT 0x%X\n",dwEAT);
	//printf("*GPA EAT 0x%X\n",*(dwEAT));
 
	DWORD dwEATgpa = (DWORD)(dwEAT+0x198);
	printf("GPA EAT 0x%X\n",(dwEAT+0x198));//0x199 = 409
	printf("*GPA EAT 0x%X\n",*(dwEAT+0x198));
 
	DWORD rvaGPA = dwEAT[409-1];//409 = gpa index
	DWORD dwGPA = k32base+rvaGPA;
 
	printf("rvaGPA 0x%X\n",rvaGPA);
	printf("dwGPA 0x%X\n",dwGPA);
//	printf("GetProcAddress 0x%X\n",GetProcAddress);
	//system("pause");
 
	/////////////////////////////////////////////////
 
	// Calcular el rva de mi gpa
	DWORD rvaMiGPA = (((DWORD)newGetProcAddress)-DWORD(k32base));
 
	printf("dwEATgpa 0x%X\n",dwEATgpa);
	printf("rvaMiGPA 0x%X\n",rvaMiGPA);
 
	// Inicializar puntero de retorno a la original
	pGetProcAddress = (GetProcAddress_t)dwGPA;
 
	// Parche
	PatchEAT( dwEATgpa, rvaMiGPA );
 
	printf("newGetProcAddress 0x%X\n",newGetProcAddress);
//	printf("GetProcAddress 0x%X\n",GetProcAddress);
	system("pause");
}
 
//
int main(){
 
	// 1
//	PatchEatConInlineASM();
 
	// 2
	PatchEatSinInlineASM();
 
	/////////////////////////////////////////////////
	// Test
 
	DWORD test = (DWORD)GetProcAddress(GetModuleHandle("kernel32.dll"),"GetProcAddress");
	printf("test 0x%X\n",test);
	printf("pGetProcAddress 0x%X\n",pGetProcAddress);// retorno a la original
 
	system("pause");
	return 0;
}
 
//

PROYECTO VC6
http://www.mediafire.com/?t87q7m7b7give3b

hasta luego