mirror of
https://github.com/ZTatman/myst.git
synced 2026-11-20 20:07:59 +00:00
Centralize all Forgejo HTTP in app/services/forgejo.py (get/post + authorize_url/exchange_code/fetch_user, typed ForgejoError, defensive base-URL join). Centralize credential encryption in app/auth/tokens.py (decrypt_pat/set_pat, set_client_secret/decrypt_client_secret) so the get_fernet()+crypto+column pattern no longer leaks into routers. auth/settings/setup now delegate to these modules; the duplicated client-secret encrypt block and per-call httpx clients are gone.
197 lines
6.8 KiB
Python
197 lines
6.8 KiB
Python
from __future__ import annotations
|
|
|
|
import secrets
|
|
from datetime import UTC, datetime, timedelta
|
|
from typing import Annotated
|
|
|
|
from fastapi import APIRouter, Cookie, Depends, HTTPException, Request, status
|
|
from fastapi.responses import RedirectResponse
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.auth import tokens
|
|
from app.auth.identity import find_or_create_user
|
|
from app.auth.session import create_session, revoke_session
|
|
from app.config import get_app_settings
|
|
from app.deps import get_db
|
|
from app.models.app_settings import AppSettings
|
|
from app.services import forgejo
|
|
|
|
router = APIRouter(prefix="/auth", tags=["auth"])
|
|
|
|
|
|
# ── Forgejo OAuth error translation ──
|
|
|
|
|
|
def _oauth_gateway_error(exc: forgejo.ForgejoError) -> HTTPException:
|
|
"""Translate a Forgejo failure into the OAuth flow's 502 response."""
|
|
if exc.unreachable:
|
|
detail = "Cannot reach Forgejo. Check your connection settings."
|
|
else:
|
|
detail = f"Forgejo returned an error ({exc.status_code}). Verify your OAuth configuration."
|
|
return HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=detail)
|
|
|
|
|
|
# ── OAuth CSRF helpers ──
|
|
|
|
|
|
def _set_oauth_state_cookie(response: RedirectResponse, state: str) -> None:
|
|
response.set_cookie(
|
|
key="oauth_state",
|
|
value=state,
|
|
httponly=True,
|
|
samesite="lax",
|
|
path="/",
|
|
max_age=600,
|
|
)
|
|
|
|
|
|
def _verify_oauth_state(state: str | None, oauth_state: str | None) -> None:
|
|
if not state or not oauth_state or not secrets.compare_digest(state, oauth_state):
|
|
raise HTTPException(
|
|
status_code=status.HTTP_400_BAD_REQUEST,
|
|
detail="OAuth state mismatch. Possible CSRF attack.",
|
|
)
|
|
|
|
|
|
# ── Forgejo response parsers ──
|
|
|
|
|
|
def _parse_token_response(data: dict) -> tuple[str, str | None, datetime | None]:
|
|
access_token = data.get("access_token")
|
|
if not access_token or not isinstance(access_token, str):
|
|
raise HTTPException(
|
|
status_code=status.HTTP_502_BAD_GATEWAY,
|
|
detail="Forgejo OAuth response did not include an access_token.",
|
|
)
|
|
refresh_token = data.get("refresh_token")
|
|
refresh_plain = refresh_token if isinstance(refresh_token, str) else None
|
|
expires_in = data.get("expires_in")
|
|
if expires_in is not None:
|
|
expires_at = datetime.now(UTC) + timedelta(seconds=int(expires_in))
|
|
else:
|
|
expires_at = None
|
|
return access_token, refresh_plain, expires_at
|
|
|
|
|
|
def _parse_user_response(data: dict) -> tuple[str, str, str | None]:
|
|
provider_user_id = str(data.get("id", "")).strip()
|
|
provider_username = str(data.get("username", "")).strip()
|
|
if not provider_user_id or not provider_username:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_502_BAD_GATEWAY,
|
|
detail="Forgejo user response missing id or username.",
|
|
)
|
|
email_val = data.get("email")
|
|
email = email_val if isinstance(email_val, str) and email_val.strip() else None
|
|
return provider_user_id, provider_username, email
|
|
|
|
|
|
# ── OAuth config helpers ──
|
|
|
|
|
|
def _forgejo_oauth_redirect_uri(request: Request, app_settings: AppSettings) -> str:
|
|
base_url = app_settings.firebreak_public_base_url.strip().rstrip("/")
|
|
if base_url:
|
|
return f"{base_url}/auth/callback/forgejo"
|
|
return str(request.url_for("forgejo_oauth_callback"))
|
|
|
|
|
|
def _get_oauth_client_secret(app_settings: AppSettings) -> str:
|
|
try:
|
|
return tokens.decrypt_client_secret(app_settings)
|
|
except ValueError:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
|
detail="Forgejo OAuth credentials could not be decrypted. Reconfigure at /setup.",
|
|
)
|
|
|
|
|
|
# ── Routes ──
|
|
|
|
|
|
@router.get("/login/forgejo")
|
|
async def login_forgejo(
|
|
request: Request, app_settings: Annotated[AppSettings, Depends(get_app_settings)]
|
|
) -> RedirectResponse:
|
|
"""Redirect the browser to Forgejo to begin OAuth sign-in."""
|
|
|
|
redirect_uri = _forgejo_oauth_redirect_uri(request, app_settings)
|
|
state = secrets.token_urlsafe(32)
|
|
authorization_url = forgejo.authorize_url(app_settings, redirect_uri=redirect_uri, state=state)
|
|
response = RedirectResponse(authorization_url, status_code=status.HTTP_302_FOUND)
|
|
_set_oauth_state_cookie(response, state)
|
|
return response
|
|
|
|
|
|
@router.get("/callback/forgejo", name="forgejo_oauth_callback")
|
|
async def callback_forgejo(
|
|
request: Request,
|
|
db: Annotated[AsyncSession, Depends(get_db)],
|
|
app_settings: Annotated[AppSettings, Depends(get_app_settings)],
|
|
code: str | None = None,
|
|
state: str | None = None,
|
|
oauth_state: Annotated[str | None, Cookie()] = None,
|
|
) -> RedirectResponse:
|
|
"""Handle Forgejo's OAuth callback and create a local app session."""
|
|
|
|
_verify_oauth_state(state, oauth_state)
|
|
|
|
if not code:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_400_BAD_REQUEST,
|
|
detail="Forgejo did not return an authorization code. The user may have denied consent.",
|
|
)
|
|
|
|
client_secret = _get_oauth_client_secret(app_settings)
|
|
redirect_uri = _forgejo_oauth_redirect_uri(request, app_settings)
|
|
|
|
try:
|
|
token_data = await forgejo.exchange_code(
|
|
app_settings,
|
|
code=code,
|
|
client_secret=client_secret,
|
|
redirect_uri=redirect_uri,
|
|
)
|
|
except forgejo.ForgejoError as exc:
|
|
raise _oauth_gateway_error(exc) from exc
|
|
access_token, refresh_plain, expires_at = _parse_token_response(token_data)
|
|
|
|
try:
|
|
user_data = await forgejo.fetch_user(app_settings, access_token)
|
|
except forgejo.ForgejoError as exc:
|
|
raise _oauth_gateway_error(exc) from exc
|
|
provider_user_id, provider_username, email = _parse_user_response(user_data)
|
|
|
|
user = await find_or_create_user(
|
|
db,
|
|
app_settings,
|
|
provider="forgejo",
|
|
provider_user_id=provider_user_id,
|
|
provider_username=provider_username,
|
|
email=email,
|
|
access_token_raw=access_token,
|
|
access_token_expires_at=expires_at,
|
|
refresh_token_raw=refresh_plain,
|
|
)
|
|
|
|
# Clear setup token on first successful login — setup is proven to work
|
|
if request.app.state.setup_token is not None:
|
|
request.app.state.setup_token = None
|
|
|
|
redirect = RedirectResponse("/dashboard", status_code=status.HTTP_302_FOUND)
|
|
redirect.delete_cookie("oauth_state")
|
|
|
|
await create_session(db, redirect, user.id, secure=request.url.scheme == "https")
|
|
return redirect
|
|
|
|
|
|
@router.get("/logout")
|
|
async def logout(
|
|
db: Annotated[AsyncSession, Depends(get_db)],
|
|
firebreak_session: Annotated[str | None, Cookie()] = None,
|
|
) -> RedirectResponse:
|
|
"""Revoke the current app session and redirect back to the home page."""
|
|
|
|
redirect = RedirectResponse("/", status_code=status.HTTP_302_FOUND)
|
|
await revoke_session(db, redirect, firebreak_session)
|
|
return redirect
|