TLS & HTTPS

What TLS Does

TLS (Transport Layer Security) provides three guarantees:

1. Confidentiality — data is encrypted; eavesdroppers see gibberish
2. Integrity — data can’t be modified in transit without detection
3. Authentication — you’re talking to the real server, not an impersonator

HTTPS is just HTTP over TLS. The S means your browser established a TLS connection before sending any HTTP data.

The TLS 1.3 Handshake

TLS 1.3 reduced the handshake from 2 round-trips (TLS 1.2) to just 1:

// TLS 1.3 Handshake (simplified)

// 1. Client Hello
//    Client → Server:
//    - Supported cipher suites
//    - Client's key share (Diffie-Hellman public key)
//    - SNI (Server Name Indication — which domain)

// 2. Server Hello + Encrypted Extensions
//    Server → Client:
//    - Chosen cipher suite
//    - Server's key share
//    - Certificate + signature
//    - Finished (verification)

// 3. Client Finished
//    Client → Server:
//    - Finished (verification)
//    - Application data can now flow!

interface TLSClientHello {
  supportedVersions: ["TLS 1.3"];
  cipherSuites: string[];
  keyShare: {
    group: "x25519" | "secp256r1";
    publicKey: Uint8Array;
  };
  sni: string; // "api.example.com"
}

Certificates and Trust

How does your browser know it’s really talking to google.com?

Certificate chain:

1. Google’s server presents a certificate signed by a Certificate Authority (CA)
2. The CA’s certificate is signed by a root CA
3. Root CA certificates are pre-installed in your browser/OS (the trust store)

interface X509Certificate {
  subject: string;          // "*.google.com"
  issuer: string;           // "Google Trust Services"
  validFrom: Date;
  validTo: Date;
  publicKey: Uint8Array;
  signature: Uint8Array;    // signed by issuer's private key
  extensions: {
    subjectAltNames: string[]; // domains this cert covers
    keyUsage: string[];
  };
}

function verifyCertChain(certs: X509Certificate[]): boolean {
  for (let i = 0; i < certs.length - 1; i++) {
    const cert = certs[i];
    const issuer = certs[i + 1];

    // Verify signature
    if (!verifySignature(cert, issuer.publicKey)) return false;

    // Check expiration
    if (cert.validTo < new Date()) return false;

    // Check issuer matches
    if (cert.issuer !== issuer.subject) return false;
  }

  // Last cert must be in trust store
  return trustStore.has(certs[certs.length - 1]);
}

Key Exchange: Diffie-Hellman

TLS uses Diffie-Hellman to create a shared secret without ever sending it over the wire. Even if someone records all the traffic, they can’t derive the key.

// Simplified Diffie-Hellman concept
// Both sides generate a key pair, exchange public keys,
// and independently derive the same shared secret

// Client: privateA, publicA = generate()
// Server: privateB, publicB = generate()

// Client sends publicA → Server
// Server sends publicB → Client

// Client computes: sharedSecret = combine(privateA, publicB)
// Server computes: sharedSecret = combine(privateB, publicA)
// Both get the same sharedSecret!

// An eavesdropper sees publicA and publicB
// but can't derive sharedSecret without a private key

Common TLS Issues

// Certificate pinning — extra security for mobile apps
const PINNED_HASHES = [
  "sha256/YLh1dUR9y6Kja30RrAn7JKnbQG/uEtLMkBgFF2Fuihg=",
];

function verifyPin(cert: X509Certificate): boolean {
  const hash = sha256(cert.publicKey);
  return PINNED_HASHES.includes(`sha256/${base64(hash)}`);
}

// Mixed content — loading HTTP resources on HTTPS page
// Browser blocks this to prevent downgrade attacks
// Always use HTTPS for everything

// HSTS — tell browsers to always use HTTPS
// Strict-Transport-Security: max-age=31536000; includeSubDomains

Key Takeaways

1. TLS provides encryption, integrity, and authentication — all three matter
2. TLS 1.3 is 1 round-trip — significantly faster than TLS 1.2
3. Certificates form a chain of trust back to pre-installed root CAs
4. Diffie-Hellman key exchange creates shared secrets without sending them over the wire
5. Perfect Forward Secrecy means compromising today’s key doesn’t reveal yesterday’s traffic