acceptodds
Under review as a conference paper at ICLR 2027

NeuroProbe: LLM-Augmented Reverse Engineering of Deep Neural Network Binaries

Abstract

Deep learning compilers translate high-level models into optimized native binaries yet these executables often leak structural patterns that expose proprietary architectures. We present NeuroProbe, a reverse-engineering pipeline that recovers operator semantics and architecture family from compiled neural network binaries under both clean and identifier-stripped conditions. Our solution ensembles a symbol-stripped XGBoost model trained on assembly features with a LoRA-tuned Qwen2.5-3B-Instruct model that outputs structured chain-of-thought rationale. We build and release a benchmark of 400 compiled binaries spanning three compiler backends (TVM, IREE, TensorRT) and three architecture families (CNN, Transformer, and Hybrid CNN-Transformer), covering 117 base models and 13,438 extracted kernel functions. NeuroProbe recovers operators with 99.7% F1 under clean compilation and 79.7% F1 under obfuscated setting, while architecture-family accuracy remains at 95% per binary in both settings. Beyond classification, NeuroProbe performs fine-grained hyperparameter estimation and topology reconstruction. We perform signal-ablation experiments to quantify the explicit contributions of symbol names versus assembly features, demonstrating that compiled transformer models remain substantially recoverable under heavy obfuscation despite prior assumptions of robustness.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
Deep Neural Networks, Reverse Engineering, DNN Binary

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_uRAbOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes a reverse engineering pipeline that decompiles neural-network binaries in unstripped and stripped setup. The model in this work is XGBoost model trained on assembly features with a LoRA-tuned Qwen2.5-3B-Instruct model that outputs structured chain-of-thought rationale. Authors made a benchmark of 400 compiled Binaries across 3 compilers and different architectures. The evaluation in the paper shows that this model can outperform the frontier model in identifying operators and hyperparameter estimation and topology reconstruction.

Critical strengths

The paper introduces an evaluation dataset consisting of 400 compiled binaries. This diversity provides an evaluation baseline rather than for evaluating a single case. Also, The evaluation setup is systematic, including different optimization and model families.

This work also considers the obfuscation case, and the training incorporates the part obfuscated with NeuroShield.

The work attempts to use LLMs with finetune approach to address a valuable question on neural network decompilation.

Critical weaknesses

The margin of improvement compared to the base Qwen implementation is low. Shown in Table 5 and Table 2a, Qwen reaches 78.1% accuracy under obfuscation, whereas the full framework achieves 79.7%, marking a ~2 percentage point increase on both cases. The ablation study does not work in favor of the approach this work proposes, and the proposed finetune and approach is not well justified for its performance gain.

The baseline models in Table 1 are not using sota frontier models, and the reference to Opus lacks version details required for reproducibility. In addition, a comparison of prior neural network decompilers is not presented.

The system does not function as a full neural-network decompiler. As shown in Appendix B, its outputs are operator labels, architecture families, and topology graphs. Prior work such as DnD and BTD provide stronger capabilities, recovering complete model specifications and evaluating executable reconstructions within their supported frameworks.

Questions for authors

Model used in this work (Qwen2.5) and other evaluated model are relatively outdated, dating from 2 years to 1 years old, and models listed does not label their generation. As frontier models such as GPT6 and Fable are advancing rapidly, is it possible to show that either this approach also holds for the recent models, or update the evaluation of more recent frontier models?

The ablation experiment shows a small improvement compared to vanilla Qwen2.5, can you elaborate more on the motivation?

7 comments

We thank the reviewer for a sharp review.

W1 / Q2: The margin over Qwen

The "Qwen" column in Tables 2a and 5 is not a plain Qwen model. It is the fine-tuned reasoner trained with NeuroProbe's own components (name-blind prior, leak-free context, SCA-CoT, Prior Dropout, SFT and GRPO), scored before fusion, so these tables isolate only the effect of fusion. The "Zero-Shot" label in Table 5 is wrong, and we include this correction in the revised version. The framework's gain over unadapted models is in Table 1: under obfuscation NeuroProbe beats the best zero-shot frontier model by 12.6 Operator F1 and 30.9 Exact points.

On clean binaries, fusion cuts the error from 2.5% to 0.3% (97.5 to 99.7 Operator F1, an 88% relative reduction) and beats both components (prior alone 99.2). Under obfuscation it raises Operator F1 from 78.1 to 79.7, and per-kernel family accuracy is 95.8% vs. 95.0% for the prior alone.

The prior alone reaches 81.0 Operator F1 under obfuscation, which we consider the paper's main security finding: stripping identifiers does not protect a compiled model. With every symbol name removed, it recovers 83.7% Operator F1 (80.5% Exact) and 94.3% family accuracy (52.9% majority baseline) on the full test set, and 76.6% on TensorRT plans with no disassembly. We include this result first in the revised version. The LLM's role on top is auditability: each prediction carries a rationale whose evidence is checked against the prompt.

W2 / Q1: Frontier models and version details

The Opus model in Table 1 is Claude Opus 4. On model choice, the very newest frontier models (e.g., Fable) are expensive to run at the scale of our evaluation, so we evaluated on lighter models: Claude Opus, GPT-4o, DeepSeek and Llama 4 Maverick. The pipeline is model-agnostic (prompt format, SFT targets and reward do not depend on Qwen2.5, and the comparison models are only queried zero-shot), so the conclusion does not hinge on a particular model, and newer models can be substituted directly.

W3: Not a full decompiler

We respectfully disagree that prior work provides stronger capabilities in the settings we target. DnD and BTD are strong within a narrow scope: unobfuscated CPU executables of supported CNN operators. Even there, coverage is partial: DnD supports 59 of 70 ONNX operators and cannot represent recurrent structures, and BTD reports correctly recovering 59 of 65 executables and notes that it does not guarantee correct output. Outside that scope they do not apply: both are CPU-only, so GPU engine plans such as TensorRT are out of reach, neither reports transformer results, and in our Table 3b BTD fails on all three transformer models. Both also assume unobfuscated binaries. Other work on recovering DNN structure from executables (e.g., Libsteal, Neuroscope) and general-purpose LLM binary-analysis tools such as ReCopilot, LLM4Decompile and ReSym address a different task (function names, types and source-level code, not DNN operators), so they are not directly comparable. NeuroDeX, the closest LLM-based work, covers CNNs only and does not evaluate obfuscated binaries.

NeuroProbe works across exactly the regimes where these tools do not: TensorRT plans with no disassembly, Transformer architectures, and binaries with stripped identifiers. From further prompting it can produce much detailed information and full model recovery without pretraining.

We thank the reviewer again; their point has made the paper's contribution considerably clearer. We are happy to answer any further questions.

Thank you for the clarifications. The explanation that the Qwen results refer to the fine-tuned reasoner reduces my concern about the small reported improvement. However, my concern about the age of the evaluated models and main motivation remains unresolved. A model-agnostic design does not establish that the reported advantages persist with newer models. I understand the cost constraints, but a limited comparison against a recent strong baseline would help address this.

I will raise my score from 1 to 2 given the clarification of W3, but W1/W2 are not convincing enough in my view.

We thank the reviewer again for their time.

R1/W1: Motivation for the finetuning

  • Frontier models given the same prompt, including the same prior, score 8.7 - 19.5 points below NeuroProbe under obfuscation (Table R1); off-the-shelf LLMs often override a correct prior with wrong guesses. NeuroProbe's training closes most of that gap with a 3B model.
  • Auditable predictions. Every prediction carries a structured rationale (evidence, constraints, hypothesis, self-check), and our verifier checks each cited value against the prompt.

Why Qwen2.5-3B. (i) It was pretrained on a large mix of code and mathematical data, so instruction mnemonics, register names and numeric feature ratios are in-distribution. (ii) Its open weights permit research fine-tuning.


R1/W2: Comparison against current frontier models

We agree that comparing against current frontier models gives a more up-to-date picture of NeuroProbe's performance, so we have evaluated GPT-6 Astra, Claude Fable 5.2, and Claude Opus 5.5 alongside the baselines in the submission. **Evaluation protocol : ** All models are evaluated on the identical held-out kernels. Each uses the same four-block prompt (FUNCTION, ASM/BYTES, PRIOR, CONTEXT), the same 28-label operator vocabulary, and greedy decoding. The comparison is therefore controlled for input information and output space. Table R1. Per-kernel Operator F1 (%).

ModelClean compilationObfuscated
NeuroProbe99.779.7
GPT-6 Astra89.871.0
Claude Fable 5.288.869.5
Claude Opus 5.588.569.3
Claude Opus 4 (prior baseline)86.567.1
GPT-4o79.660.2
Hopefully this clarifies point 2. Please let us know if any questions remain.
Reviewer_jxwyOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2(+1)
Read review
Paper summary

The paper proposes NeuroProbe, which aims to recover operator types, architecture families, and model topology from compiled binaries. The evaluation covers clean and obfuscated binaries. NeuroProbe combines an XGBoost classifier, based solely on assembly- and byte-level statistical features, with Qwen2.5-3B, using LoRA fine-tuning and stepwise reasoning. LLM training consists of a two-stage SFT followed by GRPO-lite. The authors also construct a benchmark of 400 binaries compiled with TVM, IREE, and TensorRT. The reported operator F1 is 99.7% on clean binaries and 79.7% on obfuscated binaries.

Critical strengths
  1. The problem has practical significance. The paper extends previous work to cover multiple compilers and Transformer models.
  2. All name-related features are masked in the obfuscated setting. The results in that setting, therefore, do not rely solely on reading symbol names.
Critical weaknesses
  1. Beyond BTD, the experiments lack comparisons with non-LLM methods on operator-level performance to establish the effectiveness of NeuroProbe's framework design. The training and inference overhead introduced by the LLM should also be reported.
  2. The paper lacks in-depth experiments to justify the hyperparameter choices, including 48 bytes and 120 in Section 2.1. The authors should clarify whether the filtering affects performance.
  3. Section 3.4.1 should clarify the number of SFT data pairs used at each stage. The authors should also explain how high-quality reasoning data are obtained.
Questions for authors

What exactly is provided to the LLM: raw assembly or numerical feature vectors? Figure 4 shows raw assembly in the ASM/BYTES block, whereas Section 3.2 defines ASM/BYTES as an opcode histogram.

3 comments

We thank the reviewer. We answer each point below and have added all of it to the revised paper.

1. Non-LLM Baselines and Overhead (W1)

In our literature review, the closest non-LLM prior work is DnD (USENIX Sec. '22) and BTD (USENIX Sec. '23). Both evaluate CNN-style models only and report no transformer results (DnD: MNIST, ResNet, MobileNetV2; BTD: ResNet18, VGG16, Inception, ShuffleNet, MobileNet, EfficientNet, FastText). In our Table 3b, BTD fails on all three transformer models. DnD cannot represent recurrent structures and supports 59 of 70 ONNX operators; BTD lacks four quantized operators and RNN/LSTM support. Both are CPU-only, so TensorRT GPU plans are out of scope, and both assume unobfuscated binaries (BTD leaves obfuscation to future work). NeuroProbe handles transformers, TensorRT plans and name-stripped binaries, at operator/family level rather than full model recovery; BTD still does better on MobileNet-V3-Large (82.1 vs. 80.0, Table 3b).

Overhead. Only 59.9M parameters (≈1.9%) are trained, on a 4-bit NF4 base (≈2.1 GB VRAM). On a single NVIDIA A100, SFT (two stages) took ≈87 min, GRPO rollouts 62 min for 400 prompts, and GRPO updates ≈53 min per epoch (2 epochs). Inference with K=3 chains takes ≈8 s per kernel (≈16 min per 120 kernels). XGBoost runs on CPU. The LLM is therefore the main cost and is the price of auditable rationales; the prior alone is near-free. We have added these figures to the revision.

2. 48 Bytes and 120 Functions (W2)

Symbols under 48 B are thunks, PLT stubs and trampolines, not compiled operator kernels: they carry no operator semantics, and our labels (taken from compiler-emitted kernel names) never assign them an operator. Dropping them removes non-targets, not hard cases. Each binary then keeps up to 120 functions: the 60 largest (so compute-heavy kernels are always present) plus 60 drawn at random from the rest (so small elementwise and layout operators, i.e. the long tail, are still represented), re-sorted by address so adjacency and topology are preserved.

Why it cannot favour NeuroProbe. The same filter and cap are applied to training and test binaries, and every compared method is scored on the same retained kernels. Any effect of the cutoff or cap therefore shifts all methods together and cannot create the gaps in Tables 1 and 3b.

3. SFT Data and Reasoning Targets (W3)

Training is a two-stage curriculum: Stage 1 uses clean prompts; Stage 2 obfuscates 50% of them (hashed names, name features zeroed). In both stages each training model contributes at most 90 kernels, 30% of prompts drop the PRIOR line (Prior Dropout, p=0.30), and a separate group of training models is used for validation. Stage 1 uses 1,609 clean training pairs; Stage 2 uses the same 1,609-pair pool, balanced between 805 clean and 804 obfuscated pairs. Each stage also uses 124 validation pairs. GRPO then uses 400 prompts, half of them obfuscated.

The reasoning data are not written by a frontier LLM. A deterministic teacher builds every target: EVIDENCE is computed only from values present in the prompt (instruction-class ratios, SIMD width, leading mnemonics, byte statistics); PRIOR is copied from the XGBoost posterior; CONSTRAINTS are rule-based checks over instruction ratios and neighbor predictions; the final answer lines come from the ground-truth labels. Chains are therefore grounded and reproducible by construction, and the GRPO grounding reward (0.14) penalizes evidence not found in the prompt. The generator will be released with the code.

4. Raw Assembly or Feature Vector (Q)

The LLM sees neither the full disassembly nor the raw 71-dim vector. For ELF binaries, the ASM/BYTES block has an ASM line (instruction-class ratios, SIMD width, loop counts) and a RAW line with the leading mnemonic sequence (first 40 mnemonics, operands removed). TensorRT plans have no disassembly and get a BYTES line (byte entropy, fp32 density, zero ratio). So both are used: a histogram-style summary plus a short mnemonic window. Sec. 3.2 describes the summary, and Figure 4 shows the mnemonic window with operands; we have made both consistent with this description and corrected Figure 4.

We hope this addresses all concerns. Please let us know if any remain.

Dear Reviewer, Thank you again for your thoughtful review. As the discussion period nears its end, we would be grateful to know whether our responses have resolved your concerns, and we are happy to clarify anything further. Thank you for your time

Thanks for your detailed response. The clarification regarding the LLM inputs and data compsotion are helpful and address several of my questions. However, concerns about the effectiveness of the LLM componenets and hyperparameter sensitivity analyses remain insufficiently addresed. Therefore, I'd raise my soundness scores only.

Reviewer_zEE4OpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper presents an LLM-aided approach to reverse-engineer a neural network architecture from (possibly obfuscated) binary inputs. It places special focus on incorporating leak-free information from adjacent predictions.

Critical strengths

Reverse-engineering of neural network architectures from (obfuscated) binaries is generally interesting and their evaluation shows that this is indeed possible with their method (even surpassing commercial zero shot LLMs).

Critical weaknesses
  • Pipeline definition. The paper's core problem is its focus on methodological details regarding the language model optimization (Section 3) instead of a more precise definition of the overall setting. The largest missing pieces for me are:

    • What is the concrete output schema and classes (hinted at in Section 2.1) that is supposed to be predicted by the pipeline (i.e., the S in Y=[C;S])? What are the relations between (S, O_k, Y_i) and (x_k, P_i)?
    • How is the XGBoost training done to make "spatial adjacent predictions"; what are its inputs and outputs; and how does this enforce information-theoretical isolation (e.g., couldn't there be train-test leakage because the adjacent predictions leak information to the LLM)?
    • How is the dataset constructed and, since the accuracy of the method is reported, how are the predicted "classes" distributed? How is accuracy even measured, if the schema is a complex JSON object?

    The paper would be strengthed if the authors address these questions and make the pipeline's input / output and dataset more explicit.

  • Evaluation. The paper's evaluation is quite short. Given the complex output format, I am unsure how to interpret the provided metrics (e.g., How are topological differences evaluated? How are recall and precision defined in this dynamic context?). Further, I noticed that NeuroProbe is compared against zero-shot LLMs for the obfuscated task (Table 1), but not for the unobfuscated task. In Table 2a), NeuroProbe is only compared against a (weak) Qwen baseline in terms of accuracy(??). Overall, I find the evaluation hard to interpret given the unclear definition of outputs and how evaluation metrics are defined.

  • Minor. I think Section 3 currently takes a bigger focus than necessary, especially since other aspects (as described above) could be handled instead. A lot of these sections appear more like engineering efforts to increase performance or reduce memory usage that methodological improvements on effectiveness. Further, Section 3.3.1 discusses the choice of Qwen-2.5-3B-Instruct which I find unclear for two reason: 1) The choice is motivated by running on low-latency inference on edge-constrained hardware, but I do not see a reason why reverse-engineering should be restricted (or useful) in that environment, 2) the claim "As delineated in Table 1, Qwen2.5-3B-Instruct demonstrates superior code understanding compared to alternative open-weights LLMs" does not follow from the evaluation. Table 1) shows Qwen performing in the NeuroProbe framework against zero shot LLMs in the obfuscated setting; this does not show that Qwen is somehow superior. Lastly, the origins of the scaling hyperparameters in 3.5.1 are unclear.

Questions for authors
  • How are the evaluation metrics defined over the (complex) output structures?
  • How is XGBoost trained? How is accidental data-leakage prevented?
  • How does NeuroProbe compare against zero shot LLMs in the unobfuscated setting?
2 comments

We thank the reviewer. We clarify the pipeline, dataset and metrics below; all of this has been added to the revised paper.


1. Output Schema (W1/Q1)

The model output is Yi=[Ci;Si]:

  • Ci (reasoning chain): EVIDENCE, PRIOR, CONSTRAINTS, HYPOTHESIS, CHECK.
  • Si (structured answer): three key-value lines, parsed deterministically. Only Si is scored.
    • OPERATORS: a set from a closed 26-class vocabulary (appendix)
    • ARCHITECTURE {CNN, Transformer, Hybrid}
    • CONFIDENCE [0,1]

Inputs:

  • xk: 71-dim features, 45 name-independent and 26 name features (zeroed under obfuscation).
  • O^k=arg⁡max⁡OP(O∣xk;XGB)\hat O_k=\arg\max_O P(O\mid x_k;\mathrm{XGB})
  • Pi: FUNCTION metadata, ASM/BYTES summary, PRIOR (XGBoost posteriors) and CONTEXT (Oi1).

Inference: Yi is sampled K=3 times; parsed operator sets are verifier-weighted and fused 0.5/0.5 with the XGBoost posterior to give oi (Alg. 1, l.10).


2. XGBoost and Leakage (W1/Q2)

Classifier: XGBops_obf is one class-balanced binary XGBoost per operator, trained only on training-model kernels using the 45 name-independent features, mapping xk to a 26-way posterior; XGBarch gives the family posterior.

Split: By model, family-stratified, with 7 held-out models ([LIST] in Table 7), asserted in code. Test models are never used for XGBoost, SFT, GRPO or tuning; validation uses training-model holdouts.

No label leakage: At test time, CONTEXT comes from this classifier on the test binary's own name-blind features. No ground-truth label or symbol name enters any prompt. Neighbor predictions are adversary-computable and label-free, unlike prior methods using annotations or names.

Revision: "mutual information is identically zero" → "no ground-truth label enters the prompt".


3. Dataset and Classes (W1)

Compilation and features

ComponentDetails
ELFfunctions 48 B; Capstone features
TensorRTASCII descriptors from three 48 MB windows; byte statistics in 4 KB windows

Labels: From compiler-emitted names in the unobfuscated build via a fixed, released lexicon. Fused kernels get every operator in their name and are scored as sets. Obfuscation hashes names and zeroes name features; labels are unchanged. Over 99% of records have one operator (1.007 avg.).

Distribution: Families are 59.0% CNN, 35.8% Transformer, 5.1% Hybrid (Table 7). The n=120 set is compiler-stratified (55% TensorRT, 24% TVM, 21% IREE; Table 2b) and covers all 7 held-out models. Majority-class family baseline is 52.9% vs. 95.8% Arch/Kern. Operators are long-tailed, hence Macro F1 (histogram in appendix).

Why obfuscation is the headline setting:

Input (clean binaries)Operator F1
Names only98.9%
Names + assembly98.9%
Assembly only83.7%

Assembly-only reaches 80.5% Exact. Names alone are near-perfect on clean binaries, so obfuscation is our headline setting.


4. Metrics (W2/Q1)

Parsed per line; unparseable = wrong. Per kernel:

precision=|predtrue||pred|,recall=|predtrue||true|

MetricDefinition
Operator F1Mean per-kernel F1
Macro F1Per-operator average
ExactSet equality
Arch/KernPer-kernel family accuracy
Arch/BinAccuracy of confidence-weighted per-binary vote

Topology is deterministic (Alg. 1, l.13–14): address-ordered edges plus family-schema residuals, so it follows from operator and family accuracy.


5. Tables 2a/5 (W2)

Clarifications and corrections

  • "Qwen" in Table 2a is the fine-tuned reasoner alone, before fusion, scored in Operator F1.
  • We fixed the "Zero-Shot" label in Table 5 and "binary instances" → "kernel instances" (Sec. 4.1).

Component analysis (same n=120 set, Operator F1)

SettingPrior alone
Clean99.2%
Obfuscated81.0%
  • Fusion beats both components on clean binaries; under obfuscation, the name-blind prior carries most of the signal. This is itself a security finding: stripping identifiers leaves substantial information in instruction statistics.

6. Clean Zero-Shot LLMs (Q3)

ModelOperator F1 (clean)
NeuroProbe99.7%
Claude Opus86.5%
GPT-4o79.6%
DeepSeek77.8%
Llama 4 Maverick73.0%

On Exact, NeuroProbe reaches 99.2% vs. 68.3% for Opus; under obfuscation the gap is +12.6 Operator F1 and +30.9 Exact (Table 1). Added to the paper.


7. Minor

  • Claims: We drop the "superior code understanding" and edge-hardware claims. The motivation: auditors cannot upload proprietary binaries to third-party APIs; NF4 with 59.9M LoRA parameters fits in ~2.1 GB.
  • Reward weights: Set heuristically, not tuned on test data (0.52 on correctness).
  • Section 3: Now focuses on leak-free context, SCA-CoT and Prior Dropout; NF4/LoRA/padding moves to the appendix.

We hope this addresses all concerns.

Dear Reviewer, Thank you again for your detailed review. As the discussion period is coming to a close, we wanted to check whether our responses have addressed your concerns, or whether any points would benefit from further clarification. We would be glad to answer any remaining questions. Thank you for your time.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.