Agenten-Berechtigungen: Zugriffskontrolle für KI-Agenten

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Agenten-Berechtigungen behandelt

• Wie Berechtigungen für KI-Agenten funktionieren.
• Wie Du Least Privilege für Agenten implementierst.
• Wie Du Tool-, System- und Daten-Berechtigungen kontrollierst.
• Praxisbeispiele für verschiedene Agenten-Rollen.
• Best Practices für Sicherheit und Compliance.

Einleitung: Agenten-Berechtigungen verständlich erklärt

Agenten-Berechtigungen bestimmen, was ein KI-Agent darf: Welche Tools, welche Systeme, welche Daten, welche Aktionen. Nicht „alles für alle”, sondern „nur nötige für die Aufgabe”. Least Privilege für Agenten.

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

Warum brauche ich Agenten-Berechtigungen?

Stell Dir vor, Dein Agent hat Zugriff auf alle Systeme. Er könnte Dateien löschen, Daten exfiltrieren, Systeme manipulieren. Mit Berechtigungen: Er kann nur lesen, was er braucht, nur schreiben, wo er soll, nur ausführen, was erlaubt ist.

Agenten-Berechtigungen kurz erklärt

Berechtigungen = Was darf der Agent? Tools (read/write/execute), Systeme (Dateisystem, DB, API), Daten (welche Tabellen, welche Pfade). Least Privilege: Nur nötige Berechtigungen.

Der Kerngedanke lautet: Kontrolliere, was der Agent kann.

Für wen ist dieser Artikel gedacht?

• Sicherheits-Bewusste, die Agenten absichern.
• Admins, die Zugriffskontrolle implementieren.
• Entwickler, die sichere Agenten bauen.
• Compliance-Verantwortliche, die Richtlinien durchsetzen.

Wichtige Begriffe

• Least Privilege - Minimale Berechtigungen. Wann nützlich: für Sicherheit.
• Tool-Berechtigungen - Tool-Zugriff. Wann nützlich: für Werkzeuge.
• MCP-Berechtigungen - MCP-Zugriff. Wann nützlich: für MCP-Tools.
• Prompt Injection - Angriffe. Wann nützlich: für Risiken.
• Audit Logging - Protokollierung. Wann nützlich: für Compliance.

Berechtigungs-Modell für Agenten

# Berechtigungen für verschiedene Agenten-Rollen
agent_permissions = {
    "research_agent": {
        "description": "Nur Recherche, keine Änderungen",
        "permissions": {
            "filesystem": {"read": True, "write": False, "delete": False},
            "database": {"read": True, "insert": False, "update": False, "delete": False},
            "web_search": {"search": True},
            "api": {"get": True, "post": False}
        }
    },
    "writer_agent": {
        "description": "Kann lesen und schreiben",
        "permissions": {
            "filesystem": {"read": True, "write": True, "delete": False},
            "database": {"read": True, "insert": True, "update": False, "delete": False},
            "api": {"get": True, "post": True}
        }
    },
    "admin_agent": {
        "description": "Volle Kontrolle (mit Freigabe für kritische Aktionen)",
        "permissions": {
            "filesystem": {"read": True, "write": True, "delete": True},
            "database": {"read": True, "insert": True, "update": True, "delete": True},
            "api": {"get": True, "post": True, "put": True, "delete": True},
            "system": {"execute": True}
        },
        "requires_approval": ["delete", "system.execute"]
    }
}

Praxisbeispiel 1: Tool-Berechtigungen

class AgentPermissions:
    """Berechtigungen für Agenten"""

    def __init__(self, role):
        self.role = role
        self.permissions = self.load_permissions(role)

    def can_use_tool(self, tool_name, action):
        """Darf der Agent das Tool nutzen?"""
        if tool_name not in self.permissions:
            return False

        if action not in self.permissions[tool_name]:
            return False

        return self.permissions[tool_name][action]

    def check_tool_permission(self, tool_name, action, context=None):
        """Berechtigung prüfen (mit Kontext)"""
        # Basis-Berechtigung
        if not self.can_use_tool(tool_name, action):
            raise PermissionError(f"Agent '{self.role}' cannot use '{tool_name}.{action}'")

        # Kontext-basierte Prüfung
        if context:
            # Pfad-Restrictions für Dateisystem
            if tool_name == "filesystem" and "path" in context:
                if not self.is_path_allowed(context["path"]):
                    raise PermissionError(f"Path '{context['path']}' not allowed")

            # Table-Restrictions für Datenbank
            if tool_name == "database" and "table" in context:
                if not self.is_table_allowed(context["table"]):
                    raise PermissionError(f"Table '{context['table']}' not allowed")

        return True

Praxisbeispiel 2: Path-Restrictions

def is_path_allowed(self, path):
    """Pfad-Berechtigung prüfen"""
    allowed_paths = self.permissions.get("allowed_paths", [])
    denied_paths = self.permissions.get("denied_paths", [])

    # Denied zuerst prüfen
    for denied in denied_paths:
        if path.startswith(denied):
            return False

    # Allowed prüfen
    for allowed in allowed_paths:
        if path.startswith(allowed):
            return True

    return False  # Default: deny

Praxisbeispiel 3: Kritische Aktionen mit Freigabe

def execute_with_approval(self, action, params):
    """Kritische Aktion mit menschlicher Freigabe"""
    if action in self.permissions.get("requires_approval", []):
        # Freigabe anfordern
        approval = self.request_approval(action, params)

        if not approval["approved"]:
            raise PermissionError(f"Action '{action}' requires approval")

        # Log für Audit
        self.log_approval(action, params, approval)

    # Aktion ausführen
    return self.execute(action, params)

Sicherheitshinweise

• Least Privilege: Nur nötige Berechtigungen. Siehe Tool-Berechtigungen.
• Path-Restrictions: Für Dateisystem: Nur erlaubte Pfade.
• Table-Restrictions: Für Datenbank: Nur erlaubte Tabellen.
• Menschliche Freigabe: Für kritische Aktionen (delete, system.execute).
• 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.
• Keine Path-Restrictions: Agent sollte nicht auf alle Pfade zugreifen können.
• Keine Freigabe für kritische Aktionen: Delete, System-Execute sollten Freigabe brauchen.
• Berechtigungen nicht geprüft: Vor jeder Aktion prüfen.
• Kein Audit: Berechtigungsverletzungen sollten geloggt werden.

Weiterführende Links

• Tool-Berechtigungen - Tool-Zugriff.
• MCP-Berechtigungen - MCP-Zugriff.
• Agenten-Sicherheit - Übersicht.
• Prompt Injection - Angriffe.
• Audit Logging - Protokollierung.
• Menschliche Freigabe - Freigabe.

Key Takeaways:

• Agenten-Berechtigungen: Least Privilege für Tools, Systeme, Daten.
• Verschiedene Rollen: research (read-only), writer (read+write), admin (full mit Freigabe).
• Path-Restrictions für Dateisystem, Table-Restrictions für Datenbank.
• Kritische Aktionen brauchen menschliche Freigabe.
• Audit-Log für alle Berechtigungsverletzungen.

FAQ

Quellen und weiterführende Literatur

• Least Privilege - Sicherheitsprinzip.
• RBAC - Role-Based Access Control.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert