写在前面

在逆向工程中为了防止破解者调试软件，通常都会在软件中采用一些反调试技术来防破解。下面就是一些在逆向工程中常见的反调试技巧与示例。

BeingDebuged

利用调试器加载程序时调试器会通过CreateProcess（）创建调试进程，同时会创建调试内核对象并保存在当前线程环境块的DbgSsReserved[1]字段中，此时此线程就不同于普通线程了（一般称为调试器线程）。接着CreateProcess（）会判断是否有调试器，无则直接返回，有则调用PspCreateProcess()，此函数会根据DbgSsReserved[1]字段设置创建进程的EPROCESS的DebugPort字段，这样此被创建进程就可以称为被调试进程。接着PspCreateProcess（）会调用MmCreatePeb（），此函数会根据EPROCESS的Debugport字段设置PEB的BeingDebuged字段。（无调试器时其值为0）

我们可以直接通过内联汇编来访问BeingDebuged字段，也可以通过IsDebuggerPresent（）这个API来得到此字段的值。下面是示例程序。

int main(int argc, char *argv[])

{

	DWORD	dwBeingDebuged;

	TCHAR	szTest[]	= TEXT("已检测到调试器！");

	TCHAR	szSuccess[]	= TEXT("运行正常！");

  	dwBeingDebuged		= IsDebuggerPresent();

	if(0 != dwBeingDebuged)

	{

		MessageBox(NULL, szTest, NULL, MB_OK);

		ExitProcess(NULL);

	}

	MessageBox(NULL, szSuccess, NULL, MB_OK);

	return 0;

}

NtGlobalFlag

当BeingDebuged被设为“TRUE”后程序会将PEB的NtGlobalFlag设置0x70h标志。我们通过内联汇编检测进程环境快的NtGlobalFlag字段。

int main(int argc, char *argv[])

{

	DWORD	dwNtGlobalFlag;

	TCHAR	szTest[]	= TEXT("已检测到调试器！");

	TCHAR	szSuccess[]	= TEXT("运行正常！");

  	dwNtGlobalFlag		= _AntiDebug();

	if(0 != dwNtGlobalFlag)

	{

		MessageBox(NULL, szTest, NULL, MB_OK);

		ExitProcess(NULL);

	}

	MessageBox(NULL, szSuccess, NULL, MB_OK);

	return 0;

}

DWORD _AntiDebug()

{

	_asm{

	mov eax,fs:[0x30]

	mov eax,[eax + 0x68]

	and eax,0x70

	}

}

ProcessHeap的Flags和ForceFlags

当NtGlobalFlag字段被设置0x70标志后，其会改变PEB的字段ProcessHeap所指向的Flags和ForceFlags的值。

对于x86平台而言Flags和ForceFlags偏移地址分别是相对于ProcessHeap指向地址的0x40和0x44处。当程序未被调试器调试时Flags的值应包含0x00000002标志，ForceFlags的值应为0，下面是通过内联汇编检测二者的值。

int main(int argc, char *argv[])

{

	DWORD	dwReturn;

	TCHAR	szTest[]	= TEXT("已检测到调试器！");

	TCHAR	szSuccess[]	= TEXT("运行正常！");

  dwReturn			= _AntiDebug();

	if(0 != dwReturn)

	{

		MessageBox(NULL, szTest, NULL, MB_OK);

		ExitProcess(NULL);

	}

	MessageBox(NULL, szSuccess, NULL, MB_OK);

	return 0;

}

DWORD _AntiDebug()

{

	_asm{

	push ebx

	mov eax,fs:[0x30]

	mov eax,[eax + 0x18]

	mov ebx,dword ptr [eax + 0x40]

	and ebx,0x00000002

	cmp ebx,0

	je	end0

	mov ebx,dword ptr [eax + 0x44]

	cmp ebx,0

	jne end0

	xor eax,eax

	jmp end

end0:

	mov eax,1

end:

	pop ebx

	}

}

Heap Magic

当进程被调试器调试时其进程堆会被一些特殊的标记填充，这些特殊标记分别是0xABABABAB , 0xBAADF00D , 0xFEEEFEEE。

通过从进程堆中创建内存块来获得进程堆的起始地址，然后通过对整个进程堆双字遍历来计算这些标志的数量。（如果大于10则证明进程被调试器调试了）

int main(int argc, char *argv[])

