Introduction
The Move programming language was designed from the ground up for blockchain safety, incorporating a strict static type system and resource-oriented semantics to mitigate common vulnerabilities like reentrancy. However, Move contracts remain susceptible to logic flaws and arithmetic errors that fall outside the scope of its type system. Traditional fuzzing tools, often ported from the Ethereum Virtual Machine (EVM), struggle with Move's "strong" typing. In Move, objects cannot be forged from random bytes; they must be instantiated through valid function calls and adhere to strict signatures.
The Challenge of Move Fuzzing
A significant hurdle in Move is the "Hot Potato" object—a struct without drop or store abilities that must be consumed within the same transaction it is created. Conventional fuzzers generate syntactically invalid transactions that the Move Virtual Machine (MoveVM) rejects instantly, leading to poor code coverage. Analysis of real-world packages reveals that these features are not edge cases but standard practice.
As shown in the figure above, over 80% of frequently used Move packages utilize type parameters or Hot Potato objects. This prevalence renders type-unaware fuzzing largely ineffective for the Move ecosystem, as it fails to navigate the mandatory paths defined by these objects.
Methodology: The Belobog Framework
Belobog introduces a multi-stage approach to overcome Move's unique constraints through a novel "type graph" architecture:
1. Type Graph Construction
The framework constructs a directed graph where nodes represent types (primitives, structs, or Hot Potatoes) and functions. Edges define the relationships between inputs and outputs, serving as a blueprint for valid call sequences.
2. Type-Aware Generation and Mutation
Instead of random bit-flipping, Belobog traverses the type graph. It ensures that if a function produces a Hot Potato, a subsequent function in the transaction is selected to consume it. It also employs a heuristic-based method to instantiate generic type parameters with concrete types (e.g., substituting a generic T with a specific USDC coin type).
3. Concolic Execution and Custom Oracles
To reach deep code paths guarded by specific constraints (e.g., assert!(amount > 1000)), Belobog uses a concolic executor built on MoveVM to solve for required symbolic inputs. It also utilizes custom oracles, including a novel "Earning Profits" oracle that flags transactions where a sender's balance increases without a legitimate minting operation—a classic sign of an exploit.
Key Results and Impact
Belobog's performance significantly outpaces traditional alternatives across several benchmarks:
- Detection Rate: It identified 100% of critical vulnerabilities in an audit dataset of 37 real-world projects, whereas the baseline fuzzer (ItyFuzz) found none.
- Coverage and Efficiency: Belobog achieved 55.6% edge coverage (vs. 8.8% for ItyFuzz) and operated 10x faster by avoiding "junk" transactions that the VM would otherwise reject.
- Real-World Exploits: The tool successfully reproduced multi-million dollar exploits in the Cetus and Nemo protocols without prior knowledge and discovered 7 new vulnerabilities in active projects.
Conclusion
Belobog demonstrates that effective fuzzing for resource-oriented languages like Move requires deep integration with the language's type system. By modeling "Hot Potato" objects as graph reachability problems, Belobog provides a robust solution for securing the next generation of smart contracts in the Sui and Aptos ecosystems.
Summary updated