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

 

 


Tema destacado: ¿Eres nuevo? ¿Tienes dudas acerca del funcionamiento de la comunidad? Lee las Reglas Generales


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

Desconectado Desconectado

Mensajes: 206



Ver Perfil WWW
glTest 1: Interceptar Opengl32 con GPA
« en: 7 Marzo 2013, 02:41 am »

NIVEL: Beginner
Test: WinXP SP3

Esto es una demostración de como puede aplicarse un IAT hook para interceptar funciones en un proceso. En este caso , se trata de un ejecutable que utiliza funciones de Opengl32 para crear una ventana y representar una imagen.



Para hacer uso de las funciones Opengl32 desde un ejecutable .EXE como en este caso, se puede hacer mediante vinculación dinámica (con DLL) o vinculación estática (con LIB).

Antes dejo unos enlaces donde consultar información:
http://msdn.microsoft.com/es-ar/library/253b8k2c.aspx
http://msdn.microsoft.com/es-es/library/1ez7dh12(v=vs.80).aspx
http://msdn.microsoft.com/es-ar/library/9se914de.aspx
http://msdn.microsoft.com/en-us/library/windows/desktop/ms681914(v=vs.85).aspx
http://msdn.microsoft.com/es-es/library/ms235636(v=vs.80).aspx
http://msdn.microsoft.com/es-es/library/9yd93633(v=vs.80).aspx
http://msdn.microsoft.com/en-us/library/windows/desktop/ms681938(v=vs.85).aspx
http://msdn.microsoft.com/es-es/library/ms235627(v=vs.90).aspx
http://msdn.microsoft.com/es-es/library/ms235627(v=vs.80).aspx
http://social.msdn.microsoft.com/Forums/en/vcgeneral/thread/bed8a074-afe0-46a8-bdc5-5e4244ca55a6
http://msdn.microsoft.com/en-us/library/ms235627(v=vs.80).aspx
http://msdn.microsoft.com/es-es/library/abx4dbyh.aspx
http://msdn.microsoft.com/en-us/library/abx4dbyh(v=vs.80).aspx

Para construir este ejecutable de ejemplo, usé un código de ejemplo que ofrece el sitio oficial de Opengl..
http://www.opengl.org/archives/resources/code/samples/glut_examples/advanced/textrim.c
http://www.opengl.org/resources/libraries/glut/
http://www.opengl.org/archives/resources/code/samples/simple/
http://www.opengl.org/archives/resources/code/samples/glut_examples/examples/examples.html
http://www.opengl.org/archives/resources/code/samples/glut_examples/contrib/contrib.html

El programa de ejemplo original usa la vinculación estática, pero para poder realizar esta demostración tuvo que ser modificado XD.

Las modificaciones se dan para las llamadas a 3 funciones de Opengl32 que fueron elegidas para poder realizar la demostración.

las funciones son: glBegin, glBlendFunc y glViewport
Para saber acerca de estas funciones van a tener que recurrir a un manual de Opengl32, o busquen en el sitio oficial.

A estas 3 funciones se las desea interceptar para lograr cambiar el comportamiento del programa, la idea es cambiar lo que el programa muestra por pantalla.

Lo que se hace en el ejecutable es arreglar las llamadas a estas 3 funciones, que normalmente son llamadas por vinculación estática. En cambio ahora fueron modificadas para que la vinculación sea dinámica. Por eso se declararon punteros a función y se resuelven las direcciones correspondientes a las funciones dentro de Opengl32.DLL , en tiempo de ejecución. Esto se hace usando GetProcAddress.

Ahora que sabemos que el ejecutable de la demostración, hace uso de GetProcAddress para conseguir las direcciones de estas 3 funciones mencionadas, vamos a interceptar GetProcAddress para que devuelva otras direcciones. Digamos, las direcciones de nuestras funciones de reemplazo.

Esas funciones de reemplazo, o HOOKs, van a estar dentro de una DLL aparte que va a ser cargada al proceso. Una vez cargada en el proceso va a parchear la IAT en la entrada de GetProcAddress, de esa forma GetProcAddress queda interceptada.

Veamos el código del EXE:
Los includes necesarios, y las librerías estáticas requeridas para que compile.
Código
  1. #pragma comment (lib, "opengl32.lib")
  2. #pragma comment (lib, "GLUT32/glut32.lib")
  3. #include <windows.h>
  4. #include <math.h>
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  8. #include <time.h>
  9.  
  10. #include "GLUT32/glut.h"
  11. #include <gl\gl.h>
  12. #include <gl\glu.h>
  13.  
  14. #include "texture.h"
  15.  

Los punteros a función para las 3 funciones que vamos a interceptar.
Código
  1. // Opengl32 es APIENTRY
  2. typedef void(__stdcall* t_glBegin)(GLenum);
  3. typedef void(__stdcall* t_glBlendFunc)(GLenum, GLenum);
  4. typedef void(__stdcall* t_glViewport)(GLint,GLint,GLsizei,GLsizei);
  5.  
  6. // Declaramos unos punteros que van a contener la dirección de las funciones OGL32 que usemos.
  7. t_glBegin pOrig_glBegin = NULL;
  8. t_glBlendFunc pOrig_glBlendFunc = NULL;
  9. t_glViewport pOrig_glViewport = NULL;
  10.  

Punto de entrada. Como podemos ver, la DLL se carga con un simple LoadLibrary. No hacemos inyección de DLL o cualquier otra forma de cargar una DLL. "glhack1.dll" es la DLL la cual se encarga del patch a la IAT y contiene los hooks de GPA y Opengl32.
Código
  1. int main(int argc, char **argv)
  2. {
  3.   SetConsoleTitle("glTest");
  4.  
  5.   int opc=0;
  6.   while( 1){
  7.  
  8. 		system("cls");
  9. 		printf("Bienvenido!\n");
  10. 		printf("1: Interceptar OPENGL32\n");
  11. 		printf("2: NO Interceptar OPENGL32\n");
  12. 		printf("3: Salir\n");
  13. 		scanf("%d",&opc);
  14.  
  15. 		if(opc == 1||opc == 2||opc == 3) break;
  16.   }
  17.  
  18.   if(opc==3) ExitProcess(45);
  19.  
  20.   if(opc==1) //Al cargar la DLL, esta instala el hook a GPA para poder interceptar OGL32
  21.   {
  22. 	  if(!LoadLibrary("glhack1.dll")){
  23.  
  24. 		  MessageBox(0,0,0,0);
  25. 		  ExitProcess(0);
  26. 	  }
  27.   }
  28.  
  29.   printf("\n");
  30.   printf("EXE: GPA 0x%X\n", GetProcAddress);
  31.   printf("EXE: glBegin 0x%X\n", glBegin);
  32.   if(GetModuleHandle("opengl32.dll"))
  33.   {
  34. 	  pOrig_glBegin = (t_glBegin)GetProcAddress(GetModuleHandle("opengl32.dll"), "glBegin");
  35. 	  pOrig_glBlendFunc = (t_glBlendFunc)GetProcAddress(GetModuleHandle("opengl32.dll"), "glBlendFunc");
  36. 	  pOrig_glViewport = (t_glViewport)GetProcAddress(GetModuleHandle("opengl32.dll"), "glViewport");
  37. 	  printf("EXE: glBegin 0x%X\n", pOrig_glBegin);
  38. 	  printf("EXE: glBlendFunc 0x%X\n", pOrig_glBlendFunc);
  39. 	  printf("EXE: glViewport 0x%X\n", pOrig_glViewport);
  40.   }
  41.   else
  42.   {
  43. 	  MessageBox(0,0,0,0);
  44. 	  ExitProcess(0);
  45. 	  return 0;
  46.   }
  47.  
  48.   glutInit(&argc, argv);
  49.   glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
  50.   glutInitWindowSize(450, 450);
  51.   glutCreateWindow("glTest");
  52.   // glutFullScreen();
  53.   init(argv[1]);
  54.   glutDisplayFunc(display);
  55.   glutKeyboardFunc(key);
  56.   glutReshapeFunc(reshape);
  57.   glutIdleFunc(tick);
  58.   glutMainLoop();
  59.   return 0;             /* ANSI C requires main to return int. */
  60. }
  61.  
  62. //
  63.  

