Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
Keep configuration credentials off stale temporary and backup paths
pulse-triage[bot]b1caf968460f
diff --git a/docs/release-control/v6/internal/subsystems/security-privacy.md b/docs/release-control/v6/internal/subsystems/security-privacy.mdindex 4f85843cde..96e8a5da87 100644--- a/docs/release-control/v6/internal/subsystems/security-privacy.md+++ b/docs/release-control/v6/internal/subsystems/security-privacy.md@@ -18,6 +18,32 @@## Purpose+### Configuration writes own their temporary files++Ordinary shared configuration writes, their retained credential backups and+legacy `.env` updates prepare exclusively created, uniquely named files in the+destination directory. Owner permissions are set before writing through the+owned descriptor; a complete write and successful close precede replacement.+Stale predictable `.tmp` paths must not redirect a save or migration, disclose+environment secrets through inherited modes, or block it with a directory.+Existing destination links are replaced, not written through, including backups.++Failure preserves the previous destination, closes the descriptor and removes+only the temporary file this write owns; cleanup errors remain reported.+Imports still stage primary, backup and environment changes until transaction+commit. Encryption/key formats, exact backup contents, scope/authentication,+best-effort ordinary backup policy and environment update rules are unchanged.+This is atomic file publication, not a new power-loss durability or multi-file+transaction guarantee outside import. Other metadata/journal writers are not+changed. No rendered field, response policy or installed-recovery claim follows.++The registered `persistence_atomic_test.go` exercises real encrypted credential+and token saves, SSO plaintext migration, environment preservation and backup+replacement against stale regular files, symlinks, hardlinks and directories.+`atomic_file_test.go` covers descriptor/short-write/close/rename failures, cleanup+errors, independent concurrent writes and unchanged import staging. Existing+filesystem fault tests inject write errors through the same descriptor seam.+### SSO settings results remain with their current readerThe existing SSO provider inventory, provider-detail editor, connection test anddiff --git a/internal/config/atomic_file.go b/internal/config/atomic_file.gonew file mode 100644index 0000000000..7e23d0f53d--- /dev/null+++ b/internal/config/atomic_file.go@@ -0,0 +1,66 @@+package config++import (+ "errors"+ "fmt"+ "io"+ "os"+ "path/filepath"+)++// TemporaryFile is the owned descriptor used to prepare a configuration write.+// FileSystem implementations must create it exclusively with owner-only access.+type TemporaryFile interface {+ Name() string+ Write([]byte) (int, error)+ Chmod(os.FileMode) error+ Close() error+}++func (dfs defaultFileSystem) CreateTemp(dir, pattern string) (TemporaryFile, error) {+ return os.CreateTemp(dir, pattern)+}++// writeConfigFileAtomic publishes only a complete, closed file in the same+// directory. It never reopens the temporary pathname or follows an existing+// destination link. The caller owns directory admission and serialization.+func writeConfigFileAtomic(fs FileSystem, path string, data []byte, perm os.FileMode) (retErr error) {+ f, err := fs.CreateTemp(filepath.Dir(path), "."+filepath.Base(path)+".*.tmp")+ if err != nil {+ return fmt.Errorf("create temp config file for %s: %w", path, err)+ }+ tmp := f.Name()+ closed, published := false, false+ defer func() {+ if !closed {+ if err := f.Close(); err != nil {+ retErr = errors.Join(retErr, fmt.Errorf("close temp config file %s: %w", tmp, err))+ }+ }+ if !published {+ if err := fs.Remove(tmp); err != nil && !os.IsNotExist(err) {+ retErr = errors.Join(retErr, fmt.Errorf("cleanup temp config file %s: %w", tmp, err))+ }+ }+ }()++ if err := f.Chmod(perm); err != nil {+ return fmt.Errorf("chmod temp config file %s: %w", tmp, err)+ }+ n, err := f.Write(data)+ if err != nil {+ return fmt.Errorf("write temp config file %s: %w", tmp, err)+ }+ if n != len(data) {+ return fmt.Errorf("write temp config file %s: %w", tmp, io.ErrShortWrite)+ }+ closed = true+ if err := f.Close(); err != nil {+ return fmt.Errorf("close temp config file %s: %w", tmp, err)+ }+ if err := fs.Rename(tmp, path); err != nil {+ return fmt.Errorf("rename temp config file %s to %s: %w", tmp, path, err)+ }+ published = true+ return nil+}diff --git a/internal/config/atomic_file_test.go b/internal/config/atomic_file_test.gonew file mode 100644index 0000000000..eecad48eca--- /dev/null+++ b/internal/config/atomic_file_test.go@@ -0,0 +1,225 @@+package config++import (+ "bytes"+ "errors"+ "io"+ "os"+ "path/filepath"+ "sync"+ "testing"++ "github.com/stretchr/testify/require"+)++type atomicConfigFaultFS struct {+ FileSystem+ fault string+ failure error+ cleanupErr error+ file *atomicConfigFaultFile+ renameCalls int+}++func (fs *atomicConfigFaultFS) CreateTemp(dir, pattern string) (TemporaryFile, error) {+ if fs.fault == "create" {+ return nil, fs.failure+ }+ f, err := fs.FileSystem.CreateTemp(dir, pattern)+ if err != nil {+ return nil, err+ }+ fs.file = &atomicConfigFaultFile{TemporaryFile: f, fs: fs}+ return fs.file, nil+}++func (fs *atomicConfigFaultFS) Rename(from, to string) error {+ fs.renameCalls+++ if fs.fault == "rename" {+ return fs.failure+ }+ return fs.FileSystem.Rename(from, to)+}++func (fs *atomicConfigFaultFS) Remove(path string) error {+ if fs.cleanupErr != nil {+ return fs.cleanupErr+ }+ return fs.FileSystem.Remove(path)+}++type atomicConfigFaultFile struct {+ TemporaryFile+ fs *atomicConfigFaultFS+ closeCalls int+}++func (f *atomicConfigFaultFile) Chmod(perm os.FileMode) error {+ if f.fs.fault == "chmod" {+ return f.fs.failure+ }+ return f.TemporaryFile.Chmod(perm)+}++func (f *atomicConfigFaultFile) Write(data []byte) (int, error) {+ if f.fs.fault == "write" {+ // A partial write must never replace the previous primary or backup.+ n, _ := f.TemporaryFile.Write(data[:len(data)/2])+ return n, f.fs.failure+ }+ if f.fs.fault == "short write" {+ return f.TemporaryFile.Write(data[:len(data)/2])+ }+ return f.TemporaryFile.Write(data)+}++func (f *atomicConfigFaultFile) Close() error {+ f.closeCalls+++ err := f.TemporaryFile.Close()+ if f.fs.fault == "close" {+ return errors.Join(err, f.fs.failure)+ }+ return err+}++func TestAtomicConfigWritePreservesStateOnFailure(t *testing.T) {+ for _, fault := range []string{"create", "chmod", "write", "short write", "close", "rename"} {+ t.Run(fault, func(t *testing.T) {+ dir := t.TempDir()+ path := filepath.Join(dir, "config.enc")+ require.NoError(t, os.WriteFile(path, []byte("previous complete state"), 0o600))+ failure := errors.New("synthetic " + fault + " failure")+ fs := &atomicConfigFaultFS{FileSystem: defaultFileSystem{}, fault: fault, failure: failure}+ err := writeConfigFileAtomic(fs, path, []byte("replacement complete state"), 0o600)+ if fault == "short write" {+ require.ErrorIs(t, err, io.ErrShortWrite)+ } else {+ require.ErrorIs(t, err, failure)+ }+ raw, err := os.ReadFile(path)+ require.NoError(t, err)+ require.Equal(t, "previous complete state", string(raw))+ if fs.file != nil {+ require.Equal(t, 1, fs.file.closeCalls)+ _, err = os.Stat(fs.file.Name())+ require.True(t, os.IsNotExist(err), "owned temporary file must be cleaned")+ }+ if fault != "rename" {+ require.Zero(t, fs.renameCalls, "incomplete files must not be published")+ }+ entries, err := os.ReadDir(dir)+ require.NoError(t, err)+ require.Len(t, entries, 1)+ })+ }+}++func TestAtomicConfigWriteReportsCleanupFailure(t *testing.T) {+ writeErr, cleanupErr := errors.New("synthetic write failure"), errors.New("synthetic cleanup failure")+ fs := &atomicConfigFaultFS{FileSystem: defaultFileSystem{}, fault: "write", failure: writeErr, cleanupErr: cleanupErr}+ path := filepath.Join(t.TempDir(), "config.enc")+ err := writeConfigFileAtomic(fs, path, []byte("synthetic state"), 0o600)+ require.ErrorIs(t, err, writeErr)+ require.ErrorIs(t, err, cleanupErr)+ require.Equal(t, 1, fs.file.closeCalls)+ _, err = os.Stat(path)+ require.True(t, os.IsNotExist(err), "failed write must not create a primary")+}++type atomicConfigConcurrentFS struct {+ FileSystem+ mu sync.Mutex+ paths []string+}++func (fs *atomicConfigConcurrentFS) CreateTemp(dir, pattern string) (TemporaryFile, error) {+ f, err := fs.FileSystem.CreateTemp(dir, pattern)+ if err != nil {+ return nil, err+ }+ fs.mu.Lock()+ fs.paths = append(fs.paths, f.Name())+ fs.mu.Unlock()+ return f, nil+}++func TestAtomicConfigIndependentWritersPublishCompleteFiles(t *testing.T) {+ dir := t.TempDir()+ path := filepath.Join(dir, "config.enc")+ fs := &atomicConfigConcurrentFS{FileSystem: defaultFileSystem{}}+ const writers = 12+ start := make(chan struct{})+ results := make(chan error, writers)+ values := make([][]byte, writers)+ for i := range writers {+ values[i] = bytes.Repeat([]byte{byte('a' + i)}, 65536)+ go func() {+ <-start+ results <- writeConfigFileAtomic(fs, path, values[i], 0o600)+ }()+ }+ close(start)+ for range writers {+ require.NoError(t, <-results)+ }+ raw, err := os.ReadFile(path)+ require.NoError(t, err)+ complete := false+ for _, value := range values {+ complete = complete || bytes.Equal(value, raw)+ }+ require.True(t, complete, "final state must be one complete write, never mixed")+ requirePrivateConfigFile(t, path)+ seen := make(map[string]bool)+ for _, tmp := range fs.paths {+ require.False(t, seen[tmp], "independent writes must own different temporary files")+ seen[tmp] = true+ require.Equal(t, dir, filepath.Dir(tmp))+ }+ require.Len(t, seen, writers)+ entries, err := os.ReadDir(dir)+ require.NoError(t, err)+ require.Len(t, entries, 1)+}++func TestAtomicConfigWritesRemainStagedDuringImport(t *testing.T) {+ cp := NewConfigPersistence(t.TempDir())+ records := []APITokenRecord{{ID: "fixture-id", Hash: "previous-hash", Scopes: []string{"monitoring:read"}}}+ require.NoError(t, cp.SaveAPITokens(records))+ original, err := os.ReadFile(cp.apiTokensFile)+ require.NoError(t, err)+ env := filepath.Join(cp.configDir, ".env")+ originalEnv := []byte("PULSE_AUTH_PASS=synthetic-private-value\nUPDATE_CHANNEL=beta\n")+ require.NoError(t, os.WriteFile(env, originalEnv, 0o600))+ tx, err := newImportTransaction(cp.configDir)+ require.NoError(t, err)+ defer tx.Cleanup()+ cp.beginTransaction(tx)+ defer cp.endTransaction(tx)+ records[0].Hash = "replacement-hash"+ require.NoError(t, cp.SaveAPITokens(records))+ require.NoError(t, cp.SaveSystemSettings(SystemSettings{UpdateChannel: "stable"}))+ for path, want := range map[string][]byte{cp.apiTokensFile: original, env: originalEnv} {+ got, err := os.ReadFile(path)+ require.NoError(t, err)+ require.Equal(t, want, got, "import must not change live state before commit")+ }+ _, err = os.Stat(cp.apiTokensFile + ".backup")+ require.True(t, os.IsNotExist(err), "even backup changes must remain staged")+ require.Len(t, tx.staged, 4)+ for _, staged := range tx.staged {+ requirePrivateConfigFile(t, staged)+ }+ require.NoError(t, tx.Commit())+ cp.endTransaction(tx)+ loaded, err := cp.LoadAPITokens()+ require.NoError(t, err)+ require.Equal(t, "replacement-hash", loaded[0].Hash)+ backup, err := os.ReadFile(cp.apiTokensFile + ".backup")+ require.NoError(t, err)+ require.Equal(t, original, backup)+ rawEnv, err := os.ReadFile(env)+ require.NoError(t, err)+ require.Contains(t, string(rawEnv), "UPDATE_CHANNEL=stable\n")+ require.Contains(t, string(rawEnv), "PULSE_AUTH_PASS=synthetic-private-value\n")+}diff --git a/internal/config/persistence.go b/internal/config/persistence.goindex e7b988f51d..3f03014ca0 100644--- a/internal/config/persistence.go+++ b/internal/config/persistence.go@@ -72,6 +72,7 @@ type ConfigPersistence struct {type FileSystem interface {ReadFile(name string) ([]byte, error)WriteFile(name string, data []byte, perm os.FileMode) error+ CreateTemp(dir, pattern string) (TemporaryFile, error)Rename(oldpath, newpath string) errorRemove(name string) errorStat(name string) (os.FileInfo, error)@@ -460,28 +461,14 @@ func (c *ConfigPersistence) writeConfigFileLocked(path string, data []byte, permreturn nil}- tmp := path + ".tmp"- if err := c.fs.WriteFile(tmp, data, perm); err != nil {- return fmt.Errorf("write temp config file %s: %w", tmp, err)- }- if err := c.fs.Rename(tmp, path); err != nil {- renameErr := fmt.Errorf("rename temp config file %s to %s: %w", tmp, path, err)- if removeErr := c.fs.Remove(tmp); removeErr != nil && !os.IsNotExist(removeErr) {- return errors.Join(renameErr, fmt.Errorf("cleanup temp config file %s: %w", tmp, removeErr))- }- return renameErr- }- return nil+ return writeConfigFileAtomic(c.fs, path, data, perm)}// writeConfigBackupLocked preserves ordinary backup writes, but makes them// part of an active import instead of changing recovery files before commit.// Caller must hold c.mu.func (c *ConfigPersistence) writeConfigBackupLocked(path string, data []byte, perm os.FileMode) error {- if c.tx != nil {- return c.tx.StageFile(path, data, perm)- }- return c.fs.WriteFile(path, data, perm)+ return c.writeConfigFileLocked(path, data, perm)}// preserveCorruptConfigFileLocked moves a config file that failed to parse or@@ -3923,8 +3910,7 @@ func (c *ConfigPersistence) updateEnvFile(envFile string, settings SystemSettingreturn nil}- // Write to temp file first using owner-only permissions.- tempFile := envFile + ".tmp"+ // Preserve owner permissions, never group/other access to environment secrets.perm := os.FileMode(0600)if info, err := c.fs.Stat(envFile); err == nil {perm = info.Mode().Perm() & 0700@@ -3932,18 +3918,7 @@ func (c *ConfigPersistence) updateEnvFile(envFile string, settings SystemSettingperm = 0600}}- if c.tx != nil {- return c.writeConfigFileLocked(envFile, []byte(content), perm)- }- if err := c.fs.WriteFile(tempFile, []byte(content), perm); err != nil {- return fmt.Errorf("write temp env file %s: %w", tempFile, err)- }-- // Atomic rename- if err := c.fs.Rename(tempFile, envFile); err != nil {- return fmt.Errorf("rename temp env file %s to %s: %w", tempFile, envFile, err)- }- return nil+ return c.writeConfigFileLocked(envFile, []byte(content), perm)}// IsEncryptionEnabled returns whether the config persistence has encryption enableddiff --git a/internal/config/persistence_coverage_test.go b/internal/config/persistence_coverage_test.goindex 67aac7ad1d..7380cfce1d 100644--- a/internal/config/persistence_coverage_test.go+++ b/internal/config/persistence_coverage_test.go@@ -28,6 +28,26 @@ func (m *mockFSError) WriteFile(name string, data []byte, perm os.FileMode) erroreturn m.FileSystem.WriteFile(name, data, perm)}+func (m *mockFSError) CreateTemp(dir, pattern string) (TemporaryFile, error) {+ f, err := m.FileSystem.CreateTemp(dir, pattern)+ if err != nil {+ return nil, err+ }+ return &configWriteErrorFile{TemporaryFile: f, writeError: m.writeError}, nil+}++type configWriteErrorFile struct {+ TemporaryFile+ writeError error+}++func (f *configWriteErrorFile) Write(data []byte) (int, error) {+ if f.writeError != nil {+ return 0, f.writeError+ }+ return f.TemporaryFile.Write(data)+}+func (m *mockFSError) Rename(oldpath, newpath string) error {if m.renameError != nil {return m.renameError@@ -202,3 +222,14 @@ func (m *mockFSWriteSpecific) WriteFile(name string, data []byte, perm os.FileMo}return m.FileSystem.WriteFile(name, data, perm)}++func (m *mockFSWriteSpecific) CreateTemp(dir, pattern string) (TemporaryFile, error) {+ f, err := m.FileSystem.CreateTemp(dir, pattern)+ if err != nil {+ return nil, err+ }+ if strings.Contains(filepath.Join(dir, pattern), m.failPattern) {+ return &configWriteErrorFile{TemporaryFile: f, writeError: os.ErrPermission}, nil+ }+ return f, nil+}