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

一、Windows API方法

Win32提供了两个API, IsDebuggerPresent和CheckRemoteDebuggerPresent可以用来检测当前进程是否正在被调试，以IsDebuggerPresent函数为例，例子如下：
BOOL ret = IsDebuggerPresent();
printf("ret = %d\n", ret);

破解方法很简单，就是在系统里将这两个函数hook掉，让这两个函数一直返回false就可以了，网上有很多做hook API工作的工具，也有很多工具源代码是开放的，所以这里就不细谈了
二、查询进程PEB的BeingDebugged标志位

当进程被调试器所附加的时候，操作系统会自动设置这个标志位，因此在程序里定期查询这个标志位就可以了，例子如下：

bool PebIsDebuggedApproach()8 R& ]/ {7 V6 T‘ z, K
{
       char result = 0;  q" V3 N9 u5 @# q% d+ E$ J
       __asm
       {
                // 进程的PEB地址放在fs这个寄存器位置上" C* e( ], k7 m
              mov eax, fs:[30h]7 C/ M0 X; b- G. L‘ S+ x, S" V
                // 查询BeingDebugged标志位6 J5 o, `6 U: a
              mov al, BYTE PTR [eax + 2] & k5 `; M9 v( _6 [
              mov result, al
       }
) n& r& d8 i5 c# t$ P8 s4 K
       return result != 0;, d; p" C‘ q, u8 I8 \
}

三、查询进程PEB的NtGlobal标志位 6 p6 C* _  T- V/ @‘ l. }
2 g; ~6 k* y# S) R
" \( O( p& i‘ H, f" T& K
跟第二个方法一样，当进程被调试的时候，操作系统除了修改BeingDebugged这个标志位以外，还会修改其他几个地方，其中NtDll中一些控制堆（Heap）操作的函数的标志位就会被修改，因此也可以查询这个标志位，例子如下：

bool PebNtGlobalFlagsApproach()  I  V7 g0 J& G9 P2 {2 j$ F# ]
{
       int result = 0;
__asm. ]& d" Z1 D$ h. m) d
       {" v+ s- m( Z$ c2 T* z8 f
                          // 进程的PEB
              mov eax, fs:[30h]
                          // 控制堆操作函数的工作方式的标志位
              mov eax, [eax + 68h]" c7 F2 s2 \7 ^7 d7 O5 y; [
                          // 操作系统会加上这些标志位FLG_HEAP_ENABLE_TAIL_CHECK, " O7 I& t, {9 r: g. g) V  {9 J
                          // FLG_HEAP_ENABLE_FREE_CHECK and FLG_HEAP_VALIDATE_PARAMETERS，
                          // 它们的并集就是x705 W5 z6 _$ a( b  D" `8 u$ W
                          //‘ z6 B) L‘ P1 g! |
                          // 下面的代码相当于C/C++的5 W3 w5 s$ ?! Y3 u( ^+ N4 _* _
                          //     eax = eax & 0x70# C* f! ^$ B‘ y
              and eax, 0x70
              mov result, eax
       }; _7 j* E4 {% y) {# u
( `1 B: r, ?8 K# O6 f/ K3 T
       return result != 0;+ c5 L# A! R# A‘ ?
}- T/ K/ B) X/ O
6 k" i* H( ?# l4 O8 D2 y, V, V: L7 {


四、查询进程堆的一些标志位" A) t* ^‘ n% E. ?. Z( F& L

# x- t; ^1 U/ d7 ?+ O4 s2 P
这个方法是第三个方法的变种，只要进程被调试，进程在堆上分配的内存，在分配的堆的头信息里，ForceFlags这个标志位会被修改，因此可以通过判断这个标志位的方式来反调试。因为进程可以有很多的堆，因此只要检查任意一个堆的头信息就可以了，所以这个方法貌似很强大，例子如下：
0 P# v: B: N+ z‘ n* |) f
bool HeapFlagsApproach()
{
       int result = 0;
& L9 V% Z  l) p) {, e9 Q
       __asm
       {‘ k) s‘ P6 p+ `& A, M9 T: f4 F5 G+ o
                      // 进程的PEB
              mov eax, fs:[30h]‘ K6 Q" {4 [! |; s: T
                      // 进程的堆，我们随便访问了一个堆，下面是默认的堆
              mov eax, [eax + 18h]
                          // 检查ForceFlag标志位，在没有被调试的情况下应该是4 z1 D  s$ I: ^% q  P5 _
              mov eax, [eax + 10h]7 @7 s3 o8 Y* q5 Z  W
              mov result, eax% H# F6 I4 z3 Y( h7 ?
       }
. m4 Q7 Z3 Q; p3 B
       return result != 0;
}8 w; p9 N& P6 k1 K: P7 L+ H
  S( R5 V0 X! c# r4 n‘ C2 ~0 L
5 p" G# F! V3 W) @" |; P: V
- G9 N+ ^4 j6 W0 u
& B; E) _/ ]. \( B: r8 @
五、使用NtQueryInformationProcess函数
% d8 A0 |& v, T$ p- }9 J: l0 T

NtQueryInformationProcess函数是一个未公开的API，它的第二个参数可以用来查询进程的调试端口。如果进程被调试，那么返回的端口值会是-1，否则就是其他的值。由于这个函数是一个未公开的函数，因此需要使用LoadLibrary和GetProceAddress的方法获取调用地址，示例代码如下：
, o) s( p( Q+ [
  A0 j" n9 P2 i
// 声明一个函数指针。7 r7 W/ w. T7 N! c
typedef NTSTATUS (WINAPI *NtQueryInformationProcessPtr)(
       HANDLE processHandle,
       PROCESSINFOCLASS processInformationClass,
       PVOID processInformation,
       ULONG processInformationLength,
       PULONG returnLength);7 z( z/ }+ I! u6 f4 ?, s: W
( B7 _7 ]2 W; K9 a. l* S% z7 a: z
bool NtQueryInformationProcessApproach()# W5 g& c# g& Z6 Y: G8 g5 X
{! k9 t/ F" e4 i4 _% T8 @
       int debugPort = 0;
       HMODULE hModule = LoadLibrary(TEXT("Ntdll.dll "));7 R, @8 S6 c  q- Y+ G
       NtQueryInformationProcessPtr NtQueryInformationProcess = (NtQueryInformationProcessPtr)GetProcAddress(hModule, "NtQueryInformationProcess");& n‘ @! [6 D8 n$ X3 f
       if ( NtQueryInformationProcess(GetCurrentProcess(), (PROCESSINFOCLASS)7, &debugPort, sizeof(debugPort), NULL) )9 ]/ @& h" y) n- o" F) o" E
              printf("[ERROR NtQueryInformationProcessApproach] NtQueryInformationProcess failed\n");4 O# M$ r9 [4 G‘ K6 x
       else
              return debugPort == -1;
8 z6 T$ A6 M8 f& u- U8 p
       return false;
}
, P; K$ f5 g5 v! n- {
! Y5 F; y9 a; E( s( t# o3 ]3 L- z: O

六、NtSetInformationThread方法
" W‘ Q4 a$ o3 y% R% |. C/ ]* l

这个也是使用Windows的一个未公开函数的方法，你可以在当前线程里调用NtSetInformationThread，调用这个函数时，如果在第二个参数里指定0x11这个值（意思是ThreadHideFromDebugger），等于告诉操作系统，将所有附加的调试器统统取消掉。示例代码:1 J" g8 F, u# \3 A

3 b2 h) Z4 P" ]) m- E" R
// 声明一个函数指针。
typedef NTSTATUS (*NtSetInformationThreadPtr)(HANDLE threadHandle,2 q7 n  ?% d. U5 S
       THREADINFOCLASS threadInformationClass,
       PVOID threadInformation,9 K) ]# i# c7 |2 }4 @
       ULONG threadInformationLength);6 F* o‘ |: S: {/ d5 f
" {; s4 Q1 q" x: _) \( C! q$ v
void NtSetInformationThreadApproach()1 x8 s( E- n0 q# }
{
      HMODULE hModule = LoadLibrary(TEXT("ntdll.dll"));
      NtSetInformationThreadPtr NtSetInformationThread = (NtSetInformationThreadPtr)GetProcAddress(hModule, "NtSetInformationThread");5 b$ k4 e7 o, Z0 }
    
      NtSetInformationThread(GetCurrentThread(), (THREADINFOCLASS)0x11, 0, 0);: v; o‘ h2 p‘ W/ q) q% g* Z  V7 s
}
- u& ~) T9 o6 T  q$ s* e+ Y
( f3 V( |! s$ ~8 y0 R9 U
6 u/ F" t( ~( e! S5 m" f
七、触发异常的方法2 b‘ V& l& z# j" m
: \* L/ a( M) g

这个技术的原理是，首先，进程使用SetUnhandledExceptionFilter函数注册一个未处理异常处理函数A，如果进程没有被调试的话，那么触发一个未处理异常，会导致操作系统将控制权交给先前注册的函数A；而如果进程被调试的话，那么这个未处理异常会被调试器捕捉，这样我们的函数A就没有机会运行了。
8 c8 L# _+ a! _+ ?% v
# y% j* t5 a: P- B0 ]# I$ N% y, k
这里有一个技巧，就是触发未处理异常的时候，如果跳转回原来代码继续执行，而不是让操作系统关闭进程。方案是在函数A里修改eip的值，因为在函数A的参数_EXCEPTION_POINTERS里，会保存当时触发异常的指令地址，所以在函数A里根据这个指令地址修改寄存器eip的值就可以了，示例代码如下：/ |$ r: ]% X5 O
" z6 t# \6 s2 o3 E* M; k
) H# x9 U/ t$ w5 H2 `
// 进程要注册的未处理异常处理程序A/ {1 m! t/ S  r( A  b2 o7 z
LONG WINAPI MyUnhandledExceptionFilter(struct _EXCEPTION_POINTERS *pei)$ M. a( ~0 s# M! d7 m
{‘ B/ V" Q: D5 J) r7 G8 [5 K1 ?
       SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)
              pei->ContextRecord->Eax);
       // 修改寄存器eip的值
       pei->ContextRecord->Eip += 2;5 Y7 B9 A  {5 N- D1 B. \
       // 告诉操作系统，继续执行进程剩余的指令（指令保存在eip里），而不是关闭进程+ \4 i- I( [/ F9 z% H1 `0 e/ n
       return EXCEPTION_CONTINUE_EXECUTION;7 [9 s6 K. R4 x7 i6 M  x3 o
}

bool UnhandledExceptionFilterApproach()
{5 h% s9 O! v8 }- Q
       SetUnhandledExceptionFilter(MyUnhandledExceptionFilter);
       __asm
       {. j2 P# |9 H( b
              // 将eax清零
              xor eax, eax
              // 触发一个除零异常
              div eax9 q8 l3 f* v0 c4 Q
       }6 Q5 N7 g- J8 D2 h( z9 F  y1 u
0 _2 j* U% D9 n" M
       return false;6 w7 ]! y1 r* p( r
}  \/ z* ?( k" W


八、调用DeleteFiber函数* o9 g‘ y6 r; y" o
- h, g$ t3 F4 v

如果给DeleteFiber函数传递一个无效的参数的话，DeleteFiber函数除了会抛出一个异常以外，还是将进程的LastError值设置为具体出错原因的代号。然而，如果进程正在被调试的话，这个LastError值会被修改，因此如果调试器绕过了第七步里讲的反调试技术的话，我们还可以通过验证LastError值是不是被修改过来检测调试器的存在，示例代码：


bool DeleteFiberApproach()% _5 i% ?, d5 g
{% Y0 y) Q+ b1 }7 o: Y& _2 O# e# o
       char fib[1024] = {0};
       // 会抛出一个异常并被调试器捕获
       DeleteFiber(fib);

       // 0x57的意思是ERROR_INVALID_PARAMETER
       return (GetLastError() != 0x57);& \9 m2 J, F" T" V
}