Przejdź do głównej treści
Polski— Wybierz język
Menu

Bezpieczeństwo wywoływania funkcji

Lekcja 11 z 14 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Nigdy nie wykonuj ślepo
  2. Waliduj przed wykonaniem
  3. Gdy argument staje się ładunkiem
  4. Ogranicz pole możliwości
  5. Nie wszystkie funkcje mają taki sam ciężar gatunkowy
  6. Powstrzymaj nadużycia i pętle nieskończone
  7. Co wraca do modelu
  8. Kluczowe wnioski

Nigdy nie wykonuj ślepo

Wywoływanie funkcji daje modelowi możliwość żądania wykonania funkcji w Twoim systemie. To potężne narzędzie, ale tworzy też potencjalny wektor ataku. Złośliwy użytkownik nie może bezpośrednio uruchomić Twojego kodu; może jednak wpisać cokolwiek w polu czatu, wpływając tym samym na argumenty generowane przez model. Musisz obalić wygodne założenie: argumenty tool_call to nie są dane wewnętrzne Twojej aplikacji. To dane użytkownika, które przeszły przez model językowy. Twój kod musi być ostatnią linią obrony.

Waliduj przed wykonaniem

Model generuje argumenty JSON, gwarantując jedynie ich poprawność gramatyczną, a nigdy biznesową legitimność. transaction_id może być syntaktycznie ciągiem znaków, a zawierać cokolwiek. Dyscyplina polega więc na walidacji każdego argumentu przed jakąkolwiek operacją i strukturze funkcji w trzech wyraźnych krokach: weryfikacja formatu, weryfikacja istnienia i dopiero potem wykonanie.

import re

def validate_transaction_id(transaction_id: str) -> bool:
    """Waliduje format identyfikatora transakcji."""
    # Oczekiwany 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:
    """Bezpieczna wersja z walidacją."""
    # 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})

Wyrażenie regularne ^T\d{4}$ wykonuje tutaj całą pracę defensywną: zakotwiczone po obu stronach, odrzuca każdy ciąg zawierający choćby jeden dodatkowy znak. Prowadzi to bezpośrednio do przyczyny tego kotwiczenia.

Gdy argument staje się ładunkiem

Rozważ to żądanie, które wydaje się całkowicie niewinne:

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

Model, sumiennie wykonując swoje zadanie ekstrakcji, może wygenerować {"transaction_id": "T1001; DROP TABLE payments"}. Nie zrobił nic złego: otrzymał identyfikator i przekazał go dalej. Jeśli Twoja funkcja wstawi ten argument do zapytania SQL poprzez konkatenację, właśnie straciłeś swoją tabelę. Problem nie jest nowy – to klasyczny wtrysk SQL – ale wywoływanie funkcji dodaje ogniwo, które tworzy fałszywe wrażenie filtrowania.

Poniższe trzy wersje pokazują ewolucję: czego nigdy nie pisać, absolutne minimum do zaakceptowania oraz praktykę, którą należy przyjąć.

# 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,))

Zapytanie sparametryzowane wystarczy, aby zneutralizować wtrysk, ponieważ sterownik traktuje argument jako wartość, a nie jako kod SQL. Walidacja wstępna dodaje drugą barierę i, przy okazji, zapewnia znacznie jaśniejszy komunikat o błędzie niż baza danych.

Ogranicz pole możliwości

Drugą linią obrony jest ograniczenie tego, co model może zażądać. Jawna lista dozwolonych funkcji (allowlist), oddzielna od słownika dyspozytorskiego, czarno na białym określa, które funkcje są autoryzowane w tym kontekście. Rozdzielenie to ma znaczenie: ALLOWED_FUNCTIONS wyraża decyzję bezpieczeństwa, podczas gdy available_functions odzwierciedla stan implementacji. Mylenie obu oznacza autoryzację funkcji jedynie dlatego, że ją zakodowałeś.

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

def execute_tool_call_safe(tool_call, available_functions):
    """Wykonanie z weryfikacją listy dozwolonych."""
    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)

Nie wszystkie funkcje mają taki sam ciężar gatunkowy

Odczytanie statusu płatności i usuwanie starych rekordów oczywiście nie niosą takiego samego ryzyka. Klasyfikacja funkcji według poziomów – tylko do odczytu, zapis, destrukcyjne – pozwala przyznać każdej sesji lub użytkownikowi odpowiedni zakres. Asystent śledzenia zamówień publicznych będzie działał w trybie read; narzędzie back-office autoryzuje zapis. Co do działań destrukcyjnych, właściwą odpowiedzią nie jest ich zakazywanie, lecz eskalacja: funkcja zwraca confirmation_required, model wyjaśnia użytkownikowi, co ma się wydarzyć, a człowiek podejmuje ostateczną decyzję.

# 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"):
    """Wykonuje z weryfikacją poziomu uprawnień."""
    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)

Powstrzymaj nadużycia i pętle nieskończone

Źle zarządzana pętla konwersacji może wywołać tę samą funkcję kilkadziesiąt razy w ciągu kilku sekund, czy to z powodu złośliwości, czy prostego błędu w łańcuchu. Licznik przesuwny w oknie sześćdziesięciu sekund na funkcję kosztuje kilka linii kodu i zapobiega przeciążeniu zewnętrznego API rozliczanego za wywołanie.

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 wraca do modelu

Ostatnim ślepym punktem jest często ten najbardziej kosztowny. Funkcja zwracająca pełny wiersz bazy danych może zawierać hasz hasła, klucz API lub numer karty. Wszystko, co umieścisz w wiadomości tool, trafia do kontekstu modelu, co oznacza, że potencjalnie może pojawić się w jego odpowiedzi na ekranie, w Twoich logach oraz po stronie Twojego dostawcy. Maskowanie wrażliwych pól przed wysłaniem – rekurencyjnie, aby objąć obiekty zagnieżdżone – to środek ostrożności, który uchroni Cię przed incydentem wycieku danych.

def sanitize_result(result: dict) -> dict:
    """Usuwa wrażliwe pola przed zwrotem do 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

Kluczowe wnioski

  • Zawsze waliduj argumenty przed wykonaniem funkcji – format, typ, dozwolone wartości
  • Używaj zapytań sparametryzowanych, aby zapobiec wtryskowi SQL
  • Wdróż listę dozwolonych funkcji (allowlist)
  • Klasyfikuj funkcje według poziomu ryzyka (odczyt, zapis, destrukcyjne)
  • Dodaj ograniczanie częstotliwości (rate limiting), aby zapobiec nadużyciom
  • Sanityzuj wyniki, aby uniknąć ujawniania wrażliwych danych modelowi