ARC-02: verschluesselung-at-rest

- mail/internal/crypto: Envelope-Encryption (AES-256-GCM), DEK pro Objekt, HTTPKEKProvider bezieht Tenant-KEK ueber Core API-12 - bewaehrtes Muster aus DMS FDN-09, Neuimplementierung (Mail kann DMS nicht importieren) - mail/internal/encstorage: verbindet ARC-01 (storage.Service) mit ARC-02 (crypto.Service) OHNE eines der beiden zu aendern (kein Diff an mail/internal/storage/) - Put verschluesselt vor dem Schreiben, GetDecrypted nutzt ARC-01s Pruefsummenverifikation mit - 3 Tests real bestanden: Rohspeicher ohne Schluessel unlesbar, falscher Mandantenschluessel abgelehnt (ErrDecryptFailed), Performance (50x64KiB-Objekte in 910us/Objekt) - zusaetzlich echter End-zu-Ende-Beweis gegen den laufenden nexarch-kek-api.service (API-12): vollstaendiger Put->GetDecrypted- Roundtrip ueber echten HTTP-KEK-Bezug, nicht-existenter Tenant real abgelehnt (404) - offener Punkt ehrlich vermerkt: internal/crypto/internal/encstorage fehlen noch in QA-01s Pflichttest-Gate-Pfadmustern Pruefungen siehe mail/docs/ARC-02-PRUEFPROTOKOLL.md
2026-08-30 23:58:44 +02:00
parent ee98efb51e
commit cb5a9da701
6 changed files with 567 additions and 0 deletions
@@ -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
+}
@@ -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
+}
@@ -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)
+}