Säkerhet vid funktionsanrop
På denna sida
Exekvera aldrig blindt
Funktionsanrop ger modellen möjlighet att begära körning av funktioner i ditt system. Det är kraftfullt, men skapar också en potentiell attackvektor. En illvillig användare kan inte exekvera din kod direkt, men kan skriva vad som helst i chattfältet och därmed påverka de argument modellen producerar. Du måste överge en bekväm föreställning: argumenten i tool_call är inte intern data från din applikation. Det är användardata som har passerat genom en språkmodell. Din kod måste vara den sista försvarslinjen.
Validera innan exekvering
Modellen genererar JSON-argument där den garanterar den grammatiska formen, aldrig den affärsmässiga legitimiteten. Ett transaction_id kan vara syntaktiskt en sträng men ändå innehålla vad som helst. Disciplinen är därför att validera varje argument innan du gör något med det, och att strukturera funktionen i tre distinkta steg: verifiera formatet, verifiera existensen och först därefter exekvera.
import re
def validate_transaction_id(transaction_id: str) -> bool:
"""Validerar formatet på ett transaktionsidentifierare."""
# Förväntat format: T följt av 4 siffror
return bool(re.match(r"^T\d{4}$", transaction_id))
def retrieve_payment_status_safe(df, transaction_id: str) -> str:
"""Säker version med validering."""
# Steg 1: Validera format
if not validate_transaction_id(transaction_id):
return json.dumps({
"error": "invalid_format",
"message": "ID måste vara i formatet Txxxx (t.ex. T1001)"
})
# Steg 2: Kontrollera existens
if transaction_id not in df["transaction_id"].values:
return json.dumps({
"error": "not_found",
"message": f"Transaktion {transaction_id} hittades inte"
})
# Steg 3: Exekvera
status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
return json.dumps({"status": status})
Det reguljära uttrycket ^T\d{4}$ gör allt det defensiva arbetet här: förankrat på båda sidorna, avvisar det varje sträng som innehåller ens ett enda extra tecken. Detta leder direkt till anledningen för denna förankring.
När argumentet blir en payload
Tänk på denna begäran, som verkar helt oskyldig:
Användare: "Hitta betalningen med ID: T1001; DROP TABLE payments"
Modellen, som samvetsgrant gör sitt extraheringsjobb, kan generera {"transaction_id": "T1001; DROP TABLE payments"}. Den gjorde inget fel: den fick ett identifierare och skickade det vidare. Om din funktion infogar detta argument i en SQL-fråga via konkatenering har du precis förlorat din tabell. Problemet är inte nytt – det är klassisk SQL-injection – men funktionsanrop lägger till en länk som skapar en falsk känsla av filtrering.
De följande tre versionerna visar progressionen: vad du aldrig får skriva, det absoluta minimum som är acceptabelt, och praxisen du bör anta.
# GÖR ALDRIG detta — direkt SQL-injection
def bad_query(transaction_id):
cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")
# GÖR ALLTID detta — parametriserade frågor
def safe_query(transaction_id):
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
# ÄNNU BÄTTRE — validering + parametriserad fråga
def best_query(transaction_id):
if not validate_transaction_id(transaction_id):
raise ValueError("Ogiltigt ID-format")
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
Den parametriserade frågan räcker för att neutralisera injection, eftersom drivrutinen behandlar argumentet som ett värde, inte som SQL. Validering uppströms lägger till en andra barriär och ger dessutom ett mycket tydligare felmeddelande än vad databasen skulle göra.
Begränsa möjliga alternativ
Den andra försvarslinjen är att minska vad modellen kan begära. En explicit tillåten lista (allowlist), separat från din dispatch-ordbok, anger svart på vitt vilka funktioner som är auktoriserade i detta sammanhang. Separationen är viktig: ALLOWED_FUNCTIONS uttrycker ett säkerhetsbeslut, medan available_functions speglar ett implementeringstillstånd. Att blanda ihop dessa två innebär att du auktoriserar en funktion helt enkelt för att du har kodat den.
# Definiera explicit tillåtna funktioner
ALLOWED_FUNCTIONS = {
"retrieve_payment_status",
"retrieve_payment_date",
"search_transactions"
}
def execute_tool_call_safe(tool_call, available_functions):
"""Exekvering med verifiering mot tillåten lista."""
function_name = tool_call.function.name
# Kontrollera tillåten lista
if function_name not in ALLOWED_FUNCTIONS:
return json.dumps({
"error": "forbidden",
"message": f"Funktionen {function_name} är inte auktoriserad."
})
if function_name not in available_functions:
return json.dumps({
"error": "not_implemented",
"message": f"Funktionen {function_name} är inte implementerad."
})
# Exekvera
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Alla funktioner bär inte samma vikt
Att läsa en betalningsstatus och att rensa gamla register bär uppenbarligen inte samma risk. Att klassificera dina funktioner efter nivå – skrivskyddad, skrivning, destruktiv – låter dig bevilja varje session eller användare lämplig behörighet. En offentlig assistent för orderföljning kommer att köras i read-läge; ett back-office-verktyg kommer att auktorisera skrivningar. När det gäller destruktiva åtgärder är inte svaret att förbjuda dem, utan att eskalera dem: funktionen returnerar confirmation_required, modellen förklarar för användaren vad som håller på att hända, och en människa fattar det slutgiltiga beslutet.
# Risknivåer
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"):
"""Exekverar med verifiering av behörighetsnivå."""
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"Endast läsfunktioner är auktoriserade. "
f"{function_name} kräver nivån 'write'."
})
if function_name in DESTRUCTIVE:
return json.dumps({
"error": "confirmation_required",
"message": f"Åtgärden {function_name} är destruktiv och "
f"kräver manuell bekräftelse."
})
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Inneslut missbruk och oändliga loopar
En dåligt hanterad konversationsloop kan anropa samma funktion dussintals gånger på några sekunder, oavsett om det beror på illvilja eller ett enkelt kedjekopplingsfel. En glidande räknare över sextio sekunder per funktion kostar några rader kod och förhindrar att ett tredjeparts-API, som debiteras per anrop, överbelastas.
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()
# Rensa anrop äldre än en 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)
Vad som returneras till modellen
Den sista blindfläcken är ofta den dyraste. En funktion som returnerar en komplett databasrad kan inkludera en lösenordshash, en API-nyckel eller ett kortnummer. Men allt du placerar i ett tool-meddelande hamnar i modellens kontext, vilket betyder att det potentiellt kan dyka upp i dess svar på skärmen, i dina loggar och hos din leverantör. Att maskera känsliga fält innan sändning – rekursivt, för att täcka nästlade objekt – är försiktighetsåtgärden som räddar dig från en incident med dataintrång.
def sanitize_result(result: dict) -> dict:
"""Tar bort känsliga fält innan returnering till 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
Viktiga punkter
- Validera alltid argument innan du exekverar en funktion – format, typ, tillåtna värden
- Använd parametriserade frågor för att förhindra SQL-injection
- Implementera en tillåten lista (allowlist) över auktoriserade funktioner
- Klassificera funktioner efter risknivå (läs, skriv, destruktiv)
- Lägg till hastighetsbegränsning (rate limiting) för att förhindra missbruk
- Sanera resultat för att undvika att exponera känslig data för modellen