The DAO Hack Explained: Crypto's Most Famous Exploit

The DAO hack was a 2016 exploit in which an attacker used a reentrancy vulnerability in the smart contract of "The DAO" — at the time the largest crowdfunded project in history — to repeatedly withdraw funds before the contract could update its internal balance records, ultimately draining roughly one-third of the project's pooled ether, and triggering a controversial hard fork that permanently split the Ethereum blockchain into two separate networks.

The DAO (Decentralized Autonomous Organization) was an ambitious 2016 project built on Ethereum, designed to function as a venture-capital-style fund governed entirely by token holders voting on investment proposals, with no traditional management structure. It raised the equivalent of roughly $150 million worth of ether at the time from thousands of participants, making it the largest crowdfunding event in history up to that point — a testament to how much excitement the still-young Ethereum ecosystem had already generated.

The vulnerability

The DAO's smart contract included a "split" function allowing token holders to withdraw their share of pooled ether. The function's logic contained a critical ordering flaw: it sent the requested ether to the caller before updating the internal record of that caller's remaining balance. This is the textbook pattern behind what's now known as a reentrancy attack — our companion piece on what a reentrancy attack is explains the general mechanism in more technical detail.

Because the ether transfer happened first, an attacker could structure their withdrawal request through a malicious contract that, upon receiving the funds, immediately called back into the same withdrawal function again — and again — before the original transaction had finished executing and updated the balance. Each recursive call saw the same, not-yet-updated balance, allowing repeated withdrawals against funds that should have already been recorded as spent.

The attack and its scale

In June 2016, an attacker exploited this vulnerability to drain approximately 3.6 million ETH — at the time worth around $60 million, and a substantial fraction of the entire project's pooled funds — into a separate child DAO structure, exploiting the exact recursive pattern described above. The attack was executed openly on the public blockchain, meaning the Ethereum community could observe the drain happening in close to real time but had no straightforward way to stop it, since the transactions were, technically, entirely valid under the contract's own rules.

The response: a contested hard fork

The Ethereum community faced a genuinely difficult choice. Leaving the exploit unaddressed meant accepting the loss as final, consistent with the principle that blockchain transactions — even ones exploiting a bug — should be immutable. Reversing it required a hard fork: a coordinated change to the Ethereum protocol itself that would effectively rewrite history, moving the drained funds to a recovery contract as if the exploit had never happened.

After significant community debate, the majority of the network — including most major exchanges, developers, and users — adopted the hard fork, becoming what is today known simply as Ethereum (ETH). A minority who rejected the fork on principle, holding that blockchain immutability should never be compromised even to reverse a theft, continued running the original, unforked chain, which became Ethereum Classic (ETC) — a separate cryptocurrency and network that still exists today.

Why it still matters

The DAO hack remains one of the most consequential events in crypto history for several reasons: it's the direct origin of the Ethereum/Ethereum Classic split that persists to this day, it's widely cited as the canonical example of a reentrancy vulnerability, and it forced the broader industry to confront a philosophical question — whether "code is law" should hold absolutely, even when code contains an exploitable bug — that recurs in various forms after nearly every major hack since.

The DAO hack at a glance

Element	Detail
Year	2016
Vulnerability type	Reentrancy
Amount drained	3.6 million ETH ($60M at the time)
Response	Contested hard fork
Lasting outcome	Permanent Ethereum / Ethereum Classic split

Lasting lessons for smart contract security

The DAO hack directly popularized the "checks-effects-interactions" pattern now considered standard secure coding practice — updating a contract's internal state before making any external calls or transfers, closing off the exact ordering flaw that made the original exploit possible. It also spurred significant growth in smart contract auditing as a discipline, since a bug of this scale and consequence made clear how much value could ride on a single overlooked function.

Bottom line

The DAO hack demonstrated, in the starkest possible terms, that a smart contract's code is the actual, unforgiving rulebook governing funds — with no external authority able to intervene except through the extraordinary and controversial step of forking the entire network. Its legacy lives on in a specific coding pattern every serious smart contract developer now follows, and in the ongoing existence of two separate Ethereum-derived blockchains, each representing a different answer to the same hard question the hack forced onto the entire industry.