

Drunkmars's Blog

Drunkmars's Blog

windows环境下的调试器探究



windows环境下的调试器探究

二进制 内核

字数统计: 4.6k阅读时长: 21 min

 2022/04/01   Share

• 
• 
• 
• 
• 

在windows里面触发异常主要通过三种方式：软件断点、内存断点、硬件断点来实现，本文对这三种方式进行原理分析，通过自己构造代码来实现调试器的效果。

软件断点

当在调试器下一个断点，其实就是把这行汇编语句的硬编码改为CC，即int 3

被调试进程

1.CPU检测到INT 3指令
2.查IDT表找到对应的函数
3.CommonDispatchException
4.KiDispatchException
5.DbgkForwardException收集并发送调试事件

首先找到IDT表的3号中断

调用CommonDispatchException

通过KiDispatchException分发异常

首先用KeContextFromframes备份，若为用户调用则跳转

进入函数如果没有内核调试器则跳转，也就是说如果有内核调试器的存在，3环调试器是接收不到异常的

然后调用调试事件

DbgkForwardException主要是通过DbgkpSendApiMessage来发送调试事件，第二个参数决定线程是否挂起，首先通过cmp判断，如果为0则直接跳转，如果不为0则调用DbgkpSuspendProcess将被调试进程挂起

也就是说如果要想调试进程，就必须要调用DbgkpSuspendProcess将调试进程挂起

首先用调试模式创建进程，然后使用调试循环

如果是异常事件则调用ExceptionHandler

ExceptionHandler主要是通过判断ExcptionRecord结构里面的ExceptionCode来判断异常的类型，然后调用相应的函数，这里首先看软件断点，即int 3，调用Int3ExceptionProc

下断点会把之前的指令修改为CC，如果不是系统断点，就把下断点的位置修改的指令写回去，然后获取int3断点的地址

然后获取上下文，所有调试寄存器都存储在ContextFlags里面

当我们下软件断点的时候，EIP并不会停留在断点的地方，而是会停留在断点+1的地方(这里不同的异常EIP停留的位置不同)，所以这里需要进行EIP-1的操作

然后调用处理的函数

当被调试进程收集并发送调试事件之后就会处于阻塞状态，根据异常处理的结果决定下一步的执行

实现代码如下

// Debug4.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdio.h>
#include <windows.h>
#include <tlhelp32.h>

#define DEBUGGEE "C:\\ipmsg.exe"

//被调试进程ID,进程句柄，OEP
DWORD dwDebuggeePID = 0;

//被调试线程句柄
HANDLE hDebuggeeThread = NULL;
HANDLE hDebuggeeProcess = NULL;

//系统断点
BOOL bIsSystemInt3 = TRUE;

//被INT 3覆盖的数据
CHAR OriginalCode = 0;

//线程上下文
CONTEXT Context;

typedef HANDLE (__stdcall *FnOpenThread) (DWORD, BOOL, DWORD);

VOID InitDebuggeeInfo(DWORD dwPID, HANDLE hProcess)
{
	dwDebuggeePID = dwPID;
	hDebuggeeProcess = hProcess;
}

DWORD GetProcessId(LPTSTR lpProcessName)
{
	HANDLE hProcessSnap = NULL;
	PROCESSENTRY32 pe32 = {0};
	
	hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	if(hProcessSnap == (HANDLE)-1)
	{
		return 0;
	}
	
	pe32.dwSize = sizeof(PROCESSENTRY32);
	
	if(Process32First(hProcessSnap, &pe32))
	{
		do 
		{
			if(!strcmp(lpProcessName, pe32.szExeFile))
				return (int)pe32.th32ProcessID;
		} while (Process32Next(hProcessSnap, &pe32));
	}
	else
	{
		CloseHandle(hProcessSnap);
	}
	
	return 0;
}

BOOL WaitForUserCommand()
{
	BOOL bRet = FALSE;
	CHAR command;

	printf("COMMAND > ");

	command = getchar();

	switch(command)
	{
		// into
	case 't':
		bRet = TRUE;
		break;
		// pass
	case 'p':
		bRet = TRUE;
		break;
		// go
	case 'g':
		bRet = TRUE;
		break;
	}

	getchar();
	return bRet;
}

BOOL Int3ExceptionProc(EXCEPTION_DEBUG_INFO *pExceptionInfo)
{
	BOOL bRet = FALSE;

	//1. 将INT 3修复为原来的数据(如果是系统断点，不用修复)
	
	if(bIsSystemInt3)
	{
		bIsSystemInt3 = FALSE;
		return TRUE;
	}

	else
	{
		WriteProcessMemory(hDebuggeeProcess, pExceptionInfo->ExceptionRecord.ExceptionAddress, &OriginalCode, 1, NULL);
	}

	//2. 显示断点位置
	printf("Int 3断点 : 0x%p \r\n", pExceptionInfo->ExceptionRecord.ExceptionAddress);

	//3. 获取线程上下文
	Context.ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS;
	GetThreadContext(hDebuggeeThread, &Context);
	
	//4. 修正EIP
	//printf("Eip : %x\n",Context.Eip);
	Context.Eip--;
	SetThreadContext(hDebuggeeThread, &Context);

	//5. 显示反汇编代码、寄存器等
	
	//6. 等待用户命令
	while(bRet == FALSE)
	{
		bRet = WaitForUserCommand();
	}
	
	return bRet;
}

BOOL AccessExceptionProc(EXCEPTION_DEBUG_INFO *pExceptionInfo)
{
	BOOL bRet = TRUE;

	return bRet;
}

BOOL SingleStepExceptionProc(EXCEPTION_DEBUG_INFO *pExceptionInfo)
{
	BOOL bRet = TRUE;
	
	return bRet;
}

BOOL ExceptionHandler(DEBUG_EVENT *pDebugEvent)
{ 
	BOOL bRet = TRUE;
	EXCEPTION_DEBUG_INFO *pExceptionInfo = NULL;
	pExceptionInfo = &pDebugEvent->u.Exception;

	//得到线程句柄，后面要用
	FnOpenThread MyOpenThread = (FnOpenThread)GetProcAddress(LoadLibrary("kernel32.dll"), "OpenThread");
	hDebuggeeThread = MyOpenThread(THREAD_ALL_ACCESS, FALSE, pDebugEvent->dwThreadId);

	switch(pExceptionInfo->ExceptionRecord.ExceptionCode)
	{
	//INT 3异常
		case EXCEPTION_BREAKPOINT:
			bRet = Int3ExceptionProc(pExceptionInfo);
			break;

	//访问异常
		case EXCEPTION_ACCESS_VIOLATION:
			bRet = AccessExceptionProc(pExceptionInfo);
			break;

	//单步执行
		case EXCEPTION_SINGLE_STEP:
			bRet = SingleStepExceptionProc(pExceptionInfo);
			break;
	}

	return bRet;
}

void SetInt3BreakPoint(LPVOID addr)
{
	ReadProcessMemory(hDebuggeeProcess, addr, &OriginalCode, 1, NULL);
	
	BYTE int3[1] = { 0xcc };

	WriteProcessMemory(hDebuggeeProcess, addr, int3, 1, NULL);
}

BOOL ExceptionTest()
{
	BOOL nIsContinue = TRUE;
	DEBUG_EVENT debugEvent = {0};
	BOOL bRet = TRUE;
	DWORD dwContinue = DBG_CONTINUE;

	//1.创建调试进程
	STARTUPINFO startupInfo = {0};
	PROCESS_INFORMATION pInfo = {0};
	GetStartupInfo(&startupInfo);

	bRet = CreateProcess(DEBUGGEE, NULL, NULL, NULL, TRUE, DEBUG_PROCESS || DEBUG_ONLY_THIS_PROCESS, NULL, NULL, &startupInfo, &pInfo);
	
	if(!bRet)
	{
		printf("CreateProcess error: %d \n", GetLastError());
		return 0;
	}

	hDebuggeeProcess = pInfo.hProcess;

	//2.调试循环
	while(nIsContinue)
	{
		bRet = WaitForDebugEvent(&debugEvent, INFINITE);
		
		if(!bRet)
		{
			printf("WaitForDebugEvent error: %d \n", GetLastError());
			return 0;
		}

		switch(debugEvent.dwDebugEventCode)
		{
		//1.异常
		case EXCEPTION_DEBUG_EVENT:
			bRet = ExceptionHandler(&debugEvent);
			if(!bRet)
				dwContinue = DBG_EXCEPTION_NOT_HANDLED;
			break;
		//2.
		case CREATE_THREAD_DEBUG_EVENT:
			break;
		//3.创建进程
		case CREATE_PROCESS_DEBUG_EVENT:
			SetInt3BreakPoint((PCHAR)debugEvent.u.CreateProcessInfo.lpStartAddress);
			break;
		//4.
		case EXIT_THREAD_DEBUG_EVENT:
			break;
		//5.
		case EXIT_PROCESS_DEBUG_EVENT:
			break;
		//6.
		case LOAD_DLL_DEBUG_EVENT:
			break;
		//7.
		case UNLOAD_DLL_DEBUG_EVENT:
			break;
		//8.
		case OUTPUT_DEBUG_STRING_EVENT:
			break;
		}
		
		bRet = ContinueDebugEvent(debugEvent.dwProcessId, debugEvent.dwThreadId, DBG_CONTINUE);
	}

	return 0;
}

int main(int argc, char* argv[])
{
	ExceptionTest();

	return 0;
}

实现效果

内存断点

描述：当需要在某块内存被访问时产生中断，可以使用内存断点。

内存断点能够分为两种类型：

内存访问：内存被读写时产生中断
内存写入：内存被写入时产生中断

原理：VirtualProtectEx

BOOL VirtualProtectEx(
	HANDLE hProcess,        // handle to process
	LPVOID lpAddress,       // region of committed pages
	SIZE_T dwSize,          // size of region
	DWORD flNewProtect,     // desired access protection
	PDWORD lpflOldProtect   // old protection
);

flNewProtect

内存访问：将指定内存的属性修改为PAGE_NOACCESS（修改后，PTE的P位等于0）
内存写入：将指定内存的属性修改为PAGE_EXECUTE_READ（修改后，PTE的P位等于1，R/W位等于0）

流程

被调试进程：

1）CPU访问错误的内存地址，触发页异常
2）查IDT表找到对应的中断处理函数（nt!_KiTrap0E）
3）CommonDispatchException
4）KiDispatchException
5）DbgkForwardException收集并发送调试事件

最终调用DbgkpSendApiMessage(x, x)，第一个参数：消息类型，共有7种类型，第二个参数：是否挂起其它线程

调试器进程：

1）循环判断
2）取出调试事件
3）列出消息（寄存器/内存）
4）用户处理

在创建进程的地方使用内存断点

通过修改PTE的P=0来设置页不可访问

我们首先看一下EXCEPTION_DEBUG_INFO结构

然后再看ExceptionRecord

定位到_EXCEPTION_RECORD

到msdn里面看一下EXCEPTION_RECORD，这里主要关注ExceptionInformation

如果这个值为0有线程试图读这块内存，如果这个值为1则有线程试图写这块内存

这里显示出异常的信息，打印异常类型和异常地址

内存断点的EIP就是原EIP，不需要进行减的操作

实现代码如下

// Debug4.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdio.h>
#include <windows.h>
#include <tlhelp32.h>

#define DEBUGGEE "C:\\ipmsg.exe"

//被调试进程ID,进程句柄，OEP
DWORD dwDebuggeePID = 0;

//被调试线程句柄
HANDLE hDebuggeeThread = NULL;
HANDLE hDebuggeeProcess = NULL;

//系统断点
BOOL bIsSystemInt3 = TRUE;

//被INT 3覆盖的数据
CHAR OriginalCode = 0;

//原始内存属性
DWORD dwOriginalProtect;

//线程上下文
CONTEXT Context;

typedef HANDLE (__stdcall *FnOpenThread) (DWORD, BOOL, DWORD);

VOID InitDebuggeeInfo(DWORD dwPID, HANDLE hProcess)
{
	dwDebuggeePID = dwPID;
	hDebuggeeProcess = hProcess;
}

DWORD GetProcessId(LPTSTR lpProcessName)
{
	HANDLE hProcessSnap = NULL;
	PROCESSENTRY32 pe32 = {0};
	
	hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	if(hProcessSnap == (HANDLE)-1)
	{
		return 0;
	}
	
	pe32.dwSize = sizeof(PROCESSENTRY32);
	
	if(Process32First(hProcessSnap, &pe32))
	{
		do 
		{
			if(!strcmp(lpProcessName, pe32.szExeFile))
				return (int)pe32.th32ProcessID;
		} while (Process32Next(hProcessSnap, &pe32));
	}
	else
	{
		CloseHandle(hProcessSnap);
	}
	
	return 0;
}

BOOL WaitForUserCommand()
{
	BOOL bRet = FALSE;
	CHAR command;

	printf("COMMAND>");

	command = getchar();

	switch(command)
	{
	case 't':
		bRet = TRUE;
		break;
	case 'p':
		bRet = TRUE;
		break;
	case 'g':
		bRet = TRUE;
		break;
	}

	getchar();
	return bRet;
}

BOOL Int3ExceptionProc(EXCEPTION_DEBUG_INFO *pExceptionInfo)
{
	BOOL bRet = FALSE;

	//1. 将INT 3修复为原来的数据（如果是系统断点，不用修复）
	if(bIsSystemInt3)
	{
		bIsSystemInt3 = FALSE;
		return TRUE;
	}
	else
	{
		WriteProcessMemory(hDebuggeeProcess, pExceptionInfo->ExceptionRecord.ExceptionAddress, &OriginalCode, 1, NULL);
	}

	//2. 显示断点位置
	printf("Int 3断点 : 0x%p \r\n", pExceptionInfo->ExceptionRecord.ExceptionAddress);

	//3. 获取线程上下文
	Context.ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS;
	GetThreadContext(hDebuggeeThread, &Context);
	
	//4. 修正EIP
	Context.Eip--;
	SetThreadContext(hDebuggeeThread, &Context);

	//5. 显示反汇编代码、寄存器等
	
	//6. 等待用户命令
	while(bRet == FALSE)
	{
		bRet = WaitForUserCommand();
	}
	
	return bRet;
}

BOOL AccessExceptionProc(EXCEPTION_DEBUG_INFO *pExceptionInfo)
{
	BOOL bRet = FALSE;
	DWORD dwAccessFlag;		//访问类型 0为读 1为写
	DWORD dwAccessAddr;		//访问地址
	DWORD dwProtect;		//内存属性

	//1. 获取异常信息，修改内存属性
	dwAccessFlag = pExceptionInfo->ExceptionRecord.ExceptionInformation[0];
	dwAccessAddr = pExceptionInfo->ExceptionRecord.ExceptionInformation[1];
	printf("内存断点 : dwAccessFlag - %x dwAccessAddr - %x \n", dwAccessFlag, dwAccessAddr);
	VirtualProtectEx(hDebuggeeProcess, (VOID*)dwAccessAddr, 1, dwOriginalProtect, &dwProtect);
	
	//2. 获取线程上下文
	Context.ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS;
	GetThreadContext(hDebuggeeThread, &Context);
	//3. 修正EIP(内存访问异常，不需要修正EIP)
	printf("Eip: 0x%p \n", Context.Eip);
	//4. 显示汇编/寄存器等信息
	//5. 等待用户命令
	while(bRet == FALSE)
	{
		bRet = WaitForUserCommand();
	}

	return bRet;
}

BOOL SingleStepExceptionProc(EXCEPTION_DEBUG_INFO *pExceptionInfo)
{
	BOOL bRet = TRUE;
	
	return bRet;
}

BOOL ExceptionHandler(DEBUG_EVENT *pDebugEvent)
{ 
	BOOL bRet = TRUE;
	EXCEPTION_DEBUG_INFO *pExceptionInfo = NULL;

	pExceptionInfo = &pDebugEvent->u.Exception;

	//得到线程句柄，后面要用
	FnOpenThread MyOpenThread = (FnOpenThread)GetProcAddress(LoadLibrary("kernel32.dll"), "OpenThread");
	hDebuggeeThread = MyOpenThread(THREAD_ALL_ACCESS, FALSE, pDebugEvent->dwThreadId);

	switch(pExceptionInfo->ExceptionRecord.ExceptionCode)
	{
	//INT 3异常
	case EXCEPTION_BREAKPOINT:
		{
			bRet = Int3ExceptionProc(pExceptionInfo);
			break;
		}
	//访问异常
	case EXCEPTION_ACCESS_VIOLATION:
		bRet = AccessExceptionProc(pExceptionInfo);
		break;
	//单步执行
	case EXCEPTION_SINGLE_STEP:
		bRet = SingleStepExceptionProc(pExceptionInfo);
		break;
	}

	return bRet;
}

VOID SetInt3BreakPoint(LPVOID addr)
{
	CHAR int3 = 0xCC;
	
	//1. 备份
	ReadProcessMemory(hDebuggeeProcess, addr, &OriginalCode, 1, NULL);
	//2. 修改
	WriteProcessMemory(hDebuggeeProcess, addr, &int3, 1, NULL);
}

VOID SetMemBreakPoint(PCHAR pAddress)
{
	//1. 访问断点
	VirtualProtectEx(hDebuggeeProcess, pAddress, 1, PAGE_NOACCESS, &dwOriginalProtect);	//PTE P=0
	//2. 写入断点
	//VirtualProtectEx(hDebuggeeProcess, pAddress, 1, PAGE_EXECUTE_READ, &dwOriginalProtect);	//PTE R/W=0
}

int main(int argc, char* argv[])
{
	BOOL nIsContinue = TRUE;
	DEBUG_EVENT debugEvent = {0};
	BOOL bRet = TRUE;
	DWORD dwContinue = DBG_CONTINUE;

	//1.创建调试进程
	STARTUPINFO startupInfo = {0};
	PROCESS_INFORMATION pInfo = {0};
	GetStartupInfo(&startupInfo);

	bRet = CreateProcess(DEBUGGEE, NULL, NULL, NULL, TRUE, DEBUG_PROCESS || DEBUG_ONLY_THIS_PROCESS, NULL, NULL, &startupInfo, &pInfo);
	if(!bRet)
	{
		printf("CreateProcess error: %d \n", GetLastError());
		return 0;
	}

	hDebuggeeProcess = pInfo.hProcess;

	//2.调试循环
	while(nIsContinue)
	{
		bRet = WaitForDebugEvent(&debugEvent, INFINITE);
		if(!bRet)
		{
			printf("WaitForDebugEvent error: %d \n", GetLastError());
			return 0;
		}

		switch(debugEvent.dwDebugEventCode)
		{
		//1.异常
		case EXCEPTION_DEBUG_EVENT:
			bRet = ExceptionHandler(&debugEvent);
			if(!bRet)
				dwContinue = DBG_EXCEPTION_NOT_HANDLED;
			break;
		//2.
		case CREATE_THREAD_DEBUG_EVENT:
			break;
		//3.创建进程
		case CREATE_PROCESS_DEBUG_EVENT:
			//int3 断点
			//SetInt3BreakPoint((PCHAR)debugEvent.u.CreateProcessInfo.lpStartAddress);
			//内存断点
			SetMemBreakPoint((PCHAR)debugEvent.u.CreateProcessInfo.lpStartAddress);
			break;
		//4.
		case EXIT_THREAD_DEBUG_EVENT:
			break;
		//5.
		case EXIT_PROCESS_DEBUG_EVENT:
			break;
		//6.
		case LOAD_DLL_DEBUG_EVENT:
			break;
		//7.
		case UNLOAD_DLL_DEBUG_EVENT:
			break;
		//8.
		case OUTPUT_DEBUG_STRING_EVENT:
			break;
		}
		
		bRet = ContinueDebugEvent(debugEvent.dwProcessId, debugEvent.dwThreadId, DBG_CONTINUE);
	}
	
	return 0;
}

实现效果如下

硬件断点

1. 与软件断点与内存断点不同，硬件断点不依赖被调试程序，而是依赖于CPU中的调试寄存器。
2. 调试寄存器有7个，分别为Dr0~Dr7。
3. 用户最多能够设置4个硬件断点，这是由于只有Dr0~Dr3用于存储线性地址。
4. 其中，Dr4和Dr5是保留的。

假如在Dr0寄存器中写入线性地址，是否所有线程都会受影响？其实不会，每个线程都拥有一份独立的寄存器，切换线程时，寄存器的值也会被切换。

设置硬件断点

Dr0~Dr3用于设置硬件断点，由于只有4个断点寄存器，所以最多只能设置4个硬件调试断点。在7个寄存器里面，Dr7是最重要的寄存器

L0/G0 ~ L3/G3：控制Dr0~Dr3是否有效，局部还是全局；每次异常后，Lx都被清零，Gx不清零。

若Dr0有效，L0=1则为局部，G0=1则为全局，以此类推

断点长度(LENx)：00(1字节)、01(2字节)、11(4字节)

通过DR7的LEN控制

断点类型(R/Wx)：00(执行断点)、01(写入断点)、11(访问断点)

流程

被调试进程：

1）CPU执行时检测当前线性地址与调试寄存器（Dr0~Dr3）中的线性地址相等。
2）查IDT表找到对应的中断处理函数（nt!_KiTrap01）
3）CommonDispatchException
4）KiDispatchException
5）DbgkForwardException收集并发送调试事件

最终调用DbgkpSendApiMessage(x, x)，第一个参数：消息类型，第二个参数：是否挂起其它线程

调试器进程：

1）循环判断
2）取出调试事件
3）列出信息：寄存器、内存
4）用户处理

处理硬件断点

1）硬件调试断点产生的异常是 STATUS_SINGLE_STEP（单步异常）
2）检测Dr6寄存器的B0~B3：哪个寄存器触发的异常

这里硬件断点有两种情况，一种情况是dr0-dr3寄存器引发的异常，另外一种情况就是TF=1引发的异常

这里如果是DR0寄存器引发的异常，那么B0=1，以此类推，如果是TF=1引发的异常，那么DR6的低4位为全0

首先看一下异常处理函数

BOOL SingleStepExceptionProc(EXCEPTION_DEBUG_INFO *pExceptionInfo)
{
	BOOL bRet = FALSE;

	//1. 获取线程上下文
	Context.ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS;
	GetThreadContext(hDebuggeeThread, &Context);
	//2. 判断是否是硬件断点导致的异常
	if(Context.Dr6 & 0xF)	//B0~B3不为空 硬件断点
	{
		//2.1 显示断点信息
		printf("硬件断点：%x 0x%p \n", Context.Dr7&0x00030000, Context.Dr0);
		//2.2 将断点去除
		Context.Dr0 = 0;
		Context.Dr7 &= 0xfffffffe;
	}
	else	//单步异常
	{
		//2.1 显示断点信息
		printf("单步：0x%p \n", Context.Eip);
		//2.2 将断点去除
		Context.Dr7 &= 0xfffffeff;
	}

	SetThreadContext(hDebuggeeThread, &Context);

	// 等待用户命令
	while(bRet == FALSE)
	{
		bRet = WaitForUserCommand();
	}
	
	return bRet;
}

​

之前我们是在创建进程的时候进行断点，但是因为硬件断点需要在线程创建完成之后，设置在被调试程序的上下文中

因此当被调试程序触发调试器设置的INT 3断点时，此时设置硬件断点较为合理

再就是硬件断点的代码，这里把Dr0寄存器置1，然后把16、17为置0为执行断点，异常长度为1字节(18、19位置0)，地址的话就是int3断点的地址+1

VOID SetHardBreakPoint(PVOID pAddress)
{
	//1. 获取线程上下文
	Context.ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS;
	GetThreadContext(hDebuggeeThread, &Context);
	//2. 设置断点位置
	Context.Dr0 = (DWORD)pAddress;
	Context.Dr7 |= 1;
	//3. 设置断点长度和类型
	Context.Dr7 &= 0xfff0ffff;	//执行断点（16、17位 置0） 1字节（18、19位 置0）
	//5. 设置线程上下文
	SetThreadContext(hDebuggeeThread, &Context);
}

完整代码如下

// Debug4.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdio.h>
#include <windows.h>
#include <tlhelp32.h>

#define DEBUGGEE "C:\\ipmsg.exe"

//被调试进程ID,进程句柄，OEP
DWORD dwDebuggeePID = 0;

//被调试线程句柄
HANDLE hDebuggeeThread = NULL;
HANDLE hDebuggeeProcess = NULL;

//系统断点
BOOL bIsSystemInt3 = TRUE;

//被INT 3覆盖的数据
CHAR OriginalCode = 0;

//原始内存属性
DWORD dwOriginalProtect;

//线程上下文
CONTEXT Context;

typedef HANDLE (__stdcall *FnOpenThread) (DWORD, BOOL, DWORD);

VOID InitDebuggeeInfo(DWORD dwPID, HANDLE hProcess)
{
	dwDebuggeePID = dwPID;
	hDebuggeeProcess = hProcess;
}

DWORD GetProcessId(LPTSTR lpProcessName)
{
	HANDLE hProcessSnap = NULL;
	PROCESSENTRY32 pe32 = {0};
	
	hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	if(hProcessSnap == (HANDLE)-1)
	{
		return 0;
	}
	
	pe32.dwSize = sizeof(PROCESSENTRY32);
	
	if(Process32First(hProcessSnap, &pe32))
	{
		do 
		{
			if(!strcmp(lpProcessName, pe32.szExeFile))
				return (int)pe32.th32ProcessID;
		} while (Process32Next(hProcessSnap, &pe32));
	}
	else
	{
		CloseHandle(hProcessSnap);
	}
	
	return 0;
}

