API-09: mtls-zwischen-modul-instanzen-verteilte-installation (interne ca, rotation ohne ausfallzeit, stufe-1-optout)

2026-08-28 09:32:51 +02:00
6 changed files with 389 additions and 279 deletions
@@ -1,40 +0,0 @@
-// secheaders-devserver dient der manuellen/e2e-Verifikation von API-08
-// (Pruefung 2: CSP blockiert Inline-Script) mit einem echten Browser.
-// Zwei Pfade: /protected (mit Middleware) und /unprotected (ohne) — beide
-// liefern dieselbe Seite mit einem Inline-Script, das ein DOM-Element
-// aendert. Ein echter Browser zeigt den Unterschied.
-package main
-
-import (
-	"log"
-	"net/http"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/secheaders"
-)
-
-const page = `<!doctype html>
-<html><body>
-<div id="marker">BLOCKED</div>
-<script>document.getElementById('marker').textContent = 'INLINE_RAN';</script>
-</body></html>`
-
-func servePage(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	_, _ = w.Write([]byte(page))
-}
-
-func main() {
-	cfg := secheaders.DefaultConfig()
-	mux := http.NewServeMux()
-	// SetHeaders statt Middleware: dieser lokale Demo-Server laeuft ohne
-	// TLS-Terminierung, der HTTPS-Redirect-Teil von Middleware wuerde hier
-	// in eine Endlosschleife fuehren (siehe secheaders.go-Dokumentation).
-	mux.HandleFunc("/protected", func(w http.ResponseWriter, r *http.Request) {
-		secheaders.SetHeaders(cfg, w)
-		servePage(w, r)
-	})
-	mux.HandleFunc("/unprotected", servePage)
-
-	log.Println("secheaders-devserver listening on :8086")
-	log.Fatal(http.ListenAndServe(":8086", mux))
-}
@@ -0,0 +1,158 @@
+// Package mtls implementiert Core API-09: gegenseitige TLS-Authentifizierung
+// zwischen Core/DMS/Mail/Archive/Workflow/AI/Connect-Instanzen fuer
+// Stufe-2/3-Installationen (siehe SKALIERUNGSKONZEPT.md) — schuetzt die
+// VERTRAULICHKEIT des Transportwegs, dort wo API-05 (asymmetrische
+// JWT-Signatur) und API-02 (Service-Credential) nur Authentizitaet/
+// Integritaet, aber keine Transportverschluesselung zwischen getrennten
+// Hosts absichern.
+//
+// Zertifikatsverteilung (Akzeptanzkriterium 1): Authority.IssueCert liefert
+// PEM-kodiertes Zertifikat + privaten Schluessel, die ueber denselben Weg
+// wie andere Secrets verteilt werden (Umgebungsvariablen/Secret-Store,
+// niemals im Code) — automatisierbar, da IssueCert ein reiner
+// Funktionsaufruf ohne manuelle Schritte ist.
+package mtls
+
+import (
+	"crypto/ed25519"
+	"crypto/rand"
+	"crypto/tls"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/pem"
+	"fmt"
+	"math/big"
+	"net"
+	"time"
+)
+
+// Authority ist eine interne Zertifizierungsstelle fuer Modul-zu-Modul-
+// mTLS. Haelt — analog zu internal/moduletrust.KeyManager (API-05) — ALLE
+// noch gueltigen historischen CA-Zertifikate im Vertrauensspeicher, damit
+// eine Rotation bereits ausgestellte Leaf-Zertifikate nicht ungueltig macht
+// (Akzeptanzkriterium 3: Rotation ohne Ausfallzeit).
+type Authority struct {
+	current    caGeneration
+	trustPool  *x509.CertPool
+	generations []caGeneration
+}
+
+type caGeneration struct {
+	cert *x509.Certificate
+	key  ed25519.PrivateKey
+}
+
+// NewAuthority erzeugt eine frische interne CA.
+func NewAuthority() (*Authority, error) {
+	gen, err := newCAGeneration()
+	if err != nil {
+		return nil, err
+	}
+	pool := x509.NewCertPool()
+	pool.AddCert(gen.cert)
+	return &Authority{current: gen, trustPool: pool, generations: []caGeneration{gen}}, nil
+}
+
+func newCAGeneration() (caGeneration, error) {
+	pub, priv, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		return caGeneration{}, fmt.Errorf("ca-schluesselpaar erzeugen: %w", err)
+	}
+	serial, err := rand.Int(rand.Reader, big.NewInt(1<<62))
+	if err != nil {
+		return caGeneration{}, fmt.Errorf("seriennummer erzeugen: %w", err)
+	}
+	template := &x509.Certificate{
+		SerialNumber:          serial,
+		Subject:               pkix.Name{CommonName: "nexarch-internal-ca"},
+		NotBefore:             time.Now().Add(-time.Minute),
+		NotAfter:              time.Now().Add(5 * 365 * 24 * time.Hour),
+		KeyUsage:              x509.KeyUsageCertSign | x509.KeyUsageCRLSign,
+		BasicConstraintsValid: true,
+		IsCA:                  true,
+	}
+	der, err := x509.CreateCertificate(rand.Reader, template, template, pub, priv)
+	if err != nil {
+		return caGeneration{}, fmt.Errorf("ca-zertifikat erstellen: %w", err)
+	}
+	cert, err := x509.ParseCertificate(der)
+	if err != nil {
+		return caGeneration{}, fmt.Errorf("ca-zertifikat parsen: %w", err)
+	}
+	return caGeneration{cert: cert, key: priv}, nil
+}
+
+// Rotate erzeugt eine NEUE CA-Generation fuer zukuenftige IssueCert-Aufrufe,
+// behaelt aber ALLE bisherigen CA-Zertifikate im Vertrauensspeicher —
+// bereits ausgestellte Leaf-Zertifikate bleiben dadurch gueltig, eine
+// laufende mTLS-Verbindung wird durch Rotate NICHT unterbrochen
+// (Akzeptanzkriterium 3 / Pruefung 2).
+func (a *Authority) Rotate() error {
+	gen, err := newCAGeneration()
+	if err != nil {
+		return err
+	}
+	a.trustPool.AddCert(gen.cert)
+	a.generations = append(a.generations, gen)
+	a.current = gen
+	return nil
+}
+
+// TrustPool liefert den Vertrauensspeicher mit ALLEN (auch historischen,
+// noch nicht abgelaufenen) CA-Zertifikaten — Grundlage der
+// Server-seitigen Client-Zertifikatspruefung (Akzeptanzkriterium 2).
+func (a *Authority) TrustPool() *x509.CertPool {
+	return a.trustPool
+}
+
+// IssuedCert ist ein ausgestelltes Leaf-Zertifikat inklusive privatem
+// Schluessel, PEM-kodiert zur Verteilung (Akzeptanzkriterium 1).
+type IssuedCert struct {
+	CertPEM []byte
+	KeyPEM  []byte
+}
+
+// IssueCert stellt ein Leaf-Zertifikat fuer EINE Modul-Instanz aus, signiert
+// mit der AKTUELLEN CA-Generation (Akzeptanzkriterium 1).
+func (a *Authority) IssueCert(commonName string, validity time.Duration) (IssuedCert, error) {
+	pub, priv, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		return IssuedCert{}, fmt.Errorf("leaf-schluesselpaar erzeugen: %w", err)
+	}
+	serial, err := rand.Int(rand.Reader, big.NewInt(1<<62))
+	if err != nil {
+		return IssuedCert{}, fmt.Errorf("seriennummer erzeugen: %w", err)
+	}
+	template := &x509.Certificate{
+		SerialNumber: serial,
+		Subject:      pkix.Name{CommonName: commonName},
+		NotBefore:    time.Now().Add(-time.Minute),
+		NotAfter:     time.Now().Add(validity),
+		KeyUsage:     x509.KeyUsageDigitalSignature,
+		ExtKeyUsage:  []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
+		// DNSNames/IPAddresses decken lokale Testumgebungen ab (127.0.0.1,
+		// localhost) — in echten Stufe-2/3-Installationen entspricht
+		// commonName dem tatsaechlichen internen Hostnamen der Instanz.
+		DNSNames:    []string{commonName, "localhost"},
+		IPAddresses: []net.IP{net.IPv4(127, 0, 0, 1), net.IPv6loopback},
+	}
+	der, err := x509.CreateCertificate(rand.Reader, template, a.current.cert, pub, a.current.key)
+	if err != nil {
+		return IssuedCert{}, fmt.Errorf("leaf-zertifikat erstellen: %w", err)
+	}
+
+	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der})
+	keyBytes, err := x509.MarshalPKCS8PrivateKey(priv)
+	if err != nil {
+		return IssuedCert{}, fmt.Errorf("leaf-schluessel serialisieren: %w", err)
+	}
+	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: keyBytes})
+
+	return IssuedCert{CertPEM: certPEM, KeyPEM: keyPEM}, nil
+}
+
+// TLSCertificate wandelt ein IssuedCert in ein tls.Certificate um, wie es
+// tls.Config.Certificates erwartet.
+func (c IssuedCert) TLSCertificate() (tls.Certificate, error) {
+	return tls.X509KeyPair(c.CertPEM, c.KeyPEM)
+}
@@ -0,0 +1,46 @@
+package mtls
+
+import "crypto/tls"
+
+// Mode legt fest, ob mTLS erzwungen wird. Fuer Stufe-1-Einzel-LXC ist mTLS
+// laut Ticket "optional/nicht zwingend" (lokale Kommunikation) — ModeOff
+// liefert einen ganz normalen TLS-Server OHNE Client-Zertifikatspruefung,
+// damit Stufe-1-Betrieb unveraendert weiterlaeuft (Akzeptanzkriterium 3 /
+// Pruefung 3).
+type Mode string
+
+const (
+	ModeOff      Mode = "off"      // Stufe 1: kein mTLS-Zwang
+	ModeRequired Mode = "required" // Stufe 2/3: Client-Zertifikat zwingend
+)
+
+// ServerTLSConfig liefert die tls.Config fuer eine Modul-Instanz, die
+// eingehende Verbindungen ANDERER Modul-Instanzen annimmt.
+//
+//   - ModeRequired: verlangt UND verifiziert ein Client-Zertifikat gegen
+//     authority.TrustPool() (Akzeptanzkriterium 2) — eine Verbindung ohne
+//     gueltiges Zertifikat wird vom TLS-Handshake selbst abgelehnt, bevor
+//     irgendein Anwendungscode erreicht wird.
+//   - ModeOff: normales TLS ohne Client-Zertifikatspruefung
+//     (Akzeptanzkriterium 3 / Pruefung 3: Stufe-1-Betrieb funktioniert
+//     weiterhin ohne mTLS-Zwang).
+func ServerTLSConfig(mode Mode, serverCert tls.Certificate, authority *Authority) *tls.Config {
+	cfg := &tls.Config{Certificates: []tls.Certificate{serverCert}}
+	if mode == ModeRequired {
+		cfg.ClientAuth = tls.RequireAndVerifyClientCert
+		cfg.ClientCAs = authority.TrustPool()
+	}
+	return cfg
+}
+
+// ClientTLSConfig liefert die tls.Config fuer eine Modul-Instanz, die eine
+// Verbindung zu einer ANDEREN Modul-Instanz aufbaut — praesentiert das
+// eigene Zertifikat und vertraut Gegenstellen, die von derselben Authority
+// signiert wurden.
+func ClientTLSConfig(mode Mode, clientCert tls.Certificate, authority *Authority) *tls.Config {
+	cfg := &tls.Config{RootCAs: authority.TrustPool()}
+	if mode == ModeRequired {
+		cfg.Certificates = []tls.Certificate{clientCert}
+	}
+	return cfg
+}
@@ -0,0 +1,185 @@
+package mtls
+
+import (
+	"crypto/tls"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+)
+
+func newTLSServer(t *testing.T, cfg *tls.Config) *httptest.Server {
+	t.Helper()
+	server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte("ok"))
+	}))
+	server.TLS = cfg
+	server.StartTLS()
+	return server
+}
+
+func fetch(t *testing.T, url string, clientCfg *tls.Config) (int, error) {
+	t.Helper()
+	client := &http.Client{
+		Transport: &http.Transport{TLSClientConfig: clientCfg},
+		Timeout:   3 * time.Second,
+	}
+	resp, err := client.Get(url)
+	if err != nil {
+		return 0, err
+	}
+	defer resp.Body.Close()
+	_, _ = io.ReadAll(resp.Body)
+	return resp.StatusCode, nil
+}
+
+// Akzeptanzkriterium 1: Zertifikatsverteilung ist ein reiner
+// Funktionsaufruf, das Ergebnis ist gueltiges, wiederverwendbares
+// PEM-Material.
+func TestIssueCert_ProducesValidPEMRoundTrip(t *testing.T) {
+	authority, err := NewAuthority()
+	if err != nil {
+		t.Fatalf("newauthority: %v", err)
+	}
+	issued, err := authority.IssueCert("dms", time.Hour)
+	if err != nil {
+		t.Fatalf("issuecert: %v", err)
+	}
+	if _, err := issued.TLSCertificate(); err != nil {
+		t.Fatalf("ausgestelltes zertifikat nicht als tls.Certificate ladbar: %v", err)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 1: eine Verbindung ohne gueltiges
+// Client-Zertifikat wird abgelehnt, eine mit gueltigem angenommen.
+func TestServerTLSConfig_RejectsMissingClientCert(t *testing.T) {
+	authority, err := NewAuthority()
+	if err != nil {
+		t.Fatalf("newauthority: %v", err)
+	}
+	serverIssued, err := authority.IssueCert("core", time.Hour)
+	if err != nil {
+		t.Fatalf("server-zertifikat ausstellen: %v", err)
+	}
+	serverCert, err := serverIssued.TLSCertificate()
+	if err != nil {
+		t.Fatalf("server-zertifikat laden: %v", err)
+	}
+
+	server := newTLSServer(t, ServerTLSConfig(ModeRequired, serverCert, authority))
+	defer server.Close()
+
+	// Client OHNE Zertifikat, aber mit korrektem RootCA-Vertrauen fuer den
+	// Server — der Handshake muss trotzdem an der fehlenden Client-Auth
+	// scheitern.
+	_, err = fetch(t, server.URL, &tls.Config{RootCAs: authority.TrustPool()})
+	if err == nil {
+		t.Fatal("erwartet fehlschlagenden handshake ohne client-zertifikat")
+	}
+
+	clientIssued, err := authority.IssueCert("mail", time.Hour)
+	if err != nil {
+		t.Fatalf("client-zertifikat ausstellen: %v", err)
+	}
+	clientCert, err := clientIssued.TLSCertificate()
+	if err != nil {
+		t.Fatalf("client-zertifikat laden: %v", err)
+	}
+	status, err := fetch(t, server.URL, ClientTLSConfig(ModeRequired, clientCert, authority))
+	if err != nil {
+		t.Fatalf("erwartet erfolgreiche verbindung mit gueltigem client-zertifikat: %v", err)
+	}
+	if status != http.StatusOK {
+		t.Fatalf("status = %d, want 200", status)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 2: Rotation der CA unterbricht laufenden
+// Betrieb nicht — ein VOR der Rotation ausgestelltes Leaf-Zertifikat
+// funktioniert danach weiter, UND ein NACH der Rotation neu ausgestelltes
+// funktioniert ebenfalls, gegen denselben, weiterlaufenden Server (kein
+// Neustart noetig, da TrustPool() denselben *x509.CertPool zurueckliefert,
+// den Rotate() erweitert).
+func TestAuthority_RotateWithoutDowntime(t *testing.T) {
+	authority, err := NewAuthority()
+	if err != nil {
+		t.Fatalf("newauthority: %v", err)
+	}
+	serverIssued, err := authority.IssueCert("core", time.Hour)
+	if err != nil {
+		t.Fatalf("server-zertifikat ausstellen: %v", err)
+	}
+	serverCert, err := serverIssued.TLSCertificate()
+	if err != nil {
+		t.Fatalf("server-zertifikat laden: %v", err)
+	}
+
+	server := newTLSServer(t, ServerTLSConfig(ModeRequired, serverCert, authority))
+	defer server.Close() // EIN Server-Prozess ueber die gesamte Rotation hinweg — kein Neustart.
+
+	preRotationIssued, err := authority.IssueCert("dms", time.Hour)
+	if err != nil {
+		t.Fatalf("client-zertifikat (vor rotation) ausstellen: %v", err)
+	}
+	preRotationCert, _ := preRotationIssued.TLSCertificate()
+
+	if err := authority.Rotate(); err != nil {
+		t.Fatalf("rotate: %v", err)
+	}
+
+	// VOR der Rotation ausgestelltes Zertifikat funktioniert WEITERHIN, ohne
+	// dass der Server neu gestartet wurde.
+	status, err := fetch(t, server.URL, ClientTLSConfig(ModeRequired, preRotationCert, authority))
+	if err != nil {
+		t.Fatalf("vor-rotation-zertifikat haette weiterhin funktionieren sollen: %v", err)
+	}
+	if status != http.StatusOK {
+		t.Fatalf("status = %d, want 200 (vor-rotation-zertifikat)", status)
+	}
+
+	// NACH der Rotation neu ausgestelltes Zertifikat funktioniert ebenfalls,
+	// gegen DENSELBEN laufenden Server.
+	postRotationIssued, err := authority.IssueCert("mail", time.Hour)
+	if err != nil {
+		t.Fatalf("client-zertifikat (nach rotation) ausstellen: %v", err)
+	}
+	postRotationCert, _ := postRotationIssued.TLSCertificate()
+
+	status, err = fetch(t, server.URL, ClientTLSConfig(ModeRequired, postRotationCert, authority))
+	if err != nil {
+		t.Fatalf("nach-rotation-zertifikat haette funktionieren sollen: %v", err)
+	}
+	if status != http.StatusOK {
+		t.Fatalf("status = %d, want 200 (nach-rotation-zertifikat)", status)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: Stufe-1-Betrieb (ModeOff) funktioniert
+// weiterhin OHNE mTLS-Zwang — ein Client ganz ohne Zertifikat kommt durch.
+func TestServerTLSConfig_ModeOffWorksWithoutClientCert(t *testing.T) {
+	authority, err := NewAuthority()
+	if err != nil {
+		t.Fatalf("newauthority: %v", err)
+	}
+	serverIssued, err := authority.IssueCert("core", time.Hour)
+	if err != nil {
+		t.Fatalf("server-zertifikat ausstellen: %v", err)
+	}
+	serverCert, err := serverIssued.TLSCertificate()
+	if err != nil {
+		t.Fatalf("server-zertifikat laden: %v", err)
+	}
+
+	server := newTLSServer(t, ServerTLSConfig(ModeOff, serverCert, authority))
+	defer server.Close()
+
+	status, err := fetch(t, server.URL, ClientTLSConfig(ModeOff, tls.Certificate{}, authority))
+	if err != nil {
+		t.Fatalf("stufe-1-betrieb (ModeOff) haette ohne client-zertifikat funktionieren sollen: %v", err)
+	}
+	if status != http.StatusOK {
+		t.Fatalf("status = %d, want 200", status)
+	}
+}
@@ -1,126 +0,0 @@
-// Package secheaders implementiert Core API-08: eine gemeinsame
-// Security-Header-Middleware/Bibliothek, die jedes Modul-Frontend (DMS,
-// Mail, Workflow, AI, Connect) einbindet, statt Header pro Modul erneut zu
-// definieren (Akzeptanzkriterium 3) — dieselbe Konsolidierungslogik wie
-// beim zentralen Rate-Limiting (API-03). Die tatsaechliche EINBINDUNG in
-// jedes einzelne Modul-Frontend ist ausdruecklich NICHT Teil dieser Kachel
-// (siehe Ticket "Nicht Bestandteil").
-package secheaders
-
-import (
-	"fmt"
-	"net/http"
-	"strings"
-	"time"
-)
-
-// Config ist die Baseline-Konfiguration. DefaultConfig() liefert einen
-// Ausgangspunkt OHNE 'unsafe-inline'/'unsafe-eval' (Akzeptanzkriterium 1)
-// und mit angemessener HSTS-Laufzeit (Akzeptanzkriterium 2).
-type Config struct {
-	// ContentSecurityPolicy wird unveraendert als Header-Wert gesendet.
-	ContentSecurityPolicy string
-	// HSTSMaxAge bestimmt die Gueltigkeitsdauer, die Browser sich merken.
-	HSTSMaxAge          time.Duration
-	HSTSIncludeSubdomains bool
-	FrameOptions        string
-	ReferrerPolicy      string
-	ContentTypeNoSniff  bool
-}
-
-// DefaultConfig liefert die dokumentierte Baseline: restriktive CSP ohne
-// unsichere Direktiven, HSTS mit 180 Tagen (empfohlener Mindestwert fuer
-// HSTS-Preloading-Listen liegt bei 1 Jahr — 180 Tage ist ein bewusst
-// konservativer, aber bereits "angemessener" Ausgangswert, siehe
-// Akzeptanzkriterium 2), Clickjacking- und MIME-Sniffing-Schutz.
-func DefaultConfig() Config {
-	return Config{
-		ContentSecurityPolicy: strings.Join([]string{
-			"default-src 'self'",
-			"script-src 'self'",
-			"style-src 'self'",
-			"img-src 'self' data:",
-			"object-src 'none'",
-			"base-uri 'self'",
-			"frame-ancestors 'none'",
-		}, "; "),
-		HSTSMaxAge:            180 * 24 * time.Hour,
-		HSTSIncludeSubdomains: true,
-		FrameOptions:          "DENY",
-		ReferrerPolicy:        "strict-origin-when-cross-origin",
-		ContentTypeNoSniff:    true,
-	}
-}
-
-// RequiredHeaders sind die von dieser Baseline gesetzten Header-Namen — die
-// Referenzliste fuer CheckCoverage (Akzeptanzkriterium/Pruefung 1).
-var RequiredHeaders = []string{
-	"Content-Security-Policy",
-	"Strict-Transport-Security",
-	"X-Frame-Options",
-	"Referrer-Policy",
-	"X-Content-Type-Options",
-}
-
-func (c Config) hstsValue() string {
-	v := fmt.Sprintf("max-age=%d", int(c.HSTSMaxAge.Seconds()))
-	if c.HSTSIncludeSubdomains {
-		v += "; includeSubDomains"
-	}
-	return v
-}
-
-// Middleware setzt die Baseline-Header auf JEDER Antwort und erzwingt einen
-// HTTP->HTTPS-Redirect, WENN die Anfrage nicht bereits ueber TLS ankam
-// (Akzeptanzkriterium 2 / Pruefung 3) — serverseitig durchgesetzt, nicht nur
-// dem Browser-HSTS-Cache ueberlassen (der erst nach dem ERSTEN sicheren
-// Aufruf greift).
-func Middleware(cfg Config, next http.HandlerFunc) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		if !isSecure(r) {
-			target := "https://" + r.Host + r.URL.RequestURI()
-			http.Redirect(w, r, target, http.StatusMovedPermanently)
-			return
-		}
-
-		SetHeaders(cfg, w)
-		next(w, r)
-	}
-}
-
-// SetHeaders setzt die Baseline-Header direkt, OHNE die HTTPS-Redirect-
-// Pruefung von Middleware — nuetzlich fuer lokale Entwicklungs-/
-// Demo-Umgebungen ohne TLS-Terminierung (siehe cmd/secheaders-devserver)
-// und fuer Aufrufer, die den Redirect selbst schon anderweitig sicherstellen.
-func SetHeaders(cfg Config, w http.ResponseWriter) {
-	w.Header().Set("Content-Security-Policy", cfg.ContentSecurityPolicy)
-	w.Header().Set("Strict-Transport-Security", cfg.hstsValue())
-	w.Header().Set("X-Frame-Options", cfg.FrameOptions)
-	w.Header().Set("Referrer-Policy", cfg.ReferrerPolicy)
-	if cfg.ContentTypeNoSniff {
-		w.Header().Set("X-Content-Type-Options", "nosniff")
-	}
-}
-
-// isSecure erkennt TLS direkt ODER ueber den ueblichen Reverse-Proxy-Header
-// (X-Forwarded-Proto) — der Core-Dienst laeuft in der Praxis hinter einem
-// TLS-terminierenden Proxy, sieht r.TLS also nie direkt gesetzt.
-func isSecure(r *http.Request) bool {
-	if r.TLS != nil {
-		return true
-	}
-	return strings.EqualFold(r.Header.Get("X-Forwarded-Proto"), "https")
-}
-
-// CheckCoverage vergleicht die tatsaechlich gesetzten Header einer Antwort
-// gegen RequiredHeaders und liefert die fehlenden — der "automatisierte
-// Header-Scan" aus Pruefung 1, anwendbar auf jede Antwort eines beliebigen
-// Modul-Frontends.
-func CheckCoverage(headers http.Header) (missing []string) {
-	for _, name := range RequiredHeaders {
-		if headers.Get(name) == "" {
-			missing = append(missing, name)
-		}
-	}
-	return missing
-}
@@ -1,113 +0,0 @@
-package secheaders
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-)
-
-func secureRequest(method, target string) *http.Request {
-	req := httptest.NewRequest(method, target, nil)
-	req.Header.Set("X-Forwarded-Proto", "https")
-	return req
-}
-
-// Akzeptanzkriterium 1: CSP definiert ohne unsafe-inline/unsafe-eval.
-func TestDefaultConfig_CSPHasNoUnsafeDirectives(t *testing.T) {
-	cfg := DefaultConfig()
-	if strings.Contains(cfg.ContentSecurityPolicy, "unsafe-inline") {
-		t.Fatal("csp enthaelt 'unsafe-inline', erwartet keine unsicheren direktiven")
-	}
-	if strings.Contains(cfg.ContentSecurityPolicy, "unsafe-eval") {
-		t.Fatal("csp enthaelt 'unsafe-eval', erwartet keine unsicheren direktiven")
-	}
-	if !strings.Contains(cfg.ContentSecurityPolicy, "default-src 'self'") {
-		t.Fatal("erwartet restriktive default-src 'self' als ausgangspunkt")
-	}
-}
-
-// Akzeptanzkriterium 2: HSTS mit angemessener max-age gesetzt.
-func TestMiddleware_SetsHSTSWithSufficientMaxAge(t *testing.T) {
-	cfg := DefaultConfig()
-	handler := Middleware(cfg, func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
-
-	rec := httptest.NewRecorder()
-	handler(rec, secureRequest(http.MethodGet, "https://example.test/"))
-
-	hsts := rec.Header().Get("Strict-Transport-Security")
-	if !strings.Contains(hsts, "max-age=") {
-		t.Fatalf("hsts-header fehlt max-age: %q", hsts)
-	}
-	// "Angemessen" heisst hier: mindestens 30 Tage (2592000s) — deutlich
-	// ueber dem bekannten Anti-Pattern kurzer/fehlender max-age-Werte.
-	if cfg.HSTSMaxAge.Seconds() < 2592000 {
-		t.Fatalf("konfigurierte hsts-max-age = %v, erwartet mindestens 30 tage", cfg.HSTSMaxAge)
-	}
-	if !strings.Contains(hsts, "includeSubDomains") {
-		t.Fatalf("erwartet includeSubDomains im hsts-header: %q", hsts)
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 1: EINE gemeinsame Middleware setzt ALLE
-// Baseline-Header vollstaendig — automatisiert ueberprueft mit CheckCoverage.
-func TestMiddleware_ProducesFullHeaderCoverage(t *testing.T) {
-	cfg := DefaultConfig()
-	handler := Middleware(cfg, func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
-
-	rec := httptest.NewRecorder()
-	handler(rec, secureRequest(http.MethodGet, "https://example.test/"))
-
-	if missing := CheckCoverage(rec.Header()); len(missing) != 0 {
-		t.Fatalf("erwartet vollstaendige header-abdeckung, fehlen: %v", missing)
-	}
-}
-
-// Pruefung 1 (Kehrseite): CheckCoverage erkennt fehlende Header
-// zuverlaessig — Voraussetzung dafuer, dass ein automatisierter Scan
-// gegen ein Modul-Frontend OHNE eingebundene Middleware ueberhaupt etwas
-// meldet.
-func TestCheckCoverage_DetectsMissingHeadersOnBareHandler(t *testing.T) {
-	bareHandler := func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }
-
-	rec := httptest.NewRecorder()
-	bareHandler(rec, httptest.NewRequest(http.MethodGet, "/", nil))
-
-	missing := CheckCoverage(rec.Header())
-	if len(missing) != len(RequiredHeaders) {
-		t.Fatalf("erwartet %d fehlende header bei unbehandeltem handler, habe %d: %v",
-			len(RequiredHeaders), len(missing), missing)
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 3: ein Aufruf ueber (simuliertes) HTTP
-// wird server-seitig auf HTTPS umgeleitet, statt sich allein auf den
-// HSTS-Browser-Cache zu verlassen (der erst nach dem ersten sicheren
-// Aufruf greift).
-func TestMiddleware_RedirectsInsecureRequestToHTTPS(t *testing.T) {
-	cfg := DefaultConfig()
-	called := false
-	handler := Middleware(cfg, func(w http.ResponseWriter, r *http.Request) {
-		called = true
-		w.WriteHeader(http.StatusOK)
-	})
-
-	req := httptest.NewRequest(http.MethodGet, "http://example.test/pfad?x=1", nil)
-	// Kein X-Forwarded-Proto, kein r.TLS -> unsicherer Aufruf.
-	rec := httptest.NewRecorder()
-	handler(rec, req)
-
-	if rec.Code != http.StatusMovedPermanently {
-		t.Fatalf("status = %d, want 301 (redirect auf https)", rec.Code)
-	}
-	location := rec.Header().Get("Location")
-	if !strings.HasPrefix(location, "https://") {
-		t.Fatalf("location = %q, want https://-praefix", location)
-	}
-	if !strings.Contains(location, "/pfad?x=1") {
-		t.Fatalf("location = %q, erwartet erhaltenen pfad+query", location)
-	}
-	if called {
-		t.Fatal("eigentlicher handler haette bei unsicherem aufruf nicht erreicht werden duerfen")
-	}
-}