Begrænsning af forespørgsler og forebyggelse af misbrug
På denne side
Hvorfor begrænse forespørgsler?
AI-applikationer er primære mål for misbrug af en grund, der ikke eksisterede for traditionelle apps: hvert modelkald koster penge. En traditionel REST-API, der udsættes for en flodbølge af forespørgsler, bliver langsom og crascher til sidst, men den tømmer ikke en bankkonto. En LLM-applikation fortsætter derimod med at svare perfekt, mens regningen eksploderer. Uden begrænsning af forespørgsler (rate limiting) kan en angriber ruinere dit API-budget på få minutter, lancere automatiserede prompt injection-angreb eller bruge din infrastruktur til at generere spam på din regning.
To måder at tælle på
Det glidende vindue (sliding window) er den fundamentale mekanisme. Det registrerer tidsstemplet for hver forespørgsel, kasserer dem, der er faldet ud af vinduet, og sammenligner resten med loftet. Dens overlegenhed i forhold til det faste vindue handler om en detalje, der betyder noget i praksis: med et fast vindue, der nulstilles hvert minut, kan en angriber placere sin kvote i slutningen af det ene minut og igen i starten af det næste, hvilket effektivt fordobler den tilladte gennemstrømning over få sekunder. Det glidende vindue efterlader ingen sådan åbning.
Desuden returnerer funktionen ikke en simpel boolean; den returnerer et ordbogsobjekt (dictionary), der angiver de resterende forespørgsler og tiden indtil nulstilling. Disse værdier befolker svar-headers, som dine legitime klienter vil bruge til at selvregulere – en veldesignet integration venter i stedet for at hamre endpointet.
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),
}
At tælle forespørgsler er dog ikke nok, fordi ikke alle forespørgsler er lige. Ti korte spørgsmål koster en brøkdel af, hvad en enkelt forespørgsel ledsaget af et halvtreds sider langt dokument koster. En begrænser pr. forespørgsel ville lukke sidstnævnte igennem og blokere de første, hvilket er præcis det modsatte af, hvad serviceøkonomien dikterer. Et token-budget genopretter proportionaliteten med en daglig nulstilling og registrering af det faktiske forbrug i efterhånd, da estimatet foretaget før kaldet ikke kender længden af svaret.
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,
)
Genkendelse af en bot
En metodisk angriber holder sig under dine lofter: de skal bare sætte farten ned. Opdagelse af misbrug kræver derfor, at man ser på trafikformens facon snarere end dens volumen. De fire signaler, der er implementeret nedenfor, supplerer hinanden godt. Identisk gentagelse afslører et script, der sidder fast i en løkke. En byge af forespørgsler inden for få sekunder indikerer et tempo, som intet menneske kan opretholde ved tastaturet. En besked på titusindvis af tegn signalerer et forsøg på volumetrisk injection. Det fjerde er det mest interessante: strengt identiske beskedlængder over ti på hinanden følgende forespørgsler afslører en fuzzer, der varierer indholdet med konstant struktur, hvorimod en rigtig bruger skriver sætninger med uregelmæssige længder.
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()
Trinvise sanktioner
At udelukke ved første alarm ville være en dyr fejl, fordi intet af disse signaler er ufejlbarlige: en bruger, der nervøst genindlæser en side, udløser burst-detektoren uden at være ondsindet. Progressiv udelukkelse akkumulerer en score og udløser proportionale responser – en advarsel, derefter drossling, derefter en midlertidig blokering på en time og til sidst fireogtyve timer. Hvert trin giver den legitime bruger en chance for at komme af sporet, mens det automatiserede script følger det hele vejen.
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
Rækkefølgen af tjek betyder noget
Den endelige samling kæder de fire mekanismer sammen før kaldet til modellen, og denne rækkefølge adlyder en simpel regel: fra mindst til mest ressourcekrævende. Tjekket for udelukkelse er et opslag i en ordbog, begrænsning af forespørgsler scanner en kort liste, detektion af misbrug analyserer historik, og budgetkontrol kommer lige før det fakturerede kald. At vende denne sekvens ville betyde at betale for adfærdsanalyse for en bruger, der allerede er udelukket. Det sidste trin er det, der oftest glemmes: registrering af det faktiske forbrug fra feltet usage i svaret, uden hvilket dit budget ville drive væk fra estimatet foretaget før kaldet.
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
Vigtige pointer
- Begrænsning af forespørgsler beskytter dit API-budget og forhindrer automatiserede angreb
- Kombiner grænser pr. forespørgsel (glidende vindue) og grænser pr. omkostning (tokens)
- Detektion af misbrug identificerer mønstre: spam, flood, fuzzing, volumen
- Progressiv udelukkelse (advarsel, drossling, blokering) undgår permanente falske positiver
- Hvert svar bør inkludere headers for begrænsning af forespørgsler for at informere brugeren