详解反调试技术

最新推荐文章于 2022-05-28 00:20:45 发布
最新推荐文章于 2022-05-28 00:20:45 发布
阅读量1.6k 收藏 6
点赞数

反调试技术，恶意代码用它识别是否被调试，或者让调试器失效。恶意代码编写者意识到分析人员经常使用调试器来观察恶意代码的操作，因此他们使用反调试技术尽可能地延长恶意代码的分析时间。为了阻止调试器的分析，当恶意代码意识到自己被调试时，它们可能改变正常的执行路径或者修改自身程序让自己崩溃，从而增加调试时间和复杂度。很多种反调试技术可以达到反调试效果。这里介绍当前常用的几种反调试技术，同时也会介绍一些逃避反调试的技巧。
一.探测Windows调试器
恶意代码会使用多种技术探测调试器调试它的痕迹，其中包括使用Windows API、手动检测调试器人工痕迹的内存结构，查询调试器遗留在系统中的痕迹等。调试器探测是恶意代码最常用的反调试技术。
1.使用Windows API
使用Windows API函数检测调试器是否存在是最简单的反调试技术。Windows操作系统中提供了这样一些API，应用程序可以通过调用这些API，来检测自己是否正在被调试。这些API中有些是专门用来检测调试器的存在的，而另外一些API是出于其他目的而设计的，但也可以被改造用来探测调试器的存在。其中很小部分API函数没有在微软官方文档显示。通常，防止恶意代码使用API进行反调试的最简单的办法是在恶意代码运行期间修改恶意代码，使其不能调用探测调试器的API函数，或者修改这些API函数的返回值，确保恶意代码执行合适的路径。与这些方法相比，较复杂的做法是挂钩这些函数，如使用rootkit技术。
1.1IsDebuggerPresent
IsDebuggerPresent查询进程环境块(PEB)中的IsDebugged标志。如果进程没有运行在调试器环境中，函数返回0；如果调试附加了进程，函数返回一个非零值。

[cpp]  view plain  copy
  1. BOOL CheckDebug()  
  2. {  
  3.     return IsDebuggerPresent();  
  4. }  

1.2CheckRemoteDebuggerPresent
CheckRemoteDebuggerPresent同IsDebuggerPresent几乎一致。它不仅可以探测系统其他进程是否被调试，通过传递自身进程句柄还可以探测自身是否被调试。

[cpp]  view plain  copy
  1. BOOL CheckDebug()  
  2. {  
  3.     BOOL ret;  
  4.     CheckRemoteDebuggerPresent(GetCurrentProcess(), &ret);  
  5.     return ret;  
  6. }  

1.3NtQueryInformationProcess
这个函数是Ntdll.dll中一个原生态API，它用来提取一个给定进程的信息。它的第一个参数是进程句柄，第二个参数告诉我们它需要提取进程信息的类型。为第二个参数指定特定值并调用该函数，相关信息就会设置到第三个参数。第二个参数是一个枚举类型，其中与反调试有关的成员有ProcessDebugPort(0x7)、ProcessDebugObjectHandle(0x1E)和ProcessDebugFlags(0x1F)。例如将该参数置为ProcessDebugPort，如果进程正在被调试，则返回调试端口，否则返回0。

[cpp]  view plain  copy
  1. BOOL CheckDebug()  
  2. {  
  3.     int debugPort = 0;  
  4.     HMODULE hModule = LoadLibrary("Ntdll.dll");  
  5.     NtQueryInformationProcessPtr NtQueryInformationProcess = (NtQueryInformationProcessPtr)GetProcAddress(hModule, "NtQueryInformationProcess");  
  6.     NtQueryInformationProcess(GetCurrentProcess(), 0x7, &debugPort, sizeof(debugPort), NULL);  
  7.     return debugPort != 0;  
  8. }  
  9.   
  10. BOOL CheckDebug()  
  11. {  
  12.     HANDLE hdebugObject = NULL;  
  13.     HMODULE hModule = LoadLibrary("Ntdll.dll");  
  14.     NtQueryInformationProcessPtr NtQueryInformationProcess = (NtQueryInformationProcessPtr)GetProcAddress(hModule, "NtQueryInformationProcess");  
  15.     NtQueryInformationProcess(GetCurrentProcess(), 0x1E, &hdebugObject, sizeof(hdebugObject), NULL);  
  16.     return hdebugObject != NULL;  
  17. }  
  18.   
  19. BOOL CheckDebug()  
  20. {  
  21.     BOOL bdebugFlag = TRUE;  
  22.     HMODULE hModule = LoadLibrary("Ntdll.dll");  
  23.     NtQueryInformationProcessPtr NtQueryInformationProcess = (NtQueryInformationProcessPtr)GetProcAddress(hModule, "NtQueryInformationProcess");  
  24.     NtQueryInformationProcess(GetCurrentProcess(), 0x1E, &bdebugFlag, sizeof(bdebugFlag), NULL);  
  25.     return bdebugFlag != TRUE;  
  26. }  

1.4GetLastError
编写应用程序时，经常需要涉及到错误处理问题。许多函数调用只用TRUE和FALSE来表明函数的运行结果。一旦出现错误，MSDN中往往会指出请用GetLastError()函数来获得错误原因。恶意代码可以使用异常来破坏或者探测调试器。调试器捕获异常后，并不会立即将处理权返回被调试进程处理，大多数利用异常的反调试技术往往据此来检测调试器。多数调试器默认的设置是捕获异常后不将异常传递给应用程序。如果调试器不能将异常结果正确返回到被调试进程，那么这种异常失效可以被进程内部的异常处理机制探测。
对于OutputDebugString函数，它的作用是在调试器中显示一个字符串，同时它也可以用来探测调试器的存在。使用SetLastError函数，将当前的错误码设置为一个任意值。如果进程没有被调试器附加，调用OutputDebugString函数会失败，错误码会重新设置，因此GetLastError获取的错误码应该不是我们设置的任意值。但如果进程被调试器附加，调用OutputDebugString函数会成功，这时GetLastError获取的错误码应该没改变。

[cpp]  view plain  copy
  1. BOOL CheckDebug()  
  2. {  
  3.     DWORD errorValue = 12345;  
  4.     SetLastError(errorValue);  
  5.     OutputDebugString("Test for debugger!");  
  6.     if (GetLastError() == errorValue)  
  7.     {  
  8.         return TRUE;  
  9.     }  
  10.     else  
  11.     {  
  12.         return FALSE;  
  13.     }  
  14. }  

对于DeleteFiber函数，如果给它传递一个无效的参数的话会抛出ERROR_INVALID_PARAMETER异常。如果进程正在被调试的话，异常会被调试器捕获。所以，同样可以通过验证LastError值来检测调试器的存在。如代码所示，0x57就是指ERROR_INVALID_PARAMETER。

[cpp]  view plain  copy
  1. BOOL CheckDebug()  
  2. {  
  3.     char fib[1024] = {0};  
  4.     DeleteFiber(fib);  
  5.     return (GetLastError() != 0x57);  
  6. }  

同样还可以使用CloseHandle、CloseWindow产生异常，使得错误码改变。

[cpp]  view plain  copy
  1. BOOL CheckDebug()  
  2. {  
  3.     DWORD ret = CloseHandle((HANDLE)0x1234);  
  4.     if (ret != 0 || GetLastError() != ERROR_INVALID_HANDLE)  
  5.     {  
  6.         return TRUE;  
  7.     }  
  8.     else  
  9.     {  
  10.         return FALSE;  
  11.     }  
  12. }  
  13.   
  14. BOOL CheckDebug()  
  15. {  
  16.     DWORD ret = CloseWindow((HWND)0x1234);  
  17.     if (ret != 0 || GetLastError() != ERROR_INVALID_WINDOW_HANDLE)  
  18.     {  
  19.         return TRUE;  
  20.     }  
  21.     else  
  22.     {  
  23.         return FALSE;  
  24.     }  
  25. }  

1.5ZwSetInformationThread
ZwSetInformationThread拥有两个参数，第一个参数用来接收当前线程的句柄，第二个参数表示线程信息类型，若其值设置为ThreadHideFromDebugger(0x11)，使用语句ZwSetInformationThread(GetCurrentThread(), ThreadHideFromDebugger, NULL, 0);调用该函数后，调试进程就会被分离出来。该函数不会对正常运行的程序产生任何影响，但若运行的是调试器程序，因为该函数隐藏了当前线程，调试器无法再收到该线程的调试事件，最终停止调试。还有一个函数DebugActiveProcessStop用来分离调试器和被调试进程，从而停止调试。两个API容易混淆，需要牢记它们的区别。
2.手动检测数据结构
虽然使用Windows API是探测调试器存在的最简单办法，但手动检查数据结构是恶意代码编写者最常使用的办法。这是因为很多时候通过Windows API实现的反调试技术无效，例如这些API函数被rootkit挂钩，并返回错误信息。因此，恶意代码编写者经常手动执行与这些API功能相同的操作。在手动检测中，PEB结构中的一些标志暴露了调试器存在的信息。这里，我们关注检测调试器存在常用的一些标志。
2.1检测BeingDebugged属性
Windows操作系统维护着每个正在运行的进程的PEB结构，它包含与这个进程相关的所有用户态参数。这些参数包括进程环境数据，环境数据包括环境变量、加载的模块列表、内存地址，以及调试器状态。


进程运行时，位置fs:[30h]指向PEB的基地址。为了实现反调试技术，恶意代码通过这个位置检查BeingDebugged标志，这个标志标识进程是否正在被调试。

[cpp]  view plain  copy
  1. BOOL CheckDebug()  
  2. {  
  3.     int result = 0;  
  4.     __asm  
  5.     {  
  6.         mov eax, fs:[30h]  
  7.         mov al, BYTE PTR [eax + 2]   
  8.         mov result, al  
  9.     }  
  10.     return result != 0;  
  11. }  

这种检查有多种形式，最终，条件跳转决定代码的路径。避免这种问题最简单的方法是在执行跳转指令前，手动修改零标志，强制执行跳转(或者不跳转)。
可以或者手动修改BeingDebugged属性值为0。在OllyDbg中安装命令行插件，为了启动该插件，用OllyDbg加载恶意代码，选择Plugins->Command Line->Command Line选项,在命令行窗口输入下面的命令。


如图所示，这条命令会将BeingDebugged属性转储到转储面板窗口。右键单击BeingDebugged属性，选择Binary->Fill With 00's，这时属性被设置为0。
OllyDbg的一些插件可以帮助我们修改BeingDebugged标志。其中最流行的有HideDebugger、Hidedebug和PhantOm。以PhantOm为例，同样将dll文件拷贝到OllyDbg的安装目录下就会自动安装。选择Plugins->PhantOm->Options选项，勾选hide from PEB即可。


2.2检测ProcessHeap属性
Reserved数组中一个未公开的位置叫作ProcessHeap，它被设置为加载器为进程分配的第一个堆的位置。ProcessHeap位于PEB结构的0x18处。第一个堆头部有一个属性字段，它告诉内核这个堆是否在调试器中创建。这些属性叫作ForceFlags和Flags。在Windows XP系统中，ForceFlags属性位于堆头部偏移量0x10处；在Windows 7系统中，对于32位的应用程序来说ForceFlags属性位于堆头部偏移量0x44处。
[cpp]  view plain  copy
  1. BOOL CheckDebug()  
  2. {  
  3.     int result = 0;  
  4.     DWORD dwVersion = GetVersion();  
  5.     DWORD dwWindowsMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));  
  6.     //for xp  
  7.     if (dwWindowsMajorVersion == 5)  
  8.     {  
  9.         __asm  
  10.         {  
  11.             mov eax, fs:[30h]  
  12.             mov eax, [eax + 18h]  
  13.             mov eax, [eax + 10h]  
  14.             mov result, eax  
  15.         }  
  16.     }  
  17.     else  
  18.     {  
  19.         __asm  
  20.         {  
  21.             mov eax, fs:[30h]  
  22.             mov eax, [eax + 18h]  
  23.             mov eax, [eax + 44h]  
  24.             mov result, eax  
  25.         }  
  26.     }  
  27.     return result != 0;  
  28. }  

同样，恶意代码也可以检查Windows XP系统中偏移量0x0C处，或者Windows 7系统中偏移量0x40处的Flags属性。这个属性总与ForceFlags属性大致相同，但通常情况下Flags与值2进行比较。

[cpp]  view plain  copy
  1. BOOL CheckDebug()  
  2. {  
  3.     int result = 0;  
  4.     DWORD dwVersion = GetVersion();  
  5.     DWORD dwWindowsMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));  
  6.     //for xp  
  7.     if (dwWindowsMajorVersion == 5)  
  8.     {  
  9.         __asm  
  10.         {  
  11.             mov eax, fs:[30h]  
  12.             mov eax, [eax + 18h]  
  13.             mov eax, [eax + 0ch]  
  14.             mov result, eax  
  15.         }  
  16.     }  
  17.     else  
  18.     {  
  19.         __asm  
  20.         {  
  21.             mov eax, fs:[30h]  
  22.             mov eax, [eax + 18h]  
  23.             mov eax, [eax + 40h]  
  24.             mov result, eax  
  25.         }  
  26.     }  
  27.     return result != 2;  
  28. }  
避免这种问题方法和前面的差不多。如果用OllyDbg的命令行插件修改，输入的命令为dump ds:[fs:[30]+0x18]+0x10。如果用PhantOm插件，它会禁用调试堆创建功能而不需要手动设置。
2.3检测NTGlobalFlag
由于调试器中启动进程与正常模式下启动进程有些不同，所以它们创建内存堆的方式也不同。系统使用PEB结构偏移量0x68处的一个未公开位置，来决定如何创建堆结构。如果这个位置的值为0x70，我们就知道进程正运行在调试器中。
[cpp]  view plain  copy
  1. BOOL CheckDebug()  
  2. {  
  3.     int result = 0;  
  4.     __asm  
  5.     {  
  6.         mov eax, fs:[30h]  
  7.         mov eax, [eax + 68h]  
  8.         and eax, 0x70  
  9.         mov result, eax  
  10.     }  
  11.     return result != 0;  
  12. }  
操作系统创建堆时，值0x70是下列标志的一个组合。如果进程从调试器启动，那么进程的这些标志将被设置。
(FLG_HEAP_ENABLE_TAIL_CHECK|FLG_HEAP_ENABLE_FREE_CHECK|FLG_HEAP_VALIDATE_PARAMETERS)
避免这种问题方法和前面的差不多。如果用OllyDbg的命令行插件修改，输入的命令为dump fs:[30]+0x68。如果用PhantOm插件，它会逃避使用NTGlobalFlag的反调试技术而不需要手动设置。
3.系统痕迹检测
通常，我们使用调试工具来分析恶意代码，但这些工具会在系统中驻留一些痕迹。恶意代码通过搜索这种系统痕迹，来确定你是否试图分析它。
3.1查找调试器引用的注册表项
下面是调试器在注册表中的一个常用位置。
SOFTWARE\Microsoft\Windows NT\CurrentVersion\AeDebug(32位系统)
SOFTWARE\Wow6432Node\Microsoft\WindowsNT\CurrentVersion\AeDebug(64位系统)
该注册表项指定当应用程序发生错误时，触发哪一个调试器。默认情况下，它被设置为Dr.Watson。如果该这册表的键值被修改为OllyDbg，则恶意代码就可能确定它正在被调试。
[cpp]  view plain  copy
  1. BOOL CheckDebug()  
  2. {  
  3.     BOOL is_64;  
  4.     IsWow64Process(GetCurrentProcess(), &is_64);  
  5.     HKEY hkey = NULL;  
  6.     char key[] = "Debugger";  
  7.     char reg_dir_32bit[] = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug";  
  8.     char reg_dir_64bit[] = "SOFTWARE\\Wow6432Node\\Microsoft\\WindowsNT\\CurrentVersion\\AeDebug";  
  9.     DWORD ret = 0;  
  10.     if (is_64)  
  11.     {  
  12.         ret = RegCreateKeyA(HKEY_LOCAL_MACHINE, reg_dir_64bit, &hkey);  
  13.     }  
  14.     else  
  15.     {  
  16.         ret = RegCreateKeyA(HKEY_LOCAL_MACHINE, reg_dir_32bit, &hkey);  
  17.     }  
  18.     if (ret != ERROR_SUCCESS)  
  19.     {  
  20.         return FALSE;  
  21.     }  
  22.     char tmp[256];  
  23.     DWORD len = 256;  
  24.     DWORD type;  
  25.     ret = RegQueryValueExA(hkey, key, NULL, &type, (LPBYTE)tmp, &len);  
  26.     if (strstr(tmp, "OllyIce")!=NULL || strstr(tmp, "OllyDBG")!=NULL || strstr(tmp, "WinDbg")!=NULL || strstr(tmp, "x64dbg")!=NULL || strstr(tmp, "Immunity")!=NULL)  
  27.     {  
  28.         return TRUE;  
  29.     }  
  30.     else  
  31.     {  
  32.         return FALSE;  
  33.     }  
  34. }  

3.2查找窗体信息
FindWindow函数检索处理顶级窗口的类名和窗口名称匹配指定的字符串。

[cpp]  view plain  copy
  1. BOOL CheckDebug()  
  2. {  
  3.     if (FindWindowA("OLLYDBG", NULL)!=NULL || FindWindowA("WinDbgFrameClass", NULL)!=NULL || FindWindowA("QWidget", NULL)!=NULL)  
  4.     {  
  5.         return TRUE;  
  6.     }  
  7.     else  
  8.     {  
  9.         return FALSE;  
  10.     }  
  11. }  

EnumWindows函数枚举所有屏幕上的顶层窗口，并将窗口句柄传送给应用程序定义的回调函数。

[cpp]  view plain  copy
  1. BOOL CALLBACK EnumWndProc(HWND hwnd, LPARAM lParam)    
  2. {    
  3.     char cur_window[1024];  
  4.     GetWindowTextA(hwnd, cur_window, 1023);  
  5.     if (strstr(cur_window, "WinDbg")!=NULL || strstr(cur_window, "x64_dbg")!=NULL || strstr(cur_window, "OllyICE")!=NULL || strstr(cur_window, "OllyDBG")!=NULL || strstr(cur_window, "Immunity")!=NULL)  
  6.     {  
  7.         *((BOOL*)lParam) = TRUE;  
  8.     }  
  9.     return TRUE;  
  10. }   
[cpp]  view plain  copy
  1. BOOL CheckDebug()  
  2. {  
  3.     BOOL ret = FALSE;  
  4.     EnumWindows(EnumWndProc, (LPARAM)&ret);   
  5.     return ret;  
  6. }  

GetForegroundWindow获取一个前台窗口的句柄。

 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  BOOL CheckDebug()  
  2.  {  
  3.      char fore_window[1024];  
  4.      GetWindowTextA(GetForegroundWindow(), fore_window, 1023);  
  5.      if (strstr(fore_window, "WinDbg")!=NULL || strstr(fore_window, "x64_dbg")!=NULL || strstr(fore_window, "OllyICE")!=NULL || strstr(fore_window, "OllyDBG")!=NULL || strstr(fore_window, "Immunity")!=NULL)  
  6.      {  
  7.          return TRUE;  
  8.      }  
  9.      else  
  10.      {  
  11.          return FALSE;  
  12.      }  
  13.  }  
 

 

 为了防范这种技术，在OllyDbg的PhantOm插件中勾选hide OllyDbg windows。
 3.3查找进程信息
 
 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  BOOL CheckDebug()  
  2.  {  
  3.      DWORD ID;  
  4.      DWORD ret = 0;  
  5.      PROCESSENTRY32 pe32;  
  6.      pe32.dwSize = sizeof(pe32);   
  7.      HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);   
  8.      if(hProcessSnap == INVALID_HANDLE_VALUE)   
  9.      {   
  10.          return FALSE;   
  11.      }  
  12.      BOOL bMore = Process32First(hProcessSnap, &pe32);   
  13.      while(bMore)  
  14.      {  
  15.          if (stricmp(pe32.szExeFile, "OllyDBG.EXE")==0 || stricmp(pe32.szExeFile, "OllyICE.exe")==0 || stricmp(pe32.szExeFile, "x64_dbg.exe")==0 || stricmp(pe32.szExeFile, "windbg.exe")==0 || stricmp(pe32.szExeFile, "ImmunityDebugger.exe")==0)  
  16.          {  
  17.              return TRUE;  
  18.          }  
  19.          bMore = Process32Next(hProcessSnap, &pe32);   
  20.      }  
  21.      CloseHandle(hProcessSnap);   
  22.      return FALSE;  
  23.  }  
 

 
二.识别调试器行为 

 
在逆向工程中，为了帮助恶意代码分析人员进行分析，可以使用调试器设置一个断点，或是单步执行一个进程。然而，在调试器中执行这些操作时，它们会修改进程中的代码。因此，恶意代码常使用几种反调试技术探测软件/硬件断点、完整性校验、时钟检测等几种类型的调试器行为。直接运行恶意代码与在调试器中运行恶意代码也会在一些细节上不同，如父进程信息、STARTUPINFO信息、SeDebugPrivilege权限等。 

 
1.软件断点检查 

 
调试器设置断点的基本机制是用软件中断指令INT 3临时替换运行程序中的一条指令，然后当程序运行到这条指令时，调用调试异常处理例程。INT 3指令的机器码是0xCC，因此无论何时，使用调试器设置一个断点，它都会插入一个0xCC来修改代码。恶意代码常用的一种反调试技术是在它的代码中查找机器码0xCC，来扫描调试器对它代码的INT 3修改。repne scasb指令用于在一段数据缓冲区中搜索一个字节。EDI需指向缓冲区地址，AL则包含要找的字节，ECX设为缓冲区的长度。当ECX=0或找到该字节时，比较停止。 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  BOOL CheckDebug()  
  2.  {  
  3.      PIMAGE_DOS_HEADER pDosHeader;  
  4.      PIMAGE_NT_HEADERS32 pNtHeaders;  
  5.      PIMAGE_SECTION_HEADER pSectionHeader;  
  6.      DWORD dwBaseImage = (DWORD)GetModuleHandle(NULL);   
  7.      pDosHeader = (PIMAGE_DOS_HEADER)dwBaseImage;  
  8.      pNtHeaders = (PIMAGE_NT_HEADERS32)((DWORD)pDosHeader + pDosHeader->e_lfanew);  
  9.      pSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD)pNtHeaders + sizeof(pNtHeaders->Signature) + sizeof(IMAGE_FILE_HEADER) +   
  10.                       (WORD)pNtHeaders->FileHeader.SizeOfOptionalHeader);  
  11.      DWORD dwAddr = pSectionHeader->VirtualAddress + dwBaseImage;   
  12.      DWORD dwCodeSize = pSectionHeader->SizeOfRawData;      
  13.      BOOL Found = FALSE;  
  14.      __asm  
  15.      {  
  16.          cld               
  17.          mov     edi,dwAddr  
  18.          mov     ecx,dwCodeSize  
  19.          mov     al,0CCH   
  20.          repne   scasb  
  21.          jnz     NotFound  
  22.          mov Found,1  
  23.  NotFound:           
  24.      }  
  25.      return Found;  
  26.  }  
 

 

 2.硬件断点检查
 

 
 
 

 在OllyDbg的寄存器窗口按下右键，点击View debug registers可以看到DR0、DR1、DR2、DR3、DR6和DR7这几个寄存器。DR0、Dr1、Dr2、Dr3用于设置硬件断点，由于只有4个硬件断点寄存器，所以同时最多只能设置4个硬件断点。DR4、DR5由系统保留。  DR6、DR7用于记录Dr0-Dr3中断点的相关属性。如果没有硬件断点，那么DR0、DR1、DR2、DR3这4个寄存器的值都为0。
 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  BOOL CheckDebug()  
  2.  {  
  3.      CONTEXT context;    
  4.      HANDLE hThread = GetCurrentThread();    
  5.      context.ContextFlags = CONTEXT_DEBUG_REGISTERS;    
  6.      GetThreadContext(hThread, &context);    
  7.      if (context.Dr0 != 0 || context.Dr1 != 0 || context.Dr2 != 0 || context.Dr3!=0)     
  8.      {    
  9.          return TRUE;    
  10.      }    
  11.      return FALSE;    
  12.  }  
 

 
3.执行代码校验和检查 

 
恶意代码可以计算代码段的校验并实现与扫描中断相同的目的。与扫描0xCC不同，这种检查仅执行恶意代码中机器码CRC或者MD5校验和检查。 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  BOOL CheckDebug()  
  2.  {  
  3.      PIMAGE_DOS_HEADER pDosHeader;  
  4.      PIMAGE_NT_HEADERS32 pNtHeaders;  
  5.      PIMAGE_SECTION_HEADER pSectionHeader;  
  6.      DWORD dwBaseImage = (DWORD)GetModuleHandle(NULL);   
  7.      pDosHeader = (PIMAGE_DOS_HEADER)dwBaseImage;  
  8.      pNtHeaders = (PIMAGE_NT_HEADERS32)((DWORD)pDosHeader + pDosHeader->e_lfanew);  
  9.      pSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD)pNtHeaders + sizeof(pNtHeaders->Signature) + sizeof(IMAGE_FILE_HEADER) +  
  10.          (WORD)pNtHeaders->FileHeader.SizeOfOptionalHeader);  
  11.      DWORD dwAddr = pSectionHeader->VirtualAddress + dwBaseImage;   
  12.      DWORD dwCodeSize = pSectionHeader->SizeOfRawData;      
  13.      DWORD checksum = 0;  
  14.      __asm  
  15.      {  
  16.          cld  
  17.          mov     esi, dwAddr  
  18.          mov     ecx, dwCodeSize  
  19.          xor eax, eax  
  20.      checksum_loop :  
  21.          movzx    ebx, byte ptr[esi]  
  22.          add        eax, ebx  
  23.          rol eax, 1  
  24.          inc esi  
  25.          loop       checksum_loop  
  26.          mov checksum, eax  
  27.      }  
  28.      if (checksum != 0x46ea24)  
  29.      {  
  30.          return FALSE;  
  31.      }  
  32.      else  
  33.      {  
  34.          return TRUE;  
  35.      }  
  36.  }  
 

 
4.时钟检测 

 
被调试时，进程的运行速度大大降低，例如，单步调试大幅降低恶意代码的运行速度，所以时钟检测是恶意代码探测调试器存在的最常用方式之一。有如下两种用时钟检测来探测调试器存在的方法。 

 
记录一段操作前后的时间戳，然后比较这两个时间戳，如果存在滞后，则可以认为存在调试器。 

 
记录触发一个异常前后的时间戳。如果不调试进程，可以很快处理完异常，因为调试器处理异常的速度非常慢。默认情况下，调试器处理异常时需要人为干预，这导致大量延迟。虽然很多调试器允许我们忽略异常，将异常直接返回程序，但这样操作仍然存在不小的延迟。 

 
4.1使用rdtsc指令 

 
较常用的时钟检测方法是利用rdtsc指令(操作码0x0F31)，它返回至系统重新启动以来的时钟数，并且将其作为一个64位的值存入EDX:EAX中。恶意代码运行两次rdtsc指令，然后比较两次读取之间的差值。 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  BOOL CheckDebug()  
  2.  {  
  3.      DWORD time1, time2;  
  4.      __asm  
  5.      {  
  6.          rdtsc  
  7.          mov time1, eax  
  8.          rdtsc  
  9.          mov time2, eax  
  10.      }  
  11.      if (time2 - time1 < 0xff)  
  12.      {  
  13.          return FALSE;  
  14.      }  
  15.      else  
  16.      {  
  17.          return TRUE;  
  18.      }  
  19.  }  
 

 
4.2使用QueryPerformanceCounter和GetTickCount 

 
同rdtsc指令一样，这两个Windows API函数也被用来执行一个反调试的时钟检测。使用这种方法的前提是处理器有高分辨率能力的计数器-寄存器，它能存储处理器活跃的时钟数。为了获取比较的时间差，调用两次QueryPerformanceCounter函数查询这个计数器。若两次调用之间花费的时间过于长，则可以认为正在使用调试器。GetTickCount函数返回最近系统重启时间与当前时间的相差毫秒数(由于时钟计数器的大小原因，计数器每49.7天就被重置一次)。 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  BOOL CheckDebug()  
  2.  {  
  3.      DWORD time1 = GetTickCount();  
  4.      __asm  
  5.      {  
  6.          mov     ecx,10             
  7.          mov     edx,6                 
  8.          mov     ecx,10  
  9.      }  
  10.      DWORD time2 = GetTickCount();  
  11.      if (time2-time1 > 0x1A)  
  12.      {  
  13.          return TRUE;  
  14.      }  
  15.      else  
  16.      {  
  17.          return FALSE;  
  18.      }  
  19.  }  
 

 

 5.判断父进程是否是explorer.exe 
 一般双击运行的进程的父进程都是explorer.exe，但是如果进程被调试父进程则是调试器进程。也就是说如果父进程不是explorer.exe则可以认为程序正在被调试。
 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  BOOL CheckDebug()  
  2.  {  
  3.      LONG                      status;    
  4.      DWORD                     dwParentPID = 0;    
  5.      HANDLE                    hProcess;    
  6.      PROCESS_BASIC_INFORMATION pbi;    
  7.      int pid = getpid();  
  8.      hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);    
  9.      if(!hProcess)    
  10.          return -1;    
  11.      PNTQUERYINFORMATIONPROCESS  NtQueryInformationProcess = (PNTQUERYINFORMATIONPROCESS)GetProcAddress(GetModuleHandleA("ntdll"),"NtQueryInformationProcess");  
  12.      status = NtQueryInformationProcess(hProcess,SystemBasicInformation,(PVOID)&pbi,sizeof(PROCESS_BASIC_INFORMATION),NULL);  
  13.      PROCESSENTRY32 pe32;  
  14.      pe32.dwSize = sizeof(pe32);   
  15.      HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);   
  16.      if(hProcessSnap == INVALID_HANDLE_VALUE)   
  17.      {   
  18.          return FALSE;   
  19.      }  
  20.      BOOL bMore = Process32First(hProcessSnap, &pe32);   
  21.      while(bMore)  
  22.      {  
  23.          if (pbi.InheritedFromUniqueProcessId == pe32.th32ProcessID)  
  24.          {  
  25.              if (stricmp(pe32.szExeFile, "explorer.exe")==0)  
  26.              {  
  27.                  CloseHandle(hProcessSnap);  
  28.                  return FALSE;  
  29.              }  
  30.              else  
  31.              {  
  32.                  CloseHandle(hProcessSnap);  
  33.                  return TRUE;  
  34.              }  
  35.          }  
  36.          bMore = Process32Next(hProcessSnap, &pe32);   
  37.      }  
  38.      CloseHandle(hProcessSnap);  
  39.  }  
 

 
