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 audit evidence after credential withdrawal

pulse-triage[bot]ffa96dd81e36
diff --git a/internal/api/audit_read_authority_test.go b/internal/api/audit_read_authority_test.go
new file mode 100644
index 0000000000..b130ab7b45
--- /dev/null
+++ b/internal/api/audit_read_authority_test.go
@@ -0,0 +1,14 @@
+package api
+
+import (
+ "github.com/rcourtman/pulse-go-rewrite/internal/config"
+ "testing"
+)
+
+func TestAuditReadCurrentAuthorityAndPrefix(t *testing.T) {
+ responseCurrentAuthorityAndPrefix(t, config.ScopeAuditRead, responseMediaAudit)
+}
+
+func TestAuditReadKeepsOrganizationBoundAuthority(t *testing.T) {
+ responseKeepsOrganizationBoundAuthority(t, config.ScopeAuditRead, responseMediaAudit)
+}
diff --git a/internal/api/audit_read_lifetime_test.go b/internal/api/audit_read_lifetime_test.go
new file mode 100644
index 0000000000..3ea4d11fb5
--- /dev/null
+++ b/internal/api/audit_read_lifetime_test.go
@@ -0,0 +1,277 @@
+package api
+
+import (
+ "context"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "sync"
+ "sync/atomic"
+ "testing"
+ "time"
+
+ "github.com/rcourtman/pulse-go-rewrite/internal/config"
+ "github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"
+ "github.com/rcourtman/pulse-go-rewrite/pkg/audit"
+ pkglicensing "github.com/rcourtman/pulse-go-rewrite/pkg/licensing"
+)
+
+// Only synthetic in-memory evidence: hold the real handlers' storage read,
+// after actual Router authentication/permission/licence/scope admission.
+type auditReadHold struct {
+ armed atomic.Bool
+ entered, release chan struct{}
+ once sync.Once
+}
+
+func (h *auditReadHold) wait() {
+ if h.armed.Load() {
+ h.once.Do(func() { close(h.entered) })
+ <-h.release
+ }
+}
+func (h *auditReadHold) unblock() {
+ select {
+ case <-h.release:
+ default:
+ close(h.release)
+ }
+}
+
+type heldAuditLogger struct {
+ hold *auditReadHold
+ event audit.Event
+}
+
+func (l *heldAuditLogger) Record(audit.Event) error { return nil }
+func (l *heldAuditLogger) Query(f audit.QueryFilter) ([]audit.Event, error) {
+ l.hold.wait()
+ if f.ID != "" && f.ID != l.event.ID {
+ return []audit.Event{}, nil
+ }
+ return []audit.Event{l.event}, nil
+}
+func (l *heldAuditLogger) Count(audit.QueryFilter) (int, error) { return 1, nil }
+func (l *heldAuditLogger) Close() error { return nil }
+func (l *heldAuditLogger) GetWebhookURLs() []string { return nil }
+func (l *heldAuditLogger) UpdateWebhookURLs([]string) error { return nil }
+func (l *heldAuditLogger) VerifySignature(e audit.Event) bool {
+ return e.Signature == l.event.Signature
+}
+
+type heldAuditResourceStore struct {
+ unifiedresources.ResourceStore
+ hold *auditReadHold
+}
+
+func (s *heldAuditResourceStore) GetActionAudits(id string, since time.Time, limit int) ([]unifiedresources.ActionAuditRecord, error) {
+ s.hold.wait()
+ return s.ResourceStore.GetActionAudits(id, since, limit)
+}
+func (s *heldAuditResourceStore) GetActionLifecycleEvents(id string, since time.Time, limit int) ([]unifiedresources.ActionLifecycleEvent, error) {
+ s.hold.wait()
+ return s.ResourceStore.GetActionLifecycleEvents(id, since, limit)
+}
+func (s *heldAuditResourceStore) GetExportAudits(since time.Time, limit int) ([]unifiedresources.ExportAuditRecord, error) {
+ s.hold.wait()
+ return s.ResourceStore.GetExportAudits(since, limit)
+}
+
+type auditReadCase struct{ name, path, marker string }
+
+func auditReadCases() []auditReadCase {
+ return []auditReadCase{
+ {"list", "/api/audit", "private-audit-fixture"},
+ {"list_slash", "/api/audit/", "private-audit-fixture"},
+ {"verify", "/api/audit/private-audit-fixture/verify", "verified"},
+ {"export_json", "/api/audit/export?format=json&verify=true", "private-audit-fixture"},
+ {"export_csv", "/api/audit/export?format=csv&verify=true", "private-audit-fixture"},
+ {"summary", "/api/audit/summary?verify=true", "config_change"},
+ {"actions", "/api/audit/actions", "private-action-fixture"},
+ {"lifecycle", "/api/audit/actions/private-action-fixture/events", "private-action-fixture"},
+ {"exports", "/api/audit/exports", "private-export-fixture"},
+ }
+}
+
+func newHeldAuditReadRouter(t *testing.T) (*Router, *config.Config, *httptest.Server, *auditReadHold) {
+ t.Helper()
+ cfg := newTestConfigWithTokens(t,
+ newTokenRecord(t, logStreamToken, []string{config.ScopeAuditRead}, 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)
+ hold := &auditReadHold{entered: make(chan struct{}), release: make(chan struct{})}
+ now := time.Date(2026, 11, 1, 12, 0, 0, 0, time.UTC)
+ logger := &heldAuditLogger{hold: hold, event: audit.Event{ID: "private-audit-fixture", Timestamp: now, EventType: "config_change", User: "fixture-operator", IP: "192.0.2.10", Path: "/synthetic/private-setting", Success: true, Details: "synthetic private audit evidence", Signature: "synthetic-signature"}}
+ priorManager := GetTenantAuditManager()
+ SetTenantAuditManager(nil)
+ t.Cleanup(func() { SetTenantAuditManager(priorManager) })
+ setAuditLogger(t, logger)
+ store := unifiedresources.NewMemoryStore()
+ if err := store.RecordActionAudit(unifiedresources.ActionAuditRecord{ID: "private-action-fixture", CreatedAt: now, UpdatedAt: now, State: unifiedresources.ActionStateCompleted, Request: unifiedresources.ActionRequest{RequestID: "fixture-request", ResourceID: "vm:100", CapabilityName: "restart", RequestedBy: "fixture-operator"}}); err != nil {
+ t.Fatal(err)
+ }
+ if err := store.RecordActionLifecycleEvent(unifiedresources.ActionLifecycleEvent{ActionID: "private-action-fixture", Timestamp: now, State: unifiedresources.ActionStateCompleted}); err != nil {
+ t.Fatal(err)
+ }
+ if err := store.RecordExportAudit(unifiedresources.ExportAuditRecord{ID: "private-export-fixture", Timestamp: now, Actor: "fixture-operator", EnvelopeHash: "synthetic-hash", Decision: unifiedresources.ExportAllowed, Destination: "synthetic-destination"}); err != nil {
+ t.Fatal(err)
+ }
+ handlers := NewAuditHandlers()
+ handlers.SetResourceStoreProvider(func(string) (unifiedresources.ResourceStore, error) {
+ return &heldAuditResourceStore{ResourceStore: store, hold: hold}, nil
+ })
+ // Re-register the production group with its existing provider seam, avoiding
+ // a real database. Retain the full Router middleware and real DELETE/logout.
+ original := router.mux
+ router.mux = http.NewServeMux()
+ router.registerOrgLicenseRoutesGroup(nil, nil, handlers)
+ router.mux.Handle("/api/security/", original)
+ router.mux.Handle("/api/logout", original)
+ server := httptest.NewServer(router.Handler())
+ t.Cleanup(func() { hold.unblock(); server.Close() })
+ return router, cfg, server, hold
+}
+
+func auditReadRequest(t *testing.T, ctx context.Context, server *httptest.Server, path, raw, transport string) *http.Request {
+ t.Helper()
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, server.URL+path, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ switch transport {
+ case "bearer":
+ req.Header.Set("Authorization", "Bearer "+raw)
+ case "session":
+ req.AddCookie(&http.Cookie{Name: cookieNameSession, Value: raw})
+ default:
+ req.Header.Set("X-API-Token", raw)
+ }
+ return req
+}
+
+func auditReadNativeWithdrawal(t *testing.T) {
+ for _, tc := range auditReadCases() {
+ for _, transport := range []string{"header", "bearer", "session"} {
+ t.Run(tc.name+"/"+transport, func(t *testing.T) {
+ router, cfg, server, hold := newHeldAuditReadRouter(t)
+ ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+ defer cancel()
+ raw := logStreamToken
+ if transport == "session" {
+ raw = "synthetic-audit-session"
+ GetSessionStore().CreateSession(raw, time.Hour, "fixture", "127.0.0.1", cfg.AuthUser)
+ t.Cleanup(func() { GetSessionStore().DeleteSession(raw) })
+ }
+ hold.armed.Store(true)
+ type result struct {
+ response *http.Response
+ err error
+ }
+ done := make(chan result, 1)
+ go func() {
+ r, e := server.Client().Do(auditReadRequest(t, ctx, server, tc.path, raw, transport))
+ done <- result{r, e}
+ }()
+ select {
+ case <-hold.entered:
+ case r := <-done:
+ t.Fatalf("read not admitted: %v %v", r.response, r.err)
+ case <-ctx.Done():
+ t.Fatal("read did not reach storage 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(auditReadRequest(t, ctx, server, tc.path, raw, transport))
+ if err != nil {
+ t.Fatal(err)
+ }
+ fresh.Body.Close()
+ if fresh.StatusCode != http.StatusUnauthorized {
+ t.Fatalf("fresh admission=%d", fresh.StatusCode)
+ }
+ hold.unblock()
+ var completed result
+ select {
+ case completed = <-done:
+ case <-ctx.Done():
+ t.Fatal("held read 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)
+ }
+ if completed.response.StatusCode != http.StatusUnauthorized || string(body) != "Authentication required\n" || completed.response.Header.Get("Content-Disposition") != "" || completed.response.Header.Get("X-Event-Count") != "" {
+ t.Errorf("held audit=%d after persisted withdrawal (private evidence=%v), want generic 401 without attachment/count", completed.response.StatusCode, strings.Contains(string(body), tc.marker))
+ }
+ control, err := server.Client().Do(auditReadRequest(t, ctx, server, tc.path, 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), tc.marker) {
+ t.Fatalf("independent audit read lost: %d %s %v", control.StatusCode, controlBody, err)
+ }
+ })
+ }
+ }
+}
+
+func TestAuditReadNativeWithdrawal(t *testing.T) { auditReadNativeWithdrawal(t) }
+
+func TestAuditReadPreservesAdmission(t *testing.T) {
+ for _, gate := range []string{"scope", "licence", "session_admin"} {
+ t.Run(gate, func(t *testing.T) {
+ router, cfg, server, _ := newHeldAuditReadRouter(t)
+ raw, transport, want := logStreamToken, "header", http.StatusForbidden
+ switch gate {
+ case "scope":
+ config.Mu.Lock()
+ cfg.APITokens[0].Scopes = []string{config.ScopeMonitoringRead}
+ config.Mu.Unlock()
+ case "licence":
+ setLicenseTierForHandlersForTests(t, router.licenseHandlers, "default", pkglicensing.TierFree)
+ want = http.StatusPaymentRequired
+ case "session_admin":
+ raw, transport = "synthetic-nonadmin-audit-session", "session"
+ GetSessionStore().CreateSession(raw, time.Hour, "fixture", "127.0.0.1", "different-user")
+ t.Cleanup(func() { GetSessionStore().DeleteSession(raw) })
+ }
+ for _, tc := range auditReadCases() {
+ response, err := server.Client().Do(auditReadRequest(t, context.Background(), server, tc.path, raw, transport))
+ if err != nil {
+ t.Fatal(err)
+ }
+ body, err := io.ReadAll(response.Body)
+ response.Body.Close()
+ if err != nil || response.StatusCode != want || strings.Contains(string(body), tc.marker) || response.Header.Get("Content-Disposition") != "" {
+ t.Errorf("%s gate=%d %s, want %d", tc.name, response.StatusCode, body, want)
+ }
+ }
+ })
+ }
+}
diff --git a/internal/api/contract_test.go b/internal/api/contract_test.go
index 5e9e6bc516..4a28715504 100644
--- a/internal/api/contract_test.go
+++ b/internal/api/contract_test.go
@@ -29139,3 +29139,10 @@ func TestContractSupportBundleStopsAfterAdmittedPrefix(t *testing.T) {
func TestContractReportDownloadWithdrawal(t *testing.T) {
reportDownloadNativeWithdrawal(t)
}
+
+// Audit evidence stays behind current admitted authority even when storage
+// returns after a persisted DELETE/logout. Existing admission, signed evidence
+// and independent readers remain unchanged.
+func TestContractAuditReadWithdrawal(t *testing.T) {
+ auditReadNativeWithdrawal(t)
+}
diff --git a/internal/api/report_download_authority_test.go b/internal/api/report_download_authority_test.go
index b7b987fdf6..446167bb56 100644
--- a/internal/api/report_download_authority_test.go
+++ b/internal/api/report_download_authority_test.go
@@ -13,7 +13,7 @@ import (
)
func TestReportDownloadMediaPoliciesStaySeparate(t *testing.T) {
- for _, policy := range []responseMediaPolicy{responseMediaJSON, responseMediaZIP, responseMediaReport, responseMediaPolicy(255)} {
+ for _, policy := range []responseMediaPolicy{responseMediaJSON, responseMediaZIP, responseMediaReport, responseMediaAudit, 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()
@@ -36,6 +36,13 @@ func TestReportDownloadMediaPoliciesStaySeparate(t *testing.T) {
if provided == "application/zip" {
want = provided
}
+ case responseMediaAudit:
+ switch {
+ case provided == "application/json":
+ want = provided
+ case strings.HasPrefix(provided, "text/csv"):
+ want = "text/csv; charset=utf-8"
+ }
case responseMediaReport:
switch {
case provided == "application/json", provided == "application/pdf":
@@ -58,6 +65,10 @@ func TestReportDownloadMediaPoliciesStaySeparate(t *testing.T) {
}
func TestReportDownloadCurrentAuthorityAndPrefix(t *testing.T) {
+ responseCurrentAuthorityAndPrefix(t, config.ScopeSettingsRead, responseMediaReport)
+}
+
+func responseCurrentAuthorityAndPrefix(t *testing.T, scope string, media responseMediaPolicy) {
for _, transport := range []string{"header", "bearer", "session"} {
changes := []string{"revoked", "expired", "scope", "org", "identity", "principal", "unrelated_scope"}
if transport == "session" {
@@ -70,7 +81,7 @@ func TestReportDownloadCurrentAuthorityAndPrefix(t *testing.T) {
name = change + "/after_prefix"
}
t.Run(transport+"/"+name, func(t *testing.T) {
- cfg := newTestConfigWithTokens(t, newTokenRecord(t, logStreamToken, []string{config.ScopeSettingsRead, config.ScopeAIExecute}, nil))
+ cfg := newTestConfigWithTokens(t, newTokenRecord(t, logStreamToken, []string{scope, config.ScopeAIExecute}, nil))
const session = "synthetic-report-prefix-session"
if transport == "session" {
InitSessionStore(t.TempDir())
@@ -88,7 +99,7 @@ func TestReportDownloadCurrentAuthorityAndPrefix(t *testing.T) {
}
base := httptest.NewRecorder()
var late http.ResponseWriter
- guard := retainResponseAuthority(cfg, config.ScopeSettingsRead, false, responseMediaReport, func(w http.ResponseWriter, r *http.Request) {
+ guard := retainResponseAuthority(cfg, scope, false, media, 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")
@@ -116,7 +127,7 @@ func TestReportDownloadCurrentAuthorityAndPrefix(t *testing.T) {
case "principal":
cfg.APITokens[0].Metadata = map[string]string{apiTokenMetadataOwnerUserID: "different-owner"}
case "unrelated_scope":
- cfg.APITokens[0].Scopes = []string{config.ScopeSettingsRead}
+ cfg.APITokens[0].Scopes = []string{scope}
}
config.Mu.Unlock()
}
@@ -162,13 +173,17 @@ func TestReportDownloadCurrentAuthorityAndPrefix(t *testing.T) {
}
func TestReportDownloadKeepsOrganizationBoundAuthority(t *testing.T) {
- record := newTokenRecord(t, logStreamToken, []string{config.ScopeSettingsRead}, nil)
+ responseKeepsOrganizationBoundAuthority(t, config.ScopeSettingsRead, responseMediaReport)
+}
+
+func responseKeepsOrganizationBoundAuthority(t *testing.T, scope string, media responseMediaPolicy) {
+ record := newTokenRecord(t, logStreamToken, []string{scope}, 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) {
+ handler := retainResponseAuthority(cfg, scope, false, media, 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)
diff --git a/internal/api/router_routes_licensing.go b/internal/api/router_routes_licensing.go
index ce30f55a09..571ee43ee4 100644
--- a/internal/api/router_routes_licensing.go
+++ b/internal/api/router_routes_licensing.go
@@ -53,49 +53,49 @@ func (r *Router) registerOrgLicenseRoutesGroup(orgHandlers *OrgHandlers, rbacHan
if !ensureAdminSession(r.config, w, req) {
return
}
- RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityList, auditAdminEndpoints.HandleListEvents)))(w, req)
+ RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityList, retainResponseAuthority(r.config, config.ScopeAuditRead, false, responseMediaJSON, auditAdminEndpoints.HandleListEvents))))(w, req)
}))
r.mux.HandleFunc("GET /api/audit/", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceAuditLogs, func(w http.ResponseWriter, req *http.Request) {
if !ensureAdminSession(r.config, w, req) {
return
}
- RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityList, auditAdminEndpoints.HandleListEvents)))(w, req)
+ RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityList, retainResponseAuthority(r.config, config.ScopeAuditRead, false, responseMediaJSON, auditAdminEndpoints.HandleListEvents))))(w, req)
}))
r.mux.HandleFunc("GET /api/audit/{id}/verify", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceAuditLogs, func(w http.ResponseWriter, req *http.Request) {
if !ensureAdminSession(r.config, w, req) {
return
}
- RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityVerify, auditAdminEndpoints.HandleVerifyEvent)))(w, req)
+ RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityVerify, retainResponseAuthority(r.config, config.ScopeAuditRead, false, responseMediaJSON, auditAdminEndpoints.HandleVerifyEvent))))(w, req)
}))
r.mux.HandleFunc("GET /api/audit/export", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceAuditLogs, func(w http.ResponseWriter, req *http.Request) {
if !ensureAdminSession(r.config, w, req) {
return
}
- RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityExport, auditAdminEndpoints.HandleExportEvents)))(w, req)
+ RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityExport, retainResponseAuthority(r.config, config.ScopeAuditRead, false, responseMediaAudit, auditAdminEndpoints.HandleExportEvents))))(w, req)
}))
r.mux.HandleFunc("GET /api/audit/summary", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceAuditLogs, func(w http.ResponseWriter, req *http.Request) {
if !ensureAdminSession(r.config, w, req) {
return
}
- RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivitySummary, auditAdminEndpoints.HandleSummary)))(w, req)
+ RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivitySummary, retainResponseAuthority(r.config, config.ScopeAuditRead, false, responseMediaJSON, auditAdminEndpoints.HandleSummary))))(w, req)
}))
r.mux.HandleFunc("GET /api/audit/actions", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceAuditLogs, func(w http.ResponseWriter, req *http.Request) {
if !ensureAdminSession(r.config, w, req) {
return
}
- RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityList, auditHandlers.HandleListUnifiedActionAudits)))(w, req)
+ RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityList, retainResponseAuthority(r.config, config.ScopeAuditRead, false, responseMediaJSON, auditHandlers.HandleListUnifiedActionAudits))))(w, req)
}))
r.mux.HandleFunc("GET /api/audit/actions/{id}/events", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceAuditLogs, func(w http.ResponseWriter, req *http.Request) {
if !ensureAdminSession(r.config, w, req) {
return
}
- RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityList, auditHandlers.HandleListUnifiedActionLifecycleEvents)))(w, req)
+ RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityList, retainResponseAuthority(r.config, config.ScopeAuditRead, false, responseMediaJSON, auditHandlers.HandleListUnifiedActionLifecycleEvents))))(w, req)
}))
r.mux.HandleFunc("GET /api/audit/exports", RequirePermission(r.config, r.authorizer, auth.ActionRead, auth.ResourceAuditLogs, func(w http.ResponseWriter, req *http.Request) {
if !ensureAdminSession(r.config, w, req) {
return
}
- RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityExport, auditHandlers.HandleListUnifiedExportAudits)))(w, req)
+ RequireLicenseFeature(r.licenseHandlers, featureAuditLoggingValue, RequireScope(config.ScopeAuditRead, r.withAuditReadActivity(config.AuditReadActivityExport, retainResponseAuthority(r.config, config.ScopeAuditRead, false, responseMediaJSON, auditHandlers.HandleListUnifiedExportAudits))))(w, req)
}))
// RBAC routes (Phase 2 - Enterprise feature)
diff --git a/internal/api/token_response_authority.go b/internal/api/token_response_authority.go
index a9c3913a1e..3c9a255767 100644
--- a/internal/api/token_response_authority.go
+++ b/internal/api/token_response_authority.go
@@ -26,6 +26,7 @@ const (
responseMediaJSON responseMediaPolicy = iota
responseMediaZIP
responseMediaReport
+ responseMediaAudit
)
// retainResponseAuthority serves slow synchronous results and private downloads.
@@ -118,6 +119,14 @@ func (w *tokenResponseWriter) commitLocked(status int) {
if mediaType == "application/zip" {
pinnedType = mediaType
}
+ case responseMediaAudit:
+ // Audit exports are structured evidence, never report PDFs.
+ switch mediaType {
+ case "application/json":
+ pinnedType = mediaType
+ case "text/csv":
+ pinnedType = "text/csv; charset=utf-8"
+ }
case responseMediaReport:
// Existing PDF/CSV attachments and structured API errors.
// CSV is UTF-8; never forward renderer-supplied parameters.