Il-limitazzjoni tar-rati u l-prevenzjoni tal-abbuż
F'din il-paġna
Għaliex tillimita t-talbiet?
L-applikazzjonijiet tal-AI huma miri primarji għall-abbuż għal raġuni li ma kinitx teżisti mal-applikazzjonijiet tradizzjonali: kull sejħa tal-mudell tiswi flus. API REST tradizzjonali soġġetta għal għargħar ta’ talbiet tibbies u eventwalment taqa’, iżda ma tnixxixx kont bankarju. Applikazzjoni LLM, madankollu, tkompli tweġib perfettament filwaqt li l-kont jitla’ għas-sema. Mingħajr limitazzjoni tar-rata, attakkant jista’ jħassar il-baġit tal-API tiegħek f’ftit minuti, iniedi attakki awtomatizzati ta’ injezzjoni tal-prompt, jew juża l-infrastruttura tiegħek biex jiġġenera spam fuq in-nefqa tiegħek.
Żewġ modi kif tgħodd
It-tieqa li tiżżerżaq (sliding window) hija l-mekkaniżmu fundamentali. Tirreġistra t-timestamp ta’ kull talba, tarmi dawk li waqgħu barra mit-tieqa, u tqabbel il-bqija mal-limitu massimu. Is-superjorità tagħha fuq it-tieqa fissa tinżel għal dettall li jimpotta fil-prattika: b’tieqa fissa li tirrisettja kull minuta, attakkant jista’ jpoġġi l-kwota tiegħu fi tmiem minuta u mill-ġdid fil-bidu tal-oħra, u b’hekk jirdoppja effettivament il-produzzjoni permessa fuq ftit sekondi. It-tieqa li tiżżerżaq ma tħalli l-ebda ftuħ bħal dan.
Barra minn hekk, il-funzjoni ma tirritornax sempliċiment boolean; tirritorna dizzjunarju li jindika t-talbiet li fadal u l-ħin sal-irrisettjar. Dawn il-valuri jpopolaw l-intestaturi tar-risposta li l-klijenti leġittimi tiegħek se jużaw biex jirregolaw lilhom infushom—integrazzjoni mfassla tajjeb tistenna minflok ma tħabbat 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),
}
Madankollu, li tgħodd it-talbiet mhux biżżejjed, għax mhux it-talbiet kollha huma ugwali. Għaxar mistoqsijiet qosra jiswew frazzjoni ta’ dak li jiswa talba waħda akkumpanjata minn dokument ta’ ħamsin paġna. Limitatur għal kull talba jħalli dan tal-aħħar jgħaddi u jimblokka l-ewwel, li huwa eżattament l-oppost ta’ dak li jiddettaw l-ekonomiji tas-servizz. Baġit ta’ token jirrestawra l-proporzjonalità, b’risettjar kuljum u rreġistrar tal-użu attwali wara l-fatt, peress li l-istima magħmula qabel is-sejħa ma tkunx taf it-tul tar-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,
)
Kif tagħraf bot
Attakkant metodużu jibqa’ taħt is-soqfa tiegħek: sempliċiment irid jibbies. Għalhekk, is-sejbien tal-abbuż jeħtieġ li tħares lejn il-forma tat-traffiku minflok il-volum tiegħu. L-erba’ sinjali implimentati hawn taħt jissupplimentaw lil xulxin sew. Ir-ripetizzjoni identika tiżvela skript imwaħħal f’loop. Mewġa ta’ talbiet fi ftit sekondi tindika ritmu li l-ebda bniedem ma jista’ jżomm fuq it-tastiera. Messaġġ twil għaxriet eluf ta’ karattri jissinjala tentattiv ta’ injezzjoni volumetrika. Ir-raba’ wieħed huwa l-aktar interessanti: tul ta’ messaġġi rigorużament identiku fuq għaxar talbiet konsekuttivi jiżvela fuzzer li jbiddel il-kontenut b’struttura kostanti, filwaqt li utent reali jikteb sentenzi b’tulijiet 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()
Sanzjonijiet fuq livelli
Il-projbizzjoni fl-ewwel allarm tkun żball kostjuż, għax l-ebda wieħed minn dawn is-sinjali mhu infallibbli: utent nervuż li jkun qed iġedded paġna jattiva d-ditekter tal-mewġa mingħajr ma jkun malizzjuż. Il-projbizzjoni progressiva takkumula punteġġ u ttriggera risposti proporzjonali—twissija, imbagħad throttling, imbagħad blokk temporanju ta’ siegħa, u finalment erbgħa u għoxrin siegħa. Kull livell jagħti lill-utent leġittimu ċ-ans li joħroġ mit-traġettorja, filwaqt li l-iskript awtomatizzat isegwiha sal-aħħar.
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-ordni tal-verifiki jimpotta
L-assemblaġġ finali jgħaqqad l-erba’ mekkaniżmi qabel ma jsejjaħ il-mudell, u dan l-ordni jobdi regola sempliċi: mill-inqas għali għall-aktar għali. Il-verifika tal-projbizzjoni hija tfittxija f’dizzjunarju, il-limitazzjoni tar-rata tiskannja lista qasira, id-detezzjoni tal-abbuż tanalizza l-istorja, u l-kontroll tal-baġit jiġi eżatt qabel is-sejħa bil-ħlas. Li taqleb din is-sekwenza tfisser li tħallas għall-analiżi komportamentali għal utent li diġà huwa pprojbit. L-aħħar pass huwa dak li l-aktar jintesa: ir-reġistrar tal-użu attwali mill-qasam usage tar-risposta, li mingħajru l-baġit tiegħek iddevja mill-istima magħmula qabel is-sejħa.
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 Ewlenin
- Il-limitazzjoni tar-rati tipproteġi l-baġit tal-API tiegħek u tipprevjeni attakki awtomatizzati
- Għaqqad limiti għal kull talba (tieqa li tiżżerżaq) u limiti għal kull spiża (tokens)
- Id-detezzjoni tal-abbuż tidentifika mudelli: spam, flood, fuzzing, volum
- Il-projbizzjoni progressiva (wissi, ibbies, imblokka) tevita pożittivi foloz permanenti
- Kull risposta għandha tinkludi intestaturi ta’ limitu tar-rata biex tinforma lill-utent