Back to DashboardProtocolsPhase 5 · Pilots & Migrationintermediate40 min

TLS 1.3 Basics

Learn about TLS 1.3, configure handshake parameters, and explore PQC migration trade-offs.

Why this matters: TLS protects nearly all web traffic; the 1.3 handshake is the prerequisite for every hybrid-PQC rollout you'll plan.

Start here: Set the client and server panels — identity certificates and key exchange groups — then press Start Full Interaction: the handshake runs and a summary plus the negotiated results appear below.

For your role

Developer / Engineer
The TLS 1.3 handshake, certificates and cipher suites, then the simulator: choose a hybrid key share and an ML-DSA certificate and read every message in TXT and HEX, with the OpenSSL config that produced it.
Security Architect
The handshake is the prerequisite for every hybrid-PQC rollout; the simulator shows what a PQC certificate chain and a hybrid key share add to each connection.
Researcher / Academic
The simulator supports pure ML-DSA certificates and the IETF hybrid key shares; inspect the encodings against the drafts listed at the top of the tool.
IT Ops / DevOps
Set the server side as your edge is configured and run the simulator: the Config File tab and the module's Apache, nginx, HAProxy and Caddy snippets are what you deploy.
Curious Explorer
The padlock in your browser is TLS; the module shows what happens in the handshake and what changes when the algorithms inside it go post-quantum.
Practice in the Simulation

Before You Start

Prerequisites: Familiarity with public-key cryptography (asymmetric keys, digital signatures, certificates) and basic HTTPS concepts.

After completing this module, you will be able to:

  1. Explain the TLS 1.3 handshake and how it differs from TLS 1.2
  2. Compare overhead of classical, hybrid, and PQC TLS configurations quantitatively
  3. Configure a web server for hybrid PQC TLS key exchange

What is TLS 1.3?

1.3 is the latest version of the Transport Layer Security protocol, securing virtually all HTTPS traffic on the internet. It is specified by RFC 9846 (July 2026), which obsoleted the original RFC 8446. It was a major overhaul from TLS 1.2, removing insecure legacy features and introducing mandatory , a faster 1-RTT handshake, and a dramatically simplified cipher suite list.

Removed
  • RSA key exchange (no forward secrecy)
  • CBC cipher modes
  • Renegotiation & compression
Added
  • Mandatory ECDHE forward secrecy
  • 0-RTT early data (optional) — TLS provides no inherent replay protection for 0-RTT data (RFC 9846 §8)
  • Encrypted handshake messages
Simplified
  • 5 cipher suites (vs hundreds in 1.2)
  • 1-RTT handshake (vs 2-RTT)
  • AEAD-only encryption

The TLS 1.3

The handshake establishes a secure connection in a single round trip. The client sends its supported parameters and a key share; the server responds with its choice and key share. After the ServerHello, all remaining handshake messages are encrypted using handshake traffic keys derived via .

💻
Client
🖥️
Server
ClientHello
+ key_share (X25519MLKEM768, client share 1216 B), supported_groups
RFC 9846 §4.2.2
ServerHello
+ key_share (KEM ciphertext / ECDH response, 1120 B)
RFC 9846 §4.2.3
Handshake keys derived
{EncryptedExtensions}
RFC 9846 §4.4.1
{CertificateRequest}(mTLS)
Optional: server asks for a client certificate
RFC 9846 §4.4.2
{Certificate}
Server identity
RFC 9846 §4.5.1
{CertificateVerify}
Signature proof — first offered sigalg mldsa44 (2,420 B)
RFC 9846 §4.5.2
{Finished}
Server handshake MAC
RFC 9846 §4.5.3
{Certificate}(mTLS)
Client identity, sent only if requested
RFC 9846 §4.5.1
{CertificateVerify}(mTLS)
Client signature, only with a non-empty Certificate
RFC 9846 §4.5.2
{Finished}
Client handshake MAC
RFC 9846 §4.5.3
Application Data
Encrypted with traffic keys
RFC 9846 §7.3

First offered group X25519MLKEM768. Client share 1216 B and server share 1120 B. Hybrid shares include both components. First offered signature scheme mldsa44, 2,420 B.

Check the TLS key-share field capacity

A sample parser reserves separate buffers for the client and serverkey_exchange fields. Predict which buffer needs to grow when the group changes.

Client field
1,216 bytes
Server field
1,120 bytes
Shared secret input to TLS HKDF
64 bytes

Both field sizes fit their sample buffers.

The shares are field payloads. A full handshake also carries headers and other messages. TLS derives its traffic keys from the combined secret through HKDF.

RFC 10024 negotiated groupsTLS 1.3 key schedule

Explained

TLS 1.3 cipher suites only specify the symmetric encryption algorithm and hash — key exchange and authentication are negotiated separately. This is why there are only 5 suites compared to hundreds in TLS 1.2.

TLS_AES_256_GCM_SHA384 in GCM mode (AEAD) + SHA-384 for HKDF
TLS_AES_128_GCM_SHA256AES-128 in GCM mode (AEAD) + SHA-256 for HKDF
TLS_CHACHA20_POLY1305_SHA256 (AEAD) + SHA-256 — optimized for mobile/ARM
TLS_AES_128_CCM_SHA256AES-128 in CCM mode + SHA-256 — designed for constrained environments (IoT)
TLS_AES_128_CCM_8_SHA256AES-128 in CCM mode with 8-byte auth tag + SHA-256 — for highly constrained devices

Key Exchange: Classical, PQC, and Hybrid

TLS 1.3 uses ephemeral key exchange for every connection, ensuring forward secrecy. With post-quantum cryptography (PQC), three approaches are available:

Classical ()

, , . Fast and small (~32 byte keys). Vulnerable to quantum computers.

PQC ()

ML-KEM-512/768/1024. Quantum-resistant. Larger keys (1,184 B for ML-KEM-768, FIPS 203) increase handshake size.

Hybrid

combines both. Already deployed in Chrome and Firefox. Secure even if one algorithm is broken.

Key Schedule (HKDF)

TLS 1.3 derives all session keys through a structured key schedule using HKDF (HMAC-based Key Derivation Function). The shared secret from key exchange feeds into a chain of Extract and Expand operations:

1.Early Secret — derived from PSK (or zero for full handshake)
2.Handshake Secret — derived from ECDHE/KEM shared secret → produces CLIENT_HANDSHAKE_TRAFFIC_SECRET and SERVER_HANDSHAKE_TRAFFIC_SECRET
3.Master Secret — produces CLIENT_TRAFFIC_SECRET_0 and SERVER_TRAFFIC_SECRET_0 for application data

These exact secrets are visible in the Simulate tab after running a handshake.

Session Resumption & PSK

After a successful handshake, the server issues a ticket. On reconnection, the client presents this PSK, which feeds into the Early Secret stage — enabling a faster resumed handshake and optionally 0-RTT early data. In a full handshake with no prior session, the PSK input is zero.

HelloRetryRequest (HRR)

A client lists every group it supports in supported_groups but usually sends a key share for only one or two of them. If the server selects a group that both sides support but the ClientHello carried no key_share for it, the server responds with a HelloRetryRequest instead of a ServerHello, naming the group it wants. The client resends its ClientHello with a key share for that group, making a 2-RTT handshake instead of the standard 1-RTT (RFC 9846 §4.2.1, §4.2.4). If client and server have no supported group in common, no retry can help: the server aborts the handshake with a handshake_failure alert.

When Does HRR Happen?
  • Client supports X25519 and X25519MLKEM768 but sends a key share only for X25519; the server selects X25519MLKEM768
  • Client supports ML-KEM-768 and ML-KEM-1024 with a key share only for ML-KEM-768; the server accepts only ML-KEM-1024
  • Not an HRR: no group in common (e.g. client X25519 only, server X25519MLKEM768 only) ends in handshake_failure
PQC Migration Impact
  • During PQC rollout, clients often send a classical key share first and an HRR upgrades them to the hybrid group the server prefers
  • X25519MLKEM768 is its own group codepoint (RFC 10024): a classical-only client matches only if the server also supports plain X25519 as a separate group
  • Offering X25519 as a fallback needs a policy that prevents silent downgrade to classical-only key exchange
  • HRR costs a round trip; a server with no group in common fails the handshake instead

In the simulator, set the client groups to X25519 then X25519MLKEM768 and the server to X25519MLKEM768 only to observe an HRR. Set the client to ML-KEM-1024 only and the server to X25519 only to observe a handshake failure with no common group.

Post-Quantum Cryptography in TLS

Quantum computers threaten classical key exchange (ECDH) through . The attack means adversaries can record encrypted traffic today and decrypt it once quantum computers are available. PQC integration into TLS addresses this by using KEMs (ML-KEM) and signatures ().

The trade-off: PQC algorithms have larger keys and ciphertexts, increasing handshake overhead. For example, ML-KEM-768 public keys are ~1,184 bytes vs 32 bytes for X25519. The hybrid approach (e.g., X25519MLKEM768) provides quantum resistance while maintaining classical security as a fallback.

SLH-DSA: Hash-Based Alternative (FIPS 205)

(formerly SPHINCS+) is a hash-based signature scheme standardized alongside ML-DSA. It relies on hash function security rather than lattice problems, providing cryptographic diversity— if lattices are broken, SLH-DSA remains secure. The trade-off is significantly larger signatures (~7.9 KB (7,856 B) for SLH-DSA-SHA2-128s vs 2,420 B, about 2.4 KB, for ML-DSA-44). The simulator's signature options offer ML-DSA only: no IETF working-group draft yet specifies SLH-DSA for TLS 1.3 (only an individual Internet-Draft, draft-reddy-tls-slhdsa, exists, and it has expired).

Scaling PQC for HTTPS

PQC signatures are significantly larger than classical ones — an ML-DSA certificate chain can add several kilobytes to every TLS handshake. For the web, where billions of connections happen daily, this overhead is a serious scalability concern. The ecosystem is deploying multiple mitigations.

TLS Certificate Compression (RFC 8879)

TLS certificate compression is available, and certificates are compressed before transmission and decompressed by the peer. The IETF UTA working-group draft on PQC recommendations for TLS-based applications states that its impact on PQ and PQ/T hybrid certificates is limited, because the larger public keys and signatures are high-entropy fields that constrain compression effectiveness.

Certificate Transparency (RFC 9162)

Certificate Transparency gives public TLS issuance an auditable record. Chrome and Apple require eligible Signed Certificate Timestamps (SCTs) for publicly trusted TLS server certificates under their respective policies. An SCT is a signed promise of inclusion. An auditor verifies actual inclusion separately. Private trust anchors sit outside those public-trust policies.

Chrome CT policyApple CT policyRFC 9162 inclusion proof

Merkle Tree Certificates (MTC)

Google's MTC program (announced February 2026) goes further than compression — it replaces entire certificate chains with compact Merkle proofs.

Problem: X.509 Certificate Chains

Traditional TLS uses a chain of X.509 certificates, each containing a public key and a signature from the issuing CA. With PQC signatures (3,309 B, about 3.3 KB, for ML-DSA-65), the Certificate message of the Hub's sample capture (a leaf plus an intermediate) is 11,100 B with ML-DSA-65 against 1,642 B with RSA-2048 — a substantial bandwidth increase. Sizes only; no handshake time was measured.

Solution: Merkle Tree Proofs

MTCs replace the serialized signature chain with a compact Merkle inclusion proof. A single CA-signed "Tree Head" represents potentially millions of certificates. Browsers receive a lightweight proof-of-inclusion rather than full certificate chains.

Deployment Roadmap

Phase 1 (Now)Feasibility testing with Cloudflare on live traffic; all MTC connections backed by traditional X.509 certificates as fallback
Phase 2 (sample plan, Q1 2027)Inviting Certificate Transparency log operators to bootstrap public MTC infrastructure
Phase 3 (sample plan, Q3 2027)Establishing Chrome Quantum-resistant Root Store (CQRS) with new requirements for MTC Certificate Authorities
Google Security Blog: Quantum-safe HTTPS

Encrypted Client Hello (ECH)

TLS 1.3 sends the ClientHello, including the , in plaintext, so an on-path observer can see which site a user is connecting to. Encrypted Client Hello (ECH, RFC 9849) lets the client encrypt the real ("inner") ClientHello to an ECH public key that the server normally publishes in DNS, and send a decoy ("outer") ClientHello. This hides the SNI and other sensitive fields such as the ALPN list among the sites that share the same ECH configuration. RFC 9849 states that ECH is not in itself sufficient to protect the identity of the server: the target may still be visible through plaintext DNS queries or the server's IP address.

Encrypted Client Hello (ECH), published as RFC 9849, encrypts the inner ClientHello with HPKE under the server's ECH key. ECH and a hybrid key exchange such as X25519MLKEM768 protect different things. The hybrid group protects the key exchange of the TLS session. The inner ClientHello is encrypted separately with HPKE (RFC 9180) under the server's ECH key, using the KEM named in the ECH configuration. RFC 9180 defines only Diffie-Hellman KEMs (P-256, P-384, P-521, X25519, X448) and acknowledges that a non-quantum-resistant KEM used with HPKE can be broken by a quantum computer; the IANA HPKE registry lists ML-KEM-based identifiers that come from Internet-Drafts. RFC 9849 also states that ECH provides no forward secrecy for the inner ClientHello, because the server's ECH key is static. So a hybrid TLS key exchange does not by itself keep ECH-protected metadata private against a future quantum computer: that depends on the KEM in the site's ECH configuration, which this lesson does not assume is post-quantum.

Related Resources

Products shown here are a representative selection — not an exhaustive list. For the full vendor landscape with PQC readiness status, visit the Tools & Products tab in this module or browse the Migrate catalog →

Check off all sections and mark this reading done.

In the Industry Landscape

Check your understanding

21 questions on TLS Basics, each with its answer and the reason.

Take the quiz

Next step

Practice it: TLS 1.3 Simulator

TLS 1.3 Simulator is the hands-on version of this module: the same ideas, run in your browser.

Production Tool Capabilities & Verification Checklist

Capabilities to require in your production tools:

  • TLS 1.3 hybrid post-quantum group negotiation (`X25519MLKEM768`, `SecP256r1MLKEM768`, `SecP384r1MLKEM1024`) on ingress gateways and service meshes.
  • Support for RFC 8879 TLS Certificate Compression (zlib/Brotli/Zstd); measure its actual effect on PQC chains, since PQC keys and signatures compress poorly.
  • Strict TLS 1.3 enforcement disabling legacy TLS 1.0/1.1 and static RSA key transport.

How to evaluate in your environment

Run `openssl s_client -groups X25519MLKEM768` against staging endpoints and inspect TCP segment counts and handshake latency.

Production evidence to collect

Staging TLS handshake transcript showing negotiated `Negotiated TLS1.3 group: X25519MLKEM768` and MTU fragmentation telemetry.

Completing this Hub module and its browser-based sample exercises teaches the technical and governance decision criteria for your role; it does not test, validate, or certify your deployed production systems.

Record evidence for your environment

Identify the tested build and configuration. Use reference IDs for observations. For a proposed exclusion, record the system boundary or rule and why it excludes this build.

TLS 1.3 hybrid post-quantum group negotiation (`X25519MLKEM768`, `SecP256r1MLKEM768`, `SecP384r1MLKEM1024`) on ingress gateways and service meshes.
Support for RFC 8879 TLS Certificate Compression (zlib/Brotli/Zstd); measure its actual effect on PQC chains, since PQC keys and signatures compress poorly.
Strict TLS 1.3 enforcement disabling legacy TLS 1.0/1.1 and static RSA key transport.

Evidence missing. 0 of 3 requirements have a reference or scope rationale.

Learning module content can be inaccurate. Please double-check its information. Report inaccuracies in PQC Today GitHub Discussions.