BasicBit HomeArchivesDevelopNoteReverseOS
反调试总结

API 检测

1
2
3
4
5
6
PBYTE pCC = (PBYTE)MessageBoxW;
if (*pCC == 0xCC)
{
	return true;
}
MessageBoxW(0, L"未发现调试器！\n", 0, 0);

在调试器中下断点时,会将目标地址的首字节替换为0xCC,上述代码以此进行判断会否处于调试状态

破解思路:避免在函数的首地址下断点,可以在函数的其他代码部分下断,通常在ret指令处下断

PEB BeingDebugged

1
2
3
4
5
__asm {
	MOV EAX, DWORD PTR FS : [0x30] ;获取PEB
	MOV AL, BYTE PTR DS : [EAX + 2]
	MOV bDebugged, AL
}

当进程被调试时,AL的值为1,这个值取自PEB的BeingDebugged成员.

代码校验

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
bool CheckDebug_Checksum()
{
	BOOL bDebugging = FALSE;
	__asm {
		call CHECKBEGIN
CHECKBEGIN:
		pop esi
		mov ecx, 0x15           // ecx : loop count
		xor eax, eax            // eax : checksum
		xor ebx, ebx

_CALC_CHECKSUM :
		movzx ebx, byte ptr ds : [esi]
		add eax, ebx
		rol eax, 1
		inc esi
		loop _CALC_CHECKSUM
		cmp eax, 0x1859a602
		je _NOT_DEBUGGING
		mov bDebugging, 1
_NOT_DEBUGGING:
	}
	return bDebugging;
}

调试信号判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
int main()
{
	// 尝试打开互斥体，确定是否首次运行程序
	HANDLE hMutex = OpenMutex(MUTEX_MODIFY_STATE, FALSE, L"Global\\MyMutex");
	if (hMutex)
	{
		// 打开成功说明第2次运行，执行正常代码
		printf("正被调试运行！\n");
		getchar();
	}
	else
	{
		// 打开失败说明第1次运行，创建互斥体，并调试创建自身进程
		CreateMutex(NULL, FALSE, L"Global\\MyMutex");
		TCHAR szPath[MAX_PATH] = {};
		GetModuleFileName(NULL, szPath, MAX_PATH);
		// 调试方式打开程序
		STARTUPINFO si = { sizeof(STARTUPINFO) };
		PROCESS_INFORMATION pi = {};
		// 正常创建，后面附加调试
		BOOL bStatus = CreateProcess(szPath, NULL, NULL, NULL, FALSE,
			CREATE_NEW_CONSOLE,
			NULL, NULL, &si, &pi);
		if (!bStatus) {
			printf("创建进程失败!\n");
			return 0;
		}
		if (!DebugActiveProcess(pi.dwProcessId)) {
			printf("附加进程失败!\n");
			return 0;
		}
		// 初始化调试事件结构体
		DEBUG_EVENT DbgEvent = { 0 };
		DWORD dwState = DBG_EXCEPTION_NOT_HANDLED;
		// 等待目标Exe产生调试事件
		BOOL bExit = FALSE;
		while (!bExit) {
			WaitForDebugEvent(&DbgEvent, INFINITE);
			if (DbgEvent.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
			{
				// 被调试进程退出
				bExit = TRUE;
			}
			ContinueDebugEvent(DbgEvent.dwProcessId, DbgEvent.dwThreadId, dwState);
		}
		return 0;
	}
	return 0;
}

以调试状态启动自身,等待调试事件触发,通过调试事件Code判断当前是否是调试状态,由于创建了互斥体,所以自身创建的调试进程启动后就退出了,不会出现两个软件同时运行的情况

破解思路: 跳转patch

窗口遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
PROCESSENTRY32 pe32 = { sizeof(pe32) };
HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hProcessSnap == INVALID_HANDLE_VALUE)
{
	return FALSE;
}
Process32First(hProcessSnap, &pe32);
do
{
	// 这里只比较了OllyDbg,也可以添加其他的调试分析工具名
	if (_tcsicmp(pe32.szExeFile, TEXT("OllyDbg.exe")) == 0)
	{
		CloseHandle(hProcessSnap);
		return TRUE;
	}
} while (Process32Next(hProcessSnap, &pe32));
CloseHandle(hProcessSnap);

