Bearer-Authentifizierung im MCP-Server konfigurieren

MCP Auth bietet verschiedene Möglichkeiten, die Bearer-Autorisierung in deinem MCP-Server zu konfigurieren:

• JWT (JSON Web Token)-Modus: Eine integrierte Autorisierungsmethode, die JWTs mit Anspruchsüberprüfungen verifiziert.
• Benutzerdefinierter Modus: Ermöglicht es dir, deine eigene Autorisierungslogik zu implementieren.

Bearer-Authentifizierung mit JWT-Modus konfigurieren

Wenn dein OAuth / OIDC-Anbieter JWTs zur Autorisierung ausstellt, kannst du den integrierten JWT-Modus in MCP Auth verwenden. Er überprüft die JWT-Signatur, das Ablaufdatum und andere von dir angegebene Ansprüche; anschließend werden die Authentifizierungsinformationen im Anfragekontext für die weitere Verarbeitung in deiner MCP-Implementierung bereitgestellt.

Berechtigungsprüfung (Scope validation)

Hier ist ein Beispiel für die grundlegende Berechtigungsprüfung:

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);
});

Im obigen Beispiel haben wir angegeben, dass das JWT die Berechtigungen (Scopes) read und write enthalten muss. Wenn das JWT keine dieser Berechtigungen enthält, wird die Anfrage mit einem 403 Forbidden-Fehler abgelehnt.

Ressourcenindikator-Prüfung (RFC 8707)

Wenn dein Anbieter auf OIDC basiert oder die Resource Indicator-Erweiterung unterstützt, kannst du außerdem die Option audience angeben, um den aud (Zielgruppe / Audience)-Anspruch im JWT zu validieren. Dies ist nützlich, um sicherzustellen, dass das JWT für deinen MCP-Server bestimmt ist.

Überprüfe die Dokumentation deines Anbieters, um zu sehen, ob die Resource Indicator-Erweiterung unterstützt wird und wie sie konfiguriert wird. Manche Anbieter verwenden andere Begriffe wie „audience“, „API-Ressource“ oder „API-Indikator“ für dasselbe Konzept.

Sobald der Ressourcenindikator konfiguriert ist, kannst du ihn in der bearerAuth-Middleware angeben:

Python

bearer_auth = mcp_auth.bearer_auth_middleware(
    "jwt",
    audience="https://api.example.com/mcp",  # Die erwartete Zielgruppe (Audience) für das JWT
    required_scopes=["read", "write"]
)

Node.js

const bearerAuth = mcpAuth.bearerAuth('jwt', {
  audience: 'https://api.example.com/mcp', // Die erwartete Zielgruppe (Audience) für das JWT
  requiredScopes: ['read', 'write'],
});

Im obigen Beispiel validiert MCP Auth sowohl den aud-Anspruch im JWT als auch die erforderlichen Berechtigungen.

Benutzerdefinierte Optionen für die JWT-Überprüfung angeben

Du kannst auch benutzerdefinierte Optionen an die zugrunde liegende JWT-Überprüfungsbibliothek übergeben:

Python

Im Python SDK verwenden wir PyJWT für die JWT-Überprüfung. Du kannst folgende Optionen nutzen:

• leeway: Erlaubt eine gewisse Toleranz bei der Überprüfung der JWT-Ablaufzeit (in Sekunden). Standard ist 60 Sekunden.

bearer_auth = mcp_auth.bearer_auth_middleware(
    "jwt",
    audience="https://api.example.com/mcp",
    required_scopes=["read", "write"]
    leeway=10,  # Reduziert Zeitabweichungen, indem 10 Sekunden Toleranz erlaubt werden
)

Node.js

Im Node.js SDK verwenden wir die jose-Bibliothek für die JWT-Überprüfung. Du kannst folgende Optionen angeben:

• jwtVerify: Optionen für den JWT-Überprüfungsprozess (jwtVerify-Funktion aus jose).
• remoteJwtSet: Optionen für das Abrufen des Remote-JWT-Sets (createRemoteJWKSet-Funktion aus jose).

const bearerAuth = mcpAuth.bearerAuth('jwt', {
  audience: 'https://api.example.com/mcp',
  requiredScopes: ['read', 'write'],
  jwtVerify: {
    clockTolerance: 60, // Erlaubt eine Zeitabweichung von 60 Sekunden
  },
  remoteJwtSet: {
    timeoutDuration: 10 * 1000, // 10 Sekunden Timeout für das Abrufen des Remote-JWT-Sets
  },
});

Bearer-Authentifizierung mit benutzerdefinierter Überprüfung konfigurieren

Wenn dein OAuth / OIDC-Anbieter keine JWTs ausstellt oder du deine eigene Autorisierungslogik implementieren möchtest, erlaubt dir MCP Auth, eine benutzerdefinierte Überprüfungsfunktion zu erstellen:

info

Da die Bearer-Authentifizierungs-Middleware den Aussteller (iss), die Zielgruppe (aud) und die erforderlichen Berechtigungen (scope) anhand des Überprüfungsergebnisses prüft, musst du diese Prüfungen nicht in deiner benutzerdefinierten Überprüfungsfunktion implementieren. Du kannst dich darauf konzentrieren, die Token-Gültigkeit zu überprüfen (z. B. Signatur, Ablauf usw.) und das Auth-Info-Objekt zurückzugeben.

Python

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

async def custom_verification(token: str) -> AuthInfo:
    # Implementiere hier deine benutzerdefinierte Überprüfungslogik
    info = await verify_token(token)
    if not info:
        raise MCPAuthJwtVerificationException(
            MCPAuthJwtVerificationExceptionCode.JWT_VERIFICATION_FAILED
        )
    return info  # Gib das Auth-Info-Objekt zurück

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

Node.js

const bearerAuth = mcpAuth.bearerAuth(
  async (token) => {
    // Implementiere hier deine benutzerdefinierte Überprüfungslogik
    const info = await verifyToken(token);
    if (!info) {
      throw new MCPAuthJwtVerificationError('jwt_verification_failed');
    }
    return info; // Gib das Auth-Info-Objekt zurück
  },
  { requiredScopes: ['read', 'write'] }
);

Bearer-Authentifizierung in deinem MCP-Server anwenden

Um deinen MCP-Server mit Bearer-Authentifizierung zu schützen, musst du die Bearer-Authentifizierungs-Middleware auf deine MCP-Server-Instanz anwenden.

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'] }));

Dadurch wird sichergestellt, dass alle eingehenden Anfragen gemäß den konfigurierten Bearer-Authentifizierungseinstellungen authentifiziert und autorisiert werden und die Authentifizierungsinformationen im Anfragekontext verfügbar sind.

Du kannst die Informationen dann in deiner MCP-Server-Implementierung abrufen:

Python

@mcp.tool()
async def whoami() -> dict:
    # `mcp_auth.auth_info` ist das Kontextobjekt für die aktuelle Anfrage
    auth_info = mcp_auth.auth_info
    print(f"Authentifizierter Benutzer: {auth_info.subject}")
    return {"subject": auth_info.subject}

Node.js

// `authInfo` wird aus dem `req.auth`-Objekt übernommen
server.tool('whoami', ({ authInfo }) => {
  console.log(`Authentifizierter Benutzer: ${authInfo.subject}`);
  return { subject: authInfo.subject };
});