Files
member-dashboard/app/oidc.py
T
inference-bot 622982a371 oidc.py: single-sourced shared module; guest trail consumes the portal's state
- app/oidc.py is now a byte-identical copy of the canonical module
  (ops-docs: scripts/shared/oidc_client.py); this app's identity (logger
  name, session cookie, session salt) is set via oidc.configure() in
  main.py with the app's historical values, so existing sessions survive.
  tests/test_oidc_sync.py pins the copy to the canonical revision — a hand
  edit goes red; changes go through the canonical + sync-oidc-module.sh.
- The guest trail pill consumes the portal-served `state` (the single
  invited-vs-active derivation, tested in the portal) with the old
  status-only payload fallback kept; dashboard-guests-harness.js asserts
  both shapes through the real page JS.
2026-11-11 05:21:31 +00:00

211 lines
8.3 KiB
Python

"""OIDC client for Cloudron's OpenID Connect addon — ONE shared module.
This file is the SINGLE SOURCE for the two thin Cloudron apps that implement
the authorization-code flow themselves (admin-panel, member-dashboard). The
copies in those repos' app/oidc.py are byte-identical to this file — verified
by ops-docs/scripts/check-oidc-sync.py and enforced by each repo's
tests/test_oidc_sync.py — so a fix lands here, is synced to both repos, and
can never drift. Do not edit a repo copy directly: sync-oidc-module.sh
overwrites it, and the pin test goes red on any hand edit.
Cloudron exports these env vars (they change on every restart — read per-call,
never cache at import):
CLOUDRON_OIDC_ISSUER e.g. https://my.inference.coop/openid
CLOUDRON_OIDC_AUTH_ENDPOINT authorization endpoint
CLOUDRON_OIDC_TOKEN_ENDPOINT token endpoint
CLOUDRON_OIDC_KEYS_ENDPOINT JWKS endpoint (RS256/EdDSA keys)
CLOUDRON_OIDC_PROFILE_ENDPOINT userinfo endpoint
CLOUDRON_OIDC_CLIENT_ID client id
CLOUDRON_OIDC_CLIENT_SECRET client secret
CLOUDRON_APP_DOMAIN the app's public domain
Identity: Cloudron's `sub` claim is the username (the unique user identifier).
We use `sub` as the identity; each host app decides what it authorizes — the
panel matches it against its ADMIN_USERNAMES allowlist, the dashboard
forwards it to the portal's broker as `X-Member-User` (which resolves
username → email).
Per-app identity: the ONLY differences the two copies used to carry were the
logger name, the session cookie name and the session salt. The host app now
supplies those via configure() at import time (see each app's main.py), which
keeps this file byte-identical everywhere while preserving each app's
existing cookie names and salts (so existing sessions survive a redeploy).
"""
import os
import secrets as _secrets
import logging
import urllib.parse
import httpx
from authlib.jose import JsonWebToken, JsonWebKey
from itsdangerous import URLSafeTimedSerializer, BadSignature, SignatureExpired
# Per-app identity — set by the host app at import time via configure().
# The unset sentinels below are loud on purpose: a copy that reaches a
# request without its host app having configured itself is a sync/setup bug.
APP_NAME = "unset-app"
SESSION_COOKIE = "unset_oidc_session"
_SESSION_SALT = "unset-oidc-session"
SESSION_MAX_AGE = 60 * 60 * 8 # 8 hours, roughly a working day
SCOPES = "openid profile email"
def configure(app_name: str, session_cookie: str, session_salt: str) -> None:
"""Set this app's identity. The host app MUST call this at import time."""
global APP_NAME, SESSION_COOKIE, _SESSION_SALT
APP_NAME = app_name
SESSION_COOKIE = session_cookie
_SESSION_SALT = session_salt
class _LazyLogger:
"""Resolves at CALL time, not import time.
The host app calls configure() AFTER this module is imported (from its
main.py), so an eagerly-created module-level logger would bind the
'unset-app' sentinel name and every OIDC log line would carry the wrong
attribution. Logging through this proxy reads the configured APP_NAME
when the line is actually emitted; logging.getLogger caches by name, so
the per-call lookup is free.
"""
def __getattr__(self, name):
return getattr(logging.getLogger(APP_NAME), name)
logger = _LazyLogger()
def _oidc_env(name: str) -> str:
return os.environ.get(name, "").strip()
def is_oidc_configured() -> bool:
"""True when Cloudron has injected the OIDC addon env vars."""
return bool(
_oidc_env("CLOUDRON_OIDC_CLIENT_ID")
and _oidc_env("CLOUDRON_OIDC_CLIENT_SECRET")
and _oidc_env("CLOUDRON_OIDC_AUTH_ENDPOINT")
)
def _session_serializer() -> URLSafeTimedSerializer:
# Derive a stable, secret signing key from the OIDC client secret (already
# a secret the app holds, and stable across restarts).
secret = _oidc_env("CLOUDRON_OIDC_CLIENT_SECRET") or _secrets.token_urlsafe(32)
return URLSafeTimedSerializer(secret, salt=_SESSION_SALT)
def _redirect_uri(request_host: str) -> str:
domain = _oidc_env("CLOUDRON_APP_DOMAIN")
host = domain or request_host
scheme = "https"
return f"{scheme}://{host}/auth/openid/callback"
def build_login_url(request_host: str) -> tuple[str, str, str]:
"""Return (login_url, state, nonce). Caller stores state+nonce in cookies."""
state = _secrets.token_urlsafe(24)
nonce = _secrets.token_urlsafe(24)
params = {
"response_type": "code",
"client_id": _oidc_env("CLOUDRON_OIDC_CLIENT_ID"),
"redirect_uri": _redirect_uri(request_host),
"scope": SCOPES,
"state": state,
"nonce": nonce,
}
url = f"{_oidc_env('CLOUDRON_OIDC_AUTH_ENDPOINT')}?{urllib.parse.urlencode(params)}"
return url, state, nonce
async def exchange_code(code: str, request_host: str, nonce: str) -> str:
"""Exchange an authorization code for an ID token, returning the username.
Validates the ID token signature (JWKS), issuer, audience, nonce, and
expiry. Returns the `sub` claim (Cloudron = username) on success.
Raises ValueError on any failure.
"""
issuer = _oidc_env("CLOUDRON_OIDC_ISSUER")
client_id = _oidc_env("CLOUDRON_OIDC_CLIENT_ID")
client_secret = _oidc_env("CLOUDRON_OIDC_CLIENT_SECRET")
token_endpoint = _oidc_env("CLOUDRON_OIDC_TOKEN_ENDPOINT")
keys_endpoint = _oidc_env("CLOUDRON_OIDC_KEYS_ENDPOINT")
id_token = None
async with httpx.AsyncClient(timeout=20.0) as client:
# Token exchange (client_secret_post).
token_resp = await client.post(
token_endpoint,
data={
"grant_type": "authorization_code",
"code": code,
"redirect_uri": _redirect_uri(request_host),
"client_id": client_id,
"client_secret": client_secret,
},
)
if token_resp.status_code != 200:
logger.warning("OIDC token exchange failed: %s %s", token_resp.status_code, token_resp.text[:200])
raise ValueError("token exchange failed")
id_token = token_resp.json().get("id_token")
if not id_token:
logger.warning("OIDC token response missing id_token")
raise ValueError("missing id_token")
# Fetch JWKS.
keys_resp = await client.get(keys_endpoint)
if keys_resp.status_code != 200:
logger.warning("OIDC JWKS fetch failed: %s", keys_resp.status_code)
raise ValueError("jwks fetch failed")
jwks = keys_resp.json()
# Validate signature + standard claims (exp/nbf) via claims.validate(),
# and check iss/aud/nonce manually (authlib's JWTClaims.validate() only
# handles exp/nbf; issuer/audience/nonce are checked explicitly).
try:
jwk_set = JsonWebKey.import_key_set(jwks)
jwt = JsonWebToken(["RS256", "EdDSA"])
claims = jwt.decode(id_token, jwk_set)
claims.validate() # validates exp + nbf
# Issuer + audience + nonce (replay protection).
if claims.get("iss") != issuer:
logger.warning("OIDC id_token issuer mismatch: %s", claims.get("iss"))
raise ValueError("issuer mismatch")
if claims.get("aud") != client_id:
logger.warning("OIDC id_token audience mismatch: %s", claims.get("aud"))
raise ValueError("audience mismatch")
if claims.get("nonce") != nonce:
logger.warning("OIDC id_token nonce mismatch")
raise ValueError("nonce mismatch")
except Exception as e:
logger.warning("OIDC id_token validation failed: %s", e)
raise ValueError("id_token validation failed") from e
username = claims.get("sub")
if not username:
logger.warning("OIDC id_token missing sub claim")
raise ValueError("missing sub claim")
return str(username)
def write_session(identity: str) -> str:
"""Create a signed session token for the given identity (username)."""
return _session_serializer().dumps({"identity": identity})
def read_session(token: str) -> str | None:
"""Return the identity from a signed session token, or None if invalid."""
if not token:
return None
try:
data = _session_serializer().loads(token, max_age=SESSION_MAX_AGE)
return data.get("identity") if isinstance(data, dict) else None
except (BadSignature, SignatureExpired):
return None