Back to blog

Cracking a 1024-bit DKIM Key

Cost, Timeline, and Why It's Closer Than You Think

Published: March 04, 2026

Updated on November 18, 2026. Two GPU factoring records from September 2026, RSA-260 and RSA-896, replace the CPU-only baseline of the first version. The cost estimate for a 1024-bit key drops from $40M–$120M to about $30M, and the run time from one or two years to about five to six months. The CPU price per core, the timeline table and the memory figure for the matrix step are corrected.

Your DKIM public key is sitting in DNS right now. Anyone can read it. If you're still using a 1024-bit RSA key, the question isn't whether it can be cracked. It's how much it would cost.

Let's do the math.

 

NIST already called it

NIST Special Publication 800-131A Rev. 2 (March 2019) is the definitive reference here. In Table 2, Section 3, the status of RSA keys shorter than 2048 bits for digital signature generation is one word:

Not deprecated. Not legacy use. Disallowed.

A 1024-bit RSA key provides roughly 80 bits of security strength. NIST requires a minimum of 112 bits for federal use. That minimum maps to 2048-bit RSA.

NIST defines "disallowed" in SP 800-131A Rev. 2 [1] as:

"The algorithm or key length is no longer allowed for applying cryptographic protection."

1024-bit keys are only permitted in "legacy use" mode, meaning you can still verify old signatures but must not generate new ones.

The draft of SP 800-131A Rev. 3 (initial public draft, October 2024) [2] goes further. It deprecates the 112-bit security strength for classical digital signatures and key establishment after December 31, 2030. That covers RSA-2048. NIST chose "deprecated" rather than "disallowed" and does not require a move to RSA-3072 (128-bit security) in between. The draft proposes one transition from 112-bit keys to quantum-resistant algorithms instead of two.

 

The factoring records

The algorithm that cracks RSA keys is the General Number Field Sieve (GNFS). It's been used to set every modern factoring record.

RSA-250 (829 bits) was factored in February 2020 by Boudot, Gaudry, Guillevic, Heninger, Thomé, and Zimmermann [6][7]. The total computation time was roughly 2,700 core-years using Intel Xeon Gold 6130 CPUs at 2.1GHz. Sieving took 2,450 core-years and the matrix step took 250 core-years.

RSA-240 (795 bits) was factored in 2019 using approximately 900 core-years [6].

RSA-260 (862 bits) was factored on September 3, 2026 by Eric Lu at Cognition [11]. The run used GPUs instead of CPUs, with a modified version of CADO-NFS, the software behind the two earlier records. It took about 4,900 GPU-days (13.5 GPU-years) over 15.6 days. Cognition puts the cost at about $400,000 at market GPU prices.

RSA-896 (896 bits) followed on September 19, 2026. Stephen Weis at Anthropic factored it with Claude, which ported CADO-NFS to GPUs [12]. The run took about 30 GPU-years over 10 days, on a fleet of up to 2,048 H100 GPUs. In both runs an AI coding agent did the GPU port.

RSA-1024 (1024 bits) has never been publicly factored.

 

Extrapolating to 1024 Bits

The GNFS complexity scales as:

L(n) = exp( c · (log n)1/3 · (log log n)2/3 )

where c ≈ 1.923 and log denotes the natural logarithm. Running this formula for 829 bits (RSA-250) versus 1024 bits gives a scaling factor of 200x. From 795 bits (RSA-240) the factor is 543x. From 862 bits (RSA-260) it is 78x, and from 896 bits (RSA-896) it is 30x.

That gives us a range:

Basis Multiplier Estimate for RSA-1024

RSA-240 (900 core-years)

543x

~489,000 core-years

RSA-250 (2,700 core-years)

200x

~540,000 core-years

Published estimate from 2015 [13]

Sieving 1,000,000 + matrix 120,000

~1,120,000 core-years

RSA-260 (13.5 GPU-years)

78x

~1,050 GPU-years

RSA-896 (30 GPU-years)

30x

~900 GPU-years

The CPU records point to roughly 500,000 core-years, and the published estimate to about 1.1 million [13]. The GPU records change the unit. At the efficiency of the two GPU runs, RSA-1024 takes about 900 to 1,050 GPU-years.

The matrix step is a small share of that work. Linear algebra took about 9.5% of the RSA-260 run [11] and about 11% of the published estimate [13]. Scaling the RSA-896 matrix of 1.48 billion rows [12] gives about 8 billion rows at 1024 bits. An estimate by Thorsten Kleinjung gives 6 to 12 billion rows and 4 to 5 TB of memory to store the matrix [14].

 

The cloud cost calculator

GPUs are the cheap route. Cognition prices GPU time at $3.50 per GPU-hour [11], and both rows below use that rate.

Basis GPU-years Cost at $3.50 per GPU-hour

RSA-260

~1,050

~$32M

RSA-896

~900

~$28M

Cognition's own estimate for RSA-1024 is about $30M, and its author expects that moderate further work could halve it [11].

CPUs cost more. On Alibaba Cloud ECS, a compute-optimized ecs.c6.large (2 vCPU) costs approximately $0.06/hour on pay-as-you-go pricing in the mainland China regions [9]. The 2 vCPUs are the two threads of one physical core, and the CPU records count physical cores [6]. That makes $0.06 per core-hour, or roughly $526 per core-year.

Scenario Core-years On-demand Spot (~70% off)

Optimistic

500,000

$263M

$79M

Mid-range

750,000

$394M

$118M

Pessimistic

1,120,000

$589M

$177M

A well-funded attacker could crack a 1024-bit RSA key for about $30M in rented GPU time. On cloud CPUs, even aggressive use of spot instances leaves the bill at $80M to $180M.

For comparison, the Shamir and Tromer estimate from 2003 [4] suggested that a custom-built ASIC device could finish the sieving step for RSA-1024 in less than a year for approximately $10M (in 2003 dollars). With 20+ years of Moore's law improvements, a purpose-built hardware approach would likely be cheaper today, though nobody has publicly built one.

 

Timeline: how fast?

The sieving step is embarrassingly parallel. A larger fleet shortens the run and leaves the bill unchanged, because the total GPU-years stay the same.

GPUs Compute time Cost

2,048

~5 to 6 months

~$30M

5,000

~2 to 2.5 months

~$30M

10,000

~5 weeks

~$30M

20,000

~2.5 weeks

~$30M

The matrix step sets the lower limit. It runs on a tightly coupled cluster and cannot spread over a larger fleet the way sieving does. Its longest stage took 54 hours for RSA-260 [11] and 59 hours for RSA-896 [12]. Scaled by the same factors, that stage takes about two to six months at 1024 bits on clusters of the same size, so the shorter runs in the table need a larger matrix cluster as well. Memory is not the obstacle. A matrix of a few terabytes fits in a handful of high-memory cloud instances, such as Alibaba's ecs.r7.32xlarge with 1 TB of RAM.

 

Why DKIM is a special case

Here's what makes DKIM different from TLS or S/MIME:

The public key is published in DNS. No need to intercept traffic or perform a man-in-the-middle attack. Just query selector._domainkey.example.com and you have the raw public key material. You can check your own DKIM key length right now and see exactly what an attacker sees.

DKIM keys rarely rotate. Many organizations set their DKIM key once and forget it for years. A cracked key stays useful for as long as the DNS record exists.

A single key compromise is devastating. Once you have the private key, you can forge emails from that domain that pass DKIM, SPF alignment, and DMARC. Phishing emails from a trusted domain with valid authentication are the holy grail for attackers.

You don't need real-time cracking. Unlike TLS where you need the session key quickly, DKIM key cracking can take months. The key will still be valid when you're done.

 

What this means for Your domain

A 1024-bit DKIM key is not going to be cracked by a random script kiddie. The price tag of about $30M puts this in the territory of nation-states, well-funded criminal enterprises and organizations that already run a GPU data center.

But that's exactly the point. If your domain is a target for state-sponsored phishing, or if you're in finance, government, healthcare, or critical infrastructure, a 1024-bit DKIM key is a known weakness.

The fix is straightforward. Start by running a DKIM check on your domain to see which selectors are active and what key sizes they use. Then:

  1. Upgrade to 2048-bit RSA keys

    (the current minimum recommendation)

  2. Consider 4096-bit keys

    if your DNS provider supports them (watch out for UDP packet size limits)

  3. Rotate your keys regularly

    (twice a year)

  4. Monitor with DMARC

    to detect unauthorized use of your domain

 

Time to Act

About $30M to crack a DKIM RSA-1024 key sounds like a lot, but consider what that buys.

As of November 2026, both apple.com and microsoft.com still publish 1024-bit RSA DKIM keys in their DNS. Anyone can verify this right now. Crack one of those keys and you can send perfectly authenticated emails from @apple.com or @microsoft.com to anyone on the planet. DKIM passes. DMARC passes. The email lands in the inbox, not the spam folder.

Now think about what a single well-crafted email from @apple.com is worth to an attacker. A fake password reset to a Fortune 500 CEO. A fraudulent wire transfer instruction from @microsoft.com to a CFO who trusts Microsoft email implicitly. A supply chain attack targeting thousands of developers through a spoofed security advisory. The FBI's IC3 reported $2.77 billion in business email compromise losses in 2024 alone, and those attacks typically rely on lookalike domains that careful recipients can spot. A DKIM-authenticated email from the real domain? There's nothing to spot.

$30M is not expensive. It's a rounding error compared to the potential return. For a nation-state running an intelligence operation, it's a line item. For an organized crime syndicate running BEC at scale, it pays for itself with a single successful wire fraud against a large target.

A 1024-bit DKIM key provides 80 bits of security. That's below the minimum standard NIST mandated in 2011, with a final transition deadline of December 31, 2013. Rented GPUs have made the cost of factoring these keys drop from "theoretical" to "expensive but achievable." The question is no longer whether someone can afford to do this. It's whether the target is worth it. And if your domain is apple.com or microsoft.com, the answer is obviously yes.

Don't wait for someone to prove it. Rotate your DKIM keys today.


References

  1. Barker, E. & Roginsky, A. (2019). Transitioning the Use of Cryptographic Algorithms and Key Lengths. NIST SP 800-131A Rev. 2. https://doi.org/10.6028/NIST.SP.800-131Ar2

  2. NIST SP 800-131Ar3 Initial Public Draft (October 2024). Transitioning the Use of Cryptographic Algorithms and Key Lengths. https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar3.ipd.pdf

  3. Rose, S. (2017). Defining Elliptic Curve Cryptography Algorithms for use with DKIM. IETF Draft. https://datatracker.ietf.org/doc/html/draft-ietf-dcrup-dkim-ecc-00

  4. Shamir, A. & Tromer, E. (2003). Factoring Large Numbers with the TWIRL Device. CRYPTO 2003, LNCS 2729, pp. 1-26. Springer.

  5. Lenstra, A.K., Tromer, E., Shamir, A., Kortsmit, W., Dodson, B., Hughes, J. & Leyland, P. (2003). Factoring Estimates for a 1024-Bit RSA Modulus. ASIACRYPT 2003, LNCS 2894, pp. 55-74. https://doi.org/10.1007/978-3-540-40061-5_4

  6. Boudot, F., Gaudry, P., Guillevic, A., Heninger, N., Thomé, E. & Zimmermann, P. (2020). Comparing the Difficulty of Factorization and Discrete Logarithm: A 240-Digit Experiment. CRYPTO 2020, LNCS 12171, pp. 62-91. https://doi.org/10.1007/978-3-030-56880-1_3

  7. Boudot, F. et al. (2020). Factorization of RSA-250. CADO-NFS announcement.

  8. Kleinjung, T. et al. (2010). Factorization of a 768-Bit RSA Modulus. CRYPTO 2010, LNCS 6223, pp. 333-350. https://doi.org/10.1007/978-3-642-14623-7_18

  9. Alibaba Cloud ECS Pricing. https://www.alibabacloud.com/en/product/ecs (see Pricing tab)

  10. NIST SP 800-57 Part 1 Rev. 5. Recommendation for Key Management: General. https://doi.org/10.6028/NIST.SP.800-57pt1r5

  11. Lu, E. (2026). Factoring RSA-260. Cognition. https://cognition.com/blog/factoring-rsa-260

  12. Weis, S.A. (2026). RSA-896. https://saweis.net/posts/rsa-896.html

  13. Adrian, D. et al. (2015). Imperfect Forward Secrecy: How Diffie-Hellman Fails in Practice. ACM CCS 2015. https://weakdh.org/imperfect-forward-secrecy-ccs15.pdf

  14. Kleinjung, T. Estimates for factoring 1024-bit integers. IPAM workshop slides, UCLA. https://helper.ipam.ucla.edu/publications/scws4/scws4_6649.pdf

 

Is your domain really protected?

Enter your domain to run a live DMARC check and see how easy it for others to spoof your domain.

No sign-up required. Safe to try on any domain.

More articles

Bulletproof emails with DMARC

Check domain and follow the instructions to nail down your DMARC configuration.
No expert knowledge needed!