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.
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:
- Explain the TLS 1.3 handshake and how it differs from TLS 1.2
- Compare overhead of classical, hybrid, and PQC TLS configurations quantitatively
- 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.
- RSA key exchange (no forward secrecy)
- CBC cipher modes
- Renegotiation & compression
- 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
- 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 .
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.
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.
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:
, , . Fast and small (~32 byte keys). Vulnerable to quantum computers.
ML-KEM-512/768/1024. Quantum-resistant. Larger keys (1,184 B for ML-KEM-768, FIPS 203) increase handshake size.
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:
CLIENT_HANDSHAKE_TRAFFIC_SECRET and SERVER_HANDSHAKE_TRAFFIC_SECRETCLIENT_TRAFFIC_SECRET_0 and SERVER_TRAFFIC_SECRET_0 for application dataThese 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.
- 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
- 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.
Merkle Tree Certificates (MTC)
Google's MTC program (announced February 2026) goes further than compression — it replaces entire certificate chains with compact Merkle proofs.
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.
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
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.
Related modules
- Email & Document SigningSame track · Protocols · Same migration phase · Shares ML-DSA, X.509
- DNSSEC & Post-Quantum SignaturesSame track · Protocols · Same migration phase · Shares ML-DSA, ECDSA
- PQC Hardware AccelerationShares ML-DSA, ML-KEM, ECDSA
- Web Gateway PQCSame track · Protocols · Shares ML-DSA, ML-KEM, RFC 9846
In the Industry Landscape
- Cloud Computing / Data CentersTenant-facing TLS & API endpoints · Backup & disaster-recovery encryption
- Cross-IndustryWeb & API TLS everywhere
- Aerospace / AviationBy protocol · Satellite communications & ground links
- Automotive / Connected VehiclesBy protocol · Telematics & connected-car cloud APIs
- Critical Infrastructure / EnergyBy protocol · SCADA & substation automation (IEC 61850/62351) · Distributed energy resources & EV charging (IEEE 2030.5 / OCPP)
- Education / ResearchBy protocol · Student information systems & LMS · Research data protection (CUI)
- Finance & BankingBy protocol · Interbank payments & settlement (SWIFT/RTGS) · Digital banking channels · Long-term records & HNDL exposure
- Government & DefenseBy protocol · National security systems — transport (CNSA 2.0) · National security systems — protocol authentication (CNSA 2.0)
- Healthcare / PharmaceuticalBy protocol · EHR & health-information exchange
- Internet of Things (IoT)By protocol · Device identity & provisioning · Industrial IoT (OPC UA / IEC 62443)
- IT Industry / SoftwareBy protocol · Crypto libraries & TLS stacks — key exchange · Crypto libraries & TLS stacks — PQC signatures · Web PKI & certificate authorities
- Media / Entertainment / DRMBy protocol · Streaming delivery & license TLS
- Payment Card IndustryBy protocol · Terminal PIN security & key injection · E-commerce payment data (PCI DSS)
- Rail / TransitBy protocol · Train control key management (ETCS) · Railway mobile communications (GSM-R → FRMCS)
- Retail & E-CommerceBy protocol · Online checkout & POS
- Supply Chain / LogisticsBy protocol · Port & vessel identity systems
- TelecommunicationsBy protocol · Backhaul & core transport (IPsec/TLS) · Inter-operator roaming security (SEPP / N32)
- Water / WastewaterBy protocol · Treatment plant SCADA & remote ops · Water metering & sensor networks
- InsuranceBy protocol · Policyholder data & HNDL exposure
Check your understanding
21 questions on TLS Basics, each with its answer and the reason.
Take the quizNext step
Practice it: TLS 1.3 SimulatorTLS 1.3 Simulator is the hands-on version of this module: the same ideas, run in your browser.
Production Tool Capabilities & Verification ChecklistNetwork Engineers, SREs & Application Developers
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.
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.