yuzu/unicorn
1
0
Fork 0
mirror of https://github.com/yuzu-emu/unicorn.git synced 2025-02-02 07:21:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/unicorn-engine/unicorn

Browse source
This commit is contained in:
Nguyen Anh Quynh 2015-09-08 22:52:23 +08:00
parent 2929138c99 99379e92e9
commit ae703e0efd
4 changed files with 88 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
bindings/go/unicorn/hook.go
View file

@ -12,55 +12,57 @@ import (
import "C"
type HookData struct {
Uc *Uc
Uc Unicorn
Callback interface{}
}
type Hook uint64
//export hookCode
func hookCode(handle *C.uc_engine, addr uint64, size uint32, user unsafe.Pointer) {
hook := (*HookData)(user)
hook.Callback.(func(*Uc, uint64, uint32))(hook.Uc, uint64(addr), uint32(size))
hook.Callback.(func(Unicorn, uint64, uint32))(hook.Uc, uint64(addr), uint32(size))
}
//export hookMemInvalid
func hookMemInvalid(handle *C.uc_engine, typ C.uc_mem_type, addr uint64, size int, value int64, user unsafe.Pointer) bool {
hook := (*HookData)(user)
return hook.Callback.(func(*Uc, int, uint64, int, int64) bool)(hook.Uc, int(typ), addr, size, value)
return hook.Callback.(func(Unicorn, int, uint64, int, int64) bool)(hook.Uc, int(typ), addr, size, value)
}
//export hookMemAccess
func hookMemAccess(handle *C.uc_engine, typ C.uc_mem_type, addr uint64, size int, value int64, user unsafe.Pointer) {
hook := (*HookData)(user)
hook.Callback.(func(*Uc, int, uint64, int, int64))(hook.Uc, int(typ), addr, size, value)
hook.Callback.(func(Unicorn, int, uint64, int, int64))(hook.Uc, int(typ), addr, size, value)
}
//export hookInterrupt
func hookInterrupt(handle *C.uc_engine, intno uint32, user unsafe.Pointer) {
hook := (*HookData)(user)
hook.Callback.(func(*Uc, uint32))(hook.Uc, intno)
hook.Callback.(func(Unicorn, uint32))(hook.Uc, intno)
}
//export hookX86In
func hookX86In(handle *C.uc_engine, port, size uint32, user unsafe.Pointer) uint32 {
hook := (*HookData)(user)
return hook.Callback.(func(*Uc, uint32, uint32) uint32)(hook.Uc, port, size)
return hook.Callback.(func(Unicorn, uint32, uint32) uint32)(hook.Uc, port, size)
}
//export hookX86Out
func hookX86Out(handle *C.uc_engine, port, size, value uint32, user unsafe.Pointer) {
hook := (*HookData)(user)
hook.Callback.(func(*Uc, uint32, uint32, uint32))(hook.Uc, port, size, value)
hook.Callback.(func(Unicorn, uint32, uint32, uint32))(hook.Uc, port, size, value)
}
//export hookX86Syscall
func hookX86Syscall(handle *C.uc_engine, user unsafe.Pointer) {
hook := (*HookData)(user)
hook.Callback.(func(*Uc))(hook.Uc)
hook.Callback.(func(Unicorn))(hook.Uc)
}
var hookRetain = make(map[C.uc_hook]*HookData)
var hookRetain = make(map[Hook]*HookData)
func (u *Uc) HookAdd(htype int, cb interface{}, extra ...uint64) (C.uc_hook, error) {
func (u *uc) HookAdd(htype int, cb interface{}, extra ...uint64) (Hook, error) {
var callback unsafe.Pointer
var iarg1 C.int
var uarg1, uarg2 C.uint64_t
@ -101,15 +103,15 @@ func (u *Uc) HookAdd(htype int, cb interface{}, extra ...uint64) (C.uc_hook, err
} else {
uarg1, uarg2 = 1, 0
}
C.uc_hook_add_u2(u.Handle, &h2, C.uc_hook_type(htype), callback, unsafe.Pointer(data), uarg1, uarg2)
C.uc_hook_add_u2(u.handle, &h2, C.uc_hook_type(htype), callback, unsafe.Pointer(data), uarg1, uarg2)
} else {
C.uc_hook_add_i1(u.Handle, &h2, C.uc_hook_type(htype), callback, unsafe.Pointer(data), iarg1)
C.uc_hook_add_i1(u.handle, &h2, C.uc_hook_type(htype), callback, unsafe.Pointer(data), iarg1)
}
hookRetain[h2] = data
return h2, nil
hookRetain[Hook(h2)] = data
return Hook(h2), nil
}
func (u *Uc) HookDel(hook C.uc_hook) error {
func (u *uc) HookDel(hook Hook) error {
delete(hookRetain, hook)
return errReturn(C.uc_hook_del(u.Handle, hook))
return errReturn(C.uc_hook_del(u.handle, C.uc_hook(hook)))
}

58
bindings/go/unicorn/unicorn.go
View file

@ -23,16 +23,30 @@ func errReturn(err C.uc_err) error {
return nil
}
type Uc struct {
Handle *C.uc_engine
Arch, Mode int
type Unicorn interface {
MemMap(addr, size uint64) error
MemMapProt(addr, size uint64, prot int) error
MemRead(addr, size uint64) ([]byte, error)
MemReadInto(dst []byte, addr uint64) error
MemWrite(addr uint64, data []byte) error
RegRead(reg int) (uint64, error)
RegWrite(reg int, value uint64) error
Start(begin, until uint64) error
StartWithOptions(begin, until uint64, options *UcOptions) error
Stop() error
HookAdd(htype int, cb interface{}, extra ...uint64) (Hook, error)
HookDel(hook Hook) error
}
type uc struct {
handle *C.uc_engine
}
type UcOptions struct {
Timeout, Count uint64
}
func NewUc(arch, mode int) (*Uc, error) {
func NewUnicorn(arch, mode int) (Unicorn, error) {
var major, minor C.uint
C.uc_version(&major, &minor)
if major != C.UC_API_MAJOR || minor != C.UC_API_MINOR {
@ -42,58 +56,58 @@ func NewUc(arch, mode int) (*Uc, error) {
if ucerr := C.uc_open(C.uc_arch(arch), C.uc_mode(mode), &handle); ucerr != ERR_OK {
return nil, UcError(ucerr)
}
uc := &Uc{handle, arch, mode}
uc := &uc{handle}
return uc, nil
}
func (u *Uc) StartWithOptions(begin, until uint64, options *UcOptions) error {
ucerr := C.uc_emu_start(u.Handle, C.uint64_t(begin), C.uint64_t(until), C.uint64_t(options.Timeout), C.size_t(options.Count))
func (u *uc) StartWithOptions(begin, until uint64, options *UcOptions) error {
ucerr := C.uc_emu_start(u.handle, C.uint64_t(begin), C.uint64_t(until), C.uint64_t(options.Timeout), C.size_t(options.Count))
return errReturn(ucerr)
}
func (u *Uc) Start(begin, until uint64) error {
func (u *uc) Start(begin, until uint64) error {
return u.StartWithOptions(begin, until, &UcOptions{})
}
func (u *Uc) Stop() error {
return errReturn(C.uc_emu_stop(u.Handle))
func (u *uc) Stop() error {
return errReturn(C.uc_emu_stop(u.handle))
}
func (u *Uc) RegWrite(reg int, value uint64) error {
func (u *uc) RegWrite(reg int, value uint64) error {
var val C.uint64_t = C.uint64_t(value)
ucerr := C.uc_reg_write(u.Handle, C.int(reg), unsafe.Pointer(&val))
ucerr := C.uc_reg_write(u.handle, C.int(reg), unsafe.Pointer(&val))
return errReturn(ucerr)
}
func (u *Uc) RegRead(reg int) (uint64, error) {
func (u *uc) RegRead(reg int) (uint64, error) {
var val C.uint64_t
ucerr := C.uc_reg_read(u.Handle, C.int(reg), unsafe.Pointer(&val))
ucerr := C.uc_reg_read(u.handle, C.int(reg), unsafe.Pointer(&val))
return uint64(val), errReturn(ucerr)
}
func (u *Uc) MemWrite(addr uint64, data []byte) error {
func (u *uc) MemWrite(addr uint64, data []byte) error {
if len(data) == 0 {
return nil
}
return errReturn(C.uc_mem_write(u.Handle, C.uint64_t(addr), unsafe.Pointer(&data[0]), C.size_t(len(data))))
return errReturn(C.uc_mem_write(u.handle, C.uint64_t(addr), unsafe.Pointer(&data[0]), C.size_t(len(data))))
}
func (u *Uc) MemReadInto(dst []byte, addr uint64) error {
func (u *uc) MemReadInto(dst []byte, addr uint64) error {
if len(dst) == 0 {
return nil
}
return errReturn(C.uc_mem_read(u.Handle, C.uint64_t(addr), unsafe.Pointer(&dst[0]), C.size_t(len(dst))))
return errReturn(C.uc_mem_read(u.handle, C.uint64_t(addr), unsafe.Pointer(&dst[0]), C.size_t(len(dst))))
}
func (u *Uc) MemRead(addr, size uint64) ([]byte, error) {
func (u *uc) MemRead(addr, size uint64) ([]byte, error) {
dst := make([]byte, size)
return dst, u.MemReadInto(dst, addr)
}
func (u *Uc) MemMapProt(addr, size uint64, prot int) error {
return errReturn(C.uc_mem_map(u.Handle, C.uint64_t(addr), C.size_t(size), C.uint32_t(prot)))
func (u *uc) MemMapProt(addr, size uint64, prot int) error {
return errReturn(C.uc_mem_map(u.handle, C.uint64_t(addr), C.size_t(size), C.uint32_t(prot)))
}
func (u *Uc) MemMap(addr, size uint64) error {
func (u *uc) MemMap(addr, size uint64) error {
return u.MemMapProt(addr, size, PROT_ALL)
}

10
bindings/go/unicorn/x86_test.go
View file

@ -6,8 +6,8 @@ import (
var ADDRESS uint64 = 0x1000000
func MakeUc(mode int, code string) (*Uc, error) {
mu, err := NewUc(ARCH_X86, mode)
func MakeUc(mode int, code string) (Unicorn, error) {
mu, err := NewUnicorn(ARCH_X86, mode)
if err != nil {
return nil, err
}
@ -84,7 +84,7 @@ func TestX86InOut(t *testing.T) {
}
var outVal uint64
var inCalled, outCalled bool
mu.HookAdd(HOOK_INSN, func(mu *Uc, port, size uint32) uint32 {
mu.HookAdd(HOOK_INSN, func(_ Unicorn, port, size uint32) uint32 {
inCalled = true
switch size {
case 1:
@ -97,7 +97,7 @@ func TestX86InOut(t *testing.T) {
return 0
}
}, X86_INS_IN)
mu.HookAdd(HOOK_INSN, func(uc *Uc, port, size, value uint32) {
mu.HookAdd(HOOK_INSN, func(_ Unicorn, port, size, value uint32) {
outCalled = true
var err error
switch size {
@ -129,7 +129,7 @@ func TestX86Syscall(t *testing.T) {
if err != nil {
t.Fatal(err)
}
mu.HookAdd(HOOK_INSN, func(mu *Uc) {
mu.HookAdd(HOOK_INSN, func(_ Unicorn) {
rax, _ := mu.RegRead(X86_REG_RAX)
mu.RegWrite(X86_REG_RAX, rax+1)
}, X86_INS_SYSCALL)

29
regress/mips_except.py Executable file
View file

@ -0,0 +1,29 @@
#!/usr/bin/python
from unicorn import *
from unicorn.mips_const import *
def hook_intr(uc, intno, _):
print 'interrupt', intno
CODE = 0x400000
asm = '0000a48f'.decode('hex')
uc = Uc(UC_ARCH_MIPS, UC_MODE_MIPS32 + UC_MODE_LITTLE_ENDIAN)
uc.hook_add(UC_HOOK_INTR, hook_intr)
uc.mem_map(CODE, 0x1000)
uc.mem_write(CODE, asm)
print 'unaligned access (exc 12)'
uc.reg_write(UC_MIPS_REG_SP, 0x01)
uc.emu_start(CODE, CODE + len(asm), 300)
print
print 'dunno (exc 26)'
uc.reg_write(UC_MIPS_REG_SP, 0xFFFFFFF0)
uc.emu_start(CODE, CODE + len(asm), 200)
print
print 'unassigned access (exc 28)'
uc.reg_write(UC_MIPS_REG_SP, 0x80000000)
uc.emu_start(CODE, CODE + len(asm), 100)
print