From e519dc587c5538763d8f85f1ea82ce6f3592ae3e Mon Sep 17 00:00:00 2001 From: Ilker Manap Date: Wed, 16 Sep 2026 10:46:45 +0200 Subject: [PATCH] Serve the cluster dashboard over the web, without serving pprof with it MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reaching it meant an SSH tunnel, because the page lived on the admin listener and that listener is bound to loopback. Opening the port was never the way to fix that: it also serves pprof, and pprof can dump the process heap, where every API key sits in plaintext. Exposing the port would have been exposing the key store. So the page moves rather than the port. The same dashboard is now mounted at /admin on the client-facing port, behind the session and CSRF machinery that already guards /profile, gated on a flag on the account. The admin listener keeps pprof and metrics and stays on loopback. One bit, not a role system: it grants looking. Everything that changes the cluster or issues a credential stays on the CLI, where it needs a shell rather than a session — which keeps the worst case of a stolen admin cookie to "saw the cluster" rather than "drained your fleet". Someone without the flag gets 404, not 403. A 403 confirms the page is there and that admin accounts exist here, which is free reconnaissance; 404 is what every other unknown path returns. The profile page does not show a link to a door the visitor cannot open. Co-Authored-By: Claude Opus 5 (1M context) --- docs/onboarding.md | 35 ++++++++- internal/cli/server.go | 5 ++ internal/cli/users.go | 49 ++++++++++++- internal/router/handlers.go | 13 +++- internal/router/router.go | 15 ++++ .../store/migrations/sqlite/0004_admins.sql | 11 +++ internal/store/sessions.go | 4 +- internal/store/users.go | 24 +++++- internal/web/admin_page.go | 30 ++++++++ internal/web/templates/account.html | 1 + llmgw-plan.md | 4 +- test/e2e/signup_test.go | 73 +++++++++++++++++++ 12 files changed, 250 insertions(+), 14 deletions(-) create mode 100644 internal/store/migrations/sqlite/0004_admins.sql create mode 100644 internal/web/admin_page.go diff --git a/docs/onboarding.md b/docs/onboarding.md index dc73a43d..676cf21d 100644 --- a/docs/onboarding.md +++ b/docs/onboarding.md @@ -236,14 +236,43 @@ Tell them out of band and have them change it from their profile. Their sessions are closed — if they lost the password, the reason might be that someone else has it. Their API keys keep working; those are separate credentials. +## Seeing the cluster + +The dashboard — nodes, replicas, models, why something did not get placed, usage +per key — is served twice, and the difference matters. + +On the **admin listener** (`127.0.0.1:9090` by default) it needs no +authentication: having a shell on the machine is the credential. + +``` +ssh -L 9090:127.0.0.1:9090 # then http://127.0.0.1:9090/ +``` + +That listener also serves pprof, which can dump the process heap — where API +keys sit in plaintext. **Never expose that port.** It is bound to loopback for +that reason. + +On the **client-facing port** the same page is at `/admin`, behind a session and +an admin flag, so it can be reached from a browser without the port carrying +pprof along with it: + +``` +llmgw users promote usr-k4mq… --store … +``` + +Someone without the flag gets a 404 rather than a 403, because 403 confirms the +page exists. The dashboard is read-only in both places: everything that changes +the cluster or issues a credential stays on the CLI, which keeps the worst case +of a stolen admin cookie to "saw the cluster". + ## What this does not do - **No email.** No approval notice, no self-service password reset, no address verification. The loop is manual on purpose at this size; if it stops being the right size, that is the thing to automate. - **No SSO.** Accounts are local, with local passwords. -- **No roles.** Every approved account can do the same things: make its own keys - and nothing else. Administration is the CLI, and having a shell here is what - makes someone an administrator. +- **No roles.** There is one flag, `is_admin`, and it grants looking at the + dashboard. Everything else an administrator does is the CLI, and having a + shell here is what makes someone one. - **Rate limits are per gateway instance.** With two instances each counts its own, so the effective limit doubles. v1 is single-instance by design. diff --git a/internal/cli/server.go b/internal/cli/server.go index 2bd7f6c8..51c1c8a8 100644 --- a/internal/cli/server.go +++ b/internal/cli/server.go @@ -129,6 +129,11 @@ func newServerCmd() *cobra.Command { adminMux.HandleFunc("GET /", web.Dashboard( api, usage, version.Version, 5*time.Second, log)) adminMux.Handle("GET /_static/", web.Static()) + + // The same page on the client-facing port at /admin, behind a + // session and an admin flag. Handing the router the data rather + // than the port keeps pprof where it is. + rt.SetClusterView(api, usage) } apiSrv := &http.Server{ diff --git a/internal/cli/users.go b/internal/cli/users.go index e643fe05..2ca3715b 100644 --- a/internal/cli/users.go +++ b/internal/cli/users.go @@ -32,7 +32,9 @@ func newUsersCmd() *cobra.Command { "Stop an account working, keeping it and its history"), newUserStateCmd(open, "reinstate", store.UserActive, "Let a suspended account work again"), - newUserCreateCmd(open), newUserResetPasswordCmd(open)) + newUserCreateCmd(open), newUserResetPasswordCmd(open), + newUserAdminCmd(open, "promote", true, "Let an account see the cluster dashboard at /admin"), + newUserAdminCmd(open, "demote", false, "Take away access to the cluster dashboard")) return cmd } @@ -65,11 +67,15 @@ func newUserListCmd(open userOpener) *cobra.Command { } w := tabwriter.NewWriter(cmd.OutOrStdout(), 0, 0, 2, ' ', 0) - fmt.Fprintln(w, "ID\tEMAIL\tNAME\tSTATE\tPROJECT\tSIGNED UP\tLAST LOGIN") + fmt.Fprintln(w, "ID\tEMAIL\tNAME\tSTATE\tADMIN\tPROJECT\tSIGNED UP\tLAST LOGIN") now := time.Now() for _, u := range users { - fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n", - u.ID, u.Email, u.Name, u.State, dash(u.ProjectID), + admin := "-" + if u.IsAdmin { + admin = "yes" + } + fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", + u.ID, u.Email, u.Name, u.State, admin, dash(u.ProjectID), ago(u.CreatedAt, now), ago(u.LastLoginAt, now)) } return w.Flush() @@ -142,6 +148,41 @@ func newUserStateCmd(open userOpener, verb string, state store.UserState, short } } +func newUserAdminCmd(open userOpener, verb string, admin bool, short string) *cobra.Command { + return &cobra.Command{ + Use: verb + " ", + Short: short, + Long: "The dashboard is read-only, so this grants looking and nothing else.\n" + + "Everything that changes the cluster or issues a credential stays here on\n" + + "the CLI, where it needs a shell rather than a session — which keeps the\n" + + "worst case of a stolen admin cookie to \"saw the cluster\".", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + s, err := open(cmd) + if err != nil { + return err + } + defer s.Close() + + if err := s.SetAdmin(cmd.Context(), args[0], admin); err != nil { + return err + } + u, err := s.UserByID(cmd.Context(), args[0]) + if err != nil { + return err + } + if admin { + fmt.Fprintf(cmd.OutOrStdout(), "%s can now see /admin\n", u.Email) + } else { + fmt.Fprintf(cmd.OutOrStdout(), "%s can no longer see /admin\n", u.Email) + cmd.PrintErrln("Their session stays open; the page is read-only. " + + "Suspend the account to close it.") + } + return nil + }, + } +} + func newUserResetPasswordCmd(open userOpener) *cobra.Command { var password string cmd := &cobra.Command{ diff --git a/internal/router/handlers.go b/internal/router/handlers.go index ca1f65e1..453b6b4a 100644 --- a/internal/router/handlers.go +++ b/internal/router/handlers.go @@ -106,7 +106,16 @@ func (r *Router) Handler() http.Handler { // Signup, sign-in and the profile page. These are browser surfaces // authenticated by a session cookie, not by an API key, which is why // they are exempt below. - web.NewAccountPages(r.accounts, r.store, r.store, version.Version, r.log).Register(mux) + pages := web.NewAccountPages(r.accounts, r.store, r.store, version.Version, r.log) + pages.Register(mux) + + if r.clusterView != nil { + // The cluster dashboard, reachable from a browser without exposing + // the admin listener — which also carries pprof, and pprof can dump + // the heap that holds every API key in plaintext. + mux.HandleFunc("GET /admin", pages.AdminPage(web.Dashboard( + r.clusterView, r.clusterUsage, version.Version, 5*time.Second, r.log))) + } } if r.auth == nil { @@ -117,7 +126,7 @@ func (r *Router) Handler() http.Handler { // stays open because a load balancer has no key. return auth.Middleware(r.auth, r.log, "/health", "/", "/_static/", "/claim/", - "/signup", "/login", "/logout", "/profile", "/profile/")(mux) + "/signup", "/login", "/logout", "/profile", "/profile/", "/admin")(mux) } // parsedRequest is what the router needs from a request. Everything else in the diff --git a/internal/router/router.go b/internal/router/router.go index 93d50281..52eff47c 100644 --- a/internal/router/router.go +++ b/internal/router/router.go @@ -27,6 +27,7 @@ import ( "gitea.mynodes.xyz/ilker/llmgw/internal/router/scheduler" "gitea.mynodes.xyz/ilker/llmgw/internal/router/scrape" storepkg "gitea.mynodes.xyz/ilker/llmgw/internal/store" + "gitea.mynodes.xyz/ilker/llmgw/internal/web" ) // Router serves the OpenAI API in front of a set of engine replicas. @@ -57,6 +58,20 @@ type Router struct { store *storepkg.SQLite acct *accounting.Accountant recorder *accounting.Recorder + + // clusterView is nil until the control plane hands it over, and stays nil + // in a router-only deployment. + clusterView web.Source + clusterUsage web.UsageSource +} + +// SetClusterView gives the router the data the /admin page renders. +// +// Set by the server command once the control plane exists, because the router +// is built first. Nil leaves /admin unmounted, which is what a router-only +// deployment should have: no cluster to show. +func (r *Router) SetClusterView(src web.Source, usage web.UsageSource) { + r.clusterView, r.clusterUsage = src, usage } // Auth exposes the authenticator so ctl and the batch writer can reach it. diff --git a/internal/store/migrations/sqlite/0004_admins.sql b/internal/store/migrations/sqlite/0004_admins.sql new file mode 100644 index 00000000..5e3b82c9 --- /dev/null +++ b/internal/store/migrations/sqlite/0004_admins.sql @@ -0,0 +1,11 @@ +-- Who may see the cluster. +-- +-- Until now the answer was "whoever has a shell on the control plane", because +-- the dashboard lived on a loopback-bound port. Serving it over the web needs +-- an actual answer, and this is the smallest one that is not a lie: a flag on +-- an account that already has a password, a session and a CSRF token. +-- +-- Deliberately not a role system. One bit is enough for "can see the cluster" +-- and impossible to get subtly wrong; roles arrive when there is a second +-- distinction worth drawing. +ALTER TABLE users ADD COLUMN is_admin INTEGER NOT NULL DEFAULT 0; diff --git a/internal/store/sessions.go b/internal/store/sessions.go index d77ae020..c6643107 100644 --- a/internal/store/sessions.go +++ b/internal/store/sessions.go @@ -53,7 +53,7 @@ func (s *SQLite) SessionByToken(ctx context.Context, token string) (Session, Use row := s.db.QueryRowContext(ctx, `SELECT s.user_id, s.csrf_hash, s.expires_at, u.id, u.email, u.name, u.password_hash, u.state, COALESCE(u.project_id, ''), - u.created_at, u.approved_at, u.approved_by, u.last_login_at + u.created_at, u.approved_at, u.approved_by, u.last_login_at, u.is_admin FROM sessions s JOIN users u ON u.id = s.user_id WHERE s.token_hash = ?`, HashKey(token)) @@ -67,7 +67,7 @@ func (s *SQLite) SessionByToken(ctx context.Context, token string) (Session, Use if err := row.Scan(&sess.UserID, &sess.CSRFHash, &expires, &u.ID, &u.Email, &u.Name, &u.PasswordHash, &state, &u.ProjectID, - &created, &approved, &approvedBy, &lastLogin); err != nil { + &created, &approved, &approvedBy, &lastLogin, &u.IsAdmin); err != nil { if errors.Is(err, sql.ErrNoRows) { return Session{}, User{}, ErrNoSession } diff --git a/internal/store/users.go b/internal/store/users.go index 6881d7ea..3d81ecae 100644 --- a/internal/store/users.go +++ b/internal/store/users.go @@ -40,6 +40,9 @@ type User struct { ApprovedAt time.Time ApprovedBy string LastLoginAt time.Time + // IsAdmin lets this account see the cluster dashboard. It is not a role + // system: one bit, and everything that changes the cluster stays on the CLI. + IsAdmin bool } // CanSignIn reports whether this account may open a session. @@ -53,7 +56,7 @@ func NormalizeEmail(email string) string { } const userColumns = `id, email, name, password_hash, state, COALESCE(project_id, ''), - created_at, approved_at, approved_by, last_login_at` + created_at, approved_at, approved_by, last_login_at, is_admin` // CreateUser records a new, unapproved account. func (s *SQLite) CreateUser(ctx context.Context, u User) error { @@ -128,6 +131,23 @@ func (s *SQLite) SetUserState(ctx context.Context, id string, state UserState) e return nil } +// SetAdmin grants or withdraws access to the cluster dashboard. +// +// Withdrawing does not close their sessions: the page is read-only, so the +// worst a stale session buys is a few more seconds of looking. Suspending the +// account is what closes sessions, and that is the lever for someone who should +// not be here at all. +func (s *SQLite) SetAdmin(ctx context.Context, id string, admin bool) error { + res, err := s.db.ExecContext(ctx, `UPDATE users SET is_admin = ? WHERE id = ?`, admin, id) + if err != nil { + return err + } + if n, _ := res.RowsAffected(); n == 0 { + return ErrNotFound + } + return nil +} + // TouchLogin records a successful sign-in. func (s *SQLite) TouchLogin(ctx context.Context, id string, at time.Time) error { _, err := s.db.ExecContext(ctx, `UPDATE users SET last_login_at = ? WHERE id = ?`, @@ -184,7 +204,7 @@ func (s *SQLite) scanUser(sc scanner) (User, error) { var approvedBy sql.NullString if err := sc.Scan(&u.ID, &u.Email, &u.Name, &u.PasswordHash, &state, &u.ProjectID, - &created, &approved, &approvedBy, &lastLogin); err != nil { + &created, &approved, &approvedBy, &lastLogin, &u.IsAdmin); err != nil { if errors.Is(err, sql.ErrNoRows) { return User{}, ErrNotFound } diff --git a/internal/web/admin_page.go b/internal/web/admin_page.go new file mode 100644 index 00000000..d6a98e90 --- /dev/null +++ b/internal/web/admin_page.go @@ -0,0 +1,30 @@ +package web + +import ( + "net/http" +) + +// AdminPage wraps the dashboard in a session check for the public port. +// +// A visitor who is not an admin gets 404 rather than 403. 403 would confirm the +// page exists and that admin accounts are a thing here, which is free +// reconnaissance for anyone probing; 404 is what every other unknown path +// returns. +func (p *AccountPages) AdminPage(dashboard http.HandlerFunc) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + noStore(w) + _, user, ok := p.session(r) + if !ok { + // Not signed in at all: send them to sign in, which is useful and + // reveals nothing — /login is public anyway. + http.Redirect(w, r, "/login", http.StatusSeeOther) + return + } + if !user.IsAdmin { + http.NotFound(w, r) + return + } + p.log.Info("admin viewed the cluster", "user", user.ID, "email", user.Email) + dashboard(w, r) + } +} diff --git a/internal/web/templates/account.html b/internal/web/templates/account.html index aebecd3a..0de16f7a 100644 --- a/internal/web/templates/account.html +++ b/internal/web/templates/account.html @@ -54,6 +54,7 @@ Tell whoever you asked for access that you have signed up.

{{.User.Name}} · {{.User.Email}} · project {{.User.ProjectID}}