Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Omezování rychlosti a prevence zneužití

Lekce 8 z 14 Aktualizováno 28. července 2026 Pokročilý
Na této stránce
  1. Proč omezovat požadavky?
  2. Dva způsoby počítání
  3. Rozpoznání bota
  4. Postupné sankce
  5. Na pořadí kontrol záleží
  6. Klíčové poznatky

Proč omezovat požadavky?

Aplikace založené na umělé inteligenci jsou prvotřídními cíli pro zneužití z důvodu, který u tradičních aplikací neexistoval: každé volání modelu stojí peníze. Tradiční REST API zaplavené požadavky zpomalí a nakonec spadne, ale nevysaje vám bankovní účet. Aplikace s LLM však bude dokonale odpovídat dál, zatímco faktura prudce poroste. Bez omezování rychlosti může útočník během několika minut zničit váš rozpočet na API, spustit automatizované útoky typu prompt injection nebo využít vaši infrastrukturu ke generování spamu na vaše náklady.

Dva způsoby počítání

Posuvné okno je základním mechanismem. Ukládá časovou značku každého požadavku, zahodí ty, které vypadly z okna, a zbytek porovná se stropem. Jeho nadřazenost nad pevným oknem spočívá v detailu, který má v praxi zásadní význam: u pevného okna, které se resetuje každou minutu, může útočník umístit svou kvótu na konec jedné minuty a znovu na začátek další, čímž efektivně zdvojnásobí povolenou propustnost během několika sekund. Posuvné okno takovou skulinu nenechává.

Funkce navíc nevrací jednoduchou boolean hodnotu; vrací slovník s informacemi o zbývajících požadavcích a čase do resetu. Tyto hodnoty plní hlavičky odpovědí, které vaši legitimní klienti využijí k samoregulaci – dobře navržená integrace raději počká, než aby endpoint bombardovala.

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

Samotné počítání požadavků však nestačí, protože ne všechny požadavky jsou si rovny. Deset krátkých otázek stojí zlomek toho, co jeden požadavek doprovázený padesátistránkovým dokumentem. Omezovač založený na počtu požadavků by ten druhý propustil a první zablokoval, což je přesný opak toho, co diktuje ekonomika služby. Rozpočet tokenů obnovuje úměrnost s denním resetem a zaznamenáním skutečné spotřeby až dodatečně, protože odhad před voláním nezná délku odpovědi.

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

Rozpoznání bota

Metodický útočník se vejde do vašich stropů: stačí, když zpomalí. Detekce zneužití proto vyžaduje sledování tvaru provozu, nikoli jen jeho objemu. Čtyři níže implementované signály se navzájem dobře doplňují. Identická opakování prozrazují skript uvízlý ve smyčce. Záplava požadavků během několika sekund naznačuje tempo, které žádný člověk u klávesnice neudrží. Zpráva dlouhá desítky tisíc znaků signalizuje pokus o objemovou injekci. Čtvrtý signál je nejzajímavější: rigorózně identické délky zpráv během deseti po sobě jdoucích požadavků odhalují fuzzer, který mění obsah při zachování konstantní struktury, zatímco skutečný uživatel píše věty nepravidelných délek.

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

Postupné sankce

Okamžitý ban při prvním upozornění by byla nákladná chyba, protože žádný z těchto signálů není neomylný: uživatel, který nervózně obnovuje stránku, spustí detektor záplavy, aniž by byl škodlivý. Postupné banování akumuluje skóre a spouští přiměřené reakce – varování, poté omezení rychlosti, následně hodinový blok a nakonec čtyřiadvacet hodin. Každá úroveň dává legitimnímu uživateli šanci dostat se z nebezpečné trajektorie, zatímco automatizovaný skript ji následuje až do konce.

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

Na pořadí kontrol záleží

Finální sestavení řetězí čtyři mechanismy před voláním modelu a toto pořadí se řídí jednoduchým pravidlem: od nejméně nákladného po nejnákladnější. Kontrola banu je vyhledávání ve slovníku, omezování rychlosti skenuje krátký seznam, detekce zneužití analyzuje historii a kontrola rozpočtu přichází těsně před fakturované volání. Obrácení této sekvence by znamenalo platit za behaviorální analýzu pro uživatele, který je již zabanován. Poslední krok je ten, na který se nejčastěji zapomíná: zaznamenání skutečné spotřeby z pole usage v odpovědi, bez kterého by se váš rozpočet odchýlil od odhadu provedeného před voláním.

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

Klíčové poznatky

  • Omezování rychlosti chrání váš rozpočet na API a předchází automatizovaným útokům
  • Kombinujte limity na počet požadavků (posuvné okno) a limity na náklady (tokeny)
  • Detekce zneužití identifikuje vzorce: spam, záplavu, fuzzing, objem
  • Postupné banování (varování, omezení, blok) se vyhýbá trvalým falešným pozitivům
  • Každá odpověď by měla obsahovat hlavičky s limity rychlosti, aby informovaly uživatele