package webui import ( "context" "net/http" "net/http/httptest" "strings" "testing" "github.com/samcharles93/archie-core/internal/domain/access" "github.com/samcharles93/archie-core/internal/domain/identity" "github.com/samcharles93/archie-core/internal/domain/org" "github.com/samcharles93/archie-core/internal/domain/source" "github.com/samcharles93/archie-core/internal/domain/storecontract" "github.com/samcharles93/archie-core/internal/domain/workflow/task" infraaccess "github.com/samcharles93/archie-core/internal/infrastructure/access" ) // operator is the person owner the upgrade creates and the shared-token // session acts as. func operator() access.Principal { return access.Principal{ IdentityID: identity.OperatorID(), Org: org.DefaultOrgID, Memberships: []org.Membership{ {IdentityID: identity.OperatorID(), OrgID: org.DefaultOrgID, Role: org.RoleOwner}, }, } } // stubPrincipals answers the operator's own principal and a bare one for // anyone else. func stubPrincipals(haveOperator bool) access.PrincipalSource { return operatorPrincipals{haveOperator: haveOperator} } type operatorPrincipals struct{ haveOperator bool } func (s operatorPrincipals) PrincipalFor(_ context.Context, id identity.IdentityID) (access.Principal, error) { if s.haveOperator && id == identity.OperatorID() { return operator(), nil } return access.Principal{IdentityID: id, Org: org.DefaultOrgID}, nil } type allowAll struct{} func (allowAll) Authorize(access.Principal, access.Action, access.Resource, access.Context) access.Decision { return access.Allowed() } func (allowAll) Ready() bool { return true } // notReadyChain is an authorizer whose engine has not loaded: every decision // is the not-loaded refusal, which no policy evaluated. type notReadyChain struct{} func (notReadyChain) Authorize(access.Principal, access.Action, access.Resource, access.Context) access.Decision { return access.Unavailable() } func (notReadyChain) Ready() bool { return false } type recordingTokens struct{ owner identity.IdentityID } // AddPersonalToken mirrors the State Store's rule: only a signed-in person's // principal may own a personal token. func (t *recordingTokens) AddPersonalToken(ctx context.Context, _ identity.Subject) error { p, ok := access.PrincipalFromContext(ctx) if !ok || p.IdentityID == identity.SystemID || p.Role("") != org.RoleOwner { return identity.ErrInvalid } t.owner = p.IdentityID return nil } func (*recordingTokens) ListPersonalTokens(context.Context) ([]identity.PersonalToken, error) { return nil, nil } func (*recordingTokens) RevokePersonalToken(context.Context, string) error { return nil } // TestSharedTokenPrincipal pins who the dashboard acts as when no provider // signed anyone in: the org-sys owner person when the upgrade made one, the // system owner otherwise. func TestSharedTokenPrincipal(t *testing.T) { tests := []struct { name string principals access.PrincipalSource want identity.IdentityID }{ {"the operator person owns the shared session", stubPrincipals(true), identity.OperatorID()}, {"with no operator the system owner remains", stubPrincipals(false), identity.SystemID}, {"with no principal source the system owner remains", nil, identity.SystemID}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { s := &Server{Principals: tt.principals} p, err := s.requestPrincipal(t.Context()) if err != nil { t.Fatal(err) } if p.IdentityID != tt.want { t.Fatalf("principal = %q, want %q", p.IdentityID, tt.want) } }) } } // TestSharedTokenOperatorPostsPersonalToken drives the whole dashboard path: // the shared token resolves to the operator, the token route accepts it where // the system principal was refused, and a write's audit names the operator. func TestSharedTokenOperatorPostsPersonalToken(t *testing.T) { tokens := &recordingTokens{} s := &Server{ Token: "shared", Access: allowAll{}, Principals: stubPrincipals(true), PersonalTokens: tokens, } handler := s.requireToken(s.authorize(http.HandlerFunc(s.handlePersonalTokenCreate))) rec := httptest.NewRecorder() req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/api/tokens", nil) req.Header.Set("Authorization", "Bearer shared") handler.ServeHTTP(rec, req) if rec.Code != http.StatusCreated { t.Fatalf("POST /api/tokens = %d, body %s", rec.Code, rec.Body.String()) } if tokens.owner != identity.OperatorID() { t.Fatalf("token owner = %q, want the operator", tokens.owner) } audit, err := webAudit(access.WithPrincipal(t.Context(), operator())) if err != nil { t.Fatal(err) } if audit.ActorID != identity.OperatorID() { t.Fatalf("audit actor = %q, want the operator", audit.ActorID) } } // TestAuthorizeRefusesWithoutAChain pins the gate for a server with no chain // and for a chain that has not loaded: the request is refused rather than // served as the system org, and nothing is written. func TestAuthorizeRefusesWithoutAChain(t *testing.T) { tests := []struct { name string srv *Server method, path, accept string body string }{ {name: "no chain", srv: &Server{}, method: http.MethodPost, path: "/api/tokens"}, {name: "chain not loaded", srv: &Server{Access: notReadyChain{}}, method: http.MethodPost, path: "/api/tokens"}, // An outage is not a credential failure, so the browser notice is 503 // too. {name: "chain not loaded, browser", srv: &Server{Access: notReadyChain{}}, method: http.MethodGet, path: "/tasks", accept: "text/html"}, // The health report still says why, naming only the chain. {name: "chain not loaded, health detail", srv: &Server{Access: notReadyChain{}}, method: http.MethodGet, path: healthDetailedRoute, body: `"name":"access_policies"`}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tokens := &recordingTokens{} tt.srv.Token = "shared" tt.srv.Principals = stubPrincipals(true) tt.srv.PersonalTokens = tokens handler := tt.srv.requireToken(tt.srv.authorize(http.HandlerFunc(func(http.ResponseWriter, *http.Request) { t.Fatal("the handler must not be reached") }))) rec := httptest.NewRecorder() req := httptest.NewRequestWithContext(t.Context(), tt.method, tt.path, nil) req.Header.Set("Authorization", "Bearer shared") if tt.accept != "" { req.Header.Set("Accept", tt.accept) } handler.ServeHTTP(rec, req) if rec.Code != http.StatusServiceUnavailable { t.Fatalf("status = %d, want 503", rec.Code) } if !strings.Contains(rec.Body.String(), tt.body) { t.Fatalf("body = %q, want it to contain %q", rec.Body.String(), tt.body) } if tokens.owner != "" { t.Fatalf("token owner = %q, want no write", tokens.owner) } }) } } func TestAdministrationRoutes(t *testing.T) { tests := []struct { method, path string action access.Action }{ {http.MethodGet, "/api/extensions", access.ActionRead}, {http.MethodPost, "/api/extensions", access.ActionManageIdentities}, {http.MethodPost, "/api/extensions/bws/accept", access.ActionManageIdentities}, {http.MethodPut, "/api/extensions/bws/enabled", access.ActionManageIdentities}, {http.MethodDelete, "/api/extensions/bws", access.ActionDelete}, {http.MethodGet, "/api/access/policies", access.ActionRead}, {http.MethodPut, "/api/access/policies", access.ActionManagePolicies}, {http.MethodDelete, "/api/access/policies", access.ActionManagePolicies}, {http.MethodGet, "/api/schedules", access.ActionRead}, {http.MethodPut, "/api/schedules/nightly", access.ActionManageIdentities}, {http.MethodPost, "/api/schedules/nightly/runs", access.ActionManageIdentities}, {http.MethodDelete, "/api/schedules/nightly", access.ActionDelete}, } for _, tt := range tests { t.Run(tt.method+" "+tt.path, func(t *testing.T) { action, kind, _ := accessRequest(httptest.NewRequestWithContext(t.Context(), tt.method, tt.path, nil)) if action != tt.action || kind != access.KindPolicy { t.Fatalf("accessRequest = %q on %q, want %q on %q", action, kind, tt.action, access.KindPolicy) } }) } } func TestChannelReloadRoute(t *testing.T) { req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/api/channels/telegram/reload", nil) action, kind, key := accessRequest(req) if action != access.ActionManageIdentities || kind != access.KindDashboard || key != "telegram" { t.Fatalf("accessRequest = %q on %q (%q), want %q on %q (telegram)", action, kind, key, access.ActionManageIdentities, access.KindDashboard) } } func TestPersonalTokensWithoutPerson(t *testing.T) { for _, method := range []string{http.MethodGet, http.MethodPost, http.MethodDelete} { t.Run(method, func(t *testing.T) { s := &Server{PersonalTokens: &recordingTokens{}} req := httptest.NewRequestWithContext(access.WithPrincipal(t.Context(), access.SharedTokenOwner()), method, "/api/tokens", nil) rec := httptest.NewRecorder() switch method { case http.MethodGet: s.handlePersonalTokensList(rec, req) case http.MethodPost: s.handlePersonalTokenCreate(rec, req) case http.MethodDelete: s.handlePersonalTokenRevoke(rec, req) } if method == http.MethodGet { if rec.Code != http.StatusOK || !strings.Contains(rec.Body.String(), `"available":false`) { t.Fatalf("list without person = %d %s", rec.Code, rec.Body.String()) } } else if rec.Code != http.StatusForbidden || strings.TrimSpace(rec.Body.String()) != "Personal tokens need a signed-in person." { t.Fatalf("mutation without person = %d %s", rec.Code, rec.Body.String()) } }) } } // sourcesIn serves GetSource, the one read authorization makes: one source // per path, in the workspace it names. type sourcesIn struct { storecontract.SourceStore workspaces map[string]org.WorkspaceID } func (s sourcesIn) GetSource(_ context.Context, path string) (*source.Source, error) { ws, ok := s.workspaces[path] if !ok { return nil, nil } return &source.Source{Path: path, OrgID: org.DefaultOrgID, WorkspaceID: ws}, nil } type principalOf access.Principal func (p principalOf) PrincipalFor(context.Context, identity.IdentityID) (access.Principal, error) { return access.Principal(p), nil } // TestAuthorizeRecord pins that a request for a record is decided in that // record's scope: its workspace's policies and the role held there, and the // record's own object policies. func TestAuthorizeRecord(t *testing.T) { member := func(id identity.IdentityID, role org.Role, workspaces ...org.Membership) access.Principal { return access.Principal{IdentityID: id, Org: org.DefaultOrgID, Memberships: append([]org.Membership{ {IdentityID: id, OrgID: org.DefaultOrgID, Role: role}, }, workspaces...)} } dev := member("dev", org.RoleDeveloper, org.Membership{IdentityID: "dev", OrgID: org.DefaultOrgID, WorkspaceID: "locked", Role: org.RoleViewer}) ops, admin := member("ops", org.RoleAdmin), member("admin", org.RoleAdmin) policies := append(access.ShippedOrgPolicies(org.DefaultOrgID), access.Policy{ ID: "prod-open", Level: access.LevelWorkspace, OrgID: org.DefaultOrgID, WorkspaceID: "prod", Text: `permit(principal, action, resource);`, }, access.Policy{ ID: "prod-frozen", Level: access.LevelWorkspace, OrgID: org.DefaultOrgID, WorkspaceID: "prod", Text: `forbid(principal, action == Archie::Action::"update", resource);`, }, access.Policy{ ID: "ops-reads-it", Level: access.LevelObject, OrgID: org.DefaultOrgID, ObjectKind: access.KindSecret, ObjectID: "in-default", Text: `permit(principal, action, resource) when { principal == Archie::Identity::"ops" };`, }, ) sources := sourcesIn{workspaces: map[string]org.WorkspaceID{ "in-default": org.DefaultWorkspaceID, "in-prod": "prod", "in-locked": "locked", }} tests := []struct { name, method, path string principal access.Principal want int }{ {"the org role edits a default-workspace record", http.MethodPut, "/api/sources/in-default/name", dev, http.StatusOK}, {"a workspace forbid denies the edit there", http.MethodPut, "/api/sources/in-prod/name", dev, http.StatusForbidden}, {"the forbid leaves reads alone", http.MethodGet, "/api/sources/in-prod", dev, http.StatusOK}, {"a workspace viewer role replaces the org developer role", http.MethodPut, "/api/sources/in-locked/name", dev, http.StatusForbidden}, {"the workspace role still reads", http.MethodGet, "/api/sources/in-locked", dev, http.StatusOK}, {"a developer does not read a secret", http.MethodPost, "/api/sources/in-prod/secret", dev, http.StatusForbidden}, {"an admin reads a secret", http.MethodPost, "/api/sources/in-prod/secret", admin, http.StatusOK}, {"an object policy narrows who reads it", http.MethodPost, "/api/sources/in-default/secret", admin, http.StatusForbidden}, {"the reader it names still does", http.MethodPost, "/api/sources/in-default/secret", ops, http.StatusOK}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { s := &Server{Access: infraaccess.New(policies), Principals: principalOf(tt.principal), Sources: sources} handler := s.authorize(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {})) req := httptest.NewRequestWithContext(WithActingIdentity(t.Context(), identity.Identity{ID: tt.principal.IdentityID}), tt.method, tt.path, nil) rec := httptest.NewRecorder() handler.ServeHTTP(rec, req) if rec.Code != tt.want { t.Fatalf("%s %s = %d, want %d", tt.method, tt.path, rec.Code, tt.want) } }) } } // TestAuthorizeCreateIn pins that a create is decided in the workspace its // body names, where the role held there replaces the org role. func TestAuthorizeCreateIn(t *testing.T) { dev := access.Principal{IdentityID: "dev", Org: org.DefaultOrgID, Memberships: []org.Membership{ {IdentityID: "dev", OrgID: org.DefaultOrgID, Role: org.RoleDeveloper}, {IdentityID: "dev", OrgID: org.DefaultOrgID, WorkspaceID: "locked", Role: org.RoleViewer}, }} tests := []struct { name string workspace org.WorkspaceID want int }{ {"the default workspace was decided at the route", "", http.StatusOK}, {"a workspace the org role covers", "open", http.StatusOK}, {"a workspace where the caller is only a viewer", "locked", http.StatusForbidden}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { s := &Server{Access: infraaccess.New(access.ShippedOrgPolicies(org.DefaultOrgID))} req := httptest.NewRequestWithContext(access.WithPrincipal(t.Context(), dev), http.MethodPost, "/api/sources", nil) rec := httptest.NewRecorder() if s.authorizeCreateIn(rec, req, access.KindSource, tt.workspace) { rec.WriteHeader(http.StatusOK) } if rec.Code != tt.want { t.Fatalf("create in %q = %d, want %d", tt.workspace, rec.Code, tt.want) } }) } } type taskAttributesStore struct { storecontract.TaskStore owner, status string } func (s taskAttributesStore) TaskByID(context.Context, int64) (*task.Task, error) { return &task.Task{ID: 7, Identity: s.owner, Status: s.status, Workspace: "default"}, nil } func TestTaskAuthorizationUsesStoredAttributes(t *testing.T) { policy := access.Policy{ID: "owned-queued", Level: access.LevelObject, OrgID: "acme", ObjectKind: access.KindTask, ObjectID: "7", Text: `permit(principal,action,resource) when {resource.owner == "alice" && resource.state == "queued"};`} p := access.Principal{IdentityID: "alice", Org: "acme", Memberships: []org.Membership{{IdentityID: "alice", OrgID: "acme", Role: org.RoleDeveloper}}} for _, tc := range []struct { name, owner, state string want int }{ {"owned queued task", "alice", "queued", 200}, {"other owner", "bob", "queued", 403}, {"different state", "alice", "running", 403}, } { t.Run(tc.name, func(t *testing.T) { srv := &Server{Store: taskAttributesStore{owner: tc.owner, status: tc.state}, Access: infraaccess.New(append(access.ShippedOrgPolicies("acme"), policy)), Principals: principalOf(p)} req := httptest.NewRequestWithContext(WithActingIdentity(t.Context(), identity.Identity{ID: "alice"}), "PUT", "https://archie.example/api/tasks/7", strings.NewReader(`{"owner":"alice","state":"queued"}`)) rec := httptest.NewRecorder() srv.authorize(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {})).ServeHTTP(rec, req) if rec.Code != tc.want { t.Fatalf("status=%d want=%d body=%s", rec.Code, tc.want, rec.Body.String()) } }) } }