Google DeepMind published two results on 6 November, and both concern only 1024-bit RSA — a key size standards bodies retired for new signatures more than a decade ago, but one that survives in old hardware, long-lived certificates and embedded systems. The work was led at DeepMind by Krishnamurthy (Dj) Dvijotham and Abhradeep Thakurta, with Nadia Heninger of UC San Diego and Emmanuel Thomé of Inria as co-authors. Pushmeet Kohli, DeepMind's vice president of science, said the team reached the results in weeks rather than years.

Result one: padding protects less than assumed

RSA signatures are not computed over a raw hash. The scheme first wraps the digest in a rigid padding structure, and that structure has long been treated as a defence against forgery. The agents found, according to DeepMind, that the protection fades fast once an attacker controls a large share of the signed block: at roughly half the block or more, padding adds no meaningful protection and forgery becomes about as hard as attacking an unpadded system.

DeepMind tested this in a sandboxed simulation against a 1024-bit benchmark key that had already been attacked in earlier academic work. The AI-generated implementation reproduced the result with 3.5 times less CPU time, using less than a thousandth of the computation needed to factor the key itself. The benchmark is the September paper by Laura Shea, Miro Haller, Adam Suhl, Nadia Heninger and Emmanuel Thomé, who forged signatures from a hardware security module through black-box API calls — 1,380 CPU core-years over five calendar months and 2^32 queries to a raw signing oracle. A 3.5-fold reduction would bring the same job to roughly 390 core-years.

For the harder case, where the attacker controls only a small part of the block such as a 32-byte digest, the team says the agents found a new algorithm it estimates is about 1,600 times better than the best previously known method. That figure is a theoretical estimate; DeepMind has not named the specific padding schemes covered, and a full paper on the signature result was not public when this was written.

Result two: a "fan factory" for keys in bulk

The second result is a working paper dated 5 November, "Fan Factories: Multiple Number Fields in Factorization Factories and Batch NFS". It builds on Don Coppersmith's 1993 factorization factory. A factory pays off when many integers of the same size must be factored: the attacker pays once for a large precomputation, then less per target.

The DeepMind construction gives each target integer its own "fan" of number fields, all fed by a shared precomputed rational side, and derives a closed-form minimum cost per integer for each precomputation budget. With a budget equal to one GNFS factorization, each further 1024-bit key costs about 1/58 of a GNFS run — in the usual L[c] notation, L[1.793] against L[1.902] for the multiple number field sieve, the best batch method since 1993. That is roughly 30 times less per key. Counting the precomputation, the fan is already cheaper than MNFS at three targets; the advantage grows with batch size and approaches the 30-fold gap.

How the agents were used

The paper describes a two-agent harness: one model generates the proofs, a second verifies them. The algebraic identities and exact feasibility witnesses behind the main theorems are machine-checked in the Lean 4 proof assistant; the calculus arguments that complete the optimisation were checked numerically. That division of labour is what makes the result checkable by outsiders — for machine-generated claims, verification is the bottleneck, not the idea.

The limits are part of the result

The paper drops lower-order terms, rests on standard heuristics about how often numbers are smooth, and assumes a simple unit-cost computing model. Memory is a second obstacle: at a budget of one GNFS run, the stored table holds on the order of L[1.66] pairs. No fan factory has been built, and the key size at which it would beat a well-tuned number field sieve in practice is an open empirical question. With unlimited precomputation, Coppersmith's original factory remains optimal — so the theoretical floor does not move.

And 2048-bit keys? DeepMind and the paper both say it plainly: modern deployments of 2048 bits and larger are not threatened. NIST has disallowed shorter keys for new signatures since the end of 2013.

What organisations should still do

- Operators of signing services and HSMs: where 1024-bit signing is exposed through an API, treat partial attacker control of the signed block as a forgery risk, restrict raw or low-padding signing operations and rotate the keys. - Anyone running large fleets of legacy keys: in a batch attack the inventory matters more than any single key — embedded devices, older smart cards, long-lived code-signing roots, archived certificates. - Teams planning post-quantum migration: one more documented reason to retire 1024-bit keys now and to schedule RSA-2048 retirement on the post-quantum timeline.

The real signal is not that RSA was broken; it was not. It is that a team of humans and agents moved cryptanalysis forward in weeks, and the result arrives with a proof that outsiders can machine-check.