x64dbg/x64dbg
x64dbg
/
x64dbg
1
0
Fork 0
Code Releases 4 Activity

PROJECT: updated help 

DBG: re-wrote breakpoint.cpp
DBG: fixed some small code bugs (thanks DMichael)
DBG: fixed a bug with dbload()
DBG: INT3 breakpoint (set, delete, disable, enable) works again!
This commit is contained in:
mr.exodia 2013-11-18 19:20:18 +01:00
parent 0a86eb07a2
commit aa6c48743a
12 changed files with 295 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
bin/x64/TitanEngine.dll
View File

Binary file not shown.

24
help/x64_dbg.wcp
View File

@ -257,43 +257,43 @@ TitleList.ContextNumber.15=1012
TitleList.ApplyTemp.15=0
TitleList.Expanded.15=0
TitleList.Kind.15=0
TitleList.Title.16=EnableBPX/bpe/be
TitleList.Title.16=DeleteBPX/bpc/bc
TitleList.Level.16=1
TitleList.Url.16=EnableBPX_bpe_be.htm
TitleList.Url.16=DeleteBPX_bpc_bc.htm
TitleList.Icon.16=0
TitleList.Status.16=0
TitleList.Keywords.16=
TitleList.ContextNumber.16=1014
TitleList.ContextNumber.16=1017
TitleList.ApplyTemp.16=0
TitleList.Expanded.16=0
TitleList.Kind.16=0
TitleList.Title.17=DisableBPX/bpd/bd
TitleList.Title.17=EnableBPX/bpe/be
TitleList.Level.17=1
TitleList.Url.17=DisableBPX_bpd_bd.htm
TitleList.Url.17=EnableBPX_bpe_be.htm
TitleList.Icon.17=0
TitleList.Status.17=0
TitleList.Keywords.17=
TitleList.ContextNumber.17=1016
TitleList.ContextNumber.17=1014
TitleList.ApplyTemp.17=0
TitleList.Expanded.17=0
TitleList.Kind.17=0
TitleList.Title.18=ToggleBPX/bpt/bt
TitleList.Title.18=DisableBPX/bpd/bd
TitleList.Level.18=1
TitleList.Url.18=ToggleBPX_bpt_bt.htm
TitleList.Url.18=DisableBPX_bpd_bd.htm
TitleList.Icon.18=0
TitleList.Status.18=0
TitleList.Keywords.18=
TitleList.ContextNumber.18=1019
TitleList.ContextNumber.18=1016
TitleList.ApplyTemp.18=0
TitleList.Expanded.18=0
TitleList.Kind.18=0
TitleList.Title.19=DeleteBPX/bpc/bc
TitleList.Title.19=ToggleBPX/bpt/bt
TitleList.Level.19=1
TitleList.Url.19=DeleteBPX_bpc_bc.htm
TitleList.Url.19=ToggleBPX_bpt_bt.htm
TitleList.Icon.19=0
TitleList.Status.19=0
TitleList.Keywords.19=
TitleList.ContextNumber.19=1017
TitleList.ContextNumber.19=1019
TitleList.ApplyTemp.19=0
TitleList.Expanded.19=0
TitleList.Kind.19=0

3
x64_dbg_bridge/bridgemain.cpp
View File

@ -1,6 +1,7 @@
#include "_global.h"
#include "bridgemain.h"
#include <stdio.h>
#include <new>
static HINSTANCE hInst;
@ -129,7 +130,7 @@ DLL_IMPEXP const char* BridgeStart()
DLL_IMPEXP void* BridgeAlloc(size_t size)
{
unsigned char* a= new unsigned char[size];
unsigned char* a= new (std::nothrow)unsigned char[size];
if(!a)
{
MessageBoxA(0, "Could not allocate memory", "Error", MB_ICONERROR);

15
x64_dbg_dbg/_exports.cpp
View File

@ -182,12 +182,15 @@ extern "C" DLL_EXPORT int _dbg_bpgettypeat(duint addr)
{
BREAKPOINT bp;
int result=0;
if(bpget(addr, BPNORMAL, &bp))
result|=bpnormal;
if(bpget(addr, BPHARDWARE, &bp))
result|=bphardware;
if(bpget(addr, BPMEMORY, &bp))
result|=bpmemory;
if(bpget(addr, BPNORMAL, 0, &bp))
if(bp.enabled)
result|=bpnormal;
if(bpget(addr, BPHARDWARE, 0, &bp))
if(bp.enabled)
result|=bphardware;
if(bpget(addr, BPMEMORY, 0, &bp))
if(bp.enabled)
result|=bpmemory;
return result;
return 0;
}

7
x64_dbg_dbg/_global.cpp
View File

@ -1,8 +1,9 @@
#include "_global.h"
#include <new>
HINSTANCE hInst;
char sqlitedb_basedir[deflen]="";
char dbpath[deflen]="";
char dbpath[3*deflen]="";
void* emalloc(size_t size)
{
@ -25,7 +26,7 @@ static int emalloc_count=0;
void* emalloc(size_t size, const char* reason)
{
unsigned char* a=new unsigned char[size+0x1000];
unsigned char* a=new (std::nothrow)unsigned char[size+0x1000];
if(!a)
{
MessageBoxA(0, "Could not allocate memory", "Error", MB_ICONERROR);
@ -51,6 +52,8 @@ bool arraycontains(const char* cmd_list, const char* cmd)
char temp[deflen]="";
strcpy(temp, cmd_list);
int len=strlen(cmd_list);
if(len>=deflen)
return false;
for(int i=0; i<len; i++)
if(temp[i]==1)
temp[i]=0;

2
x64_dbg_dbg/_global.h
View File

@ -92,7 +92,7 @@ enum BITMASK
//superglobal variables
extern HINSTANCE hInst;
extern char sqlitedb_basedir[deflen];
extern char dbpath[deflen];
extern char dbpath[3*deflen];
//functions
void* emalloc(size_t size);

20
x64_dbg_dbg/addrinfo.cpp
View File

@ -16,18 +16,24 @@ void dbinit()
dputs("failed to open database!");
return;
}
dbload();
sqlloadorsavedb(userdb, dbpath, false);
if(!sqlexec(userdb, "CREATE TABLE IF NOT EXISTS comments (id INTEGER PRIMARY KEY AUTOINCREMENT, mod TEXT, addr INT64 NOT NULL, text TEXT NOT NULL)"))
dprintf("SQL Error: %s\n", sqllasterror());
if(!sqlexec(userdb, "CREATE TABLE IF NOT EXISTS labels (id INTEGER PRIMARY KEY AUTOINCREMENT, mod TEXT, addr INT64 NOT NULL, text TEXT NOT NULL)"))
dprintf("SQL Error: %s\n", sqllasterror());
if(!sqlexec(userdb, "CREATE TABLE IF NOT EXISTS breakpoints (id INTEGER PRIMARY KEY AUTOINCREMENT, addr INT64 NOT NULL, enabled INT NOT NULL, singleshoot INT NOT NULL, oldbytes INT NOT NULL, type INT NOT NULL, titantype INT NOT NULL, mod TEXT, name TEXT)"))
dprintf("SQL Error: %s\n", sqllasterror());
dbsave();
bpenumall(0);
}
bool dbload()
{
if(!FileExists(dbpath))
{
dbinit();
return true;
}
return sqlloadorsavedb(userdb, dbpath, false);
}
@ -203,7 +209,7 @@ bool commentset(uint addr, const char* text)
char commenttext[MAX_COMMENT_SIZE]="";
sqlstringescape(text, commenttext);
char modname[35]="";
char sql[256]="";
char sql[deflen]="";
if(!modnamefromaddr(addr, modname)) //comments without module
{
sprintf(sql, "SELECT text FROM comments WHERE mod IS NULL AND addr=%"fext"d", addr);
@ -237,7 +243,7 @@ bool commentget(uint addr, char* text)
if(!IsFileBeingDebugged() or !memisvalidreadptr(fdProcessInfo->hProcess, addr) or !text)
return false;
char modname[35]="";
char sql[256]="";
char sql[deflen]="";
if(!modnamefromaddr(addr, modname)) //comments without module
sprintf(sql, "SELECT text FROM comments WHERE mod IS NULL AND addr=%"fext"d", addr);
else
@ -250,7 +256,7 @@ bool commentdel(uint addr)
if(!IsFileBeingDebugged() or !memisvalidreadptr(fdProcessInfo->hProcess, addr))
return false;
char modname[35]="";
char sql[256]="";
char sql[deflen]="";
if(!modnamefromaddr(addr, modname)) //comments without module
sprintf(sql, "SELECT id FROM comments WHERE mod IS NULL AND addr=%"fext"d", addr);
else
@ -283,7 +289,7 @@ bool labelset(uint addr, const char* text)
char labeltext[MAX_LABEL_SIZE]="";
sqlstringescape(text, labeltext);
char modname[35]="";
char sql[256]="";
char sql[deflen]="";
if(!modnamefromaddr(addr, modname)) //labels without module
{
sprintf(sql, "SELECT text FROM labels WHERE mod IS NULL AND addr=%"fext"d", addr);
@ -317,7 +323,7 @@ bool labelget(uint addr, char* text)
if(!IsFileBeingDebugged() or !memisvalidreadptr(fdProcessInfo->hProcess, addr) or !text)
return false;
char modname[35]="";
char sql[256]="";
char sql[deflen]="";
if(!modnamefromaddr(addr, modname)) //labels without module
sprintf(sql, "SELECT text FROM labels WHERE mod IS NULL AND addr=%"fext"d", addr);
else
@ -330,7 +336,7 @@ bool labeldel(uint addr)
if(!IsFileBeingDebugged() or !memisvalidreadptr(fdProcessInfo->hProcess, addr))
return false;
char modname[35]="";
char sql[256]="";
char sql[deflen]="";
if(!modnamefromaddr(addr, modname)) //labels without module
sprintf(sql, "SELECT id FROM labels WHERE mod IS NULL AND addr=%"fext"d", addr);
else

6
x64_dbg_dbg/argument.cpp
View File

@ -24,6 +24,8 @@ formatarg:
*/
void argformat(char* cmd)
{
if(strlen(cmd)>=deflen)
return;
char command_[deflen]="";
char* command=command_;
strcpy(command, cmd);
@ -147,7 +149,7 @@ void argformat(char* cmd)
int arggetcount(const char* cmd)
{
int len=strlen(cmd);
if(!len)
if(!len or len>=deflen)
return -1;
int arg_count=0;
@ -182,6 +184,8 @@ int arggetcount(const char* cmd)
*/
bool argget(const char* cmd, char* arg, int arg_num, bool optional)
{
if(strlen(cmd)>=deflen)
return false;
int argcount=arggetcount(cmd);
if((arg_num+1)>argcount)
{

153
x64_dbg_dbg/breakpoint.cpp
View File

@ -4,30 +4,33 @@
#include "sqlhelper.h"
#include "console.h"
static uint bpaddrs[1000];
static int bptitantype[1000];
static BREAKPOINT bpall[1000];
static int bpcount=0;
int bpgetlist(uint** list, int** type)
int bpgetlist(BREAKPOINT** list)
{
if(!list or !type)
return bpcount;
*list=bpaddrs;
*type=bptitantype;
if(list)
*list=bpall;
return bpcount;
}
bool bpnew(uint addr, bool enabled, bool singleshoot, short oldbytes, BP_TYPE type, int titantype)
bool bpnew(uint addr, bool enabled, bool singleshoot, short oldbytes, BP_TYPE type, int titantype, const char* name)
{
char modname[256]="";
if(!modnamefromaddr(addr, modname)) //no module
return false;
char sql[256]="";
char sql[deflen]="";
uint modbase=modbasefromaddr(addr);
sprintf(sql, "SELECT * FROM breakpoints WHERE addr=%"fext"d AND mod='%s' AND type=%d", addr-modbase, modname, type);
if(sqlhasresult(userdb, sql)) //no breakpoint set
if(bpget(addr, type, name, 0)) //breakpoint found
return false;
sprintf(sql, "INSERT INTO breakpoints (addr,enabled,singleshoot,oldbytes,type,titantype,mod) VALUES (%"fext"d,%d,%d,%d,%d,%d,'%s')", addr-modbase, enabled, singleshoot, oldbytes, type, titantype, modname);
char bpname[MAX_BREAKPOINT_NAME]="";
if(name and *name)
{
sqlstringescape(name, bpname);
sprintf(sql, "INSERT INTO breakpoints (addr,enabled,singleshoot,oldbytes,type,titantype,mod,name) VALUES (%"fext"d,%d,%d,%d,%d,%d,'%s','%s')", addr-modbase, enabled, singleshoot, oldbytes, type, titantype, modname, bpname);
}
else
sprintf(sql, "INSERT INTO breakpoints (addr,enabled,singleshoot,oldbytes,type,titantype,mod) VALUES (%"fext"d,%d,%d,%d,%d,%d,'%s')", addr-modbase, enabled, singleshoot, oldbytes, type, titantype, modname);
if(!sqlexec(userdb, sql))
{
dprintf("SQL Error: %s\n", sqllasterror());
@ -38,14 +41,39 @@ bool bpnew(uint addr, bool enabled, bool singleshoot, short oldbytes, BP_TYPE ty
return true;
}
bool bpget(uint addr, BP_TYPE type, BREAKPOINT* bp)
bool bpget(uint addr, BP_TYPE type, const char* name, BREAKPOINT* bp)
{
char sql[256]="";
char sql[deflen]="";
char modname[256]="";
char bpname[MAX_BREAKPOINT_NAME]="";
uint modbase=0;
if(!modnamefromaddr(addr, modname)) //no module
return false;
uint modbase=modbasefromaddr(addr);
sprintf(sql, "SELECT enabled,singleshoot,oldbytes,type,titantype,name FROM breakpoints WHERE addr=%"fext"d AND type=%d AND mod='%s'", addr-modbase, type, modname);
{
if(bp)
*bp->mod=0;
if(name and *name)
{
sqlstringescape(name, bpname);
sprintf(sql, "SELECT addr,enabled,singleshoot,oldbytes,type,titantype,mod,name FROM breakpoints WHERE (addr=%"fext"d AND type=%d AND mod IS NULL) OR name='%s'", addr, type, bpname);
puts(sql);
}
else
sprintf(sql, "SELECT addr,enabled,singleshoot,oldbytes,type,titantype,mod,name FROM breakpoints WHERE (addr=%"fext"d AND type=%d AND mod IS NULL)", addr, type);
}
else
{
if(bp)
strcpy(bp->mod, modname);
modbase=modbasefromaddr(addr);
if(name and *name)
{
sqlstringescape(name, bpname);
sprintf(sql, "SELECT addr,enabled,singleshoot,oldbytes,type,titantype,mod,name FROM breakpoints WHERE (addr=%"fext"d AND type=%d AND mod='%s') OR name='%s'", addr-modbase, type, modname, bpname);
puts(sql);
}
else
sprintf(sql, "SELECT addr,enabled,singleshoot,oldbytes,type,titantype,mod,name FROM breakpoints WHERE (addr=%"fext"d AND type=%d AND mod='%s')", addr-modbase, type, modname);
}
sqlite3_stmt* stmt;
if(sqlite3_prepare_v2(userdb, sql, -1, &stmt, 0)!=SQLITE_OK)
{
@ -62,28 +90,38 @@ bool bpget(uint addr, BP_TYPE type, BREAKPOINT* bp)
sqlite3_finalize(stmt);
return true;
}
if(!modbase)
{
const char* mod=(const char*)sqlite3_column_text(stmt, 6);
if(mod)
modbase=modbasefromname(mod);
}
//addr
bp->addr=addr;
#ifdef _WIN64
bp->addr=sqlite3_column_int64(stmt, 0)+modbase; //addr
#else
bp->addr=sqlite3_column_int(stmt, 0)+modbase; //addr
#endif // _WIN64
//enabled
if(sqlite3_column_int(stmt, 0))
if(sqlite3_column_int(stmt, 1))
bp->enabled=true;
else
bp->enabled=false;
//singleshoot
if(sqlite3_column_int(stmt, 1))
if(sqlite3_column_int(stmt, 2))
bp->singleshoot=true;
else
bp->singleshoot=false;
//oldbytes
bp->oldbytes=(short)(sqlite3_column_int(stmt, 2)&0xFFFF);
bp->oldbytes=(short)(sqlite3_column_int(stmt, 3)&0xFFFF);
//type
bp->type=(BP_TYPE)sqlite3_column_int(stmt, 3);
bp->type=(BP_TYPE)sqlite3_column_int(stmt, 4);
//titantype
bp->titantype=sqlite3_column_int(stmt, 4);
bp->titantype=sqlite3_column_int(stmt, 5);
//name
const char* name=(const char*)sqlite3_column_text(stmt, 5);
if(name)
strcpy(bp->name, name);
const char* bpname_=(const char*)sqlite3_column_text(stmt, 7);
if(bpname_)
strcpy(bp->name, bpname_);
else
*bp->name=0;
sqlite3_finalize(stmt);
@ -92,15 +130,15 @@ bool bpget(uint addr, BP_TYPE type, BREAKPOINT* bp)
bool bpdel(uint addr, BP_TYPE type)
{
BREAKPOINT found;
if(!bpget(addr, type, 0, &found))
return false;
char modname[256]="";
char sql[deflen]="";
if(!modnamefromaddr(addr, modname)) //no module
return false;
uint modbase=modbasefromaddr(addr);
char sql[256]="";
sprintf(sql, "SELECT * FROM breakpoints WHERE addr=%"fext"d AND mod='%s' AND type=%d", addr-modbase, modname, type);
if(!sqlhasresult(userdb, sql)) //no breakpoint
return false;
sprintf(sql, "DELETE FROM breakpoints WHERE addr=%"fext"d AND mod='%s' AND type=%d", addr-modbase, modname, type);
sprintf(sql, "DELETE FROM breakpoints WHERE addr=%"fext"d AND IS NULL AND type=%d", addr, type);
else
sprintf(sql, "DELETE FROM breakpoints WHERE addr=%"fext"d AND mod='%s' AND type=%d", addr-modbasefromaddr(addr), modname, type);
if(!sqlexec(userdb, sql))
{
dprintf("SQL Error: %s\n", sqllasterror());
@ -113,21 +151,22 @@ bool bpdel(uint addr, BP_TYPE type)
bool bpenable(uint addr, BP_TYPE type, bool enable)
{
BREAKPOINT found;
if(!bpget(addr, type, 0, &found))
return false;
char modname[256]="";
char sql[deflen]="";
if(!modnamefromaddr(addr, modname)) //no module
return false;
uint modbase=modbasefromaddr(addr);
char sql[256]="";
sprintf(sql, "SELECT * FROM breakpoints WHERE addr=%"fext"d AND mod='%s' AND type=%d", addr-modbase, modname, type);
if(!sqlhasresult(userdb, sql)) //no breakpoint
return false;
sprintf(sql, "UPDATE breakpoints SET enabled=%d WHERE addr=%"fext"d AND mod='%s' AND type=%d", enable, addr-modbase, modname, type);
if(!sqlexec(userdb, sql))
sprintf(sql, "UPDATE breakpoints SET enabled=%d WHERE addr=%"fext"d AND mod IS NULL AND type=%d", enable, addr, type);
else
sprintf(sql, "UPDATE breakpoints SET enabled=%d WHERE addr=%"fext"d AND mod='%s' AND type=%d", enable, addr-modbasefromaddr(addr), modname, type);
if(sqlexec(userdb, sql))
{
dprintf("SQL Error: %s\n", sqllasterror());
return false;
}
dbsave();
bpenumall(0); //update breakpoint list
return true;
}
@ -136,19 +175,13 @@ bool bpsetname(uint addr, BP_TYPE type, const char* name)
if(!name)
return false;
char modname[256]="";
if(!modnamefromaddr(addr, modname)) //no module
return false;
uint modbase=modbasefromaddr(addr);
char sql[256]="";
sprintf(sql, "SELECT * FROM breakpoints WHERE addr=%"fext"d AND mod='%s' AND type=%d", addr-modbase, modname, type);
if(!sqlexec(userdb, sql))
{
dprintf("SQL Error: %s\n", sqllasterror());
return false;
}
char sql[deflen]="";
char bpname[MAX_BREAKPOINT_NAME]="";
sqlstringescape(name, bpname);
sprintf(sql, "UPDATE breakpoints SET name='%s' WHERE addr=%"fext"d AND mod='%s' AND type=%d", bpname, addr-modbase, modname, type);
if(!modnamefromaddr(addr, modname)) //no module
sprintf(sql, "UPDATE breakpoints SET name='%s' WHERE addr=%"fext"d AND mod IS NULL AND type=%d", bpname, addr, type);
else
sprintf(sql, "UPDATE breakpoints SET name='%s' WHERE addr=%"fext"d AND mod='%s' AND type=%d", bpname, addr-modbasefromaddr(addr), modname, type);
if(!sqlexec(userdb, sql))
{
dprintf("SQL Error: %s\n", sqllasterror());
@ -160,9 +193,10 @@ bool bpsetname(uint addr, BP_TYPE type, const char* name)
bool bpenumall(BPENUMCALLBACK cbEnum, const char* module)
{
bool retval=true;
if(!cbEnum)
bpcount=0;
char sql[256]="";
char sql[deflen]="";
if(!module)
sprintf(sql, "SELECT addr,enabled,singleshoot,oldbytes,type,titantype,mod,name FROM breakpoints");
else
@ -203,22 +237,25 @@ bool bpenumall(BPENUMCALLBACK cbEnum, const char* module)
strcpy(curbp.name, bpname);
else
*curbp.name=0;
//TODO: fix breakpoints without module
uint modbase=modbasefromname(modname);
if(!modbase) //module not loaded
if(!modbase) //module not loaded //TODO: fix this
continue;
curbp.addr=modbase+rva;
if(cbEnum)
cbEnum(&curbp);
{
if(!cbEnum(&curbp))
retval=false;
}
else if(bpcount<1000 and curbp.type==BPNORMAL)
{
bpaddrs[bpcount]=curbp.addr;
bptitantype[bpcount]=curbp.titantype;
memcpy(&bpall[bpcount], &curbp, sizeof(BREAKPOINT));
bpcount++;
}
}
while(sqlite3_step(stmt)==SQLITE_ROW);
sqlite3_finalize(stmt);
return true;
return retval;
}
bool bpenumall(BPENUMCALLBACK cbEnum)

9
x64_dbg_dbg/breakpoint.h
View File

@ -25,16 +25,17 @@ struct BREAKPOINT
BP_TYPE type;
int titantype;
char name[MAX_BREAKPOINT_NAME];
char mod[32];
};
#pragma pack()
//typedefs
typedef void (*BPENUMCALLBACK)(const BREAKPOINT* bp);
typedef bool (*BPENUMCALLBACK)(const BREAKPOINT* bp);
//functions
int bpgetlist(uint** list, int** type);
bool bpnew(uint addr, bool enabled, bool singleshoot, short oldbytes, BP_TYPE type, int titantype);
bool bpget(uint addr, BP_TYPE type, BREAKPOINT* bp);
int bpgetlist(BREAKPOINT** list);
bool bpnew(uint addr, bool enabled, bool singleshoot, short oldbytes, BP_TYPE type, int titantype, const char* name);
bool bpget(uint addr, BP_TYPE type, const char* name, BREAKPOINT* bp);
bool bpdel(uint addr, BP_TYPE type);
bool bpenable(uint addr, BP_TYPE type, bool enable);
bool bpsetname(uint addr, BP_TYPE type, const char* name);

359
x64_dbg_dbg/debugger.cpp
View File

@ -30,25 +30,24 @@ static void cbUserBreakpoint();
void dbgdisablebpx()
{
uint* bplist=0;
int* titantype=0;
int bpcount=bpgetlist(&bplist, &titantype);
BREAKPOINT* list;
int bpcount=bpgetlist(&list);
for(int i=0; i<bpcount; i++)
{
//printf(fhex"\n", bplist[i]);
if(IsBPXEnabled(bplist[i]))
DeleteBPX(bplist[i]);
if(IsBPXEnabled(list[i].addr))
DeleteBPX(list[i].addr);
}
}
void dbgenablebpx()
{
uint* bplist=0;
int* titantype=0;
int bpcount=bpgetlist(&bplist, &titantype);
BREAKPOINT* list;
int bpcount=bpgetlist(&list);
for(int i=0; i<bpcount; i++)
if(!IsBPXEnabled(bplist[i]))
SetBPX(bplist[i], titantype[i], (void*)cbUserBreakpoint);
{
if(!IsBPXEnabled(list[i].addr) and list[i].enabled)
SetBPX(list[i].addr, list[i].titantype, (void*)cbUserBreakpoint);
}
}
bool dbgisrunning()
@ -66,9 +65,8 @@ void DebugUpdateGui(uint disasm_addr)
static void cbUserBreakpoint()
{
//TODO: restore bp
BREAKPOINT bp;
if(!bpget(GetContextData(UE_CIP), BPNORMAL, &bp))
if(!bpget(GetContextData(UE_CIP), BPNORMAL, 0, &bp) and bp.enabled)
dputs("breakpoint reached not in list!");
else
{
@ -139,6 +137,7 @@ static void cbMemoryBreakpoint(void* ExceptionAddress)
uint cip=GetContextData(UE_CIP);
uint size;
uint base=memfindbaseaddr(fdProcessInfo->hProcess, (uint)ExceptionAddress, &size);
//TODO: restore bp
/*BREAKPOINT* cur=bpfind(bplist, 0, base, 0, BPMEMORY);
if(!cur)
dputs("memory breakpoint reached not in list!");
@ -246,14 +245,17 @@ SymRegisterCallbackProc64(
return TRUE;
}
static void cbSetModuleBreakpoints(const BREAKPOINT* bp)
static bool cbSetModuleBreakpoints(const BREAKPOINT* bp)
{
//TODO: more breakpoint types
switch(bp->type)
{
case BPNORMAL:
if(bp->enabled)
SetBPX(bp->addr, bp->titantype, (void*)cbUserBreakpoint);
{
if(!SetBPX(bp->addr, bp->titantype, (void*)cbUserBreakpoint))
dprintf("could not set breakpoint "fhex"\n!", bp->addr);
}
break;
case BPMEMORY:
break;
@ -262,6 +264,7 @@ static void cbSetModuleBreakpoints(const BREAKPOINT* bp)
default:
break;
}
return true;
}
static void cbLoadDll(LOAD_DLL_DEBUG_INFO* LoadDll)
@ -285,7 +288,7 @@ static void cbLoadDll(LOAD_DLL_DEBUG_INFO* LoadDll)
bpenumall(cbSetModuleBreakpoints, modname);
}
static void cbRemoveModuleBreakpoints(const BREAKPOINT* bp)
static bool cbRemoveModuleBreakpoints(const BREAKPOINT* bp)
{
//TODO: more breakpoint types
switch(bp->type)
@ -301,6 +304,7 @@ static void cbRemoveModuleBreakpoints(const BREAKPOINT* bp)
default:
break;
}
return true;
}
static void cbUnloadDll(UNLOAD_DLL_DEBUG_INFO* UnloadDll)
@ -314,9 +318,8 @@ static void cbUnloadDll(UNLOAD_DLL_DEBUG_INFO* UnloadDll)
dprintf("DLL Unloaded: "fhex" %s\n", base, DLLDebugFileName);
char modname[256]="";
if(modnamefromaddr((uint)base, modname))
bpenumall(cbSetModuleBreakpoints, modname);
bpenumall(cbRemoveModuleBreakpoints, modname);
SymUnloadModule64(fdProcessInfo->hProcess, (DWORD64)base);
bpenumall(0);
}
static void cbCreateProcess(CREATE_PROCESS_DEBUG_INFO* CreateProcessInfo)
@ -565,9 +568,6 @@ CMDRESULT cbDebugSetBPXOptions(const char* cmd)
CMDRESULT cbDebugSetBPX(const char* cmd) //bp addr [,name [,type]]
{
char argaddr[deflen]="";
if(!argget(cmd, argaddr, 0, true))
if(!_strnicmp(cmd, "bp", 2))
return cbBadCmd(cmd);
if(!argget(cmd, argaddr, 0, false))
return STATUS_ERROR;
char argname[deflen]="";
@ -586,7 +586,7 @@ CMDRESULT cbDebugSetBPX(const char* cmd) //bp addr [,name [,type]]
dprintf("invalid addr: \"%s\"\n", argaddr);
return STATUS_ERROR;
}
if(addr==(uint)(GetPE32Data(szFileName, 0, UE_OEP)+GetPE32Data(szFileName, 0, UE_IMAGEBASE)))
if(addr==(uint)(GetPE32Data(szFileName, 0, UE_OEP)+pDebuggedDllBase))
{
dputs("entry breakpoint will be set automatically");
return STATUS_ERROR;
@ -607,256 +607,189 @@ CMDRESULT cbDebugSetBPX(const char* cmd) //bp addr [,name [,type]]
else if(strstr(argtype, "short"))
type|=UE_BREAKPOINT_TYPE_INT3;
short oldbytes;
bool found=bpget(addr, BPNORMAL, 0);
if(IsBPXEnabled(addr) or !memread(fdProcessInfo->hProcess, (void*)addr, &oldbytes, sizeof(short), 0) or found or !SetBPX(addr, type, (void*)cbUserBreakpoint))
const char* bpname=0;
if(*argname)
bpname=argname;
if(IsBPXEnabled(addr) or !memread(fdProcessInfo->hProcess, (void*)addr, &oldbytes, sizeof(short), 0) or bpget(addr, BPNORMAL, bpname, 0) or !SetBPX(addr, type, (void*)cbUserBreakpoint) or !bpnew(addr, true, singleshoot, oldbytes, BPNORMAL, type, bpname))
{
dprintf("error setting breakpoint at "fhex"!\n", addr);
return STATUS_ERROR;
}
if(bpnew(addr, true, singleshoot, oldbytes, BPNORMAL, type))
dprintf("breakpoint at "fhex" set!\n", addr);
else
{
dputs("problem setting breakpoint!");
return STATUS_ERROR;
}
dprintf("breakpoint at "fhex" set!\n", addr);
GuiUpdateAllViews();
return STATUS_CONTINUE;
}
static bool cbDeleteAllBreakpoints(const BREAKPOINT* bp)
{
if(DeleteBPX(bp->addr) and bpdel(bp->addr, BPNORMAL))
return true;
dprintf("delete breakpoint failed: "fhex"\n", bp->addr);
return false;
}
CMDRESULT cbDebugDeleteBPX(const char* cmd)
{
char arg1[deflen]="";
if(!argget(cmd, arg1, 0, true)) //delete all breakpoints
{
if(!bpgetlist(0)) //get number of breakpoints
{
dputs("no breakpoints to delete!");
return STATUS_CONTINUE;
}
if(!bpenumall(cbDeleteAllBreakpoints)) //at least one deletion failed
return STATUS_ERROR;
dputs("all breakpoints deleted!");
GuiUpdateAllViews();
return STATUS_CONTINUE;
}
BREAKPOINT found;
if(bpget(0, BPNORMAL, arg1, &found)) //found a breakpoint with name
{
if(!DeleteBPX(found.addr) or !bpdel(found.addr, BPNORMAL))
{
dprintf("delete breakpoint failed: "fhex"\n", found.addr);
return STATUS_ERROR;
}
return STATUS_CONTINUE;
}
uint addr=0;
if(!valfromstring(arg1, &addr, 0, 0, true, 0) or !bpget(addr, BPNORMAL, 0, &found)) //invalid breakpoint
{
dprintf("no such breakpoint \"%s\"\n", arg1);
return STATUS_ERROR;
}
if(!DeleteBPX(found.addr) or !bpdel(found.addr, BPNORMAL))
{
dprintf("delete breakpoint failed: "fhex"\n", found.addr);
return STATUS_ERROR;
}
dputs("breakpoint deleted!");
GuiUpdateAllViews();
return STATUS_CONTINUE;
}
static bool cbEnableAllBreakpoints(const BREAKPOINT* bp)
{
if(!SetBPX(bp->addr, bp->titantype, (void*)cbUserBreakpoint) or !bpenable(bp->addr, BPNORMAL, true))
{
dprintf("could not enable "fhex"\n", bp->addr);
return false;
}
return true;
}
CMDRESULT cbDebugEnableBPX(const char* cmd)
{
//TODO: restore bp
/*
char arg1[deflen]="";
if(!argget(cmd, arg1, 0, true)) //enable all breakpoints
if(!argget(cmd, arg1, 0, true)) //delete all breakpoints
{
BREAKPOINT* cur=bplist;
if(!cur or !cur->addr)
if(!bpgetlist(0)) //get number of breakpoints
{
dputs("no breakpoints!");
dputs("no breakpoints to enable!");
return STATUS_CONTINUE;
}
if(!bpenumall(cbEnableAllBreakpoints)) //at least one deletion failed
return STATUS_ERROR;
}
bool bNext=true;
CMDRESULT res=STATUS_CONTINUE;
while(bNext)
{
if(!SetBPX(cur->addr, cur->type, (void*)cbUserBreakpoint))
{
dprintf("could not enable %.8X\n", cur->addr);
res=STATUS_ERROR;
}
else
cur->enabled=true;
cur=cur->next;
if(!cur)
bNext=false;
}
dputs("all breakpoints enabled!");
GuiUpdateAllViews();
return res;
return STATUS_CONTINUE;
}
BREAKPOINT* bp=bpfind(bplist, arg1, 0, 0, BPNORMAL);
if(!bp)
BREAKPOINT found;
if(bpget(0, BPNORMAL, arg1, &found)) //found a breakpoint with name
{
uint addr=0;
if(!valfromstring(arg1, &addr, 0, 0, false, 0))
if(!SetBPX(found.addr, found.titantype, (void*)cbUserBreakpoint) or !bpenable(found.addr, BPNORMAL, true))
{
dprintf("invalid addr: \"%s\"\n", arg1);
return STATUS_ERROR;
}
bp=bpfind(bplist, 0, addr, 0, BPNORMAL);
if(!bp)
{
dprintf("no such breakpoint: \"%s\"\n", arg1);
dprintf("could not enable "fhex"\n", found.addr);
return STATUS_ERROR;
}
GuiUpdateAllViews();
return STATUS_CONTINUE;
}
if(bp->type!=BPNORMAL and bp->type!=BPSINGLESHOOT)
uint addr=0;
if(!valfromstring(arg1, &addr, 0, 0, true, 0) or !bpget(addr, BPNORMAL, 0, &found)) //invalid breakpoint
{
dputs("this breakpoint type cannot be enabled");
dprintf("no such breakpoint \"%s\"\n", arg1);
return STATUS_ERROR;
}
if(bp->enabled)
if(found.enabled)
{
dputs("breakpoint already enabled!");
GuiUpdateAllViews();
return STATUS_CONTINUE;
}
if(!SetBPX(found.addr, found.titantype, (void*)cbUserBreakpoint) or !bpenable(found.addr, BPNORMAL, true))
{
dprintf("could not enable "fhex"\n", found.addr);
return STATUS_ERROR;
}
if(!SetBPX(bp->addr, bp->type, (void*)cbUserBreakpoint))
dputs("could not enable breakpoint");
else
bp->enabled=true;
GuiUpdateAllViews();*/
dputs("breakpoint enabled!");
GuiUpdateAllViews();
return STATUS_CONTINUE;
}
static bool cbDisableAllBreakpoints(const BREAKPOINT* bp)
{
if(!DeleteBPX(bp->addr) or !bpenable(bp->addr, BPNORMAL, false))
{
dprintf("could not disable "fhex"\n", bp->addr);
return false;
}
return true;
}
CMDRESULT cbDebugDisableBPX(const char* cmd)
{
//TODO: restore bp
/*
char arg1[deflen]="";
if(!argget(cmd, arg1, 0, true)) //disable all breakpoints
if(!argget(cmd, arg1, 0, true)) //delete all breakpoints
{
BREAKPOINT* cur=bplist;
if(!cur or !cur->addr)
if(!bpgetlist(0)) //get number of breakpoints
{
dputs("no breakpoints!");
dputs("no breakpoints to disable!");
return STATUS_CONTINUE;
}
if(!bpenumall(cbDisableAllBreakpoints)) //at least one deletion failed
return STATUS_ERROR;
}
bool bNext=true;
CMDRESULT res=STATUS_CONTINUE;
while(bNext)
{
if(!DeleteBPX(cur->addr))
{
dprintf("could not disable %.8X\n", cur->addr);
res=STATUS_ERROR;
}
else
cur->enabled=false;
cur=cur->next;
if(!cur)
bNext=false;
}
dputs("all breakpoints disabled!");
GuiUpdateAllViews();
return res;
return STATUS_CONTINUE;
}
BREAKPOINT* bp=bpfind(bplist, arg1, 0, 0, BPNORMAL);
if(!bp)
BREAKPOINT found;
if(bpget(0, BPNORMAL, arg1, &found)) //found a breakpoint with name
{
uint addr=0;
if(!valfromstring(arg1, &addr, 0, 0, false, 0))
if(!DeleteBPX(found.addr) or !bpenable(found.addr, BPNORMAL, false))
{
dprintf("invalid addr: \"%s\"\n", arg1);
return STATUS_ERROR;
}
bp=bpfind(bplist, 0, addr, 0, BPNORMAL);
if(!bp)
{
dprintf("no such breakpoint: \"%s\"\n", arg1);
dprintf("could not disable "fhex"\n", found.addr);
return STATUS_ERROR;
}
GuiUpdateAllViews();
return STATUS_CONTINUE;
}
if(bp->type!=BPNORMAL and bp->type!=BPSINGLESHOOT)
uint addr=0;
if(!valfromstring(arg1, &addr, 0, 0, true, 0) or !bpget(addr, BPNORMAL, 0, &found)) //invalid breakpoint
{
dputs("this breakpoint type cannot be disabled");
dprintf("no such breakpoint \"%s\"\n", arg1);
return STATUS_ERROR;
}
if(!bp->enabled)
if(!found.enabled)
{
dputs("breakpoint already disabled!");
return STATUS_CONTINUE;
}
if(!DeleteBPX(found.addr) or !bpenable(found.addr, BPNORMAL, false))
{
dprintf("could not disable "fhex"\n", found.addr);
return STATUS_ERROR;
}
if(!DeleteBPX(bp->addr))
dputs("could not disable breakpoint");
else
bp->enabled=false;
GuiUpdateAllViews();*/
dputs("breakpoint enabled!");
GuiUpdateAllViews();
return STATUS_CONTINUE;
}
CMDRESULT cbDebugToggleBPX(const char* cmd)
{
//TODO: restore bp
/*
char arg1[deflen]="";
if(!argget(cmd, arg1, 0, false))
return STATUS_ERROR;
BREAKPOINT* bp=bpfind(bplist, arg1, 0, 0, BPNORMAL);
if(!bp)
{
uint addr=0;
if(!valfromstring(arg1, &addr, 0, 0, false, 0))
{
dprintf("invalid addr: \"%s\"\n", arg1);
return STATUS_ERROR;
}
bp=bpfind(bplist, 0, addr, 0, BPNORMAL);
if(!bp)
{
dprintf("no such breakpoint: \"%s\"\n", arg1);
return STATUS_ERROR;
}
}
if(bp->type!=BPNORMAL and bp->type!=BPSINGLESHOOT)
{
dputs("this breakpoint type cannot be toggled");
return STATUS_ERROR;
}
bool disable=bp->enabled;
if(disable)
{
if(!DeleteBPX(bp->addr))
{
dputs("could not disable breakpoint");
return STATUS_ERROR;
}
else
{
bp->enabled=false;
dputs("breakpoint disabled!");
}
}
else
{
if(!SetBPX(bp->addr, bp->type, (void*)cbUserBreakpoint))
{
dputs("could not disable breakpoint");
return STATUS_ERROR;
}
else
{
bp->enabled=true;
dputs("breakpoint enabled!");
}
}
varset("$res", (uint)disable, false);
GuiUpdateAllViews();*/
return STATUS_CONTINUE;
}
static void cbDeleteAllBreakpoints(const BREAKPOINT* bp)
{
DeleteBPX(bp->addr);
bpdel(bp->addr, BPNORMAL);
}
CMDRESULT cbDebugDeleteBPX(const char* cmd)
{
//TODO: restore bp
char arg1[deflen]="";
if(!argget(cmd, arg1, 0, true)) //delete all breakpoints
{
if(!bpgetlist(0, 0))
{
dputs("no breakpoints!");
return STATUS_ERROR;
}
bpenumall(cbDeleteAllBreakpoints);
dputs("all breakpoints deleted!");
GuiUpdateAllViews();
return STATUS_CONTINUE;
}
BREAKPOINT bp;
uint addr=0;
if(!valfromstring(arg1, &addr, 0, 0, false, 0))
{
dprintf("invalid addr: \"%s\"\n", arg1);
return STATUS_ERROR;
}
if(!bpget(addr, BPNORMAL, &bp))
{
dprintf("no such breakpoint: \"%s\"\n", arg1);
return STATUS_ERROR;
}
if(!DeleteBPX(bp.addr))
{
dprintf("delete breakpoint failed: "fhex"\n", bp.addr);
return STATUS_ERROR;
}
bpdel(addr, BPNORMAL);
GuiUpdateAllViews();
return STATUS_CONTINUE;
}

3
x64_dbg_dbg/x64_dbg.cpp
View File

@ -123,7 +123,8 @@ extern "C" DLL_EXPORT const char* _dbg_dbginit()
{
DeleteFileA("DLLLoader.exe");
char dir[deflen]="";
GetModuleFileNameA(hInst, dir, deflen);
if(!GetModuleFileNameA(hInst, dir, deflen))
return "GetModuleFileNameA failed!";
int len=strlen(dir);
while(dir[len]!='\\')
len--;