TLS session resumption lets a client reconnect without repeating every step of a full TLS 1.3 handshake. The earlier connection leaves behind a pre-shared key, or PSK, that can authenticate the resumed session. A server usually gives the client an opaque session ticket that identifies that PSK.
Resumption can reduce setup work, but it is separate from 0-RTT. A resumed connection may still wait for the handshake before sending application data. Zero round-trip time is an optional extra that lets selected data travel before the server has completed the new handshake, with weaker replay guarantees.
Standards check: This explainer follows RFC 8446 and RFC 8470 as reviewed on 1 November 2026.
Full handshake, resumption and early data
| Connection path | What the client reuses | When ordinary application data starts | Main caution |
|---|---|---|---|
| Full TLS 1.3 handshake | Nothing from an earlier session | After the handshake establishes fresh traffic keys | More setup messages |
| Resumed 1-RTT handshake | A PSK established by an earlier connection | After the resumed handshake | Ticket handling and key lifetime |
| Resumed connection with 0-RTT | A PSK and server permission for early data | Some data can leave with the first ClientHello | Early data can be replayed |
The table describes protocol options. It does not promise that a browser, library, origin or CDN will enable each one. A server may accept a ticket for resumption while rejecting early data.
How a TLS 1.3 ticket becomes a PSK
After a full handshake, the server can send a NewSessionTicket message. RFC 8446 section 4.6.1 ties the ticket to a PSK derived from the connection’s resumption master secret. The ticket itself is opaque to the client. It can be a lookup key for server-side state or a protected value that carries state for the server.
On a later connection, the client places the ticket in the pre_shared_key extension of its ClientHello. It also sends a binder calculated with the PSK. That binder proves possession of the secret and binds the offer to the current handshake transcript. The server can accept one offered identity or continue with a full handshake.
TLS 1.3 calls this a PSK even when the secret was created by a previous certificate-authenticated connection. The name describes how the resumed handshake starts, not how the original trust was established.
Tickets expire, and clients can discard them sooner
A NewSessionTicket includes a lifetime. RFC 8446 caps that advertised lifetime at 604,800 seconds, or seven days. Clients must not cache a ticket longer than seven days and can delete it earlier. A server can also stop accepting it before the advertised deadline.
The message includes a random ticket_age_add value that obscures the ticket age sent back by the client. It also carries a per-ticket nonce, so multiple tickets from one connection derive different PSKs.
Shorter lifetimes reduce how long stolen or old resumption material remains useful. They also reduce the hit rate for resumption. That trade-off belongs in the TLS configuration, rather than in application code that assumes every reconnect will resume.
PSK-only and PSK with fresh Diffie-Hellman differ
A resumed TLS 1.3 handshake can combine the PSK with a fresh ephemeral Diffie-Hellman key exchange. This is the psk_dhe_ke mode. The new key share adds forward secrecy to the resumed connection: later compromise of the PSK alone does not reveal the application traffic protected by the fresh exchange.
The psk_ke mode uses the PSK without a fresh Diffie-Hellman share. RFC 8446 permits it but states that application data then loses forward secrecy. Operators should check what their TLS stack negotiates instead of treating every resumed handshake as cryptographically identical.
The server’s certificate is normally absent from the resumed flight because the PSK authenticates the server through its link to the original session. That saves messages, but it also means a chain of repeated resumptions can keep relying on older authentication material. RFC 8446 recommends limiting the total lifetime of that material, taking certificate lifetime and possible revocation into account.
Resumption does not require 0-RTT
A ticket authorizes early data only when its NewSessionTicket carries the early_data extension. That extension includes the maximum number of early-data bytes the client may send.
Without it, the ticket can still support a shorter resumed handshake. This is the useful distinction:
- resumption reuses a PSK to avoid a full certificate handshake;
- 0-RTT sends application data before the new handshake finishes;
- a deployment can enable resumption and keep 0-RTT disabled.
For QUIC, session resumption also works without 0-RTT. The protocol carries TLS ticket messages after the handshake, while early data requires additional retained connection state. For the transport differences around QUIC, read HTTP/3 vs HTTP/2.
Why 0-RTT data can be replayed
Early data is encrypted, but encryption does not make it unique. It is sent before the client receives a fresh ServerHello, so its protection does not depend on the new server random value. An attacker who captures the first flight may try to deliver it more than once.
RFC 8446 section 8 describes server-side defenses such as single-use tickets and recording values from recent ClientHello messages. Those measures can reduce replays, but distributed servers may not share perfectly consistent state. Clients therefore must treat early data as potentially replayable.
This is a problem for actions with side effects. A repeated request might create two orders, submit two jobs or trigger the same state change twice. Even a nominally idempotent request can consume resources when replayed at scale.
What HTTP does with 425 Too Early
RFC 8470 defines HTTP mechanisms for handling early data. A client must not send methods of unknown safety in early data unless it has stronger information from the application. An origin can delay processing until the handshake completes, reject early data, or respond with 425 Too Early when it is unwilling to risk processing a replayable request.
A retry after 425 must not be sent in early data. This gives the request a normal post-handshake path. The status does not magically make a request idempotent; it provides a way to move it out of the replay-prone phase.
Gateways need consistent rules too. If one edge node processes an early request while another rejects it and triggers a retry, the system can still produce a duplicate effect. Replay policy has to cover the origin, intermediaries and application behavior together.
Privacy and ticket reuse
Session tickets can also link connections. RFC 8446 advises clients not to reuse one ticket for multiple connections because a repeated ticket can help a passive observer correlate them. Servers can issue several tickets so parallel connections do not need to reuse the same value.
This does not make resumption uniquely unsafe. It means performance state is also privacy state. Ticket rotation, limited lifetimes and single-use behavior should be part of a privacy review, especially when traffic crosses several edges or address families.
A deployment checklist
Before enabling or tuning TLS session resumption:
- confirm that resumed handshakes use PSK with a fresh Diffie-Hellman share where forward secrecy is required;
- set ticket lifetimes deliberately and rotate ticket-protection keys;
- decide whether 0-RTT is needed at all;
- if 0-RTT is enabled, list the exact requests allowed before handshake completion;
- keep state-changing operations, authentication changes and payments out of early data;
- make anti-replay state consistent across the servers that can accept one ticket;
- support 425 responses and retry only after the handshake;
- monitor full handshakes, resumed handshakes, accepted early data and rejected early data separately;
- test a deployment restart, key rotation and multi-region failover, not only the happy path.
A packet trace can show a pre_shared_key extension or an early-data indication. It cannot by itself prove that application-side replay controls are correct.





