Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Begrænsning af forespørgsler og forebyggelse af misbrug

Lektion 8 af 14 Opdateret 28. juli 2026 Avanceret
På denne side
  1. Hvorfor begrænse forespørgsler?
  2. To måder at tælle på
  3. Genkendelse af en bot
  4. Trinvise sanktioner
  5. Rækkefølgen af tjek betyder noget
  6. Vigtige pointer

Hvorfor begrænse forespørgsler?

AI-applikationer er primære mål for misbrug af en grund, der ikke eksisterede for traditionelle apps: hvert modelkald koster penge. En traditionel REST-API, der udsættes for en flodbølge af forespørgsler, bliver langsom og crascher til sidst, men den tømmer ikke en bankkonto. En LLM-applikation fortsætter derimod med at svare perfekt, mens regningen eksploderer. Uden begrænsning af forespørgsler (rate limiting) kan en angriber ruinere dit API-budget på få minutter, lancere automatiserede prompt injection-angreb eller bruge din infrastruktur til at generere spam på din regning.

To måder at tælle på

Det glidende vindue (sliding window) er den fundamentale mekanisme. Det registrerer tidsstemplet for hver forespørgsel, kasserer dem, der er faldet ud af vinduet, og sammenligner resten med loftet. Dens overlegenhed i forhold til det faste vindue handler om en detalje, der betyder noget i praksis: med et fast vindue, der nulstilles hvert minut, kan en angriber placere sin kvote i slutningen af det ene minut og igen i starten af det næste, hvilket effektivt fordobler den tilladte gennemstrømning over få sekunder. Det glidende vindue efterlader ingen sådan åbning.

Desuden returnerer funktionen ikke en simpel boolean; den returnerer et ordbogsobjekt (dictionary), der angiver de resterende forespørgsler og tiden indtil nulstilling. Disse værdier befolker svar-headers, som dine legitime klienter vil bruge til at selvregulere – en veldesignet integration venter i stedet for at hamre endpointet.

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

At tælle forespørgsler er dog ikke nok, fordi ikke alle forespørgsler er lige. Ti korte spørgsmål koster en brøkdel af, hvad en enkelt forespørgsel ledsaget af et halvtreds sider langt dokument koster. En begrænser pr. forespørgsel ville lukke sidstnævnte igennem og blokere de første, hvilket er præcis det modsatte af, hvad serviceøkonomien dikterer. Et token-budget genopretter proportionaliteten med en daglig nulstilling og registrering af det faktiske forbrug i efterhånd, da estimatet foretaget før kaldet ikke kender længden af svaret.

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

Genkendelse af en bot

En metodisk angriber holder sig under dine lofter: de skal bare sætte farten ned. Opdagelse af misbrug kræver derfor, at man ser på trafikformens facon snarere end dens volumen. De fire signaler, der er implementeret nedenfor, supplerer hinanden godt. Identisk gentagelse afslører et script, der sidder fast i en løkke. En byge af forespørgsler inden for få sekunder indikerer et tempo, som intet menneske kan opretholde ved tastaturet. En besked på titusindvis af tegn signalerer et forsøg på volumetrisk injection. Det fjerde er det mest interessante: strengt identiske beskedlængder over ti på hinanden følgende forespørgsler afslører en fuzzer, der varierer indholdet med konstant struktur, hvorimod en rigtig bruger skriver sætninger med uregelmæssige længder.

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

Trinvise sanktioner

At udelukke ved første alarm ville være en dyr fejl, fordi intet af disse signaler er ufejlbarlige: en bruger, der nervøst genindlæser en side, udløser burst-detektoren uden at være ondsindet. Progressiv udelukkelse akkumulerer en score og udløser proportionale responser – en advarsel, derefter drossling, derefter en midlertidig blokering på en time og til sidst fireogtyve timer. Hvert trin giver den legitime bruger en chance for at komme af sporet, mens det automatiserede script følger det hele vejen.

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

Rækkefølgen af tjek betyder noget

Den endelige samling kæder de fire mekanismer sammen før kaldet til modellen, og denne rækkefølge adlyder en simpel regel: fra mindst til mest ressourcekrævende. Tjekket for udelukkelse er et opslag i en ordbog, begrænsning af forespørgsler scanner en kort liste, detektion af misbrug analyserer historik, og budgetkontrol kommer lige før det fakturerede kald. At vende denne sekvens ville betyde at betale for adfærdsanalyse for en bruger, der allerede er udelukket. Det sidste trin er det, der oftest glemmes: registrering af det faktiske forbrug fra feltet usage i svaret, uden hvilket dit budget ville drive væk fra estimatet foretaget før kaldet.

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

Vigtige pointer

  • Begrænsning af forespørgsler beskytter dit API-budget og forhindrer automatiserede angreb
  • Kombiner grænser pr. forespørgsel (glidende vindue) og grænser pr. omkostning (tokens)
  • Detektion af misbrug identificerer mønstre: spam, flood, fuzzing, volumen
  • Progressiv udelukkelse (advarsel, drossling, blokering) undgår permanente falske positiver
  • Hvert svar bør inkludere headers for begrænsning af forespørgsler for at informere brugeren