逆向利器Unicorn——一款很酷的指令模拟器

已于 2023-11-16 16:13:12 修改
阅读量1.2k 收藏 3
点赞数 8
分类专栏： 逆向技巧 文章标签： c++ python 汇编 安全
于 2023-11-16 15:56:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43767456/article/details/134437893
版权

文章目录

什么是Unicorn

Unicorn是一种基于QEMU的轻量级多架构CPU模拟器，可以模拟在不同的CPU架构上执行二进制代码。它提供了统一的接口，使得在不同的CPU架构上运行代码变得简单和高效。Unicorn的设计目标是提供一个轻量级、高效且可扩展的模拟器，以便在安全研究、调试和分析等领域中使用。

Unicorn的特点包括：

  • 轻量级：Unicorn模拟器在运行时占用的内存和CPU资源都非常少，可以轻松地嵌入到其他应用程序中。
  • 多架构：Unicorn支持多种不同的CPU架构，包括x86、ARM、MIPS等，可以轻松地模拟在不同的架构上执行二进制代码。
  • 高效：Unicorn使用动态翻译技术，将二进制代码翻译成模拟器可以执行的指令，从而提高了模拟器的执行效率。
  • 可扩展：Unicorn提供了丰富的API接口，可以方便地进行扩展和定制，以便满足不同的需求。
    使用Unicorn可以带来很多好处，比如可以在不同的CPU架构上测试和验证二进制代码的行为，可以模拟程序的执行过程并收集性能数据，可以进行安全漏洞的分析和验证等。同时，Unicorn的使用也非常灵活，可以将其集成到其他应用程序中，也可以使用其提供的API接口进行扩展和定制。
  • 跨平台性：Unicorn API可以在不同的操作系统上运行，包括Windows、Linux、Mac OS等。

Unicorn可以做什么

Unicorn是一个强大的指令模拟器，可以用于执行和分析各种不同的指令集。在下面的领域，Unicorn都可以一展身手：

  • 漏洞分析：Unicorn可以用于模拟目标程序的运行环境，帮助安全研究人员和分析师测试和验证漏洞。通过在Unicorn中加载目标程序，并模拟其执行过程，研究人员可以观察程序的行为和状态，以便发现潜在的安全问题。
    -调试和分析：Unicorn可以用于调试和分析应用程序的执行过程。通过在Unicorn中加载目标程序，并模拟其执行过程，开发人员可以逐步执行代码，观察变量的值和内存状态，以便调试程序中的错误和问题。
    -逆向工程：Unicorn可以用于逆向工程二进制文件。通过加载目标文件并模拟其执行过程，分析人员可以观察程序的指令集和行为，以便理解程序的功能和结构。这有助于分析人员识别潜在的恶意软件或破解程序。
    -性能分析：Unicorn可以用于分析和优化程序的性能。通过模拟程序的执行过程并收集性能数据，开发人员可以了解程序的瓶颈和优化机会，以便提高程序的性能和响应速度。
    软件开发和测试：Unicorn可以用于开发和测试嵌入式系统和硬件驱动程序。通过模拟硬件环境并加载测试程序，开发人员可以测试程序的功能和稳定性，以便验证硬件和软件之间的交互和行为。

安装Unicorn

Unicorn支持多种编程语言。如果你使用C/C++开发，那么你可以在官网下载动态链接库（dll）或者静态链接（lib）以及头文件，直接使用即可。当然，你也可以下载源码自行编译使用。Java或其他语言同理。如果你使用Python语言开发，那么你可以在安装了Python环境的情况下，使用pip按装Unicorn模块，命令如下：

pip install unicorn

常用API简介

创建和关闭实例

uc_open

uc_err uc_open(uc_arch arch, uc_mode mode, uc_engine **uc);

这个函数用于新建一个Unicorn engine实例。
@arch: 架构类型
@mode: 硬件模式
@uc: 创建的 uc_engine 实例
@return 成功则返回UC_ERR_OK , 否则返回 uc_err 枚举的其他错误类型

Unicorn支持的架构类型和硬件模式如下：

// Architecture type
typedef enum uc_arch {
    UC_ARCH_ARM = 1, // ARM architecture (including Thumb, Thumb-2)
    UC_ARCH_ARM64,   // ARM-64, also called AArch64
    UC_ARCH_MIPS,    // Mips architecture
    UC_ARCH_X86,     // X86 architecture (including x86 & x86-64)
    UC_ARCH_PPC,     // PowerPC architecture
    UC_ARCH_SPARC,   // Sparc architecture
    UC_ARCH_M68K,    // M68K architecture
    UC_ARCH_RISCV,   // RISCV architecture
    UC_ARCH_S390X,   // S390X architecture
    UC_ARCH_TRICORE, // TriCore architecture
    UC_ARCH_MAX,
} uc_arch;

// Mode type
typedef enum uc_mode {
    UC_MODE_LITTLE_ENDIAN = 0,    // little-endian mode (default mode)
    UC_MODE_BIG_ENDIAN = 1 << 30, // big-endian mode

    // arm / arm64
    UC_MODE_ARM = 0,        // ARM mode
    UC_MODE_THUMB = 1 << 4, // THUMB mode (including Thumb-2)
    // Depreciated, use UC_ARM_CPU_* with uc_ctl instead.
    UC_MODE_MCLASS = 1 << 5,  // ARM's Cortex-M series.
    UC_MODE_V8 = 1 << 6,      // ARMv8 A32 encodings for ARM
    UC_MODE_ARMBE8 = 1 << 10, // Big-endian data and Little-endian code.
                              // Legacy support for UC1 only.

    // arm (32bit) cpu types
    // Depreciated, use UC_ARM_CPU_* with uc_ctl instead.
    UC_MODE_ARM926 = 1 << 7,  // ARM926 CPU type
    UC_MODE_ARM946 = 1 << 8,  // ARM946 CPU type
    UC_MODE_ARM1176 = 1 << 9, // ARM1176 CPU type

    // mips
    UC_MODE_MICRO = 1 << 4,    // MicroMips mode (currently unsupported)
    UC_MODE_MIPS3 = 1 << 5,    // Mips III ISA (currently unsupported)
    UC_MODE_MIPS32R6 = 1 << 6, // Mips32r6 ISA (currently unsupported)
    UC_MODE_MIPS32 = 1 << 2,   // Mips32 ISA
    UC_MODE_MIPS64 = 1 << 3,   // Mips64 ISA

    // x86 / x64
    UC_MODE_16 = 1 << 1, // 16-bit mode
    UC_MODE_32 = 1 << 2, // 32-bit mode
    UC_MODE_64 = 1 << 3, // 64-bit mode

    // ppc
    UC_MODE_PPC32 = 1 << 2, // 32-bit mode
    UC_MODE_PPC64 = 1 << 3, // 64-bit mode (currently unsupported)
    UC_MODE_QPX =
        1 << 4, // Quad Processing eXtensions mode (currently unsupported)

    // sparc
    UC_MODE_SPARC32 = 1 << 2, // 32-bit mode
    UC_MODE_SPARC64 = 1 << 3, // 64-bit mode
    UC_MODE_V9 = 1 << 4,      // SparcV9 mode (currently unsupported)

    // riscv
    UC_MODE_RISCV32 = 1 << 2, // 32-bit mode
    UC_MODE_RISCV64 = 1 << 3, // 64-bit mode

    // m68k
} uc_mode;

uc_close

uc_err uc_close(uc_engine *uc);

这个函数用于关闭Unicorn引擎实例。
注意：只有uc实例不再使用时才能调用此函数。这个API释放了uc的一些缓存内存，因此在关闭uc之后，再使用任何其他的Unicorn API时可能使程序崩溃。在此之后，uc无效，并且不可用。

映射内存

uc_mem_map

uc_err uc_mem_map(uc_engine *uc, uint64_t address, size_t size, uint32_t perms);

