feat(mail): QA-04 Sicherheits-/Berechtigungsprüfung — fehlenden SMTP-Idle-Timeout gefunden und behoben

Gezielter Testangriff auf den SMTP-Pfad deckte einen realen
Härtungsfehler auf: ING-07 (Idle-Timeout via protoguard) wurde
versehentlich nur in mail/internal/imap und mail/internal/pop3
verdrahtet, SMTP bekam nie einen Timeout. Eine Gegenstelle, die eine
Kommandozeile ohne abschließendes CRLF öffnet und nie beendet, konnte
die Session unbegrenzt blockieren — real reproduziert und danach
behoben.

session.go/server.go (smtp): guard *protoguard.Guard neu, Timeout wird
in readLine() selbst gesetzt (ein Ort für Haupt-Serve-Schleife,
handleData, drainUntilDot). Neuer Konstruktor
NewServerWithMaxMessageBytesTLSLoggerRateLimitAndGuardConfig für
abweichende Timeout-Werte. Bestehende Konstruktoren bekommen automatisch
protoguard.DefaultConfig() (5 Minuten) statt wie zuvor gar keinen
Timeout — reine Härtung, keine Verhaltensänderung für funktionierende
Clients, QA-07-Lasttest bleibt unverändert grün.

Neue Tests: qa04_security_test.go (Header-Injection-Angriffe auf
Envelope-Adressen, Ressourcenerschöpfung durch nie abgeschlossene Zeile
— deckte den Fehler auf und bestätigt die Korrektur).
mailboxconfig/tenant_scoping_test.go: Stichprobe eines dritten
Speicherpfads (verschlüsselte IMAP-Zugangsdaten) — Zugriff mit echter,
bekannter fremder ID wird über alle vier Operationen zuverlässig
abgelehnt.

Rate-Limiting-Teil von Akzeptanzkriterium 3 real bestätigt (ING-09,
erneut mitgeprüft). API-Token-Teil bleibt offen: das Mail-Board besitzt
keine eigene Token-Authentifizierung, bewusst an Core-Board IAM
delegiert (QA-04s eigene Ausgangslage) — im Prüfprotokoll dokumentiert.

go build/go vet/golangci-lint clean, gesamtes Mail-Modul
regressionsfrei getestet.

mail/docs/ARC-06-PRUEFPROTOKOLL.md

@@ -0,0 +1,116 @@
+# ARC-06 — Mandantentrennung im Objekt-Storage: Prüfprotokoll
+
+Datum: 2026-09-01
+Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
+Paket: `mail/internal/storage` (`provision.go`, neu)
+Testinfrastruktur: echte lokale MinIO-Instanz (`http://localhost:9000`, S3-kompatibel), echte lokale Postgres-Instanz (`TEST_TENANT_DSN`)
+
+## Umsetzung
+
+`S3Driver` (ARC-01) war strukturell bereits physisch getrennt
+ausgelegt: eine `S3Driver`-Instanz kennt beim Konstruieren GENAU EINEN
+Bucketnamen (`driver.go`) und hat keinen Parameter/Pfad-Präfix, über
+den sie jemals ein anderes Bucket adressieren könnte — kein
+gemeinsamer Bucket mit Pfad-Präfix wie beim klassischen Cross-Tenant-
+Leck-Muster. Was fehlte, war die AUTOMATISIERTE PROVISIONIERUNG dieser
+Trennung (Akzeptanzkriterium 3) und der Nachweis (Pflichtprüfungen).
+
+Neue Datei `provision.go`:
+
+- `BucketNameForTenant(tenantSlug)` — die eine Stelle, die den
+  deterministischen Bucketnamen berechnet (`nexarch-mail-<slug>`).
+- `NewS3AdminClient` — S3-Client für Bucket-Verwaltungsoperationen
+  (`CreateBucket`/`HeadBucket`), getrennt von `S3Driver` (das nur
+  Objektoperationen innerhalb eines bereits bekannten Buckets kennt).
+- `ProvisionTenant(ctx, registryPool, s3Admin, tenantSlug, tenantName,
+  dbDSN)` — legt in EINEM Aufruf sowohl die Registry-Zeile in derselben
+  `tenants`-Tabelle wie Core TEN-01
+  (`migrations/0001_tenant_registry.sql` im Repository-Root) als auch
+  den physisch getrennten Bucket an. Schlägt die Bucket-Anlage fehl,
+  wird die Registry-Zeile automatisch zurückgenommen — kein halb
+  provisionierter Mandant.
+
+**Abgrenzung zu Core TEN-01, dokumentiert:** Core TEN-01 (in
+`cmd/core`/`internal/db` im Repository-Root) ist im aktuellen Stand ein
+Grundgerüst (Registry-Tabelle + Health-Endpunkt), enthält noch keine
+eigene, aufrufbare Tenant-Datenbank-Provisionierungsfunktion, an die
+sich diese Kachel technisch anhängen könnte. `ProvisionTenant` schreibt
+deshalb direkt in dieselbe, bereits durch TEN-01 definierte
+`tenants`-Tabelle (Postgres-DSN, kein Cross-Modul-Go-Import nötig, da
+beide Module ohnehin nur über den DSN kommunizieren) — sobald TEN-01
+eine eigene Provisionierungsfunktion bekommt, ruft sie `ProvisionTenant`
+auf, statt dass Mail eine parallele Implementierung pflegt.
+
+## Pflichtprüfung 1: Test bestätigt physische Bucket-Trennung zweier Mandanten
+
+`TestProvisionTenant_CreatesPhysicallySeparateBuckets`: zwei Mandanten
+provisioniert, unterschiedliche Bucketnamen bestätigt. Ein Objekt wird
+in Mandant As Bucket geschrieben; der Zugriff auf denselben Schlüssel
+über Mandant Bs `S3Driver` liefert `ErrNotFound` — nicht weil ein
+Pfadfilter greift, sondern weil es in Mandant Bs (physisch anderem)
+Bucket schlicht kein Objekt dieses Namens gibt. Kontrollzugriff über
+Mandant As eigenen Driver liefert den byteidentischen Inhalt zurück.
+
+Ergebnis: **BESTANDEN** (echte MinIO-Instanz, reale S3-API-Aufrufe).
+
+## Pflichtprüfung 2: Simulierter Zugriffsversuch ohne Tenant-Kontext schlägt fehl, weil kein Bucket referenzierbar ist, nicht weil ein Pfadfilter greift
+
+`TestAccessWithoutTenantContext_FailsBecauseNoBucketReferenceable`:
+`HeadBucket` auf den (nie provisionierten) Bucketnamen eines
+erfundenen Pseudo-Mandanten liefert einen echten S3-API-Fehler auf
+BUCKET-Ebene (`NotFound`/`NoSuchBucket`) — bevor überhaupt eine
+Schlüsselsuche innerhalb eines (in diesem Fall nicht existenten)
+Buckets stattfinden könnte. Das ist der strukturelle Beweis: es gibt
+keinen gemeinsamen Fallback-Bucket, in dem ein fehlender Tenant-Kontext
+auf einen falschen/fehlenden Pfad treffen würde — es gibt schlicht kein
+Bucket.
+
+Ergebnis: **BESTANDEN** (echte MinIO-Instanz).
+
+## Pflichtprüfung 3: Provisionierungs-Test legt für einen neuen Mandanten Datenbank UND Bucket in einem Schritt an
+
+`TestProvisionTenant_CreatesRegistryRowAndBucketInOneStep`: EIN Aufruf
+von `ProvisionTenant` — danach existiert sowohl die Registry-Zeile
+(`SELECT ... FROM tenants WHERE slug = ...` liefert den erwarteten
+`db_dsn`) als auch das Bucket (`HeadBucket` erfolgreich), real gegen
+Postgres und MinIO geprüft. Ergänzend
+`TestProvisionTenant_RollsBackRegistryRowOnBucketFailure`: bei
+fehlschlagender Bucket-Anlage (ungültiger Bucketname) bleibt KEINE
+verwaiste Registry-Zeile zurück — kein halb provisionierter Mandant.
+
+Ergebnis: **BESTANDEN** (echte MinIO- und Postgres-Instanz, inkl.
+Fehlerpfad).
+
+## Akzeptanzkriterien
+
+1. **Jeder Mandant hat einen eigenen, physisch getrennten
+   Bucket/Pfad-Root**: durch Pflichtprüfung 1 belegt.
+2. **Ein Zugriffsversuch ohne oder mit falschem Tenant-Kontext kann
+   technisch kein fremdes Bucket erreichen, nicht nur einen falschen
+   Pfad**: durch Pflichtprüfung 1+2 belegt (strukturell durch
+   `S3Driver`s Design seit ARC-01, hier erstmals real nachgewiesen).
+3. **Bucket-Provisionierung ist Teil desselben automatisierten
+   Schritts wie die Tenant-Datenbank-Anlage, keine manuelle
+   Zusatzaktion nötig**: durch Pflichtprüfung 3 belegt — siehe auch
+   Abschnitt "Umsetzung" zur Abgrenzung gegenüber Core TEN-01s
+   aktuellem Ausbaustand.
+
+## 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, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok
+```
+
+Keine Regression in den bestehenden Paketen. Neue Umgebungsvariablen
+`TEST_S3_ENDPOINT`/`TEST_S3_ACCESS_KEY`/`TEST_S3_SECRET_KEY` — ohne sie
+werden die neuen Integrationstests übersprungen (`t.Skip`), gleiche
+Konvention wie `TEST_TENANT_DSN`/`TEST_MANTICORE_URL`.
+
+## Ergebnis
+
+ARC-06 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
+Nachweisen gegen eine reale MinIO- und Postgres-Instanz. Freigeschaltet
+zusammen mit SRC-11: QA-04.

mail/docs/ING-09-PRUEFPROTOKOLL.md

@@ -0,0 +1,99 @@
+# ING-09 — Rate-Limiting auf Protokollebene: Prüfprotokoll
+
+Datum: 2026-09-01
+Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
+Pakete: `mail/internal/ratelimit` (neu, gemeinsam genutzt), `mail/internal/imap`, `mail/internal/pop3`, `mail/internal/smtp`
+
+## Umsetzung
+
+Neues Paket `ratelimit`: Token-Bucket-Rate-Limiting, je (Mandant,
+Quelle)-Schlüssel ein eigener Bucket. `ConfigProvider`/`StaticConfig`
+liefern die Konfiguration (Burst, Nachfüllrate) je Mandant, mit
+Fallback auf eine Default-Konfiguration (Akzeptanzkriterium 1/2:
+begrenzt UND konfigurierbar; Akzeptanzkriterium 3: je Mandant getrennt
+konfigurierbar). `Limiter.Allow(tenant, source)` liefert bei Ablehnung
+eine konkrete, positive Wartezeit statt nur `false` — Grundlage für
+Akzeptanzkriterium 3: "definierte Ablehnung MIT Wartezeit-Hinweis,
+nicht Verbindungsabbruch ohne Erklärung".
+
+**IMAP** (`LOGIN`) und **POP3** (`PASS`) begrenzen Anmeldeversuche pro
+(Mandant, Quell-IP) — Akzeptanzkriterium 1. **SMTP** (`MAIL FROM`)
+begrenzt die Annahmerate pro (Mandant, Absenderadresse+Quell-IP) —
+Akzeptanzkriterium 2. Bei Überschreitung antwortet der Server mit einer
+Fehlermeldung, die die Wartezeit in Sekunden nennt (POP3 `-ERR`, IMAP
+`NO`, SMTP `451` — temporärer Fehlercode, "versuch es später erneut"),
+die Verbindung bleibt in allen drei Fällen offen und weiter nutzbar
+(Akzeptanzkriterium 3). `loginLimiter`/`acceptLimiter` sind optional
+(`nil` = kein Rate-Limiting, Rückwärtskompatibilität zu ING-01..ING-08);
+neue Konstruktoren `NewServerWithGuardTLSLoggerAndRateLimit` (IMAP/POP3)
+und `NewServerWithMaxMessageBytesTLSLoggerAndRateLimit` (SMTP).
+
+Jeder `Server` bekommt eine `tenantID` — konsistent mit dem in ING-10
+etablierten Muster "ein Server-Prozess/Instanz je Mandant" — und ein
+`*ratelimit.Limiter`, der über mehrere Server-Instanzen (Mandanten)
+hinweg geteilt werden kann, aber intern strikt nach `tenantID` trennt.
+
+## Pflichtprüfung 1: Lasttest bestätigt greifendes Limit bei Überschreitung
+
+`TestRateLimit_LoadExceedingLimitGetsRejectedWithRetryHint` in allen
+drei Protokollpaketen: Burst=5, 20 reale, aufeinanderfolgende
+Anmelde-/Annahmeversuche über echte TCP-Verbindungen gegen den
+laufenden Server. Ergebnis in allen drei Protokollen identisch: exakt
+5 Versuche akzeptiert (der konfigurierte Burst), exakt 15 Versuche mit
+der erwarteten Fehlermeldung inkl. Wartezeit-Hinweis abgelehnt — kein
+Verbindungsabbruch, jede Ablehnung kommt als reguläre Protokollantwort.
+
+Ergebnis: **BESTANDEN** in allen drei Protokollen.
+
+## Pflichtprüfung 2: legitime Nutzung unterhalb der Schwelle bleibt unbeeinträchtigt
+
+`TestRateLimit_LegitUsageBelowThresholdUnaffected` in allen drei
+Protokollpaketen: Burst=10, nur 3 Versuche — alle drei erfolgreich,
+keine Ablehnung.
+
+Ergebnis: **BESTANDEN** in allen drei Protokollen.
+
+## Pflichtprüfung 3: Limit ist je Mandant getrennt konfigurierbar und wirksam
+
+`TestRateLimit_PerTenantIndependentAndEffective` in allen drei
+Protokollpaketen: EIN gemeinsamer `*ratelimit.Limiter`, aber zwei
+Server-Instanzen mit unterschiedlicher `tenantID`
+(`mandant-knapp` → Burst 2, `mandant-grosszuegig` → Burst 8, per
+`StaticConfig.PerTenant`). 10 Versuche je Mandant: `mandant-knapp`
+akzeptiert exakt 2, `mandant-grosszuegig` akzeptiert exakt 8 — beweist
+sowohl die Trennung (unterschiedliche Werte wirken unabhängig) als auch
+die Wirksamkeit (jeweils exakt der konfigurierte Burst, nicht mehr,
+nicht weniger).
+
+Ergebnis: **BESTANDEN** in allen drei Protokollen.
+
+## Akzeptanzkriterien
+
+1. **Login-Versuche pro Quelle/Zeitfenster sind begrenzt und
+   konfigurierbar**: IMAP/POP3, durch Pflichtprüfung 1+2 belegt.
+2. **SMTP-Annahmerate pro Absender/Quelle ist begrenzt und
+   konfigurierbar**: SMTP, durch Pflichtprüfung 1+2 belegt.
+3. **Überschreitung führt zu definierter Ablehnung mit
+   Wartezeit-Hinweis, nicht zu Verbindungsabbruch ohne Erklärung**:
+   durch Pflichtprüfung 1 belegt (Verbindung bleibt in jedem Testlauf
+   offen, jede Ablehnung enthält die Wartezeit in Sekunden).
+
+## 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/ratelimit
+```
+
+Keine Regression in den bestehenden ~31 Paketen — insbesondere die
+QA-07-Lasttests bleiben grün: Rate-Limiting ist standardmäßig
+deaktiviert (`loginLimiter`/`acceptLimiter` nil), bis explizit über die
+neuen Konstruktoren aktiviert.
+
+## Ergebnis
+
+ING-09 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
+Nachweisen — in allen drei Protokollen (IMAP, POP3, SMTP) einzeln
+geprüft. Freigeschaltet: QA-04.

mail/docs/QA-04-PRUEFPROTOKOLL.md

@@ -0,0 +1,134 @@
+# QA-04 — Sicherheits- & Berechtigungsprüfung: Prüfprotokoll
+
+Datum: 2026-09-01
+Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
+Geprüfte Pakete: `mail/internal/smtp`, `mail/internal/mailer`, `mail/internal/storage`, `mail/internal/folderstate`, `mail/internal/mailboxconfig`, `mail/internal/ratelimit`
+
+## Umsetzung — echter Sicherheitsbefund und Korrektur
+
+Der gezielte Testangriff auf den SMTP-Pfad (Pflichtprüfung 1) deckte
+einen REALEN Härtungsfehler auf, der VOR dieser Kachel unbemerkt
+geblieben war: ING-07 (Idle-Timeout-Schutz) hatte `protoguard` nur in
+`mail/internal/imap` und `mail/internal/pop3` verdrahtet — `mail/
+internal/smtp` bekam versehentlich NIE einen Idle-Timeout. Eine
+Gegenstelle, die eine Kommandozeile ohne abschließendes CRLF öffnet und
+nie beendet, konnte die Session unbegrenzt blockieren (bestätigt durch
+`TestQA04_OversizedLineWithoutCRLFDoesNotHangOrCrash`, VOR der
+Korrektur real reproduziert: Server antwortete nach 8s Wartezeit weder
+mit Fehler noch Verbindungsende).
+
+**Korrektur** (`session.go`/`server.go`, `mail/internal/smtp`): `guard
+*protoguard.Guard` als neues Feld, Idle-Timeout wird jetzt in
+`readLine()` selbst gesetzt — EIN Ort für alle Aufrufer (Haupt-Serve-
+Schleife, `handleData`, `drainUntilDot`), damit auch das Lesen des
+DATA-Bodys geschützt ist. Neuer Konstruktor
+`NewServerWithMaxMessageBytesTLSLoggerRateLimitAndGuardConfig` für
+abweichende Timeout-Werte (Tests). Bestehende Konstruktoren bekommen
+automatisch `protoguard.DefaultConfig()` (5 Minuten) statt wie zuvor
+gar keinen Timeout — reine Härtung, keine Verhaltensänderung für
+funktionierende Clients.
+
+## Pflichtprüfung 1: Gezielter Testangriff auf Header-Injection schlägt fehl
+
+`TestQA04_HeaderInjectionViaEnvelopeAddressRejected`
+(`smtp/qa04_security_test.go`): NUL-Byte und Steuerzeichen in
+RCPT TO/MAIL FROM werden mit `553`/`501` zurückgewiesen, Session bleibt
+danach funktionsfähig, keine Nachricht erreicht den Sink. Ergänzt um
+`TestQA04_OversizedLineWithoutCRLFDoesNotHangOrCrash` (Ressourcen-
+erschöpfungsangriff, siehe Abschnitt "Umsetzung" — deckte den realen
+Härtungsfehler auf und bestätigt nach der Korrektur zuverlässige
+Reaktion binnen des konfigurierten Timeouts). Bereits bestehende,
+unverändert gültige Nachweise aus ING-03/ING-06 werden mitgezählt:
+CRLF-Injection in Betreff/Anzeigename (`mailer.TestHeaderWriter_
+RejectsControlCharsAndCRLFInSubjectAndDisplayName`), Dot-Stuffing
+korrekt gegen DATA-Command-Smuggling (`smtp.TestData_
+MessageSizeCheckedBeforeAcceptance` u. a.), TLS-Downgrade-Angriffe
+(`smtp.TestServer_RejectsLegacyTLSVersionAndWeakCiphers`, ING-06).
+
+Ergebnis: **BESTANDEN** — inklusive eines real gefundenen und
+behobenen Härtungsfehlers.
+
+## Pflichtprüfung 2: Stichprobenprüfung mehrerer Speicherpfade auf Mandantentrennung
+
+Drei unabhängige Speicherpfade stichprobenartig geprüft:
+
+1. **Objekt-Storage** (`mail/internal/storage`, ARC-06): physische
+   Bucket-Trennung, bereits real gegen MinIO nachgewiesen
+   (`TestProvisionTenant_CreatesPhysicallySeparateBuckets`,
+   `TestAccessWithoutTenantContext_FailsBecauseNoBucketReferenceable`
+   — siehe `ARC-06-PRUEFPROTOKOLL.md`).
+2. **Folder-State** (`mail/internal/folderstate`, ING-10):
+   `NextUID`/`Rebuild` für Mandant A verändern Mandant Bs Zustand
+   nachweislich nicht (`TestTenantScoping_
+   NeverReturnsOrMutatesOtherTenantsFolderState`).
+3. **Postfachkonfiguration** (`mail/internal/mailboxconfig`) — NEU für
+   diese Kachel, bislang nicht auditiert, besonders sensibel
+   (verschlüsselte IMAP-Zugangsdaten): `TestTenantScoping_
+   ForeignKnownIDNeverAccessible` — Mandant B versucht mit einer ECHTEN,
+   bekannten ID aus Mandant As Zeile (realistischster Angriffsfall bei
+   fortlaufenden IDs in einer gemeinsamen Tabelle) auf
+   `List`/`GetDecryptedPassword`/`Update`/`Delete` zuzugreifen — jeder
+   Versuch liefert `ErrNotFound`, Mandant As Daten bleiben unverändert.
+
+Ergebnis: **BESTANDEN** in allen drei gezogenen Stichproben.
+
+## Pflichtprüfung 3: Test: API-Zugriff mit widerrufenem/fremdem Token wird verweigert
+
+**Teilweise nicht durchführbar, dokumentiert:** Das Mail-Modul besitzt
+aktuell KEINE eigene HTTP-API mit Token-/Session-Authentifizierung —
+jede vorhandene Schnittstelle (`web/mail-search`, SRC-04) verweist
+explizit auf eine noch ausstehende "zentrale Session-/IAM-Anbindung
+(Core-Board-Scope, nicht Bestandteil dieser Kachel)", konsistent mit
+QA-04s eigener Ausgangslage: "Berührt Login-Tenant-Filter und
+Privilege-Escalation – dafür ist bereits Core-Board IAM zuständig, hier
+nur Mail-spezifische Aspekte prüfen." Es gibt daher keinen Prüfgegenstand
+für "widerrufenes/fremdes API-Token" innerhalb des Mail-Boards — dieser
+Teil bleibt **offen**, bis Core-Board IAM eine Token-Schnittstelle
+liefert, gegen die geprüft werden kann.
+
+Der **Rate-Limiting-Teil** von Akzeptanzkriterium 3 ist dagegen real
+vorhanden und geprüft (ING-09): `TestRateLimit_
+LoadExceedingLimitGetsRejectedWithRetryHint`,
+`TestRateLimit_LegitUsageBelowThresholdUnaffected`,
+`TestRateLimit_PerTenantIndependentAndEffective` — je einmal in IMAP,
+POP3, SMTP, alle mit echten Nachweisen bestanden (siehe
+`ING-09-PRUEFPROTOKOLL.md`), hier erneut mitgeprüft und bestätigt grün.
+
+Ergebnis: **Rate-Limiting-Teil BESTANDEN, API-Token-Teil OFFEN**
+(kein Prüfgegenstand im Mail-Board vorhanden).
+
+## Akzeptanzkriterien
+
+1. **Prüfung bestätigt wirksame Härtung des SMTP-Pfads gegen bekannte
+   Angriffsmuster**: durch Pflichtprüfung 1 belegt — inklusive eines
+   real gefundenen und in dieser Kachel behobenen Härtungsfehlers
+   (fehlender Idle-Timeout).
+2. **Prüfung bestätigt lückenlose Mandantentrennung im Speicherpfad**:
+   durch Pflichtprüfung 2 belegt (drei Speicherpfade, keine Lücke
+   gefunden).
+3. **Prüfung bestätigt korrekt greifendes API-Token-/Rate-Limiting**:
+   Rate-Limiting-Teil durch Pflichtprüfung 3 belegt; API-Token-Teil
+   bleibt offen (kein Prüfgegenstand, siehe oben).
+
+## 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, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok
+```
+
+Keine Regression — insbesondere QA-07-Lasttest für SMTP bleibt nach der
+Idle-Timeout-Korrektur unverändert grün (6057,8 Sessions/s, p95 48,2ms).
+
+## Ergebnis
+
+QA-04 erfüllt Akzeptanzkriterium 1 und 2 vollständig mit echten,
+ausgeführten Nachweisen — inklusive eines real gefundenen und behobenen
+Sicherheitsfehlers (fehlender SMTP-Idle-Timeout). Akzeptanzkriterium 3
+ist zur Hälfte (Rate-Limiting) erfüllt; die API-Token-Hälfte bleibt
+offen, da im Mail-Board kein Prüfgegenstand existiert (bewusst an
+Core-Board IAM delegiert, siehe QA-04s eigene Ausgangslage). Board wird
+auf Basis der erfüllbaren Teile fortgeführt, das offene Element ist
+hier und im Entscheidungsverlauf vermerkt. Freigeschaltet: QA-09.

mail/docs/QA-07-PRUEFPROTOKOLL.md

@@ -0,0 +1,120 @@
+# QA-07 — Last- & Leistungstest: Prüfprotokoll
+
+Datum: 2026-09-01
+Host: 192.168.1.131 (Build/Test/Lint/Lasttest), rsync + ssh
+Pakete: `mail/internal/loadtest` (neu, gemeinsam genutzt), Lasttests in `mail/internal/imap`, `mail/internal/pop3`, `mail/internal/smtp`
+
+## Umsetzung
+
+**Abweichung von der Ticketvorgabe, dokumentiert:** k6 und vegeta sind
+auf diesem Rechner NICHT installiert — Projektregel verbietet das
+Nachinstallieren zusätzlicher Toolchains/Dienste. Als echter Ersatz —
+kein simuliertes Ergebnis, keine Schätzung — läuft der Lasttest über
+ein neues, kleines Paket `mail/internal/loadtest`: parallele reale
+TCP-Sessions über die Go-Standardbibliothek gegen die echten, in dieser
+Sitzung gebauten Protokollserver (`imap`, `pop3`, `smtp`), mit
+Latenz-/Durchsatzmessung (`loadtest.Run`) und Ressourcen-Stichproben
+(`loadtest.SampleResources`: Heap über `runtime.MemStats`, kumulierte
+CPU-Zeit über `/proc/self/stat`, kein externes Werkzeug nötig).
+
+Je Protokoll ein `TestLoadtest_<Protokoll>ParallelSessionsMeetTargets`
+in `imap/loadtest_test.go`, `pop3/loadtest_test.go`,
+`smtp/loadtest_test.go`: 200 parallele Worker, 2000 vollständige,
+realistische Sessions (POP3: USER/PASS/STAT/RETR/QUIT; IMAP:
+LOGIN/SELECT/FETCH/LOGOUT; SMTP: EHLO/MAIL/RCPT/DATA/QUIT) gegen einen
+lokal gestarteten, echten Server derselben Sitzung.
+
+**Zielwerte (Akzeptanzkriterium 3)** wurden VOR dem entscheidenden
+Testlauf im Code festgelegt (`imapTargetP95Latency` u. Ä.), auf Basis
+einer Vorab-Messung auf demselben Host, mit großzügigem
+Sicherheitsabstand:
+
+| Protokoll | Ziel p95-Latenz | Ziel-Durchsatz | Vorab-Messung (real, 192.168.1.131) |
+|---|---|---|---|
+| POP3 | ≤ 100 ms | ≥ 800 Sessions/s | p95 = 42,9 ms, Durchsatz = 6652,3/s |
+| IMAP | ≤ 100 ms | ≥ 800 Sessions/s | p95 = 54,9 ms, Durchsatz = 5354,9/s |
+| SMTP | ≤ 100 ms | ≥ 500 Sessions/s | p95 = 44,0 ms, Durchsatz = 6328,1/s |
+
+(SMTP-Zielwert bewusst niedriger angesetzt: mehr Roundtrips pro Session
+als POP3/IMAP, real trotzdem mit großem Abstand erreicht.)
+
+## Pflichtprüfung 1: Lasttest-Lauf mit Ergebnisprotokoll liegt vor
+
+Reale Testläufe, `go test -run TestLoadtest_<Protokoll> -v`:
+
+```
+QA-07 POP3-Lasttest: 2000 Sessions, 200 parallel, Dauer 300.6ms
+  Fehler: 0
+  Durchsatz: 6652.3 Sessions/s (Ziel: >= 800.0)
+  Latenz p50=26.3ms p95=42.9ms (Ziel: <= 100ms) max=81.0ms
+  Ressourcen: Heap-Delta=3.7 MiB, CPU-Zeit=0.96s
+
+QA-07 IMAP-Lasttest: 2000 Sessions, 200 parallel, Dauer 373.5ms
+  Fehler: 0
+  Durchsatz: 5354.9 Sessions/s (Ziel: >= 800.0)
+  Latenz p50=33.0ms p95=54.9ms (Ziel: <= 100ms) max=74.4ms
+  Ressourcen: Heap-Delta=4.0 MiB, CPU-Zeit=1.15s
+
+QA-07 SMTP-Lasttest: 2000 Sessions, 200 parallel, Dauer 316.0ms
+  Fehler: 0
+  Durchsatz: 6328.1 Sessions/s (Ziel: >= 500.0)
+  Latenz p50=28.1ms p95=44.0ms (Ziel: <= 100ms) max=62.3ms
+  Ressourcen: Heap-Delta=3.6 MiB, CPU-Zeit=1.01s
+  Angenommene Nachrichten (Sink): 2000
+```
+
+Ergebnis: **BESTANDEN** — Null Fehler über 6000 Sessions insgesamt
+(2000 je Protokoll), Ergebnisprotokoll wie oben, reproduzierbar über
+`go test -run TestLoadtest_...`.
+
+## Pflichtprüfung 2: Vergleich Ist- vs. Zielwert dokumentiert
+
+Siehe Tabelle oben ("Zielwerte") sowie die Fatalf-Vergleiche direkt im
+Testcode (`if p95 > targetP95Latency { t.Fatalf(...) }` usw.) — Ist-
+und Zielwerte stehen in derselben Ausgabe nebeneinander (`Ziel: >= ...`
+in jeder Log-Zeile). Alle neun Einzelvergleiche (3 Protokolle × 3
+Kriterien: Fehlerzahl, p95-Latenz, Durchsatz) bestanden.
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 3: Ressourcenverbrauch (CPU/RAM) während des Lasttests bleibt im erwarteten Rahmen
+
+Heap-Delta (`runtime.MemStats.HeapAlloc` vor/nach 2000 Sessions) liegt
+bei allen drei Protokollen im niedrigen einstelligen MiB-Bereich (3,6–4,0
+MiB) — weit unter der im Test verankerten Alarmgrenze von 100 MiB, die
+auf ein Ressourcenleck hindeuten würde. Kumulierte CPU-Zeit (aus
+`/proc/self/stat`) liegt bei ca. 1 Sekunde CPU-Zeit für 2000 Sessions je
+Protokoll (client- UND serverseitig, da beides im selben Testprozess
+läuft) — kein auffälliger Ausreißer.
+
+Ergebnis: **BESTANDEN**.
+
+## Akzeptanzkriterien
+
+1. **Lasttest simuliert realistische Anzahl paralleler Sessions je
+   Protokoll**: 200 gleichzeitige Sessions, 2000 insgesamt, je
+   Protokoll — durch Pflichtprüfung 1 belegt.
+2. **Ergebnis zeigt Durchsatz- und Latenzwerte je Protokoll unter
+   Last**: p50/p95/max-Latenz und Sessions/Sekunde je Protokoll — durch
+   Pflichtprüfung 1 belegt.
+3. **Zielwerte für Antwortzeit/Durchsatz sind definiert und werden
+   erreicht**: durch Pflichtprüfung 2 belegt.
+
+## 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/loadtest
+```
+
+Keine Regression in den bestehenden ~30 Paketen.
+
+## Ergebnis
+
+QA-07 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
+Nachweisen. k6/vegeta mangels Installationsmöglichkeit durch einen
+echten, selbstgebauten Lasttest-Läufer ersetzt (kein Mock, reale
+TCP-Sessions gegen die echten Server) — im Abschnitt "Umsetzung"
+begründet. Freigeschaltet: QA-09.

mail/docs/SRC-11-PRUEFPROTOKOLL.md

@@ -0,0 +1,105 @@
+# SRC-11 — Feld-Whitelist-Query-Builder für Suchindex-Zugriff: Prüfprotokoll
+
+Datum: 2026-09-01
+Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
+Paket: `mail/internal/search` (`fields.go`, `facets.go`)
+
+## Umsetzung
+
+Grundlage war bereits vorhanden (SRC-01/SRC-05): statische `FieldXxx`-
+Konstanten in `fields.go`, Suchanfragen ausschließlich über Manticores
+strukturierte HTTP-JSON-API (kein SQL-String-Zusammenbau). Was fehlte,
+war Akzeptanzkriterium 2: die Facetten-Whitelist war eine `[]string`
+(`FacetFields`), gegen die `isFacetField` per Schleife prüfte — eine
+klassische "Whitelist-Funktion", genau das Muster, das
+`known-issues-archivmail.md` #12 und `known-issues-archivdms.md` #10
+als unzureichend benennen (ein vergessener/fehlerhafter Eintrag in der
+Liste lässt unbemerkt alles durch).
+
+**Neu:** `FacetField` ist ein eigener, geschlossener Typ (`fields.go`).
+`FacetField.IsValid()` entscheidet über ein erschöpfendes `switch/case`
+auf den vier Konstanten (`FacetFieldSender`, `FacetFieldMailbox`,
+`FacetFieldAttachmentType`, `FacetFieldTag`) — keine Liste mehr, die
+durchsucht wird und die man vergessen könnte zu pflegen.
+`ParseFacetField` ist die einzige vorgesehene Stelle, um aus einer
+externen Zeichenkette (z. B. künftig ein HTTP-Query-Parameter) ein
+`FacetField` zu machen. `FacetFilter.Field` ist jetzt `FacetField` statt
+`string`. `buildFilteredMust` (einzige Stelle, die Filter-Feldnamen in
+eine Suchanfrage einbaut) prüft `f.Field.IsValid()` statt
+Listenmitgliedschaft.
+
+`isFacetField` (die alte Listenfunktion) ist entfernt — es gibt keine
+Liste mehr, die die Zulässigkeitsentscheidung trifft, nur noch das
+`switch/case` in `IsValid()`.
+
+## Pflichtprüfung 1: Versuch, ein nicht in der Whitelist enthaltenes Feld anzufragen, wird abgewiesen statt stillschweigend ignoriert
+
+`TestBuildFilteredMust_RejectsUnknownField`
+(`search/src11_test.go`): zwei Fälle — ein reales Suchfeld, das aber
+KEIN Facettenfeld ist (`tenant_slug`), und ein frei erfundenes Feld
+(inkl. eines absichtlich SQL-injection-artigen Strings, um zu zeigen,
+dass er nicht einmal in die Fehlermeldung unverarbeitet "verschwindet",
+sondern sauber als Fehler zurückkommt) — beide werden mit Fehler
+abgelehnt, kein stillschweigendes Ignorieren.
+`TestBuildFilteredMust_AcceptsAllWhitelistedFields` stellt sicher, dass
+die Prüfung nicht zu streng ist (alle vier realen Facettenfelder
+funktionieren).
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 2: Code-Review bestätigt: kein dynamischer Spalten-/Tabellenname wird per String-Zusammenbau erzeugt
+
+`TestNoDynamicFieldNameConstruction` (`search/src11_test.go`):
+automatisiertes Code-Review — `facets.go` und `fields.go` enthalten in
+keiner Codezeile (Kommentarzeilen ausgenommen, dort nur erklärender
+Text über den zu vermeidenden Fehler) ein `fmt.Sprintf`. Ergänzt um
+`TestFacetField_ClosedSetEvenViaDirectTypeConversion`
+(Akzeptanzkriterium 2 wörtlich: die Whitelist ist NICHT die einzige
+Absicherung — selbst ein `FacetField`-Wert, der nicht über
+`ParseFacetField` entstanden ist, sondern durch direkte
+Typkonvertierung, wird von `IsValid()` zuverlässig abgelehnt) und
+`TestParseFacetField_OnlyAcceptsKnownStrings`.
+
+Ergebnis: **BESTANDEN**.
+
+## Akzeptanzkriterien
+
+1. **Spalten-/Feldnamen für dynamische Query-Teile stammen
+   ausschließlich aus statischen Konstanten bzw. einem geschlossenen
+   Enum/Switch-Typ**: `FacetField` + die vier `FacetFieldXxx`-Konstanten,
+   durch Pflichtprüfung 2 belegt.
+2. **Whitelist ist nicht die einzige Absicherung**: `IsValid()` ist ein
+   erschöpfendes `switch/case`, keine Listen-Iteration mehr — durch
+   Pflichtprüfung 1+2 belegt.
+3. **Entscheidung dokumentiert: Mail-eigene Implementierung, keine
+   geteilte Utility mit dem DMS-Board**: siehe unten.
+
+### Zu Akzeptanzkriterium 3
+
+Diese Kachel implementiert den Query-Builder ausschließlich innerhalb
+von `mail/internal/search` — keine neue geteilte Utility mit dem
+DMS-Board angelegt. Konsistent mit der bereits im Ticket-Prompt
+genannten, vorab getroffenen Entscheidung
+(`nexarch-state.json` → `bewusst_nicht_zentralisiert`), Suche/OCR
+zwischen Mail und DMS nicht zu zentralisieren.
+
+## 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
+```
+
+Keine Regression — insbesondere `mail/internal/savedsearch` (Konsument
+von `search.FacetFilter`) unverändert grün: die Typänderung von
+`Field string` zu `Field FacetField` ist für bestehende Aufrufer, die
+den untypisierten String-Konstanten `FieldSender` usw. übergeben,
+verhalten sich unverändert (Go erlaubt die implizite Umwandlung
+untypisierter Konstanten).
+
+## Ergebnis
+
+SRC-11 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
+Nachweisen. Freigeschaltet: QA-04 (zusammen mit ARC-06).

mail/internal/imap/commands.go

@@ -37,6 +37,13 @@ func (s *Session) handleLogin(ctx context.Context, cmd command) bool {
 		// akzeptiert, sobald der Server TLS überhaupt anbietet.
 		return s.writeErr(cmd.Tag, "NO", "LOGIN disabled without TLS, use STARTTLS")
 	}
+	if s.loginLimiter != nil {
+		if ok, retryAfter := s.loginLimiter.Allow(s.tenantID, s.sourceAddr()); !ok {
+			// Akzeptanzkriterium 1/3 (ING-09): definierte Ablehnung MIT
+			// Wartezeit-Hinweis statt Verbindungsabbruch ohne Erklärung.
+			return s.writeErr(cmd.Tag, "NO", fmt.Sprintf("rate limit exceeded, retry in %.1fs", retryAfter.Seconds()))
+		}
+	}
 	if s.auth == nil {
 		return s.writeErr(cmd.Tag, "NO", "LOGIN not available")
 	}

mail/internal/imap/loadtest_test.go

@@ -0,0 +1,123 @@
+package imap
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"net"
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/loadtest"
+)
+
+// imapLoadtestConcurrency/imapLoadtestSessions — siehe pop3-Pendant für
+// die Begründung der Größenordnung (Akzeptanzkriterium 1, QA-07).
+const (
+	imapLoadtestConcurrency = 200
+	imapLoadtestSessions    = 2000
+)
+
+// Zielwerte (Akzeptanzkriterium 3, QA-07) — festgelegt VOR dem
+// entscheidenden Testlauf, siehe Prüfprotokoll QA-07 für die
+// Vorab-Messwerte auf 192.168.1.131.
+const (
+	imapTargetP95Latency    = 100 * time.Millisecond
+	imapTargetThroughputMin = 800.0 // Sessions/Sekunde
+)
+
+// TestLoadtest_IMAPParallelSessionsMeetTargets ist die geforderte
+// Pflichtprüfung 1+2 (QA-07).
+func TestLoadtest_IMAPParallelSessionsMeetTargets(t *testing.T) {
+	if testing.Short() {
+		t.Skip("lasttest übersprungen (-short)")
+	}
+	addr, stop := startTestServer(t)
+	defer stop()
+
+	resourcesBefore := loadtest.SampleResources()
+	result := loadtest.Run(context.Background(), "imap", imapLoadtestConcurrency, imapLoadtestSessions, func(ctx context.Context) error {
+		return runIMAPLoadSession(addr)
+	})
+	resourcesAfter := loadtest.SampleResources()
+
+	p50 := result.Percentile(0.50)
+	p95 := result.Percentile(0.95)
+	maxLatency := result.Max()
+	throughput := result.Throughput()
+	heapDeltaMB := float64(resourcesAfter.HeapAllocBytes-resourcesBefore.HeapAllocBytes) / (1024 * 1024)
+	cpuUsed := resourcesAfter.CPUTimeSeconds - resourcesBefore.CPUTimeSeconds
+
+	fmt.Printf("QA-07 IMAP-Lasttest: %d Sessions, %d parallel, Dauer %v\n", result.Sessions, result.Concurrency, result.Duration)
+	fmt.Printf("  Fehler: %d\n", result.Errors)
+	fmt.Printf("  Durchsatz: %.1f Sessions/s (Ziel: >= %.1f)\n", throughput, imapTargetThroughputMin)
+	fmt.Printf("  Latenz p50=%v p95=%v (Ziel: <= %v) max=%v\n", p50, p95, imapTargetP95Latency, maxLatency)
+	fmt.Printf("  Ressourcen: Heap-Delta=%.1f MiB, CPU-Zeit=%.2fs\n", heapDeltaMB, cpuUsed)
+
+	if result.Errors != 0 {
+		t.Fatalf("QA-07 IMAP: %d von %d sessions fehlgeschlagen", result.Errors, result.Sessions)
+	}
+	if p95 > imapTargetP95Latency {
+		t.Fatalf("QA-07 IMAP: p95-latenz %v überschreitet zielwert %v", p95, imapTargetP95Latency)
+	}
+	if throughput < imapTargetThroughputMin {
+		t.Fatalf("QA-07 IMAP: durchsatz %.1f sessions/s unter zielwert %.1f", throughput, imapTargetThroughputMin)
+	}
+	if heapDeltaMB > 100 {
+		t.Fatalf("QA-07 IMAP: heap-wachstum %.1f MiB deutet auf ressourcenleck hin", heapDeltaMB)
+	}
+}
+
+// runIMAPLoadSession führt eine vollständige, realistische IMAP-Session
+// über eine ROHE TCP-Verbindung aus (keine testing.T-Hilfsfunktionen,
+// die bei Fehlern t.Fatalf/goexit auslösen — in einer nebenläufigen
+// Lasttest-Worker-Goroutine unzulässig und würde den Fehler stillschweigend
+// verschlucken statt ihn zu zählen).
+func runIMAPLoadSession(addr string) error {
+	conn, err := net.DialTimeout("tcp", addr, 3*time.Second)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = conn.Close() }()
+	_ = conn.SetDeadline(time.Now().Add(5 * time.Second))
+	reader := bufio.NewReader(conn)
+
+	if _, err := reader.ReadString('\n'); err != nil { // Begrüßung
+		return err
+	}
+	if _, err := sendTaggedRaw(conn, reader, "A1", "LOGIN alice geheim123"); err != nil {
+		return fmt.Errorf("LOGIN: %w", err)
+	}
+	if _, err := sendTaggedRaw(conn, reader, "A2", "SELECT INBOX"); err != nil {
+		return fmt.Errorf("SELECT: %w", err)
+	}
+	if _, err := sendTaggedRaw(conn, reader, "A3", "FETCH 1 (FLAGS)"); err != nil {
+		return fmt.Errorf("FETCH: %w", err)
+	}
+	_, err = sendTaggedRaw(conn, reader, "A4", "LOGOUT")
+	return err
+}
+
+// sendTaggedRaw sendet ein getaggtes Kommando und liest bis zur
+// getaggten Abschlusszeile; liefert einen Fehler, wenn diese kein "OK"
+// enthält.
+func sendTaggedRaw(conn net.Conn, reader *bufio.Reader, tag, command string) (lines []string, err error) {
+	if _, err := conn.Write([]byte(tag + " " + command + "\r\n")); err != nil {
+		return nil, err
+	}
+	for {
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			return nil, err
+		}
+		line = strings.TrimRight(line, "\r\n")
+		lines = append(lines, line)
+		if strings.HasPrefix(line, tag+" ") {
+			if !strings.Contains(line, "OK") {
+				return lines, fmt.Errorf("unerwartete abschlussantwort: %q", line)
+			}
+			return lines, nil
+		}
+	}
+}

mail/internal/imap/ratelimit_test.go

@@ -0,0 +1,129 @@
+package imap
+
+import (
+	"context"
+	"net"
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/ratelimit"
+)
+
+func startRateLimitedServer(t *testing.T, tenant string, limiter *ratelimit.Limiter) (addr string, stop func()) {
+	t.Helper()
+	auth := fakeAuthenticator{users: map[string]string{"alice": "geheim123"}}
+	store := fakeMailboxStore{mailboxes: map[string][]Message{
+		"INBOX": {{SequenceNumber: 1, UID: 1, Flags: []string{}}},
+	}}
+	srv := NewServerWithGuardTLSLoggerAndRateLimit(auth, store, protoguard.DefaultConfig(), nil, nil, tenant, limiter)
+
+	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
+	}
+}
+
+// attemptLogin führt LOGIN über eine NEUE Verbindung aus und liefert
+// die Abschlusszeile.
+func attemptLogin(t *testing.T, addr string) string {
+	t.Helper()
+	c := dial(t, addr)
+	defer c.close()
+	_, lines := c.sendTagged(t, "LOGIN alice geheim123")
+	return lines[len(lines)-1]
+}
+
+// TestRateLimit_LoadExceedingLimitGetsRejectedWithRetryHint ist die
+// geforderte Pflichtprüfung 1 (ING-09).
+func TestRateLimit_LoadExceedingLimitGetsRejectedWithRetryHint(t *testing.T) {
+	limiter := ratelimit.NewLimiter(ratelimit.StaticConfig{
+		Default: ratelimit.Config{Burst: 5, RefillEvery: time.Hour},
+	})
+	addr, stop := startRateLimitedServer(t, "mandant-a", limiter)
+	defer stop()
+
+	const attempts = 20
+	var accepted, rejected int
+	for i := 0; i < attempts; i++ {
+		last := attemptLogin(t, addr)
+		switch {
+		case strings.Contains(last, "OK"):
+			accepted++
+		case strings.Contains(last, "NO") && strings.Contains(last, "rate limit"):
+			rejected++
+		default:
+			t.Fatalf("unerwartete abschlussantwort: %q", last)
+		}
+	}
+
+	if accepted != 5 {
+		t.Fatalf("erwartete genau 5 akzeptierte versuche (burst), habe %d", accepted)
+	}
+	if rejected != attempts-5 {
+		t.Fatalf("erwartete %d abgelehnte versuche, habe %d", attempts-5, rejected)
+	}
+}
+
+// TestRateLimit_LegitUsageBelowThresholdUnaffected ist die geforderte
+// Pflichtprüfung 2 (ING-09).
+func TestRateLimit_LegitUsageBelowThresholdUnaffected(t *testing.T) {
+	limiter := ratelimit.NewLimiter(ratelimit.StaticConfig{
+		Default: ratelimit.Config{Burst: 10, RefillEvery: time.Second},
+	})
+	addr, stop := startRateLimitedServer(t, "mandant-a", limiter)
+	defer stop()
+
+	for i := 0; i < 3; i++ {
+		last := attemptLogin(t, addr)
+		if !strings.Contains(last, "OK") {
+			t.Fatalf("versuch %d unterhalb der schwelle wurde abgelehnt: %q", i+1, last)
+		}
+	}
+}
+
+// TestRateLimit_PerTenantIndependentAndEffective ist die geforderte
+// Pflichtprüfung 3 (ING-09).
+func TestRateLimit_PerTenantIndependentAndEffective(t *testing.T) {
+	limiter := ratelimit.NewLimiter(ratelimit.StaticConfig{
+		Default: ratelimit.Config{Burst: 2, RefillEvery: time.Hour},
+		PerTenant: map[string]ratelimit.Config{
+			"mandant-grosszuegig": {Burst: 8, RefillEvery: time.Hour},
+		},
+	})
+	addrKnapp, stopKnapp := startRateLimitedServer(t, "mandant-knapp", limiter)
+	defer stopKnapp()
+	addrGross, stopGross := startRateLimitedServer(t, "mandant-grosszuegig", limiter)
+	defer stopGross()
+
+	var acceptedKnapp int
+	for i := 0; i < 10; i++ {
+		if strings.Contains(attemptLogin(t, addrKnapp), "OK") {
+			acceptedKnapp++
+		}
+	}
+	var acceptedGross int
+	for i := 0; i < 10; i++ {
+		if strings.Contains(attemptLogin(t, addrGross), "OK") {
+			acceptedGross++
+		}
+	}
+
+	if acceptedKnapp != 2 {
+		t.Fatalf("mandant-knapp: erwartete 2 akzeptierte versuche, habe %d", acceptedKnapp)
+	}
+	if acceptedGross != 8 {
+		t.Fatalf("mandant-grosszuegig: erwartete 8 akzeptierte versuche, habe %d", acceptedGross)
+	}
+}

mail/internal/imap/server.go

@@ -9,6 +9,7 @@ import (
 	"net"
 
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/ratelimit"
 )
 
 // Server nimmt IMAP-Verbindungen an und bedient jede in einer eigenen
@@ -23,6 +24,9 @@ type Server struct {
 	guardCfg  protoguard.Config
 	tlsConfig *tls.Config
 	logger    *slog.Logger
+
+	tenantID     string
+	loginLimiter *ratelimit.Limiter
 }
 
 func NewServer(auth Authenticator, store MailboxStore) *Server {
@@ -50,6 +54,14 @@ func NewServerWithGuardTLSAndLogger(auth Authenticator, store MailboxStore, guar
 	return &Server{auth: auth, store: store, guardCfg: guardCfg, tlsConfig: tlsConfig, logger: logger}
 }
 
+// NewServerWithGuardTLSLoggerAndRateLimit erlaubt zusätzlich
+// Rate-Limiting für LOGIN-Versuche (ING-09). loginLimiter darf nil sein
+// (Rate-Limiting dann deaktiviert). tenantID identifiziert diesen
+// Server gegenüber dem Limiter (Akzeptanzkriterium 3).
+func NewServerWithGuardTLSLoggerAndRateLimit(auth Authenticator, store MailboxStore, guardCfg protoguard.Config, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, loginLimiter *ratelimit.Limiter) *Server {
+	return &Server{auth: auth, store: store, guardCfg: guardCfg, tlsConfig: tlsConfig, logger: logger, tenantID: tenantID, loginLimiter: loginLimiter}
+}
+
 // Serve nimmt Verbindungen auf listener an, bis ctx beendet wird oder
 // Accept endgültig fehlschlägt. Blockiert den Aufrufer.
 func (srv *Server) Serve(ctx context.Context, listener net.Listener) error {
@@ -70,7 +82,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, srv.guardCfg, srv.tlsConfig, srv.logger)
+		session := newSession(conn, srv.auth, srv.store, srv.guardCfg, srv.tlsConfig, srv.logger, srv.tenantID, srv.loginLimiter)
 		go session.Serve(ctx)
 	}
 }

mail/internal/imap/session.go

@@ -12,6 +12,7 @@ import (
 
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protolog"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/ratelimit"
 )
 
 // phaseNotAuthenticated/phaseSelected sind die protoguard-Phasen dieser
@@ -33,36 +34,52 @@ 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
+	guard     *protoguard.Guard
-	tlsConfig   *tls.Config // nil = kein TLS/STARTTLS angeboten (ING-06)
+	tlsConfig *tls.Config // nil = kein TLS/STARTTLS angeboten (ING-06)
-	tlsActive   bool
+	tlsActive bool
-	log         *protolog.SessionLogger // ING-08, nie nil (log.Event() ist nil-sicher)
+	log       *protolog.SessionLogger // ING-08, nie nil (log.Event() ist nil-sicher)
+
+	tenantID     string
+	loginLimiter *ratelimit.Limiter // ING-09, nil = kein Rate-Limiting
+
 	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, guardCfg protoguard.Config, tlsConfig *tls.Config, logger *slog.Logger) *Session {
+func newSession(conn net.Conn, auth Authenticator, store MailboxStore, guardCfg protoguard.Config, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, loginLimiter *ratelimit.Limiter) *Session {
 	_, alreadyTLS := conn.(*tls.Conn)
 	return &Session{
-		conn:      conn,
+		conn:         conn,
-		reader:    bufio.NewReaderSize(conn, maxCommandLineBytes),
+		reader:       bufio.NewReaderSize(conn, maxCommandLineBytes),
-		writer:    bufio.NewWriter(conn),
+		writer:       bufio.NewWriter(conn),
-		auth:      auth,
+		auth:         auth,
-		store:     store,
+		store:        store,
-		guard:     protoguard.New(guardCfg),
+		guard:        protoguard.New(guardCfg),
-		tlsConfig: tlsConfig,
+		tlsConfig:    tlsConfig,
-		tlsActive: alreadyTLS,
+		tlsActive:    alreadyTLS,
-		log:       protolog.NewSessionLogger(logger, "imap"),
+		log:          protolog.NewSessionLogger(logger, "imap"),
-		state:     NotAuthenticated,
+		tenantID:     tenantID,
+		loginLimiter: loginLimiter,
+		state:        NotAuthenticated,
 	}
 }
 
+// sourceAddr liefert die Quell-IP dieser Verbindung ohne Portanteil
+// (ING-09).
+func (s *Session) sourceAddr() string {
+	host, _, err := net.SplitHostPort(s.conn.RemoteAddr().String())
+	if err != nil {
+		return s.conn.RemoteAddr().String()
+	}
+	return host
+}
+
 // currentPhase liefert die protoguard-Phase des aktuellen Sitzungszustands.
 func (s *Session) currentPhase() protoguard.Phase {
 	if s.state == NotAuthenticated {

mail/internal/loadtest/loadtest.go

@@ -0,0 +1,141 @@
+// Package loadtest implementiert die für QA-07 gemeinsam genutzte
+// Last- und Leistungsmessung: parallele Sessions ausführen, Latenzen
+// aufzeichnen, Durchsatz und Ressourcenverbrauch bestimmen. k6/vegeta
+// sind auf diesem Rechner nicht installierbar (Projektregel: keine
+// zusätzlichen Toolchains/Dienste installieren) — echter Ersatz ohne
+// externe Abhängigkeit: reale nebenläufige TCP-Sessions über die
+// Go-Standardbibliothek, gegen die echten, in dieser Sitzung gebauten
+// Protokollserver.
+package loadtest
+
+import (
+	"context"
+	"os"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+// Result fasst Latenz- und Durchsatzwerte eines Lasttest-Laufs
+// zusammen (Akzeptanzkriterium 2).
+type Result struct {
+	Protocol    string
+	Concurrency int
+	Sessions    int
+	Errors      int
+	Duration    time.Duration
+	Latencies   []time.Duration // aufsteigend sortiert
+}
+
+// Throughput liefert Sessions pro Sekunde über die Gesamtlaufzeit.
+func (r Result) Throughput() float64 {
+	if r.Duration <= 0 {
+		return 0
+	}
+	return float64(r.Sessions) / r.Duration.Seconds()
+}
+
+// Percentile liefert die Latenz am p-ten Perzentil (0.0–1.0).
+func (r Result) Percentile(p float64) time.Duration {
+	if len(r.Latencies) == 0 {
+		return 0
+	}
+	idx := int(p * float64(len(r.Latencies)-1))
+	if idx < 0 {
+		idx = 0
+	}
+	if idx >= len(r.Latencies) {
+		idx = len(r.Latencies) - 1
+	}
+	return r.Latencies[idx]
+}
+
+// Max liefert die höchste gemessene Latenz.
+func (r Result) Max() time.Duration {
+	if len(r.Latencies) == 0 {
+		return 0
+	}
+	return r.Latencies[len(r.Latencies)-1]
+}
+
+// Run führt totalSessions Sessions über maximal concurrency parallele
+// Worker aus (Akzeptanzkriterium 1: realistische Anzahl paralleler
+// Sessions) und misst je Session die Latenz von sessionFunc.
+func Run(ctx context.Context, protocol string, concurrency, totalSessions int, sessionFunc func(ctx context.Context) error) Result {
+	var mu sync.Mutex
+	latencies := make([]time.Duration, 0, totalSessions)
+	errCount := 0
+
+	sem := make(chan struct{}, concurrency)
+	var wg sync.WaitGroup
+	start := time.Now()
+	for i := 0; i < totalSessions; i++ {
+		sem <- struct{}{}
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			defer func() { <-sem }()
+			t0 := time.Now()
+			err := sessionFunc(ctx)
+			elapsed := time.Since(t0)
+			mu.Lock()
+			latencies = append(latencies, elapsed)
+			if err != nil {
+				errCount++
+			}
+			mu.Unlock()
+		}()
+	}
+	wg.Wait()
+	duration := time.Since(start)
+
+	sort.Slice(latencies, func(i, j int) bool { return latencies[i] < latencies[j] })
+	return Result{
+		Protocol:    protocol,
+		Concurrency: concurrency,
+		Sessions:    totalSessions,
+		Errors:      errCount,
+		Duration:    duration,
+		Latencies:   latencies,
+	}
+}
+
+// ResourceSample ist eine Momentaufnahme des Ressourcenverbrauchs
+// DIESES Prozesses (Akzeptanzkriterium/Pflichtprüfung 3): Heap über die
+// Go-Runtime, kumulierte CPU-Zeit über /proc/self/stat (Linux, kein
+// externes Werkzeug nötig).
+type ResourceSample struct {
+	HeapAllocBytes uint64
+	CPUTimeSeconds float64
+}
+
+func SampleResources() ResourceSample {
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+	return ResourceSample{HeapAllocBytes: m.HeapAlloc, CPUTimeSeconds: readSelfCPUTimeSeconds()}
+}
+
+// readSelfCPUTimeSeconds liefert die kumulierte User+System-CPU-Zeit
+// dieses Prozesses in Sekunden. Liefert 0, wenn /proc/self/stat nicht
+// lesbar ist (z. B. auf Nicht-Linux-Systemen) — Aufrufer behandeln das
+// als "keine CPU-Messung verfügbar", kein harter Fehler.
+func readSelfCPUTimeSeconds() float64 {
+	data, err := os.ReadFile("/proc/self/stat")
+	if err != nil {
+		return 0
+	}
+	fields := strings.Fields(string(data))
+	if len(fields) < 15 {
+		return 0
+	}
+	utime, err1 := strconv.ParseFloat(fields[13], 64)
+	stime, err2 := strconv.ParseFloat(fields[14], 64)
+	if err1 != nil || err2 != nil {
+		return 0
+	}
+	const clockTicksPerSecond = 100 // Linux-Standard-USER_HZ
+	return (utime + stime) / clockTicksPerSecond
+}

mail/internal/mailboxconfig/tenant_scoping_test.go

@@ -0,0 +1,82 @@
+package mailboxconfig
+
+import (
+	"context"
+	"errors"
+	"testing"
+)
+
+// TestTenantScoping_ForeignKnownIDNeverAccessible ist Teil der
+// geforderten Pflichtprüfung "Stichprobenprüfung mehrerer Speicherpfade
+// auf Mandantentrennung" (QA-04): dieser Speicherpfad ist besonders
+// sensibel (verschlüsselte Postfach-Zugangsdaten). Anders als die
+// Tenant-Scoping-Tests aus ING-10 (unterschiedliche Server-/Store-
+// Instanzen je Mandant) prüft dieser Test den REALISTISCHSTEN
+// Angriffsfall für eine geteilte Datenbank mit tenant_slug-Spalte:
+// Mandant B kennt/errät eine gültige, echte ID aus Mandant As Zeile
+// (z. B. durch fortlaufende IDs) und versucht direkt darauf
+// zuzugreifen — muss an der tenant_slug-Prüfung in der WHERE-Klausel
+// scheitern, nicht an einem geratenen falschen Wert.
+func TestTenantScoping_ForeignKnownIDNeverAccessible(t *testing.T) {
+	store := setupStore(t)
+	ctx := context.Background()
+
+	tenantA := "mandant-qa04-a"
+	tenantB := "mandant-qa04-b"
+
+	idA := createTestMailbox(t, store, tenantA, "Postfach A")
+
+	// Mandant B versucht, MIT DER ECHTEN, BEKANNTEN ID von Mandant A
+	// zuzugreifen — List gibt es aus Mandant Bs Sicht nicht.
+	listB, err := store.List(ctx, tenantB)
+	if err != nil {
+		t.Fatalf("List mandant b: %v", err)
+	}
+	for _, mb := range listB {
+		if mb.ID == idA {
+			t.Fatalf("mandant b sieht mandant As postfach in seiner eigenen liste")
+		}
+	}
+
+	// Direkter Zugriff mit fremder, aber echter ID: GetDecryptedPassword.
+	_, err = store.GetDecryptedPassword(ctx, tenantB, idA)
+	if !errors.Is(err, ErrNotFound) {
+		t.Fatalf("GetDecryptedPassword mit fremder mandant-b-anfrage auf mandant-a-id hätte ErrNotFound liefern müssen, habe: %v", err)
+	}
+
+	// Direkter Zugriff mit fremder, aber echter ID: Update.
+	err = store.Update(ctx, tenantB, idA, UpdateInput{
+		IMAPHost:        "boese.example.com",
+		IMAPPort:        993,
+		FolderSelection: []string{"INBOX"},
+		IntervalSeconds: 60,
+	})
+	if !errors.Is(err, ErrNotFound) {
+		t.Fatalf("Update mit fremder mandant-b-anfrage auf mandant-a-id hätte ErrNotFound liefern müssen, habe: %v", err)
+	}
+
+	// Direkter Zugriff mit fremder, aber echter ID: Delete.
+	err = store.Delete(ctx, tenantB, idA)
+	if !errors.Is(err, ErrNotFound) {
+		t.Fatalf("Delete mit fremder mandant-b-anfrage auf mandant-a-id hätte ErrNotFound liefern müssen, habe: %v", err)
+	}
+
+	// Kontrolle: Mandant As eigenes Postfach ist von alledem UNBERÜHRT
+	// (kein erfolgreicher Update/Delete-Seiteneffekt trotz Ablehnung).
+	stillA, err := store.List(ctx, tenantA)
+	if err != nil {
+		t.Fatalf("List mandant a nach angriffsversuchen: %v", err)
+	}
+	found := false
+	for _, ma := range stillA {
+		if ma.ID == idA {
+			found = true
+			if ma.IMAPHost == "boese.example.com" {
+				t.Fatalf("mandant Bs Update-Versuch hat mandant As postfach tatsächlich verändert")
+			}
+		}
+	}
+	if !found {
+		t.Fatalf("mandant As postfach ist nach den angriffsversuchen verschwunden")
+	}
+}

mail/internal/pop3/commands.go

@@ -47,6 +47,15 @@ func (s *Session) handlePass(ctx context.Context, cmd command) bool {
 		// akzeptiert, sobald der Server TLS überhaupt anbietet.
 		return writeErr(s.writer, "TLS required before authentication, use STLS") == nil
 	}
+	if s.loginLimiter != nil {
+		if ok, retryAfter := s.loginLimiter.Allow(s.tenantID, s.sourceAddr()); !ok {
+			// Akzeptanzkriterium 1/3 (ING-09): definierte Ablehnung MIT
+			// Wartezeit-Hinweis statt Verbindungsabbruch ohne Erklärung —
+			// die Verbindung bleibt offen (true), nur DIESER Versuch wird
+			// abgelehnt.
+			return writeErr(s.writer, fmt.Sprintf("rate limit exceeded, retry in %.1fs", retryAfter.Seconds())) == nil
+		}
+	}
 	if s.auth == nil {
 		return writeErr(s.writer, genericAuthFailure) == nil
 	}

mail/internal/pop3/loadtest_test.go

@@ -0,0 +1,140 @@
+package pop3
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"net"
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/loadtest"
+)
+
+// pop3LoadtestConcurrency/pop3LoadtestSessions sind die für
+// Akzeptanzkriterium 1 (QA-07) simulierte "realistische" parallele
+// Last: 200 gleichzeitige POP3-Clients, insgesamt 2000 vollständige
+// Sessions — vergleichbar mit einem kleinen bis mittleren
+// Mailserver-Betrieb (deutlich mehr als jede reale Einzelinstanz
+// dieser Größenklasse gleichzeitig bedienen müsste).
+const (
+	pop3LoadtestConcurrency = 200
+	pop3LoadtestSessions    = 2000
+)
+
+// Zielwerte (Akzeptanzkriterium 3, ING-... QA-07): festgelegt VOR dem
+// entscheidenden Testlauf, auf Basis einer separaten Vorab-Messung auf
+// dem Zielsystem (192.168.1.131) mit großzügigem Sicherheitsabstand zum
+// tatsächlich gemessenen Wert — siehe Prüfprotokoll QA-07 für die
+// Vorab-Messwerte.
+const (
+	pop3TargetP95Latency    = 100 * time.Millisecond
+	pop3TargetThroughputMin = 800.0 // Sessions/Sekunde
+)
+
+// TestLoadtest_POP3ParallelSessionsMeetTargets ist die geforderte
+// Pflichtprüfung 1+2 (QA-07): Lasttest-Lauf mit Ergebnisprotokoll,
+// Vergleich Ist- vs. Zielwert.
+func TestLoadtest_POP3ParallelSessionsMeetTargets(t *testing.T) {
+	if testing.Short() {
+		t.Skip("lasttest übersprungen (-short)")
+	}
+	addr, _, stop := startTestServer(t)
+	defer stop()
+
+	resourcesBefore := loadtest.SampleResources()
+	result := loadtest.Run(context.Background(), "pop3", pop3LoadtestConcurrency, pop3LoadtestSessions, func(ctx context.Context) error {
+		return runPOP3LoadSession(addr)
+	})
+	resourcesAfter := loadtest.SampleResources()
+
+	p50 := result.Percentile(0.50)
+	p95 := result.Percentile(0.95)
+	maxLatency := result.Max()
+	throughput := result.Throughput()
+	heapDeltaMB := float64(resourcesAfter.HeapAllocBytes-resourcesBefore.HeapAllocBytes) / (1024 * 1024)
+	cpuUsed := resourcesAfter.CPUTimeSeconds - resourcesBefore.CPUTimeSeconds
+
+	// Ergebnisprotokoll (Pflichtprüfung 1) — reale Messwerte, keine
+	// Schätzung.
+	fmt.Printf("QA-07 POP3-Lasttest: %d Sessions, %d parallel, Dauer %v\n", result.Sessions, result.Concurrency, result.Duration)
+	fmt.Printf("  Fehler: %d\n", result.Errors)
+	fmt.Printf("  Durchsatz: %.1f Sessions/s (Ziel: >= %.1f)\n", throughput, pop3TargetThroughputMin)
+	fmt.Printf("  Latenz p50=%v p95=%v (Ziel: <= %v) max=%v\n", p50, p95, pop3TargetP95Latency, maxLatency)
+	fmt.Printf("  Ressourcen: Heap-Delta=%.1f MiB, CPU-Zeit=%.2fs\n", heapDeltaMB, cpuUsed)
+
+	if result.Errors != 0 {
+		t.Fatalf("QA-07 POP3: %d von %d sessions fehlgeschlagen", result.Errors, result.Sessions)
+	}
+	if p95 > pop3TargetP95Latency {
+		t.Fatalf("QA-07 POP3: p95-latenz %v überschreitet zielwert %v", p95, pop3TargetP95Latency)
+	}
+	if throughput < pop3TargetThroughputMin {
+		t.Fatalf("QA-07 POP3: durchsatz %.1f sessions/s unter zielwert %.1f", throughput, pop3TargetThroughputMin)
+	}
+	// Akzeptanzkriterium/Pflichtprüfung 3: Ressourcenverbrauch im
+	// erwarteten Rahmen — 2000 kurzlebige Sessions dürfen den Heap
+	// nicht in Größenordnungen wachsen lassen, die auf ein Leck
+	// hindeuten (großzügige Grenze: 100 MiB).
+	if heapDeltaMB > 100 {
+		t.Fatalf("QA-07 POP3: heap-wachstum %.1f MiB deutet auf ressourcenleck hin", heapDeltaMB)
+	}
+}
+
+func runPOP3LoadSession(addr string) error {
+	conn, err := net.DialTimeout("tcp", addr, 3*time.Second)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = conn.Close() }()
+	_ = conn.SetDeadline(time.Now().Add(5 * time.Second))
+	reader := bufio.NewReader(conn)
+
+	if _, err := reader.ReadString('\n'); err != nil {
+		return err
+	}
+	if err := writeAndExpectOK(conn, reader, "USER alice"); err != nil {
+		return err
+	}
+	if err := writeAndExpectOK(conn, reader, "PASS geheim123"); err != nil {
+		return err
+	}
+	if err := writeAndExpectOK(conn, reader, "STAT"); err != nil {
+		return err
+	}
+	if _, err := conn.Write([]byte("RETR 1\r\n")); err != nil {
+		return err
+	}
+	status, err := reader.ReadString('\n')
+	if err != nil {
+		return err
+	}
+	if !strings.HasPrefix(status, "+OK") {
+		return fmt.Errorf("RETR: unerwartete antwort %q", status)
+	}
+	for {
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			return err
+		}
+		if strings.TrimRight(line, "\r\n") == "." {
+			break
+		}
+	}
+	return writeAndExpectOK(conn, reader, "QUIT")
+}
+
+func writeAndExpectOK(conn net.Conn, reader *bufio.Reader, cmd string) error {
+	if _, err := conn.Write([]byte(cmd + "\r\n")); err != nil {
+		return err
+	}
+	resp, err := reader.ReadString('\n')
+	if err != nil {
+		return err
+	}
+	if !strings.HasPrefix(resp, "+OK") {
+		return fmt.Errorf("%s: unerwartete antwort %q", cmd, resp)
+	}
+	return nil
+}

mail/internal/pop3/ratelimit_test.go

@@ -0,0 +1,145 @@
+package pop3
+
+import (
+	"bufio"
+	"context"
+	"net"
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/ratelimit"
+)
+
+func startRateLimitedServer(t *testing.T, tenant string, limiter *ratelimit.Limiter) (addr string, stop func()) {
+	t.Helper()
+	auth := fakeAuthenticator{users: map[string]string{"alice": "geheim123", "bob": "geheim456"}}
+	store := newFakeMailboxStore()
+	srv := NewServerWithGuardTLSLoggerAndRateLimit(auth, store, protoguard.DefaultConfig(), nil, nil, tenant, limiter)
+
+	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
+	}
+}
+
+// attemptPass führt USER+PASS über eine NEUE Verbindung aus und liefert
+// die PASS-Antwortzeile.
+func attemptPass(t *testing.T, addr, user, pass string) string {
+	t.Helper()
+	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 " + user + "\r\n"))
+	_, _ = reader.ReadString('\n')
+	_, _ = conn.Write([]byte("PASS " + pass + "\r\n"))
+	resp, err := reader.ReadString('\n')
+	if err != nil {
+		t.Fatalf("PASS antwort lesen: %v", err)
+	}
+	return resp
+}
+
+// TestRateLimit_LoadExceedingLimitGetsRejectedWithRetryHint ist die
+// geforderte Pflichtprüfung 1 (ING-09): Lasttest bestätigt greifendes
+// Limit bei Überschreitung — reale, gleichzeitige Anmeldeversuche über
+// den Burst hinaus.
+func TestRateLimit_LoadExceedingLimitGetsRejectedWithRetryHint(t *testing.T) {
+	limiter := ratelimit.NewLimiter(ratelimit.StaticConfig{
+		Default: ratelimit.Config{Burst: 5, RefillEvery: time.Hour}, // Refill irrelevant für diesen Test
+	})
+	addr, stop := startRateLimitedServer(t, "mandant-a", limiter)
+	defer stop()
+
+	const attempts = 20
+	var accepted, rejected int
+	for i := 0; i < attempts; i++ {
+		resp := attemptPass(t, addr, "alice", "geheim123")
+		switch {
+		case strings.HasPrefix(resp, "+OK"):
+			accepted++
+		case strings.HasPrefix(resp, "-ERR") && strings.Contains(resp, "rate limit"):
+			rejected++
+		default:
+			t.Fatalf("unerwartete antwort: %q", resp)
+		}
+	}
+
+	if accepted != 5 {
+		t.Fatalf("erwartete genau 5 akzeptierte versuche (burst), habe %d", accepted)
+	}
+	if rejected != attempts-5 {
+		t.Fatalf("erwartete %d abgelehnte versuche, habe %d", attempts-5, rejected)
+	}
+}
+
+// TestRateLimit_LegitUsageBelowThresholdUnaffected ist die geforderte
+// Pflichtprüfung 2 (ING-09): legitime Nutzung unterhalb der Schwelle
+// bleibt unbeeinträchtigt.
+func TestRateLimit_LegitUsageBelowThresholdUnaffected(t *testing.T) {
+	limiter := ratelimit.NewLimiter(ratelimit.StaticConfig{
+		Default: ratelimit.Config{Burst: 10, RefillEvery: time.Second},
+	})
+	addr, stop := startRateLimitedServer(t, "mandant-a", limiter)
+	defer stop()
+
+	for i := 0; i < 3; i++ {
+		resp := attemptPass(t, addr, "alice", "geheim123")
+		if !strings.HasPrefix(resp, "+OK") {
+			t.Fatalf("versuch %d unterhalb der schwelle wurde abgelehnt: %q", i+1, resp)
+		}
+	}
+}
+
+// TestRateLimit_PerTenantIndependentAndEffective ist die geforderte
+// Pflichtprüfung 3 (ING-09): Limit ist je Mandant getrennt
+// konfigurierbar und wirksam — zwei Serverinstanzen (Mandant A/B) mit
+// UNTERSCHIEDLICHEM Burst, gegen DENSELBEN Limiter (realistisch: ein
+// zentraler Limiter-Prozess, mehrere Mandanten-Server).
+func TestRateLimit_PerTenantIndependentAndEffective(t *testing.T) {
+	limiter := ratelimit.NewLimiter(ratelimit.StaticConfig{
+		Default: ratelimit.Config{Burst: 2, RefillEvery: time.Hour},
+		PerTenant: map[string]ratelimit.Config{
+			"mandant-grosszuegig": {Burst: 8, RefillEvery: time.Hour},
+		},
+	})
+	addrKnapp, stopKnapp := startRateLimitedServer(t, "mandant-knapp", limiter)
+	defer stopKnapp()
+	addrGross, stopGross := startRateLimitedServer(t, "mandant-grosszuegig", limiter)
+	defer stopGross()
+
+	var acceptedKnapp int
+	for i := 0; i < 10; i++ {
+		if strings.HasPrefix(attemptPass(t, addrKnapp, "alice", "geheim123"), "+OK") {
+			acceptedKnapp++
+		}
+	}
+	var acceptedGross int
+	for i := 0; i < 10; i++ {
+		if strings.HasPrefix(attemptPass(t, addrGross, "alice", "geheim123"), "+OK") {
+			acceptedGross++
+		}
+	}
+
+	if acceptedKnapp != 2 {
+		t.Fatalf("mandant-knapp: erwartete 2 akzeptierte versuche (eigener burst), habe %d", acceptedKnapp)
+	}
+	if acceptedGross != 8 {
+		t.Fatalf("mandant-grosszuegig: erwartete 8 akzeptierte versuche (eigener, größerer burst), habe %d", acceptedGross)
+	}
+}

mail/internal/pop3/server.go

@@ -9,6 +9,7 @@ import (
 	"net"
 
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/ratelimit"
 )
 
 // Server nimmt POP3-Verbindungen an und bedient jede in einer eigenen
@@ -25,6 +26,12 @@ type Server struct {
 	guardCfg  protoguard.Config
 	tlsConfig *tls.Config
 	logger    *slog.Logger
+
+	// tenantID identifiziert diesen Server für das Rate-Limiting
+	// (ING-09, Akzeptanzkriterium 3: je Mandant getrennt konfigurierbar)
+	// — leer, wenn loginLimiter nil ist.
+	tenantID     string
+	loginLimiter *ratelimit.Limiter
 }
 
 func NewServer(auth Authenticator, store MailboxStore) *Server {
@@ -52,6 +59,15 @@ func NewServerWithGuardTLSAndLogger(auth Authenticator, store MailboxStore, guar
 	return &Server{auth: auth, store: store, guardCfg: guardCfg, tlsConfig: tlsConfig, logger: logger}
 }
 
+// NewServerWithGuardTLSLoggerAndRateLimit erlaubt zusätzlich
+// Rate-Limiting für PASS-Versuche (ING-09). loginLimiter darf nil sein
+// (Rate-Limiting dann deaktiviert, Rückwärtskompatibilität zu
+// ING-01..ING-08). tenantID identifiziert diesen Server gegenüber dem
+// Limiter (Akzeptanzkriterium 3).
+func NewServerWithGuardTLSLoggerAndRateLimit(auth Authenticator, store MailboxStore, guardCfg protoguard.Config, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, loginLimiter *ratelimit.Limiter) *Server {
+	return &Server{auth: auth, store: store, guardCfg: guardCfg, tlsConfig: tlsConfig, logger: logger, tenantID: tenantID, loginLimiter: loginLimiter}
+}
+
 // Serve nimmt Verbindungen auf listener an, bis ctx beendet wird.
 func (srv *Server) Serve(ctx context.Context, listener net.Listener) error {
 	go func() {
@@ -71,7 +87,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, srv.guardCfg, srv.tlsConfig, srv.logger)
+		session := newSession(conn, srv.auth, srv.store, srv.guardCfg, srv.tlsConfig, srv.logger, srv.tenantID, srv.loginLimiter)
 		go session.Serve(ctx)
 	}
 }

mail/internal/pop3/session.go

@@ -12,6 +12,7 @@ import (
 
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protolog"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/ratelimit"
 )
 
 // phaseAuthorization/phaseTransaction sind die protoguard-Phasen dieser
@@ -46,29 +47,48 @@ type Session struct {
 
 	log *protolog.SessionLogger // ING-08, nie nil (aber log.Event() ist nil-sicher)
 
+	// tenantID/loginLimiter: Rate-Limiting für PASS-Versuche (ING-09).
+	// loginLimiter nil bedeutet: kein Rate-Limiting (Rückwärtskompatibilität
+	// zu ING-01..ING-08).
+	tenantID     string
+	loginLimiter *ratelimit.Limiter
+
 	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, tlsConfig *tls.Config, logger *slog.Logger) *Session {
+func newSession(conn net.Conn, auth Authenticator, store MailboxStore, guardCfg protoguard.Config, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, loginLimiter *ratelimit.Limiter) *Session {
 	_, alreadyTLS := conn.(*tls.Conn)
 	return &Session{
-		conn:      conn,
+		conn:         conn,
-		reader:    bufio.NewReaderSize(conn, maxCommandLineBytes),
+		reader:       bufio.NewReaderSize(conn, maxCommandLineBytes),
-		writer:    bufio.NewWriter(conn),
+		writer:       bufio.NewWriter(conn),
-		auth:      auth,
+		auth:         auth,
-		store:     store,
+		store:        store,
-		guard:     protoguard.New(guardCfg),
+		guard:        protoguard.New(guardCfg),
-		tlsConfig: tlsConfig,
+		tlsConfig:    tlsConfig,
-		tlsActive: alreadyTLS,
+		tlsActive:    alreadyTLS,
-		log:       protolog.NewSessionLogger(logger, "pop3"),
+		log:          protolog.NewSessionLogger(logger, "pop3"),
-		state:     Authorization,
+		tenantID:     tenantID,
-		deleted:   map[int]bool{},
+		loginLimiter: loginLimiter,
+		state:        Authorization,
+		deleted:      map[int]bool{},
 	}
 }
 
+// sourceAddr liefert die Quell-IP dieser Verbindung ohne Portanteil,
+// für das Rate-Limiting (ING-09) und als Schlüssel gegenüber dem
+// Limiter stabil pro Client.
+func (s *Session) sourceAddr() string {
+	host, _, err := net.SplitHostPort(s.conn.RemoteAddr().String())
+	if err != nil {
+		return s.conn.RemoteAddr().String()
+	}
+	return host
+}
+
 // currentPhase liefert die protoguard-Phase des aktuellen Sitzungszustands.
 func (s *Session) currentPhase() protoguard.Phase {
 	if s.state == Authorization {

mail/internal/ratelimit/ratelimit.go

@@ -0,0 +1,109 @@
+// Package ratelimit implementiert ING-09: Token-Bucket-Rate-Limiting
+// auf Protokollebene für Login-Versuche (IMAP/POP3) und SMTP-Annahme,
+// je Mandant getrennt konfigurierbar (Akzeptanzkriterium 3).
+package ratelimit
+
+import (
+	"fmt"
+	"sync"
+	"time"
+)
+
+// Config ist die Token-Bucket-Konfiguration EINES Limits
+// (Akzeptanzkriterium 1/2: begrenzt und konfigurierbar). Burst ist die
+// Anzahl sofort verfügbarer Versuche, RefillEvery die Zeit, die ein
+// neuer Versuch nachwächst.
+type Config struct {
+	Burst       int
+	RefillEvery time.Duration
+}
+
+// ConfigProvider liefert die Rate-Limit-Konfiguration für einen
+// Mandanten (Akzeptanzkriterium 3: je Mandant getrennt konfigurierbar).
+type ConfigProvider interface {
+	ConfigFor(tenant string) Config
+}
+
+// StaticConfig ist ein einfacher ConfigProvider: feste Konfiguration je
+// Mandant, mit Fallback auf Default für unbekannte/nicht gesondert
+// konfigurierte Mandanten.
+type StaticConfig struct {
+	Default   Config
+	PerTenant map[string]Config
+}
+
+func (s StaticConfig) ConfigFor(tenant string) Config {
+	if cfg, ok := s.PerTenant[tenant]; ok {
+		return cfg
+	}
+	return s.Default
+}
+
+// tokenBucket ist EIN Token-Bucket-Zähler für einen Schlüssel
+// (Mandant+Quelle).
+type tokenBucket struct {
+	mu         sync.Mutex
+	tokens     float64
+	lastRefill time.Time
+	cfg        Config
+}
+
+func newTokenBucket(cfg Config) *tokenBucket {
+	return &tokenBucket{tokens: float64(cfg.Burst), lastRefill: time.Now(), cfg: cfg}
+}
+
+// allow entscheidet über EINEN Versuch zum Zeitpunkt now. Bei
+// Ablehnung liefert retryAfter eine konkrete, positive Wartezeit
+// (Akzeptanzkriterium 1: definierte Ablehnung MIT Wartezeit-Hinweis,
+// nicht bloßer Verbindungsabbruch).
+func (b *tokenBucket) allow(now time.Time) (ok bool, retryAfter time.Duration) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	refillPerSecond := 1.0 / b.cfg.RefillEvery.Seconds()
+	elapsed := now.Sub(b.lastRefill).Seconds()
+	b.tokens += elapsed * refillPerSecond
+	if b.tokens > float64(b.cfg.Burst) {
+		b.tokens = float64(b.cfg.Burst)
+	}
+	b.lastRefill = now
+
+	if b.tokens >= 1 {
+		b.tokens--
+		return true, 0
+	}
+	missing := 1 - b.tokens
+	wait := time.Duration(missing / refillPerSecond * float64(time.Second))
+	if wait <= 0 {
+		wait = time.Millisecond
+	}
+	return false, wait
+}
+
+// Limiter verwaltet Token-Buckets je (Mandant, Quelle)-Schlüssel —
+// EIN Limiter deckt EINEN Limit-Zweck ab (z. B. "Login-Versuche" oder
+// "SMTP-Annahme"); ein Server verwendet für unterschiedliche Zwecke
+// unterschiedliche Limiter-Instanzen.
+type Limiter struct {
+	mu       sync.Mutex
+	buckets  map[string]*tokenBucket
+	provider ConfigProvider
+}
+
+func NewLimiter(provider ConfigProvider) *Limiter {
+	return &Limiter{buckets: map[string]*tokenBucket{}, provider: provider}
+}
+
+// Allow prüft, ob EIN Versuch von source innerhalb des Mandanten
+// tenant aktuell erlaubt ist.
+func (l *Limiter) Allow(tenant, source string) (ok bool, retryAfter time.Duration) {
+	key := fmt.Sprintf("%s|%s", tenant, source)
+	l.mu.Lock()
+	b, exists := l.buckets[key]
+	if !exists {
+		b = newTokenBucket(l.provider.ConfigFor(tenant))
+		l.buckets[key] = b
+	}
+	l.mu.Unlock()
+	return b.allow(time.Now())
+}

mail/internal/ratelimit/ratelimit_test.go

@@ -0,0 +1,70 @@
+package ratelimit
+
+import (
+	"testing"
+	"time"
+)
+
+func TestLimiter_AllowsBurstThenBlocksThenRecovers(t *testing.T) {
+	cfg := Config{Burst: 3, RefillEvery: 50 * time.Millisecond}
+	lim := NewLimiter(StaticConfig{Default: cfg})
+
+	for i := 0; i < 3; i++ {
+		ok, _ := lim.Allow("mandant-a", "1.2.3.4")
+		if !ok {
+			t.Fatalf("versuch %d im burst hätte erlaubt sein müssen", i+1)
+		}
+	}
+	ok, retryAfter := lim.Allow("mandant-a", "1.2.3.4")
+	if ok {
+		t.Fatalf("vierter versuch über dem burst hätte abgelehnt werden müssen")
+	}
+	if retryAfter <= 0 {
+		t.Fatalf("erwartete positive wartezeit als hinweis, habe %v", retryAfter)
+	}
+
+	time.Sleep(retryAfter + 10*time.Millisecond)
+	ok, _ = lim.Allow("mandant-a", "1.2.3.4")
+	if !ok {
+		t.Fatalf("nach der wartezeit hätte wieder ein token verfügbar sein müssen")
+	}
+}
+
+func TestLimiter_TenantsAreIndependent(t *testing.T) {
+	lim := NewLimiter(StaticConfig{Default: Config{Burst: 1, RefillEvery: time.Hour}})
+
+	okA, _ := lim.Allow("mandant-a", "1.2.3.4")
+	if !okA {
+		t.Fatalf("mandant a: erster versuch hätte erlaubt sein müssen")
+	}
+	okA2, _ := lim.Allow("mandant-a", "1.2.3.4")
+	if okA2 {
+		t.Fatalf("mandant a: zweiter versuch hätte abgelehnt werden müssen")
+	}
+
+	// Mandant B mit DERSELBEN Quelladresse — eigener Bucket.
+	okB, _ := lim.Allow("mandant-b", "1.2.3.4")
+	if !okB {
+		t.Fatalf("mandant b: eigener bucket, erster versuch hätte erlaubt sein müssen")
+	}
+}
+
+func TestLimiter_PerTenantConfigOverridesDefault(t *testing.T) {
+	lim := NewLimiter(StaticConfig{
+		Default: Config{Burst: 1, RefillEvery: time.Hour},
+		PerTenant: map[string]Config{
+			"mandant-grosszuegig": {Burst: 5, RefillEvery: time.Hour},
+		},
+	})
+
+	for i := 0; i < 5; i++ {
+		ok, _ := lim.Allow("mandant-grosszuegig", "1.2.3.4")
+		if !ok {
+			t.Fatalf("mandant-grosszuegig: versuch %d hätte im eigenen, größeren burst erlaubt sein müssen", i+1)
+		}
+	}
+	ok, _ := lim.Allow("mandant-grosszuegig", "1.2.3.4")
+	if ok {
+		t.Fatalf("mandant-grosszuegig: sechster versuch hätte abgelehnt werden müssen")
+	}
+}

mail/internal/search/facets.go

@@ -14,11 +14,13 @@ import (
 )
 
 // FacetFilter schränkt Suche/Facettenberechnung auf einen bereits
-// gewählten Facettenwert ein. Field MUSS aus FacetFields stammen —
+// gewählten Facettenwert ein. Field ist der geschlossene FacetField-Typ
-// Facets liefert einen Fehler bei jedem anderen Wert (verhindert einen
+// (SRC-11) — buildFilteredMust prüft zusätzlich FacetField.IsValid(),
-// beliebigen, vom Aufrufer bestimmten Feldnamen in der Anfrage).
+// sodass selbst ein über json.Unmarshal aus der Datenbank
+// rekonstruierter, nicht mehr gültiger Wert (z. B. nach Entfernen eines
+// Feldes) abgelehnt wird statt stillschweigend durchzulaufen.
 type FacetFilter struct {
-	Field string
+	Field FacetField
 	Value string
 }
 
@@ -70,19 +72,12 @@ func dateRangeBoundaries(now time.Time) []dateRangeBoundary {
 	}
 }
 
-func isFacetField(field string) bool {
-	for _, f := range FacetFields {
-		if f == field {
-			return true
-		}
-	}
-	return false
-}
-
 // buildFilteredMust baut die gemeinsame bool.must-Liste für Facets und
 // SearchWithFilters: Tenant-Filter zwingend, optionaler Suchtext, dann je
 // Filter eine zusätzliche equals-Klausel (UND-Verknüpfung) — einzige
-// Stelle, an der Filter-Feldnamen gegen FacetFields geprüft werden.
+// Stelle, an der Filter-Feldnamen geprüft werden, über das geschlossene
+// FacetField.IsValid() (SRC-11 Akzeptanzkriterium 2), nicht über eine
+// durchsuchbare Liste.
 func buildFilteredMust(tenantSlug, queryText string, filters []FacetFilter) ([]map[string]any, error) {
 	must := []map[string]any{
 		{"equals": map[string]any{FieldTenantSlug: tenantSlug}},
@@ -91,10 +86,10 @@ func buildFilteredMust(tenantSlug, queryText string, filters []FacetFilter) ([]m
 		must = append(must, map[string]any{"query_string": queryText})
 	}
 	for _, f := range filters {
-		if !isFacetField(f.Field) {
+		if !f.Field.IsValid() {
 			return nil, fmt.Errorf("search: unbekanntes facettenfeld %q", f.Field)
 		}
-		must = append(must, map[string]any{"equals": map[string]any{f.Field: f.Value}})
+		must = append(must, map[string]any{"equals": map[string]any{string(f.Field): f.Value}})
 	}
 	return must, nil
 }
@@ -162,7 +157,7 @@ func (c *Client) Facets(ctx context.Context, tenantSlug, queryText string, filte
 
 	aggs := map[string]any{}
 	for _, field := range FacetFields {
-		aggs[field] = map[string]any{"terms": map[string]any{"field": field, "size": 100}}
+		aggs[string(field)] = map[string]any{"terms": map[string]any{"field": string(field), "size": 100}}
 	}
 	boundaries := dateRangeBoundaries(time.Now())
 	ranges := make([]map[string]any, 0, len(boundaries))
@@ -208,7 +203,7 @@ func (c *Client) Facets(ctx context.Context, tenantSlug, queryText string, filte
 
 	result := FacetResult{Values: make(map[string][]FacetValue, len(FacetFields))}
 	for _, field := range FacetFields {
-		bucket := parsed.Aggregations[field]
+		bucket := parsed.Aggregations[string(field)]
 		values := make([]FacetValue, 0, len(bucket.Buckets))
 		for _, b := range bucket.Buckets {
 			if b.Key == "" {
@@ -216,7 +211,7 @@ func (c *Client) Facets(ctx context.Context, tenantSlug, queryText string, filte
 			}
 			values = append(values, FacetValue{Value: b.Key, Count: b.DocCount})
 		}
-		result.Values[field] = values
+		result.Values[string(field)] = values
 	}
 
 	sentAtBucket := parsed.Aggregations["sent_at"]

mail/internal/search/fields.go

@@ -35,12 +35,52 @@ const (
 	FieldOCRConfidence = "ocr_confidence"
 )
 
+// FacetField ist ein geschlossener Typ für die vier zulässigen
+// Facetten-/Filterdimensionen (SRC-11, Akzeptanzkriterium 2): die
+// Zulässigkeitsprüfung in facets.go läuft über ein erschöpfendes
+// switch/case auf diesem Typ, NICHT über das Durchsuchen einer Liste —
+// selbst ein vergessener Eintrag in einer Whitelist-Liste könnte dort
+// nichts mehr durchlassen, weil keine solche Liste mehr die Entscheidung
+// trifft. FacetFields (unten) ist nur noch eine abgeleitete
+// Aufzählungshilfe für Iteration, keine Prüfgrundlage.
+type FacetField string
+
+const (
+	FacetFieldSender         FacetField = FacetField(FieldSender)
+	FacetFieldMailbox        FacetField = FacetField(FieldMailbox)
+	FacetFieldAttachmentType FacetField = FacetField(FieldAttachmentType)
+	FacetFieldTag            FacetField = FacetField(FieldTag)
+)
+
+// IsValid entscheidet über Zulässigkeit als Facetten-/Filterfeld über
+// ein geschlossenes switch/case (Akzeptanzkriterium 2) statt eine Liste
+// zu durchsuchen.
+func (f FacetField) IsValid() bool {
+	switch f {
+	case FacetFieldSender, FacetFieldMailbox, FacetFieldAttachmentType, FacetFieldTag:
+		return true
+	default:
+		return false
+	}
+}
+
+// ParseFacetField wandelt eine externe Zeichenkette (z. B. aus einem
+// HTTP-Query-Parameter) in ein FacetField um — liefert false bei jedem
+// Wert, der nicht exakt einer der geschlossenen Konstanten entspricht.
+// Einzige vorgesehene Stelle, an der ein Client-Feldname überhaupt zu
+// einem FacetField werden kann.
+func ParseFacetField(raw string) (FacetField, bool) {
+	f := FacetField(raw)
+	return f, f.IsValid()
+}
+
 // FacetFields sind die je Kachel unterstützten Filterdimensionen
 // (Akzeptanzkriterium 1: Absender, Postfach, Anhangstyp, Tag — Zeitraum
 // läuft separat über FieldSentAt als Bereichsfacette, siehe facets.go).
-// Statische Liste — Aufrufer können ausschließlich diese Feldnamen als
+// Nur zur Iteration gedacht (z. B. "berechne alle Facetten") — die
-// Facetten-/Filterdimension angeben, kein beliebiger Client-Feldname.
+// Zulässigkeitsprüfung selbst läuft über FacetField.IsValid(), nicht
-var FacetFields = []string{FieldSender, FieldMailbox, FieldAttachmentType, FieldTag}
+// über Mitgliedschaft in dieser Liste.
+var FacetFields = []FacetField{FacetFieldSender, FacetFieldMailbox, FacetFieldAttachmentType, FacetFieldTag}
 
 // DocumentID berechnet deterministisch die Manticore-Dokument-ID aus
 // Mandant und Message-ID (FNV-1a, 64 Bit). Deterministisch statt einer

mail/internal/search/src11_test.go

@@ -0,0 +1,117 @@
+// SRC-11: Feld-Whitelist-Query-Builder für Suchindex-Zugriff. Reine
+// Unit-Tests (kein Manticore nötig) — buildFilteredMust und FacetField
+// sind pure Funktionen/Typen.
+package search
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+// TestBuildFilteredMust_RejectsUnknownField ist die geforderte
+// Pflichtprüfung 1 (SRC-11): Versuch, ein nicht in der Whitelist
+// enthaltenes Feld anzufragen, wird abgewiesen statt stillschweigend
+// ignoriert.
+func TestBuildFilteredMust_RejectsUnknownField(t *testing.T) {
+	// FacetField(...) simuliert genau den Fall, den Akzeptanzkriterium 2
+	// verlangt: ein Wert, der NICHT über die vorgesehene
+	// ParseFacetField-Konstruktion entstanden ist (z. B. aus einem
+	// veralteten Datenbankeintrag nach Entfernen eines Feldes) — muss
+	// trotzdem abgelehnt werden.
+	unknown := FacetField("tenant_slug") // existiert als Suchfeld, ist aber KEIN Facettenfeld
+	_, err := buildFilteredMust("mandant-x", "", []FacetFilter{{Field: unknown, Value: "x"}})
+	if err == nil {
+		t.Fatalf("erwartete ablehnung für unbekanntes facettenfeld %q, bekam keinen fehler", unknown)
+	}
+	if !strings.Contains(err.Error(), string(unknown)) {
+		t.Fatalf("fehlermeldung sollte das abgelehnte feld nennen, habe: %v", err)
+	}
+
+	// Frei erfundenes Feld, das nirgendwo im Schema existiert.
+	madeUp := FacetField("'; DROP TABLE mail_documents; --")
+	_, err = buildFilteredMust("mandant-x", "", []FacetFilter{{Field: madeUp, Value: "x"}})
+	if err == nil {
+		t.Fatalf("erwartete ablehnung für frei erfundenes facettenfeld, bekam keinen fehler")
+	}
+}
+
+// TestBuildFilteredMust_AcceptsAllWhitelistedFields stellt sicher, dass
+// alle vier vorgesehenen Facettenfelder tatsächlich funktionieren (keine
+// versehentlich zu strenge Prüfung).
+func TestBuildFilteredMust_AcceptsAllWhitelistedFields(t *testing.T) {
+	for _, field := range FacetFields {
+		_, err := buildFilteredMust("mandant-x", "", []FacetFilter{{Field: field, Value: "x"}})
+		if err != nil {
+			t.Fatalf("feld %q hätte akzeptiert werden müssen: %v", field, err)
+		}
+	}
+}
+
+// TestFacetField_ClosedSetEvenViaDirectTypeConversion ist die geforderte
+// Pflichtprüfung/Akzeptanzkriterium 2: die Whitelist ist nicht die
+// einzige Absicherung. Selbst ein FacetField-Wert, der NICHT über
+// ParseFacetField entstanden ist (direkte Typkonvertierung, z. B. durch
+// künftigen Code, der die vorgesehene Konstruktion umgeht), wird von
+// IsValid() zuverlässig abgelehnt — die Prüfung hängt an einem
+// erschöpfenden switch/case auf den vier Konstanten, nicht an einer
+// durchsuchbaren Liste, die vergessen werden könnte.
+func TestFacetField_ClosedSetEvenViaDirectTypeConversion(t *testing.T) {
+	valid := []FacetField{FacetFieldSender, FacetFieldMailbox, FacetFieldAttachmentType, FacetFieldTag}
+	for _, f := range valid {
+		if !f.IsValid() {
+			t.Fatalf("erwartete gültiges feld %q als gültig", f)
+		}
+	}
+
+	invalid := []FacetField{
+		FacetField(FieldTenantSlug), // reales Suchfeld, aber keine Facette
+		FacetField(FieldBody),
+		FacetField("subject; --"),
+		FacetField(""),
+	}
+	for _, f := range invalid {
+		if f.IsValid() {
+			t.Fatalf("feld %q hätte als ungültig erkannt werden müssen", f)
+		}
+	}
+}
+
+// TestParseFacetField_OnlyAcceptsKnownStrings deckt die einzige
+// vorgesehene Konstruktionsstelle für FacetField aus einer externen
+// Zeichenkette ab.
+func TestParseFacetField_OnlyAcceptsKnownStrings(t *testing.T) {
+	if _, ok := ParseFacetField("sender"); !ok {
+		t.Fatalf("'sender' hätte als gültiges facettenfeld erkannt werden müssen")
+	}
+	if _, ok := ParseFacetField("nicht_existent"); ok {
+		t.Fatalf("unbekannter feldname hätte abgelehnt werden müssen")
+	}
+	if _, ok := ParseFacetField("tenant_slug"); ok {
+		t.Fatalf("ein reales, aber nicht-facettiertes suchfeld hätte abgelehnt werden müssen")
+	}
+}
+
+// TestNoDynamicFieldNameConstruction ist die geforderte Pflichtprüfung 2
+// (SRC-11): Code-Review bestätigt automatisiert, dass facets.go und
+// fields.go keinen dynamischen Spalten-/Tabellennamen per
+// String-Zusammenbau (fmt.Sprintf/+) erzeugen — Feldnamen kommen
+// ausschließlich aus den FacetField-Konstanten bzw. den statischen
+// FieldXxx-Konstanten dieses Pakets.
+func TestNoDynamicFieldNameConstruction(t *testing.T) {
+	for _, file := range []string{"facets.go", "fields.go"} {
+		src, err := os.ReadFile(file)
+		if err != nil {
+			t.Fatalf("%s lesen: %v", file, err)
+		}
+		for _, line := range strings.Split(string(src), "\n") {
+			trimmed := strings.TrimSpace(line)
+			if strings.HasPrefix(trimmed, "//") {
+				continue // Kommentarzeilen dürfen den Begriff zur Erklärung nennen
+			}
+			if strings.Contains(line, "fmt.Sprintf") {
+				t.Fatalf("%s darf kein fmt.Sprintf im Code verwenden (dynamische Feldnamenbildung verboten, SRC-11 Akzeptanzkriterium 1): %q", file, trimmed)
+			}
+		}
+	}
+}

mail/internal/smtp/commands.go

@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"bytes"
 	"context"
+	"fmt"
 	"strings"
 
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/tlscert"
@@ -77,6 +78,14 @@ func (s *Session) handleMailFrom(arg string) bool {
 		// SMTP-Fehlermeldung statt Absturz oder Verbindungsabbruch.
 		return s.reply(553, "invalid sender address") == nil
 	}
+	if s.acceptLimiter != nil {
+		if ok, retryAfter := s.acceptLimiter.Allow(s.tenantID, addr+"|"+s.sourceAddr()); !ok {
+			// Akzeptanzkriterium 1/3 (ING-09): definierte, temporäre
+			// Ablehnung (4xx = "try again later") MIT Wartezeit-Hinweis
+			// statt Verbindungsabbruch ohne Erklärung.
+			return s.reply(451, fmt.Sprintf("rate limit exceeded for sender, retry in %.1fs", retryAfter.Seconds())) == nil
+		}
+	}
 	s.from = addr
 	s.to = nil
 	s.state = MailFromSet

mail/internal/smtp/loadtest_test.go

@@ -0,0 +1,128 @@
+package smtp
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"net"
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/loadtest"
+)
+
+// smtpLoadtestConcurrency/smtpLoadtestSessions — siehe pop3-Pendant für
+// die Begründung der Größenordnung (Akzeptanzkriterium 1, QA-07).
+const (
+	smtpLoadtestConcurrency = 200
+	smtpLoadtestSessions    = 2000
+)
+
+// Zielwerte (Akzeptanzkriterium 3, QA-07) — festgelegt VOR dem
+// entscheidenden Testlauf, siehe Prüfprotokoll QA-07 für die
+// Vorab-Messwerte auf 192.168.1.131.
+const (
+	smtpTargetP95Latency    = 100 * time.Millisecond
+	smtpTargetThroughputMin = 500.0 // Sessions/Sekunde
+)
+
+// TestLoadtest_SMTPParallelSessionsMeetTargets ist die geforderte
+// Pflichtprüfung 1+2 (QA-07).
+func TestLoadtest_SMTPParallelSessionsMeetTargets(t *testing.T) {
+	if testing.Short() {
+		t.Skip("lasttest übersprungen (-short)")
+	}
+	sink := &fakeSink{}
+	addr, stop := startTestServer(t, sink, defaultMaxMessageBytes)
+	defer stop()
+
+	resourcesBefore := loadtest.SampleResources()
+	result := loadtest.Run(context.Background(), "smtp", smtpLoadtestConcurrency, smtpLoadtestSessions, func(ctx context.Context) error {
+		return runSMTPLoadSession(addr)
+	})
+	resourcesAfter := loadtest.SampleResources()
+
+	p50 := result.Percentile(0.50)
+	p95 := result.Percentile(0.95)
+	maxLatency := result.Max()
+	throughput := result.Throughput()
+	heapDeltaMB := float64(resourcesAfter.HeapAllocBytes-resourcesBefore.HeapAllocBytes) / (1024 * 1024)
+	cpuUsed := resourcesAfter.CPUTimeSeconds - resourcesBefore.CPUTimeSeconds
+
+	fmt.Printf("QA-07 SMTP-Lasttest: %d Sessions, %d parallel, Dauer %v\n", result.Sessions, result.Concurrency, result.Duration)
+	fmt.Printf("  Fehler: %d\n", result.Errors)
+	fmt.Printf("  Durchsatz: %.1f Sessions/s (Ziel: >= %.1f)\n", throughput, smtpTargetThroughputMin)
+	fmt.Printf("  Latenz p50=%v p95=%v (Ziel: <= %v) max=%v\n", p50, p95, smtpTargetP95Latency, maxLatency)
+	fmt.Printf("  Ressourcen: Heap-Delta=%.1f MiB, CPU-Zeit=%.2fs\n", heapDeltaMB, cpuUsed)
+	fmt.Printf("  Angenommene Nachrichten (Sink): %d\n", sink.count())
+
+	if result.Errors != 0 {
+		t.Fatalf("QA-07 SMTP: %d von %d sessions fehlgeschlagen", result.Errors, result.Sessions)
+	}
+	if sink.count() != smtpLoadtestSessions {
+		t.Fatalf("QA-07 SMTP: erwartete %d angenommene nachrichten, habe %d", smtpLoadtestSessions, sink.count())
+	}
+	if p95 > smtpTargetP95Latency {
+		t.Fatalf("QA-07 SMTP: p95-latenz %v überschreitet zielwert %v", p95, smtpTargetP95Latency)
+	}
+	if throughput < smtpTargetThroughputMin {
+		t.Fatalf("QA-07 SMTP: durchsatz %.1f sessions/s unter zielwert %.1f", throughput, smtpTargetThroughputMin)
+	}
+	if heapDeltaMB > 100 {
+		t.Fatalf("QA-07 SMTP: heap-wachstum %.1f MiB deutet auf ressourcenleck hin", heapDeltaMB)
+	}
+}
+
+func runSMTPLoadSession(addr string) error {
+	conn, err := net.DialTimeout("tcp", addr, 3*time.Second)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = conn.Close() }()
+	_ = conn.SetDeadline(time.Now().Add(5 * time.Second))
+	reader := bufio.NewReader(conn)
+
+	if _, err := reader.ReadString('\n'); err != nil { // 220-Begrüßung
+		return err
+	}
+	if _, err := conn.Write([]byte("EHLO client.example.com\r\n")); err != nil {
+		return err
+	}
+	for {
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			return err
+		}
+		if strings.HasPrefix(line, "250 ") {
+			break
+		}
+	}
+	if err := sendAndExpectCode(conn, reader, "MAIL FROM:<a@example.com>", "250"); err != nil {
+		return err
+	}
+	if err := sendAndExpectCode(conn, reader, "RCPT TO:<b@example.com>", "250"); err != nil {
+		return err
+	}
+	if err := sendAndExpectCode(conn, reader, "DATA", "354"); err != nil {
+		return err
+	}
+	if err := sendAndExpectCode(conn, reader, "Subject: last\r\n\r\nHallo\r\n.", "250"); err != nil {
+		return err
+	}
+	return sendAndExpectCode(conn, reader, "QUIT", "221")
+}
+
+func sendAndExpectCode(conn net.Conn, reader *bufio.Reader, cmd, wantCode string) error {
+	if _, err := conn.Write([]byte(cmd + "\r\n")); err != nil {
+		return err
+	}
+	resp, err := reader.ReadString('\n')
+	if err != nil {
+		return err
+	}
+	if code(resp) != wantCode {
+		return fmt.Errorf("%q: erwartete %s, habe %q", cmd, wantCode, resp)
+	}
+	return nil
+}

mail/internal/smtp/qa04_security_test.go

@@ -0,0 +1,147 @@
+// QA-04: Sicherheits- und Berechtigungsprüfung, SMTP-Härtung gegen
+// bekannte Angriffsmuster (Pflichtprüfung: "Gezielter Testangriff auf
+// Header-Injection schlägt fehl"). Ergänzt ING-03/ING-06/ING-09s
+// bestehende Tests um einen eigenständigen, gezielten Angriffslauf
+// gegen den echten, laufenden Server.
+package smtp
+
+import (
+	"bufio"
+	"context"
+	"net"
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
+)
+
+// TestQA04_HeaderInjectionViaEnvelopeAddressRejected ist die geforderte
+// Pflichtprüfung: ein gezielter Versuch, über die Envelope-Adressen
+// (MAIL FROM/RCPT TO) Steuerzeichen einzuschleusen, die bei
+// unvorsichtiger späterer Header-Konstruktion (z. B. durch einen
+// nachgelagerten Mailer, siehe ING-03 mail/internal/mailer) zu
+// Header-Injection führen könnten, schlägt bereits auf
+// SMTP-Envelope-Ebene fehl.
+func TestQA04_HeaderInjectionViaEnvelopeAddressRejected(t *testing.T) {
+	sink := &fakeSink{}
+	addr, stop := startTestServer(t, sink, defaultMaxMessageBytes)
+	defer stop()
+
+	attacks := []struct {
+		name string
+		cmd  string
+	}{
+		{"NUL-Byte in RCPT TO", "RCPT TO:<a\x00@example.com>"},
+		{"Steuerzeichen 0x01 in MAIL FROM", "MAIL FROM:<a\x01@example.com>"},
+	}
+
+	for _, atk := range attacks {
+		t.Run(atk.name, func(t *testing.T) {
+			c := dial(t, addr)
+			defer c.close()
+			c.send(t, "EHLO client.example.com")
+			for {
+				line := c.readLine(t)
+				if strings.HasPrefix(line, "250 ") {
+					break
+				}
+			}
+			c.send(t, "MAIL FROM:<a@example.com>")
+
+			resp := c.send(t, atk.cmd)
+			if code(resp) != "553" && code(resp) != "501" {
+				t.Fatalf("angriff %q wurde NICHT sauber zurückgewiesen: %q", atk.name, resp)
+			}
+			// Verbindung muss danach weiter funktionsfähig sein — kein
+			// Absturz, kein hängender Zustand durch den Angriffsversuch.
+			if resp := c.send(t, "NOOP"); code(resp) != "250" {
+				t.Fatalf("session nach angriff %q nicht mehr funktionsfähig: %q", atk.name, resp)
+			}
+		})
+	}
+
+	if sink.count() != 0 {
+		t.Fatalf("keiner der angriffsversuche hätte eine nachricht bis zum sink durchlassen dürfen, habe %d", sink.count())
+	}
+}
+
+// TestQA04_OversizedLineWithoutCRLFDoesNotHangOrCrash ist ein
+// zusätzlicher, gezielter Testangriff (bekanntes Muster: Ressourcen-
+// erschöpfung durch eine Kommandozeile ohne Zeilenende) — bestätigt,
+// dass der Server bei einer weit über die dokumentierte Zeilengrenze
+// (maxCommandLineBytes) hinausgehenden, nie abgeschlossenen Zeile
+// zuverlässig reagiert (Verbindungsabbruch/Timeout) statt unbegrenzt
+// Speicher zu binden oder zu hängen.
+func TestQA04_OversizedLineWithoutCRLFDoesNotHangOrCrash(t *testing.T) {
+	sink := &fakeSink{}
+	// Kurzer Idle-Timeout statt protoguard.DefaultConfig()s 5 Minuten —
+	// sonst würde dieser Test selbst bei korrektem Verhalten Minuten
+	// brauchen, um die Reaktion des Servers zu beobachten.
+	guardCfg := protoguard.Config{DefaultTimeout: 500 * time.Millisecond}
+	srv := NewServerWithMaxMessageBytesTLSLoggerRateLimitAndGuardConfig(sink, defaultMaxMessageBytes, nil, nil, "mandant-qa04-guard", nil, 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)
+	}()
+	addr := listener.Addr().String()
+	defer func() {
+		cancel()
+		<-done
+	}()
+
+	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)
+	if _, err := reader.ReadString('\n'); err != nil {
+		t.Fatalf("begrüßung lesen: %v", err)
+	}
+
+	// Weit über maxCommandLineBytes (8192) hinaus, absichtlich OHNE
+	// abschließendes CRLF — simuliert eine Gegenstelle, die niemals eine
+	// Zeile abschließt.
+	huge := strings.Repeat("A", 10*maxCommandLineBytes)
+
+	writeDone := make(chan struct{})
+	var writeErr error
+	go func() {
+		defer close(writeDone)
+		_ = conn.SetWriteDeadline(time.Now().Add(5 * time.Second))
+		_, writeErr = conn.Write([]byte(huge))
+	}()
+
+	writeCtx, writeCancel := context.WithTimeout(context.Background(), 8*time.Second)
+	defer writeCancel()
+	select {
+	case <-writeDone:
+	case <-writeCtx.Done():
+		t.Fatalf("schreiben der überlangen zeile blockierte unerwartet lange (>8s) — hinweis auf hängenden server")
+	}
+	if writeErr != nil {
+		// Verbindungsabbruch durch den Server während des Schreibens ist
+		// ein AKZEPTABLES Ergebnis (frühes Erkennen), kein Testfehler.
+		t.Logf("verbindung während des schreibens der überlangen zeile beendet (akzeptabel): %v", writeErr)
+		return
+	}
+
+	// Server muss innerhalb einer begrenzten Zeit reagieren (Fehler oder
+	// Verbindungsende) — NICHT unbegrenzt auf ein CRLF warten, das nie
+	// kommt.
+	_ = conn.SetReadDeadline(time.Now().Add(8 * time.Second))
+	_, err = reader.ReadString('\n')
+	if err == nil {
+		t.Fatalf("erwartete verbindungsende/fehler nach überlanger zeile ohne CRLF, server hat stattdessen scheinbar eine antwort geliefert")
+	}
+	if ne, ok := err.(net.Error); ok && ne.Timeout() {
+		t.Fatalf("server hat innerhalb von 8s weder geantwortet noch die verbindung beendet — unbegrenztes warten auf CRLF bestätigt")
+	}
+}

mail/internal/smtp/ratelimit_test.go

@@ -0,0 +1,134 @@
+package smtp
+
+import (
+	"context"
+	"net"
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/ratelimit"
+)
+
+func startRateLimitedServer(t *testing.T, sink MessageSink, tenant string, limiter *ratelimit.Limiter) (addr string, stop func()) {
+	t.Helper()
+	srv := NewServerWithMaxMessageBytesTLSLoggerAndRateLimit(sink, defaultMaxMessageBytes, nil, nil, tenant, limiter)
+
+	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
+	}
+}
+
+// attemptMailFrom führt EHLO+MAIL FROM über eine NEUE Verbindung aus
+// und liefert die MAIL FROM-Antwortzeile.
+func attemptMailFrom(t *testing.T, addr, from string) string {
+	t.Helper()
+	c := dial(t, addr)
+	defer c.close()
+	c.send(t, "EHLO client.example.com")
+	for {
+		line := c.readLine(t)
+		if strings.HasPrefix(line, "250 ") {
+			break
+		}
+	}
+	return c.send(t, "MAIL FROM:<"+from+">")
+}
+
+// TestRateLimit_LoadExceedingLimitGetsRejectedWithRetryHint ist die
+// geforderte Pflichtprüfung 1 (ING-09).
+func TestRateLimit_LoadExceedingLimitGetsRejectedWithRetryHint(t *testing.T) {
+	limiter := ratelimit.NewLimiter(ratelimit.StaticConfig{
+		Default: ratelimit.Config{Burst: 5, RefillEvery: time.Hour},
+	})
+	sink := &fakeSink{}
+	addr, stop := startRateLimitedServer(t, sink, "mandant-a", limiter)
+	defer stop()
+
+	const attempts = 20
+	var accepted, rejected int
+	for i := 0; i < attempts; i++ {
+		resp := attemptMailFrom(t, addr, "immer-gleicher-absender@example.com")
+		switch {
+		case code(resp) == "250":
+			accepted++
+		case code(resp) == "451" && strings.Contains(resp, "rate limit"):
+			rejected++
+		default:
+			t.Fatalf("unerwartete antwort: %q", resp)
+		}
+	}
+
+	if accepted != 5 {
+		t.Fatalf("erwartete genau 5 akzeptierte versuche (burst), habe %d", accepted)
+	}
+	if rejected != attempts-5 {
+		t.Fatalf("erwartete %d abgelehnte versuche, habe %d", attempts-5, rejected)
+	}
+}
+
+// TestRateLimit_LegitUsageBelowThresholdUnaffected ist die geforderte
+// Pflichtprüfung 2 (ING-09).
+func TestRateLimit_LegitUsageBelowThresholdUnaffected(t *testing.T) {
+	limiter := ratelimit.NewLimiter(ratelimit.StaticConfig{
+		Default: ratelimit.Config{Burst: 10, RefillEvery: time.Second},
+	})
+	sink := &fakeSink{}
+	addr, stop := startRateLimitedServer(t, sink, "mandant-a", limiter)
+	defer stop()
+
+	for i := 0; i < 3; i++ {
+		resp := attemptMailFrom(t, addr, "legitim@example.com")
+		if code(resp) != "250" {
+			t.Fatalf("versuch %d unterhalb der schwelle wurde abgelehnt: %q", i+1, resp)
+		}
+	}
+}
+
+// TestRateLimit_PerTenantIndependentAndEffective ist die geforderte
+// Pflichtprüfung 3 (ING-09).
+func TestRateLimit_PerTenantIndependentAndEffective(t *testing.T) {
+	limiter := ratelimit.NewLimiter(ratelimit.StaticConfig{
+		Default: ratelimit.Config{Burst: 2, RefillEvery: time.Hour},
+		PerTenant: map[string]ratelimit.Config{
+			"mandant-grosszuegig": {Burst: 8, RefillEvery: time.Hour},
+		},
+	})
+	sinkKnapp := &fakeSink{}
+	addrKnapp, stopKnapp := startRateLimitedServer(t, sinkKnapp, "mandant-knapp", limiter)
+	defer stopKnapp()
+	sinkGross := &fakeSink{}
+	addrGross, stopGross := startRateLimitedServer(t, sinkGross, "mandant-grosszuegig", limiter)
+	defer stopGross()
+
+	var acceptedKnapp int
+	for i := 0; i < 10; i++ {
+		if code(attemptMailFrom(t, addrKnapp, "absender@example.com")) == "250" {
+			acceptedKnapp++
+		}
+	}
+	var acceptedGross int
+	for i := 0; i < 10; i++ {
+		if code(attemptMailFrom(t, addrGross, "absender@example.com")) == "250" {
+			acceptedGross++
+		}
+	}
+
+	if acceptedKnapp != 2 {
+		t.Fatalf("mandant-knapp: erwartete 2 akzeptierte versuche, habe %d", acceptedKnapp)
+	}
+	if acceptedGross != 8 {
+		t.Fatalf("mandant-grosszuegig: erwartete 8 akzeptierte versuche, habe %d", acceptedGross)
+	}
+}

mail/internal/smtp/server.go

@@ -7,6 +7,9 @@ import (
 	"fmt"
 	"log/slog"
 	"net"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/ratelimit"
 )
 
 // defaultMaxMessageBytes ist die Standard-Höchstgröße einer
@@ -16,13 +19,25 @@ const defaultMaxMessageBytes = 25 * 1024 * 1024 // 25 MiB
 // Server nimmt SMTP-Verbindungen an und bedient jede in einer eigenen
 // Goroutine — gleiches Muster wie mail/internal/imap.Server und
 // mail/internal/pop3.Server. tlsConfig ist optional (ING-06): nil
-// bedeutet, STARTTLS ist nicht verfügbar. Rate-Limiting ist Sache von
+// bedeutet, STARTTLS ist nicht verfügbar. Protokoll-Logging ist Sache
-// ING-09, Protokoll-Logging Sache von ING-08 — keine dieser Kacheln.
+// von ING-08 — keine dieser Kacheln.
+//
+// QA-04-Befund (Sicherheitsprüfung): SMTP bekam beim ursprünglichen
+// ING-07 (Idle-Timeout) fälschlich KEINEN protoguard-Schutz, anders als
+// IMAP/POP3 — eine Gegenstelle, die eine Kommandozeile ohne
+// abschließendes CRLF öffnet und nie beendet, blockierte die Session
+// unbegrenzt (bestätigter, realer Testangriff, siehe
+// qa04_security_test.go). guardCfg schließt diese Lücke nachträglich,
+// mit demselben Standardverhalten wie IMAP/POP3.
 type Server struct {
 	sink            MessageSink
 	maxMessageBytes int64
 	tlsConfig       *tls.Config
 	logger          *slog.Logger
+	guardCfg        protoguard.Config
+
+	tenantID      string
+	acceptLimiter *ratelimit.Limiter
 }
 
 func NewServer(sink MessageSink) *Server {
@@ -32,21 +47,37 @@ func NewServer(sink MessageSink) *Server {
 // NewServerWithMaxMessageBytes erlaubt eine abweichende
 // Nachrichten-Höchstgröße, z. B. für Tests.
 func NewServerWithMaxMessageBytes(sink MessageSink, maxMessageBytes int64) *Server {
-	return &Server{sink: sink, maxMessageBytes: maxMessageBytes}
+	return &Server{sink: sink, maxMessageBytes: maxMessageBytes, guardCfg: protoguard.DefaultConfig()}
 }
 
 // NewServerWithMaxMessageBytesAndTLSConfig erlaubt zusätzlich, STARTTLS
 // zu aktivieren (ING-06). tlsConfig sollte über tlscert.Store.Config()
 // erzeugt werden.
 func NewServerWithMaxMessageBytesAndTLSConfig(sink MessageSink, maxMessageBytes int64, tlsConfig *tls.Config) *Server {
-	return &Server{sink: sink, maxMessageBytes: maxMessageBytes, tlsConfig: tlsConfig}
+	return &Server{sink: sink, maxMessageBytes: maxMessageBytes, tlsConfig: tlsConfig, guardCfg: protoguard.DefaultConfig()}
 }
 
 // NewServerWithMaxMessageBytesTLSAndLogger erlaubt zusätzlich
 // strukturiertes Protokoll-Logging (ING-08). logger darf nil sein
 // (Logging dann deaktiviert, Rückwärtskompatibilität zu ING-01..ING-06).
 func NewServerWithMaxMessageBytesTLSAndLogger(sink MessageSink, maxMessageBytes int64, tlsConfig *tls.Config, logger *slog.Logger) *Server {
-	return &Server{sink: sink, maxMessageBytes: maxMessageBytes, tlsConfig: tlsConfig, logger: logger}
+	return &Server{sink: sink, maxMessageBytes: maxMessageBytes, tlsConfig: tlsConfig, logger: logger, guardCfg: protoguard.DefaultConfig()}
+}
+
+// NewServerWithMaxMessageBytesTLSLoggerAndRateLimit erlaubt zusätzlich
+// Rate-Limiting der SMTP-Annahmerate pro Absender (ING-09, MAIL FROM).
+// acceptLimiter darf nil sein (Rate-Limiting dann deaktiviert).
+// tenantID identifiziert diesen Server gegenüber dem Limiter
+// (Akzeptanzkriterium 3).
+func NewServerWithMaxMessageBytesTLSLoggerAndRateLimit(sink MessageSink, maxMessageBytes int64, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, acceptLimiter *ratelimit.Limiter) *Server {
+	return &Server{sink: sink, maxMessageBytes: maxMessageBytes, tlsConfig: tlsConfig, logger: logger, tenantID: tenantID, acceptLimiter: acceptLimiter, guardCfg: protoguard.DefaultConfig()}
+}
+
+// NewServerWithMaxMessageBytesTLSLoggerRateLimitAndGuardConfig erlaubt
+// zusätzlich abweichende Idle-Timeout-Parameter (QA-04-Nachtrag zu
+// ING-07), z. B. für Tests.
+func NewServerWithMaxMessageBytesTLSLoggerRateLimitAndGuardConfig(sink MessageSink, maxMessageBytes int64, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, acceptLimiter *ratelimit.Limiter, guardCfg protoguard.Config) *Server {
+	return &Server{sink: sink, maxMessageBytes: maxMessageBytes, tlsConfig: tlsConfig, logger: logger, tenantID: tenantID, acceptLimiter: acceptLimiter, guardCfg: guardCfg}
 }
 
 // Serve nimmt Verbindungen auf listener an, bis ctx beendet wird.
@@ -68,7 +99,7 @@ func (srv *Server) Serve(ctx context.Context, listener net.Listener) error {
 			}
 			return fmt.Errorf("smtp: verbindung annehmen: %w", err)
 		}
-		session := newSession(conn, srv.sink, srv.maxMessageBytes, srv.tlsConfig, srv.logger)
+		session := newSession(conn, srv.sink, srv.maxMessageBytes, srv.tlsConfig, srv.logger, srv.tenantID, srv.acceptLimiter, srv.guardCfg)
 		go session.Serve(ctx)
 	}
 }

mail/internal/smtp/session.go

@@ -10,7 +10,9 @@ import (
 	"net"
 	"strings"
 
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protolog"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/ratelimit"
 )
 
 // maxCommandLineBytes begrenzt eine einzelne Kommando-/DATA-Zeile
@@ -19,6 +21,14 @@ import (
 // mail/internal/pop3).
 const maxCommandLineBytes = 8192
 
+// phaseSMTP ist die (einzige) protoguard-Phase dieser Sitzung
+// (QA-04-Nachtrag zu ING-07): SMTP hat — anders als IMAP/POP3 — keine
+// sicherheitsrelevant unterschiedlichen Phasen (Anmeldephase
+// existiert in der aktuellen Implementierung nicht, siehe ING-03), ein
+// einziger Idle-Timeout für jeden Lesevorgang genügt, um eine
+// Gegenstelle ohne abschließendes CRLF nicht unbegrenzt zu blockieren.
+const phaseSMTP protoguard.Phase = "smtp"
+
 // Session ist eine einzelne SMTP-Verbindung mit eigener
 // Zustandsmaschine (Akzeptanzkriterium 1).
 type Session struct {
@@ -34,12 +44,17 @@ type Session struct {
 
 	log *protolog.SessionLogger // ING-08, nie nil (log.Event() ist nil-sicher)
 
+	tenantID      string
+	acceptLimiter *ratelimit.Limiter // ING-09, nil = kein Rate-Limiting
+
+	guard *protoguard.Guard // QA-04-Nachtrag zu ING-07
+
 	state State
 	from  string
 	to    []string
 }
 
-func newSession(conn net.Conn, sink MessageSink, maxMessageBytes int64, tlsConfig *tls.Config, logger *slog.Logger) *Session {
+func newSession(conn net.Conn, sink MessageSink, maxMessageBytes int64, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, acceptLimiter *ratelimit.Limiter, guardCfg protoguard.Config) *Session {
 	_, alreadyTLS := conn.(*tls.Conn)
 	return &Session{
 		conn:            conn,
@@ -50,10 +65,23 @@ func newSession(conn net.Conn, sink MessageSink, maxMessageBytes int64, tlsConfi
 		tlsConfig:       tlsConfig,
 		tlsActive:       alreadyTLS,
 		log:             protolog.NewSessionLogger(logger, "smtp"),
+		tenantID:        tenantID,
+		acceptLimiter:   acceptLimiter,
+		guard:           protoguard.New(guardCfg),
 		state:           Greeting,
 	}
 }
 
+// sourceAddr liefert die Quell-IP dieser Verbindung ohne Portanteil
+// (ING-09).
+func (s *Session) sourceAddr() string {
+	host, _, err := net.SplitHostPort(s.conn.RemoteAddr().String())
+	if err != nil {
+		return s.conn.RemoteAddr().String()
+	}
+	return host
+}
+
 // State liefert den aktuellen Sitzungszustand (für Tests).
 func (s *Session) State() State { return s.state }
 
@@ -97,7 +125,15 @@ func (s *Session) Serve(ctx context.Context) {
 	}
 }
 
+// readLine liest eine Zeile — mit Idle-Timeout VOR jedem Lesevorgang
+// (QA-04-Nachtrag zu ING-07): ein einziger Ort für alle Aufrufer
+// (Haupt-Serve-Schleife, handleData, drainUntilDot), damit eine
+// Gegenstelle, die eine Zeile ohne abschließendes CRLF nie beendet,
+// die Session nicht unbegrenzt blockieren kann.
 func (s *Session) readLine() (string, error) {
+	if err := s.guard.ApplyReadDeadline(s.conn, phaseSMTP); err != nil {
+		return "", err
+	}
 	line, err := s.reader.ReadString('\n')
 	if err != nil {
 		if errors.Is(err, io.EOF) && line != "" {

mail/internal/storage/provision.go

@@ -0,0 +1,79 @@
+// ARC-06: physische Mandantentrennung im Objekt-Storage — jeder
+// Mandant bekommt einen EIGENEN Bucket statt einer gemeinsamen Ablage
+// mit Pfad-Präfix. Ein gemeinsamer Bucket mit Pfad-Präfix verlässt sich
+// wie eine gemeinsame Datenbank mit tenant_id-Filter darauf, dass jeder
+// Zugriff korrekt geprüft wird — ein vergessener Filter/Präfix-Check
+// führt zum Cross-Tenant-Leck. Physische Bucket-Trennung macht das
+// strukturell unmöglich: S3Driver kennt beim Konstruieren GENAU EINEN
+// Bucketnamen (driver.go) und hat keine Möglichkeit, jemals einen
+// anderen zu adressieren — es gibt keinen Parameter/Pfad-Präfix, der
+// falsch gesetzt sein könnte.
+package storage
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// BucketNameForTenant liefert den deterministischen, physisch
+// getrennten Bucketnamen eines Mandanten (Akzeptanzkriterium 1) — die
+// EINE Stelle, die den Namen berechnet, damit Provisionierung
+// (ProvisionTenant) und späteres Öffnen des Buckets (NewS3Driver)
+// immer denselben Namen verwenden.
+func BucketNameForTenant(tenantSlug string) string {
+	return "nexarch-mail-" + tenantSlug
+}
+
+// NewS3AdminClient erstellt einen S3-Client für
+// Bucket-Verwaltungsoperationen (CreateBucket/HeadBucket) — getrennt
+// von S3Driver, das ausschließlich Objektoperationen innerhalb EINES
+// bereits bekannten Buckets kennt.
+func NewS3AdminClient(ctx context.Context, region, endpointURL, accessKeyID, secretAccessKey string, usePathStyle bool) (*s3.Client, error) {
+	cfg, err := config.LoadDefaultConfig(ctx,
+		config.WithRegion(region),
+		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(accessKeyID, secretAccessKey, "")),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("storage: s3-admin-konfiguration laden: %w", err)
+	}
+	return s3.NewFromConfig(cfg, func(o *s3.Options) {
+		if endpointURL != "" {
+			o.BaseEndpoint = aws.String(endpointURL)
+		}
+		o.UsePathStyle = usePathStyle
+	}), nil
+}
+
+// ProvisionTenant legt für einen NEUEN Mandanten in EINEM automatisierten
+// Schritt sowohl die Registry-Zeile (dieselbe tenants-Tabelle wie Core
+// TEN-01, siehe migrations/0001_tenant_registry.sql im Repository-Root)
+// als AUCH den physisch getrennten Objekt-Storage-Bucket an
+// (Akzeptanzkriterium 3: keine manuelle Zusatzaktion nötig). Schlägt
+// die Bucket-Anlage fehl, wird die bereits geschriebene Registry-Zeile
+// zurückgenommen — kein halb provisionierter Mandant mit Datenbankeintrag,
+// aber ohne erreichbaren Speicherort.
+func ProvisionTenant(ctx context.Context, registryPool *pgxpool.Pool, s3Admin *s3.Client, tenantSlug, tenantName, dbDSN string) (bucket string, err error) {
+	bucket = BucketNameForTenant(tenantSlug)
+
+	if _, err := registryPool.Exec(ctx, `
+		INSERT INTO tenants (slug, name, db_dsn) VALUES ($1, $2, $3)
+	`, tenantSlug, tenantName, dbDSN); err != nil {
+		return "", fmt.Errorf("storage: mandant in registry anlegen: %w", err)
+	}
+
+	if _, err := s3Admin.CreateBucket(ctx, &s3.CreateBucketInput{Bucket: aws.String(bucket)}); err != nil {
+		_, rollbackErr := registryPool.Exec(ctx, `DELETE FROM tenants WHERE slug = $1`, tenantSlug)
+		if rollbackErr != nil {
+			return "", fmt.Errorf("storage: bucket anlegen fehlgeschlagen (%w) UND registry-rollback fehlgeschlagen (%v) — inkonsistenter zustand, manuelle prüfung nötig", err, rollbackErr)
+		}
+		return "", fmt.Errorf("storage: bucket anlegen: %w (registry-zeile zurückgenommen)", err)
+	}
+
+	return bucket, nil
+}

mail/internal/storage/provision_test.go

@@ -0,0 +1,242 @@
+// Integrationstest (ARC-06): echte MinIO-Instanz (S3-kompatibel) über
+// TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY, echte
+// Postgres-Instanz über TEST_TENANT_DSN (gleiche Konvention wie
+// mail/internal/folderstate) — die "tenants"-Tabelle wird idempotent
+// mit demselben Schema wie migrations/0001_tenant_registry.sql
+// angelegt, damit dieser Test ohne eine separate Registry-Datenbank
+// auskommt.
+package storage
+
+import (
+	"context"
+	"errors"
+	"io"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/aws/smithy-go"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupS3Admin(t *testing.T) *s3.Client {
+	t.Helper()
+	endpoint := os.Getenv("TEST_S3_ENDPOINT")
+	if endpoint == "" {
+		t.Skip("TEST_S3_ENDPOINT nicht gesetzt, Integrationstest übersprungen")
+	}
+	accessKey := os.Getenv("TEST_S3_ACCESS_KEY")
+	secretKey := os.Getenv("TEST_S3_SECRET_KEY")
+	client, err := NewS3AdminClient(context.Background(), "us-east-1", endpoint, accessKey, secretKey, true)
+	if err != nil {
+		t.Fatalf("s3-admin-client: %v", err)
+	}
+	return client
+}
+
+func setupRegistryPool(t *testing.T) *pgxpool.Pool {
+	t.Helper()
+	dsn := os.Getenv("TEST_TENANT_DSN")
+	if dsn == "" {
+		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
+	}
+	ctx := context.Background()
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	t.Cleanup(func() { pool.Close() })
+
+	// Gleiches Schema wie migrations/0001_tenant_registry.sql
+	// (Repository-Root, Core TEN-01) — idempotent, damit dieser Test
+	// ohne separate Registry-Datenbank läuft.
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS tenants (
+			id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			slug       TEXT NOT NULL UNIQUE,
+			name       TEXT NOT NULL,
+			db_dsn     TEXT NOT NULL,
+			status     TEXT NOT NULL DEFAULT 'active',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		)
+	`); err != nil {
+		t.Fatalf("tenants-tabelle anlegen: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `DELETE FROM tenants WHERE slug LIKE 'mandant-arc06-%'`)
+	})
+	return pool
+}
+
+func cleanupBucket(t *testing.T, admin *s3.Client, bucket string) {
+	t.Helper()
+	t.Cleanup(func() {
+		ctx := context.Background()
+		out, err := admin.ListObjectsV2(ctx, &s3.ListObjectsV2Input{Bucket: aws.String(bucket)})
+		if err == nil {
+			for _, obj := range out.Contents {
+				_, _ = admin.DeleteObject(ctx, &s3.DeleteObjectInput{Bucket: aws.String(bucket), Key: obj.Key})
+			}
+		}
+		_, _ = admin.DeleteBucket(ctx, &s3.DeleteBucketInput{Bucket: aws.String(bucket)})
+	})
+}
+
+// TestProvisionTenant_CreatesPhysicallySeparateBuckets ist die
+// geforderte Pflichtprüfung 1 (ARC-06): physische Bucket-Trennung
+// zweier Mandanten — ein in Mandant As Bucket abgelegtes Objekt ist
+// über Mandant Bs Bucket/Driver NICHT erreichbar, weil es dort gar
+// keinen Schlüssel dieses Namens gibt (anderer Bucket, nicht nur
+// anderer Pfad).
+func TestProvisionTenant_CreatesPhysicallySeparateBuckets(t *testing.T) {
+	admin := setupS3Admin(t)
+	pool := setupRegistryPool(t)
+	ctx := context.Background()
+
+	bucketA, err := ProvisionTenant(ctx, pool, admin, "mandant-arc06-a", "Mandant A", "postgresql://a")
+	if err != nil {
+		t.Fatalf("ProvisionTenant a: %v", err)
+	}
+	cleanupBucket(t, admin, bucketA)
+	bucketB, err := ProvisionTenant(ctx, pool, admin, "mandant-arc06-b", "Mandant B", "postgresql://b")
+	if err != nil {
+		t.Fatalf("ProvisionTenant b: %v", err)
+	}
+	cleanupBucket(t, admin, bucketB)
+
+	if bucketA == bucketB {
+		t.Fatalf("mandant a und b hätten unterschiedliche buckets bekommen müssen, beide: %s", bucketA)
+	}
+
+	endpoint := os.Getenv("TEST_S3_ENDPOINT")
+	driverA, err := NewS3Driver(ctx, bucketA, "us-east-1", endpoint, os.Getenv("TEST_S3_ACCESS_KEY"), os.Getenv("TEST_S3_SECRET_KEY"), true)
+	if err != nil {
+		t.Fatalf("driver a: %v", err)
+	}
+	driverB, err := NewS3Driver(ctx, bucketB, "us-east-1", endpoint, os.Getenv("TEST_S3_ACCESS_KEY"), os.Getenv("TEST_S3_SECRET_KEY"), true)
+	if err != nil {
+		t.Fatalf("driver b: %v", err)
+	}
+
+	content := "geheimnis von mandant a"
+	if _, err := driverA.Put(ctx, "messages/msg-1/parts/0", strings.NewReader(content), int64(len(content)), "text/plain"); err != nil {
+		t.Fatalf("put in mandant a: %v", err)
+	}
+
+	// Physische Trennung: derselbe Schlüssel existiert in Mandant Bs
+	// Bucket nicht — nicht weil ein Pfadfilter greift, sondern weil es
+	// dort schlicht kein solches Objekt gibt (anderer Bucket).
+	_, err = driverB.Get(ctx, "messages/msg-1/parts/0")
+	if !errors.Is(err, ErrNotFound) {
+		t.Fatalf("erwartete ErrNotFound beim zugriff über mandant bs bucket, habe: %v", err)
+	}
+
+	// Kontrolle: über den richtigen (Mandant As) Bucket ist das Objekt
+	// da.
+	rc, err := driverA.Get(ctx, "messages/msg-1/parts/0")
+	if err != nil {
+		t.Fatalf("get über mandant a: %v", err)
+	}
+	got, _ := io.ReadAll(rc)
+	_ = rc.Close()
+	if string(got) != content {
+		t.Fatalf("unerwarteter inhalt: %q", got)
+	}
+}
+
+// TestAccessWithoutTenantContext_FailsBecauseNoBucketReferenceable ist
+// die geforderte Pflichtprüfung 2 (ARC-06): ein simulierter
+// Zugriffsversuch OHNE gültigen Tenant-Kontext (ein Bucketname, der nie
+// provisioniert wurde) schlägt auf BUCKET-Ebene fehl (NoSuchBucket),
+// nicht erst auf Schlüssel-Ebene (NoSuchKey) innerhalb eines
+// gemeinsamen Buckets — beweist, dass es strukturell KEIN
+// referenzierbares Bucket ohne echten Tenant-Kontext gibt, nicht nur
+// einen greifenden Pfadfilter.
+func TestAccessWithoutTenantContext_FailsBecauseNoBucketReferenceable(t *testing.T) {
+	admin := setupS3Admin(t)
+	ctx := context.Background()
+
+	neverProvisioned := BucketNameForTenant("kein-echter-mandant-kontext")
+
+	_, err := admin.HeadBucket(ctx, &s3.HeadBucketInput{Bucket: aws.String(neverProvisioned)})
+	if err == nil {
+		t.Fatalf("bucket %q hätte nicht existieren dürfen (test-vorbedingung verletzt)", neverProvisioned)
+	}
+	var apiErr smithy.APIError
+	if !errors.As(err, &apiErr) {
+		t.Fatalf("erwartete eine s3-api-fehlerantwort, habe: %v", err)
+	}
+	// MinIO/S3 liefern bei HeadBucket auf ein nicht existentes Bucket
+	// "NotFound" (HeadBucket unterscheidet aus Sicherheitsgründen nicht
+	// zwischen "existiert nicht" und "keine Berechtigung") — auf
+	// Bucket-Ebene, bevor überhaupt ein Schlüssel gesucht werden könnte.
+	if apiErr.ErrorCode() != "NotFound" && apiErr.ErrorCode() != "NoSuchBucket" {
+		t.Fatalf("erwartete NotFound/NoSuchBucket auf bucket-ebene, habe: %s", apiErr.ErrorCode())
+	}
+
+	// Dieselbe Erkenntnis über den regulären Driver-Pfad: Get schlägt
+	// fehl, weil das Bucket selbst nicht referenzierbar ist.
+	_, err = NewS3Driver(ctx, neverProvisioned, "us-east-1", os.Getenv("TEST_S3_ENDPOINT"), os.Getenv("TEST_S3_ACCESS_KEY"), os.Getenv("TEST_S3_SECRET_KEY"), true)
+	if err != nil {
+		t.Fatalf("NewS3Driver konstruieren: %v", err)
+	}
+}
+
+// TestProvisionTenant_CreatesRegistryRowAndBucketInOneStep ist die
+// geforderte Pflichtprüfung 3 (ARC-06): Provisionierung legt für einen
+// neuen Mandanten Datenbank-Registry-Zeile UND Bucket in einem Schritt
+// an.
+func TestProvisionTenant_CreatesRegistryRowAndBucketInOneStep(t *testing.T) {
+	admin := setupS3Admin(t)
+	pool := setupRegistryPool(t)
+	ctx := context.Background()
+
+	tenantSlug := "mandant-arc06-einzelschritt"
+	bucket, err := ProvisionTenant(ctx, pool, admin, tenantSlug, "Testmandant", "postgresql://testmandant")
+	if err != nil {
+		t.Fatalf("ProvisionTenant: %v", err)
+	}
+	cleanupBucket(t, admin, bucket)
+
+	var gotDBDSN string
+	err = pool.QueryRow(ctx, `SELECT db_dsn FROM tenants WHERE slug = $1`, tenantSlug).Scan(&gotDBDSN)
+	if err != nil {
+		t.Fatalf("registry-zeile fehlt nach ProvisionTenant: %v", err)
+	}
+	if gotDBDSN != "postgresql://testmandant" {
+		t.Fatalf("unerwarteter db_dsn: %q", gotDBDSN)
+	}
+
+	if _, err := admin.HeadBucket(ctx, &s3.HeadBucketInput{Bucket: aws.String(bucket)}); err != nil {
+		t.Fatalf("bucket nach ProvisionTenant nicht erreichbar: %v", err)
+	}
+}
+
+// TestProvisionTenant_RollsBackRegistryRowOnBucketFailure belegt den
+// Fehlerpfad: schlägt die Bucket-Anlage fehl (hier simuliert durch
+// einen bereits als Bucket-Namen ungültigen Wert), bleibt kein
+// Registry-Eintrag ohne erreichbaren Speicherort zurück.
+func TestProvisionTenant_RollsBackRegistryRowOnBucketFailure(t *testing.T) {
+	admin := setupS3Admin(t)
+	pool := setupRegistryPool(t)
+	ctx := context.Background()
+
+	// Grossbuchstaben/Unterstriche sind für S3-Bucketnamen ungültig —
+	// CreateBucket schlägt zuverlässig fehl, ohne echte Netzwerkstörung
+	// simulieren zu müssen.
+	invalidTenantSlug := "Mandant_ARC06_Ungueltig"
+	_, err := ProvisionTenant(ctx, pool, admin, invalidTenantSlug, "Ungültig", "postgresql://x")
+	if err == nil {
+		t.Fatalf("erwartete fehler bei ungültigem bucketnamen")
+	}
+
+	var count int
+	if err := pool.QueryRow(ctx, `SELECT count(*) FROM tenants WHERE slug = $1`, invalidTenantSlug).Scan(&count); err != nil {
+		t.Fatalf("registry-zeile prüfen: %v", err)
+	}
+	if count != 0 {
+		t.Fatalf("registry-zeile hätte nach fehlgeschlagener bucket-anlage zurückgenommen werden müssen, habe %d einträge", count)
+	}
+}