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

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

Browse Source
This commit is contained in:
Nguyen Anh Quynh 2015-09-05 09:12:23 +08:00
commit 7b5bb95147
4 changed files with 338 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
include/unicorn/unicorn.h
View File

@ -150,13 +150,13 @@ typedef void (*uc_cb_insn_out_t)(ucengine *uc, uint32_t port, int size, uint32_t
// All type of memory accesses for UC_HOOK_MEM_*
typedef enum uc_mem_type {
UC_MEM_READ = 16, // Memory is read from
UC_MEM_WRITE, // Memory is written to
UC_MEM_READ_WRITE, // Memory is accessed (either READ or WRITE)
UC_MEM_EXEC, // Unmapped memory is fetched, but unmapped (invalid memory access)
UC_MEM_WRITE_PROT, // write to write protected memory
UC_MEM_READ_PROT, // read from read protected memory
UC_MEM_EXEC_PROT, // fetch from non-executable memory
UC_MEM_READ = 16, // Unmapped memory is read from
UC_MEM_WRITE, // Unmapped memory is written to
UC_MEM_READ_WRITE, // Unmapped memory is accessed (either READ or WRITE)
UC_MEM_EXEC, // Unmapped memory is fetched
UC_MEM_WRITE_PROT, // Write to write protected, but mapped, memory
UC_MEM_READ_PROT, // Read from read protected, but mapped, memory
UC_MEM_EXEC_PROT, // Fetch from non-executable, but mapped, memory
} uc_mem_type;
// All type of hooks for uc_hook_add() API.

2
qemu/cputlb.c
View File

@ -300,7 +300,7 @@ tb_page_addr_t get_page_addr_code(CPUArchState *env1, target_ulong addr)
(addr & TARGET_PAGE_MASK))) {
cpu_ldub_code(env1, addr);
//check for NX related error from softmmu
if (env1->invalid_error == UC_ERR_MEM_READ) {
if (env1->invalid_error == UC_ERR_EXEC_PROT) {
env1->invalid_error = UC_ERR_CODE_INVALID;
return -1;
}

3
samples/Makefile
View File

@ -97,6 +97,7 @@ endif
ifneq (,$(findstring x86,$(UNICORN_ARCHS)))
SOURCES += sample_x86.c
SOURCES += shellcode.c
SOURCES += mem_apis.c
endif
ifneq (,$(findstring m68k,$(UNICORN_ARCHS)))
SOURCES += sample_m68k.c
@ -111,7 +112,7 @@ all: $(BINARY)
clean:
rm -rf *.o $(OBJS_ELF) $(BINARY) $(SAMPLEDIR)/*.exe $(SAMPLEDIR)/*.static $(OBJDIR)/lib$(LIBNAME)* $(OBJDIR)/$(LIBNAME)*
rm -rf libunicorn*.so libunicorn*.lib libunicorn*.dylib unicorn*.dll unicorn*.lib
rm -rf sample_x86 sample_arm sample_arm64 sample_mips sample_sparc sample_ppc sample_m68k shellcode
rm -rf sample_x86 sample_arm sample_arm64 sample_mips sample_sparc sample_ppc sample_m68k shellcode mem_apis
$(BINARY): $(OBJS)

328
samples/mem_apis.c Normal file
View File

@ -0,0 +1,328 @@
/*
Sample use of uc_mem_unmap, uc_mem_protect, and memory permissions
Copyright(c) 2015 Chris Eagle
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
version 2 as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#define __STDC_FORMAT_MACROS
#include <inttypes.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unicorn/unicorn.h>
static int insts_executed;
// callback for tracing instructions, detect HLT and terminate emulation
static void hook_code(ucengine *uc, uint64_t addr, uint32_t size, void *user_data)
{
uint8_t opcode;
unsigned char buf[256];
insts_executed++;
if (uc_mem_read(uc, addr, buf, size) != UC_ERR_OK) {
printf("not ok - uc_mem_read fail during hook_code callback, addr: 0x%" PRIx64 "\n", addr);
if (uc_emu_stop(uc) != UC_ERR_OK) {
printf("not ok - uc_emu_stop fail during hook_code callback, addr: 0x%" PRIx64 "\n", addr);
_exit(-1);
}
}
opcode = buf[0];
switch (opcode) {
case 0x41: //inc ecx
if (uc_mem_protect(uc, 0x101000, 0x1000, UC_PROT_READ) != UC_ERR_OK) {
printf("not ok - uc_mem_protect fail during hook_code callback, addr: 0x%" PRIx64 "\n", addr);
_exit(-1);
}
break;
case 0x42: //inc edx
if (uc_mem_unmap(uc, 0x101000, 0x1000) != UC_ERR_OK) {
printf("not ok - uc_mem_unmap fail during hook_code callback, addr: 0x%" PRIx64 "\n", addr);
_exit(-1);
}
break;
case 0xf4: //hlt
if (uc_emu_stop(uc) != UC_ERR_OK) {
printf("not ok - uc_emu_stop fail during hook_code callback, addr: 0x%" PRIx64 "\n", addr);
_exit(-1);
}
break;
default: //all others
break;
}
}
// callback for tracing invalid memory access (READ/WRITE/EXEC)
static bool hook_mem_invalid(ucengine *uc, uc_mem_type type,
uint64_t addr, int size, int64_t value, void *user_data)
{
switch(type) {
default:
printf("not ok - UC_HOOK_MEM_INVALID type: %d at 0x%" PRIx64 "\n", type, addr);
return false;
case UC_MEM_READ:
printf("not ok - Read from invalid memory at 0x%"PRIx64 ", data size = %u\n", addr, size);
return false;
case UC_MEM_WRITE:
printf("not ok - Write to invalid memory at 0x%"PRIx64 ", data size = %u, data value = 0x%"PRIx64 "\n", addr, size, value);
return false;
case UC_MEM_EXEC_PROT:
printf("not ok - Fetch from non-executable memory at 0x%"PRIx64 "\n", addr);
return false;
case UC_MEM_WRITE_PROT:
printf("not ok - Write to non-writeable memory at 0x%"PRIx64 ", data size = %u, data value = 0x%"PRIx64 "\n", addr, size, value);
return false;
case UC_MEM_READ_PROT:
printf("not ok - Read from non-readable memory at 0x%"PRIx64 ", data size = %u\n", addr, size);
return false;
}
}
static void do_nx_demo(bool cause_fault)
{
ucengine *uc;
uchook trace1, trace2;
uc_err err;
uint8_t code_buf[0x3000];
insts_executed = 0;
printf("===================================\n");
printf("# Example of marking memory NX (%s)\n", cause_fault ? "faulting" : "non-faulting");
// Initialize emulator in X86-32bit mode
err = uc_open(UC_ARCH_X86, UC_MODE_32, &uc);
if (err) {
printf("not ok - Failed on uc_open() with error returned: %u\n", err);
return;
}
uc_mem_map(uc, 0x100000, 0x3000, UC_PROT_READ | UC_PROT_EXEC);
/*
bits 32
page0:
times 4091 inc eax
jmp page2
page1:
times 4095 inc eax
hlt
page2:
jmp page1
*/
memset(code_buf, 0x40, sizeof(code_buf)); //fill with inc eax
memcpy(code_buf + 0x1000 - 5, "\xe9\x00\x10\x00\x00", 5); //jump to 0x102000
memcpy(code_buf + 0x2000, "\xe9\xfb\xef\xff\xff", 5); //jump to 0x101000
code_buf[0x1fff] = 0xf4; //hlt
if (cause_fault) {
//insert instruction to trigger U_PROT_EXEC change (see hook_code function)
code_buf[0x1000] = 0x41; //inc ecx at page1
}
// write machine code to be emulated to memory
if (uc_mem_write(uc, 0x100000, code_buf, sizeof(code_buf))) {
printf("not ok - Failed to write emulation code to memory, quit!\n");
return;
}
// intercept code and invalid memory events
if (uc_hook_add(uc, &trace2, UC_HOOK_CODE, hook_code, NULL, (uint64_t)1, (uint64_t)0) != UC_ERR_OK ||
uc_hook_add(uc, &trace1, UC_HOOK_MEM_INVALID, hook_mem_invalid, NULL) != UC_ERR_OK) {
printf("not ok - Failed to install hooks\n");
return;
}
// emulate machine code until told to stop by hook_code
printf("BEGINNING EXECUTION\n");
err = uc_emu_start(uc, 0x100000, 0x103000, 0, 0);
if (err != UC_ERR_OK) {
printf("not ok - Failure on uc_emu_start() with error %u: %s\n", err, uc_strerror(err));
printf("FAILED EXECUTION\n");
} else {
printf("SUCCESSFUL EXECUTION\n");
}
printf("Executed %d instructions\n\n", insts_executed);
uc_close(uc);
}
void nx_test()
{
printf("NX demo - step 1: show that code runs to completion\n");
do_nx_demo(false);
printf("NX demo - step 2: show that code fails without UC_PROT_EXEC\n");
do_nx_demo(true);
}
const uint8_t WRITE_DEMO[] =
"\x90\xc7\x05\x00\x20\x10\x00\x78\x56\x34\x12\xc7\x05\xfc\x0f\x10"
"\x00\x78\x56\x34\x12\xc7\x05\x00\x10\x10\x00\x21\x43\x65\x87";
static void do_perms_demo(bool change_perms)
{
ucengine *uc;
uchook trace1, trace2;
uc_err err;
uint8_t code_buf[0x3000];
insts_executed = 0;
printf("===================================\n");
printf("# Example of manipulating memory permissions\n");
// Initialize emulator in X86-32bit mode
err = uc_open(UC_ARCH_X86, UC_MODE_32, &uc);
if (err) {
printf("not ok - Failed on uc_open() with error returned: %u\n", err);
return;
}
uc_mem_map(uc, 0x100000, 0x3000, UC_PROT_ALL);
/*
bits 32
nop
mov dword [0x102000], 0x12345678
mov dword [0x100ffc], 0x12345678
mov dword [0x101000], 0x87654321 ; crashing case crashes here
times 1000 nop
hlt
*/
memcpy(code_buf, WRITE_DEMO, sizeof(WRITE_DEMO) - 1);
memset(code_buf + sizeof(WRITE_DEMO) - 1, 0x90, 1000);
code_buf[sizeof(WRITE_DEMO) - 1 + 1000] = 0xf4; //hlt
if (change_perms) {
code_buf[0] = 0x41; //inc ecx (see hook_code function)
}
// write machine code to be emulated to memory
if (uc_mem_write(uc, 0x100000, code_buf, sizeof(code_buf))) {
printf("not ok - Failed to write emulation code to memory, quit!\n");
return;
}
// intercept code and invalid memory events
if (uc_hook_add(uc, &trace2, UC_HOOK_CODE, hook_code, NULL, (uint64_t)1, (uint64_t)0) != UC_ERR_OK ||
uc_hook_add(uc, &trace1, UC_HOOK_MEM_INVALID, hook_mem_invalid, NULL) != UC_ERR_OK) {
printf("not ok - Failed to install hooks\n");
return;
}
// emulate machine code until told to stop by hook_code
printf("BEGINNING EXECUTION\n");
err = uc_emu_start(uc, 0x100000, 0x103000, 0, 0);
if (err != UC_ERR_OK) {
printf("FAILED EXECUTION\n");
printf("not ok - Failure on uc_emu_start() with error %u: %s\n", err, uc_strerror(err));
} else {
printf("SUCCESSFUL EXECUTION\n");
}
printf("Executed %d instructions\n\n", insts_executed);
uc_close(uc);
}
void perms_test()
{
printf("Permissions demo - step 1: show that area is writeable\n");
do_perms_demo(false);
printf("Permissions demo - step 2: show that code fails when memory marked unwriteable\n");
do_perms_demo(true);
}
static void do_unmap_demo(bool do_unmap)
{
ucengine *uc;
uchook trace1, trace2;
uc_err err;
uint8_t code_buf[0x3000];
insts_executed = 0;
printf("===================================\n");
printf("# Example of unmapping memory\n");
// Initialize emulator in X86-32bit mode
err = uc_open(UC_ARCH_X86, UC_MODE_32, &uc);
if (err) {
printf("not ok - Failed on uc_open() with error returned: %u\n", err);
return;
}
uc_mem_map(uc, 0x100000, 0x3000, UC_PROT_ALL);
/*
bits 32
nop
mov dword [0x102000], 0x12345678
mov dword [0x100ffc], 0x12345678
mov dword [0x101000], 0x87654321 ; crashing case crashes here
times 1000 nop
hlt
*/
memcpy(code_buf, WRITE_DEMO, sizeof(WRITE_DEMO) - 1);
memset(code_buf + sizeof(WRITE_DEMO) - 1, 0x90, 1000);
code_buf[sizeof(WRITE_DEMO) - 1 + 1000] = 0xf4; //hlt
if (do_unmap) {
code_buf[0] = 0x42; //inc edx (see hook_code function)
}
// write machine code to be emulated to memory
if (uc_mem_write(uc, 0x100000, code_buf, 0x1000)) {
printf("not ok - Failed to write emulation code to memory, quit!\n");
return;
}
// intercept code and invalid memory events
if (uc_hook_add(uc, &trace2, UC_HOOK_CODE, hook_code, NULL, (uint64_t)1, (uint64_t)0) != UC_ERR_OK ||
uc_hook_add(uc, &trace1, UC_HOOK_MEM_INVALID, hook_mem_invalid, NULL) != UC_ERR_OK) {
printf("not ok - Failed to install hooks\n");
return;
}
// emulate machine code until told to stop by hook_code
printf("BEGINNING EXECUTION\n");
err = uc_emu_start(uc, 0x100000, 0x103000, 0, 0);
if (err != UC_ERR_OK) {
printf("FAILED EXECUTION\n");
printf("not ok - Failure on uc_emu_start() with error %u: %s\n", err, uc_strerror(err));
} else {
printf("SUCCESSFUL EXECUTION\n");
}
printf("Executed %d instructions\n\n", insts_executed);
uc_close(uc);
}
void unmap_test()
{
printf("Unmap demo - step 1: show that area is writeable\n");
do_unmap_demo(false);
printf("Unmap demo - step 2: show that code fails when memory is unmapped\n");
do_unmap_demo(true);
}
int main(int argc, char **argv, char **envp)
{
nx_test();
perms_test();
unmap_test();
return 0;
}