通过遍历当前所有的窗口列表,以此判断是否有进程名为调试器名字的软件

父进程判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
struct PROCESS_BASIC_INFORMATION
{
	DWORD ExitStatus;
	DWORD PebBaseAddress;
	DWORD AffinityMask;
	DWORD BasePriority;
	ULONG UniqueProcessId;
	ULONG InheritedFromUniqueProcessId;
}pbi = {};
NtQueryInformationProcess(GetCurrentProcess(), ProcessBasicInformation, (PVOID)&pbi, sizeof(pbi), NULL);
PROCESSENTRY32 pe32 = { sizeof(pe32) };
HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hProcessSnap == INVALID_HANDLE_VALUE)
{
	return FALSE;
}
Process32First(hProcessSnap, &pe32);
do
{
	if (pbi.InheritedFromUniqueProcessId == pe32.th32ProcessID)
	{
		if (_tcsicmp(pe32.szExeFile, TEXT("explorer.exe")) == 0)
		{
			CloseHandle(hProcessSnap);
			return FALSE;
		}
		else
		{
			CloseHandle(hProcessSnap);
			return TRUE;
		}
	}
} while (Process32Next(hProcessSnap, &pe32));
CloseHandle(hProcessSnap);
return FALSE;

NtQueryInformationProcess这个函数是未被公开的一个函数,在ntdll中,可以通过getprocaddress来调用,函数原型:

1
2
3
4
5
6
7
NTSTATUS WINAPI NtQueryInformationProcess(
  _In_      HANDLE           ProcessHandle,
  _In_      PROCESSINFOCLASS ProcessInformationClass,
  _Out_     PVOID            ProcessInformation,
  _In_      ULONG            ProcessInformationLength,
  _Out_opt_ PULONG           ReturnLength
);

ProcessHandle:查询进程的句柄

ProcessInformationClass: 查找信息的标识符,可以取以下值:

1
2
3
4
5
ProcessBasicInformation   0
ProcessDebugPort          7 
ProcessWow64Information      26
ProcessImageFileName            27
ProcessBreakOnTermination   29

ProcessInformation：要存放查询结果的缓冲区，这个结构要根据第二个参数来决定，
ProcessInformationLength：缓冲区大小

ReturnLength：实际返回的写入缓冲区的字节数

当调用此函数,传入当前进程的句柄,参数2传入ProcessBasicInfomation,在参数3 就会返回PROCESS_BASIC_INFORMATION这个结构体,文中有定义,这个结构体中就包含了父进程的句柄,在通过遍历的方式判断父进程的名字是不是explorer即可

FindWindow

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

bool CheckDebug_FindWindow() {
	// OD的主窗口类名为 OLLYDBG，也可以查询其他调试器的类名
	// 其他常用调试器的类名可以使用Spy++查看
	if (FindWindow(TEXT("OLLYDBG"), NULL))
		return true;
	return false;
}
BOOL CALLBACK EnumWindowProc(HWND hWnd, LPARAM lParam) {
	TCHAR winTitle[0x100] = {};
	GetWindowText(hWnd, winTitle, 0x100);
	if (_tcsstr(winTitle, TEXT("OllyDbg")))
	{
		// nFind=true
		*((int*)lParam) = true;
		// 找到目标窗口停止遍历
		return false;
	}
	// 继续遍历下一个窗口
	return true;
}
bool CheckDebug_EnumWindow() {
	int nFind = false;
	EnumWindows(EnumWindowProc, (LPARAM)&nFind);
	return nFind != 0;
}

这个和之前的窗口遍历差不多,不过实现方式不同

硬件断点 & 异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

// API查询
bool CheckDebug_HB()
{
	CONTEXT context;
	HANDLE hThread = GetCurrentThread();
	context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
	GetThreadContext(hThread, &context);
	if (context.Dr0 != 0 || context.Dr1 != 0 || context.Dr2 != 0 || context.Dr3 != 0)
	{
		return TRUE;
	}
	return FALSE;
}
// 触发异常查询
bool CheckDebug_HB_EXCEPTION()
{
	BOOL bDebugging = FALSE;
	__asm {
		// install SEH
		push handler
		push DWORD ptr fs : [0]
		mov DWORD ptr fs : [0], esp
		__emit(0xcc)
		mov bDebugging, 1
		jmp normal_code
handler :
		mov eax, dword ptr ss : [esp + 0xc];// ContextRecord
		mov dword ptr ds : [eax + 0xb8], offset normal_code;
		mov ecx, [eax + 4];	// Dr0
		or ecx, [eax + 8];	// Dr1
		or ecx, [eax + 0x0C];// Dr2
		or ecx, [eax + 0x10];// Dr3
		je NoDebugger;
		mov ecx, [eax + 0xb4];// ebp
		// vs2015 debug下bDebugging的地址为ebp-c
		mov [ecx-0x0c],1 // bDebugging
	NoDebugger:
		xor eax, eax
		retn
normal_code :
		//   remove SEH
		pop dword ptr fs : [0]
		add esp, 4
	}
	return bDebugging;
}

CheckDebug_HB函数,通过判断是否有硬件断点,如果有则为调试状态

CheckDebug_HB_EXCEPTION函数,设置SEH异常处理函数后触发异常,如果未在调试状态,则会走到自己的函数中,否则在调试状态下

INT 2D

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

bool CheckDebug_INT_2D() {
	BOOL bDebugging = FALSE;
	__asm {
		// install SEH
		push handler
		push DWORD ptr fs : [0]
		mov DWORD ptr fs : [0], esp
		// OD会忽略0x2d和nop，继续向后执行
		// 这时候可以选择只是检测调试器还是跑飞
		int 0x2d
		nop
		mov bDebugging, 1
		jmp normal_code
handler :
		mov eax, dword ptr ss : [esp + 0xc]
		mov dword ptr ds : [eax + 0xb8], offset normal_code
		mov bDebugging, 0
		xor eax, eax
		retn
normal_code :
		//   remove SEH
		pop dword ptr fs : [0]
		add esp, 4
	}
	return bDebugging;
}

此方法和CheckDebug_HB_EXCEPTION差不多,只不过触发异常的方式不同

NtGlobalFlag

1
2
3
4
5
6
7
int nNtFlag = 0;
__asm {
	MOV EAX, DWORD PTR FS : [0x30]
	MOV EAX, DWORD PTR DS : [EAX + 0x68]
	MOV nNtFlag, EAX
}
return nNtFlag==0x70;

在32位机器上, NtGlobalFlag字段位于PEB(进程环境块)0x68的偏移处, 64位机器则是在偏移0xBC位置. 该字段的默认值为0. 当调试器正在运行时, 该字段会被设置为一个特定的值:

1
2
3
FLG_HEAP_ENABLE_TAIL_CHECK (0x10)
FLG_HEAP_ENABLE_FREE_CHECK (0x20)
FLG_HEAP_VALIDATE_PARAMETERS (0x40)

可以通过内存访问断点来定位反调试代码

或者修改注册表,来替换GlobalFlag的值:

注册表HKLM\System\CurrentControlSet\Control\SessionManager的GlobalFlag的值会替换进行NtGlobalFlag字段. 尽管它随后还可能由Windows改变(以下会介绍), 注册表键值会对系统中所有进程产生影响并在重启后生效.

NtQueryInformationProcess的另外三种调试判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

bool CheckDebug_DebugPort() {
	DWORD dwDebugPort = 0;
	NtQueryInformationProcess(GetCurrentProcess(), ProcessDebugPort, &dwDebugPort, 4, 0);
	return dwDebugPort == -1;
}

bool CheckDebug_DebugHandle() {
	DWORD dwDebugHandle = 0;
	NtQueryInformationProcess(GetCurrentProcess(), (PROCESSINFOCLASS)0x1E, &dwDebugHandle, 4, 0);
	return dwDebugHandle != 0;
}

// 此方法win7下已失效
bool CheckDebug_DebugFlags() {
	bool bDebugFlags = 0;
	NtQueryInformationProcess(GetCurrentProcess(), (PROCESSINFOCLASS)0x1F, &bDebugFlags, 1, 0);
	printf("%d\n", bDebugFlags);
	return bDebugFlags == 0;
}

参数二 = ProcessDebugPort

非调试状态下debugport == 0

参数二 = ProcessDebugObjectHandle

第三个参数返回为被调试对象句柄，当返回NULL时说明进程处于非调试状态

参数二 = ProcessDebugFlags

rocessDebugFlags参数用于获取调试标识，DebugFlag的值若为0则处于调试状态，若为1则处于非调试状态

NtQueryObject

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
bool CheckDebug_QueryObject() {
	typedef struct _OBJECT_TYPE_INFORMATION
	{
		UNICODE_STRING TypeNames;
		ULONG TotalNumberOfHandles;
		ULONG TotalNumberOfObjects;
	}OBJECT_TYPE_INFORMATION, *POBJECT_TYPE_INFORMATION;
	typedef struct _OBJECT_ALL_INFORMATION
	{
		ULONG NumberOfObjectsTypes;
		OBJECT_TYPE_INFORMATION ObjectTypeInfo[1];
	}OBJECT_ALL_INFORMATION, *POBJECT_ALL_INFORMATION;
	//1.获取欲查询信息大小
	ULONG uSize = 0;
	NtQueryObject(NULL, (OBJECT_INFORMATION_CLASS)0x03, &uSize, sizeof(uSize), &uSize);
	//2.获取对象大信息
	POBJECT_ALL_INFORMATION pObjectAllInfo = (POBJECT_ALL_INFORMATION) new BYTE[uSize+4];
	NtQueryObject(NULL, (OBJECT_INFORMATION_CLASS)0x03, pObjectAllInfo, uSize, &uSize);
	//3.循环遍历并处理对象信息
	POBJECT_TYPE_INFORMATION pObjectTypeInfo = pObjectAllInfo->ObjectTypeInfo;
	for (int i = 0; i < pObjectAllInfo->NumberOfObjectsTypes; i++)
	{
		//3.1查看此对象的类型是否为DebugObject
		if (!wcscmp(L"DebugObject", pObjectTypeInfo->TypeNames.Buffer))
		{
			delete[] pObjectAllInfo;
			return true;
		}
		//3.2获取对象名占用空间大小(考虑到了结构体对齐问题)
		ULONG uNameLength = pObjectTypeInfo->TypeNames.Length;
		ULONG uDataLength = uNameLength - uNameLength % sizeof(ULONG) + sizeof(ULONG);
		//3.3指向下一个对象信息
		pObjectTypeInfo = (POBJECT_TYPE_INFORMATION)pObjectTypeInfo->TypeNames.Buffer;
		pObjectTypeInfo = (POBJECT_TYPE_INFORMATION)((PBYTE)pObjectTypeInfo + uDataLength);
	}
	delete[] pObjectAllInfo;
	return false;
}

系统中某个调试器调试进程时，会创建一个调试对象类型的内核对象。检测该对象是否存在即可判断是否有进程正在被调试

ntdll!NtQueryObject可获得系统各种内核对象信息

1
2
3
4
5
6
7
NTSTATUS NtQueryObject(
  _In_opt_  HANDLE                   Handle,
  _In_      OBJECT_INFORMATION_CLASS ObjectInformationClass,
  _Out_opt_ PVOID                    ObjectInformation,
  _In_      ULONG                    ObjectInformationLength,
  _Out_opt_ PULONG                   ReturnLength
);

该API与上面讲过的API使用方法类似

1
2
3
4
5
6
7
typedef enum _OBJECT_INFORMATION_CLASS { 
  ObjectBasicInformation,
  ObjectTypeInformation,
  ObjectNameInformation,
  ObjectAllInformation, //3
  ObjectHandleInformation
} OBJECT_INFORMATION_CLASS;

ObjectAllInformation(0x3)

使用ObjectAllInformation可获得系统所有对象信息，然后从中检测是否存在调试对象

NtQuerySystemInformation

1
2
3
4
5
6
7
8
9
10
11
12
13
14

bool CheckDebug_KernelDebug() {
	struct _SYSTEM_KERNEL_DEBUGGER_INFORMATION
	{
		BOOLEAN DebuggerEnabled;
		BOOLEAN DebuggerNotPresent;
	}DebuggerInfo = { 0 };
	NtQuerySystemInformation(
		(SYSTEM_INFORMATION_CLASS)0x23,		//查询信息类型
		&DebuggerInfo,						//输出查询信息
		sizeof(DebuggerInfo),				//查询类型大小
		NULL);								//实际返回数据大小
	return DebuggerInfo.DebuggerEnabled;
}

NtQuerySystemInformation这个函数用来获取当前的运行信息

