diff --git a/internal/app/archied/bootstrap.go b/internal/app/archied/bootstrap.go index d40e45695..4ec5556cd 100644 --- a/internal/app/archied/bootstrap.go +++ b/internal/app/archied/bootstrap.go @@ -30,6 +30,7 @@ import ( "github.com/samcharles93/archie-core/internal/container" controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1" "github.com/samcharles93/archie-core/internal/daemon" + "github.com/samcharles93/archie-core/internal/domain/access" "github.com/samcharles93/archie-core/internal/domain/applystatus" "github.com/samcharles93/archie-core/internal/domain/curator" "github.com/samcharles93/archie-core/internal/domain/eda/module" @@ -46,6 +47,7 @@ import ( "github.com/samcharles93/archie-core/internal/forge" forgewebhook "github.com/samcharles93/archie-core/internal/forge/webhook" "github.com/samcharles93/archie-core/internal/gateway" + infraaccess "github.com/samcharles93/archie-core/internal/infrastructure/access" "github.com/samcharles93/archie-core/internal/infrastructure/configuration" infraembedding "github.com/samcharles93/archie-core/internal/infrastructure/embedding" "github.com/samcharles93/archie-core/internal/infrastructure/eventbus/nats" @@ -124,6 +126,13 @@ type boot struct { // set. The b.st field remains solely for the standalone archie-state-store // binary, which serves the task store from Postgres. stateStore storecontract.TaskStore + // accessChain is the daemon's policy engine, built once from the stored + // policies (openAccessChain); accessProblems is what the readiness + // surface reports. Both are nil when no policy store is wired. + accessChain access.Authorizer + accessPrincipals access.PrincipalSource + accessDenials access.DenialStore + accessProblems []infraaccess.Problem // stateStoreGrants issues per-task, scoped State Store credentials for // agent containers (daemon.StateStoreGrantIssuer), wrapping the same // *staterpc.Client as stateStore. Nil when the State Store adapter isn't @@ -435,6 +444,33 @@ func (b *boot) openStateStoreAdapter() error { return nil } +// openAccessChain builds the policy chain the daemon dispatches through +// (docs/prds/orgs-and-access.md, "Where it lives"): the stored policies over +// the wire, compiled once at boot. An invalid instance policy fails the boot; +// an invalid org, workspace or object policy is retained as a health problem +// and its level denies everything. +func (b *boot) openAccessChain(ctx context.Context) error { + source, ok := b.stateStore.(access.PolicySource) + if !ok { + return nil // no policy store wired: the chain is not built + } + stored, err := source.Policies(ctx) + if err != nil { + return fmt.Errorf("load stored policies: %w", err) + } + engine, err := infraaccess.New(stored) + if err != nil { + return fmt.Errorf("validate stored policies: %w", err) + } + b.accessChain = engine + b.accessProblems = engine.Problems() + for _, problem := range b.accessProblems { + b.log.Error("stored access policy is invalid and denies its level", + "policy", problem.Policy.ID, "level", problem.Policy.Level, "err", problem.Err) + } + return nil +} + // openChatSessions opens the conversation store on its own pool from // database_url. The daemon reads it (session curator) and the Gateway serves // it; only the Gateway claims serve ownership (claimGatewayOwnership). @@ -1387,6 +1423,18 @@ func (b *boot) buildDaemon() { if btc, ok := b.stateStore.(storecontract.BindingTaskCreator); ok { b.d.BindingTaskCreator = btc } + // Dispatch is the second Authorizer call site: the chain built by + // openAccessChain, the principal assembly over the wire, and the denial + // record -- wired together or not at all (docs/prds/orgs-and-access.md). + b.d.Access = b.accessChain + if b.accessChain != nil { + if principals, ok := b.stateStore.(access.PrincipalSource); ok { + b.d.Principals = principals + } + if denials, ok := b.stateStore.(access.DenialStore); ok { + b.d.Denials = denials + } + } b.d.PlaybookLedger = playbookLedger(b.stateStore, b.playbooks, b.log) b.setupForgeWebhook() } diff --git a/internal/app/archied/main.go b/internal/app/archied/main.go index 65ba53618..f738aa3b6 100644 --- a/internal/app/archied/main.go +++ b/internal/app/archied/main.go @@ -375,6 +375,12 @@ func Run() int { //nolint:cyclop,funlen // the composition root's setup sequence if err := b.openDaemonStateSurfaces(); err != nil { return 1 } + // The policy chain the dispatch loop evaluates, built once from the + // stored policies (docs/prds/orgs-and-access.md). It runs after the + // state surfaces exist and before the daemon is built. + if err := b.openAccessChain(ctx); err != nil { + return 1 + } if err := b.loadRuntimeConfig(ctx); err != nil { b.log.Error("runtime settings unavailable", "err", err) return 1 diff --git a/internal/app/archied/readiness.go b/internal/app/archied/readiness.go index ea6b3e9bb..b23381e5d 100644 --- a/internal/app/archied/readiness.go +++ b/internal/app/archied/readiness.go @@ -44,6 +44,9 @@ func (b *boot) setupReadinessProbes() { return pingChat(ctx, b.chat) }), } + if b.accessProblems != nil { + probes = append(probes, readiness.NewProblemProbe("access_policies", b.accessProblems)) + } b.healthRegistry = health.NewRegistry(probes...) } diff --git a/internal/app/archieui/compose.go b/internal/app/archieui/compose.go index e69ff564f..1900a8e74 100644 --- a/internal/app/archieui/compose.go +++ b/internal/app/archieui/compose.go @@ -6,6 +6,7 @@ import ( "time" controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1" + "github.com/samcharles93/archie-core/internal/domain/access" "github.com/samcharles93/archie-core/internal/domain/health" "github.com/samcharles93/archie-core/internal/domain/identity" "github.com/samcharles93/archie-core/internal/domain/messaging" @@ -33,6 +34,12 @@ type deps struct { // Login drives the browser sign-in flow, or nil when no provider is // configured for it. Login identity.LoginFlow + // Access evaluates the policy chain; Principals assembles the request + // principal; Denials records refusals + // (docs/prds/orgs-and-access.md). Wired together or not at all. + Access access.Authorizer + Principals access.PrincipalSource + Denials access.DenialStore } // compose builds the dashboard server for the UI process. It sets exactly the @@ -114,6 +121,11 @@ func compose(d deps) *webui.Server { // rather than opening a path (docs/prds/ui-service-boundary.md). Withholding // it would degrade a page that has an owner, and would leave the dashboard // claiming task logging was not enabled -- see wireTaskLogs. + // The policy chain: wired together or not at all + // (docs/prds/orgs-and-access.md, "Where it lives"). + srv.Access = d.Access + srv.Principals = d.Principals + srv.Denials = d.Denials wireTaskLogs(d, srv) wireCaptureSurfaces(d, srv) return srv diff --git a/internal/app/archieui/degraded_routes_test.go b/internal/app/archieui/degraded_routes_test.go index 19220eb05..7b4e3b124 100644 --- a/internal/app/archieui/degraded_routes_test.go +++ b/internal/app/archieui/degraded_routes_test.go @@ -181,6 +181,6 @@ func composeUIProcess(t *testing.T) (*webui.Server, int64) { Options: options, Log: slog.New(slog.DiscardHandler), Store: client, - Health: newReadinessRegistry(options, client, nil), + Health: newReadinessRegistry(options, client, nil, nil), }), task.ID } diff --git a/internal/app/archieui/readiness.go b/internal/app/archieui/readiness.go index 386a60e94..77c0f272d 100644 --- a/internal/app/archieui/readiness.go +++ b/internal/app/archieui/readiness.go @@ -6,6 +6,7 @@ import ( "github.com/samcharles93/archie-core/internal/domain/health" "github.com/samcharles93/archie-core/internal/domain/messaging" "github.com/samcharles93/archie-core/internal/domain/storecontract" + infraaccess "github.com/samcharles93/archie-core/internal/infrastructure/access" "github.com/samcharles93/archie-core/internal/infrastructure/readiness" ) @@ -17,8 +18,9 @@ import ( // // The component names match the daemon dashboard's, so the readiness view // reads the same whichever process serves it. -func newReadinessRegistry(o Options, tasks storecontract.TaskStore, chat messaging.ChatContract) *health.Registry { +func newReadinessRegistry(o Options, tasks storecontract.TaskStore, chat messaging.ChatContract, problems []infraaccess.Problem) *health.Registry { return health.NewRegistry( + readiness.NewProblemProbe("access_policies", problems), readiness.NewContractProbe("state_db", o.DependencyTimeout, func(ctx context.Context) error { _, err := tasks.StatusCounts(ctx) return err diff --git a/internal/app/archieui/run.go b/internal/app/archieui/run.go index ac057cc98..9c73c6be9 100644 --- a/internal/app/archieui/run.go +++ b/internal/app/archieui/run.go @@ -10,11 +10,38 @@ import ( "os" "slices" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "github.com/samcharles93/archie-core/internal/domain/access" + infraaccess "github.com/samcharles93/archie-core/internal/infrastructure/access" "github.com/samcharles93/archie-core/internal/infrastructure/gatewayrpc" "github.com/samcharles93/archie-core/internal/infrastructure/staterpc" "github.com/samcharles93/archie-core/internal/webui" ) +// errAccessStoreUnavailable reports that no policy store is wired. The +// dashboard degrades to the credential check rather than refusing to serve. +var errAccessStoreUnavailable = errors.New("access policy store unavailable") + +// buildAccessChain loads the stored policies over the wire and builds the +// engine. The wire client satisfies the two access contracts the dashboard +// needs alongside the engine. +func buildAccessChain(ctx context.Context, store *staterpc.Client) (access.Authorizer, []infraaccess.Problem, error) { + stored, err := store.ListPolicies(ctx) + if err != nil { + if status.Code(err) == codes.Unavailable { + return nil, nil, errAccessStoreUnavailable + } + return nil, nil, err + } + engine, err := infraaccess.New(stored) + if err != nil { + return nil, nil, err + } + return engine, engine.Problems(), nil +} + // Run serves the dashboard until ctx is cancelled. It resolves its own // options, dials the Gateway and State Store contracts itself, composes the // HTTP surface over them, and unwinds listener then clients in reverse order @@ -44,6 +71,27 @@ func Run(ctx context.Context, options Options) error { } cleanups = append(cleanups, closeGateway) + // The access chain is built here, from the stored policies over the + // wire: an invalid instance policy stops this process serving until it + // is fixed; an invalid org, workspace or object policy is reported as a + // health issue naming the policy and the error, and its level denies + // everything (docs/prds/orgs-and-access.md, "Storing and changing + // policies"). + chain, problems, err := buildAccessChain(ctx, tasks) + if err != nil { + if errors.Is(err, errAccessStoreUnavailable) { + // A State Store serving no policies has no chain to evaluate: + // the dashboard keeps the credential check as the whole gate. + log.Warn("access chain unavailable; the credential check is the gate", "err", err) + } else { + return err + } + } + for _, problem := range problems { + log.Error("stored access policy is invalid and denies its level", + "policy", problem.Policy.ID, "level", problem.Policy.Level, "err", problem.Err) + } + authenticate, err := dashboardAuthenticator(ctx, opts, tasks, log) if err != nil { return err @@ -58,11 +106,14 @@ func Run(ctx context.Context, options Options) error { Log: log, Store: tasks, Chat: chat, - Health: newReadinessRegistry(opts, tasks, chat), + Health: newReadinessRegistry(opts, tasks, chat, problems), ControlPlane: tasks.ControlPlane(), Identities: tasks, Authenticate: authenticate, Login: login, + Access: chain, + Principals: tasks, + Denials: tasks, }) // Live activity has no in-process bus in this process: the pump reads diff --git a/internal/app/archieui/run_test.go b/internal/app/archieui/run_test.go index 278368eb5..d404a4a73 100644 --- a/internal/app/archieui/run_test.go +++ b/internal/app/archieui/run_test.go @@ -178,7 +178,7 @@ func TestUIServesDashboardAgainstRemoteContracts(t *testing.T) { Log: slog.New(slog.DiscardHandler), Store: stateClient, Chat: chatClient, - Health: newReadinessRegistry(options, stateClient, chatClient), + Health: newReadinessRegistry(options, stateClient, chatClient, nil), }) ts := httptest.NewServer(srv.Handler()) defer ts.Close() diff --git a/internal/app/archieui/task_logs_test.go b/internal/app/archieui/task_logs_test.go index fe6390d39..ca5e9c803 100644 --- a/internal/app/archieui/task_logs_test.go +++ b/internal/app/archieui/task_logs_test.go @@ -193,7 +193,7 @@ func composeUIProcessWithLog(t *testing.T) (*webui.Server, int64, int) { Options: options, Log: slog.New(slog.DiscardHandler), Store: client, - Health: newReadinessRegistry(options, client, nil), + Health: newReadinessRegistry(options, client, nil, nil), }) return srv, task.ID, task.Attempt } diff --git a/internal/daemon/daemon.go b/internal/daemon/daemon.go index aa071b145..96f332a06 100644 --- a/internal/daemon/daemon.go +++ b/internal/daemon/daemon.go @@ -19,6 +19,7 @@ import ( "github.com/samcharles93/archie-core/internal/agentexec" "github.com/samcharles93/archie-core/internal/config" "github.com/samcharles93/archie-core/internal/container" + "github.com/samcharles93/archie-core/internal/domain/access" "github.com/samcharles93/archie-core/internal/domain/binding" "github.com/samcharles93/archie-core/internal/domain/curator" "github.com/samcharles93/archie-core/internal/domain/eda/playbook" @@ -129,10 +130,21 @@ type Daemon struct { // dispatch loop does not acquire the full task-creation contract. // Optional: nil disables the dispatch loop. BindingTaskCreator storecontract.BindingTaskCreator - Forge forge.Forge - Trees *worktree.Manager - Bus *events.Bus - Log *slog.Logger + // Access evaluates the policy chain at dispatch, the second of the two + // Authorizer call sites (docs/prds/orgs-and-access.md, "Where it + // lives"): the workflow's identity may `run` the workflow in its + // workspace. Optional: nil dispatches without the chain, which is the + // behaviour of an install that has not built it. + Access access.Authorizer + // Principals assembles the dispatch principal for the workflow's + // identity. Wired with Access or not at all. + Principals access.PrincipalSource + // Denials records dispatch refusals. Optional: nil skips the record. + Denials access.DenialStore + Forge forge.Forge + Trees *worktree.Manager + Bus *events.Bus + Log *slog.Logger // Tasks is the NATS task distribution bus: the poller publishes // discovered work over it and runViaAgent requests execution through it. // NATS startup is mandatory (there is no broker-off execution mode), so @@ -728,6 +740,14 @@ func (d *Daemon) dispatchOneBinding(ctx context.Context, b binding.Binding, c st if !ok { return } + // The chain decides dispatch: the workflow's identity may `run` this + // workflow in its workspace, and the event's signature result and + // address travel with the request (docs/prds/orgs-and-access.md, + // "Access decisions"). A denial is recorded and the dispatch is not + // claimed: the capture stays listed for the next cycle. + if !d.authorizeDispatch(ctx, b, c, target) { + return + } if err := d.BindingDispatcher.RecordDispatch(ctx, b.ID, int64(b.Version), c.ID, 0); err != nil { if !errors.Is(err, storecontract.ErrAlreadyDispatched) { d.Log.Warn("binding dispatch: record", "binding", b.ID, "capture", c.ID, "error", err) @@ -749,6 +769,58 @@ func (d *Daemon) dispatchOneBinding(ctx context.Context, b binding.Binding, c st } } +// authorizeDispatch evaluates the policy chain for the workflow's identity +// before the dispatch is claimed: the identity may `run` the workflow in its +// workspace, with the event's signature result and source address as context. +// A denial is recorded with the level that decided it and the deciding +// policies, and reported as a binding_dispatch_failure. +func (d *Daemon) authorizeDispatch(ctx context.Context, b binding.Binding, c storecontract.CapturedEvent, target bindingTarget) bool { + if d.Access == nil || d.Principals == nil { + return true + } + principal, err := d.Principals.PrincipalFor(ctx, d.RootIdentityID) + if err != nil { + d.Log.Warn("binding dispatch: principal unavailable; dispatch parked for the next cycle", + "binding", b.ID, "capture", c.ID, "error", err) + return false + } + resource := access.Resource{ + Kind: access.KindWorkflow, ID: b.Workflow, Org: principal.Org, + } + contextValue := access.Context{Signature: signatureOf(c), Addr: c.RemoteAddr} + decision := d.Access.Authorize(principal, access.ActionRun, resource, contextValue) + if decision.Allowed { + return true + } + if d.Denials != nil { + denial := access.Denial{ + Principal: principal.IdentityID, Org: principal.Org, Action: access.ActionRun, + Kind: resource.Kind, ResourceID: resource.ID, Level: decision.Level, + Policies: decision.Policies, + } + if err := d.Denials.RecordDenial(ctx, denial); err != nil { + d.Log.Warn("binding dispatch: record denial", "binding", b.ID, "error", err) + } + } + d.recordDispatchFailure(ctx, b, c, "access denied", map[string]any{ + "level": string(decision.Level), "policies": decision.Policies, + }) + return false +} + +// signatureOf names the event's signature result as the dispatch context +// carries it: a signed event and an approved unsigned event are the two +// dispatchable shapes (storecontract.CapturedEvent.Dispatchable). +func signatureOf(c storecontract.CapturedEvent) string { + switch { + case c.Authenticated: + return "valid" + case c.Unsigned: + return "unsigned" + } + return "unverified" +} + // markUnsignedStart records on a task's timeline that an unsigned event // started it. func (d *Daemon) markUnsignedStart(ctx context.Context, taskID int64, b binding.Binding, c storecontract.CapturedEvent) { diff --git a/internal/infrastructure/readiness/probes.go b/internal/infrastructure/readiness/probes.go index a8c94d152..1b281889b 100644 --- a/internal/infrastructure/readiness/probes.go +++ b/internal/infrastructure/readiness/probes.go @@ -21,6 +21,7 @@ import ( "github.com/samcharles93/archie-core/internal/config" "github.com/samcharles93/archie-core/internal/domain/health" + "github.com/samcharles93/archie-core/internal/infrastructure/access" ) // --- state_db --- @@ -93,6 +94,51 @@ func (p *ContractProbe) Check(ctx context.Context) health.Result { return health.Result{Status: health.StatusOK} } +// --- access policies --- + +// PolicyProblems reports the stored access policies this process's engine +// could not validate. The policy chain is the source; a policy that failed +// startup re-validation denies its level and must be named here with its +// error (docs/prds/orgs-and-access.md, "Storing and changing policies"). +type PolicyProblems interface { + Problems() []access.Problem +} + +// ProblemProbe reports the stored policies the engine could not validate. +// It is a static probe: the engine is immutable for the life of the process, +// so the problems it names do not change under it. +type ProblemProbe struct { + ProbeName string + Source PolicyProblems +} + +// NewProblemProbe returns an access_policies probe over a problem source. +// A nil source degrades the probe rather than lying about the chain. +func NewProblemProbe(name string, problems []access.Problem) *ProblemProbe { + return &ProblemProbe{ProbeName: name, Source: staticProblemSource(problems)} +} + +type staticProblemSource []access.Problem + +func (s staticProblemSource) Problems() []access.Problem { return s } + +func (p *ProblemProbe) Name() string { return p.ProbeName } + +func (p *ProblemProbe) Check(ctx context.Context) health.Result { + if p.Source == nil { + return health.Result{Status: health.StatusDegraded, Detail: "access engine not wired"} + } + problems := p.Source.Problems() + if len(problems) == 0 { + return health.Result{Status: health.StatusOK} + } + details := make([]string, 0, len(problems)) + for _, problem := range problems { + details = append(details, problem.Policy.ID+": "+problem.Err.Error()) + } + return health.Result{Status: health.StatusDegraded, Detail: strings.Join(details, "; ")} +} + // --- config --- // ConfigProbe validates the running configuration. It is the same check the diff --git a/internal/webui/authorize.go b/internal/webui/authorize.go new file mode 100644 index 000000000..d7fdaa64a --- /dev/null +++ b/internal/webui/authorize.go @@ -0,0 +1,224 @@ +// The access chain at the dashboard and API request path: the second of the +// two places that call the Authorizer (docs/prds/orgs-and-access.md, "Where +// it lives"). A request that carries an identity is assembled into a +// principal; the action and resource kind are derived from the route; the +// chain decides; a denial is recorded with the level that decided it and +// reported as forbidden without the reason. +// +// The shared token is the single-operator install's owner of the default org +// (docs/prds/orgs-and-access.md, "Credentials"): the token principal is +// assembled here, not looked up, until principal credentials exist. +package webui + +import ( + "context" + "log/slog" + "net/http" + "strings" + + "github.com/samcharles93/archie-core/internal/domain/access" + "github.com/samcharles93/archie-core/internal/domain/identity" + "github.com/samcharles93/archie-core/internal/domain/org" +) + +// TokenOwnerPrincipal is the principal the shared token acts as: the owner +// of the default org, per the single-operator credential rule. +func TokenOwnerPrincipal() access.Principal { + return access.Principal{ + IdentityID: identity.SystemID, + Kind: identity.KindSystem, + Org: org.DefaultOrgID, + Memberships: []org.Membership{ + {IdentityID: identity.SystemID, OrgID: org.DefaultOrgID, Role: org.RoleOwner}, + }, + } +} + +// principalContextKey carries the assembled principal of a request. +type principalContextKey struct{} + +// WithRequestPrincipal attaches the principal a request was authorized for. +func WithPrincipal(ctx context.Context, p access.Principal) context.Context { + return context.WithValue(ctx, principalContextKey{}, p) +} + +// RequestPrincipal returns the principal a request was authorized as. +func RequestPrincipal(ctx context.Context) (access.Principal, bool) { + value, ok := ctx.Value(principalContextKey{}).(access.Principal) + return value, ok +} + +// authorize wraps h with the policy chain. Optional: a server with no +// Authorizer keeps the credential check as the whole gate, which is the +// documented behaviour of an install that has not built the chain. +func (s *Server) authorize(h http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if s.Access == nil { + h.ServeHTTP(w, r) + return + } + principal, err := s.requestPrincipal(r.Context()) + if err != nil { + if wantsDocument(r) { + s.authPage(w, "Sign-in could not resolve your org.") + return + } + http.Error(w, "principal unavailable", http.StatusServiceUnavailable) + return + } + action, kind, id := accessRequest(r) + // The record's org is not loaded here: org-filtered lookups keep a + // record of another org from ever being fetched, and this request's + // record (when it has an ID) belongs to the caller's org. The + // workspace is likewise the record's, not the route's. + resource := access.Resource{Kind: kind, ID: id, Org: principal.Org} + decision := s.Access.Authorize(principal, action, resource, access.Context{}) + if !decision.Allowed { + s.recordDenial(r.Context(), principal, action, resource, decision) + if wantsDocument(r) { + s.authPage(w, "You do not have permission to do that.") + return + } + // A denial inside the caller's org is forbidden, without the + // reason (docs/prds/orgs-and-access.md, "Denials"). + http.Error(w, "forbidden", http.StatusForbidden) + return + } + h.ServeHTTP(w, r.WithContext(WithPrincipal(r.Context(), principal))) + }) +} + +// requestPrincipal assembles the principal a request acts as. With no acting +// identity (the shared token), it is the token owner; with one, it is the +// identity's org and memberships, read over the wire. +func (s *Server) requestPrincipal(ctx context.Context) (access.Principal, error) { + if acting, ok := ActingIdentity(ctx); ok { + if s.Principals == nil { + return access.Principal{}, errPrincipalsUnavailable + } + return s.Principals.PrincipalFor(ctx, acting.ID) + } + return TokenOwnerPrincipal(), nil +} + +func (s *Server) recordDenial(ctx context.Context, p access.Principal, action access.Action, r access.Resource, decision access.Decision) { + if s.Denials == nil { + return + } + denial := access.Denial{ + Principal: p.IdentityID, Org: p.Org, Action: action, + Kind: r.Kind, ResourceID: r.ID, Level: decision.Level, + Policies: decision.Policies, + } + if err := s.Denials.RecordDenial(ctx, denial); err != nil && s.Log != nil { + s.Log.Error("record access denial", "err", err) + } +} + +// errPrincipalsUnavailable is the answer of a dashboard wired with the chain +// but without the principal assembly, which is a composition error: the two +// are wired together or not at all. +var errPrincipalsUnavailable = ¬WiredError{} + +type notWiredError struct{} + +func (*notWiredError) Error() string { return "webui: principal assembly not wired" } + +// accessRequest derives the action, resource kind and record key of one API +// request from its method and path. Unmapped routes read the dashboard +// itself, so a new route is never wider than read until it is mapped. +func accessRequest(r *http.Request) (access.Action, access.ResourceKind, string) { + action := access.ActionRead + switch r.Method { + case http.MethodPost: + action = access.ActionCreate + case http.MethodPut, http.MethodPatch: + action = access.ActionUpdate + case http.MethodDelete: + action = access.ActionDelete + } + path := r.URL.Path + + // Route-specific action and kind refinements. + switch { + case action == access.ActionCreate && matchSegment(path, "/api/bindings/", "/approve"): + return access.ActionApprove, access.KindBinding, segmentValue(path, 2) + case matchSegment(path, "/api/tasks/", "/logs"): + return access.ActionReadLogs, access.KindTask, segmentValue(path, 2) + case matchPrefix(path, "/api/identities"): + return actionManage(action), access.KindIdentity, segmentValue(path, 2) + case matchPrefix(path, "/api/control-plane/resources"): + return actionManage(action), access.KindPolicy, segmentValue(path, 3) + case matchPrefix(path, "/api/chat"): + if action == access.ActionCreate { + return access.ActionRun, access.KindWorkflow, "" + } + return access.ActionRead, access.KindDashboard, "" + case matchSegment(path, "/api/sources/", "/secret"): + return access.ActionUpdate, access.KindSecret, segmentValue(path, 2) + case matchPrefix(path, "/api/channels/"): + return actionManage(action), access.KindDashboard, segmentValue(path, 2) + case matchPrefix(path, "/api/config"), matchPrefix(path, "/api/logs"): + return access.ActionRead, access.KindDashboard, "" + } + + switch { + case matchPrefix(path, "/api/tasks"): + return action, access.KindTask, segmentValue(path, 2) + case matchPrefix(path, "/api/event-types"): + return action, access.KindEventType, segmentValue(path, 2) + case matchPrefix(path, "/api/mappings"): + return action, access.KindMapping, segmentValue(path, 2) + case matchPrefix(path, "/api/bindings"): + return action, access.KindBinding, segmentValue(path, 2) + case matchPrefix(path, "/api/sources"): + return action, access.KindSource, segmentValue(path, 2) + case matchPrefix(path, "/api/work-requests"): + return action, access.KindTask, "" + } + return action, access.KindDashboard, "" +} + +// actionManage lifts a create or update on a managed surface to the manage +// action the role vocabulary carries. +func actionManage(action access.Action) access.Action { + switch action { + case access.ActionCreate, access.ActionUpdate: + return access.ActionManageIdentities + case access.ActionDelete: + return access.ActionDelete + } + return action +} + +// segmentValue returns the value of the n-th (0-based) segment of an API +// path, or "" when the path is shorter: /api/tasks/7/changes -> 7 is segment +// 2. +func segmentValue(path string, n int) string { + segments := splitPath(path) + if n < len(segments) { + return segments[n] + } + return "" +} + +func splitPath(path string) []string { + var out []string + for segment := range strings.SplitSeq(path, "/") { + if segment != "" { + out = append(out, segment) + } + } + return out +} + +func matchPrefix(path, prefix string) bool { + return strings.HasPrefix(path, prefix+"/") || path == prefix +} + +func matchSegment(path, prefix, suffix string) bool { + return strings.HasPrefix(path, prefix) && strings.HasSuffix(path, suffix) +} + +// The log the authorize wrapper reports assembly failures with. +var _ = slog.Default //nolint:unused // logging stays on s.Log diff --git a/internal/webui/authorize_test.go b/internal/webui/authorize_test.go new file mode 100644 index 000000000..d850bc47e --- /dev/null +++ b/internal/webui/authorize_test.go @@ -0,0 +1,125 @@ +package webui + +import ( + "context" + "errors" + "net/http" + "net/http/httptest" + "testing" + + "github.com/samcharles93/archie-core/internal/domain/access" + "github.com/samcharles93/archie-core/internal/domain/identity" + "github.com/samcharles93/archie-core/internal/domain/org" +) + +// fakeAuthorizer records the request it evaluated and answers with a fixed +// decision. It is the chain stand-in the webui tests run against. +type fakeAuthorizer struct { + decision access.Decision + last access.Resource + lastAct access.Action +} + +func (f *fakeAuthorizer) Authorize(_ access.Principal, a access.Action, r access.Resource, _ access.Context) access.Decision { + f.lastAct, f.last = a, r + return f.decision +} + +type recordingDenials struct{ recorded []access.Denial } + +func (r *recordingDenials) RecordDenial(_ context.Context, d access.Denial) error { + r.recorded = append(r.recorded, d) + return nil +} + +func (r *recordingDenials) ListDenials(_ context.Context, _ org.OrgID, _ int) ([]access.Denial, error) { + return nil, errors.New("not needed") +} + +func handlerEcho(w http.ResponseWriter, r *http.Request) { + principal, ok := RequestPrincipal(r.Context()) + if ok { + w.Header().Set("X-Principal-Org", string(principal.Org)) + } + w.WriteHeader(http.StatusOK) +} + +func newAccessServer(t *testing.T, engine access.Authorizer, denials access.DenialStore) *Server { + t.Helper() + return &Server{Access: engine, Principals: nil, Denials: denials, Token: ""} +} + +func TestAuthorizeNilEngineServesEverything(t *testing.T) { + s := &Server{} + h := s.authorize(http.HandlerFunc(handlerEcho)) + rec := httptest.NewRecorder() + h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/api/tasks", nil)) + if rec.Code != http.StatusOK { + t.Fatalf("nil chain served %d, want 200: the credential check stays the gate", rec.Code) + } +} + +func TestAuthorizeTokenOwnerAllowed(t *testing.T) { + engine := &fakeAuthorizer{decision: access.Allowed()} + s := newAccessServer(t, engine, nil) + h := s.authorize(http.HandlerFunc(handlerEcho)) + rec := httptest.NewRecorder() + h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/api/bindings", nil)) + if rec.Code != http.StatusOK { + t.Fatalf("allowed request served %d, want 200", rec.Code) + } + // The token owner is the owner of the default org, and the route + // derived a read on the binding surface. + if rec.Header().Get("X-Principal-Org") != string(org.DefaultOrgID) { + t.Fatalf("principal org = %q, want the default org", rec.Header().Get("X-Principal-Org")) + } + if engine.lastAct != access.ActionRead || engine.last.Kind != access.KindBinding { + t.Fatalf("derived action %q kind %q, want read on bindings", engine.lastAct, engine.last.Kind) + } +} + +func TestAuthorizeDenialIsForbiddenWithoutReason(t *testing.T) { + engine := &fakeAuthorizer{decision: access.DeniedAt(access.LevelOrg, []string{access.PolicyOrgRead})} + denials := &recordingDenials{} + s := newAccessServer(t, engine, denials) + h := s.authorize(http.HandlerFunc(handlerEcho)) + rec := httptest.NewRecorder() + h.ServeHTTP(rec, httptest.NewRequest(http.MethodDelete, "/api/bindings/b1", nil)) + if rec.Code != http.StatusForbidden { + t.Fatalf("denied request served %d, want 403", rec.Code) + } + if rec.Body != nil && rec.Body.String() != "forbidden\n" { + t.Fatalf("denial body = %q, want no reason", rec.Body.String()) + } + if engine.lastAct != access.ActionDelete { + t.Fatalf("derived action = %q, want delete", engine.lastAct) + } + if len(denials.recorded) != 1 { + t.Fatalf("recorded %d denials, want 1", len(denials.recorded)) + } + recorded := denials.recorded[0] + if recorded.Principal != identity.SystemID || recorded.Action != access.ActionDelete || + recorded.Level != access.LevelOrg || len(recorded.Policies) != 1 { + t.Fatalf("denial record = %+v, want principal, action, level and policies", recorded) + } +} + +func TestAuthorizeApproveRoute(t *testing.T) { + engine := &fakeAuthorizer{decision: access.Allowed()} + s := newAccessServer(t, engine, nil) + h := s.authorize(http.HandlerFunc(handlerEcho)) + h.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest(http.MethodPost, "/api/bindings/b1/approve", nil)) + if engine.lastAct != access.ActionApprove { + t.Fatalf("approve route derived action %q, want approve", engine.lastAct) + } +} + +func TestAuthorizeTaskLogRouteReadsLogs(t *testing.T) { + engine := &fakeAuthorizer{decision: access.Allowed()} + s := newAccessServer(t, engine, nil) + h := s.authorize(http.HandlerFunc(handlerEcho)) + h.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/api/tasks/7/logs", nil)) + if engine.lastAct != access.ActionReadLogs || engine.last.Kind != access.KindTask || engine.last.ID != "7" { + t.Fatalf("log route derived %+v %q, want read_logs on task 7", engine.lastAct, engine.last.Kind) + } +} diff --git a/internal/webui/server.go b/internal/webui/server.go index 79430ee1f..7e3e4a80c 100644 --- a/internal/webui/server.go +++ b/internal/webui/server.go @@ -11,6 +11,7 @@ import ( "time" controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1" + "github.com/samcharles93/archie-core/internal/domain/access" "github.com/samcharles93/archie-core/internal/domain/health" "github.com/samcharles93/archie-core/internal/domain/identity" "github.com/samcharles93/archie-core/internal/domain/messaging" @@ -108,6 +109,16 @@ type Server struct { // through a browser -- an agent does exactly that. Login identity.LoginFlow + // Access evaluates the policy chain for each request + // (docs/prds/orgs-and-access.md). Optional: nil keeps the credential + // check as the whole gate -- the documented behaviour of an install that + // has not built the chain. Principals assembles the request principal + // from the acting identity; Denials records refusals. All three are + // wired together at composition or not at all. + Access access.Authorizer + Principals access.PrincipalSource + Denials access.DenialStore + // Events publishes operator actions so they reach the task timeline and // the live activity stream. Optional: nil means the action is recorded // in the store but invisible to anyone watching. @@ -329,7 +340,10 @@ func (s *Server) Handler() http.Handler { if s.CaptureIntake != nil { top.Handle(captureIntakeRoute, s.CaptureIntake) } - top.Handle("/", s.requireToken(mux)) + // The chain runs after the credential check and before any handler: the + // principal exists only once the credential resolved + // (docs/prds/orgs-and-access.md, "Where it lives"). + top.Handle("/", s.requireToken(s.authorize(mux))) return top }