📊 结果 | 🤗 模型 | 🚀 快速入门 | 📚 HumanEval-Decompile | 📎 引用 | 📝 论文 | 🖥️ Colab | ▶️ YouTube

逆向工程：利用大型语言模型反编译二进制代码

更新

• [2025-10-04]: 发布 SK²Decompile：基于 LLM 的两阶段二进制反编译，从骨架到皮肤。第一阶段结构恢复（骨架）：将二进制/伪代码转换为混淆的中间表示形式 🤗 HF 链接。第二阶段标识符命名（皮肤）：生成带有有意义标识符的人类可读源代码 🤗 HF 链接。
• [2025-05-20]: 发布 decompile-bench，包含用于训练的二百万对二进制-源代码函数对，以及用于评估的七万对函数对。详情请参阅 decompile-bench 文件夹。
• [2024-10-17]: 发布 decompile-ghidra-100k，这是一个包含十万个训练样本的子集（每个优化级别 2.5 万个）。我们提供了一个 训练脚本，在单块 A100 40G GPU 上运行约 3.5 小时即可完成。该模型实现了 0.26 的可重执行率，总成本低于 20 美元，便于快速复现 LLM4Decompile。
• [2024-09-26]: 更新了 Colab 笔记本，以演示 LLM4Decompile 模型的使用方法，包括 LLM4Decompile-End 和 LLM4Decompile-Ref 模型的示例。
• [2024-09-23]: 发布 LLM4Decompile-9B-v2，基于 Yi-Coder-9B 进行微调，在 Decompile 基准测试中达到了 0.6494 的可重执行率。
• [2024-06-19]: 发布 V2 系列（LLM4Decompile-Ref）。V2（1.3B-22B）以 Ghidra 为基础，使用 20 亿个标记进行训练，以 精炼 Ghidra 反编译出的伪代码。22B-V2 版本比 6.7B-V1.5 提高了额外的 40.1%。详情请查看 ghidra 文件夹。
• [2024-05-13]: 发布 V1.5 系列（LLM4Decompile-End，直接使用 LLM 反编译二进制文件）。V1.5 使用更大的数据集（150 亿个标记）和最大标记长度 4,096 进行训练，与先前模型相比，性能显著提升（超过 100%）。
• [2024-03-16]: 新增 llm4decompile-6.7b-uo 模型，该模型在不预先了解优化级别（O0~O3）的情况下进行训练，平均可重执行率约为 0.219，是我们所有模型中表现最好的。

关于

• LLM4Decompile 是开创性的开源大型语言模型，专门用于反编译。当前版本支持将 Linux x86_64 二进制文件（从 GCC 的 O0 到 O3 优化级别）反编译为人类可读的 C 源代码。我们的团队致力于扩展此工具的功能，目前正在努力纳入更广泛的架构和配置。
• LLM4Decompile-End 专注于直接反编译二进制文件。LLM4Decompile-Ref 则用于精炼由 Ghidra 反编译得到的伪代码。

评估

框架

在编译过程中，预处理器会处理源代码（SRC），去除注释并展开宏或包含文件。清理后的代码随后被传递给编译器，将其转换为汇编代码（ASM）。然后，汇编器将这些汇编代码进一步转化为二进制代码（0 和 1）。最后，链接器通过链接函数调用创建可执行文件。而反编译则是将二进制代码重新转换回源文件的过程。由于 LLM 是基于文本训练的，无法直接处理二进制数据。因此，必须先使用 Objdump 将二进制文件反汇编成汇编语言（ASM）。需要注意的是，二进制文件和反汇编后的 ASM 是等价的，可以相互转换，因此我们在讨论中会交替使用这两个术语。最后，通过计算反编译代码与源代码之间的损失来指导训练。为了评估反编译代码（SRC'）的质量，我们会通过测试断言（可重执行性）来检验其功能是否正常。

指标

• 可重执行性 用于评估反编译后的代码是否能够正确执行，并通过所有预定义的测试用例。

基准测试

• HumanEval-Decompile 是一个包含 164 个 C 函数的集合，这些函数仅依赖于 标准 C 库。
• ExeBench 是一个包含 2,621 个函数的集合，这些函数来自 真实项目，每个函数都使用了用户自定义的函数、结构体和宏。

结果

模型

我们的 LLM4Decompile 包含参数量从 13 亿到 330 亿不等的模型，并且我们已将这些模型发布在 Hugging Face 上。

模型	检查点	参数量	可重执行性	备注
llm4decompile-1.3b-v1.5	🤗 HF 链接	13亿	27.3%	注3
llm4decompile-6.7b-v1.5	🤗 HF 链接	67亿	45.4%	注3
llm4decompile-1.3b-v2	🤗 HF 链接	13亿	46.0%	注4
llm4decompile-6.7b-v2	🤗 HF 链接	67亿	52.7%	注4
llm4decompile-9b-v2	🤗 HF 链接	90亿	64.9%	注4
llm4decompile-22b-v2	🤗 HF 链接	220亿	63.6%	注4

注3：V1.5 系列使用更大的数据集（150 亿个 token）和最大 4,096 个 token 的序列长度进行训练，与先前模型相比，性能显著提升（超过 100%）。

注4：V2 系列基于 Ghidra 构建，并在 20 亿个 token 上进行训练，以 优化 Ghidra 生成的反编译伪代码。详情请参阅 ghidra 文件夹。

快速入门

设置： 请使用以下脚本安装必要的环境。

git clone https://github.com/albertan017/LLM4Decompile.git
cd LLM4Decompile
conda create -n 'llm4decompile' python=3.9 -y
conda activate llm4decompile
pip install -r requirements.txt

以下是使用我们模型的示例（针对 V1.5 版本进行了修订。对于旧版本，请查看 Hugging Face 上对应的模型页面）。 注意：请将“func0”替换为您想要反编译的函数名。

预处理： 将 C 代码编译为二进制文件，并将二进制文件反汇编为汇编指令。

import subprocess
import os
func_name = 'func0'
OPT = ["O0", "O1", "O2", "O3"]
fileName = 'samples/sample' #'path/to/file'
for opt_state in OPT:
    output_file = fileName +'_' + opt_state
    input_file = fileName+'.c'
    compile_command = f'gcc -o {output_file}.o {input_file} -{opt_state} -lm'#用 GCC 在 Linux 上编译代码
    subprocess.run(compile_command, shell=True, check=True)
    compile_command = f'objdump -d {output_file}.o > {output_file}.s'#将二进制文件反汇编为汇编指令
    subprocess.run(compile_command, shell=True, check=True)
    
    input_asm = ''
    with open(output_file+'.s') as f:#asm 文件
        asm= f.read()
        if '<'+func_name+'>:' not in asm: #重要：将 func0 替换为实际函数名
            raise ValueError("编译失败")
        asm = '<'+func_name+'>:' + asm.split('<'+func_name+'>:')[-1].split('\n\n')[0] #重要：将 func0 替换为实际函数名
        asm_clean = ""
        asm_sp = asm.split("\n")
        for tmp in asm_sp:
            if len(tmp.split("\t"))<3 和 '00' 在其中时：
                continue
            idx = min(
                len(tmp.split("\t")) - 1, 2
            )
            tmp_asm = "\t".join(tmp.split("\t")[idx:])  # 去除二进制代码
            tmp_asm = tmp_asm.split("#")[0].strip()  # 去除注释
            asm_clean += tmp_asm + "\n"
    input_asm = asm_clean.strip()
    before = f"# 这是汇编代码:\n"#提示
    after = "\n# 源代码是什么？\n"#提示
    input_asm_prompt = before+input_asm.strip()+after
    with open(fileName +'_' + opt_state +'.asm','w',encoding='utf-8') as f:
        f.write(input_asm_prompt)

汇编指令应采用以下格式：

:\nOPERATIONS\nOPERATIONS\n

典型的汇编指令可能如下所示：

<func0>:
endbr64
lea    (%rdi,%rsi,1),%eax
retq

反编译： 使用 LLM4Decompile 将汇编指令转换为 C 语言代码：

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_path = 'LLM4Binary/llm4decompile-6.7b-v1.5' # V1.5 模型
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(model_path,torch_dtype=torch.bfloat16).cuda()

with open(fileName +'_' + OPT[0] +'.asm','r') as f:#优化级别 O0
    asm_func = f.read()
inputs = tokenizer(asm_func, return_tensors="pt").to(model.device)
with torch.no_grad():
    outputs = model.generate(**inputs, max_new_tokens=2048)### 最大长度为 4096，新令牌数量应在范围内
c_func_decompile = tokenizer.decode(outputs[0][len(inputs[0]):-1])

with open(fileName +'.c','r') as f:#原始文件
    func = f.read()

print(f'原始函数:\n{func}')# 注意我们只反编译一个函数，而原始文件可能包含多个函数
print(f'反编译后的函数:\n{c_func_decompile}')

Docker 设置

# 构建 Docker
docker build -t llm4decompile .

# 使用 GPU 运行 Docker
docker run --gpus all -it --name llm4decompile llm4decompile /bin/bash

# 运行 demo.py（运行前请根据您的资源选择合适的模型）
cd ghidra
python demo.py

HumanEval-Decompile

数据存储在 llm4decompile/decompile-eval/decompile-eval-executable-gcc-obj.json 中，采用 JSON 列表格式。共有 164*4（O0、O1、O2、O3）个样本，每个样本包含五个键：

• task_id：表示问题的 ID。
• type：优化阶段，取值为 [O0、O1、O2、O3]。
• c_func：HumanEval 问题的 C 语言解决方案。
• c_test：C 语言测试断言。
• input_asm_prompt：带有提示的汇编指令，可参考我们的 预处理示例。

请查看 评估脚本。

进展中

• 更大的训练数据集及清洗流程。（已完成：2024年5月13日）
• 对主流语言/平台及配置的支持。
• 对可执行二进制文件的支持。（已完成：2024年5月13日）
• 与反编译工具（如 Ghidra、Rizin）的集成。

许可证

此代码仓库采用 MIT 许可证和 DeepSeek 许可证授权。

引用

@misc{tan2024llm4decompile,
      title={LLM4Decompile: 使用大型语言模型反编译二进制代码}, 
      author={Hanzhuo Tan、Qi Luo、Jing Li、Yuqun Zhang},
      year={2024},
      eprint={2403.05286},
      archivePrefix={arXiv},
      primaryClass={cs.PL}
}

星标历史

LLM4Decompile 快速上手指南

LLM4Decompile 是一款专为反编译设计的开源大语言模型，支持将 Linux x86_64 架构下的二进制文件（涵盖 GCC O0-O3 优化等级）还原为可读的 C 语言源代码。本项目提供两种主要模式：LLM4Decompile-End（直接从汇编反编译）和 LLM4Decompile-Ref（基于 Ghidra 生成的伪代码进行优化）。

环境准备

• 操作系统: Linux (推荐 Ubuntu)
• 硬件要求: NVIDIA GPU (建议显存 16GB 以上以运行较大模型，如 6.7B/9B)
• 软件依赖:
  • Python 3.9
  • Conda (推荐用于环境管理)
  • GCC (用于编译测试代码)
  • Objdump (GNU Binutils 的一部分，用于反汇编)
  • CUDA Toolkit (需与 PyTorch 版本匹配)

安装步骤

1. 克隆项目

git clone https://github.com/albertan017/LLM4Decompile.git
cd LLM4Decompile

2. 创建并激活虚拟环境

conda create -n 'llm4decompile' python=3.9 -y
conda activate llm4decompile

3. 安装 Python 依赖

(注：若下载速度慢，可配置 pip 使用国内镜像源，如清华源)

pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple

4. 验证系统工具

确保 gcc 和 objdump 已安装：

gcc --version
objdump --version

基本使用

以下示例演示如何使用 LLM4Decompile-End (V1.5) 模型，将编译后的二进制文件反汇编并还原为 C 代码。

第一步：预处理（编译与反汇编）

首先将 C 代码编译为二进制，并使用 objdump 提取特定函数的汇编指令。

import subprocess
import os

# 配置项：替换为你想要反编译的函数名
func_name = 'func0' 
OPT = ["O0", "O1", "O2", "O3"]
fileName = 'samples/sample' # 你的文件路径前缀

for opt_state in OPT:
    output_file = fileName +'_' + opt_state
    input_file = fileName+'.c'
    
    # 1. 使用 GCC 编译代码 (Linux 环境)
    compile_command = f'gcc -o {output_file}.o {input_file} -{opt_state} -lm'
    subprocess.run(compile_command, shell=True, check=True)
    
    # 2. 将二进制文件反汇编为汇编指令
    compile_command = f'objdump -d {output_file}.o > {output_file}.s'
    subprocess.run(compile_command, shell=True, check=True)
    
    input_asm = ''
    with open(output_file+'.s') as f:
        asm = f.read()
        # 检查函数是否存在
        if '<'+func_name+'>:' not in asm: 
            raise ValueError("compile fails")
        
        # 提取目标函数的汇编代码块
        asm = '<'+func_name+'>:' + asm.split('<'+func_name+'>:')[-1].split('\n\n')[0] 
        
        # 清洗汇编代码：移除地址和机器码，保留助记符
        asm_clean = ""
        asm_sp = asm.split("\n")
        for tmp in asm_sp:
            if len(tmp.split("\t"))<3 and '00' in tmp:
                continue
            idx = min(len(tmp.split("\t")) - 1, 2)
            tmp_asm = "\t".join(tmp.split("\t")[idx:])  # 移除二进制码
            tmp_asm = tmp_asm.split("#")[0].strip()    # 移除注释
            asm_clean += tmp_asm + "\n"
    
    input_asm = asm_clean.strip()
    
    # 构造模型输入 Prompt
    before = f"# This is the assembly code:\n"
    after = "\n# What is the source code?\n"
    input_asm_prompt = before + input_asm.strip() + after
    
    # 保存处理后的汇编文件
    with open(fileName +'_' + opt_state +'.asm', 'w', encoding='utf-8') as f:
        f.write(input_asm_prompt)

汇编格式说明： 处理后的 .asm 文件内容应如下所示：

<func0>:
endbr64
lea    (%rdi,%rsi,1),%eax
retq

第二步：执行反编译

加载模型并将汇编指令转换为 C 代码。

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# 选择模型路径 (此处以 6.7B V1.5 为例)
model_path = 'LLM4Binary/llm4decompile-6.7b-v1.5' 

# 加载分词器和模型
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch.bfloat16).cuda()

# 读取预处理后的汇编文件 (以 O0 优化等级为例)
with open(fileName +'_' + "O0" +'.asm', 'r') as f:
    asm_func = f.read()

# 推理生成
inputs = tokenizer(asm_func, return_tensors="pt").to(model.device)
with torch.no_grad():
    # max_new_tokens 需根据上下文长度调整，最大支持 4096
    outputs = model.generate(**inputs, max_new_tokens=2048)

# 解码输出结果
c_func_decompile = tokenizer.decode(outputs[0][len(inputs[0]):-1])

# 对比原始代码（可选）
with open(fileName +'.c', 'r') as f:
    func = f.read()

print(f'Original function:\n{func}')
print(f'Decompiled function:\n{c_func_decompile}')

Docker 快速启动（可选）

如果你希望使用容器化环境，可以使用以下命令：

# 构建镜像
docker build -t llm4decompile .

# 启动容器（需挂载 GPU）
docker run --gpus all -it --name llm4decompile llm4decompile /bin/bash

# 在容器内运行演示脚本
cd ghidra
python demo.py