Binance Hack: Key Misuse vs. Private Key Theft
Blockaid suspects Binance’s signing infrastructure may have been manipulated, not that private keys were stolen. Here’s what the evidence does—and doesn’t—show.

Binance Hack: What Key Misuse Could Mean for Exchange Security
A crypto theft doesn't always start with someone copying a private key. In some attacks, the key stays right where it's supposed to be, while a compromised device, account, or signing process gets manipulated into approving a transaction. That distinction sits at the center of Blockaid's preliminary look at the suspected Binance hack.
Blockaid CEO Ido Ben-Natan said the activity looked more consistent with misuse of transaction-signing infrastructure than with a private key being extracted. That's an assessment - not a confirmed explanation. Binance hasn't publicly laid out the attack method, and Arkham CEO Miguel Morel told Cointelegraph there wasn't enough information to tell stolen keys from compromised infrastructure. He also said the activity might still be ongoing.
The reported scale makes the distinction matter. The source report put losses at more than $2.5 billion, but the exact amount and the mechanics behind the approvals remain unconfirmed. This article breaks down what "key misuse" means, how the reported EIP-7702 activity fits into the story, why a Bybit comparison is useful (and why it's not proof), and what exchanges should investigate before drawing conclusions.
What does key misuse mean in a crypto hack?
A private key is the cryptographic "permission slip" that lets someone authorize transactions from an account. If an attacker obtains the key - or something that can be used like one - they may be able to sign transactions without the owner's consent. That's the familiar "key theft" scenario.
Key misuse is different. The secret key might never be copied or exposed. Instead, the attacker compromises or manipulates the systems and workflows around using the key. A signing service could be fed a malicious transaction request, a wallet interface could show misleading information, or an authorized user could be tricked into approving a transaction that doesn't match what they think it is.
The practical difference matters, but it doesn't make key misuse any less serious. Even a secure cryptographic system can't protect you if the surrounding process is tricked into authorizing the wrong thing. The signing system can still be "doing exactly what it was told," while the transaction it approves is malicious.
The signing chain is larger than the key
On a large exchange, transaction authorization is usually an operational workflow, not a person typing a key into a wallet. It can involve custody software, policy checks, approval interfaces, hardware security modules, employee credentials, network controls, and monitoring. The details vary across organizations.
So an investigation can't stop at "was a key exported?" It needs to trace how the transaction was created, what information the signers saw, what approvals were recorded, and whether the signed transaction aligned with the intended policy. If an attacker changed a transaction before approval, the key may never have left its protected environment.
Why the distinction matters for the response
If a key was exposed, the first priorities tend to look like containment and cleanup: revoke or replace the key, move assets, and find any copies or backups. If the signing workflow was manipulated, rotating keys alone may miss the real problem. The compromised piece could be a device, an identity credential, a transaction builder, or the approval process itself.
That's why Ben-Natan's wording matters. Blockaid said its preliminary view pointed to "key misuse" and that it didn't think a key had been leaked. But it's still a hypothesis based on early observations, not a forensic conclusion. Until Binance or independent investigators publish more details, both key theft and signing-infrastructure compromise remain plausible.
What does the reported EIP-7702 activity show?
Blockaid's onchain analysis described a transaction that bundled 50 EIP-7702 authorizations and targeted an account identified as Binance 14. Blockaid said one authorization matched the account's required nonce and was accepted. After that, the account was delegated to an unverified sweeper contract. Blockaid said this enabled a designated operator to drain tokens and Ether.
These details help explain how the onchain transaction was structured. They don't, by themselves, show how the attacker gained the ability to authorize it. Blockchain data can confirm that an authorization was accepted and assets were moved. It generally can't tell you whether a signer was deceived, whether a device was compromised, whether a credential was stolen, or whether an internal approval step failed.
What EIP-7702 does - and does not - mean
EIP-7702 lets an externally owned account delegate execution to smart-contract code. Practically, an account can enable contract-style behavior while still remaining an account that signs transactions. That can make account design more flexible, but it also means a valid delegation deserves scrutiny - the delegated code can shape what happens next.
The existence of EIP-7702 isn't evidence of a protocol flaw. And using an unverified contract doesn't automatically explain how an attacker secured authorization. The core security question is how the authorization was generated and approved - and whether signers and policy controls could identify the destination and its effects.
What onchain analysis can establish
Onchain analysis is helpful because it gives investigators a durable record of transaction order, addresses, contract interactions, and asset movements. It can help reconstruct what happened and identify flows that may be traceable. What it can't do is reveal offchain events, like a compromised workstation or a deceptive approval screen.
For now, the careful takeaway is limited: Blockaid reported a specific authorization pattern and delegation, and interpreted it as consistent with a signing-infrastructure compromise. That supports investigating the signing path. It doesn't prove the method, identify the intruder, or define the full incident scope.
How does the suspected attack compare with Bybit?
Ben-Natan described the suspected Binance activity as "very, very similar" to the February 2025 Bybit attack. In its forensic update, Bybit said attackers compromised a Safe developer's credentials, accessed the wallet provider's infrastructure, and deceived signers into approving a malicious transaction.
That comparison is useful because it points to a broader class of attacks aimed at the machinery around signing - not just direct extraction of a private key. In both cases, transaction approval and the integrity of the signing workflow are the central questions. The earlier incident becomes a relevant reference point for investigation.
But similarity isn't the same as attribution. It doesn't prove the Binance incident used the same access route, tools, operator, or organizational weakness. And a matching pattern doesn't prove the same group was behind both. A known attack can shape hypotheses, but investigators still need incident-specific evidence.
Attribution requires more than a familiar pattern
Ben-Natan said the onchain preparations resembled operations linked to North Korean cyber attackers, based on their sophistication. That's an assessment of resemblance, not a confirmation of identity. Attribution usually relies on multiple evidence streams - things like infrastructure, tactics, malware, and account activity - plus intelligence that often isn't visible onchain.
Public reporting should keep that line intact. "Resembles activity linked to" isn't the same as "was carried out by." Overstating attribution can mislead customers and organizations trying to understand their exposure, and it can also undermine trust later if the initial theory changes.
The unresolved question of an ongoing attack
Arkham CEO Miguel Morel told Cointelegraph there wasn't enough information to determine whether keys were stolen or infrastructure compromised. He also said the hack appeared to be ongoing. If that's accurate, the priority shifts from "explaining what happened" to containment and monitoring right now.
A comparison with Bybit can help investigators ask sharper questions: Were signers shown an accurate transaction? Were credentials or devices compromised? Did an attacker alter transaction data before approval? Those questions are productive. Treating the comparison as a verdict isn't. The evidence in the source report supports a working theory, not a final incident report.
What should exchanges investigate after a signing incident?
The first job is to contain risk without destroying evidence. If suspicious transfers might still be happening, the response needs to coordinate across custody, security, legal, communications, and operations. Emergency controls should also be tested against the possibility that the apparent cause is wrong. Rotating a key, for example, doesn't fix the problem if an attacker still controls the system that requests signatures.
Investigators should reconstruct the full path from transaction creation to final broadcast. That means preserving relevant logs, approval records, device telemetry, identity events, and transaction data. It also means comparing what the transaction did onchain to what each signer was shown before approving. The goal is to find where intent and execution diverged.
A practical investigation sequence
- Contain and verify. Identify affected accounts and transaction flows, pause or restrict risky signing where appropriate, and independently confirm whether suspicious activity continues.
- Preserve evidence. Secure logs and relevant system images before routine retention or cleanup removes them. Record who accessed, changed, or approved each control during the response.
- Reconstruct authorization. Trace transaction construction, policy evaluation, approval prompts, signer actions, and broadcast. Check whether the displayed destination and operation matched the signed payload.
- Test competing explanations. Look for evidence of key extraction, credential misuse, compromised endpoints, altered transaction data, and failures in approval policy. Don't assume one theory because it resembles a past incident.
- Revoke access and validate recovery. Rotate affected credentials or keys where justified, but also remediate the systems that use them. Test the revised process before restoring normal signing limits.
Controls that address the process, not just the secret
Exchanges can reduce exposure by separating transaction creation from approval, requiring independent review for high-value transfers, and forcing signers to verify meaningful transaction details - not approve opaque data. Limits, delays, and out-of-band checks add friction, but they also slow down the kind of trickery that relies on fast approvals. The right level of control depends on what's at stake and how quickly the organization can respond.
A practical test: can a single compromised device, credential, or approval interface move assets without any other independent control noticing? If the answer is yes, you have concentration risk - even if private keys are stored securely.
No control set removes every operational risk. More checks can mean more delays, more staffing demands, and new failure points. The goal isn't maximum friction. It's a signing process where a malicious request is hard to disguise, hard to approve on its own, and detectable before losses compound.
Conclusion
The most important distinction in the suspected Binance hack isn't just whether a private key was stolen. It's whether the exchange's authorization process - end to end - can be trusted, from transaction construction and policy checks to what signers actually saw and what was ultimately broadcast.
Blockaid's interpretation of the reported EIP-7702 activity makes signing infrastructure a reasonable focus for investigation. But it doesn't settle the cause. Until a forensic account clarifies how authorization was obtained, the responsible approach is to treat key theft and process compromise as competing hypotheses.
For exchanges, the operational lesson is straightforward: keep keys secure, but also secure every system and decision point that can turn those keys into signatures for the wrong transaction. A strong custody setup is only as reliable as the transaction approval path it supports.