Pith. sign in

REVIEW 4 major objections 6 minor 61 references

Deconstructing Obfuscation: A four-dimensional framework for evaluating Large Language Models assembly code deobfuscation capabilities

T0 review · 4 major / 6 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read Commercial LLMs can undo some single obfuscation passes but fail universally when bogus control flow, instruction substitution, and control-flow flattening are stacked in one binary.

desk verdict A useful, honest qualitative benchmark of LLMs on OLLVM assembly; the 'universal failure' claim is overgeneralized from a single 14-line function. read the letter →

arxiv 2505.19887 v2 pith:WADBN5L4 submitted 2025-05-26 cs.SE cs.AIcs.CR

Anton Tkachenko , Dmitrij Suskevic , Benjamin Adolphi This is my paper · ORCID
classification cs.SEcs.AIcs.CR
keywords largelanguagemodelsassemblydeobfuscationcodeobfuscationcontrolflowflatteninginstructionsubstitutionbogusreverseengineeringAI-assistedsecurity
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

The paper asks whether general-purpose commercial LLMs, used without fine-tuning, can turn obfuscated x86-64 assembly back into readable logic. Testing eight commercial models that were state of the art as of March 2025 on a small C function obfuscated four ways, it finds that control-flow flattening is frequently undone, often autonomously; bogus control flow is overcome by a few strong models; instruction substitution resists almost everyone; and when all three techniques are stacked in one binary, every model fails even after extensive expert prompting. To explain this, the paper proposes four capability dimensions—Reasoning Depth, Pattern Recognition, Noise Filtering, and Context Integration—and a taxonomy of five recurring error types. The paper's central claim is that layered obfuscation currently defines an upper bound on LLM deobfuscation, so the realistic near-term use is human-guided analysis rather than full automation.

What carries the argument

The machinery is a two-part evaluation apparatus. An attacker-knowledge scale, from fully autonomous deobfuscation to "beyond expert correction," turns model outputs into a comparable hardness score. A four-dimensional framework then maps each obfuscation technique to the capability it attacks: bogus control flow attacks Reasoning Depth through always-true opaque predicates, instruction substitution attacks Pattern Recognition by replacing simple operations with equivalent but unfamiliar expressions, control flow flattening attacks Context Integration by shredding related code across a state-machine shell, and combined techniques attack all dimensions simultaneously. The framework does its explanatory work by predicting that a model fails precisely where a technique targets its weakest dimension.

What would settle it

Run the same five binaries through a fresh set of models; if any model, given only the disassembly and the standard request, autonomously produces a four-case switch on the input's two low bits whose arithmetic branches match the original function on random 32-bit inputs for the combined binary, the claimed upper bound would be broken.

Watch

Extended reading notes

Core claim

On the paper's own terms, the discovery is a three-tier resistance ordering with a hard ceiling. Control-flow flattening is the least resistant, with several models reaching Level 0 autonomous deobfuscation; bogus control flow is intermediate, with one model at Level 0 and most others requiring guidance; instruction substitution and the combined binary are highly resistant, requiring Level 4 or higher intervention or producing no usable output. The paper attributes this ordering to its four dimensions: each single technique primarily taxes one dimension, while the combined binary taxes all four at once, producing universal failure at the top attacker-knowledge level. Five error classes—predicate misinterpretation, structural mapping errors, control flow misinterpretation, arithmetic transformation errors, and constant propagation errors—recur across models and mark where the dimensional breakdowns surface.

Load-bearing premise

The load-bearing premise is that one 14-line C function, compiled with a single obfuscating compiler and disassembled with one engine, stands in for the deobfuscation difficulty of real-world obfuscated binaries; the paper itself acknowledges this as a sample-diversity limitation in Section 4.3.

Editorial extensions

If this is right

  • Software that must resist AI-assisted analysis can currently rely on layered obfuscation: stacking bogus control flow, instruction substitution, and control-flow flattening defeated every tested model.
  • LLM-based deobfuscation tools should be built for assisted analysis rather than unattended reconstruction, because even successful models require human verification of arithmetic and constants.
  • The four dimensions give a common language for comparing future LLMs, letting a gain in deobfuscation be credited to a specific capability rather than to raw scale.
  • The five error classes give obfuscation designers concrete targets, including constants that invite mis-transcription and arithmetic identities that resist simplification.
  • Analysts can use the three resistance tiers to predict which obfuscated samples are likely to yield to LLM tooling and which still require expert manual reverse engineering.

Reading between the lines

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

  • A testable reading of the paper's account: if arithmetic blocks that fail inside full assembly are simplified correctly in isolation, the binding constraint is contextual noise rather than pattern recognition itself.
  • The framework suggests that simply enlarging context windows will not move the instruction-substitution tier, because the bottleneck is expression equivalence, not long-range memory.
  • The single-benchmark design leaves open that the universal-failure ceiling may be specific to this compiler, this 14-line function, and this disassembly; testing other obfuscators and larger programs is the natural way to check.
  • The five error classes could be turned into a per-dimension benchmark, giving future models pass/fail scores on each capability instead of one aggregate deobfuscation score.
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 / 6 minor

Summary. The paper evaluates eight commercial LLMs on deobfuscating assembly produced from a single 14-line C function obfuscated with OLLVM, using five configurations: baseline, bogus control flow, instruction substitution, control flow flattening, and a combination of all three. From qualitative transcript analysis and manually assigned attacker-knowledge levels (0–5), the authors identify five error patterns, propose a four-dimensional capability framework (Reasoning Depth, Pattern Recognition, Noise Filtering, Context Integration), and introduce a three-tier resistance model. The headline claim is that all tested models failed against combined obfuscation, which the authors interpret as a universal upper bound on current LLM deobfuscation capability.

Significance. The paper contributes a valuable qualitative dataset: full transcripts are publicly archived, the manual comparison against specific assembly addresses is careful, and the error taxonomy (predicate misinterpretation, structural mapping, control-flow misinterpretation, arithmetic transformation, constant propagation) is a useful organizing device for future work. If the findings generalize, they would inform both LLM-assisted reverse engineering and the design of obfuscation techniques. However, the significance is currently capped by three load-bearing weaknesses: the 'universal failure' conclusion rests on one 14-line function and five models; the Level-5 labels rest on subjective judgment without an objective equivalence check; and the four-dimensional framework is derived from and then used to explain the same experiments. Because the central empirical material is reproducible and the framing can be corrected, the paper is worth revising rather than rejecting.

major comments (4)
  1. [Section 3.4 / Table 2 / Section 4.3] The claim that combined techniques cause 'universal failure' that 'defines a clear upper bound on current capabilities' is supported only by five model entries in Table 2, all tested on one 14-line C function compiled once with one OLLVM configuration. This conflates 'these five models failed on this one binary under these prompts' with 'combined obfuscation defeats advanced LLMs.' Section 4.3 (Sample Diversity) itself concedes that the evaluation is limited to a single well-documented OLLVM program. To make the upper-bound claim load-bearing, the authors would need to test multiple programs, obfuscators, and code sizes, or explicitly restrict the conclusion to the evaluated sample.
  2. [Section 2 / Section 3.2.5 / Table 2] The attacker-knowledge scale (Levels 0–5) is subjective, and the critical Level-5 assignments are not backed by an objective success criterion. The transcripts in Sections 3.4.1–3.4.5 show models sometimes recovering the switch structure while miscomputing arithmetic; labeling these 'Beyond Expert Correction' requires a judgment about expert rework that was never tested. No deobfuscated output is compiled or executed to verify semantic equivalence, and Section 3.2.5 explicitly states that Claude's transformation 'remains unverified whether this transformation preserves the exact behavior.' Inter-rater reliability or a reproducible scoring rubric is needed for the central quantitative-looking entries in Table 2.
  3. [Section 4.1 / Section 4.2] The four-dimensional framework and the three-tier resistance model are presented as explanatory and predictive, but they are derived from the same experiments they are invoked to explain (Section 4.1: 'derived from pattern analysis across multiple obfuscation techniques and models'). The dimensional prioritization (BCF→Reasoning Depth, IS→Pattern Recognition, CFF→Context Integration) is a post-hoc fit, and no independent prediction or cross-validation is offered. Without an out-of-sample test, the framework's 'predictive value' (claimed in the opening of Section 4) is unsupported.
  4. [Abstract / Section 4.2.2 / Table 2] The three-tier resistance model is internally inconsistent. The abstract states that bogus control flow has low resistance and control flow flattening has moderate resistance, but Section 4.2.2 assigns control flow flattening to 'Low Resistance Techniques' and bogus control flow to 'Moderate Resistance Techniques.' The empirical data in Table 2 support the Section 4.2.2 ordering: control flow flattening entries are mostly Levels 0–2, whereas bogus control flow entries reach Levels 4–5. The abstract should be corrected, or the model should be reconciled with the table.
minor comments (6)
  1. [Abstract / Section 2] The abstract says 'seven state-of-the-art models,' while Section 2 says 'eight' and Table 1 lists eight models; the count should be unified.
  2. [Table 1 / Table 2 / Section 3.4] Model naming is inconsistent across the paper: 'o1' in Table 1, 'GPT-Pro-o1' in Table 2, and 'ChatGPT-pro-o1' in Section 3.4.2; likewise 'GPT-3o Mini High' appears as 'GPT-3o Mini' elsewhere. Please standardize.
  3. [Section 3.4] The opening sentence states that GPT-4o, GPT-3o Mini, and Grok2 were not tested for combined techniques 'due to their particularly poor overall performance'; this selection criterion should be stated before the 'universal failure' claim and reflected in the wording of the conclusion.
  4. [References] Reference [41] lists a last-access date of '1 April 2026,' which is after the paper's arXiv submission date of May 2025; please verify the date.
  5. [Listing 1] Listing 1 contains formatting artifacts such as 'un si gn ed int'; the listings throughout should be cleaned to ensure readability.
  6. [Table 2] Table 2 entries like '1-2' and '0-1' mix ranges with point values; a brief definition of how ranges are derived (e.g., multiple trials) would improve interpretability.

Circularity Check

2 steps flagged · score 5.0 of 10

The empirical failure data are self-contained, but the four-dimensional framework and its per-technique dimension mapping are post-hoc relabelings of the same Table 2 outcomes, making the paper's explanatory layer partially circular by construction.

  1. renaming known result [Section 4.1, 'Theoretical Framework for LLM Deobfuscation']
    "Our four-dimensional framework, derived from pattern analysis across multiple obfuscation techniques and models, provides a systematic foundation for characterizing how LLMs process obfuscated code and why specific techniques present greater analytical challenges than others."

    The four dimensions are not specified or measured independently of the experiments; they are induced from the same performance patterns they are then used to explain. The phrase 'derived from pattern analysis' makes this explicit: the framework is a post-hoc categorization of Table 2 outcomes, not an independent theoretical construct. Consequently, the framework cannot fail on these data, and its claimed 'explanatory power for our results' is a restatement of the results in new vocabulary rather than an independent derivation.

  2. fitted input called prediction [Section 4.2, 'Mapping Framework Dimensions to Empirical Results', 'Dimensional Prioritization by Obfuscation Type']
    "Our results suggest that each obfuscation technique challenges a different primary dimension: ... This dimensional mapping explains the inconsistent performance patterns observed across techniques: models excel where their dimensional strengths align with technique demands, while struggling where techniques target their dimensional weaknesses."

    The 'dimensional demands' of each technique and the 'dimensional strengths' of each model are both read off the same Table 2 scores: CFF low intervention levels are labeled strong Context Integration, IS high intervention levels are labeled weak Pattern Recognition, and so on. The mapping is therefore fitted to the outcomes it is invoked to explain. No independent test measures Reasoning Depth, Pattern Recognition, Noise Filtering, or Context Integration, so the explanation is forced by construction: the framework is the performance table renamed as a theory.

full rationale

The empirical core of the paper is not circular: the evaluation uses a fixed OLLVM-obfuscated benchmark, documented prompts, published transcripts, and a defined attacker-knowledge scale, and the 'universal failure against combined techniques' claim is a direct reading of the Level 5 entries in Table 2. Those observations stand on their own, and the paper's explicit limitations sections (single OLLVM sample, subjective level assignments, unverified semantic equivalence) are correctness and generalization risks, not circularity. The circularity is confined to the theoretical layer. The four-dimensional framework is openly described as 'derived from pattern analysis across multiple obfuscation techniques and models' (Section 4.1), and then the same framework is used to 'explain' those very patterns, including the dimensional prioritization mapping in Section 4.2. Because the dimension assignments and the model strength attributions come from the same experimental matrix, the explanation reduces by construction to a relabeling of the data. This is partial circularity: the empirical measurements are genuine, but the advertised explanatory framework does not add independent predictive content. Self-citation is not load-bearing here: the only author-owned artifact cited is the transcript repository [60], and the Quarkslab baseline [36] is external. The score of 5 reflects a substantial post-hoc relabeling in the central theoretical contribution while acknowledging that the underlying failure data are independently generated.

Assumptions & free parameters 0 free parameters · 5 assumptions · 5 invented entities

The paper introduces no numeric fitted constants. Its theoretical constructs (four dimensions, resistance tiers, knowledge levels) are qualitative and derived from the same data they explain. The axioms are mostly domain assumptions about toolchain reliability and ground truth; the framework itself is an ad hoc postulate lacking independent validation.

assumptions (5)
  • domain assumption The original unobfuscated C function (Listing 1) is the ground truth for evaluating deobfuscation success.
    Section 2 uses the Quarkslab analysis [36] as an implicit baseline and never verifies deobfuscated outputs by execution or equivalence checking.
  • domain assumption Capstone disassembly of the OLLVM-compiled binaries is accurate and complete.
    Section 2: 'Each binary was disassembled using Capstone [38], producing x86_64 assembly code for our detailed low-level analysis.'
  • ad hoc to paper The four-dimension framework (Reasoning Depth, Pattern Recognition, Noise Filtering, Context Integration) is a sufficient and correct decomposition of LLM deobfuscation ability.
    Section 4.1 states the framework is 'derived from pattern analysis across multiple obfuscation techniques and models'; no independent validation is offered.
  • standard math The product of two consecutive integers is always even (mathematical property behind the opaque predicate analysis).
    Section 3.1 uses this property to judge whether models correctly identified invariant predicates.
  • ad hoc to paper The attacker knowledge-level scale (0 to 5) is a valid ordinal measure of deobfuscation difficulty.
    Section 2 defines the levels; Section 4.3 acknowledges the framework's reproducibility remains a challenge.
invented entities (5)
  • Reasoning Depth dimension
    purpose: Explains why some models recognize invariant opaque predicates and others do not.
    Defined post hoc in Section 4.1; no falsifiable prediction is made that could be tested independently of the observed data.
  • Pattern Recognition dimension
    purpose: Explains differences in reconstructing obfuscated arithmetic and structural patterns.
    Same post hoc status; mapped to instruction substitution based on the same experiments.
  • Noise Filtering dimension
    purpose: Explains ability to separate essential logic from obfuscation artifacts.
    Introduced as a construct, with no independent measure beyond the analyzed transcripts.
  • Context Integration dimension
    purpose: Explains performance on control flow flattening and fragmented code segments.
    Attributed to transformer attention, but never measured separately from other dimensions.
  • Three-tier resistance model
    purpose: Categorizes obfuscation techniques by observed difficulty (low, moderate, high resistance).
    Directly re-labels the outcomes in Table 2; no independent prediction of resistance is made.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Deconstructing Obfuscation: A four-dimensional framework for evaluating Large Language Models assembly code deobfuscation capabilities." pith.science (2026). https://pith.science/paper/WADBN5L4

@misc{pith2026250519887,
  author       = {Pith},
  title        = {Pith review of: Deconstructing Obfuscation: A four-dimensional framework for evaluating Large Language Models assembly code deobfuscation capabilities},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/WADBN5L4}},
  note         = {Machine review of arXiv:2505.19887}
}
read the original abstract

Large language models (LLMs) have shown promise in software engineering, yet their effectiveness for binary analysis remains unexplored. We present the first comprehensive evaluation of commercial LLMs for assembly code deobfuscation. Testing seven state-of-the-art models against four obfuscation scenarios (bogus control flow, instruction substitution, control flow flattening, and their combination), we found striking performance variations--from autonomous deobfuscation to complete failure. We propose a theoretical framework based on four dimensions: Reasoning Depth, Pattern Recognition, Noise Filtering, and Context Integration, explaining these variations. Our analysis identifies five error patterns: predicate misinterpretation, structural mapping errors, control flow misinterpretation, arithmetic transformation errors, and constant propagation errors, revealing fundamental limitations in LLM code processing.We establish a three-tier resistance model: bogus control flow (low resistance), control flow flattening (moderate resistance), and instruction substitution/combined techniques (high resistance). Universal failure against combined techniques demonstrates that sophisticated obfuscation remains effective against advanced LLMs. Our findings suggest a human-AI collaboration paradigm where LLMs reduce expertise barriers for certain reverse engineering tasks while requiring human guidance for complex deobfuscation. This work provides a foundation for evaluating emerging capabilities and developing resistant obfuscation techniques.x deobfuscation. This work provides a foundation for evaluating emerging capabilities and developing resistant obfuscation techniques.

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

61 extracted references · 49 canonical work pages

  1. [1]

    BERT: Pre-training of deep bidirectional transformers for language understanding

    Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In Jill Burstein, Christy Doran, and Thamar Solorio, editors,Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volu...

    2019

  2. [2]

    Language models are few-shot learners

    Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Nee- lakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-V oss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel Ziegler, Jeffrey Wu, Clemens Winter, Chris Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott...

    work page 1901

  3. [3]

    Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. J. Mach. Learn. Res., 21(1), January 2020

    work page 2020

  4. [4]

    Gomez, Łukasz Kaiser, and Illia Polosukhin

    Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Proceedings of the 31st International Conference on Neural Information Processing Systems, NIPS’17, pages 6000–6010, Red Hook, NY , USA, 2017. Curran Associates Inc

    work page 2017

  5. [5]

    CodeBERT: A pre-trained model for programming and natural languages

    Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, and Ming Zhou. CodeBERT: A pre-trained model for programming and natural languages. In Trevor Cohn, Yulan He, and Yang Liu, editors, Findings of the Association for Computational Linguistics: EMNLP 2020, pages 1536–1547, Online, November ...

    work page 2020

  6. [6]

    Wizardcoder: Empowering code large language models with evol-instruct

    Ziyang Luo, Can Xu, Pu Zhao, Qingfeng Sun, Xiubo Geng, Wenxiang Hu, Chongyang Tao, Jing Ma, Qingwei Lin, and Daxin Jiang. Wizardcoder: Empowering code large language models with evol-instruct. In The Twelfth International Conference on Learning Representations, 2024

    2024

  7. [7]

    Repobench: Benchmarking repository-level code auto-completion systems

    Tianyang Liu, Canwen Xu, and Julian McAuley. Repobench: Benchmarking repository-level code auto-completion systems. In International Conference on Learning Representations, 2024

    work page 2024

  8. [8]

    Livecodebench: Holistic and contamination free evaluation of large language models for code

    Naman Jain, King Han, Alex Gu, Wen-Ding Li, Fanjia Yan, Tianjun Zhang, Sida Wang, Armando Solar-Lezama, Koushik Sen, and Ion Stoica. Livecodebench: Holistic and contamination free evaluation of large language models for code. arXiv preprint arXiv:2403.07974, 2025

    arXiv 2025

Show all 61 references
  1. [9]

    Is model attention aligned with human attention? an empirical study on large language models for code generation

    Bonan Kou, Shengmai Chen, Zhijie Wang, Lei Ma, and Tianyi Zhang. Is model attention aligned with human attention? an empirical study on large language models for code generation. arXiv preprint arXiv:2306.01220, 2023

    2023 arXiv

  2. [10]

    Robustness, security, privacy, explainability, efficiency, and usability of large language models for code

    Zhou Yang, Zhensu Sun, Hong Jin Kang, Bowen Xu, Junda He, and David Lo. Robustness, security, privacy, explainability, efficiency, and usability of large language models for code. arXiv preprint arXiv:2403.07506, 2024

    2024 arXiv

  3. [11]

    Codegen: An open large language model for code with multi-turn program synthesis

    Erik Nijkamp, Hiroaki Hayashi, Caiming Xiong, Silvio Savarese, and Yingbo Zhou. Codegen: An open large language model for code with multi-turn program synthesis. arXiv preprint arXiv:2203.13474, 2022

    2022 arXiv

  4. [12]

    Automatically recom- mend code updates: Are we there yet? ACM Trans

    Yue Liu, Chakkrit Tantithamthavorn, Yonghui Liu, Patanamon Thongtanunam, and Li Li. Automatically recom- mend code updates: Are we there yet? ACM Trans. Softw. Eng. Methodol., 33(8), December 2024

    2024

  5. [13]

    Palacio, Alejandro Velasco, Daniel Rodríguez-Cárdenas, Kevin Moran, and Denys Poshyvanyk

    David N. Palacio, Alejandro Velasco, Daniel Rodríguez-Cárdenas, Kevin Moran, and Denys Poshyvanyk. Evaluat- ing and explaining large language models for code using syntactic structures. ArXiv, abs/2308.03873, 2023

    2023 arXiv

  6. [14]

    Autocoderover: Autonomous program improvement

    Yuntong Zhang, Haifeng Ruan, Zhiyu Fan, and Abhik Roychoudhury. Autocoderover: Autonomous program improvement. In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis, ISSTA 2024, pages 1592–1604, New York, NY , USA, 2024. Association fo...

    2024

  7. [15]

    Yu, Qiang Yang, and Xing Xie

    Yupeng Chang, Xu Wang, Jindong Wang, Yuan Wu, Linyi Yang, Kaijie Zhu, Hao Chen, Xiaoyuan Yi, Cunxiang Wang, Yidong Wang, Wei Ye, Yue Zhang, Yi Chang, Philip S. Yu, Qiang Yang, and Xing Xie. A survey on evaluation of large language models. ACM Trans. Intell. Syst. Technol., 15(...

    2024

  8. [16]

    The stack: 3 tb of permissively licensed source code

    Denis Kocetkov, Raymond Li, LI Jia, Chenghao Mou, Yacine Jernite, Margaret Mitchell, Carlos Muñoz Ferrandis, Sean Hughes, Thomas Wolf, Dzmitry Bahdanau, and others. The stack: 3 tb of permissively licensed source code. Transactions on Machine Learning Research, 2022

    2022

  9. [17]

    Evaluating large language models trained on code

    Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, and others. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374, 2021

    2021 arXiv

  10. [18]

    Large language models meet nl2code: A survey

    Daoguang Zan, Bei Chen, Dejian Yang, Zeqi Lin, Minsu Kim, Bei Guan, Yongji Wang, Jian-Guang Lou, and Weizhu Chen. Large language models meet nl2code: A survey. In Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), p...

    2023

  11. [19]

    Codet5+: Open code large language models for code understanding and generation

    Yue Wang, Hung Le, Akhilesh Gotmare, Nghi Bui, Junnan Li, and Steven Hoi. Codet5+: Open code large language models for code understanding and generation. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pages 1069–1088, 2023

    2023

  12. [20]

    Securing mobile agents control flow using opaque predicates

    Anirban Majumdar and Clark Thomborson. Securing mobile agents control flow using opaque predicates. In Proceedings of the 9th International Conference on Knowledge-Based Intelligent Information and Engineering Systems - Volume Part III, KES’05, pages 1065–1071, Berlin, Heidelb...

    2005

  13. [21]

    A large-scale empirical study on the effects of code obfuscations on android apps and anti-malware products

    Mahmoud Hammad, Joshua Garcia, and Sam Malek. A large-scale empirical study on the effects of code obfuscations on android apps and anti-malware products. In Proceedings of the 40th International Conference on Software Engineering, ICSE ’18, pages 421–431, New York, NY , USA, ...

    2018

  14. [22]

    Sok: Automatic deobfuscation of virtualization-protected applications

    Patrick Kochberger, Sebastian Schrittwieser, Stefan Schweighofer, Peter Kieseberg, and Edgar Weippl. Sok: Automatic deobfuscation of virtualization-protected applications. In Proceedings of the 16th International Conference on Availability, Reliability and Security, ARES ’21, ...

    2021

  15. [23]

    Obfuscation of executable code to improve resistance to static disassembly

    Cullen Linn and Saumya Debray. Obfuscation of executable code to improve resistance to static disassembly. In Proceedings of the 10th ACM Conference on Computer and Communications Security, CCS ’03, pages 290–299, New York, NY , USA, 2003. Association for Computing Machinery

    2003

  16. [24]

    Deobfuscating android native binary code

    Zeliang Kan, Haoyu Wang, Lei Wu, Yao Guo, and Guoai Xu. Deobfuscating android native binary code. In 2019 IEEE/ACM 41st International Conference on Software Engineering: Companion Proceedings (ICSE-Companion), pages 322–323, 2019. 30 arXiv Template A PREPRINT

    2019

  17. [25]

    Malware detection in android based on dynamic analysis

    Taniya Bhatia and Rishabh Kaushal. Malware detection in android based on dynamic analysis. In 2017 International Conference on Cyber Security And Protection Of Digital Services (Cyber Security), pages 1–6, 2017

    2017

  18. [26]

    Dynamic security analysis on android: A systematic literature review

    Thomas Sutter, Timo Kehrer, Marc Rennhard, Bernhard Tellenbach, and Jacques Klein. Dynamic security analysis on android: A systematic literature review. IEEE Access, 12:57261–57287, 2024

    2024

  19. [27]

    The IDA Pro Book: The Unofficial Guide to the World’s Most Popular Disassembler

    Chris Eagle. The IDA Pro Book: The Unofficial Guide to the World’s Most Popular Disassembler. No Starch Press, 2011

    2011

  20. [28]

    Ghidra: A software reverse engineering framework

    Robert Joyce. Ghidra: A software reverse engineering framework. In RSA Conference, San Francisco, CA, 2019

    2019

  21. [29]

    Collberg and Clark Thomborson

    Christian S. Collberg and Clark Thomborson. Watermarking, tamper-proofing, and obfuscation: Tools for software protection. IEEE Transactions on Software Engineering, 28(8):735–746, 2002

    2002

  22. [30]

    Smartdec: Approaching c++ decompilation

    Alexander Fokin, Egor Derevenetc, Alexander Chernov, and Katerina Troshina. Smartdec: Approaching c++ decompilation. In Proceedings of the 2011 18th Working Conference on Reverse Engineering, WCRE ’11, pages 347–356, USA, 2011. IEEE Computer Society

    2011

  23. [31]

    Evolving exact decompilation

    Eric Schulte, Jonathan Ruchti, Matt Noonan, David Ciarletta, and Alexey Loginov. Evolving exact decompilation. In Workshop on Binary Analysis Research (BAR 2018), San Diego, CA, USA, 2018

    2018

  24. [32]

    Beyond the c: Retargetable decompilation using neural machine translation

    Iman Hosseini and Brendan Dolan-Gavitt. Beyond the c: Retargetable decompilation using neural machine translation. Arxiv, 2022

    2022

  25. [33]

    Dobf: a deobfuscation pre- training objective for programming languages

    Marie-Anne Lachaux, Baptiste Roziere, Marc Szafraniec, and Guillaume Lample. Dobf: a deobfuscation pre- training objective for programming languages. In Proceedings of the 35th International Conference on Neural Information Processing Systems, NIPS ’21, Red Hook, NY , USA, 202...

    2021

  26. [34]

    Resym: Harnessing llms to recover variable and data structure symbols from stripped binaries

    Danning Xie, Zhuo Zhang, Nan Jiang, Xiangzhe Xu, Lin Tan, and Xiangyu Zhang. Resym: Harnessing llms to recover variable and data structure symbols from stripped binaries. In Proceedings of the 2024 on ACM SIGSAC Conference on Computer and Communications Security, CCS ’24, page...

    2024

  27. [35]

    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

  28. [36]

    Deobfuscation: Recovering an ollvm-protected pro- gram

    Jonathan Salwan, Sébastien Bardin, and Marie-Laure Potet. Deobfuscation: Recovering an ollvm-protected pro- gram. https://blog.quarkslab.com/deobfuscation-recovering-an-ollvm-protected-program. html, 2017. 20 March 2023, last accessed

    2017

  29. [37]

    Obfuscator-LLVM – software protection for the masses

    Pascal Junod, Julien Rinaldini, Johan Wehrli, and Julie Michielin. Obfuscator-LLVM – software protection for the masses. In Brecht Wyseur, editor, Proceedings of the IEEE/ACM 1st International Workshop on Software Protection, SPRO’15, Firenze, Italy, May 19th, 2015, pages 3–9....

    2015

  30. [38]

    Capstone: The ultimate disassembler

    Anh Quynh Nguyen and Capstone Contributors. Capstone: The ultimate disassembler. https://www. capstone-engine.org/, 2023. 16 March 2023 last accessed

    2023

  31. [39]

    Chi, Quoc V

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed H. Chi, Quoc V . Le, and Denny Zhou. Chain-of-thought prompting elicits reasoning in large language models. In Proceedings of the 36th International Conference on Neural Information Processing Sy...

    2022

  32. [40]

    Claude 3.7 sonnet and claude code

    Anthropic PBC. Claude 3.7 sonnet and claude code. https://www.anthropic.com/news/ claude-3-7-sonnet . 24 February 2025 last accessed

    2025

  33. [41]

    Openai models

    OpenAI. Openai models. https://platform.openai.com/docs/models. 1 April 2026 last accessed

    2026

  34. [42]

    Grok 3 beta — the age of reasoning agents.https://x.ai/news/grok-3

    XAI. Grok 3 beta — the age of reasoning agents.https://x.ai/news/grok-3. 19 February 2025 last accessed

    2025

  35. [43]

    Grok-2 beta release

    XAI. Grok-2 beta release. https://x.ai/news/grok-2. 7 March 2025 last accessed

    2025

  36. [44]

    Obfuscator-llvm

    Obfuscator-LLVM Team. Obfuscator-llvm. https://github.com/obfuscator-llvm/obfuscator/wiki. 3 March 2025 last accessed

    2025

  37. [45]

    DeepSeek-AI and Daya Guo and Dejian Yang and Haowei Zhang and Junxiao Song and Ruoyu Zhang and Runxin Xu and Qihao Zhu and Shirong Ma and Peiyi Wang and Xiao Bi and Xiaokang Zhang and Xingkai Yu and Yu Wu and Z. F. Wu and Zhibin Gou and Zhihong Shao and Zhuoshu Li and Ziyi Gao...

    2025

  38. [46]

    Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints

    Patrick Cousot and Radhia Cousot. Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints. In Proceedings of the 4th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages, POPL ’77, pages 238–...

    1977

  39. [47]

    C. E. Shannon. A mathematical theory of communication. The Bell System Technical Journal, 27(3):379–423, 1948

    1948

  40. [48]

    Program slicing

    Mark Weiser. Program slicing. In Proceedings of the 5th International Conference on Software Engineering, ICSE ’81, pages 439–449. IEEE Press, 1981

    1981

  41. [49]

    Goodfellow, Jonathon Shlens, and Christian Szegedy

    Ian J. Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. CoRR, abs/1412.6572, 2014

    2014 arXiv

  42. [50]

    Baxter, A

    I.D. Baxter, A. Yahin, L. Moura, M. Sant’Anna, and L. Bier. Clone detection using abstract syntax trees. In Proceedings. International Conference on Software Maintenance (Cat. No. 98CB36272), pages 368–377, 1998

    1998

  43. [51]

    Kamiya, S

    T. Kamiya, S. Kusumoto, and K. Inoue. Ccfinder: a multilinguistic token-based code clone detection system for large scale source code. IEEE Transactions on Software Engineering, 28(7):654–670, 2002

    2002

  44. [52]

    Barr, Zhendong Su, Mark Gabel, and Premkumar Devanbu

    Abram Hindle, Earl T. Barr, Zhendong Su, Mark Gabel, and Premkumar Devanbu. On the naturalness of software. In 2012 34th International Conference on Software Engineering (ICSE), pages 837–847, 2012

    2012

  45. [53]

    Barr, Premkumar Devanbu, and Charles Sutton

    Miltiadis Allamanis, Earl T. Barr, Premkumar Devanbu, and Charles Sutton. A survey of machine learning for big code and naturalness. ACM Comput. Surv., 51(4), July 2018

    2018

  46. [54]

    Frances E. Allen. Control flow analysis. SIGPLAN Not., 5(7):1–19, July 1970

    1970

  47. [55]

    Survey of hallucination in natural language generation

    Ziwei Ji, Nayeon Lee, Rita Frieske, Tiezheng Yu, Dan Su, Yan Xu, Etsuko Ishii, Ye Jin Bang, Andrea Madotto, and Pascale Fung. Survey of hallucination in natural language generation. ACM Comput. Surv., 55(12), March 2023

    2023

  48. [56]

    Sok: (state of) the art of war: Offensive techniques in binary analysis

    Yan Shoshitaishvili, Ruoyu Wang, Christopher Salls, Nick Stephens, Mario Polino, Andrew Dutcher, John Grosen, Siji Feng, Christophe Hauser, Christopher Kruegel, and Giovanni Vigna. Sok: (state of) the art of war: Offensive techniques in binary analysis. In 2016 IEEE Symposium ...

    2016

  49. [57]

    Schwartz

    David Brumley, Ivan Jager, Thanassis Avgerinos, and Edward J. Schwartz. Bap: a binary analysis platform. In Proceedings of the 23rd International Conference on Computer Aided Verification , CA V’11, pages 463–469, Berlin, Heidelberg, 2011. Springer-Verlag

    2011

  50. [58]

    Practical Reverse Engineering: x86, x64, ARM, Windows Kernel, Reversing Tools, and Obfuscation

    Bruce Dang, Alexandre Gazet, Elias Bachaalany, and Sbastien Josse. Practical Reverse Engineering: x86, x64, ARM, Windows Kernel, Reversing Tools, and Obfuscation. Wiley Publishing, 1st edition, 2014. 32 arXiv Template A PREPRINT

    2014

  51. [59]

    Jens Anders, Pablo Andreu, Bernd Becker, Steffen Becker, Riccardo Cantoro, Nikolaos I. Deligiannis, Nourhan Elhamawy, Tobias Faller, Carles Hernandez, Nele Mentens, Mahnaz Namazi Rizi, Ilia Polian, Abolfazl Sajadi, Mathias Sauer, Denis Schwachhofer, Matteo Sonza Reorda, Todor ...

    2023

  52. [60]

    Tjbim/deconstructing-obfuscation: Llm assembly deobfuscation study

    Anton Tkachenko. Tjbim/deconstructing-obfuscation: Llm assembly deobfuscation study. Zenodo, April 2025. https://doi.org/10.5281/zenodo.15294891 33

    2025 doi

  53. [2019]

    Association for Computational Linguistics

Pith tools

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