package webui import ( "context" "encoding/json" "errors" "net" "net/http" "strconv" "strings" "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/org" "github.com/samcharles93/archie-core/internal/domain/storecontract" ) // authorize wraps h with the policy chain. A chain that is absent or has not // loaded refuses the request: the credential check alone is never the gate // while orgs exist, so a State Store outage closes the dashboard rather than // letting every request through as the system org. func (s *Server) authorize(h http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { // Checked before the principal: resolving it is a State Store round // trip, which buys nothing when the answer is a refusal anyway. if s.Access == nil || !s.Access.Ready() { s.refuseUngated(w, r) return } principal, err := s.requestPrincipal(r.Context()) if err != nil { if wantsDocument(r) { s.authPage(w, http.StatusUnauthorized, "Sign-in could not resolve your org.") return } http.Error(w, "principal unavailable", http.StatusServiceUnavailable) return } action, kind, id := accessRequest(r) ctx := org.WithOrg(access.WithPrincipal(r.Context(), principal), principal.Org) // 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, owner and state are read from the record, never the body. resource, err := s.recordResource(ctx, kind, id) if err != nil { s.logf("record workspace unavailable", "kind", kind, "id", id, "err", err) http.Error(w, "record unavailable", http.StatusServiceUnavailable) return } peer, _, _ := net.SplitHostPort(r.RemoteAddr) decision := s.Access.Authorize(principal, action, resource, access.Context{Addr: peer}) if !decision.Allowed { if errors.Is(decision.Err, access.ErrChainUnavailable) { // Nothing was evaluated: the chain has not loaded. This is an // availability failure, not a denial, so none is recorded. s.refuseUngated(w, r) return } s.recordDenial(r.Context(), principal, action, resource, decision) if wantsDocument(r) { s.authPage(w, http.StatusUnauthorized, "You do not have permission to do that.") return } // A denial inside the caller's org is forbidden, without the // reason. http.Error(w, "forbidden", http.StatusForbidden) return } // The principal rides the context into every State Store call, which // derives the org it acts in from it. h.ServeHTTP(w, r.WithContext(ctx)) }) } // authorizeCreateIn checks a create against the workspace the body names, which // the route-level check cannot see: no record exists yet to read it from. An // empty workspace is the default one, which that check already covered. func (s *Server) authorizeCreateIn(w http.ResponseWriter, r *http.Request, kind access.ResourceKind, workspace org.WorkspaceID) bool { principal, ok := access.PrincipalFromContext(r.Context()) if workspace == "" || !ok { return true } resource := access.Resource{Kind: kind, Org: principal.Org, Workspace: workspace} decision := s.Access.Authorize(principal, access.ActionCreate, resource, access.Context{}) if decision.Allowed { return true } s.recordDenial(r.Context(), principal, access.ActionCreate, resource, decision) http.Error(w, "forbidden", http.StatusForbidden) return false } // recordResource reads policy attributes from the stored record, never the body. func (s *Server) recordResource(ctx context.Context, kind access.ResourceKind, id string) (access.Resource, error) { resource := access.Resource{Kind: kind, ID: id, Org: org.OrgFromContext(ctx)} if id == "" { return resource, nil } var err error switch kind { case access.KindTask: return s.taskResource(ctx, resource) case access.KindBinding: return s.bindingResource(ctx, resource) case access.KindSource: resource.Workspace, err = s.sourceWorkspace(ctx, id) case access.KindMapping: resource.Workspace, err = s.mappingWorkspace(ctx, id) case access.KindEventType: resource.Workspace, err = s.eventTypeWorkspace(ctx, id) } return resource, err } func (s *Server) sourceWorkspace(ctx context.Context, path string) (org.WorkspaceID, error) { if s.Sources == nil { return "", nil } src, err := s.Sources.GetSource(ctx, path) if src == nil || err != nil { return "", err } return src.WorkspaceID, nil } func (s *Server) bindingResource(ctx context.Context, resource access.Resource) (access.Resource, error) { if s.Bindings == nil { return resource, nil } b, err := s.Bindings.GetBinding(ctx, resource.ID) if b == nil || err != nil { return resource, ignoreNotFound(err, storecontract.ErrBindingNotFound) } resource.Workspace, resource.State = b.WorkspaceID, string(b.Status) return resource, nil } func (s *Server) mappingWorkspace(ctx context.Context, id string) (org.WorkspaceID, error) { if s.Mappings == nil { return "", nil } m, err := s.Mappings.GetMapping(ctx, id) if m == nil || err != nil { return "", ignoreNotFound(err, storecontract.ErrMappingNotFound) } return m.WorkspaceID, nil } func (s *Server) eventTypeWorkspace(ctx context.Context, id string) (org.WorkspaceID, error) { if s.EventTypes == nil { return "", nil } types, err := s.EventTypes.ListEventTypes(ctx) if err != nil { return "", err } for _, t := range types { if t.ID == id { return t.WorkspaceID, nil } } return "", nil } func (s *Server) taskResource(ctx context.Context, resource access.Resource) (access.Resource, error) { taskID, ok := numericID(resource.ID) if !ok { return resource, nil } t, err := s.Store.TaskByID(ctx, taskID) if t == nil || err != nil { return resource, err } resource.Workspace, resource.Owner, resource.State = t.Workspace, identity.IdentityID(t.Identity), t.Status return resource, nil } // numericID parses a task route's ID; any other segment names no task. func numericID(id string) (int64, bool) { n, err := strconv.ParseInt(id, 10, 64) return n, err == nil } // ignoreNotFound drops the store's not-found answer: a missing record has no // workspace, and the handler reports it. func ignoreNotFound(err, notFound error) error { if errors.Is(err, notFound) { return nil } return err } // refuseUngated answers a request the dashboard cannot authorize because no // policy chain is available. It serves nothing ungated: without a chain the // credential check would be the whole gate and every call would act as the // system org. The detailed health report names only the unloaded chain, so // the operator can see why without any other probe being served ungated. func (s *Server) refuseUngated(w http.ResponseWriter, r *http.Request) { if wantsDocument(r) { s.authPage(w, http.StatusServiceUnavailable, "The access policy chain is not available yet.") return } w.Header().Set("Cache-Control", "no-store") if r.URL.Path == healthDetailedRoute { w.Header().Set("Content-Type", "application/json") w.WriteHeader(http.StatusServiceUnavailable) _ = json.NewEncoder(w).Encode(health.Report{Status: health.StatusDegraded, Components: []health.Component{{ Name: "access_policies", Status: health.StatusDegraded, Detail: "policies not loaded; requests refused", }}}) return } http.Error(w, "access policies are not available", http.StatusServiceUnavailable) } // requestPrincipal assembles the principal a request acts as. With no acting // identity (the shared token), it is the org-sys owner person when the upgrade // created one; with an acting identity, it is the identity's org and // memberships, read over the wire. The system owner remains the fallback for an // install that has not run the operator phase. 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) } if s.Principals != nil { if operator, err := s.Principals.PrincipalFor(ctx, identity.OperatorID()); err == nil && operator.Org == org.DefaultOrgID && operator.Role("") == org.RoleOwner { return operator, nil } } return access.SharedTokenOwner(), 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 := actionOf(r.Method) path := r.URL.Path if a, kind, id, ok := routeOverride(action, path); ok { return a, kind, id } return action, kindOf(path), segmentValue(path, 2) } // actionOf maps the HTTP method onto the action vocabulary. POST is create: // the route refinements lift the routes whose write is something else. func actionOf(method string) access.Action { switch method { case http.MethodPost: return access.ActionCreate case http.MethodPut, http.MethodPatch: return access.ActionUpdate case http.MethodDelete: return access.ActionDelete } return access.ActionRead } // routeOverride returns the action, kind and record key a specific route // shape carries, or ok=false when the method-and-kind fallback applies. func routeOverride(action access.Action, path string) (access.Action, access.ResourceKind, string, bool) { if a, kind, ok := accountRoute(path); ok { return a, kind, "", true } if command, ok := bindingCommand(action, path); ok { return command, access.KindBinding, segmentValue(path, 2), true } switch { case matchSegment(path, "/api/tasks/", "/logs"), matchSegment(path, "/api/tasks/", "/sandbox"): return access.ActionReadLogs, access.KindTask, segmentValue(path, 2), true case matchPrefix(path, "/api/access/policies"): return policyAction(action), access.KindPolicy, "", true case matchPrefix(path, "/api/identities"): return actionManage(action), access.KindIdentity, segmentValue(path, 2), true case matchPrefix(path, "/api/orgs"): return orgRouteAction(action, path), access.KindOrg, segmentValue(path, 2), true case matchPrefix(path, "/api/extensions"): // Installing and enabling an extension runs a process on the host, so it // is the same administration as editing a control-plane resource. return actionManage(action), access.KindPolicy, segmentValue(path, 2), true case matchPrefix(path, "/api/control-plane/resources"): return actionManage(action), access.KindPolicy, segmentValue(path, 3), true case matchPrefix(path, "/api/chat"): return chatRoute(action) case matchSegment(path, "/api/sources/", "/secret"): // Rotating a source's secret hands back its value. return access.ActionReadSecret, access.KindSecret, segmentValue(path, 2), true case matchPrefix(path, "/api/harness/terminal"): // Opening the setup terminal updates the binding's secret. return access.ActionUpdate, access.KindSecret, "", true case matchPrefix(path, "/api/harness/bindings"): return access.ActionRead, access.KindSecret, "", true case matchPrefix(path, "/api/channels"): return actionManage(action), access.KindDashboard, segmentValue(path, 2), true case matchPrefix(path, "/api/config"), matchPrefix(path, "/api/logs"), // A person's own tokens act only as that person, so managing them // needs no more than reading the dashboard. matchPrefix(path, "/api/tokens"): return access.ActionRead, access.KindDashboard, "", true } return action, "", "", false } // bindingCommand maps a binding lifecycle route to its action: approving arms // a binding, so it is approval; pausing and resuming change its state. func bindingCommand(action access.Action, path string) (access.Action, bool) { switch { case action != access.ActionCreate: return action, false case matchSegment(path, "/api/bindings/", "/approve"): return access.ActionApprove, true case matchSegment(path, "/api/bindings/", "/pause"), matchSegment(path, "/api/bindings/", "/resume"): return access.ActionUpdate, true } return action, false } // orgRouteAction maps an org request: reads are org reads, changing who // belongs to the org or which agents serve it is member management (an // admin's grant), and any other mutation updates the org. func orgRouteAction(action access.Action, path string) access.Action { switch { case action == access.ActionRead: return access.ActionRead case segmentValue(path, 3) == "members", segmentValue(path, 3) == "agents": return access.ActionManageMembers } return access.ActionUpdate } // chatRoute maps a chat request: posting runs a workflow, anything else reads // the dashboard. func chatRoute(action access.Action) (access.Action, access.ResourceKind, string, bool) { if action == access.ActionCreate { return access.ActionRun, access.KindWorkflow, "", true } return access.ActionRead, access.KindDashboard, "", true } // kindOf maps a collection route onto the resource kind it addresses. func kindOf(path string) access.ResourceKind { switch { case matchPrefix(path, "/api/tasks"): return access.KindTask case matchPrefix(path, "/api/event-types"): return access.KindEventType case matchPrefix(path, "/api/mappings"): return access.KindMapping case matchPrefix(path, "/api/bindings"): return access.KindBinding case matchPrefix(path, "/api/sources"): return access.KindSource case matchPrefix(path, "/api/work-requests"), matchPrefix(path, "/api/repositories"): return access.KindTask } return access.KindDashboard } // actionManage lifts a create or update on a managed surface to the manage // action the role vocabulary carries. // policyAction lifts every write on the policy routes to manage_policies. func policyAction(action access.Action) access.Action { if action == access.ActionRead { return action } return access.ActionManagePolicies } 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) } func accountRoute(path string) (access.Action, access.ResourceKind, bool) { switch path { case "/api/accounts": return access.ActionManageMembers, access.KindMember, true case "/api/authentication": return access.ActionManageIdentities, access.KindIdentity, true } return "", "", false }