MS Detours 2.1 para interceptar Opengl32

[85]

http://research.microsoft.com/en-us/projects/detours/

Overview
Innovative systems research hinges on the ability to easily instrument and extend existing operating system and application functionality. With access to appropriate source code, it is often trivial to insert new instrumentation or extensions by rebuilding the OS or application. However, in today's world systems researchers seldom have access to all relevant source code.

Detours is a library for instrumenting arbitrary Win32 functions Windows-compatible processors. Detours intercepts Win32 functions by re-writing the in-memory code for target functions. The Detours package also contains utilities to attach arbitrary DLLs and data segments (called payloads) to any Win32 binary.

Detours preserves the un-instrumented target function (callable through a trampoline) as a subroutine for use by the instrumentation. Our trampoline design enables a large class of innovative extensions to existing binary software.

We have used Detours to create an automatic distributed partitioning system, to instrument and analyze the DCOM protocol stack, and to create a thunking layer for a COM-based OS API. Detours is used widely within Microsoft and within the industry.

Bueno, la intención no es contar toda la historia sino publicar un código fuente XD.

En síntesis, con esta librería se pueden interceptar funciones. Es una librería de MS que no es pública en su versión completa, pero si tiene una versión de prueba para el público.
Se usaba desde hace años para construir los hacks de distintos juegos, por ejemplo para el Counter-Strike.
En este enlace se puede encontrar una base para un hook de Opengl32 que fue muy conocida cuando salió.
http://board.cheat-project.com/showthread.php?t=9232

Algunas de estas bases se hicieron primero con Detours 1.5 y después se actualizaron a Detours 2.1. Ahora está disponible la versión pública de Detours 3.0.

Lo que hice yo, fue organizar la base publicada en ese enlace que he mostrado. originalmente no compilaba, tenía errores, faltaban archivos, y tenía mucho código que no era necesario para una simple demostración.
Por eso el código fue organizado y arreglado para que funcione, el proyecto es de una librería de vínculos dinámicos (DLL), que debe ser cargada en el juego Counter-Strike (En modo Opengl32).
Al cargarse la DLL se instalan los hooks ('detours'), y se obtiene un "Wallhack" funcionando.

El creador de esta base es un tal Xantrax, el link ya lo he mostrado.
Esto se trata de ver como se implementa esta librería.
Dejo el código completo y al final un enlace de descarga.
La descarga fue preparada especialmente, porque incluye los archivos de instalación de Detours 2.1, el .h y la librería estática .lib.
Y se incluye también el .h y la librería estática .lib correspondiente a Detours 1.5.
El tema es que estos archivos no se consiguen fácilmente porque son versiones anteriores de 'Detours'.
Otra cosa es que para obtener la librería estática .lib se tiene que compilar 'Detours' para que la produzca.

Código (cpp) [Seleccionar] Expandir



//
// Modifications: By 85
// Credits: Xantrax, MS Detours 2.1
// elhacker.net
// etalking.com.ar
// david_bs@live.com
// 2013
//

///////////////////////////////////////////////////////////////////////////////////////

#pragma comment(lib,"detours.lib")// 1.5
#pragma comment(lib,"OpenGL32.lib")
#include <windows.h>
#include <gl/gl.h>
#include<stdio.h>

#include "detours.h"

///////////////////////////////////////////////////////////////////////////////////////

bool bOGLSubtractive = false;
bool g_bSky = false;

///////////////////////////////////////////////////////////////////////////////////////

class CDraw {
public:
CDraw();
int m_iVpCounter;
bool m_bDrawing;
void DrawPanel();
};

CDraw::CDraw( ){
m_iVpCounter = 0;
m_bDrawing = false;
}

void CDraw::DrawPanel( ) {

//Drawing Every 5th here
}

CDraw* pDraw = new CDraw();

///////////////////////////////////////////////////////////////////////////////////////

/* function prototype and original target */

DETOUR_TRAMPOLINE( VOID WINAPI Trampoline_glBegin( GLenum mode ), glBegin );
DETOUR_TRAMPOLINE( VOID WINAPI Trampoline_glViewport( GLint x,  GLint y,  GLsizei width,  GLsizei height ), glViewport );
DETOUR_TRAMPOLINE( VOID WINAPI Trampoline_glVertex3fv( const GLfloat *v ), glVertex3fv  );
DETOUR_TRAMPOLINE( VOID WINAPI Trampoline_glVertex3f( GLfloat x, GLfloat y, GLfloat z ), glVertex3f );
DETOUR_TRAMPOLINE( VOID WINAPI Trampoline_glShadeModel( GLenum mode ), glShadeModel );
DETOUR_TRAMPOLINE( VOID WINAPI Trampoline_glClear( GLbitfield mask ), glClear );
DETOUR_TRAMPOLINE( VOID WINAPI Trampoline_glColor3f( GLfloat red, GLfloat green, GLfloat blue ), glColor3f );
typedef void (WINAPI* wglSwapBuffers_t)(HDC);

///////////////////////////////////////////////////////////////////////////////////////

//#define HIWORD(l)           ((WORD)((DWORD_PTR)(l) >> 16))

DETOUR_TRAMPOLINE(FARPROC WINAPI Trampoline_GetProcAddress(HMODULE hModule,
 LPCSTR lpProcName), GetProcAddress);

///////////////////////////////////////////////////////////////////////////////////////

VOID WINAPI glBeginDetour(GLenum mode)
{
if(mode == GL_TRIANGLE_STRIP || mode == GL_TRIANGLE_FAN)
glDepthRange( 0, 0.5 );
else
glDepthRange( 0.5, 1 );

if(mode == GL_TRIANGLE_STRIP || mode == GL_TRIANGLE_FAN)
glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_DECAL);

if( mode == GL_QUADS )
g_bSky = true;
else
g_bSky = false;

Trampoline_glBegin(mode);
}

///////////////////////////////////////////////////////////////////////////////////////

VOID WINAPI glClearDetour(GLbitfield mask)
{
if(mask==GL_DEPTH_BUFFER_BIT)
{
mask+=GL_COLOR_BUFFER_BIT;
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

Trampoline_glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
return;
}

Trampoline_glClear(mask);
}

///////////////////////////////////////////////////////////////////////////////////////

VOID WINAPI glShadeModelDetour(GLenum mode)
{
//XQZ2 wallhack
if( mode == GL_SMOOTH ){
__asm {
push 0x00000100 //GL_DEPTH_BUFFER_BIT
call dword ptr[ Trampoline_glClear ]
}
}

Trampoline_glShadeModel(mode);
}

///////////////////////////////////////////////////////////////////////////////////////

VOID WINAPI glViewportDetour(GLint x, GLint y, GLsizei width, GLsizei height)
{
pDraw->m_iVpCounter++;
if( pDraw->m_iVpCounter >= 5 ){
pDraw->m_bDrawing = true;
}
Trampoline_glViewport(x, y, width, height);
}

///////////////////////////////////////////////////////////////////////////////////////

VOID WINAPI glColor3fDetour(GLfloat red, GLfloat green, GLfloat blue)
{
Trampoline_glColor3f(red, green, blue);
}

///////////////////////////////////////////////////////////////////////////////////////

VOID WINAPI glVertex3fvDetour(const GLfloat* v)
{
if(g_bSky && v[2]>300){

return;
/*float flZero = 0.0f;
__asm {
push flZero
push flZero
push flZero
call dword ptr[ Trampoline_glColor3f ]
}*/
}
Trampoline_glVertex3fv(v);
}

///////////////////////////////////////////////////////////////////////////////////////

VOID WINAPI glVertex3fDetour(GLfloat x, GLfloat y, GLfloat z)
{
Trampoline_glVertex3f(x, y, z);
}

