from d810.mba.dsl import Var, Const, DynamicConst
from d810.mba.rules._base import VerifiableRule

x = Var("x_0")                            # 模式变量：匹配任意子表达式
ONE = Const("1", 1)                       # 具体常量（名字, 值）
ZERO_VAL = DynamicConst("val_0", lambda ctx: 0)  # 替换常量（自动适配位宽）
_ALL_MATURITIES = [2, 3, 4, 5]            # 触发阶段：抢在 IDA 优化器前,表示ida优化的从汇编到伪代码的各个阶段

class MyPredOddConsecutive(VerifiableRule):
    maturities = _ALL_MATURITIES          # 不写则默认 [3,4,5]
    PATTERN = ((x - ONE) * x) & ONE       # ← 要匹配的表达式树（微码形态）
    REPLACEMENT = ZERO_VAL                # ← 替换成什么
    DESCRIPTION = "((x-1)*x)&1 -> 0"      # 界面里显示的名字
    REFERENCE = "main_bcf OLLVM BCF"      # 出处/参考

#!/usr/bin/env python3
"""
step0_minimal.py — Qiling 零基础最小示例（逐行注释）。

作用：把 tea/build/main_bcf 完整模拟跑起来，
     在"主程序自己的代码"上挂一个指令级 hook，打印前 20 条指令，
     然后让它跑完，看看 stdout 是什么。

用法：
    /home/f0x/anaconda3/envs/frida/bin/python step0_minimal.py

和 trace.py 的区别：这只是教学示例，trace.py 才是真正干活的。
"""
import io

from qiling import Qiling

# ========== 1. 构造模拟器 ==========
# Qiling(要执行的程序, rootfs目录, ...)
#   - rootfs: 模拟器里的"文件系统根目录"。程序要加载的
#     /lib/x86_64-linux-gnu/libstdc++.so.6 等动态库都从这里面读。
#   - multithread=True: 必须开！这个程序是 C++ 写的，libstdc++ 初始化
#     会调用 futex 系统调用，不开多线程支持会直接崩。
#   - verbose=0: 别打印一堆 qiling 自己的调试信息。
ql = Qiling(["../build/main_bcf"], "./ubuntu24_rootfs",
            multithread=True, verbose=0)

# ========== 2. 设置程序的 stdin / stdout ==========
# 程序用 read(0) 读输入、write(1) 写输出。
# 注意：必须挂在 ql.os.stdin / ql.os.stdout 上！
# 如果写成 ql.stdin = ...，qiling 的 Linux 系统调用层根本看不到，
# read(0) 会读到宿主进程自己的 stdin（脚本化运行时 = 立刻 EOF）。
# 这里喂一个 22 字节的错误 flag（长度对，但内容错 → 走 Wrong flag 分支）。
ql.os.stdin = io.BytesIO(b"flag{aaaaaaaaaaaaaa}")
out = io.BytesIO()
ql.os.stdout = out

# ========== 3. 找到"主程序自己的镜像"在内存里的范围 ==========
# 这个二进制是 PIE（地址随机化程序），qiling 把它加载在 0x555555554000。
# 动态库 ld-linux/libc/libstdc++ 加载在 0x7ffff7dd5000 等别的地方。
# 我们只关心主程序的指令（0x555555554000 ~ 0x555555563000），
# 不然 hook_code 会把 libc 里每条指令都回调，又慢又没意义。
main_img = None
for img in ql.loader.images:
    if "main_bcf" in img.path:
        main_img = img
        break
lo, hi = main_img.base, main_img.end
print(f"主镜像: {main_img.path}")
print(f"  加载地址 base = {hex(lo)}  结束 end = {hex(hi)}")

# ========== 4. hook_code: 每条指令执行前回调 ==========
# ql.hook_code(回调函数) → 每执行一条指令就调用一次回调(ql, address, size)。
# 我们只在地址落在主镜像范围内时打印，并限制条数。
count = 0
MAX = 20

def on_insn(ql, address, size):
    global count
    if lo <= address < hi and count < MAX:
        print(f"  执行到指令 @ {hex(address)}")
        count += 1

