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.

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.md
index 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-scoped
Persisted PVE `tlsFingerprintOverrides` are exact authority/base-path operator
diff --git a/internal/api/audit_handlers_test.go b/internal/api/audit_handlers_test.go
index f97f5e7921..233664a4cd 100644
--- a/internal/api/audit_handlers_test.go
+++ b/internal/api/audit_handlers_test.go
@@ -1,8 +1,10 @@
package api
import (
+ "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.go
index 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 structure
diff --git a/pkg/audit/export_test.go b/pkg/audit/export_test.go
index b94d0448f7..d461377474 100644
--- a/pkg/audit/export_test.go
+++ b/pkg/audit/export_test.go
@@ -1,9 +1,11 @@
package audit
import (
+ "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")
+ }
+ }
+ }
+}