Parchear la EAT para interceptar GPA

[85]

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 (cpp) [Seleccionar] Expandir



//
// 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