Varnost pri klicanju funkcij
Na tej strani
Nikoli ne izvajaj slepo
Klicanje funkcij modelu omogoča, da zahteva izvajanje funkcij znotraj tvojega sistema. To je zmogljivo, vendar ustvarja tudi potencialen napadalni vektor. Zlonamerni uporabnik ne more neposredno izvajati tvoje kode, lahko pa v polje za klepet napiše karkoli in s tem vpliva na argumente, ki jih ustvari model. Opustiti moraš udobno predpostavko: argumenti tool_call niso interni podatki tvoje aplikacije. To so uporabniški podatki, ki so šli skozi jezikovni model. Tvoja koda mora biti zadnja obrambna črta.
Pred izvajanjem validiraj
Model generira argumente v formatu JSON, kjer zagotavlja slovnično obliko, nikoli pa poslovne legitimnosti. transaction_id je lahko sintaktično niz, vendar vsebuje karkoli. Disciplina zato zahteva, da vsak argument validiraš, preden z njim karkoli narediš, in funkcijo strukturiraš v tri ločene korake: preveri format, preveri obstoj in šele nato izvedi.
import re
def validate_transaction_id(transaction_id: str) -> bool:
"""Validira format identifikatorja transakcije."""
# Pričakovani format: T, ki mu sledijo 4 števke
return bool(re.match(r"^T\d{4}$", transaction_id))
def retrieve_payment_status_safe(df, transaction_id: str) -> str:
"""Varna različica z validacijo."""
# 1. korak: Validacija formata
if not validate_transaction_id(transaction_id):
return json.dumps({
"error": "invalid_format",
"message": "ID mora biti v formatu Txxxx (npr. T1001)"
})
# 2. korak: Preverjanje obstoja
if transaction_id not in df["transaction_id"].values:
return json.dumps({
"error": "not_found",
"message": f"Transakcija {transaction_id} ni najdena"
})
# 3. korak: Izvedba
status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
return json.dumps({"status": status})
Regularni izraz ^T\d{4}$ tu opravi vse obrambno delo: sidran na obeh straneh zavrne vsak niz, ki vsebuje celo en sam dodaten znak. To nas neposredno pripelje do razloga za to sidranje.
Ko argument postane tovor
Razmisli o tej zahtevi, ki se zdi popolnoma nedolžna:
Uporabnik: "Poišči plačilo z ID-jem: T1001; DROP TABLE payments"
Model, ki vestno opravlja svoje delo ekstrakcije, lahko generira {"transaction_id": "T1001; DROP TABLE payments"}. Ni storil nič narobe: dobil je identifikator in ga posredoval naprej. Če tvoja funkcija ta argument vstavi v poizvedbo SQL s pomočjo združevanja nizov (concatenation), si pravkar izgubil tabelo. Težava ni nova – gre za klasično injiciranje SQL – vendar klicanje funkcij dodaja povezavo, ki ustvarja lažen vtis filtriranja.
Naslednje tri različice kažejo napredek: česar nikoli ne smeš napisati, absolutni minimum, ki je sprejemljiv, in praksa, ki jo moraš sprejeti.
# NIKOLI ne delaj tega — neposredno injiciranje SQL
def bad_query(transaction_id):
cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")
# VEDNO delaj to — parametrizirane poizvedbe
def safe_query(transaction_id):
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
# ŠE BOLJE — validacija + parametrizirana poizvedba
def best_query(transaction_id):
if not validate_transaction_id(transaction_id):
raise ValueError("Neveljaven format ID-ja")
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
Parametrizirana poizvedba je dovolj za nevtralizacijo injiciranja, saj gonilnik argument obravnava kot vrednost, ne kot SQL. Validacija na višji ravni doda drugo pregrado in mimogrede zagotovi veliko jasnejše sporočilo o napaki, kot bi ga baza podatkov.
Omeji polje možnosti
Druga obrambna črta je zmanjšanje tega, kar model lahko zahteva. Ekspliciten seznam dovoljenih (allowlist), ločen od tvojega slovarja za usmerjanje, črno na belem določa, katere funkcije so v tem kontekstu pooblaščene. Ločitev je pomembna: ALLOWED_FUNCTIONS izraža varnostno odločitev, medtem ko available_functions odraža stanje implementacije. Zamenjava obeh pomeni pooblastitev funkcije zgolj zato, ker si jo kodiral.
# Eksplicitno definiranje dovoljenih funkcij
ALLOWED_FUNCTIONS = {
"retrieve_payment_status",
"retrieve_payment_date",
"search_transactions"
}
def execute_tool_call_safe(tool_call, available_functions):
"""Izvedba s preverjanjem seznama dovoljenih."""
function_name = tool_call.function.name
# Preveri seznam dovoljenih
if function_name not in ALLOWED_FUNCTIONS:
return json.dumps({
"error": "forbidden",
"message": f"Funkcija {function_name} ni pooblaščena."
})
if function_name not in available_functions:
return json.dumps({
"error": "not_implemented",
"message": f"Funkcija {function_name} ni implementirana."
})
# Izvedi
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Vse funkcije nimajo enake teže
Branje statusa plačila in brisanje starih zapisov očitno ne nosita enakega tveganja. Razvrstitev tvojih funkcij po ravneh – samo za branje, pisanje, destruktivno – ti omogoča, da vsaki seji ali uporabniku dodeliš ustrezen obseg. Javni pomočnik za sledenje naročilom bo deloval v načinu read; orodje za back-office bo dovoljevalo pisanje. Kar zadeva destruktivna dejanja, pravi odgovor ni njihova prepoved, temveč eskalacija: funkcija vrne confirmation_required, model uporabniku razloži, kaj se bo zgodilo, in človek sprejme končno odločitev.
# Ravni tveganja
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"):
"""Izvedba s preverjanjem ravni dovoljenj."""
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"Dovoljene so samo funkcije za branje. "
f"{function_name} zahteva raven 'write'."
})
if function_name in DESTRUCTIVE:
return json.dumps({
"error": "confirmation_required",
"message": f"Akcija {function_name} je destruktivna in "
f"zahteva ročno potrditev."
})
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Zajemi zlorabe in zanke
Slabo upravljana zanka pogovora lahko isto funkcijo pokliče ducat krat v nekaj sekundah, bodisi zaradi zlonamernosti bodisi zaradi preproste napake v verigenju. Drsni števec za šestdeset sekund na funkcijo stane nekaj vrstic kode in prepreči zasičenje zunanjega API-ja, ki se zaračunava na klic.
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()
# Počisti klice, starejše od ene minute
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)
Kaj se vrne modelu
Zadnja slepa pega je pogosto najbolj draga. Funkcija, ki vrne celotno vrstico baze podatkov, lahko vključuje hash gesla, API ključ ali številko kartice. Vse, kar postaviš v sporočilo tool, vstopi v kontekst modela, kar pomeni, da se lahko potencialno pojavi v njegovem odzivu na zaslonu, v tvojih dnevnikih in pri tvojem ponudniku. Prikrivanje občutljivih polj pred pošiljanjem – rekurzivno, da pokriješ gnezdenje objekte – je previdnostni ukrep, ki te bo rešil pred incidentom uhajanja podatkov.
def sanitize_result(result: dict) -> dict:
"""Odstrani občutljiva polja pred vrnitvijo 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
Ključne ugotovitve
- Vedno validiraj argumente pred izvajanjem funkcije – format, tip, dovoljene vrednosti
- Uporabi parametrizirane poizvedbe za preprečevanje injiciranja SQL
- Implementiraj seznam dovoljenih (allowlist) pooblaščenih funkcij
- Razvrsti funkcije po ravni tveganja (branje, pisanje, destruktivno)
- Dodaj omejevanje hitrosti (rate limiting) za preprečevanje zlorab
- Prečisti rezultate, da se izogneš razkrivanju občutljivih podatkov modelu