Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Sigurnost pozivanja funkcija

Lekcija 11 od 14 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Nikada ne izvršavaj slijepo
  2. Validiraj prije izvršavanja
  3. Kada argument postaje payload
  4. Ograniči polje mogućnosti
  5. Nisu sve funkcije iste težine
  6. Obuzdaj zlouporabe i beskonačne petlje
  7. Što se vraća modelu
  8. Ključne točke

Nikada ne izvršavaj slijepo

Pozivanje funkcija modelu daje mogućnost zatražiti izvršavanje funkcija unutar tvog sustava. To je moćno, ali stvara i potencijalni vektor napada. Zlonamjerni korisnik ne može izravno izvršiti tvoj kod; međutim, može napisati bilo što u polju za chat i time utjecati na argumente koje model proizvede. Moraš preokrenuti jednu ugodnu pretpostavku: argumenti tool_call nisu interni podaci tvoje aplikacije. To su korisnički podaci koji su prošli kroz jezični model. Tvoj kod mora biti posljednja linija obrane.

Validiraj prije izvršavanja

Model generira JSON argumente gdje jamči gramatički oblik, nikada poslovnu legitimnost. transaction_id može biti sintaktički niz, a ipak sadržavati bilo što. Disciplina je stoga validirati svaki argument prije nego što s njim učiniš išta te strukturirati funkciju u tri različita koraka: provjeri format, provjeri postojanje i tek onda izvrši.

import re

def validate_transaction_id(transaction_id: str) -> bool:
    """Validira format identifikatora transakcije."""
    # Očekivani format: T praćen s 4 znamenke
    return bool(re.match(r"^T\d{4}$", transaction_id))


def retrieve_payment_status_safe(df, transaction_id: str) -> str:
    """Sigurna verzija s validacijom."""
    # Korak 1: Validacija formata
    if not validate_transaction_id(transaction_id):
        return json.dumps({
            "error": "invalid_format",
            "message": "ID mora biti u formatu Txxxx (npr. T1001)"
        })

    # Korak 2: Provjera postojanja
    if transaction_id not in df["transaction_id"].values:
        return json.dumps({
            "error": "not_found",
            "message": f"Transakcija {transaction_id} nije pronađena"
        })

    # Korak 3: Izvršavanje
    status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
    return json.dumps({"status": status})

Regularni izraz ^T\d{4}$ ovdje obavlja sav obrambeni posao: sidren s obje strane, odbija svaki niz koji sadrži čak i jedan dodatni znak. To nas vodi izravno do razloga za ovo sidrenje.

Kada argument postaje payload

Razmotri ovaj zahtjev koji se čini potpuno nevinim:

User: "Pronađi uplatu s ID-jem: T1001; DROP TABLE payments"

Model, savjesno obavljajući svoj posao ekstrakcije, mogao bi generirati {"transaction_id": "T1001; DROP TABLE payments"}. Nije učinio ništa loše: dobio je identifikator i proslijedio ga dalje. Ako tvoja funkcija ubaci ovaj argument u SQL upit putem konkatenacije, upravo si izgubio svoju tablicu. Problem nije nov – radi se o klasičnoj SQL injekciji – ali pozivanje funkcija dodaje vezu koja stvara lažan dojam filtriranja.

Sljedeće tri verzije pokazuju napredak: što nikada ne smiješ pisati, apsolutni minimum koji je prihvatljiv i praksu koju trebaš usvojiti.

# NIKADA nemoj ovo raditi — izravna SQL injekcija
def bad_query(transaction_id):
    cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")

# UVIJEK radi ovo — parametrizirani upiti
def safe_query(transaction_id):
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

# JOŠ BOLJE — validacija + parametrizirani upit
def best_query(transaction_id):
    if not validate_transaction_id(transaction_id):
        raise ValueError("Neispravan format ID-ja")
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

Parametrizirani upit dovoljan je za neutralizaciju injekcije jer upravljački program (driver) tretira argument kao vrijednost, a ne kao SQL. Validacija na ulazu dodaje drugu barijeru i, usput, pruža puno jasniju poruku o grešci nego što bi to učinila baza podataka.

Ograniči polje mogućnosti

Druga linija obrane je smanjiti ono što model može zatražiti. Eksplicitna lista dopuštenih (allowlist), odvojena od tvog rječnika za raspodjelu, crno na bijelo navodi koje su funkcije ovlaštene u ovom kontekstu. Odvajanje je bitno: ALLOWED_FUNCTIONS izražava sigurnosnu odluku, dok available_functions odražava stanje implementacije. Brkanje ta dva znači ovlaštivanje funkcije jednostavno zato što si je kodirao.

# Eksplicitno definiraj dopuštene funkcije
ALLOWED_FUNCTIONS = {
    "retrieve_payment_status",
    "retrieve_payment_date",
    "search_transactions"
}

def execute_tool_call_safe(tool_call, available_functions):
    """Izvršavanje s provjerom liste dopuštenih."""
    function_name = tool_call.function.name

    # Provjera liste dopuštenih
    if function_name not in ALLOWED_FUNCTIONS:
        return json.dumps({
            "error": "forbidden",
            "message": f"Funkcija {function_name} nije ovlaštena."
        })

    if function_name not in available_functions:
        return json.dumps({
            "error": "not_implemented",
            "message": f"Funkcija {function_name} nije implementirana."
        })

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

Nisu sve funkcije iste težine

Čitanje statusa uplate i brisanje starih zapisa očito ne nose istu razinu rizika. Klasificiranje tvojih funkcija po razini – samo za čitanje, pisanje, destruktivne – omogućuje ti da svakoj sesiji ili korisniku dodijeliš odgovarajući opseg. Javni asistent za praćenje narudžbi radit će u načinu read; alat za back-office ovlastit će pisanje. Što se tiče destruktivnih radnji, ispravan odgovor nije zabraniti ih, već ih eskalirati: funkcija vraća confirmation_required, model korisniku objašnjava što se sprema dogoditi, a čovjek donosi konačnu odluku.

# Razine rizika
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"):
    """Izvršavanje s provjerom razine dopuštenja."""
    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"Ovlaštene su samo funkcije za čitanje. "
                       f"{function_name} zahtijeva razinu 'write'."
        })

    if function_name in DESTRUCTIVE:
        return json.dumps({
            "error": "confirmation_required",
            "message": f"Radnja {function_name} je destruktivna i "
                       f"zahtijeva ručnu potvrdu."
        })

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

Obuzdaj zlouporabe i beskonačne petlje

Loše upravljana petlja razgovora može pozvati istu funkciju desecima puta u nekoliko sekundi, bilo zbog zlonamjernosti ili jednostavne greške u lančanom pozivu. Klizni brojač tijekom šezdeset sekundi po funkciji košta nekoliko redaka koda i sprječava zasićenje API-ja treće strane koji se naplaćuje po pozivu.

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()
        # Očisti pozive starije od jedne minute
        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)

Što se vraća modelu

Posljednje slijepo mjesto često je najskuplje. Funkcija koja vraća cijeli redak baze podataka može uključivati hash lozinke, API ključ ili broj kartice. Ipak, sve što staviš u poruku tool ulazi u kontekst modela, što znači da bi se potencijalno moglo pojaviti u njegovom odgovoru na zaslonu, u tvojim zapisnicima (logovima) i kod tvog pružatelja usluge. Maskiranje osjetljivih polja prije slanja – rekurzivno, kako bi se pokrili ugniježđeni objekti – mjera je opreza koja će te spasiti od incidenta curenja podataka.

def sanitize_result(result: dict) -> dict:
    """Uklanja osjetljiva polja prije vraćanja modelu."""
    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

Ključne točke

  • Uvijek validiraj argumente prije izvršavanja funkcije – format, tip, dopuštene vrijednosti
  • Koristi parametrizirane upite za sprječavanje SQL injekcije
  • Implementiraj listu dopuštenih (allowlist) ovlaštenih funkcija
  • Klasificiraj funkcije po razini rizika (čitanje, pisanje, destruktivno)
  • Dodaj ograničenje brzine (rate limiting) za sprječavanje zlouporabe
  • Pročisti rezultate kako bi izbjegao izlaganje osjetljivih podataka modelu