MCP-Sicherheit: Tools sicher integrieren

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über MCP-Sicherheit behandelt

• Wie Du MCP-Tools sicher für KI-Agenten integrierst.
• Wie Du Tool-Validierung und Injection-Schutz implementierst.
• Wie Du Sandboxing für kritische Tools nutzt.
• Praxisbeispiele für sichere Tool-Integration.
• Best Practices für Sicherheit und Risikominimierung.

Einleitung: MCP-Sicherheit verständlich erklärt

MCP-Sicherheit bedeutet: Deine Tools sind sicher gegen Missbrauch, Injection und unbefugte Zugriffe. Ein Agent sollte nicht beliebige Tools aufrufen, beliebige Parameter senden oder sensible Daten exfiltrieren können.

Dieser Artikel richtet sich an Anwender, die MCP-Tools sicher integrieren wollen. Grundlagen findest Du in MCP und Agenten-Sicherheit.

Warum brauche ich MCP-Sicherheit?

Stell Dir vor, Dein Agent hat ein Tool „execute_command”. Ohne Sicherheit: Er könnte rm -rf / ausführen. Mit Sicherheit: Nur erlaubte Commands, nur erlaubte Parameter, alle Aktionen geloggt. MCP-Sicherheit verhindert Missbrauch.

MCP-Sicherheit kurz erklärt

MCP-Tool + Sicherheit = Input-Validierung, Berechtigungen, Sandboxing, Audit-Log. Agent kann nur erlaubte Tools, erlaubte Parameter, erlaubte Aktionen ausführen.

Der Kerngedanke lautet: Verhindere Missbrauch durch Validierung und Kontrolle.

Für wen ist dieser Artikel gedacht?

• Sicherheits-Bewusste, die Agenten absichern.
• Entwickler, die sichere Tools 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.
• Prompt Injection - Angriffe. Wann nützlich: für Risiken.
• Sandboxing - Isolation. Wann nützlich: für kritische Tools.
• Audit Logging - Protokollierung. Wann nützlich: für Nachvollziehbarkeit.

Sicherheits-Schichten

Agent-Anfrage
    │
    ▼
1. Input-Validierung
    ├─ Parameter-Typen prüfen
    ├─ Wertebereiche prüfen
    └─ Injection-Patterns erkennen
    │
    ▼
2. Berechtigungen
    ├─ Tool erlaubt?
    ├─ Aktion erlaubt?
    └─ Scope erlaubt?
    │
    ▼
3. Sandboxing (für kritische Tools)
    ├─ Isolierte Umgebung
    ├─ Keine System-Zugriffe
    └─ Timeout-Limits
    │
    ▼
4. Audit-Log
    ├─ Wer? Was? Wann?
    ├─ Erfolg? Fehler?
    └─ Alert bei Anomalien
    │
    ▼
Tool-Ausführung

Praxisbeispiel 1: Input-Validierung

import re
from typing import Any

class SecureTool:
    """Sicheres Tool mit Input-Validierung"""

    def validate_input(self, param_name: str, value: Any, param_type: type):
        """Input validieren"""
        # Typ prüfen
        if not isinstance(value, param_type):
            raise ValidationError(f"{param_name} must be {param_type.__name__}")

        # Injection-Patterns prüfen
        if isinstance(value, str):
            dangerous_patterns = [
                r"rm\s+-rf", r"sudo", r"eval\(", r"exec\(",
                r"__import__", r"subprocess", r"os\.system"
            ]
            for pattern in dangerous_patterns:
                if re.search(pattern, value, re.IGNORECASE):
                    raise SecurityError(f"Dangerous pattern detected: {pattern}")

        return True

    def safe_execute(self, command: str):
        """Sichere Ausführung"""
        # Validierung
        self.validate_input("command", command, str)

        # Nur erlaubte Commands
        allowed_commands = ["ls", "pwd", "cat", "grep", "find"]
        cmd = command.split()[0]
        if cmd not in allowed_commands:
            raise PermissionError(f"Command '{cmd}' not allowed")

        # Ausführen
        import subprocess
        result = subprocess.run(
            command.split(),
            capture_output=True,
            text=True,
            timeout=10
        )
        return result.stdout

Praxisbeispiel 2: Sandboxing

import docker

class SandboxedTool:
    """Tool in Sandbox"""

    def __init__(self):
        self.client = docker.from_env()

    def execute_in_sandbox(self, code: str):
        """Code in Sandbox ausführen"""
        # Docker-Container für Isolation
        container = self.client.containers.run(
            image="python:3.11-slim",
            command=f"python -c '{code}'",
            remove=True,
            network_disabled=True,  # Kein Netzwerk
            mem_limit="128m",       # Memory-Limit
            cpu_period=100000,
            cpu_quota=50000,        # CPU-Limit
            security_opt=["no-new-privileges"],
            cap_drop=["ALL"]        # Keine Capabilities
        )

        return container.decode("utf-8")

Praxisbeispiel 3: Injection-Schutz

class InjectionProtectedTool:
    """Tool mit Injection-Schutz"""

    def sanitize_input(self, user_input: str) -> str:
        """Input sanitizen"""
        # Gefährliche Zeichen entfernen/escapen
        sanitized = user_input
        sanitized = sanitized.replace(";", "")
        sanitized = sanitized.replace("|", "")
        sanitized = sanitized.replace("&", "")
        sanitized = sanitized.replace("`", "")
        sanitized = sanitized.replace("$(", "")
        sanitized = sanitized.replace("${", "")

        return sanitized

    def safe_query(self, table: str, filters: dict):
        """Sichere Datenbank-Abfrage"""
        # Table-Name validieren (keine SQL-Injection)
        if not re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', table):
            raise ValidationError("Invalid table name")

        # Filters sanitizen
        sanitized_filters = {}
        for key, value in filters.items():
            sanitized_filters[key] = self.sanitize_input(str(value))

        # Parameterisierte Query
        return self.db.query(table, sanitized_filters)

Praxisbeispiel 4: Audit-Log

import logging
from datetime import datetime

class AuditedTool:
    """Tool mit Audit-Log"""

    def __init__(self):
        self.logger = logging.getLogger("mcp_tool")

    def log_tool_call(self, tool_name, params, result, status):
        """Tool-Aufruf protokollieren"""
        self.logger.info({
            "timestamp": datetime.now().isoformat(),
            "tool": tool_name,
            "params": params,
            "result": str(result)[:1000],  # Truncate für Log
            "status": status
        })

    def execute_with_audit(self, tool_name, params):
        """Tool mit Audit ausführen"""
        try:
            result = self.execute(tool_name, params)
            self.log_tool_call(tool_name, params, result, "success")
            return result
        except Exception as e:
            self.log_tool_call(tool_name, params, str(e), "error")
            raise

Sicherheitshinweise

• Input-Validierung: Alle Parameter validieren (Type, Format, Range).
• Injection-Schutz: SQL-Injection, Command-Injection, Code-Injection verhindern.
• Sandboxing: Für kritische Tools (Code-Ausführung) Sandboxing nutzen. Siehe Sandboxing.
• Berechtigungen: Least Privilege für alle Tools. Siehe Tool-Berechtigungen.
• Audit: Alle Tool-Aufrufe loggen. Siehe Audit Logging.
• Rate-Limiting: Für externe APIs Rate-Limits setzen.

Typische Stolpersteine

• Keine Input-Validierung: Agent kann beliebige Parameter senden. Immer validieren.
• String-Concatenation: Für SQL/Commands: Parameterisierte Queries, keine String-Concatenation.
• Kein Sandboxing: Kritische Tools (Code-Ausführung) ohne Isolation = gefährlich.
• Zu viele Berechtigungen: Agent sollte nicht alle Tools nutzen können.
• Kein Audit: Ohne Log weißt Du nicht, was der Agent gemacht hat.

Weiterführende Links

• MCP - Model Context Protocol.
• MCP-Berechtigungen - Zugriffskontrolle.
• Eigene MCP-Tools - Tools bauen.
• Tool-Berechtigungen - Berechtigungen.
• Sandboxing - Isolation.
• Prompt Injection - Angriffe.
• Audit Logging - Protokollierung.

Key Takeaways:

• MCP-Sicherheit: Input-Validierung, Berechtigungen, Sandboxing, Audit.
• Injection-Schutz: SQL, Command, Code-Injection verhindern.
• Sandboxing für kritische Tools (Code-Ausführung).
• Least Privilege für alle Tools.
• Audit-Log für Nachvollziehbarkeit.

FAQ

Quellen und weiterführende Literatur

• MCP - Model Context Protocol.
• OWASP - Security-Praktiken.
• Prompt Injection - Angriffe verstehen.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert