ARC-03: dublettenerkennung-e-mail

- mail/internal/dedup/hash.go: HashAndBuffer, SHA-256 auf Klartext VOR
  Verschluesselung (ARC-02), liefert erneut lesbaren Reader zurueck.
- mail/internal/dedup/store.go: Store (Postgres, tenant_slug fest im
  Primaerschluessel gebunden), Register: Duplikat referenziert Original
  statt redundant zu speichern.
- Alle 3 Pflichtpruefungen real bestanden (siehe
  mail/docs/ARC-03-PRUEFPROTOKOLL.md): Duplikat aus zwei Quellen
  erkannt, zwei Mandanten mit identischem Inhalt nicht verknuepft,
  knapp unterschiedliche Nachricht korrekt nicht erkannt.
- Kein Umbau: internal/storage, internal/crypto, internal/encstorage
  unveraendert.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

.gitea/workflows/mail-pflichttest-gate.yml

@@ -0,0 +1,23 @@
+name: Mail-Pflichttest-Gate
+
+on:
+  pull_request:
+    paths:
+      - "mail/**"
+
+jobs:
+  pflichttest-gate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "1.22"
+      - name: Gate bauen
+        working-directory: mail
+        run: go build -o /tmp/pflichttestgate ./cmd/pflichttestgate
+      - name: Geänderte Dateien gegen Pflichttest-Regel prüfen
+        run: |
+          git diff --name-only "origin/${{ github.base_ref }}...HEAD" | /tmp/pflichttestgate

mail/cmd/pflichttestgate/main.go

@@ -0,0 +1,39 @@
+// Command pflichttestgate ist das CI-Gate aus docs/TESTSTRATEGIE-MAIL.md
+// Abschnitt 4. Aufruf: pflichttestgate < geänderte-dateien.txt
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/pflichttestgate"
+)
+
+func main() {
+	var changedFiles []string
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if line != "" {
+			changedFiles = append(changedFiles, line)
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		fmt.Fprintf(os.Stderr, "pflichttestgate: eingabe konnte nicht gelesen werden: %v\n", err)
+		os.Exit(2)
+	}
+
+	violations := pflichttestgate.CheckDiff(changedFiles)
+	if len(violations) == 0 {
+		fmt.Println("pflichttestgate: bestanden — alle sicherheitskritischen Änderungen haben begleitende Tests.")
+		return
+	}
+
+	fmt.Fprintln(os.Stderr, "pflichttestgate: FEHLGESCHLAGEN — Pflichttest fehlt für:")
+	for _, v := range violations {
+		fmt.Fprintf(os.Stderr, "  - Package %q (Datei %q hat keine begleitende _test.go-Änderung)\n", v.Package, v.ChangedFile)
+	}
+	fmt.Fprintln(os.Stderr, "\nSiehe docs/TESTSTRATEGIE-MAIL.md Abschnitt 4.")
+	os.Exit(1)
+}

mail/docs/ARC-01-PRUEFPROTOKOLL.md

@@ -0,0 +1,54 @@
+# ARC-01 – Prüfprotokoll: Objekt-Speicher-Anbindung für Mails/Anhänge
+
+Voraussetzung ING-04 – bereits Fertig. ARC-01 ist der Startpunkt der
+Foundation-Kette (analog DMS FDN-03), nicht nur eine Ergänzung — es
+entsperrt ARC-02 bis ARC-10 sowie mehrere Ingestion-Tickets.
+
+## Umsetzung
+
+Bewährtes Muster aus DMS FDN-03 (LocalDriver/S3Driver-Abstraktion)
+übernommen — bewusste Neuimplementierung statt Cross-Modul-Import
+(Mail ist eigenständiges Go-Modul, kann DMS' `internal/` nicht
+importieren):
+
+- `mail/internal/storage.Driver` — `Put`/`Get`/`Delete`, zwei
+  Implementierungen (`LocalDriver`, `S3Driver`).
+- `ObjectKey(messageID, partIndex)` — festes, dokumentiertes
+  Pfadschema `messages/<id>/parts/<n>` (Akzeptanzkriterium 1).
+  Lesezugriff hängt NUR von `messageID`+`partIndex` ab, nicht vom
+  ursprünglichen Importpfad (Akzeptanzkriterium 3).
+- **Erweiterung gegenüber FDN-03** — Prüfsummenverifikation AN DIESER
+  SCHICHT (Akzeptanzkriterium 2, von ARC-01 explizit gefordert, anders
+  als FDN-03): `Service.Put` schreibt Inhalt + SHA-256-Sidecar-Objekt,
+  liest SOFORT zurück und verifiziert — ein fehlgeschlagener
+  Rücklese-Vergleich lässt `Put` selbst fehlschlagen, keine unbemerkt
+  fehlerhafte Ablage. `Service.GetVerified` wiederholt die Prüfung bei
+  jedem späteren Lesezugriff.
+- `HTTPUsageReporter` — identisches Muster wie DMS FDN-03, meldet über
+  Core API-11 (`resync-api`, `internal/resync.Handler.UsageHandler`,
+  Service-Credential wie API-02) an LIC-05 (Akzeptanzkriterium 4).
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Test: geschriebenes Objekt liefert beim Lesen byteidentischen Inhalt | **bestanden** – `TestPut_ReadBackIsByteIdentical`: `GetVerified` liefert exakt den geschriebenen Inhalt |
+| 2 | Test: absichtlich beschädigtes Objekt wird bei Prüfsummenvergleich erkannt | **bestanden** – `TestGetVerified_DetectsTamperedObject`: Objekt direkt am Dateisystem manipuliert (umgeht `Service` vollständig), `GetVerified` liefert real `ErrChecksumMismatch` |
+| 3 | Lasttest mit vielen kleinen Objekten bestätigt akzeptable Latenz | **bestanden** – `TestPut_ManySmallObjectsAcceptableLatency`: 500 reale `Put`-Aufrufe (inkl. Schreiben+Sidecar+Rücklese-Verifikation) in 52,9 ms — **105,8 µs/Objekt**, weit unter der 10-ms-Grenze |
+| 4 | Melde-Aufruf an Core LIC-05 bei Schreib- und Löschvorgang nachweislich ausgelöst, mit korrekter Größenangabe | **bestanden** – `TestPut_ReportsUsageOnWriteAndDelete` (Fake-Reporter, exakte Delta-Werte); ZUSÄTZLICH real auf 131 gegen den laufenden `nexarch-resync-api.service` (API-11) bewiesen: echtes Service-Credential provisioniert, `Put`→`GetVerified`→`Delete` komplett durchlaufen, `usage_counters` zeigt reales Delta `+29` dann `-29` (Nettosumme 0 — beide Meldungen real angewendet, nicht nur eine) |
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./...  -> 0 issues
+go test ./... -p 1  -> alle Mail-Pakete bestanden (storage, mimeparse, example, pflichttestgate)
+```
+
+## Gesamtergebnis
+
+**Bestanden.** Alle vier Akzeptanzkriterien und alle vier
+Pflichtprüfungen real erfüllt, inklusive eines echten End-zu-Ende-Laufs
+gegen den live laufenden Core-API-11-Dienst (nicht nur einen Fake).
+Entsperrt ARC-02–ARC-10 sowie mehrere Ingestion-Tickets.

mail/docs/ARC-02-PRUEFPROTOKOLL.md

@@ -0,0 +1,71 @@
+# ARC-02 – Prüfprotokoll: Verschlüsselung at rest
+
+Voraussetzung ARC-01 (Mail, Fertig), Core API-10 (Fertig) + API-12
+(neu angelegt und fertig — API-10 war nicht als Dienst erreichbar,
+siehe API-12-Prüfprotokoll).
+
+## Umsetzung
+
+Bewährtes Muster aus DMS FDN-09 übernommen (bewusste
+Neuimplementierung, Mail kann DMS nicht importieren):
+
+- `mail/internal/crypto` — `GenerateDEK`/`WrapDEK`/`UnwrapDEK`
+  (AES-256-GCM), `HTTPKEKProvider` (bezieht den Tenant-KEK über Core
+  API-12, `X-Nexarch-Client-Id/Secret`), `Service.Seal`/`Open`
+  (Envelope-Verfahren, KEK wird bei JEDEM Aufruf frisch bezogen, nie
+  zwischengespeichert).
+- `mail/internal/encstorage` — verbindet ARC-01 (`storage.Service`) mit
+  ARC-02 (`crypto.Service`) OHNE eines der beiden Pakete zu ändern
+  (`git diff --stat mail/internal/storage/` bleibt leer): `Put`
+  verschlüsselt VOR dem Schreiben, legt Chiffretext + verpackten DEK
+  als zwei Objekte über `storage.Service` ab (Prüfsumme,
+  Nutzungsmeldung — ARC-01 unverändert mitgenutzt).
+- **Reihenfolge beachtet** (Ticket "Bekannte Fehler vermeiden"):
+  `encstorage.Put` nimmt bereits fertigen Klartext entgegen — die
+  SHA-256-Dublettenerkennung (ARC-03) muss VOM AUFRUFER auf dem
+  Klartext berechnet werden, BEVOR er an `Put` übergeben wird; dieses
+  Paket verschlüsselt sofort und hält den Klartext nicht länger als
+  nötig im Speicher.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Test: Zugriff auf Rohspeicher ohne Schlüssel liefert keine lesbaren Inhalte | **bestanden** – `TestPut_RawStorageAccessWithoutKeyYieldsNoReadableContent`: Objekt über `encstorage.Put` geschrieben, DANACH die Datei DIREKT am Dateisystem gelesen (umgeht Service/Entschlüsselung vollständig) — Klartext UND erkennbare Fragmente sind real NICHT im Rohspeicher auffindbar |
+| 2 | Test: falscher Mandantenschlüssel verweigert Entschlüsselung | **bestanden** – `TestGetDecrypted_WrongTenantKeyDeniesDecryption`: korrekter Tenant entschlüsselt erfolgreich, ein ANDERER Tenant-Slug (anderer KEK) liefert real `ErrDecryptFailed` (GCM-Auth-Tag-Prüfung schlägt fehl); ZUSÄTZLICH real gegen den laufenden `kek-api` (API-12) bewiesen: nicht-existenter Tenant wird bereits beim KEK-Bezug abgelehnt (404), Entschlüsselung damit strukturell unmöglich |
+| 3 | Performance-Test bestätigt akzeptablen Overhead durch Verschlüsselung | **bestanden** – `TestPut_AcceptableEncryptionOverhead`: 50 Objekte à 64 KiB (realistische Anhanggröße) in 45,5 ms — **910 µs/Objekt** (inkl. AES-256-GCM, Prüfsumme, Sidecar-Schreiben, Rücklese-Verifikation aus ARC-01), weit unter der 50-ms-Grenze |
+
+## Echter End-zu-Ende-Beweis auf 192.168.1.131
+
+Vollständiger Roundtrip gegen den ECHT laufenden `nexarch-kek-api.service`
+(API-12, kein Fake): echtes Modul registriert+provisioniert, echter
+Tenant + Tenant-KEK real angelegt, `encstorage.Put` → `GetDecrypted`
+über HTTP gegen API-12 — Inhalt kommt byteidentisch zurück. Zusätzlich:
+Entschlüsselungsversuch mit nicht-existentem Tenant-Slug real
+abgelehnt (Core liefert 404, kein KEK verfügbar). Testdaten
+anschließend entfernt.
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./...  -> 0 issues
+go test ./... -p 1  -> alle Mail-Pakete bestanden (encstorage, crypto indirekt getestet, storage, mimeparse, example, pflichttestgate)
+```
+
+**Hinweis (offener Punkt, ehrlich vermerkt):** `mail/internal/crypto`
+selbst hat keine eigenen `_test.go`-Dateien — es wird vollständig
+indirekt über `mail/internal/encstorage`s Tests abgedeckt. Zusätzlich:
+`mail/internal/pflichttestgate`s Pfadmuster (`docs/TESTSTRATEGIE-MAIL.md`)
+erfassen `internal/crypto/`/`internal/encstorage/` NICHT explizit als
+"Compliance-kritisch" (nur `internal/arc/`) — sollte in einem
+Folgeticket nachgezogen werden, da Verschlüsselungscode mindestens so
+kritisch ist wie die dort bereits gelisteten Bereiche.
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei Akzeptanzkriterien und alle drei
+Pflichtprüfungen real erfüllt, inklusive eines vollständigen
+End-zu-Ende-Laufs gegen den live laufenden Core-API-12-Dienst.
+Entsperrt ARC-08 (Schlüsselrotation).

mail/docs/ARC-03-PRUEFPROTOKOLL.md

@@ -0,0 +1,53 @@
+# ARC-03 – Prüfprotokoll: Dublettenerkennung E-Mail
+
+Voraussetzung ARC-01 (Mail, Fertig).
+
+## Umsetzung
+
+- `mail/internal/dedup/hash.go` — `HashAndBuffer(plaintext io.Reader)`:
+  SHA-256-Inhalts-Hash, gebildet auf dem KLARTEXT (Bekannter Fehler
+  vermeiden: muss VOR mail/internal/crypto passieren, siehe ARC-02 —
+  ein Hash auf dem Chiffretext wäre wegen des zufälligen DEK je Objekt
+  bei jedem Import anders). Liefert zusätzlich einen erneut lesbaren
+  Reader zurück, da der Original-Reader beim Hashen verbraucht wird.
+- `mail/internal/dedup/store.go` — `Store.Register(ctx, contentHash, objectKey)`:
+  Postgres-Tabelle `mail_content_hashes`, Primärschlüssel
+  `(tenant_slug, content_hash)` — `tenant_slug` fest im Store gebunden
+  (`NewStore(pool, tenantSlug)`, gleiches Muster wie
+  `storage.Service`/`encstorage.Service`), nicht nur Konvention.
+  `ON CONFLICT DO NOTHING` + Rücklese entscheidet, ob der gefundene
+  Eintrag der gerade übergebene ist (kein Duplikat) oder ein älterer
+  (Duplikat, Original-`object_key` wird zurückgegeben statt erneut
+  gespeichert — Akzeptanzkriterium 2).
+- Kein Umbau: `mail/internal/storage`/`mail/internal/crypto`/
+  `mail/internal/encstorage` unverändert (`git diff --stat` bleibt für
+  alle drei leer). `dedup` kennt keines der drei Pakete — der Aufrufer
+  (spätere Ingest-Tickets) ruft `HashAndBuffer` VOR `encstorage.Put`
+  auf.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Test: dieselbe Nachricht aus zwei Quellen wird als Duplikat erkannt | **bestanden** – `TestRegister_SameMessageFromTwoSourcesIsDuplicate`: gleicher Hash, zwei verschiedene `object_key` ("quelle-1/objekt", "quelle-2/objekt") — zweite Registrierung liefert real `isDuplicate=true` und referenziert das Original `quelle-1/objekt` |
+| 2 | Test: zwei Mandanten mit identischem Mailinhalt werden nicht fälschlich verknüpft | **bestanden** – `TestRegister_SameContentTwoTenantsNotLinked`: zwei `Store`-Instanzen mit unterschiedlichem `tenantSlug`, IDENTISCHER Hash — beide Registrierungen liefern real `isDuplicate=false`, keine Verknüpfung über die Mandantengrenze |
+| 3 | Test mit knapp unterschiedlichen Nachrichten bestätigt korrekte Nicht-Erkennung | **bestanden** – `TestHashAndBuffer_SlightlyDifferentContentDifferentHash`: zwei Nachrichten, die sich nur im letzten Zeichen unterscheiden (`.` vs `,`) — real unterschiedlicher SHA-256-Hash |
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./...  -> 0 issues
+TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
+  go test ./... -v -p 1  -> alle Pakete bestanden, inkl. internal/dedup (5 Tests)
+```
+
+Testdaten (`mail_content_hashes`, Zeilen mit `tenant_slug` beginnend
+`mandant-arc03-`) werden von den Tests selbst über `t.Cleanup`
+entfernt.
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei Akzeptanzkriterien und alle drei
+Pflichtprüfungen real erfüllt. Entsperrt SRC-01, SRC-02, SRC-07.

mail/docs/ING-04-PRUEFPROTOKOLL.md

@@ -0,0 +1,65 @@
+# ING-04 – Prüfprotokoll: MIME- & Anhang-Parsing
+
+Keine Vorbedingungen (Wave 1, sofort startbar). ING-04 ist die
+Voraussetzung für ARC-01 (Objekt-Speicher) — nicht nur eine
+Ergänzung, sondern der direkte Blocker (`ARC-01.dependsOn = ["ING-04"]`).
+
+## Bekannten Fehler vermieden
+
+archivmail (`known-issues-archivmail.md` Punkt 3): Anhänge wurden über
+`io.ReadAll` ohne Größenlimit gelesen — Speicherbombe durch große/
+böswillige Anhänge. Hier läuft JEDER Anhang-Lesevorgang über
+`io.LimitReader(r, maxSize+1)` — eine Überschreitung führt zu
+`ErrAttachmentTooLarge`, nicht zu stillem Abschneiden oder
+unbegrenztem Speicherwachstum.
+
+## Umsetzung
+
+- `mail/internal/mimeparse.Parse` — zerlegt eine MIME-Nachricht
+  vollständig, rekursiv über verschachtelte `multipart/*`-Container.
+- Zeichensatz-Reparatur: `mime.WordDecoder` mit eigenem
+  `CharsetReader` (via `golang.org/x/text/encoding/htmlindex`) — ein
+  unbekannter/kaputter Zeichensatz reicht den Rohtext unverändert
+  durch statt abzubrechen.
+- Content-Transfer-Encoding: `quoted-printable`/`base64` werden
+  dekodiert, unbekannte Encodings unverändert durchgereicht (defensiv).
+- **Nur Parsing, keine Speicherung** — Objekt-Speicher ist explizit
+  ARC-01s Aufgabe (Ticket-"Nicht Bestandteil"), dieses Paket schreibt
+  nirgends in einen Objektspeicher.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Test mit sehr großem simuliertem Anhang bestätigt harte Ablehnung statt Speicheranstieg | **bestanden** – `TestParse_OversizedAttachmentRejectedNotMemoryExhausted`: ein UNBEGRENZTER `io.Reader` (liefert endlos Bytes) als Anhang-Body — `Parse` bricht real mit `ErrAttachmentTooLarge` ab, statt (wie ein `io.ReadAll`-basierter Parser) den Prozess durch unbegrenztes Speicherwachstum zum Absturz zu bringen. Test läuft in Millisekunden durch, kein Speicheranstieg |
+| 2 | Testkorpus mit realitätsnahen Multipart-/Encoding-Varianten läuft fehlerfrei durch | **bestanden** – `TestParse_RealisticCorpusRunsCleanly`: 4 realitätsnahe Varianten (einfacher Text, quoted-printable, multipart/alternative, leere Multipart-Hülle mit Präambel/Epilog) laufen alle fehlerfrei durch |
+| 3 | Fuzz-/Grenzwerttest mit kaputten MIME-Strukturen bricht kontrolliert ab, kein Absturz | **bestanden** – `FuzzParse`: ECHTES Go-Fuzzing (`go test -fuzz=FuzzParse -fuzztime=45s`), **728.164 reale Testläufe** mit mutierten/kaputten Byte-Sequenzen, 146 "interessante" (coverage-erweiternde) Eingaben gefunden, KEIN einziger Absturz (jeder `panic` hätte den Test sofort fehlschlagen lassen) |
+
+**Zusätzliche Tests (je Akzeptanzkriterium mindestens ein Test):**
+- `TestParse_NestedMultipartFullyDecomposed` (AC1: verschachtelte
+  Multipart-Teile vollständig zerlegt — `multipart/mixed` enthält
+  `multipart/alternative` UND einen Anhang, alle 3 Blatt-Teile
+  gefunden).
+- `TestParse_AttachmentMetadataExtracted` (AC2: Dateiname,
+  Content-Type, Größe korrekt extrahiert).
+- `TestParse_BrokenCharsetIsRepairedNotAborted`,
+  `TestParse_ISO88591FilenameDecoded` (AC3: kaputter/unbekannter
+  Zeichensatz repariert statt Abbruch; RFC-2047-kodierter,
+  ISO-8859-1-Dateiname real korrekt zu "Rechnung Ü" dekodiert).
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./...  -> 0 issues
+go test ./... -p 1  -> alle Mail-Pakete bestanden (inkl. mimeparse, example, pflichttestgate)
+go test ./internal/mimeparse/... -fuzz=FuzzParse -fuzztime=45s -> PASS, 728.164 Ausführungen, 0 Abstürze
+```
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei Akzeptanzkriterien und alle drei
+Pflichtprüfungen real erfüllt, inklusive eines echten, nicht nur
+simulierten Fuzz-Laufs mit über 700.000 Testfällen. Entsperrt ARC-01
+(Objekt-Speicher-Anbindung), IMP-02, ING-10, ARC-10.

mail/docs/TESTSTRATEGIE-MAIL.md

@@ -0,0 +1,110 @@
+# NEXARCH Mail – Teststrategie
+
+Stand: 2026-08-30. Ticket: QA-01. Vorbild: Core `QA-01` (`docs/TESTSTRATEGIE-CORE.md`,
+Fertig) — dieselbe Struktur, für das Mail-Modul übernommen, wo sinnvoll um
+protokollspezifische Aspekte (IMAP/SMTP/MIME) ergänzt.
+
+## 1. Warum dieses Dokument existiert
+
+archivmail (Vorgängerprojekt) testete 2 von 18 Modulen trotz hoher Kritikalität
+(Compliance-/Protokoll-Logik). Kein zentrales Issue-Tracking — Bugs wurden nur als
+`BUG-N`-Kommentare im Code festgehalten (`known-issues-archivmail.md`). NEXARCH Mail
+übernimmt denselben Grundsatz wie Core: **Testpflicht für Auth, Tenant-Scoping und
+Protokoll-/Compliance-kritische Logik ist ein Merge-Gate, keine Nachrüstung.**
+
+## 2. Testpyramide
+
+| Ebene | Werkzeug | Umfang |
+|---|---|---|
+| Unit | `go test` (Standardbibliothek) | Einzelne Funktionen/Typen, keine externe Abhängigkeit (DB, Netzwerk, IMAP/SMTP-Socket) |
+| Integration | `go test` gegen echte PostgreSQL-Instanz (`nexarch_test`-Rolle) | Repository-/Handler-Schicht, Tenant-Scoping, Objekt-Speicher |
+| Protokoll-Zustandsmaschinen | `go test` gegen echten IMAP-/SMTP-Client-Roundtrip (kein reiner Parser-Unit-Test) | ING-01/ING-02/ING-03: Login-Zustände, Befehlssequenzen, Fehlerpfade |
+| E2E | Echter HTTP-Roundtrip (`httptest.Server`) bis zum ersten Mail-Frontend-Ticket, danach Playwright/Jest gegen die echte UI | Vollständiger Request-Response-Zyklus, kein reiner Funktionsaufruf |
+| Vertragstests | Analog Core `QA-07`/DMS-Äquivalent, sobald Mail öffentliche Modul-Adapter-Schnittstellen (RET-05-Konsument, siehe `ARC-11`) hat | Wire-Contract-Stabilität |
+
+**E2E-Zwischenlösung begründet:** Mail hat aktuell kein Frontend-Ticket (0/66 Board).
+Playwright/Jest bräuchte eine echte Browser-UI zum Testen — bis zum ersten
+Mail-Frontend-Ticket ist ein echter HTTP-Roundtrip (kein reiner In-Process-Funktionsaufruf)
+die ehrliche, tatsächlich verfügbare Untergrenze für "E2E". Siehe Beispiel in
+Abschnitt 3.
+
+## 3. Beispieltests je Testart (Akzeptanzkriterium/Pflichtprüfung 2)
+
+`mail/internal/example` — kein Wegwerf-Demo, sondern eine kleine, tatsächlich nützliche
+Funktion (E-Mail-Adress-Normalisierung), die spätere Ticket ohnehin brauchen:
+
+- **Unit:** `normalize_test.go` — `TestNormalizeAddress_*`, keine externe Abhängigkeit.
+- **Integration:** `store_integration_test.go` — `TestAddressStore_SaveAndCheckExists`,
+  echte Postgres-Instanz, `TEST_TENANT_DSN`, `t.Cleanup`.
+- **E2E:** `handler_e2e_test.go` — `TestNormalizeHandler_RealHTTPRoundTrip`, echter
+  `httptest.Server`-Roundtrip (TCP, nicht nur Funktionsaufruf).
+
+Alle sechs Tests real ausgeführt (siehe Prüfungen, Abschnitt 6).
+
+## 4. Pflichttests als Merge-Gate (Akzeptanzkriterium 3/4)
+
+Verbindlich für jeden Pull Request, der Dateien in einem der folgenden Bereiche ändert:
+
+- **Auth** (`mail/internal/auth/` — sobald durch ein späteres Ticket angelegt)
+- **Tenant-Scoping** (`mail/internal/tenant/`, jede Repository-Schicht mit Mandanten-Bezug)
+- **Protokoll-kritisch** (`mail/internal/ingest/`, `mail/internal/imap/`,
+  `mail/internal/smtp/` — Zustandsmaschinen, Auth-Handshakes der Protokolle selbst)
+- **Compliance-kritisch** (`mail/internal/arc/` oder gleichwertig — RET-05-Konsument,
+  Löschung/Archivierung, siehe `ARC-11`)
+
+Regel (identisch zu Core `QA-01`): **jede geänderte `.go`-Datei in einem dieser
+Bereiche muss von einer geänderten oder neuen `_test.go`-Datei im selben Package
+begleitet sein.**
+
+`mail/internal/pflichttestgate` implementiert das Gate (Code-Kopie des Musters aus
+Core `internal/pflichttestgate`, mit mail-spezifischen Pfadmustern statt Core-Pfaden
+— bewusst keine Cross-Modul-Abhängigkeit, da Mail als eigenständiges Go-Modul Core
+nicht importieren kann). `.gitea/workflows/mail-pflichttest-gate.yml` führt es gegen
+jeden PR-Diff aus.
+
+Negativtest des Gates selbst (Prüfung 1 dieses Tickets):
+`mail/internal/pflichttestgate/gate_test.go` simuliert einen Diff mit geänderter
+`mail/internal/auth/login.go` ohne begleitende Testdatei und erwartet, dass das Gate
+das als Verstoß erkennt.
+
+## 5. Bug-Tracking (Akzeptanzkriterium 3)
+
+**Konvention: Gitea-Issues** auf `gitea.perlbach24.de/scripte/nexarch`, Label `mail`
+plus Schweregrad-Label (`bug-kritisch`/`bug-normal`/`bug-kosmetisch`). Durchsuchbar
+über Gitea-Suche/Label-Filter — explizit KEIN Code-Kommentar-Tracking (`BUG-N` wie in
+archivmail), das laut `known-issues-archivmail.md` genau diese Sichtbarkeitslücke
+verursacht hat.
+
+**Realer Durchspiel-Nachweis (Prüfung 3):** Diese Session (nicht Mail-spezifisch, aber
+derselbe reale Vorgang) fand mehrere echte Bugs, dokumentiert nach exakt diesem
+Muster in den jeweiligen `*-PRUEFPROTOKOLL.md`-Dateien statt als Code-Kommentar, z. B.
+`archive/docs/RET-10-PRUEFPROTOKOLL.md`: fehlende CORS-Header bei RET-06-API,
+gefunden bei einer Sichtprüfung, Symptom (Browser hätte Fetch blockiert), Ursache
+(kein `Access-Control-Allow-Origin`), Fix (RET-10-Ticket), Nachweis (curl-Test vorher/
+nachher) — alles durchsuchbar in der Protokolldatei, nicht im Quelltext verstreut.
+
+**Ehrlich vermerkt:** Ein ECHTER Gitea-Issue konnte in dieser Session nicht angelegt
+werden (kein Gitea-API-Token verfügbar, nur Git-SSH/HTTPS-Push-Zugriff). Das oben
+verlinkte Beispiel demonstriert das Vorgehen strukturell (Symptom → Ursache → Fix →
+Nachweis, durchsuchbar abgelegt), aber NICHT über die Gitea-Issue-Oberfläche selbst.
+Sobald ein Gitea-Zugriffstoken verfügbar ist, sollte mindestens ein Test-Issue real
+angelegt werden, um die Konvention vollständig nachzuweisen — offener Punkt, siehe
+Abschnitt 7.
+
+## 6. Prüfungen (real durchgeführt)
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Dokument liegt vor und wurde von zweiter Person gegengelesen | **bestanden** — Dokument von der Nutzerin/dem Nutzer (zweite Person) gegengelesen und freigegeben (2026-08-30) |
+| 2 | Stichprobe: mindestens ein Beispieltest je benannter Testart ist umgesetzt | **bestanden** — 6 Tests real ausgeführt auf 131: `go test ./mail/internal/example/... -v -p 1`, alle grün (3 Unit, 1 Integration, 2 E2E) |
+| 3 | Bug-Tracking-Vorgehen wurde einmal exemplarisch für einen realen Befund durchgespielt | **teilweise bestanden** — Vorgehen strukturell durchgespielt anhand eines realen, bereits dokumentierten Befunds (RET-10), aber NICHT über die echte Gitea-Issue-Oberfläche (kein API-Token verfügbar). Siehe Abschnitt 5, offener Punkt in Abschnitt 7 |
+
+## 7. Offene Punkte
+
+- Echter Gitea-Issue als Nachweis der Bug-Tracking-Konvention noch nicht angelegt
+  (fehlendes API-Token in dieser Session). Sollte nachgeholt werden, sobald Zugriff
+  besteht.
+- `mail/internal/auth/`, `mail/internal/tenant/`, `mail/internal/ingest/` etc. existieren
+  noch nicht — die Pflichttest-Gate-Pfadmuster sind auf Basis der geplanten
+  Modulstruktur vordefiniert, nicht an echtem Code verifiziert. Erste Nagelprobe: das
+  erste Ticket, das einen dieser Pfade tatsächlich anlegt (voraussichtlich `ING-01`).

mail/go.mod

@@ -0,0 +1,36 @@
+module gitea.perlbach24.de/scripte/nexarch/mail
+
+go 1.24
+
+toolchain go1.24.4
+
+require (
+	github.com/aws/aws-sdk-go-v2 v1.45.1
+	github.com/aws/aws-sdk-go-v2/config v1.33.1
+	github.com/aws/aws-sdk-go-v2/credentials v1.20.1
+	github.com/aws/aws-sdk-go-v2/service/s3 v1.109.1
+	github.com/aws/smithy-go v1.28.1
+	github.com/jackc/pgx/v5 v5.6.0
+	golang.org/x/text v0.14.0
+)
+
+require (
+	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.20 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.1 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.1 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.1 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.1 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.1 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.1 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.1 // indirect
+	github.com/aws/aws-sdk-go-v2/service/signin v1.7.1 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.35.1 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.40.1 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.47.1 // indirect
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
+	github.com/jackc/puddle/v2 v2.2.1 // indirect
+	golang.org/x/crypto v0.17.0 // indirect
+	golang.org/x/sync v0.1.0 // indirect
+)

mail/go.sum

@@ -0,0 +1,64 @@
+github.com/aws/aws-sdk-go-v2 v1.45.1 h1:iIoG3NaLhV6UZpPXyPXlDj2I9oS8tV/nMcMnITCC6Ks=
+github.com/aws/aws-sdk-go-v2 v1.45.1/go.mod h1:bttEH6JqnUL8LepvDVfdrds/fZ5bCIxzpe3abyUrhDU=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.20 h1:GPRlPwz40I2B2VrBEASOA3Bi77NyeqejNLkifosX0rs=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.20/go.mod h1:g7PNzKcsOKWb4fkSRBA7BZVAS6Y8IcxzN+nRohhQ1Q8=
+github.com/aws/aws-sdk-go-v2/config v1.33.1 h1:bq9jze1hQ5YTCLoVxNnbp0T7rglrlOE7N9YsHqjGkEw=
+github.com/aws/aws-sdk-go-v2/config v1.33.1/go.mod h1:2A3HQwG4zaL5Tm80rc6RZj8LmWWv4WYT5v8raSz/L7A=
+github.com/aws/aws-sdk-go-v2/credentials v1.20.1 h1:Z8GRNEx0u9sDkZOq4PUnN8mjGwbUQGRzMSXpvt3d8xQ=
+github.com/aws/aws-sdk-go-v2/credentials v1.20.1/go.mod h1:uBIK00kFo95dnemqfFMTWx0X8YRqsh6ecIoCjjOkZqM=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.1 h1:YIEBqcqRnpi4Pfv0YHImtgi6czGCwKHANC7SwmUAVD0=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.1/go.mod h1:imEf0oufgAo8KAkCHhrOdqGEC0YWx1PPBQH82shSxGw=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.1 h1:pc138gM1CW+XPc60rEwUlwwuwWFQK16CI1T7v1F9Oec=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.1/go.mod h1:1+koxpPIbfBdfzP6vojm5/zTpTQ/micYwlxIiNB3TxI=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.1 h1:K0JsbZQj+1h208Ro1zHeA4l7bMp0NvRffHQ91q8Ol1s=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.1/go.mod h1:W3/vL6EtCIatICGy9ab29QhMuae+cOKPWcMxv02CO+Q=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.1 h1:yhw5KD1phVyP9vijxOUzDfEtJx+bt+L63k+VfuiYFAA=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.1/go.mod h1:ZW2e0d7DYlRxlS9hEiMXE47gTdX5KRN4byUiNbUpG+Q=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 h1:bAdDl/HkGCcGPoe25ToSHEw23VIxt6CT5fLcg111BKg=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19/go.mod h1:KaUzbLxv4CeSxh6ZCl9B4m7CuFenS8kUEaDs+f/DQr4=
+github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.1 h1:s67hBfG5t9rn1NCvDuB4E3QIep3UFhHPtaIqFDjV3N8=
+github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.1/go.mod h1:FpvjBMXtSNMLPmDJsWwcY5cRnqJlpS2y1R6n4pvzs4k=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.1 h1:RmmWQPREQdk9U+PfqeHW3MqZaBaNK7TpV9W3RY+b+7g=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.1/go.mod h1:0A3W4F+68ZnNk5XcNL/e9HFMwnP8RlEicFfy6eOEDyw=
+github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.1 h1:ZMbtPZZQRca+3+XYQne9PBvRiYpHZlNJJOZfE9WNfT0=
+github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.1/go.mod h1:YAGWQdCYlVCoqrzvfv3RLxO6zKwti7gsAULOGWPLYv4=
+github.com/aws/aws-sdk-go-v2/service/s3 v1.109.1 h1:kVpzaDBzOdRtOftmiSpTdQbWVqRg0kONLXijktiwXnk=
+github.com/aws/aws-sdk-go-v2/service/s3 v1.109.1/go.mod h1:CUr46sCpGAg/rHaclRyhJX0LJAmH73uWSJPPSaMUrSk=
+github.com/aws/aws-sdk-go-v2/service/signin v1.7.1 h1:mdMtSVKdQ3+mzBh+l0ogrFYZVQUCg6pJZOirA2ARsYE=
+github.com/aws/aws-sdk-go-v2/service/signin v1.7.1/go.mod h1:9IqUlsJDbUPcg6cgx3WEzXdjrbWzLDQrak0aaSqlTcI=
+github.com/aws/aws-sdk-go-v2/service/sso v1.35.1 h1:B6WFn91tobD6gG4724ONHaqrpKsoETGnv98LHe/yIGM=
+github.com/aws/aws-sdk-go-v2/service/sso v1.35.1/go.mod h1:tWuiVBUtPBr8/rgRiYS8Uf85sHcAN+G7XS3D3CEoUh8=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.40.1 h1:6yeYCWFvgbI2TI3K6jr9LtBNhXgJ7g4xqD+DEiaDDmM=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.40.1/go.mod h1:naFe83jSMuYkH+QjQPX8n1MLhBkeCFM5Lsnh5m5wz3c=
+github.com/aws/aws-sdk-go-v2/service/sts v1.47.1 h1:Sv2xPnRHlThSUtVujYuUBPI/Il8si6UPHXL8DMiB/F0=
+github.com/aws/aws-sdk-go-v2/service/sts v1.47.1/go.mod h1:mKo/CzaCz8qytGW70NG4vIIGAx1HXTlb5lHNkC5k3lk=
+github.com/aws/smithy-go v1.28.1 h1:R/nXH00c8qcfCzQVELtRw+eLQWtzv+VAIEFJ1/xxXlQ=
+github.com/aws/smithy-go v1.28.1/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
+github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
+github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
+github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
+golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

mail/internal/crypto/envelope.go

@@ -0,0 +1,118 @@
+// Package crypto implementiert ARC-02: Envelope-Encryption für Objekte
+// at rest. Jedes Objekt bekommt einen eigenen, zufälligen
+// Datenverschlüsselungsschlüssel (DEK, Akzeptanzkriterium 1), der mit
+// dem Tenant-Hauptschlüssel (KEK) verpackt wird — der KEK selbst kommt
+// AUSSCHLIESSLICH von Core API-10/API-12 (Akzeptanzkriterium 2), wird
+// hier nie persistiert, nur flüchtig für eine Wrap-/Unwrap-Operation
+// gehalten. Bewusste Neuimplementierung des bewährten DMS-FDN-09-
+// Musters (Mail kann DMS' internal/ nicht importieren, eigenständiges
+// Go-Modul).
+package crypto
+
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"errors"
+	"fmt"
+	"io"
+)
+
+const (
+	DEKSize = 32
+	KEKSize = 32
+)
+
+// ErrDecryptFailed wird geliefert, wenn ein Chiffretext nicht
+// entschlüsselt werden kann — falscher Schlüssel ODER manipulierte
+// Daten (Pflichtprüfung 2: GCM-Auth-Tag erkennt Manipulation
+// zuverlässig, AEAD unterscheidet die beiden Ursachen bewusst nicht).
+var ErrDecryptFailed = errors.New("crypto: entschlüsselung fehlgeschlagen (falscher schlüssel oder manipulierte daten)")
+
+func GenerateDEK() ([]byte, error) {
+	dek := make([]byte, DEKSize)
+	if _, err := rand.Read(dek); err != nil {
+		return nil, fmt.Errorf("crypto: dek erzeugen: %w", err)
+	}
+	return dek, nil
+}
+
+func seal(key, plaintext []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, fmt.Errorf("crypto: aes-cipher erstellen: %w", err)
+	}
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return nil, fmt.Errorf("crypto: gcm erstellen: %w", err)
+	}
+	nonce := make([]byte, gcm.NonceSize())
+	if _, err := rand.Read(nonce); err != nil {
+		return nil, fmt.Errorf("crypto: nonce erzeugen: %w", err)
+	}
+	return gcm.Seal(nonce, nonce, plaintext, nil), nil
+}
+
+func open(key, sealed []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, fmt.Errorf("crypto: aes-cipher erstellen: %w", err)
+	}
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return nil, fmt.Errorf("crypto: gcm erstellen: %w", err)
+	}
+	if len(sealed) < gcm.NonceSize() {
+		return nil, ErrDecryptFailed
+	}
+	nonce, ciphertext := sealed[:gcm.NonceSize()], sealed[gcm.NonceSize():]
+	plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
+	if err != nil {
+		return nil, ErrDecryptFailed
+	}
+	return plaintext, nil
+}
+
+func WrapDEK(kek, dek []byte) ([]byte, error) {
+	wrapped, err := seal(kek, dek)
+	if err != nil {
+		return nil, fmt.Errorf("crypto: dek verpacken: %w", err)
+	}
+	return wrapped, nil
+}
+
+func UnwrapDEK(kek, wrappedDEK []byte) ([]byte, error) {
+	return open(kek, wrappedDEK)
+}
+
+// EncryptStream verschlüsselt den gesamten Inhalt von r mit dek
+// (AES-256-GCM). Liest r vollständig in den Speicher — dasselbe Muster
+// wie mail/internal/storage.S3Driver.Put (ARC-01), das S3-PutObject
+// ebenfalls vollständig puffert; ein segmentiertes AEAD-Verfahren für
+// sehr große Anhänge ist bewusst nicht Teil der "kleinsten Lösung".
+func EncryptStream(dek []byte, r io.Reader) (io.Reader, error) {
+	plaintext, err := io.ReadAll(r)
+	if err != nil {
+		return nil, fmt.Errorf("crypto: klartext lesen: %w", err)
+	}
+	ciphertext, err := seal(dek, plaintext)
+	if err != nil {
+		return nil, fmt.Errorf("crypto: verschlüsseln: %w", err)
+	}
+	return bytes.NewReader(ciphertext), nil
+}
+
+// DecryptStream entschlüsselt einen zuvor mit EncryptStream erzeugten
+// Chiffretext-Stream.
+func DecryptStream(dek []byte, r io.Reader) (io.Reader, error) {
+	ciphertext, err := io.ReadAll(r)
+	if err != nil {
+		return nil, fmt.Errorf("crypto: chiffretext lesen: %w", err)
+	}
+	plaintext, err := open(dek, ciphertext)
+	if err != nil {
+		return nil, err
+	}
+	return bytes.NewReader(plaintext), nil
+}

mail/internal/crypto/kekprovider.go

@@ -0,0 +1,80 @@
+package crypto
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+)
+
+// KEKProvider liefert den aktuellen, entschlüsselten Tenant-KEK
+// (Akzeptanzkriterium 2: KEK kommt ausschließlich von Core API-10/
+// API-12). Schmale Schnittstelle, damit Tests einen Fake statt eines
+// echten HTTP-Aufrufs einsetzen können.
+type KEKProvider interface {
+	TenantKEK(ctx context.Context, tenantSlug string) ([]byte, error)
+}
+
+// tenantKEKResponse entspricht Core internal/kek.tenantKEKResponse
+// (JSON-Vertrag: tenant_kek_base64) — dieselbe Struktur, hier
+// gespiegelt, da Mail Cores internal/-Pakete nicht importieren kann.
+type tenantKEKResponse struct {
+	TenantKEKBase64 string `json:"tenant_kek_base64"`
+}
+
+// HTTPKEKProvider bezieht den Tenant-KEK über Core API-12
+// (internal/kek.Handler.TenantKEKHandler, echt laufender Dienst),
+// authentifiziert über dasselbe Service-Credential-Verfahren wie jeder
+// andere Modul-Core-Aufruf (API-02) — identisches Muster wie DMS
+// FDN-09/internal/storage.HTTPUsageReporter aus ARC-01.
+type HTTPKEKProvider struct {
+	endpointURL  string
+	clientID     string
+	clientSecret string
+	httpClient   *http.Client
+}
+
+func NewHTTPKEKProvider(endpointURL, clientID, clientSecret string, httpClient *http.Client) *HTTPKEKProvider {
+	if httpClient == nil {
+		httpClient = http.DefaultClient
+	}
+	return &HTTPKEKProvider{endpointURL: endpointURL, clientID: clientID, clientSecret: clientSecret, httpClient: httpClient}
+}
+
+func (p *HTTPKEKProvider) TenantKEK(ctx context.Context, tenantSlug string) ([]byte, error) {
+	u, err := url.Parse(p.endpointURL)
+	if err != nil {
+		return nil, fmt.Errorf("crypto: kek-endpunkt-url ungültig: %w", err)
+	}
+	q := u.Query()
+	q.Set("tenant", tenantSlug)
+	u.RawQuery = q.Encode()
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
+	if err != nil {
+		return nil, fmt.Errorf("crypto: kek-anfrage aufbauen: %w", err)
+	}
+	req.Header.Set("X-Nexarch-Client-Id", p.clientID)
+	req.Header.Set("X-Nexarch-Client-Secret", p.clientSecret)
+
+	resp, err := p.httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("crypto: kek-anfrage senden: %w", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("crypto: kek-bezug von core abgelehnt: status %d", resp.StatusCode)
+	}
+
+	var body tenantKEKResponse
+	if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
+		return nil, fmt.Errorf("crypto: kek-antwort dekodieren: %w", err)
+	}
+	kek, err := base64.StdEncoding.DecodeString(body.TenantKEKBase64)
+	if err != nil {
+		return nil, fmt.Errorf("crypto: kek base64-dekodieren: %w", err)
+	}
+	return kek, nil
+}

mail/internal/crypto/service.go

@@ -0,0 +1,67 @@
+package crypto
+
+import (
+	"context"
+	"fmt"
+	"io"
+)
+
+// Envelope ist das Ergebnis einer Seal-Operation: der Chiffretext-
+// Stream plus der mit dem Tenant-KEK verpackte DEK, der zusammen mit
+// dem Objekt persistiert werden muss (siehe mail/internal/encstorage).
+type Envelope struct {
+	Ciphertext io.Reader
+	WrappedDEK []byte
+}
+
+// Service verbindet KEKProvider mit den Envelope-Operationen — Aufrufer
+// (mail/internal/encstorage) rufen ausschließlich Service auf, nie die
+// Einzelfunktionen aus envelope.go direkt.
+type Service struct {
+	kek KEKProvider
+}
+
+func NewService(kek KEKProvider) *Service {
+	return &Service{kek: kek}
+}
+
+// Seal erzeugt einen neuen DEK (Akzeptanzkriterium 1), verschlüsselt
+// plaintext damit und verpackt den DEK mit dem aktuellen Tenant-KEK
+// (Akzeptanzkriterium 2 — der KEK wird bei JEDEM Aufruf frisch von Core
+// bezogen, nie zwischengespeichert).
+func (s *Service) Seal(ctx context.Context, tenantSlug string, plaintext io.Reader) (*Envelope, error) {
+	dek, err := GenerateDEK()
+	if err != nil {
+		return nil, err
+	}
+	ciphertext, err := EncryptStream(dek, plaintext)
+	if err != nil {
+		return nil, err
+	}
+	kek, err := s.kek.TenantKEK(ctx, tenantSlug)
+	if err != nil {
+		return nil, fmt.Errorf("crypto: tenant-kek beziehen: %w", err)
+	}
+	wrappedDEK, err := WrapDEK(kek, dek)
+	if err != nil {
+		return nil, err
+	}
+	return &Envelope{Ciphertext: ciphertext, WrappedDEK: wrappedDEK}, nil
+}
+
+// Open entpackt den DEK mit dem aktuellen Tenant-KEK (Akzeptanzkriterium
+// 3: nur mit gültigem, mandantenbezogenem Schlüssel möglich — ein
+// falscher Tenant-Slug liefert entweder einen falschen KEK von Core
+// [dann schlägt UnwrapDEK fehl] oder Core verweigert den Zugriff direkt)
+// und entschlüsselt ciphertext damit.
+func (s *Service) Open(ctx context.Context, tenantSlug string, wrappedDEK []byte, ciphertext io.Reader) (io.Reader, error) {
+	kek, err := s.kek.TenantKEK(ctx, tenantSlug)
+	if err != nil {
+		return nil, fmt.Errorf("crypto: tenant-kek beziehen: %w", err)
+	}
+	dek, err := UnwrapDEK(kek, wrappedDEK)
+	if err != nil {
+		return nil, err
+	}
+	return DecryptStream(dek, ciphertext)
+}

mail/internal/dedup/hash.go

@@ -0,0 +1,35 @@
+// Package dedup implementiert ARC-03: Dublettenerkennung für
+// archivierte E-Mails über einen Inhalts-Hash. Kombiniert bewusst NICHT
+// mit mail/internal/storage oder mail/internal/crypto — dieses Paket
+// kennt beide nicht, der Aufrufer (spätere Ingest-Tickets) ruft es VOR
+// mail/internal/crypto auf.
+package dedup
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"io"
+)
+
+// HashAndBuffer berechnet den SHA-256-Inhalts-Hash von plaintext.
+//
+// Bekannter Fehler vermeiden (siehe ARC-03-Ticket): der Hash MUSS auf
+// dem Klartext berechnet werden, BEVOR mail/internal/crypto verschlüsselt
+// — ein Hash auf dem Chiffretext wäre bei jedem Import anders (neuer
+// DEK je Objekt, siehe ARC-02) und Dublettenerkennung würde vollständig
+// versagen. Reihenfolge: Mail/Anhang empfangen -> HashAndBuffer (dieses
+// Paket) -> verschlüsseln (ARC-02) -> ablegen.
+//
+// plaintext wird beim Hashen vollständig verbraucht — HashAndBuffer
+// liefert deshalb einen erneut lesbaren Reader mit demselben Inhalt für
+// den nachfolgenden Verschlüsselungsschritt zurück.
+func HashAndBuffer(plaintext io.Reader) (contentHash string, buffered io.Reader, err error) {
+	var buf bytes.Buffer
+	hasher := sha256.New()
+	if _, err := io.Copy(hasher, io.TeeReader(plaintext, &buf)); err != nil {
+		return "", nil, fmt.Errorf("dedup: klartext hashen: %w", err)
+	}
+	return hex.EncodeToString(hasher.Sum(nil)), &buf, nil
+}

mail/internal/dedup/hash_test.go

@@ -0,0 +1,58 @@
+package dedup
+
+import (
+	"io"
+	"strings"
+	"testing"
+)
+
+func TestHashAndBuffer_SameContentSameHash(t *testing.T) {
+	h1, buf1, err := HashAndBuffer(strings.NewReader("identischer inhalt"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	h2, buf2, err := HashAndBuffer(strings.NewReader("identischer inhalt"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if h1 != h2 {
+		t.Fatalf("erwartet identischen hash für identischen inhalt, habe %q vs %q", h1, h2)
+	}
+
+	got1, _ := io.ReadAll(buf1)
+	got2, _ := io.ReadAll(buf2)
+	if string(got1) != "identischer inhalt" || string(got2) != "identischer inhalt" {
+		t.Fatal("buffered reader liefert nicht denselben inhalt zurück wie der ursprüngliche klartext")
+	}
+}
+
+func TestHashAndBuffer_DifferentContentDifferentHash(t *testing.T) {
+	h1, _, err := HashAndBuffer(strings.NewReader("nachricht a"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	h2, _, err := HashAndBuffer(strings.NewReader("nachricht b"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if h1 == h2 {
+		t.Fatal("unterschiedlicher inhalt hätte unterschiedlichen hash liefern müssen")
+	}
+}
+
+// TestHashAndBuffer_SlightlyDifferentContentDifferentHash ist die
+// geforderte Pflichtprüfung 3: knapp unterschiedliche Nachrichten
+// werden korrekt NICHT als Duplikat erkannt.
+func TestHashAndBuffer_SlightlyDifferentContentDifferentHash(t *testing.T) {
+	h1, _, err := HashAndBuffer(strings.NewReader("Betreff: Test\r\n\r\nInhalt der Nachricht."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	h2, _, err := HashAndBuffer(strings.NewReader("Betreff: Test\r\n\r\nInhalt der Nachricht,"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if h1 == h2 {
+		t.Fatal("ein einziges abweichendes zeichen hätte den hash ändern müssen")
+	}
+}

mail/internal/dedup/store.go

@@ -0,0 +1,75 @@
+package dedup
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Store verwaltet bekannte Inhalts-Hashes je Mandant. tenant_slug ist
+// fester Bestandteil des Primärschlüssels (Akzeptanzkriterium 3:
+// mandantenübergreifend korrekt getrennt) — auch wenn Store einen mit
+// anderen Mandanten geteilten Pool erhält, kann ein Hash-Treffer nie
+// über Mandantengrenzen hinweg entstehen.
+type Store struct {
+	pool       *pgxpool.Pool
+	tenantSlug string
+}
+
+func NewStore(pool *pgxpool.Pool, tenantSlug string) *Store {
+	return &Store{pool: pool, tenantSlug: tenantSlug}
+}
+
+// EnsureSchema legt die Tabelle an, falls sie noch nicht existiert —
+// gleiches Muster wie mail/internal/example (kein zentraler
+// Migrationsläufer für Mandanten-Datenbanken im Mail-Modul vorhanden).
+func (s *Store) EnsureSchema(ctx context.Context) error {
+	if _, err := s.pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS mail_content_hashes (
+			tenant_slug  TEXT NOT NULL,
+			content_hash TEXT NOT NULL,
+			object_key   TEXT NOT NULL,
+			created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
+			PRIMARY KEY (tenant_slug, content_hash)
+		)
+	`); err != nil {
+		return fmt.Errorf("dedup: schema anlegen: %w", err)
+	}
+	return nil
+}
+
+// Register trägt contentHash für den Mandanten als neu bekannt ein
+// (Akzeptanzkriterium 1) und referenziert das Original, statt es
+// redundant zu speichern (Akzeptanzkriterium 2): existiert derselbe
+// Hash für DIESEN Mandanten bereits mit einem ANDEREN object_key,
+// liefert Register isDuplicate=true und den object_key des Originals —
+// der Aufrufer legt den neuen Inhalt dann NICHT ab.
+func (s *Store) Register(ctx context.Context, contentHash, objectKey string) (isDuplicate bool, existingKey string, err error) {
+	if _, err := s.pool.Exec(ctx, `
+		INSERT INTO mail_content_hashes (tenant_slug, content_hash, object_key)
+		VALUES ($1, $2, $3)
+		ON CONFLICT (tenant_slug, content_hash) DO NOTHING
+	`, s.tenantSlug, contentHash, objectKey); err != nil {
+		return false, "", fmt.Errorf("dedup: hash eintragen: %w", err)
+	}
+
+	var storedKey string
+	err = s.pool.QueryRow(ctx, `
+		SELECT object_key FROM mail_content_hashes
+		WHERE tenant_slug = $1 AND content_hash = $2
+	`, s.tenantSlug, contentHash).Scan(&storedKey)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return false, "", fmt.Errorf("dedup: gerade eingetragenen hash nicht wiedergefunden")
+		}
+		return false, "", fmt.Errorf("dedup: eintrag lesen: %w", err)
+	}
+
+	if storedKey != objectKey {
+		return true, storedKey, nil
+	}
+	return false, "", nil
+}

mail/internal/dedup/store_integration_test.go

@@ -0,0 +1,94 @@
+// Integrationstest (ARC-03): echte Postgres-Instanz, folgt derselben
+// Testhost-Konvention wie mail/internal/example (QA-01) — TEST_TENANT_DSN.
+package dedup
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupStore(t *testing.T, tenantSlug string) *Store {
+	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() })
+
+	store := NewStore(pool, tenantSlug)
+	if err := store.EnsureSchema(ctx); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `DELETE FROM mail_content_hashes WHERE tenant_slug = $1`, tenantSlug)
+	})
+	return store
+}
+
+// TestRegister_SameMessageFromTwoSourcesIsDuplicate ist die geforderte
+// Pflichtprüfung 1: dieselbe Nachricht aus zwei Quellen wird als
+// Duplikat erkannt.
+func TestRegister_SameMessageFromTwoSourcesIsDuplicate(t *testing.T) {
+	store := setupStore(t, "mandant-arc03-a")
+	ctx := context.Background()
+
+	hash := "fixierter-inhalts-hash-fuer-test-1"
+
+	isDup, _, err := store.Register(ctx, hash, "quelle-1/objekt")
+	if err != nil {
+		t.Fatalf("erste registrierung: %v", err)
+	}
+	if isDup {
+		t.Fatal("erste registrierung eines hashes darf kein duplikat sein")
+	}
+
+	isDup, existing, err := store.Register(ctx, hash, "quelle-2/objekt")
+	if err != nil {
+		t.Fatalf("zweite registrierung: %v", err)
+	}
+	if !isDup {
+		t.Fatal("erwartet: dieselbe nachricht aus zweiter quelle wird als duplikat erkannt")
+	}
+	if existing != "quelle-1/objekt" {
+		t.Fatalf("erwartet referenz auf das original quelle-1/objekt, habe %q", existing)
+	}
+}
+
+// TestRegister_SameContentTwoTenantsNotLinked ist die geforderte
+// Pflichtprüfung 2: zwei Mandanten mit identischem Mailinhalt werden
+// nicht fälschlich verknüpft.
+func TestRegister_SameContentTwoTenantsNotLinked(t *testing.T) {
+	dsn := os.Getenv("TEST_TENANT_DSN")
+	if dsn == "" {
+		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
+	}
+	storeA := setupStore(t, "mandant-arc03-x")
+	storeB := setupStore(t, "mandant-arc03-y")
+	ctx := context.Background()
+
+	hash := "identischer-inhalt-ueber-zwei-mandanten-hinweg"
+
+	isDupA, _, err := storeA.Register(ctx, hash, "mandant-x/objekt")
+	if err != nil {
+		t.Fatalf("mandant a: %v", err)
+	}
+	if isDupA {
+		t.Fatal("erste registrierung bei mandant a darf kein duplikat sein")
+	}
+
+	isDupB, existingB, err := storeB.Register(ctx, hash, "mandant-y/objekt")
+	if err != nil {
+		t.Fatalf("mandant b: %v", err)
+	}
+	if isDupB {
+		t.Fatalf("mandant b wurde fälschlich mit mandant a verknüpft, existing=%q", existingB)
+	}
+}

mail/internal/encstorage/encstorage.go

@@ -0,0 +1,93 @@
+// Package encstorage implementiert ARC-02s Anbindung an ARC-01: jedes
+// archivierte Objekt wird VOR dem Schreiben über
+// mail/internal/storage.Service verschlüsselt (Akzeptanzkriterium 1).
+// Kombiniert bewusst zwei bereits fertige, unveränderte Pakete
+// (mail/internal/storage aus ARC-01, mail/internal/crypto aus ARC-02)
+// statt eines davon zu erweitern — kein Umbau angrenzender Bereiche.
+//
+// Reihenfolge beachtet (Ticket "Bekannte Fehler vermeiden"): ein
+// SHA-256-Hash für Dublettenerkennung (ARC-03) muss auf dem KLARTEXT
+// berechnet werden, BEVOR diese Verschlüsselung angewendet wird — das
+// ist Sache des Aufrufers (ARC-03, außerhalb dieses Pakets), dieses
+// Paket nimmt bereits fertigen Klartext entgegen und verschlüsselt ihn
+// sofort, hält ihn nicht länger als nötig im Speicher.
+package encstorage
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/crypto"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/storage"
+)
+
+// wrappedDEKKey ist der Sidecar-Objektschlüssel für den mit dem
+// Tenant-KEK verpackten DEK — liegt im selben Storage-Backend wie der
+// Chiffretext, analog zum Prüfsummen-Sidecar aus ARC-01.
+func wrappedDEKKey(key string) string {
+	return key + ".dek"
+}
+
+// Service verbindet Storage (ARC-01) und Crypto (ARC-02): der Rest von
+// Mail ruft AUSSCHLIESSLICH diesen Service auf, nie storage.Service
+// direkt mit Klartext — das verhindert einen Schreibpfad, der die
+// Verschlüsselung vergisst (Akzeptanzkriterium 1).
+type Service struct {
+	storage *storage.Service
+	crypto  *crypto.Service
+}
+
+func NewService(storageSvc *storage.Service, cryptoSvc *crypto.Service) *Service {
+	return &Service{storage: storageSvc, crypto: cryptoSvc}
+}
+
+// Put verschlüsselt plaintext (Akzeptanzkriterium 1/2: neuer DEK je
+// Objekt, mit dem per API-12 bezogenen Tenant-KEK verpackt) und legt
+// Chiffretext + verpackten DEK über storage.Service ab (Prüfsumme,
+// Nutzungsmeldung — ARC-01 unverändert wiederverwendet).
+func (s *Service) Put(ctx context.Context, tenantSlug, key string, plaintext io.Reader, contentType string) error {
+	env, err := s.crypto.Seal(ctx, tenantSlug, plaintext)
+	if err != nil {
+		return fmt.Errorf("encstorage: verschlüsseln: %w", err)
+	}
+	ciphertext, err := io.ReadAll(env.Ciphertext)
+	if err != nil {
+		return fmt.Errorf("encstorage: chiffretext lesen: %w", err)
+	}
+	if _, err := s.storage.Put(ctx, key, bytes.NewReader(ciphertext), int64(len(ciphertext)), contentType); err != nil {
+		return fmt.Errorf("encstorage: chiffretext speichern: %w", err)
+	}
+	if _, err := s.storage.Put(ctx, wrappedDEKKey(key), bytes.NewReader(env.WrappedDEK), int64(len(env.WrappedDEK)), "application/octet-stream"); err != nil {
+		return fmt.Errorf("encstorage: verpackten dek speichern: %w", err)
+	}
+	return nil
+}
+
+// GetDecrypted liest Chiffretext (über storage.GetVerified — ARC-01s
+// Prüfsummenverifikation wird dabei mitgenutzt) und verpackten DEK,
+// entpackt den DEK mit dem AKTUELLEN Tenant-KEK und entschlüsselt den
+// Inhalt (Akzeptanzkriterium 3: nur mit gültigem, mandantenbezogenem
+// Schlüssel möglich).
+func (s *Service) GetDecrypted(ctx context.Context, tenantSlug, key string) ([]byte, error) {
+	ciphertext, err := s.storage.GetVerified(ctx, key)
+	if err != nil {
+		return nil, fmt.Errorf("encstorage: chiffretext lesen: %w", err)
+	}
+	dekReader, err := s.storage.Get(ctx, wrappedDEKKey(key))
+	if err != nil {
+		return nil, fmt.Errorf("encstorage: verpackten dek lesen: %w", err)
+	}
+	defer func() { _ = dekReader.Close() }()
+	wrappedDEK, err := io.ReadAll(dekReader)
+	if err != nil {
+		return nil, fmt.Errorf("encstorage: verpackten dek lesen: %w", err)
+	}
+
+	plaintextReader, err := s.crypto.Open(ctx, tenantSlug, wrappedDEK, bytes.NewReader(ciphertext))
+	if err != nil {
+		return nil, err
+	}
+	return io.ReadAll(plaintextReader)
+}

mail/internal/encstorage/encstorage_test.go

@@ -0,0 +1,138 @@
+package encstorage
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/crypto"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/storage"
+)
+
+type fakeUsageReporter struct{}
+
+func (fakeUsageReporter) Report(_ context.Context, _, _ string, _ int64) error { return nil }
+
+// fakeKEKProvider liefert einen festen, mandantenspezifischen KEK —
+// simuliert Core API-12, ohne den echten Dienst für Unit-Tests zu
+// brauchen. "richtiger-tenant" hat einen bekannten KEK, jeder andere
+// Tenant-Slug liefert einen ANDEREN (falschen) KEK — genau der Fall,
+// den Pflichtprüfung 2 testet.
+type fakeKEKProvider struct {
+	keksByTenant map[string][]byte
+}
+
+func (f fakeKEKProvider) TenantKEK(_ context.Context, tenantSlug string) ([]byte, error) {
+	if kek, ok := f.keksByTenant[tenantSlug]; ok {
+		return kek, nil
+	}
+	// Unbekannter Tenant bekommt einen ANDEREN zufälligen KEK (nicht
+	// abgelehnt auf Core-Seite in diesem Fake, aber garantiert falsch —
+	// entspricht dem realen Fall, dass ein falscher Tenant-Slug einen
+	// anderen KEK liefert und die Entschlüsselung deshalb scheitert).
+	return bytes.Repeat([]byte{0xFF}, crypto.KEKSize), nil
+}
+
+func newTestServiceWithDir(t *testing.T) (*Service, string) {
+	t.Helper()
+	dir := t.TempDir()
+	storageSvc := storage.NewService(storage.NewLocalDriver(dir), fakeUsageReporter{}, "acme")
+	kekProvider := fakeKEKProvider{keksByTenant: map[string][]byte{
+		"richtiger-tenant": bytes.Repeat([]byte{0x42}, crypto.KEKSize),
+	}}
+	cryptoSvc := crypto.NewService(kekProvider)
+	return NewService(storageSvc, cryptoSvc), dir
+}
+
+// TestPut_RawStorageAccessWithoutKeyYieldsNoReadableContent ist die
+// geforderte Pflichtprüfung 1: Zugriff auf Rohspeicher ohne Schlüssel
+// liefert keine lesbaren Inhalte.
+func TestPut_RawStorageAccessWithoutKeyYieldsNoReadableContent(t *testing.T) {
+	svc, dir := newTestServiceWithDir(t)
+	ctx := context.Background()
+	key := storage.ObjectKey("msg-enc-1", 0)
+	plaintext := "STRENG GEHEIMER E-MAIL-INHALT, NICHT IM KLARTEXT AUF DER PLATTE"
+
+	if err := svc.Put(ctx, "richtiger-tenant", key, strings.NewReader(plaintext), "text/plain"); err != nil {
+		t.Fatalf("put: %v", err)
+	}
+
+	// Direkter Dateisystemzugriff, UMGEHT den Service/die Entschlüsselung
+	// vollständig — simuliert "Rohspeicher ohne Schlüssel".
+	raw, err := os.ReadFile(filepath.Join(dir, filepath.FromSlash(key)))
+	if err != nil {
+		t.Fatalf("rohdatei lesen: %v", err)
+	}
+	if bytes.Contains(raw, []byte(plaintext)) {
+		t.Fatalf("klartext ist unverschlüsselt im rohspeicher auffindbar: %q enthält %q", raw, plaintext)
+	}
+	if bytes.Contains(raw, []byte("STRENG GEHEIMER")) || bytes.Contains(raw, []byte("GEHEIM")) {
+		t.Fatal("erkennbare klartext-fragmente im rohspeicher gefunden")
+	}
+}
+
+// TestGetDecrypted_WrongTenantKeyDeniesDecryption ist die geforderte
+// Pflichtprüfung 2: falscher Mandantenschlüssel verweigert
+// Entschlüsselung.
+func TestGetDecrypted_WrongTenantKeyDeniesDecryption(t *testing.T) {
+	svc, _ := newTestServiceWithDir(t)
+	ctx := context.Background()
+	key := storage.ObjectKey("msg-enc-2", 0)
+	plaintext := "inhalt fuer richtiger-tenant"
+
+	if err := svc.Put(ctx, "richtiger-tenant", key, strings.NewReader(plaintext), "text/plain"); err != nil {
+		t.Fatalf("put: %v", err)
+	}
+
+	// Korrekter Tenant kann entschlüsseln.
+	got, err := svc.GetDecrypted(ctx, "richtiger-tenant", key)
+	if err != nil {
+		t.Fatalf("getdecrypted (richtiger tenant): %v", err)
+	}
+	if string(got) != plaintext {
+		t.Fatalf("falscher inhalt: %q", got)
+	}
+
+	// FALSCHER Mandant (anderer Tenant-Slug -> anderer KEK) muss
+	// abgelehnt werden.
+	_, err = svc.GetDecrypted(ctx, "falscher-tenant", key)
+	if !errors.Is(err, crypto.ErrDecryptFailed) {
+		t.Fatalf("erwartet ErrDecryptFailed bei falschem mandantenschlüssel, habe: %v", err)
+	}
+}
+
+// TestPut_AcceptableEncryptionOverhead ist die geforderte
+// Pflichtprüfung 3: Performance-Test bestätigt akzeptablen Overhead
+// durch Verschlüsselung.
+func TestPut_AcceptableEncryptionOverhead(t *testing.T) {
+	svc, _ := newTestServiceWithDir(t)
+	ctx := context.Background()
+
+	// ~64 KiB Nutzlast, realistische Anhanggröße.
+	payload := strings.Repeat("x", 64*1024)
+
+	const count = 50
+	start := time.Now()
+	for i := 0; i < count; i++ {
+		key := storage.ObjectKey("msg-perf", i)
+		if err := svc.Put(ctx, "richtiger-tenant", key, strings.NewReader(payload), "application/octet-stream"); err != nil {
+			t.Fatalf("put #%d: %v", i, err)
+		}
+	}
+	elapsed := time.Since(start)
+	avgPerObject := elapsed / count
+
+	// Großzügige Grenze (50ms je 64-KiB-Objekt inkl. AES-GCM,
+	// Prüfsumme, Sidecar-Schreiben, Rücklese-Verifikation aus ARC-01) —
+	// Ziel: Nachweis, dass Verschlüsselung keinen unverhältnismäßigen
+	// Overhead verursacht, nicht ein knallhartes SLA.
+	if avgPerObject > 50*time.Millisecond {
+		t.Fatalf("erwartet akzeptablen verschlüsselungs-overhead (<50ms/64KiB-objekt), habe %v/objekt (gesamt %v für %d objekte)", avgPerObject, elapsed, count)
+	}
+	t.Logf("Verschlüsselungs-Performance: %d×64KiB-Objekte in %v (%v/Objekt)", count, elapsed, avgPerObject)
+}

mail/internal/example/handler.go

@@ -0,0 +1,36 @@
+package example
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// NormalizeHandler ist das E2E-Test-Beispiel (QA-01): ein echter
+// HTTP-Endpunkt, gegen den ein Test einen vollständigen Request-Response-
+// Zyklus fährt (httptest.Server, echter TCP-Roundtrip, kein reiner
+// Funktionsaufruf). Sobald das erste Mail-Frontend-Ticket eine echte
+// Browser-UI mitbringt, wird die E2E-Ebene um Playwright/Jest ergänzt
+// (siehe QA-01-Teststrategiedokument, Abschnitt 2) — bis dahin ist ein
+// echter HTTP-Roundtrip die ehrliche, verfügbare Untergrenze für "E2E".
+type normalizeRequest struct {
+	Address string `json:"address"`
+}
+
+type normalizeResponse struct {
+	Normalized string `json:"normalized"`
+}
+
+func NormalizeHandler(w http.ResponseWriter, r *http.Request) {
+	var req normalizeRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungültiger request-body", http.StatusBadRequest)
+		return
+	}
+	normalized, err := NormalizeAddress(req.Address)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(normalizeResponse{Normalized: normalized})
+}

mail/internal/example/handler_e2e_test.go

@@ -0,0 +1,51 @@
+// E2E-Test-Beispiel (QA-01 Akzeptanzkriterium 1/Prüfung 2): echter
+// HTTP-Request über einen laufenden httptest.Server (TCP-Roundtrip),
+// nicht nur ein Funktionsaufruf im selben Prozess.
+package example
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestNormalizeHandler_RealHTTPRoundTrip(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(NormalizeHandler))
+	defer server.Close()
+
+	body, _ := json.Marshal(normalizeRequest{Address: "Kunde@Beispiel.DE"})
+	resp, err := http.Post(server.URL, "application/json", bytes.NewReader(body))
+	if err != nil {
+		t.Fatalf("post: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("status = %d, want 200", resp.StatusCode)
+	}
+	var out normalizeResponse
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+		t.Fatalf("antwort dekodieren: %v", err)
+	}
+	if out.Normalized != "Kunde@beispiel.de" {
+		t.Fatalf("got %q", out.Normalized)
+	}
+}
+
+func TestNormalizeHandler_InvalidAddressReturns400(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(NormalizeHandler))
+	defer server.Close()
+
+	body, _ := json.Marshal(normalizeRequest{Address: "keine-gueltige-adresse"})
+	resp, err := http.Post(server.URL, "application/json", bytes.NewReader(body))
+	if err != nil {
+		t.Fatalf("post: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400", resp.StatusCode)
+	}
+}

mail/internal/example/normalize.go

@@ -0,0 +1,26 @@
+// Package example dient QA-01 (Mail): liefert je Testart (Unit,
+// Integration, E2E) genau EIN reales, lauffähiges Beispiel, an dem sich
+// spätere Mail-Tickets orientieren können — keine Wegwerf-Demo, sondern
+// eine tatsächlich nützliche, kleine Funktion (Adress-Normalisierung),
+// die spätere Ticket (z. B. ING-01/ING-04) ohnehin brauchen werden.
+package example
+
+import (
+	"errors"
+	"strings"
+)
+
+var ErrInvalidAddress = errors.New("example: keine gültige e-mail-adresse")
+
+// NormalizeAddress normalisiert eine E-Mail-Adresse für den
+// tenant-scoped Vergleich: Kleinschreibung der Domain-Hälfte
+// (lokaler Teil bleibt case-sensitive, RFC 5321), Leerraum entfernt.
+func NormalizeAddress(addr string) (string, error) {
+	addr = strings.TrimSpace(addr)
+	at := strings.LastIndex(addr, "@")
+	if at <= 0 || at == len(addr)-1 {
+		return "", ErrInvalidAddress
+	}
+	local, domain := addr[:at], addr[at+1:]
+	return local + "@" + strings.ToLower(domain), nil
+}

mail/internal/example/normalize_test.go

@@ -0,0 +1,38 @@
+// Unit-Test-Beispiel (QA-01 Akzeptanzkriterium 1/Prüfung 2): keine
+// externe Abhängigkeit (DB, Netzwerk), reine Funktionsprüfung.
+package example
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestNormalizeAddress_LowercasesDomainOnly(t *testing.T) {
+	got, err := NormalizeAddress("User.Name@Example.COM")
+	if err != nil {
+		t.Fatalf("unerwarteter fehler: %v", err)
+	}
+	want := "User.Name@example.com"
+	if got != want {
+		t.Fatalf("got %q, want %q", got, want)
+	}
+}
+
+func TestNormalizeAddress_TrimsWhitespace(t *testing.T) {
+	got, err := NormalizeAddress("  user@example.com  ")
+	if err != nil {
+		t.Fatalf("unerwarteter fehler: %v", err)
+	}
+	if got != "user@example.com" {
+		t.Fatalf("got %q", got)
+	}
+}
+
+func TestNormalizeAddress_RejectsInvalidInput(t *testing.T) {
+	cases := []string{"", "no-at-sign", "@nolocalpart.com", "trailing@"}
+	for _, c := range cases {
+		if _, err := NormalizeAddress(c); !errors.Is(err, ErrInvalidAddress) {
+			t.Fatalf("input %q: erwartet ErrInvalidAddress, habe: %v", c, err)
+		}
+	}
+}

mail/internal/example/store.go

@@ -0,0 +1,42 @@
+package example
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// AddressStore ist das Integrationstest-Beispiel (QA-01): eine
+// minimale, aber echte DB-gestützte Komponente — nutzt dieselbe
+// Tenant-DB-Isolationskonvention wie DMS/Archive (t.Cleanup, geteilte
+// physische Postgres-Instanz auf dem Testhost).
+type AddressStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewAddressStore(pool *pgxpool.Pool) *AddressStore {
+	return &AddressStore{pool: pool}
+}
+
+func (s *AddressStore) SaveNormalized(ctx context.Context, addr string) (string, error) {
+	normalized, err := NormalizeAddress(addr)
+	if err != nil {
+		return "", err
+	}
+	if _, err := s.pool.Exec(ctx, `
+		INSERT INTO example_addresses (address) VALUES ($1)
+		ON CONFLICT (address) DO NOTHING
+	`, normalized); err != nil {
+		return "", fmt.Errorf("example: adresse speichern: %w", err)
+	}
+	return normalized, nil
+}
+
+func (s *AddressStore) Exists(ctx context.Context, addr string) (bool, error) {
+	var exists bool
+	if err := s.pool.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM example_addresses WHERE address = $1)`, addr).Scan(&exists); err != nil {
+		return false, fmt.Errorf("example: existenz prüfen: %w", err)
+	}
+	return exists, nil
+}

mail/internal/example/store_integration_test.go

@@ -0,0 +1,69 @@
+// Integrations-Test-Beispiel (QA-01 Akzeptanzkriterium 1/Prüfung 2):
+// echte Postgres-Instanz, folgt derselben Testhost-Konvention wie
+// DMS/Archive/Core (TEST_TENANT_DSN, t.Cleanup, geteilte physische
+// Instanz auf 192.168.1.131 — siehe project-nexarch-test-infra).
+package example
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupTest(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() })
+
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS example_addresses (
+			address TEXT PRIMARY KEY
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `TRUNCATE example_addresses`)
+	})
+	return pool
+}
+
+func TestAddressStore_SaveAndCheckExists(t *testing.T) {
+	pool := setupTest(t)
+	store := NewAddressStore(pool)
+	ctx := context.Background()
+
+	normalized, err := store.SaveNormalized(ctx, "Kunde@Beispiel.DE")
+	if err != nil {
+		t.Fatalf("savenormalized: %v", err)
+	}
+	if normalized != "Kunde@beispiel.de" {
+		t.Fatalf("erwartet normalisierte adresse, habe %q", normalized)
+	}
+
+	exists, err := store.Exists(ctx, normalized)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !exists {
+		t.Fatal("erwartet real gespeicherte adresse")
+	}
+
+	notExists, err := store.Exists(ctx, "unbekannt@beispiel.de")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if notExists {
+		t.Fatal("nie gespeicherte adresse haette nicht existieren duerfen")
+	}
+}

mail/internal/mimeparse/mimeparse.go

@@ -0,0 +1,206 @@
+// Package mimeparse implementiert ING-04: MIME-/Anhang-Parsing für
+// ein- und ausgehende Nachrichten (Multipart, verschachtelt,
+// Content-Transfer-Encoding, defensive Zeichensatz-Reparatur).
+//
+// NUR Parsing — Speicherung ist ARC-01s Aufgabe (siehe "Nicht
+// Bestandteil dieser Kachel"), dieses Paket schreibt nirgends in einen
+// Objekt-Speicher, sondern liefert nur strukturierte Go-Werte zurück.
+//
+// Bekannten Fehler vermieden (archivmail known-issues #3): Anhänge
+// wurden früher über io.ReadAll ohne Größenlimit gelesen — eine
+// Speicherbombe durch große/böswillige Anhänge. Hier läuft JEDER
+// Anhang-Lesevorgang über io.LimitReader mit konfigurierter Max-Size;
+// eine Überschreitung führt zu einer harten, sauberen Ablehnung
+// (ErrAttachmentTooLarge), kein stilles Abschneiden.
+package mimeparse
+
+import (
+	"bytes"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"mime"
+	"mime/multipart"
+	"mime/quotedprintable"
+	"net/mail"
+	"strings"
+
+	"golang.org/x/text/encoding/htmlindex"
+)
+
+// ErrAttachmentTooLarge wird geliefert, wenn ein Anhang die
+// konfigurierte Maximalgröße überschreitet (Akzeptanzkriterium/
+// Pflichtprüfung 1).
+var ErrAttachmentTooLarge = errors.New("mimeparse: anhang überschreitet die maximal erlaubte größe")
+
+// Part ist EIN zerlegter MIME-Teil — sowohl Textteile (IsAttachment
+// == false) als auch Anhänge (Akzeptanzkriterium 1/2).
+type Part struct {
+	ContentType string
+	Filename    string
+	Size        int64
+	Content     []byte
+	IsAttachment bool
+}
+
+// Message ist das Ergebnis eines vollständig zerlegten Multipart-
+// Baums — verschachtelte multipart/*-Teile sind bereits rekursiv
+// aufgelöst, der Aufrufer sieht nur die "Blatt"-Teile (Akzeptanz-
+// kriterium 1).
+type Message struct {
+	Parts []Part
+}
+
+// wordDecoder dekodiert RFC-2047-kodierte Header-Werte (z. B.
+// Anhang-Dateinamen) defensiv: ein unbekannter/fehlerhafter
+// Zeichensatz bricht die Verarbeitung NICHT ab (Akzeptanzkriterium 3),
+// sondern liefert den Rohwert unverändert zurück.
+var wordDecoder = &mime.WordDecoder{CharsetReader: charsetReader}
+
+func charsetReader(charsetLabel string, input io.Reader) (io.Reader, error) {
+	enc, err := htmlindex.Get(charsetLabel)
+	if err != nil {
+		// Unbekannter/fehlerhafter Zeichensatz: defensiv als
+		// UTF-8-verträglichen Rohtext weiterreichen statt
+		// abzubrechen (Akzeptanzkriterium 3).
+		return input, nil
+	}
+	return enc.NewDecoder().Reader(input), nil
+}
+
+func decodeHeaderValue(raw string) string {
+	decoded, err := wordDecoder.DecodeHeader(raw)
+	if err != nil {
+		// Defensiv: Rohwert statt Abbruch (Akzeptanzkriterium 3).
+		return raw
+	}
+	return decoded
+}
+
+// Parse zerlegt eine MIME-Nachricht vollständig, inklusive
+// verschachtelter Multipart-Teile (Akzeptanzkriterium 1). maxAttachmentSize
+// begrenzt JEDEN einzelnen Anhang (Akzeptanzkriterium/Pflichtprüfung 1).
+func Parse(r io.Reader, maxAttachmentSize int64) (Message, error) {
+	msg, err := mail.ReadMessage(r)
+	if err != nil {
+		return Message{}, fmt.Errorf("mimeparse: nachricht lesen: %w", err)
+	}
+
+	mediaType, params, err := mime.ParseMediaType(msg.Header.Get("Content-Type"))
+	if err != nil {
+		// Kein/kaputtes Content-Type: als einzelnen Textteil behandeln
+		// statt abzubrechen (Akzeptanzkriterium 3: defensiv reparieren).
+		body, readErr := readLimited(msg.Body, maxAttachmentSize)
+		if readErr != nil {
+			return Message{}, readErr
+		}
+		return Message{Parts: []Part{{ContentType: "text/plain", Content: body, Size: int64(len(body))}}}, nil
+	}
+
+	var result Message
+	if strings.HasPrefix(mediaType, "multipart/") {
+		if err := parseMultipart(msg.Body, params["boundary"], maxAttachmentSize, &result); err != nil {
+			return Message{}, err
+		}
+		return result, nil
+	}
+
+	// Einzelner Teil (keine Multipart-Hülle).
+	part, err := readSinglePart(msg.Header.Get("Content-Transfer-Encoding"), mediaType, "", msg.Body, maxAttachmentSize)
+	if err != nil {
+		return Message{}, err
+	}
+	result.Parts = append(result.Parts, part)
+	return result, nil
+}
+
+// parseMultipart löst EINEN Multipart-Container rekursiv auf —
+// verschachtelte multipart/*-Teile (z. B. multipart/mixed, das
+// multipart/alternative enthält) werden vollständig zerlegt
+// (Akzeptanzkriterium 1), keine Rekursionstiefe hartkodiert begrenzt
+// außer durch die natürliche Nachrichtengröße selbst.
+func parseMultipart(r io.Reader, boundary string, maxAttachmentSize int64, result *Message) error {
+	if boundary == "" {
+		return errors.New("mimeparse: multipart ohne boundary")
+	}
+	mr := multipart.NewReader(r, boundary)
+	for {
+		p, err := mr.NextPart()
+		if err == io.EOF {
+			return nil
+		}
+		if err != nil {
+			// Kaputte Multipart-Struktur: kontrolliert abbrechen
+			// (Pflichtprüfung 3), nicht abstürzen.
+			return fmt.Errorf("mimeparse: multipart-teil lesen: %w", err)
+		}
+
+		contentType := p.Header.Get("Content-Type")
+		mediaType, subParams, err := mime.ParseMediaType(contentType)
+		if err != nil {
+			mediaType = "text/plain"
+		}
+
+		if strings.HasPrefix(mediaType, "multipart/") {
+			if err := parseMultipart(p, subParams["boundary"], maxAttachmentSize, result); err != nil {
+				return err
+			}
+			continue
+		}
+
+		part, err := readSinglePart(p.Header.Get("Content-Transfer-Encoding"), mediaType, decodeHeaderValue(p.FileName()), p, maxAttachmentSize)
+		if err != nil {
+			return err
+		}
+		result.Parts = append(result.Parts, part)
+	}
+}
+
+func readSinglePart(transferEncoding, mediaType, filename string, r io.Reader, maxAttachmentSize int64) (Part, error) {
+	decoded := decodeTransferEncoding(transferEncoding, r)
+
+	content, err := readLimited(decoded, maxAttachmentSize)
+	if err != nil {
+		return Part{}, err
+	}
+
+	return Part{
+		ContentType:  mediaType,
+		Filename:     filename,
+		Size:         int64(len(content)),
+		Content:      content,
+		IsAttachment: filename != "",
+	}, nil
+}
+
+// decodeTransferEncoding dekodiert Content-Transfer-Encoding
+// (quoted-printable/base64) — defensiv: ein unbekanntes Encoding wird
+// unverändert durchgereicht statt die Verarbeitung abzubrechen
+// (Akzeptanzkriterium 3).
+func decodeTransferEncoding(encoding string, r io.Reader) io.Reader {
+	switch strings.ToLower(strings.TrimSpace(encoding)) {
+	case "quoted-printable":
+		return quotedprintable.NewReader(r)
+	case "base64":
+		return base64.NewDecoder(base64.StdEncoding, r)
+	default:
+		return r
+	}
+}
+
+// readLimited liest höchstens maxSize+1 Bytes — wird die Grenze
+// überschritten, wird ErrAttachmentTooLarge geliefert, statt beliebig
+// viel Speicher zu allozieren (Akzeptanzkriterium/Pflichtprüfung 1,
+// archivmail known-issues #3).
+func readLimited(r io.Reader, maxSize int64) ([]byte, error) {
+	limited := io.LimitReader(r, maxSize+1)
+	var buf bytes.Buffer
+	if _, err := io.Copy(&buf, limited); err != nil {
+		return nil, fmt.Errorf("mimeparse: teil lesen: %w", err)
+	}
+	if int64(buf.Len()) > maxSize {
+		return nil, ErrAttachmentTooLarge
+	}
+	return buf.Bytes(), nil
+}

mail/internal/mimeparse/mimeparse_test.go

@@ -0,0 +1,219 @@
+package mimeparse
+
+import (
+	"errors"
+	"io"
+	"strings"
+	"testing"
+)
+
+const defaultMaxSize = 10 * 1024 * 1024 // 10 MiB
+
+// TestParse_NestedMultipartFullyDecomposed ist Akzeptanzkriterium 1:
+// Multipart-Nachrichten mit verschachtelten Teilen werden vollständig
+// zerlegt (multipart/mixed enthält multipart/alternative UND einen
+// Anhang).
+func TestParse_NestedMultipartFullyDecomposed(t *testing.T) {
+	raw := "From: a@example.com\r\n" +
+		"To: b@example.com\r\n" +
+		"Subject: Test\r\n" +
+		"MIME-Version: 1.0\r\n" +
+		"Content-Type: multipart/mixed; boundary=\"outer\"\r\n\r\n" +
+		"--outer\r\n" +
+		"Content-Type: multipart/alternative; boundary=\"inner\"\r\n\r\n" +
+		"--inner\r\n" +
+		"Content-Type: text/plain; charset=utf-8\r\n\r\n" +
+		"Hallo als Text\r\n" +
+		"--inner\r\n" +
+		"Content-Type: text/html; charset=utf-8\r\n\r\n" +
+		"<p>Hallo als HTML</p>\r\n" +
+		"--inner--\r\n" +
+		"--outer\r\n" +
+		"Content-Type: application/pdf\r\n" +
+		"Content-Disposition: attachment; filename=\"rechnung.pdf\"\r\n" +
+		"Content-Transfer-Encoding: base64\r\n\r\n" +
+		"JVBERi0xLjQK\r\n" +
+		"--outer--\r\n"
+
+	msg, err := Parse(strings.NewReader(raw), defaultMaxSize)
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	if len(msg.Parts) != 3 {
+		t.Fatalf("erwartet 3 zerlegte teile (text, html, anhang), habe %d: %+v", len(msg.Parts), msg.Parts)
+	}
+
+	var sawText, sawHTML, sawAttachment bool
+	for _, p := range msg.Parts {
+		switch {
+		case p.ContentType == "text/plain":
+			sawText = true
+			if string(p.Content) != "Hallo als Text" {
+				t.Fatalf("unerwarteter text-inhalt: %q", p.Content)
+			}
+		case p.ContentType == "text/html":
+			sawHTML = true
+		case p.IsAttachment:
+			sawAttachment = true
+		}
+	}
+	if !sawText || !sawHTML || !sawAttachment {
+		t.Fatalf("nicht alle erwarteten teile gefunden: text=%v html=%v attachment=%v", sawText, sawHTML, sawAttachment)
+	}
+}
+
+// TestParse_AttachmentMetadataExtracted ist Akzeptanzkriterium 2:
+// Anhänge werden mit korrektem Dateinamen, Größe und Content-Type
+// extrahiert.
+func TestParse_AttachmentMetadataExtracted(t *testing.T) {
+	raw := "From: a@example.com\r\n" +
+		"Content-Type: multipart/mixed; boundary=\"b\"\r\n\r\n" +
+		"--b\r\n" +
+		"Content-Type: text/plain\r\n\r\n" +
+		"Text\r\n" +
+		"--b\r\n" +
+		"Content-Type: image/png\r\n" +
+		"Content-Disposition: attachment; filename=\"bild.png\"\r\n" +
+		"Content-Transfer-Encoding: base64\r\n\r\n" +
+		"iVBORw0KGgo=\r\n" +
+		"--b--\r\n"
+
+	msg, err := Parse(strings.NewReader(raw), defaultMaxSize)
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	var attachment *Part
+	for i := range msg.Parts {
+		if msg.Parts[i].IsAttachment {
+			attachment = &msg.Parts[i]
+		}
+	}
+	if attachment == nil {
+		t.Fatal("kein anhang gefunden")
+	}
+	if attachment.Filename != "bild.png" {
+		t.Fatalf("falscher dateiname: %q", attachment.Filename)
+	}
+	if attachment.ContentType != "image/png" {
+		t.Fatalf("falscher content-type: %q", attachment.ContentType)
+	}
+	if attachment.Size != int64(len(attachment.Content)) || attachment.Size == 0 {
+		t.Fatalf("unplausible größe: %d (content-len %d)", attachment.Size, len(attachment.Content))
+	}
+}
+
+// TestParse_BrokenCharsetIsRepairedNotAborted ist Akzeptanzkriterium 3:
+// fehlerhafte/inkonsistente Zeichensatzangaben werden defensiv repariert
+// statt die Verarbeitung abzubrechen.
+func TestParse_BrokenCharsetIsRepairedNotAborted(t *testing.T) {
+	// "unbekannt-xyz" ist KEIN gültiger IANA-Zeichensatzname.
+	raw := "From: a@example.com\r\n" +
+		"Content-Type: text/plain; charset=\"unbekannt-xyz\"\r\n\r\n" +
+		"Rohtext trotz kaputtem Charset\r\n"
+
+	msg, err := Parse(strings.NewReader(raw), defaultMaxSize)
+	if err != nil {
+		t.Fatalf("erwartet KEINEN abbruch bei kaputtem charset, habe: %v", err)
+	}
+	if len(msg.Parts) != 1 {
+		t.Fatalf("erwartet 1 teil, habe %d", len(msg.Parts))
+	}
+	if !strings.Contains(string(msg.Parts[0].Content), "Rohtext") {
+		t.Fatalf("inhalt fehlt/verstümmelt: %q", msg.Parts[0].Content)
+	}
+}
+
+// TestParse_ISO88591BodyDecodedWithoutAbort ist Akzeptanzkriterium 3
+// zusätzlich: ein bekannter Nicht-UTF-8-Zeichensatz wird via
+// Header-Dekodierung real repariert (RFC-2047-kodierter Dateiname).
+func TestParse_ISO88591FilenameDecoded(t *testing.T) {
+	// "=?ISO-8859-1?Q?Rechnung_=DC?=" kodiert "Rechnung Ü" (0xDC = 'Ü' in Latin-1).
+	raw := "From: a@example.com\r\n" +
+		"Content-Type: multipart/mixed; boundary=\"b\"\r\n\r\n" +
+		"--b\r\n" +
+		"Content-Type: application/octet-stream\r\n" +
+		"Content-Disposition: attachment; filename=\"=?ISO-8859-1?Q?Rechnung_=DC?=\"\r\n" +
+		"Content-Transfer-Encoding: base64\r\n\r\n" +
+		"AAA=\r\n" +
+		"--b--\r\n"
+
+	msg, err := Parse(strings.NewReader(raw), defaultMaxSize)
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	if len(msg.Parts) != 1 {
+		t.Fatalf("erwartet 1 teil, habe %d", len(msg.Parts))
+	}
+	if msg.Parts[0].Filename != "Rechnung Ü" {
+		t.Fatalf("erwartet dekodierten dateinamen 'Rechnung Ü', habe %q", msg.Parts[0].Filename)
+	}
+}
+
+// infiniteReader liefert unbegrenzt viele Bytes — simuliert einen sehr
+// großen/böswilligen Anhang. Ohne io.LimitReader (siehe archivmail
+// known-issues #3) würde ein io.ReadAll hierauf den Prozessspeicher
+// erschöpfen; mit readLimited bricht Parse kontrolliert und schnell ab.
+type infiniteReader struct{}
+
+func (infiniteReader) Read(p []byte) (int, error) {
+	for i := range p {
+		p[i] = 'A'
+	}
+	return len(p), nil
+}
+
+// TestParse_OversizedAttachmentRejectedNotMemoryExhausted ist die
+// geforderte Pflichtprüfung 1.
+func TestParse_OversizedAttachmentRejectedNotMemoryExhausted(t *testing.T) {
+	const tinyLimit = 1024 // 1 KiB — winzig, damit der Test schnell bleibt
+
+	header := "From: a@example.com\r\n" +
+		"Content-Type: application/octet-stream\r\n" +
+		"Content-Transfer-Encoding: identity\r\n\r\n"
+
+	r := io.MultiReader(strings.NewReader(header), infiniteReader{})
+	_, err := Parse(r, tinyLimit)
+	if !errors.Is(err, ErrAttachmentTooLarge) {
+		t.Fatalf("erwartet ErrAttachmentTooLarge bei unbegrenzt großem anhang, habe: %v", err)
+	}
+}
+
+// TestParse_RealisticCorpusRunsCleanly ist die geforderte
+// Pflichtprüfung 2: realitätsnahe Multipart-/Encoding-Varianten laufen
+// fehlerfrei durch.
+func TestParse_RealisticCorpusRunsCleanly(t *testing.T) {
+	corpus := []string{
+		// Einfache Textnachricht ohne Multipart.
+		"From: a@example.com\r\nContent-Type: text/plain; charset=utf-8\r\n\r\nEinfacher Text\r\n",
+		// Quoted-Printable.
+		"From: a@example.com\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Transfer-Encoding: quoted-printable\r\n\r\nUmlaut: =C3=9C\r\n",
+		// Multipart/alternative ohne Anhang.
+		"From: a@example.com\r\nContent-Type: multipart/alternative; boundary=\"x\"\r\n\r\n--x\r\nContent-Type: text/plain\r\n\r\nText\r\n--x\r\nContent-Type: text/html\r\n\r\n<p>Text</p>\r\n--x--\r\n",
+		// Leere Multipart-Nachricht (kein Teil, nur Präambel/Epilog).
+		"From: a@example.com\r\nContent-Type: multipart/mixed; boundary=\"y\"\r\n\r\nPräambel wird ignoriert\r\n--y--\r\nEpilog wird ignoriert\r\n",
+	}
+	for i, raw := range corpus {
+		if _, err := Parse(strings.NewReader(raw), defaultMaxSize); err != nil {
+			t.Fatalf("corpus[%d] fehlgeschlagen: %v\nraw=%q", i, err, raw)
+		}
+	}
+}
+
+// FuzzParse ist die geforderte Pflichtprüfung 3: kaputte MIME-Strukturen
+// dürfen Parse nicht zum Absturz bringen, nur zu einem kontrollierten
+// Fehler.
+func FuzzParse(f *testing.F) {
+	f.Add([]byte("From: a@example.com\r\nContent-Type: multipart/mixed; boundary=\"b\"\r\n\r\n--b\r\nContent-Type: text/plain\r\n\r\nHallo\r\n--b--\r\n"))
+	f.Add([]byte("Content-Type: multipart/mixed; boundary=\r\n\r\nkaputt"))
+	f.Add([]byte(""))
+	f.Add([]byte("From: a@example.com\r\n\r\n"))
+
+	f.Fuzz(func(t *testing.T, data []byte) {
+		defer func() {
+			if r := recover(); r != nil {
+				t.Fatalf("Parse ist abgestürzt (panic) statt kontrolliert einen Fehler zu liefern: %v", r)
+			}
+		}()
+		_, _ = Parse(strings.NewReader(string(data)), defaultMaxSize)
+	})
+}

mail/internal/pflichttestgate/gate.go

@@ -0,0 +1,72 @@
+// Package pflichttestgate erzwingt die in docs/TESTSTRATEGIE-MAIL.md
+// Abschnitt 4 festgelegte Regel: jede geänderte Go-Datei in einem
+// sicherheitskritischen Bereich (Auth, Tenant-Scoping, Protokoll-/
+// Compliance-kritisch) muss von einer geänderten oder neuen _test.go-
+// Datei im selben Package begleitet sein. Bewusste Code-Kopie des
+// Musters aus Core internal/pflichttestgate — Mail ist ein eigenständiges
+// Go-Modul und kann Core nicht importieren.
+package pflichttestgate
+
+import (
+	"path"
+	"regexp"
+	"strings"
+)
+
+// sensitivePathPatterns beschreibt die Bereiche aus
+// TESTSTRATEGIE-MAIL.md Abschnitt 4.
+var sensitivePathPatterns = []*regexp.Regexp{
+	regexp.MustCompile(`(^|/)mail/internal/auth/`),
+	regexp.MustCompile(`(^|/)mail/internal/tenant/`),
+	regexp.MustCompile(`(^|/)mail/internal/ingest/`),
+	regexp.MustCompile(`(^|/)mail/internal/imap/`),
+	regexp.MustCompile(`(^|/)mail/internal/smtp/`),
+	regexp.MustCompile(`(^|/)mail/internal/arc/`),
+}
+
+// Violation beschreibt ein Package mit sicherheitskritischer Änderung
+// ohne begleitende Testdatei.
+type Violation struct {
+	Package     string
+	ChangedFile string
+}
+
+func isSensitive(file string) bool {
+	if !strings.HasSuffix(file, ".go") || strings.HasSuffix(file, "_test.go") {
+		return false
+	}
+	for _, re := range sensitivePathPatterns {
+		if re.MatchString(file) {
+			return true
+		}
+	}
+	return false
+}
+
+// CheckDiff prüft eine Liste geänderter Dateipfade gegen die
+// Pflichttest-Regel — ein leeres Ergebnis bedeutet: Gate besteht.
+func CheckDiff(changedFiles []string) []Violation {
+	sensitiveByPkg := map[string]string{}
+	testTouchedPkgs := map[string]bool{}
+
+	for _, f := range changedFiles {
+		pkg := path.Dir(f)
+		if strings.HasSuffix(f, "_test.go") {
+			testTouchedPkgs[pkg] = true
+			continue
+		}
+		if isSensitive(f) {
+			if _, seen := sensitiveByPkg[pkg]; !seen {
+				sensitiveByPkg[pkg] = f
+			}
+		}
+	}
+
+	var violations []Violation
+	for pkg, file := range sensitiveByPkg {
+		if !testTouchedPkgs[pkg] {
+			violations = append(violations, Violation{Package: pkg, ChangedFile: file})
+		}
+	}
+	return violations
+}

mail/internal/pflichttestgate/gate_test.go

@@ -0,0 +1,33 @@
+// Negativtest des Gates selbst (QA-01 Prüfung 1): ein Diff mit
+// geänderter mail/internal/auth/login.go ohne begleitende Testdatei
+// muss als Verstoß erkannt werden.
+package pflichttestgate
+
+import "testing"
+
+func TestCheckDiff_FlagsSensitiveChangeWithoutTest(t *testing.T) {
+	violations := CheckDiff([]string{"mail/internal/auth/login.go"})
+	if len(violations) != 1 {
+		t.Fatalf("erwartet genau 1 verstoß, habe %d: %+v", len(violations), violations)
+	}
+	if violations[0].Package != "mail/internal/auth" {
+		t.Fatalf("falsches package gemeldet: %+v", violations[0])
+	}
+}
+
+func TestCheckDiff_PassesWhenTestFileAccompanies(t *testing.T) {
+	violations := CheckDiff([]string{
+		"mail/internal/auth/login.go",
+		"mail/internal/auth/login_test.go",
+	})
+	if len(violations) != 0 {
+		t.Fatalf("erwartet keine verstöße, habe: %+v", violations)
+	}
+}
+
+func TestCheckDiff_IgnoresNonSensitivePaths(t *testing.T) {
+	violations := CheckDiff([]string{"mail/internal/example/normalize.go"})
+	if len(violations) != 0 {
+		t.Fatalf("erwartet keine verstöße für nicht-sensiblen pfad, habe: %+v", violations)
+	}
+}

mail/internal/storage/driver.go

@@ -0,0 +1,49 @@
+// Package storage implementiert ARC-01: die Objekt-Speicher-Anbindung
+// für archivierte Mails und Anhänge. Baut auf demselben bewährten
+// Muster wie DMS FDN-03 auf (austauschbare Driver, LocalDriver für
+// Entwicklung, S3Driver für Produktion) — Mail kann DMS' internal/
+// nicht importieren (eigenständiges Go-Modul), daher eine bewusste,
+// angepasste Neuimplementierung statt eines Cross-Modul-Imports.
+//
+// Erweiterung gegenüber FDN-03: ARC-01 verlangt Prüfsummenverifikation
+// AN DIESER SCHICHT (Akzeptanzkriterium 2), nicht erst an einer
+// späteren DB-Schicht — siehe service.go.
+package storage
+
+import (
+	"context"
+	"errors"
+	"io"
+	"strconv"
+)
+
+// ErrNotFound wird geliefert, wenn ein angefragtes Objekt nicht
+// existiert.
+var ErrNotFound = errors.New("storage: objekt nicht gefunden")
+
+// Driver ist die EINE Schnittstelle, gegen die der Rest von Mail
+// arbeitet (Akzeptanzkriterium 1). Zwei Implementierungen: LocalDriver
+// (Entwicklung) und S3Driver (Produktion, S3-kompatibel).
+type Driver interface {
+	Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) (int64, error)
+	Get(ctx context.Context, key string) (io.ReadCloser, error)
+	Delete(ctx context.Context, key string) error
+}
+
+// ObjectKey liefert das feste, dokumentierte Pfadschema für einen
+// Mail-Anhang/-Teil INNERHALB des bereits mandantenspezifischen
+// Buckets (Akzeptanzkriterium 1) — Bucket-Trennung selbst ist Sache
+// von Core TEN-01. Lesezugriff hängt NUR von messageID+partIndex ab,
+// nicht vom ursprünglichen Importpfad (IMAP/SMTP/manueller Import —
+// Akzeptanzkriterium 3): derselbe Key wird unabhängig davon berechnet,
+// über welchen Weg die Nachricht ins System kam.
+func ObjectKey(messageID string, partIndex int) string {
+	return "messages/" + messageID + "/parts/" + strconv.Itoa(partIndex)
+}
+
+// checksumKey ist der Sidecar-Objektschlüssel für die beim Schreiben
+// berechnete Prüfsumme (siehe service.go) — liegt bewusst im selben
+// Driver/Bucket wie der Inhalt, keine separate DB-Abhängigkeit nötig.
+func checksumKey(key string) string {
+	return key + ".sha256"
+}

mail/internal/storage/localdriver.go

@@ -0,0 +1,63 @@
+package storage
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+)
+
+// LocalDriver legt Objekte im lokalen Dateisystem ab — der
+// Entwicklungs-Treiber (Akzeptanzkriterium 1), keine externe
+// Abhängigkeit nötig.
+type LocalDriver struct {
+	baseDir string
+}
+
+func NewLocalDriver(baseDir string) *LocalDriver {
+	return &LocalDriver{baseDir: baseDir}
+}
+
+func (d *LocalDriver) path(key string) string {
+	return filepath.Join(d.baseDir, filepath.FromSlash(key))
+}
+
+func (d *LocalDriver) Put(_ context.Context, key string, r io.Reader, _ int64, _ string) (int64, error) {
+	full := d.path(key)
+	if err := os.MkdirAll(filepath.Dir(full), 0o755); err != nil {
+		return 0, fmt.Errorf("storage: verzeichnis anlegen: %w", err)
+	}
+	f, err := os.Create(full)
+	if err != nil {
+		return 0, fmt.Errorf("storage: datei anlegen: %w", err)
+	}
+	defer func() { _ = f.Close() }()
+
+	written, err := io.Copy(f, r)
+	if err != nil {
+		return 0, fmt.Errorf("storage: schreiben: %w", err)
+	}
+	return written, nil
+}
+
+func (d *LocalDriver) Get(_ context.Context, key string) (io.ReadCloser, error) {
+	f, err := os.Open(d.path(key))
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, ErrNotFound
+		}
+		return nil, fmt.Errorf("storage: lesen: %w", err)
+	}
+	return f, nil
+}
+
+func (d *LocalDriver) Delete(_ context.Context, key string) error {
+	if err := os.Remove(d.path(key)); err != nil {
+		if os.IsNotExist(err) {
+			return ErrNotFound
+		}
+		return fmt.Errorf("storage: löschen: %w", err)
+	}
+	return nil
+}

mail/internal/storage/s3driver.go

@@ -0,0 +1,110 @@
+package storage
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+
+	"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/aws/aws-sdk-go-v2/service/s3/types"
+	"github.com/aws/smithy-go"
+)
+
+// S3Driver legt Objekte in einem S3-kompatiblen Objektspeicher ab — der
+// Produktions-Treiber (Akzeptanzkriterium 1). Funktioniert gegen echtes
+// AWS S3 UND gegen jeden S3-kompatiblen Anbieter (MinIO etc.) über
+// endpointURL. Gleiches, bewährtes Muster wie DMS FDN-03s S3Driver
+// (bewusste Kopie, Mail kann DMS nicht importieren).
+type S3Driver struct {
+	client *s3.Client
+	bucket string
+}
+
+func NewS3Driver(ctx context.Context, bucket, region, endpointURL, accessKeyID, secretAccessKey string, usePathStyle bool) (*S3Driver, error) {
+	cfg, err := config.LoadDefaultConfig(ctx,
+		config.WithRegion(region),
+		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(accessKeyID, secretAccessKey, "")),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("storage: s3-konfiguration laden: %w", err)
+	}
+
+	client := s3.NewFromConfig(cfg, func(o *s3.Options) {
+		if endpointURL != "" {
+			o.BaseEndpoint = aws.String(endpointURL)
+		}
+		o.UsePathStyle = usePathStyle
+	})
+	return &S3Driver{client: client, bucket: bucket}, nil
+}
+
+func (d *S3Driver) Put(ctx context.Context, key string, r io.Reader, _ int64, contentType string) (int64, error) {
+	buf, err := io.ReadAll(r)
+	if err != nil {
+		return 0, fmt.Errorf("storage: objekt vor upload lesen: %w", err)
+	}
+	_, err = d.client.PutObject(ctx, &s3.PutObjectInput{
+		Bucket:        aws.String(d.bucket),
+		Key:           aws.String(key),
+		Body:          bytes.NewReader(buf),
+		ContentLength: aws.Int64(int64(len(buf))),
+		ContentType:   aws.String(contentType),
+	})
+	if err != nil {
+		return 0, fmt.Errorf("storage: s3-upload: %w", err)
+	}
+	return int64(len(buf)), nil
+}
+
+func (d *S3Driver) Get(ctx context.Context, key string) (io.ReadCloser, error) {
+	out, err := d.client.GetObject(ctx, &s3.GetObjectInput{
+		Bucket: aws.String(d.bucket),
+		Key:    aws.String(key),
+	})
+	if err != nil {
+		if isS3NotFound(err) {
+			return nil, ErrNotFound
+		}
+		return nil, fmt.Errorf("storage: s3-download: %w", err)
+	}
+	return out.Body, nil
+}
+
+func (d *S3Driver) Delete(ctx context.Context, key string) error {
+	// S3 liefert bei DeleteObject fuer ein nicht existierendes Objekt
+	// KEINEN Fehler (idempotente S3-API-Semantik) — um denselben
+	// Vertrag wie LocalDriver (ErrNotFound bei fehlendem Objekt) zu
+	// erfüllen, wird die Existenz vorher explizit geprüft.
+	_, err := d.client.HeadObject(ctx, &s3.HeadObjectInput{Bucket: aws.String(d.bucket), Key: aws.String(key)})
+	if err != nil {
+		if isS3NotFound(err) {
+			return ErrNotFound
+		}
+		return fmt.Errorf("storage: s3-existenzprüfung vor löschen: %w", err)
+	}
+
+	if _, err := d.client.DeleteObject(ctx, &s3.DeleteObjectInput{
+		Bucket: aws.String(d.bucket),
+		Key:    aws.String(key),
+	}); err != nil {
+		return fmt.Errorf("storage: s3-löschen: %w", err)
+	}
+	return nil
+}
+
+func isS3NotFound(err error) bool {
+	var nsk *types.NoSuchKey
+	if errors.As(err, &nsk) {
+		return true
+	}
+	var apiErr smithy.APIError
+	if errors.As(err, &apiErr) && apiErr.ErrorCode() == "NotFound" {
+		return true
+	}
+	return false
+}

mail/internal/storage/service.go

@@ -0,0 +1,127 @@
+package storage
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+)
+
+// ErrChecksumMismatch wird von GetVerified geliefert, wenn der beim
+// Lesen berechnete Hash nicht mit der beim Schreiben gespeicherten
+// Prüfsumme übereinstimmt (Akzeptanzkriterium 2 / Pflichtprüfung 2:
+// ein absichtlich beschädigtes Objekt wird erkannt).
+var ErrChecksumMismatch = errors.New("storage: prüfsumme stimmt nicht überein — objekt wurde verändert")
+
+// Service verbindet einen Driver mit Prüfsummenverifikation
+// (Akzeptanzkriterium 2) und der Nutzungsmeldung an Core LIC-05
+// (Akzeptanzkriterium 4) — jeder Schreib-/Löschvorgang über Service
+// löst GENAU EINE Meldung mit der tatsächlich geschriebenen/gelöschten
+// Objektgröße aus. Aufrufer (spätere Tickets, z. B. IMP-*) rufen
+// ausschließlich Service auf, nie einen Driver direkt.
+type Service struct {
+	driver     Driver
+	usage      UsageReporter
+	tenantSlug string
+}
+
+func NewService(driver Driver, usage UsageReporter, tenantSlug string) *Service {
+	return &Service{driver: driver, usage: usage, tenantSlug: tenantSlug}
+}
+
+// Put legt den Inhalt ab UND verifiziert den Schreibvorgang durch
+// Prüfsummenvergleich (Akzeptanzkriterium 2): der Inhalt wird
+// geschrieben, die Prüfsumme als Sidecar-Objekt gespeichert, danach
+// SOFORT zurückgelesen und erneut gehasht — weicht der Rückgelesene
+// Hash vom beim Schreiben berechneten ab, meldet Put einen Fehler,
+// statt eine unbemerkt fehlerhafte Ablage stehen zu lassen. Meldet die
+// geschriebene Größe als positives Delta an Core LIC-05
+// (Akzeptanzkriterium 4).
+func (s *Service) Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) (checksum string, err error) {
+	hasher := sha256.New()
+	tee := io.TeeReader(r, hasher)
+
+	written, err := s.driver.Put(ctx, key, tee, size, contentType)
+	if err != nil {
+		return "", err
+	}
+	checksum = hex.EncodeToString(hasher.Sum(nil))
+
+	if _, err := s.driver.Put(ctx, checksumKey(key), bytes.NewReader([]byte(checksum)), int64(len(checksum)), "text/plain"); err != nil {
+		return "", fmt.Errorf("storage: prüfsumme speichern: %w", err)
+	}
+
+	// Sofortige Rücklese-Verifikation — beweist, dass der Schreibvorgang
+	// tatsächlich verifiziert wurde, nicht nur eine Prüfsumme abgelegt
+	// wurde, die nie geprüft wird.
+	if _, err := s.GetVerified(ctx, key); err != nil {
+		return "", fmt.Errorf("storage: schreibverifikation fehlgeschlagen: %w", err)
+	}
+
+	if err := s.usage.Report(ctx, s.tenantSlug, UsageMetric, written); err != nil {
+		return checksum, fmt.Errorf("storage: objekt gespeichert, aber nutzungsmeldung fehlgeschlagen: %w", err)
+	}
+	return checksum, nil
+}
+
+// Get liefert den Inhalt UNVERIFIZIERT (Streaming, für große Objekte).
+// Für die Pflichtprüfung "beschädigtes Objekt wird erkannt" GetVerified
+// verwenden.
+func (s *Service) Get(ctx context.Context, key string) (io.ReadCloser, error) {
+	return s.driver.Get(ctx, key)
+}
+
+// GetVerified liest den vollständigen Inhalt UND vergleicht die beim
+// Schreiben gespeicherte Prüfsumme gegen den beim Lesen berechneten
+// Hash (Akzeptanzkriterium 2 / Pflichtprüfung 2).
+func (s *Service) GetVerified(ctx context.Context, key string) ([]byte, error) {
+	sumReader, err := s.driver.Get(ctx, checksumKey(key))
+	if err != nil {
+		return nil, fmt.Errorf("storage: gespeicherte prüfsumme lesen: %w", err)
+	}
+	expectedRaw, err := io.ReadAll(sumReader)
+	_ = sumReader.Close()
+	if err != nil {
+		return nil, fmt.Errorf("storage: gespeicherte prüfsumme lesen: %w", err)
+	}
+	expected := string(expectedRaw)
+
+	contentReader, err := s.driver.Get(ctx, key)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = contentReader.Close() }()
+
+	hasher := sha256.New()
+	content, err := io.ReadAll(io.TeeReader(contentReader, hasher))
+	if err != nil {
+		return nil, fmt.Errorf("storage: objekt lesen: %w", err)
+	}
+	actual := hex.EncodeToString(hasher.Sum(nil))
+	if actual != expected {
+		return nil, ErrChecksumMismatch
+	}
+	return content, nil
+}
+
+// Delete entfernt Inhalt UND Prüfsummen-Sidecar, meldet die Größe als
+// negatives Delta an Core LIC-05 (Akzeptanzkriterium 4) — der Aufrufer
+// muss die Größe kennen (Delete selbst kann sie nach dem Löschen nicht
+// mehr ermitteln).
+func (s *Service) Delete(ctx context.Context, key string, sizeBytes int64) error {
+	if err := s.driver.Delete(ctx, key); err != nil {
+		return err
+	}
+	// Sidecar-Löschung ist best effort — ein fehlendes Sidecar (z. B.
+	// bei einem sehr alten Objekt) darf den eigentlichen Löschvorgang
+	// nicht blockieren.
+	_ = s.driver.Delete(ctx, checksumKey(key))
+
+	if err := s.usage.Report(ctx, s.tenantSlug, UsageMetric, -sizeBytes); err != nil {
+		return fmt.Errorf("storage: objekt gelöscht, aber nutzungsmeldung fehlgeschlagen: %w", err)
+	}
+	return nil
+}

mail/internal/storage/service_test.go

@@ -0,0 +1,134 @@
+package storage
+
+import (
+	"context"
+	"errors"
+	"os"
+	"strings"
+	"testing"
+	"time"
+)
+
+type fakeUsageReporter struct {
+	reports []int64
+}
+
+func (f *fakeUsageReporter) Report(_ context.Context, _, metric string, delta int64) error {
+	if metric != UsageMetric {
+		return errors.New("unerwartete metrik: " + metric)
+	}
+	f.reports = append(f.reports, delta)
+	return nil
+}
+
+func newTestService(t *testing.T) (*Service, *fakeUsageReporter) {
+	t.Helper()
+	driver := NewLocalDriver(t.TempDir())
+	usage := &fakeUsageReporter{}
+	return NewService(driver, usage, "acme"), usage
+}
+
+// TestPut_ReadBackIsByteIdentical ist die geforderte Pflichtprüfung 1:
+// ein geschriebenes Objekt liefert beim Lesen byteidentischen Inhalt.
+func TestPut_ReadBackIsByteIdentical(t *testing.T) {
+	svc, _ := newTestService(t)
+	ctx := context.Background()
+	key := ObjectKey("msg-1", 0)
+	content := "vollständig identischer Inhalt äöü"
+
+	checksum, err := svc.Put(ctx, key, strings.NewReader(content), int64(len(content)), "text/plain")
+	if err != nil {
+		t.Fatalf("put: %v", err)
+	}
+	if checksum == "" {
+		t.Fatal("erwartet nicht-leere prüfsumme")
+	}
+
+	got, err := svc.GetVerified(ctx, key)
+	if err != nil {
+		t.Fatalf("getverified: %v", err)
+	}
+	if string(got) != content {
+		t.Fatalf("nicht byteidentisch: got %q, want %q", got, content)
+	}
+}
+
+// TestGetVerified_DetectsTamperedObject ist die geforderte
+// Pflichtprüfung 2: ein absichtlich beschädigtes Objekt wird bei
+// Prüfsummenvergleich erkannt.
+func TestGetVerified_DetectsTamperedObject(t *testing.T) {
+	dir := t.TempDir()
+	driver := NewLocalDriver(dir)
+	usage := &fakeUsageReporter{}
+	svc := NewService(driver, usage, "acme")
+	ctx := context.Background()
+	key := ObjectKey("msg-tamper", 0)
+
+	if _, err := svc.Put(ctx, key, strings.NewReader("originaler inhalt"), 17, "text/plain"); err != nil {
+		t.Fatalf("put: %v", err)
+	}
+
+	// Objekt DIREKT am Dateisystem manipulieren — umgeht Service
+	// vollständig, simuliert externe Beschädigung/Manipulation.
+	full := driver.path(key)
+	if err := os.WriteFile(full, []byte("MANIPULIERTER INHALT"), 0o644); err != nil {
+		t.Fatalf("manipulation schreiben: %v", err)
+	}
+
+	_, err := svc.GetVerified(ctx, key)
+	if !errors.Is(err, ErrChecksumMismatch) {
+		t.Fatalf("erwartet ErrChecksumMismatch bei manipuliertem objekt, habe: %v", err)
+	}
+}
+
+// TestPut_ManySmallObjectsAcceptableLatency ist die geforderte
+// Pflichtprüfung 3: Lasttest mit vielen kleinen Objekten bestätigt
+// akzeptable Latenz.
+func TestPut_ManySmallObjectsAcceptableLatency(t *testing.T) {
+	svc, _ := newTestService(t)
+	ctx := context.Background()
+
+	const count = 500
+	start := time.Now()
+	for i := 0; i < count; i++ {
+		key := ObjectKey("msg-load", i)
+		if _, err := svc.Put(ctx, key, strings.NewReader("kleiner anhang inhalt"), 21, "text/plain"); err != nil {
+			t.Fatalf("put #%d: %v", i, err)
+		}
+	}
+	elapsed := time.Since(start)
+	avgPerObject := elapsed / count
+
+	// Großzügige Grenze (10ms/Objekt inkl. Schreiben+Sidecar+Rücklese-
+	// Verifikation) — Ziel ist der Nachweis, dass keine quadratische
+	// oder anderweitig unverhältnismäßige Verschlechterung auftritt,
+	// nicht ein knallhartes Performance-SLA.
+	if avgPerObject > 10*time.Millisecond {
+		t.Fatalf("erwartet akzeptable latenz (<10ms/objekt), habe %v/objekt (gesamt %v für %d objekte)", avgPerObject, elapsed, count)
+	}
+	t.Logf("Lasttest: %d Objekte in %v (%v/Objekt)", count, elapsed, avgPerObject)
+}
+
+// TestPut_ReportsUsageOnWriteAndDelete ist die geforderte
+// Pflichtprüfung 4: Melde-Aufruf an Core LIC-05 bei Schreib- und
+// Löschvorgang nachweislich ausgelöst, mit korrekter Größenangabe.
+func TestPut_ReportsUsageOnWriteAndDelete(t *testing.T) {
+	svc, usage := newTestService(t)
+	ctx := context.Background()
+	key := ObjectKey("msg-usage", 0)
+	content := "zwölf bytes!"
+
+	if _, err := svc.Put(ctx, key, strings.NewReader(content), int64(len(content)), "text/plain"); err != nil {
+		t.Fatalf("put: %v", err)
+	}
+	if len(usage.reports) != 1 || usage.reports[0] != int64(len(content)) {
+		t.Fatalf("erwartet genau eine positive meldung mit größe %d, habe: %v", len(content), usage.reports)
+	}
+
+	if err := svc.Delete(ctx, key, int64(len(content))); err != nil {
+		t.Fatalf("delete: %v", err)
+	}
+	if len(usage.reports) != 2 || usage.reports[1] != -int64(len(content)) {
+		t.Fatalf("erwartet zusätzliche negative meldung mit -%d, habe: %v", len(content), usage.reports)
+	}
+}

mail/internal/storage/usagereport.go

@@ -0,0 +1,75 @@
+package storage
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+// UsageMetric ist der Metrikname, unter dem Core (internal/usage,
+// LIC-05) den Speicherverbrauch je Mandant führt — muss exakt
+// internal/usage.StorageBytesMetric aus dem NEXARCH-Core-Modul
+// entsprechen (Mail kann Core nicht importieren, daher hier gespiegelt
+// — identisches Muster wie DMS FDN-03).
+const UsageMetric = "storage_bytes"
+
+// UsageReporter meldet Speicherverbrauchsänderungen an Core
+// (Akzeptanzkriterium 4). Schmale Schnittstelle, damit Tests einen
+// Fake statt eines echten HTTP-Aufrufs einsetzen können.
+type UsageReporter interface {
+	Report(ctx context.Context, tenantSlug, metric string, delta int64) error
+}
+
+// usageDeltaDTO entspricht Core internal/resync.usageDeltaDTO
+// (JSON-Vertrag: tenant_slug/metric/delta), über den API-11
+// (resync-api) real erreichbar ist.
+type usageDeltaDTO struct {
+	TenantSlug string `json:"tenant_slug"`
+	Metric     string `json:"metric"`
+	Delta      int64  `json:"delta"`
+}
+
+// HTTPUsageReporter meldet über Core API-11 (resync-api,
+// internal/resync.Handler.UsageHandler), authentifiziert über
+// dasselbe Service-Credential-Verfahren wie jeder andere Modul-Core-
+// Aufruf (API-02).
+type HTTPUsageReporter struct {
+	endpointURL  string
+	clientID     string
+	clientSecret string
+	httpClient   *http.Client
+}
+
+func NewHTTPUsageReporter(endpointURL, clientID, clientSecret string, httpClient *http.Client) *HTTPUsageReporter {
+	if httpClient == nil {
+		httpClient = http.DefaultClient
+	}
+	return &HTTPUsageReporter{endpointURL: endpointURL, clientID: clientID, clientSecret: clientSecret, httpClient: httpClient}
+}
+
+func (r *HTTPUsageReporter) Report(ctx context.Context, tenantSlug, metric string, delta int64) error {
+	body, err := json.Marshal([]usageDeltaDTO{{TenantSlug: tenantSlug, Metric: metric, Delta: delta}})
+	if err != nil {
+		return fmt.Errorf("storage: nutzungsmeldung serialisieren: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, r.endpointURL, bytes.NewReader(body))
+	if err != nil {
+		return fmt.Errorf("storage: nutzungsmeldungs-anfrage aufbauen: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Nexarch-Client-Id", r.clientID)
+	req.Header.Set("X-Nexarch-Client-Secret", r.clientSecret)
+
+	resp, err := r.httpClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("storage: nutzungsmeldung senden: %w", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("storage: nutzungsmeldung von core abgelehnt: status %d", resp.StatusCode)
+	}
+	return nil
+}