Ierobežojumu piemērošana un ļaunprātīgas izmantošanas novēršana
Šajā lapā
Kāpēc ierobežot pieprasījumus?
AI lietojumprogrammas ir īpaši pievilcīgi mērķi ļaunprātīgai izmantošanai iemesla dēļ, kas tradicionālajām lietotnēm nepastāvēja: katrs modeļa izsaukums maksā naudu. Tradicionāls REST API, pakļauts pieprasījumu plūsmai, palēninās un galu galā sabojājas, taču tas neiztukšo bankas kontu. Savukārt LLM lietotne turpina perfekti atbildēt, kamēr rēķins strauji aug. Bez pieprasījumu ierobežošanas uzbrucējs minūšu laikā var izpostīt tava API budžetu, uzsākt automatizētus promptu injicēšanas uzbrukumus vai izmantot tavu infrastruktūru, lai ģenerētu spamu uz tava rēķina.
Divi skaitīšanas veidi
Slīdošais logs ir fundamentālais mehānisms. Tas reģistrē katra pieprasījuma laika zīmogu, atsijā tos, kas ir izgājuši ārpus loga, un salīdzina atlikušos ar noteikto griestu vērtību. Tā pārākums pār fiksēto logu slēpjas detaļā, kas praksē ir izšķiroša: ar fiksētu logu, kas atiestatās katru minūti, uzbrucējs var izvietot savu kvotu vienas minūtes beigās un atkal nākamās sākumā, efektīvi dubultojot atļauto caurlaidību dažu sekunžu laikā. Slīdošais logs neatstāj šādu iespēju.
Turklāt funkcija neatgriež vienkāršu boolean vērtību; tā atgriež vārdnīcu, kas norāda atlikušo pieprasījumu skaitu un laiku līdz atiestatīšanai. Šīs vērtības aizpilda atbildes galvenes, ko tavi leģitīmie klienti izmantos pašregulācijai – labi izstrādāta integrācija gaida, nevis bombardē galapunktu.
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),
}
Tomēr pieprasījumu skaitīšana nepietiek, jo ne visi pieprasījumi ir vienādi. Desmit īsi jautājumi izmaksā daļu no tā, ko maksā viens pieprasījums, kam pievienots piecdesmit lappušu dokuments. Ierobežojums uz vienu pieprasījumu ļautu pēdējam cauri un bloķētu pirmos, kas ir tieši pretējs tam, ko diktē pakalpojuma ekonomika. Tokena budžets atjauno proporcionalitāti, veicot ikdienas atiestatīšanu un reģistrējot faktisko izmantojumu pēc notikuma, jo aplēse pirms izsaukuma nezina atbildes garumu.
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,
)
Bota atpazīšana
Metodisks uzbrucējs paliek zem taviem griestiem: viņam vienkārši jāpalēninās. Tādēļ ļaunprātīgas izmantošanas noteikšanai ir jāraugās uz satiksmes formu, nevis tās apjomu. Zemāk ieviestie četri signāli lieliski papildina viens otru. Identiska atkārtošanās nodod skriptu, kas iestrēdzis cilpā. Pieprasījumu uzliesmojums dažu sekunžu laikā norāda uz tempu, ko cilvēks pie tastatūras nespēj uzturēt. Ziņojums, kas garāks par desmitiem tūkstošu rakstzīmju, signalizē par mēģinājumu veikt apjomīgu injicēšanu. Ceturtais ir visinteresantākais: stingri identiski ziņojumu garumi desmit secīgos pieprasījumos atklāj fuzzeri, kas maina saturu ar nemainīgu struktūru, turpretī īsts lietotājs raksta teikumus ar neregulāru garumu.
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()
Pakāpeniskas sankcijas
Aizliegums jau pie pirmā brīdinājuma būtu dārga kļūda, jo neviens no šiem signāliem nav nekaitīgs: lietotājs, kas nervozi atsvaidzina lapu, aktivizē uzliesmojuma detektoru, nebūdams ļaunprātīgs. Pakāpeniska aizliegšana uzkrāj punktu skaitu un aktivizē proporcionālas reakcijas – brīdinājumu, tad ātruma ierobežošanu, tad īslaicīgu bloķēšanu uz vienu stundu un visbeidzot uz divdesmit četrām stundām. Katrs līmenis dod leģitīmajam lietotājam iespēju novirzīties no šī ceļa, kamēr automatizēts skripts tam seko līdz galam.
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
Pārbaudes secībai ir nozīme
Galīgā montāža savieno četrus mehānismus pirms modeļa izsaukšanas, un šī secība pakļaujas vienkāršam likumam: no vismazāk dārgā uz visdārgāko. Aizlieguma pārbaude ir vārdnīcas meklēšana, pieprasījumu ierobežošana skenē īsu sarakstu, ļaunprātīgas izmantošanas noteikšana analizē vēsturi, un budžeta kontrole notiek tieši pirms apmaksātā izsaukuma. Šīs secības apgriešana nozīmētu, ka tu maksā par uzvedības analīzi lietotājam, kurš jau ir aizliegts. Pēdējais solis ir tas, ko visbiežāk aizmirst: faktiskās izmantošanas reģistrēšana no atbildes lauka usage, bez kura tavs budžets novirzītos no aplēses, kas veikta pirms izsaukuma.
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
Galvenās atziņas
- Pieprasījumu ierobežošana aizsargā tava API budžetu un novērš automatizētus uzbrukumus
- Apvieno ierobežojumus uz vienu pieprasījumu (slīdošais logs) un izmaksu ierobežojumus (tokeni)
- Ļaunprātīgas izmantošanas noteikšana identificē modeļus: spamu, plūdus, fuzingu, apjomu
- Pakāpeniska aizliegšana (brīdināt, ierobežot ātrumu, bloķēt) izvairās no pastāvīgiem viltus pozitīviem rezultātiem
- Katrai atbildei jāietver galvenes ar informāciju par pieprasījumu ierobežojumiem, lai informētu lietotāju