6.判断STARTUPINFO信息 

 
explorer.exe创建进程的时候会把STARTUPINFO结构中的值设为0，而非explorer.exe创建进程的时候会忽略这个结构中的值，也就是结构中的值不为0。所以可以利用STARTUPINFO来判断程序是否在被调试。 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  BOOL CheckDebug()  
  2.  {  
  3.      STARTUPINFO si;  
  4.      GetStartupInfo(&si);  
  5.      if (si.dwX!=0 || si.dwY!=0 || si.dwFillAttribute!=0 || si.dwXSize!=0 || si.dwYSize!=0 || si.dwXCountChars!=0 || si.dwYCountChars!=0)  
  6.      {  
  7.          return TRUE;  
  8.      }  
  9.      else  
  10.      {  
  11.          return FALSE;  
  12.      }  
  13.  }  
 

 

 7.判断是否具有SeDebugPrivilege权限
 默认情况下进程是没有SeDebugPrivilege权限的，但是当进程通过调试器启动时，由于调试器本身启动了SeDebugPrivilege权限，当调试进程被加载时SeDebugPrivilege也就被继承了。所以我们可以检测进程的SeDebugPrivilege权限来间接判断是否存在调试器，而对SeDebugPrivilege权限的判断可以用能否打开csrss.exe进程来判断。
 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  BOOL CheckDebug()  
  2.  {  
  3.      DWORD ID;  
  4.      DWORD ret = 0;  
  5.      PROCESSENTRY32 pe32;  
  6.      pe32.dwSize = sizeof(pe32);   
  7.      HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);   
  8.      if(hProcessSnap == INVALID_HANDLE_VALUE)   
  9.      {   
  10.          return FALSE;   
  11.      }  
  12.      BOOL bMore = Process32First(hProcessSnap, &pe32);   
  13.      while(bMore)  
  14.      {  
  15.          if (strcmp(pe32.szExeFile, "csrss.exe")==0)  
  16.          {  
  17.              ID = pe32.th32ProcessID;  
  18.              break;  
  19.          }  
  20.          bMore = Process32Next(hProcessSnap, &pe32);   
  21.      }  
  22.      CloseHandle(hProcessSnap);   
  23.      if (OpenProcess(PROCESS_QUERY_INFORMATION, NULL, ID) != NULL)  
  24.      {  
  25.          return TRUE;  
  26.      }  
  27.      else  
  28.      {  
  29.          return FALSE;  
  30.      }  
  31.  }  
 

 

 三.干扰调试器的功能
 恶意代码可以用一些技术来干扰调试器的正常运行。例如线程本地存储(TLS)回调、插入中断、异常等。这些技术当且仅当程序处于调试器控制之下时才试图扰乱程序的运行。
 1.使用TLS回调
 Thread Local Storage(TLS)，即线程本地存储，是Windows为解决一个进程中多个线程同时访问全局变量而提供的机制。TLS可以简单地由操作系统代为完成整个互斥过程，也可以由用户自己编写控制信号量的函数。当进程中的线程访问预先制定的内存空间时，操作系统会调用系统默认的或用户自定义的信号量函数，保证数据的完整性与正确性。下面是一个简单的TLS回调的例子，TLS_CALLBACK1函数在main函数执行前调用IsDebuggerPresent函数检查它是否正在被调试。
 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  #include "stdafx.h"  
  2.  #include <stdio.h>  
  3.  #include <windows.h>  
  4.    
  5.  void NTAPI __stdcall TLS_CALLBACK1(PVOID DllHandle, DWORD dwReason, PVOID Reserved);  
  6.    
  7.  #ifdef _M_IX86  
  8.  #pragma comment (linker, "/INCLUDE:__tls_used")  
  9.  #pragma comment (linker, "/INCLUDE:__tls_callback")  
  10.  #else  
  11.  #pragma comment (linker, "/INCLUDE:_tls_used")  
  12.  #pragma comment (linker, "/INCLUDE:_tls_callback")  
  13.  #endif  
  14.  EXTERN_C  
  15.  #ifdef _M_X64  
  16.  #pragma const_seg (".CRT$XLB")  
  17.  const  
  18.  #else  
  19.  #pragma data_seg (".CRT$XLB")  
  20.  #endif  
  21.    
  22.  PIMAGE_TLS_CALLBACK _tls_callback[] = { TLS_CALLBACK1,0};  
  23.  #pragma data_seg ()  
  24.  #pragma const_seg ()  
  25.    
  26.  #include <iostream>  
  27.    
  28.  void NTAPI __stdcall TLS_CALLBACK1(PVOID DllHandle, DWORD Reason, PVOID Reserved)  
  29.  {  
  30.      if (IsDebuggerPresent())  
  31.      {  
  32.          printf("TLS_CALLBACK: Debugger Detected!\n");  
  33.      }  
  34.      else  
  35.      {  
  36.          printf("TLS_CALLBACK: No Debugger Present!\n");  
  37.      }  
  38.  }  
  39.    
  40.  int main(int argc, char* argv[])  
  41.  {  
  42.      printf("233\n");  
  43.      return 0;  
  44.  }  
 

 

 要在程序中使用TLS，必须为TLS数据单独建一个数据段，用相关数据填充此段，并通知链接器为TLS数据在PE文件头中添加数据。_tls_callback[]数组中保存了所有的TLS回调函数指针。数组必须以NULL指针结束，且数组中的每一个回调函数在程序初始化时都会被调用，程序员可按需要添加。但程序员不应当假设操作系统已何种顺序调用回调函数。如此则要求在TLS回调函数中进行反调试操作需要一定的独立性。
 正常运行这个程序会打印下面的内容。
 TLS_CALLBACK: No Debugger Present!
 233
 如果把在OllyDbg中运行，在OllyDbg暂停之前会打印下面的内容。
 TLS_CALLBACK: Debugger Detected!
 使用PEview查看.tls段，可以发现TLS回调函数。通常情况下，正常程序不使用.tls段，如果在可执行程序中看到.tls段，应该立即怀疑它使用了反调试技术。
 
 

 
 
 

 在OllyDbg中选择Options->Debugging Options->Events，然后设置System break-point作为第一个暂停的位置，这样就可以让OllyDbg在TLS回调执行前暂停。
 

 
 
 

 在IDA Pro中按Ctrl+E快捷键看到二进制的入口点，该组合键的作用是显示应用程序所有的入口点，其中包括TLS回调。双击函数名可以浏览回调函数。
 

 
 
 

 
 
 

 由于TLS回调已广为人知，因此同过去相比，恶意代码使用它的次数已经明显减少。为数不多的合法程序使用TLS回调，所以可执行程序中的.tls段特别突出。
 2.利用中断
 因为调试器使用INT 3来设置软件断点，所以一种反调试技术就是在合法代码段中插入0xCC(INT 3)欺骗调试器，使其认为这些0xCC机器码是自己设置的断点。
 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  BOOL CheckDebug()  
  2.  {  
  3.        __try  
  4.        {  
  5.              __asm int 3  
  6.        }  
  7.        __except(1)  
  8.        {  
  9.              return FALSE;  
  10.        }  
  11.        return TRUE;  
  12.  }  
 

 
除了使用_try和_except以外还可以直接使用汇编代码安装SEH。在下面的代码中如果进程没有处于调试中，则正常终止；如果进程处于调试中，则跳转到非法地址0xFFFFFFFF处，无法继续调试。 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  #include "stdio.h"  
  2.  #include "windows.h"  
  3.  #include "tchar.h"  
  4.    
  5.  void AD_BreakPoint()  
  6.  {  
  7.      printf("SEH : BreakPoint\n");  
  8.    
  9.      __asm {  
  10.          // install SEH  
  11.          push handler  
  12.          push DWORD ptr fs:[0]  
  13.          mov DWORD ptr fs:[0], esp  
  14.            
  15.          // generating exception  
  16.          int 3  
  17.    
  18.          // 1) debugging  
  19.          //    go to terminating code  
  20.          mov eax, 0xFFFFFFFF  
  21.          jmp eax                 // process terminating!!!  
  22.    
  23.          // 2) not debugging  
  24.          //    go to normal code  
  25.  handler:  
  26.          mov eax, dword ptr ss:[esp+0xc]  
  27.          mov ebx, normal_code  
  28.          mov dword ptr ds:[eax+0xb8], ebx  
  29.          xor eax, eax  
  30.          retn  
  31.    
  32.  normal_code:  
  33.          //   remove SEH  
  34.          pop dword ptr fs:[0]  
  35.          add esp, 4  
  36.      }  
  37.    
  38.      printf("  => Not debugging...\n\n");  
  39.  }  
  40.    
  41.  int _tmain(int argc, TCHAR* argv[])  
  42.  {  
  43.      AD_BreakPoint();  
  44.    
  45.      return 0;  
  46.  }  
 

 

 双字节操作码0xCD03也可以产生INT 3中断，这是恶意代码干扰WinDbg调试器的有效方法。在调试器外，0xCD03指令产生一个STATUS_BREAKPOINT异常。然而在WinDbg调试器内，由于断点通常是单字节机器码0xCC，因此WinDbg会捕获这个断点然后将EIP加1字节。这可能导致程序在被正常运行的WinDbg调试时，执行不同的指令集(OllyDbg可以避免双字节INT 3的攻击)。
 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  BOOL CheckDebug()  
  2.  {  
  3.        __try  
  4.        {  
  5.              __asm  
  6.              {  
  7.                    __emit 0xCD  
  8.                    __emit 0x03  
  9.              }  
  10.        }  
  11.        __except(1)  
  12.        {  
  13.              return FALSE;  
  14.        }  
  15.        return TRUE;   
  16.  }  
 

 

 INT 2D原为内核模式中用来触发断点异常的指令，也可以在用户模式下触发异常。但程序调试运行时不会触发异常，只是忽略。INT 2D指令在ollydbg中有两个有趣的特性。在调试模式中执行INT 2D指令，下一条指令的第一个字节将被忽略。使用StepInto(F7)或者StepOver(F8)命令跟踪INT 2D指令，程序不会停在下一条指令开始的地方，而是一直运行，就像RUN(F9)一样。在下面的代码中，程序调试运行时，执行INT 2D之后不会运行SEH，而是跳过NOP，把bDebugging标志设置为1，跳转到normal_code；程序正常运行时，执行INT 2D之后触发SEH，在异常处理器中设置EIP并把bDebugging标志设置为0。
 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  BOOL CheckDebug()  
  2.  {  
  3.      BOOL bDebugging = FALSE;  
  4.    
  5.      __asm {  
  6.          // install SEH  
  7.          push handler  
  8.          push DWORD ptr fs:[0]  
  9.          mov DWORD ptr fs:[0], esp  
  10.            
  11.          int 0x2d  
  12.    
  13.          nop  
  14.          mov bDebugging, 1  
  15.          jmp normal_code  
  16.    
  17.  handler:  
  18.          mov eax, dword ptr ss:[esp+0xc]  
  19.          mov dword ptr ds:[eax+0xb8], offset normal_code  
  20.          mov bDebugging, 0  
  21.          xor eax, eax  
  22.          retn  
  23.    
  24.  normal_code:  
  25.          //   remove SEH  
  26.          pop dword ptr fs:[0]  
  27.          add esp, 4  
  28.      }  
  29.    
  30.      printf("Trap Flag (INT 2D)\n");  
  31.      if( bDebugging )  return 1;  
  32.      else              return 0;  
  33.  }  
 

 

 片内仿真器(ICE)断点指令ICEBP(操作码0xF1)是Intel未公开的指令之一。由于使用ICE难以在任意位置设置断点，因此ICEBP指令被设计用来降低使用ICE设置断点的难度。运行ICEBP指令将会产生一个单步异常，如果通过单步调试跟踪程序，调试器会认为这是单步调试产生的异常，从而不执行先前设置的异常处理例程。利用这一点，恶意代码使用异常处理例程作为它的正常执行流程。为了防止这种反调试技术，执行ICEBP指令时不要使用单步。
 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  BOOL CheckDebug()  
  2.  {  
  3.        __try  
  4.        {  
  5.              __asm __emit 0xF1  
  6.        }  
  7.        __except(1)  
  8.        {  
  9.              return FALSE;  
  10.        }  
  11.        return TRUE;  
  12.  }  
 

 

 3.设置陷阱标志位
 EFLAGS寄存器的第八个比特位是陷阱标志位。如果设置了，就会产生一个单步异常。
 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  BOOL CheckDebug()  
  2.  {  
  3.        __try  
  4.        {  
  5.              __asm  
  6.              {  
  7.                    pushfd       
  8.                    or word ptr[esp], 0x100              
  9.                    popfd  
  10.                    nop          
  11.              }  
  12.        }  
  13.        __except(1)  
  14.        {  
  15.              return FALSE;  
  16.        }  
  17.        return TRUE;  
  18.  }  
 

 

 4.使用异常
 前面已经讨论了各种使用异常机制的反调试手段。
 4.1RaiseException
 RaiseException函数产生的若干不同类型的异常可以被调试器捕获。
 
 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  BOOL TestExceptionCode(DWORD dwCode)  
  2.  {  
  3.        __try  
  4.        {  
  5.              RaiseException(dwCode, 0, 0, 0);  
  6.        }  
  7.        __except(1)  
  8.        {  
  9.              return FALSE;  
  10.        }  
  11.        return TRUE;  
  12.  }  
  13.     
  14.  BOOL CheckDebug()  
  15.  {  
  16.        return TestExceptionCode(DBG_RIPEXCEPTION);      
  17.  }  
 

 

 4.2SetUnhandledExceptionFilter
 进程中发生异常时若SEH未处理或注册的SEH不存在，会调用UnhandledExceptionFilter，它会运行系统最后的异常处理器。UnhandledExceptionFilter内部调用了前面提到过的NtQueryInformationProcess以判断是否正在调试进程。若进程正常运行，则运行最后的异常处理器；若进程处于调试，则将异常派送给调试器。SetUnhandledExceptionFilter函数可以修改系统最后的异常处理器。下面的代码先触发异常，然后在新注册的最后的异常处理器内部判断进程正常运行还是调试运行。进程正常运行时pExcept->ContextRecord->Eip+=4;将发生异常的代码地址加4使得其能够继续运行；进程调试运行时产生无效的内存访问异常，从而无法继续调试。
 
 

 
 
 
  
 
   [cpp]  
   view plain 
    copy 
   
 
   
 
    
  
 
 
 
 
  1.  #include "stdio.h"  
  2.  #include "windows.h"  
  3.  #include "tchar.h"  
  4.    
  5.  LPVOID g_pOrgFilter = 0;  
  6.    
  7.  LONG WINAPI ExceptionFilter(PEXCEPTION_POINTERS pExcept)  
  8.  {  
  9.      SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)g_pOrgFilter);  
  10.    
  11.      // 8900    MOV DWORD PTR DS:[EAX], EAX  
  12.      // FFE0    JMP EAX  
  13.      pExcept->ContextRecord->Eip += 4;  
  14.    
  15.      return EXCEPTION_CONTINUE_EXECUTION;  
  16.  }  
  17.    
  18.  void AD_SetUnhandledExceptionFilter()  
  19.  {  
  20.      printf("SEH : SetUnhandledExceptionFilter()\n");  
  21.    
  22.      g_pOrgFilter = (LPVOID)SetUnhandledExceptionFilter(  
  23.                                  (LPTOP_LEVEL_EXCEPTION_FILTER)ExceptionFilter);  
  24.    
  25.      __asm {  
  26.          xor eax, eax;  
  27.          mov dword ptr [eax], eax  
  28.          jmp eax                       
  29.      }  
  30.        
  31.      printf("  => Not debugging...\n\n");  
  32.  }  
  33.    
  34.  int _tmain(int argc, TCHAR* argv[])  
  35.  {  
  36.      AD_SetUnhandledExceptionFilter();  
  37.    
  38.      return 0;  
  39.  }  
 

 

 在OllyDbg中，选择Options->Debugging Options->Exceptions来设置把异常传递给应用程序。
 
 

 
 
 

 四.调试器漏洞
 与所有软件一样，调试器也存在漏洞，有时恶意代码编写者为了防止被调试，会攻击这些漏洞。这里我们展示几种OllyDbg调试器处理PE格式文件时的常见漏洞。
 1.PE头漏洞
 OllyDbg非常严格地遵循了微软对PE文件头部的规定。在PE文件的头部，通常存在一个叫作IMAGE_OPTIONAL_HEADER的结构。
 
 

 
 
 

 需要特别注意这个结构中的最后几个元素。NumberOfRvaAndSizes属性标识后面DataDirectory数组中的元素个数。DataDirectory数组表示在这个可执行文件中的什么地方可找到其他导入可执行模块的位置，它位于可选头部结构的末尾，是一个比IMAGE_DATA_DIRECTORY略大一些的数组。数组中每个结构目录都指明了目录的相对虚拟地址和大小。DataDirectory数组的大小被设置为IMAGE_NUMBEROF_DIRECTORY_ENTRIES，它等于0x10。因为DataDirectory数组不足以容纳超过0x10个目录项，所以当NumberOfRvaAndSizes大于0x10时，Windows加载器将会忽略NumberOfRvaAndSizes。OllyDbg遵循了这个标准，并且无论NumberOfRvaAndSizes是什么值，OllyDbg都使用它。因此，设置NumberOfRvaAndSizes为一个超过0x10的值，会导致在程序退出前，OllyDbg对用户弹出一个窗口。如图所示，使用LordPE打开可执行文件，修改RVA数及大小并保存，再用OllyDbg打开，会提示错误Bad or unknown format of 32-bit executable file。
 

 
 
 

 
 
 

 另一种PE头的欺骗与节头部有关。文件内容中包含的节包括代码节、数据节、资源节，以及一些其他信息节。每个节都拥有一个IMAGE_SECTION_HEADER结构的头部。
 

 
 
 

 VirtualSize和SizeOfRawData是其中两个比较重要的属性。根据微软对PE的规定，VirtualSize应该包含载入到内存的节大小，SizeOfRawData应该包含节在硬盘中的大小。Windows加载器使用VirtualSize和SizeOfRawData中的最小值将节数据映射到内存。如果SizeOfRawData大于VirtualSize，则仅将VirtualSize大小的数据复制入内存，忽略其余数据。因为OllyDbg仅使用SizeOfRawData，所以设置SizeOfRawData为一个类似0x77777777的大数值时，会导致OllyDbg崩溃。如图所示，使用LordPE打开可执行文件，点击区段，在区段表上右击，点击编辑区段，修改物理大小并保存，再用OllyDbg打开，会提示同样的错误。
 

 
 
 

 对抗这种反调试技术的最简单方法是用类似的编辑器手动修改PE头部。OllyDbg2.0和WinDbg不存在这种漏洞。
 2.OutputDebugString漏洞
 恶意代码常尝试利用OllyDbg1.1的格式化字符串漏洞，为OutputDebugString函数提供一个%s字符串的参数，让OllyDbg崩溃。因此，需要注意程序中可疑的OutputDebugString调用，例如OutputDebugString("%s%s%s%s%s%s%s%s%s")。如果执行了这个调用，OllyDbg将会崩溃。
 

 总结
 
 

 最后让我们总结一下提到的内容。腾讯2016游戏安全技术竞赛有一道题，大概意思就是给一个exe，要求编写一个Tencent2016D.dll，并导出多个接口函数CheckDebugX。X为1-100之间的数字，比如CheckDebug1，CheckDebug8，...，CheckDebug98。函数功能是检测自己是否处于被调试状态，是返回TRUE，否则返回FALSE。函数的原型都是typedef BOOL (WINAPI* Type_CheckDebug)();。编译好dll之后，放在Tencent2016D.exe的同目录，运行Tencent2016D.exe，点击检测按钮，正常运行时，函数接口输出为0，调试运行或者被附加运行时，接口输出1。我们把提到的知识综合一下完成这道题目。
 解题的参考代码和题目相关信息：https://github.com/houjingyi233/test-debug/
 参考资料：《恶意代码分析实战》第16章反调试技术、《逆向工程核心原理》第51章静态反调试技术&第52章动态反调试技术、freebuf技术分享：利用异常实现反调试、天枢战队官方博客、吾爱破解论坛、《windows anti-debugger reference》

                

        

        

    

  


    

      

        

            

              
                
                  H-KING
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
【C++软件调试技术】C++软件开发维护过程中典型软件异常问题的排查与总结

				
			

			

				

					dvlinker的技术专栏
				

				

					04-15
					
					4万+
					
				

			

		

		

			
				
本文以问答的方式进行展开，罗列了C++软件日常开发和维护中遇到的多个软件调试问题及有代表性的场景，给出详细的处置思路和处理办法，以供大家借鉴和参考。

			
		

	



                

              
                



	

		

			

				
					
反调试技术

				
			

			

				

					bj5716的博客
				

				

					04-21
					
					964
					
				

			

		

		

			
				
前言反调试技术可以被恶意代码用来识别是否被调试，或者让调试器失效，而倘若想要分析相应的包含反调试机制的恶意代码，则需要进行一些操作。我们先来看看主流的一些反调试技术。0x1探测调试器使用windows api使用windows api函数探测调试器是否存在是最简单的反调试技术。下面是一些apiIsDebuggerPresent它查询PEB中的IsDebugged标志。如果进程没有运行在调试器环境中...

			
		

	



                


  
              

                


	

		

			

				
					
反调试技术揭秘（转）

				
			

			

				

					weixin_33935505的博客
				

				

					03-04
					
					525
					
				

			

		

		

			
				
在调试一些病毒程序的时候，可能会碰到一些反调试技术，也就是说，被调试的程序可以检测到自己是否被调试器附加了，如果探知自己正在被调试，肯定是有人试图反汇编啦之类的方法破解自己。为了了解如何破解反调试技术，首先我们来看看反调试技术。
 
一、Windows API方法
 
Win32提供了两个API, IsDebuggerPresent和CheckRemoteDebuggerPresent可以...

			
		

	





	

		

			

				
					
反调试技巧总结-原理和实现

				
			

			

				

					weixin_30535843的博客
				

				

					06-07
					
					424
					
				

			

		

		

			
				
来源：http://bbs.pediy.com/showthread.php?t=70470 作者：shellwolf 时间：2008-08-10,22:40:53


一、 前言
 前段学习反调试和vc，写了antidebug-tester，经常会收到message希望交流或索要实现代码，我都没有回复。其实代码已经在编程版提供了1个版本，另其多是vc内嵌asm...

			
		

	



		

			
		



	

		

			

				
					
iOS安全防护系列之ptrace反调试与汇编调用系统方法详解

				
			

			

				

					08-27
				

			

		

		

			
				
本文将深入探讨ptrace反调试技术以及汇编调用系统方法，这些都是iOS开发者和安全研究人员必备的知识。  首先，ptrace是一个系统调用，允许一个进程监视和控制另一个进程。在iOS环境中，它被广泛用于调试工具，如lldb...

			
		

	





	

		

			

				
					
.NET下的终极反调试

				
			

			

				

					12-23
				

			

		

		

			
				
.NET环境下的反调试技术一直备受关注，特别是针对那些需要在运行时避免被调试的应用场景。本文将深入探讨一种被称为“终极反调试”的方法，该方法由0xd4d提出并实践，通过一系列的技术手段有效地阻止了调试器对目标...

			
		

	





	

		

			

				
					
iOS安全防护系列之重签名防护与sysctl反调试详解

				
			

			

				

					08-27
				

			

		

		

			
				
接下来，我们讨论sysctl反调试技术。sysctl是一个系统调用，可用于获取和设置系统的各种参数。在iOS中，我们可以利用sysctl来检测应用是否正在被调试。当应用被调试器附加时，系统会有一些特定的标志发生变化。通过...

			
		

	





	

		

			

				
					
反调试技术(以OD为例附核心原代码)

				
			

			

				

					06-05
				

			

		

		

			
				
反调试技术(以OD为例附核心原代码)，word文档，实例简单易懂，里面包括7个短实例，

			
		

	





	

		

			

				
					
各种反调试技术原理与实例 VC版[学习CK].

				
			

			

				

					11-10
				

			

		

		

			
				
反调试技术 VC版	2
发现OD的处理	2
1.	窗口类名、窗口名	3
2.	检测调试器进程	4
3.	父进程是否是Explorer	5
4.	RDTSC/ GetTickCount时间敏感程序段	6
5.	StartupInfo结构	7
6.	BeingDebugged	8
7.	PEB.NtGlobalFlag , Heap.HeapFlags, Heap.ForceFlags	9
8.	DebugPort: CheckRemoteDebuggerPresent()/NtQueryInformationProcess()	12
9.	SetUnhandledExceptionFilter/ Debugger Interrupts	14
10.	Trap Flag单步标志异常	16
11.	SeDebugPrivilege 进程权限	16
12.	DebugObject: NtQueryObject()	17
13.	OllyDbg：Guard Pages	20
14.	Software Breakpoint Detection	22
15.	Hardware Breakpoints Detection	24
16.	PatchingDetection CodeChecksumCalculation补丁检测，代码检验和	25
17.	block input封锁键盘、鼠标输入	26
18.	EnableWindow禁用窗口	27
19.	ThreadHideFromDebugger	28
20.	Disabling Breakpoints禁用硬件断点	30
21.	OllyDbg:OutputDebugString() Format String Bug	30
22.	TLS Callbacks	30

			
		

	





	

		

			

				
					
各种反调试技术原理与实例

				
			

			

				

					04-18
				

			

		

		

			
				
本人学习的总结，汇总归纳了各种反调试技术并提供了本人创作的各种反调试实例及源代码。
http://hi.baidu.com/tjt999
http://bbs.pediy.com/showthread.php?t=106143

反调试技术	2
发现OD的处理	2
1.	窗口类名、窗口名	3
2.	检测调试器进程	4
3.	父进程是否是Explorer	5
4.	RDTSC/ GetTickCount时间敏感程序段	7
5.	StartupInfo结构	7
6.	BeingDebugged	8
7.	PEB.NtGlobalFlag , Heap.HeapFlags, Heap.ForceFlags	10
8.	DebugPort: CheckRemoteDebuggerPresent()/NtQueryInformationProcess()	11
9.	SetUnhandledExceptionFilter/ Debugger Interrupts	13
10.	Trap Flag单步标志异常	15
11.	SeDebugPrivilege 进程权限	16
12.	DebugObject: NtQueryObject()	16
13.	OllyDbg：Guard Pages	17
14.	Software Breakpoint Detection	19
15.	Hardware Breakpoints	21
16.	PatchingDetection CodeChecksumCalculation补丁检测，代码检验和	22
17.	block input封锁键盘、鼠标输入	23
18.	EnableWindow禁用窗口	23
19.	ThreadHideFromDebugger	24
20.	Disabling Breakpoints禁用硬件断点	26
21.	OllyDbg:OutputDebugString() Format String Bug	27
22.	TLS Callbacks	27
反反调试技术	31

			
		

	





	

		

			

				
					
《逆向工程核心原理》学习笔记（七）：反调试技术

				
			

			

				

					闵行小鱼塘
				

				

					05-28
					
					2569
					
				

			

		

		

			
				
继续学习《逆向工程核心原理》，本篇笔记是第七部分：反调试技术，包括一些静态反调试技术和动态反调试技术

			
		

	





	

		

			

				
					
反调试技术总结(看雪)

				
			

			

				

					eli的博客
				

				

					12-07
					
					2971
					
				

			

		

		

			
				
大概是在一年半以前我在自己CSDN博客上写了详解反虚拟机技术和详解反调试技术，没想到看的人还很多，有人甚至给我发私信发邮件，在百度和谷歌搜索“反调试”和“反虚拟机”，第一条结果就是我的文章。我决定在看雪也分享一下。当然我只是做了个整理收集的工作，没有一条技术和一行代码是我原创的，参考链接会附在最后。





反调试技术，恶意代码用它识别是否被调试，或者让调试器失效。恶意代码编写者意识到分析人员经常使用调试器来观察恶意代码的操作，因此他们使用反调试技术尽可能地延长恶意代码的分析时间。为了阻止调试器的分析..

			
		

	





	

		

			

				
					
「娃娃分享」-反调试技术总结.

				
			

			

				

					weixin_30371875的博客
				

				

					05-30
					
					230
					
				

			

		

		

			
				
最近学习反调试技术，总结了网络上的一些反调试技术，文章中的代码均通过调试，在OllyDbg中测试通过，同时谢谢看雪的《加密与解密》第三版测试软件：IDA最新5.5，使用5.4OllyDbg最新2.0，结合v1.10（汉化第二版）一．抗静态分析技术静态分析是指从反汇编出来的程序清单上分析程序流程，反静态分析主要是指扰乱汇编代码可读性。1.花指令在原程序中添加一些汇编指令，添加后不影响原程...

			
		

	





	

		

			

				
					
JavaScript反调试技术详解与应用

				
			

			

				

					
				

			

		

		

			
				
函数重定义是本文介绍的一个具体反调试技术实例。它演示了如何通过重新定义`console.log`来隐藏或伪造输出信息，以此干扰调试者对程序状态的理解。这种技术可以扩展到其他内置函数或自定义函数，以实现更加复杂的...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值