Estas funciones son originales del código que conseguí en opengl.org
Los cambios que se ven son que las llamadas a función originales para las 3 funciones elegidas,
fueron cambiadas por los punteros a función que creamos.
Código
  1. void bfunc(void)
  2. {
  3.   static int state;
  4.   if (state ^= 1) 
  5.   {
  6.     pOrig_glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  7.     glEnable(GL_BLEND);
  8.   } else {
  9.     glDisable(GL_BLEND);
  10.   }
  11. }
  12.  

Código
  1. void bfunc(void)
  2. {
  3.   static int state;
  4.   if (state ^= 1) 
  5.   {
  6.     pOrig_glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  7.     glEnable(GL_BLEND);
  8.   } else {
  9.     glDisable(GL_BLEND);
  10.   }
  11. }
  12.  

Código
  1. void display(void)
  2. {
  3.   glClear(GL_COLOR_BUFFER_BIT);
  4.   glPushMatrix();
  5.   glTranslatef(transx, transy, 0.f);
  6.   glRotatef(rotx, 0., 1., 0.);
  7.   glRotatef(roty, 1., 0., 0.);
  8.   glScalef(scale, scale, 0.);
  9.   pOrig_glBegin(GL_POLYGON);
  10.   glTexCoord2f(0.0, 0.0);
  11.   glVertex2f(-1.0, -1.0);
  12.   glTexCoord2f(1.0, 0.0);
  13.   glVertex2f(1.0, -1.0);
  14.   glTexCoord2f(1.0, 1.0);
  15.   glVertex2f(1.0, 1.0);
  16.   glTexCoord2f(0.0, 1.0);
  17.   glVertex2f(-1.0, 1.0);
  18.   glEnd();
  19.   glPopMatrix();
  20.   glutSwapBuffers();
  21. }
  22.  


Código
  1. void reshape(int w, int h)
  2. {
  3.   pOrig_glViewport(-50, -50, w+120, h+120);
  4. }
  5.  

La DLL hace un patch a la IAT del EXE, el tema es que esta función la traje de un conocido creador de hacks que se llama h1web.
http://50hz.ws/devel/iathook.c.txt

El tema es que tuve que modificar la función para que funcione correctamente. Los cambios fueron en el 4to parámetro y dentro de la función. El problema era que estas estructuras que recorre, contienen cadenas sin terminación en 0, por lo que STRCMP no encontraba en nombre de GetProcAddress.
Código
  1. BOOL HookIAT(char* szModule, char* szFunc, DWORD dwOwn, DWORD& dwOrg)
  2. {
  3.     DWORD dwBase = (DWORD)GetModuleHandle(NULL);
  4.     PIMAGE_DOS_HEADER pDosHdr = (PIMAGE_DOS_HEADER)dwBase;
  5.     PIMAGE_NT_HEADERS pNTHdr = (PIMAGE_NT_HEADERS)(dwBase + pDosHdr->e_lfanew);
  6.     DWORD ImportData = (DWORD)pNTHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
  7.     PIMAGE_IMPORT_DESCRIPTOR pImportD = (PIMAGE_IMPORT_DESCRIPTOR)(dwBase + ImportData);
  8.     while(pImportD->Name != 0)
  9.     {
  10. 		// CUIDADO! En estas estructuras se encuentran strings no terminadas en 0
  11. 		// por lo que STRCMP no sirve.
  12. 		// Un cambio fácil puede ser usar STRSTR que encuentra una cadena dentro de otra.
  13. 		//	if(!strcmp((char*)(dwBase + pImportD->Name), szModule))
  14.         if(!strstr((char*)(dwBase + pImportD->Name), szModule))
  15.             break;
  16.         pImportD++;
  17.     }
  18.  
  19. 	//printf("pImportD->Name: %s\n",(char*)(dwBase + pImportD->Name));
  20. 	//system("pause");
  21.     if(pImportD->Name == 0) return FALSE;
  22. 	//printf("pImportD->Name: 0x%X\n",pImportD->Name);
  23. 	//system("pause");
  24.  
  25.     PIMAGE_THUNK_DATA pThunk = (PIMAGE_THUNK_DATA)(dwBase + pImportD->FirstThunk);
  26.     DWORD OrgFunc = (DWORD)GetProcAddress(GetModuleHandle(szModule), szFunc);
  27.     while(pThunk->u1.Function != 0)
  28.     {
  29.         if(pThunk->u1.Function == (DWORD*)OrgFunc)
  30.         {
  31.             dwOrg = OrgFunc;
  32.             DWORD dwOldProt = 0;
  33.             VirtualProtect((void*)&pThunk->u1.Function, 4, PAGE_EXECUTE_READWRITE, &dwOldProt);
  34.             pThunk->u1.Function = (DWORD*)dwOwn;
  35.             VirtualProtect((void*)&pThunk->u1.Function, 4, dwOldProt, &dwOldProt);
  36.             if(pThunk->u1.Function == (DWORD*)dwOwn)
  37.                 return TRUE;
  38.             else
  39.                 return FALSE;
  40.         }
  41.         pThunk++;
  42.     }
  43.     return FALSE;
  44. }

DLL: main.cpp
Código
  1.  
  2. //
  3. // By 85
  4. // HookIAT (h1web, Thanks to Ashkbiz Danehkar)
  5. // elhacker.net
  6. // etalking.com.ar
  7. // 2013
  8. //
  9.  
  10. ///////////////////////////////////////////////////////////////////////////////////////////////////////////
  11.  
  12. #define WIN32_LEAN_AND_MEAN
  13. #include<windows.h>
  14. #include<stdio.h>
  15. #include<stdlib.h>
  16. #include"opengl.h"
  17.  
  18. ///////////////////////////////////////////////////////////////////////////////////////////////////////////
  19.  
  20. FARPROC (WINAPI* pGetProcAddress) ( HMODULE hModule, LPCSTR lpProcName );
  21.  
  22. //
  23. FARPROC WINAPI newGetProcAddress(HMODULE hModule, LPCSTR lpProcName)
  24. {
  25. 	FARPROC nResult;
  26. 	nResult=GetProcAddress(hModule, lpProcName);
  27. 	if (HIWORD(lpProcName))
  28. 	{
  29. 		if (!lstrcmp(lpProcName, "GetProcAddress"))
  30. 		{
  31. 			return (FARPROC) &newGetProcAddress;
  32. 		}
  33. 		else
  34. 		{
  35. 			CheckForOpenGlHook(&nResult, lpProcName);
  36.         }
  37. 	}
  38. 	return nResult;
  39. }
  40.  
  41. //
  42. BOOL HookIAT(char* szModule, char* szFunc, DWORD dwOwn, DWORD& dwOrg)
  43. {
  44.      // Ya mostrado
  45. }
  46.  
  47. //
  48. bool WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
  49. {
  50. 	if (fdwReason==DLL_PROCESS_ATTACH) 
  51. 	{
  52. 		//printf("GetProcAddress 0x%X\n", GetProcAddress);// No refenciar GPA antes!
  53. 		if(!HookIAT("kernel32.dll","GetProcAddress",(DWORD)newGetProcAddress,
  54. 			(DWORD&)pGetProcAddress)){
  55.  
  56. 			MessageBox(0,0,0,0);
  57. 			return (false);
  58. 		}
  59.  
  60. 		printf("\n");
  61. 		printf("DLL: newGetProcAddress 0x%X\n", newGetProcAddress);
  62. 		printf("DLL: GetProcAddress 0x%X\n", GetProcAddress);
  63. 		printf("DLL: pGetProcAddress 0x%X\n", pGetProcAddress);
  64.  
  65. 	}
  66. 	return (true);
  67. }
  68.  

Los Hooks o funciones de gancho, como quieran decirles, son estas siguientes. Vemos que dentro de las de Opengl32 se hicieron cambios para modificar el resultado del programa.
El Hook de GetProcAddress se encarga de cambiar la dirección de retorno por una de los Hooks de Opengl32, y de inicializar los punteros a función con las direcciones de las originales.

DLL: opengl32.cpp
Código
  1. //
  2. // By 85
  3. // elhacker.net
  4. // etalking.com.ar
  5. // 2013
  6. //
  7.  
  8. ///////////////////////////////////////////////////////////////////////////////////////////////////////////
  9.  
  10. #pragma comment(lib, "opengl32.lib")
  11. #include<windows.h>
  12. #include<stdio.h>
  13. #include "opengl.h"
  14.  
  15. ///////////////////////////////////////////////////////////////////////////////////////////////////////////
  16.  
  17. // Opengl32 es APIENTRY
  18. typedef void(__stdcall* t_glBegin)(GLenum);
  19. typedef void(__stdcall* t_glBlendFunc)(GLenum, GLenum);
  20. typedef void(__stdcall* t_glViewport)(GLint,GLint,GLsizei,GLsizei);
  21.  
  22. t_glBegin pOrig_glBegin = NULL;
  23. t_glBlendFunc pOrig_glBlendFunc = NULL;
  24. t_glViewport pOrig_glViewport = NULL;
  25.  
  26. bool once=false;
  27. bool oglSubtractive = false;
  28. bool NewDimension = true;
  29.  
  30. int posx = 200;
  31. int posy = 200;
  32. int neww = 50;
  33. int newh = 50;
  34.  
  35. //
  36. void __stdcall HOOK_glBegin(GLenum mode)
  37. {
  38. 	if(!once){
  39. 		once=true;
  40. 	}
  41.  
  42. 	if (mode==GL_POLYGON)
  43. 	{
  44. 	    glClearColor(1.0, 1.0, 1.0, 1.0);
  45. 	    glColor3f(0, 0, 0);
  46. 	}
  47.  
  48. 	(*pOrig_glBegin)(mode);
  49. }
  50.  
  51. void __stdcall HOOK_glBlendFunc(GLenum sfactor, GLenum dfactor)
  52. {
  53. 	if(oglSubtractive){
  54. 		glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  55.  
  56. 	} else {
  57. 		glBlendFunc(sfactor,dfactor);
  58. 	}
  59. }
  60.  
  61. void __stdcall HOOK_glViewport( GLint x,GLint y,GLsizei width,GLsizei height )
  62. {
  63. 	if(NewDimension){
  64.  
  65. 		(*pOrig_glViewport)(posx,posy,neww,newh);
  66. 	}
  67. 	else
  68. 	{
  69. 		(*pOrig_glViewport)(x,y,width,height);
  70. 	}
  71. }
  72.  
  73. void CheckForOpenGlHook(FARPROC* pProc,LPCTSTR lpProcName)
  74. {
  75. 	if (!strcmp(lpProcName,"glBegin"))
  76. 	{
  77. 		pOrig_glBegin = (t_glBegin)*pProc;
  78. 		*pProc = (FARPROC)&HOOK_glBegin;
  79. 	}
  80. 	else if(!strcmp(lpProcName,"glBlendFunc"))
  81. 	{
  82. 			pOrig_glBlendFunc = (t_glBlendFunc)*pProc;
  83. 			*pProc = (FARPROC)&HOOK_glBlendFunc;
  84. 	}
  85. 	else if(!strcmp(lpProcName,"glViewport"))
  86. 	{
  87. 			pOrig_glViewport = (t_glViewport)*pProc;
  88. 			*pProc = (FARPROC)&HOOK_glViewport;
  89. 	}
  90. }
  91.  

Espero que les haya gustado. Es un tutorial básico por lo tanto sólamente usé un parche a la IAT. Se puede experimentar con otro tipo de Hook más avanzado.

El programa ofrece la opción de interceptar Opengl32 o no:


Archivos utilizados:


Resultados:


Si me preguntan por qué hacer que usen GetProcAddress cuando no era necesario, la respuesta es que algunos juegos lo han hecho así, y servía para demostrar la utilidad de interceptar GPA.
Interceptar Opengl32 se podía haber hecho parcheando la IAT en las entradas de Opengl32 también.

Proyecto vc6:
http://www.mediafire.com/?p673twh7in70ys1
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
Interceptar API « 1 2 »
.NET (C#, VB.NET, ASP) 		Keyen Night 12 10,918 Último mensaje 22 Diciembre 2009, 21:07 pm
por raul338
Interceptar Winsocks
Programación Visual Basic 		Dunkansdk 7 3,212 Último mensaje 25 Marzo 2011, 18:46 pm
por DaasCook
Interceptar llamadas
Hacking Mobile 		interesado9 1 5,013 Último mensaje 3 Diciembre 2011, 18:01 pm
por imoen
Wrapper de Opengl32.dll de Crusader (2002)
Programación C/C++ 		85 2 2,239 Último mensaje 5 Abril 2013, 21:00 pm
por 85
Interceptar Opengl32 con Detours y obtener un WH
Programación C/C++ 		85 4 2,519 Último mensaje 10 Abril 2013, 04:48 am
por 85
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines