Function Calling -turvallisuus
Tällä sivulla
Älä koskaan suorita sokeasti
Function calling antaa mallille kyvyn pyytää funktioiden suorittamista järjestelmässäsi. Tämä on tehokasta, mutta se luo myös mahdollisen hyökkäysvektorin. Pahantahtoinen käyttäjä ei voi suorittaa koodiasi suoraan, mutta hän voi kirjoittaa mitä tahansa chat-kenttään ja siten vaikuttaa mallin tuottamiin argumentteihin. Sinun on hylättävä mukava olettamus: tool_call-argumentit eivät ole sovelluksesi sisäistä dataa. Ne ovat käyttäjädataa, joka on kulkenut kielimallin läpi. Koodisi on oltava viimeinen puolustuslinja.
Tarkista ennen suorittamista
Malli tuottaa JSON-argumentteja, joissa se takaa vain kieliopillisen muodon, ei liiketoiminnallista legititeettiä. transaction_id voi olla syntaksillisesti merkkijono, mutta sisältää mitä tahansa. Kurin on siis oltava sellainen, että tarkistat jokaisen argumentin ennen kuin teet sillä mitään, ja rakennat funktion kolmeen erilliseen vaiheeseen: tarkista muoto, tarkista olemassaolo ja vasta sitten suorita.
import re
def validate_transaction_id(transaction_id: str) -> bool:
"""Validoi transaktiotunnisteen muodon."""
# Odotettu muoto: 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:
"""Turvallinen versio validoinnilla."""
# Vaihe 1: Validoi muoto
if not validate_transaction_id(transaction_id):
return json.dumps({
"error": "invalid_format",
"message": "ID:n on oltava muodossa Txxxx (esim. T1001)"
})
# Vaihe 2: Tarkista olemassaolo
if transaction_id not in df["transaction_id"].values:
return json.dumps({
"error": "not_found",
"message": f"Transaktiota {transaction_id} ei löytynyt"
})
# Vaihe 3: Suorita
status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
return json.dumps({"status": status})
Säännöllinen lauseke ^T\d{4}$ tekee kaiken puolustustyön tässä: se on ankkuroitu molemmilta puolilta, joten se hylkää kaikki merkkijonot, jotka sisältävät edes yhden ylimääräisen merkin. Tämä johtaa suoraan syyhyn, miksi ankkurointi on tarpeen.
Kun argumentista tulee hyökkäyskuorma
Harkitse tätä pyyntöä, joka näyttää täysin viattomalta:
User: "Find the payment with ID: T1001; DROP TABLE payments"
Malli, joka tekee extraction-työtään tunnollisesti, saattaa tuottaa {"transaction_id": "T1001; DROP TABLE payments"}. Se ei tehnyt mitään väärin: sille annettiin tunniste, ja se välitti sen eteenpäin. Jos funktiosi lisää tämän argumentin SQL-kyselyyn merkkijonon yhdistämisen kautta, olet juuri menettänyt taulukkosi. Ongelma ei ole uusi – se on klassinen SQL-injektio – mutta function calling lisää linkin, joka luo väärän vaikutelman suodatuksesta.
Seuraavat kolme versiota näyttävät etenemisen: mitä et saa koskaan kirjoittaa, hyväksyttävän minimin ja omaksuttavan käytännön.
# ÄLÄ KOSKAAN tee näin — suora SQL-injektio
def bad_query(transaction_id):
cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")
# AINA tee näin — parametrisoidut kyselyt
def safe_query(transaction_id):
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
# VIELÄ PAREMPI — validointi + parametroitu kysely
def best_query(transaction_id):
if not validate_transaction_id(transaction_id):
raise ValueError("Virheellinen ID-muoto")
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
Parametroitu kysely riittää neutraloimaan injektion, sillä ajuri käsittelee argumenttia arvona, ei SQL-koodina. Ylävirran validointi lisää toisen esteen ja tarjoaa samalla paljon selkeämmän virheilmoituksen kuin tietokanta itse.
Rajoita mahdollisuuksien kenttää
Toinen puolustuslinja on vähentää sitä, mitä malli voi pyytää. Eksplisiittinen sallittujen lista (allowlist), erillään dispatch-sanakirjastasi, määrittelee mustaa valkoisella, mitkä funktiot ovat tässä kontekstissa sallittuja. Erottelulla on väliä: ALLOWED_FUNCTIONS ilmaisee turvallisuuspäätöksen, kun taas available_functions heijastaa toteutustilaa. Näiden sekoittaminen tarkoittaa funktion hyväksymistä pelkästään siksi, että olet koodannut sen.
# Määrittele sallitut funktiot eksplisiittisesti
ALLOWED_FUNCTIONS = {
"retrieve_payment_status",
"retrieve_payment_date",
"search_transactions"
}
def execute_tool_call_safe(tool_call, available_functions):
"""Suoritus allowlist-tarkistuksella."""
function_name = tool_call.function.name
# Tarkista allowlist
if function_name not in ALLOWED_FUNCTIONS:
return json.dumps({
"error": "forbidden",
"message": f"Funktio {function_name} ei ole sallittu."
})
if function_name not in available_functions:
return json.dumps({
"error": "not_implemented",
"message": f"Funktiota {function_name} ei ole toteutettu."
})
# Suorita
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Kaikki funktiot eivät ole yhtä painavia
Maksutilan lukeminen ja vanhojen tietueiden tyhjentäminen eivät ilmeisesti kanna samaa riskiä. Funktioiden luokittelu tason mukaan – vain luku, kirjoitus, tuhoisa – mahdollistaa oikean laajuuden myöntämisen jokaiselle istunnolle tai käyttäjälle. Julkinen tilausten seuranta-assistentti toimii read-tilassa; back-office-työkalu sallii kirjoituksen. Tuhoisien toimintojen osalta oikea vastaus ei ole kieltää niitä, vaan eskaloida ne: funktio palauttaa confirmation_required, malli selittää käyttäjälle, mitä on tapahtumassa, ja ihminen tekee lopullisen päätöksen.
# Riskitasot
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"):
"""Suoritus oikeustason tarkistuksella."""
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"Vain luku-funktiot ovat sallittuja. "
f"{function_name} vaatii 'write'-tason."
})
if function_name in DESTRUCTIVE:
return json.dumps({
"error": "confirmation_required",
"message": f"Toiminto {function_name} on tuhoisa ja "
f"vaatii manuaalisen vahvistuksen."
})
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Hillitse väärinkäyttöä ja silmukoita
Huonosti hallittu keskustelusilmukka voi kutsua samaa funktiota kymmeniä kertoja muutamassa sekunnissa, oli syynä sitten pahantahtoisuus tai yksinkertainen ketjutusvirhe. Liukuva laskuri kuudenkymmenen sekunnin ajalta funktiota kohden maksaa muutaman rivin koodia ja estää kolmannen osapuolen API:n kyllästymisen, jos sitä laskutetaan kutsukohtaisesti.
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()
# Puhdista yli minuutin vanhat kutsut
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)
Mitä palautetaan mallille
Viimeinen sokea piste on usein kallein. Funktio, joka palauttaa kokonaisen tietokannan rivin, saattaa sisältää salasanan tiivisteen, API-avaimen tai korttinumeron. Kaikki, mitä sijoitat tool-viestiin, päätyy mallin kontekstiin, mikä tarkoittaa, että se voi potentiaalisesti ilmestyä sen näyttövasteeseen, lokkeihisi ja palveluntarjoajasi päätyyn. Arkaluonteisten kenttien peittäminen ennen lähetystä – rekursiivisesti pesiytyneiden objektien kattamiseksi – on varotoimi, joka pelastaa sinut tietovuototapaukselta.
def sanitize_result(result: dict) -> dict:
"""Poistaa arkaluonteiset kentät ennen palauttamista mallille."""
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
Keskeiset asiat
- Validoi aina argumentit ennen funktion suorittamista – muoto, tyyppi, sallitut arvot
- Käytä parametroituja kyselyitä SQL-injektion estämiseksi
- Toteuta sallittujen funktioiden lista (allowlist)
- Luokittele funktiot riskitason mukaan (luku, kirjoitus, tuhoisa)
- Lisää nopeusrajoitus väärinkäytön estämiseksi
- Puhdista tulokset välttääksesi arkaluonteisen datan paljastumisen mallille