diff --git a/server/tests/test_mcp_keys.py b/server/tests/test_mcp_keys.py new file mode 100644 index 0000000..3d4e3b6 --- /dev/null +++ b/server/tests/test_mcp_keys.py @@ -0,0 +1,356 @@ +from __future__ import annotations + +import hashlib +import hmac +import json +import time +import uuid +from datetime import UTC, datetime + +import pytest +from fastapi.testclient import TestClient +from sqlalchemy import select +from starlette.responses import JSONResponse + +from app.auth.actor import Actor +from app.auth.context import current_actor, current_mcp_scopes +from app.auth.mcp_guard import McpTokenGuard, mcp_actor +from app.auth.mcp_keys import create_key, resolve_mcp_token +from app.auth.sessions import create_session, to_current_user +from app.config import Settings, get_settings +from app.main import app +from app.mcp_http import app as mcp_http_app +from app.mcp_server import mcp +from app.storage.db import Database +from app.storage.models import McpToken, User + +AUTH_ENV = { + "GNEXUS_BOOK_STORAGE_BACKEND": "db", + "GNEXUS_BOOK_AUTH_CLIENT_ID": "gnexus-book", + "GNEXUS_BOOK_AUTH_CLIENT_SECRET": "test-client-secret", + "GNEXUS_BOOK_AUTH_BASE_URL": "https://auth.example.test", + "GNEXUS_BOOK_AUTH_REDIRECT_URI": "https://book.example.test/auth/callback", + "GNEXUS_BOOK_AUTH_WEBHOOK_SECRET": "test-webhook-secret", + "GNEXUS_BOOK_AUTH_COOKIE_SECURE": "false", + "GNEXUS_BOOK_INTERNAL_KEY_SECRET": "test-internal-secret", + "GNEXUS_BOOK_INTERNAL_ALLOWLIST": "testclient", + "GNEXUS_BOOK_MCP_KEY_RATE_LIMIT": "100", +} + + +@pytest.fixture() +def key_settings(database: Database, monkeypatch: pytest.MonkeyPatch) -> Settings: + monkeypatch.setenv("GNEXUS_BOOK_DATABASE_URL", database.url) + for key, value in AUTH_ENV.items(): + monkeypatch.setenv(key, value) + get_settings.cache_clear() + return get_settings() + + +def _insert_user(database: Database, sub: str = "sub-key-user") -> User: + with database.session() as session: + with session.begin(): + user = User( + sub=sub, + email=f"{sub}@example.test", + display_name=sub, + profile={"locale": "en"}, + system_role="admin", + status="active", + ) + session.add(user) + session.flush() + return user + + +def _service_headers() -> dict[str, str]: + return {"X-Service-Key": "test-internal-secret"} + + +def _sign(body: str, secret: str, timestamp: int) -> str: + digest = hmac.new( + secret.encode(), f"{timestamp}.{body}".encode(), hashlib.sha256 + ).hexdigest() + return f"t={timestamp},v1={digest}" + + +def test_streamable_http_path_is_protocol_endpoint() -> None: + assert mcp.settings.streamable_http_path == "/mcp-protocol/" + + +def test_internal_key_lifecycle( + key_settings: Settings, database: Database +) -> None: + user = _insert_user(database) + client = TestClient(app) + + created = client.post( + "/internal/keys", + headers=_service_headers(), + json={"user_id": user.sub, "consumer": "navi", "name": "Navi key"}, + ) + assert created.status_code == 201, created.text + issued = created.json() + assert issued["token"].startswith("mcp_") + assert issued["consumer"] == "navi" + assert issued["role"] == "admin" + assert issued["user_id"] == user.sub + + with database.session() as session: + row = session.scalars( + select(McpToken).where( + McpToken.token_hash + == hashlib.sha256(issued["token"].encode()).hexdigest() + ) + ).first() + assert row is not None + assert row.token_hash != issued["token"] + assert row.token_hint == issued["token"][-6:] + + listed = client.get( + "/internal/keys", + params={"user_id": user.sub}, + headers=_service_headers(), + ) + assert listed.status_code == 200 + items = listed.json()["items"] + assert len(items) == 1 + assert "token" not in items[0] + assert items[0]["token_hint"] == issued["token"][-6:] + + duplicate = client.post( + "/internal/keys", + headers=_service_headers(), + json={"user_id": user.sub, "consumer": "navi", "name": "Another"}, + ) + assert duplicate.status_code == 409 + assert duplicate.json()["error"] == "key_exists" + + reissued = client.post( + "/internal/keys", + headers=_service_headers(), + json={"user_id": user.sub, "consumer": "navi", "name": "Navi key", "reissue": True}, + ) + assert reissued.status_code == 201 + new_token = reissued.json()["token"] + assert new_token != issued["token"] + assert resolve_mcp_token(database, issued["token"]) is None + assert resolve_mcp_token(database, new_token) is not None + + revoked = client.delete( + f"/internal/keys/{reissued.json()['key_id']}", + headers=_service_headers(), + ) + assert revoked.status_code == 204 + assert resolve_mcp_token(database, new_token) is None + + +def test_internal_key_validation( + key_settings: Settings, database: Database, monkeypatch: pytest.MonkeyPatch +) -> None: + user = _insert_user(database, sub="sub-key-validation") + client = TestClient(app) + + missing_user = client.post( + "/internal/keys", + headers=_service_headers(), + json={"user_id": "missing", "consumer": "navi"}, + ) + assert missing_user.status_code == 400 + assert missing_user.json()["error"] == "invalid_user_id" + + bad_consumer = client.post( + "/internal/keys", + headers=_service_headers(), + json={"user_id": user.sub, "consumer": "Bad Consumer"}, + ) + assert bad_consumer.status_code == 400 + + wrong_secret = client.post( + "/internal/keys", + headers={"X-Service-Key": "wrong"}, + json={"user_id": user.sub, "consumer": "navi"}, + ) + assert wrong_secret.status_code == 401 + + monkeypatch.setenv("GNEXUS_BOOK_INTERNAL_ALLOWLIST", "127.0.0.1") + get_settings.cache_clear() + denied_source = client.post( + "/internal/keys", + headers=_service_headers(), + json={"user_id": user.sub, "consumer": "navi"}, + ) + assert denied_source.status_code == 403 + + +def test_user_key_api_requires_session( + key_settings: Settings, database: Database +) -> None: + user = _insert_user(database, sub="sub-user-api") + token, _ = create_session(database, user.id, 3600) + + anonymous = TestClient(app).get("/mcp-keys") + assert anonymous.status_code == 401 + + client = TestClient(app) + client.cookies.set("gnb_session", token) + + created = client.post( + "/mcp-keys", json={"consumer": "claude-code", "name": "Claude Code key"} + ) + assert created.status_code == 201, created.text + issued = created.json() + assert issued["token"].startswith("mcp_") + + listed = client.get("/mcp-keys") + assert listed.status_code == 200 + assert len(listed.json()["items"]) == 1 + + revoked = client.delete(f"/mcp-keys/{issued['key_id']}") + assert revoked.status_code == 204 + assert resolve_mcp_token(database, issued["token"]) is None + + +def test_guard_rejects_missing_and_revoked_keys( + key_settings: Settings, database: Database +) -> None: + user = _insert_user(database, sub="sub-guard") + current = to_current_user(user) + issued, token = create_key(database, current, "navi", "Guard key") + payload = { + "jsonrpc": "2.0", + "id": 1, + "method": "initialize", + "params": { + "protocolVersion": "2025-03-26", + "capabilities": {}, + "clientInfo": {"name": "test", "version": "1"}, + }, + } + + with TestClient(mcp_http_app) as client: + anonymous = client.post("/mcp-protocol/", json=payload) + assert anonymous.status_code == 401 + assert anonymous.headers["www-authenticate"] == "Bearer" + + authenticated = client.post( + "/mcp-protocol/", + json=payload, + headers={"Authorization": f"Bearer {token}"}, + ) + assert authenticated.status_code != 401 + + with database.session() as session: + with session.begin(): + row = session.get(McpToken, uuid.UUID(issued["key_id"])) + assert row is not None + row.revoked_at = datetime.now(UTC) + + revoked = client.post( + "/mcp-protocol/", + json=payload, + headers={"Authorization": f"Bearer {token}"}, + ) + assert revoked.status_code == 401 + + +class _EchoActorApp: + async def __call__(self, scope, receive, send) -> None: + actor = current_actor.get() + scopes = current_mcp_scopes.get() + response = JSONResponse( + { + "actor_kind": actor.kind if actor else None, + "actor_name": actor.name if actor else None, + "via": actor.via if actor else None, + "scopes": list(scopes or []), + } + ) + await response(scope, receive, send) + + +def test_guard_sets_key_actor_and_scopes( + key_settings: Settings, database: Database +) -> None: + user = _insert_user(database, sub="sub-actor") + current = to_current_user(user) + _, token = create_key(database, current, "navi", "Actor key") + + guarded = McpTokenGuard(_EchoActorApp(), lambda: key_settings) + client = TestClient(guarded) + response = client.get( + "/anything", headers={"Authorization": f"Bearer {token}"} + ) + + assert response.status_code == 200 + body = response.json() + assert body["actor_kind"] == "agent" + assert body["actor_name"] == "Actor key" + assert body["via"] == "mcp" + assert body["scopes"] == ["read", "write"] + + +def test_guard_rate_limits_requests( + key_settings: Settings, + database: Database, + monkeypatch: pytest.MonkeyPatch, +) -> None: + user = _insert_user(database, sub="sub-rate-limit") + current = to_current_user(user) + _, token = create_key(database, current, "navi", "Rate key") + + monkeypatch.setenv("GNEXUS_BOOK_MCP_REQUEST_RATE_LIMIT", "1") + get_settings.cache_clear() + settings = get_settings() + guarded = McpTokenGuard(_EchoActorApp(), lambda: settings) + client = TestClient(guarded) + headers = {"Authorization": f"Bearer {token}"} + + assert client.get("/anything", headers=headers).status_code == 200 + limited = client.get("/anything", headers=headers) + assert limited.status_code == 429 + + +def test_is_user_toggles_actor_kind_only() -> None: + base_actor = Actor(kind="agent", name="Navi key", via="mcp") + reset = current_actor.set(base_actor) + try: + assert mcp_actor(False).kind == "agent" + assert mcp_actor(True).kind == "user" + assert mcp_actor(True).name == "Navi key" + assert mcp_actor(True).via == "mcp" + finally: + current_actor.reset(reset) + + +def test_blocked_user_webhook_revokes_keys( + key_settings: Settings, database: Database +) -> None: + user = _insert_user(database, sub="sub-blocked") + current = to_current_user(user) + issued, token = create_key(database, current, "navi", "Blocked key") + + body = json.dumps( + { + "id": "evt_block_key", + "type": "user.blocked", + "target": {"user_id": user.sub}, + "data": {"user": {"id": user.sub, "status": "blocked"}}, + } + ) + timestamp = int(time.time()) + headers = { + "X-Gnexus-Event-Id": "evt_block_key", + "X-Gnexus-Event-Type": "user.blocked", + "X-Gnexus-Event-Timestamp": str(timestamp), + "X-Gnexus-Signature": _sign(body, "test-webhook-secret", timestamp), + "Content-Type": "application/json", + } + client = TestClient(app) + response = client.post("/webhooks/gnexus-auth", content=body, headers=headers) + assert response.status_code == 200 + assert resolve_mcp_token(database, token) is None + + with database.session() as session: + row = session.get(McpToken, uuid.UUID(issued["key_id"])) + assert row is not None and row.revoked_at is not None