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.
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.
X25519MLKEM768pairs the classical X25519 exchange with the post-quantum ML-KEM-768 mechanism.[2] The hybrid is designed to protect recorded traffic if a future quantum computer can break the classical component.X25519on its own is classical key exchange. A reported TLS version of 1.3 tells you the protocol in use. Read the group name to see whether ML-KEM was involved.
🔑 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.
| Server setting | Visitor → proxyWhat a public checker sees | Proxy → 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
- Check each public hostname that handles sensitive traffic and record its negotiated group.
- Find where HTTPS terminates and confirm whether the proxy connects to the origin over HTTPS.
- Observe a fresh proxy-to-origin handshake. Record the selected group, hostname, and date.
- Repeat the checks after changes to your CDN, load balancer, or origin TLS settings.
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
- 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
- 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
- Cloudflare. (2026). Automatic key exchange to origins. Cloudflare SSL/TLS documentation. https://developers.cloudflare.com/ssl/origin-configuration/automatic-key-exchange/
- 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/
- 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