feat(mail): ING-02 POP3-Server (RFC 1939) mit Zustandsmaschine
Vollständiger POP3-Server von Grund auf implementiert, analog zum bestehenden IMAP-Server (ING-01): TCP-Listener mit einer Goroutine pro Verbindung, CRLF/Byte-Stuffing-sichere Response-Writer, Zustandsmaschine (Authorization/Transaction/Update), Kommandos USER, PASS, STAT, LIST, RETR, DELE, QUIT. Zentrale Designentscheidungen: - USER antwortet immer +OK (RFC-konform), Prüfung erst bei PASS - Fehlgeschlagene Anmeldung liefert für unbekannten Benutzer und falsches Passwort denselben generischen Text (keine Informationspreisgabe, Akzeptanzkriterium 3) - DELE markiert Nachrichten nur sitzungslokal; store.Delete wird strukturell ausschließlich in QUIT (Transaction -> Update) aufgerufen, wodurch ein Verbindungsabbruch ohne QUIT nichts endgültig löscht (Pflichtprüfung 3) Alle drei Pflichtprüfungen mit echten Nachweisen durchgeführt: Zustandsübergangs-Tests gegen realen TCP-Server, manuelle Session mit Python-Standardbibliothek poplib (echtes Transkript im Prüfprotokoll), automatisierter Test für DELE-ohne-QUIT. Zusätzlich: 20 parallele reale Sessions (Akzeptanzkriterium 1), vollständiger RETR+DELE+QUIT-Zyklus (Akzeptanzkriterium 2). go build/go vet/golangci-lint clean, gesamtes Mail-Modul (~24 Pakete) regressionsfrei getestet. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01HhgFcLS8tYMhDJpP74C6AQ
This commit is contained in:
sysops
co-authored by
Claude Sonnet 5
Claude Sonnet 5
parent
5dcfa36f99
commit
bd1f52648c
@@ -0,0 +1,202 @@
|
||||
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 {
|
||||
// Immer derselbe generische Text, egal ob unbekannter Nutzer,
|
||||
// falsches Passwort oder interner Fehler (Akzeptanzkriterium 3).
|
||||
return writeErr(s.writer, genericAuthFailure) == nil
|
||||
}
|
||||
|
||||
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")
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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:],
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
package pop3
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
)
|
||||
|
||||
// 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
|
||||
}
|
||||
|
||||
func NewServer(auth Authenticator, store MailboxStore) *Server {
|
||||
return &Server{auth: auth, store: store}
|
||||
}
|
||||
|
||||
// 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)
|
||||
go session.Serve(ctx)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
package pop3
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"net"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// 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
|
||||
|
||||
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) *Session {
|
||||
return &Session{
|
||||
conn: conn,
|
||||
reader: bufio.NewReaderSize(conn, maxCommandLineBytes),
|
||||
writer: bufio.NewWriter(conn),
|
||||
auth: auth,
|
||||
store: store,
|
||||
state: Authorization,
|
||||
deleted: map[int]bool{},
|
||||
}
|
||||
}
|
||||
|
||||
// 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 {
|
||||
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).
|
||||
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
|
||||
}
|
||||
}
|
||||
@@ -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"
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user