253 lines
8.0 KiB
Go
253 lines
8.0 KiB
Go
// Audit feed: the read model over every durable trail the State Store owns,
|
|
// mapped into internal/domain/audit's row shape. Every entry is redacted here,
|
|
// before it crosses the gRPC boundary; undecodable JSON is dropped rather than
|
|
// passed through.
|
|
package postgres
|
|
|
|
import (
|
|
"cmp"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"slices"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/audit"
|
|
"github.com/samcharles93/archie-core/internal/domain/org"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/postgresdb"
|
|
"github.com/samcharles93/archie-core/internal/webhookguard"
|
|
)
|
|
|
|
var _ audit.Store = (*Store)(nil)
|
|
|
|
// auditFieldJSON is one field of a change set on the wire: two JSON values,
|
|
// either of which is null when that side of the change is absent.
|
|
type auditFieldJSON struct {
|
|
Old json.RawMessage `json:"old"`
|
|
New json.RawMessage `json:"new"`
|
|
}
|
|
|
|
// ListAudit returns one org-scoped page of the feed. The org comes from the
|
|
// request context; a request that names no org reads the system org, which is
|
|
// the org an unattributed call acts in.
|
|
func (s *Store) ListAudit(ctx context.Context, filter audit.Filter, cursor audit.Cursor, limit int) (audit.Page, error) {
|
|
if err := filter.Normalize(); err != nil {
|
|
return audit.Page{}, err
|
|
}
|
|
limit = audit.NormalizeLimit(limit)
|
|
orgID := org.DefaultOrgID
|
|
if scoped, ok := org.Scope(ctx); ok {
|
|
orgID = scoped
|
|
}
|
|
rows, err := s.queries().ListAudit(ctx, postgresdb.ListAuditParams{
|
|
PageLimit: int64(limit + 1),
|
|
OrgID: string(orgID),
|
|
InstanceAdmin: audit.InstanceAdmin(ctx),
|
|
Categories: filter.Categories,
|
|
FromAt: auditTime(filter.From),
|
|
ToAt: auditTime(filter.To),
|
|
Actor: auditText(filter.Actor),
|
|
Actions: filter.Actions,
|
|
Kinds: filter.Kinds,
|
|
TargetKinds: filter.TargetKinds,
|
|
TargetIds: filter.TargetIDs,
|
|
Severities: filter.Severities,
|
|
Outcomes: filter.Outcomes,
|
|
Q: auditText(filter.Query),
|
|
CursorAt: auditTime(cursor.At),
|
|
CursorRank: int32(cursor.Rank),
|
|
CursorID: cursor.ID,
|
|
})
|
|
if err != nil {
|
|
return audit.Page{}, fmt.Errorf("list audit: %w", err)
|
|
}
|
|
page := audit.Page{}
|
|
if len(rows) > limit {
|
|
page.HasMore = true
|
|
rows = rows[:limit]
|
|
}
|
|
page.Entries = make([]audit.Entry, len(rows))
|
|
for i := range rows {
|
|
page.Entries[i] = auditEntry(rows[i])
|
|
}
|
|
if page.HasMore {
|
|
last := page.Entries[len(page.Entries)-1]
|
|
page.NextCursor = audit.Cursor{
|
|
At: last.At, Rank: last.Rank, ID: last.SourceID, FilterHash: filter.Hash(),
|
|
}.Encode()
|
|
}
|
|
return page, nil
|
|
}
|
|
|
|
// AuditHead returns the cheap change token: the newest id of each trail the
|
|
// caller can read, and the denial count sum because a coalesced denial bumps
|
|
// its count in place without drawing a new id.
|
|
func (s *Store) AuditHead(ctx context.Context) (string, error) {
|
|
orgID := org.DefaultOrgID
|
|
if scoped, ok := org.Scope(ctx); ok {
|
|
orgID = scoped
|
|
}
|
|
row, err := s.queries().AuditHead(ctx, postgresdb.AuditHeadParams{
|
|
OrgID: string(orgID),
|
|
InstanceAdmin: audit.InstanceAdmin(ctx),
|
|
})
|
|
if err != nil {
|
|
return "", fmt.Errorf("audit head: %w", err)
|
|
}
|
|
return fmt.Sprintf("%d:%d:%d:%d:%d",
|
|
row.SysAuditID, row.IdentityEventID, row.AccessDenialID, row.AccessDenialCount, row.EventID), nil
|
|
}
|
|
|
|
// CountAudit returns how many entries a filter matches, with the same org and
|
|
// instance scoping as a page. It counts change sets, not field rows, so the
|
|
// number is exactly what an export of that filter would stream.
|
|
func (s *Store) CountAudit(ctx context.Context, filter audit.Filter) (int64, error) {
|
|
if err := filter.Normalize(); err != nil {
|
|
return 0, err
|
|
}
|
|
orgID := org.DefaultOrgID
|
|
if scoped, ok := org.Scope(ctx); ok {
|
|
orgID = scoped
|
|
}
|
|
count, err := s.queries().CountAudit(ctx, postgresdb.CountAuditParams{
|
|
OrgID: string(orgID),
|
|
InstanceAdmin: audit.InstanceAdmin(ctx),
|
|
Categories: filter.Categories,
|
|
FromAt: auditTime(filter.From),
|
|
ToAt: auditTime(filter.To),
|
|
Actor: auditText(filter.Actor),
|
|
Actions: filter.Actions,
|
|
Kinds: filter.Kinds,
|
|
TargetKinds: filter.TargetKinds,
|
|
TargetIds: filter.TargetIDs,
|
|
Severities: filter.Severities,
|
|
Outcomes: filter.Outcomes,
|
|
Q: auditText(filter.Query),
|
|
})
|
|
if err != nil {
|
|
return 0, fmt.Errorf("count audit: %w", err)
|
|
}
|
|
return count, nil
|
|
}
|
|
|
|
// auditExportRecord is the value stored on a completed export's audit row.
|
|
type auditExportRecord struct {
|
|
Format string `json:"format"`
|
|
FiltersHash string `json:"filters_hash"`
|
|
Rows int64 `json:"rows"`
|
|
}
|
|
|
|
// RecordAuditExport appends the audit row of one completed export. The org,
|
|
// actor and source come from the caller's context, as every sys_audit write
|
|
// does.
|
|
func (s *Store) RecordAuditExport(ctx context.Context, format, filterHash string, rows int64) error {
|
|
orgID := org.DefaultOrgID
|
|
if scoped, ok := org.Scope(ctx); ok {
|
|
orgID = scoped
|
|
}
|
|
return insertAuditValues(ctx, s.queries(), "audit_export", "export", "export", nil,
|
|
auditExportRecord{Format: format, FiltersHash: filterHash, Rows: rows}, 0, string(orgID))
|
|
}
|
|
|
|
func auditTime(t time.Time) pgtype.Timestamptz {
|
|
if t.IsZero() {
|
|
return pgtype.Timestamptz{}
|
|
}
|
|
return pgtype.Timestamptz{Time: t, Valid: true}
|
|
}
|
|
|
|
func auditText(value string) pgtype.Text {
|
|
if value == "" {
|
|
return pgtype.Text{}
|
|
}
|
|
return pgtype.Text{String: value, Valid: true}
|
|
}
|
|
|
|
// auditEntry maps one read-model row to the domain entry, redacting every
|
|
// free-form part. A field list or data document that cannot be decoded is
|
|
// dropped, never forwarded unredacted.
|
|
func auditEntry(row postgresdb.ListAuditRow) audit.Entry {
|
|
return audit.Entry{
|
|
Rank: int(row.SourceRank),
|
|
SourceID: row.SourceID,
|
|
Category: audit.Category(row.Category),
|
|
At: row.At,
|
|
Actor: row.Actor,
|
|
ActorKind: row.ActorKind,
|
|
PrincipalID: row.PrincipalID,
|
|
TargetKind: row.TargetKind,
|
|
TargetID: row.TargetID,
|
|
Kind: row.Kind,
|
|
RecordVersion: row.RecordVersion,
|
|
RequestID: row.RequestID,
|
|
Source: row.Source,
|
|
Fields: redactedFields(row.Fields),
|
|
Action: row.Action,
|
|
Severity: audit.Severity(row.Severity),
|
|
Outcome: audit.Outcome(row.Outcome),
|
|
Detail: webhookguard.RedactString(row.Detail),
|
|
WorkspaceID: row.WorkspaceID,
|
|
TaskID: row.TaskID,
|
|
Data: redactedData(row.DataText),
|
|
}
|
|
}
|
|
|
|
// redactedFields decodes the change set's fields object, redacts each side
|
|
// under its own field name, and returns them sorted for a stable view.
|
|
func redactedFields(encoded []byte) []audit.Field {
|
|
if len(encoded) == 0 {
|
|
return nil
|
|
}
|
|
var raw map[string]auditFieldJSON
|
|
if err := json.Unmarshal(encoded, &raw); err != nil {
|
|
return nil
|
|
}
|
|
fields := make([]audit.Field, 0, len(raw))
|
|
for name, side := range raw {
|
|
fields = append(fields, audit.Field{
|
|
Name: name,
|
|
Old: redactFieldValue(name, side.Old),
|
|
New: redactFieldValue(name, side.New),
|
|
})
|
|
}
|
|
slices.SortFunc(fields, func(a, b audit.Field) int { return cmp.Compare(a.Name, b.Name) })
|
|
return fields
|
|
}
|
|
|
|
// redactFieldValue redacts one side of one field. Wrapping it under the field
|
|
// name lets the existing redactor apply both its key and value rules, so a
|
|
// secret reference survives as a hidden value while the field name stays.
|
|
func redactFieldValue(name string, value json.RawMessage) json.RawMessage {
|
|
if len(value) == 0 || string(value) == "null" {
|
|
return value
|
|
}
|
|
wrapped, err := json.Marshal(map[string]json.RawMessage{name: value})
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
redacted, err := webhookguard.RedactPayload(wrapped)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
var out map[string]json.RawMessage
|
|
if err := json.Unmarshal(redacted, &out); err != nil {
|
|
return nil
|
|
}
|
|
return out[name]
|
|
}
|
|
|
|
// redactedData redacts an event's data document, dropping one that cannot be
|
|
// decoded. An empty document is absent rather than an empty object.
|
|
func redactedData(text string) json.RawMessage {
|
|
if text == "" || text == "{}" {
|
|
return nil
|
|
}
|
|
redacted, err := webhookguard.RedactPayload([]byte(text))
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return redacted
|
|
}
|