Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Drošība, izsaucot funkcijas

Nodarbība 11 no 14 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Nekad neizpildi akli
  2. Validē pirms izpildes
  3. Kad arguments kļūst par slodzi
  4. Ierobežo iespēju lauku
  5. Ne visām funkcijām ir vienāds svars
  6. Ierobežo ļaunprātīgu izmantošanu un pārmērīgu izpildi
  7. Kas tiek atgriezts modelim
  8. Galvenās atziņas

Nekad neizpildi akli

Funkciju izsaukšana dod modelim iespēju pieprasīt funkciju izpildi tavā sistēmā. Tas ir spēcīgs instruments, taču vienlaikus rada potenciālu uzbrukuma vektoru. Ļaunprātīgs lietotājs nevar tieši izpildīt tavu kodu, tomēr tas var ierakstīt jebko čata laukā, tādējādi ietekmējot modeļa ģenerētos argumentus. Tev ir jāatsakās no ērtā pieņēmuma: tool_call argumenti nav tavi iekšējie lietojumprogrammas dati. Tie ir lietotāja dati, kas izgājuši caur valodas modeli. Tavam kodam ir jābūt pēdējai aizsardzības līnijai.

Validē pirms izpildes

Modelis ģenerē JSON argumentus, garantējot tikai gramatisko formu, nevis biznesa leģitimitāti. transaction_id var būt sintaktiski virkne, taču saturēt jebko. Tādēļ disciplīna prasa validēt katru argumentu pirms jebkādas darbības ar to un strukturēt funkciju trīs atsevišķos soļos: pārbaudīt formātu, pārbaudīt esamību un tikai tad izpildīt.

import re

def validate_transaction_id(transaction_id: str) -> bool:
    """Validē darījuma identifikatora formātu."""
    # Paredzētais formāts: T, kam seko 4 cipari
    return bool(re.match(r"^T\d{4}$", transaction_id))


def retrieve_payment_status_safe(df, transaction_id: str) -> str:
    """Droša versija ar validāciju."""
    # 1. solis: Validē formātu
    if not validate_transaction_id(transaction_id):
        return json.dumps({
            "error": "invalid_format",
            "message": "ID ir jābūt formātā Txxxx (piem., T1001)"
        })

    # 2. solis: Pārbaudi esamību
    if transaction_id not in df["transaction_id"].values:
        return json.dumps({
            "error": "not_found",
            "message": f"Darījums {transaction_id} nav atrasts"
        })

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

Regulārā izteiksme ^T\d{4}$ šeit veic visu aizsardzības darbu: piesaistīta abos galos, tā noraida jebkuru virkni, kas satur pat vienu lieku rakstzīmi. Tas tieši noved pie šīs piesaistes iemesla.

Kad arguments kļūst par slodzi

Apsver šo pieprasījumu, kas šķiet pilnīgi nevainīgs:

Lietotājs: "Atrodi maksājumu ar ID: T1001; DROP TABLE payments"

Modelis, godīgi veicot savu ekstrakcijas darbu, var ģenerēt {"transaction_id": "T1001; DROP TABLE payments"}. Tas nav izdarījis neko nepareizu: tam tika dots identifikators, un tas to nodeva tālāk. Ja tava funkcija ievieto šo argumentu SQL vaicājumā, izmantojot konkatenāciju, tu tikko esi zaudējis savu tabulu. Problēma nav jauna – tā ir klasiska SQL injekcija –, taču funkciju izsaukšana pievieno saiti, kas rada maldīgu filtrēšanas iespaidu.

Turpmākās trīs versijas parāda attīstību: ko nekad nedrīkst rakstīt, minimālo pieņemamo līmeni un praksi, kas jāievēro.

# NEKAD nedari tā — tieša SQL injekcija
def bad_query(transaction_id):
    cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")

# VIENMĒR dari tā — parametrizēti vaicājumi
def safe_query(transaction_id):
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

# VĒL LABĀK — validācija + parametrizēts vaicājums
def best_query(transaction_id):
    if not validate_transaction_id(transaction_id):
        raise ValueError("Nederīgs ID formāts")
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

Parametrizēts vaicājums ir pietiekams, lai neitralizētu injekciju, jo draiveris uztver argumentu kā vērtību, nevis kā SQL kodu. Augšupējā validācija pievieno otro barjeru un, starp citu, nodrošina daudz skaidrāku kļūdas ziņojumu nekā datubāze.

Ierobežo iespēju lauku

Otrā aizsardzības līnija ir samazināt to, ko modelis var pieprasīt. Eksplicīts atļauto saraksts (allowlist), kas atdalīts no tavas maršrutēšanas vārdnīcas, melns uz balta nosaka, kuras funkcijas šajā kontekstā ir atļautas. Atdalīšana ir svarīga: ALLOWED_FUNCTIONS izsaka drošības lēmumu, savukārt available_functions atspoguļo implementācijas stāvokli. Sajaukt abus nozīmē atļaut funkciju vienkārši tāpēc, ka esi to uzrakstījis.

# Eksplicīti definē atļautās funkcijas
ALLOWED_FUNCTIONS = {
    "retrieve_payment_status",
    "retrieve_payment_date",
    "search_transactions"
}

def execute_tool_call_safe(tool_call, available_functions):
    """Izpilde ar atļauto saraksta pārbaudi."""
    function_name = tool_call.function.name

    # Pārbaudi atļauto sarakstu
    if function_name not in ALLOWED_FUNCTIONS:
        return json.dumps({
            "error": "forbidden",
            "message": f"Funkcija {function_name} nav atļauta."
        })

    if function_name not in available_functions:
        return json.dumps({
            "error": "not_implemented",
            "message": f"Funkcija {function_name} nav implementēta."
        })

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

Ne visām funkcijām ir vienāds svars

Maksājuma statusa lasīšana un vecu ierakstu dzēšana acīmredzami nerada vienādus riskus. Klasificējot savas funkcijas pēc līmeņiem – tikai lasīšana, rakstīšana, destruktīvas – tu vari piešķirt katrai sesijai vai lietotājam atbilstošu darbības jomu. Publisks pasūtījumu izsekošanas asistents darbosies read režīmā; aizmugures biroja rīks atļaus rakstīšanu. Kas attiecas uz destruktīvām darbībām, pareizā atbilde nav tās aizliegt, bet gan eskalēt: funkcija atgriež confirmation_required, modelis paskaidro lietotājam, kas notiks, un cilvēks pieņem galīgo lēmumu.

# Riska līmeņi
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"):
    """Izpilde ar atļauju līmeņa pārbaudi."""
    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"Atļautas tikai lasīšanas funkcijas. "
                       f"{function_name} prasa 'write' līmeni."
        })

    if function_name in DESTRUCTIVE:
        return json.dumps({
            "error": "confirmation_required",
            "message": f"Darbība {function_name} ir destruktīva un "
                       f"prasa manuālu apstiprinājumu."
        })

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

Ierobežo ļaunprātīgu izmantošanu un pārmērīgu izpildi

Slikti pārvaldīts sarunu cikls var izsaukt to pašu funkciju desmitiem reižu dažu sekunžu laikā, vai nu ļaunprātības, vai vienkāršas ķēdes kļūdas dēļ. Slīdošs skaitītājs sešdesmit sekundēm katrai funkcijai aizņem tikai dažas koda rindiņas un novērš trešās puses API noslogošanu, kas tiek apmaksāts par izsaukumu.

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()
        # Notīri izsaukumus, kas vecāki par vienu minūti
        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 tiek atgriezts modelim

Pēdējais aklais punkts bieži vien ir visdārgākais. Funkcija, kas atgriež pilnu datubāzes rindu, var ietvert paroles hašu, API atslēgu vai kartes numuru. Tomēr viss, ko ievieto tool ziņojumā, nonāk modeļa kontekstā, kas nozīmē, ka tas potenciāli var parādīties tā ekrāna atbildē, tavos žurnālos un pie tava pakalpojumu sniedzēja. Konfidenciālo lauku maskēšana pirms nosūtīšanas – rekursīvi, lai aptvertu ligzdotus objektus – ir piesardzība, kas pasargās tevi no datu noplūdes incidenta.

def sanitize_result(result: dict) -> dict:
    """Noņem konfidenciālos laukus pirms atgriešanas modelim."""
    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

Galvenās atziņas

  • Vienmēr validē argumentus pirms funkcijas izpildes – formātu, tipu, atļautās vērtības
  • Izmanto parametrizētus vaicājumus, lai novērstu SQL injekcijas
  • Implementē atļauto funkciju sarakstu (allowlist)
  • Klasificē funkcijas pēc riska līmeņa (lasīšana, rakstīšana, destruktīvas)
  • Pievieno ātruma ierobežošanu (rate limiting), lai novērstu ļaunprātīgu izmantošanu
  • Attīri rezultātus, lai izvairītos no konfidenciālu datu atklāšanas modelim