Sikkerhed ved funktionskald
På denne side
Udfør aldrig blindt
Funktionskald giver modellen evnen til at anmode om udførelse af funktioner i dit system. Det er kraftfuldt, men det skaber også en potentiel angrebsvektor. En ondsindet bruger kan ikke udføre din kode direkte; de kan dog skrive hvad som helst i chatfeltet og dermed påvirke de argumenter, modellen producerer. Du skal vende en behagelig antagelse på hovedet: Argumenterne i tool_call er ikke interne data fra din applikation. Det er brugerdata, der er passeret gennem en sprogmodel. Din kode skal være dit sidste forsvar.
Valider før udførelse
Modellen genererer JSON-argumenter, hvor den garanterer den grammatikalske form, aldrig den forretningsmæssige legitimitet. Et transaction_id kan være syntaktisk en streng, men indeholde hvad som helst. Disciplinen er derfor at validere hvert argument, før du gør noget med det, og at strukturere funktionen i tre distinkte trin: verificer formatet, verificer eksistensen, og først derefter udfør.
import re
def validate_transaction_id(transaction_id: str) -> bool:
"""Validerer formatet på en transaktionsidentifikator."""
# Forventet format: T efterfulgt af 4 cifre
return bool(re.match(r"^T\d{4}$", transaction_id))
def retrieve_payment_status_safe(df, transaction_id: str) -> str:
"""Sikker version med validering."""
# Trin 1: Valider format
if not validate_transaction_id(transaction_id):
return json.dumps({
"error": "invalid_format",
"message": "ID skal være i formatet Txxxx (f.eks. T1001)"
})
# Trin 2: Tjek eksistens
if transaction_id not in df["transaction_id"].values:
return json.dumps({
"error": "not_found",
"message": f"Transaktion {transaction_id} ikke fundet"
})
# Trin 3: Udfør
status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
return json.dumps({"status": status})
Det regulære udtryk ^T\d{4}$ udfører alt det defensive arbejde her: Det er forankret i begge ender og afviser enhver streng, der indeholder selv et enkelt ekstra tegn. Dette leder direkte til årsagen til denne forankring.
Når argumentet bliver en payload
Overvej denne anmodning, som ser helt uskyldig ud:
Bruger: "Find betalingen med ID: T1001; DROP TABLE payments"
Modellen, som samvittighedsfuldt udfører sit ekstraktionsarbejde, kan generere {"transaction_id": "T1001; DROP TABLE payments"}. Den har ikke gjort noget forkert: Den fik en identifikator og videregav den. Hvis din funktion indsætter dette argument i en SQL-forespørgsel via sammenkædning, har du lige mistet din tabel. Problemet er ikke nyt – det er klassisk SQL-injection – men funktionskald tilføjer et led, der skaber et falsk indtryk af filtrering.
De følgende tre versioner viser udviklingen: hvad du aldrig må skrive, det absolutte minimum, der er acceptabelt, og den praksis, du bør adoptere.
# GØR ALDRIG dette — direkte SQL-injection
def bad_query(transaction_id):
cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")
# GØR ALTID dette — parametriserede forespørgsler
def safe_query(transaction_id):
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
# ENDNU BEDRE — validering + parametriseret forespørgsel
def best_query(transaction_id):
if not validate_transaction_id(transaction_id):
raise ValueError("Ugyldigt ID-format")
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
Den parametriserede forespørgsel er tilstrækkelig til at neutralisere injection, da driveren behandler argumentet som en værdi og ikke som SQL. Validering upstream tilføjer en anden barriere og giver tilfældigvis en meget klarere fejlmeddelelse, end databasen ville gøre.
Begræns mulighedsfeltet
Den anden forsvarslinje er at reducere, hvad modellen kan anmode om. En eksplicit tilladelsesliste (allowlist), adskilt fra dit dispatch-ordbog, angiver sort på hvidt, hvilke funktioner der er autoriserede i denne kontekst. Adskillelsen betyder noget: ALLOWED_FUNCTIONS udtrykker en sikkerhedsbeslutning, mens available_functions afspejler en implementeringstilstand. At forveksle de to svarer til at autorisere en funktion simpelthen fordi, du har kodet den.
# Definer eksplicit tilladte funktioner
ALLOWED_FUNCTIONS = {
"retrieve_payment_status",
"retrieve_payment_date",
"search_transactions"
}
def execute_tool_call_safe(tool_call, available_functions):
"""Udførelse med verificering af tilladelsesliste."""
function_name = tool_call.function.name
# Tjek tilladelsesliste
if function_name not in ALLOWED_FUNCTIONS:
return json.dumps({
"error": "forbidden",
"message": f"Funktionen {function_name} er ikke autoriseret."
})
if function_name not in available_functions:
return json.dumps({
"error": "not_implemented",
"message": f"Funktionen {function_name} er ikke implementeret."
})
# Udfør
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Ikke alle funktioner har samme vægt
At læse en betalingsstatus og at rydde gamle poster bærer åbenlyst ikke samme risiko. Ved at klassificere dine funktioner efter niveau – skrivebeskyttet, skrivning, destruktiv – kan du give hver session eller bruger det passende omfang. En offentlig ordresporingsassistent kører i read-tilstand; et backoffice-værktøj vil autorisere skrivning. Hvad angår destruktive handlinger, er det rigtige svar ikke at forbyde dem, men at eskalere dem: Funktionen returnerer confirmation_required, modellen forklarer brugeren, hvad der er ved at ske, og et menneske træffer den endelige beslutning.
# Risikoniveauer
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"):
"""Udfører med verificering af tilladelsesniveau."""
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"Kun læsefunktioner er autoriserede. "
f"{function_name} kræver 'write'-niveau."
})
if function_name in DESTRUCTIVE:
return json.dumps({
"error": "confirmation_required",
"message": f"Handlingen {function_name} er destruktiv og "
f"kræver manuel bekræftelse."
})
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Inddæm misbrug og løbske processer
En dårligt styret samtaleloop kan kalde den samme funktion dusinvis af gange på få sekunder, hvad enten det skyldes ond vilje eller en simpel kædningsfejl. En glidende tæller over tres sekunder pr. funktion koster få linjer kode og forhindrer mætning af en tredjeparts-API, der faktureres pr. kald.
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()
# Ryd op i kald ældre end ét 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)
Hvad der returneres til modellen
Det sidste blinde punkt er ofte det dyreste. En funktion, der returnerer en komplet databaserække, kan inkludere et adgangskode-hash, en API-nøgle eller et kortnummer. Alt, hvad du placerer i en tool-besked, kommer ind i modellens kontekst, hvilket betyder, at det potentielt kan dukke op i dens svar på skærmen, i dine logs og hos din udbyder. At maskere følsomme felter før afsendelse – rekursivt for at dække nestede objekter – er den forholdsregel, der vil spare dig for en hændelse med datalæk.
def sanitize_result(result: dict) -> dict:
"""Fjerner følsomme felter før returnering til modellen."""
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
Vigtige pointer
- Valider altid argumenter før udførelse af en funktion – format, type, tilladte værdier
- Brug parametriserede forespørgsler for at forhindre SQL-injection
- Implementer en tilladelsesliste over autoriserede funktioner
- Klassificer funktioner efter risikoniveau (læs, skriv, destruktiv)
- Tilføj hastighedsbegrænsning for at forhindre misbrug
- Rens resultater for at undgå at eksponere følsomme data for modellen