Files
nexarch/archive/internal/backup/encryption_test.go
patrickandClaude Sonnet 5 70e9a82531 BAK-09: kekclient und backupcrypto fuer envelope-verschluesselung von backups
- kekclient: Archive-eigener HTTP-Client fuer Core API-10
  (internal/kek.Handler.TenantKEKHandler), gespiegelt aus
  dms/internal/crypto.HTTPKEKProvider (FDN-09) - Archive kann Cores
  internal/kek nicht importieren (getrenntes Go-Modul)
- backupcrypto: AES-256-GCM-Envelope-Primitive (DEK generieren, mit
  Tenant-KEK ver-/entpacken) sowie Datei-Ver-/Entschluesselung mit
  Envelope-Metadaten-Sidecar
- backup: EncryptGeneration/DecryptedRestore verschluesseln bzw.
  entschluesseln die BAK-01-Sicherungsdateien (base.tar.gz,
  pg_wal.tar.gz) einer Generation mit dem Tenant-KEK, ohne die
  bestehende Restore-Funktion zu veraendern

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QPsyieCYwvbUBsnN598SbP
2026-09-17 15:20:58 +02:00

139 lines
4.4 KiB
Go

package backup
import (
"bytes"
"context"
"errors"
"os"
"path/filepath"
"testing"
"time"
)
// fakeKEKProvider liefert deterministische, tenant-spezifische KEKs für
// Tests, ohne einen echten Core-API-10-Aufruf zu brauchen.
type fakeKEKProvider struct {
keks map[string][]byte
}
func newFakeKEKProvider() *fakeKEKProvider {
return &fakeKEKProvider{keks: map[string][]byte{
"mandant-a": bytes.Repeat([]byte{0xAA}, 32),
"mandant-b": bytes.Repeat([]byte{0xBB}, 32),
}}
}
func (f *fakeKEKProvider) TenantKEK(ctx context.Context, tenantSlug string) ([]byte, error) {
kek, ok := f.keks[tenantSlug]
if !ok {
return nil, errors.New("fakeKEKProvider: unbekannter mandant")
}
return kek, nil
}
// TestEncryptGeneration_RemovesPlaintextReadability ist Prüfung 1 (BAK-09):
// die verschlüsselte Sicherungsdatei enthält keine erkennbaren
// Klartext-Reste des Originals mehr (Akzeptanzkriterium 2).
func TestEncryptGeneration_RemovesPlaintextReadability(t *testing.T) {
cfg := requireTestConfig(t)
ctx := context.Background()
provider := newFakeKEKProvider()
genID := NewGenerationID(time.Now())
manifest, err := FullBackup(ctx, cfg, genID)
if err != nil {
t.Fatalf("fullbackup: %v", err)
}
dir := filepath.Dir(manifest)
plaintext, err := os.ReadFile(filepath.Join(dir, BaseTarGzFile))
if err != nil {
t.Fatalf("klartext-sicherung lesen: %v", err)
}
if err := EncryptGeneration(ctx, provider, "mandant-a", cfg, genID); err != nil {
t.Fatalf("encryptgeneration: %v", err)
}
ciphertext, err := os.ReadFile(filepath.Join(dir, BaseTarGzFile))
if err != nil {
t.Fatalf("verschluesselte sicherung lesen: %v", err)
}
if bytes.Contains(ciphertext, plaintext[:512]) {
t.Fatal("verschluesselte sicherung enthaelt noch einen erkennbaren klartext-abschnitt des originals")
}
// gzip-Magic-Bytes duerfen im Chiffretext nicht mehr am Dateianfang
// auftauchen - ein Angreifer ohne Tenant-KEK kann die Datei nicht
// einmal als gzip identifizieren, geschweige denn entpacken.
if bytes.HasPrefix(ciphertext, []byte{0x1f, 0x8b}) {
t.Fatal("verschluesselte sicherung beginnt weiterhin mit dem gzip-magic-byte - keine echte verschluesselung")
}
envelopePath := filepath.Join(dir, BaseTarGzFile+".envelope.json")
if _, err := os.Stat(envelopePath); err != nil {
t.Fatalf("envelope-metadaten fehlen: %v", err)
}
}
// TestDecryptedRestore_WithCorrectTenantKEK ist Prüfung 2 (BAK-09):
// Wiederherstellung mit korrektem Tenant-KEK stellt die Daten vollständig
// wieder her (Akzeptanzkriterium 3).
func TestDecryptedRestore_WithCorrectTenantKEK(t *testing.T) {
cfg := requireTestConfig(t)
ctx := context.Background()
provider := newFakeKEKProvider()
genID := NewGenerationID(time.Now())
manifest, err := FullBackup(ctx, cfg, genID)
if err != nil {
t.Fatalf("fullbackup: %v", err)
}
if err := Verify(filepath.Dir(manifest)); err != nil {
t.Fatalf("verify vor verschluesselung: %v", err)
}
if err := EncryptGeneration(ctx, provider, "mandant-a", cfg, genID); err != nil {
t.Fatalf("encryptgeneration: %v", err)
}
outputDir := t.TempDir()
// pg_combinebackup verlangt ein leeres Zielverzeichnis.
if err := os.RemoveAll(outputDir); err != nil {
t.Fatalf("outputdir entfernen: %v", err)
}
if err := DecryptedRestore(ctx, provider, "mandant-a", cfg, genID, outputDir); err != nil {
t.Fatalf("decryptedrestore mit korrektem tenant-kek: %v", err)
}
if _, err := os.Stat(filepath.Join(outputDir, "PG_VERSION")); err != nil {
t.Fatalf("wiederhergestelltes pgdata-verzeichnis unvollstaendig, PG_VERSION fehlt: %v", err)
}
}
// TestDecryptedRestore_WithWrongTenantKEK ist Prüfung 3 (BAK-09): Restore
// mit falschem/fremdem Tenant-KEK schlägt fehl, statt fremde Daten zu
// liefern (Akzeptanzkriterium 2/3).
func TestDecryptedRestore_WithWrongTenantKEK(t *testing.T) {
cfg := requireTestConfig(t)
ctx := context.Background()
provider := newFakeKEKProvider()
genID := NewGenerationID(time.Now())
manifest, err := FullBackup(ctx, cfg, genID)
if err != nil {
t.Fatalf("fullbackup: %v", err)
}
if err := EncryptGeneration(ctx, provider, "mandant-a", cfg, genID); err != nil {
t.Fatalf("encryptgeneration: %v", err)
}
_ = manifest
outputDir := t.TempDir()
if err := os.RemoveAll(outputDir); err != nil {
t.Fatalf("outputdir entfernen: %v", err)
}
err = DecryptedRestore(ctx, provider, "mandant-b", cfg, genID, outputDir)
if err == nil {
t.Fatal("decryptedrestore mit fremdem tenant-kek haette fehlschlagen muessen, lieferte aber keinen fehler")
}
}