feat(mail): ING-07 einheitliche Fehlerbehandlung & Wiederverbindung IMAP/POP3

Neues Paket mail/internal/protoguard kapselt die für IMAP- und
POP3-Sessions gemeinsam benötigte Timeout- und Backoff-Logik einer
einzelnen Verbindung:

- Pro Protokollphase konfigurierbarer Idle-Read-Timeout (POP3:
  Authorization/Transaction, IMAP: NotAuthenticated/Selected), vor
  jedem Lesevorgang neu gesetzt.
- Sich verdoppelnder Backoff bei wiederholten Anmeldefehlversuchen
  einer Verbindung (BackoffBase bis BackoffMax), Verbindungstrennung
  nach konfigurierbarer Höchstzahl statt Dauerschleife.

Server.NewServer bleibt unverändert (Standardkonfiguration);
NewServerWithGuardConfig erlaubt abweichende Werte. Ressourcenaufräumung
bei Verbindungsabbruch war bereits durch defer conn.Close() strukturell
gegeben — der Timeout sorgt dafür, dass dieser Pfad auch bei hängenden
oder böswilligen Gegenstellen zuverlässig erreicht wird.

Alle drei Pflichtprüfungen mit echten Nachweisen durchgeführt:
Chaos-Test mit 30 hart gekappten Verbindungen während aktiver
Übertragung (kein Goroutine-Leck), Timeout-Auslösung in jeder
Protokollphase beider Server, steigender Backoff mit definierter
Verbindungstrennung nach Höchstzahl an Fehlversuchen.

go build/go vet/golangci-lint clean, gesamtes Mail-Modul (~24 Pakete)
regressionsfrei getestet.

mail/docs/ING-02-PRUEFPROTOKOLL.md

@@ -0,0 +1,90 @@
+# ING-02 — POP3-Server: Prüfprotokoll
+
+Datum: 2026-09-01
+Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
+Paket: `mail/internal/pop3`
+
+## Umsetzung
+
+Vollständiger POP3-Server (RFC 1939) von Grund auf implementiert:
+TCP-Listener, CRLF/Byte-Stuffing-sichere Response-Writer, Session-Zustandsmaschine
+(Authorization / Transaction / Update), Kommandos USER, PASS, STAT, LIST, RETR,
+DELE, QUIT. Architektonisch analog zum bestehenden `mail/internal/imap`-Paket
+(ING-01).
+
+## Pflichtprüfung 1: automatisierter Test für jede Zustandsübergangs-Regel
+
+`TestSession_StateTransitions` (`pop3_test.go`), realer TCP-Client gegen realen
+Server:
+
+- STAT/RETR in Authorization → `-ERR` (verboten)
+- PASS ohne vorheriges USER → `-ERR`
+- USER + PASS korrekt → Authorization → Transaction
+- USER erneut in Transaction → `-ERR` (verboten)
+- STAT in Transaction → `+OK` (erlaubt)
+- QUIT in Transaction → `+OK`, Verbindungsende
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 2: manuelle Session mit Standard-POP3-Client gegen Test-Postfach
+
+Realer Server (`pop3.NewServer`) auf `127.0.0.1:14400` gestartet (Wegwerf-Programm
+`mail/cmd/pop3-manual-test`, danach entfernt), Testpostfach mit 2 Nachrichten
+(fest codiert: `testuser`/`testpass`). Session mit Python-Standardbibliothek
+`poplib` (kein selbstgeschriebener Client) durchgeführt, reales Transkript:
+
+```
+Begruessung: b'+OK POP3 server ready'
+USER -> b'+OK send PASS'
+PASS -> b'+OK maildrop locked and ready'
+STAT -> (2, 45)
+LIST -> b'+OK 2 messages (45 octets)' [b'1 25', b'2 20'] 12
+RETR 1 -> b'+OK 26 octets' [b'Erste Testnachricht Inhalt'] 28
+DELE 1 -> b'+OK message 1 deleted'
+QUIT -> b'+OK goodbye'
+```
+
+Ergebnis: **BESTANDEN** — echter Standard-Client, keine Ausnahme, alle Antworten
+RFC-1939-konform.
+
+## Pflichtprüfung 3: DELE ohne QUIT löscht nichts endgültig
+
+`TestCommands_DeleWithoutQuitDeletesNothing` (`pop3_test.go`): DELE 1 gesendet,
+Verbindung danach OHNE QUIT hart geschlossen, 100ms gewartet, Store-Zustand
+geprüft — weiterhin 2 Nachrichten vorhanden (keine endgültige Löschung).
+
+Strukturell garantiert durch Code-Design: `store.Delete` wird ausschließlich in
+`handleQuit` im Zustand `Transaction → Update` aufgerufen; `handleDele` mutiert
+nur `s.deleted` (sitzungslokal).
+
+Ergebnis: **BESTANDEN**.
+
+## Akzeptanzkriterien
+
+1. **Jede Verbindung eigene Goroutine**: `Server.Serve` startet pro Accept eine
+   neue Goroutine (`server.go`). Zusätzlich belegt: `TestServer_ManyParallelSessions`,
+   20 parallele reale TCP-Sessions, alle erfolgreich.
+2. **RETR liefert vollständige Nachricht, DELE+QUIT löscht endgültig**:
+   `TestCommands_RetrDeleFullCycle` — RETR liefert mehrzeiligen Inhalt
+   vollständig und byte-identisch; nach DELE+QUIT sinkt die Nachrichtenzahl im
+   Store tatsächlich von 2 auf 1.
+3. **Fehlerhafte Anmeldeversuche ohne Informationspreisgabe**:
+   `TestPass_RejectsWithoutInformationLeak` — unbekannter Benutzername und
+   falsches Passwort liefern byte-identischen `-ERR`-Text
+   (`genericAuthFailure = "authentication failed"`).
+
+## Build/Vet/Lint/Test — Gesamtmodul
+
+```
+go build ./...    → OK
+go vet ./...      → OK
+golangci-lint run ./... → 0 issues
+go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL gesetzt) → alle Pakete ok, inkl. neuem internal/pop3 (0.109s, 5/5 Tests)
+```
+
+Keine Regression in den bestehenden ~23 Paketen.
+
+## Ergebnis
+
+ING-02 erfüllt alle Pflichtprüfungen und Akzeptanzkriterien mit echten,
+ausgeführten Nachweisen. Freigeschaltet: ING-06, ING-07, ING-08, ING-10, QA-07.

mail/docs/ING-07-PRUEFPROTOKOLL.md

@@ -0,0 +1,100 @@
+# ING-07 — Protokoll-Fehlerbehandlung & Wiederverbindung: Prüfprotokoll
+
+Datum: 2026-09-01
+Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
+Pakete: `mail/internal/protoguard` (neu, gemeinsam genutzt), `mail/internal/imap`, `mail/internal/pop3`
+
+## Umsetzung
+
+Neues Paket `protoguard` kapselt Timeout- und Backoff-Logik EINER
+Verbindung (`Guard`), von IMAP- und POP3-Session gleichermaßen genutzt:
+
+- `ApplyReadDeadline(conn, phase)` setzt vor jedem Lesevorgang die
+  Lese-Deadline passend zur aktuellen Protokollphase (POP3:
+  Authorization/Transaction, IMAP: NotAuthenticated/Selected).
+- `RecordAuthFailure()` zählt Anmeldefehlversuche EINER Verbindung,
+  liefert eine sich verdoppelnde Backoff-Wartezeit (`BackoffBase` bis
+  `BackoffMax`) und meldet nach `MaxAuthFailures`, dass die Verbindung
+  zu trennen ist.
+
+`Server.NewServer` verwendet `protoguard.DefaultConfig()` (5 Minuten
+Timeout, max. 5 Fehlversuche, 200ms–5s Backoff); `NewServerWithGuardConfig`
+erlaubt abweichende Werte für Tests/gehärtete Umgebungen. Bestehende
+Aufrufer von `NewServer(auth, store)` sind unverändert kompatibel.
+
+Ressourcenaufräumung bei Verbindungsabbruch war bereits vor ING-07
+durch `defer conn.Close()` in beiden Sessions strukturell gegeben —
+ING-07 sorgt dafür, dass dieser Pfad auch bei hängenden oder böswilligen
+Gegenstellen zuverlässig erreicht wird (Timeout statt endlosem
+Blockieren).
+
+## Pflichtprüfung 1: Chaos-Test — harter Verbindungsabbruch während aktiver Übertragung, kein Ressourcenleck
+
+`TestGuard_ChaosHardCutDuringTransferNoLeak` (`pop3/guard_test.go`,
+`imap/guard_test.go`): 30 reale TCP-Verbindungen, jeweils angemeldet und
+mitten in einer laufenden Anfrage (POP3: RETR-Kopfzeile gelesen, Rest
+nicht konsumiert; IMAP: FETCH gesendet, Antwort nicht abgewartet) hart
+per `conn.Close()` gekappt. `runtime.NumGoroutine()` vor und nach den 30
+Abbrüchen verglichen (mit Toleranz für Laufzeit-Jitter und Wartezeit für
+Server-Aufräumung).
+
+Ergebnis: **BESTANDEN** — Goroutinezahl kehrt in beiden Paketen auf den
+Ausgangswert zurück, kein Leck.
+
+## Pflichtprüfung 2: Test für Timeout-Auslösung in jeder Protokollphase
+
+`TestGuard_TimeoutPerPhase` (beide Pakete), Guard mit 100ms Timeout je
+Phase konfiguriert:
+
+- POP3: Subtest `authorization` (Verbindung offen, nichts gesendet) und
+  `transaction` (nach erfolgreichem USER/PASS nichts weiter gesendet) —
+  beide erwarten Verbindungsende durch Timeout.
+- IMAP: Subtest `not_authenticated` und `selected` (nach LOGIN+SELECT)
+  — gleiche Erwartung.
+
+Ergebnis: **BESTANDEN** — alle vier Subtests bestätigen, dass der
+konfigurierte Timeout in der jeweiligen Phase tatsächlich greift.
+
+## Pflichtprüfung 3: Test für Backoff-Verhalten bei wiederholten Fehlversuchen
+
+`TestGuard_BackoffOnRepeatedAuthFailures` (beide Pakete), Guard mit
+`MaxAuthFailures=3`, `BackoffBase=50ms`, `BackoffMax=500ms`:
+
+- Drei aufeinanderfolgende fehlgeschlagene Anmeldeversuche (POP3:
+  USER+PASS falsch; IMAP: LOGIN falsch) über dieselbe Verbindung.
+  Gemessene Antwortzeit des zweiten Versuchs ist länger als die des
+  ersten (Verdopplung statt konstanter oder fehlender Wartezeit).
+- Nach dem dritten (= `MaxAuthFailures`-ten) Fehlversuch wird die
+  Verbindung serverseitig getrennt — ein weiterer Anmeldeversuch über
+  dieselbe Verbindung schlägt fehl statt in einer Dauerschleife erneut
+  beantwortet zu werden.
+
+Ergebnis: **BESTANDEN**.
+
+## Akzeptanzkriterien
+
+1. **Verbindungsabbrüche räumen serverseitige Session-Ressourcen
+   zuverlässig auf**: durch Pflichtprüfung 1 belegt (kein
+   Goroutine-Leck nach 30 harten Abbrüchen in beiden Protokollen).
+2. **Timeouts sind pro Protokollphase konfigurierbar und greifen
+   nachweislich**: durch Pflichtprüfung 2 belegt (`protoguard.Config.
+   PhaseTimeout` je Phase, vier bestandene Subtests).
+3. **Wiederholte Fehlversuche eines Clients führen zu klar definiertem
+   Backoff statt Dauerschleife**: durch Pflichtprüfung 3 belegt
+   (steigender Backoff, definierte Trennung nach `MaxAuthFailures`).
+
+## Build/Vet/Lint/Test — Gesamtmodul
+
+```
+go build ./...    → OK
+go vet ./...      → OK
+golangci-lint run ./... → 0 issues
+go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL gesetzt) → alle Pakete ok, inkl. neuem internal/protoguard (indirekt über imap/pop3-Tests abgedeckt)
+```
+
+Keine Regression in den bestehenden ~24 Paketen.
+
+## Ergebnis
+
+ING-07 erfüllt alle Pflichtprüfungen und Akzeptanzkriterien mit echten,
+ausgeführten Nachweisen. Freigeschaltet: QA-02.

mail/internal/imap/commands.go

@@ -29,12 +29,17 @@ func (s *Session) handleLogin(ctx context.Context, cmd command) bool {
 	}
 
 	ok, err := s.auth.Authenticate(ctx, cmd.Args[0], cmd.Args[1])
-	if err != nil {
+	if err != nil || !ok {
-		return s.writeErr(cmd.Tag, "NO", "LOGIN failed")
+		// Backoff statt Dauerschleife bei wiederholten Fehlversuchen
-	}
+		// (Akzeptanzkriterium 3, ING-07).
-	if !ok {
+		backoff, disconnect := s.guard.RecordAuthFailure()
-		return s.writeErr(cmd.Tag, "NO", "LOGIN failed")
+		s.guard.Wait(ctx, backoff)
+		if !s.writeErr(cmd.Tag, "NO", "LOGIN failed") {
+			return false
+		}
+		return !disconnect
 	}
+	s.guard.ResetAuthFailures()
 	s.state = Authenticated
 	return s.writeErr(cmd.Tag, "OK", "LOGIN completed")
 }

mail/internal/imap/guard_test.go

@@ -0,0 +1,157 @@
+package imap
+
+import (
+	"context"
+	"net"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
+)
+
+func startTestServerWithGuardConfig(t *testing.T, guardCfg protoguard.Config) (addr string, stop func()) {
+	t.Helper()
+	auth := fakeAuthenticator{users: map[string]string{"alice": "geheim123"}}
+	store := fakeMailboxStore{mailboxes: map[string][]Message{
+		"INBOX": {
+			{SequenceNumber: 1, UID: 101, Flags: []string{"\\Seen"}},
+			{SequenceNumber: 2, UID: 102, Flags: []string{}},
+		},
+	}}
+	srv := NewServerWithGuardConfig(auth, store, guardCfg)
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("listener: %v", err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	done := make(chan struct{})
+	go func() {
+		_ = srv.Serve(ctx, listener)
+		close(done)
+	}()
+	return listener.Addr().String(), func() {
+		cancel()
+		<-done
+	}
+}
+
+// TestGuard_ChaosHardCutDuringTransferNoLeak ist die geforderte
+// Pflichtprüfung 1 (ING-07): Verbindung wird während aktiver
+// Übertragung hart gekappt, danach kein Ressourcenleck.
+func TestGuard_ChaosHardCutDuringTransferNoLeak(t *testing.T) {
+	addr, stop := startTestServerWithGuardConfig(t, protoguard.DefaultConfig())
+	defer stop()
+
+	runtime.GC()
+	baseline := runtime.NumGoroutine()
+
+	const rounds = 30
+	for i := 0; i < rounds; i++ {
+		c := dial(t, addr)
+		c.sendTagged(t, `LOGIN alice geheim123`)
+		c.sendTagged(t, `SELECT INBOX`)
+		// Mitten in einer laufenden Anfrage hart abbrechen: Kommando
+		// senden, aber die vollständige Antwort NICHT abwarten.
+		_, err := c.conn.Write([]byte("A99 FETCH 1:2 (FLAGS)\r\n"))
+		if err != nil {
+			t.Fatalf("kommando senden: %v", err)
+		}
+		_ = c.conn.Close()
+	}
+
+	deadline := time.Now().Add(3 * time.Second)
+	for {
+		runtime.GC()
+		current := runtime.NumGoroutine()
+		if current <= baseline+2 {
+			return
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("goroutine-leck nach hartem Verbindungsabbruch: baseline=%d, aktuell=%d", baseline, current)
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+}
+
+// TestGuard_TimeoutPerPhase ist die geforderte Pflichtprüfung 2
+// (ING-07): Timeout-Auslösung in jeder Protokollphase.
+func TestGuard_TimeoutPerPhase(t *testing.T) {
+	cfg := protoguard.Config{
+		PhaseTimeout: map[protoguard.Phase]time.Duration{
+			phaseNotAuthenticated: 100 * time.Millisecond,
+			phaseSelected:         100 * time.Millisecond,
+		},
+		DefaultTimeout: 5 * time.Second,
+	}
+
+	t.Run("not_authenticated", func(t *testing.T) {
+		addr, stop := startTestServerWithGuardConfig(t, cfg)
+		defer stop()
+		c := dial(t, addr)
+		defer c.close()
+
+		_ = c.conn.SetReadDeadline(time.Now().Add(2 * time.Second))
+		_, err := c.reader.ReadString('\n')
+		if err == nil {
+			t.Fatalf("erwartete Verbindungsende durch NotAuthenticated-Timeout")
+		}
+	})
+
+	t.Run("selected", func(t *testing.T) {
+		addr, stop := startTestServerWithGuardConfig(t, cfg)
+		defer stop()
+		c := dial(t, addr)
+		defer c.close()
+		c.sendTagged(t, `LOGIN alice geheim123`)
+		c.sendTagged(t, `SELECT INBOX`) // jetzt Selected, nichts weiter senden
+
+		_ = c.conn.SetReadDeadline(time.Now().Add(2 * time.Second))
+		_, err := c.reader.ReadString('\n')
+		if err == nil {
+			t.Fatalf("erwartete Verbindungsende durch Selected-Timeout")
+		}
+	})
+}
+
+// TestGuard_BackoffOnRepeatedAuthFailures ist die geforderte
+// Pflichtprüfung 3 (ING-07): Backoff-Verhalten bei wiederholten
+// Fehlversuchen statt Dauerschleife.
+func TestGuard_BackoffOnRepeatedAuthFailures(t *testing.T) {
+	cfg := protoguard.Config{
+		DefaultTimeout:  5 * time.Second,
+		MaxAuthFailures: 3,
+		BackoffBase:     50 * time.Millisecond,
+		BackoffMax:      500 * time.Millisecond,
+	}
+	addr, stop := startTestServerWithGuardConfig(t, cfg)
+	defer stop()
+	c := dial(t, addr)
+	defer c.close()
+
+	var attemptDurations []time.Duration
+	for i := 0; i < 3; i++ {
+		start := time.Now()
+		_, lines := c.sendTagged(t, `LOGIN alice falsch`)
+		last := lines[len(lines)-1]
+		if !strings.Contains(last, "NO") {
+			t.Fatalf("fehlversuch %d: erwartete NO, habe: %q", i+1, last)
+		}
+		attemptDurations = append(attemptDurations, time.Since(start))
+	}
+
+	if attemptDurations[1] <= attemptDurations[0] {
+		t.Fatalf("erwartete steigenden Backoff, habe Dauern: %v", attemptDurations)
+	}
+
+	// Nach MaxAuthFailures muss die Verbindung getrennt sein.
+	_ = c.conn.SetReadDeadline(time.Now().Add(2 * time.Second))
+	if _, err := c.conn.Write([]byte("A99 LOGIN alice geheim123\r\n")); err == nil {
+		_, err = c.reader.ReadString('\n')
+		if err == nil {
+			t.Fatalf("erwartete Verbindungstrennung nach %d Fehlversuchen", cfg.MaxAuthFailures)
+		}
+	}
+}

mail/internal/imap/server.go

@@ -5,6 +5,8 @@ import (
 	"errors"
 	"fmt"
 	"net"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
 )
 
 // Server nimmt IMAP-Verbindungen an und bedient jede in einer eigenen
@@ -13,12 +15,20 @@ import (
 // Klartext-TCP, wie im Ticket vorgesehen ("Bereite höchstens die
 // Schnittstelle dafür vor").
 type Server struct {
-	auth  Authenticator
+	auth     Authenticator
-	store MailboxStore
+	store    MailboxStore
+	guardCfg protoguard.Config
 }
 
 func NewServer(auth Authenticator, store MailboxStore) *Server {
-	return &Server{auth: auth, store: store}
+	return NewServerWithGuardConfig(auth, store, protoguard.DefaultConfig())
+}
+
+// NewServerWithGuardConfig erlaubt abweichende Phase-Timeouts und
+// Backoff-Parameter (ING-07), z. B. für Tests oder gehärtete
+// Betriebsumgebungen.
+func NewServerWithGuardConfig(auth Authenticator, store MailboxStore, guardCfg protoguard.Config) *Server {
+	return &Server{auth: auth, store: store, guardCfg: guardCfg}
 }
 
 // Serve nimmt Verbindungen auf listener an, bis ctx beendet wird oder
@@ -41,7 +51,7 @@ func (srv *Server) Serve(ctx context.Context, listener net.Listener) error {
 			}
 			return fmt.Errorf("imap: verbindung annehmen: %w", err)
 		}
-		session := newSession(conn, srv.auth, srv.store)
+		session := newSession(conn, srv.auth, srv.store, srv.guardCfg)
 		go session.Serve(ctx)
 	}
 }

mail/internal/imap/session.go

@@ -7,6 +7,18 @@ import (
 	"io"
 	"net"
 	"strings"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
+)
+
+// phaseNotAuthenticated/phaseSelected sind die protoguard-Phasen dieser
+// Sitzung (ING-07 Akzeptanzkriterium 2: Timeouts pro Protokollphase
+// konfigurierbar). Authenticated und Selected teilen sich denselben
+// Timeout — beides ist bereits angemeldeter Zustand, nur die
+// Anmeldephase braucht separate (typischerweise kürzere) Werte.
+const (
+	phaseNotAuthenticated protoguard.Phase = "not_authenticated"
+	phaseSelected         protoguard.Phase = "selected"
 )
 
 // maxCommandLineBytes begrenzt eine einzelne Kommandozeile (Defensive
@@ -18,27 +30,37 @@ const maxCommandLineBytes = 8192
 // Session ist eine einzelne IMAP-Verbindung mit eigener
 // Zustandsmaschine (Akzeptanzkriterium 1).
 type Session struct {
-	conn    net.Conn
+	conn        net.Conn
-	reader  *bufio.Reader
+	reader      *bufio.Reader
-	writer  *bufio.Writer
+	writer      *bufio.Writer
-	auth    Authenticator
+	auth        Authenticator
-	store   MailboxStore
+	store       MailboxStore
+	guard       *protoguard.Guard
 	state       State
 	mailbox     string // gewähltes Postfach im Zustand Selected
 	mailboxSize uint32 // Nachrichtenzahl aus dem letzten erfolgreichen SELECT
 }
 
-func newSession(conn net.Conn, auth Authenticator, store MailboxStore) *Session {
+func newSession(conn net.Conn, auth Authenticator, store MailboxStore, guardCfg protoguard.Config) *Session {
 	return &Session{
 		conn:   conn,
 		reader: bufio.NewReaderSize(conn, maxCommandLineBytes),
 		writer: bufio.NewWriter(conn),
 		auth:   auth,
 		store:  store,
+		guard:  protoguard.New(guardCfg),
 		state:  NotAuthenticated,
 	}
 }
 
+// currentPhase liefert die protoguard-Phase des aktuellen Sitzungszustands.
+func (s *Session) currentPhase() protoguard.Phase {
+	if s.state == NotAuthenticated {
+		return phaseNotAuthenticated
+	}
+	return phaseSelected
+}
+
 // State liefert den aktuellen Sitzungszustand (für Tests).
 func (s *Session) State() State { return s.state }
 
@@ -51,8 +73,18 @@ func (s *Session) Serve(ctx context.Context) {
 	}
 
 	for {
+		// Akzeptanzkriterium 2 (ING-07): Idle-Timeout pro Protokollphase,
+		// vor jedem Lesevorgang neu gesetzt, da ein Zustandswechsel die
+		// Phase (und damit den geltenden Timeout) ändern kann.
+		if err := s.guard.ApplyReadDeadline(s.conn, s.currentPhase()); err != nil {
+			return
+		}
 		line, err := s.readLine()
 		if err != nil {
+			// Verbindungsende (Timeout, Netzwerkabbruch oder harter
+			// Abbruch) — Session-Ressourcen werden über das defer
+			// conn.Close() oben zuverlässig freigegeben
+			// (Akzeptanzkriterium 1).
 			return
 		}
 		if line == "" {

mail/internal/pop3/commands.go

@@ -0,0 +1,210 @@
+package pop3
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// genericAuthFailure ist bewusst IMMER derselbe Text, unabhängig davon,
+// ob der Benutzername unbekannt oder nur das Passwort falsch war
+// (Akzeptanzkriterium 3: fehlerhafte Anmeldeversuche ohne
+// Informationspreisgabe).
+const genericAuthFailure = "authentication failed"
+
+func (s *Session) handleUser(cmd command) bool {
+	if s.state != Authorization {
+		return writeErr(s.writer, "command not valid in this state") == nil
+	}
+	if len(cmd.Args) != 1 {
+		return writeErr(s.writer, "USER requires a username") == nil
+	}
+	// RFC 1939: USER antwortet immer mit +OK, unabhängig davon, ob der
+	// Name existiert — die eigentliche Prüfung passiert erst bei PASS
+	// (Akzeptanzkriterium 3: keine Informationspreisgabe schon an dieser
+	// Stelle).
+	s.pendingUsername = cmd.Args[0]
+	return writeOK(s.writer, "send PASS") == nil
+}
+
+func (s *Session) handlePass(ctx context.Context, cmd command) bool {
+	if s.state != Authorization {
+		return writeErr(s.writer, "command not valid in this state") == nil
+	}
+	if s.pendingUsername == "" {
+		return writeErr(s.writer, genericAuthFailure) == nil
+	}
+	if len(cmd.Args) != 1 {
+		return writeErr(s.writer, "PASS requires a password") == nil
+	}
+	if s.auth == nil {
+		return writeErr(s.writer, genericAuthFailure) == nil
+	}
+
+	ok, err := s.auth.Authenticate(ctx, s.pendingUsername, cmd.Args[0])
+	if err != nil || !ok {
+		// Backoff statt Dauerschleife bei wiederholten Fehlversuchen
+		// (Akzeptanzkriterium 3, ING-07). Immer derselbe generische Text,
+		// egal ob unbekannter Nutzer, falsches Passwort oder interner
+		// Fehler.
+		backoff, disconnect := s.guard.RecordAuthFailure()
+		s.guard.Wait(ctx, backoff)
+		if err := writeErr(s.writer, genericAuthFailure); err != nil {
+			return false
+		}
+		return !disconnect
+	}
+
+	s.guard.ResetAuthFailures()
+	s.username = s.pendingUsername
+	s.state = Transaction
+	return writeOK(s.writer, "maildrop locked and ready") == nil
+}
+
+func (s *Session) handleStat(ctx context.Context) bool {
+	if s.state != Transaction {
+		return writeErr(s.writer, "command not valid in this state") == nil
+	}
+	messages, err := s.activeMessages(ctx)
+	if err != nil {
+		return writeErr(s.writer, "unable to read maildrop") == nil
+	}
+	var totalSize int64
+	for _, m := range messages {
+		totalSize += m.Size
+	}
+	return writeOK(s.writer, fmt.Sprintf("%d %d", len(messages), totalSize)) == nil
+}
+
+func (s *Session) handleList(ctx context.Context, cmd command) bool {
+	if s.state != Transaction {
+		return writeErr(s.writer, "command not valid in this state") == nil
+	}
+	messages, err := s.activeMessages(ctx)
+	if err != nil {
+		return writeErr(s.writer, "unable to read maildrop") == nil
+	}
+
+	if len(cmd.Args) == 1 {
+		n, convErr := strconv.Atoi(cmd.Args[0])
+		if convErr != nil {
+			return writeErr(s.writer, "invalid message number") == nil
+		}
+		for _, m := range messages {
+			if m.Number == n {
+				return writeOK(s.writer, fmt.Sprintf("%d %d", m.Number, m.Size)) == nil
+			}
+		}
+		return writeErr(s.writer, "no such message") == nil
+	}
+
+	var totalSize int64
+	lines := make([]string, 0, len(messages))
+	for _, m := range messages {
+		totalSize += m.Size
+		lines = append(lines, fmt.Sprintf("%d %d", m.Number, m.Size))
+	}
+	return writeMultiline(s.writer, fmt.Sprintf("%d messages (%d octets)", len(messages), totalSize), strings.Join(lines, "\n")) == nil
+}
+
+func (s *Session) handleRetr(ctx context.Context, cmd command) bool {
+	if s.state != Transaction {
+		return writeErr(s.writer, "command not valid in this state") == nil
+	}
+	n, err := s.parseActiveMessageNumber(ctx, cmd)
+	if err != nil {
+		return writeErr(s.writer, err.Error()) == nil
+	}
+
+	content, err := s.store.Retrieve(ctx, s.username, n)
+	if err != nil {
+		return writeErr(s.writer, "unable to retrieve message") == nil
+	}
+	// Akzeptanzkriterium 2: RETR liefert die VOLLSTÄNDIGE Nachricht.
+	return writeMultiline(s.writer, fmt.Sprintf("%d octets", len(content)), string(content)) == nil
+}
+
+func (s *Session) handleDele(cmd command) bool {
+	if s.state != Transaction {
+		return writeErr(s.writer, "command not valid in this state") == nil
+	}
+	if len(cmd.Args) != 1 {
+		return writeErr(s.writer, "DELE requires a message number") == nil
+	}
+	n, err := strconv.Atoi(cmd.Args[0])
+	if err != nil {
+		return writeErr(s.writer, "invalid message number") == nil
+	}
+	if s.deleted[n] {
+		return writeErr(s.writer, "message already deleted") == nil
+	}
+	// NUR innerhalb der Sitzung markiert — endgültig gelöscht wird
+	// ausschließlich in handleQuit (Akzeptanzkriterium 2/Pflichtprüfung 3).
+	s.deleted[n] = true
+	return writeOK(s.writer, fmt.Sprintf("message %d deleted", n)) == nil
+}
+
+func (s *Session) handleQuit(ctx context.Context) bool {
+	if s.state != Transaction {
+		// Aus Authorization: keine Update-Phase, keine Löschungen möglich
+		// (es wurde noch nichts markiert).
+		_ = writeOK(s.writer, "goodbye")
+		return false
+	}
+
+	s.state = Update
+	if len(s.deleted) > 0 {
+		numbers := make([]int, 0, len(s.deleted))
+		for n := range s.deleted {
+			numbers = append(numbers, n)
+		}
+		if err := s.store.Delete(ctx, s.username, numbers); err != nil {
+			_ = writeErr(s.writer, "unable to update maildrop, changes not committed")
+			return false
+		}
+	}
+	_ = writeOK(s.writer, "goodbye")
+	return false
+}
+
+// activeMessages liefert alle Nachrichten, die in DIESER Sitzung noch
+// nicht per DELE markiert wurden (RFC 1939: gelöschte Nachrichten sind
+// für STAT/LIST/RETR ab dem Zeitpunkt der Markierung nicht mehr sichtbar,
+// auch wenn die Löschung selbst erst bei QUIT endgültig wird).
+func (s *Session) activeMessages(ctx context.Context) ([]Message, error) {
+	all, err := s.store.List(ctx, s.username)
+	if err != nil {
+		return nil, err
+	}
+	active := make([]Message, 0, len(all))
+	for _, m := range all {
+		if !s.deleted[m.Number] {
+			active = append(active, m)
+		}
+	}
+	return active, nil
+}
+
+func (s *Session) parseActiveMessageNumber(ctx context.Context, cmd command) (int, error) {
+	if len(cmd.Args) != 1 {
+		return 0, fmt.Errorf("requires a message number")
+	}
+	n, err := strconv.Atoi(cmd.Args[0])
+	if err != nil {
+		return 0, fmt.Errorf("invalid message number")
+	}
+	if s.deleted[n] {
+		return 0, fmt.Errorf("message deleted")
+	}
+	messages, err := s.activeMessages(ctx)
+	if err != nil {
+		return 0, fmt.Errorf("unable to read maildrop")
+	}
+	for _, m := range messages {
+		if m.Number == n {
+			return n, nil
+		}
+	}
+	return 0, fmt.Errorf("no such message")
+}

mail/internal/pop3/guard_test.go

@@ -0,0 +1,189 @@
+package pop3
+
+import (
+	"bufio"
+	"context"
+	"net"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
+)
+
+func startTestServerWithGuardConfig(t *testing.T, guardCfg protoguard.Config) (addr string, store *fakeMailboxStore, stop func()) {
+	t.Helper()
+	auth := fakeAuthenticator{users: map[string]string{"alice": "geheim123"}}
+	store = newFakeMailboxStore()
+	srv := NewServerWithGuardConfig(auth, store, guardCfg)
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("listener: %v", err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	done := make(chan struct{})
+	go func() {
+		_ = srv.Serve(ctx, listener)
+		close(done)
+	}()
+	return listener.Addr().String(), store, func() {
+		cancel()
+		<-done
+	}
+}
+
+// TestGuard_ChaosHardCutDuringTransferNoLeak ist die geforderte
+// Pflichtprüfung 1 (ING-07): Verbindung wird während aktiver
+// Übertragung hart gekappt, danach kein Ressourcenleck.
+func TestGuard_ChaosHardCutDuringTransferNoLeak(t *testing.T) {
+	addr, _, stop := startTestServerWithGuardConfig(t, protoguard.DefaultConfig())
+	defer stop()
+
+	runtime.GC()
+	baseline := runtime.NumGoroutine()
+
+	const rounds = 30
+	for i := 0; i < rounds; i++ {
+		conn, err := net.DialTimeout("tcp", addr, 2*time.Second)
+		if err != nil {
+			t.Fatalf("dial: %v", err)
+		}
+		reader := bufio.NewReader(conn)
+		_, _ = reader.ReadString('\n') // Begrüßung
+		_, _ = conn.Write([]byte("USER alice\r\n"))
+		_, _ = reader.ReadString('\n')
+		_, _ = conn.Write([]byte("PASS geheim123\r\n"))
+		_, _ = reader.ReadString('\n')
+		// Mitten in der Multiline-Übertragung (RETR-Antwortkopf gelesen,
+		// Datenzeilen NICHT vollständig konsumiert) hart abbrechen.
+		_, _ = conn.Write([]byte("RETR 1\r\n"))
+		_, _ = reader.ReadString('\n') // nur die "+OK ... octets"-Kopfzeile
+		_ = conn.Close()
+	}
+
+	// Server braucht kurz, um die abgebrochenen Sessions abzuräumen.
+	deadline := time.Now().Add(3 * time.Second)
+	for {
+		runtime.GC()
+		current := runtime.NumGoroutine()
+		if current <= baseline+2 { // kleine Toleranz für Laufzeit-Jitter
+			return
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("goroutine-leck nach hartem Verbindungsabbruch: baseline=%d, aktuell=%d", baseline, current)
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+}
+
+// TestGuard_TimeoutPerPhase ist die geforderte Pflichtprüfung 2
+// (ING-07): Timeout-Auslösung in jeder Protokollphase.
+func TestGuard_TimeoutPerPhase(t *testing.T) {
+	cfg := protoguard.Config{
+		PhaseTimeout: map[protoguard.Phase]time.Duration{
+			phaseAuthorization: 100 * time.Millisecond,
+			phaseTransaction:   100 * time.Millisecond,
+		},
+		DefaultTimeout: 5 * time.Second,
+	}
+
+	t.Run("authorization", func(t *testing.T) {
+		addr, _, stop := startTestServerWithGuardConfig(t, cfg)
+		defer stop()
+		conn, err := net.DialTimeout("tcp", addr, 2*time.Second)
+		if err != nil {
+			t.Fatalf("dial: %v", err)
+		}
+		defer func() { _ = conn.Close() }()
+		reader := bufio.NewReader(conn)
+		_, _ = reader.ReadString('\n') // Begrüßung, aber nichts weiter senden
+
+		_ = conn.SetReadDeadline(time.Now().Add(2 * time.Second))
+		_, err = reader.ReadString('\n')
+		if err == nil {
+			t.Fatalf("erwartete Verbindungsende durch Authorization-Timeout")
+		}
+	})
+
+	t.Run("transaction", func(t *testing.T) {
+		addr, _, stop := startTestServerWithGuardConfig(t, cfg)
+		defer stop()
+		conn, err := net.DialTimeout("tcp", addr, 2*time.Second)
+		if err != nil {
+			t.Fatalf("dial: %v", err)
+		}
+		defer func() { _ = conn.Close() }()
+		reader := bufio.NewReader(conn)
+		_, _ = reader.ReadString('\n')
+		_, _ = conn.Write([]byte("USER alice\r\n"))
+		_, _ = reader.ReadString('\n')
+		_, _ = conn.Write([]byte("PASS geheim123\r\n"))
+		_, _ = reader.ReadString('\n') // jetzt in Transaction, nichts weiter senden
+
+		_ = conn.SetReadDeadline(time.Now().Add(2 * time.Second))
+		_, err = reader.ReadString('\n')
+		if err == nil {
+			t.Fatalf("erwartete Verbindungsende durch Transaction-Timeout")
+		}
+	})
+}
+
+// TestGuard_BackoffOnRepeatedAuthFailures ist die geforderte
+// Pflichtprüfung 3 (ING-07): Backoff-Verhalten bei wiederholten
+// Fehlversuchen statt Dauerschleife.
+func TestGuard_BackoffOnRepeatedAuthFailures(t *testing.T) {
+	cfg := protoguard.Config{
+		DefaultTimeout:  5 * time.Second,
+		MaxAuthFailures: 3,
+		BackoffBase:     50 * time.Millisecond,
+		BackoffMax:      500 * time.Millisecond,
+	}
+	addr, _, stop := startTestServerWithGuardConfig(t, cfg)
+	defer stop()
+
+	conn, err := net.DialTimeout("tcp", addr, 2*time.Second)
+	if err != nil {
+		t.Fatalf("dial: %v", err)
+	}
+	defer func() { _ = conn.Close() }()
+	reader := bufio.NewReader(conn)
+	_, _ = reader.ReadString('\n')
+
+	var attemptDurations []time.Duration
+	for i := 0; i < 3; i++ {
+		_, _ = conn.Write([]byte("USER alice\r\n"))
+		_, _ = reader.ReadString('\n')
+
+		start := time.Now()
+		_, _ = conn.Write([]byte("PASS falsch\r\n"))
+		_ = conn.SetReadDeadline(time.Now().Add(3 * time.Second))
+		resp, err := reader.ReadString('\n')
+		if err != nil {
+			if i < 2 {
+				t.Fatalf("fehlversuch %d: unerwarteter Verbindungsabbruch: %v", i+1, err)
+			}
+			// dritter Fehlversuch: Trennung nach der Antwort ist erlaubt.
+		} else if !strings.Contains(resp, "-ERR") {
+			t.Fatalf("fehlversuch %d: erwartete -ERR, habe: %q", i+1, resp)
+		}
+		attemptDurations = append(attemptDurations, time.Since(start))
+	}
+
+	// Backoff steigt: der zweite Fehlversuch muss spürbar länger dauern
+	// als der erste (Verdopplung statt konstanter/keiner Wartezeit).
+	if attemptDurations[1] <= attemptDurations[0] {
+		t.Fatalf("erwartete steigenden Backoff, habe Dauern: %v", attemptDurations)
+	}
+
+	// Nach MaxAuthFailures muss die Verbindung getrennt werden (kein
+	// endloses erneutes USER/PASS erlaubt) statt in Dauerschleife.
+	_ = conn.SetReadDeadline(time.Now().Add(2 * time.Second))
+	if _, err := conn.Write([]byte("USER alice\r\n")); err == nil {
+		_, err = reader.ReadString('\n')
+		if err == nil {
+			t.Fatalf("erwartete Verbindungstrennung nach %d Fehlversuchen", cfg.MaxAuthFailures)
+		}
+	}
+}

mail/internal/pop3/interfaces.go

@@ -0,0 +1,38 @@
+// Package pop3 implementiert ING-02: den POP3-Server (RFC 1939) mit den
+// Zuständen Authorization/Transaction/Update und den Kernbefehlen
+// USER/PASS/STAT/LIST/RETR/DELE/QUIT. Bewusste Neuimplementierung nach
+// NEXARCH-Techstack, kein 1:1-Übernehmen von archivmail — gleiche
+// Konvention wie mail/internal/imap (ING-01): eigene, schmale
+// Authenticator/MailboxStore-Schnittstellen statt geteilter Typen über
+// Paketgrenzen hinweg, CRLF-sichere Antworten (response.go).
+package pop3
+
+import "context"
+
+// Authenticator prüft Zugangsdaten für PASS.
+type Authenticator interface {
+	Authenticate(ctx context.Context, username, password string) (ok bool, err error)
+}
+
+// Message ist eine Nachricht im Postfach (nur Nummer/Größe für STAT/
+// LIST — Inhalt kommt separat über MailboxStore.Retrieve, damit LIST
+// nicht unnötig alle Nachrichteninhalte laden muss).
+type Message struct {
+	Number int
+	Size   int64
+}
+
+// MailboxStore liefert Postfachzustand für STAT/LIST/RETR/DELE.
+type MailboxStore interface {
+	// List liefert alle (noch nicht gelöschten) Nachrichten des Postfachs
+	// username.
+	List(ctx context.Context, username string) ([]Message, error)
+	// Retrieve liefert den vollständigen Inhalt einer Nachricht
+	// (Akzeptanzkriterium 2: RETR liefert vollständige Nachrichten).
+	Retrieve(ctx context.Context, username string, number int) ([]byte, error)
+	// Delete löscht die angegebenen Nachrichtennummern ENDGÜLTIG — wird
+	// AUSSCHLIESSLICH im Update-Zustand nach einem regulären QUIT
+	// aufgerufen (Akzeptanzkriterium 2/Pflichtprüfung 3: DELE markiert
+	// nur innerhalb der Sitzung, committet wird erst hier).
+	Delete(ctx context.Context, username string, numbers []int) error
+}

mail/internal/pop3/parser.go

@@ -0,0 +1,26 @@
+package pop3
+
+import "strings"
+
+// command ist eine geparste POP3-Kommandozeile — POP3 hat (anders als
+// IMAP) keine Tags, nur "KOMMANDO [Argumente]".
+type command struct {
+	Name string // groß geschrieben (z. B. "USER")
+	Args []string
+}
+
+// parseCommandLine zerlegt eine Kommandozeile (bereits ohne CRLF) in
+// Kommandoname und Leerzeichen-getrennte Argumente. POP3-Argumente
+// (Benutzername/Passwort/Nachrichtennummern) enthalten in der Praxis
+// keine Anführungszeichen-Syntax wie IMAP — ein einfacher Split genügt
+// für die kleinste Lösung.
+func parseCommandLine(line string) command {
+	fields := strings.Fields(line)
+	if len(fields) == 0 {
+		return command{}
+	}
+	return command{
+		Name: strings.ToUpper(fields[0]),
+		Args: fields[1:],
+	}
+}

mail/internal/pop3/pop3_test.go

@@ -0,0 +1,301 @@
+package pop3
+
+import (
+	"bufio"
+	"context"
+	"errors"
+	"net"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+type fakeAuthenticator struct {
+	users map[string]string
+}
+
+func (f fakeAuthenticator) Authenticate(_ context.Context, username, password string) (bool, error) {
+	want, ok := f.users[username]
+	return ok && want == password, nil
+}
+
+// fakeMailboxStore hält Nachrichten im Prozessspeicher — Delete entfernt
+// sie erst bei tatsächlichem Aufruf (durch handleQuit im Update-Zustand).
+type fakeMailboxStore struct {
+	mu       sync.Mutex
+	messages map[string]map[int]string // username -> nummer -> inhalt
+}
+
+func newFakeMailboxStore() *fakeMailboxStore {
+	return &fakeMailboxStore{messages: map[string]map[int]string{
+		"alice": {1: "Erste Testnachricht\nmit zwei Zeilen", 2: "Zweite Testnachricht"},
+	}}
+}
+
+func (f *fakeMailboxStore) List(_ context.Context, username string) ([]Message, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	msgs := f.messages[username]
+	result := make([]Message, 0, len(msgs))
+	for n, content := range msgs {
+		result = append(result, Message{Number: n, Size: int64(len(content))})
+	}
+	return result, nil
+}
+
+func (f *fakeMailboxStore) Retrieve(_ context.Context, username string, number int) ([]byte, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	content, ok := f.messages[username][number]
+	if !ok {
+		return nil, errors.New("keine solche nachricht")
+	}
+	return []byte(content), nil
+}
+
+func (f *fakeMailboxStore) Delete(_ context.Context, username string, numbers []int) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	for _, n := range numbers {
+		delete(f.messages[username], n)
+	}
+	return nil
+}
+
+func (f *fakeMailboxStore) count(username string) int {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return len(f.messages[username])
+}
+
+func startTestServer(t *testing.T) (addr string, store *fakeMailboxStore, stop func()) {
+	t.Helper()
+	auth := fakeAuthenticator{users: map[string]string{"alice": "geheim123"}}
+	store = newFakeMailboxStore()
+	srv := NewServer(auth, store)
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("listener: %v", err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	done := make(chan struct{})
+	go func() {
+		_ = srv.Serve(ctx, listener)
+		close(done)
+	}()
+	return listener.Addr().String(), store, func() {
+		cancel()
+		<-done
+	}
+}
+
+type pop3Client struct {
+	conn   net.Conn
+	reader *bufio.Reader
+}
+
+func dial(t *testing.T, addr string) *pop3Client {
+	t.Helper()
+	conn, err := net.DialTimeout("tcp", addr, 2*time.Second)
+	if err != nil {
+		t.Fatalf("dial: %v", err)
+	}
+	c := &pop3Client{conn: conn, reader: bufio.NewReader(conn)}
+	c.readLine(t) // Begrüßung
+	return c
+}
+
+func (c *pop3Client) readLine(t *testing.T) string {
+	t.Helper()
+	_ = c.conn.SetReadDeadline(time.Now().Add(3 * time.Second))
+	line, err := c.reader.ReadString('\n')
+	if err != nil {
+		t.Fatalf("antwort lesen: %v", err)
+	}
+	return strings.TrimRight(line, "\r\n")
+}
+
+// send sendet EIN Kommando und liest EINE Antwortzeile (Statuszeile).
+func (c *pop3Client) send(t *testing.T, cmd string) string {
+	t.Helper()
+	if _, err := c.conn.Write([]byte(cmd + "\r\n")); err != nil {
+		t.Fatalf("kommando senden: %v", err)
+	}
+	return c.readLine(t)
+}
+
+// sendMultiline sendet ein Kommando und liest bis zur "."-Abschlusszeile.
+func (c *pop3Client) sendMultiline(t *testing.T, cmd string) (status string, dataLines []string) {
+	t.Helper()
+	status = c.send(t, cmd)
+	if !strings.HasPrefix(status, "+OK") {
+		return status, nil
+	}
+	for {
+		line := c.readLine(t)
+		if line == "." {
+			return status, dataLines
+		}
+		dataLines = append(dataLines, line)
+	}
+}
+
+func (c *pop3Client) close() { _ = c.conn.Close() }
+
+func loginAsAlice(t *testing.T, c *pop3Client) {
+	t.Helper()
+	if resp := c.send(t, "USER alice"); !strings.HasPrefix(resp, "+OK") {
+		t.Fatalf("USER: %s", resp)
+	}
+	if resp := c.send(t, "PASS geheim123"); !strings.HasPrefix(resp, "+OK") {
+		t.Fatalf("PASS: %s", resp)
+	}
+}
+
+// TestSession_StateTransitions ist die geforderte Pflichtprüfung 1:
+// automatisierter Test für jede Zustandsübergangs-Regel.
+func TestSession_StateTransitions(t *testing.T) {
+	addr, _, stop := startTestServer(t)
+	defer stop()
+	c := dial(t, addr)
+	defer c.close()
+
+	// Verbotener Übergang: STAT/RETR/DELE in Authorization.
+	if resp := c.send(t, "STAT"); !strings.HasPrefix(resp, "-ERR") {
+		t.Fatalf("erwartete -ERR für STAT in Authorization, habe: %s", resp)
+	}
+	if resp := c.send(t, "RETR 1"); !strings.HasPrefix(resp, "-ERR") {
+		t.Fatalf("erwartete -ERR für RETR in Authorization, habe: %s", resp)
+	}
+
+	// PASS ohne vorheriges USER.
+	if resp := c.send(t, "PASS irgendwas"); !strings.HasPrefix(resp, "-ERR") {
+		t.Fatalf("erwartete -ERR für PASS ohne USER, habe: %s", resp)
+	}
+
+	// Authorization -> Transaction.
+	loginAsAlice(t, c)
+
+	// Verbotener Übergang: USER/PASS erneut in Transaction.
+	if resp := c.send(t, "USER alice"); !strings.HasPrefix(resp, "-ERR") {
+		t.Fatalf("erwartete -ERR für USER in Transaction, habe: %s", resp)
+	}
+
+	// In Transaction erlaubt: STAT.
+	if resp := c.send(t, "STAT"); !strings.HasPrefix(resp, "+OK") {
+		t.Fatalf("erwartete +OK für STAT in Transaction, habe: %s", resp)
+	}
+
+	// Transaction -> (Update, real durchlaufen) -> Verbindungsende.
+	if resp := c.send(t, "QUIT"); !strings.HasPrefix(resp, "+OK") {
+		t.Fatalf("erwartete +OK für QUIT, habe: %s", resp)
+	}
+}
+
+// TestCommands_RetrDeleFullCycle deckt Akzeptanzkriterium 2 ab: RETR
+// liefert vollständige Nachrichten, DELE + QUIT löscht endgültig.
+func TestCommands_RetrDeleFullCycle(t *testing.T) {
+	addr, store, stop := startTestServer(t)
+	defer stop()
+	c := dial(t, addr)
+	defer c.close()
+	loginAsAlice(t, c)
+
+	status, lines := c.sendMultiline(t, "RETR 1")
+	if !strings.HasPrefix(status, "+OK") {
+		t.Fatalf("RETR: %s", status)
+	}
+	full := strings.Join(lines, "\n")
+	if full != "Erste Testnachricht\nmit zwei Zeilen" {
+		t.Fatalf("RETR lieferte keine vollständige nachricht, habe: %q", full)
+	}
+
+	if resp := c.send(t, "DELE 1"); !strings.HasPrefix(resp, "+OK") {
+		t.Fatalf("DELE: %s", resp)
+	}
+	if resp := c.send(t, "QUIT"); !strings.HasPrefix(resp, "+OK") {
+		t.Fatalf("QUIT: %s", resp)
+	}
+
+	if store.count("alice") != 1 {
+		t.Fatalf("erwartete 1 verbleibende nachricht nach DELE+QUIT, habe %d", store.count("alice"))
+	}
+}
+
+// TestCommands_DeleWithoutQuitDeletesNothing ist die geforderte
+// Pflichtprüfung 3: DELE ohne anschließendes QUIT löscht nichts
+// endgültig.
+func TestCommands_DeleWithoutQuitDeletesNothing(t *testing.T) {
+	addr, store, stop := startTestServer(t)
+	defer stop()
+	c := dial(t, addr)
+	loginAsAlice(t, c)
+
+	if resp := c.send(t, "DELE 1"); !strings.HasPrefix(resp, "+OK") {
+		t.Fatalf("DELE: %s", resp)
+	}
+
+	// Verbindung OHNE QUIT abrupt schließen.
+	c.close()
+	time.Sleep(100 * time.Millisecond) // server real verarbeiten lassen
+
+	if store.count("alice") != 2 {
+		t.Fatalf("erwartete weiterhin 2 nachrichten (kein QUIT, keine endgültige löschung), habe %d", store.count("alice"))
+	}
+}
+
+// TestPass_RejectsWithoutInformationLeak ist die geforderte
+// Akzeptanzkriterium-3-Prüfung: fehlerhafte Anmeldeversuche ohne
+// Informationspreisgabe.
+func TestPass_RejectsWithoutInformationLeak(t *testing.T) {
+	addr, _, stop := startTestServer(t)
+	defer stop()
+
+	c1 := dial(t, addr)
+	defer c1.close()
+	c1.send(t, "USER unbekannter_nutzer")
+	respUnknownUser := c1.send(t, "PASS irgendwas")
+
+	c2 := dial(t, addr)
+	defer c2.close()
+	c2.send(t, "USER alice")
+	respWrongPassword := c2.send(t, "PASS falschespasswort")
+
+	if respUnknownUser != respWrongPassword {
+		t.Fatalf("unterschiedliche fehlermeldungen verraten, ob der nutzer existiert: %q vs %q", respUnknownUser, respWrongPassword)
+	}
+	if !strings.HasPrefix(respUnknownUser, "-ERR") {
+		t.Fatalf("erwartete -ERR, habe: %s", respUnknownUser)
+	}
+}
+
+// TestServer_ManyParallelSessions belegt Robustheit unter Last (Vorbild
+// ING-01) — kein expliziter Lasttest im Ticket gefordert, aber sinnvolle
+// Ergänzung zur Zustandsmaschinen-Testabdeckung.
+func TestServer_ManyParallelSessions(t *testing.T) {
+	addr, _, stop := startTestServer(t)
+	defer stop()
+
+	const sessions = 20
+	var wg sync.WaitGroup
+	for i := 0; i < sessions; i++ {
+		wg.Add(1)
+		go func(n int) {
+			defer wg.Done()
+			conn, err := net.DialTimeout("tcp", addr, 3*time.Second)
+			if err != nil {
+				t.Errorf("dial %d: %v", n, err)
+				return
+			}
+			defer func() { _ = conn.Close() }()
+			c := &pop3Client{conn: conn, reader: bufio.NewReader(conn)}
+			c.readLine(t)
+			loginAsAlice(t, c)
+			c.send(t, "STAT")
+			c.send(t, "QUIT")
+		}(i)
+	}
+	wg.Wait()
+}

mail/internal/pop3/response.go

@@ -0,0 +1,58 @@
+package pop3
+
+import (
+	"bufio"
+	"strings"
+)
+
+// sanitizeResponseText entfernt eingebettete CR/LF aus text, BEVOR er in
+// eine Antwortzeile eingebettet wird (Bekannter Fehler vermeiden — gleiche
+// Konvention wie mail/internal/imap/response.go: archivmail erlaubte
+// Header-/Zeilen-Injection durch Stringkonkatenation ohne CRLF-Prüfung).
+func sanitizeResponseText(text string) string {
+	text = strings.ReplaceAll(text, "\r", "")
+	text = strings.ReplaceAll(text, "\n", "")
+	return text
+}
+
+func writeOK(w *bufio.Writer, text string) error {
+	_, err := w.WriteString("+OK " + sanitizeResponseText(text) + "\r\n")
+	if err != nil {
+		return err
+	}
+	return w.Flush()
+}
+
+func writeErr(w *bufio.Writer, text string) error {
+	_, err := w.WriteString("-ERR " + sanitizeResponseText(text) + "\r\n")
+	if err != nil {
+		return err
+	}
+	return w.Flush()
+}
+
+// writeMultiline schreibt eine mehrzeilige POP3-Antwort (LIST/RETR):
+// "+OK ...\r\n" gefolgt von den Datenzeilen und einer abschließenden
+// "." -Zeile (RFC 1939 §3). content wird an "\n" in Zeilen zerlegt; jede
+// Zeile, die selbst mit "." beginnt, wird per "Byte-Stuffing" verdoppelt
+// (RFC-Pflicht UND zusätzlicher Schutz gegen eine vorzeitig wirkende
+// Terminierungszeile durch Nachrichteninhalt).
+func writeMultiline(w *bufio.Writer, okText, content string) error {
+	if _, err := w.WriteString("+OK " + sanitizeResponseText(okText) + "\r\n"); err != nil {
+		return err
+	}
+	normalized := strings.ReplaceAll(content, "\r\n", "\n")
+	for _, line := range strings.Split(normalized, "\n") {
+		line = strings.TrimSuffix(line, "\r")
+		if strings.HasPrefix(line, ".") {
+			line = "." + line
+		}
+		if _, err := w.WriteString(line + "\r\n"); err != nil {
+			return err
+		}
+	}
+	if _, err := w.WriteString(".\r\n"); err != nil {
+		return err
+	}
+	return w.Flush()
+}

mail/internal/pop3/server.go

@@ -0,0 +1,55 @@
+package pop3
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
+)
+
+// Server nimmt POP3-Verbindungen an und bedient jede in einer eigenen
+// Goroutine (Akzeptanzkriterium 1) — gleiches Muster wie
+// mail/internal/imap.Server. TLS/STARTTLS ist Sache von ING-06, nicht
+// dieser Kachel.
+type Server struct {
+	auth     Authenticator
+	store    MailboxStore
+	guardCfg protoguard.Config
+}
+
+func NewServer(auth Authenticator, store MailboxStore) *Server {
+	return NewServerWithGuardConfig(auth, store, protoguard.DefaultConfig())
+}
+
+// NewServerWithGuardConfig erlaubt abweichende Phase-Timeouts und
+// Backoff-Parameter (ING-07), z. B. für Tests oder gehärtete
+// Betriebsumgebungen.
+func NewServerWithGuardConfig(auth Authenticator, store MailboxStore, guardCfg protoguard.Config) *Server {
+	return &Server{auth: auth, store: store, guardCfg: guardCfg}
+}
+
+// Serve nimmt Verbindungen auf listener an, bis ctx beendet wird.
+func (srv *Server) Serve(ctx context.Context, listener net.Listener) error {
+	go func() {
+		<-ctx.Done()
+		_ = listener.Close()
+	}()
+
+	for {
+		conn, err := listener.Accept()
+		if err != nil {
+			if ctx.Err() != nil {
+				return nil
+			}
+			var netErr net.Error
+			if errors.As(err, &netErr) && netErr.Timeout() {
+				continue
+			}
+			return fmt.Errorf("pop3: verbindung annehmen: %w", err)
+		}
+		session := newSession(conn, srv.auth, srv.store, srv.guardCfg)
+		go session.Serve(ctx)
+	}
+}

mail/internal/pop3/session.go

@@ -0,0 +1,145 @@
+package pop3
+
+import (
+	"bufio"
+	"context"
+	"errors"
+	"io"
+	"net"
+	"strings"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
+)
+
+// phaseAuthorization/phaseTransaction sind die protoguard-Phasen dieser
+// Sitzung (ING-07 Akzeptanzkriterium 2: Timeouts pro Protokollphase
+// konfigurierbar).
+const (
+	phaseAuthorization protoguard.Phase = "authorization"
+	phaseTransaction   protoguard.Phase = "transaction"
+)
+
+// maxCommandLineBytes begrenzt eine einzelne Kommandozeile (defensive
+// Fehlerbehandlung bei nicht-konformen Gegenstellen, gleiche Konvention
+// wie mail/internal/imap).
+const maxCommandLineBytes = 8192
+
+// Session ist eine einzelne POP3-Verbindung mit eigener Zustandsmaschine
+// (Akzeptanzkriterium 1).
+type Session struct {
+	conn   net.Conn
+	reader *bufio.Reader
+	writer *bufio.Writer
+	auth   Authenticator
+	store  MailboxStore
+	guard  *protoguard.Guard
+
+	state           State
+	pendingUsername string // nach USER, vor erfolgreichem PASS
+	username        string // nach erfolgreichem PASS
+	deleted         map[int]bool
+}
+
+func newSession(conn net.Conn, auth Authenticator, store MailboxStore, guardCfg protoguard.Config) *Session {
+	return &Session{
+		conn:    conn,
+		reader:  bufio.NewReaderSize(conn, maxCommandLineBytes),
+		writer:  bufio.NewWriter(conn),
+		auth:    auth,
+		store:   store,
+		guard:   protoguard.New(guardCfg),
+		state:   Authorization,
+		deleted: map[int]bool{},
+	}
+}
+
+// currentPhase liefert die protoguard-Phase des aktuellen Sitzungszustands.
+func (s *Session) currentPhase() protoguard.Phase {
+	if s.state == Authorization {
+		return phaseAuthorization
+	}
+	return phaseTransaction
+}
+
+// State liefert den aktuellen Sitzungszustand (für Tests).
+func (s *Session) State() State { return s.state }
+
+// Serve führt die Sitzung bis QUIT oder Verbindungsende aus.
+func (s *Session) Serve(ctx context.Context) {
+	defer func() { _ = s.conn.Close() }()
+
+	if err := writeOK(s.writer, "POP3 server ready"); err != nil {
+		return
+	}
+
+	for {
+		// Akzeptanzkriterium 2 (ING-07): Idle-Timeout pro Protokollphase,
+		// vor jedem Lesevorgang neu gesetzt, da ein Zustandswechsel die
+		// Phase (und damit den geltenden Timeout) ändern kann.
+		if err := s.guard.ApplyReadDeadline(s.conn, s.currentPhase()); err != nil {
+			return
+		}
+		line, err := s.readLine()
+		if err != nil {
+			// Verbindung endet OHNE QUIT (Timeout, Netzwerkabbruch oder
+			// harter Verbindungsabbruch) — Akzeptanzkriterium 1: die
+			// Session-Ressourcen (Verbindung, Reader/Writer) werden über
+			// das defer conn.Close() oben zuverlässig freigegeben.
+			// Zusätzlich Pflichtprüfung 3: als Deleted markierte
+			// Nachrichten dürfen dadurch NICHT gelöscht werden. Da
+			// store.Delete nur im regulären handleQuit aufgerufen wird,
+			// ist das hier bereits strukturell garantiert (kein Aufruf,
+			// keine Löschung).
+			return
+		}
+		if line == "" {
+			continue
+		}
+
+		cmd := parseCommandLine(line)
+		if cmd.Name == "" {
+			if err := writeErr(s.writer, "unrecognized command"); err != nil {
+				return
+			}
+			continue
+		}
+
+		if !s.dispatch(ctx, cmd) {
+			return
+		}
+	}
+}
+
+func (s *Session) readLine() (string, error) {
+	line, err := s.reader.ReadString('\n')
+	if err != nil {
+		if errors.Is(err, io.EOF) && line != "" {
+			return strings.TrimRight(line, "\r"), nil
+		}
+		return "", err
+	}
+	return strings.TrimRight(line, "\r\n"), nil
+}
+
+// dispatch verarbeitet EIN geparstes Kommando. false bedeutet: Sitzung
+// beenden (QUIT abgeschlossen oder Schreibfehler).
+func (s *Session) dispatch(ctx context.Context, cmd command) bool {
+	switch cmd.Name {
+	case "USER":
+		return s.handleUser(cmd)
+	case "PASS":
+		return s.handlePass(ctx, cmd)
+	case "STAT":
+		return s.handleStat(ctx)
+	case "LIST":
+		return s.handleList(ctx, cmd)
+	case "RETR":
+		return s.handleRetr(ctx, cmd)
+	case "DELE":
+		return s.handleDele(cmd)
+	case "QUIT":
+		return s.handleQuit(ctx)
+	default:
+		return writeErr(s.writer, "unknown command") == nil
+	}
+}

mail/internal/pop3/state.go

@@ -0,0 +1,24 @@
+package pop3
+
+// State ist einer der drei POP3-Sitzungszustände (RFC 1939 §3),
+// Akzeptanzkriterium 1.
+type State int
+
+const (
+	Authorization State = iota
+	Transaction
+	Update
+)
+
+func (s State) String() string {
+	switch s {
+	case Authorization:
+		return "AUTHORIZATION"
+	case Transaction:
+		return "TRANSACTION"
+	case Update:
+		return "UPDATE"
+	default:
+		return "unknown"
+	}
+}

mail/internal/protoguard/protoguard.go

@@ -0,0 +1,119 @@
+// Package protoguard bündelt die Fehlerbehandlungs- und
+// Wiederverbindungslogik, die IMAP- und POP3-Sessions gemeinsam
+// brauchen (ING-07): pro Protokollphase konfigurierbare Idle-Timeouts
+// und Backoff statt Dauerschleife bei wiederholten Anmeldefehlern.
+// Ressourcenaufräumung selbst passiert bereits strukturell durch
+// defer conn.Close() in den Sessions — Guard sorgt dafür, dass dieser
+// Pfad auch bei hängenden oder böswilligen Gegenstellen zuverlässig
+// erreicht wird.
+package protoguard
+
+import (
+	"context"
+	"net"
+	"time"
+)
+
+// Phase identifiziert eine Protokollphase, für die ein eigener
+// Idle-Timeout gilt.
+type Phase string
+
+// Config steuert Timeout- und Backoff-Verhalten einer Verbindung.
+type Config struct {
+	// PhaseTimeout liefert den Idle-Timeout je Phase. Fehlt ein Eintrag,
+	// gilt DefaultTimeout.
+	PhaseTimeout map[Phase]time.Duration
+	// DefaultTimeout gilt, wenn für die aktuelle Phase kein eigener Wert
+	// gesetzt ist. 0 bedeutet: kein Timeout.
+	DefaultTimeout time.Duration
+	// MaxAuthFailures ist die Anzahl fehlgeschlagener Anmeldeversuche,
+	// nach der eine Verbindung getrennt wird. 0 bedeutet: unbegrenzt
+	// (kein Trennen, nur Backoff).
+	MaxAuthFailures int
+	// BackoffBase ist die Wartezeit vor der Antwort nach dem ersten
+	// Fehlversuch, verdoppelt sich je weiterem Fehlversuch bis
+	// BackoffMax.
+	BackoffBase time.Duration
+	BackoffMax  time.Duration
+}
+
+// DefaultConfig liefert praxistaugliche Werte für Produktionsbetrieb.
+func DefaultConfig() Config {
+	return Config{
+		DefaultTimeout:  5 * time.Minute,
+		MaxAuthFailures: 5,
+		BackoffBase:     200 * time.Millisecond,
+		BackoffMax:      5 * time.Second,
+	}
+}
+
+// Guard kapselt den Fehlerbehandlungszustand EINER Verbindung: aktuell
+// angewandte Phase-Timeouts und Zahl der Anmeldefehlversuche.
+type Guard struct {
+	cfg          Config
+	authFailures int
+}
+
+// New erstellt einen Guard für eine einzelne Session.
+func New(cfg Config) *Guard {
+	return &Guard{cfg: cfg}
+}
+
+// ApplyReadDeadline setzt die Lese-Deadline von conn passend zur
+// angegebenen Protokollphase (Akzeptanzkriterium 2).
+func (g *Guard) ApplyReadDeadline(conn net.Conn, phase Phase) error {
+	d := g.cfg.DefaultTimeout
+	if pd, ok := g.cfg.PhaseTimeout[phase]; ok {
+		d = pd
+	}
+	if d <= 0 {
+		return conn.SetReadDeadline(time.Time{})
+	}
+	return conn.SetReadDeadline(time.Now().Add(d))
+}
+
+// RecordAuthFailure zählt einen fehlgeschlagenen Anmeldeversuch dieser
+// Verbindung und liefert die Backoff-Wartezeit vor der Fehlerantwort
+// sowie ob die Verbindung danach getrennt werden muss (Akzeptanzkriterium
+// 3: klar definierter Backoff statt Dauerschleife).
+func (g *Guard) RecordAuthFailure() (backoff time.Duration, disconnect bool) {
+	g.authFailures++
+	backoff = g.backoffFor(g.authFailures)
+	disconnect = g.cfg.MaxAuthFailures > 0 && g.authFailures >= g.cfg.MaxAuthFailures
+	return backoff, disconnect
+}
+
+// ResetAuthFailures setzt den Fehlversuchszähler nach erfolgreicher
+// Anmeldung zurück.
+func (g *Guard) ResetAuthFailures() { g.authFailures = 0 }
+
+func (g *Guard) backoffFor(failures int) time.Duration {
+	if g.cfg.BackoffBase <= 0 {
+		return 0
+	}
+	d := g.cfg.BackoffBase
+	for i := 1; i < failures; i++ {
+		d *= 2
+		if g.cfg.BackoffMax > 0 && d >= g.cfg.BackoffMax {
+			return g.cfg.BackoffMax
+		}
+	}
+	if g.cfg.BackoffMax > 0 && d > g.cfg.BackoffMax {
+		return g.cfg.BackoffMax
+	}
+	return d
+}
+
+// Wait wartet d, bricht aber bei ctx-Abbruch sofort ab, damit ein
+// Server-Shutdown nicht auf eine laufende Backoff-Pause warten muss.
+func (g *Guard) Wait(ctx context.Context, d time.Duration) {
+	if d <= 0 {
+		return
+	}
+	timer := time.NewTimer(d)
+	defer timer.Stop()
+	select {
+	case <-timer.C:
+	case <-ctx.Done():
+	}
+}