Ograničavanje brzine i sprječavanje zlouporabe
Na ovoj stranici
Zašto ograničiti zahtjeve?
AI aplikacije su primarne mete zlouporabe iz razloga koji nije postojao kod tradicionalnih aplikacija: svaki poziv modelu košta novca. Tradicionalni REST API pod udarom poplave zahtjeva usporava i na kraju se ruši, ali ne ispražnjuje bankovni račun. LLM aplikacija, s druge strane, nastavlja savršeno odgovarati dok račun eksplodira. Bez ograničavanja brzine, napadač može uništiti tvoj proračun za API u nekoliko minuta, pokrenuti automatizirane napade ubrizgavanja promptova ili iskoristiti tvoju infrastrukturu za generiranje spama o tvom trošku.
Dva načina brojanja
Klizni prozor temeljni je mehanizam. On bilježi vremensku oznaku svakog zahtjeva, odbacuje one koji su ispali iz prozora i uspoređuje preostale s gornjom granicom. Njegova superiornost nad fiksnim prozorom svodi se na detalj koji je bitan u praksi: kod fiksnog prozora koji se resetira svake minute, napadač može iskoristiti svoju kvotu na kraju jedne minute i ponovno na početku sljedeće, čime efektivno udvostručuje dopušteni propusni tok u nekoliko sekundi. Klizni prozor ne ostavlja takav otvor.
Štoviše, funkcija ne vraća jednostavnu boolean vrijednost; vraća rječnik koji označava preostale zahtjeve i vrijeme do resetiranja. Te vrijednosti popunjavaju zaglavlja odgovora koja će tvoji legitimni klijenti koristiti za samoregulaciju – dobro dizajnirana integracija čeka umjesto da bombardira krajnju točku.
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),
}
Samo brojanje zahtjeva nije dovoljno jer nisu svi zahtjevi jednaki. Deset kratkih pitanja košta djelić onoga što košta jedan zahtjev popraćen dokumentom od pedeset stranica. Ograničivač po zahtjevu propustio bi potonje, a blokirao prve, što je točno suprotno od onoga što diktira ekonomija usluge. Proračun tokena vraća proporcionalnost, s dnevnim resetiranjem i bilježenjem stvarne potrošnje nakon činjenice, jer procjena napravljena prije poziva ne zna duljinu odgovora.
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,
)
Prepoznavanje bota
Metodičan napadač ostaje ispod tvojih stropova: samo se treba usporiti. Otkrivanje zlouporabe stoga zahtijeva promatranje oblika prometa, a ne njegovog volumena. Četiri signala implementirana u nastavku dobro se nadopunjuju. Identično ponavljanje odaje skriptu zaglavljenu u petlji. Prasak zahtjeva unutar nekoliko sekundi ukazuje na tempo koji nijedan čovjek ne može održati na tipkovnici. Poruka duga desetke tisuća znakova signalizira pokušaj volumetrijskog ubrizgavanja. Četvrti je najzanimljiviji: rigorozno identične duljine poruka tijekom deset uzastopnih zahtjeva otkrivaju fuzzer koji varira sadržaj uz konstantnu strukturu, dok stvarni korisnik piše rečenice nepravilnih duljina.
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()
Hijerarhijske sankcije
Blokiranje pri prvoj uzbuni bila bi skupa pogreška jer nijedan od ovih signala nije nepogrešiv: korisnik koji nervozno osvježava stranicu okida detektor praska, a da nije zlonamjeran. Progresivno blokiranje akumulira bodove i pokreće proporcionalne odgovore – upozorenje, zatim usporavanje, potom privremena blokada od sat vremena i na kraju dvadeset četiri sata. Svaka razina daje legitimnom korisniku priliku da siđe s tog puta, dok automatizirana skripta slijedi put do kraja.
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
Redoslijed provjera je bitan
Konačna sastavnica povezuje četiri mehanizma prije poziva modelu, a ovaj redoslijed poštuje jednostavno pravilo: od najjeftinijeg prema najskupljem. Provjera blokade je pretraživanje rječnika, ograničavanje brzine skenira kratki popis, otkrivanje zlouporabe analizira povijest, a kontrola proračuna dolazi neposredno prije naplaćenog poziva. Obrtanje ovog slijeda značilo bi plaćanje bihevioralne analize za korisnika koji je već blokiran. Posljednji korak je onaj koji se najčešće zaboravlja: bilježenje stvarne potrošnje iz polja usage odgovora, bez čega bi tvoj proračun odstupao od procjene napravljene prije poziva.
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
Ključne točke
- Ograničavanje brzine štiti tvoj proračun za API i sprječava automatizirane napade
- Kombiniraj ograničenja po zahtjevu (klizni prozor) i ograničenja po trošku (tokeni)
- Otkrivanje zlouporabe identificira obrasce: spam, poplava, fuzzing, volumen
- Progresivno blokiranje (upozori, uspori, blokiraj) izbjegava trajne lažno pozitivne rezultate
- Svaki odgovor treba uključivati zaglavlja s ograničenjem brzine kako bi se informirao korisnik