///////////////////////////////////////////////////////////////////////////////////////

wglSwapBuffers_t pwglSwapBuffers = NULL;
// DETOUR_TRAMPOLINE(void WINAPI _wglSwapBuffers(HDC hDC), wglSwapBuffers);
// since wglSwapBuffers is undefined, the macro wont work. this is, what it basically does:
static PVOID __fastcall _Detours_GetVA_wglSwapBuffers(VOID)
{
   return pwglSwapBuffers;
}

///////////////////////////////////////////////////////////////////////////////////////

__declspec(naked) void WINAPI _Trampoline_wglSwapBuffers(HDC hDC)
{
   __asm { nop };
   __asm { nop };
   __asm { call _Detours_GetVA_wglSwapBuffers };
   __asm { jmp eax };
   __asm { ret };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
   __asm { nop };
}

///////////////////////////////////////////////////////////////////////////////////////

VOID WINAPI _wglSwapBuffers(HDC hDC)
{
pDraw->m_iVpCounter = 0;
_Trampoline_wglSwapBuffers( hDC );
}

///////////////////////////////////////////////////////////////////////////////////////

void DetourOpenGL()
{
#define Detour( pbTrampFunc, pbDetourFunc )\
DetourFunctionWithTrampoline( (PBYTE)##pbTrampFunc,( PBYTE )##pbDetourFunc )

Detour( Trampoline_glBegin, glBeginDetour );
Detour( Trampoline_glVertex3fv, glVertex3fvDetour );
Detour( Trampoline_glClear, glClearDetour );
/*
Detour( Trampoline_glShadeModel, glShadeModelDetour );
Detour( Trampoline_glViewport, glViewportDetour );
Detour( Trampoline_glVertex3f, glVertex3fDetour );

// Because wglSwapBuffers isnt declared in GL\GL.h...
pwglSwapBuffers = (wglSwapBuffers_t)GetProcAddress(LoadLibrary("opengl32.dll"),
"wglSwapBuffers");
Detour( _Trampoline_wglSwapBuffers, _wglSwapBuffers);

Detour( Trampoline_glColor3f, glColor3fDetour );*/
}

///////////////////////////////////////////////////////////////////////////////////////

void RemoveOpenGLDetour()
{
#define Destroy( pbTrampFunc, pbDetourFunc )\
DetourRemove( (PBYTE)##pbTrampFunc,( PBYTE )##pbDetourFunc )

Destroy( Trampoline_glBegin, glBeginDetour );
Destroy( Trampoline_glVertex3fv, glVertex3fvDetour );
Destroy( Trampoline_glClear, glClearDetour );
/*
Destroy( Trampoline_glShadeModel, glShadeModelDetour );
Destroy( Trampoline_glViewport, glViewportDetour );
Destroy( Trampoline_glVertex3f, glVertex3fDetour );

Destroy( Trampoline_glColor3f, glColor3fDetour );*/
}

///////////////////////////////////////////////////////////////////////////////////////

FARPROC WINAPI GetProcAddressDetour(HMODULE hModule, LPCSTR lpProcName)
{
FARPROC retval = Trampoline_GetProcAddress(hModule, lpProcName);
return retval;
}

///////////////////////////////////////////////////////////////////////////////////////

BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
switch(ul_reason_for_call)
{
case DLL_PROCESS_ATTACH://Let the magic happen...:->
DetourOpenGL();
//Extras
/* DetourFunctionWithTrampoline((PBYTE)Trampoline_GetProcAddress,
(PBYTE)GetProcAddressDetour);*/
break;
case DLL_PROCESS_DETACH:
RemoveOpenGLDetour();
break;
}
   return TRUE;
}

///////////////////////////////////////////////////////////////////////////////////////


PROJECT VCPP6
http://www.mediafire.com/?tl9qprjaytk77v7

[Luchoz95]

Gracias me sirve de mucho !