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
fix(api): publish SSO config changes as immutable snapshots
rcourtman74f3dcc97541
diff --git a/internal/api/contract_test.go b/internal/api/contract_test.goindex 06b31f7bb0..42555cab0c 100644--- a/internal/api/contract_test.go+++ b/internal/api/contract_test.go@@ -21,6 +21,7 @@ import ("slices""sort""strings"+ "sync""sync/atomic""testing""time"@@ -27266,3 +27267,118 @@ func TestChartServiceInitializationIsConcurrentAndRouterScoped(t *testing.T) {t.Fatal("different routers shared a chart service")}}++// Login, status and middleware reads of the SSO configuration run on every+// request goroutine while an administrator edits providers, and the legacy+// OIDC_* provider is re-applied on every read. Run under -race.+func TestSSOConfigConcurrentReadsAndAdminWrites(t *testing.T) {+ t.Setenv("OIDC_ENABLED", "true")+ t.Setenv("OIDC_ISSUER_URL", "https://issuer.example.com")+ t.Setenv("OIDC_CLIENT_ID", "pulse-env")++ router, _ := setupTestRouter(t)+ router.ensureSSOConfig()++ const (+ readers = 4+ writers = 4+ rounds = 6+ )++ stop := make(chan struct{})+ var readersWG sync.WaitGroup+ for range readers {+ readersWG.Add(1)+ go func() {+ defer readersWG.Done()+ for {+ select {+ case <-stop:+ return+ default:+ }+ // /api/security/status and the CSRF middleware.+ _ = router.ensureSSOConfig().GetEnabledProviders()+ // OIDC and SAML login handlers.+ if provider := router.getSSOProvider(config.LegacyOIDCProviderID); provider == nil || provider.OIDC == nil || provider.OIDC.ClientID != "pulse-env" {+ t.Error("environment OIDC provider missing during concurrent edits")+ return+ }+ w := httptest.NewRecorder()+ router.handleListSSOProviders(w, httptest.NewRequest(http.MethodGet, "/api/security/sso/providers", nil))+ if w.Code != http.StatusOK {+ t.Errorf("list providers: status %d", w.Code)+ return+ }+ }+ }()+ }++ create := func(id string) int {+ body, _ := json.Marshal(config.SSOProvider{+ ID: id,+ Name: "Provider " + id,+ Type: config.SSOProviderTypeOIDC,+ OIDC: &config.OIDCProviderConfig{+ IssuerURL: "https://issuer.example.com",+ ClientID: id,+ },+ })+ w := httptest.NewRecorder()+ router.handleCreateSSOProvider(w, httptest.NewRequest(http.MethodPost, "/api/security/sso/providers", bytes.NewReader(body)))+ return w.Code+ }+ remove := func(id string) int {+ w := httptest.NewRecorder()+ router.handleSSOProvider(w, httptest.NewRequest(http.MethodDelete, "/api/security/sso/providers/"+id, nil))+ return w.Code+ }++ var writersWG sync.WaitGroup+ for i := range writers {+ writersWG.Add(1)+ go func() {+ defer writersWG.Done()+ for j := range rounds {+ id := fmt.Sprintf("race-%d-%d", i, j)+ if code := create(id); code != http.StatusCreated {+ t.Errorf("create %s: status %d", id, code)+ return+ }+ if code := remove(id); code != http.StatusNoContent {+ t.Errorf("delete %s: status %d", id, code)+ return+ }+ }+ if id := fmt.Sprintf("keep-%d", i); create(id) != http.StatusCreated {+ t.Errorf("create %s failed", id)+ }+ }()+ }+ writersWG.Wait()+ close(stop)+ readersWG.Wait()++ providerIDs := func(cfg *config.SSOConfig) []string {+ ids := make([]string, 0, len(cfg.Providers))+ for _, provider := range cfg.Providers {+ ids = append(ids, provider.ID)+ }+ sort.Strings(ids)+ return ids+ }++ want := []string{"keep-0", "keep-1", "keep-2", "keep-3", config.LegacyOIDCProviderID}+ sort.Strings(want)+ if got := providerIDs(router.ensureSSOConfig()); fmt.Sprint(got) != fmt.Sprint(want) {+ t.Fatalf("published providers = %v, want %v", got, want)+ }++ persisted, err := router.persistence.LoadSSOConfig()+ if err != nil {+ t.Fatalf("load persisted SSO config: %v", err)+ }+ if got := providerIDs(persisted); fmt.Sprint(got) != fmt.Sprint(want[:writers]) {+ t.Fatalf("persisted providers = %v, want %v", got, want[:writers])+ }+}diff --git a/internal/api/identity_sso_handlers.go b/internal/api/identity_sso_handlers.goindex 56542571df..6e6ccde1a3 100644--- a/internal/api/identity_sso_handlers.go+++ b/internal/api/identity_sso_handlers.go@@ -230,9 +230,21 @@ func (r *Router) handleSSOProvider(w http.ResponseWriter, req *http.Request) {}// ensureSSOConfig loads the SSO configuration from persistence on first access,-// falling back to an empty config if nothing is persisted.+// falling back to an empty config if nothing is persisted, and applies the+// legacy OIDC_* environment provider.+//+// The returned configuration is a published snapshot that is never mutated+// afterwards, so callers may read it without holding ssoMu but must not+// modify it. Changes go through commitSSOConfig.func (r *Router) ensureSSOConfig() *config.SSOConfig {- if r.ssoConfig == nil {+ r.ssoMu.Lock()+ defer r.ssoMu.Unlock()+ return r.ensureSSOConfigLocked()+}++func (r *Router) ensureSSOConfigLocked() *config.SSOConfig {+ current := r.ssoConfig+ if current == nil {if r.persistence != nil {cfg, err := r.persistence.LoadSSOConfig()if err != nil {@@ -241,13 +253,11 @@ func (r *Router) ensureSSOConfig() *config.SSOConfig {} else {r.ssoAuthLoadFailed.Store(false)}- if cfg != nil {- r.ssoConfig = cfg- }+ current = cfg}- if r.ssoConfig == nil {- r.ssoConfig = config.NewSSOConfig()+ if current == nil {+ current = config.NewSSOConfig()}}@@ -255,26 +265,60 @@ func (r *Router) ensureSSOConfig() *config.SSOConfig {if r.config != nil {publicURL = r.config.PublicURL}- if config.ApplyLegacyOIDCEnvProvider(r.ssoConfig, publicURL) {- log.Info().Str("provider_id", config.LegacyOIDCProviderID).Msg("Loaded legacy OIDC environment SSO provider")+ // The environment provider is rewritten on every call; apply it to a+ // private copy so readers of the previous snapshot never see the write.+ if _, ok := config.LegacyOIDCEnvProvider(publicURL); ok {+ current = current.Clone()+ if config.ApplyLegacyOIDCEnvProvider(current, publicURL) {+ log.Info().Str("provider_id", config.LegacyOIDCProviderID).Msg("Loaded legacy OIDC environment SSO provider")+ }}- setSSOAuthSnapshot(r.config, r.ssoConfig)+ r.ssoConfig = current+ setSSOAuthSnapshot(r.config, current)+ return current+}++// currentSSOConfig returns the published SSO configuration without loading+// it. The result must be treated as read-only.+func (r *Router) currentSSOConfig() *config.SSOConfig {+ r.ssoMu.RLock()+ defer r.ssoMu.RUnlock()return r.ssoConfig}+// commitSSOConfig applies mutate to a private copy of the SSO configuration,+// persists the copy, and publishes it only when persistence succeeds, so+// concurrent login and status requests never observe a partial edit or an+// unsaved one. A mutate error is returned as applyErr and a persistence+// failure as saveErr; either leaves the published configuration unchanged.+func (r *Router) commitSSOConfig(mutate func(*config.SSOConfig) error) (applyErr, saveErr error) {+ r.ssoMu.Lock()+ defer r.ssoMu.Unlock()++ next := r.ensureSSOConfigLocked().Clone()+ if err := mutate(next); err != nil {+ return err, nil+ }+ if err := r.persistSSOConfigLocked(next); err != nil {+ return nil, err+ }+ r.ssoConfig = next+ return nil, nil+}+func (r *Router) ssoAuthenticationLoadFailed() bool {return r != nil && r.ssoAuthLoadFailed.Load()}func (r *Router) handleListSSOProviders(w http.ResponseWriter, req *http.Request) {- r.ensureSSOConfig()+ ssoCfg := r.ensureSSOConfig()response := EmptySSOProvidersListResponse()- response.DefaultProviderID = r.ssoConfig.DefaultProviderID- response.AllowMultipleProviders = r.ssoConfig.AllowMultipleProviders+ response.DefaultProviderID = ssoCfg.DefaultProviderID+ response.AllowMultipleProviders = ssoCfg.AllowMultipleProviders- for _, p := range r.ssoConfig.Providers {+ for _, p := range ssoCfg.Providers {response.Providers = append(response.Providers, providerToResponse(&p, r.config.PublicURL, req))}@@ -283,9 +327,7 @@ func (r *Router) handleListSSOProviders(w http.ResponseWriter, req *http.Request}func (r *Router) handleGetSSOProvider(w http.ResponseWriter, req *http.Request, providerID string) {- r.ensureSSOConfig()-- provider := r.ssoConfig.GetProvider(providerID)+ provider := r.ensureSSOConfig().GetProvider(providerID)if provider == nil {writeErrorResponse(w, http.StatusNotFound, "not_found", "Provider not found", nil)return@@ -379,27 +421,22 @@ func (r *Router) handleCreateSSOProvider(w http.ResponseWriter, req *http.Requesreturn}- r.ensureSSOConfig()-// Check for duplicate ID- if r.ssoConfig.GetProvider(provider.ID) != nil {+ if r.ensureSSOConfig().GetProvider(provider.ID) != nil {writeErrorResponse(w, http.StatusConflict, "duplicate_id", "Provider with this ID already exists", nil)return}- // Add provider- if err := r.ssoConfig.AddProvider(provider); err != nil {- writeErrorResponse(w, http.StatusBadRequest, "add_error", err.Error(), nil)+ // Add and persist the provider; nothing is published if either step fails.+ addErr, saveErr := r.commitSSOConfig(func(cfg *config.SSOConfig) error {+ return cfg.AddProvider(provider)+ })+ if addErr != nil {+ writeErrorResponse(w, http.StatusBadRequest, "add_error", addErr.Error(), nil)return}-- // Persist configuration- if err := r.saveSSOConfig(); err != nil {- log.Error().Err(err).Msg("Failed to persist SSO configuration")- // Remove the provider we just added since persistence failed- if err := r.ssoConfig.RemoveProvider(provider.ID); err != nil {- log.Warn().Err(err).Str("provider_id", provider.ID).Msg("Failed to remove provider during rollback")- }+ if saveErr != nil {+ log.Error().Err(saveErr).Msg("Failed to persist SSO configuration")writeErrorResponse(w, http.StatusInternalServerError, "save_error", "Failed to save configuration", nil)return}@@ -429,9 +466,9 @@ func (r *Router) handleCreateSSOProvider(w http.ResponseWriter, req *http.Reques}func (r *Router) handleUpdateSSOProvider(w http.ResponseWriter, req *http.Request, providerID string) {- r.ensureSSOConfig()-- existing := r.ssoConfig.GetProvider(providerID)+ // Work on a private copy: the merge below writes through existing's+ // nested OIDC/SAML pointers, which the published snapshot must not share.+ existing := r.ensureSSOConfig().Clone().GetProvider(providerID)if existing == nil {writeErrorResponse(w, http.StatusNotFound, "not_found", "Provider not found", nil)return@@ -523,19 +560,16 @@ func (r *Router) handleUpdateSSOProvider(w http.ResponseWriter, req *http.Reques}}- // Update provider- if err := r.ssoConfig.UpdateProvider(updated); err != nil {- writeErrorResponse(w, http.StatusBadRequest, "update_error", err.Error(), nil)+ // Update and persist the provider; nothing is published if either step fails.+ updateErr, saveErr := r.commitSSOConfig(func(cfg *config.SSOConfig) error {+ return cfg.UpdateProvider(updated)+ })+ if updateErr != nil {+ writeErrorResponse(w, http.StatusBadRequest, "update_error", updateErr.Error(), nil)return}-- // Persist configuration- if err := r.saveSSOConfig(); err != nil {- log.Error().Err(err).Msg("Failed to persist SSO configuration")- // Revert to existing provider- if err := r.ssoConfig.UpdateProvider(*existing); err != nil {- log.Warn().Err(err).Str("provider_id", existing.ID).Msg("Failed to revert provider during rollback")- }+ if saveErr != nil {+ log.Error().Err(saveErr).Msg("Failed to persist SSO configuration")writeErrorResponse(w, http.StatusInternalServerError, "save_error", "Failed to save configuration", nil)return}@@ -582,9 +616,7 @@ func (r *Router) handleUpdateSSOProvider(w http.ResponseWriter, req *http.Reques}func (r *Router) handleDeleteSSOProvider(w http.ResponseWriter, req *http.Request, providerID string) {- r.ensureSSOConfig()-- existing := r.ssoConfig.GetProvider(providerID)+ existing := r.ensureSSOConfig().GetProvider(providerID)if existing == nil {writeErrorResponse(w, http.StatusNotFound, "not_found", "Provider not found", nil)return@@ -594,19 +626,16 @@ func (r *Router) handleDeleteSSOProvider(w http.ResponseWriter, req *http.Requesreturn}- // Remove provider- if err := r.ssoConfig.RemoveProvider(providerID); err != nil {- writeErrorResponse(w, http.StatusBadRequest, "remove_error", err.Error(), nil)+ // Remove and persist; nothing is published if either step fails.+ removeErr, saveErr := r.commitSSOConfig(func(cfg *config.SSOConfig) error {+ return cfg.RemoveProvider(providerID)+ })+ if removeErr != nil {+ writeErrorResponse(w, http.StatusBadRequest, "remove_error", removeErr.Error(), nil)return}-- // Persist configuration- if err := r.saveSSOConfig(); err != nil {- log.Error().Err(err).Msg("Failed to persist SSO configuration")- // Re-add the provider since persistence failed- if err := r.ssoConfig.AddProvider(*existing); err != nil {- log.Warn().Err(err).Str("provider_id", existing.ID).Msg("Failed to re-add provider during rollback")- }+ if saveErr != nil {+ log.Error().Err(saveErr).Msg("Failed to persist SSO configuration")writeErrorResponse(w, http.StatusInternalServerError, "save_error", "Failed to save configuration", nil)return}@@ -626,16 +655,20 @@ func (r *Router) handleDeleteSSOProvider(w http.ResponseWriter, req *http.Requesw.WriteHeader(http.StatusNoContent)}+// saveSSOConfig persists the published SSO configuration as it stands.func (r *Router) saveSSOConfig() error {- if r.persistence == nil {- setSSOAuthSnapshot(r.config, r.ssoConfig)- r.ssoAuthLoadFailed.Store(false)- return nil- }- if err := r.persistence.SaveSSOConfig(r.ssoConfig); err != nil {- return err+ r.ssoMu.Lock()+ defer r.ssoMu.Unlock()+ return r.persistSSOConfigLocked(r.ssoConfig)+}++func (r *Router) persistSSOConfigLocked(cfg *config.SSOConfig) error {+ if r.persistence != nil {+ if err := r.persistence.SaveSSOConfig(cfg); err != nil {+ return err+ }}- setSSOAuthSnapshot(r.config, r.ssoConfig)+ setSSOAuthSnapshot(r.config, cfg)r.ssoAuthLoadFailed.Store(false)return nil}diff --git a/internal/api/oidc_handlers.go b/internal/api/oidc_handlers.goindex fc2d661517..0c6212b20d 100644--- a/internal/api/oidc_handlers.go+++ b/internal/api/oidc_handlers.go@@ -235,10 +235,11 @@ func resolveGroupRoles(groups []string, mappings map[string]string) []string {// InitializeOIDCProviders initializes all enabled SSO OIDC providers at startup.func (r *Router) InitializeOIDCProviders(ctx context.Context) error {- if r.ssoConfig == nil {+ ssoCfg := r.currentSSOConfig()+ if ssoCfg == nil {return nil}- for _, provider := range r.ssoConfig.Providers {+ for _, provider := range ssoCfg.Providers {if provider.Type == config.SSOProviderTypeOIDC && provider.Enabled && provider.OIDC != nil {p := provider // capture loop variableif err := r.oidcManager.InitializeProvider(ctx, p.ID, &p, ""); err != nil {diff --git a/internal/api/router.go b/internal/api/router.goindex 98e2b784a6..ecd905e2a4 100644--- a/internal/api/router.go+++ b/internal/api/router.go@@ -138,6 +138,7 @@ type Router struct {oidcService *OIDCServiceoidcManager *OIDCServiceManagersamlManager *SAMLServiceManager+ ssoMu sync.RWMutex // guards ssoConfig; a published config is never mutated (see commitSSOConfig)ssoConfig *config.SSOConfigssoAuthLoadFailed atomic.BoolsessionStore *SessionStorediff --git a/internal/api/router_routes_auth_security.go b/internal/api/router_routes_auth_security.goindex 571aaa152f..fa2842a5a0 100644--- a/internal/api/router_routes_auth_security.go+++ b/internal/api/router_routes_auth_security.go@@ -710,13 +710,12 @@ func newSSOAdminRuntime(router *Router) extensions.SSOAdminRuntime {if router == nil {return nil}- previous := router.ssoConfig- router.ssoConfig = toCoreSSOConfig(snapshot)- if err := router.saveSSOConfig(); err != nil {- router.ssoConfig = previous- return err- }- return nil+ // Publish the replacement only once it is persisted.+ _, err := router.commitSSOConfig(func(cfg *config.SSOConfig) error {+ *cfg = *toCoreSSOConfig(snapshot)+ return nil+ })+ return err}runtime.GetPublicURL = func() string {if router == nil || router.config == nil {diff --git a/internal/api/saml_handlers.go b/internal/api/saml_handlers.goindex 4688838a07..e1fc529c94 100644--- a/internal/api/saml_handlers.go+++ b/internal/api/saml_handlers.go@@ -820,24 +820,23 @@ func extractSAMLProviderID(path, endpoint string) string {return ""}-// getSSOProvider retrieves an SSO provider by ID from the current configuration+// getSSOProvider retrieves an SSO provider by ID from the current configuration.+// The result belongs to a published snapshot and must be treated as read-only.func (r *Router) getSSOProvider(providerID string) *config.SSOProvider {- if r.ssoConfig == nil {- return nil- }- return r.ssoConfig.GetProvider(providerID)+ return r.currentSSOConfig().GetProvider(providerID)}// InitializeSAMLProviders initializes all enabled SAML providersfunc (r *Router) InitializeSAMLProviders(ctx context.Context) error {- if r.ssoConfig == nil {+ ssoCfg := r.currentSSOConfig()+ if ssoCfg == nil {return nil}if err := r.syncSAMLPublicURL(); err != nil {return fmt.Errorf("sync saml public url: %w", err)}- for _, provider := range r.ssoConfig.Providers {+ for _, provider := range ssoCfg.Providers {if provider.Type == config.SSOProviderTypeSAML && provider.Enabled && provider.SAML != nil {if err := r.samlManager.InitializeProvider(ctx, provider.ID, provider.SAML); err != nil {log.Error().