emulator

Documentation

Index

• Constants
• Variables
• type Arch
• type ByteOrder
• type CodeCallback
• type Context
• type Emulator
• type Hook
• type HookType
  • func (ht HookType) String() string
• type InterruptCallback
• type InvalidCallback
• type MemProt
• type MemRegion
• type MemoryCallback
• type Pointer
  • func ToPointer(emu Emulator, addr uint64) Pointer
  • func (p Pointer) Add(offset uint64) Pointer
  • func (p Pointer) Address() uint64
  • func (p Pointer) IsNil() bool
  • func (p Pointer) MemRead(size uint64) ([]byte, error)
  • func (p Pointer) MemReadPointer() (ptr Pointer, err error)
  • func (p Pointer) MemReadPtr(size uint64, ptr unsafe.Pointer) error
  • func (p Pointer) MemReadString() (string, error)
  • func (p Pointer) MemWrite(data []byte) error
  • func (p Pointer) MemWritePtr(size uint64, ptr unsafe.Pointer) error
  • func (p Pointer) ReadAt(b []byte, off int64) (n int, err error)
  • func (p Pointer) Sub(offset uint64) Pointer
  • func (p Pointer) WriteAt(b []byte, off int64) (n int, err error)
• type Reg
• type RegisterContext
• type Uintptr32
• type Uintptr64

Constants

const (
	HOOK_TYPE_INTR HookType = 1 << iota
	HOOK_TYPE_INSN_INVALID
	HOOK_TYPE_CODE
	HOOK_TYPE_BLOCK
	HOOK_TYPE_MEM_READ_UNMAPPED
	HOOK_TYPE_MEM_WRITE_UNMAPPED
	HOOK_TYPE_MEM_FETCH_UNMAPPED
	HOOK_TYPE_MEM_READ_PROT
	HOOK_TYPE_MEM_WRITE_PROT
	HOOK_TYPE_MEM_FETCH_PROT
	HOOK_TYPE_MEM_READ
	HOOK_TYPE_MEM_WRITE
	HOOK_TYPE_MEM_FETCH
	HOOK_TYPE_MEM_READ_AFTER

	HOOK_TYPE_MEM_UNMAPPED      = HOOK_TYPE_MEM_READ_UNMAPPED | HOOK_TYPE_MEM_WRITE_UNMAPPED | HOOK_TYPE_MEM_FETCH_UNMAPPED
	HOOK_TYPE_MEM_PROT          = HOOK_TYPE_MEM_READ_PROT | HOOK_TYPE_MEM_WRITE_PROT | HOOK_TYPE_MEM_FETCH_PROT
	HOOK_TYPE_MEM_READ_INVALID  = HOOK_TYPE_MEM_READ_UNMAPPED | HOOK_TYPE_MEM_READ_PROT
	HOOK_TYPE_MEM_WRITE_INVALID = HOOK_TYPE_MEM_WRITE_UNMAPPED | HOOK_TYPE_MEM_WRITE_PROT
	HOOK_TYPE_MEM_FETCH_INVALID = HOOK_TYPE_MEM_FETCH_UNMAPPED | HOOK_TYPE_MEM_FETCH_PROT
	HOOK_TYPE_MEM_INVALID       = HOOK_TYPE_MEM_READ_INVALID | HOOK_TYPE_MEM_WRITE_INVALID | HOOK_TYPE_MEM_FETCH_INVALID
	HOOK_TYPE_MEM_VALID         = HOOK_TYPE_MEM_READ | HOOK_TYPE_MEM_WRITE | HOOK_TYPE_MEM_FETCH
)

Variables

var (
	ErrArchUnsupported = errors.New("architecture unsupported")
	ErrArchMismatch    = errors.New("architecture mismatch")
)

Types

type Arch

type Arch int

const (
	ARCH_UNKNOWN Arch = iota
	ARCH_ARM
	ARCH_ARM64
	ARCH_X86
	ARCH_X86_64
)

type ByteOrder

type ByteOrder int

const (
	BO_LITTLE_ENDIAN ByteOrder = iota
	BO_BIG_ENDIAN
)

type CodeCallback

type CodeCallback = func(addr, size uint64, data any)

type Context

type Context interface {
	io.Closer
	Save() error
	Restore() error
	RegisterContext
	Clone() (Context, error)
}

type Emulator

type Emulator interface {
	io.Closer
	Arch() Arch
	ByteOrder() ByteOrder
	PageSize() uint64
	MemMap(addr, size uint64, prot MemProt) error
	MemMapPtr(addr, size uint64, prot MemProt, ptr unsafe.Pointer) error
	MemUnmap(addr, size uint64) error
	MemProtect(addr, size uint64, prot MemProt) error
	MemRegions() ([]MemRegion, error)
	MemRead(addr, size uint64) ([]byte, error)
	MemWrite(addr uint64, data []byte) error
	MemReadPtr(addr, size uint64, ptr unsafe.Pointer) error
	MemWritePtr(addr, size uint64, ptr unsafe.Pointer) error
	RegisterContext
	Start(begin, until uint64) error
	Stop() error
	ContextAlloc() (Context, error)
	Hook(typ HookType, callback any, data any, begin, end uint64) (Hook, error)
}

type Hook

type Hook interface {
	io.Closer
	Type() HookType
}

type HookType

type HookType int

func (HookType) String

func (ht HookType) String() string

type InterruptCallback

type InterruptCallback = func(intno uint64, data any)

type InvalidCallback

type InvalidCallback = func(data any) bool

type MemProt

type MemProt int

const (
	MEM_PROT_NONE MemProt = 0
	MEM_PROT_READ MemProt = 1 << (iota - 1)
	MEM_PROT_WRITE
	MEM_PROT_EXEC

	MEM_PROT_ALL = MEM_PROT_READ | MEM_PROT_WRITE | MEM_PROT_EXEC
)

type MemRegion

type MemRegion struct {
	Addr, Size uint64
	Prot       MemProt
}

type MemoryCallback

type MemoryCallback = func(typ HookType, addr, size, value uint64, data any) bool

type Pointer

type Pointer struct {
	// contains filtered or unexported fields
}

func ToPointer

func ToPointer(emu Emulator, addr uint64) Pointer

func (Pointer) Add

func (p Pointer) Add(offset uint64) Pointer

func (Pointer) Address

func (p Pointer) Address() uint64

func (Pointer) IsNil

func (p Pointer) IsNil() bool

func (Pointer) MemRead

func (p Pointer) MemRead(size uint64) ([]byte, error)

func (Pointer) MemReadPointer

func (p Pointer) MemReadPointer() (ptr Pointer, err error)

func (Pointer) MemReadPtr

func (p Pointer) MemReadPtr(size uint64, ptr unsafe.Pointer) error

func (Pointer) MemReadString

func (p Pointer) MemReadString() (string, error)

func (Pointer) MemWrite

func (p Pointer) MemWrite(data []byte) error

func (Pointer) MemWritePtr

func (p Pointer) MemWritePtr(size uint64, ptr unsafe.Pointer) error

func (Pointer) ReadAt

func (p Pointer) ReadAt(b []byte, off int64) (n int, err error)

func (Pointer) Sub

func (p Pointer) Sub(offset uint64) Pointer

func (Pointer) WriteAt

func (p Pointer) WriteAt(b []byte, off int64) (n int, err error)

type Reg

type Reg int

type RegisterContext

type RegisterContext interface {
	RegRead(reg Reg) (uint64, error)
	RegWrite(reg Reg, value uint64) error
	RegReadPtr(reg Reg, ptr unsafe.Pointer) error
	RegWritePtr(reg Reg, ptr unsafe.Pointer) error
	RegReadBatch(regs ...Reg) ([]uint64, error)
	RegWriteBatch(regs []Reg, vals []uint64) error
}

type Uintptr32

type Uintptr32 = uint32

type Uintptr64

type Uintptr64 = uint64