Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Piirangud ja kuritarvituste ennetamine

Õppetund 8 / 14 Värskendatud 28. juuli 2026 Edasijõudnutele
Sellel lehel
  1. Miks päringuid piirata?
  2. Kaks loendamise viisi
  3. Boti äratundmine
  4. Astmeline karistamine
  5. Kontrollide järjekord on oluline
  6. Peamised punktid

Miks päringuid piirata?

Tehisintellekti rakendused on kuritarvituste peamised sihtmärgid põhjusel, mida traditsiooniliste rakenduste puhul ei eksisteerinud: iga mudeli väljakutse maksab raha. Traditsiooniline REST API aeglustub päringute tulva korral ja lõpuks kukub kokku, kuid see ei tühjenda pangakontot. LLM-rakendus seevastu vastab jätkuvalt veatult, samal ajal kui arve kasvab taevani. Ilma kiiruse piiramiseta võib ründaja mõne minutiga sinu API eelarve nullida, käivitada automatiseeritud sisendikäskude süstimise rünnakuid või kasutada sinu taristut oma kulul rämpsu genereerimiseks.

Kaks loendamise viisi

Liuguv aken on fundamentaalne mehhanism. See salvestab iga päringu ajatempli, viskab aknast välja langenud päringud välja ja võrdleb ülejäänud osa laega. Selle üleolek fikseeritud aknast taandub praktilisele detailile: fikseeritud akna puhul, mis nullitakse iga minuti tagant, saab ründaja paigutada oma kvoodi ühe minuti lõppu ja järgmise algusesse, kahekordistades sellega tegelikku läbilaskevõimet mõne sekundi jooksul. Liuguv aken sellist võimalust ei jäta.

Lisaks ei tagasta funktsioon lihtsalt tõeväärtust; see tagasta sõnastiku, mis näitab allesjäänud päringute arvu ja aega kuni lähtestamiseni. Need väärtused täidavad vastuse päiseid, mida sinu legaalsed kliendid kasutavad eneseregulatsiooniks – hästi disainitud integratsioon ootab, selle asemel et lõpppunkti pommitada.

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

Pelgalt päringute loendamisest ei piisa, sest kõik päringud ei ole võrdsed. Kümme lühikest küsimust maksavad murdosa sellest, mida maksab üksainus päring, millega kaasneb viiekümneleheküljeline dokument. Päringupõhine piirang laseks viimase läbi ja blokeeriks esimesed, mis on täpselt vastupidine sellele, mida teenuse majanduslik loogika dikteerib. Tokenite eelarve taastab proportsionaalsuse, kasutades päevast lähtestamist ja tegeliku kasutuse registreerimist tagantjärele, kuna enne väljakutset tehtud hinnang ei tea vastuse pikkust.

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

Boti äratundmine

Metoodiline ründaja püsib sinu lagede all: tal tuleb lihtsalt tempot aeglustada. Kuritarvituste tuvastamine nõuab seetõttu liikluse kuju, mitte selle mahu vaatlemist. Allpool rakendatud neli signaali täiendavad üksteist hästi. Identne kordus reedab silmuses kinni jäänud skripti. Päringute plahvatus mõne sekundi jooksul viitab tempole, mida ükski inimene klaviatuuril trükkides säilitada ei suuda. Kümnete tuhandete tähemärkide pikkune sõnum annab märku mahulisest süstimiskatsest. Neljas on kõige huvitavam: rangelt identsed sõnumipikkused kümne järjestikuse päringu vältel paljastavad fuzzeri, mis varieerib sisu konstantse struktuuriga, samas kui reaalne kasutaja kirjutab ebaregulaarse pikkusega lauseid.

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

Astmeline karistamine

Esimese häire peale keelamine oleks kulukas viga, sest ükski neist signaalidest pole eksimatu: lehte närviliselt värskendav kasutaja käivitab plahvatuse detektori, olemata pahatahtlik. Progresseeruv keelamine kogub skoore ja käivitab proportsionaalsed reaktsioonid – hoiatus, seejärel kiiruse vähendamine, siis ajutine ühetunnine blokeering ja lõpuks kakskümmend neli tundi. Iga tase annab legitiimsele kasutajale võimaluse kõrvale kalduda, samas kui automatiseeritud skript järgib seda lõpuni.

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

Kontrollide järjekord on oluline

Lõplik koost aheldab need neli mehhanismi enne mudeli kutsumist ja see järjekord järgib lihtsat reeglit: kõige odavamast kõige kallimani. Keelu oleku kontroll on sõnastiku päring, kiiruse piiramine skaneerib lühikest loendit, kuritarvituste tuvastamine analüüsib ajalugu ja eelarve kontroll toimub vahetult enne tasulist väljakutset. Selle jada ümberpööramine tähendaks käitumisanalüüsi eest maksmist kasutaja puhul, kes on juba keelatud. Viimane samm on see, mida kõige sagedamini unustatakse: tegeliku kasutuse registreerimine vastuse väljalt usage, ilma milleta nihkuks sinu eelarve enne väljakutset tehtud hinnangust.

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

Peamised punktid

  • Kiiruse piiramine kaitseb sinu API eelarvet ja hoiab ära automatiseeritud rünnakud
  • Kombineeri päringupõhiseid piiranguid (liuguv aken) ja kulupõhiseid piiranguid (tokenid)
  • Kuritarvituste tuvastamine identifitseerib mustreid: rämpspost, tulv, fuzzing, maht
  • Astmeline keelamine (hoiata, aeglustada, blokeerida) väldib püsivaid valepositiivseid tulemusi
  • Iga vastus peaks sisaldama kiiruse piirangu päiseid, et kasutajat informeerida