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.

Withhold configuration backups after credential withdrawal

pulse-triage[bot]1168ebb397f0
diff --git a/docs/release-control/v6/internal/subsystems/security-privacy.md b/docs/release-control/v6/internal/subsystems/security-privacy.md
index 54d28c958d..33012b47ad 100644
--- a/docs/release-control/v6/internal/subsystems/security-privacy.md
+++ b/docs/release-control/v6/internal/subsystems/security-privacy.md
@@ -18,6 +18,28 @@
## Purpose
+### Configuration backups retain their admitted reader
+
+The existing configuration export POST keeps canonical transfer admission and
+requires no new grant. After that admission, its synchronous JSON result checks
+the current admitted API token or local session at each write, including after
+persistence and passphrase encryption. A withdrawn/expired/replaced credential,
+lost settings-read scope or token organisation/principal authority returns the
+fixed 401 before output; after an admitted prefix it only stops later writes.
+Encryption with the caller's chosen passphrase is not a substitute for authority.
+The public recovery route records the session actually admitted by its local
+policy, since it deliberately does not run the ordinary CheckAuth wrapper.
+
+No payload, passphrase rule, backup format, tenant boundary, Basic/proxy/no-auth
+recovery policy, import apply lifetime or independent work changes. Session
+admission cannot be borrowed from an ambient cookie when an explicit token was
+chosen. Normal-suite config-export lifetime/current-admission tests use actual
+DELETE/logout and the real exporter held after encryption through its existing
+audit dependency. Authorised synthetic backups restore in a separate temporary
+scope; withdrawal does not remove source connections or independent credentials.
+This is not installed/IdP recovery, exposure measurement or release evidence.
+
+
### Dashboard sockets do not retain withdrawn token authority
The existing `/ws` route keeps its initial authentication, monitoring-read,
diff --git a/internal/api/config_export_authority_test.go b/internal/api/config_export_authority_test.go
new file mode 100644
index 0000000000..1aa58af68f
--- /dev/null
+++ b/internal/api/config_export_authority_test.go
@@ -0,0 +1,104 @@
+package api
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "testing"
+ "time"
+
+ "github.com/rcourtman/pulse-go-rewrite/internal/api/configapi"
+ "github.com/rcourtman/pulse-go-rewrite/internal/config"
+)
+
+func TestConfigExportCurrentAdmission(t *testing.T) {
+ for _, transport := range []string{"header", "bearer", "session"} {
+ changes := []string{"expired", "scope", "org", "identity", "principal", "unrelated_scope"}
+ if transport == "session" {
+ changes = []string{"expired", "principal", "replaced", "recovery"}
+ }
+ for _, change := range changes {
+ t.Run(transport+"/"+change, func(t *testing.T) {
+ router, cfg, server, _ := newHeldConfigExportRouter(t)
+ raw := logStreamToken
+ if transport == "session" {
+ raw = "synthetic-config-export-current-session"
+ GetSessionStore().CreateSession(raw, time.Hour, "fixture", "127.0.0.1", cfg.AuthUser)
+ t.Cleanup(func() { GetSessionStore().DeleteSession(raw) })
+ }
+ router.configHandlers.SetRuntimeDependencies(configapi.RuntimeDependencies{AuditEvent: func(_, event, _, _, _ string, success bool, _ string) {
+ if event != "config_exported" || !success {
+ t.Fatal("export failed before current-authority control")
+ }
+ if transport == "session" {
+ mutateReadSession(raw, change)
+ return
+ }
+ config.Mu.Lock()
+ defer config.Mu.Unlock()
+ switch change {
+ case "expired":
+ past := time.Now().Add(-time.Minute)
+ cfg.APITokens[0].ExpiresAt = &past
+ case "scope":
+ cfg.APITokens[0].Scopes = []string{config.ScopeMonitoringRead}
+ case "org":
+ cfg.APITokens[0].OrgID = "another-organization"
+ case "identity":
+ cfg.APITokens[0].ID = "another-credential"
+ case "principal":
+ cfg.APITokens[0].Metadata = map[string]string{apiTokenMetadataOwnerUserID: "another-principal"}
+ case "unrelated_scope":
+ cfg.APITokens[0].Scopes = []string{config.ScopeSettingsRead}
+ }
+ }})
+ req := configExportRequest(t, t.Context(), server, raw, transport)
+ rec := httptest.NewRecorder()
+ router.Handler().ServeHTTP(rec, req)
+ if change == "unrelated_scope" {
+ assertConfigExportArchive(t, configExportWire{rec.Code, rec.Header(), rec.Body.String()})
+ } else if rec.Code != http.StatusUnauthorized || rec.Body.String() != "Authentication required\n" {
+ t.Fatalf("changed credential admitted backup: status=%d", rec.Code)
+ }
+ })
+ }
+ }
+}
+
+func TestConfigTransferSessionAdmissionIsExplicit(t *testing.T) {
+ router, cfg, server, _ := newHeldConfigExportRouter(t)
+ const session = "synthetic-config-transfer-admission"
+ GetSessionStore().CreateSession(session, time.Hour, "fixture", "127.0.0.1", cfg.AuthUser)
+ t.Cleanup(func() { GetSessionStore().DeleteSession(session) })
+ for _, transport := range []string{"session", "header", "invalid_header"} {
+ t.Run(transport, func(t *testing.T) {
+ req := configExportRequest(t, t.Context(), server, session, "session")
+ if transport != "session" {
+ token := logStreamToken
+ if transport == "invalid_header" {
+ token = "invalid-synthetic-credential"
+ }
+ req.Header.Set("X-API-Token", token)
+ }
+ req = extractAndStoreAuthContext(cfg, nil, req)
+ rec := httptest.NewRecorder()
+ allowed := router.authorizeConfigTransfer(rec, req, configTransferExport)
+ if transport == "invalid_header" {
+ if allowed || rec.Code != http.StatusUnauthorized || sessionReadRevalidator(req) != nil {
+ t.Fatal("invalid explicit token fell back to ambient session")
+ }
+ return
+ }
+ if !allowed {
+ t.Fatalf("admitted credential denied: %d", rec.Code)
+ }
+ recheck := sessionReadRevalidator(req)
+ if transport == "session" {
+ if recheck == nil || !recheck() {
+ t.Fatal("route-local session admission was not retained")
+ }
+ } else if recheck != nil {
+ t.Fatal("token admission borrowed ambient session authority")
+ }
+ })
+ }
+}
diff --git a/internal/api/config_export_lifetime_test.go b/internal/api/config_export_lifetime_test.go
new file mode 100644
index 0000000000..6998b491d1
--- /dev/null
+++ b/internal/api/config_export_lifetime_test.go
@@ -0,0 +1,212 @@
+package api
+
+import (
+ "context"
+ "encoding/json"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "sync"
+ "sync/atomic"
+ "testing"
+ "time"
+
+ "github.com/rcourtman/pulse-go-rewrite/internal/api/configapi"
+ "github.com/rcourtman/pulse-go-rewrite/internal/config"
+ internalauth "github.com/rcourtman/pulse-go-rewrite/pkg/auth"
+)
+
+const configExportPassphrase = "synthetic-backup-passphrase"
+
+// Hold the real exporter after it has loaded and encrypted only temporary
+// configuration, at the existing audit dependency, before any transport write.
+type configExportHold struct {
+ armed atomic.Bool
+ entered, release chan struct{}
+ once sync.Once
+}
+
+func (h *configExportHold) unblock() { h.once.Do(func() { close(h.release) }) }
+
+func newHeldConfigExportRouter(t *testing.T) (*Router, *config.Config, *httptest.Server, *configExportHold) {
+ t.Helper()
+ cfg := newTestConfigWithTokens(t,
+ newTokenRecord(t, logStreamToken, []string{config.ScopeSettingsRead}, nil),
+ newTokenRecord(t, logStreamControl, []string{config.ScopeWildcard}, nil))
+ cfg.AuthUser = "operator"
+ t.Setenv("PULSE_DATA_DIR", cfg.DataPath)
+ router := NewRouter(cfg, nil, nil, nil, nil, "test")
+ cleanupTestRouter(t, router)
+ if err := router.persistence.SaveNodesConfig([]config.PVEInstance{{Name: "private-backup-fixture", Host: "https://pve.invalid:8006", User: "fixture@pve", TokenName: "fixture", TokenValue: "synthetic-backup-secret", VerifySSL: true}}, nil, nil); err != nil {
+ t.Fatal(err)
+ }
+ if err := router.persistence.SaveAPITokens(cfg.APITokens); err != nil {
+ t.Fatal(err)
+ }
+ hold := &configExportHold{entered: make(chan struct{}), release: make(chan struct{})}
+ router.configHandlers.SetRuntimeDependencies(configapi.RuntimeDependencies{AuditEvent: func(_, event, _, _, path string, success bool, _ string) {
+ if event == "config_exported" && path == "/api/config/export" && success && hold.armed.CompareAndSwap(true, false) {
+ close(hold.entered)
+ <-hold.release
+ }
+ }})
+ server := httptest.NewServer(router.Handler())
+ t.Cleanup(func() { hold.unblock(); server.Close() })
+ return router, cfg, server, hold
+}
+
+func configExportRequest(t *testing.T, ctx context.Context, server *httptest.Server, raw, transport string) *http.Request {
+ t.Helper()
+ req, err := http.NewRequestWithContext(ctx, http.MethodPost, server.URL+"/api/config/export", strings.NewReader(`{"passphrase":"`+configExportPassphrase+`"}`))
+ if err != nil {
+ t.Fatal(err)
+ }
+ req.Header.Set("Content-Type", "application/json")
+ switch transport {
+ case "bearer":
+ req.Header.Set("Authorization", "Bearer "+raw)
+ case "session", "sso_session":
+ req.AddCookie(&http.Cookie{Name: cookieNameSession, Value: raw})
+ req.Header.Set("X-CSRF-Token", generateCSRFToken(raw))
+ default:
+ req.Header.Set("X-API-Token", raw)
+ }
+ return req
+}
+
+type configExportWire struct {
+ Status int
+ Header http.Header
+ Body string
+}
+
+func readConfigExportWire(t *testing.T, response *http.Response) configExportWire {
+ t.Helper()
+ defer response.Body.Close()
+ body, err := io.ReadAll(response.Body)
+ if err != nil {
+ t.Fatal(err)
+ }
+ return configExportWire{response.StatusCode, response.Header.Clone(), string(body)}
+}
+
+func assertConfigExportArchive(t *testing.T, wire configExportWire) {
+ t.Helper()
+ var envelope struct{ Status, Data string }
+ if wire.Status != http.StatusOK || json.Unmarshal([]byte(wire.Body), &envelope) != nil || envelope.Status != "success" || envelope.Data == "" || wire.Header.Get("Content-Type") != "application/json" {
+ t.Fatal("authorised export lost its JSON archive")
+ }
+ // Use the existing importer only in a separate temporary persistence scope:
+ // an opaque ciphertext string is not proof that the backup still restores.
+ restored := config.NewConfigPersistence(t.TempDir())
+ if err := restored.ImportConfig(envelope.Data, configExportPassphrase); err != nil {
+ t.Fatalf("synthetic backup no longer restores: %v", err)
+ }
+ nodes, err := restored.LoadNodesConfig()
+ if err != nil || len(nodes.PVEInstances) != 1 || nodes.PVEInstances[0].TokenValue != "synthetic-backup-secret" || !nodes.PVEInstances[0].VerifySSL {
+ t.Fatal("synthetic backup changed its connection or credential")
+ }
+}
+
+func configExportNativeWithdrawal(t *testing.T, transport string) (configExportWire, configExportWire) {
+ t.Helper()
+ router, cfg, server, hold := newHeldConfigExportRouter(t)
+ ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+ defer cancel()
+ raw := logStreamToken
+ if transport == "session" || transport == "sso_session" {
+ raw = "synthetic-config-export-session"
+ username := cfg.AuthUser
+ if transport == "sso_session" {
+ username = "sso:[email protected]"
+ manager := installTestRBACManager(t)
+ if err := manager.UpdateUserRoles(username, []string{internalauth.RoleAdmin}); err != nil {
+ t.Fatal(err)
+ }
+ }
+ GetSessionStore().CreateSession(raw, time.Hour, "fixture", "127.0.0.1", username)
+ t.Cleanup(func() { GetSessionStore().DeleteSession(raw) })
+ }
+ request := configExportRequest(t, ctx, server, raw, transport)
+ hold.armed.Store(true)
+ type result struct {
+ response *http.Response
+ err error
+ }
+ done := make(chan result, 1)
+ go func() { r, e := server.Client().Do(request); done <- result{r, e} }()
+ select {
+ case <-hold.entered:
+ case r := <-done:
+ t.Fatalf("export did not reach encrypted-result hold: %v %v", r.response, r.err)
+ case <-ctx.Done():
+ t.Fatal("export never reached encrypted-result hold")
+ }
+ // A separately admitted reader must finish while this export remains held.
+ response, err := server.Client().Do(configExportRequest(t, ctx, server, logStreamControl, "header"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ authorised := readConfigExportWire(t, response)
+ assertConfigExportArchive(t, authorised)
+ if transport == "session" || transport == "sso_session" {
+ logoutReadSession(t, server.URL, raw)
+ } else {
+ config.Mu.RLock()
+ id := cfg.APITokens[0].ID
+ config.Mu.RUnlock()
+ deletion, err := http.NewRequestWithContext(ctx, http.MethodDelete, server.URL+"/api/security/tokens/"+id, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ deletion.Header.Set("X-API-Token", logStreamControl)
+ response, err := server.Client().Do(deletion)
+ if err != nil {
+ t.Fatal(err)
+ }
+ response.Body.Close()
+ persisted, err := router.persistence.LoadAPITokens()
+ if response.StatusCode != http.StatusNoContent || err != nil || len(persisted) != 1 || persisted[0].ID == id {
+ t.Fatal("DELETE did not persist exact credential withdrawal")
+ }
+ }
+ fresh, err := server.Client().Do(configExportRequest(t, ctx, server, raw, transport))
+ if err != nil {
+ t.Fatal(err)
+ }
+ freshWire := readConfigExportWire(t, fresh)
+ if freshWire.Status != http.StatusUnauthorized {
+ t.Fatalf("fresh admission=%d, want 401", freshWire.Status)
+ }
+ hold.unblock()
+ var completed result
+ select {
+ case completed = <-done:
+ case <-ctx.Done():
+ t.Fatal("encrypted export failed to finish after release")
+ }
+ if completed.err != nil {
+ t.Fatal(completed.err)
+ }
+ denied := readConfigExportWire(t, completed.response)
+ if denied.Status != http.StatusUnauthorized || denied.Body != "Authentication required\n" || denied.Header.Get("Content-Disposition") != "" {
+ // Parent witnesses establish that the escaped result is a decryptable
+ // configuration backup, not a success flag or a harmless empty response.
+ if denied.Status == http.StatusOK {
+ assertConfigExportArchive(t, denied)
+ }
+ t.Errorf("held export status=%d, encrypted archive escaped=%v after persisted withdrawal; want generic 401", denied.Status, strings.Contains(denied.Body, `"data"`))
+ }
+ nodes, err := router.persistence.LoadNodesConfig()
+ if err != nil || len(nodes.PVEInstances) != 1 || nodes.PVEInstances[0].TokenValue != "synthetic-backup-secret" {
+ t.Fatal("withdrawal changed source configuration")
+ }
+ return authorised, denied
+}
+
+func TestConfigExportNativeWithdrawal(t *testing.T) {
+ for _, transport := range []string{"header", "bearer", "session", "sso_session"} {
+ t.Run(transport, func(t *testing.T) { configExportNativeWithdrawal(t, transport) })
+ }
+}
diff --git a/internal/api/config_transfer_authorization.go b/internal/api/config_transfer_authorization.go
index de6b295f76..73ca20f84b 100644
--- a/internal/api/config_transfer_authorization.go
+++ b/internal/api/config_transfer_authorization.go
@@ -115,6 +115,10 @@ func (r *Router) authorizeConfigTransfer(w http.ResponseWriter, req *http.Reques
if !ensureOrgAdminSession(r.config, w, req) {
return false
}
+ // Transfer is a public recovery route, so it does not pass through
+ // CheckAuth's session admission. Retain the session actually admitted
+ // here, not an ambient cookie discovered after the export has run.
+ attachSessionReadAdmission(req, cookie.Value, session)
return true
}
}
diff --git a/internal/api/contract_test.go b/internal/api/contract_test.go
index 4a28715504..7810a6c452 100644
--- a/internal/api/contract_test.go
+++ b/internal/api/contract_test.go
@@ -495,7 +495,7 @@ func TestContract_ConfigTransferRoutesUseCanonicalPreHandlerAuthorization(t *tes
authorize string
handler string
}{
- {authorize: "authorizeConfigTransfer(w, req, configTransferExport)", handler: "HandleExportConfig(w, req)"},
+ {authorize: "authorizeConfigTransfer(w, req, configTransferExport)", handler: "retainTokenResponseAuthority(r.config, config.ScopeSettingsRead, false, r.configHandlers.HandleExportConfig)(w, req)"},
{authorize: "authorizeConfigTransfer(w, req, configTransferImport)", handler: "HandleImportConfig(w, req)"},
} {
authorizeAt := strings.Index(routes, sequence.authorize)
diff --git a/internal/api/router_routes_registration.go b/internal/api/router_routes_registration.go
index 177849da99..7519fccef9 100644
--- a/internal/api/router_routes_registration.go
+++ b/internal/api/router_routes_registration.go
@@ -450,7 +450,10 @@ func (r *Router) registerConfigSystemRoutes(updateHandlers *UpdateHandlers) {
if !r.authorizeConfigTransfer(w, req, configTransferExport) {
return
}
- r.configHandlers.HandleExportConfig(w, req)
+ // Encryption can outlive the admitted credential. Keep the existing
+ // transfer/recovery policy, but refuse undisclosed backup bytes after
+ // token withdrawal or local logout. Import's apply lifetime is separate.
+ retainTokenResponseAuthority(r.config, config.ScopeSettingsRead, false, r.configHandlers.HandleExportConfig)(w, req)
} else {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
}