make cleanup
This commit is contained in:
Stephen
@ -13,7 +13,7 @@ SAMPLE_X86 = $(TMP_DIR)/sample_x86
|
||||
|
||||
ENV_VARS = LD_LIBRARY_PATH=../ DYLD_LIBRARY_PATH=../
|
||||
|
||||
.PHONY: build install samples sample_python expected python sample_diff clean check
|
||||
.PHONY: build install expected python sample_diff clean check test
|
||||
|
||||
build:
|
||||
$(MAKE) -C python gen_const
|
||||
@ -26,9 +26,7 @@ install: build
|
||||
$(MAKE) -C python install
|
||||
$(MAKE) -C java install
|
||||
|
||||
samples: expected python
|
||||
|
||||
sample_python: expected python
|
||||
test: expected python sample_diff
|
||||
|
||||
expected:
|
||||
$(MAKE) -C ../samples
|
||||
@ -38,9 +36,11 @@ expected:
|
||||
$(ENV_VARS) ../samples/sample_mips > $(SAMPLE_MIPS)_e
|
||||
$(ENV_VARS) ../samples/sample_sparc > $(SAMPLE_SPARC)_e
|
||||
$(ENV_VARS) ../samples/sample_m68k > $(SAMPLE_M68K)_e
|
||||
$(ENV_VARS) ../samples/sample_x86 > $(SAMPLE_X86)_e
|
||||
$(ENV_VARS) ../samples/sample_x86 -16 > $(SAMPLE_X86)_e
|
||||
$(ENV_VARS) ../samples/sample_x86 -32 >> $(SAMPLE_X86)_e
|
||||
$(ENV_VARS) ../samples/sample_x86 -64 >> $(SAMPLE_X86)_e
|
||||
|
||||
python: FORCE
|
||||
python:
|
||||
$(MAKE) -C python
|
||||
$(ENV_VARS) python python/sample_arm.py > $(SAMPLE_ARM)_o
|
||||
$(ENV_VARS) python python/sample_arm64.py > $(SAMPLE_ARM64)_o
|
||||
@ -48,9 +48,8 @@ python: FORCE
|
||||
$(ENV_VARS) python python/sample_sparc.py > $(SAMPLE_SPARC)_o
|
||||
$(ENV_VARS) python python/sample_m68k.py > $(SAMPLE_M68K)_o
|
||||
$(ENV_VARS) python python/sample_x86.py > $(SAMPLE_X86)_o
|
||||
$(MAKE) sample_diff
|
||||
|
||||
sample_diff: FORCE
|
||||
sample_diff:
|
||||
$(DIFF) $(SAMPLE_ARM)_e $(SAMPLE_ARM)_o
|
||||
$(DIFF) $(SAMPLE_ARM64)_e $(SAMPLE_ARM64)_o
|
||||
$(DIFF) $(SAMPLE_MIPS)_e $(SAMPLE_MIPS)_o
|
||||
@ -65,5 +64,3 @@ clean:
|
||||
|
||||
check:
|
||||
make -C python check
|
||||
|
||||
FORCE:
|
||||
|
||||
28
bindings/go/unicorn/context.go
Normal file
28
bindings/go/unicorn/context.go
Normal file
@ -0,0 +1,28 @@
|
||||
package unicorn
|
||||
|
||||
import (
|
||||
"runtime"
|
||||
)
|
||||
|
||||
// #include <unicorn/unicorn.h>
|
||||
import "C"
|
||||
|
||||
type Context **C.uc_context
|
||||
|
||||
func (u *uc) ContextSave(reuse Context) (Context, error) {
|
||||
ctx := reuse
|
||||
if ctx == nil {
|
||||
ctx = new(*C.uc_context)
|
||||
}
|
||||
if err := errReturn(C.uc_context_alloc(u.handle, ctx)); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
runtime.SetFinalizer(ctx, func(p Context) { C.uc_context_free(*p) })
|
||||
if err := errReturn(C.uc_context_save(u.handle, *ctx)); err != nil {
|
||||
}
|
||||
return ctx, nil
|
||||
}
|
||||
|
||||
func (u *uc) ContextRestore(ctx Context) error {
|
||||
return errReturn(C.uc_context_restore(u.handle, *ctx))
|
||||
}
|
||||
26
bindings/go/unicorn/context_test.go
Normal file
26
bindings/go/unicorn/context_test.go
Normal file
@ -0,0 +1,26 @@
|
||||
package unicorn
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestContext(t *testing.T) {
|
||||
u, err := NewUnicorn(ARCH_X86, MODE_32)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
u.RegWrite(X86_REG_EBP, 100)
|
||||
ctx, err := u.ContextSave(nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
u.RegWrite(X86_REG_EBP, 200)
|
||||
err = u.ContextRestore(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
val, _ := u.RegRead(X86_REG_EBP)
|
||||
if val != 100 {
|
||||
t.Fatal("context restore failed")
|
||||
}
|
||||
}
|
||||
@ -55,6 +55,9 @@ type Unicorn interface {
|
||||
HookDel(hook Hook) error
|
||||
Query(queryType int) (uint64, error)
|
||||
Close() error
|
||||
|
||||
ContextSave(reuse Context) (Context, error)
|
||||
ContextRestore(Context) error
|
||||
}
|
||||
|
||||
type uc struct {
|
||||
|
||||
@ -40,6 +40,10 @@ x86Code32JmpInvalid = BS.pack [0xe9, 0xe9, 0xee, 0xee, 0xee, 0x41, 0x4a]
|
||||
x86Code32InOut :: BS.ByteString
|
||||
x86Code32InOut = BS.pack [0x41, 0xe4, 0x3f, 0x4a, 0xe6, 0x46, 0x43]
|
||||
|
||||
-- inc eax
|
||||
x86Code32Inc :: BS.ByteString
|
||||
x86Code32Inc = BS.pack [0x40]
|
||||
|
||||
x86Code64 :: BS.ByteString
|
||||
x86Code64 = BS.pack [0x41, 0xbc, 0x3b, 0xb0, 0x28, 0x2a, 0x49, 0x0f, 0xc9,
|
||||
0x90, 0x4d, 0x0f, 0xad, 0xcf, 0x49, 0x87, 0xfd, 0x90,
|
||||
@ -494,6 +498,70 @@ testI386InOut = do
|
||||
Left err -> putStrLn $ "Failed with error " ++ show err ++ ": " ++
|
||||
strerror err
|
||||
|
||||
-- Emulate code and save/restore the CPU context
|
||||
testI386ContextSave :: IO ()
|
||||
testI386ContextSave = do
|
||||
putStrLn "==================================="
|
||||
putStrLn "Save/restore CPU context in opaque blob"
|
||||
|
||||
result <- runEmulator $ do
|
||||
-- Initialize emulator in X86-32bit mode
|
||||
uc <- open ArchX86 [Mode32]
|
||||
|
||||
-- Map 8KB memory for this emulation
|
||||
memMap uc address (8 * 1024) [ProtAll]
|
||||
|
||||
-- Write machine code to be emulated to memory
|
||||
memWrite uc address x86Code32Inc
|
||||
|
||||
-- Initialize machine registers
|
||||
regWrite uc X86.Eax 0x1
|
||||
|
||||
-- Emulate machine code in infinite time
|
||||
emuPutStrLn ">>> Running emulation for the first time"
|
||||
|
||||
let codeLen = codeLength x86Code32Inc
|
||||
start uc address (address + codeLen) Nothing Nothing
|
||||
|
||||
-- Now print out some registers
|
||||
emuPutStrLn ">>> Emulation done. Below is the CPU context"
|
||||
|
||||
eax <- regRead uc X86.Eax
|
||||
|
||||
emuPutStrLn $ ">>> EAX = 0x" ++ showHex eax
|
||||
|
||||
-- Allocate and save the CPU context
|
||||
emuPutStrLn ">>> Saving CPU context"
|
||||
|
||||
context <- contextAllocate uc
|
||||
contextSave uc context
|
||||
|
||||
-- Emulate machine code again
|
||||
emuPutStrLn ">>> Running emulation for the second time"
|
||||
|
||||
start uc address (address + codeLen) Nothing Nothing
|
||||
|
||||
-- Now print out some registers
|
||||
emuPutStrLn ">>> Emulation done. Below is the CPU context"
|
||||
|
||||
eax <- regRead uc X86.Eax
|
||||
|
||||
emuPutStrLn $ ">>> EAX = 0x" ++ showHex eax
|
||||
|
||||
-- Restore CPU context
|
||||
contextRestore uc context
|
||||
|
||||
-- Now print out some registers
|
||||
emuPutStrLn ">>> Emulation done. Below is the CPU context"
|
||||
|
||||
eax <- regRead uc X86.Eax
|
||||
|
||||
emuPutStrLn $ ">>> EAX = 0x" ++ showHex eax
|
||||
case result of
|
||||
Right _ -> return ()
|
||||
Left err -> putStrLn $ "Failed with error " ++ show err ++ ": " ++
|
||||
strerror err
|
||||
|
||||
testX8664 :: IO ()
|
||||
testX8664 = do
|
||||
putStrLn "Emulate x86_64 code"
|
||||
@ -660,6 +728,7 @@ main = do
|
||||
["-32"] -> do
|
||||
testI386
|
||||
testI386InOut
|
||||
testI386ContextSave
|
||||
testI386Jump
|
||||
testI386Loop
|
||||
testI386InvalidMemRead
|
||||
|
||||
@ -9,41 +9,47 @@ framework based on QEMU.
|
||||
|
||||
Further information is available at <http://www.unicorn-engine.org>.
|
||||
-}
|
||||
module Unicorn (
|
||||
-- * Emulator control
|
||||
Emulator,
|
||||
Engine,
|
||||
Architecture(..),
|
||||
Mode(..),
|
||||
QueryType(..),
|
||||
runEmulator,
|
||||
open,
|
||||
query,
|
||||
start,
|
||||
stop,
|
||||
module Unicorn
|
||||
( -- * Emulator control
|
||||
Emulator
|
||||
, Engine
|
||||
, Architecture(..)
|
||||
, Mode(..)
|
||||
, QueryType(..)
|
||||
, runEmulator
|
||||
, open
|
||||
, query
|
||||
, start
|
||||
, stop
|
||||
|
||||
-- * Register operations
|
||||
regWrite,
|
||||
regRead,
|
||||
-- * Register operations
|
||||
, regWrite
|
||||
, regRead
|
||||
|
||||
-- * Memory operations
|
||||
MemoryPermission(..),
|
||||
MemoryRegion(..),
|
||||
memWrite,
|
||||
memRead,
|
||||
memMap,
|
||||
memUnmap,
|
||||
memProtect,
|
||||
memRegions,
|
||||
-- * Memory operations
|
||||
, MemoryPermission(..)
|
||||
, MemoryRegion(..)
|
||||
, memWrite
|
||||
, memRead
|
||||
, memMap
|
||||
, memUnmap
|
||||
, memProtect
|
||||
, memRegions
|
||||
|
||||
-- * Error handling
|
||||
Error(..),
|
||||
errno,
|
||||
strerror,
|
||||
-- * Context operations
|
||||
, Context
|
||||
, contextAllocate
|
||||
, contextSave
|
||||
, contextRestore
|
||||
|
||||
-- * Misc.
|
||||
version,
|
||||
) where
|
||||
-- * Error handling
|
||||
, Error(..)
|
||||
, errno
|
||||
, strerror
|
||||
|
||||
-- * Misc.
|
||||
, version
|
||||
) where
|
||||
|
||||
import Control.Monad (liftM)
|
||||
import Control.Monad.Trans.Class (lift)
|
||||
@ -132,8 +138,8 @@ stop uc = do
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
-- | Write to register.
|
||||
regWrite :: Reg r =>
|
||||
Engine -- ^ 'Unicorn' engine handle
|
||||
regWrite :: Reg r
|
||||
=> Engine -- ^ 'Unicorn' engine handle
|
||||
-> r -- ^ Register ID to write to
|
||||
-> Int64 -- ^ Value to write to register
|
||||
-> Emulator () -- ^ An 'Error' on failure
|
||||
@ -147,8 +153,8 @@ regWrite uc regId value = do
|
||||
left err
|
||||
|
||||
-- | Read register value.
|
||||
regRead :: Reg r =>
|
||||
Engine -- ^ 'Unicorn' engine handle
|
||||
regRead :: Reg r
|
||||
=> Engine -- ^ 'Unicorn' engine handle
|
||||
-> r -- ^ Register ID to read from
|
||||
-> Emulator Int64 -- ^ The value read from the register on success,
|
||||
-- or an 'Error' on failure
|
||||
@ -259,6 +265,46 @@ memRegions uc = do
|
||||
else
|
||||
left err
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
-- Context operations
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
-- | Allocate a region that can be used to perform quick save/rollback of the
|
||||
-- CPU context, which includes registers and some internal metadata. Contexts
|
||||
-- may not be shared across engine instances with differing architectures or
|
||||
-- modes.
|
||||
contextAllocate :: Engine -- ^ 'Unicon' engine handle
|
||||
-> Emulator Context -- ^ A CPU context
|
||||
contextAllocate uc = do
|
||||
(err, contextPtr) <- lift $ ucContextAlloc uc
|
||||
if err == ErrOk then
|
||||
-- Return a CPU context if ucContextAlloc completed successfully
|
||||
lift $ mkContext contextPtr
|
||||
else
|
||||
left err
|
||||
|
||||
-- | Save a copy of the internal CPU context.
|
||||
contextSave :: Engine -- ^ 'Unicorn' engine handle
|
||||
-> Context -- ^ A CPU context
|
||||
-> Emulator () -- ^ An error on failure
|
||||
contextSave uc context = do
|
||||
err <- lift $ ucContextSave uc context
|
||||
if err == ErrOk then
|
||||
right ()
|
||||
else
|
||||
left err
|
||||
|
||||
-- | Restore the current CPU context from a saved copy.
|
||||
contextRestore :: Engine -- ^ 'Unicorn' engine handle
|
||||
-> Context -- ^ A CPU context
|
||||
-> Emulator () -- ^ An error on failure
|
||||
contextRestore uc context = do
|
||||
err <- lift $ ucContextRestore uc context
|
||||
if err == ErrOk then
|
||||
right ()
|
||||
else
|
||||
left err
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
-- Misc.
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
@ -8,22 +8,25 @@ License : GPL-2
|
||||
|
||||
Definitions for the ARM architecture.
|
||||
-}
|
||||
module Unicorn.CPU.Arm (
|
||||
Register(..),
|
||||
) where
|
||||
module Unicorn.CPU.Arm
|
||||
(
|
||||
Register(..)
|
||||
) where
|
||||
|
||||
import Unicorn.Internal.Core (Reg)
|
||||
|
||||
{# context lib="unicorn" #}
|
||||
{# context lib = "unicorn" #}
|
||||
|
||||
#include <unicorn/arm.h>
|
||||
|
||||
-- | ARM registers.
|
||||
{# enum uc_arm_reg as Register
|
||||
{underscoreToCase}
|
||||
omit (UC_ARM_REG_INVALID,
|
||||
UC_ARM_REG_ENDING)
|
||||
with prefix="UC_ARM_REG_"
|
||||
deriving (Show, Eq, Bounded) #}
|
||||
{ underscoreToCase }
|
||||
omit ( UC_ARM_REG_INVALID
|
||||
, UC_ARM_REG_ENDING
|
||||
)
|
||||
with prefix = "UC_ARM_REG_"
|
||||
deriving (Show, Eq, Bounded)
|
||||
#}
|
||||
|
||||
instance Reg Register
|
||||
|
||||
@ -8,22 +8,25 @@ License : GPL-2
|
||||
|
||||
Definitions for the ARM64 (ARMv8) architecture.
|
||||
-}
|
||||
module Unicorn.CPU.Arm64 (
|
||||
Register(..),
|
||||
) where
|
||||
module Unicorn.CPU.Arm64
|
||||
(
|
||||
Register(..)
|
||||
) where
|
||||
|
||||
import Unicorn.Internal.Core (Reg)
|
||||
|
||||
{# context lib="unicorn" #}
|
||||
{# context lib = "unicorn" #}
|
||||
|
||||
#include <unicorn/arm64.h>
|
||||
|
||||
-- | ARM64 registers.
|
||||
{# enum uc_arm64_reg as Register
|
||||
{underscoreToCase}
|
||||
omit (UC_ARM64_REG_INVALID,
|
||||
UC_ARM64_REG_ENDING)
|
||||
with prefix="UC_ARM64_REG_"
|
||||
deriving (Show, Eq, Bounded) #}
|
||||
{ underscoreToCase }
|
||||
omit ( UC_ARM64_REG_INVALID
|
||||
, UC_ARM64_REG_ENDING
|
||||
)
|
||||
with prefix = "UC_ARM64_REG_"
|
||||
deriving (Show, Eq, Bounded)
|
||||
#}
|
||||
|
||||
instance Reg Register
|
||||
|
||||
@ -8,22 +8,25 @@ License : GPL-2
|
||||
|
||||
Definitions for the MK68K architecture.
|
||||
-}
|
||||
module Unicorn.CPU.M68k (
|
||||
Register(..),
|
||||
) where
|
||||
module Unicorn.CPU.M68k
|
||||
(
|
||||
Register(..)
|
||||
) where
|
||||
|
||||
import Unicorn.Internal.Core (Reg)
|
||||
|
||||
{# context lib="unicorn" #}
|
||||
{# context lib = "unicorn" #}
|
||||
|
||||
#include <unicorn/m68k.h>
|
||||
|
||||
-- | M68K registers.
|
||||
{# enum uc_m68k_reg as Register
|
||||
{underscoreToCase}
|
||||
omit (UC_M68K_REG_INVALID,
|
||||
UC_M68K_REG_ENDING)
|
||||
with prefix="UC_M68K_REG_"
|
||||
deriving (Show, Eq, Bounded) #}
|
||||
{ underscoreToCase }
|
||||
omit ( UC_M68K_REG_INVALID
|
||||
, UC_M68K_REG_ENDING
|
||||
)
|
||||
with prefix = "UC_M68K_REG_"
|
||||
deriving (Show, Eq, Bounded)
|
||||
#}
|
||||
|
||||
instance Reg Register
|
||||
|
||||
@ -8,54 +8,58 @@ License : GPL-2
|
||||
|
||||
Definitions for the MIPS architecture.
|
||||
-}
|
||||
module Unicorn.CPU.Mips (
|
||||
Register(..),
|
||||
) where
|
||||
module Unicorn.CPU.Mips
|
||||
(
|
||||
Register(..)
|
||||
) where
|
||||
|
||||
import Unicorn.Internal.Core (Reg)
|
||||
|
||||
{# context lib="unicorn" #}
|
||||
{# context lib = "unicorn" #}
|
||||
|
||||
#include <unicorn/mips.h>
|
||||
|
||||
-- | MIPS registers.
|
||||
{# enum UC_MIPS_REG as Register
|
||||
{underscoreToCase,
|
||||
UC_MIPS_REG_0 as Reg0,
|
||||
UC_MIPS_REG_1 as Reg1,
|
||||
UC_MIPS_REG_2 as Reg2,
|
||||
UC_MIPS_REG_3 as Reg3,
|
||||
UC_MIPS_REG_4 as Reg4,
|
||||
UC_MIPS_REG_5 as Reg5,
|
||||
UC_MIPS_REG_6 as Reg6,
|
||||
UC_MIPS_REG_7 as Reg7,
|
||||
UC_MIPS_REG_8 as Reg8,
|
||||
UC_MIPS_REG_9 as Reg9,
|
||||
UC_MIPS_REG_10 as Reg10,
|
||||
UC_MIPS_REG_11 as Reg11,
|
||||
UC_MIPS_REG_12 as Reg12,
|
||||
UC_MIPS_REG_13 as Reg13,
|
||||
UC_MIPS_REG_14 as Reg14,
|
||||
UC_MIPS_REG_15 as Reg15,
|
||||
UC_MIPS_REG_16 as Reg16,
|
||||
UC_MIPS_REG_17 as Reg17,
|
||||
UC_MIPS_REG_18 as Reg18,
|
||||
UC_MIPS_REG_19 as Reg19,
|
||||
UC_MIPS_REG_20 as Reg20,
|
||||
UC_MIPS_REG_21 as Reg21,
|
||||
UC_MIPS_REG_22 as Reg22,
|
||||
UC_MIPS_REG_23 as Reg23,
|
||||
UC_MIPS_REG_24 as Reg24,
|
||||
UC_MIPS_REG_25 as Reg25,
|
||||
UC_MIPS_REG_26 as Reg26,
|
||||
UC_MIPS_REG_27 as Reg27,
|
||||
UC_MIPS_REG_28 as Reg28,
|
||||
UC_MIPS_REG_29 as Reg29,
|
||||
UC_MIPS_REG_30 as Reg30,
|
||||
UC_MIPS_REG_31 as Reg31}
|
||||
omit (UC_MIPS_REG_INVALID,
|
||||
UC_MIPS_REG_ENDING)
|
||||
with prefix="UC_MIPS_REG_"
|
||||
deriving (Show, Eq, Bounded) #}
|
||||
{ underscoreToCase
|
||||
, UC_MIPS_REG_0 as Reg0g
|
||||
, UC_MIPS_REG_1 as Reg1g
|
||||
, UC_MIPS_REG_2 as Reg2g
|
||||
, UC_MIPS_REG_3 as Reg3g
|
||||
, UC_MIPS_REG_4 as Reg4g
|
||||
, UC_MIPS_REG_5 as Reg5g
|
||||
, UC_MIPS_REG_6 as Reg6g
|
||||
, UC_MIPS_REG_7 as Reg7g
|
||||
, UC_MIPS_REG_8 as Reg8g
|
||||
, UC_MIPS_REG_9 as Reg9g
|
||||
, UC_MIPS_REG_10 as Reg10g
|
||||
, UC_MIPS_REG_11 as Reg11g
|
||||
, UC_MIPS_REG_12 as Reg12g
|
||||
, UC_MIPS_REG_13 as Reg13g
|
||||
, UC_MIPS_REG_14 as Reg14g
|
||||
, UC_MIPS_REG_15 as Reg15g
|
||||
, UC_MIPS_REG_16 as Reg16g
|
||||
, UC_MIPS_REG_17 as Reg17g
|
||||
, UC_MIPS_REG_18 as Reg18g
|
||||
, UC_MIPS_REG_19 as Reg19g
|
||||
, UC_MIPS_REG_20 as Reg20g
|
||||
, UC_MIPS_REG_21 as Reg21g
|
||||
, UC_MIPS_REG_22 as Reg22g
|
||||
, UC_MIPS_REG_23 as Reg23g
|
||||
, UC_MIPS_REG_24 as Reg24g
|
||||
, UC_MIPS_REG_25 as Reg25g
|
||||
, UC_MIPS_REG_26 as Reg26g
|
||||
, UC_MIPS_REG_27 as Reg27g
|
||||
, UC_MIPS_REG_28 as Reg28g
|
||||
, UC_MIPS_REG_29 as Reg29g
|
||||
, UC_MIPS_REG_30 as Reg30g
|
||||
, UC_MIPS_REG_31 as Reg31
|
||||
}
|
||||
omit ( UC_MIPS_REG_INVALID
|
||||
, UC_MIPS_REG_ENDING
|
||||
)
|
||||
with prefix = "UC_MIPS_REG_"
|
||||
deriving (Show, Eq, Bounded)
|
||||
#}
|
||||
|
||||
instance Reg Register
|
||||
|
||||
@ -8,22 +8,25 @@ License : GPL-2
|
||||
|
||||
Definitions for the SPARC architecture.
|
||||
-}
|
||||
module Unicorn.CPU.Sparc (
|
||||
Register(..),
|
||||
) where
|
||||
module Unicorn.CPU.Sparc
|
||||
(
|
||||
Register(..)
|
||||
) where
|
||||
|
||||
import Unicorn.Internal.Core (Reg)
|
||||
|
||||
{# context lib="unicorn" #}
|
||||
{# context lib = "unicorn" #}
|
||||
|
||||
#include <unicorn/sparc.h>
|
||||
|
||||
-- | SPARC registers.
|
||||
{# enum uc_sparc_reg as Register
|
||||
{underscoreToCase}
|
||||
omit (UC_SPARC_REG_INVALID,
|
||||
UC_SPARC_REG_ENDING)
|
||||
with prefix="UC_SPARC_REG_"
|
||||
deriving (Show, Eq, Bounded) #}
|
||||
{ underscoreToCase }
|
||||
omit (UC_SPARC_REG_INVALID
|
||||
, UC_SPARC_REG_ENDING
|
||||
)
|
||||
with prefix = "UC_SPARC_REG_"
|
||||
deriving (Show, Eq, Bounded)
|
||||
#}
|
||||
|
||||
instance Reg Register
|
||||
|
||||
@ -8,11 +8,12 @@ License : GPL-2
|
||||
|
||||
Definitions for the X86 architecture.
|
||||
-}
|
||||
module Unicorn.CPU.X86 (
|
||||
Mmr(..),
|
||||
Register(..),
|
||||
Instruction(..),
|
||||
) where
|
||||
module Unicorn.CPU.X86
|
||||
(
|
||||
Mmr(..)
|
||||
, Register(..)
|
||||
, Instruction(..)
|
||||
) where
|
||||
|
||||
import Control.Applicative
|
||||
import Data.Word
|
||||
@ -20,18 +21,18 @@ import Foreign
|
||||
|
||||
import Unicorn.Internal.Core (Reg)
|
||||
|
||||
{# context lib="unicorn" #}
|
||||
{# context lib = "unicorn" #}
|
||||
|
||||
#include <unicorn/x86.h>
|
||||
|
||||
-- | Memory-managemen Register for instructions IDTR, GDTR, LDTR, TR.
|
||||
-- Borrow from SegmentCache in qemu/target-i386/cpu.h
|
||||
data Mmr = Mmr {
|
||||
mmrSelector :: Word16, -- ^ Not used by GDTR and IDTR
|
||||
mmrBase :: Word64, -- ^ Handle 32 or 64 bit CPUs
|
||||
mmrLimit :: Word32,
|
||||
mmrFlags :: Word32 -- ^ Not used by GDTR and IDTR
|
||||
}
|
||||
data Mmr = Mmr
|
||||
{ mmrSelector :: Word16 -- ^ Not used by GDTR and IDTR
|
||||
, mmrBase :: Word64 -- ^ Handle 32 or 64 bit CPUs
|
||||
, mmrLimit :: Word32
|
||||
, mmrFlags :: Word32 -- ^ Not used by GDTR and IDTR
|
||||
}
|
||||
|
||||
instance Storable Mmr where
|
||||
sizeOf _ = {# sizeof uc_x86_mmr #}
|
||||
@ -48,18 +49,22 @@ instance Storable Mmr where
|
||||
|
||||
-- | X86 registers.
|
||||
{# enum uc_x86_reg as Register
|
||||
{underscoreToCase}
|
||||
omit (UC_X86_REG_INVALID,
|
||||
UC_X86_REG_ENDING)
|
||||
with prefix="UC_X86_REG_"
|
||||
deriving (Show, Eq, Bounded) #}
|
||||
{ underscoreToCase }
|
||||
omit ( UC_X86_REG_INVALID
|
||||
, UC_X86_REG_ENDING
|
||||
)
|
||||
with prefix = "UC_X86_REG_"
|
||||
deriving (Show, Eq, Bounded)
|
||||
#}
|
||||
|
||||
instance Reg Register
|
||||
|
||||
-- | X86 instructions.
|
||||
{# enum uc_x86_insn as Instruction
|
||||
{underscoreToCase}
|
||||
omit (UC_X86_INS_INVALID,
|
||||
UC_X86_INS_ENDING)
|
||||
with prefix="UC_X86_INS_"
|
||||
deriving (Show, Eq, Bounded) #}
|
||||
{ underscoreToCase }
|
||||
omit ( UC_X86_INS_INVALID
|
||||
, UC_X86_INS_ENDING
|
||||
)
|
||||
with prefix = "UC_X86_INS_"
|
||||
deriving (Show, Eq, Bounded)
|
||||
#}
|
||||
|
||||
@ -6,36 +6,36 @@ License : GPL-2
|
||||
|
||||
Insert hook points into the Unicorn emulator engine.
|
||||
-}
|
||||
module Unicorn.Hook (
|
||||
-- * Hook types
|
||||
Hook,
|
||||
MemoryHookType(..),
|
||||
MemoryEventHookType(..),
|
||||
MemoryAccess(..),
|
||||
module Unicorn.Hook
|
||||
( -- * Hook types
|
||||
Hook
|
||||
, MemoryHookType(..)
|
||||
, MemoryEventHookType(..)
|
||||
, MemoryAccess(..)
|
||||
|
||||
-- * Hook callbacks
|
||||
CodeHook,
|
||||
InterruptHook,
|
||||
BlockHook,
|
||||
InHook,
|
||||
OutHook,
|
||||
SyscallHook,
|
||||
MemoryHook,
|
||||
MemoryReadHook,
|
||||
MemoryWriteHook,
|
||||
MemoryEventHook,
|
||||
-- * Hook callbacks
|
||||
, CodeHook
|
||||
, InterruptHook
|
||||
, BlockHook
|
||||
, InHook
|
||||
, OutHook
|
||||
, SyscallHook
|
||||
, MemoryHook
|
||||
, MemoryReadHook
|
||||
, MemoryWriteHook
|
||||
, MemoryEventHook
|
||||
|
||||
-- * Hook callback management
|
||||
codeHookAdd,
|
||||
interruptHookAdd,
|
||||
blockHookAdd,
|
||||
inHookAdd,
|
||||
outHookAdd,
|
||||
syscallHookAdd,
|
||||
memoryHookAdd,
|
||||
memoryEventHookAdd,
|
||||
hookDel,
|
||||
) where
|
||||
-- * Hook callback management
|
||||
, codeHookAdd
|
||||
, interruptHookAdd
|
||||
, blockHookAdd
|
||||
, inHookAdd
|
||||
, outHookAdd
|
||||
, syscallHookAdd
|
||||
, memoryHookAdd
|
||||
, memoryEventHookAdd
|
||||
, hookDel
|
||||
) where
|
||||
|
||||
import Control.Monad
|
||||
import Control.Monad.Trans.Class
|
||||
@ -213,7 +213,8 @@ hookDel uc hook = do
|
||||
-- Takes the tuple returned by `ucHookAdd`, an IO (Error, Hook), and
|
||||
-- returns either a `Right Hook` if no error occurred or a `Left Error` if an
|
||||
-- error occurred
|
||||
getResult :: IO (Error, Hook) -> IO (Either Error Hook)
|
||||
getResult :: IO (Error, Hook)
|
||||
-> IO (Either Error Hook)
|
||||
getResult =
|
||||
liftM (uncurry checkResult)
|
||||
where checkResult err hook =
|
||||
|
||||
@ -17,31 +17,34 @@ import Control.Monad
|
||||
import Control.Monad.Trans.Either (EitherT)
|
||||
import Foreign
|
||||
|
||||
{# context lib="unicorn" #}
|
||||
{# context lib = "unicorn" #}
|
||||
|
||||
#include <unicorn/unicorn.h>
|
||||
#include "unicorn_wrapper.h"
|
||||
|
||||
-- | The Unicorn engine.
|
||||
{# pointer *uc_engine as Engine
|
||||
foreign finalizer uc_close_wrapper as close
|
||||
newtype #}
|
||||
foreign finalizer uc_close_wrapper as close
|
||||
newtype
|
||||
#}
|
||||
|
||||
-- | A pointer to a Unicorn engine.
|
||||
{# pointer *uc_engine as EnginePtr -> Engine #}
|
||||
|
||||
-- | Make a new Unicorn engine out of an engine pointer. The returned Unicorn
|
||||
-- engine will automatically call 'uc_close_wrapper' when it goes out of scope.
|
||||
mkEngine :: EnginePtr -> IO Engine
|
||||
mkEngine :: EnginePtr
|
||||
-> IO Engine
|
||||
mkEngine ptr =
|
||||
liftM Engine (newForeignPtr close ptr)
|
||||
|
||||
-- | Errors encountered by the Unicorn API. These values are returned by
|
||||
-- 'errno'.
|
||||
{# enum uc_err as Error
|
||||
{underscoreToCase}
|
||||
with prefix="UC_"
|
||||
deriving (Show, Eq, Bounded) #}
|
||||
{ underscoreToCase }
|
||||
with prefix = "UC_"
|
||||
deriving (Show, Eq, Bounded)
|
||||
#}
|
||||
|
||||
-- | The emulator runs in the IO monad and allows for the handling of errors
|
||||
-- "under the hood".
|
||||
|
||||
@ -11,54 +11,54 @@ Low-level bindings for inserting hook points into the Unicorn emulator engine.
|
||||
This module should not be directly imported; it is only exposed because of the
|
||||
way cabal handles ordering of chs files.
|
||||
-}
|
||||
module Unicorn.Internal.Hook (
|
||||
-- * Types
|
||||
Hook,
|
||||
HookType(..),
|
||||
MemoryHookType(..),
|
||||
MemoryEventHookType(..),
|
||||
MemoryAccess(..),
|
||||
module Unicorn.Internal.Hook
|
||||
( -- * Types
|
||||
Hook
|
||||
, HookType(..)
|
||||
, MemoryHookType(..)
|
||||
, MemoryEventHookType(..)
|
||||
, MemoryAccess(..)
|
||||
|
||||
-- * Hook callback bindings
|
||||
CodeHook,
|
||||
InterruptHook,
|
||||
BlockHook,
|
||||
InHook,
|
||||
OutHook,
|
||||
SyscallHook,
|
||||
MemoryHook,
|
||||
MemoryReadHook,
|
||||
MemoryWriteHook,
|
||||
MemoryEventHook,
|
||||
-- * Hook callback bindings
|
||||
, CodeHook
|
||||
, InterruptHook
|
||||
, BlockHook
|
||||
, InHook
|
||||
, OutHook
|
||||
, SyscallHook
|
||||
, MemoryHook
|
||||
, MemoryReadHook
|
||||
, MemoryWriteHook
|
||||
, MemoryEventHook
|
||||
|
||||
-- * Hook marshalling
|
||||
marshalCodeHook,
|
||||
marshalInterruptHook,
|
||||
marshalBlockHook,
|
||||
marshalInHook,
|
||||
marshalOutHook,
|
||||
marshalSyscallHook,
|
||||
marshalMemoryHook,
|
||||
marshalMemoryReadHook,
|
||||
marshalMemoryWriteHook,
|
||||
marshalMemoryEventHook,
|
||||
-- * Hook marshallin
|
||||
, marshalCodeHook
|
||||
, marshalInterruptHook
|
||||
, marshalBlockHook
|
||||
, marshalInHook
|
||||
, marshalOutHook
|
||||
, marshalSyscallHook
|
||||
, marshalMemoryHook
|
||||
, marshalMemoryReadHook
|
||||
, marshalMemoryWriteHook
|
||||
, marshalMemoryEventHook
|
||||
|
||||
-- * Hook registration and deletion bindings
|
||||
ucHookAdd,
|
||||
ucInsnHookAdd,
|
||||
ucHookDel,
|
||||
) where
|
||||
-- * Hook registration and deletion bindings
|
||||
, ucHookAdd
|
||||
, ucInsnHookAdd
|
||||
, ucHookDel
|
||||
) where
|
||||
|
||||
import Control.Monad
|
||||
import Foreign
|
||||
|
||||
import Unicorn.Internal.Util
|
||||
|
||||
{# context lib="unicorn" #}
|
||||
|
||||
{# import Unicorn.Internal.Core #}
|
||||
{# import Unicorn.CPU.X86 #}
|
||||
|
||||
{# context lib = "unicorn" #}
|
||||
|
||||
#include <unicorn/unicorn.h>
|
||||
#include "unicorn_wrapper.h"
|
||||
|
||||
@ -79,7 +79,8 @@ import Unicorn.Internal.Util
|
||||
foreign import ccall "&uc_close_dummy"
|
||||
closeDummy :: FunPtr (EnginePtr -> IO ())
|
||||
|
||||
mkEngineNC :: EnginePtr -> IO Engine
|
||||
mkEngineNC :: EnginePtr
|
||||
-> IO Engine
|
||||
mkEngineNC ptr =
|
||||
liftM Engine (newForeignPtr closeDummy ptr)
|
||||
|
||||
@ -92,47 +93,55 @@ type Hook = {# type uc_hook #}
|
||||
-- Note that the both valid and invalid memory access hooks are omitted from
|
||||
-- this enum (and are exposed to the user).
|
||||
{# enum uc_hook_type as HookType
|
||||
{underscoreToCase}
|
||||
omit (UC_HOOK_MEM_READ_UNMAPPED,
|
||||
UC_HOOK_MEM_WRITE_UNMAPPED,
|
||||
UC_HOOK_MEM_FETCH_UNMAPPED,
|
||||
UC_HOOK_MEM_READ_PROT,
|
||||
UC_HOOK_MEM_WRITE_PROT,
|
||||
UC_HOOK_MEM_FETCH_PROT,
|
||||
UC_HOOK_MEM_READ,
|
||||
UC_HOOK_MEM_WRITE,
|
||||
UC_HOOK_MEM_FETCH)
|
||||
with prefix="UC_"
|
||||
deriving (Show, Eq, Bounded) #}
|
||||
{ underscoreToCase }
|
||||
omit ( UC_HOOK_MEM_READ_UNMAPPED
|
||||
, UC_HOOK_MEM_WRITE_UNMAPPED
|
||||
, UC_HOOK_MEM_FETCH_UNMAPPED
|
||||
, UC_HOOK_MEM_READ_PROT
|
||||
, UC_HOOK_MEM_WRITE_PROT
|
||||
, UC_HOOK_MEM_FETCH_PROT
|
||||
, UC_HOOK_MEM_READ
|
||||
, UC_HOOK_MEM_WRITE
|
||||
, UC_HOOK_MEM_FETCH
|
||||
, UC_HOOK_MEM_READ_AFTER
|
||||
)
|
||||
with prefix = "UC_"
|
||||
deriving (Show, Eq, Bounded)
|
||||
#}
|
||||
|
||||
-- | Memory hook types (for valid memory accesses).
|
||||
{# enum uc_hook_type as MemoryHookType
|
||||
{underscoreToCase}
|
||||
omit (UC_HOOK_INTR,
|
||||
UC_HOOK_INSN,
|
||||
UC_HOOK_CODE,
|
||||
UC_HOOK_BLOCK,
|
||||
UC_HOOK_MEM_READ_UNMAPPED,
|
||||
UC_HOOK_MEM_WRITE_UNMAPPED,
|
||||
UC_HOOK_MEM_FETCH_UNMAPPED,
|
||||
UC_HOOK_MEM_READ_PROT,
|
||||
UC_HOOK_MEM_WRITE_PROT,
|
||||
UC_HOOK_MEM_FETCH_PROT)
|
||||
with prefix="UC_"
|
||||
deriving (Show, Eq, Bounded) #}
|
||||
{ underscoreToCase }
|
||||
omit ( UC_HOOK_INTR
|
||||
, UC_HOOK_INSN
|
||||
, UC_HOOK_CODE
|
||||
, UC_HOOK_BLOCK
|
||||
, UC_HOOK_MEM_READ_UNMAPPED
|
||||
, UC_HOOK_MEM_WRITE_UNMAPPED
|
||||
, UC_HOOK_MEM_FETCH_UNMAPPED
|
||||
, UC_HOOK_MEM_READ_PROT
|
||||
, UC_HOOK_MEM_WRITE_PROT
|
||||
, UC_HOOK_MEM_FETCH_PROT
|
||||
)
|
||||
with prefix = "UC_"
|
||||
deriving (Show, Eq, Bounded)
|
||||
#}
|
||||
|
||||
-- | Memory event hook types (for invalid memory accesses).
|
||||
{# enum uc_hook_type as MemoryEventHookType
|
||||
{underscoreToCase}
|
||||
omit (UC_HOOK_INTR,
|
||||
UC_HOOK_INSN,
|
||||
UC_HOOK_CODE,
|
||||
UC_HOOK_BLOCK,
|
||||
UC_HOOK_MEM_READ,
|
||||
UC_HOOK_MEM_WRITE,
|
||||
UC_HOOK_MEM_FETCH)
|
||||
with prefix="UC_"
|
||||
deriving (Show, Eq, Bounded) #}
|
||||
{ underscoreToCase }
|
||||
omit ( UC_HOOK_INTR
|
||||
, UC_HOOK_INSN
|
||||
, UC_HOOK_CODE
|
||||
, UC_HOOK_BLOCK
|
||||
, UC_HOOK_MEM_READ
|
||||
, UC_HOOK_MEM_WRITE
|
||||
, UC_HOOK_MEM_FETCH
|
||||
, UC_HOOK_MEM_READ_AFTER
|
||||
)
|
||||
with prefix = "UC_"
|
||||
deriving (Show, Eq, Bounded)
|
||||
#}
|
||||
|
||||
-- | Unify the hook types with a type class
|
||||
class Enum a => HookTypeC a
|
||||
@ -143,9 +152,10 @@ instance HookTypeC MemoryEventHookType
|
||||
|
||||
-- | Memory access.
|
||||
{# enum uc_mem_type as MemoryAccess
|
||||
{underscoreToCase}
|
||||
with prefix="UC_"
|
||||
deriving (Show, Eq, Bounded) #}
|
||||
{ underscoreToCase }
|
||||
with prefix = "UC_"
|
||||
deriving (Show, Eq, Bounded)
|
||||
#}
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
-- Hook callbacks
|
||||
@ -159,16 +169,18 @@ type CodeHook a = Engine -- ^ 'Unicorn' engine handle
|
||||
-> a -- ^ User data passed to tracing APIs
|
||||
-> IO ()
|
||||
|
||||
type CCodeHook = EnginePtr -> Word64 -> Word32 -> Ptr () -> IO ()
|
||||
type CCodeHook = EnginePtr -> Word64 -> Word32 -> Ptr () -> IO ()
|
||||
|
||||
foreign import ccall "wrapper"
|
||||
mkCodeHook :: CCodeHook -> IO {# type uc_cb_hookcode_t #}
|
||||
mkCodeHook :: CCodeHook
|
||||
-> IO {# type uc_cb_hookcode_t #}
|
||||
|
||||
marshalCodeHook :: Storable a
|
||||
=> CodeHook a -> IO {# type uc_cb_hookcode_t #}
|
||||
=> CodeHook a
|
||||
-> IO {# type uc_cb_hookcode_t #}
|
||||
marshalCodeHook codeHook =
|
||||
mkCodeHook $ \ucPtr address size userDataPtr -> do
|
||||
uc <- mkEngineNC ucPtr
|
||||
uc <- mkEngineNC ucPtr
|
||||
userData <- castPtrAndPeek userDataPtr
|
||||
let maybeSize = if size == 0 then Nothing
|
||||
else Just $ fromIntegral size
|
||||
@ -186,10 +198,11 @@ foreign import ccall "wrapper"
|
||||
mkInterruptHook :: CInterruptHook -> IO {# type uc_cb_hookintr_t #}
|
||||
|
||||
marshalInterruptHook :: Storable a
|
||||
=> InterruptHook a -> IO {# type uc_cb_hookintr_t #}
|
||||
=> InterruptHook a
|
||||
-> IO {# type uc_cb_hookintr_t #}
|
||||
marshalInterruptHook interruptHook =
|
||||
mkInterruptHook $ \ucPtr intNo userDataPtr -> do
|
||||
uc <- mkEngineNC ucPtr
|
||||
uc <- mkEngineNC ucPtr
|
||||
userData <- castPtrAndPeek userDataPtr
|
||||
interruptHook uc (fromIntegral intNo) userData
|
||||
|
||||
@ -197,7 +210,8 @@ marshalInterruptHook interruptHook =
|
||||
type BlockHook a = CodeHook a
|
||||
|
||||
marshalBlockHook :: Storable a
|
||||
=> BlockHook a -> IO {# type uc_cb_hookcode_t #}
|
||||
=> BlockHook a
|
||||
-> IO {# type uc_cb_hookcode_t #}
|
||||
marshalBlockHook =
|
||||
marshalCodeHook
|
||||
|
||||
@ -214,10 +228,11 @@ foreign import ccall "wrapper"
|
||||
mkInHook :: CInHook -> IO {# type uc_cb_insn_in_t #}
|
||||
|
||||
marshalInHook :: Storable a
|
||||
=> InHook a -> IO {# type uc_cb_insn_in_t #}
|
||||
=> InHook a
|
||||
-> IO {# type uc_cb_insn_in_t #}
|
||||
marshalInHook inHook =
|
||||
mkInHook $ \ucPtr port size userDataPtr -> do
|
||||
uc <- mkEngineNC ucPtr
|
||||
uc <- mkEngineNC ucPtr
|
||||
userData <- castPtrAndPeek userDataPtr
|
||||
inHook uc (fromIntegral port) (fromIntegral size) userData
|
||||
|
||||
@ -232,13 +247,15 @@ type OutHook a = Engine -- ^ 'Unicorn' engine handle
|
||||
type COutHook = EnginePtr -> Word32 -> Int32 -> Word32 -> Ptr () -> IO ()
|
||||
|
||||
foreign import ccall "wrapper"
|
||||
mkOutHook :: COutHook -> IO {# type uc_cb_insn_out_t #}
|
||||
mkOutHook :: COutHook
|
||||
-> IO {# type uc_cb_insn_out_t #}
|
||||
|
||||
marshalOutHook :: Storable a
|
||||
=> OutHook a -> IO {# type uc_cb_insn_out_t #}
|
||||
=> OutHook a
|
||||
-> IO {# type uc_cb_insn_out_t #}
|
||||
marshalOutHook outHook =
|
||||
mkOutHook $ \ucPtr port size value userDataPtr -> do
|
||||
uc <- mkEngineNC ucPtr
|
||||
uc <- mkEngineNC ucPtr
|
||||
userData <- castPtrAndPeek userDataPtr
|
||||
outHook uc (fromIntegral port) (fromIntegral size) (fromIntegral value)
|
||||
userData
|
||||
@ -251,13 +268,15 @@ type SyscallHook a = Engine -- ^ 'Unicorn' engine handle
|
||||
type CSyscallHook = Ptr () -> Ptr () -> IO ()
|
||||
|
||||
foreign import ccall "wrapper"
|
||||
mkSyscallHook :: CSyscallHook -> IO {# type uc_cb_insn_syscall_t #}
|
||||
mkSyscallHook :: CSyscallHook
|
||||
-> IO {# type uc_cb_insn_syscall_t #}
|
||||
|
||||
marshalSyscallHook :: Storable a
|
||||
=> SyscallHook a -> IO {# type uc_cb_insn_syscall_t #}
|
||||
=> SyscallHook a
|
||||
-> IO {# type uc_cb_insn_syscall_t #}
|
||||
marshalSyscallHook syscallHook =
|
||||
mkSyscallHook $ \ucPtr userDataPtr -> do
|
||||
uc <- mkEngineNC $ castPtr ucPtr
|
||||
uc <- mkEngineNC $ castPtr ucPtr
|
||||
userData <- castPtrAndPeek userDataPtr
|
||||
syscallHook uc userData
|
||||
|
||||
@ -281,13 +300,15 @@ type CMemoryHook = EnginePtr
|
||||
-> IO ()
|
||||
|
||||
foreign import ccall "wrapper"
|
||||
mkMemoryHook :: CMemoryHook -> IO {# type uc_cb_hookmem_t #}
|
||||
mkMemoryHook :: CMemoryHook
|
||||
-> IO {# type uc_cb_hookmem_t #}
|
||||
|
||||
marshalMemoryHook :: Storable a
|
||||
=> MemoryHook a -> IO {# type uc_cb_hookmem_t #}
|
||||
=> MemoryHook a
|
||||
-> IO {# type uc_cb_hookmem_t #}
|
||||
marshalMemoryHook memoryHook =
|
||||
mkMemoryHook $ \ucPtr memAccessI address size value userDataPtr -> do
|
||||
uc <- mkEngineNC ucPtr
|
||||
uc <- mkEngineNC ucPtr
|
||||
userData <- castPtrAndPeek userDataPtr
|
||||
let memAccess = toMemAccess memAccessI
|
||||
maybeValue = case memAccess of
|
||||
@ -304,10 +325,11 @@ type MemoryReadHook a = Engine -- ^ 'Unicorn' engine handle
|
||||
-> IO ()
|
||||
|
||||
marshalMemoryReadHook :: Storable a
|
||||
=> MemoryReadHook a -> IO {# type uc_cb_hookmem_t #}
|
||||
=> MemoryReadHook a
|
||||
-> IO {# type uc_cb_hookmem_t #}
|
||||
marshalMemoryReadHook memoryReadHook =
|
||||
mkMemoryHook $ \ucPtr _ address size _ userDataPtr -> do
|
||||
uc <- mkEngineNC ucPtr
|
||||
uc <- mkEngineNC ucPtr
|
||||
userData <- castPtrAndPeek userDataPtr
|
||||
memoryReadHook uc address (fromIntegral size) userData
|
||||
|
||||
@ -321,10 +343,11 @@ type MemoryWriteHook a = Engine -- ^ 'Unicorn' engine handle
|
||||
-> IO ()
|
||||
|
||||
marshalMemoryWriteHook :: Storable a
|
||||
=> MemoryWriteHook a -> IO {# type uc_cb_hookmem_t #}
|
||||
=> MemoryWriteHook a
|
||||
-> IO {# type uc_cb_hookmem_t #}
|
||||
marshalMemoryWriteHook memoryWriteHook =
|
||||
mkMemoryHook $ \ucPtr _ address size value userDataPtr -> do
|
||||
uc <- mkEngineNC ucPtr
|
||||
uc <- mkEngineNC ucPtr
|
||||
userData <- castPtrAndPeek userDataPtr
|
||||
memoryWriteHook uc address (fromIntegral size) (fromIntegral value)
|
||||
userData
|
||||
@ -351,15 +374,17 @@ type CMemoryEventHook = EnginePtr
|
||||
-> IO Int32
|
||||
|
||||
foreign import ccall "wrapper"
|
||||
mkMemoryEventHook :: CMemoryEventHook -> IO {# type uc_cb_eventmem_t #}
|
||||
mkMemoryEventHook :: CMemoryEventHook
|
||||
-> IO {# type uc_cb_eventmem_t #}
|
||||
|
||||
marshalMemoryEventHook :: Storable a
|
||||
=> MemoryEventHook a -> IO {# type uc_cb_eventmem_t #}
|
||||
=> MemoryEventHook a
|
||||
-> IO {# type uc_cb_eventmem_t #}
|
||||
marshalMemoryEventHook eventMemoryHook =
|
||||
mkMemoryEventHook $ \ucPtr memAccessI address size value userDataPtr -> do
|
||||
uc <- mkEngineNC ucPtr
|
||||
uc <- mkEngineNC ucPtr
|
||||
userData <- castPtrAndPeek userDataPtr
|
||||
let memAccess = toMemAccess memAccessI
|
||||
let memAccess = toMemAccess memAccessI
|
||||
maybeValue = case memAccess of
|
||||
MemReadUnmapped -> Nothing
|
||||
MemReadProt -> Nothing
|
||||
@ -369,7 +394,7 @@ marshalMemoryEventHook eventMemoryHook =
|
||||
res <- eventMemoryHook uc memAccess address (fromIntegral size)
|
||||
maybeValue userData
|
||||
return $ boolToInt res
|
||||
where boolToInt True = 1
|
||||
where boolToInt True = 1
|
||||
boolToInt False = 0
|
||||
|
||||
|
||||
@ -378,38 +403,43 @@ marshalMemoryEventHook eventMemoryHook =
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
{# fun variadic uc_hook_add as ucHookAdd
|
||||
`(Storable a, HookTypeC h)' =>
|
||||
{`Engine',
|
||||
alloca- `Hook' peek*,
|
||||
enumToNum `h',
|
||||
castFunPtrToPtr `FunPtr b',
|
||||
castPtr `Ptr a',
|
||||
`Word64',
|
||||
`Word64'}
|
||||
-> `Error' #}
|
||||
`HookTypeC h' =>
|
||||
{ `Engine'
|
||||
, alloca- `Hook' peek*
|
||||
, enumToNum `h'
|
||||
, castFunPtrToPtr `FunPtr b'
|
||||
, castPtr `Ptr a'
|
||||
, `Word64'
|
||||
, `Word64'
|
||||
} -> `Error'
|
||||
#}
|
||||
|
||||
{# fun variadic uc_hook_add[int] as ucInsnHookAdd
|
||||
`(Storable a, HookTypeC h)' =>
|
||||
{`Engine',
|
||||
alloca- `Hook' peek*,
|
||||
enumToNum `h',
|
||||
castFunPtrToPtr `FunPtr b',
|
||||
castPtr `Ptr a',
|
||||
`Word64',
|
||||
`Word64',
|
||||
enumToNum `Instruction'}
|
||||
-> `Error' #}
|
||||
`HookTypeC h' =>
|
||||
{ `Engine'
|
||||
, alloca- `Hook' peek*
|
||||
, enumToNum `h'
|
||||
, castFunPtrToPtr `FunPtr b'
|
||||
, castPtr `Ptr a'
|
||||
, `Word64'
|
||||
, `Word64'
|
||||
, enumToNum `Instruction'
|
||||
} -> `Error'
|
||||
#}
|
||||
|
||||
-- | Unregister (remove) a hook callback.
|
||||
{# fun uc_hook_del as ^
|
||||
{`Engine',
|
||||
fromIntegral `Hook'}
|
||||
-> `Error' #}
|
||||
{ `Engine'
|
||||
, fromIntegral `Hook'
|
||||
} -> `Error'
|
||||
#}
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
-- Helper functions
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
toMemAccess :: Integral a => a -> MemoryAccess
|
||||
toMemAccess :: Integral a
|
||||
=> a
|
||||
-> MemoryAccess
|
||||
toMemAccess =
|
||||
toEnum . fromIntegral
|
||||
|
||||
@ -12,33 +12,39 @@ Low-level bindings for the Unicorn CPU emulator framework.
|
||||
This module should not be directly imported; it is only exposed because of the
|
||||
way cabal handles ordering of chs files.
|
||||
-}
|
||||
module Unicorn.Internal.Unicorn (
|
||||
-- * Types
|
||||
Architecture(..),
|
||||
Mode(..),
|
||||
MemoryPermission(..),
|
||||
MemoryRegion(..),
|
||||
QueryType(..),
|
||||
module Unicorn.Internal.Unicorn
|
||||
( -- * Types
|
||||
Architecture(..)
|
||||
, Mode(..)
|
||||
, MemoryPermission(..)
|
||||
, MemoryRegion(..)
|
||||
, QueryType(..)
|
||||
, Context
|
||||
|
||||
-- * Function bindings
|
||||
ucOpen,
|
||||
ucQuery,
|
||||
ucEmuStart,
|
||||
ucEmuStop,
|
||||
ucRegWrite,
|
||||
ucRegRead,
|
||||
ucMemWrite,
|
||||
ucMemRead,
|
||||
ucMemMap,
|
||||
ucMemUnmap,
|
||||
ucMemProtect,
|
||||
ucMemRegions,
|
||||
ucVersion,
|
||||
ucErrno,
|
||||
ucStrerror,
|
||||
) where
|
||||
-- * Function bindings
|
||||
, ucOpen
|
||||
, ucQuery
|
||||
, ucEmuStart
|
||||
, ucEmuStop
|
||||
, ucRegWrite
|
||||
, ucRegRead
|
||||
, ucMemWrite
|
||||
, ucMemRead
|
||||
, ucMemMap
|
||||
, ucMemUnmap
|
||||
, ucMemProtect
|
||||
, ucMemRegions
|
||||
, mkContext
|
||||
, ucContextAlloc
|
||||
, ucContextSave
|
||||
, ucContextRestore
|
||||
, ucVersion
|
||||
, ucErrno
|
||||
, ucStrerror
|
||||
) where
|
||||
|
||||
import Control.Applicative
|
||||
import Control.Monad
|
||||
import Data.ByteString (ByteString, useAsCStringLen)
|
||||
import Foreign
|
||||
import Foreign.C
|
||||
@ -46,11 +52,12 @@ import Prelude hiding (until)
|
||||
|
||||
import Unicorn.Internal.Util
|
||||
|
||||
{# context lib="unicorn" #}
|
||||
|
||||
{# import Unicorn.Internal.Core #}
|
||||
|
||||
{# context lib = "unicorn" #}
|
||||
|
||||
#include <unicorn/unicorn.h>
|
||||
#include "unicorn_wrapper.h"
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
-- Types
|
||||
@ -58,29 +65,33 @@ import Unicorn.Internal.Util
|
||||
|
||||
-- | CPU architecture.
|
||||
{# enum uc_arch as Architecture
|
||||
{underscoreToCase}
|
||||
with prefix="UC_"
|
||||
deriving (Show, Eq, Bounded) #}
|
||||
{ underscoreToCase }
|
||||
with prefix = "UC_"
|
||||
deriving (Show, Eq, Bounded)
|
||||
#}
|
||||
|
||||
-- | CPU hardware mode.
|
||||
{# enum uc_mode as Mode
|
||||
{underscoreToCase}
|
||||
with prefix="UC_"
|
||||
deriving (Show, Eq, Bounded) #}
|
||||
{ underscoreToCase }
|
||||
with prefix = "UC_"
|
||||
deriving (Show, Eq, Bounded)
|
||||
#}
|
||||
|
||||
-- | Memory permissions.
|
||||
{# enum uc_prot as MemoryPermission
|
||||
{underscoreToCase}
|
||||
with prefix="UC_"
|
||||
deriving (Show, Eq, Bounded) #}
|
||||
{ underscoreToCase }
|
||||
with prefix = "UC_"
|
||||
deriving (Show, Eq, Bounded)
|
||||
#}
|
||||
|
||||
-- | Memory region mapped by 'memMap'. Retrieve the list of memory regions with
|
||||
-- 'memRegions'.
|
||||
data MemoryRegion = MemoryRegion {
|
||||
mrBegin :: Word64, -- ^ Begin address of the region (inclusive)
|
||||
mrEnd :: Word64, -- ^ End address of the region (inclusive)
|
||||
mrPerms :: [MemoryPermission] -- ^ Memory permissions of the region
|
||||
}
|
||||
data MemoryRegion = MemoryRegion
|
||||
{
|
||||
mrBegin :: Word64 -- ^ Begin address of the region (inclusive)
|
||||
, mrEnd :: Word64 -- ^ End address of the region (inclusive)
|
||||
, mrPerms :: [MemoryPermission] -- ^ Memory permissions of the region
|
||||
}
|
||||
|
||||
instance Storable MemoryRegion where
|
||||
sizeOf _ = {# sizeof uc_mem_region #}
|
||||
@ -99,121 +110,174 @@ instance Storable MemoryRegion where
|
||||
|
||||
-- | Query types for the 'query' API.
|
||||
{# enum uc_query_type as QueryType
|
||||
{underscoreToCase}
|
||||
with prefix="UC_"
|
||||
deriving (Show, Eq, Bounded) #}
|
||||
{ underscoreToCase }
|
||||
with prefix = "UC_"
|
||||
deriving (Show, Eq, Bounded)
|
||||
#}
|
||||
|
||||
-- | Opaque storage for CPU context, used with the context functions.
|
||||
{# pointer *uc_context as Context
|
||||
foreign finalizer uc_context_free_wrapper as contextFree
|
||||
newtype
|
||||
#}
|
||||
|
||||
-- | A pointer to a CPU context.
|
||||
{# pointer *uc_context as ContextPtr -> Context #}
|
||||
|
||||
-- | Make a CPU context out of a context pointer. The returned CPU context will
|
||||
-- automatically call 'uc_context_free' when it goes out of scope.
|
||||
mkContext :: ContextPtr
|
||||
-> IO Context
|
||||
mkContext ptr =
|
||||
liftM Context (newForeignPtr contextFree ptr)
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
-- Emulator control
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
{# fun uc_open as ^
|
||||
{`Architecture',
|
||||
combineEnums `[Mode]',
|
||||
alloca- `EnginePtr' peek*}
|
||||
-> `Error' #}
|
||||
{ `Architecture'
|
||||
, combineEnums `[Mode]'
|
||||
, alloca- `EnginePtr' peek*
|
||||
} -> `Error'
|
||||
#}
|
||||
|
||||
{# fun uc_query as ^
|
||||
{`Engine',
|
||||
`QueryType',
|
||||
alloca- `Int' castPtrAndPeek*}
|
||||
-> `Error' #}
|
||||
{ `Engine'
|
||||
, `QueryType'
|
||||
, alloca- `Int' castPtrAndPeek*
|
||||
} -> `Error'
|
||||
#}
|
||||
|
||||
{# fun uc_emu_start as ^
|
||||
{`Engine',
|
||||
`Word64',
|
||||
`Word64',
|
||||
`Int',
|
||||
`Int'}
|
||||
-> `Error' #}
|
||||
{ `Engine'
|
||||
, `Word64'
|
||||
, `Word64'
|
||||
, `Int'
|
||||
, `Int'} -> `Error'
|
||||
#}
|
||||
|
||||
{# fun uc_emu_stop as ^
|
||||
{`Engine'}
|
||||
-> `Error' #}
|
||||
{ `Engine'
|
||||
} -> `Error'
|
||||
#}
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
-- Register operations
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
{# fun uc_reg_write as ^
|
||||
`Reg r' =>
|
||||
{`Engine',
|
||||
enumToNum `r',
|
||||
castPtr `Ptr Int64'}
|
||||
-> `Error' #}
|
||||
`Reg r' =>
|
||||
{ `Engine'
|
||||
, enumToNum `r'
|
||||
, castPtr `Ptr Int64'
|
||||
} -> `Error'
|
||||
#}
|
||||
|
||||
{# fun uc_reg_read as ^
|
||||
`Reg r' =>
|
||||
{`Engine',
|
||||
enumToNum `r',
|
||||
allocaInt64ToVoid- `Int64' castPtrAndPeek*}
|
||||
-> `Error' #}
|
||||
`Reg r' =>
|
||||
{ `Engine'
|
||||
, enumToNum `r'
|
||||
, allocaInt64ToVoid- `Int64' castPtrAndPeek*
|
||||
} -> `Error'
|
||||
#}
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
-- Memory operations
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
{# fun uc_mem_write as ^
|
||||
{`Engine',
|
||||
`Word64',
|
||||
withByteStringLen* `ByteString'&}
|
||||
-> `Error' #}
|
||||
{ `Engine'
|
||||
, `Word64'
|
||||
, withByteStringLen* `ByteString'&
|
||||
} -> `Error'
|
||||
#}
|
||||
|
||||
{# fun uc_mem_read as ^
|
||||
{`Engine',
|
||||
`Word64',
|
||||
castPtr `Ptr Word8',
|
||||
`Int'}
|
||||
-> `Error' #}
|
||||
{ `Engine'
|
||||
, `Word64'
|
||||
, castPtr `Ptr Word8'
|
||||
, `Int'} -> `Error'
|
||||
#}
|
||||
|
||||
{# fun uc_mem_map as ^
|
||||
{`Engine',
|
||||
`Word64',
|
||||
`Int',
|
||||
combineEnums `[MemoryPermission]'}
|
||||
-> `Error' #}
|
||||
{ `Engine'
|
||||
, `Word64'
|
||||
, `Int'
|
||||
, combineEnums `[MemoryPermission]'
|
||||
} -> `Error' #}
|
||||
|
||||
{# fun uc_mem_unmap as ^
|
||||
{`Engine',
|
||||
`Word64',
|
||||
`Int'}
|
||||
-> `Error' #}
|
||||
{ `Engine'
|
||||
, `Word64'
|
||||
, `Int'
|
||||
} -> `Error'
|
||||
#}
|
||||
|
||||
{# fun uc_mem_protect as ^
|
||||
{`Engine',
|
||||
`Word64',
|
||||
`Int',
|
||||
combineEnums `[MemoryPermission]'}
|
||||
-> `Error' #}
|
||||
{ `Engine'
|
||||
, `Word64'
|
||||
, `Int'
|
||||
, combineEnums `[MemoryPermission]'
|
||||
} -> `Error'
|
||||
#}
|
||||
|
||||
{# fun uc_mem_regions as ^
|
||||
{`Engine',
|
||||
alloca- `MemoryRegionPtr' peek*,
|
||||
alloca- `Int' castPtrAndPeek*}
|
||||
-> `Error' #}
|
||||
{ `Engine'
|
||||
, alloca- `MemoryRegionPtr' peek*
|
||||
, alloca- `Int' castPtrAndPeek*
|
||||
} -> `Error'
|
||||
#}
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
-- Context
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
{# fun uc_context_alloc as ^
|
||||
{ `Engine'
|
||||
, alloca- `ContextPtr' peek*
|
||||
} -> `Error'
|
||||
#}
|
||||
|
||||
{# fun uc_context_save as ^
|
||||
{ `Engine'
|
||||
, `Context'
|
||||
} -> `Error'
|
||||
#}
|
||||
|
||||
{# fun uc_context_restore as ^
|
||||
{ `Engine'
|
||||
, `Context'
|
||||
} -> `Error'
|
||||
#}
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
-- Misc.
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
{# fun pure unsafe uc_version as ^
|
||||
{id `Ptr CUInt',
|
||||
id `Ptr CUInt'}
|
||||
-> `Int' #}
|
||||
{ id `Ptr CUInt'
|
||||
, id `Ptr CUInt'
|
||||
} -> `Int'
|
||||
#}
|
||||
|
||||
{# fun unsafe uc_errno as ^
|
||||
{`Engine'}
|
||||
-> `Error' #}
|
||||
{ `Engine'
|
||||
} -> `Error'
|
||||
#}
|
||||
|
||||
{# fun pure unsafe uc_strerror as ^
|
||||
{`Error'}
|
||||
-> `String' #}
|
||||
{ `Error'
|
||||
} -> `String'
|
||||
#}
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
-- Helper functions
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
expandMemPerms :: (Integral a, Bits a) => a -> [MemoryPermission]
|
||||
expandMemPerms :: (Integral a, Bits a)
|
||||
=> a
|
||||
-> [MemoryPermission]
|
||||
expandMemPerms perms =
|
||||
-- Only interested in the 3 least-significant bits
|
||||
let maskedPerms = fromIntegral $ perms .&. 0x7 in
|
||||
@ -232,10 +296,13 @@ expandMemPerms perms =
|
||||
checkRWE _ [] =
|
||||
[]
|
||||
|
||||
allocaInt64ToVoid :: (Ptr () -> IO b) -> IO b
|
||||
allocaInt64ToVoid :: (Ptr () -> IO b)
|
||||
-> IO b
|
||||
allocaInt64ToVoid f =
|
||||
alloca $ \(ptr :: Ptr Int64) -> poke ptr 0 >> f (castPtr ptr)
|
||||
|
||||
withByteStringLen :: ByteString -> ((Ptr (), CULong) -> IO a) -> IO a
|
||||
withByteStringLen :: ByteString
|
||||
-> ((Ptr (), CULong) -> IO a)
|
||||
-> IO a
|
||||
withByteStringLen bs f =
|
||||
useAsCStringLen bs $ \(ptr, len) -> f (castPtr ptr, fromIntegral len)
|
||||
|
||||
@ -10,16 +10,22 @@ import Data.Bits
|
||||
import Foreign
|
||||
|
||||
-- | Combine a list of Enums by performing a bitwise-OR.
|
||||
combineEnums :: (Enum a, Num b, Bits b) => [a] -> b
|
||||
combineEnums :: (Enum a, Num b, Bits b)
|
||||
=> [a]
|
||||
-> b
|
||||
combineEnums =
|
||||
foldr ((.|.) <$> enumToNum) 0
|
||||
|
||||
-- | Cast a pointer and then peek inside it.
|
||||
castPtrAndPeek :: Storable a => Ptr b -> IO a
|
||||
castPtrAndPeek :: Storable a
|
||||
=> Ptr b
|
||||
-> IO a
|
||||
castPtrAndPeek =
|
||||
peek . castPtr
|
||||
|
||||
-- | Convert an 'Eum' to a 'Num'.
|
||||
enumToNum :: (Enum a, Num b) => a -> b
|
||||
enumToNum :: (Enum a, Num b)
|
||||
=> a
|
||||
-> b
|
||||
enumToNum =
|
||||
fromIntegral . fromEnum
|
||||
|
||||
@ -6,3 +6,7 @@ void uc_close_wrapper(uc_engine *uc) {
|
||||
|
||||
void uc_close_dummy(uc_engine *uc) {
|
||||
}
|
||||
|
||||
void uc_context_free_wrapper(uc_context *context) {
|
||||
uc_context_free(context);
|
||||
}
|
||||
|
||||
@ -13,4 +13,9 @@ void uc_close_wrapper(uc_engine *uc);
|
||||
*/
|
||||
void uc_close_dummy(uc_engine *uc);
|
||||
|
||||
/*
|
||||
* Wrap Unicorn's uc_context_free function and ignore the returned error code.
|
||||
*/
|
||||
void uc_context_free_wrapper(uc_context *context);
|
||||
|
||||
#endif
|
||||
|
||||
@ -13,8 +13,9 @@ copyright: (c) 2016, Adrian Herrera
|
||||
category: System
|
||||
build-type: Simple
|
||||
stability: experimental
|
||||
cabal-version: >=1.10
|
||||
extra-source-files: cbits/, include/
|
||||
cabal-version: >= 1.10
|
||||
extra-source-files: cbits/
|
||||
, include/
|
||||
|
||||
library
|
||||
exposed-modules: Unicorn.Internal.Core
|
||||
@ -29,10 +30,10 @@ library
|
||||
Unicorn.Hook
|
||||
Unicorn
|
||||
other-modules: Unicorn.Internal.Util
|
||||
build-depends: base >=4 && <5,
|
||||
bytestring >= 0.9.1,
|
||||
transformers < 0.6,
|
||||
either >= 4.4
|
||||
build-depends: base >=4 && <5
|
||||
, bytestring >= 0.9.1
|
||||
, transformers < 0.6
|
||||
, either >= 4.4
|
||||
hs-source-dirs: src
|
||||
c-sources: src/cbits/unicorn_wrapper.c
|
||||
include-dirs: src/include
|
||||
|
||||
@ -21,7 +21,7 @@ def hook_block(uc, address, size, user_data):
|
||||
|
||||
# callback for tracing instructions
|
||||
def hook_code(uc, address, size, user_data):
|
||||
print(">>> Tracing instruction at 0x%x, instruction size = %u" %(address, size))
|
||||
print(">>> Tracing instruction at 0x%x, instruction size = 0x%x" %(address, size))
|
||||
|
||||
|
||||
# Test ARM
|
||||
@ -46,7 +46,7 @@ def test_arm():
|
||||
mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
||||
|
||||
# tracing all instructions with customized callback
|
||||
mu.hook_add(UC_HOOK_CODE, hook_code)
|
||||
mu.hook_add(UC_HOOK_CODE, hook_code, begin=ADDRESS, end=ADDRESS)
|
||||
|
||||
# emulate machine code in infinite time
|
||||
mu.emu_start(ADDRESS, ADDRESS + len(ARM_CODE))
|
||||
@ -100,5 +100,5 @@ def test_thumb():
|
||||
|
||||
if __name__ == '__main__':
|
||||
test_arm()
|
||||
print("=" * 20)
|
||||
print("=" * 26)
|
||||
test_thumb()
|
||||
|
||||
@ -21,7 +21,7 @@ def hook_block(uc, address, size, user_data):
|
||||
|
||||
# callback for tracing instructions
|
||||
def hook_code(uc, address, size, user_data):
|
||||
print(">>> Tracing instruction at 0x%x, instruction size = %u" %(address, size))
|
||||
print(">>> Tracing instruction at 0x%x, instruction size = 0x%x" %(address, size))
|
||||
|
||||
|
||||
# Test ARM64
|
||||
|
||||
@ -20,7 +20,7 @@ def hook_block(uc, address, size, user_data):
|
||||
|
||||
# callback for tracing instructions
|
||||
def hook_code(uc, address, size, user_data):
|
||||
print(">>> Tracing instruction at 0x%x, instruction size = %u" %(address, size))
|
||||
print(">>> Tracing instruction at 0x%x, instruction size = 0x%x" %(address, size))
|
||||
|
||||
|
||||
# Test ARM
|
||||
@ -51,8 +51,34 @@ def test_m68k():
|
||||
# now print out some registers
|
||||
print(">>> Emulation done. Below is the CPU context")
|
||||
|
||||
a0 = mu.reg_read(UC_M68K_REG_A0)
|
||||
a1 = mu.reg_read(UC_M68K_REG_A1)
|
||||
a2 = mu.reg_read(UC_M68K_REG_A2)
|
||||
a3 = mu.reg_read(UC_M68K_REG_A3)
|
||||
a4 = mu.reg_read(UC_M68K_REG_A4)
|
||||
a5 = mu.reg_read(UC_M68K_REG_A5)
|
||||
a6 = mu.reg_read(UC_M68K_REG_A6)
|
||||
a7 = mu.reg_read(UC_M68K_REG_A7)
|
||||
d0 = mu.reg_read(UC_M68K_REG_D0)
|
||||
d1 = mu.reg_read(UC_M68K_REG_D1)
|
||||
d2 = mu.reg_read(UC_M68K_REG_D2)
|
||||
d3 = mu.reg_read(UC_M68K_REG_D3)
|
||||
print(">>> D3 = 0x%x" %d3)
|
||||
d4 = mu.reg_read(UC_M68K_REG_D4)
|
||||
d5 = mu.reg_read(UC_M68K_REG_D5)
|
||||
d6 = mu.reg_read(UC_M68K_REG_D6)
|
||||
d7 = mu.reg_read(UC_M68K_REG_D7)
|
||||
pc = mu.reg_read(UC_M68K_REG_PC)
|
||||
sr = mu.reg_read(UC_M68K_REG_SR)
|
||||
print(">>> A0 = 0x%x\t\t>>> D0 = 0x%x" % (a0, d0))
|
||||
print(">>> A1 = 0x%x\t\t>>> D1 = 0x%x" % (a1, d1))
|
||||
print(">>> A2 = 0x%x\t\t>>> D2 = 0x%x" % (a2, d2))
|
||||
print(">>> A3 = 0x%x\t\t>>> D3 = 0x%x" % (a3, d3))
|
||||
print(">>> A4 = 0x%x\t\t>>> D4 = 0x%x" % (a4, d4))
|
||||
print(">>> A5 = 0x%x\t\t>>> D5 = 0x%x" % (a5, d5))
|
||||
print(">>> A6 = 0x%x\t\t>>> D6 = 0x%x" % (a6, d6))
|
||||
print(">>> A7 = 0x%x\t\t>>> D7 = 0x%x" % (a7, d7))
|
||||
print(">>> PC = 0x%x" % pc)
|
||||
print(">>> SR = 0x%x" % sr)
|
||||
|
||||
except UcError as e:
|
||||
print("ERROR: %s" % e)
|
||||
|
||||
@ -22,7 +22,7 @@ def hook_block(uc, address, size, user_data):
|
||||
|
||||
# callback for tracing instructions
|
||||
def hook_code(uc, address, size, user_data):
|
||||
print(">>> Tracing instruction at 0x%x, instruction size = %u" %(address, size))
|
||||
print(">>> Tracing instruction at 0x%x, instruction size = 0x%x" %(address, size))
|
||||
|
||||
|
||||
# Test MIPS EB
|
||||
@ -54,7 +54,7 @@ def test_mips_eb():
|
||||
print(">>> Emulation done. Below is the CPU context")
|
||||
|
||||
r1 = mu.reg_read(UC_MIPS_REG_1)
|
||||
print(">>> r1 = 0x%x" %r1)
|
||||
print(">>> R1 = 0x%x" %r1)
|
||||
|
||||
except UcError as e:
|
||||
print("ERROR: %s" % e)
|
||||
@ -89,7 +89,7 @@ def test_mips_el():
|
||||
print(">>> Emulation done. Below is the CPU context")
|
||||
|
||||
r1 = mu.reg_read(UC_MIPS_REG_1)
|
||||
print(">>> r1 = 0x%x" %r1)
|
||||
print(">>> R1 = 0x%x" %r1)
|
||||
|
||||
except UcError as e:
|
||||
print("ERROR: %s" % e)
|
||||
@ -97,5 +97,5 @@ def test_mips_el():
|
||||
|
||||
if __name__ == '__main__':
|
||||
test_mips_eb()
|
||||
print("=" * 20)
|
||||
print("=" * 27)
|
||||
test_mips_el()
|
||||
|
||||
@ -20,7 +20,7 @@ def hook_block(uc, address, size, user_data):
|
||||
|
||||
# callback for tracing instructions
|
||||
def hook_code(uc, address, size, user_data):
|
||||
print(">>> Tracing instruction at 0x%x, instruction size = %u" %(address, size))
|
||||
print(">>> Tracing instruction at 0x%x, instruction size = 0x%x" %(address, size))
|
||||
|
||||
|
||||
# Test SPARC
|
||||
|
||||
@ -8,6 +8,8 @@ from unicorn.x86_const import *
|
||||
|
||||
X86_CODE32 = b"\x41\x4a\x66\x0f\xef\xc1" # INC ecx; DEC edx; PXOR xmm0, xmm1
|
||||
X86_CODE32_LOOP = b"\x41\x4a\xeb\xfe" # INC ecx; DEC edx; JMP self-loop
|
||||
X86_CODE32_JUMP = b"\xeb\x02\x90\x90\x90\x90\x90\x90" # jmp 4; nop; nop; nop; nop; nop; nop
|
||||
X86_CODE32_JMP_INVALID = b"\xe9\xe9\xee\xee\xee\x41\x4a" # JMP outside; INC ecx; DEC edx
|
||||
X86_CODE32_MEM_READ = b"\x8B\x0D\xAA\xAA\xAA\xAA\x41\x4a" # mov ecx,[0xaaaaaaaa]; INC ecx; DEC edx
|
||||
X86_CODE32_MEM_WRITE = b"\x89\x0D\xAA\xAA\xAA\xAA\x41\x4a" # mov [0xaaaaaaaa], ecx; INC ecx; DEC edx
|
||||
X86_CODE64 = b"\x41\xBC\x3B\xB0\x28\x2A\x49\x0F\xC9\x90\x4D\x0F\xAD\xCF\x49\x87\xFD\x90\x48\x81\xD2\x8A\xCE\x77\x35\x48\xF7\xD9\x4D\x29\xF4\x49\x81\xC9\xF6\x8A\xC6\x53\x4D\x87\xED\x48\x0F\xAD\xD2\x49\xF7\xD4\x48\xF7\xE1\x4D\x19\xC5\x4D\x89\xC5\x48\xF7\xD6\x41\xB8\x4F\x8D\x6B\x59\x4D\x87\xD0\x68\x6A\x1E\x09\x3C\x59"
|
||||
@ -26,9 +28,14 @@ def hook_block(uc, address, size, user_data):
|
||||
|
||||
# callback for tracing instructions
|
||||
def hook_code(uc, address, size, user_data):
|
||||
print(">>> Tracing instruction at 0x%x, instruction size = %u" %(address, size))
|
||||
#eip = uc.reg_read(UC_X86_REG_EIP)
|
||||
#print(">>> EIP = 0x%x" %(eip))
|
||||
print(">>> Tracing instruction at 0x%x, instruction size = 0x%x" %(address, size))
|
||||
eip = uc.reg_read(UC_X86_REG_EFLAGS)
|
||||
print(">>> --- EFLAGS is 0x%x" %(eip))
|
||||
|
||||
def hook_code64(uc, address, size, user_data):
|
||||
print(">>> Tracing instruction at 0x%x, instruction size = 0x%x" %(address, size))
|
||||
rip = uc.reg_read(UC_X86_REG_RIP)
|
||||
print(">>> RIP is 0x%x" %rip);
|
||||
|
||||
|
||||
# callback for tracing invalid memory access (READ or WRITE)
|
||||
@ -128,21 +135,21 @@ def test_i386():
|
||||
r_xmm0 = mu.reg_read(UC_X86_REG_XMM0)
|
||||
print(">>> ECX = 0x%x" %r_ecx)
|
||||
print(">>> EDX = 0x%x" %r_edx)
|
||||
print(">>> XMM0 = 0x%x" %r_xmm0)
|
||||
print(">>> XMM0 = 0x%.32x" %r_xmm0)
|
||||
|
||||
# read from memory
|
||||
tmp = mu.mem_read(ADDRESS, 2)
|
||||
print(">>> Read 2 bytes from [0x%x] =" %(ADDRESS), end="")
|
||||
for i in tmp:
|
||||
print(" 0x%x" %i, end="")
|
||||
tmp = mu.mem_read(ADDRESS, 4)
|
||||
print(">>> Read 4 bytes from [0x%x] = 0x" %(ADDRESS), end="")
|
||||
for i in reversed(tmp):
|
||||
print("%x" %(i), end="")
|
||||
print("")
|
||||
|
||||
except UcError as e:
|
||||
print("ERROR: %s" % e)
|
||||
|
||||
|
||||
def test_i386_loop():
|
||||
print("Emulate i386 code with infinite loop - wait for 2 seconds then stop emulation")
|
||||
def test_i386_map_ptr():
|
||||
print("Emulate i386 code - use uc_mem_map_ptr()")
|
||||
try:
|
||||
# Initialize emulator in X86-32bit mode
|
||||
mu = Uc(UC_ARCH_X86, UC_MODE_32)
|
||||
@ -151,14 +158,20 @@ def test_i386_loop():
|
||||
mu.mem_map(ADDRESS, 2 * 1024 * 1024)
|
||||
|
||||
# write machine code to be emulated to memory
|
||||
mu.mem_write(ADDRESS, X86_CODE32_LOOP)
|
||||
mu.mem_write(ADDRESS, X86_CODE32)
|
||||
|
||||
# initialize machine registers
|
||||
mu.reg_write(UC_X86_REG_ECX, 0x1234)
|
||||
mu.reg_write(UC_X86_REG_EDX, 0x7890)
|
||||
|
||||
# tracing all basic blocks with customized callback
|
||||
mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
||||
|
||||
# tracing all instructions with customized callback
|
||||
mu.hook_add(UC_HOOK_CODE, hook_code)
|
||||
|
||||
# emulate machine code in infinite time
|
||||
mu.emu_start(ADDRESS, ADDRESS + len(X86_CODE32_LOOP), 2 * UC_SECOND_SCALE)
|
||||
mu.emu_start(ADDRESS, ADDRESS + len(X86_CODE32), 2 * UC_SECOND_SCALE)
|
||||
|
||||
# now print out some registers
|
||||
print(">>> Emulation done. Below is the CPU context")
|
||||
@ -168,6 +181,13 @@ def test_i386_loop():
|
||||
print(">>> ECX = 0x%x" %r_ecx)
|
||||
print(">>> EDX = 0x%x" %r_edx)
|
||||
|
||||
# read from memory
|
||||
tmp = mu.mem_read(ADDRESS, 4)
|
||||
print(">>> Read 4 bytes from [0x%x] = 0x" %(ADDRESS), end="")
|
||||
for i in reversed(tmp):
|
||||
print("%x" %(i), end="")
|
||||
print("")
|
||||
|
||||
except UcError as e:
|
||||
print("ERROR: %s" % e)
|
||||
|
||||
@ -198,7 +218,7 @@ def test_i386_invalid_mem_read():
|
||||
# emulate machine code in infinite time
|
||||
mu.emu_start(ADDRESS, ADDRESS + len(X86_CODE32_MEM_READ))
|
||||
except UcError as e:
|
||||
print("ERROR: %s" % e)
|
||||
print("Failed on uc_emu_start() with error returned 6: %s" % e)
|
||||
|
||||
# now print out some registers
|
||||
print(">>> Emulation done. Below is the CPU context")
|
||||
@ -211,6 +231,35 @@ def test_i386_invalid_mem_read():
|
||||
except UcError as e:
|
||||
print("ERROR: %s" % e)
|
||||
|
||||
def test_i386_jump():
|
||||
print("Emulate i386 code with jump")
|
||||
try:
|
||||
# Initialize emulator in X86-32bit mode
|
||||
mu = Uc(UC_ARCH_X86, UC_MODE_32)
|
||||
|
||||
# map 2MB memory for this emulation
|
||||
mu.mem_map(ADDRESS, 2 * 1024 * 1024)
|
||||
|
||||
# write machine code to be emulated to memory
|
||||
mu.mem_write(ADDRESS, X86_CODE32_JUMP)
|
||||
|
||||
# tracing all basic blocks with customized callback
|
||||
mu.hook_add(UC_HOOK_BLOCK, hook_block, begin=ADDRESS, end=ADDRESS)
|
||||
|
||||
# tracing all instructions with customized callback
|
||||
mu.hook_add(UC_HOOK_CODE, hook_code, begin=ADDRESS, end=ADDRESS)
|
||||
|
||||
try:
|
||||
# emulate machine code in infinite time
|
||||
mu.emu_start(ADDRESS, ADDRESS + len(X86_CODE32_JUMP))
|
||||
except UcError as e:
|
||||
print("ERROR: %s" % e)
|
||||
|
||||
print(">>> Emulation done. Below is the CPU context")
|
||||
|
||||
except UcError as e:
|
||||
print("ERROR: %s" % e)
|
||||
|
||||
|
||||
def test_i386_invalid_mem_write():
|
||||
print("Emulate i386 code that write to invalid memory")
|
||||
@ -229,10 +278,10 @@ def test_i386_invalid_mem_write():
|
||||
mu.reg_write(UC_X86_REG_EDX, 0x7890)
|
||||
|
||||
# tracing all basic blocks with customized callback
|
||||
#mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
||||
mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
||||
|
||||
# tracing all instructions with customized callback
|
||||
#mu.hook_add(UC_HOOK_CODE, hook_code)
|
||||
mu.hook_add(UC_HOOK_CODE, hook_code)
|
||||
|
||||
# intercept invalid memory events
|
||||
mu.hook_add(UC_HOOK_MEM_READ_UNMAPPED | UC_HOOK_MEM_WRITE_UNMAPPED, hook_mem_invalid)
|
||||
@ -251,25 +300,92 @@ def test_i386_invalid_mem_write():
|
||||
print(">>> ECX = 0x%x" %r_ecx)
|
||||
print(">>> EDX = 0x%x" %r_edx)
|
||||
|
||||
# read from memory
|
||||
print(">>> Read 4 bytes from [0x%x] = 0x" %(0xaaaaaaaa), end="")
|
||||
tmp = mu.mem_read(0xaaaaaaaa, 4)
|
||||
for i in reversed(tmp):
|
||||
if i != 0:
|
||||
print("%x" %i, end="")
|
||||
print("")
|
||||
|
||||
try:
|
||||
# read from memory
|
||||
print(">>> Read 4 bytes from [0x%x] = " %(0xaaaaaaaa), end="")
|
||||
tmp = mu.mem_read(0xaaaaaaaa, 4)
|
||||
for i in tmp:
|
||||
print(" 0x%x" %i, end="")
|
||||
tmp = mu.mem_read(0xffffffaa, 4)
|
||||
print(">>> Read 4 bytes from [0x%x] = 0x" %(0xffffffaa), end="")
|
||||
for i in reversed(tmp):
|
||||
print("%x" %i, end="")
|
||||
print("")
|
||||
|
||||
print(">>> Read 4 bytes from [0x%x] = " %(0xffffffaa), end="")
|
||||
tmp = mu.mem_read(0xffffffaa, 4)
|
||||
for i in tmp:
|
||||
print(" 0x%x" %i, end="")
|
||||
print("")
|
||||
except UcError as e:
|
||||
print("ERROR: %s" % e)
|
||||
print(">>> Failed to read 4 bytes from [0xffffffaa]")
|
||||
|
||||
except UcError as e:
|
||||
print("ERROR: %s" % e)
|
||||
|
||||
def test_i386_jump_invalid():
|
||||
print("Emulate i386 code that jumps to invalid memory")
|
||||
try:
|
||||
# Initialize emulator in X86-32bit mode
|
||||
mu = Uc(UC_ARCH_X86, UC_MODE_32)
|
||||
|
||||
# map 2MB memory for this emulation
|
||||
mu.mem_map(ADDRESS, 2 * 1024 * 1024)
|
||||
|
||||
# write machine code to be emulated to memory
|
||||
mu.mem_write(ADDRESS, X86_CODE32_JMP_INVALID)
|
||||
|
||||
# initialize machine registers
|
||||
mu.reg_write(UC_X86_REG_ECX, 0x1234)
|
||||
mu.reg_write(UC_X86_REG_EDX, 0x7890)
|
||||
|
||||
# tracing all basic blocks with customized callback
|
||||
mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
||||
|
||||
# tracing all instructions with customized callback
|
||||
mu.hook_add(UC_HOOK_CODE, hook_code)
|
||||
|
||||
try:
|
||||
mu.emu_start(ADDRESS, ADDRESS + len(X86_CODE32_JMP_INVALID))
|
||||
except UcError as e:
|
||||
print("Failed on uc_emu_start() with error returned 8: %s" %e)
|
||||
|
||||
print(">>> Emulation done. Below is the CPU context")
|
||||
|
||||
r_ecx = mu.reg_read(UC_X86_REG_ECX)
|
||||
r_edx = mu.reg_read(UC_X86_REG_EDX)
|
||||
print(">>> ECX = 0x%x" %r_ecx)
|
||||
print(">>> EDX = 0x%x" %r_edx)
|
||||
|
||||
except UcError as e:
|
||||
print("ERROR %s" % e)
|
||||
|
||||
def test_i386_loop():
|
||||
print("Emulate i386 code that loop forever")
|
||||
try:
|
||||
# Initialize emulator in X86-32bit mode
|
||||
mu = Uc(UC_ARCH_X86, UC_MODE_32)
|
||||
|
||||
# map 2MB memory for this emulation
|
||||
mu.mem_map(ADDRESS, 2 * 1024 * 1024)
|
||||
|
||||
# write machine code to be emulated to memory
|
||||
mu.mem_write(ADDRESS, X86_CODE32_LOOP)
|
||||
|
||||
# initialize machine registers
|
||||
mu.reg_write(UC_X86_REG_ECX, 0x1234)
|
||||
mu.reg_write(UC_X86_REG_EDX, 0x7890)
|
||||
|
||||
mu.emu_start(ADDRESS, ADDRESS + len(X86_CODE32_LOOP), timeout=2*UC_SECOND_SCALE)
|
||||
|
||||
print(">>> Emulation done. Below is the CPU context")
|
||||
|
||||
r_ecx = mu.reg_read(UC_X86_REG_ECX)
|
||||
r_edx = mu.reg_read(UC_X86_REG_EDX)
|
||||
print(">>> ECX = 0x%x" %r_ecx)
|
||||
print(">>> EDX = 0x%x" %r_edx)
|
||||
|
||||
|
||||
except UcError as e:
|
||||
print("ERROR: %s" % e)
|
||||
|
||||
# Test X86 32 bit with IN/OUT instruction
|
||||
def test_i386_inout():
|
||||
@ -397,7 +513,7 @@ def test_x86_64():
|
||||
mu.hook_add(UC_HOOK_BLOCK, hook_block)
|
||||
|
||||
# tracing all instructions in range [ADDRESS, ADDRESS+20]
|
||||
mu.hook_add(UC_HOOK_CODE, hook_code, None, ADDRESS, ADDRESS+20)
|
||||
mu.hook_add(UC_HOOK_CODE, hook_code64, None, ADDRESS, ADDRESS+20)
|
||||
|
||||
# tracing all memory READ & WRITE access
|
||||
mu.hook_add(UC_HOOK_MEM_WRITE, hook_mem_access)
|
||||
@ -429,23 +545,21 @@ def test_x86_64():
|
||||
r14 = mu.reg_read(UC_X86_REG_R14)
|
||||
r15 = mu.reg_read(UC_X86_REG_R15)
|
||||
|
||||
print(">>> RAX = %x" %rax)
|
||||
print(">>> RBX = %x" %rbx)
|
||||
print(">>> RCX = %x" %rcx)
|
||||
print(">>> RDX = %x" %rdx)
|
||||
print(">>> RSI = %x" %rsi)
|
||||
print(">>> RDI = %x" %rdi)
|
||||
print(">>> R8 = %x" %r8)
|
||||
print(">>> R9 = %x" %r9)
|
||||
print(">>> R10 = %x" %r10)
|
||||
print(">>> R11 = %x" %r11)
|
||||
print(">>> R12 = %x" %r12)
|
||||
print(">>> R13 = %x" %r13)
|
||||
print(">>> R14 = %x" %r14)
|
||||
print(">>> R15 = %x" %r15)
|
||||
print(">>> RAX = 0x%x" %rax)
|
||||
print(">>> RBX = 0x%x" %rbx)
|
||||
print(">>> RCX = 0x%x" %rcx)
|
||||
print(">>> RDX = 0x%x" %rdx)
|
||||
print(">>> RSI = 0x%x" %rsi)
|
||||
print(">>> RDI = 0x%x" %rdi)
|
||||
print(">>> R8 = 0x%x" %r8)
|
||||
print(">>> R9 = 0x%x" %r9)
|
||||
print(">>> R10 = 0x%x" %r10)
|
||||
print(">>> R11 = 0x%x" %r11)
|
||||
print(">>> R12 = 0x%x" %r12)
|
||||
print(">>> R13 = 0x%x" %r13)
|
||||
print(">>> R14 = 0x%x" %r14)
|
||||
print(">>> R15 = 0x%x" %r15)
|
||||
|
||||
#BUG
|
||||
mu.emu_start(ADDRESS, ADDRESS + len(X86_CODE64))
|
||||
|
||||
except UcError as e:
|
||||
print("ERROR: %s" % e)
|
||||
@ -516,27 +630,29 @@ def test_x86_16():
|
||||
print(">>> Emulation done. Below is the CPU context")
|
||||
|
||||
tmp = mu.mem_read(11, 1)
|
||||
print("[0x%x] = 0x%x" %(11, tmp[0]))
|
||||
print(">>> Read 1 bytes from [0x%x] = 0x%x" %(11, tmp[0]))
|
||||
|
||||
except UcError as e:
|
||||
print("ERROR: %s" % e)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
test_i386()
|
||||
print("=" * 20)
|
||||
test_i386_loop()
|
||||
print("=" * 20)
|
||||
test_i386_invalid_mem_read()
|
||||
print("=" * 20)
|
||||
test_i386_invalid_mem_write()
|
||||
print("=" * 20)
|
||||
test_i386_inout()
|
||||
print("=" * 20)
|
||||
test_i386_context_save()
|
||||
print("=" * 20)
|
||||
test_x86_64()
|
||||
print("=" * 20)
|
||||
test_x86_64_syscall()
|
||||
print("=" * 20)
|
||||
test_x86_16()
|
||||
test_i386()
|
||||
print("=" * 35)
|
||||
test_i386_map_ptr()
|
||||
print("=" * 35)
|
||||
test_i386_inout()
|
||||
print("=" * 35)
|
||||
test_i386_jump()
|
||||
print("=" * 35)
|
||||
test_i386_loop()
|
||||
print("=" * 35)
|
||||
test_i386_invalid_mem_read()
|
||||
print("=" * 35)
|
||||
test_i386_invalid_mem_write()
|
||||
print("=" * 35)
|
||||
test_i386_jump_invalid()
|
||||
test_x86_64()
|
||||
print("=" * 35)
|
||||
test_x86_64_syscall()
|
||||
|
||||
@ -23,7 +23,7 @@ if os.path.exists(PATH_LIB64) and os.path.exists(PATH_LIB32):
|
||||
PKG_NAME = 'unicorn-windows'
|
||||
|
||||
SYSTEM = sys.platform
|
||||
VERSION = '1.0'
|
||||
VERSION = '1.0.0'
|
||||
|
||||
# adapted from commit e504b81 of Nguyen Tan Cong
|
||||
# Reference: https://docs.python.org/2/library/platform.html#cross-platform
|
||||
|
||||
@ -63,7 +63,8 @@ _path_list = [pkg_resources.resource_filename(__name__, 'lib'),
|
||||
os.path.join(os.path.split(__file__)[0], 'lib'),
|
||||
'',
|
||||
distutils.sysconfig.get_python_lib(),
|
||||
"/usr/local/lib/" if sys.platform == 'darwin' else '/usr/lib64']
|
||||
"/usr/local/lib/" if sys.platform == 'darwin' else '/usr/lib64',
|
||||
os.environ['PATH']]
|
||||
|
||||
for _path in _path_list:
|
||||
_uc = _load_lib(_path)
|
||||
@ -105,7 +106,6 @@ _setup_prototype(_uc, "uc_context_alloc", ucerr, uc_engine, ctypes.POINTER(uc_co
|
||||
_setup_prototype(_uc, "uc_context_free", ucerr, uc_context)
|
||||
_setup_prototype(_uc, "uc_context_save", ucerr, uc_engine, uc_context)
|
||||
_setup_prototype(_uc, "uc_context_restore", ucerr, uc_engine, uc_context)
|
||||
_setup_prototype(_uc, "free", None, ctypes.c_voidp)
|
||||
|
||||
# uc_hook_add is special due to variable number of arguments
|
||||
_uc.uc_hook_add = _uc.uc_hook_add
|
||||
|
||||
@ -73,11 +73,11 @@ VALUE m_uc_emu_start(int argc, VALUE* argv, VALUE self){
|
||||
Data_Get_Struct(rb_iv_get(self,"@uch"), uc_engine, _uc);
|
||||
|
||||
rb_scan_args(argc, argv, "22",&begin, &until, &timeout, &count);
|
||||
if (NIL_P(timeout))
|
||||
timeout = INT2NUM(0);
|
||||
if (NIL_P(timeout))
|
||||
timeout = INT2NUM(0);
|
||||
|
||||
if (NIL_P(count))
|
||||
count = INT2NUM(0);
|
||||
if (NIL_P(count))
|
||||
count = INT2NUM(0);
|
||||
|
||||
err = uc_emu_start(_uc, NUM2ULL(begin), NUM2ULL(until), NUM2INT(timeout), NUM2INT(count));
|
||||
if (err != UC_ERR_OK) {
|
||||
@ -133,7 +133,7 @@ VALUE m_uc_reg_read(VALUE self, VALUE reg_id){
|
||||
if (err != UC_ERR_OK) {
|
||||
rb_raise(UcError, "%s", uc_strerror(err));
|
||||
}
|
||||
return LL2NUM(reg_value);
|
||||
return ULL2NUM(reg_value);
|
||||
}
|
||||
|
||||
}
|
||||
@ -165,7 +165,7 @@ VALUE m_uc_reg_write(VALUE self, VALUE reg_id, VALUE reg_value){
|
||||
err = uc_reg_write(_uc, NUM2INT(reg_id), &tmp);
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
if (err != UC_ERR_OK) {
|
||||
rb_raise(UcError, "%s", uc_strerror(err));
|
||||
}
|
||||
@ -205,8 +205,8 @@ VALUE m_uc_mem_map(int argc, VALUE* argv, VALUE self){
|
||||
uc_engine *_uc;
|
||||
Data_Get_Struct(rb_iv_get(self,"@uch"), uc_engine, _uc);
|
||||
rb_scan_args(argc, argv, "21",&address, &size, &perms);
|
||||
if (NIL_P(perms))
|
||||
perms = INT2NUM(UC_PROT_ALL);
|
||||
if (NIL_P(perms))
|
||||
perms = INT2NUM(UC_PROT_ALL);
|
||||
|
||||
err = uc_mem_map(_uc, NUM2ULL(address), NUM2UINT(size), NUM2UINT(perms));
|
||||
if (err != UC_ERR_OK) {
|
||||
@ -332,14 +332,14 @@ VALUE m_uc_hook_add(int argc, VALUE* argv, VALUE self){
|
||||
uc_engine *_uc;
|
||||
Data_Get_Struct(rb_iv_get(self,"@uch"), uc_engine, _uc);
|
||||
rb_scan_args(argc, argv, "24",&hook_type, &callback, &user_data, &begin, &end, &arg1);
|
||||
if (NIL_P(begin))
|
||||
begin = ULL2NUM(1);
|
||||
if (NIL_P(begin))
|
||||
begin = ULL2NUM(1);
|
||||
|
||||
if (NIL_P(end))
|
||||
end = ULL2NUM(0);
|
||||
if (NIL_P(end))
|
||||
end = ULL2NUM(0);
|
||||
|
||||
if (NIL_P(arg1))
|
||||
arg1 = INT2NUM(0);
|
||||
if (NIL_P(arg1))
|
||||
arg1 = INT2NUM(0);
|
||||
|
||||
VALUE passthrough;
|
||||
uc_hook trace;
|
||||
@ -374,12 +374,12 @@ VALUE m_uc_hook_add(int argc, VALUE* argv, VALUE self){
|
||||
else if(htype == UC_HOOK_CODE || htype == UC_HOOK_BLOCK){
|
||||
err = uc_hook_add(_uc, &trace, htype, cb_hook_code,(void *)passthrough, NUM2ULL(begin), NUM2ULL(end));
|
||||
}
|
||||
else if (htype & UC_HOOK_MEM_READ_UNMAPPED
|
||||
|| htype & UC_HOOK_MEM_WRITE_UNMAPPED
|
||||
|| htype & UC_HOOK_MEM_FETCH_UNMAPPED
|
||||
|| htype & UC_HOOK_MEM_READ_PROT
|
||||
|| htype & UC_HOOK_MEM_WRITE_PROT
|
||||
|| htype & UC_HOOK_MEM_FETCH_PROT
|
||||
else if (htype & UC_HOOK_MEM_READ_UNMAPPED
|
||||
|| htype & UC_HOOK_MEM_WRITE_UNMAPPED
|
||||
|| htype & UC_HOOK_MEM_FETCH_UNMAPPED
|
||||
|| htype & UC_HOOK_MEM_READ_PROT
|
||||
|| htype & UC_HOOK_MEM_WRITE_PROT
|
||||
|| htype & UC_HOOK_MEM_FETCH_PROT
|
||||
|| htype & UC_HOOK_MEM_READ_INVALID
|
||||
|| htype & UC_HOOK_MEM_WRITE_INVALID
|
||||
|| htype & UC_HOOK_MEM_FETCH_INVALID
|
||||
@ -387,7 +387,7 @@ VALUE m_uc_hook_add(int argc, VALUE* argv, VALUE self){
|
||||
|| htype & UC_HOOK_MEM_PROT
|
||||
|| htype & UC_HOOK_MEM_INVALID) {
|
||||
err = uc_hook_add(_uc, &trace, htype, cb_hook_mem_invalid,(void *)passthrough, NUM2ULL(begin), NUM2ULL(end));
|
||||
}
|
||||
}
|
||||
else{
|
||||
err = uc_hook_add(_uc, &trace, htype, cb_hook_mem_access,(void *)passthrough, NUM2ULL(begin), NUM2ULL(end));
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user