Files
nexarch/archive/internal/backup/encryption.go
patrickandClaude Sonnet 5 3a56756e41 BAK-09: envelope-metadaten beim rename mitfuehren, tenant-verschluesseltes objectbackup-config
EncryptGeneration liess die von EncryptFile geschriebene Envelope-Sidecar-
Datei am tmp-Pfad zuruck statt sie mit der Hauptdatei an den finalen Ort
zu verschieben - Restore haette den DEK nicht mehr entpacken koennen.

TenantEncryptedConfig baut fuer objectbackup (BAK-01/02) ein Config mit
tenant-KEK-gebundenem restic-Passwort, analog zur DB-Backup-Verschluesselung.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-17 16:20:39 +02:00

127 lines
4.6 KiB
Go

package backup
import (
"context"
"fmt"
"os"
"path/filepath"
"gitea.perlbach24.de/scripte/nexarch/archive/internal/backupcrypto"
"gitea.perlbach24.de/scripte/nexarch/archive/internal/kekclient"
)
// encryptedFiles sind die Sicherungsinhalte je Stufenverzeichnis, die
// tatsaechliche Nutzdaten enthalten (BAK-09, Akzeptanzkriterium 1) —
// BackupManifestFile bleibt bewusst im Klartext, es enthaelt nur
// Pruefsummen/Struktur, keine Klartext-Nutzdaten, und wird von
// pg_combinebackup direkt gelesen.
var encryptedFiles = []string{BaseTarGzFile, WalTarGzFile}
// EncryptGeneration verschluesselt die Nutzdatendateien einer bereits
// erstellten Generation (Voll- und alle Inkrement-Stufen) in-place mit dem
// Tenant-KEK von tenantSlug (BAK-09, Akzeptanzkriterium 1). Nach
// erfolgreichem Aufruf liegen im Sicherungsverzeichnis nur noch
// Chiffretext und Envelope-Metadaten, keine Klartext-Nutzdaten mehr.
func EncryptGeneration(ctx context.Context, provider kekclient.Provider, tenantSlug string, cfg Config, generationID string) error {
genDir := filepath.Join(cfg.BackupDir, generationID)
stageDirs, err := stageDirsOf(genDir)
if err != nil {
return err
}
for _, stageDir := range stageDirs {
for _, name := range encryptedFiles {
path := filepath.Join(stageDir, name)
if _, err := os.Stat(path); err != nil {
continue
}
tmp := path + ".enctmp"
if err := backupcrypto.EncryptFile(ctx, provider, tenantSlug, path, tmp); err != nil {
return fmt.Errorf("backup: %q verschluesseln: %w", path, err)
}
if err := os.Rename(tmp, path); err != nil {
return fmt.Errorf("backup: verschluesselte datei %q an ort verschieben: %w", path, err)
}
if err := os.Rename(tmp+backupcrypto.EnvelopeSuffix, path+backupcrypto.EnvelopeSuffix); err != nil {
return fmt.Errorf("backup: envelope-metadaten fuer %q an ort verschieben: %w", path, err)
}
}
}
return nil
}
// DecryptedRestore entschluesselt eine mit EncryptGeneration gesicherte
// Generation in ein temporaeres Verzeichnis und ruft anschliessend die
// unveraendert gebliebene Restore-Funktion darauf auf (BAK-09,
// Akzeptanzkriterium 3: Wiederherstellung funktioniert unveraendert bei
// korrektem Tenant-KEK). Schlaegt fehl, wenn provider fuer tenantSlug
// nicht den beim Verschluesseln verwendeten Tenant-KEK liefert.
func DecryptedRestore(ctx context.Context, provider kekclient.Provider, tenantSlug string, cfg Config, generationID, outputDir string) error {
genDir := filepath.Join(cfg.BackupDir, generationID)
stageDirs, err := stageDirsOf(genDir)
if err != nil {
return err
}
plainRoot, err := os.MkdirTemp("", "backup-decrypt-*")
if err != nil {
return fmt.Errorf("backup: entschluesselungs-verzeichnis anlegen: %w", err)
}
defer func() { _ = os.RemoveAll(plainRoot) }()
plainGenDir := filepath.Join(plainRoot, generationID)
for _, stageDir := range stageDirs {
rel, err := filepath.Rel(genDir, stageDir)
if err != nil {
return fmt.Errorf("backup: relativen stufenpfad ermitteln: %w", err)
}
plainStageDir := filepath.Join(plainGenDir, rel)
if err := os.MkdirAll(plainStageDir, 0o750); err != nil {
return fmt.Errorf("backup: entschluesseltes stufenverzeichnis anlegen: %w", err)
}
manifestData, err := os.ReadFile(filepath.Join(stageDir, BackupManifestFile))
if err != nil {
return fmt.Errorf("backup: %q lesen: %w", BackupManifestFile, err)
}
if err := os.WriteFile(filepath.Join(plainStageDir, BackupManifestFile), manifestData, 0o600); err != nil {
return fmt.Errorf("backup: manifest kopieren: %w", err)
}
for _, name := range encryptedFiles {
srcPath := filepath.Join(stageDir, name)
if _, err := os.Stat(srcPath); err != nil {
continue
}
dstPath := filepath.Join(plainStageDir, name)
if err := backupcrypto.DecryptFile(ctx, provider, tenantSlug, srcPath, dstPath); err != nil {
return fmt.Errorf("backup: %q entschluesseln: %w", srcPath, err)
}
}
}
plainCfg := cfg
plainCfg.BackupDir = plainRoot
return Restore(ctx, plainCfg, generationID, outputDir)
}
// stageDirsOf liefert das Vollsicherungsverzeichnis und alle vorhandenen
// Inkrement-Stufenverzeichnisse einer Generation.
func stageDirsOf(genDir string) ([]string, error) {
stageDirs := []string{filepath.Join(genDir, FullBackupDirName)}
incrDir := filepath.Join(genDir, IncrementalSubdir)
entries, err := os.ReadDir(incrDir)
if err != nil {
if os.IsNotExist(err) {
return stageDirs, nil
}
return nil, fmt.Errorf("backup: inkrement-verzeichnis lesen: %w", err)
}
for _, e := range entries {
if e.IsDir() {
stageDirs = append(stageDirs, filepath.Join(incrDir, e.Name()))
}
}
return stageDirs, nil
}