Tool-Berechtigungen für KI-Agenten

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Tool-Berechtigungen für KI-Agenten behandelt

• Wie Du Tool-Berechtigungen für KI-Agenten konfigurierst.
• Wie Du Least Privilege, Rollen und Freigaben umsetzt.
• Wie Du Tool-Zugriff einschränkst, überwachst und auditierst.
• Praxisbeispiele für Dateisystem-, Netzwerk- und Shell-Tools.
• Best Practices für Sicherheit, Hierarchie und Human-in-the-Loop.

Einleitung: Tool-Berechtigungen für KI-Agenten verständlich erklärt

KI-Agenten rufen Tools auf, um Aufgaben zu lösen: Dateien lesen, E-Mails verschicken, Shell-Befehle ausführen. Jedes Tool ist eine Fähigkeit, die der Agent nutzen kann. Wenn der Agent zu viele Tools hat, kann er zu viel tun. Wenn er zu wenige hat, kann er seine Aufgabe nicht lösen. Tool-Berechtigungen sind das Konzept, um den Zugriff des Agenten auf genau die Tools zu beschränken, die er braucht.

Dieser Artikel richtet sich an Entwicklerinnen und Entwickler, die KI-Agenten bauen und absichern wollen. Du solltest verstehen, was KI-Agenten sind und wie Function Calling funktioniert. Grundlagen der Python-Programmierung findest Du auf IRC-Coding.de.

Warum brauche ich Tool-Berechtigungen?

Stell Dir vor, Du baust einen Agenten, der E-Mails beantworten soll. Du gibst ihm Tools für E-Mail-Versand, Dateisystem-Zugriff und Shell-Ausführung. Der Agent soll nur E-Mails beantworten, aber er kann jetzt auch Dateien löschen oder Shell-Befehle ausführen. Wenn der Agent manipuliert wird (Prompt Injection), kann er schädliche Aktionen ausführen.

Tool-Berechtigungen lösen das Problem: Der Agent bekommt nur die Tools, die er für seine Aufgabe braucht. Ein E-Mail-Agent bekommt E-Mail-Tools, kein Shell-Tool. Ein Datei-Agent bekommt Lese-Zugriff, keinen Schreib-Zugriff. Das Prinzip heißt Least Privilege.

Tool-Berechtigungen für KI-Agenten kurz erklärt

Tool-Berechtigungen sind das Konzept, den Tool-Zugriff eines Agenten zu beschränken. Der Agent bekommt nur die Tools, die er für seine Aufgabe braucht, mit den minimalen Rechten, die notwendig sind. Das Prinzip heißt Least Privilege: So viele Rechte wie nötig, so wenige wie möglich.

Der Kerngedanke lautet: Ein Agent, der nur E-Mails beantworten soll, braucht keinen Shell-Zugriff.

Für wen ist dieser Artikel gedacht?

• Entwicklerinnen und Entwickler, die KI-Agenten bauen und absichern.
• Sicherheits-Verantwortliche, die Agenten-Berechtigungen definieren.
• Systemadministratoren, die Agenten in Produktion betreuen.
• Teams, die Agenten sicher einführen wollen.

Vorkenntnisse in Python, KI-Agenten und Function Calling sind erforderlich.

Wichtige Begriffe rund um Tool-Berechtigungen

• Tool-Berechtigung - Recht, ein bestimmtes Tool zu nutzen. Wann nützlich: Grundkonzept.
• Least Privilege - Prinzip: minimale Rechte. Wann nützlich: Sicherheitsstandard.
• Rolle - Menge von Berechtigungen. Wann nützlich: für mehrere Agenten.
• Freigabe - Menschliche Bestätigung für Tool-Aufruf. Wann nützlich: für kritische Aktionen.
• Audit - Protokollierung aller Tool-Aufrufe. Wann nützlich: für Nachvollziehbarkeit.
• KI-Agenten - Programme, die Tools aufrufen. Wann nützlich: was abgesichert wird.
• Function Calling - Strukturierte KI-Antworten. Wann nützlich: wie Tools aufgerufen werden.
• Menschliche Freigabe - Human-in-the-Loop. Wann nützlich: für kritische Aktionen.
• Sandbox-Umgebungen - Isolierte Ausführung. Wann nützlich: für Code-Agenten.
• Prompt Injection Schutz - Schutz vor Manipulation. Wann nützlich: weil Berechtigungen allein nicht reichen.

Berechtigungsstufen

Tools können in verschiedenen Stufen angeboten werden:

Berechtigungskonzept implementieren

Tool-Definition mit Berechtigungen

from enum import Enum

class Permission(Enum):
    ALLOWED = "allowed"
    REQUIRES_APPROVAL = "requires_approval"
    RESTRICTED = "restricted"
    DISABLED = "disabled"

class Tool:
    def __init__(self, name, description, permission, parameters=None, restrictions=None):
        self.name = name
        self.description = description
        self.permission = permission
        self.parameters = parameters or {}
        self.restrictions = restrictions or {}

    def can_execute(self, parameters=None):
        if self.permission == Permission.DISABLED:
            return False
        if self.permission == Permission.RESTRICTED:
            return self.check_restrictions(parameters)
        return True

    def check_restrictions(self, parameters):
        for key, allowed_values in self.restrictions.items():
            if key in parameters:
                if parameters[key] not in allowed_values:
                    return False
        return True

Rollen definieren

class Role:
    def __init__(self, name, tools):
        self.name = name
        self.tools = {t.name: t for t in tools}

    def get_tool(self, tool_name):
        return self.tools.get(tool_name)

    def can_use(self, tool_name):
        return tool_name in self.tools and self.tools[tool_name].permission != Permission.DISABLED

# Rollen definieren
email_agent_role = Role("email_agent", [
    Tool("read_email", "E-Mail lesen", Permission.ALLOWED),
    Tool("send_email", "E-Mail verschicken", Permission.REQUIRES_APPROVAL),
    Tool("classify_email", "E-Mail klassifizieren", Permission.ALLOWED),
    Tool("execute_shell", "Shell-Befehl ausführen", Permission.DISABLED),
])

file_agent_role = Role("file_agent", [
    Tool("read_file", "Datei lesen", Permission.RESTRICTED, restrictions={
        "path": ["/data/", "/tmp/"]
    }),
    Tool("write_file", "Datei schreiben", Permission.REQUIRES_APPROVAL, restrictions={
        "path": ["/data/"]
    }),
    Tool("delete_file", "Datei löschen", Permission.REQUIRES_APPROVAL),
    Tool("execute_shell", "Shell-Befehl ausführen", Permission.DISABLED),
])

Agent mit Berechtigungen

class SecureAgent:
    def __init__(self, role, model="llama3.1"):
        self.role = role
        self.model = model

    def call_tool(self, tool_name, parameters):
        # Berechtigung prüfen
        tool = self.role.get_tool(tool_name)
        if not tool:
            raise PermissionError(f"Tool {tool_name} nicht in Rolle {self.role.name}")

        if not tool.can_execute(parameters):
            raise PermissionError(f"Tool {tool_name} darf mit diesen Parametern nicht ausgeführt werden")

        # Freigabe nötig?
        if tool.permission == Permission.REQUIRES_APPROVAL:
            approved = request_human_approval(tool_name, parameters)
            if not approved:
                return {"status": "denied", "reason": "Menschliche Freigabe verweigert"}

        # Tool ausführen
        result = execute_tool(tool_name, parameters)

        # Audit-Log
        audit_log(tool_name, parameters, result)

        return result

Praxisbeispiel 1: E-Mail-Agent mit Berechtigungen

# Rolle definieren
email_role = Role("email_agent", [
    Tool("read_email", "E-Mail lesen", Permission.ALLOWED),
    Tool("send_email", "E-Mail verschicken", Permission.REQUIRES_APPROVAL),
    Tool("delete_email", "E-Mail löschen", Permission.REQUIRES_APPROVAL),
    Tool("execute_shell", "Shell", Permission.DISABLED),
    Tool("read_file", "Datei lesen", Permission.RESTRICTED, restrictions={
        "path": ["/data/templates/"]
    }),
])

# Agent erstellen
agent = SecureAgent(email_role)

# Erlaubt: E-Mail lesen
agent.call_tool("read_email", {"id": 123})

# Erlaubt mit Freigabe: E-Mail verschicken
agent.call_tool("send_email", {"to": "user@example.com", "subject": "Test"})

# Verboten: Shell ausführen
try:
    agent.call_tool("execute_shell", {"command": "rm -rf /"})
except PermissionError:
    print("Shell-Ausführung verboten")

Praxisbeispiel 2: Datei-Agent mit Pfad-Einschränkung

file_role = Role("file_agent", [
    Tool("read_file", "Datei lesen", Permission.RESTRICTED, restrictions={
        "path": ["/data/", "/tmp/"]
    }),
    Tool("write_file", "Datei schreiben", Permission.RESTRICTED, restrictions={
        "path": ["/data/"]
    }),
])

agent = SecureAgent(file_role)

# Erlaubt: Datei in /data/ lesen
agent.call_tool("read_file", {"path": "/data/document.txt"})

# Verboten: Datei in /etc/ lesen
try:
    agent.call_tool("read_file", {"path": "/etc/passwd"})
except PermissionError:
    print("Zugriff auf /etc/ verboten")

Praxisbeispiel 3: Code-Agent mit Sandbox

code_role = Role("code_agent", [
    Tool("write_code", "Code schreiben", Permission.ALLOWED, restrictions={
        "language": ["python", "javascript"]
    }),
    Tool("run_code", "Code ausführen", Permission.REQUIRES_APPROVAL, restrictions={
        "sandbox": ["docker", "firejail"]
    }),
    Tool("read_file", "Datei lesen", Permission.RESTRICTED, restrictions={
        "path": ["/workspace/"]
    }),
    Tool("write_file", "Datei schreiben", Permission.RESTRICTED, restrictions={
        "path": ["/workspace/"]
    }),
])

# Code-Ausführung nur in Sandbox
agent = SecureAgent(code_role)
agent.call_tool("run_code", {
    "code": "print('Hallo')",
    "sandbox": "docker"
})

Siehe Sandbox-Umgebungen für Details.

Human-in-the-Loop für kritische Aktionen

def request_human_approval(tool_name, parameters):
    print(f"\n--- Freigabe erforderlich ---")
    print(f"Tool: {tool_name}")
    print(f"Parameter: {parameters}")
    print(f"Freigeben? (y/n): ")

    response = input().strip().lower()
    return response == "y"

# In der Praxis: Web-UI, Slack-Bot, E-Mail-Bestätigung

Siehe Menschliche Freigabe für Details.

Audit-Logging für Tool-Aufrufe

import json
from datetime import datetime

def audit_log(tool_name, parameters, result, agent_id="default"):
    entry = {
        "timestamp": datetime.now().isoformat(),
        "agent_id": agent_id,
        "tool": tool_name,
        "parameters": parameters,
        "result_status": result.get("status", "unknown"),
        "approved": True
    }
    with open("/var/log/agent_audit.log", "a") as f:
        f.write(json.dumps(entry) + "\n")

Siehe Protokollierung für Details.

Sicherheitshinweise

• Least Privilege: Gib dem Agenten nur die Tools, die er braucht. Kein Shell-Zugriff für E-Mail-Agenten.
• Freigabe für kritische Aktionen: Löschen, Senden, Ausführen sollten Freigabe erfordern.
• Audit-Logging: Protokolliere alle Tool-Aufrufe mit Parametern und Ergebnissen.
• Prompt Injection Schutz: Berechtigungen allein reichen nicht. Schütze vor Manipulation. Siehe Prompt Injection Schutz.
• Sandbox für Code-Ausführung: Code-Agenten müssen in Sandbox laufen. Siehe Sandbox-Umgebungen.
• Parameter-Validierung: Prüfe Tool-Parameter, nicht nur Tool-Namen. Pfad-Einschränkungen, Command-Whitelists.
• Regelmäßige Überprüfung: Überprüfe Berechtigungen regelmäßig. Braucht der Agent noch alle Tools?

Typische Stolpersteine

• Zu viele Tools: Agent bekommt alle Tools, weil es einfacher ist. Sicherheitsrisiko.
• Keine Freigabe für kritische Aktionen: Löschen ohne Freigabe ist gefährlich.
• Keine Parameter-Validierung: Tool ist erlaubt, aber Parameter nicht geprüft. Pfad-Traversal möglich.
• Kein Audit-Logging: Ohne Logs keine Nachvollziehbarkeit.
• Berechtigungen nie überprüft: Agent braucht Tool nicht mehr, aber behält es.
• Prompt Injection vergessen: Agent wird manipuliert, Berechtigungen umgangen.

Weiterführende Links und Infos zu Tool-Berechtigungen

• KI-Agenten Grundlagen - Was KI-Agenten sind.
• Function Calling - Wie Tools aufgerufen werden.
• Menschliche Freigabe - Human-in-the-Loop.
• Sandbox-Umgebungen - Isolierte Ausführung.
• Prompt Injection Schutz - Schutz vor Manipulation.
• Guardrails konfigurieren - Guardrails.
• Protokollierung - Audit-Logging.
• Least Privilege - Prinzip minimaler Rechte.

Key Takeaways:

• Tool-Berechtigungen beschränken den Tool-Zugriff eines Agenten.
• Least Privilege: So viele Rechte wie nötig, so wenige wie möglich.
• Freigabe für kritische Aktionen: Löschen, Senden, Ausführen.
• Parameter-Validierung: Nicht nur Tool-Namen, auch Parameter prüfen.
• Audit-Logging für alle Tool-Aufrufe.

FAQ: Tool-Berechtigungen für KI-Agenten - Typische Fragen

Quellen und weiterführende Literatur

• OWASP LLM Top 10 - Sicherheitsrisiken bei LLMs.
• NIST AI Risk Management Framework - KI-Risiko-Management.
• MCP Sicherheit - Model Context Protocol.
• Ollama - Lokaler Modellserver.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert