In the history of computer science, we have faced bugs like Y2K. We have faced vulnerabilities like Heartbleed. But we have never faced a mathematical extinction event. Y2Q (Years to Quantum) marks the point where a Quantum Computer becomes powerful enough to run Shor’s Algorithm at scale.

When this day arrives (estimated 2030-2035), the foundation of the modern internet—Public Key Cryptography—will collapse instantly.

RSA: Broken.
Elliptic Curve (ECC): Broken.
Diffie-Hellman: Broken.

Every TLS connection, every SSH session, every digital signature, and every Bitcoin wallet will be compromised.

At Maison Code Paris, we operate on “Centennial Time.” We build systems meant to last. This means we must engineer defenses today for the threats of tomorrow.

Why Maison Code Discusses This

At Maison Code Paris, we act as the architectural conscience for our clients. We often inherit “modern” stacks that were built without a foundational understanding of scale. We see simple APIs that take 4 seconds to respond because of N+1 query problems, and “Microservices” that cost $5,000/month in idle cloud fees.

We discuss this topic because it represents a critical pivot point in engineering maturity. Implementing this correctly differentiates a fragile MVP from a resilient, enterprise-grade platform that can handle Black Friday traffic without breaking a sweat.

The Strategy: Harvest Now, Decrypt Later

Why care today? You don’t have a Quantum Computer. Neither does North Korea (probably). However, intelligence agencies and bad actors are currently executing a strategy called Harvest Now, Decrypt Later (HNDL). They are intercepting and storing encrypted traffic (HTTPS/VPN) en masse. It looks like noise to them today. Ideally, it stays on a hard drive for 10 years. In 2035, they buy a Quantum Computer, run the key derivation, and retroactively decrypt the traffic.

Your trade secrets.
Your customers’ SSNs.
Your private communications. They are already compromised. The only defense for HNDL is to have used Quantum-Resistant encryption today.

The Math: Why RSA Falls and Lattices Stand

Classical Vulnerability

Traditional asymmetric encryption relies on the difficulty of Factoring Large Primes (RSA) or the Discrete Logarithm Problem (ECC). For a classical computer, finding the factors of a 2048-bit number takes billions of years. For a Quantum Computer, using Shor’s Algorithm, it is a polynomial time problem. It takes hours. Shor’s algorithm uses the property of quantum superposition to find the “period” of a function, which reveals the prime factors.

Post-Quantum Hope: Lattices

NIST (National Institute of Standards and Technology) has standardized new algorithms based on math problems that not even quantum computers are good at. The winner is Lattice-Based Cryptography.

Imagine a 500-dimensional grid (lattice). I pick a point on a grid intersection. I add a tiny bit of “noise” (error) to move it slightly off the intersection. The Problem: Given the noisy point and the grid definition, find the original intersection. This is the Learning With Errors (LWE) problem. Solving this in 500 dimensions is exponentially hard for both classical and quantum machines.

The NIST Standards (PQC)

After a 6-year competition, NIST announced the survivors in 2024.

1. Key Encapsulation Mechanism (KEM): ML-KEM (Kyber)

This replaces Diffie-Hellman Key Exchange.

Usage: TLS Handshakes (HTTPS), VPN Key Exchange.
Performance: Extremely fast (faster than current RSA/ECC operations).
Cost: Larger Keys.
- RSA-2048 Public Key: 256 bytes.
- Kyber-768 Public Key: 1,184 bytes.
- This fits in a TCP packet, so it’s viable for the web.

2. Digital Signatures: ML-DSA (Dilithium)

This replaces RSA Signatures and ECDSA.

Usage: Signing software updates, Identity Verification, TLS Certificates.
Cost: Much Larger Signatures.
- Ed25519 Signature: 64 bytes.
- Dilithium3 Signature: 3,293 bytes.
- This is heavy. It bloats the handshake.

3. The Backup: SPHINCS+

This is Hash-based cryptography. It is incredibly slow and produces massive signatures (40KB - 7KB). Why keep it? Because it is not based on Lattices. If a mathematician suddenly breaks Lattice math tomorrow, we have SPHINCS+ as a fallback.

Implementation: Crypto Agility

The most dangerous thing you can do is hardcode Alg = "RSA" in your database. You must adopt Crypto Agility. Your system must support swapping the underlying cryptographic primitive without rewriting the application logic.

Hybrid Key Exchange

We are in a transition period. We trust ECC (it’s battle-tested). We think Kyber is safe (but it’s new). Solution: Use Both. Combine a classical key exchange (X25519) with a quantum one (Kyber768). Keyshare = X25519_Share || Kyber768_Share To break this, an attacker must break both algorithms.

Configuring Cloudflare / AWS

If you use a major CDN, you can often enable this today with a checkbox. Cloudflare: Supports X25519Kyber768 hybrid key agreement. Checking this box protects your traffic against HNDL attacks immediately.

Symmetric Encryption (AES)

Good news: AES-256 is Quantum Resistant. There is a quantum algorithm called Grover’s Algorithm that can search unsorted databases. It effectively halves the bit-strength of symmetric keys.

AES-128 becomes 64-bit effective strength (Cracked).
AES-256 becomes 128-bit effective strength (Safe). Action: Audit your database encryption. If you use AES-128, upgrade to AES-256 immediately.

The Performance Cost

PQC is CPU-efficient, but Bandwidth-heavy. Because Kyber/Dilithium keys are larger, the initial TLS handshake grows by ~4-5KB. On a fast 5G connection, this is negligible (<5ms). On a slow IoT connection (LoRaWAN / 2G), this is catastrophic. It might cause packet fragmentation.

For constrained environments, we might look at Falcon (another NIST finalist), which has smaller signatures but requires complex floating-point math (making it hard to implement securely without side-channel leaks).

Code Example: Using `liboqs` (Node.js)

The Open Quantum Safe (OQS) project provides C libraries for these algorithms.

// This is illustrative. Use 'liboqs-node' wrapper.
const oqs = require('liboqs');

function quantumKeyExchange() {
  const kem = new oqs.KeyEncapsulation('Kyber768');
  
  // 1. Alice generates Keypair
  kem.generate_keypair(); 
  const public_key = kem.export_public_key();
  
  // 2. Bob encapsulates a shared secret
  // (Bob sends 'ciphertext' over the wire to Alice)
  const { ciphertext, shared_secret_bob } = kem.encapsulate_secret(public_key);
  
  // 3. Alice decapsulates using her private key
  const shared_secret_alice = kem.decapsulate_secret(ciphertext);
  
  // Now Alice and Bob both have the same shared_secret
  // They use this to derive an AES-256 session key.
  assert(shared_secret_alice.equals(shared_secret_bob));
}

10. The Migration Roadmap (2025-2030)

You cannot migrate overnight.

Phase 1 (2025): Inventory. Find every certificate, every SSH key, every JWT signing key. Update Cloudflare/AWS to support Hybrid Key Exchange.
Phase 2 (2027): Internal PKI. Upgrade your internal CA (HashiCorp Vault) to issue Hybrid Certificates.
Phase 3 (2029): Data Resealing. Re-encrypt old database backups (AES-128 -> AES-256).
Phase 4 (2030): Deprecation. Turn off RSA support. If you start in 2029, you will fail.

11. Mythbusting: Quantum Key Distribution (QKD)

Vendors will try to sell you QKD Hardware (Physics-based satellites/fiber optics). “Unbreakable keys via physics!” Ignore them. The NSA and NCSC (UK) both recommend Post-Quantum Cryptography (Math), not QKD (Physics). QKD requires dedicated hardware lines, has distance limits (100km), and introduces hardware vulnerabilities. Math is free. Physics is expensive. Stick to the NIST math standards.

13. The Blockchain Impact (Bitcoin and Ethereum)

Bitcoin addresses (P2PKH) are hashes of public keys. They are technically quantum-resistant until you spend from them (revealing the public key). However, many old “Satoshi Era” coins use P2PK (Pay to Public Key). These are vulnerable. Ethereum accounts are ECDSA. Vulnerable. If you hold crypto assets for your company, you must watch the “Quantum Hard Fork” roadmap of these chains. You will likely need to migrate your funds to a new “Quantum Wallet” address standard around 2028.

14. The NIST Timeline Details

Start preparing now.

2024: Standards Published (FIPS 203, 204, 205).
2025-2030: Vendor Rollout (Browser support, OS support).
2030-2033: Disallow RSA usage in government.
2035: Y2Q Window opens. If you are building a system today with a 10-year lifespan (e.g., IoT Device, Car, satellite), you are already late.

15. Conclusion

The “Quantum Apocalypse” sounds like science fiction, but the National Security Agency (NSA) has already issued a directive (CNSA 2.0) requiring all National Security Systems to migrate to PQC by 2033.

The clock is ticking. You do not want to be the engineer explaining why the CEO’s emails from 2025 were decrypted in 2030 because you didn’t flip a toggle in the load balancer config.

Future-Proof your Stack

Do you rely on RSA for long-term data storage?

Hire our Architects.