Премини към основното съдържание
Български— Изберете език
Меню

Сигурност при извикване на функции

Урок 11 от 14 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Никога не изпълнявайте сляпо
  2. Валидирайте преди изпълнение
  3. Когато аргументът се превърне в товар
  4. Ограничете полето на възможностите
  5. Не всички функции носят еднаква тежест
  6. Ограничете злоупотребите и безконтролните изпълнения
  7. Какво се връща на модела
  8. Ключови изводи

Никога не изпълнявайте сляпо

Извикването на функции дава на модела възможност да поиска изпълнение на функции във Вашата система. Това е мощен инструмент, но също така създава потенциален вектор за атака. Злонамерен потребител не може да изпълни директно Вашия код; обаче той може да напише всичко в полето за чат, като по този начин влияе върху аргументите, които моделът генерира. Трябва да обърнете едно удобно предположение: аргументите на tool_call не са вътрешни данни от Вашето приложение. Те са потребителски данни, които са преминали през езиков модел. Вашият код трябва да бъде последната линия на защита.

Валидирайте преди изпълнение

Моделът генерира JSON аргументи, като гарантира само граматическата форма, а не бизнес легитимността. Един transaction_id може синтактично да бъде низ, но да съдържа каквото и да е. Дисциплината следователно изисква валидиране на всеки аргумент, преди да направите каквото и да е с него, и структуриране на функцията в три отделни стъпки: проверка на формата, проверка на съществуването и едва тогава изпълнение.

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})

Регулярният израз ^T\d{4}$ върши цялата защитна работа тук: закотвен от двете страни, той отхвърля всеки низ, съдържащ дори един единствен допълнителен символ. Това води директно до причината за това закотвяне.

Когато аргументът се превърне в товар

Разгледайте тази заявка, която изглежда напълно невинна:

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

Моделът, съвестно изпълнявайки задачата си за извличане, може да генерира {"transaction_id": "T1001; DROP TABLE payments"}. Той не е направил нищо грешно: получил е идентификатор и го е предал нататък. Ако Вашата функция вмъкне този аргумент в SQL заявка чрез конкатенация, току-що сте загубили таблицата си. Проблемът не е нов – това е класическа SQL инжекция – но извикването на функции добавя връзка, която създава фалшиво впечатление за филтриране.

Следващите три версии показват прогресията: какво никога не трябва да пишете, абсолютния минимум, който е приемлив, и практиката, която трябва да възприемете.

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

Параметризираната заявка е достатъчна, за да неутрализира инжекцията, тъй като драйверът третира аргумента като стойност, а не като SQL. Валидирането отгоре добавя втора бариера и между другото осигурява много по-ясно съобщение за грешка, отколкото базата данни би предоставила.

Ограничете полето на възможностите

Втората линия на защита е да намалите това, което моделът може да поиска. Изричен списък с позволени елементи (allowlist), отделен от Вашия речник за диспечиране, черно на бяло посочва кои функции са разрешени в този контекст. Разделението е важно: ALLOWED_FUNCTIONS изразява решение за сигурност, докато available_functions отразява състояние на реализация. Объркването на двете означава да разрешите функция просто защото сте я кодирали.

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

Не всички функции носят еднаква тежест

Четенето на статус на плащане и изчистването на стари записи очевидно не носят един и същи риск. Класифицирането на Вашите функции по ниво – само за четене, за запис, разрушителни – Ви позволява да предоставите на всяка сесия или потребител подходящ обхват. Публичен асистент за проследяване на поръчки ще работи в режим read; инструмент за бек-офис ще authorize записи. Що се отнася до разрушителните действия, правилният отговор не е да ги забраните, а да ги ескалирате: функцията връща confirmation_required, моделът обяснява на потребителя какво предстои да се случи и човек взема окончателното решение.

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

Ограничете злоупотребите и безконтролните изпълнения

Лошо управляван цикъл на разговор може да извика една и съща функция десетки пъти за няколко секунди, било поради злонамереност или просто бъг във веригата. Плъзгащ се брояч за шестдесет секунди на функция струва няколко реда код и предотвратява насищането на API на трета страна, който се таксува на извикване.

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)

Какво се връща на модела

Последното сляпо петно често е най-скъпото. Функция, която връща цял ред от базата данни, може да включва хеш на парола, API ключ или номер на карта. Въпреки това, всичко, което поставите в съобщение tool, влиза в контекста на модела, което означава, че потенциално може да се появи в неговия екранен отговор, във Вашите логове и при Вашия доставчик. Маскирането на чувствителните полета преди изпращане – рекурсивно, за да се обхванат вложени обекти – е предпазната мярка, която ще Ви спаси от инцидент с изтичане на данни.

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

Ключови изводи

  • Винаги валидирайте аргументите преди изпълнение на функция – формат, тип, позволени стойности
  • Използвайте параметризирани заявки, за да предотвратите SQL инжекция
  • Внедрете списък с позволени функции (allowlist)
  • Класифицирайте функциите по ниво на риск (четене, запис, разрушителни)
  • Добавете ограничаване на честотата (rate limiting), за да предотвратите злоупотреба
  • Почиствайте резултатите, за да избегнете излагането на чувствителни данни пред модела