PyObject* vm_set_u64(VmMngr* self, PyObject* args)
{
PyObject *py_addr;
PyObject *py_val;
uint64_t value;
uint64_t addr;
int ret;
if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_val))
RAISE(PyExc_TypeError,"Cannot parse arguments");
PyGetInt_uint64_t(py_addr, addr);
PyGetInt_uint64_t(py_val, value);
value = set_endian64(&self->vm_mngr, value);
ret = vm_write_mem(&self->vm_mngr, addr, (char*)&value, 8);
if (ret < 0)
RAISE(PyExc_TypeError, "Error in set_mem");
add_mem_write(&self->vm_mngr, addr, 8);
check_invalid_code_blocs(&self->vm_mngr);
Py_INCREF(Py_None);
return Py_None;
}
PyObject* vm_set_mem(JitCpu *self, PyObject* args)
{
PyObject *py_addr;
PyObject *py_buffer;
Py_ssize_t py_length;
char * buffer;
uint64_t size;
uint64_t addr;
int ret = 0x1337;
if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer))
return NULL;
PyGetInt(py_addr, addr);
if(!PyString_Check(py_buffer))
RAISE(PyExc_TypeError,"arg must be str");
size = PyString_Size(py_buffer);
PyString_AsStringAndSize(py_buffer, &buffer, &py_length);
ret = vm_write_mem(&(((VmMngr*)self->pyvm)->vm_mngr), addr, buffer, size);
if (ret < 0)
RAISE(PyExc_TypeError,"arg must be str");
check_automod(self, addr, size*8);
Py_INCREF(Py_None);
return Py_None;
}
PyObject* vm_set_mem(VmMngr* self, PyObject* args)
{
PyObject *py_addr;
PyObject *py_buffer;
Py_ssize_t py_length;
char * buffer;
Py_ssize_t pysize;
uint64_t addr;
int ret;
if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer))
RAISE(PyExc_TypeError,"Cannot parse arguments");
PyGetInt_uint64_t(py_addr, addr);
if (!PyBytes_Check(py_buffer))
RAISE(PyExc_TypeError,"arg must be bytes");
pysize = PyBytes_Size(py_buffer);
if (pysize < 0) {
RAISE(PyExc_TypeError,"Python error");
}
PyBytes_AsStringAndSize(py_buffer, &buffer, &py_length);
ret = vm_write_mem(&self->vm_mngr, addr, buffer, pysize);
if (ret < 0)
RAISE(PyExc_TypeError, "Error in set_mem");
add_mem_write(&self->vm_mngr, addr, (size_t)pysize);
check_invalid_code_blocs(&self->vm_mngr);
Py_INCREF(Py_None);
return Py_None;
}
int vmx_vmexit_resolve_dt()
{
vmcs_exit_info_insn_dt_t *dt_insn;
offset_t dt_addr;
dt_reg_t dt_reg;
raw64_t disp;
uint64_t addr_msk, op_msk;
int rc, sz, mode;
if(!__rmode())
{
debug(VMX_DT, "DT intercept only while in real mode\n");
return VM_FAIL;
}
vmcs_read(vm_exit_info.insn_info);
vmcs_read(vm_exit_info.qualification);
dt_insn = &vm_exit_info.insn_info.dt;
dt_addr = 0;
disp.sraw = vm_exit_info.qualification.sraw;
addr_msk = (1ULL<<(16*(1<<dt_insn->addr))) - 1;
switch(dt_insn->seg)
{
case VMCS_VM_EXIT_INFORMATION_VMX_INSN_INFORMATION_SEG_REG_ES:
vmcs_read(vm_state.es.base);
dt_addr += vm_state.es.base.raw;
break;
case VMCS_VM_EXIT_INFORMATION_VMX_INSN_INFORMATION_SEG_REG_CS:
vmcs_read(vm_state.cs.base);
dt_addr += vm_state.cs.base.raw;
break;
case VMCS_VM_EXIT_INFORMATION_VMX_INSN_INFORMATION_SEG_REG_SS:
vmcs_read(vm_state.ss.base);
dt_addr += vm_state.ss.base.raw;
break;
case VMCS_VM_EXIT_INFORMATION_VMX_INSN_INFORMATION_SEG_REG_DS:
vmcs_read(vm_state.ds.base);
dt_addr += vm_state.ds.base.raw;
break;
case VMCS_VM_EXIT_INFORMATION_VMX_INSN_INFORMATION_SEG_REG_FS:
vmcs_read(vm_state.fs.base);
dt_addr += vm_state.fs.base.raw;
break;
case VMCS_VM_EXIT_INFORMATION_VMX_INSN_INFORMATION_SEG_REG_GS:
vmcs_read(vm_state.gs.base);
dt_addr += vm_state.gs.base.raw;
break;
}
/* XXX: compute offset alone and check against segment limit */
if(!dt_insn->no_base)
{
int reg = GPR64_RAX - (dt_insn->base & GPR64_RAX);
dt_addr += info->vm.cpu.gpr->raw[reg].raw & addr_msk;
}
if(!dt_insn->no_idx)
{
int reg = GPR64_RAX - (dt_insn->idx & GPR64_RAX);
uint64_t val = info->vm.cpu.gpr->raw[reg].raw & addr_msk;
if(dt_insn->scale)
val *= (1ULL<<dt_insn->scale);
dt_addr += val;
}
dt_addr += (disp.sraw & addr_msk);
mode = cpu_addr_sz();
if(mode == 64)
{
op_msk = -1ULL;
sz = 10;
}
else if(dt_insn->op == VMCS_VM_EXIT_INFORMATION_VMX_INSN_INFORMATION_OP_SZ_16)
{
op_msk = (1ULL<<24) - 1;
sz = 6;
}
else
{
op_msk = (1ULL<<32) - 1;
sz = 6;
}
debug(VMX_DT, "dt op @ 0x%X\n", dt_addr);
if(dt_insn->type < VMCS_VM_EXIT_INFORMATION_VMX_INSN_INFORMATION_TYPE_LGDT)
{
if(dt_insn->type == VMCS_VM_EXIT_INFORMATION_VMX_INSN_INFORMATION_TYPE_SGDT)
rc = __vmx_vmexit_sgdt(&dt_reg);
else
rc = __vmx_vmexit_sidt(&dt_reg);
dt_reg.base.raw &= op_msk;
if(!vm_write_mem(dt_addr, (uint8_t*)&dt_reg, sz))
{
debug(VMX_DT, "could not write vm mem @0x%X\n", dt_addr);
return VM_FAIL;
}
}
else
{
if(!vm_read_mem(dt_addr, (uint8_t*)&dt_reg, sz))
{
debug(VMX_DT, "could not read vm mem @0x%X\n", dt_addr);
return VM_FAIL;
}
dt_reg.base.raw &= op_msk;
if(dt_insn->type == VMCS_VM_EXIT_INFORMATION_VMX_INSN_INFORMATION_TYPE_LGDT)
rc = __vmx_vmexit_lgdt(&dt_reg);
else
rc = __vmx_vmexit_lidt(&dt_reg);
}
vmcs_read(vm_exit_info.insn_len);
return emulate_done(rc, vm_exit_info.insn_len.raw);
}
