Salt la conținutul principal
Română— Alege o limbă
Meniu

Limitarea cererilor și prevenirea abuzurilor

Lecția 8 din 14 Actualizată 28 iulie 2026 Avansat
Pe această pagină
  1. De ce să limitați cererile?
  2. Două moduri de a număra
  3. Recunoașterea unui bot
  4. Sancțiuni eșalonate
  5. Ordinea verificărilor contează
  6. Puncte cheie

De ce să limitați cererile?

Aplicațiile bazate pe IA sunt ținte predilecte pentru abuzuri dintr-un motiv care nu exista în cazul aplicațiilor tradiționale: fiecare apel al modelului costă bani. Un API REST tradițional supus unui flux masiv de cereri încetinește și, în final, se prăbușește, dar nu golește un cont bancar. O aplicație LLM, însă, continuă să răspundă perfect în timp ce factura crește exponențial. Fără limitarea ratei, un atacator vă poate epuiza bugetul API în câteva minute, poate lansa atacuri automate de injectare de prompt-uri sau poate folosi infrastructura dumneavoastră pentru a genera spam pe cheltuiala dumneavoastră.

Două moduri de a număra

Fereastra glisantă este mecanismul fundamental. Aceasta înregistrează marcajul temporal al fiecărei cereri, le elimină pe cele care au ieșit din fereastră și compară restul cu plafonul stabilit. Superioritatea sa față de fereastra fixă se reduce la un detaliu crucial în practică: cu o fereastră fixă care se resetează la fiecare minut, un atacator își poate plasa cota la sfârșitul unui minut și din nou la începutul următorului, dublând efectiv throughput-ul permis pe parcursul câtorva secunde. Fereastra glisantă nu lasă nicio astfel de breșă.

În plus, funcția nu returnează un simplu boolean; ea returnează un dicționar care indică numărul de cereri rămase și timpul până la resetare. Aceste valori populează anteturile de răspuns pe care clienții dumneavoastră legitimi le vor folosi pentru a se autoreglementa – o integrare bine concepută așteaptă în loc să bombardeze endpoint-ul.

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),
}

Numărarea cererilor nu este suficientă, deoarece nu toate cererile sunt egale. Zece întrebări scurte costă o fracțiune din ceea ce costă o singură cerere însoțită de un document de cincizeci de pagini. Un limitator per-cereră ar permite trecerea ultimului caz și l-ar bloca pe primul, ceea ce este exact opusul a ceea ce dictează economia serviciilor. Un buget de tokeni restabilește proporționalitatea, cu o resetare zilnică și înregistrarea utilizării reale după fapt, deoarece estimarea făcută înainte de apel nu cunoaște lungimea răspunsului.

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,
)

Recunoașterea unui bot

Un atacator metodic rămâne sub plafoanele dumneavoastră: trebuie doar să încetinească. Detectarea abuzurilor necesită, prin urmare, analizarea formei traficului, nu doar a volumului său. Cele patru semnale implementate mai jos se completează reciproc. Repetarea identică trădează un script blocat într-o buclă. O explozie de cereri în câteva secunde indică un ritm pe care niciun om nu îl poate menține la tastatură. Un mesaj de zeci de mii de caractere semnalează o tentativă de injecție volumetrică. Al patrulea este cel mai interesant: lungimi riguros identice ale mesajelor pe zece cereri consecutive relevă un fuzzer care variază conținutul cu o structură constantă, în timp ce un utilizator real scrie propoziții de lungimi neregulate.

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()

Sancțiuni eșalonate

Interzicerea accesului la prima alertă ar fi o greșeală costisitoare, deoarece niciunul dintre aceste semnale nu este infailibil: un utilizator care reîncarcă nervos o pagină declanșează detectorul de explozie fără a fi rău intenționat. Interzicerea progresivă acumulează un scor și declanșează răspunsuri proporționale – un avertisment, apoi limitarea vitezei, apoi un blocaj temporar de o oră și, în final, de douăzeci și patru de ore. Fiecare nivel oferă utilizatorului legitim șansa de a ieși din această traiectorie, în timp ce scriptul automat o urmează până la capăt.

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

Ordinea verificărilor contează

Asamblarea finală înlănțuie cele patru mecanisme înainte de a apela modelul, iar această ordine respectă o regulă simplă: de la cel mai puțin costisitor la cel mai costisitor. Verificarea interzicerii este o căutare în dicționar, limitarea ratei scanează o listă scurtă, detectarea abuzurilor analizează istoricul, iar controlul bugetar vine chiar înainte de apelul facturat. Inversarea acestei secvențe ar însemna să plătiți pentru analiza comportamentală a unui utilizator care este deja interzis. Ultimul pas este cel mai adesea uitat: înregistrarea utilizării reale din câmpul usage al răspunsului, fără de care bugetul dumneavoastră s-ar abate de la estimarea făcută înainte de apel.

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

Puncte cheie

  • Limitarea ratei protejează bugetul API și previne atacurile automate
  • Combinați limitele per-cerere (fereastră glisantă) cu limitele per-cost (tokeni)
  • Detectarea abuzurilor identifică tipare: spam, flood, fuzzing, volum
  • Interzicerea progresivă (avertizare, limitare, blocare) evită fals pozitivele permanente
  • Fiecare răspuns ar trebui să includă antete de limitare a ratei pentru a informa utilizatorul