Pith. sign in

REVIEW 3 major objections 4 minor 78 references

Disa: Accurate Learning-based Static Disassembly with Attentions

T0 review · 3 major / 4 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This paper argues that all three hard boundary decisions in static disassembly—function entries, true instructions, and memory-block boundaries—can be learned as binary classifications over superset-decoded instructions, and that the…

desk verdict Worth a serious referee, but push on the DWARF ground truth and the DeepDi/BPA baselines. read the letter →

arxiv 2507.07246 v1 pith:4VQJB7JX submitted 2025-07-09 cs.CR

Peicheng Wang , Monika Santra , Mingyu Liu , Cong Sun , Dongrui Zeng , Gang Tan This is my paper · ORCID
classification cs.CR
keywords staticdisassemblyfunctionentry-pointidentificationmemoryblockboundaryself-attentionsupersetindirectcalltargetcontrolflowgraphrecoverybinaryobfuscation
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Disa sets out to show that the three hardest boundary decisions in static disassembly—where functions begin, which decoded instructions are real, and where memory blocks corresponding to source-level data structures start and end—can all be learned as binary classifications over a superset of decoded instructions. The paper's core move is to feed each superset instruction's field encoding through a transformer encoder, letting multi-head self-attention capture long-range correlations that byte-level models miss, and then to feed the learned memory-block boundaries into a block-memory points-to analysis. If the approach is right, obfuscated binaries that desynchronize linear disassembly become tractable, and static CFG recovery resolves indirect calls more precisely: the paper reports 9.1% and 13.2% F1 gains in function-entry recovery on desynchronized and source-level-obfuscated binaries, 18.5% higher memory-block precision, and 4.4% fewer average indirect call targets.

What carries the argument

The carrying mechanism is the superset instruction sequence $SI$ with learned per-field and positional embeddings, passed through a 6-layer transformer encoder with 8 attention heads and embedding dimension 384. For T3, the encoding adds the memory region $\mathrm{Rgn}$ and relative displacement $\mathrm{Disp}$, so attention learns which memory-access patterns touch compound-data-structure boundaries. The second piece is boundary-targeted value tracking (bVTR): an intra-procedural value-set analysis that converts each predicted BRel instruction's memory operand into offsets from the initial $\mathtt{esp}$ or from a global section, producing the actual memory-block boundaries consumed by the block-memory points-to analysis.

What would settle it

Compile a corpus of stripped binaries from code that intentionally performs pointer arithmetic across adjacent source-level objects (e.g., container_of macros, flexible array members, or manual memory pooling), then compare Disa's memory-block predictions against manually verified boundaries; if precision drops to roughly the heuristic baseline's level on those binaries, the DWARF-ground-truth assumption is the reason.

Watch

Extended reading notes

Core claim

The central claim is that disassembly reduces to classifying instructions in a superset, and that the same transformer encoder can perform all three classifications. For tasks T1 and T2, instructions are encoded as integer triples (opcode, ModRM, SIB); for T3, memory-access and branching instructions are encoded as quintuples that add a memory region and a relative displacement. The model labels function-entry instructions, true instructions, and block-boundary-related (BRel) instructions, and a lightweight intra-procedural value-tracking pass converts BRel labels into concrete block boundaries as offsets from a function's initial stack pointer or from global section starts. Fed into block-memory points-to analysis, these boundaries replace heuristic blocks and reduce the ambiguity of indirect-call targets, yielding assembly-level CFGs, which Disa claims no previous deep-learning disassembler did.

Load-bearing premise

The load-bearing premise, stated in Section 3.3.1, is that memory-block boundaries extracted from DWARF debugging metadata are true boundaries, meaning pointer arithmetic never deliberately crosses source-level data structure boundaries; if a real binary violates that, the T3 training labels and measured precision gains inherit the error.

Editorial extensions

If this is right

  • If Disa's classification of superset instructions is correct, function and instruction boundary recovery no longer needs per-architecture disassembly heuristics or a hand-built instruction-flow graph for the deep model.
  • If T3's memory-block boundaries are as accurate as reported, block-memory points-to analysis can drop its conservative heuristic blocks, sharpening points-to sets and removing spurious indirect-call edges from binary CFGs.
  • On binaries obfuscated by disassembly desynchronization and source-level transforms, function-entry F1 gains of 9.1% and 13.2% imply that instruction-level context, not raw byte statistics, is what lets a disassembler resist those obfuscations.
  • Because all three tasks share one encoder architecture and differ only in input fields and labels, the same pipeline can be retrained for new boundary-like classification tasks without redesign.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The paper's instruction-level BRel prediction cannot distinguish multiple block boundaries touched by one instruction, so array and loop accesses can smear several candidate boundaries into one label; an operand-level or element-level supervision signal is the natural next experiment.
  • The DWARF-ground-truth dependency suggests a boundary curriculum: train on debug-rich binaries, then distill onto stripped binaries using the model's own high-precision BRel predictions as pseudo-labels.
  • The same BRel idea should transfer to object-boundary consumers beyond CFG recovery, such as memory sanitization for binary fuzzing or type-assisted control-flow integrity.
  • A cleaner isolation test of T3's contribution would hold function and instruction boundaries fixed and vary only the memory-block source; the paper's ablation varies T1 and T2 together, so the marginal value of learned boundaries alone is not fully separated.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. The paper presents Disa, a learning-based static disassembly framework built on a transformer encoder over superset instructions. Disa addresses three tasks: function entry-point identification (T1), true instruction identification (T2), and a newly introduced memory block boundary identification (T3), where a BRel-instruction classifier is combined with an intra-procedural value-tracking analysis (bVTR) to recover memory block boundaries. These boundaries are then fed into the block-memory-model points-to analysis BPA to refine indirect call targets and improve CFG recovery. The evaluation compares Disa with XDA, biRNN, DeepDi, IDA Pro, Ghidra, and Binary Ninja on non-obfuscated, real-world, and obfuscated binaries (desync-cc, OLLVM, Tigress, VMProtect, Themida), and compares BPADisa with BPA and a DWARF-oracle version of BPA. The headline results are 9.1% and 13.2% F1 improvements over prior deep-learning approaches on desync-cc- and Tigress-obfuscated binaries, 18.5% memory-block precision improvement over BPA, and a 4.4% AICT reduction.

Significance. The T3 contribution is potentially significant: using deep learning to predict memory block boundaries, rather than instruction/function boundaries alone, is a new direction that directly targets a known bottleneck in binary-level points-to analysis. The paper is also strong in evaluation breadth: multiple compilers, optimization levels, file formats, obfuscators, and real-world corpora, with held-out splits and a publicly available implementation. The ablation study with BPA variants and the comparison against a DWARF-based upper bound are useful. However, the strength of the central claims is currently limited by three load-bearing concerns: the T3 labels and evaluation share the same DWARF-derived oracle, the obfuscated instruction ground truths are incomplete and use a permissive one-byte overlap rule, and the comparison with DeepDi is against a frozen reference model not trained on the same data. These issues are addressable, so the work is worth revising rather than rejecting.

major comments (3)
  1. [§3.3.1] The DWARF-derived memory block boundary ground truth is used both to generate BRel training labels (via iVTR in Algorithm 2) and to score Disa's memory block predictions and the BPADWARF upper bound. Section 3.3.1 explicitly assumes that pointer arithmetic does not cross source-level data structure boundaries, and also reports that DWARF location information is sometimes missing and requires a custom prologue analysis. If the prologue analysis mis-handles frame-pointer omission, stack realignment, or unusual prologues, all stack boundaries for a function shift, and the same shift is baked into training, evaluation, and the BPADWARF reference. The model could therefore be learning the DWARF-extraction heuristics rather than true block boundaries, and the reported 18.5% precision gain and 4.4% AICT reduction could partly reflect this shared-oracle bias. Please provide a sensitivity analysis: e.g., perturb the prologue offset by one word per function and report the resulting change in BRel label noise, memory-block precision, and AICT; additionally, manually audit a random sample of SPx86_test blocks against source code and report the fraction of DWARF boundaries that are missing or displaced. Without such validation, the T3 claim should be framed as aligned with DWARF-based boundaries rather than as ground-truth memory block recovery.
  2. [§5.1.1] The instruction ground truths for obfuscated binaries are sound-but-incomplete Pin traces, and a predicted instruction is treated as positive if it overlaps at least one byte with a runtime-reached true instruction; predictions in unknown slots are excluded from the denominator. This can inflate T2 precision/F1: a model that emits many incorrect instructions in unreached code, or whose boundaries are shifted but overlapping, is not penalized. Since the paper makes robustness claims on obfuscated binaries and uses T2 in the integrated BPA ablation, please report additional conservative metrics: (a) treating unknown regions as negative, (b) requiring exact instruction-boundary matches, and (c) segment-level overlap rather than one-byte overlap. Also report the fraction of test-set bytes that fall into unknown slots for each obfuscator and optimization level, and show how F1 changes when those slots are excluded versus included.
  3. [§5.2] DeepDi is compared only as a reference model obtained through its released APIs, not retrained or finetuned on the same 90% training split used for Disa-SN and the other baselines. The claimed superiority over DeepDi (including the 9.1% F1 gain on desync-cc binaries) may therefore be attributable to differences in training data distribution, compiler coverage, or hyperparameters rather than to the proposed architecture. To support the 'outperforms prior deep-learning approaches' claim, please either train DeepDi on the identical SN training split (or a clearly documented equivalent), or explicitly narrow all such claims to 'Disa-SN vs. the released DeepDi reference model' and add a discussion of how training-data differences might confound the comparison.
minor comments (4)
  1. [Contribution 2] The claim that Disa is 'the first disassembly approach that can identify memory block boundaries at the binary level' should be positioned against prior binary type and data-structure recovery work such as TypeMiner and OSPREY; the current text asserts novelty without describing how those approaches differ in task formulation or evaluation.
  2. [§5.5.2] The paper states that a reevaluation of BPA found an implementation issue that changes the original results, but it does not specify the fix. Please document the corrected BPA behavior, the affected code, or release a patch, since the baseline numbers in Table 3 and the ablation depend on this correction.
  3. [§5.3 / §5.4 / §5.5] Several heatmaps (Figs. 6, 7, 10, 12, 15, 17) are difficult to read at the available resolution because the underlying cell values are not printed numerically. Please provide the corresponding numeric tables in an appendix so that readers can verify the reported F1, precision, recall, and AICT values.
  4. [Appendix A] The training procedure reports only that XDA finetuning takes several days per epoch; please report the number of epochs, early-stopping criterion, learning rate, and random seed for all deep models to support reproducibility.

Circularity Check

0 steps flagged · score 1.0 of 10

No significant circularity: Disa's central results are supervised models evaluated on held-out binaries against external ground truths, and the author-overlap with BPA is a baseline comparison, not a derivation.

full rationale

The claimed derivation chain is empirically supervised, not definitionally circular. For T1 and T2, the models are trained on a 90% subset of the SN dataset and tested on the held-out 10% plus the separate SR and SO corpora, with ground truths taken from symbol tables, linear disassembly, and runtime Pin instrumentation that are independent of the learned model. For T3, the BRel classifier is trained on SPx86_train using labels produced by iVTR from DWARF information, and it is evaluated on SPx86_test, a different compiler and benchmark set whose DWARF-derived blocks are used only for scoring, not for fitting. The paper states the training and testing separation explicitly: "The labeled instructions extracted from SPx86_train are then employed to train the Disa deep model for T3, while the ground truth BRel instructions from SPx86_test are utilized for evaluations in Section 5.5." Thus the memory-block precision improvement over BPA is a genuine held-out generalization result, not a fitted input renamed as a prediction. The BPADWARF reference also uses DWARF blocks, but it serves as an upper-bound baseline, and the AICT comparison with BPA is computed by running the independently published BPA implementation with different memory-block inputs. The author overlap with BPA [32] is a self-citation, yet BPA is a separately published and externally evaluated system, so the comparison does not reduce to an unverified self-supporting premise. The manuscript itself flags the load-bearing validity risk that DWARF may be incomplete or imprecise: "we encounter location information missing particularly in cases where the location information includes complex DWARF stack details, such as pointer deference, which cannot be resolved statically," and it concedes that "Disa's intra-procedural value tracking fails to account for global accesses that are passed through function arguments." These are correctness limitations of the oracle and analysis, not circularity, because a flawed oracle would bias the training labels and the evaluation metric in the same direction for any model, which is a measurement-validity concern distinct from a claim that reduces to its own inputs by construction.

Assumptions & free parameters 10 free parameters · 8 assumptions · 1 invented entities

The central claims rest on supervised learning over instruction representations derived from superset disassembly, with labels from symbol tables, linear disassembly, DWARF, and runtime Pin traces. Hand-chosen hyperparameters and heuristic feature extraction (Rgn, Disp range) are the main free parameters. The DWARF-as-ground-truth assumption and the incomplete Pin-based ground truths for obfuscated binaries are the most consequential domain assumptions.

free parameters (10)
  • Input sequence length L = 512
    Fixed-length window for transformer encoder input; chosen by hand in Section 4.
  • Embedding dimension d_model = 384
    Dimension of concatenated field embeddings; set in Section 4.
  • Number of encoder layers = 6
    Transformer depth; set in Section 4.
  • Number of attention heads = 8
    Self-attention heads; set in Section 4.
  • Batch size = 16
    Training batch size; set in Section 4.
  • Focal loss alpha and gamma = not specified
    Alpha-balanced focal loss used for class imbalance; exact values are not stated in Section 4.
  • Disp discretization range [lower, upper] = [-1024, 1024]
    Relative displacement is encoded exactly only inside this range; values outside are collapsed to <lower or >upper (Section 3.1).
  • Rgn heuristic patterns = hand-designed
    Pattern matching rules for memory region of each instruction (heap, stack, data, bss, rodata, unknown) in Section 3.1.
  • One-byte overlap positive criterion = 1 byte
    On incomplete obfuscated ground truths, a prediction is positive if it overlaps at least one byte with a runtime-reached true instruction (Appendix A, Fig. 14).
  • Coverage exclusion threshold = 5%
    Obfuscated binaries with less than 5% runtime instruction coverage are excluded from evaluation (Appendix A).
assumptions (8)
  • domain assumption Superset disassembly via Capstone yields every true instruction as a candidate, so there are no instruction-level false negatives.
    Section 3.1: decode(b, i) is applied at each offset; relies on the decoder covering the ISA. Follows [11].
  • domain assumption DWARF debugging information gives precise memory block boundaries, and pointer arithmetic never crosses source-level data structure boundaries.
    Section 3.3.1 states 'Assuming that pointer arithmetic should not cross the boundary of source-level data structures, memory blocks extracted from debugging information can be treated as ground truth.'
  • domain assumption GCC and Clang never inline data into the code section, so linear disassembly provides instruction ground truth for those binaries.
    Section 5.1.1, citing [6].
  • domain assumption Runtime Pin traces under standard workloads give sound but incomplete instruction ground truth for obfuscated binaries, and unreached bytes are neither positive nor negative.
    Section 5.1.1 and Appendix A; used for S_O metrics.
  • domain assumption The block memory model of BPA holds: pointer arithmetic cannot make a pointer to one block point to a different block.
    Section 2.3, inherited from [32].
  • domain assumption FuncWiseVSA value-set analysis is precise enough to resolve memory operands to block boundary offsets, with heap values ignored.
    Section 3.3 and Algorithms 1 and 2; heap-valued offsets are discarded as unknown.
  • domain assumption Deduplication of length-L input sequences removes train-test overlap.
    Section 5.1: 'We deduplicate the length-L input sequences in each sub-dataset of SN to avoid the train-test overlap [46].'
  • standard math Standard mathematical and architectural background for transformer attention.
    Transformer encoder from [62] is used as given; no modification is introduced.
invented entities (1)
  • Block-Boundary-Related (BRel) instruction
    purpose: An instruction predicted by T3 whose memory accesses are then converted by bVTR into memory block boundaries for BPA.
    The concept is defined and labeled via DWARF-derived ground truth within this paper; there is no external empirical handle beyond the paper's own evaluation and released code.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Disa: Accurate Learning-based Static Disassembly with Attentions." pith.science (2026). https://pith.science/paper/4VQJB7JX

@misc{pith2026250707246,
  author       = {Pith},
  title        = {Pith review of: Disa: Accurate Learning-based Static Disassembly with Attentions},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/4VQJB7JX}},
  note         = {Machine review of arXiv:2507.07246}
}
read the original abstract

For reverse engineering related security domains, such as vulnerability detection, malware analysis, and binary hardening, disassembly is crucial yet challenging. The fundamental challenge of disassembly is to identify instruction and function boundaries. Classic approaches rely on file-format assumptions and architecture-specific heuristics to guess the boundaries, resulting in incomplete and incorrect disassembly, especially when the binary is obfuscated. Recent advancements of disassembly have demonstrated that deep learning can improve both the accuracy and efficiency of disassembly. In this paper, we propose Disa, a new learning-based disassembly approach that uses the information of superset instructions over the multi-head self-attention to learn the instructions' correlations, thus being able to infer function entry-points and instruction boundaries. Disa can further identify instructions relevant to memory block boundaries to facilitate an advanced block-memory model based value-set analysis for an accurate control flow graph (CFG) generation. Our experiments show that Disa outperforms prior deep-learning disassembly approaches in function entry-point identification, especially achieving 9.1% and 13.2% F1-score improvement on binaries respectively obfuscated by the disassembly desynchronization technique and popular source-level obfuscator. By achieving an 18.5% improvement in the memory block precision, Disa generates more accurate CFGs with a 4.4% reduction in Average Indirect Call Targets (AICT) compared with the state-of-the-art heuristic-based approach.

Figures

Figures reproduced from arXiv: 2507.07246 by the authors.

Figure 1
Figure 1. Workflow of Disa struct discard_rule { void (*condition)(); int flag; } rules[] = {{fptr1, 0}, {fptr2, 1}, {fptr3, -1}}; void discard_moves(){ int i, user_f; for(i=0;i<3;++i){ rules[i].condition(); user_f = rules[i].flag; } rules[2].condition(); ... } <discard_moves>: [Ord] [Inst] [Rgn, Disp] [BRel] 319: mov [ebp - 0xc]4, 0 (stack, -12) X 322: add [eax]1, al (unkn., ) 323: add [eax]1, al (unkn., ) 324: add [eax]1,… view at source ↗
Figure 2
Figure 2. Example with Auxiliary Features and BRel Instruc￾tions (upper=lower=1024, .data is [0x804a010, 0x804a02f]). SIB, and Displacement2 . If we cannot track the region of a memory￾access expression during the instruction-decoding procedure, Rgn is labeled unknown. The instruction’s relative displacement Disp is the offset from a base addressing expression in the data sections or a stack frame. For encoding convenience, D… view at source ↗
Figure 3
Figure 3. Value Tracking with Boundary Identification [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (10 more)
Figure 6
Figure 6. Figure 6: T1 Accuracy Heatmaps on Different Platforms and ISA Variants using DWARF-based memory blocks as the ground truth reference. To define the precision, recall, and F1-score in this scenario, a true positive (TP) indicates a correctly generated memory block that aligns wit…
Figure 8
Figure 8. Figure 8: T1 Cross-Optimization-Level Generalizability Heatmap on Real-World x64-ELF Binaries in SRx64 ELF, as presented in [PITH_FULL_IMAGE:figures/full_fig_p010_8.png]
Figure 9
Figure 9. Figure 9: Generalizability Heatmap on Real-World Binaries [PITH_FULL_IMAGE:figures/full_fig_p011_9.png]
Figure 11
Figure 11. Figure 11: T2 Generalizability Heatmap in Predicting VM￾Protect and Themida-obfuscated PE binaries compiler optimizations to the obfuscation, which was assumed by [46], and the compiler optimizations are disabled by [46, 69]. In many cases, the deep models have lower effectivene…
Figure 12
Figure 12. Figure 12: Effectiveness Heatmap of Disa on Deciding Mem￾ory Block Boundaries Compared with BPA (in Percentage) 5.5.1 Effectiveness On Memory Block Boundary Generations. We compared the memory block generation of Disa with that of BPA’s heuristic-based approach in terms of preci…
Figure 13
Figure 13. Figure 13: Task T2 Efficiency on Obfuscated Binaries original BPADisa, especially for larger and more highly optimized binaries like gobmk and perlbench. In addition, it maintains a high recall rate for the majority, indicating its overall capability of cov￾ering the attack surf…
Figure 14
Figure 14. Figure 14: Classification Definition on Incomplete Ground [PITH_FULL_IMAGE:figures/full_fig_p016_14.png]
Figure 15
Figure 15. Figure 15: T2 Accuracy Heatmaps on Different Platforms and [PITH_FULL_IMAGE:figures/full_fig_p016_15.png]
Figure 16
Figure 16. Figure 16: T2 Generalizability Heatmap in Predicting Unseen Real-World x64-ELF Binaries O0 O1 O2 O3 DISA-SN XDA-SN biRNN-SN DEEPDIref IDAPro Ghidra DISA-SN x64 ELF XDA-SN x64 ELF biRNN-SN x64 ELF Tool 0.984 0.979 0.978 0.978 0.997 0.998 0.998 0.998 0.968 0.961 0.962 0.962 0.996 …
Figure 17
Figure 17. Figure 17: T2 Generalizability Heatmap in Predicting Obfus￾cated Binaries at Different Optimization Levels Disassembly. In 31st USENIX Security Symposium. USENIX Association, 2709– 2725. [70] Naville Zhang. 2019. Hikari – an improvement over obfuscator-llvm. https: //github.com/…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

78 extracted references · 76 canonical work pages

  1. [32]

    Sun Hyoung Kim, Cong Sun, Dongrui Zeng, and Gang Tan. 2021. Refining Indirect Call Targets at the Binary Level. In NDSS’21. The Internet Society

    work page 2021

  2. [1]

    DWARF Debugging Information Format Version 4

    2010. DWARF Debugging Information Format Version 4. https://dwarfstd.org/ doc/DWARF4.pdf

    work page 2010

  3. [2]

    Obfuscator-LLVM

    2013. Obfuscator-LLVM. http://o-llvm.org

    work page 2013

  4. [3]

    C tutorial for Capstone

    2014. C tutorial for Capstone. https://www.capstone-engine.org/lang_c.html

    work page 2014

  5. [4]

    desync-cc — Automatic Disassembly Desynchronization Obfuscator

    2021. desync-cc — Automatic Disassembly Desynchronization Obfuscator. https: //github.com/UlfKargen/desync-cc

    work page 2021

  6. [5]

    Dia2dump Sample

    2024. Dia2dump Sample. https://learn.microsoft.com/en-us/visualstudio/ debugger/debug-interface-access/dia2dump-sample?view=vs-2022

    work page 2024

  7. [6]

    Dennis Andriesse, Xi Chen, Victor van der Veen, Asia Slowinska, and Herbert Bos. 2016. An In-Depth Analysis of Disassembly on Full-Scale x86/x64 Binaries. In 25th USENIX Security Symposium . USENIX Association, 583–600

    work page 2016

  8. [7]

    Dennis Andriesse, Asia Slowinska, and Herbert Bos. 2017. Compiler-Agnostic Function Detection in Binaries. In EuroS&P’17. IEEE, 177–189

    work page 2017

Show all 78 references
  1. [8]

    Gogul Balakrishnan and Thomas W. Reps. 2004. Analyzing Memory Accesses in x86 Executables. In CC’04 (LNCS, Vol. 2985). Springer, 5–23

    2004

  2. [9]

    Tiffany Bao, Jonathan Burket, Maverick Woo, Rafael Turner, and David Brumley

  3. [10]

    Sébastien Bardin, Robin David, and Jean-Yves Marion. 2017. Backward-Bounded DSE: Targeting Infeasibility Questions on Obfuscated Codes. In SP’17. IEEE, 633–651

    2017

  4. [11]

    Erick Bauman, Zhiqiang Lin, and Kevin W. Hamlen. 2018. Superset Disassembly: Statically Rewriting x86 Binaries Without Heuristics. In NDSS’18. The Internet Society. Disa: Accurate Learning-based Static Disassembly with Attentions CCS ’25, October 13–17, 2025, Taipei, Taiwan

    2018

  5. [12]

    Ammar Ben Khadra, Dominik Stoffel, and Wolfgang Kunz

    M. Ammar Ben Khadra, Dominik Stoffel, and Wolfgang Kunz. 2016. Speculative disassembly of binary code. In CASES’16. ACM, 16:1–16:10

    2016

  6. [13]

    Eli Bendersky. 2011. pyelftools. https://github.com/eliben/pyelftools

    2011

  7. [14]

    Hadjer Benkraouda, Nirav Diwan, and Gang Wang. 2025. You Can’t Judge a Binary by Its Header: Data-Code Separation for Non-Standard ARM Binaries Using Pseudo Labels. In SP ’25. IEEE, 3727–3745

    2025

  8. [15]

    Bernat and Barton P

    Andrew R. Bernat and Barton P. Miller. 2011. Anywhere, any-time binary instru- mentation. In PASTE’11. ACM, 9–16

    2011

  9. [16]

    Fernandez, Jean-Yves Marion, Benjamin Rouxel, Fabrice Sabatier, and Aurélien Thierry

    Guillaume Bonfante, José M. Fernandez, Jean-Yves Marion, Benjamin Rouxel, Fabrice Sabatier, and Aurélien Thierry. 2015. CoDisasm: Medium Scale Concatic Disassembly of Self-Modifying Binaries with Overlapping Instructions. InCCS’15. ACM, 745–756

    2015

  10. [17]

    Schwartz

    David Brumley, Ivan Jager, Thanassis Avgerinos, and Edward J. Schwartz. 2011. BAP: A Binary Analysis Platform. InCA V’11 (LNCS, Vol. 6806). Springer, 463–469

    2011

  11. [18]

    Juan Caballero and Zhiqiang Lin. 2016. Type Inference on Executables. ACM Comput. Surv. 48, 4 (2016), 65:1–65:35

    2016

  12. [19]

    Xingman Chen, Yinghao Shi, Zheyu Jiang, Yuan Li, Ruoyu Wang, Haixin Duan, Haoyu Wang, and Chao Zhang. 2023. MTSan: A Feasible and Practical Mem- ory Sanitizer for Fuzzing COTS Binaries. In 32nd USENIX Security Symposium . USENIX Association, 841–858

    2023

  13. [20]

    Christian Collberg. [n. d.]. The Tigress C Obfuscator. https://tigress.wtf/index. html

  14. [21]

    Cryptic Apps. [n. d.]. Hopper: The macOS and Linux Disassembler. https: //www.hopperapp.com

  15. [22]

    Alessandro Di Federico, Mathias Payer, and Giovanni Agosta. 2017. rev.ng: a unified binary analysis framework to recover CFGs and function boundaries. In CC ’17. ACM, 131–141

    2017

  16. [23]

    Antonio Flores-Montoya and Eric M. Schulte. 2020. Datalog Disassembly. In 29th USENIX Security Symposium. USENIX Association, 1075–1092

    2020

  17. [24]

    GNU. 2023. GNU Binutils 2.40. https://www.gnu.org/software/binutils

    2023

  18. [25]

    Guthaus, J.S

    M.R. Guthaus, J.S. Ringenberg, D. Ernst, T.M. Austin, T. Mudge, and R.B. Brown

  19. [26]

    Jingxuan He, Pesho Ivanov, Petar Tsankov, Veselin Raychev, and Martin T. Vechev

  20. [27]

    Hex-Rays. 2021. IDA Pro. https://hex-rays.com/IDA-pro

    2021

  21. [28]

    Minkyu Jung, Soomin Kim, HyungSeok Han, Jaeseung Choi, and Sang Kil Cha

  22. [29]

    Pascal Junod, Julien Rinaldini, Johan Wehrli, and Julie Michielin. 2015. Obfuscator- LLVM – Software Protection for the Masses. In IEEE/ACM 1st International Work- shop on Software Protection, SPRO’15 . IEEE, 3–9

    2015

  23. [30]

    Ulf Kargén, Ivar Härnqvist, Johannes Wilson, Gustav Eriksson, Evelina Holm- gren, and Nahid Shahmehri. 2022. desync-cc: An Automatic Disassembly- Desynchronization Obfuscator. In SANER’22. IEEE, 464–468

    2022

  24. [31]

    Jacob Devlin Ming-Wei Chang Kenton and Lee Kristina Toutanova. 2019. Bert: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of naacL-HLT, Vol. 1. 2

    2019

  25. [33]

    Sun Hyoung Kim, Dongrui Zeng, Cong Sun, and Gang Tan. 2022. BinPointer: towards precise, sound, and scalable binary-level pointer analysis. In CC ’22. ACM, 169–180

    2022

  26. [34]

    Hyungjoon Koo, Soyeon Park, and Taesoo Kim. 2021. A Look Back on a Function Identification Problem. In ACSAC ’21. ACM, 158–168

    2021

  27. [35]

    Robertson, Fredrik Valeur, and Giovanni Vi- gna

    Christopher Krügel, William K. Robertson, Fredrik Valeur, and Giovanni Vi- gna. 2004. Static Disassembly of Obfuscated Binaries. In 13th USENIX Security Symposium. USENIX Association, 255–270

    2004

  28. [36]

    Xuezixiang Li, Yu Qu, and Heng Yin. 2021. PalmTree: Learning an Assembly Language Model for Instruction Embedding. In CCS ’21. ACM, 3236–3251

    2021

  29. [37]

    Girshick, Kaiming He, and Piotr Dollár

    Tsung-Yi Lin, Priya Goyal, Ross B. Girshick, Kaiming He, and Piotr Dollár. 2017. Focal Loss for Dense Object Detection. In ICCV’17. IEEE, 2999–3007

    2017

  30. [38]

    Yan Lin and Debin Gao. 2021. When Function Signature Recovery Meets Compiler Optimization. In SP’21. IEEE, 36–52

    2021

  31. [39]

    Alwin Maier, Hugo Gascon, Christian Wressnegger, and Konrad Rieck. 2019. TypeMiner: Recovering Types in Binary Programs Using Machine Learning. In DIMV A ’19 (LNCS, Vol. 11543). Springer, 288–308

    2019

  32. [40]

    Miller, Yonghwi Kwon, Yi Sun, Zhuo Zhang, Xiangyu Zhang, and Zhiqiang Lin

    Kenneth A. Miller, Yonghwi Kwon, Yi Sun, Zhuo Zhang, Xiangyu Zhang, and Zhiqiang Lin. 2019. Probabilistic disassembly. InICSE’19. IEEE / ACM, 1187–1198

    2019

  33. [41]

    Paul Muntean, Matthias Fischer, Gang Tan, Zhiqiang Lin, Jens Grossklags, and Claudia Eckert. 2018. 𝜏CFI: Type-Assisted Control Flow Integrity for x86-64 Binaries. In RAID’18 (LNCS, Vol. 11050). Springer, 423–444

    2018

  34. [42]

    NSA. 2019. Ghidra Software Reverse Engineering Framework. https://github. com/NationalSecurityAgency/ghidra

    2019

  35. [43]

    Chengbin Pang, Ruotong Yu, Yaohui Chen, Eric Koskinen, Georgios Portokalidis, Bing Mao, and Jun Xu. 2021. SoK: All You Ever Wanted to Know About x86/x64 Binary Disassembly But Were Afraid to Ask. In SP’21. IEEE, 833–851

    2021

  36. [44]

    Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala

    Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Köpf, Edward Z. Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, ...

    2019

  37. [45]

    Kexin Pei, Jonas Guan, Matthew Broughton, Zhongtian Chen, Songchen Yao, David Williams-King, Vikas Ummadisetty, Junfeng Yang, Baishakhi Ray, and Suman Jana. 2021. StateFormer: fine-grained type recovery from binaries using generative state modeling. In ESEC/FSE ’21. ACM, 690–702

    2021

  38. [46]

    Kexin Pei, Jonas Guan, David Williams-King, Junfeng Yang, and Suman Jana

  39. [47]

    Nguyen Anh Quynh. 2014. Capstone: Next-gen disassembly framework. Black Hat USA 5, 2 (2014), 3–8

    2014

  40. [48]

    radareorg. 2014. Radare2: Libre Reversing Framework for Unix Geeks. https: //github.com/radareorg/radare2

    2014

  41. [49]

    Xiaolei Ren, Michael Ho, Jiang Ming, Yu Lei, and Li Li. 2021. Unleashing the hidden power of compiler optimization on binary code difference: an empirical study. In PLDI ’21. ACM, 142–157

    2021

  42. [50]

    Huanyao Rong, Yue Duan, Hang Zhang, XiaoFeng Wang, Hongbo Chen, Shengchen Duan, and Shen Wang. 2024. Disassembling Obfuscated Executables with LLM. CoRR abs/2407.08924 (2024)

    2024 arXiv

  43. [51]

    Florent Saudel and Jonathan Salwan. 2015. Triton: A Dynamic Symbolic Execution Framework. In Symposium sur la sécurité des technologies de l’information et des communications (SSTIC). Rennes, France, 31–54

    2015

  44. [52]

    Debray, and Gregory R

    Benjamin Schwarz, Saumya K. Debray, and Gregory R. Andrews. 2002. Disas- sembly of Executable Code Revisited. In WCRE’02. IEEE, 45–54

    2002

  45. [53]

    Eui Chul Richard Shin, Dawn Song, and Reza Moazzezi. 2015. Recognizing Functions in Binaries with Neural Networks. In24th USENIX Security Symposium. USENIX Association, 611–626

    2015

  46. [54]

    Yan Shoshitaishvili, Ruoyu Wang, Andrew Dutcher, Lukas Dresel, Zion Leona- henahe Basque, Eric Gustafson, Nilo Redini, Paul Grosen, Colin Unger, Christo- pher Salls, Nick Stephens, Christophe Hauser, Jessie Grosen, Christopher Krügel, and Giovanni Vigna. 2013. angr: A platform...

    2013

  47. [55]

    Yan Shoshitaishvili, Ruoyu Wang, Christopher Salls, Nick Stephens, Mario Polino, Andrew Dutcher, John Grosen, Siji Feng, Christophe Hauser, Christopher Krügel, and Giovanni Vigna. 2016. SOK: (State of) The Art of War: Offensive Techniques in Binary Analysis. In SP ’16. IEEE, 138–157

    2016

  48. [56]

    Asia Slowinska, Traian Stancescu, and Herbert Bos. 2012. Body Armor for Binaries: Preventing Buffer Overflows Without Recompilation. InUSENIX Annual Technical Conference. USENIX Association, 125–137

    2012

  49. [57]

    VMProtect Software. 2025. VMProtect. https://vmpsoft.com/vmprotect/

    2025

  50. [58]

    Rui Sun, Yinggang Guo, Zicheng Wang, and Qingkai Zeng. 2023. AttnCall: Refining Indirect Call Targets in Binaries with Attention. In ESORICS ’23 (LNCS, Vol. 14347). Springer, 391–409

    2023

  51. [59]

    2004-2025

    Oreans Technologies. 2004-2025. Themida: Advanced Windows software protec- tion system. https://www.oreans.com/themida.php

    2004

  52. [60]

    Vaidya, Prasad A

    Ruturaj K. Vaidya, Prasad A. Kulkarni, and Michael R. Jantz. 2021. Explore Capabilities and Effectiveness of Reverse Engineering Tools to Provide Memory Safety for Binary Programs. In ISPEC ’21 (LNCS, Vol. 13107) . Springer, 11–31

    2021

  53. [61]

    Victor van der Veen, Enes Göktas, Moritz Contag, Andre Pawlowski, Xi Chen, Sanjay Rawat, Herbert Bos, Thorsten Holz, Elias Athanasopoulos, and Cristiano Giuffrida. 2016. A Tough Call: Mitigating Advanced Code-Reuse Attacks at the Binary Level. In SP’16. IEEE, 934–953

    2016

  54. [62]

    Gomez, Lukasz Kaiser, and Illia Polosukhin

    Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. 2017. Attention is All you Need. In NIPS’17. 5998–6008

    2017

  55. [63]

    Vector 35. 2016. Binary Ninja. https://binary.ninja

    2016

  56. [64]

    Haijun Wang, Xiaofei Xie, Shang-Wei Lin, Yun Lin, Yuekang Li, Shengchao Qin, Yang Liu, and Ting Liu. 2019. Locating vulnerabilities in binaries via memory layout recovering. In ESEC/SIGSOFT FSE ’19. ACM, 718–728

    2019

  57. [65]

    Shuai Wang, Pei Wang, and Dinghao Wu. 2015. Reassembleable Disassembling. In 24th USENIX Security Symposium . USENIX Association, 627–642

    2015

  58. [66]

    Hamlen, and Murat Kantarcioglu

    Richard Wartell, Yan Zhou, Kevin W. Hamlen, and Murat Kantarcioglu. 2014. Shingled Graph Disassembly: Finding the Undecideable Path. InPAKDD’14 (LNCS, Vol. 8443). Springer, 273–285

    2014

  59. [67]

    Hamlen, Murat Kantarcioglu, and Bhavani Thuraisingham

    Richard Wartell, Yan Zhou, Kevin W. Hamlen, Murat Kantarcioglu, and Bhavani Thuraisingham. 2011. Differentiating Code from Data in x86 Binaries. In ECML PKDD ’11 (LNCS, Vol. 6913) . Springer, 522–536

    2011

  60. [68]

    Yapeng Ye, Zhuo Zhang, Qingkai Shi, Yousra Aafer, and Xiangyu Zhang. 2023. D-ARM: Disassembling ARM Binaries by Lightweight Superset Instruction Inter- pretation and Graph Modeling. In SP’23. IEEE, 2391–2408

    2023

  61. [69]

    Sheng Yu, Yu Qu, Xunchao Hu, and Heng Yin. 2022. DeepDi: Learning a Relational Graph Convolutional Network Model on Instructions for Fast and Accurate CCS ’25, October 13–17, 2025, Taipei, Taiwan Peicheng Wang et al. s 1 s 2 FN Ground TPs : Predictions : TP FP unk . … … … … t ...

    2022

  62. [70]

    Naville Zhang. 2019. Hikari – an improvement over obfuscator-llvm. https: //github.com/HikariObfuscator/Hikari

    2019

  63. [71]

    Zhuo Zhang, Yapeng Ye, Wei You, Guanhong Tao, Wen-Chuan Lee, Yonghwi Kwon, Yousra Aafer, and Xiangyu Zhang. 2021. OSPREY: Recovery of Variable and Data Structure via Probabilistic Analysis for Stripped Binary. In SP’21. IEEE, 813–832

    2021

  64. [72]

    Wenyu Zhu, Zhiyao Feng, Zihan Zhang, Jianjun Chen, Zhijian Ou, Min Yang, and Chao Zhang. 2023. Callee: Recovering call graphs for binaries with transfer and contrastive learning. In SP’23. IEEE, 2357–2374

    2023

  65. [73]

    zyantific team. 2014. Zydis: The ultimate, open-source X86 & X86-64 decoder/dis- assembler library. https://zydis.re. A Baseline Implementation and Configuration We re-implement biRNN using PyTorch following the same struc- ture and setup described in [53]. We especially follo...

    2014

  66. [2001]

    In Proceedings of the Fourth Annual IEEE International Workshop on Workload Characterization

    MiBench: A free, commercially representative embedded benchmark suite. In Proceedings of the Fourth Annual IEEE International Workshop on Workload Characterization. WWC-4 (Cat. No.01EX538). 3–14

  67. [2014]

    In 23rd USENIX Security Symposium

    BYTEWEIGHT: Learning to Recognize Functions in Binary Code. In 23rd USENIX Security Symposium. USENIX Association, 845–860

  68. [2018]

    In CCS’18

    Debin: Predicting Debug Information in Stripped Binaries. In CCS’18. ACM, 1667–1680

  69. [2019]

    InThe Workshop on Binary Analysis Research

    B2R2: Building an Efficient Front-End for Binary Analysis. InThe Workshop on Binary Analysis Research

  70. [2021]

    In NDSS’21

    XDA: Accurate, Robust Disassembly with Transfer Learning. In NDSS’21. The Internet Society

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.