TLS 1.2 vs TLS 1.3: what changed and why it matters
Key takeaways
- TLS 1.3 needs one round trip for a typical full handshake versus two in TLS 1.2, and it removes RSA key transport and renegotiation.
- TLS 1.3 encrypts handshake messages after ServerHello, but observers can still analyze traffic timing and size, so it does not make a connection anonymous.
- The optional 0-RTT mode risks replayed early requests, so leave it disabled unless each route has a named owner, a rationale, and safety tests.
- Retire TLS 1.2 using evidence: inventory clients, measure negotiated versions over a representative period, test real applications, and set a removal date afterward.
TLS 1.3 improves on TLS 1.2 by shortening connection setup, removing legacy cryptographic options, and encrypting more of the handshake. The practical benefits are less waiting when connections begin and fewer opportunities for insecure configuration—not simply stronger encryption keys. This guide explains the differences, the limits of those improvements, and how to plan an upgrade without overlooking compatibility. (rfc-editor.org)
What is the difference between TLS 1.2 and TLS 1.3?
The main difference is that TLS 1.3 redesigns how a secure connection is established and restricts which cryptographic mechanisms it can use. TLS 1.2 offers a broader collection of options, including legacy choices that administrators must exclude. TLS 1.3 removes much of that flexibility, making a secure deployment easier to achieve. (rfc-editor.org)
For a quick TLS comparison, focus on these operational differences:
| Area | TLS 1.2 | TLS 1.3 |
|---|---|---|
| Typical full handshake | Two TLS round trips | One TLS round trip |
| Record encryption | Supports modern and legacy constructions | Uses authenticated encryption |
| RSA key transport | Available in legacy configurations | Removed |
| Handshake privacy | More handshake information is visible | Messages after ServerHello are encrypted |
| Early application data | No equivalent standardized TLS early-data mode | Optional 0-RTT mode, with security trade-offs |
| Renegotiation | Supported by the protocol | Removed |
These are protocol-level differences, not a promise that every application becomes noticeably faster. Configuration, network conditions, connection reuse, and application behavior still matter. (rfc-editor.org)
The decision is therefore not “encryption or no encryption.” Both versions can protect communications; TLS 1.3 offers a cleaner starting point with fewer inherited hazards. Treat the version upgrade as one part of deployment quality, alongside certificate validation, software maintenance, and testing. (rfc-editor.org)
TLS fundamentals: what the protocol protects
Transport Layer Security protects communication between endpoints, such as an application client and a server. Its core purposes are confidentiality, integrity, and authentication: keeping exchanged information private, detecting unauthorized changes, and establishing the identity of the communicating peer. In typical web connections, the server authenticates itself using a certificate; client certificate authentication is optional. (rfc-editor.org)
TLS has two related jobs. The handshake negotiates connection parameters and establishes shared secrets. The record layer then uses derived keys to protect application data as it travels across the connection. (rfc-editor.org)
That distinction helps explain TLS encryption without treating everything as one operation. Certificates, signatures, key exchange, and bulk encryption have different roles. A certificate does not encrypt every page, API response, or uploaded file; the connection uses symmetric traffic keys for that ongoing work. (rfc-editor.org)
HTTPS uses TLS to secure HTTP communication, but HTTP and TLS versions are separate concepts. Upgrading TLS does not, by itself, switch an application to a different HTTP version. When documenting a deployment, record the application protocol and its security settings separately so troubleshooting does not confuse them. (rfc-editor.org)
Faster handshakes and the meaning of round trips
The full handshake takes fewer exchanges
In a conventional TLS 1.2 full handshake, the client and server exchange information across two TLS round trips before normal client application data follows. TLS 1.3 reorganizes that exchange so a typical full handshake requires one. These counts describe TLS setup, not DNS resolution or the underlying TCP connection. (rfc-editor.org)
The client helps make this possible by sending a key share with its initial ClientHello. Rather than waiting for a separate exchange to begin key agreement, the server can use suitable information immediately. The published TLS 1.3 handshake traces illustrate this sequence, including the server authentication messages and subsequent application traffic. (rfc-editor.org)
One round trip is not an unconditional ceiling. If the server needs a different key share, it can issue a HelloRetryRequest, adding another exchange. Include this possibility when interpreting handshake timing rather than assuming every TLS 1.3 connection follows the shortest path. (rfc-editor.org)
Measure connection setup separately from application speed
For performance testing, separate three questions: how long a new connection takes, whether later connections resume successfully, and how long the application itself takes to respond. This avoids attributing a slow database query to TLS—or overlooking a handshake improvement because backend work dominates the result.
Use comparable workloads and network conditions. Test both fresh connections and reused ones, and keep response sizes consistent. A useful report should show where time changed, not merely announce that the newer protocol was enabled.
Cryptographic changes that reduce configuration risk
Authenticated encryption becomes the baseline
TLS 1.3 restricts its record-protection algorithms to authenticated encryption with associated data, usually shortened to AEAD. This combines confidentiality with integrity protection through a defined cryptographic construction. TLS 1.2 can also use strong AEAD suites, but its broader design includes older alternatives that need careful configuration. (tlswg.org)
Common TLS 1.3 suite names include TLS_AES_128_GCM_SHA256 and TLS_CHACHA20_POLY1305_SHA256. Unlike TLS 1.2 suite names, these do not also select the certificate type and key-exchange mechanism. Those choices are negotiated separately, so a shorter suite name does not mean authentication or key exchange has disappeared. (docs.openssl.org)
The operational lesson is straightforward: do not copy an old cipher string into a new deployment and assume it controls both versions. In OpenSSL, TLS 1.2-and-earlier cipher lists and TLS 1.3 cipher suites have separate configuration controls. Review both when maintaining a dual-version service. (docs.openssl.org)
Forward secrecy no longer depends on choosing ephemeral public-key suites
Forward secrecy protects past sessions against later compromise of a long-term authentication key, provided the session secrets have been properly handled and erased. TLS 1.2 can provide this protection with ephemeral key agreement. Legacy RSA key transport does not provide the same property. (nvlpubs.nist.gov)
TLS 1.3 removes static RSA and static Diffie–Hellman key exchange; its public-key-based key exchanges provide forward secrecy. This is an important distinction from saying “TLS 1.3 bans RSA.” RSA certificates can still authenticate connections through signatures even though RSA key transport is gone. (tlswg.org)
There is also a qualification for pre-shared-key operation. PSK-only modes and early data do not provide all the forward-secrecy properties of a fresh asymmetric exchange. When evaluating TLS security, distinguish a full handshake, resumed traffic, and early data rather than assigning identical guarantees to all three. (rfc-editor.org)
For a security review, ask which key compromise scenario matters. Protecting yesterday’s captured traffic is different from protecting an endpoint that is already compromised. Record those assumptions explicitly so “forward secrecy” becomes a meaningful requirement, not a checkbox detached from the threat model.
More handshake privacy, without complete anonymity
TLS 1.3 encrypts handshake messages after ServerHello, including the certificate messages in a normal certificate-authenticated handshake. This conceals information that was exposed during earlier handshake designs. It also means a passive observer has less handshake detail available for analysis. (tlswg.org)
However, TLS does not conceal every aspect of a connection. Network observers can still analyze characteristics such as traffic timing and size, and the base TLS 1.3 handshake does not automatically hide every ClientHello field. Do not equate an encrypted application session with an anonymous or unobservable one. (tlswg.org)
For operations teams, make observability part of the migration plan. Decide which questions need answers: connection failures, certificate problems, negotiated parameters, or application errors. Then identify an authorized source for each answer, rather than assuming an existing packet-capture workflow will remain sufficient.
Keep the scope narrow. Most investigations need reliable metadata and useful application errors, not unrestricted access to decrypted content. Document access, retention, and escalation procedures before a production incident forces hurried decisions.
When does 0-RTT help, and what are the risks?
TLS 1.3’s optional 0-RTT mode lets an eligible client send early application data when reconnecting using previously established information. It can remove the wait before sending that data, but it does not eliminate networking or make every connection instant. Its defining security concern is replay: an attacker may cause the same early request to be processed again. (rfc-editor.org)
This is a separate decision from enabling TLS 1.3 itself. You can adopt the normal handshake improvements without accepting early data. Start there unless an application-specific review establishes a worthwhile benefit and acceptable replay handling.
Consider these review questions:
- Could repeating the request change state? Examine payments, account changes, message submission, and other actions where duplication matters.
- Does the endpoint behave as its method suggests? Review implementation behavior rather than relying only on labels such as GET.
- Where is early data accepted? Include proxies and backend services in the decision, not just the public listener.
- What happens after rejection? Test the client’s retry path and ensure the user receives an understandable result.
HTTP defines an Early-Data header and a 425 Too Early response to help coordinate handling. These mechanisms support safer retries; they do not make arbitrary operations replay-safe. A route that appears read-only still deserves review for hidden side effects or expensive repeated work. (rfc-editor.org)
Require a named owner for each early-data exception. Document the accepted routes, the rationale, and the tests that demonstrate safe behavior. If that evidence is missing, leave 0-RTT disabled rather than treating it as a routine performance toggle.
Compatibility and the role of TLS 1.2
TLS 1.2 is not equivalent to obsolete TLS 1.0 or TLS 1.1. Those older TLS versions were formally deprecated in RFC 8996. Avoid preserving them as a catch-all response to compatibility uncertainty; identify the affected clients and plan an upgrade instead. (rfc-editor.org)
For existing services, carefully configured TLS 1.2 can remain a compatibility option while TLS 1.3 is preferred. RFC 9325 provides hardening recommendations for that situation. Its guidance should not be interpreted as permission to retain arbitrary legacy suites just because the negotiated version reads “1.2.” (rfc-editor.org)
Guidance for new protocol designs has moved further. Published in July 2026, RFC 9852 requires new protocols using TLS to specify TLS 1.3 as the default; TLS 1.2 may be an additional, non-default option where deployment considerations warrant it. That is distinct from ordering every existing service to disable TLS 1.2 immediately. (rfc-editor.org)
For your own retirement decision, use evidence:
- Inventory legitimate clients and their owners.
- Measure negotiated versions across a representative operating period.
- Investigate remaining TLS 1.2 use rather than assuming it is unavoidable.
- Test updates with the actual application, not only a generic browser.
- Set a removal date only after reviewing impact and recovery options.
Include network appliances and custom clients. OpenSSL’s migration notes identify application-level differences around session handling, renegotiation, and middlebox compatibility. A successful browser connection alone is not a complete interoperability test. (github.com)
A practical migration plan
Map every TLS termination point
Begin with a connection diagram. Mark the public endpoint, reverse proxies, load balancers, origins, internal gateways, and application clients. For every connection, record who owns its TLS policy and where you can inspect the negotiated result.
Do not let an edge-only test stand in for an end-to-end review. Define acceptance criteria for each connection separately. Include certificate identity checks, permitted versions, expected authentication behavior, and the application transaction that proves the connection is useful.
A simple worksheet can keep the work actionable:
| Connection | Policy owner | Test client | Acceptance evidence |
|---|---|---|---|
| Client to public endpoint | Assigned team | Representative external client | Negotiation and transaction results |
| Proxy to origin | Assigned team | Proxy or equivalent test | Origin identity and connection results |
| Internal service connection | Assigned team | Actual service client | Authentication and application results |
Review the deployed configuration, not just the template
Check the running software, linked cryptographic library, and effective settings before changing protocol policy. For example, NGINX exposes permitted versions through ssl_protocols, and its TLS capabilities depend on its OpenSSL integration. An example directive is ssl_protocols TLSv1.2 TLSv1.3;, but this is only one part of a complete configuration. (nginx.org)
Use your platform’s maintained documentation instead of copying an old configuration wholesale. Review certificate chains, client authentication, session behavior, and the separate controls for each protocol version. Assign responsibility for keeping that configuration current after the migration project ends.
Roll out with explicit success and failure criteria
Define a small rollout scope and a clear observation window. Record the starting configuration, expected results, and a tested rollback procedure. Avoid changing protocol versions, certificate automation, routing, and application behavior simultaneously unless those changes must be coordinated.
Evaluate more than successful handshakes. Exercise login, uploads, API calls, long-lived connections, and mutual authentication where applicable. For each failure, preserve enough detail to distinguish a TLS negotiation problem from a certificate or application problem.
Use a short release checklist:
- Positive tests: Supported clients connect and complete representative transactions.
- Negative tests: Disallowed versions and invalid identities fail as intended.
- Performance tests: Fresh, resumed, and reused connections are measured separately.
- Operational tests: Alerts, logs, ownership, and rollback procedures work.
- Exception review: Every retained compatibility allowance has an owner and review date.
How to verify the negotiated TLS version
Test the deployed hostname with the intended version explicitly selected. OpenSSL’s s_client supports -tls1_2 and -tls1_3, allowing separate checks instead of relying on automatic negotiation. Include the server name so the test targets the appropriate virtual host. (docs.openssl.org)
For example, replace example.com with a hostname you control or are authorized to test:
- TLS 1.3: openssl s_client -connect example.com:443 -servername example.com -tls1_3 -brief
- TLS 1.2: openssl s_client -connect example.com:443 -servername example.com -tls1_2 -brief
Inspect the negotiated protocol and cipher, then test identity validation deliberately. With s_client, use -verify_hostname example.com and -verify_return_error when requiring hostname verification and failure on certificate errors. Trust-store configuration also matters; a completed diagnostic connection alone is not proof that certificate validation succeeded. (docs.openssl.org)
Repeat checks from representative locations and with actual production clients. Save the command, timestamp, endpoint, and relevant output so the result is reproducible. Compare observed behavior against the acceptance criteria rather than treating a single successful connection as the finish line.
Put TLS 1.3 advantages in the right context
The strongest TLS 1.3 advantages are a streamlined handshake, fewer legacy cryptographic choices, and better handshake confidentiality. They simplify important parts of secure transport, but they do not remove the need to maintain software, validate identities, and test application behavior. Judge the outcome by deployed behavior, not the presence of a version number. (rfc-editor.org)
TLS 1.3 also provides the foundation for newer transport designs: QUIC integrates its handshake and requires TLS 1.3 or later. Separately, the IETF’s ongoing post-quantum work focuses on TLS 1.3 or later, rather than extending TLS 1.2. Enabling TLS 1.3 alone, however, is not proof that a connection uses post-quantum key exchange. (rfc-editor.org)
For an existing service, the practical path is to enable and prefer TLS 1.3, retain hardened TLS 1.2 only where justified, and evaluate 0-RTT separately. Build the removal plan around measured dependencies and accountable owners. That turns a protocol upgrade into a controlled improvement rather than a configuration change whose consequences nobody has checked.
Related guides
Sources
- rfc-editor.org: Rfc8446
- RFC 9325: Recommendations for Secure Use of Transport Layer Security (TLS) and Datagram Transport Layer Security (DTLS)
- rfc-editor.org: Rfc5246
- RFC 9110: HTTP Semantics
- rfc-editor.org: Rfc8448
- RFC 9846: The Transport Layer Security (TLS) Protocol Version 1.3
- openssl-ciphers - OpenSSL Documentation
- nvlpubs.nist.gov: NIST.SP.800 52r2
- rfc-editor.org: Rfc8470
- RFC 8996: Deprecating TLS 1.0 and TLS 1.1
- RFC 9852: New Protocols Using TLS Must Require TLS 1.3
- TLS1.3 · openssl/openssl Wiki · GitHub
- Module ngx_http_ssl_module
- openssl-s_client - OpenSSL Documentation
- RFC 9001: Using TLS to Secure QUIC