Topic Overview

TLS/SSL Handshake

Master the TLS/SSL handshake process for establishing secure encrypted connections, including certificate validation, key exchange, and cipher suite negotiation.

TLS (Transport Layer Security) and SSL (Secure Sockets Layer) provide encrypted communication over networks. The handshake process establishes a secure connection by negotiating encryption parameters, authenticating parties, and exchanging keys.

What is TLS/SSL?

TLS/SSL provides:

  • Encryption: Data is encrypted in transit
  • Authentication: Verifies server (and optionally client) identity
  • Integrity: Detects tampering with data

Note: SSL is deprecated, TLS is the modern standard (TLS 1.2, TLS 1.3)

TLS Handshake Process

Step-by-Step Handshake

Client                          Server
   |                               |
   | 1. Client Hello               |
   |------------------------------>|
   |    - TLS version               |
   |    - Cipher suites             |
   |    - Random number             |
   |    - Supported extensions      |
   |                               |
   | 2. Server Hello                |
   |<------------------------------|
   |    - Selected TLS version      |
   |    - Selected cipher suite     |
   |    - Random number             |
   |    - Server certificate        |
   |                               |
   | 3. Certificate Validation      |
   |    (Client verifies cert)      |
   |                               |
   | 4. Key Exchange                |
   |    - Client generates pre-master secret |
   |    - Encrypts with server's public key |
   |------------------------------>|
   |                               |
   | 5. Change Cipher Spec          |
   |<------------------------------|
   |    (Switch to encrypted)       |
   |                               |
   | 6. Encrypted Handshake         |
   |<------------------------------|
   |    (Verify handshake)          |
   |                               |
   | 7. Application Data            |
   |<==============================>|
   |    (Encrypted communication)   |

Detailed Handshake Steps

1. Client Hello

Client initiates handshake:

Client Hello:
  - TLS Version: TLS 1.2, TLS 1.3
  - Cipher Suites: List of supported encryption methods
  - Random Number: Client random (28 bytes)
  - Session ID: (for resumption)
  - Compression Methods: (deprecated in TLS 1.3)
  - Extensions: SNI, ALPN, etc.

Example:

TLS Version: TLS 1.2
Cipher Suites:
  - TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
  - TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
  - TLS_RSA_WITH_AES_256_GCM_SHA384
Random: [28 random bytes]
Server Name: example.com (SNI)

2. Server Hello

Server responds:

Server Hello:
  - Selected TLS Version: TLS 1.2
  - Selected Cipher Suite: TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
  - Random Number: Server random (28 bytes)
  - Session ID: (for resumption)
  - Certificate: Server's X.509 certificate
  - Server Key Exchange: (for ECDHE)
  - Certificate Request: (optional, for client auth)
  - Server Hello Done

3. Certificate Validation

Client validates server certificate:

1. Check certificate chain
   Root CA → Intermediate CA → Server Certificate

2. Verify signature
   - Certificate signed by trusted CA
   - Signature is valid

3. Check validity
   - Not expired
   - Not revoked (OCSP/CRL)

4. Verify domain
   - Certificate matches domain (CN or SAN)

4. Key Exchange

RSA Key Exchange (TLS 1.2):

1. Client generates pre-master secret (48 bytes)
2. Client encrypts with server's public key
3. Client sends encrypted pre-master secret
4. Server decrypts with private key
5. Both derive master secret from pre-master secret

ECDHE Key Exchange (TLS 1.2, TLS 1.3):

1. Server sends: Server key exchange (ECDHE parameters)
2. Client sends: Client key exchange (ECDHE parameters)
3. Both compute: Shared secret using ECDH
4. Both derive: Master secret from shared secret

5. Change Cipher Spec

Both parties switch to encrypted communication:

Client → Server: Change Cipher Spec
Server → Client: Change Cipher Spec

6. Encrypted Handshake

Verify handshake integrity:

Client → Server: Encrypted Handshake (Finished)
Server → Client: Encrypted Handshake (Finished)

Both verify handshake messages haven't been tampered with.

7. Application Data

Secure communication begins:

All subsequent data is encrypted using:
  - Symmetric encryption (AES)
  - Keys derived from master secret

TLS 1.3 Improvements

TLS 1.3 simplifies and speeds up the handshake:

Key Changes:

  1. 1-RTT handshake: Reduced from 2 round trips to 1
  2. Removed insecure ciphers: Only secure cipher suites
  3. 0-RTT resumption: Send data in first message (for resumed sessions)
  4. Forward secrecy: Only ECDHE key exchange

TLS 1.3 Handshake:

Client                          Server
   |                               |
   | Client Hello                  |
   | + Key Share (ECDHE)           |
   |------------------------------>|
   |                               |
   | Server Hello                  |
   | + Key Share (ECDHE)            |
   | + Certificate                 |
   | + Encrypted Extensions        |
   | + Finished                    |
   |<------------------------------|
   |                               |
   | Finished                      |
   |------------------------------>|
   |                               |
   | Application Data              |
   |<==============================>|

1-RTT: Handshake completes in one round trip (vs 2 in TLS 1.2)

Examples

TLS Handshake in Python

import ssl
import socket

def tls_handshake_example():
    # Create SSL context
    context = ssl.create_default_context()
    
    # Create socket
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
    # Wrap socket with SSL
    ssl_sock = context.wrap_socket(sock, server_hostname='example.com')
    
    # Connect (handshake happens here)
    ssl_sock.connect(('example.com', 443))
    
    # Get certificate
    cert = ssl_sock.getpeercert()
    print(f"Certificate: {cert['subject']}")
    
    # Get cipher suite
    cipher = ssl_sock.cipher()
    print(f"Cipher: {cipher[0]}")
    print(f"TLS Version: {ssl_sock.version()}")
    
    # Send encrypted data
    ssl_sock.send(b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")
    
    ssl_sock.close()

# Usage
tls_handshake_example()

Certificate Validation

import ssl
import socket
from cryptography import x509
from cryptography.hazmat.backends import default_backend

def validate_certificate(hostname, port=443):
    # Create context
    context = ssl.create_default_context()
    
    # Connect
    with socket.create_connection((hostname, port)) as sock:
        with context.wrap_socket(sock, server_hostname=hostname) as ssl_sock:
            # Get certificate
            cert_der = ssl_sock.getpeercert(binary_form=True)
            cert = x509.load_der_x509_certificate(cert_der, default_backend())
            
            # Validate
            print(f"Subject: {cert.subject}")
            print(f"Issuer: {cert.issuer}")
            print(f"Valid from: {cert.not_valid_before}")
            print(f"Valid until: {cert.not_valid_after}")
            
            # Check expiration
            from datetime import datetime
            if cert.not_valid_after < datetime.now():
                print("Certificate expired!")
            else:
                print("Certificate valid")

# Usage
validate_certificate('example.com')

TLS Version Detection

import ssl
import socket

def detect_tls_version(hostname, port=443):
    # Try different TLS versions
    versions = {
        ssl.PROTOCOL_TLSv1_2: 'TLS 1.2',
        ssl.PROTOCOL_TLSv1_3: 'TLS 1.3'
    }
    
    for protocol, name in versions.items():
        try:
            context = ssl.SSLContext(protocol)
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            ssl_sock = context.wrap_socket(sock, server_hostname=hostname)
            ssl_sock.connect((hostname, port))
            
            print(f"Supported: {name}")
            print(f"Negotiated: {ssl_sock.version()}")
            ssl_sock.close()
            break
        except ssl.SSLError:
            continue

# Usage
detect_tls_version('example.com')

Common Pitfalls

  • Certificate validation disabled: Not validating certificates allows man-in-the-middle attacks. Fix: Always validate certificates
  • Weak cipher suites: Using weak encryption. Fix: Use strong cipher suites (AES-GCM, ChaCha20-Poly1305)
  • TLS version too old: TLS 1.0, 1.1 are insecure. Fix: Use TLS 1.2 or 1.3
  • Certificate expiration: Not checking expiration. Fix: Monitor certificate expiration, auto-renew
  • Mixed content: HTTP resources on HTTPS pages. Fix: Use HTTPS for all resources
  • SNI not configured: Server doesn't know which certificate to send. Fix: Configure Server Name Indication (SNI)
  • OCSP stapling not enabled: Slower certificate validation. Fix: Enable OCSP stapling

Interview Questions

Beginner

Q: What is TLS/SSL and why is it important?

A:

TLS/SSL (Transport Layer Security / Secure Sockets Layer) provides encrypted, authenticated communication over networks.

Why important:

  1. Encryption: Protects data from eavesdropping
  2. Authentication: Verifies server identity (prevents man-in-the-middle)
  3. Integrity: Detects data tampering

How it works:

1. Client initiates handshake
2. Server sends certificate
3. Client validates certificate
4. Key exchange (establish shared secret)
5. Switch to encrypted communication
6. All data encrypted

Example:

  • Without TLS: Data sent in plaintext (readable by anyone)
  • With TLS: Data encrypted (only client and server can read)

Common use:

  • HTTPS (HTTP over TLS)
  • Secure email (SMTP/TLS)
  • VPN connections

Intermediate

Q: Explain the TLS handshake process step by step.

A:

TLS Handshake (TLS 1.2):

  1. Client Hello

    • Client sends: TLS version, cipher suites, random number
    • Server receives: List of supported encryption methods

  2. Server Hello

    • Server sends: Selected TLS version, cipher suite, random number, certificate
    • Client receives: Server's certificate and encryption parameters

  3. Certificate Validation

    • Client validates: Certificate chain, signature, expiration, domain match
    • If invalid: Handshake fails

  4. Key Exchange

    • RSA: Client encrypts pre-master secret with server's public key
    • ECDHE: Both exchange ECDHE parameters, compute shared secret
    • Both derive: Master secret from pre-master/shared secret

  5. Change Cipher Spec

    • Both parties: Switch to encrypted communication

  6. Encrypted Handshake

    • Both send: Encrypted "Finished" message
    • Verify: Handshake integrity

  7. Application Data

    • All subsequent data: Encrypted using symmetric encryption

TLS 1.3 Improvements:

  • 1-RTT handshake: Reduced to 1 round trip (vs 2 in TLS 1.2)
  • Only secure ciphers: Removed insecure cipher suites
  • 0-RTT resumption: Send data in first message (for resumed sessions)

Senior

Q: Design a TLS termination system for a high-traffic web application. How do you handle certificate management, TLS version negotiation, and performance optimization?

A:

class TLSTerminationSystem {
  private certificateManager: CertificateManager;
  private tlsConfig: TLSConfig;
  private sessionCache: SessionCache;
  private ocspStapling: OCSPStapling;
  
  constructor() {
    this.certificateManager = new CertificateManager({
      autoRenew: true,
      acmeProvider: 'letsencrypt'
    });
    
    this.tlsConfig = new TLSConfig({
      minVersion: 'TLS 1.2',
      maxVersion: 'TLS 1.3',
      cipherSuites: [
        'TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384',
        'TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256',
        'TLS_CHACHA20_POLY1305_SHA256'
      ]
    });
    
    this.sessionCache = new SessionCache({
      backend: 'redis',
      ttl: 3600 // 1 hour
    });
    
    this.ocspStapling = new OCSPStapling({
      enabled: true,
      refreshInterval: 3600
    });
  }
  
  // 1. TLS Termination
  async handleConnection(connection: TLSConnection): Promise<void> {
    // Get certificate for domain (SNI)
    const domain = connection.getServerName();
    const certificate = await this.certificateManager.getCertificate(domain);
    
    // Configure TLS
    connection.setCertificate(certificate);
    connection.setTLSConfig(this.tlsConfig);
    
    // Enable session resumption
    connection.enableSessionResumption(this.sessionCache);
    
    // Enable OCSP stapling
    const ocspResponse = await this.ocspStapling.getStapledResponse(certificate);
    connection.setOCSPStapling(ocspResponse);
    
    // Perform handshake
    await connection.handshake();
  }
  
  // 2. Certificate Management
  class CertificateManager {
    async getCertificate(domain: string): Promise<Certificate> {
      // Check cache
      let cert = await this.cache.get(domain);
      if (cert && !this.isExpiringSoon(cert)) {
        return cert;
      }
      
      // Auto-renew if expiring
      if (cert && this.isExpiringSoon(cert)) {
        cert = await this.renewCertificate(domain);
      } else {
        cert = await this.loadCertificate(domain);
      }
      
      await this.cache.set(domain, cert);
      return cert;
    }
    
    async renewCertificate(domain: string): Promise<Certificate> {
      // Use ACME (Let's Encrypt) for auto-renewal
      const acme = new ACMEClient();
      return await acme.obtainCertificate(domain);
    }
  }
  
  // 3. Session Resumption (Performance)
  class SessionCache {
    async getSession(sessionId: string): Promise<Session | null> {
      return await this.redis.get(`tls_session:${sessionId}`);
    }
    
    async setSession(sessionId: string, session: Session): Promise<void> {
      await this.redis.setex(
        `tls_session:${sessionId}`,
        3600, // 1 hour
        session
      );
    }
  }
  
  // 4. OCSP Stapling (Performance)
  class OCSPStapling {
    async getStapledResponse(certificate: Certificate): Promise<OCSPResponse> {
      // Check cache
      let response = await this.cache.get(certificate.serial);
      if (response && !this.isExpired(response)) {
        return response;
      }
      
      // Fetch from OCSP server
      response = await this.fetchOCSPResponse(certificate);
      
      // Cache response
      await this.cache.set(certificate.serial, response, 3600);
      
      return response;
    }
  }
  
  // 5. TLS Version Negotiation
  class TLSConfig {
    negotiateVersion(clientVersions: string[]): string {
      // Prefer TLS 1.3, fallback to 1.2
      if (clientVersions.includes('TLS 1.3')) {
        return 'TLS 1.3';
      } else if (clientVersions.includes('TLS 1.2')) {
        return 'TLS 1.2';
      } else {
        throw new Error('No supported TLS version');
      }
    }
  }
  
  // 6. Performance Optimization
  async optimizePerformance(): Promise<void> {
    // Enable session resumption (0-RTT for TLS 1.3)
    this.enableSessionResumption();
    
    // Enable OCSP stapling (avoid OCSP lookup)
    this.enableOCSPStapling();
    
    // Use TLS 1.3 (1-RTT handshake)
    this.preferTLS13();
    
    // Connection pooling
    this.enableConnectionPooling();
  }
}

Features:

  1. Certificate management: Auto-renewal, ACME integration
  2. Session resumption: Cache sessions for 0-RTT (TLS 1.3)
  3. OCSP stapling: Cache OCSP responses, avoid lookups
  4. TLS version negotiation: Prefer TLS 1.3, fallback to 1.2
  5. Performance optimization: Session cache, connection pooling
  6. Monitoring: Track handshake performance, certificate expiration

Key Takeaways

  • TLS/SSL: Provides encryption, authentication, and integrity for network communication
  • Handshake process: Client hello → Server hello → Certificate validation → Key exchange → Encrypted communication
  • TLS 1.3: 1-RTT handshake (vs 2-RTT in TLS 1.2), only secure ciphers, 0-RTT resumption
  • Certificate validation: Check chain, signature, expiration, domain match
  • Key exchange: RSA (encrypt pre-master) or ECDHE (compute shared secret)
  • Session resumption: Cache sessions for faster subsequent connections
  • OCSP stapling: Include OCSP response in handshake to avoid lookups
  • Best practices: Use TLS 1.2 or 1.3, strong cipher suites, validate certificates, monitor expiration

About the author

InterviewCrafted helps you master system design with patience. We believe in curiosity-led engineering, reflective writing, and designing systems that make future changes feel calm.