Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Bezpečnost volání funkcí

Lekce 11 z 14 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Nikdy neprováděj naslepo
  2. Ověřuj před provedením
  3. Když se argument stane payloadem
  4. Omez pole možností
  5. Ne všechny funkce mají stejnou váhu
  6. Zabraň zneužití a smyčkám
  7. Co se vrací modelu
  8. Klíčové poznatky

Nikdy neprováděj naslepo

Volání funkcí dává modelu schopnost požádat o provedení funkce ve tvém systému. Je to mocný nástroj, ale zároveň vytváří potenciální vektor útoku. Škodlivý uživatel sice nemůže spustit tvůj kód přímo, ale může napsat cokoliv do chatového pole, a tím ovlivnit argumenty, které model vygeneruje. Musíš převrátit pohodlný předpoklad: argumenty tool_call nejsou interní data tvé aplikace. Jsou to uživatelská data, která prošla jazykovým modelem. Tvůj kód musí být poslední linií obrany.

Ověřuj před provedením

Model generuje JSON argumenty, kde garantuje pouze gramatickou formu, nikoliv obchodní legitimitu. transaction_id může být syntakticky řetězec, ale obsahovat cokoliv. Disciplína proto spočívá v ověření každého argumentu před jakoukoli akcí a ve strukturování funkce do tří odlišných kroků: ověření formátu, ověření existence a teprve poté provedení.

import re

def validate_transaction_id(transaction_id: str) -> bool:
    """Validates the format of a transaction identifier."""
    # Expected format: T followed by 4 digits
    return bool(re.match(r"^T\d{4}$", transaction_id))


def retrieve_payment_status_safe(df, transaction_id: str) -> str:
    """Secure version with validation."""
    # Step 1: Validate format
    if not validate_transaction_id(transaction_id):
        return json.dumps({
            "error": "invalid_format",
            "message": "ID must be in Txxxx format (e.g., T1001)"
        })

    # Step 2: Check existence
    if transaction_id not in df["transaction_id"].values:
        return json.dumps({
            "error": "not_found",
            "message": f"Transaction {transaction_id} not found"
        })

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

Regulární výraz ^T\d{4}$ zde odvádí veškerou obrannou práci: ukotvený na obou stranách odmítá jakýkoli řetězec obsahující byť jen jeden znak navíc. To přímo vede k důvodu tohoto ukotvení.

Když se argument stane payloadem

Zvaž tuto žádost, která vypadá zcela nevinně:

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

Model, svědomitě plnící svou extrakční úlohu, může vygenerovat {"transaction_id": "T1001; DROP TABLE payments"}. Neudělal nic špatného: dostal identifikátor a předal jej dál. Pokud tvá funkce vloží tento argument do SQL dotazu pomocí zřetězení, právě jsi přišel o svou tabulku. Problém není nový – je to klasická SQL injekce – ale volání funkcí přidává článek, který vytváří falešný dojem filtrování.

Následující tři verze ukazují vývoj: co nikdy nesmíš psát, absolutní minimum a praxi, kterou máš adoptovat.

# NEVER do this — direct SQL injection
def bad_query(transaction_id):
    cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")

# ALWAYS do this — parameterized queries
def safe_query(transaction_id):
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

# EVEN BETTER — validation + parameterized query
def best_query(transaction_id):
    if not validate_transaction_id(transaction_id):
        raise ValueError("Invalid ID format")
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

Parametrizovaný dotaz stačí k neutralizaci injekce, protože ovladač zachází s argumentem jako s hodnotou, nikoliv jako s SQL. Nadřazená validace přidává druhou bariéru a mimochodem poskytuje mnohem srozumitelnější chybovou zprávu, než by poskytla databáze.

Omez pole možností

Druhou linií obrany je snížení toho, co model může požadovat. Explicitní seznam povolených položek (allowlist), oddělený od tvého dispatch slovníku, černé na bílém stanovuje, které funkce jsou v tomto kontextu autorizovány. Toto oddělení je důležité: ALLOWED_FUNCTIONS vyjadřuje bezpečnostní rozhodnutí, zatímco available_functions odráží stav implementace. Zaměňovat obě znamená autorizovat funkci pouze proto, že jsi ji nakódoval.

# Explicitly define allowed functions
ALLOWED_FUNCTIONS = {
    "retrieve_payment_status",
    "retrieve_payment_date",
    "search_transactions"
}

def execute_tool_call_safe(tool_call, available_functions):
    """Execution with allowlist verification."""
    function_name = tool_call.function.name

    # Check allowlist
    if function_name not in ALLOWED_FUNCTIONS:
        return json.dumps({
            "error": "forbidden",
            "message": f"Function {function_name} is not authorized."
        })

    if function_name not in available_functions:
        return json.dumps({
            "error": "not_implemented",
            "message": f"Function {function_name} is not implemented."
        })

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

Ne všechny funkce mají stejnou váhu

Čtení stavu platby a mazání starých záznamů očividně nenesou stejné riziko. Klasifikace funkcí podle úrovně – pouze pro čtení, zápis, destruktivní – ti umožňuje udělit každé relaci nebo uživateli odpovídající rozsah. Veřejný asistent pro sledování objednávek poběží v režimu read; back-office nástroj autorizuje zápisy. Co se týče destruktivních akcí, správnou odpovědí není je zakázat, ale eskalovat je: funkce vrátí confirmation_required, model uživateli vysvětlí, co se chystá stát, a člověk učiní finální rozhodnutí.

# Risk levels
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"):
    """Executes with permission level verification."""
    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"Only read functions are authorized. "
                       f"{function_name} requires 'write' level."
        })

    if function_name in DESTRUCTIVE:
        return json.dumps({
            "error": "confirmation_required",
            "message": f"Action {function_name} is destructive and "
                       f"requires manual confirmation."
        })

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

Zabraň zneužití a smyčkám

Špatně řízená smyčka konverzace může volat stejnou funkci desítkykrát během několika sekund, ať už kvůli zlomyslnosti nebo jednoduché chybě v řetězení. Posuvný čítač přes šedesát sekund na funkci stojí pár řádků kódu a zabrání zahlcení API třetí strany fakturovaného za volání.

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()
        # Clean up calls older than one 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)

Co se vrací modelu

Posledním slepým místem je často to nejdražší. Funkce, která vrací kompletní řádek databáze, může zahrnovat hash hesla, API klíč nebo číslo karty. Přesto vše, co umístíš do zprávy tool, vstupuje do kontextu modelu, což znamená, že by se to potenciálně mohlo objevit v jeho odpovědi na obrazovce, v tvých logách a na straně tvého poskytovatele. Maskování citlivých polí před odesláním – rekurzivně, aby byly pokryty vnořené objekty – je opatření, které tě zachrání před incidentem úniku dat.

def sanitize_result(result: dict) -> dict:
    """Removes sensitive fields before returning to the 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

Klíčové poznatky

  • Vždy ověřuj argumenty před provedením funkce – formát, typ, povolené hodnoty
  • Používej parametrizované dotazy k prevenci SQL injekcí
  • Implementuj seznam povolených funkcí (allowlist)
  • Klasifikuj funkce podle úrovně rizika (čtení, zápis, destruktivní)
  • Přidej omezení rychlosti (rate limiting) k prevenci zneužití
  • Čisti výsledky, abys předešel vystavení citlivých dat modelu