Health card: public addresses up top, checks as tiles

The public IPv4 and IPv6 addresses, with their uplink, lead the card.
Every other check is a tile with a plain-word status, the raw setting
and, when it fails, what is wrong. The header counts passing or failing
checks.

README.md

@@ -40,19 +40,6 @@ dependencies on the server: the binary installs, updates and removes itself.
 - **HTTPS built in:** Let's Encrypt, a self-signed certificate, your own
   certificate files, or plain HTTP behind a reverse proxy.
 
-## Screenshots
-
-| | |
-|---|---|
-| ![Peers list with status, endpoint, latency sparklines and 30-day traffic](screenshots/peers.png) | ![Peer page with traffic and latency charts, connection details and history](screenshots/peer.png) |
-| **Peers:** status, endpoint, latency and traffic at a glance | **Peer:** traffic, latency, connection history and settings |
-| ![Server page with health checks, interface, endpoint, client defaults and firewall](screenshots/server.png) | ![Settings with users, web interface and API tokens](screenshots/settings.png) |
-| **Server:** health, address plan, client defaults and firewall | **Settings:** users, web interface and API tokens |
-| ![My account page with profile, password and own app tokens](screenshots/account.png) | ![Sign-in page](screenshots/login.png) |
-| **My account:** profile, password and your app tokens | **Sign-in** |
-
-The screenshots show sample data from the built-in simulator.
-
 ## Security
 
 - **Client private keys are never stored.** A config is shown once, as a
@@ -65,8 +52,19 @@ The screenshots show sample data from the built-in simulator.
   `CAP_NET_ADMIN` and `CAP_NET_BIND_SERVICE`, and can write only to
   `/opt/ghostwire`.
 - **Sign-in:** one or more users, all admins. Passwords are stored as argon2id hashes.
-  After 5 failed attempts, sign-in is locked for 15 minutes. Sessions use an
+  After 5 failed attempts from one IP address, sign-in from it is locked for 15
+  minutes; wrong two-step codes count too. Sessions use an
   HttpOnly, SameSite=Strict cookie and last 12 hours by default.
+- **Two-step sign-in:** each user can add an authenticator app (TOTP) and
+  passkeys under My account. A passkey signs in on its own, without username
+  and password, and also works as the second step after a password. It can live
+  on the device (Touch ID, Face ID, Windows Hello), in a password manager, or on
+  a YubiKey with a PIN set. Turning it on gives 10 one-time recovery codes. An
+  admin can require it for everyone (Settings → Sign-in) and reset it for a user
+  who lost their phone or key. Passkeys use WebAuthn and need the server's
+  domain name with a trusted certificate (Let's Encrypt, certificate files, or a
+  reverse proxy); on a self-signed certificate or an IP address, only the
+  authenticator app is offered. API tokens never need a second step.
 - **API tokens** are stored only as hashes and can be read-only or full access.
 - `config.json` holds the server private key and is readable only by the
   service (0600).
@@ -219,7 +217,7 @@ After editing `config.json` by hand, run `sudo systemctl reload ghostwire`.
 | File | Content |
 |---|---|
 | `GHOSTWIRE` | the program |
-| `config.json` | all settings, server key, peers, token hashes (0600) |
+| `config.json` | all settings, server key, peers, pending setup links with their PINs, user password hashes, authenticator app secrets, passkeys, recovery code and token hashes (0600) |
 | `stats.json` | traffic and connection history per peer |
 | `geo-country.mmdb`, `geo-asn.mmdb` | DB-IP Lite databases for country and network lookups |
 | `GHOSTWIRE.jsonl` | log, one JSON object per line. Changes carry `"audit":true` |
@@ -231,18 +229,33 @@ Base path `/api/v1`. The web interface signs in with a session cookie; every
 user is an admin. Apps and scripts use `Authorization: Bearer <token>`; create
 the token under Settings → Pair iOS app. A token belongs to the user who made
 it and is revoked when that user is deleted. A read-only token may only use
-GET. Full-access tokens can do everything the web interface does except backup
-and restore. Users, passwords and API tokens need a full-access token even for
-reading.
+GET. Full-access tokens can do everything the web interface does except the
+endpoints marked "signed in": users, passwords, API tokens, the sign-in rules,
+backup and restore.
+
+For a user with two-step sign-in, `POST /auth/login` answers
+`{"mfa": true, "ticket": "…", "methods": ["key", "totp", "recovery"]}`
+instead of starting a session; the ticket is good for 5 minutes, and one of
+the `/auth/login/…` steps turns it into the session. `PATCH /settings`
+`{"signin": {"requireMfa": true}}` requires two-step sign-in for every user;
+only a signed-in user can change it.
 
 `POST /users` and `POST /users/{id}/reset-password` take
 `{"password": "…", "mustChangePassword": true}`; with `true` (the default) the
 user can do nothing but choose a new password at the next sign-in.
 
 ```
-POST   /auth/login · /auth/logout        GET /auth/me        POST /auth/password (own password)
-GET    /users      POST /users           PATCH /users/{id}   DELETE /users/{id}
-POST   /users/{id}/reset-password
+POST   /auth/login · /auth/logout        GET /auth/me
+signed in: POST /auth/password (own password)
+signed in: GET|POST /users · PATCH|DELETE /users/{id}
+signed in: POST /users/{id}/reset-password · /users/{id}/reset-mfa
+GET    /auth/options (public: is passkey sign-in offered here)
+POST   /auth/login/totp · /auth/login/recovery {"ticket", "code"}
+POST   /auth/login/key/begin {"ticket"} · /auth/login/key/finish?ticket=  (body: the WebAuthn credential)
+POST   /auth/login/passkey/begin · /auth/login/passkey/finish?id=
+signed in: GET /auth/mfa · POST /auth/mfa/totp/setup · /auth/mfa/totp/confirm · DELETE /auth/mfa/totp
+signed in: POST /auth/mfa/keys/begin · /auth/mfa/keys/finish?name= · PATCH|DELETE /auth/mfa/keys/{id}
+signed in: POST /auth/mfa/recovery-codes
 GET    /status                           GET /stats?range=24h|7d|30d|90d
 GET    /server         PATCH /server     POST /server/rotate-key     GET /server/detect-ip
 GET    /peers          POST /peers       (returns the config and QR once)
@@ -253,8 +266,7 @@ GET    /peers/{id}/latency               (24 h, one point per 5 minutes)
 GET    /peers/{id}/setup (not read-only) DELETE /peers/{id}/setup
 GET    /settings       PATCH /settings   POST /restart
 GET    /logs?level=&limit=&audit=1       GET /logs/download
-GET    /tokens     POST /tokens          DELETE /tokens/{id}
-signed in: GET /backup · POST /restore
+signed in: GET|POST /tokens · DELETE /tokens/{id} · GET /backup · POST /restore
 public: GET /setup/{token} · POST /setup/{token} {"pin"}   (what a setup link opens)
 ```
 
@@ -284,8 +296,9 @@ override a drop in another table, so if ufw or firewalld is active, allow UDP
 ## iOS app
 
 The native iPhone app (SwiftUI, iOS 17+) lives in its own project,
-GHOSTWIRE-Companion. It does everything the web interface does except
-password, API tokens and backups. Pair it in the web interface under
+GHOSTWIRE-Companion. It manages peers, the server and the app settings and
+shows stats and logs. Users, passwords, API tokens, two-step sign-in, backup
+and restore stay in the web interface. Pair it in the web interface under
 Settings → Pair iOS app: scan the QR code, or tap "Copy pairing code" and paste
 it into the app's "Enter manually". Self-signed certificates are pinned during
 pairing.

api.go

@@ -84,6 +84,11 @@ func (a *App) guard(adminOnly bool, h http.HandlerFunc) http.HandlerFunc {
 			writeJSON(w, http.StatusForbidden, map[string]string{"error": "choose a new password first", "code": "password_change_required"})
 			return
 		}
+		if p.MFASetupRequired && r.URL.Path != "/api/v1/auth/me" && r.URL.Path != "/api/v1/auth/password" &&
+			!strings.HasPrefix(r.URL.Path, "/api/v1/auth/mfa") {
+			writeJSON(w, http.StatusForbidden, map[string]string{"error": "set up two-step sign-in first", "code": "mfa_setup_required"})
+			return
+		}
 		if p.Scope == "ro" && r.Method != http.MethodGet {
 			writeJSON(w, http.StatusForbidden, map[string]string{"error": "this token is read-only"})
 			return
@@ -92,17 +97,6 @@ func (a *App) guard(adminOnly bool, h http.HandlerFunc) http.HandlerFunc {
 	}
 }
 
-// fullAccess refuses read-only tokens, also for GET.
-func fullAccess(h http.HandlerFunc) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		if who(r).Scope == "ro" {
-			writeJSON(w, http.StatusForbidden, map[string]string{"error": "this token is read-only"})
-			return
-		}
-		h(w, r)
-	}
-}
-
 // applyResult saves-then-applies: the config is already stored, so a kernel
 // error is reported but does not undo the change.
 func (a *App) apply() string {
@@ -116,18 +110,36 @@ func (a *App) routes() http.Handler {
 	mux := http.NewServeMux()
 	g := func(pattern string, h http.HandlerFunc) { mux.HandleFunc(pattern, a.guard(false, h)) }
 	adm := func(pattern string, h http.HandlerFunc) { mux.HandleFunc(pattern, a.guard(true, h)) }
-	// full is for signed-in users and full-access tokens, even for reading.
-	full := func(pattern string, h http.HandlerFunc) { mux.HandleFunc(pattern, a.guard(false, fullAccess(h))) }
 
 	mux.HandleFunc("POST /api/v1/auth/login", a.login)
 	mux.HandleFunc("POST /api/v1/auth/logout", a.logout)
+	// The second step of signing in, and signing in with a passkey alone.
+	mux.HandleFunc("GET /api/v1/auth/options", a.signInOptions)
+	mux.HandleFunc("POST /api/v1/auth/login/totp", a.loginTOTP)
+	mux.HandleFunc("POST /api/v1/auth/login/recovery", a.loginRecovery)
+	mux.HandleFunc("POST /api/v1/auth/login/key/begin", a.loginKeyBegin)
+	mux.HandleFunc("POST /api/v1/auth/login/key/finish", a.loginKeyFinish)
+	mux.HandleFunc("POST /api/v1/auth/login/passkey/begin", a.loginPasskeyBegin)
+	mux.HandleFunc("POST /api/v1/auth/login/passkey/finish", a.loginPasskeyFinish)
+	// Your own two-step sign-in. Keys and passkeys need a browser, so these
+	// are for signed-in users only.
+	adm("GET /api/v1/auth/mfa", a.mfaStatus)
+	adm("POST /api/v1/auth/mfa/totp/setup", a.totpSetup)
+	adm("POST /api/v1/auth/mfa/totp/confirm", a.totpConfirm)
+	adm("DELETE /api/v1/auth/mfa/totp", a.totpRemove)
+	adm("POST /api/v1/auth/mfa/keys/begin", a.keyBegin)
+	adm("POST /api/v1/auth/mfa/keys/finish", a.keyFinish)
+	adm("PATCH /api/v1/auth/mfa/keys/{id}", a.keyRename)
+	adm("DELETE /api/v1/auth/mfa/keys/{id}", a.keyRemove)
+	adm("POST /api/v1/auth/mfa/recovery-codes", a.newRecoveryCodesHandler)
 	g("GET /api/v1/auth/me", a.me)
-	full("POST /api/v1/auth/password", a.changePassword)
-	full("GET /api/v1/users", a.listUsers)
-	full("POST /api/v1/users", a.createUser)
-	full("PATCH /api/v1/users/{id}", a.patchUser)
-	full("POST /api/v1/users/{id}/reset-password", a.resetPassword)
-	full("DELETE /api/v1/users/{id}", a.deleteUser)
+	adm("POST /api/v1/auth/password", a.changePassword)
+	adm("GET /api/v1/users", a.listUsers)
+	adm("POST /api/v1/users", a.createUser)
+	adm("PATCH /api/v1/users/{id}", a.patchUser)
+	adm("POST /api/v1/users/{id}/reset-password", a.resetPassword)
+	adm("DELETE /api/v1/users/{id}", a.deleteUser)
+	adm("POST /api/v1/users/{id}/reset-mfa", a.resetMFA)
 
 	g("GET /api/v1/status", a.status)
 	g("GET /api/v1/stats", a.allStats)
@@ -157,13 +169,14 @@ func (a *App) routes() http.Handler {
 	mux.HandleFunc("POST /api/v1/setup/{token}", a.setupRedeem)
 
 	// Full-access tokens (the iOS app) may change app settings, read logs and
-	// manage users and tokens. Backups need a signed-in user.
+	// restart. Users, passwords, API tokens, the sign-in rules and backups
+	// need a signed-in user.
 	g("GET /api/v1/settings", a.getSettings)
 	g("PATCH /api/v1/settings", a.patchSettings)
 	g("POST /api/v1/restart", a.restart)
-	full("GET /api/v1/tokens", a.listTokens)
-	full("POST /api/v1/tokens", a.createToken)
-	full("DELETE /api/v1/tokens/{id}", a.deleteToken)
+	adm("GET /api/v1/tokens", a.listTokens)
+	adm("POST /api/v1/tokens", a.createToken)
+	adm("DELETE /api/v1/tokens/{id}", a.deleteToken)
 	g("GET /api/v1/logs", a.logs)
 	g("GET /api/v1/logs/download", a.downloadLog)
 	adm("GET /api/v1/backup", a.backup)
@@ -203,16 +216,22 @@ func (a *App) login(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	ip := remoteIP(r)
-	id, err := a.auth.Login(in.Username, in.Password, ip)
+	id, ticket, err := a.auth.Login(in.Username, in.Password, ip)
 	if err != nil {
 		slog.Warn("login failed", "user", in.Username, "remote", ip, "reason", err.Error())
 		code := http.StatusUnauthorized
-		if errors.Is(err, errLocked) {
+		if errors.Is(err, errLocked) || errors.Is(err, errBusy) {
 			code = http.StatusTooManyRequests
 		}
 		writeJSON(w, code, map[string]string{"error": err.Error()})
 		return
 	}
+	if ticket != "" {
+		// The password was right; the second step makes the session.
+		_, u := a.auth.ticketUserID(ticket)
+		writeJSON(w, http.StatusOK, map[string]any{"mfa": true, "ticket": ticket, "methods": mfaMethods(u)})
+		return
+	}
 	a.setSessionCookie(w, r, id)
 	slog.Info("login", "audit", true, "actor", in.Username, "remote", ip)
 	writeJSON(w, http.StatusOK, map[string]any{"ok": true})
@@ -237,10 +256,7 @@ func (a *App) me(w http.ResponseWriter, r *http.Request) {
 	p := who(r)
 	out := map[string]any{
 		"id": p.UserID, "name": p.Name, "isAdmin": p.IsAdmin, "scope": p.Scope,
-		"mustChangePassword": p.MustChangePassword, "version": version, "session": p.Session,
-	}
-	if p.TokenID != "" {
-		out["tokenId"] = p.TokenID // lets an app find its own token in /tokens
+		"mustChangePassword": p.MustChangePassword, "mfaSetupRequired": p.MFASetupRequired, "version": version, "session": p.Session,
 	}
 	if _, u := a.store.Get().userByID(p.UserID); u != nil {
 		out["username"], out["note"], out["created"] = u.Username, u.Note, u.Created
@@ -977,14 +993,14 @@ func (a *App) issueConfig(w http.ResponseWriter, r *http.Request) {
 func (a *App) getSettings(w http.ResponseWriter, r *http.Request) {
 	cfg := a.store.Get()
 	writeJSON(w, http.StatusOK, map[string]any{
-		"web":           cfg.Web,
-		"log":           cfg.Log,
-		"stats":         cfg.Stats,
-		"decoy":         cfg.Decoy,
-		"geo":           a.geoStatus(),
-		"adminUsername": a.username(cfg, who(r).UserID), // kept for older iOS app versions
-		"fingerprint":   a.tls.Fingerprint(),
-		"logPath":       a.logPath,
+		"web":         cfg.Web,
+		"log":         cfg.Log,
+		"stats":       cfg.Stats,
+		"decoy":       cfg.Decoy,
+		"signin":      cfg.SignIn,
+		"geo":         a.geoStatus(),
+		"fingerprint": a.tls.Fingerprint(),
+		"logPath":     a.logPath,
 	})
 }
 
@@ -994,8 +1010,8 @@ func (a *App) patchSettings(w http.ResponseWriter, r *http.Request) {
 		writeErr(w, err)
 		return
 	}
-	if _, ok := m["adminUsername"]; ok {
-		writeErr(w, badRequest("usernames are changed under /users"))
+	if _, ok := m["signin"]; ok && !who(r).IsAdmin {
+		writeJSON(w, http.StatusForbidden, map[string]string{"error": "API tokens cannot change the sign-in rules; sign in to the web interface"})
 		return
 	}
 	var restart bool
@@ -1012,6 +1028,9 @@ func (a *App) patchSettings(w http.ResponseWriter, r *http.Request) {
 		if err := field(m, "decoy", &c.Decoy); err != nil {
 			return err
 		}
+		if err := field(m, "signin", &c.SignIn); err != nil {
+			return err
+		}
 		return field(m, "log", &c.Log)
 	})
 	if err != nil {

app.css

@@ -136,10 +136,16 @@ h1 { margin: 0; font-size: 26px; font-weight: 600; letter-spacing: -0.01em; over
 table { width: 100%; border-collapse: collapse; min-width: 720px; }
 table.narrow { min-width: 520px; }
 th { text-align: left; font-size: 12px; font-weight: 600; color: var(--ink-2); padding: 10px 12px; border-bottom: 1px solid var(--line); white-space: nowrap; }
+th .sort { display: inline-flex; align-items: center; gap: 4px; background: none; border: 0; padding: 0; font: inherit; color: inherit; cursor: pointer; }
+th .sort:hover, th .sort.on { color: var(--ink); }
+th .sort .arrow { font-size: 11px; opacity: 0.35; }
+th .sort:hover .arrow, th .sort.on .arrow { opacity: 1; }
 td { padding: 12px; border-bottom: 1px solid var(--line-2); vertical-align: middle; }
 tr:last-child td { border-bottom: 0; }
 .num { text-align: right; font-variant-numeric: tabular-nums; white-space: nowrap; }
 td .note { font-size: 12px; color: var(--ink-3); }
+a.pname { color: var(--ink); font-weight: 600; text-decoration: none; }
+a.pname:hover, a.pname:focus-visible { color: var(--ink); text-decoration: underline; text-underline-offset: 3px; }
 .empty { padding: 24px 12px; margin: 0; text-align: center; color: var(--ink-3); }
 
 /* forms */
@@ -167,10 +173,28 @@ fieldset { border: 0; margin: 0; padding: 0; min-width: 0; display: flex; flex-d
 .kv dt { color: var(--ink-2); }
 .kv dd { margin: 0; min-width: 0; overflow-wrap: anywhere; }
 
-/* checks */
-.chk { display: flex; gap: 10px; align-items: center; padding: 10px 0; border-bottom: 1px solid var(--line-2); font-size: 13px; }
-.chk:last-child { border-bottom: 0; }
-.chk b { font-weight: 500; min-width: 160px; }
+/* health: public addresses, then one tile per check */
+.hchead { display: flex; align-items: baseline; gap: 12px; flex-wrap: wrap; }
+.hchead > span { font-size: 13px; color: var(--ink-2); }
+.hchead > span.bad { color: var(--bad-ink); font-weight: 500; }
+.hcaddrs { display: grid; grid-template-columns: repeat(auto-fit, minmax(260px, 1fr)); gap: 12px; margin-top: 16px; }
+.hcaddr { background: var(--ground); border-radius: 10px; padding: 14px 16px; min-width: 0; }
+.hcaddr .l { display: flex; align-items: center; gap: 8px; font-size: 12px; color: var(--ink-2); }
+.hcaddr .v { margin-top: 4px; font-size: 15px; font-weight: 500; overflow-wrap: anywhere; }
+.hcaddr .v.mono { font-size: 20px; }
+.hcaddr .n { font-family: var(--sans); font-size: 12px; font-weight: 400; color: var(--ink-2); }
+.hcaddr.bad { background: #fdf6f5; box-shadow: inset 0 0 0 1px #e6b3b0; }
+.hcaddr.bad .v { color: var(--bad-ink); }
+.hctiles { display: grid; grid-template-columns: repeat(auto-fill, minmax(190px, 1fr)); gap: 12px; margin-top: 12px; }
+.hctile { border: 1px solid var(--line); border-radius: 10px; padding: 12px 14px; display: flex; flex-direction: column; gap: 4px; min-width: 0; }
+.hctile .l { display: flex; align-items: center; gap: 8px; font-size: 12px; color: var(--ink-2); }
+.hctile .l > span:first-child { flex: 1; min-width: 0; }
+.hctile .s { font-size: 15px; font-weight: 500; }
+.hctile .r { font-size: 11.5px; color: var(--ink-3); overflow-wrap: anywhere; }
+.hctile .p { font-size: 12.5px; color: var(--bad-ink); overflow-wrap: anywhere; }
+.hctile.bad { border-color: #e6b3b0; background: #fdf6f5; }
+.hctile.bad .s { color: var(--bad-ink); }
+@media (max-width: 640px) { .hctiles { grid-template-columns: repeat(2, minmax(0, 1fr)); } }
 
 /* activity */
 .ev { display: flex; gap: 12px; padding: 10px 0; border-bottom: 1px solid var(--line-2); font-size: 13px; }
@@ -272,7 +296,6 @@ dialog::backdrop { background: rgba(22, 23, 26, .55); }
 .linkbtn { background: none; border: 0; padding: 4px; font: inherit; font-size: 13px; color: #9cc3f5; text-decoration: underline; cursor: pointer; align-self: center; }
 .linkbtn:hover { color: #fff; }
 .loginform .err-text:empty { display: none; }
-.loginfoot { margin: 0; font-family: var(--mono); font-size: 11px; letter-spacing: 0.08em; text-transform: uppercase; color: #8d8e93; }
 .err-text { color: var(--bad-ink); font-size: 13px; margin: 0; }
 /* setup link page (setup.html): same dark look as the login page */
 .setuppage { min-height: 100vh; display: flex; justify-content: center; padding: 48px 16px; background: var(--ink); color: #f4f4f1; font-size: 15px; }
@@ -304,3 +327,18 @@ dialog::backdrop { background: rgba(22, 23, 26, .55); }
 .steps .btn.primary { background: #f4f4f1; border-color: #f4f4f1; color: var(--ink); font-weight: 600; }
 .steps .qr { width: 100%; height: auto; max-width: 280px; align-self: center; }
 .loading-page { padding: 40px; color: var(--ink-3); }
+
+/* two-step sign-in */
+.loginalt { width: 100%; display: flex; flex-direction: column; gap: 14px; margin-top: -24px; }
+.loginalt .or, .loginform .or { display: flex; align-items: center; gap: 10px; color: #8d8e93; font-size: 12px; }
+.loginalt .or::before, .loginalt .or::after { content: ""; flex: 1; height: 1px; background: #2c2d32; }
+.loginpage .btn.altbtn { min-height: 44px; width: 100%; font-size: 15px; font-weight: 500; background: none; border-color: #3a3b41; color: #f4f4f1; margin-top: 0; }
+.loginpage .btn.altbtn:hover { background: #222328; border-color: #55565c; color: #fff; }
+.loginlinks { display: flex; flex-direction: column; align-items: center; gap: 2px; margin-top: 6px; }
+.loginform .codeinput { text-align: center; font-size: 20px; letter-spacing: 0.2em; }
+.mfalist { display: flex; flex-direction: column; }
+.mfarow { display: flex; align-items: center; gap: 8px; padding: 12px 0; border-top: 1px solid var(--line-2); }
+.mfarow:first-child { border-top: 0; padding-top: 0; }
+.mfarow .grow { flex: 1; min-width: 0; }
+.dlg .secret { font-size: 15px; letter-spacing: 0.04em; overflow-wrap: anywhere; }
+.dlg .codes { columns: 2; font-size: 15px; line-height: 1.8; }

app.js

@@ -48,6 +48,7 @@
     server: '<rect x="3" y="4" width="18" height="7" rx="1.5"/><rect x="3" y="13" width="18" height="7" rx="1.5"/><path d="M7 7.5h.01M7 16.5h.01"/>',
     settings: '<path d="M4 6h10M18 6h2M4 12h4M12 12h8M4 18h12"/><circle cx="16" cy="6" r="2"/><circle cx="10" cy="12" r="2"/><circle cx="18" cy="18" r="2"/>',
     plus: '<path d="M12 5v14M5 12h14"/>',
+    key: '<circle cx="8" cy="15" r="4"/><path d="M11 12l9-9M17 6l3 3M14 9l2 2"/>',
     logout: '<path d="M14 4h4a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2h-4"/><path d="M10 16l-4-4 4-4M6 12h10"/>',
   };
 
@@ -138,6 +139,15 @@
     return ts + '  ' + String(l.level).padEnd(5) + '  ' + l.msg + (rest ? '  ' + rest : '');
   }
 
+  // mfaText summarizes a user's two-step sign-in: "App, 2 keys" or "".
+  function mfaText(m) {
+    if (!m) return '';
+    const parts = [];
+    if (m.totp) parts.push('App');
+    if (m.passkeys) parts.push(m.passkeys === 1 ? '1 passkey' : m.passkeys + ' passkeys');
+    return parts.join(', ');
+  }
+
   // "Germany · Deutsche Telekom AG", "Local network" or "".
   function fmtLocation(g) {
     if (!g) return '';
@@ -216,7 +226,7 @@
     const r = await fetch('/api/v1' + path, opt);
     let data = {};
     try { data = await r.json(); } catch { /* empty body */ }
-    if (r.status === 401 && path !== '/auth/login' && path !== '/auth/me') {
+    if (r.status === 401 && !path.startsWith('/auth/login') && path !== '/auth/me') {
       me = null;
       showLogin();
       throw new Error('Signed out');
@@ -225,6 +235,10 @@
       showNewPassword();
       throw new Error('Signed out');
     }
+    if (r.status === 403 && data.code === 'mfa_setup_required') {
+      showMFASetup();
+      throw new Error('Signed out');
+    }
     if (!r.ok) throw new Error(data.error || r.statusText);
     return data;
   }
@@ -243,13 +257,26 @@
     else if (okMsg) toast(okMsg);
   }
 
+  // dialog shows a modal dialog. Extensions such as Bitwarden move elements
+  // around in <body>; a moved dialog stays open but drops out of the top
+  // layer to the bottom of the page, so it is shown as a modal again. That
+  // goes through close(), whose close event arrives after the dialog is open
+  // again and is kept from the listeners added by callers.
   function dialog(build) {
     const d = h('dialog');
     const close = () => d.close();
-    d.addEventListener('close', () => d.remove());
+    const moved = new MutationObserver(() => {
+      if (d.open && d.isConnected && !d.matches(':modal')) { d.close(); d.showModal(); }
+    });
+    d.addEventListener('close', (e) => {
+      if (d.open) { e.stopImmediatePropagation(); return; }
+      moved.disconnect();
+      d.remove();
+    });
     d.append(build(close));
     document.body.append(d);
     d.showModal();
+    moved.observe(document.body, { childList: true, subtree: true });
     return d;
   }
 
@@ -566,6 +593,7 @@
       try { me = await api('GET', '/auth/me'); } catch { showLogin(); return; }
     }
     if (me.mustChangePassword) { showNewPassword(); return; }
+    if (me.mfaSetupRequired) { showMFASetup(); return; }
     if (!main || !main.isConnected) buildShell();
     every(30000, refreshSide);
     const hash = location.hash || '#/';
@@ -604,9 +632,9 @@
       err.textContent = '';
       btn.disabled = true;
       try {
-        await api('POST', '/auth/login', { username: user.value, password: pw.value });
-        me = await api('GET', '/auth/me');
-        if (me.mustChangePassword) showNewPassword(pw.value); else render();
+        const res = await api('POST', '/auth/login', { username: user.value, password: pw.value });
+        if (res.mfa) { showSecondStep(res.ticket, res.methods, pw.value); return; }
+        await signedIn(pw.value);
       } catch (x) {
         err.textContent = x.message;
         btn.disabled = false;
@@ -616,13 +644,301 @@
     h('div', { class: 'field' }, h('label', { htmlFor: 'u' }, 'Username'), user),
     h('div', { class: 'field' }, h('label', { htmlFor: 'p' }, 'Password'), pw),
     err, btn);
+    // A passkey signs in without username and password, where the address
+    // allows it.
+    const passkeyRow = h('div', { class: 'loginalt', hidden: true },
+      h('div', { class: 'or' }, 'or'),
+      h('button', { type: 'button', class: 'btn altbtn signin', onClick: async () => {
+        err.textContent = '';
+        try {
+          const b = await api('POST', '/auth/login/passkey/begin');
+          const cred = await webauthnGet(b.options);
+          await api('POST', '/auth/login/passkey/finish?id=' + encodeURIComponent(b.id), cred);
+          await signedIn();
+        } catch (x) { err.textContent = keyError(x); }
+      } }, icon('key', 18), h('span', { class: 'en' }, 'Sign in with a passkey'), h('span', { class: 'ja', lang: 'ja', 'aria-hidden': 'true' }, 'パスキーでサインイン')));
+    if (window.PublicKeyCredential) {
+      api('GET', '/auth/options').then((o) => { passkeyRow.hidden = !o.passkeys; }).catch(() => {});
+    }
     app.replaceChildren(h('div', { class: 'loginpage' }, h('div', { class: 'loginbox' },
       brand(72),
-      form),
-      h('p', { class: 'loginfoot' }, 'WireGuard server manager')));
+      form, passkeyRow)));
     user.focus();
   }
 
+  // signedIn continues after a successful sign-in. password is the one just
+  // typed, if any, so a temporary password need not be typed again.
+  async function signedIn(password) {
+    me = await api('GET', '/auth/me');
+    if (me.mustChangePassword) showNewPassword(password); else render();
+  }
+
+  // ---------- two-step sign-in ----------
+
+  const b64dec = (s) => {
+    const b = atob(s.replace(/-/g, '+').replace(/_/g, '/') + '='.repeat((4 - s.length % 4) % 4));
+    return Uint8Array.from(b, (c) => c.charCodeAt(0)).buffer;
+  };
+  const b64enc = (buf) => btoa(String.fromCharCode(...new Uint8Array(buf))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+
+  // webauthnCreate and webauthnGet turn the server's options into the
+  // browser call and the browser's answer back into JSON.
+  async function webauthnCreate(opts) {
+    const pk = opts.publicKey;
+    pk.challenge = b64dec(pk.challenge);
+    pk.user.id = b64dec(pk.user.id);
+    (pk.excludeCredentials || []).forEach((c) => { c.id = b64dec(c.id); });
+    const c = await navigator.credentials.create({ publicKey: pk });
+    return {
+      id: c.id, rawId: b64enc(c.rawId), type: c.type, authenticatorAttachment: c.authenticatorAttachment,
+      response: {
+        clientDataJSON: b64enc(c.response.clientDataJSON), attestationObject: b64enc(c.response.attestationObject),
+        transports: c.response.getTransports ? c.response.getTransports() : [],
+      },
+      clientExtensionResults: c.getClientExtensionResults(),
+    };
+  }
+
+  async function webauthnGet(opts) {
+    const pk = opts.publicKey;
+    pk.challenge = b64dec(pk.challenge);
+    (pk.allowCredentials || []).forEach((c) => { c.id = b64dec(c.id); });
+    const c = await navigator.credentials.get({ publicKey: pk });
+    return {
+      id: c.id, rawId: b64enc(c.rawId), type: c.type, authenticatorAttachment: c.authenticatorAttachment,
+      response: {
+        clientDataJSON: b64enc(c.response.clientDataJSON), authenticatorData: b64enc(c.response.authenticatorData),
+        signature: b64enc(c.response.signature), userHandle: c.response.userHandle ? b64enc(c.response.userHandle) : null,
+      },
+      clientExtensionResults: c.getClientExtensionResults(),
+    };
+  }
+
+  // keyError explains a failed key or passkey prompt.
+  function keyError(x) {
+    if (x && x.name === 'NotAllowedError') return 'Cancelled or timed out. Try again.';
+    if (x && x.name === 'InvalidStateError') return 'This key is already set up for your account.';
+    if (x && x.name === 'SecurityError') return 'Passkeys need this site on its domain name with a trusted certificate.';
+    return x.message;
+  }
+
+  // showSecondStep asks for a key, an authenticator code or a recovery code
+  // after a correct password.
+  function showSecondStep(ticket, methods, password) {
+    cleanups.forEach((f) => f());
+    cleanups = [];
+    main = null;
+    const canKey = methods.includes('key') && !!window.PublicKeyCredential;
+    let mode = canKey ? 'key' : methods.includes('totp') ? 'totp' : 'recovery';
+    const box = h('div', { class: 'loginform' });
+    const TITLES = {
+      key: ['Use your passkey', 'Confirm with Touch ID, Face ID, Windows Hello or your password manager, or insert your YubiKey and touch it.'],
+      totp: ['Enter the code', 'The 6-digit code from your authenticator app.'],
+      recovery: ['Use a recovery code', 'One of the codes you saved when you set up two-step sign-in. Each works once.'],
+    };
+    const LINKS = { key: 'Use a passkey instead', totp: 'Use an authenticator code instead', recovery: 'Use a recovery code' };
+    const head = h('div', { class: 'logintext' });
+    const draw = () => {
+      const err = h('p', { class: 'err-text', role: 'alert' });
+      head.replaceChildren(h('h1', null, TITLES[mode][0]), h('p', null, TITLES[mode][1]));
+      const others = ['key', 'totp', 'recovery'].filter((m) => m !== mode && methods.includes(m) && (m !== 'key' || canKey))
+        .map((m) => h('button', { type: 'button', class: 'linkbtn', onClick: () => { mode = m; draw(); } }, LINKS[m]));
+      const foot = h('div', { class: 'loginlinks' }, others, h('button', { type: 'button', class: 'linkbtn', onClick: showLogin }, 'Start over'));
+      if (mode === 'key') {
+        const btn = h('button', { type: 'button', class: 'btn primary' }, 'Use passkey');
+        const go = async () => {
+          err.textContent = '';
+          btn.disabled = true;
+          try {
+            const opts = await api('POST', '/auth/login/key/begin', { ticket });
+            const cred = await webauthnGet(opts);
+            await api('POST', '/auth/login/key/finish?ticket=' + encodeURIComponent(ticket), cred);
+            await signedIn(password);
+          } catch (x) { err.textContent = keyError(x); btn.disabled = false; }
+        };
+        btn.addEventListener('click', go);
+        box.replaceChildren(err, btn, foot);
+        btn.focus();
+        return;
+      }
+      const code = h('input', { id: 'mc', autocomplete: 'one-time-code', autocapitalize: 'none', required: true,
+        inputMode: mode === 'totp' ? 'numeric' : 'text', class: 'mono codeinput', placeholder: mode === 'totp' ? '123 456' : 'XXXX-XXXX' });
+      const btn = h('button', { type: 'submit', class: 'btn primary' }, 'Verify');
+      box.replaceChildren(h('form', { class: 'loginform', onSubmit: async (e) => {
+        e.preventDefault();
+        err.textContent = '';
+        btn.disabled = true;
+        try {
+          await api('POST', '/auth/login/' + mode, { ticket, code: code.value });
+          await signedIn(password);
+        } catch (x) {
+          err.textContent = x.message;
+          btn.disabled = false;
+          code.select();
+        }
+      } }, h('div', { class: 'field' }, h('label', { htmlFor: 'mc', class: 'sr' }, TITLES[mode][0]), code), err, btn), foot);
+      code.focus();
+    };
+    app.replaceChildren(h('div', { class: 'loginpage' }, h('div', { class: 'loginbox' }, brand(72), head, box)));
+    draw();
+  }
+
+  // showMFASetup is the screen for a user who must set up two-step sign-in
+  // before doing anything else.
+  async function showMFASetup() {
+    cleanups.forEach((f) => f());
+    cleanups = [];
+    main = null;
+    let st = { keysAvailable: false };
+    try { st = await api('GET', '/auth/mfa'); } catch { /* offer the app only */ }
+    const done = async () => { me = await api('GET', '/auth/me'); render(); };
+    const keys = st.keysAvailable && window.PublicKeyCredential;
+    app.replaceChildren(h('div', { class: 'loginpage' }, h('div', { class: 'loginbox' },
+      brand(72),
+      h('div', { class: 'logintext' },
+        h('h1', null, 'Set up two-step sign-in'),
+        h('p', null, 'This server asks for a second step after the password. Add one to continue.')),
+      h('div', { class: 'loginform' },
+        h('button', { type: 'button', class: 'btn primary', onClick: () => addTOTP(done) }, 'Use an authenticator app'),
+        keys ? h('button', { type: 'button', class: 'btn altbtn', onClick: () => addPasskey(done) }, 'Use a passkey') : null,
+        h('div', { class: 'loginlinks' }, h('button', { type: 'button', class: 'linkbtn', onClick: logout }, 'Sign out'))))));
+  }
+
+  // recoveryDialog shows new recovery codes once.
+  function recoveryDialog(codes, onClose) {
+    const text = codes.join('\n');
+    const d = dialog((close) => h('div', { class: 'dlg' },
+      h('h2', null, 'Your recovery codes'),
+      h('p', null, 'If you lose your phone or key, each of these signs you in once. Store them somewhere safe, such as your password manager. They are not shown again.'),
+      h('pre', { class: 'code codes' }, text),
+      h('div', { class: 'actions' },
+        h('button', { type: 'button', class: 'btn', onClick: () => copy(text) }, 'Copy'),
+        h('button', { type: 'button', class: 'btn', onClick: () => download(APP.toLowerCase() + '-recovery-codes.txt', text + '\n') }, 'Download')),
+      h('div', { class: 'foot' }, h('button', { type: 'button', class: 'btn primary', onClick: close }, 'Done'))));
+    if (onClose) d.addEventListener('close', onClose);
+  }
+
+  // afterAdd shows recovery codes when the method was the first one.
+  const afterAdd = (res, onDone) => {
+    if (res.recoveryCodes && res.recoveryCodes.length) recoveryDialog(res.recoveryCodes, onDone);
+    else if (onDone) onDone();
+  };
+
+  async function addTOTP(onDone) {
+    let s;
+    try { s = await api('POST', '/auth/mfa/totp/setup'); } catch (x) { toast(x.message, true); return; }
+    const code = h('input', { id: 'tc', class: 'mono', autocomplete: 'one-time-code', inputMode: 'numeric', placeholder: '123 456', required: true });
+    const e = h('p', { class: 'err-text', role: 'alert' });
+    dialog((close) => h('form', { class: 'dlg', onSubmit: async (ev) => {
+      ev.preventDefault();
+      e.textContent = '';
+      try {
+        const res = await api('POST', '/auth/mfa/totp/confirm', { code: code.value });
+        close();
+        toast('Authenticator app turned on');
+        afterAdd(res, onDone);
+      } catch (x) { e.textContent = x.message; code.select(); }
+    } },
+    h('h2', null, 'Add an authenticator app'),
+    h('div', { class: 'qrrow' },
+      h('img', { class: 'qr', src: s.qr, alt: 'QR code for the authenticator app' }),
+      h('div', { class: 'col' },
+        h('p', null, 'Scan the code with your authenticator app, for example 1Password, Google Authenticator or Authy. Or enter this key by hand:'),
+        h('code', { class: 'mono secret' }, s.secret.match(/.{1,4}/g).join(' ')),
+        h('div', null, h('button', { type: 'button', class: 'btn small', onClick: () => copy(s.secret) }, 'Copy key')))),
+    h('div', { class: 'field' }, h('label', { htmlFor: 'tc' }, 'Code from the app'), code),
+    e,
+    h('div', { class: 'foot' }, h('button', { type: 'button', class: 'btn', onClick: close }, 'Cancel'), h('button', { type: 'submit', class: 'btn primary' }, 'Turn on'))));
+    code.focus();
+  }
+
+  // addPasskey adds a passkey. It signs in on its own, and also serves as
+  // the second step after a password.
+  function addPasskey(onDone) {
+    const nm = h('input', { id: 'kn', value: 'Passkey', autocomplete: 'off', maxLength: 64 });
+    const e = h('p', { class: 'err-text', role: 'alert' });
+    const btn = h('button', { type: 'submit', class: 'btn primary' }, 'Add passkey');
+    dialog((close) => h('form', { class: 'dlg', onSubmit: async (ev) => {
+      ev.preventDefault();
+      e.textContent = '';
+      btn.disabled = true;
+      try {
+        const opts = await api('POST', '/auth/mfa/keys/begin');
+        const cred = await webauthnCreate(opts);
+        const res = await api('POST', '/auth/mfa/keys/finish?name=' + encodeURIComponent(nm.value.trim()), cred);
+        close();
+        toast('Passkey added');
+        afterAdd(res, onDone);
+      } catch (x) { e.textContent = keyError(x); btn.disabled = false; }
+    } },
+    h('h2', null, 'Add a passkey'),
+    h('p', null, 'A passkey signs you in on its own, without username and password, and also works as the second step after your password. It can live on this device (Touch ID, Face ID, Windows Hello), in your password manager, or on a YubiKey with a PIN set.'),
+    h('div', { class: 'field' }, h('label', { htmlFor: 'kn' }, 'Name'), nm, h('span', { class: 'hint' }, 'So you can tell your passkeys apart, for example "MacBook" or "YubiKey"')),
+    e,
+    h('div', { class: 'foot' }, h('button', { type: 'button', class: 'btn', onClick: close }, 'Cancel'), btn)));
+    nm.select();
+  }
+
+  // mfaCard is the "Two-step sign-in" section of My account.
+  function mfaCard() {
+    const body = h('div', null, h('p', { class: 'muted' }, 'Loading…'));
+    const card = h('section', { class: 'card', 'aria-labelledby': 'mfa' },
+      h('h2', { id: 'mfa' }, 'Two-step sign-in'),
+      h('p', { class: 'lead' }, 'Asks for a second proof after your password. App tokens, like the iOS app\'s, are not affected.'),
+      body);
+    const draw = async () => {
+      let s;
+      try { s = await api('GET', '/auth/mfa'); } catch (x) { body.replaceChildren(h('p', { class: 'err-text' }, x.message)); return; }
+      const keys = s.keysAvailable && window.PublicKeyCredential;
+      const removeKey = async (k) => {
+        if (!await confirmDialog({ title: 'Remove ' + k.name + '?', text: 'It can no longer be used to sign in.', ok: 'Remove', danger: true })) return;
+        try { await api('DELETE', '/auth/mfa/keys/' + k.id); toast('Removed ' + k.name); draw(); } catch (x) { toast(x.message, true); }
+      };
+      const renameKey = (k) => {
+        const nm = h('input', { id: 'rk', value: k.name, maxLength: 64, required: true });
+        const e = h('p', { class: 'err-text', role: 'alert' });
+        dialog((close) => h('form', { class: 'dlg', onSubmit: async (ev) => {
+          ev.preventDefault();
+          try { await api('PATCH', '/auth/mfa/keys/' + k.id, { name: nm.value.trim() }); close(); draw(); } catch (x) { e.textContent = x.message; }
+        } }, h('h2', null, 'Rename key'), h('div', { class: 'field' }, h('label', { htmlFor: 'rk' }, 'Name'), nm), e,
+        h('div', { class: 'foot' }, h('button', { type: 'button', class: 'btn', onClick: close }, 'Cancel'), h('button', { type: 'submit', class: 'btn primary' }, 'Save'))));
+        nm.select();
+      };
+      const removeTOTP = async () => {
+        if (!await confirmDialog({ title: 'Remove the authenticator app?', text: 'Its codes stop working for this account.', ok: 'Remove', danger: true })) return;
+        try { await api('DELETE', '/auth/mfa/totp'); toast('Authenticator app removed'); draw(); } catch (x) { toast(x.message, true); }
+      };
+      const newCodes = async () => {
+        if (!await confirmDialog({ title: 'Make new recovery codes?', text: 'Your old codes stop working.', ok: 'Make new codes' })) return;
+        try { recoveryDialog((await api('POST', '/auth/mfa/recovery-codes')).recoveryCodes, draw); } catch (x) { toast(x.message, true); }
+      };
+      const rows = [];
+      if (s.totp) {
+        rows.push(h('div', { class: 'mfarow' }, h('div', { class: 'grow' }, h('strong', null, 'Authenticator app'), h('div', { class: 'hint' }, 'Added ' + fmtDate(s.totpAdded))),
+          h('button', { type: 'button', class: 'btn danger small', onClick: removeTOTP }, 'Remove')));
+      }
+      for (const k of s.keys) {
+        rows.push(h('div', { class: 'mfarow' }, h('div', { class: 'grow' }, h('strong', null, k.name),
+          h('div', { class: 'hint' }, 'Added ' + fmtDate(k.created) + ' · ' + (k.lastUsed ? 'last used ' + ago(k.lastUsed) : 'not used yet'))),
+        h('button', { type: 'button', class: 'btn small', onClick: () => renameKey(k) }, 'Rename'),
+        h('button', { type: 'button', class: 'btn danger small', onClick: () => removeKey(k) }, 'Remove')));
+      }
+      if (rows.length) {
+        rows.push(h('div', { class: 'mfarow' }, h('div', { class: 'grow' }, h('strong', null, 'Recovery codes'), h('div', { class: 'hint' }, s.recoveryLeft + ' of 10 left')),
+          h('button', { type: 'button', class: 'btn small', onClick: newCodes }, 'New codes')));
+      }
+      body.replaceChildren(...[
+        rows.length ? h('div', { class: 'mfalist' }, rows) : h('div', { class: 'notice' }, s.required ? 'Two-step sign-in is required on this server.' : 'Two-step sign-in is off for your account.'),
+        h('div', { class: 'actions section' },
+          s.totp ? null : h('button', { type: 'button', class: 'btn primary', onClick: () => addTOTP(draw) }, 'Add authenticator app'),
+          keys ? h('button', { type: 'button', class: 'btn', onClick: () => addPasskey(draw) }, 'Add passkey') : null),
+        keys ? null : h('p', { class: 'hint section' }, 'Passkeys need this site on its domain name with a trusted certificate (Let\'s Encrypt or certificate files).'),
+      ].filter(Boolean));
+    };
+    draw();
+    return card;
+  }
+
   // showNewPassword is the screen after signing in with a temporary password
   // an admin chose. current is that password when the user just typed it.
   function showNewPassword(current) {
@@ -658,8 +974,7 @@
       h('div', { class: 'logintext' },
         h('h1', null, me ? 'Welcome, ' + me.name : 'Choose a new password'),
         h('p', null, 'An admin gave you a temporary password. Choose your own to continue.')),
-      form),
-      h('p', { class: 'loginfoot' }, 'WireGuard server manager')));
+      form)));
     (cur || p1).focus();
   }
 
@@ -740,9 +1055,50 @@
 
   // ---------- peers ----------
 
+  // PEER_SORT holds the sort keys of the peers table. Each returns a value
+  // where smaller sorts first; null always sorts last. Numbers start
+  // descending, text ascending.
+  const STATE_ORDER = ['online', 'offline', 'never', 'setup', 'nokey', 'disabled'];
+  const ipNum = (ip) => ip.split('.').reduce((n, o) => n * 256 + Number(o), 0);
+  const PEER_SORT = {
+    name: { label: 'Name', key: (p) => p.name.toLowerCase() },
+    address: { label: 'Address', key: (p) => ipNum(p.ipv4) },
+    status: { label: 'Status', key: (p) => STATE_ORDER.indexOf(peerState(p).key) * 1e13 - (p.stats.lastHandshake ? Date.parse(p.stats.lastHandshake) : 0) },
+    endpoint: { label: 'Endpoint', key: (p) => p.stats.endpoint ? ((p.stats.location && p.stats.location.country) || '~') + ' ' + p.stats.endpoint : null },
+    latency: { label: 'Latency', num: true, asc: true, key: (p) => { const st = latState(p); return st && st.ms != null ? st.ms : null; } },
+    down: { label: 'Download, 30 d', num: true, key: (p) => p.stats.down30d },
+    up: { label: 'Upload, 30 d', num: true, key: (p) => p.stats.up30d },
+    enabled: { label: 'Enabled', key: (p) => (p.enabled ? 0 : 1) },
+  };
+  let peerSort = { by: null, desc: false }; // kept while the app is open
+
   async function viewPeers(wrap) {
     let q = '', filter = 'all', data = await api('GET', '/peers');
     const tbody = h('tbody');
+    const headRow = h('tr');
+    const sortBy = (k) => {
+      const c = PEER_SORT[k];
+      peerSort = peerSort.by === k ? { by: k, desc: !peerSort.desc } : { by: k, desc: c.num && !c.asc };
+      drawHead();
+      drawRows();
+    };
+    const drawHead = () => headRow.replaceChildren(
+      ...Object.entries(PEER_SORT).map(([k, c]) => {
+        const on = peerSort.by === k;
+        return h('th', { class: c.num ? 'num' : null, 'aria-sort': on ? (peerSort.desc ? 'descending' : 'ascending') : 'none' },
+          h('button', { type: 'button', class: on ? 'sort on' : 'sort', onClick: () => sortBy(k) }, c.label,
+            h('span', { class: 'arrow', 'aria-hidden': 'true' }, on ? (peerSort.desc ? '↓' : '↑') : '↕')));
+      }),
+      h('th', null, h('span', { class: 'sr' }, 'Actions')));
+    const sorted = (rows) => {
+      if (!peerSort.by) return rows;
+      const key = PEER_SORT[peerSort.by].key, dir = peerSort.desc ? -1 : 1;
+      return rows.map((p) => [p, key(p)]).sort(([a, ka], [b, kb]) => {
+        if (ka == null || kb == null) return ka == null && kb == null ? 0 : ka == null ? 1 : -1;
+        const c = typeof ka === 'string' ? ka.localeCompare(kb) : ka - kb;
+        return c * dir || a.name.localeCompare(b.name);
+      }).map(([p]) => p);
+    };
     const empty = h('p', { class: 'empty', hidden: true }, 'No peers match this filter.');
     const sub = h('p', { class: 'sub' });
     const pills = h('div', { class: 'pills', role: 'group', 'aria-label': 'Status filter' });
@@ -767,8 +1123,8 @@
         const keep = filter === 'all' || filter === st || (filter === 'offline' && ['offline', 'never', 'setup', 'nokey'].includes(st));
         return hit && keep;
       });
-      tbody.replaceChildren(...rows.map((p) => h('tr', null,
-        h('td', null, h('a', { href: '#/peers/' + p.id }, h('strong', null, p.name)), p.note ? h('div', { class: 'note' }, p.note) : null),
+      tbody.replaceChildren(...sorted(rows).map((p) => h('tr', null,
+        h('td', null, h('a', { class: 'pname', href: '#/peers/' + p.id }, p.name), p.note ? h('div', { class: 'note' }, p.note) : null),
         h('td', { class: 'mono' }, p.ipv4),
         h('td', null, badge(peerState(p))),
         h('td', { class: 'mono muted' }, p.stats.endpoint || '–',
@@ -782,6 +1138,7 @@
     };
 
     drawPills();
+    drawHead();
     drawRows();
     fill(wrap,
       h('div', { class: 'head' },
@@ -792,8 +1149,7 @@
         h('input', { id: 'q', type: 'search', placeholder: 'Search name, address or note', style: { flex: '1 1 260px', maxWidth: '360px' }, onInput: (e) => { q = e.target.value.toLowerCase(); drawRows(); } }),
         pills),
       h('section', { class: 'card flush' }, h('div', { class: 'tbl' }, h('table', null,
-        h('thead', null, h('tr', null, ['Name', 'Address', 'Status', 'Endpoint'].map((t) => h('th', null, t)),
-          h('th', { class: 'num' }, 'Latency'), h('th', { class: 'num' }, 'Download, 30 d'), h('th', { class: 'num' }, 'Upload, 30 d'), h('th', null, 'Enabled'), h('th', null, h('span', { class: 'sr' }, 'Actions')))),
+        h('thead', null, headRow),
         tbody), empty)),
       h('p', { class: 'muted', style: { margin: '0', fontSize: '13px' } }, 'Online means a handshake in the last 3 minutes. Latency is the round trip from the server through the tunnel to the device and back, median of the last 5 minutes; turn it on in a peer\'s settings. Download and Upload are measured from the peer\'s side. Changes apply live without disconnecting other peers.'));
     every(15000, async () => { try { data = await api('GET', '/peers'); drawRows(); } catch { /* keep last */ } });
@@ -937,8 +1293,24 @@
   // ---------- peer detail ----------
 
   async function viewPeer(wrap, id) {
-    const [p, srv, sess] = await Promise.all([api('GET', '/peers/' + id), api('GET', '/server'), api('GET', '/peers/' + id + '/sessions?limit=50')]);
+    const [p, srv, sess] = await Promise.all([api('GET', '/peers/' + id), api('GET', '/server'), api('GET', '/peers/' + id + '/sessions?limit=100')]);
     const sessions = sess.sessions;
+    // The history shows the newest rows; the rest open on request.
+    const SHORT = 8;
+    let allSessions = false;
+    const sessBody = h('tbody');
+    const sessMore = h('button', { type: 'button', class: 'btn small', onClick: () => { allSessions = !allSessions; drawSessions(); } });
+    const drawSessions = () => {
+      sessBody.replaceChildren(...(allSessions ? sessions : sessions.slice(0, SHORT)).map((se) => h('tr', null,
+        h('td', null, fmtStamp(se.start)),
+        h('td', null, se.open ? [h('span', { class: 'badge' }, h('span', { class: 'dot ok' }), 'Online now'), ' ', fmtDuration(se.seconds)] : fmtDuration(se.seconds)),
+        h('td', null, fmtLocation(se.geo) || h('span', { class: 'muted' }, 'Unknown')),
+        h('td', { class: 'mono muted' }, se.ip),
+        h('td', { class: 'num' }, fmtBytes(se.down)),
+        h('td', { class: 'num' }, fmtBytes(se.up)))));
+      sessMore.textContent = allSessions ? 'Show fewer' : 'Show all ' + sessions.length;
+    };
+    drawSessions();
     let range = '7d';
     const st = peerState(p);
     const traffic = h('div');
@@ -1111,14 +1483,9 @@
         sessions.length ? h('div', { class: 'tbl' }, h('table', null,
           h('thead', null, h('tr', null, h('th', null, 'Started'), h('th', null, 'Duration'), h('th', null, 'From'), h('th', null, 'Address'),
             h('th', { class: 'num' }, 'Download'), h('th', { class: 'num' }, 'Upload'))),
-          h('tbody', null, sessions.map((se) => h('tr', null,
-            h('td', null, fmtStamp(se.start)),
-            h('td', null, se.open ? [h('span', { class: 'badge' }, h('span', { class: 'dot ok' }), 'Online now'), ' ', fmtDuration(se.seconds)] : fmtDuration(se.seconds)),
-            h('td', null, fmtLocation(se.geo) || h('span', { class: 'muted' }, 'Unknown')),
-            h('td', { class: 'mono muted' }, se.ip),
-            h('td', { class: 'num' }, fmtBytes(se.down)),
-            h('td', { class: 'num' }, fmtBytes(se.up)))))))
+          sessBody))
           : h('p', { class: 'empty' }, 'No connections recorded yet.'),
+        sessions.length > SHORT ? h('div', { style: { margin: '8px 12px 0' } }, sessMore) : null,
         h('p', { class: 'hint', style: { margin: '4px 12px 12px' } }, 'Country and network: ',
           h('a', { href: 'https://db-ip.com', target: '_blank', rel: 'noopener' }, 'IP Geolocation by DB-IP'),
           '. Kept as long as the daily traffic history.')),
@@ -1143,6 +1510,69 @@
 
   const DNS_PRESETS = [['Quad9', '9.9.9.9, 149.112.112.112']];
 
+  // healthParts turns the server's checks into the Health card: the public
+  // address per IP family (from its uplink and public address checks), then
+  // one tile per other check with a plain-word status, the raw setting and,
+  // when it fails, what is wrong.
+  function healthParts(checks) {
+    const by = Object.fromEntries(checks.map((c) => [c.name, c]));
+    const addrs = [];
+    for (const fam of ['IPv4', 'IPv6']) {
+      const up = by[fam + ' uplink'], pub = by['Public ' + fam];
+      if (!up) continue;
+      const m = pub && pub.ok ? /^(\S+) \((.+)\)$/.exec(pub.detail) : null;
+      addrs.push({
+        label: 'Public ' + fam + (up.ok ? ' · ' + up.detail : ''),
+        ok: up.ok && (!pub || pub.ok),
+        value: m ? m[1] : (pub ? pub.detail : up.detail),
+        note: m ? m[2] : null,
+        mono: !!(pub && pub.ok),
+      });
+    }
+    const sysctl = (d) => d.replace(/^net\.ipv[46]\.(conf\.)?/, '');
+    const tiles = checks.filter((c) => !/^(IPv[46] uplink|Public IPv[46])$/.test(c.name)).map((c) => {
+      const t = { label: c.name, ok: c.ok, status: c.ok ? 'OK' : 'Problem', raw: null, problem: c.ok ? null : c.detail };
+      switch (c.name) {
+        case 'WireGuard interface': t.status = c.detail; t.problem = null; break;
+        case 'IPv4 forwarding': case 'IPv6 forwarding': t.status = c.ok ? 'On' : 'Off'; t.raw = sysctl(c.detail); t.problem = null; break;
+        case 'IPv6 router announcements': {
+          const [setting, ...why] = c.detail.split(': ');
+          t.label = 'Router announcements';
+          t.status = !c.ok ? 'Ignored' : setting.endsWith('=0') ? 'Not used' : 'Accepted';
+          t.raw = sysctl(setting);
+          t.problem = c.ok || !why.length ? null : why.join(': ');
+          break;
+        }
+        case 'nftables rules':
+          t.status = c.ok ? 'Present' : 'Missing';
+          if (/^table /.test(c.detail)) { t.raw = c.detail.replace(/ (present|missing)$/, ''); t.problem = null; }
+          break;
+        case 'Last apply':
+          if (c.ok) { const iso = c.detail.replace(/^applied /, ''); t.status = ago(iso); t.title = fmtStamp(iso); } else t.status = 'Failed';
+          break;
+        case 'Latency check': t.status = c.ok ? 'Tunnel ping works' : 'Failing'; break;
+      }
+      return t;
+    });
+    return { addrs, tiles, failing: checks.filter((c) => !c.ok).length, total: checks.length };
+  }
+
+  function healthCard(checks) {
+    const hp = healthParts(checks);
+    const dot = (ok) => [h('span', { class: ok ? 'dot ok' : 'dot bad' }), h('span', { class: 'sr' }, ok ? 'OK: ' : 'Problem: ')];
+    return h('section', { class: 'card', 'aria-labelledby': 'hc' },
+      h('div', { class: 'hchead' }, h('h2', { id: 'hc' }, 'Health'),
+        h('span', { class: hp.failing ? 'bad' : null }, hp.failing ? hp.failing + ' of ' + hp.total + ' checks failing' : 'All ' + hp.total + ' checks pass')),
+      hp.addrs.length ? h('div', { class: 'hcaddrs' }, hp.addrs.map((a) => h('div', { class: a.ok ? 'hcaddr' : 'hcaddr bad' },
+        h('div', { class: 'l' }, dot(a.ok), a.label),
+        h('div', { class: a.mono ? 'v mono' : 'v' }, a.value, a.note ? h('span', { class: 'n' }, ' ' + a.note) : null)))) : null,
+      h('div', { class: 'hctiles' }, hp.tiles.map((t) => h('div', { class: t.ok ? 'hctile' : 'hctile bad', title: t.title || null },
+        h('div', { class: 'l' }, h('span', null, t.label), dot(t.ok)),
+        h('div', { class: 's' }, t.status),
+        t.raw ? h('div', { class: 'r mono' }, t.raw) : null,
+        t.problem ? h('div', { class: 'p' }, t.problem) : null))));
+  }
+
   async function viewServer(wrap) {
     const [srv, st] = await Promise.all([api('GET', '/server'), api('GET', '/status')]);
     const orig = JSON.parse(JSON.stringify(srv));
@@ -1213,11 +1643,7 @@
     fill(wrap,
       h('div', null, h('h1', null, 'Server'), h('p', { class: 'sub' }, 'WireGuard interface, address plan, client defaults and firewall')),
       result,
-      h('section', { class: 'card', 'aria-labelledby': 'hc' },
-        h('h2', { id: 'hc' }, 'Health'),
-        h('div', { style: { marginTop: '8px' } }, st.checks.map((c) => h('div', { class: 'chk' },
-          h('span', { class: c.ok ? 'dot ok' : 'dot bad' }), h('span', { class: 'sr' }, c.ok ? 'OK: ' : 'Problem: '),
-          h('b', null, c.name), h('span', { class: c.ok ? 'muted' : null }, c.detail))))),
+      healthCard(st.checks),
 
       h('section', { class: 'card', 'aria-labelledby': 'if' },
         h('h2', { id: 'if' }, 'Interface'),
@@ -1357,6 +1783,8 @@
         pwErr,
         h('div', { class: 'formfoot' }, h('button', { type: 'submit', class: 'btn primary' }, 'Change password'))),
 
+      mfaCard(),
+
       h('section', { class: 'card flush', 'aria-labelledby': 'mytk' },
         h('div', { class: 'cardhead' },
           h('div', null, h('h2', { id: 'mytk' }, 'My app tokens'), h('p', { class: 'lead', style: { marginBottom: '0' } }, 'Tokens you created for the iOS app and scripts. All tokens are listed under Settings → API tokens.')),
@@ -1379,6 +1807,7 @@
     const drawUsers = (users) => userBody.replaceChildren(...users.map((u) => h('tr', null,
       h('td', null, h('strong', null, u.username), u.you ? h('span', { class: 'tag plain' }, 'You') : null, u.note ? h('div', { class: 'note' }, u.note) : null),
       h('td', null, u.mustChangePassword ? h('span', { class: 'badge warn' }, 'Must choose a password') : h('span', { class: 'muted' }, 'Active')),
+      h('td', null, mfaText(u.mfa) ? h('span', { class: 'badge' }, mfaText(u.mfa)) : h('span', { class: s.signin.requireMfa ? 'badge warn' : 'muted' }, 'Off')),
       h('td', null, u.lastLogin ? ago(u.lastLogin.at) + ' · ' + u.lastLogin.ip : h('span', { class: 'muted' }, 'Not since restart')),
       h('td', null, u.tokens ? String(u.tokens) : h('span', { class: 'muted' }, 'None')),
       h('td', null, fmtDate(u.created)),
@@ -1452,6 +1881,7 @@
       must.el,
       h('div', { class: 'actions' },
         h('button', { type: 'button', class: 'btn', onClick: () => { close(); resetUser(u); } }, 'Reset password…'),
+        mfaText(u.mfa) ? h('button', { type: 'button', class: 'btn', onClick: () => { close(); resetMFA(u); } }, 'Reset two-step sign-in…') : null,
         h('button', { type: 'button', class: 'btn danger', onClick: () => { close(); deleteUser(u); } }, 'Delete user…')),
       e,
       h('div', { class: 'foot' }, h('button', { type: 'button', class: 'btn', onClick: close }, 'Cancel'), h('button', { type: 'submit', class: 'btn primary' }, 'Save'))));
@@ -1475,6 +1905,10 @@
       pw.el, must.el, e,
       h('div', { class: 'foot' }, h('button', { type: 'button', class: 'btn', onClick: close }, 'Cancel'), h('button', { type: 'submit', class: 'btn primary' }, 'Reset password'))));
     };
+    const resetMFA = async (u) => {
+      if (!await confirmDialog({ title: 'Reset two-step sign-in for ' + u.username + '?', text: 'Their authenticator app, passkeys and recovery codes are removed. They sign in with their password and can set it up again.', ok: 'Reset', danger: true })) return;
+      try { await api('POST', '/users/' + u.id + '/reset-mfa'); toast('Two-step sign-in reset for ' + u.username); reloadUsers(); } catch (x) { toast(x.message, true); }
+    };
     const deleteUser = async (u) => {
       const tokens = u.tokens ? ' Their ' + (u.tokens === 1 ? 'app token is' : u.tokens + ' app tokens are') + ' revoked too.' : '';
       if (!await confirmDialog({ title: 'Delete ' + u.username + '?', text: u.username + ' is signed out and can no longer sign in.' + tokens, ok: 'Delete user', danger: true })) return;
@@ -1546,8 +1980,28 @@
       try { await api('PATCH', '/settings', { log: { ...s.log, level: e.target.value } }); s.log.level = e.target.value; toast('Log level: ' + e.target.value); } catch (x) { toast(x.message, true); }
     } }, ['debug', 'info', 'warn', 'error'].map((l) => h('option', { value: l, selected: s.log.level === l }, l)));
 
+    // sign-in rules
+    const requireBox = h('input', { type: 'checkbox', id: 'rq', checked: s.signin.requireMfa, onChange: async (e) => {
+      const on = e.target.checked;
+      if (on) {
+        const mine = us.users.find((u) => u.you);
+        const without = us.users.filter((u) => !mfaText(u.mfa)).map((u) => u.username);
+        const text = 'Users without two-step sign-in must set it up right after their next sign-in, before they can do anything else. API tokens are not affected.' +
+          (without.length ? ' Not set up yet: ' + without.join(', ') + '.' : '') +
+          (mine && !mfaText(mine.mfa) ? ' That includes you: you are asked to set it up now.' : '');
+        if (!await confirmDialog({ title: 'Require two-step sign-in?', text, ok: 'Require it' })) { e.target.checked = false; return; }
+      }
+      try {
+        await api('PATCH', '/settings', { signin: { ...s.signin, requireMfa: on } });
+        s.signin.requireMfa = on;
+        toast(on ? 'Two-step sign-in required' : 'Two-step sign-in optional');
+        me = await api('GET', '/auth/me');
+        if (me.mfaSetupRequired) showMFASetup(); else reloadUsers();
+      } catch (x) { e.target.checked = !on; toast(x.message, true); }
+    } });
+
     // decoy
-    const decoyPages = [['nginx', 'nginx welcome page'], ['apache', 'Apache "It works!" page'], ['soon', '"Coming soon" page']];
+    const decoyPages = [['nginx', 'nginx welcome page'], ['apache', 'Apache "It works!" page'], ['soon', '"Coming soon" page'], ['blank', 'Blank page'], ['forbidden', '"Forbidden" page'], ['private', '"Private server" page']];
     const decoyBox = h('input', { type: 'checkbox', id: 'dc', checked: s.decoy.enabled, onChange: async (e) => {
       const on = e.target.checked;
       if (on) {
@@ -1625,9 +2079,15 @@
           h('div', null, h('h2', { id: 'usr' }, 'Users'), h('p', { class: 'lead', style: { marginBottom: '0' } }, 'Everyone here is an admin. You cannot delete yourself, so one user always remains.')),
           h('button', { type: 'button', class: 'btn primary', onClick: addUser }, 'Add user')),
         h('div', { class: 'tbl' }, h('table', null,
-          h('thead', null, h('tr', null, h('th', null, 'User'), h('th', null, 'Status'), h('th', null, 'Last sign-in'), h('th', null, 'App tokens'), h('th', null, 'Created'), h('th', null, h('span', { class: 'sr' }, 'Actions')))),
+          h('thead', null, h('tr', null, h('th', null, 'User'), h('th', null, 'Status'), h('th', null, 'Two-step'), h('th', null, 'Last sign-in'), h('th', null, 'App tokens'), h('th', null, 'Created'), h('th', null, h('span', { class: 'sr' }, 'Actions')))),
           userBody))),
 
+      h('section', { class: 'card', 'aria-labelledby': 'sgn' },
+        h('h2', { id: 'sgn' }, 'Sign-in'),
+        h('p', { class: 'lead' }, 'Everyone sets up two-step sign-in under My account: an authenticator app or passkeys, including on a YubiKey. Changes apply immediately.'),
+        h('label', { class: 'check' }, requireBox, h('span', null, 'Require two-step sign-in for everyone', h('br'),
+          h('span', { class: 'hint' }, 'Users without it are asked to set it up right after their password. To help someone who lost their phone or key, use Edit → Reset two-step sign-in.')))),
+
       h('form', { class: 'card', onSubmit: saveWeb, 'aria-labelledby': 'web' },
         h('h2', { id: 'web' }, 'Web interface'),
         h('p', { class: 'lead' }, 'Changes take effect after the service restarts.'),

auth.go

@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"net"
 	"net/http"
+	"net/netip"
 	"strings"
 	"sync"
 	"time"
@@ -26,12 +27,23 @@ const (
 	argonKeyLen  = 32
 )
 
+// Every argon2 run takes argonMemory (64 MiB). argonSlots caps how many run
+// at once, so a burst of sign-ins cannot run the server out of memory: two
+// slots are 128 MiB at most.
+var argonSlots = make(chan struct{}, 2)
+
+func argonKey(pw, salt []byte, t, m uint32, p uint8, n uint32) []byte {
+	argonSlots <- struct{}{}
+	defer func() { <-argonSlots }()
+	return argon2.IDKey(pw, salt, t, m, p, n)
+}
+
 func hashPassword(pw string) (string, error) {
 	salt := make([]byte, 16)
 	if _, err := rand.Read(salt); err != nil {
 		return "", err
 	}
-	key := argon2.IDKey([]byte(pw), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
+	key := argonKey([]byte(pw), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
 	b64 := base64.RawStdEncoding
 	return fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
 		argon2.Version, argonMemory, argonTime, argonThreads, b64.EncodeToString(salt), b64.EncodeToString(key)), nil
@@ -54,7 +66,7 @@ func verifyPassword(encoded, pw string) bool {
 	if err1 != nil || err2 != nil {
 		return false
 	}
-	got := argon2.IDKey([]byte(pw), salt, t, m, p, uint32(len(want)))
+	got := argonKey([]byte(pw), salt, t, m, p, uint32(len(want)))
 	return subtle.ConstantTimeCompare(got, want) == 1
 }
 
@@ -102,7 +114,10 @@ type principal struct {
 	RemoteIP string
 	// MustChangePassword blocks everything but changing the password.
 	MustChangePassword bool
-	Session            *sessionInfo // nil for API tokens
+	// MFASetupRequired blocks everything but setting up two-step sign-in,
+	// when it is required and the user has none.
+	MFASetupRequired bool
+	Session          *sessionInfo // nil for API tokens
 }
 
 // sessionInfo is when and from where a browser session started.
@@ -136,37 +151,71 @@ type Auth struct {
 	mu       sync.Mutex
 	sessions map[string]*session
 	used     map[string]tokenUse
-	logins   map[string]tokenUse // last sign-in per user ID
-	fails    map[string]*failState
+	logins   map[string]tokenUse   // last sign-in per user ID
+	fails    map[string]*failState // by lockKey
+	waiting  int                   // sign-ins waiting for or running a password check
+	mfa      mfaState
 }
 
 const (
 	maxFailures = 5
 	lockoutTime = 15 * time.Minute
+	// maxWaiting sign-ins may wait for a password check; more are turned
+	// away until the queue is shorter.
+	maxWaiting = 16
 )
 
 func newAuth(s *Store) *Auth {
-	return &Auth{store: s, sessions: map[string]*session{}, used: map[string]tokenUse{}, logins: map[string]tokenUse{}, fails: map[string]*failState{}}
+	return &Auth{store: s, sessions: map[string]*session{}, used: map[string]tokenUse{}, logins: map[string]tokenUse{}, fails: map[string]*failState{}, mfa: newMFAState()}
 }
 
 func cookieName() string { return appName + "_session" }
 
-var errLocked = errors.New("too many failed attempts, try again later")
+var (
+	errLocked = errors.New("too many failed attempts, try again later")
+	errBusy   = errors.New("too many sign-ins at once, try again in a moment")
+)
 
-// Login checks the credentials and returns a new session id.
-func (a *Auth) Login(user, pw, ip string) (string, error) {
-	a.mu.Lock()
-	f := a.fails[ip]
-	if f != nil && time.Now().Before(f.until) {
-		a.mu.Unlock()
-		return "", errLocked
+// lockKey is what failed sign-ins are counted by: the IPv4 address, or the
+// /64 network of an IPv6 address, since one device can pick any address in
+// its /64.
+func lockKey(ip string) string {
+	a, err := netip.ParseAddr(ip)
+	if err != nil || a.Unmap().Is4() {
+		return ip
 	}
-	a.mu.Unlock()
+	p, _ := a.Prefix(64)
+	return p.String()
+}
 
+// Login checks the credentials and returns a new session id, or, for a user
+// with two-step sign-in, a ticket for the second step.
+func (a *Auth) Login(user, pw, ip string) (sessionID, ticket string, err error) {
 	cfg := a.store.Get()
 	if !cfg.passwordSet() {
-		return "", errors.New("no password is set; run: " + appName + " passwd")
+		return "", "", errors.New("no password is set; run: " + appName + " passwd")
 	}
+	// The attempt counts as failed before the password is checked, so
+	// parallel attempts cannot get past the lockout; a right password takes
+	// it back.
+	a.mu.Lock()
+	if a.lockedLocked(ip) {
+		a.mu.Unlock()
+		return "", "", errLocked
+	}
+	if a.waiting >= maxWaiting {
+		a.mu.Unlock()
+		return "", "", errBusy
+	}
+	a.waiting++
+	undo := a.failLocked(ip)
+	a.mu.Unlock()
+	defer func() {
+		a.mu.Lock()
+		a.waiting--
+		a.mu.Unlock()
+	}()
+
 	// An unknown username costs as much time as a wrong password, so the
 	// answer time does not tell which usernames exist.
 	u := cfg.userByName(strings.TrimSpace(user))
@@ -180,20 +229,15 @@ func (a *Auth) Login(user, pw, ip string) (string, error) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
 	if !okUser || !okPw {
-		if f == nil {
-			f = &failState{}
-			a.fails[ip] = f
-		}
-		f.count++
-		if f.count >= maxFailures {
-			f.count = 0
-			f.until = time.Now().Add(lockoutTime)
-		}
-		return "", errors.New("wrong username or password")
+		return "", "", errors.New("wrong username or password")
 	}
-	delete(a.fails, ip)
+	undo()
+	if u.hasMFA() {
+		return "", a.newTicketLocked(u, ip), nil
+	}
+	delete(a.fails, lockKey(ip))
 	a.logins[u.ID] = tokenUse{At: time.Now(), IP: ip}
-	return a.newSessionLocked(cfg, u, sessionInfo{Started: time.Now(), IP: ip}), nil
+	return a.newSessionLocked(cfg, u, sessionInfo{Started: time.Now(), IP: ip}), "", nil
 }
 
 // NewSession replaces a session after the user changed their password; it
@@ -290,7 +334,8 @@ func (a *Auth) Authenticate(r *http.Request) (*principal, bool) {
 		return nil, false
 	}
 	info := s.info
-	return &principal{Name: u.Username, UserID: u.ID, Scope: "rw", IsAdmin: true, RemoteIP: ip, MustChangePassword: u.MustChangePassword, Session: &info}, true
+	return &principal{Name: u.Username, UserID: u.ID, Scope: "rw", IsAdmin: true, RemoteIP: ip, MustChangePassword: u.MustChangePassword,
+		MFASetupRequired: cfg.SignIn.RequireMFA && !u.hasMFA(), Session: &info}, true
 }
 
 func (a *Auth) TokenUse(id string) *tokenUse {
@@ -312,9 +357,21 @@ func (a *Auth) sweep() {
 			delete(a.sessions, id)
 		}
 	}
-	for ip, f := range a.fails {
+	for key, f := range a.fails {
 		if now.After(f.until) && f.count == 0 {
-			delete(a.fails, ip)
+			delete(a.fails, key)
+		}
+	}
+	for id, t := range a.mfa.tickets {
+		if now.After(t.expires) {
+			delete(a.mfa.tickets, id)
+		}
+	}
+	for _, m := range []map[string]*ceremony{a.mfa.logins, a.mfa.enrolls} {
+		for id, c := range m {
+			if now.After(c.expires) {
+				delete(m, id)
+			}
 		}
 	}
 }

config.go

@@ -27,12 +27,20 @@ type Config struct {
 	APITokens []APIToken `json:"apiTokens"`
 	// Admin is the single account of config version 1; applyDefaults moves
 	// it into Users.
-	Admin  *Admin      `json:"admin,omitempty"`
-	Server Server      `json:"server"`
-	Peers  []Peer      `json:"peers"`
-	Log    LogConfig   `json:"log"`
-	Stats  StatsConfig `json:"stats"`
-	Decoy  DecoyConfig `json:"decoy"`
+	Admin  *Admin       `json:"admin,omitempty"`
+	Server Server       `json:"server"`
+	Peers  []Peer       `json:"peers"`
+	Log    LogConfig    `json:"log"`
+	Stats  StatsConfig  `json:"stats"`
+	Decoy  DecoyConfig  `json:"decoy"`
+	SignIn SignInConfig `json:"signin"`
+}
+
+// SignInConfig holds the rules for signing in to the web interface.
+type SignInConfig struct {
+	// RequireMFA sends users without two-step sign-in to set it up before
+	// they can do anything else. API tokens are not affected.
+	RequireMFA bool `json:"requireMfa"`
 }
 
 // DecoyConfig replaces the web interface with a stock web server page.
@@ -92,6 +100,7 @@ type User struct {
 	// the user can do nothing else until they pick their own.
 	MustChangePassword bool      `json:"mustChangePassword,omitempty"`
 	Created            time.Time `json:"created"`
+	MFA                *UserMFA  `json:"mfa,omitempty"` // two-step sign-in, nil when never set up
 }
 
 type APIToken struct {
@@ -195,6 +204,9 @@ func (c *Config) applyDefaults() {
 		c.Users = []User{u}
 	}
 	c.Admin = nil
+	for i := range c.Users {
+		dropSecurityKeys(&c.Users[i])
+	}
 	for i := range c.APITokens {
 		if c.APITokens[i].UserID == "" {
 			c.APITokens[i].UserID = c.Users[0].ID // tokens from before users existed

decoy.go

@@ -11,15 +11,20 @@ import (
 // front page is its stock welcome page and everything else is its stock
 // error page. Only /api/v1 and live setup links get past it.
 type decoyPage struct {
-	server string                                 // Server header, "" for none
-	index  func(host string) string               // the front page
-	error  func(code int, r *http.Request) string // body for 404 and 405
+	server    string                                 // Server header, "" for none
+	index     func(host string) string               // the front page
+	indexCode int                                    // status of the front page, 0 for 200
+	error     func(code int, r *http.Request) string // body for 404 and 405
 }
 
 var decoyPages = map[string]decoyPage{
 	"nginx":  {server: nginxServer, index: func(string) string { return nginxIndex }, error: nginxError},
 	"apache": {server: apacheServer, index: func(string) string { return apacheIndex }, error: apacheError},
 	"soon":   {index: soonIndex, error: soonError},
+	// Generic pages that name no server software.
+	"blank":     {index: func(string) string { return "" }, error: func(int, *http.Request) string { return "" }},
+	"forbidden": {index: func(string) string { return forbiddenIndex }, indexCode: http.StatusForbidden, error: soonError},
+	"private":   {index: func(string) string { return privateIndex }, error: soonError},
 }
 
 // serveDecoy writes the decoy's answer for r. It drops the headers the web
@@ -43,6 +48,9 @@ func serveDecoy(w http.ResponseWriter, r *http.Request, name string) {
 		code, body = http.StatusMethodNotAllowed, d.error(http.StatusMethodNotAllowed, r)
 	case r.URL.Path == "/" || r.URL.Path == "/index.html":
 		body = d.index(hostOnly(r.Host))
+		if d.indexCode != 0 {
+			code = d.indexCode
+		}
 	default:
 		code, body = http.StatusNotFound, d.error(http.StatusNotFound, r)
 	}
@@ -537,3 +545,36 @@ const apacheIndex = `<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//
   </body>
 </html>
 `
+
+const forbiddenIndex = `<!DOCTYPE html>
+<html>
+<head><title>403 Forbidden</title></head>
+<body>
+<h1>Forbidden</h1>
+<p>You don't have permission to access this resource.</p>
+</body>
+</html>
+`
+
+const privateIndex = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Private</title>
+<style>
+html, body { height: 100%; margin: 0; }
+body { display: flex; align-items: center; justify-content: center; background: #111; color: #999;
+font-family: Georgia, serif; text-align: center; }
+h1 { font-size: 28px; font-weight: normal; letter-spacing: 0.04em; color: #fff; margin: 0 0 10px; }
+p { margin: 0; font-size: 15px; }
+</style>
+</head>
+<body>
+<main>
+<h1>Private server</h1>
+<p>Nothing to see here.</p>
+</main>
+</body>
+</html>
+`

go.mod

@@ -3,6 +3,7 @@ module ghostwire
 go 1.27.1
 
 require (
+	github.com/go-webauthn/webauthn v0.18.2
 	github.com/google/nftables v0.3.0
 	github.com/oschwald/maxminddb-golang v1.13.1
 	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
@@ -15,11 +16,20 @@ require (
 )
 
 require (
+	github.com/fxamacker/cbor/v2 v2.9.4 // indirect
+	github.com/go-viper/mapstructure/v2 v2.5.0 // indirect
+	github.com/go-webauthn/x v0.3.1 // indirect
+	github.com/golang-jwt/jwt/v5 v5.3.1 // indirect
 	github.com/google/go-cmp v0.6.0 // indirect
+	github.com/google/go-tpm v0.9.8 // indirect
+	github.com/google/uuid v1.6.0 // indirect
 	github.com/mdlayher/genetlink v1.3.2 // indirect
 	github.com/mdlayher/netlink v1.7.3-0.20250113171957-fbb4dce95f42 // indirect
 	github.com/mdlayher/socket v0.5.1 // indirect
+	github.com/philhofer/fwd v1.2.0 // indirect
+	github.com/tinylib/msgp v1.6.4 // indirect
 	github.com/vishvananda/netns v0.0.5 // indirect
+	github.com/x448/float16 v0.8.4 // indirect
 	golang.org/x/sync v0.23.0 // indirect
 	golang.org/x/text v0.42.0 // indirect
 	golang.zx2c4.com/wireguard v0.0.0-20231211153847-12269c276173 // indirect

go.sum

@@ -1,9 +1,23 @@
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/fxamacker/cbor/v2 v2.9.4 h1:xwjVlxEMR3S605oUlgBjKLTTeGFciYPGYCtF/35LKGo=
+github.com/fxamacker/cbor/v2 v2.9.4/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ=
+github.com/go-viper/mapstructure/v2 v2.5.0 h1:vM5IJoUAy3d7zRSVtIwQgBj7BiWtMPfmPEgAXnvj1Ro=
+github.com/go-viper/mapstructure/v2 v2.5.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
+github.com/go-webauthn/webauthn v0.18.2 h1:0BeftmEHU7i3Dv0VFwBtidy/ba37Vcdjvqst9EYu8Sk=
+github.com/go-webauthn/webauthn v0.18.2/go.mod h1:hEXaOuLxvZ3zG9miZe3ehlyeVso9AtklXG+kTn36k+A=
+github.com/go-webauthn/x v0.3.1 h1:1ff37z3XfmTTomkhlURgGizLIDyOvPgTt2t9nlzKLRo=
+github.com/go-webauthn/x v0.3.1/go.mod h1:ZInxAynYXfBPvvm5gzKZ7geBlL23K71xASMgohHl/Rg=
+github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
+github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-tpm v0.9.8 h1:slArAR9Ft+1ybZu0lBwpSmpwhRXaa85hWtMinMyRAWo=
+github.com/google/go-tpm v0.9.8/go.mod h1:h9jEsEECg7gtLis0upRBQU+GhYVH6jMjrFxI8u6bVUY=
+github.com/google/go-tpm-tools v0.3.13-0.20230620182252-4639ecce2aba h1:qJEJcuLzH5KDR0gKc0zcktin6KSAwL7+jWKBYceddTc=
+github.com/google/go-tpm-tools v0.3.13-0.20230620182252-4639ecce2aba/go.mod h1:EFYHy8/1y2KfgTAsx7Luu7NGhoxtuVHnNo8jE7FikKc=
 github.com/google/nftables v0.3.0 h1:bkyZ0cbpVeMHXOrtlFc8ISmfVqq5gPJukoYieyVmITg=
 github.com/google/nftables v0.3.0/go.mod h1:BCp9FsrbF1Fn/Yu6CLUc9GGZFw/+hsxfluNXXmxBfRM=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/mdlayher/genetlink v1.3.2 h1:KdrNKe+CTu+IbZnm/GVUMXSqBBLqcGpRDa0xkQy56gw=
 github.com/mdlayher/genetlink v1.3.2/go.mod h1:tcC3pkCrPUGIKKsCsp0B3AdaaKuHtaxoJRz3cc+528o=
 github.com/mdlayher/netlink v1.7.3-0.20250113171957-fbb4dce95f42 h1:A1Cq6Ysb0GM0tpKMbdCXCIfBclan4oHk1Jb+Hrejirg=
@@ -14,16 +28,24 @@ github.com/mikioh/ipaddr v0.0.0-20190404000644-d465c8ab6721 h1:RlZweED6sbSArvlE9
 github.com/mikioh/ipaddr v0.0.0-20190404000644-d465c8ab6721/go.mod h1:Ickgr2WtCLZ2MDGd4Gr0geeCH5HybhRJbonOgQpvSxc=
 github.com/oschwald/maxminddb-golang v1.13.1 h1:G3wwjdN9JmIK2o/ermkHM+98oX5fS+k5MbwsmL4MRQE=
 github.com/oschwald/maxminddb-golang v1.13.1/go.mod h1:K4pgV9N/GcK694KSTmVSDTODk4IsCNThNdTmnaBZ/F8=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/philhofer/fwd v1.2.0 h1:e6DnBTl7vGY+Gz322/ASL4Gyp1FspeMvx1RNDoToZuM=
+github.com/philhofer/fwd v1.2.0/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM=
 github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e h1:MRM5ITcdelLK2j1vwZ3Je0FKVCfqOLp5zO6trqMLYs0=
 github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e/go.mod h1:XV66xRDqSt+GTGFMVlhk3ULuV0y9ZmzeVGR4mloJI3M=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
+github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
+github.com/tinylib/msgp v1.6.4 h1:mOwYbyYDLPj35mkA2BjjYejgJk9BuHxDdvRnb6v2ZcQ=
+github.com/tinylib/msgp v1.6.4/go.mod h1:RSp0LW9oSxFut3KzESt5Voq4GVWyS+PSulT77roAqEA=
 github.com/vishvananda/netlink v1.3.1 h1:3AEMt62VKqz90r0tmNhog0r/PpWKmrEShJU0wJW6bV0=
 github.com/vishvananda/netlink v1.3.1/go.mod h1:ARtKouGSTGchR8aMwmkzC0qiNPrrWO5JS/XMVl45+b4=
 github.com/vishvananda/netns v0.0.5 h1:DfiHV+j8bA32MFM7bfEunvT8IAqQ/NzSJHtcmW5zdEY=
 github.com/vishvananda/netns v0.0.5/go.mod h1:SpkAiCQRtJ6TvvxPnOSyH3BMl6unz3xZlaprSwhNNJM=
+github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=
+github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=
+go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y=
+go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU=
+go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
+go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
 golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M=
 golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA=
 golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To=
@@ -42,5 +64,3 @@ golang.zx2c4.com/wireguard v0.0.0-20231211153847-12269c276173 h1:/jFs0duh4rdb8uI
 golang.zx2c4.com/wireguard v0.0.0-20231211153847-12269c276173/go.mod h1:tkCQ4FQXmpAgYVh++1cq16/dH4QJtmvpRv19DWGAHSA=
 golang.zx2c4.com/wireguard/wgctrl v0.0.0-20241231184526-a9ab2273dd10 h1:3GDAcqdIg1ozBNLgPy4SLT84nfcBjr6rhGtXYtrkWLU=
 golang.zx2c4.com/wireguard/wgctrl v0.0.0-20241231184526-a9ab2273dd10/go.mod h1:T97yPqesLiNrOYxkwmhMI0ZIlJDm+p0PMR8eRVeR5tQ=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

kernel.go

@@ -3,6 +3,8 @@ package main
 import (
 	"log/slog"
 	"net/netip"
+	"os"
+	"strings"
 	"sync"
 	"time"
 )
@@ -38,6 +40,15 @@ type Kernel interface {
 	Close() error
 }
 
+// readSysctl returns the trimmed content of a /proc/sys file, or "".
+func readSysctl(path string) string {
+	b, err := os.ReadFile(path)
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(b))
+}
+
 // Reconciler applies the config to the kernel whenever it is triggered and
 // remembers the outcome for the health report.
 type Reconciler struct {

kernel_linux.go

@@ -3,13 +3,13 @@
 package main
 
 import (
+	"cmp"
 	"errors"
 	"fmt"
 	"net"
 	"net/netip"
 	"os"
 	"slices"
-	"strings"
 
 	"github.com/vishvananda/netlink"
 	"golang.zx2c4.com/wireguard/wgctrl"
@@ -318,14 +318,6 @@ func publicAddr(uplink string, v6 bool) (bool, string) {
 	return false, "no address on " + uplink
 }
 
-func readSysctl(path string) string {
-	b, err := os.ReadFile(path)
-	if err != nil {
-		return ""
-	}
-	return strings.TrimSpace(string(b))
-}
-
 func (k *linuxKernel) Checks(c *Config) []Check {
 	var out []Check
 	link, err := netlink.LinkByName(c.Server.Interface)
@@ -341,6 +333,19 @@ func (k *linuxKernel) Checks(c *Config) []Check {
 		v := readSysctl("/proc/sys/net/ipv6/conf/all/forwarding")
 		out = append(out, Check{"IPv6 forwarding", v == "1", "net.ipv6.conf.all.forwarding=" + v})
 	}
+	// With IPv6 forwarding on, accept_ra 1 means router announcements are
+	// ignored: an IPv6 route learned from them expires (see sysctlConf).
+	if readSysctl("/proc/sys/net/ipv6/conf/all/forwarding") == "1" {
+		up := cmp.Or(k.Uplink(c, true), k.Uplink(c, false))
+		if ra := readSysctl("/proc/sys/net/ipv6/conf/" + up + "/accept_ra"); up != "" && ra != "" {
+			ok := ra != "1"
+			detail := "net.ipv6.conf." + up + ".accept_ra=" + ra
+			if !ok {
+				detail += ": IPv6 from router announcements stops working; run " + appName + " update"
+			}
+			out = append(out, Check{"IPv6 router announcements", ok, detail})
+		}
+	}
 	ok, detail := firewallPresent()
 	out = append(out, Check{"nftables rules", ok, detail})
 	up4 := k.Uplink(c, false)

main_test.go

@@ -12,7 +12,9 @@ import (
 	"net/netip"
 	"os"
 	"path/filepath"
+	"slices"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 )
@@ -311,8 +313,13 @@ func TestAPI(t *testing.T) {
 	secret := tok["token"].(string)
 
 	// Read-only token: GET works, changes are refused, admin endpoints too.
-	bearer := func(method, path string, want int) {
-		req, _ := http.NewRequest(method, srv.URL+"/api/v1"+path, nil)
+	bearer := func(method, path string, want int, body ...any) {
+		var rd io.Reader
+		if len(body) > 0 {
+			b, _ := json.Marshal(body[0])
+			rd = bytes.NewReader(b)
+		}
+		req, _ := http.NewRequest(method, srv.URL+"/api/v1"+path, rd)
 		req.Header.Set("Authorization", "Bearer "+secret)
 		resp, err := http.DefaultClient.Do(req)
 		if err != nil {
@@ -328,10 +335,20 @@ func TestAPI(t *testing.T) {
 	bearer("GET", "/tokens", 403)
 	bearer("GET", "/peers/"+id+"/setup", 403) // the link would set up a device
 
-	// A full-access token manages users and tokens, but not backups.
+	// A full-access token changes settings, but users, passwords, tokens,
+	// the sign-in rules and backups need a signed-in user.
 	secret = call("POST", "/tokens", map[string]string{"name": "full", "scope": "rw"}, 201)["token"].(string)
-	bearer("GET", "/users", 200)
-	bearer("GET", "/tokens", 200)
+	uid := call("GET", "/auth/me", nil, 200)["id"].(string)
+	bearer("PATCH", "/settings", 200, map[string]any{"log": store.Get().Log})
+	bearer("PATCH", "/settings", 403, map[string]any{"signin": map[string]bool{"requireMfa": false}})
+	bearer("GET", "/users", 403)
+	bearer("POST", "/users", 403, map[string]any{"username": "eve", "password": "correct horse battery"})
+	bearer("POST", "/users/"+uid+"/reset-password", 403, map[string]any{"password": "correct horse battery"})
+	bearer("POST", "/users/"+uid+"/reset-mfa", 403)
+	bearer("POST", "/auth/password", 403, map[string]string{"current": "x", "new": "y"})
+	bearer("GET", "/tokens", 403)
+	bearer("POST", "/tokens", 403, map[string]string{"name": "more", "scope": "rw"})
+	bearer("DELETE", "/tokens/"+tok["id"].(string), 403)
 	bearer("GET", "/backup", 403)
 
 	call("DELETE", "/peers/"+id, nil, 200)
@@ -376,6 +393,92 @@ func TestUnitFile(t *testing.T) {
 	}
 }
 
+func TestSysctlConf(t *testing.T) {
+	dir := t.TempDir()
+	conf, sys := filepath.Join(dir, "conf"), filepath.Join(dir, "net")
+	for name, ra := range map[string]string{"eth0": "1", "wlan0": "2", "eth1": "0", "br0": "1", "veth1": "1", "lo": "1"} {
+		_ = os.MkdirAll(filepath.Join(conf, name), 0o755)
+		_ = os.WriteFile(filepath.Join(conf, name, "accept_ra"), []byte(ra+"\n"), 0o644)
+	}
+	for _, name := range []string{"eth0", "wlan0", "eth1"} { // network cards
+		_ = os.MkdirAll(filepath.Join(sys, name, "device"), 0o755)
+	}
+	_ = os.MkdirAll(filepath.Join(sys, "veth1"), 0o755)
+	// br0 carries the default route; the lo line is the kernel's unreachable route.
+	routes := filepath.Join(dir, "ipv6_route")
+	_ = os.WriteFile(routes, []byte(
+		"00000000000000000000000000000000 00 00000000000000000000000000000000 00 fe800000000000000000000000000001 00000400 00000001 00000000 00000003     br0\n"+
+			"00000000000000000000000000000000 00 00000000000000000000000000000000 00 00000000000000000000000000000000 ffffffff 00000001 00000000 00200200       lo\n"), 0o644)
+
+	got := raInterfaces(conf, sys, routes)
+	if want := []string{"br0", "eth0", "wlan0"}; !slices.Equal(got, want) {
+		t.Fatalf("raInterfaces = %v, want %v", got, want)
+	}
+	c := sysctlConf(got)
+	for _, want := range []string{"net.ipv6.conf.all.forwarding=1\n", "net.ipv6.conf.default.accept_ra=2\n", "net.ipv6.conf.eth0.accept_ra=2\n", "net.ipv6.conf.br0.accept_ra=2\n"} {
+		if !strings.Contains(c, want) {
+			t.Errorf("sysctl conf lacks %q:\n%s", want, c)
+		}
+	}
+	if strings.Contains(c, "eth1") || strings.Contains(c, "veth1") {
+		t.Errorf("sysctl conf names eth1 (accept_ra 0) or veth1 (virtual):\n%s", c)
+	}
+}
+
+func TestLoginLockout(t *testing.T) {
+	store, err := openStore(filepath.Join(t.TempDir(), "config.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	hash, _ := hashPassword("a long test password")
+	_ = store.Update(func(c *Config) error { c.Users[0].PasswordHash = hash; return nil })
+	a := newAuth(store)
+	const right, wrong = "a long test password", "a wrong password"
+
+	// Ten wrong attempts at once from one /64: five are checked, the others
+	// are locked out before any password check.
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+	got := map[string]int{}
+	for i := range 10 {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			_, _, err := a.Login("admin", wrong, fmt.Sprintf("2001:db8::%x", i+1))
+			mu.Lock()
+			got[err.Error()]++
+			mu.Unlock()
+		}()
+	}
+	wg.Wait()
+	if got["wrong username or password"] != 5 || got[errLocked.Error()] != 5 {
+		t.Fatalf("parallel attempts: %v", got)
+	}
+	if _, _, err := a.Login("admin", right, "2001:db8::ffff"); !errors.Is(err, errLocked) {
+		t.Fatalf("same /64: %v, want locked", err)
+	}
+	if _, _, err := a.Login("admin", right, "2001:db8:0:1::1"); err != nil {
+		t.Fatalf("other /64: %v", err)
+	}
+
+	// A right password takes its own attempt back. With two-step sign-in
+	// the earlier failures stay, so wrong codes still lead to the lockout.
+	_ = store.Update(func(c *Config) error { c.Users[0].MFA = &UserMFA{TOTPSecret: newTOTPSecret()}; return nil })
+	ip := "192.0.2.7"
+	for range maxFailures - 1 {
+		_, _, _ = a.Login("admin", wrong, ip)
+	}
+	if _, tk, err := a.Login("admin", right, ip); err != nil || tk == "" {
+		t.Fatalf("5th attempt, right password: ticket %q, %v", tk, err)
+	}
+	if _, _, err := a.Login("admin", wrong, ip); err == nil || errors.Is(err, errLocked) {
+		t.Fatalf("6th attempt: %v, want wrong password", err)
+	}
+	if _, _, err := a.Login("admin", right, ip); !errors.Is(err, errLocked) {
+		t.Fatalf("7th attempt: %v, want locked", err)
+	}
+}
+
 func TestWriteIfChanged(t *testing.T) {
 	p := filepath.Join(t.TempDir(), "x.conf")
 	if ch, err := writeIfChanged(p, "a\n", 0o644); !ch || err != nil {
@@ -881,7 +984,6 @@ func TestUsers(t *testing.T) {
 	if n := len(admin("GET", "/users", nil, 200)["users"].([]any)); n != 2 {
 		t.Fatalf("users: %d, want 2", n)
 	}
-	admin("PATCH", "/settings", map[string]any{"adminUsername": "x"}, 400)
 }
 
 // TestDecoy checks that the decoy hides the web interface but leaves the API
@@ -921,8 +1023,15 @@ func TestDecoy(t *testing.T) {
 		}
 	}
 
-	if b, _ := get("/", 200); !strings.Contains(b, "/app.js") {
-		t.Fatal("web interface not served with the decoy off")
+	b, _ := get("/", 200)
+	if !strings.Contains(b, `"/app.js?v=`+assetHash["app.js"]+`"`) || !strings.Contains(b, `"/app.css?v=`+assetHash["app.css"]+`"`) {
+		t.Fatalf("web interface not served with fingerprinted files: %q", b)
+	}
+	if _, h := get("/app.js?v="+assetHash["app.js"], 200); !strings.Contains(h.Get("Cache-Control"), "immutable") {
+		t.Fatalf("fingerprinted app.js: %v", h)
+	}
+	if _, h := get("/app.js?v=old", 200); h.Get("Cache-Control") != "no-cache" {
+		t.Fatalf("stale app.js cached: %v", h)
 	}
 	set(func(c *Config) {
 		v4 := netip.MustParsePrefix(c.Server.IPv4)
@@ -939,7 +1048,7 @@ func TestDecoy(t *testing.T) {
 			t.Fatalf("%s leaks: %q", p, b)
 		}
 	}
-	if b, _ := get("/setup/live-token", 200); !strings.Contains(b, `src="/setup/live-token/setup.js"`) {
+	if b, _ := get("/setup/live-token", 200); !strings.Contains(b, `src="/setup/live-token/setup.js?v=`+assetHash["setup.js"]+`"`) {
 		t.Fatalf("setup page files not under the link: %q", b)
 	}
 	get("/setup/live-token/app.css", 200)
@@ -954,7 +1063,190 @@ func TestDecoy(t *testing.T) {
 	if b, h := get("/", 200); !strings.Contains(b, "<p class=\"host\">127.0.0.1</p>") || h.Get("Server") != "" {
 		t.Fatalf("soon decoy: %q", b)
 	}
+	set(func(c *Config) { c.Decoy.Page = "blank" })
+	if b, _ := get("/", 200); b != "" {
+		t.Fatalf("blank decoy: %q", b)
+	}
+	if b, _ := get("/app.js", 404); b != "" {
+		t.Fatalf("blank 404: %q", b)
+	}
+	set(func(c *Config) { c.Decoy.Page = "forbidden" })
+	if b, _ := get("/", 403); !strings.Contains(b, "Forbidden") {
+		t.Fatalf("forbidden decoy: %q", b)
+	}
+	set(func(c *Config) { c.Decoy.Page = "private" })
+	if b, _ := get("/", 200); !strings.Contains(b, "Private server") {
+		t.Fatalf("private decoy: %q", b)
+	}
 	if err := store.Update(func(c *Config) error { c.Decoy.Page = "iis"; return nil }); err == nil {
 		t.Fatal("unknown decoy page accepted")
 	}
 }
+
+func TestTOTPCode(t *testing.T) {
+	// RFC 6238, appendix B (SHA-1), cut to 6 digits.
+	key := []byte("12345678901234567890")
+	for _, c := range []struct {
+		unix int64
+		want string
+	}{{59, "287082"}, {1111111109, "081804"}, {1234567890, "005924"}, {2000000000, "279037"}} {
+		if got := totpCode(key, uint64(c.unix/30)); got != c.want {
+			t.Errorf("time %d: %s, want %s", c.unix, got, c.want)
+		}
+	}
+	secret := b32.EncodeToString(key)
+	now := time.Unix(1111111109, 0)
+	if _, ok := totpMatch(secret, "081 804", now); !ok {
+		t.Error("code with a space refused")
+	}
+	if _, ok := totpMatch(secret, "081804", now.Add(90*time.Second)); ok {
+		t.Error("code three steps late accepted")
+	}
+}
+
+// TestMFA signs in with an authenticator code and a recovery code, and
+// checks the "require" switch and the admin reset.
+func TestMFA(t *testing.T) {
+	dir := t.TempDir()
+	store, err := openStore(filepath.Join(dir, "config.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	hash, _ := hashPassword("a long test password")
+	_ = store.Update(func(c *Config) error { c.Users[0].PasswordHash = hash; return nil })
+	k := &fakeKernel{}
+	st, _ := openStats(filepath.Join(dir, "stats.json"), store, k)
+	app := &App{store: store, kernel: k, recon: newReconciler(k, store), stats: st, auth: newAuth(store),
+		tls: &webTLS{}, logPath: filepath.Join(dir, "log.jsonl"), started: time.Now(), shutdown: func() {}}
+	srv := httptest.NewServer(app.routes())
+	defer srv.Close()
+
+	client := func() func(method, path string, body any, want int) map[string]any {
+		jar, _ := cookiejar.New(nil)
+		cl := &http.Client{Jar: jar}
+		return func(method, path string, body any, want int) map[string]any {
+			t.Helper()
+			var rd io.Reader
+			if body != nil {
+				b, _ := json.Marshal(body)
+				rd = bytes.NewReader(b)
+			}
+			req, _ := http.NewRequest(method, srv.URL+"/api/v1"+path, rd)
+			req.Header.Set("Content-Type", "application/json")
+			resp, err := cl.Do(req)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer resp.Body.Close()
+			var out map[string]any
+			_ = json.NewDecoder(resp.Body).Decode(&out)
+			if resp.StatusCode != want {
+				t.Fatalf("%s %s: status %d, want %d: %v", method, path, resp.StatusCode, want, out)
+			}
+			return out
+		}
+	}
+	login := map[string]string{"username": "admin", "password": "a long test password"}
+	adm := client()
+	adm("POST", "/auth/login", login, 200)
+	if o := adm("GET", "/auth/options", nil, 200); o["passkeys"] != false {
+		t.Fatalf("passkeys offered on an IP address: %v", o)
+	}
+	adm("POST", "/auth/mfa/keys/begin", nil, 400)
+
+	// Turn on the authenticator app; the first method brings recovery codes.
+	setup := adm("POST", "/auth/mfa/totp/setup", nil, 200)
+	secret := setup["secret"].(string)
+	if !strings.HasPrefix(setup["uri"].(string), "otpauth://totp/") || setup["qr"] == "" {
+		t.Fatalf("setup: %v", setup)
+	}
+	adm("POST", "/auth/mfa/totp/confirm", map[string]string{"code": "000000"}, 400)
+	key, _ := b32.DecodeString(secret)
+	code := func(offset int) string { return totpCode(key, uint64(time.Now().Unix()/30)+uint64(offset)) }
+	conf := adm("POST", "/auth/mfa/totp/confirm", map[string]string{"code": code(0)}, 200)
+	codes := conf["recoveryCodes"].([]any)
+	if len(codes) != recoveryCount {
+		t.Fatalf("recovery codes: %v", conf)
+	}
+	if s := adm("GET", "/auth/mfa", nil, 200); s["totp"] != true || s["recoveryLeft"] != float64(recoveryCount) {
+		t.Fatalf("status: %v", s)
+	}
+
+	// A password alone now gives a ticket, not a session.
+	c := client()
+	r := c("POST", "/auth/login", login, 200)
+	ticket, _ := r["ticket"].(string)
+	if r["mfa"] != true || ticket == "" {
+		t.Fatalf("login without second step: %v", r)
+	}
+	c("GET", "/peers", nil, 401)
+	c("POST", "/auth/login/totp", map[string]string{"ticket": ticket, "code": "123456"}, 401)
+	c("POST", "/auth/login/totp", map[string]string{"ticket": ticket, "code": code(0)}, 401) // used during setup
+	c("POST", "/auth/login/totp", map[string]string{"ticket": ticket, "code": code(1)}, 200)
+	c("GET", "/peers", nil, 200)
+
+	// A recovery code works once.
+	c2 := client()
+	ticket = c2("POST", "/auth/login", login, 200)["ticket"].(string)
+	c2("POST", "/auth/login/recovery", map[string]string{"ticket": ticket, "code": strings.ToLower(codes[0].(string))}, 200)
+	c3 := client()
+	ticket = c3("POST", "/auth/login", login, 200)["ticket"].(string)
+	c3("POST", "/auth/login/recovery", map[string]string{"ticket": ticket, "code": codes[0].(string)}, 401)
+	c3("POST", "/auth/login/recovery", map[string]string{"ticket": ticket, "code": codes[1].(string)}, 200)
+
+	// Required for everyone: a user without it can only set it up.
+	adm("PATCH", "/settings", map[string]any{"signin": map[string]bool{"requireMfa": true}}, 200)
+	u := adm("POST", "/users", map[string]any{"username": "eve", "password": "eve's password 1", "mustChangePassword": false}, 201)["user"].(map[string]any)
+	e := client()
+	e("POST", "/auth/login", map[string]string{"username": "eve", "password": "eve's password 1"}, 200)
+	if me := e("GET", "/auth/me", nil, 200); me["mfaSetupRequired"] != true {
+		t.Fatalf("me: %v", me)
+	}
+	e("GET", "/peers", nil, 403)
+	e("GET", "/auth/mfa", nil, 200)
+	// The last method cannot be removed while it is required.
+	adm("DELETE", "/auth/mfa/totp", nil, 400)
+
+	// An admin resets another user's two-step sign-in, not their own.
+	_ = store.Update(func(c *Config) error {
+		_, eu := c.userByID(u["id"].(string))
+		eu.MFA = &UserMFA{TOTPSecret: newTOTPSecret(), RecoveryCodes: []string{"x"}}
+		return nil
+	})
+	if l := adm("GET", "/users", nil, 200)["users"].([]any); l[1].(map[string]any)["mfa"].(map[string]any)["totp"] != true {
+		t.Fatalf("users list: %v", l)
+	}
+	me := adm("GET", "/auth/me", nil, 200)
+	adm("POST", "/users/"+me["id"].(string)+"/reset-mfa", nil, 400)
+	adm("POST", "/users/"+u["id"].(string)+"/reset-mfa", nil, 200)
+	if _, eu := store.Get().userByID(u["id"].(string)); eu.hasMFA() || len(eu.MFA.RecoveryCodes) != 0 {
+		t.Fatal("reset left methods behind")
+	}
+}
+
+// TestDropSecurityKeys checks that security keys from v0.3.0 are deleted on
+// load, and recovery codes with them when nothing else is left.
+func TestDropSecurityKeys(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "config.json")
+	cfg := `{"users": [
+		{"id": "a", "username": "a", "passwordHash": "x", "mfa": {"keys": [{"id": "k", "name": "YubiKey", "passkey": false}], "recoveryCodes": ["h"]}},
+		{"id": "b", "username": "b", "passwordHash": "x", "mfa": {"keys": [{"id": "k1", "name": "YubiKey", "passkey": false}, {"id": "k2", "name": "Mac", "passkey": true}], "recoveryCodes": ["h"]}}
+	]}`
+	if err := os.WriteFile(path, []byte(cfg), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	store, err := openStore(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	c := store.Get()
+	if a := c.Users[0].MFA; len(a.Keys) != 0 || len(a.RecoveryCodes) != 0 {
+		t.Fatalf("user a kept %v", a)
+	}
+	if b := c.Users[1].MFA; len(b.Keys) != 1 || b.Keys[0].Name != "Mac" || len(b.RecoveryCodes) != 1 {
+		t.Fatalf("user b: %v", b)
+	}
+	if b, _ := os.ReadFile(path); strings.Contains(string(b), "YubiKey") {
+		t.Fatal("security key still in config.json")
+	}
+}

mfa.go

@@ -0,0 +1,940 @@
+package main
+
+import (
+	"bytes"
+	"crypto/hmac"
+	"crypto/rand"
+	"crypto/sha1"
+	"crypto/sha256"
+	"crypto/subtle"
+	"encoding/base32"
+	"encoding/binary"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"log/slog"
+	"net"
+	"net/http"
+	"net/url"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/go-webauthn/webauthn/protocol"
+	"github.com/go-webauthn/webauthn/webauthn"
+)
+
+// Two-step sign-in for the web interface: an authenticator app (TOTP) and
+// passkeys (WebAuthn, also on a YubiKey), plus one-time recovery codes. A
+// passkey signs in on its own and also serves as the second step after a
+// password. API tokens never need a second step.
+//
+// After a correct password, a user with two-step sign-in gets a short-lived
+// ticket instead of a session; the ticket and a code or key turn into the
+// session. A passkey signs in on its own, without username and password.
+
+// UserMFA is a user's two-step sign-in setup, stored in config.json.
+type UserMFA struct {
+	TOTPSecret    string     `json:"totpSecret,omitempty"` // base32
+	TOTPAdded     *time.Time `json:"totpAdded,omitempty"`
+	Keys          []MFAKey   `json:"keys,omitempty"`
+	RecoveryCodes []string   `json:"recoveryCodes,omitempty"` // SHA-256 of the unused codes
+	Handle        []byte     `json:"handle,omitempty"`        // WebAuthn user handle
+}
+
+// MFAKey is a passkey.
+type MFAKey struct {
+	ID         string              `json:"id"`
+	Name       string              `json:"name"`
+	Passkey    bool                `json:"passkey"` // false only for security keys added by v0.3.0, which are deleted
+	Created    time.Time           `json:"created"`
+	LastUsed   *time.Time          `json:"lastUsed,omitempty"`
+	Credential webauthn.Credential `json:"credential"`
+}
+
+// dropSecurityKeys deletes the security keys v0.3.0 could add; only
+// passkeys are supported. A user left without a method loses their
+// recovery codes too.
+func dropSecurityKeys(u *User) {
+	if u.MFA == nil {
+		return
+	}
+	u.MFA.Keys = slices.DeleteFunc(u.MFA.Keys, func(k MFAKey) bool { return !k.Passkey })
+	if !u.hasMFA() {
+		u.MFA.RecoveryCodes = nil
+	}
+}
+
+func (u *User) hasMFA() bool {
+	return u.MFA != nil && (u.MFA.TOTPSecret != "" || len(u.MFA.Keys) > 0)
+}
+
+const (
+	ticketTTL     = 5 * time.Minute
+	recoveryCount = 10
+	totpPeriod    = 30
+	totpDigits    = 6
+	maxKeyName    = 64
+)
+
+// --- TOTP (RFC 6238, SHA-1, 6 digits, 30 s) ---
+
+var b32 = base32.StdEncoding.WithPadding(base32.NoPadding)
+
+func newTOTPSecret() string {
+	b := make([]byte, 20)
+	if _, err := rand.Read(b); err != nil {
+		panic(err)
+	}
+	return b32.EncodeToString(b)
+}
+
+func totpCode(key []byte, counter uint64) string {
+	var msg [8]byte
+	binary.BigEndian.PutUint64(msg[:], counter)
+	m := hmac.New(sha1.New, key)
+	m.Write(msg[:])
+	sum := m.Sum(nil)
+	off := sum[len(sum)-1] & 0x0f
+	v := binary.BigEndian.Uint32(sum[off:off+4]) & 0x7fffffff
+	return fmt.Sprintf("%0*d", totpDigits, v%1_000_000)
+}
+
+// totpMatch returns the time step the code belongs to, allowing one step of
+// clock drift either way.
+func totpMatch(secret, code string, now time.Time) (uint64, bool) {
+	key, err := b32.DecodeString(strings.ToUpper(secret))
+	code = strings.Map(func(r rune) rune {
+		if r >= '0' && r <= '9' {
+			return r
+		}
+		return -1
+	}, code)
+	if err != nil || len(code) != totpDigits {
+		return 0, false
+	}
+	step := uint64(now.Unix() / totpPeriod)
+	for _, c := range []uint64{step, step - 1, step + 1} {
+		if subtle.ConstantTimeCompare([]byte(totpCode(key, c)), []byte(code)) == 1 {
+			return c, true
+		}
+	}
+	return 0, false
+}
+
+func totpURI(secret, username string) string {
+	label := url.PathEscape(appName + ":" + username)
+	return "otpauth://totp/" + label + "?secret=" + secret + "&issuer=" + url.QueryEscape(appName) + "&algorithm=SHA1&digits=6&period=30"
+}
+
+// --- recovery codes ---
+
+const recoveryAlphabet = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ"
+
+// newRecoveryCodes returns codes to show once and their hashes to store.
+func newRecoveryCodes() (codes, hashes []string) {
+	for range recoveryCount {
+		b := make([]byte, 8)
+		if _, err := rand.Read(b); err != nil {
+			panic(err)
+		}
+		var s strings.Builder
+		for i, x := range b {
+			if i == 4 {
+				s.WriteByte('-')
+			}
+			s.WriteByte(recoveryAlphabet[int(x)%len(recoveryAlphabet)])
+		}
+		codes = append(codes, s.String())
+		hashes = append(hashes, hashRecovery(s.String()))
+	}
+	return codes, hashes
+}
+
+func hashRecovery(code string) string {
+	norm := strings.Map(func(r rune) rune {
+		if r == '-' || r == ' ' {
+			return -1
+		}
+		return r
+	}, strings.ToUpper(code))
+	sum := sha256.Sum256([]byte(norm))
+	return hex.EncodeToString(sum[:])
+}
+
+// --- WebAuthn ---
+
+// waUser adapts a User to the webauthn library.
+type waUser struct{ u *User }
+
+func (w waUser) WebAuthnID() []byte          { return w.u.MFA.Handle }
+func (w waUser) WebAuthnName() string        { return w.u.Username }
+func (w waUser) WebAuthnDisplayName() string { return w.u.Username }
+func (w waUser) WebAuthnCredentials() []webauthn.Credential {
+	var out []webauthn.Credential
+	if w.u.MFA != nil {
+		for _, k := range w.u.MFA.Keys {
+			out = append(out, k.Credential)
+		}
+	}
+	return out
+}
+
+// keysAvailable reports whether passkeys can work on this
+// address: WebAuthn needs a domain name (not an IP address) and a
+// certificate the browser trusts, or localhost.
+func (a *App) keysAvailable(r *http.Request) bool {
+	host := hostOnly(r.Host)
+	if host == "localhost" {
+		return true
+	}
+	return host != "" && net.ParseIP(host) == nil && a.store.Get().Web.TLS.Mode != "selfsigned"
+}
+
+func (a *App) webAuthn(r *http.Request) (*webauthn.WebAuthn, error) {
+	if !a.keysAvailable(r) {
+		return nil, badRequest("passkeys need a domain name with a trusted certificate")
+	}
+	scheme := "https"
+	if r.TLS == nil && hostOnly(r.Host) == "localhost" {
+		scheme = "http"
+	}
+	return webauthn.New(&webauthn.Config{
+		RPID: hostOnly(r.Host), RPDisplayName: appName, RPOrigins: []string{scheme + "://" + r.Host},
+	})
+}
+
+// --- pending ceremonies, kept in memory ---
+
+// ticket is a sign-in waiting for its second step.
+type ticket struct {
+	userID  string
+	ip      string
+	expires time.Time
+	fails   int
+	key     *webauthn.SessionData // a passkey challenge, once asked for
+}
+
+type ceremony struct {
+	userID  string // "" for a passkey sign-in
+	data    *webauthn.SessionData
+	expires time.Time
+}
+
+type mfaState struct {
+	tickets   map[string]*ticket
+	logins    map[string]*ceremony // passkey sign-ins by id
+	enrolls   map[string]*ceremony // key registrations by user ID
+	totpSetup map[string]string    // TOTP secrets waiting for their first code, by user ID
+	totpLast  map[string]uint64    // last time step used per user, so a code works once
+}
+
+func newMFAState() mfaState {
+	return mfaState{tickets: map[string]*ticket{}, logins: map[string]*ceremony{}, enrolls: map[string]*ceremony{},
+		totpSetup: map[string]string{}, totpLast: map[string]uint64{}}
+}
+
+var errBadTicket = errors.New("the sign-in expired; enter your password again")
+
+// failLocked counts a failed attempt from ip toward the lockout and returns
+// a function that takes it back, for an attempt counted before it was
+// checked. a.mu must be held, also when calling undo.
+func (a *Auth) failLocked(ip string) (undo func()) {
+	key := lockKey(ip)
+	f := a.fails[key]
+	if f == nil {
+		f = &failState{}
+		a.fails[key] = f
+	}
+	f.count++
+	locked := f.count >= maxFailures
+	if locked {
+		f.count = 0
+		f.until = time.Now().Add(lockoutTime)
+	}
+	return func() {
+		switch {
+		case locked:
+			f.count, f.until = maxFailures-1, time.Time{}
+		case f.count > 0:
+			f.count--
+		}
+	}
+}
+
+func (a *Auth) lockedLocked(ip string) bool {
+	f := a.fails[lockKey(ip)]
+	return f != nil && time.Now().Before(f.until)
+}
+
+// newTicket starts the second step for a user whose password was right.
+// a.mu must be held.
+func (a *Auth) newTicketLocked(u *User, ip string) string {
+	id := randomString(32)
+	a.mfa.tickets[id] = &ticket{userID: u.ID, ip: ip, expires: time.Now().Add(ticketTTL)}
+	return id
+}
+
+// ticketUser returns the live ticket and its user.
+func (a *Auth) ticketUser(id, ip string) (*ticket, *User, error) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if a.lockedLocked(ip) {
+		return nil, nil, errLocked
+	}
+	t := a.mfa.tickets[id]
+	if t == nil || time.Now().After(t.expires) {
+		delete(a.mfa.tickets, id)
+		return nil, nil, errBadTicket
+	}
+	_, u := a.store.Get().userByID(t.userID)
+	if u == nil {
+		delete(a.mfa.tickets, id)
+		return nil, nil, errBadTicket
+	}
+	return t, u, nil
+}
+
+// ticketFailed counts a wrong code; five end the ticket.
+func (a *Auth) ticketFailed(id, ip string) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	a.failLocked(ip)
+	if t := a.mfa.tickets[id]; t != nil {
+		t.fails++
+		if t.fails >= maxFailures {
+			delete(a.mfa.tickets, id)
+		}
+	}
+}
+
+// finishSignIn turns a passed second step into a session.
+func (a *Auth) finishSignIn(u *User, ip string) string {
+	cfg := a.store.Get()
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	delete(a.fails, lockKey(ip))
+	a.logins[u.ID] = tokenUse{At: time.Now(), IP: ip}
+	return a.newSessionLocked(cfg, u, sessionInfo{Started: time.Now(), IP: ip})
+}
+
+// --- sign-in endpoints (public) ---
+
+func (a *App) signedIn(w http.ResponseWriter, r *http.Request, u *User, how string) {
+	ip := remoteIP(r)
+	a.setSessionCookie(w, r, a.auth.finishSignIn(u, ip))
+	slog.Info("login", "audit", true, "actor", u.Username, "remote", ip, "method", how)
+	writeJSON(w, http.StatusOK, map[string]any{"ok": true})
+}
+
+func (a *App) signInFailed(w http.ResponseWriter, err error) {
+	code := http.StatusUnauthorized
+	if errors.Is(err, errLocked) {
+		code = http.StatusTooManyRequests
+	}
+	writeJSON(w, code, map[string]string{"error": err.Error()})
+}
+
+// signInOptions tells the sign-in page whether to offer a passkey.
+func (a *App) signInOptions(w http.ResponseWriter, r *http.Request) {
+	writeJSON(w, http.StatusOK, map[string]any{"passkeys": a.keysAvailable(r)})
+}
+
+func (a *App) loginTOTP(w http.ResponseWriter, r *http.Request) {
+	var in struct{ Ticket, Code string }
+	if err := readJSON(r, &in); err != nil {
+		writeErr(w, err)
+		return
+	}
+	ip := remoteIP(r)
+	_, u, err := a.auth.ticketUser(in.Ticket, ip)
+	if err != nil {
+		a.signInFailed(w, err)
+		return
+	}
+	if u.MFA == nil || u.MFA.TOTPSecret == "" || !a.auth.useTOTP(u.ID, u.MFA.TOTPSecret, in.Code) {
+		a.auth.ticketFailed(in.Ticket, ip)
+		slog.Warn("login failed", "user", u.Username, "remote", ip, "reason", "wrong authenticator code")
+		a.signInFailed(w, errors.New("wrong code"))
+		return
+	}
+	a.auth.dropTicket(in.Ticket)
+	a.signedIn(w, r, u, "totp")
+}
+
+// useTOTP checks a code and makes sure it is not used twice.
+func (a *Auth) useTOTP(userID, secret, code string) bool {
+	step, ok := totpMatch(secret, code, time.Now())
+	if !ok {
+		return false
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if last, seen := a.mfa.totpLast[userID]; seen && step <= last {
+		return false
+	}
+	a.mfa.totpLast[userID] = step
+	return true
+}
+
+// ticketUserID returns the ticket's user without checking the lockout.
+func (a *Auth) ticketUserID(id string) (string, *User) {
+	a.mu.Lock()
+	t := a.mfa.tickets[id]
+	a.mu.Unlock()
+	if t == nil {
+		return "", nil
+	}
+	_, u := a.store.Get().userByID(t.userID)
+	return t.userID, u
+}
+
+// mfaMethods lists what the second step can use: "key", "totp", "recovery".
+func mfaMethods(u *User) []string {
+	out := []string{}
+	if u == nil || u.MFA == nil {
+		return out
+	}
+	if len(u.MFA.Keys) > 0 {
+		out = append(out, "key")
+	}
+	if u.MFA.TOTPSecret != "" {
+		out = append(out, "totp")
+	}
+	if len(u.MFA.RecoveryCodes) > 0 {
+		out = append(out, "recovery")
+	}
+	return out
+}
+
+func (a *Auth) dropTicket(id string) {
+	a.mu.Lock()
+	delete(a.mfa.tickets, id)
+	a.mu.Unlock()
+}
+
+func (a *App) loginRecovery(w http.ResponseWriter, r *http.Request) {
+	var in struct{ Ticket, Code string }
+	if err := readJSON(r, &in); err != nil {
+		writeErr(w, err)
+		return
+	}
+	ip := remoteIP(r)
+	_, u, err := a.auth.ticketUser(in.Ticket, ip)
+	if err != nil {
+		a.signInFailed(w, err)
+		return
+	}
+	h := hashRecovery(in.Code)
+	var left int
+	used := false
+	_ = a.store.Update(func(c *Config) error {
+		_, cu := c.userByID(u.ID)
+		if cu == nil || cu.MFA == nil {
+			return nil
+		}
+		for i, x := range cu.MFA.RecoveryCodes {
+			if subtle.ConstantTimeCompare([]byte(x), []byte(h)) == 1 {
+				cu.MFA.RecoveryCodes = slices.Delete(cu.MFA.RecoveryCodes, i, i+1)
+				used = true
+				break
+			}
+		}
+		left = len(cu.MFA.RecoveryCodes)
+		return nil
+	})
+	if !used {
+		a.auth.ticketFailed(in.Ticket, ip)
+		slog.Warn("login failed", "user", u.Username, "remote", ip, "reason", "wrong recovery code")
+		a.signInFailed(w, errors.New("wrong or used recovery code"))
+		return
+	}
+	a.auth.dropTicket(in.Ticket)
+	slog.Info("recovery code used", "audit", true, "actor", u.Username, "remote", ip, "left", left)
+	a.signedIn(w, r, u, "recovery code")
+}
+
+// loginKeyBegin asks for one of the user's passkeys, as the second step.
+func (a *App) loginKeyBegin(w http.ResponseWriter, r *http.Request) {
+	var in struct{ Ticket string }
+	if err := readJSON(r, &in); err != nil {
+		writeErr(w, err)
+		return
+	}
+	t, u, err := a.auth.ticketUser(in.Ticket, remoteIP(r))
+	if err != nil {
+		a.signInFailed(w, err)
+		return
+	}
+	wa, err := a.webAuthn(r)
+	if err != nil {
+		writeErr(w, err)
+		return
+	}
+	if u.MFA == nil || len(u.MFA.Keys) == 0 {
+		writeErr(w, badRequest("no passkey is set up"))
+		return
+	}
+	opts, data, err := wa.BeginLogin(waUser{u}, webauthn.WithUserVerification(protocol.VerificationDiscouraged))
+	if err != nil {
+		writeErr(w, err)
+		return
+	}
+	a.auth.mu.Lock()
+	t.key = data
+	a.auth.mu.Unlock()
+	writeJSON(w, http.StatusOK, opts)
+}
+
+// loginKeyFinish checks the key's answer. The ticket is in the query, the
+// body is the browser's credential.
+func (a *App) loginKeyFinish(w http.ResponseWriter, r *http.Request) {
+	id := r.URL.Query().Get("ticket")
+	ip := remoteIP(r)
+	t, u, err := a.auth.ticketUser(id, ip)
+	if err != nil {
+		a.signInFailed(w, err)
+		return
+	}
+	wa, err := a.webAuthn(r)
+	if err != nil {
+		writeErr(w, err)
+		return
+	}
+	a.auth.mu.Lock()
+	data := t.key
+	t.key = nil
+	a.auth.mu.Unlock()
+	if data == nil {
+		writeErr(w, badRequest("ask for the key first"))
+		return
+	}
+	cred, err := wa.FinishLogin(waUser{u}, *data, r)
+	if err != nil {
+		a.auth.ticketFailed(id, ip)
+		slog.Warn("login failed", "user", u.Username, "remote", ip, "reason", "passkey: "+err.Error())
+		a.signInFailed(w, errors.New("the passkey was not accepted"))
+		return
+	}
+	a.keyUsed(u.ID, cred)
+	a.auth.dropTicket(id)
+	a.signedIn(w, r, u, "passkey")
+}
+
+// keyUsed stores the key's new signature counter and when it was used.
+func (a *App) keyUsed(userID string, cred *webauthn.Credential) {
+	now := time.Now().UTC()
+	_ = a.store.Update(func(c *Config) error {
+		if _, u := c.userByID(userID); u != nil && u.MFA != nil {
+			for i := range u.MFA.Keys {
+				if k := &u.MFA.Keys[i]; bytes.Equal(k.Credential.ID, cred.ID) {
+					k.Credential.Authenticator = cred.Authenticator
+					k.Credential.Flags = cred.Flags
+					k.LastUsed = &now
+				}
+			}
+		}
+		return nil
+	})
+}
+
+// loginPasskeyBegin starts a sign-in with a passkey alone.
+func (a *App) loginPasskeyBegin(w http.ResponseWriter, r *http.Request) {
+	wa, err := a.webAuthn(r)
+	if err != nil {
+		writeErr(w, err)
+		return
+	}
+	opts, data, err := wa.BeginDiscoverableLogin(webauthn.WithUserVerification(protocol.VerificationRequired))
+	if err != nil {
+		writeErr(w, err)
+		return
+	}
+	id := randomString(24)
+	a.auth.mu.Lock()
+	a.auth.mfa.logins[id] = &ceremony{data: data, expires: time.Now().Add(ticketTTL)}
+	a.auth.mu.Unlock()
+	writeJSON(w, http.StatusOK, map[string]any{"id": id, "options": opts})
+}
+
+func (a *App) loginPasskeyFinish(w http.ResponseWriter, r *http.Request) {
+	id := r.URL.Query().Get("id")
+	ip := remoteIP(r)
+	a.auth.mu.Lock()
+	cer := a.auth.mfa.logins[id]
+	delete(a.auth.mfa.logins, id)
+	locked := a.auth.lockedLocked(ip)
+	a.auth.mu.Unlock()
+	if locked {
+		a.signInFailed(w, errLocked)
+		return
+	}
+	if cer == nil || time.Now().After(cer.expires) {
+		a.signInFailed(w, errors.New("the sign-in expired; try again"))
+		return
+	}
+	wa, err := a.webAuthn(r)
+	if err != nil {
+		writeErr(w, err)
+		return
+	}
+	cfg := a.store.Get()
+	var found *User
+	cred, err := wa.FinishDiscoverableLogin(func(rawID, handle []byte) (webauthn.User, error) {
+		for i := range cfg.Users {
+			u := &cfg.Users[i]
+			if u.MFA != nil && len(u.MFA.Handle) > 0 && bytes.Equal(u.MFA.Handle, handle) {
+				for _, k := range u.MFA.Keys {
+					if bytes.Equal(k.Credential.ID, rawID) {
+						found = u
+						return waUser{u}, nil
+					}
+				}
+			}
+		}
+		return nil, errors.New("unknown passkey")
+	}, *cer.data, r)
+	if err != nil || found == nil {
+		a.auth.mu.Lock()
+		a.auth.failLocked(ip)
+		a.auth.mu.Unlock()
+		slog.Warn("login failed", "remote", ip, "reason", "passkey not accepted")
+		a.signInFailed(w, errors.New("this passkey is not known here"))
+		return
+	}
+	a.keyUsed(found.ID, cred)
+	a.signedIn(w, r, found, "passkey")
+}
+
+// --- managing your own two-step sign-in (signed-in users) ---
+
+type keyView struct {
+	ID       string     `json:"id"`
+	Name     string     `json:"name"`
+	Created  time.Time  `json:"created"`
+	LastUsed *time.Time `json:"lastUsed"`
+}
+
+func (a *App) mfaStatus(w http.ResponseWriter, r *http.Request) {
+	cfg := a.store.Get()
+	_, u := cfg.userByID(who(r).UserID)
+	if u == nil {
+		writeErr(w, badRequest("no such user"))
+		return
+	}
+	out := map[string]any{"totp": false, "totpAdded": nil, "keys": []keyView{}, "recoveryLeft": 0,
+		"keysAvailable": a.keysAvailable(r), "required": cfg.SignIn.RequireMFA}
+	if m := u.MFA; m != nil {
+		keys := []keyView{}
+		for _, k := range m.Keys {
+			keys = append(keys, keyView{k.ID, k.Name, k.Created, k.LastUsed})
+		}
+		out["totp"], out["totpAdded"], out["keys"], out["recoveryLeft"] = m.TOTPSecret != "", m.TOTPAdded, keys, len(m.RecoveryCodes)
+	}
+	writeJSON(w, http.StatusOK, out)
+}
+
+// addFirstCodes gives a user recovery codes with their first method. It
+// returns the codes to show, or nil when the user already has codes. It runs
+// inside a store update.
+func addFirstCodes(u *User) []string {
+	if len(u.MFA.RecoveryCodes) > 0 {
+		return nil
+	}
+	codes, hashes := newRecoveryCodes()
+	u.MFA.RecoveryCodes = hashes
+	return codes
+}
+
+func (a *App) totpSetup(w http.ResponseWriter, r *http.Request) {
+	p := who(r)
+	secret := newTOTPSecret()
+	a.auth.mu.Lock()
+	a.auth.mfa.totpSetup[p.UserID] = secret
+	a.auth.mu.Unlock()
+	_, u := a.store.Get().userByID(p.UserID)
+	if u == nil {
+		writeErr(w, badRequest("no such user"))
+		return
+	}
+	uri := totpURI(secret, u.Username)
+	qr, _ := qrDataURL(uri)
+	writeJSON(w, http.StatusOK, map[string]any{"secret": secret, "uri": uri, "qr": qr})
+}
+
+func (a *App) totpConfirm(w http.ResponseWriter, r *http.Request) {
+	var in struct{ Code string }
+	if err := readJSON(r, &in); err != nil {
+		writeErr(w, err)
+		return
+	}
+	p := who(r)
+	a.auth.mu.Lock()
+	secret := a.auth.mfa.totpSetup[p.UserID]
+	a.auth.mu.Unlock()
+	if secret == "" {
+		writeErr(w, badRequest("start the setup again"))
+		return
+	}
+	if !a.auth.useTOTP(p.UserID, secret, in.Code) {
+		writeErr(w, badRequest("wrong code; check the time on your phone and try the next one"))
+		return
+	}
+	var codes []string
+	now := time.Now().UTC()
+	if err := a.store.Update(func(c *Config) error {
+		_, u := c.userByID(p.UserID)
+		if u == nil {
+			return badRequest("no such user")
+		}
+		if u.MFA == nil {
+			u.MFA = &UserMFA{}
+		}
+		u.MFA.TOTPSecret, u.MFA.TOTPAdded = secret, &now
+		codes = addFirstCodes(u)
+		return nil
+	}); err != nil {
+		writeErr(w, err)
+		return
+	}
+	a.auth.mu.Lock()
+	delete(a.auth.mfa.totpSetup, p.UserID)
+	a.auth.mu.Unlock()
+	a.audit(r, "authenticator app added")
+	writeJSON(w, http.StatusOK, map[string]any{"ok": true, "recoveryCodes": codes})
+}
+
+// lastMethodCheck refuses to remove the last method while two-step sign-in
+// is required.
+func lastMethodCheck(c *Config, u *User) error {
+	if c.SignIn.RequireMFA && !u.hasMFA() {
+		return badRequest("two-step sign-in is required here; add another method first")
+	}
+	if !u.hasMFA() && u.MFA != nil {
+		u.MFA.RecoveryCodes = nil
+	}
+	return nil
+}
+
+func (a *App) totpRemove(w http.ResponseWriter, r *http.Request) {
+	p := who(r)
+	if err := a.store.Update(func(c *Config) error {
+		_, u := c.userByID(p.UserID)
+		if u == nil || u.MFA == nil || u.MFA.TOTPSecret == "" {
+			return badRequest("no authenticator app is set up")
+		}
+		u.MFA.TOTPSecret, u.MFA.TOTPAdded = "", nil
+		return lastMethodCheck(c, u)
+	}); err != nil {
+		writeErr(w, err)
+		return
+	}
+	a.audit(r, "authenticator app removed")
+	writeJSON(w, http.StatusOK, map[string]any{"ok": true})
+}
+
+// keyBegin starts adding a passkey.
+func (a *App) keyBegin(w http.ResponseWriter, r *http.Request) {
+	wa, err := a.webAuthn(r)
+	if err != nil {
+		writeErr(w, err)
+		return
+	}
+	p := who(r)
+	// The user handle is made once and never changes.
+	if err := a.store.Update(func(c *Config) error {
+		_, u := c.userByID(p.UserID)
+		if u == nil {
+			return badRequest("no such user")
+		}
+		if u.MFA == nil {
+			u.MFA = &UserMFA{}
+		}
+		if len(u.MFA.Handle) == 0 {
+			u.MFA.Handle = make([]byte, 32)
+			if _, err := rand.Read(u.MFA.Handle); err != nil {
+				return err
+			}
+		}
+		return nil
+	}); err != nil {
+		writeErr(w, err)
+		return
+	}
+	_, u := a.store.Get().userByID(p.UserID)
+	var exclude []protocol.CredentialDescriptor
+	for _, k := range u.MFA.Keys {
+		exclude = append(exclude, k.Credential.Descriptor())
+	}
+	sel := protocol.AuthenticatorSelection{ResidentKey: protocol.ResidentKeyRequirementRequired, UserVerification: protocol.VerificationRequired}
+	opts, data, err := wa.BeginRegistration(waUser{u}, webauthn.WithAuthenticatorSelection(sel), webauthn.WithExclusions(exclude))
+	if err != nil {
+		writeErr(w, err)
+		return
+	}
+	a.auth.mu.Lock()
+	a.auth.mfa.enrolls[p.UserID] = &ceremony{userID: p.UserID, data: data, expires: time.Now().Add(ticketTTL)}
+	a.auth.mu.Unlock()
+	writeJSON(w, http.StatusOK, opts)
+}
+
+// keyFinish stores the new key. The name is in the query, the body is the
+// browser's credential.
+func (a *App) keyFinish(w http.ResponseWriter, r *http.Request) {
+	p := who(r)
+	name := strings.TrimSpace(r.URL.Query().Get("name"))
+	a.auth.mu.Lock()
+	cer := a.auth.mfa.enrolls[p.UserID]
+	delete(a.auth.mfa.enrolls, p.UserID)
+	a.auth.mu.Unlock()
+	if cer == nil || time.Now().After(cer.expires) {
+		writeErr(w, badRequest("adding the key took too long; try again"))
+		return
+	}
+	wa, err := a.webAuthn(r)
+	if err != nil {
+		writeErr(w, err)
+		return
+	}
+	_, u := a.store.Get().userByID(p.UserID)
+	if u == nil {
+		writeErr(w, badRequest("no such user"))
+		return
+	}
+	cred, err := wa.FinishRegistration(waUser{u}, *cer.data, r)
+	if err != nil {
+		writeErr(w, badRequest("the key was not accepted: %v", err))
+		return
+	}
+	if name == "" {
+		name = "Passkey"
+	}
+	if len(name) > maxKeyName {
+		name = name[:maxKeyName]
+	}
+	var codes []string
+	key := MFAKey{ID: newID(), Name: name, Passkey: true, Created: time.Now().UTC(), Credential: *cred}
+	if err := a.store.Update(func(c *Config) error {
+		_, u := c.userByID(p.UserID)
+		if u == nil || u.MFA == nil {
+			return badRequest("no such user")
+		}
+		u.MFA.Keys = append(u.MFA.Keys, key)
+		codes = addFirstCodes(u)
+		return nil
+	}); err != nil {
+		writeErr(w, err)
+		return
+	}
+	a.audit(r, "passkey added", "key", name)
+	writeJSON(w, http.StatusOK, map[string]any{"ok": true, "recoveryCodes": codes})
+}
+
+func (a *App) keyRename(w http.ResponseWriter, r *http.Request) {
+	var in struct{ Name string }
+	if err := readJSON(r, &in); err != nil {
+		writeErr(w, err)
+		return
+	}
+	in.Name = strings.TrimSpace(in.Name)
+	if in.Name == "" || len(in.Name) > maxKeyName {
+		writeErr(w, badRequest("name must be 1–%d characters", maxKeyName))
+		return
+	}
+	id := r.PathValue("id")
+	if err := a.store.Update(func(c *Config) error {
+		_, u := c.userByID(who(r).UserID)
+		if u == nil || u.MFA == nil {
+			return badRequest("no such key")
+		}
+		for i := range u.MFA.Keys {
+			if u.MFA.Keys[i].ID == id {
+				u.MFA.Keys[i].Name = in.Name
+				return nil
+			}
+		}
+		return badRequest("no such key")
+	}); err != nil {
+		writeErr(w, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]any{"ok": true})
+}
+
+func (a *App) keyRemove(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	var name string
+	if err := a.store.Update(func(c *Config) error {
+		_, u := c.userByID(who(r).UserID)
+		if u == nil || u.MFA == nil {
+			return badRequest("no such key")
+		}
+		i := slices.IndexFunc(u.MFA.Keys, func(k MFAKey) bool { return k.ID == id })
+		if i < 0 {
+			return badRequest("no such key")
+		}
+		name = u.MFA.Keys[i].Name
+		u.MFA.Keys = slices.Delete(u.MFA.Keys, i, i+1)
+		return lastMethodCheck(c, u)
+	}); err != nil {
+		writeErr(w, err)
+		return
+	}
+	a.audit(r, "passkey removed", "key", name)
+	writeJSON(w, http.StatusOK, map[string]any{"ok": true})
+}
+
+func (a *App) newRecoveryCodesHandler(w http.ResponseWriter, r *http.Request) {
+	var codes []string
+	if err := a.store.Update(func(c *Config) error {
+		_, u := c.userByID(who(r).UserID)
+		if u == nil || !u.hasMFA() {
+			return badRequest("turn on two-step sign-in first")
+		}
+		var hashes []string
+		codes, hashes = newRecoveryCodes()
+		u.MFA.RecoveryCodes = hashes
+		return nil
+	}); err != nil {
+		writeErr(w, err)
+		return
+	}
+	a.audit(r, "recovery codes replaced")
+	writeJSON(w, http.StatusOK, map[string]any{"recoveryCodes": codes})
+}
+
+// resetMFA removes another user's two-step sign-in, for a lost phone or key.
+// Their user handle stays, so passkeys they still hold are just unknown.
+func (a *App) resetMFA(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	if id == who(r).UserID {
+		writeErr(w, badRequest("manage your own two-step sign-in under My account"))
+		return
+	}
+	var name string
+	if err := a.store.Update(func(c *Config) error {
+		_, u := c.userByID(id)
+		if u == nil {
+			return badRequest("no such user")
+		}
+		name = u.Username
+		if u.MFA != nil {
+			u.MFA = &UserMFA{Handle: u.MFA.Handle}
+		}
+		return nil
+	}); err != nil {
+		writeErr(w, err)
+		return
+	}
+	a.audit(r, "two-step sign-in reset", "user", name)
+	writeJSON(w, http.StatusOK, map[string]any{"ok": true})
+}
+
+// mfaSummary is what user lists show.
+func mfaSummary(u *User) map[string]any {
+	out := map[string]any{"totp": false, "passkeys": 0}
+	if m := u.MFA; m != nil {
+		out["totp"], out["passkeys"] = m.TOTPSecret != "", len(m.Keys)
+	}
+	return out
+}

setup.go

@@ -12,6 +12,7 @@ import (
 	"os/user"
 	"path/filepath"
 	"runtime"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
@@ -273,7 +274,51 @@ WantedBy=multi-user.target
 // rewrite the unit for every release.
 const unitVersion = "unit-1"
 
-const sysctlConf = "net.ipv4.ip_forward=1\nnet.ipv6.conf.all.forwarding=1\n"
+// sysctlConf turns on forwarding. With IPv6 forwarding on, Linux ignores
+// router announcements unless accept_ra is 2, and a server that gets its
+// IPv6 route from them (SLAAC, e.g. a Raspberry Pi at home) loses IPv6 when
+// the route expires. So every interface in ras keeps accepting them, as
+// pivpn does for its uplink.
+func sysctlConf(ras []string) string {
+	var b strings.Builder
+	b.WriteString("net.ipv4.ip_forward=1\nnet.ipv6.conf.all.forwarding=1\nnet.ipv6.conf.default.accept_ra=2\n")
+	for _, name := range ras {
+		fmt.Fprintf(&b, "net.ipv6.conf.%s.accept_ra=2\n", name)
+	}
+	return b.String()
+}
+
+// raInterfaces returns the network cards and the interface of the IPv6
+// default route, except those where router announcements are switched off
+// (accept_ra 0). The directories are /proc/sys/net/ipv6/conf and
+// /sys/class/net, routes is /proc/net/ipv6_route.
+func raInterfaces(confDir, netDir, routes string) []string {
+	want := map[string]bool{}
+	if b, err := os.ReadFile(routes); err == nil {
+		for _, line := range strings.Split(string(b), "\n") {
+			f := strings.Fields(line)
+			if len(f) == 10 && f[0] == strings.Repeat("0", 32) && f[1] == "00" && f[9] != "lo" {
+				want[f[9]] = true
+			}
+		}
+	}
+	entries, _ := os.ReadDir(netDir)
+	for _, e := range entries {
+		// Only real devices: bridges, veth and tunnels come and go.
+		if _, err := os.Stat(filepath.Join(netDir, e.Name(), "device")); err == nil {
+			want[e.Name()] = true
+		}
+	}
+	var out []string
+	for name := range want {
+		v := readSysctl(filepath.Join(confDir, name, "accept_ra"))
+		if v == "1" || v == "2" {
+			out = append(out, name)
+		}
+	}
+	slices.Sort(out)
+	return out
+}
 
 // writeSystemFiles writes the unit, sysctl and module files. It reports
 // whether the unit changed (systemd must then reload).
@@ -281,7 +326,8 @@ func writeSystemFiles() (unitChanged bool, err error) {
 	if unitChanged, err = writeIfChanged(unitPath, unitFile(), 0o644); err != nil {
 		return false, err
 	}
-	sysChanged, err := writeIfChanged(sysctlPath, sysctlConf, 0o644)
+	ras := raInterfaces("/proc/sys/net/ipv6/conf", "/sys/class/net", "/proc/net/ipv6_route")
+	sysChanged, err := writeIfChanged(sysctlPath, sysctlConf(ras), 0o644)
 	if err != nil {
 		return false, err
 	}

users.go

@@ -13,14 +13,15 @@ import (
 // everyone changes their own password with the current one.
 
 type userView struct {
-	ID                 string    `json:"id"`
-	Username           string    `json:"username"`
-	Note               string    `json:"note"`
-	MustChangePassword bool      `json:"mustChangePassword"`
-	Created            time.Time `json:"created"`
-	LastLogin          *tokenUse `json:"lastLogin"` // since the service started
-	Tokens             int       `json:"tokens"`
-	You                bool      `json:"you"`
+	ID                 string         `json:"id"`
+	Username           string         `json:"username"`
+	Note               string         `json:"note"`
+	MustChangePassword bool           `json:"mustChangePassword"`
+	Created            time.Time      `json:"created"`
+	LastLogin          *tokenUse      `json:"lastLogin"` // since the service started
+	Tokens             int            `json:"tokens"`
+	You                bool           `json:"you"`
+	MFA                map[string]any `json:"mfa"` // {"totp": bool, "passkeys": n}
 }
 
 func (a *App) userView(c *Config, u *User, me string) userView {
@@ -30,7 +31,7 @@ func (a *App) userView(c *Config, u *User, me string) userView {
 			n++
 		}
 	}
-	return userView{u.ID, u.Username, u.Note, u.MustChangePassword, u.Created, a.auth.LastLogin(u.ID), n, u.ID == me}
+	return userView{u.ID, u.Username, u.Note, u.MustChangePassword, u.Created, a.auth.LastLogin(u.ID), n, u.ID == me, mfaSummary(u)}
 }
 
 // username names a user for lists, or "" if the ID is unknown.

web.go

@@ -1,7 +1,9 @@
 package main
 
 import (
+	"crypto/sha256"
 	"embed"
+	"encoding/hex"
 	"net/http"
 	"net/url"
 	"strings"
@@ -14,6 +16,39 @@ import (
 //go:embed index.html setup.html app.js setup.js app.css favicon.svg apple-touch-icon.png ShipporiMinchoB1-ExtraBold.woff2
 var webFiles embed.FS
 
+// The pages load app.js, setup.js and app.css with ?v=<hash of the file>, so
+// a new binary makes browsers fetch the new files, and a fingerprinted file
+// can be cached for good.
+var (
+	assetHash = map[string]string{}
+	indexPage []byte
+)
+
+func init() {
+	for _, name := range []string{"app.js", "setup.js", "app.css"} {
+		b, err := webFiles.ReadFile(name)
+		if err != nil {
+			panic(err)
+		}
+		sum := sha256.Sum256(b)
+		assetHash[name] = hex.EncodeToString(sum[:5])
+	}
+	b, err := webFiles.ReadFile("index.html")
+	if err != nil {
+		panic(err)
+	}
+	indexPage = fingerprint(b, "/")
+}
+
+// fingerprint adds ?v=<hash> to the page's references to base + file.
+func fingerprint(page []byte, base string) []byte {
+	s := string(page)
+	for name, h := range assetHash {
+		s = strings.ReplaceAll(s, `"`+base+name+`"`, `"`+base+name+"?v="+h+`"`)
+	}
+	return []byte(s)
+}
+
 func (a *App) webHandler() http.Handler {
 	files := http.FileServerFS(webFiles)
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -22,7 +57,18 @@ func (a *App) webHandler() http.Handler {
 			return
 		}
 		switch r.URL.Path {
-		case "/", "/app.js", "/setup.js", "/app.css", "/favicon.svg", "/apple-touch-icon.png":
+		case "/":
+			w.Header().Set("Content-Type", "text/html; charset=utf-8")
+			w.Header().Set("Cache-Control", "no-cache")
+			_, _ = w.Write(indexPage)
+		case "/app.js", "/setup.js", "/app.css":
+			if v := r.URL.Query().Get("v"); v != "" && v == assetHash[r.URL.Path[1:]] {
+				w.Header().Set("Cache-Control", "public, max-age=31536000, immutable")
+			} else {
+				w.Header().Set("Cache-Control", "no-cache")
+			}
+			files.ServeHTTP(w, r)
+		case "/favicon.svg", "/apple-touch-icon.png":
 			w.Header().Set("Cache-Control", "no-cache")
 			files.ServeHTTP(w, r)
 		case "/ShipporiMinchoB1-ExtraBold.woff2":
@@ -66,7 +112,7 @@ func (a *App) setupPage(w http.ResponseWriter, r *http.Request) {
 	page := strings.NewReplacer(`href="/`, `href="`+base, `src="/`, `src="`+base).Replace(string(b))
 	w.Header().Set("Content-Type", "text/html; charset=utf-8")
 	w.Header().Set("Cache-Control", "no-store")
-	_, _ = w.Write([]byte(page))
+	_, _ = w.Write(fingerprint([]byte(page), base))
 }
 
 func (a *App) setupAsset(w http.ResponseWriter, r *http.Request) {