Skip to content

armgit / Pulse

Public Imported from GitHub
0

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.

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.md
index 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 reader
The existing SSO provider inventory, provider-detail editor, connection test and
diff --git a/internal/config/atomic_file.go b/internal/config/atomic_file.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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) error
Remove(name string) error
Stat(name string) (os.FileInfo, error)
@@ -460,28 +461,14 @@ func (c *ConfigPersistence) writeConfigFileLocked(path string, data []byte, perm
return 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 SystemSetting
return 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 SystemSetting
perm = 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 enabled
diff --git a/internal/config/persistence_coverage_test.go b/internal/config/persistence_coverage_test.go
index 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) erro
return 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
+}