TLS 1.3 handshake: a clear step-by-step guide
Learn the TLS 1.3 handshake step by step, read packet captures in Wireshark, inspect OpenSSL output, and troubleshoot common certificate failures.
Security / Field note
Learn the main steps in a TLS handshake, how certificates identify a server, and why people still call it an SSL handshake.
Explore by doing
A browser and a website exchange messages before they send protected data. Use this visualizer to follow those messages, compare TLS 1.2 and TLS 1.3, and see what happens when a certificate check fails.
01 / Follow the messages
Step through ClientHello, ServerHello, certificate checks, and Finished messages.
02 / Compare versions
A full TLS 1.3 handshake usually takes one round trip. A full TLS 1.2 handshake usually takes two.
03 / Try example errors
Try an expired certificate, a name mismatch, or an untrusted issuer and see how the check changes.
This is a learning simulation. It does not connect to a real website or check live certificates.
Protocol sequence
Selected message
supported_versions: TLS 1.3 cipher_suites: TLS_AES_128_GCM_SHA256, TLS_AES_256_GCM_SHA384 server_name: www.example.com alpn: h2, http/1.1 key_share: X25519
Key exchange & integrity
Client sends its public key share; private key material stays on the client.Learning simulation only. Certificate values, endpoint names, and failure outcomes are examples; no certificate, OCSP responder, or live website is contacted.
When you open a secure website, your browser and the website first need to agree on how to protect their connection. They do this with a TLS handshake. The handshake happens before normal website data is sent.
People often say “SSL handshake.” SSL is an old protocol and is no longer safe to use. Modern secure websites use TLS, which replaced SSL. In everyday speech, “SSL handshake” usually means a TLS handshake.
For a typical website, the steps are:
Find the server with DNS
↓
Connect to the server (usually TCP for HTTP/1.1 or HTTP/2)
↓
Agree on TLS settings and check the server
↓
Send the HTTP request and response inside TLSHTTP/3 uses QUIC over UDP. QUIC includes TLS 1.3 in its connection setup, so it does not use the TCP steps shown above.
The client and server need to:
This is a typical full handshake that uses a server certificate. A resumed session, a client certificate, or a request for a different key share can change the message flow.
ClientHelloThe client offers supported TLS versions and cipher suites. It also sends a temporary key share. For a website, the message usually includes SNI (Server Name Indication), which tells a shared server which site the client wants. It can also offer application protocols such as HTTP/2 with ALPN.
ServerHelloThe server chooses settings from the client’s offer and returns its own key share. The two sides use their private key material and the other side’s public key share to calculate matching handshake secrets. They do not send the final shared secret over the network.
After ServerHello, TLS 1.3 encrypts the rest of the handshake. The server sends selected extensions, its certificate chain, CertificateVerify, and Finished. The certificate chain helps the client check the server name and trust path. CertificateVerify proves that the server controls the private key for the certificate. Finished checks the handshake transcript and confirms the handshake keys.
FinishedThe client checks that the certificate covers the requested name, is within its validity dates, and chains to a trusted certificate authority. It also checks the server’s proof and Finished message. Revocation checks depend on client policy and the status information available to it.
The client then sends its own Finished message. Client certificates are optional and are used only when a service requests client authentication.
After the handshake, the client and server use derived traffic keys to protect application data, such as an HTTPS request and response. TLS protects data between the two TLS endpoints. It does not prove that a website is honest or that its content is safe.
TLS 1.2 has a different message flow. A typical full ECDHE handshake includes a server flight with ServerHello, a certificate, key-exchange parameters, and ServerHelloDone. The client then sends key-exchange information and Finished; the server answers with its own Finished. The exact flow depends on the selected cipher suite and authentication method.
TLS 1.3 usually completes a full handshake in one round trip. A typical TLS 1.2 full handshake usually takes two. Both versions can be resumed, which changes the flow. TLS 1.3 also encrypts handshake messages after ServerHello and removes older key-exchange options.
Imagine that you open https://shop.example:
If the name is wrong, the certificate is not trusted, or the client and server cannot agree on settings, the connection can stop before the page loads.
Is an SSL handshake different from a TLS handshake?
People often use “SSL handshake” as an older name. Modern secure website connections use TLS; SSL should not be enabled.
Does the certificate contain the secret session key?
No. The certificate helps the client check the server identity and its proof. The client and server derive separate traffic keys for the connection.
Often, the SNI name is visible in the ClientHello. Encrypted Client Hello can protect it when both the client and server support and use it.
Continue reading
Learn the TLS 1.3 handshake step by step, read packet captures in Wireshark, inspect OpenSSL output, and troubleshoot common certificate failures.
Find common TLS handshake problems with OpenSSL, curl, and DNS checks, then learn what each result can tell you.
Reader signal
Your feedback helps shape the next field note and lab.
Views count when this page opens. You can change or remove your vote during this tab session.