CTL Model Checking of Concurrent Self Modifying Code
Tayssir Touili, Olzhas Zhangeldinov · SPIRE - Sciences Po Institutional REpository · 2026
International audience
Cited by 0Open access
Search 250 million research papers
Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.
About 474 papers for “self-modifying code”
Unconditional self-modifying code elimination with dynamic compiler optimizations
Isabelle Gnaedig, Matthieu Kaczmarek, Daniel Reynaud et al. · 2010
This paper deals with the issue of self-modifying code and packed programs, a long-standing problem commonly addressed by emulation techniques and memory dumps. We propose an original semantics-based approach to simplify dynamic code analysis, by using compiler optimization techniques to get rid of code-generating instructions. For this, we use classic slicing techniques to identify code dependencies. As it is semantics-based, our approach allows us to rely on strongly established formal methods and is a promising approach for handling packed programs.
Cited by 0
Control flow obfuscation with irreducible loopsand self-modifying code
Gregory Morse, Midya Alqaradaghi, Tamás Kozsik · Publicationes Mathematicae Debrecen · 2022
This paper considers an obfuscation scheme designed around runtime generated self-modifying code and irreducible loops, both of which are notoriously difficult to reason about.This leads to a mechanism for both source and binary code that increase resistance to static analysis as well as dynamic analysis.By making use of the fact that static analysis of self-modifying code has limits in decidability as per Rice's theorem, and that transformation of irreducible loops to reducible ones using techniques such as node-splitting or introduction of variables can have a quadratic complexity increase on the size of the control-flow graph.Our construction looks at turning an algorithm into the lowest abstraction level with multi-input logic gates, to evaluate the most generic perspective on the scheme though it is applicable to any control-flow graph.A final benefit is that although complicated and naturally inter-related, the different ideas could be applied separately.
Cited by 1Open access
SMaCk: Efficient Instruction Cache Attacks via Self-Modifying Code Conflicts
Seonghun Son, Daniel Moghimi, Berk Gülmezoğlu · 2025
Self-modifying code (SMC) allows programs to alter their own instructions, optimizing performance and functionality on x86 processors. Despite its benefits, SMC introduces unique microarchitectural behaviors that can be exploited for malicious purposes. In this paper, we explore the security implications of SMC by examining how specific x86 instructions affecting instruction cache lines lead to measurable timing discrepancies between cache hits and misses. These discrepancies facilitate refined cache attacks, making them less noisy and more effective. We introduce novel attack techniques that leverage these timing variations to enhance existing methods such as Prime+Probe and Flush+Reload. Our advanced techniques allow adversaries to more precisely attack cryptographic keys and create covert channels akin to Spectre across various x86 platforms. Finally, we propose a dynamic detection methodology utilizing hardware performance counters to mitigate these enhanced threats.
Cited by 0Open access
Pure Infinitely Self-Modifying Code is Realizable and Turing-complete
Gregory Morse · International Journal of Electronics and Telecommunications · 2018
Although self-modifying code has been shyed away from due to its complexity and discouragement due to safety issues, it nevertheless provides for a very unique obfuscation method and a different perspective on the relationship between data and code. The generality of the von Neumann architecture is hardly realized by today’s processor models. A code-only model is shown where every instruction merely modifies other instructions yet achieves the ability to compute and Turing machine operation is easily possible.
Cited by 1Open access
A Survey of Software Protection Methods Based on Self-Modifying Code
Xianya Mi, Yi Zhang, Baosheng Wang et al. · 2015
As the software industry develops rapidly, protecting software intellectual property from reverse attacker has become more and more important. The technical way is to make software hard to understand and will cost attackers more time and energy to crack the software than they can take. Self-modifying code is a code changing mechanism based on stored program architecture and has been widely used in software protection methods these years. This article introduces four different kinds of software protection methods using self-modifying code, and classifies the features of the implementation. The protection intensity and overheads are evaluated respectively. This article also compares the advantages and drawbacks of each method, and makes conclusions about the developing trends of software protection technologies.
Cited by 4
System Metamodeling of Open-Ended Evolution Implemented with Self-Modifying Code
Patrik Christen · Complex Systems · 2024
Having a model and being able to implement open-ended evolutionary systems is important for advancing our understanding of open-endedness. Complex systems science and the newest generation high-level programming languages provide intriguing possibilities to do so. Here, some recent advances in modeling and implementing open-ended evolutionary systems are reviewed (an earlier and shorter version was presented at [1]). Then, the so-called allagmatic method is introduced as a computational framework that describes, models, implements and allows interpreting complex systems using system metamodeling. Based on recent advances, the model building blocks evolving entities, entity lifetime parameter, co-evolutionary operations of entities and environment and combinatorial interactions are identified to characterize open-ended evolutionary systems. They are formalized within the system metamodel, providing a formal description of an open-ended evolutionary system. The study further provides a self-modifying code prototype in C# and guidance to create code blocks for an intrinsic implementation of open-ended evolutionary systems. This is achieved by controlling the self-modification of program code within the abstractly defined building blocks of the system metamodel. It is concluded that the identified model building blocks and the proposed self-modifying code provide a promising starting point to model and implement open-endedness in a computational system that potentially allows us to interpret novelties at runtime.
Cited by 0Open access
Flexible High-Performance Matrix Multiply via a Self-Modifying Runtime Code
Greg Henry · 2001
With the advent of architectures with multiple levels of memory hierarchies, the quest for high performance implementation of commonly used linear algebra operations has become progressively more complex. Fortunately, recent research has shown that a large class of such operations can be implemented in a relatively portable fashion provided a high-performance matrix-matrix multiplication routine is available for a given architecture.
Cited by 0
RePEconstruct: reconstructing binaries with self-modifying code and import address table destruction
David Korczynski · 2016
Reverse engineering packed binaries remain a tedious challenge as code packing is continuously being used by malware to hinder detection and analysis. The problem of automatically unpacking binaries has previously been investigated. However, current generic unpackers either do not offer any dump of the unpacked binary at all or produces a set of memory dumps that each lack several structures that make them well-suited for further analysis. In this paper, we present RePEconstruct, a tool that unpacks packed binaries and reconstructs them in a manner well suited for further analysis. RePEconstruct deploys a model of self-modifying code similar to previous work but goes the step further by also utilizing a novel, aggressive, approach to rebuilding the import address table. Our approach relies on both static and dynamic analysis. We build RePEconstruct as a DynamoRIO client and successfully evaluate it against a set of packed applications.
Cited by 12
Language-independent sandboxing of just-in-time compilation and self-modifying code
Jason Ansel, Petr Marchenko, Úlfar Erlingsson et al. · ACM SIGPLAN Notices · 2011
When dealing with dynamic, untrusted content, such as on the Web, software behavior must be sandboxed, typically through use of a language like JavaScript. However, even for such specially-designed languages, it is difficult to ensure the safety of highly-optimized, dynamic language runtimes which, for efficiency, rely on advanced techniques such as Just-In-Time (JIT) compilation, large libraries of native-code support routines, and intricate mechanisms for multi-threading and garbage collection. Each new runtime provides a new potential attack surface and this security risk raises a barrier to the adoption of new languages for creating untrusted content. Removing this limitation, this paper introduces general mechanisms for safely and efficiently sandboxing software, such as dynamic language runtimes, that make use of advanced, low-level techniques like runtime code modification. Our language-independent sandboxing builds on Software-based Fault Isolation (SFI), a traditionally static technique. We provide a more flexible form of SFI by adding new constraints and mechanisms that allow safety to be guaranteed despite runtime code modifications. We have added our extensions to both the x86-32 and x86-64 variants of a production-quality, SFI-based sandboxing platform; on those two architectures SFI mechanisms face different challenges. We have also ported two representative language platforms to our extended sandbox: the Mono common language runtime and the V8 JavaScript engine. In detailed evaluations, we find that sandboxing slowdown varies between different benchmarks, languages, and hardware platforms. Overheads are generally moderate and they are close to zero for some important benchmark/platform combinations.
Cited by 67
So Far So Good: Self-Adaptive Dynamic Checkpointing for Intermittent Computation based on Self-Modifying Code
Bahram Yarahmadi, Erven Rohou · SPIRE - Sciences Po Institutional REpository · 2021
International audience
Cited by 0
Challenges in Analysing Executables: Scalability, Self-Modifying Code and Synergy (Dagstuhl Seminar 14241)
Roberto Giacobazzi, Axel Simon, Sarah Zennou · DROPS (Schloss Dagstuhl – Leibniz Center for Informatics) · 2014
This report summarizes the program and the outcomes of the Dagstuhl Seminar 14241, entitled "Challenges in Analysing Executables: Scalability, Self-Modifying Code and Synergy". The seminar brought together practitioners and researchers from industry and academia to discuss the state-of-the art in the analysis of binaries, the handling of the most challenging malware and the ever-lasting problem of scalability. The meeting created new links within this very diverse community and highlighted the broad interest in dealing with obfuscated code.
Cited by 1Open access
Efficient Hardware Support for Deterministic Replay Debugging of Memory\nRaces, Interrupts and Self Modifying Code
Narayanasamy, Satish, Pereira, Cristiano, Calder, Brad · eScholarship (California Digital Library) · 2005
Significant time is spent by companies trying to reproduce and fix\nbugs. BugNet is a recent architecture proposal that provides architecture\nsupport for debugging. It focuses on continuously recording information about\nthe program execution which can be communicated back to the developer on\nencountering an abrupt program termination. Using that information the\ndeveloper can deterministically replay the program execution and can reproduce\nand fix the bugs.\nTo enable deterministic replay for multi-threaded programs BugNet assumed\nhardware support to record the ordering between the memory operations executed\nacross all the threads. In this paper, we significantly reduce the hardware\nsupport required for logging multi-threaded programs by exploiting an important\nproperty in BugNet checkpointing scheme that allows one to independently replay\neach thread without explicitly logging shared memory dependences. During\noffline debugging, we independently replay each thread to collect memory traces\nfor their execution. Given these traces, we show how one can infer the memory\nordering across the threads.\nIn addition, we present a set of optimizations to improve the complexity and\nfunctionality of the BugNet architecture. Those optimizations include\nsupporting self-modifying code and reducing the log size in the presence of\nfrequent interrupts.Pre-2018 CSE ID: CS2005-0843
Cited by 0
A New Disassembly Approach for Binary Code Using Dynamic Multiple-Path Exploration and Static Disassembly
Jing Qiu, Xiao Hong Su, Jun Pei · Applied Mechanics and Materials · 2014
We present a new approach for disassembling executables with self-modifying code. Self-modifying code is very common in malware. Conventional static or dynamic approaches cannot handle self-modifying code very well. We combine static and dynamic analysis to fight against self-modifying code with the multiple-path exploration technique. The evaluation results indicate that our approach works well in disassembling executables with self-modifying code with high precision and code coverage compared with the state-of-art disassembler.
Cited by 0
Report from Dagstuhl Seminar 14241 Challenges in Analysing Executables: Scalability, Self-Modifying Code and Synergy Edited by
Roberto Giacobazzi, Axel Simon, Sarah Zennou et al. · 2015
This report summarizes the program and the outcomes of the Dagstuhl Seminar 14241, entitled “Challenges in Analysing Executables: Scalability, Self-Modifying Code and Synergy”. The sem-inar brought together practitioners and researchers from industry and academia to discuss the state-of-the art in the analysis of binaries, the handling of the most challenging malware and the ever-lasting problem of scalability. The meeting created new links within this very diverse community and highlighted the broad interest in dealing with obfuscated code.
Cited by 0
The Executioner Paradox: understanding self-referential dilemma in computational systems
Sachit Mahajan · AI & Society · 2024
Abstract As computational systems burgeon with advancing artificial intelligence (AI), the deterministic frameworks underlying them face novel challenges, especially when interfacing with self-modifying code. The Executioner Paradox, introduced herein, exemplifies such a challenge where a deterministic Executioner Machine (EM) grapples with self-aware and self-modifying code. This unveils a self-referential dilemma, highlighting a gap in current deterministic computational frameworks when faced with self-evolving code. In this article, the Executioner Paradox is proposed, highlighting the nuanced interactions between deterministic decision-making and self-aware code, and the ensuing challenges. This article advocates for a re-evaluation of existing deterministic frameworks, emphasizing the need for adaptive decision-making mechanisms in computational systems. By dissecting the Executioner Paradox, the aim is to foster a robust discussion on evolving deterministic frameworks to accommodate the dynamic nature of self-modifying code, thereby contributing a forward-looking lens to the discourse on computational systems amidst advancing AI.
Cited by 1Open access
Cobra: fine-grained malware analysis using stealth localized-executions
Amit Vasudevan, Ramesh Yerraballi · 2006
Fine-grained code analysis in the context of malware is a complex and challenging task that provides insight into malware code-layers (polymorphic/metamorphic), its data encryption/decryption engine, its memory layout etc., important pieces of information that can be used to detect and counter the malware and its variants. Current research in fine-grained code analysis can be categorized into static and dynamic approaches. Static approaches have been tailored towards malware and allow exhaustive fine-grained malicious code analysis, but lack support for self-modifying code, have limitations related to code-obfuscations and face the undecidability problem. Given that most if not all malware employ self-modifying code and code-obfuscations, poses the need to analyze them at runtime using dynamic approaches. However, current dynamic approaches for fine-grained code analysis are not tailored specifically towards malware and lack support for multithreading, self-modifying/self-checking code and are easily detected and countered by ever-evolving anti-analysis tricks employed by malware. To address this problem, we propose a powerful dynamic fine-grained malicious code analysis framework, codenamed Cobra, to combat malware that are becoming increasingly hard to analyze. Our goal is to provide a stealth, efficient, portable and easy-to-use framework supporting multithreading, self-modifying/self-checking code and any form of code obfuscation in both user- and kernel-mode on commodity operating systems. Cobra cannot be detected or countered and can be dynamically and selectively deployed on malware specific code-streams while allowing other code-streams to execute as is. We also illustrate the framework utility by describing our experience with a tool employing Cobra to analyze a real-world malware
Cited by 94
Outline
Michalis Polychronakis, Evangelos Markatos · 2015
• Introduction to the problem: shell code attacks – buffer overflows • Polymorphic attacks (self modifying shell-code) • Network-level Emulation (NEMU)
Cited by 0
Outline
Michalis Polychronakis, Evangelos Markatos · 2015
§ Introduction to the problem: shell code attacks – buffer overflows § Polymorphic attacks (self modifying shell-code) § Network-level Emulation (NEMU)
Cited by 0
astrosega/Haze-bending-wave: v1.0.0
astrosega · Zenodo (CERN European Organization for Nuclear Research) · 2024
Code associated with Sega et al. 2024, ICARUS, titled The dynamics of Self-gravity Wakes in the Mimas 5:3 Bending Wave: modifying the linear theory. Richard French aided in testing the code for a general release.
Cited by 0Open access