Open-source personal finance manager. Self-hosted, privacy-first.
feat: add OIDC login support (#275)
Romulo Gatto22bada4f0769
diff --git a/.env.example b/.env.exampleindex 625a3b4b..1381d47d 100644--- a/.env.example+++ b/.env.example@@ -19,6 +19,23 @@ ENABLE_BANKING_APP_ID=# Must match exactly one of the Allowed Redirect URLs in your EB applicationENABLE_BANKING_OAUTH_REDIRECT_URI=http://localhost:${FRONTEND_PORT:-3000}/oauth/callback+# OIDC login (optional) — Authentik, Pocket ID, or any standard OIDC provider+## Redirect/callback URL to register in the provider:+## http://localhost:${FRONTEND_PORT:-3000}/api/auth/oidc/callback+# OIDC_ENABLED=true+# OIDC_PROVIDER_NAME=Pocket ID+# OIDC_DISCOVERY_URL=https://id.example.com/.well-known/openid-configuration+# OIDC_CLIENT_ID=securo+# OIDC_CLIENT_SECRET=your-client-secret+# OIDC_SCOPES=openid email profile+# OIDC_AUTO_REGISTER=true+# OIDC_REQUIRE_VERIFIED_EMAIL=true+# Optional: sync Securo admin/workspace roles from OIDC roles/groups+# OIDC_SYNC_ROLES=true+# OIDC_ROLES_CLAIM=groups+# OIDC_ADMIN_ROLES=securo-admins+# OIDC_WORKSPACE_ROLE_MAP={"securo-owners":"owner","securo-editors":"editor","securo-viewers":"viewer"}+# Host ports (optional) — change these to avoid conflicts with other services## Default values are set in docker-compose.yml and docker-compose.prod.yml.## Example:diff --git a/README.md b/README.mdindex 2716ebae..5f080730 100644--- a/README.md+++ b/README.md@@ -53,6 +53,7 @@ Open [http://localhost:3000](http://localhost:3000) and create an account. That'- Multi-currency support with automatic FX conversion- Multi-user support with admin panel and registration controls- Two-factor authentication (TOTP) with brute-force protection+- OIDC login support for Authentik, Pocket ID, and other standard providers- AI Agents (optional): self-hosted LLM chat with tool-use over your data, plus a per-agent RAG knowledge base## Bank Sync (Optional)@@ -93,6 +94,41 @@ SIMPLEFIN_API_URL=https://beta-bridge.simplefin.org # sandbox; use bridge.simpThen in Securo: **Accounts → Connect Bank → SimpleFIN**, and paste the token. The [developer page](https://beta-bridge.simplefin.org/info/developers) gives out free demo tokens if you want to try it without a real bank.+## OIDC Login (Optional)++Securo can delegate login to any standard OIDC provider, including Authentik and Pocket ID. Create a confidential/web application in your provider and register this redirect URI:++```+https://your-securo-host/api/auth/oidc/callback+```++Then add the provider settings to `.env` and restart:++```+OIDC_ENABLED=true+OIDC_PROVIDER_NAME=Pocket ID+OIDC_DISCOVERY_URL=https://id.example.com/.well-known/openid-configuration+OIDC_CLIENT_ID=securo+OIDC_CLIENT_SECRET=your-client-secret+# Optional; defaults to ${FRONTEND_URL}/api/auth/oidc/callback+OIDC_REDIRECT_URI=https://your-securo-host/api/auth/oidc/callback+```++New OIDC users are auto-provisioned by default (`OIDC_AUTO_REGISTER=true`) using verified email addresses. Set `OIDC_AUTO_REGISTER=false` to allow only existing Securo users whose email matches the provider claim.++### Optional OIDC role sync++Securo can also synchronize provider roles/groups into its built-in permissions when `OIDC_SYNC_ROLES=true`. The default claim is `groups`, which works well with Authentik group mappings and Pocket ID role/group assignments.++```+OIDC_SYNC_ROLES=true+OIDC_ROLES_CLAIM=groups+OIDC_ADMIN_ROLES=securo-admins+OIDC_WORKSPACE_ROLE_MAP={"securo-owners":"owner","securo-editors":"editor","securo-viewers":"viewer"}+```++`OIDC_ADMIN_ROLES` grants or revokes Securo admin (`is_superuser`) on each OIDC login. `OIDC_WORKSPACE_ROLE_MAP` maps provider roles/groups to the user's Personal workspace role (`owner`, `editor`, or `viewer`); if multiple mapped roles are present, Securo applies the highest permission. Leave `OIDC_SYNC_ROLES=false` to keep all Securo roles managed locally.+## Exchange Rates (Optional)For automatic currency conversion, add a free [Open Exchange Rates](https://openexchangerates.org/) key to `.env`:diff --git a/backend/.env.example b/backend/.env.exampleindex 22ce6d37..9443aa6b 100644--- a/backend/.env.example+++ b/backend/.env.example@@ -6,3 +6,19 @@ PLUGGY_CLIENT_SECRET=PLUGGY_OAUTH_REDIRECT_URI=http://localhost:5173/oauth/callbackFRONTEND_URL=http://localhost:5173REDIS_URL=redis://localhost:6379/0++# Optional OIDC login (Authentik, Pocket ID, or standard OIDC providers)+OIDC_ENABLED=false+OIDC_PROVIDER_NAME=OIDC+OIDC_DISCOVERY_URL=+OIDC_CLIENT_ID=+OIDC_CLIENT_SECRET=+# Defaults to ${FRONTEND_URL}/api/auth/oidc/callback+OIDC_REDIRECT_URI=+OIDC_SCOPES=openid email profile+OIDC_AUTO_REGISTER=true+OIDC_REQUIRE_VERIFIED_EMAIL=true+OIDC_SYNC_ROLES=false+OIDC_ROLES_CLAIM=groups+OIDC_ADMIN_ROLES=+OIDC_WORKSPACE_ROLE_MAP=diff --git a/backend/alembic/versions/055_oidc_identity_linking.py b/backend/alembic/versions/055_oidc_identity_linking.pynew file mode 100644index 00000000..dbc5c929--- /dev/null+++ b/backend/alembic/versions/055_oidc_identity_linking.py@@ -0,0 +1,31 @@+"""add oidc identity linking to users++Revision ID: 055+Revises: 054+Create Date: 2026-06-05+"""++from alembic import op+import sqlalchemy as sa+++revision = "055"+down_revision = "054"+branch_labels = None+depends_on = None+++def upgrade() -> None:+ op.add_column("users", sa.Column("oidc_issuer", sa.String(length=255), nullable=True))+ op.add_column("users", sa.Column("oidc_subject", sa.String(length=255), nullable=True))+ op.create_index("ix_users_oidc_issuer", "users", ["oidc_issuer"])+ op.create_index("ix_users_oidc_subject", "users", ["oidc_subject"])+ op.create_unique_constraint("uq_users_oidc_identity", "users", ["oidc_issuer", "oidc_subject"])+++def downgrade() -> None:+ op.drop_constraint("uq_users_oidc_identity", "users", type_="unique")+ op.drop_index("ix_users_oidc_subject", table_name="users")+ op.drop_index("ix_users_oidc_issuer", table_name="users")+ op.drop_column("users", "oidc_subject")+ op.drop_column("users", "oidc_issuer")diff --git a/backend/app/api/oidc_auth.py b/backend/app/api/oidc_auth.pynew file mode 100644index 00000000..7997fe93--- /dev/null+++ b/backend/app/api/oidc_auth.py@@ -0,0 +1,386 @@+import base64+import hashlib+import json+import secrets+from typing import Any+from urllib.parse import urlencode++import httpx+from fastapi import APIRouter, Depends, HTTPException, Query+from fastapi.responses import RedirectResponse+from fastapi_users import schemas+from fastapi_users.exceptions import UserAlreadyExists+from jose import JWTError, jwt+from pydantic import BaseModel, EmailStr+from sqlalchemy import func, select, update as sql_update+from sqlalchemy.ext.asyncio import AsyncSession++from app.core.auth import UserManager, get_jwt_strategy, get_user_manager+from app.core.config import get_settings+from app.core.database import get_async_session+from app.core.redis import get_redis+from app.models.account import Account+from app.models.user import User+from app.models.workspace import WORKSPACE_ROLES, Workspace, WorkspaceMember+from app.services import admin_service+from app.services.category_service import create_default_categories+from app.services.rule_service import create_default_rules+from app.services.workspace_service import create_personal_workspace_for_user++router = APIRouter(prefix="/api/auth/oidc", tags=["auth"])+OIDC_STATE_TTL = 600+++class OIDCConfigResponse(BaseModel):+ enabled: bool+ provider_name: str = "OIDC"+++async def _discover() -> dict[str, Any]:+ settings = get_settings()+ if not settings.oidc_enabled:+ raise HTTPException(status_code=404, detail="OIDC login is not enabled")+ if not settings.oidc_discovery_url:+ raise HTTPException(status_code=500, detail="OIDC_DISCOVERY_URL is required")+ async with httpx.AsyncClient(timeout=10) as client:+ response = await client.get(settings.oidc_discovery_url)+ response.raise_for_status()+ return response.json()+++def _redirect_uri() -> str:+ settings = get_settings()+ return settings.oidc_redirect_uri or f"{settings.frontend_url.rstrip('/')}/api/auth/oidc/callback"++[email protected]("/config", response_model=OIDCConfigResponse)+async def oidc_config():+ settings = get_settings()+ return OIDCConfigResponse(+ enabled=bool(settings.oidc_enabled and settings.oidc_client_id and settings.oidc_discovery_url),+ provider_name=settings.oidc_provider_name or "OIDC",+ )++[email protected]("/login")+async def oidc_login():+ settings = get_settings()+ if not settings.oidc_client_id:+ raise HTTPException(status_code=500, detail="OIDC_CLIENT_ID is required")+ discovery = await _discover()+ authorization_endpoint = discovery.get("authorization_endpoint")+ if not authorization_endpoint:+ raise HTTPException(status_code=500, detail="OIDC discovery is missing authorization_endpoint")++ state = secrets.token_urlsafe(32)+ nonce = secrets.token_urlsafe(32)+ code_verifier = secrets.token_urlsafe(64)+ code_challenge = base64.urlsafe_b64encode(+ hashlib.sha256(code_verifier.encode()).digest()+ ).rstrip(b"=").decode()+ r = await get_redis()+ await r.set(+ f"oidc_state:{state}",+ json.dumps({"nonce": nonce, "code_verifier": code_verifier}),+ ex=OIDC_STATE_TTL,+ )++ params = {+ "client_id": settings.oidc_client_id,+ "redirect_uri": _redirect_uri(),+ "response_type": "code",+ "scope": settings.oidc_scopes,+ "state": state,+ "nonce": nonce,+ "code_challenge": code_challenge,+ "code_challenge_method": "S256",+ }+ return RedirectResponse(f"{authorization_endpoint}?{urlencode(params)}")+++async def _exchange_code(discovery: dict[str, Any], code: str, code_verifier: str) -> dict[str, Any]:+ settings = get_settings()+ token_endpoint = discovery.get("token_endpoint")+ if not token_endpoint:+ raise HTTPException(status_code=500, detail="OIDC discovery is missing token_endpoint")+ data = {+ "grant_type": "authorization_code",+ "client_id": settings.oidc_client_id,+ "client_secret": settings.oidc_client_secret,+ "code": code,+ "redirect_uri": _redirect_uri(),+ "code_verifier": code_verifier,+ }+ async with httpx.AsyncClient(timeout=10) as client:+ response = await client.post(token_endpoint, data=data)+ response.raise_for_status()+ return response.json()+++async def _fetch_userinfo(discovery: dict[str, Any], access_token: str) -> dict[str, Any]:+ userinfo_endpoint = discovery.get("userinfo_endpoint")+ if not userinfo_endpoint:+ return {}+ async with httpx.AsyncClient(timeout=10) as client:+ response = await client.get(userinfo_endpoint, headers={"Authorization": f"Bearer {access_token}"})+ response.raise_for_status()+ return response.json()+++async def _decode_id_token(discovery: dict[str, Any], id_token: str, nonce: str) -> dict[str, Any]:+ settings = get_settings()+ jwks_uri = discovery.get("jwks_uri")+ issuer = discovery.get("issuer")+ if not jwks_uri or not issuer:+ raise HTTPException(status_code=500, detail="OIDC discovery is missing jwks_uri or issuer")+ async with httpx.AsyncClient(timeout=10) as client:+ response = await client.get(jwks_uri)+ response.raise_for_status()+ jwks = response.json()+ headers = jwt.get_unverified_header(id_token)+ key = next((k for k in jwks.get("keys", []) if k.get("kid") == headers.get("kid")), None)+ if key is None:+ raise HTTPException(status_code=400, detail="OIDC signing key not found")+ try:+ claims = jwt.decode(+ id_token,+ key,+ algorithms=[key.get("alg", "RS256")],+ audience=settings.oidc_client_id,+ issuer=issuer,+ )+ except JWTError as exc:+ raise HTTPException(status_code=400, detail="Invalid OIDC id_token") from exc+ if claims.get("nonce") != nonce:+ raise HTTPException(status_code=400, detail="Invalid OIDC nonce")+ return claims+++def _claim_values(payload: dict[str, Any], claim_name: str) -> set[str]:+ value: Any = payload+ for part in claim_name.split("."):+ if isinstance(value, dict):+ value = value.get(part)+ else:+ return set()+ if value is None:+ return set()+ if isinstance(value, str):+ return {value}+ if isinstance(value, (list, tuple, set)):+ return {str(item) for item in value}+ return {str(value)}+++def _parse_workspace_role_map(raw: str) -> dict[str, str]:+ if not raw:+ return {}+ try:+ parsed = json.loads(raw)+ except json.JSONDecodeError as exc:+ raise HTTPException(status_code=500, detail="OIDC_WORKSPACE_ROLE_MAP must be valid JSON") from exc+ if not isinstance(parsed, dict):+ raise HTTPException(status_code=500, detail="OIDC_WORKSPACE_ROLE_MAP must be a JSON object")+ role_map = {str(k): str(v).lower() for k, v in parsed.items()}+ invalid = sorted({role for role in role_map.values() if role not in WORKSPACE_ROLES})+ if invalid:+ raise HTTPException(+ status_code=500,+ detail=f"OIDC_WORKSPACE_ROLE_MAP contains invalid Securo roles: {', '.join(invalid)}",+ )+ return role_map+++def _desired_workspace_role(provider_roles: set[str], role_map: dict[str, str]) -> str | None:+ role_rank = {"viewer": 1, "editor": 2, "owner": 3}+ matches = [role_map[role] for role in provider_roles if role in role_map]+ if not matches:+ return None+ return max(matches, key=lambda role: role_rank[role])+++OIDC_EXISTING_USER_LINK_MODES = {"disabled", "verified_email", "email"}+++async def _sync_oidc_roles(user: User, merged_claims: dict[str, Any], session: AsyncSession) -> None:+ settings = get_settings()+ if not settings.oidc_sync_roles:+ return+ provider_roles = _claim_values(merged_claims, settings.oidc_roles_claim)+ admin_roles = {role.strip() for role in settings.oidc_admin_roles.split(",") if role.strip()}+ if admin_roles:+ user.is_superuser = bool(provider_roles & admin_roles)+ session.add(user)++ role_map = _parse_workspace_role_map(settings.oidc_workspace_role_map)+ desired_role = _desired_workspace_role(provider_roles, role_map)+ if desired_role is None:+ return++ workspace_result = await session.execute(+ select(Workspace)+ .join(WorkspaceMember, WorkspaceMember.workspace_id == Workspace.id)+ .where(+ WorkspaceMember.user_id == user.id,+ Workspace.kind == "personal",+ Workspace.created_by_user_id == user.id,+ )+ .limit(1)+ )+ workspace = workspace_result.scalar_one_or_none()+ if workspace is None:+ return+ member_result = await session.execute(+ select(WorkspaceMember).where(+ WorkspaceMember.workspace_id == workspace.id,+ WorkspaceMember.user_id == user.id,+ )+ )+ member = member_result.scalar_one_or_none()+ if member is not None and member.role != desired_role:+ if workspace.kind == "personal" and member.role == "owner" and desired_role != "owner":+ return+ member.role = desired_role+ session.add(member)+++async def _get_or_create_oidc_user(+ claims: dict[str, Any],+ userinfo: dict[str, Any],+ issuer: str,+ session: AsyncSession,+ user_manager: UserManager,+) -> User:+ settings = get_settings()+ if userinfo.get("sub") is not None and userinfo.get("sub") != claims.get("sub"):+ raise HTTPException(status_code=400, detail="OIDC userinfo subject does not match id_token subject")+ # Userinfo is fetched with a bearer token, but the id_token is the signed,+ # audience-validated source of truth. Let signed claims win for overlapping+ # identity and authorization fields such as email, email_verified, and groups.+ merged = {**userinfo, **claims}+ subject = merged.get("sub")+ if not subject:+ raise HTTPException(status_code=400, detail="OIDC provider did not return a subject claim")+ subject = str(subject)+ if not issuer:+ raise HTTPException(status_code=500, detail="OIDC discovery is missing issuer")++ link_mode = settings.oidc_existing_user_link_mode+ if link_mode not in OIDC_EXISTING_USER_LINK_MODES:+ raise HTTPException(status_code=500, detail="OIDC_EXISTING_USER_LINK_MODE must be disabled, verified_email, or email")++ linked = await session.execute(select(User).where(User.oidc_issuer == issuer, User.oidc_subject == subject))+ user = linked.scalar_one_or_none()+ if user is not None:+ await _sync_oidc_roles(user, merged, session)+ await session.commit()+ await session.refresh(user)+ return user++ email = merged.get("email")+ if not email:+ raise HTTPException(status_code=400, detail="OIDC provider did not return an email claim")+ email = str(EmailStr._validate(email)).lower()+ email_verified = merged.get("email_verified")++ existing = await session.execute(select(User).where(func.lower(User.email) == email))+ user = existing.scalar_one_or_none()+ if user is not None:+ if user.oidc_issuer or user.oidc_subject:+ raise HTTPException(status_code=403, detail="OIDC identity is linked to a different account")+ if link_mode == "disabled":+ raise HTTPException(status_code=403, detail="Existing account is not linked to this OIDC identity")+ if link_mode == "verified_email" and email_verified not in (True, "true"):+ raise HTTPException(status_code=400, detail="OIDC email is not verified")+ user.oidc_issuer = issuer+ user.oidc_subject = subject+ session.add(user)+ await _sync_oidc_roles(user, merged, session)+ await session.commit()+ await session.refresh(user)+ return user+ if settings.oidc_require_verified_email and email_verified not in (True, "true"):+ raise HTTPException(status_code=400, detail="OIDC email is not verified")+ if not await admin_service.is_registration_enabled(session):+ raise HTTPException(status_code=403, detail="Registration is disabled")+ if not settings.oidc_auto_register:+ raise HTTPException(status_code=403, detail="No local account is linked to this OIDC identity")++ display_name = merged.get("name") or merged.get("preferred_username") or email.split("@", 1)[0]+ preferences = {+ "language": "en",+ "date_format": "MM/DD/YYYY",+ "timezone": "UTC",+ "currency_display": settings.default_currency,+ "display_name": display_name,+ "auth_provider": settings.oidc_provider_name,+ }+ provider_roles = _claim_values(merged, settings.oidc_roles_claim)+ admin_roles = {role.strip() for role in settings.oidc_admin_roles.split(",") if role.strip()}+ user_create = schemas.BaseUserCreate(+ email=email,+ password=secrets.token_urlsafe(32),+ is_verified=True,+ is_superuser=bool(settings.oidc_sync_roles and admin_roles and provider_roles & admin_roles),+ )+ try:+ user = await user_manager.create(user_create, safe=True, request=None)+ except UserAlreadyExists:+ user = (await session.execute(select(User).where(func.lower(User.email) == email))).scalar_one()++ db_session = user_manager.user_db.session+ await db_session.execute(+ sql_update(User)+ .where(User.id == user.id)+ .values(preferences=preferences, oidc_issuer=issuer, oidc_subject=str(merged.get("sub")))+ )+ await db_session.refresh(user)+ workspace = await create_personal_workspace_for_user(db_session, user)+ wallet = Account(+ user_id=user.id,+ workspace_id=workspace.id,+ name="Wallet",+ type="checking",+ balance=0,+ currency=settings.default_currency,+ )+ db_session.add(wallet)+ await db_session.commit()+ await create_default_categories(db_session, user.id, "en", workspace_id=workspace.id)+ await create_default_rules(db_session, user.id, "en", workspace_id=workspace.id)+ await _sync_oidc_roles(user, merged, db_session)+ await db_session.commit()+ await db_session.refresh(user)+ return user++[email protected]("/callback")+async def oidc_callback(+ code: str = Query(...),+ state: str = Query(...),+ session: AsyncSession = Depends(get_async_session),+ user_manager: UserManager = Depends(get_user_manager),+):+ r = await get_redis()+ state_key = f"oidc_state:{state}"+ raw_state = await r.get(state_key)+ if raw_state is None:+ raise HTTPException(status_code=400, detail="Invalid or expired OIDC state")+ await r.delete(state_key)+ if isinstance(raw_state, bytes):+ raw_state = raw_state.decode()+ state_data = json.loads(raw_state)++ discovery = await _discover()+ token_response = await _exchange_code(discovery, code, state_data.get("code_verifier", ""))+ id_token = token_response.get("id_token")+ if not id_token:+ raise HTTPException(status_code=400, detail="OIDC provider did not return an id_token")+ claims = await _decode_id_token(discovery, id_token, state_data["nonce"])+ userinfo = await _fetch_userinfo(discovery, token_response.get("access_token", ""))+ user = await _get_or_create_oidc_user(claims, userinfo, discovery.get("issuer", ""), session, user_manager)+ if not user.is_active:+ raise HTTPException(status_code=403, detail="User is inactive")+ token = await get_jwt_strategy().write_token(user)+ frontend_url = get_settings().frontend_url.rstrip("/")+ return RedirectResponse(f"{frontend_url}/auth/oidc/callback#access_token={token}&token_type=bearer")diff --git a/backend/app/core/config.py b/backend/app/core/config.pyindex baa82654..cc8f63db 100644--- a/backend/app/core/config.py+++ b/backend/app/core/config.py@@ -61,6 +61,22 @@ class Settings(BaseSettings):# Registrationregistration_enabled: bool = True+ # OIDC login (works with Authentik, Pocket ID, and other standard OIDC providers)+ oidc_enabled: bool = False+ oidc_provider_name: str = "OIDC"+ oidc_discovery_url: str = "" # e.g. https://auth.example.com/application/o/securo/.well-known/openid-configuration+ oidc_client_id: str = ""+ oidc_client_secret: str = ""+ oidc_redirect_uri: str = "" # defaults to {FRONTEND_URL}/api/auth/oidc/callback+ oidc_scopes: str = "openid email profile"+ oidc_auto_register: bool = True+ oidc_existing_user_link_mode: str = "disabled" # disabled|verified_email|email+ oidc_require_verified_email: bool = True+ oidc_sync_roles: bool = False+ oidc_roles_claim: str = "groups"+ oidc_admin_roles: str = "" # comma-separated provider roles/groups that grant Securo admin+ oidc_workspace_role_map: str = "" # JSON: {"provider-role": "owner|editor|viewer"}+# Celeryredis_url: str = "redis://localhost:6379/0"diff --git a/backend/app/main.py b/backend/app/main.pyindex 286d1fce..468ec226 100644--- a/backend/app/main.py+++ b/backend/app/main.py@@ -15,6 +15,7 @@ from app.api.connections import router as connections_routerfrom app.api.custom_auth import router as custom_auth_routerfrom app.api.dashboard import router as dashboard_routerfrom app.api.import_logs import router as import_logs_router+from app.api.oidc_auth import router as oidc_auth_routerfrom app.api.import_transactions import router as import_routerfrom app.api.info import router as info_routerfrom app.api.recurring_transactions import router as recurring_router@@ -88,6 +89,7 @@ app.include_router(prefix="/api/auth",tags=["auth"],)+app.include_router(oidc_auth_router)app.include_router(fastapi_users.get_register_router(UserRead, UserCreate),prefix="/api/auth",diff --git a/backend/app/models/user.py b/backend/app/models/user.pyindex 50555685..c91fd65c 100644--- a/backend/app/models/user.py+++ b/backend/app/models/user.py@@ -1,7 +1,7 @@from typing import TYPE_CHECKING, Optionalfrom fastapi_users.db import SQLAlchemyBaseUserTableUUID-from sqlalchemy import JSON, Boolean, String+from sqlalchemy import JSON, Boolean, String, UniqueConstraintfrom sqlalchemy.orm import Mapped, mapped_column, relationshipfrom app.core.database import Base@@ -14,6 +14,9 @@ if TYPE_CHECKING:class User(SQLAlchemyBaseUserTableUUID, Base):__tablename__ = "users"+ __table_args__ = (+ UniqueConstraint("oidc_issuer", "oidc_subject", name="uq_users_oidc_identity"),+ )preferences: Mapped[Optional[dict]] = mapped_column(JSON,@@ -27,6 +30,8 @@ class User(SQLAlchemyBaseUserTableUUID, Base):totp_secret: Mapped[Optional[str]] = mapped_column(String(32), nullable=True, default=None)is_2fa_enabled: Mapped[bool] = mapped_column(Boolean, default=False, server_default="0")+ oidc_issuer: Mapped[Optional[str]] = mapped_column(String(255), nullable=True, index=True)+ oidc_subject: Mapped[Optional[str]] = mapped_column(String(255), nullable=True, index=True)categories: Mapped[list["Category"]] = relationship(back_populates="user", cascade="all, delete-orphan")category_groups: Mapped[list["CategoryGroup"]] = relationship(back_populates="user", cascade="all, delete-orphan")diff --git a/backend/tests/test_oidc_auth.py b/backend/tests/test_oidc_auth.pynew file mode 100644index 00000000..e9ccd248--- /dev/null+++ b/backend/tests/test_oidc_auth.py@@ -0,0 +1,659 @@+import base64+import hashlib+import json+from urllib.parse import parse_qs, urlparse++import pytest+from httpx import AsyncClient+from sqlalchemy import select++from app.api import oidc_auth+from app.core.config import get_settings+from app.models.app_settings import AppSetting+from app.models.workspace import WorkspaceMember+++class FakeRedis:+ def __init__(self):+ self.store = {}++ async def set(self, key, value, ex=None):+ self.store[key] = value++ async def get(self, key):+ return self.store.get(key)++ async def delete(self, key):+ self.store.pop(key, None)+++def oidc_settings(monkeypatch):+ settings = get_settings()+ old = settings.model_dump()+ settings.oidc_enabled = True+ settings.oidc_provider_name = "Pocket ID"+ settings.oidc_discovery_url = "https://id.example.com/.well-known/openid-configuration"+ settings.oidc_client_id = "securo"+ settings.oidc_client_secret = "secret"+ settings.frontend_url = "http://test"+ settings.oidc_sync_roles = False+ settings.oidc_roles_claim = "groups"+ settings.oidc_admin_roles = ""+ settings.oidc_workspace_role_map = ""+ yield settings+ for key, value in old.items():+ setattr(settings, key, value)+++async def test_oidc_config_disabled_by_default(client: AsyncClient, clean_db):+ response = await client.get("/api/auth/oidc/config")+ assert response.status_code == 200+ assert response.json()["enabled"] is False+++async def test_oidc_login_redirects_to_provider(client: AsyncClient, clean_db, oidc_settings, monkeypatch):+ fake_redis = FakeRedis()++ async def fake_discover():+ return {"authorization_endpoint": "https://id.example.com/authorize"}++ async def fake_get_redis():+ return fake_redis++ monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)+ monkeypatch.setattr(oidc_auth, "_discover", fake_discover)++ response = await client.get("/api/auth/oidc/login", follow_redirects=False)+ assert response.status_code == 307+ location = response.headers["location"]+ parsed = urlparse(location)+ params = parse_qs(parsed.query)+ assert parsed.scheme == "https"+ assert parsed.netloc == "id.example.com"+ assert parsed.path == "/authorize"+ assert params["client_id"] == ["securo"]+ assert params["scope"] == ["openid email profile"]+ assert params["redirect_uri"] == ["http://test/api/auth/oidc/callback"]+ assert params["code_challenge_method"] == ["S256"]+ assert params["code_challenge"][0]+ stored = json.loads(fake_redis.store[f"oidc_state:{params['state'][0]}"])+ expected_challenge = (+ base64.urlsafe_b64encode(hashlib.sha256(stored["code_verifier"].encode()).digest())+ .rstrip(b"=")+ .decode()+ )+ assert params["code_challenge"][0] == expected_challenge+++async def test_oidc_callback_creates_user_and_redirects_with_securo_token(+ client: AsyncClient, clean_db, oidc_settings, monkeypatch+):+ fake_redis = FakeRedis()+ await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))++ async def fake_discover():+ return {"issuer": "https://id.example.com"}++ async def fake_exchange(discovery, code, code_verifier=""):+ assert code == "abc"+ return {"id_token": "id-token", "access_token": "provider-token"}++ async def fake_decode(discovery, id_token, nonce):+ assert id_token == "id-token"+ assert nonce == "nonce123"+ return {"sub": "user-sub", "email": "[email protected]", "email_verified": True, "name": "OIDC User"}++ async def fake_userinfo(discovery, access_token):+ assert access_token == "provider-token"+ return {}++ async def fake_get_redis():+ return fake_redis++ monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)+ monkeypatch.setattr(oidc_auth, "_discover", fake_discover)+ monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)+ monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)+ monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)++ response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)+ assert response.status_code == 307+ location = response.headers["location"]+ assert location.startswith("http://test/auth/oidc/callback#access_token=")++ token = parse_qs(urlparse(location).fragment)["access_token"][0]+ me = await client.get("/api/users/me", headers={"Authorization": f"Bearer {token}"})+ assert me.status_code == 200+ assert me.json()["email"] == "[email protected]"+++async def test_oidc_callback_syncs_existing_user_admin_and_workspace_role(+ client: AsyncClient, session, test_user, oidc_settings, monkeypatch+):+ oidc_settings.oidc_sync_roles = True+ oidc_settings.oidc_admin_roles = "securo-admins"+ test_user.oidc_issuer = "https://id.example.com"+ test_user.oidc_subject = "user-sub"+ session.add(test_user)+ await session.commit()+ oidc_settings.oidc_workspace_role_map = json.dumps(+ {+ "securo-viewers": "viewer",+ "securo-editors": "editor",+ "securo-owners": "owner",+ }+ )+ fake_redis = FakeRedis()+ await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))++ async def fake_discover():+ return {"issuer": "https://id.example.com"}++ async def fake_exchange(discovery, code, code_verifier=""):+ return {"id_token": "id-token", "access_token": "provider-token"}++ async def fake_decode(discovery, id_token, nonce):+ return {+ "sub": "user-sub",+ "email": "[email protected]",+ "email_verified": True,+ "groups": ["securo-admins", "securo-editors"],+ }++ async def fake_userinfo(discovery, access_token):+ return {}++ async def fake_get_redis():+ return fake_redis++ monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)+ monkeypatch.setattr(oidc_auth, "_discover", fake_discover)+ monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)+ monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)+ monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)++ response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)+ assert response.status_code == 307+ token = parse_qs(urlparse(response.headers["location"]).fragment)["access_token"][0]++ me = await client.get("/api/users/me", headers={"Authorization": f"Bearer {token}"})+ assert me.status_code == 200+ assert me.json()["is_superuser"] is True++ workspace = await client.get("/api/workspaces/current", headers={"Authorization": f"Bearer {token}"})+ assert workspace.status_code == 200+ assert workspace.json()["role"] == "owner"++ member = (+ await session.execute(select(WorkspaceMember).where(WorkspaceMember.user_id == test_user.id))+ ).scalars().first()+ assert member.role == "owner"+++async def test_oidc_callback_sync_roles_can_revoke_admin(+ client: AsyncClient, session, test_superuser, oidc_settings, monkeypatch+):+ oidc_settings.oidc_sync_roles = True+ oidc_settings.oidc_admin_roles = "securo-admins"+ test_superuser.oidc_issuer = "https://id.example.com"+ test_superuser.oidc_subject = "user-sub"+ session.add(test_superuser)+ await session.commit()+ fake_redis = FakeRedis()+ await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))++ async def fake_discover():+ return {"issuer": "https://id.example.com"}++ async def fake_exchange(discovery, code, code_verifier=""):+ return {"id_token": "id-token", "access_token": "provider-token"}++ async def fake_decode(discovery, id_token, nonce):+ return {+ "sub": "user-sub",+ "email": "[email protected]",+ "email_verified": True,+ "groups": ["securo-users"],+ }++ async def fake_userinfo(discovery, access_token):+ return {}++ async def fake_get_redis():+ return fake_redis++ monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)+ monkeypatch.setattr(oidc_auth, "_discover", fake_discover)+ monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)+ monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)+ monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)++ response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)+ assert response.status_code == 307+ token = parse_qs(urlparse(response.headers["location"]).fragment)["access_token"][0]++ me = await client.get("/api/users/me", headers={"Authorization": f"Bearer {token}"})+ assert me.status_code == 200+ assert me.json()["is_superuser"] is False+++async def test_oidc_callback_signed_claims_override_userinfo_roles(+ client: AsyncClient, clean_db, oidc_settings, monkeypatch+):+ oidc_settings.oidc_sync_roles = True+ oidc_settings.oidc_admin_roles = "securo-admins"+ fake_redis = FakeRedis()+ await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))++ async def fake_discover():+ return {"issuer": "https://id.example.com"}++ async def fake_exchange(discovery, code, code_verifier=""):+ return {"id_token": "id-token", "access_token": "provider-token"}++ async def fake_decode(discovery, id_token, nonce):+ return {+ "sub": "signed-sub",+ "email": "[email protected]",+ "email_verified": True,+ "groups": ["securo-users"],+ }++ async def fake_userinfo(discovery, access_token):+ return {+ "sub": "signed-sub",+ "email": "[email protected]",+ "email_verified": True,+ "groups": ["securo-admins"],+ }++ async def fake_get_redis():+ return fake_redis++ monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)+ monkeypatch.setattr(oidc_auth, "_discover", fake_discover)+ monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)+ monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)+ monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)++ response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)+ assert response.status_code == 307+ token = parse_qs(urlparse(response.headers["location"]).fragment)["access_token"][0]++ me = await client.get("/api/users/me", headers={"Authorization": f"Bearer {token}"})+ assert me.status_code == 200+ assert me.json()["email"] == "[email protected]"+ assert me.json()["is_superuser"] is False+++async def test_oidc_callback_rejects_userinfo_subject_mismatch(+ client: AsyncClient, clean_db, oidc_settings, monkeypatch+):+ fake_redis = FakeRedis()+ await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))++ async def fake_discover():+ return {"issuer": "https://id.example.com"}++ async def fake_exchange(discovery, code, code_verifier=""):+ return {"id_token": "id-token", "access_token": "provider-token"}++ async def fake_decode(discovery, id_token, nonce):+ return {"sub": "signed-sub", "email": "[email protected]", "email_verified": True}++ async def fake_userinfo(discovery, access_token):+ return {"sub": "different-sub", "email": "[email protected]", "email_verified": True}++ async def fake_get_redis():+ return fake_redis++ monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)+ monkeypatch.setattr(oidc_auth, "_discover", fake_discover)+ monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)+ monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)+ monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)++ response = await client.get("/api/auth/oidc/callback?code=abc&state=state123")+ assert response.status_code == 400+ assert response.json()["detail"] == "OIDC userinfo subject does not match id_token subject"+++async def test_oidc_callback_requires_verified_email_claim_when_enabled(+ client: AsyncClient, clean_db, oidc_settings, monkeypatch+):+ fake_redis = FakeRedis()+ await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))++ async def fake_discover():+ return {"issuer": "https://id.example.com"}++ async def fake_exchange(discovery, code, code_verifier=""):+ return {"id_token": "id-token", "access_token": "provider-token"}++ async def fake_decode(discovery, id_token, nonce):+ return {"sub": "signed-sub", "email": "[email protected]"}++ async def fake_userinfo(discovery, access_token):+ return {}++ async def fake_get_redis():+ return fake_redis++ monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)+ monkeypatch.setattr(oidc_auth, "_discover", fake_discover)+ monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)+ monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)+ monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)++ response = await client.get("/api/auth/oidc/callback?code=abc&state=state123")+ assert response.status_code == 400+ assert response.json()["detail"] == "OIDC email is not verified"+++async def test_oidc_callback_rejects_unlinked_existing_user_by_default(+ client: AsyncClient, test_user, oidc_settings, monkeypatch+):+ fake_redis = FakeRedis()+ await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))++ async def fake_discover():+ return {"issuer": "https://id.example.com"}++ async def fake_exchange(discovery, code, code_verifier=""):+ return {"id_token": "id-token", "access_token": "provider-token"}++ async def fake_decode(discovery, id_token, nonce):+ return {"sub": "new-sub", "email": "[email protected]", "email_verified": True}++ async def fake_userinfo(discovery, access_token):+ return {}++ async def fake_get_redis():+ return fake_redis++ monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)+ monkeypatch.setattr(oidc_auth, "_discover", fake_discover)+ monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)+ monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)+ monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)++ response = await client.get("/api/auth/oidc/callback?code=abc&state=state123")++ assert response.status_code == 403+ assert response.json()["detail"] == "Existing account is not linked to this OIDC identity"+++async def test_oidc_callback_verified_email_link_mode_links_existing_user(+ client: AsyncClient, session, test_user, oidc_settings, monkeypatch+):+ oidc_settings.oidc_existing_user_link_mode = "verified_email"+ fake_redis = FakeRedis()+ await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))++ async def fake_discover():+ return {"issuer": "https://id.example.com"}++ async def fake_exchange(discovery, code, code_verifier=""):+ return {"id_token": "id-token", "access_token": "provider-token"}++ async def fake_decode(discovery, id_token, nonce):+ return {"sub": "linked-sub", "email": "[email protected]", "email_verified": True}++ async def fake_userinfo(discovery, access_token):+ return {}++ async def fake_get_redis():+ return fake_redis++ monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)+ monkeypatch.setattr(oidc_auth, "_discover", fake_discover)+ monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)+ monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)+ monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)++ response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)++ assert response.status_code == 307+ await session.refresh(test_user)+ assert test_user.oidc_issuer == "https://id.example.com"+ assert test_user.oidc_subject == "linked-sub"+++async def test_oidc_callback_rejects_existing_user_with_different_linked_subject(+ client: AsyncClient, session, test_user, oidc_settings, monkeypatch+):+ oidc_settings.oidc_existing_user_link_mode = "verified_email"+ test_user.oidc_issuer = "https://id.example.com"+ test_user.oidc_subject = "original-sub"+ session.add(test_user)+ await session.commit()+ fake_redis = FakeRedis()+ await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))++ async def fake_discover():+ return {"issuer": "https://id.example.com"}++ async def fake_exchange(discovery, code, code_verifier=""):+ return {"id_token": "id-token", "access_token": "provider-token"}++ async def fake_decode(discovery, id_token, nonce):+ return {"sub": "different-sub", "email": "[email protected]", "email_verified": True}++ async def fake_userinfo(discovery, access_token):+ return {}++ async def fake_get_redis():+ return fake_redis++ monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)+ monkeypatch.setattr(oidc_auth, "_discover", fake_discover)+ monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)+ monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)+ monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)++ response = await client.get("/api/auth/oidc/callback?code=abc&state=state123")++ assert response.status_code == 403+ assert response.json()["detail"] == "OIDC identity is linked to a different account"+++async def test_oidc_callback_respects_disabled_registration_setting(+ client: AsyncClient, session, clean_db, oidc_settings, monkeypatch+):+ oidc_settings.registration_enabled = True+ oidc_settings.oidc_auto_register = True+ session.add(AppSetting(key="registration_enabled", value="false"))+ await session.commit()+ fake_redis = FakeRedis()+ await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))++ async def fake_discover():+ return {"issuer": "https://id.example.com"}++ async def fake_exchange(discovery, code, code_verifier=""):+ return {"id_token": "id-token", "access_token": "provider-token"}++ async def fake_decode(discovery, id_token, nonce):+ return {"sub": "new-sub", "email": "[email protected]", "email_verified": True}++ async def fake_userinfo(discovery, access_token):+ return {}++ async def fake_get_redis():+ return fake_redis++ monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)+ monkeypatch.setattr(oidc_auth, "_discover", fake_discover)+ monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)+ monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)+ monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)++ response = await client.get("/api/auth/oidc/callback?code=abc&state=state123")++ assert response.status_code == 403+ assert response.json()["detail"] == "Registration is disabled"+++async def test_oidc_callback_email_link_mode_links_existing_user_without_verified_email(+ client: AsyncClient, session, test_user, oidc_settings, monkeypatch+):+ oidc_settings.oidc_existing_user_link_mode = "email"+ fake_redis = FakeRedis()+ await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))++ async def fake_discover():+ return {"issuer": "https://id.example.com"}++ async def fake_exchange(discovery, code, code_verifier=""):+ return {"id_token": "id-token", "access_token": "provider-token"}++ async def fake_decode(discovery, id_token, nonce):+ return {"sub": "unverified-linked-sub", "email": "[email protected]"}++ async def fake_userinfo(discovery, access_token):+ return {}++ async def fake_get_redis():+ return fake_redis++ monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)+ monkeypatch.setattr(oidc_auth, "_discover", fake_discover)+ monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)+ monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)+ monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)++ response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)++ assert response.status_code == 307+ await session.refresh(test_user)+ assert test_user.oidc_issuer == "https://id.example.com"+ assert test_user.oidc_subject == "unverified-linked-sub"+++async def test_oidc_callback_linked_user_can_login_without_verified_email_when_required(+ client: AsyncClient, session, test_user, oidc_settings, monkeypatch+):+ oidc_settings.oidc_require_verified_email = True+ oidc_settings.oidc_existing_user_link_mode = "verified_email"+ test_user.oidc_issuer = "https://id.example.com"+ test_user.oidc_subject = "linked-sub"+ session.add(test_user)+ await session.commit()+ fake_redis = FakeRedis()+ await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))++ async def fake_discover():+ return {"issuer": "https://id.example.com"}++ async def fake_exchange(discovery, code, code_verifier=""):+ return {"id_token": "id-token", "access_token": "provider-token"}++ async def fake_decode(discovery, id_token, nonce):+ return {"sub": "linked-sub", "email": "[email protected]"}++ async def fake_userinfo(discovery, access_token):+ return {}++ async def fake_get_redis():+ return fake_redis++ monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)+ monkeypatch.setattr(oidc_auth, "_discover", fake_discover)+ monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)+ monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)+ monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)++ response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)++ assert response.status_code == 307+++async def test_oidc_callback_linked_user_can_login_without_email_claim(+ client: AsyncClient, session, test_user, oidc_settings, monkeypatch+):+ oidc_settings.oidc_require_verified_email = True+ test_user.oidc_issuer = "https://id.example.com"+ test_user.oidc_subject = "linked-sub"+ session.add(test_user)+ await session.commit()+ fake_redis = FakeRedis()+ await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))++ async def fake_discover():+ return {"issuer": "https://id.example.com"}++ async def fake_exchange(discovery, code, code_verifier=""):+ return {"id_token": "id-token", "access_token": "provider-token"}++ async def fake_decode(discovery, id_token, nonce):+ return {"sub": "linked-sub"}++ async def fake_userinfo(discovery, access_token):+ return {}++ async def fake_get_redis():+ return fake_redis++ monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)+ monkeypatch.setattr(oidc_auth, "_discover", fake_discover)+ monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)+ monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)+ monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)++ response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)++ assert response.status_code == 307+++async def test_oidc_callback_registration_disabled_does_not_block_existing_email_link(+ client: AsyncClient, session, test_user, oidc_settings, monkeypatch+):+ oidc_settings.oidc_existing_user_link_mode = "email"+ session.add(AppSetting(key="registration_enabled", value="false"))+ await session.commit()+ fake_redis = FakeRedis()+ await fake_redis.set("oidc_state:state123", json.dumps({"nonce": "nonce123"}))++ async def fake_discover():+ return {"issuer": "https://id.example.com"}++ async def fake_exchange(discovery, code, code_verifier=""):+ return {"id_token": "id-token", "access_token": "provider-token"}++ async def fake_decode(discovery, id_token, nonce):+ return {"sub": "linked-with-registration-disabled", "email": "[email protected]"}++ async def fake_userinfo(discovery, access_token):+ return {}++ async def fake_get_redis():+ return fake_redis++ monkeypatch.setattr(oidc_auth, "get_redis", fake_get_redis)+ monkeypatch.setattr(oidc_auth, "_discover", fake_discover)+ monkeypatch.setattr(oidc_auth, "_exchange_code", fake_exchange)+ monkeypatch.setattr(oidc_auth, "_decode_id_token", fake_decode)+ monkeypatch.setattr(oidc_auth, "_fetch_userinfo", fake_userinfo)++ response = await client.get("/api/auth/oidc/callback?code=abc&state=state123", follow_redirects=False)++ assert response.status_code == 307+ await session.refresh(test_user)+ assert test_user.oidc_subject == "linked-with-registration-disabled"diff --git a/docker-compose.prod.yml b/docker-compose.prod.ymlindex 1f053c8c..ec5f80ef 100644--- a/docker-compose.prod.yml+++ b/docker-compose.prod.yml@@ -21,6 +21,20 @@ x-backend-env: &backend-envENABLE_BANKING_OAUTH_REDIRECT_URI: ${ENABLE_BANKING_OAUTH_REDIRECT_URI:-http://localhost:3000/oauth/callback}SIMPLEFIN_ENABLED: ${SIMPLEFIN_ENABLED:-false}SIMPLEFIN_API_URL: ${SIMPLEFIN_API_URL:-https://beta-bridge.simplefin.org}+ OIDC_ENABLED: ${OIDC_ENABLED:-false}+ OIDC_PROVIDER_NAME: ${OIDC_PROVIDER_NAME:-OIDC}+ OIDC_DISCOVERY_URL: ${OIDC_DISCOVERY_URL:-}+ OIDC_CLIENT_ID: ${OIDC_CLIENT_ID:-}+ OIDC_CLIENT_SECRET: ${OIDC_CLIENT_SECRET:-}+ OIDC_REDIRECT_URI: ${OIDC_REDIRECT_URI:-}+ OIDC_SCOPES: ${OIDC_SCOPES:-openid email profile}+ OIDC_AUTO_REGISTER: ${OIDC_AUTO_REGISTER:-true}+ OIDC_EXISTING_USER_LINK_MODE: ${OIDC_EXISTING_USER_LINK_MODE:-disabled}+ OIDC_REQUIRE_VERIFIED_EMAIL: ${OIDC_REQUIRE_VERIFIED_EMAIL:-true}+ OIDC_SYNC_ROLES: ${OIDC_SYNC_ROLES:-false}+ OIDC_ROLES_CLAIM: ${OIDC_ROLES_CLAIM:-groups}+ OIDC_ADMIN_ROLES: ${OIDC_ADMIN_ROLES:-}+ OIDC_WORKSPACE_ROLE_MAP: ${OIDC_WORKSPACE_ROLE_MAP:-}OPENEXCHANGERATES_APP_ID: ${OPENEXCHANGERATES_APP_ID:-}FX_SYNC_MODE: ${FX_SYNC_MODE:-on_demand}REDIS_URL: redis://redis:6379/0diff --git a/docker-compose.yml b/docker-compose.ymlindex b4a4be57..fa69820a 100644--- a/docker-compose.yml+++ b/docker-compose.yml@@ -21,6 +21,20 @@ x-backend-env: &backend-envENABLE_BANKING_OAUTH_REDIRECT_URI: ${ENABLE_BANKING_OAUTH_REDIRECT_URI:-http://localhost:${FRONTEND_PORT:-3000}/oauth/callback}SIMPLEFIN_ENABLED: ${SIMPLEFIN_ENABLED:-false}SIMPLEFIN_API_URL: ${SIMPLEFIN_API_URL:-https://beta-bridge.simplefin.org}+ OIDC_ENABLED: ${OIDC_ENABLED:-false}+ OIDC_PROVIDER_NAME: ${OIDC_PROVIDER_NAME:-OIDC}+ OIDC_DISCOVERY_URL: ${OIDC_DISCOVERY_URL:-}+ OIDC_CLIENT_ID: ${OIDC_CLIENT_ID:-}+ OIDC_CLIENT_SECRET: ${OIDC_CLIENT_SECRET:-}+ OIDC_REDIRECT_URI: ${OIDC_REDIRECT_URI:-}+ OIDC_SCOPES: ${OIDC_SCOPES:-openid email profile}+ OIDC_AUTO_REGISTER: ${OIDC_AUTO_REGISTER:-true}+ OIDC_EXISTING_USER_LINK_MODE: ${OIDC_EXISTING_USER_LINK_MODE:-disabled}+ OIDC_REQUIRE_VERIFIED_EMAIL: ${OIDC_REQUIRE_VERIFIED_EMAIL:-true}+ OIDC_SYNC_ROLES: ${OIDC_SYNC_ROLES:-false}+ OIDC_ROLES_CLAIM: ${OIDC_ROLES_CLAIM:-groups}+ OIDC_ADMIN_ROLES: ${OIDC_ADMIN_ROLES:-}+ OIDC_WORKSPACE_ROLE_MAP: ${OIDC_WORKSPACE_ROLE_MAP:-}REDIS_URL: redis://redis:6379/0OPENEXCHANGERATES_APP_ID: ${OPENEXCHANGERATES_APP_ID:-}FX_SYNC_MODE: ${FX_SYNC_MODE:-on_demand}diff --git a/frontend/src/App.tsx b/frontend/src/App.tsxindex 931994a8..0904f16c 100644--- a/frontend/src/App.tsx+++ b/frontend/src/App.tsx@@ -36,6 +36,7 @@ const AgentDetailPage = lazy(() => import('@/pages/agent-detail'))const AgentConnectionsPage = lazy(() => import('@/pages/agent-connections'))const WorkspaceSettingsPage = lazy(() => import('@/pages/workspace-settings'))const OAuthCallbackPage = lazy(() => import('@/pages/oauth-callback'))+const OIDCCallbackPage = lazy(() => import('@/pages/oidc-callback'))const queryClient = new QueryClient({defaultOptions: {@@ -65,6 +66,7 @@ function App() {<Routes><Route path="/setup" element={<SetupPage />} /><Route path="/login" element={<LoginPage />} />+ <Route path="/auth/oidc/callback" element={<OIDCCallbackPage />} /><Route path="/register" element={<RegisterPage />} /><Routeelement={diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.tsindex f390e34c..9a9c6d18 100644--- a/frontend/src/lib/api.ts+++ b/frontend/src/lib/api.ts@@ -187,6 +187,10 @@ export const auth = {const { data } = await api.post('/auth/2fa/verify', { temp_token: tempToken, code })return data},+ oidcConfig: async (): Promise<{ enabled: boolean; provider_name: string }> => {+ const { data } = await api.get('/auth/oidc/config')+ return data+ },}// Categoriesdiff --git a/frontend/src/locales/en.json b/frontend/src/locales/en.jsonindex f91e5def..4144d40e 100644--- a/frontend/src/locales/en.json+++ b/frontend/src/locales/en.json@@ -187,7 +187,9 @@"disable2fa": "Disable 2FA","disable2faDescription": "Enter your password and a verification code to disable two-factor authentication.","twoFactorEnabled": "Two-factor authentication enabled",- "twoFactorDisabled": "Two-factor authentication disabled"+ "twoFactorDisabled": "Two-factor authentication disabled",+ "or": "or",+ "loginWithProvider": "Continue with {{provider}}"},"dashboard": {"title": "Dashboard",diff --git a/frontend/src/locales/es.json b/frontend/src/locales/es.jsonindex 62909293..ed1bdbc2 100644--- a/frontend/src/locales/es.json+++ b/frontend/src/locales/es.json@@ -187,7 +187,9 @@"disable2fa": "Desactivar 2FA","disable2faDescription": "Introduce tu contraseña y un código de verificación para desactivar la autenticación de dos factores.","twoFactorEnabled": "Autenticación de dos factores activada",- "twoFactorDisabled": "Autenticación de dos factores desactivada"+ "twoFactorDisabled": "Autenticación de dos factores desactivada",+ "or": "o",+ "loginWithProvider": "Continuar con {{provider}}"},"dashboard": {"title": "Inicio",diff --git a/frontend/src/locales/pl.json b/frontend/src/locales/pl.jsonindex f66bc574..0aef3116 100644--- a/frontend/src/locales/pl.json+++ b/frontend/src/locales/pl.json@@ -187,7 +187,9 @@"disable2fa": "Wyłącz 2FA","disable2faDescription": "Wprowadź hasło i kod weryfikacyjny, aby wyłączyć uwierzytelnianie dwuskładnikowe.","twoFactorEnabled": "Włączono uwierzytelnianie dwuskładnikowe",- "twoFactorDisabled": "Wyłączono uwierzytelnianie dwuskładnikowe"+ "twoFactorDisabled": "Wyłączono uwierzytelnianie dwuskładnikowe",+ "or": "lub",+ "loginWithProvider": "Kontynuuj z {{provider}}"},"dashboard": {"title": "Pulpit",diff --git a/frontend/src/locales/pt-BR.json b/frontend/src/locales/pt-BR.jsonindex bffcb055..e4f46378 100644--- a/frontend/src/locales/pt-BR.json+++ b/frontend/src/locales/pt-BR.json@@ -187,7 +187,9 @@"disable2fa": "Desativar 2FA","disable2faDescription": "Digite sua senha e um código de verificação para desativar a autenticação em dois fatores.","twoFactorEnabled": "Autenticação em dois fatores ativada",- "twoFactorDisabled": "Autenticação em dois fatores desativada"+ "twoFactorDisabled": "Autenticação de dois fatores desativada",+ "or": "ou",+ "loginWithProvider": "Continuar com {{provider}}"},"dashboard": {"title": "Painel",diff --git a/frontend/src/pages/login.tsx b/frontend/src/pages/login.tsxindex 1102962d..49e8507b 100644--- a/frontend/src/pages/login.tsx+++ b/frontend/src/pages/login.tsx@@ -2,7 +2,7 @@ import { useState, useEffect } from 'react'import { Link, useNavigate } from 'react-router-dom'import { useTranslation } from 'react-i18next'import { useAuth } from '@/contexts/auth-context'-import { setup, admin as adminApi } from '@/lib/api'+import { setup, auth as authApi, admin as adminApi } from '@/lib/api'import { Button } from '@/components/ui/button'import { Input } from '@/components/ui/input'import { Label } from '@/components/ui/label'@@ -22,6 +22,7 @@ export default function LoginPage() {const [error, setError] = useState('')const [isLoading, setIsLoading] = useState(false)const [registrationEnabled, setRegistrationEnabled] = useState(true)+ const [oidcConfig, setOidcConfig] = useState<{ enabled: boolean; provider_name: string }>({ enabled: false, provider_name: 'OIDC' })// 2FA stateconst [requires2fa, setRequires2fa] = useState(false)@@ -41,6 +42,7 @@ export default function LoginPage() {adminApi.registrationStatus().then(({ enabled }) => {setRegistrationEnabled(enabled)}).catch(() => {})+ authApi.oidcConfig().then(setOidcConfig).catch(() => {})adminApi.defaultColors().then(({ light, dark }) => {setThemeBasedOnSystem(light, dark, resolvedTheme)}).catch(() => {})@@ -70,6 +72,10 @@ export default function LoginPage() {}}+ const handleOIDCLogin = () => {+ window.location.href = '/api/auth/oidc/login'+ }+const handleVerify2fa = async (e: React.FormEvent) => {e.preventDefault()setError('')@@ -194,6 +200,18 @@ export default function LoginPage() {<Button type="submit" className="w-full" disabled={isLoading}>{isLoading ? t('common.loading') : t('auth.login')}</Button>+ {oidcConfig.enabled && (+ <>+ <div className="flex items-center gap-3 w-full">+ <div className="h-px flex-1 bg-border" />+ <span className="text-xs text-muted-foreground">{t('auth.or')}</span>+ <div className="h-px flex-1 bg-border" />+ </div>+ <Button type="button" variant="outline" className="w-full" onClick={handleOIDCLogin}>+ {t('auth.loginWithProvider', { provider: oidcConfig.provider_name })}+ </Button>+ </>+ )}{registrationEnabled && (<p className="text-sm text-muted-foreground">{t('auth.noAccount')}{' '}diff --git a/frontend/src/pages/oidc-callback.tsx b/frontend/src/pages/oidc-callback.tsxnew file mode 100644index 00000000..a0f79448--- /dev/null+++ b/frontend/src/pages/oidc-callback.tsx@@ -0,0 +1,39 @@+import { useEffect, useMemo } from 'react'+import { useNavigate } from 'react-router-dom'+import { useAuth } from '@/contexts/auth-context'+import { Card, CardContent } from '@/components/ui/card'+import { ShellLogo } from '@/components/shell-logo'++export default function OIDCCallbackPage() {+ const navigate = useNavigate()+ const { loginWithToken } = useAuth()+ const accessToken = useMemo(() => {+ const params = new URLSearchParams(window.location.hash.replace(/^#/, ''))+ return params.get('access_token')+ }, [])++ useEffect(() => {+ if (!accessToken) return+ loginWithToken(accessToken)+ window.history.replaceState(null, '', '/auth/oidc/callback')+ navigate('/', { replace: true })+ }, [accessToken, loginWithToken, navigate])++ return (+ <div className="flex flex-col items-center justify-center min-h-screen bg-background px-4">+ <Card className="w-full max-w-[380px] shadow-sm">+ <CardContent className="flex flex-col items-center gap-4 px-8 py-8 text-center">+ <div className="w-11 h-11 rounded-xl bg-primary/10 flex items-center justify-center">+ <ShellLogo size={22} className="text-primary" />+ </div>+ <div>+ <h1 className="text-xl font-semibold tracking-tight">Signing you in…</h1>+ <p className="text-sm text-muted-foreground mt-1">+ {accessToken ? 'Completing secure OIDC login.' : 'OIDC login did not return an access token.'}+ </p>+ </div>+ </CardContent>+ </Card>+ </div>+ )+}