API-17: gehaertete HTTP-Server (Timeouts, Body-Limit) in allen Diensten (QA-15 F-05)

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

archive/cmd/kennzahlen-api/main.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/jackc/pgx/v5/pgxpool"
 
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/httpharden"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/kennzahlenapi"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/rbacclient"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/retentionapi"
@@ -53,7 +54,7 @@ func main() {
 	handler := retentionapi.CORS(corsOrigin, mux)
 
 	log.Printf("kennzahlen-api: listening on %s (cors origin: %s)", addr, corsOrigin)
-	if err := http.ListenAndServe(addr, handler); err != nil {
+	if err := httpharden.ListenAndServe(addr, handler); err != nil {
 		log.Fatalf("http server: %v", err)
 	}
 }

archive/cmd/moduleadapter-api/main.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/jackc/pgx/v5/pgxpool"
 
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/httpharden"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/legalholdapi"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/moduleadapter"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/tenantregistryclient"
@@ -55,7 +56,7 @@ func main() {
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 
 	log.Printf("moduleadapter-api: listening on %s", addr)
-	if err := http.ListenAndServe(addr, mux); err != nil {
+	if err := httpharden.ListenAndServe(addr, mux); err != nil {
 		log.Fatalf("http server: %v", err)
 	}
 }

archive/cmd/restoretest-metrics/main.go

@@ -10,6 +10,7 @@ import (
 	"net/http"
 	"os"
 
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/httpharden"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/restoretest"
 )
 
@@ -64,7 +65,7 @@ func main() {
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 
 	log.Printf("restoretest-metrics: listening on %s", addr)
-	if err := http.ListenAndServe(addr, mux); err != nil {
+	if err := httpharden.ListenAndServe(addr, mux); err != nil {
 		log.Fatalf("http server: %v", err)
 	}
 }

archive/cmd/retention-api/main.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/jackc/pgx/v5/pgxpool"
 
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/httpharden"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/rbacclient"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/retentionapi"
 )
@@ -56,7 +57,7 @@ func main() {
 	handler := retentionapi.CORS(corsOrigin, mux)
 
 	log.Printf("retention-api: listening on %s (cors origin: %s)", addr, corsOrigin)
-	if err := http.ListenAndServe(addr, handler); err != nil {
+	if err := httpharden.ListenAndServe(addr, handler); err != nil {
 		log.Fatalf("http server: %v", err)
 	}
 }

archive/cmd/scrub-metrics/main.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/jackc/pgx/v5/pgxpool"
 
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/httpharden"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/scrub"
 )
 
@@ -56,7 +57,7 @@ func main() {
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 
 	log.Printf("scrub-metrics: listening on %s", addr)
-	if err := http.ListenAndServe(addr, mux); err != nil {
+	if err := httpharden.ListenAndServe(addr, mux); err != nil {
 		log.Fatalf("http server: %v", err)
 	}
 }

archive/internal/httpharden/harden.go

@@ -0,0 +1,111 @@
+// Package httpharden liefert gehaertete http.Server-Grundeinstellungen
+// (Timeouts, Header-Limit) und ein Body-Limit fuer alle Dienste (QA-15 F-05).
+// Dieselbe Datei existiert in archive/internal/httpharden und
+// dms/internal/httpharden, weil die Module getrennte go.mod-Dateien haben.
+package httpharden
+
+import (
+	"log"
+	"net/http"
+	"os"
+	"strconv"
+	"time"
+)
+
+const (
+	DefaultReadHeaderTimeout = 10 * time.Second
+	DefaultReadTimeout       = 30 * time.Second
+	DefaultWriteTimeout      = 60 * time.Second
+	DefaultIdleTimeout       = 120 * time.Second
+	DefaultMaxHeaderBytes    = 1 << 20
+	DefaultMaxBodyBytes      = 1 << 20
+
+	EnvReadHeaderTimeout = "NEXARCH_HTTP_READ_HEADER_TIMEOUT_SECONDS"
+	EnvReadTimeout       = "NEXARCH_HTTP_READ_TIMEOUT_SECONDS"
+	EnvWriteTimeout      = "NEXARCH_HTTP_WRITE_TIMEOUT_SECONDS"
+	EnvIdleTimeout       = "NEXARCH_HTTP_IDLE_TIMEOUT_SECONDS"
+	EnvMaxBodyBytes      = "NEXARCH_HTTP_MAX_BODY_BYTES"
+)
+
+// Options weicht vom Standard ab. Nullwerte bedeuten Standard bzw. Env-Wert;
+// StreamingBodies/StreamingResponses setzen ReadTimeout/WriteTimeout auf 0
+// (unbegrenzt), damit lange Uploads und Downloads nicht abbrechen. Schutz
+// gegen langsame Header bleibt ueber ReadHeaderTimeout und IdleTimeout.
+type Options struct {
+	StreamingBodies    bool
+	StreamingResponses bool
+}
+
+func envSeconds(name string, def time.Duration) time.Duration {
+	v := os.Getenv(name)
+	if v == "" {
+		return def
+	}
+	n, err := strconv.Atoi(v)
+	if err != nil || n < 1 || n > 3600 {
+		log.Fatalf("%s muss eine ganze Zahl zwischen 1 und 3600 sein, war %q", name, v)
+	}
+	return time.Duration(n) * time.Second
+}
+
+// MaxBodyBytes liest die Body-Obergrenze (Standard 1 MiB, Env
+// NEXARCH_HTTP_MAX_BODY_BYTES, 1 KiB bis 1 GiB).
+func MaxBodyBytes() int64 {
+	v := os.Getenv(EnvMaxBodyBytes)
+	if v == "" {
+		return DefaultMaxBodyBytes
+	}
+	n, err := strconv.ParseInt(v, 10, 64)
+	if err != nil || n < 1<<10 || n > 1<<30 {
+		log.Fatalf("%s muss zwischen 1024 und 1073741824 liegen, war %q", EnvMaxBodyBytes, v)
+	}
+	return n
+}
+
+// NewServer baut einen http.Server mit gehaerteten Timeouts.
+func NewServer(addr string, h http.Handler, opt Options) *http.Server {
+	s := &http.Server{
+		Addr:              addr,
+		Handler:           h,
+		ReadHeaderTimeout: envSeconds(EnvReadHeaderTimeout, DefaultReadHeaderTimeout),
+		ReadTimeout:       envSeconds(EnvReadTimeout, DefaultReadTimeout),
+		WriteTimeout:      envSeconds(EnvWriteTimeout, DefaultWriteTimeout),
+		IdleTimeout:       envSeconds(EnvIdleTimeout, DefaultIdleTimeout),
+		MaxHeaderBytes:    DefaultMaxHeaderBytes,
+	}
+	if opt.StreamingBodies {
+		s.ReadTimeout = 0
+	}
+	if opt.StreamingResponses {
+		s.WriteTimeout = 0
+	}
+	return s
+}
+
+// ListenAndServe ersetzt http.ListenAndServe: JSON-API mit Body-Limit.
+func ListenAndServe(addr string, h http.Handler) error {
+	return NewServer(addr, LimitBody(MaxBodyBytes(), h), Options{}).ListenAndServe()
+}
+
+// ListenAndServeStreaming fuer Dienste mit grossen Uploads/Downloads: keine
+// globale Body-Grenze und keine Lese-/Schreib-Gesamtzeit, nur Header-Timeout.
+func ListenAndServeStreaming(addr string, h http.Handler) error {
+	return NewServer(addr, h, Options{StreamingBodies: true, StreamingResponses: true}).ListenAndServe()
+}
+
+// LimitBody begrenzt Request-Bodies. Ein Content-Length ueber dem Limit wird
+// vor dem Handler mit 413 abgewiesen, chunked Bodies ueber MaxBytesReader.
+func LimitBody(max int64, next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.ContentLength > max {
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusRequestEntityTooLarge)
+			_, _ = w.Write([]byte(`{"error":{"code":"payload_too_large","message":"Anfrage zu gross"}}`))
+			return
+		}
+		if r.Body != nil && r.Body != http.NoBody {
+			r.Body = http.MaxBytesReader(w, r.Body, max)
+		}
+		next.ServeHTTP(w, r)
+	})
+}

archive/internal/httpharden/harden_test.go

@@ -0,0 +1,105 @@
+package httpharden
+
+import (
+	"bufio"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestLimitBody_ContentLengthOverLimitIs413(t *testing.T) {
+	called := false
+	h := LimitBody(10, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { called = true }))
+	req := httptest.NewRequest("POST", "/", strings.NewReader(strings.Repeat("a", 11)))
+	rec := httptest.NewRecorder()
+	h.ServeHTTP(rec, req)
+	if rec.Code != http.StatusRequestEntityTooLarge || called {
+		t.Fatalf("code=%d called=%v", rec.Code, called)
+	}
+}
+
+func TestLimitBody_ChunkedOverLimitFailsRead(t *testing.T) {
+	var readErr error
+	h := LimitBody(10, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, readErr = io.ReadAll(r.Body)
+	}))
+	req := httptest.NewRequest("POST", "/", strings.NewReader(strings.Repeat("a", 50)))
+	req.ContentLength = -1
+	h.ServeHTTP(httptest.NewRecorder(), req)
+	if readErr == nil {
+		t.Fatal("lesen ueber dem Limit muss fehlschlagen")
+	}
+}
+
+func TestLimitBody_UnderLimitPasses(t *testing.T) {
+	var got string
+	h := LimitBody(10, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		b, _ := io.ReadAll(r.Body)
+		got = string(b)
+	}))
+	h.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest("POST", "/", strings.NewReader("abc")))
+	if got != "abc" {
+		t.Fatalf("got %q", got)
+	}
+}
+
+func TestNewServer_DefaultsAndStreaming(t *testing.T) {
+	s := NewServer(":0", nil, Options{})
+	if s.ReadHeaderTimeout == 0 || s.ReadTimeout == 0 || s.WriteTimeout == 0 || s.IdleTimeout == 0 {
+		t.Fatalf("Timeouts muessen gesetzt sein: %+v", s)
+	}
+	st := NewServer(":0", nil, Options{StreamingBodies: true, StreamingResponses: true})
+	if st.ReadTimeout != 0 || st.WriteTimeout != 0 || st.ReadHeaderTimeout == 0 || st.IdleTimeout == 0 {
+		t.Fatalf("Streaming: nur Lese-/Schreib-Gesamtzeit 0: %+v", st)
+	}
+}
+
+func TestNewServer_EnvOverride(t *testing.T) {
+	t.Setenv(EnvReadHeaderTimeout, "3")
+	if got := NewServer(":0", nil, Options{}).ReadHeaderTimeout; got != 3*time.Second {
+		t.Fatalf("got %v", got)
+	}
+}
+
+func TestMaxBodyBytes_EnvOverride(t *testing.T) {
+	if MaxBodyBytes() != DefaultMaxBodyBytes {
+		t.Fatal("Standard")
+	}
+	t.Setenv(EnvMaxBodyBytes, "2048")
+	if MaxBodyBytes() != 2048 {
+		t.Fatal("Env")
+	}
+}
+
+// Slowloris: Verbindung sendet unvollstaendige Header, der Server trennt nach ReadHeaderTimeout.
+func TestSlowHeadersAreClosed(t *testing.T) {
+	t.Setenv(EnvReadHeaderTimeout, "1")
+	srv := NewServer("127.0.0.1:0", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}), Options{})
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	go srv.Serve(ln)
+	defer srv.Close()
+	conn, err := net.Dial("tcp", ln.Addr().String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer conn.Close()
+	if _, err := conn.Write([]byte("GET / HTTP/1.1\r\nHost: x\r\nX-Slow: a")); err != nil {
+		t.Fatal(err)
+	}
+	conn.SetReadDeadline(time.Now().Add(5 * time.Second))
+	start := time.Now()
+	_, err = bufio.NewReader(conn).ReadByte()
+	if err == nil {
+		t.Log("Server antwortete (z. B. 408)")
+	}
+	if time.Since(start) > 4*time.Second {
+		t.Fatalf("Verbindung wurde nicht nach dem Header-Timeout beendet (%v)", time.Since(start))
+	}
+}

cmd/auditlog-devserver/main.go

@@ -21,6 +21,7 @@ import (
 	"gitea.perlbach24.de/scripte/nexarch/internal/audit"
 	"gitea.perlbach24.de/scripte/nexarch/internal/auditadmin"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
+	"gitea.perlbach24.de/scripte/nexarch/internal/httpharden"
 )
 
 func main() {
@@ -60,7 +61,7 @@ func main() {
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 
 	log.Printf("auditlog-devserver listening on %s", addr)
-	log.Fatal(http.ListenAndServe(addr, mux))
+	log.Fatal(httpharden.ListenAndServe(addr, mux))
 }
 
 func withCORS(next http.HandlerFunc) http.HandlerFunc {

cmd/kek-api/main.go

@@ -14,6 +14,7 @@ import (
 	"github.com/jackc/pgx/v5/pgxpool"
 
 	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
+	"gitea.perlbach24.de/scripte/nexarch/internal/httpharden"
 	"gitea.perlbach24.de/scripte/nexarch/internal/kek"
 	"gitea.perlbach24.de/scripte/nexarch/internal/moduleregistry"
 	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
@@ -76,7 +77,7 @@ func main() {
 	mux.HandleFunc("/internal/kek/tenant", handler.TenantKEKHandler)
 
 	log.Printf("kek-api: listening on %s", addr)
-	if err := http.ListenAndServe(addr, mux); err != nil {
+	if err := httpharden.ListenAndServe(addr, mux); err != nil {
 		log.Fatalf("http server: %v", err)
 	}
 }

cmd/metrics-devserver/main.go

@@ -11,6 +11,7 @@ import (
 	"os"
 
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
+	"gitea.perlbach24.de/scripte/nexarch/internal/httpharden"
 	"gitea.perlbach24.de/scripte/nexarch/internal/metrics"
 )
 
@@ -39,5 +40,5 @@ func main() {
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 
 	log.Printf("metrics-devserver listening on %s", addr)
-	log.Fatal(http.ListenAndServe(addr, mux))
+	log.Fatal(httpharden.ListenAndServe(addr, mux))
 }

cmd/notify-api/main.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/jackc/pgx/v5/pgxpool"
 
+	"gitea.perlbach24.de/scripte/nexarch/internal/httpharden"
 	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
 	"gitea.perlbach24.de/scripte/nexarch/internal/notifyapi"
 	"gitea.perlbach24.de/scripte/nexarch/internal/notifyprefs"
@@ -46,7 +47,7 @@ func main() {
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 
 	log.Printf("notify-api: listening on %s", addr)
-	if err := http.ListenAndServe(addr, mux); err != nil {
+	if err := httpharden.ListenAndServe(addr, mux); err != nil {
 		log.Fatalf("http server: %v", err)
 	}
 }

cmd/notifyprefs-api/main.go

@@ -14,6 +14,7 @@ import (
 	"github.com/jackc/pgx/v5/pgxpool"
 
 	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+	"gitea.perlbach24.de/scripte/nexarch/internal/httpharden"
 	"gitea.perlbach24.de/scripte/nexarch/internal/notifyprefs"
 )
 
@@ -53,7 +54,7 @@ func main() {
 	mux.HandleFunc("GET /notifications/preferences/tenant", auth.RequireAuth(tokenIssuer, handler.ListTenantOverview))
 
 	log.Printf("notifyprefs-api: listening on %s", addr)
-	if err := http.ListenAndServe(addr, mux); err != nil {
+	if err := httpharden.ListenAndServe(addr, mux); err != nil {
 		log.Fatalf("http server: %v", err)
 	}
 }

cmd/policy-api/main.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/jackc/pgx/v5/pgxpool"
 
+	"gitea.perlbach24.de/scripte/nexarch/internal/httpharden"
 	"gitea.perlbach24.de/scripte/nexarch/internal/policy"
 	"gitea.perlbach24.de/scripte/nexarch/internal/policyapi"
 )
@@ -44,7 +45,7 @@ func main() {
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 
 	log.Printf("policy-api: listening on %s", addr)
-	if err := http.ListenAndServe(addr, mux); err != nil {
+	if err := httpharden.ListenAndServe(addr, mux); err != nil {
 		log.Fatalf("http server: %v", err)
 	}
 }

cmd/rbac-admin-api/main.go

@@ -14,6 +14,7 @@ import (
 	"github.com/jackc/pgx/v5/pgxpool"
 
 	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+	"gitea.perlbach24.de/scripte/nexarch/internal/httpharden"
 	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
 )
 
@@ -60,7 +61,7 @@ func main() {
 	mux.HandleFunc("POST /rbac/groups/members/remove", auth.RequireAuth(tokenIssuer, handler.RemoveGroupMember))
 
 	log.Printf("rbac-admin-api: listening on %s", addr)
-	if err := http.ListenAndServe(addr, mux); err != nil {
+	if err := httpharden.ListenAndServe(addr, mux); err != nil {
 		log.Fatalf("http server: %v", err)
 	}
 }

cmd/resync-api/main.go

@@ -15,6 +15,7 @@ import (
 
 	"gitea.perlbach24.de/scripte/nexarch/internal/audit"
 	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
+	"gitea.perlbach24.de/scripte/nexarch/internal/httpharden"
 	"gitea.perlbach24.de/scripte/nexarch/internal/moduleregistry"
 	"gitea.perlbach24.de/scripte/nexarch/internal/resync"
 	"gitea.perlbach24.de/scripte/nexarch/internal/usage"
@@ -64,7 +65,7 @@ func main() {
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 
 	log.Printf("resync-api: listening on %s", addr)
-	if err := http.ListenAndServe(addr, mux); err != nil {
+	if err := httpharden.ListenAndServe(addr, mux); err != nil {
 		log.Fatalf("http server: %v", err)
 	}
 }

cmd/secheaders-devserver/main.go

@@ -9,6 +9,7 @@ import (
 	"log"
 	"net/http"
 
+	"gitea.perlbach24.de/scripte/nexarch/internal/httpharden"
 	"gitea.perlbach24.de/scripte/nexarch/internal/secheaders"
 )
 
@@ -36,5 +37,5 @@ func main() {
 	mux.HandleFunc("/unprotected", servePage)
 
 	log.Println("secheaders-devserver listening on :8086")
-	log.Fatal(http.ListenAndServe(":8086", mux))
+	log.Fatal(httpharden.ListenAndServe(":8086", mux))
 }

cmd/statuspage-devserver/main.go

@@ -12,6 +12,7 @@ import (
 	"time"
 
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
+	"gitea.perlbach24.de/scripte/nexarch/internal/httpharden"
 	"gitea.perlbach24.de/scripte/nexarch/internal/statuspage"
 )
 
@@ -49,7 +50,7 @@ func main() {
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 
 	log.Printf("statuspage-devserver listening on %s (poll-intervall: %ds)", addr, intervalSeconds)
-	log.Fatal(http.ListenAndServe(addr, mux))
+	log.Fatal(httpharden.ListenAndServe(addr, mux))
 }
 
 func withCORS(next http.HandlerFunc) http.HandlerFunc {

dms/cmd/app/main.go

@@ -20,6 +20,7 @@ import (
 	"gitea.perlbach24.de/scripte/nexarch/dms/internal/batchsplit"
 	"gitea.perlbach24.de/scripte/nexarch/dms/internal/cmis"
 	"gitea.perlbach24.de/scripte/nexarch/dms/internal/errortracking"
+	"gitea.perlbach24.de/scripte/nexarch/dms/internal/httpharden"
 	"gitea.perlbach24.de/scripte/nexarch/dms/internal/importdir"
 	"gitea.perlbach24.de/scripte/nexarch/dms/internal/jobqueue"
 	"gitea.perlbach24.de/scripte/nexarch/dms/internal/logging"
@@ -105,7 +106,7 @@ func main() {
 	handler := logging.Middleware(logger)(metricsReg.Middleware(recoverMiddleware(tracker, routes)))
 
 	log.Printf("dms-app hoert auf %s (version %s)", addr, shared.Version)
-	if err := http.ListenAndServe(addr, handler); err != nil {
+	if err := httpharden.ListenAndServeStreaming(addr, handler); err != nil {
 		log.Fatal(err)
 	}
 }

dms/cmd/worker/main.go

@@ -9,7 +9,6 @@ import (
 	"crypto/x509"
 	"errors"
 	"log"
-	"net/http"
 	"os"
 	"os/signal"
 	"strconv"
@@ -21,6 +20,7 @@ import (
 	dmscrypto "gitea.perlbach24.de/scripte/nexarch/dms/internal/crypto"
 	"gitea.perlbach24.de/scripte/nexarch/dms/internal/einvoice"
 	"gitea.perlbach24.de/scripte/nexarch/dms/internal/errortracking"
+	"gitea.perlbach24.de/scripte/nexarch/dms/internal/httpharden"
 	"gitea.perlbach24.de/scripte/nexarch/dms/internal/jobqueue"
 	"gitea.perlbach24.de/scripte/nexarch/dms/internal/logging"
 	"gitea.perlbach24.de/scripte/nexarch/dms/internal/mailimport"
@@ -47,7 +47,7 @@ func main() {
 		metricsAddr = ":8601"
 	}
 	go func() {
-		if err := http.ListenAndServe(metricsAddr, metricsReg.Handler()); err != nil {
+		if err := httpharden.ListenAndServe(metricsAddr, metricsReg.Handler()); err != nil {
 			log.Printf("dms-worker: /metrics-server beendet: %v", err)
 		}
 	}()

dms/internal/httpharden/harden.go

@@ -0,0 +1,111 @@
+// Package httpharden liefert gehaertete http.Server-Grundeinstellungen
+// (Timeouts, Header-Limit) und ein Body-Limit fuer alle Dienste (QA-15 F-05).
+// Dieselbe Datei existiert in archive/internal/httpharden und
+// dms/internal/httpharden, weil die Module getrennte go.mod-Dateien haben.
+package httpharden
+
+import (
+	"log"
+	"net/http"
+	"os"
+	"strconv"
+	"time"
+)
+
+const (
+	DefaultReadHeaderTimeout = 10 * time.Second
+	DefaultReadTimeout       = 30 * time.Second
+	DefaultWriteTimeout      = 60 * time.Second
+	DefaultIdleTimeout       = 120 * time.Second
+	DefaultMaxHeaderBytes    = 1 << 20
+	DefaultMaxBodyBytes      = 1 << 20
+
+	EnvReadHeaderTimeout = "NEXARCH_HTTP_READ_HEADER_TIMEOUT_SECONDS"
+	EnvReadTimeout       = "NEXARCH_HTTP_READ_TIMEOUT_SECONDS"
+	EnvWriteTimeout      = "NEXARCH_HTTP_WRITE_TIMEOUT_SECONDS"
+	EnvIdleTimeout       = "NEXARCH_HTTP_IDLE_TIMEOUT_SECONDS"
+	EnvMaxBodyBytes      = "NEXARCH_HTTP_MAX_BODY_BYTES"
+)
+
+// Options weicht vom Standard ab. Nullwerte bedeuten Standard bzw. Env-Wert;
+// StreamingBodies/StreamingResponses setzen ReadTimeout/WriteTimeout auf 0
+// (unbegrenzt), damit lange Uploads und Downloads nicht abbrechen. Schutz
+// gegen langsame Header bleibt ueber ReadHeaderTimeout und IdleTimeout.
+type Options struct {
+	StreamingBodies    bool
+	StreamingResponses bool
+}
+
+func envSeconds(name string, def time.Duration) time.Duration {
+	v := os.Getenv(name)
+	if v == "" {
+		return def
+	}
+	n, err := strconv.Atoi(v)
+	if err != nil || n < 1 || n > 3600 {
+		log.Fatalf("%s muss eine ganze Zahl zwischen 1 und 3600 sein, war %q", name, v)
+	}
+	return time.Duration(n) * time.Second
+}
+
+// MaxBodyBytes liest die Body-Obergrenze (Standard 1 MiB, Env
+// NEXARCH_HTTP_MAX_BODY_BYTES, 1 KiB bis 1 GiB).
+func MaxBodyBytes() int64 {
+	v := os.Getenv(EnvMaxBodyBytes)
+	if v == "" {
+		return DefaultMaxBodyBytes
+	}
+	n, err := strconv.ParseInt(v, 10, 64)
+	if err != nil || n < 1<<10 || n > 1<<30 {
+		log.Fatalf("%s muss zwischen 1024 und 1073741824 liegen, war %q", EnvMaxBodyBytes, v)
+	}
+	return n
+}
+
+// NewServer baut einen http.Server mit gehaerteten Timeouts.
+func NewServer(addr string, h http.Handler, opt Options) *http.Server {
+	s := &http.Server{
+		Addr:              addr,
+		Handler:           h,
+		ReadHeaderTimeout: envSeconds(EnvReadHeaderTimeout, DefaultReadHeaderTimeout),
+		ReadTimeout:       envSeconds(EnvReadTimeout, DefaultReadTimeout),
+		WriteTimeout:      envSeconds(EnvWriteTimeout, DefaultWriteTimeout),
+		IdleTimeout:       envSeconds(EnvIdleTimeout, DefaultIdleTimeout),
+		MaxHeaderBytes:    DefaultMaxHeaderBytes,
+	}
+	if opt.StreamingBodies {
+		s.ReadTimeout = 0
+	}
+	if opt.StreamingResponses {
+		s.WriteTimeout = 0
+	}
+	return s
+}
+
+// ListenAndServe ersetzt http.ListenAndServe: JSON-API mit Body-Limit.
+func ListenAndServe(addr string, h http.Handler) error {
+	return NewServer(addr, LimitBody(MaxBodyBytes(), h), Options{}).ListenAndServe()
+}
+
+// ListenAndServeStreaming fuer Dienste mit grossen Uploads/Downloads: keine
+// globale Body-Grenze und keine Lese-/Schreib-Gesamtzeit, nur Header-Timeout.
+func ListenAndServeStreaming(addr string, h http.Handler) error {
+	return NewServer(addr, h, Options{StreamingBodies: true, StreamingResponses: true}).ListenAndServe()
+}
+
+// LimitBody begrenzt Request-Bodies. Ein Content-Length ueber dem Limit wird
+// vor dem Handler mit 413 abgewiesen, chunked Bodies ueber MaxBytesReader.
+func LimitBody(max int64, next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.ContentLength > max {
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusRequestEntityTooLarge)
+			_, _ = w.Write([]byte(`{"error":{"code":"payload_too_large","message":"Anfrage zu gross"}}`))
+			return
+		}
+		if r.Body != nil && r.Body != http.NoBody {
+			r.Body = http.MaxBytesReader(w, r.Body, max)
+		}
+		next.ServeHTTP(w, r)
+	})
+}

dms/internal/httpharden/harden_test.go

@@ -0,0 +1,105 @@
+package httpharden
+
+import (
+	"bufio"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestLimitBody_ContentLengthOverLimitIs413(t *testing.T) {
+	called := false
+	h := LimitBody(10, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { called = true }))
+	req := httptest.NewRequest("POST", "/", strings.NewReader(strings.Repeat("a", 11)))
+	rec := httptest.NewRecorder()
+	h.ServeHTTP(rec, req)
+	if rec.Code != http.StatusRequestEntityTooLarge || called {
+		t.Fatalf("code=%d called=%v", rec.Code, called)
+	}
+}
+
+func TestLimitBody_ChunkedOverLimitFailsRead(t *testing.T) {
+	var readErr error
+	h := LimitBody(10, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, readErr = io.ReadAll(r.Body)
+	}))
+	req := httptest.NewRequest("POST", "/", strings.NewReader(strings.Repeat("a", 50)))
+	req.ContentLength = -1
+	h.ServeHTTP(httptest.NewRecorder(), req)
+	if readErr == nil {
+		t.Fatal("lesen ueber dem Limit muss fehlschlagen")
+	}
+}
+
+func TestLimitBody_UnderLimitPasses(t *testing.T) {
+	var got string
+	h := LimitBody(10, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		b, _ := io.ReadAll(r.Body)
+		got = string(b)
+	}))
+	h.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest("POST", "/", strings.NewReader("abc")))
+	if got != "abc" {
+		t.Fatalf("got %q", got)
+	}
+}
+
+func TestNewServer_DefaultsAndStreaming(t *testing.T) {
+	s := NewServer(":0", nil, Options{})
+	if s.ReadHeaderTimeout == 0 || s.ReadTimeout == 0 || s.WriteTimeout == 0 || s.IdleTimeout == 0 {
+		t.Fatalf("Timeouts muessen gesetzt sein: %+v", s)
+	}
+	st := NewServer(":0", nil, Options{StreamingBodies: true, StreamingResponses: true})
+	if st.ReadTimeout != 0 || st.WriteTimeout != 0 || st.ReadHeaderTimeout == 0 || st.IdleTimeout == 0 {
+		t.Fatalf("Streaming: nur Lese-/Schreib-Gesamtzeit 0: %+v", st)
+	}
+}
+
+func TestNewServer_EnvOverride(t *testing.T) {
+	t.Setenv(EnvReadHeaderTimeout, "3")
+	if got := NewServer(":0", nil, Options{}).ReadHeaderTimeout; got != 3*time.Second {
+		t.Fatalf("got %v", got)
+	}
+}
+
+func TestMaxBodyBytes_EnvOverride(t *testing.T) {
+	if MaxBodyBytes() != DefaultMaxBodyBytes {
+		t.Fatal("Standard")
+	}
+	t.Setenv(EnvMaxBodyBytes, "2048")
+	if MaxBodyBytes() != 2048 {
+		t.Fatal("Env")
+	}
+}
+
+// Slowloris: Verbindung sendet unvollstaendige Header, der Server trennt nach ReadHeaderTimeout.
+func TestSlowHeadersAreClosed(t *testing.T) {
+	t.Setenv(EnvReadHeaderTimeout, "1")
+	srv := NewServer("127.0.0.1:0", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}), Options{})
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	go srv.Serve(ln)
+	defer srv.Close()
+	conn, err := net.Dial("tcp", ln.Addr().String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer conn.Close()
+	if _, err := conn.Write([]byte("GET / HTTP/1.1\r\nHost: x\r\nX-Slow: a")); err != nil {
+		t.Fatal(err)
+	}
+	conn.SetReadDeadline(time.Now().Add(5 * time.Second))
+	start := time.Now()
+	_, err = bufio.NewReader(conn).ReadByte()
+	if err == nil {
+		t.Log("Server antwortete (z. B. 408)")
+	}
+	if time.Since(start) > 4*time.Second {
+		t.Fatalf("Verbindung wurde nicht nach dem Header-Timeout beendet (%v)", time.Since(start))
+	}
+}

internal/httpharden/harden.go

@@ -0,0 +1,111 @@
+// Package httpharden liefert gehaertete http.Server-Grundeinstellungen
+// (Timeouts, Header-Limit) und ein Body-Limit fuer alle Dienste (QA-15 F-05).
+// Dieselbe Datei existiert in archive/internal/httpharden und
+// dms/internal/httpharden, weil die Module getrennte go.mod-Dateien haben.
+package httpharden
+
+import (
+	"log"
+	"net/http"
+	"os"
+	"strconv"
+	"time"
+)
+
+const (
+	DefaultReadHeaderTimeout = 10 * time.Second
+	DefaultReadTimeout       = 30 * time.Second
+	DefaultWriteTimeout      = 60 * time.Second
+	DefaultIdleTimeout       = 120 * time.Second
+	DefaultMaxHeaderBytes    = 1 << 20
+	DefaultMaxBodyBytes      = 1 << 20
+
+	EnvReadHeaderTimeout = "NEXARCH_HTTP_READ_HEADER_TIMEOUT_SECONDS"
+	EnvReadTimeout       = "NEXARCH_HTTP_READ_TIMEOUT_SECONDS"
+	EnvWriteTimeout      = "NEXARCH_HTTP_WRITE_TIMEOUT_SECONDS"
+	EnvIdleTimeout       = "NEXARCH_HTTP_IDLE_TIMEOUT_SECONDS"
+	EnvMaxBodyBytes      = "NEXARCH_HTTP_MAX_BODY_BYTES"
+)
+
+// Options weicht vom Standard ab. Nullwerte bedeuten Standard bzw. Env-Wert;
+// StreamingBodies/StreamingResponses setzen ReadTimeout/WriteTimeout auf 0
+// (unbegrenzt), damit lange Uploads und Downloads nicht abbrechen. Schutz
+// gegen langsame Header bleibt ueber ReadHeaderTimeout und IdleTimeout.
+type Options struct {
+	StreamingBodies    bool
+	StreamingResponses bool
+}
+
+func envSeconds(name string, def time.Duration) time.Duration {
+	v := os.Getenv(name)
+	if v == "" {
+		return def
+	}
+	n, err := strconv.Atoi(v)
+	if err != nil || n < 1 || n > 3600 {
+		log.Fatalf("%s muss eine ganze Zahl zwischen 1 und 3600 sein, war %q", name, v)
+	}
+	return time.Duration(n) * time.Second
+}
+
+// MaxBodyBytes liest die Body-Obergrenze (Standard 1 MiB, Env
+// NEXARCH_HTTP_MAX_BODY_BYTES, 1 KiB bis 1 GiB).
+func MaxBodyBytes() int64 {
+	v := os.Getenv(EnvMaxBodyBytes)
+	if v == "" {
+		return DefaultMaxBodyBytes
+	}
+	n, err := strconv.ParseInt(v, 10, 64)
+	if err != nil || n < 1<<10 || n > 1<<30 {
+		log.Fatalf("%s muss zwischen 1024 und 1073741824 liegen, war %q", EnvMaxBodyBytes, v)
+	}
+	return n
+}
+
+// NewServer baut einen http.Server mit gehaerteten Timeouts.
+func NewServer(addr string, h http.Handler, opt Options) *http.Server {
+	s := &http.Server{
+		Addr:              addr,
+		Handler:           h,
+		ReadHeaderTimeout: envSeconds(EnvReadHeaderTimeout, DefaultReadHeaderTimeout),
+		ReadTimeout:       envSeconds(EnvReadTimeout, DefaultReadTimeout),
+		WriteTimeout:      envSeconds(EnvWriteTimeout, DefaultWriteTimeout),
+		IdleTimeout:       envSeconds(EnvIdleTimeout, DefaultIdleTimeout),
+		MaxHeaderBytes:    DefaultMaxHeaderBytes,
+	}
+	if opt.StreamingBodies {
+		s.ReadTimeout = 0
+	}
+	if opt.StreamingResponses {
+		s.WriteTimeout = 0
+	}
+	return s
+}
+
+// ListenAndServe ersetzt http.ListenAndServe: JSON-API mit Body-Limit.
+func ListenAndServe(addr string, h http.Handler) error {
+	return NewServer(addr, LimitBody(MaxBodyBytes(), h), Options{}).ListenAndServe()
+}
+
+// ListenAndServeStreaming fuer Dienste mit grossen Uploads/Downloads: keine
+// globale Body-Grenze und keine Lese-/Schreib-Gesamtzeit, nur Header-Timeout.
+func ListenAndServeStreaming(addr string, h http.Handler) error {
+	return NewServer(addr, h, Options{StreamingBodies: true, StreamingResponses: true}).ListenAndServe()
+}
+
+// LimitBody begrenzt Request-Bodies. Ein Content-Length ueber dem Limit wird
+// vor dem Handler mit 413 abgewiesen, chunked Bodies ueber MaxBytesReader.
+func LimitBody(max int64, next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.ContentLength > max {
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusRequestEntityTooLarge)
+			_, _ = w.Write([]byte(`{"error":{"code":"payload_too_large","message":"Anfrage zu gross"}}`))
+			return
+		}
+		if r.Body != nil && r.Body != http.NoBody {
+			r.Body = http.MaxBytesReader(w, r.Body, max)
+		}
+		next.ServeHTTP(w, r)
+	})
+}

internal/httpharden/harden_test.go

@@ -0,0 +1,105 @@
+package httpharden
+
+import (
+	"bufio"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestLimitBody_ContentLengthOverLimitIs413(t *testing.T) {
+	called := false
+	h := LimitBody(10, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { called = true }))
+	req := httptest.NewRequest("POST", "/", strings.NewReader(strings.Repeat("a", 11)))
+	rec := httptest.NewRecorder()
+	h.ServeHTTP(rec, req)
+	if rec.Code != http.StatusRequestEntityTooLarge || called {
+		t.Fatalf("code=%d called=%v", rec.Code, called)
+	}
+}
+
+func TestLimitBody_ChunkedOverLimitFailsRead(t *testing.T) {
+	var readErr error
+	h := LimitBody(10, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, readErr = io.ReadAll(r.Body)
+	}))
+	req := httptest.NewRequest("POST", "/", strings.NewReader(strings.Repeat("a", 50)))
+	req.ContentLength = -1
+	h.ServeHTTP(httptest.NewRecorder(), req)
+	if readErr == nil {
+		t.Fatal("lesen ueber dem Limit muss fehlschlagen")
+	}
+}
+
+func TestLimitBody_UnderLimitPasses(t *testing.T) {
+	var got string
+	h := LimitBody(10, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		b, _ := io.ReadAll(r.Body)
+		got = string(b)
+	}))
+	h.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest("POST", "/", strings.NewReader("abc")))
+	if got != "abc" {
+		t.Fatalf("got %q", got)
+	}
+}
+
+func TestNewServer_DefaultsAndStreaming(t *testing.T) {
+	s := NewServer(":0", nil, Options{})
+	if s.ReadHeaderTimeout == 0 || s.ReadTimeout == 0 || s.WriteTimeout == 0 || s.IdleTimeout == 0 {
+		t.Fatalf("Timeouts muessen gesetzt sein: %+v", s)
+	}
+	st := NewServer(":0", nil, Options{StreamingBodies: true, StreamingResponses: true})
+	if st.ReadTimeout != 0 || st.WriteTimeout != 0 || st.ReadHeaderTimeout == 0 || st.IdleTimeout == 0 {
+		t.Fatalf("Streaming: nur Lese-/Schreib-Gesamtzeit 0: %+v", st)
+	}
+}
+
+func TestNewServer_EnvOverride(t *testing.T) {
+	t.Setenv(EnvReadHeaderTimeout, "3")
+	if got := NewServer(":0", nil, Options{}).ReadHeaderTimeout; got != 3*time.Second {
+		t.Fatalf("got %v", got)
+	}
+}
+
+func TestMaxBodyBytes_EnvOverride(t *testing.T) {
+	if MaxBodyBytes() != DefaultMaxBodyBytes {
+		t.Fatal("Standard")
+	}
+	t.Setenv(EnvMaxBodyBytes, "2048")
+	if MaxBodyBytes() != 2048 {
+		t.Fatal("Env")
+	}
+}
+
+// Slowloris: Verbindung sendet unvollstaendige Header, der Server trennt nach ReadHeaderTimeout.
+func TestSlowHeadersAreClosed(t *testing.T) {
+	t.Setenv(EnvReadHeaderTimeout, "1")
+	srv := NewServer("127.0.0.1:0", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}), Options{})
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	go srv.Serve(ln)
+	defer srv.Close()
+	conn, err := net.Dial("tcp", ln.Addr().String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer conn.Close()
+	if _, err := conn.Write([]byte("GET / HTTP/1.1\r\nHost: x\r\nX-Slow: a")); err != nil {
+		t.Fatal(err)
+	}
+	conn.SetReadDeadline(time.Now().Add(5 * time.Second))
+	start := time.Now()
+	_, err = bufio.NewReader(conn).ReadByte()
+	if err == nil {
+		t.Log("Server antwortete (z. B. 408)")
+	}
+	if time.Since(start) > 4*time.Second {
+		t.Fatalf("Verbindung wurde nicht nach dem Header-Timeout beendet (%v)", time.Since(start))
+	}
+}