Files
archie/modules/governance/access_api.go
T

174 lines
6.5 KiB
Go

package governance
import (
"context"
"errors"
"log/slog"
"net/http"
"time"
"github.com/danielgtaylor/huma/v2"
"github.com/samcharles93/archie-core/internal/platform/httpapi"
)
// policyAdmin is the stored policy chain the routes edit. PutPolicy and
// DeletePolicy refuse a change that leaves an org with nobody able to manage
// policies.
type policyAdmin interface {
ListPolicies(context.Context) ([]Policy, error)
PutPolicy(context.Context, Policy) (int64, error)
DeletePolicy(context.Context, Policy) error
}
// denialSearch reads the recorded refusals.
type denialSearch interface {
SearchDenials(context.Context, DenialQuery) ([]Denial, error)
}
// accessAPI serves the access policies and the record of refused requests.
type accessAPI struct {
policies policyAdmin
denials denialSearch
log *slog.Logger
}
func (m *Module) access() *accessAPI {
return &accessAPI{policies: m, denials: m, log: m.log}
}
type policiesBody struct {
Policies []Policy `json:"policies"`
Shipped []string `json:"shipped" doc:"IDs of the policies Archie ships, which a reset restores"`
}
type policyVersionBody struct {
Version int64 `json:"version" doc:"The policy chain's new revision"`
}
type policyInput struct {
Body Policy
}
type denialsInput struct {
Principal string `query:"principal" doc:"Only refusals of this identity"`
Action string `query:"action" doc:"Only refusals of this action"`
Kind string `query:"kind" doc:"Only refusals on this resource kind"`
Since time.Time `query:"since" doc:"Only refusals first recorded at or after this time"`
Until time.Time `query:"until" doc:"Only refusals first recorded before this time"`
Limit int `query:"limit" default:"100" minimum:"1" maximum:"1000" doc:"How many refusals to return"`
Offset int `query:"offset" default:"0" minimum:"0" doc:"How many of the newest matching refusals to skip"`
}
type denialsBody struct {
Denials []Denial `json:"denials"`
More bool `json:"more" doc:"Whether older refusals match beyond this page"`
}
func (m *Module) registerPolicies(api huma.API, op func(id, method, path, summary string, status int) huma.Operation) {
a := m.access()
httpapi.Register(api, httpapi.Authorized(ActionRead, KindPolicy), op("list-access-policies", http.MethodGet, "/api/access/policies", "List the organisation's access policies", 0), a.listPolicies)
httpapi.Register(api, httpapi.Authorized(ActionManagePolicies, KindPolicy), op("put-access-policy", http.MethodPut, "/api/access/policies", "Create or replace an access policy", 0), a.putPolicy)
httpapi.Register(api, httpapi.Authorized(ActionManagePolicies, KindPolicy), op("delete-access-policy", http.MethodDelete, "/api/access/policies", "Delete an access policy", http.StatusNoContent), a.deletePolicy)
}
func (m *Module) registerDenials(api huma.API, op func(id, method, path, summary string, status int) huma.Operation) {
a := m.access()
httpapi.Register(api, httpapi.Authorized(ActionReadAudit, KindAudit), op("list-access-denials", http.MethodGet, "/api/access/denials", "List the requests access policies refused", 0), a.listDenials)
}
func (a *accessAPI) listPolicies(ctx context.Context, _ *struct{}) (*httpapi.Reply[policiesBody], error) {
p, err := caller(ctx)
if err != nil {
return nil, err
}
stored, err := a.policies.ListPolicies(ctx)
if err != nil {
return nil, a.failed(ctx, "read the policies", err)
}
out := make([]Policy, 0, len(stored))
for _, s := range stored {
if s.Level == LevelInstance && p.InstanceAdmin() || s.Level != LevelInstance && s.OrgID == p.Org {
out = append(out, s)
}
}
return httpapi.OK(policiesBody{Policies: out, Shipped: shippedOrgPolicyIDs()}), nil
}
func (a *accessAPI) putPolicy(ctx context.Context, in *policyInput) (*httpapi.Reply[policyVersionBody], error) {
value, err := a.scoped(ctx, in.Body)
if err != nil {
return nil, err
}
if err := NewEngine(nil).Validate(value); err != nil {
return nil, a.failed(ctx, "save the policy", err)
}
version, err := a.policies.PutPolicy(ctx, value)
if err != nil {
return nil, a.failed(ctx, "save the policy", err)
}
return httpapi.OK(policyVersionBody{Version: version}), nil
}
func (a *accessAPI) deletePolicy(ctx context.Context, in *policyInput) (*struct{}, error) {
value, err := a.scoped(ctx, in.Body)
if err != nil {
return nil, err
}
if err := a.policies.DeletePolicy(ctx, value); err != nil {
return nil, a.failed(ctx, "delete the policy", err)
}
return nil, nil
}
// scoped pins a policy to the caller's organisation, since no request field
// chooses where a policy applies. Instance policies span every organisation, so
// only an instance administrator edits them.
func (a *accessAPI) scoped(ctx context.Context, value Policy) (Policy, error) {
p, err := caller(ctx)
if err != nil {
return Policy{}, err
}
if value.Level == LevelInstance {
if !p.InstanceAdmin() {
return Policy{}, huma.Error403Forbidden("Only an instance owner can change instance policies.")
}
value.OrgID, value.WorkspaceID, value.ObjectKind, value.ObjectID = "", "", "", ""
return value, nil
}
value.OrgID = p.Org
return value, nil
}
func (a *accessAPI) listDenials(ctx context.Context, in *denialsInput) (*httpapi.Reply[denialsBody], error) {
p, err := caller(ctx)
if err != nil {
return nil, err
}
found, err := a.denials.SearchDenials(ctx, DenialQuery{
Org: p.Org, Principal: IdentityID(in.Principal), Action: Action(in.Action), Kind: ResourceKind(in.Kind),
Since: in.Since, Until: in.Until, Limit: in.Limit + 1, Offset: in.Offset,
})
if err != nil {
return nil, a.failed(ctx, "read the denials", err)
}
more := len(found) > in.Limit
return httpapi.OK(denialsBody{Denials: found[:min(len(found), in.Limit)], More: more}), nil
}
// failed answers a policy failure with the status a person can act on: the
// Cedar error for a policy that does not compile, a conflict for a change that
// would lock every owner out.
func (a *accessAPI) failed(ctx context.Context, what string, err error) error {
switch {
case errors.Is(err, ErrPolicyLockout):
return huma.Error409Conflict("That change would leave no owner able to manage policies.")
case errors.Is(err, ErrPolicyNotFound):
return huma.Error404NotFound("That policy does not exist.")
case errors.Is(err, ErrInvalidPolicy), errors.Is(err, ErrInvalidLevel), errors.Is(err, ErrPolicyInvalidText):
return huma.Error400BadRequest(err.Error())
}
a.log.ErrorContext(ctx, "access operation failed", "operation", what, "err", err)
return huma.Error503ServiceUnavailable("Couldn't " + what + ". Try again shortly.")
}