Windows环境下的调试器探究——软件断点

前言

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

软件断点

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

被调试进程

.

首先找到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的操作

然后调用处理的函数

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

实现代码如下

#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;
}

实现效果