Unicorn模拟CPU指令并Hook CPU执行状态的方法

import unicorn
import capstone
import binascii
CODE = b'\x0A\x46\x03\x46'  # 测试指令 IDA 中拉来的, mov 命令，未涉及到内存读写命令
def print_result(mu):
    """输出调试结果, 源码中，这些都是常量
    UC_ARM_REG_R0 = 66
    UC_ARM_REG_R1 = 67
    UC_ARM_REG_R2 = 68
    UC_ARM_REG_R3 = 69
    UC_ARM_REG_R4 = 70
    """
    msg = """
    寄存器输出 --------
    寄存器[R0], 值:{}
    寄存器[R1], 值:{}
    寄存器[R2], 值:{}
    寄存器[R3], 值:{}
    """.format(
        mu.reg_read(66),  # UC_ARM_REG_R0 源码对应常量 66
        mu.reg_read(67),
        mu.reg_read(68),
        mu.reg_read(69),
    )
    print(msg.strip().replace(' ', ''))
def capstone_print(code):
    """capstone 测试"""
    print("\033[1;32m-------- capstone 输出--------\033[0m")
    CP = capstone.Cs(capstone.CS_ARCH_ARM, capstone.CS_MODE_THUMB)  # 指定 THUMB 指令集
    for i in CP.disasm(code, 0, len(code)):  
        print('\033[1;32m地址: %s | 操作码: %s | 内容: %s\033[0m'%(i.address, i.mnemonic, i.op_str))
def uni_test():
    "将汇编片段，映射到 unicorn 虚拟内存中，将 pc 指向第一条指令处并执行"
    print('-------- unicorn 执行前--------')
    # 1. 创建实例
    mu = unicorn.Uc(unicorn.UC_ARCH_ARM, unicorn.UC_MODE_THUMB)  # 要指定架构和模式, 这里用 arm 架构， 指定 THUMB 指令集
    # 2. 将代码片段映射到模拟器的虚拟地址
    ADDRESS = 0x1000 # 映射开始地址
    SIZE = 1024  # 分配映射大小
    # 3. 开始映射
    mu.mem_map(ADDRESS, SIZE)  # 初始化映射 参数1：地址 参数2:空间大小  默认初始化后默认值：0
    mu.mem_write(ADDRESS, CODE)  # 写入指令 参数1: 写入位置 参数2:写入内容
    # 4. 测试读取 [测试]
    bytes=mu.mem_read(ADDRESS, 10)  # 参数1: 读出位置 参数2:读出字节数
    print('地址:%x, 内容:%s'%(ADDRESS, binascii.b2a_hex(bytes)))  # 读出来是 bates， 要用 binascii 转换一下
    # 写入寄存器
    # 5. 寄存器初始化 指令集涉及到 R0，R1，R2，R3 4个寄存器
    mu.reg_write(unicorn.arm_const.UC_ARM_REG_R0, 0x100)  # 在 r0 寄存器上写入 0x100
    mu.reg_write(unicorn.arm_const.UC_ARM_REG_R1, 0x200)  # 在 r1 寄存器上写入 0x200
    mu.reg_write(unicorn.arm_const.UC_ARM_REG_R2, 0x300)  # 在 r2 寄存器上写入 0x100
    mu.reg_write(unicorn.arm_const.UC_ARM_REG_R3, 0x400)  # 在 r3 寄存器上写入 0x200
    # 6. pc 指针指向地址开始执行
    follow_cpu(mu)  # 跟踪 CPU 进行 hook
    print_result(mu)  # 输出
    mu.emu_start(ADDRESS+1, ADDRESS+4)  # THUMB 指令集所以要 ADDRESS +1,    参数1:起始位置，参数2:结束位置
    print('-------- unicorn 执行后--------')
    print_result(mu)  # 输出
def follow_cpu(mu):
    """跟踪 cpu 执行状态进行 hook 堆栈显示"""
    mu.hook_add(unicorn.UC_HOOK_CODE, hook_code)  # 这里默认跟踪所有，具体也可以配置
def hook_code(mu, address, size, user_data):
    """定义回调函数， 在进入汇编指令之前就会先运行这里
    mu: 模拟器
    address: 执行地址
    size: 汇编指令大小
    user_data: 通过 hook_add 添加的参数
    """
    code=mu.mem_read(address,size)  # 读取
    print('\033[1;32m=== Hook cpu ===\033[0m')
    capstone_print(code)
    return
if __name__ == "__main__":
    capstone_print(CODE)
    uni_test()

def hook_mem_write_unmapped(mu, type, address, size, value, user_data):
    print('\033[1;32m=== Hook cpu ===\033[0m')
    if type==unicorn.UC_MEM_WRITE_UNMAPPED:
        mu.mem_map(0x0,0x1000)  # 主动映射进去 注意：映射的时候需要对齐！！和最开始设定的位置和大小！
        print("\033[1;32m[主动映射]地址: 0x%x ｜ hook_mem 类型: %d ｜ 大小:%d ｜ 值:0x%x\033[0m" % (address, type, size, value))
    return True  # 返回 True 继续执行，返回 False 则不执行后面的

def hook_syscall(mu,intno,user_data):
    print("\033[1;36mhook 系统调用 系统调用号: 0x%d"%intno)
    if intno==2:  # 例子 2 是退出
        print("系统调用退出!!")
    print_result(mu)
    print("\033[0m")
    return
def hook_block(mu, address, size, user_data):
    # code = mu.mem_read(address,size)
    print("\033[1;36mhook 基本块")
    print_result(mu)
    print("\033[0m")
    return