ql.hook_code(on_insn)#每次执行一条机器指令的时候执行里面的回调函数

# ========== 5. 开跑 ==========
print("\n开始模拟执行...")
ql.run()
print(f"\n退出码: {ql.os.exit_code}")
print(f"程序输出: {out.getvalue()!r}")
print(f"\n小结: 程序被完整模拟跑了 {count}+ 条主程序指令,")
print("      read(0) 读到了我们喂的输入, write(1) 输出了结果。")
print("      → 这就是'模拟执行'：CPU、系统调用、动态链接全部被 Qiling 模拟了。")

#!/usr/bin/env python3
"""
trace.py — 用 Qiling 跑 main_bcf, 记录"真正执行过的基本块"。

去混淆原理:
    OLLVM BCF 会在基本块之间插入不透明谓词 + 垃圾块 (bogus block)。
    不透明谓词在运行时恒真/恒假, 所以垃圾块永远不会被执行
    (或者只走其中一个分支)。
    因此: 动态执行轨迹里出现过的基本块 = 真实控制流;
          静态 CFG 里有、但从未执行的块 = BCF 垃圾块候选。

重要: 本脚本【不需要知道 flag】!
    垃圾块与输入内容无关——无论喂什么输入, 垃圾块都不会执行。
    默认喂 22 个 'A' (任意输入) 就能拿到真实路径的轨迹。
    多喂几组不同输入只是为了覆盖更多分支 (如 Wrong flag 分支),
    让后续 analyze 找垃圾块找得更全, 与 flag 是否正确无关。

用法:
    /home/f0x/anaconda3/envs/frida/bin/python trace.py [选项] [输入文件] [输出前缀, 默认 executed]
    不带参数 = 喂 22 个 'A' (任意输入), 输出 executed.txt
    带输入文件 = 喂该文件内容, 输出 <前缀>.txt
    -f/--force-correct = hook memcmp 强制相等, 覆盖 "Correct" 分支轨迹
                         (不需要知道 flag; 不知道 flag 也能覆盖所有分支)
    多次运行后合并: cat executed_a.txt executed_b.txt | sort -u > executed.txt

输出:
    <前缀>_blocks.json   {运行时地址: 执行次数}
    <前缀>_edges.json    [[from, to], ...]  执行过的控制流边
    <前缀>.txt           主程序镜像内执行过的块地址 (运行时地址, 已排序)
"""
import io
import json
import sys

from qiling import Qiling

# 任意 22 字节输入即可: 轨迹不依赖 flag 内容, 只依赖"程序走了哪条路径"
DEFAULT_PAYLOAD = b"A" * 22

# main 里 "call memcmp" 的 RVA (比较加密结果 vs 内置密文)
MEMCMP_CALL_OFF = 0x2c08


def main():
    import argparse
    ap = argparse.ArgumentParser(description="Qiling 基本块级轨迹 (不需要知道 flag)")
    ap.add_argument("input", nargs="?", default=None,
                    help="输入文件; 缺省 = 22 个 'A' (任意输入)")
    ap.add_argument("prefix", nargs="?", default="executed",
                    help="输出前缀, 默认 executed")
    ap.add_argument("-f", "--force-correct", action="store_true",
                    help="hook memcmp 强制相等 → 程序走 'Correct' 分支, "
                         "覆盖正确路径的轨迹 (不需要知道 flag)")
    a = ap.parse_args()

    payload = open(a.input, "rb").read() if a.input else DEFAULT_PAYLOAD
    prefix = a.prefix

    out = io.BytesIO()
    ql = Qiling(["../build/main_bcf"], "./ubuntu24_rootfs",
                multithread=True, verbose=0)
    ql.os.stdin = io.BytesIO(payload)
    ql.os.stdout = out

    # 主程序镜像的地址范围 (排除 libc / ld-linux 的噪音)
    main_img = None
    for img in ql.loader.images:
        if "main_bcf" in img.path:
            main_img = img
            break
    lo, hi = main_img.base, main_img.end
    print(f"main image: {main_img.path}  {hex(lo)} - {hex(hi)}")

    if a.force_correct:
        def force_memcmp_eq(ql):
            # "call memcmp" 还没执行, 寄存器里还是实参: rdi=算出的密文, rsi=内置密文。
            # 把 rdi 改成 rsi → memcmp(cipher, cipher) 必返回 0 → 走 Correct 分支。
            # 效果等价于"我知道 flag 且 flag 正确", 但这里根本不需要 flag 内容。
            ql.arch.regs.rdi = ql.arch.regs.rsi
        ql.hook_address(force_memcmp_eq, lo + MEMCMP_CALL_OFF)
        print("[force-correct] memcmp 已被强制相等, 将覆盖 Correct 分支")

    blocks = {}          # addr -> count
    edges = []           # (from, to)
    last = None

    def on_block(ql, address, size):
        nonlocal last
        if lo <= address < hi:
            blocks[address] = blocks.get(address, 0) + 1
            if last is not None and last != address:
                edges.append((last, address))
            last = address

    ql.hook_block(on_block)

    ql.run()
    print("exit code:", ql.os.exit_code)
    print("stdout:", out.getvalue())

    # 保存结果
    with open(f"{prefix}_blocks.json", "w") as f:
        json.dump({hex(k): v for k, v in sorted(blocks.items())}, f, indent=1)
    with open(f"{prefix}_edges.json", "w") as f:
        json.dump([[hex(a), hex(b)] for a, b in edges], f, indent=1)
    with open(f"{prefix}.txt", "w") as f:
        for a in sorted(blocks):
            f.write(f"{a:016x}\n")

    print(f"\nexecuted {len(blocks)} unique blocks in main image")
    print(f"results saved: {prefix}_blocks.json, {prefix}_edges.json, {prefix}.txt")


if __name__ == "__main__":
    main()

$PY trace.py                     # 单次运行 → 写入 executed.txt
$PY trace.py -f                  # 再次运行 → 覆盖 executed.txt
$PY trace.py wrong_input.txt wrong   # → wrong.txt
cat executed.txt wrong.txt | sort -u > executed_all.txt   # 合并 → 临时名
cp executed_all.txt executed.txt    # ① 关键: 覆盖回约定名
$PY analyze.py                  # ② 读到的就是合并后的 327 块

#!/usr/bin/env python3
"""
analyze.py — 静态 CFG vs 动态轨迹, 找出 BCF 垃圾块 (按函数分析)。

用法:
    /home/f0x/anaconda3/envs/frida/bin/python analyze.py [rva_of_function]

原理:
    1. 从 ELF 符号表拿函数边界 (main_bcf 未 strip, 有符号);
    2. 对每个"被动态执行过"的函数, 用递归下降反汇编重建静态基本块;
    3. 静态块 - 动态执行块 = 该函数内的 BCF 垃圾块候选。

注意:
    - 整个函数都没被执行过 (如 TEA::decrypt, main 没调用它) 会被单列为
      "dead function", 它们不是 BCF 垃圾, 只是这次输入没走到。
    - 想覆盖更多分支 (如 Wrong flag 分支), 用不同输入多跑几次 trace.py,
      然后把多个 executed.txt 合并后再分析 (见 merge 说明)。

输出:
    junk_rva.txt / junk_blocks.txt   垃圾块地址 (RVA / 运行时地址)
    real_blocks.txt                  真实执行过的块
"""
import json
import sys

from capstone import Cs, CS_ARCH_X86, CS_MODE_64
from elftools.elf.elffile import ELFFile

BINARY = "../build/main_bcf"
RUNTIME_BASE = 0x555555554000


def get_functions():
    """从符号表提取 {名称: (起始RVA,  )}。"""
    funcs = {}
    with open(BINARY, "rb") as f:
        elf = ELFFile(f)
        for sym in elf.get_section_by_name(".symtab").iter_symbols():
            if sym.entry.st_info.type == "STT_FUNC" and sym.entry.st_size > 0:
                name = sym.name or f"sub_{sym.entry.st_value:x}"
                funcs[name] = (sym.entry.st_value, sym.entry.st_value + sym.entry.st_size)
    return funcs


def load_text():
    with open(BINARY, "rb") as f:
        elf = ELFFile(f)
        sec = elf.get_section_by_name(".text")
        return sec.data(), sec["sh_addr"]


def static_blocks_in(func_start, func_end, code, text_vaddr):
    """
    递归下降反汇编 [func_start, func_end), 返回静态基本块入口集合。
    从函数入口开始, 沿 jcc 两条边 / jmp / 顺序流向下走, 遇到 ret 停。
    """
    md = Cs(CS_ARCH_X86, CS_MODE_64)
    md.detail = True

    def rva_to_off(rva):
        return rva - text_vaddr

    visited_insn = set()
    blocks = set()
    worklist = [func_start]

    while worklist:
        pc = worklist.pop()
        off = rva_to_off(pc)
        if not (0 <= off < len(code)) or pc >= func_end:
            continue
        # 一个基本块: 从 pc 顺序反汇编到第一个分支指令
        block_start = pc
        while True:
            if pc in visited_insn or pc >= func_end:
                break
            visited_insn.add(pc)
            o = rva_to_off(pc)
            insn = next(md.disasm(code[o:o + 15], pc), None)
            if insn is None:
                break
            pc += insn.size

            if insn.mnemonic in ("ret", "retq", "jmp", "jb", "jae", "je", "jne",
                                 "jg", "jge", "jl", "jle", "ja", "jbe", "js",
                                 "jns", "jo", "jno", "jz", "jnz", "jecxz", "loop"):
                # 无条件跳: 只有目标; 条件跳: 目标 + 顺序下一条
                if len(insn.operands) > 0 and insn.operands[0].type == 2:  # IMM
                    worklist.append(insn.operands[0].imm)
                if insn.mnemonic != "jmp":  # 条件跳/loop 的 fall-through
                    worklist.append(pc)
                break
            # call 视为顺序执行 (目标不展开, 那是另一个函数)
        blocks.add(block_start)

    return blocks


def block_extents_in(func_start, func_end, code, text_vaddr, blocks):
    """
    给一组块入口补上结束地址: 每个块的 [start, next_start) 或到函数末尾。
    返回 {start: end}。用于 patch.py 把垃圾块 NOP 掉。
    """
    starts = sorted(b for b in blocks if func_start <= b < func_end)
    ext = {}
    for i, s in enumerate(starts):
        e = starts[i + 1] if i + 1 < len(starts) else func_end
        ext[s] = e
    return ext


def main():
    funcs = get_functions()

    # 动态执行过的块
    executed = set()
    try:
        with open("executed.txt") as f:
            executed = {int(l.strip(), 16) for l in f if l.strip()}
    except FileNotFoundError:
        print("先运行 trace.py 生成 executed.txt")
        return

    code, text_vaddr = load_text()

    print(f"{'function':<36} {'static':>7} {'exec':>6} {'junk':>6}")
    all_junk = set()
    junk_extents = {}      # {start_rva: end_rva}
    dead_funcs = []
    for name, (s, e) in sorted(funcs.items(), key=lambda kv: kv[1][0]):
        func_exec = [a for a in executed if s + RUNTIME_BASE <= a < e + RUNTIME_BASE]
        if not func_exec:
            dead_funcs.append((name, s, e))
            continue
        sblocks = static_blocks_in(s, e, code, text_vaddr)
        sblocks_r = {a + RUNTIME_BASE for a in sblocks}
        junk = sblocks_r - executed
        all_junk |= junk
        extents = block_extents_in(s, e, code, text_vaddr, sblocks)
        for j in junk:
            junk_extents[j - RUNTIME_BASE] = extents[j - RUNTIME_BASE]
        print(f"{name:<36} {len(sblocks_r):>7} {len(func_exec):>6} {len(junk):>6}")

    print(f"\ndead functions (never entered this run):")
    for name, s, e in dead_funcs:
        print(f"  {name}  [{s:08x}, {e:08x})")

    with open("junk_rva.txt", "w") as f:
        for a in sorted(all_junk):
            f.write(f"{a - RUNTIME_BASE:08x}\n")
    with open("junk_blocks.txt", "w") as f:
        for a in sorted(all_junk):
            f.write(f"{a:016x}\n")
    with open("junk_extents.json", "w") as f:
        json.dump({f"{s:08x}": f"{e:08x}" for s, e in sorted(junk_extents.items())},
                  f, indent=1)
    print(f"\ntotal junk blocks: {len(all_junk)}  ->  junk_rva.txt / junk_blocks.txt / junk_extents.json")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
