Security for Developers #5: HTTPS and TLS — How Encryption Works

1. Client Hello
   Browser → Server: "I support TLS 1.3, here are the cipher suites I know"

2. Server Hello + Certificate
   Server → Browser: "Let's use TLS 1.3 with this cipher suite. Here is my certificate."

3. Certificate Verification
   Browser checks: Is the certificate valid? Is it issued by a trusted CA?
   Is the domain name correct? Has it expired?

4. Key Exchange
   Browser and server agree on a shared secret key using
   Diffie-Hellman key exchange. This key is unique to this session.

5. Encrypted Communication
   All data is now encrypted with the shared key.
   Neither side sends the key over the network.

1. Server owner generates a key pair (public + private)
2. Server owner sends a Certificate Signing Request (CSR) to a Certificate Authority (CA)
3. CA verifies that the owner controls the domain
4. CA signs the certificate with the CA's private key
5. Browser has a list of trusted CAs built in
6. When connecting, browser verifies the certificate signature against the trusted CA list

# Install Certbot
sudo apt update
sudo apt install certbot python3-certbot-nginx

# Get a certificate and configure Nginx automatically
sudo certbot --nginx -d example.com -d www.example.com

# Certbot will:
# 1. Verify you own the domain
# 2. Download the certificate
# 3. Configure Nginx to use HTTPS
# 4. Set up auto-redirect from HTTP to HTTPS

# Test auto-renewal
sudo certbot renew --dry-run

# Certbot adds a cron job or systemd timer automatically
# Certificates renew when they have less than 30 days left

# docker-compose.yml
services:
  certbot:
    image: certbot/certbot
    volumes:
      - ./certbot/conf:/etc/letsencrypt
      - ./certbot/www:/var/www/certbot
    command: certonly --webroot -w /var/www/certbot -d example.com

  nginx:
    image: nginx
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./certbot/conf:/etc/letsencrypt
      - ./certbot/www:/var/www/certbot

package main

import (
    "crypto/tls"
    "log"
    "net/http"
    "golang.org/x/crypto/acme/autocert"
)

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello, HTTPS!"))
    })

    // Auto-obtain and renew Let's Encrypt certificates
    manager := &autocert.Manager{
        Cache:      autocert.DirCache("certs"),
        Prompt:     autocert.AcceptTOS,
        HostPolicy: autocert.HostWhitelist("example.com"),
    }

    server := &http.Server{
        Addr:    ":443",
        Handler: mux,
        TLSConfig: &tls.Config{
            GetCertificate: manager.GetCertificate,
            MinVersion:     tls.VersionTLS12,
        },
    }

    // Redirect HTTP to HTTPS
    go http.ListenAndServe(":80", manager.HTTPHandler(nil))

    log.Println("Starting HTTPS server on :443")
    log.Fatal(server.ListenAndServeTLS("", ""))
}

# Development only — self-signed certificate
from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello, HTTPS!"

if __name__ == "__main__":
    app.run(ssl_context="adhoc")  # Development only!

# Production: use Nginx + Let's Encrypt as a reverse proxy
# Flask should NOT handle TLS directly in production

const https = require('https');
const fs = require('fs');
const express = require('express');

const app = express();

app.get('/', (req, res) => {
    res.send('Hello, HTTPS!');
});

// Load Let's Encrypt certificates
const options = {
    key: fs.readFileSync('/etc/letsencrypt/live/example.com/privkey.pem'),
    cert: fs.readFileSync('/etc/letsencrypt/live/example.com/fullchain.pem'),
};

https.createServer(options, app).listen(443, () => {
    console.log('HTTPS server running on port 443');
});

// Redirect HTTP to HTTPS
const http = require('http');
http.createServer((req, res) => {
    res.writeHead(301, { Location: `https://${req.headers.host}${req.url}` });
    res.end();
}).listen(80);

Strict-Transport-Security: max-age=63072000; includeSubDomains; preload

// Go
func HSTSMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Strict-Transport-Security",
            "max-age=63072000; includeSubDomains; preload")
        next.ServeHTTP(w, r)
    })
}

# Nginx
server {
    listen 443 ssl;
    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains; preload" always;
}

# Nginx
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384;
ssl_prefer_server_ciphers off;

// Using OkHttp
val certificatePinner = CertificatePinner.Builder()
    .add("api.example.com", "sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=")
    .build()

val client = OkHttpClient.Builder()
    .certificatePinner(certificatePinner)
    .build()

// Using URLSession
class PinnedSessionDelegate: NSObject, URLSessionDelegate {
    func urlSession(_ session: URLSession,
                    didReceive challenge: URLAuthenticationChallenge,
                    completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {

        guard let serverTrust = challenge.protectionSpace.serverTrust,
              let certificate = SecTrustGetCertificateAtIndex(serverTrust, 0) else {
            completionHandler(.cancelAuthenticationChallenge, nil)
            return
        }

        // Compare certificate with pinned certificate
        let serverCertData = SecCertificateCopyData(certificate) as Data
        if serverCertData == pinnedCertData {
            completionHandler(.useCredential, URLCredential(trust: serverTrust))
        } else {
            completionHandler(.cancelAuthenticationChallenge, nil)
        }
    }
}

<!-- Bad — HTTP image on HTTPS page -->
<img src="http://example.com/image.png">

<!-- Good — use HTTPS or protocol-relative URLs -->
<img src="https://example.com/image.png">
<img src="//example.com/image.png">

# Check certificate expiration
echo | openssl s_client -servername example.com -connect example.com:443 2>/dev/null | openssl x509 -noout -dates

# Nginx — redirect HTTP to HTTPS
server {
    listen 80;
    server_name example.com;
    return 301 https://$host$request_uri;
}

# Install
git clone --depth 1 https://github.com/drwetter/testssl.sh.git

# Run
./testssl.sh/testssl.sh https://example.com

# Check TLS version and certificate
curl -vI https://example.com 2>&1 | grep -E "SSL|TLS|subject|expire"