Test Foro de elhacker.net SMF 2.1

Si eso estaba en el código original de SharkBoy999, no lo quité pero eso no funciona así, es decir vos comprobás si GetAsyncKeyState es diferente de 0, ya que la especificación de la MSDN dice que si el bit más significativo es 1 es que la llave está presionada, y dice que no se tome en cuenta otros comportamientos, por lo tanto no hace falta usar máscara de bits, sólamente comprobando que no sea 0 es suficiente.

http://msdn.microsoft.com/en-us/library/windows/desktop/ms646293(v=vs.85).aspx


EDIT: XD aparte la función 'toggle' es cualquier cosa , es decir no le des bola al resto del código porque pertenece a la base de SharkBoy999, es un man que hizo un par de hacks en el pasado y siempre que publicaba códigos lo hacía poniendo errores para que no los compile cualquiera o para que no funcionen. Lo mismo hacían muchos otros.

Es decir, concentráte en el método del HOOK

Saludos

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.


typedef void(__stdcall* t_glBegin)(GLenum);
t_glBegin pOrig_glBegin = NULL;

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

void __stdcall HOOK_glBegin(GLenum mode)
{
static bool once=false;
if(!once){

printf("\n");
printf("DLL -> HOOK_glBegin!\n");
system("pause");
once=true;
}

(*pOrig_glBegin)(mode);
}

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

DWORD* OGL_GetFuncForOffset( DWORD dwTIBOffset )
{
DWORD* retval=0;
__asm {
mov eax, fs:[0x18]; // TIB
add eax, dwTIBOffset;
mov eax, [eax]
mov retval, eax
}
return retval;
}

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

bool OGL_IsOffsetHooked( DWORD dwTIBOffset, DWORD* dwOriginal, DWORD* dwHook )
{
return( OGL_GetFuncForOffset( dwTIBOffset ) == dwHook );
}

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

void OGL_HookTIB( DWORD dwTIBOffset, DWORD* dwOriginal, DWORD* dwHook )
{
if( OGL_IsOffsetHooked( dwTIBOffset, dwOriginal, dwHook ) ){
return;
}

__asm {
mov eax, dword ptr fs:[0x18]; // TIB
add eax, dwTIBOffset; // add offset needed
mov ecx, [eax] // get the function offset
mov ebx, [dwOriginal] // grab addr of original
mov [ebx], ecx; // move it into our pointer
mov ecx, dwHook; // move offset of our hook into ecx
mov [eax], ecx; // move ecx into opengl's info space
}
}

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

#define ofs_glBegin     0x7CC
#define ofs_glVertext3f 0x94C
#define ofs_glPopMatrix 0x9E4

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

DWORD dwReplaceDriverAddress(DWORD dwIndex, DWORD dwNewFunction)
{
   DWORD* dwTIB = NULL;
DWORD teb=0;
PTEB myTEB;

      __asm
      {
           mov eax, dword ptr fs:[18h]
           add eax, dwIndex
           mov dwTIB, eax
           mov myTEB,eax
      }

printf("myTEB 0x%X\n",myTEB);
printf("dwIndex 0x%X\n",dwIndex);
printf("dwTIB 0x%X\n",dwTIB);
printf("*dwTIB 0x%X\n",*dwTIB);
printf("dwNewFunction 0x%X\n",dwNewFunction);
system("pause");

       DWORD g_dwReturnValue = *dwTIB;
       //*dwTIB = dwNewFunction;
       //printf("*dwTIB 0x%X\n",*dwTIB);
       return g_dwReturnValue;
}

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

void thread(){

while(1){

if(GetModuleHandle("opengl32.dll")){

pOrig_glBegin = (t_glBegin)dwReplaceDriverAddress(ofs_glBegin,(DWORD)HOOK_glBegin);

if(pOrig_glBegin){

   printf("pOrig_glBegin 0x%X\n",pOrig_glBegin);
   system("pause");
}
break;
}

Sleep(300);
}
}

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

BOOL APIENTRY DllMain(HINSTANCE i, DWORD reason, LPVOID res){

if(reason == DLL_PROCESS_ATTACH){

if(GetModuleHandle("opengl32.dll")){

pOrig_glBegin = (t_glBegin)dwReplaceDriverAddress(ofs_glBegin,(DWORD)HOOK_glBegin);

if(pOrig_glBegin){
   printf("pOrig_glBegin 0x%X\n",pOrig_glBegin);
   system("pause");
}
}

//CreateThread(0,0,(unsigned long (__stdcall *)(void *))thread,0,0,0);
}
return (true);
}


PS: Ese código la sarpa, parece un multihack XD.. y tiene la librería de karman IntelliAPIHooking, nice  

Cita de: Luchoz95 en  8 Abril 2013, 01:35 AM
aah, claro voy a tratar de ir escalando por metodo

La verdad, esto que hiciste se puede considerar parchear el juego, pero en realidad se aplica a cuando cambiás bytes en la memoria del proceso en la parte del código, los punteros son datos aunque podemos considerarlo un parche el hecho de reemplazar un valor por otro.

Los 'Detours' también es "parchear el juego".

Los hooks del tipo EAT y IAT también se trata de parchear, lo mismo, osea punteros.

Pero eso te dije que son métodos instrusivos.

Son fáciles de detectar y de restaurar.
Por eso cuando uno parchea algo que tiene comprobaciones de seguridad, lo que se debe hacer también es parchear esas comprobaciones XD, para que no te detecten

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


//

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

#pragma comment(lib,"OpenGL32.lib")
#pragma comment(lib, "Version.lib")
#define _WIN32_WINNT 0x0500
#undef UNICODE
#include <windows.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <shlwapi.h>
#include <stdio.h>

#include "nt.h"

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

HANDLE hThread=NULL;
PBYTE dwFSBase,dwFSBase2;

HWND hdHalfLife;

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

typedef void (APIENTRY* glBlendFunc_t)(GLenum,GLenum);
typedef void (APIENTRY* glClear_t)(GLbitfield);
typedef void (APIENTRY* glVertex2f_t)(GLfloat,GLfloat);
typedef void (APIENTRY* glVertex3f_t)(GLfloat,GLfloat,GLfloat);
typedef void (APIENTRY* glVertex3fv_t)(const GLfloat*);
typedef void (APIENTRY* glBegin_t)(GLenum);
glBlendFunc_t pglBlendFunc=0;
glClear_t pglClear=0;
glVertex2f_t pglVertex2f=0;
glVertex3f_t pglVertex3f=0;
glVertex3fv_t pglVertex3fv=0;
glBegin_t pglBegin=0;

BOOL bFlash=FALSE;
BOOL bSky=FALSE;

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

void APIENTRY New_glBegin(GLenum mode){

if(mode==GL_TRIANGLE_STRIP||mode==GL_TRIANGLE_FAN)
glDisable(GL_DEPTH_TEST);
else if(mode!=GL_QUADS&&mode!=GL_LINES)
glEnable(GL_DEPTH_TEST);

if(mode==GL_QUADS){
float col[4];
       glGetFloatv(GL_CURRENT_COLOR, col);
       bFlash=(col[0]==1.0&&col[1]==1.0&&col[2]==1.0&&col[3]>0.2);
bSky=TRUE;
   }
else
bSky=FALSE;
pglBegin(mode);
}

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

void APIENTRY New_glClear(GLbitfield mask){

if(mask==GL_DEPTH_BUFFER_BIT){
mask+=GL_COLOR_BUFFER_BIT;
glClearColor(0.0f,0.0f,0.0f,0.0f);
}
pglClear(mask);
}

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

void APIENTRY New_glVertex3fv(const GLfloat* v){

if(bSky) return;
pglVertex3fv(v);
}

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

void APIENTRY New_glVertex2f(GLfloat x, GLfloat y){

if(bFlash&&x==0.0&&y==0.0) glColor4f(1.0f,1.0f,1.0f,0.2f);
   pglVertex2f(x,y);
}

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

void APIENTRY New_glVertex3f(GLfloat x, GLfloat y, GLfloat z){

glColor3f(1.0f,1.0f,1.0f);
pglVertex3f(x,y,z);
}

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

BOOL GetDllVersion(HMODULE hLibModule, DLLVERSIONINFO* aVersion){
 
   CHAR fileName[MAX_PATH];
   UINT len=0;
   VS_FIXEDFILEINFO* vsfi=NULL;
   DWORD handle=0;
   DWORD size=GetModuleFileName(hLibModule,fileName,MAX_PATH);
   fileName[size]=0;
   size=GetFileVersionInfoSize(fileName, &handle);
   BYTE* versionInfo=new BYTE[size];
   if(!GetFileVersionInfo(fileName,handle,size,versionInfo)){
delete[] versionInfo;
       return FALSE;
   }
   VerQueryValue(versionInfo,"\\",(PVOID*)&vsfi,&len);
   aVersion->dwMajorVersion=HIWORD(vsfi->dwFileVersionMS);
   aVersion->dwMinorVersion=LOWORD(vsfi->dwFileVersionMS);
   aVersion->dwBuildNumber=HIWORD(vsfi->dwFileVersionLS);
   aVersion->dwPlatformID=LOWORD(vsfi->dwFileVersionLS);
   delete[] versionInfo;
   return TRUE;
}

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

void* Detour1(BYTE* src, const BYTE* dst, const int len){
BYTE* jmp = (BYTE*)malloc(len+5);
DWORD dwback;
while(!VirtualProtect(src, len, PAGE_READWRITE, &dwback));
memcpy(jmp, src, len);jmp+=len;
jmp[0] = 0xE9;
*(DWORD*)(jmp+1)=(DWORD)(src+len-jmp)-5;
src[0] = 0xE9;
*(DWORD*)(src+1)=(DWORD)(dst-src)-5;
while(!VirtualProtect(src, len, dwback, &dwback));
return (jmp-len);
}

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

/*
DWORD GetProcessThreadId(unsigned long ProcessId)
{
   HANDLE hSnapThread = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, ProcessId);
   if(hSnapThread == INVALID_HANDLE_VALUE) return NULL;
   THREADENTRY32 te;
   te.dwSize = sizeof(THREADENTRY32);
   if(Thread32First(hSnapThread, &te))
   {
      do
      {
           if(te.th32OwnerProcessID == ProcessId) {
               CloseHandle(hSnapThread);
               return te.th32ThreadID;
           }

      } while(Thread32Next(hSnapThread, &te));
   }
   CloseHandle(hSnapThread);
   return 0;
}*/

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

DWORD WINAPI Thread(LPVOID lpParam){

   DWORD dwThreadId,dwProcessId,dwOGLOffset;
   CONTEXT Context;
   LDT_ENTRY SelEntry;
   HMODULE hModule;
   Context.ContextFlags=CONTEXT_FULL|CONTEXT_DEBUG_REGISTERS;
   DWORD dwTLSIndex=0;
   DLLVERSIONINFO oglVersion;

   while(((hdHalfLife=FindWindow("Valve001",NULL))==NULL)
             &&((hdHalfLife=FindWindow(NULL,"Counter-Strike"))==NULL))
                     Sleep(100);

   while((hModule=GetModuleHandle("Opengl32.dll"))==NULL)
             Sleep(100);

   if(GetDllVersion(hModule,&oglVersion)){

       if(oglVersion.dwMajorVersion==5&&oglVersion.dwMinorVersion==1){
           dwTLSIndex=0xAC80C;
}
else if(oglVersion.dwMajorVersion==6&&oglVersion.dwMinorVersion==0){
           dwTLSIndex=0xAB958;
}
else if(oglVersion.dwMajorVersion==6&&oglVersion.dwMinorVersion==1){
           dwTLSIndex=0xA100C;
}
       else
       {
            //MessageBox(hdHalfLife,"Incompatible OpenGL Version...\n\nSorry man...","Inexinferis FX Series - Karman",0);
           ExitThread(0);
           return 0;
       }
   }
   else
   {
       //MessageBox(hdHalfLife,"Can't Get OpenGL Version...\n\nWrong OpenGL???","Inexinferis FX Series - Karman",0);
ExitThread(0);
       return 0;
   }

   //DWORD ProcessId = GetCurrentProcessId();
   //DWORD ProcessThreadId = GetProcessThreadId(ProcessId);
   dwThreadId=GetWindowThreadProcessId(hdHalfLife,&dwProcessId);
   HANDLE hThread=OpenThread(THREAD_GET_CONTEXT|THREAD_SUSPEND_RESUME|THREAD_QUERY_INFORMATION,FALSE,dwThreadId);

   if(!hThread){
       //MessageBox(hdHalfLife,"Couldn't Get Proccess Info...\n\nAntivirus???","Inexinferis FX Series - Karman",0);
       CloseHandle(hThread);
       ExitThread(0);
       return 0;
   }

   GetThreadContext(hThread,&Context);
   GetThreadSelectorEntry(hThread, Context.SegFs, &SelEntry);
   dwFSBase = (PBYTE)((SelEntry.HighWord.Bits.BaseHi<<24)|(SelEntry.HighWord.Bits.BaseMid<<16)|SelEntry.BaseLow);

   if(!dwFSBase||IsBadReadPtr((PVOID)dwFSBase,sizeof(DWORD))){
       //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);
       CloseHandle(hThread);
       ExitThread(0);
       return 0;
   }

   dwOGLOffset=((DWORD)hModule)+dwTLSIndex;
   if(!dwTLSIndex||IsBadReadPtr((PVOID)dwOGLOffset,sizeof(DWORD))){
       //MessageBox(hdHalfLife,"Couldn't Read From Opengl32.dll Address\n\nMaybe your OpenGL driver is not compatible...","Inexinferis FX Series - Karman",0);
      CloseHandle(hThread);
      ExitThread(0);
      return 0;
   }
   //multiple redirect...
   do{
          Sleep(10);
          dwFSBase2=(PBYTE)(*(PDWORD)((DWORD)dwFSBase+(*(PDWORD)dwOGLOffset)));
   }while(dwFSBase2==NULL);

/*
  dwFSBase2=(PBYTE)(*(PDWORD)((DWORD)dwFSBase+(*(PDWORD)0x5F1CC80C)));
  if(!dwFSBase2){
      CloseHandle(hThread);
      ExitThread(0);
      return 0;
  }*/

               


  //MessageBox(hdHalfLife,"http://www.inexinferis.com.ar/foro","Inexinferis FX Series - Karman",0);
  SuspendThread(hThread);

  ////////
  // Hooks

  // 0x01D46862  opengl32.glClear [EAX+32C] -> 0x69609A20 [12]
  pglClear= (glClear_t)Detour1((PBYTE)(*(PDWORD)(dwFSBase2+0x32C)),(PBYTE)New_glClear,12);
   
  // 0x01D3CF1D  opengl32.glVertex2f [EAX+92C] -> 0x69606320 [12]
  pglVertex2f= (glVertex2f_t)Detour1((PBYTE)(*(PDWORD)(dwFSBase+0x92C)),(PBYTE)New_glVertex2f,12);
   
  pglVertex3f= (glVertex3f_t)Detour1((PBYTE)(*(PDWORD)(dwFSBase+0x94C)),(PBYTE)New_glVertex3f,12);
   
  // 0x01D936C5 opengl32.glVertex3fv [EAX+950] -> 0x696073F0 [12]
  pglVertex3fv= (glVertex3fv_t)Detour1((PBYTE)(*(PDWORD)(dwFSBase+0x950)),(PBYTE)New_glVertex3fv,12);
   
  // 0x01D93681 opengl32.glBegin [EAX+7CC] -> 0x695FD250 [8]
  pglBegin= (glBegin_t)Detour1((PBYTE)(*(PDWORD)(dwFSBase+0x7CC)),(PBYTE)New_glBegin, 8);

   ////////

   ResumeThread(hThread);
   CloseHandle(hThread);

   ExitThread(0);
   return 0;
}

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

BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD fdwReason, LPVOID lpvReserved){
 
if(fdwReason==DLL_PROCESS_ATTACH){
   
DisableThreadLibraryCalls(hInstance);
hThread=CreateThread(NULL,0,Thread,NULL,0,NULL);
}
return (TRUE);
}

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



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

Para terminar de redondear el tema de interceptar Opengl32 usando detours, muestro una pequeña base para crear un WH, utiliza una función personalizada para instalar un hook del tipo DETOUR.
Habíamos visto en otros tutoriales como se hace, y que se trata de una técnica intrusiva porque requiere parchear la memoria (código) del proceso víctima.
http://foro.elhacker.net/programacion_cc/detours-t168884.0.html
No tiene nada que ver con otros tutoriales que muestran como se modifican los valores de algunos punteros que corresponden a datos en el proceso.
Ej: http://foro.elhacker.net/programacion_cc/codigo_fuente_cheat_cs_16-t387341.0.html

Dejo el código funcional y el proyecto para descargar como siempre, dejo unas imágenes..

En este caso para diferenciarnos de otros tutoriales, explico la forma en que se puede cargar esta DLL en el proceso "hl.exe" que corresponde al juego Counter-Strike.

Se trata de ir a la carpeta del juego, y buscar una DLL de las que sabemos que no son necesarias en el juego pero de todas formas son cargadas al proceso.
Hay otras DLLs que son cargadas y algunas de sus funciones o todas, son utilizadas en el proceso, por lo que no se puede quitarlas, sino más bien hacer un 'wrapper' de ellas. Pero no quitarlas.

Vamos a ver una DLL que si la podemos quitar que se llama "DemoPlayer.dll". Vamos a quitarla y poner nuestra DLL con el WH en su lugar. Obviamente la tenemos que renombrar a "demoplayer.DLL" si es que no tiene ese nombre toda via.





Al final quiero decir que los sistemas de seguridad suelen escanear en la memoria, por ejemplo los primeros 5 bytes de algunas funciones para determinar si tienen 'detours'.
Pero a veces hacen otras comprobaciones como CRC32 de toda una función, o quien sabe que otras comprobaciones.. el tema es que este es un método intrusivo.



//
// Modifications: By 85
// Credits: gamedeception (detour function), SharkBoy999 base
// elhacker.net
// etalking.com.ar
// david_bs@live.com
// 2013
//

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

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

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

#define wallhack_key     GetAsyncKeyState(VK_NUMPAD1) &1
#define lambert_key GetAsyncKeyState(VK_NUMPAD2) &1
#define nosmoke_key GetAsyncKeyState(VK_NUMPAD3) &1
#define noflash_key GetAsyncKeyState(VK_NUMPAD4) &1

bool wallhack = true;
bool lambert = true;
bool nosmoke = true;
bool noflash = true;

bool bDrawingSmoke = false;
bool bDrawingFlash = false;

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

typedef FARPROC (APIENTRY* GetProcAddress_t)(HMODULE, LPCSTR);
typedef void (APIENTRY* glBegin_t)(GLenum mode);
typedef void (APIENTRY* glViewport_t)(GLint x, GLint y, GLsizei width, GLsizei height);
typedef void (APIENTRY* glVertex3fv_t)(const GLfloat* v);
typedef void (APIENTRY* glVertex2f_t)(GLfloat,GLfloat);

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

GetProcAddress_t pGetProcAddress = 0;
glBegin_t pglBegin;
glViewport_t pglViewport;
glVertex3fv_t pglVertex3fv;
glVertex2f_t pglVertex2f;

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

void toggle(bool var)
{
   var = !var;
}

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

void* Detour1(BYTE* src, const BYTE* dst, const int len)
{
BYTE* jmp = (BYTE*)malloc(len+5);
DWORD dwback;
while(!VirtualProtect(src, len, PAGE_READWRITE, &dwback));
memcpy(jmp, src, len);jmp+=len;
jmp[0] = 0xE9;
*(DWORD*)(jmp+1)=(DWORD)(src+len-jmp)-5;
src[0] = 0xE9;
*(DWORD*)(src+1)=(DWORD)(dst-src)-5;
while(!VirtualProtect(src, len, dwback, &dwback));
return (jmp-len);
}

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

FARPROC APIENTRY new_GetProcAddress(HMODULE hModule, LPCSTR lpProcName)
{
//FARPROC fpResult = (*pGetProcAddress)(hModule, lpProcName);
FARPROC fpResult = pGetProcAddress(hModule, lpProcName);
if(HIWORD(lpProcName))
{
if(!lstrcmp(lpProcName,"GetProcAddress"))
return((FARPROC)&new_GetProcAddress);
}
return fpResult;
}

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

void APIENTRY new_glBegin(GLenum mode)
{
if(wallhack)
{
if(mode == GL_TRIANGLE_STRIP || mode == GL_TRIANGLE_FAN)
glDepthRange( 0, 0.5 );
else
glDepthRange( 0.5, 1 );
}

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

if(nosmoke)
{
if(mode==GL_QUADS)
{
GLfloat curcol[4];
glGetFloatv(GL_CURRENT_COLOR, curcol);
if(mode==GL_QUADS
&& (curcol[0]==curcol[1])
&& (curcol[0]==curcol[2])
&& (curcol[0]!=0.0)
&& (curcol[0]!=1.0))
{
bDrawingSmoke = true;
}
else
bDrawingSmoke = false;
}
}

if(noflash)
{
GLfloat color[4];
glGetFloatv(GL_CURRENT_COLOR, color);
if(mode == GL_QUADS && (color[0]==1 && color[1]==1 && color[2]==1) )
{
bDrawingFlash = true;
}
else
bDrawingFlash = false;
}
pglBegin(mode);
}

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

void APIENTRY new_glViewport(GLint x, GLint y, GLsizei w, GLsizei h)
{
if(wallhack_key)
toggle(wallhack);
if(lambert_key)
toggle(lambert);
if(nosmoke_key)
toggle(nosmoke);
if(noflash_key)
toggle(noflash);
pglViewport(x,y,w,h);
}

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

void APIENTRY new_glVertex3fv(const GLfloat* v)
{
if(bDrawingSmoke)
return;

pglVertex3fv(v);
}

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

void APIENTRY new_glVertex2f(GLfloat x,GLfloat y)
{
/* if (bDrawingFlash)
{
GLfloat color[4];
glGetFloatv(GL_CURRENT_COLOR, color);
//color[0]=0, color[1]=0, color[2]=0;
glDisable(GL_TEXTURE_2D);
glColor4f(color[0], color[1], color[2], 0.01f);
}*/
pglVertex2f(x,y);
}

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

void Hook(void)
{
pglBegin =        (glBegin_t)       Detour1((LPBYTE)glBegin,       (LPBYTE)new_glBegin, 6);
pglViewport =     (glViewport_t)    Detour1((LPBYTE)glViewport,    (LPBYTE)new_glViewport, 7);
pglVertex3fv =    (glVertex3fv_t)   Detour1((LPBYTE)glVertex3fv,   (LPBYTE)new_glVertex3fv, 6);
pglVertex2f =     (glVertex2f_t)    Detour1((LPBYTE)glVertex2f,    (LPBYTE)new_glVertex2f, 6);
}

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

bool APIENTRY DllMain(HANDLE hModule, DWORD  dwReason, LPVOID lpReserved)
{
if(dwReason == DLL_PROCESS_ATTACH)
{
// No es necesario este Detour para la demostración..
pGetProcAddress = (GetProcAddress_t)Detour1((LPBYTE)GetProcAddress,
(LPBYTE)new_GetProcAddress, 5);

if(GetModuleHandle("Opengl32.dll"))
Hook();
}
else if(dwReason == DLL_PROCESS_DETACH)
{
// Restaurar bytes en GPA

// (no hace falta suspender el mismo hilo! no sirve para nada XD)

// Salida con retardo.
// Permite que se ejecuten los últimos llamados a GPA
// (Y no hace falta restaurar los bytes parcheados XD)
ExitProcess(100);
}
return (true);
}

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



otra cosa que quiero agregar, es que el 'hook' a GetProcAddress no es necesario, pero está hecho y sirve para demostrar algo importante.

cuando salimos del juego, osea del proceso, antes se descargan las DLLs entre otras cosas, pero cuando se descarga nuestra DLL la memoria del proceso continua parcheada (los hooks que instalamos), y las referencias a los hooks son inválidas ya que la DLL se ha descargado.

Esto no importa para Opengl32 porque nadie va a utilizar Opengl32 al salir, pero con GetProcAddress si pasa esto. Por eso se debería considerar restaurar los bytes parcheados en GetProcAddress, o más fácil es hacer que la DLL se descargue cuando ya no sea necesaria (cuando no se haga más referencia a los hooks). Con un ExitProcess(100) queda resuelto, en realidad no investigué acerca de este tema, sólo traté de arreglarlo de alguna forma. Pero es un detalle a considerar.

PROYECTO
http://www.mediafire.com/?qfb65fsfgaf5doa

By: Shabbir (Go4Expert)
http://www.go4expert.com/articles/st...ration-t29601/

Captcha, reCaptcha as well as Question and Answer does not stop vBulletin Spam registrations and so I have come up with yet another solution to stop vBulletin Spam for Registration. This works with any kind of site and is based on Cookies for Comments Wordpress Plugin.

The idea and implementation is completely based on the plugin and so the credit completely goes to the Authors of the above plugin. I have just used it for vBulletin and shared it here so you can apply the same for your forums. It is very simple and yet so effective that it can be applied to almost any website.

Step 1
Download the above plugin and extract into a folder. Upload css.php file to your forum root directory. Browse to the css.php file in your browser and copy the link to the css.php file.

Step 2
Now add the following lines to your headinclude template in each of your vBulletin style.


<link rel="stylesheet" type="text/css" href="LINK_TO_FILE UPLOADED_IN_STEP1?k=SOME_RANDOM_STRING_OF_YOUR_CHOICE" />


Replace the SOME_RANDOM_STRING_OF_YOUR_CHOICE with anything of your choice.

If you don't want to add stylesheet declaration in your template, you can also opt for blank image. For this you have to upload the blank.gif image from the above plugin to your site and then add the following blank image code in header or footer template of each of your vBulletin style.


<img src="LINK_TO_FILE UPLOADED_IN_STEP1?k=SOME_RANDOM_STRING_OF_YOUR_CHOICE&o=img" width="0" height="0" border="0" style="display:none;" />


Step 3
Now Add the following into your .htaccess file.


RewriteCond %{HTTP_COOKIE} !^.*SOME_RANDOM_STRING_OF_YOUR_CHOICE.*$
RewriteRule ^register.php - [F,L]


Remember the above rules goes right at the top. Even above the vBSEO Rules if any.

Now any user visiting your register.php file without visiting any of your pages on your forum will get a 403 forbidden error message.

There can be issues if you have multiple CMSes like may be Wordpress and vBulletin or any other static pages and genuine users can click on registration link from those pages. The solution is to make the call to the above CSS/image file from every page of your site.

I hope it helps reduce the spam registration considerably.

The above solution can even be applied to any other custom CMS of your choice as well. You have to just block your registration pages with the needed cookie and set the cookies in header or footer of your site for genuine users who visit your site.

Further Spam Prevention Options for vBulletin
You can also opt for some more spam prevention options that I have mentioned on my blog here as well as opt for a Block vBulletin Spam Posts Plugin to stop spam posts in forums.

NOTA: Si está en inglés, pueden usar el traductor de google XD
http://translate.google.com.ar/

Pero si esto funciona como dice, es super importante para los que tienen vBulletin por el gran problema de los bots :/
Supuestamente sirve para cualquier sitio.

Aunque no entiendas nada tendrías que leer un manual de los básicos, siempre traen ejemplos de código.
Se aprende entrenando, nunk dejes de codificar, aunque sea con ejemplos que te pasen otros o lo que sea..

Estos 2 temas fijate a mi criterio parecen básicos, es decir nada complicado y indicado para un beginner.
http://foro.elhacker.net/programacion_cc/descomponer_en_unidades-t386770.0.html
http://foro.elhacker.net/programacion_cc/clases_de_almacenamiento-t386497.0.html

bucles
FOR = ciclo exacto, osea se conocen la cantidad de ciclos
WHILE = ciclo inexacto, no se conocen la cantidad de ciclos

bloques condicionales
IF
ELSE-IF
ELSE

tipos de datos del lenguaje
tipos de datos personalizados

funciones

me imagino que sabés acerca de la función MAIN, también conocida como punto de entrada del programa.

El manual es necesario, no conozco a nadie que no haya agarrado un manual de C para aprender, ya que del manual no sólo se aprende el lenguaje en sí, sino acerca de las especificaciones técnicas (Se conoce como standard).

Nop, Ring0 ak no tiene nada que ver. Vos sabés que para ejecutar código en modo Ring0 se requiere un driver, y las librerías son otras que las de modo Ring3 (usuario). Es decir es otro tema XD, se requiere una DDK para compilar drivers, es otro tema

Todo esto es desde Ring3. Pero si te interesa saber si se puede hacer desde Ring0, la respuesta es si, todo o casi todo se puede hacer desde ese nivel.
Sólo que es otra programación (otras librerías).

Andá escalando XD, ya sabés lo que es parchear el juego, sabés lo que es un 'wrapper' de DLL, sabés acerca de usar 'Detours' que también es parchear.
Y también deberías saber acerca de EAT y IAT debido a los múltiples temas que se han publicado al respecto. Por ejemplo el link de mr.blood

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

Citar
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.



//
// 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

para trabajar directamente con la memoria son necesarios, a menos que te manejes con las direcciones de las variables o de las funciones directamente, o utilices "pseudopunteros" o typecasting de variables de tipo DWORD por ejemplo que guarden direcciones de memoria. Es decir, la idea es usar punteros si.
Claro en un sistema x32 con JMP+ADDRESS son 5 bytes, 1 del JMP y 4 de la ADDRESS.

Te recomiendo que desensambles algunos programas muy simples en C para examinar el código ASM, al menos para ver de que se trata. No es necesario saber programar en ASM para observar algunos conceptos.

Bajate algún desensamblador o sino utilizando un depurador, El tema es que veas los bytes en la memoria, que corresponden a tu programa.