使用Unicorn模拟执行代码，需要首先用uc_mem_map将要执行的代码映射到Unicorn虚拟内存中。
@uc: uc_open() 返回的句柄
@address: 要映射到的新内存区域的起始地址。此地址必须与4KB对齐，否则将返回UC_ERR_ARG错误
@size: 要映射到的新存储器区域的大小。此大小必须是4KB的倍数，否则将返回UC_ERR_ARG。
@perms: 新映射区域的权限。这必须是UC_PROT_READ|UC_PROT_WRITE|UC_PROT_EXEC的某种组合，否则将返回UC_ERR_ARG错误。
@return 成功则返回UC_ERR_OK , 否则返回 uc_err 枚举的其他错误类型

uc_mem_unmap

uc_err uc_mem_unmap(uc_engine *uc, uint64_t address, size_t size);

此函数用于删除对虚拟内存区域的映射。
@uc: uc_open() 返回的句柄
@address: 要删除映射的内存区域的起始地址。此地址必须对齐为4KB，否则将返回UC_ERR_ARG错误。
@size: 要修改的内存区域大小。这个大小必须是4KB的倍数，否则将返回UC_ERR_ARG错误。
@return 成功则返回UC_ERR_OK , 否则返回 uc_err 枚举的其他错误类型。

读写内存

uc_mem_read

uc_err uc_mem_read(uc_engine *uc, uint64_t address, void *bytes, size_t size);

读取内存中的一系列字节。
@uc：uc_open() 返回的句柄
@address：要获取的字节的起始内存地址。
@bytes：指向包含从内存复制的数据的变量的指针。
@size：要读取的内存大小。
注意：@bytes 必须足够大，以包含 @size 字节。
@return 成功时返回UC_ERR_OK，失败时返回其他值

uc_mem_write

uc_err uc_mem_write(uc_engine *uc, uint64_t address, void *bytes, size_t size);

写入内存中的一系列字节。

@uc：uc_open() 返回的句柄
@address：要设置的字节的起始内存地址。
@bytes：指向包含要写入内存的数据的变量的指针。
@size：要写入的内存大小。
注意：@bytes 必须足够大，以包含 @size 字节。
@return 成功时返回UC_ERR_OK，失败时返回其他值

读写寄存器

uc_reg_read

uc_err uc_reg_read(uc_engine *uc, int regid, void *value);

读取寄存器的值。
@uc：uc_open() 返回的句柄
@regid：要检索的寄存器ID。
@value：指向存储寄存器值的变量的指针。
@return 成功时返回UC_ERR_OK，失败时返回其他值

uc_reg_write

uc_err uc_reg_write(uc_engine *uc, int regid, const void *value);

写入寄存器。
@uc：uc_open() 返回的句柄
@regid：要修改的寄存器ID。
@value：指向将设置到寄存器 @regid 的值的指针。
@return 成功时返回UC_ERR_OK，失败时返回其他值

内存权限

uc_mem_protect

uc_err uc_mem_protect(uc_engine *uc, uint64_t address, size_t size, uint32_t perms);

为虚拟内存设置内存权限。此API更改现有内存区域的权限。
@uc：uc_open() 返回的句柄
@address：要修改的内存区域的起始地址。
该地址必须对齐到4KB，否则将返回UC_ERR_ARG错误。
@size：要修改的内存区域的大小。
此大小必须是4KB的倍数，否则将返回UC_ERR_ARG错误。
@perms：映射区域的新权限。
这必须是UC_PROT_READ | UC_PROT_WRITE | UC_PROT_EXEC的组合，否则将返回UC_ERR_ARG错误。
@return 成功时返回UC_ERR_OK，失败时返回其他值

添加hook

uc_hook_add

uc_err uc_hook_add(uc_engine *uc, uc_hook *hh, int type, void *callback,
                   void *user_data, uint64_t begin, uint64_t end, ...);

为hook事件注册回调。当hook事件发生时，将运行callback回调函数。
@uc：uc_open() 返回的句柄
@hh：从此次注册中获得的钩子句柄。用于uc_hook_del() API
@type：hook类型。
@callback：当指令命中时运行的回调
@user_data：用户定义的数据。将作为回调函数的最后一个参数传递给该数据
@begin：回调生效的区域起始地址（包括）
@end：回调生效的区域结束地址（包括）
注意1：仅当相关地址在此范围[@begin, @end]内时，才会调用回调函数
注意2：如果@begin > @end，每当此钩子类型被触发时都会调用回调函数
@…：可变参数（取决于@type）
注意：如果@type = UC_HOOK_INSN，这是指令ID。
目前，只支持x86的in、out、syscall、sysenter、cpuid。
注意：如果@type = UC_HOOK_TCG_OPCODE，参数是@opcode和@flags。
@return UC_ERR_OK表示成功，其他值表示失败。

Unicorn支持颗粒化的hook机制，为我们了解代码行为提供了便利。Unicorn的hook类型可以分为以下三种:

  • 指令执行类
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
UC_HOOK_MEM_PROT
UC_HOOK_MEM_FETCH_INVALID
UC_HOOK_MEM_INVALID
UC_HOOK_MEM_VALID
  • 异常处理类
UC_HOOK_MEM_READ_UNMAPPED
UC_HOOK_MEM_WRITE_UNMAPPED
UC_HOOK_MEM_FETCH_UNMAPPED

开机与关机

uc_emu_start

uc_err uc_emu_start(uc_engine *uc, uint64_t begin, uint64_t until,
                    uint64_t timeout, size_t count);

启动模拟器，开始执行代码。
@uc：由uc_open()返回的句柄
@begin：模拟开始所在的地址
@until：模拟停止的地址（即当此地址被命中时）
@timeout：模拟代码的时间（以微秒为单位）。当此值为0时，我们将无限期模拟代码，直到代码完成。
@count：要模拟的指令数量。当此值为0时，我们将模拟所有可用的代码，直到代码完成。
注意：只有当uc_emu_start返回无错误或错误已在回调中处理时，才能保证引擎的内部状态正确。
@return UC_ERR_OK表示成功，其他值表示失败

uc_emu_stop

uc_err uc_emu_stop(uc_engine *uc);

停止模拟（由uc_emu_start() API启动）。
@uc：由uc_open()返回的句柄
@return UC_ERR_OK表示成功，其他值表示失败

示例代码

这里给出使用Unicorn模拟执行arm指令的完整代码。想要了解更多架构的代码，可以前往官网查看。

/* Unicorn Emulator Engine */
/* By Nguyen Anh Quynh, 2015 */

/* Sample code to demonstrate how to emulate ARM code */

#include <unicorn/unicorn.h>
#include <string.h>

// code to be emulated
// #define ARM_CODE "\x37\x00\xa0\xe3" // mov r0, #0x37
#define ARM_CODE "\x00\xf0\x20\xe3" // nop
// #define ARM_CODE "\x37\x00\xa0\xe3\x03\x10\x42\xe0" // mov r0, #0x37; sub r1,
// r2, r3
#define THUMB_CODE "\x83\xb0" // sub    sp, #0xc

#define ARM_THUM_COND_CODE                                                     \
    "\x9a\x42\x14\xbf\x68\x22\x4d\x22" // 'cmp r2, r3\nit ne\nmov r2, #0x68\nmov
                                       // r2, #0x4d'

// code to be emulated
#define ARM_CODE_EB                                                            \
    "\xe3\xa0\x00\x37\xe0\x42\x10\x03" // mov r0, #0x37; sub r1, r2, r3
#define THUMB_CODE_EB "\xb0\x83"       // sub    sp, #0xc
// memory address where emulation starts
#define ADDRESS 0x10000

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

static void hook_code(uc_engine *uc, uint64_t address, uint32_t size,
                      void *user_data)
{
    printf(">>> Tracing instruction at 0x%" PRIx64
           ", instruction size = 0x%x\n",
           address, size);
}

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, 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_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);
}

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

static void test_armeb(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 Big-Endian code\n");

    // Initialize emulator in ARM mode
    err = uc_open(UC_ARCH_ARM, UC_MODE_ARM + UC_MODE_BIG_ENDIAN, &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_EB, sizeof(ARM_CODE_EB) - 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_EB) - 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_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);
}

static void test_thumbeb(void)
{
    uc_engine *uc;
    uc_err err;
    uc_hook trace1, trace2;

    int sp = 0x1234; // R0 register

    printf("Emulate THUMB Big-Endian code\n");

    // Initialize emulator in ARM mode
    err = uc_open(UC_ARCH_ARM, UC_MODE_THUMB + UC_MODE_BIG_ENDIAN, &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_EB, sizeof(THUMB_CODE_EB) - 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_EB) - 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);
}

static void test_thumb_mrs(void)
{
    uc_engine *uc;
    uc_err err;
    uc_hook trace1, trace2;

    int pc;

    printf("Emulate THUMB MRS instruction\n");
    // 0xf3ef8014 - mrs r0, control

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

    // Setup the cpu model.
    err = uc_ctl_set_cpu_model(uc, UC_CPU_ARM_CORTEX_M33);
    if (err) {
        printf("Failed on uc_ctl() 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, "\xef\xf3\x14\x80", 4);

    // 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 + 4, 0, 1);
    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_PC, &pc);
    printf(">>> PC = 0x%x\n", pc);
    if (pc != ADDRESS + 4) {
        printf("Error, PC was 0x%x, expected was 0x%x.\n", pc, ADDRESS + 4);
    }

    uc_close(uc);
}

static void test_thumb_ite_internal(bool step, uint32_t *r2_out,
                                    uint32_t *r3_out)
{
    uc_engine *uc;
    uc_err err;

    uint32_t sp = 0x1234;
    uint32_t r2 = 0, r3 = 1;

    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;
    }

    uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);

    uc_mem_write(uc, ADDRESS, ARM_THUM_COND_CODE,
                 sizeof(ARM_THUM_COND_CODE) - 1);

    uc_reg_write(uc, UC_ARM_REG_SP, &sp);

    uc_reg_write(uc, UC_ARM_REG_R2, &r2);
    uc_reg_write(uc, UC_ARM_REG_R3, &r3);

    if (!step) {
        err = uc_emu_start(uc, ADDRESS | 1,
                           ADDRESS + sizeof(ARM_THUM_COND_CODE) - 1, 0, 0);
        if (err) {
            printf("Failed on uc_emu_start() with error returned: %u\n", err);
        }
    } else {
        int i, addr = ADDRESS;
        for (i = 0; i < sizeof(ARM_THUM_COND_CODE) / 2; i++) {
            err = uc_emu_start(uc, addr | 1,
                               ADDRESS + sizeof(ARM_THUM_COND_CODE) - 1, 0, 1);
            if (err) {
                printf("Failed on uc_emu_start() with error returned: %u\n",
                       err);
            }
            uc_reg_read(uc, UC_ARM_REG_PC, &addr);
        }
    }

    uc_reg_read(uc, UC_ARM_REG_R2, &r2);
    uc_reg_read(uc, UC_ARM_REG_R3, &r3);

    uc_close(uc);

    *r2_out = r2;
    *r3_out = r3;
}

static void test_thumb_ite()
{
    uint32_t r2, r3;
    uint32_t step_r2, step_r3;

    printf("Emulate a THUMB ITE block as a whole or per instruction.\n");

    // Run once.
    printf("Running the entire binary.\n");
    test_thumb_ite_internal(false, &r2, &r3);
    printf(">>> R2: %d\n", r2);
    printf(">>> R3: %d\n\n", r3);

    // Step each instruction.
    printf("Running the binary one instruction at a time.\n");
    test_thumb_ite_internal(true, &step_r2, &step_r3);
    printf(">>> R2: %d\n", step_r2);
    printf(">>> R3: %d\n\n", step_r3);

    if (step_r2 != r2 || step_r3 != r3) {
        printf("Failed with ARM ITE blocks stepping!\n");
    }
}

static void test_read_sctlr()
{
    uc_engine *uc;
    uc_err err;
    uc_arm_cp_reg reg;

    printf("Read the SCTLR register.\n");

    err = uc_open(UC_ARCH_ARM, UC_MODE_ARM, &uc);
    if (err != UC_ERR_OK) {
        printf("Failed on uc_emu_start() with error returned: %u\n", err);
    }

    // SCTLR. See arm reference.
    reg.cp = 15;
    reg.is64 = 0;
    reg.sec = 0;
    reg.crn = 1;
    reg.crm = 0;
    reg.opc1 = 0;
    reg.opc2 = 0;

    err = uc_reg_read(uc, UC_ARM_REG_CP_REG, &reg);
    if (err != UC_ERR_OK) {
        printf("Failed on uc_reg_read() with error returned: %u\n", err);
    }

    printf(">>> SCTLR = 0x%" PRIx32 "\n", (uint32_t)reg.val);
    printf(">>> SCTLR.IE = %" PRId32 "\n", (uint32_t)((reg.val >> 31) & 1));
    printf(">>> SCTLR.B = %" PRId32 "\n", (uint32_t)((reg.val >> 7) & 1));

    uc_close(uc);
}

int main(int argc, char **argv, char **envp)
{
    test_arm();

    printf("==========================\n");
    test_thumb();

    printf("==========================\n");
    test_armeb();

    printf("==========================\n");
    test_thumbeb();

    printf("==========================\n");
    test_thumb_mrs();

    printf("==========================\n");
    test_thumb_ite();

    printf("==========================\n");
    test_read_sctlr();

    return 0;
}

总结

Unicorn不仅仅是一个模拟器，更是一种“硬件级”调试器，使用Unicorn的API可以轻松控制CPU寄存器、内存等资源，调试或调用目标二进制代码。而且，Unicorn相比于其他一些模拟器，它对性能的要求更高。
此外，Unicorn可以轻松的和其他工具进行集成，例如Frida。在某些情况下，我们可能需要在基本块级别或指令级别（即在插桩上有hooks）上具有更细的粒度。为了解决这个限制，常用的一个技巧是将hook与仿真结合起来。我们可以使用Frida来hook我们感兴趣的函数，然后我们可以转储CPU上下文和进程的内存状态，最终通过Unicorn这样的模拟器继续执行。
为了方便大家学习使用，我已经将unicorn的dll和lib文件上传附件，需要的朋友可以自行下载。

麦子zzy
关注
  • 8
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
逆向利器Unicorn-一款很酷的指令模拟器
11-16
Unicode 32位dll和lib
ARMStrong：一种基于Unicorn和Keystone引擎的用于教育的快速，简单的ARM模拟器
02-05
用于教育的快速，简单的ARM模拟器 安装 下载并享受它！ 图形用户界面 java -jar project-armstrong.jar 命令行界面 java -jar project-armstrong.jar cli 信息 要求 Java 11 Windows x86 / x64或Linux x64 使用的图书馆 独角兽 梯形失真 JavaFX DockFX 用 :red_heart: 由＃@ RMStrong团队提供
cpp-基于Unicorn和LibFuzzer的模拟执行fuzzing
08-16
基于Unicorn和LibFuzzer的模拟执行fuzzing
unicorn-hat-sim:在您的计算机上模拟pimoroni unicornhat（HD）
05-05
独角兽HAT（HD）模拟器 使用pygame模拟Unicorn HAT HD（也适用于8x8 HAT和8x4 PHAT）。 用法 如果您想让代码和Pi一起在计算机上运行，​​则可以执行以下操作： pip install unicorn-hat-sim （或pip2或pip3具体取决于您的设置） 如下调整您的import unicornhathd语句： try : import unicornhathd as unicorn print ( "unicorn hat hd detected" ) except ImportError : from unicorn_hat_sim import unicornhathd as unicorn 您可以选择import unicornhathd （16x16）， import unicornhat （8x8）和imp
unicorn10:UNICORN的前端
04-05
独角兽 :unicorn: 基于统一网络的竞赛组织，规则和新闻界面。 动机 在The Gathering，音乐，图形和演示的创作比赛一直都有传统。 2014年，我们开始研究一种竞赛系统，以支持The Gathering的创意竞赛及其需求。 总结起来，这是在处理参赛作品，进行排位赛/取消排位赛，并启用API来显示舞台，票数和结果上的条目。 多年来，通过参加比赛和成就比赛，这种情况有所增加。 我们从中学到了很多东西，并且犯了很多错误，该系统已成为大约4次重写的受害者。 “关于”是因为它取决于您的计算方式。 希望这是最后一次完整的重写，其中我们已将前端分为基于React的自己的服务。 入门 要自己运行UNICORN，您几乎只需分叉并克隆该项目（以及其他一些东西）。 此时，您将需要运行UNICORN后端和身份验证服务。 UNICORN后端将于今年晚些时候开源，但是现在您需要访问正在运行的实例。 环境变量 在
unicorn_pe:Unicorn PE是基于独角兽的检测项目，旨在模拟Windows PE文件的代码执行
05-14
独角兽PE Unicorn PE是基于的工具项目/框架，旨在模拟Windows PE文件（尤其是打包文件）的代码执行。 特征 将PE映像从emu内存中转储到文件中，修复导入表，解密VMProtect字符串，解密VMProtect导入。 对异常的部分支持。 （仅#DB和#BP） 对正在执行的所有指令显示disasm。 将BlackBone更新到最新版本（2020.4.5）。 去做 功能：x86（低优先级）-0％ 建造 Visual Studio 2017或2019 使用Visual Studio打开unicorn_pe.sln 将项目“ unicorn_pe”构建为x64 / Release或x64 / Debug。 （目前尚不支持x86） 用法 unicorn_pe（文件名或文件路径）[-k用于内核模式驱动程序仿真] [-disasm用于显示disasm] [-dump用于二进
UNICORN模拟ARM遇到的问题记录
groundhappy的专栏
05-24 2808
ARM指令为4字节THUMB指令为2字节THUMB2 指令可能是2字节，也可能是4字节 （通过PC的最低bit位来检测）问题1 在使用UNICORN模拟器 THUMB2 的时候，返回 UC_ERR_INSN_INVALID一定要检查当前设置PC值是不是正确因为在unicorn_arm.c中对于reg_write写入PC寄存器的时候case UC_ARM_REG_R15:              ...
使用 Unicorn Engine 模拟执行二进制代码片段
个人笔记
03-07 4364
http://eternal.red/2018/unicorn-engine-tutorial/
【Android安全】Unicorn工具
Juruo@Security
01-14 750
【Android安全】Unicorn工具
使用unicorn模拟执行去除混淆
wei_java144的博客
02-03 876
在分析某app的so时遇到了间接跳转类型的混淆，不去掉的话无法使用ida f5来静态分析，f5之后就长下面这样：本文记录一下使用python+unicorn模拟执行来去掉混淆的过程。
UnicornWrightFisher：渲染为Unicorn Hat HD的Wright Fisher模拟器
03-04
UnicornWrightFisher：渲染为Unicorn Hat HD的Wright Fisher模拟器
UnicornPascal：Unicorn模拟器的Pascal绑定
02-05
独角兽帕斯卡 用于（ ）的Pascal语言绑定。 Unicorn是基于的轻量级多平台，多体系结构的CPU仿真器框架。 执照 GPL 兼容性 操作系统：Windows，Linux 编译器：Delphi，Free Pascal 产品特点 与C核心相同的API 有一些针对uc_mem_write()不区分大小写的变通办法： uc_mem_write() -> uc_mem_write_() ， uc_mem_read() -> uc_mem_read_() 缺少的功能将可变数量的参数传递给函数（ ... ）： uc_hook_add() -> uc_hook_add_0() ， uc_ho
unicorn模拟执行学习
weixin_30668887的博客
08-03 1165
前言 unicorn 是一个模拟执行软件，用于模拟执行各种平台的二进制文件，前几天在 twitter 上看到一篇文章，这里做个记录。 正文 记录系统调用 首先是一个简单的示例 e8ffffffffc05d6a055b29dd83c54e89e96a02030c245b31d266ba12008b39c1e710c1ef1081e9feffffff8b4500c1e010c1e81089c309...
Unicorn的学习记录
Zarcs_233的博客
08-28 1212
Unicorn，是一个基于qemu的模拟引擎，当前应该有很多教程了，许多的框架都基于了Unicorn，但是学习之后发现，仅仅只是个模拟cpu的框架，在逆向分析中确实有许多的不便，于是在这里记录下学习过程中的问题与收获。 这里是基础的入门教程地址：https://bbs.pediy.com/thread-224315.htm，在这里不在细讲了。 Unicorn在CTF逆向中确实有不便之处，首先就是模拟的情况过于简单，对于linux，windows下的底层api都没办法模拟，还有异常机制也没有模拟，毕竟知识一个
unicorn源码分析与使用视频教程
08-08
本套视频教程主要讲的unicorn源码分析与使用视频教程，通过从虚拟机机原理到unicorn源码分析一步步带领大家深入的去学习unicorn，最常用的api都带领使用以及去调试源码，同时也讲了unicorn的框架定位以及对unicorn功能完善，比如实现pe elf macho文件加载，同时也讲了用unicorn去掉ollvm反混淆，也讲了在android中的使用场景。
unicorn模拟android,汇编与反汇编神器Unicorn
weixin_34481252的博客
06-04 1252
我们来先说说Unicorn有啥子卵用。Unicorn 是一款非常优秀的跨平台模拟执行框架，该框架可以跨平台执行Arm, Arm64 (Armv8), M68K, Mips, Sparc, & X86 (include X86_64)等指令集的原生程序。好了说得那么官方，我们举个例子好了，研究OLLVM的时候是不是很头疼函数的地址，使用Unicorn就可以打印函数注册地址，已经参数名称，用某...
Unicorn系列--基础知识
Tasfa的博客
05-12 1900
Unicorn是一个轻量的跨平台、多架构CPU模拟器框架
unicorn模拟执行Miniduke病毒自定义的SHA1算法
摔不死的笨鸟的博客
10-09 332
unicorn模拟执行二进制函数
C++ 使用matplot++ 处理数据生成svg图表
最新发布
小蝈蝈的博客
05-13 157
python的图表库很丰富，C++依赖于python的 matplotlib的库却有很多功能不足，显得很鸡肋，其他的一些库没有过多的研究，Matplot++编译需要依赖一堆第三方库，可以参考官网，但是github上也提供了编译好的静态库，使用Matplot++同时需要下载安装gnuplot，并将gnuplot的bin加入到环境变量。将include、lib加入到对应的位置，并配置好路径和库连接，这部分不多说了。这里主要说说不依赖于python的纯C++ 的图表库 Matplot++
unicorn模拟arm
05-26
Unicorn是一个基于QEMU的开源模拟器，它支持多种CPU架构，包括ARM、MIPS、PowerPC等。使用Unicorn模拟ARM可以在不同的平台上运行ARM代码，例如在x86平台上运行ARM代码。 Unicorn提供了一组API，可以使用C语言或Python等编程语言编写模拟器，实现指令的解析和模拟执行。同时，Unicorn还支持内存映射、断点、单步执行等调试功能，可以帮助开发人员进行调试和测试。 在使用Unicorn模拟ARM时，需要准备一个ARM二进制文件，然后使用Unicorn加载该二进制文件，并模拟执行其中的指令。开发人员可以通过编写代码来控制模拟器的行为，例如设置断点、读取和写入内存等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

麦子zzy

谢谢支持

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值