Ограничаване на заявките и предотвратяване на злоупотреби
На тази страница
Защо да ограничавате заявките?
Приложенията с изкуствен интелект са основна мишена за злоупотреби поради причина, която не съществуваше при традиционните приложения: всяко извикване на модел струва пари. Традиционен 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), обем
- Прогресивното блокиране (предупреждение, ограничаване, блокиране) избягва постоянни фалшиви положителни резултати
- Всеки отговор трябва да включва заглавки за ограничаване на честотата, за да информира потребителя