Function Calling'i turvalisus
Sellel lehel
Ära kunagi käivita pimesi
Function calling annab mudelile võime taotleda funktsioonide käivitamist sinu süsteemis. See on võimas, kuid loob samal ajal potentsiaalse rünnakuvektori. Pahatahtlik kasutaja ei saa sinu koodi otse käivitada, kuid ta saab vestlusväljale kirjutada mida iganes, mõjutades seeläbi mudeli genereeritavaid argumente. Pead ümber hindama ühe mugava eelduse: tool_call argumendid ei ole sinu rakenduse sisemised andmed. Need on kasutajaandmed, mis on läbinud keelemudeli. Sinu kood peab olema viimane kaitseliin.
Valideeri enne käivitamist
Mudel genereerib JSON-argumendid, garanteerides ainult grammatilist vormi, mitte ärireeglitele vastavust. transaction_id võib olla süntaktiliselt string, kuid sisaldada ükskõik mida. Seetõttu on distsipliiniks valideerida iga argument enne sellega tegutsemist ja struktureerida funktsioon kolme eraldiseisva sammuna: vormingu kontroll, olemasolu kontroll ja alles seejärel käivitamine.
import re
def validate_transaction_id(transaction_id: str) -> bool:
"""Valideerib tehingu identifikaatori vormingu."""
# Oodatav vorming: T, millele järgneb 4 numbrit
return bool(re.match(r"^T\d{4}$", transaction_id))
def retrieve_payment_status_safe(df, transaction_id: str) -> str:
"""Turvaline versioon valideerimisega."""
# 1. samm: Valideeri vorming
if not validate_transaction_id(transaction_id):
return json.dumps({
"error": "invalid_format",
"message": "ID peab olema vormingus Txxxx (nt T1001)"
})
# 2. samm: Kontrolli olemasolu
if transaction_id not in df["transaction_id"].values:
return json.dumps({
"error": "not_found",
"message": f"Tehingut {transaction_id} ei leitud"
})
# 3. samm: Käivita
status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
return json.dumps({"status": status})
Regulaaravaldis ^T\d{4}$ teeb siin kogu kaitsva töö: mõlemalt poolt ankurdatuna lükkab see tagasi iga stringi, mis sisaldab kasvõi üht lisamärki. See viib otse sellise ankurdamise põhjuseni.
Kui argumendist saab payload
Vaatle seda päringut, mis tundub täiesti süütu:
Kasutaja: "Leia makse ID-ga: T1001; DROP TABLE payments"
Mudel, tehes kohusetundlikult oma ekstraheerimistööd, võib genereerida {"transaction_id": "T1001; DROP TABLE payments"}. Ta ei teinud midagi valesti: talle anti identifikaator ja ta edastas selle edasi. Kui sinu funktsioon sisestab selle argumendi SQL-päringusse liitmise teel, oled just oma tabeli kaotanud. Probleem pole uus – see on klassikaline SQL-injektsioon –, kuid function calling lisab lüli, mis tekitab vale mulje filtreerimisest.
Järgnevad kolm versiooni näitavad arengut: mida mitte kunagi kirjutada, minimaalset vastuvõetavat taset ja praktikat, mida tuleks järgida.
# ÄRA KUNAGI tee nii — otsene SQL-injektsioon
def bad_query(transaction_id):
cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")
# ALATI tee nii – parameteriseeritud päringud
def safe_query(transaction_id):
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
# VEEL PAREM – valideerimine + parameteriseeritud päring
def best_query(transaction_id):
if not validate_transaction_id(transaction_id):
raise ValueError("Vigane ID vorming")
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
Parameteriseeritud päring on injektsiooni neutraliseerimiseks piisav, kuna draiver käsitleb argumenti väärtusena, mitte SQL-koodina. Ülesvoolu valideerimine lisab teise tõkke ja annab muu hulgas palju selgema veateate, kui seda teeks andmebaas.
Piira võimaluste välja
Teine kaitseliin on vähendada seda, mida mudel saab taotleda. Selge lubatud nimekiri (allowlist), eraldi sinu dispatch-sõnastikust, sätestab must-valgelt, millised funktsioonid on selles kontekstis lubatud. Eraldatus on oluline: ALLOWED_FUNCTIONS väljendab turvaotsust, samas kui available_functions peegeldab implementatsiooni olekut. Nende kahe segiajamine võrdub funktsiooni lubamisega lihtsalt seetõttu, et sa oled selle kodeerinud.
# Määratle lubatud funktsioonid selgelt
ALLOWED_FUNCTIONS = {
"retrieve_payment_status",
"retrieve_payment_date",
"search_transactions"
}
def execute_tool_call_safe(tool_call, available_functions):
"""Käivitamine lubatud nimekirja kontrolliga."""
function_name = tool_call.function.name
# Kontrolli lubatud nimekirja
if function_name not in ALLOWED_FUNCTIONS:
return json.dumps({
"error": "forbidden",
"message": f"Funktsioon {function_name} ei ole lubatud."
})
if function_name not in available_functions:
return json.dumps({
"error": "not_implemented",
"message": f"Funktsioon {function_name} on implementeerimata."
})
# Käivita
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Kõik funktsioonid ei kanna sama kaalu
Maksestaatuse lugemine ja vanade kirjete kustutamine ei kanna ilmselgelt sama riski. Funktsioonide liigitamine tasemete kaupa – ainult lugemine, kirjutamine, hävitav – võimaldab anda igale seansile või kasutajale sobiva ulatuse. Avalik tellimuste jälgimise assistent töötab read režiimis; back-office’i tööriist lubab kirjutamist. Mis puutub hävitavatesse tegevustesse, siis õige vastus pole neid keelata, vaid eskaleerida: funktsioon tagastab confirmation_required, mudel selgitab kasutajale, mis juhtumas on, ja inimene teeb lõpliku otsuse.
# Riskitasemed
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"):
"""Käivitamine õigustaseme kontrolliga."""
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"Lubatud on ainult lugemisfunktsioonid. "
f"{function_name} nõuab 'write' taset."
})
if function_name in DESTRUCTIVE:
return json.dumps({
"error": "confirmation_required",
"message": f"Tegevus {function_name} on hävitav ja "
f"nõuab manuaalset kinnitust."
})
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Tõrju kuritarvitamist ja lõpmatuid tsükleid
Halvasti hallatud vestlutsükkel võib kutsuda sama funktsiooni välja kümneid kordi mõne sekundi jooksul, olgu siis pahatahtlikkuse või lihtsa aheldusvea tõttu. Liuguv loendur kuuekümne sekundi lõikes funktsiooni kohta maksab mõned koodiread ja hoiab ära kolmanda osapoole API küllastumise, mida arvutatakse call-põhiselt.
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()
# Puhasta üle minuti vanad väljakutsed
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)
Mis naaseb mudelile
Viimane pime koht on sageli kõige kulukam. Funktsioon, mis tagastab terve andmebaasirea, võib sisaldada parooli räsi, API võtit või kaardinumbrit. Kõik, mida paned tool sõnumisse, siseneb mudeli konteksti, mis tähendab, et see võib potentsiaalselt ilmuda ekraanivastusesse, sinu logidesse ja sinu teenusepakkuja juurde. Tundlike väljade maskeerimine enne saatmist – rekursiivselt, et katta pesastatud objekte – on ettevaatusabinõu, mis päästab sind andmelekke intsidentidest.
def sanitize_result(result: dict) -> dict:
"""Eemaldab tundlikud väljad enne mudelile tagastamist."""
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
Peamised punktid
- Valideeri alati argumendid enne funktsiooni käivitamist – vorming, tüüp, lubatud väärtused
- Kasuta parameteriseeritud päringuid SQL-injektsiooni vältimiseks
- Implementeeri lubatud funktsioonide nimekiri (allowlist)
- Liigita funktsioonid riskitaseme järgi (lugemine, kirjutamine, hävitav)
- Lisa kiiruse piiramine (rate limiting) kuritarvitamise vältimiseks
- Puhasta tulemused, et vältida tundlike andmete paljastamist mudelile