send
Grupo de Telegram
play_arrow
Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

ClsAntiDebug

  • 0 Respuestas
  • 1481 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado [L]ord [R]NA

  • *
  • Underc0der
  • Mensajes: 86
  • Actividad:
    0%
  • Reputación 0
  • H-Sec
    • Ver Perfil
  • Skype: lordrna
  • Twitter: lordrna
« en: Junio 02, 2011, 12:14:34 pm »
ClsAntidebug.h
Código: C++
  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

ClsAntiDebug.cpp
Código: C++
  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. }
  133.  
  134.  

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

 

¿Te gustó el post? COMPARTILO!