myst/web/app/routers/auth.py

248 lines
8.2 KiB
Python

from __future__ import annotations
import secrets
from datetime import UTC, datetime, timedelta
from typing import Annotated
from urllib.parse import urlencode
from fastapi import APIRouter, Cookie, Depends, HTTPException, Request, status
from fastapi.responses import RedirectResponse
from sqlalchemy.ext.asyncio import AsyncSession
from app.auth.crypto import decrypt_token
from app.auth.identity import find_or_create_user
from app.auth.session import create_session, revoke_session
from app.clients import forgejo
from app.deps import get_db
from app.models.app_settings import AppSettings
from app.settings import get_app_settings, get_fernet
router = APIRouter(prefix="/auth", tags=["auth"])
# ── OAuth CSRF helpers ──
def _set_oauth_state_cookie(response: RedirectResponse, state: str) -> None:
"""Set the OAuth state cookie in the response.
Args:
response: The response to set the cookie in.
state: The state to set in the cookie.
"""
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:
"""Verify the OAuth state and raise an exception if it is invalid.
Args:
state: The state parameter from the OAuth request.
oauth_state: The state cookie from the client.
"""
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]:
"""Parse the token response from Forgejo and return the access token, refresh token, and expiration time.
Args:
data: The token response from Forgejo.
Returns:
access_token: The access token.
refresh_token: The refresh token.
expires_at: The expiration time of the access token.
"""
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]:
"""Parse the user response from Forgejo and return the provider user id, provider username, and email.
Args:
data: The user response from Forgejo.
Returns:
provider_user_id: The provider user id.
provider_username: The provider username.
email: The email address of the user.
"""
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:
"""Generate the redirect URI for the Forgejo OAuth callback.
Args:
request: The incoming request.
app_settings: The application settings.
Returns:
The redirect URI for the Forgejo OAuth callback.
"""
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:
"""Get the OAuth client secret from the application settings.
Args:
app_settings: The application settings.
Returns:
The OAuth client secret.
"""
try:
return decrypt_token(
get_fernet(), app_settings.forgejo_oauth_client_secret_encrypted
)
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)
query = urlencode(
{
"client_id": app_settings.forgejo_oauth_client_id,
"response_type": "code",
"redirect_uri": redirect_uri,
"state": state,
}
)
authorization_url = f"{app_settings.forgejo_base_url}/login/oauth/authorize?{query}"
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 creates a new 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 access.",
)
client_secret = _get_oauth_client_secret(app_settings)
redirect_uri = _forgejo_oauth_redirect_uri(request, app_settings)
token_data = await forgejo.post(
app_settings,
"/login/oauth/access_token",
{
"grant_type": "authorization_code",
"client_id": app_settings.forgejo_oauth_client_id,
"client_secret": client_secret,
"code": code,
"redirect_uri": redirect_uri,
},
)
access_token, refresh_plain, expires_at = _parse_token_response(token_data)
user_data = await forgejo.get(app_settings, "/api/v1/user", access_token)
provider_user_id, provider_username, email = _parse_user_response(user_data)
# Find or create the user in the database
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")
# Create a new session for the user
await create_session(db, redirect, user.id, secure=request.url.scheme == "https")
# Redirect to the dashboard
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