lazymio/unicorn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Unicorn rust bindings improvements

Browse Source
This commit is contained in:
Dominik Maier
2021-11-08 19:34:53 +01:00
parent 06f454d513
commit f8f0d4471f
16 changed files with 417 additions and 388 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
bindings/rust/tests/unicorn.rs
View File

@@ -32,6 +32,7 @@ pub static X86_REGISTERS: [RegisterX86; 125] = [
RegisterX86::EDX,
RegisterX86::EFLAGS,
RegisterX86::EIP,
RegisterX86::EIZ,
RegisterX86::ES,
RegisterX86::ESI,
RegisterX86::ESP,
@@ -46,6 +47,7 @@ pub static X86_REGISTERS: [RegisterX86; 125] = [
RegisterX86::RDI,
RegisterX86::RDX,
RegisterX86::RIP,
RegisterX86::RIZ,
RegisterX86::RSI,
RegisterX86::RSP,
RegisterX86::SI,
@@ -58,7 +60,17 @@ pub static X86_REGISTERS: [RegisterX86; 125] = [
RegisterX86::CR2,
RegisterX86::CR3,
RegisterX86::CR4,
RegisterX86::CR5,
RegisterX86::CR6,
RegisterX86::CR7,
RegisterX86::CR8,
RegisterX86::CR9,
RegisterX86::CR10,
RegisterX86::CR11,
RegisterX86::CR12,
RegisterX86::CR13,
RegisterX86::CR14,
RegisterX86::CR15,
RegisterX86::DR0,
RegisterX86::DR1,
RegisterX86::DR2,
@@ -67,6 +79,14 @@ pub static X86_REGISTERS: [RegisterX86; 125] = [
RegisterX86::DR5,
RegisterX86::DR6,
RegisterX86::DR7,
RegisterX86::DR8,
RegisterX86::DR9,
RegisterX86::DR10,
RegisterX86::DR11,
RegisterX86::DR12,
RegisterX86::DR13,
RegisterX86::DR14,
RegisterX86::DR15,
RegisterX86::FP0,
RegisterX86::FP1,
RegisterX86::FP2,
@@ -133,15 +153,12 @@ pub static X86_REGISTERS: [RegisterX86; 125] = [
RegisterX86::R15W,
];
type Unicorn<'a> = unicorn_engine::UnicornHandle<'a>;
#[test]
fn emulate_x86() {
let x86_code32: Vec<u8> = vec![0x41, 0x4a]; // INC ecx; DEC edx
let mut unicorn = unicorn_engine::Unicorn::new(Arch::X86, Mode::MODE_32)
let mut emu = unicorn_emulator::Unicorn::new(Arch::X86, Mode::MODE_32, 0)
.expect("failed to initialize unicorn instance");
let mut emu = unicorn.borrow();
assert_eq!(emu.reg_write(RegisterX86::EAX as i32, 123), Ok(()));
assert_eq!(emu.reg_read(RegisterX86::EAX as i32), Ok(123));
@@ -183,16 +200,15 @@ fn x86_code_callback() {
let codes_cell = Rc::new(RefCell::new(codes));
let callback_codes = codes_cell.clone();
let callback = move |_: Unicorn<'_>, address: u64, size: u32| {
let callback = move |_: &mut Unicorn<'_, ()>, address: u64, size: u32| {
let mut codes = callback_codes.borrow_mut();
codes.push(CodeExpectation(address, size));
};
let x86_code32: Vec<u8> = vec![0x41, 0x4a]; // INC ecx; DEC edx
let mut unicorn = unicorn_engine::Unicorn::new(Arch::X86, Mode::MODE_32)
let mut emu = unicorn_emulator::Unicorn::new(Arch::X86, Mode::MODE_32, ())
.expect("failed to initialize unicorn instance");
let mut emu = unicorn.borrow();
assert_eq!(emu.mem_map(0x1000, 0x4000, Permission::ALL), Ok(()));
assert_eq!(emu.mem_write(0x1000, &x86_code32), Ok(()));
@@ -215,15 +231,14 @@ fn x86_intr_callback() {
let intr_cell = Rc::new(RefCell::new(IntrExpectation(0)));
let callback_intr = intr_cell.clone();
let callback = move |_: Unicorn<'_>, intno: u32| {
let callback = move |_: &mut Unicorn<'_, ()>, intno: u32| {
*callback_intr.borrow_mut() = IntrExpectation(intno);
};
let x86_code32: Vec<u8> = vec![0xcd, 0x80]; // INT 0x80;
let mut unicorn = unicorn_engine::Unicorn::new(Arch::X86, Mode::MODE_32)
let mut emu = unicorn_emulator::Unicorn::new(Arch::X86, Mode::MODE_32, ())
.expect("failed to initialize unicorn instance");
let mut emu = unicorn.borrow();
assert_eq!(emu.mem_map(0x1000, 0x4000, Permission::ALL), Ok(()));
assert_eq!(emu.mem_write(0x1000, &x86_code32), Ok(()));
@@ -251,22 +266,16 @@ fn x86_mem_callback() {
let expects = vec![
MemExpectation(MemType::WRITE, 0x2000, 4, 0xdeadbeef),
MemExpectation(MemType::READ_UNMAPPED, 0x10000, 4, 0),
MemExpectation(MemType::READ, 0x10000, 4, 0),
];
let mems: Vec<MemExpectation> = Vec::new();
let mems_cell = Rc::new(RefCell::new(mems));
let callback_mems = mems_cell.clone();
let callback =
move |uc: Unicorn<'_>, mem_type: MemType, address: u64, size: usize, value: i64| {
move |_: &mut Unicorn<'_, ()>, mem_type: MemType, address: u64, size: usize, value: i64| {
let mut mems = callback_mems.borrow_mut();
let mut uc = uc;
mems.push(MemExpectation(mem_type, address, size, value));
if mem_type == MemType::READ_UNMAPPED {
uc.mem_map(address, 0x1000, Permission::ALL).unwrap();
}
true
};
// mov eax, 0xdeadbeef;
@@ -276,9 +285,8 @@ fn x86_mem_callback() {
0xB8, 0xEF, 0xBE, 0xAD, 0xDE, 0xA3, 0x00, 0x20, 0x00, 0x00, 0xA1, 0x00, 0x00, 0x01, 0x00,
];
let mut unicorn = unicorn_engine::Unicorn::new(Arch::X86, Mode::MODE_32)
let mut emu = unicorn_emulator::Unicorn::new(Arch::X86, Mode::MODE_32, ())
.expect("failed to initialize unicorn instance");
let mut emu = unicorn.borrow();
assert_eq!(emu.mem_map(0x1000, 0x4000, Permission::ALL), Ok(()));
assert_eq!(emu.mem_write(0x1000, &x86_code32), Ok(()));
@@ -293,7 +301,7 @@ fn x86_mem_callback() {
10 * SECOND_SCALE,
0x1000
),
Ok(())
Err(uc_error::READ_UNMAPPED)
);
assert_eq!(expects, *mems_cell.borrow());
@@ -308,15 +316,14 @@ fn x86_insn_in_callback() {
let insn_cell = Rc::new(RefCell::new(InsnInExpectation(0, 0)));
let callback_insn = insn_cell.clone();
let callback = move |_: Unicorn<'_>, port: u32, size: usize| {
let callback = move |_: &mut Unicorn<'_, ()>, port: u32, size: usize| {
*callback_insn.borrow_mut() = InsnInExpectation(port, size);
};
let x86_code32: Vec<u8> = vec![0xe5, 0x10]; // IN eax, 0x10;
let mut unicorn = unicorn_engine::Unicorn::new(Arch::X86, Mode::MODE_32)
let mut emu = unicorn_emulator::Unicorn::new(Arch::X86, Mode::MODE_32, ())
.expect("failed to initialize unicorn instance");
let mut emu = unicorn.borrow();
assert_eq!(emu.mem_map(0x1000, 0x4000, Permission::ALL), Ok(()));
assert_eq!(emu.mem_write(0x1000, &x86_code32), Ok(()));
@@ -345,15 +352,14 @@ fn x86_insn_out_callback() {
let insn_cell = Rc::new(RefCell::new(InsnOutExpectation(0, 0, 0)));
let callback_insn = insn_cell.clone();
let callback = move |_: Unicorn<'_>, port: u32, size: usize, value: u32| {
let callback = move |_: &mut Unicorn<'_, ()>, port: u32, size: usize, value: u32| {
*callback_insn.borrow_mut() = InsnOutExpectation(port, size, value);
};
let x86_code32: Vec<u8> = vec![0xb0, 0x32, 0xe6, 0x46]; // MOV al, 0x32; OUT 0x46, al;
let mut unicorn = unicorn_engine::Unicorn::new(Arch::X86, Mode::MODE_32)
let mut emu = unicorn_emulator::Unicorn::new(Arch::X86, Mode::MODE_32, ())
.expect("failed to initialize unicorn instance");
let mut emu = unicorn.borrow();
assert_eq!(emu.mem_map(0x1000, 0x4000, Permission::ALL), Ok(()));
assert_eq!(emu.mem_write(0x1000, &x86_code32), Ok(()));
@@ -382,7 +388,7 @@ fn x86_insn_sys_callback() {
let insn_cell = Rc::new(RefCell::new(InsnSysExpectation(0)));
let callback_insn = insn_cell.clone();
let callback = move |uc: Unicorn<'_>| {
let callback = move |uc: &mut Unicorn<'_, ()>| {
println!("!!!!");
let rax = uc.reg_read(RegisterX86::RAX as i32).unwrap();
*callback_insn.borrow_mut() = InsnSysExpectation(rax);
@@ -393,9 +399,8 @@ fn x86_insn_sys_callback() {
0x48, 0xB8, 0xEF, 0xBE, 0xAD, 0xDE, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x05,
];
let mut unicorn = unicorn_engine::Unicorn::new(Arch::X86, Mode::MODE_64)
let mut emu = unicorn_emulator::Unicorn::new(Arch::X86, Mode::MODE_64, ())
.expect("failed to initialize unicorn instance");
let mut emu = unicorn.borrow();
assert_eq!(emu.mem_map(0x1000, 0x4000, Permission::ALL), Ok(()));
assert_eq!(emu.mem_write(0x1000, &x86_code), Ok(()));
@@ -420,9 +425,8 @@ fn x86_insn_sys_callback() {
fn emulate_arm() {
let arm_code32: Vec<u8> = vec![0x83, 0xb0]; // sub sp, #0xc
let mut unicorn = unicorn_engine::Unicorn::new(Arch::ARM, Mode::THUMB)
let mut emu = unicorn_emulator::Unicorn::new(Arch::ARM, Mode::THUMB, ())
.expect("failed to initialize unicorn instance");
let mut emu = unicorn.borrow();
assert_eq!(emu.reg_write(RegisterARM::R1 as i32, 123), Ok(()));
assert_eq!(emu.reg_read(RegisterARM::R1 as i32), Ok(123));
@@ -461,9 +465,8 @@ fn emulate_arm() {
fn emulate_mips() {
let mips_code32 = vec![0x56, 0x34, 0x21, 0x34]; // ori $at, $at, 0x3456;
let mut unicorn = unicorn_engine::Unicorn::new(Arch::MIPS, Mode::MODE_32)
let mut emu = unicorn_emulator::Unicorn::new(Arch::MIPS, Mode::MODE_32, ())
.expect("failed to initialize unicorn instance");
let mut emu = unicorn.borrow();
assert_eq!(emu.mem_map(0x1000, 0x4000, Permission::ALL), Ok(()));
assert_eq!(emu.mem_write(0x1000, &mips_code32), Ok(()));
assert_eq!(
@@ -487,9 +490,8 @@ fn emulate_mips() {
fn emulate_ppc() {
let ppc_code32 = vec![0x7F, 0x46, 0x1A, 0x14]; // add 26, 6, 3
let mut unicorn = unicorn_engine::Unicorn::new(Arch::PPC, Mode::PPC32 | Mode::BIG_ENDIAN)
let mut emu = unicorn_emulator::Unicorn::new(Arch::PPC, Mode::PPC32, ())
.expect("failed to initialize unicorn instance");
let mut emu = unicorn.borrow();
assert_eq!(emu.mem_map(0x1000, 0x4000, Permission::ALL), Ok(()));
assert_eq!(emu.mem_write(0x1000, &ppc_code32), Ok(()));
assert_eq!(
@@ -512,9 +514,8 @@ fn emulate_ppc() {
#[test]
fn mem_unmapping() {
let mut unicorn = unicorn_engine::Unicorn::new(Arch::X86, Mode::MODE_32)
let mut emu = unicorn_emulator::Unicorn::new(Arch::X86, Mode::MODE_32, ())
.expect("failed to initialize unicorn instance");
let mut emu = unicorn.borrow();
assert_eq!(emu.mem_map(0x1000, 0x4000, Permission::ALL), Ok(()));
assert_eq!(emu.mem_unmap(0x1000, 0x4000), Ok(()));
}
@@ -525,9 +526,8 @@ fn mem_map_ptr() {
let mut mem: [u8; 4000] = [0; 4000];
let x86_code32: Vec<u8> = vec![0x41, 0x4a]; // INC ecx; DEC edx
let mut unicorn = unicorn_engine::Unicorn::new(Arch::X86, Mode::MODE_32)
let mut emu = unicorn_emulator::Unicorn::new(Arch::X86, Mode::MODE_32, ())
.expect("failed to initialize unicorn instance");
let mut emu = unicorn.borrow();
// Attempt to write to memory before mapping it.
assert_eq!(
@@ -536,7 +536,7 @@ fn mem_map_ptr() {
);
assert_eq!(
emu.mem_map_ptr(0x1000, 0x4000, Permission::ALL, mem.as_mut_ptr() as _),
unsafe { emu.mem_map_ptr(0x1000, 0x4000, Permission::ALL, mem.as_mut_ptr() as _) },
Ok(())
);
assert_eq!(emu.mem_write(0x1000, &x86_code32), Ok(()));
@@ -572,7 +572,7 @@ fn mem_map_ptr() {
);
assert_eq!(
emu.mem_map_ptr(0x1000, 0x4000, Permission::ALL, mem.as_mut_ptr() as _),
unsafe { emu.mem_map_ptr(0x1000, 0x4000, Permission::ALL, mem.as_mut_ptr() as _) },
Ok(())
);
assert_eq!(emu.mem_write(0x1000, &x86_code32), Ok(()));
@@ -600,13 +600,12 @@ fn mem_map_ptr() {
#[test]
fn x86_context_save_and_restore() {
for mode in vec![Mode::MODE_32, Mode::MODE_64] {
for mode in &[Mode::MODE_32, Mode::MODE_64] {
let x86_code: Vec<u8> = vec![
0x48, 0xB8, 0xEF, 0xBE, 0xAD, 0xDE, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x05,
];
let mut unicorn = unicorn_engine::Unicorn::new(Arch::X86, mode)
let mut emu = unicorn_emulator::Unicorn::new(Arch::X86, *mode, ())
.expect("failed to initialize unicorn instance");
let mut emu = unicorn.borrow();
assert_eq!(emu.mem_map(0x1000, 0x4000, Permission::ALL), Ok(()));
assert_eq!(emu.mem_write(0x1000, &x86_code), Ok(()));
let _ = emu.emu_start(
@@ -621,9 +620,8 @@ fn x86_context_save_and_restore() {
let context = context.unwrap();
/* and create a new emulator, into which we will "restore" that context */
let mut unicorn2 = unicorn_engine::Unicorn::new(Arch::X86, mode)
let emu2 = unicorn_emulator::Unicorn::new(Arch::X86, *mode, ())
.expect("failed to initialize unicorn instance");
let emu2 = unicorn2.borrow();
assert_eq!(emu2.context_restore(&context), Ok(()));
for register in X86_REGISTERS.iter() {
println!("Testing register {:?}", register);
@@ -644,16 +642,15 @@ fn x86_block_callback() {
let blocks_cell = Rc::new(RefCell::new(blocks));
let callback_blocks = blocks_cell.clone();
let callback = move |_: Unicorn<'_>, address: u64, size: u32| {
let callback = move |_: &mut Unicorn<'_, ()>, address: u64, size: u32| {
let mut blocks = callback_blocks.borrow_mut();
blocks.push(BlockExpectation(address, size));
};
let x86_code32: Vec<u8> = vec![0x41, 0x4a]; // INC ecx; DEC edx
let mut unicorn = unicorn_engine::Unicorn::new(Arch::X86, Mode::MODE_32)
let mut emu = unicorn_emulator::Unicorn::new(Arch::X86, Mode::MODE_32, ())
.expect("failed to initialize unicorn instance");
let mut emu = unicorn.borrow();
assert_eq!(emu.mem_map(0x1000, 0x4000, Permission::ALL), Ok(()));
assert_eq!(emu.mem_write(0x1000, &x86_code32), Ok(()));