Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Ribojimas ir piktnaudžiavimo prevencija

Paskaita 8 iš 14 Atnaujinta 2026 m. liepos 28 d. Pažengusiems
Šiame puslapyje
  1. Kodėl reikia riboti užklausas?
  2. Du skaičiavimo būdai
  3. Boto atpažinimas
  4. Pakopinės sankcijos
  5. Patikrų eiliškumas yra svarbus
  6. Svarbiausi punktai

Kodėl reikia riboti užklausas?

DI programos yra pagrindinės piktnaudžiavimo taikinys dėl priežasties, kurios nebuvo tradicinėse programose: kiekvienas modelio iškvietimas kainuoja pinigus. Tradicinė REST API, užplūsta užklausomis, sulėtėja ir galiausiai stringa, tačiau ji neištuština banko sąskaitos. Tačiau LLM programa toliau puikiai atsako, o sąskaita šauna į viršų. Be ribojimo, puolėjas gali per kelias minutes sugriauti tavo API biudžetą, paleisti automatizuotas promptų injekcijos atakas arba naudoti tavo infrastruktūrą šlamšto generavimui tavo sąskaita.

Du skaičiavimo būdai

Slankusis langas yra pagrindinis mechanizmas. Jis įrašo kiekvienos užklausos laiko žymą, pašalina tas, kurios iškrito iš lango, ir likusias palygina su lubomis. Jo pranašumas prieš fiksuotą langą slypi praktiškai svarbioje detalėje: naudojant fiksuotą langą, kuris atsinaujina kas minutę, puolėjas gali savo kvotą panaudoti vienos minutės pabaigoje ir dar kartą – kitos pradžioje, taip efektyviai padvigubindamas leidžiamą pralaidumą per kelias sekundes. Slankusis langas tokios spragos nepalieka.

Be to, funkcija grąžina ne paprastą boolean reikšmę, o žodyną, nurodantį likusių užklausų skaičių ir laiką iki atsinaujinimo. Šios reikšmės užpildo atsakymo antraštes, kurias tavo teisėti klientai naudos savireguliacijai – gerai suprojektuota integracija palaukia, užuot bombardavusi galinį tašką.

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

Tačiau vien užklausų skaičiavimo nepakanka, nes ne visos užklausos yra vienodos. Dešimt trumpų klausimų kainuoja truputį to, ką kainuoja viena užklausa su penkiasdešimties puslapių dokumentu. Ribotuvas, skaičiuojantis tik užklausas, praleistų pastarąją ir blokuotų pirmąsias, o tai yra priešinga tam, ko reikalauja paslaugų ekonomika. Žetonų biudžetas atkuria proporcingumą, kasdien atsinaujindamas ir fiksuodamas faktinį naudojimą po fakto, nes prieš iškvietimą atliktas įvertis nežino atsakymo ilgio.

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

Boto atpažinimas

Metodiškas puolėjas laikosi tavo lubų: jam tereikia sulėtinti tempą. Todėl piktnaudžiavimo aptikimui reikia žiūrėti ne į srauto apimtį, o į jo formą. Toliau pateikti keturi signalai puikiai papildo vienas kitą. Identiškas pasikartojimas išduoda cikle įstrigusį scenarijų. Užklausų srautas per kelias sekundes rodo tempą, kurio žmogus negali išlaikyti klaviatūroje. Dešimtis tūkstančių simbolių ilgio žinutė signalizuoja apie apimties injekcijos bandymą. Ketvirtasis yra įdomiausias: griežtai identiški žinučių ilgiai per dešimt iš eilės einančių užklausų atskleidžia „fuzzer“, keičiantį turinį esant pastoviai struktūrai, tuo tarpu tikras vartotojas rašo įvairaus ilgio sakinius.

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

Pakopinės sankcijos

Blokavimas po pirmojo įspėjimo būtų brangi klaida, nes nė vienas iš šių signalų nėra neklaidingas: vartotojas, nervingai atnaujinantis puslapį, suaktyvina srauto detektorių, nors ir nėra kenkėjiškas. Progresyvus blokavimas kaupia balus ir suaktyvina proporcingus atsakus – įspėjimą, tada sulėtinimą, tada laikiną vienos valandos bloką ir galiausiai – dvidešimt keturioms valandoms. Kiekviena pakopa suteikia teisėtam vartotojui galimybę nukrypti nuo šio kelio, tuo tarpu automatinis scenarijus juo eina iki galo.

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

Patikrų eiliškumas yra svarbus

Galutinis surinkimas sujungia keturis mechanizmus prieš iškviečiant modelį, ir ši tvarka paklūsta paprastai taisyklei: nuo mažiausiai kainuojančio iki brangiausio. Bloko patikra yra žodyno paieška, ribojimas nuskenuoja trumpą sąrašą, piktnaudžiavimo aptikimas analizuoja istoriją, o biudžeto kontrolė vyksta tik prieš pat apmokamą iškvietimą. Apvertus šią seką, tektų mokėti už elgesio analizę vartotojui, kuris jau yra užblokuotas. Paskutinis žingsnis yra tas, kuris dažniausiai pamirštamas: faktinio naudojimo įrašymas iš atsakymo lauko usage, be kurio tavo biudžetas nukryptų nuo prieš iškvietimą atlikto įverčio.

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

Svarbiausi punktai

  • Ribojimas apsaugo tavo API biudžetą ir neleidžia vykdyti automatizuotų atakų
  • Derink užklausų ribas (slankusis langas) ir išlaidų ribas (žetonai)
  • Piktnaudžiavimo aptikimas nustato šablonus: šlamštą, srautą, „fuzzing“, apimtį
  • Progresyvus blokavimas (įspėti, sulėtinti, blokuoti) išvengia nuolatinių klaidingų teigiamų rezultatų
  • Kiekviename atsakyme turi būti ribojimo antraštės, informuojančios vartotoją