Asegure su servidor MCP: una lista de verificación para desarrolladores de 8 puntos

1. Agregue autenticación a su punto final MCP

"Está en localhost" no es un modelo de seguridad. Extensiones del navegador, procesos locales y cualquier código que se ejecute en la misma máquina puede alcanzar localhost:3000. MCP remoto está creciendo rápidamente; Claude escritorio, cursor, y Windsurf admiten la conexión a servidores MCP remotos a través de HTTPS.

Requerir un token de portador en cada solicitud. El servidor MCP de Botoi en api.botoi.com/mcp acepta API claves a través del Authorization encabezamiento. Sin una clave válida, recibe 5 solicitudes por minuto y 100 por día; con uno, los límites se adaptan a su plan.

Si sus agentes pasan JWT en lugar de claves estáticas, decodifíquelos para extraer alcances e identidad. Así es como para inspeccionar un JWT desde un encabezado de solicitud MCP:

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"
  }
}

La sub El reclamo identifica al agente. El scope El reclamo enumera qué herramientas puede acceso. Verifique la firma del lado del servidor antes de confiar en estos valores.

2. Herramientas de alcance por clave API

No todos los agentes necesitan todas las herramientas. Un agente de monitoreo que verifica registros DNS nunca debe acceder a un punto final de creación de pegado. Cree listas de permitidos que asigne cada clave API a un conjunto específico de herramientas.

// 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. Validar las entradas de la herramienta con esquemas Zod

Las herramientas MCP aceptan JSON arbitrario de los agentes. Un agente puede enviar donde tu espere una cadena o incluya campos que su herramienta no reconoce. Valide cada entrada antes de ejecutar.

El servidor MCP de Botoi convierte las definiciones de ruta de OpenAPI en esquemas Zod al inicio usando schema-builder.ts. La buildZodSchema La función lee sus especificaciones OpenAPI y mapas. cada tipo de propiedad a un tipo Zod y marca los campos obligatorios:

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

Genere esquemas Zod a partir de entradas de muestra

Si no tiene una especificación OpenAPI, genere esquemas Zod a partir de entradas de herramientas de ejemplo:

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() })"
  }
}

Validar entradas contra el esquema JSON en tiempo de ejecución

Para la validación en tiempo de ejecución sin Zod, utilice el esquema JSON. Envíe el esquema y la entrada del agente a /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" }
  }'

Devoluciones de entrada válidas:

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

Si pasa una agente "record_type": "INVALID", obtienes errores procesables antes de que se ejecute tu herramienta:

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

4. Establecer anotaciones de herramientas

El protocolo MCP define cuatro sugerencias de anotaciones: readOnlyHint, destructiveHint, idempotentHint, y openWorldHint. Estos indican a los agentes si una herramienta lee datos, modifica el estado, es seguro volver a intentarlo o se pone en contacto con servicios externos. La mayoría de los servidores MCP los ignoran.

El servidor MCP de Botoi anota las 49 herramientas. Así es como se ve eso en la práctica:

// 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
    },
  },
};

Los agentes que respeten las anotaciones evitarán llamar a herramientas destructivas sin confirmación y preferirán herramientas idempotentes al reintentar solicitudes fallidas. Colóquelos en cada herramienta.

5. Límite de tarifa por identidad de agente

Un agente deshonesto atrapado en un ciclo de reintento no debería agotar toda su cuota de API. Limitación de tasa estándar por dirección IP no es suficiente; varios agentes pueden compartir la misma IP y un solo agente puede rotar las IP.

Extraiga la identidad del agente de la clave API o JWT, luego aplique límites por identidad usando una ventana deslizante o depósito de tokens almacenado en KV:

// 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. Registre cada invocación de herramienta con atribución de agente

Cuando algo sale mal en producción, es necesario responder tres preguntas: qué agente llamó a qué herramienta, cuándo y con qué entrada. Sin registros de invocación, estás depurando a ciegas.

Hash la entrada en lugar de almacenar argumentos sin formato. Esto le proporciona suficiente para correlacionar y deduplicar sin registrar datos confidenciales:

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

Envíe estos registros estructurados a su canalización existente (Datadog, Grafana Loki, Cloudflare Logpush). Cree alertas para patrones inusuales: un solo agente que realiza 10 veces su volumen de llamadas normal, o solo lectura agente que intenta llamar herramientas destructivas.

7. Fijar definiciones de herramientas y verificar la integridad

El informe Barracuda encontró que los atacantes inyectaban definiciones de herramientas maliciosas en los marcos de los agentes a través de dependencias comprometidas. Si alguien modifica el manifiesto de su herramienta MCP (nombres, descripciones o parámetros esquemas), los agentes llamarán a herramientas con un comportamiento diferente al previsto.

Hash el manifiesto de su herramienta en el momento de la compilación. Al inicio, vuelva a calcular el hash y compare:

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

Genera el hash con la API de Botoi

Para entornos de CI o tiempos de ejecución perimetrales sin 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"
  }
}

Almacene el hash esperado como una variable de entorno. Compárelo en el momento de la implementación. Si los hashes divergen, bloquear el despliegue.

8. Operaciones destructivas de sandbox

Las herramientas que escriben datos, desencadenan efectos secundarios o contactan servicios externos necesitan un flujo de confirmación. No permita que un agente cree 1000 pegados ni active webhooks sin una revisión humana.

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

El patrón es sencillo: las herramientas destructivas devuelven una vista previa en la primera llamada. El agente muestra la vista previa al usuario. Sólo después de que el usuario confirma, el agente envía una segunda llamada con "confirmed": true.

Para herramientas que contactan servicios externos (openWorldHint: true), considere agregar un tiempo de espera y un disyuntor. Si una API externa es lenta o está lenta, su servidor MCP no debería Cuelgue para siempre esperando una respuesta.

Cómo aplica el servidor MCP de Botoi estas comprobaciones

El servidor MCP de Botoi en api.botoi.com/mcp sirve como referencia de trabajo para esto lista de verificación. Así es como se asigna cada elemento:

Puede conectarse al servidor MCP de Botoi desde Claude Desktop, Claude Code, Cursor, VS Code o Windsurf. El Página de configuración de MCP Tiene la configuración para cada cliente.

Lista de verificación de seguridad de su servidor MCP

Aquí está la lista de verificación completa, condensada. Imprímelo, fíjalo o pégalo en el runbook de tu equipo:

• Requerir autenticación en cada punto final de MCP (token de portador, clave API o JWT)
• Asigne cada clave API a una lista permitida de herramientas permitidas
• Valide cada entrada de herramienta con esquemas Zod o esquema JSON antes de la ejecución
• Anota cada herramienta con readOnlyHint, destructiveHint, idempotentHint, y openWorldHint
• Límite de velocidad por identidad de agente, no por IP; use límites máximos diarios y de ráfaga
• Registre cada invocación de herramienta con ID de agente, nombre de herramienta, hash de entrada, duración y estado.
• Hash el manifiesto de su herramienta en el momento de la compilación; verificar al inicio y bloquear implementaciones manipuladas
• Devolver vistas previas de herramientas destructivas; Requerir confirmación explícita antes de ejecutar.

Se enviarán 43 marcos de agentes con vulnerabilidades integradas en 2026. Los servidores MCP son el próximo objetivo. Las ocho comprobaciones anteriores no harán que su servidor sea invulnerable, pero cerrarán las brechas que los atacantes pueden Explotar primero: puntos finales abiertos, entradas no validadas e invocaciones invisibles.