2020 lines
60 KiB
C++
2020 lines
60 KiB
C++
#include "debugger_commands.h"
|
|
#include "console.h"
|
|
#include "value.h"
|
|
#include "thread.h"
|
|
#include "memory.h"
|
|
#include "threading.h"
|
|
#include "variable.h"
|
|
#include "argument.h"
|
|
#include "plugin_loader.h"
|
|
#include "simplescript.h"
|
|
#include "symbolinfo.h"
|
|
#include "assemble.h"
|
|
#include "disasm_fast.h"
|
|
|
|
static bool bScyllaLoaded = false;
|
|
uint LoadLibThreadID;
|
|
LPVOID DLLNameMem;
|
|
LPVOID ASMAddr;
|
|
TITAN_ENGINE_CONTEXT_t backupctx = { 0 };
|
|
|
|
CMDRESULT cbDebugInit(int argc, char* argv[])
|
|
{
|
|
if(DbgIsDebugging())
|
|
DbgCmdExecDirect("stop");
|
|
|
|
static char arg1[deflen] = "";
|
|
if(!argget(*argv, arg1, 0, false))
|
|
return STATUS_ERROR;
|
|
char szResolvedPath[MAX_PATH] = "";
|
|
if(ResolveShortcut(GuiGetWindowHandle(), StringUtils::Utf8ToUtf16(arg1).c_str(), szResolvedPath, _countof(szResolvedPath)))
|
|
{
|
|
dprintf("Resolved shortcut \"%s\"->\"%s\"\n", arg1, szResolvedPath);
|
|
strcpy_s(arg1, szResolvedPath);
|
|
}
|
|
if(!FileExists(arg1))
|
|
{
|
|
dputs("File does not exist!");
|
|
return STATUS_ERROR;
|
|
}
|
|
HANDLE hFile = CreateFileW(StringUtils::Utf8ToUtf16(arg1).c_str(), GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
|
|
if(hFile == INVALID_HANDLE_VALUE)
|
|
{
|
|
dputs("Could not open file!");
|
|
return STATUS_ERROR;
|
|
}
|
|
GetFileNameFromHandle(hFile, arg1); //get full path of the file
|
|
CloseHandle(hFile);
|
|
|
|
//do some basic checks
|
|
switch(GetFileArchitecture(arg1))
|
|
{
|
|
case invalid:
|
|
dputs("Invalid PE file!");
|
|
return STATUS_ERROR;
|
|
#ifdef _WIN64
|
|
case x32:
|
|
dputs("Use x32_dbg to debug this file!");
|
|
#else //x86
|
|
case x64:
|
|
dputs("Use x64_dbg to debug this file!");
|
|
#endif //_WIN64
|
|
return STATUS_ERROR;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
static char arg2[deflen] = "";
|
|
argget(*argv, arg2, 1, true);
|
|
char* commandline = 0;
|
|
if(strlen(arg2))
|
|
commandline = arg2;
|
|
|
|
char arg3[deflen] = "";
|
|
argget(*argv, arg3, 2, true);
|
|
|
|
static char currentfolder[deflen] = "";
|
|
strcpy(currentfolder, arg1);
|
|
int len = (int)strlen(currentfolder);
|
|
while(currentfolder[len] != '\\' and len != 0)
|
|
len--;
|
|
currentfolder[len] = 0;
|
|
|
|
if(DirExists(arg3))
|
|
strcpy(currentfolder, arg3);
|
|
//initialize
|
|
wait(WAITID_STOP); //wait for the debugger to stop
|
|
waitclear(); //clear waiting flags NOTE: thread-unsafe
|
|
|
|
static INIT_STRUCT init;
|
|
memset(&init, 0, sizeof(INIT_STRUCT));
|
|
init.exe = arg1;
|
|
init.commandline = commandline;
|
|
if(*currentfolder)
|
|
init.currentfolder = currentfolder;
|
|
CloseHandle(CreateThread(0, 0, threadDebugLoop, &init, 0, 0));
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbStopDebug(int argc, char* argv[])
|
|
{
|
|
scriptreset(); //reset the currently-loaded script
|
|
StopDebug();
|
|
unlock(WAITID_RUN);
|
|
wait(WAITID_STOP);
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugRun(int argc, char* argv[])
|
|
{
|
|
if(!waitislocked(WAITID_RUN))
|
|
{
|
|
dputs("Program is already running");
|
|
return STATUS_ERROR;
|
|
}
|
|
GuiSetDebugState(running);
|
|
unlock(WAITID_RUN);
|
|
PLUG_CB_RESUMEDEBUG callbackInfo;
|
|
callbackInfo.reserved = 0;
|
|
plugincbcall(CB_RESUMEDEBUG, &callbackInfo);
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugErun(int argc, char* argv[])
|
|
{
|
|
if(waitislocked(WAITID_RUN))
|
|
dbgsetskipexceptions(true);
|
|
return cbDebugRun(argc, argv);
|
|
}
|
|
|
|
CMDRESULT cbDebugSetBPXOptions(int argc, char* argv[])
|
|
{
|
|
char argtype[deflen] = "";
|
|
DWORD type = 0;
|
|
if(!argget(*argv, argtype, 0, false))
|
|
return STATUS_ERROR;
|
|
const char* a = 0;
|
|
uint setting_type;
|
|
if(strstr(argtype, "long"))
|
|
{
|
|
setting_type = 1; //break_int3long
|
|
a = "TYPE_LONG_INT3";
|
|
type = UE_BREAKPOINT_LONG_INT3;
|
|
}
|
|
else if(strstr(argtype, "ud2"))
|
|
{
|
|
setting_type = 2; //break_ud2
|
|
a = "TYPE_UD2";
|
|
type = UE_BREAKPOINT_UD2;
|
|
}
|
|
else if(strstr(argtype, "short"))
|
|
{
|
|
setting_type = 0; //break_int3short
|
|
a = "TYPE_INT3";
|
|
type = UE_BREAKPOINT_INT3;
|
|
}
|
|
else
|
|
{
|
|
dputs("Invalid type specified!");
|
|
return STATUS_ERROR;
|
|
}
|
|
SetBPXOptions(type);
|
|
BridgeSettingSetUint("Engine", "BreakpointType", setting_type);
|
|
dprintf("Default breakpoint type set to: %s\n", a);
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugSetBPX(int argc, char* argv[]) //bp addr [,name [,type]]
|
|
{
|
|
char argaddr[deflen] = "";
|
|
if(!argget(*argv, argaddr, 0, false))
|
|
return STATUS_ERROR;
|
|
char argname[deflen] = "";
|
|
argget(*argv, argname, 1, true);
|
|
char argtype[deflen] = "";
|
|
bool has_arg2 = argget(*argv, argtype, 2, true);
|
|
if(!has_arg2 and (scmp(argname, "ss") or scmp(argname, "long") or scmp(argname, "ud2")))
|
|
{
|
|
strcpy(argtype, argname);
|
|
*argname = 0;
|
|
}
|
|
_strlwr(argtype);
|
|
uint addr = 0;
|
|
if(!valfromstring(argaddr, &addr))
|
|
{
|
|
dprintf("Invalid addr: \"%s\"\n", argaddr);
|
|
return STATUS_ERROR;
|
|
}
|
|
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;
|
|
if(bpget(addr, BPNORMAL, bpname, 0))
|
|
{
|
|
dputs("Breakpoint already set!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
if(IsBPXEnabled(addr))
|
|
{
|
|
dprintf("Error setting breakpoint at "fhex"! (IsBPXEnabled)\n", addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
else if(!memread(fdProcessInfo->hProcess, (void*)addr, &oldbytes, sizeof(short), 0))
|
|
{
|
|
dprintf("Error setting breakpoint at "fhex"! (memread)\n", addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
else if(!bpnew(addr, true, singleshoot, oldbytes, BPNORMAL, type, bpname))
|
|
{
|
|
dprintf("Error setting breakpoint at "fhex"! (bpnew)\n", addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
else if(!SetBPX(addr, type, (void*)cbUserBreakpoint))
|
|
{
|
|
dprintf("Error setting breakpoint at "fhex"! (SetBPX)\n", addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
dprintf("Breakpoint at "fhex" set!\n", addr);
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugDeleteBPX(int argc, char* argv[])
|
|
{
|
|
char arg1[deflen] = "";
|
|
if(!argget(*argv, arg1, 0, true)) //delete all breakpoints
|
|
{
|
|
if(!bpgetcount(BPNORMAL))
|
|
{
|
|
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(!bpdel(found.addr, BPNORMAL))
|
|
{
|
|
dprintf("Delete breakpoint failed (bpdel): "fhex"\n", found.addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
else if(found.enabled && !DeleteBPX(found.addr))
|
|
{
|
|
dprintf("Delete breakpoint failed (DeleteBPX): "fhex"\n", found.addr);
|
|
GuiUpdateAllViews();
|
|
return STATUS_ERROR;
|
|
}
|
|
return STATUS_CONTINUE;
|
|
}
|
|
uint addr = 0;
|
|
if(!valfromstring(arg1, &addr) or !bpget(addr, BPNORMAL, 0, &found)) //invalid breakpoint
|
|
{
|
|
dprintf("No such breakpoint \"%s\"\n", arg1);
|
|
return STATUS_ERROR;
|
|
}
|
|
if(!bpdel(found.addr, BPNORMAL))
|
|
{
|
|
dprintf("Delete breakpoint failed (bpdel): "fhex"\n", found.addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
else if(found.enabled && !DeleteBPX(found.addr))
|
|
{
|
|
dprintf("Delete breakpoint failed (DeleteBPX): "fhex"\n", found.addr);
|
|
GuiUpdateAllViews();
|
|
return STATUS_ERROR;
|
|
}
|
|
dputs("Breakpoint deleted!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugEnableBPX(int argc, char* argv[])
|
|
{
|
|
char arg1[deflen] = "";
|
|
if(!argget(*argv, arg1, 0, true)) //enable all breakpoints
|
|
{
|
|
if(!bpgetcount(BPNORMAL))
|
|
{
|
|
dputs("No breakpoints to enable!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
if(!bpenumall(cbEnableAllBreakpoints)) //at least one enable failed
|
|
return STATUS_ERROR;
|
|
dputs("All breakpoints enabled!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
BREAKPOINT found;
|
|
if(bpget(0, BPNORMAL, arg1, &found)) //found a breakpoint with name
|
|
{
|
|
if(!bpenable(found.addr, BPNORMAL, true) or !SetBPX(found.addr, found.titantype, (void*)cbUserBreakpoint))
|
|
{
|
|
dprintf("Could not enable breakpoint "fhex"\n", found.addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
uint addr = 0;
|
|
if(!valfromstring(arg1, &addr) or !bpget(addr, BPNORMAL, 0, &found)) //invalid breakpoint
|
|
{
|
|
dprintf("No such breakpoint \"%s\"\n", arg1);
|
|
return STATUS_ERROR;
|
|
}
|
|
if(found.enabled)
|
|
{
|
|
dputs("Breakpoint already enabled!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
if(!bpenable(found.addr, BPNORMAL, true) or !SetBPX(found.addr, found.titantype, (void*)cbUserBreakpoint))
|
|
{
|
|
dprintf("Could not enable breakpoint "fhex"\n", found.addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
dputs("Breakpoint enabled!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugDisableBPX(int argc, char* argv[])
|
|
{
|
|
char arg1[deflen] = "";
|
|
if(!argget(*argv, arg1, 0, true)) //delete all breakpoints
|
|
{
|
|
if(!bpgetcount(BPNORMAL))
|
|
{
|
|
dputs("No breakpoints to disable!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
if(!bpenumall(cbDisableAllBreakpoints)) //at least one deletion failed
|
|
return STATUS_ERROR;
|
|
dputs("All breakpoints disabled!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
BREAKPOINT found;
|
|
if(bpget(0, BPNORMAL, arg1, &found)) //found a breakpoint with name
|
|
{
|
|
if(!bpenable(found.addr, BPNORMAL, false) or !DeleteBPX(found.addr))
|
|
{
|
|
dprintf("Could not disable breakpoint "fhex"\n", found.addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
uint addr = 0;
|
|
if(!valfromstring(arg1, &addr) or !bpget(addr, BPNORMAL, 0, &found)) //invalid breakpoint
|
|
{
|
|
dprintf("No such breakpoint \"%s\"\n", arg1);
|
|
return STATUS_ERROR;
|
|
}
|
|
if(!found.enabled)
|
|
{
|
|
dputs("Breakpoint already disabled!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
if(!bpenable(found.addr, BPNORMAL, false) or !DeleteBPX(found.addr))
|
|
{
|
|
dprintf("Could not disable breakpoint "fhex"\n", found.addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
dputs("Breakpoint disabled!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugBplist(int argc, char* argv[])
|
|
{
|
|
bpenumall(cbBreakpointList);
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugStepInto(int argc, char* argv[])
|
|
{
|
|
StepInto((void*)cbStep);
|
|
dbgsetstepping(true);
|
|
return cbDebugRun(argc, argv);
|
|
}
|
|
|
|
CMDRESULT cbDebugeStepInto(int argc, char* argv[])
|
|
{
|
|
dbgsetskipexceptions(true);
|
|
return cbDebugStepInto(argc, argv);
|
|
}
|
|
|
|
CMDRESULT cbDebugStepOver(int argc, char* argv[])
|
|
{
|
|
StepOver((void*)cbStep);
|
|
dbgsetstepping(true);
|
|
return cbDebugRun(argc, argv);
|
|
}
|
|
|
|
CMDRESULT cbDebugeStepOver(int argc, char* argv[])
|
|
{
|
|
dbgsetskipexceptions(true);
|
|
return cbDebugStepOver(argc, argv);
|
|
}
|
|
|
|
CMDRESULT cbDebugSingleStep(int argc, char* argv[])
|
|
{
|
|
char arg1[deflen] = "";
|
|
uint stepcount = 1;
|
|
if(argget(*argv, arg1, 0, true))
|
|
{
|
|
if(!valfromstring(arg1, &stepcount))
|
|
stepcount = 1;
|
|
}
|
|
SingleStep((DWORD)stepcount, (void*)cbStep);
|
|
dbgsetstepping(true);
|
|
return cbDebugRun(argc, argv);
|
|
}
|
|
|
|
CMDRESULT cbDebugeSingleStep(int argc, char* argv[])
|
|
{
|
|
dbgsetskipexceptions(true);
|
|
return cbDebugSingleStep(argc, argv);
|
|
}
|
|
|
|
CMDRESULT cbDebugHide(int argc, char* argv[])
|
|
{
|
|
if(HideDebugger(fdProcessInfo->hProcess, UE_HIDE_PEBONLY))
|
|
dputs("Debugger hidden");
|
|
else
|
|
dputs("Something went wrong");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugDisasm(int argc, char* argv[])
|
|
{
|
|
char arg1[deflen] = "";
|
|
uint addr = GetContextDataEx(hActiveThread, UE_CIP);
|
|
if(argget(*argv, arg1, 0, true))
|
|
if(!valfromstring(arg1, &addr))
|
|
addr = GetContextDataEx(hActiveThread, UE_CIP);
|
|
if(!memisvalidreadptr(fdProcessInfo->hProcess, addr))
|
|
return STATUS_CONTINUE;
|
|
DebugUpdateGui(addr, false);
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugSetMemoryBpx(int argc, char* argv[])
|
|
{
|
|
char arg1[deflen] = ""; //addr
|
|
if(!argget(*argv, arg1, 0, false))
|
|
return STATUS_ERROR;
|
|
uint addr;
|
|
if(!valfromstring(arg1, &addr))
|
|
return STATUS_ERROR;
|
|
bool restore = false;
|
|
char arg2[deflen] = ""; //restore
|
|
char arg3[deflen] = ""; //type
|
|
argget(*argv, arg3, 2, true);
|
|
if(argget(*argv, arg2, 1, true))
|
|
{
|
|
if(*arg2 == '1')
|
|
restore = true;
|
|
else if(*arg2 == '0')
|
|
restore = false;
|
|
else
|
|
strcpy(arg3, arg2);
|
|
}
|
|
DWORD type = UE_MEMORY;
|
|
if(*arg3)
|
|
{
|
|
switch(*arg3)
|
|
{
|
|
case 'r':
|
|
type = UE_MEMORY_READ;
|
|
break;
|
|
case 'w':
|
|
type = UE_MEMORY_WRITE;
|
|
break;
|
|
case 'x':
|
|
type = UE_MEMORY_EXECUTE; //EXECUTE
|
|
break;
|
|
default:
|
|
dputs("Invalid type (argument ignored)");
|
|
break;
|
|
}
|
|
}
|
|
uint size = 0;
|
|
uint base = memfindbaseaddr(addr, &size, true);
|
|
bool singleshoot = false;
|
|
if(!restore)
|
|
singleshoot = true;
|
|
if(bpget(base, BPMEMORY, 0, 0))
|
|
{
|
|
dputs("Hardware breakpoint already set!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
if(!bpnew(base, true, singleshoot, 0, BPMEMORY, type, 0) or !SetMemoryBPXEx(base, size, type, restore, (void*)cbMemoryBreakpoint))
|
|
{
|
|
dputs("Error setting memory breakpoint!");
|
|
return STATUS_ERROR;
|
|
}
|
|
dprintf("Memory breakpoint at "fhex" set!\n", addr);
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugDeleteMemoryBreakpoint(int argc, char* argv[])
|
|
{
|
|
char arg1[deflen] = "";
|
|
if(!argget(*argv, arg1, 0, true)) //delete all breakpoints
|
|
{
|
|
if(!bpgetcount(BPMEMORY))
|
|
{
|
|
dputs("no memory breakpoints to delete!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
if(!bpenumall(cbDeleteAllMemoryBreakpoints)) //at least one deletion failed
|
|
return STATUS_ERROR;
|
|
dputs("All memory breakpoints deleted!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
BREAKPOINT found;
|
|
if(bpget(0, BPMEMORY, arg1, &found)) //found a breakpoint with name
|
|
{
|
|
uint size;
|
|
memfindbaseaddr(found.addr, &size);
|
|
if(!bpdel(found.addr, BPMEMORY) or !RemoveMemoryBPX(found.addr, size))
|
|
{
|
|
dprintf("Delete memory breakpoint failed: "fhex"\n", found.addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
return STATUS_CONTINUE;
|
|
}
|
|
uint addr = 0;
|
|
if(!valfromstring(arg1, &addr) or !bpget(addr, BPMEMORY, 0, &found)) //invalid breakpoint
|
|
{
|
|
dprintf("No such memory breakpoint \"%s\"\n", arg1);
|
|
return STATUS_ERROR;
|
|
}
|
|
uint size;
|
|
memfindbaseaddr(found.addr, &size);
|
|
if(!bpdel(found.addr, BPMEMORY) or !RemoveMemoryBPX(found.addr, size))
|
|
{
|
|
dprintf("Delete memory breakpoint failed: "fhex"\n", found.addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
dputs("Memory breakpoint deleted!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugRtr(int argc, char* argv[])
|
|
{
|
|
StepOver((void*)cbRtrStep);
|
|
cbDebugRun(argc, argv);
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugeRtr(int argc, char* argv[])
|
|
{
|
|
dbgsetskipexceptions(true);
|
|
return cbDebugRtr(argc, argv);
|
|
}
|
|
|
|
CMDRESULT cbDebugSetHardwareBreakpoint(int argc, char* argv[])
|
|
{
|
|
char arg1[deflen] = ""; //addr
|
|
if(!argget(*argv, arg1, 0, false))
|
|
return STATUS_ERROR;
|
|
uint addr;
|
|
if(!valfromstring(arg1, &addr))
|
|
return STATUS_ERROR;
|
|
DWORD type = UE_HARDWARE_EXECUTE;
|
|
char arg2[deflen] = ""; //type
|
|
if(argget(*argv, arg2, 1, true))
|
|
{
|
|
switch(*arg2)
|
|
{
|
|
case 'r':
|
|
type = UE_HARDWARE_READWRITE;
|
|
break;
|
|
case 'w':
|
|
type = UE_HARDWARE_WRITE;
|
|
break;
|
|
case 'x':
|
|
break;
|
|
default:
|
|
dputs("invalid type, assuming 'x'");
|
|
break;
|
|
}
|
|
}
|
|
char arg3[deflen] = ""; //size
|
|
DWORD titsize;
|
|
if(argget(*argv, arg3, 2, true))
|
|
{
|
|
uint size;
|
|
if(!valfromstring(arg3, &size))
|
|
return STATUS_ERROR;
|
|
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("Invalid size, using 1");
|
|
break;
|
|
}
|
|
if((addr % size) != 0)
|
|
{
|
|
dprintf("Address not aligned to %d\n", size);
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
DWORD drx = 0;
|
|
if(!GetUnusedHardwareBreakPointRegister(&drx))
|
|
{
|
|
dputs("You can only set 4 hardware breakpoints");
|
|
return STATUS_ERROR;
|
|
}
|
|
int titantype = 0;
|
|
TITANSETDRX(titantype, drx);
|
|
TITANSETTYPE(titantype, type);
|
|
TITANSETSIZE(titantype, titsize);
|
|
//TODO: hwbp in multiple threads TEST
|
|
if(bpget(addr, BPHARDWARE, 0, 0))
|
|
{
|
|
dputs("Hardware breakpoint already set!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
if(!bpnew(addr, true, false, 0, BPHARDWARE, titantype, 0))
|
|
{
|
|
dputs("error setting hardware breakpoint (bpnew)!");
|
|
return STATUS_ERROR;
|
|
}
|
|
if(!SetHardwareBreakPoint(addr, drx, type, titsize, (void*)cbHardwareBreakpoint))
|
|
{
|
|
dputs("error setting hardware breakpoint (TitanEngine)!");
|
|
return STATUS_ERROR;
|
|
}
|
|
dprintf("Hardware breakpoint at "fhex" set!\n", addr);
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugDeleteHardwareBreakpoint(int argc, char* argv[])
|
|
{
|
|
char arg1[deflen] = "";
|
|
if(!argget(*argv, arg1, 0, true)) //delete all breakpoints
|
|
{
|
|
if(!bpgetcount(BPHARDWARE))
|
|
{
|
|
dputs("No hardware breakpoints to delete!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
if(!bpenumall(cbDeleteAllHardwareBreakpoints)) //at least one deletion failed
|
|
return STATUS_ERROR;
|
|
dputs("All hardware breakpoints deleted!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
BREAKPOINT found;
|
|
if(bpget(0, BPHARDWARE, arg1, &found)) //found a breakpoint with name
|
|
{
|
|
if(!bpdel(found.addr, BPHARDWARE) or !DeleteHardwareBreakPoint(TITANGETDRX(found.titantype)))
|
|
{
|
|
dprintf("Delete hardware breakpoint failed: "fhex"\n", found.addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
return STATUS_CONTINUE;
|
|
}
|
|
uint addr = 0;
|
|
if(!valfromstring(arg1, &addr) or !bpget(addr, BPHARDWARE, 0, &found)) //invalid breakpoint
|
|
{
|
|
dprintf("No such hardware breakpoint \"%s\"\n", arg1);
|
|
return STATUS_ERROR;
|
|
}
|
|
if(!bpdel(found.addr, BPHARDWARE) or !DeleteHardwareBreakPoint(TITANGETDRX(found.titantype)))
|
|
{
|
|
dprintf("Delete hardware breakpoint failed: "fhex"\n", found.addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
dputs("Hardware breakpoint deleted!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugAlloc(int argc, char* argv[])
|
|
{
|
|
char arg1[deflen] = ""; //size
|
|
uint size = 0x1000;
|
|
if(argget(*argv, arg1, 0, true))
|
|
if(!valfromstring(arg1, &size, false))
|
|
return STATUS_ERROR;
|
|
uint mem = (uint)memalloc(fdProcessInfo->hProcess, 0, size, PAGE_EXECUTE_READWRITE);
|
|
if(!mem)
|
|
dputs("VirtualAllocEx failed");
|
|
else
|
|
dprintf(fhex"\n", mem);
|
|
if(mem)
|
|
varset("$lastalloc", mem, true);
|
|
dbggetprivateusage(fdProcessInfo->hProcess, true);
|
|
memupdatemap(fdProcessInfo->hProcess);
|
|
GuiUpdateMemoryView();
|
|
varset("$res", mem, false);
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugFree(int argc, char* argv[])
|
|
{
|
|
uint lastalloc;
|
|
varget("$lastalloc", &lastalloc, 0, 0);
|
|
char arg1[deflen] = ""; //addr
|
|
uint addr = lastalloc;
|
|
if(argget(*argv, arg1, 0, true))
|
|
{
|
|
if(!valfromstring(arg1, &addr, false))
|
|
return STATUS_ERROR;
|
|
}
|
|
else if(!lastalloc)
|
|
{
|
|
dputs("$lastalloc is zero, provide a page address");
|
|
return STATUS_ERROR;
|
|
}
|
|
if(addr == lastalloc)
|
|
varset("$lastalloc", (uint)0, true);
|
|
bool ok = !!VirtualFreeEx(fdProcessInfo->hProcess, (void*)addr, 0, MEM_RELEASE);
|
|
if(!ok)
|
|
dputs("VirtualFreeEx failed");
|
|
dbggetprivateusage(fdProcessInfo->hProcess, true);
|
|
memupdatemap(fdProcessInfo->hProcess);
|
|
GuiUpdateMemoryView();
|
|
varset("$res", ok, false);
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugMemset(int argc, char* argv[])
|
|
{
|
|
char arg3[deflen] = ""; //size
|
|
uint addr;
|
|
uint value;
|
|
uint size;
|
|
if(argc < 3)
|
|
{
|
|
dputs("Not enough arguments");
|
|
return STATUS_ERROR;
|
|
}
|
|
if(!valfromstring(argv[1], &addr, false) or !valfromstring(argv[2], &value, false))
|
|
return STATUS_ERROR;
|
|
if(argget(*argv, arg3, 2, true))
|
|
{
|
|
if(!valfromstring(arg3, &size, false))
|
|
return STATUS_ERROR;
|
|
}
|
|
else
|
|
{
|
|
uint base = memfindbaseaddr(addr, &size, true);
|
|
if(!base)
|
|
{
|
|
dputs("invalid address specified");
|
|
return STATUS_ERROR;
|
|
}
|
|
uint diff = addr - base;
|
|
addr = base + diff;
|
|
size -= diff;
|
|
}
|
|
BYTE fi = value & 0xFF;
|
|
if(!Fill((void*)addr, size & 0xFFFFFFFF, &fi))
|
|
dputs("Memset failed");
|
|
else
|
|
dprintf("Memory "fhex" (size: %.8X) set to %.2X\n", addr, size & 0xFFFFFFFF, value & 0xFF);
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugBenchmark(int argc, char* argv[])
|
|
{
|
|
uint addr = memfindbaseaddr(GetContextDataEx(hActiveThread, UE_CIP), 0);
|
|
DWORD ticks = GetTickCount();
|
|
char comment[MAX_COMMENT_SIZE] = "";
|
|
for(uint i = addr; i < addr + 100000; i++)
|
|
{
|
|
commentset(i, "test", false);
|
|
labelset(i, "test", false);
|
|
bookmarkset(i, false);
|
|
functionadd(i, i, false);
|
|
}
|
|
dprintf("%ums\n", GetTickCount() - ticks);
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugPause(int argc, char* argv[])
|
|
{
|
|
if(waitislocked(WAITID_RUN))
|
|
{
|
|
dputs("Program is not running");
|
|
return STATUS_ERROR;
|
|
}
|
|
dbgsetispausedbyuser(true);
|
|
DebugBreakProcess(fdProcessInfo->hProcess);
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
static DWORD WINAPI scyllaThread(void* lpParam)
|
|
{
|
|
typedef INT (WINAPI * SCYLLASTARTGUI)(DWORD pid, HINSTANCE mod);
|
|
SCYLLASTARTGUI ScyllaStartGui = 0;
|
|
HINSTANCE hScylla = LoadLibraryW(L"Scylla.dll");
|
|
if(!hScylla)
|
|
{
|
|
dputs("Error loading Scylla.dll!");
|
|
bScyllaLoaded = false;
|
|
FreeLibrary(hScylla);
|
|
return 0;
|
|
}
|
|
ScyllaStartGui = (SCYLLASTARTGUI)GetProcAddress(hScylla, "ScyllaStartGui");
|
|
if(!ScyllaStartGui)
|
|
{
|
|
dputs("Could not find export 'ScyllaStartGui' inside Scylla.dll");
|
|
bScyllaLoaded = false;
|
|
FreeLibrary(hScylla);
|
|
return 0;
|
|
}
|
|
if(dbgisdll())
|
|
ScyllaStartGui(fdProcessInfo->dwProcessId, (HINSTANCE)dbgdebuggedbase());
|
|
else
|
|
ScyllaStartGui(fdProcessInfo->dwProcessId, 0);
|
|
FreeLibrary(hScylla);
|
|
bScyllaLoaded = false;
|
|
return 0;
|
|
}
|
|
|
|
CMDRESULT cbDebugStartScylla(int argc, char* argv[])
|
|
{
|
|
if(bScyllaLoaded)
|
|
{
|
|
dputs("Scylla is already loaded");
|
|
return STATUS_ERROR;
|
|
}
|
|
bScyllaLoaded = true;
|
|
CloseHandle(CreateThread(0, 0, scyllaThread, 0, 0, 0));
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugAttach(int argc, char* argv[])
|
|
{
|
|
if(argc < 2)
|
|
{
|
|
dputs("Not enough arguments!");
|
|
return STATUS_ERROR;
|
|
}
|
|
uint pid = 0;
|
|
if(!valfromstring(argv[1], &pid, false))
|
|
return STATUS_ERROR;
|
|
if(argc > 2)
|
|
{
|
|
uint eventHandle = 0;
|
|
if(!valfromstring(argv[2], &eventHandle, false))
|
|
return STATUS_ERROR;
|
|
dbgsetattachevent((HANDLE)eventHandle);
|
|
}
|
|
if(DbgIsDebugging())
|
|
DbgCmdExecDirect("stop");
|
|
Handle hProcess = TitanOpenProcess(PROCESS_ALL_ACCESS, false, (DWORD)pid);
|
|
if(!hProcess)
|
|
{
|
|
dprintf("Could not open process %X!\n", pid);
|
|
return STATUS_ERROR;
|
|
}
|
|
BOOL wow64 = false, mewow64 = false;
|
|
if(!IsWow64Process(hProcess, &wow64) or !IsWow64Process(GetCurrentProcess(), &mewow64))
|
|
{
|
|
dputs("IsWow64Process failed!");
|
|
return STATUS_ERROR;
|
|
}
|
|
if((mewow64 and !wow64) or (!mewow64 and wow64))
|
|
{
|
|
#ifdef _WIN64
|
|
dputs("Use x32_dbg to debug this process!");
|
|
#else
|
|
dputs("Use x64_dbg to debug this process!");
|
|
#endif // _WIN64
|
|
return STATUS_ERROR;
|
|
}
|
|
wchar_t wszFileName[MAX_PATH] = L"";
|
|
if(!GetModuleFileNameExW(hProcess, 0, wszFileName, MAX_PATH))
|
|
{
|
|
dprintf("Could not get module filename %X!\n", pid);
|
|
return STATUS_ERROR;
|
|
}
|
|
strcpy_s(szFileName, StringUtils::Utf16ToUtf8(wszFileName).c_str());
|
|
CloseHandle(CreateThread(0, 0, threadAttachLoop, (void*)pid, 0, 0));
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugDetach(int argc, char* argv[])
|
|
{
|
|
unlock(WAITID_RUN); //run
|
|
dbgsetisdetachedbyuser(true); //detach when paused
|
|
StepInto((void*)cbDetach);
|
|
DebugBreakProcess(fdProcessInfo->hProcess);
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugDump(int argc, char* argv[])
|
|
{
|
|
if(argc < 2)
|
|
{
|
|
dputs("not enough arguments!");
|
|
return STATUS_ERROR;
|
|
}
|
|
duint addr = 0;
|
|
if(!valfromstring(argv[1], &addr))
|
|
{
|
|
dprintf("Invalid address \"%s\"!\n", argv[1]);
|
|
return STATUS_ERROR;
|
|
}
|
|
GuiDumpAt(addr);
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugStackDump(int argc, char* argv[])
|
|
{
|
|
duint addr = 0;
|
|
if(argc < 2)
|
|
addr = GetContextDataEx(hActiveThread, UE_CSP);
|
|
else if(!valfromstring(argv[1], &addr))
|
|
{
|
|
dprintf("Invalid address \"%s\"!\n", argv[1]);
|
|
return STATUS_ERROR;
|
|
}
|
|
duint csp = GetContextDataEx(hActiveThread, UE_CSP);
|
|
duint size = 0;
|
|
duint base = memfindbaseaddr(csp, &size);
|
|
if(base && addr >= base && addr < (base + size))
|
|
GuiStackDumpAt(addr, csp);
|
|
else
|
|
dputs("Invalid stack address!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugContinue(int argc, char* argv[])
|
|
{
|
|
if(argc < 2)
|
|
{
|
|
SetNextDbgContinueStatus(DBG_CONTINUE);
|
|
dputs("Exception will be swallowed");
|
|
}
|
|
else
|
|
{
|
|
SetNextDbgContinueStatus(DBG_EXCEPTION_NOT_HANDLED);
|
|
dputs("Exception will be thrown in the program");
|
|
}
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugBpDll(int argc, char* argv[])
|
|
{
|
|
if(argc < 2)
|
|
{
|
|
dputs("not enough arguments!");
|
|
return STATUS_ERROR;
|
|
}
|
|
DWORD type = UE_ON_LIB_ALL;
|
|
if(argc > 2)
|
|
{
|
|
switch(*argv[2])
|
|
{
|
|
case 'l':
|
|
type = UE_ON_LIB_LOAD;
|
|
break;
|
|
case 'u':
|
|
type = UE_ON_LIB_UNLOAD;
|
|
break;
|
|
}
|
|
}
|
|
bool singleshoot = true;
|
|
if(argc > 3)
|
|
singleshoot = false;
|
|
LibrarianSetBreakPoint(argv[1], type, singleshoot, (void*)cbLibrarianBreakpoint);
|
|
dprintf("Dll breakpoint set on \"%s\"!\n", argv[1]);
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugBcDll(int argc, char* argv[])
|
|
{
|
|
if(argc < 2)
|
|
{
|
|
dputs("Not enough arguments");
|
|
return STATUS_ERROR;
|
|
}
|
|
if(!LibrarianRemoveBreakPoint(argv[1], UE_ON_LIB_ALL))
|
|
{
|
|
dputs("Failed to remove DLL breakpoint...");
|
|
return STATUS_ERROR;
|
|
}
|
|
dputs("DLL breakpoint removed!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugSwitchthread(int argc, char* argv[])
|
|
{
|
|
uint threadid = fdProcessInfo->dwThreadId; //main thread
|
|
if(argc > 1)
|
|
if(!valfromstring(argv[1], &threadid, false))
|
|
return STATUS_ERROR;
|
|
if(!threadisvalid((DWORD)threadid)) //check if the thread is valid
|
|
{
|
|
dprintf("Invalid thread %X\n", threadid);
|
|
return STATUS_ERROR;
|
|
}
|
|
//switch thread
|
|
hActiveThread = threadgethandle((DWORD)threadid);
|
|
DebugUpdateGui(GetContextDataEx(hActiveThread, UE_CIP), true);
|
|
dputs("Thread switched!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugSuspendthread(int argc, char* argv[])
|
|
{
|
|
uint threadid = fdProcessInfo->dwThreadId;
|
|
if(argc > 1)
|
|
if(!valfromstring(argv[1], &threadid, false))
|
|
return STATUS_ERROR;
|
|
if(!threadisvalid((DWORD)threadid)) //check if the thread is valid
|
|
{
|
|
dprintf("Invalid thread %X\n", threadid);
|
|
return STATUS_ERROR;
|
|
}
|
|
//suspend thread
|
|
if(SuspendThread(threadgethandle((DWORD)threadid)) == -1)
|
|
{
|
|
dputs("Error suspending thread");
|
|
return STATUS_ERROR;
|
|
}
|
|
dputs("Thread suspended");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugResumethread(int argc, char* argv[])
|
|
{
|
|
uint threadid = fdProcessInfo->dwThreadId;
|
|
if(argc > 1)
|
|
if(!valfromstring(argv[1], &threadid, false))
|
|
return STATUS_ERROR;
|
|
if(!threadisvalid((DWORD)threadid)) //check if the thread is valid
|
|
{
|
|
dprintf("Invalid thread %X\n", threadid);
|
|
return STATUS_ERROR;
|
|
}
|
|
//resume thread
|
|
if(ResumeThread(threadgethandle((DWORD)threadid)) == -1)
|
|
{
|
|
dputs("Error resuming thread");
|
|
return STATUS_ERROR;
|
|
}
|
|
dputs("Thread resumed!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugKillthread(int argc, char* argv[])
|
|
{
|
|
uint threadid = fdProcessInfo->dwThreadId;
|
|
if(argc > 1)
|
|
if(!valfromstring(argv[1], &threadid, false))
|
|
return STATUS_ERROR;
|
|
uint exitcode = 0;
|
|
if(argc > 2)
|
|
if(!valfromstring(argv[2], &exitcode, false))
|
|
return STATUS_ERROR;
|
|
if(!threadisvalid((DWORD)threadid)) //check if the thread is valid
|
|
{
|
|
dprintf("Invalid thread %X\n", threadid);
|
|
return STATUS_ERROR;
|
|
}
|
|
//terminate thread
|
|
if(TerminateThread(threadgethandle((DWORD)threadid), (DWORD)exitcode) != 0)
|
|
{
|
|
GuiUpdateAllViews();
|
|
dputs("Thread terminated");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
dputs("Error terminating thread!");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
CMDRESULT cbDebugSuspendAllThreads(int argc, char* argv[])
|
|
{
|
|
int threadCount = threadgetcount();
|
|
int suspendedCount = threadsuspendall();
|
|
dprintf("%d/%d thread(s) suspended\n", suspendedCount, threadCount);
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugResumeAllThreads(int argc, char* argv[])
|
|
{
|
|
int threadCount = threadgetcount();
|
|
int resumeCount = threadresumeall();
|
|
dprintf("%d/%d thread(s) resumed\n", resumeCount, threadCount);
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugSetPriority(int argc, char* argv[])
|
|
{
|
|
if(argc < 3)
|
|
{
|
|
dputs("Not enough arguments!");
|
|
return STATUS_ERROR;
|
|
}
|
|
uint threadid;
|
|
if(!valfromstring(argv[1], &threadid, false))
|
|
return STATUS_ERROR;
|
|
uint 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("Unknown priority value, read the help!");
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch(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("Unknown priority value, read the help!");
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
if(!threadisvalid((DWORD)threadid)) //check if the thread is valid
|
|
{
|
|
dprintf("Invalid thread %X\n", threadid);
|
|
return STATUS_ERROR;
|
|
}
|
|
//set thread priority
|
|
if(SetThreadPriority(threadgethandle((DWORD)threadid), (int)priority) == 0)
|
|
{
|
|
dputs("Error setting thread priority");
|
|
return STATUS_ERROR;
|
|
}
|
|
dputs("Thread priority changed!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugEnableHardwareBreakpoint(int argc, char* argv[])
|
|
{
|
|
char arg1[deflen] = "";
|
|
DWORD drx = 0;
|
|
if(!GetUnusedHardwareBreakPointRegister(&drx))
|
|
{
|
|
dputs("You can only set 4 hardware breakpoints");
|
|
return STATUS_ERROR;
|
|
}
|
|
if(!argget(*argv, arg1, 0, true)) //enable all hardware breakpoints
|
|
{
|
|
if(!bpgetcount(BPHARDWARE))
|
|
{
|
|
dputs("No hardware breakpoints to enable!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
if(!bpenumall(cbEnableAllHardwareBreakpoints)) //at least one enable failed
|
|
return STATUS_ERROR;
|
|
dputs("All hardware breakpoints enabled!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
BREAKPOINT found;
|
|
uint addr = 0;
|
|
if(!valfromstring(arg1, &addr) or !bpget(addr, BPHARDWARE, 0, &found)) //invalid hardware breakpoint
|
|
{
|
|
dprintf("No such hardware breakpoint \"%s\"\n", arg1);
|
|
return STATUS_ERROR;
|
|
}
|
|
if(found.enabled)
|
|
{
|
|
dputs("Hardware breakpoint already enabled!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
TITANSETDRX(found.titantype, drx);
|
|
bpsettitantype(found.addr, BPHARDWARE, found.titantype);
|
|
if(!bpenable(found.addr, BPHARDWARE, true) or !SetHardwareBreakPoint(found.addr, drx, TITANGETTYPE(found.titantype), TITANGETSIZE(found.titantype), (void*)cbHardwareBreakpoint))
|
|
{
|
|
dprintf("Could not enable hardware breakpoint "fhex"\n", found.addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
dputs("Hardware breakpoint enabled!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugDisableHardwareBreakpoint(int argc, char* argv[])
|
|
{
|
|
char arg1[deflen] = "";
|
|
if(!argget(*argv, arg1, 0, true)) //delete all hardware breakpoints
|
|
{
|
|
if(!bpgetcount(BPHARDWARE))
|
|
{
|
|
dputs("No hardware breakpoints to disable!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
if(!bpenumall(cbDisableAllHardwareBreakpoints)) //at least one deletion failed
|
|
return STATUS_ERROR;
|
|
dputs("All hardware breakpoints disabled!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
BREAKPOINT found;
|
|
uint addr = 0;
|
|
if(!valfromstring(arg1, &addr) or !bpget(addr, BPHARDWARE, 0, &found)) //invalid hardware breakpoint
|
|
{
|
|
dprintf("No such hardware breakpoint \"%s\"\n", arg1);
|
|
return STATUS_ERROR;
|
|
}
|
|
if(!found.enabled)
|
|
{
|
|
dputs("Hardware breakpoint already disabled!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
if(!bpenable(found.addr, BPHARDWARE, false) or !DeleteHardwareBreakPoint(TITANGETDRX(found.titantype)))
|
|
{
|
|
dprintf("Could not disable hardware breakpoint "fhex"\n", found.addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
dputs("Hardware breakpoint disabled!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugEnableMemoryBreakpoint(int argc, char* argv[])
|
|
{
|
|
char arg1[deflen] = "";
|
|
DWORD drx = 0;
|
|
if(!GetUnusedHardwareBreakPointRegister(0))
|
|
{
|
|
dputs("You can only set 4 hardware breakpoints");
|
|
return STATUS_ERROR;
|
|
}
|
|
if(!argget(*argv, arg1, 0, true)) //enable all memory breakpoints
|
|
{
|
|
if(!bpgetcount(BPMEMORY))
|
|
{
|
|
dputs("No hardware breakpoints to enable!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
if(!bpenumall(cbEnableAllHardwareBreakpoints)) //at least one enable failed
|
|
return STATUS_ERROR;
|
|
dputs("All memory breakpoints enabled!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
BREAKPOINT found;
|
|
uint addr = 0;
|
|
if(!valfromstring(arg1, &addr) or !bpget(addr, BPMEMORY, 0, &found)) //invalid memory breakpoint
|
|
{
|
|
dprintf("No such memory breakpoint \"%s\"\n", arg1);
|
|
return STATUS_ERROR;
|
|
}
|
|
if(found.enabled)
|
|
{
|
|
dputs("Hardware memory already enabled!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
uint size = 0;
|
|
memfindbaseaddr(found.addr, &size);
|
|
if(!bpenable(found.addr, BPMEMORY, true) or !SetMemoryBPXEx(found.addr, size, found.titantype, !found.singleshoot, (void*)cbMemoryBreakpoint))
|
|
{
|
|
dprintf("Could not enable memory breakpoint "fhex"\n", found.addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
dputs("Memory breakpoint enabled!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugDisableMemoryBreakpoint(int argc, char* argv[])
|
|
{
|
|
char arg1[deflen] = "";
|
|
if(!argget(*argv, arg1, 0, true)) //delete all memory breakpoints
|
|
{
|
|
if(!bpgetcount(BPMEMORY))
|
|
{
|
|
dputs("No memory breakpoints to disable!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
if(!bpenumall(cbDisableAllMemoryBreakpoints)) //at least one deletion failed
|
|
return STATUS_ERROR;
|
|
dputs("All memory breakpoints disabled!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
BREAKPOINT found;
|
|
uint addr = 0;
|
|
if(!valfromstring(arg1, &addr) or !bpget(addr, BPMEMORY, 0, &found)) //invalid memory breakpoint
|
|
{
|
|
dprintf("No such memory breakpoint \"%s\"\n", arg1);
|
|
return STATUS_ERROR;
|
|
}
|
|
if(!found.enabled)
|
|
{
|
|
dputs("Memory breakpoint already disabled!");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
uint size = 0;
|
|
memfindbaseaddr(found.addr, &size);
|
|
if(!bpenable(found.addr, BPMEMORY, false) or !RemoveMemoryBPX(found.addr, size))
|
|
{
|
|
dprintf("Could not disable memory breakpoint "fhex"\n", found.addr);
|
|
return STATUS_ERROR;
|
|
}
|
|
dputs("Memory breakpoint disabled!");
|
|
GuiUpdateAllViews();
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugDownloadSymbol(int argc, char* argv[])
|
|
{
|
|
char szDefaultStore[MAX_SETTING_SIZE] = "";
|
|
const char* szSymbolStore = szDefaultStore;
|
|
if(!BridgeSettingGet("Symbols", "DefaultStore", szDefaultStore)) //get default symbol store from settings
|
|
{
|
|
strcpy(szDefaultStore, "http://msdl.microsoft.com/download/symbols");
|
|
BridgeSettingSet("Symbols", "DefaultStore", szDefaultStore);
|
|
}
|
|
if(argc < 2) //no arguments
|
|
{
|
|
symdownloadallsymbols(szSymbolStore); //download symbols for all modules
|
|
GuiSymbolRefreshCurrent();
|
|
dputs("Done! See symbol log for more information");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
//get some module information
|
|
uint modbase = modbasefromname(argv[1]);
|
|
if(!modbase)
|
|
{
|
|
dprintf("Invalid module \"%s\"!\n", argv[1]);
|
|
return STATUS_ERROR;
|
|
}
|
|
wchar_t wszModulePath[MAX_PATH] = L"";
|
|
if(!GetModuleFileNameExW(fdProcessInfo->hProcess, (HMODULE)modbase, wszModulePath, MAX_PATH))
|
|
{
|
|
dputs("GetModuleFileNameExA failed!");
|
|
return STATUS_ERROR;
|
|
}
|
|
char szModulePath[MAX_PATH] = "";
|
|
strcpy_s(szModulePath, StringUtils::Utf16ToUtf8(wszModulePath).c_str());
|
|
char szOldSearchPath[MAX_PATH] = "";
|
|
if(!SymGetSearchPath(fdProcessInfo->hProcess, szOldSearchPath, MAX_PATH)) //backup current search path
|
|
{
|
|
dputs("SymGetSearchPath failed!");
|
|
return STATUS_ERROR;
|
|
}
|
|
char szServerSearchPath[MAX_PATH * 2] = "";
|
|
if(argc > 2)
|
|
szSymbolStore = argv[2];
|
|
sprintf_s(szServerSearchPath, "SRV*%s*%s", szSymbolCachePath, szSymbolStore);
|
|
if(!SymSetSearchPath(fdProcessInfo->hProcess, szServerSearchPath)) //set new search path
|
|
{
|
|
dputs("SymSetSearchPath (1) failed!");
|
|
return STATUS_ERROR;
|
|
}
|
|
if(!SymUnloadModule64(fdProcessInfo->hProcess, (DWORD64)modbase)) //unload module
|
|
{
|
|
SymSetSearchPath(fdProcessInfo->hProcess, szOldSearchPath);
|
|
dputs("SymUnloadModule64 failed!");
|
|
return STATUS_ERROR;
|
|
}
|
|
if(!SymLoadModuleEx(fdProcessInfo->hProcess, 0, szModulePath, 0, (DWORD64)modbase, 0, 0, 0)) //load module
|
|
{
|
|
dputs("SymLoadModuleEx failed!");
|
|
SymSetSearchPath(fdProcessInfo->hProcess, szOldSearchPath);
|
|
return STATUS_ERROR;
|
|
}
|
|
if(!SymSetSearchPath(fdProcessInfo->hProcess, szOldSearchPath))
|
|
{
|
|
dputs("SymSetSearchPath (2) failed!");
|
|
return STATUS_ERROR;
|
|
}
|
|
GuiSymbolRefreshCurrent();
|
|
dputs("Done! See symbol log for more information");
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugGetJITAuto(int argc, char* argv[])
|
|
{
|
|
bool jit_auto = false;
|
|
arch actual_arch = invalid;
|
|
|
|
if(argc == 1)
|
|
{
|
|
if(!dbggetjitauto(&jit_auto, notfound, & actual_arch, NULL))
|
|
{
|
|
dprintf("Error getting JIT auto %s\n", (actual_arch == x64) ? "x64" : "x32");
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
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("Unknown JIT auto entry type. Use x64 or x32 as parameter.");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
if(!dbggetjitauto(& jit_auto, actual_arch, NULL, & rw_error))
|
|
{
|
|
if(rw_error == ERROR_RW_NOTWOW64)
|
|
dprintf("Error using x64 arg the debugger is not a WOW64 process\n");
|
|
else
|
|
dprintf("Error getting JIT auto %s\n", argv[1]);
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dputs("Unknown JIT auto entry type. Use x64 or x32 as parameter");
|
|
}
|
|
|
|
dprintf("JIT auto %s: %s\n", (actual_arch == x64) ? "x64" : "x32", jit_auto ? "ON" : "OFF");
|
|
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugSetJITAuto(int argc, char* argv[])
|
|
{
|
|
arch actual_arch;
|
|
bool set_jit_auto;
|
|
if(!IsProcessElevated())
|
|
{
|
|
dprintf("Error run the debugger as Admin to setjitauto\n");
|
|
return STATUS_ERROR;
|
|
}
|
|
if(argc < 2)
|
|
{
|
|
dprintf("Error setting JIT Auto. Use ON:1 or OFF:0 arg or x64/x32, ON:1 or OFF:0.\n");
|
|
return STATUS_ERROR;
|
|
}
|
|
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("Error unknown parameters. Use ON:1 or OFF:0");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
if(!dbgsetjitauto(set_jit_auto, notfound, & actual_arch, NULL))
|
|
{
|
|
dprintf("Error setting JIT auto %s\n", (actual_arch == x64) ? "x64" : "x32");
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
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("Unknown JIT auto entry type. Use x64 or x32 as parameter");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
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
|
|
{
|
|
return STATUS_ERROR;
|
|
dputs("Error unknown parameters. Use x86 or x64 and ON:1 or OFF:0\n");
|
|
}
|
|
|
|
if(!dbgsetjitauto(set_jit_auto, actual_arch, NULL, & rw_error))
|
|
{
|
|
if(rw_error == ERROR_RW_NOTWOW64)
|
|
dprintf("Error using x64 arg the debugger is not a WOW64 process\n");
|
|
else
|
|
|
|
dprintf("Error getting JIT auto %s\n", (actual_arch == x64) ? "x64" : "x32");
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dputs("Error unknown parameters use x86 or x64, ON/1 or OFF/0\n");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
dprintf("New JIT auto %s: %s\n", (actual_arch == x64) ? "x64" : "x32", set_jit_auto ? "ON" : "OFF");
|
|
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugSetJIT(int argc, char* argv[])
|
|
{
|
|
arch actual_arch = invalid;
|
|
char* jit_debugger_cmd = "";
|
|
char oldjit[MAX_SETTING_SIZE] = "";
|
|
char path[JIT_ENTRY_DEF_SIZE];
|
|
if(!IsProcessElevated())
|
|
{
|
|
dprintf("Error run the debugger as Admin to setjit\n");
|
|
return STATUS_ERROR;
|
|
}
|
|
if(argc < 2)
|
|
{
|
|
dbggetdefjit(path);
|
|
|
|
jit_debugger_cmd = path;
|
|
if(!dbgsetjit(jit_debugger_cmd, notfound, & actual_arch, NULL))
|
|
{
|
|
dprintf("Error setting JIT %s\n", (actual_arch == x64) ? "x64" : "x32");
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
else if(argc == 2)
|
|
{
|
|
if(!_strcmpi(argv[1], "old"))
|
|
{
|
|
jit_debugger_cmd = oldjit;
|
|
if(!BridgeSettingGet("JIT", "Old", jit_debugger_cmd))
|
|
{
|
|
dputs("Error there is no old JIT entry stored.");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
if(!dbgsetjit(jit_debugger_cmd, notfound, & actual_arch, NULL))
|
|
{
|
|
dprintf("Error setting JIT %s\n", (actual_arch == x64) ? "x64" : "x32");
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
else if(!_strcmpi(argv[1], "oldsave"))
|
|
{
|
|
char path[JIT_ENTRY_DEF_SIZE];
|
|
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, get_entry);
|
|
|
|
jit_debugger_cmd = path;
|
|
if(!dbgsetjit(jit_debugger_cmd, notfound, & actual_arch, NULL))
|
|
{
|
|
dprintf("Error setting JIT %s\n", (actual_arch == x64) ? "x64" : "x32");
|
|
return STATUS_ERROR;
|
|
}
|
|
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", jit_debugger_cmd))
|
|
{
|
|
dputs("Error there is no old JIT entry stored.");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
if(!dbgsetjit(jit_debugger_cmd, notfound, & actual_arch, NULL))
|
|
{
|
|
dprintf("Error setting JIT %s\n", (actual_arch == x64) ? "x64" : "x32");
|
|
return STATUS_ERROR;
|
|
}
|
|
BridgeSettingSet("JIT", 0, 0);
|
|
}
|
|
else
|
|
{
|
|
jit_debugger_cmd = argv[1];
|
|
if(!dbgsetjit(jit_debugger_cmd, notfound, & actual_arch, NULL))
|
|
{
|
|
dprintf("Error setting JIT %s\n", (actual_arch == x64) ? "x64" : "x32");
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
}
|
|
else if(argc == 3)
|
|
{
|
|
readwritejitkey_error_t rw_error;
|
|
|
|
if(!_strcmpi(argv[1], "old"))
|
|
{
|
|
BridgeSettingSet("JIT", "Old", argv[2]);
|
|
|
|
dprintf("New OLD JIT stored: %s\n", argv[2]);
|
|
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
else if(_strcmpi(argv[1], "x64") == 0)
|
|
actual_arch = x64;
|
|
else if(_strcmpi(argv[1], "x32") == 0)
|
|
actual_arch = x32;
|
|
else
|
|
{
|
|
dputs("Unknown JIT entry type. Use OLD, x64 or x32 as parameter.");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
jit_debugger_cmd = argv[2];
|
|
if(!dbgsetjit(jit_debugger_cmd, actual_arch, NULL, & rw_error))
|
|
{
|
|
if(rw_error == ERROR_RW_NOTWOW64)
|
|
dprintf("Error using x64 arg. The debugger is not a WOW64 process\n");
|
|
else
|
|
dprintf("Error setting JIT %s\n", (actual_arch == x64) ? "x64" : "x32");
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dputs("Error unknown parameters. Use old, oldsave, restore, x86 or x64 as parameter.");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
dprintf("New JIT %s: %s\n", (actual_arch == x64) ? "x64" : "x32", jit_debugger_cmd);
|
|
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT 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("Error getting JIT %s\n", (actual_arch == x64) ? "x64" : "x32");
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
readwritejitkey_error_t rw_error;
|
|
char oldjit[MAX_SETTING_SIZE] = "";
|
|
if(_strcmpi(argv[1], "OLD") == 0)
|
|
{
|
|
if(!BridgeSettingGet("JIT", "Old", (char*) & oldjit))
|
|
{
|
|
dputs("Error: there is not an OLD JIT entry stored yet.");
|
|
return STATUS_ERROR;
|
|
}
|
|
else
|
|
{
|
|
dprintf("OLD JIT entry stored: %s\n", oldjit);
|
|
return STATUS_CONTINUE;
|
|
}
|
|
}
|
|
else if(_strcmpi(argv[1], "x64") == 0)
|
|
actual_arch = x64;
|
|
else if(_strcmpi(argv[1], "x32") == 0)
|
|
actual_arch = x32;
|
|
else
|
|
{
|
|
dputs("Unknown JIT entry type. Use OLD, x64 or x32 as parameter.");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
if(!dbggetjit(get_entry, actual_arch, NULL, & rw_error))
|
|
{
|
|
if(rw_error == ERROR_RW_NOTWOW64)
|
|
dprintf("Error using x64 arg. The debugger is not a WOW64 process\n");
|
|
else
|
|
dprintf("Error getting JIT %s\n", argv[1]);
|
|
return STATUS_ERROR;
|
|
}
|
|
}
|
|
|
|
dprintf("JIT %s: %s\n", (actual_arch == x64) ? "x64" : "x32", get_entry);
|
|
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugGetPageRights(int argc, char* argv[])
|
|
{
|
|
uint addr = 0;
|
|
char rights[RIGHTS_STRING_SIZE];
|
|
|
|
if(argc != 2 || !valfromstring(argv[1], &addr))
|
|
{
|
|
dprintf("Error: using an address as arg1\n");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
if(!dbggetpagerights(addr, rights))
|
|
{
|
|
dprintf("Error getting rights of page: %s\n", argv[1]);
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
dprintf("Page: "fhex", Rights: %s\n", addr, rights);
|
|
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugSetPageRights(int argc, char* argv[])
|
|
{
|
|
uint addr = 0;
|
|
char rights[RIGHTS_STRING_SIZE];
|
|
|
|
if(argc < 3 || !valfromstring(argv[1], &addr))
|
|
{
|
|
dprintf("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 STATUS_ERROR;
|
|
}
|
|
|
|
if(!dbgsetpagerights(addr, argv[2]))
|
|
{
|
|
dprintf("Error: Set rights of "fhex" with Rights: %s\n", addr, argv[2]);
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
if(!dbggetpagerights(addr, rights))
|
|
{
|
|
dprintf("Error getting rights of page: %s\n", argv[1]);
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
//update the memory map
|
|
dbggetprivateusage(fdProcessInfo->hProcess, true);
|
|
memupdatemap(fdProcessInfo->hProcess);
|
|
GuiUpdateMemoryView();
|
|
|
|
dprintf("New rights of "fhex": %s\n", addr, rights);
|
|
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugLoadLib(int argc, char* argv[])
|
|
{
|
|
if(argc < 2)
|
|
{
|
|
dprintf("Error: you must specify the name of the DLL to load\n");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
LoadLibThreadID = fdProcessInfo->dwThreadId;
|
|
HANDLE LoadLibThread = threadgethandle((DWORD)LoadLibThreadID);
|
|
|
|
DLLNameMem = VirtualAllocEx(fdProcessInfo->hProcess, NULL, strlen(argv[1]) + 1, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
|
|
ASMAddr = VirtualAllocEx(fdProcessInfo->hProcess, NULL, 0x1000, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
|
|
|
|
if(!DLLNameMem || !ASMAddr)
|
|
{
|
|
dprintf("Error: couldn't allocate memory in debuggee");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
if(!memwrite(fdProcessInfo->hProcess, DLLNameMem, argv[1], strlen(argv[1]), NULL))
|
|
{
|
|
dprintf("Error: couldn't write process memory");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
int size = 0;
|
|
int counter = 0;
|
|
uint LoadLibraryA = 0;
|
|
char command[50] = "";
|
|
char error[256] = "";
|
|
|
|
GetFullContextDataEx(LoadLibThread, &backupctx);
|
|
|
|
valfromstring("kernel32:LoadLibraryA", &LoadLibraryA, false);
|
|
|
|
// Arch specific asm code
|
|
#ifdef _WIN64
|
|
sprintf(command, "mov rcx, "fhex, DLLNameMem);
|
|
#else
|
|
sprintf(command, "push "fhex, DLLNameMem);
|
|
#endif // _WIN64
|
|
|
|
assembleat((uint)ASMAddr, command, &size, error, true);
|
|
counter += size;
|
|
|
|
#ifdef _WIN64
|
|
sprintf(command, "mov rax, "fhex, LoadLibraryA);
|
|
assembleat((uint)ASMAddr + counter, command, &size, error, true);
|
|
counter += size;
|
|
sprintf(command, "call rax");
|
|
#else
|
|
sprintf(command, "call "fhex, LoadLibraryA);
|
|
#endif // _WIN64
|
|
|
|
assembleat((uint)ASMAddr + counter, command, &size, error, true);
|
|
counter += size;
|
|
|
|
SetContextDataEx(LoadLibThread, UE_CIP, (uint)ASMAddr);
|
|
SetBPX((uint)ASMAddr + counter, UE_SINGLESHOOT | UE_BREAKPOINT_TYPE_INT3, (void*)cbLoadLibBPX);
|
|
|
|
threadsuspendall();
|
|
ResumeThread(LoadLibThread);
|
|
|
|
unlock(WAITID_RUN);
|
|
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
void cbLoadLibBPX()
|
|
{
|
|
uint LibAddr = 0;
|
|
HANDLE LoadLibThread = threadgethandle((DWORD)LoadLibThreadID);
|
|
#ifdef _WIN64
|
|
LibAddr = GetContextDataEx(LoadLibThread, UE_RAX);
|
|
#else
|
|
LibAddr = GetContextDataEx(LoadLibThread, UE_EAX);
|
|
#endif //_WIN64
|
|
varset("$result", LibAddr, false);
|
|
backupctx.eflags &= ~0x100;
|
|
SetFullContextDataEx(LoadLibThread, &backupctx);
|
|
VirtualFreeEx(fdProcessInfo->hProcess, DLLNameMem, 0, MEM_RELEASE);
|
|
VirtualFreeEx(fdProcessInfo->hProcess, ASMAddr, 0, MEM_RELEASE);
|
|
threadresumeall();
|
|
//update GUI
|
|
GuiSetDebugState(paused);
|
|
DebugUpdateGui(GetContextDataEx(hActiveThread, UE_CIP), true);
|
|
//lock
|
|
lock(WAITID_RUN);
|
|
SetForegroundWindow(GuiGetWindowHandle());
|
|
PLUG_CB_PAUSEDEBUG pauseInfo;
|
|
pauseInfo.reserved = 0;
|
|
plugincbcall(CB_PAUSEDEBUG, &pauseInfo);
|
|
wait(WAITID_RUN);
|
|
}
|
|
|
|
void showcommandlineerror(cmdline_error_t* cmdline_error)
|
|
{
|
|
bool unkown = false;
|
|
|
|
switch(cmdline_error->type)
|
|
{
|
|
case CMDL_ERR_ALLOC:
|
|
dprintf("Error allocating memory for cmdline");
|
|
break;
|
|
case CMDL_ERR_CONVERTUNICODE:
|
|
dprintf("Error converting UNICODE cmdline");
|
|
break;
|
|
case CMDL_ERR_READ_PEBBASE:
|
|
dprintf("Error reading PEB base addres");
|
|
break;
|
|
case CMDL_ERR_READ_PROCPARM_CMDLINE:
|
|
dprintf("Error reading PEB -> ProcessParameters -> CommandLine UNICODE_STRING");
|
|
break;
|
|
case CMDL_ERR_READ_PROCPARM_PTR:
|
|
dprintf("Error reading PEB -> ProcessParameters pointer address");
|
|
break;
|
|
case CMDL_ERR_GET_PEB:
|
|
dprintf("Error Getting remote PEB address");
|
|
break;
|
|
case CMDL_ERR_READ_GETCOMMANDLINEBASE:
|
|
dprintf("Error Getting command line base address");
|
|
break;
|
|
case CMDL_ERR_CHECK_GETCOMMANDLINESTORED:
|
|
dprintf("Error checking the pattern of the commandline stored");
|
|
break;
|
|
case CMDL_ERR_WRITE_GETCOMMANDLINESTORED:
|
|
dprintf("Error writing the new command line stored");
|
|
break;
|
|
case CMDL_ERR_GET_GETCOMMANDLINE:
|
|
dprintf("Error getting getcommandline");
|
|
break;
|
|
case CMDL_ERR_ALLOC_UNICODEANSI_COMMANDLINE:
|
|
dprintf("Error allocating the page with UNICODE and ANSI command lines");
|
|
break;
|
|
case CMDL_ERR_WRITE_ANSI_COMMANDLINE:
|
|
dprintf("Error writing the ANSI command line in the page");
|
|
break;
|
|
case CMDL_ERR_WRITE_UNICODE_COMMANDLINE:
|
|
dprintf("Error writing the UNICODE command line in the page");
|
|
break;
|
|
case CMDL_ERR_WRITE_PEBUNICODE_COMMANDLINE:
|
|
dprintf("Error writing command line UNICODE in PEB");
|
|
break;
|
|
default:
|
|
unkown = true;
|
|
dputs("Error getting cmdline");
|
|
break;
|
|
}
|
|
|
|
if(!unkown)
|
|
{
|
|
if(cmdline_error->addr != 0)
|
|
dprintf(" (Address: "fhex")", cmdline_error->addr);
|
|
dputs("");
|
|
}
|
|
}
|
|
|
|
CMDRESULT 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))
|
|
{
|
|
showcommandlineerror(& cmdline_error);
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
dprintf("Command line: %s\n", cmd_line);
|
|
|
|
efree(cmd_line);
|
|
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugSetCmdline(int argc, char* argv[])
|
|
{
|
|
cmdline_error_t cmdline_error = {(cmdline_error_type_t) 0, 0};
|
|
|
|
if(argc != 2)
|
|
{
|
|
dputs("Error: write the arg1 with the new command line of the process debugged");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
if(!dbgsetcmdline(argv[1], &cmdline_error))
|
|
{
|
|
showcommandlineerror(&cmdline_error);
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
//update the memory map
|
|
dbggetprivateusage(fdProcessInfo->hProcess, true);
|
|
memupdatemap(fdProcessInfo->hProcess);
|
|
GuiUpdateMemoryView();
|
|
|
|
dprintf("New command line: %s\n", argv[1]);
|
|
|
|
return STATUS_CONTINUE;
|
|
}
|
|
|
|
CMDRESULT cbDebugSkip(int argc, char* argv[])
|
|
{
|
|
SetNextDbgContinueStatus(DBG_CONTINUE); //swallow the exception
|
|
uint cip = GetContextDataEx(hActiveThread, UE_CIP);
|
|
BASIC_INSTRUCTION_INFO basicinfo;
|
|
memset(&basicinfo, 0, sizeof(basicinfo));
|
|
disasmfast(cip, &basicinfo);
|
|
cip += basicinfo.size;
|
|
SetContextDataEx(hActiveThread, UE_CIP, cip);
|
|
DebugUpdateGui(cip, false); //update GUI
|
|
return STATUS_CONTINUE;
|
|
}
|