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