- 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
139 lines
4.4 KiB
Go
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")
|
|
}
|
|
}
|