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
Keep audit CSV text literal without rewriting signed evidence
pulse-triage[bot]0771be9b27c3
diff --git a/docs/release-control/v6/internal/subsystems/security-privacy.md b/docs/release-control/v6/internal/subsystems/security-privacy.mdindex cd289498fe..12a1ae67b5 100644--- a/docs/release-control/v6/internal/subsystems/security-privacy.md+++ b/docs/release-control/v6/internal/subsystems/security-privacy.md@@ -18,6 +18,24 @@## Purpose+### Audit CSV is a spreadsheet projection, not rewritten evidence++The canonical audit exporter prefixes dangerous text cells with one apostrophe+at CSV rendering only. ID, event type, user, IP, path, details and signature+text cannot begin as formulas, including after whitespace/BOM, with full-width+formula introducers, or with leading tab/CR/LF controls. Ordinary and already+literal text is unchanged; CSV quoting still owns column/row boundaries.+Generated timestamps, success and verification booleans keep their existing forms.++Verification receives the original signed events before this projection. Valid+v2 and historical signatures, invalid and absent verdicts, JSON evidence, stored+records, selection/tenant scope and the 10,000-event ceiling are unchanged.+Use JSON for lossless evidence; CSV's text marker is not part of the signed event.+`TestExporterCSVLiteralCells` covers every text column and idempotence;+`TestExporterCSVVerifiesOriginalSignedEvents` covers original inputs, real+signatures, repeat CSV/JSON exports and unchanged source records. The canonical+HTTP export tests retain attachment metadata and the same bounded, scoped rows.+### Proxmox trust choices are endpoint-scopedPersisted PVE `tlsFingerprintOverrides` are exact authority/base-path operatordiff --git a/internal/api/audit_handlers_test.go b/internal/api/audit_handlers_test.goindex f97f5e7921..233664a4cd 100644--- a/internal/api/audit_handlers_test.go+++ b/internal/api/audit_handlers_test.go@@ -1,8 +1,10 @@package apiimport (+ "bytes""context""encoding/base64"+ "encoding/csv""encoding/json""fmt""net"@@ -14,6 +16,7 @@ import ("testing""time"+ "github.com/rcourtman/pulse-go-rewrite/internal/config"unifiedresources "github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources""github.com/rcourtman/pulse-go-rewrite/pkg/audit""github.com/stretchr/testify/assert"@@ -1312,3 +1315,101 @@ func TestSAMLACSAuditsResponseNotAnsweringThisBrowsersLogin(t *testing.T) {t.Fatalf("expected one successful saml_login event, got %+v", completions)}}++// Real exporter, HMAC verification and authenticated router, without a database.+type csvAuditLogger struct {+ *auditSelectionLogger+ signer *audit.Signer+ verified []audit.Event+}++func (l *csvAuditLogger) VerifySignature(event audit.Event) bool {+ l.verified = append(l.verified, event)+ return l.signer.Verify(event)+}+func newCSVAuditFixture(t *testing.T) *csvAuditLogger {+ t.Helper()+ signer, err := audit.NewSignerWithKey(bytes.Repeat([]byte{0x43}, 32))+ if err != nil {+ t.Fatal(err)+ }+ original := audit.Event{ID: "valid", Timestamp: time.Date(2026, 10, 27, 12, 0, 0, 0, time.UTC), EventType: "login",+ User: "=operator", IP: "192.0.2.1", Path: "+path", Details: "=1+1, \"quote\"\nline two", Success: true}+ original.Signature = signer.Sign(original)+ tampered := original+ tampered.ID = "tampered"+ tampered.Signature = signer.Sign(tampered)+ tampered.Details += " altered"+ malformed := original+ malformed.ID = "malformed"+ malformed.Signature = "@invalid"+ unsigned := original+ unsigned.ID = "unsigned"+ unsigned.Signature = ""+ unsigned.Success = false+ other := original+ other.ID = "unselected"+ other.User = "other-operator"+ logger := newAuditSelectionLogger()+ logger.events = []audit.Event{original, tampered, malformed, unsigned, other}+ return &csvAuditLogger{auditSelectionLogger: logger, signer: signer}+}++func TestHandleExportAuditCSVUsesLiteralProjection(t *testing.T) {+ t.Setenv("PULSE_DEV", "true")+ logger := newCSVAuditFixture(t)+ setAuditLogger(t, logger)+ token := "synthetic-csv-audit-token-123.12345678"+ record := newTokenRecord(t, token, []string{config.ScopeAuditRead}, nil)+ router := NewRouter(newTestConfigWithTokens(t, record), nil, nil, nil, nil, "1.0.0")+ original := append([]audit.Event(nil), logger.events...)+ for _, verify := range []bool{false, true} {+ for repeat := 0; repeat < 2; repeat++ {+ logger.verified = nil+ path := "/api/audit/export?event=login&user=%3Doperator&format=csv&verify=" + fmt.Sprint(verify) + "&limit=1&offset=999"+ req := httptest.NewRequest(http.MethodGet, path, nil)+ req.Header.Set("X-API-Token", token)+ rec := httptest.NewRecorder()+ router.Handler().ServeHTTP(rec, req)+ if rec.Code != 200 || rec.Header().Get("Content-Type") != "text/csv; charset=utf-8" || rec.Header().Get("X-Event-Count") != "4" || !strings.HasPrefix(rec.Header().Get("Content-Disposition"), "attachment; filename=audit-log-") {+ t.Fatalf("CSV status/metadata = %d/%v", rec.Code, rec.Header())+ }+ rows, err := csv.NewReader(rec.Body).ReadAll()+ if err != nil || len(rows) != 5 {+ t.Fatalf("invalid selected CSV: %v / %q", err, rows)+ }+ for i, row := range rows[1:] {+ if row[0] != original[i].ID || row[3] != "'=operator" || row[5] != "'+path" || row[7] != "'"+original[i].Details {+ t.Fatalf("row %d lost literal fields: %q", i, row)+ }+ if verify && row[9] != []string{"true", "false", "false", ""}[i] {+ t.Fatal("CSV changed original verdict")+ }+ }+ if verify && !reflect.DeepEqual(logger.verified, original[:3]) || !verify && len(logger.verified) != 0 {+ t.Fatal("verification did not receive original selected signatures")+ }+ if logger.lastQuery.User != "=operator" || logger.lastQuery.Limit != audit.MaxExportEvents+1 || logger.lastQuery.Offset != 0 || !reflect.DeepEqual(logger.events, original) {+ t.Fatal("projection changed selection/limits/source")+ }+ req = httptest.NewRequest(http.MethodGet, strings.Replace(path, "format=csv", "format=json", 1), nil)+ req.Header.Set("X-API-Token", token)+ rec = httptest.NewRecorder()+ router.Handler().ServeHTTP(rec, req)+ var body struct {+ Events []audit.ExportEvent `json:"events"`+ }+ if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {+ t.Fatal(err)+ }+ if rec.Code != 200 || len(body.Events) != 4 {+ t.Fatal("JSON lost original selection")+ }+ for i, event := range body.Events {+ if event.ID != original[i].ID || event.User != original[i].User || event.Details != original[i].Details || event.Path != original[i].Path || event.Signature != original[i].Signature {+ t.Fatal("JSON changed signed evidence")+ }+ }+ }+ }+}diff --git a/pkg/audit/export.go b/pkg/audit/export.goindex 4104551ea3..427f5cb6f3 100644--- a/pkg/audit/export.go+++ b/pkg/audit/export.go@@ -6,7 +6,9 @@ import ("encoding/json""errors""fmt"+ "strings""time"+ "unicode")// ExportFormat defines the export file format.@@ -142,15 +144,15 @@ func (e *Exporter) exportCSV(events []ExportEvent, timestamp string, includeVeri}row := []string{- event.ID,+ auditCSVText(event.ID),event.Timestamp.Format(time.RFC3339),- event.EventType,- event.User,- event.IP,- event.Path,+ auditCSVText(event.EventType),+ auditCSVText(event.User),+ auditCSVText(event.IP),+ auditCSVText(event.Path),success,- event.Details,- event.Signature,+ auditCSVText(event.Details),+ auditCSVText(event.Signature),}if includeVerification {@@ -183,6 +185,31 @@ func (e *Exporter) exportCSV(events []ExportEvent, timestamp string, includeVeri}, nil}+// auditCSVText projects untrusted text as a spreadsheet literal. CSV quoting+// protects column boundaries, not cell types. Match the reporting CSV boundary,+// preserving the original bytes after a single text marker. This runs only at+// CSV rendering: verification must use the original signed event, and JSON+// remains the lossless evidence export rather than this spreadsheet projection.+func auditCSVText(value string) string {+ if value == "" {+ return value+ }+ switch value[0] {+ case '\t', '\r', '\n':+ return "'" + value+ }+ leading := strings.TrimLeftFunc(value, func(r rune) bool {+ return unicode.IsSpace(r) || r == '\uFEFF'+ })+ for _, first := range leading {+ if strings.ContainsRune("=+-@=+-@", first) {+ return "'" + value+ }+ break+ }+ return value+}+// exportJSON generates a JSON export.func (e *Exporter) exportJSON(events []ExportEvent, timestamp string) (*ExportResult, error) {// Wrap in an object for better structurediff --git a/pkg/audit/export_test.go b/pkg/audit/export_test.goindex b94d0448f7..d461377474 100644--- a/pkg/audit/export_test.go+++ b/pkg/audit/export_test.go@@ -1,9 +1,11 @@package auditimport (+ "bytes""encoding/csv""encoding/json""errors"+ "reflect""strings""testing""time"@@ -113,3 +115,169 @@ func TestExporterExportAndSummary(t *testing.T) {t.Fatalf("unexpected summary: %+v", summary)}}++// All seven text columns are untrusted, including malformed signature text.+// The timestamp and generated booleans are not spreadsheet text projections.+func TestExporterCSVLiteralCells(t *testing.T) {+ cases := []struct {+ name, text string+ literal bool+ }{+ {"equals", "=1+1", true}, {"plus", "+1+1", true},+ {"minus", "-12.5", true}, {"at", "@SUM(1,1)", true},+ {"tab", "\toperator", true}, {"cr", "\roperator", true}, {"lf", "\noperator", true},+ {"spaces", " \t=1+1", true}, {"nbsp", "\u00a0+1+1", true},+ {"unicode_space", "\u2003@SUM(1,1)", true}, {"bom", "\uFEFF-1", true},+ {"mixed_bom_space", " \uFEFF\t=1+1", true},+ {"wide_equals", "=1+1", true}, {"wide_plus", "+1", true},+ {"wide_minus", "-1", true}, {"wide_at", "@SUM(1,1)", true},+ {"quoted_multiline", "=\"comma,quote\"\r\nand newline", true},+ {"empty", "", false}, {"ordinary", "node-1", false},+ {"space_text", " node-1", false}, {"unicode", "東京", false},+ {"apostrophe", "O'Brien", false}, {"already_literal", "'=1+1", false},+ {"already_tab_literal", "'\toperator", false}, {"numeric_text", "12.50", false},+ {"whitespace_only", " \u00a0", false}, {"embedded", "name=1+1", false},+ {"ordinary_multiline", "comma,quote\"and\r\nnewline", false},+ }+ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ want := tc.text+ if tc.literal {+ want = "'" + want+ }+ for _, verify := range []bool{false, true} {+ event := Event{ID: tc.text, Timestamp: time.Date(2026, 10, 27, 12, 0, 0, 0, time.UTC),+ EventType: tc.text, User: tc.text, IP: tc.text, Path: tc.text, Details: tc.text, Signature: tc.text, Success: true}+ logger := &exportBoundsLogger{events: []Event{event}}+ result, err := NewExporter(logger).Export(QueryFilter{}, ExportFormatCSV, verify)+ if err != nil {+ t.Fatal(err)+ }+ header := []string{"ID", "Timestamp", "Event Type", "User", "IP", "Path", "Success", "Details", "Signature"}+ row := []string{want, "2026-10-27T12:00:00Z", want, want, want, want, "true", want, want}+ count := 0+ if verify {+ header = append(header, "Signature Valid")+ verdict := ""+ if tc.text != "" {+ verdict = "false"+ count = 1+ }+ row = append(row, verdict)+ }+ // Compare encoded bytes too: csv.Reader normalises embedded CRLF to LF.+ var expected bytes.Buffer+ writer := csv.NewWriter(&expected)+ if err := writer.WriteAll([][]string{header, row}); err != nil {+ t.Fatal(err)+ }+ if !bytes.Equal(result.Data, expected.Bytes()) {+ t.Fatalf("verify=%t: CSV bytes = %q, want %q", verify, result.Data, expected.Bytes())+ }+ rows, err := csv.NewReader(bytes.NewReader(result.Data)).ReadAll()+ if err != nil || len(rows) != 2 || len(rows[1]) != len(row) {+ t.Fatalf("invalid CSV shape: %q / %v", rows, err)+ }+ if result.EventCount != 1 || result.ContentType != "text/csv; charset=utf-8" || logger.verifications != count || logger.events[0] != event {+ t.Fatal("projection changed metadata, verification count or source event")+ }+ }+ })+ }+}++type csvSignatureLogger struct {+ events []Event+ signer *Signer+ verified []Event+}++func (l *csvSignatureLogger) Query(QueryFilter) ([]Event, error) { return l.events, nil }+func (l *csvSignatureLogger) VerifySignature(event Event) bool {+ l.verified = append(l.verified, event)+ return l.signer.Verify(event)+}++func TestExporterCSVVerifiesOriginalSignedEvents(t *testing.T) {+ signer, err := NewSignerWithKey(bytes.Repeat([]byte{0x42}, 32))+ if err != nil {+ t.Fatal(err)+ }+ base := Event{ID: "=event", Timestamp: time.Date(2026, 10, 27, 12, 0, 0, 123, time.UTC), EventType: "+login",+ User: "\uFEFF@operator", IP: "-address", Path: "=path", Success: true, Details: "\t=1+1,\"detail\"\nline two"}+ valid := base+ valid.Signature = signer.Sign(valid)+ legacy := base+ legacy.ID = "legacy"+ legacy.Signature = signer.signCanonical(signer.legacyTimeCanonicalForm(legacy))+ tampered := valid+ tampered.Details += " tampered"+ malformed := base+ malformed.Signature = "=invalid-signature"+ unsigned := base+ unsigned.Signature = ""+ unsigned.Success = false+ original := []Event{valid, legacy, tampered, malformed, unsigned}+ logger := &csvSignatureLogger{events: append([]Event(nil), original...), signer: signer}+ exporter := NewExporter(logger)+ for _, verify := range []bool{false, true} {+ for repeat := 0; repeat < 2; repeat++ {+ logger.verified = nil+ csvResult, err := exporter.Export(QueryFilter{}, ExportFormatCSV, verify)+ if err != nil {+ t.Fatal(err)+ }+ rows, err := csv.NewReader(bytes.NewReader(csvResult.Data)).ReadAll()+ if err != nil {+ t.Fatal(err)+ }+ if len(rows) != 6 {+ t.Fatal("missing rows")+ }+ for i, row := range rows[1:] {+ signature := original[i].Signature+ if i == 3 {+ signature = "'" + signature+ }+ if row[3] != "'"+original[i].User || row[7] != "'"+original[i].Details || row[8] != signature {+ t.Fatalf("row %d lost literal text/signature", i)+ }+ if verify && row[9] != []string{"true", "true", "false", "false", ""}[i] {+ t.Fatalf("row %d changed original signature verdict: %q", i, row[9])+ }+ }+ if verify && !reflect.DeepEqual(logger.verified, original[:4]) || !verify && len(logger.verified) != 0 {+ t.Fatal("verification did not use exactly the original signed rows")+ }+ jsonResult, err := exporter.Export(QueryFilter{}, ExportFormatJSON, verify)+ if err != nil {+ t.Fatal(err)+ }+ var body struct {+ Events []ExportEvent `json:"events"`+ }+ if err := json.Unmarshal(jsonResult.Data, &body); err != nil {+ t.Fatal(err)+ }+ if len(body.Events) != len(original) {+ t.Fatal("JSON lost rows")+ }+ for i, got := range body.Events {+ want := original[i]+ if got.ID != want.ID || got.Timestamp != want.Timestamp || got.EventType != want.EventType || got.User != want.User || got.IP != want.IP || got.Path != want.Path || got.Success != want.Success || got.Details != want.Details || got.Signature != want.Signature {+ t.Fatal("JSON rewrote evidence")+ }+ if !verify || i == 4 {+ if got.SignatureValid != nil {+ t.Fatal("invented signature verdict")+ }+ } else if got.SignatureValid == nil || *got.SignatureValid != (i < 2) {+ t.Fatal("JSON signature verdict changed")+ }+ }+ if !reflect.DeepEqual(logger.events, original) {+ t.Fatal("export mutated signed source")+ }+ }+ }+}