debuger！

#include <windows.h>
#include <string>
#include <iostream>

using namespace std;

/*先声明一些Debug消息处理函数供调用*/
void OnProcessCreated(const CREATE_PROCESS_DEBUG_INFO*);
void OnThreadCreated(const CREATE_THREAD_DEBUG_INFO*);
void OnException(const EXCEPTION_DEBUG_INFO*);
void OnProcessExited(const EXIT_PROCESS_DEBUG_INFO*);
void OnThreadExited(const EXIT_THREAD_DEBUG_INFO*);
void OnOutputDebugString(const OUTPUT_DEBUG_STRING_INFO*);
void OnRipEvent(const RIP_INFO*);
void OnDllLoaded(const LOAD_DLL_DEBUG_INFO*);
void OnDllUnloaded(const UNLOAD_DLL_DEBUG_INFO*);


void main()
{
    //定义两个结构供api填值
    STARTUPINFO    si={0};
    
    PROCESS_INFORMATION pi = { 0 };
    
    if (!CreateProcess(
        TEXT("C:\windows\notepad.exe"), //打开的程序名称，这里用TEXT宏包含了一下
        NULL,
        NULL,
        NULL,
        FALSE,
        DEBUG_ONLY_THIS_PROCESS|CREATE_NEW_CONSOLE,//只调试当前进程
        NULL,
        NULL,    //当前目录
        &si,    //启动信息
        &pi))    //进程信息
    {
        std::cout<<GetLastError()<<endl;
        return;
    }
    
    BOOL waitEvent = TRUE;
    
    DEBUG_EVENT debugEvent;
    while (waitEvent == TRUE && WaitForDebugEvent(&debugEvent, INFINITE)) {
        //WaitForDebugEvent接收OS的调试消息事件
        switch (debugEvent.dwDebugEventCode) {
            
        case CREATE_PROCESS_DEBUG_EVENT:
            OnProcessCreated(&debugEvent.u.CreateProcessInfo);
            break;
            
        case CREATE_THREAD_DEBUG_EVENT:
            OnThreadCreated(&debugEvent.u.CreateThread);
            break;
            
        case EXCEPTION_DEBUG_EVENT:
            OnException(&debugEvent.u.Exception);
            break;
            
        case EXIT_PROCESS_DEBUG_EVENT:
            OnProcessExited(&debugEvent.u.ExitProcess);
//要注意这里是如何退出循环的：引入一个BOOL类型的waitEvent变量，在处理EXIT_PROCESS_DEBUG_EVENT之后将它的值改成FALSE
            waitEvent = FALSE;
            break;
            
        case EXIT_THREAD_DEBUG_EVENT:
            OnThreadExited(&debugEvent.u.ExitThread);
            break;
            
        case LOAD_DLL_DEBUG_EVENT:
            OnDllLoaded(&debugEvent.u.LoadDll);
            break;
            
        case UNLOAD_DLL_DEBUG_EVENT:
            OnDllUnloaded(&debugEvent.u.UnloadDll);
            break;
            
        case OUTPUT_DEBUG_STRING_EVENT:
            OnOutputDebugString(&debugEvent.u.DebugString);
            break;
            
        case RIP_EVENT:
            OnRipEvent(&debugEvent.u.RipInfo);
            break;
            
        default:
            std::cout << TEXT("Unknown debug event.") << std::endl;
            break;
        }
        
        if (waitEvent == TRUE) {
            ContinueDebugEvent(debugEvent.dwProcessId, debugEvent.dwThreadId, DBG_CONTINUE);
        }
        else {
            break;//waitEvent != TRUE 时退出循环
        }
    }

}

void OnProcessCreated(const CREATE_PROCESS_DEBUG_INFO* pInfo) {
    
    std::cout<<TEXT("Debuggee was created.")<<endl;
}



void OnThreadCreated(const CREATE_THREAD_DEBUG_INFO* pInfo) {
    
    std::cout<<TEXT("A new thread was created.")<<endl;
}



void OnException(const EXCEPTION_DEBUG_INFO* pInfo) {
    
    std::cout<< TEXT("An exception was occured.")<<endl;
}



void OnProcessExited(const EXIT_PROCESS_DEBUG_INFO* pInfo) {
    
    std::cout<<TEXT("Debuggee was terminated.")<<endl;
}



void OnThreadExited(const EXIT_THREAD_DEBUG_INFO* pInfo) {
    
    std::cout<<TEXT("A thread was terminated.")<<endl;
}



void OnOutputDebugString(const OUTPUT_DEBUG_STRING_INFO* pInfo) {
    
    std::cout<<TEXT("Debuggee outputed debug string.")<<endl;
}



void OnRipEvent(const RIP_INFO* pInfo) {
    
    std::cout<<TEXT("A RIP_EVENT occured.")<<endl;
}



void OnDllLoaded(const LOAD_DLL_DEBUG_INFO* pInfo) {
    
    std::cout<<TEXT("A dll was loaded.")<<endl;
}



void OnDllUnloaded(const UNLOAD_DLL_DEBUG_INFO* pInfo) {
    
    std::cout<<TEXT("A dll was unloaded.")<<endl;
}

typedef struct _DEBUG_EVENT {
  DWORD dwDebugEventCode;　　　　　　　　//从这确定union联合域内是什么内容
  DWORD dwProcessId;　　　　　　　　　　　//PID
  DWORD dwThreadId;　　　　　　　　　　　 //线程ID
  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;
//然后从各种event_info_struct中取得调试信息

 --各种事件的处理--------------------------------------

RIP_EVENT

关于这种调试事件的文档资料非常少，只要输出一条信息或者干脆忽略它即可。

OUTPUT_DEBUG_STRING_EVENT

当被调试进程调用OutputDebugString()时就会引发该类调试事件，OUTPUT_DEBUG_STRING_INFO结构体描述了关于该事件的详细信息。

typedef struct _OUTPUT_DEBUG_STRING_INFO {
  LPSTR lpDebugStringData;　　  //字符串在被调试进程的进程空间内的地址
  WORD  fUnicode;              //是否Unicode编码
  WORD  nDebugStringLength;    //以字符为单位的字符串的长度
} OUTPUT_DEBUG_STRING_INFO, *LPOUTPUT_DEBUG_STRING_INFO;
    

字符串是在被调试进程的地址空间内，我们就要使用ReadProcessMemory函数读取这个字符串。下面的代码展示了这个过程：

void OnOutputDebugString(const OUTPUT_DEBUG_STRING_INFO* pInfo) {
    
    BYTE* pBuffer = (BYTE*)malloc(pInfo->nDebugStringLength);//申请的大小刚好
    
    SIZE_T bytesRead;    //读取的字数
    
    ReadProcessMemory(    //读入buffer
        g_hProcess,　　　　//g_hProcess==pi.hProcess;
        pInfo->lpDebugStringData,
        pBuffer, 
        pInfo->nDebugStringLength,
        &bytesRead);
    
    std::cout << TEXT("Debugger debug string: ") << pBuffer <<  std::endl;
    
    free(pBuffer);
}

----------------读取寄存器和内存（OD的寄存器窗口和数据窗口）--------------------

获取寄存器的值

每个线程都有一个上下文环境（context），它包含了有关线程的大部分信息，例如线程栈的地址，线程当前正在执行的指令地址等。上下文环境保存在寄存器中，系统进行线程调度的时候会发生上下文切换，实际上就是将一个线程的上下文环境保存到内存中，然后将另一个线程的上下文环境装入寄存器。

在实际上下文中谈CONTEXT结构
CONTEXT结构包括以下部分：

 　　CONTEXT_CONTROL:包含CPU的控制寄存器,比如指今指针,堆栈指针,标志和函数返回地址..AX, BX, CX, DX, SI, DI
  　  CONTEXT_INTEGER:用于标识CPU的整数寄存器.DS, ES, FS, GS
 　　CONTEXT_FLOATING_POINT:用于标识CPU的浮点寄存器.
  　  CONTEXT_SEGMENTS:用于标识CPU的段寄存器.SS:SP, CS:IP, FLAGS, BP
 　　CONTEXT_DEBUG_REGISTER:用于标识CPU的调试寄存器.  
 　　CONTEXT_EXTENDED_REGISTERS:用于标识CPU的扩展寄存器I
 　　CONTEXT_FULL:相当于CONTEXT_CONTROL or CONTEXT_INTEGER or   CONTEXT_SEGMENTS,即这三个标志的组合

我们可以使用GetThreadContext函数来查看线程内核对象的内部，并获取当前CPU寄存器状态的集合。

BOOL GetThreadContext (

HANDLE  hThread,

PCONTEXT  pContext)；

若要调用该函数，只需指定一个CONTEXT结构，对某些标志（该结构的ContextFlags成员）进行初始化，指明想要收回哪些寄存器，并将该结构的地址传递给GetThreadContext 。然后该函数将数据填入你要求的成员。

在调用GetThreadContext函数之前，应该调用SuspendThread，否则，线程可能刚好被调度，这样一来，线程的上下文就和所获取的信息不一致了。

示例代码如下： 

         CONTEXT Context;　　　　　　　　　　　　　　　　  //定义一个CONTEXT结构

         Context.ContextFlags = CONTEXT_CONTROL;　　  //告诉系统我们想获取线程控制寄存器的内容   

         GetThreadContext(hThread, &Context);　　　　　　//调用GetThreadContext获取相关信息

Ps：在调用GetThreadContext函数之前，必须首先初始化CONTEXT结构的ContextFlags成员。

要获得线程的所有重要的寄存器(也就是微软认为最常用的寄存器)，应该像下面一样初始化ContextFlags：

Context.ContextFlags = CONTEXT_FULL;

在WinNT. h头文件中，定义了CONTEXT_FULL为CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS。

当然，我们还可以通过调用SetThreadContext函数来改变结构中的成员，并把新的寄存器值放回线程的内核对象中

BOOL SetThreadContext (

HANDLE  hThread,

CONST CONTEXT  *pContext)；

同样，如果要改变哪个线程的上下文，应该先暂停该线程。       

         CONTEXT Context;　　　　　　//定义一个CONTEXT结构      

         SuspendThread(hThread);　　//挂起线程  

         Context.ContextFlags = CONTEXT_CONTROL;　　 //获取当前上下文的值

         GetThreadContext(hThread, &Context);

         Context.Eip = 0x00010000;　　　　　　//Eip字段存储的是指令指针，现在让指令指针指向地址 0x00010000；

         Context.ContextFlags = CONTEXT_CONTROL;

         SetThreadContext(hThread, &Context); 　　//重新设置线程上下文

         ResumeThread(hThread);         //恢复线程，现在线程开始从0x00010000这个地方开始执行指令