BOOL WaitForUserCommand()
{
	BOOL bRet = FALSE;
	CHAR command;

	printf("COMMAND>");

	command = getchar();

	switch(command)
	{
	case 't':
		bRet = TRUE;
		break;
	case 'p':
		bRet = TRUE;
		break;
	case 'g':
		bRet = TRUE;
		break;
	}

	getchar();
	return bRet;
}

VOID SetHardBreakPoint(PVOID pAddress)
{
	//1. 获取线程上下文
	Context.ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS;
	GetThreadContext(hDebuggeeThread, &Context);
	//2. 设置断点位置
	Context.Dr0 = (DWORD)pAddress;
	Context.Dr7 |= 1;
	//3. 设置断点长度和类型
	Context.Dr7 &= 0xfff0ffff;	//执行断点（16、17位 置0） 1字节（18、19位 置0）
	//5. 设置线程上下文
	SetThreadContext(hDebuggeeThread, &Context);
}

BOOL Int3ExceptionProc(EXCEPTION_DEBUG_INFO *pExceptionInfo)
{
	BOOL bRet = FALSE;

	//1. 将INT 3修复为原来的数据（如果是系统断点，不用修复）
	if(bIsSystemInt3)
	{
		bIsSystemInt3 = FALSE;
		return TRUE;
	}
	else
	{
		WriteProcessMemory(hDebuggeeProcess, pExceptionInfo->ExceptionRecord.ExceptionAddress, &OriginalCode, 1, NULL);
	}

	//2. 显示断点位置
	printf("Int 3断点：0x%p \r\n", pExceptionInfo->ExceptionRecord.ExceptionAddress);

	//3. 获取线程上下文
	Context.ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS;
	GetThreadContext(hDebuggeeThread, &Context);
	
	//4. 修正EIP
	Context.Eip--;
	SetThreadContext(hDebuggeeThread, &Context);

	//5. 显示反汇编代码、寄存器等

	/*
	硬件断点需要设置在被调试进程的的线程上下文中。
	因此当被调试程序触发调试器设置的INT 3断点时，此时设置硬件断点较为合理。
	*/
	SetHardBreakPoint((PVOID)((DWORD)pExceptionInfo->ExceptionRecord.ExceptionAddress+1));
	
	//6. 等待用户命令
	while(bRet == FALSE)
	{
		bRet = WaitForUserCommand();
	}
	
	return bRet;
}

BOOL AccessExceptionProc(EXCEPTION_DEBUG_INFO *pExceptionInfo)
{
	BOOL bRet = FALSE;
	DWORD dwAccessFlag;		//访问类型 0为读 1为写
	DWORD dwAccessAddr;		//访问地址
	DWORD dwProtect;		//内存属性

	//1. 获取异常信息，修改内存属性
	dwAccessFlag = pExceptionInfo->ExceptionRecord.ExceptionInformation[0];
	dwAccessAddr = pExceptionInfo->ExceptionRecord.ExceptionInformation[1];
	printf("内存断点 : dwAccessFlag - %x dwAccessAddr - %x \n", dwAccessFlag, dwAccessAddr);
	VirtualProtectEx(hDebuggeeProcess, (VOID*)dwAccessAddr, 1, dwOriginalProtect, &dwProtect);
	
	//2. 获取线程上下文
	Context.ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS;
	GetThreadContext(hDebuggeeThread, &Context);
	//3. 修正EIP(内存访问异常，不需要修正EIP)
	printf("Eip: 0x%p \n", Context.Eip);
	//4. 显示汇编/寄存器等信息
	//5. 等待用户命令
	while(bRet == FALSE)
	{
		bRet = WaitForUserCommand();
	}

	return bRet;
}

BOOL SingleStepExceptionProc(EXCEPTION_DEBUG_INFO *pExceptionInfo)
{
	BOOL bRet = FALSE;

	//1. 获取线程上下文
	Context.ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS;
	GetThreadContext(hDebuggeeThread, &Context);
	//2. 判断是否是硬件断点导致的异常
	if(Context.Dr6 & 0xF)	//B0~B3不为空 硬件断点
	{
		//2.1 显示断点信息
		printf("硬件断点：%x 0x%p \n", Context.Dr7&0x00030000, Context.Dr0);
		//2.2 将断点去除
		Context.Dr0 = 0;
		Context.Dr7 &= 0xfffffffe;
	}
	else	//单步异常
	{
		//2.1 显示断点信息
		printf("单步：0x%p \n", Context.Eip);
		//2.2 将断点去除
		Context.Dr7 &= 0xfffffeff;
	}

	SetThreadContext(hDebuggeeThread, &Context);

	//6. 等待用户命令
	while(bRet == FALSE)
	{
		bRet = WaitForUserCommand();
	}
	
	return bRet;
}

BOOL ExceptionHandler(DEBUG_EVENT *pDebugEvent)
{ 
	BOOL bRet = TRUE;
	EXCEPTION_DEBUG_INFO *pExceptionInfo = NULL;
	pExceptionInfo = &pDebugEvent->u.Exception;
	//得到线程句柄，后面要用
	FnOpenThread MyOpenThread = (FnOpenThread)GetProcAddress(LoadLibrary("kernel32.dll"), "OpenThread");
	hDebuggeeThread = MyOpenThread(THREAD_ALL_ACCESS, FALSE, pDebugEvent->dwThreadId);

	switch(pExceptionInfo->ExceptionRecord.ExceptionCode)
	{
	//INT 3异常
	case EXCEPTION_BREAKPOINT:
		bRet = Int3ExceptionProc(pExceptionInfo);
		break;
	//访问异常
	case EXCEPTION_ACCESS_VIOLATION:
		bRet = AccessExceptionProc(pExceptionInfo);
		break;
	//单步执行
	case EXCEPTION_SINGLE_STEP:
		bRet = SingleStepExceptionProc(pExceptionInfo);
		break;
	}

	return bRet;
}

VOID SetInt3BreakPoint(LPVOID addr)
{
	CHAR int3 = 0xCC;
	
	//1. 备份
	ReadProcessMemory(hDebuggeeProcess, addr, &OriginalCode, 1, NULL);
	//2. 修改
	WriteProcessMemory(hDebuggeeProcess, addr, &int3, 1, NULL);
}

VOID SetMemBreakPoint(PCHAR pAddress)
{
	//1. 访问断点
	VirtualProtectEx(hDebuggeeProcess, pAddress, 1, PAGE_NOACCESS, &dwOriginalProtect);	//PTE P=0
	//2. 写入断点
	//VirtualProtectEx(hDebuggeeProcess, pAddress, 1, PAGE_EXECUTE_READ, &dwOriginalProtect);	//PTE R/W=0
}

int main(int argc, char* argv[])
{
	BOOL nIsContinue = TRUE;
	DEBUG_EVENT debugEvent = {0};
	BOOL bRet = TRUE;
	DWORD dwContinue = DBG_CONTINUE;

	//1.创建调试进程
	STARTUPINFO startupInfo = {0};
	PROCESS_INFORMATION pInfo = {0};
	GetStartupInfo(&startupInfo);

	bRet = CreateProcess(DEBUGGEE, NULL, NULL, NULL, TRUE, DEBUG_PROCESS || DEBUG_ONLY_THIS_PROCESS, NULL, NULL, &startupInfo, &pInfo);
	if(!bRet)
	{
		printf("CreateProcess error: %d \n", GetLastError());
		return 0;
	}

	hDebuggeeProcess = pInfo.hProcess;

	//2.调试循环
	while(nIsContinue)
	{
		bRet = WaitForDebugEvent(&debugEvent, INFINITE);
		if(!bRet)
		{
			printf("WaitForDebugEvent error: %d \n", GetLastError());
			return 0;
		}

		switch(debugEvent.dwDebugEventCode)
		{
		//1.异常
		case EXCEPTION_DEBUG_EVENT:
			bRet = ExceptionHandler(&debugEvent);
			if(!bRet)
				dwContinue = DBG_EXCEPTION_NOT_HANDLED;
			break;
		//2.
		case CREATE_THREAD_DEBUG_EVENT:
			break;
		//3.创建进程
		case CREATE_PROCESS_DEBUG_EVENT:
			//int3 断点
			SetInt3BreakPoint((PCHAR)debugEvent.u.CreateProcessInfo.lpStartAddress);
			//内存断点
			//SetMemBreakPoint((PCHAR)debugEvent.u.CreateProcessInfo.lpStartAddress);
			break;
		//4.
		case EXIT_THREAD_DEBUG_EVENT:
			break;
		//5.
		case EXIT_PROCESS_DEBUG_EVENT:
			break;
		//6.
		case LOAD_DLL_DEBUG_EVENT:
			break;
		//7.
		case UNLOAD_DLL_DEBUG_EVENT:
			break;
		//8.
		case OUTPUT_DEBUG_STRING_EVENT:
			break;
		}
		
		bRet = ContinueDebugEvent(debugEvent.dwProcessId, debugEvent.dwThreadId, DBG_CONTINUE);
	}

	return 0;
}

实现效果如下

原文作者：Drunkmars

原文链接：http://drunkmars.top/2022/04/01/%E5%BC%82%E5%B8%B8%E8%A7%A6%E5%8F%91/

发表日期：四月 1日 2022, 12:00:00 凌晨

更新日期：April 6th 2022, 5:49:39 pm

版权声明：本文采用知识共享署名-非商业性使用 4.0 国际许可协议进行许可

• Next Post
  通过硬件断点绕过hook检测
• Previous Post
  windows异常处理探究

Powered by Hexotheme Archer

PV: :)

CATALOG

1. 1. 软件断点
2. 2. 内存断点
   1. 2.1. 流程
3. 3. 硬件断点
   1. 3.1. 设置硬件断点
   2. 3.2. 流程
   3. 3.3. 处理硬件断点

• Archive
• Tag
• Cate

Total : 117

2022

• 05/14 浅谈EDR绕过
• 05/14 调用NtCreateUserProcess创建进程绕过杀软hook
• 05/12 ETW的攻与防
• 05/07 对抗无落地的shellcode注入
• 05/04 x64环境下隐藏可执行内存
• 05/01 深入理解注册表监控
• 04/30 windows环境下的自保护探究
• 04/29 64位下使用回调函数实现监控
• 04/16 通过嵌入x64汇编隐藏数据&反调试
• 04/13 构建API调用框架绕过杀软hook
• 04/10 windows环境下的反调试探究
• 04/07 浅谈hook攻防
• 04/04 通过硬件断点绕过hook检测
• 04/01 windows环境下的调试器探究
• 03/28 windows异常处理探究
• 03/22 ring0下使用内核重载绕过杀软hook
• 03/16 基于全局句柄表发现隐藏进程
• 03/03 基于PEB断链实现进程与模块隐藏
• 02/20 ring3下API的逆向分析及重构
• 02/17 shellcode编写探究
• 02/16 ring0下的Inline hook
• 02/15 ring0下的进程保护
• 02/14 进程强杀初探
• 01/17 URLDNS链探究
• 01/15 RMI探究
• 01/14 java反射探究
• 01/10 java反序列化探究

2021

• 12/05 关于抓取明文的探究
• 11/08 使用api创建计划任务详解
• 11/07 自删除技术的实现
• 11/05 CS中上线不出网主机
• 11/04 创建进程的几种方式
• 10/27 自启动技术详解
• 10/26 初探傀儡进程
• 10/25 socket的探究与实现
• 10/22 通过内存写入隐藏模块
• 10/21 初探进程伪装
• 10/21 关于进程隐藏的探究
• 10/19 关于bypassuac的探究
• 10/07 初探com劫持
• 10/04 CSV注入获取meterpreter
• 10/04 反沙箱调试
• 10/04 父进程伪造
• 10/04 调试与反调试的探究
• 10/03 初探dll劫持
• 10/01 关于几种dll注入的学习
• 09/26 浅谈内网转发与流量代理
• 09/13 记一次外网打点到内网渗透
• 09/12 hook技术详解
• 09/10 mysql提权总结
• 08/23 php漏洞大杂烩
• 08/20 struts2漏洞总结
• 08/16 tomcat漏洞大杂烩
• 08/09 红日靶场4
• 08/04 weblogic漏洞大杂烩
• 07/28 浅谈域环境下布置水坑实现hash窃取
• 07/21 红日靶场2
• 07/20 redis漏洞总结
• 07/19 spring漏洞总结
• 07/19 红日靶场3
• 07/06 红日靶场5
• 07/05 一种简单的反虚拟机调试方法
• 06/16 C++二叉树实现
• 06/15 C++链表实现
• 06/13 msf生成木马小结
• 06/11 certutil探究
• 06/10 横向移动总结
• 06/09 从mimikatz抓取密码学习攻防
• 06/08 LLMNR和NetBIOS欺骗攻击分析及防范
• 06/04 NULL、0、nullptr 区别分析
• 06/02 RPC提权
• 06/01 CVE-2019-1388 UAC提权
• 06/01 如何编写属于自己的第一个exp
• 05/29 读书笔记
• 05/28 vulnhub靶场实战
• 05/26 渗透测试中弹shell的多种方式及bypass
• 05/25 CVE-2020-1472详解
• 05/23 从外围打点到内网渗透拿下域控
• 05/19 内网渗透之向日葵妙用
• 05/12 Dedecms(织梦cms)漏洞分析及复现
• 05/12 Empirecms(帝国cms)漏洞分析及复现
• 05/11 CVE-2020-0796分析及利用
• 05/11 MS17_010检测及打法
• 05/11 木马解析&disable_fuctions
• 05/08 jboss之JMXInvokerServlet反序列化漏洞分析利用
• 05/08 内网穿透的n种姿势
• 05/06 文件上传bypass安全狗
• 04/28 cs加载宏上线初探
• 04/27 内网渗透之DPAPI机制学习
• 04/20 隐藏用户的创建和使用
• 04/19 利用卷影拷贝服务提取ntds.dit
• 04/17 中间人攻击之arp欺骗
• 04/15 浅谈域渗透中组策略及gpp运用
• 04/14 thinkphp漏洞分析与总结
• 04/13 msf使用详解
• 04/13 sql注入之超详细sqlmap使用攻略
• 04/10 windows认证解读
• 04/09 巧用smb beacon拿下不出网主机(红日靶场1)
• 04/08 phpmyadmin页面getshell
• 04/08 windows环境下抓密码总结
• 04/04 Stega
• 04/02 内网渗透命令
• 03/30 IPC命令&计划任务上线
• 03/29 常用端口总结
• 03/27 mysql离线解析密码
• 03/27 绕过CDN找源站ip
• 03/27 记一次php、sql注入学习后的一道ctf代码审计题复盘
• 03/26 小白的第一次sql实战
• 03/23 crackme001
• 03/21 certutil&wmic绕过
• 03/17 vps-java环境配置
• 03/16 Joomla框架搭建&远程代码执行(RCE)漏洞复现
• 03/16 jboss打入内网的四种方式
• 03/16 sqlmap在https下的一种错误 - ssl连接失败
• 03/14 汇编JCC指令表
• 03/13 README
• 03/13 写在最前

 内网渗透  cve  漏洞复现  C++  二进制  内核  cms  web渗透  private  横向移动  提权  windows  ctf  java  cobalt strike  apt  java中间件  msf命令  oa  中间件  mysql  sql  thinkphp  web  x64  环境配置  域渗透  碎碎念  bypass  php  靶场实战  权限维持



缺失模块，请参考主题文档进行安装配置：https://github.com/fi3ework/hexo-theme-archer#%E5%AE%89%E8%A3%85%E4%B8%BB%E9%A2%98