{

	DWORD	dwNum = 0;

	PDWORD	pHeap;

	TCHAR	szTest[]	= TEXT("已检测到调试器！");

	TCHAR	szSuccess[]	= TEXT("运行正常！");

	pHeap = (DWORD*)HeapAlloc(GetProcessHeap(), NULL, 0x100);	//通过在自己的进程默认堆中申请内存得到堆中内存的地址，（还可以通过PEB的LDR_MODULE字段中得到这些标志）

	_try{

	for(;;){						        //检测Heap Magic标志。

		switch(*pHeap++){

		case 0xABABABAB:

		case 0xBAADF00D:

		case 0xFEEEFEEE:

			dwNum++;

			break;

		}

	      }

	}

	_except(EXCEPTION_EXECUTE_HANDLER){

		if(dwNum > 10)

		{

			MessageBox(NULL, szTest, NULL, MB_OK);

			ExitProcess(NULL);

		}

	}

	MessageBox(NULL, szSuccess, NULL, MB_OK);

	return 0;

}

ProcessDebugPort

如果进程被调试则进程会通过一个调试端口与调试子系统通信，进而与调试器通信。我们可以通过CheckRemoteDebuggerPresent（）来检测调试端口是否存在ProcessDebugPort实际就是PEB的DebugPort字段。同时CheckRemoteDebuggerPresent（）不仅可以检测自身是否存在调试端口，还可以检测其他进程是否存在调试端口。

int main(int argc, char *argv[])

{

	BOOL	bDebuggerPresent;

	TCHAR	szTest[]	= TEXT("已检测到调试器！");

	TCHAR	szSuccess[]	= TEXT("运行正常！");

  	CheckRemoteDebuggerPresent(GetCurrentProcess(), &bDebuggerPresent);

	if(TRUE == bDebuggerPresent)

	{

		MessageBox(NULL, szTest, NULL, MB_OK);

		ExitProcess(NULL);

	}

	MessageBox(NULL, szSuccess, NULL, MB_OK);

	return 0;

}

实际CheckRemoteDebuggerPresent（）函数内部是通过调用NtQueryInformationProcess（）来检测进程是否存在调试端口的，所以我们也可以直接通过动态调用NtQueryInformationProcess（）来检测是否存在调试端口。

typedef NTSTATUS(NTAPI  *pfnNtQueryInformationProcess)(						//typedef后可以掩饰复合类型

	_In_      HANDLE           ProcessHandle,

        _In_      UINT             ProcessInformationClass,

        _Out_     PVOID            ProcessInformation,

        _In_      ULONG            ProcessInformationLength,

        _Out_opt_ PULONG           ReturnLength

	);

//表示检测进程的调试端口

UINT ProcessDebugPort = 7;	      												

int main(int argc, char *argv[])

{

	TCHAR		szTest[]	= TEXT("已检测到调试器！");

	TCHAR		szSuccess[]	= TEXT("运行正常！");

	DWORD		dwDebuggerPresent = 0;

	NTSTATUS	stNtstatus;

	pfnNtQueryInformationProcess NtQueryInformationProcess = (pfnNtQueryInformationProcess)GetProcAddress(LoadLibrary(TEXT("ntdll.dll")), TEXT("NtQueryInformationProcess"));

  	stNtstatus = NtQueryInformationProcess(

		GetCurrentProcess(),

		ProcessDebugPort,

		&dwDebuggerPresent,

		sizeof(DWORD),

		NULL);

	if(0 != dwDebuggerPresent && stNtstatus == 0x00000000)

	{

		MessageBox(NULL, szTest, NULL, MB_OK);

		ExitProcess(NULL);

	}

	MessageBox(NULL, szSuccess, NULL, MB_OK);

	return 0;

}

ProcessDebugObjectHandle

如果进程被调试会创建一个调试内核对象，通过NtQueryInformationProcess（）可以检测是否存在调试内核对象句柄。

typedef NTSTATUS(NTAPI  *pfnNtQueryInformationProcess)(

    _In_      HANDLE           ProcessHandle,

    _In_      UINT             ProcessInformationClass,

    _Out_     PVOID            ProcessInformation,

    _In_      ULONG            ProcessInformationLength,

    _Out_opt_ PULONG           ReturnLength

);

UINT ProcessDebugObjectHandle = 0x1E;

int main(int argc, char* argv[])

{

	HANDLE		hDebugHandle;

	NTSTATUS	stNtstatus;

	pfnNtQueryInformationProcess NtQueryInformationProcess;

	NtQueryInformationProcess = (pfnNtQueryInformationProcess)GetProcAddress(LoadLibrary(TEXT("ntdll.dll")), TEXT("NtQueryInformationProcess"));

	stNtstatus = NtQueryInformationProcess(

		GetCurrentProcess(),

		ProcessDebugObjectHandle,

		&hDebugHandle,

		sizeof(HANDLE),

		NULL);

	if(0x00000000 == stNtstatus && NULL != isDebuggerPresent)

	{

		MessageBox(NULL, TEXT("已检测到调试器！"),NULL, MB_OK);

		ExitProcess(NULL);

	}

	MessageBox(NULL, TEXT("程序正常运行！"), NULL, MB_OK);

	return 0;

}

ProcessDebugFlags

当进程被调试时其进程内核对象EPROCESS的NoDebugInherit字段会被置空，调用NtQueryInformationProcess可以检测此字段的值。

typedef NTSTATUS(NTAPI  *pfnNtQueryInformationProcess)(

	_In_      HANDLE           ProcessHandle,

    _In_      UINT             ProcessInformationClass,

    _Out_     PVOID            ProcessInformation,

    _In_      ULONG            ProcessInformationLength,

    _Out_opt_ PULONG           ReturnLength

);

UINT ProcessDebugFlags = 0x1F;

int main(int argc, char* argv[])

{

	ULONG		DebugFlags;

	NTSTATUS	stNtstatus;

	pfnNtQueryInformationProcess NtQueryInformationProcess;

	NtQueryInformationProcess = (pfnNtQueryInformationProcess)GetProcAddress(LoadLibrary(TEXT("ntdll.dll")), TEXT("NtQueryInformationProcess"));

	stNtstatus = NtQueryInformationProcess(

		GetCurrentProcess(),

		ProcessDebugFlags,

		&DebugFlags,

		sizeof(ULONG),

		NULL);

	if(0x00000000 == stNtstatus && NULL == DebugFlags)

	{

		MessageBox(NULL, TEXT("已检测到调试器！"),NULL, MB_OK);

		ExitProcess(NULL);

	}

	MessageBox(NULL, TEXT("程序正常运行！"), NULL, MB_OK);

	return 0;

}

ProcessBasicInformation

调用NtQuertyInformationProcess检测ProcessBasicInformation得到一个数据结构。通过这个数据结构可以得到进程ID，进一步通过PID创建进程快照得到父进程的PID从而进一步得到父进程的用户名。通过判断父进程的用户名是不是调试器而进行反调试。

#include <Windows.h>

#include <winternl.h>

#include <TlHelp32.h>

typedef NTSTATUS(NTAPI  *pfnNtQueryInformationProcess)(

	_In_      HANDLE           ProcessHandle,

    _In_      UINT             ProcessInformationClass,

    _Out_     PVOID            ProcessInformation,

    _In_      ULONG            ProcessInformationLength,

    _Out_opt_ PULONG           ReturnLength

);

const UINT uProcessBasicInformation = 0;

DWORD GetParentPID(DWORD dwPid);

BOOL GetExeNameByPID(char * szExeName, DWORD dwPid);

int main(int argc, char* argv[])

{

	char 		szExeName[256] = {0};

	DWORD		dwParent;

	NTSTATUS	stNtstatus;

	pfnNtQueryInformationProcess NtQueryInformationProcess;

	PROCESS_BASIC_INFORMATION stProcessBasicInformation;							

	NtQueryInformationProcess = (pfnNtQueryInformationProcess)GetProcAddress(LoadLibrary(TEXT("ntdll.dll")), TEXT("NtQueryInformationProcess"));

	stNtstatus = NtQueryInformationProcess(

		GetCurrentProcess(),

		uProcessBasicInformation,

		&stProcessBasicInformation,

		sizeof(PROCESS_BASIC_INFORMATION),

		NULL);

	dwParent = GetParentPID(stProcessBasicInformation.UniqueProcessId);

	GetExeNameByPID(szExeName, dwParent);

	if(0x00000000 == stNtstatus && (lstrcmp(szExeName, "explorer.exe") && lstrcmp(szExeName, "cmd.exe") && lstrcmp(szExeName, "services.exe")))

	{

		MessageBox(NULL, TEXT("已检测到调试器！"),NULL, MB_OK);

		ExitProcess(NULL);

	}

	MessageBox(NULL, TEXT("程序正常运行！"), NULL, MB_OK);

	return 0;

}

//获取父进程的PID

DWORD GetParentPID(DWORD dwPid)

{

	HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

	PROCESSENTRY32 pe32;

	pe32.dwSize = sizeof(PROCESSENTRY32);

	if(hProcessSnap == INVALID_HANDLE_VALUE)

	{

		CloseHandle(hProcessSnap);

		return 0;

	}

	if(!Process32First(hProcessSnap, &pe32))

	{

		CloseHandle(hProcessSnap);

		return 0;

	}

	do{

		if(pe32.th32ProcessID == dwPid)

			break;

	}while(Process32Next(hProcessSnap, &pe32));

	return pe32.th32ParentProcessID;

}

