Dev.to Security 🔐 Cybersecurity 👁 0 📖 4 min read

Verus bridge lost $11.7M and every proof was valid

Verus-Ethereum bridge lost about $11.7M in May 2026, and the detail that makes this case worth a post is that every cryptographic proof in the attack was valid. The signatures were correct. The notarisation was correct.

Verus bridge lost $11.7M and every proof was valid

Verus-Ethereum bridge lost about $11.7M in May 2026, and the detail that makes this case worth a post is that every cryptographic proof in the attack was valid.

The signatures were correct. The notarisation was correct. The Merkle commitments matched. The contract did exactly what it was written to do, and $11.7M left anyway.

The numbers

Cartoon: three message types on a conveyor — a primary export, a supplemental export and a notarization — all passing through a gate marked proof valid, with a triangle being paid out as coins

  • Loss: roughly $11.7M in ETH, tBTC and USDC
  • Date: May 18, 2026
  • Path: Verus L1 to Ethereum
  • Seed funding: 1 ETH through Tornado Cash
  • Recovery: about 75% returned within five days
  • The bridge halted itself after a node assertion failure

That last line is worth pausing on. The system that stopped the bleed was an assertion inside a node, not a guard inside the contract.

Three object types, one missing check

The Verus bridge protocol carries three kinds of objects:

  1. Primary Export — the object type used for actual payments.
  2. Supplemental Export — extra data attached to a transaction, not a payment instruction.
  3. Notarization — the state proof.

The Ethereum-side contract verified the proof that a given object had been emitted on Verus. It did not verify which type of object it was importing.

So the attacker constructed supplemental exports — data intended to be non-payment context — and submitted them as imports. The proof was genuine, because those objects really had been emitted. The contract accepted them as payment instructions, because it never asked what type they were.

How the attack ran

  1. Funded an address with 1 ETH through Tornado Cash.
  2. Took 0.02 VRSC from a faucet to have native currency.
  3. Created four export transactions with crafted supplemental outputs.
  4. Embedded matching hashReserveTransfers commitments so the Merkle layer lined up.
  5. Waited for notarisation to advance, so the proofs would be legitimate.
  6. Submitted the imports on Ethereum.
  7. The bridge verified: proof valid, type unchecked.
  8. Extracted $11.7M.

Nothing in that sequence is a clever exploit of a bug. It is a sequence of legitimate operations, each individually correct, assembled into a payment that was never authorised.

Why this is a new category, not a repeat

Bridge security has spent years getting good at checking three things: is the signature valid, is the Merkle proof valid, is the ZK proof valid. Those checks are now, broadly, working. The bridges that still get hit in 2026 are not failing at cryptography.

They are failing at the question that comes after the cryptography: given that this message is authentic, what is it allowed to do?

That is a different problem. It is semantic, not mathematical. It requires modelling what each message type means and enforcing that the operation matches the intent. Most bridge codebases have never had that modelled explicitly, because the cryptographic checks felt like the hard part, and everything after them looked like plumbing.

June 2026 made that assumption expensive:

  • Hyperbridge: $2.5M, proof-request decoupling.
  • Syscoin: about $8M, validation gap.
  • Aztec Connect: $2.19M, a deprecated contract nobody was watching.
  • Verus: $11.7M, type confusion.

Four different codebases, four different mechanisms, one shared property: the authentication was fine, the authorisation was not.

The part that makes this hard to fix

Type confusion is easy to describe and awkward to prevent, because it lives in the space between two systems.

On one side, a chain emits structured objects with types. On the other side, a contract defines handlers that expect particular shapes. The binding between them is a specification, and specifications drift. A field that means "context" in one release becomes "context or instruction" when someone adds a feature, and the check that would have caught it was never written because nobody thought to ask.

Practical mitigations, in order of impact:

1. Make the type part of the signed payload, not a sibling field.
If the proof covers an object, the type has to be inside the object. Anything outside the proof is attacker-controlled by definition.

2. Reject unknown types explicitly.
Allow-list the handlers. A default: branch that throws costs nothing and prevents an entire class of confusion.

3. Write the intent down as an invariant test.
For each bridge operation, assert the property in plain language and test it: "an import may only release funds if the source object is a Primary Export." Then test that a supplemental export import reverts.

4. Fuzz the message space, not just the amounts.
Most bridge fuzzing varies amounts and addresses. It rarely varies the semantic type and shape of the message. That is where the money is now.

5. Treat the message format as an attack surface.
It is code, and it has a grammar. Anything with a grammar has ambiguity, and ambiguity in a money path is a vulnerability.

The line worth keeping

"Verified" means someone proved the message is genuine. It does not mean the message is allowed to do what it is asking.

Every one of the 2026 bridge losses sits in that gap. The Verus case just makes it unusually clean: no exploit trick, no race, no oracle manipulation, just a contract that trusted the shape of its input as much as the proof of it.

This is one of 61 on-chain case investigations, indexed at qanzhi111.github.io/intel.

The archive: 61 investigations, 64 leak scans, 0 exploited

The archive. 61 on-chain investigations and 64 days of GitHub leak scanning, redacted and never used. Read the index or try the free token risk check at qanzhi111.github.io.

📰 Read the original article on Dev.to Security

Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.