Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Biztonság a függvényhívásoknál

11. lecke 14 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Soha ne hajts végre vakon
  2. Ellenőrzés végrehajtás előtt
  3. Amikor az argumentum hasznos tehergé válik
  4. Korlátozd a lehetőségek körét
  5. Nem minden függvény hordoz ugyanakkora kockázatot
  6. Kezeld a visszaéléseket és a végtelen ciklusokat
  7. Ami visszakerül a modellhez
  8. Főbb megállapítások

Soha ne hajts végre vakon

A függvényhívás lehetővé teszi, hogy a modell függvényvégrehajtást kérjen a rendszereden belül. Ez hatalmas erő, de egyben potenciális támadási felületet is nyit. Egy rosszindulatú felhasználó nem tudja közvetlenül futtatni a kódodat, viszont bármit beírhat a chat mezőbe, ezzel befolyásolva a modell által generált argumentumokat. Le kell mondanod egy kényelmes tévhitről: a tool_call argumentumai nem belső adatok az alkalmazásodból. Ezek felhasználói adatok, amelyek átmentek egy nyelvi modellen. A kódodnak kell lennie az utolsó védelmi vonalnak.

Ellenőrzés végrehajtás előtt

A modell JSON argumentumokat generál, ahol csak a nyelvtani helyességet garantálja, az üzleti legitimitást soha. Egy transaction_id szintaktikailag lehet string, mégis bármit tartalmazhat. A fegyelem tehát az, hogy minden argumentumot ellenőrizz, mielőtt bármit is tennél vele, és a függvényt három elkülönült lépésre építsd fel: formátum ellenőrzése, létezés vizsgálata, és csak ezután a végrehajtás.

import re

def validate_transaction_id(transaction_id: str) -> bool:
    """Érvényesíti a tranzakcióazonosító formátumát."""
    # Várt formátum: T betűt követően 4 számjegy
    return bool(re.match(r"^T\d{4}$", transaction_id))


def retrieve_payment_status_safe(df, transaction_id: str) -> str:
    """Biztonságos verzió ellenőrzéssel."""
    # 1. lépés: Formátum ellenőrzése
    if not validate_transaction_id(transaction_id):
        return json.dumps({
            "error": "invalid_format",
            "message": "Az ID-nak Txxxx formátumúnak kell lennie (pl. T1001)"
        })

    # 2. lépés: Létezés ellenőrzése
    if transaction_id not in df["transaction_id"].values:
        return json.dumps({
            "error": "not_found",
            "message": f"A(z) {transaction_id} tranzakció nem található"
        })

    # 3. lépés: Végrehajtás
    status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
    return json.dumps({"status": status})

A ^T\d{4}$ reguláris kifejezés végzi itt az összes védekezési munkát: mindkét oldalról horgonyzott, így elutasít minden olyan stringet, amely akár csak egyetlen extra karaktert is tartalmaz. Ez közvetlenül vezet a horgonyzás okához.

Amikor az argumentum hasznos tehergé válik

Tekintsük ezt a látszólag teljesen ártalmatlan kérést:

Felhasználó: "Keresd meg a T1001 azonosítójú fizetést; DROP TABLE payments"

A modell, lelkiismeretesen végezve a kinyerési munkáját, generálhatja ezt: {"transaction_id": "T1001; DROP TABLE payments"}. Nem tett semmi rosszat: kapott egy azonosítót, és továbbította azt. Ha a függvényed összefűzéssel (concatenation) illeszti be ezt az argumentumot egy SQL lekérdezésbe, máris elvesztetted a tábládat. A probléma nem új – ez klasszikus SQL injection –, de a függvényhívás hozzáad egy láncszemet, ami hamis szűrési benyomást kelt.

Az alábbi három verzió mutatja a fejlődést: amit soha nem szabad megírnod, a minimálisan elfogadhatót, és az alkalmazandó gyakorlatot.

# SOHA ne csináld ezt — közvetlen SQL injection
def bad_query(transaction_id):
    cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")

# MINDIG ezt csináld — paraméterezett lekérdezések
def safe_query(transaction_id):
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

# MÉG JOBB — ellenőrzés + paraméterezett lekérdezés
def best_query(transaction_id):
    if not validate_transaction_id(transaction_id):
        raise ValueError("Érvénytelen ID formátum")
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

A paraméterezett lekérdezés önmagában is elegendő az injection semlegesítésére, mivel a driver az argumentumot értékként, nem pedig SQL-kódként kezeli. A korai szakaszban végzett ellenőrzés egy második akadályt jelent, és mellékesen sokkal tisztább hibaüzenetet biztosít, mint amit az adatbázis adna.

Korlátozd a lehetőségek körét

A második védelmi vonal annak csökkentése, amit a modell kérhet. Egy explicit engedélyezési lista (allowlist), elkülönítve a dispatch szótáradtól, fekete-fehéren rögzíti, mely függvények engedélyezettek ebben a kontextusban. Az elkülönítés számít: az ALLOWED_FUNCTIONS egy biztonsági döntést fejez ki, míg az available_functions egy implementációs állapotot tükröz. A kettő összekeverése annyit jelent, mint egy függvényt pusztán azért engedélyezni, mert megkódoltad.

# Expliciten definiált engedélyezett függvények
ALLOWED_FUNCTIONS = {
    "retrieve_payment_status",
    "retrieve_payment_date",
    "search_transactions"
}

def execute_tool_call_safe(tool_call, available_functions):
    """Végrehajtás engedélyezési lista ellenőrzéssel."""
    function_name = tool_call.function.name

    # Engedélyezési lista ellenőrzése
    if function_name not in ALLOWED_FUNCTIONS:
        return json.dumps({
            "error": "forbidden",
            "message": f"A(z) {function_name} függvény nem engedélyezett."
        })

    if function_name not in available_functions:
        return json.dumps({
            "error": "not_implemented",
            "message": f"A(z) {function_name} függvény nincs implementálva."
        })

    # Végrehajtás
    function_params = json.loads(tool_call.function.arguments)
    return available_functions[function_name](**function_params)

Nem minden függvény hordoz ugyanakkora kockázatot

Egy fizetési állapot lekérése és a régi rekordok törlése nyilvánvalóan nem hordoz ugyanakkora kockázatot. Ha szintek szerint osztályozod a függvényeidet – csak olvasható, írási, romboló –, akkor minden munkamenetnek vagy felhasználónak megadhatod a megfelelő hatókört. Egy nyilvános rendelés-követő asszisztens read módban fut; egy back-office eszköz engedélyezheti az írást. Ami a romboló műveleteket illeti, a helyes válasz nem a tiltás, hanem a fokozás: a függvény confirmation_required értéket ad vissza, a modell elmagyarázza a felhasználónak, mi fog történni, és egy ember hozza meg a végső döntést.

# Kockázati szintek
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"):
    """Végrehajtás jogosultsági szint ellenőrzéssel."""
    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"Csak az olvasó függvények engedélyezettek. "
                       f"A(z) {function_name} 'write' szintet igényel."
        })

    if function_name in DESTRUCTIVE:
        return json.dumps({
            "error": "confirmation_required",
            "message": f"A(z) {function_name} művelet romboló, és "
                       f"kézi megerősítést igényel."
        })

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

Kezeld a visszaéléseket és a végtelen ciklusokat

Egy rosszul kezelt beszélgetési hurok másodpercek alatt tucatszor hívhatja meg ugyanazt a függvényt, legyen szó rosszindulatú támadásról vagy egyszerű láncolási hibáról. Egy csúszó számláló implementálása függvényenként hatvan másodpercre néhány sor kódba kerül, és megakadályozza, hogy telítsd a hívásonként számlázott harmadik féltől származó API-t.

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()
        # Töröljük az egy percnél régebbi hívásokat
        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)

Ami visszakerül a modellhez

Az utolsó vakfolt gyakran a legköltségesebb. Egy függvény, amely egy teljes adatbázis-sort ad vissza, tartalmazhat jelszó-hash-t, API-kulcsot vagy bankkártyaszámot. Minden, amit egy tool üzenetbe helyezel, belép a modell kontextusába, ami azt jelenti, hogy potenciálisan megjelenhet a képernyőn lévő válaszában, a naplóidban (logok) és a szolgáltatódnál is. Az érzékeny mezők elrejtése (masking) a modellnek való visszaküldés előtt – rekurzívan, a beágyazott objektumok lefedésére – az az óvintézkedés, ami megvéd egy adatszivárgási incidenstől.

def sanitize_result(result: dict) -> dict:
    """Eltávolítja az érzékeny mezőket, mielőtt visszakerülnének a modellhez."""
    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

Főbb megállapítások

  • Mindig ellenőrizd az argumentumokat a függvény végrehajtása előtt – formátum, típus, engedélyezett értékek
  • Használj paraméterezett lekérdezéseket az SQL injection megelőzésére
  • Implementálj egy engedélyezési listát (allowlist) a jogosult függvényekhez
  • Osztályozd a függvényeket kockázati szint szerint (olvasás, írás, romboló)
  • Adj hozzá sebességkorlátozást (rate limiting) a visszaélések megelőzésére
  • Tisztítsd meg (sanitize) az eredményeket, hogy elkerüld az érzékeny adatok modell előtti felfedését