//获取对应PID进程的程序名称

BOOL GetExeNameByPID(char szExeName[], DWORD dwPid)

{

	HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

	PROCESSENTRY32 pe32;

	pe32.dwSize = sizeof(PROCESSENTRY32);

	if(hProcessSnap == INVALID_HANDLE_VALUE)

	{

		CloseHandle(hProcessSnap);

		return 0;

	}

	if(!Process32First(hProcessSnap, &pe32))

	{

		CloseHandle(hProcessSnap);

		return 0;

	}

	do{

		if(pe32.th32ProcessID == dwPid)

		{

			lstrcpy(szExeName, pe32.szExeFile);

			break;

		}

	}while(Process32Next(hProcessSnap, &pe32));

	return 1;

}

HideFromDebugger

被调试进程通过调试端口DebugPort与调试子系统通信进一步与调试器通信。如果我们能将DebugPort清除就可以阻止进程与调试器通信达到反调试的目的，但是DebugPort一旦被创建就无法被在设置，所以我们这种思路走不通。

我们发现进程如果产生异常，其会检测ETHREAD的HideFromDebugger成员是否为“FALSE”,如果是就会向当前进程的调试端口发送调试事件消息（为"TRUE"表示该异常对用户调试器不可见）。我们可以通过ZwSetInformationThread（）设置HideFromDebugger字段的值为TRUE从而令用户调试器接收不到调试事件，达到反调试的目的。

#include <winternl.h>

typedef NTSTATUS (NTAPI *pfnZwSetInformationThread)(

	_In_ HANDLE ThreadHandle,

	_In_ UINT	ThreadInformationClass,

	_In_ PVOID	ThreadInformation,

	_In_ ULONG	ThreadInformationLength

	);

UINT uThreadHideFromDebugger = 0x11;

int main(int argc, char * argv[])

{

	NTSTATUS stNtstatus;

	pfnZwSetInformationThread ZwSetInformationThread;

	ZwSetInformationThread = (pfnZwSetInformationThread)GetProcAddress(LoadLibrary(TEXT("ntdll.dll")), TEXT("ZwSetInformationThread"));

	ZwSetInformationThread(

		GetCurrentThread(),

		uThreadHideFromDebugger,

		0,

		0);

	return 0;

}

NtCreateThreadEx

通过CreateThread( )的时候利用THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER标志，则在创建该线程时，它将对调试器隐藏。

//通过CreateThread( )的时候利用THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER标志，则在创建该线程时，它将对调试器隐藏。

//#include <Windows.h>

typedef NTSTATUS(NTAPI* pfnNtCreateThreadEx) (

    _Out_    PHANDLE              ThreadHandle,

    _In_     ACCESS_MASK          DesiredAccess,

    _In_opt_ PVOID		  ObjectAttributes,		//POBJECT_ATTRIBUTES

    _In_     HANDLE               ProcessHandle,

    _In_     PVOID                StartRoutine,

    _In_opt_ PVOID                Argument,

    _In_     ULONG                CreateFlags,

    _In_opt_ ULONG_PTR            ZeroBits,

    _In_opt_ SIZE_T               StackSize,

    _In_opt_ SIZE_T               MaximumStackSize,

    _In_opt_ PVOID                AttributeList

);

void ThreadProc();

int main(int argc, char* argv[])

{

	HANDLE hThread;

	pfnNtCreateThreadEx NtCreateThreadEx;

	NtCreateThreadEx = (pfnNtCreateThreadEx)GetProcAddress(LoadLibrary(TEXT("ntdll.dll")), TEXT("NtCreateThreadEx"));

	NtCreateThreadEx(

		&hThread,

		0x1FFFFF,

		NULL,

		GetCurrentProcess(),

		(LPTHREAD_START_ROUTINE)ThreadProc,

		NULL,

		0x00000004,					//直接执行并且对调试器隐藏THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER

		NULL,

		NULL,

		NULL,

		NULL

		);

	WaitForSingleObject(hThread,INFINITE);

	int n = GetLastError();

	return 0;

}

//线程回调函数

void ThreadProc()

{

	MessageBox(NULL, TEXT("我是一个新线程！"), NULL, MB_OK);

}

参考资料：看雪学院《加密解密》

张银奎《软件调试》

https://www.apriorit.com/dev-blog/367-anti-reverse-engineering-protection-techniques-to-use-before-releasing-software

巴特西

Windows反调试技术（上）