人よ、幸福に生きよ

1
Ghidra 伪代码 → LLM 修复 → 尝试编译 → 收集错误 → 再修复 → ...

1
// 真实源码（你要恢复的目标）
2
struct connection_t {
3
    int fd;
4
    char *buffer;
5
    size_t buf_size;
6
    struct sockaddr_in peer_addr;
7
};
8

9
// 函数 A：创建连接
10
struct connection_t* create_connection(int port, const char *host) {
11
    struct connection_t *conn = malloc(sizeof(struct connection_t));
12
    conn->fd = socket(AF_INET, SOCK_STREAM, 0);
13
    conn->peer_addr.sin_port = htons(port);
14
    conn->peer_addr.sin_addr.s_addr = inet_addr(host);
15
    connect(conn->fd, (struct sockaddr*)&conn->peer_addr, sizeof(conn->peer_addr));
16
    conn->buffer = malloc(4096);
17
    conn->buf_size = 4096;
18
    return conn;
19
}
20

21
// 函数 B：发送数据（依赖函数 A 创建的 connection_t）
22
int send_data(struct connection_t *conn, const char *data, size_t len) {
23
    if (len > conn->buf_size) {
24
        conn->buffer = realloc(conn->buffer, len);
25
        conn->buf_size = len;
26
    }
27
    memcpy(conn->buffer, data, len);
28
    return send(conn->fd, conn->buffer, len, 0);
29
}

1
// LLM4D 的输出——它不知道 struct connection_t 长什么样
2
void* sub_401234(int param_1, char *param_2) {
3
    void *v1 = malloc(32);  // 不知道是 struct connection_t
4
    *(int*)v1 = socket(2, 1, 0);
5
    // ... 一堆指针偏移操作 ...
6
    return v1;
7
}

1
// 独立反编译——同一个 struct 完全不同的理解
2
int sub_401500(long param_1, char *param_2, int param_3) {
3
    if (param_3 > *(int*)(param_1 + 16)) {  // buf_size 偏移猜测
4
        // ...
5
    }
6
    return send(*(int*)param_1, *(char**)(param_1 + 8), param_3, 0);
7
}

1
                        处理粒度
2
                  函数级 ◄──────────► 全程序级
3
                    │                    │
4
  LLM4Decompile ────┤                    │
5
  SK²Decompile ─────┤                    │
6
  ReF Decompile ────┤                    │
7
  DecLLM ───────────┤                    │
8
  ReCopilot ────────┼──┐                 │
9
                    │  │                 │
10
                    │  (有限的跨函数)      │
11
                    │                    │
12
                    │            ❓这里是空白
13
                    │                    │
14
           单模型/管道 ◄──────────► 多智能体协作

1
[一个巨大的 prompt]
2
├── 函数 1 的反汇编 (2K tokens)
3
├── 函数 2 的反汇编 (3K tokens)
4
├── ...
5
├── 函数 200 的反汇编 (1.5K tokens)
6
├── 调用关系说明 (5K tokens)
7
├── 全局变量列表 (2K tokens)
8
├── 已知类型定义 (3K tokens)
9
└── 任务指令 (1K tokens)
10
= 远远超出上下文限制

1
Agent A 处理函数 1 时的 prompt:
2
├── 函数 1 的 Ghidra 伪代码 (0.5K tokens)
3
├── [从 neo4j 查询] 函数 1 调用的 3 个函数的签名 (0.3K tokens)
4
├── [从 neo4j 查询] 函数 1 使用的 2 个全局变量的类型 (0.1K tokens)
5
├── [从 neo4j 查询] 相关的 1 个 struct 定义 (0.2K tokens)
6
└── 任务指令 (0.5K tokens)
7
= 仅 1.6K tokens，精准且充分

1
反编译 Agent：我觉得这个函数返回 int
2
                    ↓ 写入知识库
3
验证 Agent：编译器说调用者把返回值赋给了 char*，类型冲突
4
                    ↓ 反馈
5
修复 Agent：根据调用上下文，应该返回 char*，修复

1
                    ┌─────────────────────────────────────────┐
2
                    │           Orchestrator (编排器)           │
3
                    │  LangGraph StateGraph + 确定性状态机      │
4
                    └────┬────────┬──────────┬────────────┬───┘
5
                         │        │          │            │
6
                    ┌────▼───┐┌───▼────┐┌────▼─────┐┌────▼─────┐
7
                    │Phase 0 ││Phase 1 ││Phase 2   ││Phase 3   │
8
                    │预处理   ││反编译   ││关系恢复   ││验证修复   │
9
                    │Agent   ││Agent   ││Agent     ││Agent     │
10
                    │        ││        ││          ││          │
11
                    │Ghidra  ││LLM4D   ││GPT-4 /   ││GCC +     │
12
                    │headless││-Ref    ││Claude    ││angr +    │
13
                    │+ 分析  ││6.7B    ││+ neo4j   ││LLM       │
14
                    └───┬────┘└───┬────┘└────┬─────┘└────┬─────┘
15
                        │         │          │           │
16
                        ▼         ▼          ▼           ▼
17
                    ┌─────────────────────────────────────────┐
18
                    │           共享知识库                      │
19
                    │  neo4j (代码属性图 CPG)                   │
20
                    │  + SQLite (元数据与状态追踪)               │
21
                    │  + 文件系统 (源码/头文件/编译产物)          │
22
                    └─────────────────────────────────────────┘

1
优先级策略：修改逆拓扑排序（叶函数优先）
2

3
为什么？叶函数（不调用其他用户函数的函数）反编译时不依赖任何其他函数的信息，
4
结果最独立可靠。先反编译它们，就可以把它们的签名信息存入知识库，
5
供后续反编译其调用者时使用。
6

7
Batch 1: 叶函数 → 独立反编译，签名写入 CPG
8
Batch 2: 只调用 Batch 1 的函数 → 利用 Batch 1 的签名作为上下文
9
Batch 3: 调用 Batch 1+2 的函数 → 上下文更丰富
10
...
11
最后: main() → 拥有最完整的上下文

1
### Context:
2
// Known callee signatures:
3
int parse_header(const char *buf, size_t len);
4
void free_connection(struct conn_t *conn);
5

6
// Known global variables:
7
extern int g_verbose_level;
8
extern struct config_t *g_config;
9

10
// Known struct:
11
struct conn_t { int fd; char *buffer; size_t buf_size; };
12

13
### Ghidra Pseudo-Code:
14
undefined8 FUN_00401234(long param_1, int param_2) { ... }
15

16
### Refined C Code:

1
Level 1: 语法验证 (tree-sitter, < 1秒)
2
    ✓ → Level 2
3
    ✗ → 规则修复（缺分号、括号不匹配等，无需 LLM）
4

5
Level 2: 编译验证 (GCC, < 10秒)
6
    ✓ → Level 3
7
    ✗ → 结构化错误解析 → 分类（5类错误） → 对应修复策略
8

9
Level 3: 语义验证 (angr 符号执行, 分钟级)
10
    ✓ → 完成
11
    ✗ → LLM 深度推理修复
12

13
Level 4: 行为验证 (编译+运行对比, 可选)
14
    对比反编译程序和原始二进制在相同输入下的输出

1
节点类型:
2
  (:Function)  — 函数，含地址、名字、签名、置信度
3
  (:Variable)  — 变量，含名字、类型、作用域
4
  (:Struct)    — 结构体，含字段定义
5
  (:Type)      — 类型信息
6
  (:SourceFile)— 源文件
7

8
关系类型:
9
  CALLS        — 函数调用关系
10
  HAS_VARIABLE — 函数拥有变量
11
  HAS_TYPE     — 变量的类型
12
  READS_GLOBAL — 函数读取全局变量
13
  WRITES_GLOBAL— 函数写入全局变量
14
  INCLUDES     — 文件包含关系

1
// 获取函数 F 的完整上下文：调用者+被调用者+共享全局变量+相关结构体
2
MATCH (f:Function {address: 0x401234})
3
OPTIONAL MATCH (caller)-[:CALLS]->(f)
4
OPTIONAL MATCH (f)-[:CALLS]->(callee)
5
OPTIONAL MATCH (f)-[:READS_GLOBAL|WRITES_GLOBAL]->(gv:Variable)
6
OPTIONAL MATCH (f)-[:ACCESSES_STRUCT]->(s:Struct)
7
RETURN f, collect(DISTINCT caller), collect(DISTINCT callee),
8
       collect(DISTINCT gv), collect(DISTINCT s)

1
Phase 0 → Phase 1 → Phase 2 → Phase 3
2
                ↑        ↑        │
3
                │        │        ├── 编译通过 → 完成
4
                │        │        ├── 类型问题 → 回退 Phase 2
5
                │        └────────┤
6
                │                 └── 函数需重做 → 回退 Phase 1
7
                └─────────────────┘