Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Περιορισμός αιτημάτων και πρόληψη κακόβουλων ενεργειών

Μάθημα 8 / 14 Ενημερώθηκε 28 Ιουλίου 2026 Προχωρημένος
Σε αυτήν τη σελίδα
  1. Γιατί να περιορίζετε τα αιτήματα;
  2. Δύο τρόποι μέτρησης
  3. Αναγνώριση ενός bot
  4. Κλιμακωτές κυρώσεις
  5. Η σειρά των ελέγχων έχει σημασία
  6. Βασικά σημεία

Γιατί να περιορίζετε τα αιτήματα;

Οι εφαρμογές τεχνητής νοημοσύνης αποτελούν πρωταρχικούς στόχους για κακόβουλες ενέργειες για έναν λόγο που δεν υπήρχε στις παραδοσιακές εφαρμογές: κάθε κλήση μοντέλου κοστίζει χρήματα. Ένα παραδοσιακό REST API που δέχεται σε καταιγισμό αιτημάτων επιβραδύνεται και τελικά καταρρέει, αλλά δεν αδειάζει έναν τραπεζικό λογαριασμό. Μια εφαρμογή LLM, ωστόσο, συνεχίζει να αποκρίνεται άψογα ενώ ο λογαριασμός εκτοξεύεται στα ύψη. Χωρίς περιορισμό ρυθμού, ένας επιτιθέμενος μπορεί να καταστρέψει τον προϋπολογισμό του API σας σε λίγα λεπτά, να εξαπολύσει αυτοματοποιημένες επιθέσεις έγχυσης prompt ή να χρησιμοποιήσει την υποδομή σας για τη δημιουργία spam με δικά σας έξοδα.

Δύο τρόποι μέτρησης

Το κυλιόμενο παράθυρο είναι ο θεμελιώδης μηχανισμός. Καταγράφει τη χρονοσφραγίδα κάθε αιτήματος, απορρίπτει εκείνα που έχουν βγει εκτός παραθύρου και συγκρίνει τα υπόλοιπα με το ανώτατο όριο. Η υπεροχή του έναντι του σταθερού παραθύρου οφείλεται σε μια λεπτομέρεια που έχει σημασία στην πράξη: με ένα σταθερό παράθυρο που επαναφέρεται κάθε λεπτό, ένας επιτιθέμενος μπορεί να τοποθετήσει την ποσόσωσή του στο τέλος του ενός λεπτού και ξανά στην αρχή του επόμενου, διπλασιάζοντας ουσιαστικά την επιτρεπόμενη απόδοση μέσα σε λίγα δευτερόλεπτα. Το κυλιόμενο παράθυρο δεν αφήνει κανένα τέτοιο κενό.

Επιπλέον, η συνάρτηση δεν επιστρέφει μια απλή boolean τιμή· επιστρέφει ένα λεξικό που υποδεικνύει τα εναπομείναντα αιτήματα και τον χρόνο μέχρι την επαναφορά. Αυτές οι τιμές συμπληρώνουν τις κεφαλίδες απόκρισης που θα χρησιμοποιήσουν οι νόμιμοι πελάτες σας για να αυτορρυθμιστούν—μια καλά σχεδιασμένη ενσωμάτωση περιμένει αντί να βομβαρδίζει το 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),
}

Ωστόσο, η μέτρηση των αιτημάτων δεν αρκεί, επειδή δεν είναι όλα τα αιτήματα ίσα. Δέκα σύντομες ερωτήσεις κοστίζουν ένα κλάσμα αυτού που κοστίζει ένα μοναδικό αίτημα συνοδευόμενο από ένα έγγραφο πενήντα σελίδων. Ένας περιοριστής ανά αίτημα θα άφηνε να περάσει το δεύτερο και θα απέκλειε το πρώτο, κάτι που είναι ακριβώς το αντίθετο από αυτό που υπαγορεύουν τα οικονομικά της υπηρεσίας. Ένας προϋπολογισμός token αποκαθιστά την αναλογικότητα, με ημερήσια επαναφορά και καταγραφή της πραγματικής χρήσης εκ των υστέρων, καθώς η εκτίμηση που γίνεται πριν την κλήση δεν γνωρίζει το μήκος της απόκρισης.

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

Αναγνώριση ενός bot

Ένας μεθοδικός επιτιθέμενος παραμένει κάτω από τα ανώτατα όριά σας: απλώς χρειάζεται να επιβραδυνθεί. Η ανίχνευση κακόβουλων ενεργειών απαιτεί therefore να εξετάζετε το σχήμα της κίνησης και όχι τον όγκο της. Τα τέσσερα σήματα που υλοποιούνται παρακάτω αλληλοσυμπληρώνονται καλά. Η πανομοιότυπη επανάληψη προδίδει ένα script κολλημένο σε βρόχο. Μια έκρηξη αιτημάτων μέσα σε λίγα δευτερόλεπτα υποδηλώνει ρυθμό που κανένας άνθρωπος δεν μπορεί να διατηρήσει στο πληκτρολόγιο. Ένα μήνυμα δεκάδων χιλιάδων χαρακτήρων σηματοδοτεί μια απόπειρα ογκομετρικής έγχυσης. Το τέταρτο είναι το πιο ενδιαφέρον: αυστηρά πανομοιότυπα μήκη μηνυμάτων σε δέκα διαδοχικά αιτήματα αποκαλύπτουν έναν fuzzer που μεταβάλλει το περιεχόμενο με σταθερή δομή, ενώ ένας πραγματικός χρήστης γράφει προτάσεις ακανόνιστου μήκους.

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

Κλιμακωτές κυρώσεις

Η απαγόρευση με την πρώτη ειδοποίηση θα ήταν ένα δαπανηρό λάθος, επειδή κανένα από αυτά τα σήματα δεν είναι αλάνθαστο: ένας χρήστης που ανανεώνει νευρικά μια σελίδα ενεργοποιεί τον ανιχνευτή έκρηξης χωρίς να είναι κακόβουλος. Η προοδευτική απαγόρευση συσσωρεύει μια βαθμολογία και ενεργοποιεί αναλογικές αποκρίσεις—μια προειδοποίηση, έπειτα περιορισμός ρυθμού, έπειτα προσωρινός αποκλεισμός μίας ώρας και τελικά είκοσι τεσσάρων ωρών. Κάθε επίπεδο δίνει στον νόμιμο χρήστη την ευκαιρία να βγει από αυτή την τροχιά, ενώ το αυτοματοποιημένο script την ακολουθεί μέχρι το τέλος.

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

Η σειρά των ελέγχων έχει σημασία

Η τελική συναρμολόγηση αλυσιδώνει τους τέσσερις μηχανισμούς πριν καλέσει το μοντέλο, και αυτή η σειρά υπακούει σε έναν απλό κανόνα: από το λιγότερο δαπανηρό στο πιο δαπανηρό. Ο έλεγχος απαγόρευσης είναι μια αναζήτηση σε λεξικό, ο περιορισμός ρυθμού σαρώνει μια σύντομη λίστα, η ανίχνευση κακόβουλων ενεργειών αναλύει το ιστορικό και ο έλεγχος προϋπολογισμού έρχεται ακριβώς πριν την χρεώσιμη κλήση. Η αντιστροφή αυτής της ακολουθίας θα σήμαινε πληρωμή για ανάλυση συμπεριφοράς για έναν χρήστη που είναι ήδη αποκλεισμένος. Το τελευταίο βήμα είναι αυτό που ξεχνιέται συχνότερα: η καταγραφή της πραγματικής χρήσης από το πεδίο usage της απόκρισης, χωρίς την οποία ο προϋπολογισμός σας θα απέκλινε από την εκτίμηση που έγινε πριν την κλήση.

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

Βασικά σημεία

  • Ο περιορισμός ρυθμού προστατεύει τον προϋπολογισμό του API σας και αποτρέπει τις αυτοματοποιημένες επιθέσεις
  • Συνδυάστε όρια ανά αίτημα (κυλιόμενο παράθυρο) και όρια ανά κόστος (tokens)
  • Η ανίχνευση κακόβουλων ενεργειών εντοπίζει μοτίβα: spam, flood, fuzzing, όγκος
  • Η προοδευτική απαγόρευση (προειδοποίηση, περιορισμός, αποκλεισμός) αποφεύγει μόνιμα ψευδώς θετικά αποτελέσματα
  • Κάθε απόκριση πρέπει να περιλαμβάνει κεφαλίδες ορίου ρυθμού για την ενημέρωση του χρήστη