routes.py 30 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646
  1. """HTTP routes for the dashboard-auth OAuth round trip.
  2. Mounted at root (no prefix) by ``web_server.py``; ``gated_auth_middleware``
  3. allowlists the public ones.
  4. GET /login server-rendered login page
  5. GET /auth/login?provider=N 302 to IDP, sets PKCE cookie
  6. GET /auth/native/authorize RFC 8252 native-app (desktop) login start
  7. GET /auth/callback completes login, sets session cookies
  8. POST /auth/password-login username/password login (JSON)
  9. POST /auth/logout clears cookies, best-effort revoke
  10. POST /auth/native/token loopback code -> bearer tokens
  11. POST /auth/native/refresh desktop-held refresh token rotation
  12. GET /api/auth/providers list registered providers (login bootstrap)
  13. GET /api/auth/me Session as JSON (gated: verified session; loopback:
  14. token-validated synthetic loopback identity)
  15. POST /api/auth/ws-ticket single-use WS upgrade ticket (auth-required)
  16. """
  17. from __future__ import annotations
  18. import logging
  19. import threading
  20. import time
  21. from collections import OrderedDict, deque
  22. from typing import Any, Deque, Dict
  23. from urllib.parse import quote, unquote, urlencode, urlparse, urlunparse
  24. from fastapi import APIRouter, HTTPException, Request
  25. from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
  26. from pydantic import BaseModel, Field
  27. from starlette.concurrency import run_in_threadpool
  28. from hermes_cli import webapp_sign_in
  29. from hermes_cli.dashboard_auth import (
  30. get_provider, list_interactive_providers, list_providers, list_session_providers,
  31. native_flow)
  32. from hermes_cli.dashboard_auth import prefix as _prefix_mod
  33. from hermes_cli.dashboard_auth.audit import AuditEvent, audit_log
  34. from hermes_cli.dashboard_auth.base import (
  35. InvalidCodeError, InvalidCredentialsError, ProviderError, Session)
  36. from hermes_cli.dashboard_auth.cookies import (
  37. clear_pkce_cookie, clear_session_cookies, clear_sso_attempt_cookie, detect_https,
  38. parse_pkce_payload, read_pkce_cookie, read_session_cookies, set_pkce_cookie,
  39. set_session_cookies)
  40. from hermes_cli.dashboard_auth.login_page import (
  41. render_login_html, render_native_provider_choice_html)
  42. from hermes_cli.dashboard_auth.refresh_singleflight import refresh_session_coalesced
  43. from hermes_cli.dashboard_auth.request_utils import (
  44. access_token_max_age, client_ip as _client_ip, is_safe_next_path)
  45. _log = logging.getLogger(__name__)
  46. router = APIRouter()
  47. _NO_STORE = {"Cache-Control": "no-store, no-cache, must-revalidate"}
  48. _NATIVE_EXPIRED_DETAIL = "Native login expired or unknown; restart sign-in."
  49. def _http(status_code: int, detail: str) -> HTTPException:
  50. return HTTPException(status_code=status_code, detail=detail)
  51. def _prefix(request: Request) -> str:
  52. """Normalised ``X-Forwarded-Prefix`` (cookie name/Path + redirect URLs)."""
  53. return _prefix_mod.prefix_from_request(request)
  54. def _audit(request: Request, event: AuditEvent, **fields) -> None:
  55. audit_log(event, **fields, ip=_client_ip(request))
  56. def _redirect_uri(request: Request) -> str:
  57. """Absolute ``/auth/callback`` URL handed to the IDP. An operator-declared public URL is the
  58. complete authority (``X-Forwarded-Prefix`` ignored so a baked-in prefix is not doubled);
  59. otherwise ``url_for`` (honours ``X-Forwarded-Host/Proto`` under uvicorn ``proxy_headers``)
  60. with the prefix prepended, which Starlette does not do."""
  61. public_url = _prefix_mod.resolve_public_url(request.app.state)
  62. if public_url:
  63. return f"{public_url}/auth/callback"
  64. base = str(request.url_for("auth_callback"))
  65. prefix = _prefix(request)
  66. if not prefix:
  67. return base
  68. parsed = urlparse(base)
  69. return urlunparse(parsed._replace(path=f"{prefix}{parsed.path}"))
  70. def _provider_pkce_segments(cookie_payload: dict[str, str]) -> dict[str, str]:
  71. """Parse a provider's flat ``state=…;verifier=…`` PKCE string into a dict — the ONE place
  72. the flat form is parsed; :func:`set_pkce_cookie` encodes the dict."""
  73. flat = cookie_payload.get("hermes_session_pkce", "")
  74. return dict(seg.split("=", 1) for seg in flat.split(";") if "=" in seg)
  75. def _validate_post_login_target(raw: str) -> str:
  76. """``raw`` (URL-decoded) if it is a safe same-origin path, else ``""``. Re-validated
  77. at every hop because a ``next=`` value can re-enter via a crafted URL."""
  78. decoded = unquote(raw) if raw else ""
  79. return decoded if decoded and is_safe_next_path(decoded) else ""
  80. def _set_pkce(resp, request: Request, payload: dict[str, str]) -> None:
  81. set_pkce_cookie(resp, payload=payload, use_https=detect_https(request), prefix=_prefix(request),
  82. gateway=webapp_sign_in.cookie_gateway(request))
  83. def _clear_pkce(resp, request: Request) -> None:
  84. clear_pkce_cookie(resp, use_https=detect_https(request), prefix=_prefix(request),
  85. gateway=webapp_sign_in.cookie_gateway(request))
  86. def _set_session(resp, request: Request, session: Session) -> None:
  87. set_session_cookies(
  88. resp, access_token=session.access_token, refresh_token=session.refresh_token,
  89. access_token_expires_in=access_token_max_age(session), use_https=detect_https(request),
  90. prefix=_prefix(request), provider=session.provider, gateway=webapp_sign_in.cookie_gateway(request))
  91. webapp_sign_in.bind(resp, request)
  92. def _bearer_payload(session: Session) -> dict[str, Any]:
  93. """JSON body for the native token/refresh endpoints (tokens in body, no cookie)."""
  94. return {
  95. "access_token": session.access_token, "refresh_token": session.refresh_token,
  96. "token_type": "Bearer", "expires_at": session.expires_at,
  97. "provider": session.provider, "user_id": session.user_id}
  98. def _finish_native_login(
  99. request: Request, *, broker_state: str, session: Session, provider: str) -> str:
  100. """Mint the one-time loopback code and return the desktop's ``redirect_uri?code=…&state=…``.
  101. No session cookies on the native path — the desktop redeems at ``/auth/native/token``."""
  102. try:
  103. pending = native_flow.get_pending(broker_state)
  104. gw_code = native_flow.complete_pending(broker_state, session=session)
  105. except native_flow.NativeFlowError:
  106. _audit(request, AuditEvent.NATIVE_TOKEN_FAILURE, provider=provider,
  107. reason="pending_not_found")
  108. raise _http(400, _NATIVE_EXPIRED_DETAIL)
  109. sep = "&" if "?" in pending.redirect_uri else "?"
  110. query = urlencode({'code': gw_code, 'state': pending.client_state})
  111. _audit(request, AuditEvent.NATIVE_CODE_ISSUED, provider=provider, user_id=session.user_id)
  112. return f"{pending.redirect_uri}{sep}{query}"
  113. def _login_failure(request: Request, provider: str, reason: str, **extra) -> None:
  114. _audit(request, AuditEvent.LOGIN_FAILURE, provider=provider, reason=reason, **extra)
  115. def _login_success(request: Request, session: Session, provider: str) -> None:
  116. _audit(request, AuditEvent.LOGIN_SUCCESS, provider=provider, user_id=session.user_id,
  117. email=session.email, org_id=session.org_id)
  118. def _externalize_post_login_target(target: str, prefix: str) -> str:
  119. """Prepend *prefix* to *target* when behind a reverse proxy.
  120. When the dashboard is mounted at a sub-path (e.g. ``/hermes``) via
  121. ``X-Forwarded-Prefix``, a bare ``/`` landing must become ``/hermes/``
  122. so the browser stays inside the mount. Paths that already carry the
  123. prefix are returned unchanged; the native loopback redirect (an
  124. absolute ``http://127.0.0.1...`` URL) never matches and is untouched.
  125. """
  126. prefix = prefix.rstrip("/")
  127. if not target or not prefix:
  128. return target
  129. if target == prefix or target.startswith(f"{prefix}/"):
  130. return target
  131. return f"{prefix}{target}"
  132. def _complete_login(request: Request, provider: str, session: Session, *, broker_state: str,
  133. next_raw: str) -> tuple:
  134. """Shared tail of the callback + password routes after credentials verified: audit success,
  135. then either the native loopback redirect (no cookies) or the landing path. Returns
  136. ``(target_url, native)``."""
  137. _login_success(request, session, provider)
  138. if broker_state:
  139. return _finish_native_login(
  140. request, broker_state=broker_state, session=session, provider=provider), True
  141. landing = _validate_post_login_target(next_raw) or "/"
  142. return _externalize_post_login_target(landing, _prefix(request)), False
  143. def _start_upstream_login(request: Request, p, *, audit_failure: bool, extra_pkce: dict[str, str]):
  144. """Run ``start_login`` and 302 to the IDP with the PKCE cookie set. That cookie is the only
  145. server-controlled channel surviving the round trip (IDPs echo back only code+state), so it
  146. carries the provider name plus ``extra_pkce``."""
  147. try:
  148. ls = p.start_login(redirect_uri=_redirect_uri(request))
  149. except ProviderError as e:
  150. if audit_failure:
  151. _login_failure(request, p.name, "provider_unreachable")
  152. raise _http(503, f"Provider unreachable: {e}")
  153. resp = RedirectResponse(url=ls.redirect_url, status_code=302)
  154. pkce = _provider_pkce_segments(ls.cookie_payload)
  155. pkce.setdefault("provider", p.name)
  156. pkce.update(extra_pkce)
  157. _set_pkce(resp, request, pkce)
  158. return resp
  159. # --- Public: login page + provider list ------------------------------------
  160. @router.get("/login", name="login_page")
  161. async def login_page(request: Request) -> HTMLResponse:
  162. # ``next=`` is set by the gate's redirect but /login is reachable directly.
  163. next_path = _validate_post_login_target(request.query_params.get("next", ""))
  164. return HTMLResponse(
  165. render_login_html(next_path=next_path, prefix=_prefix(request)), headers=_NO_STORE)
  166. @router.get("/api/auth/providers", name="auth_providers")
  167. async def api_auth_providers() -> Any:
  168. # Only interactive providers are sign-in options; fail closed on zero
  169. # session providers. A deployment authenticated solely by a provisioned
  170. # credential (interactive_login False — the session-token provider) answers
  171. # an empty list: there is no browser sign-in to offer, which is correct,
  172. # not an outage.
  173. if not list_session_providers():
  174. return JSONResponse({"detail": "no auth providers registered"}, status_code=503)
  175. return {"providers": [
  176. {"name": p.name, "display_name": p.display_name,
  177. "supports_password": bool(getattr(p, "supports_password", False))}
  178. for p in list_interactive_providers()]}
  179. # --- Public: OAuth round trip ----------------------------------------------
  180. @router.get("/auth/login", name="auth_login")
  181. async def auth_login(request: Request, provider: str, next: str = ""):
  182. p = get_provider(provider)
  183. if p is None:
  184. raise _http(404, f"Unknown provider: {provider!r}")
  185. if not getattr(p, "supports_session", True):
  186. raise _http(404, f"Provider does not support interactive login: {provider!r}")
  187. if not getattr(p, "interactive_login", True):
  188. # Verifies credentials but has no sign-in flow (the session-token provider):
  189. # never 500 inside start_login — answer the same 404 an unknown provider gets.
  190. raise _http(404, f"Provider has no interactive login: {provider!r}")
  191. safe_next = _validate_post_login_target(next)
  192. if getattr(p, "supports_password", False):
  193. login_url = f"{_prefix(request)}/login"
  194. if safe_next:
  195. login_url = f"{login_url}?next={quote(safe_next, safe='')}"
  196. return RedirectResponse(url=login_url, status_code=302)
  197. resp = _start_upstream_login(
  198. request, p, audit_failure=True, extra_pkce={"next": safe_next} if safe_next else {})
  199. _audit(request, AuditEvent.LOGIN_START, provider=provider)
  200. return resp
  201. # --- Public: RFC 8252 native-app authorization (system browser + loopback + PKCE)
  202. # RFC 8252 loopback IP literals -> their canonical URL authority spelling.
  203. _LOOPBACK_NETLOC_HOSTS = {"127.0.0.1": "127.0.0.1", "::1": "[::1]"}
  204. def _validate_loopback_redirect_uri(raw: str) -> str:
  205. """Return a canonical RFC 8252 loopback URI or reject it.
  206. Both the server parser and the system browser must see the same authority: URL userinfo,
  207. backslashes, fragments, controls, and non-canonical host/port spellings are rejected before
  208. the URI is persisted. ``localhost`` is rejected in favour of IP literals (RFC 8252 §8.3).
  209. """
  210. if not raw:
  211. raise _http(400, "redirect_uri required")
  212. if (
  213. not raw.isascii()
  214. or "\\" in raw
  215. or any(ord(ch) <= 0x20 or ord(ch) == 0x7F for ch in raw)
  216. ):
  217. raise _http(400, "native redirect_uri must use a canonical loopback URL")
  218. try:
  219. parsed = urlparse(raw)
  220. hostname = parsed.hostname
  221. port = parsed.port
  222. except ValueError:
  223. raise _http(400, "native redirect_uri must use a canonical loopback URL")
  224. if parsed.scheme != "http":
  225. raise _http(400, "native redirect_uri must be http:// on the loopback interface")
  226. if "#" in raw:
  227. raise _http(400, "native redirect_uri must not contain a fragment")
  228. if parsed.username is not None or parsed.password is not None:
  229. raise _http(400, "native redirect_uri must not contain userinfo")
  230. canonical_host = _LOOPBACK_NETLOC_HOSTS.get(hostname)
  231. if canonical_host is None:
  232. raise _http(400, "native redirect_uri host must be a loopback IP literal (127.0.0.1 / ::1)")
  233. canonical_netloc = canonical_host + (f":{port}" if port is not None else "")
  234. if parsed.netloc != canonical_netloc:
  235. raise _http(400, "native redirect_uri must use a canonical loopback authority")
  236. # scheme/netloc are already canonical and fragments rejected; only an empty path needs "/".
  237. return urlunparse(parsed._replace(path=parsed.path or "/"))
  238. def _select_native_provider(provider: str):
  239. """Resolve the provider for a native authorize request. An empty ``provider`` auto-selects
  240. the ONLY interactive session provider (password providers included — native sign-in brokers
  241. them via ``/login``); with several the caller renders a chooser instead of guessing."""
  242. if provider:
  243. return get_provider(provider)
  244. candidates = list_interactive_providers()
  245. return candidates[0] if len(candidates) == 1 else None
  246. @router.get("/auth/native/authorize", name="auth_native_authorize")
  247. async def auth_native_authorize(
  248. request: Request, provider: str = "", code_challenge: str = "",
  249. code_challenge_method: str = "", redirect_uri: str = "", state: str = ""):
  250. """Begin an RFC 8252 native-app login: stash a pending broker authorization keyed by an
  251. opaque ``broker_state`` riding in the gateway's own PKCE cookie (the desktop's
  252. challenge/state never touch it), then run the normal upstream round trip. Password providers
  253. go to the ``/login`` form instead."""
  254. if code_challenge_method.upper() != "S256":
  255. raise _http(400, "code_challenge_method must be S256")
  256. if not code_challenge:
  257. raise _http(400, "code_challenge required")
  258. redirect_uri = _validate_loopback_redirect_uri(redirect_uri)
  259. p = _select_native_provider(provider)
  260. if p is None and not provider:
  261. candidates = list_interactive_providers()
  262. if len(candidates) > 1:
  263. # Render the chooser BEFORE allocating broker state or setting a cookie: every link
  264. # re-enters this same validated route with an explicit provider.
  265. return HTMLResponse(
  266. render_native_provider_choice_html(
  267. providers=candidates,
  268. authorize_path=f"{_prefix(request)}/auth/native/authorize",
  269. code_challenge=code_challenge,
  270. code_challenge_method=code_challenge_method,
  271. redirect_uri=redirect_uri, state=state,
  272. prefix=_prefix(request)),
  273. headers=_NO_STORE)
  274. if p is None:
  275. raise _http(404, f"Unknown provider: {provider!r}")
  276. if not getattr(p, "supports_session", True) or not getattr(p, "interactive_login", True):
  277. # Checked BEFORE register_pending: a provisioned-credential provider (session-token)
  278. # has only a start_login stub, so it must never reach the upstream round trip.
  279. raise _http(400, f"Provider does not support native login: {p.name!r}")
  280. try:
  281. broker_state = native_flow.register_pending(
  282. code_challenge=code_challenge, redirect_uri=redirect_uri, client_state=state,
  283. client_ip=_client_ip(request))
  284. except native_flow.NativeFlowError as e:
  285. raise _http(503, str(e))
  286. if getattr(p, "supports_password", False):
  287. _audit(request, AuditEvent.NATIVE_AUTHORIZE_START, provider=p.name)
  288. resp = RedirectResponse(url=f"{_prefix(request)}/login", status_code=302)
  289. _set_pkce(resp, request, {"provider": p.name, "broker": broker_state})
  290. return resp
  291. resp = _start_upstream_login(
  292. request, p, audit_failure=False, extra_pkce={"broker": broker_state})
  293. _audit(request, AuditEvent.NATIVE_AUTHORIZE_START, provider=p.name)
  294. return resp
  295. @router.get("/auth/callback", name="auth_callback")
  296. async def auth_callback(
  297. request: Request, code: str = "", state: str = "", error: str = "",
  298. error_description: str = ""):
  299. pkce_raw = read_pkce_cookie(request, webapp_sign_in.cookie_gateway(request))
  300. if not pkce_raw:
  301. _audit(request, AuditEvent.LOGIN_FAILURE, reason="missing_pkce_cookie")
  302. raise _http(400, "Missing PKCE state cookie")
  303. # ``next`` and ``broker`` come from the server-set cookie ONLY: the IDP
  304. # echoes back just code+state, so any such query param is attacker controlled.
  305. parts = parse_pkce_payload(pkce_raw)
  306. provider_name = parts.get("provider", "")
  307. p = get_provider(provider_name)
  308. if p is None:
  309. raise _http(400, f"Unknown provider in cookie: {provider_name!r}")
  310. if error:
  311. _login_failure(request, provider_name, "idp_error", error=error)
  312. raise _http(400, f"OAuth error from provider: {error} ({error_description})")
  313. if not state or state != parts.get("state", ""):
  314. _login_failure(request, provider_name, "state_mismatch")
  315. raise _http(400, "OAuth state mismatch (CSRF check failed)")
  316. try:
  317. session = p.complete_login(
  318. code=code, state=state, code_verifier=parts.get("verifier", ""),
  319. redirect_uri=_redirect_uri(request))
  320. except InvalidCodeError as e:
  321. _login_failure(request, provider_name, "invalid_code")
  322. raise _http(400, f"Invalid code: {e}")
  323. except ProviderError as e:
  324. _login_failure(request, provider_name, "provider_unreachable")
  325. raise _http(503, f"Provider unreachable: {e}")
  326. target, native = _complete_login(
  327. request, provider_name, session, broker_state=parts.get("broker", ""),
  328. next_raw=parts.get("next", ""))
  329. resp = RedirectResponse(url=target, status_code=302)
  330. if not native:
  331. _set_session(resp, request, session)
  332. _clear_pkce(resp, request)
  333. # Clear the one-shot auto-SSO loop-guard so it never suppresses a future silent attempt.
  334. clear_sso_attempt_cookie(resp, prefix=_prefix(request), gateway=webapp_sign_in.cookie_gateway(request))
  335. return resp
  336. # --- Public: password (non-redirect) login ---------------------------------
  337. # Brute-force throttle: a process-local sliding window per client IP. Best-effort
  338. # defence-in-depth on top of the provider's constant-time verify (resets on restart).
  339. # Uses the ASGI peer; trusted proxy normalization must happen upstream.
  340. _PW_RATE_MAX_ATTEMPTS = 10
  341. _PW_RATE_WINDOW_SEC = 60.0
  342. _PW_RATE_MAX_BUCKETS = 4096
  343. _pw_attempts: OrderedDict[str, deque[float]] = OrderedDict()
  344. _pw_attempts_lock = threading.Lock()
  345. def _prune_password_rate_buckets_locked(cutoff: float) -> None:
  346. """Drop expired/empty password-login limiter buckets.
  347. Must be called with ``_pw_attempts_lock`` held.
  348. """
  349. for bucket_key in list(_pw_attempts.keys()):
  350. bucket = _pw_attempts[bucket_key]
  351. while bucket and bucket[0] < cutoff:
  352. bucket.popleft()
  353. if not bucket:
  354. _pw_attempts.pop(bucket_key, None)
  355. def _password_rate_limited(ip: str) -> bool:
  356. """True if ``ip`` exceeded the budget; records the attempt when allowed. An empty IP shares
  357. one bucket — fail-safe toward throttling."""
  358. now = time.monotonic()
  359. cutoff = now - _PW_RATE_WINDOW_SEC
  360. with _pw_attempts_lock:
  361. key = ip or "_unknown_"
  362. max_buckets = max(1, int(_PW_RATE_MAX_BUCKETS))
  363. if key not in _pw_attempts and len(_pw_attempts) >= max_buckets:
  364. _prune_password_rate_buckets_locked(cutoff)
  365. while key not in _pw_attempts and len(_pw_attempts) >= max_buckets:
  366. _pw_attempts.popitem(last=False)
  367. bucket = _pw_attempts.get(key)
  368. if bucket is None:
  369. bucket = deque()
  370. _pw_attempts[key] = bucket
  371. else:
  372. _pw_attempts.move_to_end(key)
  373. while bucket and bucket[0] < cutoff:
  374. bucket.popleft()
  375. if len(bucket) >= _PW_RATE_MAX_ATTEMPTS:
  376. return True
  377. bucket.append(now)
  378. return False
  379. def _reset_password_rate_limit() -> None:
  380. """Test-only: clear all rate-limit buckets."""
  381. with _pw_attempts_lock:
  382. _pw_attempts.clear()
  383. class _PasswordLoginBody(BaseModel):
  384. # Providers use short stable IDs, not display names or URLs.
  385. provider: str = Field(max_length=128)
  386. username: str
  387. password: str
  388. next: str = ""
  389. @router.post("/auth/password-login", name="auth_password_login")
  390. async def auth_password_login(request: Request, body: _PasswordLoginBody):
  391. """Authenticate a username/password against a password provider.
  392. Returns ``{"ok": true, "next": <path>}`` (the form POSTs via fetch, which follows a 302
  393. opaquely) and sets the session cookies; with a native ``broker`` handle in the PKCE cookie,
  394. ``next`` is the desktop's loopback redirect and NO cookies are set. Failures are deliberately
  395. generic (no username/provider oracle): unknown/non-password provider 404, bad credentials
  396. 401, store unreachable 503, rate limited 429.
  397. """
  398. if _password_rate_limited(_client_ip(request)):
  399. _login_failure(request, body.provider, "rate_limited")
  400. raise _http(429, "Too many login attempts. Try again shortly.")
  401. p = get_provider(body.provider)
  402. if p is None or not getattr(p, "supports_password", False):
  403. _login_failure(request, body.provider, "unknown_password_provider")
  404. raise _http(404, "Unknown provider")
  405. # The native broker handle also records WHICH provider the flow was started for. Enforce
  406. # equality BEFORE verifying credentials so a flow started for provider A cannot be completed
  407. # with provider B's credentials.
  408. pkce_raw = read_pkce_cookie(request, webapp_sign_in.cookie_gateway(request))
  409. pkce_parts = parse_pkce_payload(pkce_raw) if pkce_raw else {}
  410. broker_state = pkce_parts.get("broker", "")
  411. if broker_state and pkce_parts.get("provider", "") != body.provider:
  412. _audit(request, AuditEvent.NATIVE_TOKEN_FAILURE, provider=body.provider,
  413. reason="provider_mismatch")
  414. raise _http(400, "This native sign-in was started for a different provider; "
  415. "use that provider's form or restart sign-in.")
  416. try:
  417. session = p.complete_password_login(username=body.username, password=body.password)
  418. except InvalidCredentialsError:
  419. _login_failure(request, body.provider, "invalid_credentials")
  420. raise _http(401, "Invalid credentials")
  421. except NotImplementedError:
  422. # supports_password True but method not implemented: a provider bug.
  423. raise _http(500, "Provider misconfigured")
  424. except ProviderError as e:
  425. _login_failure(request, body.provider, "provider_unreachable")
  426. raise _http(503, f"Provider unreachable: {e}")
  427. target, native = _complete_login(
  428. request, body.provider, session, broker_state=broker_state, next_raw=body.next)
  429. resp = JSONResponse({"ok": True, "next": target})
  430. if native:
  431. _clear_pkce(resp, request)
  432. else:
  433. _set_session(resp, request, session)
  434. return resp
  435. @router.post("/auth/logout", name="auth_logout")
  436. async def auth_logout(request: Request):
  437. _at, rt = read_session_cookies(request, webapp_sign_in.cookie_gateway(request))
  438. # Best-effort revoke on every provider; failures logged, never raised.
  439. for provider in list_providers() if rt else ():
  440. try:
  441. provider.revoke_session(refresh_token=rt)
  442. except Exception as e:
  443. _log.warning("dashboard-auth: revoke on %r failed: %s", provider.name, e)
  444. sess = getattr(request.state, "session", None)
  445. _audit(request, AuditEvent.LOGOUT, provider=(sess.provider if sess else "unknown"),
  446. user_id=(sess.user_id if sess else ""))
  447. prefix = _prefix(request)
  448. resp = RedirectResponse(url=f"{prefix}/login", status_code=302)
  449. clear_session_cookies(resp, prefix=prefix, gateway=webapp_sign_in.cookie_gateway(request))
  450. _clear_pkce(resp, request)
  451. return resp
  452. # --- Auth-required: identity probe + WS ticket for the SPA -----------------
  453. def _require_session(request: Request):
  454. sess = getattr(request.state, "session", None)
  455. if sess is None:
  456. raise _http(401, "Unauthorized")
  457. return sess
  458. @router.get("/api/auth/me", name="auth_me")
  459. async def api_auth_me(request: Request):
  460. """Return the verified session as JSON.
  461. Gated mode: the auth middleware attached a verified Session — return it.
  462. Loopback mode (``auth_required`` False): there is no OAuth Session, but the
  463. legacy ``_SESSION_TOKEN`` middleware has already validated the bearer
  464. token for non-public ``/api/`` routes. Report the loopback identity
  465. honestly instead of 401-ing (GH #66223). Belt-and-braces: re-verify the
  466. token so the handler stays safe even if this route were ever allowlisted.
  467. """
  468. sess = getattr(request.state, "session", None)
  469. if sess is None:
  470. if getattr(request.app.state, "auth_required", False):
  471. raise _http(401, "Unauthorized")
  472. from hermes_cli.web_server import _has_valid_session_token
  473. if not _has_valid_session_token(request):
  474. raise _http(401, "Unauthorized")
  475. return {
  476. "user_id": "local",
  477. "email": "",
  478. "display_name": "Local",
  479. "org_id": "",
  480. "provider": "loopback",
  481. "expires_at": 0,
  482. }
  483. return {
  484. "user_id": sess.user_id, "email": sess.email, "display_name": sess.display_name,
  485. "org_id": sess.org_id, "provider": sess.provider, "expires_at": sess.expires_at}
  486. @router.post("/api/auth/ws-ticket", name="auth_ws_ticket")
  487. async def api_auth_ws_ticket(request: Request):
  488. """Mint a 30s single-use ticket for a WS upgrade (browsers cannot set
  489. ``Authorization`` on the upgrade); one ticket per WS."""
  490. sess = _require_session(request)
  491. from hermes_cli.dashboard_auth.ws_tickets import TTL_SECONDS, mint_ticket
  492. # On the gateway's Webapp the ticket carries the login's sign-in binding, so the socket it opens
  493. # closes at sign-out (``hermes_cli.webapp_sign_in``).
  494. signed_in = webapp_sign_in.sign_in_of(request)
  495. ticket = mint_ticket(user_id=sess.user_id, provider=sess.provider, issuer=sess.issuer,
  496. extra={"sign_in": signed_in} if signed_in else None)
  497. _audit(request, AuditEvent.WS_TICKET_MINTED, provider=sess.provider, user_id=sess.user_id)
  498. return {"ticket": ticket, "ttl_seconds": TTL_SECONDS}
  499. # --- Public: RFC 8252 native-app token exchange + refresh ------------------
  500. class _NativeTokenBody(BaseModel):
  501. code: str
  502. code_verifier: str
  503. @router.post("/auth/native/token", name="auth_native_token")
  504. async def auth_native_token(request: Request, body: _NativeTokenBody):
  505. """Exchange a loopback gateway code + PKCE verifier for bearer tokens. The code is consumed
  506. on every path (no verifier oracle, no replay); any failure is a generic 400. Tokens go in
  507. the JSON body; no cookie is set."""
  508. try:
  509. session = native_flow.redeem_code(code=body.code, code_verifier=body.code_verifier)
  510. except native_flow.CodeInvalid:
  511. _audit(request, AuditEvent.NATIVE_TOKEN_FAILURE, reason="invalid_code_or_pkce")
  512. raise _http(400, "Invalid or expired authorization code.")
  513. webapp_sign_in.gave_native_app(request, session)
  514. _audit(request, AuditEvent.NATIVE_TOKEN_SUCCESS, provider=session.provider,
  515. user_id=session.user_id)
  516. return _bearer_payload(session)
  517. class _NativeRefreshBody(BaseModel):
  518. refresh_token: str
  519. provider: str = ""
  520. @router.post("/auth/native/refresh", name="auth_native_refresh")
  521. async def auth_native_refresh(request: Request, body: _NativeRefreshBody):
  522. """Rotate a desktop-held refresh token (mirrors the gate's ``_attempt_refresh``): every
  523. provider rejecting the RT -> 401 ``session_expired`` (desktop re-logs); none rotated and one
  524. unreachable -> 503. On the gateway's Webapp behind the gate it renews only refresh tokens
  525. this listener gave a native app's sign-in (``webapp_sign_in.token_works_alone``)."""
  526. if not body.refresh_token:
  527. raise _http(400, "refresh_token required")
  528. if not webapp_sign_in.token_works_alone(request, body.refresh_token):
  529. _audit(request, AuditEvent.REFRESH_FAILURE, reason="not_a_native_sign_in")
  530. return JSONResponse(
  531. {"error": "session_expired",
  532. "detail": "Refresh token expired or invalid; start a new sign-in."}, status_code=401)
  533. try:
  534. # Off the event loop: the provider call is synchronous network I/O and a slow IdP
  535. # otherwise wedges every public endpoint (/api/status) behind it.
  536. refreshed = await run_in_threadpool(
  537. refresh_session_coalesced, body.refresh_token, body.provider,
  538. phase="native refresh", log=_log)
  539. except ProviderError as e:
  540. raise _http(503, f"Auth provider {str(e)!r} unreachable")
  541. if refreshed is not None:
  542. session = refreshed[0]
  543. webapp_sign_in.gave_native_app(request, session)
  544. _audit(request, AuditEvent.REFRESH_SUCCESS, provider=session.provider,
  545. user_id=session.user_id)
  546. return _bearer_payload(session)
  547. _audit(request, AuditEvent.REFRESH_FAILURE, reason="all_providers_rejected_rt")
  548. return JSONResponse(
  549. {"error": "session_expired",
  550. "detail": "Refresh token expired or invalid; start a new sign-in."}, status_code=401)