2026-10-10

Why Audited Protocols Still Get Exploited

Clean audit reports don't prevent every exploit. Documented incidents show where the real gaps are: scope, upgrades, toolchains, keys and monitoring.

Why Audited Protocols Still Get Exploited

"They were audited and still got drained" is one of the most common lines in crypto incident coverage. It's usually framed as proof that audits don't work. A better reading is that the audit covered something other than what failed. If you know the usual gaps, you can close them before your launch and not after.

This article looks at incidents with public primary write-ups and pulls out the pattern behind each.

1. The code changed after the review: Nomad (August 2022)

Nomad's bridge lost about $190 million on August 1, 2022. In its root-cause analysis, Nomad explains that the Replica contract stopped authenticating messages properly, so any message could be forged as long as it hadn't already been processed. The relevant code arrived in a contract upgrade on June 21, 2022. After one attacker showed the way, copycats replayed the same transaction pattern.

Lesson: an audit is a statement about a specific commit. Every upgrade, re-initialization or configuration change reopens the question. Your security process needs a rule like "no production upgrade without a scoped diff review," and the deployment step itself (initialization values, constructor arguments) belongs in scope.

2. The bug was in the toolchain: Curve and Vyper (July 2023)

On July 30, 2023, several Curve pools were exploited. The Vyper team's post-mortem traces the cause to the compiler: an "improperly implemented re-entrancy guard that could be bypassed under certain conditions" in Vyper 0.2.15, 0.2.16 and 0.3.0. The bug had been fixed in 0.3.1, but "the impact to protocols using the vulnerable compilers was not realized at the time and they were not explicitly notified."

Lesson: source-level review assumes the compiler does what the source says. For high-value contracts, pin compiler versions, track language security advisories (the Solidity and Vyper GitHub advisory feeds), and ask your auditor whether they checked the compiled bytecode and the compiler version against known issues.

3. The keys failed, not the contracts

Chainalysis attributes 43.8% of value stolen in 2024 to private key compromises (2024 data), and its 2025 report counts over $3.4 billion stolen in 2025, with the Bybit compromise alone at $1.5 billion through key infrastructure and signing, not contract code. Those losses do not require a bug in the contracts an auditor read. Validator keys, admin keys, and signer quorums sit outside the code diff.

Lesson: a contract audit doesn't review operational security. If your threat model ends at the contract boundary, your audit report can be spotless while the keys are the weak point. The Trail of Bits–led Rekt Test is a better starting checklist here: hardware keys for production, key management that needs multiple humans and physical steps, background checks, and a tested incident response plan.

4. A mature, reviewed protocol met a path nobody modeled: Euler (March 2023)

Euler's own account describes a protocol that had been live "for over a year" through hostile market conditions until March 13, 2023, when it was exploited for about $197 million. The attack went through the donateToReserves function in combination with Euler's liquidation logic. Euler recovered the funds over the next three weeks through negotiation and on-chain pressure. The recovery is a separate lesson in incident response.

Lesson: a feature that is safe on its own can become dangerous when combined with others. Reviews that check functions one at a time miss these paths. What helps is invariant-based testing of whole-system properties (for example, "no account can end a transaction with negative health and positive extractable value") and reviewers who are asked to attack the economics, not just the syntax.

5. The bug was found the right way: Wormhole (2022)

Not every story ends in a loss. Immunefi's bugfix review describes an uninitialized proxy vulnerability in Wormhole that a whitehat reported through Wormhole's bug bounty. Wormhole paid "a record bug bounty of $10 million." That's the outcome a security program is built for: the bug existed, but the incentive was big enough that the person who found it chose disclosure.

Lesson: bounties cover the period after the audit, when new code, new integrations and new market conditions change your risk. Size the bounty against extractable value, not against your marketing budget.

The pattern

Across these incidents, the failure was usually something the audit wasn't asked to cover, or covered only once:

Gap Example Control
Post-audit changes Nomad upgrade Diff review gate on every upgrade and initialization
Toolchain Vyper compiler Pinned compilers, advisory tracking, bytecode-aware review
Keys and infrastructure Private-key compromise Rekt Test controls, quorum design, monitoring
Cross-function economics Euler Invariant and fuzz testing, economic attack review
Post-launch discovery Wormhole Credible bounty, fast patch path

Trail of Bits' analysis of 246 of its own audit findings points the same way. Many serious bugs could, in principle, be caught by automated tools, but almost half of all findings need human understanding of the system and its market context. Neither tools nor people are enough alone, and neither covers keys and operations.

Questions to ask before you call your protocol "audited"

  1. Which commit was reviewed, and what has changed since then?
  2. Was deployment and initialization in scope?
  3. Which compiler and library versions were assumed, and are any affected by a published advisory?
  4. Who holds upgrade and admin keys, and what is the quorum?
  5. What monitoring would detect a large outflow within minutes, and who can pause?
  6. Is there a live bounty, and does its maximum payout make sense against extractable value?

If you can answer all six, "audited" means something. If you can't, the report is a snapshot, not a guarantee.

Sources

Sponsored