Parchear la IAT para interceptar GPA

[85]

Hola, quería mostrar algo básico que puede aportar algunos conceptos. Más que nada, gente que está en sus comienzos con la programación y puede interesarse en algunos detalles técnicos.

NIVEL: Beginner
No consideren esto de nivel avanzado.

Lo primero:
IAT = IMPORT ADDRESS TABLE
http://sandsprite.com/CodeStuff/Understanding_imports.html
http://www.karmany.net/index.php/ingenieria-inversa/19-ingenieria-inversa-novatos/146-pe-header-que-es-la-iat-import-address-table
http://cboard.cprogramming.com/cplusplus-programming/99240-import-address-table-iat.html

La iat es un lugar que puede accederse fácilmente con un desensamblador y se pueden observar todos los símbolos que el ejecutable importa de ciertos módulos. Hay una forma de hacer que el ejecutable no contenga imports, pero fuera de esa técnica los ejecutables la utilizan.
Generalmente se dice que los EXE usan la IAT y las DLL las EAT,
véase EAT = EXPORT ADDRESS TABLA , es para exportar símbolos.

Más información
http://www.rohitab.com/discuss/topic/33541-assembling-an-executable-with-no-imports/
http://www.etalking.com.ar/showthread.php?400-llamar-funciones-winapi32-sin-imports


Volviendo al tema, veamos lo que uno puede hacer fácilmente, con un desensamblador:









Obteniendo la dirección específica en la IAT se puede proceder a crear el parche con el cual se logra interceptar GetProcAddress.
Se trata sólo de cambiar el valor de un puntero, poniéndole la dirección de nuestra función "de gancho" o hook, para que sea llamada en lugar de la original.

Código [Seleccionar] Expandir



//
// By 85
// PatchIAT LTFX
// elhacker.net
// etalking.com.ar
// 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 PatchIAT( 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;
}

int main(){

//400000+2004= GPA IAT ENTRY (En este programa x64core!, no lo modifiques!)
DWORD dwGPA = (DWORD)(GetModuleHandle(NULL));
dwGPA+=0x2004;

// x64core lo quiere en ASM inline..
__asm {
mov ebx, dwGPA
mov edx, [ebx]
mov pGetProcAddress, edx
}

// pGetProcAddress = *(GetProcAddress_t*)dwGPA;// Ajam..

printf("pGetProcAddress 0x%X\n\n",pGetProcAddress);
printf("GetProcAddress antes 0x%X\n\n",*(DWORD*)dwGPA);
// printf("GetProcAddress antes 0x%X\n\n",GetProcAddress);//No referenciar GPA antes del parche!

// Parchear IAT
PatchIAT( dwGPA, (DWORD)&newGetProcAddress );

// Sin PatchIAT:
//Desproteger
//DWORD* pGPA=(DWORD*)0x00402004;//400000+2004= GPA IAT ENTRY
//*pGPA=(DWORD)&newGetProcAddress;
//Proteger

printf("dwGPA 0x%X\n",dwGPA);
printf("*dwGPA 0x%X\n",*(DWORD*)dwGPA);
printf("GetProcAddress ahora 0x%X\n",GetProcAddress);
printf("newGetProcAddress 0x%X\n",newGetProcAddress);
system("pause");

DWORD test = (DWORD)GetProcAddress(GetModuleHandle("kernel32.dll"),"GetProcAddress");
printf("test 0x%X\n",test);
printf("GetProcAddress ahora 0x%X\n",GetProcAddress);
system("pause");
return 0;
}

//


Dejo el proyectito para descargar
http://www.mediafire.com/?2sowg12a6vora4n

Hasta Luego

[x64core]

Hola,

Código [Seleccionar] Expandir

400000+2004=IAT
Quien dice que la IAT siempre sera almacenada en esa dirección? En ese programa tal vez, pero creo que si vas a publicar
un metodo que fue ya publicado más de 1000 veces no crees que seria al menos publicar algo decente?

Código [Seleccionar] Expandir

__asm {
mov ebx, dwGPA
mov edx, [ebx]
mov pGetProcAddress, edx
}
porque usar ensamblador directo para acceder al contenido de un puntero?

[85]

mi publicación es decente, el indecente sos vos amigo.

que tiene que ver que la IAT no está siempre en esa dirección?

para algo la busqué en el PE EXPLORER !! se trata de usar el desensamblador no de hacer algo automático. Si se trata de este programa específicamente!. Ni leer sabés, nice bepi


y si, tal parece que se ha publicado 1001 vez

[x64core]

mi publicación es decente, el indecente sos vos amigo.

que tiene que ver que la IAT no está siempre en esa dirección?

para algo la busqué en el PE EXPLORER !! se trata de usar el desensamblador no de hacer algo automático. Si se trata de este programa específicamente!. Ni leer sabés, nice bepi


y si, tal parece que se ha publicado 1001 vez

que tiene que ver que la IAT no está siempre en esa dirección?

Lucis como que no tenes idea de lo que vos mismo publicas, bueno no me extrañaria, ya que al parecer solo sabes usar un desesamblador y tener el estilo de un niño programador.

Y eso quiere decir que cada vez que quiero hookear la IAT tendre que usar un desesamblador y todo lio que has publicado?
Estamos en el año 2013 si no te has dado cuenta.

[85]

para que voy a adjuntar el OLLY DBG ? necesito hacer eso?
puedo abrilo con un editor PE sólamente.  

EJ: LORD PE

Seguro no conocés nada, ni el OLLY, ni el LORD PE, windbg?

quién habló de hookear APIs? PFF

El título te lo dice amigo:

Pachear la IAT, no es hooking en general, el hooking es algo secundario en este topic, el tema era parchear la IAT.

seguro estás aprendiendo API hooking y me lo querés demostrar XD

JAJA x64 se pone,  nice bepi  

[x64core]

para que voy a adjuntar el OLLY DBG ? necesito hacer eso?
puedo abrilo con un editor PE sólamente.  

EJ: LORD PE

Seguro no conocés nada, ni el OLLY, ni el LORD PE, windbg?

quién habló de hookear APIs? PFF

El título te lo dice amigo:

Pachear la IAT, no es hooking en general, el hooking es algo secundario en este topic, el tema era parchear la IAT.

seguro estás aprendiendo API hooking y me lo querés demostrar XD

JAJA x64 se pone,  nice bepi  

Este chico es tan divertido, solo para que no continues espameando el foro, mandame algo decente por MP.

[85]

Para el rico bepi de x64core que dice que usar el ensamblador en línea no es portable, y si pero qué me importa? si el objetivo es parchear la IAT......
si quiero lo hago todo con ensamblador en línea we
Era algo demostrativo nada más...

veamos como quedaría:

Código [Seleccionar] Expandir

/* __asm {
mov ebx, dwGPA
mov edx, [ebx]
mov pGetProcAddress, edx
}*/

POR

Código [Seleccionar] Expandir


typedef FARPROC (WINAPI* GetProcAddress_t) ( HMODULE hModule, LPCSTR lpProcName );

pGetProcAddress = *(GetProcAddress_t*)dwGPA;

[x64core]

Para el rico bepi de x64core que dice que usar el ensamblador en línea no es portable, y si pero qué me importa? si el objetivo es parchear la IAT......
si quiero lo hago todo con ensamblador en línea we
Era algo demostrativo nada más...

veamos como quedaría:

Código [Seleccionar] Expandir

/* __asm {
mov ebx, dwGPA
mov edx, [ebx]
mov pGetProcAddress, edx
}*/

POR

Código [Seleccionar] Expandir


typedef FARPROC (WINAPI* GetProcAddress_t) ( HMODULE hModule, LPCSTR lpProcName );

pGetProcAddress = *(GetProcAddress_t*)dwGPA;

Felicidades, ya pudiste acceder al contenido de un puntero sin usar ensamblador al menos usando tu estilo de casting

[MCKSys Argentina]

Sin ánimos de ofender, tengo pregunta: Cuál es el objetivo de parchear la IAT del proceso que estas corriendo?

En todo caso, no sería mejor parchear la API?

Digo, porque por ej.. una DLL cargada por el ejecutable no va a usar la IAT del EXE, va a usar su propia IAT.

Por esto, no le veo la utilidad al parcheo de la IAT.

Podrías explicar la finalidad del parche?