patch.py — 把 BCF 垃圾块 NOP 掉, 生成去混淆副本。

用法:
    /home/f0x/anaconda3/envs/frida/bin/python patch.py

前置: 先跑 trace.py (喂多个输入合并) + analyze.py 生成 junk_extents.json

安全依据:
    垃圾块 = 静态可达、动态从未执行。真实代码的不透明谓词分支永远
    不往垃圾块跳, 所以把它们整块替换成 0x90 (NOP) 不影响运行。
    补丁后会用 Qiling 重新跑一遍验证行为一致。

输出:
    ../build/main_bcf_patched   去混淆后的二进制副本 (NOP 填满垃圾块)
"""
import json
import os
import shutil

BINARY = "../build/main_bcf"
PATCHED = "../build/main_bcf_patched"
TEXT_VADDR = 0x10D0   # .text 的 vaddr == file offset (段对齐一致)

NOP = b"\x90"


def main():
    with open("junk_extents.json") as f:
        extents = {int(k, 16): int(v, 16) for k, v in json.load(f).items()}

    shutil.copy(BINARY, PATCHED)
    total = 0
    with open(PATCHED, "r+b") as f:
        for start, end in sorted(extents.items()):
            # RVA -> 文件偏移 (.text 段 vaddr==offset)
            off, size = start, end - start
            if size <= 0:
                continue
            f.seek(off)
            f.write(NOP * size)
            total += size

    print(f"patched {len(extents)} junk blocks, {total} bytes NOPed -> {PATCHED}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
sobf_decrypt_dump.py — 针对 sobf(字符串加密) 的模拟执行解密 dump。

原理:
    sobf 把 C 字符串加密存 .rodata, 运行时由 goron_decrypt_string_* 解密,
    把明文写入 .bss/.data 里的"解密后变量"。所以:
      静态看 .rodata = 密文 (strings 看不到明文)
      动态跑完后   .bss/.data = 明文
    用 Qiling 模拟执行, 跑完后扫描主镜像内存的 ASCII 串,
    就能拿到所有被 sobf 解密出来的原始字符串。

    (这个方案 "只 dump 不改 ELF", 比 hook 解密函数更简单可靠——不需要定位
    或解析解密函数, 明文解密后自然出现在可写段里。)

用法:
    /home/f0x/anaconda3/envs/frida/bin/python sobf_decrypt_dump.py <目标二进制> [输入文件]
"""
import importlib.util
import io
import re
import sys

from elftools.elf.elffile import ELFFile
from qiling import Qiling


def find_main_image(ql, name_hint):
    """在 ql.loader.images 里找主程序镜像。"""
    for img in ql.loader.images:
        if name_hint in img.path:
            return img
    return ql.loader.images[0]


def extract_ascii(data: bytes, min_len=4):
    """从内存字节里提取所有可打印 ASCII 字符串。"""
    return [m.decode() for m in re.findall(rb'[\x20-\x7e]{%d,}' % min_len, data)]


def main():
    if len(sys.argv) < 2:
        print("用法: python sobf_decrypt_dump.py <目标二进制> [输入文件]")
        return
    binary = sys.argv[1]
    payload = open(sys.argv[2], "rb").read() if len(sys.argv) > 2 else b"A" * 22

    ql = Qiling([binary], "/", multithread=True, verbose=0)
    ql.os.stdin = io.BytesIO(payload)
    ql.os.stdout = io.BytesIO()

    out_buf = bytearray()

    def on_write(ql):
        nonlocal out_buf
        fd, buf, count = ql.arch.regs.rdi, ql.arch.regs.rsi, ql.arch.regs.rdx
        if fd == 1:                       # stdout: C++ cout 输出, 解密后的字符串
            out_buf += bytes(ql.mem.read(buf, count))

    ql.os.set_syscall("write", on_write)
    ql.run()

    base = ql.loader.load_address

    # sobf 解密后明文写入 .data/.bss(可写段); .rodata 是密文(垃圾)。
    # 逐个读这些段的运行时内容, 提取 ASCII 串即可拿到解密明文。
    elf = ELFFile(open(binary, "rb"))
    plaintext = []
    for sec in elf.iter_sections():
        if sec.name not in (".data", ".bss") or not sec["sh_addr"]:
            continue
        try:
            seg_data = bytes(ql.mem.read(sec["sh_addr"] + base, sec["sh_size"]))
        except Exception:
            continue
        plaintext.extend(extract_ascii(seg_data, min_len=4))
    # C++ cout 的明文在 stdout(输出流), 不在 .bss 全局变量 -> 用 write hook 补上
    plaintext.extend(extract_ascii(bytes(out_buf), min_len=4))

    # 去噪: 去掉库/GNU/编译期符号
    noise = ("GCC", "GNU", "GLIBC", "GLIBCXX", "crtstuff", "_Z", "@GLIBC",
             "std::", "libc", "libstd", "libm", "libgcc", "/lib64", "ld-linux")
    seen, uniq = set(), []
    for s in plaintext:
        if not any(t in s for t in noise) and s not in seen:
            seen.add(s)
            uniq.append(s)

    print(f"主镜像: {binary}\n运行时: {hex(base)}\n")
    print("=== sobf 解密后, 拿到的明文字符串 ===")
    for s in uniq:
        print(f"  {s!r}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3只处理主镜像里的指令
# -*- coding: utf-8 -*-
"""
deobf_ibr_emul.py — 用 Qiling 模拟执行, 取出 -ibr (间接分支) 的真实跳转目标
================================================================================

【这是什么】
    OLLVM 的 -ibr pass 会把"条件分支"改成:
        查加密表 -> +密钥 V 解密 -> jmp rax
    这样指令里看不到目标地址, 静态分析(IDA)会在 jmp rax 处断头。

【为什么模拟执行能解】
    "藏"只对静态生效: 程序真正执行时, 目标地址一定会被算出来放进寄存器。
    所以只要:
        ① 用 Qiling 把二进制完整模拟跑起来;
        ② 在每条指令执行【前】hook 一次;
        ③ 遇到 jmp/call <寄存器> 时, 直接读那个寄存器的值;
    拿到的就是"程序自己算出的真实目标"——不需要找密钥 V、不需要解表,
    对每次编译随机密钥、甚至动态密钥(MySecret != 0) 都天然免疫。
    (顺带记录 'call reg' = -icall 间接调用的目标, 同一个套路。)

【用法】
    uniconre/venv/bin/python deobf_ibr_emul.py [选项]

    选项:
      -b, --binary      目标二进制 (默认 ../build/main_ibr)
      -i, --input       输入文件, 可重复传; 不传则自动跑默认输入组
      -f, --force-correct
                        hook 掉 memcmp 强制相等 -> 走 "Correct" 分支
                        (不需要知道 flag 就能覆盖正确路径)
      -m, --memcmp-off  memcmp 调用的 RVA (默认 0x13e5, 当前 main_ibr 的
                        间接调用点; 重新编译后需用 objdump 重新确认)
      -o, --out         输出文件名前缀 (默认 deobf_ibr_emul)

【输出】
    控制台 : 每个 (jmp/call reg) 站点 -> 执行到的目标 (均为 RVA)
    <out>_sites.json : {"站点RVA": ["目标RVA", ...], ...}

【依赖】
    Qiling 1.4.6 (uniconre/venv 内已装), capstone, readelf
"""

import io
import json
import os
import argparse

from capstone import Cs, CS_ARCH_X86, CS_MODE_64
from qiling import Qiling

# ======================================================================
# 1. 常量配置区 —— 路径与默认值
# ======================================================================

# 本脚本所在目录: 用它推导 rootfs / 二进制的相对位置, 不依赖当前工作目录
HERE = os.path.dirname(os.path.abspath(__file__))

# Qiling 的 Linux 文件系统根: 直接用 uniconre 里准备好的 ubuntu24_rootfs
ROOTFS = os.path.join(HERE, "ubuntu24_rootfs")

# 默认目标二进制: uniconre 的上一级目录 build/main_ibr
DEFAULT_BIN = os.path.abspath(os.path.join(HERE, "../build/main_ibr"))

# memcmp 被调用的位置 (RVA)。
# 当前 main_ibr 里 memcmp 被 -icall 改成 "call rax" 于 0x13e5;
# 若重新编译, 用 `objdump -d ... | grep -B1 memcmp` 重新找。
DEFAULT_MEMCMP_CALL_OFF = 0x13e5

# 我们关心的"间接跳转/调用"所允许的目标寄存器集合。
# op_str 精确等于这些名字, 才能排除:
#   直接跳转  jmp 0x1234        (op_str = "0x1234")
#   内存间接  jmp qword [rax]   (op_str = "[rax]")
#   条件跳转  jne 0x1234        (mnemonic 不是 jmp)
JMP_REGS = set("rax rbx rcx rdx rsi rdi r8 r9 r10 r11 r12 r13 r14 r15".split())

# x86-64 反汇编器句柄: 把内存里的字节翻译成指令 (mnemonic / op_str)。
# CS_MODE_64 = 64 位模式; 15 = x86-64 单条指令的最大长度。
md = Cs(CS_ARCH_X86, CS_MODE_64)
MAX_INSN_LEN = 15


# ======================================================================
# 2. 单次模拟运行 —— 核心探针
# ======================================================================

def run_once(ql, label, lo, hi, out):
    """
    用给定的 qiling 实例跑完整个程序, 记录本镜像内所有 jmp/call 寄存器的目标。

    参数:
      ql    : 已构造好的 Qiling 实例 (输入已设置)
      label : 本次运行的说明文字 (用于打印日志)
      lo,hi : 主镜像的地址范围 [base, end), 只在这范围内 hook, 过滤 libc 噪音
      out   : 跨多次运行共享的汇总字典 {站点RVA: [目标RVA, ...]}
    """
    sites = {}  # 本次运行内: {站点RVA: [目标RVA, ...]}

    def hook(ql, addr, size):
        """
        指令级探针: 每条指令【执行前】被调用一次 (Qiling/Unicorn 语义)。

        三步:
          ① 范围过滤:  (libc/libstdc++ 的每条指令
             也会触发回调, 不滤掉会慢一个数量级且结果全是噪音);
          ② 反汇编: 读当前 PC 处的字节, 用 capstone 解出这一条指令;
          ③ 识别 + 记录: 若是 "jmp/call <寄存器>", 执行前读该寄存器的值
             = 程序刚算出的真实目标 (ibr/icall 隐藏的东西), 记下 (站点->目标)。
        """
        # ---- ① 范围过滤 ----
        if not (lo <= addr < hi):
            return

        # ---- ② 反汇编 ----
        try:
            code = ql.mem.read(addr, MAX_INSN_LEN)  # 读模拟内存里的原始字节
        except Exception:
            return                                   # 读到未映射页尾等: 跳过
        ins = next(md.disasm(code, addr), None)      # 解出第一条指令
        if ins is None:
            return

        # ---- ③ 识别并记录 ----
        if ins.mnemonic in ("jmp", "call") and ins.op_str in JMP_REGS:
            tgt = getattr(ql.arch.regs, ins.op_str)  # 执行前寄存器 = 目标(绝对地址)
            site = addr - lo                         # 站点归一成 RVA
            tgt -= lo                                # 目标归一成 RVA (跨运行可比)
            sites.setdefault(site, []).append(tgt)

    # 挂上探针, 开跑
    ql.hook_code(hook)
    ql.run()

    # 本次结果去重后并入跨运行汇总表
    for s, ts in sites.items():
        out.setdefault(s, []).extend(t for t in set(ts))

    # 打印本次运行的简明摘要
    joined = ", ".join(
        f"0x{s:x}->0x{t:x}"
        for s in sorted(sites)
        for t in sorted(set(sites[s]))
    )
    print(f"  [{label}] 抓到的点: {joined}")


# ======================================================================
# 3. 主流程: 参数解析 -> 组合输入 -> 逐次模拟 -> 汇总输出
# ======================================================================

def main():
    ap = argparse.ArgumentParser(
        description="Qiling 模拟执行, 取出 -ibr 的真实跳转目标")
    ap.add_argument("-b", "--binary", default=DEFAULT_BIN,
                    help="目标二进制")
    ap.add_argument("-i", "--input", action="append", default=None,
                    help="输入文件(可重复); 不传则自动跑默认输入组")
    ap.add_argument("-f", "--force-correct", action="store_true",
                    help="hook memcmp 强制相等, 覆盖 Correct 分支")
    ap.add_argument("-m", "--memcmp-off",
                    type=lambda x: int(x, 0), default=DEFAULT_MEMCMP_CALL_OFF,
                    help="memcmp 调用点的 RVA")
    ap.add_argument("-o", "--out", default="deobf_ibr_emul",
                    help="输出文件名前缀")
    a = ap.parse_args()

    # ---- 输入组合: 决定这次能覆盖哪些分支路径 ----
    payloads = []
    if a.input:
        payloads = [(f"输入文件 {p}", open(p, "rb").read()) for p in a.input]
    else:
        # 长度错误 -> 走 if1 的 Wrong 分支
        payloads.append(("长度错误", b"x\n"))
        # 22 个 'A' -> 走 if1 继续 + for 循环 + if2 的 Wrong 分支
        payloads.append(("22个A", b"A" * 22 + b"\n"))
        if a.force_correct:
            # 同一输入 + memcmp 强制相等 -> 再覆盖 if2 的 Correct 分支
            payloads.append(("22个A+forceCorrect", b"A" * 22 + b"\n"))

    print(f"目标: {a.binary}")
    all_sites = {}  # 所有运行汇总: {站点RVA: [目标RVA, ...]}

    # ---- 逐组输入, 各起一个干净的 Qiling 实例 ----
    for label, payload in payloads:
        ql = Qiling([a.binary], ROOTFS,
                    multithread=True,   # C++ 二进制必需: libstdc++ 初始化用到 futex
                    verbose=0)
        ql.os.stdin = io.BytesIO(payload)   # 注入 stdin (直接 ql.stdin= 不会进 fd 表)
        ql.os.stdout = io.BytesIO()         # 捕获程序输出

        # 定位主镜像, 拿到 [base, end) 用于探针范围过滤
        img = next(i for i in ql.loader.images
                   if os.path.basename(i.path) == os.path.basename(a.binary))
        lo, hi = img.base, img.end

        # force-correct: 在 "call memcmp" 那条指令处, 把实参 rdi 改成 rsi
        # -> memcmp(自己, 自己) 必返回 0 -> 走 Correct 分支 (无需知道 flag)
        if a.force_correct and "forceCorrect" in label:
            def force_eq(ql):
                ql.arch.regs.rdi = ql.arch.regs.rsi
            ql.hook_address(force_eq, lo + a.memcmp_off)

        print(f"  镜像基址={hex(lo)} 范围={hex(lo)}-{hex(hi)} "
              f"(.text 起始 RVA ≈ 0x10e0)")
        run_once(ql, label, lo, hi, all_sites)
        print(f"    exit={ql.os.exit_code}  stdout={ql.os.stdout.getvalue()!r}")

    # ---- 汇总输出 ----
    print()
    print("=== 汇总: 所有站点 -> 目标 (RVA) ===")
    for s in sorted(all_sites):
        print(f"  0x{s:x} -> " + ", ".join(
            f"0x{t:x}" for t in sorted(set(all_sites[s]))))

    with open(f"{a.out}_sites.json", "w") as f:
        json.dump(
            {f"0x{k:x}": [f"0x{v:x}" for v in sorted(set(all_sites[k]))]
             for k in sorted(all_sites)},
            f, indent=1)
    print(f"已保存 {a.out}_sites.json")


if __name__ == "__main__":
    main()