Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Function Calling Security

Paskaita 11 iš 14 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Niekada nevykdyk aklai
  2. Patikrink prieš vykdydamas
  3. Kai argumentas tampa našta
  4. Apribok galimybių lauką
  5. Ne visos funkcijos turi tą pačią svorį
  6. Suvaldyk piktnaudžiavimą ir begalinius ciklus
  7. Kas grąžinama modeliui
  8. Svarbiausi punktai

Niekada nevykdyk aklai

Function calling suteikia modeliui galimybę prašyti vykdyti funkcijas tavo sistemoje. Tai galinga, tačiau kartu sukuria potencialią atakos vietą. Piktavališkas vartotojas negali tiesiogiai vykdyti tavo kodo, tačiau jis gali rašyti bet ką pokalbio lauke ir taip daryti įtaką modelio generuojamiems argumentams. Turi paneigti vieną patogią prielaidą: tool_call argumentai nėra vidiniai tavo programos duomenys. Tai vartotojo duomenys, praėję per kalbos modelį. Tavo kodas turi būti paskutinė gynybos linija.

Patikrink prieš vykdydamas

Modelis generuoja JSON argumentus, kuriuose garantuojama tik gramatinė forma, o ne verslo teisėtumas. transaction_id gali būti sintaksiškai eilutė, tačiau joje gali būti bet kas. Todėl disciplina reikalauja patikrinti kiekvieną argumentą prieš atliekant bet kokius veiksmus su juo ir struktūruoti funkciją į tris atskirus žingsnius: patikrinti formatą, patikrinti egzistavimą ir tik tada vykdyti.

import re

def validate_transaction_id(transaction_id: str) -> bool:
    """Patikrina sandorio identifikatoriaus formatą."""
    # Tikėtinas formatas: T ir 4 skaitmenys
    return bool(re.match(r"^T\d{4}$", transaction_id))


def retrieve_payment_status_safe(df, transaction_id: str) -> str:
    """Saugi versija su patikra."""
    # 1 žingsnis: Patikrinti formatą
    if not validate_transaction_id(transaction_id):
        return json.dumps({
            "error": "invalid_format",
            "message": "ID turi būti Txxxx formato (pvz., T1001)"
        })

    # 2 žingsnis: Patikrinti egzistavimą
    if transaction_id not in df["transaction_id"].values:
        return json.dumps({
            "error": "not_found",
            "message": f"Sandoris {transaction_id} nerastas"
        })

    # 3 žingsnis: Vykdyti
    status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
    return json.dumps({"status": status})

Reguliarusis reiškinys ^T\d{4}$ čia atlieka visą apsauginį darbą: įtvirtintas abiejose pusėse, jis atmeta bet kurią eilutę, turinčią net vieną papildomą simbolį. Tai tiesiogiai veda prie šio įtvirtinimo priežasties.

Kai argumentas tampa našta

Apsvarstyk šį prašymą, kuris atrodo visiškai nekaltas:

User: "Find the payment with ID: T1001; DROP TABLE payments"

Modelis, sąžiningai atlikdamas savo ištraukimo darbą, gali sugeneruoti {"transaction_id": "T1001; DROP TABLE payments"}. Jis nieko blogo nepadarė: jam buvo pateiktas identifikatorius, ir jis jį perdavė toliau. Jei tavo funkcija įterpia šį argumentą į SQL užklausą naudodama konkatenaciją, tu ką tik praradai savo lentelę. Problema nėra nauja – tai klasikinė SQL injekcija – tačiau function calling sukuria papildomą grandį, kuri klaidingai sukuria filtravimo įspūdį.

Šios trys versijos rodo progresiją: ko niekada negalima rašyti, minimalų priimtiną lygį ir praktiką, kurios reikia laikytis.

# NIEKADA nedaryk taip – tiesioginė SQL injekcija
def bad_query(transaction_id):
    cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")

# VISADA daryk taip – parametrizuotos užklausos
def safe_query(transaction_id):
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

# DAR GERIAU – patikra + parametrizuota užklausa
def best_query(transaction_id):
    if not validate_transaction_id(transaction_id):
        raise ValueError("Neteisingas ID formatas")
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

Parametrizuota užklausa pakanka injekcijai neutralizuoti, nes tvarkyklė argumentą traktuoja kaip reikšmę, o ne kaip SQL kodą. Išankstinis patikrinimas sukuria antrą barjerą ir, be kita ko, pateikia daug aiškesnį klaidos pranešimą nei duomenų bazė.

Apribok galimybių lauką

Antroji gynybos linija – sumažinti tai, ką modelis gali prašyti. Aiškus leidimų sąrašas (allowlist), atskiras nuo tavo nukreipimo žodyno, juodu ant balto nurodo, kurios funkcijos šiame kontekste yra autorizuotos. Šis atskyrimas svarbus: ALLOWED_FUNCTIONS išreiškia saugumo sprendimą, o available_functions atspindi įgyvendinimo būseną. Supainiojus abu, tai reiškia funkcijos autorizavimą vien todėl, kad ją užkodavai.

# Aiškiai apibrėžkite leidžiamas funkcijas
ALLOWED_FUNCTIONS = {
    "retrieve_payment_status",
    "retrieve_payment_date",
    "search_transactions"
}

def execute_tool_call_safe(tool_call, available_functions):
    """Vykdoma su leidimų sąrašo patikra."""
    function_name = tool_call.function.name

    # Patikrinti leidimų sąrašą
    if function_name not in ALLOWED_FUNCTIONS:
        return json.dumps({
            "error": "forbidden",
            "message": f"Funkcija {function_name} nėra autorizuota."
        })

    if function_name not in available_functions:
        return json.dumps({
            "error": "not_implemented",
            "message": f"Funkcija {function_name} nėra įgyvendinta."
        })

    # Vykdyti
    function_params = json.loads(tool_call.function.arguments)
    return available_functions[function_name](**function_params)

Ne visos funkcijos turi tą pačią svorį

Mokėjimo statuso skaitymas ir senų įrašų išvalymas akivaizdžiai kelia skirtingą riziką. Klasifikuodamas savo funkcijas pagal lygį – tik skaitymui, rašymui, destruktyvios – gali suteikti kiekvienai sesijai ar vartotojui tinkamą apimtį. Viešas užsakymų sekimo asistentas veiks read režimu; back-office įrankis leis rašymo operacijas. O dėl destruktyvių veiksmų teisingas atsakymas yra ne jų draudimas, o eskalavimas: funkcija grąžina confirmation_required, modelis paaiškina vartotojui, kas vyksta, ir žmogus priima galutinį sprendimą.

# Rizikos lygiai
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"):
    """Vykdoma su leidimų lygio patikra."""
    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"Autorizuotos tik skaitymo funkcijos. "
                       f"{function_name} reikalauja 'write' lygio."
        })

    if function_name in DESTRUCTIVE:
        return json.dumps({
            "error": "confirmation_required",
            "message": f"Veiksmas {function_name} yra destruktyvus ir "
                       f"reikalauja rankinio patvirtinimo."
        })

    function_params = json.loads(tool_call.function.arguments)
    return available_functions[function_name](**function_params)

Suvaldyk piktnaudžiavimą ir begalinius ciklus

Prastai valdomas pokalbio ciklas gali tą pačią funkciją iškviesti dešimtis kartų per kelias sekundes, nesvarbu, ar dėl piktavališkumo, ar dėl paprastos grandininės klaidos. Slankusis skaitiklis per šešiasdešimt sekundžių vienai funkcijai kainuoja kelias kodo eilutes ir neleidžia perkrauti trečiosios šalies API, apmokestinamo už kiekvieną kvietimą.

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()
        # Išvalyti kvietimus, senesnius nei viena 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)

Kas grąžinama modeliui

Paskutinė aklavietė dažnai būna pati brangiausia. Funkcija, grąžinanti visą duomenų bazės eilutę, gali įtraukti slaptažodžio maišą, API raktą arba kortelės numerį. Tačiau viskas, ką įdedi į tool žinutę, patenka į modelio kontekstą, o tai reiškia, kad tai potencialiai gali atsirasti jo ekrane rodomame atsakyme, tavo žurnaluose ir pas tavo tiekėją. Paslėpti jautrius laukus prieš siunčiant – rekursyviai, kad būtų aprėpti įdėtieji objektai – yra atsargumo priemonė, kuri išgelbės tave nuo duomenų nutekėjimo incidento.

def sanitize_result(result: dict) -> dict:
    """Pašalina jautrius laukus prieš grąžinant modeliui."""
    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

Svarbiausi punktai

  • Visada patikrink argumentus prieš vykdydamas funkciją – formatą, tipą, leistinas reikšmes
  • Naudok parametrizuotas užklausas, kad išvengtum SQL injekcijų
  • Įgyvendink leidimų sąrašą (allowlist) autorizuotoms funkcijoms
  • Klasifikuok funkcijas pagal rizikos lygį (skaitymas, rašymas, destruktyvios)
  • Pridėk užklausų ribojimą (rate limiting), kad išvengtum piktnaudžiavimo
  • Išvalyk rezultatus, kad išvengtum jautrių duomenų atskleidimo modeliui