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
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.mdindex 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-onlyevidence 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.mdindex 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 thereal CLI and disposable child processes through all ten outcomes, verifiesunaltered logs/result/digest/strict arguments and excludes the synthetic tokenfrom 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.mdindex 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 installedrecovery. `TestContractChartSLOProofCLIClassifiesExecution` preserves childexit, output and executable identity across those distinctions; the 90 msvalid-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.goindex 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.Requereturn}- // 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.gonew file mode 100644index 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.gonew file mode 100644index 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.goindex 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.goindex 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.Requesreturn}- 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.gonew file mode 100644index 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.gonew file mode 100644index 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+}