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.

Reject competing public SSO and recovery request fields

pulse-triage[bot]3d05fd3cdaad
diff --git a/docs/release-control/v6/internal/subsystems/agent-lifecycle.md b/docs/release-control/v6/internal/subsystems/agent-lifecycle.md
index e2c8f899ea..baca1a22e1 100644
--- a/docs/release-control/v6/internal/subsystems/agent-lifecycle.md
+++ b/docs/release-control/v6/internal/subsystems/agent-lifecycle.md
@@ -10271,3 +10271,13 @@ The actual CLI/receipt control is
`TestContractChartSLOProofCLIClassifiesExecution`; the separate read-only
evidence and check-writer boundary is
`TestChartSLOWorkflowPreservesInconclusiveAndFailure`.
+
+### Administrative JSON does not select agent operations (24 October 2026)
+
+The public SSO and RBAC administrative JSON admission rejects competing field
+values before settings, roles or one-use recovery tokens change. It exposes
+no agent enrollment, command, update or credential operation. Singleton
+requests and existing access, organization and Community SSO gates remain;
+`TestContractSSOAmbiguousSavePreservesDetail` and the SSO/RBAC JSON admission
+tests establish configuration/account preservation, not installed agent or
+guest recovery.
diff --git a/docs/release-control/v6/internal/subsystems/api-contracts.md b/docs/release-control/v6/internal/subsystems/api-contracts.md
index a3636e7ae7..d2229531ba 100644
--- a/docs/release-control/v6/internal/subsystems/api-contracts.md
+++ b/docs/release-control/v6/internal/subsystems/api-contracts.md
@@ -12625,3 +12625,21 @@ classification. `TestContractChartSLOProofCLIClassifiesExecution` drives the
real CLI and disposable child processes through all ten outcomes, verifies
unaltered logs/result/digest/strict arguments and excludes the synthetic token
from the child environment. Its capacity rows are synthetic, not latency proof.
+
+### Unambiguous public administrative writes (24 October 2026)
+
+Public SSO provider create/update and RBAC reset-admin require one complete,
+bounded JSON object. Competing members for a decoded request field, including
+escaped and case-folded aliases and repeated nested OIDC/SAML objects, return
+`400 invalid_json` before persistence, provider initialization, role changes or
+recovery-token consumption. Group-role map keys remain case-sensitive data;
+exact or escaped duplicates cannot choose a later role. Well-formed unknown
+fields and singleton aliases remain compatible. Deliberate empty restrictions,
+blank-secret preservation, Community SSO and existing tenant/access/licence
+checks are unchanged. SSO consumes the full 1 MiB bound; reset-admin retains
+its 4 KiB bound, including trailing whitespace. No route or response field is
+added. `TestContractSSOAmbiguousSavePreservesDetail` binds the error and retained
+detail response; `sso_json_admission_test.go`, `rbac_json_admission_test.go` and
+`admin_json_test.go` cover persisted preservation, explicit clears, aliases,
+limits and one-use recovery. These are public source controls, not an observed
+exploit, private runtime acceptance or installed sign-in recovery.
diff --git a/docs/release-control/v6/internal/subsystems/storage-recovery.md b/docs/release-control/v6/internal/subsystems/storage-recovery.md
index aefc0ab0a4..c890bdea14 100644
--- a/docs/release-control/v6/internal/subsystems/storage-recovery.md
+++ b/docs/release-control/v6/internal/subsystems/storage-recovery.md
@@ -7243,3 +7243,14 @@ History latency result, intact stored data, guest liveness or installed
recovery. `TestContractChartSLOProofCLIClassifiesExecution` preserves child
exit, output and executable identity across those distinctions; the 90 ms
valid-capacity requirement and independent native recovery remain unchanged.
+
+### Rejected administrative input preserves saved recovery choices (24 October 2026)
+
+Competing public SSO request fields cannot overwrite restrictions or saved
+provider credentials, and ambiguous reset-admin fields cannot consume the
+one-use token while selecting a different account. A complete unique request
+can still deliberately clear restrictions or perform its authorized scoped
+reset. `TestContractSSOAmbiguousSavePreservesDetail` and the SSO/RBAC JSON
+admission tests preserve persisted settings, exact roles and token usability.
+No database schema, stored history, backup/thaw operation or native recovery
+route changes; parser admission does not establish those operational outcomes.
diff --git a/internal/api/access_admin_handlers.go b/internal/api/access_admin_handlers.go
index 6419440d47..c826f06b7b 100644
--- a/internal/api/access_admin_handlers.go
+++ b/internal/api/access_admin_handlers.go
@@ -58,15 +58,12 @@ func (h *RBACHandlers) HandleRBACAdminReset(w http.ResponseWriter, r *http.Reque
return
}
- // Limit request body size.
- r.Body = http.MaxBytesReader(w, r.Body, 4*1024) // 4KB max
-
var req struct {
OrgID string `json:"org_id"`
Username string `json:"username"`
RecoveryToken string `json:"recovery_token"`
}
- if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+ if err := decodeAdminJSONObject(w, r, &req, 4*1024); err != nil {
writeErrorResponse(w, http.StatusBadRequest, "invalid_json", "Invalid request body", nil)
return
}
diff --git a/internal/api/admin_json.go b/internal/api/admin_json.go
new file mode 100644
index 0000000000..2fbc05bd41
--- /dev/null
+++ b/internal/api/admin_json.go
@@ -0,0 +1,122 @@
+package api
+
+import (
+ "bytes"
+ "encoding/json"
+ "errors"
+ "io"
+ "net/http"
+ "reflect"
+ "strings"
+)
+
+var errAmbiguousAdminJSON = errors.New("request body must contain one unambiguous JSON object")
+
+// decodeAdminJSONObject preserves the standard decoder's singleton aliases and
+// unknown fields, but never chooses between competing values for a control.
+// Callers supply small request structs (no embedded fields or custom decoders).
+// Validate before unmarshalling so an invalid request cannot partially apply.
+func decodeAdminJSONObject(w http.ResponseWriter, r *http.Request, dst any, limit int64) error {
+ if r.Body == nil {
+ return errAmbiguousAdminJSON
+ }
+ r.Body = http.MaxBytesReader(w, r.Body, limit)
+ data, err := io.ReadAll(r.Body)
+ if err != nil {
+ return err
+ }
+ data = bytes.TrimSpace(data)
+ if len(data) == 0 || data[0] != '{' || !json.Valid(data) {
+ return errAmbiguousAdminJSON
+ }
+ if err := validateAdminJSONMembers(data, reflect.TypeOf(dst)); err != nil {
+ return err
+ }
+ return json.Unmarshal(data, dst)
+}
+
+func validateAdminJSONMembers(data []byte, target reflect.Type) error {
+ for target.Kind() == reflect.Pointer {
+ target = target.Elem()
+ }
+ data = bytes.TrimSpace(data)
+ switch target.Kind() {
+ case reflect.Struct, reflect.Map:
+ if data[0] != '{' {
+ return nil // The ordinary decoder reports incompatible field types.
+ }
+ decoder := json.NewDecoder(bytes.NewReader(data))
+ if _, err := decoder.Token(); err != nil {
+ return err
+ }
+ seen := make(map[string]bool)
+ for decoder.More() {
+ key, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ name := key.(string) // json.Valid already checked the object syntax.
+ canonical, child := adminJSONField(target, name)
+ if child != nil {
+ if seen[canonical] {
+ // Never echo names or values: map keys can be private group names.
+ return errAmbiguousAdminJSON
+ }
+ seen[canonical] = true
+ }
+ var value json.RawMessage
+ if err := decoder.Decode(&value); err != nil {
+ return err
+ }
+ if child != nil {
+ if err := validateAdminJSONMembers(value, child); err != nil {
+ return err
+ }
+ }
+ }
+ case reflect.Slice, reflect.Array:
+ if data[0] != '[' {
+ return nil
+ }
+ var values []json.RawMessage
+ if err := json.Unmarshal(data, &values); err != nil {
+ return err
+ }
+ for _, value := range values {
+ if err := validateAdminJSONMembers(value, target.Elem()); err != nil {
+ return err
+ }
+ }
+ }
+ return nil
+}
+
+func adminJSONField(target reflect.Type, name string) (string, reflect.Type) {
+ if target.Kind() == reflect.Map {
+ // Role/group names are data, not struct-field aliases. Distinct case is
+ // meaningful; only exact (including JSON-escaped) duplicates compete.
+ return name, target.Elem()
+ }
+ var foldedName string
+ var foldedType reflect.Type
+ for i := 0; i < target.NumField(); i++ {
+ field := target.Field(i)
+ if !field.IsExported() {
+ continue
+ }
+ key := strings.Split(field.Tag.Get("json"), ",")[0]
+ if key == "-" {
+ continue
+ }
+ if key == "" {
+ key = field.Name
+ }
+ if key == name {
+ return key, field.Type
+ }
+ if foldedType == nil && strings.EqualFold(key, name) {
+ foldedName, foldedType = key, field.Type
+ }
+ }
+ return foldedName, foldedType
+}
diff --git a/internal/api/admin_json_test.go b/internal/api/admin_json_test.go
new file mode 100644
index 0000000000..d3c8eb68f4
--- /dev/null
+++ b/internal/api/admin_json_test.go
@@ -0,0 +1,75 @@
+package api
+
+import (
+ "net/http/httptest"
+ "strings"
+ "testing"
+
+ "github.com/rcourtman/pulse-go-rewrite/internal/config"
+ "github.com/stretchr/testify/require"
+)
+
+func TestDecodeAdminJSONObject(t *testing.T) {
+ tests := []struct {
+ name string
+ body string
+ ok bool
+ }{
+ {"unique", `{"name":"SSO","allowedGroups":["ops"]}`, true},
+ {"singleton aliases", `{"NAME":"SSO","allowedGroup\u0073":[],"OIDC":{"CLIENTID":"pulse"}}`, true},
+ {"unicode singleton alias", `{"allowedGroupſ":["ops"]}`, true},
+ {"explicit clears", `{"allowedGroups":[],"allowedDomains":[],"allowedEmails":[],"groupRoleMappings":{}}`, true},
+ {"case sensitive group names", `{"groupRoleMappings":{"Ops":"admin","ops":"viewer"}}`, true},
+ {"unknown fields", `{"future":{"allowedGroups":[],"AllowedGroups":["ignored"]},"runtimeManaged":true}`, true},
+ {"exact duplicate", `{"allowedGroups":["ops"],"allowedGroups":[]}`, false},
+ {"escaped duplicate", `{"allowedGroups":["ops"],"allowedGroup\u0073":[]}`, false},
+ {"case folded duplicate", `{"allowedGroups":["ops"],"ALLOWEDGROUPS":[]}`, false},
+ {"unicode folded duplicate", `{"allowedGroups":["ops"],"allowedGroupſ":[]}`, false},
+ {"nested duplicate", `{"oidc":{"clientSecret":"one","CLIENTSECRET":"two"}}`, false},
+ {"merged nested objects", `{"oidc":{"clientId":"one"},"OIDC":{"clientSecret":"two"}}`, false},
+ {"group duplicate", `{"groupRoleMappings":{"ops":"viewer","ops":"admin"}}`, false},
+ {"escaped group duplicate", `{"groupRoleMappings":{"ops":"viewer","op\u0073":"admin"}}`, false},
+ {"wrong field type", `{"allowedGroups":"ops"}`, false},
+ {"null root", `null`, false},
+ {"array root", `[]`, false},
+ {"empty", ``, false},
+ {"incomplete", `{"name":"SSO"`, false},
+ {"second object", `{"name":"SSO"}{}`, false},
+ {"trailing junk", `{"name":"SSO"}x`, false},
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ var provider config.SSOProvider
+ err := decodeAdminJSONObject(httptest.NewRecorder(), httptest.NewRequest("POST", "/", strings.NewReader(tt.body)), &provider, 1024)
+ if tt.ok {
+ require.NoError(t, err)
+ } else {
+ require.Error(t, err)
+ }
+ })
+ }
+}
+
+func TestDecodeAdminJSONObjectCompleteBound(t *testing.T) {
+ body := `{"name":"SSO"}`
+ for _, tt := range []struct {
+ name string
+ body string
+ ok bool
+ }{
+ {"exact limit", body, true},
+ {"whitespace within limit", body + " ", true},
+ {"whitespace overflow", body + " ", false},
+ {"unread second object", body + " {}", false},
+ } {
+ t.Run(tt.name, func(t *testing.T) {
+ var provider config.SSOProvider
+ err := decodeAdminJSONObject(httptest.NewRecorder(), httptest.NewRequest("POST", "/", strings.NewReader(tt.body)), &provider, int64(len(body)+1))
+ if tt.ok {
+ require.NoError(t, err)
+ } else {
+ require.Error(t, err)
+ }
+ })
+ }
+}
diff --git a/internal/api/contract_test.go b/internal/api/contract_test.go
index c7b60cdd9a..164352d1dc 100644
--- a/internal/api/contract_test.go
+++ b/internal/api/contract_test.go
@@ -27650,3 +27650,34 @@ func TestContract_PortablePrivateBootstrapPayloads(t *testing.T) {
}
}
}
+
+// An ambiguous administrative save must not become a successful empty access
+// selection in the detail API consumed by Settings.
+func TestContractSSOAmbiguousSavePreservesDetail(t *testing.T) {
+ router, _ := setupTestRouter(t)
+ seedRestrictedSSOProvider(t, router)
+ get := func() *httptest.ResponseRecorder {
+ rec := httptest.NewRecorder()
+ router.handleGetSSOProvider(rec, httptest.NewRequest(http.MethodGet, "/api/security/sso/providers/guarded", nil), "guarded")
+ return rec
+ }
+ before := get()
+ if before.Code != http.StatusOK {
+ t.Fatalf("detail status = %d", before.Code)
+ }
+ rejected := serveSSOAdmission(router, "update", `{"name":"Corporate SSO","type":"oidc","oidc":{"clientId":"pulse"},"allowedGroups":["ops"],"ALLOWEDGROUPS":[]}`)
+ if rejected.Code != http.StatusBadRequest || !strings.Contains(rejected.Body.String(), `"invalid_json"`) {
+ t.Fatalf("ambiguous save status = %d, want invalid_json", rejected.Code)
+ }
+ after := get()
+ if after.Code != http.StatusOK || before.Body.String() != after.Body.String() {
+ t.Fatal("rejected save changed the detail response")
+ }
+ var detail SSOProviderResponse
+ if err := json.Unmarshal(after.Body.Bytes(), &detail); err != nil {
+ t.Fatal(err)
+ }
+ if !slices.Equal(detail.AllowedGroups, []string{"ops"}) || detail.OIDC == nil || !detail.OIDC.ClientSecretSet || strings.Contains(after.Body.String(), "fixture-secret") {
+ t.Fatal("detail lost its access selection or exposed the saved secret")
+ }
+}
diff --git a/internal/api/identity_sso_handlers.go b/internal/api/identity_sso_handlers.go
index 6e6ccde1a3..81e8491fe9 100644
--- a/internal/api/identity_sso_handlers.go
+++ b/internal/api/identity_sso_handlers.go
@@ -338,14 +338,8 @@ func (r *Router) handleGetSSOProvider(w http.ResponseWriter, req *http.Request,
}
func (r *Router) handleCreateSSOProvider(w http.ResponseWriter, req *http.Request) {
- body, err := io.ReadAll(io.LimitReader(req.Body, maxRequestBodySize))
- if err != nil {
- writeErrorResponse(w, http.StatusBadRequest, "read_error", "Failed to read request body", nil)
- return
- }
-
var provider config.SSOProvider
- if err := json.Unmarshal(body, &provider); err != nil {
+ if err := decodeAdminJSONObject(w, req, &provider, maxRequestBodySize); err != nil {
writeErrorResponse(w, http.StatusBadRequest, "invalid_json", "Invalid JSON payload", nil)
return
}
@@ -478,14 +472,8 @@ func (r *Router) handleUpdateSSOProvider(w http.ResponseWriter, req *http.Reques
return
}
- body, err := io.ReadAll(io.LimitReader(req.Body, maxRequestBodySize))
- if err != nil {
- writeErrorResponse(w, http.StatusBadRequest, "read_error", "Failed to read request body", nil)
- return
- }
-
var updated config.SSOProvider
- if err := json.Unmarshal(body, &updated); err != nil {
+ if err := decodeAdminJSONObject(w, req, &updated, maxRequestBodySize); err != nil {
writeErrorResponse(w, http.StatusBadRequest, "invalid_json", "Invalid JSON payload", nil)
return
}
diff --git a/internal/api/rbac_json_admission_test.go b/internal/api/rbac_json_admission_test.go
new file mode 100644
index 0000000000..c4e54719bf
--- /dev/null
+++ b/internal/api/rbac_json_admission_test.go
@@ -0,0 +1,82 @@
+package api
+
+import (
+ "context"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/rcourtman/pulse-go-rewrite/pkg/auth"
+ "github.com/stretchr/testify/require"
+)
+
+func TestRBACAdminJSONRejectsBeforeTokenConsumption(t *testing.T) {
+ for _, tt := range []struct{ name, body string }{
+ {"username", `{"username":"intended","username":"other","recovery_token":%q}`},
+ {"identical username", `{"username":"intended","username":"intended","recovery_token":%q}`},
+ {"escaped username", `{"username":"intended","usernam\u0065":"other","recovery_token":%q}`},
+ {"folded username", `{"username":"intended","USERNAME":"other","recovery_token":%q}`},
+ {"unicode folded username", `{"username":"intended","uſername":"other","recovery_token":%q}`},
+ {"org scope", `{"username":"intended","org_id":"other","org_id":"default","recovery_token":%q}`},
+ {"escaped org scope", `{"username":"intended","org_id":"other","org_\u0069d":"default","recovery_token":%q}`},
+ {"folded org scope", `{"username":"intended","org_id":"other","ORG_ID":"default","recovery_token":%q}`},
+ {"token", `{"username":"intended","recovery_token":"not-valid","recovery_token":%q}`},
+ {"folded token", `{"username":"intended","recovery_token":"not-valid","RECOVERY_TOKEN":%q}`},
+ {"trailing document", `{"username":"intended","recovery_token":%q}{}`},
+ {"trailing junk", `{"username":"intended","recovery_token":%q}x`},
+ {"oversized suffix", `{"username":"intended","recovery_token":%q}` + strings.Repeat(" ", 4*1024)},
+ } {
+ t.Run(tt.name, func(t *testing.T) {
+ baseDir := t.TempDir()
+ provider := NewTenantRBACProvider(baseDir)
+ t.Cleanup(func() { _ = provider.Close() })
+ manager, err := provider.GetManager("default")
+ require.NoError(t, err)
+ resetRecoveryStore()
+ t.Cleanup(resetRecoveryStore)
+ InitRecoveryTokenStore(baseDir)
+ token, err := GetRecoveryTokenStore().GenerateRecoveryToken(5*time.Minute, "127.0.0.1")
+ require.NoError(t, err)
+ handlers := NewRBACHandlers(nil, provider)
+ serve := func(body string) *httptest.ResponseRecorder {
+ req := httptest.NewRequest(http.MethodPost, "/api/admin/rbac/reset-admin", strings.NewReader(body))
+ req.RemoteAddr = "127.0.0.1:12345"
+ rec := httptest.NewRecorder()
+ handlers.HandleRBACAdminReset(rec, req)
+ return rec
+ }
+ rec := serve(fmt.Sprintf(tt.body, token))
+ require.Equal(t, http.StatusBadRequest, rec.Code)
+ require.Contains(t, rec.Body.String(), `"invalid_json"`)
+ require.NotContains(t, rec.Body.String(), token)
+ for _, user := range []string{"intended", "other"} {
+ _, assigned := manager.GetUserAssignment(user)
+ require.False(t, assigned, "rejected request assigned a role")
+ }
+ // The same token remains available for one deliberate, scoped reset.
+ valid := fmt.Sprintf(`{"USERNAME":"intended","ORG_ID":"default","recovery_\u0074oken":%q,"future":{}}`, token)
+ require.Equal(t, http.StatusOK, serve(valid).Code, "rejected input consumed the one-use token")
+ assignment, ok := manager.GetUserAssignment("intended")
+ require.True(t, ok)
+ require.Contains(t, assignment.RoleIDs, auth.RoleAdmin)
+ _, assigned := manager.GetUserAssignment("other")
+ require.False(t, assigned)
+ require.Equal(t, http.StatusForbidden, serve(valid).Code, "successful reset must consume the token")
+ })
+ }
+}
+
+func TestRBACAdminJSONKeepsTenantBoundary(t *testing.T) {
+ provider := NewTenantRBACProvider(t.TempDir())
+ t.Cleanup(func() { _ = provider.Close() })
+ handlers := NewRBACHandlers(nil, provider)
+ req := httptest.NewRequest(http.MethodPost, "/api/admin/rbac/reset-admin", strings.NewReader(`{"ORG_ID":"org-b","USERNAME":"intended","RECOVERY_TOKEN":"not-used"}`))
+ req = req.WithContext(context.WithValue(req.Context(), OrgIDContextKey, "org-a"))
+ rec := httptest.NewRecorder()
+ handlers.HandleRBACAdminReset(rec, req)
+ require.Equal(t, http.StatusForbidden, rec.Code)
+ require.Contains(t, rec.Body.String(), `"access_denied"`)
+}
diff --git a/internal/api/sso_json_admission_test.go b/internal/api/sso_json_admission_test.go
new file mode 100644
index 0000000000..fd24442f67
--- /dev/null
+++ b/internal/api/sso_json_admission_test.go
@@ -0,0 +1,159 @@
+package api
+
+import (
+ "bytes"
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+
+ "github.com/rcourtman/pulse-go-rewrite/internal/config"
+ "github.com/stretchr/testify/require"
+)
+
+func TestSSOAdminJSONRejectsAmbiguousControls(t *testing.T) {
+ for _, operation := range []string{"create", "update"} {
+ t.Run(operation, func(t *testing.T) {
+ for _, tt := range []struct{ name, fields string }{
+ {"identical groups", `"allowedGroups":["ops"],"allowedGroups":["ops"]`},
+ {"cleared groups", `"allowedGroups":["ops"],"allowedGroups":[]`},
+ {"escaped groups", `"allowedGroups":["ops"],"allowedGroup\u0073":[]`},
+ {"folded groups", `"allowedGroups":["ops"],"ALLOWEDGROUPS":[]`},
+ {"unicode folded groups", `"allowedGroups":["ops"],"allowedGroupſ":[]`},
+ {"cleared domains", `"allowedDomains":["example.test"],"allowedDomains":[]`},
+ {"cleared emails", `"allowedEmails":["[email protected]"],"allowedEmails":[]`},
+ {"groups claim", `"groupsClaim":"groups","groupsClaim":"other"`},
+ {"whole mappings", `"groupRoleMappings":{"ops":"viewer"},"GROUPROLEMAPPINGS":{}`},
+ {"mapping role", `"groupRoleMappings":{"ops":"viewer","op\u0073":"admin"}`},
+ {"nested oidc secret", `"oidc":{"clientId":"pulse","clientSecret":"first","CLIENTSECRET":"second"}`},
+ {"nested oidc issuer", `"oidc":{"issuerUrl":"https://first.example.test","issuerUrl":"https://second.example.test"}`},
+ {"merged oidc", `"oidc":{"clientId":"pulse"},"OIDC":{"clientSecret":"second"}`},
+ {"nested saml policy", `"saml":{"wantAssertionsSigned":true,"WANTASSERTIONSSIGNED":false}`},
+ {"merged saml", `"saml":{"groupsAttr":"groups"},"SAML":{"groupsAttr":"other"}`},
+ {"enabled switch", `"enabled":true,"ENABLED":false`},
+ } {
+ t.Run(tt.name, func(t *testing.T) {
+ router, dir := setupTestRouter(t)
+ if operation == "update" {
+ seedRestrictedSSOProvider(t, router)
+ }
+ beforeConfig, err := json.Marshal(router.ensureSSOConfig())
+ require.NoError(t, err)
+ beforeFiles := ssoAdmissionFiles(t, dir)
+ body := `{"id":"guarded","name":"Corporate SSO","type":"oidc",` + tt.fields + `}`
+ // Each otherwise incomplete OIDC request gets one baseline object.
+ if !strings.Contains(tt.fields, `"oidc"`) {
+ body = body[:len(body)-1] + `,"oidc":{"clientId":"pulse"}}`
+ }
+ rec := serveSSOAdmission(router, operation, body)
+ require.Equal(t, http.StatusBadRequest, rec.Code)
+ require.Contains(t, rec.Body.String(), `"invalid_json"`)
+ afterConfig, err := json.Marshal(router.ensureSSOConfig())
+ require.NoError(t, err)
+ require.Equal(t, string(beforeConfig), string(afterConfig), "published settings changed")
+ require.Equal(t, beforeFiles, ssoAdmissionFiles(t, dir), "persisted settings changed")
+ })
+ }
+ })
+ }
+}
+
+func TestSSOAdminJSONRequiresCompleteBoundedObject(t *testing.T) {
+ valid := `{"id":"guarded","name":"Corporate SSO","type":"oidc","oidc":{"clientId":"pulse"}}`
+ for _, operation := range []string{"create", "update"} {
+ t.Run(operation, func(t *testing.T) {
+ for _, tt := range []struct{ name, body string }{
+ {"null", `null`},
+ {"array", `[]`},
+ {"trailing document", valid + `{}`},
+ {"oversized whitespace", valid + strings.Repeat(" ", maxRequestBodySize)},
+ {"hidden suffix", valid + strings.Repeat(" ", maxRequestBodySize) + `{}`},
+ } {
+ t.Run(tt.name, func(t *testing.T) {
+ router, dir := setupTestRouter(t)
+ if operation == "update" {
+ seedRestrictedSSOProvider(t, router)
+ }
+ before := ssoAdmissionFiles(t, dir)
+ require.Equal(t, http.StatusBadRequest, serveSSOAdmission(router, operation, tt.body).Code)
+ require.Equal(t, before, ssoAdmissionFiles(t, dir))
+ })
+ }
+ })
+ }
+}
+
+func TestSSOAdminJSONPreservesUniqueRequestsAndDeliberateClears(t *testing.T) {
+ router, _ := setupTestRouter(t)
+ body := `{"ID":"guarded","NAME":"Corporate SSO","TYPE":"oidc","OIDC":{"CLIENTID":"pulse","clientSecret":"fixture-secret"},"allowedGroup\u0073":["Ops"],"allowedDomains":["example.test"],"allowedEmails":["[email protected]"],"groupsClaim":"groups","groupRoleMappings":{"Ops":"admin","ops":"viewer"},"future":{"ALLOWEDGROUPS":[],"allowedGroups":["ignored"]}}`
+ require.Equal(t, http.StatusCreated, serveSSOAdmission(router, "create", body).Code)
+ stored, err := router.persistence.LoadSSOConfig()
+ require.NoError(t, err)
+ require.Equal(t, []string{"Ops"}, stored.GetProvider("guarded").AllowedGroups)
+ require.Equal(t, map[string]string{"Ops": "admin", "ops": "viewer"}, stored.GetProvider("guarded").GroupRoleMappings)
+
+ // Blank secret saves keep the existing secret, but explicit access clears
+ // remain a supported operation; never turn them into an accidental keep.
+ clear := `{"name":"Corporate SSO","type":"oidc","oidc":{"clientId":"pulse","clientSecret":""},"allowedGroups":[],"allowedDomains":[],"allowedEmails":[],"groupsClaim":"","groupRoleMappings":{}}`
+ rec := serveSSOAdmission(router, "update", clear)
+ require.Equal(t, http.StatusOK, rec.Code)
+ require.NotContains(t, rec.Body.String(), "fixture-secret")
+ stored, err = router.persistence.LoadSSOConfig()
+ require.NoError(t, err)
+ provider := stored.GetProvider("guarded")
+ require.Empty(t, provider.AllowedGroups)
+ require.Empty(t, provider.AllowedDomains)
+ require.Empty(t, provider.AllowedEmails)
+ require.Empty(t, provider.GroupRoleMappings)
+ require.Equal(t, "fixture-secret", provider.OIDC.ClientSecret)
+
+ require.Equal(t, http.StatusOK, serveSSOAdmission(router, "update", body).Code)
+ stored, err = router.persistence.LoadSSOConfig()
+ require.NoError(t, err)
+ require.Equal(t, []string{"Ops"}, stored.GetProvider("guarded").AllowedGroups)
+}
+
+func seedRestrictedSSOProvider(t *testing.T, router *Router) {
+ t.Helper()
+ provider := config.SSOProvider{
+ ID: "guarded", Name: "Corporate SSO", Type: config.SSOProviderTypeOIDC,
+ AllowedGroups: []string{"ops"}, AllowedDomains: []string{"example.test"},
+ AllowedEmails: []string{"[email protected]"}, GroupsClaim: "groups",
+ GroupRoleMappings: map[string]string{"ops": "viewer"},
+ OIDC: &config.OIDCProviderConfig{ClientID: "pulse", ClientSecret: "fixture-secret", ClientSecretSet: true},
+ }
+ require.NoError(t, router.ssoConfig.AddProvider(provider))
+ require.NoError(t, router.saveSSOConfig())
+}
+
+func serveSSOAdmission(router *Router, operation, body string) *httptest.ResponseRecorder {
+ rec := httptest.NewRecorder()
+ if operation == "create" {
+ router.handleCreateSSOProvider(rec, httptest.NewRequest(http.MethodPost, "/api/security/sso/providers", bytes.NewBufferString(body)))
+ } else {
+ router.handleUpdateSSOProvider(rec, httptest.NewRequest(http.MethodPut, "/api/security/sso/providers/guarded", bytes.NewBufferString(body)), "guarded")
+ }
+ return rec
+}
+
+func ssoAdmissionFiles(t *testing.T, dir string) map[string]string {
+ t.Helper()
+ files := map[string]string{}
+ require.NoError(t, filepath.WalkDir(dir, func(path string, entry os.DirEntry, err error) error {
+ if err != nil {
+ return err
+ }
+ if !entry.IsDir() {
+ data, err := os.ReadFile(path)
+ if err != nil {
+ return err
+ }
+ files[path] = string(data)
+ }
+ return nil
+ }))
+ return files
+}