242 lines
8.7 KiB
Go
242 lines
8.7 KiB
Go
// 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 := 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) {
|
|
switch {
|
|
case action == access.ActionCreate && matchSegment(path, "/api/bindings/", "/approve"):
|
|
return access.ActionApprove, access.KindBinding, segmentValue(path, 2), true
|
|
case matchSegment(path, "/api/tasks/", "/logs"):
|
|
return access.ActionReadLogs, access.KindTask, segmentValue(path, 2), true
|
|
case matchPrefix(path, "/api/identities"):
|
|
return actionManage(action), access.KindIdentity, 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"):
|
|
if action == access.ActionCreate {
|
|
return access.ActionRun, access.KindWorkflow, "", true
|
|
}
|
|
return access.ActionRead, access.KindDashboard, "", true
|
|
case matchSegment(path, "/api/sources/", "/secret"):
|
|
return access.ActionUpdate, access.KindSecret, segmentValue(path, 2), true
|
|
case matchPrefix(path, "/api/channels/"):
|
|
return actionManage(action), access.KindDashboard, segmentValue(path, 2), true
|
|
case matchPrefix(path, "/api/config"), matchPrefix(path, "/api/logs"):
|
|
return access.ActionRead, access.KindDashboard, "", true
|
|
}
|
|
return action, "", "", false
|
|
}
|
|
|
|
// 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.
|
|
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
|