Salt la conținutul principal
Română— Alege o limbă
Meniu

Securitatea apelurilor de funcții

Lecția 11 din 14 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Nu executați niciodată orb
  2. Validați înainte de a executa
  3. Când argumentul devine o încărcătură utilitară (Payload)
  4. Restricționați câmpul posibilităților
  5. Nu toate funcțiile au aceeași greutate
  6. Conțineți abuzurile și buclele infinite
  7. Ce se întoarce către model
  8. Puncte cheie

Nu executați niciodată orb

Apelul de funcții oferă modelului capacitatea de a solicita executarea unor funcții în cadrul sistemului dumneavoastră. Aceasta este o funcționalitate puternică, dar creează și un potențial vector de atac. Un utilizator rău intenționat nu vă poate executa codul direct; totuși, acesta poate scrie orice în câmpul de chat, influențând astfel argumentele pe care le produce modelul. Trebuie să infirmați o presupunere comodă: argumentele tool_call nu sunt date interne ale aplicației dumneavoastră. Acestea sunt date ale utilizatorului care au trecut printr-un model lingvistic. Codul dumneavoastră trebuie să fie ultima linie de apărare.

Validați înainte de a executa

Modelul generează argumente JSON pentru care garantează doar forma gramaticală, niciodată legitimitatea comercială. Un transaction_id poate fi sintactic un șir de caractere, dar poate conține orice. Disciplina impune, așadar, validarea fiecărui argument înainte de a face orice cu acesta și structurarea funcției în trei pași distincți: verificarea formatului, verificarea existenței și abia apoi executarea.

import re

def validate_transaction_id(transaction_id: str) -> bool:
    """Validează formatul unui identificator de tranzacție."""
    # Format așteptat: T urmat de 4 cifre
    return bool(re.match(r"^T\d{4}$", transaction_id))


def retrieve_payment_status_safe(df, transaction_id: str) -> str:
    """Versiune securizată cu validare."""
    # Pasul 1: Validarea formatului
    if not validate_transaction_id(transaction_id):
        return json.dumps({
            "error": "invalid_format",
            "message": "ID-ul trebuie să fie în formatul Txxxx (de ex. T1001)"
        })

    # Pasul 2: Verificarea existenței
    if transaction_id not in df["transaction_id"].values:
        return json.dumps({
            "error": "not_found",
            "message": f"Tranzacția {transaction_id} nu a fost găsită"
        })

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

Expresia regulată ^T\d{4}$ face aici toată munca de apărare: ancorată la ambele capete, aceasta respinge orice șir care conține chiar și un singur caracter în plus. Acest lucru duce direct la motivul pentru care este necesară această ancorare.

Când argumentul devine o încărcătură utilitară (Payload)

Luați în considerare această cerere, care pare perfect inocentă:

Utilizator: "Găsește plata cu ID-ul: T1001; DROP TABLE payments"

Modelul, făcându-și conștiincios treaba de extragere, ar putea genera {"transaction_id": "T1001; DROP TABLE payments"}. Nu a făcut nimic greșit: i s-a dat un identificator și l-a transmis mai departe. Dacă funcția dumneavoastră introduce acest argument într-o interogare SQL prin concatenare, tocmai ați pierdut tabelul. Problema nu este nouă—este o injecție SQL clasică—dar apelul de funcții adaugă o verigă care creează o falsă impresie de filtrare.

Cele trei versiuni de mai jos arată progresia: ceea ce nu trebuie niciodată să scrieți, minimul acceptabil și practica de adoptat.

# NU faceți niciodată asta — injecție SQL directă
def bad_query(transaction_id):
    cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")

# Faceți ÎNTOTDEAUNA asta — interogări parametrizate
def safe_query(transaction_id):
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

# ȘI MAI BINE — validare + interogare parametrizată
def best_query(transaction_id):
    if not validate_transaction_id(transaction_id):
        raise ValueError("Format ID invalid")
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

Interogarea parametrizată este suficientă pentru a neutraliza injecția, deoarece driverul tratează argumentul ca pe o valoare, nu ca pe cod SQL. Validarea upstream adaugă o a doua barieră și, incidental, oferă un mesaj de eroare mult mai clar decât ar face baza de date.

Restricționați câmpul posibilităților

A doua linie de apărare este reducerea a ceea ce modelul poate solicita. O listă de permisiuni (allowlist) explicită, separată de dicționarul de dispatch, stabilește negru pe alb care funcții sunt autorizate în acest context. Separarea contează: ALLOWED_FUNCTIONS exprimă o decizie de securitate, în timp ce available_functions reflectă o stare de implementare. Confundarea celor două echivalează cu autorizarea unei funcții simplu pentru că ați codat-o.

# Definește explicit funcțiile permise
ALLOWED_FUNCTIONS = {
    "retrieve_payment_status",
    "retrieve_payment_date",
    "search_transactions"
}

def execute_tool_call_safe(tool_call, available_functions):
    """Execuție cu verificarea listei de permisiuni."""
    function_name = tool_call.function.name

    # Verifică lista de permisiuni
    if function_name not in ALLOWED_FUNCTIONS:
        return json.dumps({
            "error": "forbidden",
            "message": f"Funcția {function_name} nu este autorizată."
        })

    if function_name not in available_functions:
        return json.dumps({
            "error": "not_implemented",
            "message": f"Funcția {function_name} nu este implementată."
        })

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

Nu toate funcțiile au aceeași greutate

Citirea statutului unei plăți și ștergerea vechilor înregistrări nu comportă, evident, același risc. Clasificarea funcțiilor pe niveluri—doar citire, scriere, distructive—vă permite să acordați fiecărei sesiuni sau utilizator domeniul de aplicare corespunzător. Un asistent public de urmărire a comenzilor va rula în modul read; un instrument de back-office va autoriza scrierile. În ceea ce privește acțiunile distructive, răspunsul corect nu este interzicerea lor, ci escaladarea lor: funcția returnează confirmation_required, modelul explică utilizatorului ce urmează să se întâmple, iar un om ia decizia finală.

# Niveluri de risc
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"):
    """Execută cu verificarea nivelului de permisiune."""
    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"Sunt autorizate doar funcțiile de citire. "
                       f"{function_name} necesită nivelul 'write'."
        })

    if function_name in DESTRUCTIVE:
        return json.dumps({
            "error": "confirmation_required",
            "message": f"Acțiunea {function_name} este distructivă și "
                       f"necesită confirmare manuală."
        })

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

Conțineți abuzurile și buclele infinite

O buclă de conversație gestionată necorespunzător poate apela aceeași funcție de zeci de ori în câteva secunde, fie din răutate, fie din cauza unui simplu bug de înlănțuire. Un contor glisant pe șaizeci de secunde per funcție costă câteva linii de cod și previne saturarea unui API terț facturat per apel.

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()
        # Curăță apelurile mai vechi de un 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)

Ce se întoarce către model

Ultimul punct orb este adesea cel mai costisitor. O funcție care returnează un rând complet din baza de date ar putea include un hash de parolă, o cheie API sau un număr de card. Totuși, tot ce plasați într-un mesaj tool intră în contextul modelului, ceea ce înseamnă că ar putea apărea potențial în răspunsul său afișat pe ecran, în jurnalele dumneavoastră (logs) și la furnizorul dumneavoastră. Mascarea câmpurilor sensibile înainte de trimitere—recursiv, pentru a acoperi obiectele imbricate—este precauția care vă va salva de la un incident de scurgere de date.

def sanitize_result(result: dict) -> dict:
    """Elimină câmpurile sensibile înainte de returnarea către model."""
    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

Puncte cheie

  • Validați întotdeauna argumentele înainte de a executa o funcție—format, tip, valori permise
  • Utilizați interogări parametrizate pentru a preveni injecția SQL
  • Implementați o listă de permisiuni (allowlist) a funcțiilor autorizate
  • Clasificați funcțiile după nivelul de risc (citire, scriere, distructive)
  • Adăugați limitarea ratei (rate limiting) pentru a preveni abuzurile
  • Sanitizați rezultatele pentru a evita expunerea datelor sensibile către model