Wprowadzenie

Ta instrukcja dotyczy wąskiej, ale bardzo podstępnej grupy problemów: żądanie nie przechodzi lub przechodzi tylko częściowo, ponieważ jego nagłówki lub pliki cookie stały się zbyt duże. Z zewnątrz wygląda to jak błąd 431 Request Header Fields Too Large, jak specyficzny dla nginx kod 494 Request Header Too Large, jak niejasny 400 Request Header Or Cookie Too Large, a w najgorszym przypadku nie wygląda wcale: jakiś węzeł pośredniczący po cichu odrzuca część nagłówków, a aplikacja otrzymuje użytkownika bez sesji, bez tokenu autoryzacji lub bez potrzebnych plików cookie.

Ważne, żeby od razu odciąć się od pokrewnego tematu. W osobnym artykule omawialiśmy kody 407, 502 i 504, które zwraca sama warstwa proxy przy ustanawianiu tunelu: nie przeszła autoryzacja na proxy, nie podniósł się upstream, minął timeout. Tam problem leży w połączeniu i w samym proxy. Tutaj połączenie nawiązuje się prawidłowo, tunel istnieje, ale dane, które próbujesz przez niego wysłać, nie mieszczą się w buforach jednego z węzłów łańcucha. Przyczyna zawsze tkwi w objętości i składzie nagłówków, a leczy się ją zupełnie innymi narzędziami.

Co zyskasz

  • Umiejętność dokładnego zmierzenia rozmiaru nagłówków i plików cookie konkretnego żądania w kilka minut.
  • Zrozumienie, który węzeł łańcucha (przeglądarka lub klient, proxy, load balancer, serwer WWW, aplikacja) odrzuca lub obcina dane.
  • Gotowy endpoint echo do wykrywania cichego obcinania bez ani jednego kodu błędu.
  • Działające konfiguracje limitów dla nginx, Apache, Node.js, HAProxy, Tomcat i Gunicorn z wyjaśnieniem każdego parametru.
  • Strategię zmniejszania plików cookie, żeby problem nie wrócił po miesiącu.
  • Monitoring, który zawczasu zasygnalizuje zbliżanie się do limitu.

Dla kogo jest ten przewodnik

Dla web developerów, administratorów systemów, specjalistów od scrapingu i automatyzacji, a także dla tych, którzy pracują z dużą liczbą kont przez proxy i regularnie spotykają się z niezrozumiałymi odmowami. Poziom trudności średni: nie musisz być ekspertem od protokołu HTTP, ale podstawowe umiejętności pracy z terminalem i zrozumienie, czym jest plik konfiguracyjny, będą potrzebne.

Co warto wiedzieć wcześniej

  • Jak otworzyć terminal i wykonać polecenie.
  • Jak otworzyć panel deweloperski w przeglądarce (klawisz F12).
  • Gdzie leżą konfigi twojego serwera WWW, jeśli nim administrujesz.
  • Ogólne pojęcie o tym, że żądanie idzie od klienta przez węzły pośredniczące do serwera.

Ile czasu to zajmie

Diagnoza według kroków 1-4 zajmuje od 30 do 60 minut. Naprawa po stronie serwera (kroki 5-7) zajmie kolejne 1-2 godziny z uwzględnieniem restartów i weryfikacji. Jeśli tylko sprawdzasz cudzą usługę i nie masz dostępu do jej ustawień, wystarczą ci pierwsze cztery kroki i sekcja o zmniejszaniu plików cookie.

Przygotowanie wstępne

Nic egzotycznego nie będzie potrzebne, ale przygotuj narzędzia zawczasu, żeby nie rozpraszać się w trakcie.

Potrzebne narzędzia

  • curl w wersji 7.70 lub nowszej. Jest w macOS, we wszystkich dystrybucjach Linuksa i w Windows 10 i 11 od razu. Sprawdź poleceniem curl --version.
  • Przeglądarka z panelem deweloperskim: Chrome, Edge, Firefox lub Yandex Browser. Przyda się zakładka Network (Sieć) oraz zakładka Application lub Storage do przeglądania plików cookie.
  • Edytor tekstu z podświetlaniem składni: VS Code, Notepad++ lub wbudowany nano na serwerze.
  • Dostęp SSH do serwera, jeśli będziesz zmieniać limity. Uprawnienia do czytania logów i restartowania usług są obowiązkowe.
  • Python 3 lub Node.js do uruchomienia endpointu echo. Wystarczy dowolna aktualna wersja.
  • Opcjonalnie: mitmproxy lub wbudowany analizator w przeglądarce antydetekcyjnej, jeśli chcesz podejrzeć ruch między klientem a proxy.

Wymagania systemowe

Dowolna maszyna robocza. Dla serwera echo wystarczy 100 MB pamięci operacyjnej. Jedyny realny wymóg: dostęp sieciowy do sprawdzanej usługi i, w razie potrzeby, do używanego proxy.

Co pobrać i skonfigurować

  1. Upewnij się, że curl działa: wykonaj curl -sI https://example.com. Powinieneś zobaczyć wiersze nagłówków odpowiedzi, zaczynające się od HTTP/2 200 lub podobnego.
  2. Jeśli pracujesz przez proxy, przygotuj jego adres, port, login i hasło. Sprawdź podstawowe połączenie poleceniem curl -x http://login:hasło@host:port -sI https://example.com. Jeśli tu pojawia się błąd 407 lub połączenie w ogóle się nie nawiązuje, wróć do artykułu o kodach warstwy proxy: nasz temat zaczyna się dopiero po udanym tunelu.
  3. Na serwerze znajdź główny konfig: dla nginx to zwykle /etc/nginx/nginx.conf i katalog /etc/nginx/conf.d/, dla Apache /etc/apache2/apache2.conf lub /etc/httpd/conf/httpd.conf.
  4. Znajdź logi: /var/log/nginx/error.log, /var/log/nginx/access.log, /var/log/apache2/error.log. Upewnij się, że możesz je czytać poleceniem tail -n 50.

Kopie zapasowe

Przed każdą zmianą konfigów zrób kopię. Zajmuje to sekundy, a oszczędza godziny.

  1. Wykonaj sudo cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak-2026.
  2. Dla katalogu ze stronami: sudo cp -r /etc/nginx/conf.d /etc/nginx/conf.d.bak-2026.
  3. Dla Apache analogicznie: sudo cp /etc/apache2/apache2.conf /etc/apache2/apache2.conf.bak-2026.
  4. Zapisz aktualne wartości limitów w osobnym pliku z notatkami, żeby wiedzieć, od czego startujesz.

Uwaga: nigdy nie edytuj produkcyjnego konfigu bez uprzedniego sprawdzenia składni. Dla nginx to sudo nginx -t, dla Apache sudo apachectl configtest. Błąd w jednej linii przy restarcie zostawi usługę leżącą.

Podstawowe pojęcia

Zanim zaczniemy łapać problem, ustalmy terminy. Nie ma tu nic skomplikowanego, ale zamieszanie w słowach często prowadzi diagnozę w złym kierunku.

Czym są nagłówki żądania

Każde żądanie HTTP składa się z wiersza startowego (metoda, ścieżka, wersja protokołu), bloku nagłówków i opcjonalnego ciała. Nagłówki to pary w formacie Nazwa: wartość. Przeglądarka dodaje je automatycznie: Host, User-Agent, Accept, Accept-Language, Referer, Authorization i oczywiście Cookie. Aplikacje dodają swoje: tokeny, identyfikatory śledzenia, znaczniki eksperymentów.

Dlaczego pliki cookie to najczęstszy winowajca

Nagłówek Cookie składa się ze wszystkich plików cookie pasujących do domeny i ścieżki żądania. Każdy system analityczny, każdy widget czatu, każda sieć reklamowa dodaje po kilka sztuk. Wartość jednego pliku cookie może mieć do 4 KB, a takich plików cookie na domenie są dziesiątki. Co więcej, przeglądarka wysyła je ze wszystkimi żądaniami, w tym obrazkami i fontami. W rezultacie nagłówek Cookie łatwo przekracza 8-16 KB, a właśnie takie progi domyślnie stoją w większości serwerów.

Kod 431

431 Request Header Fields Too Large to standardowy kod opisany w specyfikacji HTTP. Serwer komunikuje: nagłówki są zbyt duże, albo jeden z nich, albo wszystkie razem. Kod zwracają Node.js, Go, Envoy, niektóre CDN-y i nowoczesne frameworki. Odpowiedź z 431 jest poprawna protokolarnie i dobrze widoczna w logach, dlatego to najwygodniejszy do diagnozy wariant.

Kod 494

494 Request Header Too Large to wewnętrzny, niestandardowy kod nginx. Nginx używa go w swoim kodzie, gdy nagłówek nie mieści się w buforach zadanych dyrektywą large_client_header_buffers. Klientowi domyślnie wysyłane jest wtedy 400 z treścią Request Header Or Cookie Too Large. Samą cyfrę 494 można zobaczyć w dwóch przypadkach: jeśli administrator jawnie opisał error_page 494, albo jeśli czytasz wewnętrzne zmienne i logi nginx. Dlatego jeśli użytkownik skarży się na białą stronę z napisem 400 i słowami o cookie, wiedz: to ten sam 494.

Ciche obcinanie

Najbardziej nieprzyjemny scenariusz. Węzeł pośredniczący nie odrzuca żądania, tylko obcina nagłówek do rozmiaru swojego bufora lub odrzuca część nagłówków w całości. Aplikacja otrzymuje niepełne dane. Objawy są różnorodne: użytkownika nagle wylogowuje, gubi się koszyk, nie da się odczytać tokenu, znika nagłówek z identyfikatorem regionu. Kodu błędu nie ma, w logach serwera WWW wszystko jest na zielono. Takie zachowanie występuje w samodzielnie pisanych proxy na stałych buforach, w starych firmowych bramach, w niektórych WAF-ach w trybie łagodnej obsługi, w bibliotekach klienckich, które dzielą lub ucinają długie wartości, a także w samej przeglądarce, która po cichu ignoruje Set-Cookie dłuższe niż 4096 bajtów.

Gdzie w ogóle stoją limity

Wyobraź sobie łańcuch: przeglądarka lub skrypt, potem twoje wyjściowe proxy (na przykład mobilne), potem CDN lub WAF, potem load balancer, potem serwer WWW, potem serwer aplikacji. Każde ogniwo ma swój limit i swoje zachowanie przy przekroczeniu. Zadaniem diagnozy jest znalezienie najwęższego miejsca. Właśnie dlatego samo zwiększenie limitu w nginx często nie wystarcza: za nim stoi Node.js ze swoim progiem 16 KB.

Granica z błędem 502 upstream sent too big header

Osobny przypadek na styku dwóch tematów. Jeśli nginx pisze w error.log frazę upstream sent too big header while reading response header from upstream i zwraca 502, to nie chodzi o tunel ani o padnięty upstream, tylko o nagłówki odpowiedzi aplikacji, które nie zmieściły się w proxy_buffer_size. Formalnie to 502, ale leczy się parametrami buforów, o których tu mówimy. Zapamiętaj ten znacznik: pomoże nie szukać problemu w warstwie proxy.

Krok 1: Odtwórz problem i zapisz objawy

Cel etapu: uzyskać stabilny scenariusz, w którym błąd występuje, i zapisać dokładne oznaki: kod, treść odpowiedzi, nagłówek Server i czas.

  1. Otwórz problematyczną stronę w przeglądarce. Naciśnij F12, przejdź do zakładki Network (Sieć).
  2. Zaznacz pole Preserve log (Zachowaj dziennik), żeby wpisy nie znikały przy przejściach.
  3. Odśwież stronę klawiszem F5. Znajdź żądanie pokolorowane na czerwono lub żądanie ze statusem 400, 431 albo 494. Kliknij je.
  4. W zakładce Headers zapisz: kod statusu, wartość nagłówka Server w odpowiedzi (nginx, cloudflare, AkamaiGHost, gunicorn), wartość Via, jeśli jest, oraz wszelkie nagłówki z prefiksem X- lub CF-.
  5. Przejdź do zakładki Response i skopiuj treść odpowiedzi. Fraza Request Header Or Cookie Too Large wskazuje na nginx. Fraza Request Header Fields Too Large bez słowa Cookie jest typowa dla Node.js. Fraza Bad Request - Request Too Long jest charakterystyczna dla IIS.
  6. Przewiń w dół do bloku Request Headers. Oszacuj długość wiersza Cookie: jeśli zajmuje kilka ekranów, to już podpowiedź.
  7. Otwórz okno w trybie incognito i powtórz żądanie. Jeśli w czystym profilu błędu nie ma, winne są nagromadzone pliki cookie konkretnego użytkownika.

Jeśli problem występuje w skrypcie, a nie w przeglądarce, zapisz te same dane z odpowiedzi biblioteki: status, treść, nagłówki. W Python requests to response.status_code, response.text i response.headers.

Wskazówka: wyeksportuj wszystkie żądania do pliku HAR prawym przyciskiem myszy na liście żądań i pozycją Save all as HAR with content. Ten plik można później otworzyć lub przekazać koledze, a zachowa dokładne rozmiary nagłówków.

Weryfikacja: powinieneś mieć notatkę z czterema punktami: kod statusu, tekst treści odpowiedzi, wartość nagłówka Server i wynik testu w incognito. Jeśli wynik w incognito się różni, znasz już 70 procent przyczyny.

Możliwe problemy

  • Błąd pojawia się nie zawsze. Znaczy to, że rozmiar plików cookie oscyluje wokół progu: na przykład po odwiedzeniu pewnej sekcji dochodzi jeszcze jeden plik cookie. Zapisz, po jakich działaniach błąd się pojawia.
  • Czerwonego żądania nie ma, ale strona działa nieprawidłowo. To oznaka cichego obcinania. Przejdź do kroku 4 od razu po pomiarze.

Krok 2: Zmierz rzeczywisty rozmiar nagłówków i plików cookie

Cel etapu: uzyskać dokładne liczby w bajtach: całkowity rozmiar bloku nagłówków, rozmiar nagłówka Cookie, rozmiar każdego pojedynczego pliku cookie.

Pomiar w przeglądarce

  1. W panelu deweloperskim otwórz zakładkę Console (Konsola).
  2. Wpisz document.cookie.length i naciśnij Enter. Zobaczysz liczbę: to długość w znakach wszystkich plików cookie dostępnych skryptom, bez flagi HttpOnly. Rzeczywisty nagłówek będzie większy, bo pliki cookie HttpOnly tu nie wchodzą.
  3. Wpisz document.cookie.split('; ').map(c => [c.split('=')[0], c.length]).sort((a, b) => b[1] - a[1]). Konsola pokaże tablicę par nazwa-długość, posortowaną malejąco. Najcięższe pliki cookie znajdą się na górze.
  4. Przejdź do zakładki Application (w Firefoksie Storage), rozwiń Cookies, wybierz domenę. Tu widać wszystkie pliki cookie, w tym HttpOnly, z kolumną Size. Kliknij nagłówek kolumny, żeby posortować według rozmiaru.
  5. Zsumuj rozmiary lub po prostu spójrz na wiersz Cookie w żądaniu z kroku 1: w Chrome przy najechaniu na nagłówek wyświetla się jego długość.

Pomiar przez curl

Curl pozwala wysłać nagłówki dowolnego rozmiaru i dokładnie ustalić, przy jakiej objętości serwer zaczyna odmawiać. Wygenerujmy plik cookie o kontrolowanej długości.

  1. Utwórz ciąg 8000 znaków. W Linuksie i macOS: BIG=$(head -c 8000 /dev/zero | tr '\0' 'a'). Jeśli powłoka zgłasza błąd escapowania, użyj wariantu BIG=$(python3 -c "print('a'*8000)").
  2. Wyślij żądanie: curl -s -o /dev/null -w '%{http_code}' -H "Cookie: test=$BIG" https://twoja-strona.pl/. Na ekranie pojawi się tylko kod odpowiedzi.
  3. Zmieniaj rozmiar: 4000, 8000, 12000, 16000, 32000, 64000. Zapisz, przy jakiej wartości kod zmienia się z 200 na 400 lub 431.
  4. Jeśli pracujesz przez proxy, dodaj -x http://login:hasło@host:port i powtórz serię. Różnica między progami z proxy i bez niego pokaże, czy limit jest na samym proxy.

Przykład wyszukiwania binarnego progu w jednym poleceniu dla 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://twoja-strona.pl/; echo; done

W Windows PowerShell odpowiednik: $big = 'a' * 16000; curl.exe -s -o NUL -w '%{http_code}' -H "Cookie: t=$big" https://twoja-strona.pl/.

Interpretacja liczb

  • Próg około 8 KB: typowy dla Apache z domyślnymi ustawieniami, Tomcat, Gunicorn, a także dla nginx, gdy nagłówek nie mieści się w jednym buforze z czterech po 8 KB.
  • Próg około 16 KB: Node.js od wersji 13, HAProxy z podstawowym tune.bufsize, IIS.
  • Próg około 32 KB: łączny limit niektórych CDN-ów. Pojedynczy nagłówek jest tam często ograniczony do 16 KB.
  • Próg około 60-64 KB: Envoy i część chmurowych load balancerów.
  • Próg około 1 MB: standardowy serwer Go.

Wskazówka: mierz nie tylko Cookie. Powtórz serię z nagłówkiem Authorization: Bearer $BIG i z kilkoma mniejszymi nagłówkami. Niektóre serwery ograniczają osobno rozmiar jednego pola, osobno ich liczbę i osobno całkowitą objętość. Nginx na przykład domyślnie nie przepuści jednego nagłówka większego niż 8 KB, nawet przy niewielkim łącznym rozmiarze, bo każdy wiersz musi zmieścić się w osobnym buforze.

Weryfikacja: w notatkach powinna pojawić się liczba, przy której serwer zaczyna odmawiać, oraz lista trzech-pięciu najcięższych plików cookie z ich rozmiarami. Jeśli próg nie został znaleziony do 64 KB, a błąd w przeglądarce występuje, to znaczy, że odmawia nie serwer, tylko coś między przeglądarką a serwerem w twoim konkretnym środowisku. Przejdź do następnego kroku.

Krok 3: Ustal, która warstwa odmawia

Cel etapu: dokładnie nazwać węzeł łańcucha, który zwraca błąd lub tnie dane, żeby zmieniać ustawienia właśnie tam.

Czytanie podpisu odpowiedzi

  1. Wykonaj curl -sv -H "Cookie: t=$BIG" https://twoja-strona.pl/ 2>&1 | grep -i -E 'server|via|cf-|x-served|x-cache|HTTP/', gdzie BIG z pewnością przekracza próg.
  2. Odczytaj nagłówek Server. Wartość nginx z treścią Request Header Or Cookie Too Large oznacza, że odmówił nginx. Wartość cloudflare oznacza, że żądanie nie dotarło do twojego serwera. Pusty Server i treść w formacie JSON często wskazuje na aplikację.
  3. Zwróć uwagę na wersję protokołu w pierwszym wierszu. Jeśli przy normalnych żądaniach serwer odpowiada po HTTP/2, a błąd przychodzi po HTTP/1.1, to oznaka, że odpowiedź została wygenerowana przez węzeł pośredniczący, a nie końcowy.
  4. Porównaj treści błędów: strona nginx jest lakoniczna i zawiera jego nazwę na dole; strona Cloudflare zawiera Ray ID; Node.js często zwraca puste ciało ze statusem 431.

Omijanie warstw

  1. Jeśli masz bezpośredni adres IP serwera za CDN, powtórz żądanie z kluczem --resolve twoja-strona.pl:443:1.2.3.4. To zmusi curl do połączenia się bezpośrednio, zachowując prawidłowy Host i SNI. Jeśli bezpośrednio żądanie przechodzi, a przez CDN nie, limit stoi na CDN-ie.
  2. Jeśli masz dostęp do serwera, wykonaj żądanie lokalnie: curl -s -o /dev/null -w '%{http_code}' -H "Cookie: t=$BIG" -H 'Host: twoja-strona.pl' http://127.0.0.1:80/. W ten sposób wykluczasz wszystkie zewnętrzne węzły.
  3. Następnie uderzaj prosto do aplikacji, omijając nginx: curl ... http://127.0.0.1:3000/ dla Node.js lub port, na którym nasłuchuje Gunicorn. Jeśli nginx przepuszcza, a aplikacja odpowiada 431, limit stoi w aplikacji.
  4. Sprawdź wpływ swojego wyjściowego proxy: jedna seria żądań z -x, jedna bez. Dla żądań HTTPS przez proxy używana jest metoda CONNECT, a proxy nie widzi nagłówków wewnątrz szyfrowanego tunelu, więc nie może wpływać na ich rozmiar. Ale dla zwykłych żądań HTTP proxy samo analizuje nagłówki i tu już możliwy jest własny limit, a nawet obcinanie.

Czytanie logów na serwerze

  1. Wykonaj sudo tail -f /var/log/nginx/error.log i powtórz problematyczne żądanie.
  2. Wiersz client sent too long header line potwierdza, że pojedynczy wiersz nagłówka przekroczył bufor nginx. Wiersz client sent too large request mówi o przekroczeniu łącznej objętości.
  3. Dla Apache w error.log szukaj Request header exceeds LimitRequestFieldSize lub Size of a request header field exceeds server limit.
  4. Dla Node.js w logach aplikacji: błąd HPE_HEADER_OVERFLOW, to wewnętrzny kod parsera, który na zewnątrz zamienia się w 431.
  5. W access.log nginx sprawdź pole z rozmiarem żądania. Jeśli używasz standardowego formatu, dodaj do log_format zmienną $request_length: pokaże pełny rozmiar żądania wraz z nagłówkami i będzie przydatna do monitoringu.

Uwaga: jeśli w error.log nginx widzisz upstream sent too big header, to odmawia nie żądanie przychodzące, tylko odpowiedź twojej aplikacji, której nagłówki nie mieszczą się w buforze nginx. Taki przypadek wygląda jak 502, ale należy do naszego tematu. Przyczyna zwykle tkwi w gigantycznym Set-Cookie lub w dziesiątkach nagłówków od frameworka. Rozwiązanie w kroku 6.

Weryfikacja: powinieneś umieć z pewnością powiedzieć jedno z: odmawia CDN; odmawia nginx; odmawia Apache; odmawia aplikacja; odmawia proxy po mojej stronie. Jeśli obraz jest niejednoznaczny, to znaczy, że limit jest przekroczony na kilku węzłach naraz i trzeba będzie poprawiać je wszystkie po kolei, za każdym razem powtarzając test z kroku 2.

Krok 4: Wykryj ciche obcinanie za pomocą endpointu echo

Cel etapu: upewnić się, że nagłówki docierają do aplikacji dokładnie w takiej postaci, w jakiej zostały wysłane, i złapać węzeł, który po cichu je zmienia.

Pomysł jest prosty. Podniesiemy mały serwer, który zwraca w odpowiedzi wszystkie otrzymane nagłówki i ich rozmiary. Wyślemy nagłówek znanej długości z sumą kontrolną i porównamy, co przyszło.

Uruchomienie serwera echo w Pythonie

  1. Utwórz plik echo.py o następującej treści:
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. Uruchom: python3 echo.py. Serwer nasłuchuje na porcie 8089.
  2. Umieść go tam, gdzie stoi twoja prawdziwa aplikacja, albo tymczasowo skieruj na niego jeden location w nginx: location /__echo { proxy_pass http://127.0.0.1:8089; }. Wtedy żądanie przejdzie przez cały rzeczywisty łańcuch.

Weź pod uwagę, że standardowy HTTPServer Pythona nie ma sztywnego limitu na długość nagłówków, ale ogranicza ich liczbę do setki. Do testu to wystarczy.

Wysłanie żądania kontrolnego

  1. Wygeneruj wartość 12000 znaków, ale nie jednorodną, tylko ze znacznikami pozycji, żeby widzieć, od którego miejsca została obcięta: V=$(python3 -c "print(''.join(str(i%10) for i in range(12000)))").
  2. Oblicz referencyjny hash: python3 -c "import hashlib,sys; print(hashlib.sha256(sys.argv[1].encode()).hexdigest()[:12])" "$V".
  3. Wyślij przez cały łańcuch: curl -s -H "Cookie: probe=$V" -H "X-Probe-Len: 12000" https://twoja-strona.pl/__echo.
  4. Porównaj w odpowiedzi pole len dla Cookie z liczbą 12006 (nazwa probe plus znak równości plus 12000 znaków) i hash z referencyjnym.
  5. Powtórz z kilkoma nagłówkami: dodaj 30 nagłówków X-Test-1 ... X-Test-30 i sprawdź pole _count.

Jak czytać wynik

  • Długość się zgadza, hash się zgadza: na tej ścieżce nie ma obcinania.
  • Długość mniejsza, nagłówek urwany: ktoś odciął ogon. Spójrz na ostatni znak otrzymanej wartości: podpowie pozycję cięcia, często to równa granica 4096 lub 8192 bajtów.
  • Nagłówka brak w całości: węzeł odrzucił pole, które nie zmieściło się w buforze. Tak zachowują się niektóre WAF-y i stare bramy.
  • _count mniejszy od wysłanego: osiągnięto limit liczby nagłówków. Apache i Gunicorn domyślnie przyjmują 100 pól, HAProxy 101, a część implementacji odrzuca nadmiarowe po cichu.
  • Długość się zgadza, hash się nie zgadza: węzeł zmienił zawartość. Tak bywa przy normalizacji spacji lub przekodowaniu; sprawdź, czy w wartości nie ma znaków, które proxy uznaje za niedozwolone.

Wskazówka: jeśli pracujesz przez mobilne lub inne zewnętrzne proxy, podnieś serwer echo na publicznie dostępnym hoście i przepuść żądania przez proxy w zwykłym HTTP bez TLS. Właśnie w tym trybie proxy samo analizuje nagłówki i może pokazać swoje limity. W trybie HTTPS przez CONNECT zawartość jest dla proxy nieprzejrzysta i obcinanie na tej warstwie jest fizycznie niemożliwe.

Weryfikacja: masz tabelę: węzeł, wysłano bajtów, otrzymano bajtów, zgodność hasha. Jeśli wszystkie wiersze się zgadzają, cichego obcinania nie ma, a twoje objawy tłumaczą się jawnymi odmowami z kroków 1-3. Jeśli jest rozbieżność, wiesz dokładnie, gdzie.

Osobne sprawdzenie przeglądarki pod kątem Set-Cookie

Przeglądarka też tnie po cichu, ale nie żądanie, tylko odpowiedź. Jeśli serwer wysyła Set-Cookie dłuższe niż około 4096 bajtów, Chrome i Firefox po prostu je ignorują, bez jednego ostrzeżenia. Sprawdź: w zakładce Network znajdź odpowiedź z Set-Cookie, spójrz na długość wiersza, potem otwórz zakładkę Application i upewnij się, że plik cookie się zapisał. Jeśli go nie ma, rozbij wartość na części lub przenieś dane na serwer.

Krok 5: Zmniejsz objętość plików cookie i nagłówków

Cel etapu: usunąć źródło problemu, żeby żądania mieściły się w standardowych limitach i nie zależały od łaski węzłów pośredniczących.

Podniesienie limitów jest kuszące, ale to leczenie objawu. Każdy zbędny kilobajt pliku cookie idzie z każdym żądaniem każdego użytkownika, w tym z żądaniami o obrazki. Zacznij od zmniejszenia.

Audyt plików cookie

  1. Weź listę z kroku 2, posortowaną według rozmiaru.
  2. Dla każdego pliku cookie odpowiedz na trzy pytania: kto go ustawia, czy jest potrzebny serwerowi, czy jest potrzebny na każdej ścieżce strony.
  3. Pliki cookie systemów analitycznych i pikseli reklamowych prawie nigdy nie są potrzebne serwerowi. Nie trzeba ich usuwać, ale nie należy ich wysyłać na domenę API.
  4. Pliki cookie ze zserializowanym stanem (koszyk w JSON, ustawienia interfejsu, historia przeglądania) to kandydaci do przeniesienia do localStorage lub do przechowywania serwerowego z krótkim identyfikatorem.

Techniki zmniejszania

  1. Przenieś API na osobną subdomenę. Pliki cookie ustawione na www.strona.pl bez jawnego Domain nie są wysyłane na api.strona.pl. Ciężkie pliki cookie marketingowe zostaną na witrynie, a API dostanie tylko sesję.
  2. Ustawiaj atrybut Path. Plik cookie z Path=/admin nie pójdzie w żądaniach do /static. Sprawdź, czy twoje frameworki nie ustawiają wszystkich plików cookie na korzeń bez potrzeby.
  3. Przechowuj w pliku cookie identyfikator, a nie dane. Zamiast JSON-a na 3 KB włóż 32-znakowy klucz, a dane trzymaj w Redisie lub bazie. Przy okazji rozwiąże się problem fałszowania zawartości.
  4. Skracaj JWT. Token w pliku cookie lub w Authorization puchnie przez zbędne pola w payloadzie: listę ról, adres, avatar. Zostaw identyfikator i czas życia, resztę pobieraj osobnym wywołaniem. Typowy JWT powinien mieścić się w 500-800 bajtach.
  5. Usuwaj przestarzałe pliki cookie jawnie. Jeśli zmieniłeś nazwę pliku cookie, stary zostanie u użytkowników do wygaśnięcia. Wyślij Set-Cookie ze starą nazwą i Max-Age=0.
  6. Używaj osobnej domeny bez plików cookie dla statyki. Klasyczny zabieg: static.strona.pl lub domena CDN, na której pliki cookie nie są ustawiane w ogóle.
  7. Sprawdź duplikację. Często ten sam plik cookie istnieje w dwóch wariantach: dla strona.pl i dla .strona.pl z kropką. Przeglądarka wyśle oba.

Dla skryptów i automatyzacji

Jeśli zarządzasz wieloma kontami przez proxy i przeglądarki antydetekcyjne, pilnuj profili. Profil żyjący pół roku gromadzi pliki cookie dziesiątek obcych domen, a żądania do docelowej strony zaczynają odmawiać właśnie z powodu rozdmuchanego nagłówka. Skonfiguruj okresowe czyszczenie plików cookie obcych domen, nie ruszając plików cookie autoryzacji docelowej strony. W bibliotekach typu requests lub httpx trzymaj pliki cookie w osobnym CookieJar na konto i raz na dobę usuwaj wpisy z minionym terminem ważności.

Wskazówka: dodaj na kliencie proste sprawdzenie przed żądaniem: jeśli document.cookie.length przekracza 6000 znaków, wyślij metrykę do swojego systemu analitycznego. Tak dowiesz się o problemie od pierwszych użytkowników, a nie od masowych skarg.

Weryfikacja: powtórz pomiar z kroku 2 na czystym profilu, przejdź typowy scenariusz użytkownika (logowanie, katalog, koszyk, zamówienie) i upewnij się, że łączny rozmiar nagłówków nie przekracza 4 KB na API i 8 KB na witrynie. To komfortowy zapas względem wszelkich standardowych limitów.

Krok 6: Skonfiguruj limity na serwerze WWW, load balancerze i w aplikacji

Cel etapu: ustawić spójne limity na wszystkich węzłach, którymi zarządzasz, tak żeby żaden z nich nie był niespodziewanie węższy od sąsiadów.

Złota zasada: limit węzła zewnętrznego powinien być nie większy niż limit węzła wewnętrznego. Inaczej nginx przepuści 32 KB, a Node.js za nim odrzuci z 431 i dostaniesz błąd z głębi stosu, trudniejszy do zdiagnozowania. Rozsądny punkt odniesienia na 2026 rok: 16 KB na cały blok nagłówków i 8-16 KB na pojedyncze pole. To wystarcza niemal wszystkim, a przy tym zostaje ochrona przed nadużyciami.

nginx

  1. Otwórz /etc/nginx/nginx.conf. Znajdź blok http { ... }.
  2. Dodaj lub zmień trzy dyrektywy:
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 to pierwszy mały bufor dla typowych żądań. Domyślna wartość 1k zmusza nginx do przełączania się na duże bufory niemal zawsze, co nie jest groźne, ale 4k zmniejsza zbędne alokacje.
  2. large_client_header_buffers 4 16k oznacza: do czterech buforów po 16 KB. Każdy wiersz nagłówka musi zmieścić się w całości w jednym buforze, a cały blok w sumie buforów. Znaczy to, że pojedynczy plik cookie lub Authorization nie mogą przekraczać 16 KB, a wszystkie nagłówki razem 64 KB.
  3. proxy_buffer_size odpowiada za pierwszą porcję odpowiedzi upstreamu, w tym jego nagłówki. Właśnie jego zwiększenie usuwa 502 z frazą upstream sent too big header. Wartość proxy_buffers powinna być nie mniejsza niż proxy_buffer_size.
  4. Jeśli chcesz, żeby klient widział sensowną odpowiedź zamiast standardowej strony 400, dodaj wewnątrz server: error_page 494 =431 /431.html; i umieść plik 431.html z jasnym tekstem i radą, żeby wyczyścić pliki cookie. Tak zamieniasz niestandardowy 494 na standardowy 431.
  5. Sprawdź składnię: sudo nginx -t. Powinno pojawić się syntax is ok i test is successful.
  6. Zastosuj bez zrywania połączeń: sudo nginx -s reload.

Pamiętaj, że large_client_header_buffers można ustawić także w kontekście server, ale dla HTTP/2 działa wartość z kontekstu http, więc poprawiaj właśnie tam. Dla HTTP/2 istnieje dodatkowo dyrektywa http2_max_header_size w starszych wersjach; w aktualnych buildach została usunięta i wystarcza large_client_header_buffers.

Apache

  1. Otwórz główny konfig i dodaj na poziomie serwera lub VirtualHost:
LimitRequestFieldSize 16384
LimitRequestFields 150
LimitRequestLine 16384
  1. LimitRequestFieldSize ogranicza jedno pole, domyślnie 8190 bajtów. LimitRequestFields ogranicza liczbę pól, domyślnie 100. LimitRequestLine ogranicza wiersz startowy, co jest ważne przy długich URL-ach z parametrami.
  2. Jeśli Apache działa jako reverse proxy przez mod_proxy_http, dodaj ProxyIOBufferSize 32768 dla odpowiedzi z dużymi nagłówkami.
  3. Sprawdź: sudo apachectl configtest, potem sudo systemctl reload apache2.

Node.js

  1. Limit zadaje się przy starcie procesu flagą --max-http-header-size. Wartość w bajtach: node --max-http-header-size=32768 server.js.
  2. Jeśli używasz PM2 lub systemd, podaj flagę w polu node_args lub w zmiennej środowiskowej NODE_OPTIONS=--max-http-header-size=32768.
  3. Alternatywa w kodzie: http.createServer({ maxHeaderSize: 32768 }, app). Ten parametr jest obsługiwany w aktualnych wersjach Node i pozwala ustawić limit bez restartu z nowymi flagami.
  4. Sprawdź po restarcie serią curl prosto na port Node: próg powinien się przesunąć.

Tomcat i Spring Boot

  1. W server.xml w elemencie Connector dodaj atrybut maxHttpHeaderSize="16384". Domyślnie jest tam 8192.
  2. W Spring Boot wystarczy wiersz w application.properties: server.max-http-request-header-size=16KB. Stara nazwa właściwości server.max-http-header-size też działa w niektórych wersjach, ale jest oznaczona jako przestarzała.
  3. Zrestartuj aplikację i sprawdź próg.

Gunicorn i Uvicorn

  1. Dla Gunicorna dodaj w konfigu lub w wierszu polecenia: --limit-request-field_size 16380 --limit-request-fields 150 --limit-request-line 8190. Zwróć uwagę na pisownię field_size z podkreśleniem: to historyczny artefakt, z myślnikiem parametr nie zadziała.
  2. Wartość 0 przy limit-request-field_size zdejmuje ograniczenie całkowicie, ale nie rób tak na publicznych serwerach.
  3. Uvicorn ogranicza rozmiar nagłówków przez parser h11 i domyślnie dopuszcza dość duże wartości; częściej wąskie gardło znajduje się przed nim, w nginx.

HAProxy

  1. W sekcji global: tune.bufsize 32768 i tune.http.maxhdr 150.
  2. Żądanie w całości wraz ze wszystkimi nagłówkami musi zmieścić się w jednym buforze rozmiaru tune.bufsize minus rezerwa tune.maxrewrite. Przy domyślnym 16384 rzeczywista dostępna objętość to około 15 KB.
  3. Sprawdź haproxy -c -f /etc/haproxy/haproxy.cfg i zrestartuj. Weź pod uwagę, że zwiększenie bufsize podnosi zużycie pamięci na każde połączenie.

IIS

  1. Limity żyją w rejestrze w gałęzi HTTP.sys: parametry MaxFieldLength i MaxRequestBytes w kluczu HKLM SYSTEM CurrentControlSet Services HTTP Parameters. Wartości domyślne 16384 bajtów dla obu, maksimum 65534.
  2. Po zmianie wymagany jest restart usługi HTTP lub serwera.
  3. Dodatkowo sprawdź maxAllowedContentLength i maxQueryString w requestFiltering, jeśli problem dotyczy długich URL-i.

CDN i WAF

U większości chmurowych CDN-ów limity są stałe w podstawowych planach i zmieniane tylko w korporacyjnych. Jeśli próg z kroku 3 opiera się o CDN, jedyna uniwersalna droga to zmniejszenie plików cookie z kroku 5. Dodatkowo sprawdź, czy na WAF-ie nie jest ustawiony tryb, w którym duże nagłówki nie są blokowane, tylko wycinane: taki tryb tworzy właśnie to ciche obcinanie i lepiej przełączyć go na jawną odmowę z kodem.

Uwaga: nie ustawiaj limitów w megabajtach dla spokoju. Każdy kilobajt bufora mnoży się przez liczbę równoczesnych połączeń, a atakujący może celowo wysyłać gigantyczne nagłówki, żeby wyczerpać pamięć. Trzymaj rozsądny zapas dwa-trzy razy od rzeczywistego maksimum i nie więcej.

Weryfikacja: powtórz serię curl z kroku 2 dla każdego węzła osobno (prosto do aplikacji, przez nginx, z zewnątrz przez CDN). Progi powinny albo się zgadzać, albo maleć od wewnętrznego do zewnętrznego. Upewnij się, że przy przekroczeniu każdy węzeł zwraca zrozumiały kod, a nie zrywa połączenia.

Krok 7: Uczyń odmowy jawnymi i skonfiguruj monitoring

Cel etapu: wykluczyć ciche obcinanie w przyszłości i dowiadywać się o wzroście nagłówków, zanim uderzą w limit.

Jawne odpowiedzi zamiast ciszy

  1. Upewnij się, że każdy twój węzeł przy przekroczeniu limitu zwraca 431 lub przynajmniej 400 z tekstem. W nginx jest to już zrobione w kroku 6 przez error_page 494.
  2. Jeśli masz samodzielnie pisane proxy lub bramę na stałym buforze, dodaj sprawdzenie: jeśli nagłówek się nie zmieścił, odpowiadaj 431 i zamykaj połączenie. Nigdy nie przekazuj dalej uciętej wartości.
  3. W aplikacji dodaj walidację krytycznych nagłówków. Na przykład jeśli JWT się nie parsuje lub plik cookie sesji jest krótszy od oczekiwanej długości, loguj to osobnym zdarzeniem z adnotacją possible truncation. To tani detektor problemów na dowolnym zewnętrznym węźle.

Logowanie rozmiarów

  1. W nginx rozszerz format logu. W bloku 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. Prosty i niezawodny wariant bez map: loguj tylko $request_length. Ta zmienna wystarczy, żeby widzieć wzrost.
  2. Raz na dobę wykonaj awk po access.log i znajdź maksimum i 99. percentyl req_len. Jeśli 99. percentyl przekroczył połowę limitu, czas wyczyścić pliki cookie.
  3. Dla Apache użyj w LogFormat zmiennej %I z mod_logio: pokazuje bajty przychodzące wraz z nagłówkami.

Alerty

  1. Załóż metrykę liczby odpowiedzi 431 i 400 z treścią o plikach cookie. W Prometheusie z nginx-exporterem to statusy z access.log; w chmurowych panelach monitoringu zwykle jest rozbicie na kody.
  2. Ustaw próg: więcej niż 10 takich odpowiedzi w 5 minut to sygnał. Masowy błąd 431 prawie zawsze oznacza, że ktoś wypuścił nowy ciężki plik cookie.
  3. Dodaj sprawdzenie syntetyczne: raz na godzinę skrypt wysyła żądanie z nagłówkiem na 90 procent limitu i sprawdza, że przechodzi, a z nagłówkiem na 110 procent sprawdza, że zwracane jest właśnie 431. Tak złapiesz i przypadkowe zaostrzenie limitu, i przypadkowe jego zdjęcie.

Wskazówka: trzymaj endpoint echo z kroku 4 na stałe, zamknięty po IP lub prostą autoryzacją. Przyda się przy każdej zmianie infrastruktury: dodaliście WAF, zmieniliście load balancer, podłączyliście nową pulę proxy, a w minutę można upewnić się, że nagłówki docierają w całości.

Weryfikacja: wyślij z pewnością duże żądanie i upewnij się, że trafiło do logu z prawidłowym rozmiarem, że licznik 431 się zwiększył i że alert zadziałał przy nakręceniu progu. Potem przywróć progi do roboczych wartości.

Sprawdzenie wyniku

Przejdź przez listę kontrolną. Każdy punkt powinien być spełniony, inaczej wróć do odpowiedniego kroku.

Lista kontrolna

  • Problematyczna strona z kroku 1 otwiera się bez błędów w głównym profilu przeglądarki.
  • Łączny rozmiar nagłówków typowego żądania nie przekracza 8 KB, a na domenie API 4 KB.
  • Żaden plik cookie nie przekracza 2 KB, najcięższe obce pliki cookie nie są wysyłane na API.
  • Próg odmowy na każdym węźle jest znany i zapisany; limity maleją lub są równe od aplikacji do zewnętrznego brzegu.
  • Przy przekroczeniu limitu klient otrzymuje kod 431 lub 400 z tekstem, a nie zerwanie połączenia i nie po cichu ucięte żądanie.
  • Endpoint echo pokazuje zgodność długości i hasha przy wysyłce przez cały łańcuch, w tym przez twoje proxy.
  • W access.log jest rozmiar żądania, skonfigurowany alert na wzrost 431.
  • Kopie zapasowe konfigów leżą obok, a ty znasz polecenie wycofania.

Jak przetestować całość

  1. Wyczyść pliki cookie dla testowej domeny i przejdź scenariusz użytkownika od logowania do kluczowej akcji. Błędów być nie powinno.
  2. Uruchom pętlę curl z kroku 2 z zewnątrz. Zapisz próg; powinien odpowiadać twoim nowym ustawieniom.
  3. Wyślij żądanie kontrolne na endpoint echo przez każdą używaną ścieżkę: bezpośrednio, przez CDN, przez pulę proxy.
  4. Celowo wyślij nagłówek dwukrotnie większy od limitu i upewnij się, że otrzymujesz 431 z jasną treścią.
  5. Sprawdź, że odpowiedzi aplikacji z dużymi Set-Cookie nie powodują 502 u nginx.

Wskaźniki sukcesu

Udział odpowiedzi 431 i 400 z tekstem o nagłówkach dąży do zera w zwykłym ruchu. 99. percentyl rozmiaru żądania jest mniejszy niż połowa najwęższego limitu. Wylogowania bez powodu i utracone sesje przestają pojawiać się w zgłoszeniach użytkowników.

Typowe błędy i rozwiązania

Zwiększyliśmy limit w nginx, a 431 został

Przyczyna: za nginx stoi Node.js lub Tomcat ze swoim limitem 8-16 KB i teraz odmawia właśnie on. Rozwiązanie: sprawdź próg prosto na porcie aplikacji z kroku 3 i podnieś go flagą --max-http-header-size lub maxHttpHeaderSize. Potem upewnij się, że limit nginx nie jest większy niż limit aplikacji.

Ustawiliśmy large_client_header_buffers w bloku server, ale nic się nie zmieniło

Przyczyna: dla HTTP/2 nginx używa wartości z kontekstu http, a dyrektywa nie jest dziedziczona tak, jak się oczekuje, jeśli jest zadana w kilku server dla jednego adresu. Rozwiązanie: przenieś dyrektywę do bloku http i przeładuj konfig.

Błąd pojawia się tylko u części użytkowników

Przyczyna: rozmiar plików cookie zależy od historii konkretnego użytkownika: odwiedzonych sekcji, włączonych eksperymentów, starych plików cookie z poprzednich wersji strony. Rozwiązanie: zbierz statystyki rozmiarów przez $request_length, znajdź, które pliki cookie rosną, i jawnie usuwaj przestarzałe przez Set-Cookie z Max-Age=0.

Po wyczyszczeniu plików cookie wszystko działa, ale po tygodniu znowu się psuje

Przyczyna: źródło wzrostu nie zostało usunięte: na przykład skrypt analityczny przy każdej wizycie dopisuje dane do jednego pliku cookie. Rozwiązanie: znajdź plik cookie, który rośnie, przez sortowanie według rozmiaru w różnych dniach, i przenieś jego zawartość do localStorage lub ogranicz po stronie dostawcy skryptu.

Nginx zwraca 502, chociaż aplikacja żyje

Przyczyna: w error.log fraza upstream sent too big header: nagłówki odpowiedzi aplikacji nie zmieściły się w proxy_buffer_size. Zwykle winny jest ogromny Set-Cookie lub mnóstwo nagłówków debugowych. Rozwiązanie: zwiększ proxy_buffer_size do 16k i proxy_buffers do 8 16k, a w aplikacji skróć nagłówki odpowiedzi.

Przez proxy żądanie po HTTP gubi część nagłówków, a po HTTPS przechodzi

Przyczyna: dla HTTP proxy samo analizuje nagłówki i opiera się o swój bufor, a dla HTTPS przez CONNECT zawartość jest nieprzejrzysta i przechodzi nietknięta. Rozwiązanie: przejdź na HTTPS dla docelowego zasobu lub skróć nagłówki. Jeśli proxy jest twoje własne, podnieś jego limit i skonfiguruj jawną odmowę zamiast obcinania.

Przeglądarka nie zapisuje pliku cookie po odpowiedzi serwera

Przyczyna: wiersz Set-Cookie jest dłuższy niż 4096 bajtów lub łączna liczba plików cookie na domenę przekroczyła limit przeglądarki (około 180 w Chrome), i po cichu odrzuciła nowy albo wyparła stary. Rozwiązanie: przechowuj w pliku cookie tylko identyfikator, a dane trzymaj na serwerze; nie twórz dziesiątek drobnych plików cookie, łącz je.

Gunicorn ignoruje parametr limitu

Przyczyna: parametr jest napisany z myślnikiem jako limit-request-field-size, a prawidłowa nazwa zawiera podkreślenie: limit-request-field_size. Rozwiązanie: popraw pisownię i zrestartuj workery.

Dodatkowe możliwości

Różne limity dla różnych ścieżek

Nie trzeba podnosić limitu dla całej strony. Jeśli ciężkie nagłówki są potrzebne tylko na jednej ścieżce, na przykład przy przesyłaniu plików z długimi metadanymi, w nginx można wyodrębnić tę ścieżkę do osobnego server na osobnej nazwie lub porcie ze zwiększonymi large_client_header_buffers, a główną stronę zostawić surową. Tak zachowujesz ochronę przed nadużyciami tam, gdzie jest ważniejsza.

Kompresja nagłówków w HTTP/2 i HTTP/3

Protokoły HTTP/2 i HTTP/3 kompresują nagłówki algorytmami HPACK i QPACK. W sieci powtarzające się pliki cookie idą kompaktowo, ale na serwerze są rozpakowywane do pełnego rozmiaru, a limity stosuje się właśnie do rozpakowanych danych. Dlatego włączenie HTTP/2 oszczędza ruch, ale nie ratuje przed 431. Parametr SETTINGS_MAX_HEADER_LIST_SIZE, który serwer ogłasza klientowi, zadaje górną granicę rozpakowanej listy; w nginx jest obliczany z large_client_header_buffers automatycznie.

Dzielone pliki cookie

Niektóre biblioteki autoryzacji potrafią rozbić długą wartość na kilka plików cookie z sufiksami .0, .1, .2 i złożyć z powrotem na serwerze. To rozwiązuje problem limitu przeglądarki na jeden plik cookie 4 KB, ale nie zmniejsza łącznego rozmiaru nagłówka Cookie. Używaj tego zabiegu tylko jako środka tymczasowego przy przechodzeniu na serwerowe przechowywanie sesji.

Sesje na serwerze zamiast plików cookie-kontenerów

Najbardziej niezawodne rozwiązanie architektoniczne: w pliku cookie zostaje tylko losowy identyfikator długości 32-64 znaków, a cały stan leży w Redisie z TTL. Nagłówek Cookie rzadko przekracza wtedy 200 bajtów i cały temat limitów przestaje być aktualny. Przeprowadzka zajmuje od jednego dnia dla małej aplikacji do kilku tygodni dla dużej, ale zwraca się zmniejszeniem ruchu i uproszczeniem bezpieczeństwa.

Automatyczne sprawdzenie w CI

Dodaj do pipeline'u test: podnieś aplikację, wyślij żądanie z nagłówkami na 90 procent zadeklarowanego limitu i sprawdź kod 200, potem na 120 procent i sprawdź kod 431. Test zajmie sekundy i nie pozwoli przypadkowo zwęzić limitu przy aktualizacji frameworka, gdy zmieniają się wartości domyślne.

Praca z pulą proxy

Jeśli używasz kilku serwerów proxy lub mobilnej puli z rotacją, przepuść żądanie kontrolne na endpoint echo przez każde wyjście po HTTP i po HTTPS. Wyniki zapisz w tabeli. Tak wykryjesz wyjścia o niestandardowym zachowaniu i będziesz mógł albo je wykluczyć, albo wysyłać przez nie tylko ruch HTTPS, gdzie obcinanie jest niemożliwe.

FAQ

Czym różni się 431 od 494, skoro oba dotyczą dużych nagłówków?

431 to standardowy kod ze specyfikacji HTTP, rozumieją go wszyscy klienci i narzędzia monitoringu. 494 to wewnętrzny kod nginx, który domyślnie na zewnątrz zamienia się w 400 z tekstem Request Header Or Cookie Too Large. Dla użytkownika nie ma różnicy, ale dla diagnozy 494 w logach lub w error_page jednoznacznie wskazuje nginx jako źródło.

Czy można po prostu ustawić bardzo duży limit i zapomnieć?

Technicznie tak, ale tak zwiększysz zużycie pamięci na każde połączenie i ułatwisz ataki z gigantycznymi nagłówkami. Poza tym limitów CDN-ów i przeglądarek nie kontrolujesz i problem po prostu przeniesie się tam. Właściwa kolejność: najpierw zmniejszyć pliki cookie, potem ustawić umiarkowany limit z zapasem.

Dlaczego w incognito wszystko działa, a w zwykłym trybie jest błąd?

W incognito nie ma nagromadzonych plików cookie. To prawie stuprocentowa oznaka, że przyczyna tkwi w rozmiarze nagłówka Cookie u konkretnego użytkownika. Wyczyszczenie plików cookie dla domeny rozwiąże problem jednorazowo, a krok 5 rozwiąże go na zawsze.

Jak zmierzyć rozmiar nagłówków, jeśli nie ma dostępu do serwera?

Użyj panelu deweloperskiego: zakładka Application pokazuje rozmiar każdego pliku cookie, a polecenie document.cookie.length w konsoli daje łączną długość plików cookie dostępnych skryptom. Dla dokładnego progu odmowy wysyłaj curl ze sztucznie dużym nagłówkiem i patrz na kod odpowiedzi.

Czy moje proxy może obcinać nagłówki w żądaniach HTTPS?

Nie. Przy HTTPS przez proxy używana jest metoda CONNECT, a proxy przekazuje zaszyfrowany strumień bajtów, nie widząc jego zawartości. Obciąć lub zmienić nagłówki w środku fizycznie nie może. Natomiast dla zwykłych żądań HTTP proxy samo analizuje nagłówki i tu możliwe są i limity, i obcinanie.

Jak poznać, że nagłówek został obcięty, jeśli nie ma błędu?

Podnieś endpoint echo z kroku 4, wyślij nagłówek znanej długości ze znacznikami pozycji i porównaj długość oraz hash otrzymanej wartości z wysłaną. Rozbieżność pokaże i fakt obcięcia, i pozycję cięcia.

Nginx przepuszcza, a aplikacja na Node.js odpowiada 431. Co robić?

Podnieść limit Node.js flagą --max-http-header-size lub parametrem maxHeaderSize w createServer, a następnie doprowadzić limit nginx do tej samej lub mniejszej wartości, żeby odmowa następowała na zewnętrznej warstwie z jasną stroną.

Co ważniejsze ograniczyć: rozmiar jednego nagłówka czy łączny rozmiar?

I jedno, i drugie. Łączny rozmiar chroni pamięć, a limit na jedno pole chroni parsery. W nginx oba limity wynikają z large_client_header_buffers: rozmiar bufora to limit na wiersz, a liczba buforów pomnożona przez rozmiar to limit łączny.

Czy warto przechwytywać 431 na kliencie i automatycznie czyścić pliki cookie?

Dla własnej strony to świetny zabieg: po otrzymaniu 431 lub 400 z właściwym tekstem frontend usuwa z pewnością nieobowiązkowe pliki cookie i powtarza żądanie. Nie usuwaj plików cookie autoryzacji bez zgody użytkownika i koniecznie loguj takie zdarzenia, żeby usunąć źródło problemu.

Jak upewnić się, że nowa wersja frameworka nie zmieniła domyślnego limitu?

Trzymaj sprawdzenie syntetyczne z kroku 7 i test w CI z sekcji dodatkowych możliwości. Oba wysyłają żądania na granicy limitu i od razu pokażą, jeśli próg się przesunął w którąkolwiek stronę.

Zakończenie

Podsumujmy, co zrobiłeś. Nauczyłeś się odtwarzać błąd i odróżniać 431, 494 i jego publiczne oblicze w postaci 400 po podpisie odpowiedzi. Zmierzyłeś rzeczywisty rozmiar nagłówków i plików cookie i znalazłeś próg odmowy przez wyszukiwanie binarne z curlem. Ustaliłeś, który węzeł łańcucha odpowiada za odmowę, i oddzieliłeś ten problem od kodów warstwy proxy w rodzaju 407, 502 i 504, zostawiając sobie przydatny znacznik o upstream sent too big header. Za pomocą endpointu echo złapałeś lub wykluczyłeś ciche obcinanie, które nie zostawia śladów w logach. Potem zmniejszyłeś pliki cookie, przeniosłeś API na czystą domenę, uzgodniłeś limity w nginx, Apache, Node.js, Tomcat, Gunicorn i HAProxy, uczyniłeś odmowy jawnymi i podłączyłeś monitoring.

Co dalej. W najbliższym tygodniu poobserwuj metrykę rozmiaru żądań i licznik 431: pokażą, czy nie zostało źródło wzrostu plików cookie. Ustal zasadę dla zespołu: każdy nowy plik cookie przechodzi review z pytaniami o rozmiar, domenę i ścieżkę. Jeśli projekt używa sesji w pliku cookie w formie zserializowanego stanu, zaplanuj przeprawę na przechowywanie serwerowe z krótkim identyfikatorem.

Kierunki rozwoju. Następny poziom to głębokie zrozumienie kompresji nagłówków w HTTP/2 i HTTP/3, precyzyjne dostrajanie buforów pod obciążenie i budowa przejrzystej warstwy obserwowalności, w której rozmiar każdego żądania widać w trace'u. Warto też zbadać, jak zachowują się limity przy pracy przez różne typy proxy i load balancerów, i zebrać własną tabelę progów dla infrastruktury, z którą pracujesz. Narzędzia zebrane w tym przewodniku, w tym endpoint echo i pętla curl, zostaną z tobą i będą oszczędzać godziny przy każdej kolejnej dziwnej odmowie. Udało ci się, a ta kategoria problemów przestała być zagadką.