Sigurtà tas-Sejħiet tal-Funzjonijiet
F'din il-paġna
Qatt Ma Tesegwixxi Blindament
Is-sejħiet tal-funzjonijiet jagħtu lill-mudell il-kapaċità li jitlob l-eżekuzzjoni ta’ funzjonijiet fis-sistema tiegħek. Dan huwa qawwi, iżda joħloq ukoll vettur ta’ attakk potenzjali. Utent malizzjuż ma jistax jesegwixxi l-kodiċi tiegħek direttament; madankollu, jista’ jikteb kwalunkwe ħaġa fil-qasam taċ-chat, u b’hekk jinfluwenza l-argumenti li jipproduċi l-mudell. Għandek taqleb preżunzjoni komda: l-argumenti ta’ tool_call mhumiex dejta interna mill-applikazzjoni tiegħek. Huma dejta tal-utent li għaddiet minn mudell tal-lingwa. Il-kodiċi tiegħek irid ikun l-aħħar linja ta’ difiża.
Ivvvalida Qabel Ma Tesegwixxi
Il-mudell jiġġenera argumenti JSON fejn jiggarantixxi l-forma grammatikali, qatt mhux il-leġittimità tan-negozju. transaction_id jista’ jkun sintattikament string iżda jkun fih kwalunkwe ħaġa. Għalhekk, id-dixxiplina hija li tivvalida kull argument qabel ma tagħmel xi ħaġa bih, u li tistruttura l-funzjoni f’tliet passi distinti: ivverifika l-format, ivverifika l-eżistenza, u mbagħad biss esegwixxi.
import re
def validate_transaction_id(transaction_id: str) -> bool:
"""Validates the format of a transaction identifier."""
# Expected format: T followed by 4 digits
return bool(re.match(r"^T\d{4}$", transaction_id))
def retrieve_payment_status_safe(df, transaction_id: str) -> str:
"""Secure version with validation."""
# Step 1: Validate format
if not validate_transaction_id(transaction_id):
return json.dumps({
"error": "invalid_format",
"message": "ID must be in Txxxx format (e.g., T1001)"
})
# Step 2: Check existence
if transaction_id not in df["transaction_id"].values:
return json.dumps({
"error": "not_found",
"message": f"Transaction {transaction_id} not found"
})
# Step 3: Execute
status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
return json.dumps({"status": status})
L-espressjoni regolari ^T\d{4}$ tagħmel ix-xogħol difensiv kollu hawn: imwaħħla fuq iż-żewġ naħat, tiċħad kwalunkwe string li fiha anke karattru wieħed żejjed. Dan iwassal direttament għar-raġuni għal din il-waħħla.
Meta l-Argument Isir Payload
Ikkunsidra din it-talba, li tidher kompletament innoċenti:
User: "Find the payment with ID: T1001; DROP TABLE payments"
Il-mudell, billi jagħmel ix-xogħol ta’ estrazzjoni tiegħu b’mod kuxjenzjuż, jista’ jiġġenera {"transaction_id": "T1001; DROP TABLE payments"}. Ma għamel xejn ħażin: ngħata identifikatur, u għaddieh. Jekk il-funzjoni tiegħek tidħol dan l-argument f’mistoqsija SQL permezz ta’ konkatenażzjoni, għadek kemm tilfet it-tabella tiegħek. Il-problema mhix ġdida—hija SQL injection klassika—iżda s-sejħiet tal-funzjonijiet iżidu rabta li toħloq impressjoni falza ta’ filtrar.
It-tliet verżjonijiet li ġejjin juru l-progressjoni: x’qatt m’għandek tikteb, l-minimu assolut aċċettabbli, u l-prattika li għandek tadotta.
# NEVER do this — direct SQL injection
def bad_query(transaction_id):
cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")
# ALWAYS do this — parameterized queries
def safe_query(transaction_id):
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
# EVEN BETTER — validation + parameterized query
def best_query(transaction_id):
if not validate_transaction_id(transaction_id):
raise ValueError("Invalid ID format")
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
Il-mistoqsija parametrizzata hija biżżejjed biex tnewtralizza l-injection, peress li s-sewwieq jittratta l-argument bħala valur, mhux bħala SQL. Il-validazzjoni upstream iżżdied bħala t-tieni barriera u, inċidentalment, tipprovdi messaġġ ta’ żball ħafna aktar ċar milli jagħmel id-database.
Irrestrinġi l-Kamp tal-Possibbiltajiet
It-tieni linja ta’ difiża hija li tnaqqas dak li l-mudell jista’ jitlob. Allowlist espliċita, separata mid-dizzjunarju tad-dispaċċ tiegħek, tiddikjara b’mod ċar u skritt liema funzjonijiet huma awtorizzati f’dan il-kuntest. Is-separazzjoni hija importanti: ALLOWED_FUNCTIONS tesprimi deċiżjoni ta’ sigurtà, filwaqt li available_functions tirrifletti stat ta’ implimentazzjoni. Li tħawwad iż-żewġ affarijiet ifisser li tawtorizza funzjoni sempliċiment għax ikkodifikajtha.
# Explicitly define allowed functions
ALLOWED_FUNCTIONS = {
"retrieve_payment_status",
"retrieve_payment_date",
"search_transactions"
}
def execute_tool_call_safe(tool_call, available_functions):
"""Execution with allowlist verification."""
function_name = tool_call.function.name
# Check allowlist
if function_name not in ALLOWED_FUNCTIONS:
return json.dumps({
"error": "forbidden",
"message": f"Function {function_name} is not authorized."
})
if function_name not in available_functions:
return json.dumps({
"error": "not_implemented",
"message": f"Function {function_name} is not implemented."
})
# Execute
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Mhux il-Funzjonijiet Kollha Għandhom l-Istess Piż
Il-qari tal-istatus ta’ ħlas u t-tneħħija ta’ rekords antiki ovvjament ma jġorrux l-istess riskju. Il-klassifikazzjoni tal-funzjonijiet tiegħek skont il-livell—read-only, write, destructive—tippermettilek tagħti lil kull sessjoni jew utent l-ambitu xieraq. Assistent pubbliku għat-traċċar tal-ordnijiet se jaħdem fil-modalità read; għodda back-office tawtorizza l-kitbiet. Għal azzjonijiet distruttivi, it-tweġiba t-tajba mhix li tipprojbixxihom iżda li tiskalahom: il-funzjoni tirritorna confirmation_required, il-mudell jispjega lill-utent x’se jiġri, u bniedem jagħmel is-sejħa finali.
# Risk levels
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"):
"""Executes with permission level verification."""
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"Only read functions are authorized. "
f"{function_name} requires 'write' level."
})
if function_name in DESTRUCTIVE:
return json.dumps({
"error": "confirmation_required",
"message": f"Action {function_name} is destructive and "
f"requires manual confirmation."
})
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Ikkontrolla l-Abbuż u r-Runaways
Loop ta’ konversazzjoni ġestita ħażin tista’ ssejjaħ l-istess funzjoni għexieren ta’ darbiet f’ftit sekondi, kemm jekk minħabba malizzja jew bug sempliċi ta’ katina. Konteur li jiżżerżaq fuq sittin sekonda għal kull funzjoni jiswew ftit linji ta’ kodiċi u jipprevjenu s-saturazzjoni ta’ API ta’ parti terza fatturata għal kull sejħa.
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()
# Clean up calls older than one 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)
X’Jirritorna lill-Mudell
L-aħħar punt blind spiss ikun l-aktar kostuż. Funzjoni li tirritorna ringiela sħiħa tad-database tista’ tinkludi hash tal-password, API key, jew numru tal-karta. Madankollu, kull ma tqiegħed f’messaġġ tool jidħol fil-kuntest tal-mudell, li jfisser li jista’ potenzjalment jidher fir-rispons tiegħu fuq l-iskrin, fil-logs tiegħek, u fit-tarf tal-fornitur tiegħek. Il-maskra tal-oqsma sensittivi qabel ma tibgħathom—rikorsivament, biex tkopri oġġetti mbejjta—hija l-prekawzjoni li ssalvak minn inċident ta’ tnixxija ta’ dejta.
def sanitize_result(result: dict) -> dict:
"""Removes sensitive fields before returning to the model."""
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
Punti Ewlenin
- Dejjem ivvalida l-argumenti qabel ma tesegwixxi funzjoni—format, tip, valuri permessi
- Uża mistqsijiet parametrizzati biex tipprevjeni SQL injection
- Implimenta allowlist ta’ funzjonijiet awtorizzati
- Ikklassifika l-funzjonijiet skont il-livell ta’ riskju (read, write, destructive)
- Żid limitazzjoni tar-rata biex tipprevjeni l-abbuż
- Sanitizza ir-riżultati biex tevita li tesponi dejta sensittiva lill-mudell