26种对付反调试的方法

目前主要有3种分析软件的方法：

10年积累的网站设计、成都网站制作经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先网站制作后付款的网站建设流程，更有阿合奇免费网站建设让你可以放心的选择与我们合作。

1.数据交换分析，研究人员使用数据包嗅探工具来分析网络数据交换。

2.对软件的二进制代码进行反汇编，然后以汇编语言列出。

3.字节码解码或二进制解码，然后以高级编程语言重新创建源代码。

本文针对的是Windows操作系统中常用的防破解及防逆向工程保护技术，即反调试方法，各种防逆向工程技术的主要目标是尽可能多的使逆变工具尽可能失效。

本文的对付反调试方法，总共涉及26种：

1. IsDebuggerPresent

2. PEB（进程环境块）

3.如何避开IsDebuggerPresent的检查

4.TLS回调

5.NtGlobalFlag

6.如何避开NtGlobalFlag检查

7.NtGlobalFlag和IMAGE_LOAD_CONFIG_DIRECTORY

8.HeapFlag和ForceFlags

9.如何避开HeapFlag和ForceFlags

10.陷阱标识检查

11.如何避开陷阱标识检查

12.CheckRemoteDebuggerPresent和NtQueryInformationProcess

13.如何避开CheckRemoteDebuggerPresent和NtQueryInformationProcess

14.基于NtQueryInformationProcess的其他反调试保护技术

15.如何避开NtQueryInformationProcess检查

16.软件和硬件的断点反应

17.SEH（结构化异常处理）

18.如何避开SHE检查

19.VEH（向量化异常处理）

20.如何避开硬件断点检查和VEH

21.NtSetInformationThread ，在调试工具中隐藏线程

22.如何避开从调试工具中隐藏线程

23.NtCreateThreadEx

24. 如何避开NtCreateThreadEx

25.处理跟踪

26.堆栈段操作

建议你在阅读本文时，先具备一定的Assembler知识，一些Windbg操作经验以及使用API函数开发Windows的经验。

IsDebuggerPresent

也许最简单的方法是调用IsDebuggerPresent函数，用此函数检测用户模式的调试器是否正在调试调用进程。下面的代码就是一个基本的保护案例：

 
 
   
  
  int main()   
  
  {   
  
      if (IsDebuggerPresent())   
  
      {   
  
          std::cout << "Stop debugging program!" << std::endl;   
  
          exit(-1);   
  
      }   
  
      return 0;   
  
  }

如果我们来看看IsDebuggerPresent函数，我们会发现这样的代码：

 
 
   
  
  0:000< u kernelbase!IsDebuggerPresent L3   
  
  KERNELBASE!IsDebuggerPresent:   
  
  751ca8d0 64a130000000    mov     eax,dword ptr fs:[00000030h]   
  
  751ca8d6 0fb64002        movzx   eax,byte ptr [eax+2]   
  
  751ca8da c3              ret

Windows X64里的进程如下：

 
 
   
  
  0:000< u kernelbase!IsDebuggerPresent L3   
  
  KERNELBASE!IsDebuggerPresent:   
  
  00007ffc`ab6c1aa0 65488b042560000000 mov   rax,qword ptr gs:[60h]   
  
  00007ffc`ab6c1aa9 0fb64002           movzx eax,byte ptr [rax+2]   
  
  00007ffc`ab6c1aad c3                 ret

在FS寄存器的偏移量30h处存在PEB（进程环境块），而在X64上，PEB（进程环境块）存在于GS段寄存器的偏移量60h处。在PEB中的2个偏移量处，我们将找到BeingDebugged字段：

 
 
   
  
  0:000< dt _PEB   
  
  ntdll!_PEB   
  
     +0x000 InheritedAddressSpace : UChar   
  
     +0x001 ReadImageFileExecOptions : UChar   
  
     +0x002 BeingDebugged    : UChar

即IsDebuggerPresent函数读取BeingDebugged字段的值。如果进程被调试，值为1，否则为0。

PEB（进程环境块）

PEB是在操作系统内使用的封闭结构。在不同地运行环境下，大家应该以不同的方式获取PEB结构指针。如下所示，你可以在下图中找到x32和x64系统的PEB指针：

 
 
   
  
  // Get PEB for WOW64 Process   
  
  PVOID GetPEB64()   
  
  {   
  
      PVOID pPeb = 0;   
  
  #ifndef _WIN64   
  
      // 1. There are two copies of PEB - PEB64 and PEB32 in WOW64 process   
  
      // 2. PEB64 follows after PEB32   
  
      // 3. This is true for version less then Windows 8, else __readfsdword returns address of real PEB64   
  
      if (IsWin8OrHigher())   
  
      {   
  
          BOOL isWow64 = FALSE;   
  
          typedef BOOL(WINAPI *pfnIsWow64Process)(HANDLE hProcess, PBOOL isWow64);   
  
          pfnIsWow64Process fnIsWow64Process = (pfnIsWow64Process)   
  
              GetProcAddress(GetModuleHandleA("Kernel32.dll"), "IsWow64Process");   
  
          if (fnIsWow64Process(GetCurrentProcess(), &isWow64))   
  
          {   
  
              if (isWow64)   
  
              {   
  
                  pPeb = (PVOID)__readfsdword(0x0C * sizeof(PVOID));   
  
                  pPeb = (PVOID)((PBYTE)pPeb + 0x1000);   
  
              }   
  
          }   
  
      }   
  
  #endif   
  
      return pPeb;   
  
  }

检查操作系统版本的功能代码如下：

 
 
   
  
  WORD GetVersionWord()   
  
  {   
  
      OSVERSIONINFO verInfo = { sizeof(OSVERSIONINFO) };   
  
      GetVersionEx(&verInfo);   
  
      return MAKEWORD(verInfo.dwMinorVersion, verInfo.dwMajorVersion);   
  
  }   
  
  BOOL IsWin8OrHigher() { return GetVersionWord() >= _WIN32_WINNT_WIN8; }   
  
  BOOL IsVistaOrHigher() { return GetVersionWord() >= _WIN32_WINNT_VISTA; }

如何避开IsDebuggerPresent检查

为了做到这一点，在执行检查代码之前，需要将0置于BeingDebugged。例如，可以使用DLL注入：

 
 
   
  
  mov eax, dword ptr fs:[0x30]     
  
  mov byte ptr ds:[eax+2], 0

Windows X64里的进程如下：

 
 
   
  
  DWORD64 dwpeb = __readgsqword(0x60);   
  
  *((PBYTE)(dwpeb + 2)) = 0;

TLS回调

其实，在主函数中检查调试器的存在不是最好的方法，因为TLS回调处于反汇编列表时反向工具的第一个位置。它实施的检查可以由nop指令擦除，从而解除保护。如果使用CRT库，则在将控制权转移到主函数之前，主线程就已经有一个调用堆栈了。执行调试器存在检查的一个方法便是TLS回调。如下图所示，在可执行模块入口调用之前就已经调用回调函数。

 
 
   
  
  #pragma section(".CRT$XLY", long, read)   
  
  __declspec(thread) int var = 0xDEADBEEF;   
  
  VOID NTAnopPI TlsCallback(PVOID DllHandle, DWORD Reason, VOID Reserved)   
  
  {   
  
      var = 0xB15BADB0; // Required for TLS Callback call   
  
      if (IsDebuggerPresent())   
  
      {   
  
          MessageBoxA(NULL, "Stop debugging program!", "Error", MB_OK | MB_ICONERROR);   
  
          TerminateProcess(GetCurrentProcess(), 0xBABEFACE);   
  
      }   
  
  }   
  
  __declspec(allocate(".CRT$XLY"))PIMAGE_TLS_CALLBACK g_tlsCallback = TlsCallback;

NtGlobalFlag

在Windows NT中，存在一组标识，它们存储在全局变量NtGlobalFlag中。在系统启动时，NtGlobalFlag全局系统变量将使用系统注册表项中的值进行初始化：

 
 
   
  
  [HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlSession ManagerGlobalFlag]

该变量值用于系统跟踪，调试和控制。虽然变量标识未记录，但SDK包括gflags实用程序，它允许对一个全局标识值进行编辑。 PEB结构还包括NtGlobalFlag字段，其位结构不对应于NtGlobalFlag全局系统变量。在调试期间，这些标识在NtGlobalFlag字段中的设置如下：

 
 
   
  
  FLG_HEAP_ENABLE_TAIL_CHECK (0x10)   
  
  FLG_HEAP_ENABLE_FREE_CHECK (0x20)   
  
  FLG_HEAP_VALIDATE_PARAMETERS (0x40)

要检查进程是否使用了调试器启动，你应该检查PEB结构的NtGlobalFlag字段的值。在x32和x64系统中，该字段位于PEB结构的开始处的0x068和0x0bc偏移处。

 
 
   
  
  0:000> dt _PEB NtGlobalFlag @$peb    
  
  ntdll!_PEB   
  
     +0x068 NtGlobalFlag : 0x70

Windows X64里的进程如下：

 
 
   
  
  0:000> dt _PEB NtGlobalFlag @$peb   
  
  ntdll!_PEB   
  
     +0x0bc NtGlobalFlag : 0x70

以下代码片段就是基于NtGlobalFlag标识检查的反调试保护：

 
 
   
  
  #define FLG_HEAP_ENABLE_TAIL_CHECK   0x10   
  
  #define FLG_HEAP_ENABLE_FREE_CHECK   0x20   
  
  #define FLG_HEAP_VALIDATE_PARAMETERS 0x40   
  
  #define NT_GLOBAL_FLAG_DEBUGGED (FLG_HEAP_ENABLE_TAIL_CHECK | FLG_HEAP_ENABLE_FREE_CHECK | FLG_HEAP_VALIDATE_PARAMETERS)   
  
  void CheckNtGlobalFlag()   
  
  {   
  
      PVOID pPeb = GetPEB();   
  
      PVOID pPeb64 = GetPEB64();   
  
      DWORD offsetNtGlobalFlag = 0;   
  
  #ifdef _WIN64   
  
      offsetNtGlobalFlag = 0xBC;   
  
  #else   
  
      offsetNtGlobalFlag = 0x68;   
  
  #endif   
  
      DWORD NtGlobalFlag = *(PDWORD)((PBYTE)pPeb + offsetNtGlobalFlag);   
  
      if (NtGlobalFlag & NT_GLOBAL_FLAG_DEBUGGED)   
  
      {   
  
          std::cout << "Stop debugging program!" << std::endl;   
  
          exit(-1);   
  
      }   
  
      if (pPeb64)   
  
      {   
  
          DWORD NtGlobalFlagWow64 = *(PDWORD)((PBYTE)pPeb64 + 0xBC);   
  
          if (NtGlobalFlagWow64 & NT_GLOBAL_FLAG_DEBUGGED)   
  
          {   
  
              std::cout << "Stop debugging program!" << std::endl;   
  
              exit(-1);   
  
          }   
  
      }   
  
  }

如何避开NtGlobalFlag检查

在执行该检查之前，应该在通过反调试保护检查该值之前，将0调整为调试过程中PEB结构的NtGlobalFlag字段。

NtGlobalFlag和IMAGE_LOAD_CONFIG_DIRECTORY

可执行文件既包括IMAGE_LOAD_CONFIG_DIRECTORY结构，也包括系统加载程序的其他配置参数。不过在默认情况下，此结构不会内置到可执行文件中，需要使用补丁添加。此结构具有GlobalFlagsClear字段，对PEB结构中要重置的NtGlobalFlag字段进行了标识。如果最初没有对该结构或GlobalFlagsClear = 0创建可执行文件，那么在磁盘或内存中，该字段就具有非零值，隐藏的调试器就会正常运行。下面就是检查运行进程的内存和磁盘上的GlobalFlagsClear字段的代码，这是一种流行的反调试技术：

 
 
   
  
  PIMAGE_NT_HEADERS GetImageNtHeaders(PBYTE pImageBase)   
  
  {   
  
      PIMAGE_DOS_HEADER pImageDosHeader = (PIMAGE_DOS_HEADER)pImageBase;   
  
      return (PIMAGE_NT_HEADERS)(pImageBase + pImageDosHeader->e_lfanew);   
  
  }   
  
  PIMAGE_SECTION_HEADER FindRDataSection(PBYTE pImageBase)   
  
  {   
  
      static const std::string rdata = ".rdata";   
  
      PIMAGE_NT_HEADERS pImageNtHeaders = GetImageNtHeaders(pImageBase);   
  
      PIMAGE_SECTION_HEADER pImageSectionHeader = IMAGE_FIRST_SECTION(pImageNtHeaders);   
  
      int n = 0;   
  
      for (; n < pImageNtHeaders->FileHeader.NumberOfSections; ++n)   
  
      {   
  
          if (rdata == (char*)pImageSectionHeader[n].Name)   
  
          {   
  
              break;   
  
          }   
  
      }   
  
      return &pImageSectionHeader[n];   
  
  }   
  
  void CheckGlobalFlagsClearInProcess()   
  
  {   
  
      PBYTE pImageBase = (PBYTE)GetModuleHandle(NULL);   
  
      PIMAGE_NT_HEADERS pImageNtHeaders = GetImageNtHeaders(pImageBase);   
  
      PIMAGE_LOAD_CONFIG_DIRECTORY pImageLoadConfigDirectory = (PIMAGE_LOAD_CONFIG_DIRECTORY)(pImageBase   
  
          + pImageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG].VirtualAddress);   
  
      if (pImageLoadConfigDirectory->GlobalFlagsClear != 0)   
  
      {   
  
          std::cout << "Stop debugging program!" << std::endl;   
  
          exit(-1);   
  
      }   
  
  }   
  
  void CheckGlobalFlagsClearInFile()   
  
  {   
  
      HANDLE hExecutable = INVALID_HANDLE_VALUE;   
  
      HANDLE hExecutableMapping = NULL;   
  
      PBYTE pMappedImageBase = NULL;   
  
      __try   
  
      {   
  
          PBYTE pImageBase = (PBYTE)GetModuleHandle(NULL);   
  
          PIMAGE_SECTION_HEADER pImageSectionHeader = FindRDataSection(pImageBase);   
  
          TCHAR pszExecutablePath[MAX_PATH];   
  
          DWORD dwPathLength = GetModuleFileName(NULL, pszExecutablePath, MAX_PATH);   
  
          if (0 == dwPathLength) __leave;   
  
          hExecutable = CreateFile(pszExecutablePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);   
  
          if (INVALID_HANDLE_VALUE == hExecutable) __leave;   
  
          hExecutableMapping = CreateFileMapping(hExecutable, NULL, PAGE_READONLY, 0, 0, NULL);   
  
          if (NULL == hExecutableMapping) __leave;   
  
          pMappedImageBase = (PBYTE)MapViewOfFile(hExecutableMapping, FILE_MAP_READ, 0, 0,   
  
              pImageSectionHeader->PointerToRawData + pImageSectionHeader->SizeOfRawData);   
  
          if (NULL == pMappedImageBase) __leave;   
  
          PIMAGE_NT_HEADERS pImageNtHeaders = GetImageNtHeaders(pMappedImageBase);   
  
          PIMAGE_LOAD_CONFIG_DIRECTORY pImageLoadConfigDirectory = (PIMAGE_LOAD_CONFIG_DIRECTORY)(pMappedImageBase    
  
              + (pImageSectionHeader->PointerToRawData   
  
                  + (pImageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG].VirtualAddress - pImageSectionHeader->VirtualAddress)));   
  
          if (pImageLoadConfigDirectory->GlobalFlagsClear != 0)   
  
          {   
  
              std::cout << "Stop debugging program!" << std::endl;   
  
              exit(-1);   
  
          }   
  
      }   
  
      __finally   
  
      {   
  
          if (NULL != pMappedImageBase)   
  
              UnmapViewOfFile(pMappedImageBase);   
  
          if (NULL != hExecutableMapping)   
  
              CloseHandle(hExecutableMapping);   
  
          if (INVALID_HANDLE_VALUE != hExecutable)   
  
              CloseHandle(hExecutable);   
  
      }    
  
  }

在此代码中，CheckGlobalFlagsClearInProcess函数会通过加载当前运行的进程地址查找PIMAGE_LOAD_CONFIG_DIRECTORY结构，并检查GlobalFlagsClear字段值。如果不是0，那么该进程可能被调试。 CheckGlobalFlagsClearInFile函数也会执行相同的检查，但仅仅针对的是磁盘上的可执行文件。

HeapFlag和ForceFlags

PEB结构包含指向进程堆的指针— _HEAPP结构：

 
 
   
  
  0:000> dt _PEB ProcessHeap @$peb   
  
  ntdll!_PEB   
  
     +0x018 ProcessHeap : 0x00440000 Void0:000> dt _HEAP Flags ForceFlags 00440000 ntdll!_HEAP   
  
     +0x040 Flags      : 0x40000062   
  
     +0x044 ForceFlags : 0x40000060

Windows X64里的进程如下：

 
 
   
  
  0:000> dt _PEB ProcessHeap @$peb   
  
  ntdll!_PEB   
  
     +0x030 ProcessHeap : 0x0000009d`94b60000 Void   
  
  0:000> dt _HEAP Flags ForceFlags 0000009d`94b60000   
  
  ntdll!_HEAP   
  
     +0x070 Flags      : 0x40000062   
  
     +0x074 ForceFlags : 0x40000060

如果正在调试进程，则两个字段Flags和ForceFlags都具有特定的调试值：

1.如果Flags字段没有设置HEAP_GROWABLE（0x00000002）标识，则正在调试进程。

2.如果ForceFlags！= 0，则正在调试进程。

不过要注意的是，_HEAP结构并未记录，并且Flags和ForceFlags字段的偏移值可能因操作系统版本而异。以下代码就是基于HeapFlag检查的反调试保护：

 
 
   
  
  int GetHeapFlagsOffset(bool x64)   
  
  {   
  
      return x64 ?   
  
          IsVistaOrHigher() ? 0x70 : 0x14: //x64 offsets   
  
          IsVistaOrHigher() ? 0x40 : 0x0C; //x86 offsets   
  
  }   
  
  int GetHeapForceFlagsOffset(bool x64)   
  
  {   
  
      return x64 ?   
  
          IsVistaOrHigher() ? 0x74 : 0x18: //x64 offsets   
  
          IsVistaOrHigher() ? 0x44 : 0x10; //x86 offsets   
  
  }   
  
  void CheckHeap()   
  
  {   
  
      PVOID pPeb = GetPEB();   
  
      PVOID pPeb64 = GetPEB64();   
  
      PVOID heap = 0;   
  
      DWORD offsetProcessHeap = 0;   
  
      PDWORD heapFlagsPtr = 0, heapForceFlagsPtr = 0;   
  
      BOOL x64 = FALSE;   
  
  #ifdef _WIN64   
  
      x64 = TRUE;   
  
      offsetProcessHeap = 0x30;   
  
  #else   
  
      offsetProcessHeap = 0x18;   
  
  #endif   
  
      heap = (PVOID)*(PDWORD_PTR)((PBYTE)pPeb + offsetProcessHeap);   
  
      heapFlagsPtr = (PDWORD)((PBYTE)heap + GetHeapFlagsOffset(x64));   
  
      heapForceFlagsPtr = (PDWORD)((PBYTE)heap + GetHeapForceFlagsOffset(x64));   
  
      if (*heapFlagsPtr & ~HEAP_GROWABLE || *heapForceFlagsPtr != 0)   
  
      {   
  
          std::cout << "Stop debugging program!" << std::endl;   
  
          exit(-1);   
  
      }   
  
      if (pPeb64)   
  
      {   
  
          heap = (PVOID)*(PDWORD_PTR)((PBYTE)pPeb64 + 0x30);   
  
          heapFlagsPtr = (PDWORD)((PBYTE)heap + GetHeapFlagsOffset(true));   
  
          heapForceFlagsPtr = (PDWORD)((PBYTE)heap + GetHeapForceFlagsOffset(true));   
  
          if (*heapFlagsPtr & ~HEAP_GROWABLE || *heapForceFlagsPtr != 0)   
  
          {   
  
              std::cout << "Stop debugging program!" << std::endl;   
  
              exit(-1);   
  
          }   
  
      }   
  
  }

如何避开HeapFlag和ForceFlags检查

为了避开基于HeapFlag检查的反调试保护，应该为Flags字段设置HEAP_GROWABLE标识，并将ForceFlags的值设置为0.。但要注意的是，字段值的重新定义应该在HeapFlag检查之前执行。

陷阱标识检查

Trap Flag（陷阱标识）位于EFLAGS寄存器内，如果TF设置为1，CPU将在每个指令执行后产生INT 01h或单步异常(single-step exception)。以下就是基于TF设置和异常调用检查的反调试：

 
 
   
  
  BOOL isDebugged = TRUE;   
  
  __try   
  
  {   
  
      __asm   
  
      {   
  
          pushfd   
  
          or dword ptr[esp], 0x100 // set the Trap Flag    
  
          popfd                    // Load the value into EFLAGS register   
  
          nop   
  
      }   
  
  }   
  
  __except (EXCEPTION_EXECUTE_HANDLER)   
  
  {   
  
      // If an exception has been raised – debugger is not present   
  
      isDebugged = FALSE;   
  
  }   
  
  if (isDebugged)   
  
  {   
  
      std::cout << "Stop debugging program!" << std::endl;   
  
      exit(-1);   
  
  }

这里TF有意设置为生成异常。如果正在调试进程，则异常将被调试器捕获。

如何避开陷阱标识检查

为了在调试过程中避开TF标识检查，应该将pushfd指令传递给单步异常，但要跳过它，将断点置后，继续执行程序。断点后，跟踪可以继续。

CheckRemoteDebuggerPresent和NtQueryInformationProcess

与IsDebuggerPresent函数不同，CheckRemoteDebuggerPresent会检查一个进程是否被另一个同步进程调试。下图就是一个基于CheckRemoteDebuggerPresent的反调试技术：

 
 
   
  
  int main(int argc, char *argv[])   
  
  {   
  
      BOOL isDebuggerPresent = FALSE;   
  
      if (CheckRemoteDebuggerPresent(GetCurrentProcess(), &isDebuggerPresent ))   
  
      {   
  
          if (isDebuggerPresent )   
  
          {   
  
              std::cout << "Stop debugging program!" << std::endl;   
  
              exit(-1);   
  
          }   
  
      }   
  
      return 0;   
  
  }

在CheckRemoteDebuggerPresent的内部，调用NtQueryInformationProcess函数：

 
 
   
  
  0:000> uf kernelbase!CheckRemotedebuggerPresent   
  
  KERNELBASE!CheckRemoteDebuggerPresent:   
  
  ...   
  
  75207a24 6a00            push    0   
  
  75207a26 6a04            push    4   
  
  75207a28 8d45fc          lea     eax,[ebp-4]   
  
  75207a2b 50              push    eax   
  
  75207a2c 6a07            push    7   
  
  75207a2e ff7508          push    dword ptr [ebp+8]   
  
  75207a31 ff151c602775    call    dword ptr [KERNELBASE!_imp__NtQueryInformationProcess (7527601c)]   
  
  75207a37 85c0            test    eax,eax   
  
  75207a39 0f88607e0100    js      KERNELBASE!CheckRemoteDebuggerPresent+0x2b (7521f89f)   
  
  ...

如果我们来看看NtQueryInformationProcess文档，那么这个Assembler列表将向我们展示CheckRemoteDebuggerPresent函数获取DebugPort值，因为ProcessInformationClass参数值（第二个）为7，以下反调试代码就是基于调用NtQueryInformationProcess：

 
 
   
  
  typedef NTSTATUS(NTAPI *pfnNtQueryInformationProcess)(   
  
      _In_      HANDLE           ProcessHandle,   
  
      _In_      UINT             ProcessInformationClass,   
  
      _Out_     PVOID            ProcessInformation,   
  
      _In_      ULONG            ProcessInformationLength,   
  
      _Out_opt_ PULONG           ReturnLength   
  
      );   
  
  const UINT ProcessDebugPort = 7;   
  
  int main(int argc, char *argv[])   
  
  {   
  
      pfnNtQueryInformationProcess NtQueryInformationProcess = NULL;   
  
      NTSTATUS status;   
  
      DWORD isDebuggerPresent = 0;   
  
      HMODULE hNtDll = LoadLibrary(TEXT("ntdll.dll"));   
  
         
  
      if (NULL != hNtDll)   
  
      {   
  
          NtQueryInformationProcess = (pfnNtQueryInformationProcess)GetProcAddress(hNtDll, "NtQueryInformationProcess");   
  
          if (NULL != NtQueryInformationProcess)   
  
          {   
  
              status = NtQueryInformationProcess(   
  
                  GetCurrentProcess(),   
  
                  ProcessDebugPort,   
  
                  &isDebuggerPresent,   
  
                  sizeof(DWORD),   
  
                  NULL);   
  
              if (status == 0x00000000 && isDebuggerPresent != 0)   
  
              {   
  
                  std::cout << "Stop debugging program!" << std::endl;   
  
                  exit(-1);   
  
              }   
  
          }   
  
      }   
  
      return 0;   
  
  }

如何避开CheckRemoteDebuggerPresent和NtQueryInformationProcess

应该替换NtQueryInformationProcess函数返回的值。如果要使用mhook，就要先设置一个钩子，可以将DLL注入到调试过程中，并使用mhook在DLLMain中设置一个钩子。以下就是一个mhook用法的例子：

 
 
   
  
  #include    
  
  #include "mhook.h"   
  
  typedef NTSTATUS(NTAPI *pfnNtQueryInformationProcess)(   
  
      _In_      HANDLE           ProcessHandle,   
  
      _In_      UINT             ProcessInformationClass,   
  
      _Out_     PVOID            ProcessInformation,   
  
      _In_      ULONG            ProcessInformationLength,   
  
      _Out_opt_ PULONG           ReturnLength   
  
      );   
  
  const UINT ProcessDebugPort = 7;   
  
  pfnNtQueryInformationProcess g_origNtQueryInformationProcess = NULL;   
  
  NTSTATUS NTAPI HookNtQueryInformationProcess(   
  
      _In_      HANDLE           ProcessHandle,   
  
      _In_      UINT             ProcessInformationClass,   
  
      _Out_     PVOID            ProcessInformation,   
  
      _In_      ULONG            ProcessInformationLength,   
  
      _Out_opt_ PULONG           ReturnLength   
  
      )   
  
  {   
  
      NTSTATUS status = g_origNtQueryInformationProcess(   
  
          ProcessHandle,   
  
          ProcessInformationClass,   
  
          ProcessInformation,   
  
          ProcessInformationLength,   
  
          ReturnLength);   
  
      if (status == 0x00000000 && ProcessInformationClass == ProcessDebugPort)   
  
      {   
  
          *((PDWORD_PTR)ProcessInformation) = 0;   
  
      }   
  
      return status;   
  
  }   
  
  DWORD SetupHook(PVOID pvContext)   
  
  {   
  
      HMODULE hNtDll = LoadLibrary(TEXT("ntdll.dll"));   
  
      if (NULL != hNtDll)   
  
      {   
  
          g_origNtQueryInformationProcess = (pfnNtQueryInformationProcess)GetProcAddress(hNtDll, "NtQueryInformationProcess");   
  
          if (NULL != g_origNtQueryInformationProcess)   
  
          {   
  
              Mhook_SetHook((PVOID*)&g_origNtQueryInformationProcess, HookNtQueryInformationProcess);   
  
          }   
  
      }   
  
      return 0;   
  
  }   
  
  BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved)   
  
  {   
  
      switch (fdwReason)   
  
      {   
  
      case DLL_PROCESS_ATTACH:   
  
          DisableThreadLibraryCalls(hInstDLL);   
  
          CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)SetupHook, NULL, NULL, NULL);   
  
          Sleep(20);   
  
      case DLL_PROCESS_DETACH:   
  
          if (NULL != g_origNtQueryInformationProcess)   
  
          {   
  
              Mhook_Unhook((PVOID*)&g_origNtQueryInformationProcess);   
  
          }   
  
          break;   
  
      }   
  
      return TRUE;   
  
  }

基于NtQueryInformationProcess的其他反调试保护技术

可以从NtQueryInformationProcess函数提供的信息知道，还有更多的调试器检测技术：

1.ProcessDebugPort 0x07，已在上面讨论过。

2.ProcessDebugObjectHandle 0x1E

3.ProcessDebugFlags 0x1F

4.ProcessBasicInformation 0x00

ProcessDebugObjectHandle

从Windows XP开始，研究人员就为调试过程创建了调试对象。以下就是检查当前进程调试对象的案例：

 
 
   
  
  status = NtQueryInformationProcess(   
  
              GetCurrentProcess(),   
  
              ProcessDebugObjectHandle,   
  
              &hProcessDebugObject,   
  
              sizeof(HANDLE),   
  
              NULL);   
  
  if (0x00000000 == status && NULL != hProcessDebugObject)   
  
  {   
  
      std::cout << "Stop debugging program!" << std::endl;   
  
      exit(-1);   
  
  }

如果有调试对象，则正在调试该进程。

ProcessDebugFlags

当检查该标识时，它会返回到EPROCESS内核结构的NoDebugInherit位的反转值。如果NtQueryInformationProcess函数的返回值为0，则正在调试进程。以下就是一个这样的反调试检查的例子：

 
 
   
  
  status = NtQueryInformationProcess(   
  
      GetCurrentProcess(),   
  
      ProcessDebugObjectHandle,   
  
      &debugFlags,   
  
      sizeof(ULONG),   
  
      NULL);   
  
  if (0x00000000 == status && NULL != debugFlags)   
  
  {   
  
      std::cout << "Stop debugging program!" << std::endl;   
  
      exit(-1);   
  
  }

ProcessBasicInformation

当使用ProcessBasicInformation标识调用NtQueryInformationProcess函数时，会返回PROCESS_BASIC_INFORMATION结构：

 
 
   
  
  typedef struct _PROCESS_BASIC_INFORMATION {   
  
      NTSTATUS ExitStatus;   
  
      PVOID PebBaseAddress;   
  
      ULONG_PTR AffinityMask;   
  
      KPRIORITY BasePriority;   
  
      HANDLE UniqueProcessId;   
  
      HANDLE InheritedFromUniqueProcessId;   
  
  } PROCESS_BASIC_INFORMATION, *PPROCESS_BASIC_INFORMATION;

该结构中最有趣的是InheritedFromUniqueProcessId字段。在这里，我们需要获取父进程的名称并将其与流行调试器的名称进行比较，以下是这种反调试检查的列表：

 
 
   
  
  std::wstring GetProcessNameById(DWORD pid)   
  
  {   
  
      HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);   
  
      if (hProcessSnap == INVALID_HANDLE_VALUE)   
  
      {   
  
          return 0;   
  
      }   
  
      PROCESSENTRY32 pe32;   
  
      pe32.dwSize = sizeof(PROCESSENTRY32);   
  
      std::wstring processName = L"";   
  
      if (!Process32First(hProcessSnap, &pe32))   
  
      {   
  
          CloseHandle(hProcessSnap);   
  
          return processName;   
  
      }   
  
      do   
  
      {   
  
          if (pe32.th32ProcessID == pid)   
  
          {   
  
              processName = pe32.szExeFile;   
  
              break;   
  
          }   
  
      } while (Process32Next(hProcessSnap, &pe32));   
  
         
  
      CloseHandle(hProcessSnap);   
  
      return processName;   
  
  }   
  
  status = NtQueryInformationProcess(   
  
      GetCurrentProcess(),   
  
      ProcessBasicInformation,   
  
      &processBasicInformation,   
  
      sizeof(PROCESS_BASIC_INFORMATION),   
  
      NULL);   
  
  std::wstring parentProcessName = GetProcessNameById((DWORD)processBasicInformation.InheritedFromUniqueProcessId);   
  
  if (L"devenv.exe" == parentProcessName)   
  
  {   
  
      std::cout << "Stop debugging program!" << std::endl;   
  
      exit(-1);   
  
  }

如何避开NtQueryInformationProcess检查

避开是非常简单的， NtQueryInformationProcess函数返回的值应该更改为那些不指示调试器存在的值：

1.将ProcessDebugObjectHandle设置为0

2.将ProcessDebugFlags设置为1

3.对于ProcessBasicInformation，将InheritedFromUniqueProcessId值更改为另一个进程ID，例如， Explorer.exe的

断点

断点，调试器的功能之一，可以让程序中断在需要的地方，从而方便其分析。两种类型的断点：

1.软件断点

2.硬件断点

在没有断点的情况下很难进行逆向工程，所以目前流行的反逆向工程策略都是基于检测断点，然后提供一系列相应的反调试方法。

软件断点

在IA-32架构中，有一个特定的指令 – int 3h，带有0xCC操作码，用于调用调试句柄。当CPU执行该指令时，会产生中断并将控制传输到调试器。为了达到控制的目的，调试器必须将int 3h指令注入到代码中。要检测断点，我们可以计算函数的校验和。

 
 
   
  
  DWORD CalcFuncCrc(PUCHAR funcBegin, PUCHAR funcEnd)   
  
  {   
  
      DWORD crc = 0;   
  
      for (; funcBegin < funcEnd; ++funcBegin)   
  
      {   
  
          crc += *funcBegin;   
  
      }   
  
      return crc;   
  
  }   
  
  #pragma auto_inline(off)   
  
  VOID DebuggeeFunction()   
  
  {   
  
      int calc = 0;   
  
      calc += 2;   
  
      calc <<= 8;   
  
      calc -= 3;   
  
  }   
  
  VOID DebuggeeFunctionEnd()   
  
  {   
  
  };   
  
  #pragma auto_inline(on)   
  
  DWORD g_origCrc = 0x2bd0;   
  
  int main()   
  
  {   
  
      DWORD crc = CalcFuncCrc((PUCHAR)DebuggeeFunction, (PUCHAR)DebuggeeFunctionEnd);   
  
      if (g_origCrc != crc) 
                名称栏目：26种对付反调试的方法
                

                网站URL：http://www.shufengxianlan.com/qtweb/news15/152315.html
            
            
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
            
                广告
                
            
            
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联

猜你还喜欢下面的内容