Ledger Ethereum Bug Let dApps Swap Your Transaction Mid-Review. Update to 1.22.2 Now

Here's a nightmare scenario for any hardware wallet user. The screen says you're approving one transaction. The device actually signs another. That's not a theoretical exploit from a spy movie. It was a real bug in Ledger's Ethereum app, and it's now patched.

The Story

Security firm TestMachine posted findings on Aug. 22 describing a nasty race condition. A malicious dApp with WebHID access could start a second signing command while a transaction was still on screen. The device would show the original transaction details, but hitting approve would sign the substituted data.

This isn't a subtle pixel difference or a phishing trick. The hardware wallet, the very device meant to be the ultimate arbiter of truth, would sign something entirely different from what you reviewed.

The attack was validated on Ledger Flex. TestMachine says the shared code base means Nano X, Nano S Plus, Stax, and Apex are all affected too. The tagged app manifest for 1.22.2 lists those exact models as build targets. So yes, this is the entire modern Ledger lineup.

Ledger's code history shows the fix. One commit tears down an active review when a new signing command comes in. Another added state checks because approval callbacks previously signed without confirming the app was still in the expected state. Version 1.22.2 closes both paths.

Here's where it gets murky. The changelog dates 1.22.2 to Aug. 12. GitHub shows a signed tag on Aug. 13. But TestMachine said on Aug. 22 that the fix wasn't released yet. Ledger CTO Charles Guillemet said on Aug. 23 that Ledger Donjon found the bug and deployed the fix about two weeks earlier.

So who found it first? Guillemet says Donjon beat TestMachine to the bounty program. TestMachine says its Azimuth system found the issue and verified it with Ledger. The public sources don't settle this cleanly. But honestly, who cares?

The real story is that the flaw existed at all.

Analysis

Hardware wallets sell on one promise: the secure element displays exactly what gets signed. That's the entire trust model. If that breaks, the device is just an expensive USB stick with a screen.

This bug doesn't extract your private key. It doesn't drain funds directly. But it lets an attacker replace a transaction you're reviewing with something else you didn't see. That's a catastrophic failure of the core security promise.

Let's be clear about the attack path. It requires a dApp with WebHID access. That's a browser API that lets websites talk to hardware devices. So the user would have to visit a malicious site and approve WebHID access. That's a meaningful barrier.

But here's the thing. Malicious dApps aren't rare. Phishing sites pop up daily. And once a user grants WebHID access, the attack is invisible. The screen shows one thing, the signature is for another. No warnings, no red flags.

Historically speaking, this mirrors the 2020 era of wallet bugs where the threat model was simpler. Now we've sophisticated race conditions being discovered by automated security systems. The bar is rising.

What's the actual damage here? No confirmed in-the-wild exploitation. No lost funds. No private key extraction. This was a responsible disclosure, and Ledger patched it. That's the good news.

The uncomfortable part is that this isn't a one-off. Ledger has had a rough security run lately. Earlier this year, researchers found a 7-year-old bug in the native Zilliqa app that let attackers rebuild a private key from five signatures. Five signatures. That's a different class of flaw entirely, but it's the same theme.

How many other apps in the Ledger store have similar races we haven't found yet? That's a rhetorical question, but it's the one every Ledger user should be asking.

Takeaway

Update your Ethereum app to 1.22.2 right now. Open Ledger Live, check the version, install the update. It's a two-minute task that closes a documented, code-level vulnerability.

Guillemet advises keeping device firmware, apps, and client software current. That's standard advice, but it's the only thing standing between you and a class of bugs that targets the blind spot between review and signature.

The invalidation point for your trust in any hardware wallet is simple: if the screen can't be trusted, nothing else matters. This bug didn't fully break that trust, but it bent it.

Here's the structural take. Hardware wallets are still the safest cold storage option for self-custody. But they're not magic. They're computers with a security-focused design, and that design needs constant auditing. TestMachine's Azimuth system found this one. Ledger Donjon fixed it. That's the system working.

The chart is the chart. And in this case, the chart says the vulnerability window is closed. Update, verify, move on. But remember what this tells you about the gap between what you see and what gets signed.

That gap is smaller now. It isn't zero. It never is.