Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Kéréskorlátozás és visszaélés-megelőzés

8. lecke 14 közül Frissítve 2026. július 28. Haladó
Ezen az oldalon
  1. Miért kell korlátozni a kéréseket?
  2. Kétféle számlálás
  3. Bot felismerése
  4. Fokozatos szankciók
  5. Az ellenőrzések sorrendje számít
  6. Főbb megállapítások

Miért kell korlátozni a kéréseket?

Az AI-alkalmazások kiemelt célpontjai a visszaéléseknek egy olyan okból, amely a hagyományos alkalmazásoknál nem létezett: minden modellhívás pénzbe kerül. Egy hagyományos REST API, amelyet kérések áradatának tesznek ki, lelassul, majd végül összeomlik, de nem meríti ki a bankszámládat. Ezzel szemben egy LLM-alkalmazás tökéletesen folytatja a válaszadást, miközben a számlád az egekbe szökik. Kéréskorlátozás nélkül egy támadó percek alatt tönkreteheti az API-költségkeretedet, automatizált prompt-injekciós támadásokat indíthat, vagy a te infrastruktúrádat használva spamet generálhat a te költségedre.

Kétféle számlálás

A csúszó ablak (sliding window) az alapvető mechanizmus. Ez rögzíti minden kérés időbélyegét, elveti azokat, amelyek kiestek az ablakból, és a maradékot hasonlítja össze a felső határral. A fix ablakkal szembeni fölénye egy gyakorlatban fontos részleten múlik: egy percenként alaphelyzetbe álló fix ablak esetén a támadó a kvótáját az egyik perc végére és a következő elejére időzítheti, így néhány másodperc alatt gyakorlatilag megduplázhatja a megengedett átviteli sebességet. A csúszó ablak nem hagy ilyen rést.

Ráadásul a függvény nem egyszerű boolean értéket ad vissza; hanem egy szótárat, amely jelzi a fennmaradó kérések számát és a visszaállításig hátralévő időt. Ezek az értékek töltik fel azokat a válaszfejléceket, amelyeket a jogosult klienseid az önkorlátozásra használnak – egy jól megtervezett integráció inkább vár, mintsem hogy ostromolja a végpontot.

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

A kérések számlálása önmagában nem elég, mert nem minden kérés egyenértékű. Tíz rövid kérdés töredékébe kerül annak, mint egyetlen, ötvenoldalas dokumentummal kísért kérés. A kérésenkénti korlátozó engedné át az utóbbit, és blokkolná az előbbit, ami pontosan az ellenkezője annak, amit a szolgáltatás gazdaságossága diktál. A tokenköltség-keret (token budget) helyreállítja az arányosságot, napi visszaállással és a tényleges felhasználás utólagos rögzítésével, mivel a hívás előtt készített becslés nem ismeri a válasz hosszát.

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

Bot felismerése

Egy módszeres támadó a korlátaid alatt marad: csak lassítania kell. A visszaélések észlelése ezért nem a forgalom mennyiségét, hanem annak alakzatát vizsgálja. Az alább implementált négy jel jól kiegészíti egymást. Az azonos ismétlés egy hurokban ragadt szkriptet árul el. A néhány másodpercen belüli kérések kitörése olyan tempót jelez, amelyet ember nem képes维持ani a billentyűzetnél. A több tízezer karakter hosszú üzenet volumetrikus injekciós kísérletre utal. A negyedik a legérdekesebb: tíz egymást követő kérés során szigorúan azonos üzenethosszak egy olyan fuzzert tárnak fel, amely változtatja a tartalmat, de állandó szerkezetet tart, míg egy valódi felhasználó szabálytalan hosszúságú mondatokat ír.

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

Fokozatos szankciók

Az első riasztásra történő letiltás költséges hiba lenne, mert e jelek egyike sem tévedhetetlen: egy idegesen frissítő felhasználó kiválthatja a kitörés-érzékelőt anélkül, hogy rosszindulatú lenne. A fokozatos letiltás pontszámot halmoz fel, és arányos válaszokat vált ki – figyelmeztetés, majd lassítás, majd egy órás ideiglenes blokkolás, végül huszonnégy óra. Minden szint lehetőséget ad a jogosult felhasználónak, hogy letérjen erről az útról, míg az automatizált szkript végigmegy rajta.

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

Az ellenőrzések sorrendje számít

A végső összeállítás a négy mechanizmust láncolja össze a modell hívása előtt, és ez a sorrend egy egyszerű szabályt követ: a legkevésbé költségestől a legköltségesebbig. A letiltás ellenőrzése egy szótárkeresés, a kéréskorlátozás egy rövid lista bejárása, a visszaélés-észlelés az előzmények elemzése, a költségkeret-ellenőrzés pedig közvetlenül a számlázott hívás előtt történik. E sorrend megfordítása azt jelentené, hogy viselkedéselemzésért fizetnél egy olyan felhasználó esetén, akit már letiltottak. Az utolsó lépés az, amit leggyakrabban elfelejtenek: a tényleges felhasználás rögzítése a válasz usage mezőjéből, ami nélkül a költségkereted eltérne a hívás előtt készített becsléstől.

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

Főbb megállapítások

  • A kéréskorlátozás védi az API-költségkeretedet és megelőzi az automatizált támadásokat
  • Kombináld a kérésenkénti korlátokat (csúszó ablak) és a költségalapú korlátokat (tokenek)
  • A visszaélés-észlelés mintázatokat azonosít: spam, flood, fuzzing, volumen
  • A fokozatos letiltás (figyelmeztetés, lassítás, blokkolás) elkerüli a tartós téves pozitív eredményeket
  • Minden válasznak tartalmaznia kell a kéréskorlátozási fejléceket a felhasználó tájékoztatására