异常情况

以下方法有意的引起异常，以验证进程是否运行在调试器下。

1. UnhandledExceptionFilter()

如果发生异常并且未注册任何异常处理程序（或已注册但未处理此类异常），则将调用kernel32!UnhandledExceptionFilter()函数。可以使用kernel32!SetUnhandledExceptionFilter()注册自定义未处理的异常过滤器。但是，如果程序在调试器下运行，则不会调用自定义过滤器，并且会将异常传递给调试器。因此，如果未处理的异常筛选器已注册并将控件传递给它，则该进程将不会在调试器中运行。

x86汇编（FASM）

  1. include 'win32ax.inc'
  3. .code
  5. start:
  6.         jmp begin
  8. not_debugged:
  9.         invoke  MessageBox,HWND_DESKTOP,"Not Debugged","",MB_OK
  10.         invoke  ExitProcess,0
  12. begin:
  13.         invoke SetUnhandledExceptionFilter, not_debugged
  14.         int  3
  15.         jmp  being_debugged
  17. being_debugged:
  18.         invoke  MessageBox,HWND_DESKTOP,"Debugged","",MB_OK
  19.         invoke  ExitProcess,0
  21. .end start

C / C ++代码

  1. LONG UnhandledExceptionFilter(PEXCEPTION_POINTERS pExceptionInfo)
  2. {
  3.     PCONTEXT ctx = pExceptionInfo->ContextRecord;
  4.     ctx->Eip += 3; // Skip \xCC\xEB\x??
  5.     return EXCEPTION_CONTINUE_EXECUTION;
  6. }
  8. bool Check()
  9. {
  10.     bool bDebugged = true;
  11.     SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)UnhandledExceptionFilter);
  12.     __asm
  13.     {
  14.         int 3                      // CC
  15.         jmp near being_debugged    // EB ??
  16.     }
  17.     bDebugged = false;
  19. being_debugged:
  20.     return bDebugged;
  21. }

2. RaiseException()

诸如DBC_CONTROL_C或DBG_RIPEVENT之类的异常不会传递给当前进程的异常处理程序，而是由调试器使用。这使我们可以注册一个异常处理程序，使用kernel32!RaiseException()函数引发这些异常，并检查控件是否传递给了我们的处理程序。如果未调用异常处理程序，则该进程可能正在调试中。

C / C ++代码

  1. bool Check()
  2. {
  3.     __try
  4.     {
  5.         RaiseException(DBG_CONTROL_C, 0, 0, NULL);
  6.         return true;
  7.     }
  8.     __except(DBG_CONTROL_C == GetExceptionCode()
  9.         ? EXCEPTION_EXECUTE_HANDLER 
  10.         : EXCEPTION_CONTINUE_SEARCH)
  11.     {
  12.         return false;
  13.     }
  14. }

3.使用异常处理程序隐藏控制流

这种方法不检查是否存在调试器，但有助于按异常处理程序的顺序隐藏程序的控制流。

我们可以注册一个引发另一个异常的异常处理程序（结构化异常处理SEH or 向量化异常处理VEH），该异常将传递给下一个引发下一个异常的处理程序，依此类推。最后，处理程序的顺序应导向我们要隐藏的进程。

使用结构化异常处理程序：

C / C ++代码

  1. #include <Windows.h>
  3. void MaliciousEntry()
  4. {
  5.     // ...
  6. }
  8. void Trampoline2()
  9. {
  10.     __try
  11.     {
  12.         __asm int 3;
  13.     }
  14.     __except (EXCEPTION_EXECUTE_HANDLER)
  15.     {
  16.         MaliciousEntry();
  17.     }
  18. }
  20. void Trampoline1()
  21. {
  22.     __try 
  23.     {
  24.         __asm int 3;
  25.     }
  26.     __except (EXCEPTION_EXECUTE_HANDLER)
  27.     {
  28.         Trampoline2();
  29.     }
  30. }
  32. int main(void)
  33. {
  34.     __try
  35.     {
  36.         __asm int 3;
  37.     }
  38.     __except (EXCEPTION_EXECUTE_HANDLER) {}
  39.     {
  40.         Trampoline1();
  41.     }
  43.     return 0;
  44. }

使用向量异常处理程序：

C / C ++代码

  1. #include <Windows.h>
  3. PVOID g_pLastVeh = nullptr;
  5. void MaliciousEntry()
  6. {
  7.     // ...
  8. }
  10. LONG WINAPI ExeptionHandler2(PEXCEPTION_POINTERS pExceptionInfo)
  11. {
  12.     MaliciousEntry();
  13.     ExitProcess(0);
  14. }
  16. LONG WINAPI ExeptionHandler1(PEXCEPTION_POINTERS pExceptionInfo)
  17. {
  18.     if (g_pLastVeh)
  19.     {
  20.         RemoveVectoredExceptionHandler(g_pLastVeh);
  21.         g_pLastVeh = AddVectoredExceptionHandler(TRUE, ExeptionHandler2);
  22.         if (g_pLastVeh)
  23.             __asm int 3;
  24.     }
  25.     ExitProcess(0);
  26. }
  29. int main(void)
  30. {
  31.     g_pLastVeh = AddVectoredExceptionHandler(TRUE, ExeptionHandler1);
  32.     if (g_pLastVeh)
  33.         __asm int 3;
  35.     return 0;
  36. }

缓解措施

  • 调试期间：

    • 对于调试器检测检查：只需用NOP填充相应的检查。
    • 对于控制流隐藏：您必须手动跟踪程序直到有效负载。
  • 对于反反调试工具开发：这类技术的问题在于，不同的调试器会使用不同的异常，并且不将其返回给调试器。这意味着您必须为特定的调试器实现一个插件，并更改在相应异常之后触发的事件处理程序的行为。