Limitazione delle richieste e prevenzione degli abusi
In questa pagina
Perché limitare le richieste?
Le applicazioni di intelligenza artificiale sono bersagli privilegiati per gli abusi per un motivo che non esisteva con le app tradizionali: ogni chiamata al modello ha un costo. Un’API REST tradizionale sottoposta a un flusso massiccio di richieste rallenta e alla fine va in crash, ma non prosciuga un conto in banca. Un’applicazione basata su LLM, invece, continua a rispondere perfettamente mentre la fattura schizza alle stelle. Senza una limitazione delle richieste, un attaccante può distruggere il tuo budget API in pochi minuti, lanciare attacchi automatizzati di prompt injection o utilizzare la tua infrastruttura per generare spam a tue spese.
Due modi per contare
La finestra scorrevole è il meccanismo fondamentale. Registra il timestamp di ogni richiesta, scarta quelle uscite dalla finestra e confronta il resto con il limite massimo. La sua superiorità rispetto alla finestra fissa si riduce a un dettaglio che conta nella pratica: con una finestra fissa che si resetta ogni minuto, un attaccante può posizionare il proprio quota alla fine di un minuto e di nuovo all’inizio del successivo, raddoppiando di fatto il throughput consentito in pochi secondi. La finestra scorrevole non lascia spazio a tali aperture.
Inoltre, la funzione non restituisce un semplice booleano; restituisce un dizionario che indica le richieste rimanenti e il tempo mancante al reset. Questi valori popolano gli header di risposta che i tuoi clienti legittimi utilizzeranno per autoregolarsi: un’integrazione ben progettata attende invece di martellare l’endpoint.
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),
}
Contare le richieste non basta, però, perché non tutte le richieste sono uguali. Dieci domande brevi costano una frazione di quanto costa una singola richiesta accompagnata da un documento di cinquanta pagine. Un limitatore per richiesta lascerebbe passare quest’ultima e bloccherebbe le prime, esattamente l’opposto di quanto dettano l’economia del servizio. Un budget di token ripristina la proporzionalità, con un reset giornaliero e la registrazione dell’uso effettivo dopo il fatto, dato che la stima fatta prima della chiamata non conosce la lunghezza della risposta.
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,
)
Riconoscere un bot
Un attaccante metodico rimane sotto i tuoi limiti: gli basta solo rallentare. Rilevare gli abusi richiede quindi di osservare la forma del traffico piuttosto che il suo volume. I quattro segnali implementati di seguito si completano a vicenda. La ripetizione identica tradisce uno script bloccato in un loop. Un’esplosione di richieste in pochi secondi indica un ritmo che nessun umano può mantenere alla tastiera. Un messaggio lungo decine di migliaia di caratteri segnala un tentativo di iniezione volumetrica. Il quarto è il più interessante: lunghezze di messaggio rigorosamente identiche per dieci richieste consecutive rivelano un fuzzer che varia il contenuto mantenendo una struttura costante, mentre un utente reale scrive frasi di lunghezze irregolari.
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()
Sanzioni a livelli
Bannare al primo allarme sarebbe un errore costoso, perché nessuno di questi segnali è infallibile: un utente che aggiorna nervosamente una pagina attiva il rilevatore di picchi senza essere malintenzionato. Il banno progressivo accumula un punteggio e attiva risposte proporzionate: un avvertimento, poi una limitazione della velocità, poi un blocco temporaneo di un’ora e infine di ventiquattro ore. Ogni livello dà all’utente legittimo la possibilità di uscire dalla traiettoria, mentre lo script automatizzato la segue fino alla fine.
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
L’ordine dei controlli conta
L’assemblaggio finale concatena i quattro meccanismi prima di chiamare il modello, e questo ordine obbedisce a una regola semplice: dal meno costoso al più costoso. Il controllo del banno è una ricerca in dizionario, la limitazione delle richieste scansiona una lista breve, il rilevamento degli abusi analizza la cronologia e il controllo del budget arriva appena prima della chiamata a pagamento. Invertire questa sequenza significherebbe pagare per l’analisi comportamentale di un utente che è già bannato. L’ultimo passo è quello più spesso dimenticato: registrare l’uso effettivo dal campo usage della risposta, senza il quale il tuo budget si discosterebbe dalla stima fatta prima della chiamata.
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
Punti chiave
- La limitazione delle richieste protegge il tuo budget API e previene gli attacchi automatizzati
- Combina limiti per richiesta (finestra scorrevole) e limiti per costo (token)
- Il rilevamento degli abusi identifica pattern: spam, flood, fuzzing, volume
- Il banno progressivo (avverti, limita, blocca) evita falsi positivi permanenti
- Ogni risposta dovrebbe includere header di limitazione delle richieste per informare l’utente