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

THORChain lost $10.7M to a fix that was already written

THORChain lost about $10.7M to an exploit its own developers had already fixed. Not "had a fix in progress". Not "were working on it". The patch had been written, tested, and scheduled to ship. The deployment automation

THORChain lost $10.7M to a fix that was already written

THORChain lost about $10.7M to an exploit its own developers had already fixed.

Not "had a fix in progress". Not "were working on it". The patch had been written, tested, and scheduled to ship. The deployment automation failed, and the fix never reached production.

That detail makes this case more useful than most exploit writeups, because almost every resilient team is one broken pipeline away from the same headline.

Cartoon: an open vault leaking coins, a parcel labelled FIX stuck before a broken conveyor, and a clock labelled patch queued

What was exploited

Per Blockaid's analysis, the attacker abused a proposer-forgery bug in Bifrost's attestation gossip — the layer where nodes gossip observations about what they saw on connected chains.

The chain of events:

  1. The attacker forged proposer messages in the attestation gossip layer.
  2. They intercepted inbound deposit observations — the messages saying "funds arrived on chain X".
  3. They flipped those into outbound payment requests — "release funds on chain Y".
  4. The validator signature did not cover the inbound/outbound direction bit.
  5. Vaults were drained across ETH, BTC and BNB.

Read step four again. The signature covered the payload but not the direction. A validator signing "I saw this event" was indistinguishable from a validator signing "pay this out", because the bit that says which one it is wasn't inside the signed data.

That is the same class of failure as a check that verifies a proof but not what the proof is about. The cryptography worked exactly as specified. The specification didn't include the one field that mattered.

The part that should worry every team

THORChain's developers knew about this bug. They had already written the fix. It was scheduled for deployment earlier in the month.

The automated update system failed, so the fix sat in a queue while the vulnerability stayed live.

This is not a story about a team ignoring warnings. It is a story about the difference between "we fixed it" and "the fix is running". Those two states feel identical from inside an engineering org, and they are separated by an entire deployment pipeline that nobody treats as security-critical.

Ask yourself, honestly: if someone asked you right now whether your last security patch is running in production, how would you answer? From memory, or from a dashboard?

The secondary story nobody wants to have

RUNE dropped about 14% in two hours after the news, from $0.585 to $0.501. That is the financial part, and it recovered or didn't, as markets do.

The stranger part is what THORChain has become. It was built specifically to avoid bridges, because bridges are where the money gets stolen. Now it is one of the preferred routes for laundering the proceeds of bridge hacks. In the Kelp DAO incident alone, roughly $292M was routed through THORChain.

Its operators describe the refusal to screen transactions as principled decentralisation. You can hold that position and still notice the shape of the outcome: infrastructure that processes a large share of state-sponsored laundering, maintained by people who consider that a feature.

I am not making a policy argument here. I am pointing out that a protocol's reputational risk is now a security property. When your chain is the main exit for Lazarus Group funds, you are a target, a subject of regulatory attention, and a line item in every counterparty's risk review.

The actual lesson

Four things, in order of how much they would have helped:

1. The deployment pipeline is part of the attack surface.
Audit CI/CD the same way you audit contracts. A patch that fails to deploy is a patch that does not exist. Measure "time from fix merged to fix in production", and alert on it like you alert on uptime.

2. Sign what you mean, not just what you say.
If a signature is meant to authorise a direction, a volume, and a destination, then all three need to be inside the signed payload. Signing a message that a separate field reinterprets is the oldest bug in the book, and it keeps working because the signed part looks fine.

3. Automate the detection of "not deployed".
The interesting failure mode is not a broken build that yells. It is a build that silently doesn't run. Your monitoring should compare what is running to what is supposed to be running, per service, continuously.

4. Assume the press cycle will outlive the incident.
The exploit is a week of headlines. Being the industry's favourite laundering route is a permanent condition. Both of those belong in your threat model.

The line worth keeping

This one is going to sting if you have ever shipped anything:

You are not secure because you have the fix. You are secure because the fix is running.

Everything between those two statements is engineering, and it is the part that gets skipped when a launch is close and the patch "is obviously fine".

THORChain had the fix. That is the whole tragedy of the case, and the whole lesson.

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.