Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Il-limitazzjoni tar-rati u l-prevenzjoni tal-abbuż

Lezzjoni 8 / 14 Aġġornat 28 ta’ Lulju 2026 Avvanzat
F'din il-paġna
  1. Għaliex tillimita t-talbiet?
  2. Żewġ modi kif tgħodd
  3. Kif tagħraf bot
  4. Sanzjonijiet fuq livelli
  5. L-ordni tal-verifiki jimpotta
  6. Punti Ewlenin

Għaliex tillimita t-talbiet?

L-applikazzjonijiet tal-AI huma miri primarji għall-abbuż għal raġuni li ma kinitx teżisti mal-applikazzjonijiet tradizzjonali: kull sejħa tal-mudell tiswi flus. API REST tradizzjonali soġġetta għal għargħar ta’ talbiet tibbies u eventwalment taqa’, iżda ma tnixxixx kont bankarju. Applikazzjoni LLM, madankollu, tkompli tweġib perfettament filwaqt li l-kont jitla’ għas-sema. Mingħajr limitazzjoni tar-rata, attakkant jista’ jħassar il-baġit tal-API tiegħek f’ftit minuti, iniedi attakki awtomatizzati ta’ injezzjoni tal-prompt, jew juża l-infrastruttura tiegħek biex jiġġenera spam fuq in-nefqa tiegħek.

Żewġ modi kif tgħodd

It-tieqa li tiżżerżaq (sliding window) hija l-mekkaniżmu fundamentali. Tirreġistra t-timestamp ta’ kull talba, tarmi dawk li waqgħu barra mit-tieqa, u tqabbel il-bqija mal-limitu massimu. Is-superjorità tagħha fuq it-tieqa fissa tinżel għal dettall li jimpotta fil-prattika: b’tieqa fissa li tirrisettja kull minuta, attakkant jista’ jpoġġi l-kwota tiegħu fi tmiem minuta u mill-ġdid fil-bidu tal-oħra, u b’hekk jirdoppja effettivament il-produzzjoni permessa fuq ftit sekondi. It-tieqa li tiżżerżaq ma tħalli l-ebda ftuħ bħal dan.

Barra minn hekk, il-funzjoni ma tirritornax sempliċiment boolean; tirritorna dizzjunarju li jindika t-talbiet li fadal u l-ħin sal-irrisettjar. Dawn il-valuri jpopolaw l-intestaturi tar-risposta li l-klijenti leġittimi tiegħek se jużaw biex jirregolaw lilhom infushom—integrazzjoni mfassla tajjeb tistenna minflok ma tħabbat l-endpoint.

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

Madankollu, li tgħodd it-talbiet mhux biżżejjed, għax mhux it-talbiet kollha huma ugwali. Għaxar mistoqsijiet qosra jiswew frazzjoni ta’ dak li jiswa talba waħda akkumpanjata minn dokument ta’ ħamsin paġna. Limitatur għal kull talba jħalli dan tal-aħħar jgħaddi u jimblokka l-ewwel, li huwa eżattament l-oppost ta’ dak li jiddettaw l-ekonomiji tas-servizz. Baġit ta’ token jirrestawra l-proporzjonalità, b’risettjar kuljum u rreġistrar tal-użu attwali wara l-fatt, peress li l-istima magħmula qabel is-sejħa ma tkunx taf it-tul tar-risposta.

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

Kif tagħraf bot

Attakkant metodużu jibqa’ taħt is-soqfa tiegħek: sempliċiment irid jibbies. Għalhekk, is-sejbien tal-abbuż jeħtieġ li tħares lejn il-forma tat-traffiku minflok il-volum tiegħu. L-erba’ sinjali implimentati hawn taħt jissupplimentaw lil xulxin sew. Ir-ripetizzjoni identika tiżvela skript imwaħħal f’loop. Mewġa ta’ talbiet fi ftit sekondi tindika ritmu li l-ebda bniedem ma jista’ jżomm fuq it-tastiera. Messaġġ twil għaxriet eluf ta’ karattri jissinjala tentattiv ta’ injezzjoni volumetrika. Ir-raba’ wieħed huwa l-aktar interessanti: tul ta’ messaġġi rigorużament identiku fuq għaxar talbiet konsekuttivi jiżvela fuzzer li jbiddel il-kontenut b’struttura kostanti, filwaqt li utent reali jikteb sentenzi b’tulijiet irregolari.

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

Sanzjonijiet fuq livelli

Il-projbizzjoni fl-ewwel allarm tkun żball kostjuż, għax l-ebda wieħed minn dawn is-sinjali mhu infallibbli: utent nervuż li jkun qed iġedded paġna jattiva d-ditekter tal-mewġa mingħajr ma jkun malizzjuż. Il-projbizzjoni progressiva takkumula punteġġ u ttriggera risposti proporzjonali—twissija, imbagħad throttling, imbagħad blokk temporanju ta’ siegħa, u finalment erbgħa u għoxrin siegħa. Kull livell jagħti lill-utent leġittimu ċ-ans li joħroġ mit-traġettorja, filwaqt li l-iskript awtomatizzat isegwiha sal-aħħar.

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

L-ordni tal-verifiki jimpotta

L-assemblaġġ finali jgħaqqad l-erba’ mekkaniżmi qabel ma jsejjaħ il-mudell, u dan l-ordni jobdi regola sempliċi: mill-inqas għali għall-aktar għali. Il-verifika tal-projbizzjoni hija tfittxija f’dizzjunarju, il-limitazzjoni tar-rata tiskannja lista qasira, id-detezzjoni tal-abbuż tanalizza l-istorja, u l-kontroll tal-baġit jiġi eżatt qabel is-sejħa bil-ħlas. Li taqleb din is-sekwenza tfisser li tħallas għall-analiżi komportamentali għal utent li diġà huwa pprojbit. L-aħħar pass huwa dak li l-aktar jintesa: ir-reġistrar tal-użu attwali mill-qasam usage tar-risposta, li mingħajru l-baġit tiegħek iddevja mill-istima magħmula qabel is-sejħa.

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

Punti Ewlenin

  • Il-limitazzjoni tar-rati tipproteġi l-baġit tal-API tiegħek u tipprevjeni attakki awtomatizzati
  • Għaqqad limiti għal kull talba (tieqa li tiżżerżaq) u limiti għal kull spiża (tokens)
  • Id-detezzjoni tal-abbuż tidentifika mudelli: spam, flood, fuzzing, volum
  • Il-projbizzjoni progressiva (wissi, ibbies, imblokka) tevita pożittivi foloz permanenti
  • Kull risposta għandha tinkludi intestaturi ta’ limitu tar-rata biex tinforma lill-utent