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


 


Tema destacado: Arreglado, de nuevo, el registro del warzone (wargame) de EHN


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

Desconectado Desconectado

Mensajes: 206



Ver Perfil WWW
Interceptar con Detours el Opengl nativo por TEB
« en: 9 Abril 2013, 20:50 »

Primero que nada quiero decir que voy a postear el código fuente público de un hack de karman, llamado Inexinferis FX de finales del 2010.
Es un código ya publicado sólo que no se observa demasiado por internet XD

Lo posteo porque es parte de los métodos que se estaban comentando en el foro últimamente, y se trata de utilizar 'detours' pero a un nivel más profundo que el que ofrece Openg32.dll, siendo Opengl32.dll el nivel más alto y el driver de la tarjeta gráfica lo más bajo. Intermediamente se tiene otra DLL de relacionada con Opengl32 pero perteneciente a la firma de la tarjeta gráfica, pero el tema es que hay muchas marcas de tarjetas gráficas y por lo tanto muchos drivers. Por lo que cada uno sabe lo que tiene XD

Esta es la información que se necesita manejar para poder entender como se determinan las direcciones de bajo nivel para Opengl por medio de lo que se llama TEB (Thread Environment Block), también conocido como TIB (Thread Information Block) por algunos, aunque otros insisten en que el TIB es miembro del TEB (Ver link de undocumented.ntinternals.net).
http://es.wikipedia.org/wiki/Win32_Thread_Information_Block
http://en.wikipedia.org/wiki/Win32_Thread_Information_Block
http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/NT%20Objects/Thread/TEB.html

Otros links
http://www.snoxd.net/index.php/topic/377-finding-the-thread-id-from-the-executable-name/
http://www.alex-ionescu.com/part1.pdf
http://www.ciphermonk.net/teb.php
http://nasutechtips.blogspot.com.ar/2011/01/thread-information-block-tib-and-fs.html
http://skypher.com/wiki/index.php/Hacking/Windows_internals/Process/Memory/TEB
http://stackoverflow.com/questions/9964236/tib-access-in-win32
http://software.intel.com/sites/products/documentation/doclib/stdxe/2013composerxe/compiler/cpp-win/GUID-F90BD123-AE25-4DC2-ADFB-B59067E77728.htm

Otros links que se pueden tomar en cuenta
http://www.nynaeve.net/?p=180
http://msdn.microsoft.com/es-ar/library/6yh4a9k1.aspx
http://msdn.microsoft.com/en-us/library/6yh4a9k1.aspx
http://msdn.microsoft.com/es-ar/library/y6h8hye8.aspx
http://msdn.microsoft.com/es-ar/library/2s9wt68x.aspx


En Opengl32.DLL básicamente se encuentran funciones que sólo hacen saltos hacia el nivel más bajo de Opengl, y para obtener las direcciones correctas del driver, se hace con este método del TEB.

Este es el ejemplo de glBegin

Citar
Pos: FS:[0x18]      Len: 4   Ver: Win9x y NT   -> Dirección lineal del TIB

con esos parámetros se consigue hacer un salto hacia el nivel bajo del que hablábamos (nvoglnt.dll en mi caso que tengo una tarjeta NVIDIA)


Luego hace otro salto hacia la función en sí.
Con OllyDBG se puede observar el estado de los registros para tener una mejor idea de como se obtienen las direcciones.
Mejor aún, para aquellos que prefieren leer una buena explicación les dejo este manual al respecto:
http://www.mediafire.com/?kmru385gmmcik46

