Function Calling Security
Šiame puslapyje
Niekada nevykdyk aklai
Function calling suteikia modeliui galimybę prašyti vykdyti funkcijas tavo sistemoje. Tai galinga, tačiau kartu sukuria potencialią atakos vietą. Piktavališkas vartotojas negali tiesiogiai vykdyti tavo kodo, tačiau jis gali rašyti bet ką pokalbio lauke ir taip daryti įtaką modelio generuojamiems argumentams. Turi paneigti vieną patogią prielaidą: tool_call argumentai nėra vidiniai tavo programos duomenys. Tai vartotojo duomenys, praėję per kalbos modelį. Tavo kodas turi būti paskutinė gynybos linija.
Patikrink prieš vykdydamas
Modelis generuoja JSON argumentus, kuriuose garantuojama tik gramatinė forma, o ne verslo teisėtumas. transaction_id gali būti sintaksiškai eilutė, tačiau joje gali būti bet kas. Todėl disciplina reikalauja patikrinti kiekvieną argumentą prieš atliekant bet kokius veiksmus su juo ir struktūruoti funkciją į tris atskirus žingsnius: patikrinti formatą, patikrinti egzistavimą ir tik tada vykdyti.
import re
def validate_transaction_id(transaction_id: str) -> bool:
"""Patikrina sandorio identifikatoriaus formatą."""
# Tikėtinas formatas: T ir 4 skaitmenys
return bool(re.match(r"^T\d{4}$", transaction_id))
def retrieve_payment_status_safe(df, transaction_id: str) -> str:
"""Saugi versija su patikra."""
# 1 žingsnis: Patikrinti formatą
if not validate_transaction_id(transaction_id):
return json.dumps({
"error": "invalid_format",
"message": "ID turi būti Txxxx formato (pvz., T1001)"
})
# 2 žingsnis: Patikrinti egzistavimą
if transaction_id not in df["transaction_id"].values:
return json.dumps({
"error": "not_found",
"message": f"Sandoris {transaction_id} nerastas"
})
# 3 žingsnis: Vykdyti
status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
return json.dumps({"status": status})
Reguliarusis reiškinys ^T\d{4}$ čia atlieka visą apsauginį darbą: įtvirtintas abiejose pusėse, jis atmeta bet kurią eilutę, turinčią net vieną papildomą simbolį. Tai tiesiogiai veda prie šio įtvirtinimo priežasties.
Kai argumentas tampa našta
Apsvarstyk šį prašymą, kuris atrodo visiškai nekaltas:
User: "Find the payment with ID: T1001; DROP TABLE payments"
Modelis, sąžiningai atlikdamas savo ištraukimo darbą, gali sugeneruoti {"transaction_id": "T1001; DROP TABLE payments"}. Jis nieko blogo nepadarė: jam buvo pateiktas identifikatorius, ir jis jį perdavė toliau. Jei tavo funkcija įterpia šį argumentą į SQL užklausą naudodama konkatenaciją, tu ką tik praradai savo lentelę. Problema nėra nauja – tai klasikinė SQL injekcija – tačiau function calling sukuria papildomą grandį, kuri klaidingai sukuria filtravimo įspūdį.
Šios trys versijos rodo progresiją: ko niekada negalima rašyti, minimalų priimtiną lygį ir praktiką, kurios reikia laikytis.
# NIEKADA nedaryk taip – tiesioginė SQL injekcija
def bad_query(transaction_id):
cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")
# VISADA daryk taip – parametrizuotos užklausos
def safe_query(transaction_id):
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
# DAR GERIAU – patikra + parametrizuota užklausa
def best_query(transaction_id):
if not validate_transaction_id(transaction_id):
raise ValueError("Neteisingas ID formatas")
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
Parametrizuota užklausa pakanka injekcijai neutralizuoti, nes tvarkyklė argumentą traktuoja kaip reikšmę, o ne kaip SQL kodą. Išankstinis patikrinimas sukuria antrą barjerą ir, be kita ko, pateikia daug aiškesnį klaidos pranešimą nei duomenų bazė.
Apribok galimybių lauką
Antroji gynybos linija – sumažinti tai, ką modelis gali prašyti. Aiškus leidimų sąrašas (allowlist), atskiras nuo tavo nukreipimo žodyno, juodu ant balto nurodo, kurios funkcijos šiame kontekste yra autorizuotos. Šis atskyrimas svarbus: ALLOWED_FUNCTIONS išreiškia saugumo sprendimą, o available_functions atspindi įgyvendinimo būseną. Supainiojus abu, tai reiškia funkcijos autorizavimą vien todėl, kad ją užkodavai.
# Aiškiai apibrėžkite leidžiamas funkcijas
ALLOWED_FUNCTIONS = {
"retrieve_payment_status",
"retrieve_payment_date",
"search_transactions"
}
def execute_tool_call_safe(tool_call, available_functions):
"""Vykdoma su leidimų sąrašo patikra."""
function_name = tool_call.function.name
# Patikrinti leidimų sąrašą
if function_name not in ALLOWED_FUNCTIONS:
return json.dumps({
"error": "forbidden",
"message": f"Funkcija {function_name} nėra autorizuota."
})
if function_name not in available_functions:
return json.dumps({
"error": "not_implemented",
"message": f"Funkcija {function_name} nėra įgyvendinta."
})
# Vykdyti
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Ne visos funkcijos turi tą pačią svorį
Mokėjimo statuso skaitymas ir senų įrašų išvalymas akivaizdžiai kelia skirtingą riziką. Klasifikuodamas savo funkcijas pagal lygį – tik skaitymui, rašymui, destruktyvios – gali suteikti kiekvienai sesijai ar vartotojui tinkamą apimtį. Viešas užsakymų sekimo asistentas veiks read režimu; back-office įrankis leis rašymo operacijas. O dėl destruktyvių veiksmų teisingas atsakymas yra ne jų draudimas, o eskalavimas: funkcija grąžina confirmation_required, modelis paaiškina vartotojui, kas vyksta, ir žmogus priima galutinį sprendimą.
# Rizikos lygiai
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"):
"""Vykdoma su leidimų lygio patikra."""
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"Autorizuotos tik skaitymo funkcijos. "
f"{function_name} reikalauja 'write' lygio."
})
if function_name in DESTRUCTIVE:
return json.dumps({
"error": "confirmation_required",
"message": f"Veiksmas {function_name} yra destruktyvus ir "
f"reikalauja rankinio patvirtinimo."
})
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Suvaldyk piktnaudžiavimą ir begalinius ciklus
Prastai valdomas pokalbio ciklas gali tą pačią funkciją iškviesti dešimtis kartų per kelias sekundes, nesvarbu, ar dėl piktavališkumo, ar dėl paprastos grandininės klaidos. Slankusis skaitiklis per šešiasdešimt sekundžių vienai funkcijai kainuoja kelias kodo eilutes ir neleidžia perkrauti trečiosios šalies API, apmokestinamo už kiekvieną kvietimą.
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()
# Išvalyti kvietimus, senesnius nei viena minutė
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)
Kas grąžinama modeliui
Paskutinė aklavietė dažnai būna pati brangiausia. Funkcija, grąžinanti visą duomenų bazės eilutę, gali įtraukti slaptažodžio maišą, API raktą arba kortelės numerį. Tačiau viskas, ką įdedi į tool žinutę, patenka į modelio kontekstą, o tai reiškia, kad tai potencialiai gali atsirasti jo ekrane rodomame atsakyme, tavo žurnaluose ir pas tavo tiekėją. Paslėpti jautrius laukus prieš siunčiant – rekursyviai, kad būtų aprėpti įdėtieji objektai – yra atsargumo priemonė, kuri išgelbės tave nuo duomenų nutekėjimo incidento.
def sanitize_result(result: dict) -> dict:
"""Pašalina jautrius laukus prieš grąžinant modeliui."""
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
Svarbiausi punktai
- Visada patikrink argumentus prieš vykdydamas funkciją – formatą, tipą, leistinas reikšmes
- Naudok parametrizuotas užklausas, kad išvengtum SQL injekcijų
- Įgyvendink leidimų sąrašą (allowlist) autorizuotoms funkcijoms
- Klasifikuok funkcijas pagal rizikos lygį (skaitymas, rašymas, destruktyvios)
- Pridėk užklausų ribojimą (rate limiting), kad išvengtum piktnaudžiavimo
- Išvalyk rezultatus, kad išvengtum jautrių duomenų atskleidimo modeliui