Skip to content

Open-source personal finance manager. Self-hosted, privacy-first.

feat: add OIDC login support (#275)

Romulo Gatto22bada4f0769
diff --git a/.env.example b/.env.example
index 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 application
ENABLE_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.md
index 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.simp
Then 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.example
index 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/callback
FRONTEND_URL=http://localhost:5173
REDIS_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.py
new file mode 100644
index 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.py
new file mode 100644
index 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",
+ )
+
+
+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.py
index baa82654..cc8f63db 100644
--- a/backend/app/core/config.py
+++ b/backend/app/core/config.py
@@ -61,6 +61,22 @@ class Settings(BaseSettings):
# Registration
registration_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"}
+
# Celery
redis_url: str = "redis://localhost:6379/0"
diff --git a/backend/app/main.py b/backend/app/main.py
index 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_router
from app.api.custom_auth import router as custom_auth_router
from app.api.dashboard import router as dashboard_router
from app.api.import_logs import router as import_logs_router
+from app.api.oidc_auth import router as oidc_auth_router
from app.api.import_transactions import router as import_router
from app.api.info import router as info_router
from 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.py
index 50555685..c91fd65c 100644
--- a/backend/app/models/user.py
+++ b/backend/app/models/user.py
@@ -1,7 +1,7 @@
from typing import TYPE_CHECKING, Optional
from fastapi_users.db import SQLAlchemyBaseUserTableUUID
-from sqlalchemy import JSON, Boolean, String
+from sqlalchemy import JSON, Boolean, String, UniqueConstraint
from sqlalchemy.orm import Mapped, mapped_column, relationship
from 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.py
new file mode 100644
index 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.yml
index 1f053c8c..ec5f80ef 100644
--- a/docker-compose.prod.yml
+++ b/docker-compose.prod.yml
@@ -21,6 +21,20 @@ x-backend-env: &backend-env
ENABLE_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/0
diff --git a/docker-compose.yml b/docker-compose.yml
index b4a4be57..fa69820a 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -21,6 +21,20 @@ x-backend-env: &backend-env
ENABLE_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/0
OPENEXCHANGERATES_APP_ID: ${OPENEXCHANGERATES_APP_ID:-}
FX_SYNC_MODE: ${FX_SYNC_MODE:-on_demand}
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 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 />} />
<Route
element={
diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.ts
index 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
+ },
}
// Categories
diff --git a/frontend/src/locales/en.json b/frontend/src/locales/en.json
index 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.json
index 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.json
index 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.json
index 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.tsx
index 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 state
const [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.tsx
new file mode 100644
index 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>
+ )
+}