Einleitung

Diese Anleitung widmet sich einer kleinen, aber sehr tückischen Problemgruppe: Eine Anfrage kommt nicht durch oder nur teilweise, weil ihre Header oder Cookies zu groß geworden sind. Äußerlich zeigt sich das als Fehler 431 Request Header Fields Too Large, als nginx-spezifischer Code 494 Request Header Too Large, als unklare Meldung 400 Request Header Or Cookie Too Large – oder im schlimmsten Fall gar nicht: Ein Zwischenknoten verwirft stillschweigend einen Teil der Header, und die Anwendung erhält einen Benutzer ohne Session, ohne Authentifizierungstoken oder ohne die nötigen Cookies.

Wichtig ist, sich sofort vom Nachbarthema abzugrenzen. In einem separaten Artikel haben wir die Codes 407, 502 und 504 behandelt, die der Proxy-Layer selbst ausgibt, wenn der Tunnel aufgebaut wird: Authentifizierung am Proxy fehlgeschlagen, Upstream nicht gestartet, Timeout abgelaufen. Dort liegt das Problem in der Verbindung und im Proxy selbst. Hier wird die Verbindung normal aufgebaut, der Tunnel steht, aber die Daten, die Sie hindurch senden wollen, passen nicht in die Puffer eines Knotens der Kette. Die Ursache liegt immer in Umfang und Zusammensetzung der Header, und sie wird mit ganz anderen Werkzeugen behoben.

Was Sie am Ende erreicht haben

  • Die Fähigkeit, in wenigen Minuten die Größe der Header und Cookies einer konkreten Anfrage genau zu messen.
  • Verständnis dafür, welcher Knoten der Kette (Browser oder Client, Proxy, Load Balancer, Webserver, Anwendung) die Daten ablehnt oder abschneidet.
  • Einen fertigen Echo-Endpunkt zur Erkennung von stillem Abschneiden ohne einen einzigen Fehlercode.
  • Funktionierende Limit-Konfigurationen für nginx, Apache, Node.js, HAProxy, Tomcat und Gunicorn mit Erklärung jedes Parameters.
  • Eine Strategie zur Reduzierung von Cookies, damit das Problem nicht in einem Monat wieder auftritt.
  • Monitoring, das rechtzeitig signalisiert, wenn Sie sich einem Limit nähern.

Für wen dieser Leitfaden gedacht ist

Für Webentwickler, Systemadministratoren, Spezialisten für Parsing und Automatisierung sowie für alle, die mit vielen Accounts über Proxys arbeiten und regelmäßig auf unerklärliche Ablehnungen stoßen. Der Schwierigkeitsgrad ist mittel: Sie müssen kein HTTP-Protokoll-Experte sein, aber grundlegende Terminal-Kenntnisse und ein Verständnis davon, was eine Konfigurationsdatei ist, sind erforderlich.

Was Sie vorher wissen sollten

  • Wie man ein Terminal öffnet und einen Befehl ausführt.
  • Wie man die Entwicklertools im Browser öffnet (Taste F12).
  • Wo die Konfigurationsdateien Ihres Webservers liegen, falls Sie ihn administrieren.
  • Eine allgemeine Vorstellung davon, dass eine Anfrage vom Client über Zwischenknoten zum Server geht.

Wie viel Zeit Sie benötigen

Die Diagnose in den Schritten 1–4 dauert 30 bis 60 Minuten. Die Korrektur auf Serverseite (Schritte 5–7) nimmt weitere 1–2 Stunden in Anspruch, inklusive Neustarts und Prüfungen. Wenn Sie nur einen fremden Dienst prüfen und keinen Zugriff auf seine Einstellungen haben, reichen Ihnen die ersten vier Schritte und der Abschnitt zur Cookie-Reduzierung.

Vorbereitung

Es ist nichts Exotisches nötig, aber bereiten Sie die Werkzeuge im Voraus vor, damit Sie sich nicht mitten im Prozess ablenken lassen.

Benötigte Werkzeuge

  • curl in Version 7.70 oder neuer. Es ist in macOS, allen Linux-Distributionen und Windows 10 und 11 vorinstalliert. Prüfen Sie mit curl --version.
  • Browser mit Entwicklertools: Chrome, Edge, Firefox oder Yandex Browser. Sie benötigen den Tab Network (Netzwerk) und den Tab Application bzw. Storage zum Anzeigen der Cookies.
  • Texteditor mit Syntaxhervorhebung: VS Code, Notepad++ oder das eingebaute nano auf dem Server.
  • SSH-Zugang zum Server, falls Sie Limits ändern. Leseberechtigung für Logs und die Berechtigung zum Neustart von Diensten sind Pflicht.
  • Python 3 oder Node.js zum Starten des Echo-Endpunkts. Jede aktuelle Version genügt.
  • Optional: mitmproxy oder der eingebaute Analyzer im Antidetekt-Browser, wenn Sie den Traffic zwischen Client und Proxy sehen möchten.

Systemanforderungen

Jeder Arbeitsrechner. Für den Echo-Server reichen 100 MB Arbeitsspeicher. Die einzige echte Anforderung: Netzwerkzugriff auf den zu prüfenden Dienst und bei Bedarf auf den verwendeten Proxy.

Was Sie herunterladen und einrichten sollten

  1. Stellen Sie sicher, dass curl funktioniert: Führen Sie curl -sI https://example.com aus. Sie sollten Antwort-Header-Zeilen sehen, beginnend mit HTTP/2 200 oder ähnlich.
  2. Wenn Sie über einen Proxy arbeiten, halten Sie Adresse, Port, Login und Passwort bereit. Prüfen Sie die Basisverbindung mit curl -x http://логин:пароль@host:port -sI https://example.com. Wenn hier ein Fehler 407 auftritt oder die Verbindung gar nicht zustande kommt, kehren Sie zum Artikel über Proxy-Layer-Codes zurück: Unser Thema beginnt erst nach einem erfolgreichen Tunnel.
  3. Finden Sie auf dem Server die Hauptkonfiguration: für nginx normalerweise /etc/nginx/nginx.conf und den Ordner /etc/nginx/conf.d/, für Apache /etc/apache2/apache2.conf oder /etc/httpd/conf/httpd.conf.
  4. Finden Sie die Logs: /var/log/nginx/error.log, /var/log/nginx/access.log, /var/log/apache2/error.log. Stellen Sie sicher, dass Sie sie mit tail -n 50 lesen können.

Backups

Erstellen Sie vor jeder Änderung an Konfigurationen eine Kopie. Das dauert Sekunden und spart Stunden.

  1. Führen Sie sudo cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak-2026 aus.
  2. Für den Website-Ordner: sudo cp -r /etc/nginx/conf.d /etc/nginx/conf.d.bak-2026.
  3. Für Apache analog: sudo cp /etc/apache2/apache2.conf /etc/apache2/apache2.conf.bak-2026.
  4. Notieren Sie die aktuellen Limit-Werte in einer separaten Notizdatei, damit Sie wissen, wo Sie gestartet sind.

Achtung: Bearbeiten Sie niemals eine Produktivkonfiguration ohne vorherige Syntaxprüfung. Für nginx ist das sudo nginx -t, für Apache sudo apachectl configtest. Ein Fehler in einer Zeile beim Neustart legt den Dienst lahm.

Grundbegriffe

Bevor wir das Problem angehen, einigen wir uns auf die Terminologie. Es ist nichts Kompliziertes dabei, aber Verwechslungen führen die Diagnose oft in die falsche Richtung.

Was sind Request-Header

Jede HTTP-Anfrage besteht aus einer Startzeile (Methode, Pfad, Protokollversion), einem Header-Block und einem optionalen Body. Header sind Paare der Form Name: Wert. Der Browser fügt sie automatisch hinzu: Host, User-Agent, Accept, Accept-Language, Referer, Authorization und natürlich Cookie. Anwendungen fügen eigene hinzu: Tokens, Trace-IDs, Experiment-Merkmale.

Warum Cookies der häufigste Übeltäter sind

Der Header Cookie setzt sich aus allen Cookies zusammen, die zur Domain und zum Pfad der Anfrage passen. Jedes Analyse-System, jedes Chat-Widget, jedes Werbenetzwerk fügt ein paar hinzu. Der Wert eines Cookies kann bis zu 4 KB groß sein, und solche Cookies gibt es Dutzende pro Domain. Dabei sendet der Browser sie mit allen Anfragen, einschließlich Bildern und Schriftarten. Infolgedessen überschreitet der Header Cookie leicht 8–16 KB – genau die Schwellenwerte, die bei den meisten Servern standardmäßig eingestellt sind.

Code 431

431 Request Header Fields Too Large ist ein Standardcode aus der HTTP-Spezifikation. Der Server teilt mit: Die Header sind zu groß, entweder einer davon oder alle zusammen. Der Code wird von Node.js, Go, Envoy, einigen CDNs und modernen Frameworks zurückgegeben. Eine 431-Antwort ist protokollkonform und in den Logs gut sichtbar, daher ist dies die diagnostisch bequemste Variante.

Code 494

494 Request Header Too Large ist ein interner, nicht standardisierter nginx-Code. nginx verwendet ihn im eigenen Code, wenn ein Header nicht in die Puffer passt, die durch die Direktive large_client_header_buffers festgelegt sind. Standardmäßig wird dem Client jedoch 400 mit dem Body Request Header Or Cookie Too Large gesendet. Die Ziffer 494 sehen Sie nur in zwei Fällen: Wenn der Administrator explizit error_page 494 konfiguriert hat oder wenn Sie interne nginx-Variablen und Logs lesen. Wenn ein Benutzer also über eine weiße Seite mit der Aufschrift 400 und Worten über Cookies klagt, wissen Sie: Das ist derselbe 494.

Stilles Abschneiden

Das unangenehmste Szenario. Ein Zwischenknoten lehnt die Anfrage nicht ab, sondern schneidet den Header auf die Größe seines Puffers zu oder verwirft einen Teil der Header komplett. Die Anwendung erhält unvollständige Daten. Die Symptome sind vielfältig: Der Benutzer wird plötzlich ausgeloggt, der Warenkorb geht verloren, das Token wird nicht gelesen, der Header mit der Regions-ID verschwindet. Es gibt keinen Fehlercode, in den Webserver-Logs ist alles grün. Solches Verhalten tritt bei selbstgebauten Proxys mit festen Puffern auf, bei alten Unternehmens-Gateways, bei einigen WAFs im Soft-Modus, bei Client-Bibliotheken, die lange Werte aufteilen oder kürzen, sowie im Browser selbst, der stillschweigend Set-Cookie länger als 4096 Bytes ignoriert.

Wo überall Limits stehen

Stellen Sie sich die Kette vor: Browser oder Skript, dann Ihr ausgehender Proxy (z. B. mobile), dann CDN oder WAF, dann Load Balancer, dann Webserver, dann Anwendungsserver. Jedes Glied hat sein eigenes Limit und sein eigenes Verhalten bei Überschreitung. Die Aufgabe der Diagnose ist es, die engste Stelle zu finden. Deshalb reicht es oft nicht, einfach das Limit in nginx zu erhöhen: Dahinter steht Node.js mit seiner eigenen Schwelle von 16 KB.

Abgrenzung zum Fehler 502 upstream sent too big header

Ein Sonderfall an der Schnittstelle zweier Themen. Wenn nginx im error.log die Phrase upstream sent too big header while reading response header from upstream schreibt und 502 zurückgibt, liegt das nicht am Tunnel und nicht am Absturz des Upstreams, sondern an den Antwort-Headern der Anwendung, die nicht in proxy_buffer_size gepasst haben. Formal ist das ein 502, aber es wird mit Pufferparametern behoben, über die wir hier sprechen. Merken Sie sich diesen Marker: Er hilft, das Problem nicht im Proxy-Layer zu suchen.

Schritt 1: Problem reproduzieren und Symptome festhalten

Ziel dieser Phase: ein stabiles Szenario erhalten, in dem der Fehler auftritt, und die genauen Anzeichen notieren: Code, Antworttext, Server-Header und Uhrzeit.

  1. Öffnen Sie die problematische Seite im Browser. Drücken Sie F12, wechseln Sie zum Tab Network (Netzwerk).
  2. Aktivieren Sie das Kontrollkästchen Preserve log (Protokoll beibehalten), damit Einträge bei Navigationen nicht verschwinden.
  3. Laden Sie die Seite mit F5 neu. Finden Sie die rot markierte Anfrage oder die Anfrage mit Status 400, 431 oder 494. Klicken Sie darauf.
  4. Notieren Sie im Tab Headers: den Statuscode, den Wert des Headers Server in der Antwort (nginx, cloudflare, AkamaiGHost, gunicorn), den Wert von Via, falls vorhanden, und alle Header mit Präfix X- oder CF-.
  5. Wechseln Sie zum Tab Response und kopieren Sie den Antworttext. Die Phrase Request Header Or Cookie Too Large weist auf nginx hin. Die Phrase Request Header Fields Too Large ohne das Wort Cookie ist typisch für Node.js. Die Phrase Bad Request - Request Too Long ist charakteristisch für IIS.
  6. Scrollen Sie zum Block Request Headers. Schätzen Sie die Länge der Zeile Cookie ab: Wenn sie mehrere Bildschirme einnimmt, ist das bereits ein Hinweis.
  7. Öffnen Sie ein Inkognito-Fenster und wiederholen Sie die Anfrage. Wenn im sauberen Profil kein Fehler auftritt, sind die angesammelten Cookies des konkreten Benutzers schuld.

Wenn das Problem in einem Skript statt im Browser auftritt, notieren Sie dieselben Daten aus der Antwort der Bibliothek: Status, Body, Header. In Python requests sind das response.status_code, response.text und response.headers.

Tipp: Exportieren Sie alle Anfragen in eine HAR-Datei per Rechtsklick auf die Anfrageliste und den Punkt Save all as HAR with content. Diese Datei können Sie später öffnen oder an einen Kollegen weitergeben, und sie enthält die genauen Header-Größen.

Prüfung: Sie sollten eine Notiz mit vier Punkten haben: Statuscode, Antworttext, Wert des Server-Headers und Ergebnis des Inkognito-Tests. Wenn das Ergebnis im Inkognito abweicht, kennen Sie die Ursache bereits zu 70 Prozent.

Mögliche Probleme

  • Der Fehler tritt nicht immer auf. Dann schwankt die Cookie-Größe um die Schwelle: Nach dem Besuch eines bestimmten Bereichs kommt z. B. ein weiteres Cookie hinzu. Notieren Sie, nach welchen Aktionen der Fehler erscheint.
  • Keine rote Anfrage, aber die Seite funktioniert nicht richtig. Das ist ein Anzeichen für stilles Abschneiden. Gehen Sie direkt nach der Messung zu Schritt 4.

Schritt 2: Die tatsächliche Größe von Headern und Cookies messen

Ziel dieser Phase: exakte Zahlen in Bytes erhalten: Gesamtgröße des Header-Blocks, Größe des Headers Cookie, Größe jedes einzelnen Cookies.

