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>

.containerignore

@@ -0,0 +1,16 @@
+# Nicht ins Image: lokale DB, Uploads, Backups, Werkzeug-Kram.
+.git
+.gitignore
+prod_backup/
+notes/
+venv/
+__pycache__/
+kver
+*.db
+*.db-shm
+*.db-wal
+*.db.bak
+static/media/
+migrate.sh
+Containerfile
+.containerignore

Containerfile

@@ -0,0 +1,25 @@
+# Build-Stage: statisches Binary, CGO aus (modernc.org/sqlite ist pures Go).
+FROM docker.io/library/golang:1.26-alpine AS build
+WORKDIR /src
+COPY go.mod go.sum ./
+RUN go mod download
+COPY *.go ./
+RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /kver .
+
+# Laufzeit-Stage: minimales Alpine, eigener unprivilegierter Nutzer.
+FROM docker.io/library/alpine:3.22
+RUN adduser -D -u 1000 kver
+WORKDIR /app
+COPY --from=build /kver /usr/local/bin/kver
+COPY web/ web/
+COPY static/ static/
+# data: SQLite-DB; static/media: Uploads. Beide als Volume persistieren.
+RUN mkdir -p data static/media && chown kver:kver data static/media
+USER kver
+ENV KVER_DB=/app/data/kver.db
+ENV KVER_ADDR=:8080
+EXPOSE 8080
+VOLUME ["/app/data", "/app/static/media"]
+HEALTHCHECK --interval=30s --timeout=3s \
+  CMD wget -qO /dev/null http://localhost:8080/entry/feed/0 || exit 1
+ENTRYPOINT ["/usr/local/bin/kver"]

db.go

@@ -48,6 +48,16 @@ CREATE TABLE IF NOT EXISTS vote (
     mode TEXT,
     UNIQUE(uid, pid)
 );
+
+-- Indizes für die häufigen Zugriffspfade; ohne sie werden Feed (ORDER BY
+-- last_activity), Thread (WHERE reply_to) und Vote-Zähler (WHERE pid) mit
+-- wachsender Tabelle zu Full-Table-Scans. username/session.value/vote(uid,pid)
+-- sind über UNIQUE bereits indiziert.
+CREATE INDEX IF NOT EXISTS idx_entry_last_activity ON entry(last_activity);
+CREATE INDEX IF NOT EXISTS idx_entry_reply_to      ON entry(reply_to);
+CREATE INDEX IF NOT EXISTS idx_entry_uid           ON entry(uid);
+CREATE INDEX IF NOT EXISTS idx_vote_pid            ON vote(pid);
+CREATE INDEX IF NOT EXISTS idx_session_uid         ON session(uid);
 `
 
 func initDB(dsn string) error {

entry.go

@@ -189,6 +189,10 @@ func handleThread(w http.ResponseWriter, r *http.Request) {
 func handleCreateEntry(w http.ResponseWriter, r *http.Request) {
 	uid := uidFromContext(r.Context())
 
+	// MaxBytesReader kappt den gesamten Request hart: ParseMultipartForm
+	// begrenzt nur den Speicher, alles darüber liefe sonst unbegrenzt in
+	// Temp-Dateien auf die Platte.
+	r.Body = http.MaxBytesReader(w, r.Body, maxUploadBytes)
 	if err := r.ParseMultipartForm(16 << 20); err != nil && err != http.ErrNotMultipart {
 		writeError(w, http.StatusBadRequest, "Ungültige Anfrage")
 		return
@@ -426,11 +430,15 @@ func handleVote(w http.ResponseWriter, r *http.Request) {
 }
 
 const (
-	maxImageSize   = 1024         // Zielkante beim Skalieren
+	maxImageSize   = 1024        // Zielkante beim Skalieren
-	maxImagePixels = 50_000_000   // pro Frame: Schutz vor Decompression-Bomb
+	maxImagePixels = 50_000_000  // pro Frame: Schutz vor Decompression-Bomb
-	maxGIFBytes    = 16 << 20     // Obergrenze für durchgereichte GIFs
+	maxGIFBytes    = 16 << 20    // Obergrenze für durchgereichte GIFs
-	maxGIFFrames   = 1000         // animiertes GIF: Frame-Budget
+	maxGIFFrames   = 1000        // animiertes GIF: Frame-Budget
-	maxGIFPixels   = 100_000_000  // animiertes GIF: Summe aller Frame-Pixel
+	maxGIFPixels   = 100_000_000 // animiertes GIF: Summe aller Frame-Pixel
+
+	// Hartes Limit für Upload-Requests insgesamt (Bild + Formularfelder +
+	// Multipart-Overhead), via http.MaxBytesReader.
+	maxUploadBytes = 17 << 20
 )
 
 // storeImage speichert ein hochgeladenes Bild unter static/media.

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"
+	srv := &http.Server{
-	log.Printf("kver listening on %s", addr)
+		Addr:    envOr("KVER_ADDR", ":8080"),
-	log.Fatal(http.ListenAndServe(addr, routes()))
+		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
+	// Hochgeladene Medien + alte statische Assets. nosniff (global via
-	// Browser eine durchgereichte (nicht re-kodierte) Datei als HTML/JS
+	// secHeaders) verhindert, dass der Browser eine durchgereichte (nicht
-	// interpretiert -> schließt Polyglot/Stored-XSS über Bild-Uploads.
+	// re-kodierte) Datei als HTML/JS interpretiert -> schließt
-	r.Handle("/static/*", http.StripPrefix("/static/", noSniff(http.FileServer(http.Dir("static")))))
+	// 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
+// secHeaders setzt Standard-Security-Header auf alle Antworten:
-// deklarierten Content-Type nicht überstimmt (Schutz vor Content-Sniffing).
+//   - nosniff: Browser darf den deklarierten Content-Type nicht überstimmen
-func noSniff(h http.Handler) http.Handler {
+//     (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 := w.Header()
-		h.ServeHTTP(w, r)
+		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)
 	})
 }
 

notes/deploy.md

@@ -0,0 +1,111 @@
+# Deployment mit Podman
+
+## Bauen
+
+```sh
+podman build -t kver .
+```
+
+Multi-Stage-Build (`Containerfile`): statisches Go-Binary (CGO aus, modernc-
+SQLite ist pures Go), Laufzeit-Image ist Alpine mit unprivilegiertem Nutzer.
+
+## Starten
+
+```sh
+podman run -d --name kver \
+  -p 127.0.0.1:8080:8080 \
+  -v kver-data:/app/data \
+  -v kver-media:/app/static/media \
+  kver
+```
+
+- `kver-data` hält die SQLite-DB (`/app/data/kver.db`), `kver-media` die
+  hochgeladenen Bilder. Beides Named Volumes -> überleben Image-Updates.
+- Port nur an localhost binden; nach außen geht es über den Reverse-Proxy.
+
+Konfiguration über Umgebungsvariablen:
+
+| Variable    | Default             | Bedeutung            |
+|-------------|---------------------|----------------------|
+| `KVER_ADDR` | `:8080`             | Listen-Adresse       |
+| `KVER_DB`   | `/app/data/kver.db` | Pfad zur SQLite-Datei |
+
+## Bestehende Daten übernehmen
+
+DB und Medien einmalig in die Volumes kopieren (Container muss dafür kurz
+gelaufen sein bzw. die Volumes existieren):
+
+```sh
+podman volume create kver-data
+podman volume create kver-media
+podman cp kver.db kver:/app/data/kver.db        # bei laufendem Container, oder:
+cp kver.db "$(podman volume inspect kver-data -f '{{.Mountpoint}}')/"
+cp static/media/* "$(podman volume inspect kver-media -f '{{.Mountpoint}}')/"
+```
+
+Danach Container neu starten. (Rootless: `podman unshare cp ...`, damit die
+UID-Zuordnung ins User-Namespace-Mapping passt.)
+
+## Reverse-Proxy (TLS)
+
+Der Container spricht nur HTTP. Davor gehört ein TLS-terminierender Proxy
+(Caddy/nginx), der `X-Forwarded-Proto: https` setzt — daran erkennt die App
+HTTPS und setzt das `Secure`-Flag auf den Session-Cookie (siehe `isHTTPS`).
+
+nginx-Beispiel:
+
+```nginx
+location / {
+    proxy_pass http://127.0.0.1:8080;
+    proxy_set_header X-Forwarded-Proto $scheme;
+    proxy_set_header X-Forwarded-For $remote_addr;
+    client_max_body_size 20m;   # Uploads bis 17 MB durchlassen
+}
+```
+
+`client_max_body_size` muss über dem App-Limit (17 MB, `maxUploadBytes`)
+liegen, sonst kappt nginx vor der App.
+
+Hinweis Rate-Limiting: `httprate.LimitByIP` auf den Auth-Routen sieht hinter
+einem Proxy die Proxy-IP. Entweder den Proxy die echte Client-IP als
+`X-Real-IP`/`X-Forwarded-For` setzen lassen und chi's `middleware.RealIP`
+vorschalten — oder damit leben, dass das Limit global statt pro IP wirkt.
+
+## Autostart mit systemd (Quadlet)
+
+`~/.config/containers/systemd/kver.container` (rootless):
+
+```ini
+[Unit]
+Description=kver (Kontrollverlust)
+
+[Container]
+Image=localhost/kver:latest
+PublishPort=127.0.0.1:8080:8080
+Volume=kver-data:/app/data
+Volume=kver-media:/app/static/media
+
+[Service]
+Restart=on-failure
+
+[Install]
+WantedBy=default.target
+```
+
+Aktivieren:
+
+```sh
+systemctl --user daemon-reload
+systemctl --user start kver
+loginctl enable-linger "$USER"   # damit der Dienst ohne Login läuft
+```
+
+## Update einspielen
+
+```sh
+podman build -t kver .
+systemctl --user restart kver    # bzw. podman stop kver && podman run ...
+```
+
+Die App fährt bei SIGTERM sauber herunter (laufende Requests werden zu Ende
+bedient, WAL-Checkpoint beim DB-Close).

user.go

@@ -128,6 +128,9 @@ func handleUserRename(w http.ResponseWriter, r *http.Request) {
 func handleSetAvatar(w http.ResponseWriter, r *http.Request) {
 	uid := uidFromContext(r.Context())
 
+	// Wie bei handleCreateEntry: Request-Größe hart deckeln, bevor Multipart
+	// in Temp-Dateien streamen darf.
+	r.Body = http.MaxBytesReader(w, r.Body, maxUploadBytes)
 	if err := r.ParseMultipartForm(16 << 20); err != nil {
 		writeError(w, http.StatusBadRequest, "Ungültige Anfrage")
 		return