Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Omejevanje števila zahtev in preprečevanje zlorab

Lekcija 8 od 14 Posodobljeno 28. julij 2026 Napredni
Na tej strani
  1. Zakaj omejiti število zahtev?
  2. Dva načina štetja
  3. Prepoznavanje bota
  4. Stopnjevanje sankcij
  5. Vrstni red preverjanj je pomemben
  6. Ključne ugotovitve

Zakaj omejiti število zahtev?

Aplikacije z umetno inteligenco so glavne tarče zlorab zaradi razloga, ki pri tradicionalnih aplikacijah ni obstajal: vsak klic modela stane denar. Tradicionalni REST API, izpostavljen poplavi zahtev, se upočasni in sčasoma zruši, vendar ne izprazni bančnega računa. Aplikacija z velikim jezikovnim modelom (LLM) pa še naprej popolnoma odgovarja, medtem ko račun eksplodira. Brez omejevanja števila zahtev lahko napadalec v nekaj minutah uniči tvoj proračun za API, sproži avtomatizirane napade z vbrizgavanjem pozivov ali uporabi tvojo infrastrukturo za ustvarjanje neželenih sporočil na tvoje stroške.

Dva načina štetja

Drsno okno je temeljni mehanizem. Zabeleži časovni žig vsake zahteve, zavrže tiste, ki so padle izven okna, in preostale primerja z zgornjo mejo. Njegova prednost pred fiksnim oknom temelji na podrobnosti, ki je v praksi ključna: pri fiksnem oknu, ki se ponastavi vsako minuto, lahko napadalec svoj kvoto porabi na koncu ene minute in znova na začetku naslednje, kar dejansko podvoji dovoljeno prepustnost v nekaj sekundah. Drsno okno ne pušča takšnih odprtin.

Poleg tega funkcija ne vrne preproste logične vrednosti; vrne slovar, ki kaže preostale zahteve in čas do ponastavitve. Te vrednosti zapolnijo glave odziva, ki jih bodo tvoji legitimni odjemalci uporabili za samoregulacijo – dobro zasnovana integracija raje počaka, kot da bi neprestano obremenjevala končno točko.

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

Štetje zahtev samo po sebi ni dovolj, saj niso vse zahteve enake. Deset kratkih vprašanj stane le delček tega, kar stane ena sama zahteva, ki jo spremlja petdesetstranski dokument. Omejitev na zahtevo bi slednjo prepustila, prve pa blokirala, kar je ravno nasprotno od tega, kar narekuje ekonomija storitev. Proračun žetonov obnovi sorazmernost z dnevno ponastavitvijo in beleženjem dejanske porabe po opravljenem klicu, saj ocena pred klicem ne ve dolžine odziva.

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

Prepoznavanje bota

Metodičen napadalec ostane pod tvojimi zgornjimi mejami: upočasniti se mora le toliko. Zaznavanje zlorab zato zahteva gledanje na obliko prometa, ne le na njegov obseg. Štirje spodaj implementirani signali se med seboj dobro dopolnjujejo. Enako ponavljanje razkriva skripto, ki se je zataknila v zanki. Izbruh zahtev v nekaj sekundah kaže na tempo, ki ga človek za tipkovnico ne more vzdrževati. Sporočilo, dolgo desettisoče znakov, signalizira poskus volumetričnega vbrizgavanja. Četrti signal je najbolj zanimiv: strogo enake dolžine sporočil v desetih zaporednih zahtevah razkrivajo fuzzer, ki spreminja vsebino s konstantno strukturo, medtem ko pravi uporabnik piše stavke nepravilnih dolžin.

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

Stopnjevanje sankcij

Prepoved dostopa ob prvem opozorilu bi bila draga napaka, saj noben od teh signalov ni stoodstotno zanesljiv: uporabnik, ki živčno osvežuje stran, sproži detektor izbruha, ne da bi bil zlonameren. Postopno prepovedovanje kopiči rezultat in sproža sorazmerne odzive – opozorilo, nato omejitev hitrosti, nato začasna enourna blokada in nazadnje štiriindvajseturna blokada. Vsaka stopnja daje legitimnemu uporabniku priložnost, da se umakne s te poti, medtem ko avtomatizirana skripta sledi do konca.

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

Vrstni red preverjanj je pomemben

Končna sestava poveže štiri mehanizme pred klicem modela, ta vrstni red pa sledi preprostemu pravilu: od najmanj do najbolj potratnega. Preverjanje prepovedi je iskanje v slovarju, omejevanje števila zahtev pregleda kratek seznam, zaznavanje zlorab analizira zgodovino, nadzor proračuna pa pride tik pred zaračunani klic. Obrnitev tega zaporedja bi pomenila plačevanje vedenjske analize za uporabnika, ki je že prepovedan. Zadnji korak je tisti, na katerega najpogosteje pozabimo: beleženje dejanske porabe iz polja usage v odzivu, brez katerega bi tvoj proračun odstopal od ocene, narejene pred klicem.

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

Ključne ugotovitve

  • Omejevanje števila zahtev ščiti tvoj proračun za API in preprečuje avtomatizirane napade
  • Združi omejitve na zahtevo (drsno okno) in omejitve na strošek (žetoni)
  • Zaznavanje zlorab prepozna vzorce: neželeno pošto, poplave, fuziranje, volumen
  • Postopno prepovedovanje (opozori, upočasni, blokiraj) se izogne trajnim lažno pozitivnim rezultatom
  • Vsak odziv bi moral vključevati glave za omejevanje števila zahtev, da se uporabnik obvesti