Self-Modifying Pushdown Systems (SM-PDS)

• Self-Modifying Pushdown Systems (SM-PDS) are defined by dynamic rule modifications that extend classical pushdown systems to model self-modifying code behavior.
• Direct saturation algorithms for reachability (Pre* and Post*) efficiently compute configuration sets despite an exponential state space, ensuring practical analysis.
• SM-PDS techniques enable effective malware detection, outperforming traditional methods by accurately localizing malicious code blocks and improving analysis speed.

Self-Modifying Pushdown Systems (SM-PDS) are an extension of classical pushdown systems (PDS) designed to model the behavior of programs that are capable of modifying their own transition relations during execution. This formalism provides an analyzable, automata-theoretic abstraction for self-modifying code, which is widely used in malware for obfuscation and evasion. The foundational work on SM-PDS establishes their formal semantics, reachability analysis, LTL model checking, and demonstrates their practical applicability in malware detection (Touili et al., 2019, Touili et al., 2019).

1. Formal Definition and Semantics

An SM-PDS is formally a quadruple $M = (P, \Gamma, \Delta, \Delta_n)$, where:

• $P$ is a finite set of control locations (or states).
• $\Gamma$ is a finite stack alphabet.
• $$\Delta \subseteq P \times \Gamma \times P \times \Gamma^*$$ is the standard (non-modifying) transition relation; a rule $(p, \gamma) \mapsto (p', w)$ means that at control $p$, with $\gamma$ atop the stack, pop $\gamma$, push $w$, and move to $p'$.
• $P$0 is a finite set of self-modifying rules; a rule $P$1 enables replacement of rule $P$2 with $P$3 in the active set of rules, at control $P$4, moving to $P$5 without accessing the stack.

A configuration is a tuple $P$6, where $P$7 is the current control, $P$8 is the stack, and $P$9 is the current “phase” (active rules). The transition relation $\Gamma$0 covers:

• Standard step: If $\Gamma$1, then $\Gamma$2.
• Self-modifying step: If $\Gamma$3 and $\Gamma$4, then $\Gamma$5, where $\Gamma$6.

This semantics generalizes the classical PDS by allowing the automaton to alter its operational rules dynamically, capturing code rewriting behaviors directly (Touili et al., 2019, Touili et al., 2019).

2. Reachability and Decidability

Reachability analysis in SM-PDSs extends standard PDS analysis to account for dynamic rule modifications. For a regular set of initial configurations $\Gamma$7 and a target set $\Gamma$8, define:

• $\Gamma$9,
• $$\Delta \subseteq P \times \Gamma \times P \times \Gamma^*$$0.

Both forward (Post*) and backward (Pre*) reachability sets are effectively regular and computable, despite the exponential increase in the number of possible “phases.” The reachability problem for SM-PDS is EXPTIME-complete, stemming from the $$\Delta \subseteq P \times \Gamma \times P \times \Gamma^*$$1 bound on phases and a reduction from PDS over exponentially-large alphabets (Touili et al., 2019).

3. Direct Saturation Algorithms

Efficient reachability algorithms for SM-PDS exploit direct automata saturation, extending multi-automata constructions from static PDS to the dynamic setting.

3.1 Backward Reachability (Pre*)

A finite automaton where states are $$\Delta \subseteq P \times \Gamma \times P \times \Gamma^*$$2 (control and phase) and transitions are labeled from $$\Delta \subseteq P \times \Gamma \times P \times \Gamma^*$$3 is saturated by two rules:

• (α₁) Standard transition: For $$\Delta \subseteq P \times \Gamma \times P \times \Gamma^*$$4, if $$\Delta \subseteq P \times \Gamma \times P \times \Gamma^*$$5 exists, add $$\Delta \subseteq P \times \Gamma \times P \times \Gamma^*$$6.
• (α₂) Self-modifying transition: For $$\Delta \subseteq P \times \Gamma \times P \times \Gamma^*$$7, if $$\Delta \subseteq P \times \Gamma \times P \times \Gamma^*$$8, set $$\Delta \subseteq P \times \Gamma \times P \times \Gamma^*$$9. If $(p, \gamma) \mapsto (p', w)$0, add $(p, \gamma) \mapsto (p', w)$1.

Saturation terminates as the state space $(p, \gamma) \mapsto (p', w)$2 is finite (at most $(p, \gamma) \mapsto (p', w)$3 states), guaranteeing that Pre* can be computed in $(p, \gamma) \mapsto (p', w)$4 time (Touili et al., 2019).

3.2 Forward Reachability (Post*)

A similar automaton-based construction applies, where transitions are saturated according to the applicable rule, including provisions for stack manipulation and self-modification. The method introduces “helper” states as needed and similarly achieves exact recognition of Post*, terminating after exponential time in the system size (Touili et al., 2019).

3.3 Correctness and Regularity

At each iteration, the saturation algorithms maintain an invariant connecting accepted words to configuration reachability and exploit the closure properties of regular languages. Detailed inductive proofs establish the approach’s correctness. The algorithms avoid reliance on well-quasi-ordering; plain finiteness suffices (Touili et al., 2019).

4. LTL Model Checking and SM-BPDS

Temporal logic analysis of SM-PDS proceeds by reduction to the nonemptiness problem for self-modifying Büchi pushdown systems (SM-BPDS). Given SM-PDS $(p, \gamma) \mapsto (p', w)$5, labeling function $(p, \gamma) \mapsto (p', w)$6, and LTL formula $(p, \gamma) \mapsto (p', w)$7, the construction produces a synchronized product SM-BPDS $(p, \gamma) \mapsto (p', w)$8. The state space becomes $(p, \gamma) \mapsto (p', w)$9, where $p$0 is the state set of the Büchi automaton corresponding to $p$1. Standard and self-modifying rules are producted accordingly.

Acceptance (Büchi acceptance) is defined so that a run is accepting if it visits accepting sets $p$2 infinitely often, where $p$3 are the accepting states of the Büchi automaton for $p$4 (Touili et al., 2019).

4.1 Emptiness via Head-Reachability Graphs

A head is $p$5. The SM-BPDS accepts from $p$6 iff there is a repeating head (reachable from $p$7 and lying on a cycle with at least one accepting edge) in a finite, labelled directed “head-reachability graph” $p$8. This graph has $p$9 nodes (Touili et al., 2019).

Edges are established by saturation with boolean labels indicating whether the acceptance condition is triggered. An edge is labeled $\gamma$0 if an accepting state is visited on the path. Complexity of the entire procedure is polynomial in the SM-PDS size and linear in the Büchi automaton size.

5. Implementation and Experimental Analysis

Both (Touili et al., 2019) and (Touili et al., 2019) describe direct prototype implementations of the described algorithms. Key points include:

• Construction of SM-PDS models directly from binary code, utilizing disassembly (e.g., via Jakstab) and control-flow graph extraction.
• Tool pipelines include translation of LTL formulae to Büchi automata (using LTL2BA) and direct emptiness-checking or reachability procedures.
• Performance comparison across three approaches: direct SM-PDS saturation, translation to a static PDS followed by standard (Moped) analysis, and translation to symbolic PDS.
• On synthetic benchmarks ($\gamma$1 up to 1,000), direct SM-PDS saturation is $\gamma$2–$\gamma$3 faster and lower memory than PDS translations. PDS methods become infeasible beyond $\gamma$4, while the direct method completes in seconds (Touili et al., 2019).
• In (Touili et al., 2019), LTL model checking on large SM-PDSs (up to 20,000 rules) remains practical, with direct methods running in under a minute, compared to hours or intractable resource use for PDS translations.

6. Applications in Malware Detection

SM-PDS models are directly applicable to the static analysis of self-modifying code, especially malware. Representative findings include:

• Construction of SM-PDS models that simulate mov-based self-modification in real malware, enabling the reachability of malicious code blocks to be proved—capabilities unattainable with PDS-only models (Touili et al., 2019).
• Direct application to 13 real malware samples confirmed successful localization of the malicious basic blocks.
• In (Touili et al., 2019), LTL-based model checking with SM-PDS is applied to 892 malware samples (from VirusShare, MalShare, VX-Heaven, and NGVCK) and 19 benign binaries, using four template LTL formulas for malicious behavior. The tool achieved 100% detection of malware and no false positives on benign code. Average checking times ranged from 0.001 s (small unpackers) to 100 s (complex worms).
• Comparative antivirus evaluation on 205 NGVCK worms showed the SM-PDS-based analyzer achieved 100% detection, while commercial antivirus engines peaked at approximately 82% and dropped as low as 1.4% depending on the product (Touili et al., 2019).

7. Significance and Impact

SM-PDSs provide a mathematically robust, automata-theoretic basis for analyzing programs with self-modifying behavior. The direct saturation algorithms, which are optimal for the state space blow-up inherent in SM-PDSs, outperform translation-based and symbolic PDS approaches both theoretically and empirically. The methodology enables new static analyses and temporal logic model checking previously infeasible for self-modifying code. The combination of pushdown and self-modification analysis supplies unique capabilities, particularly for malware detection, surpassing both standard program analysis frameworks and widely-used security products (Touili et al., 2019, Touili et al., 2019).