Skip to content
← Intel Brief
Intel Brief

The Signing Service Is the Wallet

Binance paused withdrawals. A delegation its own signer had already signed kept working for hours. A field note on signing-service authority, EIP-7702 and kill switches that stop the wrong layer.

AN3 Intel Brief cover with the headline The Signing Service Is the Wallet
AN3 · Offensive Research · · 11 min read

Most exchange security reviews treat the withdrawal pipeline as the control.

Risk engines, velocity limits, address allowlists and manual approval queues all sit there. That is where teams put their policy, their alerting and their audit evidence. It is also, on Binance's own account of 29 October, the layer the attacker never needed.

In its initial findings, published on 3 November, Binance says the attacker "exploited unauthorized access to an internal wallet signing service to initiate transactions outside the normal withdrawal process." The signer did what signers do. It produced valid signatures. The withdrawal controls were never asked.

If something other than your withdrawal service can become a client of your signer, your withdrawal policy is a suggestion. The signing service is the wallet.

This note is for teams that run exchange hot wallets, MPC custody, treasury signers or any internal service that turns a request into a signature. It is not a forensic report and it is not legal advice. Binance calls its document an initial report, says the investigation is ongoing, and says findings will be subject to independent review. We treat it that way.

What Binance says happened

All figures below are Binance's own, from the 3 November report, unless marked otherwise.

  • Approximately USD 6.34 billion in digital assets were impacted. About USD 2.85 billion had been frozen or intercepted, "subject to reconciliation and market price volatility."
  • Between 20:05 and 20:09 UTC, five hot wallets sent 233.46 million XRP to an attacker-controlled address.
  • Hot wallets on Solana and Optimism sent approximately 970,500 SOL and 44.2 million OP. Binance then received an internal alert on large-volume transfers.
  • A hot wallet sent 18,270 BTC to an attacker-controlled address.
  • The attacker then used the signing service to obtain EIP-7702 authorisations, giving an attacker-controlled contract what Binance calls "partial execution rights" over a hot wallet. Binance says the attackers "submitted 50 signing transactions to manipulate the account nonce and establish malicious delegation authorizations."
  • Suspending withdrawals did not stop those authorisations, because they "existed on-chain and operated independently of Binance's normal withdrawal infrastructure."
  • Because the hot wallet used MPC, there was "no single private key" to revoke the delegation immediately. The team built and ran a specialised procedure, which took extra time.
  • The final unauthorised transfer, 2,961.9 ETH, finalised at 23:56 UTC. It had been broadcast earlier and sat pending.
  • At 00:10 UTC on 30 October, Binance signed a new authorisation from the Binance14 hot wallet to the zero address, clearing the delegation code.

Binance says it will absorb the loss and that 98% of impacted token assets had been replenished as of 31 October. It cites the FBI in attributing the attack to the DPRK. The Block reported that the FBI alert of 31 October names the TraderTraitor group, and described the theft as the largest crypto hack on record.

Not every number lines up across sources. An independent reading of the report notes that Elliptic counts US$6.43 billion stolen against Binance's US$6.34 billion, and that the 98% replenishment figure comes with no per-token breakdown. We use Binance's figures and flag them as company-reported.

On the intrusion path

The report also describes a multi-stage campaign before the 29 October outflows. A tampered Homebrew install in June. A fake recruitment interview in September that put malware on an engineer's work computer. An internal AI tool used on 20 October to take control of two wallet engineers' machines. A container deployed on 29 October using stolen credentials. TechCrunch and The Block carry the same account.

Early reporting compressed this into a single compromised DevOps laptop. Binance's report shows that was incomplete, and the report itself still leaves gaps. The 29 October login window (17:15 to 19:56) has no stated timezone. The report does not give the scope or lifetime of the deployment token, or explain how a deployed container became a valid caller of the signing service. TechCrunch says Binance did not answer its questions on device controls or earlier third-party audits.

So we do not hang this analysis on the endpoint story. Phishing, malware and stolen tokens are the entry. They will keep changing. What decided the size of the loss is what that foothold was allowed to ask for, and what still worked after the operators hit stop.

What the chain shows

Some of this can be checked on-chain. The independent reading linked above went through Etherscan:

  • One type-4 (EIP-7702) transaction at 20:20:59 UTC on 29 October, in block 26,300,753, was sent from an external address to the account labelled Binance 14. It carries 50 authorisation tuples pointing at one contract, with consecutive authorisation nonces. Etherscan marks only one tuple as valid.
  • A type-4 self-transaction from Binance 14 at 00:10:35 UTC on 30 October, in block 26,301,896, carries one zero-address tuple. That matches Binance's 00:10 UTC clearing time.

Our reading: that fits Binance's "50 signing transactions to manipulate the account nonce". Sign a run of nonces so that one lands, whatever the account's nonce is when the transaction is included. It is an explorer reading, not a replay. Binance has not published the signing records that would map its count to those tuples.

The gap between those two transactions is about three hours and fifty minutes. For that window, on Binance's account, the off-chain shutdown had no hold over a piece of on-chain authority that the signer had already handed out.

Bybit poisoned the screen. This went past it.

We wrote up the Bybit incident as a signing-layer attack where the UI was the exploit. Signers approved a summary that lied. Humans were in the loop, and the loop was fed false data.

Binance's account describes a different failure. It says the attacker deployed a container, "triggered a malicious script to launch the attack," and used the signing service to initiate transactions outside the normal withdrawal process. Nothing in the report describes a human being shown a fake screen. The attacker reached the component that produces signatures and asked it directly. Bybit is a perception failure at the approval step. This is an authority failure one layer below it.

Both end up in the same place. A valid signature authorised something nobody meant to authorise. But the fixes are different. Out-of-band payload checks and diverse signer stacks, which we pushed after Bybit, do nothing if the signing service will sign for a caller that never went through a human ceremony at all.

Why the pause could not stop the delegation

EIP-7702 lets an externally owned account set a delegation indicator in its own code. Once a valid authorisation is processed, calls to that account run the delegate contract's code. The delegation persists. The spec's own rationale section explains that persistent delegation was a deliberate design choice.

Three properties of the spec matter here:

  1. Persistence. The delegation stays in account state until another valid authorisation replaces or clears it. Stopping your withdrawal service changes nothing on-chain.
  2. Clearing needs a new signature. Per the spec, an authorisation to the zero address clears the code. That authorisation has to be signed by the account. For an MPC wallet, that means a quorum ceremony for a message type the team may never have produced before. That is the "specialised procedure" Binance describes.
  3. It is not a transaction. The authorisation is a signature over keccak(MAGIC || rlp([chain_id, address, nonce])). A signing policy built to parse and limit transactions (destination, value, calldata) may not recognise this as a transfer of control at all.

The spec also says that applications "must not expect" to ask users to sign authorisations, and that "it is the duty of the wallet" not to offer an interface to do so. A user wallet is supposed to refuse delegation requests by default. An internal signing service needs the same refusal, written as policy.

"Partial execution rights" is Binance's phrase. The spec has no such permission level. What a delegate can do depends on the delegate contract's code, and here the attacker wrote that code.

We are not saying EIP-7702 is broken. It did what it says. The point is that a signer which will sign delegations can hand out authority that no off-chain switch can take back.

Failure modes we keep finding

None of the following is a claim about Binance's internal design, which it has largely kept confidential. These are the patterns we look for whenever a signing service sits behind a withdrawal pipeline.

1. Policy lives in the caller, not the signer

Limits, allowlists and approval rules sit in the withdrawal service. The signer trusts whatever reaches it. Anyone who can talk to the signer directly inherits its full authority and none of its restrictions.

Audit question: if we deliver a well-formed request straight to the signer, skipping every upstream service, what stops it?

2. Callers authenticated by where they run

Network position, a shared service token, or "deployed inside the cluster" stands in for caller identity. A new workload with a valid platform credential becomes a valid client.

Binance has not said how its signer authenticated callers. That is the right question for every team reading the report. Who can become a client of your signer, and does adding a new client need its own approval?

3. Signers that sign message types they do not understand

Transfers get policy. Everything else gets signed. EIP-7702 authorisations, EIP-712 typed data, permits, Permit2 approvals, raw digests. All are valid signatures. All can move authority. Few signers allowlist them by type.

If the signer cannot decode a request into a known, permitted action, the default has to be refusal.

4. Kill switches that stop the wrong layer

Incident runbooks pause services. Attackers rely on authority that lives on-chain: delegations, token approvals, Safe modules, session keys, guardian roles. A pause stops new requests. It does not revoke what has already been signed.

Audit question: for each hot wallet, list every on-chain grant of authority it can hold, and the exact transaction that revokes each one.

5. Revocation that has never been rehearsed

Under MPC, threshold or HSM custody, the revoking signature needs the same quorum as any other. If nobody has produced a zero-address authorisation or a bulk approval revoke under that quorum, the first attempt will happen during an incident, at night, under pressure.

Measure time-to-revoke the way you measure time-to-detect.

6. One signer, every chain

Binance's account has XRP, SOL, OP, BTC and ETH all leaving through the same signing service in the same evening. When one service signs across chains with no per-chain caps or isolation, one compromised caller has the whole estate's blast radius.

Shared infrastructure is cheaper. It is also a single quorum for the attacker to beat.

7. Already-broadcast transactions

Binance's final transfer was broadcast before containment and finalised later, at 23:56 UTC. Pending transactions and pre-signed payloads are authority in flight. Containment needs a step that replaces or invalidates them: bump the nonce, send a cancel, or clear the delegation, whichever closes the path first.

The same class off-chain

Swap the hot wallet for a code-signing service, an internal certificate authority or a payment-signing HSM. The shape is the same. A release pipeline enforces review, but the signing endpoint will sign any artefact sent by a caller on the right subnet. A payments platform enforces dual control, but the HSM's API trusts the application server.

We see this in cloud and IAM reviews all the time. A service account that can call the signer is a privileged identity, whether or not anyone labelled it one.

A practical review boundary

When we scope a wallet-infrastructure engagement, the diagram does not stop at the withdrawal API:

  1. Signer caller map. Every identity, workload and network path that can submit a request to the signing service, and how each is authenticated. Adding a caller should be a reviewed change.
  2. Policy location. Which rules are enforced inside the signer, and which only upstream. Anything only upstream gets tested by going around it.
  3. Message-type allowlist. Transactions, EIP-7702 authorisations, typed data, permits, raw digests. What is permitted per wallet, and what the signer refuses by default.
  4. Per-chain isolation. Separate policy, caps and alerting per chain and per wallet, so one compromised caller cannot drain every network in one evening.
  5. On-chain authority inventory. For each hot wallet, the current delegation code, approvals and modules, watched continuously. Any change to delegation code on an exchange wallet should page someone.
  6. Revocation drill. Timed exercises producing zero-address authorisations, approval revokes and nonce-burning cancels under the real custody quorum.
  7. Endpoint-to-signer path. A red team exercise starting from a developer laptop or CI credential. The pass condition is simple: we cannot obtain a signature of any kind.
  8. Delegate contract review. If you use EIP-7702 on purpose, the delegate contract is now part of your wallet. It needs a smart contract audit, a fixed address, and upgrade controls treated like any other upgrade path.

If a row reads "the custody vendor handles that," it still decides whether your inventory moves. The human side of the quorum is covered in Signer ops beat signature schemes.

Where AN3 fits

This sits across disciplines we run as one team. Red teaming and adversary simulation against wallet infrastructure, from the endpoint to the signer. Penetration testing of the signing service's APIs and internal trust boundaries. Cloud and IAM review of the identities that can reach it. Smart contract audits of any delegate, module or wallet contract that holds authority over funds.

For UAE-regulated VASPs, the same evidence maps onto wallet and key-management testing for VARA readiness. That comes as an add-on to the offensive work, not a replacement for it.

Scoping: ops@an3.io. Live incident: ir@an3.io.

Closing note

The withdrawal pipeline is a client of the signer. It is not the control.

Teams that put policy in the signer, authenticate every caller, refuse message types they cannot decode and rehearse revocation under their real quorum will find this class before an attacker does. Teams that pause the front door and assume the vault is shut will keep learning that on-chain authority does not read the runbook.

Whoever can get a signature has the wallet.

AN3 Intel · field notes on signing-layer and custody risk.