Código
  1. //
  2.  
  3. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  4.  
  5. #pragma comment(lib,"OpenGL32.lib")
  6. #pragma comment(lib, "Version.lib")
  7. #define _WIN32_WINNT 0x0500
  8. #undef UNICODE
  9. #include <windows.h>
  10. #include <gl/gl.h>
  11. #include <gl/glu.h>
  12. #include <shlwapi.h>
  13. #include <stdio.h>
  14.  
  15. #include "nt.h"
  16.  
  17. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  18.  
  19. HANDLE hThread=NULL;
  20. PBYTE dwFSBase,dwFSBase2;
  21.  
  22. HWND hdHalfLife;
  23.  
  24. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  25.  
  26. typedef void (APIENTRY* glBlendFunc_t)(GLenum,GLenum);
  27. typedef void (APIENTRY* glClear_t)(GLbitfield);
  28. typedef void (APIENTRY* glVertex2f_t)(GLfloat,GLfloat);
  29. typedef void (APIENTRY* glVertex3f_t)(GLfloat,GLfloat,GLfloat);
  30. typedef void (APIENTRY* glVertex3fv_t)(const GLfloat*);
  31. typedef void (APIENTRY* glBegin_t)(GLenum);
  32. glBlendFunc_t pglBlendFunc=0;
  33. glClear_t pglClear=0;
  34. glVertex2f_t pglVertex2f=0;
  35. glVertex3f_t pglVertex3f=0;
  36. glVertex3fv_t pglVertex3fv=0;
  37. glBegin_t pglBegin=0;
  38.  
  39. BOOL bFlash=FALSE;
  40. BOOL bSky=FALSE;
  41.  
  42. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  43.  
  44. void APIENTRY New_glBegin(GLenum mode){
  45.  
  46. if(mode==GL_TRIANGLE_STRIP||mode==GL_TRIANGLE_FAN)
  47. glDisable(GL_DEPTH_TEST);
  48. else if(mode!=GL_QUADS&&mode!=GL_LINES)
  49. glEnable(GL_DEPTH_TEST);
  50.  
  51. if(mode==GL_QUADS){
  52. float col[4];
  53.        glGetFloatv(GL_CURRENT_COLOR, col);
  54.        bFlash=(col[0]==1.0&&col[1]==1.0&&col[2]==1.0&&col[3]>0.2);
  55. bSky=TRUE;
  56.    }
  57. else
  58. bSky=FALSE;
  59. pglBegin(mode);
  60. }
  61.  
  62. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  63.  
  64. void APIENTRY New_glClear(GLbitfield mask){
  65.  
  66. if(mask==GL_DEPTH_BUFFER_BIT){
  67. mask+=GL_COLOR_BUFFER_BIT;
  68. glClearColor(0.0f,0.0f,0.0f,0.0f);
  69. }
  70. pglClear(mask);
  71. }
  72.  
  73. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  74.  
  75. void APIENTRY New_glVertex3fv(const GLfloat* v){
  76.  
  77. if(bSky) return;
  78. pglVertex3fv(v);
  79. }
  80.  
  81. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  82.  
  83. void APIENTRY New_glVertex2f(GLfloat x, GLfloat y){
  84.  
  85. if(bFlash&&x==0.0&&y==0.0) glColor4f(1.0f,1.0f,1.0f,0.2f);
  86.    pglVertex2f(x,y);
  87. }
  88.  
  89. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  90.  
  91. void APIENTRY New_glVertex3f(GLfloat x, GLfloat y, GLfloat z){
  92.  
  93. glColor3f(1.0f,1.0f,1.0f);
  94. pglVertex3f(x,y,z);
  95. }
  96.  
  97. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  98.  
  99. BOOL GetDllVersion(HMODULE hLibModule, DLLVERSIONINFO* aVersion){
  100.  
  101.    CHAR fileName[MAX_PATH];
  102.    UINT len=0;
  103.    VS_FIXEDFILEINFO* vsfi=NULL;
  104.    DWORD handle=0;
  105.    DWORD size=GetModuleFileName(hLibModule,fileName,MAX_PATH);
  106.    fileName[size]=0;
  107.    size=GetFileVersionInfoSize(fileName, &handle);
  108.    BYTE* versionInfo=new BYTE[size];
  109.    if(!GetFileVersionInfo(fileName,handle,size,versionInfo)){
  110. delete[] versionInfo;
  111.        return FALSE;
  112.    }
  113.    VerQueryValue(versionInfo,"\\",(PVOID*)&vsfi,&len);
  114.    aVersion->dwMajorVersion=HIWORD(vsfi->dwFileVersionMS);
  115.    aVersion->dwMinorVersion=LOWORD(vsfi->dwFileVersionMS);
  116.    aVersion->dwBuildNumber=HIWORD(vsfi->dwFileVersionLS);
  117.    aVersion->dwPlatformID=LOWORD(vsfi->dwFileVersionLS);
  118.    delete[] versionInfo;
  119.    return TRUE;
  120. }
  121.  
  122. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  123.  
  124. void* Detour1(BYTE* src, const BYTE* dst, const int len){
  125. BYTE* jmp = (BYTE*)malloc(len+5);
  126. DWORD dwback;
  127. while(!VirtualProtect(src, len, PAGE_READWRITE, &dwback));
  128. memcpy(jmp, src, len);jmp+=len;
  129. jmp[0] = 0xE9;
  130. *(DWORD*)(jmp+1)=(DWORD)(src+len-jmp)-5;
  131. src[0] = 0xE9;
  132. *(DWORD*)(src+1)=(DWORD)(dst-src)-5;
  133. while(!VirtualProtect(src, len, dwback, &dwback));
  134. return (jmp-len);
  135. }
  136.  
  137. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  138.  
  139. /*
  140. DWORD GetProcessThreadId(unsigned long ProcessId)
  141. {
  142.     HANDLE hSnapThread = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, ProcessId);
  143.     if(hSnapThread == INVALID_HANDLE_VALUE) return NULL;
  144.     THREADENTRY32 te;
  145.     te.dwSize = sizeof(THREADENTRY32);
  146.     if(Thread32First(hSnapThread, &te))
  147.     {
  148.        do
  149.        {
  150.             if(te.th32OwnerProcessID == ProcessId) {
  151.                 CloseHandle(hSnapThread);
  152.                 return te.th32ThreadID;
  153.             }
  154.  
  155.        } while(Thread32Next(hSnapThread, &te));
  156.     }
  157.     CloseHandle(hSnapThread);
  158.     return 0;
  159. }*/
  160.  
  161. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  162.  
  163. DWORD WINAPI Thread(LPVOID lpParam){
  164.  
  165.    DWORD dwThreadId,dwProcessId,dwOGLOffset;
  166.    CONTEXT Context;
  167.    LDT_ENTRY SelEntry;
  168.    HMODULE hModule;
  169.    Context.ContextFlags=CONTEXT_FULL|CONTEXT_DEBUG_REGISTERS;
  170.    DWORD dwTLSIndex=0;
  171.    DLLVERSIONINFO oglVersion;
  172.  
  173.    while(((hdHalfLife=FindWindow("Valve001",NULL))==NULL)
  174.              &&((hdHalfLife=FindWindow(NULL,"Counter-Strike"))==NULL))
  175.                      Sleep(100);
  176.  
  177.    while((hModule=GetModuleHandle("Opengl32.dll"))==NULL)
  178.              Sleep(100);
  179.  
  180.    if(GetDllVersion(hModule,&oglVersion)){
  181.  
  182.        if(oglVersion.dwMajorVersion==5&&oglVersion.dwMinorVersion==1){
  183.            dwTLSIndex=0xAC80C;
  184. }
  185. else if(oglVersion.dwMajorVersion==6&&oglVersion.dwMinorVersion==0){
  186.            dwTLSIndex=0xAB958;
  187. }
  188. else if(oglVersion.dwMajorVersion==6&&oglVersion.dwMinorVersion==1){
  189.            dwTLSIndex=0xA100C;
  190. }
  191.        else
  192.        {
  193.             //MessageBox(hdHalfLife,"Incompatible OpenGL Version...\n\nSorry man...","Inexinferis FX Series - Karman",0);
  194.            ExitThread(0);
  195.            return 0;
  196.        }
  197.    }
  198.    else
  199.    {
  200.        //MessageBox(hdHalfLife,"Can't Get OpenGL Version...\n\nWrong OpenGL???","Inexinferis FX Series - Karman",0);
  201. ExitThread(0);
  202.        return 0;
  203.    }
  204.  
  205.    //DWORD ProcessId = GetCurrentProcessId();
  206.    //DWORD ProcessThreadId = GetProcessThreadId(ProcessId);
  207.    dwThreadId=GetWindowThreadProcessId(hdHalfLife,&dwProcessId);
  208.    HANDLE hThread=OpenThread(THREAD_GET_CONTEXT|THREAD_SUSPEND_RESUME|THREAD_QUERY_INFORMATION,FALSE,dwThreadId);
  209.  
  210.    if(!hThread){
  211.        //MessageBox(hdHalfLife,"Couldn't Get Proccess Info...\n\nAntivirus???","Inexinferis FX Series - Karman",0);
  212.        CloseHandle(hThread);
  213.        ExitThread(0);
  214.        return 0;
  215.    }
  216.  
  217.    GetThreadContext(hThread,&Context);
  218.    GetThreadSelectorEntry(hThread, Context.SegFs, &SelEntry);
  219.    dwFSBase = (PBYTE)((SelEntry.HighWord.Bits.BaseHi<<24)|(SelEntry.HighWord.Bits.BaseMid<<16)|SelEntry.BaseLow);
  220.  
  221.    if(!dwFSBase||IsBadReadPtr((PVOID)dwFSBase,sizeof(DWORD))){
  222.        //MessageBox(hdHalfLife,"Couldn't Get TEB From Opengl32.dll\n\nMake Sure that you are Running the Game in OpenGl Mode...","Inexinferis FX Series - Karman",0);
  223.        CloseHandle(hThread);
  224.        ExitThread(0);
  225.        return 0;
  226.    }
  227.  
  228.    dwOGLOffset=((DWORD)hModule)+dwTLSIndex;
  229.    if(!dwTLSIndex||IsBadReadPtr((PVOID)dwOGLOffset,sizeof(DWORD))){
  230.        //MessageBox(hdHalfLife,"Couldn't Read From Opengl32.dll Address\n\nMaybe your OpenGL driver is not compatible...","Inexinferis FX Series - Karman",0);
  231.       CloseHandle(hThread);
  232.       ExitThread(0);
  233.       return 0;
  234.    }
  235.    //multiple redirect...
  236.    do{
  237.           Sleep(10);
  238.           dwFSBase2=(PBYTE)(*(PDWORD)((DWORD)dwFSBase+(*(PDWORD)dwOGLOffset)));
  239.    }while(dwFSBase2==NULL);
  240.  
  241. /*
  242.    dwFSBase2=(PBYTE)(*(PDWORD)((DWORD)dwFSBase+(*(PDWORD)0x5F1CC80C)));
  243.    if(!dwFSBase2){
  244.        CloseHandle(hThread);
  245.        ExitThread(0);
  246.        return 0;
  247.    }*/
  248.  
  249.  
  250.  
  251.  
  252.   //MessageBox(hdHalfLife,"http://www.inexinferis.com.ar/foro","Inexinferis FX Series - Karman",0);
  253.   SuspendThread(hThread);
  254.  
  255.   ////////
  256.   // Hooks
  257.  
  258.   // 0x01D46862  opengl32.glClear [EAX+32C] -> 0x69609A20 [12]
  259.   pglClear= (glClear_t)Detour1((PBYTE)(*(PDWORD)(dwFSBase2+0x32C)),(PBYTE)New_glClear,12);
  260.  
  261.   // 0x01D3CF1D  opengl32.glVertex2f [EAX+92C] -> 0x69606320 [12]
  262.   pglVertex2f= (glVertex2f_t)Detour1((PBYTE)(*(PDWORD)(dwFSBase+0x92C)),(PBYTE)New_glVertex2f,12);
  263.  
  264.   pglVertex3f= (glVertex3f_t)Detour1((PBYTE)(*(PDWORD)(dwFSBase+0x94C)),(PBYTE)New_glVertex3f,12);
  265.  
  266.   // 0x01D936C5 opengl32.glVertex3fv [EAX+950] -> 0x696073F0 [12]
  267.   pglVertex3fv= (glVertex3fv_t)Detour1((PBYTE)(*(PDWORD)(dwFSBase+0x950)),(PBYTE)New_glVertex3fv,12);
  268.  
  269.   // 0x01D93681 opengl32.glBegin [EAX+7CC] -> 0x695FD250 [8]
  270.   pglBegin= (glBegin_t)Detour1((PBYTE)(*(PDWORD)(dwFSBase+0x7CC)),(PBYTE)New_glBegin, 8);
  271.  
  272.    ////////
  273.  
  274.    ResumeThread(hThread);
  275.    CloseHandle(hThread);
  276.  
  277.    ExitThread(0);
  278.    return 0;
  279. }
  280.  
  281. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  282.  
  283. BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD fdwReason, LPVOID lpvReserved){
  284.  
  285. if(fdwReason==DLL_PROCESS_ATTACH){
  286.  
  287. DisableThreadLibraryCalls(hInstance);
  288. hThread=CreateThread(NULL,0,Thread,NULL,0,NULL);
  289. }
  290. return (TRUE);
  291. }
  292.  
  293. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  294.  
  295.  

PROYECTO MS Visual C++ 2010 Express
http://www.mediafire.com/?yttdt8712ymvj2r


« Última modificación: 25 Abril 2013, 08:19 por 85 » En línea

Me cerraron el Windows Live Spaces, entonces me creé un WordPress XD
http://etkboyscout.wordpress.com/
BloodSharp


Desconectado Desconectado

Mensajes: 540


Crianosfera 5 in comming!!!


Ver Perfil
Re: Interceptar con Detours el Opengl nativo por TIB
« Respuesta #1 en: 9 Abril 2013, 22:23 »

Esta es la versión última que era para Codeblocks+Mingw...

http://rapidshare.com/files/3440411547/inexinferisfx.rar


B#


En línea



85

Desconectado Desconectado

Mensajes: 206



Ver Perfil WWW
Re: Interceptar con Detours el Opengl nativo por TIB
« Respuesta #2 en: 10 Abril 2013, 02:47 »

Dejo un par de links más
http://www.codeproject.com/Articles/29174/Win32-TIB
http://www.microsoft.com/msj/archive/s2ce.aspx

http://www.gamedeception.net/threads/8866-TIB-Opengl-hooking
Y esto lo saqué de gamedeception (2ci- y Organner), es otro intento.. aunque sino no da los resultados que se esperan, mejor obtener un puntero al selector FS del hilo creador de la ventana, y después hacer [eax+OFFSET] tal como en Opengl32.dll. No hay TIB específico para Opengl32, sino más bien es el TIB del hilo en el que se llama a Opengl32.

Código
  1. typedef void(__stdcall* t_glBegin)(GLenum);
  2. t_glBegin pOrig_glBegin = NULL;
  3.  
  4. /////////////////////////////////////////////////////////////////////////////////////////////////
  5.  
  6. void __stdcall HOOK_glBegin(GLenum mode)
  7. {
  8. static bool once=false;
  9. if(!once){
  10.  
  11. printf("\n");
  12. printf("DLL -> HOOK_glBegin!\n");
  13. system("pause");
  14. once=true;
  15. }
  16.  
  17. (*pOrig_glBegin)(mode);
  18. }
  19.  
  20. /////////////////////////////////////////////////////////////////////////////////////////////////
  21.  
  22. DWORD* OGL_GetFuncForOffset( DWORD dwTIBOffset )
  23. {
  24. DWORD* retval=0;
  25. __asm {
  26. mov eax, fs:[0x18]; // TIB
  27. add eax, dwTIBOffset;
  28. mov eax, [eax]
  29. mov retval, eax
  30. }
  31. return retval;
  32. }
  33.  
  34. /////////////////////////////////////////////////////////////////////////////////////////////////
  35.  
  36. bool OGL_IsOffsetHooked( DWORD dwTIBOffset, DWORD* dwOriginal, DWORD* dwHook )
  37. {
  38. return( OGL_GetFuncForOffset( dwTIBOffset ) == dwHook );
  39. }
  40.  
  41. /////////////////////////////////////////////////////////////////////////////////////////////////
  42.  
  43. void OGL_HookTIB( DWORD dwTIBOffset, DWORD* dwOriginal, DWORD* dwHook )
  44. {
  45. if( OGL_IsOffsetHooked( dwTIBOffset, dwOriginal, dwHook ) ){
  46. return;
  47. }
  48.  
  49. __asm {
  50. mov eax, dword ptr fs:[0x18]; // TIB
  51. add eax, dwTIBOffset; // add offset needed
  52. mov ecx, [eax] // get the function offset
  53. mov ebx, [dwOriginal] // grab addr of original
  54. mov [ebx], ecx; // move it into our pointer
  55. mov ecx, dwHook; // move offset of our hook into ecx
  56. mov [eax], ecx; // move ecx into opengl's info space
  57. }
  58. }
  59.  
  60. /////////////////////////////////////////////////////////////////////////////////////////////////
  61.  
  62. #define ofs_glBegin     0x7CC
  63. #define ofs_glVertext3f 0x94C
  64. #define ofs_glPopMatrix 0x9E4
  65.  
  66. /////////////////////////////////////////////////////////////////////////////////////////////////
  67.  
  68. DWORD dwReplaceDriverAddress(DWORD dwIndex, DWORD dwNewFunction)
  69. {
  70.    DWORD* dwTIB = NULL;
  71. DWORD teb=0;
  72. PTEB myTEB;
  73.  
  74.       __asm
  75.       {
  76.            mov eax, dword ptr fs:[18h]
  77.            add eax, dwIndex
  78.            mov dwTIB, eax
  79.            mov myTEB,eax
  80.       }
  81.  
  82. printf("myTEB 0x%X\n",myTEB);
  83. printf("dwIndex 0x%X\n",dwIndex);
  84. printf("dwTIB 0x%X\n",dwTIB);
  85. printf("*dwTIB 0x%X\n",*dwTIB);
  86. printf("dwNewFunction 0x%X\n",dwNewFunction);
  87. system("pause");
  88.  
  89.        DWORD g_dwReturnValue = *dwTIB;
  90.        //*dwTIB = dwNewFunction;
  91.        //printf("*dwTIB 0x%X\n",*dwTIB);
  92.        return g_dwReturnValue;
  93. }
  94.  
  95. /////////////////////////////////////////////////////////////////////////////////////////////////
  96.  
  97. void thread(){
  98.  
  99. while(1){
  100.  
  101. if(GetModuleHandle("opengl32.dll")){
  102.  
  103. pOrig_glBegin = (t_glBegin)dwReplaceDriverAddress(ofs_glBegin,(DWORD)HOOK_glBegin);
  104.  
  105. if(pOrig_glBegin){
  106.  
  107.    printf("pOrig_glBegin 0x%X\n",pOrig_glBegin);
  108.    system("pause");
  109. }
  110. break;
  111. }
  112.  
  113. Sleep(300);
  114. }
  115. }
  116.  
  117. /////////////////////////////////////////////////////////////////////////////////////////////////
  118.  
  119. BOOL APIENTRY DllMain(HINSTANCE i, DWORD reason, LPVOID res){
  120.  
  121. if(reason == DLL_PROCESS_ATTACH){
  122.  
  123. if(GetModuleHandle("opengl32.dll")){
  124.  
  125. pOrig_glBegin = (t_glBegin)dwReplaceDriverAddress(ofs_glBegin,(DWORD)HOOK_glBegin);
  126.  
  127. if(pOrig_glBegin){
  128.    printf("pOrig_glBegin 0x%X\n",pOrig_glBegin);
  129.    system("pause");
  130. }
  131. }
  132.  
  133. //CreateThread(0,0,(unsigned long (__stdcall *)(void *))thread,0,0,0);
  134. }
  135. return (true);
  136. }
  137.  

PS: Ese código la sarpa, parece un multihack XD.. y tiene la librería de karman IntelliAPIHooking, nice  >:D
« Última modificación: 10 Abril 2013, 03:00 por 85 » En línea

Me cerraron el Windows Live Spaces, entonces me creé un WordPress XD
http://etkboyscout.wordpress.com/
Luchoz95

Desconectado Desconectado

Mensajes: 58


Ver Perfil
Re: Interceptar con Detours el Opengl nativo por TEB
« Respuesta #3 en: 11 Abril 2013, 00:23 »

Esta buenisimoooo mira lo que pude haceer ..
En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Ayuda Compilacion de java a nativo con gcj
Java
egyware 2 4,148 Último mensaje 20 Junio 2007, 21:14
por egyware
Backdoor nativo en SMF 2.0 « 1 2 3 4 »
Nivel Web
WHK 30 25,482 Último mensaje 8 Noviembre 2009, 23:03
por Skeletron
hook a recv sin ms detours?
Programación C/C++
while 2 2,245 Último mensaje 6 Octubre 2010, 23:25
por while
Interceptar Opengl32 con Detours y obtener un WH
Programación C/C++
85 4 1,296 Último mensaje 10 Abril 2013, 04:48
por 85
[Librería C++] Detours, Codecaves, Return Adress Spoofing y mucho más
Ingeniería Inversa
blipi 1 1,430 Último mensaje 7 Febrero 2014, 00:33
por blipi
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines