汇编分析优化技能 (asm-analysis)

完整工作流

阶段 0   架构确认 + 白皮书加载
   ↓
阶段 T   工具协调（Linux 调试环境全量探测与任务分派）★ 核心强化
   ↓
阶段 O   混淆与加壳检测（UPX/OLLVM/VMProtect 识别与处置）
   ↓
阶段 1   算法特征识别（加密/哈希/压缩 宏观扫描）
   ↓
阶段 2   文件编译信息提取（编译器/优化级别/安全标志）
   ↓
阶段 D   数据结构恢复（vtable/struct 布局/类型重建）
   ↓
阶段 3   逐块分析（指令注释 + 伪代码生成）
   ↓
阶段 4   持续分析协议
   ↓
阶段 5   综合报告
   ↓
阶段 M   记忆机制（每 10 轮自动生成上下文快照 skill）★ 新增

跳过规则：

• 仅代码片段 → 跳过 T.1 环境探测，直接 T.3 生成命令
• 无可执行文件 → 跳过阶段 O（脱壳需运行）
• 无 OOP 特征 → 跳过阶段 D vtable 分析

---

阶段 0：启动协议

架构确认

请问要分析的代码属于哪种架构？
  [A] x86 / x86-64    [B] ARM64 / AArch64    [C] 其他

上下文有明显架构特征时可直接确认并等待认可。

白皮书加载（URL 索引见 references/whitepaper-urls.md）

• x86：Intel SDM Vol.2 → https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html
• ARM64：ARM DDI 0487 → https://developer.arm.com/documentation/ddi0487/latest

拒绝加载时必须输出（不可跳过）：

⚠️ 未加载权威指令手册：SIMD 指令语义误判风险高，内存序语义（rep movs/stlr/ldar）可能歧义，伪代码可能与实际行为偏差。继续，保留此风险提示。

---

阶段 T：Linux 动态调试协调（Tool Orchestration）★

详细命令手册见 references/tool-commands.md Linux 专项调试流程见 references/linux-debug-workflows.md Frida 脚本库见 references/frida-scripts.md angr 工作流见 references/angr-workflows.md

T.1 — Linux 调试环境全量探测

# ── 调试器 ──
for t in gdb lldb; do
  which $t 2>/dev/null && $t --version 2>&1 | head -1 || echo "$t: not found"
done

# GDB 插件检测
python3 -c "
import subprocess, os
for plugin in ['pwndbg','gef','peda']:
    r = subprocess.run(['gdb','-batch','-ex',f'python import {plugin}'],
        capture_output=True, text=True)
    print(plugin, 'ok' if r.returncode==0 else 'not found')
" 2>/dev/null

# ── 静态分析 ──
for t in r2 objdump readelf nm strings file rabin2; do
  which $t 2>/dev/null && echo "$t: ok" || echo "$t: not found"
done
r2 -q -c 'pdg 1 @ 0' /dev/null 2>/dev/null | grep -q ghidra && echo "r2ghidra: ok" || echo "r2ghidra: not found"

# ── Linux 动态追踪工具 ──
for t in strace ltrace perf valgrind bpftrace systemtap addr2line eu-stack; do
  which $t 2>/dev/null && $t --version 2>&1 | head -1 || echo "$t: not found"
done

# ── 符号执行 / 动态插桩 ──
python3 -c "import frida; print('frida:', frida.__version__)" 2>/dev/null || echo "frida: not found"
python3 -c "import angr;  print('angr:',  angr.__version__)"  2>/dev/null || echo "angr: not found"

# ── 系统环境 ──
uname -a
cat /proc/sys/kernel/yama/ptrace_scope 2>/dev/null && echo "(ptrace_scope)" || true
cat /proc/sys/kernel/randomize_va_space 2>/dev/null && echo "(ASLR)" || true
cat /proc/sys/kernel/perf_event_paranoid 2>/dev/null && echo "(perf_paranoid)" || true

# ── core dump 配置 ──
ulimit -c
cat /proc/sys/kernel/core_pattern 2>/dev/null || true

输出格式：

🔧 Linux 调试环境
  调试器  : GDB 13.2 [pwndbg] / LLDB 15.0
  静态    : r2 5.8.8 [r2ghidra] / objdump / readelf / rabin2
  追踪    : strace 6.1 / ltrace 0.7.3 / perf 6.1 / bpftrace 0.18
  插桩    : Frida 16.2.1 / angr 9.2.90
  Valgrind: 3.21.0
  内核    : 6.1.0-amd64 | ASLR=2 | ptrace_scope=1 | perf_paranoid=2
  core    : ulimit=-1 | pattern=/tmp/core.%e.%p

T.2 — 工具选择策略（Linux 优先级）

分析目标	首选	辅助
通用动态调试	GDB + pwndbg	r2（静态补充）
系统调用追踪	strace	ltrace（库函数）
内存错误检测	Valgrind (memcheck)	GDB watchpoint
函数调用追踪	ltrace / Frida	GDB breakpoints
性能热点	perf record + report	GDB profiling
内核态追踪	bpftrace / perf	systemtap
符号执行	angr	GDB + Python
纯静态 stripped	r2 aaa	angr CFGFast
多线程调试	GDB thread cmds	Helgrind (Valgrind)
core dump 分析	GDB + core	eu-stack
动态库 Hook	LD_PRELOAD / Frida	GDB catch load

ptrace_scope 限制处理：

# scope=1（默认）：只能调试子进程，无法附加任意进程
# 临时降低（需 root）：
echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope

# 永久（不推荐）：
# echo 'kernel.yama.ptrace_scope = 0' >> /etc/sysctl.d/10-ptrace.conf

# 非 root 替代方案：用 gdb -f ./target 直接启动

ASLR 控制：

# 关闭 ASLR（当前 shell 子进程）
setarch $(uname -m) -R gdb ./target

# 或 GDB 内
(gdb) set disable-randomization on   # GDB 默认已开启此项

T.3 — 任务驱动命令生成

每次生成命令前说明意图，命令后说明预期输出。

全工具命令速查表

任务	GDB	r2	strace/ltrace	Frida
加载并分析	gdb -q ./bin	r2 -A ./bin	strace ./bin	frida -f ./bin -l s.js
函数列表	info functions	afl	ltrace ./bin 2>&1 | grep -o "^[a-z_]*"	Module.enumerateExports()
反汇编函数	disas <fn>	pdf @ <fn>	—	—
断点（地址）	b *0x<addr>	db 0x<addr>	—	Interceptor.attach(ptr(...))
内存查看	x/16xb 0x<a>	px 16 @ 0x<a>	—	hexdump(ptr('0x<a>').readByteArray(16))
系统调用追踪	catch syscall <name>	—	strace -e trace=<name>	Stalker
库函数追踪	b <func>	axt @ <func>	ltrace -e <func>	Interceptor.attach
内存 dump	dump binary memory out.bin s e	wtf out.bin sz @ addr	—	Memory.readByteArray
搜索字节	find s,+len,bytes	/x <hex>	—	Memory.scan
动态库断点	b dlopen	—	ltrace -e dlopen	Module.load event
进程内存图	pwndbg vmmap	dm	/proc/<pid>/maps	Process.enumerateRanges
线程列表	info threads	—	strace -f	Process.enumerateThreads
调用栈	bt full	dbt	—	Thread.backtrace

pwndbg 优先命令（有插件时必用）

vmmap                      # 内存映射全览（彩色，清晰）
telescope $rsp 20          # 栈递归指针解引用（20 层）
telescope $rdi 8           # 查看参数指向的数据链
hexdump $rdi 64            # 彩色 hex dump
context                    # 完整上下文（寄存器+栈+反汇编一屏显示）
nearpc 20                  # 当前 PC 前后 20 条指令
got                        # GOT 表当前内容
plt                        # PLT 表
checksec                   # 安全标志汇总
rop --grep "pop rdi; ret"  # ROP gadget 搜索
heap                       # 堆 chunk 状态
bins                       # tcache/fastbin/unsorted 状态
vis_heap_chunks            # 可视化堆布局
threads                    # 线程列表 + 当前状态

strace 专项命令模板

# 基础系统调用追踪（含时间戳）
strace -tt -T ./target 2>&1 | tee /tmp/strace.log

# 只追踪文件相关系统调用
strace -e trace=file ./target

# 只追踪网络相关
strace -e trace=network ./target

# 追踪内存操作（mmap/mprotect/brk）
strace -e trace=memory ./target

# 追踪信号
strace -e trace=signal ./target

# 跟踪子进程（-f）+ 附加到 pid
strace -f -p <pid>

# 统计系统调用次数和耗时
strace -c ./target

# 输出到文件（每个进程/线程独立文件）
strace -ff -o /tmp/strace_out ./target
# 生成 /tmp/strace_out.<pid> 文件

# 在特定系统调用时注入失败（fault injection）
strace --inject=open:error=ENOENT ./target

# 解码结构体（-v 详细，-s 字符串长度）
strace -v -s 256 ./target

ltrace 专项命令模板

# 追踪所有库函数调用
ltrace ./target

# 只追踪特定函数
ltrace -e strcmp -e memcmp -e strncmp ./target

# 追踪加密相关函数
ltrace -e EVP_* -e AES_* -e RSA_* -e MD5_* ./target

# 附加到运行中进程
ltrace -p <pid>

# 含时间戳 + 详细输出
ltrace -tt -T -n 2 ./target

# 跟踪子进程
ltrace -f ./target

# 统计调用次数
ltrace -c ./target

# 显示库函数的完整参数（含结构体）
ltrace -b -S ./target    # -b: 抑制信号，-S: 显示系统调用

perf 专项命令模板

# 记录函数调用图（频率采样）
perf record -g -F 999 ./target
perf report --stdio

# 追踪特定事件（cache miss / branch miss）
perf stat -e cache-references,cache-misses,branches,branch-misses ./target

# 追踪系统调用（perf trace = strace 加强版）
perf trace ./target
perf trace -e 'syscalls:sys_enter_*' ./target

# 动态探针（无需修改源码，类似 kprobe）
# 在函数入口处插入探针
perf probe -x ./target --add 'target_func'
perf record -e probe_target:target_func -g ./target
perf script

# 火焰图生成
perf record -F 99 -g -- ./target
perf script | stackcollapse-perf.pl | flamegraph.pl > flame.svg

# 内核函数追踪
sudo perf record -e 'syscalls:sys_enter_read' -ag sleep 5

bpftrace 专项命令（内核级追踪）

# 追踪某进程所有系统调用
sudo bpftrace -e '
  tracepoint:syscalls:sys_enter_* /pid == <PID>/ {
    printf("%s\n", probe);
  }
'

# 追踪 malloc/free（用户空间探针）
sudo bpftrace -e '
  uprobe:/lib/x86_64-linux-gnu/libc.so.6:malloc {
    printf("malloc(%d) pid=%d\n", arg0, pid);
  }
  uprobe:/lib/x86_64-linux-gnu/libc.so.6:free {
    printf("free(%p) pid=%d\n", arg0, pid);
  }
'

# 追踪特定函数的参数（字符串类型）
sudo bpftrace -e '
  uprobe:./target:strcmp {
    printf("strcmp(%s, %s)\n", str(arg0), str(arg1));
  }
'

# 统计系统调用频率（10 秒）
sudo bpftrace -e '
  tracepoint:syscalls:sys_enter_* { @[probe] = count(); }
  interval:s:10 { print(@); clear(@); }
'

# 追踪 mprotect（检测动态解码/脱壳）
sudo bpftrace -e '
  tracepoint:syscalls:sys_enter_mprotect /pid == <PID>/ {
    printf("mprotect addr=%lx len=%lu prot=%d\n", args->addr, args->len, args->prot);
  }
'

Valgrind 专项

# 内存错误检测（最常用）
valgrind --tool=memcheck --leak-check=full --track-origins=yes \
  --show-reachable=yes ./target 2>&1 | tee /tmp/valgrind.log

# 只报告明确泄漏（减少噪音）
valgrind --leak-check=full --show-leak-kinds=definite ./target

# 调用图分析（callgrind）
valgrind --tool=callgrind ./target
callgrind_annotate callgrind.out.<pid>

# 堆分析（massif）
valgrind --tool=massif --pages-as-heap=yes ./target
ms_print massif.out.<pid>

# 多线程竞态检测（helgrind）
valgrind --tool=helgrind ./target

/proc 文件系统集成

# 实时内存映射（比 vmmap 更原始，无需 debugger）
cat /proc/<pid>/maps

# 直接读取进程内存（需 root 或 ptrace 权限）
dd if=/proc/<pid>/mem bs=1 skip=$((0x401000)) count=256 2>/dev/null | xxd

# 文件描述符
ls -la /proc/<pid>/fd

# 命令行参数 + 环境变量
cat /proc/<pid>/cmdline | tr '\0' ' '
cat /proc/<pid>/environ | tr '\0' '\n'

# 信号状态（哪些信号被屏蔽/挂起）
cat /proc/<pid>/status | grep -E "Sig|Threads|VmRSS"

# 打开的文件 + 网络连接
cat /proc/<pid>/net/tcp
cat /proc/<pid>/net/tcp6

core dump 分析工作流

# 1. 开启 core dump（当前 shell）
ulimit -c unlimited
echo '/tmp/core.%e.%p' | sudo tee /proc/sys/kernel/core_pattern

# 2. 运行触发崩溃的程序（或复现已知崩溃）
./target <crashing_input>  # 生成 /tmp/core.target.<pid>

# 3. GDB 加载 core
gdb ./target /tmp/core.target.<pid>
(gdb) bt full              # 查看崩溃时的完整调用栈
(gdb) info registers       # 崩溃时寄存器状态
(gdb) x/32xb $rsp          # 崩溃时栈内容
(gdb) info frame           # 当前帧信息
(gdb) x/i $rip             # 崩溃指令

# 4. eu-stack（elfutils，更快的调用栈）
eu-stack -p <pid>         # 在线 backtrace
eu-stack -c core.<pid>    # 从 core 分析

# 5. 自动化 core 分析脚本
gdb -batch -ex "bt full" -ex "info registers" -ex "x/32xb \$rsp" \
    -ex quit ./target /tmp/core.target.<pid> 2>/dev/null

LD_PRELOAD 动态库注入

# 创建 hook 库：拦截 strcmp（密码验证绕过示例）
cat > /tmp/hook_strcmp.c << 'EOF'
#define _GNU_SOURCE
#include <dlfcn.h>
#include <stdio.h>
#include <string.h>

int strcmp(const char *s1, const char *s2) {
    typedef int (*orig_strcmp_t)(const char*, const char*);
    orig_strcmp_t orig = dlsym(RTLD_NEXT, "strcmp");
    int ret = orig(s1, s2);
    fprintf(stderr, "[strcmp] \"%s\" vs \"%s\" → %d\n", s1, s2, ret);
    return ret;
}
EOF
gcc -shared -fPIC -o /tmp/hook_strcmp.so /tmp/hook_strcmp.c -ldl

# 注入并运行
LD_PRELOAD=/tmp/hook_strcmp.so ./target <args>

# 追踪 malloc/free
cat > /tmp/hook_alloc.c << 'EOF'
#define _GNU_SOURCE
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
void* malloc(size_t sz) {
    typedef void* (*fn_t)(size_t);
    fn_t orig = dlsym(RTLD_NEXT, "malloc");
    void* ret = orig(sz);
    fprintf(stderr, "[malloc] size=%zu → %p\n", sz, ret);
    return ret;
}
void free(void* p) {
    fprintf(stderr, "[free] %p\n", p);
    typedef void (*fn_t)(void*);
    fn_t orig = dlsym(RTLD_NEXT, "free");
    orig(p);
}
EOF
gcc -shared -fPIC -o /tmp/hook_alloc.so /tmp/hook_alloc.c -ldl
LD_PRELOAD=/tmp/hook_alloc.so ./target

GDB Python 自动化脚本

# gdb_auto_trace.py — source 到 GDB 中
# 追踪所有已知函数，记录调用顺序和参数
import gdb, json

call_log = []
bp_map   = {}

class TraceBreakpoint(gdb.Breakpoint):
    def __init__(self, name, addr=None):
        if addr:
            super().__init__(f"*{hex(addr)}", internal=True)
        else:
            super().__init__(name, internal=True)
        self.func_name = name
        self.silent = True

    def stop(self):
        frame  = gdb.selected_frame()
        rdi = int(gdb.parse_and_eval("$rdi")) if gdb.parse_and_eval else 0
        rsi = int(gdb.parse_and_eval("$rsi")) if gdb.parse_and_eval else 0
        entry = {"fn": self.func_name, "rdi": hex(rdi), "rsi": hex(rsi)}
        call_log.append(entry)
        # 每 50 次调用打印一次摘要
        if len(call_log) % 50 == 0:
            print(f"[trace] {len(call_log)} calls logged so far")
        return False  # 不暂停

def install_traces():
    gdb.execute("set pagination off")
    # 对所有已知符号设置追踪断点
    raw = gdb.execute("info functions", to_string=True)
    for line in raw.split('\n'):
        if '0x' in line:
            parts = line.strip().split()
            if len(parts) >= 2:
                try:
                    addr = int(parts[0], 16)
                    name = parts[-1].rstrip(';')
                    bp = TraceBreakpoint(name, addr)
                    bp_map[addr] = bp
                except:
                    pass
    print(f"[trace] Installed {len(bp_map)} trace breakpoints")

def save_log():
    with open('/tmp/gdb_call_trace.json', 'w') as f:
        json.dump(call_log, f, indent=2)
    print(f"[trace] Saved {len(call_log)} calls to /tmp/gdb_call_trace.json")

# 注册退出时保存
class ExitBreak(gdb.Breakpoint):
    def __init__(self):
        super().__init__("exit", internal=True)
        self.silent = True
    def stop(self):
        save_log()
        return False

install_traces()
ExitBreak()
gdb.execute("run")

T.4 — 输出解析与分析路由

工具输出类型路由：
 strace 日志      → 提取 open/read/write/mmap 系统调用序列
                   → 识别密钥文件读取 / 配置文件路径 / 网络连接
 ltrace 日志      → 提取库函数调用序列
                   → 识别 strcmp/memcmp（密码验证）/ EVP/AES（加密）
 perf report      → 找出热点函数（占用 CPU >5% 的函数是分析重点）
 bpftrace 输出    → 低噪音内核级事件，定位 mprotect/mmap 异常行为
 Valgrind 报告    → 内存错误定位（无效读写/泄漏 → 标注到对应代码位置）
 core dump 分析   → 崩溃点寄存器状态 → 结合反汇编定位根因
 GDB 断点输出     → 寄存器快照 → 标注指令执行上下文
 Frida 追踪日志   → 函数参数/返回值 → 辅助算法识别

动态上下文标注格式（统一）：

[strace @ open] open("/etc/passwd", O_RDONLY) = 3
    分析     : 程序读取 /etc/passwd，疑似权限检查或用户验证
    关联指令 : 0x401234 call open@PLT → 返回 fd=3
    下一步   : ltrace 追踪后续的 read/strcmp，确认验证逻辑

[GDB @ 0x401260] mov rax, [rbp-0x8]
    寄存器   : rbp=0x7ffd1230, [rbp-0x8]=0x5 (十进制)
    类型推断 : 局部 int，值=5，疑似循环计数器
    下一步   : ni → 观察后续 cmp 指令

[ltrace] strcmp("admin", "root") = -1
    分析    : 硬编码字符串比较，疑似身份验证
    建议    : LD_PRELOAD hook 此 strcmp，伪造返回 0

T.5 — Linux 调试错误诊断与自动修正

错误	原因	处理方案
ptrace: Operation not permitted	ptrace_scope=1	echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope 或用 -f 启动
(no debugging symbols found)	stripped	r2 aaa，GDB b *0x<addr>，angr CFGFast
Cannot access memory at 0x<addr>	PIE + ASLR	pwndbg vmmap 获取基址后重算，或 set disable-randomization on
strace EPERM	权限不足	sudo strace 或 sudo setcap cap_sys_ptrace+ep /usr/bin/strace
perf Permission denied	perf_paranoid>0	echo -1 | sudo tee /proc/sys/kernel/perf_event_paranoid
Valgrind command not found	未安装	sudo apt install valgrind，ARM64 改用 asan
core file may not match	二进制不匹配	确认 core 对应的二进制路径，用 file core.<pid> 检查
bpftrace ERROR: No BTF	内核版本旧	降级用 perf trace 替代，或升级内核
r2 分析超时	大文件	e anal.timeout=30，改用 aa 或 af @ <addr> 单函数
angr 路径爆炸	循环太多	LoopSeer(bound=5) 或手动 avoid 地址

反调试自动 patch（Linux 专项）：

catch syscall ptrace
commands
  set $rax = 0
  continue
end
handle SIGTRAP nostop noprint pass

# /proc/self/status TracerPid 绕过（patch 读取结果）
b fgets
commands
  silent
  set $rax = 0   # 伪造读取失败
  return 0
end

T.6 — 工具会话状态追踪

🔧 工具会话状态
  主调试器  : GDB 13.2 + pwndbg
  辅助追踪  : strace / ltrace / Frida
  目标文件  : ./target (x86-64 ELF, stripped, PIE, ASLR on)
  基址偏移  : 0x555555554000（本次运行）
  断点列表  : [0x401234 ×GDB, sym.rc4_init ×Frida]
  追踪日志  : strace.log(已收集 312 次系统调用) ltrace.log(已收集 47 次库调用)
  待执行    : [valgrind memcheck, perf record, bpftrace mprotect监控]
  异常标记  : [0x4018cc RDTSC反调试, open("/proc/self/status") 反调试读取]
  对话轮次  : 第 7 轮（距下次快照还有 3 轮）

---

阶段 O：混淆与加壳检测

详细特征库见 references/obfuscation-patterns.md

快速检测

python3 -c "
import math, collections, sys
data = open(sys.argv[1],'rb').read()
freq = collections.Counter(data)
h = -sum((c/len(data))*math.log2(c/len(data)) for c in freq.values())
print(f'entropy={h:.4f}', '⚠️ packed' if h > 7.0 else '✅ normal')
" ./target

strings ./target | grep -iE "upx|vmprotect|themida|ollvm"
r2 -q -c 'iS~entropy' ./target 2>/dev/null

特征	工具	处置
UPX! 魔数	strings	upx -d
高熵代码段 + 小 stub	GDB + mprotect 断点	动态 dump OEP
OLLVM 平坦化：CFG 菊花状	r2 VV	angr Veritesting
VMProtect .vmp0/.vmp1	r2 段分析	Frida 追踪 VM loop
字符串加密 decode stub	ltrace / Frida	Hook decode 函数出口

---

阶段 1：算法特征识别

详细特征库见 references/algorithm-patterns.md

类别	算法	关键特征
流密码	RC4	256B S 盒、KSA 双指针、PRGA XOR
流密码	ChaCha20	魔数 0x61707865、旋转 16/12/8/7
分组加密	AES	S-box 0x63... 或 aesenc 指令
哈希	MD5	常数 0xd76aa478、4×16 步
哈希	SHA-256	0x428a2f98、sha256rnds2
哈希	CRC32	0xEDB88320 或 crc32 指令
编码	Base64	64 字符查表
混淆	XOR	固定密钥循环 + 可打印输出
反调试	RDTSC	0F 31 双调用时间差

📌 发现特征后立即标注 [疑似 XXX 算法] + 置信度 + 依据 + 自动生成验证命令。

---

阶段 2：文件编译信息提取

详细编译器模式见 references/compiler-patterns.md

file ./target && readelf -h ./target 2>/dev/null
strings ./target | grep -E "(GCC|clang|MSVC): [0-9]"
rabin2 -I ./target 2>/dev/null

提取：文件格式 / 架构 / 编译器版本 / 优化级别 / 安全标志（PIE/NX/canary/RELRO/CFI）

📌 编译器确定后 web_search 该版本已知优化序列，增强伪代码可靠性。

---

阶段 D：数据结构恢复

详细方法见 references/struct-recovery.md

vtable 识别

r2 -A -q -c 'avj' ./target 2>/dev/null  # JSON 输出所有 vtable

; 构造函数特征
lea  rax, [rip + vtable_offset]  ; 加载 vtable
mov  [rdi], rax                   ; this->vptr = vtable
; 虚函数调用
mov  rax, [rdi]                   ; rax = vptr
call [rax + N*8]                  ; 第 N 个虚函数

结构体字段恢复规则

• [base + N] 反复访问 → 字段 N
• 访问大小推断类型：b=uint8 / w=uint16 / d=uint32/float / q=uint64/ptr
• malloc(M) 后多字段初始化 → 结构体大小 M
• 相邻偏移间隙 → padding

输出格式（每个结构体）：

struct obj_X {
    /* 0x00 */ void*    vptr;
    /* 0x08 */ int32_t  state;
    /* 0x0c */ uint32_t flags;
    /* 0x10 */ void*    handler;  // 函数指针
};  // sizeof = 0x18

---

阶段 3：逐块分析

分析单元：函数边界 → 基本块 → 循环 → 调用图

每块输出格式

## 函数名（地址范围）[工具来源]

### 原始汇编（行号+注释）
### 动态执行上下文（strace/ltrace/GDB 快照）
### 算法识别（疑似 XXX，置信度，依据）
### 伪代码（C 风格，含类型标注）
### 分析注解（不确定点 [?? 待白皮书验证]，建议下一步命令）

不确定指令处理

1. 初步判断
2. 标注 [?? 待验证]
3. web_fetch 查对应手册章节
4. 更新并标注文档来源

---

阶段 4：持续分析协议

除非用户明确终止 / 目标达成 / 重定向，否则分析不停止。

每轮状态报告

📊 分析进度
  ✅ 已完成 : [函数/块]     🔄 进行中 : [当前]
  📋 待分析 : [剩余]        ❓ 待解决 : [不确定点]
