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

 

 


Tema destacado: Los 10 CVE más críticos (peligrosos) de 2020


  Mostrar Mensajes
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 [17] 18 19 20 21
161  Programación / Programación C/C++ / Re: Ecuacion de la recta en c++ en: 5 Marzo 2013, 04:53 am
@leosansan te falta hacer el gráfico de la solución en Opengl y tu explicación sería lo más  ;D

http://recursostic.educacion.es/secundaria/edad/4esomatematicasB/ecuaciones/impresos/quincena4.pdf

162  Programación / Programación C/C++ / Re: pequeña ayuda en c++ en: 5 Marzo 2013, 04:41 am
En realidad las llaves son importantes, fueron creadas para marcar ámbitos, y por supuesto que hacen más legible el code, aunque algunas veces yo saco las que se permiten sacar,
163  Programación / Programación C/C++ / Re: Trabajar Recursivamente en: 5 Marzo 2013, 04:30 am
dejá la función 'main' sólo con el return 0, poné todo el código de la calculadora en una función, y hacéla que sea recursiva, y por último tenés que llamar la nueva función dentro de 'main'

EDITADO

Perdóm.. haciendo una búsqueda recursiva en el foro encontré algunas cosas para vos XD
http://foro.elhacker.net/programacion_cc/recursividad-t359491.0.html
http://foro.elhacker.net/programacion_cc/recursividad_c-t366671.0.html
http://foro.elhacker.net/programacion_cc/busqueda_recursiva-t360830.0.html
http://foro.elhacker.net/programacion_cc/c_busqueda_binaria_recursiva-t374647.0.html

164  Programación / Programación C/C++ / Re: Problema con el uso de la libreria time en: 5 Marzo 2013, 04:26 am
por ejemplo, algo así pseudocódigamente hablando

Citar
if (  HORA == 11:30 )

con lo cual tenés que validar la hora y los minutos... eso necesitás?

aparte los rangos son de 0 a 60 minutos? o qué rangos estás hablando?
165  Programación / Programación C/C++ / Re: pequeña ayuda en c++ en: 2 Marzo 2013, 10:29 am
HAHAHA si la verdad, no dan premios por usar llaves XD
166  Programación / Programación C/C++ / Re: Duda sobre funciones que devuelven punteros en: 2 Marzo 2013, 10:21 am
si eso que te dijeron y hay algo más que tiene a favor, es lo siguiente y te lo muestro con un ejemplo:

Código
  1. void ReemplazaO(char* str){//Reemplaza la primer ocurrencia de 'O'
  2.  
  3.    if(strstr(str,"O")!=NULL)
  4.    {
  5.        *strstr(str,"O")='0';
  6.        return;
  7.    }
  8. }

Dicha función utiliza la función std llamada STRSTR
http://www.cplusplus.com/reference/cstring/strstr/

Código:
char * strstr (       char * str1, const char * str2 );

que cuando encuentra una cadena dentro de otra, retorna un puntero a la primer ocurrencia en la cadena pasada como 1er parámetro.

Con lo cual tenés un puntero en la posición correcta como para hacer una modificación.

Esto obviamente se puede hacer de otras formas, pero la ventaja de devolver un puntero es en este caso el posicionamiento específico.

No hace falta aclarar que la función "ReemplazaO" retorna al encontrar y cambiar la primer ocurrencia que se encuentre de 'O' ...

Saludos
167  Programación / Programación C/C++ / Parchear la EAT para interceptar GPA en: 2 Marzo 2013, 10:06 am
NIVEL: Beginner
TEST: win XP SP3

Esta es la continuación de esta especie de tutorial que había
comenzado en este hilo:

http://foro.elhacker.net/programacion_cc/parchear_la_iat_para_interceptar_gpa-t384232.0.html


En este caso, vamos a utilizar el desensamblador que veníamos usando
para obtener ciertos datos acerca de una librería llamada kernel32.dll
para los que no la conocen, es una librería (DLL) del sistema Windows
y la pueden encontrar en la carpeta system32.
Más información:
http://en.wikipedia.org/wiki/Microsoft_Windows_library_files

Usamos el desensamblador (O un explorador PE) para observar los detalles del archivo. Y también cierta información que vamos a utilizar.















Luego el código del programa..
En este programa contamos con dos rutinas que realizan el mismo
objetivo: Parchear la EAT de kernel32.dll

La diferencia es que la primera hace las operaciones automáticamente
valiéndose de cierta información obtenida del siguiente tutorial:
http://www.mediafire.com/?6nzmp28x2pb9b4n

