Skip to content

πŸš€ The fast, Pythonic way to build MCP servers and clients.

11.7 KB
Raw Blame
"""Revocation ownership must not replace the identity used for authentication."""

import time
from collections.abc import Awaitable, Callable
from unittest.mock import AsyncMock, patch
from urllib.parse import parse_qs

import httpx2
import pytest
from key_value.aio.stores.memory import MemoryStore
from mcp.server.auth.provider import AccessToken
from mcp.server.transport_security import DEFAULT_MAX_REQUEST_BODY_SIZE
from mcp.shared.auth import OAuthClientInformationFull
from pydantic import AnyUrl
from starlette.applications import Starlette

from fastmcp.server.auth.identity_assertion import IdentityAssertion
from fastmcp.server.auth.oauth_proxy import OAuthProxy
from fastmcp.server.auth.oauth_proxy.models import (
    JTIMapping,
    RefreshTokenMetadata,
    UpstreamTokenSet,
    _hash_token,
)
from fastmcp.server.auth.oidc_proxy import OIDCConfiguration, OIDCProxy
from tests.utilities.httpx2_mock import HTTPXMock


@pytest.fixture(params=["oauth", "oidc"])
async def proxy(jwt_verifier, request: pytest.FixtureRequest) -> OAuthProxy:
    if request.param == "oidc":
        configuration = OIDCConfiguration(
            issuer="https://idp.example.com",
            authorization_endpoint="https://idp.example.com/authorize",
            token_endpoint="https://idp.example.com/token",
            revocation_endpoint="https://idp.example.com/revoke",
            jwks_uri="https://idp.example.com/jwks",
            response_types_supported=["code"],
            subject_types_supported=["public"],
            id_token_signing_alg_values_supported=["RS256"],
        )
        with patch.object(
            OIDCConfiguration, "get_oidc_configuration", return_value=configuration
        ):
            proxy = OIDCProxy(
                config_url="https://idp.example.com/.well-known/openid-configuration",
                client_id="upstream-app",
                client_secret="test-secret",
                token_verifier=jwt_verifier,
                verify_id_token=True,
                base_url="https://proxy.example.com",
                jwt_signing_key="test-signing-key",
                client_storage=MemoryStore(),
            )
    else:
        proxy = OAuthProxy(
            upstream_authorization_endpoint="https://idp.example.com/authorize",
            upstream_token_endpoint="https://idp.example.com/token",
            upstream_revocation_endpoint="https://idp.example.com/revoke",
            upstream_client_id="upstream-app",
            upstream_client_secret="test-secret",
            token_verifier=jwt_verifier,
            base_url="https://proxy.example.com",
            jwt_signing_key="test-signing-key",
            client_storage=MemoryStore(),
        )
    proxy.set_mcp_path("/mcp")
    for client_id in ("dcr-client", "other-client", "alice"):
        await proxy.register_client(
            OAuthClientInformationFull(
                client_id=client_id,
                redirect_uris=[AnyUrl("https://client.example.com/callback")],
                token_endpoint_auth_method="none",
            )
        )
    return proxy


@pytest.fixture
async def issue_token(
    proxy: OAuthProxy, jwt_verifier
) -> Callable[[str], Awaitable[str]]:
    validated_tokens: dict[str, AccessToken] = {}
    jwt_verifier.verify_token = AsyncMock(side_effect=validated_tokens.get)

    async def issue(user: str) -> str:
        now = time.time()
        upstream_token = f"upstream-{user}"
        verification_token = (
            f"id-{user}" if isinstance(proxy, OIDCProxy) else upstream_token
        )
        validated_tokens[verification_token] = AccessToken(
            token=verification_token,
            client_id=user,
            scopes=["read"],
            expires_at=int(now + 3600),
            subject=user,
            claims={"sub": user},
        )
        await proxy._upstream_token_store.put(
            key=user,
            value=UpstreamTokenSet(
                upstream_token_id=user,
                access_token=upstream_token,
                refresh_token=None,
                refresh_token_expires_at=None,
                expires_at=now + 3600,
                token_type="Bearer",
                scope="read",
                client_id="dcr-client",
                created_at=now,
                raw_token_data={"id_token": verification_token},
            ),
            ttl=3600,
        )
        await proxy._jti_mapping_store.put(
            key=user,
            value=JTIMapping(jti=user, upstream_token_id=user, created_at=now),
            ttl=3600,
        )
        return proxy.jwt_issuer.issue_access_token(
            client_id="dcr-client", scopes=["read"], jti=user
        )

    return issue


async def test_authentication_preserves_two_users_with_one_dcr_client(
    proxy: OAuthProxy, issue_token: Callable[[str], Awaitable[str]]
) -> None:
    """The bearer verifier must preserve user separation with revocation enabled."""
    for user in ("alice", "bob"):
        token = await issue_token(user)
        for load in (proxy.verify_token, proxy.load_access_token):
            verified = await load(token)
            assert verified is not None
            assert verified.client_id == user
            assert verified.subject == user
            assert verified.claims == {"sub": user}


@pytest.mark.parametrize("hint", [None, "access_token", "refresh_token"])
async def test_owner_revokes_upstream_access_token(
    proxy: OAuthProxy,
    issue_token: Callable[[str], Awaitable[str]],
    httpx_mock: HTTPXMock,
    hint: str | None,
) -> None:
    token = await issue_token("alice")
    before = await proxy.verify_token(token)
    httpx_mock.add_response(url="https://idp.example.com/revoke", method="POST")
    data = {"token": token, "client_id": "dcr-client", "client_secret": ""}
    if hint:
        data["token_type_hint"] = hint
    async with httpx2.AsyncClient(
        transport=httpx2.ASGITransport(app=Starlette(routes=proxy.get_routes("/mcp"))),
        base_url="https://proxy.example.com",
    ) as client:
        response = await client.post("/revoke", data=data)
    assert response.status_code == 200
    assert response.headers["cache-control"] == "no-store"
    request = httpx_mock.get_request()
    assert request is not None
    assert parse_qs(request.content.decode()) == {"token": ["upstream-alice"]}
    # Verifiers may cache their result; a revocation-only copy must not mutate it.
    assert before is not None
    assert before.client_id == "alice"
    after = await proxy.verify_token(token)
    assert after is not None
    assert after.client_id == "alice"


@pytest.mark.parametrize("client_id", ["other-client", "alice"])
async def test_non_owner_cannot_revoke_access_token(
    proxy: OAuthProxy,
    issue_token: Callable[[str], Awaitable[str]],
    httpx_mock: HTTPXMock,
    client_id: str,
) -> None:
    token = await issue_token("alice")
    async with httpx2.AsyncClient(
        transport=httpx2.ASGITransport(app=Starlette(routes=proxy.get_routes("/mcp"))),
        base_url="https://proxy.example.com",
    ) as client:
        response = await client.post(
            "/revoke",
            data={"token": token, "client_id": client_id, "client_secret": ""},
        )
    assert response.status_code == 200
    assert httpx_mock.get_requests() == []


async def test_invalid_access_token_is_not_revoked(
    proxy: OAuthProxy, jwt_verifier, httpx_mock: HTTPXMock
) -> None:
    jwt_verifier.verify_token = AsyncMock()
    async with httpx2.AsyncClient(
        transport=httpx2.ASGITransport(app=Starlette(routes=proxy.get_routes("/mcp"))),
        base_url="https://proxy.example.com",
    ) as client:
        response = await client.post(
            "/revoke",
            data={
                "token": "invalid-jwt",
                "client_id": "dcr-client",
                "client_secret": "",
            },
        )
    assert response.status_code == 200
    assert httpx_mock.get_requests() == []
    jwt_verifier.verify_token.assert_not_awaited()


async def test_revocation_keeps_body_limit_and_cors(
    proxy: OAuthProxy, jwt_verifier, httpx_mock: HTTPXMock
) -> None:
    jwt_verifier.verify_token = AsyncMock()
    async with httpx2.AsyncClient(
        transport=httpx2.ASGITransport(app=Starlette(routes=proxy.get_routes("/mcp"))),
        base_url="https://proxy.example.com",
    ) as client:
        preflight = await client.options(
            "/revoke",
            headers={
                "origin": "https://client.example.com",
                "access-control-request-method": "POST",
            },
        )
        response = await client.post(
            "/revoke",
            content=b"token=oversized",
            headers={
                "origin": "https://client.example.com",
                "content-type": "application/x-www-form-urlencoded",
                "content-length": str(DEFAULT_MAX_REQUEST_BODY_SIZE + 1),
            },
        )
    assert preflight.status_code == 200
    assert preflight.headers["access-control-allow-origin"] == "*"
    assert response.status_code == 413
    assert response.headers["access-control-allow-origin"] == "*"
    assert httpx_mock.get_requests() == []
    jwt_verifier.verify_token.assert_not_awaited()


@pytest.mark.parametrize("hint", [None, "access_token", "refresh_token"])
async def test_owner_revokes_upstream_refresh_token(
    proxy: OAuthProxy,
    issue_token: Callable[[str], Awaitable[str]],
    httpx_mock: HTTPXMock,
    hint: str | None,
) -> None:
    await issue_token("alice")
    upstream = await proxy._upstream_token_store.get(key="alice")
    assert upstream is not None
    await proxy._upstream_token_store.put(
        key="alice",
        value=upstream.model_copy(update={"refresh_token": "upstream-refresh"}),
        ttl=3600,
    )
    token = proxy.jwt_issuer.issue_refresh_token(
        client_id="dcr-client", scopes=["read"], jti="alice", expires_in=3600
    )
    await proxy._refresh_token_store.put(
        key=_hash_token(token),
        value=RefreshTokenMetadata(
            client_id="dcr-client",
            scopes=["read"],
            expires_at=int(time.time()) + 3600,
            created_at=time.time(),
        ),
        ttl=3600,
    )
    httpx_mock.add_response(url="https://idp.example.com/revoke", method="POST")
    data = {"token": token, "client_id": "dcr-client", "client_secret": ""}
    if hint:
        data["token_type_hint"] = hint
    async with httpx2.AsyncClient(
        transport=httpx2.ASGITransport(app=Starlette(routes=proxy.get_routes("/mcp"))),
        base_url="https://proxy.example.com",
    ) as client:
        response = await client.post("/revoke", data=data)
    assert response.status_code == 200
    request = httpx_mock.get_request()
    assert request is not None
    assert parse_qs(request.content.decode()) == {"token": ["upstream-refresh"]}
    assert await proxy._refresh_token_store.get(key=_hash_token(token)) is None


async def test_id_jag_revocation_remains_local(
    proxy: OAuthProxy, httpx_mock: HTTPXMock
) -> None:
    proxy._identity_assertion = IdentityAssertion(
        trusted_issuers=["https://idp.example.com"]
    )
    token = proxy.jwt_issuer.issue_access_token(
        client_id="dcr-client",
        scopes=["read"],
        jti="id-jag",
        subject="alice",
        extra_claims={"fastmcp_grant": "id_jag"},
    )
    assert await proxy.verify_token(token) is not None
    async with httpx2.AsyncClient(
        transport=httpx2.ASGITransport(app=Starlette(routes=proxy.get_routes("/mcp"))),
        base_url="https://proxy.example.com",
    ) as client:
        response = await client.post(
            "/revoke",
            data={"token": token, "client_id": "dcr-client", "client_secret": ""},
        )
    assert response.status_code == 200
    assert await proxy.verify_token(token) is None
    assert httpx_mock.get_requests() == []