MCP-Berechtigungen: Zugriffskontrolle für Tools

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über MCP-Berechtigungen behandelt

• Wie MCP-Berechtigungen für KI-Agenten funktionieren.
• Wie Du Zugriffskontrolle für MCP-Tools implementierst.
• Wie Du Agenten nur nötige Berechtigungen gibst.
• Praxisbeispiele für Dateisystem-, Datenbank- und API-Berechtigungen.
• Best Practices für Sicherheit und Least Privilege.

Einleitung: MCP-Berechtigungen verständlich erklärt

MCP (Model Context Protocol) verbindet Agenten mit Tools. Berechtigungen bestimmen, welche Tools ein Agent nutzen darf und was er damit tun kann. Nicht „alle Tools für alle”, sondern „nur nötige Tools, nur nötige Aktionen”.

Dieser Artikel richtet sich an Anwender, die MCP-Berechtigungen für Agenten konfigurieren wollen. Grundlagen findest Du in MCP und Tool-Berechtigungen.

Warum brauche ich MCP-Berechtigungen?

Stell Dir vor, Dein Agent hat Zugriff auf das Dateisystem. Ohne Berechtigungen: Er kann alle Dateien lesen, schreiben, löschen. Mit Berechtigungen: Er kann nur in /data lesen, nicht schreiben, nicht löschen. Least Privilege: Nur nötige Berechtigungen.

MCP-Berechtigungen kurz erklärt

MCP-Tool hat Berechtigungen: read, write, execute, delete. Agent bekommt nur nötige Berechtigungen für seine Aufgabe. Ein Recherche-Agent braucht read, kein write. Ein Admin-Agent braucht write, aber nur für bestimmte Pfade.

Der Kerngedanke lautet: Least Privilege, nur nötige Berechtigungen.

Für wen ist dieser Artikel gedacht?

• Sicherheits-Bewusste, die Agenten absichern wollen.
• Entwickler, die MCP-Tools mit Berechtigungen bauen.
• Admins, die Zugriffskontrolle implementieren.
• DevOps, die Agenten sicher deployen.

Wichtige Begriffe

• MCP - Model Context Protocol. Wann nützlich: für Tool-Integration.
• Tool-Berechtigungen - Zugriffskontrolle. Wann nützlich: für Sicherheit.
• Least Privilege - Minimale Berechtigungen. Wann nützlich: für Sicherheit.
• Prompt Injection - Angriffe. Wann nützlich: für Risiken.

Berechtigungs-Modell

# MCP-Tool-Berechtigungen definieren
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  # Requests pro Stunde
    }
}

Praxisbeispiel 1: Dateisystem-Berechtigungen

class FileSystemTool:
    """Dateisystem-Tool mit Berechtigungen"""

    def __init__(self):
        self.permissions = {
            "read": True,
            "write": True,
            "delete": False,  # Keine Lösch-Berechtigung
            "allowed_paths": ["/data", "/tmp"],
            "denied_paths": ["/etc", "/var", "/root", "/home"]
        }

    def check_permission(self, action, path):
        """Berechtigung prüfen"""
        # Aktion erlaubt?
        if not self.permissions.get(action, False):
            raise PermissionError(f"Action '{action}' not allowed")

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

        # Pfad verboten?
        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):
        """Datei lesen (mit Berechtigungsprüfung)"""
        self.check_permission("read", path)
        with open(path) as f:
            return f.read()

    def write_file(self, path, content):
        """Datei schreiben (mit Berechtigungsprüfung)"""
        self.check_permission("write", path)
        with open(path, "w") as f:
            f.write(content)

Praxisbeispiel 2: Datenbank-Berechtigungen

class DatabaseTool:
    """Datenbank-Tool mit Berechtigungen"""

    def __init__(self):
        self.permissions = {
            "read": True,
            "insert": True,
            "update": False,  # Keine Update-Berechtigung
            "delete": False,  # Keine Delete-Berechtigung
            "allowed_tables": ["users", "logs", "events"],
            "denied_tables": ["admin", "secrets", "credentials"]
        }

    def query(self, table, filters):
        """Abfrage mit Berechtigungsprüfung"""
        # Tabelle erlaubt?
        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")

        # Query ausführen
        return self.db.query(table, filters)

Praxisbeispiel 3: API-Berechtigungen

class APITool:
    """API-Tool mit Berechtigungen"""

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

    def call_api(self, method, endpoint, data=None):
        """API-Aufruf mit Berechtigungsprüfung"""
        # Methode erlaubt?
        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")

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

        # Rate-Limit prüfen
        if self.request_count >= self.permissions["rate_limit"]:
            raise RateLimitError("Rate limit exceeded")

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

Berechtigungen pro Agent

# Verschiedene Agenten, verschiedene Berechtigungen
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}
        }
    }
}

Sicherheitshinweise

• Least Privilege: Nur nötige Berechtigungen. Siehe Tool-Berechtigungen.
• Path-Restrictions: Für Dateisystem: Nur erlaubte Pfade, keine Root-Pfade.
• Rate-Limiting: Für APIs: Rate-Limits verhindern Missbrauch.
• Audit: Alle Berechtigungsverletzungen loggen. Siehe Audit Logging.
• Prompt Injection: Agenten können versuchen, Berechtigungen zu umgehen. Siehe Prompt Injection.

Typische Stolpersteine

• Zu viele Berechtigungen: Agent sollte nicht alle Berechtigungen haben. Least Privilege.
• Keine Path-Restrictions: Agent sollte nicht auf alle Pfade zugreifen können.
• Keine Rate-Limits: Ohne Rate-Limits kann Agent APIs überlasten.
• Berechtigungen nicht geprüft: Berechtigungen sollten vor jeder Aktion geprüft werden.
• Kein Audit: Berechtigungsverletzungen sollten geloggt werden.

Weiterführende Links

• MCP - Model Context Protocol.
• MCP-Dateisystem - Dateisystem-MCP.
• Eigene MCP-Tools - Tools bauen.
• MCP-Sicherheit - Sicherheit.
• Tool-Berechtigungen - Berechtigungen.
• Audit Logging - Protokollierung.

Key Takeaways:

• MCP-Berechtigungen: Least Privilege für Tools.
• Dateisystem: Nur erlaubte Pfade, keine Root-Pfade.
• Datenbank: Nur erlaubte Tabellen, keine Admin-Tabellen.
• API: Rate-Limits und Endpoint-Restrictions.
• Audit: Alle Berechtigungsverletzungen loggen.

FAQ

Quellen und weiterführende Literatur

• MCP - Model Context Protocol.
• Least Privilege - Sicherheitsprinzip.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert