Beperking van aanvragen en preventie van misbruik
Op deze pagina
Waarom aanvragen beperken?
AI-toepassingen zijn om een reden die bij traditionele apps niet bestond, een primair doelwit voor misbruik: elke modelaanroep kost geld. Een traditionele REST-API die wordt overspoeld met aanvragen, vertraagt en crasht uiteindelijk, maar put geen bankrekening leeg. Een LLM-toepassing blijft daarentegen perfect reageren terwijl de factuur de hoogte in schiet. Zonder beperking van het aantal aanvragen (rate limiting) kan een aanvaller uw API-budget binnen enkele minuten ruïneren, geautomatiseerde prompt-injectieaanvallen lanceren of uw infrastructuur gebruiken om spam op uw kosten te genereren.
Twee manieren om te tellen
Het schuivende venster (sliding window) is het fundamentele mechanisme. Het registreert het tijdstip van elke aanvraag, verwijdert diegenen die buiten het venster zijn gevallen en vergelijkt de rest met het maximum. De superioriteit ten opzichte van het vaste venster komt neer op een detail dat in de praktijk belangrijk is: bij een vast venster dat elke minuut wordt gereset, kan een aanvaller zijn quotum plaatsen aan het einde van de ene minuut en opnieuw aan het begin van de volgende, waardoor de toegestane doorvoer effectief wordt verdubbeld over een paar seconden. Het schuivende venster laat geen dergelijke opening over.
Bovendien retourneert de functie niet simpelweg een boolean; deze retourneert een dictionary die het aantal resterende aanvragen en de tijd tot reset aangeeft. Deze waarden vullen de responsheaders die uw legitieme clients zullen gebruiken om zichzelf te reguleren—een goed ontworpen integratie wacht in plaats van het eindpunt te bestoken.
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),
}
Het tellen van aanvragen is echter niet genoeg, omdat niet alle aanvragen gelijk zijn. Tien korte vragen kosten een fractie van wat een enkele aanvraag vergezeld van een document van vijftig pagina’s kost. Een limiter per aanvraag zou de laatste doorlaten en de eerste blokkeren, wat precies het tegenovergestelde is van wat de service-economie voorschrijft. Een tokenbudget herstelt de proportionaliteit, met een dagelijkse reset en registratie van het daadwerkelijke gebruik achteraf, aangezien de schatting voorafgaand aan de oproep de lengte van het antwoord niet kent.
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,
)
Een bot herkennen
Een methodische aanvaller blijft onder uw plafonds: ze hoeven alleen maar te vertragen. Het detecteren van misbruik vereist daarom dat u kijkt naar de vorm van het verkeer in plaats van het volume. De vier onderstaande signalen vullen elkaar goed aan. Identieke herhaling verraadt een script dat in een lus vastzit. Een stortvloed van aanvragen binnen een paar seconden wijst op een tempo dat geen mens aan het toetsenbord kan volhouden. Een bericht van tienduizenden tekens signaleert een poging tot volumetrische injectie. Het vierde is het meest interessant: strikt identieke berichtlengtes over tien opeenvolgende aanvragen onthullen een fuzzer die inhoud varieert met een constante structuur, terwijl een echte gebruiker zinnen van onregelmatige lengtes schrijft.
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()
Getrapte sancties
Verbannen bij de eerste waarschuwing zou een kostbare fout zijn, omdat geen van deze signalen onfeilbaar is: een gebruiker die nerveus een pagina ververst, activeert de burst-detector zonder kwaadwillend te zijn. Progressief verbannen accumuleert een score en activeert proportionele reacties—een waarschuwing, vervolgens throttling, daarna een tijdelijke blokkering van één uur, en uiteindelijk vierentwintig uur. Elke trap geeft de legitieme gebruiker de kans om van koers te veranderen, terwijl het geautomatiseerde script dit tot het einde volgt.
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
De volgorde van controles is belangrijk
De uiteindelijke assemblage koppelt de vier mechanismen aan elkaar voordat het model wordt aangeroepen, en deze volgorde volgt een eenvoudige regel: van minst duur naar meest duur. De controle op verbanning is een dictionary-zoekopdracht, rate limiting scant een korte lijst, misbruikdetectie analyseert de geschiedenis, en budgetcontrole komt net voor de gefactureerde oproep. Het omdraaien van deze reeks zou betekenen dat u betaalt voor gedragsanalyse voor een gebruiker die al verbannen is. De laatste stap is degene die het vaakst wordt vergeten: het registreren van het daadwerkelijke gebruik vanuit het veld usage van de respons, zonder welke uw budget zou afwijken van de schatting die voor de oproep is gemaakt.
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
Belangrijkste punten
- Rate limiting beschermt uw API-budget en voorkomt geautomatiseerde aanvallen
- Combineer limieten per aanvraag (schuivend venster) en limieten per kostenpost (tokens)
- Misbruikdetectie identificeert patronen: spam, flood, fuzzing, volume
- Progressief verbannen (waarschuwen, vertragen, blokkeren) voorkomt permanente false positives
- Elke respons moet rate limit-headers bevatten om de gebruiker te informeren