On this page

Binance Hot-Wallet Heist (October 2026)

On 29 October 2026, starting at about 20:05 UTC, roughly USD 6.3 billion in crypto assets left Binance's hot wallets across ten or eleven blockchains, most of it in about 20 minutes. Blockchain analytics firms TRM Labs, Chainalysis and Elliptic attributed the theft to TraderTraitor, the North Korean state-backed unit the FBI had already blamed for the USD 1.5 billion Bybit hack of February 2025. Elliptic reports that the FBI made the same attribution for Binance on 31 October. It is the largest theft of crypto assets on record, and Elliptic calls it "almost certainly the single largest-known theft of any kind".

No cryptography was broken. On 3 November Binance said the attack was "not a single isolated breach or a simple phishing incident". It was a campaign that started in June: a trojanized Homebrew installer on one wallet engineer's laptop, a fake job interview and coding "assignment" for a second engineer, an internal AI tool used to reach a third, a container-deployment token left on a laptop, and finally unauthorized access to Binance's own wallet signing service. That service then signed exactly what the attacker asked for. On Ethereum this included 50 EIP-7702 delegation authorizations, which handed a hot wallet's execution rights to an attacker contract. Because that delegation lived on-chain, pausing withdrawals at Binance did not stop it.

This page is about an incident that is eleven days old

Binance published its initial findings on 3 November 2026. A full root cause has not been published, and an independent review is still under way. This page separates what is confirmed by Binance, what is reported by analytics firms or the press, and what is unknown. Figures differ between sources, and the differences are shown rather than smoothed over. Expect this page to change.

TL;DR

When29 Oct 2026, ~20:05 UTC to 23:56 UTC (last unauthorized transfer settled). Delegation revoked 30 Oct ~00:10 UTC
What~USD 6.3B drained from Binance hot wallets. Binance: ~USD 6.34B. TRM: ~USD 6.36B on 10 chains. Elliptic: ~USD 6.43B on 11 chains
WhoTraderTraitor (DPRK), per TRM, Chainalysis and Elliptic. Elliptic reports the FBI attributed it on 31 Oct. North Korea denied involvement on 3 Nov
How (confirmed by Binance)Trojanized Homebrew (June) → fake job interview with a malicious "assignment" repo (September) → internal AI tool used to take over two wallet engineers' devices (20 Oct) → stolen container-deploy token → malicious container → unauthorized use of the internal wallet signing service (29 Oct)
On-chain trickOn Ethereum, 50 pre-signed EIP-7702 authorizations covering consecutive nonces delegated hot wallet "Binance 14" to an attacker sweeper contract
Why the pause did not helpThe delegation was on-chain and "operated independently of Binance's normal withdrawal infrastructure". The wallet used MPC, so there was no single key to sign a quick revocation
Frozen~USD 2.7B (TRM) to ~2.85B (Binance, Elliptic), almost all stablecoins (Tether, Circle, Ripple, World Liberty Financial, plus Arbitrum Security Council)
Customer impactBinance covered losses from its own funds and reported 98% of affected tokens replenished by 31 Oct. Withdrawals began reopening 1 Nov
Core lessonA signing service that signs whatever an authenticated internal caller asks is a single point of compromise. Policy has to live inside the signer, check the intent of each transaction, and cap how much any hot path can lose

The Alert

The first public signals came from the chain, not from Binance. Analytics firms watching labelled Binance hot wallets saw five XRP Ledger wallets empty to a single address between 20:05 and 20:09 UTC, followed within minutes by Solana, Optimism, Bitcoin and Tron (TRM Labs).

Binance's own report says that after the Solana and Optimism outflows, "an internal alert triggered an investigation" (Binance, 3 Nov). The report does not say exactly when that alert fired or which control raised it.

The first external containment came from stablecoin issuers. Tether froze about 971M USDT at 21:01 UTC, 37 minutes after the main Ethereum sweep, and Circle froze 823M USDC at 21:04 UTC (TRM; CNBC, 29 Oct).

What made this terrifying

Binance did the "right" thing early: it suspended withdrawals. But on Ethereum, the attacker no longer needed Binance's withdrawal system. The hot wallet had already delegated its execution to the attacker's contract on-chain, so every new deposit that landed in it could be swept again. Re-sweeps continued until 23:56 UTC, almost four hours after the first transfer (Binance; TRM).

Impact

Stolen amounts

The headline number depends on who is counting and when.

SourceTotalChainsNotes
Binance (3 Nov report)~USD 6.34Bnot stated"affected" assets (Binance)
TRM Labs~USD 6.36B10Valued at time of theft, data cut-off 30 Oct 00:30 UTC (TRM)
Elliptic~USD 6.43B11 (adds NEAR)Excludes USD 169M that appeared to be Binance moving its own funds (Elliptic)
Press (CNBC, NPR, PBS, CNN)~USD 6.3BRounded Binance figure

Per-chain breakdown from TRM, valued at the time of the theft:

ChainAssets~USD
Ethereum200,630 ETH plus 185 tokens, including 1.875B USDT, 823M USDC, 88.5M RLUSD3.79B
Bitcoin18,270 BTC1.47B
Tron612.7M USDT + 46.4M TRX628M
XRP Ledger233.46M XRP296M
Solana970,500 SOL96M
Arbitrum, Optimism, Baseincluding 74.6M ARB39M
Avalanche28M
Polygon10M

The largest single transfer was about USD 2.53B, out of Binance 14 at 20:24 UTC (Elliptic).

Frozen and recovered

PartyFrozen or movedSource
Tether~1.77B USDT across Ethereum, Tron, Avalanche, PolygonTRM
Circle~825M USDCTRM
Ripple40.5M RLUSD verified on-chain. Binance co-founder Yi He's figure of about USD 200M stopped was not confirmed by TRMTRM
World Liberty Financial27.8M USD1TRM
Arbitrum Security Council~USD 30M (8,426 ETH + 74.6M ARB) forcibly moved at 00:08 UTC on 30 OctTRM
Optimism governanceappears to have moved 44M OP (~USD 5M) on 31 OctElliptic

Totals: ~USD 2.7B (TRM), ~2.8B (Chainalysis, as reported by Wikipedia and press), ~2.85B (Binance's 3 Nov report and Elliptic), ~3B (Binance's earlier estimate). Stablecoins made up about 94% of what was frozen (Elliptic). Bitcoin and ether cannot be frozen by an issuer, and TRM put the attacker's unfrozen ETH and BTC at about USD 2.4B on 3 November (TRM update).

Customers and markets

  • Binance said users would not bear the loss. It reserved more than USD 6.34B of company funds, drawing on its Secure Asset Fund for Users (SAFU), insurance fund, Bitcoin reserve and corporate treasury, and said 98% of affected tokens were replenished by 31 October (Binance; PBS).
  • Withdrawals were suspended on 29 October and began reopening at 06:00 UTC on 1 November, Bitcoin first (Elliptic). Deposits were not affected (PBS).
  • Within roughly nine hours of reopening, CNBC reported about USD 3.64B of net outflows (CNBC, 2 Nov).
  • Bitcoin fell about 5% after the theft was confirmed, according to Wikipedia's summary of contemporaneous reporting (Wikipedia).

Timeline

All times UTC. Where sources disagree, both are given.

Date / timeEventSource
June 2026Wallet DevOps Engineer A searches for a popular AI coding tool and installs it with a tampered Homebrew installer. Binance detects it, replaces the device and rotates credentials, but the engineer's role and wallet-team colleagues are already exposed to the attackerBinance, CNBC
2026, before the theftBinance says it detected and blocked 57 suspected DPRK-linked threat cases during the yearBinance
September 2026Engineer B is approached on a legitimate job-hunting platform by a fake "Project Director". Two interview rounds follow (a fake HR video call, then a chat-app call with the "CEO" of a fictitious company). He is told to download a coding "assignment" onto his work computer. The repository runs malware during setup that replaces a legitimate Python version-manager component and contacts an attacker server. Binance says it was not detected by endpoint tools at the timeBinance, The Hacker News, SecurityWeek
20 Oct 2026Using Engineer B's machine and an internal AI tool, the attacker gains control of Engineer A's and Wallet Software Engineer C's devices, and finds a container-deployment permission token on Engineer A's computerBinance
28 Oct, morningAttacker operator wallet funded with three small Tornado Cash withdrawals (Elliptic: three 0.1 ETH withdrawals)TRM, Elliptic
29 Oct, earlyAttack contract deployed and tested on two wallets, then rehearsed on a thirdTRM
29 Oct, 15:59Sweeper contract deployedElliptic
29 Oct, 17:15–19:56Attacker logs into Engineer C's computer, uses Engineer A's stolen credentials to deploy a container and run a malicious script, then abuses the internal wallet signing serviceBinance
29 Oct, 20:05–20:09Five XRP Ledger hot wallets send 233.46M XRP to one attacker addressTRM, Binance
29 Oct, ~20:10Solana and Optimism hot wallets drained. Binance: an internal alert triggers an investigationTRM, Binance
29 Oct, 20:2018,270 BTC leaves a Bitcoin hot wallet and is split into a peel chain in the same block. Chainalysis puts the start of the theft "around 8:20 p.m. UTC"TRM, Wikipedia
29 Oct, 20:20One Ethereum transaction carries 50 EIP-7702 authorizations, each signed by hot wallet Binance 14 for a different nonce, all pointing at the sweeperTRM, Elliptic
29 Oct, ~20:22Tron hot wallet sends 612.7M USDT and 46.4M TRXTRM
29 Oct, ~20:24Main sweep: 167,464 ETH and 63 tokens including 1.615B USDT. Single ~USD 2.53B transferTRM, Elliptic
29 Oct, 21:01Tether freezes ~971M USDTTRM
29 Oct, 21:04Circle freezes 823M USDC, in coordination with law enforcementTRM
29 Oct, 20:41 to 23:56Re-sweeps of new deposits into Binance 14 at 20:41, 20:59, 21:04, 21:44, 22:39 and 23:56TRM
29 Oct, 22:01 / 22:10Ripple freezes RLUSD; World Liberty Financial freezes USD1TRM
29 Oct, ~23:05Second wave against Avalanche and Polygon walletsTRM, Elliptic
29 Oct, 23:35Binance reports USD 2.54B verified frozenTRM
29 Oct, 23:56Last unauthorized transfer (2,961.9 ETH) settles. It had been broadcast earlier and was still pendingBinance
30 Oct, 00:08Arbitrum Security Council forces two transfers out of an attacker wallet (~USD 30M)TRM
30 Oct, ~00:10Binance clears the Binance 14 EIP-7702 delegation by authorizing the zero addressBinance
30 Oct, 04:30Chainalysis publicly attributes the theft to DPRKreported by DailyCoin and others; the Chainalysis post itself was not located
30 OctCo-CEO Richard Teng posts a ~5-minute video: Binance's own hot wallet was hit, the EIP-7702 delegation "did not pass through our normal approval controls", the attack was "not carried out by one person" and used a "self-destruct mechanism"Richard Teng on X, PBS
31 Oct, 23:55FBI attributes the theft to TraderTraitor, per Elliptic. Wikipedia cites an FBI alert titled "North Korea Responsible for $6 Billion+ Binance Attack"Elliptic, FBI
31 OctBinance: 98% of affected token assets replenishedBinance
1 Nov, 06:00Withdrawals begin reopening, Bitcoin firstElliptic
3 NovBinance publishes its initial incident report. North Korea's Kim Yo Jong denies involvement via KCNABinance, Wikipedia
3 NovTRM publishes laundering update: self-minted tokens and chained bridgesTRM update

Disputed or unclear points

  • Attribution by government. Elliptic dates the FBI attribution to 31 October and Wikipedia cites the FBI alert. TRM's 3 November update says "no government has attributed the theft". The FBI page returned HTTP 403 when we tried to fetch it, so we could not read it directly.
  • Number of chains. TRM counts 10; Elliptic counts 11 because it includes NEAR.
  • Start time. TRM and Binance: 20:05 UTC (XRP). Chainalysis: ~20:20 UTC (when ETH and BTC moved).
  • The developer-tool component. Binance's report names pyenv. Some coverage writes "pvenv", which looks like a typo.
  • How the AI tool was used. Binance says the attacker used "an internal AI tool" to take over two engineers' devices but does not explain how. Neither do any of the reports we read.
  • Early framing. Binance first said the incident "may involve a compromised DevOps engineer's laptop" and that it had found "no evidence of any wallet private key leak" (SecurityWeek). That later grew into three compromised engineers.

Root Cause

What Binance has confirmed

Binance's 3 November report describes a people-and-infrastructure compromise. There is no claim that MPC key shares leaked or that any cryptography failed. The chain, in Binance's words and order:

flowchart TD
    A["June: Engineer A (Wallet DevOps)<br/>installs AI coding tool via<br/>tampered Homebrew installer"] --> A2["Detected: device replaced,<br/>credentials rotated"]
    A --> A3["But: A's role and wallet-team<br/>colleagues exposed to attacker"]
    A3 --> B["September: Engineer B approached<br/>on a real job platform"]
    B --> B2["Two fake interviews<br/>(HR video call, fake CEO chat)"]
    B2 --> B3["'Assignment' repo run on<br/>WORK computer"]
    B3 --> B4["Malware swaps a pyenv component,<br/>calls attacker server,<br/>evades endpoint tools"]
    B4 --> C["20 Oct: from B's machine,<br/>internal AI tool abused to take over<br/>Engineer A and Engineer C devices"]
    C --> D["Container-deploy token<br/>found on A's computer"]
    D --> E["29 Oct 17:15-19:56: on C's computer,<br/>deploy container with A's credentials,<br/>run malicious script"]
    E --> F["Unauthorized access to<br/>internal wallet signing service"]
    F --> G["Signed transfers on XRP, SOL, OP, BTC,<br/>TRX and others"]
    F --> H["50 EIP-7702 authorizations<br/>for hot wallet Binance 14"]

    style B3 fill:#ff6b6b,color:#fff
    style D fill:#ff6b6b,color:#fff
    style F fill:#ff6b6b,color:#fff

Four things stand out.

  1. The June detection worked, and still was not enough. Binance caught the trojanized Homebrew install, replaced the device and rotated credentials. But the attacker had already learned who worked on wallet infrastructure. Reconnaissance cannot be rotated away.
  2. A coding assignment ran on a work machine. This is the oldest trick in the DPRK playbook (see "Recruitment lures are a known DPRK technique" below), and it reached an engineer on the wallet team.
  3. A long-lived deploy token sat on a laptop. Once the attacker owned Engineer A's device, the container-deploy token turned "control of a laptop" into "ability to run code next to the signing service".
  4. The signing service trusted its internal callers. Once malicious code ran in a container with access to the signing service, it could ask for signatures that the normal withdrawal flow would never have produced. Teng said the EIP-7702 delegation "did not pass through our normal approval controls" (Teng).

What analytics firms inferred before Binance spoke

Before Binance's report, TRM reasoned from the chain alone. Phishing a single Ethereum key could explain the Ethereum leg, but it "leaves the other chains unexplained": different chains, key types and signing schemes all produced valid signatures for the attacker within about half an hour. TRM's conclusion was that the attacker "gained the ability to make Binance's hot wallet signing system sign transactions of its choosing across chains" (TRM). Binance's later report is consistent with that: the attacker had "unauthorized access to an internal wallet signing service".

TRM also read something from the batch of 50 authorizations: signing them all at once in advance "suggests the access may have been time-limited, or that signatures had to be requested through a system". That is an inference, not a confirmed fact.

The EIP-7702 leg: why a withdrawal freeze could not stop it

EIP-7702, activated in Ethereum's Pectra upgrade in 2025, lets an ordinary externally owned account (EOA) sign an authorization that sets its code to a delegation designator pointing at a smart contract. After that, calls to the EOA run the contract's code in the EOA's context. The authorization includes the chain ID, the contract address and the EOA's nonce, so it is only valid at one nonce.

Binance 14 was a busy hot wallet whose nonce kept moving. According to TRM and Elliptic, the attacker obtained 50 authorizations, each for a consecutive nonce, all pointing at the attacker's sweeper contract. They were submitted in one transaction at 20:20 UTC. "One matched, which was all the attacker needed" (TRM). Binance's report describes this as 50 signed transactions used "to manipulate account nonces and establish malicious delegations".

sequenceDiagram
    participant Atk as Attacker container
    participant Sig as Binance signing service (MPC)
    participant Op as Attacker operator wallet
    participant ETH as Ethereum
    participant B14 as Hot wallet Binance 14
    participant Sw as Attacker sweeper contract

    Atk->>Sig: Request 50 EIP-7702 authorizations, nonces N to N+49
    Sig-->>Atk: 50 valid signatures (no intent check)
    Op->>ETH: 20:20 UTC - one tx carrying all 50 authorizations
    ETH->>B14: Matching nonce applies - code set to delegate to sweeper
    Op->>B14: ~20:24 - call sweep
    B14->>Sw: Runs sweeper code as Binance 14
    Sw-->>Op: 167,464 ETH, 63 tokens incl. 1.615B USDT
    Note over Sig: Binance pauses withdrawals - irrelevant to the delegation
    Op->>B14: Re-sweeps of new deposits until 23:56
    Sig->>ETH: ~00:10 30 Oct - Binance authorizes zero address, delegation cleared

Binance's report gives two reasons why the usual "kill switch" did not work:

  • The authorizations "existed on-chain and operated independently of Binance's normal withdrawal infrastructure". Turning off the withdrawal pipeline does nothing to code already installed on an account.
  • The hot wallet was secured with MPC (multi-party computation), so "there was no single private key" to quickly sign a revoking authorization. The team had to build a special revocation procedure under pressure (Binance; SecurityWeek).

Binance 14 also acted as an executor or owner of another Binance smart account, which let the attacker pull 823M USDC from it; Circle froze that (TRM; Elliptic). A second Ethereum hot wallet, Binance 16, sent 28,006 ETH and other tokens through ordinary signed transfers.

Correction to a common description

Teng's video called EIP-7702 "a known multi-signature protocol". It is not a multisig scheme. It is an account-delegation mechanism. The point that matters is the same either way: a signature from the hot wallet was enough to hand its execution to someone else.

What is still unknown

flowchart LR
    subgraph known["Confirmed by Binance"]
        K1["Homebrew trojan, June"]
        K2["Fake interview + assignment, Sept"]
        K3["Internal AI tool abused, 20 Oct"]
        K4["Deploy token on laptop"]
        K5["Malicious container, 29 Oct"]
        K6["Signing service abused"]
        K7["EIP-7702 x50 on Binance 14"]
    end
    subgraph unknown["Not public as of 9 Nov 2026"]
        U1["HOW the AI tool gave device control"]
        U2["What the signing service checked, if anything"]
        U3["Why one container could reach it"]
        U4["Why hot wallets held ~USD 6B"]
        U5["When and how the internal alert fired"]
        U6["Name of the trojanized AI coding tool"]
    end
    K3 -.-> U1
    K6 -.-> U2
    K5 -.-> U3
    K6 -.-> U4

Binance has said an independent third-party review is under way. Until it is published, any detailed account of the signing service's internals, the AI tool's role or the network path from the container to the signer is speculation. This page does not guess.

How the Funds Moved

The laundering matters to engineers because it shows how fast the window for freezing closes.

  • Racing the freeze. TRM saw about 325M USDT sold to fillers and market makers via UniswapX and intent-based contracts at an implied price more than 10% worse than market, and 60M USDT supplied to Aave to borrow about 19,760 ETH. The attacker was paying a large discount to turn freezable stablecoins into unfreezable ETH (TRM). Joe Hancock of Mishcon de Reya told CNBC: "The attackers knew that route would be closed to them and so got out ahead of that" (CNBC).
  • Automation. Chainalysis CEO Jonathan Levin described "laundering patterns we have not seen before", with funds repeatedly circulated among addresses. Elliptic counted 1,113 TRX transfers with a median gap of 90 seconds, tokens sold in slices of 89 to 94 pieces, and new selling wallets each funded with exactly 0.5 ETH (CNBC; Elliptic).
  • Breaking the trace. TRM's 3 November update describes a self-minted token whose pool linked buyer and seller wallets with no direct transfer between them, lending receipt tokens passed between wallets, and chained bridge deposits that skip the intermediate wallet where an alert or freeze would normally land (TRM update).
  • Links to earlier thefts. Chainalysis and Elliptic both saw Binance proceeds commingle with funds from the September 2026 Bitget exploit, which had already been tied to North Korea (SecurityWeek; Elliptic).

Detection

What caught it, and what did not:

SignalCaught?What happened
Trojanized Homebrew install (June)YesBinance detected it, replaced the device and rotated credentials
Malicious "assignment" repo (September)No"The 0-day malware was not detected by the endpoint security protection tools at the time" (SecurityWeek)
Lateral movement via internal AI tool (20 Oct)Not reportedNothing in the report says this was flagged
Container deployed with another engineer's token from a third engineer's machine (29 Oct)Not reportedA deploy by A's identity from C's device is the kind of mismatch device-bound credentials would block
Hot-wallet outflows (20:05 onward)Yes, after the factInternal alert after the Solana and Optimism outflows
EIP-7702 delegation on a Binance-owned EOANot reportedTRM: delegation shows up as "code at an address that should have none"

The pattern is familiar from the Axios compromise, which the same broad DPRK ecosystem has been linked to: the first stage was caught, the attacker kept the reconnaissance, and the second stage got through.

Response and Remediation

From Binance's report and statements:

Containment (29–30 Oct)

  • Suspended withdrawals on affected networks, then broadly.
  • Coordinated freezes with Tether, Circle, Ripple and others. First freezes landed about an hour after the first outflow.
  • Built and executed a revocation of the EIP-7702 delegation under MPC, clearing it at ~00:10 UTC on 30 October.

Recovery (30 Oct to 3 Nov)

  • Bought back affected assets on market and over the counter. Teng said about USD 5B had been spent within a day (PBS).
  • Reopened withdrawals from 1 November and published proof of reserves.

Hardening (as of 3 Nov) (Binance; The Hacker News)

  • Rebuilt the affected wallet system in a new environment, plus the internal AI tool and its access controls.
  • Replaced affected devices and retired the engineers' credentials and tokens.
  • Ran security scans across all employee devices.
  • Strengthened behavioural anomaly detection, wallet-service risk controls and device controls.
  • Commissioned an independent third-party review.

Binance's report: "The entry points identified as having been used in the attack have been closed" and "This should not have happened".

What Would Have Prevented It

None of these is exotic. Each one breaks a link in the confirmed chain. The goal is defence in depth: assume a wallet engineer's laptop will eventually be owned, and design so that this alone cannot move billions.

flowchart LR
    L1["1. Developer endpoint<br/>no untrusted code on work devices"] --> L2["2. Credentials<br/>short-lived, device-bound deploy access"]
    L2 --> L3["3. Deploy pipeline<br/>signed images + two-person approval<br/>for signing namespace"]
    L3 --> L4["4. Signing service<br/>policy INSIDE the signer,<br/>intent checks, no raw 7702"]
    L4 --> L5["5. Treasury design<br/>small hot wallets, velocity limits,<br/>circuit breakers"]
    L5 --> L6["6. Detection + revocation<br/>delegation monitors,<br/>pre-staged revocation"]

1. Hot wallets should not be able to lose billions

Teng said the "vast majority" of user assets sit in cold wallets and move to hot wallets only for withdrawals (PBS). Even so, about USD 6B was reachable through the hot path. Why that much was in hot wallets has not been explained. The control is a hard cap per wallet, plus a warm tier that needs extra approvals, so that the worst case for a hot-path compromise is bounded and known.

# treasury-policy.yaml — illustrative tiering for a custodial exchange
tiers:
  hot:
    # Covers expected withdrawals for a short window, not total liabilities.
    max_balance_usd: 50_000_000          # per wallet, per chain
    refill_from: warm
    refill_trigger_pct: 30               # refill when below 30% of max
    signer: mpc-hot                      # automated, policy-gated
  warm:
    max_balance_usd: 500_000_000
    refill_from: cold
    signer: mpc-warm
    approvals: { required: 2, from_groups: [treasury-ops, security-oncall] }
    timelock_minutes: 30                 # cancellable delay before broadcast
  cold:
    signer: hsm-offline                  # air-gapped, ceremony-based
    approvals: { required: 3, from_groups: [treasury, security, exec] }
    timelock_hours: 24

limits:
  hot_outflow_per_10min_usd: 20_000_000  # across all hot wallets, all chains
  hot_outflow_per_hour_usd: 60_000_000
  on_breach: halt_all_hot_signing         # circuit breaker, see below

The numbers above are placeholders. Size them from your real withdrawal distribution, for example the 99.9th percentile of hourly withdrawals plus headroom. The point is that the sum across chains must be bounded, because this attack hit ten or more chains in parallel.

2. Put policy inside the signer, and check intent, not just authentication

The decisive failure was that something with access to the signing service could get signatures the withdrawal flow would never have produced. The fix is to make the signer verify what it is signing against an independent record of what the business intended, and to refuse whole classes of operations by default.

The sketch below is a policy check that runs inside the signing boundary, before any MPC round starts. It enforces four rules that each would have stopped part of this attack:

  • reject any EIP-7702 authorization that does not target an allowlisted delegate contract;
  • reject any request carrying more than one authorization or authorizations across a nonce range (TRM's indicator of compromise);
  • require that each transfer matches a withdrawal intent recorded by a separate system;
  • enforce a cross-chain velocity limit and trip a circuit breaker.
# signer_policy.py — runs inside the signing service before any MPC round.
# Defensive sketch: shows the shape of the checks, not a production signer.
from dataclasses import dataclass, field
from time import time

ALLOWED_7702_DELEGATES = {
    # Only contracts your security team has audited and pinned.
    # Empty set = no EIP-7702 authorizations at all, the safest default.
}
MAX_AUTHS_PER_REQUEST = 1
HOT_LIMIT_USD_PER_10MIN = 20_000_000

@dataclass
class SignRequest:
    chain: str
    kind: str                     # "transfer" | "eip7702_auth" | "contract_call"
    to: str = ""
    amount_usd: float = 0.0
    intent_id: str = ""           # id of the withdrawal intent in the ledger
    delegate: str = ""            # for eip7702_auth
    auth_count: int = 0

@dataclass
class Policy:
    intents: dict                 # intent_id -> (chain, to, amount_usd), from an INDEPENDENT ledger
    window: list = field(default_factory=list)   # (timestamp, usd) across ALL chains
    tripped: bool = False

    def check(self, r: SignRequest, now=None) -> str:
        now = now or time()
        if self.tripped:
            return "DENY: circuit breaker open, human reset required"
        if r.kind == "eip7702_auth":
            if r.auth_count > MAX_AUTHS_PER_REQUEST:
                return "DENY: multiple delegation authorizations (IoC)"
            if r.delegate.lower() not in ALLOWED_7702_DELEGATES:
                return "DENY: delegate not allowlisted"
        if r.kind == "transfer":
            want = self.intents.get(r.intent_id)
            if want != (r.chain, r.to.lower(), r.amount_usd):
                return "DENY: no matching withdrawal intent"
            self.window = [(t, v) for t, v in self.window if now - t < 600]
            if sum(v for _, v in self.window) + r.amount_usd > HOT_LIMIT_USD_PER_10MIN:
                self.tripped = True
                return "DENY: velocity limit, breaker tripped"
            self.window.append((now, r.amount_usd))
        if r.kind == "contract_call":
            return "DENY: arbitrary contract calls not allowed from hot tier"
        return "ALLOW"

if __name__ == "__main__":
    p = Policy(intents={"w1": ("eth", "0xuser", 1_000.0)})
    assert p.check(SignRequest("eth", "transfer", "0xUSER", 1_000.0, "w1")) == "ALLOW"
    assert p.check(SignRequest("eth", "transfer", "0xattacker", 5e8, "none")).startswith("DENY: no matching")
    assert p.check(SignRequest("eth", "eip7702_auth", delegate="0xsweeper", auth_count=50)).startswith("DENY: multiple")
    assert p.check(SignRequest("eth", "eip7702_auth", delegate="0xsweeper", auth_count=1)).startswith("DENY: delegate")
    p.intents["big"] = ("btc", "0xu2", 25_000_000.0)
    assert "breaker" in p.check(SignRequest("btc", "transfer", "0xu2", 25_000_000.0, "big"))
    assert p.check(SignRequest("eth", "transfer", "0xUSER", 1_000.0, "w1")).startswith("DENY: circuit")
    print("policy self-check passed")

Three design points matter more than the code:

  1. The intent ledger must be independent of the caller. If the same compromised container can write the intent and request the signature, the check is theatre. The withdrawal ledger should be a separate service, ideally with its own signing of intents, which the signer verifies.
  2. The policy must run inside the trust boundary of the key material (in the MPC nodes or an enclave), not in an API gateway in front of it. Each MPC party should evaluate it independently, so that compromising one node is not enough.
  3. Default deny for new transaction types. EIP-7702 support did not need to exist in a hot-wallet signer at all. Any new capability added to a signer should arrive with a policy rule and an owner.

This is the same lesson as Bybit in 2025, where Elliptic notes that "people and infrastructure were compromised, not the cryptography": a developer machine at Safe{Wallet} was breached (Elliptic). In both cases the signatures were valid. What was missing was a check that the transaction matched what the business meant to do.

3. Lock the path from a laptop to the signer

The attacker reached the signer by deploying a container with a token found on a laptop. Three controls break that link:

Short-lived, device-bound deploy credentials. No long-lived deploy token on any laptop. Use workload identity or OIDC-issued tokens valid for minutes, bound to a managed device (see Device Trust). A token stolen from A's laptop should not work from C's.

Signed images and admission control for the signing namespace. Only images built by CI and signed with the CI key may run next to the signer. A Kyverno policy:

apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: wallet-signing-signed-images-only
spec:
  validationFailureAction: Enforce
  background: false
  rules:
    - name: require-ci-signature
      match:
        any:
          - resources:
              kinds: [Pod]
              namespaces: [wallet-signing]
      verifyImages:
        - imageReferences: ["registry.internal/wallet/*"]
          attestors:
            - entries:
                - keyless:
                    issuer: "https://token.actions.githubusercontent.com"
                    subject: "https://github.com/example-org/wallet/.github/workflows/release.yml@refs/heads/main"
    - name: block-human-deployers
      match:
        any:
          - resources:
              kinds: [Pod, Deployment]
              namespaces: [wallet-signing]
      exclude:
        any:
          - subjects:
              - kind: ServiceAccount
                name: release-bot
                namespace: ci
      validate:
        message: "Only the release pipeline may deploy into wallet-signing."
        deny: {}

Network isolation for the signer. Only the withdrawal orchestrator can call it, and it can only talk to its own chain nodes.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: signer-ingress-egress
  namespace: wallet-signing
spec:
  podSelector:
    matchLabels: { app: mpc-signer }
  policyTypes: [Ingress, Egress]
  ingress:
    - from:
        - namespaceSelector: { matchLabels: { name: withdrawals } }
          podSelector: { matchLabels: { app: withdrawal-orchestrator } }
      ports: [{ port: 8443, protocol: TCP }]
  egress:
    - to:
        - podSelector: { matchLabels: { app: mpc-peer } }
    - to:
        - namespaceSelector: { matchLabels: { name: chain-nodes } }
      ports: [{ port: 8545, protocol: TCP }]
    # no default egress: no internet, no attacker C2

Binance has not said what network path its malicious container used. These controls are general, not a claim about Binance's setup.

4. Make AI tools part of the threat model

Binance says an internal AI tool was used to take over two engineers' devices, without saying how. Whatever the mechanism, the general controls are well understood:

  • Treat an internal AI agent or assistant as a privileged service account. Give it the smallest set of tools and scopes, and never a path to run commands on employee devices unless that is its explicit job.
  • Require human confirmation for any agent action that executes code, changes access or touches production.
  • Log every agent tool call with the requesting user and device, and alert when one user's session drives actions on another user's machine.
  • Do not let an agent hold or forward credentials such as deploy tokens.

See AI Safety for wider agent guardrails.

5. Recruitment lures are a known DPRK technique

Fake recruiters asking engineers to run a "take-home" repository have been a documented North Korean technique for years. Chainalysis linked more than USD 14.3M in losses over 18 months to similar fake-interview schemes before this hack (The Hacker News). For teams with access to money-moving systems:

  • Policy: never run interview or third-party code on a work device. Make it a written rule, train it, and make it easy to report a suspicious recruiter.
  • Tooling: if engineers must evaluate untrusted code, give them a disposable sandbox with no corporate network, no credentials and no clipboard sync.
# Inspect an untrusted repo in a throwaway container: no network, no host mounts
# except a read-only copy, no credentials, destroyed on exit.
docker run --rm -it \
  --network none \
  --read-only --tmpfs /tmp:rw,size=512m \
  --cap-drop ALL --security-opt no-new-privileges \
  -v "$PWD/untrusted-repo:/src:ro" \
  node:22-bookworm-slim bash
# Read the code first. If it must run, run it here, never on a work laptop,
# and never with package-manager lifecycle scripts enabled on the host.
  • Developer tooling supply chain: the June entry point was a tampered Homebrew installer found via a search engine. Distribute approved developer tools through an internal catalogue or MDM, and block installs from unknown domains on wallet-team devices.

6. Detect delegation on accounts that should have none, and pre-stage the revocation

TRM's advice to treasury teams: watch for EIP-7702 delegations, which show up as "code at an address that should have none", alert immediately, and keep a tested, pre-approved way to sign a revocation (TRM).

Per EIP-7702, a delegated EOA's code is the 23-byte designator 0xef0100 followed by the 20-byte delegate address. A monitor needs one RPC call per wallet per block:

#!/usr/bin/env bash
# delegation-watch.sh — alert if any treasury EOA has code (EIP-7702 delegation).
# Usage: RPC_URL=https://your-node ./delegation-watch.sh wallets.txt
set -euo pipefail
while read -r addr; do
  code=$(curl -s -X POST "$RPC_URL" -H 'content-type: application/json' \
    -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_getCode\",\"params\":[\"$addr\",\"latest\"]}" \
    | jq -r .result)
  if [[ "$code" != "0x" ]]; then
    delegate="0x${code:8:40}"   # strip 0x + ef0100
    echo "ALERT: $addr has code $code (delegate $delegate)" >&2
    # page security on-call and trip the hot-signing circuit breaker here
  fi
done < "$1"

The revocation matters as much as the alert. Binance had to build a revocation procedure for an MPC wallet during the incident and cleared the delegation about four hours after it was set. Prepare the revoking authorization flow in advance, rehearse it in game days, and make it a single, pre-approved runbook step that the on-call can trigger.

7. Circuit breakers that act on the chain, not just on your API

Pausing the withdrawal API stops new requests. It does not stop:

  • transactions already broadcast and pending (the last 2,961.9 ETH settled at 23:56 after being broadcast earlier);
  • on-chain delegations or approvals already granted;
  • deposits that keep landing in a compromised hot wallet and get swept again.

A complete breaker therefore also halts the signer (so nothing more can be signed), redirects deposits away from compromised addresses, sends replacement transactions for pending ones where the chain allows it, and revokes delegations and approvals. See Circuit Breaker for the general pattern.

Lessons for System Design

  1. Bound the blast radius with money, not just permissions. The most reliable control in a custodial system is a hard ceiling on what any automated path can move per unit of time, summed across every chain. Permissions fail open when an attacker becomes an insider. Ceilings do not.
  2. Authentication is not authorization of intent. The signer saw authenticated requests. It did not check that each one matched an independently recorded business intent. Two-system agreement, where one system records intent and another signs, is the same idea as request signing and maker-checker controls in payment systems (see Payment System design).
  3. New protocol features are new attack surface. EIP-7702 was a 2025 feature. A hot-wallet signer that could sign delegation authorizations, and do it 50 at a time, gained a capability nobody needed for withdrawals. Default deny.
  4. On-chain state outlives your kill switch. Plan containment for things your own infrastructure cannot recall: delegations, approvals, pending transactions.
  5. MPC protects the key, not the decision. MPC removes the single private key, which is good. But if every party signs whatever the orchestrator asks, MPC is just a very secure way to sign the attacker's transaction. Put policy in each party.
  6. Reconnaissance cannot be rotated. The June detection was handled well and still leaked the team map. Assume attackers know who your privileged engineers are, and protect those people with stricter device, network and recruitment-contact rules.
  7. Internal AI tools are privileged infrastructure. Whatever the mechanism turns out to be, an internal AI tool was a lateral-movement path into wallet engineers' devices. Scope, log and gate agents like any other service with access to employee machines. See Least Privilege.

What Would You Do?

Scenario 1: You run treasury security at an exchange. At 20:12 UTC an alert shows Solana and Optimism hot wallets emptied to unknown addresses. XRP wallets emptied seven minutes ago. Your Ethereum hot wallets look normal. Do you (A) pause withdrawals on Solana and Optimism only and investigate, (B) halt all hot-wallet signing on every chain immediately, or (C) wait for the investigation to confirm a compromise before acting, to avoid an unnecessary outage?

Best answer: (B). Several chains failing at once, each with different keys and signing schemes, points at a shared component: the signing service or its callers. TRM made exactly this inference. Halting only the affected chains (A) leaves the shared component free to sign on the next one, and at 20:20 the Ethereum and Bitcoin legs were the largest. Waiting (C) loses the minutes that matter most. Halting all hot signing costs a few hours of withdrawals. Not halting cost billions.

Scenario 2: Withdrawals are paused, but your Ethereum hot wallet is still being drained every time a deposit lands. You see it now has code: `0xef0100` followed by an unknown address. The wallet is MPC-controlled. What do you do first?

Answer: Treat it as an on-chain delegation that your pause cannot touch. In parallel: (1) redirect deposits away from that address so there is nothing new to sweep; (2) run your pre-staged revocation, which is an authorization delegating to the zero address, signed through the MPC quorum; (3) ask stablecoin issuers to freeze the attacker's receiving addresses and the compromised wallet's balances. Binance had to build step (2) during the incident and cleared the delegation about four hours after it was set. Having it ready is the difference between minutes and hours.

Scenario 3: A senior wallet engineer tells you they have a final-round interview with a promising startup, and the "CEO" wants them to clone and run a short coding assignment today. They plan to do it on their work laptop because it has the right toolchain. What is your guidance?

Answer: No interview or third-party code on a work device, ever, and especially not on a device that can reach wallet infrastructure. If they want to do the exercise, it goes in a disposable sandbox with no network and no credentials, or on a personal machine that never touches company systems. Report the recruiter to security as well. A request to run code during a final interview is a well-documented DPRK pattern, and it is exactly how Binance's Engineer B was compromised.

Key Lessons

Key Lessons

  • No cryptography was broken. People, a laptop, a deploy token and a signing service were. Valid signatures are not proof of a valid transaction.
  • Cap the hot path. If a compromise of the hot-wallet signer can lose USD 6B, the hot wallets hold too much.
  • Policy belongs inside the signer. Check each request against an independent record of intent, deny unknown transaction types, and refuse batches of delegation authorizations.
  • Your pause button does not reach the chain. Plan for delegations, approvals and pending transactions that outlive it, and pre-stage the revocation.
  • Recruitment lures work. Never run take-home code on a work machine. Use throwaway sandboxes.
  • Internal AI tools are privileged. Scope them, gate their actions and log them like any other admin path.
  • This is still developing. The independent review is pending. Revisit this page when the root cause is published.

Quiz

Quiz

Q1: Why did suspending withdrawals not stop the Ethereum losses? The attacker had obtained an EIP-7702 authorization, signed by hot wallet Binance 14, that delegated the wallet's execution to an attacker sweeper contract. That delegation existed on-chain and worked independently of Binance's withdrawal system, so the attacker could keep sweeping new deposits until Binance revoked it at about 00:10 UTC.

Q2: Why did the attacker submit 50 authorizations instead of one? An EIP-7702 authorization is valid only at one nonce of the signing account. Binance 14 was busy and its nonce kept moving, so the attacker covered 50 consecutive nonces to make sure one would match when the transaction landed. TRM recommends treating any request for many authorizations across a nonce range as an indicator of compromise.

Q3: What made revocation slow? The hot wallet was secured with MPC, so there was no single private key to quickly sign a revoking authorization. Binance had to build a revocation procedure during the incident.

Q4: Which steps in the attack chain has Binance confirmed? A trojanized Homebrew installer on Engineer A's device in June; a fake job interview with a malicious coding assignment run on Engineer B's work computer in September; use of B's machine and an internal AI tool to take over A's and C's devices on 20 October; a container-deploy token found on A's computer; and on 29 October, a container deployed from C's computer with A's credentials, leading to unauthorized use of the internal wallet signing service.

Q5: Why did most of the frozen funds turn out to be stablecoins? Stablecoin issuers like Tether and Circle can freeze tokens at specific addresses. Native assets like BTC and ETH have no issuer that can do that. This is why the attacker sold USDT at more than 10% below market and borrowed ETH against stablecoins: to convert freezable assets into unfreezable ones before the freezes landed.

Q6: What is the main architectural difference between "the signer authenticated the caller" and "the signer authorized the transaction"? Authentication proves who is asking. Authorization of intent checks that the specific transaction matches something the business independently decided to do, with limits on type, destination, amount and rate. Binance's signer accepted requests from a malicious container that had valid internal access. An intent check against an independent ledger, enforced inside each MPC party, would have refused transfers with no matching withdrawal.

One-Liner Summary

A fake job interview, a trojanized developer tool and an abused internal AI tool gave North Korean hackers a path to Binance's wallet signing service, which signed whatever they asked, including 50 on-chain delegations that kept draining a hot wallet after withdrawals were paused: USD 6.3 billion in about 20 minutes, with no cryptography broken.

Sources

Primary

Reporting