Is Your Website Quantum-Safe? How to Check Both TLS Connections

Type: Practical Guide
Published: November 2026
Keywords: Post-Quantum TLS, Hybrid Key Exchange, X25519MLKEM768, CDN, Origin Server

Abstract

Run a post-quantum check on your website and you might get a green result. If you use a content delivery network (CDN), that result only covers the connection between your visitors and the CDN. The CDN opens a second connection to your web server, carrying the same data, often across the public internet. If that connection uses classical key exchange, recorded traffic could still be decrypted by a future quantum computer. In our test, a public checker would show the same green result whether or not the server behind the CDN supported post-quantum key exchange. This guide shows how to check the second connection from your side, using your CDN’s logs or your server.

Key Points at a Glance

  • A public domain check reports the key exchange negotiated with the HTTPS endpoint it reached. Behind a CDN, that endpoint is the CDN.
  • If a CDN terminates HTTPS, check the CDN’s connection to your origin server separately.
  • For that second connection, look for the group selected in an actual handshake. A list of supported groups tells you what the server can negotiate, not what it actually chose with your CDN.

Start with connection 1: see which key exchange your public hostname negotiates.

Check your domain for free →

1. Where the two TLS connections come from

Post-quantum key exchange is still the exception on the wider web. In a November 6, 2026 preprint, Haque and colleagues found it on 816 of 8,960 IP addresses with successful HTTPS connections in their scan, about 9.1%.[1] If your site does show a green result, it is worth checking which connection that result actually covers.

Browser Your visitor
TLS connection 1 Public checkers test this
CDN Edge server
TLS connection 2 Check separately
Web server Your origin
The browser connects to the CDN first. When the CDN fetches content from the web server over HTTPS, it opens a second TLS connection.

The CDN can return cached content or ask your original web server, called the origin, for a response. When it fetches from the origin over HTTPS, the CDN acts as a TLS client and negotiates a fresh set of keys when opening that connection. Sites serving HTTPS directly have a single browser-to-server connection to check. If your CDN fetches from the origin over plain HTTP, that leg has no TLS handshake at all.

The second connection matters because it carries the same pages, logins and form data as the first. In a typical setup it crosses the public internet, where traffic can be recorded today and decrypted later. If your CDN reaches the origin over a private link or tunnel instead, that path has less exposure, but it is still worth knowing what it negotiates.

2. Check the public hostname

Enter the exact hostname visitors use, such as www.example.com, and inspect the Key exchange field. If your login or API uses a different hostname, check it separately. A successful result applies to the endpoint the checker reached at that time. Results can vary across addresses or clients.

🔑 Key exchange is not certificate authentication

Key exchange establishes the secrets that protect traffic. Certificate signatures authenticate the server separately. A connection can negotiate hybrid key exchange and still authenticate the server with an RSA or ECDSA certificate. A green result describes the key exchange the checker observed, not the certificate. Our browser comparison explains why certificates are still classical.

3. Verify what the CDN negotiated with the origin

Start with the system that terminates the CDN’s HTTPS connection, which could be a load balancer rather than the application server. Use a test URL that makes the CDN fetch from the origin, and check that the request reaches the origin. Then look at CDN or origin-side telemetry that records the negotiated TLS key exchange group for that connection.

⚠️ “Supported” is not the same as “negotiated”

A scanner or config file showing that your origin supports X25519MLKEM768 tells you what the server can do. It does not tell you what your CDN offered or what the two sides selected. Also make sure you are looking at a fresh handshake: a cache hit or a reused connection may produce no new handshake at all.

If you use Cloudflare

Cloudflare’s Automatic Key Exchange documentation explains how its origin probes decide which groups to offer on the connection to your origin.[3] The ClientTLSKeyExchangeGroup log field describes the visitor connection, not the origin leg.[4] For the origin leg, look for a record of the actual handshake at your TLS termination point.

If you can only probe the origin yourself

A direct probe from your own network shows what the origin can negotiate with that particular client. Record it as origin capability, and keep the CDN’s negotiated group marked as unverified until you have seen a handshake from the CDN itself.

4. Our test: same green result, different protection

To show why a green result says nothing about the second connection, we built a small test: a reverse proxy standing in for the CDN, in front of a test web server. The proxy accepted the visitor’s HTTPS connection and fetched the page from the server over its own TLS connection. We ran it twice, once with the server limited to classical key exchange and once with hybrid key exchange enabled.

Negotiated TLS 1.3 groups in the reverse-proxy lab
Server settingVisitor → proxyWhat a public checker seesProxy → serverHidden from public checkers
Classical only X25519MLKEM768Hybrid X25519Classical only
Hybrid enabled X25519MLKEM768Hybrid X25519MLKEM768Hybrid

The visitor’s side was hybrid in both runs, so a public checker would have shown the same green result each time. Only the trace on the server side showed that the proxy-to-server connection switched from classical to hybrid once we enabled it. On a real site, that server-side record is the only way to tell which case you are in.

🔬 Lab setup

Node.js 24.21.0 with OpenSSL 3.6.5. The proxy and origin ran in one isolated process and carried TLS over in-memory streams instead of a network. That does not affect group selection, which happens entirely in the handshake messages. Both runs opened fresh TLS sessions and returned HTTP 200 with the expected origin response. We read the selected group from the final ServerHello on each leg using OpenSSL’s TLS trace.[5]

5. Checklist for your site

Further Reading

For which browsers offer hybrid key exchange by default, and why certificates are still classical, read Is Your Browser Quantum-Safe? Chrome, Safari, Firefox and Edge Compared.

For a closer look at how the hybrid group combines its two components:

Read: X25519+ML-KEM-768 Hybrid Key Exchange →

How to Cite This Article

APA: PostQuantumSecurity.org. (2026, November 15). Is Your Website Quantum-Safe? How to Check Both TLS Connections. https://www.postquantumsecurity.org/publications/website-tls-pqc.html

IEEE: PostQuantumSecurity.org, "Is Your Website Quantum-Safe? How to Check Both TLS Connections," Nov. 15, 2026. [Online]. Available: https://www.postquantumsecurity.org/publications/website-tls-pqc.html

LaTeX/BibTeX:

@misc{pqcryptography_website_tls_pqc,
  author       = {{PostQuantumSecurity.org}},
  title        = {Is Your Website Quantum-Safe? How to Check Both TLS Connections},
  year         = {2026},
  month        = nov,
  day          = {15},
  url          = {https://www.postquantumsecurity.org/publications/website-tls-pqc.html}
}

References

  1. Haque, M. A., Vinberg, S., Edwards, B., & Cruz, J. (2026, November 6). Empirical Assessment of Post-Quantum Cryptography Adoption Status in TLS [Preprint]. arXiv:2611.09707. https://arxiv.org/abs/2611.09707
  2. Kwiatkowski, K., Kampanakis, P., Westerbaan, B. E., & Stebila, D. (2026, August). Post-Quantum Traditional (PQ/T) Hybrid Key Agreement Mechanisms for TLS 1.3 (RFC 10024). IETF. https://www.rfc-editor.org/rfc/rfc10024.html
  3. Cloudflare. (2026). Automatic key exchange to origins. Cloudflare SSL/TLS documentation. https://developers.cloudflare.com/ssl/origin-configuration/automatic-key-exchange/
  4. Cloudflare. (2026, August 20). Per-zone post-quantum visibility in Logpush and Log Explorer. Cloudflare changelog. https://developers.cloudflare.com/changelog/post/2026-08-20-pqc-key-exchange-visibility/
  5. Node.js. (2026). TLS (SSL): tlsSocket.enableTrace(). Node.js v24.21.0 documentation. https://nodejs.org/download/release/v24.21.0/docs/api/tls.html#tlssocketenabletrace