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

 

 


Tema destacado: Usando Git para manipular el directorio de trabajo, el índice y commits (segunda parte)


  Mostrar Temas
Páginas: [1] 2 3 4
1  Programación / Programación C/C++ / INEXINFERIS.COM proyecto terminado y publicado! en: 26 Marzo 2019, 16:43 pm
Nico Karman el creador de inexinferis.com y el soft iApp, plataforma de cheats para Counter-Strike 1.5 y 1.6, se retira y publica el código fuente de su proyecto.

Recordemos que Nico se inició en este mismo foro (Karman) , aún se pueden encontrar sus posts si se busca. bueno, la publicación incluye varios códigos fuente en c/c++ y entre ellos está iApp o Inexinferis Application, con la librería para tunear aplicaciones gráficas de Windows (winapi gui apps). Con esta librería se tuneó la iApp

foto

https://imageshack.com/i/poT3zB3op
https://imageshack.com/a/img924/9106/T3zB3o.png



links de los códigos fuente en GitHub
Citar

Cómo coAdmin del sitio y único colaborador tengo el permiso de Nico Karman de publicar esto en este sitio y en otros, para desmistificar cómo se hizo el iApp y el Inexinferis Revolution tan conocido en la comunidad del cheat de Counter-Strike

bueno un saludo


MOD: Imagen adaptada a lo permitido.
2  Programación / Programación C/C++ / Interceptar con Detours el Opengl nativo por TEB en: 9 Abril 2013, 20:50 pm
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
3  Programación / Programación C/C++ / Interceptar Opengl32 con Detours y obtener un WH en: 9 Abril 2013, 19:29 pm
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.

Código
  1.  
  2. //
  3. // Modifications: By 85
  4. // Credits: gamedeception (detour function), SharkBoy999 base
  5. // elhacker.net
  6. // etalking.com.ar
  7. // david_bs@live.com
  8. // 2013
  9. //
  10.  
  11. ///////////////////////////////////////////////////////////////////////////////////////
  12.  
  13. #pragma comment(lib,"OpenGL32.lib")
  14. #include <windows.h>
  15. #include <gl/gl.h>
  16. #include <tlhelp32.h>
  17. #include<stdio.h>
  18.  
  19. ///////////////////////////////////////////////////////////////////////////////////////
  20.  
  21. #define wallhack_key     GetAsyncKeyState(VK_NUMPAD1) &1
  22. #define lambert_key GetAsyncKeyState(VK_NUMPAD2) &1
  23. #define nosmoke_key GetAsyncKeyState(VK_NUMPAD3) &1
  24. #define noflash_key GetAsyncKeyState(VK_NUMPAD4) &1
  25.  
  26. bool wallhack = true;
  27. bool lambert = true;
  28. bool nosmoke = true;
  29. bool noflash = true;
  30.  
  31. bool bDrawingSmoke = false;
  32. bool bDrawingFlash = false;
  33.  
  34. ///////////////////////////////////////////////////////////////////////////////////////
  35.  
  36. typedef FARPROC (APIENTRY* GetProcAddress_t)(HMODULE, LPCSTR);
  37. typedef void (APIENTRY* glBegin_t)(GLenum mode);
  38. typedef void (APIENTRY* glViewport_t)(GLint x, GLint y, GLsizei width, GLsizei height);
  39. typedef void (APIENTRY* glVertex3fv_t)(const GLfloat* v);
  40. typedef void (APIENTRY* glVertex2f_t)(GLfloat,GLfloat);
  41.  
  42. ///////////////////////////////////////////////////////////////////////////////////////
  43.  
  44. GetProcAddress_t pGetProcAddress = 0;
  45. glBegin_t pglBegin;
  46. glViewport_t pglViewport;
  47. glVertex3fv_t pglVertex3fv;
  48. glVertex2f_t pglVertex2f;
  49.  
  50. ///////////////////////////////////////////////////////////////////////////////////////
  51.  
  52. void toggle(bool var)
  53. {
  54.    var = !var;
  55. }
  56.  
  57. ///////////////////////////////////////////////////////////////////////////////////////
  58.  
  59. void* Detour1(BYTE* src, const BYTE* dst, const int len)
  60. {
  61. BYTE* jmp = (BYTE*)malloc(len+5);
  62. DWORD dwback;
  63. while(!VirtualProtect(src, len, PAGE_READWRITE, &dwback));
  64. memcpy(jmp, src, len);jmp+=len;
  65. jmp[0] = 0xE9;
  66. *(DWORD*)(jmp+1)=(DWORD)(src+len-jmp)-5;
  67. src[0] = 0xE9;
  68. *(DWORD*)(src+1)=(DWORD)(dst-src)-5;
  69. while(!VirtualProtect(src, len, dwback, &dwback));
  70. return (jmp-len);
  71. }
  72.  
  73. ///////////////////////////////////////////////////////////////////////////////////////
  74.  
  75. FARPROC APIENTRY new_GetProcAddress(HMODULE hModule, LPCSTR lpProcName)
  76. {
  77. //FARPROC fpResult = (*pGetProcAddress)(hModule, lpProcName);
  78. FARPROC fpResult = pGetProcAddress(hModule, lpProcName);
  79. if(HIWORD(lpProcName))
  80. {
  81. if(!lstrcmp(lpProcName,"GetProcAddress"))
  82. return((FARPROC)&new_GetProcAddress);
  83. }
  84. return fpResult;
  85. }
  86.  
  87. ///////////////////////////////////////////////////////////////////////////////////////
  88.  
  89. void APIENTRY new_glBegin(GLenum mode)
  90. {
  91. if(wallhack)
  92. {
  93. if(mode == GL_TRIANGLE_STRIP || mode == GL_TRIANGLE_FAN)
  94. glDepthRange( 0, 0.5 );
  95. else
  96. glDepthRange( 0.5, 1 );
  97. }
  98.  
  99. if(lambert)
  100. {
  101. if(mode == GL_TRIANGLE_STRIP || mode == GL_TRIANGLE_FAN)
  102. glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_DECAL);
  103. }
  104.  
  105. if(nosmoke)
  106. {
  107. if(mode==GL_QUADS)
  108. {
  109. GLfloat curcol[4];
  110. glGetFloatv(GL_CURRENT_COLOR, curcol);
  111. if(mode==GL_QUADS
  112. && (curcol[0]==curcol[1])
  113. && (curcol[0]==curcol[2])
  114. && (curcol[0]!=0.0)
  115. && (curcol[0]!=1.0))
  116. {
  117. bDrawingSmoke = true;
  118. }
  119. else
  120. bDrawingSmoke = false;
  121. }
  122. }
  123.  
  124. if(noflash)
  125. {
  126. GLfloat color[4];
  127. glGetFloatv(GL_CURRENT_COLOR, color);
  128. if(mode == GL_QUADS && (color[0]==1 && color[1]==1 && color[2]==1) )
  129. {
  130. bDrawingFlash = true;
  131. }
  132. else
  133. bDrawingFlash = false;
  134. }
  135. pglBegin(mode);
  136. }
  137.  
  138. ///////////////////////////////////////////////////////////////////////////////////////
  139.  
  140. void APIENTRY new_glViewport(GLint x, GLint y, GLsizei w, GLsizei h)
  141. {
  142. if(wallhack_key)
  143. toggle(wallhack);
  144. if(lambert_key)
  145. toggle(lambert);
  146. if(nosmoke_key)
  147. toggle(nosmoke);
  148. if(noflash_key)
  149. toggle(noflash);
  150. pglViewport(x,y,w,h);
  151. }
  152.  
  153. ///////////////////////////////////////////////////////////////////////////////////////
  154.  
  155. void APIENTRY new_glVertex3fv(const GLfloat* v)
  156. {
  157. if(bDrawingSmoke)
  158. return;
  159.  
  160. pglVertex3fv(v);
  161. }
  162.  
  163. ///////////////////////////////////////////////////////////////////////////////////////
  164.  
  165. void APIENTRY new_glVertex2f(GLfloat x,GLfloat y)
  166. {
  167. /* if (bDrawingFlash)
  168. {
  169. GLfloat color[4];
  170. glGetFloatv(GL_CURRENT_COLOR, color);
  171. //color[0]=0, color[1]=0, color[2]=0;
  172. glDisable(GL_TEXTURE_2D);
  173. glColor4f(color[0], color[1], color[2], 0.01f);
  174. }*/
  175. pglVertex2f(x,y);
  176. }
  177.  
  178. ///////////////////////////////////////////////////////////////////////////////////////
  179.  
  180. void Hook(void)
  181. {
  182. pglBegin =        (glBegin_t)       Detour1((LPBYTE)glBegin,       (LPBYTE)new_glBegin, 6);
  183. pglViewport =     (glViewport_t)    Detour1((LPBYTE)glViewport,    (LPBYTE)new_glViewport, 7);
  184. pglVertex3fv =    (glVertex3fv_t)   Detour1((LPBYTE)glVertex3fv,   (LPBYTE)new_glVertex3fv, 6);
  185. pglVertex2f =     (glVertex2f_t)    Detour1((LPBYTE)glVertex2f,    (LPBYTE)new_glVertex2f, 6);
  186. }
  187.  
  188. ///////////////////////////////////////////////////////////////////////////////////////
  189.  
  190. bool APIENTRY DllMain(HANDLE hModule, DWORD  dwReason, LPVOID lpReserved)
  191. {
  192. if(dwReason == DLL_PROCESS_ATTACH)
  193. {
  194. // No es necesario este Detour para la demostración..
  195. pGetProcAddress = (GetProcAddress_t)Detour1((LPBYTE)GetProcAddress,
  196. (LPBYTE)new_GetProcAddress, 5);
  197.  
  198. if(GetModuleHandle("Opengl32.dll"))
  199. Hook();
  200. }
  201. else if(dwReason == DLL_PROCESS_DETACH)
  202. {
  203. // Restaurar bytes en GPA
  204.  
  205. // (no hace falta suspender el mismo hilo! no sirve para nada XD)
  206.  
  207. // Salida con retardo.
  208. // Permite que se ejecuten los últimos llamados a GPA
  209. // (Y no hace falta restaurar los bytes parcheados XD)
  210. ExitProcess(100);
  211. }
  212. return (true);
  213. }
  214.  
  215. ///////////////////////////////////////////////////////////////////////////////////////
  216.  
  217.  

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

