Pith. sign in

REVIEW 4 major objections 5 minor 1 cited by

Beyond Embeddings: Interpretable Feature Extraction for Binary Code Similarity

T0 review · 4 major / 5 minor · reviewed 2026-08-04 · deepseek-v4-flash

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

Pith's one-line read Training-free LLM-generated features match trained embeddings in binary code similarity detection, and combining the two beats both.

desk verdict Genuinely new training-free BCSD design point with a strong hybrid result, but the standalone headline numbers rest on a contamination check that isn't there. read the letter →

arxiv 2509.23449 v2 pith:YXNZBO35 submitted 2025-09-27 cs.AI cs.CRcs.SE

Charles E. Gagnon , Steven H. H. Ding , Philippe Charland , Benjamin C. M. Fung This is my paper
classification cs.AIcs.CRcs.SE
keywords binarycodesimilaritydetectionlargelanguagemodelsinterpretablefeaturestraining-freemethodcross-architectureretrievalcross-optimizationinvertedindexsearchassemblyanalysis
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

This paper tries to establish that a large language model, prompted to act as a reverse-engineering analyst, can extract human-readable structured features from raw assembly code and use them to detect semantically similar functions across different compilers, optimizations, and CPU architectures, all without any matching-specific training. The authors report that these features reach recall@1 of 42% in cross-architecture retrieval and 62% in cross-optimization retrieval, comparable to embedding methods that were trained for the task (39% and 34%). They further show that blending their textual features with an embedding model's similarity scores outperforms either method alone, arguing that accuracy, scalability, and interpretability can coexist in a single BCSD pipeline. A sympathetic reader would see this as a significant shift toward transparent, maintainable binary analysis tools.

What carries the argument

The mechanism is a structured prompting pipeline that converts raw disassembly into a JSON document of hand-specified semantic features (type signature, logic/operations, notable constants, side effects, inferred category). Similarity is then computed as Jaccard overlap over the flattened field–value pairs, which can be indexed by an inverted index or relational DB, avoiding approximate nearest-neighbor search. The schema design makes the feature set extensible without retraining, and the LLM's broad pretraining supplies the cross-architecture knowledge that specialized embedding models must learn from corpora.

What would settle it

Take a set of assembly functions that are provably absent from the LLM's training data—for example, routines generated by a custom compiler or from an obscure, newer instruction set—compile them under multiple optimization levels, and run the same retrieval experiment; if recall drops to near-random levels, the reported cross-setting performance is an artifact of memorization rather than reasoning.

Watch

Extended reading notes

Core claim

The central claim is that a pretrained LLM, prompted with a structured JSON schema and a few examples, can act as a general-purpose semantic feature extractor for assembly functions, and that the resulting features—effective parameter types, loop indicators, notable constants, side effects, and an inferred algorithmic category—are sufficiently discriminative for clone retrieval. In the paper's own experiment, this training-free method achieves recall@1 of 0.436–0.531 across ARM/PPC/MIPS-to-x86-64 architectures and 0.485–0.758 across optimization levels, versus 0.334–0.443 for the best trained baseline (CLAP) in the same settings. The paper further claims that averaging the Jaccard similarity

Load-bearing premise

The paper assumes the LLM's feature extraction reflects general assembly understanding rather than memorization of the specific test binaries; the dataset is built from popular open-source projects (BusyBox, coreutils, OpenSSL, etc.) that are almost certainly present in commercial LLM training corpora, and no control is made for the LLM having seen the exact functions.

Editorial extensions

If this is right

  • If the central claim holds, BCSD databases can be built and updated without any training or fine-tuning, simply by prompting a general-purpose LLM on each new function.
  • The textual features allow analysts to inspect why two functions are judged similar, enabling verification and debugging that opaque embeddings cannot provide.
  • The hybrid scoring rule—average of Jaccard and cosine similarity—shows a concrete path to combine interpretable features with existing embedding models, improving accuracy without retraining the embeddings.
  • Inverted-index search over text features offers an exact-search alternative to approximate nearest neighbors, removing a known accuracy–efficiency trade-off at scale.
  • The method's performance scales with LLM size, implying that future improvements in base models will directly translate to better binary similarity detection without changes to the pipeline.

Reading between the lines

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

  • The reported cross-architecture recall may be inflated if the LLM has memorized the specific open-source functions (e.g., MD5Init) during pretraining; a strong test would be to evaluate on freshly authored or intentionally novel assembly routines.
  • The schema's coarse type system (only Integer/Pointer) and category list may limit the approach on niche domains, but the paper's extensible design suggests an incremental path to richer features without regenerating the database.
  • The combined method's success hints that LLM features primarily capture high-level algorithmic intent while embeddings capture low-level structural detail; this complementarity could guide research into hybrid representations beyond BCSD, such as decompiler-aided vulnerability search.
  • The retry-on-failure mechanism and few-shot prompting make the pipeline practical on small open-weight models, but the compute cost per function (seconds per query on a 7B model) may favor cloud APIs for large databases, raising privacy concerns the paper itself acknowledges.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. This paper proposes replacing learned embeddings in binary code similarity detection (BCSD) with structured, human-readable features generated by an LLM. The method prompts an LLM to analyze raw assembly functions and output JSON fields covering type signatures, logic/operation categories, notable constants, side effects, and an inferred algorithmic category. Similarity is computed as Jaccard overlap over flattened field–value pairs, which the authors argue can be indexed with inverted or relational indexes. The evaluation compares the method against Order Matters, SAFE, PalmTree, Asm2Vec, and CLAP on pools of 1,000 functions. Gemini 2.5 Flash reaches 42.2% average cross-architecture recall@1 versus CLAP's 39.7%, and 61.7% average cross-optimization recall@1 versus CLAP's 33.9%. Ablations examine LLM size, few-shot example count, prompt sections, and a hybrid combination with Qwen3-Embedding 4B, which yields large recall gains.

Significance. If verified, the central claim is significant: an LLM-based, training-free feature extractor can produce interpretable features competitive with trained embedding models on cross-architecture and cross-optimization retrieval, and can complement embeddings. The paper is generally well written, the artifact is said to be public, and the ablations on model size, few-shot prompting, and prompt sections are informative. The main value is in demonstrating that a non-embedding representation can be both semantically rich and usable for matching. However, the headline results depend on two untested assumptions: that the LLM has not effectively memorized the specific test functions, and that the proposed representation scales beyond the 1,000-function pools used in the experiments. Both are flagged in the manuscript as limitations or unaddressed risks, so the significance is conditional on additional evidence.

major comments (4)
  1. [§3.3, §3 (dataset construction), Table 1] The central 'training-free generalization' claim is not yet supported because the dataset consists entirely of extremely popular open-source projects (OpenSSL, SQLite, BusyBox, coreutils, etc.) that are almost certainly present in LLM pretraining corpora. Section 3.3 notes that the LLM 'has extensively seen' mainstream CPU architectures, but that only concerns instruction dialects, not these exact functions. Since the most discriminative features are `inferred_algo` and `int_consts` (§3.6), a model that recognizes, say, MD5Init from either compiled variant could emit identical feature sets and inflate the reported cross-optimization and cross-architecture recall@1. The paper should add a contamination check: for example, evaluate on functions added after the model's training cutoff, or on less popular/held-out projects, and report whether performance is maintained. Without this, the 42%
  2. [§5 (Conclusion), §3.2 (evaluation setup)] The scalability claim is load-bearing for the abstract's statement that accuracy, scalability, and interpretability can coexist, but it is not empirically tested. All retrieval experiments use pools of 1,000 functions (Tables 4–6), and the conclusion explicitly concedes that performance 'may not be the case when comparing millions of feature sets.' No indexing time, query latency, memory usage, or exact-search-versus-ANN comparison is reported. Please add a small-scale scalability study (e.g., 10k–100k functions using an inverted index) or clearly restrict the scalability claim to the qualitative design.
  3. [Table 5, §3.2 (baseline comparison)] The comparison against embedding baselines is not fully controlled. The baselines are evaluated off-the-shelf, and at least CLAP was trained on x86-64/gcc only; cross-optimization on ARM (Table 5) is likely out-of-distribution for CLAP, while other baselines were also trained on restricted architecture sets. The paper's explanation that low baseline scores are due to 'overfitting' (§3.2) is speculative without reporting the exact preprocessing, tokenization, and evaluation protocol used for each baseline. Please specify how each baseline was instantiated, and either include baselines evaluated under their native conditions or add a discussion of this limitation in the comparison.
  4. [§3.1, §3.5, §3.7] The 'training-free' claim is narrower than stated because several free parameters are selected using the same benchmark tasks: the backbone LLM was chosen through a pilot on a subset of the same tasks (§3.1), the three few-shot examples were chosen after ablations on those tasks (§3.5), and the hybrid weight in §3.7 is fixed at 0.5 without sensitivity analysis. No gradient training is performed, but task-specific selection does influence the reported numbers. Please report robustness to these choices (e.g., different few-shot examples, weights of 0.2/0.8) or explicitly acknowledge this selection procedure as a limitation.
minor comments (5)
  1. [Throughout] Several typos: 'adverserial' (Section 2), 'dissassembled' (Section 3 dataset description), 'similiarity' (§3.7), 'oportunities' (§5.1), 'Exampe' (Figure 2 caption), 'our its stability' (§3.2), and 'Beneficience' (Ethical Considerations).
  2. [Figure 5] The baseline models are placed at arbitrary positions on the 'Model Size' axis even though their parameter counts are not LLM parameter counts. This is visually confusing; consider using a separate axis or explicit annotations.
  3. [Table 6] The column header 'Qwen' should name the exact model, Qwen3-Embedding 4B, for reproducibility and consistency with the text.
  4. [§2.7] The Jaccard similarity over flattened field–value pairs is underspecified: it is unclear how array fields are tokenized, whether booleans and missing fields are included, and whether any field weighting is applied. Specify the exact tokenization and matching procedure.
  5. [References] Reference [8] contains a corrupted author name ('Buciluundefined'). The GPT-4 reference [38] is cited for GPT 4.1 Mini; a more specific model card citation would be appropriate.

Circularity Check

1 steps flagged · score 2.0 of 10

No definitional circularity; minor selection-on-evaluation-set choices and non-load-bearing self-citations keep the paper in the 0–2 range.

  1. other [Section 3.1, Pilot Testing for LLM Selection; Tables 2–3; also Section 3.5, Figure 6]
    "We selected a small set of tasks that are representative of the extensive experiments conducted against the baselines."

    The backbone LLM is chosen by MRR on the same cross-optimization and cross-architecture retrieval settings that later appear as headline results (e.g., O0–O3, O2–O3, ARM–x86-64 in Tables 4–5). Similarly, the three few-shot examples are validated by ablation on those same retrieval tasks (Figure 6). Thus the reported 'training-free' accuracy is not produced by a fixed, a priori configuration; the model and prompt configuration were selected on the evaluation distribution. This creates selection pressure rather than a definitional reduction: no reported recall value is forced by construction, so this is scored at the low end.

full rationale

The central claim—that LLM-generated structured features achieve competitive cross-architecture and cross-optimization recall without BCSD training—is an empirical measurement, not a derivation. No equation in the paper reduces a predicted quantity to a fitted parameter; the Jaccard similarity on extracted features is computed directly from measured outputs. The main design choices (LLM backbone, few-shot count, equal-weight hybrid combination) were selected using the same task distribution, which is a mild form of selection bias, but it does not amount to the reported results being true by definition. The self-citations to Asm2Vec [14] and Kam1n0 [15], which share authors with the present paper, are used only as comparative baselines and related work; they are not load-bearing for the central claim. The more serious threat—LLM pretraining contamination on popular functions like MD5Init from BusyBox/OpenSSL—is an empirical confound rather than a circularity, because it concerns whether the features reflect general assembly understanding or memorization; it cannot be established from the paper's equations and therefore does not raise the circularity score. Overall, the paper is self-contained as an experimental evaluation, with no significant circular derivation.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

The paper introduces no new physical or computational entities. The 'effective parameters' abstraction in Section 2.5 is a conceptual device for defining features, not an invented entity. The free parameters are all pipeline hyperparameters chosen by experimentation or ad hoc; none are fitted to the test labels.

free parameters (3)
  • few_shot_examples = 3
    Number of handcrafted feature-analysis examples in the prompt; chosen after ablation (Figure 6). More examples do not help and can hurt by consuming context.
  • hybrid_weight = 0.5
    Equal-weight average of embedding cosine similarity and feature Jaccard similarity in Section 3.7; set ad hoc, not tuned.
  • context_truncation = 4096 tokens input / 128 instructions (Gemini) / 512 output tokens
    Functions exceeding the context window are truncated; hyperparameters of the pipeline that affect very large functions.
assumptions (4)
  • domain assumption Pretrained LLMs encode sufficient assembly semantics to extract stable features across architectures and optimization levels without fine-tuning.
    Section 2.4 grounds the generalization claim (L3) on this premise; the ablation on model size supports it only partially (models under 3B fail).
  • domain assumption Jaccard overlap over flattened JSON field-value pairs is a valid similarity measure for BCSD retrieval.
    Section 2.7 defines the similarity computation; no comparison against alternative text similarity measures is provided.
  • domain assumption The ground truth assumption that functions compiled from the same source are semantic matches and functions from different sources are non-matches is correct for evaluation.
    Section 3 describes the pair construction; this is standard in BCSD but is an assumption about the task.
  • domain assumption The LLM has not memorized the specific test binaries from its pretraining corpus.
    The test set is composed of popular open-source projects (BusyBox, OpenSSL, SQLite, etc.) likely present in LLM training data; the paper does not test for contamination.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Beyond Embeddings: Interpretable Feature Extraction for Binary Code Similarity." pith.science (2026). https://pith.science/paper/YXNZBO35

@misc{pith2026250923449,
  author       = {Pith},
  title        = {Pith review of: Beyond Embeddings: Interpretable Feature Extraction for Binary Code Similarity},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YXNZBO35}},
  note         = {Machine review of arXiv:2509.23449}
}
read the original abstract

Binary code similarity detection is a core task in reverse engineering. It supports malware analysis and vulnerability discovery by identifying semantically similar code in different contexts. Modern methods have progressed from manually engineered features to vector representations. Hand-crafted statistics (e.g., operation ratios) are interpretable, but shallow and fail to generalize. Embedding-based methods overcome this by learning robust cross-setting representations, but these representations are opaque vectors that prevent rapid verification. They also face a scalability-accuracy trade-off, since high-dimensional nearest-neighbor search requires approximations that reduce precision. Current approaches thus force a compromise between interpretability, generalizability, and scalability. We bridge these gaps using a language model-based agent to conduct structured reasoning analysis of assembly code and generate features such as input/output types, side effects, notable constants, and algorithmic intent. Unlike hand-crafted features, they are richer and adaptive. Unlike embeddings, they are human-readable, maintainable, and directly searchable with inverted or relational indexes. Without any matching training, our method respectively achieves 42% and 62% for recall@1 in cross-architecture and cross-optimization tasks, comparable to embedding methods with training (39% and 34%). Combined with embeddings, it significantly outperforms the state-of-the-art, demonstrating that accuracy, scalability, and interpretability can coexist.

Figures

Figures reproduced from arXiv: 2509.23449 by the authors.

Figure 1
Figure 1. Evolution of features in BCSD. Left: Handcrafted statistics are interpretable, but shallow and sometimes intractable (CFG). Middle: Deep embeddings improve matching, but suffer from L1–L3 (interpretability, scalability–accuracy, training dependency). Right: Our LLM-generated structured features are interpretable, searchable via inverted/relational indexes, and training-free, addressing L1–L3, while improving practic… view at source ↗
Figure 2
Figure 2. Exampe MD5Init function compiled under different architectures and optimization levels. BCSD methods aim at identifying them as clones. systems relied on manually engineered features, whereas recent work uses deep neural embeddings. 4. Indexing and Search. Known functions are stored in a database of feature vectors. Given a query function fq, its vector Φ(fq) is compared against the database (e.g., via cosine simila… view at source ↗
Figure 3
Figure 3. Comparison of the simplified example sha384_init assembly function for ARM (red) and x86-64 (green); identical values in black. Right-hand panel explains several less obvious features. The specific set of features shown is function-dependent and generated by the language model. often covering only a narrow range of architectures, compil￾ers, and optimization settings. In practice however, reverse engineers must anal… view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: Workflow of our method in both the indexing and searching use cases. [PITH_FULL_IMAGE:figures/full_fig_p005_4.png]
Figure 5
Figure 5. Figure 5: MRR for cross-optimization retrieval versus LLM [PITH_FULL_IMAGE:figures/full_fig_p010_5.png]
Figure 6
Figure 6. Figure 6: MRR for cross-optimization retrieval versus prompt [PITH_FULL_IMAGE:figures/full_fig_p011_6.png]
Figure 7
Figure 7. Figure 7: MRR with one prompt section removed using Gem [PITH_FULL_IMAGE:figures/full_fig_p012_7.png]

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

  1. Practical Source Code Recovery from Binary Functions Using Anchor-Based Retrieval and LLM Reasoning

    cs.SE 2026-07 conditional novelty 5.5 of 10

    Anchor-based retrieval plus LLM re-ranking recovers source functions for 95.2% of instructions in a stripped tcpdump binary against a curated database, but only 35.5% average coverage via GitHub search.

Reference graph

Works this paper leans on

68 extracted references · 4 canonical work pages · cited by 1 Pith paper

  1. [1]

    Ghidra software reverse engineering framework, 2025-07-31

    National Security Agency. Ghidra software reverse engineering framework, 2025-07-31. URL: https:// github.com/NationalSecurityAgency/ghidra

    2025

  2. [2]

    Roy, and Juergen Rilling

    Farouq Al-Omari, Iman Keivanloo, Chanchal K. Roy, and Juergen Rilling. Detecting clones across microsoft .net programming languages. In2012 19th Working Conference on Reverse Engineering, pages 405–414, 2012.doi:10.1109/WCRE.2012.50

    work page doi:10.1109/wcre.2012.50 2012

  3. [3]

    Beyond embeddings: Interpretable feature extraction for binary code similarity – artifact, 2025-08-

    Anonymous. Beyond embeddings: Interpretable feature extraction for binary code similarity – artifact, 2025-08-

    2025

  4. [4]

    Fuzzing BusyBox: Leveraging LLM and crash reuse for em- bedded bug unearthing

    Asmita, Yaroslav Oliinyk, Michael Scott, Ryan Tsang, Chongzhou Fang, and Houman Homayoun. Fuzzing BusyBox: Leveraging LLM and crash reuse for em- bedded bug unearthing. In33rd USENIX Secu- rity Symposium (USENIX Security 24), pages 883– 900, Philadelphia, PA, August 2024. USENIX Associa- tion. URL: https://www.usenix.org/conference/ usenixsecurity24/prese...

    2024

  5. [5]

    Max Beninger, Philippe Charland, Steven H. H. Ding, and Benjamin C. M. Fung. ERS0: enhancing military cybersecurity with ai-driven SBOM for firmware vulnerability detection and asset management. In Claire Kwan, Lauri Lindström, Davide Giovannelli, Karlis Podins, and Damjan Strucl, editors,16th International Conference on Cyber Conflict: Over the Horizon, ...

    arXiv 2024

  6. [6]

    On the way to sboms: Investigating design issues and solutions in practice.ACM Trans

    Tingting Bi, Boming Xia, Zhenchang Xing, Qinghua Lu, and Liming Zhu. On the way to sboms: Investigating design issues and solutions in practice.ACM Trans. Softw. Eng. Methodol., 33(6), June 2024.doi:10.1145/ 3654442

    2024

  7. [7]

    Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-V oss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeffrey Wu, Clemens Winter, Christo- pher Hesse, Mark Chen, Eric Sigler, Mateusz Lit...

    arXiv 2020

  8. [8]

    Model compression

    Cristian Buciluundefined, Rich Caruana, and Alexandru Niculescu-Mizil. Model compression. InProceedings of the 12th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’06, page 535–541, New York, NY , USA, 2006. Association for Computing Machinery. doi:10.1145/1150402. 1150464

    doi:10.1145/1150402 2006

Show all 68 references
  1. [9]

    Openssl, 2025-08-05

    Mark Cox, Ralf Engelschall, Stephen Henson, Ben Lau- rie, and Paul Sutton. Openssl, 2025-08-05. URL: https://www.openssl.org/

    2025

  2. [10]

    Mastering digital image alchemy, 2025-07-

    John Cristy. Mastering digital image alchemy, 2025-07-

    2025

  3. [11]

    Firmup: Precise static detection of common vulnerabilities in firmware.SIGPLAN Not., 53(2):392–404, March 2018

    Yaniv David, Nimrod Partush, and Eran Yahav. Firmup: Precise static detection of common vulnerabilities in firmware.SIGPLAN Not., 53(2):392–404, March 2018. doi:10.1145/3296957.3177157

    2018

  4. [12]

    Bert: Pre-training of deep bidi- rectional transformers for language understanding,

    Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidi- rectional transformers for language understanding,

  5. [13]

    URL:https://imagemagick.org/. 14

  6. [14]

    Steven H. H. Ding, Benjamin C. M. Fung, and Philippe Charland. Asm2vec: Boosting static representation ro- bustness for binary clone search against code obfusca- tion and compiler optimization. In2019 IEEE Sym- posium on Security and Privacy (SP), pages 472–489, 2019.doi:10.11...

    2019

  7. [15]

    Ding, Benjamin C.M

    Steven H.H. Ding, Benjamin C.M. Fung, and Philippe Charland. Kam1n0: Mapreduce-based assembly clone search for reverse engineering. InProceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’16, page 461–470, New York, NY , USA, ...

    2016 doi

  8. [16]

    Coreutils - gnu core utilities, 2025-04-09

    Alex Deymo, Jim Meyering, Paul Eggert, Padraig Brady, Bernhard V oelker, and Collin Funk. Coreutils - gnu core utilities, 2025-04-09. URL: https://www.gnu.org/ software/coreutils/

    2025

  9. [17]

    Blanket execution: Dynamic similarity testing for program binaries and components

    Manuel Egele, Maverick Woo, Peter Chapman, and David Brumley. Blanket execution: Dynamic similarity testing for program binaries and components. In 23rd USENIX Security Symposium (USENIX Secu- rity 14), pages 303–317, San Diego, CA, August

  10. [18]

    Large language models for code analysis: Do LLMs really do their job? In33rd USENIX Secu- rity Symposium (USENIX Security 24), pages 829– 846, Philadelphia, PA, August 2024

    Chongzhou Fang, Ning Miao, Shaurya Srivastav, Jialin Liu, Ruoyu Zhang, Ruijie Fang, Asmita, Ryan Tsang, Najmeh Nazari, Han Wang, and Houman Homay- oun. Large language models for code analysis: Do LLMs really do their job? In33rd USENIX Secu- rity Symposium (USENIX Security 24)...

    2024

  11. [19]

    Graph-based comparison of ex- ecutable objects

    Thomas Dullien. Graph-based comparison of ex- ecutable objects. 2005. URL: https://api. semanticscholar.org/CorpusID:2001486

    2005

  12. [20]

    Cross- language binary-source code matching with intermedi- ate representations, 2022

    Yi Gui, Yao Wan, Hongyu Zhang, Huifang Huang, Yulei Sui, Guandong Xu, Zhiyuan Shao, and Hai Jin. Cross- language binary-source code matching with intermedi- ate representations, 2022. URL: https://arxiv.org/ abs/2201.07420,arXiv:2201.07420

    2022 arXiv

  13. [21]

    Funcvul: An effective function level vul- nerability detection model using llm and code chunk,

    Sajal Halder, Muhammad Ejaz Ahmed, and Seyit Camtepe. Funcvul: An effective function level vul- nerability detection model using llm and code chunk,

  14. [22]

    Code is not natural language: Unlock the power of Semantics-Oriented graph representation for binary code similarity detection

    Haojie He, Xingwei Lin, Ziang Weng, Ruijie Zhao, Shuitao Gan, Libo Chen, Yuede Ji, Jiashui Wang, and Zhi Xue. Code is not natural language: Unlock the power of Semantics-Oriented graph representation for binary code similarity detection. In33rd USENIX Se- curity Symposium (USE...

    2024

  15. [23]

    Extracting condi- tional formulas for cross-platform bug search

    Qian Feng, Minghua Wang, Mu Zhang, Rundong Zhou, Andrew Henderson, and Heng Yin. Extracting condi- tional formulas for cross-platform bug search. InPro- ceedings of the 2017 ACM on Asia Conference on Com- puter and Communications Security, ASIA CCS ’17, page 346–359, New York,...

    2017 doi

  16. [24]

    Richard Hipp

    D. Richard Hipp. Sqlite, 2025-07-30. URL: https: //sqlite.org/

    2025

  17. [25]

    Qwen2.5- coder technical report, 2024

    Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayi- heng Liu, Lei Zhang, Tianyu Liu, Jiajun Zhang, Bowen Yu, Keming Lu, Kai Dang, Yang Fan, Yichang Zhang, An Yang, Rui Men, Fei Huang, Bo Zheng, Yibo Miao, Shanghaoran Quan, Yunlong Feng, Xingzhang Ren, Xu- ancheng Ren, Jingren ...

    2024 arXiv

  18. [26]

    URL: https://anonymous.4open.science/r/ asm-feature-extraction-894E/README.md

  19. [27]

    Scalable malware forensics using phy- logenetic analysis

    Steven Jilcott. Scalable malware forensics using phy- logenetic analysis. In2015 IEEE International Sym- posium on Technologies for Homeland Security (HST), pages 1–6, 2015.doi:10.1109/THS.2015.7225311. 15

    2015

  20. [28]

    Ida pro, 2025-02-28

    hex rays. Ida pro, 2025-02-28. URL: https:// hex-rays.com/ida-pro

    2025

  21. [29]

    Le and Tomas Mikolov

    Quoc V . Le and Tomas Mikolov. Distributed representa- tions of sentences and documents, 2014. URL: https: //arxiv.org/abs/1405.4053,arXiv:1405.4053

    2014 arXiv

  22. [30]

    Understanding security risks of embedded devices through fine-grained firmware fingerprinting

    Qiang Li, Dawei Tan, Xin Ge, Haining Wang, Zhi Li, and Jiqiang Liu. Understanding security risks of embedded devices through fine-grained firmware fingerprinting. IEEE Transactions on Dependable and Secure Com- puting, 19(6):4099–4112, 2022. doi:10.1109/TDSC. 2021.3119970

    2022

  23. [31]

    International Organization for Standardization, Geneva, Switzerland, February 2012

    ISO.ISO/IEC 14882:2011 Information tech- nology — Programming languages — C++. International Organization for Standardization, Geneva, Switzerland, February 2012. URL: http: //www.iso.org/iso/iso_catalogue/catalogue_ tc/catalogue_detail.htm?csnumber=50372

    2011

  24. [32]

    A structured self-attentive sentence embedding,

    Zhouhan Lin, Minwei Feng, Cicero Nogueira dos San- tos, Mo Yu, Bing Xiang, Bowen Zhou, and Yoshua Ben- gio. A structured self-attentive sentence embedding,

  25. [33]

    Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei

    Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B. Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models, 2020. URL: https:// arxiv.org/abs/2001.08361,arXiv:2001.08361

    2020 arXiv

  26. [34]

    Binary code similarity detection

    Zian Liu. Binary code similarity detection. In2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE), pages 1056–1060, 2021. doi:10.1109/ASE51524.2021.9678518

    2021

  27. [35]

    How machine learning is solving the binary function similarity problem

    Andrea Marcelli, Mariano Graziano, Xabier Ugarte- Pedrero, Yanick Fratantonio, Mohamad Mansouri, and Davide Balzarotti. How machine learning is solving the binary function similarity problem. In31st USENIX Security Symposium (USENIX Security 22), pages 2099– 2116, Boston, MA, ...

  28. [36]

    Palmtree: Learn- ing an assembly language model for instruction em- bedding

    Xuezixiang Li, Yu Qu, and Heng Yin. Palmtree: Learn- ing an assembly language model for instruction em- bedding. InProceedings of the 2021 ACM SIGSAC Conference on Computer and Communications Secu- rity, CCS ’21, page 3236–3251, New York, NY , USA,

    2021

  29. [37]

    Distributed representations of words and phrases and their compositionality, 2013

    Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg Cor- rado, and Jeffrey Dean. Distributed representations of words and phrases and their compositionality, 2013. URL: https://arxiv.org/abs/1310.4546, arXiv: 1310.4546

    2013 arXiv

  30. [38]

    Gpt-4 technical report, 2024

    OpenAI. Gpt-4 technical report, 2024. URL: https:// arxiv.org/abs/2303.08774,arXiv:2303.08774

    2024 arXiv

  31. [39]

    Malware detection by exploiting deep learning over bi- nary programs

    Panpan Qi, Zhaoqi Zhang, Wei Wang, and Chang Yao. Malware detection by exploiting deep learning over bi- nary programs. In2020 25th International Conference on Pattern Recognition (ICPR), pages 9068–9075, 2021. doi:10.1109/ICPR48806.2021.9412227

    2021

  32. [40]

    Roberta: A robustly optimized bert pretraining approach,

    Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach,

  33. [41]

    URL: https://arxiv.org/abs/1907.11692, arXiv:1907.11692

    1907 arXiv

  34. [42]

    Penya, Borja Sanz, Carlos Laorden, and Pablo G

    Igor Santos, Felix Brezo, Javier Nieves, Yoseba K. Penya, Borja Sanz, Carlos Laorden, and Pablo G. Bringas. Idea: opcode-sequence-based malware detec- tion. InProceedings of the Second International Confer- ence on Engineering Secure Software and Systems, ES- SoS’10, page 35–4...

    2010 doi

  35. [43]

    Binary similarity detection using machine learning

    Noam Shalev and Nimrod Partush. Binary similarity detection using machine learning. InProceedings of the 13th Workshop on Programming Languages and Analysis for Security, PLAS ’18, page 42–47, New York, NY , USA, 2018. Association for Computing Machinery. doi:10.1145/3264820.3264821

    2018

  36. [44]

    Safe: Self-attentive function embeddings for binary similarity,

    Luca Massarelli, Giuseppe Antonio Di Luna, Fabio Petroni, Leonardo Querzoni, and Roberto Baldoni. Safe: Self-attentive function embeddings for binary similarity,

  37. [45]

    URL: https://arxiv.org/abs/1811.05296, arXiv:1811.05296

    arXiv

  38. [46]

    Putty, 2025-02-08

    Simon Tatham. Putty, 2025-02-08. URL:https://www. chiark.greenend.org.uk/~sgtatham/putty/

    2025

  39. [47]

    Gemini 2.5: Pushing the frontier with ad- vanced reasoning, multimodality, long context, and next generation agentic capabilities, 2025

    Google Team. Gemini 2.5: Pushing the frontier with ad- vanced reasoning, multimodality, long context, and next generation agentic capabilities, 2025. URL: https:// arxiv.org/abs/2507.06261,arXiv:2507.06261

    2025 arXiv

  40. [48]

    Gemma 3 technical report, 2025

    Google Team. Gemma 3 technical report, 2025. URL: https://arxiv.org/abs/2503.19786, arXiv:2503.19786

    2025 arXiv

  41. [49]

    Nicholas

    Edward Raff, Jon Barker, Jared Sylvester, Robert Brandon, Bryan Catanzaro, and Charles K. Nicholas. Malware detection by eating a whole EXE. In The Workshops of the The Thirty-Second AAAI Conference on Artificial Intelligence, New Orleans, Louisiana, USA, February 2-7, 2018, v...

    2018

  42. [50]

    VenkataKeerthy, Soumya Banerjee, Sayan Dey, Yashas Andaluri, Raghul PS, Subrahmanyam Kalyana- sundaram, Fernando Magno Quintão Pereira, and Ra- makrishna Upadrasta

    S. VenkataKeerthy, Soumya Banerjee, Sayan Dey, Yashas Andaluri, Raghul PS, Subrahmanyam Kalyana- sundaram, Fernando Magno Quintão Pereira, and Ra- makrishna Upadrasta. Vexir2vec: An architecture- neutral embedding framework for binary similarity. ACM Trans. Softw. Eng. Methodo...

    2025 doi

  43. [51]

    A survey of binary code sim- ilarity detection techniques.Electronics, 13(9),

    Liting Ruan, Qizhen Xu, Shunzhi Zhu, Xujing Huang, and Xinyang Lin. A survey of binary code sim- ilarity detection techniques.Electronics, 13(9),

  44. [52]

    Clap: Learning transferable binary code representations with natural language su- pervision

    Hao Wang, Zeyu Gao, Chao Zhang, Zihan Sha, Mingyang Sun, Yuchen Zhou, Wenyu Zhu, Wenju Sun, Han Qiu, and Xi Xiao. Clap: Learning transferable binary code representations with natural language su- pervision. InProceedings of the 33rd ACM SIG- SOFT International Symposium on Sof...

    2024

  45. [53]

    Improving ML-based binary function sim- ilarity detection by assessing and deprioritizing con- trol flow graph features

    Jialai Wang, Chao Zhang, Longfei Chen, Yi Rong, Yuxiao Wu, Hao Wang, Wende Tan, Qi Li, and Zong- peng Li. Improving ML-based binary function sim- ilarity detection by assessing and deprioritizing con- trol flow graph features. In33rd USENIX Secu- rity Symposium (USENIX Securit...

    2024

  46. [54]

    Enhancing machine learning based malware detection model by reinforcement learning

    Cangshuai Wu, Jiangyong Shi, Yuexiang Yang, and Wen- hua Li. Enhancing machine learning based malware detection model by reinforcement learning. InProceed- ings of the 8th International Conference on Communi- cation and Network Security, ICCNS ’18, page 74–78, New York, NY , U...

    2018

  47. [55]

    curl - command line tool and library for transferring data with urls, 2025-07-16

    Daniel Stenberg. curl - command line tool and library for transferring data with urls, 2025-07-16. URL: https: //curl.se/

    2025

  48. [56]

    LLM4Decompile: Decompiling binary code with large language models

    Hanzhuo Tan, Qi Luo, Jing Li, and Yuqun Zhang. LLM4Decompile: Decompiling binary code with large language models. In Yaser Al-Onaizan, Mohit Bansal, and Yun-Nung Chen, editors,Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, pages 3473–34...

    2024 doi

  49. [57]

    Semantic understanding of source and bi- nary code based on natural language processing

    Zhongtang Zhang, Shengli Liu, Qichao Yang, and Shichen Guo. Semantic understanding of source and bi- nary code based on natural language processing. In 2021 IEEE 4th Advanced Information Management, Communicates, Electronic and Automation Control Con- ference (IMCEC), volume 4...

    2021

  50. [60]

    Qwen3 technical report, 2025

    Qwen Team. Qwen3 technical report, 2025. URL: https://arxiv.org/abs/2505.09388, arXiv:2505.09388

    2025 arXiv

  51. [62]

    Busybox, 2024-09-27

    Denys Vlasenko, Bernhard Reutner-Fischer, and Rob Landley. Busybox, 2024-09-27. URL: https:// busybox.net/

    2024

  52. [66]

    Spain: Security patch anal- ysis for binaries towards understanding the pain and pills

    Zhengzi Xu, Bihuan Chen, Mahinthan Chandramohan, Yang Liu, and Fu Song. Spain: Security patch anal- ysis for binaries towards understanding the pain and pills. In2017 IEEE/ACM 39th International Conference on Software Engineering (ICSE), pages 462–472, 2017. doi:10.1109/ICSE.2017.49

    2017 doi

  53. [67]

    Order matters: Semantic- aware neural networks for binary code similar- ity detection.Proceedings of the AAAI Con- ference on Artificial Intelligence, 34(01):1145– 1152, Apr

    Zeping Yu, Rui Cao, Qiyi Tang, Sen Nie, Junzhou Huang, and Shi Wu. Order matters: Semantic- aware neural networks for binary code similar- ity detection.Proceedings of the AAAI Con- ference on Artificial Intelligence, 34(01):1145– 1152, Apr. 2020. URL: https://ojs.aaai. org/in...

    2020 doi

  54. [2014]

    URL: https://www

    USENIX Association. URL: https://www. usenix.org/conference/usenixsecurity14/ technical-sessions/presentation/egele

  55. [2017]

    URL: https://arxiv.org/abs/1703.03130, arXiv:1703.03130

    arXiv

  56. [2018]

    URL: https://aaai.org/ocs/index.php/ WS/AAAIW18/paper/view/16422

  57. [2019]

    URL: https://arxiv.org/abs/1810.04805, arXiv:1810.04805

    arXiv

  58. [2021]

    doi: 10.1145/3460120.3484587

    Association for Computing Machinery. doi: 10.1145/3460120.3484587

  59. [2024]

    URL: https://www.mdpi.com/2079-9292/ 13/9/1715,doi:10.3390/electronics13091715

    doi

  60. [2025]

    URL: https://arxiv.org/abs/2506.19453, arXiv:2506.19453

    arXiv

Pith tools

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