API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 18th, 2017
374
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 18.19 KB | None | 0 0
raw download clone embed print report
  1.     class CSDWin32 : public CX86Debugger
  2.     {
  3.         ALT::TString<char,0,8> m_ProcessFileName;
  4.         std::map<unsigned long, HANDLE> m_ThreadIdMap;
  5.         unsigned long m_dwThreadId;
  6.  
  7.         HANDLE m_hDbgThread;
  8.         HANDLE m_hProcess;
  9.         unsigned long m_dwCurentProcessId;
  10.         CONTEXT m_Context;
  11.         unsigned long m_ExceptionAddress;
  12.         HANDLE m_hDbgEvent;
  13.         bool m_bSuspend;
  14.         bool m_Terminate;
  15.         bool m_Attached;
  16.  
  17.         unsigned long m_StepCount;
  18.  
  19.     public:
  20.         CSDWin32();
  21.         virtual ~CSDWin32();
  22.  
  23.         bool InsertHandle(unsigned long dwThreadId, HANDLE hThread);
  24.         bool RemoveHandle(unsigned long dwThreadId);
  25.  
  26.         bool DebugException(unsigned int Type);
  27.  
  28.         bool ReadPE(unsigned long BaseAddress, PE_HEAD *pPEHead);
  29.         unsigned int ProcessDebugEvent(DEBUG_EVENT *pEvent);
  30.         static unsigned int ThreadProc(void *pData);
  31.  
  32.         virtual void Release();
  33.         virtual bool Open(const char *Name);
  34.         virtual bool Close();
  35.  
  36.         virtual unsigned long WriteMemory(unsigned long Address, void *Buffer, unsigned long Size);
  37.         virtual unsigned long ReadMemory(unsigned long Address, void *Buffer, unsigned long Size);
  38.  
  39.         bool SaveRegisters(unsigned long dwThreadId);
  40.         bool UpdateRegisters(unsigned long dwThreadId);
  41.         bool StepBack();
  42.  
  43.         virtual bool SaveRegisters();
  44.         virtual bool UpdateRegisters();
  45.  
  46.         virtual bool SetHWCodeBreakPoint(const BREAK_POINT & BP);
  47.         virtual bool ClearHWCodeBreakPoint(const BREAK_POINT & BP);
  48.         virtual bool SetHWDataBreakPoint(const BREAK_POINT & BP);
  49.         virtual bool ClearHWDataBreakPoint(const BREAK_POINT & BP);
  50.  
  51.         virtual bool SetSingleStep();
  52.         virtual bool RemoveSingleStep();
  53.         virtual bool ContinueDebug(int);
  54.  
  55.         virtual void GetX86RegPtr(X86_CPU_REG_PTR *pCPURegPtr);
  56.         virtual void GetX86RegPtr(X86_CPU_REG_PTR *pCPURegPtr, int nCPU);
  57.  
  58.         virtual bool GetSegBase(unsigned long Base, unsigned long *pAddress, unsigned long *pBits);
  59.     };
  60.  
  61.     export void GetFileFilter(char *Filter);
  62.     export void GetInfo(char *pInfo);
  63.     export void *CreateDebugger(CSyserUI *pSyserUI)
  64.  
  65. ///////
  66.  
  67.         CSDWin32::CSDWin32()
  68.         {
  69.             m_dwCurentProcessId = GetCurrentProcess();
  70.             m_bSuspend = false;
  71.             m_Terminate = false;
  72.             m_hProcess = 0;
  73.             m_pEIP = &m_Context._Eip;
  74.  
  75.         }
  76.  
  77.         CSDWin32::~CSDWin32()
  78.         {
  79.         }
  80.  
  81.         bool CSDWin32::Open(const char *Name)
  82.         {
  83.             if (!(gpLocalFileIO->IsFileExist(Name) && TStrNICmp(Name, "\\PID:", 5))
  84.                 return 0;
  85.  
  86.             if (!CDebugger::Open(Name))
  87.                 return 0;
  88.  
  89.             unsigned long ThreadId;
  90.  
  91.             m_ProcessFileName.Set(Name);
  92.             m_hDbgEvent = CreateEventA(0, 0, 0, 0);
  93.             m_hDbgThread = CreateThread(0, 0,
  94.                 (LPTHREAD_START_ROUTINE)CSDWin32::ThreadProc, this, 0, (LPDWORD)&ThreadId);
  95.  
  96.             if (!m_hDbgThread)
  97.             {
  98.                 CloseHandle(m_hDbgEvent);
  99.                 CDebugger::Close();
  100.                 return false;
  101.             }
  102.  
  103.             WaitForSingleObject(m_hDbgEvent, 0xFFFFFFFF);
  104.             if (!m_dwProcessId)
  105.             {
  106.                 CloseHandle(m_hDbgEvent);
  107.                 CDebugger::Close();
  108.                 return false;
  109.             }
  110.             return true;
  111.         }
  112.  
  113.         bool CSDWin32::Close()
  114.         {
  115.             if (!m_hProcess)
  116.                 return CDebugger::Close();
  117.  
  118.             CloseHandle(m_hProcess);
  119.             m_hProcess = OpenProcess(1, 0, m_dwProcessId);
  120.             if (!TerminateProcess(m_hProcess, 0))
  121.                 return false;
  122.  
  123.             CloseHandle(m_hProcess);
  124.             m_hProcess = 0;
  125.             m_Terminate = true;
  126.             ContinueDebug(1);
  127.             CloseHandle(m_hDbgEvent);
  128.             return CDebugger::Close();
  129.         }
  130.  
  131.         void CSDWin32::Release()
  132.         {
  133.             CDebugger::Release();
  134.             delete this;
  135.         }
  136.  
  137.         bool CSDWin32::InsertHandle(unsigned long dwThreadId, HANDLE hThread)
  138.         {
  139.             std::pair<std::map<unsigned long, HANDLE>::iterator, bool> ret =
  140.                 m_ThreadIdMap.insert(std::pair<unsigned long, HANDLE>(dwThreadId,0));
  141.  
  142.             if (ret.second == false)
  143.                 return false;
  144.  
  145.               return DuplicateHandle(m_dwCurentProcessId, hThreadId, m_dwCurentProcessId,
  146.                     &ret.first->second, 0x5A, 0, 0) != 0;
  147.  
  148.             //  PROCESS_DUP_HANDLE //0x40
  149.             //  PROCESS_VM_READ //0x10
  150.             //  PROCESS_VM_OPERATION //0x08
  151.             //  PROCESS_CREATE_THREAD //0x02
  152.  
  153.         }
  154.  
  155.         bool CSDWin32::RemoveHandle(unsigned long dwThreadId)
  156.         {
  157.             return m_ThreadIdMap.erase(dwThreadId) != 0;
  158.         }
  159.  
  160.         void CSDWin32::DebugException(unsigned int Type)
  161.         {
  162.             m_pDebugInterface->OnDebugException(Type);
  163.         }
  164.  
  165.         bool CSDWin32::SaveRegisters(unsigned long dwThreadId)
  166.         {
  167.             std::map<unsigned long, HANDLE>::iterator It = m_ThreadIdMap.find(dwThreadId);
  168.             if (It == m_ThreadIdMap.end())
  169.                 return false;
  170.  
  171.               m_Context.ContextFlags = CONTEXT_i386 |       //0x10000
  172.                     CONTEXT_DEBUG_REGISTERS |   //0x00010
  173.                     CONTEXT_EXTENDED_REGISTERS |    //0x00020
  174.                         CONTEXT_SEGMENTS |  //0x00004
  175.                         CONTEXT_INTEGER |   //0x00002
  176.                         CONTEXT_CONTROL;    //0x00001 //0x1003F;
  177.  
  178.             return GetThreadContext(It->second, &m_Context) != 0;
  179.         }
  180.  
  181.         bool CSDWin32::UpdateRegisters(unsigned long dwThreadId)
  182.         {
  183.             std::map<unsigned long, HANDLE>::iterator It = m_ThreadIdMap.find(dwThreadId);
  184.             if (It == m_ThreadIdMap.end())
  185.                 return false;
  186.  
  187.               m_Context.ContextFlags = CONTEXT_i386 |   //0x10000
  188.                         CONTEXT_CONTROL |   //0x00001
  189.                         CONTEXT_INTEGER |   //0x00002
  190.                         CONTEXT_SEGMENTS |  //0x00004
  191.                         CONTEXT_DEBUG_REGISTERS; //0x00010 //0x10017;
  192.  
  193.             return SetThreadContext(It->second, &m_Context) != 0;
  194.         }
  195.  
  196.         bool CSDWin32::StepBack()
  197.         {
  198.             if (!SaveRegisters(dwTheadId))
  199.                 return false;
  200.  
  201.             --m_Context._Eip;
  202.  
  203.             return UpdateRegisters(dwTheadId) != 0;
  204.         }
  205.  
  206.         unsigned long CSDWin32::WriteMemory(unsigned long Address, void *Buffer, unsigned long Size)
  207.         {
  208.             unsigned int WRSize = 0;
  209.  
  210.             if (!WriteProcessMemory(m_hProcess, Address, Buffer, Size, (SIZE_T *)&WRSize))
  211.                 return 0;
  212.             return WRSize;
  213.         }
  214.  
  215.         unsigned long CSDWin32::ReadMemory(unsigned long Address, void *Buffer, unsigned long Size)
  216.         {
  217.             unsigned int RDSize = 0;
  218.  
  219.             if (!ReadProcessMemory(m_hProcess, Address, Buffer, Size, (SIZE_T *)&RDSize))
  220.                 return 0;
  221.             return RDSize;
  222.         }
  223.  
  224.  
  225.         bool CSDWin32::SetHWCodeBreakPoint(const BREAK_POINT & BP)
  226.         {
  227.             return SetLowCodeBreakPoint(BP);
  228.         }
  229.  
  230.         bool CSDWin32::ClearHWCodeBreakPoint(const BREAK_POINT & BP)
  231.         {
  232.             return ClearLowCodeBreakPoint(BP);
  233.         }
  234.  
  235.         bool CSDWin32::SetHWDataBreakPoint(const BREAK_POINT & BP)
  236.         {
  237.             return SetLowDataBreakPoint(BP, &m_Context.Dr0, &m_Context.Dr7);
  238.         }
  239.  
  240.         bool CSDWin32::ClearHWDataBreakPoint(const BREAK_POINT & BP)
  241.         {
  242.             return ClearLowDataBreakPoint(BP, &m_Context.Dr0, &m_Context.Dr7);
  243.  
  244.         }
  245.  
  246.         bool CSDWin32::SetSingleStep()
  247.         {
  248.             CONTEXT regs;
  249.  
  250.             std::map<unsigned long, HANDLE>::iterator It = m_ThreadIdMap.begin();
  251.             for (; It != m_ThreadIdMap.end(); ++It)
  252.             {
  253.                 regs.ContextFlags = 0x10007;
  254.                 if (GetThreadContext(It->second, &regs))
  255.                 {
  256.                     regs.EFlags |= 0x100;
  257.                     regs.ContextFlags = 0x10007;
  258.                     if (!SetThreadContext(It->second, &regs))
  259.                     {
  260.                         //TODO
  261.                     }
  262.                 }
  263.             }
  264.             return true;
  265.         }
  266.  
  267.         bool CSDWin32::RemoveSingleStep()
  268.         {
  269.             CONTEXT regs;
  270.  
  271.             std::map<unsigned long, HANDLE>::iterator It = m_ThreadIdMap.begin();
  272.             for (; It != m_ThreadIdMap.end(); ++It)
  273.             {
  274.                 regs.ContextFlags = 0x10007;
  275.                 if (GetThreadContext(It->second, &regs))
  276.                 {
  277.                     regs.EFlags &= ~0x100;
  278.                     regs.ContextFlags = 0x10007;
  279.                     if (!SetThreadContext(It->second, &regs))
  280.                     {
  281.                         //TODO
  282.                     }
  283.                 }
  284.             }
  285.             return true;
  286.         }
  287.  
  288.         bool CSDWin32::SaveRegisters()
  289.         {
  290.             return SaveRegisters(m_dwThreadId);
  291.         }
  292.  
  293.         bool CSDWin32::UpdateRegisters()
  294.         {
  295.             return UpdateRegisters(m_dwThreadId);
  296.         }
  297.  
  298.         bool CSDWin32::ContinueDebug(int);
  299.         {
  300.             return ResumeThread(m_hDbgThread) != 0;
  301.         }
  302.  
  303.  
  304.         void CSDWin32::GetX86RegPtr(X86_CPU_REG_PTR *pCPURegPtr, int nCPU)
  305.         {
  306.             GetX86RegPtr(pCPURegPtr);
  307.         }
  308.  
  309.         void CSDWin32::GetX86RegPtr(X86_CPU_REG_PTR *pCPURegPtr)
  310.         {
  311.             pCPURegPtr->pCS = &m_Context.SegCs;
  312.             pCPURegPtr->pDS = &m_Context.SegDs;
  313.             pCPURegPtr->pES = &m_Context.SegEs;
  314.             pCPURegPtr->pFS = &m_Context.SegFs;
  315.             pCPURegPtr->pGS = &m_Context.SegGs;
  316.             pCPURegPtr->pSS = &m_Context.SegSs;
  317.             pCPURegPtr->pEAX = &m_Context.Eax;
  318.             pCPURegPtr->pEBX = &m_Context.Ebx;
  319.             pCPURegPtr->pECX = &m_Context.Ecx;
  320.             pCPURegPtr->pEDX = &m_Context.Edx;
  321.             pCPURegPtr->pESI = &m_Context.Esi;
  322.             pCPURegPtr->pEDI = &m_Context.Edi;
  323.             pCPURegPtr->pEBP = &m_Context.Ebp;
  324.             pCPURegPtr->pESP = &m_Context.Esp;
  325.             pCPURegPtr->pEFL = &m_Context.EFlags;
  326.             pCPURegPtr->pEIP = &m_Context.Eip;
  327.             pCPURegPtr->pDR0 = &m_Context.Dr0;
  328.             pCPURegPtr->pDR1 = &m_Context.Dr1;
  329.             pCPURegPtr->pDR2 = &m_Context.Dr2;
  330.             pCPURegPtr->pDR3 = &m_Context.Dr3;
  331.             pCPURegPtr->pDR4 = 0;
  332.             pCPURegPtr->pDR5 = 0;
  333.             pCPURegPtr->pDR6 = &m_Context.Dr6;
  334.             pCPURegPtr->pDR7 = &m_Context.Dr7;
  335.         }
  336.  
  337.  
  338.  
  339.         bool CSDWin32::GetSegBase(unsigned long Selector, unsigned long *pAddress, unsigned long *pBits);
  340.         {
  341.             LDT_ENTRY ldt_entry;
  342.  
  343.             std::map<unsigned long, HANDLE>::iterator It = m_ThreadIdMap.find(dwThreadId);
  344.             if (It == m_ThreadIdMap.end())
  345.                 return false;
  346.  
  347.             unsigned int Result = GetThreadSelectorEntry(It->second, Selector, &ldt_entry);
  348.             if (Result)
  349.             {
  350.                 if (pAddress)
  351.                 {
  352.                     *pAddress = ldt_entry.HighWord.Bytes.BaseHi << 24;
  353.                     *pAddress |= ldt_entry.HighWord.Bytes.BaseMid << 16;
  354.                     *pAddress |= ldt_entry.BaseLow;
  355.                 }
  356.                 if (pBits) //???
  357.                     *pBits = ((unsigned __int32)ldt_entry.HighWord.Bits._bf0 >> 16) & 0xF;
  358.             }
  359.             return Result == 1;
  360.         }
  361.  
  362.         bool CSDWin32::ReadPE(unsigned long BaseAddress, PE_HEAD *pPEHead)
  363.         {
  364.             unsigned int Offset;
  365.  
  366.             memset(pPEHead, 0, sizeof(PE_HEAD));
  367.  
  368.             if (ReadMemory(BaseAddress + 0x3C, &Offset, 4) != 4)
  369.                 return false;
  370.  
  371.             if (ReadMemory(Offset + BaseAddress, pPEHead, sizeof(PE_HEAD)) != sizeof(PE_HEAD))
  372.                 return false;
  373.  
  374.             return pPEHead->Signature == 0x4550;
  375.         }
  376.  
  377.         unsigned int CSDWin32::ThreadProc(void *pData)
  378.         {
  379.             CSDWin32 *p = (CSDWin32*)pData;
  380.            
  381.             unsigned long continueStatus;
  382.  
  383.             continueStatus = 0;
  384.  
  385.             p->m_Terminate = 0;
  386.             p->m_dwProcessId = 0;
  387.  
  388.             if (TStrStr(p->m_ProcessFileName.cstr(), "\\PID:"))
  389.             {
  390.                 sscanf(p->m_ProcessFileName.cstr(), "\\PID:%08X", p->m_dwProcessId);
  391.                 if (!DebugActiveProcess(p->m_dwProcessId))
  392.                 {
  393.                     SetEvent(p->m_hDbgEvent);
  394.                     return 0;
  395.                 }
  396.                 p->m_hProcess = OpenProcess(0x1FFFFF, 0, p->m_dwProcessId);
  397.                 if (!p->m_hProcess)
  398.                 {
  399.                     p->m_dwProcessId = 0;
  400.                     SetEvent(p->m_hDbgEvent);
  401.                     return 0;
  402.                 }
  403.                 p->m_Attached = 1;
  404.             } else
  405.             {
  406.                 _STARTUPINFOA startup_info;
  407.                 memset(&startup_info, 0, sizeof(_STARTUPINFOA));
  408.                 startup_info.cb = sizeof(_STARTUPINFOA);
  409.  
  410.                 PROCESS_INFORMATION process_info;
  411.  
  412.                 if (!CreateProcessA(p->m_ProcessFileName.cstr(), 0, 0, 0, 1, 0x21, 0, 0, &startup_info, &process_info))
  413.                 {
  414.                     SetEvent(p->m_hDbgEvent);
  415.                     return 0;
  416.                 }
  417.                 p->m_dwProcessId = process_info.dwProcessId;
  418.                 p->m_hProcess = process_info.hProcess;
  419.                 p->m_Attached = 0;
  420.             }
  421.  
  422.             p->m_MainModuleName.Set(TGetFileName(p->m_ProcessFileName.cstr()));
  423.             p->m_bSuspend = 0;
  424.             memset(&m_Context, 0, sizeof(CONTEXT));
  425.  
  426.             PE_HEAD pe_head;
  427.             char AnsiBuffer[264];
  428.             char DirName[264];
  429.             short UnicodeBuffer[262];
  430.  
  431.             DEBUG_EVENT dbg_event;
  432.  
  433.             while (!p->m_Terminate && WaitForDebugEvent(&dbg_event, 0xFFFFFFFF))
  434.             {
  435.                 unsigned int continueStatus = DBG_CONTINUE;
  436.  
  437.                 switch (dbg_event.dwDebugEventCode)
  438.                 {
  439.                 case EXCEPTION_DEBUG_EVENT:
  440.                     continueStatus = p->ProcessDebug(&dbg_event);
  441.                     break;
  442.  
  443.                 case CREATE_THREAD_DEBUG_EVENT:
  444.                     p->InsertHandle(dbg_event.dwThreadId, dbg_event.u.CreateThread.hThread);
  445.                     break;
  446.  
  447.                 case CREATE_PROCESS_DEBUG_EVENT:
  448.                     p->m_StepCount = 0;
  449.                     p->InsertHandle(dbg_event.dwThreadId, dbg_event.u.CreateProcessInfo.hThread);
  450.  
  451.                     if (!p->m_Attached)
  452.                         p->CodeGetBP(dbg_event.u.CreateProcessInfo.lpStartAddress, 0x200, 1);
  453.  
  454.                     p->ReadPE(dbg_event.u.CreateProcessInfo.lpBaseOfImage, &pe_head);
  455.  
  456.  
  457.                     p->m_pDebugInterface->LoadModule(p, p->m_ProcessFileName.cstr(),
  458.                         dbg_ev.u.CreateProcessInfo.lpBaseOfImage,
  459.                         pe_head.SizeOfImage,
  460.                         pe_head.CheckSum,
  461.                         pe_head.TimeDateStamp);
  462.                     break;
  463.  
  464.                 case EXIT_THREAD_DEBUG_EVENT:
  465.                     p->RemoveHandle(dbg_event.dwThreadId);
  466.                     break;
  467.  
  468.                 case EXIT_PROCESS_DEBUG_EVENT:
  469.  
  470.                     p->CodeDelAllBP(0, 0);
  471.  
  472.                     sprintf(AnsiBuffer, "Debug Event : Process Terminated , Exit Code = %d (0x%X) !\n",
  473.                         dbg_event.u.ExitProcess.dwExitCode,
  474.                         dbg_event.u.ExitProcess.dwExitCode);
  475.  
  476.                     p->m_pDebugInterface->DisplayMsg(AnsiBuffer);
  477.                     p->m_pDebugInterface->OnExit(1);
  478.                     p->m_Terminate = false;
  479.                     break;
  480.  
  481.                 case LOAD_DLL_DEBUG_EVENT: //6:
  482.  
  483.                     if (dbg_event.u.LoadDll.lpImageName)
  484.                     {
  485.                         AddressName = 0;
  486.                         AnsiBuffer[0] = 0;
  487.  
  488.                         p->ReadMemory(dbg_event.u.LoadDll.lpImageName, &AddressName, 4);
  489.                         if (AddressName)
  490.                         {
  491.                             if (dbg_event.u.LoadDll.fUnicode)
  492.                             {
  493.                                 UnicodeBuffer = 0;
  494.                                 p->ReadMemory(AddressName, &UnicodeBuffer, 520);
  495.                                 WideCharToMultiByte(0, 0, (LPCWSTR)&UnicodeBuffer, -1, AnsiBuffer, 260, 0, 0);
  496.                             } else
  497.                             {
  498.                                 p->ReadMemory(AddressName, AnsiBuffer, 260);
  499.                             }
  500.                         }
  501.  
  502.                         if (TGetFileName(AnsiBuffer) == AnsiBuffer)
  503.                         {
  504.                             GetSystemDirectoryA(DirName, 260);
  505.                             TStrCat(DirName, "\\");
  506.                             TStrCat(DirName, AnsiBuffer);
  507.                             TStrCpy(AnsiBuffer, DirName);
  508.                         }
  509.  
  510.                         p->ReadPE(dbg_event.u.LoadDll.lpBaseOfDll, &pe_head);
  511.  
  512.                         if (dbg_event.u.LoadDll.lpBaseOfDll && AnsiBuffer[0])
  513.                             p->m_pDebugInterface->LoadModule(p, AnsiBuffer,
  514.                                 dbg_event.u.LoadDll.lpBaseOfDll,
  515.                                 pe_head.SizeOfImage,
  516.                                 pe_head.TimeDateStamp,
  517.                                 pe_head.CheckSum);
  518.                     }
  519.                     break;
  520.                 default:
  521.                     break;
  522.                 }
  523.                 ContinueDebugEvent(dbg_event.dwProcessId, dbg_event.dwThreadId, continueStatus);
  524.             }
  525.  
  526.             p->m_hProcess = 0;
  527.             SetEvent(p->m_hDbgEvent);
  528.             return 1;
  529.         }
  530.  
  531.         unsigned int CSDWin32::ProcessDebugEvent(DEBUG_EVENT *pEvent)
  532.         {
  533.             DWORD ExceptionCode;
  534.            
  535.  
  536.             BREAK_POINT *BreakPoint;
  537.             PE_HEAD pe_head;
  538.             char Buffer[260];
  539.             unsigned int continueStatus;
  540.             char flag;
  541.  
  542.             ExceptionCode = pEvent->u.Exception.ExceptionRecord.ExceptionCode;
  543.  
  544.             if (ExceptionCode == STATUS_BREAKPOINT)
  545.             {
  546.                 continueStatus = DBG_CONTINUE;
  547.                 if (++m_StepCount == 1)
  548.                 {
  549.                     if (m_Attached)
  550.                     {
  551.                         m_dwThreadId = pEvent->dwThreadId;
  552.                         SaveRegisters(m_dwThreadId);
  553.                         DebugExeption(0);
  554.                         m_bSuspend = true;
  555.                         SetEvent(m_hDbgEvent);
  556.                         SuspendThread(m_hDbgThread);
  557.                         m_bSuspend = false;
  558.  
  559.                         HANDLE hModules = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, m_dwProcessId);
  560.                         if (hModules == -1)
  561.                             return 0;
  562.  
  563.                         MODULEENTRY32 mod;
  564.                         mod.dwSize = sizeof(MODULEENTRY32);
  565.                         if (Module32First(hModules, &mod))
  566.                         {
  567.                             do {
  568.                                 ReadPE(mod.modBaseAddr, &pe_head);
  569.                                 m_pDebugInterface->LoadModule(
  570.                                     this,
  571.                                     mod.szExePath,
  572.                                     mod.modBaseAddr,
  573.                                     mod.modBaseSize,
  574.                                     pe_head.TimeDateStamp,
  575.                                     pe_head.CheckSum);
  576.  
  577.                             } while (Module32Next(hModules, &mod));
  578.                         }
  579.                         CloseHandle(hModules);
  580.                     }
  581.                 } else
  582.                 {
  583.                     m_dwThreadId = pEvent->dwThreadId;
  584.                     BreakPoint = CodeFindBP(pEvent->u.LoadDll.nDebugInfoSize, 0, 0);
  585.  
  586.                     if (BreakPoint && BreakPoint->State == BP_STATE_ENABLE)
  587.                     {
  588.                         StepBack(pEvent->dwThreadId);
  589.                         if (WriteMemory(m_Context._Eip, (char *)&BreakPoint->CCBackup, 1))
  590.                             BreakPoint->State = BP_STATE_RECOV;
  591.  
  592.                         if (m_pDebugInterface->TestCondition(BreakPoint->Condition.cstr()))
  593.                         {
  594.                             m_pDebugInterface->ParseManyCmd(BreakPoint->Command.cstr());
  595.                             if ( !(BreakPoint->Access & 0x200) )
  596.                             {
  597.                                 m_pDebugInterface->GetDebugger(); //???
  598.                                 flag = 1;
  599.                             }
  600.  
  601.                             if (m_pDebugInterface->Continue())
  602.                             {
  603.                                 CodeDelAllBP(0x200, 0);
  604.                                 DebugExeption(1);
  605.                                 m_bSuspend = true;
  606.                                 if (m_StepCount == 2)
  607.                                     SetEvent(m_hDbgEvent);
  608.                                 SuspendThread(m_hDbgThread);
  609.                                 m_bSuspend = false;
  610.                             }
  611.                         }
  612.                         if (CheckAllRecoveryCodeBP())
  613.                             SetSingleStep();
  614.                     }
  615.                 }
  616.  
  617.  
  618.             } else
  619.             if (ExceptionCode == STATUS_SINGLE_STEP)
  620.             {
  621.                 continueStatus = DBG_CONTINUE;
  622.                 m_dwThreadId = pEvent->dwThreadId;
  623.                 SaveRegisters(pEvent->dwThreadId);
  624.                 EnableAllRecoveryCodeBP();
  625.                 flag = 0;
  626.                 BreakPoint = CodeFindBP(m_Context.Eip, 0, 0);
  627.                 if (BreakPoint && BreakPoint->State == BP_STATE_ENABLE)
  628.                 {
  629.                     if (WriteMemory(m_Context.Eip, (char *)&BreakPoint->CCBackup, 1))
  630.                         BreakPoint->State = BP_STATE_RECOV;
  631.  
  632.                     if (m_pDebugInterface->TestCondition(BreakPoint->Condition.cstr()))
  633.                     {
  634.                         m_pDebugInterface->ParseManyCmd(BreakPoint->Command.cstr());
  635.                         if ( !(BreakPoint->Access & 0x200) )
  636.                         {
  637.                             m_pDebugInterface->GetDebugger(); //???
  638.                             flag = 1;
  639.                         }
  640.                     }
  641.                 }
  642.  
  643.                 if (m_pDebugInterface->m_State && m_pDebugInterface->Continue())
  644.                 {
  645.                     flag = 1;
  646.                 } else
  647.                 if (DataGetBPList(0, 0, 0) > 0)
  648.                 {
  649.                     flag = 1;
  650.                 }
  651.  
  652.                 if (flag)
  653.                 {
  654.                     CodeDelAllBP(0x200, 0);
  655.                     DebugExeption(1);
  656.                     m_bSuspend = true;
  657.                     SuspendThread(m_hDbgThread);
  658.                     m_bSuspend = false;
  659.                 }
  660.                 if (CheckAllRecoveryCodeBP())
  661.                     SetSingleStep();
  662.             } else
  663.             if (ExceptionCode == DBG_CONTROL_C || ExceptionCode == DBG_CONTROL_BREAK)
  664.             {
  665.                 continueStatus = DBG_CONTINUE;
  666.                 m_dwThreadId = pEvent->dwThreadId;
  667.                 SaveRegisters(pEvent->dwThreadId);
  668.                 DebugExeption(5);
  669.                 m_bSuspend = true;
  670.                 SuspendThread(m_hDbgThread);
  671.                 m_bSuspend = false;
  672.             } else
  673.             if (ExceptionCode == 0xC0000005) //ACCESS VIOLATION
  674.             {
  675.                 continueStatus = DBG_CONTINUE;
  676.                 m_dwThreadId = pEvent->dwThreadId;
  677.                 SaveRegisters(pEvent->dwThreadId);
  678.                 m_ExceptionAddress = pEvent->u.Exception.ExceptionRecord.ExceptionAddress;
  679.                 sprintf(Buffer, "Debug Event : Access Violation , Address = %08X !\n", m_ExceptionAddress);
  680.                 m_pDebugInterface->DisplayMsg(Buffer);
  681.                 DebugExeption(4);
  682.                 m_bSuspend = true;
  683.                 SuspendThread(m_hDbgThread);
  684.                 SaveRegisters(pEvent->dwThreadId);
  685.                 m_bSuspend = false;
  686.  
  687.             } else
  688.             {
  689.                 continueStatus = DBG_EXCEPTION_NOT_HANDLED;
  690.                 m_dwThreadId = pEvent->dwThreadId;
  691.                 SaveRegisters(pEvent->dwThreadId);
  692.                 DebugExeption(0);
  693.                 m_bSuspend = true;
  694.                 SuspendThread(m_hDbgThread);
  695.                 SaveRegisters(pEvent->dwThreadId);
  696.                 m_bSuspend = false;
  697.             }
  698.  
  699.             return continueStatus;
  700.         }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!