forked from code/member-dashboard
- 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.
211 lines
8.3 KiB
Python
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
|