LLM4Decompile

📊 Risultati | 🤗 Modelli | 🚀 Avvio rapido | 📚 HumanEval-Decompile | 📎 Citazione | 📝 Paper | 🖥️ Colab | ▶️ YouTube

Reverse Engineering: decompilazione del codice binario con Large Language Models

Updates

• [2025-10-04]: Rilasciato SK²Decompile: decompilazione binaria in due fasi basata su LLM, dallo scheletro alla pelle. Fase 1 Recupero della struttura (Skeleton): trasforma il codice binario/pseudocodice in rappresentazioni intermedie offuscate 🤗 HF Link. Fase 2 Assegnazione dei nomi agli identificatori (Skin): genera codice sorgente leggibile dall'uomo con identificatori significativi 🤗 HF Link.
• [2025-05-20]: Rilasciato decompile-bench, contiene due milioni di coppie di funzioni binario-sorgente per l'addestramento e 70K coppie di funzioni per la valutazione. Fare riferimento alla cartella decompile-bench per i dettagli.
• [2024-10-17]: Rilasciato decompile-ghidra-100k, un sottoinsieme di 100k campioni di addestramento (25k per livello di ottimizzazione). Forniamo uno script di addestramento che viene eseguito in ~3.5 ore su una singola GPU A100 40G. Raggiunge un tasso di ri-eseguibilità di 0.26, con un costo totale inferiore a 20 $ per una rapida replica di LLM4Decompile.
• [2024-09-26]: Aggiornato un notebook Colab per dimostrare l'uso del modello LLM4Decompile, inclusi esempi per i modelli LLM4Decompile-End e LLM4Decompile-Ref.
• [2024-09-23]: Rilasciato LLM4Decompile-9B-v2, basato su Yi-Coder-9B, ha raggiunto un tasso di ri-eseguibilità di 0.6494 sul benchmark Decompile.
• [2024-06-19]: Rilasciata la serie V2 (LLM4Decompile-Ref). La V2 (1.3B-22B), basata su Ghidra, è addestrata su 2 miliardi di token per affinare lo pseudocodice decompilato da Ghidra. La versione 22B-V2 supera la 6.7B-V1.5 di un ulteriore 40.1%. Consultare la cartella ghidra per i dettagli.
• [2024-05-13]: Rilasciata la serie V1.5 (LLM4Decompile-End, decompila direttamente il binario usando LLM). Le V1.5 sono addestrate con un dataset più ampio (15B token) e una lunghezza massima dei token di 4.096, con prestazioni notevoli (oltre 100% di miglioramento) rispetto al modello precedente.
• [2024-03-16]: Aggiunto il modello llm4decompile-6.7b-uo, addestrato senza conoscenza preliminare dei livelli di ottimizzazione (O0~O3); la ri-eseguibilità media è di circa 0.219 e ottiene le migliori prestazioni tra i nostri modelli.

Informazioni

• LLM4Decompile è il pionieristico modello linguistico di grandi dimensioni open-source dedicato alla decompilazione. La sua versione attuale supporta la decompilazione di binari Linux x86_64, dai livelli di ottimizzazione O0 a O3 di GCC, in codice sorgente C leggibile dall'uomo. Il nostro team è impegnato ad espandere le capacità di questo strumento, con sforzi continui per includere una gamma più ampia di architetture e configurazioni.
• LLM4Decompile-End si concentra sulla decompilazione diretta del binario. LLM4Decompile-Ref rifinisce lo pseudocodice decompilato da Ghidra.

Valutazione

Struttura

Durante la compilazione, il Preprocessore elabora il codice sorgente (SRC) per eliminare i commenti ed espandere le macro o gli include. Il codice ripulito viene quindi inoltrato al Compilatore, che lo converte in codice assembly (ASM). Questo ASM viene trasformato in codice binario (0 e 1) dall'Assembler. Il Linker completa il processo collegando le chiamate di funzione per creare un file eseguibile. La decompilazione, d'altra parte, consiste nel riconvertire il codice binario in un file sorgente. I LLM, essendo addestrati su testo, non hanno la capacità di elaborare direttamente i dati binari. Pertanto, i binari devono essere prima disassemblati da Objdump in linguaggio assembly (ASM). Si noti che il binario e l'ASM disassemblato sono equivalenti, possono essere convertiti l'uno nell'altro, e quindi li utilizziamo in modo intercambiabile. Infine, la loss viene calcolata tra il codice decompilato e il codice sorgente per guidare l'addestramento. Per valutare la qualità del codice decompilato (SRC'), la sua funzionalità viene testata tramite asserzioni di test (ri-eseguibilità).

Metriche

• Ri-eseguibilità: valuta se il codice decompilato può essere eseguito correttamente e superare tutti i casi di test predefiniti.

Benchmark

• HumanEval-Decompile Una raccolta di 164 funzioni C che si basano esclusivamente sulle librerie C standard.
• ExeBench Una raccolta di 2.621 funzioni tratte da progetti reali, ciascuna utilizzante funzioni, strutture e macro definite dall'utente.

Risultati

Modelli

I nostri LLM4Decompile includono modelli con dimensioni tra 1,3 e 33 miliardi di parametri e abbiamo reso disponibili questi modelli su Hugging Face.

Nota 3: la serie V1.5 è addestrata con un dataset più ampio (15B token) e una dimensione massima dei token di 4.096, con prestazioni notevoli (oltre il 100% di miglioramento) rispetto al modello precedente.

Nota 4: la serie V2 è basata su Ghidra e addestrata su 2 miliardi di token per affinare lo pseudocodice decompilato da Ghidra. Consulta la cartella ghidra per i dettagli.

Avvio rapido

Setup: utilizza lo script seguente per installare l'ambiente necessario.

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

Ecco un esempio di come utilizzare il nostro modello (rivisto per V1.5. Per i modelli precedenti, consultare la pagina del modello corrispondente su HF). Nota: sostituire "func0" con il nome della funzione che si desidera decompilare.

Pre-elaborazione: compila il codice C in binario e disassembla il binario in istruzioni assembly.

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'#compile the code with GCC on Linux
    subprocess.run(compile_command, shell=True, check=True)
    compile_command = f'objdump -d {output_file}.o > {output_file}.s'#disassemble the binary file into assembly instructions
    subprocess.run(compile_command, shell=True, check=True)
    
    input_asm = ''
    with open(output_file+'.s') as f:#asm file
        asm= f.read()
        if '<'+func_name+'>:' not in asm: #IMPORTANT replace func0 with the function name
            raise ValueError("compile fails")
        asm = '<'+func_name+'>:' + asm.split('<'+func_name+'>:')[-1].split('\n\n')[0] #IMPORTANT replace func0 with the function name
        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:])  # remove the binary code
            tmp_asm = tmp_asm.split("#")[0].strip()  # remove the comments
            asm_clean += tmp_asm + "\n"
    input_asm = asm_clean.strip()
    before = f"# This is the assembly code:\n"#prompt
    after = "\n# What is the source code?\n"#prompt
    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)

Le istruzioni assembly devono essere nel formato:

<FUNCTION_NAME>:\nOPERATIONS\nOPERATIONS\n

Le istruzioni assembly tipiche possono apparire così:

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

Decompilazione: utilizza LLM4Decompile per tradurre le istruzioni assembly in C:

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_path = 'LLM4Binary/llm4decompile-6.7b-v1.5' # V1.5 Model
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:#optimization level 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)### max length to 4096, max new tokens should be below the range
c_func_decompile = tokenizer.decode(outputs[0][len(inputs[0]):-1])

with open(fileName +'.c','r') as f:#original file
    func = f.read()

print(f'original function:\n{func}')# Note we only decompile one function, where the original file may contain multiple functions
print(f'decompiled function:\n{c_func_decompile}')

Configurazione Docker

# build docker
docker build -t llm4decompile .

# run docker with GPU
docker run --gpus all -it --name llm4decompile llm4decompile /bin/bash

# run demo.py (choose a model suitable for your resources before running)
cd ghidra
python demo.py

HumanEval-Decompile

I dati sono memorizzati in llm4decompile/decompile-eval/decompile-eval-executable-gcc-obj.json, in formato lista JSON. Ci sono 164*4 (O0, O1, O2, O3) campioni, ciascuno con cinque chiavi:

• task_id: indica l'ID del problema.
• type: lo stadio di ottimizzazione, uno tra [O0, O1, O2, O3].
• c_func: soluzione C per il problema HumanEval.
• c_test: asserzioni dei test C.
• input_asm_prompt: istruzioni assembly con prompt, ottenibili come nel nostro esempio di pre-elaborazione.

Consulta gli script di valutazione.

In corso

• Dataset di addestramento più ampio con processo di pulizia. (completato: 2024.05.13)
• Supporto per linguaggi/piattaforme e impostazioni più diffusi.
• Supporto per eseguibili binari. (completato: 2024.05.13)
• Integrazione con strumenti di decompilazione (es. Ghidra, Rizin)

Licenza

Questo repository di codice è concesso in licenza sotto la licenza MIT e DeepSeek.

Citazione

@misc{tan2024llm4decompile,
      title={LLM4Decompile: Decompiling Binary Code with Large Language Models}, 
      author={Hanzhuo Tan and Qi Luo and Jing Li and Yuqun Zhang},
      year={2024},
      eprint={2403.05286},
      archivePrefix={arXiv},
      primaryClass={cs.PL}
}

Cronologia delle stelle