Configura la autenticación Bearer en el servidor MCP

MCP Auth proporciona varias formas de configurar la autorización Bearer en tu servidor MCP:

• Modo JWT (JSON Web Token): Un método de autorización integrado que verifica JWTs con aserciones de reclamos.
• Modo personalizado: Te permite implementar tu propia lógica de autorización.

Configura la autenticación Bearer con el modo JWT

Si tu proveedor OAuth / OIDC emite JWTs para la autorización, puedes usar el modo JWT integrado en MCP Auth. Este verifica la firma del JWT, la expiración y otros reclamos que especifiques; luego, rellena la información de autenticación en el contexto de la solicitud para su posterior procesamiento en tu implementación MCP.

Validación de alcance (Scope)

Aquí tienes un ejemplo de la validación básica de alcances:

Python

from mcpauth import MCPAuth
from starlette.applications import Starlette
from starlette.middleware import Middleware
from starlette.routing import Mount
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("MyMCPServer")
mcp_auth = MCPAuth(
    # Initialize with your auth server config
)
bearer_auth = mcp_auth.bearer_auth_middleware("jwt", required_scopes=["read", "write"]) 

app = Starlette(
    routes=[Mount('/', app=mcp.sse_app(), middleware=[Middleware(bearer_auth)])]
)

Node.js

import express from 'express';
import { MCPAuth } from 'mcp-auth';

const app = express();
const mcpAuth = new MCPAuth({
  /* ... */
});
const bearerAuth = mcpAuth.bearerAuth('jwt', { requiredScopes: ['read', 'write'] }); 

app.use('/mcp', bearerAuth, (req, res) => {
  // Now `req.auth` contains the auth info
  console.log(req.auth);
});

En el ejemplo anterior, especificamos que el JWT requiere los alcances (scopes) read y write. Si el JWT no contiene ninguno de estos alcances, la solicitud será rechazada con un error 403 Forbidden.

Validación del indicador de recurso (RFC 8707)

Si tu proveedor está basado en OIDC, o admite la extensión Resource Indicator, también puedes especificar la opción audience para validar el reclamo aud (audiencia) en el JWT. Esto es útil para asegurar que el JWT está destinado a tu servidor MCP.

Consulta la documentación de tu proveedor para ver si admite la extensión Resource Indicator y cómo configurarla. Algunos proveedores pueden usar otros términos como "audience", "API resource" o "API indicator" para referirse al mismo concepto.

Una vez que el indicador de recurso esté configurado, puedes especificarlo en el middleware bearerAuth:

Python

bearer_auth = mcp_auth.bearer_auth_middleware(
    "jwt",
    audience="https://api.example.com/mcp",  # La audiencia esperada para el JWT
    required_scopes=["read", "write"]
)

Node.js

const bearerAuth = mcpAuth.bearerAuth('jwt', {
  audience: 'https://api.example.com/mcp', // La audiencia esperada para el JWT
  requiredScopes: ['read', 'write'],
});

En el ejemplo anterior, MCP Auth validará tanto el reclamo aud en el JWT como los alcances requeridos.

Proporciona opciones personalizadas a la verificación JWT

También puedes proporcionar opciones personalizadas a la biblioteca subyacente de verificación JWT:

Python

En el SDK de Python, usamos PyJWT para la verificación de JWT. Puedes usar las siguientes opciones:

• leeway: Permite cierta tolerancia al verificar el tiempo de expiración del JWT (en segundos). El valor predeterminado es 60 segundos.

bearer_auth = mcp_auth.bearer_auth_middleware(
    "jwt",
    audience="https://api.example.com/mcp",
    required_scopes=["read", "write"]
    leeway=10,  # Reduce la diferencia de reloj permitiendo 10 segundos de tolerancia
)

Node.js

En el SDK de Node.js, usamos la biblioteca jose para la verificación de JWT. Puedes proporcionar las siguientes opciones:

• jwtVerify: Opciones para el proceso de verificación JWT (función jwtVerify de jose).
• remoteJwtSet: Opciones para obtener el conjunto remoto de JWT (función createRemoteJWKSet de jose).

const bearerAuth = mcpAuth.bearerAuth('jwt', {
  audience: 'https://api.example.com/mcp',
  requiredScopes: ['read', 'write'],
  jwtVerify: {
    clockTolerance: 60, // Permite una diferencia de reloj de 60 segundos
  },
  remoteJwtSet: {
    timeoutDuration: 10 * 1000, // 10 segundos de tiempo de espera para obtener el conjunto remoto de JWT
  },
});

Configura la autenticación Bearer con verificación personalizada

Si tu proveedor OAuth / OIDC no emite JWTs, o deseas implementar tu propia lógica de autorización, MCP Auth te permite crear una función de verificación personalizada:

info

Dado que el middleware de autenticación Bearer verificará el emisor (iss), la audiencia (aud) y los alcances requeridos (scope) con el resultado de la verificación proporcionado, no es necesario implementar estas comprobaciones en tu función de verificación personalizada. Puedes centrarte en verificar la validez del token (por ejemplo, firma, expiración, etc.) y devolver el objeto de información de autenticación.

Python

from mcpauth.exceptions import MCPAuthJwtVerificationException, MCPAuthJwtVerificationExceptionCode
from mcpauth.types import AuthInfo

async def custom_verification(token: str) -> AuthInfo:
    # Implementa aquí tu lógica personalizada de verificación
    info = await verify_token(token)
    if not info:
        raise MCPAuthJwtVerificationException(
            MCPAuthJwtVerificationExceptionCode.JWT_VERIFICATION_FAILED
        )
    return info  # Devuelve el objeto de información de autenticación

bearer_auth = mcp_auth.bearer_auth_middleware(
    custom_verification,
    required_scopes=["read", "write"]
)

Node.js

const bearerAuth = mcpAuth.bearerAuth(
  async (token) => {
    // Implementa aquí tu lógica personalizada de verificación
    const info = await verifyToken(token);
    if (!info) {
      throw new MCPAuthJwtVerificationError('jwt_verification_failed');
    }
    return info; // Devuelve el objeto de información de autenticación
  },
  { requiredScopes: ['read', 'write'] }
);

Aplica la autenticación Bearer en tu servidor MCP

Para proteger tu servidor MCP con autenticación Bearer, necesitas aplicar el middleware de autenticación Bearer a tu instancia del servidor MCP.

Python

bearer_auth = mcp_auth.bearer_auth_middleware("jwt", required_scopes=["read", "write"])
app = Starlette(
    routes=[Mount('/', app=mcp.sse_app(), middleware=[Middleware(bearer_auth)])]
)

Node.js

const app = express();
app.use(mcpAuth.bearerAuth('jwt', { requiredScopes: ['read', 'write'] }));

Esto asegurará que todas las solicitudes entrantes sean autenticadas y autorizadas de acuerdo con la configuración de autenticación Bearer, y la información de autenticación estará disponible en el contexto de la solicitud.

Luego puedes acceder a la información en tu implementación del servidor MCP:

Python

@mcp.tool()
async def whoami() -> dict:
    # `mcp_auth.auth_info` es el objeto de contexto para la solicitud actual
    auth_info = mcp_auth.auth_info
    print(f"Usuario autenticado: {auth_info.subject}")
    return {"subject": auth_info.subject}

Node.js

// `authInfo` se obtendrá del objeto `req.auth`
server.tool('whoami', ({ authInfo }) => {
  console.log(`Usuario autenticado: ${authInfo.subject}`);
  return { subject: authInfo.subject };
});