The Post-Quantum Countdown: NIST Standards Are Live, Is Your Stack Ready?
This week, AWS announced that all new TLS connections to S3 and API Gateway negotiate with ML-KEM (Kyber), NIST's finalized post-quantum key encapsulation mechanism, as part of a hybrid classical/PQC handshake. Cloudflare, which has run X25519+Kyber in Chrome for two years, confirmed the same shift on their edge network.
The migration security teams kept deferring has started. The question is whether your application is ready, or quietly building up quantum debt.
Why post-quantum cryptography
The threat is "harvest now, decrypt later." An adversary captures TLS traffic today and stores it. When a cryptographically relevant quantum computer arrives, timelines range from 5 to 15 years, they decrypt it after the fact.
If your application holds data that must stay confidential for more than 5 years, health records, financial history, government data, trade secrets, that data carries risk today, with no quantum computer in sight.
RSA-2048 and ECDH P-256, the workhorses of modern TLS, fall to Shor's algorithm in polynomial time on a large enough quantum computer. The NSA already requires PQC for classified systems by 2030.
The NIST PQC standards
| Algorithm | Type | Purpose | Standard |
|---|---|---|---|
| ML-KEM (Kyber) | Lattice | Key encapsulation | FIPS 203 |
| ML-DSA (Dilithium) | Lattice | Digital signatures | FIPS 204 |
| SLH-DSA (SPHINCS+) | Hash-based | Digital signatures | FIPS 205 |
| FN-DSA (Falcon) | NTRU lattice | Digital signatures | FIPS 206 |
CRYSTALS-Kyber and CRYSTALS-Dilithium do most of the work. SPHINCS+ is the conservative fallback that relies only on hash function security.
What migrated, and what did not
Migrated by default in 2026:
- Chrome, Firefox, Safari all negotiate hybrid TLS with X25519MLKEM768
- AWS, GCP, and Azure TLS endpoints use hybrid handshakes on new connections
- Let's Encrypt certificate issuance offers ML-DSA signatures in beta
Still your responsibility:
- JWTs and API signing keys, still typically ECDSA or RSA
- Database encryption at rest, usually AES-256 (symmetric, quantum-resistant) with key wrapping that may use RSA
- SSH keys to your servers, still mostly Ed25519 (workable until around 2030, plan the move)
- Code signing certificates, where most CI/CD pipelines still use RSA-2048 or ECDSA
- mTLS between your own services, with self-managed certificates where you picked the algorithm
Auditing your stack: a developer checklist
# 1. Scan for RSA/EC key usage in your codebase
grep -rn --include="*.ts" --include="*.js" --include="*.py" \
"RSA\|createECDH\|generateKeyPair.*ec\|rs256\|es256" ./src
# 2. Check your TLS certificate algorithm
echo | openssl s_client -connect yourapp.com:443 2>/dev/null \
| openssl x509 -noout -text | grep "Public Key Algorithm"
# 3. List SSH keys in use
ssh-keygen -l -f ~/.ssh/id_rsa 2>/dev/null
ssh-keygen -l -f ~/.ssh/id_ed25519 2>/dev/null
Node.js: generating PQC-ready keys
The Web Crypto API does not yet support ML-KEM natively in Node.js 22, but @noble/post-quantum provides a pure-JS implementation:
import { ml_kem768 } from "@noble/post-quantum/ml-kem";
// Key generation
const { publicKey, secretKey } = ml_kem768.keygen();
// Encapsulation (sender side)
const { cipherText, sharedSecret: senderSecret } = ml_kem768.encapsulate(publicKey);
// Decapsulation (receiver side)
const receiverSecret = ml_kem768.decapsulate(cipherText, secretKey);
// senderSecret === receiverSecret ✓
The hybrid approach
Keep classical crypto in place. Run hybrid key exchange, classical ECDH plus ML-KEM in parallel, then hash the shared secrets together. You retain the classical guarantees and add quantum resistance. AWS and Cloudflare both take this path.
import { x25519 } from "@noble/curves/ed25519";
import { ml_kem768 } from "@noble/post-quantum/ml-kem";
import { sha256 } from "@noble/hashes/sha2";
function hybridKeyExchange(
ecPriv: Uint8Array,
ecPub: Uint8Array,
kemPub: Uint8Array
) {
const ecShared = x25519.getSharedSecret(ecPriv, ecPub);
const { cipherText, sharedSecret: kemShared } = ml_kem768.encapsulate(kemPub);
// Combine secrets via hash — neither alone is sufficient
const combined = sha256(new Uint8Array([...ecShared, ...kemShared]));
return { combined, cipherText };
}
Timeline for developers
| When | Action |
|---|---|
| Now | Audit key types in use. Find RSA/EC in signing and encryption paths. |
| Q2 2026 | Migrate API signing (JWTs) to ML-DSA. Update SSH keys to new PQC variants. |
| Q4 2026 | Rotate code-signing certs. Add hybrid TLS for internal services. |
| 2027 | Deprecate RSA below 4096 and EC below P-384 in internal systems. |
| 2030 | NSA mandate deadline for classified systems. Most enterprises should have finished migration. |
Harvest-now-decrypt-later traffic collection already happens. Standards are final, tooling is maturing, and cloud providers now cover public-facing connections.
What remains is the traffic between your services, the signatures your code produces, and the keys guarding your stores. Start that audit today.
Published March 12, 2026

Written by
Sutharsan G · Software Engineer, Tirunelveli, IN
Hi, I'm Sutharsan G. I engineer scalable web systems and autonomous AI agents with obsessive attention to detail. More about me · Editorial policy
