Biztonság a függvényhívásoknál
Ezen az oldalon
Soha ne hajts végre vakon
A függvényhívás lehetővé teszi, hogy a modell függvényvégrehajtást kérjen a rendszereden belül. Ez hatalmas erő, de egyben potenciális támadási felületet is nyit. Egy rosszindulatú felhasználó nem tudja közvetlenül futtatni a kódodat, viszont bármit beírhat a chat mezőbe, ezzel befolyásolva a modell által generált argumentumokat. Le kell mondanod egy kényelmes tévhitről: a tool_call argumentumai nem belső adatok az alkalmazásodból. Ezek felhasználói adatok, amelyek átmentek egy nyelvi modellen. A kódodnak kell lennie az utolsó védelmi vonalnak.
Ellenőrzés végrehajtás előtt
A modell JSON argumentumokat generál, ahol csak a nyelvtani helyességet garantálja, az üzleti legitimitást soha. Egy transaction_id szintaktikailag lehet string, mégis bármit tartalmazhat. A fegyelem tehát az, hogy minden argumentumot ellenőrizz, mielőtt bármit is tennél vele, és a függvényt három elkülönült lépésre építsd fel: formátum ellenőrzése, létezés vizsgálata, és csak ezután a végrehajtás.
import re
def validate_transaction_id(transaction_id: str) -> bool:
"""Érvényesíti a tranzakcióazonosító formátumát."""
# Várt formátum: T betűt követően 4 számjegy
return bool(re.match(r"^T\d{4}$", transaction_id))
def retrieve_payment_status_safe(df, transaction_id: str) -> str:
"""Biztonságos verzió ellenőrzéssel."""
# 1. lépés: Formátum ellenőrzése
if not validate_transaction_id(transaction_id):
return json.dumps({
"error": "invalid_format",
"message": "Az ID-nak Txxxx formátumúnak kell lennie (pl. T1001)"
})
# 2. lépés: Létezés ellenőrzése
if transaction_id not in df["transaction_id"].values:
return json.dumps({
"error": "not_found",
"message": f"A(z) {transaction_id} tranzakció nem található"
})
# 3. lépés: Végrehajtás
status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
return json.dumps({"status": status})
A ^T\d{4}$ reguláris kifejezés végzi itt az összes védekezési munkát: mindkét oldalról horgonyzott, így elutasít minden olyan stringet, amely akár csak egyetlen extra karaktert is tartalmaz. Ez közvetlenül vezet a horgonyzás okához.
Amikor az argumentum hasznos tehergé válik
Tekintsük ezt a látszólag teljesen ártalmatlan kérést:
Felhasználó: "Keresd meg a T1001 azonosítójú fizetést; DROP TABLE payments"
A modell, lelkiismeretesen végezve a kinyerési munkáját, generálhatja ezt: {"transaction_id": "T1001; DROP TABLE payments"}. Nem tett semmi rosszat: kapott egy azonosítót, és továbbította azt. Ha a függvényed összefűzéssel (concatenation) illeszti be ezt az argumentumot egy SQL lekérdezésbe, máris elvesztetted a tábládat. A probléma nem új – ez klasszikus SQL injection –, de a függvényhívás hozzáad egy láncszemet, ami hamis szűrési benyomást kelt.
Az alábbi három verzió mutatja a fejlődést: amit soha nem szabad megírnod, a minimálisan elfogadhatót, és az alkalmazandó gyakorlatot.
# SOHA ne csináld ezt — közvetlen SQL injection
def bad_query(transaction_id):
cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")
# MINDIG ezt csináld — paraméterezett lekérdezések
def safe_query(transaction_id):
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
# MÉG JOBB — ellenőrzés + paraméterezett lekérdezés
def best_query(transaction_id):
if not validate_transaction_id(transaction_id):
raise ValueError("Érvénytelen ID formátum")
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
A paraméterezett lekérdezés önmagában is elegendő az injection semlegesítésére, mivel a driver az argumentumot értékként, nem pedig SQL-kódként kezeli. A korai szakaszban végzett ellenőrzés egy második akadályt jelent, és mellékesen sokkal tisztább hibaüzenetet biztosít, mint amit az adatbázis adna.
Korlátozd a lehetőségek körét
A második védelmi vonal annak csökkentése, amit a modell kérhet. Egy explicit engedélyezési lista (allowlist), elkülönítve a dispatch szótáradtól, fekete-fehéren rögzíti, mely függvények engedélyezettek ebben a kontextusban. Az elkülönítés számít: az ALLOWED_FUNCTIONS egy biztonsági döntést fejez ki, míg az available_functions egy implementációs állapotot tükröz. A kettő összekeverése annyit jelent, mint egy függvényt pusztán azért engedélyezni, mert megkódoltad.
# Expliciten definiált engedélyezett függvények
ALLOWED_FUNCTIONS = {
"retrieve_payment_status",
"retrieve_payment_date",
"search_transactions"
}
def execute_tool_call_safe(tool_call, available_functions):
"""Végrehajtás engedélyezési lista ellenőrzéssel."""
function_name = tool_call.function.name
# Engedélyezési lista ellenőrzése
if function_name not in ALLOWED_FUNCTIONS:
return json.dumps({
"error": "forbidden",
"message": f"A(z) {function_name} függvény nem engedélyezett."
})
if function_name not in available_functions:
return json.dumps({
"error": "not_implemented",
"message": f"A(z) {function_name} függvény nincs implementálva."
})
# Végrehajtás
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Nem minden függvény hordoz ugyanakkora kockázatot
Egy fizetési állapot lekérése és a régi rekordok törlése nyilvánvalóan nem hordoz ugyanakkora kockázatot. Ha szintek szerint osztályozod a függvényeidet – csak olvasható, írási, romboló –, akkor minden munkamenetnek vagy felhasználónak megadhatod a megfelelő hatókört. Egy nyilvános rendelés-követő asszisztens read módban fut; egy back-office eszköz engedélyezheti az írást. Ami a romboló műveleteket illeti, a helyes válasz nem a tiltás, hanem a fokozás: a függvény confirmation_required értéket ad vissza, a modell elmagyarázza a felhasználónak, mi fog történni, és egy ember hozza meg a végső döntést.
# Kockázati szintek
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"):
"""Végrehajtás jogosultsági szint ellenőrzéssel."""
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"Csak az olvasó függvények engedélyezettek. "
f"A(z) {function_name} 'write' szintet igényel."
})
if function_name in DESTRUCTIVE:
return json.dumps({
"error": "confirmation_required",
"message": f"A(z) {function_name} művelet romboló, és "
f"kézi megerősítést igényel."
})
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Kezeld a visszaéléseket és a végtelen ciklusokat
Egy rosszul kezelt beszélgetési hurok másodpercek alatt tucatszor hívhatja meg ugyanazt a függvényt, legyen szó rosszindulatú támadásról vagy egyszerű láncolási hibáról. Egy csúszó számláló implementálása függvényenként hatvan másodpercre néhány sor kódba kerül, és megakadályozza, hogy telítsd a hívásonként számlázott harmadik féltől származó API-t.
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()
# Töröljük az egy percnél régebbi hívásokat
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)
Ami visszakerül a modellhez
Az utolsó vakfolt gyakran a legköltségesebb. Egy függvény, amely egy teljes adatbázis-sort ad vissza, tartalmazhat jelszó-hash-t, API-kulcsot vagy bankkártyaszámot. Minden, amit egy tool üzenetbe helyezel, belép a modell kontextusába, ami azt jelenti, hogy potenciálisan megjelenhet a képernyőn lévő válaszában, a naplóidban (logok) és a szolgáltatódnál is. Az érzékeny mezők elrejtése (masking) a modellnek való visszaküldés előtt – rekurzívan, a beágyazott objektumok lefedésére – az az óvintézkedés, ami megvéd egy adatszivárgási incidenstől.
def sanitize_result(result: dict) -> dict:
"""Eltávolítja az érzékeny mezőket, mielőtt visszakerülnének a modellhez."""
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
Főbb megállapítások
- Mindig ellenőrizd az argumentumokat a függvény végrehajtása előtt – formátum, típus, engedélyezett értékek
- Használj paraméterezett lekérdezéseket az SQL injection megelőzésére
- Implementálj egy engedélyezési listát (allowlist) a jogosult függvényekhez
- Osztályozd a függvényeket kockázati szint szerint (olvasás, írás, romboló)
- Adj hozzá sebességkorlátozást (rate limiting) a visszaélések megelőzésére
- Tisztítsd meg (sanitize) az eredményeket, hogy elkerüld az érzékeny adatok modell előtti felfedését