On 29 October 2026, at 20:04 UTC, the first outflow left Binance's hot wallet on the XRP Ledger. Within about 20 minutes, money was leaving 17 hot wallets across nine chains; the last Ethereum outflow came at 23:56. TRM Labs puts the total loss at $6.36 billion. It is the largest crypto theft on record, and according to Elliptic's chief scientist, probably the largest theft of any kind.
I have spent four years on the security side of crypto exchanges. Like the Liquid Network case, this incident doesn't fit the usual patterns: according to Binance, no wallet private key was leaked. The attacker didn't steal the key. They got the system that uses the key to sign their requests. In this piece I try to work through the technical side of the incident, step by step, using public information and my own on-chain queries.
An important caveat: Binance has not yet published its official incident report, and the initial access vector has not been disclosed. I have tried to keep verified facts separate from inference below, and I mark the places where I am inferring.
I. The incident in numbers
According to Bitquery's on-chain analysis, at prices at the time of the theft:
| Chain | Assets out | Value |
|---|---|---|
| Ethereum | 200,630 ETH + 1.6B USDT + 62 tokens | $3.77B |
| Bitcoin | 18,270 BTC, in a single block | $1.48B |
| TRON | 613M USDT | $628M |
| XRP Ledger | 233.5M XRP | $300M |
| Solana | SOL and tokens | $96M |
| Arbitrum, Polygon, Optimism, Base | various | ~$49M |
| Total (TRM Labs) | $6.36B | |
The main Ethereum outflow was a single transaction: at 20:24, 167,464 ETH, 1.6 billion USDT and 62 different tokens moved in one go. That one transaction was worth more than $2.5 billion.
II. Timeline
In other words, the "Binance 14" wallet kept running the attacker's code for about four hours after the first drain. According to sources compiled on Wikipedia, the attackers likely began preparing at least 36 hours in advance.
III. The attack chain
Putting together Binance's preliminary findings and CEO Richard Teng's statements, this is the chain as we know it today:
- Initial access: a DevOps laptop. According to Binance's preliminary findings, the attack started on a DevOps engineer's computer. How it was compromised has not been disclosed. Binance statement
- Foothold: a service container that can submit withdrawal requests. From the laptop, the attacker reached a service container able to create withdrawal requests. Teng said further points of compromise beyond the laptop were found and the full chain is not yet clear. Binance statement
- Abuse of the signing service. The attacker obtained signatures the signing system should never have produced. According to Binance no private key leaked; the keys stayed where they were, but the system using them signed the attacker's requests. Binance statement
- Taking over the wallet on Ethereum with EIP-7702. A single transaction carried 50 authorizations signed for 50 different nonces. One of them matched and delegated the "Binance 14" wallet to the attacker's "sweeper" contract. Other chains saw ordinary signed transfers. Binance statement
- Bypassing approvals. Per Teng, the EIP-7702 delegation let the attacker take control of a hot wallet without going through normal approval procedures. Binance statement
- Covering tracks. Teng said a self-destruct mechanism wiped the attacker's tools and traces. Whether this was on-chain or server-side was not disclosed. Binance statement
What is EIP-7702, and how was it used here?
Some reports described EIP-7702 as a "multisig protocol"; it isn't. EIP-7702 shipped with Ethereum's Pectra upgrade in May 2025. It lets a normal wallet (an EOA) "borrow" a smart contract's code while keeping its own address, running that code as if it were its own. The goal is to give ordinary wallets smart-wallet features such as batching and gas sponsorship.
To do that, the wallet owner signs an authorization that goes inside a new "type-4" transaction:
authorization = sign(wallet_key, {
chain_id, // which chain
address, // whose contract code will run
nonce // the wallet's current nonce
})
// If the authorization is valid, the wallet's code becomes:
code(wallet) = 0xef0100 || address
From then on, every call to the wallet runs the code at address with the wallet's authority. If that contract is a sweeper that says "send everything to this address", all ETH and tokens in the wallet can leave with one call. The single 64-transfer transaction at 20:24 looks exactly like that.
The 50 nonces matter too. An authorization is only valid if it matches the wallet's nonce at that moment. On an exchange hot wallet that transacts constantly, it is hard to know in advance what the nonce will be. So the attacker appears to have obtained signatures for a whole nonce range and made sure one of them would land. In EIP-7702 an invalid authorization doesn't revert the transaction; it is simply skipped. The 49 misses cost the attacker nothing.
Inference: according to Phoenix Security's analysis, this batch pre-signing suggests the attacker had access not to the key but to a time-limited interface for requesting signatures. The signing service may have verified who sent the request without evaluating what the request did. This is an assessment; Binance has not confirmed it.
IV. On-chain evidence
I pulled the data in this section by querying a public Ethereum RPC node directly. I located the block matching 29 October 20:18 UTC (26,300,739), then scanned every type-4 transaction in the blocks that followed. The transaction targeting "Binance 14" sits in block 26,300,753.
1. The authorization transaction
- Transaction
0xad99264d5532ae0dd04b2004eebda05f25657e70dacb764f7ac8d4ccd051298b- Block / time
- 26,300,753 · 29 Oct 2026, 20:20:59 UTC
- Type
0x4(EIP-7702 set-code)- From
0x7c8601d4645b93cea45f71e118a729332e6b5ca0, the attacker's own address- To
0x28c6c06298d514db089934071355e5743bf21d60("Binance 14")- Data / value
0x· 0 ETH. Its only job is to install the delegation.- Authorizations
- 50, all
chainId = 1, all to the same address - Delegate code
0x63e842b054bd624a465454d533c33f573e9c6fae- Nonce range
- 18,914,775 – 18,914,824 (50 values)
- Gas
- limit 1,550,000 · used 1,258,562 · status: success · logs: 0
Two things stand out.
First, Binance didn't send this transaction. In EIP-7702 the party that signs the authorization and the party that submits the transaction can differ. All the attacker needed from the signing service was a bundle of 50 signed authorizations. They paid the gas from their own address and put them on-chain themselves. This transaction never appeared in Binance's normal withdrawal flow.
Second, the gas figure says exactly one authorization landed. The arithmetic:
base transaction 21,000
50 auths × 25,000 (PER_EMPTY_ACCOUNT_COST) 1,250,000
---------
1,271,000
valid auth, account already exists → refund −12,500
---------
expected 1,258,500
measured on-chain 1,258,562
EIP-7702 refunds 12,500 gas for each valid authorization whose account already exists. Invalid authorizations get no refund. Setting aside a 62-gas difference, the refund matches exactly one authorization. One of the 50 signatures matched the wallet's nonce at that moment; the other 49 were skipped.
2. The sweeper contract
The code at 0x63e842b0…6fae is 1,674 bytes. That is tiny for a full smart wallet and about right for a single-purpose tool. I scanned the bytecode for 4-byte values pushed with PUSH4:
| Selector | Meaning |
|---|---|
0x70a08231 | balanceOf(address): read a token balance |
0xa9059cbb | transfer(address,uint256): send tokens |
0x4e487b71 | Panic(uint256): Solidity's standard error, added by the compiler |
0x01e33667, 0x043ff9d2, 0x4782f779, 0x8a179be4, 0x97dc97cb and 9 more | No match in public signature databases; contract-specific functions |
The readable part fits the skeleton of a sweeper: for each token, read the balance and transfer all of it to one address. Some of the unknown selectors are contract-specific entry points; others may just be data in the bytecode that happens to look like a PUSH4.
Limitation: I did not decompile the bytecode. The selector list is a static scan; the functions' exact behaviour needs proper reverse engineering.
3. The drain
From the moment the delegation landed, every call to "Binance 14" ran the sweeper's code. According to Bitquery's trace, the main drain came three minutes later, at 20:24, in a single transaction: 64 transfers carrying 167,464 ETH, 1.6 billion USDT and 62 different tokens. The wallet was swept six more times over the next roughly 3.5 hours, because Binance's own systems kept sending funds to the address.
4. The delegation today
Today eth_getCode returns 0x for "Binance 14", so the wallet is a plain EOA again. Binance revoked the delegation at 00:10 UTC on 30 October. Under EIP-7702 that is done by the wallet signing a new authorization to the zero address (0x0000…0000). Reading the historical code during the attack (0xef0100 + 63e842b0…) needs an archive node; the free node I used doesn't serve that.
5. The Bitcoin side
Bitcoin has nothing like EIP-7702. The outflow there was an ordinary signed transaction: 18,270 BTC left the hot wallet in a single block and was split across 19 addresses. According to Elliptic, those 19 addresses haven't moved since. So the attacker got a valid signature for Bitcoin from the signing service as well. That shows the problem wasn't specific to EIP-7702; it was in the signing service itself.
V. Why couldn't it be stopped?
To me this is the most instructive part. On paper everything was in place: the keys weren't stolen, the signing system worked, approval processes existed. The problem was that three things were true at once:
- There was a standing path from a developer machine to production. A laptop could reach a service that can create withdrawal requests.
- The signing service signed non-standard requests. EIP-7702 authorizations for 50 different nonces is a request an exchange would never see in normal operations. It was signed anyway.
- Speed and multi-chain concurrency. Outflows starting on nine chains within 20 minutes left no time for human approval or manual intervention. The EIP-7702 revocation came about four hours after the first outflow.
I wrote something similar in the Liquid Network piece: an attacker usually breaks the process, not the cryptography. Here too the keys were sound; the weak link was a system that didn't question what it was signing.
VI. Where is the money now?
Short answer: most of the money still sits in addresses the attacker controls, but very little has been cashed out. What has happened over the past 17 days is not cash-out but conversion: turning freezable assets into unfreezable ones, meaning ETH and BTC. Per Elliptic's update of 13 November:
Status by asset
| Asset | Stolen | Status today |
|---|---|---|
| BTC | 18,270 BTC | In 19 addresses, never moved. On top of that, about 4,100 BTC ($285M) from laundering has accumulated in new addresses. |
| ETH | $1.16B | Only about $3M has moved. The nine largest addresses, holding 89% of the ETH, have been silent since 30 October. |
| USDT / USDC | $3.46B | Mostly frozen. About $786M was swapped into ETH and TRX before the freezes landed. |
| XRP | 233M XRP | About 8.5M XRP ($9M) left. The rest went to BTC via THORChain. |
| TRX | ~$210M | Less than $10M left. The rest was bridged to ETH. |
| SOL | ~$90M | All swapped, bridged or mixed. About 430 SOL remains. |
| NEAR | $41M | About $2M has moved in small batches. |
Frozen and seized
- Total: per Elliptic, about $2.85 billion has been frozen or seized, 44% of the haul. In the Bybit case that figure was only around 3%.
- US Department of Justice (12 November): obtained court authorization to seize or restrain more than $1.2 billion of the stolen assets. That is part of the frozen total, not on top of it. Which assets it covers has not been disclosed.
- Tether: 1.76B USDT in 11 freezes on Ethereum and TRON; six of them hit wallets that were already empty.
- Circle: 823M USDC, frozen before any of it moved.
- Others: about $132M from World Liberty Financial (USD1), Paxos, Ripple and First Digital. Binance blacklisted about $75M of its own wBETH token.
- Arbitrum Security Council: moved the attacker's ARB and ETH on Arbitrum into a locked wallet.
How are they moving it? Phase by phase
By Elliptic's count, the first two weeks involved nearly 27,000 wallets, 16 blockchains, at least 36 services and more than 83,000 transactions. That speed and scale point to a largely automated operation.
The techniques
One more detail: about $16 million went to addresses that also hold proceeds from the September 2026 Bitget hack. That suggests the two incidents share laundering infrastructure.
What comes next?
The Bybit case is the guide. Elliptic expects the dormant ETH to be converted to BTC in small transactions and cashed out through OTC brokers over months. Freezing gets much harder at that stage. BTC and ETH have no issuer; the only brake left is where this money meets cash: exchanges, brokers and payment processors. That is why adding the 600-plus addresses the FBI published to block lists is a must for every exchange.
VII. Who did it?
TRM Labs assessed with high confidence that the attack belongs to North Korea's TraderTraitor group (under the Lazarus umbrella). Chainalysis independently reached the same conclusion. Two days after the incident, the FBI, Secret Service and IRS-CI formally attributed it to TraderTraitor, published the attacker's addresses and urged the industry to block transactions from them.
TraderTraitor is a familiar name: the FBI linked the same group to the $1.5 billion Bybit hack in February 2025 and to the DMM Bitcoin case in May 2024. At Bybit, signers approved a malicious transaction because of a manipulated interface; at DMM, an employee of a vendor was targeted with a fake job offer. The common theme: the target isn't the key, it is the people and systems standing next to it.
Inference: TraderTraitor has historically targeted developers with fake job offers and trojanised tooling. It is plausible the Binance laptop was compromised the same way, but this has not been confirmed.
MITRE ATT&CK mapping
I mapped the incident to ATT&CK techniques. known marks steps disclosed by Binance or law enforcement; inferred marks my assessments based on TraderTraitor's past cases and the shape of the attack.
| Tactic | Technique | In this incident | |
|---|---|---|---|
| Initial access | T1566 Phishing / T1204 User Execution | The DevOps engineer's laptop. TraderTraitor's known method is fake job offers and trojanised tools. | inferred |
| Credential access | T1552 Unsecured Credentials | Kubeconfig, cloud tokens or SSH keys on the laptop used to reach production. | inferred |
| Lateral movement | T1021 Remote Services / T1609 Container Administration Command | Access to the service container that can create withdrawal requests. | known technique inferred |
| Defense evasion | T1078 Valid Accounts | Requests to the signing service that looked like a legitimate internal service. | inferred |
| Impact | T1657 Financial Theft | $6.3 billion out across nine chains. | known |
| Indicator removal | T1070 Indicator Removal | The mechanism Teng described that wiped tools and traces. | known |
VIII. Lessons for an exchange security team
This section combines recommendations from public analyses with my own experience.
1. The developer laptop is part of the security boundary
- Developer and DevOps machines should have no standing access to production. Access should be approval-based and time-boxed ("just-in-time"), through a hardened jump host.
- When a machine is suspected, every credential and token that machine ever touched should be rotated.
2. The signer must ask "what was requested", not only "who asked"
- Put a policy engine in front of the signing service. Reject EIP-7702 authorizations by default; reject batch requests that span a nonce range.
- Enforce rate and amount limits per chain and per wallet. Any request that doesn't fit a standard withdrawal template goes to an independent human approval.
- Split signing authority across chains and wallet tiers. No single service should be able to sign on nine chains at once.
The core of such a policy engine could look roughly like this. The key idea: the signer doesn't trust what the caller says; it looks at the data it is about to sign and re-verifies the withdrawal against its own independent record.
def evaluate(request):
tx = decode(request.payload) # what exactly are we signing?
# 1. Treasury wallets never need EIP-7702
if tx.type == 4 or request.kind == "eip7702_auth":
return DENY("7702 forbidden on treasury wallets")
# 2. Pre-signing future nonces = attack signature
if len(request.nonces) > 1 or tx.nonce != chain.nonce(request.wallet):
return DENY("nonce range / unexpected nonce")
# 3. No ledger entry, no signature
w = ledger.get(request.withdrawal_id) # separate DB, separate team
if not w or w.to != tx.to or w.amount != tx.amount:
return DENY("does not match ledger")
# 4. Anything off-template goes to humans
if not standard_template(tx):
return ESCALATE(approvers=2, reason="off-template")
# 5. Sliding-window limits
if window_sum(request.wallet, "10m") + tx.usd > limit[request.wallet]:
return ESCALATE(approvers=2, reason="amount limit")
return ALLOW
3. Detect in minutes, stop in seconds
Three detections I would put in place. First, any interactive access to signer pods. On the runtime side, with Falco:
- rule: Exec into custody signer pod
desc: Interactive process spawned inside a signing-service container
condition: >
spawned_process and container
and k8s.ns.name = "custody-signer"
and proc.name in (sh, bash, ash, zsh, python, python3, node, curl, wget, nc)
output: >
Exec in signer pod (user=%user.name cmd=%proc.cmdline
pod=%k8s.pod.name image=%container.image.repository)
priority: CRITICAL
tags: [custody, mitre_t1609]
And on the control-plane side, the same thing in the Kubernetes audit log, as a Sigma rule:
title: Exec or attach into custody signer pod
logsource:
product: kubernetes
service: audit
detection:
selection:
verb: create
objectRef.resource: pods
objectRef.subresource: [exec, attach, portforward]
objectRef.namespace: custody-signer
condition: selection
level: critical
tags: [attack.execution, attack.t1609]
Second, a circuit breaker for multi-chain signing bursts. On this day nine chains started signing within 20 minutes; under normal operations that never happens:
# Sliding 5-minute window over the signing-service log
w = signatures.last("5m")
chains = distinct(w.chain)
drain_ratio = sum(w.usd) / hot_balance_usd(chains)
if len(chains) >= 3 and drain_ratio > 0.10:
breaker.trip(scope="all_hot_wallets") # stop signing, require humans
page(oncall, sev=1)
Third, continuous EIP-7702 monitoring on treasury wallets. Checking eth_getCode alone tells you after the fact; recovering the signer of every authorization in every type-4 transaction tells you the moment the delegation hits the chain. With viem:
import { createPublicClient, webSocket, recoverAuthorizationAddress } from "viem";
import { mainnet } from "viem/chains";
const HOT = new Set(["0x28c6c06298d514db089934071355e5743bf21d60" /* , ... */]);
const client = createPublicClient({ chain: mainnet, transport: webSocket(WS_URL) });
client.watchBlocks({
includeTransactions: true,
onBlock: async (block) => {
// 1. Was a 7702 authorization signed by one of our wallets in this block?
for (const tx of block.transactions) {
if (tx.type !== "eip7702") continue;
for (const auth of tx.authorizationList) {
const authority = (await recoverAuthorizationAddress({ authorization: auth })).toLowerCase();
if (HOT.has(authority)) {
alarm("7702 authorization on-chain", { authority, delegate: auth.address, tx: tx.hash, nonce: auth.nonce });
}
}
}
// 2. Does any of our wallets currently carry a delegation designator?
for (const w of HOT) {
const code = await client.getCode({ address: w });
if (code?.toLowerCase().startsWith("0xef0100")) {
alarm("wallet delegated", { wallet: w, delegate: "0x" + code.slice(8, 48) });
}
}
},
});
- Have a pre-approved procedure to take back a delegated wallet: an authorization to the zero address, ready to sign within minutes. At Binance that revocation took about four hours.
4. Keep only what you need in the hot wallet
- Hot-wallet balances should be capped at what the next withdrawal window needs. That 18,270 BTC could leave in a single Bitcoin block shows how much value was sitting hot.
IX. Conclusion
The day after the incident, Binance announced it would cover all losses. Within days it said it had replenished about 98% of the affected tokens from its SAFU fund, futures insurance fund, Bitcoin reserve and corporate treasury, reopened withdrawals from 1 November and published a proof-of-reserves snapshot. For users, the story closed relatively fast. For the industry, it is only starting.
What this incident shows: protecting private keys very well is no longer enough. Every system that uses the key, every machine that can reach that system and every person using that machine is part of the security boundary. Attackers aren't looking for the key; they're looking for the chain that decides what the key signs.