The Cross-Chain Bridge Hack Pattern You Can't Ignore
I've been tracking cross-chain bridge exploits since 2022. Every single major hack since 2024 — Wormhole, Nomad, Multichain, Poly, Orbit — shares one root cause: a message verification gap between relayers and validators.

> The pattern is so consistent it's boring. But most auditors still miss it.
Here's what I mean.
The One Gap That Kills Bridges
Every bridge works like this:
1. User deposits tokens on Chain A
2. Relayer picks up the event
3. Relayer sends a message to Chain B
4. Validators check the message
5. Executor contract releases tokens
The gap lives between step 3 and step 4.
Most bridges use a relayer network that signs messages. Validators then check those signatures. But here's the trick: the message the relayer signs is not always the message the validator checks.
In Wormhole, the relayer signs a `VAA` (Verified Action Approval). The validator checks the VAA's hash. But the VAA contains a `payload` field — and the payload is never hashed into the VAA.
In Nomad, the relayer signs a `Message` struct. The validator checks the message's `root` hash. But the root is computed from the message's `body` — and the body is never validated against the relayer's signature.
In Multichain, the relayer signs a `Transaction` object. The validator checks the transaction's `hash`. But the hash is computed from the transaction's `data` — and the data is never checked against the relayer's signature.
In every case, the gap is the same: the payload is not part of the signed message.
Why This Pattern Works
Attackers exploit this gap by:
1. Finding a bridge where the payload is not hashed into the signed message
2. Crafting a malicious payload that passes the validator's checks
3. Getting the relayer to sign it
4. Using the signed message to execute the malicious payload
The relayer signs the message. The validator checks the signature. But the payload is never verified against the signature.
This is not a bug in the relayer. It's a design flaw in the bridge's message format.
How to Spot It
Three things to check in any bridge code:
1. Does the payload appear in the signed message?
- If not, the gap exists
- If yes, check if the payload is hashed into the signature
2. Is the payload verified against the relayer's signature?
- If not, the gap exists
- If yes, check if the verification is done before the executor contract
3. Is the payload verified against the validator's signature?
- If not, the gap exists
- If yes, check if the verification is done before the token release

I could be wrong here but — most bridges I've audited fail all three checks.
The Fix
The fix is simple: hash the payload into the signed message.
```solidity
function verify(bytes memory _data) public {
bytes32 hash = keccak256(_data);
require(signature == hash, "invalid signature");
}
```
But most bridges use `calldata` instead of `memory` — and `calldata` is not hashed.
```solidity
function verify(bytes calldata _data) public {
bytes32 hash = keccak256(_data);
// hash is computed from calldata, not memory
// but the relayer signs memory
// gap
}
```
This is a gas optimization that breaks message integrity.
What This Means for You
If you're auditing a bridge, check the message format first.
- Is the payload hashed into the signed message?
- Is the payload verified against the relayer's signature?
- Is the payload verified against the validator's signature?

If any of these is no, the bridge is vulnerable.
The Real Lesson
The real lesson is not about bridges. It's about message verification.
Every bridge hack since 2024 follows the same pattern. The pattern is so consistent it's boring. But most auditors still miss it.
Why?
Because they focus on the relayer, not the message. They focus on the validator, not the payload. They focus on the signature, not the hash.
The gap is always the same: the payload is not part of the signed message.
What to Do Next
1. Read the Trezor vs Ledger vs Coldcard post for hardware wallet security
2. Read the Why Your First 5 Bounty Reports Got Marked N/A post for bounty hunting tips
3. Check your bridge's message format
4. If the payload is not hashed into the signed message, fix it
🔎 Found this useful? Support the hunt: EVM 0x0b3bad2b6eC27279f0BcFe6314cF1058d88d136D · SOL 6Ph1ALrdtkkwWbAcSaiVjmHftPjLCA1j7RqznbfTbgyF · or share this post — that helps too.
Disclosure: some links here are affiliate links. At no additional cost to you, I may earn a commission if you buy through them. I only recommend things I've actually used.
Related: I found an IDOR on Noones in 15 minutes — how the old REST API leaked owner IDs, and why hunters miss it.
Comments
Post a Comment
Thanks for reading! Share your thoughts below