About a third use RSA or elliptic-curve encryption directly in their own code. Only seven have started on post-quantum, though Go's defaults are quietly doing a lot of that work. And most of the MD5 and SHA-1 we found was harmless.

What we found

  • 36 of 100 projects use RSA, elliptic-curve or Diffie-Hellman encryption directly in their own code or configuration. NIST deprecates all of these after 2030 and disallows them after 2035.
  • 7 of 100 name a post-quantum algorithm in their own code.
  • 17 of 19 Go programs already offer hybrid post-quantum key exchange in TLS, because they declare Go 1.24 or later. None of them had to write any code for it.
  • 46 of 100 use MD5 or SHA-1. When we checked 118 of those uses by hand, only 8 were security choices the project could change.

What we scanned

We took the most-starred projects on GitHub in Python, JavaScript, TypeScript, Go and Java, plus the most-starred Terraform projects, and scanned a copy of each one's main branch with Hard Keel Quantum Scan on November 20, 2026. The scan covered about 410,000 files. We left out lists, tutorials, language runtimes, encryption libraries and anything built to be insecure on purpose, because they would skew the numbers. The full method and its limits are at the end.

Language Projects RSA or elliptic curve MD5 or SHA-1
Go 21 13 14
Java 16 7 9
TypeScript 16 6 6
Python 20 5 12
JavaScript 15 1 3
Terraform 12 4 2
All 100 36 46

A third use quantum-vulnerable encryption directly

Of the 36 projects, 30 use RSA and 21 use elliptic curves (ECDSA, Ed25519 or ECDH). Fifteen use both. The uses fall into a few familiar groups:

  • Signing releases and updates. A program checks that an update really came from its maker.
  • Tokens. JWTs signed with RS256 or ES256, often to talk to another service's API.
  • Certificates and keys the project makes itself. Self-signed TLS certificates, SSH keys and cloud key settings in Terraform.
  • Key exchange. A few projects agree on keys with Diffie-Hellman in their own protocol.

Go projects were the most likely to do this, 13 of 21. Go's standard library makes it easy to generate a key or sign something in a few lines, and many of these projects are servers and networking tools that manage their own certificates. JavaScript projects were the least likely, 1 of 15.

This count only covers code that calls these methods itself. TLS handled by a library or a proxy isn't counted, so the real exposure is higher. That's the same blind spot most teams have about their own code.

Not all of these uses carry the same urgency. Key exchange comes first, because traffic recorded today can be decrypted once a large enough quantum computer exists. Signatures matter by 2035, and soonest where a key has to be trusted for years, such as an update-signing key built into devices already in the field.

Seven have started on post-quantum

Seven projects name a post-quantum algorithm in their own code:

  • Caddy, Traefik and Gitea let you choose hybrid post-quantum key exchange groups such as X25519MLKEM768 in their TLS settings. Caddy includes it in its defaults.
  • Keycloak supports ML-DSA signatures.
  • Bruno, the API client, offers hybrid key exchange when it connects to servers.
  • Tabby, the terminal, supports the hybrid mlkem768x25519 key exchange in its SSH client.
  • Netty can create ML-DSA certificates in its certificate-testing toolkit.

Go is doing a lot of the work for free

Since Go 1.24, Go's TLS offers hybrid post-quantum key exchange (X25519MLKEM768) by default unless a program sets its own list of key exchange groups. Go decides that default from the Go version a program declares in its go.mod file.

Of the 19 Go projects that build programs (the other two are libraries), 17 declare Go 1.24 or later. None of them switch the default off. The two that don't get it declare older Go versions, and would pick it up by raising that line. When both ends support it, a connection is protected against recording now and decrypting later, with no code change at all.

The same is true of anything built on OpenSSL 3.5 or later. For many teams, the quickest post-quantum win is keeping runtimes and TLS libraries current.

Most MD5 and SHA-1 was harmless

MD5 and SHA-1 turned up in 46 projects. Both are broken for security, so a scanner flags them. To see what that number means, we checked 118 uses by hand, the first few in each project:

What the hash was for Uses
IDs, cache keys and file checksums 73
Required by a protocol or service (NTLM, the WebSocket handshake, OAuth 1.0, cloud storage checksums, HTTP Digest) 30
Test code or placeholders 7
Security choices the project could change 8

The eight that matter include hashing a password or token with MD5, deriving an encryption key from MD5, using ECB mode, accepting TLS 1.0 and checking downloads with SHA-1.

So a raw count of MD5 is a poor measure of risk. Sort each use into one of these four groups. In Python, mark checksums with usedforsecurity=False so scanners and FIPS builds know. Where switching to SHA-256 is cheap, do it anyway and save the next person the question. Our guide to replacing weak encryption has the code for each language.

Terraform was mostly clean

Of the 12 Terraform projects, 9 had no exposed settings. The other three turned off certificate checks or opened ports to the whole internet somewhere in their configuration. Across all 100 projects, 10 had a setting like that. We didn't judge whether each one was deliberate.

What to take from this

  1. Make the list. A third of these well-run projects use quantum-vulnerable encryption in their own code. Yours probably does too. Our guide on finding it in your code covers where to look.
  2. Update runtimes and TLS libraries. Go 1.24 or later and OpenSSL 3.5 or later give you hybrid key exchange by default.
  3. Sort your MD5 and SHA-1 before you fix any of it. Most of it is probably fine.
  4. Plan your signing keys. Long-lived signing keys, especially for updates, need a replacement plan before NIST's 2035 cutoff.

Method and limits

  • Selection. The most-starred projects on GitHub per language in November 2026, excluding archived projects, forks, lists and tutorials, repositories over about 1 GB, language runtimes, encryption libraries, security test collections, deliberately vulnerable projects and cryptocurrency projects. The result was 20 Python, 15 JavaScript, 16 TypeScript, 21 Go, 16 Java and 12 Terraform projects.
  • Scan. Hard Keel Quantum Scan 0.1.0 on a shallow copy of each project's main branch. It matches patterns line by line, so encryption behind a wrapper can be missed. Test folders are skipped, but some test scripts in other folders were counted.
  • Direct use only. Dependencies, bundled libraries and TLS done by a library or proxy weren't counted.
  • Post-quantum. A separate text search for ML-KEM, ML-DSA, SLH-DSA, Kyber and the hybrid group names outside tests and documentation, with each hit checked by hand.
  • Hand-check. The 118 MD5 and SHA-1 uses were sorted from the line of code and its file, not a full review of each project.
  • Keys and passwords. The scanner also flags strings that look like keys or passwords. We didn't verify them, so we don't report a number. We kept no file names, lines or values.
  • Names. We name projects only for post-quantum work they've already done. We name no project for a weakness.

Sources

Originally published on hardkeel.com. Hard Keel Quantum Scan, the free and open-source scanner used here, is at hardkeel.com/quantum-scan.