Sichern Sie Ihren MCP-Server: eine 8-Punkte-Checkliste für Entwickler

1. Fügen Sie Ihrem MCP-Endpunkt eine Authentifizierung hinzu

„It's on localhost“ ist kein Sicherheitsmodell. Browsererweiterungen, lokale Prozesse und jeglicher Code, der darauf ausgeführt wird die gleiche Maschine erreichen kann localhost:3000. Remote-MCP wächst schnell; Claude Desktop, Cursor, und Windsurf unterstützen alle die Verbindung zu Remote-MCP-Servern über HTTPS.

Für jede Anfrage ist ein Bearer-Token erforderlich. Botois MCP-Server unter api.botoi.com/mcp akzeptiert API Tasten über die Authorization Kopfzeile. Ohne einen gültigen Schlüssel erhalten Sie 5 Anfragen pro Minute und 100 pro Tag; Mit einem skalieren die Grenzen nach Ihrem Plan.

Wenn Ihre Agenten JWTs anstelle statischer Schlüssel übergeben, dekodieren Sie diese, um Bereiche und Identität zu extrahieren. Hier erfahren Sie, wie So überprüfen Sie ein JWT aus einem MCP-Anfrageheader:

curl -s -X POST https://api.botoi.com/v1/jwt/decode \\
  -H "Content-Type: application/json" \\
  -d '{
    "token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJhZ2VudC1jdXJzb3ItNDIiLCJzY29wZSI6InJlYWQ6ZG5zIHJlYWQ6c3NsIiwiaWF0IjoxNzE3MDAwMDAwfQ.signature"
  }'

{
  "success": true,
  "data": {
    "header": { "alg": "RS256", "typ": "JWT" },
    "payload": {
      "sub": "agent-cursor-42",
      "scope": "read:dns read:ssl",
      "iat": 1717000000
    },
    "signature": "signature"
  }
}

Der sub Der Anspruch identifiziert den Agenten. Der scope Claim listet auf, welche Tools es kann Zugang. Überprüfen Sie die Signaturserverseite, bevor Sie diesen Werten vertrauen.

2. Scope-Tools pro API-Schlüssel

Nicht jeder Agent benötigt jedes Tool. Ein Überwachungsagent, der DNS-Einträge überprüft, sollte niemals auf a zugreifen Endpunkt für die Paste-Erstellung. Erstellen Sie Zulassungslisten, die jeden API-Schlüssel einem bestimmten Satz von Tools zuordnen.

// Scope tools per API key using an allowlist
interface AgentPermissions {
  allowedTools: Set<string>;
  maxBurst: number;
  dailyLimit: number;
}

const AGENT_PERMISSIONS: Record<string, AgentPermissions> = {
  "key_readonly_monitor": {
    allowedTools: new Set(["lookup_dns", "lookup_ssl", "lookup_ip"]),
    maxBurst: 10,
    dailyLimit: 500,
  },
  "key_full_access": {
    allowedTools: new Set(["*"]),  // wildcard for all tools
    maxBurst: 30,
    dailyLimit: 5000,
  },
};

function canUseTool(apiKey: string, toolName: string): boolean {
  const perms = AGENT_PERMISSIONS[apiKey];
  if (!perms) return false;
  if (perms.allowedTools.has("*")) return true;
  return perms.allowedTools.has(toolName);
}

3. Validieren Sie Werkzeugeingaben mit Zod-Schemas

MCP-Tools akzeptieren beliebiges JSON von Agenten. Ein Agent kann senden wo du Erwarten Sie eine Zeichenfolge oder schließen Sie Felder ein, die Ihr Tool nicht erkennt. Überprüfen Sie jede Eingabe vor der Ausführung.

Der MCP-Server von Botoi konvertiert beim Start mithilfe von OpenAPI-Pfaddefinitionen in Zod-Schemas schema-builder.ts. Der buildZodSchema Funktion liest Ihre OpenAPI-Spezifikation und Karten ordnet jeden Eigenschaftstyp einem Zod-Typ zu und markiert erforderliche Felder:

import { z } from "zod";
import { buildZodSchema } from "./schema-builder";

// Build a Zod schema from your OpenAPI spec for each tool
const dnsSchema = z.object(buildZodSchema("/v1/dns/lookup", "post"));

