FreakStudio慷
环境安装
pip install keystone-engine capstone unicorn
这3个工具用法极其简单，下面通过示例来演示其用法。
Keystone
示例
from keystone import *
CODE = b"INC ECX; ADD EDX, ECX"
try:
ks = Ks(KS_ARCH_X86, KS_MODE_64)
encoding, count = ks.asm(CODE)
print(f"汇编指令数量: {count}")
print(f"机器码 (十进制): {encoding}")
print(f"机器码 (Hex): {''.join(f'{x:02x}' for x in encoding)}")
except KsError as e:
print(f"ERROR: {e}")
代码解释
代码流程十分简单：
初始化keystone->编译代码->输出结果
初始化keystone
ks = Ks(KS_ARCH_X86, KS_MODE_64)
初始化keystone引擎：
第一个参数：选择指令架构例如：x86，arm......
第二个参数：选择模式，例如：64位，32位，小端序......
编译代码
将汇编转换为16进制的shellcode
encoding, count = ks.asm(CODE)
第一个返回值：机器码指令的数组
第二个返回值：汇编指令数量
Capstone
capstone的用法和keystone差不多。
示例
from capstone import *
CODE = b"\xff\xc1\x01\xca"
md = Cs(CS_ARCH_X86, CS_MODE_64)
print("地址\t\t指令\t\t操作数")
print("-" * 30)
for i in md.disasm(CODE, 0x1000):
print(f"0x{i.address:x}:\t{i.mnemonic}\t{i.op_str}")
代码解释
代码流程跟keystone差不多：
初始化capstone->反编译代码->输出结果
初始化capstone
md = Cs(CS_ARCH_X86, CS_MODE_64)
初始化capstone引擎：
第一个参数：选择指令架构例如：x86，arm......
第二个参数：选择模式，例如：64位，32位，小端序......
反编译代码
for i in md.disasm(CODE, 0x1000):
print(f"0x{i.address:x}:\t{i.mnemonic}\t{i.op_str}")
使用方法disasm反汇编：
第一个参数：机器码
第二个参数：第一条指令的基地址
返回：一个包含指令对象的数组
unicorn
unicorn提供的方法使用也不复杂，但需要一定的内存基础知识。
下面用一个案例解释。
示例
情景模拟： 我逆向过程中发现一个xor加密代码，我需要通过模拟执行，对密文进行解密。
根据汇编代码可以得知：
0x20000存放密文
0x30000存放结果
0x10000中读取密钥key
from unicorn import *
from unicorn.x86_const import *
import struct
from keystone import *
ASM_CODE = """
MOV ECX, 5
MOV ESI, 0x20000
MOV EDI, 0x30000
MOV BL, byte ptr [0x10000]
loop_start:
LODSB
XOR AL, BL
STOSB
LOOP loop_start
"""
def get_code():
ks = Ks(KS_ARCH_X86, KS_MODE_32)
encoding, count = ks.asm(ASM_CODE)
return bytes(encoding)
CODE = get_code()
ADDRESS_CODE = 0x400000
ADDRESS_KEY = 0x10000
ADDRESS_IN = 0x20000
ADDRESS_OUT = 0x30000
REAL_KEY = 0x77
CIPHER_TEXT = b"\x3F\x12\x1B\x1B\x18"
def hook_code(uc, access, address, size, value, user_data):
if address == ADDRESS_KEY:
key_value = uc.mem_read(address, size)
print(f"key: {hex(key_value[0])}")
def start_emulation():
try:
print("初始化环境...")
mu = Uc(UC_ARCH_X86, UC_MODE_32)
mu.mem_map(0x0, 1 * 1024 * 1024)
mu.mem_map(ADDRESS_CODE, 2 * 1024 * 1024)
mu.mem_write(ADDRESS_CODE, CODE)
mu.mem_write(ADDRESS_IN, CIPHER_TEXT)
mu.mem_write(ADDRESS_KEY, struct.pack("B", REAL_KEY))
mu.hook_add(UC_HOOK_MEM_READ, hook_code)
mu.emu_start(ADDRESS_CODE, ADDRESS_CODE + len(CODE))
decrypted_text = mu.mem_read(ADDRESS_OUT, 5)
print(f"解密后的文本: {decrypted_text.decode()}")
except UcError as e:
print(f"模拟错误: {e}")
if __name__ == "__main__":
start_emulation()
代码解释
代码流程：
初始化环境->分配虚拟内存->写入数据->添加捕获操作->模拟执行指令->读取内存结果
初始化环境
这个跟上面的keystone和capstone一样，就不解释了
mu = Uc(UC_ARCH_X86, UC_MODE_32)
分配虚拟内存
第一行是用于存放堆内存数据，第二行是用于存放执行的代码
mu.mem_map(0x0, 1 * 1024 * 1024)
mu.mem_map(ADDRESS_CODE, 2 * 1024 * 1024)
mem_map用于初始化虚拟内存
第一个参数：内存的虚拟地址基址
第二个参数：内存的大小
内写入数据
第一行写入代码，第二行写入密文，第三行写入解密key
mu.mem_write(ADDRESS_CODE, CODE)
mu.mem_write(ADDRESS_IN, CIPHER_TEXT)
mu.mem_write(ADDRESS_KEY, struct.pack("B", REAL_KEY))
mem_write用于写入虚拟内存
第一个参数：写入内存的地址
第二个参数：写入内存的数据
添加捕获操作
hook用于捕获数据，这里用于捕获key
def hook_code(uc, access, address, size, value, user_data):
if address == ADDRESS_KEY:
key_value = uc.mem_read(address, size)
print(f"key: {hex(key_value[0])}")
mu.hook_add(UC_HOOK_MEM_READ, hook_code)
hook_add添加hook
第一个参数：捕获模式，规定什么时候触发hook，例如：读取内存，中断捕获......
第二个参数：触发的回调函数，回调函数各个参数如下：
def hook_code(uc, access, address, size, value, user_data):
uc：模拟器对象
access：当前访问类型：UC_MEM_READ，UC_MEM_WRITE......
address：当前访问的虚拟地址
size：当前访问数据大小
value：access为UC_MEM_WRITE，则这里为要写入的值
user_data：用户在add_hook时传进去的自定义数据
模拟执行指令
mu.emu_start(ADDRESS_CODE, ADDRESS_CODE + len(CODE))
第一个参数：模拟执行的起始地址
第二个参数：模拟执行的代码大小
读取内存结果
decrypted_text = mu.mem_read(ADDRESS_OUT, 5)
第一个参数：读取内存的地址
第二个参数：读取内存的大小课叭舱首