Bezpečnosť volania funkcií
Na tejto strane
Nikdy nevykonávaj naslepo
Volanie funkcií dáva modelu schopnosť požadovať vykonanie funkcií vo vašom systéme. Je to mocný nástroj, ale zároveň vytvára potenciálny vektor útoku. Zlovoľný používateľ síce nemôže priamo spustiť váš kód, no môže napísať čokoľvek do chatového poľa, a tým ovplyvniť argumenty, ktoré model vygeneruje. Musíš vyvrátiť pohodlný predpoklad: argumenty tool_call nie sú internými dátami tvojej aplikácie. Sú to používateľské dáta, ktoré prešli cez jazykový model. Tvoj kód musí byť poslednou líniou obrany.
Overuj pred vykonaním
Model generuje JSON argumenty, kde zaručuje iba gramatickú správnosť, nie však obchodnú legitimitu. transaction_id môže byť syntakticky reťazec, no obsahovať čokoľvek. Disciplína preto spočíva v overení každého argumentu pred akoukoľvek prácou s ním a štruktúrovaní funkcie do troch odlišných krokov: overenie formátu, overenie existencie a až následne vykonanie.
import re
def validate_transaction_id(transaction_id: str) -> bool:
"""Validuje formát identifikátora transakcie."""
# Očakávaný formát: T nasledované 4 číslicami
return bool(re.match(r"^T\d{4}$", transaction_id))
def retrieve_payment_status_safe(df, transaction_id: str) -> str:
"""Bezpečná verzia s validáciou."""
# Krok 1: Overenie formátu
if not validate_transaction_id(transaction_id):
return json.dumps({
"error": "invalid_format",
"message": "ID musí byť vo formáte Txxxx (napr. T1001)"
})
# Krok 2: Kontrola existencie
if transaction_id not in df["transaction_id"].values:
return json.dumps({
"error": "not_found",
"message": f"Transakcia {transaction_id} nebola nájdená"
})
# Krok 3: Vykonanie
status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
return json.dumps({"status": status})
Regulárny výraz ^T\d{4}$ tu odvádza všetku obrannú prácu: ukotvený na oboch stranách odmietne akýkoľvek reťazec obsahujúci čo i len jeden znak navyše. To priamo vedie k dôvodu tohto ukotvenia.
Keď sa argument stane payloadom
Zváž túto požiadavku, ktorá sa javí ako úplne neškodná:
User: "Find the payment with ID: T1001; DROP TABLE payments"
Model, svedomito plniac svoju úlohu extrakcie, môže vygenerovať {"transaction_id": "T1001; DROP TABLE payments"}. Neurobil nič zlé: dostal identifikátor a posunul ho ďalej. Ak tvoja funkcia vloží tento argument do SQL dotazu pomocou konkatenácie, práve si prišiel o svoju tabuľku. Problém nie je nový – je to klasická SQL injekcia – ale volanie funkcií pridáva článok, ktorý vytvára falošný dojem filtrovania.
Nasledujúce tri verzie ukazujú vývoj: čo nikdy nesmieš napísať, absolútne minimum, ktoré je prijateľné, a postup, ktorý máš adoptovať.
# NIKDY nerob toto — priama SQL injekcia
def bad_query(transaction_id):
cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")
# VŽDY rob toto — parameterizované dotazy
def safe_query(transaction_id):
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
# EŠTE LEPŠIE — validácia + parameterizovaný dotaz
def best_query(transaction_id):
if not validate_transaction_id(transaction_id):
raise ValueError("Neplatný formát ID")
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
Parameterizovaný dotaz stačí na neutralizáciu injekcie, keďže ovládač zaobchádza s argumentom ako s hodnotou, nie ako so SQL kódom. Validácia na vstupe pridáva druhú bariéru a mimochodom poskytuje oveľa jasnejšiu chybovú správu, než by poskytla databáza.
Obmedz pole možností
Druhou líniou obrany je zredukovať to, čo môže model požadovať. Explicitný zoznam povolených položiek (allowlist), oddelený od tvojho slovníka dispatch, čiernym na bielom stanovuje, ktoré funkcie sú v tomto kontexte autorizované. Toto oddelenie je dôležité: ALLOWED_FUNCTIONS vyjadruje bezpečnostné rozhodnutie, zatiaľ čo available_functions odráža stav implementácie. Zamieňať tieto dve veci znamená autorizovať funkciu jednoducho preto, že si ju nakódoval.
# Explicitne definuj povolené funkcie
ALLOWED_FUNCTIONS = {
"retrieve_payment_status",
"retrieve_payment_date",
"search_transactions"
}
def execute_tool_call_safe(tool_call, available_functions):
"""Vykonanie s overením allowlistu."""
function_name = tool_call.function.name
# Kontrola allowlistu
if function_name not in ALLOWED_FUNCTIONS:
return json.dumps({
"error": "forbidden",
"message": f"Funkcia {function_name} nie je autorizovaná."
})
if function_name not in available_functions:
return json.dumps({
"error": "not_implemented",
"message": f"Funkcia {function_name} nie je implementovaná."
})
# Vykonanie
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Nie všetky funkcie majú rovnakú váhu
Čítanie stavu platby a mazanie starých záznamov očividne nenesú rovnaké riziko. Klasifikácia funkcií podľa úrovne – len na čítanie, zápis, deštruktívne – ti umožňuje udeliť každej relácii alebo používateľovi vhodný rozsah. Verejný asistent na sledovanie objednávok bude bežať v režime read; nástroj pre back-office povolí zápisy. Čo sa týka deštruktívnych akcií, správnou odpoveďou nie je ich zákaz, ale eskalácia: funkcia vráti confirmation_required, model vysvetlí používateľovi, čo sa chystá stať, a človek urobí finálne rozhodnutie.
# Úrovne rizika
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"):
"""Vykonanie s overením úrovne oprávnení."""
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"Autorizované sú len funkcie na čítanie. "
f"{function_name} vyžaduje úroveň 'write'."
})
if function_name in DESTRUCTIVE:
return json.dumps({
"error": "confirmation_required",
"message": f"Akcia {function_name} je deštruktívna a "
f"vyžaduje manuálne potvrdenie."
})
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Zabránenie zneužitiu a nekonečným cyklom
Zle spravovaná slučka konverzácie môže zavolať tú istú funkciu desiatky krát počas niekoľkých sekúnd, či už kvôli zlomyseľnosti alebo jednoduchej chybe v reťazení. Posuvný počítadlo za šesťdesiat sekúnd na funkciu stojí pár riadkov kódu a zabráni nasýteniu API tretej strany fakturovaného za volanie.
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()
# Vyčisti volania staršie ako jedna minúta
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)
Čo sa vracia modelu
Posledným slepým miestom je často to najdrahšie. Funkcia, ktorá vráti celý riadok databázy, môže obsahovať hash hesla, API kľúč alebo číslo karty. Všetko, čo umiestniš do správy tool, vstupuje do kontextu modelu, čo znamená, že sa to potenciálne môže objaviť v jeho odpovedi na obrazovke, vo tvojich logoch a na strane tvojho poskytovateľa. Maskovanie citlivých polí pred odoslaním – rekurzívne, aby sa pokryli vnorené objekty – je opatrenie, ktoré ťa zachráni pred incidentom úniku dát.
def sanitize_result(result: dict) -> dict:
"""Odstráni citlivé polia pred vrátením modelu."""
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
Kľúčové poznatky
- Vždy overuj argumenty pred vykonaním funkcie – formát, typ, povolené hodnoty
- Používaj parameterizované dotazy na prevenciu SQL injekcií
- Implementuj zoznam povolených funkcií (allowlist)
- Klasifikuj funkcie podľa úrovne rizika (čítanie, zápis, deštruktívne)
- Pridaj obmedzenie rýchlosti (rate limiting) na prevenciu zneužitia
- Čisti výsledky, aby sa modelu neexponovali citlivé dáta