Permisos MCP: Control de acceso para herramientas

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Lo que cubre este artículo

• Cómo funcionan los permisos MCP para agentes de IA.
• Cómo implementar control de acceso en herramientas MCP.
• Cómo otorgar a los agentes solo los permisos necesarios.
• Ejemplos prácticos de permisos en sistema de archivos, bases de datos y APIs.
• Mejores prácticas de seguridad y principio de menor privilegio.

Introducción: permisos MCP explicados

MCP (Model Context Protocol) conecta agentes con herramientas. Los permisos determinan qué herramientas puede utilizar un agente y qué acciones puede realizar con ellas. No se trata de “todas las herramientas para todos”, sino de “solo las herramientas necesarias, solo las acciones necesarias”.

Este artículo es para quienes desean configurar permisos MCP en agentes. Encontrarás los conceptos fundamentales en MCP y Permisos de herramientas.

¿Por qué necesito permisos MCP?

Imagina que tu agente tiene acceso al sistema de archivos. Sin permisos: puede leer, escribir y eliminar cualquier archivo. Con permisos: solo puede leer en /data, no puede escribir ni eliminar. Principio de menor privilegio: solo los permisos necesarios.

Permisos MCP en breve

Una herramienta MCP posee permisos: read, write, execute, delete. Un agente recibe solo los permisos necesarios para su tarea. Un agente de investigación necesita read, no write. Un agente administrativo necesita write, pero solo para directorios específicos.

La idea central es el principio de menor privilegio: otorgar solo los permisos indispensables.

Para quién está dirigido este artículo

• Desarrolladores preocupados por la seguridad que quieren asegurar sus agentes.
• Ingenieros que construyen herramientas MCP con permisos.
• Administradores que implementan control de acceso.
• DevOps que despliegan agentes de forma segura.

Términos clave

• MCP - Model Context Protocol. Útil para integración de herramientas.
• Permisos de herramientas - Control de acceso. Útil para seguridad.
• Principio de menor privilegio - Permisos mínimos. Útil para seguridad.
• Inyección de prompts - Ataques. Útil para entender riesgos.

Modelo de permisos

# Definir permisos de herramientas MCP
tools = {
    "filesystem": {
        "permissions": ["read", "write"],
        "allowed_paths": ["/data", "/tmp"],
        "denied_paths": ["/etc", "/var", "/root"]
    },
    "database": {
        "permissions": ["read", "insert"],
        "allowed_tables": ["users", "logs"],
        "denied_tables": ["admin", "secrets"]
    },
    "api": {
        "permissions": ["get", "post"],
        "allowed_endpoints": ["/api/data", "/api/status"],
        "rate_limit": 100  # Solicitudes por hora
    }
}

Ejemplo práctico 1: permisos del sistema de archivos

class FileSystemTool:
    """Herramienta del sistema de archivos con permisos"""

    def __init__(self):
        self.permissions = {
            "read": True,
            "write": True,
            "delete": False,  # Sin permiso para eliminar
            "allowed_paths": ["/data", "/tmp"],
            "denied_paths": ["/etc", "/var", "/root", "/home"]
        }

    def check_permission(self, action, path):
        """Verificar permiso"""
        # ¿Se permite la acción?
        if not self.permissions.get(action, False):
            raise PermissionError(f"Action '{action}' not allowed")

        # ¿Se permite la ruta?
        if not any(path.startswith(p) for p in self.permissions["allowed_paths"]):
            raise PermissionError(f"Path '{path}' not allowed")

        # ¿Está la ruta denegada?
        if any(path.startswith(p) for p in self.permissions["denied_paths"]):
            raise PermissionError(f"Path '{path}' is denied")

        return True

    def read_file(self, path):
        """Leer archivo (con verificación de permiso)"""
        self.check_permission("read", path)
        with open(path) as f:
            return f.read()

    def write_file(self, path, content):
        """Escribir archivo (con verificación de permiso)"""
        self.check_permission("write", path)
        with open(path, "w") as f:
            f.write(content)

Ejemplo práctico 2: permisos de base de datos

class DatabaseTool:
    """Herramienta de base de datos con permisos"""

    def __init__(self):
        self.permissions = {
            "read": True,
            "insert": True,
            "update": False,  # Sin permiso para actualizar
            "delete": False,  # Sin permiso para eliminar
            "allowed_tables": ["users", "logs", "events"],
            "denied_tables": ["admin", "secrets", "credentials"]
        }

    def query(self, table, filters):
        """Ejecutar consulta con verificación de permiso"""
        # ¿Se permite la tabla?
        if table in self.permissions["denied_tables"]:
            raise PermissionError(f"Table '{table}' is denied")

        if table not in self.permissions["allowed_tables"]:
            raise PermissionError(f"Table '{table}' not allowed")

        # Ejecutar consulta
        return self.db.query(table, filters)

Ejemplo práctico 3: permisos de API

class APITool:
    """Herramienta de API con permisos"""

    def __init__(self):
        self.permissions = {
            "get": True,
            "post": True,
            "put": False,
            "delete": False,
            "allowed_endpoints": [
                "/api/data",
                "/api/status",
                "/api/users"
            ],
            "rate_limit": 100  # Solicitudes por hora
        }
        self.request_count = 0

    def call_api(self, method, endpoint, data=None):
        """Llamada a API con verificación de permiso"""
        # ¿Se permite el método?
        if method.lower() not in self.permissions:
            raise PermissionError(f"Method '{method}' not allowed")

        if not self.permissions[method.lower()]:
            raise PermissionError(f"Method '{method}' is denied")

        # ¿Se permite el endpoint?
        if endpoint not in self.permissions["allowed_endpoints"]:
            raise PermissionError(f"Endpoint '{endpoint}' not allowed")

        # Verificar límite de velocidad
        if self.request_count >= self.permissions["rate_limit"]:
            raise RateLimitError("Rate limit exceeded")

        self.request_count += 1
        return self.http_request(method, endpoint, data)

Permisos por agente

# Agentes diferentes, permisos diferentes
agents = {
    "research_agent": {
        "tools": {
            "filesystem": {"read": True, "write": False},
            "web_search": {"search": True},
            "database": {"read": True}
        }
    },
    "writer_agent": {
        "tools": {
            "filesystem": {"read": True, "write": True},
            "database": {"read": True, "insert": True}
        }
    },
    "admin_agent": {
        "tools": {
            "filesystem": {"read": True, "write": True, "delete": True},
            "database": {"read": True, "insert": True, "update": True, "delete": True},
            "system": {"execute": True}
        }
    }
}

Consideraciones de seguridad

• Principio de menor privilegio: solo permisos necesarios. Consulta Permisos de herramientas.
• Restricciones de rutas: para el sistema de archivos, solo rutas permitidas, nunca directorios raíz.
• Rate limiting: para APIs, los límites de velocidad previenen abuso.
• Auditoría: registrar todas las violaciones de permiso. Consulta Audit Logging.
• Inyección de prompts: los agentes pueden intentar eludir permisos. Consulta Inyección de prompts.

Errores comunes

• Demasiados permisos: El agente no debe tener todos los permisos. Privilegio mínimo.
• Sin restricciones de rutas: El agente no debería acceder a todas las rutas.
• Sin rate-limits: Sin limitación de tasa, el agente puede sobrecargar las APIs.
• Permisos no verificados: Los permisos deben comprobarse antes de cada acción.
• Sin auditoría: Las violaciones de permisos deben registrarse.

Enlaces relacionados

• MCP - Model Context Protocol.
• MCP-Dateisystem - MCP para sistemas de archivos.
• Herramientas MCP personalizadas - Construir herramientas.
• Seguridad MCP - Seguridad.
• Permisos de herramientas - Permisos.
• Registro de auditoría - Registro.

Puntos clave:

• Permisos MCP: privilegio mínimo para herramientas.
• Sistema de archivos: solo rutas permitidas, sin rutas raíz.
• Base de datos: solo tablas permitidas, sin tablas administrativas.
• API: rate-limits y restricciones de endpoints.
• Auditoría: registrar todas las violaciones de permisos.

FAQ

Referencias y lecturas adicionales

• MCP - Model Context Protocol.
• Least Privilege - Principio de seguridad.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert