调试器原理

最新推荐文章于 2023-07-22 15:17:41 发布
最新推荐文章于 2023-07-22 15:17:41 发布
阅读量420 收藏 1
点赞数 1
分类专栏： 异常与调试 文章标签： 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/datouyu0824/article/details/115045963
版权
调式器原理
1. 对目标进程进行调试

  • 创建进程调试：

        //保存启动信息的结构体 第一个变量cb为结构体大小
    STARTUPINFO si = { sizeof(STARTUPINFO) };

    //保存进程信息的结构体
    PROCESS_INFORMATION pi = {};

    //以调式的方式创建进程
    bool result = CreateProcess(
        path,                              //文件路径
        NULL,                              //命令行
        NULL,                              //进程安全属性
        NULL,                              //线程安全属性
        FALSE,                             //子进程是否继承句柄表
        DEBUG_PROCESS | CREATE_NEW_CONSOLE,//创建标志
        NULL,                              //环境变量
        NULL,                              //当前工作路径
        &si,                               //启动信息
        &pi                                //进程信息
    );

  • 附加进程调试

     DebugActiveProcess(pid);
2. 调试事件循环

  • 等待调试事件WaitForDebugEvent(&DEBUG_EVENT,INFINITE)

  • 处理调试事件

  • 回复被调式子程序

    typedef struct _DEBUG_EVENT {
    DWORD dwDebugEventCode;	//调试事件代码
    DWORD dwProcessId;		//产生调试事件的进程ID，线程ID
    DWORD dwThreadId;		//调试事件的信息
    union {
        EXCEPTION_DEBUG_INFO Exception;
        CREATE_THREAD_DEBUG_INFO CreateThread;
        CREATE_PROCESS_DEBUG_INFO CreateProcessInfo;
        EXIT_THREAD_DEBUG_INFO ExitThread;
        EXIT_PROCESS_DEBUG_INFO ExitProcess;
        LOAD_DLL_DEBUG_INFO LoadDll;
        UNLOAD_DLL_DEBUG_INFO UnloadDll;
        OUTPUT_DEBUG_STRING_INFO DebugString;
        RIP_INFO RipInfo;
    } u;
} DEBUG_EVENT, *LPDEBUG_EVENT;

//等待调试事件
void CDebugger::DebugEventLoop()
{
    //异常处理状态
    m_DebugStatus = DBG_CONTINUE;

    //循环标志
    BOOL Isloop = true;

     //1.等待调式事件
    while (Isloop)
    {
        //等待调试事件 参数1：接收事件信息的结构体 参数2：等待时长
        WaitForDebugEvent(&m_DebugEventInfo, INFINITE);

        //获取到调式信息打开句柄
        GetHandle();

        //2.处理调试事件
        switch (m_DebugEventInfo.dwDebugEventCode)
        {
        case EXCEPTION_DEBUG_EVENT:     // 异常调试事件
            ExceptionHandler();         // 异常处理器
            break;

        case CREATE_THREAD_DEBUG_EVENT: // 线程创建事件
            break;

        case CREATE_PROCESS_DEBUG_EVENT:// 进程创建事件
            {
                //初始化被调试进程信息
                InitDebugProc();
                break;
            }      

        case EXIT_THREAD_DEBUG_EVENT:   // 退出线程事件
            break;

        case EXIT_PROCESS_DEBUG_EVENT:  // 退出进程事件
            Isloop = false;
            printf("进程退出事件触发\n\n");
            break;

        case LOAD_DLL_DEBUG_EVENT:      // 映射DLL事件
        {
            //保存模块信息
            DWORD pBase = (DWORD)m_DebugEventInfo.u.LoadDll.lpBaseOfDll;
            HANDLE hFile = m_DebugEventInfo.u.LoadDll.hFile;
        }
        break;

        case UNLOAD_DLL_DEBUG_EVENT:    // 卸载DLL事件 
            break;

        case OUTPUT_DEBUG_STRING_EVENT: // 调试字符串输出事件
            break;

        case RIP_EVENT:                 // RIP事件(内部错误)
            break;
        }
    
        //3.回复调试子系统
        ContinueDebugEvent(
            m_DebugEventInfo.dwProcessId,   //调试进程ID,必须从DEBUG_EVNET中获取
            m_DebugEventInfo.dwThreadId,    //调试线程ID,必须从DEBUG_EVNET中获取
            m_DebugStatus);			        //异常是否处理，只对异常有效 

        //处理结束关闭句柄
        GetHandle();
    }
    

    // 回复调试子系统当前调试事件的处理结果，对于除 EXCEPTION_DEBUG_EVENT
    //	之外的所有事件，可以直接返回 DBG_CONTINUE，表示调试事件已经被接收
    //	并且处理了，对于 EXCEPTION_DEBUG_EVENT，如果除了了就返回 DBG_CONTINUE
    //	否则返回 DBG_EXCEPTION_NOT_HANDLED，返回这两个值分别意味着内核函
    //	数 DbgkForwardException 返回了 TRUE 和 FALSE。

    // 在调用 ContinueDebugEvent 函数的时候，第一个参数和第二个参数[必须]是
    //	WaitForDebugEvent 函数返回的事件结构体中的进程和线程 id，原因是谁触发
    //	了调试信息，就告诉系统是处理谁的调试信息
}
3. 处理异常事件
//异常调式事件处理
void CDebugger::ExceptionHandler()
{
    //异常类型及发生异常所在地址
    DWORD dwCode = m_DebugEventInfo.u.Exception.ExceptionRecord.ExceptionCode;
    LPVOID pAddress = m_DebugEventInfo.u.Exception.ExceptionRecord.ExceptionAddress;

    //第一个为系统软件的标志
    static bool Is_SystemBreakPoint = TRUE;

    //是否需要输入的标志
    bool Is_Input = false;

    //判断异常的类型
    switch (dwCode)
    {
        //如果是软件断点异常 int3
    case EXCEPTION_BREAKPOINT:
    {
        //第一个是系统软件断点
        //系统断点，不处理，在接收到时创建OEP断点
        if (Is_SystemBreakPoint)
        {
            //当操作系统在加载一个exe模块并执行的时候，会判断当前进程是否处于调试状态
            //如果处于调试状态，那么就会通过 int 3 指令设置一个【系统断点】，否则正常
            //执行，一般来讲系统断点是不需要我们进程修复的，直接允许程序继续执行
            Is_SystemBreakPoint = false;          
        }
        //修复这个断点
        else
        {
            m_DebugStatus = CBreakPoint::FixSoftBreakPoint(m_hProc, m_hThread, pAddress);
        }
        break;
    }
    // 硬件断点(DrN & Tf) 都会触发这个异常
    case EXCEPTION_SINGLE_STEP:
    {
        //处理状态
        m_DebugStatus = DBG_CONTINUE;

        //判断是否为单步执行断点且是否存在失效的断点(修复断点)
        CBreakPoint::GetInvalidBp(m_hProc, m_hThread);

        if (CBreakPoint::IsSingleStep)
        {
            //如果存在恢复断点直接跑起来
            //如果在断点处执行单步p，需要等待接收收入
            if (!Is_t)
            {
                printf("触发断点信息 >> 序号：无  为恢复其他永久性断点设置的单步执行断点\n");
            }
            else
            {
                printf("触发断点信息 >> 序号：无  按下 t 设置的单步执行断点\n");
                //重置单步执行断点标志
                Is_t = false;
                Is_Input = true;
            }
            CBreakPoint::IsSingleStep = false;
        }

        //如果是硬件断点则修复
        if (CBreakPoint::FixHardBreakPoint(m_hProc, m_hThread, pAddress) != 0)
        {
            Is_Input = true;
        }
        break;
    }
    // 非法访问异常
    case EXCEPTION_ACCESS_VIOLATION:
    {
        //处理状态
        m_DebugStatus = DBG_CONTINUE;

        LPVOID pAddress = (LPVOID)m_DebugEventInfo.u.Exception.ExceptionRecord.ExceptionInformation[1];
        DWORD type = m_DebugEventInfo.u.Exception.ExceptionRecord.ExceptionInformation[0];

        printf(">>>>> %p\n", m_DebugEventInfo.u.Exception.ExceptionRecord.ExceptionAddress);

        {
            //获取修复的结果
            //如果是自己设置的
            DWORD ret = CBreakPoint::FixMemoryBreakPoint(m_hProc, m_hThread, pAddress);

            //如果找到的不是自己设置的则不处理
            if (ret == -1)
            {
                m_DebugStatus = DBG_EXCEPTION_NOT_HANDLED;
            }
            //如果是自己的且命中地址符合断点类型则等待输入显示汇编
            else if (ret == 1 && CBreakPoint::MBpType == type)
            {
                Is_Input = true;
            }
        }
    }
    }

    if (Is_Input)
    {
        //如果是源码调试显示源码
        if (RcFlag)
        {
            char* p = pSc;
            ShowRc(p, LineNum);
        }
        else            
        //显示反汇编
            CCapStone::DisplayAsm(m_hProc, pAddress, 10);
        Input_Command();
    }
}

  1. 不同的异常事件对应不同的结构体信息

  2. 异常事件的返回值分两种

    1. 没有处理的(让被调试程序自己处理)：m_DebugStatus = DBG_EXCEPTION_NOT_HANDLED;
    2. 处理了的：m_DebugStatus = DBG_CONTINUE;

  3. 异常事件也分两种：

    • 被调式程序自己产生的异常(一般不处理，让调试子程序的处理器处理)
    • 调式器主动制造的异常(需要处理)

  4. 最重要的异常类型EXCEPTTION_DEBUG_EVENT

    //异常事件结构体
typedef struct _EXCEPTION_DEBUG_INFO { 
  EXCEPTION_RECORD ExceptionRecord; //异常信息结构体
  DWORD dwFirstChance; //不为0则第一次遇到异常 可以判断该值只处理第二次的异常从而将被调试子程序自己产生的异常忽略
} EXCEPTION_DEBUG_INFO; 

//异常信息结构体
typedef struct _EXCEPTION_RECORD {
  DWORD ExceptionCode; //异常码
  DWORD ExceptionFlags; //异常标志 最低位为1表示不可恢复
  struct _EXCEPTION_RECORD* ExceptionRecord;//异常记录关联，连续异常用到
  PVOID ExceptionAddress;//异常发生的地址
  DWORD NumberParameters;//参数
  DWORD ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
    //内存访问异常用到 第一个元素为0读错误 1写错误 8执行错误 第二个元素表示异常地址
} EXCEPTION_RECORD;

异常代码
异常发生的原因。这是由硬件异常生成的代码，或软件生成的异常在 RaiseException函数中指定的代码。

  
EXCEPTION_INT_DIVIDE_BY_ZERO 线程尝试将整数值除以整数除数零。 //0x00 错误类

EXCEPTION_SINGLE_STEP 跟踪陷阱或其他单指令机制表示已执行一个指令。
    //0x01 单步和硬件 除硬件执行是错误类，其余为陷阱类
    
EXCEPTION_BREAKPOINT 遇到断点。 //软件断点 0x03 陷阱类
    
EXCEPTION_INT_OVERFLOW 整数操作的结果导致执行结果最重要的位。 //溢出 0x04 陷阱类
    
//0x8 双重错误 0x12机器检查 属于中止类错误无法恢复

EXCEPTION_ACCESS_VIOLATION 线程尝试从它没有适当访问权限的虚拟地址读取或写入虚拟地址。
    //内存断点错误类 0x0E
    
EXCEPTION_PRIV_INSTRUCTION 线程尝试执行在当前计算机模式下不允许其操作的指令 //如STI

EXCEPTION_ARRAY_BOUNDS_EXCEEDED 线程尝试访问超出边界的数组元素，基础硬件支持边界检查。

EXCEPTION_DATATYPE_MISALIGNMENT 线程尝试在不提供对齐的硬件上读取或写入未对齐的数据。

例如，16 位值必须在 2 字节边界上对齐;如果 16 位值必须在 2 字节边界上对齐，因此，在 2 字节边界上必须对齐 16 位值。4 字节边界上的 32 位值，等等。

EXCEPTION_FLT_DENORMAL_OPERAND 浮点操作中的操作法太小，无法表示为标准浮点值。

EXCEPTION_FLT_DIVIDE_BY_ZERO 线程尝试将浮点值除以浮点除数零。

EXCEPTION_FLT_INEXACT_RESULT 浮点操作的结果不能完全表示为小数分数。

EXCEPTION_FLT_INVALID_OPERATION 此列表中未包括的浮点异常。

EXCEPTION_FLT_OVERFLOW 浮点操作的指数大于相应类型允许的幅度。 
  
EXCEPTION_FLT_STACK_CHECK 由于浮点操作，堆栈溢出或下溢。

EXCEPTION_FLT_UNDERFLOW 浮点操作的指数小于相应类型允许的幅度。

EXCEPTION_ILLEGAL_INSTRUCTION 线程尝试执行无效的指令。

EXCEPTION_IN_PAGE_ERROR 线程尝试访问不存在且系统无法加载该页的页面。//页错误

例如，如果网络连接在网络上运行程序时丢失，则可能发生此异常。

EXCEPTION_INVALID_DISPOSITION 异常处理程序向异常调度程序返回无效处置。

使用高级语言（如 C）的程序员不应遇到此异常。

EXCEPTION_NONCONTINUABLE_EXCEPTION 发生不可继续的异常后，线程尝试继续执行。

EXCEPTION_STACK_OVERFLOW 线程已使用其堆栈。
断点的实现
1. 设置单步执行断点
  • 永久断点的实现就是断下后设置陷阱标志，在其中恢复断点
// CPU 中的 eflags 标志位中保留了一个 tf 标志位，通过
	//	设置 tf 标志位，cpu 允许在执行一条指令之后产生异常，
	//	在异常产生后，CPU 会自动重置 tf 标志为 0 

	// 0. 初始化结构体说明自己需要操作的寄存器
	CONTEXT context = { CONTEXT_CONTROL };

	// 1. 获取到目标线程的线程环境
	GetThreadContext(thread, &context);

	// 2. 设置目标的 eflags.tf 为 1
	context.EFlags |= 0x00000100;

	// 3. 将设置后的内容应用到目标线程
	SetThreadContext(thread, &context);

异常类型： 硬件断点(DrN & Tf) 都会触发这个异常
case EXCEPTION_SINGLE_STEP:

// 硬件断点(DrN & Tf) 都会触发这个异常
        case EXCEPTION_SINGLE_STEP:
        {
            m_DebugStatus = DBG_CONTINUE;
            Is_Input = true;
            break;
        }
2. 软件断点
// 设置一个软件断点
void CBreakPoint::SetSoftBreakPoint(HANDLE process, LPVOID address, bool persistent)
{
    // 0. 创建结构体，初始化断点的信息
    BREAKPOINT_INFO BpInfo = { address };

    // 1. 保存需要设置断点的地址上的原始内容
    DWORD length = 0;
    ReadProcessMemory(process, address, &BpInfo.Opcode, 1, &length);

    // 2. 修改目标进程指定地址的内容为 0xCC
    WriteProcessMemory(process, address, "\xCC", 1, &length);

    //设置永久性
    BpInfo.Is_Persistent = persistent;

    // 3. 将设置好的断点添加到断点列表
    breakpoint_list.push_back(BpInfo);
}


// 修复一个软件断点
DWORD CBreakPoint::FixSoftBreakPoint(HANDLE process, HANDLE thread, LPVOID address)
{

    // 当调试器检测到一个软件断点断下的时候，首先需要获取异常地址，判断
    //	这个软件断点是不是调试器用户设置的，如果是，就遍历断点列表找到
    //	设置 cc 之前的内容，将原始内容写回目标地址，并且将 【eip - 1】

        // 遍历用户设置的所有断点
    for (DWORD i = 0; i < breakpoint_list.size(); ++i)
    {
        // 对比断点，找到对应的断点信息
        if (address == breakpoint_list[i].Address && 软件断点 == breakpoint_list[i].dwkind)
        {

            // 1. 重新写入设置断点之前的内容
            DWORD length = 0;
            WriteProcessMemory(process, address, &breakpoint_list[i].Opcode, 1, &length);

            // 2. 获取目标线程的线程环境
            CONTEXT context = { CONTEXT_CONTROL };
            GetThreadContext(thread, &context);

            // 3. 由于是陷阱类异常，所以需要 eip - 1
            context.Eip -= 1;

            // 4. 将修改应用到目标线程
            SetThreadContext(thread, &context);

            // 5. 如果是永久断点在这里暂时置为无效，如果是临时，直接删除
            if (breakpoint_list[i].Is_Persistent)
            {
                breakpoint_list[i].Valid = false;
            }

            else
            {
                breakpoint_list.erase(breakpoint_list.begin() + i);
            }

            //设置单步执行断点
            CBreakPoint::SetStepBreakPoint(thread);

            return DBG_CONTINUE;
        }
    }
    return DBG_EXCEPTION_NOT_HANDLED;
}
3. 硬件断点
// 设置一个硬件断点
DWORD CBreakPoint::SetHardBreakPoint(HANDLE thread, LPVOID address, DWORD type, DWORD len)
{
    // 不要在系统断点设置调试寄存器

    // 硬件断点由CPU提供的 6 个调试寄存器实现，分别是 Dr0~Dr3，Dr6，Dr7
    //	其中设置断点需要用到 Dr0~Dr3 以及 Dr7，Dr0~Dr3 用于保存断点的地址
    //	Dr7 用于设置断点的类型，以及标识断点的状态。
    //  Dr6的第四位标明哪个硬件断点触发了

    //RW0~3 type读写域 0执行 1写 3读写
    //LEN0~3 len长度域 0：1字节(执行必须为0)，1：2字节，2：8字节或者未知 3：4字节
    //L0~3 为 1 局部有效
    //G0~3 为 1 全局有效(被调试进程无效)

    // 1. 获取目标线程的寄存器
    CONTEXT context = { CONTEXT_DEBUG_REGISTERS };
    GetThreadContext(thread, &context);

    // 2. 获取 Dr7 寄存器，得到硬件断点的开关状态
    PR7 dr7 = (PR7)&context.Dr7;

    //增加的断点
    BREAKPOINT_INFO bp = {};

    CStringA sKind;

    //判断len和type的值
    //如果RW域为0 则一定为执行断点 len也为0
    if (type == 0)
        len = 0;

    //根据len重置地址 设置对齐粒度
    //len=1 地址为2的倍数
    if (len == 1)
        address = LPVOID(DWORD(address) - (DWORD)address % 2);
    //len=3 地址为4的倍数
    else if (len == 3)
        address = LPVOID(DWORD(address) - (DWORD)address % 4);
    //len=0 地址为1的倍数
    else if (len == 0)
        len = 0;
    //len=2 地址为8的倍数
    else if (len == 2)
        address = LPVOID(DWORD(address) - (DWORD)address % 8);
    else
        return 0;

    // 3. 判断没有使用的硬件断点，并设置
    if (dr7->L0 == 0)
    {
        // 如果 L0 是 0 就意味这没有使用这个硬件断点
        dr7->L0 = 1;

        // 设置断点的地址
        context.Dr0 = (DWORD)address;

        // 设置断点的类型: 读1 写3 执行0 2
        dr7->RW0 = type;

        // 设置断点的触发长度，如果是执行就必须是 0
        dr7->LEN0 = len;

        sKind.Format("DR0(type:%u,len:%u)", type, len);

        bp.strKind = sKind;
        bp.Index = 1;

    }
    else if (dr7->L1 == 0)
    {
        // 如果 L0 是 0 就意味这没有使用这个硬件断点
        dr7->L1 = 1;

        // 设置断点的地址
        context.Dr1 = (DWORD)address;

        // 设置断点的类型: 读1 写3 执行0 2
        dr7->RW1 = type;

        // 设置断点的触发长度，如果是执行就必须是 0
        dr7->LEN1 = len;

        sKind.Format("DR1(type:%u,len:%u)", type, len);

        bp.strKind = sKind;
        bp.Index = 2;
    }
    else if (dr7->L2 == 0)
    {
        // 如果 L0 是 0 就意味这没有使用这个硬件断点
        dr7->L2 = 1;

        // 设置断点的地址
        context.Dr2 = (DWORD)address;

        // 设置断点的类型: 读1 写3 执行0 2
        dr7->RW2 = type;

        // 设置断点的触发长度，如果是执行就必须是 0
        dr7->LEN2 = len;

        sKind.Format("DR2(type:%u,len:%u)", type, len);

        bp.strKind = sKind;
        bp.Index = 4;
    }
    else if (dr7->L3 == 0)
    {
        // 如果 L0 是 0 就意味这没有使用这个硬件断点
        dr7->L3 = 1;

        // 设置断点的地址
        context.Dr3 = (DWORD)address;

        // 设置断点的类型: 读1 写3 执行0 2
        dr7->RW3 = type;

        // 设置断点的触发长度，如果是执行就必须是 0
        dr7->LEN3 = len;

        sKind.Format("DR3(type:%u,len:%u)", type, len);

        bp.strKind = sKind;
        bp.Index = 8;
    }
    else
    {
        printf("没有可用的硬件断点\n");
        return 0;
    }

    bp.Address = address;
    bp.Valid = true;
    bp.dwkind = 硬件断点;
    *(PWORD)(&bp.Attrbute) = type;
    *((PWORD)(&bp.Attrbute)+1) = len;

    //添加到断点列表
    breakpoint_list.push_back(bp);

    // 4. 将寄存器的修改应用到线程
    SetThreadContext(thread, &context);
    return 0;
}


//将一个硬件断点启动标志置零
DWORD CBreakPoint::SetHardBpInvalid(HANDLE thread, DWORD index)
{
    //获取线程信息
    CONTEXT context = { CONTEXT_DEBUG_REGISTERS };
    GetThreadContext(thread, &context);

    //硬件断点的位置
    DWORD Is_HardBp = 0;

    PR7 dr7 = (PR7)(&(context.Dr7));

    if ((context.Dr6 & 0xf) != 0)
    {
        index = (context.Dr6 & 0xf);
        Is_HardBp = index;
    }

    //判断是哪个硬件调试寄存器被触发了 设置为无效
    switch (index)
    {
    case 1:
        dr7->L0 = 0; break;
    case 2:
        dr7->L1 = 0; break;
    case 4:
        dr7->L2 = 0; break;
    case 8:
        dr7->L3 = 0; break;
    }

    // 4. 将寄存器的修改应用到线程
    SetThreadContext(thread, &context);

    return Is_HardBp;
}
4. 内存断点
// 0. 创建结构体，初始化断点的信息
    BREAKPOINT_INFO BpInfo = { address };

    //dwNewProtect = PAGE_EXECUTE;//内存读写断点
    //dwNewProtect = PAGE_EXECUTE_READ;//可执行可读不可写 内存写断点
    //dwNewProtect = PAGE_READWRITE;//可读可写不可执行 内存执行断点

    //原来的属性
    DWORD dwOldProtect = 0;

    //新的属性
    DWORD dwNewProtect = 0;

    switch (type)
    {
    case 'r':
        MBpType = 0;
        dwNewProtect = PAGE_NOACCESS;
        break;
    case 'w':
        MBpType = 1;
        dwNewProtect = PAGE_NOACCESS;
        break;
    case 'e':
        MBpType = 8;
        dwNewProtect = PAGE_NOACCESS;
        break;
    }

    // 1. 根据断点类型设置 
    //在地址的页起始位置设置 1页的大小
    //直接设置成没有任何访问属性
    VirtualProtectEx(process, LPVOID((DWORD)address & 0xfffff000), 0x1000, dwNewProtect, &dwOldProtect);

    BpInfo.Attrbute = dwOldProtect;
    BpInfo.dwkind = 内存断点;
    BpInfo.strKind.Format("内存%c型断点", type);
    BpInfo.type = type & 0xFF;

    // 3. 将设置好的断点添加到断点列表
    breakpoint_list.push_back(BpInfo);
    One = true;
    return 0;
}


// 修复一个内存断点
DWORD CBreakPoint::FixMemoryBreakPoint(HANDLE process, HANDLE thread, LPVOID address)
{
    //找到命中位置的标记
    DWORD Find = -1 ;

    //在断点列表中标记为失效
    // 遍历用户设置的所有断点
    for (DWORD i = 0; i < breakpoint_list.size(); ++i)
    {
        // 对比断点，找到对应的断点信息
        if (内存断点 == breakpoint_list[i].dwkind)
        {

            Find = 0;

            // 如果产生的异常不在一个分页上，那就不是自己要处理的内存异常 
            if ((((int)address & 0xFFFFF000) != ((int)breakpoint_list[i].Address & 0xfffff000)))
                return -1;

            //因为发生异常的位置为1页内4kb，所以需要判断是否是设置的位置命中
            //如果是设置的位置
            if (address == breakpoint_list[i].Address)
            {
                Find = 1;
            }

            //设置为失效
            breakpoint_list[i].Valid = false;

            //设置单步执行断点
            CBreakPoint::SetStepBreakPoint(thread);

            DWORD dwNewProtect = breakpoint_list[i].Attrbute;

            //将内存属性恢复
            VirtualProtectEx(process, address, 1, dwNewProtect, (PDWORD)&(breakpoint_list[i].Attrbute));

            printf("触发断点信息 >> 序号：%d  地址：%p  %s  触发中暂时失效\n",
                i, breakpoint_list[i].Address, breakpoint_list[i].strKind);
        }
    }
    return Find;
}
DR7结构体
// DR7寄存器结构体
typedef struct _DBG_REG7 {
    unsigned L0 : 1; unsigned G0 : 1;
    unsigned L1 : 1; unsigned G1 : 1;
    unsigned L2 : 1; unsigned G2 : 1;
    unsigned L3 : 1; unsigned G3 : 1;
    unsigned LE : 1; unsigned GE : 1;
    unsigned : 6;// 保留的无效空间
    unsigned RW0 : 2; unsigned LEN0 : 2;
    unsigned RW1 : 2; unsigned LEN1 : 2;
    unsigned RW2 : 2; unsigned LEN2 : 2;
    unsigned RW3 : 2; unsigned LEN3 : 2;
} R7, * PR7;
EFLAGS结构体
//EFLAGS结构体
typedef struct _EFLAGS {
    unsigned CF : 1; unsigned R1 : 1;//进位
    unsigned PF : 1; unsigned R2 : 1;//奇偶
    unsigned AF : 1; unsigned R3 : 1;//辅助进位
    unsigned ZF : 1;                 //零标志位
    unsigned SF : 1;                 //符号标志位
    unsigned TF : 1;                 //陷阱
    unsigned IF : 1;                 //中断
    unsigned DF : 1;                 //方向
    unsigned OF : 1;                 //溢出
    unsigned : 20;                   // 保留的无效空间
}EFLAGS, * PEFLAGS;
CONTEXT结构体
typedef struct DECLSPEC_NOINITALL _CONTEXT {

    

    DWORD ContextFlags;

    //
    // This section is specified/returned if CONTEXT_DEBUG_REGISTERS is
    // set in ContextFlags.  Note that CONTEXT_DEBUG_REGISTERS is NOT
    // included in CONTEXT_FULL.
    //

    DWORD   Dr0;
    DWORD   Dr1;
    DWORD   Dr2;
    DWORD   Dr3;
    DWORD   Dr6;
    DWORD   Dr7;

    //
    // This section is specified/returned if the
    // ContextFlags word contians the flag CONTEXT_FLOATING_POINT.
    //

    FLOATING_SAVE_AREA FloatSave;

    //
    // This section is specified/returned if the
    // ContextFlags word contians the flag CONTEXT_SEGMENTS.
    //

    DWORD   SegGs;
    DWORD   SegFs;
    DWORD   SegEs;
    DWORD   SegDs;

    //
    // This section is specified/returned if the
    // ContextFlags word contians the flag CONTEXT_INTEGER.
    //

    DWORD   Edi;
    DWORD   Esi;
    DWORD   Ebx;
    DWORD   Edx;
    DWORD   Ecx;
    DWORD   Eax;

    //
    // This section is specified/returned if the
    // ContextFlags word contians the flag CONTEXT_CONTROL.
    //

    DWORD   Ebp;
    DWORD   Eip;
    DWORD   SegCs;              // MUST BE SANITIZED
    DWORD   EFlags;             // MUST BE SANITIZED
    DWORD   Esp;
    DWORD   SegSs;

    //
    // This section is specified/returned if the ContextFlags word
    // contains the flag CONTEXT_EXTENDED_REGISTERS.
    // The format and contexts are processor specific
    //

    BYTE    ExtendedRegisters[MAXIMUM_SUPPORTED_EXTENSION];

} CONTEXT;


//#define CONTEXT_CONTROL         (CONTEXT_i386 | 0x00000001L) // SS:SP, CS:IP, FLAGS, BP
//#define CONTEXT_INTEGER         (CONTEXT_i386 | 0x00000002L) // AX, BX, CX, DX, SI, DI
//#define CONTEXT_SEGMENTS        (CONTEXT_i386 | 0x00000004L) // DS, ES, FS, GS
//#define CONTEXT_FLOATING_POINT  (CONTEXT_i386 | 0x00000008L) // 387 state
//#define CONTEXT_DEBUG_REGISTERS (CONTEXT_i386 | 0x00000010L) // DB 0-3,6,7
//#define CONTEXT_EXTENDED_REGISTERS  (CONTEXT_i386 | 0x00000020L) // cpu specific extensions
//
//#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER |\
//                      CONTEXT_SEGMENTS)
//
//#define CONTEXT_ALL             (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS | \
//                                 CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS | \
//                                 CONTEXT_EXTENDED_REGISTERS)
//
//#define CONTEXT_XSTATE          (CONTEXT_i386 | 0x00000040L)
调式对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3KQ8Hjb3-1616296463537)(E:/%E8%BD%AF%E4%BB%B6%E4%B8%8B%E8%BD%BD/Typora/%E5%9B%BE%E7%89%87/image-20201227124403490.png)]

余大头
关注
专栏目录
调试器的工作原理
05-19 1518
调试器的工作原理《黑客调试技术揭秘》  理解调试器的工作原理  对调试器的工作原理毫无所知就贸
调试器工作原理（译）
Kemin | 本博客独立到nakeman.cn
09-28 3266
调试器工作原理《How Debuggers Work》http://www.douban.com/subject/1970421/刘建文略译（http://blog.csdn.net/keminlau） 作者: Jonathan B. Rosenberg 副标题: Algorithms, Data Structures, and Architecture
调试器——原理篇
高毅的博客
06-02 1535
在本文中将介绍基于软断点的调试器的工作原理。本人是做Java开发的，由于对Python在安全方面感兴趣，特意对Python在构建调试器方面进行了研究与探索。 下面介绍的调试器原理是通用的。一般的调试器会提供三种类型的断点：软断点、硬件断点和内存断点。我重点对基于软断点的调试原理进行了研究。软断点是在调试应用程序时最为常用的断点。 软断点的实现是基于单字长指令的，该指令能中断进程的执行，并产生中
调试器的原理
南宫封清的博客
11-05 939
软件断点 int3指令 机器码为1字节，即0xCC 没有数量限制 局限性 属于代码类断点，即可以让CPU执行到代码段内的某个地址时停下来，不适用于数据段和I/O空间 对于在ROM（只读存储器）中执行的程序（比如BIOS或者其他固件程序），无法动态增加软件断点。因为目标内存是只读的无法动态写入断点指令。这时就要使用我们后面要介绍的硬件断点。 实验 是用windbg给MessageBoxW下断点，windbg只有在程序运行的时候才会把断点的地方改为int3 0:011> u user32!Mess
Android虚拟机调试器原理与实现
02-25
本文主要讲解Android虚拟机动态调试背后涉及到的技术原理，除了JDWP协议细节，还包括任意位置断点、堆栈输出、变量值获取等基础调试功能的具体实现。另外本文提供了一款新的android动态调试工具——AVMDBG，提供调试...
xds100v3调试器原理图完整版
10-28
### XDS100v3调试器原理图完整版知识点解析 #### 一、XDS100v3调试器概述 XDS100v3是一款高性能的JTAG/SWD调试器，专为德州仪器（TI）的微控制器和其他支持JTAG/SWD协议的处理器设计。它通过USB接口与PC连接，提供...
CloseHandle反调试_检测调试器原理
03-02
本篇主要探讨"CloseHandle反调试"和"检测调试器原理"。 首先，我们来理解"CloseHandle"函数。在Windows API中，`CloseHandle`是一个用于关闭系统对象句柄的关键函数。它接收一个句柄作为参数，如果该句柄是有效的，...
安卓调试器原理与实现1
08-08
总之，Android 调试器的原理与实现涉及到了 JDWP 协议的深入理解和应用，以及各种调试工具的特性分析。开发者需要根据项目需求和自身技术栈选择合适的调试方案，以提高调试效率和质量。通过理解 JDWP 协议的工作机制...
Debug调试器的工作原理
01-12
介绍Debug调试器的工作原理，重点介绍了Windows Debug API，不可多得的材料。-Debug debugging on the working principle, focus on the Windows Debug API, a rare material.
调试器的工作原理（一）：基础篇
最新发布
Free雅轩的博客
07-22 289
回到例子中，一旦我们在 regs 变量中取得了寄存器的值，我们就可以通过将 PTRACE_PEEKTEXT 作为参数、 regs.eip（x86 上的扩展指令指针）作为地址，调用 ptrace ，读取当前进程的当前指令（警告：如同我上面所说，文章很大程度上是平台相关的。意味着该进程被其父进程跟踪。这是一种复杂却强大的工具，可以允许一个进程控制另外一个进程并从内部替换Peek and poke被控制进程的内核镜像的值（Peek and poke 在系统编程中是很知名的叫法，指的是直接读写内存内容）。
调试原理机制
fa1c4的blog
03-09 392
其实非常简单, 对一个架构而言, 有一条表示断点的指令, 比如IA-32中是0xCC 执行程序时, 代码指令会放入内存, 为了实现断点, 只需要找到需要打断点的指令的起始地址, 把该地址的任意一个字节改成0xCC(IA-32架构下), 程序执行到该指令时就会中断. 为了恢复执行, 只需把指令恢复原值即可. ...
调试器原理_调试器的工作原理
cuml0912的博客
06-29 945
调试器原理 调试器是大多数（如果不是每种）开发人员在软件工程生涯中至少使用一次的软件之一，但是你们当中有多少人知道它们的实际工作原理？ 在悉尼举行的linux.conf.au 2018上的演讲中，我将谈论从头开始编写调试器...在Rust中 ！ 在本文中，术语调试器/跟踪器是可互换的。 “跟踪”是指跟踪程序正在跟踪的进程。 ptrace系统调用 大多数调试器严重依赖于称为ptrace...
调试基础知识及原理
u012117034的博客
06-13 1664
个可调试的可执行文件。我个人觉得里面的内容可以分为3个部分。 1，机器码。C/C++ 转成的机器码 2，符号表信息（symbols） 3，调试信息（debug info） 无论是 Linux 的GDB，还是 Windows 的 WinDbg 跟 VsDebug，都是根据上面这些信息来进行调试的。...
调试器工作原理之二——实现断点(ptrace)
weixin_33895016的博客
08-31 1672
本文是关于调试器工作原理探究系列的第二篇。在开始阅读本文前，请先确保你已经读过本系列的第一篇（基础篇）。 本文的主要内容 这里我将说明调试器中的断点机制是如何实现的。断点机制是调试器的两大主要支柱之一 ——另一个是在被调试进程的内存空间中查看变量的值。我们已经在第一篇文章中稍微涉及到了一些监视被调试进程的知识，但断点机制仍然还是个迷。阅读完本文之后，这将不再是什么秘密了。...
调试器工作原理——基础篇
老程序员专栏
09-05 990
#include int main() { printf(“Hello, world!n”); return 0; } 本文是一系列探究调试器工作原理的文章的第一篇。我还不确定这个系列需要包括多少篇文章以及它们所涵盖的主题，但我打算从基础知识开始说起。 关于本文 我打算在这篇文章中介绍关于Linux下的调试器实现的主要组成部分——ptrace系统调用。本文中出现的代码都在
程序调试器原理
wjgit的专栏
07-06 1331
调试器原理： 调试器是一个程序，在开发工具中也是调用一个程序，在运行时就是一个进程，这个进程与普通进程没有区别，只是这个进程调用了内核的一些特殊函数（系统调用）来操纵内核数据，这些数据就是被调试进程的内存数据。 而对操作系统调试的调试器则不同，因为没有操作系统的支持，调试器本身就不再需要调用操作系统内核的程序来支持，但是此时的调试非常特殊，因为操作系统自己有中断处理程序，调试器对中断服务程序的劫持会让操作系统的操作变得有些不同，调试器首先启动先设置CPU为单步执行状态，然后启动操作系统...
调试器工作原理之三——调试信息
老程序员专栏
09-05 2153
试器工作原理探究系列的第三篇，在阅读前请先确保已经读过本系列的第一和第二篇。 本篇主要内容 在本文中我将向大家解释关于调试器是如何在机器码中寻找C函数以及变量的，以及调试器使用了何种数据能够在C源代码的行号和机器码中来回映射。 调试信息 现代的编译器在转换高级语言程序代码上做得十分出色，能够将源代码中漂亮的缩进、嵌套的控制结构以及任意类型的变量全都转化为一长串的比特流——这就是机器码。这么
Windbg调试器原理探索：从简单分析到实战
"本文主要分析了windbg调试器的工作原理，包括分析原因、使用的工具与资源、windbg调试原理简介、ReactOS源码剖析、Windbg命令实战以及总结。作者在调试过程中遇到的一个问题引发了对windbg调试机制的探索，通过使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值