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

Partially refactor memory.cpp/.h

This commit is contained in:
Nukem 2015-03-25 22:17:52 -04:00
parent 5bd3a0b5a7
commit 78d4efc312
25 changed files with 249 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
x64_dbg_dbg/_dbgfunctions.cpp
View File

@ -72,7 +72,7 @@ static bool _patchinrange(duint start, duint end)
static bool _mempatch(duint va, const unsigned char* src, duint size)
{
return mempatch(fdProcessInfo->hProcess, (void*)va, src, size, 0);
return MemPatch((void*)va, (void*)src, size, 0);
}
static void _patchrestorerange(duint start, duint end)
@ -162,7 +162,7 @@ bool _getprocesslist(DBGPROCESSINFO** entries, int* count)
static void _memupdatemap()
{
memupdatemap(fdProcessInfo->hProcess);
MemUpdateMap(fdProcessInfo->hProcess);
}
void dbgfunctionsinit()

14
x64_dbg_dbg/_exports.cpp
View File

@ -26,17 +26,17 @@ static bool bOnlyCipAutoComments = false;
extern "C" DLL_EXPORT duint _dbg_memfindbaseaddr(duint addr, duint* size)
{
return memfindbaseaddr(addr, size);
return MemFindBaseAddr(addr, size);
}
extern "C" DLL_EXPORT bool _dbg_memread(duint addr, unsigned char* dest, duint size, duint* read)
{
return memread(fdProcessInfo->hProcess, (void*)addr, dest, size, read);
return MemRead((void*)addr, dest, size, read);
}
extern "C" DLL_EXPORT bool _dbg_memwrite(duint addr, const unsigned char* src, duint size, duint* written)
{
return memwrite(fdProcessInfo->hProcess, (void*)addr, src, size, written);
return MemWrite((void*)addr, (void*)src, size, written);
}
extern "C" DLL_EXPORT bool _dbg_memmap(MEMMAP* memmap)
@ -57,7 +57,7 @@ extern "C" DLL_EXPORT bool _dbg_memmap(MEMMAP* memmap)
extern "C" DLL_EXPORT bool _dbg_memisvalidreadptr(duint addr)
{
return memisvalidreadptr(fdProcessInfo->hProcess, addr);
return MemIsValidReadPtr(addr);
}
extern "C" DLL_EXPORT bool _dbg_valfromstring(const char* string, duint* value)
@ -122,7 +122,7 @@ extern "C" DLL_EXPORT bool _dbg_addrinfoget(duint addr, SEGMENTREG segment, ADDR
if(disasmfast(addr, &basicinfo) && basicinfo.branch && !basicinfo.call && basicinfo.memory.value) //thing is a JMP
{
uint val = 0;
if(memread(fdProcessInfo->hProcess, (const void*)basicinfo.memory.value, &val, sizeof(val), 0))
if(MemRead((void*)basicinfo.memory.value, &val, sizeof(val), 0))
{
if(SymFromAddr(fdProcessInfo->hProcess, (DWORD64)val, &displacement, pSymbol) and !displacement)
{
@ -567,7 +567,7 @@ extern "C" DLL_EXPORT int _dbg_getbplist(BPXTYPE type, BPMAP* bpmap)
curBp.addr = list[i].addr;
curBp.enabled = list[i].enabled;
//TODO: fix this
if(memisvalidreadptr(fdProcessInfo->hProcess, curBp.addr))
if(MemIsValidReadPtr(curBp.addr))
curBp.active = true;
strcpy_s(curBp.mod, list[i].mod);
strcpy_s(curBp.name, list[i].name);
@ -776,7 +776,7 @@ extern "C" DLL_EXPORT uint _dbg_sendmessage(DBGMSG type, void* param1, void* par
if(!param1 or !param2)
return 0;
unsigned char data[16];
if(!memread(fdProcessInfo->hProcess, param1, data, sizeof(data), 0))
if(!MemRead(param1, data, sizeof(data), 0))
return 0;
DISASM disasm;
memset(&disasm, 0, sizeof(disasm));

16
x64_dbg_dbg/addrinfo.cpp
View File

@ -111,14 +111,14 @@ bool apienumexports(uint base, EXPORTENUMCALLBACK cbEnum)
VirtualQueryEx(fdProcessInfo->hProcess, (const void*)base, &mbi, sizeof(mbi));
uint size = mbi.RegionSize;
Memory<void*> buffer(size, "apienumexports:buffer");
if(!memread(fdProcessInfo->hProcess, (const void*)base, buffer, size, 0))
if(!MemRead((void*)base, buffer, size, 0))
return false;
IMAGE_NT_HEADERS* pnth = (IMAGE_NT_HEADERS*)((uint)buffer + GetPE32DataFromMappedFile((ULONG_PTR)buffer, 0, UE_PE_OFFSET));
uint export_dir_rva = pnth->OptionalHeader.DataDirectory[0].VirtualAddress;
uint export_dir_size = pnth->OptionalHeader.DataDirectory[0].Size;
IMAGE_EXPORT_DIRECTORY export_dir;
memset(&export_dir, 0, sizeof(export_dir));
memread(fdProcessInfo->hProcess, (const void*)(export_dir_rva + base), &export_dir, sizeof(export_dir), 0);
MemRead((void*)(export_dir_rva + base), &export_dir, sizeof(export_dir), 0);
unsigned int NumberOfNames = export_dir.NumberOfNames;
if(!export_dir.NumberOfFunctions or !NumberOfNames) //no named exports
return false;
@ -127,28 +127,28 @@ bool apienumexports(uint base, EXPORTENUMCALLBACK cbEnum)
uint original_name_va = export_dir.Name + base;
char original_name[deflen] = "";
memset(original_name, 0, sizeof(original_name));
memread(fdProcessInfo->hProcess, (const void*)original_name_va, original_name, deflen, 0);
MemRead((void*)original_name_va, original_name, deflen, 0);
char* AddrOfFunctions_va = (char*)(export_dir.AddressOfFunctions + base);
char* AddrOfNames_va = (char*)(export_dir.AddressOfNames + base);
char* AddrOfNameOrdinals_va = (char*)(export_dir.AddressOfNameOrdinals + base);
for(DWORD i = 0; i < NumberOfNames; i++)
{
DWORD curAddrOfName = 0;
memread(fdProcessInfo->hProcess, AddrOfNames_va + sizeof(DWORD)*i, &curAddrOfName, sizeof(DWORD), 0);
MemRead(AddrOfNames_va + sizeof(DWORD)*i, &curAddrOfName, sizeof(DWORD), 0);
char* cur_name_va = (char*)(curAddrOfName + base);
char cur_name[deflen] = "";
memset(cur_name, 0, deflen);
memread(fdProcessInfo->hProcess, cur_name_va, cur_name, deflen, 0);
MemRead(cur_name_va, cur_name, deflen, 0);
WORD curAddrOfNameOrdinals = 0;
memread(fdProcessInfo->hProcess, AddrOfNameOrdinals_va + sizeof(WORD)*i, &curAddrOfNameOrdinals, sizeof(WORD), 0);
MemRead(AddrOfNameOrdinals_va + sizeof(WORD)*i, &curAddrOfNameOrdinals, sizeof(WORD), 0);
DWORD curFunctionRva = 0;
memread(fdProcessInfo->hProcess, AddrOfFunctions_va + sizeof(DWORD)*curAddrOfNameOrdinals, &curFunctionRva, sizeof(DWORD), 0);
MemRead(AddrOfFunctions_va + sizeof(DWORD)*curAddrOfNameOrdinals, &curFunctionRva, sizeof(DWORD), 0);
if(curFunctionRva >= export_dir_rva and curFunctionRva < export_dir_rva + export_dir_size)
{
char forwarded_api[deflen] = "";
memset(forwarded_api, 0, deflen);
memread(fdProcessInfo->hProcess, (void*)(curFunctionRva + base), forwarded_api, deflen, 0);
MemRead((void*)(curFunctionRva + base), forwarded_api, deflen, 0);
int len = (int)strlen(forwarded_api);
int j = 0;
while(forwarded_api[j] != '.' and j < len)

4
x64_dbg_dbg/assemble.cpp
View File

@ -67,12 +67,12 @@ bool assembleat(uint addr, const char* instruction, int* size, char* error, bool
if(size)
*size = destSize;
bool ret = mempatch(fdProcessInfo->hProcess, (void*)addr, dest, destSize, 0);
bool ret = MemPatch((void*)addr, dest, destSize, 0);
if(ret && fillnop && nopsize)
{
if(size)
*size += nopsize;
if(!mempatch(fdProcessInfo->hProcess, (void*)(addr + destSize), nops, nopsize, 0))
if(!MemPatch((void*)(addr + destSize), nops, nopsize, 0))
ret = false;
}
GuiUpdatePatches();

2
x64_dbg_dbg/bookmark.cpp
View File

@ -15,7 +15,7 @@ bool BookmarkSet(uint Address, bool Manual)
return false;
// Validate the incoming address
if(!memisvalidreadptr(fdProcessInfo->hProcess, Address))
if(!MemIsValidReadPtr(Address))
return false;
BOOKMARKSINFO bookmark;

10
x64_dbg_dbg/breakpoint.cpp
View File

@ -42,7 +42,7 @@ int BpGetList(std::vector<BREAKPOINT>* List)
{
BREAKPOINT currentBp = i.second;
currentBp.addr += ModBaseFromName(currentBp.mod);
currentBp.active = memisvalidreadptr(fdProcessInfo->hProcess, currentBp.addr);
currentBp.active = MemIsValidReadPtr(currentBp.addr);
List->push_back(currentBp);
}
@ -58,7 +58,7 @@ bool BpNew(uint Address, bool Enable, bool Singleshot, short OldBytes, BP_TYPE T
return false;
// Fail if the address is a bad memory region
if(!memisvalidreadptr(fdProcessInfo->hProcess, Address))
if(!MemIsValidReadPtr(Address))
return false;
// Fail if the breakpoint already exists
@ -113,7 +113,7 @@ bool BpGet(uint Address, BP_TYPE Type, const char* Name, BREAKPOINT* Bp)
*Bp = *bpInfo;
Bp->addr += ModBaseFromAddr(Address);
Bp->active = memisvalidreadptr(fdProcessInfo->hProcess, Bp->addr);
Bp->active = MemIsValidReadPtr(Bp->addr);
return true;
}
@ -129,7 +129,7 @@ bool BpGet(uint Address, BP_TYPE Type, const char* Name, BREAKPOINT* Bp)
{
*Bp = i.second;
Bp->addr += ModBaseFromAddr(Address);
Bp->active = memisvalidreadptr(fdProcessInfo->hProcess, Bp->addr);
Bp->active = MemIsValidReadPtr(Bp->addr);
}
// Return true if the name was found at all
@ -230,7 +230,7 @@ bool BpEnumAll(BPENUMCALLBACK EnumCallback, const char* Module)
BREAKPOINT bpInfo = i.second;
bpInfo.addr += ModBaseFromName(bpInfo.mod);
bpInfo.active = memisvalidreadptr(fdProcessInfo->hProcess, bpInfo.addr);
bpInfo.active = MemIsValidReadPtr(bpInfo.addr);
// Execute the callback
if(!EnumCallback(&bpInfo))

2
x64_dbg_dbg/comment.cpp
View File

@ -15,7 +15,7 @@ bool CommentSet(uint Address, const char* Text, bool Manual)
return false;
// A valid memory address must be supplied
if(!memisvalidreadptr(fdProcessInfo->hProcess, Address))
if(!MemIsValidReadPtr(Address))
return false;
// Make sure the string is supplied, within bounds, and not a special delimiter

48
x64_dbg_dbg/debugger.cpp
View File

@ -49,7 +49,7 @@ static DWORD WINAPI memMapThread(void* ptr)
if(cachePrivateUsage != PrivateUsage && !dbgisrunning()) //update the memory map when
{
cachePrivateUsage = PrivateUsage;
memupdatemap(fdProcessInfo->hProcess);
MemUpdateMap(fdProcessInfo->hProcess);
}
Sleep(1000);
}
@ -185,7 +185,7 @@ DWORD WINAPI updateCallStackThread(void* ptr)
void DebugUpdateGui(uint disasm_addr, bool stack)
{
uint cip = GetContextDataEx(hActiveThread, UE_CIP);
if(memisvalidreadptr(fdProcessInfo->hProcess, disasm_addr))
if(MemIsValidReadPtr(disasm_addr))
GuiDisasmAt(disasm_addr, cip);
uint csp = GetContextDataEx(hActiveThread, UE_CSP);
if(stack)
@ -338,7 +338,7 @@ void cbMemoryBreakpoint(void* ExceptionAddress)
hActiveThread = ThreadGetHandle(((DEBUG_EVENT*)GetDebugData())->dwThreadId);
uint cip = GetContextDataEx(hActiveThread, UE_CIP);
uint size;
uint base = memfindbaseaddr((uint)ExceptionAddress, &size, true);
uint base = MemFindBaseAddr((uint)ExceptionAddress, &size, true);
BREAKPOINT bp;
BRIDGEBP pluginBp;
PLUG_CB_BREAKPOINT bpInfo;
@ -487,7 +487,7 @@ static bool cbSetModuleBreakpoints(const BREAKPOINT* bp)
case BPMEMORY:
{
uint size = 0;
memfindbaseaddr(bp->addr, &size);
MemFindBaseAddr(bp->addr, &size);
if(!SetMemoryBPXEx(bp->addr, size, bp->titantype, !bp->singleshoot, (void*)cbMemoryBreakpoint))
dprintf("Could not set memory breakpoint "fhex"!\n", bp->addr);
}
@ -576,7 +576,7 @@ static unsigned char getCIPch()
{
unsigned char ch = 0x90;
uint cip = GetContextDataEx(hActiveThread, UE_CIP);
memread(fdProcessInfo->hProcess, (void*)cip, &ch, 1, 0);
MemRead((void*)cip, &ch, 1, 0);
return ch;
}
@ -604,8 +604,8 @@ static void cbCreateProcess(CREATE_PROCESS_DEBUG_INFO* CreateProcessInfo)
}
dprintf("Process Started: "fhex" %s\n", base, DebugFileName);
memupdatemap(fdProcessInfo->hProcess);
GuiDumpAt(memfindbaseaddr(GetContextData(UE_CIP), 0) + PAGE_SIZE); //dump somewhere
MemUpdateMap(fdProcessInfo->hProcess);
GuiDumpAt(MemFindBaseAddr(GetContextData(UE_CIP), 0) + PAGE_SIZE); //dump somewhere
//init program database
int len = (int)strlen(szFileName);
@ -635,7 +635,7 @@ static void cbCreateProcess(CREATE_PROCESS_DEBUG_INFO* CreateProcessInfo)
if(SymGetModuleInfo64(fdProcessInfo->hProcess, (DWORD64)base, &modInfo))
ModLoad((uint)base, modInfo.ImageSize, modInfo.ImageName);
dbggetprivateusage(fdProcessInfo->hProcess, true);
memupdatemap(fdProcessInfo->hProcess); //update memory map
MemUpdateMap(fdProcessInfo->hProcess); //update memory map
char modname[256] = "";
if(ModNameFromAddr((uint)base, modname, true))
BpEnumAll(cbSetModuleBreakpoints, modname);
@ -723,7 +723,7 @@ static void cbCreateThread(CREATE_THREAD_DEBUG_INFO* CreateThread)
if(settingboolget("Events", "ThreadStart"))
{
dbggetprivateusage(fdProcessInfo->hProcess, true);
memupdatemap(fdProcessInfo->hProcess); //update memory map
MemUpdateMap(fdProcessInfo->hProcess); //update memory map
//update GUI
GuiSetDebugState(paused);
DebugUpdateGui(GetContextDataEx(hActiveThread, UE_CIP), true);
@ -773,7 +773,7 @@ static void cbSystemBreakpoint(void* ExceptionData)
dputs("System breakpoint reached!");
bSkipExceptions = false; //we are not skipping first-chance exceptions
uint cip = GetContextDataEx(hActiveThread, UE_CIP);
GuiDumpAt(memfindbaseaddr(cip, 0, true)); //dump somewhere
GuiDumpAt(MemFindBaseAddr(cip, 0, true)); //dump somewhere
//plugin callbacks
PLUG_CB_SYSTEMBREAKPOINT callbackInfo;
@ -815,7 +815,7 @@ static void cbLoadDll(LOAD_DLL_DEBUG_INFO* LoadDll)
if(SymGetModuleInfo64(fdProcessInfo->hProcess, (DWORD64)base, &modInfo))
ModLoad((uint)base, modInfo.ImageSize, modInfo.ImageName);
dbggetprivateusage(fdProcessInfo->hProcess, true);
memupdatemap(fdProcessInfo->hProcess); //update memory map
MemUpdateMap(fdProcessInfo->hProcess); //update memory map
char modname[256] = "";
if(ModNameFromAddr((uint)base, modname, true))
BpEnumAll(cbSetModuleBreakpoints, modname);
@ -942,7 +942,7 @@ static void cbOutputDebugString(OUTPUT_DEBUG_STRING_INFO* DebugString)
if(!DebugString->fUnicode) //ASCII
{
Memory<char*> DebugText(DebugString->nDebugStringLength + 1, "cbOutputDebugString:DebugText");
if(memread(fdProcessInfo->hProcess, DebugString->lpDebugStringData, DebugText, DebugString->nDebugStringLength, 0))
if(MemRead(DebugString->lpDebugStringData, DebugText, DebugString->nDebugStringLength, 0))
{
String str = String(DebugText);
if(str != lastDebugText) //fix for every string being printed twice
@ -1022,7 +1022,7 @@ static void cbException(EXCEPTION_DEBUG_INFO* ExceptionData)
if(nameInfo.dwType == 0x1000 and nameInfo.dwFlags == 0 and ThreadIsValid(nameInfo.dwThreadID)) //passed basic checks
{
Memory<char*> ThreadName(MAX_THREAD_NAME_SIZE, "cbException:ThreadName");
if(memread(fdProcessInfo->hProcess, nameInfo.szName, ThreadName, MAX_THREAD_NAME_SIZE - 1, 0))
if(MemRead((void*)nameInfo.szName, ThreadName, MAX_THREAD_NAME_SIZE - 1, 0))
{
String ThreadNameEscaped = StringUtils::Escape(ThreadName);
dprintf("SetThreadName(%X, \"%s\")\n", nameInfo.dwThreadID, ThreadNameEscaped.c_str());
@ -1234,7 +1234,7 @@ bool cbEnableAllMemoryBreakpoints(const BREAKPOINT* bp)
if(bp->type != BPMEMORY or bp->enabled)
return true;
uint size = 0;
memfindbaseaddr(bp->addr, &size);
MemFindBaseAddr(bp->addr, &size);
if(!BpEnable(bp->addr, BPMEMORY, true) or !SetMemoryBPXEx(bp->addr, size, bp->titantype, !bp->singleshoot, (void*)cbMemoryBreakpoint))
{
dprintf("Could not enable memory breakpoint "fhex"\n", bp->addr);
@ -1282,7 +1282,7 @@ bool cbDeleteAllMemoryBreakpoints(const BREAKPOINT* bp)
if(!bp->enabled)
return true;
uint size;
memfindbaseaddr(bp->addr, &size);
MemFindBaseAddr(bp->addr, &size);
if(!BpDelete(bp->addr, BPMEMORY) or !RemoveMemoryBPX(bp->addr, size))
{
dprintf("Delete memory breakpoint failed: "fhex"\n", bp->addr);
@ -1743,7 +1743,7 @@ static bool getcommandlineaddr(uint* addr, cmdline_error_t* cmd_line_error)
//cast-trick to calculate the address of the remote peb field ProcessParameters
cmd_line_error->addr = (uint) & (((PPEB) cmd_line_error->addr)->ProcessParameters);
if(!memread(fdProcessInfo->hProcess, (const void*)cmd_line_error->addr, &pprocess_parameters, sizeof(pprocess_parameters), &size))
if(!MemRead((void*)cmd_line_error->addr, &pprocess_parameters, sizeof(pprocess_parameters), &size))
{
cmd_line_error->type = CMDL_ERR_READ_PEBBASE;
return false;
@ -1762,7 +1762,7 @@ static bool patchcmdline(uint getcommandline, uint new_command_line, cmdline_err
unsigned char data[100];
cmd_line_error->addr = getcommandline;
if(!memread(fdProcessInfo->hProcess, (const void*) cmd_line_error->addr, & data, sizeof(data), & size))
if(!MemRead((void*) cmd_line_error->addr, & data, sizeof(data), & size))
{
cmd_line_error->type = CMDL_ERR_READ_GETCOMMANDLINEBASE;
return false;
@ -1796,7 +1796,7 @@ static bool patchcmdline(uint getcommandline, uint new_command_line, cmdline_err
#endif
//update the pointer in the debuggee
if(!memwrite(fdProcessInfo->hProcess, (void*)command_line_stored, &new_command_line, sizeof(new_command_line), &size))
if(!MemWrite((void*)command_line_stored, &new_command_line, sizeof(new_command_line), &size))
{
cmd_line_error->addr = command_line_stored;
cmd_line_error->type = CMDL_ERR_WRITE_GETCOMMANDLINESTORED;
@ -1865,21 +1865,21 @@ bool dbgsetcmdline(const char* cmd_line, cmdline_error_t* cmd_line_error)
new_command_line.Buffer = command_linewstr;
uint mem = (uint)memalloc(fdProcessInfo->hProcess, 0, new_command_line.Length * 2, PAGE_READWRITE);
uint mem = (uint)MemAllocRemote(0, new_command_line.Length * 2, PAGE_READWRITE);
if(!mem)
{
cmd_line_error->type = CMDL_ERR_ALLOC_UNICODEANSI_COMMANDLINE;
return false;
}
if(!memwrite(fdProcessInfo->hProcess, (void*)mem, new_command_line.Buffer, new_command_line.Length, &size))
if(!MemWrite((void*)mem, new_command_line.Buffer, new_command_line.Length, &size))
{
cmd_line_error->addr = mem;
cmd_line_error->type = CMDL_ERR_WRITE_UNICODE_COMMANDLINE;
return false;
}
if(!memwrite(fdProcessInfo->hProcess, (void*)(mem + new_command_line.Length), cmd_line, strlen(cmd_line) + 1, &size))
if(!MemWrite((void*)(mem + new_command_line.Length), (void*)cmd_line, strlen(cmd_line) + 1, &size))
{
cmd_line_error->addr = mem + new_command_line.Length;
cmd_line_error->type = CMDL_ERR_WRITE_ANSI_COMMANDLINE;
@ -1890,7 +1890,7 @@ bool dbgsetcmdline(const char* cmd_line, cmdline_error_t* cmd_line_error)
return false;
new_command_line.Buffer = (PWSTR) mem;
if(!memwrite(fdProcessInfo->hProcess, (void*)command_line_addr, &new_command_line, sizeof(new_command_line), &size))
if(!MemWrite((void*)command_line_addr, &new_command_line, sizeof(new_command_line), &size))
{
cmd_line_error->addr = command_line_addr;
cmd_line_error->type = CMDL_ERR_WRITE_PEBUNICODE_COMMANDLINE;
@ -1912,7 +1912,7 @@ bool dbggetcmdline(char** cmd_line, cmdline_error_t* cmd_line_error)
if(!getcommandlineaddr(&cmd_line_error->addr, cmd_line_error))
return false;
if(!memread(fdProcessInfo->hProcess, (const void*)cmd_line_error->addr, &CommandLine, sizeof(CommandLine), &size))
if(!MemRead((void*)cmd_line_error->addr, &CommandLine, sizeof(CommandLine), &size))
{
cmd_line_error->type = CMDL_ERR_READ_PROCPARM_PTR;
return false;
@ -1921,7 +1921,7 @@ bool dbggetcmdline(char** cmd_line, cmdline_error_t* cmd_line_error)
Memory<wchar_t*> wstr_cmd(CommandLine.Length + sizeof(wchar_t));
cmd_line_error->addr = (uint) CommandLine.Buffer;
if(!memread(fdProcessInfo->hProcess, (const void*)cmd_line_error->addr, wstr_cmd, CommandLine.Length, &size))
if(!MemRead((void*)cmd_line_error->addr, wstr_cmd, CommandLine.Length, &size))
{
cmd_line_error->type = CMDL_ERR_READ_PROCPARM_CMDLINE;
return false;

32
x64_dbg_dbg/debugger_commands.cpp
View File

@ -219,7 +219,7 @@ CMDRESULT cbDebugSetBPX(int argc, char* argv[]) //bp addr [,name [,type]]
dprintf("Error setting breakpoint at "fhex"! (IsBPXEnabled)\n", addr);
return STATUS_ERROR;
}
else if(!memread(fdProcessInfo->hProcess, (void*)addr, &oldbytes, sizeof(short), 0))
else if(!MemRead((void*)addr, &oldbytes, sizeof(short), 0))
{
dprintf("Error setting breakpoint at "fhex"! (memread)\n", addr);
return STATUS_ERROR;
@ -458,7 +458,7 @@ CMDRESULT cbDebugDisasm(int argc, char* argv[])
if(argget(*argv, arg1, 0, true))
if(!valfromstring(arg1, &addr))
addr = GetContextDataEx(hActiveThread, UE_CIP);
if(!memisvalidreadptr(fdProcessInfo->hProcess, addr))
if(!MemIsValidReadPtr(addr))
return STATUS_CONTINUE;
DebugUpdateGui(addr, false);
return STATUS_CONTINUE;
@ -505,7 +505,7 @@ CMDRESULT cbDebugSetMemoryBpx(int argc, char* argv[])
}
}
uint size = 0;
uint base = memfindbaseaddr(addr, &size, true);
uint base = MemFindBaseAddr(addr, &size, true);
bool singleshoot = false;
if(!restore)
singleshoot = true;
@ -544,7 +544,7 @@ CMDRESULT cbDebugDeleteMemoryBreakpoint(int argc, char* argv[])
if(BpGet(0, BPMEMORY, arg1, &found)) //found a breakpoint with name
{
uint size;
memfindbaseaddr(found.addr, &size);
MemFindBaseAddr(found.addr, &size);
if(!BpDelete(found.addr, BPMEMORY) or !RemoveMemoryBPX(found.addr, size))
{
dprintf("Delete memory breakpoint failed: "fhex"\n", found.addr);
@ -559,7 +559,7 @@ CMDRESULT cbDebugDeleteMemoryBreakpoint(int argc, char* argv[])
return STATUS_ERROR;
}
uint size;
memfindbaseaddr(found.addr, &size);
MemFindBaseAddr(found.addr, &size);
if(!BpDelete(found.addr, BPMEMORY) or !RemoveMemoryBPX(found.addr, size))
{
dprintf("Delete memory breakpoint failed: "fhex"\n", found.addr);
@ -724,7 +724,7 @@ CMDRESULT cbDebugAlloc(int argc, char* argv[])
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);
uint mem = (uint)MemAllocRemote(0, size, PAGE_EXECUTE_READWRITE);
if(!mem)
dputs("VirtualAllocEx failed");
else
@ -732,7 +732,7 @@ CMDRESULT cbDebugAlloc(int argc, char* argv[])
if(mem)
varset("$lastalloc", mem, true);
dbggetprivateusage(fdProcessInfo->hProcess, true);
memupdatemap(fdProcessInfo->hProcess);
MemUpdateMap(fdProcessInfo->hProcess);
GuiUpdateMemoryView();
varset("$res", mem, false);
return STATUS_CONTINUE;
@ -760,7 +760,7 @@ CMDRESULT cbDebugFree(int argc, char* argv[])
if(!ok)
dputs("VirtualFreeEx failed");
dbggetprivateusage(fdProcessInfo->hProcess, true);
memupdatemap(fdProcessInfo->hProcess);
MemUpdateMap(fdProcessInfo->hProcess);
GuiUpdateMemoryView();
varset("$res", ok, false);
return STATUS_CONTINUE;
@ -786,7 +786,7 @@ CMDRESULT cbDebugMemset(int argc, char* argv[])
}
else
{
uint base = memfindbaseaddr(addr, &size, true);
uint base = MemFindBaseAddr(addr, &size, true);
if(!base)
{
dputs("invalid address specified");
@ -806,7 +806,7 @@ CMDRESULT cbDebugMemset(int argc, char* argv[])
CMDRESULT cbDebugBenchmark(int argc, char* argv[])
{
uint addr = memfindbaseaddr(GetContextDataEx(hActiveThread, UE_CIP), 0);
uint addr = MemFindBaseAddr(GetContextDataEx(hActiveThread, UE_CIP), 0);
DWORD ticks = GetTickCount();
char comment[MAX_COMMENT_SIZE] = "";
for(uint i = addr; i < addr + 100000; i++)
@ -962,7 +962,7 @@ CMDRESULT cbDebugStackDump(int argc, char* argv[])
}
duint csp = GetContextDataEx(hActiveThread, UE_CSP);
duint size = 0;
duint base = memfindbaseaddr(csp, &size);
duint base = MemFindBaseAddr(csp, &size);
if(base && addr >= base && addr < (base + size))
GuiStackDumpAt(addr, csp);
else
@ -1320,7 +1320,7 @@ CMDRESULT cbDebugEnableMemoryBreakpoint(int argc, char* argv[])
return STATUS_CONTINUE;
}
uint size = 0;
memfindbaseaddr(found.addr, &size);
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);
@ -1360,7 +1360,7 @@ CMDRESULT cbDebugDisableMemoryBreakpoint(int argc, char* argv[])
return STATUS_CONTINUE;
}
uint size = 0;
memfindbaseaddr(found.addr, &size);
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);
@ -1798,7 +1798,7 @@ CMDRESULT cbDebugSetPageRights(int argc, char* argv[])
//update the memory map
dbggetprivateusage(fdProcessInfo->hProcess, true);
memupdatemap(fdProcessInfo->hProcess);
MemUpdateMap(fdProcessInfo->hProcess);
GuiUpdateMemoryView();
dprintf("New rights of "fhex": %s\n", addr, rights);
@ -1826,7 +1826,7 @@ CMDRESULT cbDebugLoadLib(int argc, char* argv[])
return STATUS_ERROR;
}
if(!memwrite(fdProcessInfo->hProcess, DLLNameMem, argv[1], strlen(argv[1]), NULL))
if(!MemWrite(DLLNameMem, argv[1], strlen(argv[1]), NULL))
{
dprintf("Error: couldn't write process memory");
return STATUS_ERROR;
@ -2000,7 +2000,7 @@ CMDRESULT cbDebugSetCmdline(int argc, char* argv[])
//update the memory map
dbggetprivateusage(fdProcessInfo->hProcess, true);
memupdatemap(fdProcessInfo->hProcess);
MemUpdateMap(fdProcessInfo->hProcess);
GuiUpdateMemoryView();
dprintf("New command line: %s\n", argv[1]);

2
x64_dbg_dbg/disasm_fast.cpp
View File

@ -117,7 +117,7 @@ bool disasmfast(unsigned char* data, uint addr, BASIC_INSTRUCTION_INFO* basicinf
bool disasmfast(uint addr, BASIC_INSTRUCTION_INFO* basicinfo)
{
unsigned int data[16];
if(!memread(fdProcessInfo->hProcess, (const void*)addr, data, sizeof(data), 0))
if(!MemRead((void*)addr, data, sizeof(data), 0))
return false;
return disasmfast((unsigned char*)data, addr, basicinfo);
}

10
x64_dbg_dbg/disasm_helper.cpp
View File

@ -321,11 +321,11 @@ bool disasmispossiblestring(uint addr)
{
unsigned char data[11];
memset(data, 0, sizeof(data));
if(!memread(fdProcessInfo->hProcess, (const void*)addr, data, sizeof(data) - 3, 0))
if(!MemRead((void*)addr, data, sizeof(data) - 3, 0))
return false;
uint test = 0;
memcpy(&test, data, sizeof(uint));
if(memisvalidreadptr(fdProcessInfo->hProcess, test)) //imports/pointers
if(MemIsValidReadPtr(test)) //imports/pointers
return false;
if(isasciistring(data, sizeof(data)) or isunicodestring(data, _countof(data)))
return true;
@ -340,11 +340,11 @@ bool disasmgetstringat(uint addr, STRING_TYPE* type, char* ascii, char* unicode,
return false;
Memory<unsigned char*> data((maxlen + 1) * 2, "disasmgetstringat:data");
memset(data, 0, (maxlen + 1) * 2);
if(!memread(fdProcessInfo->hProcess, (const void*)addr, data, (maxlen + 1) * 2, 0))
if(!MemRead((void*)addr, data, (maxlen + 1) * 2, 0))
return false;
uint test = 0;
memcpy(&test, data, sizeof(uint));
if(memisvalidreadptr(fdProcessInfo->hProcess, test))
if(MemIsValidReadPtr(test))
return false;
if(isasciistring(data, maxlen))
{
@ -442,7 +442,7 @@ int disasmgetsize(uint addr, unsigned char* data)
int disasmgetsize(uint addr)
{
char data[16];
if(!memread(fdProcessInfo->hProcess, (const void*)addr, data, sizeof(data), 0))
if(!MemRead((void*)addr, data, sizeof(data), 0))
return 1;
return disasmgetsize(addr, (unsigned char*)data);
}

2
x64_dbg_dbg/function.cpp
View File

@ -15,7 +15,7 @@ bool FunctionAdd(uint Start, uint End, bool Manual)
return false;
// Make sure memory is readable
if(!memisvalidreadptr(fdProcessInfo->hProcess, Start))
if(!MemIsValidReadPtr(Start))
return false;
// Fail if boundary exceeds module size

16
x64_dbg_dbg/instruction.cpp
View File

@ -158,7 +158,7 @@ CMDRESULT cbInstrMov(int argc, char* argv[])
}
//Check the destination
uint dest;
if(!valfromstring(argv[1], &dest) || !memisvalidreadptr(fdProcessInfo->hProcess, dest))
if(!valfromstring(argv[1], &dest) || !MemIsValidReadPtr(dest))
{
dprintf("invalid destination \"%s\"\n", argv[1]);
return STATUS_ERROR;
@ -175,7 +175,7 @@ CMDRESULT cbInstrMov(int argc, char* argv[])
data[j] = res;
}
//Move data to destination
if(!memwrite(fdProcessInfo->hProcess, (void*)dest, data, data.size(), 0))
if(!MemWrite((void*)dest, data, data.size(), 0))
{
dprintf("failed to write to "fhex"\n", dest);
return STATUS_ERROR;
@ -1053,7 +1053,7 @@ CMDRESULT cbInstrCopystr(int argc, char* argv[])
dprintf("invalid address \"%s\"!\n", argv[1]);
return STATUS_ERROR;
}
if(!mempatch(fdProcessInfo->hProcess, (void*)addr, string, strlen(string), 0))
if(!MemPatch((void*)addr, string, strlen(string), 0))
{
dputs("memwrite failed!");
return STATUS_ERROR;
@ -1084,14 +1084,14 @@ CMDRESULT cbInstrFind(int argc, char* argv[])
if(pattern[len - 1] == '#')
pattern[len - 1] = '\0';
uint size = 0;
uint base = memfindbaseaddr(addr, &size, true);
uint base = MemFindBaseAddr(addr, &size, true);
if(!base)
{
dprintf("invalid memory address "fhex"!\n", addr);
return STATUS_ERROR;
}
Memory<unsigned char*> data(size, "cbInstrFind:data");
if(!memread(fdProcessInfo->hProcess, (const void*)base, data, size, 0))
if(!MemRead((void*)base, data, size, 0))
{
dputs("failed to read memory!");
return STATUS_ERROR;
@ -1136,14 +1136,14 @@ CMDRESULT cbInstrFindAll(int argc, char* argv[])
if(pattern[len - 1] == '#')
pattern[len - 1] = '\0';
uint size = 0;
uint base = memfindbaseaddr(addr, &size, true);
uint base = MemFindBaseAddr(addr, &size, true);
if(!base)
{
dprintf("invalid memory address "fhex"!\n", addr);
return STATUS_ERROR;
}
Memory<unsigned char*> data(size, "cbInstrFindAll:data");
if(!memread(fdProcessInfo->hProcess, (const void*)base, data, size, 0))
if(!MemRead((void*)base, data, size, 0))
{
dputs("failed to read memory!");
return STATUS_ERROR;
@ -1192,7 +1192,7 @@ CMDRESULT cbInstrFindAll(int argc, char* argv[])
if(findData)
{
Memory<unsigned char*> printData(patternsize, "cbInstrFindAll:printData");
memread(fdProcessInfo->hProcess, (const void*)result, printData, patternsize, 0);
MemRead((void*)result, printData, patternsize, 0);
for(int j = 0, k = 0; j < patternsize; j++)
{
if(j)

2
x64_dbg_dbg/label.cpp
View File

@ -10,7 +10,7 @@ static LabelsInfo labels;
bool labelset(uint addr, const char* text, bool manual)
{
if(!DbgIsDebugging() or !memisvalidreadptr(fdProcessInfo->hProcess, addr) or !text or strlen(text) >= MAX_LABEL_SIZE - 1 or strstr(text, "&"))
if(!DbgIsDebugging() or !MemIsValidReadPtr(addr) or !text or strlen(text) >= MAX_LABEL_SIZE - 1 or strstr(text, "&"))
return false;
if(!*text) //NOTE: delete when there is no text
{

2
x64_dbg_dbg/loop.cpp
View File

@ -10,7 +10,7 @@ static LoopsInfo loops;
bool loopadd(uint start, uint end, bool manual)
{
if(!DbgIsDebugging() or end < start or !memisvalidreadptr(fdProcessInfo->hProcess, start))
if(!DbgIsDebugging() or end < start or !MemIsValidReadPtr(start))
return false;
const uint modbase = ModBaseFromAddr(start);
if(modbase != ModBaseFromAddr(end)) //the function boundaries are not in the same mem page

149
x64_dbg_dbg/memory.cpp
View File

@ -8,7 +8,7 @@
MemoryMap memoryPages;
bool bListAllPages = false;
void memupdatemap(HANDLE hProcess)
void MemUpdateMap(HANDLE hProcess)
{
CriticalSectionLocker locker(LockMemoryPages);
MEMORY_BASIC_INFORMATION mbi;
@ -123,102 +123,139 @@ void memupdatemap(HANDLE hProcess)
}
}
uint memfindbaseaddr(uint addr, uint* size, bool refresh)
uint MemFindBaseAddr(uint addr, uint* Size, bool refresh)
{
// Update the memory map if needed
if(refresh)
memupdatemap(fdProcessInfo->hProcess); //update memory map
CriticalSectionLocker locker(LockMemoryPages);
MemoryMap::iterator found = memoryPages.find(std::make_pair(addr, addr));
MemUpdateMap(fdProcessInfo->hProcess);
SHARED_ACQUIRE(LockMemoryPages);
// Search for the memory page address
auto found = memoryPages.find(std::make_pair(addr, addr));
if(found == memoryPages.end())
return 0;
if(size)
*size = found->second.mbi.RegionSize;
// Return the allocation region size when requested
if(Size)
*Size = found->second.mbi.RegionSize;
return found->first.first;
}
bool memread(HANDLE hProcess, const void* lpBaseAddress, void* lpBuffer, SIZE_T nSize, SIZE_T* lpNumberOfBytesRead)
bool MemRead(void* BaseAddress, void* Buffer, SIZE_T Size, SIZE_T* NumberOfBytesRead)
{
if(!hProcess or !lpBaseAddress or !lpBuffer or !nSize) //generic failures
// Buffer must be supplied and size must be greater than 0
if(!Buffer || Size <= 0)
return false;
SIZE_T read = 0;
DWORD oldprotect = 0;
bool ret = MemoryReadSafe(hProcess, (void*)lpBaseAddress, lpBuffer, nSize, &read); //try 'normal' RPM
if(ret and read == nSize) //'normal' RPM worked!
{
if(lpNumberOfBytesRead)
*lpNumberOfBytesRead = read;
// If the 'bytes read' parameter is null, use a temp
SIZE_T bytesReadTemp = 0;
if(!NumberOfBytesRead)
NumberOfBytesRead = &bytesReadTemp;
// Normal single-call read
bool ret = MemoryReadSafe(fdProcessInfo->hProcess, BaseAddress, Buffer, Size, NumberOfBytesRead);
// Did the normal memory read work?
if(ret && *NumberOfBytesRead == Size)
return true;
}
for(uint i = 0; i < nSize; i++) //read byte-per-byte
// Read byte-by-byte
// TODO: Replace this with a better method (PAGE_SIZE)
for(uint i = 0; i < Size; i++)
{
unsigned char* curaddr = (unsigned char*)lpBaseAddress + i;
unsigned char* curbuf = (unsigned char*)lpBuffer + i;
ret = MemoryReadSafe(hProcess, curaddr, curbuf, 1, 0); //try 'normal' RPM
if(!ret) //we failed
unsigned char* curaddr = (unsigned char*)BaseAddress + i;
unsigned char* curbuf = (unsigned char*)Buffer + i;
ret = MemoryReadSafe(fdProcessInfo->hProcess, curaddr, curbuf, 1, nullptr);
if(!ret)
{
if(lpNumberOfBytesRead)
*lpNumberOfBytesRead = i;
*NumberOfBytesRead = i;
SetLastError(ERROR_PARTIAL_COPY);
return false;
}
}
return true;
}
bool memwrite(HANDLE hProcess, void* lpBaseAddress, const void* lpBuffer, SIZE_T nSize, SIZE_T* lpNumberOfBytesWritten)
bool MemWrite(void* BaseAddress, void* Buffer, SIZE_T Size, SIZE_T* NumberOfBytesWritten)
{
if(!hProcess or !lpBaseAddress or !lpBuffer or !nSize) //generic failures
// Buffer must be supplied and size must be greater than 0
if(!Buffer || Size <= 0)
return false;
SIZE_T written = 0;
DWORD oldprotect = 0;
bool ret = MemoryWriteSafe(hProcess, lpBaseAddress, lpBuffer, nSize, &written);
if(ret and written == nSize) //'normal' WPM worked!
{
if(lpNumberOfBytesWritten)
*lpNumberOfBytesWritten = written;
// If the 'bytes written' parameter is null, use a temp
SIZE_T bytesWrittenTemp = 0;
if(!NumberOfBytesWritten)
NumberOfBytesWritten = &bytesWrittenTemp;
// Try a regular WriteProcessMemory call
bool ret = MemoryWriteSafe(fdProcessInfo->hProcess, BaseAddress, Buffer, Size, NumberOfBytesWritten);
if(ret and * NumberOfBytesWritten == Size)
return true;
}
for(uint i = 0; i < nSize; i++) //write byte-per-byte
// Fallback: Write byte-by-byte
for(SIZE_T i = 0; i < Size; i++)
{
unsigned char* curaddr = (unsigned char*)lpBaseAddress + i;
unsigned char* curbuf = (unsigned char*)lpBuffer + i;
ret = MemoryWriteSafe(hProcess, curaddr, curbuf, 1, 0); //try 'normal' WPM
if(!ret) //we failed
unsigned char* curaddr = (unsigned char*)BaseAddress + i;
unsigned char* curbuf = (unsigned char*)Buffer + i;
ret = MemoryWriteSafe(fdProcessInfo->hProcess, curaddr, curbuf, 1, nullptr);
if(!ret)
{
if(lpNumberOfBytesWritten)
*lpNumberOfBytesWritten = i;
*NumberOfBytesWritten = i;
SetLastError(ERROR_PARTIAL_COPY);
return false;
}
}
return true;
}
bool mempatch(HANDLE hProcess, void* lpBaseAddress, const void* lpBuffer, SIZE_T nSize, SIZE_T* lpNumberOfBytesWritten)
bool MemPatch(void* BaseAddress, void* Buffer, SIZE_T Size, SIZE_T* NumberOfBytesWritten)
{
if(!hProcess or !lpBaseAddress or !lpBuffer or !nSize) //generic failures
// Buffer and size must be valid
if(!Buffer || Size <= 0)
return false;
Memory<unsigned char*> olddata(nSize, "mempatch:olddata");
if(!memread(hProcess, lpBaseAddress, olddata, nSize, 0))
return memwrite(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesWritten);
unsigned char* newdata = (unsigned char*)lpBuffer;
for(uint i = 0; i < nSize; i++)
patchset((uint)lpBaseAddress + i, olddata[i], newdata[i]);
return memwrite(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesWritten);
// Allocate the memory
Memory<unsigned char*> olddata(Size, "mempatch:olddata");
if(!MemRead(BaseAddress, olddata, Size, nullptr))
{
// If no memory can be read, no memory can be written. Fail out
// of this function.
return false;
}
for(SIZE_T i = 0; i < Size; i++)
patchset((uint)BaseAddress + i, olddata[i], ((unsigned char*)Buffer)[i]);
return MemWrite(BaseAddress, Buffer, Size, NumberOfBytesWritten);
}
bool memisvalidreadptr(HANDLE hProcess, uint addr)
bool MemIsValidReadPtr(uint Address)
{
unsigned char a = 0;
return memread(hProcess, (void*)addr, &a, 1, 0);
return MemRead((void*)Address, &a, 1, nullptr);
}
void* memalloc(HANDLE hProcess, uint addr, SIZE_T size, DWORD fdProtect)
void* MemAllocRemote(uint Address, SIZE_T Size, DWORD Protect)
{
return VirtualAllocEx(hProcess, (void*)addr, size, MEM_RESERVE | MEM_COMMIT, fdProtect);
return VirtualAllocEx(fdProcessInfo->hProcess, (void*)Address, Size, MEM_RESERVE | MEM_COMMIT, Protect);
}
void memfree(HANDLE hProcess, uint addr)
void MemFreeRemote(uint Address)
{
VirtualFreeEx(hProcess, (void*)addr, 0, MEM_RELEASE);
VirtualFreeEx(fdProcessInfo->hProcess, (void*)Address, 0, MEM_RELEASE);
}

21
x64_dbg_dbg/memory.h
View File

@ -1,6 +1,3 @@
#ifndef _MEMORY_H
#define _MEMORY_H
#include "_global.h"
#include "addrinfo.h"
@ -9,13 +6,11 @@ typedef std::map<Range, MEMPAGE, RangeCompare> MemoryMap;
extern MemoryMap memoryPages;
extern bool bListAllPages;
void memupdatemap(HANDLE hProcess);
uint memfindbaseaddr(uint addr, uint* size, bool refresh = false);
bool memread(HANDLE hProcess, const void* lpBaseAddress, void* lpBuffer, SIZE_T nSize, SIZE_T* lpNumberOfBytesRead);
bool memwrite(HANDLE hProcess, void* lpBaseAddress, const void* lpBuffer, SIZE_T nSize, SIZE_T* lpNumberOfBytesWritten);
bool mempatch(HANDLE hProcess, void* lpBaseAddress, const void* lpBuffer, SIZE_T nSize, SIZE_T* lpNumberOfBytesWritten);
bool memisvalidreadptr(HANDLE hProcess, uint addr);
void* memalloc(HANDLE hProcess, uint addr, SIZE_T size, DWORD fdProtect);
void memfree(HANDLE hProcess, uint addr);
#endif // _MEMORY_H
void MemUpdateMap(HANDLE hProcess);
uint MemFindBaseAddr(uint addr, uint* Size, bool refresh = false);
bool MemRead(void* BaseAddress, void* Buffer, SIZE_T Size, SIZE_T* NumberOfBytesRead);
bool MemWrite(void* BaseAddress, void* Buffer, SIZE_T Size, SIZE_T* NumberOfBytesWritten);
bool MemPatch(void* BaseAddress, void* Buffer, SIZE_T Size, SIZE_T* NumberOfBytesWritten);
bool MemIsValidReadPtr(uint Address);
void* MemAllocRemote(uint Address, SIZE_T Size, DWORD Protect);
void MemFreeRemote(uint Address);

6
x64_dbg_dbg/patches.cpp
View File

@ -10,7 +10,7 @@ static PatchesInfo patches;
bool patchset(uint addr, unsigned char oldbyte, unsigned char newbyte)
{
if(!DbgIsDebugging() || !memisvalidreadptr(fdProcessInfo->hProcess, addr))
if(!DbgIsDebugging() || !MemIsValidReadPtr(addr))
return false;
if(oldbyte == newbyte)
return true; //no need to make a patch for a byte that is equal to itself
@ -66,7 +66,7 @@ bool patchdel(uint addr, bool restore)
if(found == patches.end()) //not found
return false;
if(restore)
memwrite(fdProcessInfo->hProcess, (void*)(found->second.addr + ModBaseFromAddr(addr)), &found->second.oldbyte, sizeof(char), 0);
MemWrite((void*)(found->second.addr + ModBaseFromAddr(addr)), &found->second.oldbyte, sizeof(char), 0);
patches.erase(found);
return true;
}
@ -88,7 +88,7 @@ void patchdelrange(uint start, uint end, bool restore)
if(bDelAll || (i->second.addr >= start && i->second.addr < end))
{
if(restore)
memwrite(fdProcessInfo->hProcess, (void*)(i->second.addr + modbase), &i->second.oldbyte, sizeof(char), 0);
MemWrite((void*)(i->second.addr + modbase), &i->second.oldbyte, sizeof(char), 0);
patches.erase(i++);
}
else

2
x64_dbg_dbg/plugin_loader.cpp
View File

@ -303,7 +303,7 @@ void plugincbcall(CBTYPE cbType, void* callbackInfo)
if(pluginCallbackList.at(i).cbType == cbType)
{
CBPLUGIN cbPlugin = pluginCallbackList.at(i).cbPlugin;
if(memisvalidreadptr(GetCurrentProcess(), (uint)cbPlugin))
if(!IsBadReadPtr((const void*)cbPlugin, sizeof(uint)))
cbPlugin(cbType, callbackInfo);
}
}

4
x64_dbg_dbg/reference.cpp
View File

@ -10,7 +10,7 @@ int reffind(uint addr, uint size, CBREF cbRef, void* userinfo, bool silent, cons
uint start_size;
uint base;
uint base_size;
base = memfindbaseaddr(addr, &base_size, true);
base = MemFindBaseAddr(addr, &base_size, true);
if(!base or !base_size)
{
if(!silent)
@ -33,7 +33,7 @@ int reffind(uint addr, uint size, CBREF cbRef, void* userinfo, bool silent, cons
start_size = maxsize;
}
Memory<unsigned char*> data(start_size, "reffind:data");
if(!memread(fdProcessInfo->hProcess, (const void*)start_addr, data, start_size, 0))
if(!MemRead((void*)start_addr, data, start_size, 0))
{
if(!silent)
dputs("error reading memory");

20
x64_dbg_dbg/stackinfo.cpp
View File

@ -12,17 +12,17 @@ bool stackcommentget(uint addr, STACK_COMMENT* comment)
{
uint data = 0;
memset(comment, 0, sizeof(STACK_COMMENT));
memread(fdProcessInfo->hProcess, (const void*)addr, &data, sizeof(uint), 0);
if(!memisvalidreadptr(fdProcessInfo->hProcess, data)) //the stack value is no pointer
MemRead((void*)addr, &data, sizeof(uint), 0);
if(!MemIsValidReadPtr(data)) //the stack value is no pointer
return false;
uint size = 0;
uint base = memfindbaseaddr(data, &size);
uint base = MemFindBaseAddr(data, &size);
uint readStart = data - 16 * 4;
if(readStart < base)
readStart = base;
unsigned char disasmData[256];
memread(fdProcessInfo->hProcess, (const void*)readStart, disasmData, sizeof(disasmData), 0);
MemRead((void*)readStart, disasmData, sizeof(disasmData), 0);
uint prev = disasmback(disasmData, 0, sizeof(disasmData), data - readStart, 1);
uint previousInstr = readStart + prev;
@ -118,12 +118,12 @@ void stackgetcallstack(uint csp, CALLSTACK* callstack)
callstack->total = 0;
if(!DbgIsDebugging() or csp % sizeof(uint)) //alignment problem
return;
if(!memisvalidreadptr(fdProcessInfo->hProcess, csp))
if(!MemIsValidReadPtr(csp))
return;
std::vector<CALLSTACKENTRY> callstackVector;
DWORD ticks = GetTickCount();
uint stacksize = 0;
uint stackbase = memfindbaseaddr(csp, &stacksize, false);
uint stackbase = MemFindBaseAddr(csp, &stacksize, false);
if(!stackbase) //super-fail (invalid stack address)
return;
//walk up the stack
@ -131,16 +131,16 @@ void stackgetcallstack(uint csp, CALLSTACK* callstack)
while(i != stackbase + stacksize)
{
uint data = 0;
memread(fdProcessInfo->hProcess, (const void*)i, &data, sizeof(uint), 0);
if(memisvalidreadptr(fdProcessInfo->hProcess, data)) //the stack value is a pointer
MemRead((void*)i, &data, sizeof(uint), 0);
if(MemIsValidReadPtr(data)) //the stack value is a pointer
{
uint size = 0;
uint base = memfindbaseaddr(data, &size);
uint base = MemFindBaseAddr(data, &size);
uint readStart = data - 16 * 4;
if(readStart < base)
readStart = base;
unsigned char disasmData[256];
memread(fdProcessInfo->hProcess, (const void*)readStart, disasmData, sizeof(disasmData), 0);
MemRead((void*)readStart, disasmData, sizeof(disasmData), 0);
uint prev = disasmback(disasmData, 0, sizeof(disasmData), data - readStart, 1);
uint previousInstr = readStart + prev;
BASIC_INSTRUCTION_INFO basicinfo;

3
x64_dbg_dbg/thread.cpp
View File

@ -34,6 +34,7 @@ void ThreadExit(DWORD dwThreadId)
{
EXCLUSIVE_ACQUIRE(LockThreads);
// Don't use a foreach loop here because of the erase() call
for(auto itr = threadList.begin(); itr != threadList.end(); itr++)
{
if(itr->ThreadId == dwThreadId)
@ -119,7 +120,7 @@ bool ThreadGetTeb(uint TEBAddress, TEB* Teb)
//
memset(Teb, 0, sizeof(TEB));
return memread(fdProcessInfo->hProcess, (void*)TEBAddress, Teb, sizeof(TEB), nullptr);
return MemRead((void*)TEBAddress, Teb, sizeof(TEB), nullptr);
}
int ThreadGetSuspendCount(HANDLE Thread)

22
x64_dbg_dbg/threading.cpp
View File

@ -61,24 +61,4 @@ void SectionLockerGlobal::Deinitialize()
}
m_Initialized = false;
}
/*
SharedSectionLocker::SharedSectionLocker(SectionLock LockIndex)
: ExclusiveSectionLocker(LockIndex)
{
// Nothing to do here; parent class constructor is called
}
void SharedSectionLocker::Lock()
{
AcquireSRWLockShared(m_Lock);
m_LockCount++;
}
void SharedSectionLocker::Unlock()
{
m_LockCount--;
ReleaseSRWLockShared(m_Lock);
}
*/
}

4
x64_dbg_dbg/value.cpp
View File

@ -1477,7 +1477,7 @@ bool valfromstring(const char* string, uint* value, bool silent, bool baseonly,
return false;
uint addr = *value;
*value = 0;
if(!memread(fdProcessInfo->hProcess, (void*)addr, value, read_size, 0))
if(!MemRead((void*)addr, value, read_size, 0))
{
if(!silent)
dputs("failed to read memory");
@ -2025,7 +2025,7 @@ bool valtostring(const char* string, uint* value, bool silent)
{
return false;
}
if(!mempatch(fdProcessInfo->hProcess, (void*)temp, value, read_size, 0))
if(!MemPatch((void*)temp, value, read_size, 0))
{
if(!silent)
dputs("failed to write memory");

72
x64_dbg_dbg/variable.cpp
View File

@ -6,15 +6,14 @@ static VAR* vars;
static void varsetvalue(VAR* var, VAR_VALUE* value)
{
switch(var->value.type)
// VAR_STRING needs to be freed before destroying it
if(var->value.type == VAR_STRING)
{
case VAR_STRING:
var->value.u.data->clear();
delete var->value.u.data;
break;
default:
break;
}
// Replace all information in the struct
memcpy(&var->value, value, sizeof(VAR_VALUE));
}
@ -46,32 +45,37 @@ static bool varset(const char* name, VAR_VALUE* value, bool setreadonly)
void varinit()
{
varfree();
//General variables
// General variables
varnew("$result\1$res", 0, VAR_SYSTEM);
varnew("$result1\1$res1", 0, VAR_SYSTEM);
varnew("$result2\1$res2", 0, VAR_SYSTEM);
varnew("$result3\1$res3", 0, VAR_SYSTEM);
varnew("$result4\1$res4", 0, VAR_SYSTEM);
//InitDebug variables
varnew("$hProcess\1$hp", 0, VAR_READONLY);
varnew("$pid", 0, VAR_READONLY);
//hidden variables
// InitDebug variables
varnew("$hProcess\1$hp", 0, VAR_READONLY); // Process handle
varnew("$pid", 0, VAR_READONLY); // Process ID
// Hidden variables
varnew("$ans\1$an", 0, VAR_HIDDEN);
//read-only variables
varnew("$lastalloc", 0, VAR_READONLY);
varnew("$_EZ_FLAG", 0, VAR_READONLY); //equal/zero flag for internal use (1=equal, 0=unequal)
varnew("$_BS_FLAG", 0, VAR_READONLY); //bigger/smaller flag for internal use (1=bigger, 0=smaller)
// Read-only variables
varnew("$lastalloc", 0, VAR_READONLY); // Last memory allocation
varnew("$_EZ_FLAG", 0, VAR_READONLY); // Equal/zero flag for internal use (1=equal, 0=unequal)
varnew("$_BS_FLAG", 0, VAR_READONLY); // Bigger/smaller flag for internal use (1=bigger, 0=smaller)
}
void varfree()
{
CriticalSectionLocker locker(LockVariables);
EXCLUSIVE_ACQUIRE(LockVariables);
variables.clear();
}
VAR* vargetptr()
{
return 0;
// TODO: Implement this? Or remove it.
return nullptr;
}
bool varnew(const char* name, uint value, VAR_TYPE type)
@ -109,7 +113,7 @@ bool varnew(const char* name, uint value, VAR_TYPE type)
static bool varget(const char* name, VAR_VALUE* value, int* size, VAR_TYPE* type)
{
EXCLUSIVE_ACQUIRE(LockVariables);
SHARED_ACQUIRE(LockVariables);
String name_;
if(*name != '$')
@ -121,7 +125,7 @@ static bool varget(const char* name, VAR_VALUE* value, int* size, VAR_TYPE* type
if(found->second.alias.length())
{
// Release the lock (potential deadlock here)
EXCLUSIVE_RELEASE();
SHARED_RELEASE();
return varget(found->second.alias.c_str(), value, size, type);
}
@ -231,7 +235,8 @@ bool vardel(const char* name, bool delsystem)
bool vargettype(const char* name, VAR_TYPE* type, VAR_VALUE_TYPE* valtype)
{
CriticalSectionLocker locker(LockVariables);
SHARED_ACQUIRE(LockVariables);
String name_;
if(*name != '$')
name_ = "$";
@ -248,18 +253,29 @@ bool vargettype(const char* name, VAR_TYPE* type, VAR_VALUE_TYPE* valtype)
return true;
}
bool varenum(VAR* entries, size_t* cbsize)
bool varenum(VAR* List, size_t* Size)
{
CriticalSectionLocker locker(LockVariables);
if(!entries && !cbsize || !variables.size())
// A list or size must be requested
if(!List && !Size)
return false;
if(!entries && cbsize)
SHARED_ACQUIRE(LockVariables);
if(Size)
{
*cbsize = variables.size() * sizeof(VAR);
return true;
// Size requested, so return it
*Size = variables.size() * sizeof(VAR);
if(!List)
return true;
}
int j = 0;
for(VariableMap::iterator i = variables.begin(); i != variables.end(); ++i, j++)
entries[j] = i->second;
// Fill out all list entries
for(auto & itr : variables)
{
*List = itr.second;
List++;
}
return true;
}