function validateToolInput(toolName: string, input: unknown) {
  const schemas: Record<string, z.ZodTypeAny> = {
    lookup_dns: dnsSchema,
    // ... one schema per tool
  };

  const schema = schemas[toolName];
  if (!schema) {
    throw new Error(\`Unknown tool: \${toolName}\`);
  }

  const result = schema.safeParse(input);
  if (!result.success) {
    return {
      error: "Invalid input",
      issues: result.error.issues.map((i) => ({
        path: i.path.join("."),
        message: i.message,
      })),
    };
  }

  return { data: result.data };
}

Generieren Sie Zod-Schemata aus Beispieleingaben

Wenn Sie keine OpenAPI-Spezifikation haben, generieren Sie Zod-Schemas aus Beispiel-Tool-Eingaben:

curl -s -X POST https://api.botoi.com/v1/schema/json-to-zod \\
  -H "Content-Type: application/json" \\
  -d '{
    "json": {
      "domain": "github.com",
      "check_mx": true,
      "timeout_ms": 5000
    }
  }'

{
  "success": true,
  "data": {
    "schema": "z.object({ domain: z.string(), check_mx: z.boolean(), timeout_ms: z.number() })"
  }
}

Validieren Sie Eingaben zur Laufzeit anhand des JSON-Schemas

Verwenden Sie für die Laufzeitvalidierung ohne Zod das JSON-Schema. Senden Sie das Schema und die Eingaben des Agenten an /v1/schema/validate:

curl -s -X POST https://api.botoi.com/v1/schema/validate \\
  -H "Content-Type: application/json" \\
  -d '{
    "schema": {
      "type": "object",
      "required": ["domain"],
      "properties": {
        "domain": { "type": "string", "minLength": 1 },
        "record_type": { "type": "string", "enum": ["A", "AAAA", "MX", "TXT", "CNAME", "NS"] }
      },
      "additionalProperties": false
    },
    "data": { "domain": "stripe.com", "record_type": "MX" }
  }'

Gültige Eingabeergebnisse:

{
  "success": true,
  "data": {
    "valid": true,
    "errors": []
  }
}

Wenn ein Agent besteht "record_type": "INVALID", erhalten Sie umsetzbare Fehler, bevor Ihr Tool ausgeführt wird:

{
  "success": true,
  "data": {
    "valid": false,
    "errors": [
      {
        "path": "/record_type",
        "message": "must be equal to one of the allowed values"
      }
    ]
  }
}

4. Legen Sie Werkzeuganmerkungen fest

Das MCP-Protokoll definiert vier Anmerkungshinweise: readOnlyHint, destructiveHint, idempotentHint, Und openWorldHint. Diese teilen den Agenten mit, ob ein Tool Daten liest, Der Status wird geändert, es kann sicher erneut versucht werden oder es werden externe Dienste kontaktiert. Die meisten MCP-Server ignorieren sie.

Der MCP-Server von Botoi kommentiert alle 49 Tools. So sieht das in der Praxis aus:

// curated-tools.ts (from Botoi's MCP server)
export const CURATED_TOOLS: Record<string, CuratedTool> = {
  lookup_dns: {
    path: "/v1/dns/lookup",
    method: "post",
    title: "DNS Lookup",
    description: "Query DNS records for a domain.",
    annotations: {
      readOnlyHint: true,   // reads data, changes nothing
      openWorldHint: true,  // contacts external DNS servers
    },
  },
  storage_paste_create: {
    path: "/v1/paste/create",
    method: "post",
    title: "Create Paste",
    description: "Store text content and return a short URL.",
    annotations: {
      destructiveHint: true,  // creates new data
      idempotentHint: false,  // each call creates a new paste
    },
  },
};

Agenten, die Anmerkungen respektieren, vermeiden den Aufruf destruktiver Tools ohne Bestätigung und bevorzugen es idempotente Tools beim Wiederholen fehlgeschlagener Anfragen. Setzen Sie sie auf jedes Werkzeug.

5. Ratenbegrenzung pro Agentenidentität

Ein betrügerischer Agent, der in einer Wiederholungsschleife feststeckt, sollte nicht Ihr gesamtes API-Kontingent erschöpfen. Standardtarifbegrenzung nach IP-Adresse reicht nicht aus; Mehrere Agenten können dieselbe IP teilen und ein einzelner Agent kann IPs wechseln.

Extrahieren Sie die Agentenidentität aus dem API-Schlüssel oder JWT und wenden Sie dann mithilfe eines Schiebefensters Beschränkungen pro Identität an oder im KV gespeicherter Token-Bucket:

// Hono middleware for per-agent rate limiting
import type { Context, Next } from "hono";

const BURST_LIMIT = 5;   // requests per minute
const DAILY_LIMIT = 100;  // requests per day

async function rateLimitAgent(c: Context, next: Next) {
  // Extract agent identity from API key or JWT
  const apiKey = c.req.header("Authorization")?.replace("Bearer ", "");
  const agentId = apiKey || c.req.header("X-Forwarded-For") || "anonymous";

  // Check burst limit (sliding window in KV)
  const burstKey = \`rate:\${agentId}:burst\

6. Protokollieren Sie jeden Tool-Aufruf mit Agentenzuordnung

Wenn in der Produktion etwas schief geht, müssen Sie drei Fragen beantworten: Welcher Agent hat welchen angerufen? Werkzeug, wann und mit welcher Eingabe. Ohne Aufrufprotokolle debuggen Sie blind.

Hashen Sie die Eingabe, anstatt rohe Argumente zu speichern. Dies gibt Ihnen genug Zeit, um zu korrelieren und zu deduplizieren ohne Protokollierung sensibler Daten:

// Log every tool invocation with agent identity
interface ToolInvocationLog {
  timestamp: string;
  agent_id: string;
  tool_name: string;
  input_hash: string;   // SHA-256 of the input (not the raw input)
  duration_ms: number;
  status: "success" | "error";
}

async function logToolInvocation(
  agentId: string,
  toolName: string,
  input: unknown,
  startTime: number,
  status: "success" | "error"
) {
  const inputStr = JSON.stringify(input);
  const inputHash = await crypto.subtle.digest(
    "SHA-256",
    new TextEncoder().encode(inputStr)
  );
  const hashHex = Array.from(new Uint8Array(inputHash))
    .map((b) => b.toString(16).padStart(2, "0"))
    .join("");

  const log: ToolInvocationLog = {
    timestamp: new Date().toISOString(),
    agent_id: agentId,
    tool_name: toolName,
    input_hash: hashHex,
    duration_ms: Date.now() - startTime,
    status,
  };

  // Send to your logging pipeline (Datadog, Loki, Cloudflare Logpush)
  console.log(JSON.stringify(log));
}

Senden Sie diese strukturierten Protokolle an Ihre bestehende Pipeline (Datadog, Grafana Loki, Cloudflare Logpush). Erstellen Sie Benachrichtigungen für ungewöhnliche Muster: ein einzelner Agent, der das Zehnfache seines normalen Anrufvolumens tätigt, oder ein schreibgeschützter Agent Agent versucht, destruktive Tools aufzurufen.

7. Werkzeugdefinitionen anheften und Integrität prüfen

Der Barracuda-Bericht ergab, dass Angreifer bösartige Tool-Definitionen in Agent-Frameworks einschleusten kompromittierte Abhängigkeiten. Wenn jemand Ihr MCP-Tool-Manifest (Namen, Beschreibungen oder Parameter) ändert Schemas) rufen Agenten Tools mit einem anderen Verhalten auf als von Ihnen beabsichtigt.

Hashen Sie Ihr Tool-Manifest zur Erstellungszeit. Berechnen Sie beim Start den Hash neu und vergleichen Sie:

import crypto from "node:crypto";
import Botoi from "@botoi/sdk";

const botoi = new Botoi();

// Your tool manifest (the source of truth)
const tools = [
  { name: "dns_lookup", path: "/v1/dns/lookup" },
  { name: "ip_lookup", path: "/v1/ip/lookup" },
  { name: "email_validate", path: "/v1/email/validate" },
  // ... all your tools
];

const manifest = JSON.stringify(tools);

// Hash it at build time and store the expected hash
const EXPECTED_HASH = "a3f2b8c1d4e5f6..."; // from your CI build

// At startup, verify integrity
function verifyManifestIntegrity() {
  const currentHash = crypto
    .createHash("sha256")
    .update(manifest)
    .digest("hex");

  if (currentHash !== EXPECTED_HASH) {
    throw new Error(
      \`Tool manifest tampered. Expected \${EXPECTED_HASH}, got \${currentHash}\`
    );
  }

  console.log("Tool manifest integrity verified.");
}

// Or use the Botoi API for environments without Node crypto
async function verifyWithApi() {
  const result = await botoi.hash.sha256({ input: manifest });
  if (result.data.hash !== EXPECTED_HASH) {
    throw new Error("Tool manifest tampered.");
  }
}

Generieren Sie den Hash mit der Botoi-API

Für CI-Umgebungen oder Edge-Runtimes ohne node:crypto:

curl -s -X POST https://api.botoi.com/v1/hash \\
  -H "Content-Type: application/json" \\
  -d '{
    "text": "[{\\"name\\":\\"dns_lookup\\",\\"path\\":\\"/v1/dns/lookup\\"},{\\"name\\":\\"ip_lookup\\",\\"path\\":\\"/v1/ip/lookup\\"}]",
    "algorithm": "sha256"
  }'

{
  "success": true,
  "data": {
    "hash": "a3f2b8c1d4e5f67890abcdef1234567890abcdef1234567890abcdef12345678",
    "algorithm": "sha256"
  }
}

Speichern Sie den erwarteten Hash als Umgebungsvariable. Vergleichen Sie es zum Zeitpunkt der Bereitstellung. Wenn die Hashes voneinander abweichen, Blockieren Sie die Bereitstellung.

8. Zerstörerische Sandbox-Operationen

Tools, die Daten schreiben, Nebenwirkungen auslösen oder externe Dienste kontaktieren, benötigen einen Bestätigungsfluss. Lassen Sie nicht zu, dass ein Agent ohne menschliche Überprüfung 1.000 Einfügungen erstellt oder Webhooks auslöst.

// Confirmation flow for destructive MCP tools
interface ToolResult {
  content: Array<{ type: string; text: string }>;
  isError?: boolean;
}

function handleDestructiveTool(
  toolName: string,
  input: Record<string, unknown>,
  confirmed: boolean
): ToolResult {
  const destructiveTools = new Set([
    "paste_create",
    "short_url_create",
    "webhook_inbox_create",
  ]);

  if (!destructiveTools.has(toolName)) {
    // Non-destructive: execute immediately
    return executeTool(toolName, input);
  }

  if (!confirmed) {
    // Return a preview instead of executing
    return {
      content: [{
        type: "text",
        text: JSON.stringify({
          action: "confirmation_required",
          tool: toolName,
          input,
          message: \`This tool will create new data. Pass "confirmed": true to proceed.\`,
        }),
      }],
    };
  }

  // Confirmed: execute the destructive operation
  return executeTool(toolName, input);
}

Das Muster ist einfach: Zerstörerische Tools geben beim ersten Aufruf eine Vorschau zurück. Der Agent zeigt die Vorschau für den Benutzer. Erst nachdem der Benutzer bestätigt hat, sendet der Agent einen zweiten Anruf mit "confirmed": true.

Für Tools, die externe Dienste kontaktieren (openWorldHint: true), erwägen Sie das Hinzufügen ein Timeout und ein Schutzschalter. Wenn eine externe API langsam oder ausgefallen ist, sollte dies bei Ihrem MCP-Server nicht der Fall sein bleibe ewig hängen und warte auf eine Antwort.

Wie der MCP-Server von Botoi diese Prüfungen anwendet

Botois MCP-Server unter api.botoi.com/mcp dient hierfür als Arbeitsreferenz Checkliste. So werden die einzelnen Elemente zugeordnet:

Sie können über Claude Desktop, Claude Code, Cursor, VS Code oder Windsurf eine Verbindung zum MCP-Server von Botoi herstellen. Der MCP-Setup-Seite hat die Konfiguration für jeden Client.

Ihre Checkliste für die Sicherheit Ihres MCP-Servers

Hier finden Sie die vollständige Checkliste in komprimierter Form. Drucken Sie es aus, pinnen Sie es an oder fügen Sie es in das Runbook Ihres Teams ein:

• Authentifizierung an jedem MCP-Endpunkt erforderlich (Bearer-Token, API-Schlüssel oder JWT)
• Ordnen Sie jeden API-Schlüssel einer Zulassungsliste zulässiger Tools zu
• Validieren Sie jede Tool-Eingabe vor der Ausführung mit Zod-Schemas oder JSON-Schemas
• Kommentieren Sie jedes Werkzeug mit readOnlyHint, destructiveHint, idempotentHint, Und openWorldHint
• Ratenbegrenzung pro Agentenidentität, nicht pro IP; Verwenden Sie sowohl Burst- als auch Tageskapseln
• Protokollieren Sie jeden Tool-Aufruf mit Agent-ID, Tool-Name, Eingabe-Hash, Dauer und Status
• Hashen Sie Ihr Tool-Manifest zur Erstellungszeit; Überprüfen Sie beim Start und blockieren Sie manipulierte Bereitstellungen
• Vorschauen von zerstörerischen Tools zurückgeben; erfordern vor der Ausführung eine ausdrückliche Bestätigung

Im Jahr 2026 wurden 43 Agent-Frameworks mit eingebetteten Schwachstellen ausgeliefert. MCP-Server sind das nächste Ziel. Die acht oben genannten Prüfungen machen Ihren Server nicht unverwundbar, aber sie schließen die Lücken, die Angreifer haben Zuerst ausnutzen: offene Endpunkte, nicht validierte Eingaben und unsichtbare Aufrufe.