Files
archie/internal/domain/access/request.go
T

153 lines
5.6 KiB
Go

package access
import (
"context"
"time"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/org"
)
// The Cedar vocabulary every policy and every assembled entity shares. A
// policy naming an unknown type, action or attribute is refused when it is
// saved and denied at every start (the engine's validation).
const (
// Namespace prefixes every Cedar entity type the engine assembles.
Namespace = "Archie"
// EntityTypeIdentity is the principal: an Archie identity.
EntityTypeIdentity = Namespace + "::Identity"
// EntityTypeOrg is the org a resource belongs to.
EntityTypeOrg = Namespace + "::Org"
// EntityTypeWorkspace is the workspace a resource belongs to.
EntityTypeWorkspace = Namespace + "::Workspace"
// EntityTypeObject is the resource acted on. Every record -- source,
// binding, workflow, secret, task, the org itself -- is one Object
// entity carrying its kind, so a policy can scope on
// `resource.kind == Archie::Kind::"binding"` without a type per record.
EntityTypeObject = Namespace + "::Object"
// EntityTypeAction is the action entity of a request, one per Action.
EntityTypeAction = Namespace + "::Action"
// AttributeOrg is the org ID an identity or object carries.
AttributeOrg = "org"
// AttributeRole is the principal's effective role for the resource
// (workspace membership role when one exists, else its org-wide role).
AttributeRole = "role"
// AttributeKind is an object's resource kind.
AttributeKind = "kind"
// AttributeOwner is the ID of the identity that owns an object.
AttributeOwner = "owner"
// AttributeState is an object's state (binding's draft/armed, task's
// status, and so on), as the caller that assembles the request sees it.
AttributeState = "state"
)
// Principal is who acts: an identity, with the memberships that give it
// roles. The org is the one the identity serves (org.Repository's
// OrgForIdentity); Memberships carries its org-wide and workspace roles.
type Principal struct {
IdentityID identity.IdentityID
Kind identity.Kind
Org org.OrgID
Memberships []org.Membership
}
// Role returns the principal's effective role for a resource: the role of
// its membership in the resource's workspace when it holds one, else the
// role of its org-wide membership, else the empty string (no role, which
// the shipped role policies never permit).
func (p Principal) Role(ws org.WorkspaceID) org.Role {
var orgRole org.Role
for _, m := range p.Memberships {
if m.OrgID != p.Org {
continue
}
if m.WorkspaceID == "" {
orgRole = m.Role
}
if m.WorkspaceID == ws {
return m.Role
}
}
return orgRole
}
// Resource is the record acted on: its type, its workspace and org as
// parents, its owner and its state.
type Resource struct {
Kind ResourceKind
// ID is the record's caller-facing key: a source's path, a binding's
// ID, an org's ID, a workflow's name.
ID string
// Org is the org the record belongs to. Empty means the principal's own
// org, which is how a create request names a resource that does not
// exist yet.
Org org.OrgID
// Workspace is the workspace the record belongs to, empty for
// org-owned records.
Workspace org.WorkspaceID
Owner identity.IdentityID
State string
}
// Context is what was going on when the decision was asked for.
type Context struct {
// Signature is the event's signature result ("valid", "unsigned", ...).
Signature string
// Addr is the address the event came from.
Addr string
// Time is when the request was made; zero means now.
Time time.Time
// Run and Step identify the run and step when the principal is an agent.
Run string
Step string
}
// Decision is the outcome of one Authorize call. When the request is denied,
// Level names the level that decided and Policies the IDs of the deciding
// policies at that level, so a denial record can name them.
type Decision struct {
Allowed bool
Level Level
Policies []string
// Err carries the engine failure behind a deny-all level: a stored
// policy that no longer parses. A denied request with Err set was never
// evaluated -- the level refuses everything rather than decide.
Err error
}
// Allowed is the shared permit decision: no level denied.
func Allowed() Decision { return Decision{Allowed: true} }
// DeniedAt records a denial decided at a level by the given policies.
func DeniedAt(level Level, policies []string) Decision {
return Decision{Level: level, Policies: policies}
}
// PrincipalSource assembles the principal for one identity: the org it
// serves and its memberships. The State Store implements it (the memberships
// live in the State Store); the dashboard and dispatch call it over the wire.
type PrincipalSource interface {
// PrincipalFor returns the assembled principal. An identity in no org
// resolves to the default org, a principal with no role, which no
// shipped policy permits.
PrincipalFor(ctx context.Context, id identity.IdentityID) (Principal, error)
}
// Denial is one recorded refusal: who was refused, doing what, to what, by
// which level and which policies.
type Denial struct {
Principal identity.IdentityID `json:"principal"`
Org org.OrgID `json:"org"`
Action Action `json:"action"`
Kind ResourceKind `json:"kind"`
ResourceID string `json:"resource"`
Level Level `json:"level"`
Policies []string `json:"policies"`
At time.Time `json:"at"`
// Count is how many identical denials this record stands for. The store
// coalesces identical denials within a minute into one row with a count.
Count int64 `json:"count"`
}