Crypto security in 2026 has been ugly for the wrong reason: the biggest losses are increasingly coming from keys, signers, and people, not just bad code.
- H1 2026 losses: TRM Labs counted 207 hacks and $972 million stolen.
- Biggest blows: Drift Protocol lost about $285 million; KelpDAO lost about $292 million.
- Main pattern: infrastructure, key, and operational failures are doing more damage than classic smart contract bugs.
- Coldcard fallout: a hardware wallet firmware flaw showed self-custody can fail when randomness is broken.
That’s the part people keep missing. The market still loves to talk about audits as if a clean code review is some kind of magical force field. It isn’t. A protocol can ship solid contracts and still get drained because one admin key gets phished, one signer gets fooled, or one verifier is too centralized for its own good.
TRM Labs’ H1 2026 report makes that shift painfully clear. The firm says attackers carried out 207 hacks in the first half of the year and stole $972 million in total. It also says about $643 million, or roughly 66% of those losses, is attributable to North Korea-linked activity. So no, this is not just random opportunistic criminal noise. It is organized, repeated, and very often effective.
The two biggest hits were especially brutal. TRM says Drift Protocol lost about $285 million on April 1, while KelpDAO lost about $292 million on April 18. Together, that is roughly $577 million. In other words, two incidents accounted for a huge chunk of the year’s damage. That is exactly why “it’s only one exploit” is such a dumb way to think about crypto risk.
TRM’s numbers also help separate frequency from impact. Smart contract exploits were still the most common type of incident, but infrastructure and operational compromises made up only about 15% of incidents while accounting for roughly 76% of total losses. That is the real story. Most hacks may still be contract bugs, but the expensive ones are increasingly happening one layer up, in the messier human and administrative plumbing.
Ronghui Gu of CertiK put that bluntly: “A protocol can pass a flawless code audit and still lose millions because of a compromised admin key.” That’s the problem in one sentence. Code audits matter, but they are not a complete security model. They do not protect you from social engineering, rogue signers, weak custody practices, or governance that concentrates too much power in too few hands.
Drift and KelpDAO are good examples of that failure mode. According to the reporting cited by TRM and other investigators, both incidents were linked to North Korea-connected actors, including the Lazarus/TraderTraitor cluster. The Drift attack reportedly took just 128 seconds. That is not a lot of time to realize your trust assumptions have been turned into confetti.
What happened matters more than the speed alone. These kinds of attacks often do not require the attacker to “break” the blockchain in any dramatic sense. They just need to breach the trust boundary: get access to a signer, manipulate an admin workflow, compromise a verifier, or hijack a session. Once that happens, the code can be pristine and the money can still walk out the door.
KelpDAO shows how ugly the ripple effects can get. Attackers minted 116, 500 unbacked rsETH and then used it as collateral on Aave. rsETH is meant to represent staked ETH, so when the backing is fake, the collateral is fake too. That’s how bad inputs become real damage.
The fallout spread fast. Aave’s total value locked dropped by $6.28 billion in 48 hours, and nine protocols froze markets after the exploit. That does not mean Aave or DeFi “failed” in some grand, dramatic sense. It means risk controls kicked in hard when confidence broke. In DeFi, contagion is usually just a series of cautious systems all hitting the brakes at once.
Arbitrum’s Security Council later seized 30, 766 ETH from the attacker’s wallet on-chain. That kind of emergency intervention is both a feature and a red flag. It can help contain damage, but it also reminds everyone that “decentralized” often still includes a few very central escape hatches when things go sideways.
Bridge design remains a recurring weak spot for the same reason. Cross-chain systems depend on verifier assumptions, and too many of those assumptions are still too concentrated. The source notes that 47% of LayerZero OApp contracts, more than 1, 200 of them, use a single-verifier setup. OApp stands for omnichain application, which is LayerZero’s way of describing apps that move messages or assets across chains. A single verifier is exactly what it sounds like: one point of approval standing between safety and a very bad day.
That matters because bridge attacks are not usually about some cinematic on-chain wizardry. They are about trust concentration. If one verifier, one signer, or one operational path controls too much, then one compromise can unlock the whole thing. That is not decentralization. That is a bottleneck with marketing.
The AFX Trade and VerusCoin incidents, along with the Cosmos EVM underflow bug affecting MANTRA, TAC, and KiiChain, all point in the same direction: attackers keep working the trust boundary. If they can exploit message verification, custody assumptions, or cross-chain accounting, they do not need to beat the entire system. They just need to hit the part that everyone else assumed was safe.
Then there was Coldcard, which pushed the lesson into self-custody territory.
Coinkite’s hardware wallet ran into a firmware flaw that weakened entropy, the randomness used to generate keys. When randomness is compromised, private keys can become guessable or brute-forceable. That is the kind of bug that should make any serious Bitcoin user sit up straight, because hardware wallets are only as strong as the firmware and key-generation process behind them.
Galaxy Research traced the initial Coldcard wave to 1, 082.65 BTC stolen from 1, 196 addresses in 41 minutes. By August 7, the high-confidence tally had grown to 1, 596 BTC from roughly 7, 300 addresses. Broader estimates that included additional suspicious cases pushed the total past 2, 055 BTC, or about $130 million.
That is not a normal “user got phished” story. It is a failure in the self-custody stack itself. And to be clear, that does not mean hardware wallets are useless. It means secure devices still depend on trustworthy firmware, sound entropy generation, and a vendor discipline that does not cut corners where randomness matters most. If the seed is bad, everything downstream is bad too.
Coldcard Firmware Vulnerability Leads to Over $100 Million was the kind of headline nobody in Bitcoin wants to see, but it matched the scale of the damage. Coinkite CEO NVK posted a public apology. That’s the least anyone should expect when a security flaw of this size surfaces. The deeper point is harsher: self-custody is still the right instinct, but it is not a magical shield. It demands serious operational care, and the industry still has too many people treating it like a box they bought off a shelf and forgot about.
The Largest Hardware Wallet Exploit of 2026 shows just how quickly that confidence can get punched in the teeth. The source says the group’s rolling 18-month tally now exceeds $2 billion when the February 2025 Bybit hack is included. That fits the broader pattern seen in public advisories from the U.S. Treasury, FBI, and CISA, all of which have previously named Lazarus and documented its tactics.
North Korea Stole 76% of All Crypto Hack Value in 2026 is not a typo-friendly stat. It’s a reminder that a tiny number of highly coordinated attacks can dominate the damage. The point is not that Lazarus has supernatural powers. The point is that the group keeps exploiting the parts of crypto that are easiest to abuse and hardest to police: social engineering, compromised keys, session hijacking, and sloppy operational controls. If you can trick the signer, you do not need to hack the contract. You just walk around it.
That should force a rethink across the industry. Audits still matter. Smart contract bugs still matter. But the biggest losses are increasingly coming from the stuff a code review cannot fully see: admin key management, signer workflows, verifier design, governance controls, and incident response planning. Crypto loves to celebrate technical elegance, but elegance does not stop a phishing email.
The fix is not more hand-waving about “best practices.” It is less trust concentration, better hardware-backed signing, multi-verifier bridge setups, timelocks on privileged actions, and controls that assume attackers will go after people as hard as they go after code. In other words: design for real abuse, not the polished slide deck version of security.
Key takeaways
-
Why are the biggest losses happening outside smart contract code?
Because attackers are targeting keys, signers, governance, and operational weaknesses. Those paths are often cheaper and faster than finding a contract bug. -
Are audits still useful?
Yes, but only as one layer. A clean audit cannot save a protocol if an admin key is compromised or a verifier is too centralized. -
What do Drift and KelpDAO show?
They show how concentrated trust can turn one failure into a massive loss. Together, they cost roughly $577 million and exposed how fragile some protocol controls still are. -
Does the Coldcard flaw mean hardware wallets are unsafe?
No. It shows that hardware wallets still depend on correct firmware and strong entropy. Self-custody is only as strong as the weakest part of the device and supply chain. -
What should protocols do differently?
Reduce signer concentration, use hardware-backed signing, add timelocks, harden governance, and rehearse incident response. Security has to move beyond “we passed the audit.”
DeFi has lost $1.3 billion to hacks in 2026 and the same is the kind of ugly number that should end the fantasy that risk is somehow being “solved” by branding. Crypto does not need less code. It needs less trust in the wrong places.
Further reading
A few related dispatches worth having open beside this one:
