language
stringlengths 0
24
| filename
stringlengths 9
214
| code
stringlengths 99
9.93M
|
---|---|---|
C++ | x64dbg-development/src/dbg/_scriptapi_register.cpp | #include "_scriptapi_register.h"
#include "value.h"
#include "debugger.h"
#include "TraceRecord.h"
static const char* regTable[] =
{
"DR0",
"DR1",
"DR2",
"DR3",
"DR6",
"DR7",
"EAX",
"AX",
"AH",
"AL",
"EBX",
"BX",
"BH",
"BL",
"ECX",
"CX",
"CH",
"CL",
"EDX",
"DX",
"DH",
"DL",
"EDI",
"DI",
"ESI",
"SI",
"EBP",
"BP",
"ESP",
"SP",
"EIP",
#ifdef _WIN64
"RAX",
"RBX",
"RCX",
"RDX",
"RSI",
"SIL",
"RDI",
"DIL",
"RBP",
"BPL",
"RSP",
"SPL",
"RIP",
"R8",
"R8D",
"R8W",
"R8B",
"R9",
"R9D",
"R9W",
"R9B",
"R10",
"R10D",
"R10W",
"R10B",
"R11",
"R11D",
"R11W",
"R11B",
"R12",
"R12D",
"R12W",
"R12B",
"R13",
"R13D",
"R13W",
"R13B",
"R14",
"R14D",
"R14W",
"R14B",
"R15",
"R15D",
"R15W",
"R15",
#endif //_WIN64
ArchValue("EIP", "RIP"),
ArchValue("ESP", "RSP"),
ArchValue("EAX", "RAX"),
ArchValue("EBX", "RBX"),
ArchValue("ECX", "RCX"),
ArchValue("EDX", "RDX"),
ArchValue("EDI", "RDI"),
ArchValue("ESI", "RSI"),
ArchValue("EBP", "RBP"),
ArchValue("EFLAGS", "RFLAGS")
};
SCRIPT_EXPORT duint Script::Register::Get(Script::Register::RegisterEnum reg)
{
return getregister(nullptr, regTable[reg]);
}
SCRIPT_EXPORT bool Script::Register::Set(Script::Register::RegisterEnum reg, duint value)
{
auto result = setregister(regTable[reg], value);
if(reg == ArchValue(EIP, RIP) || reg == CIP)
{
auto cip = GetContextDataEx(hActiveThread, UE_CIP);
dbgtraceexecute(cip);
DebugUpdateGuiAsync(cip, false); //update disassembly + register view
}
else if(reg == ArchValue(ESP, RSP) || reg == SP || reg == CSP) //update stack
{
duint csp = GetContextDataEx(hActiveThread, UE_CSP);
DebugUpdateStack(csp, csp);
}
return result;
}
SCRIPT_EXPORT int Script::Register::Size()
{
return (int)sizeof(duint);
}
SCRIPT_EXPORT duint Script::Register::GetDR0()
{
return Get(DR0);
}
SCRIPT_EXPORT bool Script::Register::SetDR0(duint value)
{
return Set(DR0, value);
}
SCRIPT_EXPORT duint Script::Register::GetDR1()
{
return Get(DR1);
}
SCRIPT_EXPORT bool Script::Register::SetDR1(duint value)
{
return Set(DR1, value);
}
SCRIPT_EXPORT duint Script::Register::GetDR2()
{
return Get(DR2);
}
SCRIPT_EXPORT bool Script::Register::SetDR2(duint value)
{
return Set(DR2, value);
}
SCRIPT_EXPORT duint Script::Register::GetDR3()
{
return Get(DR3);
}
SCRIPT_EXPORT bool Script::Register::SetDR3(duint value)
{
return Set(DR3, value);
}
SCRIPT_EXPORT duint Script::Register::GetDR6()
{
return Get(DR6);
}
SCRIPT_EXPORT bool Script::Register::SetDR6(duint value)
{
return Set(DR6, value);
}
SCRIPT_EXPORT duint Script::Register::GetDR7()
{
return Get(DR7);
}
SCRIPT_EXPORT bool Script::Register::SetDR7(duint value)
{
return Set(DR7, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetEAX()
{
return (unsigned int)Get(EAX);
}
SCRIPT_EXPORT bool Script::Register::SetEAX(unsigned int value)
{
return Set(EAX, value);
}
SCRIPT_EXPORT unsigned short Script::Register::GetAX()
{
return (unsigned short)Get(AX);
}
SCRIPT_EXPORT bool Script::Register::SetAX(unsigned short value)
{
return Set(AX, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetAH()
{
return (unsigned char)Get(AH);
}
SCRIPT_EXPORT bool Script::Register::SetAH(unsigned char value)
{
return Set(AH, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetAL()
{
return (unsigned char)Get(AL);
}
SCRIPT_EXPORT bool Script::Register::SetAL(unsigned char value)
{
return Set(AL, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetEBX()
{
return (unsigned int)Get(EBX);
}
SCRIPT_EXPORT bool Script::Register::SetEBX(unsigned int value)
{
return Set(EBX, value);
}
SCRIPT_EXPORT unsigned short Script::Register::GetBX()
{
return (unsigned short)Get(BX);
}
SCRIPT_EXPORT bool Script::Register::SetBX(unsigned short value)
{
return Set(BX, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetBH()
{
return (unsigned char)Get(BH);
}
SCRIPT_EXPORT bool Script::Register::SetBH(unsigned char value)
{
return Set(BH, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetBL()
{
return (unsigned char)Get(BL);
}
SCRIPT_EXPORT bool Script::Register::SetBL(unsigned char value)
{
return Set(BL, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetECX()
{
return (unsigned int)Get(ECX);
}
SCRIPT_EXPORT bool Script::Register::SetECX(unsigned int value)
{
return Set(ECX, value);
}
SCRIPT_EXPORT unsigned short Script::Register::GetCX()
{
return (unsigned short)Get(CX);
}
SCRIPT_EXPORT bool Script::Register::SetCX(unsigned short value)
{
return Set(CX, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetCH()
{
return (unsigned char)Get(CH);
}
SCRIPT_EXPORT bool Script::Register::SetCH(unsigned char value)
{
return Set(CH, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetCL()
{
return (unsigned char)Get(CL);
}
SCRIPT_EXPORT bool Script::Register::SetCL(unsigned char value)
{
return Set(CL, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetEDX()
{
return (unsigned int)Get(EDX);
}
SCRIPT_EXPORT bool Script::Register::SetEDX(unsigned int value)
{
return Set(EDX, value);
}
SCRIPT_EXPORT unsigned short Script::Register::GetDX()
{
return (unsigned short)Get(DX);
}
SCRIPT_EXPORT bool Script::Register::SetDX(unsigned short value)
{
return Set(DX, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetDH()
{
return (unsigned char)Get(DH);
}
SCRIPT_EXPORT bool Script::Register::SetDH(unsigned char value)
{
return Set(DH, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetDL()
{
return (unsigned char)Get(DL);
}
SCRIPT_EXPORT bool Script::Register::SetDL(unsigned char value)
{
return Set(DL, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetEDI()
{
return (unsigned int)Get(EDI);
}
SCRIPT_EXPORT bool Script::Register::SetEDI(unsigned int value)
{
return Set(EDI, value);
}
SCRIPT_EXPORT unsigned short Script::Register::GetDI()
{
return (unsigned short)Get(DI);
}
SCRIPT_EXPORT bool Script::Register::SetDI(unsigned short value)
{
return Set(DI, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetESI()
{
return (unsigned int)Get(ESI);
}
SCRIPT_EXPORT bool Script::Register::SetESI(unsigned int value)
{
return Set(ESI, value);
}
SCRIPT_EXPORT unsigned short Script::Register::GetSI()
{
return (unsigned short)Get(SI);
}
SCRIPT_EXPORT bool Script::Register::SetSI(unsigned short value)
{
return Set(SI, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetEBP()
{
return (unsigned int)Get(EBP);
}
SCRIPT_EXPORT bool Script::Register::SetEBP(unsigned int value)
{
return Set(EBP, value);
}
SCRIPT_EXPORT unsigned short Script::Register::GetBP()
{
return (unsigned short)Get(BP);
}
SCRIPT_EXPORT bool Script::Register::SetBP(unsigned short value)
{
return Set(BP, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetESP()
{
return (unsigned int)Get(ESP);
}
SCRIPT_EXPORT bool Script::Register::SetESP(unsigned int value)
{
return Set(ESP, value);
}
SCRIPT_EXPORT unsigned short Script::Register::GetSP()
{
return (unsigned short)Get(SP);
}
SCRIPT_EXPORT bool Script::Register::SetSP(unsigned short value)
{
return Set(SP, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetEIP()
{
return (unsigned int)Get(EIP);
}
SCRIPT_EXPORT bool Script::Register::SetEIP(unsigned int value)
{
return Set(EIP, value);
}
#ifdef _WIN64
SCRIPT_EXPORT unsigned long long Script::Register::GetRAX()
{
return (unsigned long long)Get(RAX);
}
SCRIPT_EXPORT bool Script::Register::SetRAX(unsigned long long value)
{
return Set(RAX, value);
}
SCRIPT_EXPORT unsigned long long Script::Register::GetRBX()
{
return (unsigned long long)Get(RBX);
}
SCRIPT_EXPORT bool Script::Register::SetRBX(unsigned long long value)
{
return Set(RBX, value);
}
SCRIPT_EXPORT unsigned long long Script::Register::GetRCX()
{
return (unsigned long long)Get(RCX);
}
SCRIPT_EXPORT bool Script::Register::SetRCX(unsigned long long value)
{
return Set(RCX, value);
}
SCRIPT_EXPORT unsigned long long Script::Register::GetRDX()
{
return (unsigned long long)Get(RDX);
}
SCRIPT_EXPORT bool Script::Register::SetRDX(unsigned long long value)
{
return Set(RDX, value);
}
SCRIPT_EXPORT unsigned long long Script::Register::GetRSI()
{
return (unsigned long long)Get(RSI);
}
SCRIPT_EXPORT bool Script::Register::SetRSI(unsigned long long value)
{
return Set(RSI, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetSIL()
{
return (unsigned char)Get(SIL);
}
SCRIPT_EXPORT bool Script::Register::SetSIL(unsigned char value)
{
return Set(SIL, value);
}
SCRIPT_EXPORT unsigned long long Script::Register::GetRDI()
{
return (unsigned long long)Get(RDI);
}
SCRIPT_EXPORT bool Script::Register::SetRDI(unsigned long long value)
{
return Set(RDI, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetDIL()
{
return (unsigned char)Get(DIL);
}
SCRIPT_EXPORT bool Script::Register::SetDIL(unsigned char value)
{
return Set(DIL, value);
}
SCRIPT_EXPORT unsigned long long Script::Register::GetRBP()
{
return (unsigned long long)Get(RBP);
}
SCRIPT_EXPORT bool Script::Register::SetRBP(unsigned long long value)
{
return Set(RBP, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetBPL()
{
return (unsigned char)Get(BPL);
}
SCRIPT_EXPORT bool Script::Register::SetBPL(unsigned char value)
{
return Set(BPL, value);
}
SCRIPT_EXPORT unsigned long long Script::Register::GetRSP()
{
return (unsigned long long)Get(RSP);
}
SCRIPT_EXPORT bool Script::Register::SetRSP(unsigned long long value)
{
return Set(RSP, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetSPL()
{
return (unsigned char)Get(SPL);
}
SCRIPT_EXPORT bool Script::Register::SetSPL(unsigned char value)
{
return Set(SPL, value);
}
SCRIPT_EXPORT unsigned long long Script::Register::GetRIP()
{
return (unsigned long long)Get(RIP);
}
SCRIPT_EXPORT bool Script::Register::SetRIP(unsigned long long value)
{
return Set(RIP, value);
}
SCRIPT_EXPORT unsigned long long Script::Register::GetR8()
{
return (unsigned long long)Get(R8);
}
SCRIPT_EXPORT bool Script::Register::SetR8(unsigned long long value)
{
return Set(R8, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetR8D()
{
return (unsigned int)Get(R8D);
}
SCRIPT_EXPORT bool Script::Register::SetR8D(unsigned int value)
{
return Set(R8D, value);
}
SCRIPT_EXPORT unsigned short Script::Register::GetR8W()
{
return (unsigned short)Get(R8W);
}
SCRIPT_EXPORT bool Script::Register::SetR8W(unsigned short value)
{
return Set(R8W, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetR8B()
{
return (unsigned char)Get(R8B);
}
SCRIPT_EXPORT bool Script::Register::SetR8B(unsigned char value)
{
return Set(R8B, value);
}
SCRIPT_EXPORT unsigned long long Script::Register::GetR9()
{
return (unsigned long long)Get(R9);
}
SCRIPT_EXPORT bool Script::Register::SetR9(unsigned long long value)
{
return Set(R9, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetR9D()
{
return (unsigned int)Get(R9D);
}
SCRIPT_EXPORT bool Script::Register::SetR9D(unsigned int value)
{
return Set(R9D, value);
}
SCRIPT_EXPORT unsigned short Script::Register::GetR9W()
{
return (unsigned short)Get(R9W);
}
SCRIPT_EXPORT bool Script::Register::SetR9W(unsigned short value)
{
return Set(R9W, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetR9B()
{
return (unsigned char)Get(R9B);
}
SCRIPT_EXPORT bool Script::Register::SetR9B(unsigned char value)
{
return Set(R9B, value);
}
SCRIPT_EXPORT unsigned long long Script::Register::GetR10()
{
return (unsigned long long)Get(R10);
}
SCRIPT_EXPORT bool Script::Register::SetR10(unsigned long long value)
{
return Set(R10, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetR10D()
{
return (unsigned int)Get(R10D);
}
SCRIPT_EXPORT bool Script::Register::SetR10D(unsigned int value)
{
return Set(R10D, value);
}
SCRIPT_EXPORT unsigned short Script::Register::GetR10W()
{
return (unsigned short)Get(R10W);
}
SCRIPT_EXPORT bool Script::Register::SetR10W(unsigned short value)
{
return Set(R10W, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetR10B()
{
return (unsigned char)Get(R10B);
}
SCRIPT_EXPORT bool Script::Register::SetR10B(unsigned char value)
{
return Set(R10B, value);
}
SCRIPT_EXPORT unsigned long long Script::Register::GetR11()
{
return (unsigned long long)Get(R11);
}
SCRIPT_EXPORT bool Script::Register::SetR11(unsigned long long value)
{
return Set(R11, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetR11D()
{
return (unsigned int)Get(R11D);
}
SCRIPT_EXPORT bool Script::Register::SetR11D(unsigned int value)
{
return Set(R11D, value);
}
SCRIPT_EXPORT unsigned short Script::Register::GetR11W()
{
return (unsigned short)Get(R11W);
}
SCRIPT_EXPORT bool Script::Register::SetR11W(unsigned short value)
{
return Set(R11W, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetR11B()
{
return (unsigned char)Get(R11B);
}
SCRIPT_EXPORT bool Script::Register::SetR11B(unsigned char value)
{
return Set(R11B, value);
}
SCRIPT_EXPORT unsigned long long Script::Register::GetR12()
{
return (unsigned long long)Get(R12);
}
SCRIPT_EXPORT bool Script::Register::SetR12(unsigned long long value)
{
return Set(R12, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetR12D()
{
return (unsigned int)Get(R12D);
}
SCRIPT_EXPORT bool Script::Register::SetR12D(unsigned int value)
{
return Set(R12D, value);
}
SCRIPT_EXPORT unsigned short Script::Register::GetR12W()
{
return (unsigned short)Get(R12W);
}
SCRIPT_EXPORT bool Script::Register::SetR12W(unsigned short value)
{
return Set(R12W, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetR12B()
{
return (unsigned char)Get(R12B);
}
SCRIPT_EXPORT bool Script::Register::SetR12B(unsigned char value)
{
return Set(R12B, value);
}
SCRIPT_EXPORT unsigned long long Script::Register::GetR13()
{
return (unsigned long long)Get(R13);
}
SCRIPT_EXPORT bool Script::Register::SetR13(unsigned long long value)
{
return Set(R13, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetR13D()
{
return (unsigned int)Get(R13D);
}
SCRIPT_EXPORT bool Script::Register::SetR13D(unsigned int value)
{
return Set(R13D, value);
}
SCRIPT_EXPORT unsigned short Script::Register::GetR13W()
{
return (unsigned short)Get(R13W);
}
SCRIPT_EXPORT bool Script::Register::SetR13W(unsigned short value)
{
return Set(R13W, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetR13B()
{
return (unsigned char)Get(R13B);
}
SCRIPT_EXPORT bool Script::Register::SetR13B(unsigned char value)
{
return Set(R13B, value);
}
SCRIPT_EXPORT unsigned long long Script::Register::GetR14()
{
return (unsigned long long)Get(R14);
}
SCRIPT_EXPORT bool Script::Register::SetR14(unsigned long long value)
{
return Set(R14, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetR14D()
{
return (unsigned int)Get(R14D);
}
SCRIPT_EXPORT bool Script::Register::SetR14D(unsigned int value)
{
return Set(R14D, value);
}
SCRIPT_EXPORT unsigned short Script::Register::GetR14W()
{
return (unsigned short)Get(R14W);
}
SCRIPT_EXPORT bool Script::Register::SetR14W(unsigned short value)
{
return Set(R14W, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetR14B()
{
return (unsigned char)Get(R14B);
}
SCRIPT_EXPORT bool Script::Register::SetR14B(unsigned char value)
{
return Set(R14B, value);
}
SCRIPT_EXPORT unsigned long long Script::Register::GetR15()
{
return (unsigned long long)Get(R15);
}
SCRIPT_EXPORT bool Script::Register::SetR15(unsigned long long value)
{
return Set(R15, value);
}
SCRIPT_EXPORT unsigned int Script::Register::GetR15D()
{
return (unsigned int)Get(R15D);
}
SCRIPT_EXPORT bool Script::Register::SetR15D(unsigned int value)
{
return Set(R15D, value);
}
SCRIPT_EXPORT unsigned short Script::Register::GetR15W()
{
return (unsigned short)Get(R15W);
}
SCRIPT_EXPORT bool Script::Register::SetR15W(unsigned short value)
{
return Set(R15W, value);
}
SCRIPT_EXPORT unsigned char Script::Register::GetR15B()
{
return (unsigned char)Get(R15B);
}
SCRIPT_EXPORT bool Script::Register::SetR15B(unsigned char value)
{
return Set(R15B, value);
}
#endif //_WIN64
SCRIPT_EXPORT duint Script::Register::GetCAX()
{
return Get(CAX);
}
SCRIPT_EXPORT bool Script::Register::SetCAX(duint value)
{
return Set(CAX, value);
}
SCRIPT_EXPORT duint Script::Register::GetCBX()
{
return Get(CBX);
}
SCRIPT_EXPORT bool Script::Register::SetCBX(duint value)
{
return Set(CBX, value);
}
SCRIPT_EXPORT duint Script::Register::GetCCX()
{
return Get(CCX);
}
SCRIPT_EXPORT bool Script::Register::SetCCX(duint value)
{
return Set(CCX, value);
}
SCRIPT_EXPORT duint Script::Register::GetCDX()
{
return Get(CDX);
}
SCRIPT_EXPORT bool Script::Register::SetCDX(duint value)
{
return Set(CDX, value);
}
SCRIPT_EXPORT duint Script::Register::GetCDI()
{
return Get(CDI);
}
SCRIPT_EXPORT bool Script::Register::SetCDI(duint value)
{
return Set(CDI, value);
}
SCRIPT_EXPORT duint Script::Register::GetCSI()
{
return Get(CSI);
}
SCRIPT_EXPORT bool Script::Register::SetCSI(duint value)
{
return Set(CSI, value);
}
SCRIPT_EXPORT duint Script::Register::GetCBP()
{
return Get(CBP);
}
SCRIPT_EXPORT bool Script::Register::SetCBP(duint value)
{
return Set(CBP, value);
}
SCRIPT_EXPORT duint Script::Register::GetCSP()
{
return Get(CSP);
}
SCRIPT_EXPORT bool Script::Register::SetCSP(duint value)
{
return Set(CSP, value);
}
SCRIPT_EXPORT duint Script::Register::GetCIP()
{
return Get(CIP);
}
SCRIPT_EXPORT bool Script::Register::SetCIP(duint value)
{
return Set(CIP, value);
}
SCRIPT_EXPORT duint Script::Register::GetCFLAGS()
{
return Get(CFLAGS);
}
SCRIPT_EXPORT bool Script::Register::SetCFLAGS(duint value)
{
return Set(CFLAGS, value);
} |
C/C++ | x64dbg-development/src/dbg/_scriptapi_register.h | #ifndef _SCRIPTAPI_REGISTER_H
#define _SCRIPTAPI_REGISTER_H
#include "_scriptapi.h"
namespace Script
{
namespace Register
{
enum RegisterEnum
{
DR0,
DR1,
DR2,
DR3,
DR6,
DR7,
EAX,
AX,
AH,
AL,
EBX,
BX,
BH,
BL,
ECX,
CX,
CH,
CL,
EDX,
DX,
DH,
DL,
EDI,
DI,
ESI,
SI,
EBP,
BP,
ESP,
SP,
EIP,
#ifdef _WIN64
RAX,
RBX,
RCX,
RDX,
RSI,
SIL,
RDI,
DIL,
RBP,
BPL,
RSP,
SPL,
RIP,
R8,
R8D,
R8W,
R8B,
R9,
R9D,
R9W,
R9B,
R10,
R10D,
R10W,
R10B,
R11,
R11D,
R11W,
R11B,
R12,
R12D,
R12W,
R12B,
R13,
R13D,
R13W,
R13B,
R14,
R14D,
R14W,
R14B,
R15,
R15D,
R15W,
R15B,
#endif //_WIN64
CIP,
CSP,
CAX,
CBX,
CCX,
CDX,
CDI,
CSI,
CBP,
CFLAGS
}; //RegisterEnum
SCRIPT_EXPORT duint Get(RegisterEnum reg);
SCRIPT_EXPORT bool Set(RegisterEnum reg, duint value);
SCRIPT_EXPORT int Size(); //gets architecture register size in bytes
SCRIPT_EXPORT duint GetDR0();
SCRIPT_EXPORT bool SetDR0(duint value);
SCRIPT_EXPORT duint GetDR1();
SCRIPT_EXPORT bool SetDR1(duint value);
SCRIPT_EXPORT duint GetDR2();
SCRIPT_EXPORT bool SetDR2(duint value);
SCRIPT_EXPORT duint GetDR3();
SCRIPT_EXPORT bool SetDR3(duint value);
SCRIPT_EXPORT duint GetDR6();
SCRIPT_EXPORT bool SetDR6(duint value);
SCRIPT_EXPORT duint GetDR7();
SCRIPT_EXPORT bool SetDR7(duint value);
SCRIPT_EXPORT unsigned int GetEAX();
SCRIPT_EXPORT bool SetEAX(unsigned int value);
SCRIPT_EXPORT unsigned short GetAX();
SCRIPT_EXPORT bool SetAX(unsigned short value);
SCRIPT_EXPORT unsigned char GetAH();
SCRIPT_EXPORT bool SetAH(unsigned char value);
SCRIPT_EXPORT unsigned char GetAL();
SCRIPT_EXPORT bool SetAL(unsigned char value);
SCRIPT_EXPORT unsigned int GetEBX();
SCRIPT_EXPORT bool SetEBX(unsigned int value);
SCRIPT_EXPORT unsigned short GetBX();
SCRIPT_EXPORT bool SetBX(unsigned short value);
SCRIPT_EXPORT unsigned char GetBH();
SCRIPT_EXPORT bool SetBH(unsigned char value);
SCRIPT_EXPORT unsigned char GetBL();
SCRIPT_EXPORT bool SetBL(unsigned char value);
SCRIPT_EXPORT unsigned int GetECX();
SCRIPT_EXPORT bool SetECX(unsigned int value);
SCRIPT_EXPORT unsigned short GetCX();
SCRIPT_EXPORT bool SetCX(unsigned short value);
SCRIPT_EXPORT unsigned char GetCH();
SCRIPT_EXPORT bool SetCH(unsigned char value);
SCRIPT_EXPORT unsigned char GetCL();
SCRIPT_EXPORT bool SetCL(unsigned char value);
SCRIPT_EXPORT unsigned int GetEDX();
SCRIPT_EXPORT bool SetEDX(unsigned int value);
SCRIPT_EXPORT unsigned short GetDX();
SCRIPT_EXPORT bool SetDX(unsigned short value);
SCRIPT_EXPORT unsigned char GetDH();
SCRIPT_EXPORT bool SetDH(unsigned char value);
SCRIPT_EXPORT unsigned char GetDL();
SCRIPT_EXPORT bool SetDL(unsigned char value);
SCRIPT_EXPORT unsigned int GetEDI();
SCRIPT_EXPORT bool SetEDI(unsigned int value);
SCRIPT_EXPORT unsigned short GetDI();
SCRIPT_EXPORT bool SetDI(unsigned short value);
SCRIPT_EXPORT unsigned int GetESI();
SCRIPT_EXPORT bool SetESI(unsigned int value);
SCRIPT_EXPORT unsigned short GetSI();
SCRIPT_EXPORT bool SetSI(unsigned short value);
SCRIPT_EXPORT unsigned int GetEBP();
SCRIPT_EXPORT bool SetEBP(unsigned int value);
SCRIPT_EXPORT unsigned short GetBP();
SCRIPT_EXPORT bool SetBP(unsigned short value);
SCRIPT_EXPORT unsigned int GetESP();
SCRIPT_EXPORT bool SetESP(unsigned int value);
SCRIPT_EXPORT unsigned short GetSP();
SCRIPT_EXPORT bool SetSP(unsigned short value);
SCRIPT_EXPORT unsigned int GetEIP();
SCRIPT_EXPORT bool SetEIP(unsigned int value);
#ifdef _WIN64
SCRIPT_EXPORT unsigned long long GetRAX();
SCRIPT_EXPORT bool SetRAX(unsigned long long value);
SCRIPT_EXPORT unsigned long long GetRBX();
SCRIPT_EXPORT bool SetRBX(unsigned long long value);
SCRIPT_EXPORT unsigned long long GetRCX();
SCRIPT_EXPORT bool SetRCX(unsigned long long value);
SCRIPT_EXPORT unsigned long long GetRDX();
SCRIPT_EXPORT bool SetRDX(unsigned long long value);
SCRIPT_EXPORT unsigned long long GetRSI();
SCRIPT_EXPORT bool SetRSI(unsigned long long value);
SCRIPT_EXPORT unsigned char GetSIL();
SCRIPT_EXPORT bool SetSIL(unsigned char value);
SCRIPT_EXPORT unsigned long long GetRDI();
SCRIPT_EXPORT bool SetRDI(unsigned long long value);
SCRIPT_EXPORT unsigned char GetDIL();
SCRIPT_EXPORT bool SetDIL(unsigned char value);
SCRIPT_EXPORT unsigned long long GetRBP();
SCRIPT_EXPORT bool SetRBP(unsigned long long value);
SCRIPT_EXPORT unsigned char GetBPL();
SCRIPT_EXPORT bool SetBPL(unsigned char value);
SCRIPT_EXPORT unsigned long long GetRSP();
SCRIPT_EXPORT bool SetRSP(unsigned long long value);
SCRIPT_EXPORT unsigned char GetSPL();
SCRIPT_EXPORT bool SetSPL(unsigned char value);
SCRIPT_EXPORT unsigned long long GetRIP();
SCRIPT_EXPORT bool SetRIP(unsigned long long value);
SCRIPT_EXPORT unsigned long long GetR8();
SCRIPT_EXPORT bool SetR8(unsigned long long value);
SCRIPT_EXPORT unsigned int GetR8D();
SCRIPT_EXPORT bool SetR8D(unsigned int value);
SCRIPT_EXPORT unsigned short GetR8W();
SCRIPT_EXPORT bool SetR8W(unsigned short value);
SCRIPT_EXPORT unsigned char GetR8B();
SCRIPT_EXPORT bool SetR8B(unsigned char value);
SCRIPT_EXPORT unsigned long long GetR9();
SCRIPT_EXPORT bool SetR9(unsigned long long value);
SCRIPT_EXPORT unsigned int GetR9D();
SCRIPT_EXPORT bool SetR9D(unsigned int value);
SCRIPT_EXPORT unsigned short GetR9W();
SCRIPT_EXPORT bool SetR9W(unsigned short value);
SCRIPT_EXPORT unsigned char GetR9B();
SCRIPT_EXPORT bool SetR9B(unsigned char value);
SCRIPT_EXPORT unsigned long long GetR10();
SCRIPT_EXPORT bool SetR10(unsigned long long value);
SCRIPT_EXPORT unsigned int GetR10D();
SCRIPT_EXPORT bool SetR10D(unsigned int value);
SCRIPT_EXPORT unsigned short GetR10W();
SCRIPT_EXPORT bool SetR10W(unsigned short value);
SCRIPT_EXPORT unsigned char GetR10B();
SCRIPT_EXPORT bool SetR10B(unsigned char value);
SCRIPT_EXPORT unsigned long long GetR11();
SCRIPT_EXPORT bool SetR11(unsigned long long value);
SCRIPT_EXPORT unsigned int GetR11D();
SCRIPT_EXPORT bool SetR11D(unsigned int value);
SCRIPT_EXPORT unsigned short GetR11W();
SCRIPT_EXPORT bool SetR11W(unsigned short value);
SCRIPT_EXPORT unsigned char GetR11B();
SCRIPT_EXPORT bool SetR11B(unsigned char value);
SCRIPT_EXPORT unsigned long long GetR12();
SCRIPT_EXPORT bool SetR12(unsigned long long value);
SCRIPT_EXPORT unsigned int GetR12D();
SCRIPT_EXPORT bool SetR12D(unsigned int value);
SCRIPT_EXPORT unsigned short GetR12W();
SCRIPT_EXPORT bool SetR12W(unsigned short value);
SCRIPT_EXPORT unsigned char GetR12B();
SCRIPT_EXPORT bool SetR12B(unsigned char value);
SCRIPT_EXPORT unsigned long long GetR13();
SCRIPT_EXPORT bool SetR13(unsigned long long value);
SCRIPT_EXPORT unsigned int GetR13D();
SCRIPT_EXPORT bool SetR13D(unsigned int value);
SCRIPT_EXPORT unsigned short GetR13W();
SCRIPT_EXPORT bool SetR13W(unsigned short value);
SCRIPT_EXPORT unsigned char GetR13B();
SCRIPT_EXPORT bool SetR13B(unsigned char value);
SCRIPT_EXPORT unsigned long long GetR14();
SCRIPT_EXPORT bool SetR14(unsigned long long value);
SCRIPT_EXPORT unsigned int GetR14D();
SCRIPT_EXPORT bool SetR14D(unsigned int value);
SCRIPT_EXPORT unsigned short GetR14W();
SCRIPT_EXPORT bool SetR14W(unsigned short value);
SCRIPT_EXPORT unsigned char GetR14B();
SCRIPT_EXPORT bool SetR14B(unsigned char value);
SCRIPT_EXPORT unsigned long long GetR15();
SCRIPT_EXPORT bool SetR15(unsigned long long value);
SCRIPT_EXPORT unsigned int GetR15D();
SCRIPT_EXPORT bool SetR15D(unsigned int value);
SCRIPT_EXPORT unsigned short GetR15W();
SCRIPT_EXPORT bool SetR15W(unsigned short value);
SCRIPT_EXPORT unsigned char GetR15B();
SCRIPT_EXPORT bool SetR15B(unsigned char value);
#endif //_WIN64
SCRIPT_EXPORT duint GetCAX();
SCRIPT_EXPORT bool SetCAX(duint value);
SCRIPT_EXPORT duint GetCBX();
SCRIPT_EXPORT bool SetCBX(duint value);
SCRIPT_EXPORT duint GetCCX();
SCRIPT_EXPORT bool SetCCX(duint value);
SCRIPT_EXPORT duint GetCDX();
SCRIPT_EXPORT bool SetCDX(duint value);
SCRIPT_EXPORT duint GetCDI();
SCRIPT_EXPORT bool SetCDI(duint value);
SCRIPT_EXPORT duint GetCSI();
SCRIPT_EXPORT bool SetCSI(duint value);
SCRIPT_EXPORT duint GetCBP();
SCRIPT_EXPORT bool SetCBP(duint value);
SCRIPT_EXPORT duint GetCSP();
SCRIPT_EXPORT bool SetCSP(duint value);
SCRIPT_EXPORT duint GetCIP();
SCRIPT_EXPORT bool SetCIP(duint value);
SCRIPT_EXPORT duint GetCFLAGS();
SCRIPT_EXPORT bool SetCFLAGS(duint value);
}; //Register
}; //Script
#endif //_SCRIPTAPI_REGISTER_H |
C++ | x64dbg-development/src/dbg/_scriptapi_stack.cpp | #include "_scriptapi_stack.h"
#include "_scriptapi_memory.h"
#include "_scriptapi_register.h"
SCRIPT_EXPORT duint Script::Stack::Pop()
{
duint csp = Register::GetCSP();
duint top = Memory::ReadPtr(csp);
Register::SetCSP(csp + sizeof(duint));
return top;
}
SCRIPT_EXPORT duint Script::Stack::Push(duint value)
{
duint csp = Register::GetCSP();
Register::SetCSP(csp - sizeof(duint));
Memory::WritePtr(csp - sizeof(duint), value);
return Memory::ReadPtr(csp);
}
SCRIPT_EXPORT duint Script::Stack::Peek(int offset)
{
return Memory::ReadPtr(Register::GetCSP() + offset * sizeof(duint));
} |
C/C++ | x64dbg-development/src/dbg/_scriptapi_stack.h | #ifndef _SCRIPTAPI_STACK_H
#define _SCRIPTAPI_STACK_H
#include "_scriptapi.h"
namespace Script
{
namespace Stack
{
SCRIPT_EXPORT duint Pop();
SCRIPT_EXPORT duint Push(duint value); //returns the previous top, equal to Peek(1)
SCRIPT_EXPORT duint Peek(int offset = 0); //offset is in multiples of Register::Size(), for easy x32/x64 portability
}; //Stack
}; //Script
#endif //_SCRIPTAPI_STACK_H |
C++ | x64dbg-development/src/dbg/_scriptapi_symbol.cpp | #include "_scriptapi_symbol.h"
#include "_scriptapi_label.h"
#include "symbolinfo.h"
using namespace Script::Symbol;
struct cbSymbolEnumCtx
{
const SYMBOLMODULEINFO* module;
std::vector<SymbolInfo>* symbols;
};
static bool cbSymbolEnum(const SYMBOLPTR* ptr, void* user)
{
auto ctx = (cbSymbolEnumCtx*)user;
SYMBOLINFO info;
DbgGetSymbolInfo(ptr, &info);
const bool hasUndecoratedName = (0 != info.undecoratedSymbol) && (0 != info.undecoratedSymbol[0]);
const char* symbolName = hasUndecoratedName ? info.undecoratedSymbol : info.decoratedSymbol;
SymbolInfo symbol = {};
strncpy_s(symbol.mod, sizeof(symbol.mod), ctx->module->name, sizeof(symbol.mod) - 1);
symbol.rva = info.addr - ctx->module->base;
strncpy_s(symbol.name, sizeof(symbol.name), symbolName, sizeof(symbol.name) - 1);
symbol.manual = false;
switch(info.type)
{
case sym_import:
symbol.type = Import;
break;
case sym_export:
symbol.type = Export;
break;
case sym_symbol:
symbol.type = Function;
break;
default:
__debugbreak();
}
if(info.freeDecorated)
BridgeFree(info.decoratedSymbol);
if(info.freeUndecorated)
BridgeFree(info.undecoratedSymbol);
ctx->symbols->push_back(symbol);
return true;
}
SCRIPT_EXPORT bool Script::Symbol::GetList(ListOf(SymbolInfo) list)
{
BridgeList<Label::LabelInfo> labels;
if(!Label::GetList(&labels))
return false;
std::vector<SymbolInfo> symbols;
symbols.reserve(labels.Count());
for(auto i = 0; i < labels.Count(); i++)
{
const auto & label = labels[i];
SymbolInfo symbol;
strcpy_s(symbol.mod, label.mod);
symbol.rva = label.rva;
strcpy_s(symbol.name, label.text);
symbol.manual = label.manual;
symbol.type = Function;
symbols.push_back(symbol);
}
std::vector<SYMBOLMODULEINFO> modules;
SymGetModuleList(&modules);
cbSymbolEnumCtx ctx;
ctx.symbols = &symbols;
for(const auto & mod : modules)
{
ctx.module = &mod;
DbgSymbolEnumFromCache(mod.base, cbSymbolEnum, &ctx);
}
//TODO: enumerate actual symbols + virtual symbols (sub_XXXXXX) + imports + exports in addition to user-defined labels.
return BridgeList<SymbolInfo>::CopyData(list, symbols);
} |
C/C++ | x64dbg-development/src/dbg/_scriptapi_symbol.h | #ifndef _SCRIPTAPI_SYMBOL_H
#define _SCRIPTAPI_SYMBOL_H
#include "_scriptapi.h"
namespace Script
{
namespace Symbol
{
enum SymbolType
{
Function, //user-defined function
Import, //IAT entry
Export //export
};
struct SymbolInfo
{
char mod[MAX_MODULE_SIZE];
duint rva;
char name[MAX_LABEL_SIZE];
bool manual;
SymbolType type;
};
SCRIPT_EXPORT bool GetList(ListOf(SymbolInfo) list); //caller has the responsibility to free the list
}; //Symbol
}; //Script
#endif //_SCRIPTAPI_SYMBOL_H |
C++ | x64dbg-development/src/dbg/analysis/advancedanalysis.cpp | #include "advancedanalysis.h"
#include <queue>
#include "console.h"
#include "filehelper.h"
#include "function.h"
#include "xrefs.h"
#include "encodemap.h"
AdvancedAnalysis::AdvancedAnalysis(duint base, duint size, bool dump)
: Analysis(base, size),
mDump(dump)
{
mEncMap = new byte[size];
memset(mEncMap, 0, size);
}
AdvancedAnalysis::~AdvancedAnalysis()
{
delete[] mEncMap;
}
void AdvancedAnalysis::Analyse()
{
linearXrefPass();
findEntryPoints();
analyzeCandidateFunctions(true);
findFuzzyEntryPoints();
analyzeCandidateFunctions(true);
findInvalidXrefs();
writeDataXrefs();
}
void AdvancedAnalysis::SetMarkers()
{
if(mDump)
for(const auto & function : mFunctions)
FileHelper::WriteAllText(StringUtils::sprintf("cfgraph_%p.dot", function.entryPoint), function.ToDot());
duint encMapSize;
byte* buffer = (byte*)EncodeMapGetBuffer(mBase, &encMapSize, true);
memcpy(buffer, mEncMap, encMapSize);
EncodeMapReleaseBuffer(buffer);
XrefDelRange(mBase, mBase + mSize - 1);
for(const auto & vec : mXrefs)
{
for(const auto & xref : vec.second)
{
if(xref.valid)
XrefAdd(xref.addr, xref.from);
}
}
FunctionClear();
for(const auto & function : mFunctions)
{
duint start = ~0;
duint end = 0;
duint icount = 0;
for(const auto & node : function.nodes)
{
icount += node.second.icount;
start = min(node.second.start, start);
end = max(node.second.end, end);
}
if(!FunctionAdd(start, end, false, icount))
{
FunctionDelete(start);
FunctionDelete(end);
FunctionAdd(start, end, false, icount);
}
}
GuiUpdateAllViews();
}
void AdvancedAnalysis::analyzeFunction(duint entryPoint, bool writedata)
{
//BFS through the disassembly starting at entryPoint
CFGraph graph(entryPoint);
UintSet visited;
std::queue<duint> queue;
mEntryPoints.insert(entryPoint);
queue.push(graph.entryPoint);
while(!queue.empty())
{
auto start = queue.front();
queue.pop();
if(visited.count(start) || !inRange(start)) //already visited or out of range
continue;
visited.insert(start);
CFNode node(graph.entryPoint, start, start);
while(true)
{
node.icount++;
if(!mCp.Disassemble(node.end, translateAddr(node.end)))
{
if(writedata)
mEncMap[node.end - mBase] = (byte)enc_byte;
// If the next byte would be out of the memory range finish this node
if(!inRange(node.end + 1))
{
graph.AddNode(node);
break;
}
node.end++;
continue;
}
// If the memory range doesn't fit the entire instruction
// mark it as bytes and finish this node
if(!inRange(node.end + mCp.Size() - 1))
{
duint remainingSize = mBase + mSize - node.end;
memset(&mEncMap[node.end - mBase], (byte)enc_byte, remainingSize);
graph.AddNode(node);
break;
}
if(writedata)
{
mEncMap[node.end - mBase] = (byte)enc_code;
for(int i = 1; i < mCp.Size(); i++)
mEncMap[node.end - mBase + i] = (byte)enc_middle;
}
if(mCp.IsJump() || mCp.IsLoop()) //jump
{
//set the branch destinations
node.brtrue = mCp.BranchDestination();
if(mCp.GetId() != ZYDIS_MNEMONIC_JMP) //unconditional jumps dont have a brfalse
node.brfalse = node.end + mCp.Size();
//add node to the function graph
graph.AddNode(node);
//enqueue branch destinations
if(node.brtrue)
queue.push(node.brtrue);
if(node.brfalse)
queue.push(node.brfalse);
break;
}
if(mCp.IsCall()) //call
{
//TODO: handle no return
duint target = mCp.BranchDestination();
if(inRange(target) && mEntryPoints.find(target) == mEntryPoints.end())
mCandidateEPs.insert(target);
}
if(mCp.IsRet()) //return
{
node.terminal = true;
graph.AddNode(node);
break;
}
// If this instruction finishes the memory range, end the loop for this entry point
if(!inRange(node.end + mCp.Size()))
{
graph.AddNode(node);
break;
}
node.end += mCp.Size();
}
}
mFunctions.push_back(graph);
}
void AdvancedAnalysis::linearXrefPass()
{
dputs("Starting xref analysis...");
auto ticks = GetTickCount();
for(auto addr = mBase; addr < mBase + mSize;)
{
if(!mCp.Disassemble(addr, translateAddr(addr)))
{
addr++;
continue;
}
addr += mCp.Size();
XREF xref;
xref.valid = true;
xref.addr = 0;
xref.from = mCp.Address();
for(auto i = 0; i < mCp.OpCount(); i++)
{
duint dest = mCp.ResolveOpValue(i, [](ZydisRegister)->size_t
{
return 0;
});
if(inRange(dest))
{
xref.addr = dest;
break;
}
}
if(xref.addr)
{
if(mCp.IsCall())
xref.type = XREF_CALL;
else if(mCp.IsJump())
xref.type = XREF_JMP;
else
xref.type = XREF_DATA;
auto found = mXrefs.find(xref.addr);
if(found == mXrefs.end())
{
std::vector<XREF> vec;
vec.push_back(xref);
mXrefs[xref.addr] = vec;
}
else
{
found->second.push_back(xref);
}
}
}
dprintf("%d xrefs found in %ums!\n", int(mXrefs.size()), GetTickCount() - ticks);
}
void AdvancedAnalysis::findInvalidXrefs()
{
for(auto & vec : mXrefs)
{
duint jmps = 0, calls = 0;
duint addr = vec.first;
byte desttype = mEncMap[vec.first - mBase];
for(auto & xref : vec.second)
{
byte type = mEncMap[xref.from - mBase];
if(desttype == enc_code && type != enc_unknown && type != enc_code)
xref.valid = false;
else if(desttype == enc_middle)
xref.valid = false;
}
}
}
bool isFloatInstruction(ZydisMnemonic opcode)
{
switch(opcode)
{
case ZYDIS_MNEMONIC_FLD:
case ZYDIS_MNEMONIC_FST:
case ZYDIS_MNEMONIC_FSTP:
case ZYDIS_MNEMONIC_FADD:
case ZYDIS_MNEMONIC_FSUB:
case ZYDIS_MNEMONIC_FSUBR:
case ZYDIS_MNEMONIC_FMUL:
case ZYDIS_MNEMONIC_FDIV:
case ZYDIS_MNEMONIC_FDIVR:
case ZYDIS_MNEMONIC_FCOM:
case ZYDIS_MNEMONIC_FCOMP:
return true;
default:
return false;
}
}
void AdvancedAnalysis::writeDataXrefs()
{
for(auto & vec : mXrefs)
{
for(auto & xref : vec.second)
{
if(xref.type == XREF_DATA && xref.valid)
{
if(!mCp.Disassemble(xref.from, translateAddr(xref.from)))
{
xref.valid = false;
continue;
}
auto opcode = mCp.GetId();
bool isfloat = isFloatInstruction(opcode);
for(auto i = 0; i < mCp.OpCount(); i++)
{
auto & op = mCp[i];
ENCODETYPE type = enc_unknown;
//Todo: Analyze op type and set correct type
if(op.type == ZYDIS_OPERAND_TYPE_MEMORY)
{
duint size = op.size / 8;
duint offset = xref.addr - mBase;
switch(op.size)
{
case 8:
type = enc_byte;
break;
case 16:
type = enc_word;
break;
case 32:
type = isfloat ? enc_real4 : enc_dword;
break;
case 48:
type = enc_fword;
break;
case 64:
type = isfloat ? enc_real8 : enc_qword;
break;
case 80:
type = isfloat ? enc_real10 : enc_tbyte;
break;
case 128:
type = enc_oword;
break;
case 256:
type = enc_ymmword;
break;
//case 512: type = enc_zmmword; break;
default:
__debugbreak();
}
if(size == 1)
{
mEncMap[offset] = (byte)type;
}
else
{
// Check if the entire referenced data fits into the memory range
if((offset + size) <= mSize)
{
mEncMap[offset] = (byte)type;
memset(mEncMap + offset + 1, (byte)enc_middle, size - 1);
}
else
{
// If it doesn't fit, mark the remaining places as bytes
duint remainingSize = mSize - offset;
memset(mEncMap + offset, (byte)enc_byte, size);
}
}
}
}
}
}
}
}
void AdvancedAnalysis::findFuzzyEntryPoints()
{
for(const auto & entryPoint : mFuzzyEPs)
{
mCandidateEPs.insert(entryPoint);
}
}
void AdvancedAnalysis::findEntryPoints()
{
duint modbase = ModBaseFromAddr(mBase);
if(modbase)
{
apienumexports(modbase, [&](duint Base, const char* Module, const char* Name, duint Address)
{
// If within limits...
if(inRange(Address))
{
mCandidateEPs.insert(Address);
}
});
}
for(const auto & vec : mXrefs)
{
duint jmps = 0, calls = 0;
duint addr = vec.first;
for(const auto & xref : vec.second)
{
if(xref.type == XREF_CALL)
calls++;
else if(xref.type == XREF_JMP)
jmps++;
}
if(calls >= 1 && jmps + calls > 1)
mCandidateEPs.insert(addr);
else if(calls >= 1)
mFuzzyEPs.insert(addr);
}
}
void AdvancedAnalysis::analyzeCandidateFunctions(bool writedata)
{
std::unordered_set<duint> pendingEPs;
while(true)
{
pendingEPs.clear();
if(mCandidateEPs.size() == 0)
return;
for(const auto & entryPoint : mCandidateEPs)
{
pendingEPs.insert(entryPoint);
}
mCandidateEPs.clear();
for(const auto & entryPoint : pendingEPs)
{
if(mEntryPoints.find(entryPoint) == mEntryPoints.end())
{
analyzeFunction(entryPoint, true);
}
}
}
} |
C/C++ | x64dbg-development/src/dbg/analysis/advancedanalysis.h | #pragma once
#include "analysis.h"
class AdvancedAnalysis : public Analysis
{
public:
explicit AdvancedAnalysis(duint base, duint size, bool dump = false);
~AdvancedAnalysis();
void Analyse() override;
void SetMarkers() override;
using UintSet = std::unordered_set<duint>;
template<class T>
using UintMap = std::unordered_map<duint, T>;
struct CFNode
{
duint parentGraph; //function of which this node is a part
duint start; //start of the block
duint end; //end of the block (inclusive)
duint brtrue; //destination if condition is true
duint brfalse; //destination if condition is false
duint icount; //number of instructions in node
bool terminal; //node is a RET
explicit CFNode(duint parentGraph, duint start, duint end)
: parentGraph(parentGraph),
start(start),
end(end),
brtrue(0),
brfalse(0),
icount(0),
terminal(false)
{
}
explicit CFNode()
: CFNode(0, 0, 0)
{
}
String ToString() const
{
return StringUtils::sprintf("start: %p\nend: %p\nfunction: %p", start, end, parentGraph);
}
};
struct CFGraph
{
duint entryPoint; //graph entry point
UintMap<CFNode> nodes; //CFNode.start -> CFNode
UintMap<UintSet> parents; //CFNode.start -> parents
explicit CFGraph(duint entryPoint)
: entryPoint(entryPoint)
{
}
void AddNode(const CFNode & node)
{
nodes[node.start] = node;
AddParent(node.start, node.brtrue);
AddParent(node.start, node.brfalse);
}
void AddParent(duint child, duint parent)
{
if(!child || !parent)
return;
auto found = parents.find(child);
if(found == parents.end())
{
UintSet p;
p.insert(parent);
parents[child] = p;
}
else
found->second.insert(parent);
}
const char* GetNodeColor(const CFNode & node) const
{
if(node.terminal)
return "firebrick";
if(node.start == entryPoint)
return "forestgreen";
return "lightblue";
}
String ToDot() const
{
String result = "digraph CFGraph {\n";
for(const auto & node : nodes)
result += StringUtils::sprintf(" n%p[label=\"%s\" style=filled fillcolor=%s shape=box]\n",
node.second.start,
node.second.ToString().c_str(),
GetNodeColor(node.second));
result += "\n";
for(const auto & node : nodes)
{
if(node.second.brtrue)
result += StringUtils::sprintf(" n%p-> n%p [color=green]\n",
node.second.start,
node.second.brtrue);
if(node.second.brfalse)
result += StringUtils::sprintf(" n%p-> n%p [color=red]\n",
node.second.start,
node.second.brfalse);
}
result += "\n";
for(const auto & parent : parents)
{
for(const auto & node : parent.second)
result += StringUtils::sprintf(" n%p-> n%p [style=dotted color=grey]\n",
node,
parent.first);
}
result += "}";
return result;
}
};
protected:
struct XREF
{
duint addr;
duint from;
XREFTYPE type;
bool valid;
};
std::unordered_set<duint> mEntryPoints;
std::unordered_set<duint> mCandidateEPs;
std::unordered_set<duint> mFuzzyEPs;
std::vector<CFGraph> mFunctions;
std::unordered_map<duint, std::vector<XREF>> mXrefs;
byte* mEncMap;
private:
bool mDump;
void linearXrefPass();
void findInvalidXrefs();
void writeDataXrefs();
void findFuzzyEntryPoints();
void findEntryPoints();
void analyzeCandidateFunctions(bool writedata);
void analyzeFunction(duint entryPoint, bool writedata);
}; |
C++ | x64dbg-development/src/dbg/analysis/analysis.cpp | #include "analysis.h"
#include "memory.h"
#include "debugger.h"
Analysis::Analysis(duint base, duint size)
{
mBase = base;
mSize = size;
mData = new unsigned char[mSize + MAX_DISASM_BUFFER];
memset(mData, 0xCC, mSize + MAX_DISASM_BUFFER);
MemReadDumb(base, mData, size);
}
Analysis::~Analysis()
{
delete[] mData;
} |
C/C++ | x64dbg-development/src/dbg/analysis/analysis.h | #ifndef _ANALYSIS_H
#define _ANALYSIS_H
#include "_global.h"
#include <zydis_wrapper.h>
class Analysis
{
public:
explicit Analysis(duint base, duint size);
Analysis(const Analysis & that) = delete;
virtual ~Analysis();
virtual void Analyse() = 0;
virtual void SetMarkers() = 0;
protected:
duint mBase;
duint mSize;
unsigned char* mData;
Zydis mCp;
bool inRange(duint addr) const
{
return addr >= mBase && addr < mBase + mSize;
}
const unsigned char* translateAddr(duint addr) const
{
return inRange(addr) ? mData + (addr - mBase) : nullptr;
}
};
#endif //_ANALYSIS_H |
C++ | x64dbg-development/src/dbg/analysis/AnalysisPass.cpp | #include <assert.h>
#include <thread>
#include "AnalysisPass.h"
#include "memory.h"
AnalysisPass::AnalysisPass(duint VirtualStart, duint VirtualEnd, BBlockArray & MainBlocks) : m_MainBlocks(MainBlocks)
{
assert(VirtualEnd > VirtualStart);
// Internal class data
m_VirtualStart = VirtualStart;
m_VirtualEnd = VirtualEnd;
m_InternalMaxThreads = 0;
// Read remote instruction data to local memory
m_DataSize = VirtualEnd - VirtualStart;
m_Data = (unsigned char*)VirtualAlloc(nullptr, m_DataSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
if(!MemRead(VirtualStart, m_Data, m_DataSize))
{
VirtualFree(m_Data, 0, MEM_RELEASE);
assert(false);
}
}
AnalysisPass::~AnalysisPass()
{
if(m_Data)
VirtualFree(m_Data, 0, MEM_RELEASE);
}
BasicBlock* AnalysisPass::FindBBlockInRange(duint Address)
{
// NOTE: __MUST__ BE A SORTED VECTOR
//
// Use a binary search
duint indexLo = 0;
duint indexHi = m_MainBlocks.size();
// Get a pointer to pure data
const auto blocks = m_MainBlocks.data();
while(indexHi > indexLo)
{
duint indexMid = (indexLo + indexHi) / 2;
auto entry = &blocks[indexMid];
if(Address < entry->VirtualStart)
{
// Continue search in lower half
indexHi = indexMid;
}
else if(Address >= entry->VirtualEnd)
{
// Continue search in upper half
indexLo = indexMid + 1;
}
else
{
// Address is within limits, return entry
return entry;
}
}
// Not found
return nullptr;
}
duint AnalysisPass::FindBBlockIndex(BasicBlock* Block)
{
// Fast pointer arithmetic to find index
return ((duint)Block - (duint)m_MainBlocks.data()) / sizeof(BasicBlock);
}
duint AnalysisPass::IdealThreadCount()
{
if(m_InternalMaxThreads == 0)
{
// Determine the maximum hardware thread count at once
duint maximumThreads = max(std::thread::hardware_concurrency(), 1);
// Don't consume 100% of the CPU, adjust accordingly
if(maximumThreads > 1)
maximumThreads -= 1;
SetIdealThreadCount(maximumThreads);
}
return m_InternalMaxThreads;
}
void AnalysisPass::SetIdealThreadCount(duint Count)
{
m_InternalMaxThreads = (BYTE)min(Count, 255);
} |
C/C++ | x64dbg-development/src/dbg/analysis/AnalysisPass.h | #pragma once
#include "_global.h"
#include "BasicBlock.h"
class AnalysisPass
{
public:
AnalysisPass(duint VirtualStart, duint VirtualEnd, BBlockArray & MainBlocks);
virtual ~AnalysisPass();
virtual const char* GetName() = 0;
virtual bool Analyse() = 0;
protected:
duint m_VirtualStart;
duint m_VirtualEnd;
duint m_DataSize;
unsigned char* m_Data;
BBlockArray & m_MainBlocks;
unsigned char* TranslateAddress(duint Address)
{
ASSERT_TRUE(ValidateAddress(Address));
return &m_Data[Address - m_VirtualStart];
}
bool ValidateAddress(duint Address)
{
return (Address >= m_VirtualStart && Address < m_VirtualEnd);
}
BasicBlock* FindBBlockInRange(duint Address);
duint FindBBlockIndex(BasicBlock* Block);
duint IdealThreadCount();
void SetIdealThreadCount(duint Count);
private:
BYTE m_InternalMaxThreads;
}; |
C++ | x64dbg-development/src/dbg/analysis/analysis_nukem.cpp | #include "analysis_nukem.h"
#include "BasicBlock.h"
#include "LinearPass.h"
#include "FunctionPass.h"
#include "console.h"
void Analyse_nukem(duint base, duint size)
{
dputs("Starting analysis (Nukem)...");
DWORD ticks = GetTickCount();
duint end = base + size;
BBlockArray blocks;
LinearPass pass1(base, end, blocks);
pass1.Analyse();
FunctionPass pass2(base, end, blocks);
pass2.Analyse();
dprintf("Analysis finished in %ums!\n", GetTickCount() - ticks);
} |
C/C++ | x64dbg-development/src/dbg/analysis/BasicBlock.h | #pragma once
#include "_global.h"
enum BasicBlockFlags : duint
{
BASIC_BLOCK_FLAG_NONE = 0, // No flag
BASIC_BLOCK_FLAG_FUNCTION = (1 << 1), // Scanned; also part of a known function
BASIC_BLOCK_FLAG_CUTOFF = (1 << 3), // Ends prematurely because of another JMP to location
BASIC_BLOCK_FLAG_DELETE = (1 << 4), // Delete element at the next possible time
BASIC_BLOCK_FLAG_CALL = (1 << 5), // The block ends with a call
BASIC_BLOCK_FLAG_RET = (1 << 6), // The block ends with a retn
BASIC_BLOCK_FLAG_ABSJMP = (1 << 7), // Branch is absolute
BASIC_BLOCK_FLAG_INDIRECT = (1 << 8), // This block ends with an indirect branch; memory or register
BASIC_BLOCK_FLAG_INDIRPTR = (1 << 9), // This block ends with an indirect branch; pointer known
BASIC_BLOCK_FLAG_CALL_TARGET = (1 << 10), // Block is pointed to by a call instruction
//BASIC_BLOCK_FLAG_JMP_TARGET = (1 << 11),
BASIC_BLOCK_FLAG_PREPAD = (1 << 12), // Block ends because there was padding afterwards
BASIC_BLOCK_FLAG_PAD = (1 << 13), // Block is only a series of padding instructions
};
struct BasicBlock
{
duint VirtualStart; // Inclusive
duint VirtualEnd; // Inclusive
duint Flags;
duint Target;
duint InstrCount; // Number of instructions in block
__forceinline bool GetFlag(duint Flag)
{
return (Flags & Flag) == Flag;
}
__forceinline void SetFlag(duint Flag)
{
Flags |= Flag;
}
__forceinline duint Size()
{
return VirtualEnd - VirtualStart;
}
bool operator< (const BasicBlock & b) const
{
return VirtualStart < b.VirtualStart;
}
bool operator== (const BasicBlock & b) const
{
return VirtualStart == b.VirtualStart;
}
};
struct FunctionDef
{
duint VirtualStart; // Inclusive
duint VirtualEnd; // Inclusive
duint BBlockStart; // Index of first basic block
duint BBlockEnd; // Index of last basic block
duint InstrCount; // Number of instructions in function
bool operator< (const FunctionDef & b) const
{
if(VirtualStart == b.VirtualStart)
return VirtualEnd > b.VirtualEnd;
return VirtualStart < b.VirtualStart;
}
bool operator== (const FunctionDef & b) const
{
return VirtualStart == b.VirtualStart;
}
};
typedef std::vector<BasicBlock> BBlockArray;
typedef std::vector<FunctionDef> FuncDefArray; |
C++ | x64dbg-development/src/dbg/analysis/CodeFollowPass.cpp | #include "AnalysisPass.h"
#include "CodeFollowPass.h"
CodeFollowPass::CodeFollowPass(duint VirtualStart, duint VirtualEnd, BBlockArray & MainBlocks)
: AnalysisPass(VirtualStart, VirtualEnd, MainBlocks)
{
}
CodeFollowPass::~CodeFollowPass()
{
}
const char* CodeFollowPass::GetName()
{
return "Code Follower";
}
bool CodeFollowPass::Analyse()
{
// First gather all possible function references with certain tables
//
// This includes:
// Main entry
// Module exports
// Module import references (?)
// Control flow guard
// RUNTIME_FUNCTION
// TLS callbacks
// FLS callbacks
return false;
}
duint CodeFollowPass::GetReferenceOperand(const ZydisDecodedInstruction & Context)
{
for(int i = 0; i < Context.operandCount; i++)
{
auto operand = Context.operands[i];
// Looking for immediate references
if(operand.type == ZYDIS_OPERAND_TYPE_IMMEDIATE)
{
duint dest = (duint)operand.imm.value.u;
if(ValidateAddress(dest))
return dest;
}
}
return 0;
}
duint CodeFollowPass::GetMemoryOperand(Zydis & Disasm, const ZydisDecodedInstruction & Context, bool* Indirect)
{
if(Context.operandCount <= 0)
return 0;
// Only the first operand matters
auto operand = Context.operands[0];
// Jumps and calls only
if(Disasm.IsCall() || Disasm.IsJump())
{
// Looking for memory references
if(operand.type == ZYDIS_OPERAND_TYPE_MEMORY)
{
// Notify if the operand was indirect
if(Indirect)
{
if(operand.mem.base != ZYDIS_REGISTER_NONE ||
operand.mem.index != ZYDIS_REGISTER_NONE ||
operand.mem.scale != 0)
{
*Indirect = true;
return 0;
}
}
// TODO: Read pointer
// TODO: Find virtual tables (new pass?)
// TODO: Translate RIP-Relative
return 0;
duint dest = (duint)operand.mem.disp.value;
if(ValidateAddress(dest))
return dest;
}
}
return 0;
} |
C/C++ | x64dbg-development/src/dbg/analysis/CodeFollowPass.h | #pragma once
#include "AnalysisPass.h"
#include "BasicBlock.h"
#include <zydis_wrapper.h>
class CodeFollowPass : public AnalysisPass
{
public:
CodeFollowPass(duint VirtualStart, duint VirtualEnd, BBlockArray & MainBlocks);
virtual ~CodeFollowPass();
virtual const char* GetName() override;
virtual bool Analyse() override;
private:
duint GetReferenceOperand(const ZydisDecodedInstruction & Context);
duint GetMemoryOperand(Zydis & Disasm, const ZydisDecodedInstruction & Context, bool* Indirect);
}; |
C++ | x64dbg-development/src/dbg/analysis/controlflowanalysis.cpp | #include "controlflowanalysis.h"
#include "console.h"
#include "module.h"
#include "TitanEngine/TitanEngine.h"
#include "memory.h"
#include "function.h"
ControlFlowAnalysis::ControlFlowAnalysis(duint base, duint size, bool exceptionDirectory)
: Analysis(base, size),
mFunctionInfoSize(0),
mFunctionInfoData(nullptr)
{
#ifdef _WIN64
// This will only be valid if the address range is within a loaded module
mModuleBase = ModBaseFromAddr(base);
if(exceptionDirectory && mModuleBase != 0)
{
char modulePath[MAX_PATH];
memset(modulePath, 0, sizeof(modulePath));
ModPathFromAddr(mModuleBase, modulePath, ARRAYSIZE(modulePath));
HANDLE fileHandle;
DWORD fileSize;
HANDLE fileMapHandle;
ULONG_PTR fileMapVa;
if(StaticFileLoadW(
StringUtils::Utf8ToUtf16(modulePath).c_str(),
UE_ACCESS_READ,
false,
&fileHandle,
&fileSize,
&fileMapHandle,
&fileMapVa))
{
// Find a pointer to IMAGE_DIRECTORY_ENTRY_EXCEPTION for later use
auto virtualOffset = GetPE32DataFromMappedFile(fileMapVa, IMAGE_DIRECTORY_ENTRY_EXCEPTION, UE_SECTIONVIRTUALOFFSET);
mFunctionInfoSize = duint(GetPE32DataFromMappedFile(fileMapVa, IMAGE_DIRECTORY_ENTRY_EXCEPTION, UE_SECTIONVIRTUALSIZE));
// Unload the file
StaticFileUnloadW(nullptr, false, fileHandle, fileSize, fileMapHandle, fileMapVa);
// Get a copy of the function table
if(virtualOffset)
{
// Read the table into a buffer
mFunctionInfoData = emalloc(mFunctionInfoSize);
if(mFunctionInfoData)
MemRead(virtualOffset + mModuleBase, mFunctionInfoData, mFunctionInfoSize);
}
}
}
#endif //_WIN64
}
ControlFlowAnalysis::~ControlFlowAnalysis()
{
if(mFunctionInfoData)
efree(mFunctionInfoData);
}
void ControlFlowAnalysis::Analyse()
{
dputs("Starting analysis...");
auto ticks = GetTickCount();
BasicBlockStarts();
dprintf("Basic block starts in %ums!\n", GetTickCount() - ticks);
ticks = GetTickCount();
BasicBlocks();
dprintf("Basic blocks in %ums!\n", GetTickCount() - ticks);
ticks = GetTickCount();
Functions();
dprintf("Functions in %ums!\n", GetTickCount() - ticks);
ticks = GetTickCount();
FunctionRanges();
dprintf("Function ranges in %ums!\n", GetTickCount() - ticks);
dprintf("Analysis finished!\n");
}
void ControlFlowAnalysis::SetMarkers()
{
FunctionDelRange(mBase, mBase + mSize - 1, false);
auto size = mFunctionRanges.size();
for(auto i = size - 1; i != -1; i--)
{
const auto & range = mFunctionRanges[i];
FunctionAdd(range.first, range.second, false);
}
/*dprintf("digraph ControlFlow {\n");
int i = 0;
std::map<duint, int> nodeMap;
for(const auto & it : mBlocks)
{
const auto & block = it.second;
nodeMap.insert({ block.start, i });
dprintf(" node%u [label=\"s=%p, e=%p, f=%p\"];\n", i, block.start, block.end, block.function);
i++;
}
for(auto it : mBlocks)
{
const auto & block = it.second;
int startNode = nodeMap[block.start];
if(block.left)
{
if(nodeMap.count(block.left))
dprintf(" node%u -> node%u;\n", startNode, nodeMap[block.left]);
}
else
{
dprintf(" node%u [shape=point];\n", i);
dprintf(" node%u -> node%u;\n", startNode, i);
i++;
}
if(block.right)
{
if(nodeMap.count(block.right))
dprintf(" node%u -> node%u;\n", startNode, nodeMap[block.right]);
}
else
{
dprintf(" node%u [shape=point];\n", i);
dprintf(" node%u -> node%u;\n", startNode, i);
i++;
}
}
dprintf("}\n");*/
}
void ControlFlowAnalysis::BasicBlockStarts()
{
mBlockStarts.insert(mBase);
auto bSkipFilling = false;
for(duint i = 0; i < mSize;)
{
auto addr = mBase + i;
if(mCp.Disassemble(addr, translateAddr(addr), MAX_DISASM_BUFFER))
{
if(bSkipFilling) //handle filling skip mode
{
if(!mCp.IsFilling()) //do nothing until the filling stopped
{
bSkipFilling = false;
mBlockStarts.insert(addr);
}
}
else if(mCp.IsRet()) //RET breaks control flow
{
bSkipFilling = true; //skip INT3/NOP/whatever filling bytes (those are not part of the control flow)
}
else if(mCp.IsJump() || mCp.IsLoop()) //branches
{
auto dest1 = getReferenceOperand();
duint dest2 = 0;
if(mCp.GetId() != ZYDIS_MNEMONIC_JMP) //conditional jump
dest2 = addr + mCp.Size();
if(!dest1 && !dest2) //TODO: better code for this (make sure absolutely no filling is inserted)
bSkipFilling = true;
if(dest1)
mBlockStarts.insert(dest1);
if(dest2)
mBlockStarts.insert(dest2);
}
else if(mCp.IsCall())
{
auto dest1 = getReferenceOperand();
if(dest1)
{
mBlockStarts.insert(dest1);
mFunctionStarts.insert(dest1);
}
}
else
{
auto dest1 = getReferenceOperand();
if(dest1)
mBlockStarts.insert(dest1);
}
i += mCp.Size();
}
else
i++;
}
}
void ControlFlowAnalysis::BasicBlocks()
{
for(auto i = mBlockStarts.begin(); i != mBlockStarts.end(); ++i)
{
auto start = *i;
if(!inRange(start))
continue;
auto nextStart = mBase + mSize;
auto next = std::next(i);
if(next != mBlockStarts.end())
nextStart = *next;
for(duint addr = start, prevaddr; addr < mBase + mSize;)
{
prevaddr = addr;
if(mCp.Disassemble(addr, translateAddr(addr), MAX_DISASM_BUFFER))
{
if(mCp.IsRet())
{
insertBlock(BasicBlock(start, addr, 0, 0)); //leaf block
break;
}
else if(mCp.IsJump() || mCp.IsLoop())
{
auto dest1 = getReferenceOperand();
auto dest2 = mCp.GetId() != ZYDIS_MNEMONIC_JMP ? addr + mCp.Size() : 0;
insertBlock(BasicBlock(start, addr, dest1, dest2));
insertParent(dest1, start);
insertParent(dest2, start);
break;
}
addr += mCp.Size();
}
else
addr++;
if(addr == nextStart) //special case handling overlapping blocks
{
insertBlock(BasicBlock(start, prevaddr, 0, nextStart));
insertParent(nextStart, start);
break;
}
}
}
mBlockStarts.clear();
#ifdef _WIN64
auto count = 0;
enumerateFunctionRuntimeEntries64([&](PRUNTIME_FUNCTION Function)
{
auto funcAddr = mModuleBase + Function->BeginAddress;
auto funcEnd = mModuleBase + Function->EndAddress;
// If within limits...
if(inRange(funcAddr) && inRange(funcEnd))
mFunctionStarts.insert(funcAddr);
count++;
return true;
});
dprintf("%d functions from the exception directory...\n", count);
#endif // _WIN64
dprintf("%d basic blocks, %d function starts detected...\n", int(mBlocks.size()), int(mFunctionStarts.size()));
}
void ControlFlowAnalysis::Functions()
{
typedef std::pair<BasicBlock*, const UintSet*> DelayedBlock;
std::vector<DelayedBlock> delayedBlocks;
for(auto & it : mBlocks)
{
auto block = &it.second;
auto parents = findParents(block->start);
if(!block->function)
{
if(!parents || mFunctionStarts.count(block->start)) //no parents = function start
{
auto functionStart = block->start;
block->function = functionStart;
UintSet functionBlocks;
functionBlocks.insert(functionStart);
mFunctions[functionStart] = functionBlocks;
}
else //in function
{
auto function = findFunctionStart(block, parents);
if(!function) //this happens with loops / unreferenced blocks sometimes
delayedBlocks.push_back(DelayedBlock(block, parents));
else
block->function = function;
}
}
else
DebugBreak(); //this should not happen
}
auto delayedCount = int(delayedBlocks.size());
dprintf("%d/%d delayed blocks...\n", delayedCount, int(mBlocks.size()));
auto resolved = 0;
for(auto & delayedBlock : delayedBlocks)
{
auto block = delayedBlock.first;
auto parents = delayedBlock.second;
auto function = findFunctionStart(block, parents);
if(!function)
{
continue;
/*dprintf("unresolved block %s\n", blockToString(block).c_str());
if(parents)
{
dprintf("parents:\n");
for(auto parent : *parents)
dprintf(" %s\n", blockToString(findBlock(parent)).c_str());
}
else
dprintf("parents: null");
dprintf("left: %s\n", blockToString(findBlock(block->left)).c_str());
dprintf("right: %s\n", blockToString(findBlock(block->right)).c_str());
return;*/
}
block->function = function;
resolved++;
}
dprintf("%d/%d delayed blocks resolved (%d/%d still left, probably unreferenced functions)\n", resolved, delayedCount, delayedCount - resolved, int(mBlocks.size()));
auto unreferencedCount = 0;
for(const auto & block : mBlocks)
{
auto found = mFunctions.find(block.second.function);
if(found == mFunctions.end()) //unreferenced block
{
unreferencedCount++;
continue;
}
found->second.insert(block.second.start);
}
dprintf("%d/%u unreferenced blocks\n", unreferencedCount, DWORD(mBlocks.size()));
dprintf("%u functions found!\n", DWORD(mFunctions.size()));
}
void ControlFlowAnalysis::FunctionRanges()
{
//iterate over the functions and then find the deepest block = function end
for(const auto & function : mFunctions)
{
auto start = function.first;
auto end = start;
for(auto blockstart : function.second)
{
auto block = findBlock(blockstart);
if(!block)
__debugbreak(); //this shouldn't happen
if(block->end > end)
end = block->end;
}
mFunctionRanges.push_back({ start, end });
}
}
void ControlFlowAnalysis::insertBlock(const BasicBlock & block)
{
if(mBlocks.find(block.start) != mBlocks.end())
DebugBreak();
mBlocks[block.start] = block;
}
const ControlFlowAnalysis::BasicBlock* ControlFlowAnalysis::findBlock(duint start) const
{
if(!start)
return nullptr;
auto found = mBlocks.find(start);
return found != mBlocks.end() ? &found->second : nullptr;
}
void ControlFlowAnalysis::insertParent(duint child, duint parent)
{
if(!child || !parent)
return;
auto found = mParentMap.find(child);
if(found == mParentMap.end())
{
UintSet parents;
parents.insert(parent);
mParentMap[child] = parents;
}
else
found->second.insert(parent);
}
const ControlFlowAnalysis::UintSet* ControlFlowAnalysis::findParents(duint child) const
{
if(!child)
return nullptr;
auto found = mParentMap.find(child);
return found != mParentMap.end() ? &found->second : nullptr;
}
duint ControlFlowAnalysis::findFunctionStart(const BasicBlock* block, const UintSet* parents) const
{
if(!block)
return 0;
if(block->function)
return block->function;
auto left = findBlock(block->left);
if(left && left->function)
return left->function;
auto right = findBlock(block->right);
if(right && right->function)
return right->function;
for(auto start : *parents)
{
auto parent = findBlock(start);
if(parent->function)
return parent->function;
}
return 0;
}
String ControlFlowAnalysis::blockToString(const BasicBlock* block)
{
if(!block)
return String("null");
return block->toString();
}
duint ControlFlowAnalysis::getReferenceOperand() const
{
for(auto i = 0; i < mCp.OpCount(); i++)
{
const auto & op = mCp[i];
if(op.type == ZYDIS_OPERAND_TYPE_IMMEDIATE)
{
auto dest = duint(op.imm.value.u);
if(inRange(dest))
return dest;
}
else if(op.type == ZYDIS_OPERAND_TYPE_MEMORY)
{
auto dest = duint(op.mem.disp.value);
if(op.mem.base == ZYDIS_REGISTER_RIP) //rip-relative
dest += mCp.Address() + mCp.Size();
if(inRange(dest))
return dest;
}
}
return 0;
}
#ifdef _WIN64
void ControlFlowAnalysis::enumerateFunctionRuntimeEntries64(const std::function<bool(PRUNTIME_FUNCTION)> & Callback) const
{
if(!mFunctionInfoData)
return;
// Get the table pointer and size
auto functionTable = PRUNTIME_FUNCTION(mFunctionInfoData);
auto totalCount = mFunctionInfoSize / sizeof(RUNTIME_FUNCTION);
// Enumerate each entry
for(duint i = 0; i < totalCount; i++)
{
if(!Callback(&functionTable[i]))
break;
}
}
#endif // _WIN64 |
C/C++ | x64dbg-development/src/dbg/analysis/controlflowanalysis.h | #ifndef _CONTROLFLOWANALYSIS_H
#define _CONTROLFLOWANALYSIS_H
#include "_global.h"
#include "analysis.h"
#include "addrinfo.h"
#include <functional>
class ControlFlowAnalysis : public Analysis
{
public:
explicit ControlFlowAnalysis(duint base, duint size, bool exceptionDirectory);
~ControlFlowAnalysis();
void Analyse() override;
void SetMarkers() override;
private:
struct BasicBlock
{
duint start;
duint end;
duint left;
duint right;
duint function;
BasicBlock()
: BasicBlock(0, 0, 0, 0)
{
}
BasicBlock(duint start, duint end, duint left, duint right)
: start(start),
end(end),
left(min(left, right)),
right(min(left, right)),
function(0)
{
}
String toString() const
{
return StringUtils::sprintf("start:%p,end:%p,left:%p,right:%p,func:%p", start, end, left, right, function);
}
};
typedef std::unordered_set<duint> UintSet;
duint mModuleBase;
duint mFunctionInfoSize;
void* mFunctionInfoData;
UintSet mBlockStarts;
UintSet mFunctionStarts;
std::unordered_map<duint, BasicBlock> mBlocks; //start of block -> block
std::unordered_map<duint, UintSet> mParentMap; //start child -> parents
std::unordered_map<duint, UintSet> mFunctions; //function start -> function block starts
std::vector<Range> mFunctionRanges; //function start -> function range TODO: smarter stuff with overlapping ranges
void BasicBlockStarts();
void BasicBlocks();
void Functions();
void FunctionRanges();
void insertBlock(const BasicBlock & block);
const BasicBlock* findBlock(duint start) const;
void insertParent(duint child, duint parent);
const UintSet* findParents(duint child) const;
duint findFunctionStart(const BasicBlock* block, const UintSet* parents) const;
static String blockToString(const BasicBlock* block);
duint getReferenceOperand() const;
#ifdef _WIN64
void enumerateFunctionRuntimeEntries64(const std::function<bool(PRUNTIME_FUNCTION)> & Callback) const;
#endif // _WIN64
};
#endif //_CONTROLFLOWANALYSIS_H |
C++ | x64dbg-development/src/dbg/analysis/exceptiondirectoryanalysis.cpp | #include "exceptiondirectoryanalysis.h"
#include "module.h"
#include "TitanEngine/TitanEngine.h"
#include "memory.h"
#include "console.h"
#include "function.h"
ExceptionDirectoryAnalysis::ExceptionDirectoryAnalysis(duint base, duint size)
: Analysis(base, size),
mFunctionInfoSize(0),
mFunctionInfoData(nullptr)
{
#ifdef _WIN64
// This will only be valid if the address range is within a loaded module
mModuleBase = ModBaseFromAddr(base);
if(mModuleBase != 0)
{
char modulePath[MAX_PATH];
memset(modulePath, 0, sizeof(modulePath));
ModPathFromAddr(mModuleBase, modulePath, ARRAYSIZE(modulePath));
HANDLE fileHandle;
DWORD fileSize;
HANDLE fileMapHandle;
ULONG_PTR fileMapVa;
if(StaticFileLoadW(
StringUtils::Utf8ToUtf16(modulePath).c_str(),
UE_ACCESS_READ,
false,
&fileHandle,
&fileSize,
&fileMapHandle,
&fileMapVa))
{
// Find a pointer to IMAGE_DIRECTORY_ENTRY_EXCEPTION for later use
auto virtualOffset = GetPE32DataFromMappedFile(fileMapVa, IMAGE_DIRECTORY_ENTRY_EXCEPTION, UE_SECTIONVIRTUALOFFSET);
mFunctionInfoSize = duint(GetPE32DataFromMappedFile(fileMapVa, IMAGE_DIRECTORY_ENTRY_EXCEPTION, UE_SECTIONVIRTUALSIZE));
// Unload the file
StaticFileUnloadW(nullptr, false, fileHandle, fileSize, fileMapHandle, fileMapVa);
// Get a copy of the function table
if(virtualOffset)
{
// Read the table into a buffer
mFunctionInfoData = emalloc(mFunctionInfoSize);
if(mFunctionInfoData)
MemRead(virtualOffset + mModuleBase, mFunctionInfoData, mFunctionInfoSize);
}
}
}
#endif //_WIN64
}
ExceptionDirectoryAnalysis::~ExceptionDirectoryAnalysis()
{
if(mFunctionInfoData)
efree(mFunctionInfoData);
}
void ExceptionDirectoryAnalysis::Analyse()
{
#ifdef _WIN64
EnumerateFunctionRuntimeEntries64([&](PRUNTIME_FUNCTION Function)
{
auto funcAddr = mModuleBase + Function->BeginAddress;
auto funcEnd = mModuleBase + Function->EndAddress - 1;
// If within limits...
if(inRange(funcAddr) && inRange(funcEnd) && funcAddr <= funcEnd)
mFunctions.push_back({ funcAddr, funcEnd });
return true;
});
dprintf(QT_TRANSLATE_NOOP("DBG", "%u functions discovered!\n"), DWORD(mFunctions.size()));
#else //x32
dputs(QT_TRANSLATE_NOOP("DBG", "This kind of analysis doesn't work on x32 executables...\n"));
#endif // _WIN64
}
void ExceptionDirectoryAnalysis::SetMarkers()
{
FunctionDelRange(mBase, mBase + mSize - 1, false);
for(const auto & function : mFunctions)
FunctionAdd(function.first, function.second, false);
}
#ifdef _WIN64
void ExceptionDirectoryAnalysis::EnumerateFunctionRuntimeEntries64(const std::function<bool(PRUNTIME_FUNCTION)> & Callback) const
{
if(!mFunctionInfoData)
return;
// Get the table pointer and size
auto functionTable = PRUNTIME_FUNCTION(mFunctionInfoData);
auto totalCount = mFunctionInfoSize / sizeof(RUNTIME_FUNCTION);
// Enumerate each entry
for(duint i = 0; i < totalCount; i++)
{
if(!Callback(&functionTable[i]))
break;
}
}
#endif // _WIN64 |
C/C++ | x64dbg-development/src/dbg/analysis/exceptiondirectoryanalysis.h | #ifndef _EXCEPTIONDIRECTORYANALYSIS_H
#define _EXCEPTIONDIRECTORYANALYSIS_H
#include "analysis.h"
#include <functional>
class ExceptionDirectoryAnalysis : public Analysis
{
public:
explicit ExceptionDirectoryAnalysis(duint base, duint size);
~ExceptionDirectoryAnalysis();
void Analyse() override;
void SetMarkers() override;
private:
duint mModuleBase;
duint mFunctionInfoSize;
void* mFunctionInfoData;
std::vector<std::pair<duint, duint>> mFunctions;
#ifdef _WIN64
void EnumerateFunctionRuntimeEntries64(const std::function<bool(PRUNTIME_FUNCTION)> & Callback) const;
#endif // _WIN64
};
#endif //_EXCEPTIONDIRECTORYANALYSIS_H |
C++ | x64dbg-development/src/dbg/analysis/FunctionPass.cpp | #include "FunctionPass.h"
#include <ppl.h>
#include "memory.h"
#include "console.h"
#include "debugger.h"
#include "module.h"
#include "function.h"
FunctionPass::FunctionPass(duint VirtualStart, duint VirtualEnd, BBlockArray & MainBlocks)
: AnalysisPass(VirtualStart, VirtualEnd, MainBlocks)
{
// Zero values
m_FunctionInfo = nullptr;
m_FunctionInfoSize = 0;
// This will only be valid if the address range is within a loaded module
m_ModuleStart = ModBaseFromAddr(VirtualStart);
if(m_ModuleStart != 0)
{
char modulePath[MAX_PATH];
memset(modulePath, 0, sizeof(modulePath));
ModPathFromAddr(m_ModuleStart, modulePath, ARRAYSIZE(modulePath));
HANDLE fileHandle;
DWORD fileSize;
HANDLE fileMapHandle;
ULONG_PTR fileMapVa;
if(StaticFileLoadW(
StringUtils::Utf8ToUtf16(modulePath).c_str(),
UE_ACCESS_READ,
false,
&fileHandle,
&fileSize,
&fileMapHandle,
&fileMapVa))
{
// Find a pointer to IMAGE_DIRECTORY_ENTRY_EXCEPTION for later use
ULONG_PTR virtualOffset = GetPE32DataFromMappedFile(fileMapVa, IMAGE_DIRECTORY_ENTRY_EXCEPTION, UE_SECTIONVIRTUALOFFSET);
m_FunctionInfoSize = (ULONG)GetPE32DataFromMappedFile(fileMapVa, IMAGE_DIRECTORY_ENTRY_EXCEPTION, UE_SECTIONVIRTUALSIZE);
// Unload the file
StaticFileUnloadW(nullptr, false, fileHandle, fileSize, fileMapHandle, fileMapVa);
// Get a copy of the function table
if(virtualOffset)
{
// Read the table into a buffer
m_FunctionInfo = BridgeAlloc(m_FunctionInfoSize);
if(m_FunctionInfo)
MemRead(virtualOffset + m_ModuleStart, m_FunctionInfo, m_FunctionInfoSize);
}
}
}
}
FunctionPass::~FunctionPass()
{
if(m_FunctionInfo)
BridgeFree(m_FunctionInfo);
}
const char* FunctionPass::GetName()
{
return "Function Analysis";
}
bool FunctionPass::Analyse()
{
// THREAD_WORK = ceil(TOTAL / # THREADS)
duint workAmount = (m_MainBlocks.size() + (IdealThreadCount() - 1)) / IdealThreadCount();
// Initialize thread vector
auto threadFunctions = new std::vector<FunctionDef>[IdealThreadCount()];
concurrency::parallel_for(duint(0), IdealThreadCount(), [&](duint i)
{
// Memory allocation optimization
// TODO: Option to conserve memory
threadFunctions[i].reserve(30000);
// Execute
duint threadWorkStart = (workAmount * i);
duint threadWorkStop = min((threadWorkStart + workAmount), m_MainBlocks.size());
AnalysisWorker(threadWorkStart, threadWorkStop, &threadFunctions[i]);
});
// Merge thread vectors into single local
std::vector<FunctionDef> funcs;
for(duint i = 0; i < IdealThreadCount(); i++)
std::move(threadFunctions[i].begin(), threadFunctions[i].end(), std::back_inserter(funcs));
// Sort and remove duplicates
std::sort(funcs.begin(), funcs.end());
funcs.erase(std::unique(funcs.begin(), funcs.end()), funcs.end());
dprintf(QT_TRANSLATE_NOOP("DBG", "%u functions\n"), DWORD(funcs.size()));
FunctionDelRange(m_VirtualStart, m_VirtualEnd - 1, false);
for(auto & func : funcs)
{
FunctionAdd(func.VirtualStart, func.VirtualEnd, false, func.InstrCount);
}
GuiUpdateAllViews();
delete[] threadFunctions;
return true;
}
void FunctionPass::AnalysisWorker(duint Start, duint End, std::vector<FunctionDef>* Blocks)
{
//
// Step 1: Use any defined functions in the PE function table
//
FindFunctionWorkerPrepass(Start, End, Blocks);
//
// Step 2: for each block that contains a CALL flag,
// add it to a local function start array
//
// NOTE: *Some* indirect calls are included
auto blockItr = std::next(m_MainBlocks.begin(), Start);
for(duint i = Start; i < End; i++, ++blockItr)
{
if(blockItr->GetFlag(BASIC_BLOCK_FLAG_CALL))
{
duint destination = blockItr->Target;
// Was it a pointer?
if(blockItr->GetFlag(BASIC_BLOCK_FLAG_INDIRPTR))
{
// Read it from memory
if(!MemRead(destination, &destination, sizeof(duint)))
continue;
// Validity check
if(!MemIsValidReadPtr(destination))
continue;
dprintf(QT_TRANSLATE_NOOP("DBG", "Indirect pointer: 0x%p 0x%p\n"), blockItr->Target, destination);
}
// Destination must be within analysis limits
if(!ValidateAddress(destination))
continue;
Blocks->push_back({ destination, 0, 0, 0, 0 });
}
}
//
// Step 3: Sort and remove duplicates
//
std::sort(Blocks->begin(), Blocks->end());
Blocks->erase(std::unique(Blocks->begin(), Blocks->end()), Blocks->end());
//
// Step 4: Find function ends
//
FindFunctionWorker(Blocks);
//
// Step 5: Find all orphaned blocks and repeat analysis process
//
// Starting from the first global block, scan until an "untouched" block is found
blockItr = std::next(m_MainBlocks.begin(), Start);
// Cached final block
BasicBlock* finalBlock = &m_MainBlocks.back();
duint virtEnd = 0;
for(duint i = Start; i < End; i++, ++blockItr)
{
if(blockItr->VirtualStart < virtEnd)
continue;
// Skip padding
if(blockItr->GetFlag(BASIC_BLOCK_FLAG_PAD))
continue;
// Is the block untouched?
if(blockItr->GetFlag(BASIC_BLOCK_FLAG_FUNCTION))
continue;
// Try to define a function
FunctionDef def { blockItr->VirtualStart, 0, 0, 0, 0 };
if(ResolveFunctionEnd(&def, finalBlock))
{
Blocks->push_back(def);
virtEnd = def.VirtualEnd;
}
}
}
void FunctionPass::FindFunctionWorkerPrepass(duint Start, duint End, std::vector<FunctionDef>* Blocks)
{
return;
const duint minFunc = std::next(m_MainBlocks.begin(), Start)->VirtualStart;
const duint maxFunc = std::next(m_MainBlocks.begin(), End - 1)->VirtualEnd;
#ifdef _WIN64
// RUNTIME_FUNCTION exception information
EnumerateFunctionRuntimeEntries64([&](PRUNTIME_FUNCTION Function)
{
const duint funcAddr = m_ModuleStart + Function->BeginAddress;
const duint funcEnd = m_ModuleStart + Function->EndAddress;
// If within limits...
if(funcAddr >= minFunc && funcAddr < maxFunc)
{
// Add the descriptor (virtual start/end)
Blocks->push_back({ funcAddr, funcEnd, 0, 0, 0 });
}
return true;
});
#endif // _WIN64
// Module exports (return value ignored)
apienumexports(m_ModuleStart, [&](duint Base, const char* Module, const char* Name, duint Address)
{
// If within limits...
if(Address >= minFunc && Address < maxFunc)
{
// Add the descriptor (virtual start)
Blocks->push_back({ Address, 0, 0, 0, 0 });
}
});
}
void FunctionPass::FindFunctionWorker(std::vector<FunctionDef>* Blocks)
{
// Cached final block
BasicBlock* finalBlock = &m_MainBlocks.back();
// Enumerate all function entries for this thread
for(auto & block : *Blocks)
{
// Sometimes the ending address is already supplied, so check first
if(block.VirtualEnd != 0)
{
if(ResolveKnownFunctionEnd(&block))
continue;
}
// Now the function end must be determined by heuristics (find manually)
ResolveFunctionEnd(&block, finalBlock);
}
}
bool FunctionPass::ResolveKnownFunctionEnd(FunctionDef* Function)
{
// Helper to link final blocks to function
auto startBlock = FindBBlockInRange(Function->VirtualStart);
auto endBlock = FindBBlockInRange(Function->VirtualEnd);
if(!startBlock || !endBlock)
return false;
// Find block start/end indices
Function->BBlockStart = FindBBlockIndex(startBlock);
Function->BBlockEnd = FindBBlockIndex(endBlock);
// Set the flag for blocks that have been scanned
for(BasicBlock* block = startBlock; (duint)block <= (duint)endBlock; block++)
{
// Block now in use
block->SetFlag(BASIC_BLOCK_FLAG_FUNCTION);
// Counter
Function->InstrCount += block->InstrCount;
}
return true;
}
bool FunctionPass::ResolveFunctionEnd(FunctionDef* Function, BasicBlock* LastBlock)
{
ASSERT_TRUE(Function->VirtualStart != 0);
// Find the first basic block of the function
BasicBlock* block = FindBBlockInRange(Function->VirtualStart);
if(!block)
{
ASSERT_ALWAYS("Block should exist at this point");
return false;
}
// The maximum address is determined by any jump that extends past
// a RET or other terminating basic block. A function may have multiple
// return statements.
duint maximumAddr = 0;
// Loop forever until the end is found
for(; (duint)block <= (duint)LastBlock; block++)
{
if(block->GetFlag(BASIC_BLOCK_FLAG_CALL_TARGET) && block->VirtualStart != Function->VirtualStart)
{
block--;
break;
}
// Block is now in use
block->SetFlag(BASIC_BLOCK_FLAG_FUNCTION);
// Increment instruction count
Function->InstrCount += block->InstrCount;
// Calculate max from just linear instructions
maximumAddr = max(maximumAddr, block->VirtualEnd);
// Find maximum jump target
if(!block->GetFlag(BASIC_BLOCK_FLAG_CALL) && !block->GetFlag(BASIC_BLOCK_FLAG_INDIRECT))
{
if(block->Target != 0 && block->Target >= maximumAddr)
{
// Here's a problem: Compilers add tail-call elimination with a jump.
// Solve this by creating a maximum jump limit.
auto targetBlock = FindBBlockInRange(block->Target);
// If (target block found) and (target block is not called)
if(targetBlock && !targetBlock->GetFlag(BASIC_BLOCK_FLAG_CALL_TARGET))
{
duint blockEnd = targetBlock->VirtualEnd;
//
// Edge case when a compiler emits:
//
// pop ebp
// jmp some_func
// int3
// int3
// some_func:
// push ebp
//
// Where INT3 will align "some_func" to 4, 8, 12, or 16.
// INT3 padding is also optional (if the jump fits perfectly).
//
if(true/*block->GetFlag(BASIC_BLOCK_FLAG_ABSJMP)*/)
{
{
// Check if padding is aligned to 4
auto nextBlock = block + 1;
if((duint)nextBlock <= (duint)LastBlock)
{
if(nextBlock->GetFlag(BASIC_BLOCK_FLAG_PAD))
{
// If this block is aligned to 4 bytes at the end
if((nextBlock->VirtualEnd + 1) % 4 == 0)
blockEnd = block->VirtualEnd;
}
}
}
}
// Now calculate the maximum end address, taking into account the jump destination
maximumAddr = max(maximumAddr, blockEnd);
}
}
}
// Coherence check
ASSERT_TRUE(maximumAddr >= block->VirtualStart);
// Does this node contain the maximum address?
if(maximumAddr >= block->VirtualStart && maximumAddr <= block->VirtualEnd)
{
// It does! There's 4 possibilities next:
//
// 1. Return
// 2. Tail-call elimination
// 3. Optimized loop
// 4. Function continues to next block
//
// 1.
if(block->GetFlag(BASIC_BLOCK_FLAG_RET))
break;
if(block->Target != 0)
{
// NOTE: Both must be an absolute jump
if(block->GetFlag(BASIC_BLOCK_FLAG_ABSJMP))
{
// 2.
if(block->VirtualEnd == maximumAddr)
break;
// 3.
if(block->Target >= Function->VirtualStart && block->Target < block->VirtualEnd)
break;
}
}
// 4. Continue
}
}
// Loop is done. Set the information in the function structure.
Function->VirtualEnd = block->VirtualEnd;
Function->BBlockEnd = FindBBlockIndex(block);
return true;
}
#ifdef _WIN64
void FunctionPass::EnumerateFunctionRuntimeEntries64(const std::function<bool(PRUNTIME_FUNCTION)> & Callback)
{
if(!m_FunctionInfo)
return;
// Get the table pointer and size
auto functionTable = (PRUNTIME_FUNCTION)m_FunctionInfo;
size_t totalCount = (m_FunctionInfoSize / sizeof(RUNTIME_FUNCTION));
// Enumerate each entry
for(size_t i = 0; i < totalCount; i++)
{
if(!Callback(&functionTable[i]))
break;
}
}
#endif // _WIN64 |
C/C++ | x64dbg-development/src/dbg/analysis/FunctionPass.h | #pragma once
#include <functional>
#include "AnalysisPass.h"
#include "BasicBlock.h"
class FunctionPass : public AnalysisPass
{
public:
FunctionPass(duint VirtualStart, duint VirtualEnd, BBlockArray & MainBlocks);
virtual ~FunctionPass();
virtual const char* GetName() override;
virtual bool Analyse() override;
private:
duint m_ModuleStart;
PVOID m_FunctionInfo;
ULONG m_FunctionInfoSize;
void AnalysisWorker(duint Start, duint End, std::vector<FunctionDef>* Blocks);
void FindFunctionWorkerPrepass(duint Start, duint End, std::vector<FunctionDef>* Blocks);
void FindFunctionWorker(std::vector<FunctionDef>* Blocks);
bool ResolveKnownFunctionEnd(FunctionDef* Function);
bool ResolveFunctionEnd(FunctionDef* Function, BasicBlock* LastBlock);
#ifdef _WIN64
void EnumerateFunctionRuntimeEntries64(const std::function<bool(PRUNTIME_FUNCTION)> & Callback);
#endif // _WIN64
}; |
C++ | x64dbg-development/src/dbg/analysis/linearanalysis.cpp | #include "linearanalysis.h"
#include "console.h"
#include "memory.h"
#include "function.h"
#include <algorithm>
LinearAnalysis::LinearAnalysis(duint base, duint size) : Analysis(base, size)
{
}
void LinearAnalysis::Analyse()
{
dputs("Starting analysis...");
auto ticks = GetTickCount();
populateReferences();
dprintf("%u called functions populated\n", DWORD(mFunctions.size()));
analyseFunctions();
dprintf("Analysis finished in %ums!\n", GetTickCount() - ticks);
}
void LinearAnalysis::SetMarkers()
{
FunctionDelRange(mBase, mBase + mSize - 1, false);
for(auto & function : mFunctions)
{
if(!function.end)
continue;
FunctionAdd(function.start, function.end, false);
}
}
void LinearAnalysis::sortCleanup()
{
//sort & remove duplicates
std::sort(mFunctions.begin(), mFunctions.end());
auto last = std::unique(mFunctions.begin(), mFunctions.end());
mFunctions.erase(last, mFunctions.end());
}
void LinearAnalysis::populateReferences()
{
//linear immediate reference scan (call <addr>, push <addr>, mov [somewhere], <addr>)
for(duint i = 0; i < mSize;)
{
auto addr = mBase + i;
if(mCp.Disassemble(addr, translateAddr(addr), MAX_DISASM_BUFFER))
{
auto ref = getReferenceOperand();
if(ref)
mFunctions.push_back({ ref, 0 });
i += mCp.Size();
}
else
i++;
}
sortCleanup();
}
void LinearAnalysis::analyseFunctions()
{
for(size_t i = 0; i < mFunctions.size(); i++)
{
auto & function = mFunctions[i];
if(function.end) //skip already-analysed functions
continue;
auto maxaddr = mBase + mSize;
if(i < mFunctions.size() - 1)
maxaddr = mFunctions[i + 1].start;
auto end = findFunctionEnd(function.start, maxaddr);
if(end)
{
if(mCp.Disassemble(end, translateAddr(end), MAX_DISASM_BUFFER))
function.end = end + mCp.Size() - 1;
else
function.end = end;
}
}
}
duint LinearAnalysis::findFunctionEnd(duint start, duint maxaddr)
{
//disassemble first instruction for some heuristics
if(mCp.Disassemble(start, translateAddr(start), MAX_DISASM_BUFFER))
{
//JMP [123456] ; import
if(mCp.IsJump() && mCp.OpCount() && mCp[0].type == ZYDIS_OPERAND_TYPE_MEMORY)
return 0;
}
//linear search with some trickery
duint end = 0;
duint jumpback = 0;
for(duint addr = start, fardest = 0; addr < maxaddr;)
{
if(mCp.Disassemble(addr, translateAddr(addr), MAX_DISASM_BUFFER))
{
if(addr + mCp.Size() > maxaddr) //we went past the maximum allowed address
break;
if((mCp.IsJump() || mCp.IsLoop()) && mCp.OpCount() && mCp[0].type == ZYDIS_OPERAND_TYPE_IMMEDIATE) //jump
{
auto dest = duint(mCp[0].imm.value.u);
if(dest >= maxaddr) //jump across function boundaries
{
//currently unused
}
else if(dest > addr && dest > fardest) //save the farthest JXX destination forward
{
fardest = dest;
}
else if(end && dest < end && (mCp.GetId() == ZYDIS_MNEMONIC_JMP || mCp.GetId() == ZYDIS_MNEMONIC_LOOP)) //save the last JMP backwards
{
jumpback = addr;
}
}
else if(mCp.IsRet()) //possible function end?
{
end = addr;
if(fardest < addr) //we stop if the farthest JXX destination forward is before this RET
break;
}
addr += mCp.Size();
}
else
addr++;
}
return end < jumpback ? jumpback : end;
}
duint LinearAnalysis::getReferenceOperand() const
{
for(auto i = 0; i < mCp.OpCount(); i++)
{
const auto & op = mCp[i];
if(mCp.IsJump() || mCp.IsLoop()) //skip jumps/loops
continue;
if(op.type == ZYDIS_OPERAND_TYPE_IMMEDIATE) //we are looking for immediate references
{
auto dest = duint(op.imm.value.u);
if(inRange(dest))
return dest;
}
}
return 0;
} |
C/C++ | x64dbg-development/src/dbg/analysis/linearanalysis.h | #ifndef _LINEARANALYSIS_H
#define _LINEARANALYSIS_H
#include "_global.h"
#include "analysis.h"
class LinearAnalysis : public Analysis
{
public:
explicit LinearAnalysis(duint base, duint size);
void Analyse() override;
void SetMarkers() override;
private:
struct FunctionInfo
{
duint start;
duint end;
bool operator<(const FunctionInfo & b) const
{
return start < b.start;
}
bool operator==(const FunctionInfo & b) const
{
return start == b.start;
}
};
std::vector<FunctionInfo> mFunctions;
void sortCleanup();
void populateReferences();
void analyseFunctions();
duint findFunctionEnd(duint start, duint maxaddr);
duint getReferenceOperand() const;
};
#endif //_LINEARANALYSIS_H |
C++ | x64dbg-development/src/dbg/analysis/LinearPass.cpp | #include <thread>
#include <ppl.h>
#include "AnalysisPass.h"
#include "LinearPass.h"
#include <zydis_wrapper.h>
LinearPass::LinearPass(duint VirtualStart, duint VirtualEnd, BBlockArray & MainBlocks)
: AnalysisPass(VirtualStart, VirtualEnd, MainBlocks)
{
// This is a fix for when the total data analysis size is less
// than what parallelization can support. The minimum size requirement
// is ((# THREADS) * (512)) bytes. If the requirement isn't met,
// scale to use a single thread.
if((512 * IdealThreadCount()) >= m_DataSize)
SetIdealThreadCount(1);
}
LinearPass::~LinearPass()
{
}
const char* LinearPass::GetName()
{
return "Linear Scandown";
}
bool LinearPass::Analyse()
{
// Divide the work up between each thread
// THREAD_WORK = (TOTAL / # THREADS)
duint workAmount = m_DataSize / IdealThreadCount();
// Initialize thread vector
auto threadBlocks = new std::vector<BasicBlock>[IdealThreadCount()];
concurrency::parallel_for(duint(0), IdealThreadCount(), [&](duint i)
{
duint threadWorkStart = m_VirtualStart + (workAmount * i);
duint threadWorkStop = min((threadWorkStart + workAmount), m_VirtualEnd);
// Allow a 256-byte variance of scanning because of
// integer rounding errors and instruction overlap
if(threadWorkStart > m_VirtualStart)
{
threadWorkStart = max((threadWorkStart - 256), m_VirtualStart);
threadWorkStop = min((threadWorkStop + 256), m_VirtualEnd);
}
// Memory allocation optimization
// TODO: Option to conserve memory
threadBlocks[i].reserve(100000);
// Execute
AnalysisWorker(threadWorkStart, threadWorkStop, &threadBlocks[i]);
});
// Clear old data and combine vectors
m_MainBlocks.clear();
for(duint i = 0; i < IdealThreadCount(); i++)
{
std::move(threadBlocks[i].begin(), threadBlocks[i].end(), std::back_inserter(m_MainBlocks));
// Free old elements to conserve memory further
BBlockArray().swap(threadBlocks[i]);
}
// Free memory ASAP
delete[] threadBlocks;
// Sort and remove duplicates
std::sort(m_MainBlocks.begin(), m_MainBlocks.end());
m_MainBlocks.erase(std::unique(m_MainBlocks.begin(), m_MainBlocks.end()), m_MainBlocks.end());
// Run overlap analysis sub-pass
AnalyseOverlaps();
return true;
}
void LinearPass::AnalyseOverlaps()
{
// Goal of this function:
//
// Remove all overlapping basic blocks because of threads
// not ending or starting at absolutely defined points.
// (Example: one thread starts in the middle of an instruction)
//
// This also checks for basic block targets jumping into
// the middle of other basic blocks.
//
// THREAD_WORK = ceil(TOTAL / # THREADS)
duint workTotal = m_MainBlocks.size();
duint workAmount = (workTotal + (IdealThreadCount() - 1)) / IdealThreadCount();
// Initialize thread vectors
auto threadInserts = new std::vector<BasicBlock>[IdealThreadCount()];
concurrency::parallel_for(duint(0), IdealThreadCount(), [&](duint i)
{
duint threadWorkStart = (workAmount * i);
duint threadWorkStop = min((threadWorkStart + workAmount), workTotal);
// Again, allow an overlap of +/- 1 entry
if(threadWorkStart > 0)
{
threadWorkStart = max((threadWorkStart - 1), 0);
threadWorkStop = min((threadWorkStop + 1), workTotal);
}
// Execute
AnalysisOverlapWorker(threadWorkStart, threadWorkStop, &threadInserts[i]);
});
// THREAD VECTOR
std::vector<BasicBlock> overlapInserts;
{
for(duint i = 0; i < IdealThreadCount(); i++)
std::move(threadInserts[i].begin(), threadInserts[i].end(), std::back_inserter(overlapInserts));
// Sort and remove duplicates
std::sort(overlapInserts.begin(), overlapInserts.end());
overlapInserts.erase(std::unique(overlapInserts.begin(), overlapInserts.end()), overlapInserts.end());
delete[] threadInserts;
}
// GLOBAL VECTOR
{
// Erase blocks marked for deletion
m_MainBlocks.erase(std::remove_if(m_MainBlocks.begin(), m_MainBlocks.end(), [](BasicBlock & Elem)
{
return Elem.GetFlag(BASIC_BLOCK_FLAG_DELETE);
}));
// Insert
std::move(overlapInserts.begin(), overlapInserts.end(), std::back_inserter(m_MainBlocks));
// Final sort
std::sort(m_MainBlocks.begin(), m_MainBlocks.end());
}
}
void LinearPass::AnalysisWorker(duint Start, duint End, BBlockArray* Blocks)
{
Zydis disasm;
duint blockBegin = Start; // BBlock starting virtual address
duint blockEnd = 0; // BBlock ending virtual address
bool blockPrevPad = false; // Indicator if the last instruction was padding
BasicBlock* lastBlock = nullptr; // Avoid an expensive call to std::vector::back()
int insnCount = 0; // Temporary number of instructions counted for a block
for(duint i = Start; i < End;)
{
if(!disasm.Disassemble(i, TranslateAddress(i), int(End - i)))
{
// Skip instructions that can't be determined
i++;
continue;
}
// Increment counters
i += disasm.Size();
blockEnd = i;
insnCount++;
// The basic block ends here if it is a branch
bool call = disasm.IsCall(); // CALL
bool jmp = disasm.IsJump(); // JUMP
bool ret = disasm.IsRet(); // RETURN
bool padding = disasm.IsFilling(); // INSTRUCTION PADDING
if(padding)
{
// PADDING is treated differently. They are all created as their
// own separate block for more analysis later.
duint realBlockEnd = blockEnd - disasm.Size();
if((realBlockEnd - blockBegin) > 0)
{
// The next line terminates the BBlock before the INT instruction.
// Early termination, faked as an indirect JMP. Rare case.
lastBlock = CreateBlockWorker(Blocks, blockBegin, realBlockEnd, false, false, false, false);
lastBlock->SetFlag(BASIC_BLOCK_FLAG_PREPAD);
blockBegin = realBlockEnd;
lastBlock->InstrCount = insnCount;
insnCount = 0;
}
}
if(call || jmp || ret || padding)
{
// Was this a padding instruction?
if(padding && blockPrevPad)
{
// Append it to the previous block
lastBlock->VirtualEnd = blockEnd;
}
else
{
// Otherwise use the default route: create a new entry
auto block = lastBlock = CreateBlockWorker(Blocks, blockBegin, blockEnd, call, jmp, ret, padding);
// Counters
lastBlock->InstrCount = insnCount;
insnCount = 0;
if(!padding)
{
// Check if absolute jump, regardless of operand
if(disasm.GetId() == ZYDIS_MNEMONIC_JMP)
block->SetFlag(BASIC_BLOCK_FLAG_ABSJMP);
// Figure out the operand type(s)
if(disasm.OpCount() > 0)
{
const auto & operand = disasm[0];
if(operand.type == ZYDIS_OPERAND_TYPE_IMMEDIATE)
{
// Branch target immediate
block->Target = (duint)operand.imm.value.u;
}
else
{
// Indirects (no operand, register, or memory)
block->SetFlag(BASIC_BLOCK_FLAG_INDIRECT);
if(operand.type == ZYDIS_OPERAND_TYPE_MEMORY &&
operand.mem.base == ZYDIS_REGISTER_RIP &&
operand.mem.index == ZYDIS_REGISTER_NONE &&
operand.mem.scale == 1)
{
/*
block->SetFlag(BASIC_BLOCK_FLAG_INDIRPTR);
block->Target = (duint)operand.mem.disp;
*/
}
}
}
}
}
// Reset the loop variables
blockBegin = i;
blockPrevPad = padding;
}
}
}
void LinearPass::AnalysisOverlapWorker(duint Start, duint End, BBlockArray* Insertions)
{
// Comparison function to see if two blocks overlap
auto BlockOverlapsRemove = [](BasicBlock * A, BasicBlock * B) -> BasicBlock*
{
// Do the blocks overlap?
if(max(A->VirtualStart, B->VirtualStart) <= min((A->VirtualEnd - 1), (B->VirtualEnd - 1)))
{
// Return the block that should be removed
if(A->Size() > B->Size())
return B;
return A;
}
return nullptr;
};
// Get a pointer to pure data
const auto blocks = m_MainBlocks.data();
for(duint i = Start; i < End; i++)
{
const auto curr = &blocks[i];
const auto next = &blocks[i + 1];
// Current versus next (overlap -> delete)
BasicBlock* removal = BlockOverlapsRemove(curr, next);
if(removal)
removal->SetFlag(BASIC_BLOCK_FLAG_DELETE);
// Find blocks that need to be split in two because
// of CALL/JMP targets
//
// Find targets in the virtual range
if(ValidateAddress(curr->Target))
{
removal = FindBBlockInRange(curr->Target);
if(removal)
{
if(curr->GetFlag(BASIC_BLOCK_FLAG_CALL))
removal->SetFlag(BASIC_BLOCK_FLAG_CALL_TARGET);
// If the target does not equal the block start...
if(curr->Target != removal->VirtualStart)
{
// Mark for deletion
removal->SetFlag(BASIC_BLOCK_FLAG_DELETE);
// Block part 1
BasicBlock block1;
block1.VirtualStart = removal->VirtualStart;
block1.VirtualEnd = curr->Target;
block1.Target = 0;
block1.Flags = BASIC_BLOCK_FLAG_CUTOFF; // Attributes of the top half
block1.InstrCount = removal->InstrCount;
// Block part 2
BasicBlock block2;
block2.VirtualStart = curr->Target;
block2.VirtualEnd = removal->VirtualEnd;
block2.Target = removal->Target;
block2.Flags = removal->Flags; // Attributes of the bottom half (taken from original block)
block2.InstrCount = removal->InstrCount;
Insertions->push_back(block1);
Insertions->push_back(block2);
}
}
}
}
}
BasicBlock* LinearPass::CreateBlockWorker(std::vector<BasicBlock>* Blocks, duint Start, duint End, bool Call, bool Jmp, bool Ret, bool Pad)
{
BasicBlock block { Start, End - 1, 0, 0, 0 };
// Check for calls
if(Call)
block.SetFlag(BASIC_BLOCK_FLAG_CALL);
// Check for returns
if(Ret)
block.SetFlag(BASIC_BLOCK_FLAG_RET);
// Check for interrupts
if(Pad)
block.SetFlag(BASIC_BLOCK_FLAG_PAD);
Blocks->push_back(block);
// std::vector::back() incurs a very large performance overhead (30% slower) when
// used in debug mode. This code eliminates it from showing up in the profiler.
#ifdef _DEBUG
return &Blocks->data()[Blocks->size() - 1];
#else
return &Blocks->back();
#endif // _DEBUG
} |
C/C++ | x64dbg-development/src/dbg/analysis/LinearPass.h | #pragma once
#include "AnalysisPass.h"
#include "BasicBlock.h"
class LinearPass : public AnalysisPass
{
public:
LinearPass(duint VirtualStart, duint VirtualEnd, BBlockArray & MainBlocks);
virtual ~LinearPass();
virtual const char* GetName() override;
virtual bool Analyse() override;
void AnalyseOverlaps();
private:
void AnalysisWorker(duint Start, duint End, BBlockArray* Blocks);
void AnalysisOverlapWorker(duint Start, duint End, BBlockArray* Insertions);
BasicBlock* CreateBlockWorker(BBlockArray* Blocks, duint Start, duint End, bool Call, bool Jmp, bool Ret, bool Pad);
}; |
C++ | x64dbg-development/src/dbg/analysis/recursiveanalysis.cpp | #include "recursiveanalysis.h"
#include <queue>
#include "console.h"
#include "filehelper.h"
#include "function.h"
#include "label.h"
#include "xrefs.h"
#include "plugin_loader.h"
#include "loop.h"
#include <set>
#include <map>
RecursiveAnalysis::RecursiveAnalysis(duint base, duint size, duint entryPoint, bool usePlugins, bool dump)
: Analysis(base, size),
mEntryPoint(entryPoint),
mUsePlugins(usePlugins),
mDump(dump)
{
}
void RecursiveAnalysis::Analyse()
{
//TODO: implement queue to analyze multiple functions
analyzeFunction(mEntryPoint);
analyzeLoops(mEntryPoint);
}
void RecursiveAnalysis::SetMarkers()
{
if(mDump)
for(const auto & function : mFunctions)
FileHelper::WriteAllText(StringUtils::sprintf("cfgraph_%p.dot", function.second.entryPoint), GraphToDot(function.second));
//set function ranges
for(const auto & functionItr : mFunctions)
{
// Split functions with multiple chunks (either due to tail calls or PGO)
// Example: kernelbase:KernelBaseBaseDllInitialize
// This algorithm orders basic blocks and then iterates, growing the chunk downwards
// Function ranges are collected in another ordered map for loop insertion
const auto & function = functionItr.second;
std::map<Range, const BridgeCFNode*, RangeCompare> blockRanges, functionRanges;
for(const auto & nodeItr : function.nodes)
{
const auto & node = nodeItr.second;
if(!blockRanges.emplace(Range(node.start, node.end), &node).second)
dprintf_untranslated("Overlapping basic block %p-%p, please report a bug!\n", node.start, node.end);
}
auto addFunction = [&function, &functionRanges](duint start, duint end, duint icount)
{
FunctionDelRange(start, end, false /* Do not override user-defined functions */);
LoopDeleteRange(start, end); // clear loop range in function
//XrefDelRange(start, end); // clear xrefs in function
FunctionAdd(start, end, false, icount, function.entryPoint);
functionRanges.emplace(Range(start, end), nullptr);
};
duint rangeStart = 0, rangeEnd = 0, rangeInstructionCount = 0;
for(auto rangeItr = blockRanges.begin(); rangeItr != blockRanges.end(); ++rangeItr)
{
auto disasmLen = [this](duint addr)
{
if(!mCp.Disassemble(addr, translateAddr(addr)))
return 1;
return mCp.Size();
};
const auto & node = *rangeItr->second;
if(!rangeStart)
{
rangeStart = node.start;
rangeEnd = node.end;
rangeInstructionCount = node.icount;
}
else
{
#define ALIGN_UP(Address, Align) (((ULONG_PTR)(Address) + (Align) - 1) & ~((Align) - 1))
auto nextInstr = rangeEnd + disasmLen(rangeEnd);
// The next instruction(s) might be padding to align IP, also allow this case to count as consecutive
if(nextInstr == node.start || ((node.start & 0xF) == 0 && ALIGN_UP(nextInstr, 16) == node.start))
{
// Merge the consecutive range
rangeEnd = node.end;
rangeInstructionCount += node.icount;
}
else
{
if(mDump)
dprintf_untranslated("Flush partial range %p-%p\n", rangeStart, rangeEnd);
addFunction(rangeStart, rangeEnd, rangeInstructionCount);
rangeStart = node.start;
rangeEnd = node.end;
rangeInstructionCount = node.icount;
}
}
}
if(mDump)
dprintf_untranslated("Flush range %p-%p\n", rangeStart, rangeEnd);
addFunction(rangeStart, rangeEnd, rangeInstructionCount);
// Collect loop ranges
const auto & loopInfo = mLoopInfo[function.entryPoint];
std::vector<Range> loopRanges;
for(const auto & backedge : loopInfo.backedges)
{
//dprintf("Backedge %p-%p\n", backedge.first, backedge.second);
auto startBlock = backedge.second; // destination is the start of the potential loop range
auto endBlock = backedge.first; // source is the start of the last block in the potential loop range
auto startFunctionItr = functionRanges.find(Range(startBlock, startBlock));
auto endFunctionItr = functionRanges.find(Range(endBlock, endBlock));
if(startFunctionItr != functionRanges.end() && startFunctionItr == endFunctionItr)
{
// Loop ranges can only be in the same function chunk range, otherwise they won't insert/display properly
const auto & endBlockNode = function.nodes.at(endBlock);
loopRanges.emplace_back(startBlock, endBlockNode.end);
}
}
// Order loop ranges by start address so the outermost loop is inserted first
std::sort(loopRanges.begin(), loopRanges.end());
for(const auto & loopRange : loopRanges)
{
if(mDump)
dprintf_untranslated("Loop %p-%p\n", loopRange.first, loopRange.second);
duint loopInstructionCount = 0;
for(auto blockItr = blockRanges.find(Range(loopRange.first, loopRange.first)); blockItr != blockRanges.end(); ++blockItr)
{
if(mDump)
dprintf_untranslated("icount block %p-%p\n", blockItr->second->start, blockItr->second->end);
loopInstructionCount += blockItr->second->icount;
if(blockItr->second->end >= loopRange.second)
break;
}
// TODO: RtlpEnterCriticalSectionContended has some weirdly nested loops that overlap each other
// this might cause LoopAdd to fail
LoopAdd(loopRange.first, loopRange.second, false, loopInstructionCount);
}
}
//set xrefs
for(const auto & xref : mXrefs)
XrefAdd(xref.addr, xref.from);
GuiUpdateAllViews();
}
void RecursiveAnalysis::analyzeFunction(duint entryPoint)
{
//first pass: BFS through the disassembly starting at entryPoint
CFGraph graph(entryPoint);
UintSet visited;
std::queue<duint> queue;
queue.push(graph.entryPoint);
while(!queue.empty())
{
auto start = queue.front();
queue.pop();
if(visited.count(start)) //already visited
continue;
visited.insert(start);
CFNode node(graph.entryPoint, start, start);
if(!inRange(start)) //out of range
{
graph.AddNode(node);
continue;
}
while(true)
{
if(!inRange(node.end))
{
node.end = mCp.Address();
node.terminal = true;
graph.AddNode(node);
break;
}
node.icount++;
if(!mCp.Disassemble(node.end, translateAddr(node.end)))
{
node.end++;
continue;
}
//do xref analysis on the instruction
XREF xref;
xref.addr = 0;
xref.from = mCp.Address();
for(auto i = 0; i < mCp.OpCount(); i++)
{
duint dest = mCp.ResolveOpValue(i, [](ZydisRegister)->size_t
{
return 0;
});
if(inRange(dest))
{
xref.addr = dest;
break;
}
}
if(xref.addr)
mXrefs.push_back(xref);
if(!mCp.IsNop() && (mCp.IsJump() || mCp.IsLoop())) //non-nop jump
{
//set the branch destinations
node.brtrue = mCp.BranchDestination();
if(mCp.GetId() != ZYDIS_MNEMONIC_JMP) //unconditional jumps dont have a brfalse
node.brfalse = node.end + mCp.Size();
//consider register/memory branches as terminal nodes
if(mCp.OpCount() && mCp[0].type != ZYDIS_OPERAND_TYPE_IMMEDIATE)
{
//jmp ptr [index * sizeof(duint) + switchTable]
if(mCp[0].type == ZYDIS_OPERAND_TYPE_MEMORY && mCp[0].mem.base == ZYDIS_REGISTER_NONE && mCp[0].mem.index != ZYDIS_REGISTER_NONE
&& mCp[0].mem.scale == sizeof(duint) && MemIsValidReadPtr(duint(mCp[0].mem.disp.value)))
{
Memory<duint*> switchTable(512 * sizeof(duint));
duint actualSize, index;
MemRead(duint(mCp[0].mem.disp.value), switchTable(), 512 * sizeof(duint), &actualSize);
actualSize /= sizeof(duint);
for(index = 0; index < actualSize; index++)
if(MemIsCodePage(switchTable()[index], false) == false)
break;
actualSize = index;
if(actualSize >= 2 && actualSize < 512)
{
node.brtrue = 0;
node.brfalse = 0;
for(index = 0; index < actualSize; index++)
{
node.exits.push_back(switchTable()[index]);
queue.emplace(switchTable()[index]);
xref.addr = switchTable()[index];
mXrefs.push_back(xref);
}
}
else
node.terminal = true;
}
else
node.terminal = true;
}
//add node to the function graph
graph.AddNode(node);
//enqueue branch destinations
if(node.brtrue)
queue.push(node.brtrue);
if(node.brfalse)
queue.push(node.brfalse);
break;
}
if(mCp.IsCall())
{
//TODO: add this to a queue to be analyzed later
}
if(mCp.IsRet())
{
node.terminal = true;
graph.AddNode(node);
break;
}
node.end += mCp.Size();
}
}
//second pass: split overlapping blocks introduced by backedges
for(auto & nodeIt : graph.nodes)
{
auto & node = nodeIt.second;
duint addr = node.start;
duint icount = 0;
while(addr < node.end)
{
icount++;
auto size = mCp.Disassemble(addr, translateAddr(addr)) ? mCp.Size() : 1;
if(graph.nodes.count(addr + size))
{
node.end = addr;
node.split = true;
node.brtrue = addr + size;
node.brfalse = 0;
node.terminal = false;
node.icount = icount;
break;
}
addr += size;
}
}
//third pass: correct the parents + add brtrue and brfalse to the exits + get data
graph.parents.clear();
for(auto & nodeIt : graph.nodes)
{
auto & node = nodeIt.second;
graph.AddParent(node.start, node.brtrue);
graph.AddParent(node.start, node.brfalse);
if(node.brtrue)
node.exits.push_back(node.brtrue);
if(node.brfalse)
node.exits.push_back(node.brfalse);
if(node.brtrue && !node.brfalse)
node.brtrue = 0;
if(!node.icount)
continue;
node.instrs.reserve(node.icount);
auto addr = node.start;
while(addr <= node.end) //disassemble all instructions
{
auto size = mCp.Disassemble(addr, translateAddr(addr)) ? mCp.Size() : 1;
if(mCp.IsCall() && mCp.OpCount()) //call reg / call [reg+X]
{
auto & op = mCp[0];
switch(op.type)
{
case ZYDIS_OPERAND_TYPE_REGISTER:
node.indirectcall = true;
break;
case ZYDIS_OPERAND_TYPE_MEMORY:
node.indirectcall |= op.mem.base != ZYDIS_REGISTER_RIP &&
(op.mem.base != ZYDIS_REGISTER_NONE || op.mem.index != ZYDIS_REGISTER_NONE);
break;
default:
break;
}
}
BridgeCFInstruction instr;
instr.addr = addr;
for(int i = 0; i < size; i++)
instr.data[i] = inRange(addr + i) ? *translateAddr(addr + i) : 0;
node.instrs.push_back(instr);
addr += size;
}
}
//fourth pass: allow plugins to manipulate the graph
if(mUsePlugins && !plugincbempty(CB_ANALYZE))
{
PLUG_CB_ANALYZE info;
info.graph = graph.ToGraphList();
plugincbcall(CB_ANALYZE, &info);
graph = BridgeCFGraph(&info.graph, true);
}
mFunctions.emplace(entryPoint, graph);
}
void RecursiveAnalysis::analyzeLoops(duint entryPoint)
{
auto graph = GetFunctionGraph(entryPoint);
if(!graph)
return;
auto & loopInfo = mLoopInfo[entryPoint] = LoopInfo();
loopInfo.functionEntry = entryPoint;
// Detect loops to the same basic block
for(const auto & node : graph->nodes)
for(duint exit : node.second.exits)
if(exit == node.first)
loopInfo.trivialLoops.insert(node.first);
// Thanks to DefCon42 for help with the algorithm!
std::vector<duint> stack;
stack.push_back(entryPoint);
std::set<duint> visited;
std::map<duint, std::vector<duint>> state;
while(!stack.empty())
{
auto start = stack.back();
stack.pop_back();
if(visited.count(start)) //already visited
continue;
visited.insert(start);
state[start].push_back(start);
for(duint exit : graph->nodes.at(start).exits)
{
if(!visited.count(exit))
{
state[exit] = state[start];
stack.push_back(exit);
}
else if(std::count(state[start].begin(), state[start].end(), exit))
{
loopInfo.backedges.emplace(start, exit);
}
}
}
}
void RecursiveAnalysis::dominatorAnalysis(duint entryPoint)
{
auto graph = GetFunctionGraph(entryPoint);
if(!graph)
return;
// WIP algo
// http://jgaa.info/accepted/2006/GeorgiadisTarjanWerneck2006.10.1.pdf
// https://www.cs.princeton.edu/courses/archive/fall03/cs528/handouts/a%20fast%20algorithm%20for%20finding.pdf
std::map<duint, duint> parent, anchestor, vertex;
std::map<duint, duint> label, semi;
std::map<duint, std::set<duint>> pred, bucket;
std::map<duint, duint> dom;
std::map<duint, duint> indexToAddress, addressToIndex;
std::map<duint, std::set<duint>> succ;
{
size_t curIndex = 1;
for(const auto & node : graph->nodes)
{
indexToAddress[curIndex] = node.first;
addressToIndex[node.first] = curIndex;
curIndex++;
}
for(const auto & node : graph->nodes)
{
auto & s = succ[addressToIndex[node.first]];
for(duint exit : node.second.exits)
{
s.insert(addressToIndex[exit]);
}
}
}
duint r = addressToIndex[entryPoint];
duint n = 0;
std::function<void(duint)> dfs = [&](duint v)
{
semi.at(v) = (n = n + 1);
vertex.at(n) = label.at(v) = v;
anchestor.at(v) = 0;
for(duint w : succ.at(v))
{
if(semi.at(w) == 0)
{
parent.at(w) = v;
dfs(w);
}
pred.at(w).insert(v);
}
};
std::function<void(duint)> compress = [&](duint v)
{
if(anchestor.at(anchestor.at(v)) != 0)
{
compress(anchestor.at(v));
if(semi.at(label.at(anchestor.at(v))) < semi.at(label.at(v)))
label.at(v) = label.at(anchestor.at(v));
anchestor.at(v) = anchestor.at(anchestor.at(v));
}
};
auto eval = [&](duint v)
{
if(anchestor.at(v) == 0)
{
return v;
}
else
{
compress(v);
return label.at(v);
}
};
auto link = [&](duint v, duint w)
{
anchestor.at(w) = v;
};
auto print = [](const char* name, const std::map<duint, duint> & m)
{
dprintf("%s:\n", name);
for(const auto & e : m)
dprintf(" %s[%p] = %p\n", name, e.first, e.second);
};
print("indexToAddress", indexToAddress);
print("addressToIndex", addressToIndex);
// step1
for(duint i = 0; i < succ.size(); i++)
{
auto v = i + 1;
pred[v] = bucket[v];
semi[v] = vertex[v] = anchestor[v] = label[v] = parent[v] = dom[v] = 0;
dprintf("%d\n", v);
}
n = 0;
dfs(r);
print("semi", semi);
print("vertex", vertex);
print("label", label);
print("anchestor", anchestor);
for(duint i = n; i != 1; i--)
{
auto w = vertex.at(i);
// step2
for(duint v : pred.at(w))
{
auto u = eval(v);
if(semi.at(u) < semi.at(w))
{
semi[w] = semi.at(u);
}
bucket.at(vertex.at(semi.at(w))).insert(w);
link(parent.at(w), w);
}
// step3
duint parentw = parent.at(w);
auto & bp = bucket.at(parent.at(w));
for(auto itr = bp.begin(); itr != bp.end(); itr = bp.erase(itr))
{
auto v = *itr;
auto u = eval(v);
if(semi.at(u) < semi.at(v))
{
dom.at(v) = u;
}
else
{
dom.at(v) = parent.at(w);
}
}
}
// step4
for(duint i = 2; i != n; i++)
{
auto w = vertex.at(i);
if(dom.at(w) != vertex.at(semi.at(w)))
{
dom[w] = dom[dom[w]];
}
}
dom.at(r) = 0;
print("semi", semi);
//succ(v)
for(const auto & d : dom)
{
dprintf("dom[%d] = %d\n", d.first, d.second);
}
for(const auto & x : indexToAddress)
{
char label[256];
sprintf_s(label, "block%p", x.first);
LabelSet(x.second, label, false, true);
}
} |
C/C++ | x64dbg-development/src/dbg/analysis/recursiveanalysis.h | #pragma once
#include "analysis.h"
class RecursiveAnalysis : public Analysis
{
public:
explicit RecursiveAnalysis(duint base, duint size, duint entryPoint, bool usePlugins, bool dump = false);
void Analyse() override;
void SetMarkers() override;
using UintSet = std::unordered_set<duint>;
template<class T>
using UintMap = std::unordered_map<duint, T>;
using CFNode = BridgeCFNode;
using CFGraph = BridgeCFGraph;
static String NodeToString(const CFNode & n)
{
#ifdef _WIN64
return StringUtils::sprintf("start: %p, %lld\nend: %p\nfunction: %p", n.start, n.icount, n.end, n.parentGraph); //TODO: %llu or %u
#else //x86
return StringUtils::sprintf("start: %p, %d\nend: %p\nfunction: %p", n.start, n.icount, n.end, n.parentGraph); //TODO: %llu or %u
#endif //_WIN64
}
static const char* GetNodeColor(const CFGraph & graph, const CFNode & node)
{
if(node.terminal)
return "firebrick";
if(node.start == graph.entryPoint)
return "forestgreen";
return "lightblue";
}
static String GraphToDot(const CFGraph & graph)
{
String result = "digraph CFGraph {\n";
for(const auto & node : graph.nodes)
result += StringUtils::sprintf(" n%p[label=\"%s\" style=filled fillcolor=%s shape=box]\n",
node.second.start,
NodeToString(node.second).c_str(),
GetNodeColor(graph, node.second));
result += "\n";
for(const auto & node : graph.nodes)
{
if(node.second.brtrue)
result += StringUtils::sprintf(" n%p-> n%p [color=%s]\n",
node.second.start,
node.second.brtrue,
node.second.split ? "black" : "green");
if(node.second.brfalse)
result += StringUtils::sprintf(" n%p-> n%p [color=red]\n",
node.second.start,
node.second.brfalse);
}
result += "\n";
for(const auto & parent : graph.parents)
{
for(const auto & node : parent.second)
result += StringUtils::sprintf(" n%p-> n%p [style=dotted color=grey]\n",
node,
parent.first);
}
result += "}";
return std::move(result);
}
const CFGraph* GetFunctionGraph(duint entry) const
{
auto itr = mFunctions.find(entry);
return itr == mFunctions.end() ? nullptr : &itr->second;
}
protected:
duint mEntryPoint;
std::unordered_map<duint, CFGraph> mFunctions;
private:
bool mUsePlugins;
bool mDump;
struct XREF
{
duint addr;
duint from;
};
std::vector<XREF> mXrefs;
struct LoopInfo
{
duint functionEntry = 0;
std::unordered_set<duint> trivialLoops; // loops to the same basic block
std::unordered_map<duint, duint> backedges; // backedges in the CFG
};
std::unordered_map<duint, LoopInfo> mLoopInfo;
void analyzeFunction(duint entryPoint);
void analyzeLoops(duint entryPoint);
void dominatorAnalysis(duint entryPoint);
}; |
C++ | x64dbg-development/src/dbg/analysis/xrefsanalysis.cpp | #include "xrefsanalysis.h"
#include "xrefs.h"
#include "console.h"
#include <module.h>
XrefsAnalysis::XrefsAnalysis(duint base, duint size)
: Analysis(base, size)
{
modbase = ModBaseFromAddr(base);
modsize = ModSizeFromAddr(modbase);
}
void XrefsAnalysis::Analyse()
{
dputs("Starting xref analysis...");
auto ticks = GetTickCount();
for(auto addr = mBase; addr < mBase + mSize;)
{
if(!mCp.Disassemble(addr, translateAddr(addr)))
{
addr++;
continue;
}
addr += mCp.Size();
XREF xref;
xref.addr = 0;
xref.from = mCp.Address();
for(auto i = 0; i < mCp.OpCount(); i++)
{
duint dest = mCp.ResolveOpValue(i, [](ZydisRegister)->size_t
{
return 0;
});
if(inModRange(dest))
{
xref.addr = dest;
break;
}
}
if(xref.addr)
mXrefs.push_back(xref);
}
dprintf("%u xrefs found in %ums!\n", DWORD(mXrefs.size()), GetTickCount() - ticks);
}
void XrefsAnalysis::SetMarkers()
{
XrefDelRange(mBase, mBase + mSize - 1);
for(const auto & xref : mXrefs)
XrefAdd(xref.addr, xref.from);
} |
C/C++ | x64dbg-development/src/dbg/analysis/xrefsanalysis.h | #pragma once
#include "analysis.h"
class XrefsAnalysis : public Analysis
{
public:
XrefsAnalysis(duint base, duint size);
void Analyse() override;
void SetMarkers() override;
private:
struct XREF
{
duint addr;
duint from;
};
std::vector<XREF> mXrefs;
duint modbase = 0;
duint modsize = 0;
bool inModRange(duint addr) const
{
return modbase ? (addr >= modbase && addr < modbase + modsize) : inRange(addr);
}
}; |
C/C++ | x64dbg-development/src/dbg/commands/cmd-all.h | #pragma once
#include "cmd-general-purpose.h"
#include "cmd-debug-control.h"
#include "cmd-breakpoint-control.h"
#include "cmd-conditional-breakpoint-control.h"
#include "cmd-tracing.h"
#include "cmd-thread-control.h"
#include "cmd-memory-operations.h"
#include "cmd-operating-system-control.h"
#include "cmd-watch-control.h"
#include "cmd-variables.h"
#include "cmd-searching.h"
#include "cmd-user-database.h"
#include "cmd-analysis.h"
#include "cmd-types.h"
#include "cmd-plugins.h"
#include "cmd-script.h"
#include "cmd-gui.h"
#include "cmd-misc.h"
#include "cmd-undocumented.h" |
C++ | x64dbg-development/src/dbg/commands/cmd-analysis.cpp | #include "cmd-analysis.h"
#include "ntdll/ntdll.h"
#include "linearanalysis.h"
#include "memory.h"
#include "exceptiondirectoryanalysis.h"
#include "controlflowanalysis.h"
#include "analysis_nukem.h"
#include "xrefsanalysis.h"
#include "recursiveanalysis.h"
#include "value.h"
#include "advancedanalysis.h"
#include "debugger.h"
#include "variable.h"
#include "exhandlerinfo.h"
#include "symbolinfo.h"
#include "exception.h"
#include "TraceRecord.h"
#include "dbghelp_safe.h"
bool cbInstrAnalyse(int argc, char* argv[])
{
SELECTIONDATA sel;
GuiSelectionGet(GUI_DISASSEMBLY, &sel);
duint size = 0;
duint base = MemFindBaseAddr(sel.start, &size);
LinearAnalysis anal(base, size);
anal.Analyse();
anal.SetMarkers();
GuiUpdateAllViews();
return true;
}
bool cbInstrExanalyse(int argc, char* argv[])
{
SELECTIONDATA sel;
GuiSelectionGet(GUI_DISASSEMBLY, &sel);
duint size = 0;
duint base = MemFindBaseAddr(sel.start, &size);
ExceptionDirectoryAnalysis anal(base, size);
anal.Analyse();
anal.SetMarkers();
GuiUpdateAllViews();
return true;
}
bool cbInstrCfanalyse(int argc, char* argv[])
{
bool exceptionDirectory = false;
if(argc > 1)
exceptionDirectory = true;
SELECTIONDATA sel;
GuiSelectionGet(GUI_DISASSEMBLY, &sel);
duint size = 0;
duint base = MemFindBaseAddr(sel.start, &size);
ControlFlowAnalysis anal(base, size, exceptionDirectory);
anal.Analyse();
anal.SetMarkers();
GuiUpdateAllViews();
return true;
}
bool cbInstrAnalyseNukem(int argc, char* argv[])
{
SELECTIONDATA sel;
GuiSelectionGet(GUI_DISASSEMBLY, &sel);
duint size = 0;
duint base = MemFindBaseAddr(sel.start, &size);
Analyse_nukem(base, size);
GuiUpdateAllViews();
return true;
}
bool cbInstrAnalxrefs(int argc, char* argv[])
{
SELECTIONDATA sel;
GuiSelectionGet(GUI_DISASSEMBLY, &sel);
duint size = 0;
auto base = MemFindBaseAddr(sel.start, &size);
XrefsAnalysis anal(base, size);
anal.Analyse();
anal.SetMarkers();
GuiUpdateAllViews();
return true;
}
bool cbInstrAnalrecur(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint entry;
if(!valfromstring(argv[1], &entry, false))
return false;
#ifdef _WIN64
// find the closest function
{
SHARED_ACQUIRE(LockModules);
auto info = ModInfoFromAddr(entry);
if(info)
{
DWORD rva = DWORD(entry - info->base);
auto runtimeFunction = info->findRuntimeFunction(rva);
if(runtimeFunction)
{
if(runtimeFunction->BeginAddress < rva)
{
entry = info->base + runtimeFunction->BeginAddress;
}
}
}
}
#endif // _WIN64
duint size;
auto base = MemFindBaseAddr(entry, &size);
if(!base)
return false;
RecursiveAnalysis analysis(base, size, entry, true);
analysis.Analyse();
analysis.SetMarkers();
return true;
}
bool cbInstrAnalyseadv(int argc, char* argv[])
{
SELECTIONDATA sel;
GuiSelectionGet(GUI_DISASSEMBLY, &sel);
duint size = 0;
auto base = MemFindBaseAddr(sel.start, &size);
AdvancedAnalysis anal(base, size);
anal.Analyse();
anal.SetMarkers();
GuiUpdateAllViews();
return true;
}
bool cbInstrVirtualmod(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
duint base;
if(!valfromstring(argv[2], &base))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid parameter [base]!"));
return false;
}
if(!MemIsValidReadPtr(base))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid memory address!"));
return false;
}
duint size;
if(argc < 4)
base = MemFindBaseAddr(base, &size);
else if(!valfromstring(argv[3], &size))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid parameter [size]"));
return false;
}
auto name = String("virtual:\\") + (argv[1]);
if(!ModLoad(base, size, name.c_str()))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to load module (ModLoad)..."));
return false;
}
char modname[MAX_MODULE_SIZE] = "";
if(ModNameFromAddr(base, modname, true))
BpEnumAll(cbSetModuleBreakpoints, modname);
dprintf(QT_TRANSLATE_NOOP("DBG", "Virtual module \"%s\" loaded on %p[%p]!\n"), argv[1], base, size);
GuiUpdateAllViews();
return true;
}
bool cbDebugDownloadSymbol(int argc, char* argv[])
{
dputs(QT_TRANSLATE_NOOP("DBG", "This may take very long, depending on your network connection and data in the debug directory..."));
Memory<char*> szDefaultStore(MAX_SETTING_SIZE + 1);
const char* szSymbolStore = szDefaultStore();
if(!BridgeSettingGet("Symbols", "DefaultStore", szDefaultStore())) //get default symbol store from settings
{
strcpy_s(szDefaultStore(), MAX_SETTING_SIZE, "https://msdl.microsoft.com/download/symbols");
BridgeSettingSet("Symbols", "DefaultStore", szDefaultStore());
}
if(argc < 2) //no arguments
{
SymDownloadAllSymbols(szSymbolStore); //download symbols for all modules
GuiSymbolRefreshCurrent();
dputs(QT_TRANSLATE_NOOP("DBG", "Done! See symbol log for more information"));
return true;
}
//get some module information
duint modbase = ModBaseFromName(argv[1]);
if(!modbase)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid module \"%s\"!\n"), argv[1]);
return false;
}
if(argc > 2)
szSymbolStore = argv[2];
if(!SymDownloadSymbol(modbase, szSymbolStore))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Symbol download failed... See symbol log for more information"));
return false;
}
GuiSymbolRefreshCurrent();
dputs(QT_TRANSLATE_NOOP("DBG", "Done! See symbol log for more information"));
return true;
}
bool cbDebugLoadSymbol(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
//get some module information
duint modbase = ModBaseFromName(argv[1]);
if(!modbase)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid module \"%s\"!\n"), argv[1]);
return false;
}
auto pdbFile = argv[2];
if(!FileExists(pdbFile))
{
dputs(QT_TRANSLATE_NOOP("DBG", "File does not exist!"));
return false;
}
bool forceLoad = argc > 3 && DbgEval(argv[3]);
EXCLUSIVE_ACQUIRE(LockModules);
auto info = ModInfoFromAddr(modbase);
if(!info)
{
// TODO: this really isn't supposed to happen, but could if the module is suddenly unloaded
dputs("module not found...");
return false;
}
// trigger a symbol load
if(!info->loadSymbols(pdbFile, forceLoad))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Symbol load failed... See symbol log for more information"));
return false;
}
GuiSymbolRefreshCurrent();
dputs(QT_TRANSLATE_NOOP("DBG", "Done! See symbol log for more information"));
return true;
}
bool cbDebugUnloadSymbol(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
//get some module information
duint modbase = ModBaseFromName(argv[1]);
if(!modbase)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid module \"%s\"!\n"), argv[1]);
return false;
}
EXCLUSIVE_ACQUIRE(LockModules);
auto info = ModInfoFromAddr(modbase);
if(!info)
{
// TODO: this really isn't supposed to happen, but could if the module is suddenly unloaded
dputs("module not found...");
return false;
}
info->unloadSymbols();
GuiRepaintTableView();
dputs(QT_TRANSLATE_NOOP("DBG", "Done!"));
return true;
}
bool cbInstrImageinfo(int argc, char* argv[])
{
duint address;
if(argc < 2)
address = GetContextDataEx(hActiveThread, UE_CIP);
else if(!valfromstring(argv[1], &address))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid argument"));
return false;
}
duint c, dllc, mod;
{
SHARED_ACQUIRE(LockModules);
auto modinfo = ModInfoFromAddr(address);
if(!modinfo)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid argument"));
return false;
}
c = GetPE32DataFromMappedFile(modinfo->fileMapVA, 0, UE_CHARACTERISTICS);
dllc = GetPE32DataFromMappedFile(modinfo->fileMapVA, 0, UE_DLLCHARACTERISTICS);
mod = modinfo->base;
}
auto pFlag = [](ULONG_PTR value, ULONG_PTR flag, const char* name)
{
if((value & flag) == flag)
{
dprintf(" ");
dputs(name);
}
};
char modname[MAX_MODULE_SIZE] = "";
ModNameFromAddr(mod, modname, true);
dputs_untranslated("---------------");
dprintf(QT_TRANSLATE_NOOP("DBG", "Image information for %s\n"), modname);
dprintf(QT_TRANSLATE_NOOP("DBG", "Characteristics (0x%X):\n"), DWORD(c));
if(!c)
dputs(QT_TRANSLATE_NOOP("DBG", " None\n"));
pFlag(c, IMAGE_FILE_RELOCS_STRIPPED, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_RELOCS_STRIPPED: Relocation info stripped from file."));
pFlag(c, IMAGE_FILE_EXECUTABLE_IMAGE, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_EXECUTABLE_IMAGE: File is executable (i.e. no unresolved externel references)."));
pFlag(c, IMAGE_FILE_LINE_NUMS_STRIPPED, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_LINE_NUMS_STRIPPED: Line numbers stripped from file."));
pFlag(c, IMAGE_FILE_LOCAL_SYMS_STRIPPED, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_LOCAL_SYMS_STRIPPED: Local symbols stripped from file."));
pFlag(c, IMAGE_FILE_AGGRESIVE_WS_TRIM, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_AGGRESIVE_WS_TRIM: Agressively trim working set"));
pFlag(c, IMAGE_FILE_LARGE_ADDRESS_AWARE, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_LARGE_ADDRESS_AWARE: App can handle >2gb addresses"));
pFlag(c, IMAGE_FILE_BYTES_REVERSED_LO, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_BYTES_REVERSED_LO: Bytes of machine word are reversed."));
pFlag(c, IMAGE_FILE_32BIT_MACHINE, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_32BIT_MACHINE: 32 bit word machine."));
pFlag(c, IMAGE_FILE_DEBUG_STRIPPED, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_DEBUG_STRIPPED: Debugging info stripped from file in .DBG file"));
pFlag(c, IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP: If Image is on removable media, copy and run from the swap file."));
pFlag(c, IMAGE_FILE_NET_RUN_FROM_SWAP, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_NET_RUN_FROM_SWAP: If Image is on Net, copy and run from the swap file."));
pFlag(c, IMAGE_FILE_SYSTEM, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_SYSTEM: System File."));
pFlag(c, IMAGE_FILE_DLL, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_DLL: File is a DLL."));
pFlag(c, IMAGE_FILE_UP_SYSTEM_ONLY, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_UP_SYSTEM_ONLY: File should only be run on a UP machine"));
pFlag(c, IMAGE_FILE_BYTES_REVERSED_HI, QT_TRANSLATE_NOOP("DBG", "IMAGE_FILE_BYTES_REVERSED_HI: Bytes of machine word are reversed."));
dprintf(QT_TRANSLATE_NOOP("DBG", "DLL Characteristics (0x%X):\n"), DWORD(dllc));
if(!dllc)
dputs(QT_TRANSLATE_NOOP("DBG", " None\n"));
pFlag(dllc, IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE, QT_TRANSLATE_NOOP("DBG", "IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE: DLL can move."));
pFlag(dllc, IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY, QT_TRANSLATE_NOOP("DBG", "IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY: Code Integrity Image"));
pFlag(dllc, IMAGE_DLLCHARACTERISTICS_NX_COMPAT, QT_TRANSLATE_NOOP("DBG", "IMAGE_DLLCHARACTERISTICS_NX_COMPAT: Image is NX compatible"));
pFlag(dllc, IMAGE_DLLCHARACTERISTICS_NO_ISOLATION, QT_TRANSLATE_NOOP("DBG", "IMAGE_DLLCHARACTERISTICS_NO_ISOLATION: Image understands isolation and doesn't want it"));
pFlag(dllc, IMAGE_DLLCHARACTERISTICS_NO_SEH, QT_TRANSLATE_NOOP("DBG", "IMAGE_DLLCHARACTERISTICS_NO_SEH: Image does not use SEH. No SE handler may reside in this image"));
pFlag(dllc, IMAGE_DLLCHARACTERISTICS_NO_BIND, QT_TRANSLATE_NOOP("DBG", "IMAGE_DLLCHARACTERISTICS_NO_BIND: Do not bind this image."));
pFlag(dllc, IMAGE_DLLCHARACTERISTICS_WDM_DRIVER, QT_TRANSLATE_NOOP("DBG", "IMAGE_DLLCHARACTERISTICS_WDM_DRIVER: Driver uses WDM model."));
pFlag(dllc, IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE, QT_TRANSLATE_NOOP("DBG", "IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE: Remote Desktop Services aware."));
dputs_untranslated("---------------");
return true;
}
bool cbInstrGetRelocSize(int argc, char* argv[])
{
//Original tool "GetRelocSize" by Killboy/SND
if(argc < 2)
{
_plugin_logputs(QT_TRANSLATE_NOOP("DBG", "Not enough arguments!"));
return false;
}
duint RelocDirAddr;
if(!valfromstring(argv[1], &RelocDirAddr, false))
return false;
duint RelocSize = 0;
varset("$result", RelocSize, false);
IMAGE_RELOCATION RelocDir;
do
{
if(!MemRead(RelocDirAddr, &RelocDir, sizeof(IMAGE_RELOCATION)))
{
_plugin_logputs(QT_TRANSLATE_NOOP("DBG", "Invalid relocation table!"));
return false;
}
if(!RelocDir.SymbolTableIndex)
break;
RelocSize += RelocDir.SymbolTableIndex;
RelocDirAddr += RelocDir.SymbolTableIndex;
}
while(RelocDir.VirtualAddress);
if(!RelocSize)
{
_plugin_logputs(QT_TRANSLATE_NOOP("DBG", "Invalid relocation table!"));
return false;
}
varset("$result", RelocSize, false);
_plugin_logprintf(QT_TRANSLATE_NOOP("DBG", "Relocation table size: %X\n"), RelocSize);
return true;
}
static void printExhandlers(const char* name, const std::vector<duint> & entries)
{
if(!entries.size())
return;
dprintf("%s:\n", name);
for(auto entry : entries)
{
dputs_untranslated(SymGetSymbolicName(entry).c_str());
}
}
bool cbInstrExhandlers(int argc, char* argv[])
{
std::vector<duint> entries;
#ifndef _WIN64
if(ExHandlerGetInfo(EX_HANDLER_SEH, entries))
{
std::vector<duint> handlers;
for(auto entry : entries)
{
duint handler;
if(MemRead(entry + sizeof(duint), &handler, sizeof(handler)))
handlers.push_back(handler);
}
printExhandlers("StructuredExceptionHandler (SEH)", handlers);
}
else
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to get SEH (disabled?)"));
#endif //_WIN64
if(ExHandlerGetInfo(EX_HANDLER_VEH, entries))
printExhandlers("VectoredExceptionHandler (VEH)", entries);
else
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to get VEH (loaded symbols for ntdll.dll?)"));
if(IsVistaOrLater())
{
if(ExHandlerGetInfo(EX_HANDLER_VCH, entries))
printExhandlers("VectoredContinueHandler (VCH)", entries);
else
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to get VCH (loaded symbols for ntdll.dll?)"));
}
if(ExHandlerGetInfo(EX_HANDLER_UNHANDLED, entries))
printExhandlers("UnhandledExceptionFilter", entries);
else if(IsVistaOrLater())
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to get UnhandledExceptionFilter (loaded symbols for kernelbase.dll?)"));
else
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to get UnhandledExceptionFilter (loaded symbols for kernel32.dll?)"));
return true;
}
bool cbInstrExinfo(int argc, char* argv[])
{
const unsigned int MASK_FACILITY_VISUALCPP = 0x006D0000;
auto info = getLastExceptionInfo();
const auto & record = info.ExceptionRecord;
dputs_untranslated("EXCEPTION_DEBUG_INFO:");
dprintf_untranslated(" dwFirstChance: %X\n", info.dwFirstChance);
auto exceptionName = ExceptionCodeToName(record.ExceptionCode);
if(!exceptionName.size()) //if no exception was found, try the error codes (RPC_S_*)
exceptionName = ErrorCodeToName(record.ExceptionCode);
if(exceptionName.size())
dprintf_untranslated(" ExceptionCode: %08X (%s)\n", record.ExceptionCode, exceptionName.c_str());
else if((record.ExceptionCode & MASK_FACILITY_VISUALCPP) == MASK_FACILITY_VISUALCPP) //delayhlp.cpp
{
auto possibleError = record.ExceptionCode & 0xFFFF;
exceptionName = ErrorCodeToName(possibleError);
if(!exceptionName.empty())
exceptionName = StringUtils::sprintf(" (Visual C++ %s)", exceptionName.c_str());
dprintf_untranslated(" ExceptionCode: %08X%s\n", record.ExceptionCode, exceptionName.c_str());
}
else
dprintf_untranslated(" ExceptionCode: %08X\n", record.ExceptionCode);
dprintf_untranslated(" ExceptionFlags: %08X\n", record.ExceptionFlags);
dprintf_untranslated(" ExceptionAddress: %s\n", SymGetSymbolicName(duint(record.ExceptionAddress)).c_str());
dprintf_untranslated(" NumberParameters: %u\n", record.NumberParameters);
if(record.NumberParameters)
for(DWORD i = 0; i < record.NumberParameters; i++)
{
dprintf_untranslated("ExceptionInformation[%02u]: %s", i, SymGetSymbolicName(duint(record.ExceptionInformation[i])).c_str());
//https://msdn.microsoft.com/en-us/library/windows/desktop/aa363082(v=vs.85).aspx
if(record.ExceptionCode == EXCEPTION_ACCESS_VIOLATION ||
record.ExceptionCode == EXCEPTION_IN_PAGE_ERROR ||
record.ExceptionCode == EXCEPTION_GUARD_PAGE)
{
if(i == 0)
{
if(record.ExceptionInformation[i] == 0)
dprintf_untranslated(" Read");
else if(record.ExceptionInformation[i] == 1)
dprintf_untranslated(" Write");
else if(record.ExceptionInformation[i] == 8)
dprintf_untranslated(" DEP Violation");
}
else if(i == 1)
dprintf_untranslated(" Inaccessible Address");
else if(record.ExceptionCode == EXCEPTION_IN_PAGE_ERROR && i == 2)
dprintf_untranslated(" %s", ExceptionCodeToName((unsigned int)record.ExceptionInformation[i]).c_str());
}
dprintf_untranslated("\n");
}
return true;
}
bool cbInstrTraceexecute(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint addr;
if(!valfromstring(argv[1], &addr, false))
return false;
dbgtraceexecute(addr);
return true;
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-analysis.h | #pragma once
#include "command.h"
bool cbInstrAnalyse(int argc, char* argv[]);
bool cbInstrExanalyse(int argc, char* argv[]);
bool cbInstrCfanalyse(int argc, char* argv[]);
bool cbInstrAnalyseNukem(int argc, char* argv[]);
bool cbInstrAnalxrefs(int argc, char* argv[]);
bool cbInstrAnalrecur(int argc, char* argv[]);
bool cbInstrAnalyseadv(int argc, char* argv[]);
bool cbInstrVirtualmod(int argc, char* argv[]);
bool cbDebugDownloadSymbol(int argc, char* argv[]);
bool cbDebugLoadSymbol(int argc, char* argv[]);
bool cbDebugUnloadSymbol(int argc, char* argv[]);
bool cbInstrImageinfo(int argc, char* argv[]);
bool cbInstrGetRelocSize(int argc, char* argv[]);
bool cbInstrExhandlers(int argc, char* argv[]);
bool cbInstrExinfo(int argc, char* argv[]);
bool cbInstrTraceexecute(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-breakpoint-control.cpp | #include "cmd-breakpoint-control.h"
#include "console.h"
#include "memory.h"
#include "debugger.h"
#include "exception.h"
#include "value.h"
// breakpoint enumeration callbacks
static bool cbDeleteAllBreakpoints(const BREAKPOINT* bp)
{
if(bp->type != BPNORMAL)
return true;
if(!BpDelete(*bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete breakpoint failed (BpDelete): %p\n"), bp->addr);
return false;
}
if(bp->enabled && bp->active && !DeleteBPX(bp->addr))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete breakpoint failed (DeleteBPX): %p\n"), bp->addr);
return false;
}
return true;
}
static bool cbEnableAllBreakpoints(const BREAKPOINT* bp)
{
if(bp->type != BPNORMAL || bp->enabled)
return true;
if(!SetBPX(bp->addr, bp->titantype, cbUserBreakpoint))
{
if(!MemIsValidReadPtr(bp->addr))
return true;
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable breakpoint %p (SetBPX)\n"), bp->addr);
return false;
}
if(!BpEnable(bp->addr, BPNORMAL, true))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable breakpoint %p (BpEnable)\n"), bp->addr);
return false;
}
return true;
}
static bool cbDisableAllBreakpoints(const BREAKPOINT* bp)
{
if(bp->type != BPNORMAL || !bp->enabled)
return true;
if(!BpEnable(bp->addr, BPNORMAL, false))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable breakpoint %p (BpEnable)\n"), bp->addr);
return false;
}
if(!DeleteBPX(bp->addr))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable breakpoint %p (DeleteBPX)\n"), bp->addr);
return false;
}
return true;
}
// Software breakpoints
bool cbDebugSetBPX(int argc, char* argv[]) //bp addr [,name [,type]]
{
if(IsArgumentsLessThan(argc, 2))
return false;
char argaddr[deflen] = "";
strcpy_s(argaddr, argv[1]);
char argname[deflen] = "";
if(argc > 2)
strcpy_s(argname, argv[2]);
char argtype[deflen] = "";
bool has_arg2 = argc > 3;
if(has_arg2)
strcpy_s(argtype, argv[3]);
if(!has_arg2 && (scmp(argname, "ss") || scmp(argname, "long") || scmp(argname, "ud2")))
{
strcpy_s(argtype, argname);
*argname = 0;
}
_strlwr_s(argtype);
duint addr = 0;
if(!valfromstring(argaddr, &addr))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid addr: \"%s\"\n"), argaddr);
return false;
}
int type = 0;
bool singleshoot = false;
if(strstr(argtype, "ss"))
{
type |= UE_SINGLESHOOT;
singleshoot = true;
}
else
type |= UE_BREAKPOINT;
if(strstr(argtype, "long"))
type |= UE_BREAKPOINT_TYPE_LONG_INT3;
else if(strstr(argtype, "ud2"))
type |= UE_BREAKPOINT_TYPE_UD2;
else if(strstr(argtype, "short"))
type |= UE_BREAKPOINT_TYPE_INT3;
short oldbytes;
const char* bpname = 0;
if(*argname)
bpname = argname;
BREAKPOINT bp;
if(BpGet(addr, BPNORMAL, bpname, &bp))
{
if(!bp.enabled)
return DbgCmdExecDirect(StringUtils::sprintf("bpe %p", bp.addr).c_str());
dputs(QT_TRANSLATE_NOOP("DBG", "Breakpoint already set!"));
return true;
}
if(IsBPXEnabled(addr))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting breakpoint at %p! (IsBPXEnabled)\n"), addr);
return false;
}
if(!MemRead(addr, &oldbytes, sizeof(short)))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting breakpoint at %p! (memread)\n"), addr);
return false;
}
if(!BpNew(addr, true, singleshoot, oldbytes, BPNORMAL, type, bpname))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting breakpoint at %p! (bpnew)\n"), addr);
return false;
}
if(!SetBPX(addr, type, cbUserBreakpoint))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting breakpoint at %p! (SetBPX)\n"), addr);
if(!BpDelete(addr, BPNORMAL))
dprintf(QT_TRANSLATE_NOOP("DBG", "Error handling invalid breakpoint at %p! (bpdel)\n"), addr);
return false;
}
GuiUpdateAllViews();
if(bpname)
dprintf(QT_TRANSLATE_NOOP("DBG", "Breakpoint at %p (%s) set!\n"), addr, bpname);
else
dprintf(QT_TRANSLATE_NOOP("DBG", "Breakpoint at %p set!\n"), addr);
return true;
}
bool cbDebugDeleteBPX(int argc, char* argv[])
{
if(argc < 2) //delete all breakpoints
{
if(!BpGetCount(BPNORMAL))
{
dputs(QT_TRANSLATE_NOOP("DBG", "No breakpoints to delete!"));
return true;
}
if(!BpEnumAll(cbDeleteAllBreakpoints)) //at least one deletion failed
{
GuiUpdateAllViews();
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "All breakpoints deleted!"));
GuiUpdateAllViews();
return true;
}
BREAKPOINT found;
if(BpGet(0, BPNORMAL, argv[1], &found)) //found a breakpoint with name
{
if(!BpDelete(found.addr, BPNORMAL))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete breakpoint failed (bpdel): %p\n"), found.addr);
return false;
}
if(found.enabled && !DeleteBPX(found.addr))
{
GuiUpdateAllViews();
if(!MemIsValidReadPtr(found.addr))
return true;
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete breakpoint failed (DeleteBPX): %p\n"), found.addr);
return false;
}
GuiUpdateAllViews();
return true;
}
duint addr = 0;
if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPNORMAL, 0, &found)) //invalid breakpoint
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(!BpDelete(found.addr, BPNORMAL))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete breakpoint failed (bpdel): %p\n"), found.addr);
return false;
}
if(found.enabled && !DeleteBPX(found.addr))
{
GuiUpdateAllViews();
if(!MemIsValidReadPtr(found.addr))
return true;
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete breakpoint failed (DeleteBPX): %p\n"), found.addr);
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Breakpoint deleted!"));
GuiUpdateAllViews();
return true;
}
bool cbDebugEnableBPX(int argc, char* argv[])
{
if(argc < 2) //enable all breakpoints
{
if(!BpGetCount(BPNORMAL))
{
dputs(QT_TRANSLATE_NOOP("DBG", "No breakpoints to enable!"));
return true;
}
if(!BpEnumAll(cbEnableAllBreakpoints)) //at least one enable failed
return false;
dputs(QT_TRANSLATE_NOOP("DBG", "All breakpoints enabled!"));
GuiUpdateAllViews();
return true;
}
BREAKPOINT found;
if(BpGet(0, BPNORMAL, argv[1], &found)) //found a breakpoint with name
{
if(!SetBPX(found.addr, found.titantype, cbUserBreakpoint))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable breakpoint %p (SetBPX)\n"), found.addr);
return false;
}
if(!BpEnable(found.addr, BPNORMAL, true))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable breakpoint %p (BpEnable)\n"), found.addr);
return false;
}
GuiUpdateAllViews();
return true;
}
duint addr = 0;
if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPNORMAL, 0, &found)) //invalid breakpoint
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(found.enabled)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Breakpoint already enabled!"));
GuiUpdateAllViews();
return true;
}
if(!SetBPX(found.addr, found.titantype, cbUserBreakpoint))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable breakpoint %p (SetBPX)\n"), found.addr);
return false;
}
if(!BpEnable(found.addr, BPNORMAL, true))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable breakpoint %p (BpEnable)\n"), found.addr);
return false;
}
GuiUpdateAllViews();
dputs(QT_TRANSLATE_NOOP("DBG", "Breakpoint enabled!"));
return true;
}
bool cbDebugDisableBPX(int argc, char* argv[])
{
if(argc < 2) //delete all breakpoints
{
if(!BpGetCount(BPNORMAL))
{
dputs(QT_TRANSLATE_NOOP("DBG", "No breakpoints to disable!"));
return true;
}
if(!BpEnumAll(cbDisableAllBreakpoints)) //at least one deletion failed
return false;
dputs(QT_TRANSLATE_NOOP("DBG", "All breakpoints disabled!"));
GuiUpdateAllViews();
return true;
}
BREAKPOINT found;
if(BpGet(0, BPNORMAL, argv[1], &found)) //found a breakpoint with name
{
if(!BpEnable(found.addr, BPNORMAL, false))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable breakpoint %p (BpEnable)\n"), found.addr);
return false;
}
if(!DeleteBPX(found.addr))
{
GuiUpdateAllViews();
if(!MemIsValidReadPtr(found.addr))
return true;
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable breakpoint %p (DeleteBPX)\n"), found.addr);
return false;
}
GuiUpdateAllViews();
return true;
}
duint addr = 0;
if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPNORMAL, 0, &found)) //invalid breakpoint
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(!found.enabled)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Breakpoint already disabled!"));
return true;
}
if(!BpEnable(found.addr, BPNORMAL, false))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable breakpoint %p (BpEnable)\n"), found.addr);
return false;
}
if(!DeleteBPX(found.addr))
{
GuiUpdateAllViews();
if(!MemIsValidReadPtr(found.addr))
return true;
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable breakpoint %p (DeleteBPX)\n"), found.addr);
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Breakpoint disabled!"));
GuiUpdateAllViews();
return true;
}
// Hardware breakpoints
static bool cbDeleteAllHardwareBreakpoints(const BREAKPOINT* bp)
{
if(bp->type != BPHARDWARE)
return true;
if(!BpDelete(*bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete hardware breakpoint failed (BpDelete): %p\n"), bp->addr);
return false;
}
if(bp->enabled && bp->active && TITANDRXVALID(bp->titantype) && !DeleteHardwareBreakPoint(TITANGETDRX(bp->titantype)))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete hardware breakpoint failed (DeleteHardwareBreakPoint): %p\n"), bp->addr);
return false;
}
return true;
}
static bool cbEnableAllHardwareBreakpoints(const BREAKPOINT* bp)
{
if(bp->type != BPHARDWARE || bp->enabled)
return true;
DWORD drx = 0;
if(!GetUnusedHardwareBreakPointRegister(&drx))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Did not enable hardware breakpoint %p (all slots full)\n"), bp->addr);
return true;
}
int titantype = bp->titantype;
TITANSETDRX(titantype, drx);
BpSetTitanType(bp->addr, BPHARDWARE, titantype);
if(!BpEnable(bp->addr, BPHARDWARE, true))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable hardware breakpoint %p (BpEnable)\n"), bp->addr);
return false;
}
if(!SetHardwareBreakPoint(bp->addr, drx, TITANGETTYPE(bp->titantype), TITANGETSIZE(bp->titantype), cbHardwareBreakpoint))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable hardware breakpoint %p (SetHardwareBreakPoint)\n"), bp->addr);
return false;
}
return true;
}
static bool cbDisableAllHardwareBreakpoints(const BREAKPOINT* bp)
{
if(bp->type != BPHARDWARE)
return true;
if(!BpEnable(bp->addr, BPHARDWARE, false))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable hardware breakpoint %p (BpEnable)\n"), bp->addr);
return false;
}
if(bp->enabled && TITANDRXVALID(bp->titantype) && !DeleteHardwareBreakPoint(TITANGETDRX(bp->titantype)))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable hardware breakpoint %p (DeleteHardwareBreakPoint)\n"), bp->addr);
return false;
}
auto titantype = bp->titantype;
TITANSETDRX(titantype, UE_DR7);
BpSetTitanType(bp->addr, BPHARDWARE, titantype);
return true;
}
bool cbDebugSetHardwareBreakpoint(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint addr;
if(!valfromstring(argv[1], &addr))
return false;
DWORD type = UE_HARDWARE_EXECUTE;
if(argc > 2)
{
switch(*argv[2])
{
case 'r':
type = UE_HARDWARE_READWRITE;
break;
case 'w':
type = UE_HARDWARE_WRITE;
break;
case 'x':
break;
default:
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid type, assuming 'x'"));
break;
}
}
DWORD titsize = UE_HARDWARE_SIZE_1;
if(argc > 3)
{
duint size;
if(!valfromstring(argv[3], &size))
return false;
switch(size)
{
case 1:
titsize = UE_HARDWARE_SIZE_1;
break;
case 2:
titsize = UE_HARDWARE_SIZE_2;
break;
case 4:
titsize = UE_HARDWARE_SIZE_4;
break;
#ifdef _WIN64
case 8:
titsize = UE_HARDWARE_SIZE_8;
break;
#endif // _WIN64
default:
titsize = UE_HARDWARE_SIZE_1;
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid size, using 1"));
break;
}
if((addr % size) != 0)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Address not aligned to %d\n"), int(size));
return false;
}
}
DWORD drx = 0;
if(!GetUnusedHardwareBreakPointRegister(&drx))
{
dputs(QT_TRANSLATE_NOOP("DBG", "You can only set 4 hardware breakpoints"));
return false;
}
int titantype = 0;
TITANSETDRX(titantype, drx);
TITANSETTYPE(titantype, type);
TITANSETSIZE(titantype, titsize);
//TODO: hwbp in multiple threads TEST
BREAKPOINT bp;
if(BpGet(addr, BPHARDWARE, 0, &bp))
{
if(!bp.enabled)
return DbgCmdExecDirect(StringUtils::sprintf("bphwe %p", bp.addr).c_str());
dputs(QT_TRANSLATE_NOOP("DBG", "Hardware breakpoint already set!"));
return true;
}
if(!BpNew(addr, true, false, 0, BPHARDWARE, titantype, 0))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error setting hardware breakpoint (bpnew)!"));
return false;
}
if(!SetHardwareBreakPoint(addr, drx, type, titsize, cbHardwareBreakpoint))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error setting hardware breakpoint (TitanEngine)!"));
return false;
}
dprintf(QT_TRANSLATE_NOOP("DBG", "Hardware breakpoint at %p set!\n"), addr);
GuiUpdateAllViews();
return true;
}
bool cbDebugDeleteHardwareBreakpoint(int argc, char* argv[])
{
if(argc < 2) //delete all breakpoints
{
if(!BpGetCount(BPHARDWARE))
{
dputs(QT_TRANSLATE_NOOP("DBG", "No hardware breakpoints to delete!"));
return true;
}
if(!BpEnumAll(cbDeleteAllHardwareBreakpoints)) //at least one deletion failed
return false;
dputs(QT_TRANSLATE_NOOP("DBG", "All hardware breakpoints deleted!"));
GuiUpdateAllViews();
return true;
}
BREAKPOINT found;
if(BpGet(0, BPHARDWARE, argv[1], &found)) //found a breakpoint with name
{
if(!BpDelete(found.addr, BPHARDWARE))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete hardware breakpoint failed: %p (BpDelete)\n"), found.addr);
return false;
}
if(TITANDRXVALID(found.titantype) && !DeleteHardwareBreakPoint(found.titantype))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete hardware breakpoint failed: %p (DeleteHardwareBreakPoint)\n"), found.addr);
return false;
}
GuiUpdateAllViews();
return true;
}
duint addr = 0;
if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPHARDWARE, 0, &found)) //invalid breakpoint
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such hardware breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(!BpDelete(found.addr, BPHARDWARE))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete hardware breakpoint failed: %p (BpDelete)\n"), found.addr);
return false;
}
if(TITANDRXVALID(found.titantype) && !DeleteHardwareBreakPoint(TITANGETDRX(found.titantype)))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete hardware breakpoint failed: %p (DeleteHardwareBreakPoint)\n"), found.addr);
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Hardware breakpoint deleted!"));
GuiUpdateAllViews();
return true;
}
bool cbDebugEnableHardwareBreakpoint(int argc, char* argv[])
{
DWORD drx = 0;
if(!GetUnusedHardwareBreakPointRegister(&drx))
{
dputs(QT_TRANSLATE_NOOP("DBG", "You can only set 4 hardware breakpoints"));
return false;
}
if(argc < 2) //enable all hardware breakpoints
{
if(!BpGetCount(BPHARDWARE))
{
dputs(QT_TRANSLATE_NOOP("DBG", "No hardware breakpoints to enable!"));
return true;
}
if(!BpEnumAll(cbEnableAllHardwareBreakpoints)) //at least one enable failed
return false;
dputs(QT_TRANSLATE_NOOP("DBG", "All hardware breakpoints enabled!"));
GuiUpdateAllViews();
return true;
}
BREAKPOINT found;
duint addr = 0;
if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPHARDWARE, 0, &found)) //invalid hardware breakpoint
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such hardware breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(found.enabled)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Hardware breakpoint already enabled!"));
GuiUpdateAllViews();
return true;
}
TITANSETDRX(found.titantype, drx);
BpSetTitanType(found.addr, BPHARDWARE, found.titantype);
if(!SetHardwareBreakPoint(found.addr, drx, TITANGETTYPE(found.titantype), TITANGETSIZE(found.titantype), cbHardwareBreakpoint))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable hardware breakpoint %p (SetHardwareBreakpoint)\n"), found.addr);
return false;
}
if(!BpEnable(found.addr, BPHARDWARE, true))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable hardware breakpoint %p (BpEnable)\n"), found.addr);
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Hardware breakpoint enabled!"));
GuiUpdateAllViews();
return true;
}
bool cbDebugDisableHardwareBreakpoint(int argc, char* argv[])
{
if(argc < 2) //delete all hardware breakpoints
{
if(!BpGetCount(BPHARDWARE))
{
dputs(QT_TRANSLATE_NOOP("DBG", "No hardware breakpoints to disable!"));
return true;
}
if(!BpEnumAll(cbDisableAllHardwareBreakpoints)) //at least one deletion failed
return false;
dputs(QT_TRANSLATE_NOOP("DBG", "All hardware breakpoints disabled!"));
GuiUpdateAllViews();
return true;
}
BREAKPOINT found;
duint addr = 0;
if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPHARDWARE, 0, &found)) //invalid hardware breakpoint
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such hardware breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(!found.enabled)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Hardware breakpoint already disabled!"));
return true;
}
if(!BpEnable(found.addr, BPHARDWARE, false))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable hardware breakpoint %p (BpEnable)\n"), found.addr);
return false;
}
if(TITANDRXVALID(found.titantype) && !DeleteHardwareBreakPoint(TITANGETDRX(found.titantype)))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable hardware breakpoint %p (DeleteHardwareBreakpoint)\n"), found.addr);
return false;
}
TITANSETDRX(found.titantype, UE_DR7);
BpSetTitanType(found.addr, BPHARDWARE, found.titantype);
dputs(QT_TRANSLATE_NOOP("DBG", "Hardware breakpoint disabled!"));
GuiUpdateAllViews();
return true;
}
// Memory breakpoints
static bool cbDeleteAllMemoryBreakpoints(const BREAKPOINT* bp)
{
if(bp->type != BPMEMORY)
return true;
duint size;
MemFindBaseAddr(bp->addr, &size);
if(!BpDelete(*bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete memory breakpoint failed (BpDelete): %p\n"), bp->addr);
return false;
}
if(bp->enabled && bp->active && !RemoveMemoryBPX(bp->addr, size))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete memory breakpoint failed (RemoveMemoryBPX): %p\n"), bp->addr);
return false;
}
return true;
}
static bool cbEnableAllMemoryBreakpoints(const BREAKPOINT* bp)
{
if(bp->type != BPMEMORY || bp->enabled)
return true;
duint size = 0;
MemFindBaseAddr(bp->addr, &size);
if(!BpEnable(bp->addr, BPMEMORY, true))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable memory breakpoint %p (BpEnable)\n"), bp->addr);
return false;
}
if(!SetMemoryBPXEx(bp->addr, size, bp->titantype, !bp->singleshoot, cbMemoryBreakpoint))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable memory breakpoint %p (SetMemoryBPXEx)\n"), bp->addr);
return false;
}
return true;
}
static bool cbDisableAllMemoryBreakpoints(const BREAKPOINT* bp)
{
if(bp->type != BPMEMORY || !bp->enabled)
return true;
if(!BpEnable(bp->addr, BPMEMORY, false))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable memory breakpoint %p (BpEnable)\n"), bp->addr);
return false;
}
if(!RemoveMemoryBPX(bp->addr, 0))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable memory breakpoint %p (RemoveMemoryBPX)\n"), bp->addr);
return false;
}
return true;
}
bool cbDebugSetMemoryBpx(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint addr;
if(!valfromstring(argv[1], &addr))
return false;
bool restore = false;
char arg3[deflen] = "";
if(argc > 3)
strcpy_s(arg3, argv[3]);
if(argc > 2)
{
if(*argv[2] == '1')
restore = true;
else if(*argv[2] == '0')
restore = false;
else
strcpy_s(arg3, argv[2]);
}
DWORD type = UE_MEMORY;
if(*arg3)
{
switch(*arg3)
{
case 'a': //read+write+execute
type = UE_MEMORY;
break;
case 'r': //read
type = UE_MEMORY_READ;
break;
case 'w': //write
type = UE_MEMORY_WRITE;
break;
case 'x': //execute
type = UE_MEMORY_EXECUTE;
break;
default:
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid type (argument ignored)"));
break;
}
}
duint size = 0;
duint base = MemFindBaseAddr(addr, &size, true);
bool singleshoot = false;
if(!restore)
singleshoot = true;
BREAKPOINT bp;
if(BpGet(base, BPMEMORY, 0, &bp))
{
if(!bp.enabled)
return BpEnable(base, BPMEMORY, true);
dputs(QT_TRANSLATE_NOOP("DBG", "Memory breakpoint already set!"));
return true;
}
if(!BpNew(base, true, singleshoot, 0, BPMEMORY, type, 0, size))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error setting memory breakpoint! (BpNew)"));
return false;
}
if(!SetMemoryBPXEx(base, size, type, restore, cbMemoryBreakpoint))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error setting memory breakpoint! (SetMemoryBPXEx)"));
return false;
}
dprintf(QT_TRANSLATE_NOOP("DBG", "Memory breakpoint at %p set!\n"), addr);
GuiUpdateAllViews();
return true;
}
bool cbDebugDeleteMemoryBreakpoint(int argc, char* argv[])
{
if(argc < 2) //delete all breakpoints
{
if(!BpGetCount(BPMEMORY))
{
dputs(QT_TRANSLATE_NOOP("DBG", "No memory breakpoints to delete!"));
return true;
}
if(!BpEnumAll(cbDeleteAllMemoryBreakpoints)) //at least one deletion failed
return false;
dputs(QT_TRANSLATE_NOOP("DBG", "All memory breakpoints deleted!"));
GuiUpdateAllViews();
return true;
}
BREAKPOINT found;
if(BpGet(0, BPMEMORY, argv[1], &found)) //found a breakpoint with name
{
duint size;
MemFindBaseAddr(found.addr, &size);
if(!BpDelete(found.addr, BPMEMORY))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete memory breakpoint failed: %p (BpDelete)\n"), found.addr);
return false;
}
if(!RemoveMemoryBPX(found.addr, size))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete memory breakpoint failed: %p (RemoveMemoryBPX)\n"), found.addr);
return false;
}
GuiUpdateAllViews();
return true;
}
duint addr = 0;
if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPMEMORY, 0, &found)) //invalid breakpoint
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such memory breakpoint \"%s\"\n"), argv[1]);
return false;
}
duint size;
MemFindBaseAddr(found.addr, &size);
if(!BpDelete(found.addr, BPMEMORY))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete memory breakpoint failed: %p (BpDelete)\n"), found.addr);
return false;
}
if(!RemoveMemoryBPX(found.addr, size))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete memory breakpoint failed: %p (RemoveMemoryBPX)\n"), found.addr);
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Memory breakpoint deleted!"));
GuiUpdateAllViews();
return true;
}
bool cbDebugEnableMemoryBreakpoint(int argc, char* argv[])
{
if(argc < 2) //enable all memory breakpoints
{
if(!BpGetCount(BPMEMORY))
{
dputs(QT_TRANSLATE_NOOP("DBG", "No memory breakpoints to enable!"));
return true;
}
if(!BpEnumAll(cbEnableAllMemoryBreakpoints)) //at least one enable failed
return false;
dputs(QT_TRANSLATE_NOOP("DBG", "All memory breakpoints enabled!"));
GuiUpdateAllViews();
return true;
}
BREAKPOINT found;
duint addr = 0;
if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPMEMORY, 0, &found)) //invalid memory breakpoint
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such memory breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(found.enabled)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Memory breakpoint already enabled!"));
GuiUpdateAllViews();
return true;
}
duint size = 0;
MemFindBaseAddr(found.addr, &size);
if(!SetMemoryBPXEx(found.addr, size, found.titantype, !found.singleshoot, cbMemoryBreakpoint))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable memory breakpoint %p (SetMemoryBPXEx)\n"), found.addr);
return false;
}
if(!BpEnable(found.addr, BPMEMORY, true))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable memory breakpoint %p (BpEnable)\n"), found.addr);
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Memory breakpoint enabled!"));
GuiUpdateAllViews();
return true;
}
bool cbDebugDisableMemoryBreakpoint(int argc, char* argv[])
{
if(argc < 2) //disable all memory breakpoints
{
if(!BpGetCount(BPMEMORY))
{
dputs(QT_TRANSLATE_NOOP("DBG", "No memory breakpoints to disable!"));
return true;
}
if(!BpEnumAll(cbDisableAllMemoryBreakpoints)) //at least one deletion failed
return false;
dputs(QT_TRANSLATE_NOOP("DBG", "All memory breakpoints disabled!"));
GuiUpdateAllViews();
return true;
}
BREAKPOINT found;
duint addr = 0;
if(!valfromstring(argv[1], &addr) || !BpGet(addr, BPMEMORY, 0, &found)) //invalid memory breakpoint
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such memory breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(!found.enabled)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Memory breakpoint already disabled!"));
return true;
}
duint size = 0;
MemFindBaseAddr(found.addr, &size);
if(!RemoveMemoryBPX(found.addr, size))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable memory breakpoint %p (RemoveMemoryBPX)\n"), found.addr);
return false;
}
if(!BpEnable(found.addr, BPMEMORY, false))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable memory breakpoint %p (BpEnable)\n"), found.addr);
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Memory breakpoint disabled!"));
GuiUpdateAllViews();
return true;
}
// DLL breakpoints
static bool cbDeleteAllDllBreakpoints(const BREAKPOINT* bp)
{
if(bp->type != BPDLL || !bp->enabled)
return true;
if(!BpDelete(*bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not delete DLL breakpoint %s (BpDelete)\n"), bp->mod);
return false;
}
if(!dbgdeletedllbreakpoint(bp->mod, bp->titantype))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not delete DLL breakpoint %s (LibrarianRemoveBreakPoint)\n"), bp->mod);
return false;
}
return true;
}
static bool cbEnableAllDllBreakpoints(const BREAKPOINT* bp)
{
if(bp->type != BPDLL || bp->enabled)
return true;
if(!BpEnable(bp->addr, BPDLL, true))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable DLL breakpoint %s (BpEnable)\n"), bp->mod);
return false;
}
if(!dbgsetdllbreakpoint(bp->mod, bp->titantype, bp->singleshoot))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable DLL breakpoint %s (LibrarianSetBreakPoint)\n"), bp->mod);
return false;
}
return true;
}
static bool cbDisableAllDllBreakpoints(const BREAKPOINT* bp)
{
if(bp->type != BPDLL || !bp->enabled)
return true;
if(!BpEnable(bp->addr, BPDLL, false))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable DLL breakpoint %s (BpEnable)\n"), bp->mod);
return false;
}
if(!dbgdeletedllbreakpoint(bp->mod, bp->titantype))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable DLL breakpoint %s (LibrarianRemoveBreakPoint)\n"), bp->mod);
return false;
}
return true;
}
bool cbDebugBpDll(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
_strlwr_s(argv[1], strlen(argv[1]) + 1); //NOTE: does not really work on unicode strings
DWORD type = UE_ON_LIB_ALL;
if(argc > 2)
{
switch(*argv[2])
{
case 'a':
type = UE_ON_LIB_ALL;
break;
case 'l':
type = UE_ON_LIB_LOAD;
break;
case 'u':
type = UE_ON_LIB_UNLOAD;
break;
}
}
bool singleshoot = false;
if(argc > 3)
singleshoot = true;
if(!BpNewDll(argv[1], true, singleshoot, type, ""))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error creating Dll breakpoint! (BpNewDll)"));
return false;
}
if(!dbgsetdllbreakpoint(argv[1], type, singleshoot))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error creating Dll breakpoint! (LibrarianSetBreakPoint)"));
return false;
}
dprintf(QT_TRANSLATE_NOOP("DBG", "Dll breakpoint set on \"%s\"!\n"), argv[1]);
DebugUpdateBreakpointsViewAsync();
return true;
}
bool cbDebugBcDll(int argc, char* argv[])
{
if(argc < 2)
{
// delete all Dll breakpoints
if(!BpGetCount(BPDLL))
{
dputs(QT_TRANSLATE_NOOP("DBG", "No DLL breakpoints to delete!"));
return true;
}
if(!BpEnumAll(cbDeleteAllDllBreakpoints)) //at least one deletion failed
return false;
dputs(QT_TRANSLATE_NOOP("DBG", "All DLL breakpoints deleted!"));
DebugUpdateBreakpointsViewAsync();
return true;
}
_strlwr_s(argv[1], strlen(argv[1]) + 1); //NOTE: does not really work on unicode strings
BREAKPOINT bp;
if(!BpGetAny(BPDLL, argv[1], &bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to find DLL breakpoint '%s'...\n"), argv[1]);
return false;
}
if(!BpDelete(bp.addr, BPDLL))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to remove DLL breakpoint (BpDelete)..."));
return false;
}
DebugUpdateBreakpointsViewAsync();
if(!dbgdeletedllbreakpoint(bp.mod, bp.titantype))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to remove DLL breakpoint (dbgdeletedllbreakpoint)..."));
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "DLL breakpoint removed!"));
return true;
}
bool cbDebugBpDllEnable(int argc, char* argv[])
{
if(argc < 2) //enable all DLL breakpoints
{
if(!BpGetCount(BPDLL))
{
dputs(QT_TRANSLATE_NOOP("DBG", "No DLL breakpoints to enable!"));
return true;
}
if(!BpEnumAll(cbEnableAllDllBreakpoints)) //at least one deletion failed
return false;
dputs(QT_TRANSLATE_NOOP("DBG", "All DLL breakpoints enabled!"));
GuiUpdateAllViews();
return true;
}
_strlwr_s(argv[1], strlen(argv[1]) + 1); //NOTE: does not really work on unicode strings
BREAKPOINT found;
duint addr = 0;
if(!BpGetAny(BPDLL, argv[1], &found)) //invalid DLL breakpoint
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such DLL breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(found.enabled)
{
dputs(QT_TRANSLATE_NOOP("DBG", "DLL breakpoint already enabled!"));
return true;
}
if(!BpEnable(found.addr, BPDLL, true))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable DLL breakpoint %s (BpEnable)\n"), found.mod);
return false;
}
if(!dbgsetdllbreakpoint(found.mod, found.titantype, found.singleshoot))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable DLL breakpoint %s (LibrarianSetBreakPoint)\n"), found.mod);
}
dputs(QT_TRANSLATE_NOOP("DBG", "DLL breakpoint enable!"));
GuiUpdateAllViews();
return true;
}
bool cbDebugBpDllDisable(int argc, char* argv[])
{
if(argc < 2) //disable all DLL breakpoints
{
if(!BpGetCount(BPDLL))
{
dputs(QT_TRANSLATE_NOOP("DBG", "No DLL breakpoints to disable!"));
return true;
}
if(!BpEnumAll(cbDisableAllDllBreakpoints)) //at least one deletion failed
return false;
dputs(QT_TRANSLATE_NOOP("DBG", "All DLL breakpoints disabled!"));
GuiUpdateAllViews();
return true;
}
_strlwr_s(argv[1], strlen(argv[1]) + 1); //NOTE: does not really work on unicode strings
BREAKPOINT found;
duint addr = 0;
if(!BpGetAny(BPDLL, argv[1], &found)) //invalid DLL breakpoint
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such DLL breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(!found.enabled)
{
dputs(QT_TRANSLATE_NOOP("DBG", "DLL breakpoint already disabled!"));
return true;
}
if(!BpEnable(found.addr, BPDLL, false))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable DLL breakpoint %s (BpEnable)\n"), found.mod);
return false;
}
if(!dbgdeletedllbreakpoint(found.mod, found.titantype))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable DLL breakpoint %s (LibrarianRemoveBreakPoint)\n"), found.mod);
}
dputs(QT_TRANSLATE_NOOP("DBG", "DLL breakpoint disabled!"));
GuiUpdateAllViews();
return true;
}
// Exception breakpoints
static bool cbDeleteAllExceptionBreakpoints(const BREAKPOINT* bp)
{
if(bp->type != BPEXCEPTION)
return true;
if(!BpDelete(*bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not delete exception breakpoint %p (BpEnable)\n"), bp->addr);
return false;
}
return true;
}
static bool cbEnableAllExceptionBreakpoints(const BREAKPOINT* bp)
{
if(bp->type != BPEXCEPTION || bp->enabled)
return true;
if(!BpEnable(bp->addr, BPEXCEPTION, true))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable exception breakpoint %p (BpEnable)\n"), bp->addr);
return false;
}
return true;
}
static bool cbDisableAllExceptionBreakpoints(const BREAKPOINT* bp)
{
if(bp->type != BPEXCEPTION || !bp->enabled)
return true;
if(!BpEnable(bp->addr, BPEXCEPTION, false))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable exception breakpoint %p (BpEnable)\n"), bp->addr);
return false;
}
return true;
}
bool cbDebugSetExceptionBPX(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint ExceptionCode;
if(!valfromstring(argv[1], &ExceptionCode))
{
ExceptionCode = 0;
if(!ExceptionNameToCode(argv[1], reinterpret_cast<unsigned int*>(&ExceptionCode)))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid exception code: %s.\n"), argv[1]);
return false;
}
}
const String & ExceptionName = ExceptionCodeToName((unsigned int)ExceptionCode);
if(BpGet(ExceptionCode, BPEXCEPTION, nullptr, nullptr))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Exception breakpoint %X (%s) already exists!\n"), DWORD(ExceptionCode), ExceptionName.c_str());
return false;
}
auto extype = ex_firstchance;
if(argc > 2)
{
duint chance;
if(scmp(argv[2], "first"))
extype = ex_firstchance;
else if(scmp(argv[2], "second"))
extype = ex_secondchance;
else if(scmp(argv[2], "all"))
extype = ex_all;
else if(valfromstring(argv[2], &chance))
{
switch(chance)
{
case 1:
extype = ex_firstchance;
break;
case 2:
extype = ex_secondchance;
break;
case 3:
extype = ex_all;
break;
default:
_plugin_logprintf(QT_TRANSLATE_NOOP("DBG", "Invalid exception type!"));
return false;
}
}
else
{
_plugin_logprintf(QT_TRANSLATE_NOOP("DBG", "Invalid exception type!"));
return false;
}
}
if(!BpNew(ExceptionCode, true, false, 0, BPEXCEPTION, extype, ""))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to set exception breakpoint! (BpNew)"));
return false;
}
DebugUpdateBreakpointsViewAsync();
return true;
}
bool cbDebugDeleteExceptionBPX(int argc, char* argv[])
{
if(argc < 2)
{
// delete all exception breakpoints
if(!BpGetCount(BPEXCEPTION))
{
dputs(QT_TRANSLATE_NOOP("DBG", "No exception breakpoints to delete!"));
return true;
}
if(!BpEnumAll(cbDeleteAllExceptionBreakpoints)) //at least one enable failed
return false;
dputs(QT_TRANSLATE_NOOP("DBG", "All exception breakpoints deleted!"));
DebugUpdateBreakpointsViewAsync();
return true;
}
BREAKPOINT found;
if(BpGet(0, BPEXCEPTION, argv[1], &found)) //found a breakpoint with name
{
if(!BpDelete(found.addr, BPEXCEPTION))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete exception breakpoint failed (bpdel): %p\n"), found.addr);
return false;
}
DebugUpdateBreakpointsViewAsync();
return true;
}
duint addr = 0;
if((!ExceptionNameToCode(argv[1], reinterpret_cast<unsigned int*>(&addr)) && !valfromstring(argv[1], &addr)) || !BpGet(addr, BPEXCEPTION, 0, &found)) //invalid breakpoint
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such exception breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(!BpDelete(found.addr, BPEXCEPTION))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Delete exception breakpoint failed (bpdel): %p\n"), found.addr);
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Exception breakpoint deleted!"));
DebugUpdateBreakpointsViewAsync();
return true;
}
bool cbDebugEnableExceptionBPX(int argc, char* argv[])
{
if(argc < 2) //enable all breakpoints
{
if(!BpGetCount(BPEXCEPTION))
{
dputs(QT_TRANSLATE_NOOP("DBG", "No exception breakpoints to enable!"));
return true;
}
if(!BpEnumAll(cbEnableAllExceptionBreakpoints)) //at least one enable failed
return false;
dputs(QT_TRANSLATE_NOOP("DBG", "All exception breakpoints enabled!"));
DebugUpdateBreakpointsViewAsync();
return true;
}
BREAKPOINT found;
if(BpGet(0, BPEXCEPTION, argv[1], &found)) //found a breakpoint with name
{
if(!BpEnable(found.addr, BPEXCEPTION, true))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable exception breakpoint %p (BpEnable)\n"), found.addr);
return false;
}
DebugUpdateBreakpointsViewAsync();
return true;
}
duint addr = 0;
if((!ExceptionNameToCode(argv[1], reinterpret_cast<unsigned int*>(&addr)) && !valfromstring(argv[1], &addr)) || !BpGet(addr, BPEXCEPTION, 0, &found)) //invalid breakpoint
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such exception breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(found.enabled)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Exception breakpoint already enabled!"));
DebugUpdateBreakpointsViewAsync();
return true;
}
if(!BpEnable(found.addr, BPEXCEPTION, true))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not enable exception breakpoint %p (BpEnable)\n"), found.addr);
return false;
}
DebugUpdateBreakpointsViewAsync();
dputs(QT_TRANSLATE_NOOP("DBG", "Exception breakpoint enabled!"));
return true;
}
bool cbDebugDisableExceptionBPX(int argc, char* argv[])
{
if(argc < 2) //disable all breakpoints
{
if(!BpGetCount(BPEXCEPTION))
{
dputs(QT_TRANSLATE_NOOP("DBG", "No exception breakpoints to disable!"));
return true;
}
if(!BpEnumAll(cbDisableAllExceptionBreakpoints)) //at least one deletion failed
return false;
dputs(QT_TRANSLATE_NOOP("DBG", "All exception breakpoints disabled!"));
GuiUpdateAllViews();
return true;
}
BREAKPOINT found;
if(BpGet(0, BPEXCEPTION, argv[1], &found)) //found a breakpoint with name
{
if(!BpEnable(found.addr, BPEXCEPTION, false))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable exception breakpoint %p (BpEnable)\n"), found.addr);
return false;
}
GuiUpdateAllViews();
return true;
}
duint addr = 0;
if((!ExceptionNameToCode(argv[1], reinterpret_cast<unsigned int*>(&addr)) && !valfromstring(argv[1], &addr)) || !BpGet(addr, BPEXCEPTION, 0, &found)) //invalid breakpoint
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such exception breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(!found.enabled)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Exception breakpoint already disabled!"));
return true;
}
if(!BpEnable(found.addr, BPEXCEPTION, false))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not disable exception breakpoint %p (BpEnable)\n"), found.addr);
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Exception breakpoint disabled!"));
GuiUpdateAllViews();
return true;
}
bool cbDebugSetBPGoto(int argc, char* argv[])
{
if(argc != 3)
{
dputs(QT_TRANSLATE_NOOP("DBG", "argument count mismatch!\n"));
return false;
}
char cmd[deflen];
sprintf_s(cmd, "SetBreakpointCondition %s, 0", argv[1]);
if(!cmddirectexec(cmd))
return false;
sprintf_s(cmd, "SetBreakpointCommand %s, \"bpgoto(%s)\"", argv[1], argv[2]);
if(!cmddirectexec(cmd))
return false;
sprintf_s(cmd, "SetBreakpointCommandCondition %s, 1", argv[1]);
if(!cmddirectexec(cmd))
return false;
sprintf_s(cmd, "SetBreakpointFastResume %s, 0", argv[1]);
if(!cmddirectexec(cmd))
return false;
return true;
}
static bool cbBreakpointList(const BREAKPOINT* bp)
{
const char* type = 0;
if(bp->type == BPNORMAL)
{
if(bp->singleshoot)
type = "SS";
else
type = "BP";
}
else if(bp->type == BPHARDWARE)
type = "HW";
else if(bp->type == BPMEMORY)
type = "GP";
else if(bp->type == BPDLL)
type = "DLL";
else if(bp->type == BPEXCEPTION)
type = "EX";
bool enabled = bp->enabled;
if(bp->type == BPDLL)
{
if(*bp->name)
dprintf_untranslated("%d:%s:\"%s\":\"%s\"\n", enabled, type, bp->mod, bp->name);
else
dprintf_untranslated("%d:%s:\"%s\"\n", enabled, type, bp->mod);
}
else if(*bp->name)
dprintf_untranslated("%d:%s:%p:\"%s\"\n", enabled, type, bp->addr, bp->name);
else
dprintf_untranslated("%d:%s:%p\n", enabled, type, bp->addr);
return true;
}
bool cbDebugBplist(int argc, char* argv[])
{
if(!BpEnumAll(cbBreakpointList))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Something went wrong..."));
return false;
}
return true;
}
bool cbDebugSetBPXOptions(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
DWORD type = 0;
const char* strType = 0;
duint setting_type;
if(strstr(argv[1], "long"))
{
setting_type = 1; //break_int3long
strType = "TYPE_LONG_INT3";
type = UE_BREAKPOINT_LONG_INT3;
}
else if(strstr(argv[1], "ud2"))
{
setting_type = 2; //break_ud2
strType = "TYPE_UD2";
type = UE_BREAKPOINT_UD2;
}
else if(strstr(argv[1], "short"))
{
setting_type = 0; //break_int3short
strType = "TYPE_INT3";
type = UE_BREAKPOINT_INT3;
}
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid type specified!"));
return false;
}
SetBPXOptions(type);
BridgeSettingSetUint("Engine", "BreakpointType", setting_type);
dprintf(QT_TRANSLATE_NOOP("DBG", "Default breakpoint type set to: %s\n"), strType);
return true;
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-breakpoint-control.h | #pragma once
#include "command.h"
bool cbDebugSetBPX(int argc, char* argv[]);
bool cbDebugDeleteBPX(int argc, char* argv[]);
bool cbDebugEnableBPX(int argc, char* argv[]);
bool cbDebugDisableBPX(int argc, char* argv[]);
bool cbDebugSetHardwareBreakpoint(int argc, char* argv[]);
bool cbDebugDeleteHardwareBreakpoint(int argc, char* argv[]);
bool cbDebugEnableHardwareBreakpoint(int argc, char* argv[]);
bool cbDebugDisableHardwareBreakpoint(int argc, char* argv[]);
bool cbDebugSetMemoryBpx(int argc, char* argv[]);
bool cbDebugDeleteMemoryBreakpoint(int argc, char* argv[]);
bool cbDebugEnableMemoryBreakpoint(int argc, char* argv[]);
bool cbDebugDisableMemoryBreakpoint(int argc, char* argv[]);
bool cbDebugBpDll(int argc, char* argv[]);
bool cbDebugBcDll(int argc, char* argv[]);
bool cbDebugBpDllEnable(int argc, char* argv[]);
bool cbDebugBpDllDisable(int argc, char* argv[]);
bool cbDebugSetExceptionBPX(int argc, char* argv[]);
bool cbDebugDeleteExceptionBPX(int argc, char* argv[]);
bool cbDebugEnableExceptionBPX(int argc, char* argv[]);
bool cbDebugDisableExceptionBPX(int argc, char* argv[]);
bool cbDebugSetBPGoto(int argc, char* argv[]);
bool cbDebugBplist(int argc, char* argv[]);
bool cbDebugSetBPXOptions(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-conditional-breakpoint-control.cpp | #include "cmd-conditional-breakpoint-control.h"
#include "breakpoint.h"
#include "debugger.h"
#include "console.h"
#include "variable.h"
#include "value.h"
#include <functional>
static bool cbDebugSetBPXTextCommon(BP_TYPE Type, int argc, char* argv[], const String & description, const std::function<bool(duint, BP_TYPE, const char*)> & setFunction)
{
BREAKPOINT bp;
if(IsArgumentsLessThan(argc, 2))
return false;
const char* value = "";
if(argc > 2)
value = argv[2];
if(!BpGetAny(Type, argv[1], &bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(!setFunction(bp.addr, Type, value))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Can't set %s on breakpoint \"%s\"\n"), description.c_str(), argv[1]);
return false;
}
DebugUpdateBreakpointsViewAsync();
return true;
}
static bool cbDebugSetBPXNameCommon(BP_TYPE Type, int argc, char* argv[])
{
return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "breakpoint name"))), BpSetName);
}
static bool cbDebugSetBPXConditionCommon(BP_TYPE Type, int argc, char* argv[])
{
return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "break condition"))), BpSetBreakCondition);
}
static bool cbDebugSetBPXLogCommon(BP_TYPE Type, int argc, char* argv[])
{
return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "logging text"))), BpSetLogText);
}
static bool cbDebugSetBPXLogConditionCommon(BP_TYPE Type, int argc, char* argv[])
{
return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "logging condition"))), BpSetLogCondition);
}
static bool cbDebugSetBPXCommandCommon(BP_TYPE Type, int argc, char* argv[])
{
return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "command on hit"))), BpSetCommandText);
}
static bool cbDebugSetBPXCommandConditionCommon(BP_TYPE Type, int argc, char* argv[])
{
return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "command condition"))), BpSetCommandCondition);
}
static bool cbDebugSetBPXFastResumeCommon(BP_TYPE Type, int argc, char* argv[])
{
BREAKPOINT bp;
if(IsArgumentsLessThan(argc, 2))
return false;
auto fastResume = true;
if(argc > 2)
{
duint value;
if(!valfromstring(argv[2], &value, false))
return false;
fastResume = value != 0;
}
if(!BpGetAny(Type, argv[1], &bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(!BpSetFastResume(bp.addr, Type, fastResume))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Can't set fast resume on breakpoint \"%s\"\n"), argv[1]);
return false;
}
DebugUpdateBreakpointsViewAsync();
return true;
}
static bool cbDebugSetBPXSingleshootCommon(BP_TYPE Type, int argc, char* argv[])
{
BREAKPOINT bp;
if(IsArgumentsLessThan(argc, 2))
return false;
auto singleshoot = true;
if(argc > 2)
{
duint value;
if(!valfromstring(argv[2], &value, false))
return false;
singleshoot = value != 0;
}
if(!BpGetAny(Type, argv[1], &bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(!BpSetSingleshoot(bp.addr, Type, singleshoot))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Can't set singleshoot on breakpoint \"%s\"\n"), argv[1]);
return false;
}
DebugUpdateBreakpointsViewAsync();
return true;
}
static bool cbDebugSetBPXSilentCommon(BP_TYPE Type, int argc, char* argv[])
{
BREAKPOINT bp;
if(IsArgumentsLessThan(argc, 2))
return false;
auto silent = true;
if(argc > 2)
{
duint value;
if(!valfromstring(argv[2], &value, false))
return false;
silent = value != 0;
}
if(!BpGetAny(Type, argv[1], &bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(!BpSetSilent(bp.addr, Type, silent))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Can't set silent on breakpoint \"%s\"\n"), argv[1]);
return false;
}
DebugUpdateBreakpointsViewAsync();
return true;
}
static bool cbDebugGetBPXHitCountCommon(BP_TYPE Type, int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
BREAKPOINT bp;
if(!BpGetAny(Type, argv[1], &bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]);
return false;
}
varset("$result", bp.hitcount, false);
return true;
}
static bool cbDebugResetBPXHitCountCommon(BP_TYPE Type, int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint value = 0;
if(argc > 2)
if(!valfromstring(argv[2], &value, false))
return false;
BREAKPOINT bp;
if(!BpGetAny(Type, argv[1], &bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]);
return false;
}
if(!BpResetHitCount(bp.addr, Type, (uint32)value))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Can't set hit count on breakpoint \"%s\"\n"), argv[1]);
return false;
}
DebugUpdateBreakpointsViewAsync();
return true;
}
bool cbDebugSetBPXName(int argc, char* argv[])
{
return cbDebugSetBPXNameCommon(BPNORMAL, argc, argv);
}
bool cbDebugSetBPXCondition(int argc, char* argv[])
{
return cbDebugSetBPXConditionCommon(BPNORMAL, argc, argv);
}
bool cbDebugSetBPXLog(int argc, char* argv[])
{
return cbDebugSetBPXLogCommon(BPNORMAL, argc, argv);
}
bool cbDebugSetBPXLogCondition(int argc, char* argv[])
{
return cbDebugSetBPXLogConditionCommon(BPNORMAL, argc, argv);
}
bool cbDebugSetBPXCommand(int argc, char* argv[])
{
return cbDebugSetBPXCommandCommon(BPNORMAL, argc, argv);
}
bool cbDebugSetBPXCommandCondition(int argc, char* argv[])
{
return cbDebugSetBPXCommandConditionCommon(BPNORMAL, argc, argv);
}
bool cbDebugSetBPXFastResume(int argc, char* argv[])
{
return cbDebugSetBPXFastResumeCommon(BPNORMAL, argc, argv);
}
bool cbDebugSetBPXSingleshoot(int argc, char* argv[])
{
return cbDebugSetBPXSingleshootCommon(BPNORMAL, argc, argv);
}
bool cbDebugSetBPXSilent(int argc, char* argv[])
{
return cbDebugSetBPXSilentCommon(BPNORMAL, argc, argv);
}
bool cbDebugGetBPXHitCount(int argc, char* argv[])
{
return cbDebugGetBPXHitCountCommon(BPNORMAL, argc, argv);
}
bool cbDebugResetBPXHitCount(int argc, char* argv[])
{
return cbDebugResetBPXHitCountCommon(BPNORMAL, argc, argv);
}
bool cbDebugSetBPXHardwareName(int argc, char* argv[])
{
return cbDebugSetBPXNameCommon(BPHARDWARE, argc, argv);
}
bool cbDebugSetBPXHardwareCondition(int argc, char* argv[])
{
return cbDebugSetBPXConditionCommon(BPHARDWARE, argc, argv);
}
bool cbDebugSetBPXHardwareLog(int argc, char* argv[])
{
return cbDebugSetBPXLogCommon(BPHARDWARE, argc, argv);
}
bool cbDebugSetBPXHardwareLogCondition(int argc, char* argv[])
{
return cbDebugSetBPXLogConditionCommon(BPHARDWARE, argc, argv);
}
bool cbDebugSetBPXHardwareCommand(int argc, char* argv[])
{
return cbDebugSetBPXCommandCommon(BPHARDWARE, argc, argv);
}
bool cbDebugSetBPXHardwareCommandCondition(int argc, char* argv[])
{
return cbDebugSetBPXCommandConditionCommon(BPHARDWARE, argc, argv);
}
bool cbDebugSetBPXHardwareFastResume(int argc, char* argv[])
{
return cbDebugSetBPXFastResumeCommon(BPHARDWARE, argc, argv);
}
bool cbDebugSetBPXHardwareSingleshoot(int argc, char* argv[])
{
return cbDebugSetBPXSingleshootCommon(BPHARDWARE, argc, argv);
}
bool cbDebugSetBPXHardwareSilent(int argc, char* argv[])
{
return cbDebugSetBPXSilentCommon(BPHARDWARE, argc, argv);
}
bool cbDebugGetBPXHardwareHitCount(int argc, char* argv[])
{
return cbDebugGetBPXHitCountCommon(BPHARDWARE, argc, argv);
}
bool cbDebugResetBPXHardwareHitCount(int argc, char* argv[])
{
return cbDebugResetBPXHitCountCommon(BPHARDWARE, argc, argv);
}
bool cbDebugSetBPXMemoryName(int argc, char* argv[])
{
return cbDebugSetBPXNameCommon(BPMEMORY, argc, argv);
}
bool cbDebugSetBPXMemoryCondition(int argc, char* argv[])
{
return cbDebugSetBPXConditionCommon(BPMEMORY, argc, argv);
}
bool cbDebugSetBPXMemoryLog(int argc, char* argv[])
{
return cbDebugSetBPXLogCommon(BPMEMORY, argc, argv);
}
bool cbDebugSetBPXMemoryLogCondition(int argc, char* argv[])
{
return cbDebugSetBPXLogConditionCommon(BPMEMORY, argc, argv);
}
bool cbDebugSetBPXMemoryCommand(int argc, char* argv[])
{
return cbDebugSetBPXCommandCommon(BPMEMORY, argc, argv);
}
bool cbDebugSetBPXMemoryCommandCondition(int argc, char* argv[])
{
return cbDebugSetBPXCommandConditionCommon(BPMEMORY, argc, argv);
}
bool cbDebugSetBPXMemoryFastResume(int argc, char* argv[])
{
return cbDebugSetBPXFastResumeCommon(BPMEMORY, argc, argv);
}
bool cbDebugSetBPXMemorySingleshoot(int argc, char* argv[])
{
return cbDebugSetBPXSingleshootCommon(BPMEMORY, argc, argv);
}
bool cbDebugSetBPXMemorySilent(int argc, char* argv[])
{
return cbDebugSetBPXSilentCommon(BPMEMORY, argc, argv);
}
bool cbDebugGetBPXMemoryHitCount(int argc, char* argv[])
{
return cbDebugGetBPXHitCountCommon(BPMEMORY, argc, argv);
}
bool cbDebugResetBPXMemoryHitCount(int argc, char* argv[])
{
return cbDebugResetBPXHitCountCommon(BPMEMORY, argc, argv);
}
bool cbDebugSetBPXDLLName(int argc, char* argv[])
{
return cbDebugSetBPXNameCommon(BPDLL, argc, argv);
}
bool cbDebugSetBPXDLLCondition(int argc, char* argv[])
{
return cbDebugSetBPXConditionCommon(BPDLL, argc, argv);
}
bool cbDebugSetBPXDLLLog(int argc, char* argv[])
{
return cbDebugSetBPXLogCommon(BPDLL, argc, argv);
}
bool cbDebugSetBPXDLLLogCondition(int argc, char* argv[])
{
return cbDebugSetBPXLogConditionCommon(BPDLL, argc, argv);
}
bool cbDebugSetBPXDLLCommand(int argc, char* argv[])
{
return cbDebugSetBPXCommandCommon(BPDLL, argc, argv);
}
bool cbDebugSetBPXDLLCommandCondition(int argc, char* argv[])
{
return cbDebugSetBPXCommandConditionCommon(BPDLL, argc, argv);
}
bool cbDebugSetBPXDLLFastResume(int argc, char* argv[])
{
return cbDebugSetBPXFastResumeCommon(BPDLL, argc, argv);
}
bool cbDebugSetBPXDLLSingleshoot(int argc, char* argv[])
{
return cbDebugSetBPXSingleshootCommon(BPDLL, argc, argv);
}
bool cbDebugSetBPXDLLSilent(int argc, char* argv[])
{
return cbDebugSetBPXSilentCommon(BPDLL, argc, argv);
}
bool cbDebugGetBPXDLLHitCount(int argc, char* argv[])
{
return cbDebugGetBPXHitCountCommon(BPDLL, argc, argv);
}
bool cbDebugResetBPXDLLHitCount(int argc, char* argv[])
{
return cbDebugResetBPXHitCountCommon(BPDLL, argc, argv);
}
bool cbDebugSetBPXExceptionName(int argc, char* argv[])
{
return cbDebugSetBPXNameCommon(BPEXCEPTION, argc, argv);
}
bool cbDebugSetBPXExceptionCondition(int argc, char* argv[])
{
return cbDebugSetBPXConditionCommon(BPEXCEPTION, argc, argv);
}
bool cbDebugSetBPXExceptionLog(int argc, char* argv[])
{
return cbDebugSetBPXLogCommon(BPEXCEPTION, argc, argv);
}
bool cbDebugSetBPXExceptionLogCondition(int argc, char* argv[])
{
return cbDebugSetBPXLogConditionCommon(BPEXCEPTION, argc, argv);
}
bool cbDebugSetBPXExceptionCommand(int argc, char* argv[])
{
return cbDebugSetBPXCommandCommon(BPEXCEPTION, argc, argv);
}
bool cbDebugSetBPXExceptionCommandCondition(int argc, char* argv[])
{
return cbDebugSetBPXCommandConditionCommon(BPEXCEPTION, argc, argv);
}
bool cbDebugSetBPXExceptionFastResume(int argc, char* argv[])
{
return cbDebugSetBPXFastResumeCommon(BPEXCEPTION, argc, argv);
}
bool cbDebugSetBPXExceptionSingleshoot(int argc, char* argv[])
{
return cbDebugSetBPXSingleshootCommon(BPEXCEPTION, argc, argv);
}
bool cbDebugSetBPXExceptionSilent(int argc, char* argv[])
{
return cbDebugSetBPXSilentCommon(BPEXCEPTION, argc, argv);
}
bool cbDebugGetBPXExceptionHitCount(int argc, char* argv[])
{
return cbDebugGetBPXHitCountCommon(BPEXCEPTION, argc, argv);
}
bool cbDebugResetBPXExceptionHitCount(int argc, char* argv[])
{
return cbDebugResetBPXHitCountCommon(BPEXCEPTION, argc, argv);
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-conditional-breakpoint-control.h | #pragma once
#include "command.h"
bool cbDebugSetBPXName(int argc, char* argv[]);
bool cbDebugSetBPXCondition(int argc, char* argv[]);
bool cbDebugSetBPXLog(int argc, char* argv[]);
bool cbDebugSetBPXLogCondition(int argc, char* argv[]);
bool cbDebugSetBPXCommand(int argc, char* argv[]);
bool cbDebugSetBPXCommandCondition(int argc, char* argv[]);
bool cbDebugSetBPXFastResume(int argc, char* argv[]);
bool cbDebugSetBPXSingleshoot(int argc, char* argv[]);
bool cbDebugSetBPXSilent(int argc, char* argv[]);
bool cbDebugGetBPXHitCount(int argc, char* argv[]);
bool cbDebugResetBPXHitCount(int argc, char* argv[]);
bool cbDebugSetBPXHardwareName(int argc, char* argv[]);
bool cbDebugSetBPXHardwareCondition(int argc, char* argv[]);
bool cbDebugSetBPXHardwareLog(int argc, char* argv[]);
bool cbDebugSetBPXHardwareLogCondition(int argc, char* argv[]);
bool cbDebugSetBPXHardwareCommand(int argc, char* argv[]);
bool cbDebugSetBPXHardwareCommandCondition(int argc, char* argv[]);
bool cbDebugSetBPXHardwareFastResume(int argc, char* argv[]);
bool cbDebugSetBPXHardwareSingleshoot(int argc, char* argv[]);
bool cbDebugSetBPXHardwareSilent(int argc, char* argv[]);
bool cbDebugGetBPXHardwareHitCount(int argc, char* argv[]);
bool cbDebugResetBPXHardwareHitCount(int argc, char* argv[]);
bool cbDebugSetBPXMemoryName(int argc, char* argv[]);
bool cbDebugSetBPXMemoryCondition(int argc, char* argv[]);
bool cbDebugSetBPXMemoryLog(int argc, char* argv[]);
bool cbDebugSetBPXMemoryLogCondition(int argc, char* argv[]);
bool cbDebugSetBPXMemoryCommand(int argc, char* argv[]);
bool cbDebugSetBPXMemoryCommandCondition(int argc, char* argv[]);
bool cbDebugSetBPXMemoryFastResume(int argc, char* argv[]);
bool cbDebugSetBPXMemorySingleshoot(int argc, char* argv[]);
bool cbDebugSetBPXMemorySilent(int argc, char* argv[]);
bool cbDebugGetBPXMemoryHitCount(int argc, char* argv[]);
bool cbDebugResetBPXMemoryHitCount(int argc, char* argv[]);
bool cbDebugSetBPXDLLName(int argc, char* argv[]);
bool cbDebugSetBPXDLLCondition(int argc, char* argv[]);
bool cbDebugSetBPXDLLLog(int argc, char* argv[]);
bool cbDebugSetBPXDLLLogCondition(int argc, char* argv[]);
bool cbDebugSetBPXDLLCommand(int argc, char* argv[]);
bool cbDebugSetBPXDLLCommandCondition(int argc, char* argv[]);
bool cbDebugSetBPXDLLFastResume(int argc, char* argv[]);
bool cbDebugSetBPXDLLSingleshoot(int argc, char* argv[]);
bool cbDebugSetBPXDLLSilent(int argc, char* argv[]);
bool cbDebugGetBPXDLLHitCount(int argc, char* argv[]);
bool cbDebugResetBPXDLLHitCount(int argc, char* argv[]);
bool cbDebugSetBPXExceptionName(int argc, char* argv[]);
bool cbDebugSetBPXExceptionCondition(int argc, char* argv[]);
bool cbDebugSetBPXExceptionLog(int argc, char* argv[]);
bool cbDebugSetBPXExceptionLogCondition(int argc, char* argv[]);
bool cbDebugSetBPXExceptionCommand(int argc, char* argv[]);
bool cbDebugSetBPXExceptionCommandCondition(int argc, char* argv[]);
bool cbDebugSetBPXExceptionFastResume(int argc, char* argv[]);
bool cbDebugSetBPXExceptionSingleshoot(int argc, char* argv[]);
bool cbDebugSetBPXExceptionSilent(int argc, char* argv[]);
bool cbDebugGetBPXExceptionHitCount(int argc, char* argv[]);
bool cbDebugResetBPXExceptionHitCount(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-debug-control.cpp | #include "cmd-debug-control.h"
#include "ntdll/ntdll.h"
#include "console.h"
#include "debugger.h"
#include "animate.h"
#include "historycontext.h"
#include "threading.h"
#include "memory.h"
#include "disasm_fast.h"
#include "plugin_loader.h"
#include "value.h"
#include "TraceRecord.h"
#include "handle.h"
#include "thread.h"
#include "GetPeArch.h"
#include "database.h"
#include "exception.h"
#include "stringformat.h"
static bool isInt3Exception()
{
if(getLastExceptionInfo().ExceptionRecord.ExceptionCode != EXCEPTION_BREAKPOINT)
return false;
auto exceptionAddress = (duint)getLastExceptionInfo().ExceptionRecord.ExceptionAddress;
unsigned char data[MAX_DISASM_BUFFER];
MemRead(exceptionAddress, data, sizeof(data));
Zydis zydis;
return zydis.Disassemble(exceptionAddress, data) && zydis.IsInt3();
}
static bool skipInt3Stepping(int argc, char* argv[])
{
if(bSkipInt3Stepping && !dbgisrunning() && isInt3Exception())
{
//Don't allow skipping of multiple consecutive INT3 instructions
getLastExceptionInfo().ExceptionRecord.ExceptionCode = 0;
dbgsetcontinuestatus(DBG_CONTINUE); // swallow the exception
dputs(QT_TRANSLATE_NOOP("DBG", "Skipped INT3!"));
return true;
}
return false;
}
bool cbDebugRunInternal(int argc, char* argv[], HistoryAction history)
{
// History handling
if(history == history_record)
HistoryRecord();
else
HistoryClear();
// Set a singleshot breakpoint at the first parameter
if(argc >= 2 && !DbgCmdExecDirect(StringUtils::sprintf("bp \"%s\", ss", argv[1]).c_str()))
return false;
// Don't "run" twice if the program is already running
if(dbgisrunning())
return false;
GuiSetDebugStateAsync(running);
unlock(WAITID_RUN);
PLUG_CB_RESUMEDEBUG callbackInfo;
callbackInfo.reserved = 0;
plugincbcall(CB_RESUMEDEBUG, &callbackInfo);
return true;
}
bool cbDebugInit(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
EXCLUSIVE_ACQUIRE(LockDebugStartStop);
cbDebugStop(argc, argv);
ASSERT_TRUE(hDebugLoopThread == nullptr);
char arg1[deflen] = "";
strcpy_s(arg1, argv[1]);
char arg2[deflen] = "";
if(argc > 2)
strcpy_s(arg2, argv[2]);
char arg3[deflen] = "";
if(argc > 3)
strcpy_s(arg3, argv[3]);
// Process .lnk files
std::wstring executable, arguments, workingDir;
if(ResolveShortcut(GuiGetWindowHandle(), StringUtils::Utf8ToUtf16(arg1).c_str(), executable, arguments, workingDir))
{
auto resolvedPathUtf8 = StringUtils::Utf16ToUtf8(executable);
dprintf(QT_TRANSLATE_NOOP("DBG", "Resolved shortcut \"%s\" -> \"%s\"\n"), arg1, resolvedPathUtf8.c_str());
strcpy_s(arg1, resolvedPathUtf8.c_str());
// Assign a command line from the shortcut if it wasn't overwritten
if(argc <= 2)
{
auto resolvedArgsUtf8 = StringUtils::Utf16ToUtf8(arguments);
dprintf(QT_TRANSLATE_NOOP("DBG", "Resolved arguments from shortcut \"%s\"\n"), resolvedArgsUtf8.c_str());
strcpy_s(arg2, resolvedArgsUtf8.c_str());
}
// Assign a working directory from the shortcut if it wasn't overwritten
if(argc <= 3)
{
auto resolvedWorkingDirUtf8 = StringUtils::Utf16ToUtf8(workingDir);
dprintf(QT_TRANSLATE_NOOP("DBG", "Resolved working directory from shortcut \"%s\"\n"), resolvedWorkingDirUtf8.c_str());
strcpy_s(arg3, resolvedWorkingDirUtf8.c_str());
}
}
if(!FileExists(arg1))
{
dputs(QT_TRANSLATE_NOOP("DBG", "File does not exist!"));
return false;
}
auto arg1w = StringUtils::Utf8ToUtf16(arg1);
Handle hFile = CreateFileW(arg1w.c_str(), GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
if(hFile == INVALID_HANDLE_VALUE)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Could not open file!"));
return false;
}
GetFileNameFromHandle(hFile, arg1, _countof(arg1)); //get full path of the file
dprintf(QT_TRANSLATE_NOOP("DBG", "Debugging: %s\n"), arg1);
hFile.Close();
auto arch = GetPeArch(arg1w.c_str());
// Translate Any CPU to the actual architecture
if(arch == PeArch::DotnetAnyCpu)
arch = ArchValue(IsWow64() ? PeArch::Dotnet64 : PeArch::Dotnet86, PeArch::Dotnet64);
// Make sure the architecture is right
switch(arch)
{
case PeArch::Invalid:
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid PE file!"));
return false;
#ifdef _WIN64
case PeArch::Native86:
case PeArch::Dotnet86:
case PeArch::DotnetAnyCpuPrefer32:
dputs(QT_TRANSLATE_NOOP("DBG", "Use x32dbg to debug this file!"));
#else // x86
case PeArch::Native64:
case PeArch::Dotnet64:
dputs(QT_TRANSLATE_NOOP("DBG", "Use x64dbg to debug this file!"));
#endif // _WIN64
return false;
default:
break;
}
// Default to the application folder
char currentfolder[deflen] = "";
strcpy_s(currentfolder, arg1);
int len = (int)strlen(currentfolder);
while(currentfolder[len] != '\\' && len != 0)
len--;
currentfolder[len] = 0;
// Allow the user to overwrite the working directory
if(DirExists(arg3))
strcpy_s(currentfolder, arg3);
static INIT_STRUCT init;
init.exe = arg1;
init.commandline = arg2;
init.currentfolder = currentfolder;
dbgcreatedebugthread(&init);
return true;
}
bool cbDebugStop(int argc, char* argv[])
{
EXCLUSIVE_ACQUIRE(LockDebugStartStop);
if(!hDebugLoopThread)
return false;
// Give the plugins a chance to perform clean-up
PLUG_CB_STOPPINGDEBUG stoppingInfo;
stoppingInfo.reserved = 0;
plugincbcall(CB_STOPPINGDEBUG, &stoppingInfo);
auto hDebugLoopThreadCopy = hDebugLoopThread;
hDebugLoopThread = nullptr;
// HACK: TODO: Don't kill script on debugger ending a process
//scriptreset(); //reset the currently-loaded script
_dbg_animatestop();
StopDebug();
//history
HistoryClear();
DWORD BeginTick = GetTickCount();
bool shownWarning = false;
while(true)
{
switch(WaitForSingleObject(hDebugLoopThreadCopy, 100))
{
case WAIT_OBJECT_0:
CloseHandle(hDebugLoopThreadCopy);
return true;
case WAIT_TIMEOUT:
{
unlock(WAITID_RUN);
DWORD CurrentTick = GetTickCount();
DWORD TimeElapsed = CurrentTick - BeginTick;
if(TimeElapsed >= 10000)
{
if(!shownWarning)
{
shownWarning = true;
dputs(QT_TRANSLATE_NOOP("DBG", "Finalizing the debugger thread took more than 10 seconds. This can happen if you are loading large symbol files or saving a large database."));
}
if(IsFileBeingDebugged() || TimeElapsed >= 100000)
{
dputs(QT_TRANSLATE_NOOP("DBG", "The debuggee did not stop after 10 seconds of requesting termination. The debugger state may be corrupted. It is recommended to restart x64dbg."));
DbSave(DbLoadSaveType::All);
TerminateThread(hDebugLoopThreadCopy, 1); // TODO: this will lose state and cause possible corruption if a critical section is still owned
CloseHandle(hDebugLoopThreadCopy);
return false;
}
}
if(TimeElapsed >= 300)
TerminateProcess(fdProcessInfo->hProcess, -1);
}
break;
case WAIT_FAILED:
String error = stringformatinline(StringUtils::sprintf("{winerror@%x}", GetLastError()));
dprintf_untranslated("WAIT_FAILED, GetLastError() = %s\n", error.c_str());
return false;
}
}
}
bool cbDebugAttach(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint pid = 0;
if(!valfromstring(argv[1], &pid, false))
return false;
EXCLUSIVE_ACQUIRE(LockDebugStartStop);
cbDebugStop(argc, argv);
ASSERT_TRUE(hDebugLoopThread == nullptr);
Handle hProcess = TitanOpenProcess(PROCESS_ALL_ACCESS, false, (DWORD)pid);
if(!hProcess)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not open process %X!\n"), DWORD(pid));
return false;
}
BOOL debuggerPresent = FALSE;
if(CheckRemoteDebuggerPresent(hProcess, &debuggerPresent) && debuggerPresent)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Process is already being debugged!"));
return false;
}
BOOL wow64 = false, meow64 = false;
if(!IsWow64Process(hProcess, &wow64) || !IsWow64Process(GetCurrentProcess(), &meow64))
{
dputs(QT_TRANSLATE_NOOP("DBG", "IsWow64Process failed!"));
return false;
}
if(meow64 != wow64)
{
#ifdef _WIN64
dputs(QT_TRANSLATE_NOOP("DBG", "Use x32dbg to debug this process!"));
#else
dputs(QT_TRANSLATE_NOOP("DBG", "Use x64dbg to debug this process!"));
#endif // _WIN64
return false;
}
if(!GetFileNameFromProcessHandle(hProcess, szDebuggeePath, _countof(szDebuggeePath)))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not get module filename %X!\n"), DWORD(pid));
return false;
}
if(argc > 2) //event handle (JIT)
{
duint eventHandle = 0;
if(!valfromstring(argv[2], &eventHandle, false))
return false;
if(eventHandle)
dbgsetattachevent((HANDLE)eventHandle);
}
if(argc > 3) //thread id to resume (PLMDebug)
{
duint tid = 0;
if(!valfromstring(argv[3], &tid, false))
return false;
if(tid)
dbgsetresumetid(tid);
}
static INIT_STRUCT init;
init.attach = true;
init.pid = (DWORD)pid;
dbgcreatedebugthread(&init);
return true;
}
static bool dbgdetachDisableAllBreakpoints(const BREAKPOINT* bp)
{
if(bp->enabled)
{
if(bp->type == BPNORMAL)
DeleteBPX(bp->addr);
else if(bp->type == BPMEMORY)
RemoveMemoryBPX(bp->addr, 0);
else if(bp->type == BPHARDWARE && TITANDRXVALID(bp->titantype))
DeleteHardwareBreakPoint(TITANGETDRX(bp->titantype));
}
return true;
}
bool cbDebugDetach(int argc, char* argv[])
{
PLUG_CB_DETACH detachInfo;
detachInfo.fdProcessInfo = fdProcessInfo;
plugincbcall(CB_DETACH, &detachInfo);
BpEnumAll(dbgdetachDisableAllBreakpoints); // Disable all software breakpoints before detaching.
if(!DetachDebuggerEx(fdProcessInfo->dwProcessId))
dputs(QT_TRANSLATE_NOOP("DBG", "DetachDebuggerEx failed..."));
else
dputs(QT_TRANSLATE_NOOP("DBG", "Detached!"));
_dbg_animatestop(); // Stop animating
unlock(WAITID_RUN); // run to resume the debug loop if necessary
return true;
}
bool cbDebugRun(int argc, char* argv[])
{
skipInt3Stepping(1, argv);
return cbDebugRunInternal(argc, argv, history_clear);
}
bool cbDebugErun(int argc, char* argv[])
{
if(!dbgisrunning())
dbgsetskipexceptions(true);
else
{
dbgsetskipexceptions(false);
return true;
}
return cbDebugRunInternal(argc, argv, history_clear);
}
bool cbDebugSerun(int argc, char* argv[])
{
cbDebugContinue(argc, argv);
return cbDebugRunInternal(argc, argv, history_clear);
}
bool cbDebugPause(int argc, char* argv[])
{
if(_dbg_isanimating())
{
_dbg_animatestop(); // pause when animating
return true;
}
if(dbgtraceactive())
{
dbgforcebreaktrace(); // pause when tracing
return true;
}
if(dbgstepactive())
{
dbgforcebreakstep(); // pause when stepping (out/user/system)
return true;
}
if(!DbgIsDebugging())
{
dputs(QT_TRANSLATE_NOOP("DBG", "Not debugging!"));
return false;
}
if(!dbgisrunning())
{
dputs(QT_TRANSLATE_NOOP("DBG", "Program is not running"));
return false;
}
// Interesting behavior found by JustMagic, if the active thread is suspended pause would fail
auto previousSuspendCount = SuspendThread(hActiveThread);
if(previousSuspendCount != 0)
{
if(previousSuspendCount != -1)
ResumeThread(hActiveThread);
dputs(QT_TRANSLATE_NOOP("DBG", "The active thread is suspended, switch to a running thread to pause the process"));
// TODO: perhaps inject an INT3 in the process as an alternative to failing?
return false;
}
duint CIP = GetContextDataEx(hActiveThread, UE_CIP);
if(!SetBPX(CIP, UE_BREAKPOINT, cbPauseBreakpoint))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting breakpoint at %p! (SetBPX)\n"), CIP);
if(ResumeThread(hActiveThread) == -1)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error resuming thread"));
return false;
}
return false;
}
//WORKAROUND: If a program is stuck in NtUserGetMessage (GetMessage was called), this
//will send a WM_NULL to stop the waiting. This only works if the message is not filtered.
//OllyDbg also does this in a similar way.
PostThreadMessageA(ThreadGetId(hActiveThread), WM_NULL, 0, 0);
if(ResumeThread(hActiveThread) == -1)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error resuming thread"));
return false;
}
return true;
}
bool cbDebugContinue(int argc, char* argv[])
{
if(argc < 2)
{
dbgsetcontinuestatus(DBG_CONTINUE);
dputs(QT_TRANSLATE_NOOP("DBG", "Exception will be swallowed"));
}
else
{
dbgsetcontinuestatus(DBG_EXCEPTION_NOT_HANDLED);
dputs(QT_TRANSLATE_NOOP("DBG", "Exception will be thrown in the program"));
}
return true;
}
bool cbDebugStepInto(int argc, char* argv[])
{
duint steprepeat = 1;
if(argc > 1 && !valfromstring(argv[1], &steprepeat, false))
return false;
if(!steprepeat) //nothing to be done
return true;
if(skipInt3Stepping(1, argv) && !--steprepeat)
return true;
StepIntoWow64(cbStep);
dbgsetsteprepeat(true, steprepeat);
return cbDebugRunInternal(1, argv, steprepeat == 1 ? history_record : history_clear);
}
bool cbDebugeStepInto(int argc, char* argv[])
{
dbgsetskipexceptions(true);
return cbDebugStepInto(argc, argv);
}
bool cbDebugseStepInto(int argc, char* argv[])
{
cbDebugContinue(argc, argv);
return cbDebugStepInto(argc, argv);
}
static bool IsRepeated(const Zydis & zydis)
{
// https://www.felixcloutier.com/x86/rep:repe:repz:repne:repnz
// TODO: allow extracting the affected range
switch(zydis.GetId())
{
// INS
case ZYDIS_MNEMONIC_INSB:
case ZYDIS_MNEMONIC_INSW:
case ZYDIS_MNEMONIC_INSD:
// OUTS
case ZYDIS_MNEMONIC_OUTSB:
case ZYDIS_MNEMONIC_OUTSW:
case ZYDIS_MNEMONIC_OUTSD:
// MOVS
case ZYDIS_MNEMONIC_MOVSB:
case ZYDIS_MNEMONIC_MOVSW:
case ZYDIS_MNEMONIC_MOVSD:
case ZYDIS_MNEMONIC_MOVSQ:
// LODS
case ZYDIS_MNEMONIC_LODSB:
case ZYDIS_MNEMONIC_LODSW:
case ZYDIS_MNEMONIC_LODSD:
case ZYDIS_MNEMONIC_LODSQ:
// STOS
case ZYDIS_MNEMONIC_STOSB:
case ZYDIS_MNEMONIC_STOSW:
case ZYDIS_MNEMONIC_STOSD:
case ZYDIS_MNEMONIC_STOSQ:
// CMPS
case ZYDIS_MNEMONIC_CMPSB:
case ZYDIS_MNEMONIC_CMPSW:
case ZYDIS_MNEMONIC_CMPSD:
case ZYDIS_MNEMONIC_CMPSQ:
// SCAS
case ZYDIS_MNEMONIC_SCASB:
case ZYDIS_MNEMONIC_SCASW:
case ZYDIS_MNEMONIC_SCASD:
case ZYDIS_MNEMONIC_SCASQ:
return (zydis.GetInstr()->attributes & (ZYDIS_ATTRIB_HAS_REP | ZYDIS_ATTRIB_HAS_REPZ | ZYDIS_ATTRIB_HAS_REPNZ)) != 0;
}
return false;
}
bool cbDebugStepOver(int argc, char* argv[])
{
duint steprepeat = 1;
if(argc > 1 && !valfromstring(argv[1], &steprepeat, false))
return false;
if(!steprepeat) //nothing to be done
return true;
if(skipInt3Stepping(1, argv) && !--steprepeat)
return true;
auto history = history_clear;
if(steprepeat == 1)
{
Zydis zydis;
disasm(zydis, GetContextDataEx(hActiveThread, UE_CIP));
if(!zydis.IsBranchType(Zydis::BTCallSem) && !IsRepeated(zydis))
history = history_record;
}
StepOverWrapper(cbStep);
dbgsetsteprepeat(false, steprepeat);
return cbDebugRunInternal(1, argv, history);
}
bool cbDebugeStepOver(int argc, char* argv[])
{
dbgsetskipexceptions(true);
return cbDebugStepOver(1, argv);
}
bool cbDebugseStepOver(int argc, char* argv[])
{
cbDebugContinue(argc, argv);
return cbDebugStepOver(argc, argv);
}
bool cbDebugStepOut(int argc, char* argv[])
{
duint steprepeat = 1;
if(argc > 1 && !valfromstring(argv[1], &steprepeat, false))
return false;
if(!steprepeat) //nothing to be done
return true;
gRtrPreviousCSP = GetContextDataEx(hActiveThread, UE_CSP);
StepOverWrapper(cbRtrStep);
dbgsetsteprepeat(false, steprepeat);
return cbDebugRunInternal(1, argv, history_clear);
}
bool cbDebugeStepOut(int argc, char* argv[])
{
dbgsetskipexceptions(true);
return cbDebugStepOut(argc, argv);
}
bool cbDebugSkip(int argc, char* argv[])
{
duint skiprepeat = 1;
if(argc > 1 && !valfromstring(argv[1], &skiprepeat, false))
return false;
// Because an int3 causes CIP to be advanced we start disassembling from there
duint cip;
if(isInt3Exception())
cip = (duint)getLastExceptionInfo().ExceptionRecord.ExceptionAddress;
else
cip = GetContextDataEx(hActiveThread, UE_CIP);
dbgsetcontinuestatus(DBG_CONTINUE); //swallow the exception
BASIC_INSTRUCTION_INFO basicinfo;
while(skiprepeat--)
{
disasmfast(cip, &basicinfo);
cip += basicinfo.size;
dbgtraceexecute(cip);
}
SetContextDataEx(hActiveThread, UE_CIP, cip);
DebugUpdateGuiAsync(cip, false); //update GUI
return true;
}
bool cbInstrInstrUndo(int argc, char* argv[])
{
HistoryRestore();
GuiUpdateAllViews();
return true;
}
bool cbDebugStepUserInto(int argc, char* argv[])
{
StepIntoUser(cbStep);
return cbDebugRunInternal(1, argv, history_clear);
}
bool cbDebugStepSystemInto(int argc, char* argv[])
{
StepIntoSystem(cbStep);
return cbDebugRunInternal(1, argv, history_clear);
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-debug-control.h | #pragma once
#include "command.h"
enum HistoryAction
{
history_clear,
history_record,
};
bool cbDebugRunInternal(int argc, char* argv[], HistoryAction history);
bool cbDebugInit(int argc, char* argv[]);
bool cbDebugStop(int argc, char* argv[]);
bool cbDebugAttach(int argc, char* argv[]);
bool cbDebugDetach(int argc, char* argv[]);
bool cbDebugRun(int argc, char* argv[]);
bool cbDebugErun(int argc, char* argv[]);
bool cbDebugSerun(int argc, char* argv[]);
bool cbDebugPause(int argc, char* argv[]);
bool cbDebugContinue(int argc, char* argv[]);
bool cbDebugStepInto(int argc, char* argv[]);
bool cbDebugeStepInto(int argc, char* argv[]);
bool cbDebugseStepInto(int argc, char* argv[]);
bool cbDebugStepOver(int argc, char* argv[]);
bool cbDebugeStepOver(int argc, char* argv[]);
bool cbDebugseStepOver(int argc, char* argv[]);
bool cbDebugStepOut(int argc, char* argv[]);
bool cbDebugeStepOut(int argc, char* argv[]);
bool cbDebugSkip(int argc, char* argv[]);
bool cbInstrInstrUndo(int argc, char* argv[]);
bool cbDebugStepUserInto(int argc, char* argv[]);
bool cbDebugStepSystemInto(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-general-purpose.cpp | #include "cmd-general-purpose.h"
#include "value.h"
#include "memory.h"
#include "variable.h"
#include "_scriptapi_stack.h"
#include "debugger.h"
#include <intrin.h>
static bool ReadWriteVariable(const char* varname, const std::function<bool(duint*, int)> & callback)
{
duint set_value = 0;
bool isvar;
int varsize;
if(!valfromstring(varname, &set_value, true, true, &varsize, &isvar))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid variable \"%s\"\n"), varname);
return false;
}
bool retVal = callback(&set_value, varsize);
if(retVal != true)
return retVal;
duint temp = 0;
valfromstring(varname, &temp, true, true, 0, nullptr, 0); //there is no return check on this because the destination might not exist yet
if(!isvar)
isvar = vargettype(varname, 0);
if(!isvar || !valtostring(varname, set_value, true))
{
duint value;
if(valfromstring(varname, &value)) //if the var is a value already it's an invalid destination
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid variable \"%s\"\n"), varname);
return false;
}
varnew(varname, set_value, VAR_USER);
}
return true;
}
bool cbInstrInc(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
return cmddirectexec(StringUtils::sprintf("%s++", argv[1]).c_str());
}
bool cbInstrDec(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
return cmddirectexec(StringUtils::sprintf("%s--", argv[1]).c_str());
}
bool cbInstrAdd(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
return cmddirectexec(StringUtils::sprintf("%s+=%s", argv[1], argv[2]).c_str());
}
bool cbInstrSub(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
return cmddirectexec(StringUtils::sprintf("%s-=%s", argv[1], argv[2]).c_str());
}
bool cbInstrMul(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
return cmddirectexec(StringUtils::sprintf("%s*=%s", argv[1], argv[2]).c_str());
}
bool cbInstrDiv(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
return cmddirectexec(StringUtils::sprintf("%s/=%s", argv[1], argv[2]).c_str());
}
bool cbInstrAnd(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
return cmddirectexec(StringUtils::sprintf("%s&=%s", argv[1], argv[2]).c_str());
}
bool cbInstrOr(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
return cmddirectexec(StringUtils::sprintf("%s|=%s", argv[1], argv[2]).c_str());
}
bool cbInstrXor(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
return cmddirectexec(StringUtils::sprintf("%s^=%s", argv[1], argv[2]).c_str());
}
bool cbInstrNeg(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
return cmddirectexec(StringUtils::sprintf("%s=-%s", argv[1], argv[1]).c_str());
}
bool cbInstrNot(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
return cmddirectexec(StringUtils::sprintf("%s=~%s", argv[1], argv[1]).c_str());
}
bool cbInstrBswap(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
return ReadWriteVariable(argv[1], [](duint * value, int size)
{
if(size == 2)
*value = _byteswap_ushort((uint16) * value);
else if(size == 4)
*value = _byteswap_ulong((uint32) * value);
#ifdef _WIN64
else if(size == 8)
*value = _byteswap_uint64(*value);
#endif //_WIN64
else if(size != 1)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Variable size not supported."));
return false;
}
return true;
});
}
bool cbInstrRol(int argc, char* argv[])
{
duint value2;
if(IsArgumentsLessThan(argc, 3) || !valfromstring(argv[2], &value2, false))
return false;
return ReadWriteVariable(argv[1], [value2](duint * value, int size)
{
if(size == 1)
*value = _rotl8((uint8_t) * value, value2 % 8);
else if(size == 2)
*value = _rotl16((uint16) * value, value2 % 16);
else if(size == 4)
*value = _rotl((uint32) * value, value2 % 32);
#ifdef _WIN64
else if(size == 8)
*value = _rotl64(*value, value2 % 64);
#endif //_WIN64
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Variable size not supported."));
return false;
}
return true;
});
}
bool cbInstrRor(int argc, char* argv[])
{
duint value2;
if(IsArgumentsLessThan(argc, 3) || !valfromstring(argv[2], &value2, false))
return false;
return ReadWriteVariable(argv[1], [value2](duint * value, int size)
{
if(size == 1)
*value = _rotr8((uint8_t) * value, value2 % 8);
else if(size == 2)
*value = _rotr16((uint16) * value, value2 % 16);
else if(size == 4)
*value = _rotr((uint32) * value, value2 % 32);
#ifdef _WIN64
else if(size == 8)
*value = _rotr64(*value, value2 % 64);
#endif //_WIN64
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Variable size not supported."));
return false;
}
return true;
});
}
bool cbInstrShl(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
//SHL and SAL have the same semantics
return cmddirectexec(StringUtils::sprintf("%s<<=%s", argv[1], argv[2]).c_str());
}
bool cbInstrShr(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
auto oldType = valuesignedcalc();
valuesetsignedcalc(false); //SHR is unsigned
auto result = cmddirectexec(StringUtils::sprintf("%s>>=%s", argv[1], argv[2]).c_str());
valuesetsignedcalc(oldType);
return result;
}
bool cbInstrSar(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
auto oldType = valuesignedcalc();
valuesetsignedcalc(true); //SAR is signed
auto result = cmddirectexec(StringUtils::sprintf("%s>>=%s", argv[1], argv[2]).c_str());
valuesetsignedcalc(oldType);
return result;
}
bool cbInstrPush(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint value;
if(!valfromstring(argv[1], &value))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid argument \"%s\"!\n"), argv[1]);
return false;
}
Script::Stack::Push(value);
duint csp = GetContextDataEx(hActiveThread, UE_CSP);
DebugUpdateStack(csp, csp);
GuiUpdateRegisterView();
return true;
}
bool cbInstrPop(int argc, char* argv[])
{
duint value = Script::Stack::Pop();
duint csp = GetContextDataEx(hActiveThread, UE_CSP);
DebugUpdateStack(csp, csp);
GuiUpdateRegisterView();
if(argc > 1)
{
if(!valtostring(argv[1], value, false))
return false;
}
return true;
}
bool cbInstrTest(int argc, char* argv[])
{
//TODO: test
if(IsArgumentsLessThan(argc, 3))
return false;
duint arg1 = 0;
if(!valfromstring(argv[1], &arg1, false))
return false;
duint arg2 = 0;
if(!valfromstring(argv[2], &arg2, false))
return false;
duint ezflag;
duint bsflag = 0;
if(!(arg1 & arg2))
ezflag = 1;
else
ezflag = 0;
varset("$_EZ_FLAG", ezflag, true);
varset("$_BS_FLAG", bsflag, true);
//dprintf(QT_TRANSLATE_NOOP("DBG", "$_EZ_FLAG=%d, $_BS_FLAG=%d\n"), ezflag, bsflag);
return true;
}
bool cbInstrCmp(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
duint arg1 = 0;
if(!valfromstring(argv[1], &arg1, false))
return false;
duint arg2 = 0;
if(!valfromstring(argv[2], &arg2, false))
return false;
duint ezflag;
duint bsflag;
if(arg1 == arg2)
ezflag = 1;
else
ezflag = 0;
if(valuesignedcalc()) //signed comparision
{
if((dsint)arg1 < (dsint)arg2)
bsflag = 0;
else
bsflag = 1;
}
else //unsigned comparision
{
if(arg1 > arg2)
bsflag = 1;
else
bsflag = 0;
}
varset("$_EZ_FLAG", ezflag, true);
varset("$_BS_FLAG", bsflag, true);
//dprintf(QT_TRANSLATE_NOOP("DBG", "$_EZ_FLAG=%d, $_BS_FLAG=%d\n"), ezflag, bsflag);
return true;
}
bool cbInstrMov(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
String srcText = argv[2];
if(srcText[0] == '#' && srcText[srcText.length() - 1] == '#') //handle mov addr, #DATA#
{
//do some checks on the data
String dataText = srcText.substr(1, srcText.length() - 2);
std::vector<unsigned char> data;
if(!StringUtils::FromCompressedHex(dataText, data))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid hex string \"%s\"\n"), dataText.c_str());
return false;
}
//Check the destination
duint dest;
if(!valfromstring(argv[1], &dest) || !MemIsValidReadPtr(dest))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid destination \"%s\"\n"), argv[1]);
return false;
}
//Move data to destination
if(!MemPatch(dest, data.data(), data.size()))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to write to %p\n"), dest);
return false;
}
GuiUpdateAllViews(); //refresh disassembly/dump/etc
return true;
}
else
{
duint set_value = 0;
if(!valfromstring(srcText.c_str(), &set_value))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid src \"%s\"\n"), argv[2]);
return false;
}
bool isvar = false;
duint temp = 0;
valfromstring(argv[1], &temp, true, true, 0, &isvar, 0); //there is no return check on this because the destination might not exist yet
if(!isvar)
isvar = vargettype(argv[1], 0);
if(!isvar || !valtostring(argv[1], set_value, true))
{
duint value;
if(valfromstring(argv[1], &value)) //if the var is a value already it's an invalid destination
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid dest \"%s\"\n"), argv[1]);
return false;
}
varnew(argv[1], set_value, VAR_USER);
}
}
return true;
}
bool cbInstrMovdqu(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
String dstText = argv[1];
String srcText = argv[2];
duint address = 0;
DWORD registerindex = 0;
if(srcText[0] == '[' && srcText[srcText.length() - 1] == ']' && _memicmp(dstText.c_str(), "xmm", 3) == 0)
{
char newValue[16];
// movdqu xmm0, [address]
dstText = dstText.substr(3);
srcText = srcText.substr(1, srcText.size() - 2);
DWORD registerindex;
bool found = true;
registerindex = atoi(dstText.c_str());
if(registerindex < ArchValue(8, 16))
{
registerindex += UE_XMM0;
}
else
{
goto InvalidDest;
}
if(!valfromstring(srcText.c_str(), &address))
{
goto InvalidSrc;
}
if(!MemRead(address, newValue, 16))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to read (all) memory..."));
return false;
}
SetContextDataEx(hActiveThread, registerindex, (ULONG_PTR)newValue);
GuiUpdateAllViews(); //refresh disassembly/dump/etc
return true;
}
else if(dstText[0] == '[' && dstText[dstText.length() - 1] == ']' && _memicmp(srcText.c_str(), "xmm", 3) == 0)
{
// movdqu [address], xmm0
srcText = srcText.substr(3);
dstText = dstText.substr(1, dstText.size() - 2);
DWORD registerindex;
bool found = true;
registerindex = atoi(srcText.c_str());
if(registerindex >= ArchValue(8, 16))
{
goto InvalidSrc;
}
if(!valfromstring(dstText.c_str(), &address) || !MemIsValidReadPtr(address))
{
goto InvalidDest;
}
REGDUMP registers;
if(!DbgGetRegDumpEx(®isters, sizeof(registers)))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to read register context..."));
return false;
}
if(!MemWrite(address, ®isters.regcontext.XmmRegisters[registerindex], 16))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to write to %p\n"), address);
return false;
}
GuiUpdateAllViews(); //refresh disassembly/dump/etc
return true;
}
else if(_memicmp(srcText.c_str(), "xmm", 3) == 0 && _memicmp(dstText.c_str(), "xmm", 3) == 0)
{
// movdqu xmm0, xmm1
srcText = srcText.substr(3);
dstText = dstText.substr(3);
DWORD registerindex[2];
bool found = true;
registerindex[0] = atoi(srcText.c_str());
if(registerindex[0] >= ArchValue(8, 16))
{
goto InvalidSrc;
}
registerindex[1] = atoi(dstText.c_str());
if(registerindex[1] < ArchValue(8, 16))
{
registerindex[1] += UE_XMM0;
}
else
{
goto InvalidDest;
}
REGDUMP registers;
if(!DbgGetRegDumpEx(®isters, sizeof(registers)))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to read register context..."));
return false;
}
SetContextDataEx(hActiveThread, registerindex[1], (ULONG_PTR)®isters.regcontext.XmmRegisters[registerindex[0]]);
GuiUpdateAllViews(); //refresh disassembly/dump/etc
return true;
}
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Usage: movdqu xmm0, [address] / movdqu [address], xmm0 / movdqu xmm0, xmm1"));
return false;
}
InvalidSrc:
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid src \"%s\"\n"), argv[2]);
return false;
InvalidDest:
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid dest \"%s\"\n"), argv[1]);
return false;
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-general-purpose.h | #pragma once
#include "command.h"
bool cbInstrInc(int argc, char* argv[]);
bool cbInstrDec(int argc, char* argv[]);
bool cbInstrAdd(int argc, char* argv[]);
bool cbInstrSub(int argc, char* argv[]);
bool cbInstrMul(int argc, char* argv[]);
bool cbInstrDiv(int argc, char* argv[]);
bool cbInstrAnd(int argc, char* argv[]);
bool cbInstrOr(int argc, char* argv[]);
bool cbInstrXor(int argc, char* argv[]);
bool cbInstrNeg(int argc, char* argv[]);
bool cbInstrNot(int argc, char* argv[]);
bool cbInstrBswap(int argc, char* argv[]);
bool cbInstrRol(int argc, char* argv[]);
bool cbInstrRor(int argc, char* argv[]);
bool cbInstrShl(int argc, char* argv[]);
bool cbInstrShr(int argc, char* argv[]);
bool cbInstrSar(int argc, char* argv[]);
bool cbInstrPush(int argc, char* argv[]);
bool cbInstrPop(int argc, char* argv[]);
bool cbInstrTest(int argc, char* argv[]);
bool cbInstrCmp(int argc, char* argv[]);
bool cbInstrMov(int argc, char* argv[]);
bool cbInstrMovdqu(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-gui.cpp | #include "cmd-gui.h"
#include "debugger.h"
#include "console.h"
#include "memory.h"
#include "recursiveanalysis.h"
#include "function.h"
#include "stringformat.h"
#include "value.h"
#include "variable.h"
bool cbDebugDisasm(int argc, char* argv[])
{
duint addr = 0;
if(argc > 1)
{
if(!valfromstring(argv[1], &addr))
addr = GetContextDataEx(hActiveThread, UE_CIP);
}
else
{
addr = GetContextDataEx(hActiveThread, UE_CIP);
}
DebugUpdateGui(addr, false);
GuiShowCpu();
GuiFocusView(GUI_DISASSEMBLY);
return true;
}
bool cbDebugDump(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address \"%s\"!\n"), argv[1]);
return false;
}
if(argc > 2)
{
duint index = 0;
if(!valfromstring(argv[2], &index))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address \"%s\"!\n"), argv[2]);
return false;
}
GuiDumpAtN(addr, int(index));
}
else
{
ACTIVEVIEW activeView;
GuiGetActiveView(&activeView);
int dumpIndex;
if(sscanf_s(activeView.title, "Dump %d", &dumpIndex) == 1)
GuiDumpAtN(addr, dumpIndex);
else
GuiDumpAt(addr);
}
GuiShowCpu();
GuiFocusView(GUI_DUMP);
return true;
}
bool cbDebugStackDump(int argc, char* argv[])
{
duint addr = 0;
if(argc < 2)
addr = GetContextDataEx(hActiveThread, UE_CSP);
else if(!valfromstring(argv[1], &addr))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address \"%s\"!\n"), argv[1]);
return false;
}
duint csp = GetContextDataEx(hActiveThread, UE_CSP);
duint size = 0;
duint base = MemFindBaseAddr(csp, &size);
if(base && addr >= base && addr < (base + size))
DebugUpdateStack(addr, csp, true);
else
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid stack address!"));
GuiShowCpu();
GuiFocusView(GUI_STACK);
return true;
}
bool cbDebugMemmapdump(int argc, char* argv[])
{
if(argc < 2)
return false;
duint addr;
if(!valfromstring(argv[1], &addr, false) || !MemIsValidReadPtr(addr, true))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address \"%s\"!\n"), argv[1]);
return false;
}
GuiSelectInMemoryMap(addr);
GuiFocusView(GUI_MEMMAP);
return true;
}
bool cbInstrGraph(int argc, char* argv[])
{
auto options = argc > 2 ? argv[2] : "";
auto force = !!strstr(options, "force");
auto silent = !!strstr(options, "silent");
duint entry;
if(argc < 2 || !valfromstring(argv[1], &entry))
entry = GetContextDataEx(hActiveThread, UE_CIP);
duint start, size, sel = entry;
if(FunctionGet(entry, &start))
entry = start;
auto base = MemFindBaseAddr(entry, &size);
if(!base || !MemIsValidReadPtr(entry))
{
if(!silent)
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address %p!\n"), entry);
return false;
}
auto curEntry = GuiGraphAt(sel);
if(curEntry)
entry = curEntry;
if(!curEntry || force)
{
auto modbase = ModBaseFromAddr(base);
if(modbase)
base = modbase, size = ModSizeFromAddr(modbase);
RecursiveAnalysis analysis(base, size, entry, true);
analysis.Analyse();
auto graph = analysis.GetFunctionGraph(entry);
if(!graph)
{
if(!silent)
dputs(QT_TRANSLATE_NOOP("DBG", "No graph generated..."));
return false;
}
auto graphList = graph->ToGraphList();
if(!GuiLoadGraph(&graphList, sel))
return false;
}
GuiUpdateAllViews();
if(!silent)
GuiFocusView(GUI_GRAPH);
return true;
}
bool cbInstrEnableGuiUpdate(int argc, char* argv[])
{
if(GuiIsUpdateDisabled())
GuiUpdateEnable(false);
duint value;
//argv[1]=="1" = update GUI
if(argc > 1 && valfromstring(argv[1], &value) && value == 1)
GuiUpdateAllViews();
return true;
}
bool cbInstrDisableGuiUpdate(int argc, char* argv[])
{
if(!GuiIsUpdateDisabled())
GuiUpdateDisable();
return true;
}
bool cbDebugSetfreezestack(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
bool freeze = *argv[1] != '0';
dbgsetfreezestack(freeze);
if(freeze)
dputs(QT_TRANSLATE_NOOP("DBG", "Stack is now frozen\n"));
else
dputs(QT_TRANSLATE_NOOP("DBG", "Stack is now unfrozen\n"));
return true;
}
static bool bRefinit = false;
bool cbInstrRefinit(int argc, char* argv[])
{
auto title = argc > 1 ? stringformatinline(argv[1]) : GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Script"));
GuiReferenceInitialize(title.c_str());
GuiReferenceAddColumn(sizeof(duint) * 2, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address")));
GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Data")));
GuiReferenceSetRowCount(0);
GuiReferenceReloadData();
bRefinit = true;
return true;
}
bool cbInstrRefadd(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return false;
if(!bRefinit)
cbInstrRefinit(argc, argv);
int index = GuiReferenceGetRowCount();
GuiReferenceSetRowCount(index + 1);
char addr_text[32] = "";
sprintf_s(addr_text, "%p", addr);
GuiReferenceSetCellContent(index, 0, addr_text);
GuiReferenceSetCellContent(index, 1, stringformatinline(argv[2]).c_str());
GuiReferenceReloadData();
return true;
}
bool cbInstrRefGet(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint row;
if(!valfromstring(argv[1], &row, false))
return false;
auto content = GuiReferenceGetCellContent(int(row), 0);
duint addr = 0;
valfromstring(content, &addr, false);
varset("$result", addr, false);
BridgeFree(content);
return true;
}
bool cbInstrEnableLog(int argc, char* argv[])
{
GuiEnableLog();
return true;
}
bool cbInstrDisableLog(int argc, char* argv[])
{
GuiDisableLog();
return true;
}
bool cbInstrAddFavTool(int argc, char* argv[])
{
// filename, description
if(IsArgumentsLessThan(argc, 2))
return false;
if(argc == 2)
GuiAddFavouriteTool(argv[1], nullptr);
else
GuiAddFavouriteTool(argv[1], argv[2]);
return true;
}
bool cbInstrAddFavCmd(int argc, char* argv[])
{
// command, shortcut
if(IsArgumentsLessThan(argc, 2))
return false;
if(argc == 2)
GuiAddFavouriteCommand(argv[1], nullptr);
else
GuiAddFavouriteCommand(argv[1], argv[2]);
return true;
}
bool cbInstrSetFavToolShortcut(int argc, char* argv[])
{
// filename, shortcut
if(IsArgumentsLessThan(argc, 3))
return false;
GuiSetFavouriteToolShortcut(argv[1], argv[2]);
return true;
}
bool cbInstrFoldDisassembly(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
duint start, length;
if(!valfromstring(argv[1], &start))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid argument 1 : %s\n"), argv[1]);
return false;
}
if(!valfromstring(argv[2], &length))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid argument 2 : %s\n"), argv[2]);
return false;
}
GuiFoldDisassembly(start, length);
return true;
}
bool cbDebugUpdateTitle(int argc, char* argv[])
{
duint addr = 0;
if(argc > 1)
{
if(!valfromstring(argv[1], &addr))
addr = GetContextDataEx(hActiveThread, UE_CIP);
}
else
{
addr = GetContextDataEx(hActiveThread, UE_CIP);
}
DebugUpdateTitleAsync(addr, false);
return true;
}
bool cbShowReferences(int argc, char* argv[])
{
GuiShowReferences();
return true;
}
bool cbSymbolsFollow(int argc, char* argv[])
{
if(argc < 2)
return false;
duint addr;
if(!valfromstring(argv[1], &addr, false) || !MemIsValidReadPtr(addr, true))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address \"%s\"!\n"), argv[1]);
return false;
}
duint base = ModBaseFromAddr(addr);
if(!base)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Address \"%s\" doesn't belong to any module!\n"), argv[1]);
return false;
}
GuiSelectInSymbolsTab(base);
GuiFocusView(GUI_SYMMOD);
return true;
}
bool cbGotoTrace(int argc, char* argv[])
{
duint index = 0;
if(IsArgumentsLessThan(argc, 2) || !valfromstring(argv[1], &index, false))
return false;
GuiGotoTrace(index);
GuiShowTrace();
return true;
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-gui.h | #pragma once
#include "command.h"
bool cbDebugDisasm(int argc, char* argv[]);
bool cbDebugDump(int argc, char* argv[]);
bool cbDebugStackDump(int argc, char* argv[]);
bool cbDebugMemmapdump(int argc, char* argv[]);
bool cbInstrGraph(int argc, char* argv[]);
bool cbInstrEnableGuiUpdate(int argc, char* argv[]);
bool cbInstrDisableGuiUpdate(int argc, char* argv[]);
bool cbDebugSetfreezestack(int argc, char* argv[]);
bool cbInstrRefinit(int argc, char* argv[]);
bool cbInstrRefadd(int argc, char* argv[]);
bool cbInstrRefGet(int argc, char* argv[]);
bool cbInstrEnableLog(int argc, char* argv[]);
bool cbInstrDisableLog(int argc, char* argv[]);
bool cbInstrAddFavTool(int argc, char* argv[]);
bool cbInstrAddFavCmd(int argc, char* argv[]);
bool cbInstrSetFavToolShortcut(int argc, char* argv[]);
bool cbInstrFoldDisassembly(int argc, char* argv[]);
bool cbDebugUpdateTitle(int argc, char* argv[]);
bool cbShowReferences(int argc, char* argv[]);
bool cbSymbolsFollow(int argc, char* argv[]);
bool cbGotoTrace(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-memory-operations.cpp | #include "cmd-memory-operations.h"
#include "console.h"
#include "debugger.h"
#include "memory.h"
#include "variable.h"
#include "filehelper.h"
#include "value.h"
#include "stringformat.h"
#include "comment.h"
bool cbDebugAlloc(int argc, char* argv[])
{
duint size = 0x1000, addr = 0;
if(argc > 1)
if(!valfromstring(argv[1], &size, false))
return false;
if(argc > 2)
if(!valfromstring(argv[2], &addr, false))
return false;
duint mem = (duint)MemAllocRemote(addr, size);
if(!mem)
dputs(QT_TRANSLATE_NOOP("DBG", "VirtualAllocEx failed"));
else
dprintf("%p\n", mem);
if(mem)
varset("$lastalloc", mem, true);
if(mem)
CommentSet(mem, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "User-allocated memory")), true);
//update memory map
MemUpdateMap();
GuiUpdateMemoryView();
varset("$res", mem, false);
return true;
}
bool cbDebugFree(int argc, char* argv[])
{
duint lastalloc;
varget("$lastalloc", &lastalloc, 0, 0);
duint addr = lastalloc;
if(argc > 1)
{
if(!valfromstring(argv[1], &addr, false))
return false;
}
else if(!lastalloc)
{
dputs(QT_TRANSLATE_NOOP("DBG", "$lastalloc is zero, provide a page address"));
return false;
}
if(addr == lastalloc)
varset("$lastalloc", (duint)0, true);
bool ok = !!VirtualFreeEx(fdProcessInfo->hProcess, (void*)addr, 0, MEM_RELEASE);
if(!ok)
dputs(QT_TRANSLATE_NOOP("DBG", "VirtualFreeEx failed"));
//update memory map
MemUpdateMap();
GuiUpdateMemoryView();
varset("$res", ok, false);
return true;
}
bool cbDebugMemset(int argc, char* argv[])
{
duint addr;
duint value;
duint size;
if(IsArgumentsLessThan(argc, 3))
return false;
if(!valfromstring(argv[1], &addr, false) || !valfromstring(argv[2], &value, false))
return false;
if(argc > 3)
{
if(!valfromstring(argv[3], &size, false))
return false;
}
else
{
duint base = MemFindBaseAddr(addr, &size, true);
if(!base)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid address specified"));
return false;
}
duint diff = addr - base;
addr = base + diff;
size -= diff;
}
BYTE fi = value & 0xFF;
if(!Fill((void*)addr, size & 0xFFFFFFFF, &fi))
dputs(QT_TRANSLATE_NOOP("DBG", "Memset failed"));
else
dprintf(QT_TRANSLATE_NOOP("DBG", "Memory %p (size: %.8X) set to %.2X\n"), addr, DWORD(size & 0xFFFFFFFF), BYTE(value & 0xFF));
return true;
}
bool cbDebugMemcpy(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 4))
return false;
duint dst = 0, src = 0, size = 0;
if(!valfromstring(argv[1], &dst, false) || !valfromstring(argv[2], &src, false) || !valfromstring(argv[3], &size, false))
return false;
duint totalNumberOfBytesWritten = 0;
std::vector<uint8_t> buffer;
buffer.resize(PAGE_SIZE); //copy a page at a time
for(size_t i = 0; i < size; i += buffer.size())
{
duint NumberOfBytesRead = 0;
auto readOk = MemRead(src + i, buffer.data(), min(buffer.size(), size - i), &NumberOfBytesRead);
duint NumberOfBytesWritten = 0;
auto writeOk = MemWrite(dst + i, buffer.data(), NumberOfBytesRead, &NumberOfBytesWritten);
totalNumberOfBytesWritten += NumberOfBytesWritten;
if(!readOk || !writeOk)
break;
}
GuiUpdateAllViews();
varset("$result", totalNumberOfBytesWritten, false);
return true;
}
bool cbDebugGetPageRights(int argc, char* argv[])
{
duint addr = 0;
char rights[RIGHTS_STRING_SIZE];
if(argc != 2 || !valfromstring(argv[1], &addr))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: using an address as arg1\n"));
return false;
}
if(!MemGetPageRights(addr, rights))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting rights of page: %s\n"), argv[1]);
return false;
}
dprintf(QT_TRANSLATE_NOOP("DBG", "Page: %p, Rights: %s\n"), addr, rights);
return true;
}
bool cbDebugSetPageRights(int argc, char* argv[])
{
duint addr = 0;
char rights[RIGHTS_STRING_SIZE];
if(argc < 3 || !valfromstring(argv[1], &addr))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: Using an address as arg1 and as arg2: Execute, ExecuteRead, ExecuteReadWrite, ExecuteWriteCopy, NoAccess, ReadOnly, ReadWrite, WriteCopy. You can add a G at first for add PAGE GUARD, example: GReadOnly\n"));
return false;
}
if(!MemSetPageRights(addr, argv[2]))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error: Set rights of %p with Rights: %s\n"), addr, argv[2]);
return false;
}
if(!MemGetPageRights(addr, rights))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting rights of page: %s\n"), argv[1]);
return false;
}
//update the memory map
MemUpdateMap();
GuiUpdateMemoryView();
dprintf(QT_TRANSLATE_NOOP("DBG", "New rights of %p: %s\n"), addr, rights);
return true;
}
bool cbInstrSavedata(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 4))
return false;
duint addr, size;
if(!valfromstring(argv[2], &addr, false) || !valfromstring(argv[3], &size, false))
return false;
bool success = true;
Memory<unsigned char*> data(size);
if(!MemReadDumb(addr, data(), data.size()))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to read (all) memory..."));
success = false;
}
String name = stringformatinline(argv[1]);
if(name == ":memdump:")
name = StringUtils::sprintf("%s\\memdumps\\memdump_%X_%p_%x.bin", szUserDir, fdProcessInfo->dwProcessId, addr, size);
if(!FileHelper::WriteAllData(name, data(), data.size()))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to write file..."));
return false;
}
#ifdef _WIN64
dprintf(QT_TRANSLATE_NOOP("DBG", "%p[%llX] written to \"%s\" !\n"), addr, size, name.c_str());
#else //x86
dprintf(QT_TRANSLATE_NOOP("DBG", "%p[%X] written to \"%s\" !\n"), addr, size, name.c_str());
#endif
return success;
}
bool cbInstrMinidump(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
if(DbgIsRunning())
{
dputs(QT_TRANSLATE_NOOP("DBG", "Cannot dump while running..."));
return false;
}
HANDLE hFile = CreateFileA(argv[1], GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
if(hFile == INVALID_HANDLE_VALUE)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Could not open file!"));
return false;
}
// Disable all software breakpoints
std::vector<BREAKPOINT> disabledBreakpoints;
{
std::vector<BREAKPOINT> bplist;
BpGetList(&bplist);
for(const auto & bp : bplist)
{
if(bp.type == BPNORMAL && bp.active && DeleteBPX(bp.addr))
disabledBreakpoints.push_back(bp);
}
}
CONTEXT context = {};
context.ContextFlags = CONTEXT_ALL;
GetThreadContext(DbgGetThreadHandle(), &context);
context.EFlags &= ~0x100; // remove trap flag
EXCEPTION_POINTERS exceptionPointers = {};
exceptionPointers.ContextRecord = &context;
exceptionPointers.ExceptionRecord = &getLastExceptionInfo().ExceptionRecord;
if(exceptionPointers.ExceptionRecord->ExceptionCode == 0)
{
auto & exceptionRecord = *exceptionPointers.ExceptionRecord;
exceptionRecord.ExceptionCode = 0xFFFFFFFF;
#ifdef _WIN64
exceptionRecord.ExceptionAddress = PVOID(context.Rip);
#else
exceptionRecord.ExceptionAddress = PVOID(context.Eip);
#endif // _WIN64
}
MINIDUMP_EXCEPTION_INFORMATION exceptionInfo = {};
exceptionInfo.ThreadId = DbgGetThreadId();
exceptionInfo.ExceptionPointers = &exceptionPointers;
exceptionInfo.ClientPointers = FALSE;
auto dumpType = MINIDUMP_TYPE(MiniDumpWithFullMemory | MiniDumpWithFullMemoryInfo | MiniDumpIgnoreInaccessibleMemory | MiniDumpWithHandleData);
auto dumpSaved = !!MiniDumpWriteDump(DbgGetProcessHandle(), DbgGetProcessId(), hFile, dumpType, &exceptionInfo, nullptr, nullptr);
auto lastError = GetLastError() & 0xFFFF; // HRESULT_FROM_WIN32
// Re-enable all breakpoints that were previously disabled
for(const auto & bp : disabledBreakpoints)
{
SetBPX(bp.addr, bp.titantype, cbUserBreakpoint);
}
if(dumpSaved)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Dump saved!"));
}
else
{
String error = stringformatinline(StringUtils::sprintf("{winerror@%x}", lastError));
dprintf(QT_TRANSLATE_NOOP("DBG", "MiniDumpWriteDump failed. GetLastError() = %s.\n"), error.c_str());
}
CloseHandle(hFile);
return true;
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-memory-operations.h | #pragma once
#include "command.h"
bool cbDebugAlloc(int argc, char* argv[]);
bool cbDebugFree(int argc, char* argv[]);
bool cbDebugMemset(int argc, char* argv[]);
bool cbDebugMemcpy(int argc, char* argv[]);
bool cbDebugGetPageRights(int argc, char* argv[]);
bool cbDebugSetPageRights(int argc, char* argv[]);
bool cbInstrSavedata(int argc, char* argv[]);
bool cbInstrMinidump(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-misc.cpp | #include "cmd-misc.h"
#include "exprfunc.h"
#include "variable.h"
#include "value.h"
#include "debugger.h"
#include "threading.h"
#include "thread.h"
#include "assemble.h"
#include "memory.h"
#include "plugin_loader.h"
#include "jit.h"
#include "mnemonichelp.h"
#include "commandline.h"
#include "stringformat.h"
bool cbInstrChd(int argc, char* argv[])
{
String directory;
if(argc < 2)
{
directory = szProgramDir;
}
else
{
directory = argv[1];
}
if(!DirExists(argv[1]))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Directory '%s' doesn't exist\n"), directory.c_str());
return false;
}
SetCurrentDirectoryW(StringUtils::Utf8ToUtf16(directory).c_str());
dputs(QT_TRANSLATE_NOOP("DBG", "Current directory changed!"));
return true;
}
bool cbInstrZzz(int argc, char* argv[])
{
duint value = 100;
if(argc > 1)
if(!valfromstring(argv[1], &value, false))
return false;
auto ms = DWORD(value);
if(ms == INFINITE)
ms = 100;
Sleep(ms);
return true;
}
bool cbDebugHide(int argc, char* argv[])
{
if(HideDebugger(fdProcessInfo->hProcess, UE_HIDE_PEBONLY))
dputs(QT_TRANSLATE_NOOP("DBG", "Debugger hidden"));
else
dputs(QT_TRANSLATE_NOOP("DBG", "Something went wrong"));
return true;
}
static duint LoadLibThreadID;
static duint FreeLibThreadID;
static duint DLLNameMem;
static duint ASMAddr;
static TITAN_ENGINE_CONTEXT_t backupctx = { 0 };
static void cbDebugLoadLibBPX()
{
HANDLE LoadLibThread = ThreadGetHandle((DWORD)LoadLibThreadID);
#ifdef _WIN64
duint LibAddr = GetContextDataEx(LoadLibThread, UE_RAX);
#else
duint LibAddr = GetContextDataEx(LoadLibThread, UE_EAX);
#endif //_WIN64
varset("$result", LibAddr, false);
backupctx.eflags &= ~0x100;
SetFullContextDataEx(LoadLibThread, &backupctx);
MemFreeRemote(DLLNameMem);
MemFreeRemote(ASMAddr);
ThreadResumeAll();
//update GUI
DebugUpdateGuiSetStateAsync(GetContextDataEx(hActiveThread, UE_CIP), paused);
//lock
lock(WAITID_RUN);
dbgsetforeground();
PLUG_CB_PAUSEDEBUG pauseInfo = { nullptr };
plugincbcall(CB_PAUSEDEBUG, &pauseInfo);
wait(WAITID_RUN);
}
bool cbDebugLoadLib(int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: you must specify the name of the DLL to load\n"));
return false;
}
#ifdef _WIN64
unsigned char loader[] =
{
0x48, 0xB9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, //movabs rcx, DLLNameAddr
0x48, 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, //movabs rax, p_LoadLibraryW
0xFF, 0xD0, //call rax
0x90 //nop
};
#else
unsigned char loader[] =
{
0x68, 0xFF, 0xFF, 0xFF, 0xFF, //push DLLNameMem
0xB8, 0xFF, 0xFF, 0xFF, 0xFF, //mov eax, p_LoadLibraryW
0xFF, 0xD0, //call eax
0x90 //nop
};
#endif //_WIN64
auto DLLNameOffset = ArchValue(1, 2), LoadLibraryOffset = ArchValue(6, 12);
LoadLibThreadID = fdProcessInfo->dwThreadId;
HANDLE LoadLibThread = ThreadGetHandle((DWORD)LoadLibThreadID);
auto DLLNameW = StringUtils::Utf8ToUtf16(argv[1]);
auto DLLNameSize = (DLLNameW.length() + 1) * 2;
duint p_LoadLibraryW = 0;
if(!valfromstring("kernel32:LoadLibraryW", &p_LoadLibraryW, false))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't get kernel32:LoadLibraryW"));
return false;
}
ASMAddr = MemAllocRemote(0, sizeof(loader));
DLLNameMem = MemAllocRemote(0, DLLNameSize);
if(!ASMAddr || !DLLNameMem)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't allocate memory in debuggee"));
return false;
}
// Set addresses in the loader
memcpy(loader + DLLNameOffset, &DLLNameMem, sizeof(duint));
memcpy(loader + LoadLibraryOffset, &p_LoadLibraryW, sizeof(duint));
if(!MemWrite(ASMAddr, loader, sizeof(loader)) || !MemWrite(DLLNameMem, DLLNameW.c_str(), DLLNameSize))
{
MemFreeRemote(ASMAddr);
dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't write process memory"));
return false;
}
if(!SetBPX(ASMAddr + sizeof(loader) - 1, UE_SINGLESHOOT | UE_BREAKPOINT_TYPE_INT3, cbDebugLoadLibBPX))
{
MemFreeRemote(ASMAddr);
dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't SetBPX"));
return false;
}
ThreadSuspendAll();
GetFullContextDataEx(LoadLibThread, &backupctx);
SetContextDataEx(LoadLibThread, UE_CIP, ASMAddr);
#ifdef _WIN64
// Allocate shadow space + align
SetContextDataEx(LoadLibThread, UE_CSP, (backupctx.csp - 32) & ~0xF);
#else
SetContextDataEx(LoadLibThread, UE_CSP, backupctx.csp & ~0xF);
#endif // _WIN64
ResumeThread(LoadLibThread);
unlock(WAITID_RUN);
return true;
}
static void cbDebugFreeLibBPX()
{
HANDLE FreeLibThread = ThreadGetHandle((DWORD)FreeLibThreadID);
#ifdef _WIN64
duint LibAddr = GetContextDataEx(FreeLibThread, UE_RAX);
#else
duint LibAddr = GetContextDataEx(FreeLibThread, UE_EAX);
#endif //_WIN64
varset("$result", LibAddr, false);
backupctx.eflags &= ~0x100;
SetFullContextDataEx(FreeLibThread, &backupctx);
MemFreeRemote(ASMAddr);
ThreadResumeAll();
//update GUI
DebugUpdateGuiSetStateAsync(GetContextDataEx(hActiveThread, UE_CIP), paused);
//lock
lock(WAITID_RUN);
dbgsetforeground();
PLUG_CB_PAUSEDEBUG pauseInfo = { nullptr };
plugincbcall(CB_PAUSEDEBUG, &pauseInfo);
wait(WAITID_RUN);
}
bool cbDebugFreeLib(int argc, char* argv[])
{
duint base = 0;
if(IsArgumentsLessThan(argc, 2) || !valfromstring(argv[1], &base, false))
return false;
base = ModBaseFromAddr(base);
if(!base)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: the specified address does not point inside a module"));
return false;
}
unsigned char loader[] =
#ifdef _WIN64
{
0x48, 0xB9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, //movabs rcx, ModuleBase
0x48, 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, //movabs rax, p_FreeLibrary
0xFF, 0xD0, //call rax
0x90 //nop
};
#else
{
0x68, 0xFF, 0xFF, 0xFF, 0xFF, //push ModuleBase
0xB8, 0xFF, 0xFF, 0xFF, 0xFF, //mov eax, p_FreeLibrary
0xFF, 0xD0, //call eax
0x90 //nop
};
#endif //_WIN64
auto ModuleBaseOffset = ArchValue(1, 2), FreeLibraryOffset = ArchValue(6, 12);
FreeLibThreadID = fdProcessInfo->dwThreadId;
HANDLE UnLoadLibThread = ThreadGetHandle((DWORD)FreeLibThreadID);
duint p_FreeLibrary = 0;
if(!valfromstring("kernel32:FreeLibrary", &p_FreeLibrary, false))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't get kernel32:FreeLibrary"));
return false;
}
ASMAddr = MemAllocRemote(0, sizeof(loader));
if(!ASMAddr)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't allocate memory in debuggee"));
return false;
}
// Set addresses in the loader
memcpy(loader + ModuleBaseOffset, &base, sizeof(duint));
memcpy(loader + FreeLibraryOffset, &p_FreeLibrary, sizeof(duint));
if(!MemWrite(ASMAddr, loader, sizeof(loader)))
{
MemFreeRemote(ASMAddr);
dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't write process memory"));
return false;
}
if(!SetBPX(ASMAddr + sizeof(loader) - 1, UE_SINGLESHOOT | UE_BREAKPOINT_TYPE_INT3, cbDebugFreeLibBPX))
{
MemFreeRemote(ASMAddr);
dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't SetBPX"));
return false;
}
ThreadSuspendAll();
GetFullContextDataEx(UnLoadLibThread, &backupctx);
SetContextDataEx(UnLoadLibThread, UE_CIP, ASMAddr);
ResumeThread(UnLoadLibThread);
unlock(WAITID_RUN);
return true;
}
bool cbInstrAssemble(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid expression: \"%s\"!\n"), argv[1]);
return false;
}
if(!DbgMemIsValidReadPtr(addr))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address: %p!\n"), addr);
return false;
}
bool fillnop = false;
if(argc > 3)
fillnop = true;
char error[MAX_ERROR_SIZE] = "";
int size = 0;
auto asmFormat = stringformatinline(argv[2]);
if(!assembleat(addr, asmFormat.c_str(), &size, error, fillnop))
{
varset("$result", size, false);
dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to assemble \"%s\" (%s)\n"), asmFormat.c_str(), error);
return false;
}
varset("$result", size, false);
GuiUpdateAllViews();
return true;
}
bool cbInstrGpa(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
char newcmd[deflen] = "";
if(argc >= 3)
sprintf_s(newcmd, "\"%s\":%s", argv[2], argv[1]);
else
sprintf_s(newcmd, "%s", argv[1]);
duint result = 0;
if(!valfromstring(newcmd, &result, false))
return false;
varset("$RESULT", result, false);
return true;
}
bool cbDebugSetJIT(int argc, char* argv[])
{
arch actual_arch = notfound;
const char* jit_debugger_cmd = "";
Memory<char*> oldjit(MAX_SETTING_SIZE + 1);
char path[JIT_ENTRY_DEF_SIZE];
if(!BridgeIsProcessElevated())
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error run the debugger as Admin to setjit\n"));
return false;
}
if(argc < 2)
{
dbggetdefjit(path);
jit_debugger_cmd = path;
if(!dbgsetjit(jit_debugger_cmd, notfound, &actual_arch, NULL))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32");
return false;
}
}
else if(argc == 2)
{
if(!_strcmpi(argv[1], "old"))
{
jit_debugger_cmd = oldjit();
if(!BridgeSettingGet("JIT", "Old", oldjit()))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error there is no old JIT entry stored."));
return false;
}
if(!dbgsetjit(jit_debugger_cmd, notfound, &actual_arch, NULL))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32");
return false;
}
}
else if(!_strcmpi(argv[1], "oldsave"))
{
dbggetdefjit(path);
char get_entry[JIT_ENTRY_MAX_SIZE] = "";
bool get_last_jit = true;
if(!dbggetjit(get_entry, notfound, &actual_arch, NULL))
{
get_last_jit = false;
}
else
strcpy_s(oldjit(), MAX_SETTING_SIZE, get_entry);
jit_debugger_cmd = path;
if(!dbgsetjit(jit_debugger_cmd, notfound, &actual_arch, NULL))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32");
return false;
}
if(get_last_jit)
{
if(_stricmp(oldjit(), path))
BridgeSettingSet("JIT", "Old", oldjit());
}
}
else if(!_strcmpi(argv[1], "restore"))
{
jit_debugger_cmd = oldjit();
if(!BridgeSettingGet("JIT", "Old", oldjit()))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error there is no old JIT entry stored."));
return false;
}
if(!dbgsetjit(jit_debugger_cmd, notfound, &actual_arch, NULL))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32");
return false;
}
BridgeSettingSet("JIT", 0, 0);
}
else
{
jit_debugger_cmd = argv[1];
if(!dbgsetjit(jit_debugger_cmd, notfound, &actual_arch, NULL))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32");
return false;
}
}
}
else if(argc == 3)
{
readwritejitkey_error_t rw_error;
if(!_strcmpi(argv[1], "old"))
{
BridgeSettingSet("JIT", "Old", argv[2]);
dprintf(QT_TRANSLATE_NOOP("DBG", "New OLD JIT stored: %s\n"), argv[2]);
return true;
}
else if(_strcmpi(argv[1], "x64") == 0)
actual_arch = x64;
else if(_strcmpi(argv[1], "x32") == 0)
actual_arch = x32;
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Unknown JIT entry type. Use OLD, x64 or x32 as parameter."));
return false;
}
jit_debugger_cmd = argv[2];
if(!dbgsetjit(jit_debugger_cmd, actual_arch, NULL, &rw_error))
{
if(rw_error == ERROR_RW_NOTWOW64)
dputs(QT_TRANSLATE_NOOP("DBG", "Error using x64 arg. The debugger is not a WOW64 process\n"));
else
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32");
return false;
}
}
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error unknown parameters. Use old, oldsave, restore, x86 or x64 as parameter."));
return false;
}
dprintf(QT_TRANSLATE_NOOP("DBG", "New JIT %s: %s\n"), (actual_arch == x64) ? "x64" : "x32", jit_debugger_cmd);
return true;
}
bool cbDebugGetJIT(int argc, char* argv[])
{
char get_entry[JIT_ENTRY_MAX_SIZE] = "";
arch actual_arch;
if(argc < 2)
{
if(!dbggetjit(get_entry, notfound, &actual_arch, NULL))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32");
return false;
}
}
else
{
readwritejitkey_error_t rw_error;
Memory<char*> oldjit(MAX_SETTING_SIZE + 1);
if(_strcmpi(argv[1], "OLD") == 0)
{
if(!BridgeSettingGet("JIT", "Old", oldjit()))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error there is no old JIT entry stored."));
return false;
}
else
{
dprintf(QT_TRANSLATE_NOOP("DBG", "OLD JIT entry stored: %s\n"), oldjit());
return true;
}
}
else if(_strcmpi(argv[1], "x64") == 0)
actual_arch = x64;
else if(_strcmpi(argv[1], "x32") == 0)
actual_arch = x32;
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Unknown JIT entry type. Use OLD, x64 or x32 as parameter."));
return false;
}
if(!dbggetjit(get_entry, actual_arch, NULL, &rw_error))
{
if(rw_error == ERROR_RW_NOTWOW64)
dputs(QT_TRANSLATE_NOOP("DBG", "Error using x64 arg. The debugger is not a WOW64 process\n"));
else
dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting JIT %s\n"), argv[1]);
return false;
}
}
dprintf(QT_TRANSLATE_NOOP("DBG", "JIT %s: %s\n"), (actual_arch == x64) ? "x64" : "x32", get_entry);
return true;
}
bool cbDebugGetJITAuto(int argc, char* argv[])
{
bool jit_auto = false;
arch actual_arch = notfound;
if(argc == 1)
{
if(!dbggetjitauto(&jit_auto, notfound, &actual_arch, NULL))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting JIT auto %s\n"), (actual_arch == x64) ? "x64" : "x32");
return false;
}
}
else if(argc == 2)
{
readwritejitkey_error_t rw_error;
if(_strcmpi(argv[1], "x64") == 0)
actual_arch = x64;
else if(_strcmpi(argv[1], "x32") == 0)
actual_arch = x32;
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Unknown JIT auto entry type. Use x64 or x32 as parameter."));
return false;
}
if(!dbggetjitauto(&jit_auto, actual_arch, NULL, &rw_error))
{
if(rw_error == ERROR_RW_NOTWOW64)
dputs(QT_TRANSLATE_NOOP("DBG", "Error using x64 arg the debugger is not a WOW64 process\n"));
else
dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting JIT auto %s\n"), argv[1]);
return false;
}
}
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Unknown JIT auto entry type. Use x64 or x32 as parameter."));
}
dprintf(QT_TRANSLATE_NOOP("DBG", "JIT auto %s: %s\n"), (actual_arch == x64) ? "x64" : "x32", jit_auto ? "ON" : "OFF");
return true;
}
bool cbDebugSetJITAuto(int argc, char* argv[])
{
arch actual_arch;
bool set_jit_auto;
if(!BridgeIsProcessElevated())
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error run the debugger as Admin to setjitauto\n"));
return false;
}
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error setting JIT Auto. Use ON:1 or OFF:0 arg or x64/x32, ON:1 or OFF:0.\n"));
return false;
}
else if(argc == 2)
{
if(_strcmpi(argv[1], "1") == 0 || _strcmpi(argv[1], "ON") == 0)
set_jit_auto = true;
else if(_strcmpi(argv[1], "0") == 0 || _strcmpi(argv[1], "OFF") == 0)
set_jit_auto = false;
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error unknown parameters. Use ON:1 or OFF:0"));
return false;
}
if(!dbgsetjitauto(set_jit_auto, notfound, &actual_arch, NULL))
{
if(actual_arch == x64)
dputs(QT_TRANSLATE_NOOP("DBG", "Error setting JIT auto x64"));
else
dputs(QT_TRANSLATE_NOOP("DBG", "Error setting JIT auto x32"));
return false;
}
}
else if(argc == 3)
{
readwritejitkey_error_t rw_error;
actual_arch = x64;
if(_strcmpi(argv[1], "x64") == 0)
actual_arch = x64;
else if(_strcmpi(argv[1], "x32") == 0)
actual_arch = x32;
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Unknown JIT auto entry type. Use x64 or x32 as parameter."));
return false;
}
if(_strcmpi(argv[2], "1") == 0 || _strcmpi(argv[2], "ON") == 0)
set_jit_auto = true;
else if(_strcmpi(argv[2], "0") == 0 || _strcmpi(argv[2], "OFF") == 0)
set_jit_auto = false;
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error unknown parameters. Use x86 or x64 and ON:1 or OFF:0\n"));
return false;
}
if(!dbgsetjitauto(set_jit_auto, actual_arch, NULL, &rw_error))
{
if(rw_error == ERROR_RW_NOTWOW64)
dputs(QT_TRANSLATE_NOOP("DBG", "Error using x64 arg the debugger is not a WOW64 process\n"));
else
{
if(actual_arch == x64)
dputs(QT_TRANSLATE_NOOP("DBG", "Error getting JIT auto x64"));
else
dputs(QT_TRANSLATE_NOOP("DBG", "Error getting JIT auto x32"));
}
return false;
}
}
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error unknown parameters use x86 or x64, ON/1 or OFF/0\n"));
return false;
}
dprintf(QT_TRANSLATE_NOOP("DBG", "New JIT auto %s: %s\n"), (actual_arch == x64) ? "x64" : "x32", set_jit_auto ? "ON" : "OFF");
return true;
}
bool cbDebugGetCmdline(int argc, char* argv[])
{
char* cmd_line;
cmdline_error_t cmdline_error = { (cmdline_error_type_t)0, 0 };
if(!dbggetcmdline(&cmd_line, &cmdline_error, fdProcessInfo->hProcess))
{
showcommandlineerror(&cmdline_error);
return false;
}
dprintf(QT_TRANSLATE_NOOP("DBG", "Command line: %s\n"), cmd_line);
efree(cmd_line);
return true;
}
bool cbDebugSetCmdline(int argc, char* argv[])
{
cmdline_error_t cmdline_error = { (cmdline_error_type_t)0, 0 };
if(argc != 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: write the arg1 with the new command line of the process debugged"));
return false;
}
if(!dbgsetcmdline(argv[1], &cmdline_error))
{
showcommandlineerror(&cmdline_error);
return false;
}
//update the memory map
MemUpdateMap();
GuiUpdateMemoryView();
dprintf(QT_TRANSLATE_NOOP("DBG", "New command line: %s\n"), argv[1]);
return true;
}
bool cbInstrMnemonichelp(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
auto description = MnemonicHelp::getDescription(argv[1]);
if(!description.length())
dputs(QT_TRANSLATE_NOOP("DBG", "No description or empty description"));
else
{
auto padding = "================================================================";
String logText = padding;
logText += '\n';
logText += description;
logText += '\n';
logText += padding;
logText += '\n';
GuiAddLogMessage(logText.c_str());
}
return true;
}
bool cbInstrMnemonicbrief(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
dputs(MnemonicHelp::getBriefDescription(argv[1]).c_str());
return true;
}
bool cbInstrConfig(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
duint val = 0;
if(argc == 3)
{
if(BridgeSettingGetUint(argv[1], argv[2], &val))
{
varset("$result", val, false);
return true;
}
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: Configuration not found."));
return false;
}
}
else
{
if(valfromstring(argv[3], &val, true))
{
if(BridgeSettingSetUint(argv[1], argv[2], val))
{
DbgSettingsUpdated();
return true;
}
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error updating configuration."));
return false;
}
}
else
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid expression: \"%s\"!\n"), argv[3]);
return false;
}
}
}
bool cbInstrRestartadmin(int argc, char* argv[])
{
if(dbgrestartadmin())
GuiCloseApplication();
return true;
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-misc.h | #pragma once
#include "command.h"
bool cbInstrChd(int argc, char* argv[]);
bool cbInstrZzz(int argc, char* argv[]);
bool cbDebugHide(int argc, char* argv[]);
bool cbDebugLoadLib(int argc, char* argv[]);
bool cbDebugFreeLib(int argc, char* argv[]);
bool cbInstrAssemble(int argc, char* argv[]);
bool cbInstrGpa(int argc, char* argv[]);
bool cbDebugSetJIT(int argc, char* argv[]);
bool cbDebugGetJIT(int argc, char* argv[]);
bool cbDebugGetJITAuto(int argc, char* argv[]);
bool cbDebugSetJITAuto(int argc, char* argv[]);
bool cbDebugGetCmdline(int argc, char* argv[]);
bool cbDebugSetCmdline(int argc, char* argv[]);
bool cbInstrMnemonichelp(int argc, char* argv[]);
bool cbInstrMnemonicbrief(int argc, char* argv[]);
bool cbInstrConfig(int argc, char* argv[]);
bool cbInstrRestartadmin(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-operating-system-control.cpp | #include "cmd-operating-system-control.h"
#include "variable.h"
#include "debugger.h"
#include "exception.h"
#include "value.h"
#include "stringformat.h"
bool cbGetPrivilegeState(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
DWORD returnLength;
LUID luid;
if(LookupPrivilegeValueW(nullptr, StringUtils::Utf8ToUtf16(argv[1]).c_str(), &luid) == 0)
{
varset("$result", (duint)0, false);
return true;
}
Memory <TOKEN_PRIVILEGES*> Privileges(64 * 16 + 8, "_dbg_getprivilegestate");
if(GetTokenInformation(hProcessToken, TokenPrivileges, Privileges(), 64 * 16 + 8, &returnLength) == 0)
{
if(returnLength > 4 * 1024 * 1024)
{
varset("$result", (duint)0, false);
return true;
}
Privileges.realloc(returnLength, "_dbg_getprivilegestate");
if(GetTokenInformation(hProcessToken, TokenPrivileges, Privileges(), returnLength, &returnLength) == 0)
return false;
}
for(unsigned int i = 0; i < Privileges()->PrivilegeCount; i++)
{
if(4 + sizeof(LUID_AND_ATTRIBUTES) * i > returnLength)
return false;
if(memcmp(&Privileges()->Privileges[i].Luid, &luid, sizeof(LUID)) == 0)
{
varset("$result", (duint)(Privileges()->Privileges[i].Attributes + 1), false); // 2=enabled, 3=default, 1=disabled
return true;
}
}
varset("$result", (duint)0, false);
return true;
}
bool cbEnablePrivilege(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
LUID luid;
if(LookupPrivilegeValueW(nullptr, StringUtils::Utf8ToUtf16(argv[1]).c_str(), &luid) == 0)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not find the specified privilege: %s\n"), argv[1]);
return false;
}
TOKEN_PRIVILEGES Privilege;
Privilege.PrivilegeCount = 1;
Privilege.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
Privilege.Privileges[0].Luid = luid;
return AdjustTokenPrivileges(hProcessToken, FALSE, &Privilege, sizeof(TOKEN_PRIVILEGES), nullptr, nullptr) != NO_ERROR;
}
bool cbDisablePrivilege(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
LUID luid;
if(LookupPrivilegeValueW(nullptr, StringUtils::Utf8ToUtf16(argv[1]).c_str(), &luid) == 0)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not find the specified privilege: %s\n"), argv[1]);
return false;
}
TOKEN_PRIVILEGES Privilege;
Privilege.PrivilegeCount = 1;
Privilege.Privileges[0].Attributes = 0;
Privilege.Privileges[0].Luid = luid;
bool ret = AdjustTokenPrivileges(hProcessToken, FALSE, &Privilege, sizeof(TOKEN_PRIVILEGES), nullptr, nullptr) != NO_ERROR;
return ret ? true : false;
}
bool cbHandleClose(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint handle;
if(!valfromstring(argv[1], &handle, false))
return false;
if(!handle || !DuplicateHandle(fdProcessInfo->hProcess, HANDLE(handle), NULL, NULL, 0, FALSE, DUPLICATE_CLOSE_SOURCE))
{
String error = stringformatinline(StringUtils::sprintf("{winerror@%x}", GetLastError()));
dprintf(QT_TRANSLATE_NOOP("DBG", "DuplicateHandle failed: %s\n"), error.c_str());
return false;
}
#ifdef _WIN64
dprintf(QT_TRANSLATE_NOOP("DBG", "Handle %llX closed!\n"), handle);
#else //x86
dprintf(QT_TRANSLATE_NOOP("DBG", "Handle %X closed!\n"), handle);
#endif
return true;
}
bool cbEnableWindow(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint handle;
if(!valfromstring(argv[1], &handle, false))
return false;
if(!IsWindowEnabled((HWND)handle))
EnableWindow((HWND)handle, TRUE);
return true;
}
bool cbDisableWindow(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint handle;
if(!valfromstring(argv[1], &handle, false))
return false;
if(IsWindowEnabled((HWND)handle))
EnableWindow((HWND)handle, FALSE);
return true;
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-operating-system-control.h | #pragma once
#include "command.h"
bool cbGetPrivilegeState(int argc, char* argv[]);
bool cbEnablePrivilege(int argc, char* argv[]);
bool cbDisablePrivilege(int argc, char* argv[]);
bool cbHandleClose(int argc, char* argv[]);
bool cbEnableWindow(int argc, char* argv[]);
bool cbDisableWindow(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-plugins.cpp | #include "cmd-plugins.h"
#include "console.h"
#include "debugger.h"
#include "module.h"
#include "plugin_loader.h"
static bool bScyllaLoaded = false;
static DWORD WINAPI scyllaThread(void* lpParam)
{
typedef INT(WINAPI * SCYLLASTARTGUI)(DWORD pid, HINSTANCE mod, DWORD_PTR entrypoint);
SCYLLASTARTGUI ScyllaStartGui = 0;
HINSTANCE hScylla = LoadLibraryW(L"Scylla.dll");
if(!hScylla)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error loading Scylla.dll!"));
bScyllaLoaded = false;
return 0;
}
ScyllaStartGui = (SCYLLASTARTGUI)GetProcAddress(hScylla, "ScyllaStartGui");
if(!ScyllaStartGui)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Could not find export 'ScyllaStartGui' inside Scylla.dll"));
bScyllaLoaded = false;
FreeLibrary(hScylla);
return 0;
}
auto cip = GetContextDataEx(hActiveThread, UE_CIP);
auto cipModBase = ModBaseFromAddr(cip);
ScyllaStartGui(fdProcessInfo->dwProcessId, (HINSTANCE)cipModBase, cip);
FreeLibrary(hScylla);
bScyllaLoaded = false;
return 0;
}
bool cbDebugStartScylla(int argc, char* argv[])
{
if(bScyllaLoaded)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Scylla is already loaded"));
return false;
}
bScyllaLoaded = true;
CloseHandle(CreateThread(0, 0, scyllaThread, 0, 0, 0));
return true;
}
bool cbInstrPluginLoad(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
return pluginload(argv[1]);
}
bool cbInstrPluginUnload(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
return pluginunload(argv[1]);
}
bool cbInstrPluginReload(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
if(!pluginunload(argv[1]))
return false;
if(argc <= 2)
{
auto text = StringUtils::Utf8ToUtf16(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Press OK to reload the plugin...")));
auto title = StringUtils::Utf8ToUtf16(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Reload")));
if(MessageBoxW(GuiGetWindowHandle(), text.c_str(), title.c_str(), MB_OKCANCEL) != IDOK)
return true;
}
return pluginload(argv[1]);
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-plugins.h | #pragma once
#include "command.h"
bool cbDebugStartScylla(int argc, char* argv[]);
bool cbInstrPluginLoad(int argc, char* argv[]);
bool cbInstrPluginUnload(int argc, char* argv[]);
bool cbInstrPluginReload(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-script.cpp | #include "cmd-script.h"
#include "stringformat.h"
#include "console.h"
#include "variable.h"
#include "stackinfo.h"
#include "debugger.h"
#include "simplescript.h"
bool cbScriptLoad(int argc, char* argv[])
{
if(argc < 2)
return false;
scriptload(argv[1]);
return true;
}
bool cbScriptMsg(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
GuiScriptMessage(stringformatinline(argv[1]).c_str());
return true;
}
bool cbScriptMsgyn(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
varset("$RESULT", GuiScriptMsgyn(stringformatinline(argv[1]).c_str()), false);
return true;
}
bool cbScriptCmd(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
auto scriptcmd = strchr(argv[0], ' ');
if(scriptcmd == nullptr)
return false;
while(isspace(*scriptcmd))
scriptcmd++;
return scriptcmdexec(scriptcmd);
}
static bool cbGenericLog(int argc, char* argv[], void(*logputs)(const char* msg))
{
if(argc == 1) //just log newline
{
logputs("");
return true;
}
if(argc == 2) //inline logging: log "format {rax}"
{
logputs(stringformatinline(argv[1]).c_str());
}
else //log "format {0} string", arg1, arg2, argN
{
FormatValueVector formatArgs;
for(auto i = 2; i < argc; i++)
formatArgs.push_back(argv[i]);
logputs(stringformat(argv[1], formatArgs).c_str());
}
return true;
}
bool cbInstrLog(int argc, char* argv[])
{
return cbGenericLog(argc, argv, [](const char* msg)
{
dputs_untranslated(msg);
scriptlog(msg);
});
}
bool cbInstrHtmlLog(int argc, char* argv[])
{
return cbGenericLog(argc, argv, [](const char* msg)
{
dprint_untranslated_html(msg);
dprint_untranslated_html("\n");
});
}
bool cbInstrPrintStack(int argc, char* argv[])
{
duint csp = GetContextDataEx(hActiveThread, UE_CSP);
std::vector<CALLSTACKENTRY> callstackVector;
stackgetcallstack(csp, callstackVector, false);
if(callstackVector.size() == 0)
dputs(QT_TRANSLATE_NOOP("DBG", "No call stack."));
else
{
duint cip = GetContextDataEx(hActiveThread, UE_CIP);
#ifdef _WIN64
duint cbp = GetContextDataEx(hActiveThread, UE_RBP);
dprintf(QT_TRANSLATE_NOOP("DBG", "%llu call stack frames (RIP = %p , RSP = %p , RBP = %p ):\n"), callstackVector.size(), cip, csp, cbp);
#else //x86
duint cbp = GetContextDataEx(hActiveThread, UE_EBP);
dprintf(QT_TRANSLATE_NOOP("DBG", "%u call stack frames (EIP = %p , ESP = %p , EBP = %p ):\n"), callstackVector.size(), cip, csp, cbp);
#endif //_WIN64
for(auto & i : callstackVector)
dprintf_untranslated("%p %s\n", i.addr, i.comment);
}
return true;
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-script.h | #pragma once
#include "command.h"
bool cbScriptLoad(int argc, char* argv[]);
bool cbScriptMsg(int argc, char* argv[]);
bool cbScriptMsgyn(int argc, char* argv[]);
bool cbScriptCmd(int argc, char* argv[]);
bool cbInstrLog(int argc, char* argv[]);
bool cbInstrHtmlLog(int argc, char* argv[]);
bool cbInstrPrintStack(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-searching.cpp | #include "cmd-searching.h"
#include "memory.h"
#include "value.h"
#include "variable.h"
#include "reference.h"
#include "assemble.h"
#include "debugger.h"
#include "filehelper.h"
#include "label.h"
#include "stringformat.h"
#include "disasm_helper.h"
#include "symbolinfo.h"
static int maxFindResults = 5000;
static bool handlePatternArgument(const char* pattern, std::vector<PatternByte> & searchpattern, String* patternshort = nullptr)
{
searchpattern.clear();
auto handlePrefix = [&](const char* prefix, size_t size) -> bool
{
auto prefixLen = strlen(prefix);
if(_strnicmp(pattern, prefix, prefixLen) == 0)
{
duint value = 0;
if(!valfromstring(pattern + prefixLen, &value, false))
return true;
auto data = (unsigned char*)&value;
for(size_t i = 0; i < size; i++)
{
auto ch = data[i];
PatternByte b;
b.nibble[0].data = (ch >> 4) & 0xF;
b.nibble[0].wildcard = false;
b.nibble[1].data = ch & 0xF;
b.nibble[1].wildcard = false;
searchpattern.push_back(b);
}
return true;
}
return false;
};
auto result = (handlePrefix("byte:", 1)
|| handlePrefix("word:", 2)
|| handlePrefix("dword:", 4)
#ifdef _WIN64
|| handlePrefix("qword:", 8)
#endif //_WIN64
|| handlePrefix("ptr:", ArchValue(4, 8))
//remove # from the start and end of the pattern (ODBGScript support)
|| patterntransform(StringUtils::Trim(stringformatinline(pattern), "#"), searchpattern)) && !searchpattern.empty();
if(result && patternshort)
{
const auto maxShortSize = 16;
for(size_t i = 0; i < min(searchpattern.size(), maxShortSize); i++)
{
auto doNibble = [&patternshort](const PatternByte::PatternNibble & n)
{
if(n.wildcard)
*patternshort += "?";
else
*patternshort += "0123456789ABCDEF"[n.data & 0xf];
};
doNibble(searchpattern[i].nibble[0]);
doNibble(searchpattern[i].nibble[1]);
}
if(searchpattern.size() > maxShortSize)
*patternshort += "...";
}
return result;
}
bool cbInstrFind(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return false;
std::vector<PatternByte> searchpattern;
if(!handlePatternArgument(argv[2], searchpattern))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to transform pattern!"));
return false;
}
duint size = 0;
duint base = MemFindBaseAddr(addr, &size, true);
if(!base)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid memory address %p!\n"), addr);
return false;
}
Memory<unsigned char*> data(size, "cbInstrFind:data");
if(!MemRead(base, data(), size))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to read memory!"));
return false;
}
duint start = addr - base;
duint find_size = 0;
if(argc >= 4)
{
if(!valfromstring(argv[3], &find_size))
find_size = size - start;
if(find_size > (size - start))
find_size = size - start;
}
else
find_size = size - start;
duint foundoffset = patternfind(data() + start, find_size, searchpattern);
duint result = 0;
if(foundoffset != -1)
result = addr + foundoffset;
varset("$result", result, false);
return true;
}
bool cbInstrFindAll(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return false;
std::vector<PatternByte> searchpattern;
String patternshort;
if(!handlePatternArgument(argv[2], searchpattern, &patternshort))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to transform pattern!"));
return false;
}
duint size = 0;
duint base = MemFindBaseAddr(addr, &size, true);
if(!base)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid memory address %p!\n"), addr);
return false;
}
Memory<unsigned char*> data(size, "cbInstrFindAll:data");
if(!MemRead(base, data(), size))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to read memory!"));
return false;
}
duint start = addr - base;
duint find_size = 0;
bool findData = false;
if(argc >= 4)
{
if(!_stricmp(argv[3], "&data&"))
{
find_size = size - start;
findData = true;
}
else if(!valfromstring(argv[3], &find_size))
find_size = size - start;
if(find_size > (size - start))
find_size = size - start;
}
else
find_size = size - start;
//setup reference view
String patterntitle = StringUtils::sprintf(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Pattern: %s")), patternshort.c_str());
GuiReferenceInitialize(patterntitle.c_str());
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address")));
if(findData)
GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Data")));
else
GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly")));
GuiReferenceSetRowCount(0);
GuiReferenceReloadData();
DWORD ticks = GetTickCount();
int refCount = 0;
duint i = 0;
duint result = 0;
while(refCount < maxFindResults)
{
duint foundoffset = patternfind(data() + start + i, find_size - i, searchpattern);
if(foundoffset == -1)
break;
i += foundoffset + 1;
result = addr + i - 1;
char msg[deflen] = "";
sprintf_s(msg, "%p", result);
GuiReferenceSetRowCount(refCount + 1);
GuiReferenceSetCellContent(refCount, 0, msg);
if(findData)
{
Memory<unsigned char*> printData(searchpattern.size(), "cbInstrFindAll:printData");
MemRead(result, printData(), printData.size());
for(size_t j = 0, k = 0; j < printData.size(); j++)
{
if(j)
k += sprintf_s(msg + k, sizeof(msg) - k, " ");
k += sprintf_s(msg + k, sizeof(msg) - k, "%.2X", printData()[j]);
}
}
else
{
if(!GuiGetDisassembly(result, msg))
strcpy_s(msg, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "[Error disassembling]")));
}
GuiReferenceSetCellContent(refCount, 1, msg);
result++;
refCount++;
}
GuiReferenceReloadData();
dprintf(QT_TRANSLATE_NOOP("DBG", "%d occurrences found in %ums\n"), refCount, GetTickCount() - ticks);
varset("$result", refCount, false);
return true;
}
bool cbInstrFindAllMem(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return false;
std::vector<PatternByte> searchpattern;
String patternshort;
if(!handlePatternArgument(argv[2], searchpattern, &patternshort))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to transform pattern!"));
return false;
}
duint find_size = -1;
bool findData = false;
REFFINDTYPE moduleFindType = CURRENT_REGION;
if(argc >= 4)
{
if(!_stricmp(argv[3], "&data&"))
findData = true;
else if(!valfromstring(argv[3], &find_size))
findData = false;
}
if(argc >= 5)
{
if(!_stricmp(argv[4], "user"))
moduleFindType = USER_MODULES;
else if(!_stricmp(argv[4], "system"))
moduleFindType = SYSTEM_MODULES;
else if(!_stricmp(argv[4], "module"))
moduleFindType = ALL_MODULES;
}
SHARED_ACQUIRE(LockMemoryPages);
std::vector<SimplePage> searchPages;
for(auto & itr : memoryPages)
{
if(itr.second.mbi.State != MEM_COMMIT)
continue;
SimplePage page(duint(itr.second.mbi.BaseAddress), itr.second.mbi.RegionSize);
if(moduleFindType != CURRENT_REGION)
{
SHARED_ACQUIRE(LockModules);
auto info = ModInfoFromAddr(page.address);
if(info)
{
if(moduleFindType == ALL_MODULES)
{
// Looking for modules and this region is in a module
}
else if(moduleFindType == USER_MODULES && info->party == mod_user)
{
// Looking for user modules and this region is in a user module
}
else if(moduleFindType == SYSTEM_MODULES && info->party == mod_system)
{
// Looking for system modules and this region is in a system module
}
else
{
// Module type is not matching
continue;
}
}
else
{
// Region is not a module
continue;
}
}
if(page.address >= addr && (find_size == -1 || page.address + page.size <= addr + find_size))
searchPages.push_back(page);
}
SHARED_RELEASE();
DWORD ticks = GetTickCount();
std::vector<duint> results;
if(!MemFindInMap(searchPages, searchpattern, results, maxFindResults))
{
dputs(QT_TRANSLATE_NOOP("DBG", "MemFindInMap failed!"));
return false;
}
//setup reference view
String patterntitle = StringUtils::sprintf(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Pattern: %s")), patternshort.c_str());
GuiReferenceInitialize(patterntitle.c_str());
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address")));
if(findData)
GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Data")));
else
GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly")));
GuiReferenceSetRowCount(0);
GuiReferenceReloadData();
int refCount = 0;
for(duint result : results)
{
char msg[deflen] = "";
sprintf_s(msg, "%p", result);
GuiReferenceSetRowCount(refCount + 1);
GuiReferenceSetCellContent(refCount, 0, msg);
if(findData)
{
Memory<unsigned char*> printData(searchpattern.size(), "cbInstrFindAll:printData");
MemRead(result, printData(), printData.size());
for(size_t j = 0, k = 0; j < printData.size(); j++)
{
if(j)
k += sprintf_s(msg + k, sizeof(msg) - k, " ");
k += sprintf_s(msg + k, sizeof(msg) - k, "%.2X", printData()[j]);
}
}
else
{
if(!GuiGetDisassembly(result, msg))
strcpy_s(msg, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "[Error disassembling]")));
}
GuiReferenceSetCellContent(refCount, 1, msg);
refCount++;
}
GuiReferenceReloadData();
dprintf(QT_TRANSLATE_NOOP("DBG", "%d occurrences found in %ums\n"), refCount, GetTickCount() - ticks);
varset("$result", refCount, false);
return true;
}
static bool cbFindAsm(Zydis* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFINFO* refinfo)
{
if(!disasm || !basicinfo) //initialize
{
GuiReferenceInitialize(refinfo->name);
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address")));
GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly")));
GuiReferenceSetRowCount(0);
GuiReferenceReloadData();
return true;
}
const char* instruction = (const char*)refinfo->userinfo;
bool found = !_stricmp(instruction, basicinfo->instruction);
if(found)
{
char addrText[20] = "";
sprintf_s(addrText, "%p", disasm->Address());
GuiReferenceSetRowCount(refinfo->refcount + 1);
GuiReferenceSetCellContent(refinfo->refcount, 0, addrText);
char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = "";
if(GuiGetDisassembly((duint)disasm->Address(), disassembly))
GuiReferenceSetCellContent(refinfo->refcount, 1, disassembly);
else
GuiReferenceSetCellContent(refinfo->refcount, 1, disasm->InstructionText().c_str());
}
return found;
}
bool cbInstrFindAsm(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint addr = 0;
if(argc < 3 || !valfromstring(argv[2], &addr))
addr = GetContextDataEx(hActiveThread, UE_CIP);
duint size = 0;
if(argc >= 4)
if(!valfromstring(argv[3], &size))
size = 0;
duint refFindType = CURRENT_REGION;
if(argc >= 5 && valfromstring(argv[4], &refFindType, true))
if(refFindType != CURRENT_REGION && refFindType != CURRENT_MODULE && refFindType != USER_MODULES && refFindType != SYSTEM_MODULES && refFindType != ALL_MODULES)
refFindType = CURRENT_REGION;
unsigned char dest[16];
int asmsize = 0;
char error[MAX_ERROR_SIZE] = "";
auto asmFormat = stringformatinline(argv[1]);
if(!assemble(addr + size / 2, dest, &asmsize, asmFormat.c_str(), error))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to assemble \"%s\" (%s)!\n"), asmFormat.c_str(), error);
return false;
}
BASIC_INSTRUCTION_INFO basicinfo;
memset(&basicinfo, 0, sizeof(BASIC_INSTRUCTION_INFO));
disasmfast(dest, addr + size / 2, &basicinfo);
duint ticks = GetTickCount();
char title[256] = "";
sprintf_s(title, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Command: \"%s\"")), basicinfo.instruction);
int found = RefFind(addr, size, cbFindAsm, (void*)&basicinfo.instruction[0], false, title, (REFFINDTYPE)refFindType, true);
dprintf(QT_TRANSLATE_NOOP("DBG", "%u result(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks));
varset("$result", found, false);
return true;
}
bool cbInstrRefFind(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
std::string newCommand = std::string("reffindrange ") + argv[1] + std::string(",") + argv[1];
if(argc > 2)
newCommand += std::string(",") + argv[2];
if(argc > 3)
newCommand += std::string(",") + argv[3];
if(argc > 4)
newCommand += std::string(",") + argv[4];
return cmddirectexec(newCommand.c_str());
}
struct VALUERANGE
{
duint start;
duint end;
};
static bool cbRefFind(Zydis* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFINFO* refinfo)
{
if(!disasm || !basicinfo) //initialize
{
GuiReferenceInitialize(refinfo->name);
GuiReferenceAddColumn(sizeof(duint) * 2, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address")));
GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly")));
GuiReferenceSetRowCount(0);
GuiReferenceReloadData();
return true;
}
bool found = false;
VALUERANGE* range = (VALUERANGE*)refinfo->userinfo;
duint start = range->start;
duint end = range->end;
if((basicinfo->type & TYPE_VALUE) == TYPE_VALUE)
{
duint value = basicinfo->value.value;
if(value >= start && value <= end)
found = true;
// Workaround for sign-extended values, see: https://github.com/x64dbg/x64dbg/issues/2824
if((value & ArchValue(0x80000000, 0x800000000000)) != 0)
{
switch(basicinfo->value.size)
{
case size_byte:
value &= 0xFF;
break;
case size_word:
value &= 0xFFFF;
break;
case size_dword:
value &= 0xFFFFFFFF;
break;
default:
break;
}
if(value >= start && value <= end)
found = true;
}
}
if((basicinfo->type & TYPE_MEMORY) == TYPE_MEMORY)
{
duint value = basicinfo->memory.value;
if(value >= start && value <= end)
found = true;
}
if((basicinfo->type & TYPE_ADDR) == TYPE_ADDR)
{
duint value = basicinfo->addr;
if(value >= start && value <= end)
found = true;
}
if(found)
{
char addrText[20] = "";
sprintf_s(addrText, "%p", disasm->Address());
GuiReferenceSetRowCount(refinfo->refcount + 1);
GuiReferenceSetCellContent(refinfo->refcount, 0, addrText);
char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = "";
if(GuiGetDisassembly((duint)disasm->Address(), disassembly))
GuiReferenceSetCellContent(refinfo->refcount, 1, disassembly);
else
GuiReferenceSetCellContent(refinfo->refcount, 1, disasm->InstructionText().c_str());
}
return found;
}
bool cbInstrRefFindRange(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
VALUERANGE range;
if(!valfromstring(argv[1], &range.start, false))
return false;
if(argc < 3 || !valfromstring(argv[2], &range.end, false))
range.end = range.start;
duint addr = 0;
if(argc < 4 || !valfromstring(argv[3], &addr))
addr = GetContextDataEx(hActiveThread, UE_CIP);
duint size = 0;
if(argc >= 5)
if(!valfromstring(argv[4], &size))
size = 0;
duint ticks = GetTickCount();
char title[256] = "";
if(range.start == range.end)
sprintf_s(title, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Constant: %p")), range.start);
else
sprintf_s(title, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Range: %p-%p")), range.start, range.end);
duint refFindType = CURRENT_REGION;
if(argc >= 6 && valfromstring(argv[5], &refFindType, true))
if(refFindType != CURRENT_REGION && refFindType != CURRENT_MODULE && refFindType != USER_MODULES && refFindType != SYSTEM_MODULES && refFindType != ALL_MODULES)
refFindType = CURRENT_REGION;
int found = RefFind(addr, size, cbRefFind, &range, false, title, (REFFINDTYPE)refFindType, false);
dprintf(QT_TRANSLATE_NOOP("DBG", "%u reference(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks));
varset("$result", found, false);
return true;
}
static bool cbRefStr(Zydis* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFINFO* refinfo)
{
if(!disasm || !basicinfo) //initialize
{
GuiReferenceInitialize(refinfo->name);
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address")));
GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly")));
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "String Address")));
GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "String")));
GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Follow in Disassembly and Dump")), "disasm $0;dump $2");
GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Follow string in Dump")), "dump $2");
GuiReferenceSetSearchStartCol(2); //only search the strings
GuiReferenceSetRowCount(0);
GuiReferenceReloadData();
return true;
}
bool found = false;
char string[MAX_STRING_SIZE] = "";
if(basicinfo->branch) //branches have no strings (jmp dword [401000])
return false;
auto addRef = [&](duint strAddr)
{
char addrText[20] = "";
sprintf_s(addrText, "%p", disasm->Address());
char strAddrText[20] = "";
sprintf_s(strAddrText, "%p", strAddr);
GuiReferenceSetRowCount(refinfo->refcount + 1);
GuiReferenceSetCellContent(refinfo->refcount, 0, addrText);
char disassembly[4096] = "";
if(GuiGetDisassembly((duint)disasm->Address(), disassembly))
GuiReferenceSetCellContent(refinfo->refcount, 1, disassembly);
else
GuiReferenceSetCellContent(refinfo->refcount, 1, disasm->InstructionText().c_str());
GuiReferenceSetCellContent(refinfo->refcount, 2, strAddrText);
GuiReferenceSetCellContent(refinfo->refcount, 3, string);
refinfo->refcount++;
};
if((basicinfo->type & TYPE_VALUE) == TYPE_VALUE)
{
if(DbgGetStringAt(basicinfo->value.value, string))
addRef(basicinfo->value.value);
}
if((basicinfo->type & TYPE_MEMORY) == TYPE_MEMORY)
{
if(DbgGetStringAt(basicinfo->memory.value, string))
addRef(basicinfo->memory.value);
}
return false;
}
static bool cbRefFuncPtr(Zydis* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFINFO* refinfo)
{
if(!disasm || !basicinfo) //initialize
{
GuiReferenceInitialize(refinfo->name);
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address")));
GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly")));
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Function pointer")));
GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Label")));
GuiReferenceSetSearchStartCol(2); //only search the function pointers
GuiReferenceSetRowCount(0);
GuiReferenceReloadData();
return true;
}
bool found = false;
if(basicinfo->branch) //we doesn't look for function pointers in jmp & calls
return false;
auto addRef = [&](duint pointer)
{
char addrText[20] = "";
sprintf_s(addrText, "%p", disasm->Address());
GuiReferenceSetRowCount(refinfo->refcount + 1);
GuiReferenceSetCellContent(refinfo->refcount, 0, addrText);
char disassembly[4096] = "";
if(GuiGetDisassembly((duint)disasm->Address(), disassembly))
GuiReferenceSetCellContent(refinfo->refcount, 1, disassembly);
else
GuiReferenceSetCellContent(refinfo->refcount, 1, disasm->InstructionText().c_str());
char label[MAX_LABEL_SIZE];
sprintf_s(addrText, "%p", pointer);
memset(label, 0, sizeof(label));
DbgGetLabelAt(pointer, SEG_DEFAULT, label);
GuiReferenceSetCellContent(refinfo->refcount, 2, addrText);
GuiReferenceSetCellContent(refinfo->refcount, 3, label);
refinfo->refcount++;
};
if((basicinfo->type & TYPE_VALUE) == TYPE_VALUE)
{
if(MemIsCodePage(basicinfo->value.value, false))
addRef(basicinfo->value.value);
}
if((basicinfo->type & TYPE_MEMORY) == TYPE_MEMORY)
{
if(MemIsCodePage(basicinfo->memory.value, false))
addRef(basicinfo->memory.value);
}
return false;
}
bool cbInstrRefStr(int argc, char* argv[])
{
duint ticks = GetTickCount();
duint addr;
duint size = 0;
String TranslatedString;
// If not specified, assume CURRENT_REGION by default
if(argc < 2 || !valfromstring(argv[1], &addr, true))
addr = GetContextDataEx(hActiveThread, UE_CIP);
if(argc >= 3)
if(!valfromstring(argv[2], &size, true))
size = 0;
duint refFindType = CURRENT_REGION;
if(argc >= 4 && valfromstring(argv[3], &refFindType, true))
if(refFindType != CURRENT_REGION && refFindType != CURRENT_MODULE && refFindType != USER_MODULES && refFindType != SYSTEM_MODULES && refFindType != ALL_MODULES)
refFindType = CURRENT_REGION;
TranslatedString = GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Strings"));
int found = RefFind(addr, size, cbRefStr, 0, false, TranslatedString.c_str(), (REFFINDTYPE)refFindType, false);
dprintf(QT_TRANSLATE_NOOP("DBG", "%u string(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks));
varset("$result", found, false);
return true;
}
bool cbInstrRefFuncionPointer(int argc, char* argv[])
{
duint ticks = GetTickCount();
duint addr;
duint size = 0;
String TranslatedString;
// If not specified, assume CURRENT_REGION by default
if(argc < 2 || !valfromstring(argv[1], &addr, true))
addr = GetContextDataEx(hActiveThread, UE_CIP);
if(argc >= 3)
if(!valfromstring(argv[2], &size, true))
size = 0;
duint refFindType = CURRENT_REGION;
if(argc >= 4 && valfromstring(argv[3], &refFindType, true))
if(refFindType != CURRENT_REGION && refFindType != CURRENT_MODULE && refFindType != ALL_MODULES)
refFindType = CURRENT_REGION;
TranslatedString = GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Function pointers"));
int found = RefFind(addr, size, cbRefFuncPtr, 0, false, TranslatedString.c_str(), (REFFINDTYPE)refFindType, false);
dprintf(QT_TRANSLATE_NOOP("DBG", "%u function pointer(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks));
varset("$result", found, false);
return true;
}
static bool cbModCallFind(Zydis* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFINFO* refinfo)
{
if(!disasm || !basicinfo) //initialize
{
GuiReferenceInitialize(refinfo->name);
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address")));
GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly")));
GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Destination")));
GuiReferenceSetRowCount(0);
GuiReferenceReloadData();
return true;
}
duint foundaddr = 0;
char label[MAX_LABEL_SIZE] = "";
char module[MAX_MODULE_SIZE] = "";
duint base = ModBaseFromAddr(disasm->Address()), size = 0;
if(!base)
base = MemFindBaseAddr(disasm->Address(), &size);
else
size = ModSizeFromAddr(base);
if(!base || !size)
return false; //__debugbreak
if(basicinfo->call) //we are looking for calls
{
if(basicinfo->addr && MemIsValidReadPtr(basicinfo->addr, true))
{
if(basicinfo->addr < base || basicinfo->addr >= base + size) //call api
foundaddr = basicinfo->addr;
else //call [jmp.api]
{
BASIC_INSTRUCTION_INFO info;
memset(&info, 0, sizeof(BASIC_INSTRUCTION_INFO));
if(disasmfast(basicinfo->addr, &info, true) && info.branch && !info.call && info.memory.value) //jmp [addr]
{
duint memaddr;
if(MemRead(info.memory.value, &memaddr, sizeof(memaddr), nullptr, true))
{
if((memaddr < base || memaddr >= base + size) && MemIsValidReadPtr(memaddr, true))
foundaddr = memaddr;
}
}
}
}
}
switch(disasm->GetId())
{
case ZYDIS_MNEMONIC_CALL: //call dword ptr: [&api]
case ZYDIS_MNEMONIC_MOV: //mov reg, dword ptr:[&api]
if(!foundaddr && basicinfo->memory.value)
{
duint memaddr;
if(MemRead(basicinfo->memory.value, &memaddr, sizeof(memaddr), nullptr, true))
{
if((memaddr < base || memaddr >= base + size) && ModBaseFromAddr(memaddr))
foundaddr = memaddr;
}
}
break;
}
if(foundaddr)
{
char addrText[20] = "";
sprintf_s(addrText, "%p", disasm->Address());
GuiReferenceSetRowCount(refinfo->refcount + 1);
GuiReferenceSetCellContent(refinfo->refcount, 0, addrText);
char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = "";
if(GuiGetDisassembly((duint)disasm->Address(), disassembly))
{
GuiReferenceSetCellContent(refinfo->refcount, 1, disassembly);
}
else
{
GuiReferenceSetCellContent(refinfo->refcount, 1, disasm->InstructionText().c_str());
}
GuiReferenceSetCellContent(refinfo->refcount, 2, SymGetSymbolicName(foundaddr).c_str());
}
return foundaddr != 0;
}
bool cbInstrModCallFind(int argc, char* argv[])
{
duint addr;
if(argc < 2 || !valfromstring(argv[1], &addr, true))
addr = GetContextDataEx(hActiveThread, UE_CIP);
duint size = 0;
if(argc >= 3)
if(!valfromstring(argv[2], &size, true))
size = 0;
duint refFindType = CURRENT_REGION;
if(argc >= 4 && valfromstring(argv[3], &refFindType, true))
if(refFindType != CURRENT_REGION && refFindType != CURRENT_MODULE && refFindType != USER_MODULES && refFindType != SYSTEM_MODULES && refFindType != ALL_MODULES)
refFindType = CURRENT_REGION;
duint ticks = GetTickCount();
String Calls = GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Calls"));
int found = RefFind(addr, size, cbModCallFind, 0, false, Calls.c_str(), (REFFINDTYPE)refFindType, false);
dprintf(QT_TRANSLATE_NOOP("DBG", "%u call(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks));
varset("$result", found, false);
return true;
}
struct GUIDHashObject
{
inline size_t operator()(const GUID & ref) const
{
size_t* p = (size_t*)&ref;
#ifdef _WIN64
static_assert(sizeof(size_t) == 8, "The system is not 64-bit!");
return p[0] + p[1];
#else //x86
static_assert(sizeof(size_t) == 4, "The system is not 32-bit!");
return p[0] + p[1] + p[2] + p[3];
#endif //_WIN64
};
};
struct GUIDEqualObject
{
inline bool operator()(const GUID & a, const GUID & b) const
{
return memcmp(&a, &b, sizeof(GUID)) == 0;
};
};
class GUIDInfo
{
public:
String ProgId;
String Description;
String Path;
GUIDInfo(const GUID & ref, HKEY CLSID)
{
wchar_t subkey[40];
HKEY hKey;
StringFromGUID2(ref, subkey, 40);
if(RegOpenKeyExW(CLSID, subkey, 0, KEY_READ, &hKey) == ERROR_SUCCESS)
{
Description = ReadValue(nullptr, hKey);
HKEY hProgIdKey;
if(RegOpenKeyExW(hKey, L"ProgId", 0, KEY_READ, &hProgIdKey) == ERROR_SUCCESS)
{
ProgId = ReadValue(nullptr, hProgIdKey);
RegCloseKey(hProgIdKey);
}
else
{
ProgId = "";
}
HKEY hPathKey;
if(RegOpenKeyExW(hKey, L"InprocServer32", 0, KEY_READ, &hPathKey) == ERROR_SUCCESS)
{
Path = ReadValue(nullptr, hPathKey);
RegCloseKey(hPathKey);
}
else
{
Path = "";
}
RegCloseKey(hKey);
}
}
private:
String ReadValue(const wchar_t* name, HKEY hKey)
{
DWORD regType = 0;
DWORD cbData = 0;
if(RegQueryValueExW(hKey, name, nullptr, ®Type, nullptr, &cbData))
return "";
if(regType != REG_SZ)
return "";
Memory<wchar_t*> buffer(cbData + 2, "GUIDInfo::ReadValue");
buffer()[cbData / 2] = 0; //ensure the buffer is null-terminated
if(RegQueryValueExW(hKey, name, nullptr, nullptr, reinterpret_cast<LPBYTE>(buffer()), &cbData))
return "";
return StringUtils::Utf16ToUtf8(buffer());
}
};
struct GUIDRefInfo
{
std::unordered_map<GUID, size_t, GUIDHashObject, GUIDEqualObject>* allRegisteredGUIDs;
std::vector<GUIDInfo>* allQueriedGUIDs;
HKEY CLSID;
};
static bool cbGUIDFind(Zydis* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFINFO* refinfo)
{
if(!disasm || !basicinfo) //initialize
{
GuiReferenceInitialize(refinfo->name);
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address")));
GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly")));
GuiReferenceAddColumn(40, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "GUID")));
GuiReferenceAddColumn(20, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "ProgId")));
GuiReferenceAddColumn(40, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Path")));
GuiReferenceAddColumn(40, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Description")));
GuiReferenceSetRowCount(0);
GuiReferenceReloadData();
return true;
}
duint value = 0;
if(basicinfo->branch) //cannot branch to a GUID
return false;
GUIDRefInfo* refInfo = reinterpret_cast<GUIDRefInfo*>(refinfo->userinfo);
if((basicinfo->type & TYPE_VALUE) == TYPE_VALUE)
value = basicinfo->value.value;
if((basicinfo->type & TYPE_MEMORY) == TYPE_MEMORY)
value = basicinfo->memory.value;
if((basicinfo->type & TYPE_ADDR) == TYPE_ADDR)
value = basicinfo->addr;
GUID guid;
unsigned char membuffer[38 * 2];
bool found = false;
memset(&membuffer, 0, sizeof(membuffer));
if(MemRead(value, &membuffer, sizeof(membuffer), nullptr, true))
{
std::unordered_map<GUID, size_t, GUIDHashObject, GUIDEqualObject>::iterator iterator;
if(membuffer[0] == '{' && membuffer[37] == '}' && membuffer[24] == '-' && membuffer[9] == '-' && membuffer[14] == '-' && membuffer[19] == '-')
{
//very likely a ASCII string representation of GUID
wchar_t wideguid[39];
for(size_t i = 0; i < 38; i++)
wideguid[i] = membuffer[i];
wideguid[38] = 0;
if(CLSIDFromString(wideguid, &guid) == S_OK)
{
iterator = refInfo->allRegisteredGUIDs->find(guid);
if(iterator != refInfo->allRegisteredGUIDs->end())
found = true;
}
}
if(!found)
{
wchar_t* wideguid = reinterpret_cast<wchar_t*>(membuffer);
if(wideguid[0] == L'{' && wideguid[37] == L'}' && wideguid[24] == L'-' && wideguid[9] == L'-' && wideguid[14] == L'-' && wideguid[19] == L'-')
{
//very likely a Unicode string representation of GUID
if(CLSIDFromString(wideguid, &guid) == S_OK)
{
iterator = refInfo->allRegisteredGUIDs->find(guid);
if(iterator != refInfo->allRegisteredGUIDs->end())
found = true;
}
}
}
if(!found)
{
memcpy(&guid, membuffer, sizeof(guid));
iterator = refInfo->allRegisteredGUIDs->find(guid);
if(iterator != refInfo->allRegisteredGUIDs->end())
found = true;
}
if(found)
{
char addrText[20] = "";
sprintf_s(addrText, "%p", disasm->Address());
GuiReferenceSetRowCount(refinfo->refcount + 1);
GuiReferenceSetCellContent(refinfo->refcount, 0, addrText);
char disassembly[4096] = "";
if(GuiGetDisassembly((duint)disasm->Address(), disassembly))
GuiReferenceSetCellContent(refinfo->refcount, 1, disassembly);
else
GuiReferenceSetCellContent(refinfo->refcount, 1, disasm->InstructionText().c_str());
wchar_t guidText[40];
StringFromGUID2(guid, guidText, 40);
GuiReferenceSetCellContent(refinfo->refcount, 2, StringUtils::Utf16ToUtf8(guidText).c_str());
size_t infoIndex = iterator->second;
if(infoIndex == 0)
{
refInfo->allQueriedGUIDs->push_back(GUIDInfo(guid, refInfo->CLSID));
infoIndex = refInfo->allQueriedGUIDs->size();
refInfo->allRegisteredGUIDs->at(guid) = infoIndex;
}
infoIndex--;
GuiReferenceSetCellContent(refinfo->refcount, 3, refInfo->allQueriedGUIDs->at(infoIndex).ProgId.c_str());
GuiReferenceSetCellContent(refinfo->refcount, 4, refInfo->allQueriedGUIDs->at(infoIndex).Path.c_str());
GuiReferenceSetCellContent(refinfo->refcount, 5, refInfo->allQueriedGUIDs->at(infoIndex).Description.c_str());
}
}
return found;
}
bool cbInstrGUIDFind(int argc, char* argv[])
{
duint ticks = GetTickCount();
duint addr;
duint size = 0;
String TranslatedString;
std::unordered_map<GUID, size_t, GUIDHashObject, GUIDEqualObject> allRegisteredGUIDs;
std::vector<GUIDInfo> allQueriedGUIDs;
GUIDRefInfo refInfo;
// If not specified, assume CURRENT_REGION by default
if(argc < 2 || !valfromstring(argv[1], &addr, true))
addr = GetContextDataEx(hActiveThread, UE_CIP);
if(argc >= 3)
if(!valfromstring(argv[2], &size, true))
size = 0;
duint refFindType = CURRENT_REGION;
if(argc >= 4 && valfromstring(argv[3], &refFindType, true))
if(refFindType != CURRENT_REGION && refFindType != CURRENT_MODULE && refFindType != ALL_MODULES)
refFindType = CURRENT_REGION;
HKEY CLSID;
if(RegOpenKeyExW(HKEY_CLASSES_ROOT, L"CLSID", 0, KEY_READ, &CLSID))
{
dputs(QT_TRANSLATE_NOOP("DBG", "RegOpenKeyExW() failed. Cannot enumerate GUIDs."));
return false;
}
wchar_t subkeyName[40];
subkeyName[39] = 0;
DWORD i = 0;
DWORD subkeyNameLen = 40;
LONG result;
while(result = RegEnumKeyExW(CLSID, i++, subkeyName, &subkeyNameLen, nullptr, nullptr, nullptr, nullptr), result == ERROR_SUCCESS || result == ERROR_MORE_DATA)
{
if(subkeyNameLen == 38 && result != ERROR_MORE_DATA)
{
if(subkeyName[0] == '{' && subkeyName[37] == '}' && subkeyName[24] == '-' && subkeyName[9] == '-' && subkeyName[14] == '-' && subkeyName[19] == '-')
{
//very likely a GUID
GUID temp;
if(CLSIDFromString(subkeyName, &temp) == S_OK)
allRegisteredGUIDs.insert(std::make_pair(temp, 0));
}
}
subkeyNameLen = 40;
subkeyName[39] = 0;
}
refInfo.allQueriedGUIDs = &allQueriedGUIDs;
refInfo.allRegisteredGUIDs = &allRegisteredGUIDs;
refInfo.CLSID = CLSID;
TranslatedString = GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "GUID"));
int found = RefFind(addr, size, cbGUIDFind, &refInfo, false, TranslatedString.c_str(), (REFFINDTYPE)refFindType, false);
dprintf(QT_TRANSLATE_NOOP("DBG", "%u GUID(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks));
varset("$result", found, false);
RegCloseKey(CLSID);
return true;
}
bool cbInstrSetMaxFindResult(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint num;
if(!valfromstring(argv[1], &num))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid expression: \"%s\""), argv[1]);
return false;
}
maxFindResults = int(num & 0x7FFFFFFF);
return true;
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-searching.h | #pragma once
#include "command.h"
bool cbInstrFind(int argc, char* argv[]);
bool cbInstrFindAll(int argc, char* argv[]);
bool cbInstrFindAllMem(int argc, char* argv[]);
bool cbInstrFindAsm(int argc, char* argv[]);
bool cbInstrRefFind(int argc, char* argv[]);
bool cbInstrRefFindRange(int argc, char* argv[]);
bool cbInstrRefStr(int argc, char* argv[]);
bool cbInstrRefFuncionPointer(int argc, char* argv[]);
bool cbInstrModCallFind(int argc, char* argv[]);
bool cbInstrGUIDFind(int argc, char* argv[]);
bool cbInstrSetMaxFindResult(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-thread-control.cpp | #include "cmd-thread-control.h"
#include "variable.h"
#include "memory.h"
#include "value.h"
#include "debugger.h"
#include "console.h"
#include "label.h"
#include "historycontext.h"
#include "thread.h"
bool cbDebugCreatethread(int argc, char* argv[])
{
if(argc < 2)
return false;
duint Entry = 0;
duint Argument = 0;
if(!valfromstring(argv[1], &Entry))
return false;
if(!MemIsCodePage(Entry, false))
return false;
if(argc > 2)
{
if(!valfromstring(argv[2], &Argument))
return false;
}
DWORD ThreadId = 0;
auto hThread = CreateRemoteThread(fdProcessInfo->hProcess, nullptr, 0, LPTHREAD_START_ROUTINE(Entry), LPVOID(Argument), 0, &ThreadId);
if(!hThread)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Create thread failed!"));
return false;
}
else
{
CloseHandle(hThread);
char label[MAX_LABEL_SIZE];
if(!LabelGet(Entry, label))
label[0] = 0;
#ifdef _WIN64
dprintf(QT_TRANSLATE_NOOP("DBG", "Thread %s created at %s %p(Argument=%llX)\n"), formatpidtid(ThreadId).c_str(), label, Entry, Argument);
#else //x86
dprintf(QT_TRANSLATE_NOOP("DBG", "Thread %s created at %s %p(Argument=%X)\n"), formatpidtid(ThreadId).c_str(), label, Entry, Argument);
#endif
varset("$result", ThreadId, false);
return true;
}
}
bool cbDebugSwitchthread(int argc, char* argv[])
{
duint threadid = fdProcessInfo->dwThreadId; //main thread
if(argc > 1)
if(!valfromstring(argv[1], &threadid, false))
return false;
if(!ThreadIsValid((DWORD)threadid)) //check if the thread is valid
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %s\n"), formatpidtid((DWORD)threadid).c_str());
return false;
}
//switch thread
if(ThreadGetId(hActiveThread) != threadid)
{
hActiveThread = ThreadGetHandle((DWORD)threadid);
HistoryClear();
DebugUpdateGuiAsync(GetContextDataEx(hActiveThread, UE_CIP), true);
dputs(QT_TRANSLATE_NOOP("DBG", "Thread switched!"));
}
return true;
}
bool cbDebugSuspendthread(int argc, char* argv[])
{
duint threadid = fdProcessInfo->dwThreadId;
if(argc > 1)
if(!valfromstring(argv[1], &threadid, false))
return false;
if(!ThreadIsValid((DWORD)threadid)) //check if the thread is valid
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %s\n"), formatpidtid((DWORD)threadid).c_str());
return false;
}
//suspend thread
if(SuspendThread(ThreadGetHandle((DWORD)threadid)) == -1)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error suspending thread"));
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Thread suspended"));
GuiUpdateAllViews();
return true;
}
bool cbDebugResumethread(int argc, char* argv[])
{
duint threadid = fdProcessInfo->dwThreadId;
if(argc > 1)
if(!valfromstring(argv[1], &threadid, false))
return false;
if(!ThreadIsValid((DWORD)threadid)) //check if the thread is valid
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %s\n"), formatpidtid((DWORD)threadid).c_str());
return false;
}
//resume thread
if(ResumeThread(ThreadGetHandle((DWORD)threadid)) == -1)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error resuming thread"));
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Thread resumed!"));
GuiUpdateAllViews();
return true;
}
bool cbDebugKillthread(int argc, char* argv[])
{
duint threadid = fdProcessInfo->dwThreadId;
if(argc > 1)
if(!valfromstring(argv[1], &threadid, false))
return false;
duint exitcode = 0;
if(argc > 2)
if(!valfromstring(argv[2], &exitcode, false))
return false;
if(!ThreadIsValid((DWORD)threadid)) //check if the thread is valid
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %s\n"), formatpidtid((DWORD)threadid).c_str());
return false;
}
//terminate thread
if(TerminateThread(ThreadGetHandle((DWORD)threadid), (DWORD)exitcode) != 0)
{
GuiUpdateAllViews();
dputs(QT_TRANSLATE_NOOP("DBG", "Thread terminated"));
return true;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Error terminating thread!"));
return false;
}
bool cbDebugSuspendAllThreads(int argc, char* argv[])
{
dprintf(QT_TRANSLATE_NOOP("DBG", "%d/%d thread(s) suspended\n"), ThreadSuspendAll(), ThreadGetCount());
GuiUpdateAllViews();
return true;
}
bool cbDebugResumeAllThreads(int argc, char* argv[])
{
dprintf(QT_TRANSLATE_NOOP("DBG", "%d/%d thread(s) resumed\n"), ThreadResumeAll(), ThreadGetCount());
GuiUpdateAllViews();
return true;
}
bool cbDebugSetPriority(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
duint threadid;
if(!valfromstring(argv[1], &threadid, false))
return false;
duint priority;
if(!valfromstring(argv[2], &priority))
{
if(_strcmpi(argv[2], "Normal") == 0)
priority = THREAD_PRIORITY_NORMAL;
else if(_strcmpi(argv[2], "AboveNormal") == 0)
priority = THREAD_PRIORITY_ABOVE_NORMAL;
else if(_strcmpi(argv[2], "TimeCritical") == 0)
priority = THREAD_PRIORITY_TIME_CRITICAL;
else if(_strcmpi(argv[2], "Idle") == 0)
priority = THREAD_PRIORITY_IDLE;
else if(_strcmpi(argv[2], "BelowNormal") == 0)
priority = THREAD_PRIORITY_BELOW_NORMAL;
else if(_strcmpi(argv[2], "Highest") == 0)
priority = THREAD_PRIORITY_HIGHEST;
else if(_strcmpi(argv[2], "Lowest") == 0)
priority = THREAD_PRIORITY_LOWEST;
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Unknown priority value, read the help!"));
return false;
}
}
else
{
switch((int)priority) //check if the priority value is valid
{
case THREAD_PRIORITY_NORMAL:
case THREAD_PRIORITY_ABOVE_NORMAL:
case THREAD_PRIORITY_TIME_CRITICAL:
case THREAD_PRIORITY_IDLE:
case THREAD_PRIORITY_BELOW_NORMAL:
case THREAD_PRIORITY_HIGHEST:
case THREAD_PRIORITY_LOWEST:
break;
default:
dputs(QT_TRANSLATE_NOOP("DBG", "Unknown priority value, read the help!"));
return false;
}
}
if(!ThreadIsValid((DWORD)threadid)) //check if the thread is valid
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %s\n"), formatpidtid((DWORD)threadid).c_str());
return false;
}
//set thread priority
if(SetThreadPriority(ThreadGetHandle((DWORD)threadid), (int)priority) == 0)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error setting thread priority"));
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Thread priority changed!"));
GuiUpdateAllViews();
return true;
}
bool cbDebugSetthreadname(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint threadid;
if(!valfromstring(argv[1], &threadid, false))
return false;
THREADINFO info;
if(!ThreadGetInfo((DWORD)threadid, info))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %s\n"), formatpidtid((DWORD)threadid).c_str());
return false;
}
auto newname = argc > 2 ? argv[2] : "";
if(!ThreadSetName((DWORD)threadid, newname))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to change the name for thread %s\n"), formatpidtid((DWORD)threadid).c_str());
return false;
}
if(!*info.threadName)
dprintf(QT_TRANSLATE_NOOP("DBG", "Thread name set to \"%s\"!\n"), newname);
else
dprintf(QT_TRANSLATE_NOOP("DBG", "Thread name changed from \"%s\" to \"%s\"!\n"), info.threadName, newname);
GuiUpdateAllViews();
return true;
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-thread-control.h | #pragma once
#include "command.h"
bool cbDebugCreatethread(int argc, char* argv[]);
bool cbDebugSwitchthread(int argc, char* argv[]);
bool cbDebugSuspendthread(int argc, char* argv[]);
bool cbDebugResumethread(int argc, char* argv[]);
bool cbDebugKillthread(int argc, char* argv[]);
bool cbDebugSuspendAllThreads(int argc, char* argv[]);
bool cbDebugResumeAllThreads(int argc, char* argv[]);
bool cbDebugSetPriority(int argc, char* argv[]);
bool cbDebugSetthreadname(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-tracing.cpp | #include "cmd-tracing.h"
#include "debugger.h"
#include "threading.h"
#include "module.h"
#include "console.h"
#include "cmd-debug-control.h"
#include "value.h"
#include "variable.h"
#include "TraceRecord.h"
extern std::vector<std::pair<duint, duint>> RunToUserCodeBreakpoints;
static bool genericConditionalTraceCommand(TITANCBSTEP callback, STEPFUNCTION stepFunction, int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
if(dbgtraceactive())
{
dputs(QT_TRANSLATE_NOOP("DBG", "Trace already active"));
return false;
}
if(dbgisrunning())
{
dputs(QT_TRANSLATE_NOOP("DBG", "Cannot start a trace when running, pause execution first."));
return false;
}
duint maxCount;
if(!BridgeSettingGetUint("Engine", "MaxTraceCount", &maxCount) || !maxCount)
maxCount = 50000;
if(argc > 2 && !valfromstring(argv[2], &maxCount, false))
return false;
if(!dbgsettracecondition(*argv[1] ? argv[1] : "0", maxCount))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid expression \"%s\"\n"), argv[1]);
return false;
}
stepFunction(callback);
return cbDebugRunInternal(1, argv, history_clear);
}
static bool conditionalTraceIntoCommand(TITANCBSTEP callback, int argc, char* argv[])
{
return genericConditionalTraceCommand(callback, StepIntoWow64, argc, argv);
}
static bool conditionalTraceOverCommand(TITANCBSTEP callback, int argc, char* argv[])
{
return genericConditionalTraceCommand(callback, StepOverWrapper, argc, argv);
}
bool cbDebugTraceIntoConditional(int argc, char* argv[])
{
return conditionalTraceIntoCommand(cbTraceIntoConditionalStep, argc, argv);
}
bool cbDebugTraceOverConditional(int argc, char* argv[])
{
return conditionalTraceOverCommand(cbTraceOverConditionalStep, argc, argv);
}
bool cbDebugTraceIntoBeyondTraceRecord(int argc, char* argv[])
{
if(argc == 1)
{
const char* new_argv[] = { "tibt", "0" };
return conditionalTraceIntoCommand(cbTraceIntoBeyondTraceRecordStep, 2, (char**)new_argv);
}
else
return conditionalTraceIntoCommand(cbTraceIntoBeyondTraceRecordStep, argc, argv);
}
bool cbDebugTraceOverBeyondTraceRecord(int argc, char* argv[])
{
if(argc == 1)
{
const char* new_argv[] = { "tobt", "0" };
return conditionalTraceOverCommand(cbTraceOverBeyondTraceRecordStep, 2, (char**)new_argv);
}
else
return conditionalTraceOverCommand(cbTraceOverBeyondTraceRecordStep, argc, argv);
}
bool cbDebugTraceIntoIntoTraceRecord(int argc, char* argv[])
{
if(argc == 1)
{
const char* new_argv[] = { "tiit", "0" };
return conditionalTraceIntoCommand(cbTraceIntoIntoTraceRecordStep, 2, (char**)new_argv);
}
else
return conditionalTraceIntoCommand(cbTraceIntoIntoTraceRecordStep, argc, argv);
}
bool cbDebugTraceOverIntoTraceRecord(int argc, char* argv[])
{
if(argc == 1)
{
const char* new_argv[] = { "toit", "0" };
return conditionalTraceOverCommand(cbTraceOverIntoTraceRecordStep, 2, (char**)new_argv);
}
else
return conditionalTraceOverCommand(cbTraceOverIntoTraceRecordStep, argc, argv);
}
bool cbDebugRunToParty(int argc, char* argv[])
{
if(dbgisrunning())
{
dputs(QT_TRANSLATE_NOOP("DBG", "Cannot start a trace when running, pause execution first."));
return false;
}
EXCLUSIVE_ACQUIRE(LockRunToUserCode);
if(!RunToUserCodeBreakpoints.empty())
{
dputs(QT_TRANSLATE_NOOP("DBG", "Run to party is busy.\n"));
return false;
}
if(IsArgumentsLessThan(argc, 2))
return false;
int party = atoi(argv[1]); // party is a signed integer
ModEnum([party](const MODINFO & i)
{
if(i.party == party)
{
for(auto j : i.sections)
{
BREAKPOINT bp;
if(!BpGet(j.addr, BPMEMORY, nullptr, &bp))
{
size_t size = DbgMemGetPageSize(j.addr);
RunToUserCodeBreakpoints.push_back(std::make_pair(j.addr, size));
SetMemoryBPXEx(j.addr, size, UE_MEMORY_EXECUTE, false, cbRunToUserCodeBreakpoint);
}
}
}
});
return cbDebugRunInternal(1, argv, history_clear);
}
bool cbDebugRunToUserCode(int argc, char* argv[])
{
const char* newargv[] = { "RunToParty", "0" };
return cbDebugRunToParty(2, (char**)newargv);
}
bool cbDebugTraceSetLog(int argc, char* argv[])
{
auto text = argc > 1 ? argv[1] : "";
auto condition = argc > 2 ? argv[2] : "";
if(!dbgsettracelog(condition, text))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid expression \"%s\"\n"), condition);
return false;
}
return true;
}
bool cbDebugTraceSetCommand(int argc, char* argv[])
{
auto text = argc > 1 ? argv[1] : "";
auto condition = argc > 2 ? argv[2] : "";
if(!dbgsettracecmd(condition, text))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid expression \"%s\"\n"), condition);
return false;
}
return true;
}
bool cbDebugTraceSetLogFile(int argc, char* argv[])
{
auto fileName = argc > 1 ? argv[1] : "";
return dbgsettracelogfile(fileName);
}
bool cbDebugStartTraceRecording(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
return TraceRecord.enableTraceRecording(true, argv[1]);
}
bool cbDebugStopTraceRecording(int argc, char* argv[])
{
return TraceRecord.enableTraceRecording(false, nullptr);
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-tracing.h | #pragma once
#include "command.h"
bool cbDebugTraceIntoConditional(int argc, char* argv[]);
bool cbDebugTraceOverConditional(int argc, char* argv[]);
bool cbDebugTraceIntoBeyondTraceRecord(int argc, char* argv[]);
bool cbDebugTraceOverBeyondTraceRecord(int argc, char* argv[]);
bool cbDebugTraceIntoIntoTraceRecord(int argc, char* argv[]);
bool cbDebugTraceOverIntoTraceRecord(int argc, char* argv[]);
bool cbDebugRunToParty(int argc, char* argv[]);
bool cbDebugRunToUserCode(int argc, char* argv[]);
bool cbDebugTraceSetLog(int argc, char* argv[]);
bool cbDebugTraceSetCommand(int argc, char* argv[]);
bool cbDebugTraceSetLogFile(int argc, char* argv[]);
bool cbDebugStartTraceRecording(int argc, char* argv[]);
bool cbDebugStopTraceRecording(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-types.cpp | #include "cmd-types.h"
#include "console.h"
#include "encodemap.h"
#include "value.h"
#include "types.h"
#include "memory.h"
#include "variable.h"
#include "filehelper.h"
#include "label.h"
using namespace Types;
static bool cbInstrDataGeneric(ENCODETYPE type, int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint addr;
if(!valfromstring(argv[1], &addr, false))
return false;
duint size = 1;
if(argc >= 3)
if(!valfromstring(argv[2], &size, false))
return false;
bool created;
if(!EncodeMapSetType(addr, size, type, &created))
{
dputs(QT_TRANSLATE_NOOP("DBG", "EncodeMapSetType failed..."));
return false;
}
if(created)
DbgCmdExec("disasm dis.sel()");
else
GuiUpdateDisassemblyView();
return false;
}
bool cbInstrDataUnknown(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_unknown, argc, argv);
}
bool cbInstrDataByte(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_byte, argc, argv);
}
bool cbInstrDataWord(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_word, argc, argv);
}
bool cbInstrDataDword(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_dword, argc, argv);
}
bool cbInstrDataFword(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_fword, argc, argv);
}
bool cbInstrDataQword(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_qword, argc, argv);
}
bool cbInstrDataTbyte(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_tbyte, argc, argv);
}
bool cbInstrDataOword(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_oword, argc, argv);
}
bool cbInstrDataMmword(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_mmword, argc, argv);
}
bool cbInstrDataXmmword(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_xmmword, argc, argv);
}
bool cbInstrDataYmmword(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_ymmword, argc, argv);
}
bool cbInstrDataFloat(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_real4, argc, argv);
}
bool cbInstrDataDouble(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_real8, argc, argv);
}
bool cbInstrDataLongdouble(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_real10, argc, argv);
}
bool cbInstrDataAscii(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_ascii, argc, argv);
}
bool cbInstrDataUnicode(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_unicode, argc, argv);
}
bool cbInstrDataCode(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_code, argc, argv);
}
bool cbInstrDataJunk(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_junk, argc, argv);
}
bool cbInstrDataMiddle(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_middle, argc, argv);
}
#define towner "cmd"
bool cbInstrAddType(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
if(!AddType(towner, argv[1], argv[2]))
{
dputs(QT_TRANSLATE_NOOP("DBG", "AddType failed"));
return false;
}
dprintf_untranslated("typedef %s %s;\n", argv[2], argv[1]);
return true;
}
bool cbInstrAddStruct(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
if(!AddStruct(towner, argv[1]))
{
dputs(QT_TRANSLATE_NOOP("DBG", "AddStruct failed"));
return false;
}
dprintf_untranslated("struct %s;\n", argv[1]);
return true;
}
bool cbInstrAddUnion(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
if(!AddUnion(towner, argv[1]))
{
dputs(QT_TRANSLATE_NOOP("DBG", "AddUnion failed"));
return false;
}
dprintf_untranslated("union %s;\n", argv[1]);
return true;
}
bool cbInstrAddMember(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 4))
return false;
auto parent = argv[1];
auto type = argv[2];
auto name = argv[3];
int arrsize = 0, offset = -1;
if(argc > 4)
{
duint value;
if(!valfromstring(argv[4], &value, false))
return false;
arrsize = int(value);
if(argc > 5)
{
if(!valfromstring(argv[5], &value, false))
return false;
offset = int(value);
}
}
if(!AddMember(parent, type, name, arrsize, offset))
{
dputs(QT_TRANSLATE_NOOP("DBG", "AddMember failed"));
return false;
}
dprintf_untranslated("%s: %s %s", parent, type, name);
if(arrsize > 0)
dprintf_untranslated("[%d]", arrsize);
if(offset >= 0)
dprintf_untranslated(" (offset: %d)", offset);
dputs_untranslated(";");
return true;
}
bool cbInstrAppendMember(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
auto type = argv[1];
auto name = argv[2];
int arrsize = 0, offset = -1;
if(argc > 3)
{
duint value;
if(!valfromstring(argv[3], &value, false))
return false;
arrsize = int(value);
if(argc > 4)
{
if(!valfromstring(argv[4], &value, false))
return false;
offset = int(value);
}
}
if(!AppendMember(type, name, arrsize, offset))
{
dputs(QT_TRANSLATE_NOOP("DBG", "AppendMember failed"));
return false;
}
dprintf_untranslated("%s %s", type, name);
if(arrsize > 0)
dprintf_untranslated("[%d]", arrsize);
if(offset >= 0)
dprintf_untranslated(" (offset: %d)", offset);
dputs_untranslated(";");
return true;
}
bool cbInstrAddFunction(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
auto name = argv[1];
auto rettype = argv[2];
auto callconv = Cdecl;
auto noreturn = false;
if(argc > 3)
{
if(scmp(argv[3], "cdecl"))
callconv = Cdecl;
else if(scmp(argv[3], "stdcall"))
callconv = Stdcall;
else if(scmp(argv[3], "thiscall"))
callconv = Thiscall;
else if(scmp(argv[3], "delphi"))
callconv = Delphi;
else
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Unknown calling convention \"%s\"\n"), argv[3]);
return false;
}
if(argc > 4)
{
duint value;
if(!valfromstring(argv[4], &value, false))
return false;
noreturn = value != 0;
}
}
if(!AddFunction(towner, name, rettype, callconv, noreturn))
{
dputs(QT_TRANSLATE_NOOP("DBG", "AddFunction failed"));
return false;
}
dprintf_untranslated("%s %s();\n", rettype, name);
return true;
}
bool cbInstrAddArg(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 4))
return false;
if(!AddArg(argv[1], argv[2], argv[3]))
{
dputs(QT_TRANSLATE_NOOP("DBG", "AddArg failed"));
return false;
}
dprintf_untranslated("%s: %s %s;\n", argv[1], argv[2], argv[3]);
return true;
}
bool cbInstrAppendArg(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
if(!AppendArg(argv[1], argv[2]))
{
dputs(QT_TRANSLATE_NOOP("DBG", "AppendArg failed"));
return false;
}
dprintf_untranslated("%s %s;\n", argv[1], argv[2]);
return true;
}
bool cbInstrSizeofType(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
auto size = SizeofType(argv[1]);
if(!size)
{
dputs(QT_TRANSLATE_NOOP("DBG", "SizeofType failed"));
return false;
}
dprintf_untranslated("sizeof(%s) = %d\n", argv[1], size);
varset("$result", size, false);
return true;
}
struct PrintVisitor : TypeManager::Visitor
{
explicit PrintVisitor(duint data = 0, int maxPtrDepth = 0)
: mAddr(data), mMaxPtrDepth(maxPtrDepth) { }
template<typename T>
static String basicPrint(void* data, const char* format)
{
return StringUtils::sprintf(format, *(T*)data);
}
template<typename T, typename U>
static String basicPrint(void* data, const char* format)
{
return StringUtils::sprintf(format, *(T*)data, *(U*)data);
}
static bool cbPrintPrimitive(const TYPEDESCRIPTOR* type, char* dest, size_t* destCount)
{
if(!type->addr)
{
*dest = '\0';
return true;
}
String valueStr;
Memory<unsigned char*> data(type->size);
if(MemRead(type->addr + type->offset, data(), data.size()))
{
if(type->reverse)
std::reverse(data(), data() + data.size());
switch(Primitive(type->id))
{
case Void:
valueStr.clear();
break;
case Int8:
valueStr += StringUtils::sprintf("0x%02X, '%s'", *(unsigned char*)data(), StringUtils::Escape(*(char*)data()).c_str());
break;
case Uint8:
valueStr += basicPrint<unsigned char, unsigned char>(data(), "0x%02X, %d");
break;
case Int16:
valueStr += basicPrint<unsigned short, short>(data(), "0x%04X, %d");
break;
case Uint16:
valueStr += basicPrint<unsigned short, unsigned short>(data(), "0x%04X, %u");
break;
case Int32:
valueStr += basicPrint<unsigned int, int>(data(), "0x%08X, %d");
break;
case Uint32:
valueStr += basicPrint<unsigned int, unsigned int>(data(), "0x%08X, %u");
break;
case Int64:
valueStr += basicPrint<unsigned long long, long long>(data(), "0x%016llX, %lld");
break;
case Uint64:
valueStr += basicPrint<unsigned long long, unsigned long long>(data(), "0x%016llX, %llu");
break;
case Dsint:
#ifdef _WIN64
valueStr += basicPrint<duint, dsint>(data(), "0x%016llX, %lld");
#else
valueStr += basicPrint<duint, dsint>(data(), "0x%08X, %d");
#endif //_WIN64
break;
case Duint:
#ifdef _WIN64
valueStr += basicPrint<duint, duint>(data(), "0x%016llX, %llu");
#else
valueStr += basicPrint<duint, duint>(data(), "0x%08X, %u");
#endif //_WIN64
break;
case Float:
valueStr += basicPrint<float>(data(), "%f");
break;
case Double:
valueStr += basicPrint<double>(data(), "%f");
break;
case Pointer:
valueStr += basicPrint<void*>(data(), "0x%p");
break;
case PtrString:
{
valueStr += basicPrint<char*>(data(), "0x%p ");
Memory<char*> strdata(MAX_STRING_SIZE + 1);
if(MemRead(*(duint*)data(), strdata(), strdata.size() - 1))
{
valueStr += "\"";
valueStr += StringUtils::Escape(strdata());
valueStr.push_back('\"');
}
else
valueStr += "???";
}
break;
case PtrWString:
{
valueStr += basicPrint<wchar_t*>(data(), "0x%p ");
Memory<wchar_t*> strdata(MAX_STRING_SIZE * 2 + 2);
if(MemRead(*(duint*)data(), strdata(), strdata.size() - 2))
{
valueStr += "L\"";
valueStr += StringUtils::Utf16ToUtf8(strdata());
valueStr.push_back('\"');
}
else
valueStr += "???";
}
break;
default:
return false;
}
}
else
valueStr = "???";
if(*destCount <= valueStr.size())
{
*destCount = valueStr.size() + 1;
return false;
}
strcpy_s(dest, *destCount, valueStr.c_str());
return true;
}
bool visitType(const Member & member, const Type & type) override
{
if(!mParents.empty() && parent().type == Parent::Union)
mOffset = parent().offset;
String tname;
auto ptype = mParents.empty() ? Parent::Struct : parent().type;
if(ptype == Parent::Array)
{
tname = StringUtils::sprintf("%s[%u]", member.name.c_str(), parent().index++);
}
else
{
tname = StringUtils::sprintf("%s %s", type.name.c_str(), member.name.c_str());
// Prepend struct/union to pointer types
if(!type.pointto.empty())
{
auto ptrname = StructUnionPtrType(type.pointto);
if(!ptrname.empty())
tname = ptrname + " " + tname;
}
}
std::string path;
for(size_t i = 0; i < mPath.size(); i++)
{
if(ptype == Parent::Array && i + 1 == mPath.size())
break;
path.append(mPath[i]);
}
path.append(member.name);
auto ptr = mAddr + mOffset;
if(MemIsValidReadPtr(ptr))
{
if(!LabelGet(ptr, nullptr) && (parent().index == 1 || ptype != Parent::Array))
LabelSet(ptr, path.c_str(), false, true);
}
TYPEDESCRIPTOR td;
td.expanded = false;
td.reverse = false;
td.name = tname.c_str();
td.addr = mAddr;
td.offset = mOffset;
td.id = type.primitive;
td.size = type.size;
td.callback = cbPrintPrimitive;
td.userdata = nullptr;
mNode = GuiTypeAddNode(mParents.empty() ? nullptr : parent().node, &td);
mOffset += type.size;
return true;
}
bool visitStructUnion(const Member & member, const StructUnion & type) override
{
if(!mParents.empty() && parent().type == Parent::Type::Union)
mOffset = parent().offset;
String tname = StringUtils::sprintf("%s %s %s", type.isunion ? "union" : "struct", type.name.c_str(), member.name.c_str());
TYPEDESCRIPTOR td;
td.expanded = true;
td.reverse = false;
td.name = tname.c_str();
td.addr = mAddr;
td.offset = mOffset;
td.id = Void;
td.size = type.size;
td.callback = nullptr;
td.userdata = nullptr;
auto node = GuiTypeAddNode(mParents.empty() ? nullptr : parent().node, &td);
mPath.push_back((member.name == "visit" ? type.name : member.name) + ".");
mParents.push_back(Parent(type.isunion ? Parent::Union : Parent::Struct));
parent().node = node;
parent().size = td.size;
parent().offset = mOffset;
return true;
}
bool visitArray(const Member & member) override
{
String tname = StringUtils::sprintf("%s %s[%d]", member.type.c_str(), member.name.c_str(), member.arrsize);
TYPEDESCRIPTOR td;
td.expanded = member.arrsize <= 5;
td.reverse = false;
td.name = tname.c_str();
td.addr = mAddr;
td.offset = mOffset;
td.id = Void;
td.size = member.arrsize * SizeofType(member.type);
td.callback = nullptr;
td.userdata = nullptr;
auto node = GuiTypeAddNode(mParents.empty() ? nullptr : parent().node, &td);
mPath.push_back(member.name + ".");
mParents.push_back(Parent(Parent::Array));
parent().node = node;
parent().size = td.size;
return true;
}
bool visitPtr(const Member & member, const Type & type) override
{
auto offset = mOffset;
auto res = visitType(member, type); //print the pointer value
if(mPtrDepth >= mMaxPtrDepth)
return false;
duint value = 0;
if(!mAddr || !MemRead(mAddr + offset, &value, sizeof(value)))
return false;
mPath.push_back(member.name + "->");
mParents.push_back(Parent(Parent::Pointer));
parent().offset = mOffset;
parent().addr = mAddr;
parent().node = mNode;
parent().size = type.size;
mOffset = 0;
mAddr = value;
mPtrDepth++;
return res;
}
bool visitBack(const Member & member) override
{
if(parent().type == Parent::Pointer)
{
mOffset = parent().offset;
mAddr = parent().addr;
mPtrDepth--;
}
else if(parent().type == Parent::Union)
{
mOffset = parent().offset + parent().size;
}
mParents.pop_back();
mPath.pop_back();
return true;
}
private:
struct Parent
{
enum Type
{
Struct,
Union,
Array,
Pointer
};
Type type;
unsigned int index = 0;
duint addr = 0;
duint offset = 0;
void* node = nullptr;
int size = 0;
explicit Parent(Type type)
: type(type) { }
};
Parent & parent()
{
return mParents[mParents.size() - 1];
}
std::vector<Parent> mParents;
duint mOffset = 0;
duint mAddr = 0;
int mPtrDepth = 0;
int mMaxPtrDepth = 0;
void* mNode = nullptr;
std::vector<String> mPath;
};
bool cbInstrVisitType(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
auto type = argv[1];
auto name = "visit";
duint addr = 0;
auto maxPtrDepth = 0;
if(argc > 2)
{
if(!valfromstring(argv[2], &addr, false))
return false;
if(argc > 3)
{
duint value;
if(!valfromstring(argv[3], &value, false))
return false;
maxPtrDepth = int(value);
if(argc > 4)
name = argv[4];
}
}
PrintVisitor visitor(addr, maxPtrDepth);
if(!VisitType(type, name, visitor))
{
dputs(QT_TRANSLATE_NOOP("DBG", "VisitType failed"));
return false;
}
GuiUpdateAllViews();
dputs(QT_TRANSLATE_NOOP("DBG", "Done!"));
return true;
}
bool cbInstrClearTypes(int argc, char* argv[])
{
auto owner = towner;
if(argc > 1)
owner = argv[1];
ClearTypes(owner);
return true;
}
bool cbInstrRemoveType(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
if(!RemoveType(argv[1]))
{
dputs(QT_TRANSLATE_NOOP("DBG", "RemoveType failed"));
return false;
}
dprintf(QT_TRANSLATE_NOOP("DBG", "Type %s removed\n"), argv[1]);
return true;
}
bool cbInstrEnumTypes(int argc, char* argv[])
{
std::vector<TypeManager::Summary> typeList;
EnumTypes(typeList);
for(auto & type : typeList)
{
if(type.owner.empty())
type.owner.assign("x64dbg");
dprintf_untranslated("%s: %s %s, sizeof(%s) = %d\n", type.owner.c_str(), type.kind.c_str(), type.name.c_str(), type.name.c_str(), type.size);
}
return true;
}
bool cbInstrLoadTypes(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
auto owner = FileHelper::GetFileName(argv[1]);
ClearTypes(owner);
if(!LoadTypesFile(argv[1], owner))
{
dputs(QT_TRANSLATE_NOOP("DBG", "LoadTypes failed"));
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Types loaded"));
return true;
}
bool cbInstrParseTypes(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
auto owner = FileHelper::GetFileName(argv[1]);
ClearTypes(owner);
std::string data;
if(!FileHelper::ReadAllText(argv[1], data))
{
dputs("failed to read file!");
return false;
}
if(!ParseTypes(data, owner))
return false;
dprintf("Parsed header: %s\n", argv[1]);
return true;
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-types.h | #pragma once
#include "command.h"
bool cbInstrDataUnknown(int argc, char* argv[]);
bool cbInstrDataByte(int argc, char* argv[]);
bool cbInstrDataWord(int argc, char* argv[]);
bool cbInstrDataDword(int argc, char* argv[]);
bool cbInstrDataFword(int argc, char* argv[]);
bool cbInstrDataQword(int argc, char* argv[]);
bool cbInstrDataTbyte(int argc, char* argv[]);
bool cbInstrDataOword(int argc, char* argv[]);
bool cbInstrDataMmword(int argc, char* argv[]);
bool cbInstrDataXmmword(int argc, char* argv[]);
bool cbInstrDataYmmword(int argc, char* argv[]);
bool cbInstrDataFloat(int argc, char* argv[]);
bool cbInstrDataDouble(int argc, char* argv[]);
bool cbInstrDataLongdouble(int argc, char* argv[]);
bool cbInstrDataAscii(int argc, char* argv[]);
bool cbInstrDataUnicode(int argc, char* argv[]);
bool cbInstrDataCode(int argc, char* argv[]);
bool cbInstrDataJunk(int argc, char* argv[]);
bool cbInstrDataMiddle(int argc, char* argv[]);
bool cbInstrAddType(int argc, char* argv[]);
bool cbInstrAddStruct(int argc, char* argv[]);
bool cbInstrAddUnion(int argc, char* argv[]);
bool cbInstrAddMember(int argc, char* argv[]);
bool cbInstrAppendMember(int argc, char* argv[]);
bool cbInstrAddFunction(int argc, char* argv[]);
bool cbInstrAddArg(int argc, char* argv[]);
bool cbInstrAppendArg(int argc, char* argv[]);
bool cbInstrSizeofType(int argc, char* argv[]);
bool cbInstrVisitType(int argc, char* argv[]);
bool cbInstrClearTypes(int argc, char* argv[]);
bool cbInstrRemoveType(int argc, char* argv[]);
bool cbInstrEnumTypes(int argc, char* argv[]);
bool cbInstrLoadTypes(int argc, char* argv[]);
bool cbInstrParseTypes(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-undocumented.cpp | #include "cmd-undocumented.h"
#include "console.h"
#include "function.h"
#include "bookmark.h"
#include "label.h"
#include "comment.h"
#include "debugger.h"
#include "variable.h"
#include "loop.h"
#include "zydis_wrapper.h"
#include "mnemonichelp.h"
#include "value.h"
#include "symbolinfo.h"
#include "argument.h"
#include "expressionparser.h"
bool cbBadCmd(int argc, char* argv[])
{
duint value = 0;
int valsize = 0;
bool isvar = false;
bool hexonly = false;
bool silent = false;
bool baseonly = false;
bool allowassign = true;
ExpressionParser parser(argv[0]);
ExpressionParser::EvalValue evalue(0);
if(parser.Calculate(evalue, valuesignedcalc(), allowassign, silent, baseonly, &valsize, &isvar, &hexonly))
{
if(evalue.isString)
{
dputs_untranslated(StringUtils::Escape(evalue.data).c_str());
}
else if(evalue.DoEvaluate(value, silent, baseonly, &valsize, &isvar, &hexonly))
{
varset("$ans", value, true);
if(valsize)
valsize *= 2;
else
valsize = 1;
char format_str[deflen] = "";
auto symbolic = SymGetSymbolicName(value, false);
if(symbolic.length())
symbolic = " " + symbolic;
if(isvar) // and *cmd!='.' and *cmd!='x') //prevent stupid 0=0 stuff
{
if(value > 9 && !hexonly)
{
if(!valuesignedcalc()) //signed numbers
#ifdef _WIN64
sprintf_s(format_str, "%%s=%%.%dllX (%%llud)%%s\n", valsize); // TODO: This and the following statements use "%llX" for a "int"-typed variable. Maybe we can use "%X" everywhere?
#else //x86
sprintf_s(format_str, "%%s=%%.%dX (%%ud)%%s\n", valsize);
#endif //_WIN64
else
#ifdef _WIN64
sprintf_s(format_str, "%%s=%%.%dllX (%%lld)%%s\n", valsize);
#else //x86
sprintf_s(format_str, "%%s=%%.%dX (%%d)%%s\n", valsize);
#endif //_WIN64
dprintf_untranslated(format_str, *argv, value, value, symbolic.c_str());
}
else
{
sprintf_s(format_str, "%%s=%%.%dX%%s\n", valsize);
dprintf_untranslated(format_str, *argv, value, symbolic.c_str());
}
}
else
{
if(value > 9 && !hexonly)
{
if(!valuesignedcalc()) //signed numbers
#ifdef _WIN64
sprintf_s(format_str, "%%s=%%.%dllX (%%llud)%%s\n", valsize);
#else //x86
sprintf_s(format_str, "%%s=%%.%dX (%%ud)%%s\n", valsize);
#endif //_WIN64
else
#ifdef _WIN64
sprintf_s(format_str, "%%s=%%.%dllX (%%lld)%%s\n", valsize);
#else //x86
sprintf_s(format_str, "%%s=%%.%dX (%%d)%%s\n", valsize);
#endif //_WIN64
#ifdef _WIN64
sprintf_s(format_str, "%%.%dllX (%%llud)%%s\n", valsize);
#else //x86
sprintf_s(format_str, "%%.%dX (%%ud)%%s\n", valsize);
#endif //_WIN64
dprintf_untranslated(format_str, value, value, symbolic.c_str());
}
else
{
#ifdef _WIN64
sprintf_s(format_str, "%%.%dllX%%s\n", valsize);
#else //x86
sprintf_s(format_str, "%%.%dX%%s\n", valsize);
#endif //_WIN64
dprintf_untranslated(format_str, value, symbolic.c_str());
}
}
}
else //unknown command
{
dprintf_untranslated("Unknown command/expression: \"%s\"\n", *argv);
return false;
}
}
return true;
}
bool cbDebugBenchmark(int argc, char* argv[])
{
duint addr = MemFindBaseAddr(GetContextDataEx(hActiveThread, UE_CIP), 0);
DWORD ticks = GetTickCount();
for(duint i = addr; i < addr + 100000; i++)
{
CommentSet(i, "test", false);
LabelSet(i, "test", false);
BookmarkSet(i, false);
FunctionAdd(i, i, false);
ArgumentAdd(i, i, false);
LoopAdd(i, i, false);
}
dprintf_untranslated("%ums\n", GetTickCount() - ticks);
return true;
}
bool cbInstrSetstr(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
varnew(argv[1], 0, VAR_USER);
if(!vargettype(argv[1], 0))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such variable \"%s\"!\n"), argv[1]);
return false;
}
if(!varset(argv[1], argv[2], false))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to set variable \"%s\"!\n"), argv[1]);
return false;
}
cmddirectexec(StringUtils::sprintf("getstr \"%s\"", argv[1]).c_str());
return true;
}
bool cbInstrGetstr(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
VAR_VALUE_TYPE valtype;
if(!vargettype(argv[1], 0, &valtype))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such variable \"%s\"!\n"), argv[1]);
return false;
}
if(valtype != VAR_STRING)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Variable \"%s\" is not a string!\n"), argv[1]);
return false;
}
int size;
if(!varget(argv[1], (char*)0, &size, 0) || !size)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to get variable size \"%s\"!\n"), argv[1]);
return false;
}
Memory<char*> string(size + 1, "cbInstrGetstr:string");
if(!varget(argv[1], string(), &size, 0))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to get variable data \"%s\"!\n"), argv[1]);
return false;
}
dprintf_untranslated("%s=\"%s\"\n", argv[1], string());
return true;
}
bool cbInstrCopystr(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
VAR_VALUE_TYPE valtype;
if(!vargettype(argv[2], 0, &valtype))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such variable \"%s\"!\n"), argv[2]);
return false;
}
if(valtype != VAR_STRING)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Variable \"%s\" is not a string!\n"), argv[2]);
return false;
}
int size;
if(!varget(argv[2], (char*)0, &size, 0) || !size)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to get variable size \"%s\"!\n"), argv[2]);
return false;
}
Memory<char*> string(size + 1, "cbInstrGetstr:string");
if(!varget(argv[2], string(), &size, 0))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to get variable data \"%s\"!\n"), argv[2]);
return false;
}
duint addr;
if(!valfromstring(argv[1], &addr))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address \"%s\"!\n"), argv[1]);
return false;
}
if(!MemPatch(addr, string(), strlen(string())))
{
dputs(QT_TRANSLATE_NOOP("DBG", "MemPatch failed!"));
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "String written!"));
GuiUpdateAllViews();
GuiUpdatePatches();
return true;
}
bool cbInstrZydis(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr) || !MemIsValidReadPtr(addr))
{
dprintf_untranslated("Invalid address \"%s\"\n", argv[1]);
return false;
}
unsigned char data[16];
if(!MemRead(addr, data, sizeof(data)))
{
dprintf_untranslated("Could not read memory at %p\n", addr);
return false;
}
if(argc > 2)
if(!valfromstring(argv[2], &addr, false))
return false;
Zydis cp;
if(!cp.Disassemble(addr, data))
{
dputs_untranslated("Failed to disassemble!\n");
return false;
}
auto instr = cp.GetInstr();
int argcount = instr->operandCount;
dputs_untranslated(cp.InstructionText(true).c_str());
dprintf_untranslated("prefix size: %d\n", instr->raw.prefixes.count);
if(instr->attributes & ZYDIS_ATTRIB_HAS_REX)
dprintf_untranslated("rex.W: %d, rex.R: %d, rex.X: %d, rex.B: %d, rex.data: %02x\n", instr->raw.rex.W, instr->raw.rex.R, instr->raw.rex.X, instr->raw.rex.B, instr->raw.rex.data[0]);
dprintf_untranslated("disp.offset: %d, disp.size: %d\n", instr->raw.disp.offset, instr->raw.disp.size);
dprintf_untranslated("imm[0].offset: %d, imm[0].size: %d\n", instr->raw.imm[0].offset, instr->raw.imm[0].size);
dprintf_untranslated("imm[1].offset: %d, imm[1].size: %d\n", instr->raw.imm[1].offset, instr->raw.imm[1].size);
dprintf_untranslated("size: %d, id: %d, opcount: %d\n", cp.Size(), cp.GetId(), instr->operandCount);
auto rwstr = [](uint8_t action)
{
switch(action)
{
case ZYDIS_OPERAND_ACTION_READ:
case ZYDIS_OPERAND_ACTION_CONDREAD:
return "read";
case ZYDIS_OPERAND_ACTION_WRITE:
case ZYDIS_OPERAND_ACTION_CONDWRITE:
return "write";
case ZYDIS_OPERAND_ACTION_READWRITE:
case ZYDIS_OPERAND_ACTION_READ_CONDWRITE:
case ZYDIS_OPERAND_ACTION_CONDREAD_WRITE:
return "read+write";
default:
return "???";
}
};
auto vis = [](uint8_t visibility)
{
switch(visibility)
{
case ZYDIS_OPERAND_VISIBILITY_INVALID:
return "invalid";
case ZYDIS_OPERAND_VISIBILITY_EXPLICIT:
return "explicit";
case ZYDIS_OPERAND_VISIBILITY_IMPLICIT:
return "implicit";
case ZYDIS_OPERAND_VISIBILITY_HIDDEN:
return "hidden";
default:
return "???";
}
};
for(int i = 0; i < argcount; i++)
{
const auto & op = instr->operands[i];
dprintf("operand %d (size: %d, access: %s, visibility: %s) \"%s\", ", i + 1, op.size, rwstr(op.action), vis(op.visibility), cp.OperandText(i).c_str());
switch(op.type)
{
case ZYDIS_OPERAND_TYPE_REGISTER:
dprintf_untranslated("register: %s\n", cp.RegName(op.reg.value));
break;
case ZYDIS_OPERAND_TYPE_IMMEDIATE:
dprintf_untranslated("immediate: 0x%p\n", op.imm.value.u);
break;
case ZYDIS_OPERAND_TYPE_MEMORY:
{
//[base + index * scale +/- disp]
const auto & mem = op.mem;
dprintf_untranslated("memory segment: %s, base: %s, index: %s, scale: %d, displacement: 0x%p\n",
cp.RegName(mem.segment),
cp.RegName(mem.base),
cp.RegName(mem.index),
mem.scale,
mem.disp.value);
}
break;
case ZYDIS_OPERAND_TYPE_POINTER:
dprintf_untranslated("pointer: %X:%p\n", op.ptr.segment, op.ptr.offset);
break;
}
}
return true;
}
bool cbInstrVisualize(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
duint start;
duint maxaddr;
if(!valfromstring(argv[1], &start) || !valfromstring(argv[2], &maxaddr))
{
dputs_untranslated("Invalid arguments!");
return false;
}
//actual algorithm
//make sure to set these options in the INI (rest the default theme of x64dbg):
//DisassemblyBookmarkBackgroundColor = #00FFFF
//DisassemblyBookmarkColor = #000000
//DisassemblyHardwareBreakpointBackgroundColor = #00FF00
//DisassemblyHardwareBreakpointColor = #000000
//DisassemblyBreakpointBackgroundColor = #FF0000
//DisassemblyBreakpointColor = #000000
{
//initialize
Zydis _cp;
duint _base = start;
duint _size = maxaddr - start;
Memory<unsigned char*> _data(_size);
MemRead(_base, _data(), _size);
FunctionClear();
//linear search with some trickery
duint end = 0;
duint jumpback = 0;
for(duint addr = start, fardest = 0; addr < maxaddr;)
{
//update GUI
BpClear();
BookmarkClear();
LabelClear();
SetContextDataEx(hActiveThread, UE_CIP, addr);
if(end)
BpNew(end, true, false, 0, BPNORMAL, 0, nullptr);
if(jumpback)
BookmarkSet(jumpback, false);
if(fardest)
BpNew(fardest, true, false, 0, BPHARDWARE, 0, nullptr);
DebugUpdateGuiAsync(addr, false);
Sleep(300);
//continue algorithm
const unsigned char* curData = (addr >= _base && addr < _base + _size) ? _data() + (addr - _base) : nullptr;
if(_cp.Disassemble(addr, curData, MAX_DISASM_BUFFER))
{
if(addr + _cp.Size() > maxaddr) //we went past the maximum allowed address
break;
if((_cp.IsJump() || _cp.IsLoop()) && _cp.OpCount() && _cp[0].type == ZYDIS_OPERAND_TYPE_IMMEDIATE) //jump
{
duint dest = (duint)_cp[0].imm.value.u;
if(dest >= maxaddr) //jump across function boundaries
{
//currently unused
}
else if(dest > addr && dest > fardest) //save the farthest JXX destination forward
{
fardest = dest;
}
else if(end && dest < end && _cp.GetId() == ZYDIS_MNEMONIC_JMP) //save the last JMP backwards
{
jumpback = addr;
}
}
else if(_cp.IsRet()) //possible function end?
{
end = addr;
if(fardest < addr) //we stop if the farthest JXX destination forward is before this RET
break;
}
addr += _cp.Size();
}
else
addr++;
}
end = end < jumpback ? jumpback : end;
//update GUI
FunctionAdd(start, end, false);
BpClear();
BookmarkClear();
SetContextDataEx(hActiveThread, UE_CIP, start);
DebugUpdateGuiAsync(start, false);
}
return true;
}
bool cbInstrMeminfo(int argc, char* argv[])
{
if(argc < 3)
{
dputs_untranslated("Usage: meminfo a/r, addr[, size]");
return false;
}
duint addr;
if(!valfromstring(argv[2], &addr))
{
dputs_untranslated("Invalid argument");
return false;
}
if(argv[1][0] == 'a')
{
duint size = 1;
if(argc > 3 && !valfromstring(argv[3], &size))
{
dputs_untranslated("Invalid argument");
return false;
}
std::vector<uint8_t> buf;
buf.resize(size);
SIZE_T NumberOfBytesRead = 0;
ReadProcessMemory(fdProcessInfo->hProcess, (const void*)addr, buf.data(), buf.size(), &NumberOfBytesRead);
dprintf_untranslated("Data: %s\n", StringUtils::ToHex(buf.data(), NumberOfBytesRead).c_str());
}
else if(argv[1][0] == 'r')
{
MemUpdateMap();
GuiUpdateMemoryView();
dputs_untranslated("Memory map updated!");
}
return true;
}
bool cbInstrBriefcheck(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint addr;
if(!valfromstring(argv[1], &addr, false))
return false;
duint size;
auto base = DbgMemFindBaseAddr(addr, &size);
if(!base)
return false;
Memory<unsigned char*> buffer(size + 16);
DbgMemRead(base, buffer(), size);
Zydis cp;
std::unordered_set<String> reported;
for(duint i = 0; i < size;)
{
if(!cp.Disassemble(base + i, buffer() + i, 16))
{
i++;
continue;
}
i += cp.Size();
auto mnem = StringUtils::ToLower(cp.Mnemonic());
auto brief = MnemonicHelp::getBriefDescription(mnem.c_str());
if(brief.length() || reported.count(mnem))
continue;
reported.insert(mnem);
dprintf_untranslated("%p: %s\n", cp.Address(), mnem.c_str());
}
return true;
}
bool cbInstrFocusinfo(int argc, char* argv[])
{
ACTIVEVIEW activeView;
GuiGetActiveView(&activeView);
dprintf_untranslated("activeTitle: %s, activeClass: %s\n", activeView.title, activeView.className);
return true;
}
bool cbInstrFlushlog(int argc, char* argv[])
{
GuiFlushLog();
return true;
}
extern char animate_command[deflen];
bool cbInstrAnimateWait(int argc, char* argv[])
{
while(DbgIsDebugging() && dbgisrunning() && animate_command[0] != 0) //while not locked (NOTE: possible deadlock)
{
Sleep(1);
}
return true;
}
#include <lz4/lz4file.h>
bool cbInstrDbdecompress(int argc, char* argv[])
{
if(argc < 2)
{
dprintf_untranslated("Usage: dbdecompress \"c:\\path\\to\\db\"\n");
return false;
}
auto dbFile = StringUtils::Utf8ToUtf16(argv[1]);
if(LZ4_decompress_fileW(dbFile.c_str(), dbFile.c_str()) != LZ4_SUCCESS)
{
dprintf_untranslated("Failed to decompress '%s'\n", argv[1]);
return false;
}
dprintf_untranslated("Decompressed '%s'\n", argv[1]);
return true;
}
bool cbInstrDebugFlags(int argc, char* argv[])
{
if(argc < 2)
{
dprintf_untranslated("Usage: DebugFlags 0xFFFFFFFF\n");
return false;
}
auto debugFlags = (DWORD)DbgValFromString(argv[1]);
dbgsetdebugflags(debugFlags);
dprintf_untranslated("DebugFlags = 0x%08X\n", debugFlags);
return true;
}
bool cbInstrLabelRuntimeFunctions(int argc, char* argv[])
{
#ifdef _WIN64
if(argc < 2)
{
dputs_untranslated("Usage: LabelRuntimeFunctions modaddr");
return false;
}
auto modaddr = DbgValFromString(argv[1]);
SHARED_ACQUIRE(LockModules);
auto info = ModInfoFromAddr(modaddr);
if(info)
{
std::vector<COMMENTSINFO> comments;
CommentGetList(comments);
for(const auto & comment : comments)
{
if(comment.modhash == info->hash)
{
if(!comment.manual && comment.text.find("RUNTIME_FUNCTION") == 0)
{
CommentDelete(comment.addr + info->base);
}
}
}
for(const auto & runtimeFunction : info->runtimeFunctions)
{
auto setComment = [info](duint addr, const char* prefix)
{
char comment[MAX_COMMENT_SIZE] = "";
if(!CommentGet(addr, comment))
strncpy_s(comment, "RUNTIME_FUNCTION", _TRUNCATE);
strncat_s(comment, " ", _TRUNCATE);
strncat_s(comment, prefix, _TRUNCATE);
CommentSet(addr, comment, false);
};
setComment(info->base + runtimeFunction.BeginAddress, "BeginAddress");
setComment(info->base + runtimeFunction.EndAddress, "EndAddress");
}
GuiUpdateAllViews();
}
else
{
dprintf_untranslated("No module found at %p\n", modaddr);
}
return true;
#else
return false;
#endif // _WIN64
}
bool cbInstrCmdTest(int argc, char* argv[])
{
for(int i = 0; i < argc; i++)
dprintf_untranslated("argv[%d]:%s\n", i, argv[i]);
return true;
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-undocumented.h | #pragma once
#include "command.h"
bool cbBadCmd(int argc, char* argv[]);
bool cbDebugBenchmark(int argc, char* argv[]);
bool cbInstrSetstr(int argc, char* argv[]);
bool cbInstrGetstr(int argc, char* argv[]);
bool cbInstrCopystr(int argc, char* argv[]);
bool cbInstrZydis(int argc, char* argv[]);
bool cbInstrVisualize(int argc, char* argv[]);
bool cbInstrMeminfo(int argc, char* argv[]);
bool cbInstrBriefcheck(int argc, char* argv[]);
bool cbInstrFocusinfo(int argc, char* argv[]);
bool cbInstrFlushlog(int argc, char* argv[]);
bool cbInstrAnimateWait(int argc, char* argv[]);
bool cbInstrDbdecompress(int argc, char* argv[]);
bool cbInstrDebugFlags(int argc, char* argv[]);
bool cbInstrLabelRuntimeFunctions(int argc, char* argv[]);
bool cbInstrCmdTest(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-user-database.cpp | #include "cmd-user-database.h"
#include "database.h"
#include "console.h"
#include "comment.h"
#include "value.h"
#include "variable.h"
#include "label.h"
#include "bookmark.h"
#include "function.h"
#include "argument.h"
#include "loop.h"
#include "debugger.h"
#include "stringformat.h"
#include "_exports.h"
bool cbInstrDbsave(int argc, char* argv[])
{
DbSave(DbLoadSaveType::All, argc > 1 ? argv[1] : nullptr, argc > 1);
return true;
}
bool cbInstrDbload(int argc, char* argv[])
{
if(argc <= 1)
{
DebugRemoveBreakpoints();
DbClear();
}
DbLoad(DbLoadSaveType::All, argc > 1 ? argv[1] : nullptr);
DebugSetBreakpoints();
GuiUpdateAllViews();
return true;
}
bool cbInstrDbclear(int argc, char* argv[])
{
DebugRemoveBreakpoints();
DbClear();
dputs(QT_TRANSLATE_NOOP("DBG", "Database cleared!"));
GuiUpdateAllViews();
return true;
}
bool cbInstrCommentSet(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return false;
if(!CommentSet(addr, argv[2], true))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error setting comment"));
return false;
}
GuiUpdateAllViews();
return true;
}
bool cbInstrCommentDel(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return false;
if(!CommentDelete(addr))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error deleting comment"));
return false;
}
GuiUpdateAllViews();
return true;
}
bool cbInstrCommentList(int argc, char* argv[])
{
auto listAuto = argc >= 2 && *argv[1] == '1';
//setup reference view
GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Comments")));
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address")));
GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly")));
GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Comment")));
GuiReferenceSetRowCount(0);
GuiReferenceReloadData();
size_t cbsize;
CommentEnum(0, &cbsize);
if(!cbsize)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No comments"));
return true;
}
Memory<COMMENTSINFO*> comments(cbsize, "cbInstrCommentList:comments");
CommentEnum(comments(), 0);
int total = 0;
for(int i = 0; i < (int)(cbsize / sizeof(COMMENTSINFO)); i++)
{
if(!listAuto && !comments()[i].manual)
continue;
GuiReferenceSetRowCount(total + 1);
char addrText[20] = "";
sprintf_s(addrText, "%p", comments()[i].addr);
GuiReferenceSetCellContent(total, 0, addrText);
char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = "";
if(GuiGetDisassembly(comments()[i].addr, disassembly))
GuiReferenceSetCellContent(total, 1, disassembly);
GuiReferenceSetCellContent(total, 2, comments()[i].text.c_str());
total++;
}
varset("$result", total, false);
GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Delete")), "commentdel $0");
dprintf(QT_TRANSLATE_NOOP("DBG", "%d comment(s) listed in Reference View\n"), total);
GuiReferenceReloadData();
return true;
}
bool cbInstrCommentClear(int argc, char* argv[])
{
CommentClear();
GuiUpdateAllViews();
dputs(QT_TRANSLATE_NOOP("DBG", "All comments deleted!"));
return true;
}
bool cbInstrLabelSet(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return false;
auto temporaryLabel = argc > 3;
if(!LabelSet(addr, stringformatinline(argv[2]).c_str(), true, temporaryLabel))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error setting label"));
return false;
}
GuiUpdateAllViews();
return true;
}
bool cbInstrLabelDel(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return false;
if(!LabelDelete(addr))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error deleting label"));
return false;
}
return true;
}
bool cbInstrLabelList(int argc, char* argv[])
{
//setup reference view
GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Labels")));
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address")));
GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly")));
GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Label")));
GuiReferenceSetRowCount(0);
GuiReferenceReloadData();
std::vector<LABELSINFO> labels;
LabelGetList(labels);
if(labels.empty())
{
dputs(QT_TRANSLATE_NOOP("DBG", "No labels"));
return true;
}
auto count = int(labels.size());
for(int i = 0; i < count; i++)
{
labels[i].addr += ModBaseFromName(labels[i].mod().c_str());
GuiReferenceSetRowCount(i + 1);
char addrText[20] = "";
sprintf_s(addrText, "%p", labels[i].addr);
GuiReferenceSetCellContent(i, 0, addrText);
char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = "";
if(GuiGetDisassembly(labels[i].addr, disassembly))
GuiReferenceSetCellContent(i, 1, disassembly);
GuiReferenceSetCellContent(i, 2, labels[i].text.c_str());
}
varset("$result", count, false);
GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Delete")), "labeldel $0");
dprintf(QT_TRANSLATE_NOOP("DBG", "%d label(s) listed in Reference View\n"), count);
GuiReferenceReloadData();
return true;
}
bool cbInstrLabelClear(int argc, char* argv[])
{
LabelClear();
GuiUpdateAllViews();
dputs(QT_TRANSLATE_NOOP("DBG", "All labels deleted!"));
return true;
}
bool cbInstrBookmarkSet(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return false;
if(!BookmarkSet(addr, true))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to set bookmark!"));
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Bookmark set!"));
return true;
}
bool cbInstrBookmarkDel(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return false;
if(!BookmarkDelete(addr))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to delete bookmark!"));
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Bookmark deleted!"));
return true;
}
bool cbInstrBookmarkList(int argc, char* argv[])
{
//setup reference view
GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Bookmarks")));
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address")));
GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly")));
GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Label")));
GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Comment")));
GuiReferenceSetRowCount(0);
GuiReferenceReloadData();
size_t cbsize;
BookmarkEnum(0, &cbsize);
if(!cbsize)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No bookmarks found"));
return true;
}
Memory<BOOKMARKSINFO*> bookmarks(cbsize, "cbInstrBookmarkList:bookmarks");
BookmarkEnum(bookmarks(), 0);
int count = (int)(cbsize / sizeof(BOOKMARKSINFO));
for(int i = 0; i < count; i++)
{
GuiReferenceSetRowCount(i + 1);
char addrText[20] = "";
sprintf_s(addrText, "%p", bookmarks()[i].addr);
GuiReferenceSetCellContent(i, 0, addrText);
char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = "";
if(GuiGetDisassembly(bookmarks()[i].addr, disassembly))
GuiReferenceSetCellContent(i, 1, disassembly);
char comment[MAX_COMMENT_SIZE] = "";
if(CommentGet(bookmarks()[i].addr, comment))
GuiReferenceSetCellContent(i, 3, comment);
char label[MAX_LABEL_SIZE] = "";
if(LabelGet(bookmarks()[i].addr, label))
GuiReferenceSetCellContent(i, 2, label);
}
varset("$result", count, false);
GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Delete")), "bookmarkdel $0");
dprintf(QT_TRANSLATE_NOOP("DBG", "%d bookmark(s) listed\n"), count);
GuiReferenceReloadData();
return true;
}
bool cbInstrBookmarkClear(int argc, char* argv[])
{
LabelClear();
GuiUpdateAllViews();
dputs(QT_TRANSLATE_NOOP("DBG", "All bookmarks deleted!"));
return true;
}
bool cbInstrFunctionAdd(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
duint start = 0;
duint end = 0;
if(!valfromstring(argv[1], &start, false) || !valfromstring(argv[2], &end, false))
return false;
if(!FunctionAdd(start, end, true))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to add function"));
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Function added!"));
GuiUpdateAllViews();
return true;
}
bool cbInstrFunctionDel(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return false;
if(!FunctionDelete(addr))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to delete function"));
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Function deleted!"));
GuiUpdateAllViews();
return true;
}
bool cbInstrFunctionList(int argc, char* argv[])
{
//setup reference view
GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Functions")));
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Start")));
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "End")));
GuiReferenceAddColumn(5, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Size")));
GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Label")));
GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly (Start)")));
GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Comment")));
GuiReferenceSetRowCount(0);
GuiReferenceReloadData();
size_t cbsize;
FunctionEnum(0, &cbsize);
if(!cbsize)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No functions"));
return true;
}
Memory<FUNCTIONSINFO*> functions(cbsize, "cbInstrFunctionList:functions");
FunctionEnum(functions(), 0);
int count = (int)(cbsize / sizeof(FUNCTIONSINFO));
for(int i = 0; i < count; i++)
{
GuiReferenceSetRowCount(i + 1);
char addrText[20] = "";
sprintf_s(addrText, "%p", functions()[i].start);
GuiReferenceSetCellContent(i, 0, addrText);
sprintf_s(addrText, "%p", functions()[i].end);
GuiReferenceSetCellContent(i, 1, addrText);
sprintf_s(addrText, ArchValue("%X", "%llX"), functions()[i].end - functions()[i].start);
GuiReferenceSetCellContent(i, 2, addrText);
char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = "";
if(GuiGetDisassembly(functions()[i].start, disassembly))
GuiReferenceSetCellContent(i, 4, disassembly);
char label[MAX_LABEL_SIZE] = "";
BRIDGE_ADDRINFO labelinfo;
labelinfo.flags = flaglabel;
if(_dbg_addrinfoget(functions()[i].start, SEG_DEFAULT, &labelinfo))
GuiReferenceSetCellContent(i, 3, labelinfo.label);
char comment[MAX_COMMENT_SIZE] = "";
if(CommentGet(functions()[i].start, comment))
GuiReferenceSetCellContent(i, 5, comment);
}
varset("$result", count, false);
GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Delete")), "functiondel $0");
dprintf(QT_TRANSLATE_NOOP("DBG", "%d function(s) listed\n"), count);
GuiReferenceReloadData();
return true;
}
bool cbInstrFunctionClear(int argc, char* argv[])
{
FunctionClear();
GuiUpdateAllViews();
dputs(QT_TRANSLATE_NOOP("DBG", "All functions deleted!"));
return true;
}
bool cbInstrArgumentAdd(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
duint start = 0;
duint end = 0;
if(!valfromstring(argv[1], &start, false) || !valfromstring(argv[2], &end, false))
return false;
if(!ArgumentAdd(start, end, true))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to add argument"));
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Argument added!"));
GuiUpdateAllViews();
return true;
}
bool cbInstrArgumentDel(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return false;
if(!ArgumentDelete(addr))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to delete argument"));
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Argument deleted!"));
GuiUpdateAllViews();
return true;
}
bool cbInstrArgumentList(int argc, char* argv[])
{
//setup reference view
GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Arguments")));
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Start")));
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "End")));
GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly (Start)")));
GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Label/Comment")));
GuiReferenceSetRowCount(0);
GuiReferenceReloadData();
size_t cbsize;
ArgumentEnum(0, &cbsize);
if(!cbsize)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No arguments"));
return true;
}
Memory<ARGUMENTSINFO*> arguments(cbsize, "cbInstrArgumentList:arguments");
ArgumentEnum(arguments(), 0);
int count = (int)(cbsize / sizeof(ARGUMENTSINFO));
for(int i = 0; i < count; i++)
{
GuiReferenceSetRowCount(i + 1);
char addrText[20] = "";
sprintf_s(addrText, "%p", arguments()[i].start);
GuiReferenceSetCellContent(i, 0, addrText);
sprintf_s(addrText, "%p", arguments()[i].end);
GuiReferenceSetCellContent(i, 1, addrText);
char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = "";
if(GuiGetDisassembly(arguments()[i].start, disassembly))
GuiReferenceSetCellContent(i, 2, disassembly);
char label[MAX_LABEL_SIZE] = "";
if(LabelGet(arguments()[i].start, label))
GuiReferenceSetCellContent(i, 3, label);
else
{
char comment[MAX_COMMENT_SIZE] = "";
if(CommentGet(arguments()[i].start, comment))
GuiReferenceSetCellContent(i, 3, comment);
}
}
varset("$result", count, false);
GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Delete")), "argumentdel $0");
dprintf(QT_TRANSLATE_NOOP("DBG", "%d argument(s) listed\n"), count);
GuiReferenceReloadData();
return true;
}
bool cbInstrArgumentClear(int argc, char* argv[])
{
ArgumentClear();
GuiUpdateAllViews();
dputs(QT_TRANSLATE_NOOP("DBG", "All arguments deleted!"));
return true;
}
bool cbInstrLoopAdd(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return false;
duint start = 0;
duint end = 0;
if(!valfromstring(argv[1], &start, false) || !valfromstring(argv[2], &end, false))
return false;
if(!LoopAdd(start, end, true))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to add loop"));
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Loop added!"));
GuiUpdateAllViews();
return true;
}
bool cbInstrLoopDel(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return false;
duint depth = 0;
if(argc >= 3 && !valfromstring(argv[2], &depth, false))
return false;
if(!LoopDelete(int(depth), addr))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to delete loop"));
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Loop deleted!"));
GuiUpdateAllViews();
return true;
}
bool cbInstrLoopList(int argc, char* argv[])
{
//setup reference view
GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Loops")));
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Start")));
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "End")));
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Depth")));
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Parent")));
GuiReferenceAddColumn(50, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Disassembly (Start)")));
GuiReferenceAddColumn(0, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Label/Comment")));
GuiReferenceSetRowCount(0);
GuiReferenceReloadData();
size_t cbsize;
LoopEnum(0, &cbsize);
if(!cbsize)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No loops"));
return true;
}
Memory<LOOPSINFO*> loops(cbsize, "cbInstrLoopList:loops");
LoopEnum(loops(), 0);
int count = (int)(cbsize / sizeof(LOOPSINFO));
for(int i = 0; i < count; i++)
{
GuiReferenceSetRowCount(i + 1);
char addrText[20] = "";
sprintf_s(addrText, "%p", loops()[i].start);
GuiReferenceSetCellContent(i, 0, addrText);
sprintf_s(addrText, "%p", loops()[i].end);
GuiReferenceSetCellContent(i, 1, addrText);
sprintf_s(addrText, "%d", loops()[i].depth);
GuiReferenceSetCellContent(i, 2, addrText);
sprintf_s(addrText, "%p", loops()[i].parent);
GuiReferenceSetCellContent(i, 3, addrText);
char disassembly[GUI_MAX_DISASSEMBLY_SIZE] = "";
if(GuiGetDisassembly(loops()[i].start, disassembly))
GuiReferenceSetCellContent(i, 4, disassembly);
char label[MAX_LABEL_SIZE] = "";
if(LabelGet(loops()[i].start, label))
GuiReferenceSetCellContent(i, 5, label);
else
{
char comment[MAX_COMMENT_SIZE] = "";
if(CommentGet(loops()[i].start, comment))
GuiReferenceSetCellContent(i, 5, comment);
}
}
varset("$result", count, false);
GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Delete")), "loopdel $0");
dprintf(QT_TRANSLATE_NOOP("DBG", "%d loop(s) listed\n"), count);
GuiReferenceReloadData();
return true;
}
bool cbInstrLoopClear(int argc, char* argv[])
{
LoopClear();
GuiUpdateAllViews();
dputs(QT_TRANSLATE_NOOP("DBG", "All loops deleted!"));
return true;
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-user-database.h | #pragma once
#include "command.h"
bool cbInstrDbsave(int argc, char* argv[]);
bool cbInstrDbload(int argc, char* argv[]);
bool cbInstrDbclear(int argc, char* argv[]);
bool cbInstrCommentSet(int argc, char* argv[]);
bool cbInstrCommentDel(int argc, char* argv[]);
bool cbInstrCommentList(int argc, char* argv[]);
bool cbInstrCommentClear(int argc, char* argv[]);
bool cbInstrLabelSet(int argc, char* argv[]);
bool cbInstrLabelDel(int argc, char* argv[]);
bool cbInstrLabelList(int argc, char* argv[]);
bool cbInstrLabelClear(int argc, char* argv[]);
bool cbInstrBookmarkSet(int argc, char* argv[]);
bool cbInstrBookmarkDel(int argc, char* argv[]);
bool cbInstrBookmarkList(int argc, char* argv[]);
bool cbInstrBookmarkClear(int argc, char* argv[]);
bool cbInstrFunctionAdd(int argc, char* argv[]);
bool cbInstrFunctionDel(int argc, char* argv[]);
bool cbInstrFunctionList(int argc, char* argv[]);
bool cbInstrFunctionClear(int argc, char* argv[]);
bool cbInstrArgumentAdd(int argc, char* argv[]);
bool cbInstrArgumentDel(int argc, char* argv[]);
bool cbInstrArgumentList(int argc, char* argv[]);
bool cbInstrArgumentClear(int argc, char* argv[]);
bool cbInstrLoopAdd(int argc, char* argv[]);
bool cbInstrLoopDel(int argc, char* argv[]);
bool cbInstrLoopList(int argc, char* argv[]);
bool cbInstrLoopClear(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-variables.cpp | #include "cmd-variables.h"
#include "console.h"
#include "variable.h"
#include "value.h"
bool cbInstrVar(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
char arg2[deflen] = ""; //var value (optional)
if(argc > 2)
strcpy_s(arg2, argv[2]);
duint value = 0;
int add = 0;
if(*argv[1] == '$')
add++;
if(valfromstring(argv[1] + add, &value))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid variable name \"%s\"\n"), argv[1]);
return false;
}
if(!valfromstring(arg2, &value))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid value \"%s\"\n"), arg2);
return false;
}
if(!varnew(argv[1], value, VAR_USER))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error creating variable \"%s\"\n"), argv[1]);
return false;
}
else
{
if(value > 15)
#ifdef _WIN64
dprintf_untranslated("%s=%llX (%llud)\n", argv[1], value, value);
#else //x86
dprintf_untranslated("%s=%X (%ud)\n", argv[1], value, value);
#endif //_WIN64
else
#ifdef _WIN64
dprintf_untranslated("%s=%llX\n", argv[1], value);
#else //x86
dprintf_untranslated("%s=%X\n", argv[1], value);
#endif //_WIN64
}
return true;
}
bool cbInstrVarDel(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return false;
if(!vardel(argv[1], false))
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not delete variable \"%s\"\n"), argv[1]);
else
dprintf(QT_TRANSLATE_NOOP("DBG", "Deleted variable \"%s\"\n"), argv[1]);
return true;
}
bool cbInstrVarList(int argc, char* argv[])
{
int filter = 0;
if(argc > 1)
{
if(!_stricmp(argv[1], "USER"))
filter = VAR_USER;
else if(!_stricmp(argv[1], "READONLY"))
filter = VAR_READONLY;
else if(!_stricmp(argv[1], "SYSTEM"))
filter = VAR_SYSTEM;
}
size_t cbsize = 0;
if(!varenum(0, &cbsize))
{
dputs(QT_TRANSLATE_NOOP("DBG", "No variables!"));
return true;
}
Memory<VAR*> variables(cbsize, "cbInstrVarList:variables");
if(!varenum(variables(), 0))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error listing variables!"));
return false;
}
GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Variables")));
GuiReferenceAddColumn(2 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Value (Hex)"))); //The GUI only follows address in column 0
GuiReferenceAddColumn(30, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Variable")));
GuiReferenceAddColumn(3 * sizeof(duint), GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Value (Decimal)")));
GuiReferenceAddColumn(20, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Property")));
int varcount = (int)cbsize / sizeof(VAR);
int realvarcount = 0;
GuiReferenceSetRowCount(0);
for(int i = 0; i < varcount; i++)
{
char value[32];
if(variables()[i].alias.length())
continue;
if(variables()[i].type != VAR_HIDDEN)
{
GuiReferenceSetRowCount(realvarcount + 1);
GuiReferenceSetCellContent(realvarcount, 1, variables()[i].name.c_str());
#ifdef _WIN64
sprintf_s(value, "%llX", variables()[i].value.u.value);
GuiReferenceSetCellContent(realvarcount, 0, value);
sprintf_s(value, "%llu", variables()[i].value.u.value);
GuiReferenceSetCellContent(realvarcount, 2, value);
#else //x86
sprintf_s(value, "%X", variables()[i].value.u.value);
GuiReferenceSetCellContent(realvarcount, 0, value);
sprintf_s(value, "%u", variables()[i].value.u.value);
GuiReferenceSetCellContent(realvarcount, 2, value);
#endif //_WIN64
const char* szType;
switch(variables()[i].type)
{
case VAR_USER:
szType = QT_TRANSLATE_NOOP("DBG", "User Variable");
break;
case VAR_SYSTEM:
szType = QT_TRANSLATE_NOOP("DBG", "System Variable");
break;
case VAR_READONLY:
szType = QT_TRANSLATE_NOOP("DBG", "Read Only Variable");
break;
default://other variables
szType = QT_TRANSLATE_NOOP("DBG", "System Variable");
break;
}
GuiReferenceSetCellContent(realvarcount, 3, GuiTranslateText(szType));
realvarcount++;
}
}
GuiReferenceAddCommand(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Delete")), "vardel $1");
GuiReferenceReloadData();
return true;
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-variables.h | #pragma once
#include "command.h"
bool cbInstrVar(int argc, char* argv[]);
bool cbInstrVarDel(int argc, char* argv[]);
bool cbInstrVarList(int argc, char* argv[]); |
C++ | x64dbg-development/src/dbg/commands/cmd-watch-control.cpp | #include "cmd-watch-control.h"
#include "variable.h"
#include "watch.h"
#include "console.h"
#include "threading.h"
bool cbAddWatch(int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for addwatch\n"));
return false;
}
WATCHVARTYPE newtype = WATCHVARTYPE::TYPE_UINT;
if(argc > 2)
{
if(_stricmp(argv[2], "uint") == 0)
newtype = WATCHVARTYPE::TYPE_UINT;
else if(_stricmp(argv[2], "int") == 0)
newtype = WATCHVARTYPE::TYPE_INT;
else if(_stricmp(argv[2], "float") == 0)
newtype = WATCHVARTYPE::TYPE_FLOAT;
else if(_stricmp(argv[2], "ascii") == 0)
newtype = WATCHVARTYPE::TYPE_ASCII;
else if(_stricmp(argv[2], "unicode") == 0)
newtype = WATCHVARTYPE::TYPE_UNICODE;
}
unsigned int newid = WatchAddExpr(argv[1], newtype);
varset("$result", newid, false);
return true;
}
bool cbDelWatch(int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for delwatch\n"));
return false;
}
duint id;
bool ok = valfromstring(argv[1], &id);
if(!ok)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error expression in argument 1.\n"));
return false;
}
WatchDelete((unsigned int)id);
return true;
}
bool cbSetWatchdog(int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for delwatch\n"));
return false;
}
duint id;
bool ok = valfromstring(argv[1], &id);
if(!ok)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error expression in argument 1.\n"));
return false;
}
WATCHDOGMODE mode;
if(argc > 2)
{
if(_stricmp(argv[2], "disabled") == 0)
mode = WATCHDOGMODE::MODE_DISABLED;
else if(_stricmp(argv[2], "changed") == 0)
mode = WATCHDOGMODE::MODE_CHANGED;
else if(_stricmp(argv[2], "unchanged") == 0)
mode = WATCHDOGMODE::MODE_UNCHANGED;
else if(_stricmp(argv[2], "istrue") == 0)
mode = WATCHDOGMODE::MODE_ISTRUE;
else if(_stricmp(argv[2], "isfalse") == 0)
mode = WATCHDOGMODE::MODE_ISFALSE;
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Unknown watchdog mode.\n"));
return false;
}
}
else
mode = (WatchGetWatchdogEnabled((unsigned int)id) == WATCHDOGMODE::MODE_DISABLED) ? WATCHDOGMODE::MODE_CHANGED : WATCHDOGMODE::MODE_DISABLED;
WatchSetWatchdogMode((unsigned int)id, mode);
return true;
}
bool cbSetWatchType(int argc, char* argv[])
{
if(argc < 3)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for SetWatchType\n"));
return false;
}
duint id;
bool ok = valfromstring(argv[1], &id);
if(!ok)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error expression in argument 1.\n"));
return false;
}
WATCHVARTYPE newtype;
if(_stricmp(argv[2], "uint") == 0)
newtype = WATCHVARTYPE::TYPE_UINT;
else if(_stricmp(argv[2], "int") == 0)
newtype = WATCHVARTYPE::TYPE_INT;
else if(_stricmp(argv[2], "float") == 0)
newtype = WATCHVARTYPE::TYPE_FLOAT;
else if(_stricmp(argv[2], "ascii") == 0)
newtype = WATCHVARTYPE::TYPE_ASCII;
else if(_stricmp(argv[2], "unicode") == 0)
newtype = WATCHVARTYPE::TYPE_UNICODE;
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Unknown watch type.\n"));
return false;
}
WatchSetType((unsigned int)id, newtype);
return true;
}
bool cbSetWatchExpression(int argc, char* argv[])
{
if(argc < 3)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for SetWatchExpression"));
return false;
}
duint id;
bool ok = valfromstring(argv[1], &id);
if(ok)
{
WATCHVARTYPE varType;
if(argc > 3)
{
if(_stricmp(argv[3], "uint") == 0)
varType = WATCHVARTYPE::TYPE_UINT;
else if(_stricmp(argv[3], "int") == 0)
varType = WATCHVARTYPE::TYPE_INT;
else if(_stricmp(argv[3], "float") == 0)
varType = WATCHVARTYPE::TYPE_FLOAT;
else if(_stricmp(argv[3], "ascii") == 0)
varType = WATCHVARTYPE::TYPE_ASCII;
else if(_stricmp(argv[3], "unicode") == 0)
varType = WATCHVARTYPE::TYPE_UNICODE;
else
varType = WATCHVARTYPE::TYPE_UINT;
}
else
varType = WATCHVARTYPE::TYPE_UINT;
WatchModifyExpr((unsigned int)id, argv[2], varType);
return true;
}
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error expression in argument 1.\n"));
return false;
}
}
bool cbSetWatchName(int argc, char* argv[])
{
if(argc < 3)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for SetWatchName"));
return false;
}
duint id;
bool ok = valfromstring(argv[1], &id);
if(ok)
{
WatchModifyName((unsigned int)id, argv[2]);
return true;
}
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error expression in argument 1.\n"));
return false;
}
}
bool cbCheckWatchdog(int argc, char* argv[])
{
EXCLUSIVE_ACQUIRE(LockWatch);
bool watchdogTriggered = false;
for(auto j = watchexpr.begin(); j != watchexpr.end(); ++j)
{
std::pair<unsigned int, WatchExpr*> i = *j;
i.second->watchdogTriggered = false;
duint intVal = i.second->getIntValue();
watchdogTriggered |= i.second->watchdogTriggered;
}
EXCLUSIVE_RELEASE();
if(watchdogTriggered)
GuiUpdateWatchViewAsync();
varset("$result", watchdogTriggered ? 1 : 0, false);
return true;
} |
C/C++ | x64dbg-development/src/dbg/commands/cmd-watch-control.h | #pragma once
#include "command.h"
bool cbAddWatch(int argc, char* argv[]);
bool cbDelWatch(int argc, char* argv[]);
bool cbSetWatchdog(int argc, char* argv[]);
bool cbSetWatchExpression(int argc, char* argv[]);
bool cbSetWatchName(int argc, char* argv[]);
bool cbSetWatchType(int argc, char* argv[]);
bool cbCheckWatchdog(int argc, char* argv[]); |
C/C++ | x64dbg-development/src/dbg/dbghelp/dbghelp.h | #ifndef _DBGHELP_
#define _DBGHELP_
// As a general principal always call the 64 bit version
// of every API, if a choice exists. The 64 bit version
// works great on 32 bit platforms, and is forward
// compatible to 64 bit platforms.
#ifdef _WIN64
#ifndef _IMAGEHLP64
#define _IMAGEHLP64
#endif
#endif
#pragma pack(push,8)
// For those without specstrings.h
// Since there are different versions of this header, I need to
// individually test each item and define it if it is not around.
#ifndef __in
#define __in
#endif
#ifndef __out
#define __out
#endif
#ifndef __inout
#define __inout
#endif
#ifndef __in_opt
#define __in_opt
#endif
#ifndef __out_opt
#define __out_opt
#endif
#ifndef __inout_opt
#define __inout_opt
#endif
#ifndef __in_ecount
#define __in_ecount(x)
#endif
#ifndef __out_ecount
#define __out_ecount(x)
#endif
#ifndef __inout_ecount
#define __inout_ecount(x)
#endif
#ifndef __in_bcount
#define __in_bcount(x)
#endif
#ifndef __out_bcount
#define __out_bcount(x)
#endif
#ifndef __inout_bcount
#define __inout_bcount(x)
#endif
#ifndef __out_xcount
#define __out_xcount(x)
#endif
#ifndef __deref_opt_out
#define __deref_opt_out
#endif
#ifndef __deref_out
#define __deref_out
#endif
#ifndef __out_ecount_opt
#define __out_ecount_opt(x)
#endif
#ifndef __in_bcount_opt
#define __in_bcount_opt(x)
#endif
#ifndef __out_bcount_opt
#define __out_bcount_opt(x)
#endif
#ifndef __deref_out_opt
#define __deref_out_opt
#endif
#ifdef __cplusplus
extern "C" {
#endif
#ifdef _IMAGEHLP_SOURCE_
#define IMAGEAPI __stdcall
#define DBHLP_DEPRECIATED
#else
#define IMAGEAPI DECLSPEC_IMPORT __stdcall
#if (_MSC_VER >= 1300) && !defined(MIDL_PASS)
#define DBHLP_DEPRECIATED __declspec(deprecated)
#else
#define DBHLP_DEPRECIATED
#endif
#endif
#define DBHLPAPI IMAGEAPI
#define IMAGE_SEPARATION (64*1024)
// Observant readers may notice that 2 new fields,
// 'fReadOnly' and 'Version' have been added to
// the LOADED_IMAGE structure after 'fDOSImage'.
// This does not change the size of the structure
// from previous headers. That is because while
// 'fDOSImage' is a byte, it is padded by the
// compiler to 4 bytes. So the 2 new fields are
// slipped into the extra space.
typedef struct _LOADED_IMAGE
{
PSTR ModuleName;
HANDLE hFile;
PUCHAR MappedAddress;
#ifdef _IMAGEHLP64
PIMAGE_NT_HEADERS64 FileHeader;
#else
PIMAGE_NT_HEADERS32 FileHeader;
#endif
PIMAGE_SECTION_HEADER LastRvaSection;
ULONG NumberOfSections;
PIMAGE_SECTION_HEADER Sections;
ULONG Characteristics;
BOOLEAN fSystemImage;
BOOLEAN fDOSImage;
BOOLEAN fReadOnly;
UCHAR Version;
LIST_ENTRY Links;
ULONG SizeOfImage;
} LOADED_IMAGE, *PLOADED_IMAGE;
#define MAX_SYM_NAME 2000
// Error codes set by dbghelp functions. Call GetLastError
// to see them.
// Dbghelp also sets error codes found in winerror.h
#define ERROR_IMAGE_NOT_STRIPPED 0x8800 // the image is not stripped. No dbg file available.
#define ERROR_NO_DBG_POINTER 0x8801 // image is stripped but there is no pointer to a dbg file
#define ERROR_NO_PDB_POINTER 0x8802 // image does not point to a pdb file
typedef BOOL
(CALLBACK* PFIND_DEBUG_FILE_CALLBACK)(
__in HANDLE FileHandle,
__in PCSTR FileName,
__in PVOID CallerData
);
HANDLE
IMAGEAPI
SymFindDebugInfoFile(
__in HANDLE hProcess,
__in PCSTR FileName,
__out_ecount(MAX_PATH + 1) PSTR DebugFilePath,
__in_opt PFIND_DEBUG_FILE_CALLBACK Callback,
__in_opt PVOID CallerData
);
typedef BOOL
(CALLBACK* PFIND_DEBUG_FILE_CALLBACKW)(
__in HANDLE FileHandle,
__in PCWSTR FileName,
__in PVOID CallerData
);
HANDLE
IMAGEAPI
SymFindDebugInfoFileW(
__in HANDLE hProcess,
__in PCWSTR FileName,
__out_ecount(MAX_PATH + 1) PWSTR DebugFilePath,
__in_opt PFIND_DEBUG_FILE_CALLBACKW Callback,
__in_opt PVOID CallerData
);
HANDLE
IMAGEAPI
FindDebugInfoFile(
__in PCSTR FileName,
__in PCSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PSTR DebugFilePath
);
HANDLE
IMAGEAPI
FindDebugInfoFileEx(
__in PCSTR FileName,
__in PCSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PSTR DebugFilePath,
__in_opt PFIND_DEBUG_FILE_CALLBACK Callback,
__in_opt PVOID CallerData
);
HANDLE
IMAGEAPI
FindDebugInfoFileExW(
__in PCWSTR FileName,
__in PCWSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PWSTR DebugFilePath,
__in_opt PFIND_DEBUG_FILE_CALLBACKW Callback,
__in_opt PVOID CallerData
);
typedef BOOL
(CALLBACK* PFINDFILEINPATHCALLBACK)(
__in PCSTR filename,
__in PVOID context
);
BOOL
IMAGEAPI
SymFindFileInPath(
__in HANDLE hprocess,
__in_opt PCSTR SearchPath,
__in PCSTR FileName,
__in_opt PVOID id,
__in DWORD two,
__in DWORD three,
__in DWORD flags,
__out_ecount(MAX_PATH + 1) PSTR FoundFile,
__in_opt PFINDFILEINPATHCALLBACK callback,
__in_opt PVOID context
);
typedef BOOL
(CALLBACK* PFINDFILEINPATHCALLBACKW)(
__in PCWSTR filename,
__in PVOID context
);
BOOL
IMAGEAPI
SymFindFileInPathW(
__in HANDLE hprocess,
__in_opt PCWSTR SearchPath,
__in PCWSTR FileName,
__in_opt PVOID id,
__in DWORD two,
__in DWORD three,
__in DWORD flags,
__out_ecount(MAX_PATH + 1) PWSTR FoundFile,
__in_opt PFINDFILEINPATHCALLBACKW callback,
__in_opt PVOID context
);
typedef BOOL
(CALLBACK* PFIND_EXE_FILE_CALLBACK)(
__in HANDLE FileHandle,
__in PCSTR FileName,
__in_opt PVOID CallerData
);
HANDLE
IMAGEAPI
SymFindExecutableImage(
__in HANDLE hProcess,
__in PCSTR FileName,
__out_ecount(MAX_PATH + 1) PSTR ImageFilePath,
__in PFIND_EXE_FILE_CALLBACK Callback,
__in PVOID CallerData
);
typedef BOOL
(CALLBACK* PFIND_EXE_FILE_CALLBACKW)(
__in HANDLE FileHandle,
__in PCWSTR FileName,
__in_opt PVOID CallerData
);
HANDLE
IMAGEAPI
SymFindExecutableImageW(
__in HANDLE hProcess,
__in PCWSTR FileName,
__out_ecount(MAX_PATH + 1) PWSTR ImageFilePath,
__in PFIND_EXE_FILE_CALLBACKW Callback,
__in PVOID CallerData
);
HANDLE
IMAGEAPI
FindExecutableImage(
__in PCSTR FileName,
__in PCSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PSTR ImageFilePath
);
HANDLE
IMAGEAPI
FindExecutableImageEx(
__in PCSTR FileName,
__in PCSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PSTR ImageFilePath,
__in_opt PFIND_EXE_FILE_CALLBACK Callback,
__in_opt PVOID CallerData
);
HANDLE
IMAGEAPI
FindExecutableImageExW(
__in PCWSTR FileName,
__in PCWSTR SymbolPath,
__out_ecount(MAX_PATH + 1) PWSTR ImageFilePath,
__in_opt PFIND_EXE_FILE_CALLBACKW Callback,
__in PVOID CallerData
);
PIMAGE_NT_HEADERS
IMAGEAPI
ImageNtHeader(
__in PVOID Base
);
PVOID
IMAGEAPI
ImageDirectoryEntryToDataEx(
__in PVOID Base,
__in BOOLEAN MappedAsImage,
__in USHORT DirectoryEntry,
__out PULONG Size,
__out_opt PIMAGE_SECTION_HEADER* FoundHeader
);
PVOID
IMAGEAPI
ImageDirectoryEntryToData(
__in PVOID Base,
__in BOOLEAN MappedAsImage,
__in USHORT DirectoryEntry,
__out PULONG Size
);
PIMAGE_SECTION_HEADER
IMAGEAPI
ImageRvaToSection(
__in PIMAGE_NT_HEADERS NtHeaders,
__in PVOID Base,
__in ULONG Rva
);
PVOID
IMAGEAPI
ImageRvaToVa(
__in PIMAGE_NT_HEADERS NtHeaders,
__in PVOID Base,
__in ULONG Rva,
__in_opt OUT PIMAGE_SECTION_HEADER* LastRvaSection
);
#ifndef _WIN64
// This api won't be ported to Win64 - Fix your code.
typedef struct _IMAGE_DEBUG_INFORMATION
{
LIST_ENTRY List;
DWORD ReservedSize;
PVOID ReservedMappedBase;
USHORT ReservedMachine;
USHORT ReservedCharacteristics;
DWORD ReservedCheckSum;
DWORD ImageBase;
DWORD SizeOfImage;
DWORD ReservedNumberOfSections;
PIMAGE_SECTION_HEADER ReservedSections;
DWORD ReservedExportedNamesSize;
PSTR ReservedExportedNames;
DWORD ReservedNumberOfFunctionTableEntries;
PIMAGE_FUNCTION_ENTRY ReservedFunctionTableEntries;
DWORD ReservedLowestFunctionStartingAddress;
DWORD ReservedHighestFunctionEndingAddress;
DWORD ReservedNumberOfFpoTableEntries;
PFPO_DATA ReservedFpoTableEntries;
DWORD SizeOfCoffSymbols;
PIMAGE_COFF_SYMBOLS_HEADER CoffSymbols;
DWORD ReservedSizeOfCodeViewSymbols;
PVOID ReservedCodeViewSymbols;
PSTR ImageFilePath;
PSTR ImageFileName;
PSTR ReservedDebugFilePath;
DWORD ReservedTimeDateStamp;
BOOL ReservedRomImage;
PIMAGE_DEBUG_DIRECTORY ReservedDebugDirectory;
DWORD ReservedNumberOfDebugDirectories;
DWORD ReservedOriginalFunctionTableBaseAddress;
DWORD Reserved[ 2 ];
} IMAGE_DEBUG_INFORMATION, *PIMAGE_DEBUG_INFORMATION;
PIMAGE_DEBUG_INFORMATION
IMAGEAPI
MapDebugInformation(
__in_opt HANDLE FileHandle,
__in PCSTR FileName,
__in_opt PCSTR SymbolPath,
__in ULONG ImageBase
);
BOOL
IMAGEAPI
UnmapDebugInformation(
__out_xcount(unknown) PIMAGE_DEBUG_INFORMATION DebugInfo
);
#endif
BOOL
IMAGEAPI
SearchTreeForFile(
__in PCSTR RootPath,
__in PCSTR InputPathName,
__out_ecount(MAX_PATH + 1) PSTR OutputPathBuffer
);
BOOL
IMAGEAPI
SearchTreeForFileW(
__in PCWSTR RootPath,
__in PCWSTR InputPathName,
__out_ecount(MAX_PATH + 1) PWSTR OutputPathBuffer
);
typedef BOOL
(CALLBACK* PENUMDIRTREE_CALLBACK)(
__in PCSTR FilePath,
__in_opt PVOID CallerData
);
BOOL
IMAGEAPI
EnumDirTree(
__in_opt HANDLE hProcess,
__in PCSTR RootPath,
__in PCSTR InputPathName,
__out_ecount_opt(MAX_PATH + 1) PSTR OutputPathBuffer,
__in_opt PENUMDIRTREE_CALLBACK cb,
__in_opt PVOID data
);
typedef BOOL
(CALLBACK* PENUMDIRTREE_CALLBACKW)(
__in PCWSTR FilePath,
__in_opt PVOID CallerData
);
BOOL
IMAGEAPI
EnumDirTreeW(
__in_opt HANDLE hProcess,
__in PCWSTR RootPath,
__in PCWSTR InputPathName,
__out_ecount_opt(MAX_PATH + 1) PWSTR OutputPathBuffer,
__in_opt PENUMDIRTREE_CALLBACKW cb,
__in_opt PVOID data
);
BOOL
IMAGEAPI
MakeSureDirectoryPathExists(
__in PCSTR DirPath
);
//
// UnDecorateSymbolName Flags
//
#define UNDNAME_COMPLETE (0x0000) // Enable full undecoration
#define UNDNAME_NO_LEADING_UNDERSCORES (0x0001) // Remove leading underscores from MS extended keywords
#define UNDNAME_NO_MS_KEYWORDS (0x0002) // Disable expansion of MS extended keywords
#define UNDNAME_NO_FUNCTION_RETURNS (0x0004) // Disable expansion of return type for primary declaration
#define UNDNAME_NO_ALLOCATION_MODEL (0x0008) // Disable expansion of the declaration model
#define UNDNAME_NO_ALLOCATION_LANGUAGE (0x0010) // Disable expansion of the declaration language specifier
#define UNDNAME_NO_MS_THISTYPE (0x0020) // NYI Disable expansion of MS keywords on the 'this' type for primary declaration
#define UNDNAME_NO_CV_THISTYPE (0x0040) // NYI Disable expansion of CV modifiers on the 'this' type for primary declaration
#define UNDNAME_NO_THISTYPE (0x0060) // Disable all modifiers on the 'this' type
#define UNDNAME_NO_ACCESS_SPECIFIERS (0x0080) // Disable expansion of access specifiers for members
#define UNDNAME_NO_THROW_SIGNATURES (0x0100) // Disable expansion of 'throw-signatures' for functions and pointers to functions
#define UNDNAME_NO_MEMBER_TYPE (0x0200) // Disable expansion of 'static' or 'virtual'ness of members
#define UNDNAME_NO_RETURN_UDT_MODEL (0x0400) // Disable expansion of MS model for UDT returns
#define UNDNAME_32_BIT_DECODE (0x0800) // Undecorate 32-bit decorated names
#define UNDNAME_NAME_ONLY (0x1000) // Crack only the name for primary declaration;
// return just [scope::]name. Does expand template params
#define UNDNAME_NO_ARGUMENTS (0x2000) // Don't undecorate arguments to function
#define UNDNAME_NO_SPECIAL_SYMS (0x4000) // Don't undecorate special names (v-table, vcall, vector xxx, metatype, etc)
DWORD
IMAGEAPI
WINAPI
UnDecorateSymbolName(
__in PCSTR name,
__out_ecount(maxStringLength) PSTR outputString,
__in DWORD maxStringLength,
__in DWORD flags
);
DWORD
IMAGEAPI
WINAPI
UnDecorateSymbolNameW(
__in PCWSTR name,
__out_ecount(maxStringLength) PWSTR outputString,
__in DWORD maxStringLength,
__in DWORD flags
);
//
// these values are used for synthesized file types
// that can be passed in as image headers instead of
// the standard ones from ntimage.h
//
#define DBHHEADER_DEBUGDIRS 0x1
#define DBHHEADER_CVMISC 0x2
#define DBHHEADER_PDBGUID 0x3
typedef struct _MODLOAD_DATA
{
DWORD ssize; // size of this struct
DWORD ssig; // signature identifying the passed data
PVOID data; // pointer to passed data
DWORD size; // size of passed data
DWORD flags; // options
} MODLOAD_DATA, *PMODLOAD_DATA;
typedef struct _MODLOAD_CVMISC
{
DWORD oCV; // ofset to the codeview record
size_t cCV; // size of the codeview record
DWORD oMisc; // offset to the misc record
size_t cMisc; // size of the misc record
DWORD dtImage; // datetime stamp of the image
DWORD cImage; // size of the image
} MODLOAD_CVMISC, *PMODLOAD_CVMISC;
typedef struct _MODLOAD_PDBGUID_PDBAGE
{
GUID PdbGuid; // Pdb Guid
DWORD PdbAge; // Pdb Age
} MODLOAD_PDBGUID_PDBAGE, *PMODLOAD_PDBGUID_PDBAGE;
//
// StackWalking API
//
typedef enum
{
AddrMode1616,
AddrMode1632,
AddrModeReal,
AddrModeFlat
} ADDRESS_MODE;
typedef struct _tagADDRESS64
{
DWORD64 Offset;
WORD Segment;
ADDRESS_MODE Mode;
} ADDRESS64, *LPADDRESS64;
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define ADDRESS ADDRESS64
#define LPADDRESS LPADDRESS64
#else
typedef struct _tagADDRESS
{
DWORD Offset;
WORD Segment;
ADDRESS_MODE Mode;
} ADDRESS, *LPADDRESS;
__inline
void
Address32To64(
__in LPADDRESS a32,
__out LPADDRESS64 a64
)
{
a64->Offset = (ULONG64)(LONG64)(LONG)a32->Offset;
a64->Segment = a32->Segment;
a64->Mode = a32->Mode;
}
__inline
void
Address64To32(
__in LPADDRESS64 a64,
__out LPADDRESS a32
)
{
a32->Offset = (ULONG)a64->Offset;
a32->Segment = a64->Segment;
a32->Mode = a64->Mode;
}
#endif
//
// This structure is included in the STACKFRAME structure,
// and is used to trace through usermode callbacks in a thread's
// kernel stack. The values must be copied by the kernel debugger
// from the DBGKD_GET_VERSION and WAIT_STATE_CHANGE packets.
//
//
// New KDHELP structure for 64 bit system support.
// This structure is preferred in new code.
//
typedef struct _KDHELP64
{
//
// address of kernel thread object, as provided in the
// WAIT_STATE_CHANGE packet.
//
DWORD64 Thread;
//
// offset in thread object to pointer to the current callback frame
// in kernel stack.
//
DWORD ThCallbackStack;
//
// offset in thread object to pointer to the current callback backing
// store frame in kernel stack.
//
DWORD ThCallbackBStore;
//
// offsets to values in frame:
//
// address of next callback frame
DWORD NextCallback;
// address of saved frame pointer (if applicable)
DWORD FramePointer;
//
// Address of the kernel function that calls out to user mode
//
DWORD64 KiCallUserMode;
//
// Address of the user mode dispatcher function
//
DWORD64 KeUserCallbackDispatcher;
//
// Lowest kernel mode address
//
DWORD64 SystemRangeStart;
//
// Address of the user mode exception dispatcher function.
// Added in API version 10.
//
DWORD64 KiUserExceptionDispatcher;
//
// Stack bounds, added in API version 11.
//
DWORD64 StackBase;
DWORD64 StackLimit;
DWORD64 Reserved[5];
} KDHELP64, *PKDHELP64;
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define KDHELP KDHELP64
#define PKDHELP PKDHELP64
#else
typedef struct _KDHELP
{
//
// address of kernel thread object, as provided in the
// WAIT_STATE_CHANGE packet.
//
DWORD Thread;
//
// offset in thread object to pointer to the current callback frame
// in kernel stack.
//
DWORD ThCallbackStack;
//
// offsets to values in frame:
//
// address of next callback frame
DWORD NextCallback;
// address of saved frame pointer (if applicable)
DWORD FramePointer;
//
// Address of the kernel function that calls out to user mode
//
DWORD KiCallUserMode;
//
// Address of the user mode dispatcher function
//
DWORD KeUserCallbackDispatcher;
//
// Lowest kernel mode address
//
DWORD SystemRangeStart;
//
// offset in thread object to pointer to the current callback backing
// store frame in kernel stack.
//
DWORD ThCallbackBStore;
//
// Address of the user mode exception dispatcher function.
// Added in API version 10.
//
DWORD KiUserExceptionDispatcher;
//
// Stack bounds, added in API version 11.
//
DWORD StackBase;
DWORD StackLimit;
DWORD Reserved[5];
} KDHELP, *PKDHELP;
__inline
void
KdHelp32To64(
__in PKDHELP p32,
__out PKDHELP64 p64
)
{
p64->Thread = p32->Thread;
p64->ThCallbackStack = p32->ThCallbackStack;
p64->NextCallback = p32->NextCallback;
p64->FramePointer = p32->FramePointer;
p64->KiCallUserMode = p32->KiCallUserMode;
p64->KeUserCallbackDispatcher = p32->KeUserCallbackDispatcher;
p64->SystemRangeStart = p32->SystemRangeStart;
p64->KiUserExceptionDispatcher = p32->KiUserExceptionDispatcher;
p64->StackBase = p32->StackBase;
p64->StackLimit = p32->StackLimit;
}
#endif
typedef struct _tagSTACKFRAME64
{
ADDRESS64 AddrPC; // program counter
ADDRESS64 AddrReturn; // return address
ADDRESS64 AddrFrame; // frame pointer
ADDRESS64 AddrStack; // stack pointer
ADDRESS64 AddrBStore; // backing store pointer
PVOID FuncTableEntry; // pointer to pdata/fpo or NULL
DWORD64 Params[4]; // possible arguments to the function
BOOL Far; // WOW far call
BOOL Virtual; // is this a virtual frame?
DWORD64 Reserved[3];
KDHELP64 KdHelp;
} STACKFRAME64, *LPSTACKFRAME64;
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define STACKFRAME STACKFRAME64
#define LPSTACKFRAME LPSTACKFRAME64
#else
typedef struct _tagSTACKFRAME
{
ADDRESS AddrPC; // program counter
ADDRESS AddrReturn; // return address
ADDRESS AddrFrame; // frame pointer
ADDRESS AddrStack; // stack pointer
PVOID FuncTableEntry; // pointer to pdata/fpo or NULL
DWORD Params[4]; // possible arguments to the function
BOOL Far; // WOW far call
BOOL Virtual; // is this a virtual frame?
DWORD Reserved[3];
KDHELP KdHelp;
ADDRESS AddrBStore; // backing store pointer
} STACKFRAME, *LPSTACKFRAME;
#endif
typedef
BOOL
(__stdcall* PREAD_PROCESS_MEMORY_ROUTINE64)(
__in HANDLE hProcess,
__in DWORD64 qwBaseAddress,
__out_bcount(nSize) PVOID lpBuffer,
__in DWORD nSize,
__out LPDWORD lpNumberOfBytesRead
);
typedef
PVOID
(__stdcall* PFUNCTION_TABLE_ACCESS_ROUTINE64)(
__in HANDLE ahProcess,
__in DWORD64 AddrBase
);
typedef
DWORD64
(__stdcall* PGET_MODULE_BASE_ROUTINE64)(
__in HANDLE hProcess,
__in DWORD64 Address
);
typedef
DWORD64
(__stdcall* PTRANSLATE_ADDRESS_ROUTINE64)(
__in HANDLE hProcess,
__in HANDLE hThread,
__in LPADDRESS64 lpaddr
);
BOOL
IMAGEAPI
StackWalk64(
__in DWORD MachineType,
__in HANDLE hProcess,
__in HANDLE hThread,
__inout LPSTACKFRAME64 StackFrame,
__inout PVOID ContextRecord,
__in_opt PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
__in_opt PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
__in_opt PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
__in_opt PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64
#define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64
#define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64
#define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64
#define StackWalk StackWalk64
#else
typedef
BOOL
(__stdcall* PREAD_PROCESS_MEMORY_ROUTINE)(
__in HANDLE hProcess,
__in DWORD lpBaseAddress,
__out_bcount(nSize) PVOID lpBuffer,
__in DWORD nSize,
__out PDWORD lpNumberOfBytesRead
);
typedef
PVOID
(__stdcall* PFUNCTION_TABLE_ACCESS_ROUTINE)(
__in HANDLE hProcess,
__in DWORD AddrBase
);
typedef
DWORD
(__stdcall* PGET_MODULE_BASE_ROUTINE)(
__in HANDLE hProcess,
__in DWORD Address
);
typedef
DWORD
(__stdcall* PTRANSLATE_ADDRESS_ROUTINE)(
__in HANDLE hProcess,
__in HANDLE hThread,
__out LPADDRESS lpaddr
);
BOOL
IMAGEAPI
StackWalk(
DWORD MachineType,
__in HANDLE hProcess,
__in HANDLE hThread,
__inout LPSTACKFRAME StackFrame,
__inout PVOID ContextRecord,
__in_opt PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine,
__in_opt PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine,
__in_opt PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine,
__in_opt PTRANSLATE_ADDRESS_ROUTINE TranslateAddress
);
#endif
#define API_VERSION_NUMBER 11
typedef struct API_VERSION
{
USHORT MajorVersion;
USHORT MinorVersion;
USHORT Revision;
USHORT Reserved;
} API_VERSION, *LPAPI_VERSION;
LPAPI_VERSION
IMAGEAPI
ImagehlpApiVersion(
VOID
);
LPAPI_VERSION
IMAGEAPI
ImagehlpApiVersionEx(
__in LPAPI_VERSION AppVersion
);
DWORD
IMAGEAPI
GetTimestampForLoadedLibrary(
__in HMODULE Module
);
//
// typedefs for function pointers
//
typedef BOOL
(CALLBACK* PSYM_ENUMMODULES_CALLBACK64)(
__in PCSTR ModuleName,
__in DWORD64 BaseOfDll,
__in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK* PSYM_ENUMMODULES_CALLBACKW64)(
__in PCWSTR ModuleName,
__in DWORD64 BaseOfDll,
__in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK* PENUMLOADED_MODULES_CALLBACK64)(
__in PCSTR ModuleName,
__in DWORD64 ModuleBase,
__in ULONG ModuleSize,
__in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK* PENUMLOADED_MODULES_CALLBACKW64)(
__in PCWSTR ModuleName,
__in DWORD64 ModuleBase,
__in ULONG ModuleSize,
__in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK* PSYM_ENUMSYMBOLS_CALLBACK64)(
__in PCSTR SymbolName,
__in DWORD64 SymbolAddress,
__in ULONG SymbolSize,
__in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK* PSYM_ENUMSYMBOLS_CALLBACK64W)(
__in PCWSTR SymbolName,
__in DWORD64 SymbolAddress,
__in ULONG SymbolSize,
__in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK* PSYMBOL_REGISTERED_CALLBACK64)(
__in HANDLE hProcess,
__in ULONG ActionCode,
__in_opt ULONG64 CallbackData,
__in_opt ULONG64 UserContext
);
typedef
PVOID
(CALLBACK* PSYMBOL_FUNCENTRY_CALLBACK)(
__in HANDLE hProcess,
__in DWORD AddrBase,
__in_opt PVOID UserContext
);
typedef
PVOID
(CALLBACK* PSYMBOL_FUNCENTRY_CALLBACK64)(
__in HANDLE hProcess,
__in ULONG64 AddrBase,
__in ULONG64 UserContext
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64
#define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64
#define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACK64W
#define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64
#define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64
#define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64
#else
typedef BOOL
(CALLBACK* PSYM_ENUMMODULES_CALLBACK)(
__in PCSTR ModuleName,
__in ULONG BaseOfDll,
__in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK* PSYM_ENUMSYMBOLS_CALLBACK)(
__in PCSTR SymbolName,
__in ULONG SymbolAddress,
__in ULONG SymbolSize,
__in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK* PSYM_ENUMSYMBOLS_CALLBACKW)(
__in PCWSTR SymbolName,
__in ULONG SymbolAddress,
__in ULONG SymbolSize,
__in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK* PENUMLOADED_MODULES_CALLBACK)(
__in PCSTR ModuleName,
__in ULONG ModuleBase,
__in ULONG ModuleSize,
__in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK* PSYMBOL_REGISTERED_CALLBACK)(
__in HANDLE hProcess,
__in ULONG ActionCode,
__in_opt PVOID CallbackData,
__in_opt PVOID UserContext
);
#endif
// values found in SYMBOL_INFO.Tag
//
// This was taken from cvconst.h and should
// not override any values found there.
//
// #define _NO_CVCONST_H_ if you don't
// have access to that file...
#ifdef _NO_CVCONST_H
// DIA enums
enum SymTagEnum
{
SymTagNull,
SymTagExe,
SymTagCompiland,
SymTagCompilandDetails,
SymTagCompilandEnv,
SymTagFunction,
SymTagBlock,
SymTagData,
SymTagAnnotation,
SymTagLabel,
SymTagPublicSymbol,
SymTagUDT,
SymTagEnum,
SymTagFunctionType,
SymTagPointerType,
SymTagArrayType,
SymTagBaseType,
SymTagTypedef,
SymTagBaseClass,
SymTagFriend,
SymTagFunctionArgType,
SymTagFuncDebugStart,
SymTagFuncDebugEnd,
SymTagUsingNamespace,
SymTagVTableShape,
SymTagVTable,
SymTagCustom,
SymTagThunk,
SymTagCustomType,
SymTagManagedType,
SymTagDimension,
SymTagMax
};
#endif
//
// flags found in SYMBOL_INFO.Flags
//
#define SYMFLAG_VALUEPRESENT 0x00000001
#define SYMFLAG_REGISTER 0x00000008
#define SYMFLAG_REGREL 0x00000010
#define SYMFLAG_FRAMEREL 0x00000020
#define SYMFLAG_PARAMETER 0x00000040
#define SYMFLAG_LOCAL 0x00000080
#define SYMFLAG_CONSTANT 0x00000100
#define SYMFLAG_EXPORT 0x00000200
#define SYMFLAG_FORWARDER 0x00000400
#define SYMFLAG_FUNCTION 0x00000800
#define SYMFLAG_VIRTUAL 0x00001000
#define SYMFLAG_THUNK 0x00002000
#define SYMFLAG_TLSREL 0x00004000
#define SYMFLAG_SLOT 0x00008000
#define SYMFLAG_ILREL 0x00010000
#define SYMFLAG_METADATA 0x00020000
#define SYMFLAG_CLR_TOKEN 0x00040000
// this resets SymNext/Prev to the beginning
// of the module passed in the address field
#define SYMFLAG_RESET 0x80000000
//
// symbol type enumeration
//
typedef enum
{
SymNone = 0,
SymCoff,
SymCv,
SymPdb,
SymExport,
SymDeferred,
SymSym, // .sym file
SymDia,
SymVirtual,
NumSymTypes
} SYM_TYPE;
//
// symbol data structure
//
typedef struct _IMAGEHLP_SYMBOL64
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_SYMBOL64)
DWORD64 Address; // virtual address including dll base address
DWORD Size; // estimated size of symbol, can be zero
DWORD Flags; // info about the symbols, see the SYMF defines
DWORD MaxNameLength; // maximum size of symbol name in 'Name'
CHAR Name[1]; // symbol name (null terminated string)
} IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64;
typedef struct _IMAGEHLP_SYMBOL64_PACKAGE
{
IMAGEHLP_SYMBOL64 sym;
CHAR name[MAX_SYM_NAME + 1];
} IMAGEHLP_SYMBOL64_PACKAGE, *PIMAGEHLP_SYMBOL64_PACKAGE;
typedef struct _IMAGEHLP_SYMBOLW64
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_SYMBOLW64)
DWORD64 Address; // virtual address including dll base address
DWORD Size; // estimated size of symbol, can be zero
DWORD Flags; // info about the symbols, see the SYMF defines
DWORD MaxNameLength; // maximum size of symbol name in 'Name'
WCHAR Name[1]; // symbol name (null terminated string)
} IMAGEHLP_SYMBOLW64, *PIMAGEHLP_SYMBOLW64;
typedef struct _IMAGEHLP_SYMBOLW64_PACKAGE
{
IMAGEHLP_SYMBOLW64 sym;
WCHAR name[MAX_SYM_NAME + 1];
} IMAGEHLP_SYMBOLW64_PACKAGE, *PIMAGEHLP_SYMBOLW64_PACKAGE;
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64
#define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64
#define IMAGEHLP_SYMBOL_PACKAGE IMAGEHLP_SYMBOL64_PACKAGE
#define PIMAGEHLP_SYMBOL_PACKAGE PIMAGEHLP_SYMBOL64_PACKAGE
#define IMAGEHLP_SYMBOLW IMAGEHLP_SYMBOLW64
#define PIMAGEHLP_SYMBOLW PIMAGEHLP_SYMBOLW64
#define IMAGEHLP_SYMBOLW_PACKAGE IMAGEHLP_SYMBOLW64_PACKAGE
#define PIMAGEHLP_SYMBOLW_PACKAGE PIMAGEHLP_SYMBOLW64_PACKAGE
#else
typedef struct _IMAGEHLP_SYMBOL
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_SYMBOL)
DWORD Address; // virtual address including dll base address
DWORD Size; // estimated size of symbol, can be zero
DWORD Flags; // info about the symbols, see the SYMF defines
DWORD MaxNameLength; // maximum size of symbol name in 'Name'
CHAR Name[1]; // symbol name (null terminated string)
} IMAGEHLP_SYMBOL, *PIMAGEHLP_SYMBOL;
typedef struct _IMAGEHLP_SYMBOL_PACKAGE
{
IMAGEHLP_SYMBOL sym;
CHAR name[MAX_SYM_NAME + 1];
} IMAGEHLP_SYMBOL_PACKAGE, *PIMAGEHLP_SYMBOL_PACKAGE;
typedef struct _IMAGEHLP_SYMBOLW
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_SYMBOLW)
DWORD Address; // virtual address including dll base address
DWORD Size; // estimated size of symbol, can be zero
DWORD Flags; // info about the symbols, see the SYMF defines
DWORD MaxNameLength; // maximum size of symbol name in 'Name'
WCHAR Name[1]; // symbol name (null terminated string)
} IMAGEHLP_SYMBOLW, *PIMAGEHLP_SYMBOLW;
typedef struct _IMAGEHLP_SYMBOLW_PACKAGE
{
IMAGEHLP_SYMBOLW sym;
WCHAR name[MAX_SYM_NAME + 1];
} IMAGEHLP_SYMBOLW_PACKAGE, *PIMAGEHLP_SYMBOLW_PACKAGE;
#endif
//
// module data structure
//
typedef struct _IMAGEHLP_MODULE64
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE64)
DWORD64 BaseOfImage; // base load address of module
DWORD ImageSize; // virtual size of the loaded module
DWORD TimeDateStamp; // date/time stamp from pe header
DWORD CheckSum; // checksum from the pe header
DWORD NumSyms; // number of symbols in the symbol table
SYM_TYPE SymType; // type of symbols loaded
CHAR ModuleName[32]; // module name
CHAR ImageName[256]; // image name
CHAR LoadedImageName[256]; // symbol file name
// new elements: 07-Jun-2002
CHAR LoadedPdbName[256]; // pdb file name
DWORD CVSig; // Signature of the CV record in the debug directories
CHAR CVData[MAX_PATH * 3]; // Contents of the CV record
DWORD PdbSig; // Signature of PDB
GUID PdbSig70; // Signature of PDB (VC 7 and up)
DWORD PdbAge; // DBI age of pdb
BOOL PdbUnmatched; // loaded an unmatched pdb
BOOL DbgUnmatched; // loaded an unmatched dbg
BOOL LineNumbers; // we have line number information
BOOL GlobalSymbols; // we have internal symbol information
BOOL TypeInfo; // we have type information
// new elements: 17-Dec-2003
BOOL SourceIndexed; // pdb supports source server
BOOL Publics; // contains public symbols
} IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64;
typedef struct _IMAGEHLP_MODULEW64
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE64)
DWORD64 BaseOfImage; // base load address of module
DWORD ImageSize; // virtual size of the loaded module
DWORD TimeDateStamp; // date/time stamp from pe header
DWORD CheckSum; // checksum from the pe header
DWORD NumSyms; // number of symbols in the symbol table
SYM_TYPE SymType; // type of symbols loaded
WCHAR ModuleName[32]; // module name
WCHAR ImageName[256]; // image name
// new elements: 07-Jun-2002
WCHAR LoadedImageName[256]; // symbol file name
WCHAR LoadedPdbName[256]; // pdb file name
DWORD CVSig; // Signature of the CV record in the debug directories
WCHAR CVData[MAX_PATH * 3]; // Contents of the CV record
DWORD PdbSig; // Signature of PDB
GUID PdbSig70; // Signature of PDB (VC 7 and up)
DWORD PdbAge; // DBI age of pdb
BOOL PdbUnmatched; // loaded an unmatched pdb
BOOL DbgUnmatched; // loaded an unmatched dbg
BOOL LineNumbers; // we have line number information
BOOL GlobalSymbols; // we have internal symbol information
BOOL TypeInfo; // we have type information
// new elements: 17-Dec-2003
BOOL SourceIndexed; // pdb supports source server
BOOL Publics; // contains public symbols
} IMAGEHLP_MODULEW64, *PIMAGEHLP_MODULEW64;
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define IMAGEHLP_MODULE IMAGEHLP_MODULE64
#define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64
#define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64
#define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64
#else
typedef struct _IMAGEHLP_MODULE
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE)
DWORD BaseOfImage; // base load address of module
DWORD ImageSize; // virtual size of the loaded module
DWORD TimeDateStamp; // date/time stamp from pe header
DWORD CheckSum; // checksum from the pe header
DWORD NumSyms; // number of symbols in the symbol table
SYM_TYPE SymType; // type of symbols loaded
CHAR ModuleName[32]; // module name
CHAR ImageName[256]; // image name
CHAR LoadedImageName[256]; // symbol file name
} IMAGEHLP_MODULE, *PIMAGEHLP_MODULE;
typedef struct _IMAGEHLP_MODULEW
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE)
DWORD BaseOfImage; // base load address of module
DWORD ImageSize; // virtual size of the loaded module
DWORD TimeDateStamp; // date/time stamp from pe header
DWORD CheckSum; // checksum from the pe header
DWORD NumSyms; // number of symbols in the symbol table
SYM_TYPE SymType; // type of symbols loaded
WCHAR ModuleName[32]; // module name
WCHAR ImageName[256]; // image name
WCHAR LoadedImageName[256]; // symbol file name
} IMAGEHLP_MODULEW, *PIMAGEHLP_MODULEW;
#endif
//
// source file line data structure
//
typedef struct _IMAGEHLP_LINE64
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_LINE64)
PVOID Key; // internal
DWORD LineNumber; // line number in file
PCHAR FileName; // full filename
DWORD64 Address; // first instruction of line
} IMAGEHLP_LINE64, *PIMAGEHLP_LINE64;
typedef struct _IMAGEHLP_LINEW64
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_LINE64)
PVOID Key; // internal
DWORD LineNumber; // line number in file
PWSTR FileName; // full filename
DWORD64 Address; // first instruction of line
} IMAGEHLP_LINEW64, *PIMAGEHLP_LINEW64;
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define IMAGEHLP_LINE IMAGEHLP_LINE64
#define PIMAGEHLP_LINE PIMAGEHLP_LINE64
#else
typedef struct _IMAGEHLP_LINE
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_LINE)
PVOID Key; // internal
DWORD LineNumber; // line number in file
PCHAR FileName; // full filename
DWORD Address; // first instruction of line
} IMAGEHLP_LINE, *PIMAGEHLP_LINE;
typedef struct _IMAGEHLP_LINEW
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_LINE64)
PVOID Key; // internal
DWORD LineNumber; // line number in file
PCHAR FileName; // full filename
DWORD64 Address; // first instruction of line
} IMAGEHLP_LINEW, *PIMAGEHLP_LINEW;
#endif
//
// source file structure
//
typedef struct _SOURCEFILE
{
DWORD64 ModBase; // base address of loaded module
PCHAR FileName; // full filename of source
} SOURCEFILE, *PSOURCEFILE;
typedef struct _SOURCEFILEW
{
DWORD64 ModBase; // base address of loaded module
PWSTR FileName; // full filename of source
} SOURCEFILEW, *PSOURCEFILEW;
//
// data structures used for registered symbol callbacks
//
#define CBA_DEFERRED_SYMBOL_LOAD_START 0x00000001
#define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE 0x00000002
#define CBA_DEFERRED_SYMBOL_LOAD_FAILURE 0x00000003
#define CBA_SYMBOLS_UNLOADED 0x00000004
#define CBA_DUPLICATE_SYMBOL 0x00000005
#define CBA_READ_MEMORY 0x00000006
#define CBA_DEFERRED_SYMBOL_LOAD_CANCEL 0x00000007
#define CBA_SET_OPTIONS 0x00000008
#define CBA_EVENT 0x00000010
#define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL 0x00000020
#define CBA_DEBUG_INFO 0x10000000
#define CBA_SRCSRV_INFO 0x20000000
#define CBA_SRCSRV_EVENT 0x40000000
typedef struct _IMAGEHLP_CBA_READ_MEMORY
{
DWORD64 addr; // address to read from
PVOID buf; // buffer to read to
DWORD bytes; // amount of bytes to read
DWORD* bytesread; // pointer to store amount of bytes read
} IMAGEHLP_CBA_READ_MEMORY, *PIMAGEHLP_CBA_READ_MEMORY;
enum
{
sevInfo = 0,
sevProblem,
sevAttn,
sevFatal,
sevMax // unused
};
#define EVENT_SRCSPEW_START 100
#define EVENT_SRCSPEW 100
#define EVENT_SRCSPEW_END 199
typedef struct _IMAGEHLP_CBA_EVENT
{
DWORD severity; // values from sevInfo to sevFatal
DWORD code; // numerical code IDs the error
PCHAR desc; // may contain a text description of the error
PVOID object; // value dependant upon the error code
} IMAGEHLP_CBA_EVENT, *PIMAGEHLP_CBA_EVENT;
typedef struct _IMAGEHLP_CBA_EVENTW
{
DWORD severity; // values from sevInfo to sevFatal
DWORD code; // numerical code IDs the error
PCWSTR desc; // may contain a text description of the error
PVOID object; // value dependant upon the error code
} IMAGEHLP_CBA_EVENTW, *PIMAGEHLP_CBA_EVENTW;
typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD64)
DWORD64 BaseOfImage; // base load address of module
DWORD CheckSum; // checksum from the pe header
DWORD TimeDateStamp; // date/time stamp from pe header
CHAR FileName[MAX_PATH]; // symbols file or image name
BOOLEAN Reparse; // load failure reparse
HANDLE hFile; // file handle, if passed
DWORD Flags; //
} IMAGEHLP_DEFERRED_SYMBOL_LOAD64, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD64;
typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOADW64
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOADW64)
DWORD64 BaseOfImage; // base load address of module
DWORD CheckSum; // checksum from the pe header
DWORD TimeDateStamp; // date/time stamp from pe header
WCHAR FileName[MAX_PATH + 1]; // symbols file or image name
BOOLEAN Reparse; // load failure reparse
HANDLE hFile; // file handle, if passed
DWORD Flags; //
} IMAGEHLP_DEFERRED_SYMBOL_LOADW64, *PIMAGEHLP_DEFERRED_SYMBOL_LOADW64;
#define DSLFLAG_MISMATCHED_PDB 0x1
#define DSLFLAG_MISMATCHED_DBG 0x2
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64
#define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64
#else
typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DEFERRED_SYMBOL_LOAD)
DWORD BaseOfImage; // base load address of module
DWORD CheckSum; // checksum from the pe header
DWORD TimeDateStamp; // date/time stamp from pe header
CHAR FileName[MAX_PATH]; // symbols file or image name
BOOLEAN Reparse; // load failure reparse
HANDLE hFile; // file handle, if passed
} IMAGEHLP_DEFERRED_SYMBOL_LOAD, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
#endif
typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL64)
DWORD NumberOfDups; // number of duplicates in the Symbol array
PIMAGEHLP_SYMBOL64 Symbol; // array of duplicate symbols
DWORD SelectedSymbol; // symbol selected (-1 to start)
} IMAGEHLP_DUPLICATE_SYMBOL64, *PIMAGEHLP_DUPLICATE_SYMBOL64;
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64
#define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64
#else
typedef struct _IMAGEHLP_DUPLICATE_SYMBOL
{
DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_DUPLICATE_SYMBOL)
DWORD NumberOfDups; // number of duplicates in the Symbol array
PIMAGEHLP_SYMBOL Symbol; // array of duplicate symbols
DWORD SelectedSymbol; // symbol selected (-1 to start)
} IMAGEHLP_DUPLICATE_SYMBOL, *PIMAGEHLP_DUPLICATE_SYMBOL;
#endif
// If dbghelp ever needs to display graphical UI, it will use this as the parent window.
BOOL
IMAGEAPI
SymSetParentWindow(
__in HWND hwnd
);
PCHAR
IMAGEAPI
SymSetHomeDirectory(
__in_opt HANDLE hProcess,
__in_opt PCSTR dir
);
PWSTR
IMAGEAPI
SymSetHomeDirectoryW(
__in_opt HANDLE hProcess,
__in_opt PCWSTR dir
);
PCHAR
IMAGEAPI
SymGetHomeDirectory(
__in DWORD type,
__out_ecount(size) PSTR dir,
__in size_t size
);
PWSTR
IMAGEAPI
SymGetHomeDirectoryW(
__in DWORD type,
__out_ecount(size) PWSTR dir,
__in size_t size
);
enum
{
hdBase = 0, // root directory for dbghelp
hdSym, // where symbols are stored
hdSrc, // where source is stored
hdMax // end marker
};
typedef struct _OMAP
{
ULONG rva;
ULONG rvaTo;
} OMAP, *POMAP;
BOOL
IMAGEAPI
SymGetOmaps(
__in HANDLE hProcess,
__in DWORD64 BaseOfDll,
__out POMAP* OmapTo,
__out PDWORD64 cOmapTo,
__out POMAP* OmapFrom,
__out PDWORD64 cOmapFrom
);
//
// options that are set/returned by SymSetOptions() & SymGetOptions()
// these are used as a mask
//
#define SYMOPT_CASE_INSENSITIVE 0x00000001
#define SYMOPT_UNDNAME 0x00000002
#define SYMOPT_DEFERRED_LOADS 0x00000004
#define SYMOPT_NO_CPP 0x00000008
#define SYMOPT_LOAD_LINES 0x00000010
#define SYMOPT_OMAP_FIND_NEAREST 0x00000020
#define SYMOPT_LOAD_ANYTHING 0x00000040
#define SYMOPT_IGNORE_CVREC 0x00000080
#define SYMOPT_NO_UNQUALIFIED_LOADS 0x00000100
#define SYMOPT_FAIL_CRITICAL_ERRORS 0x00000200
#define SYMOPT_EXACT_SYMBOLS 0x00000400
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800
#define SYMOPT_IGNORE_NT_SYMPATH 0x00001000
#define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000
#define SYMOPT_PUBLICS_ONLY 0x00004000
#define SYMOPT_NO_PUBLICS 0x00008000
#define SYMOPT_AUTO_PUBLICS 0x00010000
#define SYMOPT_NO_IMAGE_SEARCH 0x00020000
#define SYMOPT_SECURE 0x00040000
#define SYMOPT_NO_PROMPTS 0x00080000
#define SYMOPT_OVERWRITE 0x00100000
#define SYMOPT_IGNORE_IMAGEDIR 0x00200000
#define SYMOPT_FLAT_DIRECTORY 0x00400000
#define SYMOPT_FAVOR_COMPRESSED 0x00800000
#define SYMOPT_ALLOW_ZERO_ADDRESS 0x01000000
#define SYMOPT_DISABLE_SYMSRV_AUTODETECT 0x02000000
#define SYMOPT_DEBUG 0x80000000
DWORD
IMAGEAPI
SymSetOptions(
__in DWORD SymOptions
);
DWORD
IMAGEAPI
SymGetOptions(
VOID
);
BOOL
IMAGEAPI
SymCleanup(
__in HANDLE hProcess
);
BOOL
IMAGEAPI
SymMatchString(
__in PCSTR string,
__in PCSTR expression,
__in BOOL fCase
);
BOOL
IMAGEAPI
SymMatchStringA(
__in PCSTR string,
__in PCSTR expression,
__in BOOL fCase
);
BOOL
IMAGEAPI
SymMatchStringW(
__in PCWSTR string,
__in PCWSTR expression,
__in BOOL fCase
);
typedef BOOL
(CALLBACK* PSYM_ENUMSOURCEFILES_CALLBACK)(
__in PSOURCEFILE pSourceFile,
__in_opt PVOID UserContext
);
// for backwards compatibility - don't use this
#define PSYM_ENUMSOURCFILES_CALLBACK PSYM_ENUMSOURCEFILES_CALLBACK
BOOL
IMAGEAPI
SymEnumSourceFiles(
__in HANDLE hProcess,
__in ULONG64 ModBase,
__in_opt PCSTR Mask,
__in PSYM_ENUMSOURCEFILES_CALLBACK cbSrcFiles,
__in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK* PSYM_ENUMSOURCEFILES_CALLBACKW)(
__in PSOURCEFILEW pSourceFile,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumSourceFilesW(
__in HANDLE hProcess,
__in ULONG64 ModBase,
__in_opt PCWSTR Mask,
__in PSYM_ENUMSOURCEFILES_CALLBACKW cbSrcFiles,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumerateModules64(
__in HANDLE hProcess,
__in PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumerateModulesW64(
__in HANDLE hProcess,
__in PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback,
__in_opt PVOID UserContext
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymEnumerateModules SymEnumerateModules64
#else
BOOL
IMAGEAPI
SymEnumerateModules(
__in HANDLE hProcess,
__in PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,
__in_opt PVOID UserContext
);
#endif
BOOL
IMAGEAPI
EnumerateLoadedModulesEx(
__in HANDLE hProcess,
__in PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
EnumerateLoadedModulesExW(
__in HANDLE hProcess,
__in PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
EnumerateLoadedModules64(
__in HANDLE hProcess,
__in PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
EnumerateLoadedModulesW64(
__in HANDLE hProcess,
__in PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback,
__in_opt PVOID UserContext
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define EnumerateLoadedModules EnumerateLoadedModules64
#else
BOOL
IMAGEAPI
EnumerateLoadedModules(
__in HANDLE hProcess,
__in PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback,
__in_opt PVOID UserContext
);
#endif
PVOID
IMAGEAPI
SymFunctionTableAccess64(
__in HANDLE hProcess,
__in DWORD64 AddrBase
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymFunctionTableAccess SymFunctionTableAccess64
#else
PVOID
IMAGEAPI
SymFunctionTableAccess(
__in HANDLE hProcess,
__in DWORD AddrBase
);
#endif
BOOL
IMAGEAPI
SymGetUnwindInfo(
__in HANDLE hProcess,
__in DWORD64 Address,
__out_bcount_opt(*Size) PVOID Buffer,
__inout PULONG Size
);
BOOL
IMAGEAPI
SymGetModuleInfo64(
__in HANDLE hProcess,
__in DWORD64 qwAddr,
__out PIMAGEHLP_MODULE64 ModuleInfo
);
BOOL
IMAGEAPI
SymGetModuleInfoW64(
__in HANDLE hProcess,
__in DWORD64 qwAddr,
__out PIMAGEHLP_MODULEW64 ModuleInfo
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetModuleInfo SymGetModuleInfo64
#define SymGetModuleInfoW SymGetModuleInfoW64
#else
BOOL
IMAGEAPI
SymGetModuleInfo(
__in HANDLE hProcess,
__in DWORD dwAddr,
__out PIMAGEHLP_MODULE ModuleInfo
);
BOOL
IMAGEAPI
SymGetModuleInfoW(
__in HANDLE hProcess,
__in DWORD dwAddr,
__out PIMAGEHLP_MODULEW ModuleInfo
);
#endif
DWORD64
IMAGEAPI
SymGetModuleBase64(
__in HANDLE hProcess,
__in DWORD64 qwAddr
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetModuleBase SymGetModuleBase64
#else
DWORD
IMAGEAPI
SymGetModuleBase(
__in HANDLE hProcess,
__in DWORD dwAddr
);
#endif
typedef struct _SRCCODEINFO
{
DWORD SizeOfStruct; // set to sizeof(SRCCODEINFO)
PVOID Key; // not used
DWORD64 ModBase; // base address of module this applies to
CHAR Obj[MAX_PATH + 1]; // the object file within the module
CHAR FileName[MAX_PATH + 1]; // full filename
DWORD LineNumber; // line number in file
DWORD64 Address; // first instruction of line
} SRCCODEINFO, *PSRCCODEINFO;
typedef struct _SRCCODEINFOW
{
DWORD SizeOfStruct; // set to sizeof(SRCCODEINFO)
PVOID Key; // not used
DWORD64 ModBase; // base address of module this applies to
WCHAR Obj[MAX_PATH + 1]; // the object file within the module
WCHAR FileName[MAX_PATH + 1]; // full filename
DWORD LineNumber; // line number in file
DWORD64 Address; // first instruction of line
} SRCCODEINFOW, *PSRCCODEINFOW;
typedef BOOL
(CALLBACK* PSYM_ENUMLINES_CALLBACK)(
__in PSRCCODEINFO LineInfo,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumLines(
__in HANDLE hProcess,
__in ULONG64 Base,
__in_opt PCSTR Obj,
__in_opt PCSTR File,
__in PSYM_ENUMLINES_CALLBACK EnumLinesCallback,
__in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK* PSYM_ENUMLINES_CALLBACKW)(
__in PSRCCODEINFOW LineInfo,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumLinesW(
__in HANDLE hProcess,
__in ULONG64 Base,
__in_opt PCWSTR Obj,
__in_opt PCWSTR File,
__in PSYM_ENUMLINES_CALLBACKW EnumLinesCallback,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymGetLineFromAddr64(
__in HANDLE hProcess,
__in DWORD64 qwAddr,
__out PDWORD pdwDisplacement,
__out PIMAGEHLP_LINE64 Line64
);
BOOL
IMAGEAPI
SymGetLineFromAddrW64(
__in HANDLE hProcess,
__in DWORD64 dwAddr,
__out PDWORD pdwDisplacement,
__out PIMAGEHLP_LINEW64 Line
);
BOOL
IMAGEAPI
SymEnumSourceLines(
__in HANDLE hProcess,
__in ULONG64 Base,
__in_opt PCSTR Obj,
__in_opt PCSTR File,
__in_opt DWORD Line,
__in DWORD Flags,
__in PSYM_ENUMLINES_CALLBACK EnumLinesCallback,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumSourceLinesW(
__in HANDLE hProcess,
__in ULONG64 Base,
__in_opt PCWSTR Obj,
__in_opt PCWSTR File,
__in_opt DWORD Line,
__in DWORD Flags,
__in PSYM_ENUMLINES_CALLBACKW EnumLinesCallback,
__in_opt PVOID UserContext
);
// flags for SymEnumSourceLines
#define ESLFLAG_FULLPATH 0x1
#define ESLFLAG_NEAREST 0x2
#define ESLFLAG_PREV 0x4
#define ESLFLAG_NEXT 0x8
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetLineFromAddr SymGetLineFromAddr64
#define SymGetLineFromAddrW SymGetLineFromAddrW64
#else
BOOL
IMAGEAPI
SymGetLineFromAddr(
__in HANDLE hProcess,
__in DWORD dwAddr,
__out PDWORD pdwDisplacement,
__out PIMAGEHLP_LINE Line
);
BOOL
IMAGEAPI
SymGetLineFromAddrW(
__in HANDLE hProcess,
__in DWORD dwAddr,
__out PDWORD pdwDisplacement,
__out PIMAGEHLP_LINEW Line
);
#endif
BOOL
IMAGEAPI
SymGetLineFromName64(
__in HANDLE hProcess,
__in_opt PCSTR ModuleName,
__in_opt PCSTR FileName,
__in DWORD dwLineNumber,
__out PLONG plDisplacement,
__inout PIMAGEHLP_LINE64 Line
);
BOOL
IMAGEAPI
SymGetLineFromNameW64(
__in HANDLE hProcess,
__in_opt PCWSTR ModuleName,
__in_opt PCWSTR FileName,
__in DWORD dwLineNumber,
__out PLONG plDisplacement,
__inout PIMAGEHLP_LINEW64 Line
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetLineFromName SymGetLineFromName64
#else
BOOL
IMAGEAPI
SymGetLineFromName(
__in HANDLE hProcess,
__in_opt PCSTR ModuleName,
__in_opt PCSTR FileName,
__in DWORD dwLineNumber,
__out PLONG plDisplacement,
__inout PIMAGEHLP_LINE Line
);
#endif
BOOL
IMAGEAPI
SymGetLineNext64(
__in HANDLE hProcess,
__inout PIMAGEHLP_LINE64 Line
);
BOOL
IMAGEAPI
SymGetLineNextW64(
__in HANDLE hProcess,
__inout PIMAGEHLP_LINEW64 Line
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetLineNext SymGetLineNext64
#else
BOOL
IMAGEAPI
SymGetLineNext(
__in HANDLE hProcess,
__inout PIMAGEHLP_LINE Line
);
BOOL
IMAGEAPI
SymGetLineNextW(
__in HANDLE hProcess,
__inout PIMAGEHLP_LINEW Line
);
#endif
BOOL
IMAGEAPI
SymGetLinePrev64(
__in HANDLE hProcess,
__inout PIMAGEHLP_LINE64 Line
);
BOOL
IMAGEAPI
SymGetLinePrevW64(
__in HANDLE hProcess,
__inout PIMAGEHLP_LINEW64 Line
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetLinePrev SymGetLinePrev64
#else
BOOL
IMAGEAPI
SymGetLinePrev(
__in HANDLE hProcess,
__inout PIMAGEHLP_LINE Line
);
BOOL
IMAGEAPI
SymGetLinePrevW(
__in HANDLE hProcess,
__inout PIMAGEHLP_LINEW Line
);
#endif
ULONG
IMAGEAPI
SymGetFileLineOffsets64(
__in HANDLE hProcess,
__in_opt PCSTR ModuleName,
__in PCSTR FileName,
__out_ecount(BufferLines) PDWORD64 Buffer,
__in ULONG BufferLines
);
BOOL
IMAGEAPI
SymMatchFileName(
__in PCSTR FileName,
__in PCSTR Match,
__deref_opt_out PSTR* FileNameStop,
__deref_opt_out PSTR* MatchStop
);
BOOL
IMAGEAPI
SymMatchFileNameW(
__in PCWSTR FileName,
__in PCWSTR Match,
__deref_opt_out PWSTR* FileNameStop,
__deref_opt_out PWSTR* MatchStop
);
BOOL
IMAGEAPI
SymGetSourceFile(
__in HANDLE hProcess,
__in ULONG64 Base,
__in_opt PCSTR Params,
__in PCSTR FileSpec,
__out_ecount(Size) PSTR FilePath,
__in DWORD Size
);
BOOL
IMAGEAPI
SymGetSourceFileW(
__in HANDLE hProcess,
__in ULONG64 Base,
__in_opt PCWSTR Params,
__in PCWSTR FileSpec,
__out_ecount(Size) PWSTR FilePath,
__in DWORD Size
);
BOOL
IMAGEAPI
SymGetSourceFileToken(
__in HANDLE hProcess,
__in ULONG64 Base,
__in PCSTR FileSpec,
__deref_out PVOID* Token,
__out DWORD* Size
);
BOOL
IMAGEAPI
SymGetSourceFileTokenW(
__in HANDLE hProcess,
__in ULONG64 Base,
__in PCWSTR FileSpec,
__deref_out PVOID* Token,
__out DWORD* Size
);
BOOL
IMAGEAPI
SymGetSourceFileFromToken(
__in HANDLE hProcess,
__in PVOID Token,
__in_opt PCSTR Params,
__out_ecount(Size) PSTR FilePath,
__in DWORD Size
);
BOOL
IMAGEAPI
SymGetSourceFileFromTokenW(
__in HANDLE hProcess,
__in PVOID Token,
__in_opt PCWSTR Params,
__out_ecount(Size) PWSTR FilePath,
__in DWORD Size
);
BOOL
IMAGEAPI
SymGetSourceVarFromToken(
__in HANDLE hProcess,
__in PVOID Token,
__in_opt PCSTR Params,
__in PCSTR VarName,
__out_ecount(Size) PSTR Value,
__in DWORD Size
);
BOOL
IMAGEAPI
SymGetSourceVarFromTokenW(
__in HANDLE hProcess,
__in PVOID Token,
__in_opt PCWSTR Params,
__in PCWSTR VarName,
__out_ecount(Size) PWSTR Value,
__in DWORD Size
);
typedef BOOL (CALLBACK* PENUMSOURCEFILETOKENSCALLBACK)(__in PVOID token, __in size_t size);
BOOL
IMAGEAPI
SymEnumSourceFileTokens(
__in HANDLE hProcess,
__in ULONG64 Base,
__in PENUMSOURCEFILETOKENSCALLBACK Callback
);
BOOL
IMAGEAPI
SymInitialize(
__in HANDLE hProcess,
__in_opt PCSTR UserSearchPath,
__in BOOL fInvadeProcess
);
BOOL
IMAGEAPI
SymInitializeW(
__in HANDLE hProcess,
__in_opt PCWSTR UserSearchPath,
__in BOOL fInvadeProcess
);
BOOL
IMAGEAPI
SymGetSearchPath(
__in HANDLE hProcess,
__out_ecount(SearchPathLength) PSTR SearchPath,
__in DWORD SearchPathLength
);
BOOL
IMAGEAPI
SymGetSearchPathW(
__in HANDLE hProcess,
__out_ecount(SearchPathLength) PWSTR SearchPath,
__in DWORD SearchPathLength
);
BOOL
IMAGEAPI
SymSetSearchPath(
__in HANDLE hProcess,
__in_opt PCSTR SearchPath
);
BOOL
IMAGEAPI
SymSetSearchPathW(
__in HANDLE hProcess,
__in_opt PCWSTR SearchPath
);
#define SLMFLAG_VIRTUAL 0x1
#define SLMFLAG_ALT_INDEX 0x2
#define SLMFLAG_NO_SYMBOLS 0x4
DWORD64
IMAGEAPI
SymLoadModuleEx(
__in HANDLE hProcess,
__in_opt HANDLE hFile,
__in_opt PCSTR ImageName,
__in_opt PCSTR ModuleName,
__in DWORD64 BaseOfDll,
__in DWORD DllSize,
__in_opt PMODLOAD_DATA Data,
__in_opt DWORD Flags
);
DWORD64
IMAGEAPI
SymLoadModuleExW(
__in HANDLE hProcess,
__in_opt HANDLE hFile,
__in_opt PCWSTR ImageName,
__in_opt PCWSTR ModuleName,
__in DWORD64 BaseOfDll,
__in DWORD DllSize,
__in_opt PMODLOAD_DATA Data,
__in_opt DWORD Flags
);
BOOL
IMAGEAPI
SymUnloadModule64(
__in HANDLE hProcess,
__in DWORD64 BaseOfDll
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymUnloadModule SymUnloadModule64
#else
BOOL
IMAGEAPI
SymUnloadModule(
__in HANDLE hProcess,
__in DWORD BaseOfDll
);
#endif
BOOL
IMAGEAPI
SymUnDName64(
__in PIMAGEHLP_SYMBOL64 sym, // Symbol to undecorate
__out_ecount(UnDecNameLength) PSTR UnDecName, // Buffer to store undecorated name in
__in DWORD UnDecNameLength // Size of the buffer
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymUnDName SymUnDName64
#else
BOOL
IMAGEAPI
SymUnDName(
__in PIMAGEHLP_SYMBOL sym, // Symbol to undecorate
__out_ecount(UnDecNameLength) PSTR UnDecName, // Buffer to store undecorated name in
__in DWORD UnDecNameLength // Size of the buffer
);
#endif
BOOL
IMAGEAPI
SymRegisterCallback64(
__in HANDLE hProcess,
__in PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,
__in ULONG64 UserContext
);
BOOL
IMAGEAPI
SymRegisterCallbackW64(
__in HANDLE hProcess,
__in PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,
__in ULONG64 UserContext
);
BOOL
IMAGEAPI
SymRegisterFunctionEntryCallback64(
__in HANDLE hProcess,
__in PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction,
__in ULONG64 UserContext
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymRegisterCallback SymRegisterCallback64
#define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64
#else
BOOL
IMAGEAPI
SymRegisterCallback(
__in HANDLE hProcess,
__in PSYMBOL_REGISTERED_CALLBACK CallbackFunction,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymRegisterFunctionEntryCallback(
__in HANDLE hProcess,
__in PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction,
__in_opt PVOID UserContext
);
#endif
typedef struct _IMAGEHLP_SYMBOL_SRC
{
DWORD sizeofstruct;
DWORD type;
char file[MAX_PATH];
} IMAGEHLP_SYMBOL_SRC, *PIMAGEHLP_SYMBOL_SRC;
typedef struct _MODULE_TYPE_INFO // AKA TYPTYP
{
USHORT dataLength;
USHORT leaf;
BYTE data[1];
} MODULE_TYPE_INFO, *PMODULE_TYPE_INFO;
typedef struct _SYMBOL_INFO
{
ULONG SizeOfStruct;
ULONG TypeIndex; // Type Index of symbol
ULONG64 Reserved[2];
ULONG Index;
ULONG Size;
ULONG64 ModBase; // Base Address of module comtaining this symbol
ULONG Flags;
ULONG64 Value; // Value of symbol, ValuePresent should be 1
ULONG64 Address; // Address of symbol including base address of module
ULONG Register; // register holding value or pointer to value
ULONG Scope; // scope of the symbol
ULONG Tag; // pdb classification
ULONG NameLen; // Actual length of name
ULONG MaxNameLen;
CHAR Name[1]; // Name of symbol
} SYMBOL_INFO, *PSYMBOL_INFO;
typedef struct _SYMBOL_INFO_PACKAGE
{
SYMBOL_INFO si;
CHAR name[MAX_SYM_NAME + 1];
} SYMBOL_INFO_PACKAGE, *PSYMBOL_INFO_PACKAGE;
typedef struct _SYMBOL_INFOW
{
ULONG SizeOfStruct;
ULONG TypeIndex; // Type Index of symbol
ULONG64 Reserved[2];
ULONG Index;
ULONG Size;
ULONG64 ModBase; // Base Address of module comtaining this symbol
ULONG Flags;
ULONG64 Value; // Value of symbol, ValuePresent should be 1
ULONG64 Address; // Address of symbol including base address of module
ULONG Register; // register holding value or pointer to value
ULONG Scope; // scope of the symbol
ULONG Tag; // pdb classification
ULONG NameLen; // Actual length of name
ULONG MaxNameLen;
WCHAR Name[1]; // Name of symbol
} SYMBOL_INFOW, *PSYMBOL_INFOW;
typedef struct _SYMBOL_INFO_PACKAGEW
{
SYMBOL_INFOW si;
WCHAR name[MAX_SYM_NAME + 1];
} SYMBOL_INFO_PACKAGEW, *PSYMBOL_INFO_PACKAGEW;
typedef struct _IMAGEHLP_STACK_FRAME
{
ULONG64 InstructionOffset;
ULONG64 ReturnOffset;
ULONG64 FrameOffset;
ULONG64 StackOffset;
ULONG64 BackingStoreOffset;
ULONG64 FuncTableEntry;
ULONG64 Params[4];
ULONG64 Reserved[5];
BOOL Virtual;
ULONG Reserved2;
} IMAGEHLP_STACK_FRAME, *PIMAGEHLP_STACK_FRAME;
typedef VOID IMAGEHLP_CONTEXT, *PIMAGEHLP_CONTEXT;
BOOL
IMAGEAPI
SymSetContext(
__in HANDLE hProcess,
__in PIMAGEHLP_STACK_FRAME StackFrame,
__in_opt PIMAGEHLP_CONTEXT Context
);
BOOL
IMAGEAPI
SymSetScopeFromAddr(
__in HANDLE hProcess,
__in ULONG64 Address
);
BOOL
IMAGEAPI
SymSetScopeFromIndex(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in DWORD Index
);
typedef BOOL
(CALLBACK* PSYM_ENUMPROCESSES_CALLBACK)(
__in HANDLE hProcess,
__in PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumProcesses(
__in PSYM_ENUMPROCESSES_CALLBACK EnumProcessesCallback,
__in PVOID UserContext
);
BOOL
IMAGEAPI
SymFromAddr(
__in HANDLE hProcess,
__in DWORD64 Address,
__out_opt PDWORD64 Displacement,
__inout PSYMBOL_INFO Symbol
);
BOOL
IMAGEAPI
SymFromAddrW(
__in HANDLE hProcess,
__in DWORD64 Address,
__out_opt PDWORD64 Displacement,
__inout PSYMBOL_INFOW Symbol
);
BOOL
IMAGEAPI
SymFromToken(
__in HANDLE hProcess,
__in DWORD64 Base,
__in DWORD Token,
__inout PSYMBOL_INFO Symbol
);
BOOL
IMAGEAPI
SymFromTokenW(
__in HANDLE hProcess,
__in DWORD64 Base,
__in DWORD Token,
__inout PSYMBOL_INFOW Symbol
);
BOOL
IMAGEAPI
SymNext(
__in HANDLE hProcess,
__inout PSYMBOL_INFO si
);
BOOL
IMAGEAPI
SymNextW(
__in HANDLE hProcess,
__inout PSYMBOL_INFOW siw
);
BOOL
IMAGEAPI
SymPrev(
__in HANDLE hProcess,
__inout PSYMBOL_INFO si
);
BOOL
IMAGEAPI
SymPrevW(
__in HANDLE hProcess,
__inout PSYMBOL_INFOW siw
);
// While SymFromName will provide a symbol from a name,
// SymEnumSymbols can provide the same matching information
// for ALL symbols with a matching name, even regular
// expressions. That way you can search across modules
// and differentiate between identically named symbols.
BOOL
IMAGEAPI
SymFromName(
__in HANDLE hProcess,
__in PCSTR Name,
__inout PSYMBOL_INFO Symbol
);
BOOL
IMAGEAPI
SymFromNameW(
__in HANDLE hProcess,
__in PCWSTR Name,
__inout PSYMBOL_INFOW Symbol
);
typedef BOOL
(CALLBACK* PSYM_ENUMERATESYMBOLS_CALLBACK)(
__in PSYMBOL_INFO pSymInfo,
__in ULONG SymbolSize,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumSymbols(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in_opt PCSTR Mask,
__in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
__in_opt PVOID UserContext
);
typedef BOOL
(CALLBACK* PSYM_ENUMERATESYMBOLS_CALLBACKW)(
__in PSYMBOL_INFOW pSymInfo,
__in ULONG SymbolSize,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumSymbolsW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in_opt PCWSTR Mask,
__in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumSymbolsForAddr(
__in HANDLE hProcess,
__in DWORD64 Address,
__in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumSymbolsForAddrW(
__in HANDLE hProcess,
__in DWORD64 Address,
__in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext
);
#define SYMSEARCH_MASKOBJS 0x01 // used internally to implement other APIs
#define SYMSEARCH_RECURSE 0X02 // recurse scopes
#define SYMSEARCH_GLOBALSONLY 0X04 // search only for global symbols
#define SYMSEARCH_ALLITEMS 0X08 // search for everything in the pdb, not just normal scoped symbols
BOOL
IMAGEAPI
SymSearch(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in_opt DWORD Index,
__in_opt DWORD SymTag,
__in_opt PCSTR Mask,
__in_opt DWORD64 Address,
__in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
__in_opt PVOID UserContext,
__in DWORD Options
);
BOOL
IMAGEAPI
SymSearchW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in_opt DWORD Index,
__in_opt DWORD SymTag,
__in_opt PCWSTR Mask,
__in_opt DWORD64 Address,
__in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext,
__in DWORD Options
);
BOOL
IMAGEAPI
SymGetScope(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in DWORD Index,
__inout PSYMBOL_INFO Symbol
);
BOOL
IMAGEAPI
SymGetScopeW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in DWORD Index,
__inout PSYMBOL_INFOW Symbol
);
BOOL
IMAGEAPI
SymFromIndex(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in DWORD Index,
__inout PSYMBOL_INFO Symbol
);
BOOL
IMAGEAPI
SymFromIndexW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in DWORD Index,
__inout PSYMBOL_INFOW Symbol
);
typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO
{
TI_GET_SYMTAG,
TI_GET_SYMNAME,
TI_GET_LENGTH,
TI_GET_TYPE,
TI_GET_TYPEID,
TI_GET_BASETYPE,
TI_GET_ARRAYINDEXTYPEID,
TI_FINDCHILDREN,
TI_GET_DATAKIND,
TI_GET_ADDRESSOFFSET,
TI_GET_OFFSET,
TI_GET_VALUE,
TI_GET_COUNT,
TI_GET_CHILDRENCOUNT,
TI_GET_BITPOSITION,
TI_GET_VIRTUALBASECLASS,
TI_GET_VIRTUALTABLESHAPEID,
TI_GET_VIRTUALBASEPOINTEROFFSET,
TI_GET_CLASSPARENTID,
TI_GET_NESTED,
TI_GET_SYMINDEX,
TI_GET_LEXICALPARENT,
TI_GET_ADDRESS,
TI_GET_THISADJUST,
TI_GET_UDTKIND,
TI_IS_EQUIV_TO,
TI_GET_CALLING_CONVENTION,
TI_IS_CLOSE_EQUIV_TO,
TI_GTIEX_REQS_VALID,
TI_GET_VIRTUALBASEOFFSET,
TI_GET_VIRTUALBASEDISPINDEX,
TI_GET_IS_REFERENCE,
TI_GET_INDIRECTVIRTUALBASECLASS,
IMAGEHLP_SYMBOL_TYPE_INFO_MAX,
} IMAGEHLP_SYMBOL_TYPE_INFO;
typedef struct _TI_FINDCHILDREN_PARAMS
{
ULONG Count;
ULONG Start;
ULONG ChildId[1];
} TI_FINDCHILDREN_PARAMS;
BOOL
IMAGEAPI
SymGetTypeInfo(
__in HANDLE hProcess,
__in DWORD64 ModBase,
__in ULONG TypeId,
__in IMAGEHLP_SYMBOL_TYPE_INFO GetType,
__out PVOID pInfo
);
#define IMAGEHLP_GET_TYPE_INFO_UNCACHED 0x00000001
#define IMAGEHLP_GET_TYPE_INFO_CHILDREN 0x00000002
typedef struct _IMAGEHLP_GET_TYPE_INFO_PARAMS
{
IN ULONG SizeOfStruct;
IN ULONG Flags;
IN ULONG NumIds;
IN PULONG TypeIds;
IN ULONG64 TagFilter;
IN ULONG NumReqs;
IN IMAGEHLP_SYMBOL_TYPE_INFO* ReqKinds;
IN PULONG_PTR ReqOffsets;
IN PULONG ReqSizes;
IN ULONG_PTR ReqStride;
IN ULONG_PTR BufferSize;
OUT PVOID Buffer;
OUT ULONG EntriesMatched;
OUT ULONG EntriesFilled;
OUT ULONG64 TagsFound;
OUT ULONG64 AllReqsValid;
IN ULONG NumReqsValid;
OUT PULONG64 ReqsValid OPTIONAL;
} IMAGEHLP_GET_TYPE_INFO_PARAMS, *PIMAGEHLP_GET_TYPE_INFO_PARAMS;
BOOL
IMAGEAPI
SymGetTypeInfoEx(
__in HANDLE hProcess,
__in DWORD64 ModBase,
__inout PIMAGEHLP_GET_TYPE_INFO_PARAMS Params
);
BOOL
IMAGEAPI
SymEnumTypes(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumTypesW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumTypesByName(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in_opt PCSTR mask,
__in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymEnumTypesByNameW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in_opt PCWSTR mask,
__in PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext
);
BOOL
IMAGEAPI
SymGetTypeFromName(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in PCSTR Name,
__inout PSYMBOL_INFO Symbol
);
BOOL
IMAGEAPI
SymGetTypeFromNameW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in PCWSTR Name,
__inout PSYMBOL_INFOW Symbol
);
BOOL
IMAGEAPI
SymAddSymbol(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in PCSTR Name,
__in DWORD64 Address,
__in DWORD Size,
__in DWORD Flags
);
BOOL
IMAGEAPI
SymAddSymbolW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in PCWSTR Name,
__in DWORD64 Address,
__in DWORD Size,
__in DWORD Flags
);
BOOL
IMAGEAPI
SymDeleteSymbol(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in_opt PCSTR Name,
__in DWORD64 Address,
__in DWORD Flags
);
BOOL
IMAGEAPI
SymDeleteSymbolW(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in_opt PCWSTR Name,
__in DWORD64 Address,
__in DWORD Flags
);
BOOL
IMAGEAPI
SymRefreshModuleList(
__in HANDLE hProcess
);
BOOL
IMAGEAPI
SymAddSourceStream(
__in HANDLE hProcess,
__in ULONG64 Base,
__in_opt PCSTR StreamFile,
__in_bcount_opt(Size) PBYTE Buffer,
__in size_t Size
);
typedef BOOL (WINAPI* SYMADDSOURCESTREAM)(HANDLE, ULONG64, PCSTR, PBYTE, size_t);
BOOL
IMAGEAPI
SymAddSourceStreamA(
__in HANDLE hProcess,
__in ULONG64 Base,
__in_opt PCSTR StreamFile,
__in_bcount_opt(Size) PBYTE Buffer,
__in size_t Size
);
typedef BOOL (WINAPI* SYMADDSOURCESTREAMA)(HANDLE, ULONG64, PCSTR, PBYTE, size_t);
BOOL
IMAGEAPI
SymAddSourceStreamW(
__in HANDLE hProcess,
__in ULONG64 Base,
__in_opt PCWSTR FileSpec,
__in_bcount_opt(Size) PBYTE Buffer,
__in size_t Size
);
BOOL
IMAGEAPI
SymSrvIsStoreW(
__in_opt HANDLE hProcess,
__in PCWSTR path
);
BOOL
IMAGEAPI
SymSrvIsStore(
__in_opt HANDLE hProcess,
__in PCSTR path
);
PCSTR
IMAGEAPI
SymSrvDeltaName(
__in HANDLE hProcess,
__in_opt PCSTR SymPath,
__in PCSTR Type,
__in PCSTR File1,
__in PCSTR File2
);
PCWSTR
IMAGEAPI
SymSrvDeltaNameW(
__in HANDLE hProcess,
__in_opt PCWSTR SymPath,
__in PCWSTR Type,
__in PCWSTR File1,
__in PCWSTR File2
);
PCSTR
IMAGEAPI
SymSrvGetSupplement(
__in HANDLE hProcess,
__in_opt PCSTR SymPath,
__in PCSTR Node,
__in PCSTR File
);
PCWSTR
IMAGEAPI
SymSrvGetSupplementW(
__in HANDLE hProcess,
__in_opt PCWSTR SymPath,
__in PCWSTR Node,
__in PCWSTR File
);
BOOL
IMAGEAPI
SymSrvGetFileIndexes(
__in PCSTR File,
__out GUID* Id,
__out PDWORD Val1,
__out_opt PDWORD Val2,
__in DWORD Flags
);
BOOL
IMAGEAPI
SymSrvGetFileIndexesW(
__in PCWSTR File,
__out GUID* Id,
__out PDWORD Val1,
__out_opt PDWORD Val2,
__in DWORD Flags
);
BOOL
IMAGEAPI
SymSrvGetFileIndexStringW(
__in HANDLE hProcess,
__in_opt PCWSTR SrvPath,
__in PCWSTR File,
__out_ecount(Size) PWSTR Index,
__in size_t Size,
__in DWORD Flags
);
BOOL
IMAGEAPI
SymSrvGetFileIndexString(
__in HANDLE hProcess,
__in_opt PCSTR SrvPath,
__in PCSTR File,
__out_ecount(Size) PSTR Index,
__in size_t Size,
__in DWORD Flags
);
typedef struct
{
DWORD sizeofstruct;
char file[MAX_PATH + 1];
BOOL stripped;
DWORD timestamp;
DWORD size;
char dbgfile[MAX_PATH + 1];
char pdbfile[MAX_PATH + 1];
GUID guid;
DWORD sig;
DWORD age;
} SYMSRV_INDEX_INFO, *PSYMSRV_INDEX_INFO;
typedef struct
{
DWORD sizeofstruct;
WCHAR file[MAX_PATH + 1];
BOOL stripped;
DWORD timestamp;
DWORD size;
WCHAR dbgfile[MAX_PATH + 1];
WCHAR pdbfile[MAX_PATH + 1];
GUID guid;
DWORD sig;
DWORD age;
} SYMSRV_INDEX_INFOW, *PSYMSRV_INDEX_INFOW;
BOOL
IMAGEAPI
SymSrvGetFileIndexInfo(
__in PCSTR File,
__out PSYMSRV_INDEX_INFO Info,
__in DWORD Flags
);
BOOL
IMAGEAPI
SymSrvGetFileIndexInfoW(
__in PCWSTR File,
__out PSYMSRV_INDEX_INFOW Info,
__in DWORD Flags
);
PCSTR
IMAGEAPI
SymSrvStoreSupplement(
__in HANDLE hProcess,
__in_opt PCSTR SrvPath,
__in PCSTR Node,
__in PCSTR File,
__in DWORD Flags
);
PCWSTR
IMAGEAPI
SymSrvStoreSupplementW(
__in HANDLE hProcess,
__in_opt PCWSTR SymPath,
__in PCWSTR Node,
__in PCWSTR File,
__in DWORD Flags
);
PCSTR
IMAGEAPI
SymSrvStoreFile(
__in HANDLE hProcess,
__in_opt PCSTR SrvPath,
__in PCSTR File,
__in DWORD Flags
);
PCWSTR
IMAGEAPI
SymSrvStoreFileW(
__in HANDLE hProcess,
__in_opt PCWSTR SrvPath,
__in PCWSTR File,
__in DWORD Flags
);
// used by SymGetSymbolFile's "Type" parameter
enum
{
sfImage = 0,
sfDbg,
sfPdb,
sfMpd,
sfMax
};
BOOL
IMAGEAPI
SymGetSymbolFile(
__in_opt HANDLE hProcess,
__in_opt PCSTR SymPath,
__in PCSTR ImageFile,
__in DWORD Type,
__out_ecount(cSymbolFile) PSTR SymbolFile,
__in size_t cSymbolFile,
__out_ecount(cDbgFile) PSTR DbgFile,
__in size_t cDbgFile
);
BOOL
IMAGEAPI
SymGetSymbolFileW(
__in_opt HANDLE hProcess,
__in_opt PCWSTR SymPath,
__in PCWSTR ImageFile,
__in DWORD Type,
__out_ecount(cSymbolFile) PWSTR SymbolFile,
__in size_t cSymbolFile,
__out_ecount(cDbgFile) PWSTR DbgFile,
__in size_t cDbgFile
);
//
// Full user-mode dump creation.
//
typedef BOOL (WINAPI* PDBGHELP_CREATE_USER_DUMP_CALLBACK)(
__in DWORD DataType,
__in PVOID* Data,
__out LPDWORD DataLength,
__in_opt PVOID UserData
);
BOOL
WINAPI
DbgHelpCreateUserDump(
__in_opt LPCSTR FileName,
__in PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,
__in_opt PVOID UserData
);
BOOL
WINAPI
DbgHelpCreateUserDumpW(
__in_opt LPCWSTR FileName,
__in PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,
__in_opt PVOID UserData
);
// -----------------------------------------------------------------
// The following 4 legacy APIs are fully supported, but newer
// ones are recommended. SymFromName and SymFromAddr provide
// much more detailed info on the returned symbol.
BOOL
IMAGEAPI
SymGetSymFromAddr64(
__in HANDLE hProcess,
__in DWORD64 qwAddr,
__out_opt PDWORD64 pdwDisplacement,
__inout PIMAGEHLP_SYMBOL64 Symbol
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetSymFromAddr SymGetSymFromAddr64
#else
BOOL
IMAGEAPI
SymGetSymFromAddr(
__in HANDLE hProcess,
__in DWORD dwAddr,
__out_opt PDWORD pdwDisplacement,
__inout PIMAGEHLP_SYMBOL Symbol
);
#endif
// While following two APIs will provide a symbol from a name,
// SymEnumSymbols can provide the same matching information
// for ALL symbols with a matching name, even regular
// expressions. That way you can search across modules
// and differentiate between identically named symbols.
BOOL
IMAGEAPI
SymGetSymFromName64(
__in HANDLE hProcess,
__in PCSTR Name,
__inout PIMAGEHLP_SYMBOL64 Symbol
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetSymFromName SymGetSymFromName64
#else
BOOL
IMAGEAPI
SymGetSymFromName(
__in HANDLE hProcess,
__in PCSTR Name,
__inout PIMAGEHLP_SYMBOL Symbol
);
#endif
// Symbol server exports
typedef BOOL (WINAPI* PSYMBOLSERVERPROC)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR);
typedef BOOL (WINAPI* PSYMBOLSERVERPROCA)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR);
typedef BOOL (WINAPI* PSYMBOLSERVERPROCW)(PCWSTR, PCWSTR, PVOID, DWORD, DWORD, PWSTR);
typedef BOOL (WINAPI* PSYMBOLSERVERBYINDEXPROC)(PCSTR, PCSTR, PCSTR, PSTR);
typedef BOOL (WINAPI* PSYMBOLSERVERBYINDEXPROCA)(PCSTR, PCSTR, PCSTR, PSTR);
typedef BOOL (WINAPI* PSYMBOLSERVERBYINDEXPROCW)(PCWSTR, PCWSTR, PCWSTR, PWSTR);
typedef BOOL (WINAPI* PSYMBOLSERVEROPENPROC)(VOID);
typedef BOOL (WINAPI* PSYMBOLSERVERCLOSEPROC)(VOID);
typedef BOOL (WINAPI* PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR, ULONG64);
typedef BOOL (WINAPI* PSYMBOLSERVERSETOPTIONSWPROC)(UINT_PTR, ULONG64);
typedef BOOL (CALLBACK WINAPI* PSYMBOLSERVERCALLBACKPROC)(UINT_PTR action, ULONG64 data, ULONG64 context);
typedef UINT_PTR(WINAPI* PSYMBOLSERVERGETOPTIONSPROC)();
typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROC)(PCSTR);
typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROCA)(PCSTR);
typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROCW)(PCWSTR);
typedef BOOL (WINAPI* PSYMBOLSERVERGETVERSION)(LPAPI_VERSION);
typedef BOOL (WINAPI* PSYMBOLSERVERDELTANAME)(PCSTR, PVOID, DWORD, DWORD, PVOID, DWORD, DWORD, PSTR, size_t);
typedef BOOL (WINAPI* PSYMBOLSERVERDELTANAMEW)(PCWSTR, PVOID, DWORD, DWORD, PVOID, DWORD, DWORD, PWSTR, size_t);
typedef BOOL (WINAPI* PSYMBOLSERVERGETSUPPLEMENT)(PCSTR, PCSTR, PCSTR, PSTR, size_t);
typedef BOOL (WINAPI* PSYMBOLSERVERGETSUPPLEMENTW)(PCWSTR, PCWSTR, PCWSTR, PWSTR, size_t);
typedef BOOL (WINAPI* PSYMBOLSERVERSTORESUPPLEMENT)(PCSTR, PCSTR, PCSTR, PSTR, size_t, DWORD);
typedef BOOL (WINAPI* PSYMBOLSERVERSTORESUPPLEMENTW)(PCWSTR, PCWSTR, PCWSTR, PWSTR, size_t, DWORD);
typedef BOOL (WINAPI* PSYMBOLSERVERGETINDEXSTRING)(PVOID, DWORD, DWORD, PSTR, size_t);
typedef BOOL (WINAPI* PSYMBOLSERVERGETINDEXSTRINGW)(PVOID, DWORD, DWORD, PWSTR, size_t);
typedef BOOL (WINAPI* PSYMBOLSERVERSTOREFILE)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR, size_t, DWORD);
typedef BOOL (WINAPI* PSYMBOLSERVERSTOREFILEW)(PCWSTR, PCWSTR, PVOID, DWORD, DWORD, PWSTR, size_t, DWORD);
typedef BOOL (WINAPI* PSYMBOLSERVERISSTORE)(PCSTR);
typedef BOOL (WINAPI* PSYMBOLSERVERISSTOREW)(PCWSTR);
typedef DWORD (WINAPI* PSYMBOLSERVERVERSION)();
typedef BOOL (CALLBACK WINAPI* PSYMBOLSERVERMESSAGEPROC)(UINT_PTR action, ULONG64 data, ULONG64 context);
#define SYMSRV_VERSION 2
#define SSRVOPT_CALLBACK 0x00000001
#define SSRVOPT_DWORD 0x00000002
#define SSRVOPT_DWORDPTR 0x00000004
#define SSRVOPT_GUIDPTR 0x00000008
#define SSRVOPT_OLDGUIDPTR 0x00000010
#define SSRVOPT_UNATTENDED 0x00000020
#define SSRVOPT_NOCOPY 0x00000040
#define SSRVOPT_GETPATH 0x00000040
#define SSRVOPT_PARENTWIN 0x00000080
#define SSRVOPT_PARAMTYPE 0x00000100
#define SSRVOPT_SECURE 0x00000200
#define SSRVOPT_TRACE 0x00000400
#define SSRVOPT_SETCONTEXT 0x00000800
#define SSRVOPT_PROXY 0x00001000
#define SSRVOPT_DOWNSTREAM_STORE 0x00002000
#define SSRVOPT_OVERWRITE 0x00004000
#define SSRVOPT_RESETTOU 0x00008000
#define SSRVOPT_CALLBACKW 0x00010000
#define SSRVOPT_FLAT_DEFAULT_STORE 0x00020000
#define SSRVOPT_PROXYW 0x00040000
#define SSRVOPT_MESSAGE 0x00080000
#define SSRVOPT_SERVICE 0x00100000 // deprecated
#define SSRVOPT_FAVOR_COMPRESSED 0x00200000
#define SSRVOPT_STRING 0x00400000
#define SSRVOPT_WINHTTP 0x00800000
#define SSRVOPT_WININET 0x01000000
#define SSRVOPT_MAX 0x0100000
#define SSRVOPT_RESET ((ULONG_PTR)-1)
#define NUM_SSRVOPTS 30
#define SSRVACTION_TRACE 1
#define SSRVACTION_QUERYCANCEL 2
#define SSRVACTION_EVENT 3
#define SSRVACTION_EVENTW 4
#define SSRVACTION_SIZE 5
#define SYMSTOREOPT_COMPRESS 0x01
#define SYMSTOREOPT_OVERWRITE 0x02
#define SYMSTOREOPT_RETURNINDEX 0x04
#define SYMSTOREOPT_POINTER 0x08
#define SYMSTOREOPT_ALT_INDEX 0x10
#define SYMSTOREOPT_UNICODE 0x20
#define SYMSTOREOPT_PASS_IF_EXISTS 0x40
#ifdef DBGHELP_TRANSLATE_TCHAR
#define SymInitialize SymInitializeW
#define SymAddSymbol SymAddSymbolW
#define SymDeleteSymbol SymDeleteSymbolW
#define SearchTreeForFile SearchTreeForFileW
#define UnDecorateSymbolName UnDecorateSymbolNameW
#define SymGetLineFromName64 SymGetLineFromNameW64
#define SymGetLineFromAddr64 SymGetLineFromAddrW64
#define SymGetLineNext64 SymGetLineNextW64
#define SymGetLinePrev64 SymGetLinePrevW64
#define SymFromName SymFromNameW
#define SymFindExecutableImage SymFindExecutableImageW
#define FindExecutableImageEx FindExecutableImageExW
#define SymSearch SymSearchW
#define SymEnumLines SymEnumLinesW
#define SymEnumSourceLines SymEnumSourceLinesW
#define SymGetTypeFromName SymGetTypeFromNameW
#define SymEnumSymbolsForAddr SymEnumSymbolsForAddrW
#define SymFromAddr SymFromAddrW
#define SymMatchString SymMatchStringW
#define SymEnumSourceFiles SymEnumSourceFilesW
#define SymEnumSymbols SymEnumSymbolsW
#define SymLoadModuleEx SymLoadModuleExW
#define SymSetSearchPath SymSetSearchPathW
#define SymGetSearchPath SymGetSearchPathW
#define EnumDirTree EnumDirTreeW
#define SymFromToken SymFromTokenW
#define SymFromIndex SymFromIndexW
#define SymGetScope SymGetScopeW
#define SymNext SymNextW
#define SymPrev SymPrevW
#define SymEnumTypes SymEnumTypesW
#define SymEnumTypesByName SymEnumTypesByNameW
#define SymRegisterCallback64 SymRegisterCallbackW64
#define SymFindDebugInfoFile SymFindDebugInfoFileW
#define FindDebugInfoFileEx FindDebugInfoFileExW
#define SymFindFileInPath SymFindFileInPathW
#define SymEnumerateModules64 SymEnumerateModulesW64
#define SymSetHomeDirectory SymSetHomeDirectoryW
#define SymGetHomeDirectory SymGetHomeDirectoryW
#define SymGetSourceFile SymGetSourceFileW
#define SymGetSourceFileToken SymGetSourceFileTokenW
#define SymGetSourceFileFromToken SymGetSourceFileFromTokenW
#define SymGetSourceVarFromToken SymGetSourceVarFromTokenW
#define SymGetSourceFileToken SymGetSourceFileTokenW
#define SymGetFileLineOffsets64 SymGetFileLineOffsetsW64
#define SymFindFileInPath SymFindFileInPathW
#define SymMatchFileName SymMatchFileNameW
#define SymGetSourceFileFromToken SymGetSourceFileFromTokenW
#define SymGetSourceVarFromToken SymGetSourceVarFromTokenW
#define SymGetModuleInfo64 SymGetModuleInfoW64
#define SymSrvIsStore SymSrvIsStoreW
#define SymSrvDeltaName SymSrvDeltaNameW
#define SymSrvGetSupplement SymSrvGetSupplementW
#define SymSrvStoreSupplement SymSrvStoreSupplementW
#define SymSrvGetFileIndexes SymSrvGetFileIndexes
#define SymSrvGetFileIndexString SymSrvGetFileIndexStringW
#define SymSrvStoreFile SymSrvStoreFileW
#define SymGetSymbolFile SymGetSymbolFileW
#define EnumerateLoadedModules64 EnumerateLoadedModulesW64
#define EnumerateLoadedModulesEx EnumerateLoadedModulesExW
#define SymSrvGetFileIndexInfo SymSrvGetFileIndexInfoW
#define IMAGEHLP_LINE64 IMAGEHLP_LINEW64
#define PIMAGEHLP_LINE64 PIMAGEHLP_LINEW64
#define SYMBOL_INFO SYMBOL_INFOW
#define PSYMBOL_INFO PSYMBOL_INFOW
#define SYMBOL_INFO_PACKAGE SYMBOL_INFO_PACKAGEW
#define PSYMBOL_INFO_PACKAGE PSYMBOL_INFO_PACKAGEW
#define FIND_EXE_FILE_CALLBACK FIND_EXE_FILE_CALLBACKW
#define PFIND_EXE_FILE_CALLBACK PFIND_EXE_FILE_CALLBACKW
#define SYM_ENUMERATESYMBOLS_CALLBACK SYM_ENUMERATESYMBOLS_CALLBACKW
#define PSYM_ENUMERATESYMBOLS_CALLBACK PSYM_ENUMERATESYMBOLS_CALLBACKW
#define SRCCODEINFO SRCCODEINFOW
#define PSRCCODEINFO PSRCCODEINFOW
#define SOURCEFILE SOURCEFILEW
#define PSOURCEFILE PSOURCEFILEW
#define SYM_ENUMSOURECFILES_CALLBACK SYM_ENUMSOURCEFILES_CALLBACKW
#define PSYM_ENUMSOURCEFILES_CALLBACK PSYM_ENUMSOURECFILES_CALLBACKW
#define IMAGEHLP_CBA_EVENT IMAGEHLP_CBA_EVENTW
#define PIMAGEHLP_CBA_EVENT PIMAGEHLP_CBA_EVENTW
#define PENUMDIRTREE_CALLBACK PENUMDIRTREE_CALLBACKW
#define IMAGEHLP_DEFERRED_SYMBOL_LOAD64 IMAGEHLP_DEFERRED_SYMBOL_LOADW64
#define PIMAGEHLP_DEFERRED_SYMBOL_LOAD64 PIMAGEHLP_DEFERRED_SYMBOL_LOADW64
#define PFIND_DEBUG_FILE_CALLBACK PFIND_DEBUG_FILE_CALLBACKW
#define PFINDFILEINPATHCALLBACK PFINDFILEINPATHCALLBACKW
#define IMAGEHLP_MODULE64 IMAGEHLP_MODULEW64
#define PIMAGEHLP_MODULE64 PIMAGEHLP_MODULEW64
#define SYMSRV_INDEX_INFO SYMSRV_INDEX_INFOW
#define PSYMSRV_INDEX_INFO PSYMSRV_INDEX_INFOW
#define PSYMBOLSERVERPROC PSYMBOLSERVERPROCW
#define PSYMBOLSERVERPINGPROC PSYMBOLSERVERPINGPROCW
#endif
// -----------------------------------------------------------------
// The following APIs exist only for backwards compatibility
// with a pre-release version documented in an MSDN release.
// You should use SymFindFileInPath if you want to maintain
// future compatibility.
DBHLP_DEPRECIATED
BOOL
IMAGEAPI
FindFileInPath(
__in HANDLE hprocess,
__in PCSTR SearchPath,
__in PCSTR FileName,
__in PVOID id,
__in DWORD two,
__in DWORD three,
__in DWORD flags,
__out_ecount(MAX_PATH + 1) PSTR FilePath
);
// You should use SymFindFileInPath if you want to maintain
// future compatibility.
DBHLP_DEPRECIATED
BOOL
IMAGEAPI
FindFileInSearchPath(
__in HANDLE hprocess,
__in PCSTR SearchPath,
__in PCSTR FileName,
__in DWORD one,
__in DWORD two,
__in DWORD three,
__out_ecount(MAX_PATH + 1) PSTR FilePath
);
DBHLP_DEPRECIATED
BOOL
IMAGEAPI
SymEnumSym(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,
__in_opt PVOID UserContext
);
DBHLP_DEPRECIATED
BOOL
IMAGEAPI
SymEnumerateSymbols64(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback,
__in_opt PVOID UserContext
);
DBHLP_DEPRECIATED
BOOL
IMAGEAPI
SymEnumerateSymbolsW64(
__in HANDLE hProcess,
__in ULONG64 BaseOfDll,
__in PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback,
__in_opt PVOID UserContext
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymEnumerateSymbols SymEnumerateSymbols64
#define SymEnumerateSymbolsW SymEnumerateSymbolsW64
#else
DBHLP_DEPRECIATED
BOOL
IMAGEAPI
SymEnumerateSymbols(
__in HANDLE hProcess,
__in ULONG BaseOfDll,
__in PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback,
__in_opt PVOID UserContext
);
DBHLP_DEPRECIATED
BOOL
IMAGEAPI
SymEnumerateSymbolsW(
__in HANDLE hProcess,
__in ULONG BaseOfDll,
__in PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback,
__in_opt PVOID UserContext
);
#endif
// use SymLoadModuleEx
DWORD64
IMAGEAPI
SymLoadModule64(
__in HANDLE hProcess,
__in_opt HANDLE hFile,
__in_opt PCSTR ImageName,
__in_opt PCSTR ModuleName,
__in DWORD64 BaseOfDll,
__in DWORD SizeOfDll
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymLoadModule SymLoadModule64
#else
DWORD
IMAGEAPI
SymLoadModule(
__in HANDLE hProcess,
__in_opt HANDLE hFile,
__in_opt PCSTR ImageName,
__in_opt PCSTR ModuleName,
__in DWORD BaseOfDll,
__in DWORD SizeOfDll
);
#endif
BOOL
IMAGEAPI
SymGetSymNext64(
__in HANDLE hProcess,
__inout PIMAGEHLP_SYMBOL64 Symbol
);
BOOL
IMAGEAPI
SymGetSymNextW64(
__in HANDLE hProcess,
__inout PIMAGEHLP_SYMBOLW64 Symbol
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetSymNext SymGetSymNext64
#define SymGetSymNextW SymGetSymNextW64
#else
BOOL
IMAGEAPI
SymGetSymNext(
__in HANDLE hProcess,
__inout PIMAGEHLP_SYMBOL Symbol
);
BOOL
IMAGEAPI
SymGetSymNextW(
__in HANDLE hProcess,
__inout PIMAGEHLP_SYMBOLW Symbol
);
#endif
BOOL
IMAGEAPI
SymGetSymPrev64(
__in HANDLE hProcess,
__inout PIMAGEHLP_SYMBOL64 Symbol
);
BOOL
IMAGEAPI
SymGetSymPrevW64(
__in HANDLE hProcess,
__inout PIMAGEHLP_SYMBOLW64 Symbol
);
#if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
#define SymGetSymPrev SymGetSymPrev64
#define SymGetSymPrevW SymGetSymPrevW64
#else
BOOL
IMAGEAPI
SymGetSymPrev(
__in HANDLE hProcess,
__inout PIMAGEHLP_SYMBOL Symbol
);
BOOL
IMAGEAPI
SymGetSymPrevW(
__in HANDLE hProcess,
__inout PIMAGEHLP_SYMBOLW Symbol
);
#endif
// These values should not be used.
// They have been replaced by SYMFLAG_ values.
#define SYMF_OMAP_GENERATED 0x00000001
#define SYMF_OMAP_MODIFIED 0x00000002
#define SYMF_REGISTER 0x00000008
#define SYMF_REGREL 0x00000010
#define SYMF_FRAMEREL 0x00000020
#define SYMF_PARAMETER 0x00000040
#define SYMF_LOCAL 0x00000080
#define SYMF_CONSTANT 0x00000100
#define SYMF_EXPORT 0x00000200
#define SYMF_FORWARDER 0x00000400
#define SYMF_FUNCTION 0x00000800
#define SYMF_VIRTUAL 0x00001000
#define SYMF_THUNK 0x00002000
#define SYMF_TLSREL 0x00004000
// These values should also not be used.
// They have been replaced by SYMFLAG_ values.
#define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT 1
#define IMAGEHLP_SYMBOL_INFO_REGISTER SYMF_REGISTER // 0x0008
#define IMAGEHLP_SYMBOL_INFO_REGRELATIVE SYMF_REGREL // 0x0010
#define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE SYMF_FRAMEREL // 0x0020
#define IMAGEHLP_SYMBOL_INFO_PARAMETER SYMF_PARAMETER // 0x0040
#define IMAGEHLP_SYMBOL_INFO_LOCAL SYMF_LOCAL // 0x0080
#define IMAGEHLP_SYMBOL_INFO_CONSTANT SYMF_CONSTANT // 0x0100
#define IMAGEHLP_SYMBOL_FUNCTION SYMF_FUNCTION // 0x0800
#define IMAGEHLP_SYMBOL_VIRTUAL SYMF_VIRTUAL // 0x1000
#define IMAGEHLP_SYMBOL_THUNK SYMF_THUNK // 0x2000
#define IMAGEHLP_SYMBOL_INFO_TLSRELATIVE SYMF_TLSREL // 0x4000
#pragma pack(pop)
#pragma pack(push,4)
#define MINIDUMP_SIGNATURE ('PMDM')
#define MINIDUMP_VERSION (42899)
typedef DWORD RVA;
typedef ULONG64 RVA64;
typedef struct _MINIDUMP_LOCATION_DESCRIPTOR
{
ULONG32 DataSize;
RVA Rva;
} MINIDUMP_LOCATION_DESCRIPTOR;
typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64
{
ULONG64 DataSize;
RVA64 Rva;
} MINIDUMP_LOCATION_DESCRIPTOR64;
typedef struct _MINIDUMP_MEMORY_DESCRIPTOR
{
ULONG64 StartOfMemoryRange;
MINIDUMP_LOCATION_DESCRIPTOR Memory;
} MINIDUMP_MEMORY_DESCRIPTOR, *PMINIDUMP_MEMORY_DESCRIPTOR;
// DESCRIPTOR64 is used for full-memory minidumps where
// all of the raw memory is laid out sequentially at the
// end of the dump. There is no need for individual RVAs
// as the RVA is the base RVA plus the sum of the preceeding
// data blocks.
typedef struct _MINIDUMP_MEMORY_DESCRIPTOR64
{
ULONG64 StartOfMemoryRange;
ULONG64 DataSize;
} MINIDUMP_MEMORY_DESCRIPTOR64, *PMINIDUMP_MEMORY_DESCRIPTOR64;
typedef struct _MINIDUMP_HEADER
{
ULONG32 Signature;
ULONG32 Version;
ULONG32 NumberOfStreams;
RVA StreamDirectoryRva;
ULONG32 CheckSum;
union
{
ULONG32 Reserved;
ULONG32 TimeDateStamp;
};
ULONG64 Flags;
} MINIDUMP_HEADER, *PMINIDUMP_HEADER;
//
// The MINIDUMP_HEADER field StreamDirectoryRva points to
// an array of MINIDUMP_DIRECTORY structures.
//
typedef struct _MINIDUMP_DIRECTORY
{
ULONG32 StreamType;
MINIDUMP_LOCATION_DESCRIPTOR Location;
} MINIDUMP_DIRECTORY, *PMINIDUMP_DIRECTORY;
typedef struct _MINIDUMP_STRING
{
ULONG32 Length; // Length in bytes of the string
WCHAR Buffer [0]; // Variable size buffer
} MINIDUMP_STRING, *PMINIDUMP_STRING;
//
// The MINIDUMP_DIRECTORY field StreamType may be one of the following types.
// Types will be added in the future, so if a program reading the minidump
// header encounters a stream type it does not understand it should ignore
// the data altogether. Any tag above LastReservedStream will not be used by
// the system and is reserved for program-specific information.
//
typedef enum _MINIDUMP_STREAM_TYPE
{
UnusedStream = 0,
ReservedStream0 = 1,
ReservedStream1 = 2,
ThreadListStream = 3,
ModuleListStream = 4,
MemoryListStream = 5,
ExceptionStream = 6,
SystemInfoStream = 7,
ThreadExListStream = 8,
Memory64ListStream = 9,
CommentStreamA = 10,
CommentStreamW = 11,
HandleDataStream = 12,
FunctionTableStream = 13,
UnloadedModuleListStream = 14,
MiscInfoStream = 15,
MemoryInfoListStream = 16,
ThreadInfoListStream = 17,
HandleOperationListStream = 18,
TokenStream = 19,
ceStreamNull = 0x8000,
ceStreamSystemInfo = 0x8001,
ceStreamException = 0x8002,
ceStreamModuleList = 0x8003,
ceStreamProcessList = 0x8004,
ceStreamThreadList = 0x8005,
ceStreamThreadContextList = 0x8006,
ceStreamThreadCallStackList = 0x8007,
ceStreamMemoryVirtualList = 0x8008,
ceStreamMemoryPhysicalList = 0x8009,
ceStreamBucketParameters = 0x800A,
ceStreamProcessModuleMap = 0x800B,
ceStreamDiagnosisList = 0x800C,
LastReservedStream = 0xffff
} MINIDUMP_STREAM_TYPE;
//
// The minidump system information contains processor and
// Operating System specific information.
//
//
// CPU information is obtained from one of two places.
//
// 1) On x86 computers, CPU_INFORMATION is obtained from the CPUID
// instruction. You must use the X86 portion of the union for X86
// computers.
//
// 2) On non-x86 architectures, CPU_INFORMATION is obtained by calling
// IsProcessorFeatureSupported().
//
typedef union _CPU_INFORMATION
{
//
// X86 platforms use CPUID function to obtain processor information.
//
struct
{
//
// CPUID Subfunction 0, register EAX (VendorId [0]),
// EBX (VendorId [1]) and ECX (VendorId [2]).
//
ULONG32 VendorId [ 3 ];
//
// CPUID Subfunction 1, register EAX
//
ULONG32 VersionInformation;
//
// CPUID Subfunction 1, register EDX
//
ULONG32 FeatureInformation;
//
// CPUID, Subfunction 80000001, register EBX. This will only
// be obtained if the vendor id is "AuthenticAMD".
//
ULONG32 AMDExtendedCpuFeatures;
} X86CpuInfo;
//
// Non-x86 platforms use processor feature flags.
//
struct
{
ULONG64 ProcessorFeatures [ 2 ];
} OtherCpuInfo;
} CPU_INFORMATION, *PCPU_INFORMATION;
typedef struct _MINIDUMP_SYSTEM_INFO
{
//
// ProcessorArchitecture, ProcessorLevel and ProcessorRevision are all
// taken from the SYSTEM_INFO structure obtained by GetSystemInfo( ).
//
USHORT ProcessorArchitecture;
USHORT ProcessorLevel;
USHORT ProcessorRevision;
union
{
USHORT Reserved0;
struct
{
UCHAR NumberOfProcessors;
UCHAR ProductType;
};
};
//
// MajorVersion, MinorVersion, BuildNumber, PlatformId and
// CSDVersion are all taken from the OSVERSIONINFO structure
// returned by GetVersionEx( ).
//
ULONG32 MajorVersion;
ULONG32 MinorVersion;
ULONG32 BuildNumber;
ULONG32 PlatformId;
//
// RVA to a CSDVersion string in the string table.
//
RVA CSDVersionRva;
union
{
ULONG32 Reserved1;
struct
{
USHORT SuiteMask;
USHORT Reserved2;
};
};
CPU_INFORMATION Cpu;
} MINIDUMP_SYSTEM_INFO, *PMINIDUMP_SYSTEM_INFO;
//
// The minidump thread contains standard thread
// information plus an RVA to the memory for this
// thread and an RVA to the CONTEXT structure for
// this thread.
//
//
// ThreadId must be 4 bytes on all architectures.
//
C_ASSERT(sizeof(((PPROCESS_INFORMATION)0)->dwThreadId) == 4);
typedef struct _MINIDUMP_THREAD
{
ULONG32 ThreadId;
ULONG32 SuspendCount;
ULONG32 PriorityClass;
ULONG32 Priority;
ULONG64 Teb;
MINIDUMP_MEMORY_DESCRIPTOR Stack;
MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
} MINIDUMP_THREAD, *PMINIDUMP_THREAD;
//
// The thread list is a container of threads.
//
typedef struct _MINIDUMP_THREAD_LIST
{
ULONG32 NumberOfThreads;
MINIDUMP_THREAD Threads [0];
} MINIDUMP_THREAD_LIST, *PMINIDUMP_THREAD_LIST;
typedef struct _MINIDUMP_THREAD_EX
{
ULONG32 ThreadId;
ULONG32 SuspendCount;
ULONG32 PriorityClass;
ULONG32 Priority;
ULONG64 Teb;
MINIDUMP_MEMORY_DESCRIPTOR Stack;
MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
MINIDUMP_MEMORY_DESCRIPTOR BackingStore;
} MINIDUMP_THREAD_EX, *PMINIDUMP_THREAD_EX;
//
// The thread list is a container of threads.
//
typedef struct _MINIDUMP_THREAD_EX_LIST
{
ULONG32 NumberOfThreads;
MINIDUMP_THREAD_EX Threads [0];
} MINIDUMP_THREAD_EX_LIST, *PMINIDUMP_THREAD_EX_LIST;
//
// The MINIDUMP_EXCEPTION is the same as EXCEPTION on Win64.
//
typedef struct _MINIDUMP_EXCEPTION
{
ULONG32 ExceptionCode;
ULONG32 ExceptionFlags;
ULONG64 ExceptionRecord;
ULONG64 ExceptionAddress;
ULONG32 NumberParameters;
ULONG32 __unusedAlignment;
ULONG64 ExceptionInformation [ EXCEPTION_MAXIMUM_PARAMETERS ];
} MINIDUMP_EXCEPTION, *PMINIDUMP_EXCEPTION;
//
// The exception information stream contains the id of the thread that caused
// the exception (ThreadId), the exception record for the exception
// (ExceptionRecord) and an RVA to the thread context where the exception
// occured.
//
typedef struct MINIDUMP_EXCEPTION_STREAM
{
ULONG32 ThreadId;
ULONG32 __alignment;
MINIDUMP_EXCEPTION ExceptionRecord;
MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
} MINIDUMP_EXCEPTION_STREAM, *PMINIDUMP_EXCEPTION_STREAM;
//
// The MINIDUMP_MODULE contains information about a
// a specific module. It includes the CheckSum and
// the TimeDateStamp for the module so the module
// can be reloaded during the analysis phase.
//
typedef struct _MINIDUMP_MODULE
{
ULONG64 BaseOfImage;
ULONG32 SizeOfImage;
ULONG32 CheckSum;
ULONG32 TimeDateStamp;
RVA ModuleNameRva;
VS_FIXEDFILEINFO VersionInfo;
MINIDUMP_LOCATION_DESCRIPTOR CvRecord;
MINIDUMP_LOCATION_DESCRIPTOR MiscRecord;
ULONG64 Reserved0; // Reserved for future use.
ULONG64 Reserved1; // Reserved for future use.
} MINIDUMP_MODULE, *PMINIDUMP_MODULE;
//
// The minidump module list is a container for modules.
//
typedef struct _MINIDUMP_MODULE_LIST
{
ULONG32 NumberOfModules;
MINIDUMP_MODULE Modules [ 0 ];
} MINIDUMP_MODULE_LIST, *PMINIDUMP_MODULE_LIST;
//
// Memory Ranges
//
typedef struct _MINIDUMP_MEMORY_LIST
{
ULONG32 NumberOfMemoryRanges;
MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges [0];
} MINIDUMP_MEMORY_LIST, *PMINIDUMP_MEMORY_LIST;
typedef struct _MINIDUMP_MEMORY64_LIST
{
ULONG64 NumberOfMemoryRanges;
RVA64 BaseRva;
MINIDUMP_MEMORY_DESCRIPTOR64 MemoryRanges [0];
} MINIDUMP_MEMORY64_LIST, *PMINIDUMP_MEMORY64_LIST;
//
// Support for user supplied exception information.
//
typedef struct _MINIDUMP_EXCEPTION_INFORMATION
{
DWORD ThreadId;
PEXCEPTION_POINTERS ExceptionPointers;
BOOL ClientPointers;
} MINIDUMP_EXCEPTION_INFORMATION, *PMINIDUMP_EXCEPTION_INFORMATION;
typedef struct _MINIDUMP_EXCEPTION_INFORMATION64
{
DWORD ThreadId;
ULONG64 ExceptionRecord;
ULONG64 ContextRecord;
BOOL ClientPointers;
} MINIDUMP_EXCEPTION_INFORMATION64, *PMINIDUMP_EXCEPTION_INFORMATION64;
//
// Support for capturing system handle state at the time of the dump.
//
// Per-handle object information varies according to
// the OS, the OS version, the processor type and
// so on. The minidump gives a minidump identifier
// to each possible data format for identification
// purposes but does not control nor describe the actual data.
typedef enum _MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE
{
MiniHandleObjectInformationNone,
MiniThreadInformation1,
MiniMutantInformation1,
MiniMutantInformation2,
MiniProcessInformation1,
MiniProcessInformation2,
MiniHandleObjectInformationTypeMax
} MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE;
typedef struct _MINIDUMP_HANDLE_OBJECT_INFORMATION
{
RVA NextInfoRva;
ULONG32 InfoType;
ULONG32 SizeOfInfo;
// Raw information follows.
} MINIDUMP_HANDLE_OBJECT_INFORMATION;
typedef struct _MINIDUMP_HANDLE_DESCRIPTOR
{
ULONG64 Handle;
RVA TypeNameRva;
RVA ObjectNameRva;
ULONG32 Attributes;
ULONG32 GrantedAccess;
ULONG32 HandleCount;
ULONG32 PointerCount;
} MINIDUMP_HANDLE_DESCRIPTOR, *PMINIDUMP_HANDLE_DESCRIPTOR;
typedef struct _MINIDUMP_HANDLE_DESCRIPTOR_2
{
ULONG64 Handle;
RVA TypeNameRva;
RVA ObjectNameRva;
ULONG32 Attributes;
ULONG32 GrantedAccess;
ULONG32 HandleCount;
ULONG32 PointerCount;
RVA ObjectInfoRva;
ULONG32 Reserved0;
} MINIDUMP_HANDLE_DESCRIPTOR_2, *PMINIDUMP_HANDLE_DESCRIPTOR_2;
// The latest MINIDUMP_HANDLE_DESCRIPTOR definition.
typedef MINIDUMP_HANDLE_DESCRIPTOR_2 MINIDUMP_HANDLE_DESCRIPTOR_N;
typedef MINIDUMP_HANDLE_DESCRIPTOR_N* PMINIDUMP_HANDLE_DESCRIPTOR_N;
typedef struct _MINIDUMP_HANDLE_DATA_STREAM
{
ULONG32 SizeOfHeader;
ULONG32 SizeOfDescriptor;
ULONG32 NumberOfDescriptors;
ULONG32 Reserved;
} MINIDUMP_HANDLE_DATA_STREAM, *PMINIDUMP_HANDLE_DATA_STREAM;
// Some operating systems can track the last operations
// performed on a handle. For example, Application Verifier
// can enable this for some versions of Windows. The
// handle operation list collects handle operations
// known for the dump target.
// Each entry is an AVRF_HANDLE_OPERATION.
typedef struct _MINIDUMP_HANDLE_OPERATION_LIST
{
ULONG32 SizeOfHeader;
ULONG32 SizeOfEntry;
ULONG32 NumberOfEntries;
ULONG32 Reserved;
} MINIDUMP_HANDLE_OPERATION_LIST, *PMINIDUMP_HANDLE_OPERATION_LIST;
//
// Support for capturing dynamic function table state at the time of the dump.
//
typedef struct _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR
{
ULONG64 MinimumAddress;
ULONG64 MaximumAddress;
ULONG64 BaseAddress;
ULONG32 EntryCount;
ULONG32 SizeOfAlignPad;
} MINIDUMP_FUNCTION_TABLE_DESCRIPTOR, *PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
typedef struct _MINIDUMP_FUNCTION_TABLE_STREAM
{
ULONG32 SizeOfHeader;
ULONG32 SizeOfDescriptor;
ULONG32 SizeOfNativeDescriptor;
ULONG32 SizeOfFunctionEntry;
ULONG32 NumberOfDescriptors;
ULONG32 SizeOfAlignPad;
} MINIDUMP_FUNCTION_TABLE_STREAM, *PMINIDUMP_FUNCTION_TABLE_STREAM;
//
// The MINIDUMP_UNLOADED_MODULE contains information about a
// a specific module that was previously loaded but no
// longer is. This can help with diagnosing problems where
// callers attempt to call code that is no longer loaded.
//
typedef struct _MINIDUMP_UNLOADED_MODULE
{
ULONG64 BaseOfImage;
ULONG32 SizeOfImage;
ULONG32 CheckSum;
ULONG32 TimeDateStamp;
RVA ModuleNameRva;
} MINIDUMP_UNLOADED_MODULE, *PMINIDUMP_UNLOADED_MODULE;
//
// The minidump unloaded module list is a container for unloaded modules.
//
typedef struct _MINIDUMP_UNLOADED_MODULE_LIST
{
ULONG32 SizeOfHeader;
ULONG32 SizeOfEntry;
ULONG32 NumberOfEntries;
} MINIDUMP_UNLOADED_MODULE_LIST, *PMINIDUMP_UNLOADED_MODULE_LIST;
//
// The miscellaneous information stream contains a variety
// of small pieces of information. A member is valid if
// it's within the available size and its corresponding
// bit is set.
//
#define MINIDUMP_MISC1_PROCESS_ID 0x00000001
#define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002
#define MINIDUMP_MISC1_PROCESSOR_POWER_INFO 0x00000004
#define MINIDUMP_MISC3_PROCESS_INTEGRITY 0x00000010
#define MINIDUMP_MISC3_PROCESS_EXECUTE_FLAGS 0x00000020
#define MINIDUMP_MISC3_TIMEZONE 0x00000040
#define MINIDUMP_MISC3_PROTECTED_PROCESS 0x00000080
typedef struct _MINIDUMP_MISC_INFO
{
ULONG32 SizeOfInfo;
ULONG32 Flags1;
ULONG32 ProcessId;
ULONG32 ProcessCreateTime;
ULONG32 ProcessUserTime;
ULONG32 ProcessKernelTime;
} MINIDUMP_MISC_INFO, *PMINIDUMP_MISC_INFO;
typedef struct _MINIDUMP_MISC_INFO_2
{
ULONG32 SizeOfInfo;
ULONG32 Flags1;
ULONG32 ProcessId;
ULONG32 ProcessCreateTime;
ULONG32 ProcessUserTime;
ULONG32 ProcessKernelTime;
ULONG32 ProcessorMaxMhz;
ULONG32 ProcessorCurrentMhz;
ULONG32 ProcessorMhzLimit;
ULONG32 ProcessorMaxIdleState;
ULONG32 ProcessorCurrentIdleState;
} MINIDUMP_MISC_INFO_2, *PMINIDUMP_MISC_INFO_2;
typedef struct _MINIDUMP_MISC_INFO_3
{
ULONG32 SizeOfInfo;
ULONG32 Flags1;
ULONG32 ProcessId;
ULONG32 ProcessCreateTime;
ULONG32 ProcessUserTime;
ULONG32 ProcessKernelTime;
ULONG32 ProcessorMaxMhz;
ULONG32 ProcessorCurrentMhz;
ULONG32 ProcessorMhzLimit;
ULONG32 ProcessorMaxIdleState;
ULONG32 ProcessorCurrentIdleState;
ULONG32 ProcessIntegrityLevel;
ULONG32 ProcessExecuteFlags;
ULONG32 ProtectedProcess;
ULONG32 TimeZoneId;
TIME_ZONE_INFORMATION TimeZone;
} MINIDUMP_MISC_INFO_3, *PMINIDUMP_MISC_INFO_3;
// The latest MINIDUMP_MISC_INFO definition.
typedef MINIDUMP_MISC_INFO_3 MINIDUMP_MISC_INFO_N;
typedef MINIDUMP_MISC_INFO_N* PMINIDUMP_MISC_INFO_N;
//
// The memory information stream contains memory region
// description information. This stream corresponds to
// what VirtualQuery would return for the process the
// dump was created for.
//
typedef struct _MINIDUMP_MEMORY_INFO
{
ULONG64 BaseAddress;
ULONG64 AllocationBase;
ULONG32 AllocationProtect;
ULONG32 __alignment1;
ULONG64 RegionSize;
ULONG32 State;
ULONG32 Protect;
ULONG32 Type;
ULONG32 __alignment2;
} MINIDUMP_MEMORY_INFO, *PMINIDUMP_MEMORY_INFO;
typedef struct _MINIDUMP_MEMORY_INFO_LIST
{
ULONG SizeOfHeader;
ULONG SizeOfEntry;
ULONG64 NumberOfEntries;
} MINIDUMP_MEMORY_INFO_LIST, *PMINIDUMP_MEMORY_INFO_LIST;
//
// The memory information stream contains memory region
// description information. This stream corresponds to
// what VirtualQuery would return for the process the
// dump was created for.
//
// Thread dump writer status flags.
#define MINIDUMP_THREAD_INFO_ERROR_THREAD 0x00000001
#define MINIDUMP_THREAD_INFO_WRITING_THREAD 0x00000002
#define MINIDUMP_THREAD_INFO_EXITED_THREAD 0x00000004
#define MINIDUMP_THREAD_INFO_INVALID_INFO 0x00000008
#define MINIDUMP_THREAD_INFO_INVALID_CONTEXT 0x00000010
#define MINIDUMP_THREAD_INFO_INVALID_TEB 0x00000020
typedef struct _MINIDUMP_THREAD_INFO
{
ULONG32 ThreadId;
ULONG32 DumpFlags;
ULONG32 DumpError;
ULONG32 ExitStatus;
ULONG64 CreateTime;
ULONG64 ExitTime;
ULONG64 KernelTime;
ULONG64 UserTime;
ULONG64 StartAddress;
ULONG64 Affinity;
} MINIDUMP_THREAD_INFO, *PMINIDUMP_THREAD_INFO;
typedef struct _MINIDUMP_THREAD_INFO_LIST
{
ULONG SizeOfHeader;
ULONG SizeOfEntry;
ULONG NumberOfEntries;
} MINIDUMP_THREAD_INFO_LIST, *PMINIDUMP_THREAD_INFO_LIST;
//
// Support for token information.
//
typedef struct _MINIDUMP_TOKEN_INFO_HEADER
{
ULONG TokenSize; // The size of the token structure.
ULONG TokenId; // The PID in NtOpenProcessToken() call or TID in NtOpenThreadToken() call.
ULONG64 TokenHandle; // The handle value returned.
} MINIDUMP_TOKEN_INFO_HEADER, *PMINIDUMP_TOKEN_INFO_HEADER;
typedef struct _MINIDUMP_TOKEN_INFO_LIST
{
ULONG TokenListSize;
ULONG TokenListEntries;
ULONG ListHeaderSize;
ULONG ElementHeaderSize;
} MINIDUMP_TOKEN_INFO_LIST, *PMINIDUMP_TOKEN_INFO_LIST;
//
// Support for arbitrary user-defined information.
//
typedef struct _MINIDUMP_USER_RECORD
{
ULONG32 Type;
MINIDUMP_LOCATION_DESCRIPTOR Memory;
} MINIDUMP_USER_RECORD, *PMINIDUMP_USER_RECORD;
typedef struct _MINIDUMP_USER_STREAM
{
ULONG32 Type;
ULONG BufferSize;
PVOID Buffer;
} MINIDUMP_USER_STREAM, *PMINIDUMP_USER_STREAM;
typedef struct _MINIDUMP_USER_STREAM_INFORMATION
{
ULONG UserStreamCount;
PMINIDUMP_USER_STREAM UserStreamArray;
} MINIDUMP_USER_STREAM_INFORMATION, *PMINIDUMP_USER_STREAM_INFORMATION;
//
// Callback support.
//
typedef enum _MINIDUMP_CALLBACK_TYPE
{
ModuleCallback,
ThreadCallback,
ThreadExCallback,
IncludeThreadCallback,
IncludeModuleCallback,
MemoryCallback,
CancelCallback,
WriteKernelMinidumpCallback,
KernelMinidumpStatusCallback,
RemoveMemoryCallback,
IncludeVmRegionCallback,
IoStartCallback,
IoWriteAllCallback,
IoFinishCallback,
ReadMemoryFailureCallback,
SecondaryFlagsCallback,
} MINIDUMP_CALLBACK_TYPE;
typedef struct _MINIDUMP_THREAD_CALLBACK
{
ULONG ThreadId;
HANDLE ThreadHandle;
CONTEXT Context;
ULONG SizeOfContext;
ULONG64 StackBase;
ULONG64 StackEnd;
} MINIDUMP_THREAD_CALLBACK, *PMINIDUMP_THREAD_CALLBACK;
typedef struct _MINIDUMP_THREAD_EX_CALLBACK
{
ULONG ThreadId;
HANDLE ThreadHandle;
CONTEXT Context;
ULONG SizeOfContext;
ULONG64 StackBase;
ULONG64 StackEnd;
ULONG64 BackingStoreBase;
ULONG64 BackingStoreEnd;
} MINIDUMP_THREAD_EX_CALLBACK, *PMINIDUMP_THREAD_EX_CALLBACK;
typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK
{
ULONG ThreadId;
} MINIDUMP_INCLUDE_THREAD_CALLBACK, *PMINIDUMP_INCLUDE_THREAD_CALLBACK;
typedef enum _THREAD_WRITE_FLAGS
{
ThreadWriteThread = 0x0001,
ThreadWriteStack = 0x0002,
ThreadWriteContext = 0x0004,
ThreadWriteBackingStore = 0x0008,
ThreadWriteInstructionWindow = 0x0010,
ThreadWriteThreadData = 0x0020,
ThreadWriteThreadInfo = 0x0040,
} THREAD_WRITE_FLAGS;
typedef struct _MINIDUMP_MODULE_CALLBACK
{
PWCHAR FullPath;
ULONG64 BaseOfImage;
ULONG SizeOfImage;
ULONG CheckSum;
ULONG TimeDateStamp;
VS_FIXEDFILEINFO VersionInfo;
PVOID CvRecord;
ULONG SizeOfCvRecord;
PVOID MiscRecord;
ULONG SizeOfMiscRecord;
} MINIDUMP_MODULE_CALLBACK, *PMINIDUMP_MODULE_CALLBACK;
typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK
{
ULONG64 BaseOfImage;
} MINIDUMP_INCLUDE_MODULE_CALLBACK, *PMINIDUMP_INCLUDE_MODULE_CALLBACK;
typedef enum _MODULE_WRITE_FLAGS
{
ModuleWriteModule = 0x0001,
ModuleWriteDataSeg = 0x0002,
ModuleWriteMiscRecord = 0x0004,
ModuleWriteCvRecord = 0x0008,
ModuleReferencedByMemory = 0x0010,
ModuleWriteTlsData = 0x0020,
ModuleWriteCodeSegs = 0x0040,
} MODULE_WRITE_FLAGS;
typedef struct _MINIDUMP_IO_CALLBACK
{
HANDLE Handle;
ULONG64 Offset;
PVOID Buffer;
ULONG BufferBytes;
} MINIDUMP_IO_CALLBACK, *PMINIDUMP_IO_CALLBACK;
typedef struct _MINIDUMP_READ_MEMORY_FAILURE_CALLBACK
{
ULONG64 Offset;
ULONG Bytes;
HRESULT FailureStatus;
} MINIDUMP_READ_MEMORY_FAILURE_CALLBACK,
*PMINIDUMP_READ_MEMORY_FAILURE_CALLBACK;
typedef struct _MINIDUMP_CALLBACK_INPUT
{
ULONG ProcessId;
HANDLE ProcessHandle;
ULONG CallbackType;
union
{
HRESULT Status;
MINIDUMP_THREAD_CALLBACK Thread;
MINIDUMP_THREAD_EX_CALLBACK ThreadEx;
MINIDUMP_MODULE_CALLBACK Module;
MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
MINIDUMP_IO_CALLBACK Io;
MINIDUMP_READ_MEMORY_FAILURE_CALLBACK ReadMemoryFailure;
ULONG SecondaryFlags;
};
} MINIDUMP_CALLBACK_INPUT, *PMINIDUMP_CALLBACK_INPUT;
typedef struct _MINIDUMP_CALLBACK_OUTPUT
{
union
{
ULONG ModuleWriteFlags;
ULONG ThreadWriteFlags;
ULONG SecondaryFlags;
struct
{
ULONG64 MemoryBase;
ULONG MemorySize;
};
struct
{
BOOL CheckCancel;
BOOL Cancel;
};
HANDLE Handle;
struct
{
MINIDUMP_MEMORY_INFO VmRegion;
BOOL Continue;
};
HRESULT Status;
};
} MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT;
//
// A normal minidump contains just the information
// necessary to capture stack traces for all of the
// existing threads in a process.
//
// A minidump with data segments includes all of the data
// sections from loaded modules in order to capture
// global variable contents. This can make the dump much
// larger if many modules have global data.
//
// A minidump with full memory includes all of the accessible
// memory in the process and can be very large. A minidump
// with full memory always has the raw memory data at the end
// of the dump so that the initial structures in the dump can
// be mapped directly without having to include the raw
// memory information.
//
// Stack and backing store memory can be filtered to remove
// data unnecessary for stack walking. This can improve
// compression of stacks and also deletes data that may
// be private and should not be stored in a dump.
// Memory can also be scanned to see what modules are
// referenced by stack and backing store memory to allow
// omission of other modules to reduce dump size.
// In either of these modes the ModuleReferencedByMemory flag
// is set for all modules referenced before the base
// module callbacks occur.
//
// On some operating systems a list of modules that were
// recently unloaded is kept in addition to the currently
// loaded module list. This information can be saved in
// the dump if desired.
//
// Stack and backing store memory can be scanned for referenced
// pages in order to pick up data referenced by locals or other
// stack memory. This can increase the size of a dump significantly.
//
// Module paths may contain undesired information such as user names
// or other important directory names so they can be stripped. This
// option reduces the ability to locate the proper image later
// and should only be used in certain situations.
//
// Complete operating system per-process and per-thread information can
// be gathered and stored in the dump.
//
// The virtual address space can be scanned for various types
// of memory to be included in the dump.
//
// Code which is concerned with potentially private information
// getting into the minidump can set a flag that automatically
// modifies all existing and future flags to avoid placing
// unnecessary data in the dump. Basic data, such as stack
// information, will still be included but optional data, such
// as indirect memory, will not.
//
// When doing a full memory dump it's possible to store all
// of the enumerated memory region descriptive information
// in a memory information stream.
//
// Additional thread information beyond the basic thread
// structure can be collected if desired.
//
// A minidump with code segments includes all of the code
// and code-related sections from loaded modules in order
// to capture executable content.
//
// MiniDumpWithoutAuxiliaryState turns off any secondary,
// auxiliary-supported memory gathering.
//
// MiniDumpWithFullAuxiliaryState asks any present auxiliary
// data providers to include all of their state in the dump.
// The exact set of what is provided depends on the auxiliary.
// This can be quite large.
//
typedef enum _MINIDUMP_TYPE
{
MiniDumpNormal = 0x00000000,
MiniDumpWithDataSegs = 0x00000001,
MiniDumpWithFullMemory = 0x00000002,
MiniDumpWithHandleData = 0x00000004,
MiniDumpFilterMemory = 0x00000008,
MiniDumpScanMemory = 0x00000010,
MiniDumpWithUnloadedModules = 0x00000020,
MiniDumpWithIndirectlyReferencedMemory = 0x00000040,
MiniDumpFilterModulePaths = 0x00000080,
MiniDumpWithProcessThreadData = 0x00000100,
MiniDumpWithPrivateReadWriteMemory = 0x00000200,
MiniDumpWithoutOptionalData = 0x00000400,
MiniDumpWithFullMemoryInfo = 0x00000800,
MiniDumpWithThreadInfo = 0x00001000,
MiniDumpWithCodeSegs = 0x00002000,
MiniDumpWithoutAuxiliaryState = 0x00004000,
MiniDumpWithFullAuxiliaryState = 0x00008000,
MiniDumpWithPrivateWriteCopyMemory = 0x00010000,
MiniDumpIgnoreInaccessibleMemory = 0x00020000,
MiniDumpWithTokenInformation = 0x00040000,
MiniDumpValidTypeFlags = 0x0007ffff,
} MINIDUMP_TYPE;
//
// In addition to the primary flags provided to
// MiniDumpWriteDump there are additional, less
// frequently used options queried via the secondary
// flags callback.
//
// MiniSecondaryWithoutPowerInfo suppresses the minidump
// query that retrieves processor power information for
// MINIDUMP_MISC_INFO.
//
typedef enum _MINIDUMP_SECONDARY_FLAGS
{
MiniSecondaryWithoutPowerInfo = 0x00000001,
MiniSecondaryValidFlags = 0x00000001,
} MINIDUMP_SECONDARY_FLAGS;
//
// The minidump callback should modify the FieldsToWrite parameter to reflect
// what portions of the specified thread or module should be written to the
// file.
//
typedef
BOOL
(WINAPI* MINIDUMP_CALLBACK_ROUTINE)(
__inout PVOID CallbackParam,
__in PMINIDUMP_CALLBACK_INPUT CallbackInput,
__inout PMINIDUMP_CALLBACK_OUTPUT CallbackOutput
);
typedef struct _MINIDUMP_CALLBACK_INFORMATION
{
MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
PVOID CallbackParam;
} MINIDUMP_CALLBACK_INFORMATION, *PMINIDUMP_CALLBACK_INFORMATION;
//++
//
// PVOID
// RVA_TO_ADDR(
// PVOID Mapping,
// ULONG Rva
// )
//
// Routine Description:
//
// Map an RVA that is contained within a mapped file to it's associated
// flat address.
//
// Arguments:
//
// Mapping - Base address of mapped file containing the RVA.
//
// Rva - An Rva to fixup.
//
// Return Values:
//
// A pointer to the desired data.
//
//--
#define RVA_TO_ADDR(Mapping,Rva) ((PVOID)(((ULONG_PTR) (Mapping)) + (Rva)))
BOOL
WINAPI
MiniDumpWriteDump(
__in HANDLE hProcess,
__in DWORD ProcessId,
__in HANDLE hFile,
__in MINIDUMP_TYPE DumpType,
__in_opt PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
__in_opt PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
__in_opt PMINIDUMP_CALLBACK_INFORMATION CallbackParam
);
BOOL
WINAPI
MiniDumpReadDumpStream(
__in PVOID BaseOfDump,
__in ULONG StreamNumber,
__deref_out_opt PMINIDUMP_DIRECTORY* Dir,
__deref_out_opt PVOID* StreamPointer,
__out_opt ULONG* StreamSize
);
#pragma pack(pop)
#ifdef __cplusplus
}
#endif
#endif // _DBGHELP_ |
C/C++ | x64dbg-development/src/dbg/DeviceNameResolver/DeviceNameResolver.h | #ifndef _DEVICENAMERESOLVER_H
#define _DEVICENAMERESOLVER_H
#include <windows.h>
#ifdef __cplusplus
extern "C"
{
#endif
__declspec(dllexport) bool DevicePathToPathW(const wchar_t* szDevicePath, wchar_t* szPath, size_t nSizeInChars);
__declspec(dllexport) bool DevicePathToPathA(const char* szDevicePath, char* szPath, size_t nSizeInChars);
__declspec(dllexport) bool DevicePathFromFileHandleW(HANDLE hFile, wchar_t* szDevicePath, size_t nSizeInChars);
__declspec(dllexport) bool DevicePathFromFileHandleA(HANDLE hFile, char* szDevicePath, size_t nSizeInChars);
__declspec(dllexport) bool PathFromFileHandleW(HANDLE hFile, wchar_t* szPath, size_t nSizeInChars);
__declspec(dllexport) bool PathFromFileHandleA(HANDLE hFile, char* szPath, size_t nSizeInChars);
#ifdef __cplusplus
}
#endif
#endif // _DEVICENAMERESOLVER_H |
C/C++ | x64dbg-development/src/dbg/jansson/jansson.h | /*
* Copyright (c) 2009-2016 Petri Lehtinen <[email protected]>
*
* Jansson is free software; you can redistribute it and/or modify
* it under the terms of the MIT license. See LICENSE for details.
*/
#ifndef JANSSON_H
#define JANSSON_H
#include <stdio.h>
#include <stdlib.h> /* for size_t */
#include <stdarg.h>
#include "jansson_config.h"
#ifdef __cplusplus
extern "C" {
#endif
/* version */
#define JANSSON_MAJOR_VERSION 2
#define JANSSON_MINOR_VERSION 9
#define JANSSON_MICRO_VERSION 0
/* Micro version is omitted if it's 0 */
#define JANSSON_VERSION "2.9"
/* Version as a 3-byte hex number, e.g. 0x010201 == 1.2.1. Use this
for numeric comparisons, e.g. #if JANSSON_VERSION_HEX >= ... */
#define JANSSON_VERSION_HEX ((JANSSON_MAJOR_VERSION << 16) | \
(JANSSON_MINOR_VERSION << 8) | \
(JANSSON_MICRO_VERSION << 0))
/* types */
typedef enum
{
JSON_OBJECT,
JSON_ARRAY,
JSON_STRING,
JSON_INTEGER,
JSON_REAL,
JSON_TRUE,
JSON_FALSE,
JSON_NULL
} json_type;
typedef struct json_t
{
json_type type;
size_t refcount;
} json_t;
#ifndef JANSSON_USING_CMAKE /* disabled if using cmake */
#if JSON_INTEGER_IS_LONG_LONG
#ifdef _WIN32
#define JSON_INTEGER_FORMAT "I64d"
#else
#define JSON_INTEGER_FORMAT "lld"
#endif
typedef long long json_int_t;
#else
#define JSON_INTEGER_FORMAT "ld"
typedef long json_int_t;
#endif /* JSON_INTEGER_IS_LONG_LONG */
#endif
#define json_typeof(json) ((json)->type)
#define json_is_object(json) ((json) && json_typeof(json) == JSON_OBJECT)
#define json_is_array(json) ((json) && json_typeof(json) == JSON_ARRAY)
#define json_is_string(json) ((json) && json_typeof(json) == JSON_STRING)
#define json_is_integer(json) ((json) && json_typeof(json) == JSON_INTEGER)
#define json_is_real(json) ((json) && json_typeof(json) == JSON_REAL)
#define json_is_number(json) (json_is_integer(json) || json_is_real(json))
#define json_is_true(json) ((json) && json_typeof(json) == JSON_TRUE)
#define json_is_false(json) ((json) && json_typeof(json) == JSON_FALSE)
#define json_boolean_value json_is_true
#define json_is_boolean(json) (json_is_true(json) || json_is_false(json))
#define json_is_null(json) ((json) && json_typeof(json) == JSON_NULL)
/* construction, destruction, reference counting */
__declspec(dllimport) json_t* json_object(void);
__declspec(dllimport) json_t* json_array(void);
__declspec(dllimport) json_t* json_string(const char* value);
__declspec(dllimport) json_t* json_stringn(const char* value, size_t len);
__declspec(dllimport) json_t* json_string_nocheck(const char* value);
__declspec(dllimport) json_t* json_stringn_nocheck(const char* value, size_t len);
__declspec(dllimport) json_t* json_integer(json_int_t value);
__declspec(dllimport) json_t* json_real(double value);
__declspec(dllimport) json_t* json_true(void);
__declspec(dllimport) json_t* json_false(void);
#define json_boolean(val) ((val) ? json_true() : json_false())
__declspec(dllimport) json_t* json_null(void);
static JSON_INLINE
json_t* json_incref(json_t* json)
{
if(json && json->refcount != (size_t) - 1)
++json->refcount;
return json;
}
/* do not call json_delete directly */
__declspec(dllimport) void json_delete(json_t* json);
static JSON_INLINE
void json_decref(json_t* json)
{
if(json && json->refcount != (size_t) - 1 && --json->refcount == 0)
json_delete(json);
}
#if defined(__GNUC__) || defined(__clang__)
static JSON_INLINE
void json_decrefp(json_t** json)
{
if(json)
{
json_decref(*json);
*json = NULL;
}
}
#define json_auto_t json_t __attribute__((cleanup(json_decrefp)))
#endif
/* error reporting */
#define JSON_ERROR_TEXT_LENGTH 160
#define JSON_ERROR_SOURCE_LENGTH 80
typedef struct
{
int line;
int column;
int position;
char source[JSON_ERROR_SOURCE_LENGTH];
char text[JSON_ERROR_TEXT_LENGTH];
} json_error_t;
/* getters, setters, manipulation */
__declspec(dllimport) void json_object_seed(size_t seed);
__declspec(dllimport) size_t json_object_size(const json_t* object);
__declspec(dllimport) json_t* json_object_get(const json_t* object, const char* key);
__declspec(dllimport) int json_object_set_new(json_t* object, const char* key, json_t* value);
__declspec(dllimport) int json_object_set_new_nocheck(json_t* object, const char* key, json_t* value);
__declspec(dllimport) int json_object_del(json_t* object, const char* key);
__declspec(dllimport) int json_object_clear(json_t* object);
__declspec(dllimport) int json_object_update(json_t* object, json_t* other);
__declspec(dllimport) int json_object_update_existing(json_t* object, json_t* other);
__declspec(dllimport) int json_object_update_missing(json_t* object, json_t* other);
__declspec(dllimport) void* json_object_iter(json_t* object);
__declspec(dllimport) void* json_object_iter_at(json_t* object, const char* key);
__declspec(dllimport) void* json_object_key_to_iter(const char* key);
__declspec(dllimport) void* json_object_iter_next(json_t* object, void* iter);
__declspec(dllimport) const char* json_object_iter_key(void* iter);
__declspec(dllimport) json_t* json_object_iter_value(void* iter);
__declspec(dllimport) int json_object_iter_set_new(json_t* object, void* iter, json_t* value);
#define json_object_foreach(object, key, value) \
for(key = json_object_iter_key(json_object_iter(object)); \
key && (value = json_object_iter_value(json_object_key_to_iter(key))); \
key = json_object_iter_key(json_object_iter_next(object, json_object_key_to_iter(key))))
#define json_object_foreach_safe(object, n, key, value) \
for(key = json_object_iter_key(json_object_iter(object)), \
n = json_object_iter_next(object, json_object_key_to_iter(key)); \
key && (value = json_object_iter_value(json_object_key_to_iter(key))); \
key = json_object_iter_key(n), \
n = json_object_iter_next(object, json_object_key_to_iter(key)))
#define json_array_foreach(array, index, value) \
for(index = 0; \
index < json_array_size(array) && (value = json_array_get(array, index)); \
index++)
static JSON_INLINE
int json_object_set(json_t* object, const char* key, json_t* value)
{
return json_object_set_new(object, key, json_incref(value));
}
static JSON_INLINE
int json_object_set_nocheck(json_t* object, const char* key, json_t* value)
{
return json_object_set_new_nocheck(object, key, json_incref(value));
}
static JSON_INLINE
int json_object_iter_set(json_t* object, void* iter, json_t* value)
{
return json_object_iter_set_new(object, iter, json_incref(value));
}
__declspec(dllimport) size_t json_array_size(const json_t* array);
__declspec(dllimport) json_t* json_array_get(const json_t* array, size_t index);
__declspec(dllimport) int json_array_set_new(json_t* array, size_t index, json_t* value);
__declspec(dllimport) int json_array_append_new(json_t* array, json_t* value);
__declspec(dllimport) int json_array_insert_new(json_t* array, size_t index, json_t* value);
__declspec(dllimport) int json_array_remove(json_t* array, size_t index);
__declspec(dllimport) int json_array_clear(json_t* array);
__declspec(dllimport) int json_array_extend(json_t* array, json_t* other);
static JSON_INLINE
int json_array_set(json_t* array, size_t ind, json_t* value)
{
return json_array_set_new(array, ind, json_incref(value));
}
static JSON_INLINE
int json_array_append(json_t* array, json_t* value)
{
return json_array_append_new(array, json_incref(value));
}
static JSON_INLINE
int json_array_insert(json_t* array, size_t ind, json_t* value)
{
return json_array_insert_new(array, ind, json_incref(value));
}
__declspec(dllimport) const char* json_string_value(const json_t* string);
__declspec(dllimport) size_t json_string_length(const json_t* string);
__declspec(dllimport) json_int_t json_integer_value(const json_t* integer);
__declspec(dllimport) double json_real_value(const json_t* real);
__declspec(dllimport) double json_number_value(const json_t* json);
__declspec(dllimport) int json_string_set(json_t* string, const char* value);
__declspec(dllimport) int json_string_setn(json_t* string, const char* value, size_t len);
__declspec(dllimport) int json_string_set_nocheck(json_t* string, const char* value);
__declspec(dllimport) int json_string_setn_nocheck(json_t* string, const char* value, size_t len);
__declspec(dllimport) int json_integer_set(json_t* integer, json_int_t value);
__declspec(dllimport) int json_real_set(json_t* real, double value);
/* pack, unpack */
__declspec(dllimport) json_t* json_pack(const char* fmt, ...);
__declspec(dllimport) json_t* json_pack_ex(json_error_t* error, size_t flags, const char* fmt, ...);
__declspec(dllimport) json_t* json_vpack_ex(json_error_t* error, size_t flags, const char* fmt, va_list ap);
#define JSON_VALIDATE_ONLY 0x1
#define JSON_STRICT 0x2
__declspec(dllimport) int json_unpack(json_t* root, const char* fmt, ...);
__declspec(dllimport) int json_unpack_ex(json_t* root, json_error_t* error, size_t flags, const char* fmt, ...);
__declspec(dllimport) int json_vunpack_ex(json_t* root, json_error_t* error, size_t flags, const char* fmt, va_list ap);
/* equality */
__declspec(dllimport) int json_equal(json_t* value1, json_t* value2);
/* copying */
__declspec(dllimport) json_t* json_copy(json_t* value);
__declspec(dllimport) json_t* json_deep_copy(const json_t* value);
/* decoding */
#define JSON_REJECT_DUPLICATES 0x1
#define JSON_DISABLE_EOF_CHECK 0x2
#define JSON_DECODE_ANY 0x4
#define JSON_DECODE_INT_AS_REAL 0x8
#define JSON_ALLOW_NUL 0x10
typedef size_t (*json_load_callback_t)(void* buffer, size_t buflen, void* data);
__declspec(dllimport) json_t* json_loads(const char* input, size_t flags, json_error_t* error);
__declspec(dllimport) json_t* json_loadb(const char* buffer, size_t buflen, size_t flags, json_error_t* error);
__declspec(dllimport) json_t* json_loadf(FILE* input, size_t flags, json_error_t* error);
__declspec(dllimport) json_t* json_load_file(const char* path, size_t flags, json_error_t* error);
__declspec(dllimport) json_t* json_load_callback(json_load_callback_t callback, void* data, size_t flags, json_error_t* error);
/* encoding */
#define JSON_MAX_INDENT 0x1F
#define JSON_INDENT(n) ((n) & JSON_MAX_INDENT)
#define JSON_COMPACT 0x20
#define JSON_ENSURE_ASCII 0x40
#define JSON_SORT_KEYS 0x80
#define JSON_PRESERVE_ORDER 0x100
#define JSON_ENCODE_ANY 0x200
#define JSON_ESCAPE_SLASH 0x400
#define JSON_REAL_PRECISION(n) (((n) & 0x1F) << 11)
typedef int (*json_dump_callback_t)(const char* buffer, size_t size, void* data);
__declspec(dllimport) char* json_dumps(const json_t* json, size_t flags);
__declspec(dllimport) int json_dumpf(const json_t* json, FILE* output, size_t flags);
__declspec(dllimport) int json_dump_file(const json_t* json, const char* path, size_t flags);
__declspec(dllimport) int json_dump_callback(const json_t* json, json_dump_callback_t callback, void* data, size_t flags);
/* custom memory allocation */
typedef void* (*json_malloc_t)(size_t);
typedef void (*json_free_t)(void*);
__declspec(dllimport) void json_set_alloc_funcs(json_malloc_t malloc_fn, json_free_t free_fn);
__declspec(dllimport) void json_get_alloc_funcs(json_malloc_t* malloc_fn, json_free_t* free_fn);
#ifdef __cplusplus
}
#endif
#endif |
C/C++ | x64dbg-development/src/dbg/jansson/jansson_config.h | /*
* Copyright (c) 2010-2016 Petri Lehtinen <[email protected]>
*
* Jansson is free software; you can redistribute it and/or modify
* it under the terms of the MIT license. See LICENSE for details.
*
*
* This file specifies a part of the site-specific configuration for
* Jansson, namely those things that affect the public API in
* jansson.h.
*
* The CMake system will generate the jansson_config.h file and
* copy it to the build and install directories.
*/
#ifndef JANSSON_CONFIG_H
#define JANSSON_CONFIG_H
/* Define this so that we can disable scattered automake configuration in source files */
#ifndef JANSSON_USING_CMAKE
#define JANSSON_USING_CMAKE
#endif
/* Note: when using cmake, JSON_INTEGER_IS_LONG_LONG is not defined nor used,
* as we will also check for __int64 etc types.
* (the definition was used in the automake system) */
/* Bring in the cmake-detected defines */
#define HAVE_STDINT_H 1
/* #undef HAVE_INTTYPES_H */
/* #undef HAVE_SYS_TYPES_H */
/* Include our standard type header for the integer typedef */
#if defined(HAVE_STDINT_H)
# include <stdint.h>
#elif defined(HAVE_INTTYPES_H)
# include <inttypes.h>
#elif defined(HAVE_SYS_TYPES_H)
# include <sys/types.h>
#endif
/* If your compiler supports the inline keyword in C, JSON_INLINE is
defined to `inline', otherwise empty. In C++, the inline is always
supported. */
#ifdef __cplusplus
#define JSON_INLINE inline
#else
#define JSON_INLINE __inline
#endif
#define json_int_t long long
#define json_strtoint strtoll
#define JSON_INTEGER_FORMAT "I64d"
/* If locale.h and localeconv() are available, define to 1, otherwise to 0. */
#define JSON_HAVE_LOCALECONV 1
/* Maximum recursion depth for parsing JSON input.
This limits the depth of e.g. array-within-array constructions. */
#define JSON_PARSER_MAX_DEPTH 2048
#endif |
C/C++ | x64dbg-development/src/dbg/jansson/jansson_x64dbg.h | #pragma once
#include "jansson.h"
typedef json_t* JSON;
static JSON_INLINE
json_t* json_hex(unsigned json_int_t value)
{
char hexvalue[20];
sprintf_s(hexvalue, "0x%llX", value);
return json_string(hexvalue);
}
static JSON_INLINE
unsigned json_int_t json_hex_value(const json_t* hex)
{
unsigned json_int_t ret = 0;
const char* hexvalue;
hexvalue = json_string_value(hex);
if(!hexvalue)
return 0;
sscanf_s(hexvalue, "0x%llX", &ret);
return ret;
} |
x64dbg-development/src/dbg/jansson/jansson_x86.lib | !<arch>
/ 1403015379 0 3412 `
‰ 2 \ ’ %
%
&N &N %æ %æ %z %z 0– 0– *z *z )ª )ª * * )> )> (Î (Î 5Ô 5Ô ;ä ;ä 4( 4( 3À 3À <P <P ;x ;x ; ; +º +º 1ð 1ð - - ,” ,” ,$ ,$ -p -p -Þ -Þ . . .P .P /¬ /¬ /6 /6 0 0 &¶ &¶ ä ä $ $ #^ #^ !ž !ž !. !. 7 7 :4 :4 9Ê 9Ê 9Z 9Z 6° 6° 8ä 8ä 8v 8v '† '† (^ (^ 'ð 'ð 4’ 4’ 5f 5f 4ú 4ú +J +J :¦ :¦ ' ' *â *â 1v 1v 1 1 $4 $4 "î "î L L "
"
"~ "~ À À 6F 6F 8 8 7’ 7’ 2^ 2^ 2Î 2Î 3H 3H #Ì #Ì__IMPORT_DESCRIPTOR_jansson __NULL_IMPORT_DESCRIPTOR jansson_NULL_THUNK_DATA __imp__json_dump_callback _json_dump_callback __imp__json_dumps _json_dumps __imp__json_dumpf _json_dumpf __imp__json_dump_file _json_dump_file __imp__json_object_seed _json_object_seed __imp__json_loads _json_loads __imp__json_loadb _json_loadb __imp__json_loadf _json_loadf __imp__json_load_file _json_load_file __imp__json_load_callback _json_load_callback __imp__json_set_alloc_funcs _json_set_alloc_funcs __imp__json_vpack_ex _json_vpack_ex __imp__json_pack_ex _json_pack_ex __imp__json_pack _json_pack __imp__json_vunpack_ex _json_vunpack_ex __imp__json_unpack_ex _json_unpack_ex __imp__json_unpack _json_unpack __imp__json_object _json_object __imp__json_object_size _json_object_size __imp__json_object_get _json_object_get __imp__json_object_del _json_object_del __imp__json_object_clear _json_object_clear __imp__json_object_iter _json_object_iter __imp__json_object_iter_at _json_object_iter_at __imp__json_object_iter_next _json_object_iter_next __imp__json_object_iter_key _json_object_iter_key __imp__json_object_iter_value _json_object_iter_value __imp__json_object_iter_set_new _json_object_iter_set_new __imp__json_object_key_to_iter _json_object_key_to_iter __imp__json_equal _json_equal __imp__json_array _json_array __imp__json_delete _json_delete __imp__json_array_size _json_array_size __imp__json_array_get _json_array_get __imp__json_array_extend _json_array_extend __imp__json_string_nocheck _json_string_nocheck __imp__json_stringn_nocheck _json_stringn_nocheck __imp__json_stringn _json_stringn __imp__json_string_value _json_string_value __imp__json_string_length _json_string_length __imp__json_string_setn_nocheck _json_string_setn_nocheck __imp__json_string_setn _json_string_setn __imp__json_integer _json_integer __imp__json_integer_value _json_integer_value __imp__json_integer_set _json_integer_set __imp__json_real _json_real __imp__json_real_value _json_real_value __imp__json_real_set _json_real_set __imp__json_number_value _json_number_value __imp__json_true _json_true __imp__json_false _json_false __imp__json_null _json_null __imp__json_object_set_new_nocheck _json_object_set_new_nocheck __imp__json_object_set_new _json_object_set_new __imp__json_deep_copy _json_deep_copy __imp__json_array_set_new _json_array_set_new __imp__json_array_append_new _json_array_append_new __imp__json_array_insert_new _json_array_insert_new __imp__json_array_remove _json_array_remove __imp__json_array_clear _json_array_clear __imp__json_string _json_string __imp__json_string_set_nocheck _json_string_set_nocheck __imp__json_string_set _json_string_set __imp__json_object_update _json_object_update __imp__json_object_update_existing _json_object_update_existing __imp__json_object_update_missing _json_object_update_missing __imp__json_copy _json_copy / 1403015379 0 3422 `
F 2 \ ’
% N& |