Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Function Calling'i turvalisus

Õppetund 11 / 14 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Ära kunagi käivita pimesi
  2. Valideeri enne käivitamist
  3. Kui argumendist saab payload
  4. Piira võimaluste välja
  5. Kõik funktsioonid ei kanna sama kaalu
  6. Tõrju kuritarvitamist ja lõpmatuid tsükleid
  7. Mis naaseb mudelile
  8. Peamised punktid

Ä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