On 6 November 2026, Google DeepMind announced that its AI agents had found two previously unknown weaknesses in legacy 1024-bit RSA. The headline numbers are dramatic: a signature-forgery method DeepMind estimates is around 1,600 times faster than the best published approach, and a batch-factoring method that cuts the cost of breaking each additional key by roughly 30 times. The DeepMind RSA 1024 announcement travelled fast, and so did the misunderstanding of it.
No, AI has not broken RSA. Your bank login, your email and your 2048-bit keys are unaffected. What actually happened is narrower, stranger and arguably more important: AI agents, guided by human cryptographers, did in weeks what normally takes years — and they did it to a key size the world was supposed to have retired a decade ago. This guide explains the DeepMind RSA 1024 findings in plain language, separates the measured results from the theoretical estimates, and sets out exactly who still needs to act.
Table of Contents
- What DeepMind Actually Announced
- RSA in 60 Seconds: Why 1024 Bits Matters
- Weakness 1: The Signature-Forgery Attack
- Weakness 2: Fan Factories and Cheaper Batch Factoring
- The Two Weaknesses Side by Side
- How the AI Agents Actually Did the Work
- What the DeepMind RSA 1024 Results Do NOT Mean
- Who Is Actually Exposed
- What to Do Now: A Practical Checklist
- The Bigger Picture: AI Is Now Doing Cryptanalysis
- Frequently Asked Questions
- The Bottom Line

What DeepMind Actually Announced
The DeepMind RSA 1024 story began on 6 November 2026, when Pushmeet Kohli, Google DeepMind’s vice president of science, published an essay titled “Advancing the frontier of cryptanalysis” and the Google DeepMind account posted the findings on X. The announcement described two results against legacy 1024-bit RSA, produced by AI agents working under the supervision of human cryptographers and completed in a matter of weeks.
The work was led inside DeepMind by researchers Dj Dvijotham and Abhradeep Thakurta, in collaboration with two of the best-known names in practical cryptanalysis: Nadia Heninger of UC San Diego and Emmanuel Thomé of Inria. That pairing matters. Heninger and Thomé are not AI researchers dabbling in cryptography; they are the people who have spent careers breaking real-world RSA deployments, and their presence is a large part of why the cryptography community took the announcement seriously rather than treating it as a publicity stunt.
The findings were written up in two working papers dated 5–6 November 2026. The first, “Modular Roots from a Restricted Oracle”, covers the signature-forgery result. The second, “Fan Factories: Multiple Number Fields in Factorization Factories and Batch NFS”, covers the batch-factoring result. Neither paper had been peer-reviewed when the announcement went out, and that fact belongs in any honest account of the DeepMind RSA 1024 results. Working papers are how fast-moving research is shared; peer review is how it is checked. Both stages matter, and this story is currently between the two.
DeepMind framed the project carefully as human-guided AI research, not autonomous discovery. The models did most of the exploratory work — searching for attack ideas, writing candidate proofs, testing implementations — while the experts chose the problems, judged which results were significant and checked the answers. Kohli’s central claim was about pace: progress of this kind has usually taken years, and the DeepMind RSA 1024 work took weeks. That claim about speed, more than either individual result, is what makes the announcement worth understanding.
It is also worth saying plainly what DeepMind did not claim. No live system was attacked. No production key was broken. The tests ran in an isolated sandbox against a benchmark key that academic researchers had already broken. And DeepMind stated, in the announcement and in the batch-factoring paper itself, that RSA-2048 and larger keys are not affected. Keep those boundaries in mind and the rest of this article will make sense.
RSA in 60 Seconds: Why 1024 Bits Matters
RSA is the public-key cryptosystem published in 1977 by Ron Rivest, Adi Shamir and Leonard Adleman, and it still underpins much of the internet’s trust infrastructure. Its security rests on a simple-sounding hard problem: given a large number that is the product of two primes, find those primes. Multiplying two 512-bit primes together is trivial for a computer. Working backwards from the 1024-bit product to the original primes — factoring — is enormously expensive. The “1024-bit” in the DeepMind RSA 1024 story is the size of that product, and the size is the whole security story: bigger keys are harder to factor.
For most of the 2000s, 1024-bit RSA was the standard choice. Then the arithmetic caught up with it. The largest RSA key ever factored in public is RSA-768, broken in 2009 by an academic team after years of work. A 1024-bit key is roughly a thousand times harder than that, which kept it out of practical reach — but only just, and only for attackers willing to spend the money. Standards bodies read the writing on the wall early: US federal guidance in NIST SP 800-131A disallowed RSA keys shorter than 2048 bits for generating new digital signatures from the end of 2013, and the major web certificate authorities stopped issuing 1024-bit certificates years ago.
So why does the DeepMind RSA 1024 weakness in a retired key size matter at all? Because retirement is a policy, not a physical event. Keys do not expire when guidance changes. A 1024-bit key generated in 2012 can still be sitting in a mail server, a piece of industrial hardware, a long-lived certificate or a firmware-signing process in 2026, doing its job quietly and never having been rotated. The DeepMind RSA 1024 results matter because they change the economics of attacking exactly that leftover population — and because they suggest the economics will keep changing faster than the retirement schedules assumed.
There is a second clock running as well. NIST finalised IR 8547, its Transition to Post-Quantum Cryptography Standards report, on 27 October 2026 — ten days before the DeepMind RSA 1024 announcement. The final report deprecates every quantum-vulnerable public-key algorithm, RSA included at every key size, after 2030, and disallows them after 2035. Under Executive Order 14412 and OMB Memorandum M-26-15, US federal high-value systems must move to post-quantum key establishment by 31 December 2030 and post-quantum signatures by 31 December 2031. The DeepMind RSA 1024 findings are a classical-computing story, not a quantum one, but they land on the same timeline and point in the same direction: the assumptions underneath RSA’s long retirement schedule are being tested sooner than expected.
Weakness 1: The Signature-Forgery Attack
The first of the two DeepMind RSA 1024 results concerns digital signatures, and it starts with padding. An RSA signature is not computed over a raw message. Before signing, the message digest is wrapped in fixed padding — extra structure that forces the number being signed into a rigid shape. That structure has long been treated as a defence against forgery: it stops an attacker from stitching together a valid signature from other signatures the system has already produced.
What the DeepMind agents found is that this protection fades quickly once an attacker controls a large share of the signed block. When the attacker controls roughly half of the block or more, the padding adds almost no meaningful protection, and forging a signature becomes about as hard as attacking an unpadded system. The result is aimed at a specific and realistic setting: a signing service or device that signs data an outside party can partly choose. That kind of access — a signing oracle — is exactly what a hardware security module (HSM) or a signing API provides when it signs data submitted to it.
The measured part of this result is modest and concrete. DeepMind tested the agents’ implementation in a sandbox against a 1024-bit benchmark key that an academic team had already attacked, and the AI-generated implementation reproduced that result using 3.5 times less CPU time — and less than a thousandth of the computing power needed to factor the key itself. A 3.5-fold improvement is not a revolution. It is a real, measured efficiency gain on a real attack, and it is the only part of the signature result that has actually been run.
The headline figure — around 1,600 times faster — is something else entirely. It applies to the harder case, where the attacker controls only a short piece of the signed data, such as a 32-byte digital fingerprint. For that case the agents found a new algorithm that DeepMind estimates is about 1,600 times better than the best previously known method for 1024-bit keys. That number is a theoretical estimate, not a measured run. Nobody has executed the algorithm at full size, and the full paper on the signature result was not publicly available when the announcement was made, so the padding schemes it covers and the exact threat model have not been independently checked yet. Treat the 1,600x figure as a claim about an algorithm’s mathematics, not as something that has happened.
The benchmark the agents reproduced is worth understanding, because it shows what “signature forgery” actually costs. In September 2026, Laura Shea, Miro Haller, Adam Suhl, Nadia Heninger and Emmanuel Thomé published “Forging 1024-bit RSA signatures in nearly SNFS time” (IACR ePrint 2026/2131). They implemented a 2007 algorithm by Joux, Naccache and Thomé against a hardware security module, making 2^32 queries to the signing device over five months of computation — about 1,380 CPU core-years in total. After that precomputation, any chosen signature could be forged offline for roughly 180 core-years.
Their paper also estimated that RSA with an exposed signing oracle is 15 to 30 bits weaker than factoring-based estimates suggest, across key sizes from 1024 to 4096 bits. Cryptographer Matthew Green stressed when that paper appeared that this kind of attack is not RSA-1024 factorisation: it forges signatures after many queries to a signing oracle, and the private key stays unknown. The DeepMind RSA 1024 signature result belongs to the same family — a cheaper way to abuse a signing service, not a way to recover a private key.
Three implications of the DeepMind RSA 1024 signature result follow. First, the attack needs an oracle: without a device or service that signs attacker-influenced data, there is nothing to exploit. Second, it forges signatures; it does not recover the private key, so it cannot decrypt anything. Third, the improvement is specific to 1024-bit keys and to settings where the attacker controls part of the signed block. Those are real constraints, and they are also the reason the result is a warning about legacy deployments rather than an emergency for everyone else.

Weakness 2: Fan Factories and Cheaper Batch Factoring
The second DeepMind RSA 1024 result is about factoring — but not about factoring one key faster. It is about factoring many keys cheaper, by sharing the expensive work between them. The idea it builds on is the factorisation factory, published by Don Coppersmith in 1993: when many integers of the same size must be factored, an attacker pays once for a large precomputation and then spends less on each target. DeepMind’s agents found a new design in that family, which the paper calls a “fan factory”: each target integer gets its own fan of number fields, all fed by one shared precomputed rational side, and the paper derives a closed-form minimum cost per integer for each precomputation budget.
The numbers, as stated in the paper, are striking. With a one-time precomputation equal to the cost of factoring a single 1024-bit number, each further 1024-bit key can be factored at about 1/58 of the cost of a full run — which the authors describe as roughly 30 times less than the best previous batch method, the multiple number field sieve (MNFS). In the standard notation, where costs are written as L[c] and a smaller constant means a faster method, the fan factory brings the cost of each further integer to about L[1.793], against L[1.902] for MNFS. The authors report that the fan design improves on earlier methods for precomputation budgets with exponents between about 1.902 and 1.950, and that a single number field per integer becomes optimal above that range.
The paper is careful about its own limits, and any honest account should repeat them. The estimates drop lower-order terms, rest on standard heuristics about how often numbers are smooth, and assume a simple unit-cost model of computing. Memory is a second obstacle: at a precomputation budget of one full factoring run, the stored table holds on the order of L[1.66] pairs. No fan factory has been built, and the paper says the key size at which it would beat a well-tuned number field sieve in practice is still an open empirical question. With unlimited precomputation, Coppersmith’s original factory remains the optimal design, so the fan does not lower the theoretical floor. These are leading-order theoretical estimates, not predicted running times — and DeepMind says so.
Even with those caveats, the economics change in a way that is easy to see in the paper’s own cost table. Costs are expressed in units of one general number field sieve (GNFS) factorisation of a 1024-bit number, with the fan factory’s one-run precomputation counted in its total:
| Keys factored | MNFS total (GNFS units) | Fan factory total, including precomputation | Fan factory advantage |
|---|---|---|---|
| 1 | 0.52 | 1.02 | None |
| 3 | 1.55 | 1.05 | 1.5x |
| 10 | 5.17 | 1.17 | 4.4x |
| 100 | 51.72 | 2.72 | 19x |
The pattern is the point. For a single key the fan factory is worse than the old method, because the precomputation has to be paid and is never repaid. At three keys it is already cheaper, and the advantage grows with the size of the batch, approaching the 30-fold per-key gap as the number of targets rises. The economics favour an attacker who wants to break a large population of legacy keys — an archive of old certificates, or a fleet of devices that all shipped with 1024-bit keys — rather than one carefully chosen target.
That is why batch attacks matter, and it is an old lesson: weak keys tend to come in groups, one vendor, one firmware image, one old default. Heninger’s own 2012 work with Durumeric, Wustrow and Halderman recovered RSA private keys for 0.50% of TLS hosts and 0.03% of SSH hosts because their keys shared prime factors. That was a different technique, but the lesson carries over. An attacker who goes after a whole population of old keys pays far less per key than one who goes after a single key.
The Two DeepMind RSA 1024 Weaknesses Side by Side
The two DeepMind RSA 1024 results are easy to confuse because they share a target and a headline style, but they attack different things in different ways. Keeping them apart is the key to understanding the announcement.
| Weakness 1: signature forgery | Weakness 2: batch factoring | |
|---|---|---|
| What it targets | 1024-bit RSA signatures where the attacker controls part of the signed block | Many 1024-bit RSA moduli factored together |
| What the attacker needs | Control over part of the signed block, plus access to a signing oracle | A large set of keys to attack as a batch |
| Does it recover the private key? | No — it forges signatures | Yes — it factors the moduli |
| Headline gain | About 1,600x (theoretical estimate, 32-byte fingerprint case) | About 30x lower cost per additional key |
| What has actually been measured | 3.5x less CPU time on an already-solved benchmark key | Not reported as a full-size run |
| Status | Sandbox reproduction plus theoretical estimate, per DeepMind | Working paper, leading-order estimate, not implemented |
| RSA-2048 affected? | No, per DeepMind | No, per DeepMind |
One more distinction matters and is easy to miss: neither result breaks a single 1024-bit key faster than the general number field sieve, which remains the standard measure of RSA strength. The signature result makes forgery cheaper in a specific oracle setting. The factoring result makes the nth key cheaper when keys are attacked in bulk. A single well-managed 1024-bit key, attacked alone, is exactly as hard to factor as it was on 5 November. What changed is the price of attacking populations and signing services — and the speed at which new attacks can now be found.
How the AI Agents Actually Did the Work
The batch-factoring paper is unusually specific about the role of AI, and it is the most interesting part of the DeepMind RSA 1024 story for anyone who follows AI research. The results were obtained with a two-agent harness in which one model generated proofs and a second model verified them. The algebraic identities and exact feasibility witnesses behind the main theorems are machine-checked in the Lean 4 proof assistant, while the calculus arguments that complete the optimisation were checked numerically rather than formally. The paper’s author list combines DeepMind researchers, including Kohli, Dvijotham and Thakurta, with Heninger and Thomé.
That division of labour is the honest version of “AI found this”. The experts chose the problems and judged which results were significant. The agents produced and checked candidate algorithms and proofs at a pace the company describes in weeks. The formal verification in Lean gives outside cryptographers a way to check the algebra independently, which carries particular weight for claims produced with machine assistance: a proof the computer has checked is a proof a sceptic can re-run, even if the reasoning that produced it came from a model.
Readers who have followed AI’s growing role in mathematics will recognise the pattern. Earlier this week, this site covered how AI helped settle the Aaronson-Ambainis conjecture, another case of machine assistance accelerating a hard mathematical result rather than replacing the mathematicians. The DeepMind RSA 1024 work sits in the same lineage, applied to cryptography instead of pure mathematics.

The DeepMind RSA 1024 “weeks, not years” claim deserves a moment of its own, because it is the part of the announcement with the widest consequences. Cryptanalysis has always been slow, expert work. A new attack on a widely used system is typically the product of years of specialist effort, and the community plans around that slowness: key sizes are chosen with a margin that assumes attacks improve gradually.
If AI agents can shorten the cycle from years to weeks for this class of problem, the margin itself becomes less reliable. Kohli’s own argument fits that reading: if AI lets researchers probe hardness assumptions faster than before, migration plans should not count on attacks improving slowly. The DeepMind RSA 1024 results are, on this reading, less a story about one retired key size and more a demonstration that the rate of cryptanalytic progress has changed.
It is also worth noting what the agents did not do. They did not autonomously decide to attack RSA, they did not run an attack against a live system, and they did not produce a turnkey tool. The work was steered, scoped and checked by people at every stage, and the outputs are papers and proofs, not software. That matters for how the story should be reported — and it matters for the safety framing. The same capabilities that let agents find weaknesses in old cryptography are the capabilities labs are pointing at defensive work, from finding software bugs at scale to making model outputs verifiable.
What the DeepMind RSA 1024 Results Do NOT Mean
The gap between what happened and what the headlines implied is wide enough to need its own section. Here is what the DeepMind RSA 1024 announcement does not mean, stated plainly.
It does not mean AI broke RSA. The results concern 1024-bit keys, a size retired for new signatures more than a decade ago. Modern encryption almost always uses 2048-bit keys or larger, and DeepMind says those are unaffected. RSA-2048 remains far beyond practical factoring: the largest public factorisation, RSA-768 in 2009, is still hundreds of times smaller in difficulty, and nothing in this announcement changes the cost of attacking a single modern key.
It does not mean your data is at risk. No production system relying on 1024-bit RSA was named, and no live systems were touched. The tests ran in a sandbox against a benchmark key that had already been broken by academics. If your services use current keys — RSA-2048 or larger, or elliptic-curve cryptography — this research changes nothing in practice, and DeepMind says so plainly.
It does not mean the 1,600x figure has been demonstrated. The 1,600-fold improvement for short 32-byte digests is DeepMind’s theoretical estimate for a new algorithm that has not been run at full size. The measured result is the 3.5-fold CPU reduction on the benchmark reproduction. Confusing the two numbers is the single most common error in coverage of the DeepMind RSA 1024 story, and it inflates the finding by more than two orders of magnitude.
It does not mean a fan factory exists. The batch-factoring result is a paper with cost estimates. No fan factory has been implemented, memory requirements are formidable, and the paper itself says the key size at which the method would beat a well-tuned number field sieve in practice is still an open empirical question. The 30-fold figure is a leading-order estimate under stated assumptions, not a measured speed-up.
It does not mean the papers are settled science. Neither working paper had been peer-reviewed at announcement time, and no independent replication of either result had been published. The Lean-checked algebra in the factoring paper gives the community something concrete to verify, which is a genuine strength — but verification by the wider community is still to come, and the signature paper’s details were not yet public at all.
None of this makes the DeepMind RSA 1024 announcement unimportant. It makes it a specific kind of important: a credible, expert-steered demonstration that AI agents can now do frontier cryptanalysis in weeks, with results that tighten the screws on a key size that should already have been retired. The right reaction is not panic. It is to finish the retirement.

Who Is Actually Exposed
If modern keys are safe, who should actually care about the DeepMind RSA 1024 findings? The exposure sits in systems that were never upgraded, and it concentrates in three groups.
Owners of signing services and hardware security modules. The signature result is most relevant where a system signs data that an outside party can partly choose. The September HSM attack that DeepMind used as its benchmark depended on access to a raw signing interface, and the Shea et al. paper names blind RSA schemes as another setting that offers such an interface. Teams that still expose 1024-bit signing through an API should treat partial attacker control over the signed block as a forgery risk, restrict raw or low-padding signing operations, and rotate those keys. A hardware security module that signs arbitrary blocks without hashing and padding them first — the raw RSA mechanism known as CKM_RSA_X_509 in PKCS#11 — is precisely the kind of oracle this research concerns.
Operators of large fleets of legacy keys. The batch result lowers the cost per key when many keys share the same size, so inventories matter more than any single key. Embedded devices, older smart cards, long-lived code-signing roots and archived certificates that still use 1024-bit RSA are the obvious candidates for an audit. The pattern from Heninger’s 2012 study repeats here: weak keys come in populations, and populations are where batch methods pay off. A single forgotten 1024-bit certificate in an archive is a small risk. Ten thousand of them, all generated from the same old template, is the scenario the fan factory economics describe.
Teams running email authentication on old keys. Email signing (DKIM) is the most concrete everyday example. RFC 8301 still lets DKIM signers use 1024-bit keys: signers should use at least 2048 bits, but the must floor is 1024, and domains that set up DKIM years ago may never have rotated. A 1024-bit DKIM key is exactly the kind of long-lived, rarely inspected credential the DeepMind RSA 1024 results should prompt people to check. The same logic applies to old S/MIME certificates and legacy VPN or device-management keys issued a decade ago.
Teams planning post-quantum migration. The Shea et al. paper concludes that its signing-oracle results give classical cryptanalytic support for moving away from RSA during the post-quantum transition, and DeepMind framed its own work as evidence that the hardness of cryptographic problems should be reassessed continuously. For security teams, the practical effect is a stronger case for retiring 1024-bit keys now and for scheduling RSA-2048 replacements on the post-quantum timeline rather than treating them as permanent. The NIST IR 8547 dates — deprecation after 2030, disallowance after 2035, with federal migration deadlines in 2030 and 2031 — are the calendar this planning should use.
What all four groups share is a property worth naming: their exposure comes from inaction, not from a new vulnerability in something they just deployed. The DeepMind RSA 1024 results do not create a new class of victim. They raise the price of a procrastination that was already unwise.
What to Do Now: A Practical Checklist
For most readers, the honest answer after the DeepMind RSA 1024 announcement is that nothing urgent is required — and for the small number of people who still run 1024-bit RSA, the fix is straightforward. The DeepMind RSA 1024 findings reward a short, concrete audit rather than a security overhaul.
1. Inventory your RSA key sizes. For a PEM-format private key, the command openssl rsa -in key.pem -noout -text prints the modulus size at the top of its output. For DKIM, look up each selector with dig TXT selector._domainkey.example.com and check the key length in the returned record. For certificates, openssl x509 -in cert.pem -noout -text shows the public-key size. Check mail servers, VPN gateways, code-signing keys, device-management roots and any HSM-backed signing service, not just the web servers. The keys that matter most are the ones nobody has looked at in years.
2. Retire 1024-bit keys first. Rotate them to RSA-3072, or to ECDSA or Ed25519 where the protocol allows, and move DKIM selectors to 2048 bits or more. Rotation is the single highest-value action in this whole story: it removes the exposure entirely, and it is work that was already overdue before DeepMind published anything. Prioritise signing keys over encryption keys, and keys that are exposed to outside input over keys that only ever sign internal data.
3. Close raw signing oracles. Disable raw RSA signing mechanisms — in PKCS#11, that is CKM_RSA_X_509 — unless something truly needs them, and sign only hashed, properly padded messages, preferably with RSA-PSS. Review any API or device interface that signs data supplied by a caller, and ask whether the caller can influence a large share of the signed block. If it can, that interface is the setting the DeepMind RSA 1024 signature result describes, and it should be restricted or re-keyed.
4. Start the post-quantum plan, even if the deadline feels far away. NIST’s 2030 and 2035 dates apply to every RSA size, so 2048-bit keys need a replacement path too. The practical first steps are an inventory of where cryptography is used (a cryptographic bill of materials), a list of systems with the longest-lived keys, and a test deployment of the new standards — ML-KEM for key establishment and ML-DSA for signatures, standardised as FIPS 203 and FIPS 204 in August 2024. The DeepMind RSA 1024 results are a classical attack story, but they strengthen the same conclusion as the quantum timeline: cryptographic assumptions have expiry dates, and planning should start before the expiry arrives.
5. Do not panic, and do not over-rotate. There is no reason to replace RSA-2048 in a hurry, no reason to distrust TLS, and no reason to treat this announcement as a breach. The correct response is a tidy-up of legacy keys and a realistic migration schedule — the same response the industry owed itself in 2013, when 1024-bit keys were first disallowed for new signatures. The DeepMind RSA 1024 work is best read as a reminder with numbers attached.

The Bigger Picture: AI Is Now Doing Cryptanalysis
The DeepMind RSA 1024 announcement does not stand alone. It is the second AI cryptanalysis result from a frontier lab this year, and the pattern across the two is what makes the trend worth watching. In July 2026, Anthropic reported that Claude Mythos Preview had found an improved key-recovery attack on HAWK, a post-quantum signature candidate, and a 200x to 800x faster attack on AES-128 reduced to 7 of its 10 rounds. Neither touched deployed systems. In both the Anthropic and DeepMind cases, the targets were retired or deliberately weakened versions of real systems, experts steered the work, and the claims were checked in sandboxes. The difference from earlier cryptanalysis is pace — and pace is the whole story.
The same acceleration is visible beyond cryptography. Independent evaluator METR published an assessment on 5 November 2026 finding that AI is speeding up Anthropic’s own model research by about 1.9 times, with AI itself behind most of the gain — a result this site examined in depth in its METR Anthropic report coverage. When the tools that do research get faster at doing research, every field they touch inherits the acceleration, and cryptography is no exception. The DeepMind RSA 1024 work is one more data point on that curve: agents that write and check proofs, running for weeks, producing results that used to take years.
The labs are also pointing AI and cryptography in the other direction — at making machine output verifiable rather than merely finding weaknesses. Anthropic’s FlashProve, covered on this site in the Anthropic FlashProve explainer, uses zero-knowledge proofs for LLM inference: cryptography as a way to trust what a model says it did. And the same week DeepMind announced its RSA results, Google shipped Gemini 4 Hydrogen, a new execution-oriented model for coding agents — covered in this site’s Gemini 4 Hydrogen explainer — which is the kind of model that powers the agent harnesses doing this research. The two directions, attack and verification, are advancing together, and both are driven by the same agent infrastructure.
There is a reasonable question underneath all of this, and it is the question security teams should be asking: if agents can improve attacks on old parameters in weeks, how should anyone plan around a key size losing strength slowly? The honest answer is that they should not plan around slow decay at all. Key sizes, migration timelines and retirement schedules were all built on an assumption that cryptanalysis improves gradually, through the work of a small number of human specialists. The DeepMind RSA 1024 results do not prove that assumption false. They prove it is no longer safe to rely on.
For readers learning security — including those studying ethical hacking, where understanding how attacks work is the foundation of defending against them — the lesson is methodological rather than tactical. This article deliberately does not teach the attack techniques: the value is in understanding what changed (the economics of attacking legacy keys and signing oracles), how it was found (human-guided agents with machine-checked proofs), and what to do about it (retire old keys, close raw oracles, plan the post-quantum migration). That is the durable knowledge. The specific algorithms will be superseded; the pattern of AI-accelerated cryptanalysis will not.
Frequently Asked Questions
Did DeepMind’s AI break RSA?
No. The DeepMind RSA 1024 results concern legacy 1024-bit RSA only. The agents found a cheaper way to forge signatures in settings where an attacker controls part of the signed data, and a cheaper way to factor many 1024-bit keys at once. RSA-2048 and larger keys are unaffected, and no live system was attacked. The announcement is about retired keys, not about RSA as a whole.
What does the 1,600x figure actually mean?
It is DeepMind’s theoretical estimate of how much better its new signature-forgery algorithm is than the previous best method for 1024-bit keys, in the case where the attacker controls only a 32-byte fingerprint of the signed block. It has not been run at full scale. The measured result was 3.5 times less CPU time on an already-solved benchmark key. The DeepMind RSA 1024 headline number is a projection until other cryptographers check the paper.
Are my passwords, bank account or emails at risk?
No, not because of the DeepMind RSA 1024 research. Modern services use RSA-2048 or larger keys, or elliptic-curve cryptography, and DeepMind states those are unaffected. The DeepMind RSA 1024 findings matter for organisations still running 1024-bit keys in old systems — mail servers with ancient DKIM keys, embedded devices, long-lived certificates — not for individual users of current services.
What is a fan factory?
A fan factory is the DeepMind RSA 1024 team’s new design for batch factoring: a method of factoring many RSA keys of the same size together, sharing one large precomputation across all of them. Each target key gets its own “fan” of number fields fed by a shared precomputed side. With a precomputation equal to one full factoring run, each further 1024-bit key costs about 1/58 of a full run — roughly 30 times less than the best previous batch method. It exists as a paper and a set of cost estimates, not as a built system.
Should I replace my RSA-2048 keys now?
Not because of this research. Plan for it anyway: NIST IR 8547, finalised on 27 October 2026, deprecates quantum-vulnerable signature algorithms, including RSA of every size, after 2030 and disallows them after 2035. The DeepMind RSA 1024 results are one more reason to have a migration plan, not a reason to rush one this week.
How do I check whether my domain still uses a 1024-bit DKIM key?
Query the selector’s TXT record — for example, dig TXT selector._domainkey.example.com — and decode the public key, or use your email provider’s DKIM checker. If it reports 1024 bits, rotate to a 2048-bit key or larger. The same check applies to any certificate or key your organisation issued a decade ago and never revisited.
Why Did the DeepMind RSA 1024 Agents Find This in Weeks?
Because the agents could generate and check candidate proofs at machine speed while human experts chose the problems and judged the results. The DeepMind RSA 1024 factoring paper used a two-agent harness — one model writing proofs, another verifying them — with the key algebra machine-checked in Lean 4. The experts supplied direction and significance; the agents supplied pace. That combination is the story, and it is the same pattern behind the METR finding that AI is accelerating AI research itself.
The Bottom Line
The DeepMind RSA 1024 announcement is a precise, bounded result that has been widely over-read. AI agents, guided by leading cryptographers, found two genuine weaknesses in a retired key size: a signature-forgery method that exploits padding when an attacker controls part of the signed block, and a batch-factoring method that makes the hundredth 1024-bit key far cheaper to break than the first. The measured gains are real but modest — 3.5 times less CPU time on a benchmark reproduction — while the headline figures of 1,600 times and 30 times are theoretical estimates that have not been run at full scale or independently replicated. Modern RSA-2048 and larger keys are unaffected, no live system was touched, and neither paper had been peer-reviewed when the announcement was made.
What is genuinely new is the pace. Two frontier labs in one year have shown that AI agents can do serious cryptanalysis in weeks, with machine-checked proofs, under expert guidance. That changes the planning assumption underneath every key-retirement schedule: attacks may no longer improve slowly. The practical response is unglamorous and entirely sufficient — inventory your keys, retire the 1024-bit ones, close raw signing oracles, and keep the post-quantum migration on the calendar NIST has set. The DeepMind RSA 1024 story is not a warning that encryption is broken. It is a warning that procrastination now has a price, and that the price is falling.
Sources: Google DeepMind announcement (6 Nov 2026) via Pushmeet Kohli, “Advancing the frontier of cryptanalysis”; “Fan Factories: Multiple Number Fields in Factorization Factories and Batch NFS” (working paper, 5 Nov 2026); “Modular Roots from a Restricted Oracle” (working paper, Nov 2026); Shea, Haller, Suhl, Heninger & Thomé, “Forging 1024-bit RSA signatures in nearly SNFS time” (IACR ePrint 2026/2131); NIST IR 8547 final (27 Oct 2026), summarised in the PostQuantum.com explainer; NIST SP 800-131A Rev. 2; RFC 8301 (DKIM). All benchmark and improvement figures are the researchers’ own and are labelled as such in the article.