🔧 工具会话 [T.6 快照]
🧠 记忆机制 : 第 N 轮（距快照还有 X 轮）

---

阶段 5：综合报告

# 分析报告
## 基本信息：架构 / 编译器 / 优化级别 / 安全标志 / 混淆状态
## 识别算法：[名称 | 置信度 | 函数地址 | 动态验证状态]
## 恢复的数据结构：[struct 定义 / vtable 层级]
## 关键函数伪代码索引
## 动态分析汇总：[strace摘要 | ltrace摘要 | perf热点 | Frida追踪结论]
## 未解决的不确定点
## 文档引用

---

阶段 M：记忆机制（Context Memory）★

核心目标：每 10 轮对话自动生成一份上下文快照，作为新的 skill 文件，下次对话加载后可无缝继续分析，不丢失上下文，降低长对话幻觉。

快照模板见 references/context-snapshot-template.md

M.1 — 轮次计数

• 在 T.6 工具会话状态 中始终显示当前轮次：对话轮次: 第 N 轮（距下次快照还有 X 轮）
• 每一条用户消息 = +1 轮
• 第 10 / 20 / 30 ... 轮：自动触发 M.2 快照生成

M.2 — 快照生成（每 10 轮触发）

触发时，在当前回复末尾追加完整快照块：

---
🧠 **第 N 轮上下文快照已生成**

将以下内容保存为 `.skill` 文件（或文本文件），下次对话开始时粘贴，可无缝继续本次分析。

```yaml
# asm-analysis 上下文快照
# 生成于第 N 轮 | 目标: <target_name>
snapshot_version: 1
turn: N

target:
  file: "./target"
  arch: "x86-64"
  format: "ELF"
  compiler: "GCC 11.3 -O2"
  stripped: true
  pie: true
  aslr_base: "0x555555554000"
  security_flags: ["PIE", "NX", "Canary", "Full RELRO"]

tools_confirmed:
  gdb: "13.2 + pwndbg"
  r2: "5.8.8 + r2ghidra"
  strace: "6.1"
  ltrace: "0.7.3"
  frida: "16.2.1"
  angr: "9.2.90"

whitepaper_loaded:
  - "Intel SDM Vol.2 (x86-64指令集参考)"

obfuscation:
  status: "clean"   # clean / upx_stripped / ollvm / vmprotect
  notes: ""

algorithms_found:
  - name: "RC4"
    confidence: "high"
    function: "0x401234 (sym.encrypt_data)"
    validated: true
    notes: "S盒已确认256字节，PRGA XOR输出已Frida dump验证"
  - name: "MD5"
    confidence: "medium"
    function: "0x402000"
    validated: false
    notes: "发现常数0xd76aa478，待动态确认"

structures_recovered:
  - name: "SessionCtx"
    address: "0x602000 (堆分配)"
    size: 0x38
    fields:
      - "0x00: void* vptr"
      - "0x08: int32_t state"
      - "0x10: void* handler"
      - "0x18: char key[16]"
      - "0x28: uint32_t flags"

functions_analyzed:
  completed:
    - "0x401234 sym.encrypt_data (RC4 PRGA，伪代码已生成)"
    - "0x401100 sym.init_session (SessionCtx 构造)"
  pending:
    - "0x402000 sym.hash_password (疑似MD5，待验证)"
    - "0x403000 sym.verify_token"

dynamic_analysis:
  strace_findings:
    - "open('/etc/shadow') → EACCES (权限检查)"
    - "mprotect(0x555..., EXEC) 在 0x401900 处触发（疑似自解码）"
  ltrace_findings:
    - "strcmp('admin', user_input) @ 0x401500"
    - "EVP_EncryptInit_ex 未被调用（确认非OpenSSL）"
  frida_traces:
    - "sym.encrypt_data: arg0=key_ptr arg1=16 arg2=data_ptr arg3=256"

pending_tasks:
  - "验证 0x402000 MD5 常数（动态 dump 比对）"
  - "分析 0x403000 sym.verify_token 函数"
  - "追踪 mprotect(EXEC) 之后的 OEP（疑似内联解密）"

unresolved:
  - "0x401298 vpxor xmm0,xmm0,xmm1 — SIMD 宽度待白皮书确认"
  - "0x401900 mprotect EXEC 触发点 — 性质未定"

notes: |
  本次分析重点：RC4 算法已完整确认，S盒和PRGA均通过Frida动态验证。
  下一步重点：hash_password 函数 MD5 确认 + verify_token 逆向。
  注意：程序有 /proc/self/status 反调试，已通过GDB fgets patch绕过。
```

