AI agents took on 1024-bit RSA: DeepMind reproduced five months of cryptography in days
Google DeepMind says AI agents found two weaknesses in legacy 1024-bit RSA and reproduced a five-month cryptographic computation in 3.2 days. Modern 2048-bit encryption is unaffected.

First, the reassurance, so the headline does not scare you: your online banking, your chats, and your software updates are fine. The research Google DeepMind published on November 6 targets 1024-bit RSA, an old form of encryption that almost nobody should still be using. What is actually worth your attention is not that "RSA has been broken" but who broke it: two AI agents that, with about twenty short messages from a human researcher, reproduced in under four days a cryptographic computation that took a human team five months.
The work was announced on November 6 by Pushmeet Kohli, DeepMind's Vice President of Research, with two working papers attached. It was led by Krishnamurthy (Dj) Dvijotham and Abhradeep Thakurta, with cryptographers Nadia Heninger (UC San Diego and Inria) and Emmanuel Thomé (Inria) among the co-authors. Kohli drew the boundary early: "In practice, these results only affect obsolete 1024-bit RSA systems, and modern encryption protocols, which almost universally use 2048-bit or larger keys, remain secure." Keep that sentence pinned down; every number that follows has to be read inside it.
" alt="A blackboard covered in mathematical formulas, evoking the mathematics behind cryptanalysis">
The first result concerns digital signatures. RSA signing has an old rule: the data is first padded into the PKCS#1 v1.5 format, and only then does the device sign it. That padding has long been treated as a line of defence — even if an attacker can get a signing device to sign things for them, they can only sign a small, fixed-format slice of data. DeepMind's paper works out exactly where that defence holds. In a 1024-bit signing block of 128 bytes, if the attacker controls 65 or more of them, or the digest is 64 bytes (SHA-512, for example), the padding adds no protection at all: the problem is no harder than signing raw, unpadded data. In other words, the wall only stands while the attacker controls less than half the block.
What if the attacker controls less — say, a 32-byte digest, which is what SHA-256 produces? The problem stays harder, but DeepMind offers a new algorithm: by their theoretical estimates, it improves on the previous best method by roughly 1,600x at 1024 bits. A qualifier is mandatory here: the 1,600x figure is a theoretical, asymptotic estimate, and the paper states plainly that it was not run at this size. Quoting it as "1,600 times faster, done" would be doing DeepMind's boasting for them. The numbers that were actually run are in the next section — much smaller, and much more real.
The second result is about cracking many keys at once. Since 1993, the best known method for batch factoring has been Coppersmith's multiple number field sieve. DeepMind's second paper proposes "fan factories": each target key gets its own family of number fields, all fed by one shared precomputation. By the paper's estimates, each additional 1024-bit integer would cost about 1/58 of a standard number field sieve run — roughly 30 times less than Coppersmith's method. The algebraic identities have been machine-checked in Lean 4, but no fan factory has actually been implemented. It remains, for now, a result on paper. Both papers are working papers and have not been peer reviewed, something DeepMind has not hidden.
What was actually run is a reproduction of a September paper. In that work, published on the IACR ePrint archive by Laura Shea, Miro Haller, Adam Suhl, Heninger and Thomé, the team carried out the first 1024-bit attack with a signing oracle: about 1,200 CPU core-years offline, 4.07 billion oracle queries, and 180 core-years to compute the root of one target — roughly 1,380 core-years in total, spread over five calendar months, using a hardware security module as the signing oracle. DeepMind set two AI agents to redo it with the same algorithm, the same polynomials and the same bounds. The first root took 391 core-years, 3.5 times less than the original; calendar time fell from five months to 3.2 days. The paper is honest about why: the calendar difference "reflects mainly parallelism" — the run peaked at roughly 300,000 CPU cores and 16 GPUs — while the 3.5x CPU saving comes mostly from the code itself, with the optimised siever running 1.8 to 4.4 times faster than CADO-NFS on the same machine. For comparison, factoring that 1024-bit modulus outright is estimated at 500,000 to 1,000,000 core-years. The signing-oracle route is still far cheaper.
How those 3.2 days went is described in section 6 of the paper, and it is more interesting than the results themselves. The two agents split the work: one acted as supervisor, writing the design, setting checkpoints for each stage and auditing every result; the other acted as executor, writing the code, running the distributed jobs and fixing failures. Together they wrote about 33,500 lines of new code and launched 336 distributed experiments. The human researcher sent about twenty short messages, mostly approvals such as "follow your recommendation" and "continue". Things genuinely went wrong mid-run: a 32-bit index overflow made the first computed root wrong, and the agents tracked it down and fixed it themselves; descent nodes of 82 to 85 bits appeared that a smaller rehearsal could not have exposed. This was not "AI following a script to the end of a computation". It was AI doing research — designing, debugging, correcting — with only nodding-style human supervision.
So what is actually affected? Three lines. First, only 1024-bit RSA. Modern systems using 2048-bit keys and above are outside the reach of these results, a point the paper's abstract makes in bold. Second, the attacker needs direct access to a signing interface, and a lot of it: the reproduced computation used about 4 billion oracle queries, all made before the target was known. That is not something you do by casually visiting a website. Third, mechanisms that hash the message inside the device, such as CKM_SHA256_RSA_PKCS, never let the caller choose the block at all, and fall entirely outside both attack models. The September ePrint paper did put it more starkly: with a signing oracle, the concrete security of RSA from 1024 to 4096 bits should be 15 to 30 bits lower than factoring-based estimates, and its authors wrote that "even 4096-bit RSA does not appear to meet a 128-bit security level in this attack model." That sentence deserves to be taken seriously — but it is about a model in which the attacker can call the signing interface without limit, not about the banking app on your phone.
The systems that should actually worry are the old ones still signing with 1024-bit RSA. Current guidance already no longer approves 1024-bit RSA for generating new signatures, but old devices, old firmware and old HSM configurations do not retire themselves. What DeepMind has done is turn "we should migrate eventually" into a priced-out fact: where the padding protection ends, how much cheaper batch cracking could get, and what a reproduction costs in compute are all now written down in public papers. For anyone still maintaining such systems, moving to 2048-bit keys or a newer signature scheme stops being an item on a roadmap and becomes something to move up the schedule.
Zoom out, and this is the other side of the same coin as another story from the same week: on November 5, OpenAI released GPT-6 Cyber, restricted to vetted security teams, and Anthropic's Claude found two decade-old critical vulnerabilities in the Xen hypervisor. The speed at which AI does security research is becoming news in itself. Where a cryptographic result once took years from idea to computation, it now takes weeks. METR's November 5 report estimated that research inside Anthropic is already running about 1.9 times faster than before; DeepMind's paper is the same trend showing up in cryptography — a field that usually advances slowly is being rewired by agents plus parallel compute. The good news is that offence and defence share the same tools: the agents that find vulnerabilities can help defenders audit code and verify fixes faster too.
One last caution: do not let the big numbers run away with you. The 1,600x is theoretical and was never run; the 30x is a paper method that has never been implemented. What was actually run, and can be written into the ledger, is 3.5x and 3.2 days. Those two numbers are already enough: for the first time, AI agents have independently carried weeks of frontier cryptography research while a human mostly nodded along. 1024-bit RSA was already supposed to be retired. This time, AI just wrote its obituary in more specific terms.
Comments (0)
Sources
Related articles
On 16 November 2026, Google's Threat Intelligence Group reported the first fully automated vulnerability discovery and exploitation chain: no human in the loop. The evidence is an exposed server running exploit_agent, a framework that diffs code around patch announcements, writes exploits and fires them. The same report shows a North Korean cluster turning Claude Code's settings file into a backdoor trigger — and stolen cloud compute running up $100,000 bills in a day.
On 18 November 2026, Google Research and co-authors posted BuggyMLE to arXiv: bugs injected into 222 working ML repositories, and 14 models slide from 95% on the easiest tier to 9% on the hardest. A 9-billion-parameter model trained easy-to-hard beats Claude Opus 5.5 on the 10-bug tier.
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.