766a6c482f
PR 1-5 of the multi-tenant RBAC series enforce the role matrix; what they don't do is keep a durable record of who did what. Today the RBAC middleware logs "[rbac] role insufficient ..." to stderr - perishable, not searchable. Operators cannot answer "who removed Alice from tenant T-foo on Tuesday" or "did we 403 a probing user 200 times last hour" after the fact. This PR adds a generic per-tenant audit log that: - Captures mutating RBAC actions (member add/remove/role-change/leave) durably from the tenant_member service after the repo write succeeds. - Captures enforcement rejections (RequireRole / RequireOwnershipOrRole denies under EnableRBAC=true) via a gin-context-injected hook. - Sliding-window dedup (1 minute) on (tenant, actor, action, path) for denied events so a probing client cannot flood audit_logs. - Default-on - no extra env flag. Schema is generic enough for future KB / agent / datasource events to reuse via new action namespaces without another migration. Schema (migration 000044) mirrors wiki_log_entries' shape: a single audit_logs table with action, target_type/id, request path/method, outcome, and a JSONB details column. Three indexes: (tenant_id, id DESC) for the per-tenant cursor feed, actor_user_id for "what did Alice do", (tenant_id, action) for both the action filter and the dedup lookup. Sqlite mirror added for Lite mode. Wiring is nil-safe: the audit field on tenantMemberService and the gin-context lookup in rbac.go both tolerate a nil service so existing tests construct without a stub and dormant deployments degrade gracefully if the provider is misconfigured. The query API is GET /tenants/:id/audit-log, gated by Admin+ on top of the existing PathTenantMatch (denial histories should not surface to ordinary members). Cursor-paginated by descending id (sidesteps the duplicate-timestamp tie-breaking that BIGSERIAL trivially solves). Frontend: TenantMembers.vue gets a t-tabs wrapper with Members (existing) and Audit log (new) tabs; the audit tab is gated to Admin+ to mirror the server, lazy-loads on first open, paginates via the next_cursor pattern, and renders coloured chips per action/outcome so an operator can scan for anomalies. i18n keys added in all four locales. Tests: 14 new tests across service (6), middleware (4), and handler (4). Service tests pin the dedup window behaviour (writes again after expiry, dedup is per-actor-per-path, degrades on lookup error). Middleware tests pin both reject sites' audit hook and the "dormant mode does not fire" + "nil audit does not panic" invariants. Handler tests pin the cursor envelope and that an empty page returns next_cursor=0. Out of scope: per-action ACL on the audit log, retention/TTL job, KB/agent/datasource event wiring (schema supports it - just no emitters yet), async writes, frontend filter UI.
138 lines
4.5 KiB
Go
138 lines
4.5 KiB
Go
package middleware
|
|
|
|
import (
|
|
"context"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"sync"
|
|
"testing"
|
|
|
|
"github.com/Tencent/WeKnora/internal/types"
|
|
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
// PR 6 (#1303): the rbac middleware's two reject paths now call
|
|
// AuditServiceFromContext(c).LogDenied so denials are durably
|
|
// recorded. These tests pin that wiring — without them, a future
|
|
// refactor that drops the AuditServiceProvider middleware (or breaks
|
|
// the context-stash key) would silently lose the durable audit
|
|
// without any coverage signal.
|
|
|
|
// stubDenyAudit captures LogDenied calls. Embeds the interface so any
|
|
// other method panics on use — keeps tests honest about which API
|
|
// they're exercising.
|
|
type stubDenyAudit struct {
|
|
interfaces.AuditLogService
|
|
mu sync.Mutex
|
|
calls []denyCall
|
|
}
|
|
|
|
type denyCall struct {
|
|
tenantID uint64
|
|
actorUserID string
|
|
actorRole string
|
|
required types.TenantRole
|
|
}
|
|
|
|
func (s *stubDenyAudit) LogDenied(
|
|
_ context.Context,
|
|
_ *gin.Context,
|
|
tenantID uint64,
|
|
actorUserID, actorRole string,
|
|
requiredRole types.TenantRole,
|
|
) error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
s.calls = append(s.calls, denyCall{tenantID, actorUserID, actorRole, requiredRole})
|
|
return nil
|
|
}
|
|
|
|
// auditableHarness mirrors rbacTestHarness but additionally wires
|
|
// AuditServiceProvider with the supplied stub so the rejection
|
|
// paths can exercise the audit hook.
|
|
func auditableHarness(
|
|
t *testing.T, role types.TenantRole, userID string, tenantID uint64,
|
|
audit interfaces.AuditLogService, mw gin.HandlerFunc,
|
|
) *httptest.ResponseRecorder {
|
|
t.Helper()
|
|
gin.SetMode(gin.TestMode)
|
|
r := gin.New()
|
|
r.Use(AuditServiceProvider(audit))
|
|
r.Use(func(c *gin.Context) {
|
|
ctx := context.WithValue(c.Request.Context(), types.TenantRoleContextKey, role)
|
|
ctx = context.WithValue(ctx, types.UserIDContextKey, userID)
|
|
ctx = context.WithValue(ctx, types.TenantIDContextKey, tenantID)
|
|
c.Request = c.Request.WithContext(ctx)
|
|
c.Next()
|
|
})
|
|
r.GET("/protected", mw, func(c *gin.Context) {
|
|
c.JSON(http.StatusOK, gin.H{"ok": true})
|
|
})
|
|
w := httptest.NewRecorder()
|
|
req := httptest.NewRequest(http.MethodGet, "/protected", nil)
|
|
r.ServeHTTP(w, req)
|
|
return w
|
|
}
|
|
|
|
func TestRequireRole_RejectFiresAuditHook(t *testing.T) {
|
|
audit := &stubDenyAudit{}
|
|
w := auditableHarness(t, types.TenantRoleContributor, "u1", 7, audit,
|
|
RequireRole(types.TenantRoleAdmin, cfgRBAC(true)))
|
|
if w.Code != http.StatusForbidden {
|
|
t.Fatalf("expected 403, got %d", w.Code)
|
|
}
|
|
if len(audit.calls) != 1 {
|
|
t.Fatalf("expected exactly one audit hook call, got %d", len(audit.calls))
|
|
}
|
|
got := audit.calls[0]
|
|
if got.tenantID != 7 || got.actorUserID != "u1" ||
|
|
got.actorRole != string(types.TenantRoleContributor) ||
|
|
got.required != types.TenantRoleAdmin {
|
|
t.Fatalf("audit hook payload mismatch: %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestRequireRole_DormantModeDoesNotFireAuditHook(t *testing.T) {
|
|
// EnableRBAC=false: middleware logs but does NOT 403, so the
|
|
// durable audit must NOT fire either — the dormant rollout window
|
|
// would otherwise generate audit noise for non-rejections.
|
|
audit := &stubDenyAudit{}
|
|
w := auditableHarness(t, types.TenantRoleViewer, "u1", 7, audit,
|
|
RequireRole(types.TenantRoleOwner, cfgRBAC(false)))
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200 in dormant mode, got %d", w.Code)
|
|
}
|
|
if len(audit.calls) != 0 {
|
|
t.Fatalf("dormant mode must not fire audit, got %d calls", len(audit.calls))
|
|
}
|
|
}
|
|
|
|
func TestRequireOwnershipOrRole_RejectFiresAuditHook(t *testing.T) {
|
|
// Mirror of TestRequireRole_RejectFiresAuditHook but for the
|
|
// ownership variant — the audit hook lives at a different reject
|
|
// site and must NOT skip the durable write.
|
|
audit := &stubDenyAudit{}
|
|
lookup := func(_ *gin.Context) (string, error) {
|
|
return "someone-else", nil // creator != caller, role too low
|
|
}
|
|
w := auditableHarness(t, types.TenantRoleContributor, "u1", 7, audit,
|
|
RequireOwnershipOrRole(types.TenantRoleAdmin, lookup, cfgRBAC(true)))
|
|
if w.Code != http.StatusForbidden {
|
|
t.Fatalf("expected 403, got %d", w.Code)
|
|
}
|
|
if len(audit.calls) != 1 {
|
|
t.Fatalf("expected exactly one audit hook call, got %d", len(audit.calls))
|
|
}
|
|
}
|
|
|
|
func TestRequireRole_NilAuditServiceDoesNotPanic(t *testing.T) {
|
|
// AuditServiceProvider(nil) is a deliberate no-op; the rbac path
|
|
// must degrade to "log to stderr only" rather than crashing.
|
|
w := auditableHarness(t, types.TenantRoleContributor, "u1", 7, nil,
|
|
RequireRole(types.TenantRoleAdmin, cfgRBAC(true)))
|
|
if w.Code != http.StatusForbidden {
|
|
t.Fatalf("expected 403 even with nil audit service, got %d", w.Code)
|
|
}
|
|
}
|