4  Programación / Desarrollo Web / Detener registraciones spam en vBulletin en: 9 Abril 2013, 17:34 pm
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.

Código:
<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.

Código:
<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.

Código:
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.
5  Programación / Programación C/C++ / MS Detours 2.1 para interceptar Opengl32 en: 8 Abril 2013, 00:34 am
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.

Código
  1.  
  2. //
  3. // Modifications: By 85
  4. // Credits: Xantrax, MS Detours 2.1
  5. // elhacker.net
  6. // etalking.com.ar
  7. // david_bs@live.com
  8. // 2013
  9. //
  10.  
  11. ///////////////////////////////////////////////////////////////////////////////////////
  12.  
  13. #pragma comment(lib,"detours.lib")// 1.5
  14. #pragma comment(lib,"OpenGL32.lib")
  15. #include <windows.h>
  16. #include <gl/gl.h>
  17. #include<stdio.h>
  18.  
  19. #include "detours.h"
  20.  
  21. ///////////////////////////////////////////////////////////////////////////////////////
  22.  
  23. bool bOGLSubtractive = false;
  24. bool g_bSky = false;
  25.  
  26. ///////////////////////////////////////////////////////////////////////////////////////
  27.  
  28. class CDraw {
  29. public:
  30. CDraw();
  31. int m_iVpCounter;
  32. bool m_bDrawing;
  33. void DrawPanel();
  34. };
  35.  
  36. CDraw::CDraw( ){
  37. m_iVpCounter = 0;
  38. m_bDrawing = false;
  39. }
  40.  
  41. void CDraw::DrawPanel( ) {
  42.  
  43. //Drawing Every 5th here
  44. }
  45.  
  46. CDraw* pDraw = new CDraw();
  47.  
  48. ///////////////////////////////////////////////////////////////////////////////////////
  49.  
  50. /* function prototype and original target */
  51.  
  52. DETOUR_TRAMPOLINE( VOID WINAPI Trampoline_glBegin( GLenum mode ), glBegin );
  53. DETOUR_TRAMPOLINE( VOID WINAPI Trampoline_glViewport( GLint x,  GLint y,  GLsizei width,  GLsizei height ), glViewport );
  54. DETOUR_TRAMPOLINE( VOID WINAPI Trampoline_glVertex3fv( const GLfloat *v ), glVertex3fv  );
  55. DETOUR_TRAMPOLINE( VOID WINAPI Trampoline_glVertex3f( GLfloat x, GLfloat y, GLfloat z ), glVertex3f );
  56. DETOUR_TRAMPOLINE( VOID WINAPI Trampoline_glShadeModel( GLenum mode ), glShadeModel );
  57. DETOUR_TRAMPOLINE( VOID WINAPI Trampoline_glClear( GLbitfield mask ), glClear );
  58. DETOUR_TRAMPOLINE( VOID WINAPI Trampoline_glColor3f( GLfloat red, GLfloat green, GLfloat blue ), glColor3f );
  59. typedef void (WINAPI* wglSwapBuffers_t)(HDC);
  60.  
  61. ///////////////////////////////////////////////////////////////////////////////////////
  62.  
  63. //#define HIWORD(l)           ((WORD)((DWORD_PTR)(l) >> 16))
  64.  
  65. DETOUR_TRAMPOLINE(FARPROC WINAPI Trampoline_GetProcAddress(HMODULE hModule,
  66.  LPCSTR lpProcName), GetProcAddress);
  67.  
  68. ///////////////////////////////////////////////////////////////////////////////////////
  69.  
  70. VOID WINAPI glBeginDetour(GLenum mode)
  71. {
  72. if(mode == GL_TRIANGLE_STRIP || mode == GL_TRIANGLE_FAN)
  73. glDepthRange( 0, 0.5 );
  74. else
  75. glDepthRange( 0.5, 1 );
  76.  
  77. if(mode == GL_TRIANGLE_STRIP || mode == GL_TRIANGLE_FAN)
  78. glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_DECAL);
  79.  
  80. if( mode == GL_QUADS )
  81. g_bSky = true;
  82. else
  83. g_bSky = false;
  84.  
  85. Trampoline_glBegin(mode);
  86. }
  87.  
  88. ///////////////////////////////////////////////////////////////////////////////////////
  89.  
  90. VOID WINAPI glClearDetour(GLbitfield mask)
  91. {
  92. if(mask==GL_DEPTH_BUFFER_BIT)
  93. {
  94. mask+=GL_COLOR_BUFFER_BIT;
  95. glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  96.  
  97. Trampoline_glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
  98. return;
  99. }
  100.  
  101. Trampoline_glClear(mask);
  102. }
  103.  
  104. ///////////////////////////////////////////////////////////////////////////////////////
  105.  
  106. VOID WINAPI glShadeModelDetour(GLenum mode)
  107. {
  108. //XQZ2 wallhack
  109. if( mode == GL_SMOOTH ){
  110. __asm {
  111. push 0x00000100 //GL_DEPTH_BUFFER_BIT
  112. call dword ptr[ Trampoline_glClear ]
  113. }
  114. }
  115.  
  116. Trampoline_glShadeModel(mode);
  117. }
  118.  
  119. ///////////////////////////////////////////////////////////////////////////////////////
  120.  
  121. VOID WINAPI glViewportDetour(GLint x, GLint y, GLsizei width, GLsizei height)
  122. {
  123. pDraw->m_iVpCounter++;
  124. if( pDraw->m_iVpCounter >= 5 ){
  125. pDraw->m_bDrawing = true;
  126. }
  127. Trampoline_glViewport(x, y, width, height);
  128. }
  129.  
  130. ///////////////////////////////////////////////////////////////////////////////////////
  131.  
  132. VOID WINAPI glColor3fDetour(GLfloat red, GLfloat green, GLfloat blue)
  133. {
  134. Trampoline_glColor3f(red, green, blue);
  135. }
  136.  
  137. ///////////////////////////////////////////////////////////////////////////////////////
  138.  
  139. VOID WINAPI glVertex3fvDetour(const GLfloat* v)
  140. {
  141. if(g_bSky && v[2]>300){
  142.  
  143. return;
  144. /*float flZero = 0.0f;
  145. __asm {
  146. push flZero
  147. push flZero
  148. push flZero
  149. call dword ptr[ Trampoline_glColor3f ]
  150. }*/
  151. }
  152. Trampoline_glVertex3fv(v);
  153. }
  154.  
  155. ///////////////////////////////////////////////////////////////////////////////////////
  156.  
  157. VOID WINAPI glVertex3fDetour(GLfloat x, GLfloat y, GLfloat z)
  158. {
  159. Trampoline_glVertex3f(x, y, z);
  160. }
  161.  
  162. ///////////////////////////////////////////////////////////////////////////////////////
  163.  
  164. wglSwapBuffers_t pwglSwapBuffers = NULL;
  165. // DETOUR_TRAMPOLINE(void WINAPI _wglSwapBuffers(HDC hDC), wglSwapBuffers);
  166. // since wglSwapBuffers is undefined, the macro wont work. this is, what it basically does:
  167. static PVOID __fastcall _Detours_GetVA_wglSwapBuffers(VOID)
  168. {
  169.    return pwglSwapBuffers;
  170. }
  171.  
  172. ///////////////////////////////////////////////////////////////////////////////////////
  173.  
  174. __declspec(naked) void WINAPI _Trampoline_wglSwapBuffers(HDC hDC)
  175. {
  176.    __asm { nop };
  177.    __asm { nop };
  178.    __asm { call _Detours_GetVA_wglSwapBuffers };
  179.    __asm { jmp eax };
  180.    __asm { ret };
  181.    __asm { nop };
  182.    __asm { nop };
  183.    __asm { nop };
  184.    __asm { nop };
  185.    __asm { nop };
  186.    __asm { nop };
  187.    __asm { nop };
  188.    __asm { nop };
  189.    __asm { nop };
  190.    __asm { nop };
  191.    __asm { nop };
  192.    __asm { nop };
  193.    __asm { nop };
  194.    __asm { nop };
  195.    __asm { nop };
  196.    __asm { nop };
  197.    __asm { nop };
  198.    __asm { nop };
  199.    __asm { nop };
  200.    __asm { nop };
  201.    __asm { nop };
  202.    __asm { nop };
  203. }
  204.  
  205. ///////////////////////////////////////////////////////////////////////////////////////
  206.  
  207. VOID WINAPI _wglSwapBuffers(HDC hDC)
  208. {
  209. pDraw->m_iVpCounter = 0;
  210. _Trampoline_wglSwapBuffers( hDC );
  211. }
  212.  
  213. ///////////////////////////////////////////////////////////////////////////////////////
  214.  
  215. void DetourOpenGL()
  216. {
  217. #define Detour( pbTrampFunc, pbDetourFunc )\
  218. DetourFunctionWithTrampoline( (PBYTE)##pbTrampFunc,( PBYTE )##pbDetourFunc )
  219.  
  220. Detour( Trampoline_glBegin, glBeginDetour );
  221. Detour( Trampoline_glVertex3fv, glVertex3fvDetour );
  222. Detour( Trampoline_glClear, glClearDetour );
  223. /*
  224. Detour( Trampoline_glShadeModel, glShadeModelDetour );
  225. Detour( Trampoline_glViewport, glViewportDetour );
  226. Detour( Trampoline_glVertex3f, glVertex3fDetour );
  227.  
  228. // Because wglSwapBuffers isnt declared in GL\GL.h...
  229. pwglSwapBuffers = (wglSwapBuffers_t)GetProcAddress(LoadLibrary("opengl32.dll"),
  230. "wglSwapBuffers");
  231. Detour( _Trampoline_wglSwapBuffers, _wglSwapBuffers);
  232.  
  233. Detour( Trampoline_glColor3f, glColor3fDetour );*/
  234. }
  235.  
  236. ///////////////////////////////////////////////////////////////////////////////////////
  237.  
  238. void RemoveOpenGLDetour()
  239. {
  240. #define Destroy( pbTrampFunc, pbDetourFunc )\
  241. DetourRemove( (PBYTE)##pbTrampFunc,( PBYTE )##pbDetourFunc )
  242.  
  243. Destroy( Trampoline_glBegin, glBeginDetour );
  244. Destroy( Trampoline_glVertex3fv, glVertex3fvDetour );
  245. Destroy( Trampoline_glClear, glClearDetour );
  246. /*
  247. Destroy( Trampoline_glShadeModel, glShadeModelDetour );
  248. Destroy( Trampoline_glViewport, glViewportDetour );
  249. Destroy( Trampoline_glVertex3f, glVertex3fDetour );
  250.  
  251. Destroy( Trampoline_glColor3f, glColor3fDetour );*/
  252. }
  253.  
  254. ///////////////////////////////////////////////////////////////////////////////////////
  255.  
  256. FARPROC WINAPI GetProcAddressDetour(HMODULE hModule, LPCSTR lpProcName)
  257. {
  258. FARPROC retval = Trampoline_GetProcAddress(hModule, lpProcName);
  259. return retval;
  260. }
  261.  
  262. ///////////////////////////////////////////////////////////////////////////////////////
  263.  
  264. BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
  265. {
  266. switch(ul_reason_for_call)
  267. {
  268. case DLL_PROCESS_ATTACH://Let the magic happen...:->
  269. DetourOpenGL();
  270. //Extras
  271. /* DetourFunctionWithTrampoline((PBYTE)Trampoline_GetProcAddress,
  272. (PBYTE)GetProcAddressDetour);*/
  273. break;
  274. case DLL_PROCESS_DETACH:
  275. RemoveOpenGLDetour();
  276. break;
  277. }
  278.    return TRUE;
  279. }
  280.  
  281. ///////////////////////////////////////////////////////////////////////////////////////
  282.  

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

6  Programación / Programación C/C++ / compiladores online de C/C++ en: 5 Abril 2013, 14:53 pm
Algunos sitios web que ofrecen la posibilidad de compilar, depurar y ejecutar un programa en C/C++

http://codepad.org/

Me gusta XD
http://www.compileonline.com/compile_cpp_online.php

http://isocpp.org/blog/2013/01/online-c-compilers

http://liveworkspace.org/

http://gcc.godbolt.org/

https://compilr.com/c-compiler

mucho mejor para hacer pruebas rápidas de los códigos que aparecen por el foro  >:D




7  Programación / Programación C/C++ / Wrapper de Opengl32.dll de Crusader (2002) en: 4 Abril 2013, 02:37 am
Hola, como había estado comentado algunas cosas acerca de reemplazar DLLs existentes con versiones propias,
http://foro.elhacker.net/programacion_cc/dll_wrapper_1_creando_nuestra_psapidll_con_def-t386996.0.html

justo me había acordado de una 'wrapper' muy famosa en el ambiente del hacking de juegos.
Es del 2002 de un programador llamado Crusader, y durante un tiempo esto había servido para utilizar wallhacks en el Counter-Strike, aunque se debería poder usarse en otros juegos basados en Opengl32.

este es el link del proyecto
http://www.mediafire.com/?zad5ce1gd8lr8k2

Lo que hice fue agregar algunas líneas para remover el cielo y para un wallhack. La DLL de reemplazo (wrapper) se debe poner en la carpeta del juego (ver imagen 1).

Esto es detectado por los sistemas antitrampas, validan los archivos y las rutas. Pero puede servir a alguien para practicar con Opengl32.
Con los hacks se aprende XD



8  Programación / Programación C/C++ / DLL wrapper 1: Creando nuestra psapi.dll sin .DEF en: 2 Abril 2013, 17:24 pm
NIVEL: Beginner
Test: WinXP SP3 32BITS

Tomando en cuenta el tutorial anterior acerca del creamiento de una versión propia de una DLL conocida,
http://foro.elhacker.net/programacion_cc/dll_wrapper_1_creando_nuestra_psapidll_con_def-t386996.0.html

Algo que se denominaba ‘wrapper’, en este caso vamos a hacer lo mismo pero sin la necesidad de usar un archivo .DEF para los símbolos exportados.
El tema es que para hacer la exportación de símbolos en este caso sin usar .DEF tenemos que utilizar en nuestras funciones de reemplazo, el nombre completo y correcto de las funciones originales.
 
Primero vayamos a las opciones del proyecto, y veamos que la opción de la convención de llamada  esté en __cdecl, porque si bien sabíamos que PSAPI usaba __stdcall, pero lo que vamos a hacer en esta ocasión es especificarlo explícitamente en el código, para cada función.
Por defecto siempre esta opción se encuentra en __cdecl, en otras palabras lo que quiero decir es que lo dejen así..



Empecemos diciendo en lo que es similar al anterior método, por ejemplo los prototipos de las funciones. Veamos una definición de tipo para la función EnumProcesses en main.cpp
 
Código
  1. typedef BOOL (WINAPI* EnumProcesses_t)(DWORD*,DWORD,DWORD*);

Una declaración de puntero a función
Código
  1. BOOL (WINAPI* pEnumProcesses)(DWORD*,DWORD,DWORD*);

Veamos como se expecifica explícitamente la convención de llamada __stdcall (WINAPI).
La definición de nuestra función de reemplazo, que como habíamos visto antes, retorna el puntero a función original. En este caso a la EnumProcesses original en la DLL original que renombramos PSAPI2.DLL
Código
  1. BOOL WINAPI newEnumProcesses(DWORD* pProcessIds, DWORD cb, DWORD* pBytesReturned)
  2. {
  3.      return pEnumProcesses(pProcessIds, cb, pBytesReturned);
  4. }

El tema es que como no estamos usando un .DEF tenemos que especificar en el código, qué funciones son las que van a ser exportadas. Esto se hace con __declspec (dllexport)
 
Veamos una macro que al mismo tiempo también especifica que se trata de un estilo de función de C con lo cual evitamos el planchado de nombres en los símbolos exportados.
Código
  1. #define DLLEXPORTING extern "C" __declspec (dllexport)

 Más información acerca de esto:
 http://msdn.microsoft.com/es-es/library/a90k134d(v=vs.80).aspx
http://msdn.microsoft.com/en-us/library/a90k134d(v=vs.80).aspx
http://msdn.microsoft.com/es-AR/library/0603949d(v=vs.80).aspx
http://msdn.microsoft.com/en-us/library/aa278942(v=vs.60).aspx

En el compilador vamos a dejar que la convención de llamada por defecto sea __cdecl, y vamos a valernos de especificar __stdcall en los prototipos o definiciones de tipos y en los punteros a función, como ya vimos.
En el anterior tutorial, teníamos 2 instancias de funciones de reemplazo para cada función que íbamos a exportar. Y vimos que la segunda instancia no era necesaria antes, pero ahora si lo va a ser.
 
Veamos exports.cpp
Esta es la segunda instancia, debe ser del tipo __cdecl para ser compatible con la directiva extern “C”, y al mismo tiempo debe ser el símbolo marcado para ser exportado, eso se hace con __declspec (dllexport) como dijimos antes. Y por último, el nombre de esta función debe ser exactamente igual al de la original.

Código
  1. DLLEXPORTING BOOL EnumProcesses(DWORD* pProcessIds, DWORD cb, DWORD* pBytesReturned)
  2. {
  3.       //return newEnumProcesses(pProcessIds, cb, pBytesReturned);
  4. }

Por eso si la convención de llamada por defecto es __cdecl entonces esta función tendría esa convención.
Por eso dije antes que la dejen como estaba a la opción esa. De otra forma debería especificar __cdecl
explícitamente en la definición de la función.
 
En teoría debería deberíamos usar el puntero a la función original a modo de una llamada a función por puntero (ya sea como return+puntero o sólo el puntero si se trata de una función de tipo void).
 
Es en este punto donde necesitamos ver este tutorial anterior en el cual se comentaba un caso en el cual el compilador genera código de stack frame dentro de la función lo cual altera la pila y el registro EBP.
Link:
http://foro.elhacker.net/programacion_cc/gltest1_problema_con_la_convencion_de_llamada-t384879.0.html
 
Esta situación no es diferente a la del enlace anterior, por lo que la solución es la misma; nuestra función de reemplazo de tipo __cdecl va a tener que restaurar el registro EBP antes de saltar a la función original.
Vamos a utilizar la instrucción JMP para ir a la original y no la instrucción CALL (aunque vimos que se puede).
 
Código
  1. DLLEXPORTING BOOL EnumProcesses(DWORD* pProcessIds, DWORD cb, DWORD* pBytesReturned)
  2. {
  3.             int a = 85;
  4.             a = 85 - 85 + 85;
  5.             // usa ebp
  6.             // agrega edi al stack
  7.             // add esp, 0x14
  8.  
  9.             __asm mov eax,[esp+0x10]
  10.             __asm mov EnumProcesses_ebp_save,eax
  11.             __asm mov ebp,EnumProcesses_ebp_save
  12.             __asm add esp,0x14//debe borrar hasta ebp, no más que eso (no el retaddress ni los argumentos)
  13.             __asm jmp newEnumProcesses
  14.             //return newEnumProcesses(pProcessIds, cb, pBytesReturned);
  15. }

El fix con ensamblador en línea (inline ASM), guarda el registro EBP y lo restaura antes de saltar a la función original, también se deja la pila equilibrada con ADD ESP, X
Tanto la ubicación del EBP original en la pila como la cantidad de espacios que se deben reducir para equilibrar la misma, se deben obtener de un desensamblador por ejemplo. Sino, pueden utilizar un depurador como el OllyDBG.
 
Veamos igualmente una imagen de como resulta el código de ensamblador:



Citar
10001000 >  55                           PUSH EBP
10001001    8BEC                        MOV EBP,ESP
10001003    51                            PUSH ECX
10001004    53                            PUSH EBX
10001005    56                            PUSH ESI
10001006    57                            PUSH EDI
10001007    C745 FC 5500000>      MOV DWORD PTR SS:[EBP-4],55
1000100E    C745 FC 5500000>      MOV DWORD PTR SS:[EBP-4],55
10001015    8B4424 10                 MOV EAX,DWORD PTR SS:[ESP+10]
10001019    A3 D0320010             MOV DWORD PTR DS:[100032D0],EAX
1000101E    8B2D D0320010          MOV EBP,DWORD PTR DS:[100032D0]
10001024    83C4 14                    ADD ESP,14
10001027    E9 64040000             JMP psapi.10001490
1000102C    5F                           POP EDI
1000102D    5E                           POP ESI
1000102E    5B                           POP EBX
1000102F    8BE5                        MOV ESP,EBP
10001031    5D                           POP EBP
10001032    C3                           RETN

Como ustedes pueden ver se genera al final este código:
Citar
1000102C 5F POP EDI
1000102D 5E POP ESI
1000102E 5B POP EBX
1000102F 8BE5 MOV ESP,EBP
10001031 5D POP EBP
Lo cual es una correcta liberación de pila, pero el problema es que este código no se genera sino usamos el fix.

Como ya dije, es la misma situación que la del tutorial de convención de llamada para un caso con Opengl32.
 
El resultado es una DLL wrapper de PSAPI.DLL que no requiere .DEF para realizar las exportaciones.
Psapi.lib tampoco es requerida, recordemos que hacemos un enlazamiento dinámico con la DLL PSAPI.DLL original (que renombramos a PSAPI2.DLL).

Y los nombres de los EXPORTS no resultan cambiados.



Funciona.



Proyecto VC++6:
http://www.mediafire.com/?8su3luoh0r72ypf

Saludos
9  Programación / Programación C/C++ / DLL wrapper 1: Creando nuestra psapi.dll con .DEF en: 2 Abril 2013, 17:11 pm
NIVEL: Beginner
Test: WinXP SP3
 
Este tutorial te va a enseñar como crear algo conocido como ‘Wrapper’ de una DLL, cuya traducción es ‘envoltura’ pero se conoce con el término del inglés directamente. Las wrappers son versiones propias de DLL’s conocidas. En este caso vamos a hacer un wrapper de una DLL muy conocida llamada PSAPI.DLL.
Si no la conocen investíguenla XD, pero se trata de una DLL bastante común encontrarla cargada en muchos procesos.
La técnica de construir wrappers tiene al menos 2 objetivos:
1: Hooking. ya que nuestra propia versión de la DLL va a contener nuestras propias versiones de las funciones originales, y al mismo
Tiempo necesitamos llamar a las originales dentro de las nuestras.
El tema es que podemos ejecutar nuestro código antes de que se ejecute el código original.
2: Cargar una DLL. Lo que estamos haciendo al crear nuestra propia versión de una DLL conocida es hacer que al programa víctima se le cargue nuestra DLL en lugar de la original. Esta carga no la hace el programa víctima sino el sistema operativo. El SO detecta nuestra DLL en la misma ubicación que el archivo ejecutable del programa y la carga automáticamente, ya que existe una dependencia real con la DLL.
 
En cuanto a seguridad, es una técnica no efectiva para crear un hack para un programa que tenga seguridad. Sería muy fácil validar los archivos en disco que se cargan al proceso (con MD5 por ejemplo), o validar las rutas, etc etc
Mientras no sea para nada de hacking, tiene cierto atractivo esta idea XD.
 
Acerca de como se crea algo así.. Bueno lo primero es conocer la DLL original que queremos reemplazar, es decir todas sus funciones o al menos las que el proceso víctima utilice (dependencias).

Esto significa que debemos conocer los prototipos de estas funciones, incluyendo su convención de llamada y demás.
Teniendo eso en primer lugar, vamos a considerar que también necesitamos usar la DLL original porque dependemos de las funciones originales. Esto se resuelve cambiándole el nombre a la DLL original. En el caso de PSAPI.DLL lo podemos cambiar a PSAPI2.DLL.
Luego vamos a necesitar cargar la DLL original renombrada y hacer un enlazamiento dinámico con ella,  y conseguir las direcciones originales de las funciones que necesitamos. Obviamente esto lo hacemos con LoadLibrary + GetProcAddress.
Luego en nuestra propia DLL ponemos las funciones de reemplazo respetando los prototipos y le ponemos las direcciones de retorno a las originales que importamos dinámicamente con GetProcAddress.
Utilizamos obviamente punteros a función para los retornos en las funciones de reemplazo (hooks).

La convención de llamada usada en PSAPI.DLL para las funciones es __stdcall, por eso podemos hacer que todas las funciones en nuestro proyecto sean por defecto __stdcall para no tener que especificarlo explícitamente en cada una.


Veamos a PSAPI.DLL


Veamos sus exportaciones.


Vamos a concentrarnos en una de sus funciones sólamente, por ejemplo EnumProcesses
 

Necesitamos un prototipo de función, definamos un tipo de dato correspondiente a esta función.
Código
  1. typedef BOOL (* EnumProcesses_t)(DWORD*,DWORD,DWORD*);

Creamos un puntero a función que va a servir de retorno a la original dentro de la función de reemplazo.
Código
  1. BOOL (* pEnumProcesses)(DWORD*,DWORD,DWORD*);

Creamos la función de reemplazo (vemos que retorna con el puntero a la original)
Código
  1. BOOL  newEnumProcesses(DWORD* pProcessIds, DWORD cb, DWORD* pBytesReturned)
  2. {
  3.     return pEnumProcesses(pProcessIds, cb, pBytesReturned);
  4. }

Ahora creamos otra instancia más (no realmente necesaria en este caso), esta función va a ser la que se exporte para que pueda ser usada por el programa víctima.
Código
  1. BOOL  _EnumProcesses(DWORD* pProcessIds, DWORD cb, DWORD* pBytesReturned)
  2. {
  3.     return newEnumProcesses(pProcessIds, cb, pBytesReturned);
  4. }

Y básicamente hacer lo mismo con las demás funciones XD.
Para compilar este proyecto se requiere del archivo psapi.h que contiene los tipos de datos usados en las funciones de reemplazo. No se requiere psapi.lib que es una librería de enlazamiento estático.
 
Vamos a necesitar un archivo .DEF que debe ser incluído en el proyecto.
Hay unas reglas para usar el .DEF y estas son:
1: se debe empezar poniendo LIBRARY y seguido el nombre de la DLL.
2: se debe poner EXPORTS
3: se deben poner uno por uno, los nombres que deseamos para cada símbolo, seguido de cada
Nombre debe ir el signo ‘=’ y el nombre real del símbolo, el cual obtenemos del desensamblado.
4: seguido a lo anterior se deja un espacio y se coloca un ‘arroba' y el número de índice de exportación.
 
Pero veamos una imagen para entender como se hace:
 

Veamos el código de la DLL:

En main.cpp se encuentran los prototipos de las funciones y los punteros a funciones. Para no poner todo veamos sólo el caso de EnumProcesses

Código
  1. typedef BOOL (* EnumProcesses_t)(DWORD*,DWORD,DWORD*);
  2.  

Código
  1. BOOL (* pEnumProcesses)(DWORD*,DWORD,DWORD*);
  2.  

Luego tenemos las funciones de reemplazo. Estas retornan un puntero a función.
Código
  1. BOOL  newEnumProcesses(DWORD* pProcessIds, DWORD cb, DWORD* pBytesReturned)
  2. {
  3.     return pEnumProcesses(pProcessIds, cb, pBytesReturned);
  4. }


Luego se muestra un código que se trata de una clase y la creación de un objeto de tipo de la clase, esto busca que se inicializen los punteros a función cuando el programa es ejecutado, ya que cuando se crea el objeto se ejecuta la rutina que inicializa los punteros a función.
Código
  1. /*
  2. class Inicializar
  3. {
  4. public:
  5.     Inicializar()
  6.     {
  7.         pEnumProcesses = 0;
  8.         pEnumProcessModules = 0;
  9.         pGetModuleBaseNameA = 0;
  10.         pGetModuleBaseNameW = 0;
  11.         pGetModuleFileNameExA = 0;
  12.         pGetModuleFileNameExW = 0;
  13.         pGetModuleInformation = 0;
  14.         pEmptyWorkingSet = 0;
  15.         pQueryWorkingSet = 0;
  16.         pInitializeProcessForWsWatch = 0;    
  17.         pGetWsChanges = 0;
  18.         pGetMappedFileNameW = 0;
  19.         pGetMappedFileNameA = 0;
  20.         pEnumDeviceDrivers = 0;
  21.         pGetDeviceDriverBaseNameA = 0;
  22.         pGetDeviceDriverBaseNameW = 0;
  23.         pGetDeviceDriverFileNameA = 0;
  24.         pGetDeviceDriverFileNameW = 0;
  25.         pGetProcessMemoryInfo = 0;
  26.         pEnumPageFilesA =0;
  27.         pEnumPageFilesW =0;
  28.         pGetPerformanceInfo =0;
  29.         pGetProcessImageFileNameA =0;
  30.         pGetProcessImageFileNameW=0;
  31.  
  32.         HINSTANCE myDLL;
  33.         myDLL = LoadLibrary("psapi2.dll");
  34.  
  35.         if(myDLL != NULL)
  36.         {
  37.            pEnumProcesses = (EnumProcesses_t)GetProcAddress(myDLL, "EnumProcesses");
  38.            pEnumProcessModules = (EnumProcessModules_t)GetProcAddress(myDLL, "EnumProcessModules");
  39.            pGetModuleBaseNameA = (GetModuleBaseNameA_t)GetProcAddress(myDLL, "GetModuleBaseNameA");
  40.            pGetModuleBaseNameW = (GetModuleBaseNameW_t)GetProcAddress(myDLL, "GetModuleBaseNameW");
  41.            pGetModuleFileNameExA = (GetModuleFileNameExA_t)GetProcAddress(myDLL, "GetModuleFileNameExA");
  42.            pGetModuleFileNameExW = (GetModuleFileNameExW_t)GetProcAddress(myDLL, "GetModuleFileNameExW");
  43.            pGetModuleInformation = (GetModuleInformation_t)GetProcAddress(myDLL, "GetModuleInformation");
  44.            pEmptyWorkingSet = (EmptyWorkingSet_t)GetProcAddress(myDLL, "EmptyWorkingSet");
  45.            pQueryWorkingSet = (QueryWorkingSet_t)GetProcAddress(myDLL, "QueryWorkingSet");
  46.            pInitializeProcessForWsWatch = (InitializeProcessForWsWatch_t)GetProcAddress(myDLL, "InitializeProcessForWsWatch");        
  47.            pGetWsChanges = (GetWsChanges_t)GetProcAddress(myDLL, "GetWsChanges");
  48.            pGetMappedFileNameW = (GetMappedFileNameW_t)GetProcAddress(myDLL, "GetMappedFileNameW");
  49.            pGetMappedFileNameA = (GetMappedFileNameA_t)GetProcAddress(myDLL, "GetMappedFileNameA");
  50.            pEnumDeviceDrivers = (EnumDeviceDrivers_t)GetProcAddress(myDLL, "EnumDeviceDrivers");
  51.            pGetDeviceDriverBaseNameA = (GetDeviceDriverBaseNameA_t)GetProcAddress(myDLL, "GetDeviceDriverBaseNameA");
  52.            pGetDeviceDriverBaseNameW = (GetDeviceDriverBaseNameW_t)GetProcAddress(myDLL, "GetDeviceDriverBaseNameW");
  53.            pGetDeviceDriverFileNameA = (GetDeviceDriverFileNameA_t)GetProcAddress(myDLL, "GetDeviceDriverFileNameA");
  54.            pGetDeviceDriverFileNameW = (GetDeviceDriverFileNameW_t)GetProcAddress(myDLL, "GetDeviceDriverFileNameW");
  55.            pGetProcessMemoryInfo = (GetProcessMemoryInfo_t)GetProcAddress(myDLL, "GetProcessMemoryInfo");
  56.            pEnumPageFilesA =(EnumPageFilesA_t)GetProcAddress(myDLL, "EnumPageFilesA");
  57.            pEnumPageFilesW =(EnumPageFilesW_t)GetProcAddress(myDLL, "EnumPageFilesW");
  58.            pGetPerformanceInfo =(GetPerformanceInfo_t)GetProcAddress(myDLL, "GetPerformanceInfo");
  59.            pGetProcessImageFileNameA =(GetProcessImageFileNameA_t)GetProcAddress(myDLL, "GetProcessImageFileNameA");
  60.            pGetProcessImageFileNameW =(GetProcessImageFileNameW_t)GetProcAddress(myDLL, "GetProcessImageFileNameW");
  61.         }
  62.     }
  63. };
  64.  
  65.  
  66. //
  67. Inicializar Init;
  68. */
  69.  
  70.  

Eso está comentado porque ya se hace en 'DllMain' directamente, junto con un LOG de información.
Código
  1.  
  2. BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved )
  3. {
  4.    switch (ul_reason_for_call)
  5.    {
  6.        case DLL_PROCESS_ATTACH:
  7.            {
  8.                pEnumProcesses = 0;
  9.                pEnumProcessModules = 0;
  10.                pGetModuleBaseNameA = 0;
  11.                pGetModuleBaseNameW = 0;
  12.                pGetModuleFileNameExA = 0;
  13.                pGetModuleFileNameExW = 0;
  14.                pGetModuleInformation = 0;
  15.                pEmptyWorkingSet = 0;
  16.                pQueryWorkingSet = 0;
  17.                pInitializeProcessForWsWatch = 0;    
  18.                pGetWsChanges = 0;
  19.                pGetMappedFileNameW = 0;
  20.                pGetMappedFileNameA = 0;
  21.                pEnumDeviceDrivers = 0;
  22.                pGetDeviceDriverBaseNameA = 0;
  23.                pGetDeviceDriverBaseNameW = 0;
  24.                pGetDeviceDriverFileNameA = 0;
  25.                pGetDeviceDriverFileNameW = 0;
  26.                pGetProcessMemoryInfo = 0;
  27.                pEnumPageFilesA =0;
  28.                pEnumPageFilesW =0;
  29.                pGetPerformanceInfo =0;
  30.                pGetProcessImageFileNameA =0;
  31.                pGetProcessImageFileNameW=0;
  32.  
  33.                HINSTANCE myDLL;
  34.                myDLL = LoadLibrary("psapi2.dll");
  35.  
  36.                if(myDLL != NULL)
  37.                {
  38.                   pEnumProcesses = (EnumProcesses_t)GetProcAddress(myDLL, "EnumProcesses");
  39.                   pEnumProcessModules = (EnumProcessModules_t)GetProcAddress(myDLL, "EnumProcessModules");
  40.                   pGetModuleBaseNameA = (GetModuleBaseNameA_t)GetProcAddress(myDLL, "GetModuleBaseNameA");
  41.                   pGetModuleBaseNameW = (GetModuleBaseNameW_t)GetProcAddress(myDLL, "GetModuleBaseNameW");
  42.                   pGetModuleFileNameExA = (GetModuleFileNameExA_t)GetProcAddress(myDLL, "GetModuleFileNameExA");
  43.                   pGetModuleFileNameExW = (GetModuleFileNameExW_t)GetProcAddress(myDLL, "GetModuleFileNameExW");
  44.                   pGetModuleInformation = (GetModuleInformation_t)GetProcAddress(myDLL, "GetModuleInformation");
  45.                   pEmptyWorkingSet = (EmptyWorkingSet_t)GetProcAddress(myDLL, "EmptyWorkingSet");
  46.                   pQueryWorkingSet = (QueryWorkingSet_t)GetProcAddress(myDLL, "QueryWorkingSet");
  47.                   pInitializeProcessForWsWatch = (InitializeProcessForWsWatch_t)GetProcAddress(myDLL, "InitializeProcessForWsWatch");        
  48.                   pGetWsChanges = (GetWsChanges_t)GetProcAddress(myDLL, "GetWsChanges");
  49.                   pGetMappedFileNameW = (GetMappedFileNameW_t)GetProcAddress(myDLL, "GetMappedFileNameW");
  50.                   pGetMappedFileNameA = (GetMappedFileNameA_t)GetProcAddress(myDLL, "GetMappedFileNameA");
  51.                   pEnumDeviceDrivers = (EnumDeviceDrivers_t)GetProcAddress(myDLL, "EnumDeviceDrivers");
  52.                   pGetDeviceDriverBaseNameA = (GetDeviceDriverBaseNameA_t)GetProcAddress(myDLL, "GetDeviceDriverBaseNameA");
  53.                   pGetDeviceDriverBaseNameW = (GetDeviceDriverBaseNameW_t)GetProcAddress(myDLL, "GetDeviceDriverBaseNameW");
  54.                   pGetDeviceDriverFileNameA = (GetDeviceDriverFileNameA_t)GetProcAddress(myDLL, "GetDeviceDriverFileNameA");
  55.                   pGetDeviceDriverFileNameW = (GetDeviceDriverFileNameW_t)GetProcAddress(myDLL, "GetDeviceDriverFileNameW");
  56.                   pGetProcessMemoryInfo = (GetProcessMemoryInfo_t)GetProcAddress(myDLL, "GetProcessMemoryInfo");
  57.                   pEnumPageFilesA =(EnumPageFilesA_t)GetProcAddress(myDLL, "EnumPageFilesA");
  58.                   pEnumPageFilesW =(EnumPageFilesW_t)GetProcAddress(myDLL, "EnumPageFilesW");
  59.                   pGetPerformanceInfo =(GetPerformanceInfo_t)GetProcAddress(myDLL, "GetPerformanceInfo");
  60.                   pGetProcessImageFileNameA =(GetProcessImageFileNameA_t)GetProcAddress(myDLL, "GetProcessImageFileNameA");
  61.                   pGetProcessImageFileNameW =(GetProcessImageFileNameW_t)GetProcAddress(myDLL, "GetProcessImageFileNameW");
  62.  
  63.                   DisableThreadLibraryCalls (myDLL);
  64.                }
  65.  
  66.                if(!pEnumProcesses||!pEnumProcessModules ||!pGetModuleBaseNameA ||!pGetModuleBaseNameW
  67.                    ||!pGetModuleFileNameExA ||!pGetModuleFileNameExW ||!pGetModuleInformation
  68.                    ||!pEmptyWorkingSet ||!pQueryWorkingSet
  69.  
  70.                    ||!pInitializeProcessForWsWatch ||!pGetWsChanges ||!pGetMappedFileNameW
  71.                    ||!pGetMappedFileNameA
  72.                    ||!pEnumDeviceDrivers ||!pGetDeviceDriverBaseNameA ||!pGetDeviceDriverBaseNameW
  73.                    ||!pGetDeviceDriverFileNameA ||!pGetDeviceDriverFileNameW ||!pGetProcessMemoryInfo
  74.                    ||!pEnumPageFilesA ||!pEnumPageFilesW
  75.                    ||!pGetPerformanceInfo ||!pGetProcessImageFileNameA ||!pGetProcessImageFileNameW)
  76.                {
  77.                    printf("Wrapper not installed!\n");
  78.                    system("pause");
  79.                }
  80.                else
  81.                {
  82.                    extern DWORD AddEnumProcesses;
  83.                    printf("DLL\n");
  84.                    printf("EnumProcesses 0x%x\n",AddEnumProcesses);
  85.                    printf("newEnumProcesses 0x%x\n",newEnumProcesses);
  86.                    printf("hModule 0x%x\n",hModule);
  87.                    printf("PSAPI2.DLL 0x%x\n",GetModuleHandle("psapi2.dll"));
  88.                    printf("pEnumProcesses 0x%x\n",pEnumProcesses);
  89.                    system("pause");
  90.                }
  91.            }
  92.            break;
  93.  
  94.        case DLL_THREAD_ATTACH:
  95.        case DLL_THREAD_DETACH:
  96.        case DLL_PROCESS_DETACH:
  97.        break;
  98.    }
  99.    return TRUE;
  100. }
  101.  
  102. ///////////////////////////////
  103.  

En exports.cpp sólamente tenemos las funciones de exportación, son las cuales son referenciadas en el archivo .DEF. Estas funciones retornan las funciones de reemplazo. Esto de tener 2 instancias no es necesario como ya se dijo, pero si lo es si se desea utilizar otro método que después voy a exponer.
Código
  1. BOOL  _EnumProcesses(DWORD* pProcessIds, DWORD cb, DWORD* pBytesReturned)
  2. {
  3.     return newEnumProcesses(pProcessIds, cb, pBytesReturned);
  4. }
  5.  

Veamos el código del programa ‘Dummy’ que actúa como el programa víctima:
 
Código
  1. //
  2. // By 85
  3. // elhacker.net
  4. // etalking.com.ar
  5. // david_bs@live.com
  6. // 2013
  7. //
  8.  
  9. #pragma comment(lib,"psapi.lib")
  10. #include<windows.h>
  11. #include<stdio.h>
  12.  
  13. //////////////////////
  14.  
  15. #define DLLIMPORTING extern "C" __declspec (dllimport)
  16. DLLIMPORTING BOOL WINAPI EnumProcesses(DWORD *,DWORD,DWORD *);
  17. DLLIMPORTING BOOL WINAPI EnumProcessModules(HANDLE,HMODULE *,DWORD,LPDWORD);
  18. DLLIMPORTING DWORD WINAPI GetModuleFileNameExA(HANDLE,HMODULE,LPSTR,DWORD);
  19. DLLIMPORTING DWORD WINAPI GetModuleFileNameExW(HANDLE,HMODULE,LPWSTR,DWORD);
  20.  
  21. DLLIMPORTING DWORD WINAPI GetModuleBaseNameA(HANDLE hProcess, HMODULE hModule, LPSTR lpBaseName, DWORD nSize);
  22. DLLIMPORTING DWORD WINAPI GetModuleBaseNameW(HANDLE hProcess,HMODULE hModule,LPWSTR lpwBaseName,DWORD nSize);
  23.  
  24. #ifdef UNICODE
  25. #define GetModuleFileNameEx GetModuleFileNameExW
  26. #define GetModuleBaseName GetModuleBaseNameW
  27. #else
  28. #define GetModuleFileNameEx GetModuleFileNameExA
  29. #define GetModuleBaseName GetModuleBaseNameA
  30. #endif
  31.  
  32. //////////////////////
  33.  
  34. // To ensure correct resolution of symbols, add Psapi.lib to TARGETLIBS
  35. // and compile with -DPSAPI_VERSION=1
  36. void PrintProcessNameAndID( DWORD processID )
  37. {
  38.      TCHAR szProcessName[MAX_PATH] = TEXT("<unknown>");
  39.  
  40.      // Get a handle to the process.
  41.      HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION |
  42.      PROCESS_VM_READ,
  43.      FALSE, processID );
  44.  
  45.     // Get the process name.
  46.     if (NULL != hProcess )
  47.     {
  48.         HMODULE hMod;
  49.         DWORD cbNeeded;
  50.  
  51.         if ( EnumProcessModules( hProcess, &hMod, sizeof(hMod), &cbNeeded) )
  52.         {
  53.              GetModuleBaseName( hProcess, hMod, szProcessName,
  54.                                                sizeof(szProcessName)/sizeof(TCHAR) );
  55.         }
  56.     }
  57.  
  58.     // Print the process name and identifier.
  59.     printf( TEXT("%s  (PID: %u)\n"), szProcessName, processID );
  60.     // Release the handle to the process.
  61.     CloseHandle( hProcess );
  62. }
  63.  
  64. //////////////////////
  65.  
  66. int main(void)
  67. {
  68.      //////////////////////////
  69.  
  70.      // Get the list of process identifiers.
  71.      DWORD aProcesses[1024], cbNeeded, cProcesses;
  72.      unsigned int i;
  73.  
  74.      if ( !EnumProcesses( aProcesses, sizeof(aProcesses), &cbNeeded ) )
  75.      {
  76.            return 1;
  77.      }
  78.  
  79.      // Calculate how many process identifiers were returned.
  80.      cProcesses = cbNeeded / sizeof(DWORD);
  81.  
  82.      // Print the name and process identifier for each process.
  83.      for ( i = 0; i < cProcesses; i++ )
  84.      {
  85.             if( aProcesses[i] != 0 )
  86.             {
  87.                  PrintProcessNameAndID( aProcesses[i] );
  88.             }
  89.      }
  90.      system("pause");
  91.      return 0;
  92. }
  93.  
  94. //
  95.  

El programa víctima si requiere que se referencie la librería estática psapi.lib
 
Los archivos:


El resultado



Proyecto VC++6:
http://www.mediafire.com/?q9ha83cs9oayhwm

Hasta luego
10  Programación / Programación C/C++ / Mensaje scroll en: 31 Marzo 2013, 14:03 pm
Hola, estaba probando un código para mensaje scroll, me pareció buena la idea de postearlo. Ya lo había usado mucho antes pero no para un programa de consola.

El programa va a mostrar todas las cadenas que hay en un array de cadenas o matríz de caracteres, son 13 cadenas en total, pero originalmente lo usaba con 4.
La modificación que le hice fue la necesidad de crear un hilo aparte para mostrar las cadenas en scroll, y suspender el hilo principal.

El hilo principal nunca se resume y para salir del programa se sale con ExitProcess desde el hilo secundario.

El intervalo de tiempo entre las cadenas se hace con 'Sleep'.

Como ustedes ya saben, cuando se crea un hilo con CreateThread se le debe pasar un argumento que es la rutina con la cual empieza a ejecutarse el hilo. Esta rutina lleva un parámetro, que lo recibe al crearse el hilo porque dicho parámetro se pasa a CreateThread como argumento.
http://msdn.microsoft.com/en-us/library/windows/desktop/ms682453(v=vs.85).aspx

El tamaño del vector de cadenas se puede sacar con sizeof, pero en este caso se hace restando las direcciones de memoria del último elemento menos el primero.

Para iniciar el 'scrolling' se presiona 1,  y para salir del programa se presiona 2.

Aclarado todo eso, muestro el código
Código
  1.  
  2. //
  3. // By 85
  4. // Credits: LTFX
  5. // elhacker.net
  6. // etalking.com.ar
  7. // boyscout_arg@hotmail.com
  8. // 2013
  9. //
  10.  
  11. ////////////////////////////////////////////////////////////////////////////////////////////////
  12.  
  13. #include<windows.h>
  14. #include<stdio.h>
  15. #include<stdlib.h>
  16.  
  17. ////////////////////////////////////////////////////////////////////////////////////////////////
  18.  
  19. #define MAX_MESSAGES 13
  20. #define STRINGSIZE 0x40
  21. #define INTERVAL 500
  22. bool activar=false;
  23. char* resetMessage = "setinfo \"xxxxx\" \"\"";
  24. char* blankMessage = "setinfo \"xxxxx\" \"%s\"";
  25. //allow up to 13 messages
  26. char gHudMessage5[MAX_MESSAGES][256] = { "","","","","","","","","","","","","" };
  27. // a "hack" way to scroll list without copying strings
  28. int indexRedirect[MAX_MESSAGES] = { 0,1,2,3,4,5,6,7,8,9,10,11,12 };
  29.  
  30. HANDLE hThread;
  31.  
  32. ////////////////////////////////////////////////////////////////////////////////////////////////
  33.  
  34. void gSetHudMessage5(const char* message)
  35. {
  36. int dest = indexRedirect[0];
  37. indexRedirect[0] = indexRedirect[1];
  38. indexRedirect[1] = indexRedirect[2];
  39. indexRedirect[2] = indexRedirect[3];
  40. indexRedirect[3] = indexRedirect[4];
  41. indexRedirect[4] = indexRedirect[5];
  42. indexRedirect[5] = indexRedirect[6];
  43. indexRedirect[6] = indexRedirect[7];
  44. indexRedirect[7] = indexRedirect[8];
  45. indexRedirect[8] = indexRedirect[9];
  46. indexRedirect[9] = indexRedirect[10];
  47. indexRedirect[10] = indexRedirect[11];
  48. indexRedirect[11] = indexRedirect[12];
  49. indexRedirect[12] = dest;
  50. strcpy(gHudMessage5[dest],message);
  51. }
  52.  
  53. ////////////////////////////////////////////////////////////////////////////////////////////////
  54.  
  55. void Thread(const char* value){
  56.  
  57. DWORD* ptrValue = (DWORD*)value;
  58. DWORD OFFS = 0x0;//0x00000000;
  59. DWORD BLOCK = ((ptrValue+(STRINGSIZE*(MAX_MESSAGES-1)))-ptrValue);
  60. //sizeof(messagelist);
  61.  
  62. while(1){
  63. system("cls");
  64. SYSTEMTIME SysTime;
  65. GetLocalTime(&SysTime);
  66. char* formatstring   =   (SysTime.wMinute<10) ?  "%d:0%d\n" :  "%d:%d\n";
  67. printf(formatstring, SysTime.wHour, SysTime.wMinute);
  68. printf("Presione 1 para activar/desactivar el scroll! (Salir=2)\n");
  69.  
  70. if(GetAsyncKeyState(0x31)>0) {
  71.  
  72. activar=!activar;
  73. }
  74.  
  75. if(activar)
  76. {
  77. char* val = (char*)(ptrValue+(OFFS/sizeof(DWORD)));
  78. if(val && val[0]!=0)
  79. {
  80. char message[STRINGSIZE];
  81. message[0] = 0;// Antes de usar strcat!
  82. strcat( message , "Elhacker.net" );
  83. strcat( message , ": " );
  84. strcat( message , val );
  85. strcat( message , "\n" );
  86. gSetHudMessage5(message);
  87.  
  88. printf("\nHooK MSN v 1.0\n");
  89. for(int i=0; i<MAX_MESSAGES; i++){
  90. printf(gHudMessage5[indexRedirect[i]]);
  91. }
  92.  
  93. if(OFFS==BLOCK)
  94. {
  95. OFFS=0x0;//0x00000000;
  96. }
  97. else
  98. {
  99. OFFS+=STRINGSIZE;//0x00000040;
  100. }
  101. }
  102. }
  103.  
  104. if(GetAsyncKeyState(0x32)>0){
  105.  
  106. ExitProcess(0);
  107. //ResumeThread(hThread);// Can't from this thread
  108. //break;
  109. }
  110.  
  111. Sleep(INTERVAL);
  112. }
  113. }
  114.  
  115. ////////////////////////////////////////////////////////////////////////////////////////////////
  116.  
  117. int main(){
  118.  
  119. char messagelist[MAX_MESSAGES][STRINGSIZE];
  120. strcpy(messagelist[0],"Hola");
  121. strcpy(messagelist[1],"Mi");
  122. strcpy(messagelist[2],"Nombre");
  123. strcpy(messagelist[3],"Es");
  124. strcpy(messagelist[4],"David");
  125. strcpy(messagelist[5],"Y");
  126. strcpy(messagelist[6],"Esto");
  127. strcpy(messagelist[7],"Es");
  128. strcpy(messagelist[8],"Un");
  129. strcpy(messagelist[9],"Mensaje");
  130. strcpy(messagelist[10],"Scroll");
  131. strcpy(messagelist[11],"XD");
  132. strcpy(messagelist[12],"XD");
  133. char* value = (char*)&messagelist;
  134.  
  135. // Determinar el tamaño del bloque restando final con inicio
  136. // DWORD add1 = (DWORD)&messagelist[0];
  137. // DWORD add2 = (DWORD)&messagelist[12];
  138. // DWORD diff = (DWORD)(add2-add1);
  139. // printf("%X\n",diff);
  140. // system("pause");
  141.  
  142. DWORD tID;
  143. //tID = GetCurrentThreadId();
  144. CreateThread(0,1<<24,(unsigned long (__stdcall *)(void *))Thread,value,0,&tID);
  145. //printf("tID: %d\n",tID);
  146.  
  147. //hThread = OpenThread(THREAD_ALL_ACCESS, FALSE, GetCurrentThreadId());
  148. //Returns a "pseudo handle" that can only be used from the calling thread.
  149. hThread = GetCurrentThread();
  150. SuspendThread(hThread);
  151. //ResumeThread(hThread);
  152.  
  153. system("pause");
  154. return (0);
  155. }
  156.  
  157.  



Esta era su aplicación original


PROJECT:
http://www.mediafire.com/?q6dq36cdd9hxvxb
Páginas: [1] 2 3 4
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines