diff --git a/server/app/auth/deps.py b/server/app/auth/deps.py new file mode 100644 index 0000000..37c19a5 --- /dev/null +++ b/server/app/auth/deps.py @@ -0,0 +1,28 @@ +from __future__ import annotations + +from fastapi import Depends, HTTPException, Request + +from ..config import Settings, get_settings +from .sessions import CurrentUser + + +def get_current_user(request: Request) -> CurrentUser | None: + return getattr(request.state, "user", None) + + +def require_editor( + request: Request, settings: Settings = Depends(get_settings) +) -> CurrentUser | None: + """Allow writes for authenticated, non-blocked users. + + Role-specific policy (owner review for access/security changes) is a later + refinement; the middleware already rejects anonymous requests when auth is on. + """ + if not settings.auth_enabled: + return None + user = get_current_user(request) + if user is None: + raise HTTPException(status_code=401, detail="Not authenticated") + if user.is_blocked: + raise HTTPException(status_code=403, detail="User is blocked") + return user diff --git a/server/app/auth/middleware.py b/server/app/auth/middleware.py new file mode 100644 index 0000000..6dc2f7c --- /dev/null +++ b/server/app/auth/middleware.py @@ -0,0 +1,79 @@ +from __future__ import annotations + +from typing import Callable + +from starlette.concurrency import run_in_threadpool +from starlette.requests import Request +from starlette.responses import JSONResponse +from starlette.types import ASGIApp, Receive, Scope, Send + +from ..config import Settings +from ..storage.db import Database +from .actor import actor_for_current_user +from .context import current_actor +from .sessions import resolve_session + + +class SessionAuthMiddleware: + """Resolve the browser session and guard non-exempt routes. + + Authentication is disabled when the gnexus-auth client is not configured, so + local development and the file backend keep working without credentials. + """ + + def __init__( + self, app: ASGIApp, settings_provider: Callable[[], Settings] + ) -> None: + self.app = app + self._settings_provider = settings_provider + self._database: Database | None = None + + def _db(self, settings: Settings) -> Database: + if self._database is None: + self._database = Database.from_settings(settings) + return self._database + + async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None: + if scope["type"] != "http": + await self.app(scope, receive, send) + return + + settings = self._settings_provider() + if not settings.auth_enabled: + await self.app(scope, receive, send) + return + + request = Request(scope) + state = scope.setdefault("state", {}) + token = request.cookies.get(settings.auth_session_cookie) + user = None + if token: + try: + user = await run_in_threadpool(resolve_session, self._db(settings), token) + except Exception: + response = JSONResponse( + {"detail": "Authentication storage is unavailable"}, + status_code=503, + ) + await response(scope, receive, send) + return + + state["user"] = user + actor_token = current_actor.set(actor_for_current_user(user, via="ui")) + try: + if user is None and not _is_exempt(request.url.path): + response = JSONResponse({"detail": "Not authenticated"}, status_code=401) + await response(scope, receive, send) + return + await self.app(scope, receive, send) + finally: + current_actor.reset(actor_token) + + +def _is_exempt(path: str) -> bool: + return ( + path == "/health" + or path == "/me" + or path.startswith("/auth/") + or path.startswith("/webhooks/gnexus-auth") + ) diff --git a/server/app/auth/routes.py b/server/app/auth/routes.py new file mode 100644 index 0000000..0f50978 --- /dev/null +++ b/server/app/auth/routes.py @@ -0,0 +1,168 @@ +from __future__ import annotations + +from datetime import UTC, datetime +from typing import Any + +from fastapi import APIRouter, Depends, HTTPException, Query, Request +from fastapi.responses import JSONResponse, RedirectResponse +from gnexus_gauth.exceptions import WebhookPayloadException, WebhookVerificationException +from pydantic import BaseModel + +from ..config import Settings, get_settings +from ..storage.db import Database +from .service import AuthError, AuthService +from .sessions import SUPPORTED_LOCALES, revoke_session, set_user_locale +from .users import serialize_user +from .webhooks import handle_webhook_event + +router = APIRouter() + + +class MeUpdate(BaseModel): + locale: str | None = None + + +def get_auth_service( + settings: Settings = Depends(get_settings), +) -> AuthService | None: + if not settings.auth_enabled: + return None + return AuthService(settings, Database.from_settings(settings)) + + +def _me_payload(request: Request, settings: Settings) -> dict[str, Any]: + user = getattr(request.state, "user", None) + return { + "auth_enabled": settings.auth_enabled, + "user": serialize_user(user) if user else None, + "locale": user.locale if user else None, + "locale_effective": user.effective_locale if user else "en", + } + + +def _safe_return_to(value: str | None) -> str | None: + if not value or not value.startswith("/") or value.startswith("//"): + return None + return value + + +@router.get("/me") +def me(request: Request, settings: Settings = Depends(get_settings)) -> dict[str, Any]: + return _me_payload(request, settings) + + +@router.patch("/me") +def update_me( + payload: MeUpdate, + request: Request, + settings: Settings = Depends(get_settings), +) -> dict[str, Any]: + if not settings.auth_enabled: + raise HTTPException(status_code=400, detail="Authentication is not configured") + user = getattr(request.state, "user", None) + if user is None: + raise HTTPException(status_code=401, detail="Not authenticated") + if payload.locale not in {None, "", *SUPPORTED_LOCALES}: + raise HTTPException(status_code=400, detail="locale must be en, uk, ru, or empty") + + updated = set_user_locale( + Database.from_settings(settings), user.id, payload.locale or None + ) + return { + "auth_enabled": True, + "user": serialize_user(updated), + "locale": updated.locale, + "locale_effective": updated.effective_locale, + } + + +@router.get("/auth/login") +def auth_login( + return_to: str | None = Query(default=None), + settings: Settings = Depends(get_settings), + service: AuthService | None = Depends(get_auth_service), +) -> RedirectResponse: + if service is None: + raise HTTPException(status_code=400, detail="Authentication is not configured") + url = service.build_login_url(return_to=_safe_return_to(return_to)) + return RedirectResponse(url, status_code=303) + + +@router.get("/auth/callback") +def auth_callback( + request: Request, + code: str | None = Query(default=None), + state: str | None = Query(default=None), + error: str | None = Query(default=None), + settings: Settings = Depends(get_settings), + service: AuthService | None = Depends(get_auth_service), +) -> RedirectResponse: + if service is None: + raise HTTPException(status_code=400, detail="Authentication is not configured") + if error: + return RedirectResponse("/?auth_error=access_denied", status_code=303) + if not code or not state: + raise HTTPException(status_code=400, detail="Missing code or state") + + try: + _, token, expires_at = service.exchange_code( + code, + state, + user_agent=request.headers.get("user-agent"), + ip_address=request.client.host if request.client else None, + ) + except AuthError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + except Exception as exc: + raise HTTPException(status_code=400, detail="Authentication failed") from exc + + response = RedirectResponse("/", status_code=303) + max_age = max(0, int((expires_at - datetime.now(UTC)).total_seconds())) + response.set_cookie( + key=settings.auth_session_cookie, + value=token, + max_age=max_age, + httponly=True, + secure=settings.auth_cookie_secure, + samesite="lax", + path="/", + ) + return response + + +@router.post("/auth/logout") +def auth_logout( + request: Request, settings: Settings = Depends(get_settings) +) -> JSONResponse: + token = request.cookies.get(settings.auth_session_cookie) + if token: + revoke_session(Database.from_settings(settings), token) + response = JSONResponse({"status": "ok"}) + response.delete_cookie(settings.auth_session_cookie, path="/") + return response + + +@router.post("/webhooks/gnexus-auth") +@router.post("/webhooks/gnexus-auth/") +async def gnexus_auth_webhook( + request: Request, settings: Settings = Depends(get_settings) +) -> dict[str, Any]: + if not settings.auth_enabled or not settings.auth_webhook_secret: + raise HTTPException(status_code=503, detail="Webhook endpoint is not configured") + + raw_bytes = await request.body() + try: + raw_body = raw_bytes.decode("utf-8") + except UnicodeDecodeError as exc: + raise HTTPException(status_code=400, detail="Invalid webhook payload") from exc + + service = AuthService(settings, Database.from_settings(settings)) + try: + event = service.verify_and_parse_webhook(raw_body, dict(request.headers)) + except WebhookVerificationException as exc: + raise HTTPException(status_code=401, detail="Invalid webhook signature") from exc + except WebhookPayloadException as exc: + raise HTTPException(status_code=400, detail="Invalid webhook payload") from exc + + processed = handle_webhook_event(Database.from_settings(settings), event) + return {"status": "ok", "event_id": event.event_id, "duplicate": not processed} diff --git a/server/app/auth/service.py b/server/app/auth/service.py new file mode 100644 index 0000000..97181c6 --- /dev/null +++ b/server/app/auth/service.py @@ -0,0 +1,116 @@ +from __future__ import annotations + +from datetime import timedelta +from typing import Any + +from gnexus_gauth.config import GAuthConfig +from gnexus_gauth.dto import AuthenticatedUser, WebhookEvent +from gnexus_gauth.oauth import AuthorizationUrlBuilder, HttpTokenEndpoint, PkceGenerator +from gnexus_gauth.runtime import HttpRuntimeUserProvider +from gnexus_gauth.webhook import HmacWebhookVerifier, JsonWebhookParser + +from ..config import Settings +from ..storage.db import Database +from ..storage.models import OAuthState, utcnow +from .sessions import CurrentUser, create_session, token_hash +from .users import upsert_user_from_auth + + +class AuthError(ValueError): + pass + + +class AuthService: + def __init__(self, settings: Settings, database: Database) -> None: + if not settings.auth_enabled: + raise AuthError("Authentication is not configured") + self.settings = settings + self.database = database + self.config = GAuthConfig( + base_url=settings.auth_base_url or "", + client_id=settings.auth_client_id or "", + client_secret=settings.auth_client_secret or "", + redirect_uri=settings.auth_redirect_uri or "", + state_ttl_seconds=settings.auth_state_ttl_seconds, + webhook_tolerance_seconds=settings.auth_webhook_tolerance_seconds, + user_agent="gnexus-book", + ) + self._tokens = HttpTokenEndpoint(self.config) + self._users = HttpRuntimeUserProvider(self.config) + self._urls = AuthorizationUrlBuilder(self.config) + self._webhook_verifier = HmacWebhookVerifier(self.config) + self._webhook_parser = JsonWebhookParser() + + def build_login_url(self, return_to: str | None = None) -> str: + state = PkceGenerator.generate_state() + verifier = PkceGenerator.generate_verifier() + challenge = PkceGenerator.generate_challenge(verifier) + now = utcnow() + expires_at = now + timedelta(seconds=self.settings.auth_state_ttl_seconds) + + with self.database.session() as session: + with session.begin(): + session.add( + OAuthState( + state_hash=token_hash(state), + code_verifier=verifier, + return_to=return_to, + created_at=now, + expires_at=expires_at, + ) + ) + + return self._urls.build( + state=state, + pkce_challenge=challenge, + return_to=return_to, + scopes=list(self.settings.auth_scopes), + ) + + def exchange_code( + self, + code: str, + state: str, + user_agent: str | None = None, + ip_address: str | None = None, + ) -> tuple[CurrentUser, str, Any]: + now = utcnow() + state_hash = token_hash(state) + with self.database.session() as session: + record = session.get(OAuthState, state_hash) + if record is None or record.expires_at <= now: + raise AuthError("Unknown or expired authorization state") + verifier = record.code_verifier + if not verifier: + raise AuthError("Missing PKCE verifier") + + token_set = self._tokens.exchange_authorization_code(code, verifier) + auth_user: AuthenticatedUser = self._users.fetch_user(token_set.access_token) + user = upsert_user_from_auth( + self.database, auth_user, self.settings.auth_client_id or "" + ) + + with self.database.session() as session: + with session.begin(): + record = session.get(OAuthState, state_hash) + if record is not None: + session.delete(record) + + token, expires_at = create_session( + self.database, + user.id, + self.settings.auth_session_ttl_seconds, + user_agent=user_agent, + ip_address=ip_address, + ) + return user, token, expires_at + + def verify_and_parse_webhook( + self, raw_body: str, headers: dict[str, str] + ) -> WebhookEvent: + if not self.settings.auth_webhook_secret: + raise AuthError("Webhook secret is not configured") + self._webhook_verifier.verify( + raw_body, headers, self.settings.auth_webhook_secret + ) + return self._webhook_parser.parse(raw_body) diff --git a/server/app/auth/webhooks.py b/server/app/auth/webhooks.py new file mode 100644 index 0000000..d8ec385 --- /dev/null +++ b/server/app/auth/webhooks.py @@ -0,0 +1,98 @@ +from __future__ import annotations + +import hashlib +import json + +from sqlalchemy import select, update + +from gnexus_gauth.dto import WebhookEvent + +from ..storage.db import Database +from ..storage.models import AuditLog, User, UserSession, WebhookEvent as StoredWebhookEvent, utcnow + +BLOCKED_EVENTS = {"user.blocked", "user.archived", "user.deleted"} +UNBLOCKED_EVENTS = {"user.unblocked", "user.restored"} +SESSION_EVENTS = {"auth.global_logout", "global_logout", "session.revoked"} +PROFILE_EVENTS = {"user.profile_updated", "profile.update"} + + +def handle_webhook_event(database: Database, event: WebhookEvent) -> bool: + """Store and apply one verified gnexus-auth event. Returns False on duplicate.""" + event_id = event.event_id or _fallback_event_id(event) + now = utcnow() + + with database.session() as session: + with session.begin(): + if session.get(StoredWebhookEvent, event_id) is not None: + return False + + session.add( + StoredWebhookEvent( + id=event_id, + event_type=event.event_type, + received_at=now, + payload=event.raw_payload, + ) + ) + + target = event.target_identifiers or {} + raw_user_id = target.get("user_id") + user_id = str(raw_user_id) if raw_user_id is not None else None + user = None + if user_id: + user = session.scalars(select(User).where(User.sub == user_id)).first() + + if event.event_type in BLOCKED_EVENTS: + if user is not None: + user.blocked_at = now + _revoke_sessions(session, user.id, now) + elif event.event_type in UNBLOCKED_EVENTS: + if user is not None: + user.blocked_at = None + elif event.event_type in SESSION_EVENTS: + if user is not None: + _revoke_sessions(session, user.id, now) + elif event.event_type in PROFILE_EVENTS: + profile = (event.metadata or {}).get("profile") + if user is not None and isinstance(profile, dict): + user.profile = dict(profile) + user.display_name = ( + profile.get("display_name") + or profile.get("username") + or user.display_name + ) + elif event.event_type == "user.system_role_updated": + system_role = (event.metadata or {}).get("system_role") + if user is not None and isinstance(system_role, str): + user.system_role = system_role + + session.add( + AuditLog( + actor_kind="system", + actor_name="gnexus-auth", + via="webhook", + action=event.event_type, + entity_type="user", + entity_id=user_id or "", + after={"event_id": event_id}, + ) + ) + + return True + + +def _revoke_sessions(session, user_id, now) -> None: + session.execute( + update(UserSession) + .where( + UserSession.user_id == user_id, + UserSession.revoked_at.is_(None), + ) + .values(revoked_at=now) + ) + + +def _fallback_event_id(event: WebhookEvent) -> str: + payload = json.dumps(event.raw_payload, sort_keys=True, ensure_ascii=False) + digest = hashlib.sha256(f"{event.event_type}.{payload}".encode("utf-8")).hexdigest() + return f"local_{digest}" diff --git a/server/app/main.py b/server/app/main.py index f6d4118..0ee0dd8 100644 --- a/server/app/main.py +++ b/server/app/main.py @@ -5,6 +5,9 @@ from fastapi import Depends, FastAPI, HTTPException, Query +from .auth.deps import require_editor +from .auth.middleware import SessionAuthMiddleware +from .auth.routes import router as auth_router from .config import Settings, get_settings from .docs_repository import RepositoryError from .freshness import build_freshness_report @@ -44,6 +47,9 @@ redoc_url="/api-redoc", ) +app.add_middleware(SessionAuthMiddleware, settings_provider=get_settings) +app.include_router(auth_router) + def get_docs_repo(settings: Settings = Depends(get_settings)) -> DocsRepositoryProtocol: return make_docs_repository(settings) @@ -147,6 +153,7 @@ version_no: int, summary: str | None = Query(default=None), settings: Settings = Depends(get_settings), + user=Depends(require_editor), ) -> dict[str, object]: if settings.storage_backend != "db": raise HTTPException(status_code=400, detail="Document restore is available in database mode") @@ -248,6 +255,7 @@ def propose_change( request: ProposedChangeRequest, repo: PendingChangeRepositoryProtocol = Depends(get_pending_change_repo), + user=Depends(require_editor), ) -> dict[str, object]: return repo.create(request) @@ -256,6 +264,7 @@ def apply_change( change_id: str, repo: PendingChangeRepositoryProtocol = Depends(get_pending_change_repo), + user=Depends(require_editor), ) -> dict[str, object]: try: return repo.apply(change_id) @@ -280,7 +289,11 @@ @app.post("/commit") -def commit(request: CommitRequest, git: GitAdapter = Depends(get_git_adapter)) -> dict[str, object]: +def commit( + request: CommitRequest, + git: GitAdapter = Depends(get_git_adapter), + user=Depends(require_editor), +) -> dict[str, object]: try: return git.commit(request) except GitAdapterError as exc: