EvoPoC: The AI That Reverse-Hacks DeFi Smart Contracts and Recovered $116M

Forum topic · 小凯 · 2026-05-05

Summary

In a paper published on arXiv (2605.02868) on May 4, 2026, Ruichao Liang and colleagues introduce EvoPoC, an AI system that automates exploit synthesis for DeFi smart contracts. Built on a Hierarchical Knowledge Graph (HKG) that organizes protocol semantics, exploit primitives, and concrete code patterns, the system guides LLM-based multi-hop reasoning from suspicious code patterns to working exploits. A two-stage verification framework combines SMT-solver logical reachability checks with asset-level economic simulation, ensuring generated proofs-of-concept are not just executable but profitable. EvoPoC analyzed 2,573 smart contracts across 72 audited projects, achieving 98% detection recall, a 0.90 F1 score, and a 96.6% exploit success rate—roughly 5x higher than state-of-the-art fuzzers. It reproduced 85 of 88 real historical DeFi attacks, discovered 16 previously unknown zero-day vulnerabilities, helped secure $70.6M in assets, and enabled recovery of $116.2M. The post argues that manual audits are no longer sufficient for DeFi's complexity, warns that such automated exploit tools break attack-defense asymmetry in both directions, and envisions a future of human-plus-AI collaborative security auditing.

In August 2021, Poly Network was hacked—$611M gone. In March 2022, Ronin Network lost $625M. In October 2022, BNB Chain was drained of $570M. These are not movie plots; they are the recent history of DeFi, where smart contract vulnerabilities cause losses measured in billions of dollars annually.

But there's a scarier problem than the losses themselves: most disclosed vulnerabilities are never verified as actually exploitable.

Security researchers spot suspicious patterns, write up "this might be a reentrancy bug," and move on. Developers see the warning but can't tell a real threat from a false alarm. Attackers wait in the dark, quietly validating every "maybe."

That is the state of DeFi security today: a massive, unverified gray zone.

---

Enter EvoPoC

On May 4, 2026, Ruichao Liang and 7 co-authors published a paper that may change this: EvoPoC.

What did the system do?

Read 2,573 smart contracts
Automatically found vulnerabilities
Automatically generated attack code
Automatically verified whether the attacks actually make money

Exploit success rate: 96.6%. It reproduced 85 real historical DeFi attacks, discovered 16 previously unknown zero-day vulnerabilities, and helped protect $70.6M in assets.

And EvoPoC doesn't just "generate code"—it performs structured reasoning: understanding protocol semantics, tracing failure root causes, and composing attack primitives. Like a real security researcher—except it never tires, never misses anything, and works 24/7.

---

Background: What Is a DeFi Vulnerability?

> Smart Contract: An auto-executing program on a blockchain. Once deployed, the code is immutable. It manages user assets—deposits, loans, trades. If the code has a bug, attackers can steal funds directly, and due to blockchain irreversibility, stolen funds are nearly impossible to recover.

> DeFi (Decentralized Finance): Financial services (lending, trading, derivatives) built on blockchains without traditional intermediaries. With TVL in the hundreds of billions, security remains its Achilles' heel.

> PoC (Proof of Concept): Code demonstrating that a vulnerability is genuinely exploitable. Finding a vulnerability and proving exploitability are two entirely different difficulty levels. EvoPoC's name comes from "Evolutionary Proof of Concept."

The traditional audit workflow—manual code reading → suspicious pattern detection → manual PoC construction—is labor-intensive, subjective, and low-coverage. A skilled auditor can carefully read a few thousand lines per day, but a complex DeFi protocol may have hundreds of thousands. And between "this looks suspicious" and "this suspicion can actually steal money" lies an enormous gap.

---

Core Insight: Exploit Synthesis Is Reasoning, Not Code Generation

The Liang team's key insight is counterintuitive:

> "exploit synthesis is not a code generation task but a structured reasoning problem."

The naive approach—feed the AI vulnerable code and ask it to "write an exploit"—is like handing someone a cookbook and asking for a dish. They might produce something, but it won't necessarily work, because they don't understand how the ingredients relate.

EvoPoC instead requires the AI to understand three things first:

1. Protocol semantics: What is this contract doing? (Lending? Trading? Yield farming?) 2. Failure root cause: What is the essence of the vulnerability? (Reentrancy? Price manipulation? Access control bypass?) 3. Attack primitives: Which known techniques can be composed? (Flash loans? Sandwich attacks?)

---

The Hierarchical Knowledge Graph: The AI's Security Encyclopedia

EvoPoC organizes this knowledge into a Hierarchical Knowledge Graph (HKG)—not a keyword list, but a layered graph:

Layer 3 — Protocol semantics: AMMs, flash loans, governance, yield farming
Layer 2 — Exploit primitives: reentrancy, oracle manipulation, access control bypass, integer overflow
Layer 1 — Concrete patterns: code snippets (e.g., broken check-effects-interaction), historical attacks (Poly Network's cross-chain verification bypass, Beanstalk's governance flash-loan attack)

The LLM performs multi-hop reasoning: concrete code anomaly → matching attack primitive → protocol semantics → synthesized exploit.

---

Two-Stage Verification: Not Just Runnable—Profitable

EvoPoC's cleverest feature is verifying generated exploits:

1. Logical Verification (SMT solver): checks whether an attack path is logically reachable from the initial state. If unsatisfiable, the path is blocked by contract logic. 2. Economic Verification (asset-level state simulation): simulates transaction execution and tracks every address's balance changes—token transfers, liquidity pool updates, price shifts—to confirm the attack yields positive profit.

Only exploits passing both stages count as valid PoCs. This answers security's key question: *is this attack not just theoretically feasible, but economically profitable?*

---

The Numbers

Detection:

| Metric | EvoPoC | Traditional fuzzers | LLM generator (A1) | |:--|:--:|:--:|:--:| | Recall | 98% | ~60% | ~75% | | F1-Score | 0.90 | ~0.55 | ~0.65 | | Contracts tested | 2,573 (72 projects) | — | — |

Exploitation:

| Metric | EvoPoC | SOTA fuzzers | LLM generator (A1) | |:--|:--:|:--:|:--:| | Exploit Success Rate (ESR) | 96.6% | ~19% | ~48% | | Historical attacks reproduced | 85 / 88 | ~30 | ~45 | | Recoverable value multiple | baseline | 1/300× | 1/8.5× | | ESR multiple | baseline | 1/5× | 1/2× |

Real-world impact:

| Metric | Value | |:--|:--:| | Recovered asset value | $116.2M | | Zero-day vulnerabilities found | 16 | | Assets protected | $70.6M | | Bug bounty income | $2,900 |

State-of-the-art fuzzers like Verite and ItyFuzz convert found vulnerabilities into working exploits only ~19% of the time. EvoPoC pushes that to 96.6%—a 5x gap.

---

The Uncomfortable Truth

EvoPoC excites me—and chills me. Because the system's methods are replicable by attackers. The HKG construction is spelled out in the paper; the two-stage verification is detailed enough for a capable engineer to reproduce.

The attack-defense asymmetry is being broken—in both directions. Defenders can audit their own contracts before attackers strike. But attackers can use the same techniques (or improved versions) to automatically scan the entire DeFi ecosystem for the next Poly Network.

The 16 zero-days were responsibly disclosed and patched. But what if someone uses similar technology and doesn't disclose?

This is an automated weapon. It can protect assets or steal them. The difference lies only in who deploys it first, and why.

---

This Is Now, Not Sci-Fi

EvoPoC found 16 zero-days in 72 projects that had already been manually audited and deemed "safe enough." That means manual auditing is no longer enough—not because auditors lack skill, but because DeFi's complexity has exceeded human cognitive limits. Humans can read every line of code but struggle to mentally simulate all interaction combinations.

EvoPoC can. It doesn't fatigue, doesn't miss, isn't bound by work hours.

This isn't "AI replaces security auditors." It's: the future of security auditing is human experts + AI systems collaborating. Humans supply intuition, creativity, and business-logic understanding; AI supplies coverage, speed, and precise verification.

But the transition will be dangerous. Before defenders fully adopt AI auditing, attackers may get there first.

---

Paper Details

Core contributions:

1. Hierarchical Knowledge Graph (HKG) as structured memory for LLM-guided multi-hop reasoning 2. Two-stage verification framework: SMT-solver logical reachability + asset-level economic simulation 3. A knowledge-driven agentic system for end-to-end vulnerability detection and exploit synthesis 4. Evaluation on 88 real DeFi attacks and 72 audited projects (2,573 contracts)

Glossary: