* fix(postgres): scope OpenPRs to the caller's org A principal-carrying caller read every org's pr_open tasks. The query now honours the request scope; the daemon's unscoped review scan still sees all orgs. Issue: archie-core-kgxw.23 * fix(statestore): serve task logs only to the task's org ReadTaskLog and StreamTaskLogContent took a task ID and read the file with no org check. The State Store's task-log reader now confirms the task is visible under the caller's scope first; unscoped services read as before. Issue: archie-core-kgxw.24 * fix(postgres): scope ListPolicies to the caller's org Every org's policy text reached any principal-carrying caller. A scoped read now sees its own org's policies, plus instance policies when scoped to the system org. The engines and the lockout guard decide for every org, so they read the full chain unscoped: the dashboard engine loads without the request's principal and the guard lifts the caller's scope. Issue: archie-core-kgxw.25 * fix(postgres): scope identity reads to the caller's org ListIdentities and GetIdentity (and its alias fallback) returned every identity to any caller. A caller scoped to an org now sees only that org's members and assigned agents; the system org and unscoped services still see the whole instance. Issue: archie-core-kgxw.26 * fix(postgres): hide instance status from other orgs ListPresence, ListChannelStatus, ListApplyStatus and GetConfigSnapshot answered any org principal with instance-wide state. They now return nothing unless the request is unscoped or scoped to the system org. The dashboard reads the published config as itself, since its handlers project it for callers of every org. Issue: archie-core-kgxw.27 * feat(postgres): assign new agents an org and role at creation A bot or service account created through the API served no org until the next State Store boot granted it one. Create now assigns it to the org the request acts in with the developer role in the same transaction, so it is authorized immediately. Issue: archie-core-kgxw.14 * feat(edastore): create event records in a chosen workspace Sources are created in a workspace of the caller's org, the default one when none is named; event types and bindings take their source's workspace and mappings their event type's, the same rule the org backfill applied. The binding, mapping and event type contracts carry the workspace, the four list endpoints accept ?workspace=, and the Events page has a workspace selector that filters every step and picks where a new source goes. Issue: archie-core-kgxw.11 * feat(webui): authorize a record in its workspace The API built every access request with no workspace, so workspace policies and per-workspace roles never applied. A request naming a source, binding, mapping, event type or task now reads the record's workspace under the caller's scope and authorizes in it; tasks carry their workspace on the State Store contract for this. Issue: archie-core-kgxw.9 * feat(access): expose workspace environment to policies Policies can test resource.workspace.environment. The workspace attribute is the workspace entity, which carries its environment; the principal brings its org's workspaces from the State Store, so the dashboard and the daemon's run checks describe a resource's workspace without another lookup, and the daemon now authorizes runs in the task's or binding's workspace. Issue: archie-core-kgxw.10 * fix(webui): ask read_secret when a source secret is read Rotating a source's secret returns its value, but the route asked update, which every developer holds, so no policy could narrow who reads a secret. It now asks read_secret on the secret, which the shipped roles give admins and an object policy can narrow further. Issue: archie-core-kgxw.17 * refactor(org): delete the unused upgrade-incomplete sentinel Nothing returns org.ErrUpgradeIncomplete: the State Store finishes the org upgrade before it serves. Issue: archie-core-kgxw.18
412 lines
14 KiB
Go
412 lines
14 KiB
Go
package webui
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"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 is the record's, not the route's, so it is read.
|
|
workspace, err := s.recordWorkspace(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
|
|
}
|
|
resource := access.Resource{Kind: kind, ID: id, Org: principal.Org, Workspace: workspace}
|
|
decision := s.Access.Authorize(principal, action, resource, access.Context{})
|
|
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))
|
|
})
|
|
}
|
|
|
|
// recordWorkspace returns the workspace of the record a request names, so
|
|
// workspace policies and per-workspace roles decide for it. A request naming
|
|
// no record, or one the caller's org does not hold, has none: the handler's
|
|
// own lookup answers not found.
|
|
func (s *Server) recordWorkspace(ctx context.Context, kind access.ResourceKind, id string) (org.WorkspaceID, error) {
|
|
if id == "" {
|
|
return "", nil
|
|
}
|
|
switch kind {
|
|
case access.KindSource:
|
|
return s.sourceWorkspace(ctx, id)
|
|
case access.KindBinding:
|
|
return s.bindingWorkspace(ctx, id)
|
|
case access.KindMapping:
|
|
return s.mappingWorkspace(ctx, id)
|
|
case access.KindEventType:
|
|
return s.eventTypeWorkspace(ctx, id)
|
|
case access.KindTask:
|
|
return s.taskWorkspace(ctx, id)
|
|
}
|
|
return "", nil
|
|
}
|
|
|
|
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) bindingWorkspace(ctx context.Context, id string) (org.WorkspaceID, error) {
|
|
if s.Bindings == nil {
|
|
return "", nil
|
|
}
|
|
b, err := s.Bindings.GetBinding(ctx, id)
|
|
if b == nil || err != nil {
|
|
return "", ignoreNotFound(err, storecontract.ErrBindingNotFound)
|
|
}
|
|
return b.WorkspaceID, 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) taskWorkspace(ctx context.Context, id string) (org.WorkspaceID, error) {
|
|
taskID, ok := numericID(id)
|
|
if s.Store == nil || !ok {
|
|
return "", nil
|
|
}
|
|
t, err := s.Store.TaskByID(ctx, taskID)
|
|
if t == nil || err != nil {
|
|
return "", err
|
|
}
|
|
return t.Workspace, 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: "access policies have not loaded; requests are 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 command, ok := bindingCommand(action, path); ok {
|
|
return command, access.KindBinding, segmentValue(path, 2), true
|
|
}
|
|
switch {
|
|
case matchSegment(path, "/api/tasks/", "/logs"):
|
|
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"):
|
|
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)
|
|
}
|