Skip to content
Crypto.world

Research

SseRex: Practical Symbolic Execution of Solana Smart Contracts

Solana programs receive all their inputs — including account metadata such as owners, signer flags, and public keys — directly from a transaction that an attacker can craft, so developers must…

SseRex: Practical Symbolic Execution of Solana Smart Contracts
arXiv
2603.16349
Published
2026-03-17
Authors
Tobias Cloosters, Pascal Winkler, Jens-Rene Giesen, Ghassan Karame, Lucas Davi

AI summary

Overview

Research area: Blockchain security — automated vulnerability detection for Solana smart contracts (cs.CR).

Technical level: Advanced. The paper assumes familiarity with symbolic execution, program analysis, and blockchain execution models, though the motivation and results are accessible to a broader security audience.

Scope: The paper presents SseRex, the first symbolic execution framework for detecting Solana-specific vulnerabilities — missing owner checks, missing signer checks, missing key checks, and arbitrary cross-program invocations — in bytecode-only and Anchor-based contracts, and evaluates it on 8,714 deployed contracts plus 120 open-source projects.

What This Paper Is About

Solana programs receive all their inputs — including account metadata such as owners, signer flags, and public keys — directly from a transaction that an attacker can craft, so developers must explicitly validate every account before doing anything critical. Existing automated tools miss this: VRust needs source code (unavailable for 98% of deployed programs) and produces many false positives, while FuzzDelSol cannot analyze Anchor-based contracts, which make up at least 43% of deployed programs. SseRex applies symbolic execution to raw sBPF bytecode to track whether accounts reaching security-critical actions — account writes and cross-program invocations — were actually checked.

Key Contributions

  1. The first symbolic execution framework for Solana. SseRex lifts sBPF bytecode (via Binary Ninja) into an intermediate language and executes it symbolically on top of the SENinja AMD64 framework, tracking full account verification state along each path.

  2. Techniques that make symbolic execution tractable on Solana. The paper introduces state merging after account deserialization (avoiding the (2^3)^10 ≈ 10^9 state blow-up from 10 accounts with three boolean fields each), "hybrid symbolic lengths" that use fixed maximum sizes during deserialization and symbolize lengths afterward to avoid symbolic pointers, and detection of string-formatting calls that are skipped when used only for logging.

  3. Solana-specific vulnerability oracles. Specialized checks for missing signer checks (MSC), missing owner and key checks (MOC/MKC), authority checks, and arbitrary cross-program invocation (ACPI), evaluated at critical actions rather than at the source level.

  4. A large-scale empirical study. Analysis of 8,714 bytecode-only contracts, 120 open-source Anchor-registry projects (666 builds), and the datasets of VRust and FuzzDelSol, with manual verification of a 30-bug sample and four in-depth case studies. SseRex is to be released publicly on GitHub.

Main Findings

  • 467 of 8,714 contracts flagged. In the large-scale bytecode study, SseRex reported 467 contracts with potential bugs. Of these, 374 involved unchecked account writes (117 missing owner check, 241 missing signer check, 33 both), and 100 involved arbitrary cross-program invocation.

  • 87% true positive rate on the manual sample. Manual analysis of 30 reported bugs confirmed 26 as genuine.

  • Strong precision on the Anchor registry. Across 120 open-source projects (about 90% Anchor-based), only four vulnerabilities were reported, indicating a low false-positive rate on code that already benefits from Anchor's built-in mitigations.

  • Four verified case studies. The reported issues in quarry-registry (MSC, deterministic data), serum-dex (MSC, zeroed account), sol-did (MOC, potentially exploitable), and spl-token-2022 (MSC, fresh account) all held up under manual analysis.

  • sol-did is a concrete exploit path. The resize function does not verify the resized DidAccount; because the secp256k1 signature used for Ethereum authority checks is constructed solely from the requested account size, an attacker can impersonate an Ethereum authority and shrink accounts to collect surplus rent above the rent-exemption threshold.

  • Better than VRust on the same projects. SseRex found that the "wrong key check" VRust reported in spl-governance is fine in Solana (the owner check happens after the read, and written-back data is implicitly owner-checked by the runtime). It also identified 11 missing signer checks and one ACPI in spl-instruction-padding, and noted that spl-governance allows unsigned version-number updates.

  • Matches FuzzDelSol's findings. SseRex classifies all the contracts FuzzDelSol reported and largely matches the reported bug types, while also handling Anchor contracts that FuzzDelSol cannot analyze.

  • Neodyme workshop levels. SseRex correctly detects the missing owner check (level 0), the missing signer check (level 1), and the ACPI (level 4); levels 2 and 3 (integer overflow and type confusion) were deliberately out of scope and not detected.

  • Explicitly out of scope: integer overflows (compiler pruning and the Solana VM's register-clearing behavior make bytecode-level detection unreliable), type/account confusion (mitigated by type IDs in serialization libraries), reentrancy (limited by Solana's CPI depth limit of 4 and data ownership), and the missing system-account check from Wormhole (fixed in the updated Solana SDK).

Methodology in Plain English

The researchers download each contract's compiled ELF file from the blockchain, convert the sBPF bytecode into an analyzable intermediate representation, and load it into a symbolic execution engine — a tool that explores many possible inputs at once by treating values as symbolic rather than concrete.

Three problems make naive symbolic execution stall on Solana, and each gets a dedicated fix. First, deserializing accounts creates a combinatorial explosion of nearly identical states (three boolean fields per account, ten accounts, roughly a billion states), so SseRex detects the deserialization loop and merges those states into one conditional expression. Second, variable-length account data forces symbolic pointers whose constraints overwhelm the solver, so SseRex deserializes with constant maximum sizes and only symbolizes the lengths afterward. Third, converting symbolic numbers into log strings generates intractable constraints, so SseRex recognizes formatting calls whose output is only logged and skips them.

Exploration is guided by three round-robin strategies — CPI (follow paths reaching the cross-program invocation syscall), Main (walk the instruction-dispatch switch tree to its leaves), and Random (sample paths for coverage) — each capped at 10 minutes, with static pruning of paths that cannot reach a target or merely panic! and abort.

When a critical action is reached (an account write or a CPI), the oracles ask: did any signer flag get constrained on this path? Was the account's owner field or public key compared to something, written to, or derived as a PDA? Was a trusted signer verified as authority? If an account is read without such checks, or a CPI target comes from an unchecked account with no signer check, SseRex reports a vulnerability and can also synthesize a candidate exploit transaction for that path.

Why This Matters

Solana exploits have caused more than $523 million in losses, and the bugs involved — missing signature verification in Wormhole, missing owner checks, unvalidated CPI targets — are exactly the ones a per-account validation model makes easy to overlook. SseRex shows that a bytecode-only technique can cover the 98% of contracts with no published source and the 43% built with Anchor, closing gaps that both VRust and FuzzDelSol leave open.

Real-world applications:

  • Pre-deployment auditing. Developers can run SseRex on a compiled program before deploying it, catching missing signer or owner checks that survive code review.
  • Exchange and wallet listing due diligence. Platforms screening tokens and programs can triage deployed bytecode without source access.
  • Post-incident forensics and monitoring. The ability to synthesize exploit transactions for a reported path helps confirm whether a finding is actually exploitable from a reachable on-chain state.
  • Security research and tooling baselines. The Anchor-registry and Neodyme evaluations provide a precision benchmark for future Solana analyzers.

Industry relevance: the tool targets the account-model mistakes that keep recurring in Solana incidents, and its low false-positive rate on Anchor code is important for adoption — audit teams discard tools that flood them with noise.

Future Directions

  • Full exploit chains. SseRex currently synthesizes exploits valid for a given path's constraints but dependent on a compatible initial blockchain state; extending it to generate precondition-establishing transaction sequences, including interactions with other contracts, would make findings directly actionable.

  • Business-logic-sensitive oracles. The paper notes that when a CPI has either an owner check or a signer check, judging exploitability requires source code and an understanding of the contract's intent, so richer semantic oracles remain open.

  • Coverage of excluded bug classes. Integer overflows, type/account confusion, and pseudo-reentrancy were deliberately left out; whether bytecode-level analysis can handle them reliably is unresolved.

  • Scaling and solver limits. The 10-minute per-strategy budget and the pruning heuristics trade completeness for tractability — how much vulnerability coverage is lost, and how to recover it, is an open engineering question.

Target Audience

Blockchain security researchers and auditors working on Solana; program-analysis researchers interested in applying symbolic execution to new execution models; smart contract developers who want to understand which validation checks their programs are actually missing; and tooling engineers at exchanges, wallets, or security firms who screen deployed bytecode without source access. Readers unfamiliar with symbolic execution will follow the motivation and results but will need background for the design sections.

Authors’ abstract

Solana is rapidly gaining traction among smart contract developers and users. However, its growing adoption has been accompanied by a series of major security incidents, which have spurred research into automated analysis techniques for Solana smart contracts. Unfortunately, existing approaches do not address the unique and complex account model of Solana. In this paper, we propose SseRex, the first symbolic execution vulnerability detection approach for finding…

The full abstract on arXiv
Read the original paper