231 lines
6.7 KiB
Go
231 lines
6.7 KiB
Go
// Audit: the org-scoped feed RPCs. The State Store derives the org from the
|
|
// authenticated caller's context; no request field names one.
|
|
package staterpc
|
|
|
|
import (
|
|
"context"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
|
|
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
|
|
"github.com/samcharles93/archie-core/internal/domain/access"
|
|
"github.com/samcharles93/archie-core/internal/domain/audit"
|
|
)
|
|
|
|
var errAuditUnavailable = status.Error(codes.Unavailable, "audit feed unavailable")
|
|
|
|
// withInstanceAdmin marks whether the authenticated principal administers the
|
|
// whole instance. The feed uses it instead of the org id: a viewer confined to
|
|
// the system org is not an instance administrator.
|
|
func withInstanceAdmin(ctx context.Context) context.Context {
|
|
principal, ok := access.PrincipalFromContext(ctx)
|
|
return audit.WithInstanceAdmin(ctx, ok && principal.InstanceAdmin())
|
|
}
|
|
|
|
type auditServer struct {
|
|
pb.UnimplementedAuditServiceServer
|
|
*server
|
|
}
|
|
|
|
func auditFilterValue(f *pb.AuditFilter) audit.Filter {
|
|
filter := audit.Filter{
|
|
Categories: f.GetCategories(),
|
|
Actions: f.GetActions(),
|
|
Kinds: f.GetKinds(),
|
|
Actor: f.GetActor(),
|
|
TargetKinds: f.GetTargetKinds(),
|
|
TargetIDs: f.GetTargetIds(),
|
|
Severities: f.GetSeverities(),
|
|
Outcomes: f.GetOutcomes(),
|
|
Query: f.GetQ(),
|
|
}
|
|
if from := f.GetFrom(); from != nil {
|
|
filter.From = from.AsTime()
|
|
}
|
|
if to := f.GetTo(); to != nil {
|
|
filter.To = to.AsTime()
|
|
}
|
|
return filter
|
|
}
|
|
|
|
func auditFilterProto(f audit.Filter) *pb.AuditFilter {
|
|
out := &pb.AuditFilter{
|
|
Categories: f.Categories,
|
|
Actions: f.Actions,
|
|
Kinds: f.Kinds,
|
|
Actor: f.Actor,
|
|
TargetKinds: f.TargetKinds,
|
|
TargetIds: f.TargetIDs,
|
|
Severities: f.Severities,
|
|
Outcomes: f.Outcomes,
|
|
Q: f.Query,
|
|
}
|
|
if !f.From.IsZero() {
|
|
out.From = timestamp(f.From)
|
|
}
|
|
if !f.To.IsZero() {
|
|
out.To = timestamp(f.To)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func auditEntryProto(e audit.Entry) *pb.AuditEntry {
|
|
fields := make([]*pb.AuditField, len(e.Fields))
|
|
for i, field := range e.Fields {
|
|
fields[i] = &pb.AuditField{
|
|
Field: field.Name,
|
|
OldValueJson: string(field.Old),
|
|
NewValueJson: string(field.New),
|
|
}
|
|
}
|
|
return &pb.AuditEntry{
|
|
Id: e.ID(),
|
|
Category: string(e.Category),
|
|
At: timestamp(e.At),
|
|
Actor: e.Actor,
|
|
ActorKind: e.ActorKind,
|
|
PrincipalId: e.PrincipalID,
|
|
TargetKind: e.TargetKind,
|
|
TargetId: e.TargetID,
|
|
Kind: e.Kind,
|
|
RecordVersion: e.RecordVersion,
|
|
RequestId: e.RequestID,
|
|
Source: e.Source,
|
|
Fields: fields,
|
|
Action: e.Action,
|
|
Severity: string(e.Severity),
|
|
Outcome: string(e.Outcome),
|
|
Detail: e.Detail,
|
|
WorkspaceId: e.WorkspaceID,
|
|
TaskId: e.TaskID,
|
|
DataJson: string(e.Data),
|
|
}
|
|
}
|
|
|
|
func auditEntryValue(e *pb.AuditEntry) audit.Entry {
|
|
fields := make([]audit.Field, len(e.GetFields()))
|
|
for i, field := range e.GetFields() {
|
|
fields[i] = audit.Field{
|
|
Name: field.GetField(),
|
|
Old: []byte(field.GetOldValueJson()),
|
|
New: []byte(field.GetNewValueJson()),
|
|
}
|
|
}
|
|
entry := audit.Entry{
|
|
Category: audit.Category(e.GetCategory()),
|
|
At: timeValue(e.GetAt()),
|
|
Actor: e.GetActor(),
|
|
ActorKind: e.GetActorKind(),
|
|
PrincipalID: e.GetPrincipalId(),
|
|
TargetKind: e.GetTargetKind(),
|
|
TargetID: e.GetTargetId(),
|
|
Kind: e.GetKind(),
|
|
RecordVersion: e.GetRecordVersion(),
|
|
RequestID: e.GetRequestId(),
|
|
Source: e.GetSource(),
|
|
Fields: fields,
|
|
Action: e.GetAction(),
|
|
Severity: audit.Severity(e.GetSeverity()),
|
|
Outcome: audit.Outcome(e.GetOutcome()),
|
|
Detail: e.GetDetail(),
|
|
WorkspaceID: e.GetWorkspaceId(),
|
|
TaskID: e.GetTaskId(),
|
|
}
|
|
if data := e.GetDataJson(); data != "" {
|
|
entry.Data = []byte(data)
|
|
}
|
|
entry.Rank, entry.SourceID = auditRankAndID(e.GetId())
|
|
return entry
|
|
}
|
|
|
|
// auditRankAndID restores the feed position a remote entry was read at, so
|
|
// the entry's stable id survives the wire unchanged.
|
|
func auditRankAndID(id string) (int, int64) {
|
|
rankText, idText, ok := strings.Cut(id, ":")
|
|
if !ok {
|
|
return 0, 0
|
|
}
|
|
rank, err := strconv.Atoi(rankText)
|
|
if err != nil {
|
|
return 0, 0
|
|
}
|
|
sourceID, err := strconv.ParseInt(idText, 10, 64)
|
|
if err != nil {
|
|
return 0, 0
|
|
}
|
|
return rank, sourceID
|
|
}
|
|
|
|
func (s *auditServer) ListAudit(ctx context.Context, request *pb.ListAuditRequest) (*pb.ListAuditResponse, error) {
|
|
if s.deps.Audit == nil {
|
|
return nil, errAuditUnavailable
|
|
}
|
|
filter := auditFilterValue(request.GetFilter())
|
|
if err := filter.Normalize(); err != nil {
|
|
return nil, validationFailure(err)
|
|
}
|
|
cursor := audit.Cursor{}
|
|
if raw := strings.TrimSpace(request.GetCursor()); raw != "" {
|
|
// A malformed cursor means newest; a well-formed one reused with
|
|
// other filters is refused rather than resuming somewhere else.
|
|
if parsed, ok := audit.ParseCursor(raw); ok {
|
|
if !parsed.MatchesFilter(filter) {
|
|
return nil, status.Error(codes.InvalidArgument, "cursor does not match the requested filter")
|
|
}
|
|
cursor = parsed
|
|
}
|
|
}
|
|
page, err := s.deps.Audit.ListAudit(withInstanceAdmin(ctx), filter, cursor, int(request.GetLimit()))
|
|
if err != nil {
|
|
return nil, s.logErr("ListAudit", err)
|
|
}
|
|
entries := make([]*pb.AuditEntry, len(page.Entries))
|
|
for i := range page.Entries {
|
|
entries[i] = auditEntryProto(page.Entries[i])
|
|
}
|
|
return &pb.ListAuditResponse{
|
|
Entries: entries,
|
|
NextCursor: page.NextCursor,
|
|
HasMore: page.HasMore,
|
|
}, nil
|
|
}
|
|
|
|
func (s *auditServer) GetAuditHead(ctx context.Context, _ *pb.GetAuditHeadRequest) (*pb.GetAuditHeadResponse, error) {
|
|
if s.deps.Audit == nil {
|
|
return nil, errAuditUnavailable
|
|
}
|
|
token, err := s.deps.Audit.AuditHead(withInstanceAdmin(ctx))
|
|
if err != nil {
|
|
return nil, s.logErr("GetAuditHead", err)
|
|
}
|
|
return &pb.GetAuditHeadResponse{Token: token}, nil
|
|
}
|
|
|
|
func (s *auditServer) CountAudit(ctx context.Context, request *pb.CountAuditRequest) (*pb.CountAuditResponse, error) {
|
|
if s.deps.Audit == nil {
|
|
return nil, errAuditUnavailable
|
|
}
|
|
filter := auditFilterValue(request.GetFilter())
|
|
if err := filter.Normalize(); err != nil {
|
|
return nil, validationFailure(err)
|
|
}
|
|
count, err := s.deps.Audit.CountAudit(withInstanceAdmin(ctx), filter)
|
|
if err != nil {
|
|
return nil, s.logErr("CountAudit", err)
|
|
}
|
|
return &pb.CountAuditResponse{Count: count}, nil
|
|
}
|
|
|
|
func (s *auditServer) RecordAuditExport(ctx context.Context, request *pb.RecordAuditExportRequest) (*pb.RecordAuditExportResponse, error) {
|
|
if s.deps.Audit == nil {
|
|
return nil, errAuditUnavailable
|
|
}
|
|
if err := s.deps.Audit.RecordAuditExport(ctx, request.GetFormat(), request.GetFiltersHash(), request.GetRows()); err != nil {
|
|
return nil, s.logErr("RecordAuditExport", err)
|
|
}
|
|
return &pb.RecordAuditExportResponse{}, nil
|
|
}
|