228 lines
7.9 KiB
Python
228 lines
7.9 KiB
Python
from __future__ import annotations
|
|
|
|
import secrets
|
|
from datetime import UTC, datetime, timedelta
|
|
from urllib.parse import urlencode
|
|
|
|
import httpx
|
|
from fastapi import APIRouter, Cookie, Depends, HTTPException, Request, Response, status
|
|
from fastapi.responses import RedirectResponse
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.auth.identity import find_or_create_user
|
|
from app.auth.session import create_session, revoke_session
|
|
from app.config import Settings, get_settings
|
|
from app.deps import get_db
|
|
|
|
router = APIRouter(prefix="/auth", tags=["auth"])
|
|
|
|
|
|
# ── Forgejo API client ──
|
|
|
|
|
|
async def _forgejo_post(settings: Settings, path: str, data: dict) -> dict:
|
|
url = f"{settings.forgejo_base_url.rstrip('/')}{path}"
|
|
try:
|
|
async with httpx.AsyncClient(timeout=30.0) as client:
|
|
resp = await client.post(url, data=data, headers={"Accept": "application/json"})
|
|
except httpx.RequestError as exc:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_502_BAD_GATEWAY,
|
|
detail=f"Cannot reach Forgejo: {exc}",
|
|
) from exc
|
|
if resp.status_code != 200:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_502_BAD_GATEWAY,
|
|
detail=(f"Forgejo API error {resp.status_code} at {path}: {resp.text[:500]}"),
|
|
)
|
|
return resp.json()
|
|
|
|
|
|
async def _forgejo_get(settings: Settings, path: str, token: str) -> dict:
|
|
url = f"{settings.forgejo_base_url.rstrip('/')}{path}"
|
|
try:
|
|
async with httpx.AsyncClient(timeout=30.0) as client:
|
|
resp = await client.get(url, headers={"Authorization": f"token {token}"})
|
|
except httpx.RequestError as exc:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_502_BAD_GATEWAY,
|
|
detail=f"Cannot reach Forgejo: {exc}",
|
|
) from exc
|
|
if resp.status_code != 200:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_502_BAD_GATEWAY,
|
|
detail=(f"Forgejo API error {resp.status_code} at {path}: {resp.text[:500]}"),
|
|
)
|
|
return resp.json()
|
|
|
|
|
|
# ── OAuth CSRF helpers ──
|
|
|
|
|
|
def _set_oauth_state_cookie(response: Response, 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("login", "")).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 login.",
|
|
)
|
|
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, settings: Settings) -> str:
|
|
base_url = settings.myst_public_base_url.strip().rstrip("/")
|
|
if base_url:
|
|
return f"{base_url}/auth/callback/forgejo"
|
|
return str(request.url_for("forgejo_oauth_callback"))
|
|
|
|
|
|
def _require_forgejo_oauth_config(settings: Settings) -> None:
|
|
if not settings.forgejo_base_url.strip():
|
|
raise HTTPException(
|
|
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
|
detail="Forgejo is not configured: set FORGEJO_BASE_URL in the environment.",
|
|
)
|
|
if not settings.forgejo_oauth_client_id.strip():
|
|
raise HTTPException(
|
|
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
|
detail="Forgejo OAuth is not configured: set FORGEJO_OAUTH_CLIENT_ID in the environment.",
|
|
)
|
|
secret = settings.forgejo_oauth_client_secret.get_secret_value().strip()
|
|
if not secret:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
|
detail="Forgejo OAuth is not configured: set FORGEJO_OAUTH_CLIENT_SECRET in the environment.",
|
|
)
|
|
|
|
|
|
# ── Routes ──
|
|
|
|
|
|
@router.get("/login/forgejo")
|
|
async def login_forgejo(
|
|
request: Request, settings: Settings = Depends(get_settings)
|
|
) -> RedirectResponse:
|
|
_require_forgejo_oauth_config(settings)
|
|
|
|
redirect_uri = _forgejo_oauth_redirect_uri(request, settings)
|
|
state = secrets.token_urlsafe(32)
|
|
query = urlencode(
|
|
{
|
|
"client_id": settings.forgejo_oauth_client_id,
|
|
"response_type": "code",
|
|
"redirect_uri": redirect_uri,
|
|
"state": state,
|
|
}
|
|
)
|
|
authorization_url = f"{settings.forgejo_base_url.rstrip('/')}/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: AsyncSession = Depends(get_db),
|
|
settings: Settings = Depends(get_settings),
|
|
code: str | None = None,
|
|
state: str | None = None,
|
|
oauth_state: str | None = Cookie(default=None),
|
|
) -> RedirectResponse:
|
|
_require_forgejo_oauth_config(settings)
|
|
_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.",
|
|
)
|
|
|
|
redirect = RedirectResponse("/dashboard", status_code=status.HTTP_302_FOUND)
|
|
redirect.delete_cookie("oauth_state")
|
|
|
|
token_data = await _forgejo_post(
|
|
settings,
|
|
"/login/oauth/access_token",
|
|
{
|
|
"grant_type": "authorization_code",
|
|
"client_id": settings.forgejo_oauth_client_id,
|
|
"client_secret": settings.forgejo_oauth_client_secret.get_secret_value(),
|
|
"code": code,
|
|
"redirect_uri": _forgejo_oauth_redirect_uri(request, settings),
|
|
},
|
|
)
|
|
access_token, refresh_plain, expires_at = _parse_token_response(token_data)
|
|
|
|
user_data = await _forgejo_get(settings, "/api/v1/user", access_token)
|
|
provider_user_id, provider_username, email = _parse_user_response(user_data)
|
|
|
|
user = await find_or_create_user(
|
|
db,
|
|
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,
|
|
)
|
|
|
|
await create_session(db, redirect, user.id, secure=request.url.scheme == "https")
|
|
return redirect
|
|
|
|
|
|
@router.get("/logout")
|
|
async def logout(
|
|
db: AsyncSession = Depends(get_db),
|
|
myst_session: str | None = Cookie(default=None),
|
|
) -> RedirectResponse:
|
|
redirect = RedirectResponse("/", status_code=status.HTTP_302_FOUND)
|
|
await revoke_session(db, redirect, myst_session)
|
|
return redirect
|