/** * A basic test showing mapping of memory, and reading/writing it */ static void test_basic(void **state) { uc_engine *uc = *state; const uint64_t mem_start = 0x1000; const uint64_t mem_len = 0x1000; const uint64_t test_addr = mem_start + 0x100; /* Map a region */ uc_assert_success(uc_mem_map(uc, mem_start, mem_len, UC_PROT_NONE)); /* Write some data to it */ uc_assert_success(uc_mem_write(uc, test_addr, "test", 4)); uint8_t buf[4]; memset(buf, 0xCC, sizeof(buf)); /* Read it back */ uc_assert_success(uc_mem_read(uc, test_addr, buf, sizeof(buf))); /* And make sure it matches what we expect */ assert_memory_equal(buf, "test", 4); /* Unmap the region */ //uc_assert_success(uc_mem_unmap(uc, mem_start, mem_len)); }
// emulate code that jumps to invalid memory static void test_i386_jump_invalid(void **state) { uc_engine *uc; uc_err err; static const uint64_t address = 0x1000000; static const uint8_t code[] = { 0xE9, 0xE9, 0xEE, 0xEE, 0xEE, // jmp 0xEEEEEEEE }; // Initialize emulator in X86-32bit mode err = uc_open(UC_ARCH_X86, UC_MODE_32, &uc); uc_assert_success(err); // map 2MB memory for this emulation err = uc_mem_map(uc, address, 2 * 1024 * 1024, UC_PROT_ALL); uc_assert_success(err); // write machine code to be emulated to memory err = uc_mem_write(uc, address, code, sizeof(code)); uc_assert_success(err); // emulate machine code in infinite time err = uc_emu_start(uc, address, address+sizeof(code), 0, 0); uc_assert_err(UC_ERR_FETCH_UNMAPPED, err); uc_assert_success(uc_close(uc)); }
// callback for SYSCALL instruction (X86). static void hook_syscall(uc_engine *uc, void *user_data) { uint64_t rax; uc_assert_success(uc_reg_read(uc, UC_X86_REG_RAX, &rax)); assert_int_equal(0x100, rax); rax = 0x200; uc_assert_success(uc_reg_write(uc, UC_X86_REG_RAX, &rax)); }
// mapping the last pages will silently fail static void test_last_page_map(void **state) { uc_engine *uc = *state; uint8_t writebuf[0x10]; memset(writebuf, 0xCC, sizeof(writebuf)); const uint64_t mem_len = 0x1000; const uint64_t last_page = 0xfffffffffffff000; uc_assert_success(uc_mem_map(uc, last_page, mem_len, UC_PROT_NONE)); uc_assert_success(uc_mem_write(uc, last_page, writebuf, sizeof(writebuf))); }
/* Try to map overlapped memory range */ static void test_unmap_double_map(void **state) { uc_engine *uc = *state; uc_assert_success(uc_mem_map(uc, 0, 0x4000, 0)); /* 0x0000 - 0x4000 */ uc_assert_fail(uc_mem_map(uc, 0x0000, 0x1000, 0)); /* 0x1000 - 0x1000 */ }
static void test_query_page_size(void **state) { uc_engine *uc = *state; size_t page_size; uc_assert_success(uc_query(uc, UC_QUERY_PAGE_SIZE, &page_size)); assert_int_equal(4096, page_size); }
/* Called after every test to clean up */ static int teardown(void **state) { uc_engine *uc = *state; uc_assert_success(uc_close(uc)); *state = NULL; return 0; }
/* Called before every test to set up a new instance */ static int setup(void **state) { uc_engine *uc; uc_assert_success(uc_open(UC_ARCH_X86, UC_MODE_64, &uc)); *state = uc; return 0; }
// emulate code that loop forever static void test_i386_loop(void **state) { uc_engine *uc; uc_err err; int r_ecx = 0x1234; // ECX register int r_edx = 0x7890; // EDX register static const uint64_t address = 0x1000000; static const uint8_t code[] = { 0x41, // inc ecx 0x4a, // dec edx 0xEB, 0xFE, // jmp $ }; // Initialize emulator in X86-32bit mode err = uc_open(UC_ARCH_X86, UC_MODE_32, &uc); uc_assert_success(err); // map 2MB memory for this emulation err = uc_mem_map(uc, address, 2 * 1024 * 1024, UC_PROT_ALL); uc_assert_success(err); // write machine code to be emulated to memory err = uc_mem_write(uc, address, code, sizeof(code)); uc_assert_success(err); // initialize machine registers err = uc_reg_write(uc, UC_X86_REG_ECX, &r_ecx); uc_assert_success(err); err = uc_reg_write(uc, UC_X86_REG_EDX, &r_edx); uc_assert_success(err); // emulate machine code in 2 seconds, so we can quit even // if the code loops err = uc_emu_start(uc, address, address+sizeof(code), 2*UC_SECOND_SCALE, 0); uc_assert_success(err); // verify register values uc_assert_success(uc_reg_read(uc, UC_X86_REG_ECX, &r_ecx)); uc_assert_success(uc_reg_read(uc, UC_X86_REG_EDX, &r_edx)); assert_int_equal(r_ecx, 0x1235); assert_int_equal(r_edx, 0x788F); uc_assert_success(uc_close(uc)); }
/** * Verify that we can read/write across memory map region boundaries */ static void test_rw_across_boundaries(void **state) { uc_engine *uc = *state; /* Map in two adjacent regions */ uc_assert_success(uc_mem_map(uc, 0, 0x1000, 0)); /* 0x0000 - 0x1000 */ uc_assert_success(uc_mem_map(uc, 0x1000, 0x1000, 0)); /* 0x1000 - 0x2000 */ const uint64_t addr = 0x1000 - 2; /* 2 bytes before end of block */ /* Write some data across the boundary */ uc_assert_success(uc_mem_write(uc, addr, "test", 4)); uint8_t buf[4]; memset(buf, 0xCC, sizeof(buf)); /* Read the data across the boundary */ uc_assert_success(uc_mem_read(uc, addr, buf, sizeof(buf))); assert_memory_equal(buf, "test", 4); }
//if a read is performed from a big address whith a non-zero last digit, multiple read events are triggered static void test_high_address_reads(void **state) { uc_engine *uc = *state; uc_hook trace2; uint64_t addr = 0x0010000000000001; //addr = 0x0010000000000000; // uncomment to fix wrong? behaviour //addr = 90000000; // uncomment to fix wrong? behaviour // uc_mem_map(uc, addr-(addr%4096), 4096*2, UC_PROT_ALL); uc_assert_success(uc_reg_write(uc, UC_X86_REG_RAX, &addr)); const uint64_t base_addr = 0x40000; uint8_t code[] = {0x48,0x8b,0x00,0x90,0x90,0x90,0x90}; // mov rax, [rax], nops uc_assert_success(uc_mem_map(uc, base_addr, 4096, UC_PROT_ALL)); uc_assert_success(uc_mem_write(uc, base_addr, code, 7)); uc_assert_success(uc_hook_add(uc, &trace2, UC_HOOK_MEM_READ, hook_mem64, NULL, (uint64_t)1, (uint64_t)0)); uc_assert_success(uc_emu_start(uc, base_addr, base_addr + 3, 0, 0)); if(number_of_memory_reads != 1) { fail_msg("wrong number of memory reads for instruction %i", number_of_memory_reads); } }
static void test_x86_16(void **state) { uc_engine *uc; uc_err err; uint8_t tmp; static const uint64_t address = 0; static const uint8_t code[] = { 0x00, 0x00, // add byte ptr [bx + si], al }; int32_t eax = 7; int32_t ebx = 5; int32_t esi = 6; // Initialize emulator in X86-16bit mode err = uc_open(UC_ARCH_X86, UC_MODE_16, &uc); uc_assert_success(err); // map 8KB memory for this emulation err = uc_mem_map(uc, address, 8 * 1024, UC_PROT_ALL); uc_assert_success(err); // write machine code to be emulated to memory err = uc_mem_write(uc, address, code, sizeof(code)); uc_assert_success(err); // initialize machine registers uc_assert_success(uc_reg_write(uc, UC_X86_REG_EAX, &eax)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_EBX, &ebx)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_ESI, &esi)); // emulate machine code in infinite time (last param = 0), or when // finishing all the code. err = uc_emu_start(uc, address, address+sizeof(code), 0, 0); uc_assert_success(err); // read from memory uc_assert_success(uc_mem_read(uc, 11, &tmp, 1)); assert_int_equal(7, tmp); uc_assert_success(uc_close(uc)); }
static void test_x86_64_syscall(void **state) { uc_engine *uc; uc_hook trace1; uc_err err; static const uint64_t address = 0x1000000; static const uint8_t code[] = { 0x0F, 0x05, // SYSCALL }; int64_t rax = 0x100; // Initialize emulator in X86-64bit mode err = uc_open(UC_ARCH_X86, UC_MODE_64, &uc); uc_assert_success(err); // map 2MB memory for this emulation err = uc_mem_map(uc, address, 2 * 1024 * 1024, UC_PROT_ALL); uc_assert_success(err); // write machine code to be emulated to memory err = uc_mem_write(uc, address, code, sizeof(code)); uc_assert_success(err); // hook interrupts for syscall err = uc_hook_add(uc, &trace1, UC_HOOK_INSN, hook_syscall, NULL, 1, 0, UC_X86_INS_SYSCALL); uc_assert_success(err); // initialize machine registers err = uc_reg_write(uc, UC_X86_REG_RAX, &rax); uc_assert_success(err); // emulate machine code in infinite time (last param = 0), or when // finishing all the code. err = uc_emu_start(uc, address, address + sizeof(code), 0, 0); uc_assert_success(err); // verify register values uc_assert_success(uc_reg_read(uc, UC_X86_REG_RAX, &rax)); assert_int_equal(0x200, rax); uc_assert_success(uc_close(uc)); }
//if a read is performed from a big address whith a non-zero last digit, 0 will be read static void test_high_address_read_values(void **state) { uc_engine *uc = *state; uint64_t addr = 0x0010000000000001; //addr = 0x000ffffffffffff8; // uncomment to fix wrong behaviour //addr = 90000000; // uncomment to fix wrong behaviour // uint8_t content[] = {0x42,0x42,0x42,0x42, 0x42,0x42,0x42,0x42}; uc_assert_success(uc_mem_map(uc, addr-(addr%4096), 4096*2, UC_PROT_ALL)); uc_assert_success(uc_mem_write(uc, addr, content, 8)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_RAX, &addr)); const uint64_t base_addr = 0x40000; uint8_t code[] = {0x48,0x8b,0x00,0x90,0x90,0x90,0x90}; // mov rax, [rax], nops uc_assert_success(uc_mem_map(uc, base_addr, 4096, UC_PROT_ALL)); uc_assert_success(uc_mem_write(uc, base_addr, code, 7)); uc_assert_success(uc_emu_start(uc, base_addr, base_addr + 3, 0, 0)); uint64_t rax = 0; uc_assert_success(uc_reg_read(uc, UC_X86_REG_RAX, &rax)); if(rax != 0x4242424242424242) { fail_msg("wrong memory read from code %"PRIx64, rax); } }
static void test_i386_jump(void **state) { uc_engine *uc; uc_err err; uc_hook trace1, trace2; const uint8_t code[] = "\xeb\x02\x90\x90\x90\x90\x90\x90"; // jmp 4; nop; nop; nop; nop; nop; nop const uint64_t address = 0x1000000; // Initialize emulator in X86-32bit mode err = uc_open(UC_ARCH_X86, UC_MODE_32, &uc); uc_assert_success(err); // map 2MB memory for this emulation err = uc_mem_map(uc, address, 2 * 1024 * 1024, UC_PROT_ALL); uc_assert_success(err); // write machine code to be emulated to memory err = uc_mem_write(uc, address, code, sizeof(code)-1); uc_assert_success(err); // tracing 1 basic block with customized callback err = uc_hook_add(uc, &trace1, UC_HOOK_BLOCK, hook_block, NULL, address, address); uc_assert_success(err); // tracing 1 instruction at address err = uc_hook_add(uc, &trace2, UC_HOOK_CODE, hook_code, NULL, address, address); uc_assert_success(err); // emulate machine code in infinite time err = uc_emu_start(uc, address, address+sizeof(code)-1, 0, 0); uc_assert_success(err); err = uc_close(uc); uc_assert_success(err); }
static void test_tb_x86_64_32_imul_Gv_Ev_Ib(void **state) { uc_engine *uc = *state; uc_hook trace1, trace2; void *mem; #ifdef RIP_NEXT_TO_THE_SELFMODIFY_OPCODE // These values assumes just before PC = 0x60000021 int64_t eax = 0x00000041; int64_t ecx = 0x5ffffff8; int64_t edx = 0x5ffffff8; int64_t ebx = 0x034a129b; int64_t esp = 0x6010229a; int64_t ebp = 0x60000002; int64_t esi = 0x1f350211; int64_t edi = 0x488ac239; #else // These values assumes PC == 0x6000000 int64_t eax = 0x73952c43; int64_t ecx = 0x6010229a; int64_t edx = 0x2a500e50; int64_t ebx = 0x034a1295; int64_t esp = 0x6010229a; int64_t ebp = 0x60000000; int64_t esi = 0x1f350211; int64_t edi = 0x488ac239; #endif mem = calloc(1, CODE_SPACE); assert_int_not_equal(0, mem); uc_assert_success(uc_open(UC_ARCH_X86, UC_MODE_32, &uc)); uc_assert_success(uc_mem_map(uc, PHY_STACK_REGION, CODE_SPACE, UC_PROT_ALL)); uc_assert_success(uc_mem_write(uc, PHY_STACK_REGION, X86_CODE32_ALPHA_MIXED, sizeof(X86_CODE32_ALPHA_MIXED) - 1)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_EAX, &eax)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_ECX, &ecx)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_EDX, &edx)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_EBX, &ebx)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_ESP, &esp)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_EBP, &ebp)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_ESI, &esi)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_EDI, &edi)); uc_assert_success(uc_hook_add(uc, &trace1, UC_HOOK_CODE, hook_code32, NULL, (uint64_t)1, (uint64_t)0)); uc_assert_success(uc_hook_add(uc, &trace2, UC_HOOK_MEM_VALID, hook_mem32, NULL, (uint64_t)1, (uint64_t)0)); uc_assert_success(uc_emu_start(uc, #ifdef RIP_NEXT_TO_THE_SELFMODIFY_OPCODE // Register set (before self-modifying IMUL opcode) // Start at "0x00000021: xorb %al, 0x30(%ecx) // Start at "0x00000021: xor byte ptr [ecx + 0x30], al PHY_STACK_REGION+0x0021, // 0x0024 didn't work #else PHY_STACK_REGION+0x0000, #endif PHY_STACK_REGION+sizeof(X86_CODE32_ALPHA_MIXED) - 1, 0, 0)); uc_assert_success(uc_close(uc)); }
static void test_low_paging(void **state) { uc_engine *uc; uc_err err; int r_eax; /* The following x86 code will map emulated physical memory to virtual memory using pages and attempt to read/write from virtual memory Specifically, the virtual memory address range has been mapped by Unicorn (0x7FF000 - 0x7FFFFF) Memory area purposes: 0x1000 = page directory 0x2000 = page table (identity map first 4 MiB) 0x3000 = page table (0x007FF000 -> 0x00004000) 0x4000 = data area (0xBEEF) */ const uint8_t code[] = { /* Zero memory for page directories and page tables */ 0xBF, 0x00, 0x10, 0x00, 0x00, /* MOV EDI, 0x1000 */ 0xB9, 0x00, 0x10, 0x00, 0x00, /* MOV ECX, 0x1000 */ 0x31, 0xC0, /* XOR EAX, EAX */ 0xF3, 0xAB, /* REP STOSD */ /* Load DWORD [0x4000] with 0xDEADBEEF to retrieve later */ 0xBF, 0x00, 0x40, 0x00, 0x00, /* MOV EDI, 0x4000 */ 0xB8, 0xEF, 0xBE, 0x00, 0x00, /* MOV EAX, 0xBEEF */ 0x89, 0x07, /* MOV [EDI], EAX */ /* Identity map the first 4MiB of memory */ 0xB9, 0x00, 0x04, 0x00, 0x00, /* MOV ECX, 0x400 */ 0xBF, 0x00, 0x20, 0x00, 0x00, /* MOV EDI, 0x2000 */ 0xB8, 0x03, 0x00, 0x00, 0x00, /* MOV EAX, 3 */ /* aLoop: */ 0xAB, /* STOSD */ 0x05, 0x00, 0x10, 0x00, 0x00, /* ADD EAX, 0x1000 */ 0xE2, 0xF8, /* LOOP aLoop */ /* Map physical address 0x4000 to virtual address 0x7FF000 */ 0xBF, 0xFC, 0x3F, 0x00, 0x00, /* MOV EDI, 0x3FFC */ 0xB8, 0x03, 0x40, 0x00, 0x00, /* MOV EAX, 0x4003 */ 0x89, 0x07, /* MOV [EDI], EAX */ /* Add page tables into page directory */ 0xBF, 0x00, 0x10, 0x00, 0x00, /* MOV EDI, 0x1000 */ 0xB8, 0x03, 0x20, 0x00, 0x00, /* MOV EAX, 0x2003 */ 0x89, 0x07, /* MOV [EDI], EAX */ 0xBF, 0x04, 0x10, 0x00, 0x00, /* MOV EDI, 0x1004 */ 0xB8, 0x03, 0x30, 0x00, 0x00, /* MOV EAX, 0x3003 */ 0x89, 0x07, /* MOV [EDI], EAX */ /* Load the page directory register */ 0xB8, 0x00, 0x10, 0x00, 0x00, /* MOV EAX, 0x1000 */ 0x0F, 0x22, 0xD8, /* MOV CR3, EAX */ /* Enable paging */ 0x0F, 0x20, 0xC0, /* MOV EAX, CR0 */ 0x0D, 0x00, 0x00, 0x00, 0x80, /* OR EAX, 0x80000000 */ 0x0F, 0x22, 0xC0, /* MOV CR0, EAX */ /* Clear EAX */ 0x31, 0xC0, /* XOR EAX, EAX */ /* Load using virtual memory address; EAX = 0xBEEF */ 0xBE, 0x00, 0xF0, 0x7F, 0x00, /* MOV ESI, 0x7FF000 */ 0x8B, 0x06, /* MOV EAX, [ESI] */ 0xF4, /* HLT */ }; /* Initialise X86-32bit mode */ err = uc_open(UC_ARCH_X86, UC_MODE_32, &uc); uc_assert_success(err); /* Map 8MB of memory at base address 0 */ err = uc_mem_map(uc, 0, (8 * 1024 * 1024), UC_PROT_ALL); uc_assert_success(err); /* Write code into memory at address 0 */ err = uc_mem_write(uc, 0, code, sizeof(code)); uc_assert_success(err); /* Start emulation */ err = uc_emu_start(uc, 0, sizeof(code), 0, 0); uc_assert_success(err); /* The code should have loaded 0xBEEF into EAX */ uc_reg_read(uc, UC_X86_REG_EAX, &r_eax); assert_int_equal(r_eax, 0xBEEF); uc_close(uc); }
static void test_x86_64(void **state) { uc_engine *uc; uc_err err; uc_hook trace1, trace2, trace3, trace4; static const uint64_t address = 0x1000000; static const uint8_t code[] = "\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"; int64_t rax = 0x71f3029efd49d41d; int64_t rbx = 0xd87b45277f133ddb; int64_t rcx = 0xab40d1ffd8afc461; int64_t rdx = 0x919317b4a733f01; int64_t rsi = 0x4c24e753a17ea358; int64_t rdi = 0xe509a57d2571ce96; int64_t r8 = 0xea5b108cc2b9ab1f; int64_t r9 = 0x19ec097c8eb618c1; int64_t r10 = 0xec45774f00c5f682; int64_t r11 = 0xe17e9dbec8c074aa; int64_t r12 = 0x80f86a8dc0f6d457; int64_t r13 = 0x48288ca5671c5492; int64_t r14 = 0x595f72f6e4017f6e; int64_t r15 = 0x1efd97aea331cccc; int64_t rsp = address + 0x200000; // Initialize emulator in X86-64bit mode err = uc_open(UC_ARCH_X86, UC_MODE_64, &uc); uc_assert_success(err); // map 2MB memory for this emulation err = uc_mem_map(uc, address, 2 * 1024 * 1024, UC_PROT_ALL); uc_assert_success(err); // write machine code to be emulated to memory err = uc_mem_write(uc, address, code, sizeof(code) - 1); uc_assert_success(err); // initialize machine registers uc_assert_success(uc_reg_write(uc, UC_X86_REG_RSP, &rsp)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_RAX, &rax)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_RBX, &rbx)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_RCX, &rcx)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_RDX, &rdx)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_RSI, &rsi)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_RDI, &rdi)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_R8, &r8)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_R9, &r9)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_R10, &r10)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_R11, &r11)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_R12, &r12)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_R13, &r13)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_R14, &r14)); uc_assert_success(uc_reg_write(uc, UC_X86_REG_R15, &r15)); // tracing all basic blocks with customized callback err = uc_hook_add(uc, &trace1, UC_HOOK_BLOCK, hook_block, NULL, 1, 0); uc_assert_success(err); // tracing all instructions in the range [address, address+20] err = uc_hook_add(uc, &trace2, UC_HOOK_CODE, hook_code64, NULL, address, address+20); uc_assert_success(err); // tracing all memory WRITE access (with @begin > @end) err = uc_hook_add(uc, &trace3, UC_HOOK_MEM_WRITE, hook_mem64, NULL, 1, 0); uc_assert_success(err); // tracing all memory READ access (with @begin > @end) err = uc_hook_add(uc, &trace4, UC_HOOK_MEM_READ, hook_mem64, NULL, 1, 0); uc_assert_success(err); // emulate machine code in infinite time (last param = 0), or when // finishing all the code. err = uc_emu_start(uc, address, address+sizeof(code) - 1, 0, 0); uc_assert_success(err); // Read registers uc_reg_read(uc, UC_X86_REG_RAX, &rax); uc_reg_read(uc, UC_X86_REG_RBX, &rbx); uc_reg_read(uc, UC_X86_REG_RCX, &rcx); uc_reg_read(uc, UC_X86_REG_RDX, &rdx); uc_reg_read(uc, UC_X86_REG_RSI, &rsi); uc_reg_read(uc, UC_X86_REG_RDI, &rdi); uc_reg_read(uc, UC_X86_REG_R8, &r8); uc_reg_read(uc, UC_X86_REG_R9, &r9); uc_reg_read(uc, UC_X86_REG_R10, &r10); uc_reg_read(uc, UC_X86_REG_R11, &r11); uc_reg_read(uc, UC_X86_REG_R12, &r12); uc_reg_read(uc, UC_X86_REG_R13, &r13); uc_reg_read(uc, UC_X86_REG_R14, &r14); uc_reg_read(uc, UC_X86_REG_R15, &r15); #if 0 printf(">>> RAX = 0x%" PRIx64 "\n", rax); printf(">>> RBX = 0x%" PRIx64 "\n", rbx); printf(">>> RCX = 0x%" PRIx64 "\n", rcx); printf(">>> RDX = 0x%" PRIx64 "\n", rdx); printf(">>> RSI = 0x%" PRIx64 "\n", rsi); printf(">>> RDI = 0x%" PRIx64 "\n", rdi); printf(">>> R8 = 0x%" PRIx64 "\n", r8); printf(">>> R9 = 0x%" PRIx64 "\n", r9); printf(">>> R10 = 0x%" PRIx64 "\n", r10); printf(">>> R11 = 0x%" PRIx64 "\n", r11); printf(">>> R12 = 0x%" PRIx64 "\n", r12); printf(">>> R13 = 0x%" PRIx64 "\n", r13); printf(">>> R14 = 0x%" PRIx64 "\n", r14); printf(">>> R15 = 0x%" PRIx64 "\n", r15); #endif uc_assert_success(uc_close(uc)); }
static void test_basic_blocks(void **state) { uc_engine *uc = *state; uc_hook trace1; #define BASEADDR 0x1000000 uint64_t address = BASEADDR; const uint8_t code[] = { 0x33, 0xC0, // xor eax, eax 0x90, // nop 0x90, // nop 0xEB, 0x00, // jmp $+2 0x90, // nop 0x90, // nop 0x90, // nop }; static const struct bb blocks[] = { {BASEADDR, 6}, {BASEADDR+ 6, 3}, }; struct bbtest bbtest = { .blocks = blocks, .blocknum = 0, }; #undef BASEADDR // map 2MB memory for this emulation OK(uc_mem_map(uc, address, 2 * 1024 * 1024, UC_PROT_ALL)); // write machine code to be emulated to memory OK(uc_mem_write(uc, address, code, sizeof(code))); // trace all basic blocks OK(uc_hook_add(uc, &trace1, UC_HOOK_BLOCK, test_basic_blocks_hook, &bbtest, 1, 0)); OK(uc_emu_start(uc, address, address+sizeof(code), 0, 0)); } /******************************************************************************/ // callback for tracing basic blocks static void hook_block(uc_engine *uc, uint64_t address, uint32_t size, void *user_data) { //printf(">>> Tracing basic block at 0x%"PRIx64 ", block size = 0x%x\n", address, size); } // callback for tracing instruction static void hook_code(uc_engine *uc, uint64_t address, uint32_t size, void *user_data) { //int eflags; //printf(">>> Tracing instruction at 0x%"PRIx64 ", instruction size = 0x%x\n", address, size); //uc_reg_read(uc, UC_X86_REG_EFLAGS, &eflags); //printf(">>> --- EFLAGS is 0x%x\n", eflags); // Uncomment below code to stop the emulation using uc_emu_stop() // if (address == 0x1000009) // uc_emu_stop(uc); } static void test_i386(void **state) { uc_engine *uc; uc_err err; uint32_t tmp; uc_hook trace1, trace2; const uint8_t code[] = "\x41\x4a"; // INC ecx; DEC edx const uint64_t address = 0x1000000; int r_ecx = 0x1234; // ECX register int r_edx = 0x7890; // EDX register // Initialize emulator in X86-32bit mode err = uc_open(UC_ARCH_X86, UC_MODE_32, &uc); uc_assert_success(err); // map 2MB memory for this emulation err = uc_mem_map(uc, address, 2 * 1024 * 1024, UC_PROT_ALL); uc_assert_success(err); // write machine code to be emulated to memory err = uc_mem_write(uc, address, code, sizeof(code)-1); uc_assert_success(err); // initialize machine registers err = uc_reg_write(uc, UC_X86_REG_ECX, &r_ecx); uc_assert_success(err); err = uc_reg_write(uc, UC_X86_REG_EDX, &r_edx); uc_assert_success(err); // tracing all basic blocks with customized callback err = uc_hook_add(uc, &trace1, UC_HOOK_BLOCK, hook_block, NULL, 1, 0); uc_assert_success(err); // tracing all instruction by having @begin > @end err = uc_hook_add(uc, &trace2, UC_HOOK_CODE, hook_code, NULL, 1, 0); uc_assert_success(err); // emulate machine code in infinite time err = uc_emu_start(uc, address, address+sizeof(code)-1, 0, 0); uc_assert_success(err); // now print out some registers //printf(">>> Emulation done. Below is the CPU context\n"); uc_reg_read(uc, UC_X86_REG_ECX, &r_ecx); uc_reg_read(uc, UC_X86_REG_EDX, &r_edx); assert_int_equal(r_ecx, 0x1235); assert_int_equal(r_edx, 0x788F); // read from memory err = uc_mem_read(uc, address, (uint8_t *)&tmp, 4); uc_assert_success(err); //printf(">>> Read 4 bytes from [0x%"PRIX64"] = 0x%x\n", address, tmp); uc_close(uc); }
// segfaults with NULL-deref (caused by UC_PROT_NONE) static void test_nullptr_deref_wrong_perms(void **state){ uc_engine *uc = *state; const uint64_t base_addr = 0x400000; uc_assert_success(uc_mem_map(uc, base_addr, 4096, UC_PROT_NONE)); uc_emu_start(uc, base_addr, base_addr + 1, 0, 0); }
static void test_i386_inout(void **state) { uc_engine *uc; uc_err err; uc_hook trace1, trace2, trace3, trace4; int r_eax = 0x1234; // EAX register int r_ecx = 0x6789; // ECX register static const uint64_t address = 0x1000000; static const uint8_t code[] = { 0x41, // inc ecx 0xE4, 0x3F, // in al, 0x3F 0x4A, // dec edx 0xE6, 0x46, // out 0x46, al 0x43, // inc ebx }; // Initialize emulator in X86-32bit mode err = uc_open(UC_ARCH_X86, UC_MODE_32, &uc); uc_assert_success(err); // map 2MB memory for this emulation err = uc_mem_map(uc, address, 2 * 1024 * 1024, UC_PROT_ALL); uc_assert_success(err); // write machine code to be emulated to memory err = uc_mem_write(uc, address, code, sizeof(code)); uc_assert_success(err); // initialize machine registers err = uc_reg_write(uc, UC_X86_REG_EAX, &r_eax); uc_assert_success(err); err = uc_reg_write(uc, UC_X86_REG_ECX, &r_ecx); uc_assert_success(err); // tracing all basic blocks with customized callback err = uc_hook_add(uc, &trace1, UC_HOOK_BLOCK, hook_block, NULL, 1, 0); uc_assert_success(err); // tracing all instructions err = uc_hook_add(uc, &trace2, UC_HOOK_CODE, hook_code, NULL, 1, 0); uc_assert_success(err); // uc IN instruction err = uc_hook_add(uc, &trace3, UC_HOOK_INSN, hook_in, NULL, 1, 0, UC_X86_INS_IN); uc_assert_success(err); // uc OUT instruction err = uc_hook_add(uc, &trace4, UC_HOOK_INSN, hook_out, NULL, 1, 0, UC_X86_INS_OUT); uc_assert_success(err); // emulate machine code in infinite time err = uc_emu_start(uc, address, address+sizeof(code), 0, 0); uc_assert_success(err); uc_reg_read(uc, UC_X86_REG_EAX, &r_eax); uc_reg_read(uc, UC_X86_REG_ECX, &r_ecx); //printf(">>> EAX = 0x%x\n", r_eax); //printf(">>> ECX = 0x%x\n", r_ecx); // TODO: Assert on the register values here uc_assert_success(uc_close(uc)); }
static void test_i386_reg_save(void **state) { uc_engine *uc; uc_context *saved_context; static const uint64_t address = 0; static const uint8_t code[] = { 0x40 // inc eax }; int32_t eax = 1; // Initialize emulator uc_assert_success(uc_open(UC_ARCH_X86, UC_MODE_32, &uc)); // map 8KB memory for this emulation uc_assert_success(uc_mem_map(uc, address, 8 * 1024, UC_PROT_ALL)); // write machine code to be emulated to memory uc_assert_success(uc_mem_write(uc, address, code, sizeof(code))); // set eax to 1 uc_assert_success(uc_reg_write(uc, UC_X86_REG_EAX, &eax)); // step one instruction uc_assert_success(uc_emu_start(uc, address, address+1, 0, 0)); // grab a buffer to use for state saving uc_assert_success(uc_context_alloc(uc, &saved_context)); // save the state uc_assert_success(uc_context_save(uc, saved_context)); // step one instruction uc_assert_success(uc_emu_start(uc, address, address+1, 0, 0)); // check that eax == 3 uc_assert_success(uc_reg_read(uc, UC_X86_REG_EAX, &eax)); assert_int_equal(eax, 3); // restore the state uc_context_restore(uc, saved_context); // check that eax == 2 uc_assert_success(uc_reg_read(uc, UC_X86_REG_EAX, &eax)); assert_int_equal(eax, 2); // step one instruction uc_assert_success(uc_emu_start(uc, address, address+1, 0, 0)); // check that eax == 3 uc_assert_success(uc_reg_read(uc, UC_X86_REG_EAX, &eax)); assert_int_equal(eax, 3); // restore the state uc_context_restore(uc, saved_context); // check that eax == 2 uc_assert_success(uc_reg_read(uc, UC_X86_REG_EAX, &eax)); assert_int_equal(eax, 2); // clean up; uc_context_free(saved_context); uc_assert_success(uc_close(uc)); }