MCP pour les entreprises : SSO, pistes d'audit et patterns gateway

// Configuration client Keycloak
// realm: "enterprise"
// client_id: "mcp-gateway"
// client_secret: stocké dans le coffre-fort
// URIs de redirection valides : https://mcp-gateway.internal/callback
// Scopes : openid, profile, mcp:tools:read, mcp:tools:execute

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import jwt from "jsonwebtoken";
import jwksClient from "jwks-rsa";
 
const client = jwksClient({
  jwksUri: "https://keycloak.internal/realms/enterprise/protocol/openid-connect/certs",
  cache: true,
  rateLimit: true,
});
 
function getSigningKey(kid: string): Promise<string> {
  return new Promise((resolve, reject) => {
    client.getSigningKey(kid, (err, key) => {
      if (err) reject(err);
      else resolve(key!.getPublicKey());
    });
  });
}
 
interface McpTokenPayload {
  sub: string;
  email: string;
  realm_access: { roles: string[] };
  scope: string;
  iat: number;
  exp: number;
}
 
async function validateToken(token: string): Promise<McpTokenPayload> {
  const decoded = jwt.decode(token, { complete: true });
  if (!decoded?.header.kid) throw new Error("En-tête de token invalide");
 
  const signingKey = await getSigningKey(decoded.header.kid);
  return jwt.verify(token, signingKey, {
    audience: "mcp-gateway",
    issuer: "https://keycloak.internal/realms/enterprise",
  }) as McpTokenPayload;
}

const server = new McpServer({
  name: "enterprise-tools",
  version: "1.0.0",
});
 
server.tool(
  "query_database",
  "Exécuter une requête SQL en lecture seule sur la base analytique",
  { query: { type: "string", description: "Requête SQL SELECT" } },
  async (args, extra) => {
    const token = extra.meta?.authToken as string;
    const payload = await validateToken(token);
 
    if (!hasScope(payload, "mcp:tools:execute")) {
      return {
        content: [{ type: "text", text: "Interdit : scope mcp:tools:execute manquant" }],
        isError: true,
      };
    }
 
    await auditLog({
      user: payload.email,
      tool: "query_database",
      args,
      timestamp: new Date().toISOString(),
    });
 
    const result = await executeReadOnlyQuery(args.query);
    return { content: [{ type: "text", text: JSON.stringify(result) }] };
  }
);

import { createLogger, format, transports } from "winston";
 
interface AuditEntry {
  timestamp: string;
  requestId: string;
  userId: string;
  agentId?: string;
  toolName: string;
  toolArgs: Record<string, unknown>;
  outcome: "success" | "error" | "denied";
  responseSummary?: string;
  durationMs?: number;
}
 
const auditLogger = createLogger({
  level: "info",
  format: format.combine(format.timestamp(), format.json()),
  defaultMeta: { service: "mcp-audit" },
  transports: [
    new transports.File({
      filename: "/var/log/mcp/audit.jsonl",
      maxsize: 100 * 1024 * 1024,
      maxFiles: 365,
    }),
  ],
});
 
function sanitizeArgs(args: Record<string, unknown>): Record<string, unknown> {
  const sensitive = ["password", "secret", "token", "key", "credential"];
  const sanitized = { ...args };
  for (const key of Object.keys(sanitized)) {
    if (sensitive.some((s) => key.toLowerCase().includes(s))) {
      sanitized[key] = "[MASQUÉ]";
    }
  }
  return sanitized;
}

import { randomUUID } from "crypto";
 
function withAudit(toolName: string, handler: ToolHandler): ToolHandler {
  return async (args, extra) => {
    const requestId = `req_${randomUUID().slice(0, 8)}`;
    const startTime = Date.now();
    const token = extra.meta?.authToken as string;
 
    let payload: McpTokenPayload | null = null;
    try {
      payload = await validateToken(token);
    } catch {
      await auditLog({
        timestamp: new Date().toISOString(),
        requestId,
        userId: "unknown",
        toolName,
        toolArgs: args,
        outcome: "denied",
        responseSummary: "Échec d'authentification",
      });
      return {
        content: [{ type: "text", text: "Authentification requise" }],
        isError: true,
      };
    }
 
    try {
      const result = await handler(args, extra);
      await auditLog({
        timestamp: new Date().toISOString(),
        requestId,
        userId: payload.email,
        toolName,
        toolArgs: args,
        outcome: result.isError ? "error" : "success",
        durationMs: Date.now() - startTime,
      });
      return result;
    } catch (err) {
      await auditLog({
        timestamp: new Date().toISOString(),
        requestId,
        userId: payload.email,
        toolName,
        toolArgs: args,
        outcome: "error",
        responseSummary: String(err),
        durationMs: Date.now() - startTime,
      });
      throw err;
    }
  };
}

import express from "express";
import httpProxy from "http-proxy-middleware";
import rateLimit from "express-rate-limit";
 
const app = express();
 
const limiter = rateLimit({
  windowMs: 60 * 1000,
  max: 100,
  keyGenerator: (req) => req.headers["x-user-id"] as string || req.ip,
});
 
app.use(limiter);
 
app.use(async (req, res, next) => {
  const authHeader = req.headers.authorization;
  if (!authHeader?.startsWith("Bearer ")) {
    return res.status(401).json({ error: "Autorisation manquante" });
  }
 
  try {
    const payload = await validateToken(authHeader.slice(7));
    req.headers["x-user-id"] = payload.email;
    req.headers["x-user-roles"] = payload.realm_access.roles.join(",");
    req.headers["x-user-scopes"] = payload.scope;
    next();
  } catch {
    return res.status(401).json({ error: "Token invalide" });
  }
});

interface McpServerEntry {
  name: string;
  url: string;
  healthCheck: string;
  allowedRoles: string[];
  rateLimit: number;
  description: string;
}
 
const serverRegistry: McpServerEntry[] = [
  {
    name: "database",
    url: "http://mcp-db.internal:3001",
    healthCheck: "/health",
    allowedRoles: ["db-admin", "data-analyst"],
    rateLimit: 50,
    description: "Outils de requête base de données en lecture seule",
  },
  {
    name: "files",
    url: "http://mcp-files.internal:3002",
    healthCheck: "/health",
    allowedRoles: ["developer", "admin"],
    rateLimit: 100,
    description: "Outils de système de fichiers et documents",
  },
  {
    name: "deploy",
    url: "http://mcp-deploy.internal:3003",
    healthCheck: "/health",
    allowedRoles: ["admin", "devops"],
    rateLimit: 10,
    description: "Outils de déploiement et infrastructure",
  },
];

# mcp-policies.yaml
version: "1.0"
policies:
  - name: "database-access"
    servers: ["database"]
    roles: ["db-admin", "data-analyst"]
    scopes: ["mcp:tools:execute"]
    rate_limit:
      requests_per_minute: 50
    tools:
      allowed: ["query_database", "list_tables", "describe_table"]
      denied: ["drop_table", "truncate"]
 
  - name: "deployment-access"
    servers: ["deploy"]
    roles: ["admin", "devops"]
    scopes: ["mcp:tools:execute", "mcp:admin"]
    rate_limit:
      requests_per_minute: 10
    tools:
      allowed: ["deploy_staging", "rollback"]
      denied: ["deploy_production"]
    approval_required:
      - tool: "deploy_production"
        approvers: ["platform-lead"]