Authenticatie voor MCP-servers

Authenticatie in MCP: het overzicht

Het MCP-protocol zelf regelt geen inlogmechanisme op berichtniveau. Autorisatie hoort bij de transport-laag. Voor lokale stdio-servers is dat impliciet: de gebruiker die de server start, heeft de rechten en de credentials komen uit de omgeving. Zodra je server via het netwerk bereikbaar is, moet je autorisatie zelf inrichten.

De MCP-autorisatiespec (versie 2025-11-25, de actuele versie in juni 2026) bouwt op OAuth 2.1. Het belangrijkste mentale model is dit: jouw MCP-server gedraagt zich als een OAuth 2.1 resource server. Hij geeft zelf geen tokens uit, maar valideert tokens die door een aparte authorization server zijn uitgegeven (bijvoorbeeld Google, Microsoft Entra, Auth0 of je eigen identity provider). De client haalt het token op bij die authorization server en stuurt het mee in elke aanroep.

Welke aanpak past bij jouw situatie:

Statische API-key (alleen voor server-to-server)

Voor interne koppelingen zonder gebruikersidentiteit volstaat een vaste sleutel in de Authorization-header. Gebruik dit niet voor servers die namens gebruikers handelen, want er is geen audience-binding en geen intrekbaarheid per gebruiker.

import express from "express";
import { randomUUID } from "node:crypto";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

const app = express();
app.use(express.json());

const VALID_KEYS = new Set(process.env.API_KEYS?.split(",") ?? []);

function authMiddleware(
  req: express.Request,
  res: express.Response,
  next: express.NextFunction
) {
  const authHeader = req.headers.authorization;
  if (!authHeader?.startsWith("Bearer ")) {
    res.status(401).json({ error: "Geen Bearer-token opgegeven" });
    return;
  }
  const token = authHeader.slice(7);
  if (!VALID_KEYS.has(token)) {
    res.status(403).json({ error: "Ongeldig token" });
    return;
  }
  next();
}

const server = new McpServer({ name: "secure-server", version: "1.0.0" });
const transport = new StreamableHTTPServerTransport({
  sessionIdGenerator: () => randomUUID(),
});
await server.connect(transport);

app.post("/mcp", authMiddleware, async (req, res) => {
  await transport.handleRequest(req, res, req.body);
});

app.listen(3000);

OAuth 2.1: jouw server als resource server

Dit is de aanbevolen aanpak voor remote servers die echte gebruikers bedienen. De server geeft zelf geen inlogscherm, maar valideert het binnenkomende token en wijst de client naar de juiste authorization server. De spec vraagt een paar concrete dingen.

1. Antwoord op een ontbrekend token met een 401 plus WWW-Authenticate

Wanneer er geen geldig token is, geef je een 401 terug met een WWW-Authenticate-header die naar je Protected Resource Metadata wijst (RFC 9728). Zo weet de client zelf bij welke authorization server hij een token moet halen.

function requireToken(
  req: express.Request,
  res: express.Response,
  next: express.NextFunction
) {
  const authHeader = req.headers.authorization;
  if (!authHeader?.startsWith("Bearer ")) {
    res
      .status(401)
      .set(
        "WWW-Authenticate",
        'Bearer resource_metadata="https://mcp.example.com/.well-known/oauth-protected-resource"'
      )
      .json({ error: "Authenticatie vereist" });
    return;
  }
  next();
}

2. Publiceer Protected Resource Metadata

Serveer een well-known document dat naar je authorization server(s) verwijst. De client gebruikt dit om het OAuth-verkeer te starten.

app.get("/.well-known/oauth-protected-resource", (req, res) => {
  res.json({
    resource: "https://mcp.example.com",
    authorization_servers: ["https://auth.example.com"],
    scopes_supported: ["files:read", "files:write"],
  });
});

3. Valideer het token op audience

De spec is hier streng: je server mag een token alleen accepteren als het specifiek voor jouw server is uitgegeven. Dit voorkomt dat een token dat voor een andere dienst was bedoeld, hier wordt hergebruikt. Controleer dus de handtekening, de vervaldatum en de aud-claim (RFC 8707).

import { createRemoteJWKSet, jwtVerify } from "jose";

const JWKS = createRemoteJWKSet(
  new URL("https://auth.example.com/.well-known/jwks.json")
);

async function validateToken(token: string) {
  const { payload } = await jwtVerify(token, JWKS, {
    issuer: "https://auth.example.com",
    audience: "https://mcp.example.com",
  });
  return payload;
}

Token gebruiken in een tool-handler

Zodra het token gevalideerd is, kun je in je tool de bijbehorende gebruiker en scopes gebruiken. Hieronder vraagt de tool bestanden op namens de ingelogde gebruiker. Het upstream-token voor Google staat los van het MCP-token en haal je uit een veilige store per gebruiker.

server.registerTool(
  "list_drive_files",
  {
    title: "Drive-bestanden",
    description: "Lijst bestanden in Google Drive van de ingelogde gebruiker",
    inputSchema: { folder_id: z.string().optional() },
  },
  async ({ folder_id }, extra) => {
    const userId = extra?.authInfo?.subject;
    if (!userId) {
      throw new McpError(ErrorCode.InvalidRequest, "Niet geautoriseerd.");
    }
    const upstream = await tokenStore.get(userId);
    if (!upstream) {
      throw new McpError(
        ErrorCode.InvalidRequest,
        "Geen Google-koppeling. Verbind eerst je account."
      );
    }
    oauth2Client.setCredentials(upstream);
    const drive = google.drive({ version: "v3", auth: oauth2Client });
    const response = await drive.files.list({
      q: folder_id ? `'${folder_id}' in parents` : undefined,
    });
    return {
      content: [{ type: "text", text: JSON.stringify(response.data.files) }],
    };
  }
);

Rate limiting toevoegen

Beperk het aantal verzoeken om misbruik en kostenexplosies te voorkomen. Sleutel bij voorkeur op de gevalideerde gebruiker, niet op het rauwe token, zodat je geen tokens in je sleutels logt.

import rateLimit from "express-rate-limit";

const limiter = rateLimit({
  windowMs: 60 * 1000,
  max: 100,
  message: { error: "Te veel verzoeken, wacht een minuut" },
  keyGenerator: (req) => req.headers.authorization ?? req.ip,
});

app.use("/mcp", limiter);

Audit logging

Log elke tool-aanroep voor compliance en incident-onderzoek. Log nooit het rauwe token of gevoelige argumenten; bewaar wel wie wat wanneer aanriep.

server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
  await auditLog.write({
    timestamp: new Date().toISOString(),
    tool: request.params.name,
    user: extra?.authInfo?.subject,
  });
});

Checklist voor productie