作 者: shellwolf
时 间: 2008-08-10,22:40:53
链 接: http://bbs.pediy.com/showthread.php?t=70470
反调试技巧总结-原理和实现
-------------------------------------------------------------------------------------------------------
2008.8.7 shellwolf
一、 前言
前段学习反调试和vc，写了antidebug-tester，经常会收到message希望交流或索要实现代码，我都没有回复。其实代码已经在编程版提供了1个版本，另其多是vc内嵌asm写的，对cracker而言，只要反下就知道了。我想代码其实意义不是很大，重要的是理解和运用。
做个简单的总结，说明下实现原理和实现方法。也算回复了那些给我发Message的朋友。
部分代码和参考资料来源：
1、<<脱壳的艺术>> hawking
2、<<windows anti-debugger reference>> Angeljyt
3、http://bbs.pediy.com
4、<<软件加密技术内幕>> 看雪学院
5、<<ANTI-UNPACKER TRICKS>> Peter Ferrie
我将反调试技巧按行为分为两大类，一类为检测，另一类为攻击，每类中按操作对象又分了五个小类：
1、 通用调试器 包括所有调试器的通用检测方法
2、 特定调试器 包括OD、IDA等调试器，也包括相关插件，也包括虚拟环境
3、 断点 包括内存断点、普通断点、硬件断点检测
4、 单步和跟踪 主要针对单步跟踪调试
5、 补丁 包括文件补丁和内存补丁
反调试函数前缀
检测 攻击
通用调试器 FD_ AD_
特定调试器 FS_ AS_
断点 FB_ AB_
单步和跟踪 FT_ AT_
补丁 FP_ AP_
声明：
1、本文多数都是摘录和翻译，我只是重新组合并翻译，不会有人告侵权吧。里面多是按自己的理解来说明，可能有理解错误，或有更好的实现方法，希望大家帮忙指出错误。
2、我并没有总结完全，上面的部分分类目前还只有很少的函数甚至空白，等待大家和我一起来完善和补充。我坚信如果有扎实的基础知识，丰富的想像力，灵活的运用，就会创造出更多的属于自己的反调试。而最强的反调试，通常都是自己创造的，而不是来自别人的代码。
二、 查找-通用调试器(FD_)
函数列表如下，后面会依次说明，需事先说明的是，这些反调试手段多数已家喻户晓，目前有效的不多，多数已可以通过OD的插件顺利通过，如果你想验证它们的有效性，请关闭OD的所有反反调试插件：
bool FD_IsDebuggerPresent();
bool FD_PEB_BeingDebuggedFlag();
bool FD_PEB_NtGlobalFlags();
bool FD_Heap_HeapFlags();
bool FD_Heap_ForceFlags();
bool FD_Heap_Tail();
bool FD_CheckRemoteDebuggerPresent();
bool FD_NtQueryInfoProc_DbgPort();
bool FD_NtQueryInfoProc_DbgObjHandle();
bool FD_NtQueryInfoProc_DbgFlags();
bool FD_NtQueryInfoProc_SysKrlDbgInfo();
bool FD_SeDebugPrivilege();
bool FD_Parent_Process();
bool FD_DebugObject_NtQueryObject();
bool FD_Find_Debugger_Window();
bool FD_Find_Debugger_Process();
bool FD_Find_Device_Driver();
bool FD_Exception_Closehandle();
bool FD_Exception_Int3();
bool FD_Exception_Popf();
bool FD_OutputDebugString();
bool FD_TEB_check_in_Vista();
bool FD_check_StartupInfo();
bool FD_Parent_Process1();
bool FD_Exception_Instruction_count();
bool FD_INT_2d();
2.1 FD_IsDebuggerPresent()
对调试器来说，IsDebuggerPresent是臭名昭著的恶意函数。不多说了，它是个检测调试的api函数。实现更简单，只要调用IsDebuggerPresent就可以了。在调用它之前，可以加如下代码，以用来检测是否在函数头有普通断点，或是否被钩挂。
//check softbreak
if(*(BYTE*)Func_addr==0xcc)
return true;
//check hook
if(*(BYTE*)Func_addr!=0x64)
return true;
2.2 FD_PEB_BeingDebuggedFlag
我们知道，如果程序处于调试器中，那么在PEB结构中有个beingDegug标志会被设置，直接读取它就可判断是否在调试器中。实际上IsDebuggerPresent就是这么干的。
__asm
{
mov eax, fs:[30h] ;EAX = TEB.ProcessEnvironmentBlock
inc eax
inc eax
mov eax, [eax]
and eax,0x000000ff ;AL = PEB.BeingDebugged
test eax, eax
jne rt_label
jmp rf_label
}
2.3 FD_PEB_NtGlobalFlags
PEB中还有其它FLAG表明了调试器的存在，如NtGlobalFlags。它位于PEB环境中偏移为0x68的位置，默认情况下该值为0，在win2k和其后的windows平台下，如果在调试中，它会被设置为一个特定的值。使用该标志来判断是否被调试并不可靠（如在winnt中），但这种方法却也很常用。这个标志由下面几个标志组成：
***_HEAP_ENABLE_TAIL_CHECK (0x10)
***_HEAP_ENABLE_FREE_CHECK (0x20)
***_HEAP_VALIDATE_PARAMETERS (0x40)
检测NtGlobalFlags的方法如下，这个方法在ExeCryptor中使用过。
__asm
{
mov eax, fs:[30h]
mov eax, [eax+68h]
and eax, 0x70
test eax, eax
jne rt_label
jmp rf_label
}
2.4 FD_Heap_HeapFlags()
同样，调试器也会在堆中留下痕迹，你可以使用kernel32_GetProcessHeap()函数，如果你不希望使用api函数（以免暴露），则可以直接在PEB中寻找。同样的，使用HeapFlags和后面提到的ForceFlags来检测调试器也不是非常可靠，但却很常用。
这个域由一组标志组成，正常情况下，该值应为2。
__asm
{
mov eax, fs:[30h]
mov eax, [eax+18h] ;PEB.ProcessHeap
mov eax, [eax+0ch] ;PEB.ProcessHeap.Flags
cmp eax, 2
jne rt_label
jmp rf_label
}
2.5 FD_Heap_ForceFlags
进程堆里另外一个标志，ForceFlags，它也由一组标志组成，正常情况下，该值应为0。
__asm
{
mov eax, fs:[30h]
mov eax, [eax+18h] ;PEB.ProcessHeap
mov eax, [eax+10h] ;PEB.ProcessHeap.ForceFlags
test eax, eax
jne rt_label
jmp rf_label
}
2.6 FD_Heap_Tail
如果处于调试中，堆尾部也会留下痕迹。标志HEAP_TAIL_CHECKING_ENABLED 将会在分配的堆块尾部生成两个0xABABABAB。如果需要额外的字节来填充堆尾，HEAP_FREE_CHECKING_ENABLED标志则会生成0xFEEEFEEE。
据说Themida使用过这个反调试
__asm
{
mov eax, buff
;get unused_bytes
movzx ecx, byte ptr [eax-2]
movzx edx, word ptr [eax-8] ;size
sub eax, ecx
lea edi, [edx*8+eax]
mov al, 0abh
mov cl, 8
repe sca**
je rt_label
jmp rf_label
}
2.7 FD_CheckRemoteDebuggerPresent
CheckRemoteDebuggerPresent是另一个检测调试的api，只是可惜它似乎只能在winxp sp1版本以后使用。它主要是用来查询一个在winnt时就有的一个数值，其内部会调用NtQueryInformationProcess()，我是这样实现的：
FARPROC Func_addr ;
HMODULE hModule = GetModuleHandle("kernel32.dll");
if (hModule==INVALID_HANDLE_VALUE)
return false;
(FARPROC&) Func_addr =GetProcAddress(hModule, "CheckRemoteDebuggerPresent");
if (Func_addr != NULL)
{
__asm
{
push eax;
push esp;
push 0xffffffff;
call Func_addr;
test eax,eax;
je rf_label;
pop eax;
test eax,eax
je rf_label;
jmp rt_label;
}
}
2.8 FD_NtQueryInfoProc_DbgPort
使用ntdll_NtQueryInformationProcess()来查询ProcessDebugPort可以用来检测反调试。如果进程被调试，其返回值应为0xffffffff。
下面的代码应该是从pediy里copy过来的，时间太长，不记得是哪位兄弟的代码了。
HMODULE hModule = GetModuleHandle("ntdll.dll");
ZW_QUERY_INFORMATION_PROCESS ZwQueryInformationProcess;
ZwQueryInformationProcess = (ZW_QUERY_INFORMATION_PROCESS)GetProcAddress(hModule, "ZwQueryInformationProcess");
if (ZwQueryInformationProcess == NULL)
return false;
PROCESS_DEBUG_PORT_INFO ProcessInfo;
if (STATUS_SUCCESS != ZwQueryInformationProcess(GetCurrentProcess( ), ProcessDebugPort, &ProcessInfo, sizeof(ProcessInfo), NULL))
return false;
else
if(ProcessInfo.DebugPort)
return true;
else
return false;
2.9 FD_NtQueryInfoProc_DbgObjHandle
在winxp中引入了"debug object".当一个调试活动开始，一个"debug object"被创建，同也相应产生了一个句柄。使用为公开的ProcessDebugObjectHandle类，可以查询这个句柄的数值。
代码可能还是从pediy里复制的，不记得了。
HMODULE hModule = GetModuleHandle("ntdll.dll");
ZW_QUERY_INFORMATION_PROCESS ZwQueryInformationProcess;
ZwQueryInformationProcess = (ZW_QUERY_INFORMATION_PROCESS)GetProcAddress(hModule, "ZwQueryInformationProcess");
if (ZwQueryInformationProcess == NULL)
return false;
_PROCESS_DEBUG_OBJECTHANDLE_INFO ProcessInfo;
if (STATUS_SUCCESS != ZwQueryInformationProcess(GetCurrentProcess( ), (PROCESS_INFO_CLASS)0x0000001e, &ProcessInfo, sizeof(ProcessInfo), NULL))
return false;
else
if(ProcessInfo.ObjectHandle)
return true;
else
return false;
2.10 FD_NtQueryInfoProc_DbgFlags();
同样的未公开的ProcessDebugFlags类，当调试器存在时，它会返回false。
HMODULE hModule = GetModuleHandle("ntdll.dll");
ZW_QUERY_INFORMATION_PROCESS ZwQueryInformationProcess;
ZwQueryInformationProcess = (ZW_QUERY_INFORMATION_PROCESS)GetProcAddress(hModule, "ZwQueryInformationProcess");
if (ZwQueryInformationProcess == NULL)
return false;
_PROCESS_DEBUG_FLAGS_INFO ProcessInfo;
if (STATUS_SUCCESS != ZwQueryInformationProcess(GetCurrentProcess( ), (PROCESS_INFO_CLASS)0x0000001f, &ProcessInfo, sizeof(ProcessInfo), NULL))
return false;
else
if(ProcessInfo.Debugflags)
return false;
else
return true;
2.11 FD_NtQueryInfoProc_SysKrlDbgInfo()
这个方法估计对大家用处不大，SystemKernelDebuggerInformation类同样可以用来识别调试器，只是可惜在windows下无效，据称可以用在reactOS中。
HMODULE hModule = GetModuleHandle("ntdll.dll");
ZW_QUERY_SYSTEM_INFORMATION ZwQuerySystemInformation;
ZwQuerySystemInformation = (ZW_QUERY_SYSTEM_INFORMATION)GetProcAddress(hModule, "ZwQuerySystemInformation");
if (ZwQuerySystemInformation == NULL)
return false;
SYSTEM_KERNEL_DEBUGGER_INFORMATION Info;
if (STATUS_SUCCESS == ZwQuerySystemInformation(SystemKernelDebuggerInformation, &Info, sizeof(Info), NULL))
{
if (Info.DebuggerEnabled)
{
if (Info.DebuggerNotPresent)
return false;
else
return true;
}
else
return false;
}
else
return true;
2.12 FD_SeDebugPrivilege()
当一个进程获得SeDebugPrivilege，它就获得了对CSRSS.EXE的完全控制，这种特权也会被子进程继承，也就是说一个被调试的程序如果获得了CSRSS.EXE的进程ID,它就可以使用openprocess操作CSRSS.EXE。获得其进程ID有很多中方法，如Process32Next，或NtQuerySystemInformation，在winxp下可以使用CsrGetProcessId。
hTmp=OpenProcess(PROCESS_ALL_ACCESS,false,PID_csrss);
if(hTmp!=NULL)
{
CloseHandle(hProcessSnap );
return true;
}
2.13 FD_Parent_Process()
通常我们都直接在windows界面下运行应用程序，这样的结果就是它的父进程为"explorer.exe"，这个反调试就是检测应用程序的父进程是否为"explorer.exe"，如不是则判定为处于调试器中，这也不是百分百可靠，因为有的时候你的程序是在命令行提示符下运行的。
Yoda使用了这个反调试，它使用Process32Next检测父进程，目前很多插件已经通过使Process32Next始终返回false来越过这个反调试(比如HideOD)。不过可以对代码做些简单的修正来处理这个反反调试。
2.14 FD_DebugObject_NtQueryObject();
如前面所描述的，当一个调试活动开始，一个"debug object"被创建，同也相应产生了一个句柄。我们可以查询这个调试对象列表，并检查调试对象的数量，以实现调试器的检测。
HMODULE hModule = GetModuleHandle("ntdll.dll");
PNtQueryObject NtQueryObject;
NtQueryObject = (PNtQueryObject)GetProcAddress(hModule,"NtQueryObject");
if(NtQueryObject==NULL)
return false;
unsigned char szdbgobj[25]=
"\x44\x00\x65\x00\x62\x00\x75\x00\x67\x00\x4f\x00\x62\x00\x6a\x00\x65\x00\x63\x00\x74\x00\x00\x00";
unsigned char *psz=&szdbgobj[0];
__asm
{
xor ebx,ebx;
push ebx;
push esp;
push ebx;
push ebx;
push 3;
push ebx;
Call dword ptr [NtQueryObject];
pop edi;
push 4;
push 1000h;
push edi;
push ebx;
call dword ptr [VirtualAlloc];
push ebx;
push edi;
push eax;
push 3;
push ebx;
xchg esi,eax;
Call dword ptr [NtQueryObject];
lodsd;
xchg ecx,eax;
lable1: lodsd;
movzx edx,ax;
lodsd;
xchg esi,eax;
cmp edx,16h;
jne label2;
xchg ecx,edx;
mov edi,psz;
repe cmp**;
xchg ecx,edx;
jne label2;
cmp dword ptr [eax],edx
jne rt_label;
lable2: add esi,edx
and esi,-4;
lodsd
loop label1;
}
return false;
rt_label:
return true;
2.15 FD_Find_Debugger_Window();
通过列举运行的应用程序的窗口，并于常用调试相关工具比对的方法，应该很常用了，就不多说了。这个也是个可以自行增加项目的函数，你可以将一些常用的调试工具归入其中，比如OD,IDA,WindBG,SoftICE等，你也可以添加任何你需要的，比如"Import REConstructor v1.6 FINAL (C) 2001-2003 MackT/uCF"，"Registry Monitor - Sysinternals: www.sysinternals.com"等等。
//ollyice
hWnd=CWnd::FindWindow(_T("1212121"),NULL);
if (hWnd!=NULL)
return true;
//ollydbg v1.1
hWnd=CWnd::FindWindow(_T("icu_dbg"),NULL);
if (hWnd!=NULL)
return true;
//ollyice pe--diy
hWnd=CWnd::FindWindow(_T("pe--diy"),NULL);
if (hWnd!=NULL)
return true;
//ollydbg ?-°?
hWnd=CWnd::FindWindow(_T("ollydbg"),NULL);
if (hWnd!=NULL)
return true;
//ollydbg ?-°?
hWnd=CWnd::FindWindow(_T("odbydyk"),NULL);
if (hWnd!=NULL)
return true;
//windbg
hWnd=CWnd::FindWindow(_T("WinDbgFrameClass"),NULL);
if (hWnd!=NULL)
return true;
//dede3.50
hWnd=CWnd::FindWindow(_T("TDeDeMainForm"),NULL);
if (hWnd!=NULL)
return true;
//IDA5.20
hWnd=CWnd::FindWindow(_T("TIdaWindow"),NULL);
if (hWnd!=NULL)
return true;
//others
hWnd=CWnd::FindWindow(_T("TESTDBG"),NULL);
if (hWnd!=NULL)
return true;
hWnd=CWnd::FindWindow(_T("kk1"),NULL);
if (hWnd!=NULL)
return true;
hWnd=CWnd::FindWindow(_T("Eew75"),NULL);
if (hWnd!=NULL)
return true;
hWnd=CWnd::FindWindow(_T("Shadow"),NULL);
if (hWnd!=NULL)
return true;
//PEiD v0.94
hWnd=CWnd::FindWindow(NULL,"PEiD v0.94");
if (hWnd!=NULL)
return true;
//RegMON
hWnd=CWnd::FindWindow(NULL,"Registry Monitor - Sysinternals: www.sysinternals.com");
if (hWnd!=NULL)
return true;
//File Monitor
hWnd=CWnd::FindWindow(NULL,"File Monitor - Sysinternals: www.sysinternals.com");
if (hWnd!=NULL)
return true;
//Import Rec v1.6
hWnd=CWnd::FindWindow(NULL,"Import REConstructor v1.6 FINAL (C) 2001-2003 MackT/uCF");
if (hWnd!=NULL)
return true;
return false;
2.16 FD_Find_Debugger_Process();
与上面的方法类似，区别是这个反调试用通过查询进程名字与已知的常用调试器应用程序名字进行比对，以确定是否有调试器处于运行状态。
if(strcmp(pe32.szExeFile,"OLLYICE.EXE")==0)
return true;
if(strcmp(pe32.szExeFile,"IDAG.EXE")==0)
return true;
if(strcmp(pe32.szExeFile,"OLLYDBG.EXE")==0)
return true;
if(strcmp(pe32.szExeFile,"PEID.EXE")==0)
return true;
if(strcmp(pe32.szExeFile,"SOFTICE.EXE")==0)
return true;
if(strcmp(pe32.szExeFile,"LORDPE.EXE")==0)
return true;
if(strcmp(pe32.szExeFile,"IMPORTREC.EXE")==0)
return true;
if(strcmp(pe32.szExeFile,"W32DSM89.EXE")==0)
return true;
if(strcmp(pe32.szExeFile,"WINDBG.EXE")==0)
return true;
2.17 FD_Find_Device_Driver()
调试工具通常会使用内核驱动，因此如果尝试是否可以打开一些调试器所用到的设备，就可判断是否存在调试器。常用的设备名称如下：
\\.\SICE （SoftICE）
\\.\SIWVID（SoftICE）
\\.\NTICE （SoftICE）
\\.\REGVXG（RegMON）
\\.\REGVXD（RegMON）
\\.\REGSYS（RegMON）
\\.\REGSYS（RegMON）
\\.\FILEVXG（FileMON）
\\.\FILEM（FileMON）
\\.\TRW（TRW2000）
2.18 FD_Exception_Closehandle()
如果给CloseHandle()函数一个无效句柄作为输入参数，在无调试器时，将会返回一个错误代码，而有调试器存在时，将会触发一个EXCEPTION_INVALID_HANDLE (0xc0000008)的异常。
__try
{
CloseHandle(HANDLE(0x00001234));
return false;
}
__except(1)
{
return true;
}
2.19 FD_Exception_Int3()
通过Int3产生异常中断的反调试比较经典。当INT3 被执行到时, 如果程序未被调试, 将会异常处理器程序继续执行。而INT3指令常被调试器用于设置软件断点，int 3会导致调试器误认为这是一个自己的断点，从而不会进入异常处理程序。
__asm
{
push offset exception_handler; set exception handler
push dword ptr fs:[0h]
mov dword ptr fs:[0h],esp
xor eax,eax;reset EAX invoke int3
int 3h
pop dword ptr fs:[0h];restore exception handler
add esp,4
test eax,eax; check the flag
je rt_label
jmp rf_label
exception_handler:
mov eax,dword ptr [esp+0xc];EAX = ContextRecord
mov dword ptr [eax+0xb0],0xffffffff;set flag (ContextRecord.EAX)
inc dword ptr [eax+0xb8];set ContextRecord.EIP
xor eax,eax
retn
rt_label:
xor eax,eax
inc eax
mov esp,ebp
pop ebp
retn
rf_label:
xor eax,eax
mov esp,ebp
pop ebp
retn
}
2.20 FD_Exception_Popf()
我们都知道标志寄存器中的陷阱标志，当该标志被设置时，将产生一个单步异常。在程序中动态设置这给标志，如果处于调试器中，该异常将会被调试器捕获。
可通过下面的代码设置标志寄存器。
pushf
mov dword ptr [esp], 0x100
popf
2.21 FD_OutputDebugString()
在有调试器存在和没有调试器存在时，OutputDebugString函数表现会有所不同。最明显的不同是， 如果有调试器存在，其后的GetLastError()的返回值为零。
OutputDebugString("");
tmpD=GetLastError();
if(tmpD==0)
return true;
return false;
2.22 FD_TEB_check_in_Vista();
这是从windows anti-debug reference里拷贝出来的，据说是适用于vista系统下检测调试器。我没有vista所以也没有测试。有条件的可以试下，有问题帮忙反馈给我。多谢。
//vista
__asm
{
push offset exception_handler; set exception handler
push dword ptr fs:[0h]
mov dword ptr fs:[0h],esp
xor eax,eax;reset EAX invoke int3
int 3h
pop dword ptr fs:[0h];restore exception handler
add esp,4
mov eax, fs:[18h] ; teb
add eax, 0BFCh
mov ebx, [eax] ; pointer to a unicode string
test ebx, ebx ; (ntdll.dll, gdi32.dll,...)
je rf_label
jmp rt_label
exception_handler:
mov eax,dword ptr [esp+0xc];EAX = ContextRecord
inc dword ptr [eax+0xb8];set ContextRecord.EIP
xor eax,eax
retn
}
2.23 FD_check_StartupInfo();
这是从pediy上拷贝来的。Window创建进程的时候会把STARTUPINFO结构中的值设为0,而通过调试器创建进程的时候会忽略这个结构中的值，也就是结构中的值不为0，所以可以利用这个来判断是否在调试程序。
STARTUPINFO si;
ZeroMemory( &si, sizeof(si) );
si.cb = sizeof(si);
GetStartupInfo(&si);
if ( (si.dwX != 0) || (si.dwY !=0)
|| (si.dwXCountChars != 0) || (si.dwYCountChars !=0 )
|| (si.dwFillAttribute != 0) || (si.dwXSize != 0)
|| (si.dwYSize != 0) )
return true;
else
return false;
2.24 FD_Parent_Process1()
与前面的FD_Parent_Process原理一样，唯一不同的是使用ZwQueryInformationProcess检测父进程，而没有使用Process32Next，这有一个好处是可以绕过OD的HideOD插件。
2.25 FD_Exception_Instruction_count()
好像《软件加解密技术》中有提到这个反调试。
通过注册一个异常句柄，在特定地址设置一些硬件断点，当通过这些地址时都会触发EXCEPTION_SINGLE_STEP (0x80000004)的异常，在异常处理程序中，将会调整指令指针到一条新指令，然后恢复运行。可以通过进入进程context结构来设置这些断点，有些调试器不能处理那些不是自己设置的硬件断点，从而导致一些指令将会被漏掉计数，这就形成了一个反调试。
__asm
{
xor eax,eax;
cdq;
push e_handler;
push dword ptr fs:[eax];
mov fs:[eax],esp;
int 3;
hwbp1: nop
hwbp2: nop
hwbp3: nop
hwbp4: nop
div edx
nop
pop dword ptr fs:[0]
add esp,4
cmp al,4;
jne rt_label;
jmp rf_label;
e_handler:
xor eax,eax;
;ExceptionRecord
mov ecx,dword ptr[esp+0x04]
;Contextrecord
mov edx,dword ptr[esp+0x0c]
;ContextEIP
inc byte ptr[edx+0xb8];
;ExceptionCode
mov ecx,dword ptr[ecx];
;1.EXCEPTION_INT_DIVIDE_BY_ZERO
cmp ecx,0xc0000094;
jne Ex_next2;
;Context_eip
inc byte ptr[edx+0xb8];
mov dword ptr[edx+0x04],eax;dr0
mov dword ptr[edx+0x08],eax;dr1
mov dword ptr[edx+0x0c],eax;dr2
mov dword ptr[edx+0x10],eax;dr3
mov dword ptr[edx+0x14],eax;dr6
mov dword ptr[edx+0x18],eax;dr7
ret
;2.EXCEPTION_BREAKPOINT
Ex_next2:
cmp ecx,0x80000003;
jne Ex_next3;
mov dword ptr[edx+0x04],offset hwbp1;dr0
mov dword ptr[edx+0x08],offset hwbp2;dr1
mov dword ptr[edx+0x0c],offset hwbp3;dr2
mov dword ptr[edx+0x10],offset hwbp4;dr3
mov dword ptr[edx+0x18],0x155;dr7
ret
;3.EXCEPTION_SINGLE_STEP
Ex_next3:
cmp ecx,0x80000004
jne rt_label
;CONTEXT_Eax
inc byte ptr[edx+0xb0]
ret
}
2.26 FD_INT_2d()
在windows anti-debug reference中指出，如果程序未被调试这个中断将会生产一个断点异常. 被调试并且未使用跟踪标志执行这个指令, 将不会有异常产生程序正常执行. 如果被调试并且指令被跟踪, 尾随的字节将被跳过并且执行继续. 因此, 使用 INT 2Dh 能作为一个强有力的反调试和反跟踪机制。
__try
{
__asm
{
int 2dh
inc eax;any opcode of singlebyte.
;or u can put some junkcode,"0xc8"..."0xc2"..."0xe8"..."0xe9"
}
return true;
}
__except(1)
{
return false;
}
三、 检测-专用调试器(FS_)
这一部分是我比较喜欢的，但内容还不是很丰富，比如：
1、 针对SoftIce的检测方法有很多，但由于我从没使用过Softice，也没有条件去测试，所以没有给出太多，有兴趣的可以自己查阅资料进行补充，针对softice网上资料较多，或查阅《软件加解密技术》。
2、 同样，这里也没有给出windbg等等其它调试器的检测方法。
3、 而针对Odplugin，也只给了几种HideOD的检测。事实上，目前OD的使用者通常都使用众多的强大插件，当OD的反调试越来越普遍时，自己设计几款常用的OD插件的反调试，将会是非常有效的反调试手段。
4、 对VME的检测也只给出了两种，如想丰富这一部分可以参考Peter Ferrie的一篇anti-vme的文章（http://bbs.pediy.com/showthread.php?t=68411）。里面有非常多的anti-vme方法。
针对专用调试器的函数列表如下：
//find specific debugger
bool FS_OD_Exception_GuardPages();
bool FS_OD_Int3_Pushfd();
bool FS_SI_UnhandledExceptionFilter();
bool FS_ODP_Process32NextW();
bool FS_ODP_OutputDebugStringA();
bool FS_ODP_OpenProcess();
bool FS_ODP_CheckRemoteDebuggerPresent();
bool FS_ODP_ZwSetInformationThread();
bool FS_SI_Exception_Int1();
bool IsInsideVMWare_();
bool FV_VMWare_VMX();
bool FV_VPC_Exception();
int FV_VME_RedPill();//0:none,1:vmvare;2:vpc;3:others
3.1 FS_OD_Exception_GuardPages
“保护页异常”是一个简单的反调试技巧。当应用程序尝试执行保护页内的代码时，将会产生一个EXCEPTION_GUARD_PAGE(0x80000001)异常，但如果存在调试器，调试器有可能接收这个异常，并允许该程序继续运行，事实上，在OD中就是这样处理的，OD使用保护页来实现内存断点。
最开始实现时忘记了free申请的空间，多谢sessiondiy提醒。
SYSTEM_INFO sSysInfo;
LPVOID lpvBase;
BYTE * lptmpB;
GetSystemInfo(&sSysInfo);
DWORD dwPageSize=sSysInfo.dwPageSize;
DWORD flOldProtect;
DWORD dwErrorcode;
lpvBase=VirtualAlloc(NULL,dwPageSize,MEM_COMMIT,PAGE_READWRITE);
if(lpvBase==NULL)
return false;
lptmpB=(BYTE *)lpvBase;
*lptmpB=0xc3;//retn
VirtualProtect(lpvBase,dwPageSize,PAGE_EXECUTE_READ | PAGE_GUARD,&flOldProtect);
__try
{
__asm call dword ptr[lpvBase];
VirtualFree(lpvBase,0,MEM_RELEASE);
return true;
}
__except(1)
{
VirtualFree(lpvBase,0,MEM_RELEASE);
return false;
}
3.2 FS_OD_Int3_Pushfd
这是个最近比较牛X的反调试，据称是vmp1.64里发现的，好像ttprotect里面也有使用，我没有验证。Pediy里有帖子详细讨论，我是看到gkend的分析，才搞懂一些。下面摘自gkend分析
代码:
int3，pushfd和int3，