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
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.mdindex 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 authorityThe 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.gonew file mode 100644index 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.gonew file mode 100644index 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.goindex 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.Requesif !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.goindex 4a28715504..7810a6c452 100644--- a/internal/api/contract_test.go+++ b/internal/api/contract_test.go@@ -495,7 +495,7 @@ func TestContract_ConfigTransferRoutesUseCanonicalPreHandlerAuthorization(t *tesauthorize stringhandler 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.goindex 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)}