Kontrollverlust/main.go

package main

import (
	"context"
	"encoding/json"
	"log"
	"net/http"
	"net/url"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware"
	"github.com/go-chi/httprate"
)

func main() {
	// KVER_DIR: Verzeichnis mit web/ und static/. Per Chdir werden alle
	// relativen Pfade (auch Uploads) auf einmal verankert -- die App ist damit
	// nicht mehr an das Start-CWD gebunden.
	if dir := os.Getenv("KVER_DIR"); dir != "" {
		if err := os.Chdir(dir); err != nil {
			log.Fatalf("KVER_DIR: %v", err)
		}
	}

	dsn := os.Getenv("KVER_DSN")
	if dsn == "" {
		log.Fatal("KVER_DSN fehlt (z. B. postgres://kver:passwort@host:5432/kontrollverlust)")
	}
	if err := initDB(dsn); err != nil {
		log.Fatalf("db init: %v", err)
	}
	defer db.Close()

	// Einmaliger Umzug: kver import-sqlite /pfad/zur/kver.db
	if len(os.Args) == 3 && os.Args[1] == "import-sqlite" {
		if err := importSQLite(os.Args[2]); err != nil {
			log.Fatalf("import: %v", err)
		}
		log.Print("import abgeschlossen")
		return
	}

	// Optionale GeoLite2-ASN-Datenbank für die netzwerktopologische Einordnung
	// der Impressions. Inaktiv, wenn KVER_GEOIP_ASN nicht gesetzt ist.
	initGeoASN()
	defer closeGeoASN()

	// Impression-Writer erst nach DB und GeoASN starten und VOR deren Close
	// stoppen (LIFO der defers) -- sonst könnte er nach dem Shutdown noch auf
	// die geschlossene DB oder den unmap-ten GeoIP-Reader zugreifen.
	startImpressionWorker()
	defer stopImpressionWorker()

	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)
	r.Use(checkOrigin)

	// --- Auth (öffentlich) ---
	// Login und Registrierung pro IP drosseln (Brute-Force-Bremse). bcrypt bremst
	// zusätzlich, aber das Limit kappt automatisiertes Durchprobieren früh.
	r.Group(func(r chi.Router) {
		r.Use(httprate.LimitByIP(20, time.Minute))
		r.Post("/auth/login", api(handleLogin))
		r.Post("/auth/newuser", api(handleNewUser))
	})
	// Logout als POST: SameSite=Lax schickt Cookies bei Top-Level-GET-
	// Navigationen mit -- als GET könnte eine fremde Seite Nutzer per Link
	// ausloggen (CSRF). POST ist durch Lax + checkOrigin gedeckt.
	r.Post("/auth/logout", handleLogout)
	r.Get("/auth/sessioninfo", api(handleSessionInfo))
	r.Get("/auth/headerbar", handleHeaderbar)
	r.Get("/stats", handleStats)
	r.Get("/stats/detail", handleStatsDetail)

	// Moderations-Queue (Meldungen). Basic-Auth direkt in der App (modBasicAuth),
	// weil TOR-Zugriffe die Go-App direkt erreichen und NICHT über Caddy laufen --
	// ein rein proxy-seitiger Schutz hätte diese Lücke offen gelassen. Caddy
	// erzwingt zusätzlich TLS für den Clearnet-Weg.
	r.With(modBasicAuth).Get("/moderation", api(handleModeration))

	// HTML-Seiten: mit Impression-Tracking (anonymisiert, siehe stats.go). Nur
	// echte Seitenaufrufe, nicht API/Assets.
	r.With(trackImpression).Get("/", serveIndex)

	// --- Entries ---
	r.Get("/entry/feed/{page}", api(handleFeed))
	r.Get("/entry/{pid}/votes", api(handleVotes))
	r.Get("/entry/{pid}/thread", api(handleThread))
	r.With(trackImpression).Get("/e/{pid}", serveEntryPage)

	// Melden: öffentlich (jeder darf melden, Moderationshilfe), aber pro IP
	// gedrosselt, damit der auth-lose Endpunkt nicht zum Spam-Kanal wird.
	r.With(httprate.LimitByIP(10, time.Minute)).Post("/entry/{pid}/report", api(handleReport))

	// --- User (öffentlich) ---
	r.With(trackImpression).Get("/u/{username}", serveUserPage)
	r.Get("/u/{username}/info", api(handleUserPage))
	r.Get("/u/{username}/feed/{page}", api(handleUserFeed))

	// --- Geschützt (Session erforderlich) ---
	r.Group(func(r chi.Router) {
		r.Use(requireAuth)
		r.With(blockTOR).Post("/entry/create", api(handleCreateEntry))
		r.Post("/entry/{pid}/vote", api(handleVote))
		r.Post("/entry/{pid}/bump", api(handleBump))
		r.Post("/entry/{pid}/edit", api(handleEditEntry))
		r.Post("/entry/{pid}/delete", api(handleDeleteEntry))
		r.Get("/user/info", api(handleUserInfo))
		r.Post("/user/rename", api(handleUserRename))
		r.Post("/user/avatar", api(handleSetAvatar))
		r.Post("/user/delete", api(handleUserDelete))
	})

	// 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")))

	return r
}

// 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) {
		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)
	})
}

// checkOrigin weist zustandsändernde Cross-Site-Requests ab (CSRF-Schutz,
// zusätzlich zu SameSite=Lax für ältere Browser bzw. GET-Navigationen).
// Browser setzen bei Cross-Site-Requests immer einen Origin-Header; fehlt er
// (Nicht-Browser-Clients wie curl, gleiche Site bei manchen Browsern), lassen
// wir durch -- der Cookie-Schutz greift dort ohnehin nicht bzw. schon.
var checkOrigin = guard(func(_ http.ResponseWriter, r *http.Request) error {
	if r.Method != http.MethodGet && r.Method != http.MethodHead {
		if o := r.Header.Get("Origin"); o != "" {
			u, err := url.Parse(o)
			if err != nil || u.Host != r.Host {
				return Forbidden("csrf.bad_origin", "Anfrage von fremder Seite abgelehnt")
			}
		}
	}
	return nil
})

func writeJSON(w http.ResponseWriter, status int, v any) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	_ = json.NewEncoder(w).Encode(v)
}

// truncateRunes kürzt s auf höchstens n Runen. Ein Byte-Slice s[:n] könnte
// mitten in eine Multibyte-Rune schneiden und kaputtes UTF-8 erzeugen (gleiches
// Problem wie beim Username-Kürzen, siehe sanitizeUsername).
func truncateRunes(s string, n int) string {
	if r := []rune(s); len(r) > n {
		return string(r[:n])
	}
	return s
}