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.

fix(api): publish SSO config changes as immutable snapshots

rcourtman74f3dcc97541
diff --git a/internal/api/contract_test.go b/internal/api/contract_test.go
index 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.go
index 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.Reques
return
}
- 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.Reques
return
}
- // 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.Reques
w.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.go
index 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 variable
if err := r.oidcManager.InitializeProvider(ctx, p.ID, &p, ""); err != nil {
diff --git a/internal/api/router.go b/internal/api/router.go
index 98e2b784a6..ecd905e2a4 100644
--- a/internal/api/router.go
+++ b/internal/api/router.go
@@ -138,6 +138,7 @@ type Router struct {
oidcService *OIDCService
oidcManager *OIDCServiceManager
samlManager *SAMLServiceManager
+ ssoMu sync.RWMutex // guards ssoConfig; a published config is never mutated (see commitSSOConfig)
ssoConfig *config.SSOConfig
ssoAuthLoadFailed atomic.Bool
sessionStore *SessionStore
diff --git a/internal/api/router_routes_auth_security.go b/internal/api/router_routes_auth_security.go
index 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.go
index 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 providers
func (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().