50

authorizations in one transaction, all signed with the Binance 14 key; one matched

3 min 24 s

from the delegation landing to the call that swept the wallet

63

token contracts swept by that one call, plus the ether

3 h 50 min

the attacker's code stayed in the wallet before Binance revoked it

The access was brief. The delegation made it last.

Binance did not lose its hot wallets to a flaw in Ethereum or to EIP-7702. It lost them because, for about twenty minutes on 29 Oct 2026, something was producing valid signatures from its hot wallet keys on several chains, and the attacker knew in advance what to ask it to sign. On Bitcoin, XRP, Solana and Tron that meant ordinary transfers. On Ethereum it meant one authorization that made the wallet run the attacker's own contract, after which no further Binance signature was needed.

That is the argument of this post, and the chain carries it. The Ethereum signatures were not produced live: fifty were made about three minutes before use, for fifty consecutive nonces, and listed so that exactly one could land. Someone holding the key signs one authorization at the live nonce and broadcasts it within a second. Fifty pre-signed authorizations with a three minute lag are the mark of a signing path with latency in it. The chain cannot say whether key material left Binance. It can say the attacker's contact with the signer was short, and that the delegation made the short contact last: the wallet swept itself for the attacker three more times, Binance's own systems kept depositing into it, and the code stayed until Binance revoked it at 00:10 UTC the next morning, 3 hours and 50 minutes after it was set.

We read the Ethereum transactions from public nodes; the multi-chain picture and the dollar figures come from the analysts and outlets named in each sentence, because Binance has published no figure and no cause. Every custodian with a key in a signer behind an API has the same problem: software that signs what it is asked to sign, at a rate no human reviews. This attack did not break the key. It asked the signer fifty carefully chosen questions and got a yes.

What happened on 29 October

The first public signal was a chain watcher noticing an entire Binance wallet moving into a new address. Within the hour, The Block reported that Blockaid had counted about 3.3 billion USD of suspicious outflows from Binance hot wallets on Ethereum, Arbitrum and Avalanche. Arkham's tracker put the attacker's holdings above 5.7 billion USD and Chainalysis estimated roughly 5.9 billion USD at the time of the theft, both per CoinDesk. A CertiK engineer's tracing, published by TechFlow, totals 6.28 billion USD across eight chains, 6.07 billion of it in the first 55 minutes. The spread, 3.3 to about 6.3 billion USD, reflects which chains and prices each counter used.

The sequence that tracing lays out, in UTC, starts before Ethereum. Just after 20:04 a Binance XRP wallet sent 185 million XRP, the first of several, to a freshly created attacker account. Solana moved at 20:10, Optimism at 20:18, and at 20:20 eleven Bitcoin transactions moved 18,270 BTC in one block, largely in 1,000 BTC pieces, with Tron seconds behind. At 20:20:59 the Ethereum transaction this post is about was included, and at 20:24:23 the sweep that this post is about happened. Arbitrum and Avalanche began at 20:30.

Binance's own words were careful. At 21:24 UTC its account said it was aware of reports of a potential security issue; withdrawals were paused from about 22:15. Just after midnight UTC a co-founder posted that all deposits and withdrawals were suspended while the team ran security checks, froze funds and worked with law enforcement, that a post-mortem would follow and that Binance would cover all losses. Nobody at Binance has said how the signatures were obtained.

How one signature became a contract

EIP-7702 went live on Ethereum with the Pectra upgrade in May 2025. It lets a key-controlled account point at a contract so that any call to the account runs that contract's code as the account. The pointer is set by a type 4 transaction carrying authorizations, each a short signed statement from the account's key naming the chain, the contract and a nonce, and the specification is blunt about what it grants: the code named by an authorization has unrestricted access to the account.

Figure 01

From one signature to an empty wallet

  1. 01

    Stage //

    From 28 Oct the attacker funds a fresh address through Tornado Cash, deploys a sweeper contract, and rehearses the whole sequence on wallets of its own.

  2. 02

    Sign //

    At about 20:17 UTC something produces 50 authorizations with the Binance 14 key, each naming the attacker's contract, for 50 consecutive nonces.

  3. 03

    Install //

    At 20:20:59 a type 4 transaction from the attacker's address carries all 50. One matches the wallet's live nonce. Binance 14 now runs the attacker's code.

  4. 04

    Sweep //

    At 20:24:23 the attacker calls the wallet once. 167,464 ETH and 63 tokens, including 1.615 billion USDT, move to the attacker's collection address.

  5. 05

    Widen //

    At 20:41 the same route pulls 780 million USDC out of a separate smart wallet that accepted instructions from Binance 14.

  6. 06

    Repeat //

    The code stays. The attacker sweeps again at 21:04, 21:44 and 22:39 as deposits arrive, with no new Binance signature.

Result //

One signing act became standing control of the wallet, and of everything that took its instructions.

After step two the Binance key was never needed again.

The Ethereum numbers in stages two to five are the node's; the rehearsal and repeat-sweep timings are TechFlow's. The authorization transaction 0xad99264d: type 4, sent from the attacker's address, carrying 50 authorizations, all for chain 1, all pointing at the same contract at 0x63e842b0, all recovering to the Binance 14 key, with nonces from 18,914,775 to 18,914,824. Binance 14's transaction count stood at 18,914,808 before that block and 18,914,810 after it: one of its own transfers plus one accepted authorization. After the block the wallet's code reads 0xef0100 followed by the attacker's contract address, the delegation marker the specification defines.

The sweep is 0x53bd38b8, 3 minutes and 24 seconds later: one call to Binance 14 from the attacker's address that produced 63 token transfer events from 63 different token contracts, all to one collection address, plus the ether. The USDT line alone reads 1,615,409,498, and the wallet's ether balance went from 167,465 to 1 in that block. Binance 16 got no delegation. Twenty-four seconds after the sweep it sent 28,005 ETH to the same collection address in a plain transfer signed the ordinary way, the first of nine worth about 174 million USD by the TechFlow count. Two wallets, two methods, the same access behind both.

What the fifty nonces say about the signer

Under EIP-7702 an authorization is valid only if its nonce equals the account's nonce when the transaction is processed, and each accepted authorization moves that nonce up by one. Binance 14 sends a withdrawal every few seconds, so a signature for one nonce has a window of seconds before the wallet's own traffic walks past it.

So the attacker had 50 signed, one for each of 50 consecutive nonces, and sent them all in one transaction. Two details show how carefully it was built. First, the list is in descending order, 18,914,824 at the top and 18,914,775 at the bottom. That is the only order that burns a single nonce: ascending, the first match would have moved the nonce up and every later authorization would have matched in turn, leaving the wallet's nonce 16 higher. Descending, the authorizations above the live nonce fail, one matches, and the rest fall below it. Second, the batch was signed at a known moment. The node shows Binance 14 spending nonce 18,914,775, the lowest in the batch, in block 26300737 at 20:17:47 UTC, and the type 4 transaction landing at 20:20:59, six transactions after the wallet's own transfer in the same block. The wallet had spent 34 of the 50 nonces in those three minutes. One matched. Fifteen were still ahead, and a wallet like this can spend fifteen in one block.

The simplest reading is that the signer was asked, at about 20:17, for fifty signatures covering the next fifty nonces, and the answer could not be used until about 20:20. A key in hand does not need the margin. A mediated signing path does: a batch request to a remote signer, an exfiltration channel with a delay in it, a person relaying between two systems. The same shape appears on Binance 16 in the same minute and, per the tracing, on five other chains inside twenty minutes. The chain cannot separate the candidates: several keys exfiltrated together from one backup or key management snapshot, one operator credential that could ask every signer, or a compromised build of the software that drives the wallets, the way the Bybit theft of about 1.5 billion USD in February 2025 went through a manipulated signing interface rather than a stolen key. Analysts have floated each of these, and an insider, and none is established. What they share is the part that matters: something upstream of several keys was reachable from one position, for a short time, and it signed what it was shown.

One more thing the chain settles: the type 4 transaction carried no calldata, so the attacker could have swept in the same transaction that installed the code. The 3 minute 24 second gap was a choice, and a monitor built around it is built around a courtesy.

The freeze race, and what it could not reach

The hours after the sweep show what the industry can and cannot do once a hot wallet is gone. Stablecoins have issuers, and issuers have a blacklist function. Native coins do not.

The attacker knew this and sold first. By the TechFlow tracing, within minutes of the sweep about 435 million USDT on Ethereum and 234 million on Tron had been swapped for ether and TRX. Tether's first blacklist took effect at 21:01:35 UTC, 37 minutes after the sweep, and Circle's freeze of 823 million USDC landed at 21:04:59. Ripple, World Liberty and Paxos followed over the next hour and a half. Tether's chief executive put its total at more than 1.567 billion USDT; Circle's chief executive put its figure at more than 800 million USDC. Binance said at 23:22 UTC that the verified frozen total was 2.54 billion USD, and at 00:52 UTC on 30 Oct around 3 billion USD.

Where the money stood at about midnight UTC, per the TechFlow tracing

  • Frozen //

    about 2.8 billion USD, mostly USDT and USDC, plus RLUSD, USD1, Paxos tokens and Binance's own wrapped ether
  • Trapped //

    60 million USDT locked as Aave collateral, with the borrowed ether already out
  • Not freezable //

    18,270 BTC, about 458,770 ETH, 233.5 million XRP, 684.6 million TRX, 970,500 SOL and smaller tokens: roughly 3.27 billion USD

Those numbers are one analyst's snapshot, and frozen is not recovered: a blacklisted balance sits in the attacker's address until a court or law enforcement tells the issuer to reissue it, which takes weeks. The split is still the lesson. Roughly half of what left Binance was stablecoin, and most of that was frozen the same night because a handful of companies could act on their own ledgers. The bitcoin, the ether and the XRP have no such company. The native coin half is the real loss.

What this means for anyone who runs a signer

Strip the crypto out and the design problem is familiar. A hot wallet is a service account with signing authority, fed by software, signing at machine speed, and the policy that decides what it will sign is the only control that matters once the attacker can reach it.

If your signer accepts a hash, it has no policy. An EIP-7702 authorization is a signature over a short message that begins with the byte 0x05, followed by the chain, the contract and the nonce. A signer that builds every digest itself from a transaction it has parsed, and refuses anything it cannot classify by that leading byte, cannot produce one by accident. A signer that will sign a bare 32 byte digest on request, which is how many HSM and MPC deployments are wired so that off-chain orders and permits work, will sign an authorization without knowing it did. The rule is never to sign a digest you did not derive, and to default to no for any message type outside a short allowlist.

Hold hot balances behind on-chain policy, and ask why one key held billions. The specification refuses to delegate an account that already has ordinary contract code. Funds in a contract wallet with its own limits, allowlists and delays are outside this attack class, and a delegation of the operator key that drives it is bounded by what the contract allows per call and per day. The question after this is not whether a signer parses type 4 transactions but why roughly 3 billion USD sat behind one key-controlled address.

Alarm on a nonce you did not spend, and reconcile every signature to a broadcast. The accepted authorization moved Binance 14's nonce up by one outside the wallet's own pipeline, which should have invalidated whatever it had queued next. Instead the software re-synced from chain state and carried on: the wallet sent another 94 transactions while delegated. A nonce gap is the cheapest alarm there is, and a signer's log with fifty signatures at 20:17 and no matching broadcasts is the detection the post-mortem will find.

Watch your addresses for a change of code, and know what the alert buys. For a key-controlled address any code is a delegation; for a contract wallet the check is a change from the known code hash. Parsing each block's type 4 transactions for your addresses is a block earlier than polling. What this buys is not the first sweep, which can ride in the same transaction as the delegation. It buys the repeat sweeps, the inflow shutoff and the revocation.

Stop the inflows, close the signing path, then revoke. Binance kept depositing into the compromised address: 200.4 million USDT arrived and was swept at 21:44, 80 minutes after the first sweep. Revoking a delegation is an authorization to the zero address signed by the same key, the type 4 transaction the policy above now refuses, so the runbook needs a break-glass path. On a busy wallet the practical form is what Binance eventually sent: a type 4 transaction from the wallet itself, with the authorization's nonce one above the transaction's. Binance 14 sent it at 00:10:35 UTC on 30 Oct, 3 hours and 50 minutes after the delegation landed. Revoking while the attacker still has the signing path only invites a second delegation, which is why it comes last.

What the address controls, the delegation controls. The 780 million USDC at 20:41 sat in a separate contract wallet that took instructions from Binance 14's address; the delegation removed the need for a signature per call. The subtler breakage: code that checks whether a caller is a plain account, by code size or against the transaction origin, now passes a delegated attacker one way and would reject the real Binance 14 the other.

On a sanctioned engagement this is the work we do against custody systems. We start from the signing pipeline rather than the key: who and what can submit a signing request, what the policy engine parses, and whether a well formed but wrong request is refused or signed. Then we test what one signature is worth and how fast the team can stop inflows and clear a delegation they did not set. The finding is rarely the key. It is the thing that asks the key.

What is still coming

The post-mortem is the next real event. Binance owes the industry two answers: how the signatures were obtained, and what was shared between the chains that were hit. If the first answer is a manipulated signing interface, this is Bybit again at two to four times the size. If it is exfiltrated keys, the timing says something upstream of several of them was reachable from one position.

Attribution will follow the money. Blockaid's chief executive and an on-chain investigator both pointed to North Korea on the night, per CoinDesk, and the rehearsals, the mixer funding and the speed of the selling fit the pattern analysts associate with its operators. No agency has said so.

EIP-7702 is not going away, and it should not. It gives ordinary accounts batching, gas sponsorship and recovery features smart wallets have had for years. It also created a new exposure the specification itself describes: a delegate has unrestricted access to the account, so any signature from a key is now potentially a reprogramming of the account, not just a spend. This is the largest case we know of against a custodian, and the same move works against any hot wallet whose signer does not know what the 0x05 byte means.

What to do today

  1. Never sign a digest you did not derive. Build every digest from a parsed transaction, classify by the leading byte, and refuse unknown message types by default.

  2. Move hot balances behind on-chain policy. A contract wallet with limits and delays cannot be delegated, and it caps what one signature is worth.

  3. Alarm on a nonce gap and reconcile signatures to broadcasts. A nonce your pipeline did not spend, or a signature with no matching transaction, is the earliest signal this attack leaves.

  4. Watch every controlled address for a code change. Parse each block's type 4 transactions for your addresses, and page whoever can stop inflows and revoke.

  5. Write the runbook in this order: stop inflows, close the signing path, revoke. Rehearse the self-sponsored revocation on a test wallet, with a break-glass path through the policy that otherwise refuses authorizations.

  6. Pre-arrange the freeze and the deposit blocks. The issuers moved within an hour because they could be reached; the attacker's exit is other exchanges, so arrange peer deposit blocking the same way.