y de esto:
http://www.cyvera.com/how-injected-code-finds-exported-functions/

Realiza algunas operaciones con ensamblador en línea y luego parchea la EAT.

La segunda rutina cumple con el objetivo pero sin usar ensamblador
en línea.

Con respecto al por qué de usar ASM, es para mostrar algo diferente
del anterior tutorial en el que se hacía todo automáticamente y con
C/C++.
http://foro.elhacker.net/programacion_cc/parcheo_de_eat_y_de_iat_automatico-t384486.0.html

NOTA: El objetivo es como se puede usar una herramienta como puede
ser un explorador de PE, o un desensamblador cualquiera, para obtener
estos datos.

Inclusive este tipo de cosas se puede hacer sin necesidad de código, es decir simplemente usando este tipo de herramientas pero para parchear los archivos en disco. Pero la idea era codificar algo XD

El código del programa:
Código
  1.  
  2. //
  3. // By 85
  4. // elhacker.net
  5. // etalking.com.ar
  6. // boyscout_arg@hotmail.com
  7. // 2013
  8. //
  9.  
  10. #include<windows.h>
  11. #include<stdio.h>
  12.  
  13. //
  14. FARPROC (WINAPI* pGetProcAddress) ( HMODULE hModule, LPCSTR lpProcName );
  15.  
  16. typedef FARPROC (WINAPI* GetProcAddress_t) ( HMODULE hModule, LPCSTR lpProcName );
  17.  
  18. //
  19. FARPROC WINAPI newGetProcAddress(HMODULE hModule, LPCSTR lpProcName)
  20. {
  21. FARPROC nResult;
  22. nResult=pGetProcAddress(hModule, lpProcName);
  23. if (HIWORD(lpProcName))
  24. {
  25. if (!lstrcmp(lpProcName, "GetProcAddress"))
  26. {
  27. return (FARPROC) &newGetProcAddress;
  28. }
  29. }
  30. return nResult;
  31. }
  32.  
  33. //
  34. DWORD PatchEAT( DWORD pOrgFunction, DWORD pNewFunction )
  35. {
  36. DWORD dwOldProtect;
  37. DWORD dwOldProtect2;
  38. DWORD pOldFunction = ((DWORD*)pOrgFunction)[0];
  39.  
  40. VirtualProtect( reinterpret_cast< void * >( pOrgFunction ), sizeof( DWORD ), PAGE_EXECUTE_READWRITE, &dwOldProtect );
  41. ((DWORD*)pOrgFunction)[0] = pNewFunction;
  42. VirtualProtect( reinterpret_cast< void * >( pOrgFunction ), sizeof( DWORD ), dwOldProtect, &dwOldProtect2 );
  43. return pOldFunction;
  44. }
  45.  
  46. //
  47. void PatchEatConInlineASM(){
  48.  
  49. char* gpastr = "GetProcAddress";
  50. DWORD k32base = (DWORD)GetModuleHandle("kernel32.dll");
  51.  
  52. // Logs
  53.    DWORD peheader=0;
  54. DWORD rva_exports_dir=0;
  55. DWORD rva_exports_funcs=0;
  56. DWORD rva_exports_fnames=0;
  57. DWORD va_exports_fnames=0;
  58. DWORD va_eat=0;
  59. int savedeax;
  60. DWORD rEDX;
  61.  
  62. __asm{
  63. mov ebx, k32base                      //EBX = kernel32.dll's base address
  64. mov edx,dword ptr ds:[ebx+3Ch]        //PE header
  65. mov peheader, edx
  66. mov edx,dword ptr ds:[edx+ebx+78h]    //EDX = kernel32.dll's export directory (RVA)
  67. mov rva_exports_dir, edx
  68. mov eax,dword ptr ds:[edx+ebx+1Ch]    //Address of exported funcs (EAX = EAT (RVA))
  69. mov rva_exports_funcs, eax
  70. mov edx,dword ptr ds:[edx+ebx+20h]    //EDX = Address of function names (RVA)
  71. mov rva_exports_fnames, edx
  72. add edx,ebx                           //EDX = Address of function names (VA)
  73. mov va_exports_fnames, edx
  74. add eax,ebx                           //EAX = EAT (VA)
  75. mov va_eat, eax
  76. }
  77.  
  78. __asm{
  79.  
  80. get_exports:
  81. xor ecx, ecx
  82. mov esi,gpastr              //Address of string "GetProcAddress" (not null-terminated)
  83. mov edi,dword ptr ds:[edx]  //EDI = *(EDX = VA of function names)
  84. add edi,ebx                 //Address of string (Exported function name) (k32+offs en edi)
  85. mov cl,0Eh                  //14 chars
  86. repe cmpsb                  //recibe dos direcciones de 2 strings (ESI,EDI)
  87. je short found_set_context  //Jump if this is our function
  88. add edx,4                   //Next function name
  89. add eax,4                   //Next function address
  90. jmp short get_exports
  91. found_set_context:
  92. mov savedeax, eax
  93. mov edx,dword ptr ds:[eax]
  94. add edx,ebx  
  95. mov rEDX, edx
  96. }
  97.  
  98.  
  99. printf("k32 0x%X\n",k32base);
  100. printf("peheader 0x%X\n",peheader);
  101. printf("rva_exports_dir 0x%X\n",rva_exports_dir);
  102. printf("rva_exports_funcs 0x%X\n",rva_exports_funcs);
  103. printf("rva_exports_fnames 0x%X\n",rva_exports_fnames);
  104. printf("va_exports_fnames 0x%X\n",va_exports_fnames);
  105. printf("va_eat 0x%X\n",va_eat);
  106. printf("primer entrada de va_eat 0x%X\n",*(DWORD*)va_eat);//da un rva
  107. printf("savedeax 0x%X\n",savedeax);// eat entry para gpa
  108. printf("savedeax 0x%X\n",*(DWORD*)savedeax);// el rva en el eat entry correspondiente a gpa
  109. printf("GetProcAddress 0x%X\n",GetProcAddress);
  110. printf("rEDX 0x%X\n",rEDX);
  111. system("pause");
  112.  
  113. /////////////////////////////////////////////////
  114.  
  115. // Calcular el rva con mi gpa
  116. DWORD rvaMiGPA = (((DWORD)newGetProcAddress)-DWORD(k32base));
  117.  
  118. // Inicializar puntero de retorno a la original
  119. pGetProcAddress = (GetProcAddress_t)rEDX;
  120.  
  121. // Parche
  122. PatchEAT( savedeax, rvaMiGPA );// savedeax = eat entry para gpa
  123.  
  124. printf("newGetProcAddress 0x%X\n",newGetProcAddress);
  125. // printf("GetProcAddress 0x%X\n",GetProcAddress);
  126. system("pause");
  127. }
  128.  
  129. //
  130. void PatchEatSinInlineASM(){
  131.  
  132. DWORD k32base = (DWORD)GetModuleHandle("kernel32.dll");
  133. DWORD exports = k32base+0x262C;
  134. DWORD* dwEAT = (DWORD*)(exports+0x28);//953 entradas
  135. printf("EAT 0x%X\n",dwEAT);
  136.  
  137. //for(int i=0;i<409-1;i++) dwEAT+=0x1;
  138. //printf("GPA EAT 0x%X\n",dwEAT);
  139. //printf("*GPA EAT 0x%X\n",*(dwEAT));
  140.  
  141. DWORD dwEATgpa = (DWORD)(dwEAT+0x198);
  142. printf("GPA EAT 0x%X\n",(dwEAT+0x198));//0x199 = 409
  143. printf("*GPA EAT 0x%X\n",*(dwEAT+0x198));
  144.  
  145. DWORD rvaGPA = dwEAT[409-1];//409 = gpa index
  146. DWORD dwGPA = k32base+rvaGPA;
  147.  
  148. printf("rvaGPA 0x%X\n",rvaGPA);
  149. printf("dwGPA 0x%X\n",dwGPA);
  150. // printf("GetProcAddress 0x%X\n",GetProcAddress);
  151. //system("pause");
  152.  
  153. /////////////////////////////////////////////////
  154.  
  155. // Calcular el rva de mi gpa
  156. DWORD rvaMiGPA = (((DWORD)newGetProcAddress)-DWORD(k32base));
  157.  
  158. printf("dwEATgpa 0x%X\n",dwEATgpa);
  159. printf("rvaMiGPA 0x%X\n",rvaMiGPA);
  160.  
  161. // Inicializar puntero de retorno a la original
  162. pGetProcAddress = (GetProcAddress_t)dwGPA;
  163.  
  164. // Parche
  165. PatchEAT( dwEATgpa, rvaMiGPA );
  166.  
  167. printf("newGetProcAddress 0x%X\n",newGetProcAddress);
  168. // printf("GetProcAddress 0x%X\n",GetProcAddress);
  169. system("pause");
  170. }
  171.  
  172. //
  173. int main(){
  174.  
  175. // 1
  176. // PatchEatConInlineASM();
  177.  
  178. // 2
  179. PatchEatSinInlineASM();
  180.  
  181. /////////////////////////////////////////////////
  182. // Test
  183.  
  184. DWORD test = (DWORD)GetProcAddress(GetModuleHandle("kernel32.dll"),"GetProcAddress");
  185. printf("test 0x%X\n",test);
  186. printf("pGetProcAddress 0x%X\n",pGetProcAddress);// retorno a la original
  187.  
  188. system("pause");
  189. return 0;
  190. }
  191.  
  192. //
  193.  

PROYECTO VC6
http://www.mediafire.com/?t87q7m7b7give3b

hasta luego
168  Programación / Programación C/C++ / Parcheo de EAT y de IAT automático en: 2 Marzo 2013, 09:59 am
NIVEL: Beginner
TEST: win XP SP3

En este post a modo de tutorial se han utilizado dos rutinas, googleadas de las miles que hay, que hacen los parches respectivos (EAT e IAT), automáticamente,  encontrando la ubicación de la entrada correspondiente a una función, dentro de estas tablas. Para el ejemplo del parcheo de IAT se procede a usar la IAT local  del ejecutable, mientras que para el parcheo de EAT se hace en la EAT de la librería (DLL) kernel32.dll.

El objetivo de esta demostración es interceptar la función
GetProcAddress con ningún propósito más que demostrar como
se puede interceptar una función.

Se pueden valorar los casos que se pueden dar en los siguientes
dos ejemplos de programas:

En el primer programa contamos con un EXE el cual tiene dos opciones
que se le ofrecen al usuario:

1_ parchear la eat de kernel32.dll
2_ parchear la iat local


luego de elegir una de ambas opciones, se procede a cargar una DLL
en el proceso (ver el código de la DLL para ver que hace).

DEMO 1

EXE
Código
  1. //
  2. // By 85
  3. // PatchEAT, PatchIAT (Googleadas en 5 segundos XD)
  4. // elhacker.net
  5. // etalking.com.ar
  6. // 2013
  7. //
  8.  
  9. #include<windows.h>
  10. #include<stdio.h>
  11.  
  12. //
  13. FARPROC (WINAPI* pGetProcAddress) ( HMODULE hModule, LPCSTR lpProcName );
  14.  
  15. typedef FARPROC (WINAPI* GetProcAddress_t) ( HMODULE hModule, LPCSTR lpProcName );
  16.  
  17. //
  18. FARPROC WINAPI newGetProcAddress(HMODULE hModule, LPCSTR lpProcName)
  19. {
  20. FARPROC nResult;
  21. nResult=pGetProcAddress(hModule, lpProcName);
  22. if (HIWORD(lpProcName))
  23. {
  24. if (!lstrcmp(lpProcName, "GetProcAddress"))
  25. {
  26. return (FARPROC) &newGetProcAddress;
  27. }
  28. }
  29. return nResult;
  30. }
  31.  
  32. //
  33. bool PatchEAT(HMODULE hTargetMod,CHAR* FuncName,VOID* newAdd,VOID** OrigAdd)
  34. {
  35.  
  36. #define _sword sizeof(WORD) //AddressOfNameOrdinals
  37. #define _sdword sizeof(DWORD)
  38.    DWORD addEAT,beforeProtection;
  39.    IMAGE_DOS_HEADER* dos_header=(IMAGE_DOS_HEADER*)hTargetMod;
  40.    IMAGE_NT_HEADERS* nt_header=NULL;
  41.    if(dos_header->e_magic!=IMAGE_DOS_SIGNATURE)
  42. return false;
  43.  
  44. nt_header=((PIMAGE_NT_HEADERS)((DWORD)(dos_header)+(DWORD)(dos_header->e_lfanew)));
  45. if(nt_header->Signature!=IMAGE_NT_SIGNATURE)
  46. return false;
  47.  
  48.    addEAT=nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
  49.    IMAGE_EXPORT_DIRECTORY* pEAT=(IMAGE_EXPORT_DIRECTORY*)((DWORD)addEAT+(DWORD)hTargetMod);
  50.    for(DWORD i=0;i<pEAT->NumberOfFunctions;i++){
  51.        DWORD* pName=(DWORD*)((DWORD)hTargetMod+((DWORD)pEAT->AddressOfNames+(_sdword*i)));
  52. //printf("add nombre 0x%X\n",pName);
  53. //system("pause");
  54.        if(strcmp((char*)((DWORD)hTargetMod+*pName),FuncName) == 0){
  55.            WORD* AddNamePtrs=(WORD*)((DWORD)hTargetMod+((DWORD)pEAT->AddressOfNameOrdinals+(i*_sword)));
  56.            DWORD* AddFuncRVA=(DWORD*)((DWORD)hTargetMod+((DWORD)pEAT->AddressOfFunctions+(_sdword**AddNamePtrs)));
  57.  
  58.  
  59. //if(!strcmp((char*)((DWORD)hTargetMod+*pName),"GetProcAddress")){
  60. //printf("AddNamePtrs 0x%X\n",AddNamePtrs);
  61. // printf("Add de la func rva 0x%X\n",AddFuncRVA);
  62. // printf("Add func 0x%X\n",*AddFuncRVA+DWORD(hTargetMod));
  63. // system("pause");
  64. //}
  65.  
  66. if(!VirtualProtect(AddFuncRVA,_sdword,PAGE_READWRITE,&beforeProtection))
  67. return false;
  68.  
  69. *OrigAdd=(void*)(*AddFuncRVA+DWORD(hTargetMod));
  70.            *AddFuncRVA=(((DWORD)newAdd)-DWORD(hTargetMod));//copia el nuevo rva
  71.            if(!VirtualProtect(AddFuncRVA,_sdword,beforeProtection,&beforeProtection))
  72. return false;
  73.  
  74. break;
  75.        }
  76.    }
  77.    return true;
  78. }
  79.  
  80. //
  81. BOOL PatchIAT(HMODULE ModHandle, DWORD OriginalFunc, DWORD HookFunc, void **pOriginalFunc)
  82. {
  83. DWORD pe_offset,CurAddr,CurPointer,IATanfang,IATende,base;
  84. BOOL Hooked=FALSE;
  85. IMAGE_NT_HEADERS *pehdr;
  86.  
  87. if(!ModHandle || !OriginalFunc || !HookFunc)
  88. return FALSE;
  89.  
  90. base=(DWORD)ModHandle;
  91.  
  92. memcpy(&pe_offset,(void *)(base+0x3C),sizeof(DWORD));
  93. pehdr=(IMAGE_NT_HEADERS *)((DWORD)base + pe_offset);
  94.  
  95. IATanfang=(DWORD)base+pehdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].VirtualAddress;
  96. IATende=IATanfang+pehdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT].Size;
  97.  
  98. CurAddr=IATanfang;
  99.  
  100. while(CurAddr<IATende)
  101. {
  102. memcpy(&CurPointer,(void *)CurAddr,sizeof(DWORD));
  103.  
  104. if(CurPointer==OriginalFunc)
  105. {
  106. if(pOriginalFunc)
  107. *pOriginalFunc=(PVOID)CurPointer;
  108. DWORD old_attributes,old_attributes2;
  109. if(!VirtualProtect((void *)CurAddr,sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old_attributes))
  110. return FALSE;
  111. memcpy((void *)CurAddr,&HookFunc,sizeof(DWORD));
  112. if(!VirtualProtect((void *)CurAddr,sizeof(DWORD), old_attributes, &old_attributes2))
  113. return FALSE;
  114. Hooked=TRUE;
  115. }
  116.  
  117. CurAddr+=sizeof(DWORD);
  118. }
  119. return Hooked;
  120. }
  121.  
  122. //
  123. int main(){
  124.  
  125. /*DWORD test0a = (DWORD)GetProcAddress(GetModuleHandle("kernel32.dll"),"GetProcAddress");
  126. DWORD test0b = (DWORD)GetProcAddress(GetModuleHandle(NULL),"GetProcAddress");
  127. //printf("GPA original: 0x%X\n",pGetProcAddress);
  128. printf("GPA hook: 0x%X\n",newGetProcAddress);
  129. printf("GPA es ahora (k32): 0x%X\n",test0a);
  130. printf("GPA es ahora (EXE): 0x%X\n",test0b);
  131. system("pause");*/
  132. ////////////////////////////////
  133.  
  134. HINSTANCE lib;
  135. int Res=0;
  136. int hookmode=0;
  137. while( hookmode<1||hookmode>3){
  138.  
  139. system("cls");
  140. printf("Bienvenido!\n");
  141. printf("Ingrese 1 para realizar un EAT HOOK\n");
  142. printf("Ingrese 2 para realizar un IAT HOOK\n");
  143. scanf("%d",&hookmode);
  144. }
  145.  
  146. if(hookmode == 1) __asm jmp eathook;
  147. else if(hookmode == 2) __asm jmp iathook;
  148. else if(hookmode == 3) __asm jmp salida;
  149.  
  150. /////////////////////////////////////////////////
  151. // EAT HOOK
  152.  
  153. eathook:
  154. Res = PatchEAT(GetModuleHandle("kernel32.dll"),"GetProcAddress",
  155. ((VOID*)(&newGetProcAddress)),((VOID**)(&pGetProcAddress)));
  156.  
  157. if(!Res){
  158.  
  159. printf("No se ha modificado la EAT objetivo!\n");
  160. ExitProcess(0);
  161. }
  162.  
  163. // Test 1
  164. DWORD test1a = (DWORD)GetProcAddress(GetModuleHandle("kernel32.dll"),"GetProcAddress");
  165. DWORD test1b = (DWORD)GetProcAddress(GetModuleHandle(NULL),"GetProcAddress");
  166. printf("GPA original: 0x%X\n",pGetProcAddress);
  167. printf("GPA hook: 0x%X\n",newGetProcAddress);
  168. printf("GPA es ahora (k32): 0x%X\n",test1a);
  169. printf("GPA es ahora (EXE): 0x%X\n",test1b);
  170. system("pause");
  171.  
  172. lib = LoadLibrary("loaddll.dll");
  173. FreeLibrary(lib);
  174. return 0;
  175. //
  176.  
  177. ////////////////////////////////////////////////
  178. // IAT HOOK
  179.  
  180. iathook:
  181. Res = PatchIAT(GetModuleHandle(NULL),(DWORD)GetProcAddress,
  182. (DWORD)newGetProcAddress,(void **)&pGetProcAddress);
  183.  
  184. if(!Res){
  185.  
  186. printf("No se ha modificado la IAT objetivo!\n");
  187. ExitProcess(0);
  188. }
  189.  
  190. // Test 2
  191. DWORD test2a = (DWORD)GetProcAddress(GetModuleHandle("kernel32.dll"),"GetProcAddress");
  192. DWORD test2b = (DWORD)GetProcAddress(GetModuleHandle(NULL),"GetProcAddress");
  193. printf("GPA original: 0x%X\n",pGetProcAddress);
  194. printf("GPA hook: 0x%X\n",newGetProcAddress);
  195. printf("GPA es ahora (k32): 0x%X\n",test2a);
  196. printf("GPA es ahora (EXE): 0x%X\n",test2b);
  197. system("pause");
  198.  
  199. lib = LoadLibrary("loaddll.dll");
  200. FreeLibrary(lib);
  201. return 0;
  202. //
  203.  
  204. /////////////////////////////////////////////////
  205. //
  206. salida:
  207. return 0;
  208. }
  209.  
  210. //
  211.  

DLL
Código
  1.  
  2. //
  3. // By 85
  4. // PatchEAT, PatchIAT (googleadas en 5 segundos XD)
  5. // elhacker.net
  6. // etalking.com.ar
  7. // 2013
  8. //
  9.  
  10. #include<windows.h>
  11. #include<stdio.h>
  12.  
  13. //////////////////////////
  14.  
  15. BOOL APIENTRY DllMain(
  16. HANDLE hModule, // Handle to DLL module
  17. DWORD ul_reason_for_call,
  18. LPVOID lpReserved ) // Reserved
  19. {
  20. switch ( ul_reason_for_call )
  21. {
  22. case DLL_PROCESS_ATTACH:
  23. // A process is loading the DLL.
  24.  
  25. {
  26.  
  27. DWORD res1 = (DWORD)GetProcAddress(GetModuleHandle("kernel32.dll"),"GetProcAddress");
  28. DWORD res2 = (DWORD)GetProcAddress(GetModuleHandle(NULL),"GetProcAddress");
  29. printf("GPA desde la dll mod=k32 0x%X\n", res1);
  30. printf("GPA desde la dll mod=EXE 0x%X\n", res2);
  31. system("pause");
  32. }
  33.  
  34.  
  35. break;
  36. case DLL_THREAD_ATTACH:
  37. // A process is creating a new thread.
  38. break;
  39. case DLL_THREAD_DETACH:
  40. // A thread exits normally.
  41. break;
  42. case DLL_PROCESS_DETACH:
  43. // A process unloads the DLL.
  44. break;
  45. }
  46. return TRUE;
  47. }
  48.  
  49. ////////////////
  50.  

En el segundo programa, contamos con un EXE el cual es un programa
simple. Sólo carga una DLL (Ver código de la DLL).

El código de la DLL se trata de realizar una de dos opciones.

1_ parchear la EAT kernel32.dll
2_ parchear la IAT del ejecutable

En realidad, se propone sólamente modificar la IAT del ejecutable,
el código del otro parche está deshabilitado.

En realidad el segundo programa no tiene mucho sentido tal cual está
expuesto, pero cobra sentido si nosotros quisiéramos aplicar este
método para algo relacionado al hacking.

Si queremos cambiar algo dentro de un proceso (por ejemplo un juego),
entonces una posible idea sería cargar una DLL en dicho proceso y
realizar un parche a la IAT del EXE. Siempre que sepamos que el EXE
hace uso de GetProcAddress para resolver alguna dirección interesante
para nosotros XD.

Un escenario en el cual se puede encontrar utilidad para esto pueder
ser, por ejemplo un programa (EXE) que utilice GetProcAddress para
resolver la dirección de ciertas funciones en una DLL que está cargada
en el proceso.

Al estár interceptada GetProcAddress, nosotros podemos arreglar que
retorne las direcciones de nuestros hooks en lugar de las direcciones
originales.

DEMO 2

EXE
Código
  1.  
  2. //
  3. // By 85
  4. // elhacker.net
  5. // etalking.com.ar
  6. // 2013
  7. //
  8.  
  9. #include<windows.h>
  10. #include<stdio.h>
  11.  
  12. //
  13. int main(){
  14.  
  15.  
  16. HINSTANCE lib = LoadLibrary("loaddll2.dll");
  17. FreeLibrary(lib);
  18.  
  19. printf("GPA original desde el EXE: 0x%X\n", GetProcAddress);
  20. system("pause");
  21. return 0;
  22. }
  23.  
  24. //
  25.  
  26.  

DLL
Código
  1.  
  2. //
  3. // By 85
  4. // PatchEAT, PatchIAT (googleadas en 5 segundos XD)
  5. // elhacker.net
  6. // etalking.com.ar
  7. // 2013
  8. //
  9.  
  10. #include<windows.h>
  11. #include<stdio.h>
  12.  
  13. /////////////////////
  14.  
  15. FARPROC (WINAPI* pGetProcAddress) ( HMODULE hModule, LPCSTR lpProcName );
  16.  
  17. typedef FARPROC (WINAPI* GetProcAddress_t) ( HMODULE hModule, LPCSTR lpProcName );
  18.  
  19. //
  20. FARPROC WINAPI newGetProcAddress(HMODULE hModule, LPCSTR lpProcName)
  21. {
  22. FARPROC nResult;
  23. // nResult=pGetProcAddress(hModule, lpProcName);
  24. nResult=GetProcAddress(hModule, lpProcName);
  25. if (HIWORD(lpProcName))
  26. {
  27. if (!lstrcmp(lpProcName, "GetProcAddress"))
  28. {
  29. return (FARPROC) &newGetProcAddress;
  30. }
  31. }
  32. return nResult;
  33. }
  34.  
  35. //
  36. bool PatchEAT(HMODULE hTargetMod,CHAR* FuncName,VOID* newAdd,VOID** OrigAdd)
  37. {
  38.        // misma que el anterior programa
  39. ...
  40. }
  41.  
  42. //
  43. BOOL PatchIAT(HMODULE ModHandle, DWORD OriginalFunc, DWORD HookFunc, void **pOriginalFunc)
  44. {
  45. // misma que el anterior programa
  46. ...
  47. }
  48.  
  49. //
  50. //////////////////////////
  51.  
  52. BOOL APIENTRY DllMain(
  53. HANDLE hModule, // Handle to DLL module
  54. DWORD ul_reason_for_call,
  55. LPVOID lpReserved ) // Reserved
  56. {
  57. switch ( ul_reason_for_call )
  58. {
  59. case DLL_PROCESS_ATTACH:
  60. // A process is loading the DLL.
  61.  
  62. {
  63. int Res=0;
  64. //
  65.  
  66. //////////////////////////
  67. // EAT HOOK
  68.  
  69. /* Res = PatchEAT(GetModuleHandle("kernel32.dll"),"GetProcAddress",
  70. ((VOID*)(&newGetProcAddress)),((VOID**)(&pGetProcAddress)));
  71.  
  72. if(!Res){
  73.  
  74. printf("No se ha modificado la EAT objetivo!\n");
  75. ExitProcess(0);
  76. }
  77.  
  78. // Test 1
  79. DWORD test1a = (DWORD)GetProcAddress(GetModuleHandle("kernel32.dll"),"GetProcAddress");
  80. DWORD test1b = (DWORD)GetProcAddress(GetModuleHandle(NULL),"GetProcAddress");
  81. //DWORD test1b = (DWORD)GetProcAddress(GetModuleHandle("loaddll2.dll"),"GetProcAddress");//NO
  82. printf("DLL: GPA original: 0x%X\n",pGetProcAddress);
  83. printf("DLL: GPA original: 0x%X\n",GetProcAddress);
  84. printf("DLL: GPA hook: 0x%X\n",newGetProcAddress);
  85. printf("DLL: GPA es ahora (k32): 0x%X\n",test1a);
  86. printf("DLL: GPA es ahora (EXE): 0x%X\n",test1b);
  87. system("pause");*/
  88.  
  89. /////////////////////////
  90. // IAT HOOK
  91.  
  92.  
  93. Res = PatchIAT(GetModuleHandle(NULL),(DWORD)GetProcAddress,
  94. (DWORD)newGetProcAddress,(void **)&pGetProcAddress);
  95.  
  96. if(!Res){
  97.  
  98. printf("No se ha modificado la IAT objetivo!\n");
  99. ExitProcess(0);
  100. }
  101.  
  102. // Test 2
  103. DWORD test2a = (DWORD)GetProcAddress(GetModuleHandle("kernel32.dll"),"GetProcAddress");
  104. DWORD test2b = (DWORD)GetProcAddress(GetModuleHandle(NULL),"GetProcAddress");
  105. //DWORD test2b = (DWORD)GetProcAddress(GetModuleHandle("loaddll2.dll"),"GetProcAddress");//NO
  106. printf("DLL: GPA original: 0x%X\n",pGetProcAddress);
  107. printf("DLL: GPA original: 0x%X\n",GetProcAddress);
  108. printf("DLL: GPA hook: 0x%X\n",newGetProcAddress);
  109. printf("DLL: GPA es ahora (k32): 0x%X\n",test2a);
  110. printf("DLL: GPA es ahora (EXE): 0x%X\n",test2b);
  111. system("pause");
  112.  
  113. }
  114.  
  115.  
  116. break;
  117. case DLL_THREAD_ATTACH:
  118. // A process is creating a new thread.
  119. break;
  120. case DLL_THREAD_DETACH:
  121. // A thread exits normally.
  122. break;
  123. case DLL_PROCESS_DETACH:
  124. // A process unloads the DLL.
  125. break;
  126. }
  127. return TRUE;
  128. }
  129.  
  130. ////////////////
  131.  

Dejo ambos proyectos en MSVC++ 6.0
http://www.mediafire.com/?ha8768ul77a300z
http://www.mediafire.com/?cdeog97h39c770i

Más información
http://msdn.microsoft.com/en-us/magazine/cc301805.aspx
http://www.reverse-engineering.info/SystemHooking/export.htm
http://www.masmforum.com/board/index.php?PHPSESSID=8d46cd4ecb1688be429ab49694ec53e6&topic=4286.0


hasta luego
169  Programación / Programación C/C++ / Re: Parchear la IAT para interceptar GPA en: 27 Febrero 2013, 08:31 am
Para el rico bepi de x64core que dice que usar el ensamblador en línea no es portable, y si pero qué me importa? si el objetivo es parchear la IAT......
si quiero lo hago todo con ensamblador en línea we
Era algo demostrativo nada más...

veamos como quedaría:

Código:
/* __asm {
mov ebx, dwGPA
mov edx, [ebx]
mov pGetProcAddress, edx
}*/

POR
Código:
typedef FARPROC (WINAPI* GetProcAddress_t) ( HMODULE hModule, LPCSTR lpProcName );

pGetProcAddress = *(GetProcAddress_t*)dwGPA;
170  Programación / Programación C/C++ / Re: Parchear la IAT para interceptar GPA en: 27 Febrero 2013, 07:52 am
para que voy a adjuntar el OLLY DBG ? necesito hacer eso?
puedo abrilo con un editor PE sólamente.  

EJ: LORD PE

Seguro no conocés nada, ni el OLLY, ni el LORD PE, windbg?

quién habló de hookear APIs? PFF

El título te lo dice amigo:

Pachear la IAT, no es hooking en general, el hooking es algo secundario en este topic, el tema era parchear la IAT.

seguro estás aprendiendo API hooking y me lo querés demostrar XD

JAJA x64 se pone,  nice bepi  ::)


Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 [17] 18 19 20 21
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines