TLS Fundamentals
TLS is a network security protocol that protects data moving between a client and server. It establishes shared keys, authenticates peers, and detects changes to data in transit.
itNetworking | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — TLS Fundamentals
TLS is the protocol that turns an untrusted network into a connection you can reason about. Before TLS, anything sent over the wire was readable by anyone who could tap it—which was most of the networks between you and wherever your packets were going. TLS gives you three things: confidentiality so observers cannot read the data, integrity so you know nobody changed it, and authentication so you know who is on the other end.
The two ideas everything else hangs off are handshake and record layer. The handshake negotiates parameters, proves identity, and derives shared keys. The record layer uses those keys to protect application data. That separation is why you can change cipher suites without rewriting your application, and why a connection can be encrypted to the wrong server if the handshake got the identity part wrong.
The part that surprises most people: encryption is not the point. A connection encrypted to an attacker is worse than useless—it is convincing. The certificate is what makes TLS useful, because it binds the connection to an identity you can verify. A chain of certificates leads from a leaf certificate identifying the server up to a trust anchor your client already accepts. If any link in that chain is missing, the validation fails, and it should.
What to read next depends on what just went wrong. If the handshake is failing, the Slides tab has the negotiation sequence. If certificates are the issue, the Cheatsheet shows validation rules and failure clues. If you want to know where TLS actually terminates in your architecture—and it might not be where you think—start with Field Notes. The Reference tab has the RFCs for everything mentioned here, arranged from foundational to advanced.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://www.rfc-editor.org/rfc/rfc9846.html
Supports
- TLS 1.3 handshake flow, key schedule, authentication, Finished messages, and record protection
- TLS 1.3 cipher suites select authenticated encryption and a hash while key exchange and signatures are negotiated separately
- Session resumption uses pre-shared keys and can combine them with fresh key shares
- Zero round trip time early data has replay risk
- Mutual TLS certificate authentication and private-key proof
- TLS protects a connection between its endpoints
- https://www.rfc-editor.org/rfc/rfc9325.html
Supports
- Secure deployment guidance prefers TLS 1.3 and forbids SSL 2, SSL 3, TLS 1.0, and TLS 1.1
- TLS 1.2 remains a compatibility option when configured according to current guidance
- Resumption ticket protection, rotation, and forward-secrecy guidance
- SNI and ALPN deployment guidance
- Strict TLS and HSTS reduce plaintext downgrade exposure
- https://www.rfc-editor.org/rfc/rfc5280.html
Supports
- X.509 certificate and certificate revocation list profile
- Trust anchors, certificate extensions, constraints, validity, and certification-path validation
- https://www.rfc-editor.org/rfc/rfc9525.html
Supports
- TLS service-identity construction and verification
- Subject Alternative Name identifiers replace Common Name for service identity
- DNS, IP, service, and URI identifier matching
- Clients should terminate when no presented identifier matches a reference identifier
- https://www.rfc-editor.org/rfc/rfc6066.html
Supports
- Server Name Indication carries a DNS hostname in ClientHello
- SNI supports certificate and policy selection for virtual services on one network address
- https://www.rfc-editor.org/rfc/rfc7301.html
Supports
- ALPN lets peers select an application protocol during the TLS handshake
- https://developer.mozilla.org/en-US/docs/Web/Security/Defenses/Transport_Layer_Security
Supports
- TLS provides confidentiality, integrity, and authentication across an untrusted network
- HTTPS uses TLS to protect HTTP
- The web TLS handshake negotiates protocol parameters and authenticates servers
- HSTS helps resist downgrade to unprotected HTTP
- https://github.com/sindresorhus/awesome
Supports
- Discovery index for curated security and networking awesome lists
- https://github.com/sbilly/awesome-security
Supports
- Security ecosystem list discovered from the main Awesome index
- https://github.com/decalage2/awesome-security-hardening
Supports
- TLS and SSL section lists Qualys SSL Labs, CryptoLyzer, SSLyze, and testssl.sh
- TLS configuration section lists the Mozilla SSL Configuration Generator
- https://www.ssllabs.com/
Supports
- SSL Labs provides hosted server certificate and TLS configuration testing
- https://nabla-c0d3.github.io/sslyze/documentation/
Supports
- SSLyze provides command-line and Python-driven TLS server scans
- Scan commands cover certificate, cipher-suite, resumption, and vulnerability checks
- https://testssl.sh/
Supports
- testssl.sh checks TLS protocols, cipher support, and cryptographic flaws on TLS and STARTTLS services
- The tool runs locally and supports machine-readable output
- https://mozilla.github.io/server-side-tls/ssl-config-generator/
Supports
- TLSRef generates sample TLS configurations by server software and compatibility profile
- https://gitlab.com/coroner/cryptolyzer
Supports
- CryptoLyzer is a multi-protocol cryptographic analyzer covering TLS, SSH, IKE, and DNS
- Independent protocol stack detects cipher suites and extensions that OpenSSL-based tools miss
- https://www.rfc-editor.org/rfc/rfc6176.html
Supports
- SSL 2.0 is formally prohibited and its historical specification is cited in this RFC
- SSL 2.0 had design limitations including MD5-only MAC and shared encryption and authentication key
- https://www.rfc-editor.org/rfc/rfc6101.html
Supports
- SSL 3.0 specification separated data transport from the message layer
- SSL 3.0 added Diffie-Hellman key exchange and became the foundation for all subsequent TLS versions
- https://www.rfc-editor.org/rfc/rfc2246.html
Supports
- TLS 1.0 standardized SSL as Transport Layer Security
- TLS 1.0 replaced the custom MAC with HMAC and expanded alert codes
- https://www.rfc-editor.org/rfc/rfc4346.html
Supports
- TLS 1.1 added explicit per-record initialization vectors for CBC cipher suites
- Per-record IVs addressed the chosen-plaintext weakness demonstrated by BEAST against TLS 1.0
- https://www.rfc-editor.org/rfc/rfc7507.html
Supports
- TLS Fallback SCSV defines a signaling cipher suite value preventing protocol downgrade attacks
- Server detects when a client has fallen back to a lower TLS version than the server supports
- https://nvd.nist.gov/vuln/detail/CVE-2011-3389
Supports
- BEAST is a practical chosen-plaintext attack against TLS 1.0 CBC mode
- BEAST could recover HTTPS session cookies via man-in-the-middle position
- https://www.cisa.gov/news-events/alerts/2014/10/17/ssl-30-protocol-vulnerability-and-poodle-attack
Supports
- POODLE is a padding oracle attack against SSL 3.0 CBC mode
- POODLE enabled byte-by-byte decryption and caused all major browsers to disable SSL 3.0
- https://www.rfc-editor.org/rfc/rfc8446.html
Supports
- TLS 1.3 removed RSA key exchange and eliminated CBC ciphers
- TLS 1.3 reduced the handshake to one round trip with mandatory forward secrecy
- https://googlechrome.github.io/CertificateTransparency/ct_policy.html
Supports
- Chrome required signed certificate timestamps for all publicly trusted certificates
- Certificate Transparency enforcement made certificate issuance auditable by design
- https://www.rfc-editor.org/rfc/rfc8555.html
Supports
- ACME protocol automates certificate issuance and renewal through HTTP-based challenges
- Let's Encrypt used ACME to drive mass HTTPS adoption from roughly 45 percent to over 95 percent
- https://www.rfc-editor.org/rfc/rfc9001.html
Supports
- QUIC uses TLS 1.3 for its handshake and key schedule
- QUIC replaces the TLS record layer with its own packet protection for UDP-based transport
- https://blog.cloudflare.com/why-certificate-pinning-is-outdated/
Supports
- Certificate pinning creates operational outages when certificates are rotated for compliance
- OWASP concludes pinning marginal security benefit does not justify operational cost for most applications
- https://owasp.org/www-community/controls/Certificate_and_Public_Key_Pinning
Supports
- Certificate and public key pinning is an OWASP control with documented operational risks
- https://docs.openssl.org/master/man1/openssl-s_client/
Supports
- s_client connection syntax and the -servername option for sending Server Name Indication
- The -showcerts option printing the certificate chain the peer sent
- The -verify_hostname and -verify_return_error options for checking a reference identity and failing on verification errors
- Protocol version restriction options for testing which versions an endpoint accepts
- Reporting of negotiated protocol version, cipher suite, and the verify return code
- https://docs.openssl.org/master/man1/openssl-x509/
Supports
- Certificate inspection of subject, issuer, validity dates, and named extensions