Messung im Browser

  1. Öffnen Sie in den Entwicklertools den Tab Console (Konsole).
  2. Geben Sie document.cookie.length ein und drücken Sie Enter. Sie sehen eine Zahl: die Länge in Zeichen aller für Skripte zugänglichen Cookies, ohne das Flag HttpOnly. Der echte Header wird größer sein, weil HttpOnly-Cookies hier nicht enthalten sind.
  3. Geben Sie document.cookie.split('; ').map(c => [c.split('=')[0], c.length]).sort((a, b) => b[1] - a[1]) ein. Die Konsole zeigt ein Array von Name-Länge-Paaren, absteigend sortiert. Die schwersten Cookies stehen oben.
  4. Wechseln Sie zum Tab Application (in Firefox Storage), klappen Sie Cookies auf und wählen Sie die Domain. Hier sehen Sie alle Cookies, einschließlich HttpOnly, mit einer Spalte Size. Klicken Sie auf den Spaltenkopf, um nach Größe zu sortieren.
  5. Addieren Sie die Größen oder schauen Sie einfach auf die Zeile Cookie in der Anfrage aus Schritt 1: In Chrome wird beim Überfahren des Headers seine Länge angezeigt.

Messung mit curl

Curl erlaubt es, Header beliebiger Größe zu senden und genau zu ermitteln, ab welchem Umfang der Server ablehnt. Erzeugen wir ein Cookie kontrollierter Länge.

  1. Erstellen Sie eine Zeichenkette aus 8000 Zeichen. In Linux und macOS: BIG=$(head -c 8000 /dev/zero | tr '\0' 'a'). Wenn die Shell wegen Escaping meckert, verwenden Sie die Variante BIG=$(python3 -c "print('a'*8000)").
  2. Senden Sie die Anfrage: curl -s -o /dev/null -w '%{http_code}' -H "Cookie: test=$BIG" https://ваш-сайт.ru/. Auf dem Bildschirm erscheint nur der Antwortcode.
  3. Variieren Sie die Größe: 4000, 8000, 12000, 16000, 32000, 64000. Notieren Sie, bei welchem Wert der Code von 200 auf 400 oder 431 wechselt.
  4. Wenn Sie über einen Proxy arbeiten, fügen Sie -x http://логин:пароль@host:port hinzu und wiederholen Sie die Serie. Der Unterschied zwischen den Schwellen mit und ohne Proxy zeigt, ob es ein Limit am Proxy selbst gibt.

Beispiel einer binären Suche nach der Schwelle in einem Befehl für bash:

for n in 4000 8000 12000 16000 24000 32000 64000; do BIG=$(python3 -c "print('a'*$n)"); echo -n "$n: "; curl -s -o /dev/null -w '%{http_code}' -H "Cookie: t=$BIG" https://ваш-сайт.ru/; echo; done

In Windows PowerShell das Analogon: $big = 'a' * 16000; curl.exe -s -o NUL -w '%{http_code}' -H "Cookie: t=$big" https://ваш-сайт.ru/.

Interpretation der Zahlen

  • Schwelle um 8 KB: typisch für Apache mit Standardeinstellungen, Tomcat, Gunicorn sowie für nginx, wenn ein Header nicht in einen der vier 8-KB-Puffer passt.
  • Schwelle um 16 KB: Node.js ab Version 13, HAProxy mit Standard-tune.bufsize, IIS.
  • Schwelle um 32 KB: Gesamtlimit einiger CDNs. Ein einzelner Header ist dort oft auf 16 KB begrenzt.
  • Schwelle um 60–64 KB: Envoy und einige Cloud-Load-Balancer.
  • Schwelle um 1 MB: Standard-Go-Server.

Tipp: Messen Sie nicht nur Cookie. Wiederholen Sie die Serie mit dem Header Authorization: Bearer $BIG und mit mehreren kleineren Headern. Manche Server begrenzen separat die Größe eines Feldes, separat deren Anzahl und separat das Gesamtvolumen. nginx z. B. lässt standardmäßig keinen einzelnen Header größer als 8 KB durch, selbst bei kleiner Gesamtgröße, weil jede Zeile in einen separaten Puffer passen muss.

Prüfung: In Ihren Notizen sollte eine Zahl stehen, ab der der Server ablehnt, und eine Liste der drei bis fünf schwersten Cookies mit ihren Größen. Wenn bis 64 KB keine Schwelle gefunden wurde, aber im Browser ein Fehler auftritt, lehnt nicht der Server ab, sondern etwas zwischen Browser und Server in Ihrer konkreten Umgebung. Gehen Sie zum nächsten Schritt.

Schritt 3: Bestimmen, welche Schicht ablehnt

Ziel dieser Phase: den Knoten der Kette genau benennen, der den Fehler zurückgibt oder Daten abschneidet, um genau dort die Einstellungen zu ändern.

Die Signatur der Antwort lesen

  1. Führen Sie curl -sv -H "Cookie: t=$BIG" https://ваш-сайт.ru/ 2>&1 | grep -i -E 'server|via|cf-|x-served|x-cache|HTTP/' aus, wobei BIG die Schwelle sicher überschreitet.
  2. Lesen Sie den Header Server. Der Wert nginx mit dem Body Request Header Or Cookie Too Large bedeutet, dass nginx abgelehnt hat. Der Wert cloudflare bedeutet, dass die Anfrage Ihren Server nicht erreicht hat. Ein leerer Server und ein JSON-Body deuten oft auf die Anwendung hin.
  3. Achten Sie auf die Protokollversion in der ersten Zeile. Wenn der Server bei normalen Anfragen über HTTP/2 antwortet, der Fehler aber über HTTP/1.1 kommt, ist das ein Anzeichen, dass die Antwort von einem Zwischenknoten und nicht vom Endknoten erzeugt wurde.
  4. Vergleichen Sie die Fehler-Bodies: Die nginx-Seite ist knapp und enthält unten seinen Namen; die Cloudflare-Seite enthält eine Ray ID; Node.js gibt oft einen leeren Body mit Status 431 zurück.

Schichten umgehen

  1. Wenn Sie die direkte IP-Adresse des Servers hinter dem CDN haben, wiederholen Sie die Anfrage mit dem Schlüssel --resolve ваш-сайт.ru:443:1.2.3.4. Das zwingt curl zu einer direkten Verbindung unter Beibehaltung des korrekten Host und SNI. Wenn die Anfrage direkt durchgeht, aber über das CDN nicht, liegt das Limit am CDN.
  2. Wenn Sie Zugriff auf den Server haben, führen Sie die Anfrage lokal aus: curl -s -o /dev/null -w '%{http_code}' -H "Cookie: t=$BIG" -H 'Host: ваш-сайт.ru' http://127.0.0.1:80/. So schließen Sie alle externen Knoten aus.
  3. Dann klopfen Sie direkt an die Anwendung, unter Umgehung von nginx: curl ... http://127.0.0.1:3000/ für Node.js oder den Port, auf dem Gunicorn lauscht. Wenn nginx durchlässt, die Anwendung aber 431 antwortet, liegt das Limit in der Anwendung.
  4. Prüfen Sie den Einfluss Ihres ausgehenden Proxys: eine Serie von Anfragen mit -x, eine ohne. Für HTTPS-Anfragen über einen Proxy wird die Methode CONNECT verwendet, und der Proxy sieht die Header innerhalb des verschlüsselten Tunnels nicht, kann also deren Größe nicht beeinflussen. Bei gewöhnlichen HTTP-Anfragen jedoch analysiert der Proxy die Header selbst, und hier ist ein eigenes Limit und sogar Abschneiden möglich.

Logs auf dem Server lesen

  1. Führen Sie sudo tail -f /var/log/nginx/error.log aus und wiederholen Sie die problematische Anfrage.
  2. Die Zeile client sent too long header line bestätigt, dass eine einzelne Header-Zeile den nginx-Puffer überschritten hat. Die Zeile client sent too large request deutet auf eine Überschreitung des Gesamtvolumens hin.
  3. Für Apache suchen Sie im error.log nach Request header exceeds LimitRequestFieldSize oder Size of a request header field exceeds server limit.
  4. Für Node.js in den Anwendungslogs: der Fehler HPE_HEADER_OVERFLOW, ein interner Parser-Code, der nach außen zu 431 wird.
  5. Im access.log von nginx sehen Sie das Feld mit der Anfragegröße. Wenn Sie das Standardformat verwenden, fügen Sie in log_format die Variable $request_length hinzu: Sie zeigt die vollständige Anfragegröße einschließlich Header und ist für das Monitoring nützlich.

Achtung: Wenn Sie im error.log von nginx upstream sent too big header sehen, lehnt nicht die eingehende Anfrage ab, sondern die Antwort Ihrer Anwendung, deren Header nicht in den nginx-Puffer passen. Dieser Fall sieht wie ein 502 aus, gehört aber zu unserem Thema. Die Ursache ist meist ein gigantisches Set-Cookie oder Dutzende Header vom Framework. Die Lösung steht in Schritt 6.

Prüfung: Sie sollten sicher eines der Folgenden sagen können: das CDN lehnt ab; nginx lehnt ab; Apache lehnt ab; die Anwendung lehnt ab; der Proxy auf meiner Seite lehnt ab. Wenn das Bild uneindeutig ist, wurde das Limit an mehreren Knoten gleichzeitig überschritten, und Sie müssen sie nacheinander alle anpassen und jedes Mal den Test aus Schritt 2 wiederholen.

Schritt 4: Stilles Abschneiden mit einem Echo-Endpunkt aufdecken

Ziel dieser Phase: sicherstellen, dass die Header die Anwendung genau in der Form erreichen, in der sie gesendet wurden, und den Knoten erwischen, der sie stillschweigend verändert.

Die Idee ist einfach. Wir starten einen kleinen Server, der in der Antwort alle empfangenen Header und deren Größen zurückgibt. Wir senden einen Header bekannter Länge mit Prüfsumme und vergleichen, was angekommen ist.

Echo-Server in Python starten

  1. Erstellen Sie die Datei echo.py mit folgendem Inhalt:
import hashlib, json
from http.server import BaseHTTPRequestHandler, HTTPServer

class H(BaseHTTPRequestHandler):
def do_GET(self):
out = {}
total = 0
for k, v in self.headers.items():
total += len(k) + len(v) + 4
out[k] = {"len": len(v), "sha": hashlib.sha256(v.encode()).hexdigest()[:12]}
out["_total"] = total
out["_count"] = len(self.headers)
body = json.dumps(out, indent=1).encode()
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)

HTTPServer(("0.0.0.0", 8089), H).serve_forever()
  1. Starten Sie: python3 echo.py. Der Server lauscht auf Port 8089.
  2. Platzieren Sie ihn dort, wo Ihre eigentliche Anwendung läuft, oder leiten Sie vorübergehend einen location in nginx darauf um: location /__echo { proxy_pass http://127.0.0.1:8089; }. Dann durchläuft die Anfrage die gesamte reale Kette.

Beachten Sie, dass der Standard-HTTPServer von Python kein hartes Limit für die Header-Länge hat, aber die Anzahl auf hundert begrenzt. Für den Test reicht das.

Kontrollanfrage senden

  1. Erzeugen Sie einen Wert aus 12000 Zeichen, aber nicht homogen, sondern mit Positionsmarkern, damit Sie sehen, wo abgeschnitten wurde: V=$(python3 -c "print(''.join(str(i%10) for i in range(12000)))").
  2. Berechnen Sie den Referenz-Hash: python3 -c "import hashlib,sys; print(hashlib.sha256(sys.argv[1].encode()).hexdigest()[:12])" "$V".
  3. Senden Sie durch die gesamte Kette: curl -s -H "Cookie: probe=$V" -H "X-Probe-Len: 12000" https://ваш-сайт.ru/__echo.
  4. Vergleichen Sie in der Antwort das Feld len für Cookie mit der Zahl 12006 (Name probe plus Gleichheitszeichen plus 12000 Zeichen) und den Hash mit der Referenz.
  5. Wiederholen Sie mit mehreren Headern: Fügen Sie 30 Header X-Test-1 ... X-Test-30 hinzu und prüfen Sie das Feld _count.

Das Ergebnis lesen

  • Länge stimmt, Hash stimmt: Auf diesem Pfad gibt es kein Abschneiden.
  • Länge kürzer, Header abgeschnitten: Jemand hat das Ende abgeschnitten. Schauen Sie auf das letzte Zeichen des angekommenen Werts: Es verrät die Position des Schnitts, oft eine glatte Grenze von 4096 oder 8192 Bytes.
  • Header fehlt komplett: Der Knoten hat das Feld verworfen, weil es nicht in den Puffer passte. So verhalten sich einige WAFs und alte Gateways.
  • _count kleiner als gesendet: Das Limit für die Anzahl der Header ist erreicht. Apache und Gunicorn akzeptieren standardmäßig 100 Felder, HAProxy 101, und einige Implementierungen verwerfen überzählige stillschweigend.
  • Länge stimmt, Hash stimmt nicht: Der Knoten hat den Inhalt verändert. Das passiert bei Normalisierung von Leerzeichen oder Umkodierung; prüfen Sie, ob im Wert Zeichen sind, die der Proxy als unzulässig ansieht.

Tipp: Wenn Sie über einen mobilen oder anderen externen Proxy arbeiten, stellen Sie den Echo-Server auf einem öffentlich erreichbaren Host auf und führen Sie die Anfragen über den Proxy in gewöhnlichem HTTP ohne TLS aus. Genau in diesem Modus analysiert der Proxy die Header selbst und kann seine Limits zeigen. Im HTTPS-Modus über CONNECT ist der Inhalt für den Proxy undurchsichtig, und Abschneiden auf dieser Schicht ist physisch unmöglich.

Prüfung: Sie haben eine Tabelle: Knoten, gesendete Bytes, empfangene Bytes, Hash-Übereinstimmung. Wenn alle Zeilen übereinstimmen, gibt es kein stilles Abschneiden, und Ihre Symptome erklären sich durch die expliziten Ablehnungen aus den Schritten 1–3. Bei Abweichung wissen Sie, wo genau.

Separate Browser-Prüfung auf Set-Cookie

Auch der Browser schneidet still ab, aber nicht die Anfrage, sondern die Antwort. Wenn der Server ein Set-Cookie länger als etwa 4096 Bytes sendet, ignorieren Chrome und Firefox es einfach, ohne jede Warnung. Prüfen Sie: Finden Sie im Tab Network die Antwort mit Set-Cookie, schauen Sie auf die Länge der Zeile, öffnen Sie dann den Tab Application und stellen Sie sicher, dass das Cookie gespeichert wurde. Wenn es fehlt, teilen Sie den Wert auf oder verlegen Sie die Daten auf den Server.

Schritt 5: Das Volumen von Cookies und Headern reduzieren

Ziel dieser Phase: die Ursache des Problems beseitigen, damit Anfragen in die Standardlimits passen und nicht von der Gnade der Zwischenknoten abhängen.

Die Limits zu erhöhen ist verlockend, aber das ist Symptombehandlung. Jedes zusätzliche Kilobyte Cookie geht mit jeder Anfrage jedes Benutzers raus, einschließlich der Anfragen für Bilder. Beginnen Sie mit der Reduzierung.

Cookie-Audit

  1. Nehmen Sie die Liste aus Schritt 2, sortiert nach Größe.
  2. Beantworten Sie für jedes Cookie drei Fragen: Wer setzt es, braucht der Server es, braucht er es auf jedem Pfad der Website.
  3. Cookies von Analyse-Systemen und Werbepixeln braucht der Server fast nie. Sie müssen nicht gelöscht werden, aber sie sollten nicht an die API-Domain gesendet werden.
  4. Cookies mit serialisiertem Zustand (Warenkorb als JSON, Interface-Einstellungen, Verlauf) sind Kandidaten für die Verlagerung in localStorage oder in serverseitigen Speicher mit kurzer ID.

Reduzierungstechniken

  1. Verlegen Sie die API auf eine separate Subdomain. Cookies, die auf www.сайт.ru ohne explizites Domain gesetzt wurden, werden nicht an api.сайт.ru gesendet. Schwere Marketing-Cookies bleiben im Schaufenster, und die API erhält nur die Session.
  2. Setzen Sie das Attribut Path. Ein Cookie mit Path=/admin geht nicht in Anfragen an /static. Prüfen Sie, dass Ihre Frameworks nicht alle Cookies unnötig auf die Wurzel setzen.
  3. Speichern Sie in einem Cookie eine ID, nicht Daten. Statt 3 KB JSON legen Sie einen 32-stelligen Schlüssel ab und halten die Daten in Redis oder der Datenbank. Das löst zugleich das Problem der Inhaltsfälschung.
  4. Verkürzen Sie JWT. Ein Token im Cookie oder in Authorization bläht sich durch überflüssige Felder in der Payload auf: Rollenliste, Adresse, Avatar. Behalten Sie die ID und die Lebensdauer, den Rest fordern Sie mit einem separaten Aufruf an. Ein typisches JWT sollte in 500–800 Bytes passen.
  5. Löschen Sie veraltete Cookies explizit. Wenn Sie ein Cookie umbenannt haben, bleibt das alte bei den Benutzern bis zum Ablauf. Senden Sie Set-Cookie mit dem alten Namen und Max-Age=0.
  6. Verwenden Sie eine separate cookie-freie Domain für Statik. Klassischer Trick: static.сайт.ru oder eine CDN-Domain, auf der überhaupt keine Cookies gesetzt werden.
  7. Prüfen Sie auf Duplikate. Oft existiert dasselbe Cookie in zwei Varianten: für сайт.ru und für .сайт.ru mit Punkt. Der Browser sendet beide.

Für Skripte und Automatisierung

Wenn Sie viele Accounts über Proxys und Antidetekt-Browser verwalten, achten Sie auf die Profile. Ein Profil, das ein halbes Jahr lebt, sammelt Cookies von Dutzenden fremden Domains, und Anfragen an die Zielseite werden genau wegen des aufgeblähten Headers abgelehnt. Richten Sie eine regelmäßige Bereinigung der Cookies fremder Domains ein, ohne die Autorisierungs-Cookies der Zielseite anzutasten. In Bibliotheken wie requests oder httpx speichern Sie Cookies in einem separaten CookieJar pro Account und löschen einmal täglich Einträge mit abgelaufener Gültigkeit.

Tipp: Fügen Sie auf dem Client eine einfache Prüfung vor der Anfrage hinzu: Wenn document.cookie.length 6000 Zeichen überschreitet, senden Sie eine Metrik an Ihr Analyse-System. So erfahren Sie vom Problem durch die ersten Benutzer und nicht durch massenhafte Beschwerden.

Prüfung: Wiederholen Sie die Messung aus Schritt 2 in einem sauberen Profil, durchlaufen Sie ein typisches Benutzerszenario (Login, Katalog, Warenkorb, Checkout) und stellen Sie sicher, dass die Gesamtgröße der Header 4 KB an der API und 8 KB im Schaufenster nicht überschreitet. Das ist ein komfortabler Puffer gegenüber allen Standardlimits.

Schritt 6: Limits auf Webserver, Load Balancer und in der Anwendung konfigurieren

Ziel dieser Phase: abgestimmte Limits auf allen Knoten setzen, die Sie verwalten, damit keiner unerwartet enger ist als seine Nachbarn.

Goldene Regel: Das Limit des äußeren Knotens darf nicht größer sein als das des inneren. Sonst lässt nginx 32 KB durch, und Node.js dahinter lehnt mit 431 ab – Sie erhalten einen Fehler aus der Tiefe des Stacks, der schwerer zu diagnostizieren ist. Eine vernünftige Orientierung für 2026: 16 KB für den gesamten Header-Block und 8–16 KB für ein einzelnes Feld. Das reicht fast allen, und gleichzeitig bleibt Schutz vor Missbrauch.

nginx

  1. Öffnen Sie /etc/nginx/nginx.conf. Finden Sie den Block http { ... }.
  2. Fügen Sie drei Direktiven hinzu oder ändern Sie sie:
http {
client_header_buffer_size 4k;
large_client_header_buffers 4 16k;
proxy_buffer_size 16k;
proxy_buffers 8 16k;
}
  1. client_header_buffer_size ist der erste kleine Puffer für typische Anfragen. Der Standardwert 1k zwingt nginx fast immer, auf die großen Puffer umzuschalten, was nicht schlimm ist, aber 4k reduziert überflüssige Allokationen.
  2. large_client_header_buffers 4 16k bedeutet: bis zu vier Puffer von 16 KB. Jede Header-Zeile muss vollständig in einen Puffer passen, und der gesamte Block in die Summe der Puffer. Das heißt, ein einzelnes Cookie oder Authorization darf 16 KB nicht überschreiten, und alle Header zusammen 64 KB.
  3. proxy_buffer_size ist für die erste Portion der Upstream-Antwort zuständig, einschließlich ihrer Header. Genau seine Erhöhung beseitigt das 502 mit der Phrase upstream sent too big header. Der Wert von proxy_buffers darf nicht kleiner sein als proxy_buffer_size.
  4. Wenn Sie möchten, dass der Client eine sinnvolle Antwort statt der Standardseite 400 sieht, fügen Sie innerhalb von server hinzu: error_page 494 =431 /431.html; und legen Sie die Datei 431.html mit verständlichem Text und dem Rat, Cookies zu löschen, ab. So verwandeln Sie den nicht standardisierten 494 in einen standardisierten 431.
  5. Prüfen Sie die Syntax: sudo nginx -t. Es sollte syntax is ok und test is successful erscheinen.
  6. Wenden Sie ohne Verbindungsabbruch an: sudo nginx -s reload.

Denken Sie daran, dass large_client_header_buffers auch im Kontext server gesetzt werden kann, aber für HTTP/2 der Wert aus dem Kontext http gilt, also bearbeiten Sie genau dort. Für HTTP/2 gibt es zusätzlich die Direktive http2_max_header_size in älteren Versionen; in aktuellen Builds ist sie entfernt, und large_client_header_buffers genügt.

Apache

  1. Öffnen Sie die Hauptkonfiguration und fügen Sie auf Server- oder VirtualHost-Ebene hinzu:
LimitRequestFieldSize 16384
LimitRequestFields 150
LimitRequestLine 16384
  1. LimitRequestFieldSize begrenzt ein einzelnes Feld, standardmäßig 8190 Bytes. LimitRequestFields begrenzt die Anzahl der Felder, standardmäßig 100. LimitRequestLine begrenzt die Startzeile, was bei langen URLs mit Parametern wichtig ist.
  2. Wenn Apache als Reverse Proxy über mod_proxy_http arbeitet, fügen Sie ProxyIOBufferSize 32768 für Antworten mit großen Headern hinzu.
  3. Prüfen Sie: sudo apachectl configtest, dann sudo systemctl reload apache2.

Node.js

  1. Das Limit wird beim Start des Prozesses mit dem Flag --max-http-header-size gesetzt. Der Wert in Bytes: node --max-http-header-size=32768 server.js.
  2. Wenn Sie PM2 oder systemd verwenden, geben Sie das Flag im Feld node_args oder in der Umgebungsvariable NODE_OPTIONS=--max-http-header-size=32768 an.
  3. Alternative im Code: http.createServer({ maxHeaderSize: 32768 }, app). Dieser Parameter wird in aktuellen Node-Versionen unterstützt und erlaubt es, das Limit ohne Neustart mit neuen Flags zu setzen.
  4. Prüfen Sie nach dem Neustart mit einer curl-Serie direkt auf den Node-Port: Die Schwelle sollte sich verschoben haben.

Tomcat und Spring Boot

  1. Fügen Sie in server.xml beim Connector-Element das Attribut maxHttpHeaderSize="16384" hinzu. Standardmäßig steht dort 8192.
  2. In Spring Boot genügt eine Zeile in application.properties: server.max-http-request-header-size=16KB. Der alte Eigenschaftsname server.max-http-header-size funktioniert in einigen Versionen ebenfalls, ist aber als veraltet markiert.
  3. Starten Sie die Anwendung neu und prüfen Sie die Schwelle.

Gunicorn und Uvicorn

  1. Fügen Sie für Gunicorn in die Konfiguration oder Kommandozeile hinzu: --limit-request-field_size 16380 --limit-request-fields 150 --limit-request-line 8190. Achten Sie auf die Schreibweise field_size mit Unterstrich: Das ist ein historisches Artefakt, und mit Bindestrich funktioniert der Parameter nicht.
  2. Der Wert 0 bei limit-request-field_size hebt die Beschränkung vollständig auf, aber tun Sie das nicht auf öffentlichen Servern.
  3. Uvicorn begrenzt die Header-Größe über den h11-Parser und erlaubt standardmäßig recht große Werte; oft liegt die Engstelle davor, in nginx.

HAProxy

  1. In der Sektion global: tune.bufsize 32768 und tune.http.maxhdr 150.
  2. Die Anfrage muss vollständig mit allen Headern in einen Puffer der Größe tune.bufsize minus Reserve tune.maxrewrite passen. Bei 16384 Standard sind real etwa 15 KB verfügbar.
  3. Prüfen Sie haproxy -c -f /etc/haproxy/haproxy.cfg und starten Sie neu. Beachten Sie, dass eine Erhöhung von bufsize den Speicherverbrauch pro Verbindung erhöht.

IIS

  1. Die Limits leben in der Registry unter HTTP.sys: Parameter MaxFieldLength und MaxRequestBytes im Schlüssel HKLM SYSTEM CurrentControlSet Services HTTP Parameters. Standardwerte sind 16384 Bytes für beide, Maximum 65534.
  2. Nach der Änderung ist ein Neustart des HTTP-Dienstes oder des Servers erforderlich.
  3. Prüfen Sie zusätzlich maxAllowedContentLength und maxQueryString in requestFiltering, falls das Problem lange URLs betrifft.

CDN und WAF

Bei den meisten Cloud-CDN sind die Limits in Basistarifen fest und ändern sich nur in Enterprise-Tarifen. Wenn die Schwelle aus Schritt 3 am CDN hängt, ist der einzige universelle Weg die Reduzierung der Cookies aus Schritt 5. Prüfen Sie zusätzlich, ob in der WAF ein Modus konfiguriert ist, in dem große Header nicht blockiert, sondern herausgeschnitten werden: Ein solcher Modus erzeugt genau das stille Abschneiden und sollte besser auf eine explizite Ablehnung mit Code umgestellt werden.

Achtung: Setzen Sie Limits nicht auf Megabyte zur Beruhigung. Jedes Kilobyte Puffer multipliziert sich mit der Anzahl gleichzeitiger Verbindungen, und ein Angreifer kann gezielt gigantische Header senden, um Speicher zu erschöpfen. Halten Sie einen vernünftigen Puffer vom Zwei- bis Dreifachen des realen Maximums und nicht mehr.

Prüfung: Wiederholen Sie die curl-Serie aus Schritt 2 für jeden Knoten separat (direkt in die Anwendung, über nginx, von außen über das CDN). Die Schwellen sollten entweder übereinstimmen oder vom inneren zum äußeren Rand abnehmen. Stellen Sie sicher, dass bei Überschreitung jeder Knoten einen verständlichen Code zurückgibt und nicht die Verbindung abreißt.

Schritt 7: Ablehnungen explizit machen und Monitoring einrichten

Ziel dieser Phase: stilles Abschneiden künftig ausschließen und von wachsenden Headern erfahren, bevor sie das Limit erreichen.

Explizite Antworten statt Schweigen

  1. Stellen Sie sicher, dass jeder Ihrer Knoten bei Überschreitung des Limits 431 oder zumindest 400 mit Text zurückgibt. In nginx ist das bereits in Schritt 6 über error_page 494 erledigt.
  2. Wenn Sie einen selbstgebauten Proxy oder ein Gateway mit festem Puffer haben, fügen Sie eine Prüfung hinzu: Wenn ein Header nicht passt, antworten Sie mit 431 und schließen Sie die Verbindung. Übergeben Sie niemals einen abgeschnittenen Wert weiter.
  3. Fügen Sie in der Anwendung eine Validierung kritischer Header hinzu. Wenn z. B. ein JWT nicht parst oder ein Session-Cookie kürzer als die erwartete Länge ist, loggen Sie das als separates Ereignis mit dem Vermerk possible truncation. Das ist ein günstiger Detektor für Probleme an jedem externen Knoten.

Größen protokollieren

  1. Erweitern Sie in nginx das Log-Format. Im Block http:
log_format withsize '$remote_addr - $status "$request" req_len=$request_length cookie_len=$cookie_len';
map $http_cookie $cookie_len { default 0; ~^(?<c>.*)$ $c; }
  1. Eine einfache und zuverlässige Variante ohne map: Loggen Sie nur $request_length. Diese Variable genügt, um das Wachstum zu sehen.
  2. Führen Sie einmal täglich awk über das access.log aus und finden Sie Maximum und 99. Perzentil von req_len. Wenn das 99. Perzentil die Hälfte des Limits überschreitet, ist es Zeit, Cookies zu bereinigen.
  3. Für Apache verwenden Sie im LogFormat die Variable %I aus mod_logio: Sie zeigt eingehende Bytes einschließlich Header.

Alerts

  1. Legen Sie eine Metrik für die Anzahl der Antworten 431 und 400 mit Cookie-Text an. In Prometheus mit nginx-exporter sind das die Status aus dem access.log; in Cloud-Monitoring-Panels gibt es meist eine Aufschlüsselung nach Codes.
  2. Setzen Sie eine Schwelle: Mehr als 10 solche Antworten in 5 Minuten sind ein Signal. Ein massenhafter 431-Fehler bedeutet fast immer, dass jemand ein neues schweres Cookie ausgerollt hat.
  3. Fügen Sie eine synthetische Prüfung hinzu: Ein Skript sendet stündlich eine Anfrage mit einem Header auf 90 Prozent des Limits und prüft, dass sie durchgeht, und mit einem Header auf 110 Prozent, dass genau 431 zurückkommt. So erkennen Sie sowohl eine versehentliche Verschärfung als auch eine versehentliche Aufhebung des Limits.

Tipp: Halten Sie den Echo-Endpunkt aus Schritt 4 dauerhaft bereit, abgesichert per IP oder einfacher Autorisierung. Er wird bei jeder Infrastrukturänderung nützlich sein: WAF hinzugefügt, Load Balancer gewechselt, neuer Proxy-Pool angebunden – und in einer Minute können Sie sich vergewissern, dass die Header vollständig ankommen.

Prüfung: Senden Sie eine bewusst große Anfrage und stellen Sie sicher, dass sie mit der richtigen Größe ins Log gelangt, dass der 431-Zähler gestiegen ist und dass der Alert bei Überschreitung der Schwelle ausgelöst hat. Setzen Sie danach die Schwellen auf die Arbeitswerte zurück.

Ergebnis prüfen

Gehen Sie die Checkliste durch. Jeder Punkt muss erfüllt sein, sonst kehren Sie zum entsprechenden Schritt zurück.

Checkliste

  • Die problematische Seite aus Schritt 1 öffnet sich im Hauptprofil des Browsers fehlerfrei.
  • Die Gesamtgröße der Header einer typischen Anfrage überschreitet 8 KB nicht, an der API-Domain 4 KB nicht.
  • Kein Cookie überschreitet 2 KB, die schwersten Fremd-Cookies werden nicht an die API gesendet.
  • Die Ablehnungsschwelle an jedem Knoten ist bekannt und notiert; die Limits nehmen von der Anwendung zum äußeren Rand ab oder sind gleich.
  • Bei Überschreitung des Limits erhält der Client den Code 431 oder 400 mit Text, nicht einen Verbindungsabbruch und keine stillschweigend gekürzte Anfrage.
  • Der Echo-Endpunkt zeigt Übereinstimmung von Länge und Hash beim Senden durch die gesamte Kette, einschließlich Ihrer Proxys.
  • Im access.log ist die Anfragegröße vorhanden, ein Alert auf das Wachstum von 431 ist eingerichtet.
  • Backups der Konfigurationen liegen bereit, und Sie kennen den Rollback-Befehl.

Wie man alles zusammen testet

  1. Löschen Sie die Cookies für die Testdomain und durchlaufen Sie das Benutzerszenario vom Login bis zur Schlüsselaktion. Es darf keine Fehler geben.
  2. Starten Sie die curl-Schleife aus Schritt 2 von außen. Notieren Sie die Schwelle; sie sollte Ihren neuen Einstellungen entsprechen.
  3. Senden Sie eine Kontrollanfrage an den Echo-Endpunkt über jeden verwendeten Pfad: direkt, über das CDN, über den Proxy-Pool.
  4. Senden Sie absichtlich einen Header mit der doppelten Limit-Größe und prüfen Sie den Erhalt von 431 mit verständlichem Body.
  5. Prüfen Sie, dass Antworten der Anwendung mit großen Set-Cookie keinen 502 bei nginx verursachen.

Erfolgsindikatoren

Der Anteil der Antworten 431 und 400 mit Header-Text geht im normalen Traffic gegen null. Das 99. Perzentil der Anfragegröße ist kleiner als die Hälfte des engsten Limits. Unbegründete Logouts und verlorene Sessions tauchen in den Nutzerbeschwerden nicht mehr auf.

Typische Fehler und Lösungen

Limit in nginx erhöht, aber 431 bleibt

Ursache: Hinter nginx steht Node.js oder Tomcat mit eigenem Limit von 8–16 KB, und jetzt lehnt dieser ab. Lösung: Prüfen Sie die Schwelle direkt am Anwendungsport aus Schritt 3 und erhöhen Sie sie mit dem Flag --max-http-header-size oder maxHttpHeaderSize. Stellen Sie dann sicher, dass das nginx-Limit nicht größer ist als das der Anwendung.

large_client_header_buffers im Block server gesetzt, aber nichts hat sich geändert

Ursache: Für HTTP/2 verwendet nginx den Wert aus dem Kontext http, und die Direktive wird nicht so vererbt, wie erwartet, wenn sie in mehreren server für dieselbe Adresse gesetzt ist. Lösung: Verschieben Sie die Direktive in den Block http und laden Sie die Konfiguration neu.

Der Fehler tritt nur bei einem Teil der Benutzer auf

Ursache: Die Cookie-Größe hängt von der Historie des konkreten Benutzers ab: besuchte Bereiche, aktivierte Experimente, alte Cookies aus früheren Website-Versionen. Lösung: Sammeln Sie Größenstatistiken über $request_length, finden Sie heraus, welche Cookies wachsen, und löschen Sie veraltete explizit per Set-Cookie mit Max-Age=0.

Nach dem Löschen der Cookies funktioniert alles, aber nach einer Woche bricht es wieder

Ursache: Die Wachstumsquelle ist nicht beseitigt: Zum Beispiel schreibt ein Analyse-Skript bei jedem Besuch Daten in ein Cookie. Lösung: Finden Sie das wachsende Cookie durch Sortierung nach Größe an verschiedenen Tagen und verlagern Sie seinen Inhalt in localStorage oder begrenzen Sie es auf Seiten des Skript-Anbieters.

Nginx gibt 502 zurück, obwohl die Anwendung lebt

Ursache: Im error.log steht upstream sent too big header: Die Antwort-Header der Anwendung passten nicht in proxy_buffer_size. Meist ist ein riesiges Set-Cookie oder eine Vielzahl von Debug-Headern schuld. Lösung: Erhöhen Sie proxy_buffer_size auf 16k und proxy_buffers auf 8 16k, und reduzieren Sie in der Anwendung die Antwort-Header.

Über den Proxy verliert eine HTTP-Anfrage einen Teil der Header, über HTTPS geht sie durch

Ursache: Bei HTTP analysiert der Proxy die Header selbst und stößt an seinen Puffer, während bei HTTPS über CONNECT der Inhalt undurchsichtig ist und unverändert durchgeht. Lösung: Wechseln Sie für die Zielressource auf HTTPS oder reduzieren Sie die Header. Wenn der Proxy Ihr eigener ist, erhöhen Sie sein Limit und konfigurieren Sie eine explizite Ablehnung statt Abschneiden.

Der Browser speichert ein Cookie nach der Serverantwort nicht

Ursache: Die Set-Cookie-Zeile ist länger als 4096 Bytes oder die Gesamtzahl der Cookies pro Domain hat das Browser-Limit überschritten (etwa 180 in Chrome), und er hat das neue stillschweigend verworfen oder ein altes verdrängt. Lösung: Speichern Sie im Cookie nur eine ID und halten Sie die Daten auf dem Server; legen Sie nicht Dutzende kleiner Cookies an, sondern bündeln Sie sie.

Gunicorn ignoriert den Limit-Parameter

Ursache: Der Parameter ist mit Bindestrich als limit-request-field-size geschrieben, aber der korrekte Name enthält einen Unterstrich: limit-request-field_size. Lösung: Korrigieren Sie die Schreibweise und starten Sie die Worker neu.

Zusätzliche Möglichkeiten

Unterschiedliche Limits für unterschiedliche Pfade

Sie müssen das Limit nicht für die ganze Website erhöhen. Wenn schwere Header nur auf einem Pfad nötig sind, z. B. beim Hochladen von Dateien mit langen Metadaten, können Sie diesen Pfad in nginx in einen separaten server auf einem separaten Namen oder Port mit erhöhten large_client_header_buffers auslagern und die Hauptseite streng lassen. So bewahren Sie den Schutz vor Missbrauch dort, wo er wichtiger ist.

Header-Komprimierung in HTTP/2 und HTTP/3

Die Protokolle HTTP/2 und HTTP/3 komprimieren Header mit den Algorithmen HPACK und QPACK. Über das Netz gehen wiederkehrende Cookies kompakt, aber auf dem Server werden sie in voller Größe dekomprimiert, und die Limits gelten genau für die dekomprimierten Daten. Daher spart die Aktivierung von HTTP/2 Traffic, schützt aber nicht vor 431. Der Parameter SETTINGS_MAX_HEADER_LIST_SIZE, den der Server dem Client mitteilt, legt die Obergrenze der dekomprimierten Liste fest; in nginx wird er automatisch aus large_client_header_buffers berechnet.

Gechunkte Cookies

Einige Autorisierungsbibliotheken können einen langen Wert auf mehrere Cookies mit den Suffixen .0, .1, .2 aufteilen und serverseitig wieder zusammensetzen. Das löst das Problem des Browser-Limits von 4 KB pro Cookie, reduziert aber nicht die Gesamtgröße des Headers Cookie. Verwenden Sie den Trick nur als Übergangsmaßnahme bei der Migration zu serverseitigen Sessions.

Serverseitige Sessions statt Cookie-Container

Die zuverlässigste architektonische Lösung: Im Cookie bleibt nur eine zufällige ID von 32–64 Zeichen, und der gesamte Zustand liegt in Redis mit TTL. Der Header Cookie überschreitet dabei selten 200 Bytes, und das ganze Thema Limits wird irrelevant. Die Migration dauert von einem Tag für eine kleine Anwendung bis zu mehreren Wochen für eine große, amortisiert sich aber durch geringeren Traffic und vereinfachte Sicherheit.

Automatische Prüfung in der CI

Fügen Sie in die Pipeline einen Test ein: Starten Sie die Anwendung, senden Sie eine Anfrage mit Headern auf 90 Prozent des angegebenen Limits und prüfen Sie Code 200, dann mit 120 Prozent und prüfen Sie Code 431. Der Test dauert Sekunden und verhindert, dass ein Limit bei einem Framework-Update versehentlich verengt wird, wenn sich Standardwerte ändern.

Arbeit mit einem Proxy-Pool

Wenn Sie mehrere Proxy-Server oder einen mobilen Pool mit Rotation verwenden, führen Sie die Kontrollanfrage an den Echo-Endpunkt über jeden Ausgang per HTTP und per HTTPS aus. Speichern Sie die Ergebnisse in einer Tabelle. So erkennen Sie Ausgänge mit ungewöhnlichem Verhalten und können sie entweder ausschließen oder nur HTTPS-Traffic über sie senden, wo Abschneiden unmöglich ist.

FAQ

Worin unterscheidet sich 431 von 494, wenn beide im Grunde große Header betreffen?

431 ist ein Standardcode aus der HTTP-Spezifikation, den alle Clients und Monitoring-Tools verstehen. 494 ist ein interner nginx-Code, der standardmäßig nach außen zu 400 mit dem Text Request Header Or Cookie Too Large wird. Für den Benutzer gibt es keinen Unterschied, aber für die Diagnose weist 494 in Logs oder in error_page eindeutig auf nginx als Quelle hin.

Kann man einfach ein sehr großes Limit setzen und es vergessen?

Technisch ja, aber so erhöhen Sie den Speicherverbrauch pro Verbindung und erleichtern Angriffe mit gigantischen Headern. Außerdem kontrollieren Sie die Limits von CDNs und Browsern nicht, und das Problem verlagert sich einfach dorthin. Die richtige Reihenfolge: zuerst Cookies reduzieren, dann ein moderates Limit mit Puffer setzen.

Warum funktioniert im Inkognito alles, im normalen Modus aber nicht?

Im Inkognito gibt es keine angesammelten Cookies. Das ist ein fast hundertprozentiges Anzeichen dafür, dass die Ursache in der Größe des Headers Cookie beim konkreten Benutzer liegt. Das Löschen der Cookies für die Domain löst das Problem einmalig, und Schritt 5 löst es dauerhaft.

Wie misst man die Header-Größe, wenn man keinen Serverzugriff hat?

Verwenden Sie die Entwicklertools: Der Tab Application zeigt die Größe jedes Cookies, und der Befehl document.cookie.length in der Konsole gibt die Gesamtlänge der für Skripte zugänglichen Cookies. Für die genaue Ablehnungsschwelle senden Sie curl mit einem künstlich großen Header und schauen Sie auf den Antwortcode.

Kann mein Proxy Header in HTTPS-Anfragen abschneiden?

Nein. Bei HTTPS über einen Proxy wird die Methode CONNECT verwendet, und der Proxy leitet einen verschlüsselten Byte-Strom weiter, ohne dessen Inhalt zu sehen. Header darin kann er physisch nicht abschneiden oder verändern. Bei gewöhnlichen HTTP-Anfragen dagegen analysiert der Proxy die Header selbst, und hier sind sowohl Limits als auch Abschneiden möglich.

Wie erkennt man, dass ein Header abgeschnitten wurde, wenn kein Fehler auftritt?

Stellen Sie den Echo-Endpunkt aus Schritt 4 auf, senden Sie einen Header bekannter Länge mit Positionsmarkern und vergleichen Sie Länge und Hash des empfangenen Werts mit dem gesendeten. Eine Abweichung zeigt sowohl das Abschneiden als auch die Schnittposition.

Nginx lässt durch, aber die Node.js-Anwendung antwortet mit 431. Was tun?

Erhöhen Sie das Limit von Node.js mit dem Flag --max-http-header-size oder dem Parameter maxHeaderSize in createServer und bringen Sie dann das nginx-Limit auf denselben oder einen kleineren Wert, damit die Ablehnung an der äußeren Schicht mit einer verständlichen Seite erfolgt.

Was ist wichtiger zu begrenzen: die Größe eines einzelnen Headers oder die Gesamtgröße?

Beides. Die Gesamtgröße schützt den Speicher, und das Limit für ein einzelnes Feld schützt die Parser. Bei nginx leiten sich beide Limits aus large_client_header_buffers ab: Die Puffergröße ist das Limit pro Zeile, und die Anzahl der Puffer multipliziert mit der Größe ist das Gesamtlimit.

Sollte man 431 auf dem Client abfangen und Cookies automatisch löschen?

Für die eigene Website ist das eine hervorragende Technik: Bei Erhalt von 431 oder 400 mit dem passenden Text löscht das Frontend sicherlich nicht notwendige Cookies und wiederholt die Anfrage. Löschen Sie Autorisierungs-Cookies nicht ohne Zustimmung des Benutzers und protokollieren Sie solche Ereignisse unbedingt, um die Ursache zu beseitigen.

Wie stellt man sicher, dass eine neue Framework-Version das Standardlimit nicht geändert hat?

Halten Sie die synthetische Prüfung aus Schritt 7 und den CI-Test aus dem Abschnitt zu zusätzlichen Möglichkeiten bereit. Beide senden Anfragen an der Limit-Grenze und zeigen sofort, wenn sich die Schwelle in eine beliebige Richtung verschoben hat.

Fazit

Fassen wir zusammen, was Sie getan haben. Sie haben gelernt, den Fehler zu reproduzieren und 431, 494 und seine öffentliche Erscheinung als 400 anhand der Antwortsignatur zu unterscheiden. Sie haben die tatsächliche Größe von Headern und Cookies gemessen und die Ablehnungsschwelle per binärer Suche mit curl gefunden. Sie haben bestimmt, welcher Knoten der Kette für die Ablehnung verantwortlich ist, und dieses Problem von den Proxy-Layer-Codes wie 407, 502 und 504 getrennt, wobei Sie sich den nützlichen Marker zu upstream sent too big header bewahrt haben. Mit Hilfe des Echo-Endpunkts haben Sie stilles Abschneiden erwischt oder ausgeschlossen, das keine Spuren in den Logs hinterlässt. Danach haben Sie Cookies reduziert, die API auf eine saubere Domain verlegt, die Limits in nginx, Apache, Node.js, Tomcat, Gunicorn und HAProxy abgestimmt, Ablehnungen explizit gemacht und Monitoring eingerichtet.

Was als Nächstes zu tun ist. Beobachten Sie in der kommenden Woche die Metrik der Anfragegröße und den 431-Zähler: Sie zeigen, ob eine Quelle für Cookie-Wachstum geblieben ist. Führen Sie eine Teamregel ein: Jedes neue Cookie durchläuft ein Review mit Fragen zu Größe, Domain und Pfad. Wenn das Projekt Sessions im Cookie als serialisierten Zustand verwendet, planen Sie die Migration zu serverseitigem Speicher mit kurzer ID.

Wohin Sie sich weiterentwickeln können. Die nächste Stufe ist ein tiefes Verständnis der Header-Komprimierung in HTTP/2 und HTTP/3, die Feinabstimmung der Puffer unter Last und der Aufbau einer transparenten Observability-Schicht, in der die Größe jeder Anfrage im Trace sichtbar ist. Nützlich ist auch zu untersuchen, wie sich Limits bei der Arbeit über verschiedene Proxy- und Load-Balancer-Typen verhalten, und eine eigene Tabelle von Schwellen für die Infrastruktur zu erstellen, mit der Sie arbeiten. Die in diesem Leitfaden gesammelten Werkzeuge, einschließlich des Echo-Endpunkts und der curl-Schleife, bleiben bei Ihnen und sparen Ihnen Stunden bei jeder nächsten seltsamen Ablehnung. Sie haben alles geschafft, und diese Problemkategorie ist für Sie kein Rätsel mehr.