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

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

Урок 8 от 14 Обновен 28 юли 2026 г. Напреднало
На тази страница
  1. Защо да ограничавате заявките?
  2. Два начина за броене
  3. Разпознаване на бот
  4. Йерархични санкции
  5. Редът на проверките има значение
  6. Ключови изводи

Защо да ограничавате заявките?

Приложенията с изкуствен интелект са основна мишена за злоупотреби поради причина, която не съществуваше при традиционните приложения: всяко извикване на модел струва пари. Традиционен REST API, подложен на поток от заявки, забавя работата си и в крайна сметка се срива, но не източва банкова сметка. Приложение с голям езиков модел (LLM) обаче продължава да отговаря перфектно, докато сметката се покачва драстично. Без ограничаване на честотата (rate limiting), нападател може да съсипе бюджета Ви за API за минути, да стартира автоматизирани атаки за инжектиране на подкани (prompt injection) или да използва Вашата инфраструктура за генериране на спам за Ваша сметка.

Два начина за броене

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

Освен това функцията не връща просто булева стойност; тя връща речник, показващ оставащите заявки и времето до нулиране. Тези стойности попълват заглавките на отговора, които Вашите легитимни клиенти ще използват за саморегулация – една добре проектирана интеграция изчаква, вместо да бомбардира крайната точка.

import time
from collections import defaultdict

class RateLimiter:
    """Sliding window rate limiter."""

    def __init__(self, max_requetes: int, fenetre_secondes: int):
        self.max_requetes = max_requetes
        self.fenetre = fenetre_secondes
        self.requetes: dict[str, list[float]] = defaultdict(list)

    def autoriser(self, identifiant: str) -> tuple[bool, dict]:
        """Checks if a request is allowed for this identifier."""
        maintenant = time.time()
        seuil = maintenant - self.fenetre

        # Clean up old requests
        self.requetes[identifiant] = [
            t for t in self.requetes[identifiant] if t > seuil
        ]

        nb_requetes = len(self.requetes[identifiant])

        if nb_requetes >= self.max_requetes:
            prochain_slot = self.requetes[identifiant][0] + self.fenetre
            return False, {
                "restantes": 0,
                "reset_dans": round(prochain_slot - maintenant, 1),
            }

        self.requetes[identifiant].append(maintenant)
        return True, {
            "restantes": self.max_requetes - nb_requetes - 1,
            "reset_dans": round(self.fenetre - (maintenant - self.requetes[identifiant][0]), 1),
        }

# Configuration by role
limiteurs = {
    "gratuit": RateLimiter(max_requetes=10, fenetre_secondes=60),
    "premium": RateLimiter(max_requetes=60, fenetre_secondes=60),
    "api": RateLimiter(max_requetes=200, fenetre_secondes=60),
}

Самото броене на заявките обаче не е достатъчно, защото не всички заявки са равни. Десет кратки въпроса струват част от това, което струва една единствена заявка, придружена от петдесетстраничен документ. Ограничител на база заявка би пропуснал последната и би блокирал първите, което е точно обратното на това, което диктува икономиката на услугите. Бюджетът за токени възстановява пропорционалността, с ежедневно нулиране и запис на действителното използване постфактум, тъй като оценката, направена преди извикването, не знае дължината на отговора.

class TokenBudgetLimiter:
    """Limits token spending per user."""

    def __init__(self, budget_tokens_jour: int, cout_par_1k_input: float, cout_par_1k_output: float):
        self.budget_jour = budget_tokens_jour
        self.cout_input = cout_par_1k_input
        self.cout_output = cout_par_1k_output
        self.usage: dict[str, dict] = defaultdict(lambda: {"tokens_in": 0, "tokens_out": 0, "date": ""})

    def verifier_budget(self, user_id: str, tokens_estimes: int) -> tuple[bool, dict]:
        """Checks if the user still has budget."""
        from datetime import date
        aujourd_hui = str(date.today())

        # Daily reset
        if self.usage[user_id]["date"] != aujourd_hui:
            self.usage[user_id] = {"tokens_in": 0, "tokens_out": 0, "date": aujourd_hui}

        total_utilise = self.usage[user_id]["tokens_in"] + self.usage[user_id]["tokens_out"]
        restant = self.budget_jour - total_utilise

        if tokens_estimes > restant:
            return False, {"restant": restant, "demande": tokens_estimes}

        return True, {"restant": restant - tokens_estimes}

    def enregistrer_usage(self, user_id: str, tokens_in: int, tokens_out: int):
        """Records actual usage after a call."""
        self.usage[user_id]["tokens_in"] += tokens_in
        self.usage[user_id]["tokens_out"] += tokens_out

# Example: 100K tokens/day for free users
budget = TokenBudgetLimiter(
    budget_tokens_jour=100_000,
    cout_par_1k_input=0.005,
    cout_par_1k_output=0.015,
)

Разпознаване на бот

Методичният нападател остава под Вашите тавани: трябва просто да забави темпото. Откриването на злоупотреби следователно изисква разглеждане на формата на трафика, а не на неговия обем. Четирите сигнала, реализирани по-долу, се допълват добре един друг. Идентичното повторение издава скрипт, заседнал в цикъл. Поредица от заявки за няколко секунди показва темпо, което никой човек не може да поддържа на клавиатурата. Съобщение с дължина десетки хиляди символи сигнализира за опит за обемен инжекционен удар. Четвъртият е най-интересен: строго еднакви дължини на съобщенията през десет последователни заявки разкриват фъзър (fuzzer), който варира съдържанието с постоянна структура, докато реалният потребител пише изречения с неравномерна дължина.

from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class ProfilUtilisateur:
    user_id: str
    requetes_recentes: list[dict] = field(default_factory=list)
    alertes: list[str] = field(default_factory=list)

class DetecteurAbus:
    """Detects automated abuse patterns."""

    def __init__(self):
        self.profils: dict[str, ProfilUtilisateur] = {}

    def analyser(self, user_id: str, message: str) -> list[str]:
        """Analyzes a message to detect abuse patterns."""
        if user_id not in self.profils:
            self.profils[user_id] = ProfilUtilisateur(user_id=user_id)

        profil = self.profils[user_id]
        alertes = []

        # Pattern 1: repeated identical messages
        if profil.requetes_recentes:
            derniers_messages = [r["message"] for r in profil.requetes_recentes[-5:]]
            if derniers_messages.count(message) >= 3:
                alertes.append("SPAM: identical message repeated 3+ times")

        # Pattern 2: abnormal frequency
        maintenant = datetime.now()
        recentes = [
            r for r in profil.requetes_recentes
            if (maintenant - r["timestamp"]).seconds < 10
        ]
        if len(recentes) > 5:
            alertes.append("FLOOD: 5+ requests in 10 seconds")

        # Pattern 3: very long messages (volumetric injection attempt)
        if len(message) > 10000:
            alertes.append(f"VOLUME: message of {len(message)} characters")

        # Pattern 4: systematic variation (automated fuzzing)
        if len(profil.requetes_recentes) >= 10:
            longueurs = [len(r["message"]) for r in profil.requetes_recentes[-10:]]
            if max(longueurs) - min(longueurs) < 5 and len(set(longueurs)) == 1:
                alertes.append("FUZZING: identical message length (bot)")

        # Record
        profil.requetes_recentes.append({
            "message": message,
            "timestamp": maintenant,
            "alertes": alertes,
        })

        return alertes

detecteur = DetecteurAbus()

Йерархични санкции

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

class GestionBannissement:
    """Progressive banning: warning, throttling, blocking."""

    def __init__(self):
        self.compteurs: dict[str, int] = defaultdict(int)
        self.bans: dict[str, float] = {}

    def signaler(self, user_id: str, severite: int = 1) -> str:
        """Reports abuse and applies the appropriate sanction."""
        self.compteurs[user_id] += severite
        score = self.compteurs[user_id]

        if score >= 10:
            self.bans[user_id] = time.time() + 86400  # Ban 24h
            return "BAN_24H"
        elif score >= 5:
            self.bans[user_id] = time.time() + 3600  # Ban 1h
            return "BAN_1H"
        elif score >= 3:
            return "RALENTIR"  # Reduced rate limit
        else:
            return "AVERTIR"

    def est_banni(self, user_id: str) -> bool:
        """Checks if a user is currently banned."""
        if user_id in self.bans:
            if time.time() < self.bans[user_id]:
                return True
            del self.bans[user_id]
        return False

Редът на проверките има значение

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

from openai import OpenAI

class APISecurisee:
    """API with integrated rate limiting and abuse detection."""

    def __init__(self):
        self.client = OpenAI()
        self.rate_limiter = RateLimiter(max_requetes=20, fenetre_secondes=60)
        self.budget = TokenBudgetLimiter(100_000, 0.005, 0.015)
        self.detecteur = DetecteurAbus()
        self.bans = GestionBannissement()

    def traiter(self, user_id: str, message: str) -> str:
        # Step 1: check ban status
        if self.bans.est_banni(user_id):
            return "Your access is temporarily suspended."

        # Step 2: rate limiting
        autorise, info = self.rate_limiter.autoriser(user_id)
        if not autorise:
            return f"Too many requests. Try again in {info['reset_dans']}s."

        # Step 3: abuse detection
        alertes = self.detecteur.analyser(user_id, message)
        if alertes:
            action = self.bans.signaler(user_id, severite=len(alertes))
            if action.startswith("BAN"):
                return "Abusive behavior detected. Access suspended."

        # Step 4: check token budget
        tokens_estimes = len(message) // 4 + 500
        ok, budget_info = self.budget.verifier_budget(user_id, tokens_estimes)
        if not ok:
            return "Daily token budget exhausted."

        # Step 5: call the model
        response = self.client.chat.completions.create(
            model="gpt-5.6-sol",
            messages=[{"role": "user", "content": message}],
        )

        # Record actual usage
        usage = response.usage
        self.budget.enregistrer_usage(user_id, usage.prompt_tokens, usage.completion_tokens)

        return response.choices[0].message.content

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

  • Ограничаването на честотата защитава бюджета Ви за API и предотвратява автоматизирани атаки
  • Комбинирайте ограничения на база заявка (плъзгащ се прозорец) и ограничения на база цена (токени)
  • Откриването на злоупотреби идентифицира модели: спам, наводнение (flood), фъзинг (fuzzing), обем
  • Прогресивното блокиране (предупреждение, ограничаване, блокиране) избягва постоянни фалшиви положителни резултати
  • Всеки отговор трябва да включва заглавки за ограничаване на честотата, за да информира потребителя