Research
Cross-chain bridge hacks: how bridges work and why they fail
A cross-chain bridge exists to make one decision that neither chain can make for itself: that something happened on the other chain, so value can be released or created on this one. Every cross-chain bridge hack is a way of getting that decision wrong. Three of the best-known cases, Ronin, Wormhole and Nomad, all in 2022, broke it at three different points: who signs, how the signature is checked, and what counts as proof. DefiLlama’s record, as of 22 November 2026, flags 105 incidents as bridge hacks, $3.7B in all.
What a bridge has to decide
A blockchain can read only its own state. A contract on Ethereum has no way to look at Solana and see that a deposit arrived there, so a bridge needs some party or mechanism to carry that fact across and some rule on the receiving side for believing it. The asset side and the verification side are separate design choices, and the developer documentation on ethereum.org describes both.
In the first asset design, lock and mint, tokens are locked in a contract on the source chain and a wrapped version is minted on the destination. The wrapped token is only as good as the locked pool behind it: if the pool is emptied, or if wrapped tokens are minted with nothing deposited, every holder of the wrapped token holds a claim on less than it says. The documentation lists two other ways to move an asset: burn and mint, in which tokens are destroyed on the source chain and created on the destination, and the atomic swap, in which assets on the source chain are swapped for assets on the destination with another party.
Liquidity networks work differently. In the documentation’s terms they move assets by atomic swap rather than by minting a claim, generally carry no messages, and are locally verified, relying on the underlying chains’ own validators to check each transfer.
The verification side is the choice that decides how a bridge fails. In what the documentation calls trusted bridges, an external set of verifiers (a federation behind a multisig, a multi-party computation group, an oracle network) attests that the deposit happened, and the receiving contract accepts the attestation once enough of them sign. In a light-client design the receiving chain instead runs code that checks the source chain’s own consensus. The Inter-Blockchain Communication protocol’s client specification defines a light client as a validity predicate paired with a trusted state: it accepts only those state updates that the remote chain’s consensus agreed. Optimistic designs, Nomad’s among them, accept a message unless someone proves fraud within a waiting period.
Whatever the design, the locked pools are large. As of 22 November 2026, per DefiLlama, the 70 protocols of $1M or more that it files under Bridge hold $55.1B, and the 49 of that size under Canonical Bridge, where the largest entries are Arbitrum Bridge, Base Bridge and Polygon Bridge, hold $10.4B. Those are deposits at current prices, with the caveats every TVL figure carries, and each bridge’s share of them sits behind that bridge’s own verification rule.
Why that decision breaks
Of the risks the ethereum.org page names, three bear on that decision: smart contract risk, since a single flaw in a contract can expose a bridge’s assets; systemic financial risk, since many bridges mint wrapped versions of an asset and wrapped tokens have been exploited; and, for trusted designs, the counterparty risk that validators collude to steal users’ funds. Put in terms of the decision, there are three places to break it. The attacker can control enough of the signers. The attacker can get past the code that checks the signers’ work. Or the attacker can find that the code accepts something that was never proven at all. The three 2022 cases are one of each.
Ronin, March 2022: five keys out of nine
Ronin is the Ethereum-linked sidechain Sky Mavis built for its game Axie Infinity, according to the game’s whitepaper, and its bridge to Ethereum was externally verified. Ronin’s community alert explains that the chain had nine validators and that five of their signatures were needed to recognise a deposit or a withdrawal. Sky Mavis ran four of the nine. On 23 March 2022 an attacker who controlled five used them to sign two withdrawals, which took 173,600 ether and 25.5 million USDC from the bridge. Sky Mavis found out on 29 March.
Ronin’s post-mortem explains how four became five. Sky Mavis staff had faced persistent spear-phishing, and one employee was compromised; the attacker used that access to get into Sky Mavis’s IT infrastructure and its validator nodes. The fifth signature came from an arrangement nobody had closed. In November 2021, under heavy user load, the Axie DAO had allowlisted Sky Mavis to sign transactions on its behalf. The arrangement stopped in December, but the allowlist was never revoked, so from inside Sky Mavis’s systems the attacker could obtain the Axie DAO validator’s signature through a gas-free RPC node. The post-mortem also says Sky Mavis had no proper system for tracking large outflows from the bridge, which is why six days passed before anyone noticed.
On 14 April 2022 the FBI stated that Lazarus Group and APT38, cyber actors associated with North Korea, were responsible for the theft of $620 million in ether reported on 29 March; Ronin’s post-mortem records that the FBI had attributed its breach to Lazarus Group. Ronin said its threshold would rise to eight signatures of nine.
The post-mortem points to no flaw in the bridge’s contracts. The bridge did exactly what its rule said, and the rule trusted a set of keys that was smaller in practice than on paper. DefiLlama’s record files Ronin Bridge at $624.0M under Key Compromise, technique Validator Key Compromised, and flags it as a bridge hack; it does not sit in the Bridge & Cross-Chain class.
Wormhole, February 2022: a check on the wrong account
Wormhole is a messaging network run by nineteen Guardians, and a message counts as authentic once two-thirds or more of them have signed it, according to Wormhole’s incident report. Portal, the token bridge built on it, mints wrapped tokens on a destination chain such as Solana only when it receives such a message.
The flaw was in how the Solana contract checked those signatures. Its
verify_signatures function relied on the instruction sysvar, an account the
Solana runtime fills in and that programs therefore trust. But a caller on
Solana can pass any accounts it likes, and each program must confirm that it was
given the ones it expects. verify_signatures did not confirm that the account
was the real sysvar. The attacker built an account made to look like it and
passed that in, and the function treated the message’s signatures as verified.
From there any message bound for Solana could be forged. On 2 February 2022 the
attacker used one to mint 120,000 wrapped ether with nothing deposited, sent
93,750 of them back to Ethereum, and redeemed them for real ether from the
bridge.
The report adds a detail that matters for anyone reading bridge code. A routine upgrade to Solana toolchain 1.9.4, which deprecated the unchecked functions in favour of variants that include the missing check, had been pushed to the public repository on 13 January 2022 to be audited before the next release, and Wormhole says the attacker may have noticed the vulnerability because that commit was public. Jump Crypto refilled the contract with 120,000 ether, and the network was back online at 13:29 UTC on 3 February. The attacker never needed the Guardians’ keys. The signature rule held; the code that applied it did not.
The record files Portal at $326.0M under Input Validation, technique Signature Verification Flaw, flagged as a bridge hack.
Nomad, August 2022: everything counted as proven
Nomad was an optimistic design. Messages were committed to a Merkle tree on the sending chain, and on each receiving chain a Replica contract processed a message only once it had been proven against a root that had passed its waiting period. Nomad’s root-cause analysis sets out how that check failed.
The Replica keeps a mapping from each message to the root under which it was
proven. A message never proven maps to the default value, a root of zero. The
check acceptableRoot looks up when a root became valid, and for a zero root
that lookup should have found nothing. But the contract’s initialiser marked its
starting root as valid from time 1, and Replicas deployed alongside their
sending-side contracts started from an empty tree, whose root in Nomad’s
implementation is zero. So the zero root was valid from time 1, which every
block timestamp exceeds, and every message that had never been proven passed the
check. The code went live in an upgrade on 21 June 2022. Nomad says the upgrade
had been audited by Quantstamp in May and early June, and that the change was
made during the audit period and included in the code sent for re-audit.
On 1 August 2022 the bridge was drained of about $190M, by the count in Immunefi’s analysis, which also describes what made it unusual: once the first attacker succeeded, others replayed the same transaction with their own address in it, in what Immunefi calls a “crowdsourced” hack. No key was taken. The record files Nomad at $190.0M in the Bridge & Cross-Chain class with the technique Forged Proof, though by Nomad’s own account no proof was forged; the messages were processed without one.
The record: two ways of counting
DefiLlama’s record has two ways of marking a bridge incident, and they do not
agree. The flag bridgeHack, which DefiLlama does not define, marks 105
incidents with $3.7B, 7.6% of the record’s 1,373 incidents and 13.4% of its
$27.6B. The class Bridge & Cross-Chain
holds 59 incidents with $1.5B, 4.3% and 5.6%. Forty-eight incidents are in both.
Counting either, the total is 116 incidents and $3.7B.
The difference is the point. Of the flagged value, 40.8% sits in the bridge class; the rest is filed elsewhere, under Key Compromise (17 incidents, $988.1M, 26.8%), Access Control (13, $648.1M, 17.6%) and Input Validation (8, $508.9M, 13.8%), with small amounts in four other classes. It is the 2022 pattern at record scale: more of the flagged value was lost through signer keys and through permission and input checks, 58.1% between those three classes, than through the cross-chain logic the bridge class is named for. The eleven class incidents without the flag, $30.4M between them, include rows named after chains rather than bridges (Bitcoin Gold, Ethereum Classic twice, ZenCash, MonaCoin).
| Year | Incident | Class | Technique | Amount |
|---|---|---|---|---|
| 2022 | Ronin Bridge | Key Compromise | Validator Key Compromised | $624.0M |
| 2021 | Poly Network | Access Control | Improper Access Control | $611.0M |
| 2022 | Binance Bridge | Bridge & Cross-Chain | Proof Verifier Bug | $570.0M |
| 2022 | Portal | Input Validation | Signature Verification Flaw | $326.0M |
| 2026 | Liquid Network | Bridge & Cross-Chain | Unbacked Cross-Chain Mint | $320.0M |
| 2026 | Kelp | Bridge & Cross-Chain | Cross-Chain Message Spoofing | $293.0M |
| 2022 | Nomad | Bridge & Cross-Chain | Forged Proof | $190.0M |
| 2023 | Multichain | Key Compromise | Validator Key Compromised | $126.0M |
| 2022 | Harmony Bridge | Key Compromise | Validator Key Compromised | $100.0M |
| 2023 | Heco Bridge | Key Compromise | Hot Wallet Key Compromised | $86.6M |
These are the ten largest flagged incidents. Together they hold $3.2B, 87.9% of the flagged value, and the record’s median flagged incident is $1.8M, against $735K for the record as a whole. Four of the ten carry a Key Compromise label, and three of those the technique Ronin carries, Validator Key Compromised. Within the class itself the techniques run Forged Proof (19 incidents, $265.5M), Bridge Logic Flaw (18, $35.6M), Cross-Chain Message Spoofing (9, $310.2M), Unbacked Cross-Chain Mint (7, $334.4M), Proof Verifier Bug (4, $572.9M) and Spoofed Event Log (2, $17.5M).
Over time the flagged series is lumpy. No flagged incident is dated before 2021. 2022 holds 14 flagged incidents but $1.9B, 51.6% of all flagged value. Then 2026 holds 54 flagged incidents with $754.7M, and 37 of the class’s 59 incidents, against 3 in 2025. The record does not say how the flag or the class is assigned, so it cannot show whether 2026 saw more attacks on bridges or a change in how incidents were labelled; the year so far sets the class against the rest of 2026.
The same three failures in 2026
The two largest bridge-class incidents of 2026 fit the same scheme. At Kelp, whose rsETH token moved between chains on LayerZero, the application relied on a single verifier, which, in LayerZero’s account, was fed a false picture of the source chain through RPC nodes the attacker had compromised, while the others were knocked out with a denial-of-service attack. It then confirmed transactions that had never taken place. LayerZero says the attack did not come through an exploit of its protocol, the verifier or its key management. That is the Ronin pattern in another form: the verifier itself was not breached, but there was one verifier, and it trusted its view of the chain. At Liquid Network, a Bitcoin sidechain run by a federation, Blockstream’s assessment traces about 4,000 unbacked LBTC to a flaw in how Liquid’s nodes cached the results of proof checks, after which federation signers released 3,996.02 BTC against them on the main chain. That is the Wormhole pattern: the rule was right and the code applying it accepted something it should not have.
What can be checked from outside
None of this ranks bridges, and a bridge with no row in the record has not been shown to be safe. What the cases do give is a short list of questions to put to any bridge’s documentation. What backs the wrapped token, and where is the locked pool? Who attests to a deposit, how many of them are there, and how many does a withdrawal need, counting any arrangement under which one party signs for another? Does the receiving chain check the source chain’s consensus itself, or accept a signed statement about it? And has the code that checks those signatures or proofs been changed recently, and by whom was the change reviewed? Ronin, Wormhole and Nomad each failed on one of those questions. Two more apply to a holder. For an ERC-20 token, a lock-and-mint deposit normally starts with an approval that lets the bridge contract move the token (EIP-20 defines the approve and transferFrom pair), and three flagged incidents ($10.7M) carry the technique Token Approval Abuse; what a wallet connection approves explains why an allowance outlasts the visit. And a wrapped token is a claim on a bridge’s pool, not on the original asset, so its value rests on every answer above. That is why the record’s bridge rows are worth reading on their own, as how crypto gets hacked does when it sets the class against the flag.