自学教程：C++ uc_mem_map函数代码示例

/* 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_overlap_unmap_double_map(void **state){    uc_engine *uc = *state;    uc_mem_map(  uc, 0x1000, 0x2000, 0);    uc_mem_map(  uc, 0x1000, 0x1000, 0);    uc_mem_unmap(uc, 0x2000, 0x1000);}

int main(int argc, char **argv, char **envp){    uc_engine *uc;    uc_hook trace1, trace2;    uc_err err;    uint32_t eax, ebx;        printf("Memory protections test/n");    // Initialize emulator in X86-32bit mode    err = uc_open(UC_ARCH_X86, UC_MODE_32, &uc);    if (err) {        printf("Failed on uc_open() with error returned: %u/n", err);        return 1;    }    uc_mem_map(uc, 0x100000, 0x1000, UC_PROT_READ);    uc_mem_map(uc, 0x300000, 0x1000, UC_PROT_READ | UC_PROT_WRITE);    uc_mem_map(uc, 0x400000, 0x1000, UC_PROT_WRITE);        // write machine code to be emulated to memory    if (uc_mem_write(uc, 0x100000, PROGRAM, sizeof(PROGRAM))) {        printf("Failed to write emulation code to memory, quit!/n");        return 2;    } else {        printf("Allowed to write to read only memory via uc_mem_write/n");    }    uc_mem_write(uc, 0x300000, (const uint8_t*)"/x41/x41/x41/x41", 4);    uc_mem_write(uc, 0x400000, (const uint8_t*)"/x42/x42/x42/x42", 4);    //uc_hook_add(uc, &trace2, UC_HOOK_CODE, hook_code, NULL, (uint64_t)0x400000, (uint64_t)0x400fff);    // intercept invalid memory events    uc_hook_add(uc, &trace1, UC_MEM_READ_PROT, hook_mem_invalid, NULL);    // emulate machine code in infinite time    printf("BEGIN execution/n");    err = uc_emu_start(uc, 0x100000, 0x100000 + sizeof(PROGRAM), 0, 2);    if (err) {        printf("Expected failure on uc_emu_start() with error returned %u: %s/n",                err, uc_strerror(err));    } else {        printf("UNEXPECTED uc_emu_start returned UC_ERR_OK/n");    }    printf("END execution/n");    uc_reg_read(uc, UC_X86_REG_EAX, &eax);    printf("Final eax = 0x%x/n", eax);    uc_reg_read(uc, UC_X86_REG_EBX, &ebx);    printf("Final ebx = 0x%x/n", ebx);    uc_close(uc);        return 0;}

static void VM_exec(){    int c;    uc_engine *uc;    uc_err err;    // Initialize emulator in X86-64bit mode    err = uc_open(UC_ARCH_X86, UC_MODE_32, &uc);    if(err)    {        printf("Failed on uc_open() with error returned: %s/n", uc_strerror(err));        return;    }repeat:    err = uc_mem_map(uc, ADDRESS1, SIZE, UC_PROT_ALL);    if(err != UC_ERR_OK)    {        printf("Failed to map memory %s/n", uc_strerror(err));        goto err;    }    err = uc_mem_map(uc, ADDRESS2, SIZE, UC_PROT_ALL);    if(err != UC_ERR_OK)    {        printf("Failed to map memory %s/n", uc_strerror(err));        goto err;    }    err = uc_mem_unmap(uc, ADDRESS1, SIZE);    if(err != UC_ERR_OK)    {        printf("Failed to unmap memory %s/n", uc_strerror(err));        goto err;    }    err = uc_mem_unmap(uc, ADDRESS2, SIZE);    if(err != UC_ERR_OK)    {        printf("Failed to unmap memory %s/n", uc_strerror(err));        goto err;    }    for(;;)    {        c = getchar(); //pause here and analyse memory usage before exiting with a program like VMMap;        if(c != 'e')            goto repeat;        else            break;    }err:    uc_close(uc);}

static void test_strange_map(void **state){    uc_engine *uc = *state;    uc_mem_map(  uc, 0x0,0x3000,0);     uc_mem_unmap(uc, 0x1000,0x1000);     uc_mem_map(  uc, 0x3000,0x1000,0);     uc_mem_map(  uc, 0x4000,0x1000,0);     uc_mem_map(  uc, 0x1000,0x1000,0);     uc_mem_map(  uc, 0x5000,0x1000,0);     uc_mem_unmap(uc, 0x0,0x1000); }

// emulate code that jumps to invalid memorystatic 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 tracing invalid memory access (READ or WRITE)static bool hook_mem_invalid(uc_engine *uc, uc_mem_type type,        uint64_t addr, int size, int64_t value, void *user_data){    uint32_t testval;    switch(type) {        default:            printf("not ok %d - memory invalid type: %d at 0x%" PRIx64 "/n", log_num++, type, addr);            return false;        case UC_MEM_WRITE_UNMAPPED:            printf("# write to invalid memory at 0x%"PRIx64 ", data size = %u, data value = 0x%"PRIx64 "/n", addr, size, value);            if (uc_mem_read(uc, addr, &testval, sizeof(testval)) != UC_ERR_OK) {                printf("ok %d - uc_mem_read fail for address: 0x%" PRIx64 "/n", log_num++, addr);            } else {                printf("not ok %d - uc_mem_read success after unmap at test %d/n", log_num++, test_num - 1);            }            if (uc_mem_map(uc, addr & ~0xfffL, 0x1000, UC_PROT_READ | UC_PROT_WRITE) != UC_ERR_OK) {                printf("not ok %d - uc_mem_map fail during hook_mem_invalid callback, addr: 0x%" PRIx64 "/n", log_num++, addr);            } else {                printf("ok %d - uc_mem_map success/n", log_num++);            }            return true;    }}

// callback for tracing memory access (READ or WRITE)static bool hook_mem_invalid(uc_engine *uc, uc_mem_type type,        uint64_t address, int size, int64_t value, void *user_data){    uint32_t esp;    uc_reg_read(uc, UC_X86_REG_ESP, &esp);    switch(type) {        default:            // return false to indicate we want to stop emulation            return false;        case UC_MEM_WRITE:            //if this is a push, esp has not been adjusted yet            if (esp == (address + size)) {                uint32_t upper;                upper = (esp + 0xfff) & ~0xfff;                printf(">>> Stack appears to be missing at 0x%"PRIx64 ", allocating now/n", address);                // map this memory in with 2MB in size                uc_mem_map(uc, upper - 0x8000, 0x8000, UC_PROT_READ | UC_PROT_WRITE);                // return true to indicate we want to continue                return true;            }            printf(">>> Missing memory is being WRITTEN at 0x%"PRIx64 ", data size = %u, data value = 0x%"PRIx64 "/n",                    address, size, value);            return false;        case UC_MEM_WRITE_PROT:            printf(">>> RO memory is being WRITTEN at 0x%"PRIx64 ", data size = %u, data value = 0x%"PRIx64 "/n",                    address, size, value);            return false;    }}

int main(){    int size;    uint8_t *buf;    uc_engine *uc;    uc_hook uh_trap;    uc_err err = uc_open (UC_ARCH_X86, UC_MODE_64, &uc);    if (err) {        fprintf (stderr, "Cannot initialize unicorn/n");        return 1;    }    size = UC_BUG_WRITE_SIZE;    buf = malloc (size);    if (!buf) {        fprintf (stderr, "Cannot allocate/n");        return 1;    }    memset (buf, 0, size);    if (!uc_mem_map(uc, UC_BUG_WRITE_ADDR, size, UC_PROT_ALL)) {        uc_mem_write(uc, UC_BUG_WRITE_ADDR,                (const uint8_t*)"/xff/xff/xff/xff/xff/xff/xff/xff", 8);    }    uc_hook_add(uc, &uh_trap, UC_HOOK_INTR, _interrupt, NULL, 1, 0);    uc_emu_start(uc, UC_BUG_WRITE_ADDR, UC_BUG_WRITE_ADDR+8, 0, 1);    uc_close(uc);    printf ("Correct: %s/n", got_sigill? "YES": "NO");    return got_sigill? 0: 1;}

/** * 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));}

static bool hook_invalid_mem(uc_engine *uc, uc_mem_type type, uint64_t address, int size, int64_t value, void *user_data){    uc_err err;    uint64_t address_align = TARGET_PAGE_ALIGN(address);    if(address == 0)    {        printf("Address is 0, proof 0x%" PRIx64 "/n", address);        return false;    }    switch(type)    {        default:            return false;            break;        case UC_MEM_WRITE_UNMAPPED:            printf("Mapping write address 0x%" PRIx64 " to aligned 0x%" PRIx64 "/n", address, address_align);            err = uc_mem_map(uc, address_align, PAGE_8K, UC_PROT_ALL);            if(err != UC_ERR_OK)            {                printf("Failed to map memory on UC_MEM_WRITE_UNMAPPED %s/n", uc_strerror(err));                return false;            }            return true;            break;        case UC_MEM_READ_UNMAPPED:            printf("Mapping read address 0x%" PRIx64 " to aligned 0x%" PRIx64 "/n", address, address_align);            err = uc_mem_map(uc, address_align, PAGE_8K, UC_PROT_ALL);            if(err != UC_ERR_OK)            {                printf("Failed to map memory on UC_MEM_READ_UNMAPPED %s/n", uc_strerror(err));                return false;            }            return true;            break;    }}

static void test_arm(void){    uc_engine *uc;    uc_err err;    uc_hook trace1, trace2;    int r0 = 0x1234;     // R0 register    int r2 = 0x6789;     // R1 register    int r3 = 0x3333;     // R2 register    int r1;     // R1 register    printf("Emulate ARM code/n");    // Initialize emulator in ARM mode    err = uc_open(UC_ARCH_ARM, UC_MODE_ARM, &uc);    if (err) {        printf("Failed on uc_open() with error returned: %u (%s)/n",                err, uc_strerror(err));        return;    }    // map 2MB memory for this emulation    uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);    // write machine code to be emulated to memory    uc_mem_write(uc, ADDRESS, ARM_CODE, sizeof(ARM_CODE) - 1);    // initialize machine registers    uc_reg_write(uc, UC_ARM_REG_R0, &r0);    uc_reg_write(uc, UC_ARM_REG_R2, &r2);    uc_reg_write(uc, UC_ARM_REG_R3, &r3);    // tracing all basic blocks with customized callback    uc_hook_add(uc, &trace1, UC_HOOK_BLOCK, hook_block, NULL, 1, 0);    // tracing one instruction at ADDRESS with customized callback    uc_hook_add(uc, &trace2, UC_HOOK_CODE, hook_code, NULL, ADDRESS, ADDRESS);    // emulate machine code in infinite time (last param = 0), or when    // finishing all the code.    err = uc_emu_start(uc, ADDRESS, ADDRESS + sizeof(ARM_CODE) -1, UC_SECOND_SCALE * TIMEOUT, 0);    if (err) {        printf("Failed on uc_emu_start() with error returned: %u/n", err);    }    // now print out some registers    printf(">>> Emulation done. Below is the CPU context/n");    uc_reg_read(uc, UC_ARM_REG_R0, &r0);    uc_reg_read(uc, UC_ARM_REG_R1, &r1);    printf(">>> R0 = 0x%x/n", r0);    printf(">>> R1 = 0x%x/n", r1);    uc_close(uc);}

// emulate code that jump to invalid memorystatic void test_i386_jump_invalid(void){    uc_engine *uc;    uc_err err;    uc_hook trace1, trace2;    int r_ecx = 0x1234;     // ECX register    int r_edx = 0x7890;     // EDX register    printf("===================================/n");    printf("Emulate i386 code that jumps to invalid memory/n");    // Initialize emulator in X86-32bit mode    err = uc_open(UC_ARCH_X86, UC_MODE_32, &uc);    if (err) {        printf("Failed on uc_open() with error returned: %u/n", err);        return;    }    // map 2MB memory for this emulation    uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);    // write machine code to be emulated to memory    if (uc_mem_write(uc, ADDRESS, X86_CODE32_JMP_INVALID, sizeof(X86_CODE32_JMP_INVALID) - 1)) {        printf("Failed to write emulation code to memory, quit!/n");        return;    }    // initialize machine registers    uc_reg_write(uc, UC_X86_REG_ECX, &r_ecx);    uc_reg_write(uc, UC_X86_REG_EDX, &r_edx);    // tracing all basic blocks with customized callback    uc_hook_add(uc, &trace1, UC_HOOK_BLOCK, hook_block, NULL, 1, 0);    // tracing all instructions by having @begin > @end    uc_hook_add(uc, &trace2, UC_HOOK_CODE, hook_code, NULL, 1, 0);    // emulate machine code in infinite time    err = uc_emu_start(uc, ADDRESS, ADDRESS + sizeof(X86_CODE32_JMP_INVALID) - 1, 0, 0);    if (err) {        printf("Failed on uc_emu_start() with error returned %u: %s/n",                err, uc_strerror(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);    printf(">>> ECX = 0x%x/n", r_ecx);    printf(">>> EDX = 0x%x/n", r_edx);    uc_close(uc);}

int main(int argc, char **argv, char **envp){    uc_engine *uc;    uc_hook trace1, trace2;    uc_err err;    // 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 -1;    }    uc_mem_map(uc, 0x1000, 0x1000, UC_PROT_ALL);    if (err) {        printf("not ok - Failed on uc_mem_map() with error returned: %u/n", err);        return -1;    }    uc_mem_map(uc, 0x4000, 0x1000, UC_PROT_ALL);    if (err) {        printf("not ok - Failed on uc_mem_map() with error returned: %u/n", err);        return -1;    }    err = uc_mem_unmap(uc, 0x4000, 0x1000);    if (err) {        printf("not ok - Failed on uc_mem_unmap() with error returned: %u/n", err);        return -1;    }    err = uc_mem_unmap(uc, 0x4000, 0x1000);    if (!err) {        printf("not ok - second unmap succeeded/n");        return -1;    }    printf("Tests OK/n");    uc_close(uc);    return 0;}

static void test_sparc(void){    uc_engine *uc;    uc_err err;    uc_hook trace1, trace2;    int g1 = 0x1230;     // G1 register    int g2 = 0x6789;     // G2 register    int g3 = 0x5555;     // G3 register    printf("Emulate SPARC code/n");    // Initialize emulator in Sparc mode    err = uc_open(UC_ARCH_SPARC, UC_MODE_32, &uc);    if (err) {        printf("Failed on uc_open() with error returned: %u (%s)/n",                err, uc_strerror(err));        return;    }    // map 2MB memory for this emulation    uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);    // write machine code to be emulated to memory    uc_mem_write(uc, ADDRESS, SPARC_CODE, sizeof(SPARC_CODE) - 1);    // initialize machine registers    uc_reg_write(uc, UC_SPARC_REG_G1, &g1);    uc_reg_write(uc, UC_SPARC_REG_G2, &g2);    uc_reg_write(uc, UC_SPARC_REG_G3, &g3);    // tracing all basic blocks with customized callback    uc_hook_add(uc, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);    // tracing all instructions with customized callback    uc_hook_add(uc, &trace2, UC_HOOK_CODE, hook_code, NULL, (uint64_t)1, (uint64_t)0);    // emulate machine code in infinite time (last param = 0), or when    // finishing all the code.    err = uc_emu_start(uc, ADDRESS, ADDRESS + sizeof(SPARC_CODE) - 1, 0, 0);    if (err) {        printf("Failed on uc_emu_start() with error returned: %u (%s)/n",                err, uc_strerror(err));    }    // now print out some registers    printf(">>> Emulation done. Below is the CPU context/n");    uc_reg_read(uc, UC_SPARC_REG_G3, &g3);    printf(">>> G3 = 0x%x/n", g3);    uc_close(uc);}

//if a read is performed from a big address whith a non-zero last digit, multiple read events are triggeredstatic 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);    }}

int main(int argc, char **argv){    uc_engine *uc;    uc_hook trace;    uc_err err;    uint8_t memory[MEM_SIZE];    if (argc == 1) {        usage(argv[0]);        return -1;    }    const char *fname = argv[1];    err = uc_open (UC_ARCH_X86, UC_MODE_16, &uc);    if (err) {        fprintf(stderr, "Cannot initialize unicorn/n");        return 1;    }    // map 64KB in    if (uc_mem_map (uc, 0, MEM_SIZE, UC_PROT_ALL)) {        fprintf(stderr, "Failed to write emulation code to memory, quit!/n");        uc_close(uc);        return 0;    }    // initialize internal settings    int21_init();    //load executable    size_t fsize = load_com(uc, memory, fname);    // setup PSP    setup_psp(0, memory, argc, argv);    // write machine code to be emulated in, including the prefix PSP    uc_mem_write(uc, 0, memory, DOS_ADDR + fsize);    // handle interrupt ourself    uc_hook_add(uc, &trace, UC_HOOK_INTR, hook_intr, NULL);    err = uc_emu_start(uc, DOS_ADDR, DOS_ADDR + 0x10000, 0, 0);    if (err) {        fprintf(stderr, "Failed on uc_emu_start() with error returned %u: %s/n",                err, uc_strerror(err));    }    uc_close(uc);    return 0;}

/** * 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);}

// mapping the last pages will silently failstatic 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)));}

static void test_arm64(void){    uc_engine *uc;    uc_err err;    uc_hook trace1, trace2;    int64_t x11 = 0x1234;     // X11 register    int64_t x13 = 0x6789;     // X13 register    int64_t x15 = 0x3333;     // X15 register    printf("Emulate ARM64 code/n");    // Initialize emulator in ARM mode    err = uc_open(UC_ARCH_ARM64, UC_MODE_ARM, &uc);    if (err) {        printf("Failed on uc_open() with error returned: %u (%s)/n",                err, uc_strerror(err));        return;    }    // map 2MB memory for this emulation    uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);    // write machine code to be emulated to memory    uc_mem_write(uc, ADDRESS, ARM_CODE, sizeof(ARM_CODE) - 1);    // initialize machine registers    uc_reg_write(uc, UC_ARM64_REG_X11, &x11);    uc_reg_write(uc, UC_ARM64_REG_X13, &x13);    uc_reg_write(uc, UC_ARM64_REG_X15, &x15);    // tracing all basic blocks with customized callback    uc_hook_add(uc, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);    // tracing one instruction at ADDRESS with customized callback    uc_hook_add(uc, &trace2, UC_HOOK_CODE, hook_code, NULL, (uint64_t)ADDRESS, (uint64_t)ADDRESS);    // emulate machine code in infinite time (last param = 0), or when    // finishing all the code.    err = uc_emu_start(uc, ADDRESS, ADDRESS + sizeof(ARM_CODE) -1, 0, 0);    if (err) {        printf("Failed on uc_emu_start() with error returned: %u/n", err);    }    // now print out some registers    printf(">>> Emulation done. Below is the CPU context/n");    uc_reg_read(uc, UC_ARM64_REG_X11, &x11);    printf(">>> X11 = 0x%" PRIx64 "/n", x11);    uc_close(uc);}

static void test_x86_16(void){    uc_engine *uc;    uc_err err;    uint8_t tmp;    int32_t eax = 7;    int32_t ebx = 5;    int32_t esi = 6;    printf("Emulate x86 16-bit code/n");    // Initialize emulator in X86-16bit mode    err = uc_open(UC_ARCH_X86, UC_MODE_16, &uc);    if (err) {        printf("Failed on uc_open() with error returned: %u/n", err);        return;    }    // map 8KB memory for this emulation    uc_mem_map(uc, 0, 8 * 1024, UC_PROT_ALL);    // write machine code to be emulated to memory    if (uc_mem_write(uc, 0, X86_CODE16, sizeof(X86_CODE16) - 1)) {        printf("Failed to write emulation code to memory, quit!/n");        return;    }    // initialize machine registers    uc_reg_write(uc, UC_X86_REG_EAX, &eax);    uc_reg_write(uc, UC_X86_REG_EBX, &ebx);    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, 0, sizeof(X86_CODE16) - 1, 0, 0);    if (err) {        printf("Failed on uc_emu_start() with error returned %u: %s/n",                err, uc_strerror(err));    }    // now print out some registers    printf(">>> Emulation done. Below is the CPU context/n");    // read from memory    if (!uc_mem_read(uc, 11, &tmp, 1))        printf(">>> Read 1 bytes from [0x%x] = 0x%x/n", 11, tmp);    else        printf(">>> Failed to read 1 bytes from [0x%x]/n", 11);    uc_close(uc);}

static void test_basic_blocks(void **state){    uc_engine *uc = *state;    uc_hook trace1, trace2;#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, (uint64_t)1, (uint64_t)0));    OK(uc_hook_add(uc, &trace2, UC_HOOK_BLOCK, test_basic_blocks_hook2, &bbtest, (uint64_t)1, (uint64_t)0));    OK(uc_emu_start(uc, address, address+sizeof(code), 0, 0));}int main(void){    const struct CMUnitTest tests[] = {        cmocka_unit_test_setup_teardown(test_basic_blocks, setup32, teardown),    };    return cmocka_run_group_tests(tests, NULL, NULL);}

//if a read is performed from a big address whith a non-zero last digit, 0 will be readstatic 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_x86_64_syscall(void){    uc_engine *uc;    uc_hook trace1;    uc_err err;    int64_t rax = 0x100;    printf("===================================/n");    printf("Emulate x86_64 code with 'syscall' instruction/n");    // Initialize emulator in X86-64bit mode    err = uc_open(UC_ARCH_X86, UC_MODE_64, &uc);    if (err) {        printf("Failed on uc_open() with error returned: %u/n", err);        return;    }    // map 2MB memory for this emulation    uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);    // write machine code to be emulated to memory    if (uc_mem_write(uc, ADDRESS, X86_CODE64_SYSCALL, sizeof(X86_CODE64_SYSCALL) - 1)) {        printf("Failed to write emulation code to memory, quit!/n");        return;    }    // hook interrupts for syscall    uc_hook_add(uc, &trace1, UC_HOOK_INSN, hook_syscall, NULL, 1, 0, UC_X86_INS_SYSCALL);    // initialize machine registers    uc_reg_write(uc, UC_X86_REG_RAX, &rax);    // emulate machine code in infinite time (last param = 0), or when    // finishing all the code.    err = uc_emu_start(uc, ADDRESS, ADDRESS + sizeof(X86_CODE64_SYSCALL) - 1, 0, 0);    if (err) {        printf("Failed on uc_emu_start() with error returned %u: %s/n",                err, uc_strerror(err));    }    // now print out some registers    printf(">>> Emulation done. Below is the CPU context/n");    uc_reg_read(uc, UC_X86_REG_RAX, &rax);    printf(">>> RAX = 0x%" PRIx64 "/n", rax);    uc_close(uc);}

static void test_mips_el(void){    uc_engine *uc;    uc_err err;    uc_hook trace1, trace2;    int r1 = 0x6789;     // R1 register    printf("===========================/n");    printf("Emulate MIPS code (little-endian)/n");    // Initialize emulator in MIPS mode    err = uc_open(UC_ARCH_MIPS, UC_MODE_MIPS32, &uc);    if (err) {        printf("Failed on uc_open() with error returned: %u (%s)/n",                err, uc_strerror(err));        return;    }    // map 2MB memory for this emulation    uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);    // write machine code to be emulated to memory    uc_mem_write(uc, ADDRESS, MIPS_CODE_EL, sizeof(MIPS_CODE_EL) - 1);    // initialize machine registers    uc_reg_write(uc, UC_MIPS_REG_1, &r1);    // tracing all basic blocks with customized callback    uc_hook_add(uc, &trace1, UC_HOOK_BLOCK, hook_block, NULL, (uint64_t)1, (uint64_t)0);    // tracing one instruction at ADDRESS with customized callback    uc_hook_add(uc, &trace2, UC_HOOK_CODE, hook_code, NULL, (uint64_t)ADDRESS, (uint64_t)ADDRESS);    // emulate machine code in infinite time (last param = 0), or when    // finishing all the code.    err = uc_emu_start(uc, ADDRESS, ADDRESS + sizeof(MIPS_CODE_EL) - 1, 0, 0);    if (err) {        printf("Failed on uc_emu_start() with error returned: %u (%s)/n", err, uc_strerror(err));    }    // now print out some registers    printf(">>> Emulation done. Below is the CPU context/n");    uc_reg_read(uc, UC_MIPS_REG_1, &r1);    printf(">>> R1 = 0x%x/n", r1);    uc_close(uc);}

// emulate code that loop foreverstatic void test_i386_loop(void){    uc_engine *uc;    uc_err err;    int r_ecx = 0x1234;     // ECX register    int r_edx = 0x7890;     // EDX register    printf("===================================/n");    printf("Emulate i386 code that loop forever/n");    // Initialize emulator in X86-32bit mode    err = uc_open(UC_ARCH_X86, UC_MODE_32, &uc);    if (err) {        printf("Failed on uc_open() with error returned: %u/n", err);        return;    }    // map 2MB memory for this emulation    uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);    // write machine code to be emulated to memory    if (uc_mem_write(uc, ADDRESS, X86_CODE32_LOOP, sizeof(X86_CODE32_LOOP) - 1)) {        printf("Failed to write emulation code to memory, quit!/n");        return;    }    // initialize machine registers    uc_reg_write(uc, UC_X86_REG_ECX, &r_ecx);    uc_reg_write(uc, UC_X86_REG_EDX, &r_edx);    // emulate machine code in 2 seconds, so we can quit even    // if the code loops    err = uc_emu_start(uc, ADDRESS, ADDRESS + sizeof(X86_CODE32_LOOP) - 1, 2 * UC_SECOND_SCALE, 0);    if (err) {        printf("Failed on uc_emu_start() with error returned %u: %s/n",                err, uc_strerror(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);    printf(">>> ECX = 0x%x/n", r_ecx);    printf(">>> EDX = 0x%x/n", r_edx);    uc_close(uc);}

static void test_thumb(void){    uc_engine *uc;    uc_err err;    uc_hook trace1, trace2;    int sp = 0x1234;     // R0 register    printf("Emulate THUMB code/n");    // Initialize emulator in ARM mode    err = uc_open(UC_ARCH_ARM, UC_MODE_THUMB, &uc);    if (err) {        printf("Failed on uc_open() with error returned: %u (%s)/n",                err, uc_strerror(err));        return;    }    // map 2MB memory for this emulation    uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);    // write machine code to be emulated to memory    uc_mem_write(uc, ADDRESS, THUMB_CODE, sizeof(THUMB_CODE) - 1);    // initialize machine registers    uc_reg_write(uc, UC_ARM_REG_SP, &sp);    // tracing all basic blocks with customized callback    uc_hook_add(uc, &trace1, UC_HOOK_BLOCK, hook_block, NULL, 1, 0);    // tracing one instruction at ADDRESS with customized callback    uc_hook_add(uc, &trace2, UC_HOOK_CODE, hook_code, NULL, ADDRESS, ADDRESS);    // emulate machine code in infinite time (last param = 0), or when    // finishing all the code.    // Note we start at ADDRESS | 1 to indicate THUMB mode.    err = uc_emu_start(uc, ADDRESS | 1, ADDRESS + sizeof(THUMB_CODE) -1, 0, 0);    if (err) {        printf("Failed on uc_emu_start() with error returned: %u/n", err);    }    // now print out some registers    printf(">>> Emulation done. Below is the CPU context/n");    uc_reg_read(uc, UC_ARM_REG_SP, &sp);    printf(">>> SP = 0x%x/n", sp);    uc_close(uc);}

int main(int argc, char **argv, char **envp) {  uc_engine *uc;  if (uc_open(UC_ARCH_X86, UC_MODE_64, &uc)) {    printf("uc_open(…) failed/n");    return 1;  }  uc_mem_map(uc, STARTING_ADDRESS, MEMORY_SIZE, UC_PROT_ALL);  if (uc_mem_write(uc, STARTING_ADDRESS, BINARY, sizeof(BINARY) - 1)) {    printf("uc_mem_write(…) failed/n");    return 1;  }  printf("uc_emu_start(…)/n");  uc_emu_start(uc, STARTING_ADDRESS, STARTING_ADDRESS + sizeof(BINARY) - 1, 0, 20);  printf("done/n");  return 0;}

int main(int argc, char **argv, char **envp) {  uc_engine *uc;  if (uc_open(HARDWARE_ARCHITECTURE, HARDWARE_MODE, &uc)) {    printf("uc_open(…) failed/n");    return 1;  }  uc_mem_map(uc, MEMORY_STARTING_ADDRESS, MEMORY_SIZE, MEMORY_PERMISSIONS);  if (uc_mem_write(uc, MEMORY_STARTING_ADDRESS, BINARY_CODE, sizeof(BINARY_CODE) - 1)) {    printf("uc_mem_write(…) failed/n");    return 1;  }  printf("uc_emu_start(…)/n");  uc_emu_start(uc, MEMORY_STARTING_ADDRESS, MEMORY_STARTING_ADDRESS + sizeof(BINARY_CODE) - 1, 0, 20);  printf("done/n");  return 0;}

// callback for tracing memory access (READ or WRITE)static bool hook_mem_invalid(uc_engine *uc, uc_mem_type type,        uint64_t address, int size, int64_t value, void *user_data){    switch(type) {        default:            // return false to indicate we want to stop emulation            return false;        case UC_MEM_WRITE_UNMAPPED:                 printf(">>> Missing memory is being WRITE at 0x%"PRIx64 ", data size = %u, data value = 0x%"PRIx64 "/n",                         address, size, value);                 // map this memory in with 2MB in size                 uc_mem_map(uc, 0xaaaa0000, 2 * 1024*1024, UC_PROT_ALL);                 // return true to indicate we want to continue                 return true;    }}