What a cryptographic break would mean for Ethereum
The second post in our series on the road to a fully post-quantum Ethereum.
In our previous post, we shared our takeaways from Devcon 8 and the Ethereum L1 R&D workshop, and why we believe Ethereum should aim for post-quantum readiness by the end of 2028.
This post looks at what makes that work necessary: what could break, what that would mean for users, applications, validators, and L2s, and why migration needs to happen before the existing cryptography fails.
Q-Day usually means the point when a quantum computer becomes capable of breaking widely used public-key cryptography. There is also a separate concern: AI-assisted mathematics could uncover attacks that weaken those systems on conventional hardware. That possibility is not a demonstrated break. Both risks, however, make it important to understand which assumptions Ethereum depends on.
The next post will focus on preparation. Here, we will explain the risks and give a brief overview of the possible responses.
The estimates are changing
Quantum hardware is only part of the picture. Researchers are also improving the algorithms that a quantum computer would run.
As we noted in our first post, research published in March 2026 by Google Quantum AI and collaborators lowered estimates of the quantum resources needed to attack elliptic-curve cryptography. Those estimates are not fixed: each algorithmic improvement brings a practical attack closer, independently of progress in hardware.
ECDSA.fail makes some of that work visible. Humans and AI agents collaborate on reducing the resources needed for elliptic-curve point addition, an important component of Shor’s algorithm. It provides a concrete example of AI-assisted research improving the building blocks of a quantum attack. [1]
ECDSA.fail: selected benchmark milestones
View the published values
| Date, 2026 | Logical qubits | Toffoli gates | Q × T (billions) |
|---|---|---|---|
| May 30, 07:41 UTC | 2,715 | 3,960,753 | 10.753 |
| May 31, 20:03 UTC | 2,310 | 3,656,039 | 8.445 |
| Jun 2, 02:17 UTC | 2,025 | 2,560,503 | 5.185 |
| Jun 2, 06:03 UTC | 1,698 | 2,447,846 | 4.156 |
| Jun 2, 10:52 UTC | 1,572 | 1,770,897 | 2.784 |
| Jun 5, 05:32 UTC | 1,394 | 1,629,451 | 2.271 |
| Jun 8, 08:59 UTC | 1,300 | 1,404,058 | 1.825 |
| Jun 19, 14:31 UTC | 1,164 | 1,413,462 | 1.645 |
| Jun 20, 10:18 UTC | 1,159 | 1,388,180 | 1.609 |
| Jun 26, 17:06 UTC | 1,152 | 1,364,230 | 1.572 |
| Jul 26, 09:19 UTC | 1,151 | 1,299,453 | 1.496 |
Ethereum’s migration needs to account for improvements in both hardware and algorithms. Today’s attack estimates may change while the ecosystem prepares.
At All Core Devs Consensus #191, Ben Edgington used a DEFCON framework to discuss urgency. Our ethrex and ethlambda teams backed DEFCON 2: urgently reprioritizing around post-quantum readiness. This was a discussion framework, not an official network alert or an agreed upgrade schedule. [3][4]
What is at risk for Ethereum?
Ethereum uses cryptography to authorize actions, coordinate validators, verify proofs, and check data. Breaking those assumptions would have different consequences in each part of the system. These attacks need not become practical at the same time.
| Where the dependency sits | What a successful attack could enable |
|---|---|
| User accounts — ECDSA | Signing transactions as the owner of an exposed key. |
| Applications — signed permissions | Forging token authorizations, orders, or other instructions accepted by contracts. |
| Consensus — BLS signatures | Impersonating validators, threatening finality, or producing slashable conflicting votes. |
| Rollups — curve-based proofs | Making a verifier accept an invalid state transition, including through a vulnerable proof wrapper. |
| Blob data — KZG commitments | Forging proofs that undermine the checks connecting data to its commitment. |
Execution: who can authorize an action?
Ethereum’s ordinary user accounts rely on ECDSA signatures. Once an account signs a transaction, its public key can be recovered from that signature. A sufficiently capable quantum attacker could then derive the private key and sign new transactions as the account owner. [5]
A hardware wallet protects a private key from being extracted from the device. It cannot prevent an attacker from deriving that key from public information. Similarly, requiring several ECDSA signatures in a multisig does not remove the underlying cryptographic vulnerability.
The exposure also extends beyond transactions. Applications use signatures for token permissions, exchange orders, bridge messages, and other instructions. Ethereum’s ecrecover precompile helps contracts identify the account behind an ECDSA signature. If those signatures become forgeable, an attacker can submit a forged instruction through their own account. Replacing the victim’s transaction-signing scheme alone would not close that route. [6]
A USDT or USDC balance held by an ECDSA-controlled account is exposed through that account. USDC’s design also includes signed permissions and transfer authorizations, with ECDSA validation for ordinary accounts and contract-based validation for supported smart wallets.
Administrative permissions matter too. Compromising an account that can mint tokens, upgrade a contract, or change an oracle can affect many users at once. The same reasoning applies to bridge signers, L2 security councils, and wallet recovery mechanisms. Existing token allowances can also expose funds if an authorized spender is compromised.
For application developers, the inventory therefore includes every key that can authorize an action, including keys that users never interact with directly.
Rollups: what proof does Ethereum actually verify?
Ethereum provides precompiles for elliptic-curve operations that applications use to verify proofs. A cryptographic break would not make those operations calculate the wrong answer. It could let an attacker construct a false proof that passes the existing checks. [7]
For a rollup, that could mean accepting an invalid state transition or withdrawal.
Using STARKs somewhere in the proving pipeline does not settle the question. Some systems wrap a STARK in a pairing-based SNARK to reduce verification costs. The Ethereum contract then verifies the wrapper, introducing an elliptic-curve dependency. [8]
Direct STARK verification can provide a post-quantum foundation with suitable constructions and parameters. A pairing-based wrapper retains the quantum vulnerability of its elliptic-curve assumptions. Neither route, by itself, addresses the rollup’s account keys, bridge permissions, or data-availability dependencies. [8]
Consensus: who can speak for a validator?
Ethereum validators use BLS signatures, and their public keys are public. If an attacker could derive the corresponding secret keys, they could forge validator messages, including block proposals and attestations.
With sufficient forged voting weight, an attacker could undermine finality. Conflicting forged messages could also satisfy the protocol’s slashing conditions, causing validators to be penalized for messages they never signed. [9]
Aggregation makes this particularly concerning. Ethereum combines signatures from multiple validators into one signature, checked against their combined public key. Recovering the secret corresponding to that aggregate public key would allow an attacker to forge a signature for the group without recovering every individual secret key. This follows from the same algebra that makes BLS aggregation possible. [10]
Conflicting aggregates could therefore implicate many validators at once.
BLS also supports randomness contributions and messages used by light clients, which follow the chain without running a full node. Those dependencies would need replacement too. [11]
Validator signing authority and withdrawal authority are separate. Breaking a validator’s signing key does not automatically let an attacker redirect its withdrawals, although the withdrawal account may have its own vulnerable authorization mechanism.
Data availability: are these the data that were committed?
Ethereum uses KZG commitments to help verify blob data. These commitments depend on elliptic-curve cryptography too.
Breaking their assumptions could allow forged proofs, undermining the relationship between the data and the commitment the chain accepted. This matters for rollups regardless of whether their execution proofs are post-quantum.
Protecting blob data therefore requires replacing KZG or using another way to publish the data. [12]
What if the break happens before migration?
The response depends heavily on the attack’s speed and cost. Recovering one key over several days creates a different emergency from recovering keys quickly enough to race pending transactions.
Bunker mode: reducing public-key exposure
Justin Drake’s bunker-mode proposal would reduce exposure by moving funds between fresh addresses whose public keys remain hidden behind a hash. Vitalik Buterin’s follow-up explores a related approach for multisigs, rotating signers’ keys after each operation. [13][14]
These approaches depend on keeping public keys hidden and limiting their exposure when signing. An address that has never sent a transaction may still have exposed its key through an offchain signature or use on another chain. Fast key recovery could also let an attacker race a pending transaction.
Bunker mode could buy time for account migration. It would not repair BLS signatures, vulnerable proof systems, or KZG commitments.
An emergency fork
Vitalik’s 2024 recovery-fork proposal considers a more disruptive response: reverting attacked blocks, disabling traditional account transactions, and letting eligible users recover control by proving knowledge of secrets that a key-recovery attack would not reveal. [5]
Eligibility would depend on how keys were generated and which secrets owners retained. Such a fork would require new software and agreement on how to handle the attacked chain. Consensus and application vulnerabilities would still need separate responses.
These are contingency proposals. A prepared migration gives the ecosystem much more control over the outcome.
Why migration has to start before a break
Migration must establish new cryptographic authority and remove the old authority before attackers can use it. Once an old signature can be forged, it can no longer reliably establish which replacement key belongs to the legitimate owner.
As we wrote in our first post, the direction discussed at the Ethereum L1 R&D workshop favors hash-based signatures. Among the schemes being developed for post-quantum Ethereum are leanXMSS for validators and leanSPHINCS for user accounts. Both rely on hash functions for security. These are concrete candidates for replacing today’s signatures, though their parameters and deployment plans remain under discussion. [15][16]
For accounts, that means supporting new signatures and retiring every route through which the old key can authorize actions. A wallet that accepts post-quantum signatures remains exposed if its ECDSA key can still move funds, replace wallet code, or authorize instructions accepted by applications.
Frame transactions, SETCODEFROM, and restrictions on ecrecover address different parts of that transition. EIP-8288 addresses the cost of larger post-quantum signatures through aggregation. These proposals remain subject to Ethereum’s upgrade process. [17][18][6][19]
In ethrex, our execution client, we implemented frame transactions early, as part of the Hegotá features we have been prototyping, and hosted a public testnet for application developers and other client teams. That work continued on the shared EthPandaOps devnet, helping test a transaction format that lets accounts adopt alternatives to ECDSA. [20][17]
Validators likewise need to associate their existing identities with replacement keys or commitments while the authorization for doing so can still be trusted. The proposed key registries aim to make that preparation possible before consensus switches. [11]
ethlambda began as a client for Lean Ethereum, built to explore post-quantum consensus. We have used it to test hash-based signatures and their aggregation in experimental networks with up to 4,096 validators. Alongside its support for today’s Beacon Chain, we will keep using ethlambda to explore new cryptography and consensus designs. [21][22]
Readiness comes before scale
Ethlabs’ pqai27 proposal distinguishes readiness from full-scale operation. Readiness means post-quantum consensus and a migration route for every account, with reduced capacity if a break forces a switch. Full-scale operation also brings efficient post-quantum transactions and blobs. Ethlabs proposes readiness in 2027, with full scale as a stretch goal. [23]
The forum discussion also calls for client hardening and qualifies its post-AI goal as plausible, rather than provable protection against unknown attacks. The timeline remains a proposal. [24]
Readiness as soon as possible
We believe Ethereum should reach readiness as early as it can. Every month without a migration route is a month in which a sudden break would leave users and validators with no safe way out. The work splits into two tracks, and both should move now.
Changes that do not require a hard fork should reach users first. A post-quantum key registry deployed as a contract lets users and operators commit to replacement keys today, while their current signatures can still be trusted to authorize that commitment. Shipping it early depends on settling two things before deployment: the shape of the contract, including what it stores and how other systems will read it, and the signature scheme, with suitable parameters. A registry built on the wrong interface or parameters would have to be redone, and every commitment made to it along with it.
Changes that require a hard fork, such as frame transactions and disabling ECDSA, belong in the next fork. That fork should be tightly scoped, so it can ship as soon as possible instead of waiting on unrelated features. In our first post, we argued that reopening a recently agreed fork scope is worth its cost; keeping the new scope tight is what lets that decision pay off quickly. Readiness needs both tracks: the registry gives users a place to commit to their new keys, and the fork lets those keys take over.
What comes next
Ethereum’s exposure extends through accounts, applications, consensus, proofs, and data availability. Each dependency needs a migration or a fallback.
Our next post will focus on preparation: what users, wallet and application developers, validator operators, and L2 teams can do today; what depends on protocol upgrades; and what changes when those upgrades arrive.
The goal is to prepare while the existing cryptography can still be trusted to authorize the transition.