Why Protocols Get Hacked

Take the first door slowly. Imagine a bank teller with one bad habit: when you withdraw, they hand you the cash first and only then write the new balance in the ledger. In that tiny gap, before the pen moves, you ask to withdraw again. The ledger still shows your old, full balance, so they pay you again.

A contract can have the exact same flaw. It sends money out before it updates its own memory, and the attacker uses that gap to call back in and drain far more than they own. This is the re-entry trick, and its most famous appearance was The DAO in 2016, an early Ethereum project drained through precisely this interrupted-teller flaw.

The second door is the one checkpoint 15 set up for you. A contract has no senses. To know the price of an asset, it reads a feed, a thermometer that reports an outside number onto the chain. The machine has no gut instinct to doubt that number.

So the attacker does not break the contract. They briefly bend the reading the thermometer is watching, make the feed report a price that is wildly wrong for a moment, and the contract acts on it with perfect confidence: lending too much, selling too cheap, paying out on a lie. The math was flawless. The trust in one unchecked number was the door.

The third door is less a single trick and more a place attackers concentrate. Bridges, the cross-chain crossings you met in checkpoint 14, lock real funds on one side so a stand-in can exist on the other. That makes them the largest single pots of money in the entire space.

They also run some of the most complex code anywhere, because moving value safely between two separate chains is genuinely hard. Largest reward plus highest complexity is exactly the combination an attacker hunts for. It is why, as you learned, the biggest single hacks on record have been bridge hacks. The size of the prize pulls the most effort toward the hardest code.

Now the part that makes a single flaw frightening. Back in checkpoint 12 you saw that contracts plug into each other, one calling another calling another, with no human stitching them together. That composability is the quiet superpower of this whole world.

It has a shadow. When a contract everyone builds on has a flaw, the flaw does not stay put. It travels into every other contract that trusts it. A bug in one widely used piece becomes a bug in everything that plugged into it. That is the blast radius, and it is why the stakes here are higher than in ordinary software: nobody owns the whole chain of trust.

So where does a security firm fit into all this? An audit is a serious, adversarial reading of a contract before it ships: experts spending their days trying to break it on paper, exactly as checkpoint 12 described, so it does not break later with real money on it. Done well, it finds real flaws and removes them.

But here is the part the marketing leaves out, and we will not. An audit reduces risk. It never guarantees safety. Reviewers are human, code is complex, and an attacker only needs one missed door. A good audit makes you much safer. It cannot make you certain. Anyone selling you certainty is selling, not auditing.

This is the single most useful habit in the lesson. The word audited on a landing page tells you almost nothing. It is a badge, and a badge can be printed by anyone.

A real audit produces a published report you can open and read. It names who did the review, states the scope, exactly which contracts were checked, lists what they found, and crucially says whether each issue was fixed. A finding that was reported but never resolved is still a live door. When a team waves the badge but cannot point you to the report, that gap is itself the signal.

Because no audit can promise safety, serious teams do not rely on one thing. They stack layers. Audits catch flaws before launch. Bug bounties pay outside researchers to report a flaw rather than exploit it. Monitoring watches the live system for trouble. Timelocks force a delay on big changes so users can see a risky move coming and step away in time.

This is defense in depth, and it is the right thing to look for. Not a single proud badge, but a posture: several honest layers, each covering for the others when one inevitably misses. A team that talks openly about all four is showing you how it thinks. A team with only a sticker is showing you that too.

So here is what you can now do. You know hacks are almost never broken math, they are logic, a side door nobody modeled. You can name three plain shapes: the re-entry trick that drained The DAO in 2016, the manipulated thermometer that feeds a blind contract a fake price, and the bridge pot that pulls attackers toward the richest, most complex code. You understand the blast radius of composability, and you know an audit is risk reduction, never a guarantee.

Most of all, you can tell a printed badge from a report you can open and read, and you know to look for the whole posture: audits, bounties, monitoring, timelocks, and an honest team behind them.

That is how protocols break and how you read their defenses. Next we turn it into a habit you can run on any project in ten minutes: team, token, traction, trust. How to evaluate a project, the method DYOR always promised and never gave you.