Deployment-Härtung + Podman-Container

- http.Server mit Timeouts (Slowloris) und Graceful Shutdown (SIGTERM)
- Adresse und DB-Pfad per Env (KVER_ADDR, KVER_DB)
- Security-Header global: nosniff, X-Frame-Options, Referrer-Policy, CSP
- Upload-Requests hart auf 17 MB gedeckelt (MaxBytesReader statt nur
  Multipart-Speichergrenze)
- Indizes für Feed-, Thread- und Vote-Queries
- middleware.RealIP für Logging/Rate-Limit hinter dem Reverse-Proxy
- Containerfile (Multi-Stage, Alpine, non-root) + Deploy-Doku in notes/

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

main.go

@@ -1,9 +1,13 @@
 package main
 
 import (
+	"context"
 	"encoding/json"
 	"log"
 	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
 	"time"
 
 	"github.com/go-chi/chi/v5"
@@ -12,22 +16,65 @@ import (
 )
 
 func main() {
-	if err := initDB("kver.db"); err != nil {
+	if err := initDB(envOr("KVER_DB", "kver.db")); err != nil {
 		log.Fatalf("db init: %v", err)
 	}
 	defer db.Close()
 
-	const addr = ":8080"
-	log.Printf("kver listening on %s", addr)
-	log.Fatal(http.ListenAndServe(addr, routes()))
+	srv := &http.Server{
+		Addr:    envOr("KVER_ADDR", ":8080"),
+		Handler: routes(),
+		// Timeouts gegen festhängende/langsame Verbindungen (Slowloris). Read
+		// und Write großzügig genug für 16-MB-Uploads über langsame Leitungen.
+		ReadHeaderTimeout: 10 * time.Second,
+		ReadTimeout:       2 * time.Minute,
+		WriteTimeout:      2 * time.Minute,
+		IdleTimeout:       2 * time.Minute,
+	}
+
+	// Graceful Shutdown: auf SIGINT/SIGTERM laufende Requests zu Ende bedienen,
+	// dann die DB sauber schließen (WAL-Checkpoint) statt hart abzubrechen.
+	idle := make(chan struct{})
+	go func() {
+		sig := make(chan os.Signal, 1)
+		signal.Notify(sig, os.Interrupt, syscall.SIGTERM)
+		<-sig
+		ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+		defer cancel()
+		if err := srv.Shutdown(ctx); err != nil {
+			log.Printf("shutdown: %v", err)
+		}
+		close(idle)
+	}()
+
+	log.Printf("kver listening on %s", srv.Addr)
+	if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+		log.Fatalf("listen: %v", err)
+	}
+	<-idle
+}
+
+// envOr liest eine Umgebungsvariable mit Fallback auf einen Default.
+func envOr(key, fallback string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return fallback
 }
 
 // routes baut den HTTP-Handler mit allen Endpunkten. In main() und in den
 // Tests identisch verwendet.
 func routes() http.Handler {
 	r := chi.NewRouter()
+	// RealIP übernimmt X-Forwarded-For/X-Real-IP vom Reverse-Proxy, damit
+	// Logging und das IP-Rate-Limit unten den Client statt den Proxy sehen.
+	// Voraussetzung: die App ist nur über den Proxy erreichbar (Deployment
+	// bindet an 127.0.0.1, siehe notes/deploy.md) — sonst wären die Header
+	// spoofbar.
+	r.Use(middleware.RealIP)
 	r.Use(middleware.Logger)
 	r.Use(middleware.Recoverer)
+	r.Use(secHeaders)
 
 	// --- Auth (öffentlich) ---
 	// Login und Registrierung pro IP drosseln (Brute-Force-Bremse). bcrypt bremst
@@ -65,10 +112,11 @@ func routes() http.Handler {
 		r.Post("/user/delete", handleUserDelete)
 	})
 
-	// Hochgeladene Medien + alte statische Assets. nosniff verhindert, dass der
-	// Browser eine durchgereichte (nicht re-kodierte) Datei als HTML/JS
-	// interpretiert -> schließt Polyglot/Stored-XSS über Bild-Uploads.
-	r.Handle("/static/*", http.StripPrefix("/static/", noSniff(http.FileServer(http.Dir("static")))))
+	// Hochgeladene Medien + alte statische Assets. nosniff (global via
+	// secHeaders) verhindert, dass der Browser eine durchgereichte (nicht
+	// re-kodierte) Datei als HTML/JS interpretiert -> schließt
+	// Polyglot/Stored-XSS über Bild-Uploads.
+	r.Handle("/static/*", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
 
 	// Neues JS-Frontend
 	r.Handle("/*", http.FileServer(http.Dir("web")))
@@ -76,12 +124,21 @@ func routes() http.Handler {
 	return r
 }
 
-// noSniff setzt X-Content-Type-Options: nosniff, damit der Browser den
-// deklarierten Content-Type nicht überstimmt (Schutz vor Content-Sniffing).
-func noSniff(h http.Handler) http.Handler {
+// secHeaders setzt Standard-Security-Header auf alle Antworten:
+//   - nosniff: Browser darf den deklarierten Content-Type nicht überstimmen
+//     (wichtig für durchgereichte GIF-Uploads, siehe storeImage).
+//   - Frame-Verbote gegen Clickjacking.
+//   - CSP als Defense-in-depth gegen XSS: das Frontend hat kein Inline-JS/CSS,
+//     daher reicht 'self' ohne unsafe-inline.
+func secHeaders(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("X-Content-Type-Options", "nosniff")
-		h.ServeHTTP(w, r)
+		h := w.Header()
+		h.Set("X-Content-Type-Options", "nosniff")
+		h.Set("X-Frame-Options", "DENY")
+		h.Set("Referrer-Policy", "same-origin")
+		h.Set("Content-Security-Policy",
+			"default-src 'self'; frame-ancestors 'none'; base-uri 'none'; form-action 'self'")
+		next.ServeHTTP(w, r)
 	})
 }