Rate Limiting in PHP umsetzen – Ressourcen schonen

Bots übernehmen deine Webseite oder Services? Spams überfluten Dich?

Es ist Zeit für eine Rate Limit!

Was das ist und wie Du das mit PHP einbauen kannst, zeige ich Dir in diesem Beitrag!

Starten wir!

Was ist ein Rate Limiting?

Das Rate Limiting beschränkt die Zugriffe von einer Person oder Bot auf eine Ressource. Eine Ressource kann eine Webseite, ein Dokument, eine Datenbank, ein Kompressionstool oder ähnliches sein.

Der Betreiber einer Ressource limitiert die Nutzung seiner Ressource auf z. B. 6 Nutzungen am Tag pro Nutzer. Rate Limiting kann auf verschiedene Anwendergruppen angewandt werden: öffentliche oder zahlende Kunden.

Warum brauche ich Rate Limiting?

• Kostenreduktion: Jede Benutzung der Ressource kostet dem Betreiber Geld. Er hat nicht unendlich Geld, um den Bedarf von Laufkundschaft aus dem Internet abzudecken. Das Rate Limiting machen die Kosten planbarer.
• Urheberrecht: Bots kopieren im großen Stil Qualitätsinhalte, während Nutzer z. B. die Texte lesen und genießen. Ein Mensch liest am Tag vielleicht 10 Texte a 1000 Worte und ein Bot kann in 1 Sekunde 1000 Texte verarbeiten und stehlen. Rate Limiting macht Bots das Leben schwerer.
• Unterschied zu Premium: Kostenlose öffentliche Ressourcen sind mit einem Rate Limiting belegt, um den Unterschied zu der Premiumversion darzustellen. Der Betreiber möchte jedem im Internet eine Kostprobe von dem Produkt geben z. B. Informationen aus einer Datenbank. Wer mehr als 6 Aufrufe am Tag tätigen will, der muss das Premiumpaket bezahlen.
• Überlastungsschutz: Der Betreiber nutzt einen Webserver mit z.B. 128 GB Hauptspeicher. Damit möglichst viele Kunden oder Internetnutzer die Ressource verwenden können, soll jeder einen kleinen Teil davon erhalten (10 Megabyte).

• Spamschutz: Kontakt-Formulare im Internet erstellen in der Regel eine Mail an eine (geheime Mail-Adresse), um Spam-Mails von Bots und Trollen zu reduzieren, hilft das Rate Limiting Mails zu reduzieren. Jeder Nutzer hat trotzdem die Chance mit dem Support in den Kontakt zu kommen.

Nachteile für Rate Limiting

• Nervig für echte User: Echte Nutzer, die von einer Ressource profitieren wollen, sind selten das Problem. Bots, die massiv Ressourcen abgreifen, sind die wahren Probleme. Echte Nutzer müssen mit Captchas und Co ihre „Menschlichkeit“ beweisen, was viele Nutzer abschreckt.
• Jedes Rate Limiting ist umgehbar: Die meisten Rate Limiting Mechanismen sind an IPs geknüpft. Im Zeitalter von VPNs und Cloud-Instanzen ist das Annehmen einer neuen IP ein Kinderspiel. Die meisten Rate Limiting Logiken erhöhen nur den Aufwand für die ausnutzenden Bots.

• Mehr Programmlogik: Jede Teilfunktion in der Ressource muss ein Limit erhalten. Damit ein echter Nutzer nicht sofort in Rate Limit läuft, sollten die Grenzen abgestimmt sein. z. B. 4 Bilder pro Webseite bedeutet ein 40-Bilder- und 10-Webseiten-Limit in der Programmierung.

Umsetzung via Funktion

Diese Funktion in PHP erzeugt ein Rate Limiting. Packe die Funktion an den Anfang deines Scripts. Die Funktion speichert die letzten Aufrufe pro IP in dem Ordner RLIMITER mit einem Zeitstempel.

function rate_limiter($key, $limit, $period) {
    // Erstellt den Ordner RLIMITER und hasht den Key
    $filename = 'RLIMITER/' . hash('sha256', $key) . '.txt';

    // Diese Abschnitt bestimmt die IP Adresse, welche an verschiedenen Orten stehen könnte.
    $ip = $_SERVER['REMOTE_ADDR'];
    if (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
        $ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
    }

    // Prüfung ob die IP valide ist Forme einer IPv4 oder IPv6
    if (!filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4 | FILTER_FLAG_IPV6)) {
        die('Error: Invalid IP address');
    }

    $data = array();

    // Ist Dateis chon vorhanden
    if (file_exists($filename)) {
        $data = json_decode(file_get_contents($filename), true);
    }

    // Lese die Zeit und prüfe wie lange zu letzt etwas passiert ist
    $current_time = time();
    if (isset($data[$ip]) && $current_time - $data[$ip]['last_access_time'] >= $period) {
        $data[$ip]['count'] = 0;
    }

    // Prüfe, ob das Limit überschritten wurde und sende 429 Error Code bei einer Überschreitung heraus.
    if (isset($data[$ip]) && $data[$ip]['count'] >= $limit) {
        // Return an error message or redirect to an error page
        http_response_code(429);
        header('Retry-After: ' . $period);
        die('Error: Rate limit exceeded');
    }

    // Erhöhen den Zähler und speichere diesen Ab
    if (!isset($data[$ip])) {
        $data[$ip] = array('count' => 0, 'last_access_time' => 0);
    }
    $data[$ip]['count']++;
    $data[$ip]['last_access_time'] = $current_time;
    file_put_contents($filename, json_encode($data));

    // Was ist der Zeitrahmen? - Berechnung
    return $period - ($current_time - $data[$ip]['last_access_time']);
}

rate_limiter('german', 4, 3600); 

Umsetzung via Laravel

Laravel hat die Idee des Rate Limits in das Standardprojekt eingebaut. Prüfe, ob die Grenzen für Dich Sinn ergeben.

• Was für eine Leistung hat der produktive Server?
• Wie viele Nutzer erwartest Du realistisch?
• Hattest Du schon Erfahrungen, ab welchen Zahlen Dein Server langsam war oder nicht mehr reagiert hat?

In diesem Fall wird die API auf 600 Aufrufe in 1 Minute gedrosselt. Alle anderen Aufrufe erhalten ein 429 HTTP Fehler, der besagt, dass der Nutzer zu viele Anfragen gesendet hat.

Du kannst das Verhältnis ändern: 'throttle:600,1' in der Datei /laravel/app/Http/Kernel.php

    /**
     * The application's route middleware groups.
     *
     * @var array
     */
    protected $middlewareGroups = [
        'web' => [
            \App\Http\Middleware\EncryptCookies::class,
            \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
            \Illuminate\Session\Middleware\StartSession::class,
            // \Illuminate\Session\Middleware\AuthenticateSession::class,
            \Illuminate\View\Middleware\ShareErrorsFromSession::class,
            \App\Http\Middleware\VerifyCsrfToken::class,
            \Illuminate\Routing\Middleware\SubstituteBindings::class,
        ],

        'api' => [
            'throttle:api',
            \Illuminate\Routing\Middleware\SubstituteBindings::class,
        ],
        'auth.api' => [
            \App\Http\Middleware\AddAuthTokenHeader::class,
            'throttle:600,1',
            'auth:api',
            \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
        ],
    ];

Genauso beim Passwort zurücksetzen:

    'passwords' => [
        'users' => [
            'provider' => 'users',
            'table' => 'password_resets',
            'expire' => 60,
            'throttle' => 60,
        ],
    ],

Alternativen zum Rate Limiting

Die einzige sichere Rate Limiting Alternative ist die Verwendung von Accounts. Wer die Ressource nutzen will, muss einen Account anlegen und seine Identität mit einer Telefonnummer oder einem Ausweis beweisen.

E-Mails kann man wie Sand am Meer generieren lassen. Deshalb muss genau geprüft werden, wer sich anmeldet. Jede angemeldete Person erhält dann ein Budget, welches in einer Datenbank gepflegt wird. Bei jeder Verwendung wir der Datenbank-Zähler hochgezählt. Wenn das Budget überschritten ist, muss der Kunde neue Ressourcen-Aufrufe kaufen oder die Ressource bleibt geblockt.