将以上 YAML 块保存后，下次对话直接粘贴，我会立即恢复此状态继续分析。
---

M.3 — 快照加载（新对话开始时）

当用户粘贴快照时，执行以下恢复步骤：

1. 解析 YAML 结构
2. 输出恢复确认：
   "📂 已加载上下文快照（第 N 轮）
    目标: <file> | 架构: <arch> | 进度: X 个函数已分析
    待继续: <pending_tasks 列表>
    当前轮次重置为: N+1
    从哪里继续？[最后待分析函数 / 指定目标]"
3. 恢复 T.6 工具会话状态
4. 继续持续分析协议（阶段 4）

M.4 — 手动触发快照

用户可随时说"生成快照"/"保存进度"/"snapshot" 手动触发 M.2。

M.5 — 快照压缩策略（防止快照本身过长）

• 伪代码不写入快照（太长）；只记录函数地址 + 一句话摘要
• 原始汇编不写入快照；只记录关键地址和发现
• 快照目标大小：< 100 行 YAML
• 超过 100 行时，优先保留 pending_tasks 和 unresolved，截断 completed 的详细 notes

---

参考文件索引

文件	内容	触发阶段
references/linux-debug-workflows.md	Linux 完整调试场景工作流（多线程/共享库/信号/coredump/ASLR）	阶段 T
references/tool-commands.md	GDB/LLDB/r2 命令手册 + 反调试绕过	阶段 T
references/frida-scripts.md	Frida 插桩脚本库	阶段 T
references/angr-workflows.md	angr 符号执行工作流	阶段 T / D
references/context-snapshot-template.md	记忆快照 YAML 模板（完整字段定义）	阶段 M
references/obfuscation-patterns.md	UPX/OLLVM/VMProtect 识别与处置	阶段 O
references/algorithm-patterns.md	加密/哈希/压缩算法汇编特征库	阶段 1
references/compiler-patterns.md	编译器优化模式映射	阶段 2
references/struct-recovery.md	vtable/struct/类型重建	阶段 D
references/whitepaper-urls.md	Intel SDM / ARM DDI / 加密规范 URL	阶段 0

---

附录 A：结构认知增强协议（Structure Inference Protocol）

核心原则：结构体推断是多轮迭代过程，每一轮动态观察都应更新置信度。 详细方法见 references/struct-recovery.md

A.1 — 多轮推断状态机

每个结构体实例维护一张推断卡片，跨轮次持续更新：

┌─────────────────────────────────────────────────┐
│ 结构体推断卡：struct_0x602000                      │
│ 状态：PARTIAL → SUSPECTED → CONFIRMED            │
│ 轮次：发现@T3 → 字段推断@T5 → 动态验证@T8         │
├─────────────────────────────────────────────────┤
│ 已确认字段（动态验证）                             │
│   0x00  void*    vptr       [GDB vtable读取验证]  │
│   0x08  int32_t  state      [strace观察值0/1/2]  │
│   0x18  char[16] key        [Frida dump内容]      │
├─────────────────────────────────────────────────┤
│ 疑似字段（静态推断，待验证）                        │
│   0x10  void*    handler    [访问后call [rax]]    │
│   0x28  uint32_t counter    [单调递增，疑似计数]   │
├─────────────────────────────────────────────────┤
│ 未知区域                                          │
│   0x0c  4字节   [读取但未追踪用途]                 │
│   0x2c  4字节   [疑似 padding]                    │
├─────────────────────────────────────────────────┤
│ 整体置信度：72%                                    │
│ 下一步：bpftrace 追踪 0x10 的函数指针实际指向       │
└─────────────────────────────────────────────────┘

A.2 — 置信度评分规则

证据来源	加分	说明
动态验证（GDB/Frida 实际读取）	+30	最强证据
strace/ltrace 观察到字段被外部函数使用	+20	行为证据
多函数中相同偏移有一致访问模式	+15	跨函数一致性
访问指令大小与类型假设一致	+10	静态类型推断
字段值范围符合类型语义（如 0/1/2 → enum）	+10	语义推断
angr 约束求解确认字段边界	+20	符号验证
仅在一处访问，无交叉引用	−10	孤立证据
字段值无规律	−5	弱语义