当调用NtQuerySystemInfromation()API的时候，第一个参数SystemInformationClass的值被设置为systemKernelDebuggerInfromation(0x32的时候，函数调用返回的时候，若系统处于调试状态下，DebuggerEnable的值设置为1

ss寄存器

1
2
3
4
5
6
7
__asm
{
    push ss
    pop  ss
    mov  eax, 0xC000C1EE // This line will be traced over by debugger
    xor  edx, edx        // Debugger will step to this line
}

当使用ss堆栈段寄存器进行操作时，调试器将跳过指令跟踪。如下图所示，调试器将立即移至xor edx，edx指令，同时执行上一条指令

代码运行时长

1
2
3
4
5
6
7
8
bool CheckDebug_QueryPerformanceCounter() {
	LARGE_INTEGER startTime , endTime ;
	QueryPerformanceCounter(&startTime);
	printf("我是核心代码\n也可以是核心代码前的反调试时间检测代码\n");
	QueryPerformanceCounter(&endTime);
	printf("%llx\n", endTime.QuadPart - startTime.QuadPart);
	return endTime.QuadPart - startTime.QuadPart > 0x500;
}

代码运行时长检测不止这一种方法,像GetTickCount等函数都可以实现

rdtsc指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
bool CheckDebug_RDTSC() {
	int64_t t1=0, t2=0;
	int lo=0, hi=0;
	__asm {
		rdtsc
		mov [lo], eax
		mov [hi], edx
	}
	t1 = ((int64_t)lo) | ((int64_t)hi << 32);
	__asm{
		rdtsc
		mov[lo], eax
		mov[hi], edx
	}
	t2 = ((int64_t)lo) | ((int64_t)hi << 32);
	printf("t2-t1=%llx\n", t2 - t1);
	// 不同的CPU该差值不同，所以谨慎使用这种反调试方法
	return t2 - t1 > 0x100;
}

此方法与代码运行时长类似

注册表查找调试器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
bool CheckDebug_Registry() {
	// 判断当前系统是32还是64位
	BOOL b64 = FALSE;
	IsWow64Process(GetCurrentProcess(), &b64);
	HKEY hkey = NULL;
	TCHAR *reg = b64 ?
		TEXT("SOFTWARE\\Wow6432Node\\Microsoft\\WindowsNT\\CurrentVersion\\AeDebug")
		: TEXT("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug");
	// 打开注册表键
	DWORD ret = RegCreateKey(HKEY_LOCAL_MACHINE, reg, &hkey);
	if (ret != ERROR_SUCCESS) return FALSE;
	TCHAR *subkey = TEXT("Debugger");
	TCHAR value[256] = {};
	DWORD len = 256;
	// 查询对应项的值
	ret = RegQueryValueEx(hkey, subkey, NULL,NULL,(LPBYTE)value, &len);
	RegCloseKey(hkey);
	// 这里只查找了OD，也可以同时查找WinDbg,x64Dbg等常用调试器
	if (_tcsstr(value, TEXT("OLLYDBG")) != NULL)
		return TRUE;
	return FALSE;
}

通过注册表查询是否包含调试器

rep指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
bool CheckDebug_CheckRepCC()
{
	BOOL bDebugging = FALSE;
	__asm {
		xor eax,eax
		xor ecx,ecx
		inc ecx
		lea esi,key
		// 此处步过时key处会被下0xCC断点
		// 将key处的首字节给AL
		rep lodsb
key:
		cmp al,0xcc
		je debuging
		jmp over
debuging:
		mov bDebugging,1
over :
	}
	return bDebugging;
}

执行到rep指令时,key处地址会被下断,从而与0xCC判断,是否处于调试状态

权限判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

bool CheckDebug_SeDebugPrivilege() {
	// 获取CsrGetProcessId函数地址
	HMODULE hMod = GetModuleHandle(L"ntdll.dll");
	typedef int(*CSRGETPROCESSID)();
	CSRGETPROCESSID CsrGetProcessId = (CSRGETPROCESSID)GetProcAddress(hMod, "CsrGetProcessId");
	// 获取csrss.exe的PID
	DWORD pid = CsrGetProcessId();
	// 打开成功说明管理员+调试权限
	HANDLE hCsr = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
	if (!hCsr)
	{
		return false;
	}
	CloseHandle(hCsr);
	return true;
}


BOOL CheckDebug_EnumProcess_Csrss()
{
	DWORD pid=0;
	DWORD ret = 0;
	PROCESSENTRY32 pe32;
	pe32.dwSize = sizeof(pe32);
	HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	if (hProcessSnap == INVALID_HANDLE_VALUE)
	{
		return FALSE;
	}
	Process32First(hProcessSnap, &pe32);
	do
	{
		if (wcscmp(pe32.szExeFile, L"csrss.exe") == 0)
		{
			pid = pe32.th32ProcessID;
			break;
		}
	} while (Process32Next(hProcessSnap, &pe32));
	CloseHandle(hProcessSnap);
	HANDLE hCss = OpenProcess(PROCESS_QUERY_INFORMATION, NULL, pid);
	if (!hCss)
	{
		return FALSE;
	}
	CloseHandle(hCss);
	return FALSE;
}

上述两个函数的实现不同,但作用是相同的,通过当前权限来判断是否处于调试状态

SEH异常1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
bool CheckDebug_SEH() {
	BOOL bDebugging = FALSE;
	__asm {
		// install SEH
		push handler
		push DWORD ptr fs : [0]
		mov DWORD ptr fs : [0], esp
		__emit(0xcc)
		// 只检测有无调试器
		// 若把mov bDebugging, 1改成__emit(0xE9)
		// 在调试器中就会跑飞
		mov bDebugging, 1
		jmp normal_code
handler :
		mov eax, dword ptr ss : [esp + 0xc];// ContextRecord
		mov dword ptr ds : [eax + 0xb8], offset normal_code
		xor eax, eax
		retn
normal_code :
		//   remove SEH
		pop dword ptr fs : [0]
		add esp, 4
	}
	return bDebugging;
}

如果不在调试器中,则会走到代码中设置的的seh handler,否则将会继续执行

SEH异常2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
LONG WINAPI Fun(
	_In_ struct _EXCEPTION_POINTERS *ExceptionInfo
) {
	// 跳过mov bDebug, 1这条指令
	// int 3异常时，eip会被回拨到cc处，所以要+5
	ExceptionInfo->ContextRecord->Eip += 5;
	return EXCEPTION_CONTINUE_EXECUTION;
}
bool CheckDebug_SetUnhandledExceptionFilter() {
	bool bDebug = false;
	__asm {
		__emit(0xCC);
		// 正常运行时，Fun函数会跳过这条指令
		// 调试时，调试器会不停收到int 3异常，程序崩溃
		mov bDebug, 1
	}
	return bDebug;
}

在调用CheckDebug_SetUnhandledExceptionFilter之前要先调用SetUnhandledExceptionFilter将Fun设置为SEH的handler,此方法与SEH异常处理1相似

单步检测

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
bool CheckDebug_SingleStep()
{
	bool bDebugged = false;
	__asm {
		// install SEH
		push handler
		push DWORD ptr fs : [0]
		mov DWORD ptr fs : [0], esp
		pushfd
		or dword ptr ss : [esp], 0x100
		popfd
		// 被调试就继续执行
		nop
		mov bDebugged,1
		jmp normal_code
handler :
		mov bDebugged, 1
		mov eax, dword ptr ss : [esp + 0xc]
		mov ebx, normal_code
		mov dword ptr ds : [eax + 0xb8], ebx
		xor eax, eax
		retn
normal_code :
		//   remove SEH
		pop dword ptr fs : [0]
		add esp, 4
	}
	return bDebugged;
}

TF=1 的时候，会触发单步异常。该方法属于异常处理，不过比较特殊：未修改的 OD 无论
是 F9 还是 F8 都不能处理异常，有插件的 OD 在 F9 时能正确处理，F8 时不能正确处理。

StartInfo检测

1
2
3
4
5
6
7
8
9
10
bool CheckDebug_STARTUPINFO() {
	STARTUPINFO si = {};
	GetStartupInfo(&si);
	if (si.dwX || si.dwY || si.dwXSize || si.dwYSize)
	{
		printf("%x %x %x %x\n", si.dwX, si.dwY, si.dwXSize, si.dwYSize);
		return true;
	}
	return false;
}

ZwSetInformationThread

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
bool CheckDebug_SetInformationThread() {
	enum THREAD_INFO_CLASS
	{
		ThreadHideFromDebugger = 17
	};
	typedef NTSTATUS(NTAPI *ZW_SET_INFORMATION_THREAD)(
		IN HANDLE ThreadHandle,
		IN THREAD_INFO_CLASS ThreadInformationClass,
		IN PVOID ThreadInformation,
		IN ULONG ThreadInformationLength);
	ZW_SET_INFORMATION_THREAD ZwSetInformationThread;
	ZwSetInformationThread = (ZW_SET_INFORMATION_THREAD)GetProcAddress(LoadLibrary(L"ntdll.dll"), "ZwSetInformationThread");
	ZwSetInformationThread(GetCurrentThread(), ThreadHideFromDebugger, NULL, NULL);
	return true;
}bool CheckDebug_STARTUPINFO() {
	STARTUPINFO si = {};
	GetStartupInfo(&si);
	if (si.dwX || si.dwY || si.dwXSize || si.dwYSize)
	{
		printf("%x %x %x %x\n", si.dwX, si.dwY, si.dwXSize, si.dwYSize);
		return true;
	}
	return false;
}

ZwSetInformationThread是一个未公开的函数,该API被调试者可将自身从调试器中分离出来（使调试进程终止运行，同时终止自身进程），该API不会对正常运行的程序(非调试运行)产生任何影响

TLS反调试

TLS相关知识:https://bbs.pediy.com/thread-249572.htm

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
#include "stdafx.h"
#include <Windows.h>
#include <iostream>
#include <iomanip>
using namespace std;

#pragma comment(linker, "/INCLUDE:__tls_used")
void lookupprocess(void);
void Debugger(void);
void NTAPI tls_callback(PVOID h, DWORD reason, PVOID pv)
{
        lookupprocess();
        Debugger();
        MessageBox(NULL,"Not Main!","Test1",MB_OK);
        return;
}
//创建TLS段
#pragma data_seg(".CRT$XLT")
//定义回调函数
PIMAGE_TLS_CALLBACK p_thread_callback = tls_callback;
#pragma data_seg()

// 定义静态TLS全局变量
__declspec(thread) int value =0xcccccccc;

DWORD WINAPI NewThread ( LPVOID lParam )
{
    // 设置子线程value，并不影响其他线程
    value = *((int*)lParam);

        while(1)
        {
                printf("%d\n",value);
                Sleep(1000);
        }

    return 0 ;
}

#define THREAD_NUM 3

int main(int argc, char* argv[])
{
        int arry[3]={1,2,3};
    // 设置主线程静态TLS的value为5
    value = 5 ;
    // 创建子线程
    HANDLE hThread[THREAD_NUM];

    for (int loop = 0; loop < THREAD_NUM; loop++)
    {
        hThread[loop] = CreateThread ( NULL, 0, NewThread, &arry[loop], 0, NULL );
                Sleep(20000);
    }

    // 等待直到子线程结束
    WaitForMultipleObjects(THREAD_NUM, hThread, TRUE, INFINITE);

    return 0;
}

void lookupprocess()
{
        PROCESSENTRY32 pe32;
        pe32.dwSize = sizeof(pe32);
        HANDLE hProcessSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
        BOOL bMore = ::Process32First(hProcessSnap,&pe32);
        while(bMore)
        {
                strlwr(pe32.szExeFile);
                if (!strcmp(pe32.szExeFile,"ollyice.exe"))
                {
                        exit(0);
                }
                if (!strcmp(pe32.szExeFile,"ollydbg.exe"))
                {
                        exit(0);
                }
                if (!strcmp(pe32.szExeFile,"peid.exe"))
                {
                        exit(0);
                }
                if (!strcmp(pe32.szExeFile,"idaq.exe"))
                {
                        exit(0);
                }
                bMore = ::Process32Next(hProcessSnap,&pe32);
        }
        ::CloseHandle(hProcessSnap);
}

//anti-debug2
void Debugger(void)
{
        int result=0;
        __asm
        {
                mov     eax, dword ptr fs:[30h]//TEB偏移30H处
                movzx   eax, byte ptr ds:[eax+2h]//取PEB中BeingDebug，若为1则被调试
                mov result,eax
        }
        if (result)
                exit(0);
}
Author: BarretGuy
Link: https://basicbit.cn/2018/11/30/2018-11-30-反调试总结/
Copyright Notice: All articles in this blog are licensed under CC BY-NC-SA 4.0 unless stating additionally.