elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado:


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Parchear la EAT para interceptar GPA
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Parchear la EAT para interceptar GPA  (Leído 981 veces)
85

Desconectado Desconectado

Mensajes: 206



Ver Perfil WWW
Parchear la EAT para interceptar GPA
« en: 2 Marzo 2013, 10:06 am »

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
  1.  
  2. //
  3. // By 85
  4. // elhacker.net
  5. // etalking.com.ar
  6. // boyscout_arg@hotmail.com
  7. // 2013
  8. //
  9.  
  10. #include<windows.h>
  11. #include<stdio.h>
  12.  
  13. //
  14. FARPROC (WINAPI* pGetProcAddress) ( HMODULE hModule, LPCSTR lpProcName );
  15.  
  16. typedef FARPROC (WINAPI* GetProcAddress_t) ( HMODULE hModule, LPCSTR lpProcName );
  17.  
  18. //
  19. FARPROC WINAPI newGetProcAddress(HMODULE hModule, LPCSTR lpProcName)
  20. {
  21. FARPROC nResult;
  22. nResult=pGetProcAddress(hModule, lpProcName);
  23. if (HIWORD(lpProcName))
  24. {
  25. if (!lstrcmp(lpProcName, "GetProcAddress"))
  26. {
  27. return (FARPROC) &newGetProcAddress;
  28. }
  29. }
  30. return nResult;
  31. }
  32.  
  33. //
  34. DWORD PatchEAT( DWORD pOrgFunction, DWORD pNewFunction )
  35. {
  36. DWORD dwOldProtect;
  37. DWORD dwOldProtect2;
  38. DWORD pOldFunction = ((DWORD*)pOrgFunction)[0];
  39.  
  40. VirtualProtect( reinterpret_cast< void * >( pOrgFunction ), sizeof( DWORD ), PAGE_EXECUTE_READWRITE, &dwOldProtect );
  41. ((DWORD*)pOrgFunction)[0] = pNewFunction;
  42. VirtualProtect( reinterpret_cast< void * >( pOrgFunction ), sizeof( DWORD ), dwOldProtect, &dwOldProtect2 );
  43. return pOldFunction;
  44. }
  45.  
  46. //
  47. void PatchEatConInlineASM(){
  48.  
  49. char* gpastr = "GetProcAddress";
  50. DWORD k32base = (DWORD)GetModuleHandle("kernel32.dll");
  51.  
  52. // Logs
  53.    DWORD peheader=0;
  54. DWORD rva_exports_dir=0;
  55. DWORD rva_exports_funcs=0;
  56. DWORD rva_exports_fnames=0;
  57. DWORD va_exports_fnames=0;
  58. DWORD va_eat=0;
  59. int savedeax;
  60. DWORD rEDX;
  61.  
  62. __asm{
  63. mov ebx, k32base                      //EBX = kernel32.dll's base address
  64. mov edx,dword ptr ds:[ebx+3Ch]        //PE header
  65. mov peheader, edx
  66. mov edx,dword ptr ds:[edx+ebx+78h]    //EDX = kernel32.dll's export directory (RVA)
  67. mov rva_exports_dir, edx
  68. mov eax,dword ptr ds:[edx+ebx+1Ch]    //Address of exported funcs (EAX = EAT (RVA))
  69. mov rva_exports_funcs, eax
  70. mov edx,dword ptr ds:[edx+ebx+20h]    //EDX = Address of function names (RVA)
  71. mov rva_exports_fnames, edx
  72. add edx,ebx                           //EDX = Address of function names (VA)
  73. mov va_exports_fnames, edx
  74. add eax,ebx                           //EAX = EAT (VA)
  75. mov va_eat, eax
  76. }
  77.  
  78. __asm{
  79.  
  80. get_exports:
  81. xor ecx, ecx
  82. mov esi,gpastr              //Address of string "GetProcAddress" (not null-terminated)
  83. mov edi,dword ptr ds:[edx]  //EDI = *(EDX = VA of function names)
  84. add edi,ebx                 //Address of string (Exported function name) (k32+offs en edi)
  85. mov cl,0Eh                  //14 chars
  86. repe cmpsb                  //recibe dos direcciones de 2 strings (ESI,EDI)
  87. je short found_set_context  //Jump if this is our function
  88. add edx,4                   //Next function name
  89. add eax,4                   //Next function address
  90. jmp short get_exports
  91. found_set_context:
  92. mov savedeax, eax
  93. mov edx,dword ptr ds:[eax]
  94. add edx,ebx  
  95. mov rEDX, edx
  96. }
  97.  
  98.  
  99. printf("k32 0x%X\n",k32base);
  100. printf("peheader 0x%X\n",peheader);
  101. printf("rva_exports_dir 0x%X\n",rva_exports_dir);
  102. printf("rva_exports_funcs 0x%X\n",rva_exports_funcs);
  103. printf("rva_exports_fnames 0x%X\n",rva_exports_fnames);
  104. printf("va_exports_fnames 0x%X\n",va_exports_fnames);
  105. printf("va_eat 0x%X\n",va_eat);
  106. printf("primer entrada de va_eat 0x%X\n",*(DWORD*)va_eat);//da un rva
  107. printf("savedeax 0x%X\n",savedeax);// eat entry para gpa
  108. printf("savedeax 0x%X\n",*(DWORD*)savedeax);// el rva en el eat entry correspondiente a gpa
  109. printf("GetProcAddress 0x%X\n",GetProcAddress);
  110. printf("rEDX 0x%X\n",rEDX);
  111. system("pause");
  112.  
  113. /////////////////////////////////////////////////
  114.  
  115. // Calcular el rva con mi gpa
  116. DWORD rvaMiGPA = (((DWORD)newGetProcAddress)-DWORD(k32base));
  117.  
  118. // Inicializar puntero de retorno a la original
  119. pGetProcAddress = (GetProcAddress_t)rEDX;
  120.  
  121. // Parche
  122. PatchEAT( savedeax, rvaMiGPA );// savedeax = eat entry para gpa
  123.  
  124. printf("newGetProcAddress 0x%X\n",newGetProcAddress);
  125. // printf("GetProcAddress 0x%X\n",GetProcAddress);
  126. system("pause");
  127. }
  128.  
  129. //
  130. void PatchEatSinInlineASM(){
  131.  
  132. DWORD k32base = (DWORD)GetModuleHandle("kernel32.dll");
  133. DWORD exports = k32base+0x262C;
  134. DWORD* dwEAT = (DWORD*)(exports+0x28);//953 entradas
  135. printf("EAT 0x%X\n",dwEAT);
  136.  
  137. //for(int i=0;i<409-1;i++) dwEAT+=0x1;
  138. //printf("GPA EAT 0x%X\n",dwEAT);
  139. //printf("*GPA EAT 0x%X\n",*(dwEAT));
  140.  
  141. DWORD dwEATgpa = (DWORD)(dwEAT+0x198);
  142. printf("GPA EAT 0x%X\n",(dwEAT+0x198));//0x199 = 409
  143. printf("*GPA EAT 0x%X\n",*(dwEAT+0x198));
  144.  
  145. DWORD rvaGPA = dwEAT[409-1];//409 = gpa index
  146. DWORD dwGPA = k32base+rvaGPA;
  147.  
  148. printf("rvaGPA 0x%X\n",rvaGPA);
  149. printf("dwGPA 0x%X\n",dwGPA);
  150. // printf("GetProcAddress 0x%X\n",GetProcAddress);
  151. //system("pause");
  152.  
  153. /////////////////////////////////////////////////
  154.  
  155. // Calcular el rva de mi gpa
  156. DWORD rvaMiGPA = (((DWORD)newGetProcAddress)-DWORD(k32base));
  157.  
  158. printf("dwEATgpa 0x%X\n",dwEATgpa);
  159. printf("rvaMiGPA 0x%X\n",rvaMiGPA);
  160.  
  161. // Inicializar puntero de retorno a la original
  162. pGetProcAddress = (GetProcAddress_t)dwGPA;
  163.  
  164. // Parche
  165. PatchEAT( dwEATgpa, rvaMiGPA );
  166.  
  167. printf("newGetProcAddress 0x%X\n",newGetProcAddress);
  168. // printf("GetProcAddress 0x%X\n",GetProcAddress);
  169. system("pause");
  170. }
  171.  
  172. //
  173. int main(){
  174.  
  175. // 1
  176. // PatchEatConInlineASM();
  177.  
  178. // 2
  179. PatchEatSinInlineASM();
  180.  
  181. /////////////////////////////////////////////////
  182. // Test
  183.  
  184. DWORD test = (DWORD)GetProcAddress(GetModuleHandle("kernel32.dll"),"GetProcAddress");
  185. printf("test 0x%X\n",test);
  186. printf("pGetProcAddress 0x%X\n",pGetProcAddress);// retorno a la original
  187.  
  188. system("pause");
  189. return 0;
  190. }
  191.  
  192. //
  193.  

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

hasta luego


« Última modificación: 2 Marzo 2013, 10:11 am por 85 » En línea

Me cerraron el Windows Live Spaces, entonces me creé un WordPress XD
http://etkboyscout.wordpress.com/
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Ayuda para Parchear mIRC 6.17
Ingeniería Inversa
pandemonio 2 1,411 Último mensaje 2 Mayo 2006, 16:13 pm
por pandemonio
No puedo parchear los drivers para capturar trafico
GNU/Linux
VCore 1 2,486 Último mensaje 27 Mayo 2010, 20:31 pm
por Foxy Rider
Qué es más recomendable para interceptar comunicaciones: WiFi o Ethernet?
Hacking Wireless
Libertronic 1 2,509 Último mensaje 18 Octubre 2011, 15:19 pm
por Uxio
Parchear la IAT para interceptar GPA
Programación C/C++
85 8 2,069 Último mensaje 27 Febrero 2013, 09:05 am
por MCKSys Argentina
Interceptar paquetes en red WEP/WPA para determinar IP externo.
Hacking Wireless
w1r3d 7 3,597 Último mensaje 20 Junio 2013, 09:12 am
por Sh4k4
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines