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.
This commit is contained in:
sysops
@@ -44,11 +44,19 @@ func (s *Session) handlePass(ctx context.Context, cmd command) bool {
|
||||
|
||||
ok, err := s.auth.Authenticate(ctx, s.pendingUsername, cmd.Args[0])
|
||||
if err != nil || !ok {
|
||||
// Immer derselbe generische Text, egal ob unbekannter Nutzer,
|
||||
// falsches Passwort oder interner Fehler (Akzeptanzkriterium 3).
|
||||
return writeErr(s.writer, genericAuthFailure) == nil
|
||||
// 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
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -5,6 +5,8 @@ import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
|
||||
)
|
||||
|
||||
// Server nimmt POP3-Verbindungen an und bedient jede in einer eigenen
|
||||
@@ -12,12 +14,20 @@ import (
|
||||
// mail/internal/imap.Server. TLS/STARTTLS ist Sache von ING-06, nicht
|
||||
// dieser Kachel.
|
||||
type Server struct {
|
||||
auth Authenticator
|
||||
store MailboxStore
|
||||
auth Authenticator
|
||||
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.
|
||||
@@ -39,7 +49,7 @@ func (srv *Server) Serve(ctx context.Context, listener net.Listener) error {
|
||||
}
|
||||
return fmt.Errorf("pop3: verbindung annehmen: %w", err)
|
||||
}
|
||||
session := newSession(conn, srv.auth, srv.store)
|
||||
session := newSession(conn, srv.auth, srv.store, srv.guardCfg)
|
||||
go session.Serve(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,6 +7,16 @@ import (
|
||||
"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
|
||||
@@ -22,6 +32,7 @@ type Session struct {
|
||||
writer *bufio.Writer
|
||||
auth Authenticator
|
||||
store MailboxStore
|
||||
guard *protoguard.Guard
|
||||
|
||||
state State
|
||||
pendingUsername string // nach USER, vor erfolgreichem PASS
|
||||
@@ -29,18 +40,27 @@ type Session struct {
|
||||
deleted map[int]bool
|
||||
}
|
||||
|
||||
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: 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 }
|
||||
|
||||
@@ -53,13 +73,23 @@ 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 {
|
||||
// Verbindung endet OHNE QUIT — Akzeptanzkriterium/
|
||||
// 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).
|
||||
// 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 == "" {
|
||||
|
||||
Reference in New Issue
Block a user