Claude reconstructs NSA seed origins for NIST curves, easing a long-running backdoor suspicion

Claude reconstructs NSA seed origins for NIST curves, easing a long-running backdoor suspicion

N
News Editor
2026-10-19 03:21:50
Anthropic says Claude reconstructed how the U.S. National Security Agency generated the public seeds used for a set of NIST elliptic curves in the late 1990s, solving a cryptographic history puzzle that had lingered for decades. The result does not mean AI broke elliptic-curve cryptography, derived anyone’s private key, or compromised TLS or Bitcoin. Instead, it explains how the published seeds behind core NIST prime curves appear to have been produced. According to the report, Claude examined 34 legacy pseudorandom number generators and output-slicing patterns, identified traces consistent with the POSIX/C library function lrand48(), and used LLL lattice reduction to recover internal state from truncated outputs. Anthropic said the model reached the method in under 30 minutes. The reconstructed process points to specific UTC timestamps between 1997 and 1998 and candidate positions that reproduce the published 160-bit seeds exactly. The finding matters because the seeds had long been auditable only in one direction: anyone could verify that a given seed generated a given curve coefficient, but not why those 160-bit seeds were chosen in the first place. Filippo Valsorda, who helped set a bounty on the problem in 2023, independently reimplemented the process in Go and reproduced the seeds, giving the result an external check. The report argues that this sharply narrows one concrete class of curve-selection backdoor theories while leaving some parameter-selection details unresolved.

Anthropic says Claude has reconstructed how the U.S. National Security Agency generated a set of public seeds submitted to standards bodies for NIST elliptic curves in 1997. The report is explicit about what this does not mean: AI did not break elliptic-curve cryptography, did not derive anyone’s private key, and did not suddenly make TLS or Bitcoin insecure. What it solved is a long-standing historical question in cryptography: where those published seeds came from.

The distinction is central. Calling it “AI breaks global encryption in 30 minutes” is wrong. Treating it as trivial number archaeology also misses the point. The report frames the result in four ways: it lowers the likelihood that a widely used set of NIST curves was deliberately backdoored; it shows that “verifiably random” parameters still leave half the trust chain unexplained if the original input is opaque; it suggests frontier models can now connect literature review, hypothesis generation, coding, statistical testing, and lattice methods in one research loop; and it points to a more immediate cryptographic impact from AI, not brute-forcing 256-bit keys, but auditing neglected protocols, implementations, and historical artifacts at very low cost.

What Claude reconstructed

The article first separates curve parameters from user secrets. An elliptic curve can be thought of as a shared lock design. Users on the same curve share public parameters, while each user generates a separate private key inside that system.

For prime-field curves, a common form is y² = x³ + ax + b (mod p). A full standard also specifies the field p, coefficients a and b, a base point G, the order n of that base point, and the cofactor h. Private keys are not those parameters.

FIPS 186-2, published in 2000, included curves such as P-192, P-224, P-256, P-384, and P-521. The NSA supplied the curves and 160-bit seeds, and the standard defined steps using SHA-1 to derive curve coefficients from those seeds. Anyone could verify that a published seed produced the published coefficient. The unresolved issue was simpler and deeper: why were those 160 bits chosen in the first place?

Why the seeds mattered

The report compares the problem to a lottery operator publishing the winning numbers and the drawing algorithm, but not showing which balls were loaded into the machine at the start or why those balls were chosen. If a designer had tested a large number of seeds and selected a curve with a hidden weakness, later observers could verify that the seed generated the curve without being able to rule out that earlier filtering step.

Cryptography often uses so-called “nothing-up-my-sleeve numbers,” values derived from public constants or public text through a fixed process. The point is not that such numbers are sacred. The point is that the selection process leaves no hidden knobs. In the NIST case, the seeds were public, but their origin was not explained. That made the output reproducible while leaving the source unauditable.

The distrust did not appear in a vacuum. After 2013, the NSA-backed random number generator Dual_EC_DRBG came to be widely viewed as carrying a backdoor risk for anyone who knew a special parameter relationship, and NIST later withdrew it. Dual_EC_DRBG is not the same issue as the NIST P curves discussed here, but the episode changed how much trust the field was willing to place in unexplained parameter choices. The report notes that Neal Koblitz and Alfred Menezes laid out the controversy in their 2015 paper A Riddle Wrapped in an Enigma, and that cryptographic engineer Filippo Valsorda and others put up a bounty in 2023 for anyone who could explain the seed origins.

From oral-history clues to a software-era hypothesis

The most widely circulated clue came from NSA mathematician Jerry Solinas, who had suggested the seeds might be hashes of joke phrases such as “pay Bob and Jerry more money.” Anthropic staff reportedly tried that lead and got nowhere. Solinas died in 2023, and the original code and files were not found, leaving the puzzle looking like it might remain unresolved.

According to the report, in October 2026 an Anthropic employee gave the problem to an internal research model whose exact version was not disclosed, and did so without telling it about the joke-phrase theory. Anthropic said in a research write-up published on Oct. 16 that the model found the generation method in under 30 minutes.

The key move was not brute-forcing English phrases. It was reframing the question: what software would an engineer in 1997 most likely have used to generate bytes that looked random?

How Claude landed on lrand48()

The report says Claude examined 34 legacy pseudorandom number generators and combinations of output slicing, sliding across the seed bits to look for traces of consecutive output. It found that some 32-bit words inside some seeds always had a top bit of 0. That is not a proof of insecurity, but it looks like a machine fingerprint. The POSIX/C library function lrand48() outputs only the top 31 bits of its 48-bit internal state, which leaves exactly that pattern.

For seeds that preserved more output bits, brute-forcing 17 hidden low bits was enough to recover the internal state. The harder case involved the five NIST prime curves and five ANSI X9.62 curves, where the generating program kept only fragments of lrand48() >> 23. Claude turned that into a truncated linear congruential generator state-recovery problem and then used the LLL lattice basis reduction algorithm to search for short vectors satisfying multiple approximate linear relations.

LLL recovered RNG state, not elliptic-curve secrets

The article stresses that LLL was not used here to break elliptic curves. It was used to stitch together many truncated arithmetic constraints efficiently. The analogy in the report is an old odometer: one reading does not reveal enough, but a sequence of readings, combined with the gear rules, can let you infer the hidden digits.

Once the 48-bit state was recovered, a linear congruential generator such as lrand48 could be run forward and backward. Claude then traced the state back to the form produced by srand48(t), where the low 16 bits are fixed at 0x330E, and interpreted the high bits as a Unix timestamp. The result was not a vague era but a set of specific UTC times in 1997 and 1998.

CurveUTC time for srand48Matching 20-byte candidate index
P-1921997-05-18 14:45:34139
P-5211997-08-08 01:12:041,136
P-2561997-08-16 01:52:341,842
P-3841997-08-30 14:50:082,688
P-2241998-04-03 12:52:077,026

The report gives P-256 as a concrete example. Initialize the generator with timestamp 871696354, follow the recovered byte-selection procedure, and the 1,842nd candidate yields the exact 160-bit seed published in the standard: C49D3608 86E70493 6A6678E1 139D26B7 819F7E90. Not a close match. A bit-for-bit match.

The article says coincidence is a poor explanation for that kind of result. More important, Valsorda independently rewrote the process in Go and reproduced the published seeds from the timestamps and candidate indices. That gives the conclusion an external check. The discovery came from Anthropic’s internal model, but the result does not depend on taking the model’s word for it.

Three different kinds of randomness

The report spends time on a confusion that often appears in coverage: three very different kinds of “random numbers” are being mixed together.

  • First, the curve-parameter seed. This is public design material. It determines which shared lock everyone uses. That is what was reconstructed here. Even if a weak clock-seeded lrand48 was used in 1997, the output was public from the start, so predicting it does not reveal user private keys.
  • Second, the randomness used for user private keys. If a wallet really generated private keys with lrand48 and a timestamp, those keys could in principle be guessed and funds could be stolen. The report says this finding does not show that NIST-curve users generated private keys that way.
  • Third, the nonce used in each ECDSA signature. Reused or predictable nonces can leak private keys, and that has happened in real systems. Modern implementations often use deterministic signing or extra randomness to reduce that risk. But that is not what was found here either.

That is why “the seed came from a weak PRNG” and “elliptic-curve cryptography was broken by a weak PRNG” sound similar while meaning opposite things. In this case, the reversibility of a weak generator helped researchers reconstruct a historical process. It did not weaken the elliptic-curve discrete logarithm problem, and it did not reduce the search difficulty for existing private keys.

What this does to the backdoor theory

The report argues that the main cryptographic significance is a sharp reduction in the designer’s apparent freedom of choice.

One hypothetical curve-selection backdoor does not require an obvious trapdoor in the equation itself. A designer could know how to recognize a very rare class of weak curves, test many seeds in secret, and keep only a curve that fits a weakness only they know how to exploit. The article cites a line of thought described by Daniel J. Bernstein and Tanja Lange: if the chooser had around 70 bits of freedom, they might be able to target a hypothetical weak-curve class of size about 2⁶¹.

The reconstructed timeline cuts that space down. Valsorda’s conservative estimate, as quoted in the report, is that even if the designer could choose any second in 1997–1998 and then choose any one of the first 16 valid candidates, the total freedom would be only about 30 bits. Thirty bits is not zero. But the article says it is far short of the roughly 70-bit freedom needed for that kind of directed search. That does not logically prove the NSA could not have known some unknown mathematics in 1997. It does rule out one of the most concrete and discussable seed-search backdoor mechanisms, making the “NOBUS backdoor hidden through massive seed search” story much harder to sustain.

What remains unresolved

The report keeps three caveats in view.

First, the generating process skipped some candidates that looked valid on the surface. For P-256, a prime-order curve satisfying known conditions already appeared at candidate 876, yet the final choice was candidate 1,842. The P-224 run also skipped three candidates. The team found one extra filtering rule, while another remains unclear. The article says skipping a small number of candidates is not the same as a backdoor. If a very rare weakness could be hit with so few choices, the weakness would not be very rare. Still, the full historical process has not been reconstructed end to end.

Second, the seed determines the curve coefficient b, not the base point G. Claude reportedly found the origin of the base point for P-192 and several ANSI example curves, but not yet for P-224, P-256, P-384, or P-521.

Third, the seed for the binary-field curve B-163 has not been recovered. Several other binary-field curves may have used an initialization method based on “time divided by two.” So the most accurate summary is not that every NSA-curve mystery is solved. It is that the seed origins for the five core NIST prime curves now have a reproducible explanation, the main seed-backdoor suspicion has faded substantially, and some parameter-selection details remain open.

TLS is relevant; Bitcoin is not

The article also pushes back on a common conflation. The finding is relevant to TLS, but not in the sense that “these seeds are the foundation of Bitcoin TLS digital signatures.” That line, the report says, stitches together separate layers that should not be merged.

TLS is the protocol used by browsers and servers to build secure connections. NIST P-256, also known as secp256r1, has long been used in TLS for key exchange or ECDSA certificate signatures, so the result does touch a curve deployed widely across the internet. The message, however, is increased confidence, not an emergency certificate rotation. Anthropic said there is no action users need to take.

Bitcoin uses a different curve: secp256k1. The names are similar, and both belong to the elliptic-curve family, but they are not the same curve and secp256k1 was not generated from the NSA seeds reconstructed here. The report notes that the SEC 2 standard gives secp256k1 the minimal-form equation y² = x³ + 7, and BIP 32 explicitly specifies secp256k1 for Bitcoin. Traditional Bitcoin transactions use ECDSA on that curve, while Taproot uses Schnorr signatures on the same curve.

So this result does not threaten Bitcoin private keys, does not explain why Satoshi Nakamoto chose secp256k1, and does not change the long-term question of whether future quantum computers could use Shor’s algorithm against elliptic-curve cryptography. The article compares the leap from “same family of curves” to “Bitcoin is broken too” to finding the design file for one lock and then declaring every metal-key lock compromised.

What the AI claim does and does not establish

If the answer is reduced to “it was a timestamp,” the result can sound almost plain. The weight lies in the path. Anthropic’s account says Claude proposed a hypothesis that ran against the popular oral-history story, wrote scanners, compared output structures across dozens of old PRNGs, identified lrand48 from statistical anomalies, invoked LLL for truncated outputs, recovered state, reversed the initialization form, and then validated the result against the full 160-bit seeds. Human researchers then organized, checked, and published executable code, and outside cryptographers independently rewrote and verified it.

The report calls that a small research loop: read the problem, form a hypothesis, design a test, write tools, handle failed paths, solve the math, cross-check, and produce a reproducible experiment. In that sense, the notable part is not that a model can explain LLL or code a linear congruential generator. It is that the model appears able to decide when those pieces belong together in a problem with no standard solution path.

Still, the article says the “under 30 minutes” claim needs careful reading. Cryptographers were not spending eight hours a day for 25 straight years brute-forcing this puzzle. Humans had already written the standards, proposed backdoor models, preserved the seeds, invented LLL, built the software, and framed the problem as a public bounty. The model stood on top of that full stack of knowledge and tools and found a combination that had not been seriously tested before. What it compressed was the marginal time of one research search, not 25 years of scientific accumulation.

Public materials also do not disclose the exact internal model version, the full raw session, failed branches, compute cost, or the details of human intervention during that half-hour window. So the reproducible part is the method and the result, because code now reproduces them. The stronger narrative about a fully autonomous model solving the problem in under 30 minutes comes mainly from Anthropic itself and is not yet a strict, repeatable benchmark for model capability. The report says those two things should be kept separate.

The nearer-term impact: cheaper audits of neglected black boxes

The article closes by arguing that this does not foreshadow AI brute-forcing P-256 private keys tomorrow. Under classical computation, mature elliptic-curve security still rests on the enormous hardness of the discrete logarithm problem. Being able to code and use LLL is not the same as crossing exponential complexity barriers.

The more immediate shift is elsewhere. Security systems contain many black boxes where the math is not broken, but the provenance is unclear, the implementation is old, and the composition is messy. Those systems often go unaudited not because they are unsolvable, but because the documentation is scattered, the test space is tedious, and the payoff is uncertain. The report argues that AI systems able to read old papers, generate probing code, and run tools for long stretches can cut the cost of that kind of audit sharply.

That cuts both ways. Defenders can batch-check standard parameters, look for weak-randomness fingerprints, and inspect historical code in the supply chain. Attackers can also move faster through obscure protocols, firmware, and in-house cryptographic systems. The report suggests the first systems likely to be opened up are not heavily audited standards such as AES, TLS 1.3, or mainstream curves, but systems that rely on secret implementations, vague parameters, and code no one has touched in decades.

Its policy takeaway is not panic abandonment of NIST curves. It is to make standards easier for machines to audit: generate parameters from public, non-manipulable entropy or precommitted data; publish full scripts, versions, and filtering rules; make proofs, reference implementations, and test vectors reproducible end to end; preserve full execution records for AI-assisted discoveries; separate model-only work from human prompting and post-processing; use models for defensive legacy audits while constraining network and execution privileges; and continue post-quantum migration without confusing quantum risk with this seed-origin result.

The article’s final line is that this is not a cryptographic disaster but an entry added to the trust ledger. For 25 years, people knew the NIST curves could withstand public scrutiny, but they did not know why those original numbers were there. Now there is an executable chain from a 1997 Unix clock through srand48, candidate indices, and published seeds. In the report’s framing, that changes the story from “trust that the NSA did not tamper with it” to “you can reproduce roughly how it was generated yourself.”

This article was originally published by Bit.Fan. For more cryptocurrency news and market insights, visit www.bit.fan.
12500

Disclaimer:

The market information, project data, and third-party content displayed on this platform are for industry information sharing only and do not constitute any form of investment advice or return commitment.

Cryptocurrency trading carries high risks. Users should fully assess their risk tolerance and make independent decisions. All profits, losses, and legal responsibilities are borne by the users themselves.