| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646 |
- """HTTP routes for the dashboard-auth OAuth round trip.
- Mounted at root (no prefix) by ``web_server.py``; ``gated_auth_middleware``
- allowlists the public ones.
- GET /login server-rendered login page
- GET /auth/login?provider=N 302 to IDP, sets PKCE cookie
- GET /auth/native/authorize RFC 8252 native-app (desktop) login start
- GET /auth/callback completes login, sets session cookies
- POST /auth/password-login username/password login (JSON)
- POST /auth/logout clears cookies, best-effort revoke
- POST /auth/native/token loopback code -> bearer tokens
- POST /auth/native/refresh desktop-held refresh token rotation
- GET /api/auth/providers list registered providers (login bootstrap)
- GET /api/auth/me Session as JSON (gated: verified session; loopback:
- token-validated synthetic loopback identity)
- POST /api/auth/ws-ticket single-use WS upgrade ticket (auth-required)
- """
- from __future__ import annotations
- import logging
- import threading
- import time
- from collections import OrderedDict, deque
- from typing import Any, Deque, Dict
- from urllib.parse import quote, unquote, urlencode, urlparse, urlunparse
- from fastapi import APIRouter, HTTPException, Request
- from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
- from pydantic import BaseModel, Field
- from starlette.concurrency import run_in_threadpool
- from hermes_cli import webapp_sign_in
- from hermes_cli.dashboard_auth import (
- get_provider, list_interactive_providers, list_providers, list_session_providers,
- native_flow)
- from hermes_cli.dashboard_auth import prefix as _prefix_mod
- from hermes_cli.dashboard_auth.audit import AuditEvent, audit_log
- from hermes_cli.dashboard_auth.base import (
- InvalidCodeError, InvalidCredentialsError, ProviderError, Session)
- from hermes_cli.dashboard_auth.cookies import (
- clear_pkce_cookie, clear_session_cookies, clear_sso_attempt_cookie, detect_https,
- parse_pkce_payload, read_pkce_cookie, read_session_cookies, set_pkce_cookie,
- set_session_cookies)
- from hermes_cli.dashboard_auth.login_page import (
- render_login_html, render_native_provider_choice_html)
- from hermes_cli.dashboard_auth.refresh_singleflight import refresh_session_coalesced
- from hermes_cli.dashboard_auth.request_utils import (
- access_token_max_age, client_ip as _client_ip, is_safe_next_path)
- _log = logging.getLogger(__name__)
- router = APIRouter()
- _NO_STORE = {"Cache-Control": "no-store, no-cache, must-revalidate"}
- _NATIVE_EXPIRED_DETAIL = "Native login expired or unknown; restart sign-in."
- def _http(status_code: int, detail: str) -> HTTPException:
- return HTTPException(status_code=status_code, detail=detail)
- def _prefix(request: Request) -> str:
- """Normalised ``X-Forwarded-Prefix`` (cookie name/Path + redirect URLs)."""
- return _prefix_mod.prefix_from_request(request)
- def _audit(request: Request, event: AuditEvent, **fields) -> None:
- audit_log(event, **fields, ip=_client_ip(request))
- def _redirect_uri(request: Request) -> str:
- """Absolute ``/auth/callback`` URL handed to the IDP. An operator-declared public URL is the
- complete authority (``X-Forwarded-Prefix`` ignored so a baked-in prefix is not doubled);
- otherwise ``url_for`` (honours ``X-Forwarded-Host/Proto`` under uvicorn ``proxy_headers``)
- with the prefix prepended, which Starlette does not do."""
- public_url = _prefix_mod.resolve_public_url(request.app.state)
- if public_url:
- return f"{public_url}/auth/callback"
- base = str(request.url_for("auth_callback"))
- prefix = _prefix(request)
- if not prefix:
- return base
- parsed = urlparse(base)
- return urlunparse(parsed._replace(path=f"{prefix}{parsed.path}"))
- def _provider_pkce_segments(cookie_payload: dict[str, str]) -> dict[str, str]:
- """Parse a provider's flat ``state=…;verifier=…`` PKCE string into a dict — the ONE place
- the flat form is parsed; :func:`set_pkce_cookie` encodes the dict."""
- flat = cookie_payload.get("hermes_session_pkce", "")
- return dict(seg.split("=", 1) for seg in flat.split(";") if "=" in seg)
- def _validate_post_login_target(raw: str) -> str:
- """``raw`` (URL-decoded) if it is a safe same-origin path, else ``""``. Re-validated
- at every hop because a ``next=`` value can re-enter via a crafted URL."""
- decoded = unquote(raw) if raw else ""
- return decoded if decoded and is_safe_next_path(decoded) else ""
- def _set_pkce(resp, request: Request, payload: dict[str, str]) -> None:
- set_pkce_cookie(resp, payload=payload, use_https=detect_https(request), prefix=_prefix(request),
- gateway=webapp_sign_in.cookie_gateway(request))
- def _clear_pkce(resp, request: Request) -> None:
- clear_pkce_cookie(resp, use_https=detect_https(request), prefix=_prefix(request),
- gateway=webapp_sign_in.cookie_gateway(request))
- def _set_session(resp, request: Request, session: Session) -> None:
- set_session_cookies(
- resp, access_token=session.access_token, refresh_token=session.refresh_token,
- access_token_expires_in=access_token_max_age(session), use_https=detect_https(request),
- prefix=_prefix(request), provider=session.provider, gateway=webapp_sign_in.cookie_gateway(request))
- webapp_sign_in.bind(resp, request)
- def _bearer_payload(session: Session) -> dict[str, Any]:
- """JSON body for the native token/refresh endpoints (tokens in body, no cookie)."""
- return {
- "access_token": session.access_token, "refresh_token": session.refresh_token,
- "token_type": "Bearer", "expires_at": session.expires_at,
- "provider": session.provider, "user_id": session.user_id}
- def _finish_native_login(
- request: Request, *, broker_state: str, session: Session, provider: str) -> str:
- """Mint the one-time loopback code and return the desktop's ``redirect_uri?code=…&state=…``.
- No session cookies on the native path — the desktop redeems at ``/auth/native/token``."""
- try:
- pending = native_flow.get_pending(broker_state)
- gw_code = native_flow.complete_pending(broker_state, session=session)
- except native_flow.NativeFlowError:
- _audit(request, AuditEvent.NATIVE_TOKEN_FAILURE, provider=provider,
- reason="pending_not_found")
- raise _http(400, _NATIVE_EXPIRED_DETAIL)
- sep = "&" if "?" in pending.redirect_uri else "?"
- query = urlencode({'code': gw_code, 'state': pending.client_state})
- _audit(request, AuditEvent.NATIVE_CODE_ISSUED, provider=provider, user_id=session.user_id)
- return f"{pending.redirect_uri}{sep}{query}"
- def _login_failure(request: Request, provider: str, reason: str, **extra) -> None:
- _audit(request, AuditEvent.LOGIN_FAILURE, provider=provider, reason=reason, **extra)
- def _login_success(request: Request, session: Session, provider: str) -> None:
- _audit(request, AuditEvent.LOGIN_SUCCESS, provider=provider, user_id=session.user_id,
- email=session.email, org_id=session.org_id)
- def _externalize_post_login_target(target: str, prefix: str) -> str:
- """Prepend *prefix* to *target* when behind a reverse proxy.
- When the dashboard is mounted at a sub-path (e.g. ``/hermes``) via
- ``X-Forwarded-Prefix``, a bare ``/`` landing must become ``/hermes/``
- so the browser stays inside the mount. Paths that already carry the
- prefix are returned unchanged; the native loopback redirect (an
- absolute ``http://127.0.0.1...`` URL) never matches and is untouched.
- """
- prefix = prefix.rstrip("/")
- if not target or not prefix:
- return target
- if target == prefix or target.startswith(f"{prefix}/"):
- return target
- return f"{prefix}{target}"
- def _complete_login(request: Request, provider: str, session: Session, *, broker_state: str,
- next_raw: str) -> tuple:
- """Shared tail of the callback + password routes after credentials verified: audit success,
- then either the native loopback redirect (no cookies) or the landing path. Returns
- ``(target_url, native)``."""
- _login_success(request, session, provider)
- if broker_state:
- return _finish_native_login(
- request, broker_state=broker_state, session=session, provider=provider), True
- landing = _validate_post_login_target(next_raw) or "/"
- return _externalize_post_login_target(landing, _prefix(request)), False
- def _start_upstream_login(request: Request, p, *, audit_failure: bool, extra_pkce: dict[str, str]):
- """Run ``start_login`` and 302 to the IDP with the PKCE cookie set. That cookie is the only
- server-controlled channel surviving the round trip (IDPs echo back only code+state), so it
- carries the provider name plus ``extra_pkce``."""
- try:
- ls = p.start_login(redirect_uri=_redirect_uri(request))
- except ProviderError as e:
- if audit_failure:
- _login_failure(request, p.name, "provider_unreachable")
- raise _http(503, f"Provider unreachable: {e}")
- resp = RedirectResponse(url=ls.redirect_url, status_code=302)
- pkce = _provider_pkce_segments(ls.cookie_payload)
- pkce.setdefault("provider", p.name)
- pkce.update(extra_pkce)
- _set_pkce(resp, request, pkce)
- return resp
- # --- Public: login page + provider list ------------------------------------
- @router.get("/login", name="login_page")
- async def login_page(request: Request) -> HTMLResponse:
- # ``next=`` is set by the gate's redirect but /login is reachable directly.
- next_path = _validate_post_login_target(request.query_params.get("next", ""))
- return HTMLResponse(
- render_login_html(next_path=next_path, prefix=_prefix(request)), headers=_NO_STORE)
- @router.get("/api/auth/providers", name="auth_providers")
- async def api_auth_providers() -> Any:
- # Only interactive providers are sign-in options; fail closed on zero
- # session providers. A deployment authenticated solely by a provisioned
- # credential (interactive_login False — the session-token provider) answers
- # an empty list: there is no browser sign-in to offer, which is correct,
- # not an outage.
- if not list_session_providers():
- return JSONResponse({"detail": "no auth providers registered"}, status_code=503)
- return {"providers": [
- {"name": p.name, "display_name": p.display_name,
- "supports_password": bool(getattr(p, "supports_password", False))}
- for p in list_interactive_providers()]}
- # --- Public: OAuth round trip ----------------------------------------------
- @router.get("/auth/login", name="auth_login")
- async def auth_login(request: Request, provider: str, next: str = ""):
- p = get_provider(provider)
- if p is None:
- raise _http(404, f"Unknown provider: {provider!r}")
- if not getattr(p, "supports_session", True):
- raise _http(404, f"Provider does not support interactive login: {provider!r}")
- if not getattr(p, "interactive_login", True):
- # Verifies credentials but has no sign-in flow (the session-token provider):
- # never 500 inside start_login — answer the same 404 an unknown provider gets.
- raise _http(404, f"Provider has no interactive login: {provider!r}")
- safe_next = _validate_post_login_target(next)
- if getattr(p, "supports_password", False):
- login_url = f"{_prefix(request)}/login"
- if safe_next:
- login_url = f"{login_url}?next={quote(safe_next, safe='')}"
- return RedirectResponse(url=login_url, status_code=302)
- resp = _start_upstream_login(
- request, p, audit_failure=True, extra_pkce={"next": safe_next} if safe_next else {})
- _audit(request, AuditEvent.LOGIN_START, provider=provider)
- return resp
- # --- Public: RFC 8252 native-app authorization (system browser + loopback + PKCE)
- # RFC 8252 loopback IP literals -> their canonical URL authority spelling.
- _LOOPBACK_NETLOC_HOSTS = {"127.0.0.1": "127.0.0.1", "::1": "[::1]"}
- def _validate_loopback_redirect_uri(raw: str) -> str:
- """Return a canonical RFC 8252 loopback URI or reject it.
- Both the server parser and the system browser must see the same authority: URL userinfo,
- backslashes, fragments, controls, and non-canonical host/port spellings are rejected before
- the URI is persisted. ``localhost`` is rejected in favour of IP literals (RFC 8252 §8.3).
- """
- if not raw:
- raise _http(400, "redirect_uri required")
- if (
- not raw.isascii()
- or "\\" in raw
- or any(ord(ch) <= 0x20 or ord(ch) == 0x7F for ch in raw)
- ):
- raise _http(400, "native redirect_uri must use a canonical loopback URL")
- try:
- parsed = urlparse(raw)
- hostname = parsed.hostname
- port = parsed.port
- except ValueError:
- raise _http(400, "native redirect_uri must use a canonical loopback URL")
- if parsed.scheme != "http":
- raise _http(400, "native redirect_uri must be http:// on the loopback interface")
- if "#" in raw:
- raise _http(400, "native redirect_uri must not contain a fragment")
- if parsed.username is not None or parsed.password is not None:
- raise _http(400, "native redirect_uri must not contain userinfo")
- canonical_host = _LOOPBACK_NETLOC_HOSTS.get(hostname)
- if canonical_host is None:
- raise _http(400, "native redirect_uri host must be a loopback IP literal (127.0.0.1 / ::1)")
- canonical_netloc = canonical_host + (f":{port}" if port is not None else "")
- if parsed.netloc != canonical_netloc:
- raise _http(400, "native redirect_uri must use a canonical loopback authority")
- # scheme/netloc are already canonical and fragments rejected; only an empty path needs "/".
- return urlunparse(parsed._replace(path=parsed.path or "/"))
- def _select_native_provider(provider: str):
- """Resolve the provider for a native authorize request. An empty ``provider`` auto-selects
- the ONLY interactive session provider (password providers included — native sign-in brokers
- them via ``/login``); with several the caller renders a chooser instead of guessing."""
- if provider:
- return get_provider(provider)
- candidates = list_interactive_providers()
- return candidates[0] if len(candidates) == 1 else None
- @router.get("/auth/native/authorize", name="auth_native_authorize")
- async def auth_native_authorize(
- request: Request, provider: str = "", code_challenge: str = "",
- code_challenge_method: str = "", redirect_uri: str = "", state: str = ""):
- """Begin an RFC 8252 native-app login: stash a pending broker authorization keyed by an
- opaque ``broker_state`` riding in the gateway's own PKCE cookie (the desktop's
- challenge/state never touch it), then run the normal upstream round trip. Password providers
- go to the ``/login`` form instead."""
- if code_challenge_method.upper() != "S256":
- raise _http(400, "code_challenge_method must be S256")
- if not code_challenge:
- raise _http(400, "code_challenge required")
- redirect_uri = _validate_loopback_redirect_uri(redirect_uri)
- p = _select_native_provider(provider)
- if p is None and not provider:
- candidates = list_interactive_providers()
- if len(candidates) > 1:
- # Render the chooser BEFORE allocating broker state or setting a cookie: every link
- # re-enters this same validated route with an explicit provider.
- return HTMLResponse(
- render_native_provider_choice_html(
- providers=candidates,
- authorize_path=f"{_prefix(request)}/auth/native/authorize",
- code_challenge=code_challenge,
- code_challenge_method=code_challenge_method,
- redirect_uri=redirect_uri, state=state,
- prefix=_prefix(request)),
- headers=_NO_STORE)
- if p is None:
- raise _http(404, f"Unknown provider: {provider!r}")
- if not getattr(p, "supports_session", True) or not getattr(p, "interactive_login", True):
- # Checked BEFORE register_pending: a provisioned-credential provider (session-token)
- # has only a start_login stub, so it must never reach the upstream round trip.
- raise _http(400, f"Provider does not support native login: {p.name!r}")
- try:
- broker_state = native_flow.register_pending(
- code_challenge=code_challenge, redirect_uri=redirect_uri, client_state=state,
- client_ip=_client_ip(request))
- except native_flow.NativeFlowError as e:
- raise _http(503, str(e))
- if getattr(p, "supports_password", False):
- _audit(request, AuditEvent.NATIVE_AUTHORIZE_START, provider=p.name)
- resp = RedirectResponse(url=f"{_prefix(request)}/login", status_code=302)
- _set_pkce(resp, request, {"provider": p.name, "broker": broker_state})
- return resp
- resp = _start_upstream_login(
- request, p, audit_failure=False, extra_pkce={"broker": broker_state})
- _audit(request, AuditEvent.NATIVE_AUTHORIZE_START, provider=p.name)
- return resp
- @router.get("/auth/callback", name="auth_callback")
- async def auth_callback(
- request: Request, code: str = "", state: str = "", error: str = "",
- error_description: str = ""):
- pkce_raw = read_pkce_cookie(request, webapp_sign_in.cookie_gateway(request))
- if not pkce_raw:
- _audit(request, AuditEvent.LOGIN_FAILURE, reason="missing_pkce_cookie")
- raise _http(400, "Missing PKCE state cookie")
- # ``next`` and ``broker`` come from the server-set cookie ONLY: the IDP
- # echoes back just code+state, so any such query param is attacker controlled.
- parts = parse_pkce_payload(pkce_raw)
- provider_name = parts.get("provider", "")
- p = get_provider(provider_name)
- if p is None:
- raise _http(400, f"Unknown provider in cookie: {provider_name!r}")
- if error:
- _login_failure(request, provider_name, "idp_error", error=error)
- raise _http(400, f"OAuth error from provider: {error} ({error_description})")
- if not state or state != parts.get("state", ""):
- _login_failure(request, provider_name, "state_mismatch")
- raise _http(400, "OAuth state mismatch (CSRF check failed)")
- try:
- session = p.complete_login(
- code=code, state=state, code_verifier=parts.get("verifier", ""),
- redirect_uri=_redirect_uri(request))
- except InvalidCodeError as e:
- _login_failure(request, provider_name, "invalid_code")
- raise _http(400, f"Invalid code: {e}")
- except ProviderError as e:
- _login_failure(request, provider_name, "provider_unreachable")
- raise _http(503, f"Provider unreachable: {e}")
- target, native = _complete_login(
- request, provider_name, session, broker_state=parts.get("broker", ""),
- next_raw=parts.get("next", ""))
- resp = RedirectResponse(url=target, status_code=302)
- if not native:
- _set_session(resp, request, session)
- _clear_pkce(resp, request)
- # Clear the one-shot auto-SSO loop-guard so it never suppresses a future silent attempt.
- clear_sso_attempt_cookie(resp, prefix=_prefix(request), gateway=webapp_sign_in.cookie_gateway(request))
- return resp
- # --- Public: password (non-redirect) login ---------------------------------
- # Brute-force throttle: a process-local sliding window per client IP. Best-effort
- # defence-in-depth on top of the provider's constant-time verify (resets on restart).
- # Uses the ASGI peer; trusted proxy normalization must happen upstream.
- _PW_RATE_MAX_ATTEMPTS = 10
- _PW_RATE_WINDOW_SEC = 60.0
- _PW_RATE_MAX_BUCKETS = 4096
- _pw_attempts: OrderedDict[str, deque[float]] = OrderedDict()
- _pw_attempts_lock = threading.Lock()
- def _prune_password_rate_buckets_locked(cutoff: float) -> None:
- """Drop expired/empty password-login limiter buckets.
- Must be called with ``_pw_attempts_lock`` held.
- """
- for bucket_key in list(_pw_attempts.keys()):
- bucket = _pw_attempts[bucket_key]
- while bucket and bucket[0] < cutoff:
- bucket.popleft()
- if not bucket:
- _pw_attempts.pop(bucket_key, None)
- def _password_rate_limited(ip: str) -> bool:
- """True if ``ip`` exceeded the budget; records the attempt when allowed. An empty IP shares
- one bucket — fail-safe toward throttling."""
- now = time.monotonic()
- cutoff = now - _PW_RATE_WINDOW_SEC
- with _pw_attempts_lock:
- key = ip or "_unknown_"
- max_buckets = max(1, int(_PW_RATE_MAX_BUCKETS))
- if key not in _pw_attempts and len(_pw_attempts) >= max_buckets:
- _prune_password_rate_buckets_locked(cutoff)
- while key not in _pw_attempts and len(_pw_attempts) >= max_buckets:
- _pw_attempts.popitem(last=False)
- bucket = _pw_attempts.get(key)
- if bucket is None:
- bucket = deque()
- _pw_attempts[key] = bucket
- else:
- _pw_attempts.move_to_end(key)
- while bucket and bucket[0] < cutoff:
- bucket.popleft()
- if len(bucket) >= _PW_RATE_MAX_ATTEMPTS:
- return True
- bucket.append(now)
- return False
- def _reset_password_rate_limit() -> None:
- """Test-only: clear all rate-limit buckets."""
- with _pw_attempts_lock:
- _pw_attempts.clear()
- class _PasswordLoginBody(BaseModel):
- # Providers use short stable IDs, not display names or URLs.
- provider: str = Field(max_length=128)
- username: str
- password: str
- next: str = ""
- @router.post("/auth/password-login", name="auth_password_login")
- async def auth_password_login(request: Request, body: _PasswordLoginBody):
- """Authenticate a username/password against a password provider.
- Returns ``{"ok": true, "next": <path>}`` (the form POSTs via fetch, which follows a 302
- opaquely) and sets the session cookies; with a native ``broker`` handle in the PKCE cookie,
- ``next`` is the desktop's loopback redirect and NO cookies are set. Failures are deliberately
- generic (no username/provider oracle): unknown/non-password provider 404, bad credentials
- 401, store unreachable 503, rate limited 429.
- """
- if _password_rate_limited(_client_ip(request)):
- _login_failure(request, body.provider, "rate_limited")
- raise _http(429, "Too many login attempts. Try again shortly.")
- p = get_provider(body.provider)
- if p is None or not getattr(p, "supports_password", False):
- _login_failure(request, body.provider, "unknown_password_provider")
- raise _http(404, "Unknown provider")
- # The native broker handle also records WHICH provider the flow was started for. Enforce
- # equality BEFORE verifying credentials so a flow started for provider A cannot be completed
- # with provider B's credentials.
- pkce_raw = read_pkce_cookie(request, webapp_sign_in.cookie_gateway(request))
- pkce_parts = parse_pkce_payload(pkce_raw) if pkce_raw else {}
- broker_state = pkce_parts.get("broker", "")
- if broker_state and pkce_parts.get("provider", "") != body.provider:
- _audit(request, AuditEvent.NATIVE_TOKEN_FAILURE, provider=body.provider,
- reason="provider_mismatch")
- raise _http(400, "This native sign-in was started for a different provider; "
- "use that provider's form or restart sign-in.")
- try:
- session = p.complete_password_login(username=body.username, password=body.password)
- except InvalidCredentialsError:
- _login_failure(request, body.provider, "invalid_credentials")
- raise _http(401, "Invalid credentials")
- except NotImplementedError:
- # supports_password True but method not implemented: a provider bug.
- raise _http(500, "Provider misconfigured")
- except ProviderError as e:
- _login_failure(request, body.provider, "provider_unreachable")
- raise _http(503, f"Provider unreachable: {e}")
- target, native = _complete_login(
- request, body.provider, session, broker_state=broker_state, next_raw=body.next)
- resp = JSONResponse({"ok": True, "next": target})
- if native:
- _clear_pkce(resp, request)
- else:
- _set_session(resp, request, session)
- return resp
- @router.post("/auth/logout", name="auth_logout")
- async def auth_logout(request: Request):
- _at, rt = read_session_cookies(request, webapp_sign_in.cookie_gateway(request))
- # Best-effort revoke on every provider; failures logged, never raised.
- for provider in list_providers() if rt else ():
- try:
- provider.revoke_session(refresh_token=rt)
- except Exception as e:
- _log.warning("dashboard-auth: revoke on %r failed: %s", provider.name, e)
- sess = getattr(request.state, "session", None)
- _audit(request, AuditEvent.LOGOUT, provider=(sess.provider if sess else "unknown"),
- user_id=(sess.user_id if sess else ""))
- prefix = _prefix(request)
- resp = RedirectResponse(url=f"{prefix}/login", status_code=302)
- clear_session_cookies(resp, prefix=prefix, gateway=webapp_sign_in.cookie_gateway(request))
- _clear_pkce(resp, request)
- return resp
- # --- Auth-required: identity probe + WS ticket for the SPA -----------------
- def _require_session(request: Request):
- sess = getattr(request.state, "session", None)
- if sess is None:
- raise _http(401, "Unauthorized")
- return sess
- @router.get("/api/auth/me", name="auth_me")
- async def api_auth_me(request: Request):
- """Return the verified session as JSON.
- Gated mode: the auth middleware attached a verified Session — return it.
- Loopback mode (``auth_required`` False): there is no OAuth Session, but the
- legacy ``_SESSION_TOKEN`` middleware has already validated the bearer
- token for non-public ``/api/`` routes. Report the loopback identity
- honestly instead of 401-ing (GH #66223). Belt-and-braces: re-verify the
- token so the handler stays safe even if this route were ever allowlisted.
- """
- sess = getattr(request.state, "session", None)
- if sess is None:
- if getattr(request.app.state, "auth_required", False):
- raise _http(401, "Unauthorized")
- from hermes_cli.web_server import _has_valid_session_token
- if not _has_valid_session_token(request):
- raise _http(401, "Unauthorized")
- return {
- "user_id": "local",
- "email": "",
- "display_name": "Local",
- "org_id": "",
- "provider": "loopback",
- "expires_at": 0,
- }
- return {
- "user_id": sess.user_id, "email": sess.email, "display_name": sess.display_name,
- "org_id": sess.org_id, "provider": sess.provider, "expires_at": sess.expires_at}
- @router.post("/api/auth/ws-ticket", name="auth_ws_ticket")
- async def api_auth_ws_ticket(request: Request):
- """Mint a 30s single-use ticket for a WS upgrade (browsers cannot set
- ``Authorization`` on the upgrade); one ticket per WS."""
- sess = _require_session(request)
- from hermes_cli.dashboard_auth.ws_tickets import TTL_SECONDS, mint_ticket
- # On the gateway's Webapp the ticket carries the login's sign-in binding, so the socket it opens
- # closes at sign-out (``hermes_cli.webapp_sign_in``).
- signed_in = webapp_sign_in.sign_in_of(request)
- ticket = mint_ticket(user_id=sess.user_id, provider=sess.provider, issuer=sess.issuer,
- extra={"sign_in": signed_in} if signed_in else None)
- _audit(request, AuditEvent.WS_TICKET_MINTED, provider=sess.provider, user_id=sess.user_id)
- return {"ticket": ticket, "ttl_seconds": TTL_SECONDS}
- # --- Public: RFC 8252 native-app token exchange + refresh ------------------
- class _NativeTokenBody(BaseModel):
- code: str
- code_verifier: str
- @router.post("/auth/native/token", name="auth_native_token")
- async def auth_native_token(request: Request, body: _NativeTokenBody):
- """Exchange a loopback gateway code + PKCE verifier for bearer tokens. The code is consumed
- on every path (no verifier oracle, no replay); any failure is a generic 400. Tokens go in
- the JSON body; no cookie is set."""
- try:
- session = native_flow.redeem_code(code=body.code, code_verifier=body.code_verifier)
- except native_flow.CodeInvalid:
- _audit(request, AuditEvent.NATIVE_TOKEN_FAILURE, reason="invalid_code_or_pkce")
- raise _http(400, "Invalid or expired authorization code.")
- webapp_sign_in.gave_native_app(request, session)
- _audit(request, AuditEvent.NATIVE_TOKEN_SUCCESS, provider=session.provider,
- user_id=session.user_id)
- return _bearer_payload(session)
- class _NativeRefreshBody(BaseModel):
- refresh_token: str
- provider: str = ""
- @router.post("/auth/native/refresh", name="auth_native_refresh")
- async def auth_native_refresh(request: Request, body: _NativeRefreshBody):
- """Rotate a desktop-held refresh token (mirrors the gate's ``_attempt_refresh``): every
- provider rejecting the RT -> 401 ``session_expired`` (desktop re-logs); none rotated and one
- unreachable -> 503. On the gateway's Webapp behind the gate it renews only refresh tokens
- this listener gave a native app's sign-in (``webapp_sign_in.token_works_alone``)."""
- if not body.refresh_token:
- raise _http(400, "refresh_token required")
- if not webapp_sign_in.token_works_alone(request, body.refresh_token):
- _audit(request, AuditEvent.REFRESH_FAILURE, reason="not_a_native_sign_in")
- return JSONResponse(
- {"error": "session_expired",
- "detail": "Refresh token expired or invalid; start a new sign-in."}, status_code=401)
- try:
- # Off the event loop: the provider call is synchronous network I/O and a slow IdP
- # otherwise wedges every public endpoint (/api/status) behind it.
- refreshed = await run_in_threadpool(
- refresh_session_coalesced, body.refresh_token, body.provider,
- phase="native refresh", log=_log)
- except ProviderError as e:
- raise _http(503, f"Auth provider {str(e)!r} unreachable")
- if refreshed is not None:
- session = refreshed[0]
- webapp_sign_in.gave_native_app(request, session)
- _audit(request, AuditEvent.REFRESH_SUCCESS, provider=session.provider,
- user_id=session.user_id)
- return _bearer_payload(session)
- _audit(request, AuditEvent.REFRESH_FAILURE, reason="all_providers_rejected_rt")
- return JSONResponse(
- {"error": "session_expired",
- "detail": "Refresh token expired or invalid; start a new sign-in."}, status_code=401)
|