Add backend support for scope allowlists on admin-created OAuth2 apps, previously available only through DCR. - Add optional, space-separated `scope` to create/update requests and return canonicalized, deduplicated scopes in app responses. - On create, omitted or empty `scope` means unrestricted. On update, `scope` replaces the allowlist; omission preserves it, and an empty string clears it to unrestricted. - Keep scope enforcement unchanged. Add tests for scope round-trips, DCR canonicalization parity, and authorization narrowing. - Include generated SDK and docs updates. The UI scope picker follows in a separate PR. Part of [PLAT-475](https://linear.app/codercom/issue/PLAT-475).
433 lines
14 KiB
Go
433 lines
14 KiB
Go
package rbac_test
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/coder/coder/v2/coderd/rbac"
|
|
"github.com/coder/coder/v2/coderd/rbac/policy"
|
|
)
|
|
|
|
func TestExpandScope(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
t.Run("low_level_pairs", func(t *testing.T) {
|
|
t.Parallel()
|
|
cases := []struct {
|
|
name string
|
|
resource string
|
|
action policy.Action
|
|
}{
|
|
{name: "workspace:start", resource: rbac.ResourceWorkspace.Type, action: policy.ActionWorkspaceStart},
|
|
{name: "workspace:ssh", resource: rbac.ResourceWorkspace.Type, action: policy.ActionSSH},
|
|
{name: "template:use", resource: rbac.ResourceTemplate.Type, action: policy.ActionUse},
|
|
{name: "api_key:read", resource: rbac.ResourceApiKey.Type, action: policy.ActionRead},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
s, err := rbac.ScopeName(tc.name).Expand()
|
|
require.NoError(t, err)
|
|
|
|
// site-only single permission
|
|
require.Len(t, s.Site, 1)
|
|
require.Equal(t, tc.resource, s.Site[0].ResourceType)
|
|
require.Equal(t, tc.action, s.Site[0].Action)
|
|
require.Empty(t, s.ByOrgID)
|
|
require.Empty(t, s.User)
|
|
|
|
require.Equal(t, []rbac.AllowListElement{rbac.AllowListAll()}, s.AllowIDList)
|
|
})
|
|
}
|
|
})
|
|
|
|
t.Run("invalid_low_level", func(t *testing.T) {
|
|
t.Parallel()
|
|
invalid := []string{
|
|
"", // empty
|
|
"workspace:", // missing action
|
|
":read", // missing resource
|
|
"unknown:read", // unknown resource
|
|
"workspace:bogus", // unknown action
|
|
"a:b:c", // too many parts
|
|
}
|
|
for _, name := range invalid {
|
|
t.Run(name, func(t *testing.T) {
|
|
t.Parallel()
|
|
_, err := rbac.ScopeName(name).Expand()
|
|
require.Error(t, err)
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestFirstScopeNotCovered(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
allowed []rbac.ScopeName
|
|
requested []rbac.ScopeName
|
|
want rbac.ScopeName
|
|
// wantErrContains names the side that could not be expanded, as in
|
|
// TestScopesCover.
|
|
wantErrContains string
|
|
}{
|
|
{
|
|
name: "EmptyRequestIsCovered",
|
|
allowed: []rbac.ScopeName{"workspace:read"},
|
|
requested: nil,
|
|
},
|
|
{
|
|
name: "EveryRequestedScopeCovered",
|
|
allowed: []rbac.ScopeName{"coder:workspaces.access"},
|
|
requested: []rbac.ScopeName{"workspace:read", "workspace:ssh"},
|
|
},
|
|
{
|
|
// The answer names which scope failed, not merely that one did.
|
|
name: "NamesTheFirstUncovered",
|
|
allowed: []rbac.ScopeName{"coder:workspaces.access"},
|
|
requested: []rbac.ScopeName{"workspace:read", "workspace:delete", "user_secret:delete"},
|
|
want: "workspace:delete",
|
|
},
|
|
{
|
|
name: "UnexpandableRequestedScopeNamed",
|
|
allowed: []rbac.ScopeName{"coder:workspaces.access"},
|
|
requested: []rbac.ScopeName{"workspace:read", "not_a_real_scope"},
|
|
want: "not_a_real_scope",
|
|
wantErrContains: "expand requested scope",
|
|
},
|
|
{
|
|
name: "UnexpandableAllowedScopeNamed",
|
|
allowed: []rbac.ScopeName{"not_a_real_scope"},
|
|
requested: []rbac.ScopeName{"workspace:read"},
|
|
want: "not_a_real_scope",
|
|
wantErrContains: "expand allowed scope",
|
|
},
|
|
{
|
|
// The alias validates but is not an expandable name, so callers
|
|
// must canonicalize first. Pinned because the allowed side is
|
|
// expanded once now, outside the per-scope loop.
|
|
name: "LegacyAliasIsNotExpandable",
|
|
allowed: []rbac.ScopeName{"all"},
|
|
requested: []rbac.ScopeName{"workspace:read"},
|
|
want: "all",
|
|
wantErrContains: "expand allowed scope",
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got, err := rbac.FirstScopeNotCovered(test.allowed, test.requested)
|
|
if test.wantErrContains != "" {
|
|
require.ErrorContains(t, err, test.wantErrContains)
|
|
require.Equal(t, test.want, got, "an undecidable comparison must name the scope it could not decide")
|
|
return
|
|
}
|
|
require.NoError(t, err)
|
|
require.Equal(t, test.want, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
// The two answer the same question, so a row that disagrees means one of them
|
|
// changed alone.
|
|
func TestFirstScopeNotCoveredAgreesWithScopesCover(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
allowed := []rbac.ScopeName{"coder:workspaces.access", "coder:templates.build"}
|
|
for _, name := range rbac.ExternalScopeNames() {
|
|
canonical := rbac.CanonicalScopeName(rbac.ScopeName(name))
|
|
covered, err := rbac.ScopesCover(allowed, canonical)
|
|
require.NoError(t, err, "scope %q", name)
|
|
|
|
outside, err := rbac.FirstScopeNotCovered(allowed, []rbac.ScopeName{canonical})
|
|
require.NoError(t, err, "scope %q", name)
|
|
require.Equal(t, covered, outside == "", "scope %q", name)
|
|
}
|
|
}
|
|
|
|
func TestScopesCover(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
allowed []rbac.ScopeName
|
|
requested rbac.ScopeName
|
|
want bool
|
|
// wantErrContains names the side that could not be expanded. Asserting
|
|
// the side keeps rows that fail through different paths from passing
|
|
// on each other's errors.
|
|
wantErrContains string
|
|
}{
|
|
{
|
|
name: "IdenticalName",
|
|
allowed: []rbac.ScopeName{"workspace:read"},
|
|
requested: "workspace:read",
|
|
want: true,
|
|
},
|
|
{
|
|
// Name matching alone cannot decide this: coder:workspaces.access
|
|
// never mentions workspace:ssh by name, but its expansion covers it.
|
|
name: "CompositeCoversItsMember",
|
|
allowed: []rbac.ScopeName{"coder:workspaces.access"},
|
|
requested: "workspace:ssh",
|
|
want: true,
|
|
},
|
|
{
|
|
// The composite grants no permission on this resource at all.
|
|
name: "CompositeDoesNotCoverUnrelatedResource",
|
|
allowed: []rbac.ScopeName{"coder:workspaces.access"},
|
|
requested: "user_secret:delete",
|
|
want: false,
|
|
},
|
|
{
|
|
// Same resource, action the composite does not grant. Coverage
|
|
// compares the pair, not the resource alone.
|
|
name: "CompositeDoesNotCoverUngrantedActionOnSameResource",
|
|
allowed: []rbac.ScopeName{"coder:workspaces.access"},
|
|
requested: "workspace:delete",
|
|
want: false,
|
|
},
|
|
{
|
|
name: "AllCoversEverything",
|
|
allowed: []rbac.ScopeName{rbac.ScopeAll},
|
|
requested: "user_secret:delete",
|
|
want: true,
|
|
},
|
|
{
|
|
name: "NarrowScopeDoesNotCoverAll",
|
|
allowed: []rbac.ScopeName{"workspace:read"},
|
|
requested: rbac.ScopeAll,
|
|
want: false,
|
|
},
|
|
{
|
|
name: "ResourceWildcardCoversOneAction",
|
|
allowed: []rbac.ScopeName{"workspace:*"},
|
|
requested: "workspace:ssh",
|
|
want: true,
|
|
},
|
|
{
|
|
name: "OneActionDoesNotCoverResourceWildcard",
|
|
allowed: []rbac.ScopeName{"workspace:ssh"},
|
|
requested: "workspace:*",
|
|
want: false,
|
|
},
|
|
{
|
|
// A composite is covered only when every permission it expands
|
|
// to is granted, so a strict subset of them is not enough.
|
|
name: "PartialUnionDoesNotCoverComposite",
|
|
allowed: []rbac.ScopeName{"template:read", "file:create"},
|
|
requested: "coder:templates.build",
|
|
want: false,
|
|
},
|
|
{
|
|
// The allowed side is a union rather than a set of independent
|
|
// candidates, so one composite's permissions may be drawn from
|
|
// several allowed entries at once.
|
|
name: "UnionOfAllowedScopesCoversComposite",
|
|
allowed: []rbac.ScopeName{"template:read", "file:*", "provisioner_jobs:read"},
|
|
requested: "coder:templates.build",
|
|
want: true,
|
|
},
|
|
{
|
|
name: "EmptyAllowedCoversNothing",
|
|
allowed: nil,
|
|
requested: "workspace:read",
|
|
want: false,
|
|
},
|
|
{
|
|
// Not a false: a caller cannot distinguish "known and not
|
|
// covered" from "we could not tell", so an undecidable
|
|
// comparison is surfaced rather than answered.
|
|
name: "UnknownRequestedScopeErrors",
|
|
allowed: []rbac.ScopeName{rbac.ScopeAll},
|
|
requested: "not_a_real_scope",
|
|
wantErrContains: "expand requested scope",
|
|
},
|
|
{
|
|
name: "UnknownAllowedScopeErrors",
|
|
allowed: []rbac.ScopeName{"not_a_real_scope"},
|
|
requested: "workspace:read",
|
|
wantErrContains: "expand allowed scope",
|
|
},
|
|
{
|
|
// An implementation answering on the first match never reaches it.
|
|
name: "UnknownAllowedScopeErrorsBesideCoveringScope",
|
|
allowed: []rbac.ScopeName{rbac.ScopeAll, "not_a_real_scope"},
|
|
requested: "workspace:read",
|
|
wantErrContains: "expand allowed scope",
|
|
},
|
|
{
|
|
// The aliases IsExternalScope accepts are not expandable names,
|
|
// so callers must canonicalize before asking about coverage.
|
|
name: "NonCanonicalAliasErrorsRequestedAll",
|
|
allowed: []rbac.ScopeName{rbac.ScopeAll},
|
|
requested: "all",
|
|
wantErrContains: "expand requested scope",
|
|
},
|
|
{
|
|
name: "NonCanonicalAliasErrorsRequestedApplicationConnect",
|
|
allowed: []rbac.ScopeName{rbac.ScopeAll},
|
|
requested: "application_connect",
|
|
wantErrContains: "expand requested scope",
|
|
},
|
|
{
|
|
// The only row that would catch someone canonicalizing inside the
|
|
// allowed loop, which would silently widen what an allow list
|
|
// accepts without any caller asking for it.
|
|
name: "NonCanonicalAliasErrorsAllowedApplicationConnect",
|
|
allowed: []rbac.ScopeName{"application_connect"},
|
|
requested: rbac.ScopeApplicationConnect,
|
|
wantErrContains: "expand allowed scope",
|
|
},
|
|
{
|
|
name: "NonCanonicalAliasErrorsAllowedAll",
|
|
allowed: []rbac.ScopeName{"all"},
|
|
requested: rbac.ScopeAll,
|
|
wantErrContains: "expand allowed scope",
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got, err := rbac.ScopesCover(test.allowed, test.requested)
|
|
if test.wantErrContains != "" {
|
|
require.ErrorContains(t, err, test.wantErrContains)
|
|
require.False(t, got, "an undecided comparison must not report coverage")
|
|
return
|
|
}
|
|
require.NoError(t, err)
|
|
require.Equal(t, test.want, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestCanonicalScopeName pins the alias mapping. Without it the two case arms
|
|
// could be swapped, so that requesting `all` persisted application_connect and
|
|
// the reverse, and the suite would stay green.
|
|
func TestCanonicalScopeName(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
require.Equal(t, rbac.ScopeAll, rbac.CanonicalScopeName("all"))
|
|
require.Equal(t, rbac.ScopeApplicationConnect, rbac.CanonicalScopeName("application_connect"))
|
|
|
|
// Canonical names and low-level names are returned unchanged, so callers
|
|
// can canonicalize unconditionally.
|
|
require.Equal(t, rbac.ScopeAll, rbac.CanonicalScopeName(rbac.ScopeAll))
|
|
require.Equal(t, rbac.ScopeApplicationConnect, rbac.CanonicalScopeName(rbac.ScopeApplicationConnect))
|
|
require.Equal(t, rbac.ScopeName("workspace:read"), rbac.CanonicalScopeName("workspace:read"))
|
|
require.Equal(t, rbac.ScopeName("not_a_real_scope"), rbac.CanonicalScopeName("not_a_real_scope"))
|
|
}
|
|
|
|
// TestCanonicalScopeList pins the display form of a stored allowlist.
|
|
func TestCanonicalScopeList(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
cases := []struct {
|
|
name string
|
|
raw string
|
|
want string
|
|
}{
|
|
{name: "empty", raw: "", want: ""},
|
|
// Whitespace-only is a configured allowlist that grants nothing, so it
|
|
// must not read back as the empty, unrestricted value.
|
|
{name: "whitespace_only", raw: " \t\n ", want: " \t\n "},
|
|
{name: "single", raw: "workspace:read", want: "workspace:read"},
|
|
{
|
|
name: "aliases_rewritten",
|
|
raw: "all application_connect",
|
|
want: "coder:all coder:application_connect",
|
|
},
|
|
{
|
|
name: "alias_and_canonical_collapse",
|
|
raw: "all coder:all application_connect coder:application_connect",
|
|
want: "coder:all coder:application_connect",
|
|
},
|
|
{
|
|
name: "duplicates_keep_first_seen_order",
|
|
raw: "template:read workspace:read template:read workspace:read",
|
|
want: "template:read workspace:read",
|
|
},
|
|
{
|
|
name: "unknown_names_kept",
|
|
raw: "workspace:read not_a_real_scope workspace:read not_a_real_scope",
|
|
want: "workspace:read not_a_real_scope",
|
|
},
|
|
{
|
|
name: "extra_whitespace_normalized",
|
|
raw: " workspace:read\t\ntemplate:read ",
|
|
want: "workspace:read template:read",
|
|
},
|
|
}
|
|
|
|
for _, test := range cases {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
require.Equal(t, test.want, rbac.CanonicalScopeList(test.raw))
|
|
})
|
|
}
|
|
|
|
// A large list of distinct names must come back intact and in order.
|
|
t.Run("large_distinct_list", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
raw := distinctScopeList(100_000)
|
|
|
|
got := rbac.CanonicalScopeList(raw)
|
|
require.Equal(t, raw, got)
|
|
|
|
// A repeated list collapses onto the first copy.
|
|
got = rbac.CanonicalScopeList(raw + " " + raw)
|
|
require.Equal(t, raw, got)
|
|
})
|
|
}
|
|
|
|
// distinctScopeList returns count distinct unknown names, space separated.
|
|
func distinctScopeList(count int) string {
|
|
names := make([]string, 0, count)
|
|
for i := range count {
|
|
names = append(names, fmt.Sprintf("unknown:%d", i))
|
|
}
|
|
return strings.Join(names, " ")
|
|
}
|
|
|
|
// BenchmarkCanonicalScopeList measures a list of many distinct names, the
|
|
// input that made the dedupe quadratic before it used a set.
|
|
func BenchmarkCanonicalScopeList(b *testing.B) {
|
|
raw := distinctScopeList(100_000)
|
|
for b.Loop() {
|
|
_ = rbac.CanonicalScopeList(raw)
|
|
}
|
|
}
|
|
|
|
// TestScopesCoverEveryExternalScope asserts the property the OAuth2 allowlist
|
|
// check depends on: coder:all is a ceiling over the whole external catalog, and
|
|
// every catalog name covers itself. A name that cannot be compared at all would
|
|
// otherwise reject every request naming it, which is a rejection no app owner
|
|
// could act on.
|
|
func TestScopesCoverEveryExternalScope(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// The aliases inherit this without being named here: TestScopeAliases pins
|
|
// that each one canonicalizes to a name this list offers.
|
|
for _, name := range rbac.ExternalScopeNames() {
|
|
scope := rbac.ScopeName(name)
|
|
|
|
covered, err := rbac.ScopesCover([]rbac.ScopeName{rbac.ScopeAll}, scope)
|
|
require.NoErrorf(t, err, "coder:all vs %q", scope)
|
|
require.Truef(t, covered, "coder:all must cover %q", scope)
|
|
|
|
covered, err = rbac.ScopesCover([]rbac.ScopeName{scope}, scope)
|
|
require.NoErrorf(t, err, "%q vs itself", scope)
|
|
require.Truef(t, covered, "%q must cover itself", scope)
|
|
}
|
|
}
|