Dev.to Security 🔐 Cybersecurity 👁 0 📖 8 min read

Azure Front Door Now Negotiates Post-Quantum TLS by Default. Here Is How to Check Your Own Endpoint

If your app sits behind Azure Front Door, the TLS handshake between your users and the edge may already be post-quantum hybrid, and you did not have to change anything. Microsoft turned it on by default in early November

If your app sits behind Azure Front Door, the TLS handshake between your users and the edge may already be post-quantum hybrid, and you did not have to change anything. Microsoft turned it on by default in early November 2026.

I read the Microsoft announcement and the new Front Door docs on Microsoft Learn, then tested the client side commands against a local OpenSSL 3.5 server so I could show you what real output looks like. Everything below comes from those sources. Where the docs do not say something, I do not guess.

TL;DR

  • Front Door now negotiates hybrid post-quantum key exchange for TLS 1.3 on client connections. Hybrid means a classical elliptic curve exchange combined with ML-KEM, the NIST standardized key encapsulation mechanism.
  • The default Standard key exchange policy offers SecP256r1MLKEM768, X25519MLKEM768, prime256v1, secp384r1 and secp521r1.
  • No action is required. The default prefers a hybrid group the client supports, then falls back to a classical one.
  • It covers client to Front Door only. The separate Front Door to origin connection is not configured by this policy.
  • Custom domains on Front Door Standard and Premium can pick Standard, Enhanced or Custom key exchange policies. Default *.azurefd.net domains always use Standard.
  • You can check it with openssl s_client on OpenSSL 3.5, curl, or the Security tab in Chrome or Edge DevTools.

What actually changed

TLS 1.3 negotiates a "group", which is the method client and server use to agree on a shared secret. Microsoft's Windows PQC FAQ puts it simply: the group is how keys are agreed, the cipher suite is how those keys protect the traffic. They are separate settings.

The risk Microsoft is addressing is "harvest now, decrypt later". Someone records encrypted traffic today and waits for a quantum computer that can break the classical key exchange. Certificates and signatures matter less for that specific threat, because an attacker would need the quantum computer at the time of the connection, not later. That is why the industry is moving key exchange first and leaving certificates classical for now.

A hybrid group runs both exchanges and combines the results. Microsoft's announcement says the session stays protected if either component remains secure, so you are not betting everything on a young algorithm.

Front Door terminates TLS at the point of presence nearest the user, which makes it a high leverage place to roll this out. Thousands of apps get it without each backend team doing a migration.

The groups Front Door supports

The new TLS key exchange policy page on Microsoft Learn lists everything:

Group What it is TLS versions
X25519MLKEM768 X25519 + ML-KEM-768 1.3 only
SecP256r1MLKEM768 P-256 + ML-KEM-768 1.3 only
SecP384r1MLKEM1024 P-384 + ML-KEM-1024 1.3 only
prime256v1, secp384r1, secp521r1 Classical NIST curves 1.2 and 1.3
X25519 Classical 1.2 and 1.3

And the three policies:

Policy Groups
Standard (default) SecP256r1MLKEM768, X25519MLKEM768, prime256v1, secp384r1, secp521r1
Enhanced SecP256r1MLKEM768, prime256v1, secp384r1, secp521r1 (no X25519 based groups)
Custom Any mix of the seven groups above

Two details stood out when I compared the tables. First, plain classical X25519 is not in Standard. It is only available through Custom. Second, SecP384r1MLKEM1024 is also Custom only. The docs also point out that "Standard" is the name of the key exchange policy, not the Front Door pricing tier, which is going to confuse someone in a meeting.

Do you need to configure anything?

For most apps, no. Microsoft says hybrid PQC for TLS 1.3 is enabled by default with no customer action, and existing profiles default to Standard without a migration.

If you do want to change it, the setting lives on the custom domain, next to the existing TLS policy but separate from it:

  • The TLS policy controls minimum protocol version and cipher suites.
  • The TLS key exchange policy controls the groups.

The rule that will bite people: hybrid groups only work with TLS 1.3. If your TLS policy still allows TLS 1.2 and you build a Custom key exchange policy with only hybrid groups, TLS 1.2 clients cannot connect. The docs say to include at least one classical group in that case.

Which clients will actually use it

Both sides have to support a hybrid group, otherwise the handshake quietly uses a classical one. Here is what I could confirm from first party sources:

  • Chrome switched its hybrid key share to ML-KEM (X25519MLKEM768, codepoint 0x11EC) in Chrome 131, per Google's security blog.
  • Edge and Chrome current versions support hybrid TLS 1.3, according to Microsoft's Windows PQC FAQ.
  • Go 1.24 and later enable X25519MLKEM768 by default in crypto/tls when Config.CurvePreferences is nil.
  • OpenSSL 3.5 offers X25519MLKEM768 by default. My plain openssl s_client with no group flags negotiated it against a server configured like Standard.
  • Windows Schannel supports X25519_MLKEM768 on Windows 11 24H2 and 25H2 (from KB5089573) and Windows Server 2025 (from KB5099536), but it is off by default. Microsoft's FAQ shows how to enable it:
# Elevated PowerShell. Group Policy overrides this if it is set.
Enable-TlsEccCurve -Name "X25519_MLKEM768" -Position 0
Get-TlsEccCurve

That last point matters for developers. A .NET service or PowerShell script on Windows that uses Schannel will talk classical TLS to Front Door until someone enables the hybrid group. Nothing breaks, you just do not get the post-quantum protection.

How to check from your own machine

Replace app.example.com with your Front Door custom domain or *.azurefd.net hostname.

OpenSSL 3.5 or later. Check your version first:

openssl version
openssl list -kem-algorithms | grep -i mlkem

Then see which group your default client negotiates:

openssl s_client -connect app.example.com:443 -servername app.example.com \
  -tls1_3 </dev/null 2>/dev/null | grep "Negotiated TLS1.3 group"

To prove the server supports a specific hybrid group, offer only that group. If the server does not support it, the handshake fails with alert 40 (handshake failure) instead of falling back:

openssl s_client -connect app.example.com:443 -servername app.example.com \
  -tls1_3 -groups X25519MLKEM768 </dev/null 2>&1 | grep -E "Negotiated|alert"

# Same idea for the P-256 hybrid that Enhanced keeps
openssl s_client -connect app.example.com:443 -servername app.example.com \
  -tls1_3 -groups SecP256r1MLKEM768 </dev/null 2>&1 | grep -E "Negotiated|alert"

Against my local test server, a supported group prints Negotiated TLS1.3 group: X25519MLKEM768. An unsupported one prints ssl/tls alert handshake failure and Negotiated TLS1.3 group: <NULL>.

curl. On my curl 8.14.1 build linked against OpenSSL 3.5, the verbose output includes the group in the connection line:

curl -sv --curves X25519MLKEM768 https://app.example.com/ -o /dev/null 2>&1 \
  | grep "SSL connection"
# * SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384 / X25519MLKEM768 / ...

Older curl builds, or builds on other TLS libraries, may not print the group or accept that curve name. Check curl --version first.

Browser. In Chrome or Edge, open DevTools, go to the Security panel (add it from the + menu if it is hidden), and look at the connection details. You should see TLS 1.3 and X25519MLKEM768 as the key exchange.

Wireshark. Microsoft's FAQ suggests the display filter tls.handshake.extensions_key_share_group and then reading the key_share extension line.

Compatibility gotchas

  • Bigger handshakes. The Learn page warns that post-quantum exchanges use larger handshake messages and tells you to test latency, network device compatibility and connection success rates. The ML-KEM-768 public key alone is over a kilobyte, so the ClientHello no longer fits in one typical packet.
  • Middleboxes and buggy servers. The Go 1.24 release notes describe servers that do not handle large records correctly and time out during the handshake, and keep GODEBUG=tlsmlkem=0 as an escape hatch. Chrome also has a PostQuantumKeyAgreementEnabled enterprise policy that controls hybrid key agreement. If a corporate proxy sits between your users and Front Door, test through it.
  • Enhanced drops X25519. If you pick Enhanced, clients that only offer X25519MLKEM768 or X25519 must negotiate something else. The docs tell you to verify your clients can.
  • X25519 only clients on Standard. Because Standard does not include classical X25519, a client that supports only X25519 has no common group. In my local test, an OpenSSL client limited to X25519 failed against a Standard style group list. Most clients also offer P-256, but embedded or very minimal clients are worth checking.
  • Locking yourself out. The docs warn that if a policy excludes every method a client supports, that client cannot connect at all. Monitor handshake failures after any change.

Microsoft's performance numbers look reassuring: synthetic tests showed under 1% CPU overhead for the ML-KEM-768 groups, and matched production A/B testing found no measurable CPU regression for X25519MLKEM768 against an X25519 control.

If your origin, or your CDN, is something else

The edge is only half the path. Microsoft says extending hybrid PQC to the Front Door to Azure services connection is the next engineering phase, and the Learn docs are explicit that the domain policy does not configure the origin connection. So:

  • Keep HTTPS to your origin, as the Front Door best practices page says, but do not assume that hop is post-quantum.
  • If your origin runs on OpenSSL 3.5, Go 1.24+ or Windows Server 2025 with the update, you can start testing hybrid groups there yourself with the same commands.
  • If you use a different CDN or reverse proxy, the same questions apply: which groups does the edge offer, can you choose them, and what happens on the hop to your origin?
  • Start inventorying clients you control, such as mobile apps, IoT devices and service to service callers. They are usually the slowest part of any TLS migration.

Your turn

Have you run the openssl s_client -groups X25519MLKEM768 check against your own endpoints yet, and did anything in your stack (a proxy, an old SDK, a load balancer) fail on the larger handshake? I would like to hear what broke, or what surprised you by just working.

I first wrote about this on Windows Mode.

📰 Read the original article on Dev.to Security

Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.