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.

Withhold report downloads after credential withdrawal

pulse-triage[bot]b4c317d0ae64
diff --git a/internal/api/contract_test.go b/internal/api/contract_test.go
index 900ba5cbfd..5e9e6bc516 100644
--- a/internal/api/contract_test.go
+++ b/internal/api/contract_test.go
@@ -29132,3 +29132,10 @@ func TestContractSupportBundleStopsAfterAdmittedPrefix(t *testing.T) {
}
}
}
+
+// Report downloads, including supported endpoint decorators, must not disclose
+// results after persisted credential withdrawal. Existing org-admin/settings
+// and license gates, independent readers and background work remain unchanged.
+func TestContractReportDownloadWithdrawal(t *testing.T) {
+ reportDownloadNativeWithdrawal(t)
+}
diff --git a/internal/api/log_bundle_authority_test.go b/internal/api/log_bundle_authority_test.go
index 9e4ab721ff..f41e97c399 100644
--- a/internal/api/log_bundle_authority_test.go
+++ b/internal/api/log_bundle_authority_test.go
@@ -8,12 +8,12 @@ import (
func TestSupportBundleMediaDoesNotWidenAssistantResults(t *testing.T) {
for _, policy := range []struct {
name, media string
- zip bool
- }{{"json", "application/json", false}, {"zip", "application/zip", true}} {
+ policy responseMediaPolicy
+ }{{"json", "application/json", responseMediaJSON}, {"zip", "application/zip", responseMediaZIP}} {
for _, provided := range []string{"", "application/json", "application/zip", "text/html", "image/svg+xml", "application/json; invalid"} {
t.Run(policy.name+"/"+provided, func(t *testing.T) {
base := httptest.NewRecorder()
- writer := &tokenResponseWriter{writer: base, header: base.Header().Clone(), allowed: func() bool { return true }, zipDownload: policy.zip}
+ writer := &tokenResponseWriter{writer: base, header: base.Header().Clone(), allowed: func() bool { return true }, media: policy.policy}
writer.Header()["content-type"] = []string{"text/html"}
writer.Header().Set("Content-Type", provided)
if _, err := writer.Write([]byte("synthetic bytes")); err != nil {
diff --git a/internal/api/log_handlers.go b/internal/api/log_handlers.go
index a467422a0d..b3d585af79 100644
--- a/internal/api/log_handlers.go
+++ b/internal/api/log_handlers.go
@@ -110,7 +110,7 @@ func (h *LogHandlers) HandleDownloadBundle(w http.ResponseWriter, r *http.Reques
// Raw logs are private even though the system summary is allowlisted.
// Recheck the admitted token/session at each actual ZIP transport write,
// without buffering the archive or withdrawing other readers/work.
- retainResponseAuthority(h.config, config.ScopeSettingsRead, true, true, h.writeDownloadBundle)(w, r)
+ retainResponseAuthority(h.config, config.ScopeSettingsRead, true, responseMediaZIP, h.writeDownloadBundle)(w, r)
}
func (h *LogHandlers) writeDownloadBundle(w http.ResponseWriter, r *http.Request) {
diff --git a/internal/api/report_download_authority_test.go b/internal/api/report_download_authority_test.go
new file mode 100644
index 0000000000..b7b987fdf6
--- /dev/null
+++ b/internal/api/report_download_authority_test.go
@@ -0,0 +1,186 @@
+package api
+
+import (
+ "fmt"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/rcourtman/pulse-go-rewrite/internal/config"
+)
+
+func TestReportDownloadMediaPoliciesStaySeparate(t *testing.T) {
+ for _, policy := range []responseMediaPolicy{responseMediaJSON, responseMediaZIP, responseMediaReport, responseMediaPolicy(255)} {
+ for _, provided := range []string{"", "application/json", "application/zip", "application/pdf", "text/csv", "text/csv; charset=utf-8", "text/csv; charset=windows-1252", "text/html", "image/svg+xml", "application/json; invalid"} {
+ t.Run(fmt.Sprint(policy)+"/"+provided, func(t *testing.T) {
+ base := httptest.NewRecorder()
+ w := &tokenResponseWriter{writer: base, header: base.Header().Clone(), allowed: func() bool { return true }, media: policy}
+ w.Header()["content-type"] = []string{"text/html"}
+ w.Header()["x-content-type-options"] = []string{"sniff"}
+ w.Header().Set("Content-Type", provided)
+ const payload = "<script>synthetic data, never executable</script>"
+ _, err := w.Write([]byte(payload))
+ if err != nil {
+ t.Fatal(err)
+ }
+ want := "text/plain; charset=utf-8"
+ switch policy {
+ case responseMediaJSON:
+ if provided == "application/json" {
+ want = provided
+ }
+ case responseMediaZIP:
+ if provided == "application/zip" {
+ want = provided
+ }
+ case responseMediaReport:
+ switch {
+ case provided == "application/json", provided == "application/pdf":
+ want = provided
+ case strings.HasPrefix(provided, "text/csv"):
+ want = "text/csv; charset=utf-8"
+ }
+ }
+ if base.Header().Get("Content-Type") != want || base.Header().Get("X-Content-Type-Options") != "nosniff" || base.Body.String() != payload {
+ t.Fatalf("media or payload changed: %v", base.Header())
+ }
+ for _, alias := range []string{"content-type", "x-content-type-options"} {
+ if _, ok := base.Header()[alias]; ok {
+ t.Fatal("noncanonical media header escaped")
+ }
+ }
+ })
+ }
+ }
+}
+
+func TestReportDownloadCurrentAuthorityAndPrefix(t *testing.T) {
+ for _, transport := range []string{"header", "bearer", "session"} {
+ changes := []string{"revoked", "expired", "scope", "org", "identity", "principal", "unrelated_scope"}
+ if transport == "session" {
+ changes = []string{"invalidated", "expired", "principal", "replaced", "recovery"}
+ }
+ for _, change := range changes {
+ for _, prefix := range []bool{false, true} {
+ name := change + "/before_output"
+ if prefix {
+ name = change + "/after_prefix"
+ }
+ t.Run(transport+"/"+name, func(t *testing.T) {
+ cfg := newTestConfigWithTokens(t, newTokenRecord(t, logStreamToken, []string{config.ScopeSettingsRead, config.ScopeAIExecute}, nil))
+ const session = "synthetic-report-prefix-session"
+ if transport == "session" {
+ InitSessionStore(t.TempDir())
+ GetSessionStore().CreateSession(session, time.Hour, "fixture", "127.0.0.1", "operator")
+ t.Cleanup(func() { GetSessionStore().DeleteSession(session) })
+ }
+ req := httptest.NewRequest(http.MethodGet, "/synthetic-report", nil)
+ switch transport {
+ case "bearer":
+ req.Header.Set("Authorization", "Bearer "+logStreamToken)
+ case "session":
+ req.AddCookie(&http.Cookie{Name: cookieNameSession, Value: session})
+ default:
+ req.Header.Set("X-API-Token", logStreamToken)
+ }
+ base := httptest.NewRecorder()
+ var late http.ResponseWriter
+ guard := retainResponseAuthority(cfg, config.ScopeSettingsRead, false, responseMediaReport, func(w http.ResponseWriter, r *http.Request) {
+ late = w
+ w.Header().Set("Content-Type", "text/csv; charset=utf-8")
+ w.Header().Set("Content-Disposition", "attachment; filename=synthetic.csv")
+ if prefix {
+ if _, err := w.Write([]byte("admitted,prefix\n")); err != nil {
+ t.Fatal(err)
+ }
+ }
+ if transport == "session" {
+ mutateReadSession(session, change)
+ } else {
+ config.Mu.Lock()
+ switch change {
+ case "revoked":
+ cfg.RemoveAPIToken(cfg.APITokens[0].ID)
+ case "expired":
+ past := time.Now().Add(-time.Second)
+ cfg.APITokens[0].ExpiresAt = &past
+ case "scope":
+ cfg.APITokens[0].Scopes = []string{config.ScopeMonitoringRead}
+ case "org":
+ cfg.APITokens[0].OrgID = "different-organization"
+ case "identity":
+ cfg.APITokens[0].ID = "different-credential"
+ case "principal":
+ cfg.APITokens[0].Metadata = map[string]string{apiTokenMetadataOwnerUserID: "different-owner"}
+ case "unrelated_scope":
+ cfg.APITokens[0].Scopes = []string{config.ScopeSettingsRead}
+ }
+ config.Mu.Unlock()
+ }
+ n, err := w.Write([]byte("private,result\n"))
+ if change == "unrelated_scope" {
+ if err != nil || n == 0 {
+ t.Fatal("unrelated scope removal broke report read")
+ }
+ } else if n != 0 || err != io.ErrClosedPipe {
+ t.Fatalf("withdrawn write=%d %v", n, err)
+ }
+ if r.Context().Err() != nil {
+ t.Fatal("withdrawal cancelled independent generation")
+ }
+ })
+ AuthContextMiddleware(cfg, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if !CheckAuth(cfg, w, r) {
+ t.Fatal("synthetic admission failed")
+ }
+ guard(w, r)
+ })).ServeHTTP(base, req)
+ if _, err := late.Write([]byte("late output")); err != io.ErrClosedPipe {
+ t.Fatal("returned writer reopened")
+ }
+ switch {
+ case change == "unrelated_scope":
+ if base.Code != http.StatusOK || !strings.Contains(base.Body.String(), "private,result") {
+ t.Fatal("independent scope denied")
+ }
+ case prefix:
+ if base.Code != http.StatusOK || base.Body.String() != "admitted,prefix\n" {
+ t.Fatalf("admitted prefix changed: %d %s", base.Code, base.Body)
+ }
+ default:
+ if base.Code != http.StatusUnauthorized || base.Body.String() != "Authentication required\n" || base.Header().Get("Content-Disposition") != "" {
+ t.Fatal("private report response escaped after withdrawal")
+ }
+ }
+ })
+ }
+ }
+ }
+}
+
+func TestReportDownloadKeepsOrganizationBoundAuthority(t *testing.T) {
+ record := newTokenRecord(t, logStreamToken, []string{config.ScopeSettingsRead}, nil)
+ record.OrgID = "org-a"
+ cfg := newTestConfigWithTokens(t, record)
+ req := httptest.NewRequest(http.MethodGet, "/synthetic-report", nil).WithContext(orgScopeContext("org-a"))
+ req.Header.Set("X-API-Token", logStreamToken)
+ base := httptest.NewRecorder()
+ handler := retainResponseAuthority(cfg, config.ScopeSettingsRead, false, responseMediaReport, func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "text/csv")
+ if _, err := w.Write([]byte("own-org,report\n")); err != nil {
+ t.Fatal(err)
+ }
+ })
+ AuthContextMiddleware(cfg, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if !CheckAuth(cfg, w, r) {
+ t.Fatal("org credential admission failed")
+ }
+ handler(w, r)
+ })).ServeHTTP(base, req)
+ if base.Code != http.StatusOK || base.Body.String() != "own-org,report\n" {
+ t.Fatalf("org settings reader acquired an instance-admin requirement: %d %s", base.Code, base.Body)
+ }
+}
diff --git a/internal/api/report_download_lifetime_test.go b/internal/api/report_download_lifetime_test.go
new file mode 100644
index 0000000000..709aff4e25
--- /dev/null
+++ b/internal/api/report_download_lifetime_test.go
@@ -0,0 +1,204 @@
+package api
+
+import (
+ "context"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "sync"
+ "testing"
+ "time"
+
+ "github.com/rcourtman/pulse-go-rewrite/internal/config"
+ "github.com/rcourtman/pulse-go-rewrite/pkg/extensions"
+ pkglicensing "github.com/rcourtman/pulse-go-rewrite/pkg/licensing"
+ "github.com/rcourtman/pulse-go-rewrite/pkg/reporting"
+)
+
+// Decorate the real public endpoint adapter at its supported extension seam.
+// This holds admitted generation, not authentication, before its first output.
+// No private implementation or installed workload is involved.
+type heldReportDownloads struct {
+ extensions.ReportingAdminEndpoints
+ entered chan struct{}
+ release chan struct{}
+ once sync.Once
+}
+
+func (h *heldReportDownloads) run(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
+ h.once.Do(func() { close(h.entered) })
+ select {
+ case <-h.release:
+ case <-r.Context().Done():
+ return
+ }
+ next(w, r)
+}
+func (h *heldReportDownloads) HandleGenerateReport(w http.ResponseWriter, r *http.Request) {
+ h.run(w, r, h.ReportingAdminEndpoints.HandleGenerateReport)
+}
+func (h *heldReportDownloads) HandleGenerateMultiReport(w http.ResponseWriter, r *http.Request) {
+ h.run(w, r, h.ReportingAdminEndpoints.HandleGenerateMultiReport)
+}
+func (h *heldReportDownloads) HandleExportVMInventory(w http.ResponseWriter, r *http.Request) {
+ h.run(w, r, h.ReportingAdminEndpoints.HandleExportVMInventory)
+}
+
+type reportDownloadCase struct{ name, method, path, body string }
+
+func reportDownloadCases() []reportDownloadCase {
+ return []reportDownloadCase{
+ {"single_get", http.MethodGet, "/api/admin/reports/generate?format=csv&resourceType=vm&resourceId=fixture-node-100", ""},
+ {"single_post", http.MethodPost, "/api/admin/reports/generate", `{"resourceType":"vm","resourceId":"fixture-node-100","format":"csv"}`},
+ {"fleet", http.MethodPost, "/api/admin/reports/generate-multi", `{"resources":[{"resourceType":"vm","resourceId":"fixture-node-100"}],"format":"csv"}`},
+ {"inventory", http.MethodGet, "/api/admin/reports/inventory/vms/export?format=csv", ""},
+ }
+}
+
+func newHeldReportDownloadRouter(t *testing.T) (*Router, *config.Config, *httptest.Server, *heldReportDownloads) {
+ t.Helper()
+ held := &heldReportDownloads{entered: make(chan struct{}), release: make(chan struct{})}
+ SetReportingAdminEndpointsBinder(func(defaults extensions.ReportingAdminEndpoints, _ extensions.ReportingAdminRuntime) extensions.ReportingAdminEndpoints {
+ held.ReportingAdminEndpoints = defaults
+ return held
+ })
+ t.Cleanup(func() { SetReportingAdminEndpointsBinder(nil) })
+ cfg := newTestConfigWithTokens(t,
+ newTokenRecord(t, logStreamToken, []string{config.ScopeSettingsRead}, nil),
+ newTokenRecord(t, logStreamControl, []string{config.ScopeWildcard}, nil))
+ cfg.AuthUser = "operator"
+ router := NewRouter(cfg, nil, nil, nil, nil, "test")
+ cleanupTestRouter(t, router)
+ setLicenseTierForHandlersForTests(t, router.licenseHandlers, "default", pkglicensing.TierEnterprise)
+ inventory, _, _, _, _ := inventoryScheduleFixture(t)
+ router.reportingHandlers.mtMonitor.Store(inventory.reportMonitorManager())
+ // The existing real handlers perform all parsing, scoping, generation and
+ // activity accounting. Only the performance engine's data source is synthetic.
+ original := reporting.GetEngine()
+ reporting.SetEngine(&stubReportingEngine{data: []byte("synthetic,private-report\n"), contentType: "text/csv"})
+ t.Cleanup(func() { reporting.SetEngine(original) })
+ server := httptest.NewServer(router.Handler())
+ // Unblock on any failed assertion before waiting for server cleanup.
+ t.Cleanup(func() {
+ select {
+ case <-held.release:
+ default:
+ close(held.release)
+ }
+ server.Close()
+ })
+ return router, cfg, server, held
+}
+
+func reportDownloadRequest(t *testing.T, ctx context.Context, server *httptest.Server, tc reportDownloadCase, raw, transport string) *http.Request {
+ t.Helper()
+ req, err := http.NewRequestWithContext(ctx, tc.method, server.URL+tc.path, strings.NewReader(tc.body))
+ if err != nil {
+ t.Fatal(err)
+ }
+ if tc.method == http.MethodPost {
+ req.Header.Set("Content-Type", "application/json")
+ }
+ switch transport {
+ case "bearer":
+ req.Header.Set("Authorization", "Bearer "+raw)
+ case "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
+}
+
+func reportDownloadNativeWithdrawal(t *testing.T) {
+ for _, tc := range reportDownloadCases() {
+ for _, transport := range []string{"header", "bearer", "session"} {
+ t.Run(tc.name+"/"+transport, func(t *testing.T) {
+ router, cfg, server, held := newHeldReportDownloadRouter(t)
+ raw := logStreamToken
+ if transport == "session" {
+ raw = "synthetic-held-report-session"
+ GetSessionStore().CreateSession(raw, time.Hour, "fixture", "127.0.0.1", cfg.AuthUser)
+ t.Cleanup(func() { GetSessionStore().DeleteSession(raw) })
+ }
+ ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+ defer cancel()
+ req := reportDownloadRequest(t, ctx, server, tc, raw, transport)
+ type result struct {
+ response *http.Response
+ err error
+ }
+ done := make(chan result, 1)
+ go func() { response, err := server.Client().Do(req); done <- result{response, err} }()
+ select {
+ case <-held.entered:
+ case response := <-done:
+ t.Fatalf("generation not admitted: response=%v err=%v", response.response, response.err)
+ case <-ctx.Done():
+ t.Fatal("generation did not reach hold")
+ }
+ if transport == "session" {
+ logoutReadSession(t, server.URL, raw)
+ } else {
+ config.Mu.RLock()
+ id := cfg.APITokens[0].ID
+ config.Mu.RUnlock()
+ deletion, _ := http.NewRequestWithContext(ctx, http.MethodDelete, server.URL+"/api/security/tokens/"+id, nil)
+ 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 withdrawal")
+ }
+ }
+ fresh, err := server.Client().Do(reportDownloadRequest(t, ctx, server, tc, raw, transport))
+ if err != nil {
+ t.Fatal(err)
+ }
+ fresh.Body.Close()
+ if fresh.StatusCode != http.StatusUnauthorized {
+ t.Fatalf("fresh admission=%d", fresh.StatusCode)
+ }
+ close(held.release)
+ var completed result
+ select {
+ case completed = <-done:
+ case <-ctx.Done():
+ t.Fatal("held report did not finish")
+ }
+ if completed.err != nil {
+ t.Fatal(completed.err)
+ }
+ body, err := io.ReadAll(completed.response.Body)
+ completed.response.Body.Close()
+ if err != nil {
+ t.Fatal(err)
+ }
+ marker := "private-report"
+ if tc.name == "inventory" {
+ marker = "inventory-vm-000"
+ }
+ if completed.response.StatusCode != http.StatusUnauthorized || string(body) != "Authentication required\n" || completed.response.Header.Get("Content-Disposition") != "" {
+ t.Errorf("held report=%d after persisted withdrawal (private data disclosed=%v), want generic 401 without attachment", completed.response.StatusCode, strings.Contains(string(body), marker))
+ }
+ // An independent settings reader still receives the original real-handler
+ // download. Withdrawal does not cancel a job or alter an inventory/schedule.
+ control, err := server.Client().Do(reportDownloadRequest(t, ctx, server, tc, logStreamControl, "header"))
+ if err != nil {
+ t.Fatal(err)
+ }
+ controlBody, err := io.ReadAll(control.Body)
+ control.Body.Close()
+ if err != nil || control.StatusCode != http.StatusOK || !strings.Contains(string(controlBody), marker) || control.Header.Get("Content-Disposition") == "" {
+ t.Fatalf("independent report lost: %d %v", control.StatusCode, err)
+ }
+ })
+ }
+ }
+}
diff --git a/internal/api/router_routes_licensing.go b/internal/api/router_routes_licensing.go
index ae00e3ec89..ce30f55a09 100644
--- a/internal/api/router_routes_licensing.go
+++ b/internal/api/router_routes_licensing.go
@@ -153,6 +153,8 @@ func (r *Router) registerOrgLicenseRoutesGroup(orgHandlers *OrgHandlers, rbacHan
// the request organization's inventory and metrics store, and schedules
// live in that organization's config, so an org manager may use them in
// their own organization.
+ // Slow downloads retain the admitted token/session through output, including
+ // extension renderers. Withdrawal does not cancel schedules or other work.
r.mux.HandleFunc("/api/admin/reports/catalog", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceNodes, func(w http.ResponseWriter, req *http.Request) {
if !ensureOrgAdminSession(r.config, w, req) {
return
@@ -163,19 +165,19 @@ func (r *Router) registerOrgLicenseRoutesGroup(orgHandlers *OrgHandlers, rbacHan
if !ensureOrgAdminSession(r.config, w, req) {
return
}
- RequireLicenseFeature(r.licenseHandlers, featureAdvancedReportingValue, RequireScope(config.ScopeSettingsRead, reportingAdminEndpoints.HandleGenerateReport))(w, req)
+ RequireLicenseFeature(r.licenseHandlers, featureAdvancedReportingValue, RequireScope(config.ScopeSettingsRead, retainResponseAuthority(r.config, config.ScopeSettingsRead, false, responseMediaReport, reportingAdminEndpoints.HandleGenerateReport)))(w, req)
}))
r.mux.HandleFunc("/api/admin/reports/generate-multi", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceNodes, func(w http.ResponseWriter, req *http.Request) {
if !ensureOrgAdminSession(r.config, w, req) {
return
}
- RequireLicenseFeature(r.licenseHandlers, featureAdvancedReportingValue, RequireScope(config.ScopeSettingsRead, reportingAdminEndpoints.HandleGenerateMultiReport))(w, req)
+ RequireLicenseFeature(r.licenseHandlers, featureAdvancedReportingValue, RequireScope(config.ScopeSettingsRead, retainResponseAuthority(r.config, config.ScopeSettingsRead, false, responseMediaReport, reportingAdminEndpoints.HandleGenerateMultiReport)))(w, req)
}))
r.mux.HandleFunc("/api/admin/reports/inventory/vms/export", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceNodes, func(w http.ResponseWriter, req *http.Request) {
if !ensureOrgAdminSession(r.config, w, req) {
return
}
- RequireLicenseFeature(r.licenseHandlers, featureAdvancedReportingValue, RequireScope(config.ScopeSettingsRead, reportingAdminEndpoints.HandleExportVMInventory))(w, req)
+ RequireLicenseFeature(r.licenseHandlers, featureAdvancedReportingValue, RequireScope(config.ScopeSettingsRead, retainResponseAuthority(r.config, config.ScopeSettingsRead, false, responseMediaReport, reportingAdminEndpoints.HandleExportVMInventory)))(w, req)
}))
r.mux.HandleFunc("GET /api/admin/reports/schedules", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceNodes, func(w http.ResponseWriter, req *http.Request) {
if !ensureOrgAdminSession(r.config, w, req) {
diff --git a/internal/api/token_response_authority.go b/internal/api/token_response_authority.go
index 9963105fc7..a9c3913a1e 100644
--- a/internal/api/token_response_authority.go
+++ b/internal/api/token_response_authority.go
@@ -15,13 +15,23 @@ import (
// handler waits for a provider. Keep the original work/context lifetime, but
// recheck authority at disclosure, including headers and error responses.
func retainTokenResponseAuthority(cfg *config.Config, scope string, instanceAdmin bool, next http.HandlerFunc) http.HandlerFunc {
- return retainResponseAuthority(cfg, scope, instanceAdmin, false, next)
+ return retainResponseAuthority(cfg, scope, instanceAdmin, responseMediaJSON, next)
}
-// retainResponseAuthority also serves the existing private diagnostic download.
-// The caller selects JSON or ZIP, never arbitrary executable media. Authority,
-// closure and plain-text refusals stay shared with synchronous Assistant results.
-func retainResponseAuthority(cfg *config.Config, scope string, instanceAdmin bool, zipDownload bool, next http.HandlerFunc) http.HandlerFunc {
+// responseMediaPolicy is a closed transport choice. Adding report downloads
+// must not let a report renderer widen Assistant results or diagnostic ZIPs.
+type responseMediaPolicy uint8
+
+const (
+ responseMediaJSON responseMediaPolicy = iota
+ responseMediaZIP
+ responseMediaReport
+)
+
+// retainResponseAuthority serves slow synchronous results and private downloads.
+// It preserves the route's existing gates and work lifetime; the media policy
+// selects only that transport's data formats, never arbitrary executable media.
+func retainResponseAuthority(cfg *config.Config, scope string, instanceAdmin bool, media responseMediaPolicy, next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
revalidate := tokenStreamSnapshotRevalidator(cfg, r, scope)
sessionAllowed := sessionReadRevalidator(r)
@@ -41,7 +51,7 @@ func retainResponseAuthority(cfg *config.Config, scope string, instanceAdmin boo
http.Error(w, "Authentication required", http.StatusUnauthorized)
return
}
- writer := &tokenResponseWriter{writer: w, header: w.Header().Clone(), allowed: allowed, zipDownload: zipDownload}
+ writer := &tokenResponseWriter{writer: w, header: w.Header().Clone(), allowed: allowed, media: media}
defer writer.close()
next(writer, r)
// A bodyless handler must not implicitly return 200 after withdrawal.
@@ -54,13 +64,13 @@ func retainResponseAuthority(cfg *config.Config, scope string, instanceAdmin boo
// write produces a generic 401, not false-success/empty JSON; after any admitted
// response bytes, denial only stops further output, never appends an auth error.
type tokenResponseWriter struct {
- writer http.ResponseWriter
- header http.Header
- allowed func() bool
- zipDownload bool
- mu sync.Mutex
- started bool
- closed bool
+ writer http.ResponseWriter
+ header http.Header
+ allowed func() bool
+ media responseMediaPolicy
+ mu sync.Mutex
+ started bool
+ closed bool
}
func (w *tokenResponseWriter) Header() http.Header { return w.header }
@@ -97,15 +107,29 @@ func (w *tokenResponseWriter) commitLocked(status int) {
// types must not allow HTTP sniffing or an extension to render HTML.
// Leave payload bytes alone: HTML-escaping JSON would corrupt data.
mediaType, _, err := mime.ParseMediaType(w.header.Get("Content-Type"))
- expectedType := "application/json"
- if w.zipDownload {
- expectedType = "application/zip"
- }
- if err == nil && mediaType == expectedType {
- header.Set("Content-Type", expectedType)
- } else {
- header.Set("Content-Type", "text/plain; charset=utf-8")
+ pinnedType := "text/plain; charset=utf-8"
+ if err == nil {
+ switch w.media {
+ case responseMediaJSON:
+ if mediaType == "application/json" {
+ pinnedType = mediaType
+ }
+ case responseMediaZIP:
+ if mediaType == "application/zip" {
+ pinnedType = mediaType
+ }
+ case responseMediaReport:
+ // Existing PDF/CSV attachments and structured API errors.
+ // CSV is UTF-8; never forward renderer-supplied parameters.
+ switch mediaType {
+ case "application/pdf", "application/json":
+ pinnedType = mediaType
+ case "text/csv":
+ pinnedType = "text/csv; charset=utf-8"
+ }
+ }
}
+ header.Set("Content-Type", pinnedType)
header.Set("X-Content-Type-Options", "nosniff")
w.writer.WriteHeader(status)
// Informational headers do not commit the final response.