diff --git a/server/.env.example b/server/.env.example index f261c6f..48db63e 100644 --- a/server/.env.example +++ b/server/.env.example @@ -6,6 +6,16 @@ # GNEXUS_BOOK_REPO_ROOT=/path/to/gnexus-book # MCP transport for development: stdio, sse, or streamable-http # GNEXUS_BOOK_MCP_TRANSPORT=stdio +# GNEXUS_BOOK_MCP_HOST=0.0.0.0 +# GNEXUS_BOOK_MCP_PORT=8001 +# Break-glass only; never a fallback for personal keys +# GNEXUS_BOOK_MCP_TOKEN= +# GNEXUS_BOOK_MCP_KEY_RATE_LIMIT=30 +# GNEXUS_BOOK_MCP_REQUEST_RATE_LIMIT=300 +# Internal key-provisioning API (not exposed through nginx) +# GNEXUS_BOOK_INTERNAL_KEY_SECRET= +# GNEXUS_BOOK_INTERNAL_ALLOWLIST=127.0.0.1,::1 +# GNEXUS_BOOK_INTERNAL_RATE_LIMIT=60 # gnexus-auth SSO. Leave the client id empty to run with authentication disabled. # GNEXUS_BOOK_AUTH_CLIENT_ID= diff --git a/server/app/auth/deps.py b/server/app/auth/deps.py index 37c19a5..67056ce 100644 --- a/server/app/auth/deps.py +++ b/server/app/auth/deps.py @@ -25,4 +25,12 @@ raise HTTPException(status_code=401, detail="Not authenticated") if user.is_blocked: raise HTTPException(status_code=403, detail="User is blocked") + + scopes = getattr(request.state, "mcp_scopes", None) + if ( + scopes is not None + and request.method in {"POST", "PATCH", "PUT", "DELETE"} + and "write" not in scopes + ): + raise HTTPException(status_code=403, detail="write scope required") return user diff --git a/server/app/auth/mcp_routes.py b/server/app/auth/mcp_routes.py new file mode 100644 index 0000000..d9c3c93 --- /dev/null +++ b/server/app/auth/mcp_routes.py @@ -0,0 +1,250 @@ +from __future__ import annotations + +import hmac +from typing import Any +from uuid import UUID + +from fastapi import APIRouter, Depends, HTTPException, Request +from fastapi.responses import JSONResponse, Response +from pydantic import BaseModel +from sqlalchemy import select + +from ..config import Settings, get_settings +from ..storage.db import Database +from ..storage.models import User +from .actor import Actor +from .mcp_keys import ( + KeyExistsError, + KeyNotFoundError, + create_key, + list_keys, + revoke_key, + rotate_key, +) +from .rate_limit import limiter_for +from .sessions import CurrentUser, to_current_user + +router = APIRouter() + + +class UserKeyRequest(BaseModel): + consumer: str + name: str = "" + reissue: bool = False + + +class InternalKeyRequest(BaseModel): + user_id: str + consumer: str + name: str = "" + reissue: bool = False + + +def require_internal_service( + request: Request, settings: Settings = Depends(get_settings) +) -> None: + if not settings.internal_key_secret: + raise HTTPException(status_code=503, detail="Internal key API is not configured") + + supplied = request.headers.get("x-service-key") + if not supplied: + authorization = request.headers.get("authorization", "") + parts = authorization.split(None, 1) + if len(parts) == 2 and parts[0].lower() == "bearer": + supplied = parts[1].strip() + + if not supplied or not hmac.compare_digest(supplied, settings.internal_key_secret): + raise HTTPException(status_code=401, detail="Invalid service credentials") + + host = request.client.host if request.client else "" + allowed = set(settings.internal_allowlist) | {"127.0.0.1", "::1"} + if host not in allowed: + raise HTTPException(status_code=403, detail="Source address is not allowed") + + limiter = limiter_for(settings.internal_rate_limit) + if not limiter.allow(host or "unknown"): + raise HTTPException(status_code=429, detail="Too many requests") + + +def _require_user(request: Request, settings: Settings) -> CurrentUser: + 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 user.is_blocked: + raise HTTPException(status_code=403, detail="User is blocked") + return user + + +def _user_by_sub(database: Database, sub: str) -> CurrentUser | None: + with database.session() as session: + user = session.scalars(select(User).where(User.sub == sub)).first() + return to_current_user(user) if user is not None else None + + +def _key_response(key: dict[str, Any], token: str) -> dict[str, Any]: + return {**key, "token": token} + + +@router.get("/mcp-keys") +def user_keys( + request: Request, settings: Settings = Depends(get_settings) +) -> dict[str, Any]: + user = _require_user(request, settings) + database = Database.from_settings(settings) + include_all = request.query_params.get("all") == "true" and user.system_role == "admin" + return { + "items": list_keys(database, user_id=None if include_all else user.id) + } + + +@router.post("/mcp-keys", status_code=201) +def user_create_key( + payload: UserKeyRequest, + request: Request, + settings: Settings = Depends(get_settings), +): + user = _require_user(request, settings) + if not limiter_for(settings.mcp_key_rate_limit).allow(f"user:{user.id}"): + raise HTTPException(status_code=429, detail="Too many requests") + database = Database.from_settings(settings) + try: + key, token = create_key( + database, + user, + payload.consumer, + payload.name, + reissue=payload.reissue, + ) + except KeyExistsError as exc: + return JSONResponse( + {"error": "key_exists", "key_id": exc.key_id, "token_hint": exc.token_hint}, + status_code=409, + ) + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + return _key_response(key, token) + + +@router.post("/mcp-keys/{key_id}/rotate") +def user_rotate_key( + key_id: str, + request: Request, + settings: Settings = Depends(get_settings), +): + user = _require_user(request, settings) + if not limiter_for(settings.mcp_key_rate_limit).allow(f"user:{user.id}"): + raise HTTPException(status_code=429, detail="Too many requests") + database = Database.from_settings(settings) + try: + key, token = rotate_key( + database, + key_id, + owner_user_id=None if user.system_role == "admin" else user.id, + ) + except KeyNotFoundError as exc: + raise HTTPException(status_code=404, detail=str(exc)) from exc + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + return _key_response(key, token) + + +@router.delete("/mcp-keys/{key_id}", status_code=204) +def user_revoke_key( + key_id: str, + request: Request, + settings: Settings = Depends(get_settings), +) -> Response: + user = _require_user(request, settings) + try: + revoke_key( + Database.from_settings(settings), + key_id, + owner_user_id=None if user.system_role == "admin" else user.id, + ) + except KeyNotFoundError as exc: + raise HTTPException(status_code=404, detail=str(exc)) from exc + return Response(status_code=204) + + +@router.post("/internal/keys", status_code=201) +def internal_create_key( + payload: InternalKeyRequest, + settings: Settings = Depends(get_settings), + _: None = Depends(require_internal_service), +): + database = Database.from_settings(settings) + user = _user_by_sub(database, payload.user_id) + if user is None: + return JSONResponse({"error": "invalid_user_id"}, status_code=400) + try: + key, token = create_key( + database, + user, + payload.consumer, + payload.name, + reissue=payload.reissue, + actor=Actor(kind="service", name="provisioning", via="api"), + ) + except KeyExistsError as exc: + return JSONResponse( + {"error": "key_exists", "key_id": exc.key_id, "token_hint": exc.token_hint}, + status_code=409, + ) + except ValueError as exc: + return JSONResponse({"error": "invalid_request", "detail": str(exc)}, status_code=400) + return _key_response(key, token) + + +@router.get("/internal/keys") +def internal_list_keys( + user_id: str | None = None, + consumer: str | None = None, + settings: Settings = Depends(get_settings), + _: None = Depends(require_internal_service), +): + database = Database.from_settings(settings) + owner: UUID | None = None + if user_id: + user = _user_by_sub(database, user_id) + if user is None: + return {"items": []} + owner = user.id + return {"items": list_keys(database, user_id=owner, consumer=consumer)} + + +@router.delete("/internal/keys/{key_id}", status_code=204) +def internal_revoke_key( + key_id: str, + settings: Settings = Depends(get_settings), + _: None = Depends(require_internal_service), +) -> Response: + try: + revoke_key( + Database.from_settings(settings), + key_id, + actor=Actor(kind="service", name="provisioning", via="api"), + ) + except KeyNotFoundError as exc: + raise HTTPException(status_code=404, detail=str(exc)) from exc + return Response(status_code=204) + + +@router.post("/internal/keys/{key_id}/rotate", status_code=201) +def internal_rotate_key( + key_id: str, + settings: Settings = Depends(get_settings), + _: None = Depends(require_internal_service), +): + try: + key, token = rotate_key( + Database.from_settings(settings), + key_id, + actor=Actor(kind="service", name="provisioning", via="api"), + ) + except KeyNotFoundError as exc: + raise HTTPException(status_code=404, detail=str(exc)) from exc + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + return _key_response(key, token) diff --git a/server/app/auth/middleware.py b/server/app/auth/middleware.py index 6dc2f7c..23fd1e2 100644 --- a/server/app/auth/middleware.py +++ b/server/app/auth/middleware.py @@ -9,9 +9,10 @@ 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 +from .actor import Actor, actor_for_current_user +from .context import current_actor, current_mcp_scopes +from .mcp_keys import resolve_mcp_token +from .sessions import CurrentUser, resolve_session class SessionAuthMiddleware: @@ -46,7 +47,10 @@ request = Request(scope) state = scope.setdefault("state", {}) token = request.cookies.get(settings.auth_session_cookie) - user = None + user: CurrentUser | None = None + actor = None + mcp_scopes: tuple[str, ...] | None = None + if token: try: user = await run_in_threadpool(resolve_session, self._db(settings), token) @@ -57,9 +61,43 @@ ) await response(scope, receive, send) return + if user is not None: + actor = actor_for_current_user(user, via="ui") + + if user is None: + authorization = request.headers.get("authorization", "") + parts = authorization.split(None, 1) + if len(parts) == 2 and parts[0].lower() == "bearer": + try: + resolved = await run_in_threadpool( + resolve_mcp_token, self._db(settings), parts[1].strip() + ) + except Exception: + response = JSONResponse( + {"detail": "Authentication storage is unavailable"}, + status_code=503, + ) + await response(scope, receive, send) + return + if resolved is not None: + user, key = resolved + mcp_scopes = tuple(key.scopes or []) + actor_kind = ( + "user" + if request.headers.get("x-actor", "").lower() == "user" + else "agent" + ) + actor = Actor( + kind=actor_kind, + name=key.name, + via="api", + user_id=user.id, + ) state["user"] = user - actor_token = current_actor.set(actor_for_current_user(user, via="ui")) + state["mcp_scopes"] = mcp_scopes + actor_token = current_actor.set(actor or actor_for_current_user(None, via="ui")) + scopes_token = current_mcp_scopes.set(mcp_scopes) try: if user is None and not _is_exempt(request.url.path): response = JSONResponse({"detail": "Not authenticated"}, status_code=401) @@ -68,6 +106,7 @@ await self.app(scope, receive, send) finally: current_actor.reset(actor_token) + current_mcp_scopes.reset(scopes_token) def _is_exempt(path: str) -> bool: @@ -76,4 +115,5 @@ or path == "/me" or path.startswith("/auth/") or path.startswith("/webhooks/gnexus-auth") + or path.startswith("/internal/") ) diff --git a/server/app/auth/webhooks.py b/server/app/auth/webhooks.py index d8ec385..b26fd70 100644 --- a/server/app/auth/webhooks.py +++ b/server/app/auth/webhooks.py @@ -9,11 +9,13 @@ from ..storage.db import Database from ..storage.models import AuditLog, User, UserSession, WebhookEvent as StoredWebhookEvent, utcnow +from .mcp_keys import mark_user_keys_stale_in_session, revoke_user_keys_in_session 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"} +ROLE_EVENTS = {"client.roles_changed", "client.permissions_changed"} def handle_webhook_event(database: Database, event: WebhookEvent) -> bool: @@ -46,6 +48,10 @@ if user is not None: user.blocked_at = now _revoke_sessions(session, user.id, now) + revoke_user_keys_in_session(session, user.id, now) + elif event.event_type in ROLE_EVENTS: + if user is not None: + mark_user_keys_stale_in_session(session, user.id, now) elif event.event_type in UNBLOCKED_EVENTS: if user is not None: user.blocked_at = None diff --git a/server/app/main.py b/server/app/main.py index 0ee0dd8..714986f 100644 --- a/server/app/main.py +++ b/server/app/main.py @@ -6,6 +6,7 @@ from fastapi import Depends, FastAPI, HTTPException, Query from .auth.deps import require_editor +from .auth.mcp_routes import router as mcp_keys_router from .auth.middleware import SessionAuthMiddleware from .auth.routes import router as auth_router from .config import Settings, get_settings @@ -49,6 +50,7 @@ app.add_middleware(SessionAuthMiddleware, settings_provider=get_settings) app.include_router(auth_router) +app.include_router(mcp_keys_router) def get_docs_repo(settings: Settings = Depends(get_settings)) -> DocsRepositoryProtocol: