1424 lines
41 KiB
C++
1424 lines
41 KiB
C++
#include "value.h"
|
|
#include "variable.h"
|
|
#include "debugger.h"
|
|
#include "console.h"
|
|
#include "math.h"
|
|
#include "memory.h"
|
|
#include "addrinfo.h"
|
|
#include <psapi.h>
|
|
|
|
static bool dosignedcalc=false;
|
|
|
|
bool valuesignedcalc()
|
|
{
|
|
return dosignedcalc;
|
|
}
|
|
|
|
void valuesetsignedcalc(bool a)
|
|
{
|
|
dosignedcalc=a;
|
|
}
|
|
|
|
static bool isflag(const char* string)
|
|
{
|
|
if(scmp(string, "cf"))
|
|
return true;
|
|
if(scmp(string, "pf"))
|
|
return true;
|
|
if(scmp(string, "af"))
|
|
return true;
|
|
if(scmp(string, "zf"))
|
|
return true;
|
|
if(scmp(string, "sf"))
|
|
return true;
|
|
if(scmp(string, "tf"))
|
|
return true;
|
|
if(scmp(string, "if"))
|
|
return true;
|
|
if(scmp(string, "df"))
|
|
return true;
|
|
if(scmp(string, "of"))
|
|
return true;
|
|
if(scmp(string, "rf"))
|
|
return true;
|
|
if(scmp(string, "vm"))
|
|
return true;
|
|
if(scmp(string, "ac"))
|
|
return true;
|
|
if(scmp(string, "vif"))
|
|
return true;
|
|
if(scmp(string, "vip"))
|
|
return true;
|
|
if(scmp(string, "id"))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
static bool isregister(const char* string)
|
|
{
|
|
if(scmp(string, "eax"))
|
|
return true;
|
|
if(scmp(string, "ebx"))
|
|
return true;
|
|
if(scmp(string, "ecx"))
|
|
return true;
|
|
if(scmp(string, "edx"))
|
|
return true;
|
|
if(scmp(string, "edi"))
|
|
return true;
|
|
if(scmp(string, "esi"))
|
|
return true;
|
|
if(scmp(string, "ebp"))
|
|
return true;
|
|
if(scmp(string, "esp"))
|
|
return true;
|
|
if(scmp(string, "eip"))
|
|
return true;
|
|
if(scmp(string, "eflags"))
|
|
return true;
|
|
|
|
if(scmp(string, "ax"))
|
|
return true;
|
|
if(scmp(string, "bx"))
|
|
return true;
|
|
if(scmp(string, "cx"))
|
|
return true;
|
|
if(scmp(string, "dx"))
|
|
return true;
|
|
if(scmp(string, "si"))
|
|
return true;
|
|
if(scmp(string, "di"))
|
|
return true;
|
|
if(scmp(string, "bp"))
|
|
return true;
|
|
if(scmp(string, "sp"))
|
|
return true;
|
|
if(scmp(string, "ip"))
|
|
return true;
|
|
|
|
if(scmp(string, "ah"))
|
|
return true;
|
|
if(scmp(string, "al"))
|
|
return true;
|
|
if(scmp(string, "bh"))
|
|
return true;
|
|
if(scmp(string, "bl"))
|
|
return true;
|
|
if(scmp(string, "ch"))
|
|
return true;
|
|
if(scmp(string, "cl"))
|
|
return true;
|
|
if(scmp(string, "dh"))
|
|
return true;
|
|
if(scmp(string, "dl"))
|
|
return true;
|
|
if(scmp(string, "sih"))
|
|
return true;
|
|
if(scmp(string, "sil"))
|
|
return true;
|
|
if(scmp(string, "dih"))
|
|
return true;
|
|
if(scmp(string, "dil"))
|
|
return true;
|
|
if(scmp(string, "bph"))
|
|
return true;
|
|
if(scmp(string, "bpl"))
|
|
return true;
|
|
if(scmp(string, "sph"))
|
|
return true;
|
|
if(scmp(string, "spl"))
|
|
return true;
|
|
if(scmp(string, "iph"))
|
|
return true;
|
|
if(scmp(string, "ipl"))
|
|
return true;
|
|
|
|
if(scmp(string, "dr0"))
|
|
return true;
|
|
if(scmp(string, "dr1"))
|
|
return true;
|
|
if(scmp(string, "dr2"))
|
|
return true;
|
|
if(scmp(string, "dr3"))
|
|
return true;
|
|
if(scmp(string, "dr6") or scmp(string, "dr4"))
|
|
return true;
|
|
if(scmp(string, "dr7") or scmp(string, "dr5"))
|
|
return true;
|
|
|
|
if(scmp(string, "cip"))
|
|
return true;
|
|
if(scmp(string, "csp"))
|
|
return true;
|
|
if(scmp(string, "cflags"))
|
|
return true;
|
|
|
|
if(scmp(string, "gs"))
|
|
return true;
|
|
if(scmp(string, "fs"))
|
|
return true;
|
|
if(scmp(string, "es"))
|
|
return true;
|
|
if(scmp(string, "ds"))
|
|
return true;
|
|
if(scmp(string, "cs"))
|
|
return true;
|
|
if(scmp(string, "ss"))
|
|
return true;
|
|
|
|
#ifndef _WIN64
|
|
return false;
|
|
#endif // _WIN64
|
|
if(scmp(string, "rax"))
|
|
return true;
|
|
if(scmp(string, "rbx"))
|
|
return true;
|
|
if(scmp(string, "rcx"))
|
|
return true;
|
|
if(scmp(string, "rdx"))
|
|
return true;
|
|
if(scmp(string, "rdi"))
|
|
return true;
|
|
if(scmp(string, "rsi"))
|
|
return true;
|
|
if(scmp(string, "rbp"))
|
|
return true;
|
|
if(scmp(string, "rsp"))
|
|
return true;
|
|
if(scmp(string, "rip"))
|
|
return true;
|
|
if(scmp(string, "rflags"))
|
|
return true;
|
|
if(scmp(string, "r8"))
|
|
return true;
|
|
if(scmp(string, "r9"))
|
|
return true;
|
|
if(scmp(string, "r10"))
|
|
return true;
|
|
if(scmp(string, "r11"))
|
|
return true;
|
|
if(scmp(string, "r12"))
|
|
return true;
|
|
if(scmp(string, "r13"))
|
|
return true;
|
|
if(scmp(string, "r14"))
|
|
return true;
|
|
if(scmp(string, "r15"))
|
|
return true;
|
|
if(scmp(string, "r8d"))
|
|
return true;
|
|
if(scmp(string, "r9d"))
|
|
return true;
|
|
if(scmp(string, "r10d"))
|
|
return true;
|
|
if(scmp(string, "r11d"))
|
|
return true;
|
|
if(scmp(string, "r12d"))
|
|
return true;
|
|
if(scmp(string, "r13d"))
|
|
return true;
|
|
if(scmp(string, "r14d"))
|
|
return true;
|
|
if(scmp(string, "r15d"))
|
|
return true;
|
|
if(scmp(string, "r8w"))
|
|
return true;
|
|
if(scmp(string, "r9w"))
|
|
return true;
|
|
if(scmp(string, "r10w"))
|
|
return true;
|
|
if(scmp(string, "r11w"))
|
|
return true;
|
|
if(scmp(string, "r12w"))
|
|
return true;
|
|
if(scmp(string, "r13w"))
|
|
return true;
|
|
if(scmp(string, "r14w"))
|
|
return true;
|
|
if(scmp(string, "r15w"))
|
|
return true;
|
|
if(scmp(string, "r8b"))
|
|
return true;
|
|
if(scmp(string, "r9b"))
|
|
return true;
|
|
if(scmp(string, "r10b"))
|
|
return true;
|
|
if(scmp(string, "r11b"))
|
|
return true;
|
|
if(scmp(string, "r12b"))
|
|
return true;
|
|
if(scmp(string, "r13b"))
|
|
return true;
|
|
if(scmp(string, "r14b"))
|
|
return true;
|
|
if(scmp(string, "r15b"))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool valflagfromstring(unsigned int eflags, const char* string)
|
|
{
|
|
if(scmp(string, "cf"))
|
|
return (bool)((int)(eflags&0x1)!=0);
|
|
if(scmp(string, "pf"))
|
|
return (bool)((int)(eflags&0x4)!=0);
|
|
if(scmp(string, "af"))
|
|
return (bool)((int)(eflags&0x10)!=0);
|
|
if(scmp(string, "zf"))
|
|
return (bool)((int)(eflags&0x40)!=0);
|
|
if(scmp(string, "sf"))
|
|
return (bool)((int)(eflags&0x80)!=0);
|
|
if(scmp(string, "tf"))
|
|
return (bool)((int)(eflags&0x100)!=0);
|
|
if(scmp(string, "if"))
|
|
return (bool)((int)(eflags&0x200)!=0);
|
|
if(scmp(string, "df"))
|
|
return (bool)((int)(eflags&0x400)!=0);
|
|
if(scmp(string, "of"))
|
|
return (bool)((int)(eflags&0x800)!=0);
|
|
if(scmp(string, "rf"))
|
|
return (bool)((int)(eflags&0x10000)!=0);
|
|
if(scmp(string, "vm"))
|
|
return (bool)((int)(eflags&0x20000)!=0);
|
|
if(scmp(string, "ac"))
|
|
return (bool)((int)(eflags&0x40000)!=0);
|
|
if(scmp(string, "vif"))
|
|
return (bool)((int)(eflags&0x80000)!=0);
|
|
if(scmp(string, "vip"))
|
|
return (bool)((int)(eflags&0x100000)!=0);
|
|
if(scmp(string, "id"))
|
|
return (bool)((int)(eflags&0x200000)!=0);
|
|
return false;
|
|
}
|
|
|
|
static bool setflag(const char* string, bool set)
|
|
{
|
|
uint eflags=GetContextData(UE_CFLAGS);
|
|
uint xorval=0;
|
|
uint flag=0;
|
|
if(scmp(string, "cf"))
|
|
flag=0x1;
|
|
else if(scmp(string, "pf"))
|
|
flag=0x4;
|
|
else if(scmp(string, "af"))
|
|
flag=0x10;
|
|
else if(scmp(string, "zf"))
|
|
flag=0x40;
|
|
else if(scmp(string, "sf"))
|
|
flag=0x80;
|
|
else if(scmp(string, "tf"))
|
|
flag=0x100;
|
|
else if(scmp(string, "if"))
|
|
flag=0x200;
|
|
else if(scmp(string, "df"))
|
|
flag=0x400;
|
|
else if(scmp(string, "of"))
|
|
flag=0x800;
|
|
else if(scmp(string, "rf"))
|
|
flag=0x10000;
|
|
else if(scmp(string, "vm"))
|
|
flag=0x20000;
|
|
else if(scmp(string, "ac"))
|
|
flag=0x40000;
|
|
else if(scmp(string, "vif"))
|
|
flag=0x80000;
|
|
else if(scmp(string, "vip"))
|
|
flag=0x100000;
|
|
else if(scmp(string, "id"))
|
|
flag=0x200000;
|
|
if(eflags&flag and !set)
|
|
xorval=flag;
|
|
else if(set)
|
|
xorval=flag;
|
|
return SetContextData(UE_CFLAGS, eflags^xorval);
|
|
}
|
|
|
|
static uint getregister(int* size, const char* string)
|
|
{
|
|
if(size)
|
|
*size=4;
|
|
if(scmp(string, "eax"))
|
|
{
|
|
return GetContextData(UE_EAX);
|
|
}
|
|
if(scmp(string, "ebx"))
|
|
{
|
|
return GetContextData(UE_EBX);
|
|
}
|
|
if(scmp(string, "ecx"))
|
|
{
|
|
return GetContextData(UE_ECX);
|
|
}
|
|
if(scmp(string, "edx"))
|
|
{
|
|
return GetContextData(UE_EDX);
|
|
}
|
|
if(scmp(string, "edi"))
|
|
{
|
|
return GetContextData(UE_EDI);
|
|
}
|
|
if(scmp(string, "esi"))
|
|
{
|
|
return GetContextData(UE_ESI);
|
|
}
|
|
if(scmp(string, "ebp"))
|
|
{
|
|
return GetContextData(UE_EBP);
|
|
}
|
|
if(scmp(string, "esp"))
|
|
{
|
|
return GetContextData(UE_ESP);
|
|
}
|
|
if(scmp(string, "eip"))
|
|
{
|
|
return GetContextData(UE_EIP);
|
|
}
|
|
if(scmp(string, "eflags"))
|
|
{
|
|
return GetContextData(UE_EFLAGS);
|
|
}
|
|
|
|
if(scmp(string, "gs"))
|
|
{
|
|
return GetContextData(UE_SEG_GS);
|
|
}
|
|
if(scmp(string, "fs"))
|
|
{
|
|
return GetContextData(UE_SEG_FS);
|
|
}
|
|
if(scmp(string, "es"))
|
|
{
|
|
return GetContextData(UE_SEG_ES);
|
|
}
|
|
if(scmp(string, "ds"))
|
|
{
|
|
return GetContextData(UE_SEG_DS);
|
|
}
|
|
if(scmp(string, "cs"))
|
|
{
|
|
return GetContextData(UE_SEG_CS);
|
|
}
|
|
if(scmp(string, "ss"))
|
|
{
|
|
return GetContextData(UE_SEG_SS);
|
|
}
|
|
|
|
if(size)
|
|
*size=2;
|
|
if(scmp(string, "ax"))
|
|
{
|
|
uint val=GetContextData(UE_EAX);
|
|
return val&0xFFFF;
|
|
}
|
|
if(scmp(string, "bx"))
|
|
{
|
|
uint val=GetContextData(UE_EBX);
|
|
return val&0xFFFF;
|
|
}
|
|
if(scmp(string, "cx"))
|
|
{
|
|
uint val=GetContextData(UE_ECX);
|
|
return val&0xFFFF;
|
|
}
|
|
if(scmp(string, "dx"))
|
|
{
|
|
uint val=GetContextData(UE_EDX);
|
|
return val&0xFFFF;
|
|
}
|
|
if(scmp(string, "si"))
|
|
{
|
|
uint val=GetContextData(UE_ESI);
|
|
return val&0xFFFF;
|
|
}
|
|
if(scmp(string, "di"))
|
|
{
|
|
uint val=GetContextData(UE_EDI);
|
|
return val&0xFFFF;
|
|
}
|
|
if(scmp(string, "bp"))
|
|
{
|
|
uint val=GetContextData(UE_EBP);
|
|
return val&0xFFFF;
|
|
}
|
|
if(scmp(string, "sp"))
|
|
{
|
|
uint val=GetContextData(UE_ESP);
|
|
return val&0xFFFF;
|
|
}
|
|
if(scmp(string, "ip"))
|
|
{
|
|
uint val=GetContextData(UE_EIP);
|
|
return val&0xFFFF;
|
|
}
|
|
|
|
if(size)
|
|
*size=1;
|
|
if(scmp(string, "ah"))
|
|
{
|
|
uint val=GetContextData(UE_EAX);
|
|
return (val>>8)&0xFF;
|
|
}
|
|
if(scmp(string, "al"))
|
|
{
|
|
uint val=GetContextData(UE_EAX);
|
|
return val&0xFF;
|
|
}
|
|
if(scmp(string, "bh"))
|
|
{
|
|
uint val=GetContextData(UE_EBX);
|
|
return (val>>8)&0xFF;
|
|
}
|
|
if(scmp(string, "bl"))
|
|
{
|
|
uint val=GetContextData(UE_EBX);
|
|
return val&0xFF;
|
|
}
|
|
if(scmp(string, "ch"))
|
|
{
|
|
uint val=GetContextData(UE_ECX);
|
|
return (val>>8)&0xFF;
|
|
}
|
|
if(scmp(string, "cl"))
|
|
{
|
|
uint val=GetContextData(UE_ECX);
|
|
return val&0xFF;
|
|
}
|
|
if(scmp(string, "dh"))
|
|
{
|
|
uint val=GetContextData(UE_EDX);
|
|
return (val>>8)&0xFF;
|
|
}
|
|
if(scmp(string, "dl"))
|
|
{
|
|
uint val=GetContextData(UE_EDX);
|
|
return val&0xFF;
|
|
}
|
|
if(scmp(string, "sih"))
|
|
{
|
|
uint val=GetContextData(UE_ESI);
|
|
return (val>>8)&0xFF;
|
|
}
|
|
if(scmp(string, "sil"))
|
|
{
|
|
uint val=GetContextData(UE_ESI);
|
|
return val&0xFF;
|
|
}
|
|
if(scmp(string, "dih"))
|
|
{
|
|
uint val=GetContextData(UE_EDI);
|
|
return (val>>8)&0xFF;
|
|
}
|
|
if(scmp(string, "dil"))
|
|
{
|
|
uint val=GetContextData(UE_EDI);
|
|
return val&0xFF;
|
|
}
|
|
if(scmp(string, "bph"))
|
|
{
|
|
uint val=GetContextData(UE_EBP);
|
|
return (val>>8)&0xFF;
|
|
}
|
|
if(scmp(string, "bpl"))
|
|
{
|
|
uint val=GetContextData(UE_EBP);
|
|
return val&0xFF;
|
|
}
|
|
if(scmp(string, "sph"))
|
|
{
|
|
uint val=GetContextData(UE_ESP);
|
|
return (val>>8)&0xFF;
|
|
}
|
|
if(scmp(string, "spl"))
|
|
{
|
|
uint val=GetContextData(UE_ESP);
|
|
return val&0xFF;
|
|
}
|
|
if(scmp(string, "iph"))
|
|
{
|
|
uint val=GetContextData(UE_EIP);
|
|
return (val>>8)&0xFF;
|
|
}
|
|
if(scmp(string, "ipl"))
|
|
{
|
|
uint val=GetContextData(UE_EIP);
|
|
return val&0xFF;
|
|
}
|
|
|
|
if(size)
|
|
*size=sizeof(uint);
|
|
if(scmp(string, "dr0"))
|
|
{
|
|
return GetContextData(UE_DR0);
|
|
}
|
|
if(scmp(string, "dr1"))
|
|
{
|
|
return GetContextData(UE_DR1);
|
|
}
|
|
if(scmp(string, "dr2"))
|
|
{
|
|
return GetContextData(UE_DR2);
|
|
}
|
|
if(scmp(string, "dr3"))
|
|
{
|
|
return GetContextData(UE_DR3);
|
|
}
|
|
if(scmp(string, "dr6") or scmp(string, "dr4"))
|
|
{
|
|
return GetContextData(UE_DR6);
|
|
}
|
|
if(scmp(string, "dr7") or scmp(string, "dr5"))
|
|
{
|
|
return GetContextData(UE_DR7);
|
|
}
|
|
|
|
if(scmp(string, "cip"))
|
|
{
|
|
return GetContextData(UE_CIP);
|
|
}
|
|
if(scmp(string, "csp"))
|
|
{
|
|
return GetContextData(UE_CSP);
|
|
}
|
|
if(scmp(string, "cflags"))
|
|
{
|
|
return GetContextData(UE_CFLAGS);
|
|
}
|
|
|
|
#ifdef _WIN64
|
|
if(size)
|
|
*size=8;
|
|
if(scmp(string, "rax"))
|
|
{
|
|
return GetContextData(UE_RAX);
|
|
}
|
|
if(scmp(string, "rbx"))
|
|
{
|
|
return GetContextData(UE_RBX);
|
|
}
|
|
if(scmp(string, "rcx"))
|
|
{
|
|
return GetContextData(UE_RCX);
|
|
}
|
|
if(scmp(string, "rdx"))
|
|
{
|
|
return GetContextData(UE_RDX);
|
|
}
|
|
if(scmp(string, "rdi"))
|
|
{
|
|
return GetContextData(UE_RDI);
|
|
}
|
|
if(scmp(string, "rsi"))
|
|
{
|
|
return GetContextData(UE_RSI);
|
|
}
|
|
if(scmp(string, "rbp"))
|
|
{
|
|
return GetContextData(UE_RBP);
|
|
}
|
|
if(scmp(string, "rsp"))
|
|
{
|
|
return GetContextData(UE_RSP);
|
|
}
|
|
if(scmp(string, "rip"))
|
|
{
|
|
return GetContextData(UE_RIP);
|
|
}
|
|
if(scmp(string, "rflags"))
|
|
{
|
|
return GetContextData(UE_RFLAGS);
|
|
}
|
|
if(scmp(string, "r8"))
|
|
{
|
|
return GetContextData(UE_R8);
|
|
}
|
|
if(scmp(string, "r9"))
|
|
{
|
|
return GetContextData(UE_R9);
|
|
}
|
|
if(scmp(string, "r10"))
|
|
{
|
|
return GetContextData(UE_R10);
|
|
}
|
|
if(scmp(string, "r11"))
|
|
{
|
|
return GetContextData(UE_R11);
|
|
}
|
|
if(scmp(string, "r12"))
|
|
{
|
|
return GetContextData(UE_R12);
|
|
}
|
|
if(scmp(string, "r13"))
|
|
{
|
|
return GetContextData(UE_R13);
|
|
}
|
|
if(scmp(string, "r14"))
|
|
{
|
|
return GetContextData(UE_R14);
|
|
}
|
|
if(scmp(string, "r15"))
|
|
{
|
|
return GetContextData(UE_R15);
|
|
}
|
|
|
|
if(size)
|
|
*size=4;
|
|
if(scmp(string, "r8d"))
|
|
{
|
|
return GetContextData(UE_R8)&0xFFFFFFFF;
|
|
}
|
|
if(scmp(string, "r9d"))
|
|
{
|
|
return GetContextData(UE_R9)&0xFFFFFFFF;
|
|
}
|
|
if(scmp(string, "r10d"))
|
|
{
|
|
return GetContextData(UE_R10)&0xFFFFFFFF;
|
|
}
|
|
if(scmp(string, "r11d"))
|
|
{
|
|
return GetContextData(UE_R11)&0xFFFFFFFF;
|
|
}
|
|
if(scmp(string, "r12d"))
|
|
{
|
|
return GetContextData(UE_R12)&0xFFFFFFFF;
|
|
}
|
|
if(scmp(string, "r13d"))
|
|
{
|
|
return GetContextData(UE_R13)&0xFFFFFFFF;
|
|
}
|
|
if(scmp(string, "r14d"))
|
|
{
|
|
return GetContextData(UE_R14)&0xFFFFFFFF;
|
|
}
|
|
if(scmp(string, "r15d"))
|
|
{
|
|
return GetContextData(UE_R15)&0xFFFFFFFF;
|
|
}
|
|
|
|
if(size)
|
|
*size=2;
|
|
if(scmp(string, "r8w"))
|
|
{
|
|
return GetContextData(UE_R8)&0xFFFF;
|
|
}
|
|
if(scmp(string, "r9w"))
|
|
{
|
|
return GetContextData(UE_R9)&0xFFFF;
|
|
}
|
|
if(scmp(string, "r10w"))
|
|
{
|
|
return GetContextData(UE_R10)&0xFFFF;
|
|
}
|
|
if(scmp(string, "r11w"))
|
|
{
|
|
return GetContextData(UE_R11)&0xFFFF;
|
|
}
|
|
if(scmp(string, "r12w"))
|
|
{
|
|
return GetContextData(UE_R12)&0xFFFF;
|
|
}
|
|
if(scmp(string, "r13w"))
|
|
{
|
|
return GetContextData(UE_R13)&0xFFFF;
|
|
}
|
|
if(scmp(string, "r14w"))
|
|
{
|
|
return GetContextData(UE_R14)&0xFFFF;
|
|
}
|
|
if(scmp(string, "r15w"))
|
|
{
|
|
return GetContextData(UE_R15)&0xFFFF;
|
|
}
|
|
|
|
if(size)
|
|
*size=1;
|
|
if(scmp(string, "r8b"))
|
|
{
|
|
return GetContextData(UE_R8)&0xFF;
|
|
}
|
|
if(scmp(string, "r9b"))
|
|
{
|
|
return GetContextData(UE_R9)&0xFF;
|
|
}
|
|
if(scmp(string, "r10b"))
|
|
{
|
|
return GetContextData(UE_R10)&0xFF;
|
|
}
|
|
if(scmp(string, "r11b"))
|
|
{
|
|
return GetContextData(UE_R11)&0xFF;
|
|
}
|
|
if(scmp(string, "r12b"))
|
|
{
|
|
return GetContextData(UE_R12)&0xFF;
|
|
}
|
|
if(scmp(string, "r13b"))
|
|
{
|
|
return GetContextData(UE_R13)&0xFF;
|
|
}
|
|
if(scmp(string, "r14b"))
|
|
{
|
|
return GetContextData(UE_R14)&0xFF;
|
|
}
|
|
if(scmp(string, "r15b"))
|
|
{
|
|
return GetContextData(UE_R15)&0xFF;
|
|
}
|
|
#endif //_WIN64
|
|
|
|
if(size)
|
|
*size=0;
|
|
return 0;
|
|
}
|
|
|
|
static bool setregister(const char* string, uint value)
|
|
{
|
|
if(scmp(string, "eax"))
|
|
return SetContextData(UE_EAX, value&0xFFFFFFFF);
|
|
if(scmp(string, "ebx"))
|
|
return SetContextData(UE_EBX, value&0xFFFFFFFF);
|
|
if(scmp(string, "ecx"))
|
|
return SetContextData(UE_ECX, value&0xFFFFFFFF);
|
|
if(scmp(string, "edx"))
|
|
return SetContextData(UE_EDX, value&0xFFFFFFFF);
|
|
if(scmp(string, "edi"))
|
|
return SetContextData(UE_EDI, value&0xFFFFFFFF);
|
|
if(scmp(string, "esi"))
|
|
return SetContextData(UE_ESI, value&0xFFFFFFFF);
|
|
if(scmp(string, "ebp"))
|
|
return SetContextData(UE_EBP, value&0xFFFFFFFF);
|
|
if(scmp(string, "esp"))
|
|
return SetContextData(UE_ESP, value&0xFFFFFFFF);
|
|
if(scmp(string, "eip"))
|
|
return SetContextData(UE_EIP, value&0xFFFFFFFF);
|
|
if(scmp(string, "eflags"))
|
|
return SetContextData(UE_EFLAGS, value&0xFFFFFFFF);
|
|
|
|
if(scmp(string, "gs"))
|
|
return SetContextData(UE_SEG_GS, value&0xFFFF);
|
|
if(scmp(string, "fs"))
|
|
return SetContextData(UE_SEG_FS, value&0xFFFF);
|
|
if(scmp(string, "es"))
|
|
return SetContextData(UE_SEG_ES, value&0xFFFF);
|
|
if(scmp(string, "ds"))
|
|
return SetContextData(UE_SEG_DS, value&0xFFFF);
|
|
if(scmp(string, "cs"))
|
|
return SetContextData(UE_SEG_CS, value&0xFFFF);
|
|
if(scmp(string, "ss"))
|
|
return SetContextData(UE_SEG_SS, value&0xFFFF);
|
|
|
|
if(scmp(string, "ax"))
|
|
return SetContextData(UE_EAX, (value&0xFFFF)|(GetContextData(UE_EAX)&0xFFFF0000));
|
|
if(scmp(string, "bx"))
|
|
return SetContextData(UE_EBX, (value&0xFFFF)|(GetContextData(UE_EBX)&0xFFFF0000));
|
|
if(scmp(string, "cx"))
|
|
return SetContextData(UE_ECX, (value&0xFFFF)|(GetContextData(UE_ECX)&0xFFFF0000));
|
|
if(scmp(string, "dx"))
|
|
return SetContextData(UE_EDX, (value&0xFFFF)|(GetContextData(UE_EDX)&0xFFFF0000));
|
|
if(scmp(string, "si"))
|
|
return SetContextData(UE_ESI, (value&0xFFFF)|(GetContextData(UE_ESI)&0xFFFF0000));
|
|
if(scmp(string, "di"))
|
|
return SetContextData(UE_EDI, (value&0xFFFF)|(GetContextData(UE_EDI)&0xFFFF0000));
|
|
if(scmp(string, "bp"))
|
|
return SetContextData(UE_EBP, (value&0xFFFF)|(GetContextData(UE_EBP)&0xFFFF0000));
|
|
if(scmp(string, "sp"))
|
|
return SetContextData(UE_ESP, (value&0xFFFF)|(GetContextData(UE_ESP)&0xFFFF0000));
|
|
if(scmp(string, "ip"))
|
|
return SetContextData(UE_EIP, (value&0xFFFF)|(GetContextData(UE_EIP)&0xFFFF0000));
|
|
|
|
if(scmp(string, "ah"))
|
|
return SetContextData(UE_EAX, ((value&0xFF)<<8)|(GetContextData(UE_EAX)&0xFFFF00FF));
|
|
if(scmp(string, "al"))
|
|
return SetContextData(UE_EAX, (value&0xFF)|(GetContextData(UE_EAX)&0xFFFFFF00));
|
|
if(scmp(string, "bh"))
|
|
return SetContextData(UE_EBX, ((value&0xFF)<<8)|(GetContextData(UE_EBX)&0xFFFF00FF));
|
|
if(scmp(string, "bl"))
|
|
return SetContextData(UE_EBX, (value&0xFF)|(GetContextData(UE_EBX)&0xFFFFFF00));
|
|
if(scmp(string, "ch"))
|
|
return SetContextData(UE_ECX, ((value&0xFF)<<8)|(GetContextData(UE_ECX)&0xFFFF00FF));
|
|
if(scmp(string, "cl"))
|
|
return SetContextData(UE_ECX, (value&0xFF)|(GetContextData(UE_ECX)&0xFFFFFF00));
|
|
if(scmp(string, "dh"))
|
|
return SetContextData(UE_EDX, ((value&0xFF)<<8)|(GetContextData(UE_EDX)&0xFFFF00FF));
|
|
if(scmp(string, "dl"))
|
|
return SetContextData(UE_EDX, (value&0xFF)|(GetContextData(UE_EDX)&0xFFFFFF00));
|
|
if(scmp(string, "sih"))
|
|
return SetContextData(UE_ESI, ((value&0xFF)<<8)|(GetContextData(UE_ESI)&0xFFFF00FF));
|
|
if(scmp(string, "sil"))
|
|
return SetContextData(UE_ESI, (value&0xFF)|(GetContextData(UE_ESI)&0xFFFFFF00));
|
|
if(scmp(string, "dih"))
|
|
return SetContextData(UE_EDI, ((value&0xFF)<<8)|(GetContextData(UE_EDI)&0xFFFF00FF));
|
|
if(scmp(string, "dil"))
|
|
return SetContextData(UE_EDI, (value&0xFF)|(GetContextData(UE_EDI)&0xFFFFFF00));
|
|
if(scmp(string, "bph"))
|
|
return SetContextData(UE_EBP, ((value&0xFF)<<8)|(GetContextData(UE_EBP)&0xFFFF00FF));
|
|
if(scmp(string, "bpl"))
|
|
return SetContextData(UE_EBP, (value&0xFF)|(GetContextData(UE_EBP)&0xFFFFFF00));
|
|
if(scmp(string, "sph"))
|
|
return SetContextData(UE_ESP, ((value&0xFF)<<8)|(GetContextData(UE_ESP)&0xFFFF00FF));
|
|
if(scmp(string, "spl"))
|
|
return SetContextData(UE_ESP, (value&0xFF)|(GetContextData(UE_ESP)&0xFFFFFF00));
|
|
if(scmp(string, "iph"))
|
|
return SetContextData(UE_EIP, ((value&0xFF)<<8)|(GetContextData(UE_EIP)&0xFFFF00FF));
|
|
if(scmp(string, "ipl"))
|
|
return SetContextData(UE_EIP, (value&0xFF)|(GetContextData(UE_EIP)&0xFFFFFF00));
|
|
|
|
if(scmp(string, "dr0"))
|
|
return SetContextData(UE_DR0, value);
|
|
if(scmp(string, "dr1"))
|
|
return SetContextData(UE_DR1, value);
|
|
if(scmp(string, "dr2"))
|
|
return SetContextData(UE_DR2, value);
|
|
if(scmp(string, "dr3"))
|
|
return SetContextData(UE_DR3, value);
|
|
if(scmp(string, "dr6") or scmp(string, "dr4"))
|
|
return SetContextData(UE_DR6, value);
|
|
if(scmp(string, "dr7") or scmp(string, "dr5"))
|
|
return SetContextData(UE_DR7, value);
|
|
|
|
if(scmp(string, "cip"))
|
|
return SetContextData(UE_CIP, value);
|
|
if(scmp(string, "csp"))
|
|
return SetContextData(UE_CSP, value);
|
|
if(scmp(string, "cflags"))
|
|
return SetContextData(UE_CFLAGS, value);
|
|
|
|
#ifdef _WIN64
|
|
if(scmp(string, "rax"))
|
|
return SetContextData(UE_RAX, value);
|
|
if(scmp(string, "rbx"))
|
|
return SetContextData(UE_RBX, value);
|
|
if(scmp(string, "rcx"))
|
|
return SetContextData(UE_RCX, value);
|
|
if(scmp(string, "rdx"))
|
|
return SetContextData(UE_RDX, value);
|
|
if(scmp(string, "rdi"))
|
|
return SetContextData(UE_RDI, value);
|
|
if(scmp(string, "rsi"))
|
|
return SetContextData(UE_RSI, value);
|
|
if(scmp(string, "rbp"))
|
|
return SetContextData(UE_RBP, value);
|
|
if(scmp(string, "rsp"))
|
|
return SetContextData(UE_RSP, value);
|
|
if(scmp(string, "rip"))
|
|
return SetContextData(UE_RIP, value);
|
|
if(scmp(string, "rflags"))
|
|
return SetContextData(UE_RFLAGS, value);
|
|
if(scmp(string, "r8"))
|
|
return SetContextData(UE_R8, value);
|
|
if(scmp(string, "r9"))
|
|
return SetContextData(UE_R9, value);
|
|
if(scmp(string, "r10"))
|
|
return SetContextData(UE_R10, value);
|
|
if(scmp(string, "r11"))
|
|
return SetContextData(UE_R11, value);
|
|
if(scmp(string, "r12"))
|
|
return SetContextData(UE_R12, value);
|
|
if(scmp(string, "r13"))
|
|
return SetContextData(UE_R13, value);
|
|
if(scmp(string, "r14"))
|
|
return SetContextData(UE_R14, value);
|
|
if(scmp(string, "r15"))
|
|
return SetContextData(UE_R15, value);
|
|
|
|
if(scmp(string, "r8d"))
|
|
return SetContextData(UE_R8, (value&0xFFFFFFFF)|(GetContextData(UE_R8)&0xFFFFFFFF00000000));
|
|
if(scmp(string, "r9d"))
|
|
return SetContextData(UE_R9, (value&0xFFFFFFFF)|(GetContextData(UE_R9)&0xFFFFFFFF00000000));
|
|
if(scmp(string, "r10d"))
|
|
return SetContextData(UE_R10, (value&0xFFFFFFFF)|(GetContextData(UE_R10)&0xFFFFFFFF00000000));
|
|
if(scmp(string, "r11d"))
|
|
return SetContextData(UE_R11, (value&0xFFFFFFFF)|(GetContextData(UE_R11)&0xFFFFFFFF00000000));
|
|
if(scmp(string, "r12d"))
|
|
return SetContextData(UE_R12, (value&0xFFFFFFFF)|(GetContextData(UE_R12)&0xFFFFFFFF00000000));
|
|
if(scmp(string, "r13d"))
|
|
return SetContextData(UE_R13, (value&0xFFFFFFFF)|(GetContextData(UE_R13)&0xFFFFFFFF00000000));
|
|
if(scmp(string, "r14d"))
|
|
return SetContextData(UE_R14, (value&0xFFFFFFFF)|(GetContextData(UE_R14)&0xFFFFFFFF00000000));
|
|
if(scmp(string, "r15d"))
|
|
return SetContextData(UE_R15, (value&0xFFFFFFFF)|(GetContextData(UE_R15)&0xFFFFFFFF00000000));
|
|
|
|
if(scmp(string, "r8w"))
|
|
return SetContextData(UE_R8, (value&0xFFFF)|(GetContextData(UE_R8)&0xFFFFFFFFFFFF0000));
|
|
if(scmp(string, "r9w"))
|
|
return SetContextData(UE_R9, (value&0xFFFF)|(GetContextData(UE_R9)&0xFFFFFFFFFFFF0000));
|
|
if(scmp(string, "r10w"))
|
|
return SetContextData(UE_R10, (value&0xFFFF)|(GetContextData(UE_R10)&0xFFFFFFFFFFFF0000));
|
|
if(scmp(string, "r11w"))
|
|
return SetContextData(UE_R11, (value&0xFFFF)|(GetContextData(UE_R11)&0xFFFFFFFFFFFF0000));
|
|
if(scmp(string, "r12w"))
|
|
return SetContextData(UE_R12, (value&0xFFFF)|(GetContextData(UE_R12)&0xFFFFFFFFFFFF0000));
|
|
if(scmp(string, "r13w"))
|
|
return SetContextData(UE_R13, (value&0xFFFF)|(GetContextData(UE_R13)&0xFFFFFFFFFFFF0000));
|
|
if(scmp(string, "r14w"))
|
|
return SetContextData(UE_R14, (value&0xFFFF)|(GetContextData(UE_R14)&0xFFFFFFFFFFFF0000));
|
|
if(scmp(string, "r15w"))
|
|
return SetContextData(UE_R15, (value&0xFFFF)|(GetContextData(UE_R15)&0xFFFFFFFFFFFF0000));
|
|
if(scmp(string, "r8b"))
|
|
return SetContextData(UE_R8, (value&0xFF)|(GetContextData(UE_R8)&0xFFFFFFFFFFFFFF00));
|
|
if(scmp(string, "r9b"))
|
|
return SetContextData(UE_R9, (value&0xFF)|(GetContextData(UE_R9)&0xFFFFFFFFFFFFFF00));
|
|
if(scmp(string, "r10b"))
|
|
return SetContextData(UE_R10, (value&0xFF)|(GetContextData(UE_R10)&0xFFFFFFFFFFFFFF00));
|
|
if(scmp(string, "r11b"))
|
|
return SetContextData(UE_R11, (value&0xFF)|(GetContextData(UE_R11)&0xFFFFFFFFFFFFFF00));
|
|
if(scmp(string, "r12b"))
|
|
return SetContextData(UE_R12, (value&0xFF)|(GetContextData(UE_R12)&0xFFFFFFFFFFFFFF00));
|
|
if(scmp(string, "r13b"))
|
|
return SetContextData(UE_R13, (value&0xFF)|(GetContextData(UE_R13)&0xFFFFFFFFFFFFFF00));
|
|
if(scmp(string, "r14b"))
|
|
return SetContextData(UE_R14, (value&0xFF)|(GetContextData(UE_R14)&0xFFFFFFFFFFFFFF00));
|
|
if(scmp(string, "r15b"))
|
|
return SetContextData(UE_R15, (value&0xFF)|(GetContextData(UE_R15)&0xFFFFFFFFFFFFFF00));
|
|
#endif // _WIN64
|
|
|
|
return false;
|
|
}
|
|
|
|
bool valapifromstring(const char* name, uint* value, int* value_size, bool printall, bool silent, bool* hexonly)
|
|
{
|
|
if(!value or !IsFileBeingDebugged())
|
|
return false;
|
|
DWORD cbNeeded=1;
|
|
HMODULE hMods[256];
|
|
uint addrfound[256];
|
|
int found=0;
|
|
int kernelbase=-1;
|
|
|
|
//explicit API handling
|
|
const char* apiname=strstr(name, ":");
|
|
if(apiname)
|
|
{
|
|
char modname[MAX_MODULE_SIZE]="";
|
|
strcpy(modname, name);
|
|
modname[apiname-name]=0;
|
|
apiname++;
|
|
uint modbase=modbasefromname(modname);
|
|
char szModName[MAX_PATH];
|
|
if(!GetModuleFileNameEx(fdProcessInfo->hProcess, (HMODULE)modbase, szModName, MAX_PATH) and !silent)
|
|
dprintf("could not get filename of module "fhex"\n", modbase);
|
|
else
|
|
{
|
|
char szBaseName[256]="";
|
|
int len=strlen(szModName);
|
|
while(szModName[len]!='\\')
|
|
len--;
|
|
strcpy(szBaseName, szModName+len+1);
|
|
HMODULE mod=LoadLibraryExA(szModName, 0, DONT_RESOLVE_DLL_REFERENCES|LOAD_LIBRARY_AS_DATAFILE);
|
|
if(!mod and !silent)
|
|
dprintf("unable to load library %s\n", szBaseName);
|
|
else
|
|
{
|
|
uint addr=(uint)GetProcAddress(mod, apiname);
|
|
FreeLibrary(mod);
|
|
if(addr) //found!
|
|
{
|
|
if(value_size)
|
|
*value_size=sizeof(uint);
|
|
if(hexonly)
|
|
*hexonly=true;
|
|
*value=ImporterGetRemoteAPIAddressEx(szBaseName, (char*)apiname);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(EnumProcessModules(fdProcessInfo->hProcess, hMods, sizeof(hMods), &cbNeeded))
|
|
{
|
|
for(unsigned int i=0; i<(cbNeeded/sizeof(HMODULE)); i++)
|
|
{
|
|
char szModName[MAX_PATH];
|
|
if(!GetModuleFileNameEx(fdProcessInfo->hProcess, hMods[i], szModName, MAX_PATH) and !silent)
|
|
dprintf("could not get filename of module "fhex"\n", hMods[i]);
|
|
else
|
|
{
|
|
char szBaseName[256]="";
|
|
int len=strlen(szModName);
|
|
while(szModName[len]!='\\')
|
|
len--;
|
|
strcpy(szBaseName, szModName+len+1);
|
|
HMODULE mod=LoadLibraryExA(szModName, 0, DONT_RESOLVE_DLL_REFERENCES|LOAD_LIBRARY_AS_DATAFILE);
|
|
if(!mod and !silent)
|
|
dprintf("unable to load library %s\n", szBaseName);
|
|
else
|
|
{
|
|
uint addr=(uint)GetProcAddress(mod, name);
|
|
FreeLibrary(mod);
|
|
if(addr)
|
|
{
|
|
if(!_stricmp(szBaseName, "kernelbase") or !_stricmp(szBaseName, "kernelbase.dll"))
|
|
kernelbase=found;
|
|
addrfound[found]=ImporterGetRemoteAPIAddressEx(szBaseName, (char*)name);
|
|
found++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(!found)
|
|
return false;
|
|
if(value_size)
|
|
*value_size=sizeof(uint);
|
|
if(hexonly)
|
|
*hexonly=true;
|
|
if(kernelbase!=-1)
|
|
{
|
|
*value=addrfound[kernelbase];
|
|
if(!printall or silent)
|
|
return true;
|
|
for(int i=0; i<found; i++)
|
|
if(i!=kernelbase)
|
|
dprintf(fhex"\n", addrfound[i]);
|
|
}
|
|
else
|
|
{
|
|
*value=*addrfound;
|
|
if(!printall or silent)
|
|
return true;
|
|
for(int i=1; i<found; i++)
|
|
dprintf(fhex"\n", addrfound[i]);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
check whether a string is a valid dec number
|
|
*/
|
|
static bool isdecnumber(const char* string)
|
|
{
|
|
if(*string!='.' or !string[1]) //dec indicator/no number
|
|
return false;
|
|
int decAdd=1;
|
|
if(string[1]=='-') //minus
|
|
{
|
|
if(!string[2]) //no number
|
|
return false;
|
|
decAdd++;
|
|
}
|
|
int len=strlen(string+decAdd);
|
|
for(int i=0; i<len; i++)
|
|
if(!isdigit(string[i+decAdd]))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
check whether a string is a valid hex number
|
|
*/
|
|
static bool ishexnumber(const char* string)
|
|
{
|
|
int add=0;
|
|
if(*string=='x') //hex indicator
|
|
add=1;
|
|
if(!string[add]) //only an indicator, no number
|
|
return false;
|
|
int len=strlen(string+add);
|
|
for(int i=0; i<len; i++)
|
|
if(!isxdigit(string[i+add])) //all must be hex digits
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool valfromstring(const char* string, uint* value, int* value_size, bool* isvar, bool silent, bool* hexonly)
|
|
{
|
|
if(!value)
|
|
return false;
|
|
else if(*string=='.' and string[1]=='-' and string[2]) //negative decimal number
|
|
{
|
|
uint finalMul=1;
|
|
if(value_size)
|
|
*value_size=0;
|
|
if(isvar)
|
|
*isvar=false;
|
|
int decAdd=1;
|
|
if(string[1]=='-') //negative number
|
|
{
|
|
decAdd++;
|
|
finalMul=~0;
|
|
}
|
|
uint newValue=0;
|
|
sscanf(string+decAdd, "%"fext"u", &newValue);
|
|
*value=newValue*finalMul;
|
|
return true;
|
|
}
|
|
else if(!*string)
|
|
{
|
|
*value=0;
|
|
return true;
|
|
}
|
|
else if(mathcontains(string)) //handle math
|
|
{
|
|
int len=strlen(string);
|
|
char* newstring=(char*)emalloc(len*2, "valfromstring:newstring");
|
|
if(strstr(string, "[")) //memory brackets: []
|
|
{
|
|
for(int i=0,j=0; i<len; i++)
|
|
{
|
|
if(string[i]==']')
|
|
j+=sprintf(newstring+j, ")");
|
|
else if(isdigit(string[i]) and string[i+1]==':' and string[i+2]=='[') //n:[
|
|
{
|
|
j+=sprintf(newstring+j, "@%c:(", string[i]);
|
|
i+=2;
|
|
}
|
|
else if(string[i]=='[')
|
|
j+=sprintf(newstring+j, "@(");
|
|
else
|
|
j+=sprintf(newstring+j, "%c", string[i]);
|
|
}
|
|
}
|
|
else
|
|
strcpy(newstring, string);
|
|
char* string_=(char*)emalloc(len+256, "valfromstring:string_");
|
|
strcpy(string_, newstring);
|
|
efree(newstring, "valfromstring::newstring");
|
|
int add=0;
|
|
while(mathisoperator(string_[add])>2)
|
|
add++;
|
|
if(!mathhandlebrackets(string_+add, silent))
|
|
{
|
|
efree(string_, "valfromstring:string_");
|
|
return false;
|
|
}
|
|
bool ret=mathfromstring(string_+add, value, value_size, isvar, silent);
|
|
efree(string_, "valfromstring:string_");
|
|
return ret;
|
|
}
|
|
else if(*string=='@' or strstr(string, "[")) //memory location
|
|
{
|
|
if(!IsFileBeingDebugged())
|
|
{
|
|
if(!silent)
|
|
dputs("not debugging");
|
|
*value=0;
|
|
if(value_size)
|
|
*value_size=0;
|
|
if(isvar)
|
|
*isvar=true;
|
|
return true;
|
|
}
|
|
int len=strlen(string);
|
|
char* newstring=(char*)emalloc(len*2, "valfromstring:newstring");
|
|
if(strstr(string, "["))
|
|
{
|
|
for(int i=0,j=0; i<len; i++)
|
|
{
|
|
if(string[i]==']')
|
|
j+=sprintf(newstring+j, ")");
|
|
else if(isdigit(string[i]) and string[i+1]==':' and string[i+2]=='[') //n:[
|
|
{
|
|
j+=sprintf(newstring+j, "@%c:(", string[i]);
|
|
i+=2;
|
|
}
|
|
else if(string[i]=='[')
|
|
j+=sprintf(newstring+j, "@(");
|
|
else
|
|
j+=sprintf(newstring+j, "%c", string[i]);
|
|
}
|
|
}
|
|
else
|
|
strcpy(newstring, string);
|
|
int read_size=sizeof(uint);
|
|
int add=1;
|
|
if(newstring[2]==':' and isdigit((newstring[1]))) //@n: (number of bytes to read)
|
|
{
|
|
add+=2;
|
|
int new_size=newstring[1]-0x30;
|
|
if(new_size<read_size)
|
|
read_size=new_size;
|
|
}
|
|
if(!valfromstring(newstring+add, value, 0, 0, silent, 0))
|
|
{
|
|
efree(newstring, "valfromstring::newstring");
|
|
return false;
|
|
}
|
|
efree(newstring, "valfromstring::newstring");
|
|
uint addr=*value;
|
|
*value=0;
|
|
if(!memread(fdProcessInfo->hProcess, (void*)addr, value, read_size, 0))
|
|
{
|
|
if(!silent)
|
|
dputs("failed to read memory");
|
|
return false;
|
|
}
|
|
bpfixmemory(addr, (unsigned char*)value, read_size);
|
|
if(value_size)
|
|
*value_size=read_size;
|
|
if(isvar)
|
|
*isvar=true;
|
|
return true;
|
|
}
|
|
else if(isregister(string)) //register
|
|
{
|
|
if(!IsFileBeingDebugged())
|
|
{
|
|
if(!silent)
|
|
dputs("not debugging!");
|
|
*value=0;
|
|
if(value_size)
|
|
*value_size=0;
|
|
if(isvar)
|
|
*isvar=true;
|
|
return true;
|
|
}
|
|
*value=getregister(value_size, string);
|
|
if(isvar)
|
|
*isvar=true;
|
|
return true;
|
|
}
|
|
else if(*string=='!' and isflag(string+1)) //flag
|
|
{
|
|
if(!IsFileBeingDebugged())
|
|
{
|
|
if(!silent)
|
|
dputs("not debugging");
|
|
*value=0;
|
|
if(value_size)
|
|
*value_size=0;
|
|
if(isvar)
|
|
*isvar=true;
|
|
return true;
|
|
}
|
|
uint eflags=GetContextData(UE_CFLAGS);
|
|
if(valflagfromstring(eflags, string+1))
|
|
*value=1;
|
|
else
|
|
*value=0;
|
|
if(value_size)
|
|
*value_size=0;
|
|
if(isvar)
|
|
*isvar=true;
|
|
return true;
|
|
}
|
|
else if(isdecnumber(string)) //decimal numbers come 'first'
|
|
{
|
|
if(value_size)
|
|
*value_size=0;
|
|
if(isvar)
|
|
*isvar=false;
|
|
sscanf(string+1, "%"fext"u", value);
|
|
return true;
|
|
}
|
|
else if(ishexnumber(string)) //then hex numbers
|
|
{
|
|
if(value_size)
|
|
*value_size=0;
|
|
if(isvar)
|
|
*isvar=false;
|
|
//hexadecimal value
|
|
int inc=0;
|
|
if(*string=='x')
|
|
inc=1;
|
|
sscanf(string+inc, "%"fext"x", value);
|
|
return true;
|
|
}
|
|
else if(valapifromstring(string, value, value_size, true, silent, hexonly)) //then come APIs
|
|
return true;
|
|
else if(labelfromstring(string, value)) //then come labels
|
|
return true;
|
|
else if(symfromname(string, value)) //then come symbols
|
|
return true;
|
|
else if(varget(string, value, value_size, 0)) //finally variables
|
|
{
|
|
if(isvar)
|
|
*isvar=true;
|
|
return true;
|
|
}
|
|
if(!silent)
|
|
dprintf("invalid value: \"%s\"!\n", string);
|
|
return false; //nothing was OK
|
|
}
|
|
|
|
bool valtostring(const char* string, uint* value, bool silent)
|
|
{
|
|
if(!*string or !value)
|
|
return false;
|
|
else if(*string=='@' or strstr(string, "[")) //memory location
|
|
{
|
|
if(!IsFileBeingDebugged())
|
|
{
|
|
if(!silent)
|
|
dputs("not debugging");
|
|
return false;
|
|
}
|
|
int len=strlen(string);
|
|
char* newstring=(char*)emalloc(len*2, "valfromstring:newstring");
|
|
if(strstr(string, "[")) //memory brackets: []
|
|
{
|
|
for(int i=0,j=0; i<len; i++)
|
|
{
|
|
if(string[i]==']')
|
|
j+=sprintf(newstring+j, ")");
|
|
else if(isdigit(string[i]) and string[i+1]==':' and string[i+2]=='[') //n:[
|
|
{
|
|
j+=sprintf(newstring+j, "@%c:(", string[i]);
|
|
i+=2;
|
|
}
|
|
else if(string[i]=='[')
|
|
j+=sprintf(newstring+j, "@(");
|
|
else
|
|
j+=sprintf(newstring+j, "%c", string[i]);
|
|
}
|
|
}
|
|
else
|
|
strcpy(newstring, string);
|
|
int read_size=sizeof(uint);
|
|
int add=1;
|
|
if(newstring[2]==':' and isdigit((newstring[1])))
|
|
{
|
|
add+=2;
|
|
int new_size=newstring[1]-0x30;
|
|
if(new_size<read_size)
|
|
read_size=new_size;
|
|
}
|
|
uint temp;
|
|
if(!valfromstring(newstring+add, &temp, 0, 0, silent, 0))
|
|
{
|
|
efree(newstring, "valfromstring::newstring");
|
|
return false;
|
|
}
|
|
efree(newstring, "valfromstring::newstring");
|
|
bool wpm=WriteProcessMemory(fdProcessInfo->hProcess, (void*)temp, value, read_size, 0);
|
|
bpfixmemory(temp, (unsigned char*)value, read_size);
|
|
if(!wpm)
|
|
{
|
|
if(!silent)
|
|
dputs("failed to write memory");
|
|
return false;
|
|
}
|
|
GuiUpdateAllViews(); //repaint gui
|
|
return true;
|
|
}
|
|
else if(isregister(string)) //register
|
|
{
|
|
if(!IsFileBeingDebugged())
|
|
{
|
|
if(!silent)
|
|
dputs("not debugging!");
|
|
return false;
|
|
}
|
|
bool ok=setregister(string, *value);
|
|
if(strstr(string, "ip"))
|
|
DebugUpdateGui(GetContextData(UE_CIP)); //update disassembly + register view
|
|
else
|
|
GuiUpdateAllViews(); //repaint gui
|
|
return ok;
|
|
}
|
|
else if(*string=='!' and isflag(string+1)) //flag
|
|
{
|
|
if(!IsFileBeingDebugged())
|
|
{
|
|
if(!silent)
|
|
dputs("not debugging");
|
|
return false;
|
|
}
|
|
bool set=false;
|
|
if(*value)
|
|
set=true;
|
|
setflag(string+1, set);
|
|
GuiUpdateAllViews(); //repaint gui
|
|
return true;
|
|
}
|
|
return varset(string, *value, false); //variable
|
|
}
|