Skip to content
SHC Docs

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 as 89a0067b4 for a landing-order defect and intact on feat/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_ssosel bounce 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#/route on a fragment-routed app. It is (&|#|$) now, and the guard FAILS with the old terminator.
  • The key is sso_click_selector:, not §7’s proposed sso_click:: it sits beside sso_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 as socialaccount/keycloak. With ?sso=false on 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-REFUSED and 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 return null for href).

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:

appbrief’s premisemeasured 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.


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.

appimage (the shc pin)how the login page was reached
penpotpenpotapp/frontend:2.17.0 + penpotapp/backend:2.17.0 + postgres 16 + valkey 8.1real browser, /#/auth/login
vaultwardenvaultwarden/server:1.37.1-alpine@sha256:b094afed…real browser, /#/login
minio-classicquay.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.426shipped bundle read from the image

The click-through itself was simulated two ways, deliberately:

  1. 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:
  2. A real injecting reverse proxy (/tmp/ssod/injector_proxy.py) that buffers text/html, splices the payload before </body>, and optionally merges the script’s sha256 into the response’s own CSP the way traefik/plugin/csp.go cspRelax does. 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 Allowed
POST /api/auth/oidc?provider=oidc -> 400 (transit+json, reached the handler)
GET /api/rpc/command/login-with-oidc -> 405

The 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:

conditionsappearance of the SSO control
unthrottled, warm cache, loopback1550, 1653, 1653, 1700, 1550 ms
4× CPU throttle, 100 ms latency, 5 Mbit4767, 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 IdP
GET /identity/connect/authorize?… (no code_challenge) -> 404

And 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://…/#/sso
bodytext: "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=1
run4 idp-hits=1 run5 idp-hits=1 run6 idp-hits=1

with 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 the console sidecar) 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.
appcontrolhrefcheck 1check 2check 3check 5synthetic click
penpot 2.17.0a.…btn-oidc-authnullfail (fragment)fail (405)n/afail (no end_session)works, 1.6–5.1 s race
vaultwarden 1.37.1button.vw-sso-loginnullfail (fragment)fail (browser PKCE)n/anot reachedrefuted: needs 2 human inputs
minio-classicbutton#SSOSelectornullpassfail (JSON)fail (per-render state)fail (no SLO wired)works 6/6, 0.5–4.6 s race
hulyn/an/apasspasspassfail (documented)not in the class

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:

guarddepends onsurvives in D?
the !Query(<bypass>,false) router rulethe requestyes
the target path may not match loginPatternthe target URLno
the target may not equal this requestthe target URLno
same-origin / allowOrigins refusalthe target URLno
the 90-second shc_ssosel cookietimeyes

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 typesbypass_matches
https://host/#/auth/login?sso=falsetrue
https://host/?sso=false#/auth/loginfalse

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:

appContent-Security-Policy on the login pageblocked outrightrelaxed by cspRelax
penpot frontend 2.17.0(none)non/a: nothing in the way
vaultwarden 1.37.1default-src 'none'; … script-src 'self' 'wasm-unsafe-eval'; …noyes, hash appended to script-src
minio-classic consoledefault-src 'self' 'unsafe-eval' 'unsafe-inline'; script-src 'self' https://unpkg.com; …noyes, hash appended to script-src
minio console fork 1.9.1(none)non/a
huly frontnot 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. cspRelax correctly 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 narrows script-src to '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?”
appupstream state (checked 2026-08-10)moot?
penpotIssue #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
vaultwardenThe 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-classicgithub.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
hulynot in the classn/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 state is 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, then sso_selector (href), then sso_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_click parses 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.go is retained unchanged: the frame check, the gate-session-cookie check, the deny substrings, the OIDC-error query and fragment checks, the sticky bypass, the PV/LO logout 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.yaml warning text on every consumer, because none of the three measured candidates has a working RP-initiated logout except apps/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.


  • 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 a BrokenPipeError in the 60-line python proxy, not a property of the mechanism.
  • The minio console fork’s OIDC flow was measured only at GET /api/v1/login, not driven in a browser.

  1. 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.
  2. Strike huly from the excluded class wherever it is stated; sso-auto-redirect.md already declares its sso_redirect, and this document’s §1.2 is the source-level confirmation.
  3. Fix the auto.go bypass 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.
  4. If the minio console line is ever wanted, open sso_start_json (§6) as a separate proposal, against apps/storage/minio only (the sibling that actually wires RP-initiated logout) and re-run all seven checks against it. minio-classic stays excluded on check 5 regardless.
  5. Leave penpot and vaultwarden excluded, with the reasons above recorded against them so the next sweep does not re-derive them from scratch.
  6. Nothing here arms anything. ssoAutoRedirect still defaults to false everywhere, and arming remains an owner decision gated on the latch reaching the estates, which, per §4.2, it has not: the latch is on origin/feat/sso-autoredirect-latch-rebased, not on shc main.