Technical Summary: Insecurity Through Obscurity: Veiled Vulnerabilities in Closed-Source Contracts

1. Problem Statement

On public blockchains like Ethereum, smart contract bytecode is publicly accessible, yet many developers choose to keep their source code closed or employ bytecode obfuscation to protect proprietary business logic and deter attacks (e.g., frontrunning). While obfuscation aims to provide "security through obscurity," this paper argues it often leads to "insecurity through obscurity." Obfuscation, particularly control-flow obfuscation using indirect jumps, hinders the ability of existing security tools to analyze contracts, potentially masking critical asset management vulnerabilities.

The paper identifies a specific gap: existing tools struggle to scale to large, closed-source, and obfuscated contracts, especially those handling significant assets like Maximal Extractable Value (MEV) bots. These bots often employ complex logic involving trading, flash loans, and DeFi interactions. When obfuscated, they become "black boxes" where vulnerabilities—specifically those allowing adversaries to steal assets—remain undetected until exploited.

2. Methodology: The skanf Tool

To address these challenges, the authors present skanf, a novel EVM bytecode analysis tool designed for closed-source and obfuscated contracts. skanf operates in three primary stages:

A. Control-Flow Deobfuscation

The first challenge is that obfuscated contracts use indirect jumps (where the destination is a runtime value) to hide execution paths. Existing tools often misclassify these blocks as unreachable or fail to analyze them.

• Approach: skanf leverages a specific property of the Ethereum Virtual Machine (EVM): valid jump destinations must be explicitly marked with the JUMPDEST opcode.
• Technique: The tool statically scans the bytecode to collect all legal JUMPDEST addresses. It then instruments the bytecode by inserting a branch table (a sequence of conditional checks) at a high program counter (PC) address (e.g., 0xe000).
• Transformation: Indirect jumps are rewritten to jump to this branch table. The table compares the runtime jump destination against all known valid JUMPDEST addresses. If a match is found, execution proceeds to the target; otherwise, it continues to the next check. This converts opaque indirect jumps into explicit, statically analyzable direct jumps, restoring the Control Flow Graph (CFG) without altering the contract's logic.

B. Transaction-Seeded Symbolic Execution

The second challenge is the "path explosion" problem in symbolic execution, exacerbated by the complexity of MEV bots.

• Approach: Instead of relying solely on random inputs or manual specification, skanf uses historical transactions as high-quality concrete seeds.
• Technique:
  1. Seed Extraction: The tool retrieves successful historical transactions for a target contract from an archive node. It extracts inputs (caller, origin, calldata, value) that triggered external calls, specifically filtering for those involving ERC-20 transfers.
  2. Seeded Execution: These concrete inputs initialize the symbolic execution engine. The engine explores paths guided by these seeds, significantly reducing the search space and constraint-solving complexity compared to pure symbolic execution.
  3. Taint Analysis: During path exploration, skanf performs byte-level taint propagation. It tracks how adversarial inputs (tainted calldata) flow into critical parameters of CALL instructions (target address, function selector, arguments).

C. Vulnerability Detection and Exploit Generation

• Vulnerability Oracle: A CALL instruction is flagged as a potential asset management vulnerability if:
  1. It is reachable from a public entry point.
  2. Its parameters are either adversary-controllable (tainted) or risky (fixed but dangerous, e.g., a fixed ERC-20 token address or a transfer function selector).
  3. Specifically, if the function is transfer or approve, the tool checks if the recipient and amount can be manipulated by the adversary.
• Exploit Synthesis: For identified vulnerabilities, skanf constructs a transaction to exploit the flaw. It solves constraints to generate specific calldata that triggers the vulnerable call and transfers assets to an adversary-controlled address.
• Validation: Generated exploits are validated in a local blockchain environment (using an archive node to reconstruct historical states) to ensure they successfully execute and transfer assets.

3. Key Contributions

1. Deobfuscation Method: A novel technique to remove control-flow obfuscation in EVM bytecode by reconstructing jump tables, enabling static analysis tools to function on obfuscated contracts.
2. Transaction-Seeded Symbolic Execution: A scalable approach that utilizes public historical transactions as concrete seeds to guide symbolic execution, mitigating path explosion and improving vulnerability detection efficiency.
3. skanf Implementation: A tool that integrates deobfuscation and seeded execution to detect asset management vulnerabilities and automatically generate exploits for closed-source contracts.
4. Empirical Evaluation: A large-scale study of 6,554 real-world MEV bots, demonstrating the prevalence of vulnerabilities and the effectiveness of the proposed approach.
5. Discovery of MEV Phishing Attacks: Identification of a new class of attacks where adversaries lure MEV bots into interacting with malicious contracts via crafted opportunities, resulting in significant financial losses.

4. Results

The authors evaluated skanf on a dataset of 6,554 MEV bots:

• Deobfuscation Effectiveness: skanf successfully increased code coverage for obfuscated contracts. For contracts where standard tools (Gigahorse) had coverage below 50%, skanf restored coverage to near 100% in 90% of cases.
• Vulnerability Detection:
  • skanf identified 1,030 vulnerable contracts.
  • It successfully generated and validated exploits for 394 of these contracts.
  • The potential economic loss from these synthesized exploits is estimated at $10.6 million (based on token balances at the time of writing and historical highs).
  • Compared to state-of-the-art tools (Mythril, ETHBMC, JACKAL, Securify), skanf detected significantly more vulnerabilities, largely due to its ability to handle obfuscation and use seeded execution.
• Real-World Attacks:
  • The study uncovered 104 real-world "MEV phishing" attacks targeting 37 MEV bots between 2021 and 2025.
  • These attacks resulted in a total loss of $2.76 million.
  • skanf was able to re-discover vulnerabilities in 28 of the exploited contracts, suggesting these attacks could have been prevented.
  • Only 3 of the 104 attacks were previously publicly reported.

5. Significance and Claims

The paper claims that "insecurity through obscurity" is a tangible risk in the smart contract ecosystem. By hiding code, developers inadvertently prevent security tools from detecting critical flaws, particularly those involving asset management.

• Security Implication: Obfuscation does not enhance security; rather, it creates a false sense of security while masking vulnerabilities that lead to substantial financial losses.
• Practical Utility: skanf provides a defensive mechanism for developers and auditors to analyze closed-source or obfuscated bytecode before deployment or interaction, identifying risks that would otherwise remain hidden.
• MEV Context: The study highlights that MEV bots, which handle large volumes of assets and are often closed-source, are a prime target for these vulnerabilities. The discovery of "MEV phishing attacks" reveals a sophisticated attack vector where adversaries exploit the automated nature of these bots.
• Modesty: The authors acknowledge limitations, such as the reliance on the underlying tools (Gigahorse and Greed) for initial analysis and the current focus primarily on CALL instructions (excluding DELEGATECALL, CALLCODE, etc.). They also note that while they identified many attacks, their detection method is pattern-based and may miss attacks that do not fit the specific "phishing" criteria.

In summary, the paper demonstrates that without proper analysis tools capable of handling obfuscation, the "security through obscurity" strategy in smart contracts is fundamentally flawed, leaving significant assets exposed to exploitation.