Skip to content

fix!: authenticate confidential clients at OAuth2 token revocation - #29208

Merged
BobbyHo merged 186 commits into
mainfrom
coder-plat-507-revoke-client-auth
Sep 16, 2026
Merged

BobbyHo merged 186 commits into
mainfrom
coder-plat-507-revoke-client-auth

Conversation

@BobbyHo

@BobbyHo BobbyHo commented Sep 11, 2026

Copy link
Copy Markdown
Collaborator

TL;DR

Third of three for SEC-348. The revocation endpoint read client_secret and never checked it. Anyone holding a token value and the app's public client_id could revoke that token, ending another client's session. RFC 7009 section 2.1 has the server validate the client's credentials first and only then check that the token belongs to it. The ownership check exists; this is the authentication half. Closes PLAT-507 (CDR-59).

PR What it does
#29206 Extracts the secret check into a helper.
#29207 The refresh grant calls it.
this The revocation endpoint calls it, accepts HTTP Basic, and the SDK method can send a secret.
  • No migration, no new error codes. The endpoint had no docs; it has a section now.
  • Breaking, twice. A confidential client revoking without its secret, or with a wrong one, now gets 401 and nothing is revoked. Sending the secret, as a form field or as HTTP Basic, succeeds. Public clients are unaffected. Separately, codersdk.RevokeOAuth2Token gains a clientSecret parameter, so Go callers must pass one (empty for public clients).

Implementation Details

The check

  • RevokeToken calls authenticateClient for confidential clients after the form is parsed and before the token is classified. Failure answers 401 invalid_client with WWW-Authenticate, and is logged at warn with the app id and nothing from the body.
  • Ordering follows the RFC's own sentence. It also means an unauthenticated caller learns nothing about the token it presents: 401 either way, never the 200 an unknown token would otherwise get.
  • The ownership checks in both revoke branches are unchanged. An authenticated client that presents another app's token still gets the silent 200 RFC 7009 section 2.2 requires.

HTTP Basic

  • The revocation parser only read form fields. The middleware accepted the Basic username as client_id, so Basic appeared to work because the password was never examined.
  • Coder's own MCP client revokes with Basic. Requiring the secret without reading Basic would have broken the one first-party caller that already does this correctly.
  • The parser now calls mergeBasicClientAuth from refactor(coderd/oauth2provider): extract OAuth2 client authentication helpers #29206. A header and body that disagree answer 400, with the token endpoint's wording.

The SDK

  • RevokeOAuth2Token sent only client_id. Its comment said the middleware handled client authentication, which is the belief behind this bug. It now takes a secret and the comment says what the handler expects.
  • All existing callers are tests. The public-client ones pass an empty string.

Docs

Tests
  • TestOAuth2ProviderRevokeClientAuthentication: missing secret, wrong secret, another app's valid secret, missing secret with an unknown token (401, not 200), correct secret, Basic, Basic with a wrong secret, Basic and body in conflict. Each refusal also checks the session still works.
  • TestOAuth2ProviderRevokeCrossApp and TestOAuth2CoderClient now pass the secret. The cross-app case authenticates the other app as itself, so the ownership check is still what refuses it.
  • TestOAuth2NoStoreHeaders/Revoke checks the new 401 carries Cache-Control: no-store before checking the 200 does.
  • Unchanged and still passing: the public client revocation in TestOAuth2ProviderPublicClientTokenLifecycle, and the management API's TestOAuth2ProviderRevoke, which is a different endpoint.

Stack: #28752, #29206, #29207, this PR.

BobbyHo and others added 30 commits August 14, 2026 17:02
Add ScopesCover, which reports whether every permission a requested scope
grants is also granted by at least one of a set of allowed scopes. It
expands both sides and compares the resulting permissions, so
coder:workspaces.access covers workspace:read even though it never names
it, and coder:all covers everything.

The comparison is deliberately asymmetric. Positive permissions on the
allowed side that it does not model are dropped, which can only make the
answer stricter. Anything unmodelled on the requested side is an error
instead, because ignoring it would answer "covered" about authority that
was never compared. Negative permissions are the exception and fail closed
on both sides, since dropping an anti-grant from the ceiling would widen
it rather than narrow it.

Add CanonicalScopeName, which maps the backward-compatibility aliases
IsExternalScope accepts onto the names the api_key_scope enum stores.
IsExternalScope answers whether a name may be requested, not how that name
is spelled once persisted, so a caller that stores what it validated has
to canonicalize in between.

Both functions are added without production callers. The OAuth2 authorize
endpoint uses them to negotiate a requested scope against an app's
configured allowlist, which follows in a separate change.
State the rule the guards enforce, site-level grants only, instead of
describing the asymmetry abstractly. The allow-list case is now covered
alongside negative permissions, which the previous wording omitted even
though the code treats them identically.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
ScopesCover checked the requested scope for org and user grants but not
the allowed scopes, whose User and ByOrgID permissions were discarded
unread. A scope granting workspace:* at site level while negating
workspace:delete for the user would have covered a request for
workspace:delete, because the negative that carves the action back out
lives in the half coverage never examined.

No catalog scope populates those fields today, so nothing was
miscompared in practice. The gap mattered because these guards exist to
keep the comparison fail-closed, and this one failed open.

Both sides now run the same checkCoverable helper, which refuses a scope
carrying org or user grants, a negative permission, or a resource allow
list. The helper names the side, so an error reports which half of the
comparison was undecidable. The doc comment claimed an unmodeled grant
on the allowed side is dropped; nothing is dropped now, so it is gone.

ScopesCover builds every Scope it reads from ExpandScope, which cannot
produce these shapes, so the guards are unreachable through the public
API. scopes_internal_test.go drives synthetic Scope values through
checkCoverable instead.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
permissionCovered skipped negative permissions, but checkCoverable now
refuses a scope carrying one on either side, so the branch was dead. It
was never defense in depth. Had a negative reached it, skipping the
anti-grant would leave any wildcard beside it free to match, and a scope
granting workspace:* while negating workspace:delete would report
workspace:delete as covered. The skip widened the ceiling while looking
like it narrowed it.

The precondition moves to the doc comment, which names checkCoverable as
what enforces it and says why subsumption cannot answer the question an
anti-grant poses.

No behavior change: the branch was unreachable. permissionCovered goes
from 88.9% to 100% statement coverage.
Five review findings on the coverage tests, all in scopes_test.go.

CanonicalScopeName had both alias arms at zero coverage. Its only caller
in the tests loops over ExternalScopeNames, which yields canonical names
only, so the canonicalizing call returned its input unchanged on every
iteration and read as coverage without being any. Swapping the arms, so
that `all` persisted application_connect and the reverse, kept the suite
green. TestCanonicalScopeName now pins the mapping and the loop appends
the aliases, taking the function from 50% to 100%.

The appended aliases raise branch coverage and assert a requestable name
is comparable once canonicalized, but they cannot detect a swapped
mapping, since both aliases resolve to scopes that cover themselves. The
comment says so rather than implying the loop guards more than it does.

CompositeDoesNotCoverNonMember and
CompositeDoesNotCoverWiderActionOnCoveredResource both asked for an
ungranted action on a resource coder:workspaces.access does grant, so
they tested one branch twice and left "resource not granted at all"
untested. They are now split along that line, with names that describe
which failure each one is.

The three wantErr rows shared a bare require.Error, so any error passed
any row and a bug failing every input on the requested side would have
left the allowed-side row green. wantErrContains replaces the bool and
names the side. Rewording the allowed-side message as the requested-side
one now fails three rows that previously all passed.

Alias rejection was tested for one alias on one side. Both aliases are
now tested on both sides. The allowed-side rows are the ones that earn
their place: they are what would catch someone canonicalizing inside the
allowed loop and widening the contract without a caller asking.
ScopesCover expanded and compared in a single pass, so the invariant
guards only ever ran on scopes ExpandScope had produced. Every such scope
satisfies them, which left the guards unverified in the position that
matters: the existing test called checkCoverable directly and could not
tell whether ScopesCover consulted it on both sides, or at all.

Split the comparison into scopesCoverExpanded, which takes already
expanded scopes paired with the names they came from. Tests drive
synthetic Scope values through it, so dropping the guard from either side
now fails, as does an allowed scope that grants every workspace action
except delete answering a request for delete.

Expanding every allowed scope before any guard runs reorders two error
paths against each other: a requested scope that fails a guard alongside
an unknown allowed name now reports the expansion failure rather than the
guard failure. Both return (false, error), and no ScopeName reaches that
combination today.
…ontract

The knowledge of which spellings are backward-compatibility aliases lived
in two switches, one in IsExternalScope and one in CanonicalScopeName,
kept in step by discipline. Drift between them is asymmetric: a name the
first accepts and the second does not rewrite is declared public and then
fails to expand on every request naming it. Both now read one table, so
they agree by construction, and an internal test walks that table
asserting each alias is public, resolves to a public name, and resolves
to one ExpandScope accepts. A third alias is covered the day it is added.

ScopesCover stated "names must be canonical" in prose only, which is
wrong for exactly the two inputs IsExternalScope accepts and ExpandScope
does not. The parameters are now canonicalAllowed and canonicalRequested,
so the requirement shows up in editor hints at every call site rather
than only in a doc comment the caller may not have opened.

Naming the parameters was chosen over canonicalizing inside ScopesCover.
The single downstream caller already canonicalizes both sides in bulk
before comparing, so absorbing the step would remove nothing from it
while dissolving the distinction between a public spelling and a stored
one at the layer that should hold it.
…roken

The site-only, wildcard-allow-list, no-negatives invariant was described
on ScopesCover and enforced by its guards, but ExpandScope, which is what
produces those values, had no doc comment at all. Someone adding a scope
reads ExpandScope and its neighbors; nothing there warned that populating
User or adding a negative makes the scope uncomparable. State it there,
along with the canonicalization requirement, and name the consequence
rather than just the rule.

Also note on ScopesCover that a wildcard request needs a wildcard grant.
Enumerating today's concrete actions genuinely is narrower than
`workspace:*`, so the rejection is intended. The
OneActionDoesNotCoverResourceWildcard row already pins the behavior; the
note stops the next reader of an authorize endpoint from taking it for a
bug and closing the gap.

Comments only. Checked that the documented invariant actually holds for
all three builtin scopes and all seven composites.
TestScopesCoverAllowedNegativeDoesNotWiden drove the same scope shape as
the NegativeUserPermission row of TestScopesCoverGuards, but asserted only
that some error came back. The row asserts the message, the side it names,
and that the comparison reports no coverage, and it runs the shape on both
sides rather than one. The weaker copy could pass on a regression that
returned the wrong error or stopped naming the side. Fold the scenario it
documented into the row's comment and drop the copy.

Rename the shared permission fixtures after the value they hold. The site
prefix read as "belongs in Role.Site", while two of the three are placed in
Role.User to build the shapes the guards refuse, and the No suffix gave no
hint that it means Negate.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The allowed-side wrap printed the scope name and then wrapped an error that
prints it again, so the two sides of one comparison read differently:

  expand allowed scope "foo": no scope named "foo"
  expand requested scope: no scope named "foo"

Drop the redundant verb and let the inner error carry the name on both
sides.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The docstring said the list includes the `all` and `application_connect`
special scopes. It appends ScopeAll and ScopeApplicationConnect, which are
the `coder:` spellings, so the bare aliases are absent. Two callers already
compensate by appending them by hand, one of them with a comment stating
the mismatch. Describe what the function returns and name the helper that
bridges the gap.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The invariant that expansion populates Site only was stated in full on
ExpandScope, checkCoverable and ScopesCover, and the "everything except
delete" example appeared on checkCoverable and again on permissionCovered
twenty lines below. State it once on ScopesCover, which is the function
whose behaviour depends on it, and cross-reference from the other two. Drop
framing that ranked implementation choices nobody proposed, and cut the two
test comments down to the facts the assertions do not already carry.

Kept in full: what each guard in checkCoverable defends, since no other
comment says it, and the wildcard rule on ScopesCover.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
checkCoverable said a negative site permission would be skipped, naming
a branch permissionCovered no longer has. A negative reaching it matches
on resource type and action like any other grant, so the anti-grant
would read as a grant. Name that instead, so the cross-reference lands
on a doc that matches the code.
The docstring listed the aliases and the low-level scopes, omitting the
curated composites the function also accepts. A caller consulting it to
decide whether coder:workspaces.access is public read no from the doc
and yes from the code.
ExternalScopeNames promises it offers each scope under one canonical
spelling, and no test held it to that. TestScopesCoverEveryExternalScope
appended the two aliases, but canonicalized them back into names the
list already carries, so it re-ran assertions the list iteration had
made and left the promise itself unpinned.

Assert on the alias table instead: the list omits the alias and offers
its canonical target. Every offered name is already proven coverable, so
the aliases inherit coverage, and a third alias inherits both invariants
the day it is added rather than needing a third hardcoded pair here.
The authorize endpoint parsed the scope parameter and discarded it, so an
app's configured allowlist never restricted anything and a client asking
for more than it should get was never told no. Phase 1 added the columns
that carry a negotiated scope from a code to the token it becomes, but
nothing wrote one, so every code was stamped unrestricted.

Negotiate the scope at authorization time and persist the result:

- Requested names must be in the external scope catalog, and the app's
  stored allowlist is filtered through that same catalog. Filtering only
  ever narrows what can be granted.
- The allowlist bounds authority, not spelling. A request is granted when
  every permission it grants is also granted by the allowlist, whether or
  not the allowlist names it, so an app allowed coder:workspaces.access
  can approve a client asking only for workspace:ssh.
- Omitting scope grants the filtered allowlist, per RFC 6749 section 3.3.
- Both handlers negotiate, so a request that cannot succeed fails before
  the consent page renders rather than after the user clicks Allow. Each
  reports the failure the way it already reports its own errors: a static
  error page on the GET side, an OAuth2 error body on the POST side.
- Two paths produce an empty result and are deliberately distinct. No
  allowlist and no request keeps the previous unrestricted grant, written
  as an explicit sentinel because the column is NOT NULL with a non-empty
  CHECK. An allowlist that filters to nothing is rejected, since falling
  back would grant strictly more than the allowlist ever permitted.

Dynamic client registration performs no catalog validation, so apps
registered with scopes such as openid or admin hold allowlists this
server cannot grant from. They now fail authorization in both directions.
Grandfathering unknown names would seed the enforcement path with values
it cannot evaluate, trading a visible negotiation-time error for a silent
enforcement-time hole. The failure names the registered scopes and the
remedy.

Issued tokens are still unrestricted: the exchange copies the negotiated
scope onto the token record, but the API key it mints carries no scope.
This changes which authorization requests succeed, not what a token can
do.
The consent page told every user the app was getting full access to their
account, which stopped being true once the authorize endpoint began
negotiating a narrower scope. A user approving a request has no other place
to learn what they are handing over, so the page has to follow the grant
rather than a fixed sentence.

List the negotiated permissions when the grant is bounded, and keep the
original full-access wording when it is not. An unrestricted grant is
reported as full access rather than as "coder:all", since the scope name
tells a user less than the sentence does. The list collapses to the
full-access wording whenever the unrestricted scope is present, not only
when it stands alone: an allowlist registered as `coder:all
coder:workspaces.access` grants everything, and naming the narrower entry
beside it would describe the grant as bounded.

role="list" and role="listitem" are explicit because WebKit drops the
implicit list semantics from a list styled with list-style: none, which
would otherwise leave VoiceOver announcing the permissions as loose text.

Also narrow the fragment the tests match for one rejection branch. The GET
side renders its description into HTML, which escapes the apostrophe in
"this app's allowed scope list", so the fragment stops before it.
…back

A rejected authorization request answered on Coder, which reaches only the
user's screen. The client's error handling never ran, and the state it sent
was dropped, so it could not correlate the failure with the request that
caused it. RFC 6749 section 4.1.2.1 requires the error be delivered to the
client's redirect URI once the client is known.

Redirect to the app's registered callback with error, error_description,
and the state exactly as it arrived. Both handlers use this, replacing the
static error page on the GET side and the OAuth2 error body on the POST
side.

This is safe here specifically because of ordering: extractAuthorizeParams
exact-matches the redirect URI against the app's registered callback, and
it runs before the scope check, so the destination is the app's own no
matter what the request carried. Only errors raised after that point may
use this helper, which its precondition states. Errors from
extractAuthorizeParams itself must not, since the URI is unvalidated
there. MismatchedRedirectURINotRedirected pins the ordering: an
unregistered redirect_uri fails on Coder with no Location header on either
verb, even when the same request also carries a scope the app cannot be
granted.

The other error paths in this file are unchanged, since several of them are
where redirect URI validation fails.
permissionCovered could drop its action comparison and the suite stayed
green: no ScopeName expands to {*, <specific action>}, since the wildcard
entry in policy.RBACPermissions carries no actions and coder:all is the
only wildcard resource the catalog spells. Reach the shape through
scopesCoverExpanded instead, with a positive control so the case fails on
the action rather than on resource matching, and a mirror pinning that a
single-resource grant does not cover a request for every resource.

Every allowed-side error row named the bad scope as the only entry, so an
implementation that answers as soon as one entry covers the request never
reached it. Add a row where the bad name sits behind coder:all, the only
row that fails when ScopesCover expands inside the comparison loop rather
than up front.
…otiateScope

The function does not check a requested scope and hand back a verdict. It
decides what scope the code will carry, which for an omitted request is the
app's allowlist and for an app with no allowlist is coder:all. Neither is a
value the caller asked for, so the name promised the wrong thing.
… sentinels

The black-box tests assert on the description that reaches the client, and
they did so through hand-copied fragments of the sentinel messages. A
reworded sentinel would leave every case asserting on text no branch
produces, and each case would still pass through whichever branch happened
to match next.

The sentinels live in package oauth2provider and the tests live in
oauth2provider_test, so they are bound through exported values declared in
the package's internal test file, which compiles into the same binary.
…turning it

rbac.ScopesCover reports an error when it cannot expand one of the names it
was handed. That is a deployment-side condition: the app's stored allowlist
holds something RBAC will not resolve, and no client can fix it by asking
differently. Folding it into errScopeNotAllowed both told the client it had
asked for too much, which is not what happened, and rendered RBAC internals
into error_description.

The failure now goes to the log with the app that provoked it, and the
client receives a sentinel of its own. negotiateScope takes the whole app
rather than its scope alone so the log line can name it.
… is grantable

The rejection named the filter's input, rejoined from fields. For a
whitespace-only allowlist that input is empty, so the app owner was shown
"" as the value they had to change: the one configuration where the message
is the only clue anything is set at all.

It now names the stored value verbatim.
…asons

Two reasons said things the code does not do.

"scope is not in this app's allowed scope list" described membership, but
the check is permission coverage: a scope the allowlist never names is
granted when a listed composite already confers it. A client reading the
old text would go looking for its scope in a list it was never matched
against.

"re-register the app with supported scopes" prescribed the one remedy a DCR
client has. An admin-created app is edited, not re-registered, and a DCR
client can update itself in place through RFC 7592.

The new text carries an apostrophe on the path the GET handler renders
through an HTML template, so the helper that reads those responses now
unescapes before matching.
The swagger annotation said a requested scope must be within the app's
configured allowlist, which is wrong twice over. The allowlist is checked by
permission coverage, not name membership, and it is not the only gate: every
requested name must also be in this deployment's scope catalog, including
for an app that has no allowlist at all. The omitted-scope default was
likewise stated only for apps that have one.

Two code comments went stale the same way. The branch table called the
omitted-scope default the whole allowlist when it is the catalog-filtered
one, and the comment over the persisted scope said the token minted from the
code will carry it, which is the next phase's work, not this one's.
@BobbyHo

BobbyHo commented Sep 11, 2026

Copy link
Copy Markdown
Collaborator Author

/coder-agents-review

@coder-agents-review

coder-agents-review Bot commented Sep 11, 2026 •

Copy link
Copy Markdown
Contributor

Chat: Review in progress (18/18 reviewers complete) | View chat
Requested: 2026-09-11 17:09 UTC by @BobbyHo

deep-review v0.9.0 | Round 1 | 0cdf1b8..ab0e2ac

Last posted: Round 1, 11 findings (2 P3, 2 Nit, 7 Note), COMMENT. Review

Finding inventory

Finding inventory — PR #29208

Findings

# Sev Status Location Summary Round Reviewer Posted
CRF-1 Nit Open revoke.go:99 Auth-failure warn logs app_id; rest of handler logs client_id+app_name R1 Mafuuu, Pariston, Kurapika, Kite, Gon, Chopper, Leorio, Meruem, Zoro, Razor, Hisoka Yes
CRF-2 P3 Open revoke.go:61 Stale RevokeToken doc comment still describes pre-PR auth model R1 Leorio Yes
CRF-3 P3 Open revoke.go:98 Per-request warn on keyless, unrate-limited endpoint floodable by client_id holder R1 Hisoka P3, Mafuuu P3 Yes
CRF-4 Note Open oauth2-provider.md:347 Docs "authenticates exactly as token endpoint" inexact for omitted-secret (400 vs 401) R1 Knov, Ryosuke Yes
CRF-5 Note Open codersdk/oauth2.go:455 SDK signature breaking change; two adjacent transposable string params R1 Knov, Kite, Chopper, Ryosuke Yes
CRF-6 Note Open revoke.go:103 Error-response + internal-error block duplicated (within handler and vs tokens.go) R1 Netero, Pariston, Razor, Zoro Yes
CRF-7 Nit Open oauth2_test.go:80 New //nolint comments copy OAauth2 misspelling R1 Gon Yes
CRF-8 Note Open oauth2_test.go:1266 works() in MissingSecretUnknownToken is decorative; only status carries the case R1 Bisky Yes
CRF-9 Note Open revoke.go:104 500 datastore-failure branch untested (mirrors token endpoint) R1 Bisky, Razor Yes
CRF-10 Note Open oauth2-provider.md:343 "Revoke a Token" section promises Basic or form, shows only Basic R1 Leorio Yes
CRF-11 Note Open nostore_test.go:156 Test comment narrates the diff instead of the behavior under test R1 Gon Yes
CRF-12 Note Dropped by orchestrator (benign by design, reviewer self-resolved) revoke.go:96 Secret validated outside revoke InTx; not atomic R1 Meruem No

Round log

Round 1

Netero-only first pass: 1 Note (error-mapping duplication), clean floor, panel proceeded. Panel of 17 (Bisky, Hisoka, Mafu-san, Mafuuu, Pariston, Kurapika, Razor, Knov, Kite, Ging-go, Ryosuke, Chopper, Gon, Leorio, Komugi, Meruem, Zoro) plus Netero. No P0-P2. 2 P3, 2 Nit, 7 Note posted; 1 Note dropped (benign). Reviewed against 0cdf1b8..ab0e2ac. Ging-go, Komugi, Mafu-san, and several others reported no findings; the change is a clean, well-tested closure of the last unauthenticated OAuth2 secret-reading endpoint (SEC-348).

About deep-review

CRF = Coder Review Finding (P0-P4, Nit, Note)

Reviewer Focus
Bisky tests
Chopper ops/errors
Churn-guard change verification
Ging language modernization
Gon naming
Hisoka edge cases
Killua perf
Kite change integrity
Knov contracts
Knuckle SQL
Komugi flake/determinism
Kurapika security
Law decomposition
Leorio docs
Luffy product
Mafu-san process
Mafuuu contracts
Melody dispatch/pairing
Meruem structural
Nami frontend
Netero mechanical checks
Pariston premise testing
Pen-botter product gaps
Razor verification
Robin duplication
Ryosuke Go arch
Takumi concurrency
Zoro shape

🤖 Managed by Coder Agents.

@coder-agents-review coder-agents-review Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This is a clean, tightly-scoped close of the last OAuth2 endpoint that read a client secret without checking it. Client authentication runs before the token is classified, so an unauthenticated confidential caller gets a uniform 401 whether the token is valid, foreign, or unknown, which shuts the token-existence oracle RFC 7009 §2.2 would otherwise open; MissingSecretUnknownToken proves it. The change reuses the authenticateClient/mergeBasicClientAuth helpers from #29206 instead of reimplementing auth, preserves the ownership check by making the cross-app test authenticate the other app as itself, keeps public clients bound by client_id alone, and pairs every refusal test with a works() probe so a 401-that-still-revokes could not pass. IsPublic() fails closed on an unrecognized client type. Five reviewers, including the Go-idiom, determinism, and process passes, returned no findings.

No P0-P2. Severity count: 2 P3, 2 Nit, 7 Note.

Two items worth a decision. The stale RevokeToken doc comment (CRF-2) still tells the next reader that revocation authenticates on token validity alone, which is the exact false belief the PR description says caused this bug; you corrected it on the SDK method but left it standing on the handler. The per-request warn on a keyless, unrate-limited route (CRF-3) lets anyone who knows a confidential client_id flood the log stream. It is the same class the #29207 panel raised as P3 on the token endpoint and is not a new capability, but keeping Warn vs dropping to Debug plus an aggregate metric is a human call, not something to leave implicit. Everything else is Note/Nit polish.

As Bisky put it after trying to break each of the nine subtests: "These stones cut glass."


coderd/oauth2provider/revoke.go:61

P3 [CRF-2] The RevokeToken doc comment still describes the pre-PR auth model and never mentions the client authentication this PR adds. (Leorio)

The comment reads: "Authentication is unique for this endpoint in that it does not use the standard token authentication middleware. Instead, it expects the token that is being revoked to be valid." That was true before this PR. [...] The next developer reading this comment learns that revocation authenticates on token validity alone. That is the exact false belief the commit says caused the original bug.

You fixed this belief in the SDK method's comment but left it standing on the handler that implements the fix. On a security-critical path the record should name both halves: authenticate the confidential client by client_secret/Basic per RFC 7009 §2.1, then verify the token was issued to that client, with public clients bound by client_id alone.

🤖

coderd/oauth2_test.go:80

Nit [CRF-7] The new //nolint comments copy the OAauth2 misspelling. (Gon)

The three nolint lines this PR adds read OAauth2 app management requires owner permission. It should be OAuth2.

The typo already appears many times in this file, so the PR propagates an existing class rather than introducing it; fixing the new instances (and optionally the siblings) in one pass removes it. Low impact, but it is a copied error in nolint justifications a reader will read.

🤖

🤖 This review was automatically generated with Coder Agents.

Comment thread coderd/oauth2provider/revoke.go Resolved
Comment thread coderd/oauth2provider/revoke.go Resolved
Comment thread codersdk/oauth2.go Resolved
Comment thread coderd/oauth2provider/revoke.go Resolved
Comment thread coderd/oauth2_test.go Resolved
Comment thread coderd/oauth2provider/revoke.go Resolved
Comment thread coderd/oauth2provider/nostore_test.go Resolved
… test comments

Log client_id and app_name on the authentication refusal to match the
other lines in RevokeToken. Say in the docs that revocation authenticates
as a refresh does and show where the form-credential example lives. Trim
two test comments to the behavior under test.
…t' into coder-plat-506-refresh-client-auth

# Conflicts:
#	docs/admin/integrations/oauth2-provider.md
BobbyHo added a commit that referenced this pull request Sep 15, 2026
… helpers (#29206)

Refactor client authentication for SEC-348 by extracting shared helpers for confidential-client secret validation and HTTP Basic credential handling. This prepares the refresh grant (#29207) and revocation endpoint (#29208) to use the same checks. No behavior change; existing tests pass unchanged, with new coverage for client authentication and Basic auth merging. No migration, new errors, or docs.
@BobbyHo
BobbyHo marked this pull request as ready for review September 15, 2026 21:37
@github-actions github-actions Bot added the release/breaking This label is applied to PRs to detect breaking changes as part of the release process label Sep 15, 2026

@dylanhuff-at-coder dylanhuff-at-coder left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Two docs comments, otherwise lgtm

Comment thread coderd/oauth2provider/revoke.go Resolved
Base automatically changed from coder-plat-506-refresh-client-auth to main September 15, 2026 23:18
@coderagents

coderagents Bot commented Sep 16, 2026 •

Copy link
Copy Markdown
Contributor

Documentation Check

Updates Needed

  • docs/admin/integrations/oauth2-provider.md - The "Revoke a Token" section's no-probing sentence (lines 382-384) overstates the current behavior. Addressed in 79ed5a7: the sentence now reads "A successful revocation returns HTTP 200, but that response does not confirm that the token existed or belonged to your client", the overstated 200-for-unknown-token claim is removed, and the Swagger 200 description plus the regenerated docs/reference/api/enterprise.md were aligned to the same wording. The underlying 500-on-wrong-secret behavior is a separate follow-up as agreed. With accepted client credentials, a token that exists under a prefix or ID but has the wrong secret returns HTTP 500 (invalid refresh token / invalid api key falls through to the internal-server-error branch in RevokeToken), while a token whose prefix or ID is unknown returns HTTP 200. The docs as written say "HTTP 200 whether or not the token existed or belonged to the client... cannot use it to probe", which the code does not currently honor for that case. Suggested wording from review: "A successful revocation returns HTTP 200, but that response does not confirm that the token existed or belonged to your client." The underlying 500 behavior can be a separate follow-up; the docs should not promise what the code does not do.

  • coderd/oauth2.go (Swagger annotations for POST /oauth2/revoke, revokeOAuth2Token) - Addressed in 0b96eff: the annotations now document the Authorization header (HTTP Basic), client_secret (with the public-client note), and the 400/401 responses, and the regenerated API reference in docs/reference/api/enterprise.md carries all of it. The original item: the generated API reference (docs/reference/api/) currently lists only client_id, token, and token_type_hint for this endpoint, with a single 200 success response. After this PR a confidential client following that documented request shape gets HTTP 401 invalid_client unless it also presents client_secret (form field) or HTTP Basic. Update the Swagger annotations to add client_secret (noting public clients send none) and the 400 / 401 responses, then regenerate the API docs. The conceptual "Revoke a Token" section in docs/admin/integrations/oauth2-provider.md already covers this; the reference page does not.


Automated review via Coder Agents

@BobbyHo
BobbyHo merged commit 86e43de into main Sep 16, 2026
30 of 31 checks passed
@BobbyHo
BobbyHo deleted the coder-plat-507-revoke-client-auth branch September 16, 2026 00:24
@github-actions github-actions Bot locked and limited conversation to collaborators Sep 16, 2026
Sign up for free to subscribe to this conversation on GitHub. Already have an account? Sign in.

Labels

release/breaking This label is applied to PRs to detect breaking changes as part of the release process

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants