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

 

 


Tema destacado: Rompecabezas de Bitcoin, Medio millón USD en premios


+  Foro de elhacker.net
|-+  Seguridad Informática
| |-+  Análisis y Diseño de Malware (Moderador: fary)
| | |-+  [SRC][C++/ASM] ClsAntiDebug
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: [SRC][C++/ASM] ClsAntiDebug  (Leído 2,068 veces)
[L]ord [R]NA


Desconectado Desconectado

Mensajes: 1.513

El Dictador y Verdugo de H-Sec


Ver Perfil WWW
[SRC][C++/ASM] ClsAntiDebug
« en: 3 Abril 2011, 07:17 am »

 Aqui les traigo una clase para colocar mecanismos contra Debuggers en nuestros codigos de una forma rapida y sencilla. Los metodos estan claros y simplemente se deben utilizar depende el metodo que deseemos utilizar para detectar los Debuggers. Estan integrados los metodos de deteccion a traves del PEB, del NTGlobal, utilizando los nombres comunes de los procesos de OllyDBG, IDA Pro y Win32DASM. En el metodo TimeStamp deben verificar antes de dar un valor el tiempo que dura la funcion que toma como segundo parametro. Tenemos otro metodo que es el metodo Protect, el cual toma una funcion y verifica con los tres primeros metodos de deteccion para verificar que no estan siendo Debuggeados, de caso contrario ejecutara una funcion que toma como parametro.

Como lo prometido es deuda aqui van los codigos:

Código
  1. #ifndef __ClsAntiDebug__
  2. #define __ClsAntiDebug__
  3. #include <windows.h>
  4. #include <tlhelp32.h>
  5.  
  6. class ClsAntiDebug
  7. {
  8. private:
  9. bool Debugged;
  10. public:
  11. ClsAntiDebug();
  12. void __declspec() PEBDebug();
  13. void __declspec() NTGlobalDebug();
  14. void __declspec() DebuggerActive();
  15. void __declspec() TimeStamp(int time, void *func);
  16. void Protect(void *func);
  17. bool IsDebugged();
  18. };
  19. #endif

Aqui debajo estan las declaraciones de los metodos en la clase:

Código
  1. #include "AntiDebug.h"
  2.  
  3. ClsAntiDebug::ClsAntiDebug()
  4. {
  5. this->Debugged=false;
  6. }
  7.  
  8. bool ClsAntiDebug::IsDebugged()
  9. {
  10. return this->Debugged;
  11. }
  12.  
  13. void __declspec() ClsAntiDebug::PEBDebug()
  14. {
  15. __asm
  16. {
  17. _PEBLoop:
  18. push 500
  19. call dword ptr ds:[Sleep]
  20. xor edx, edx
  21. mov dl,0x30
  22. mov esi, fs:[edx]
  23. movzx eax, byte ptr[esi+2]
  24. dec eax
  25. jne _PEBLoop
  26. inc eax
  27. }
  28. this->Debugged = true;
  29. }
  30.  
  31. void __declspec() ClsAntiDebug::NTGlobalDebug()
  32. {
  33. __asm
  34. {
  35. _NTLoop:
  36. push 500
  37. call dword ptr ds:[Sleep]
  38. xor edx, edx
  39. mov dl,0x30
  40. mov esi, fs:[edx]
  41. movzx eax, byte ptr[esi+0x68]
  42. and eax,eax
  43. je _NTLoop
  44. xor eax,eax
  45. inc eax
  46. }
  47. this->Debugged = true;
  48. }
  49.  
  50. void __declspec() ClsAntiDebug::DebuggerActive()
  51. {
  52. HANDLE hProcSnap;
  53. PROCESSENTRY32 pProcess;
  54. LPTSTR Exename;
  55. int strlength;
  56. int deb[3]={18416231/*IDA Pro*/,997340682/*W32DASM*/,1853255255/*OllyDbg*/};
  57. int i;
  58. do
  59. {
  60. hProcSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
  61. pProcess.dwSize = sizeof(PROCESSENTRY32);
  62. Process32First(hProcSnap,&pProcess);
  63. do
  64. {
  65. strlength = strlen(pProcess.szExeFile);
  66. __asm
  67. {
  68. lea eax,[pProcess.szExeFile]
  69. mov ecx,dword ptr[strlength]
  70. xor edx,edx
  71. xor edi, edi
  72. push edi
  73. gethash:
  74. pop edi
  75. xor dl, byte ptr[eax+edi]
  76. rol edx,8
  77. inc edi
  78. push edi
  79. xor edi,ecx
  80. jne gethash
  81. mov [strlength],edx/*We don't need strlength, so we recycle to get
  82.     The Hash on Int Variable*/
  83. pop edi
  84. }
  85. for(i=0;i<3;i++)if (strlength==deb[i])
  86. {
  87. this->Debugged = true;
  88. __asm{jmp ___end}
  89. }
  90. }while(Process32Next(hProcSnap,&pProcess));
  91. Sleep(500);
  92. }while(1);
  93. __asm
  94. {___end:}
  95. }
  96. void __declspec() ClsAntiDebug::Protect(void *func)
  97. {
  98.  
  99. do
  100. {
  101. switch(GetTickCount()%4)
  102. {
  103. case 0:this->PEBDebug();break;
  104. case 1:this->NTGlobalDebug();break;
  105. case 2:this->DebuggerActive();break;
  106. };
  107. if (this->Debugged)
  108. {
  109. __asm
  110. {
  111. call [func]
  112. }
  113. }
  114. Sleep(500);
  115. }while(1);
  116. }
  117.  
  118. void __declspec() ClsAntiDebug::TimeStamp(int time,void *func)
  119. {
  120. __asm
  121. {
  122. rdtsc
  123. mov ebx,eax
  124. call [func]
  125. rdtsc
  126. sub eax, ebx
  127. cmp eax, [time]
  128. jna ___rtend
  129. }
  130. this->Debugged = true;
  131. __asm{___rtend: }
  132. }

Aqui tenemos una muestra de como utilizar la clase:

Código
  1. #pragma comment(linker,"/ENTRY:main")
  2.  
  3. #include "AntiDebug.h"
  4. void CALLBACK HolaMundo()
  5. {
  6. int i;
  7. i++;
  8. i++;
  9. }
  10.  
  11. int __declspec() main()
  12. {
  13.  
  14. ClsAntiDebug *Debugger=new(ClsAntiDebug);
  15. Debugger->TimeStamp(200,HolaMundo);
  16. if (Debugger->IsDebugged())MessageBox(0,"Hola","Mundo",0);
  17. Debugger->Protect(HolaMundo);
  18. return 0;
  19. }
En línea

jackgris

Desconectado Desconectado

Mensajes: 149



Ver Perfil
Re: [SRC][C++/ASM] ClsAntiDebug
« Respuesta #1 en: 3 Abril 2011, 16:41 pm »

Exelente el post, en cuanto pueda pruebo los fuentes :D
En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines