Sicherheit beim Funktionsaufruf
Auf dieser Seite
Niemals blind ausführen
Der Funktionsaufruf verleiht dem Modell die Fähigkeit, die Ausführung von Funktionen innerhalb Ihres Systems zu anfordern. Dies ist leistungsstark, schafft aber auch ein potenzielles Angriffsvektor. Ein böswilliger Nutzer kann Ihren Code nicht direkt ausführen; er kann jedoch im Chat-Feld beliebigen Text eingeben und dadurch die vom Modell generierten Argumente beeinflussen. Sie müssen eine bequeme Annahme auf den Kopf stellen: Argumente in tool_call sind keine internen Daten Ihrer Anwendung. Es sind Nutzerdaten, die durch ein Sprachmodell hindurchgegangen sind. Ihr Code muss die letzte Verteidigungslinie sein.
Validieren vor der Ausführung
Das Modell generiert JSON-Argumente, bei denen es die grammatikalische Form garantiert, niemals jedoch die geschäftliche Legitimität. Eine transaction_id kann syntaktisch eine Zeichenkette sein, enthält aber dennoch alles Mögliche. Die Disziplin besteht daher darin, jedes Argument vor jeglicher Verwendung zu validieren und die Funktion in drei klar getrennten Schritten zu strukturieren: Format prüfen, Existenz prüfen und erst dann ausführen.
import re
def validate_transaction_id(transaction_id: str) -> bool:
"""Validiert das Format einer Transaktions-ID."""
# Erwartetes Format: T gefolgt von 4 Ziffern
return bool(re.match(r"^T\d{4}$", transaction_id))
def retrieve_payment_status_safe(df, transaction_id: str) -> str:
"""Sichere Version mit Validierung."""
# Schritt 1: Format validieren
if not validate_transaction_id(transaction_id):
return json.dumps({
"error": "invalid_format",
"message": "ID muss im Format Txxxx sein (z. B. T1001)"
})
# Schritt 2: Existenz prüfen
if transaction_id not in df["transaction_id"].values:
return json.dumps({
"error": "not_found",
"message": f"Transaktion {transaction_id} nicht gefunden"
})
# Schritt 3: Ausführen
status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
return json.dumps({"status": status})
Der reguläre Ausdruck ^T\d{4}$ übernimmt hier die gesamte defensive Arbeit: Er ist an beiden Seiten verankert und lehnt jede Zeichenkette ab, die auch nur ein einziges zusätzliches Zeichen enthält. Dies führt direkt zum Grund dieser Verankerung.
Wenn das Argument zur Last wird
Betrachten Sie diesen Aufruf, der auf den ersten Blick völlig harmlos erscheint:
User: "Find the payment with ID: T1001; DROP TABLE payments"
Das Modell, gewissenhaft in seiner Extraktionsarbeit, könnte {"transaction_id": "T1001; DROP TABLE payments"} generieren. Es hat nichts Falsches getan: Es wurde eine Identifikator gegeben und dieser weitergereicht. Wenn Ihre Funktion dieses Argument über eine Verkettung in eine SQL-Abfrage einfügt, haben Sie gerade Ihre Tabelle verloren. Das Problem ist nicht neu – es ist eine klassische SQL-Injection – aber der Funktionsaufruf fügt eine Verbindung hinzu, die den falschen Eindruck von Filtern erzeugt.
Die folgenden drei Versionen zeigen den Fortschritt: Was Sie niemals schreiben dürfen, das absolute Minimum, das akzeptabel ist, und die Praxis, die Sie übernehmen sollten.
# Niemals dies tun – direkte SQL-Injection
def bad_query(transaction_id):
cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")
# Immer dies tun – parametrisierte Abfragen
def safe_query(transaction_id):
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
# Noch besser – Validierung + parametrisierte Abfrage
def best_query(transaction_id):
if not validate_transaction_id(transaction_id):
raise ValueError("Ungültiges ID-Format")
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
Die parametrisierte Abfrage reicht aus, um Injectionen zu neutralisieren, da der Treiber das Argument als Wert und nicht als SQL behandelt. Die Validierung im Vorfeld fügt eine zweite Barriere hinzu und liefert zudem versehentlich eine deutlich klarere Fehlermeldung als die Datenbank.
Den Möglichkeitsraum einschränken
Die zweite Verteidigungslinie besteht darin, zu reduzieren, was das Modell anfordern kann. Eine explizite Whiteliste, getrennt von Ihrem Dispatch-Dict, legt in schwarz auf weiß fest, welche Funktionen in diesem Kontext autorisiert sind. Die Trennung ist wichtig: ALLOWED_FUNCTIONS drückt eine Sicherheitsentscheidung aus, während available_functions einen Implementierungszustand widerspiegelt. Die Verwechslung beider bedeutet, eine Funktion einfach nur zu autorisieren, weil Sie sie kodiert haben.
# Definieren Sie explizit erlaubte Funktionen
ALLOWED_FUNCTIONS = {
"retrieve_payment_status",
"retrieve_payment_date",
"search_transactions"
}
def execute_tool_call_safe(tool_call, available_functions):
"""Ausführung mit Whitelist-Verifikation."""
function_name = tool_call.function.name
# Whitelist prüfen
if function_name not in ALLOWED_FUNCTIONS:
return json.dumps({
"error": "forbidden",
"message": f"Die Funktion {function_name} ist nicht autorisiert."
})
if function_name not in available_functions:
return json.dumps({
"error": "not_implemented",
"message": f"Die Funktion {function_name} ist nicht implementiert."
})
# Ausführen
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Nicht alle Funktionen tragen das gleiche Gewicht
Das Ablesen eines Zahlungsstatus und das Löschen alter Datensätze tragen offensichtlich nicht das gleiche Risiko. Die Klassifizierung Ihrer Funktionen nach Ebenen – nur lesen, schreiben, zerstören – ermöglicht es Ihnen, jeder Sitzung oder jedem Nutzer den entsprechenden Umfang zu gewähren. Ein öffentlicher Bestandsverfolgungs-Assistent läuft im read-Modus; ein Back-Office-Tool autorisiert Schreibvorgänge. Was destruktive Aktionen betrifft, ist die richtige Antwort nicht, sie zu verbieten, sondern sie zu eskalieren: Die Funktion gibt confirmation_required zurück, das Modell erklärt dem Nutzer, was geschehen wird, und ein Mensch trifft die endgültige Entscheidung.
# Risikostufen
READ_ONLY = {"retrieve_payment_status", "retrieve_payment_date", "search_transactions"}
WRITE = {"update_payment_status", "create_refund"}
DESTRUCTIVE = {"delete_transaction", "purge_old_records"}
def execute_with_permissions(tool_call, available_functions, permission_level="read"):
"""Ausführung mit Verifikationsprüfung des Berechtigungslevels."""
function_name = tool_call.function.name
if permission_level == "read" and function_name not in READ_ONLY:
return json.dumps({
"error": "permission_denied",
"message": f"Nur Lese-Funktionen sind autorisiert. "
f"{function_name} erfordert 'write' Level."
})
if function_name in DESTRUCTIVE:
return json.dumps({
"error": "confirmation_required",
"message": f"Aktion {function_name} ist destruktiv und "
f"erfordert manuelle Bestätigung."
})
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Missbrauch und Ausuferungen eindämmen
Ein schlecht gemanagter Gesprächsloop kann eine Funktion innerhalb weniger Sekunden dutzende Male aufrufen, sei es aufgrund von Boshaftigkeit oder eines einfachen Verkettungsfehlers. Ein gleitender Zähler über 60 Sekunden pro Funktion kostet nur wenige Zeilen Code und verhindert die Sättigung einer Drittanbieter-API, die pro Aufruf berechnet wird.
from collections import defaultdict
import time
class FunctionRateLimiter:
def __init__(self, max_calls_per_minute=10):
self.max_calls = max_calls_per_minute
self.call_history = defaultdict(list)
def can_call(self, function_name: str) -> bool:
now = time.time()
# Aufrufe älter als eine Minute bereinigen
self.call_history[function_name] = [
t for t in self.call_history[function_name]
if now - t < 60
]
return len(self.call_history[function_name]) < self.max_calls
def record_call(self, function_name: str):
self.call_history[function_name].append(time.time())
rate_limiter = FunctionRateLimiter(max_calls_per_minute=10)
Was zurück zum Modell geht
Der letzte blinde Fleck ist oft der kostspieligste. Eine Funktion, die eine vollständige Datenbankzeile zurückgibt, kann einen Passwort-Hash, einen API-Schlüssel oder eine Kartennummer enthalten. Doch alles, was Sie in eine tool-Nachricht platzieren, gelangt in den Kontext des Modells, was bedeutet, dass es potenziell in seiner Bildschirmausgabe, in Ihren Protokollen und beim Anbieter Ihres Dienstes erscheinen könnte. Das Maskieren sensibler Felder vor dem Senden – rekursiv, um verschachtelte Objekte abzudecken – ist die Vorsichtsmaßnahme, die Sie vor einem Datenleck schützen wird.
def sanitize_result(result: dict) -> dict:
"""Entfernt sensible Felder, bevor das Ergebnis an das Modell zurückgegeben wird."""
sensitive_keys = {"password", "api_key", "secret", "token", "ssn", "credit_card"}
sanitized = {}
for key, value in result.items():
if key.lower() in sensitive_keys:
sanitized[key] = "[MASKED]"
elif isinstance(value, dict):
sanitized[key] = sanitize_result(value)
else:
sanitized[key] = value
return sanitized
Kernaussagen
- Immer validieren Sie Argumente vor der Ausführung einer Funktion – Format, Typ, erlaubte Werte
- Verwenden Sie parametrisierte Abfragen, um SQL-Injectionen zu verhindern
- Implementieren Sie eine Whitelist autorisierter Funktionen
- Klassifizieren Sie Funktionen nach Risikostufe (lesen, schreiben, zerstören)
- Fügen Sie Rate Limiting hinzu, um Missbrauch zu verhindern
- Sanitisieren Sie Ergebnisse, um sensible Daten vor dem Modell zu schützen