diff --git a/internal/app/archie/run.go b/internal/app/archie/run.go
index cbedc2695..eef841fcd 100644
--- a/internal/app/archie/run.go
+++ b/internal/app/archie/run.go
@@ -87,12 +87,13 @@ func Run(ctx context.Context, configPath string) error {
engine := runs.New(db, log.With("module", "runs"), runs.Options{Owner: owner()})
// A workflow takes its context from the run handle, as a handler takes it
// from the request.
- judge, classes := newJudgement(db, log, conns, settings)
+ judge, classes, policies := newJudgement(db, log, conns, settings)
// An approval request is carried by deliveries, and its answer wakes the run
// that is waiting on it.
allow := approvals.NewModule(db, log.With("module", "approvals"), orgID, tell, engine, classes, settings, settings)
allow.Routes(mux, guard)
classes.Routes(mux, guard, allow)
+ policies.Routes(mux, guard)
remembered := memory.NewModule(db, orgID)
engine.Register("investigate", 1, runs.Investigate(settings, conns, judge, allow, tell, remembered)) //nolint:contextcheck // see above
@@ -123,13 +124,15 @@ func work(ctx context.Context, loops ...func(context.Context)) func() {
}
// newJudgement returns the judgement module and the action classes its
-// precedent guard reads. A failed action tightens its class.
-func newJudgement(db *sqlx.DB, log *slog.Logger, conns *connectors.Module, freezes judgement.Freezes) (*judgement.Module, *judgement.Classes) {
+// precedent guard reads, and the policy sets. A failed action tightens its class.
+func newJudgement(db *sqlx.DB, log *slog.Logger, conns *connectors.Module, freezes judgement.Freezes) (*judgement.Module, *judgement.Classes, *judgement.Policies) {
classes := judgement.NewClasses(db, log.With("module", "judgement"), orgID)
- judge := judgement.NewModule(db, log.With("module", "judgement"), orgID, conns, nil,
+ policies := judgement.NewPolicies(db, log.With("module", "judgement"), orgID)
+ judge := judgement.NewModule(db, log.With("module", "judgement"), orgID, conns, []judgement.HardRule{policies},
[]judgement.Guard{judgement.Reversibility{}, judgement.Precedent{Classes: classes}, judgement.Freeze{Freezes: freezes}}, classes)
judge.UseExtensions(conns)
- return judge, classes
+ judge.UseChangeRules(policies)
+ return judge, classes, policies
}
// orgID is the one organisation until hosting is multi-tenant.
diff --git a/internal/platform/pg/migrations/00027_judgement_policies.sql b/internal/platform/pg/migrations/00027_judgement_policies.sql
new file mode 100644
index 000000000..976d9a38b
--- /dev/null
+++ b/internal/platform/pg/migrations/00027_judgement_policies.sql
@@ -0,0 +1,16 @@
+-- +goose Up
+-- Hard rules and change-request rules are Cedar policy sets, one per kind per
+-- organisation. Every version is kept; the highest is the one in force.
+CREATE TABLE judgement.policy_sets (
+ id uuid PRIMARY KEY,
+ org_id text NOT NULL,
+ kind text NOT NULL CHECK (kind IN ('hard_rules', 'change_request')),
+ version integer NOT NULL,
+ body text NOT NULL,
+ created_by text NOT NULL,
+ created_at timestamptz NOT NULL DEFAULT now(),
+ UNIQUE (org_id, kind, version)
+);
+
+-- +goose Down
+DROP TABLE judgement.policy_sets;
diff --git a/modules/judgement/extensions.go b/modules/judgement/extensions.go
index 3d709b586..87ec74702 100644
--- a/modules/judgement/extensions.go
+++ b/modules/judgement/extensions.go
@@ -22,8 +22,9 @@ type identified interface {
// RunContext is the run an action belongs to, passed to guards that want it.
type RunContext struct {
- RunID uuid.UUID
- Key string
+ RunID uuid.UUID
+ Key string
+ Workflow string
}
type runKey struct{}
diff --git a/modules/judgement/internal/store/policies.go b/modules/judgement/internal/store/policies.go
new file mode 100644
index 000000000..7b2d72e9b
--- /dev/null
+++ b/modules/judgement/internal/store/policies.go
@@ -0,0 +1,76 @@
+package store
+
+import (
+ "context"
+ "database/sql"
+ "errors"
+ "fmt"
+ "time"
+
+ "github.com/google/uuid"
+)
+
+// ErrNoPolicySet means no version of that policy set exists.
+var ErrNoPolicySet = errors.New("no such policy set")
+
+// PolicySet is one version of an organisation's policy set of one kind.
+type PolicySet struct {
+ ID uuid.UUID `db:"id"`
+ OrgID string `db:"org_id"`
+ Kind string `db:"kind"`
+ Version int `db:"version"`
+ Body string `db:"body"`
+ CreatedBy string `db:"created_by"`
+ CreatedAt time.Time `db:"created_at"`
+}
+
+const policyColumns = `id, org_id, kind, version, body, created_by, created_at`
+
+// Policy returns a version of a policy set, or the one in force when version
+// is zero.
+func (s *Store) Policy(ctx context.Context, orgID, kind string, version int) (PolicySet, error) {
+ var out PolicySet
+ query := `SELECT ` + policyColumns + ` FROM judgement.policy_sets WHERE org_id = $1 AND kind = $2`
+ args := []any{orgID, kind}
+ if version > 0 {
+ query += ` AND version = $3`
+ args = append(args, version)
+ } else {
+ query += ` ORDER BY version DESC LIMIT 1`
+ }
+ err := s.db.GetContext(ctx, &out, query, args...)
+ if errors.Is(err, sql.ErrNoRows) {
+ return PolicySet{}, ErrNoPolicySet
+ }
+ if err != nil {
+ return PolicySet{}, fmt.Errorf("read policy set: %w", err)
+ }
+ return out, nil
+}
+
+// PolicyVersions returns every version of a policy set, newest first, without
+// their bodies.
+func (s *Store) PolicyVersions(ctx context.Context, orgID, kind string) ([]PolicySet, error) {
+ var out []PolicySet
+ if err := s.db.SelectContext(ctx, &out, `
+ SELECT id, org_id, kind, version, '' AS body, created_by, created_at
+ FROM judgement.policy_sets WHERE org_id = $1 AND kind = $2 ORDER BY version DESC`, orgID, kind); err != nil {
+ return nil, fmt.Errorf("list policy versions: %w", err)
+ }
+ return out, nil
+}
+
+// AddPolicy stores body as the next version of the kind's policy set. Two
+// writers racing for one version make the second fail on the unique key.
+func (s *Store) AddPolicy(ctx context.Context, p PolicySet) (PolicySet, error) {
+ var out PolicySet
+ err := s.db.GetContext(ctx, &out, `
+ INSERT INTO judgement.policy_sets (id, org_id, kind, version, body, created_by)
+ SELECT $1, $2, $3, coalesce(max(version), 0) + 1, $4, $5
+ FROM judgement.policy_sets WHERE org_id = $2 AND kind = $3
+ RETURNING `+policyColumns, p.ID, p.OrgID, p.Kind, p.Body, p.CreatedBy)
+ if err != nil {
+ return PolicySet{}, fmt.Errorf("add policy set: %w", err)
+ }
+ return out, nil
+}
diff --git a/modules/judgement/judgement.go b/modules/judgement/judgement.go
index 3f06c9db6..4b1378f7b 100644
--- a/modules/judgement/judgement.go
+++ b/modules/judgement/judgement.go
@@ -98,9 +98,8 @@ type Guard interface {
// HardRule refuses actions outright. Hard rules run before any guard.
type HardRule interface {
- Name() string
- // Refuses reports whether the rule forbids the action, and why.
- Refuses(a Action) (reason string, refused bool)
+ // Refuses reports whether a rule forbids the action: the rule's id and why.
+ Refuses(ctx context.Context, a Action) (by, reason string, refused bool)
}
// Decision is the judgement of one action.
@@ -112,9 +111,13 @@ type Decision struct {
Level Level `json:"level"`
Verdicts []Verdict `json:"verdicts"`
// RefusedBy names the hard rule that refused the action, if one did.
- RefusedBy string `json:"refused_by,omitzero"`
- Reason string `json:"reason,omitzero"`
- At time.Time `json:"at"`
+ RefusedBy string `json:"refused_by,omitzero"`
+ // ChangeRequest says approval goes through a change request, and
+ // ChangeRequestRule which change-request rule said so.
+ ChangeRequest bool `json:"change_request,omitzero"`
+ ChangeRequestRule string `json:"change_request_rule,omitzero"`
+ Reason string `json:"reason,omitzero"`
+ At time.Time `json:"at"`
}
// Request asks for one action to be judged. Key identifies the attempt to run
@@ -126,6 +129,8 @@ type Request struct {
Connector string
Action string
Input jsontext.Value
+ // Workflow is the workflow the run executes, the principal hard rules see.
+ Workflow string
}
// Tools finds the tool that resolves and runs an action.
@@ -152,6 +157,8 @@ type Module struct {
guards []Guard
store recorder
failed FailureRecorder
+ // changeRules decides whether approval goes through a change request.
+ changeRules ChangeRules
// extensions are the guard extensions asked alongside the built-in guards.
extensions GuardExtensions
// timeout bounds one guard; zero means guardTimeout.
@@ -160,6 +167,10 @@ type Module struct {
now func() time.Time
}
+// UseChangeRules makes the module ask rules whether a held action's approval
+// goes through a change request.
+func (m *Module) UseChangeRules(r ChangeRules) { m.changeRules = r }
+
// UseExtensions makes the module ask every running guard extension alongside
// its built-in guards, on each decision.
func (m *Module) UseExtensions(e GuardExtensions) { m.extensions = e }
@@ -185,7 +196,7 @@ func (m *Module) Assess(ctx context.Context, req Request) (Decision, error) {
Connector: req.Connector, Name: req.Action, Input: req.Input,
Digest: connectors.Digest(req.Action, req.Input), Target: res.Target, Effect: res.Effect,
}
- d := m.decide(withRun(ctx, RunContext{RunID: req.RunID, Key: req.Key}), a)
+ d := m.decide(withRun(ctx, RunContext{RunID: req.RunID, Key: req.Key, Workflow: req.Workflow}), a)
d.ID, d.RunID, d.Key, d.At = uuid.New(), req.RunID, req.Key, m.now().UTC()
return m.record(ctx, d)
}
@@ -194,8 +205,8 @@ func (m *Module) Assess(ctx context.Context, req Request) (Decision, error) {
// ceilings: the action runs at the lowest.
func (m *Module) decide(ctx context.Context, a Action) Decision {
for _, r := range m.rules {
- if reason, refused := r.Refuses(a); refused {
- return Decision{Action: a, Level: Never, RefusedBy: r.Name(), Reason: reason, Verdicts: []Verdict{}}
+ if by, reason, refused := r.Refuses(ctx, a); refused {
+ return Decision{Action: a, Level: Never, RefusedBy: by, Reason: reason, Verdicts: []Verdict{}}
}
}
guards := slices.Clone(m.guards)
@@ -220,7 +231,12 @@ func (m *Module) decide(ctx context.Context, a Action) Decision {
if len(ceilings) > 0 {
level = lowest(ceilings...)
}
- return Decision{Action: a, Level: level, Verdicts: verdicts}
+ d := Decision{Action: a, Level: level, Verdicts: verdicts}
+ // A change request is a way to approve, so only a held action has one.
+ if m.changeRules != nil && level > ActAndTell && level < Never {
+ d.ChangeRequestRule, d.ChangeRequest = m.changeRules.Requires(ctx, a, level, verdicts)
+ }
+ return d
}
// judge asks one guard, turning a failure, a timeout or a missing ceiling
diff --git a/modules/judgement/judgement_test.go b/modules/judgement/judgement_test.go
index 46651c6f1..51aaa344a 100644
--- a/modules/judgement/judgement_test.go
+++ b/modules/judgement/judgement_test.go
@@ -37,8 +37,9 @@ func (g fixedGuard) Judge(context.Context, Action) (Verdict, error) {
type refuseAll struct{}
-func (refuseAll) Name() string { return "no deletes in production" }
-func (refuseAll) Refuses(Action) (string, bool) { return "production is off limits", true }
+func (refuseAll) Refuses(context.Context, Action) (string, string, bool) {
+ return "no deletes in production", "production is off limits", true
+}
// TestDecisionRunsAtTheLowestCeiling guards the weakest-link decision (spec
// section 5, decision tree 8.3): hard rules refuse before any guard runs; the
diff --git a/modules/judgement/policies.go b/modules/judgement/policies.go
new file mode 100644
index 000000000..793c77c64
--- /dev/null
+++ b/modules/judgement/policies.go
@@ -0,0 +1,393 @@
+package judgement
+
+import (
+ "context"
+ _ "embed" // the starter policy sets
+ "encoding/json/jsontext"
+ json "encoding/json/v2"
+ "errors"
+ "fmt"
+ "log/slog"
+ "maps"
+ "math"
+ "net/http"
+ "strconv"
+ "time"
+
+ cedar "github.com/cedar-policy/cedar-go"
+ "github.com/cedar-policy/cedar-go/types"
+ "github.com/google/uuid"
+ "github.com/jmoiron/sqlx"
+
+ "github.com/samcharles93/archie-core/internal/platform/httpjson"
+ "github.com/samcharles93/archie-core/modules/connectors"
+ "github.com/samcharles93/archie-core/modules/judgement/internal/store"
+)
+
+// Policy kinds. Hard rules are forbids that run before any guard; change
+// request rules are permits that run after the guards.
+const (
+ KindHardRules = "hard_rules"
+ KindChangeRequest = "change_request"
+ maxPolicyBytes = 64 << 10
+ hardRulesUnreadable = "hard-rules-unavailable"
+ changeRuleUnread = "change-request-rules-unavailable"
+)
+
+//go:embed starter/hard_rules.cedar
+var starterHardRules string
+
+//go:embed starter/change_request.cedar
+var starterChangeRequest string
+
+// ChangeRules decides whether an approval goes through a change request.
+type ChangeRules interface {
+ // Requires returns the rule that sends the action through a change
+ // request, given the level and verdicts the guards reached.
+ Requires(ctx context.Context, a Action, level Level, verdicts []Verdict) (rule string, required bool)
+}
+
+type policyStore interface {
+ Policy(ctx context.Context, orgID, kind string, version int) (store.PolicySet, error)
+ PolicyVersions(ctx context.Context, orgID, kind string) ([]store.PolicySet, error)
+ AddPolicy(ctx context.Context, p store.PolicySet) (store.PolicySet, error)
+}
+
+// Policies are an organisation's Cedar policy sets: the hard rules and the
+// change-request rules, every version kept.
+type Policies struct {
+ orgID string
+ store policyStore
+ log *slog.Logger
+ now func() time.Time
+}
+
+// NewPolicies returns the policy sets of orgID.
+func NewPolicies(db *sqlx.DB, log *slog.Logger, orgID string) *Policies {
+ return &Policies{orgID: orgID, store: store.New(db), log: log, now: time.Now}
+}
+
+var starters = map[string]string{KindHardRules: starterHardRules, KindChangeRequest: starterChangeRequest}
+
+// current returns the version of a kind in force, seeding the starter set the
+// first time.
+func (p *Policies) current(ctx context.Context, kind string) (store.PolicySet, error) {
+ set, err := p.store.Policy(ctx, p.orgID, kind, 0)
+ if !errors.Is(err, store.ErrNoPolicySet) {
+ return set, err
+ }
+ if _, err := p.store.AddPolicy(ctx, store.PolicySet{ID: uuid.New(), OrgID: p.orgID, Kind: kind, Body: starters[kind], CreatedBy: "starter"}); err != nil {
+ // Another writer seeded it first.
+ if again, rerr := p.store.Policy(ctx, p.orgID, kind, 0); rerr == nil {
+ return again, nil
+ }
+ return store.PolicySet{}, err
+ }
+ return p.store.Policy(ctx, p.orgID, kind, 0)
+}
+
+// parse compiles a policy set. Every policy needs a unique @id and must be a
+// forbid in hard rules or a permit in change-request rules.
+func parse(kind, body string) (*cedar.PolicySet, error) {
+ list, err := cedar.NewPolicyListFromBytes(kind, []byte(body))
+ if err != nil {
+ return nil, fmt.Errorf("parse policies: %w", err)
+ }
+ want := cedar.Forbid
+ if kind == KindChangeRequest {
+ want = cedar.Permit
+ }
+ set := cedar.NewPolicySet()
+ for i, pol := range list {
+ id := pol.Annotations()["id"]
+ switch {
+ case id == "":
+ return nil, fmt.Errorf("policy %d needs an @id annotation", i+1)
+ case pol.Effect() != want:
+ return nil, fmt.Errorf("policy %q must be a %s", id, effectName(want))
+ case !set.Add(cedar.PolicyID(id), pol):
+ return nil, fmt.Errorf("policy id %q is used twice", id)
+ }
+ }
+ return set, nil
+}
+
+func effectName(e cedar.Effect) string {
+ if e == cedar.Forbid {
+ return "forbid"
+ }
+ return "permit"
+}
+
+// Refuses reports whether a hard rule forbids the action, naming the policy.
+// A policy set that can't be read or evaluated refuses: a rule that can't be
+// checked is not one to run past.
+func (p *Policies) Refuses(ctx context.Context, a Action) (by, reason string, refused bool) {
+ set, err := p.compiled(ctx, KindHardRules)
+ if err != nil {
+ p.log.ErrorContext(ctx, "read hard rules", "error", err)
+ return hardRulesUnreadable, "the hard rules couldn't be read", true
+ }
+ _, diag := cedar.Authorize(set, entities(ctx, a), request(ctx, a, nil))
+ if len(diag.Reasons) > 0 {
+ return p.explain(set, diag.Reasons[0].PolicyID, "refused by hard rule")
+ }
+ if len(diag.Errors) > 0 {
+ return p.explain(set, diag.Errors[0].PolicyID, "a hard rule couldn't be evaluated: "+diag.Errors[0].Message)
+ }
+ return "", "", false
+}
+
+func (p *Policies) explain(set *cedar.PolicySet, id cedar.PolicyID, fallback string) (string, string, bool) {
+ if pol := set.Get(id); pol != nil {
+ if r := pol.Annotations()["reason"]; r != "" {
+ return string(id), string(r), true
+ }
+ }
+ return string(id), fallback + " " + string(id), true
+}
+
+// Requires reports the change-request rule that matches the action and what
+// the guards decided. A rule that can't be evaluated counts as matching:
+// more oversight is the safe side.
+func (p *Policies) Requires(ctx context.Context, a Action, level Level, verdicts []Verdict) (string, bool) {
+ set, err := p.compiled(ctx, KindChangeRequest)
+ if err != nil {
+ p.log.ErrorContext(ctx, "read change-request rules", "error", err)
+ return changeRuleUnread, true
+ }
+ decision, diag := cedar.Authorize(set, entities(ctx, a), request(ctx, a, verdictContext(level, verdicts)))
+ if decision == types.Allow && len(diag.Reasons) > 0 {
+ return string(diag.Reasons[0].PolicyID), true
+ }
+ if len(diag.Errors) > 0 {
+ return string(diag.Errors[0].PolicyID), true
+ }
+ return "", false
+}
+
+func (p *Policies) compiled(ctx context.Context, kind string) (*cedar.PolicySet, error) {
+ row, err := p.current(ctx, kind)
+ if err != nil {
+ return nil, err
+ }
+ return parse(kind, row.Body)
+}
+
+func entities(ctx context.Context, a Action) types.EntityMap {
+ principal := types.NewEntityUID("Workflow", types.String(runFrom(ctx).Workflow))
+ resource := resourceUID(a)
+ return types.EntityMap{
+ principal: {UID: principal, Attributes: types.NewRecord(types.RecordMap{"name": types.String(runFrom(ctx).Workflow)})},
+ resource: {UID: resource, Attributes: types.NewRecord(types.RecordMap{
+ "kind": types.String(a.Target.Kind), "id": types.String(a.Target.ID),
+ "environment": types.String(a.Target.Environment), "disposable": types.Boolean(a.Target.Disposable),
+ })},
+ }
+}
+
+func resourceUID(a Action) types.EntityUID {
+ return types.NewEntityUID("Target", types.String(a.Target.Kind+"/"+a.Target.ID))
+}
+
+func request(ctx context.Context, a Action, extra types.RecordMap) types.Request {
+ cc := types.RecordMap{
+ "effect": types.NewRecord(types.RecordMap{
+ "read_only": types.Boolean(a.Effect.ReadOnly),
+ "reversibility": types.String(reversibilityName(a.Effect.Reversibility)),
+ "summary": types.String(a.Effect.Summary),
+ }),
+ "input": inputValue(a.Input),
+ }
+ maps.Copy(cc, extra)
+ return types.Request{
+ Principal: types.NewEntityUID("Workflow", types.String(runFrom(ctx).Workflow)),
+ Action: types.NewEntityUID("Action", types.String(a.Connector+"::"+a.Name)),
+ Resource: resourceUID(a),
+ Context: types.NewRecord(cc),
+ }
+}
+
+func reversibilityName(r connectors.Reversibility) string {
+ switch r {
+ case connectors.UndoneAutomatically:
+ return "undone_automatically"
+ case connectors.Recoverable:
+ return "recoverable"
+ case connectors.Irreversible:
+ return "irreversible"
+ }
+ return "unspecified"
+}
+
+// verdictContext is what change-request rules read of the guards: the level
+// they reached, whether any guard failed to answer, and each guard's verdict
+// by name.
+func verdictContext(level Level, verdicts []Verdict) types.RecordMap {
+ byGuard := types.RecordMap{}
+ failed := false
+ for _, v := range verdicts {
+ failed = failed || v.Failed != ""
+ byGuard[types.String(v.Guard)] = types.NewRecord(types.RecordMap{
+ "ceiling": types.String(v.Ceiling.String()), "failed": types.Boolean(v.Failed != ""), "advisory": types.Boolean(v.Advisory),
+ })
+ }
+ return types.RecordMap{"level": types.String(level.String()), "guard_failed": types.Boolean(failed), "verdicts": types.NewRecord(byGuard)}
+}
+
+// inputValue converts an action's JSON input to a Cedar record. Cedar has no
+// null or float: null members are left out and a non-integer number is its
+// decimal text.
+func inputValue(in jsontext.Value) types.Value {
+ var v any
+ if len(in) == 0 || json.Unmarshal(in, &v) != nil {
+ return types.NewRecord(nil)
+ }
+ if out, ok := cedarValue(v).(types.Record); ok {
+ return out
+ }
+ return types.NewRecord(types.RecordMap{"value": cedarValue(v)})
+}
+
+func cedarValue(v any) types.Value {
+ switch x := v.(type) {
+ case map[string]any:
+ m := types.RecordMap{}
+ for k, e := range x {
+ if e != nil {
+ m[types.String(k)] = cedarValue(e)
+ }
+ }
+ return types.NewRecord(m)
+ case []any:
+ items := make([]types.Value, 0, len(x))
+ for _, e := range x {
+ if e != nil {
+ items = append(items, cedarValue(e))
+ }
+ }
+ return types.NewSet(items...)
+ case string:
+ return types.String(x)
+ case bool:
+ return types.Boolean(x)
+ case float64:
+ if x == math.Trunc(x) && math.Abs(x) < 1<<53 {
+ return types.Long(int64(x))
+ }
+ return types.String(strconv.FormatFloat(x, 'g', -1, 64))
+ }
+ return types.String(fmt.Sprint(v))
+}
+
+// PolicySetView is one version of a policy set, with every version's number.
+type PolicySetView struct {
+ Version int `json:"version"`
+ Body string `json:"body"`
+ CreatedBy string `json:"created_by"`
+ CreatedAt time.Time `json:"created_at"`
+ Versions []VersionView `json:"versions"`
+}
+
+// VersionView is one stored version of a policy set.
+type VersionView struct {
+ Version int `json:"version"`
+ CreatedBy string `json:"created_by"`
+ CreatedAt time.Time `json:"created_at"`
+}
+
+// View returns a version of a kind's policy set, or the one in force when
+// version is zero.
+func (p *Policies) View(ctx context.Context, kind string, version int) (PolicySetView, error) {
+ row, err := p.current(ctx, kind)
+ if err == nil && version > 0 {
+ row, err = p.store.Policy(ctx, p.orgID, kind, version)
+ }
+ if err != nil {
+ return PolicySetView{}, err
+ }
+ rows, err := p.store.PolicyVersions(ctx, p.orgID, kind)
+ if err != nil {
+ return PolicySetView{}, err
+ }
+ out := PolicySetView{Version: row.Version, Body: row.Body, CreatedBy: row.CreatedBy, CreatedAt: row.CreatedAt}
+ for _, r := range rows {
+ out.Versions = append(out.Versions, VersionView{Version: r.Version, CreatedBy: r.CreatedBy, CreatedAt: r.CreatedAt})
+ }
+ return out, nil
+}
+
+// Put validates body and stores it as the next version of the kind's policy
+// set. A body that doesn't compile changes nothing.
+func (p *Policies) Put(ctx context.Context, kind, body, by string) (PolicySetView, error) {
+ if len(body) > maxPolicyBytes {
+ return PolicySetView{}, fmt.Errorf("%w: at most %d bytes", ErrInvalidPolicy, maxPolicyBytes)
+ }
+ if _, err := parse(kind, body); err != nil {
+ return PolicySetView{}, fmt.Errorf("%w: %w", ErrInvalidPolicy, err)
+ }
+ if _, err := p.current(ctx, kind); err != nil {
+ return PolicySetView{}, err
+ }
+ if _, err := p.store.AddPolicy(ctx, store.PolicySet{ID: uuid.New(), OrgID: p.orgID, Kind: kind, Body: body, CreatedBy: by}); err != nil {
+ return PolicySetView{}, err
+ }
+ return p.View(ctx, kind, 0)
+}
+
+// ErrInvalidPolicy means a policy set didn't compile or didn't fit its kind.
+var ErrInvalidPolicy = errors.New("invalid policy set")
+
+// Routes adds the policy API to mux behind guard.
+func (p *Policies) Routes(mux *http.ServeMux, guard func(http.Handler) http.Handler) {
+ for path, kind := range map[string]string{"/api/policies/hard-rules": KindHardRules, "/api/policies/change-request": KindChangeRequest} {
+ mux.Handle("GET "+path, guard(p.get(kind)))
+ mux.Handle("PUT "+path, guard(p.put(kind)))
+ }
+}
+
+func (p *Policies) get(kind string) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ version := 0
+ if q := r.URL.Query().Get("version"); q != "" {
+ n, err := strconv.Atoi(q)
+ if err != nil || n < 1 {
+ httpjson.Error(w, http.StatusBadRequest, "version is a number")
+ return
+ }
+ version = n
+ }
+ out, err := p.View(r.Context(), kind, version)
+ switch {
+ case errors.Is(err, store.ErrNoPolicySet):
+ httpjson.Error(w, http.StatusNotFound, "no such version")
+ case err != nil:
+ p.log.ErrorContext(r.Context(), "read policies", "kind", kind, "error", err)
+ httpjson.Error(w, http.StatusInternalServerError, "couldn't read the policies")
+ default:
+ httpjson.Write(w, http.StatusOK, out)
+ }
+ })
+}
+
+func (p *Policies) put(kind string) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ var req struct {
+ Body string `json:"body"`
+ }
+ if err := httpjson.Read(r, &req); err != nil {
+ httpjson.Error(w, http.StatusBadRequest, err.Error())
+ return
+ }
+ out, err := p.Put(r.Context(), kind, req.Body, bootstrapAdmin)
+ switch {
+ case errors.Is(err, ErrInvalidPolicy):
+ httpjson.Error(w, http.StatusBadRequest, err.Error())
+ case err != nil:
+ p.log.ErrorContext(r.Context(), "save policies", "kind", kind, "error", err)
+ httpjson.Error(w, http.StatusInternalServerError, "couldn't save the policies")
+ default:
+ httpjson.Write(w, http.StatusOK, out)
+ }
+ })
+}
diff --git a/modules/judgement/policies_test.go b/modules/judgement/policies_test.go
new file mode 100644
index 000000000..f75eab102
--- /dev/null
+++ b/modules/judgement/policies_test.go
@@ -0,0 +1,93 @@
+package judgement
+
+import (
+ "context"
+ "encoding/json/jsontext"
+ "errors"
+ "log/slog"
+ "sync/atomic"
+ "testing"
+
+ "github.com/samcharles93/archie-core/modules/connectors"
+ "github.com/samcharles93/archie-core/modules/judgement/internal/store"
+)
+
+type memoryPolicies struct{ sets map[string][]store.PolicySet }
+
+func (m *memoryPolicies) Policy(_ context.Context, _, kind string, _ int) (store.PolicySet, error) {
+ v := m.sets[kind]
+ if len(v) == 0 {
+ return store.PolicySet{}, store.ErrNoPolicySet
+ }
+ return v[len(v)-1], nil
+}
+
+func (m *memoryPolicies) PolicyVersions(context.Context, string, string) ([]store.PolicySet, error) {
+ return nil, nil
+}
+
+func (m *memoryPolicies) AddPolicy(_ context.Context, p store.PolicySet) (store.PolicySet, error) {
+ p.Version = len(m.sets[p.Kind]) + 1
+ m.sets[p.Kind] = append(m.sets[p.Kind], p)
+ return p, nil
+}
+
+// TestStarterPoliciesDecide guards the policy layer (spec section 5 rule 1,
+// R25): a hard rule refuses before any guard runs and a refusal names the
+// policy; the unknown-impact change-request rule flags a held action for a
+// change request, and only a held one.
+func TestStarterPoliciesDecide(t *testing.T) {
+ prod := connectors.Target{Kind: "host", ID: "h1", Environment: "production"}
+ tests := []struct {
+ name string
+ target connectors.Target
+ effect connectors.Effect
+ guard fixedGuard
+ wantRefused string
+ wantRule string
+ wantLevel Level
+ }{
+ {
+ name: "irreversible in production is refused before any guard", target: prod,
+ effect: connectors.Effect{Reversibility: connectors.Irreversible}, guard: fixedGuard{name: "g", ceiling: ActQuietly},
+ wantRefused: "no-irreversible-in-production", wantLevel: Never,
+ },
+ {
+ name: "irreversible in staging is judged", target: connectors.Target{Kind: "host", ID: "h1", Environment: "staging"},
+ effect: connectors.Effect{Reversibility: connectors.Irreversible}, guard: fixedGuard{name: "g", ceiling: ProposeAndWait},
+ wantLevel: ProposeAndWait,
+ },
+ {
+ name: "unknown impact held goes through a change request", target: prod,
+ effect: connectors.Effect{}, guard: fixedGuard{name: "g", err: errors.New("no evidence")},
+ wantRule: "unknown-impact", wantLevel: ProposeAndWait,
+ },
+ {
+ name: "known impact held needs no change request", target: prod,
+ effect: connectors.Effect{Reversibility: connectors.Recoverable}, guard: fixedGuard{name: "g", ceiling: ProposeAndWait},
+ wantLevel: ProposeAndWait,
+ },
+ {
+ name: "unknown impact that acts quietly needs no change request", target: prod,
+ effect: connectors.Effect{}, guard: fixedGuard{name: "g", ceiling: ActQuietly},
+ wantLevel: ActQuietly,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ var calls atomic.Int32
+ tt.guard.calls = &calls
+ p := &Policies{store: &memoryPolicies{sets: map[string][]store.PolicySet{}}, log: slog.New(slog.DiscardHandler)}
+ m := &Module{rules: []HardRule{p}, changeRules: p, guards: []Guard{tt.guard}}
+ a := Action{Connector: "ssh", Name: "rm", Input: jsontext.Value(`{"path":"/data"}`), Target: tt.target, Effect: tt.effect}
+ d := m.decide(withRun(t.Context(), RunContext{Workflow: "cleanup"}), a)
+ if d.Level != tt.wantLevel || d.RefusedBy != tt.wantRefused || d.ChangeRequestRule != tt.wantRule || d.ChangeRequest != (tt.wantRule != "") {
+ t.Fatalf("decision = level %s, refused by %q, change request %v by %q; want %s, %q, rule %q",
+ d.Level, d.RefusedBy, d.ChangeRequest, d.ChangeRequestRule, tt.wantLevel, tt.wantRefused, tt.wantRule)
+ }
+ if tt.wantRefused != "" && calls.Load() != 0 {
+ t.Fatalf("a guard ran %d times before the hard rule refused", calls.Load())
+ }
+ })
+ }
+}
diff --git a/modules/judgement/starter/change_request.cedar b/modules/judgement/starter/change_request.cedar
new file mode 100644
index 000000000..10079d5d9
--- /dev/null
+++ b/modules/judgement/starter/change_request.cedar
@@ -0,0 +1,8 @@
+// A change-request rule is a permit. It runs after the guards and decides only
+// whether approval goes through a change request.
+@id("unknown-impact")
+permit (principal, action, resource)
+when {
+ context.effect.read_only == false &&
+ (context.effect.reversibility == "unspecified" || context.guard_failed)
+};
diff --git a/modules/judgement/starter/hard_rules.cedar b/modules/judgement/starter/hard_rules.cedar
new file mode 100644
index 000000000..d020d8fcc
--- /dev/null
+++ b/modules/judgement/starter/hard_rules.cedar
@@ -0,0 +1,10 @@
+// A hard rule is a forbid. It runs before any guard on the exact action and
+// target, and nothing overrides it.
+@id("no-irreversible-in-production")
+forbid (principal, action, resource)
+when {
+ resource.environment == "production" &&
+ resource.disposable == false &&
+ context.effect.read_only == false &&
+ context.effect.reversibility == "irreversible"
+};
diff --git a/modules/runs/context.go b/modules/runs/context.go
index c8ca4d07d..50a348c15 100644
--- a/modules/runs/context.go
+++ b/modules/runs/context.go
@@ -87,6 +87,9 @@ func (rc *Context) Begin(ctx context.Context, key string) (bool, error) {
// RunID is the run's id.
func (rc *Context) RunID() uuid.UUID { return rc.run.ID }
+// Workflow is the name of the workflow this run executes.
+func (rc *Context) Workflow() string { return rc.run.Workflow }
+
// OrgID is the organisation the run belongs to.
func (rc *Context) OrgID() string { return rc.run.OrgID }
diff --git a/modules/runs/investigate.go b/modules/runs/investigate.go
index 4f9eb880c..d6e2fd0a0 100644
--- a/modules/runs/investigate.go
+++ b/modules/runs/investigate.go
@@ -389,6 +389,7 @@ func runApproved(rc *Context, judge Judge, d judgement.Decision, answer approval
fresh, err := rc.Step("judge-again:"+d.Key, func(ctx context.Context, key string) (judgement.Decision, error) {
return judge.Assess(ctx, judgement.Request{
RunID: rc.RunID(), Key: key, Connector: d.Action.Connector, Action: d.Action.Name, Input: d.Action.Input,
+ Workflow: rc.Workflow(),
})
})
if err != nil {
@@ -531,7 +532,7 @@ func call(ctx context.Context, box Toolbox, judge Judge, rc *Context, d connecto
// is proposed to a person when the investigation ends, so it comes back to
// the agent as something waiting rather than a failure.
key := core.IdempotencyKey(ctx)
- decision, err := judge.Assess(ctx, judgement.Request{RunID: rc.RunID(), Key: key, Connector: d.Connector, Action: d.Name, Input: input})
+ decision, err := judge.Assess(ctx, judgement.Request{RunID: rc.RunID(), Key: key, Connector: d.Connector, Action: d.Name, Input: input, Workflow: rc.Workflow()})
if err != nil {
return "", err
}
diff --git a/ui/src/archie/ActionTrailView.vue b/ui/src/archie/ActionTrailView.vue
index 95b597d09..b9da711e3 100644
--- a/ui/src/archie/ActionTrailView.vue
+++ b/ui/src/archie/ActionTrailView.vue
@@ -43,6 +43,8 @@ const ceilingTone = (v: Verdict): Tone => (v.failed ? "warn" : "secondary");
{{ decision.action.connector }} {{ decision.action.name }}
{{ target }}
{{ decision.action.effect.Summary }}
diff --git a/ui/src/archie/App.vue b/ui/src/archie/App.vue index b3542d71d..9af0db196 100644 --- a/ui/src/archie/App.vue +++ b/ui/src/archie/App.vue @@ -36,6 +36,7 @@ function signOut() {{{ e.error }}
+