Implementation D: an injected synthetic click for the structurally-excluded class
Status: built; this note is still its only description.
★ TERMINOLOGY, and it is not a quibble. shc already uses the phrase click-through for something else, and for the opposite thing: the launcher’s cross-site sign-in offer, which navigates only when a human presses it (
feat(launcher): cross-site hosts trade the doomed silent check for a click-through,ce00cf91c, reverted as89a0067b4for a landing-order defect and intact onfeat/launcher-crosssite-fallback). This document is about a synthetic click, SHC activating the app’s control on the user’s behalf, with no gesture. §4.6 is why that distinction decides the whole question.
★★ SUPERSEDED 2026-08-21: THIS WAS BUILT, AND SHIPPED. The verdict below stood for ten days and was then overtaken by an owner directive to build the mode for glitchtip specifically. It is preserved verbatim because its MEASUREMENTS are the best evidence in the estate for this class and several of them are now load-bearing tests, and because a study whose verdict was reversed should say so in its own voice rather than be quietly deleted.
What shipped, and where the study was right and wrong:
- §4.1’s objection stands and was ANSWERED, not waved. Three of mode C’s four anti-bounce guards are assertions about a target URL, and this mode has no target URL. The shipped grade therefore joins the FOURTH guard (the shared
shc_ssoselbounce budget, 3 per 90s) which is the one that does not need a target, and pays into it from the injector because a click is not a 302 and nothing downstream can count it. It also keeps the one-shot client latch, and spends it AT THE CLICK.- §7’s design contract was adopted nearly whole, including the first-interaction abort (penpot’s 1.6-5.1s window with the credential form on screen), measured here, and now
TestAutoClickAbortsOnceThe HumanTouchesThePage.- §4.3’s break-glass defect was REAL and is FIXED. The bypass terminator
(&|$)could not match?sso=false#/routeon a fragment-routed app. It is(&|#|$)now, and the guard FAILS with the old terminator.- The key is
sso_click_selector:, not §7’s proposedsso_click:: it sits besidesso_selector:in the same block and the longer name is what makes the two grades tell themselves apart on sight.- The study’s own scope was narrower than the shipped feature. It did not consider a GATED deployment at all, and glitchtip is one. The gate passes only
X-SHC-User, which 16 of 17 gated apps ignore, so a gated app that keeps its own session serves its own login card anyway, which is where this grade does its work.- Two defects the study could not have found, because it never contacted an estate: the auto payload never claimed a CSP hash (so it was spliced and never RAN on any hash/nonce policy: glitchtip’s, and sonarqube’s), and the bounce budget counted page loads rather than login arrivals (one login hit the cap). Both were found by driving the real app and are fixed.
DRIVEN PROOF, 2026-08-21, promanager-NEW, one cookie jar, real browser: logged out ->
glitchtip.corp.promanager.vip/login-> Keycloak with zero clicks -> one credential submit -> authenticated INSIDE GlitchTip associalaccount/keycloak. With?sso=falseon the identical state, the login card renders and its button is not pressed.
Status: FEASIBILITY STUDY, COMPLETE. VERDICT (2026-08-11): DO NOT BUILD. SUPERSEDED, see above. Measured 2026-08-10/11 against pinned images on a throwaway local bring-up. No app package is changed by this document. No estate was contacted.
Companion to docs/proposals/sso-auto-redirect.md, which is the spec. This
document answers one question that spec leaves open: the apps excluded by
author check 1 (login path not server-visible) or check 2 (SSO entry is not
a plain GET whose state is minted server-side) are excluded from
Implementations A, B and C. SHC can inject script into a response. Could an
injected synthetic click (a payload that finds the app’s own SSO control
and activates it client-side, with no user gesture) serve that class?
0. The verdict, and the one sentence that carries it
Section titled “0. The verdict, and the one sentence that carries it”Do not build it. Not because it cannot work (on two of the four apps it demonstrably does, and there is a live navigation to a Keycloak authorize URL in §3 to prove it) but because of this:
A click-through has no target URL at the moment it decides to act, and three of Implementation C’s four anti-bounce guards are assertions about that URL. C compares the href it found against the login pattern, against the current request, and against the allowed origins, and refuses before it redirects. A click-through hands control to the app and never learns where the app went.
SSOSEL-SELFLOOP,SSOSEL-REFUSEDand the same-origin rule are unavailable by construction, and the defining property of this app class is precisely that the control has no href to inspect (measured: all three controls below returnnullforhref).
The class is defined by “there is no URL here”, and every safety property SHC built for the redirect path is a property of a URL. That is not a gap that more code closes.
Two further findings independently dispose of the four apps, so the question is moot in the concrete even before it is answered in the abstract:
| app | brief’s premise | measured verdict |
|---|---|---|
| huly | ”client-routes its login, so the server never sees the login path” | ★ PREMISE STALE. huly is not in the class. It declares sso_redirect on shc main today, its entry is router.get("/auth/openid") with server-minted state, and the fleet table already records /login/ → 302. Nothing to build. |
| vaultwarden | ”the BROWSER mints the PKCE verifier, the flow dies at the callback” | Premise correct, and the click-through is REFUTED for a second, harder reason: the control needs two values only a human has. §3.2. |
| penpot | ”login-with-oidc → 405, POST-only” | Premise correct, re-measured at the current endpoint name. Click-through works mechanically. Fails on the guards above plus a measured logout and bypass defect. §3.1. |
| minio / minio-classic | ”same shape, unverified for minio-classic” | Premise correct and now verified for minio-classic. Click-through works, 6/6. But it is the wrong tool: the authorize URL is available server-side, with no browser-side state at all. §3.3, §6. |
1. Two corrections to the brief’s premises, before anything else
Section titled “1. Two corrections to the brief’s premises, before anything else”1.1 SHC injects script in exactly ONE place, and Implementation C is not it
Section titled “1.1 SHC injects script in exactly ONE place, and Implementation C is not it”The framing “SHC already injects script into responses (the launcher payload, and Implementation C’s response injector)” is half wrong, and the half that is wrong is the half that sets the cost.
traefik/plugin/ssoselect.go Inject() returns body unchanged on every
path, including the success path. It parses, it resolves, and it
communicates through rc.Redirect. Its second guarantee in the spec,
“a miss serves the page byte-identically”, is actually stronger than
advertised: a hit also serves the page byte-identically, because the
middleware never ships the body at all once a redirect is set.
So the only script SHC plants is the launcher’s, and launcher: auto’s
payload beside it (traefik/plugin/auto.go). Building D would make script
injection into a login page a mechanism SHC relies on for authentication
flow for the first time. That is a category change, not an increment.
1.2 huly already has what the brief says it cannot have
Section titled “1.2 huly already has what the brief says it cannot have”Measured in the shipped hardcoreeng/account:v0.7.426 bundle
(/usr/src/app/bundle.js, extracted from the pinned image on this box):
router.get("/auth/openid", async (ctx, next) => { const state = encodeState(ctx, brandings); await passport.authenticate("oidc", { scope: "openid profile email", state })(ctx, next);});router.get("/auth/openid/callback", ...)A plain GET; state and the PKCE verifier are minted and held by
openid-client’s strategy server-side; the URL is fixed. Checks 2 and 3
pass. apps/management/huly/app.yaml has declared it since the catalogue
landing:
sso_redirect: login_path: "(?i)^{{ path('nginx') }}/login(:|/|$)" sso_start: "{{ path('nginx') }}/_accounts/auth/openid"(nginx is huly’s real front service; the anchors sit around the template,
per the renderer’s rule.) The server-visible half is Implementation B; the
client-routed half is the launcher: auto payload. huly is a solved case
and must be struck from any future statement of this excluded class.
2. What was measured, and how
Section titled “2. What was measured, and how”Every app was brought up locally from its shc-pinned image, driven with a real Chromium over CDP in a private profile on port 9333 (the user’s own debug browser on 9222 was never touched), with a stub OIDC discovery endpoint so the apps would complete their startup-time provider validation.
| app | image (the shc pin) | how the login page was reached |
|---|---|---|
| penpot | penpotapp/frontend:2.17.0 + penpotapp/backend:2.17.0 + postgres 16 + valkey 8.1 | real browser, /#/auth/login |
| vaultwarden | vaultwarden/server:1.37.1-alpine@sha256:b094afed… | real browser, /#/login |
| minio-classic | quay.io/minio/minio:RELEASE.2025-04-22T22-12-26Z.hotfix.c630804a1@sha256:a4915227… | real browser, /login (console on :9001) |
| minio (console fork) | ghcr.io/georgmangold/console:v1.9.1@sha256:38843866… | HTTP, /api/v1/login |
| huly (account) | hardcoreeng/account:v0.7.426 | shipped bundle read from the image |
The click-through itself was simulated two ways, deliberately:
Page.addScriptToEvaluateOnNewDocument: a document-start script, which is what an inline<script>spliced into the shell behaves like. Used for timing and click behaviour. It bypasses CSP, which is why:- A real injecting reverse proxy (
/tmp/ssod/injector_proxy.py) that bufferstext/html, splices the payload before</body>, and optionally merges the script’s sha256 into the response’s own CSP the waytraefik/plugin/csp.gocspRelaxdoes. Used for the CSP question, where the CDP path would have lied.
3. (a) Does it work? Per app, proved or refuted
Section titled “3. (a) Does it work? Per app, proved or refuted”3.1 penpot 2.17.0: WORKS mechanically, and is the wrong thing to do
Section titled “3.1 penpot 2.17.0: WORKS mechanically, and is the wrong thing to do”The control. From the shipped js/shared.js, the OIDC button is
button-link* rendered only when login-with-oidc is in app.config/flags:
return jsxs("a", {tabIndex:"0", onClick:on_click, onKeyDown:on_key_down, className: cls + " main_ui_components_button_link__button"}, ...)An anchor with no href. Confirmed live in the DOM:
A.main_ui_auth_login__login-btn main_ui_auth_login__btn-oidc-auth main_ui_components_button_link__button href=null txt="OpenID"Implementation C is therefore structurally unavailable here: there is no
href for firstSelectorAttr(body, sel, "href") to find. This is the first
concrete instance of the class the verdict is about.
Check 2, re-measured at the endpoint the current client actually uses.
The spec records GET /api/rpc/command/login-with-oidc → 405. At 2.17.0 the
client posts to a differently-named route, and it is also POST-only:
GET /api/auth/oidc?provider=oidc -> 405 Method Not AllowedPOST /api/auth/oidc?provider=oidc -> 400 (transit+json, reached the handler)GET /api/rpc/command/login-with-oidc -> 405The verdict stands, at both names.
Check 1 is a hard structural fail. GET /auth/login → 301 to /404.
The login page is the SPA fragment /#/auth/login; the server sees GET /
and nothing else, and the fragment is never transmitted. No Traefik matcher
can exist.
The click-through fires. With a document-start payload polling every
50 ms for a.main_ui_auth_login__btn-oidc-auth and calling .click():
{"appearedAt_ms":1650,"clickedAt_ms":1650,"polls":13,"clickErr":null, "fetches":["…/api/main/methods/get-enabled-flags", "…/api/main/methods/get-profile", "…/api/auth/oidc?provider=oidc"]}POST /api/auth/oidc?provider=oidc is the real SSO initiation; a
programmatic .click() on a React <a> dispatches a bubbling MouseEvent
that the delegated root listener handles exactly like a human’s.
The navigation that follows was not observed end-to-end locally: penpot’s
backend refuses a private-IP issuer (uri target is not allowed,
ssrf.clj:222), so the stub IdP could not be configured. The remaining step
is read from the shipped bundle and is unambiguous: on success the response’s
redirect_uri is handed to router/nav-raw, a plain top-level navigation,
and no browser-side secret is created at any point. That last fact
matters in §6.
How would the payload know the control is ready, and is that a race?
It is a race, and there is no signal to wait on. penpot’s login card does not
exist until (i) the shell parses, (ii) libs.js (6.2 MB) + main.js +
shared.js (19.8 MB uncompressed) execute, and (iii) two backend fetches
(get-enabled-flags, get-profile) resolve. With the backend down the
button never renders at all; measured: candidates: [] and two 502s.
The only available answer is “poll until it appears, give up after N”.
Measured spread on an idle local machine, no network latency:
| conditions | appearance of the SSO control |
|---|---|
| unthrottled, warm cache, loopback | 1550, 1653, 1653, 1700, 1550 ms |
| 4× CPU throttle, 100 ms latency, 5 Mbit | 4767, 4720, 5116 ms |
For every one of those milliseconds the ordinary login form is rendered and interactive. A user who begins typing an email is navigated away mid-keystroke. That is not a corner case at 4.7 seconds; it is the median experience on a laptop over a real link.
Check 5 fails. end_session appears zero times in penpot’s shipped
shared.js. There is no RP-initiated logout. On sign-out the client emits
logged-out → nav(:auth-login), a client-side route change back to the
login screen, where the payload would be waiting.
3.2 vaultwarden 1.37.1: REFUTED, by measurement
Section titled “3.2 vaultwarden 1.37.1: REFUTED, by measurement”The control is <button class="vw-sso-login …">Use single sign-on</button>,
a vaultwarden fork class, no href, no id. So again: no C.
Check 2, re-confirmed. The browser mints the verifier:
submitSso(e,t){ … const n = yield this.buildAuthorizeUrl(e,t,i.token); this.platformUtilsService.launchUri(n,{sameWindow:!0}) }buildAuthorizeUrl(){ … const e = yield this.passwordGenerationService.generatePassword(a), t = yield this.cryptoFunctionService.hash(e,"sha256"); s = Utils.fromArrayToUrlB64(t); yield this.ssoLoginService.setCodeVerifier(e); // client state … "/connect/authorize?…&code_challenge=" + s + "&code_challenge_method=S256…" }and the server refuses an entry that carries no challenge:
GET /identity/connect/authorize?…&code_challenge=x&code_challenge_method=S256 -> 307 to the IdPGET /identity/connect/authorize?… (no code_challenge) -> 404And then the click-through fails anyway. Injected through the real
proxy with button.vw-sso-login, on the login page as a visitor first
arrives:
{"payload_ran":true,"appearedAt":820,"clicked":true, "location":"http://…/#/login"}bodytext: "Log in Email address * (required) Input is required. Remember email …"The click did not navigate. It submitted the empty email step and rendered a validation error on a page the user had not yet touched. Pre-filling the email and clicking again gets one step further and then stops on a second human-only field:
log: ["filled email at 640","clicked at 943"]location: http://…/#/ssobodytext: "Single sign-on To log in with your SSO provider, enter your organization's SSO identifier to begin. … SSO identifier * (required) Continue"Two values the edge cannot know: the user’s email address and the organisation SSO identifier. A click-through here is not merely unable to complete the flow; it makes the login page worse than doing nothing, by painting a required-field error before the user has typed a character.
SSO_ONLY=true does not rescue it. Re-measured (this re-confirms the spec’s
recorded verdict rather than contradicting it): the login page renders
identically (same email field, same “Use single sign-on” button) with only
the “or / Other / Create account” affordances removed.
3.3 minio-classic (RELEASE.2025-04-22 console): WORKS, 6/6
Section titled “3.3 minio-classic (RELEASE.2025-04-22 console): WORKS, 6/6”Check 1 passes, which is new information: GET /login → 200, and it is
the same 1309-byte shell / serves, so Traefik does see the path.
The control is <button id="SSOSelector">Keycloak</button> (again no
href) and the handler is as simple as it gets:
const S = e => { window.location.href = e };… Button({ id:"SSOSelector", …, onClick: e => { if (t.length > 1) return i(!o), void h(e.currentTarget); // opens a dropdown S(`${t[0].redirect}`) } })Check 3 fails: t comes from GET /api/v1/login, whose
redirectRules[0].redirect is a complete Keycloak authorize URL minted
fresh on every call: three consecutive calls returned three different
state values. There is no stable URL for sso_start.
The click-through works, deterministically. Document-start payload,
selector #SSOSelector, six consecutive runs; every one navigated to the
IdP:
run1 idp-hits=1 run2 idp-hits=1 run3 idp-hits=1run4 idp-hits=1 run5 idp-hits=1 run6 idp-hits=1with the target being exactly
…/realms/x/protocol/openid-connect/auth?client_id=minio&redirect_uri=…&state=….
Timing, same harness: 522, 606, 2300, 4550 ms, a 9× spread on an idle
machine over loopback. Same race as penpot, wider.
Two fragilities worth recording even though the verdict is do-not-build:
- With more than one redirect rule the same click opens a dropdown and navigates nowhere. SHC configures exactly one, but the payload cannot know that from the edge, and “the button did something visible and useless” is the worst failure mode a login page can have.
- Check 5 fails for
minio-classic: nothing in its compose wires an end-session endpoint, so signing out leaves the Keycloak session live.apps/storage/minio(the current line, with theconsolesidecar) is the one that does wire it (CONSOLE_IDP_END_SESSION_ENDPOINT), which is the only reason that app could ever be a candidate for anything here.
3.4 Summary of (a)
Section titled “3.4 Summary of (a)”| app | control | href | check 1 | check 2 | check 3 | check 5 | synthetic click |
|---|---|---|---|---|---|---|---|
| penpot 2.17.0 | a.…btn-oidc-auth | null | fail (fragment) | fail (405) | n/a | fail (no end_session) | works, 1.6–5.1 s race |
| vaultwarden 1.37.1 | button.vw-sso-login | null | fail (fragment) | fail (browser PKCE) | n/a | not reached | refuted: needs 2 human inputs |
| minio-classic | button#SSOSelector | null | pass | fail (JSON) | fail (per-render state) | fail (no SLO wired) | works 6/6, 0.5–4.6 s race |
| huly | n/a | n/a | pass | pass | pass | fail (documented) | not in the class |
4. (b) What breaks
Section titled “4. (b) What breaks”4.1 The anti-bounce guarantee: the structural objection
Section titled “4.1 The anti-bounce guarantee: the structural objection”Implementation C’s spec lists four independent guards against an infinite bounce. Sorted by what they depend on:
| guard | depends on | survives in D? |
|---|---|---|
the !Query(<bypass>,false) router rule | the request | yes |
the target path may not match loginPattern | the target URL | no |
| the target may not equal this request | the target URL | no |
same-origin / allowOrigins refusal | the target URL | no |
the 90-second shc_ssosel cookie | time | yes |
Three of five (four guards plus the origin rule) evaporate, and they are the three that make the redirect provably terminating rather than empirically terminating. What is left is a timer. A timer is a mitigation, not a guarantee, and the estate has already learned once, in the launcher work, what a latch that “should” hold costs when it does not.
There is no fix available, because the fix would be to inspect the target,
and the class is defined by there being no target to inspect. All three
measured controls return null for href.
4.2 The logout bounce, and whether the latch covers a click-through
Section titled “4.2 The logout bounce, and whether the latch covers a click-through”The latch (traefik/plugin/auto.go, commit edbf78eab on
origin/feat/sso-autoredirect-latch-rebased, not on shc main, and not
rolled) is a route-transition heuristic, and deliberately so: neither
huly nor windmill has an observable logout URL, so a pathname watcher would
have latched on neither. It remembers the previous client route in
sessionStorage (PV, honoured for 30 s) and sets a logout latch (LO,
15 min) when the login route is reached from a non-base, non-login route.
It would cover a click-through, on one condition: that D is built as a
mode of the existing payload rather than a parallel machine, i.e. that it
keeps the login-route predicate and only swaps the final location.replace(SS)
for el.click(). That condition is load-bearing. A payload that degrades to
“click whatever SSO-looking control you find, wherever you find it” has
nothing for RE.test(p) to test, and the latch has nothing to key on. Any
build of D must therefore inherit the route predicate, which means every
candidate app must still declare a client-observable login pattern, the
same declaration Implementation B needs, minus the part that made it safe.
4.3 ★ A latent defect in the SHIPPED payload, found while testing the bypass
Section titled “4.3 ★ A latent defect in the SHIPPED payload, found while testing the bypass”This is not hypothetical and it is not about D. It is in auto.go today.
The payload builds q = (location.search || '') + (location.hash || '') and
tests it against new RegExp('[?&]' + BQ + '=false(&|$)'). Measured in a
browser against penpot:
| URL the operator types | bypass_matches |
|---|---|
https://host/#/auth/login?sso=false | true |
https://host/?sso=false#/auth/login | false |
The second form is the one anybody would write (the query where a URL puts a
query, before the fragment) and it does not latch the payload off,
because in the concatenation ?sso=false#/auth/login the match is followed
by #, which is neither & nor end-of-string.
Blast radius today: only apps whose login route lives in the fragment, since
otherwise location.hash is empty. AFFiNE (launcher: auto, pushState
routing) is not affected. But the affected shape is exactly the
hash-routed SPA class that Implementation D would target, so any build of D
inherits a broken break-glass on its own candidate list.
Owed, not done here (this lane changes no code): widen the terminator to
(&|#|$), or test search and hash separately. A regression test should
assert both URL forms. Recorded so it is visible rather than silent.
4.4 The bypass reaching the local form (check 4)
Section titled “4.4 The bypass reaching the local form (check 4)”For a fragment-routed app the working bypass is #/route?sso=false (the
unusual form) and per §4.3 the natural form silently does nothing. An escape
hatch an operator must be taught, and would guess wrong, is close to no
escape hatch. Under the campaign’s own rule this would force either a loud
app.yaml warning or a local_login: closed_by: declaration on every D
candidate; and declaring closed_by when a bypass does exist (just in an
unguessable spelling) is precisely the false “no way in” that rule forbids.
There is no honest way to document this pair as it stands.
4.5 CSP: measured, and the cooperation path holds
Section titled “4.5 CSP: measured, and the cooperation path holds”All four apps’ real login-page CSP headers, run through the plugin’s own
cspBlocksInlineScript / cspRelax:
| app | Content-Security-Policy on the login page | blocked outright | relaxed by cspRelax |
|---|---|---|---|
| penpot frontend 2.17.0 | (none) | no | n/a: nothing in the way |
| vaultwarden 1.37.1 | default-src 'none'; … script-src 'self' 'wasm-unsafe-eval'; … | no | yes, hash appended to script-src |
| minio-classic console | default-src 'self' 'unsafe-eval' 'unsafe-inline'; script-src 'self' https://unpkg.com; … | no | yes, hash appended to script-src |
| minio console fork 1.9.1 | (none) | no | n/a |
| huly front | not measured, and not needed; huly’s path needs no injected script |
And the merge is load-bearing, proved end-to-end through the injecting proxy against vaultwarden’s real policy:
WITH the sha256 merge -> {"payload_ran":true,"appearedAt_ms":684,"clicked":true}WITHOUT it -> {"payload_ran":false} LOG[error] Executing inline script violates the following Content Security Policy directive 'script-src 'self' 'wasm-unsafe-eval''. Either the 'unsafe-inline' keyword, a hash ('sha256-rYpbUUTeWtqEQWNXxqS4+f3PqBkhRfsMAaWmlraymuU='), or a nonce ('nonce-...') is required to enable inline execution. The action has been blocked.So CSP is not the blocker; csp.go already solved this class of problem
for the launcher, and it solves it here too. Two hazards it does not cover,
which a 302 never had:
form-action 'self'. vaultwarden ships it. A control that initiates SSO by submitting a cross-origin<form>(the SAML POST-binding shape) is blocked by that directive no matter whose script clicks it, and the failure is a silent no-op. None of the four measured controls is that shape, but the class is not closed and the edge cannot tell in advance.- Policy drift on an app upgrade.
cspRelaxcorrectly declines to widen a policy that already carries'unsafe-inline'(rule 1). An app that adds a nonce in a later image flips that branch, which is fine, but an app that narrowsscript-srcto'none'turns the whole feature off silently, and the only signal is a throttled log line on a box nobody is reading.
4.6 ★ The launcher lane reached the same conclusion, independently, this week
Section titled “4.6 ★ The launcher lane reached the same conclusion, independently, this week”While this study was running, ce00cf91c landed on main and was reverted the
same day (89a0067b4, for a landing-order defect: the plugin tree diverging
from the pinned image, explicitly “NOT A JUDGEMENT ON THE WORK”). The work
itself is the launcher’s answer to cross-site hosts, and its shape is the
strongest external corroboration this study has:
-
it renders a sign-in offer and treats “the click is consent to a login form” as the thing that licenses skipping
prompt=none; -
and its guard suite proves, by mutation, that a payload which navigates without a press must fail:
no automatic navigation: two cross-site loads, zero clicks, zero navigations; an arrival back from a failed login renders the offer again and GOES NOWHERE (a payload mutated to auto-navigate fails)
That is a different lane, a different problem (launcher visibility, not SSO entry), and a different author, arriving at the same boundary from the other side: a human gesture is what makes a client-side navigation into an authentication flow safe, and its absence is what makes termination unprovable. Implementation D is defined by not having one.
It also supplies the honest alternative, should the owner want this class served at all: not “click the app’s button for the user”, but “render an offer the user presses”, which the launcher already does, needs no selector, needs no app-specific knowledge, and cannot bounce because nothing moves until somebody moves it.
5. (c) Upstream knobs: is the question moot at a newer version?
Section titled “5. (c) Upstream knobs: is the question moot at a newer version?”| app | upstream state (checked 2026-08-10) | moot? |
|---|---|---|
| penpot | Issue #2550 “feature: Auto-Login with OpenID”: OPEN, filed 2022-11-04, last touched 2026-01-20, unimplemented. Latest release is 2.17.0, which is shc’s pin; its notes mention OIDC only as “cache OIDC provider records to skip per-login discovery”. The shipped bundle contains zero occurrences of auto-login, autologin, auto-redirect or autoRedirect. | no |
| vaultwarden | The full sso_* option set at main is 16 options; none auto-redirects. sso_only disables password login only; re-measured above, the page still renders and still demands an email. | no |
| minio-classic | github.com/minio/minio is archived ("archived": true, last push 2026-04-24). minio/console and minio/object-browser are both deleted. The community server line is frozen. | no, and never |
| minio (console fork) | ghcr.io/georgmangold/console is a community fork of a deleted upstream. A knob would be a feature request against one maintainer’s fork. | no |
| huly | not in the class | n/a |
Note the shape of penpot #2550’s own workaround, quoted in the issue thread: “custom JavaScript that automatically triggers the OpenID login button on page load.” Implementation D is not a novel idea; it is the thing penpot users already do by hand, which is evidence that it works and no evidence at all that a platform should ship it as an unattended default on someone else’s estate.
6. Cost against the alternative, and the alternative is not “upstream”
Section titled “6. Cost against the alternative, and the alternative is not “upstream””For the one app where a mechanism is genuinely missing and check 1 passes (the minio console line) a click-through is the expensive answer, and the measurements say a much cheaper one exists.
GET /api/v1/login returns the complete authorize URL, server-side, and the
browser contributes nothing to the flow:
- the handler is literally
const S = e => { window.location.href = e }; - the response carries no
Set-Cookie(verified on both the classic console and the v1.9.1 fork), so there is no browser-side half of a pair; - the
stateis a self-contained blob the console validates at/oauth_callback.
That is the frappe shape with the URL in a JSON field instead of an anchor’s
href. If the owner ever wants this class covered, the honest successor is a
third form of the existing declaration, not a script:
# ILLUSTRATIVE ONLY: nothing in this document declares anything.sso_redirect: login_path: "^{{ path('console') }}(/login/?)$" sso_start_json: url: "{{ path('console') }}/api/v1/login" field: "redirectRules.0.redirect"(console is apps/storage/minio’s real service name; the anchors sit
around the template, never after it.) That keeps every property the
click-through destroys: the edge holds the target URL before it acts, so the
self-loop refusal, the same-origin refusal and the allowOrigins check all
still apply; the decision is a 302 Traefik answers itself; there is no script,
no CSP negotiation, no hydration race, no typing-into-a-doomed-form window;
and it is testable without a browser.
Its costs are real and should not be hidden: one sub-request from the edge to
the app per login-page hit, a new failure mode (the app is up enough to serve
HTML but not enough to answer the JSON), and a JSON-path grammar the plugin
does not have. Whether that trade is worth making is an owner call, and it is
gated on check 5, which minio-classic fails outright and only
apps/storage/minio passes (it wires CONSOLE_IDP_END_SESSION_ENDPOINT).
For penpot and vaultwarden there is no alternative to recommend, because there is nothing to recommend: penpot’s login page is unreachable from the edge by construction and has no RP-initiated logout, and vaultwarden’s flow requires two human inputs. The honest posture for both is the one they have: the visitor clicks the button.
7. If it were built anyway: what the design would have to include
Section titled “7. If it were built anyway: what the design would have to include”Recorded so the cost is concrete, not to advocate for it. D is a mode of
auto.go, never a new injector:
sso_redirect: login_path: "…" # unchanged; still required, still the latch's key sso_click: "#SSOSelector" # NEW: a selector for a control with no href bypass_query: sso- Same declaration precedence as today:
sso_start(static) wins, thensso_selector(href), thensso_click, each strictly weaker than the last, and a catalogue test flags any app declaring a stronger form alongside a weaker one as dead weight. - ce validates that
sso_clickparses in the plugin’s existing stdlib-only selector grammar (traefik/plugin/cssselect.go): no new grammar, and pseudo-classes and selector lists stay refused at parse time. - Every guard from
auto.gois retained unchanged: the frame check, the gate-session-cookie check, the deny substrings, the OIDC-error query and fragment checks, the sticky bypass, thePV/LOlogout latch, the 60 s one-shot. - A hard poll budget: a bounded number of attempts with a bounded
deadline, after which the payload gives up permanently for that document.
Never an unbounded
MutationObserver. - A first-interaction abort: the payload must cancel itself the moment the user focuses or types into any field, because §3.1 measures a 1.6–5.1 s window in which the form is live. Without this the feature loses keystrokes.
- Exactly one click, ever, per document, and a coded warning on every
refusal path in the plugin’s existing non-
X######namespace (SSOCLK-NOMATCH,-GAVEUP,-ABORTED,-CONFIG). - The bypass defect in §4.3 fixed first: a break-glass that does not work is not a break-glass, and shipping D on top of it would be shipping a lockout.
app.yamlwarning text on every consumer, because none of the three measured candidates has a working RP-initiated logout exceptapps/storage/minio.
Even fully built, the §4.1 objection stands: it is a mechanism whose termination is asserted by a timer rather than proved by a comparison.
8. What this study did not establish
Section titled “8. What this study did not establish”- penpot’s navigation to Keycloak was not observed end-to-end. The click
was proved to reach
POST /api/auth/oidc?provider=oidc; the hop after it is read from the shipped bundle, not measured, because penpot’s SSRF guard refuses a private-IP issuer and no public IdP was in scope. - huly’s front image was not booted (it requires an accounts URL that was not stood up), so its CSP is unmeasured. It does not bear on any conclusion here: huly’s path is Implementation B plus the already-shipped payload.
- No live estate was touched, so nothing here is an estate measurement. Every number is from a pinned image on a throwaway local bring-up.
minio-classic’s console reached the IdP 6/6 through CDP injection and 5/6 through the local proxy; the sixth was aBrokenPipeErrorin the 60-line python proxy, not a property of the mechanism.- The
minioconsole fork’s OIDC flow was measured only atGET /api/v1/login, not driven in a browser.
9. Recommendation
Section titled “9. Recommendation”- Do not build Implementation D. §4.1 is dispositive and unfixable, and §4.6 is the same conclusion reached independently by the launcher lane in the same week. If the class is ever to be served, the shape is the launcher’s (an offer a human presses) not a synthetic click.
- Strike huly from the excluded class wherever it is stated;
sso-auto-redirect.mdalready declares itssso_redirect, and this document’s §1.2 is the source-level confirmation. - Fix the
auto.gobypass terminator (§4.3) as its own small change with its own test, independent of any of this. It is a live break-glass defect on the shipped payload, not a hypothetical. - If the minio console line is ever wanted, open
sso_start_json(§6) as a separate proposal, againstapps/storage/minioonly (the sibling that actually wires RP-initiated logout) and re-run all seven checks against it.minio-classicstays excluded on check 5 regardless. - Leave penpot and vaultwarden excluded, with the reasons above recorded against them so the next sweep does not re-derive them from scratch.
- Nothing here arms anything.
ssoAutoRedirectstill defaults tofalseeverywhere, and arming remains an owner decision gated on the latch reaching the estates, which, per §4.2, it has not: the latch is onorigin/feat/sso-autoredirect-latch-rebased, not on shc main.