วิธีแก้ข้อผิดพลาด 431 และ 494 พร้อมการตัด header แบบเงียบ: คู่มือทีละขั้นตอนสำหรับการวินิจฉัยและตั้งค่าขีดจำกัด
บทความ
- บทนำ
- การเตรียมการเบื้องต้น
- แนวคิดพื้นฐาน
- ขั้นตอนที่ 1: ทำซ้ำปัญหาและบันทึกอาการ
- ขั้นตอนที่ 2: วัดขนาดจริงของ header และ cookie
- ขั้นตอนที่ 3: พิจารณาว่าชั้นใดปฏิเสธ
- ขั้นตอนที่ 4: ตรวจจับการตัดแบบเงียบด้วยเอ็นด์พอยต์สะท้อนกลับ
- ขั้นตอนที่ 5: ลดปริมาณ cookie และ header
- ขั้นตอนที่ 6: ตั้งค่าขีดจำกัดบนเว็บเซิร์ฟเวอร์ ตัวโหลดบาลานซ์ และแอปพลิเคชัน
- ขั้นตอนที่ 7: ทำให้การปฏิเสธชัดเจนและตั้งค่าการมอนิเตอร์
- การตรวจสอบผลลัพธ์
- ข้อผิดพลาดทั่วไปและวิธีแก้ไข
- ความสามารถเพิ่มเติม
- คำถามที่พบบ่อย
- บทสรุป
บทนำ
คู่มือนี้มุ่งเน้นไปที่กลุ่มปัญหาที่แคบแต่ร้ายกาจมากกลุ่มหนึ่ง: คำขอไม่ผ่านหรือผ่านเพียงบางส่วนเพราะ header หรือ cookie ของมันใหญ่เกินไป เมื่อมองจากภายนอกจะดูเหมือนข้อผิดพลาด 431 Request Header Fields Too Large ข้อผิดพลาดรหัส 494 Request Header Too Large ที่เฉพาะเจาะจงสำหรับ nginx ข้อผิดพลาด 400 Request Header Or Cookie Too Large ที่อ่านไม่ค่อยรู้เรื่อง หรือในกรณีที่แย่ที่สุดก็ไม่ปรากฏอาการใดๆ เลย: โหนดกลางบางตัวทิ้ง header บางส่วนไปอย่างเงียบๆ และแอปพลิเคชันได้รับผู้ใช้ที่ไม่มีเซสชัน ไม่มีโทเค็นการอนุญาต หรือไม่มี cookie ที่จำเป็น
สิ่งสำคัญคือต้องแยกออกจากหัวข้อข้างเคียงทันที ในบทความแยกต่างหากเราได้วิเคราะห์รหัส 407, 502 และ 504 ซึ่งเป็นรหัสที่ชั้นพร็อกซีส่งออกมาเองเมื่อสร้างอุโมงค์: การตรวจสอบสิทธิ์ที่พร็อกซีไม่ผ่าน, upstream ไม่ทำงาน, หมดเวลารอ ในกรณีนั้นปัญหาอยู่ที่การเชื่อมต่อและตัวพร็อกซีเอง แต่ตรงนี้การเชื่อมต่อถูกสร้างขึ้นอย่างปกติ อุโมงค์มีอยู่ แต่ข้อมูลที่คุณพยายามส่งผ่านมันไม่พอดีกับบัฟเฟอร์ของโหนดใดโหนดหนึ่งในห่วงโซ่ สาเหตุอยู่ที่ปริมาณและองค์ประกอบของ header เสมอ และรักษาด้วยเครื่องมือที่แตกต่างไปเลย
สิ่งที่คุณจะได้รับในที่สุด
- ความสามารถในการวัดขนาด header และ cookie ของคำขอเฉพาะได้อย่างแม่นยำภายในไม่กี่นาที
- ความเข้าใจว่าโหนดใดในห่วงโซ่ (เบราว์เซอร์หรือไคลเอนต์, พร็อกซี, ตัวโหลดบาลานซ์, เว็บเซิร์ฟเวอร์, แอปพลิเคชัน) เป็นผู้ปฏิเสธหรือตัดข้อมูล
- เอ็นด์พอยต์สะท้อนกลับพร้อมใช้งานสำหรับตรวจจับการตัดแบบเงียบโดยไม่มีรหัสข้อผิดพลาดแม้แต่ตัวเดียว
- การตั้งค่าขีดจำกัดที่ใช้งานได้จริงสำหรับ nginx, Apache, Node.js, HAProxy, Tomcat และ Gunicorn พร้อมคำอธิบายแต่ละพารามิเตอร์
- กลยุทธ์การลด cookie เพื่อไม่ให้ปัญหากลับมาอีกในเดือนหน้า
- การมอนิเตอร์ที่จะส่งสัญญาณเตือนเมื่อใกล้ถึงขีดจำกัดล่วงหน้า
คู่มือนี้เหมาะกับใคร
สำหรับนักพัฒนาเว็บ ผู้ดูแลระบบ ผู้เชี่ยวชาญด้านการดึงข้อมูลและระบบอัตโนมัติ รวมถึงผู้ที่ทำงานกับบัญชีจำนวนมากผ่านพร็อกซีและเจอการปฏิเสธที่ไม่เข้าใจบ่อยครั้ง ระดับความยากปานกลาง: คุณไม่จำเป็นต้องเป็นผู้เชี่ยวชาญด้านโปรโตคอล HTTP แต่ทักษะพื้นฐานในการใช้เทอร์มินัลและความเข้าใจว่าไฟล์กำหนดค่าคืออะไรนั้นจำเป็น
สิ่งที่ต้องรู้ล่วงหน้า
- วิธีเปิดเทอร์มินัลและรันคำสั่ง
- วิธีเปิดแผงนักพัฒนาในเบราว์เซอร์ (ปุ่ม F12)
- ไฟล์กำหนดค่าของเว็บเซิร์ฟเวอร์ของคุณอยู่ที่ไหน หากคุณดูแลมัน
- ความเข้าใจโดยทั่วไปว่าคำขอเดินทางจากไคลเอนต์ผ่านโหนดกลางไปยังเซิร์ฟเวอร์
ต้องใช้เวลามากแค่ไหน
การวินิจฉัยตามขั้นตอนที่ 1-4 ใช้เวลา 30 ถึง 60 นาที การแก้ไขฝั่งเซิร์ฟเวอร์ (ขั้นตอนที่ 5-7) จะใช้เวลาอีก 1-2 ชั่วโมงรวมการรีสตาร์ทและการตรวจสอบ หากคุณเพียงตรวจสอบบริการของผู้อื่นและไม่มีสิทธิ์เข้าถึงการตั้งค่าของมัน สี่ขั้นตอนแรกและส่วนเกี่ยวกับการลด cookie ก็เพียงพอสำหรับคุณ
การเตรียมการเบื้องต้น
ไม่ต้องใช้อะไรแปลกใหม่ แต่เตรียมเครื่องมือไว้ล่วงหน้าเพื่อไม่ให้วอกแวกในระหว่างกระบวนการ
เครื่องมือที่จำเป็น
- curl เวอร์ชัน 7.70 หรือใหม่กว่า มีอยู่ใน macOS, ทุกดิสทริบิวชันของ Linux และใน Windows 10 และ 11 ในตัว ตรวจสอบด้วยคำสั่ง
curl --version - เบราว์เซอร์ ที่มีแผงนักพัฒนา: Chrome, Edge, Firefox หรือ Яндекс เบราว์เซอร์ ต้องใช้แท็บ Network (เครือข่าย) และแท็บ Application หรือ Storage เพื่อดู cookie
- โปรแกรมแก้ไขข้อความ ที่มีไฮไลต์: VS Code, Notepad++ หรือ nano ในตัวบนเซิร์ฟเวอร์
- การเข้าถึงผ่าน SSH ไปยังเซิร์ฟเวอร์ หากคุณจะเปลี่ยนขีดจำกัด สิทธิ์ในการอ่าน log และรีสตาร์ทบริการเป็นสิ่งจำเป็น
- Python 3 หรือ Node.js สำหรับรันเอ็นด์พอยต์สะท้อนกลับ เวอร์ชันปัจจุบันใดก็ได้เพียงพอ
- ไม่บังคับ: mitmproxy หรือตัววิเคราะห์ในตัวในเบราว์เซอร์ต้านการตรวจจับ หากคุณต้องการดูทราฟฟิกระหว่างไคลเอนต์และพร็อกซี
ข้อกำหนดของระบบ
เครื่องทำงานใดก็ได้ สำหรับเซิร์ฟเวอร์สะท้อนกลับหน่วยความจำ 100 MB ก็เพียงพอ ข้อกำหนดจริงข้อเดียว: การเข้าถึงเครือข่ายไปยังบริการที่ตรวจสอบ และหากจำเป็น ไปยังพร็อกซีที่ใช้
สิ่งที่ต้องดาวน์โหลดและตั้งค่า
- ตรวจสอบให้แน่ใจว่า curl ทำงาน: รัน
curl -sI https://example.comคุณควรเห็นบรรทัด header ของการตอบกลับ เริ่มต้นด้วยHTTP/2 200หรือคล้ายกัน - หากทำงานผ่านพร็อกซี เตรียมที่อยู่ พอร์ต ชื่อผู้ใช้ และรหัสผ่าน ตรวจสอบการเชื่อมต่อพื้นฐานด้วยคำสั่ง
curl -x http://логин:пароль@host:port -sI https://example.comหากที่นี่เกิดข้อผิดพลาด 407 หรือเชื่อมต่อไม่ได้เลย ให้กลับไปที่บทความเกี่ยวกับรหัสชั้นพร็อกซี: หัวข้อของเราเริ่มต้นหลังอุโมงค์สำเร็จเท่านั้น - บนเซิร์ฟเวอร์ ค้นหาไฟล์กำหนดค่าหลัก: สำหรับ nginx มักจะเป็น
/etc/nginx/nginx.confและโฟลเดอร์/etc/nginx/conf.d/สำหรับ Apache/etc/apache2/apache2.confหรือ/etc/httpd/conf/httpd.conf - ค้นหา log:
/var/log/nginx/error.log,/var/log/nginx/access.log,/var/log/apache2/error.logตรวจสอบว่าคุณสามารถอ่านได้ด้วยคำสั่งtail -n 50
การสำรองข้อมูล
ก่อนแก้ไขไฟล์กำหนดค่าใดๆ ให้สำรองข้อมูลก่อน ใช้เวลาไม่กี่วินาทีและช่วยประหยัดเวลาได้หลายชั่วโมง
- รัน
sudo cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak-2026 - สำหรับโฟลเดอร์เว็บไซต์:
sudo cp -r /etc/nginx/conf.d /etc/nginx/conf.d.bak-2026 - สำหรับ Apache เช่นเดียวกัน:
sudo cp /etc/apache2/apache2.conf /etc/apache2/apache2.conf.bak-2026 - บันทึกค่าขีดจำกัดปัจจุบันลงในไฟล์บันทึกแยก เพื่อให้เข้าใจว่าคุณเริ่มจากตรงไหน
ข้อควรระวัง: อย่าแก้ไขไฟล์กำหนดค่าที่ใช้งานจริงโดยไม่ตรวจสอบไวยากรณ์ก่อน สำหรับ nginx คือ sudo nginx -t สำหรับ Apache คือ sudo apachectl configtest ข้อผิดพลาดในบรรทัดเดียวเมื่อรีสตาร์ทจะทำให้บริการล่ม
แนวคิดพื้นฐาน
ก่อนจะจับปัญหา มาตกลงเรื่องคำศัพท์กันก่อน ไม่มีอะไรซับซ้อน แต่ความสับสนในคำศัพท์มักนำการวินิจฉัยไปผิดทาง
header ของคำขอคืออะไร
คำขอ HTTP ใดๆ ประกอบด้วยบรรทัดเริ่มต้น (เมธอด, พาธ, เวอร์ชันโปรโตคอล) บล็อก header และเนื้อหาที่ไม่บังคับ header คือคู่ในรูปแบบ ชื่อ: ค่า เบราว์เซอร์เพิ่ม它們โดยอัตโนมัติ: Host, User-Agent, Accept, Accept-Language, Referer, Authorization และแน่นอน Cookie แอปพลิเคชันเพิ่มของตัวเอง: โทเค็น ตัวระบุการติดตาม สัญญาณการทดลอง
ทำไม cookie จึงเป็นตัวการบ่อยที่สุด
header Cookie ถูกประกอบขึ้นจาก cookie ทั้งหมดที่ตรงกับโดเมนและพาธของคำขอ ระบบวิเคราะห์แต่ละระบบ วิดเจ็ตแชทแต่ละตัว เครือข่ายโฆษณาแต่ละแห่งเพิ่มหลายชิ้น ค่าของ cookie หนึ่งชิ้นอาจยาวถึง 4 KB และ cookie แบบนี้บนโดเมนมีเป็นสิบๆ พร้อมกันนั้นเบราว์เซอร์ส่ง它們ไปกับทุกคำขอ รวมถึงรูปภาพและฟอนต์ เป็นผลให้ header Cookie เติบโตเกิน 8-16 KB ได้ง่าย ซึ่งเป็นเกณฑ์ที่เซิร์ฟเวอร์ส่วนใหญ่ตั้งไว้เป็นค่าเริ่มต้น
รหัส 431
431 Request Header Fields Too Large เป็นรหัสมาตรฐานที่อธิบายไว้ในข้อกำหนด HTTP เซิร์ฟเวอร์แจ้งว่า: header ใหญ่เกินไป ไม่ว่าจะเป็นตัวใดตัวหนึ่งหรือทั้งหมดรวมกัน รหัสนี้ถูกส่งโดย Node.js, Go, Envoy, CDN บางแห่ง และเฟรมเวิร์กสมัยใหม่ การตอบกลับด้วย 431 ถูกต้องตามโปรโตคอลและมองเห็นได้ชัดใน log จึงเป็นตัวเลือกที่สะดวกที่สุดสำหรับการวินิจฉัย
รหัส 494
494 Request Header Too Large เป็นรหัสภายในที่ไม่เป็นมาตรฐานของ nginx nginx ใช้มันในโค้ดของตัวเองเมื่อ header ไม่พอดีกับบัฟเฟอร์ที่กำหนดโดยไดเรกทีฟ large_client_header_buffers ในขณะเดียวกันไคลเอนต์จะได้รับ 400 พร้อมเนื้อหา Request Header Or Cookie Too Large เป็นค่าเริ่มต้น การเห็นเลข 494 นั้นเกิดขึ้นได้ในสองกรณี: หากผู้ดูแลระบบระบุ error_page 494 ไว้อย่างชัดเจน หรือหากคุณอ่านตัวแปรและ log ภายในของ nginx ดังนั้นหากผู้ใช้บ่นเกี่ยวกับหน้าจอขาวที่มีข้อความ 400 และคำเกี่ยวกับ cookie ให้รู้ไว้ว่า: นั่นคือ 494 ตัวเดียวกัน
การตัดแบบเงียบ
สถานการณ์ที่แย่ที่สุด โหนดกลางไม่ปฏิเสธคำขอ แต่ตัด header ตามขนาดบัฟเฟอร์ของมัน หรือทิ้ง header บางส่วนทั้งหมด แอปพลิเคชันได้รับข้อมูลที่ไม่สมบูรณ์ อาการมีหลากหลาย: ผู้ใช้ถูกล็อกเอาท์กะทันหัน ตะกร้าสินค้าหาย โทเค็นอ่านไม่ได้ header ที่มีตัวระบุภูมิภาคหายไป ไม่มีรหัสข้อผิดพลาด ใน log ของเว็บเซิร์ฟเวอร์ทุกอย่างเป็นสีเขียว พฤติกรรมแบบนี้พบได้ในพร็อกซีที่เขียนเองบนบัฟเฟอร์คงที่ ในเกตเวย์องค์กรเก่า ใน WAF บางตัวในโหมดประมวลผลแบบอ่อน ในไลบรารีไคลเอนต์ที่แบ่งหรือตัดค่าที่ยาว รวมถึงในเบราว์เซอร์เองที่เพิกเฉยต่อ Set-Cookie ที่ยาวเกิน 4096 ไบต์อย่างเงียบๆ
ขีดจำกัดอยู่ที่ไหนบ้าง
ลองจินตนาการถึงห่วงโซ่: เบราว์เซอร์หรือสคริปต์ จากนั้นพร็อกซีขาออกของคุณ (เช่น มือถือ) จากนั้น CDN หรือ WAF จากนั้นตัวโหลดบาลานซ์ จากนั้นเว็บเซิร์ฟเวอร์ จากนั้นเซิร์ฟเวอร์แอปพลิเคชัน แต่ละจุดเชื่อมมีขีดจำกัดและพฤติกรรมของตัวเองเมื่อเกิน งานของการวินิจฉัยคือการหาจุดที่แคบที่สุด นั่นคือเหตุผลที่เพียงเพิ่มขีดจำกัดใน nginx มักไม่เพียงพอ: ข้างหลังมี Node.js ที่มีเกณฑ์ 16 KB ของตัวเอง
เส้นแบ่งกับข้อผิดพลาด 502 upstream sent too big header
กรณีพิเศษที่จุดตัดของสองหัวข้อ หาก nginx เขียนใน error.log ประโยค upstream sent too big header while reading response header from upstream และส่ง 502 แสดงว่าปัญหาไม่ได้อยู่ที่อุโมงค์หรือ upstream ล่ม แต่อยู่ที่ header ของการตอบกลับของแอปพลิเคชันที่ไม่พอดีกับ proxy_buffer_size ในทางรูปแบบนี่คือ 502 แต่รักษาด้วยพารามิเตอร์บัฟเฟอร์ที่เรากำลังพูดถึงตรงนี้ จำเครื่องหมายนี้ไว้: มันจะช่วยไม่ให้คุณไปหาปัญหาในชั้นพร็อกซี
ขั้นตอนที่ 1: ทำซ้ำปัญหาและบันทึกอาการ
เป้าหมายของขั้นตอนนี้: ได้สถานการณ์ที่แน่นอนซึ่งข้อผิดพลาดเกิดขึ้น และบันทึกอาการที่แม่นยำ: รหัส, ข้อความตอบกลับ, header Server และเวลา
- เปิดหน้าที่มีปัญหาในเบราว์เซอร์ กด F12 ไปที่แท็บ Network (เครือข่าย)
- ทำเครื่องหมายที่ Preserve log (บันทึก log ไว้) เพื่อไม่ให้รายการหายไปเมื่อเปลี่ยนหน้า
- โหลดหน้าใหม่ด้วยปุ่ม F5 ค้นหาคำขอที่ถูกทำสีแดง หรือคำขอที่มีสถานะ 400, 431 หรือ 494 คลิกที่มัน
- ในแท็บ Headers บันทึก: รหัสสถานะ ค่าของ header
Serverในการตอบกลับ (nginx, cloudflare, AkamaiGHost, gunicorn) ค่าของViaหากมี และ header ใดๆ ที่ขึ้นต้นด้วยX-หรือCF- - ไปที่แท็บ Response และคัดลอกเนื้อหาการตอบกลับ ประโยค Request Header Or Cookie Too Large ชี้ไปที่ nginx ประโยค Request Header Fields Too Large โดยไม่มีคำว่า Cookie เป็นเรื่องปกติของ Node.js ประโยค Bad Request - Request Too Long เป็นลักษณะของ IIS
- เลื่อนลงไปที่บล็อก Request Headers ประเมินความยาวของบรรทัด
Cookie: หากมันกินเวลาหลายหน้าจอ นั่นก็เป็นเบาะแสแล้ว - เปิดหน้าต่างในโหมดไม่ระบุตัวตนและทำซ้ำคำขอ หากในโปรไฟล์ใหม่ไม่มีข้อผิดพลาด แสดงว่า cookie ที่สะสมมาของผู้ใช้รายนั้นเป็นตัวการ
หากปัญหาซ้ำในสคริปต์ ไม่ใช่ในเบราว์เซอร์ ให้บันทึกข้อมูลเดียวกันจาก responses ของไลบรารี: สถานะ เนื้อหา header ใน Python requests คือ response.status_code, response.text และ response.headers
เคล็ดลับ: ส่งออกคำขอทั้งหมดเป็นไฟล์ HAR ด้วยการคลิกขวาที่รายการคำขอและเลือก Save all as HAR with content ไฟล์นี้สามารถเปิดภายหลังหรือส่งให้เพื่อนร่วมงานได้ และจะเก็บขนาด header ที่แม่นยำไว้
การตรวจสอบ: คุณควรมีบันทึกที่มีสี่รายการ: รหัสสถานะ ข้อความเนื้อหาการตอบกลับ ค่าของ header Server และผลการทดสอบในโหมดไม่ระบุตัวตน หากผลในโหมดไม่ระบุตัวตนแตกต่าง คุณรู้สาเหตุไปแล้ว 70 เปอร์เซ็นต์
ปัญหาที่อาจเกิดขึ้น
- ข้อผิดพลาดไม่ปรากฏเสมอไป แสดงว่าขนาด cookie แกว่งอยู่ใกล้เกณฑ์: เช่น หลังจากเยี่ยมชมส่วนหนึ่งๆ จะมี cookie เพิ่มอีกหนึ่งชิ้น บันทึกว่าข้อผิดพลาดเกิดขึ้นหลังจากทำอะไร
- ไม่มีคำขอสีแดง แต่หน้าทำงานผิดปกติ นี่เป็นสัญญาณของการตัดแบบเงียบ ไปที่ขั้นตอนที่ 4 ทันทีหลังการวัด
ขั้นตอนที่ 2: วัดขนาดจริงของ header และ cookie
เป้าหมายของขั้นตอนนี้: ได้ตัวเลขที่แม่นยำเป็นไบต์: ขนาดรวมของบล็อก header, ขนาดของ header Cookie, ขนาดของแต่ละ cookie
การวัดในเบราว์เซอร์
- ในแผงนักพัฒนา เปิดแท็บ Console (คอนโซล)
- พิมพ์
document.cookie.lengthแล้วกด Enter คุณจะเห็นตัวเลข: นี่คือความยาวเป็นอักขระของ cookie ทั้งหมดที่สคริปต์เข้าถึงได้ ไม่รวมแฟล็ก HttpOnly header จริงจะยาวกว่านี้ เพราะ cookie ที่มี HttpOnly ไม่ถูกรวมตรงนี้ - พิมพ์
document.cookie.split('; ').map(c => [c.split('=')[0], c.length]).sort((a, b) => b[1] - a[1])คอนโซลจะแสดงอาร์เรย์ของคู่ชื่อ-ความยาว เรียงจากมากไปน้อย cookie ที่หนักที่สุดจะอยู่ด้านบน - ไปที่แท็บ Application (ใน Firefox Storage) ขยาย Cookies เลือกโดเมน ที่นี่จะเห็น cookie ทั้งหมด รวมถึง HttpOnly พร้อมคอลัมน์ Size คลิกที่หัวคอลัมน์เพื่อเรียงตามขนาด
- รวมขนาดเข้าด้วยกัน หรือเพียงดูที่บรรทัด Cookie ในคำขอจากขั้นตอนที่ 1: ใน Chrome เมื่อวางเมาส์เหนือ header จะแสดงความยาวของมัน
การวัดผ่าน curl
Curl ช่วยให้ส่ง header ขนาดใดก็ได้และรู้แน่ชัดว่าที่ขนาดเท่าไรเซิร์ฟเวอร์เริ่มปฏิเสธ มาสร้าง cookie ที่มีความยาวควบคุมได้
- สร้างสตริง 8000 อักขระ ใน Linux และ macOS:
BIG=$(head -c 8000 /dev/zero | tr '\0' 'a')หากเชลล์บ่นเรื่องการ escape ให้ใช้ตัวเลือกBIG=$(python3 -c "print('a'*8000)") - ส่งคำขอ:
curl -s -o /dev/null -w '%{http_code}' -H "Cookie: test=$BIG" https://ваш-сайт.ru/บนหน้าจอจะปรากฏเฉพาะรหัสการตอบกลับ - เปลี่ยนขนาด: 4000, 8000, 12000, 16000, 32000, 64000 บันทึกว่าที่ค่าใดรหัสเปลี่ยนจาก 200 เป็น 400 หรือ 431
- หากทำงานผ่านพร็อกซี ให้เพิ่ม
-x http://логин:пароль@host:portและทำซ้ำชุดการทดสอบ ความแตกต่างระหว่างเกณฑ์ที่มีและไม่มีพร็อกซีจะแสดงว่ามีขีดจำกัดบนพร็อกซีเองหรือไม่
ตัวอย่างการค้นหาเกณฑ์แบบไบนารีในคำสั่งเดียวสำหรับ 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ใน Windows PowerShell ใช้แบบเทียบเท่า: $big = 'a' * 16000; curl.exe -s -o NUL -w '%{http_code}' -H "Cookie: t=$big" https://ваш-сайт.ru/
การตีความตัวเลข
- เกณฑ์ประมาณ 8 KB: ปกติสำหรับ Apache ที่มีการตั้งค่าเริ่มต้น, Tomcat, Gunicorn รวมถึง nginx เมื่อ header ไม่พอดีกับบัฟเฟอร์เดียวจากสี่ตัวที่มีขนาด 8 KB
- เกณฑ์ประมาณ 16 KB: Node.js ตั้งแต่เวอร์ชัน 13, HAProxy ที่มี tune.bufsize พื้นฐาน, IIS
- เกณฑ์ประมาณ 32 KB: ขีดจำกัดรวมของ CDN บางแห่ง header เดี่ยวมักถูกจำกัดที่ 16 KB ที่นั่น
- เกณฑ์ประมาณ 60-64 KB: Envoy และโหลดบาลานซ์บนคลาวด์บางตัว
- เกณฑ์ประมาณ 1 MB: เซิร์ฟเวอร์ Go มาตรฐาน
เคล็ดลับ: อย่าวัดแค่ Cookie ทำซ้ำชุดการทดสอบด้วย header Authorization: Bearer $BIG และกับ header หลายตัวที่เล็กกว่า เซิร์ฟเวอร์บางแห่งจำกัดขนาดของฟิลด์เดียว แยกจากจำนวนฟิลด์ และแยกจากปริมาณรวม ตัวอย่างเช่น nginx โดยค่าเริ่มต้นจะไม่ยอมให้ header เดียวใหญ่กว่า 8 KB แม้ขนาดรวมจะเล็ก เพราะแต่ละบรรทัดต้องพอดีกับบัฟเฟอร์แยก
การตรวจสอบ: ในบันทึกของคุณควรมีตัวเลขที่เซิร์ฟเวอร์เริ่มปฏิเสธ และรายการ cookie ที่หนักที่สุดสามถึงห้าตัวพร้อมขนาดของมัน หากไม่พบเกณฑ์จนถึง 64 KB แต่ในเบราว์เซอร์มีข้อผิดพลาด แสดงว่าไม่ใช่เซิร์ฟเวอร์ที่ปฏิเสธ แต่เป็นอะไรบางอย่างระหว่างเบราว์เซอร์กับเซิร์ฟเวอร์ในสภาพแวดล้อมเฉพาะของคุณ ไปที่ขั้นตอนถัดไป
ขั้นตอนที่ 3: พิจารณาว่าชั้นใดปฏิเสธ
เป้าหมายของขั้นตอนนี้: ระบุโหนดในห่วงโซ่ที่ส่งข้อผิดพลาดหรือตัดข้อมูลได้อย่างแม่นยำ เพื่อเปลี่ยนแปลงการตั้งค่า ณ ที่นั้น
การอ่านลายเซ็นของการตอบกลับ
- รัน
curl -sv -H "Cookie: t=$BIG" https://ваш-сайт.ru/ 2>&1 | grep -i -E 'server|via|cf-|x-served|x-cache|HTTP/'โดย BIG เกินเกณฑ์ไปแล้ว - อ่าน header
Serverค่า nginx ที่มีเนื้อหา Request Header Or Cookie Too Large หมายถึง nginx ปฏิเสธ ค่า cloudflare หมายถึงคำขอไม่ไปถึงเซิร์ฟเวอร์ของคุณ Server ว่างเปล่าและเนื้อหาในรูปแบบ JSON มักชี้ไปที่แอปพลิเคชัน - สังเกตเวอร์ชันโปรโตคอลในบรรทัดแรก หากคำขอปกติเซิร์ฟเวอร์ตอบด้วย HTTP/2 แต่ข้อผิดพลาดมาใน HTTP/1.1 นี่เป็นสัญญาณว่าการตอบกลับถูกสร้างโดยโหนดกลาง ไม่ใช่โหนดปลายทาง
- เปรียบเทียบเนื้อหาข้อผิดพลาด: หน้าของ nginx กระชับและมีชื่อของมันอยู่ด้านล่าง หน้าของ Cloudflare มี Ray ID ส่วน Node.js มักส่งเนื้อหาว่างเปล่าพร้อมสถานะ 431
การข้ามชั้น
- หากคุณมีที่อยู่ IP โดยตรงของเซิร์ฟเวอร์หลัง CDN ให้ทำซ้ำคำขอด้วยคีย์
--resolve ваш-сайт.ru:443:1.2.3.4สิ่งนี้บังคับให้ curl เชื่อมต่อโดยตรง โดยคง Host และ SNI ที่ถูกต้องไว้ หากคำขอโดยตรงผ่าน แต่ผ่าน CDN ไม่ผ่าน แสดงว่าขีดจำกัดอยู่ที่ CDN - หากคุณมีสิทธิ์เข้าถึงเซิร์ฟเวอร์ ให้รันคำขอในเครื่อง:
curl -s -o /dev/null -w '%{http_code}' -H "Cookie: t=$BIG" -H 'Host: ваш-сайт.ru' http://127.0.0.1:80/วิธีนี้คุณจะตัดโหนดภายนอกทั้งหมดออก - จากนั้นยิงตรงไปที่แอปพลิเคชัน ข้าม nginx:
curl ... http://127.0.0.1:3000/สำหรับ Node.js หรือพอร์ตที่ Gunicorn ฟังอยู่ หาก nginx ปล่อยผ่าน แต่แอปพลิเคชันตอบ 431 แสดงว่าขีดจำกัดอยู่ที่แอปพลิเคชัน - ตรวจสอบอิทธิพลของพร็อกซีขาออกของคุณ: ชุดคำขอหนึ่งกับ
-xอีกชุดหนึ่งไม่มี สำหรับคำขอ HTTPS ผ่านพร็อกซีจะใช้เมธอด CONNECT และพร็อกซีไม่เห็น header ภายในอุโมงค์ที่เข้ารหัส จึงไม่สามารถมีอิทธิพลต่อขนาดของมันได้ แต่สำหรับคำขอ HTTP ธรรมดา พร็อกซีจะแยกวิเคราะห์ header เอง และที่นี่อาจมีขีดจำกัดของตัวเองและแม้กระทั่งการตัด
การอ่าน log บนเซิร์ฟเวอร์
- รัน
sudo tail -f /var/log/nginx/error.logและทำซ้ำคำขอที่มีปัญหา - บรรทัด client sent too long header line ยืนยันว่าบรรทัด header เดี่ยวเกินบัฟเฟอร์ของ nginx บรรทัด client sent too large request บ่งบอกถึงการล้นของปริมาณรวม
- สำหรับ Apache ใน error.log ให้มองหา Request header exceeds LimitRequestFieldSize หรือ Size of a request header field exceeds server limit
- สำหรับ Node.js ใน log ของแอปพลิเคชัน: ข้อผิดพลาด HPE_HEADER_OVERFLOW นี่คือรหัสภายในของตัวแยกวิเคราะห์ ซึ่งภายนอกกลายเป็น 431
- ใน access.log ของ nginx ให้ดูที่ฟิลด์ที่มีขนาดคำขอ หากคุณใช้รูปแบบมาตรฐาน ให้เพิ่มตัวแปร
$request_lengthใน log_format: มันจะแสดงขนาดคำขอทั้งหมดรวม header และจะเป็นประโยชน์สำหรับการมอนิเตอร์
ข้อควรระวัง: หากใน error.log ของ nginx คุณเห็น upstream sent too big header แสดงว่าไม่ใช่คำขอขาเข้าที่ปฏิเสธ แต่เป็นการตอบกลับของแอปพลิเคชันที่ header ไม่พอดีกับบัฟเฟอร์ของ nginx กรณีแบบนี้ดูเหมือน 502 แต่เกี่ยวข้องกับหัวข้อของเรา สาเหตุมักอยู่ที่ Set-Cookie ขนาดมหึมาหรือ header หลายสิบตัวจากเฟรมเวิร์ก วิธีแก้อยู่ในขั้นตอนที่ 6
การตรวจสอบ: คุณควรพูดได้อย่างมั่นใจอย่างใดอย่างหนึ่งต่อไปนี้: CDN ปฏิเสธ; nginx ปฏิเสธ; Apache ปฏิเสธ; แอปพลิเคชันปฏิเสธ; พร็อกซีฝั่งฉันเองปฏิเสธ หากภาพยังไม่ชัดเจน แสดงว่าขีดจำกัดเกินบนหลายโหนดพร้อมกัน และจะต้องแก้ไขทั้งหมดทีละตัว ทำซ้ำการทดสอบจากขั้นตอนที่ 2 ทุกครั้ง
ขั้นตอนที่ 4: ตรวจจับการตัดแบบเงียบด้วยเอ็นด์พอยต์สะท้อนกลับ
เป้าหมายของขั้นตอนนี้: มั่นใจว่า header ไปถึงแอปพลิเคชันในรูปแบบที่ส่งไปเป๊ะๆ และจับโหนดที่เปลี่ยนมันอย่างเงียบๆ
แนวคิดนั้นง่าย เราจะตั้งเซิร์ฟเวอร์เล็กๆ ที่ส่งคืน header ทั้งหมดที่ได้รับและขนาดของมันใน response เราจะส่ง header ที่มีความยาวที่รู้ด้วยเช็คซัมและเปรียบเทียบว่าอะไรมาถึง
การรันเซิร์ฟเวอร์สะท้อนกลับบน Python
- สร้างไฟล์
echo.pyด้วยเนื้อหาดังต่อไปนี้:
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()- รัน:
python3 echo.pyเซิร์ฟเวอร์ฟังที่พอร์ต 8089 - วางไว้ตรงที่แอปพลิเคชันจริงของคุณอยู่ หรือชั่วคราวกำหนดให้ location หนึ่งใน nginx ชี้ไปที่มัน:
location /__echo { proxy_pass http://127.0.0.1:8089; }จากนั้นคำขอจะผ่านห่วงโซ่จริงทั้งหมด
โปรดทราบว่า HTTPServer มาตรฐานของ Python ไม่มีขีดจำกัดที่เข้มงวดต่อความยาวของ header แต่จำกัดจำนวนของพวกมันไว้ที่หนึ่งร้อย สำหรับการทดสอบแค่นี้ก็เพียงพอ
การส่งคำขอควบคุม
- สร้างค่าจาก 12000 อักขระ แต่ไม่ใช่แบบเดียวกันทั้งหมด ให้มีเครื่องหมายตำแหน่ง เพื่อให้เห็นว่าถูกตัดจากตรงไหน:
V=$(python3 -c "print(''.join(str(i%10) for i in range(12000)))") - คำนวณแฮชอ้างอิง:
python3 -c "import hashlib,sys; print(hashlib.sha256(sys.argv[1].encode()).hexdigest()[:12])" "$V" - ส่งผ่านห่วงโซ่ทั้งหมด:
curl -s -H "Cookie: probe=$V" -H "X-Probe-Len: 12000" https://ваш-сайт.ru/__echo - เปรียบเทียบใน response ฟิลด์ len สำหรับ Cookie กับตัวเลข 12006 (ชื่อ probe บวกเครื่องหมายเท่ากับ บวก 12000 อักขระ) และแฮชกับค่าอ้างอิง
- ทำซ้ำกับหลาย header: เพิ่ม header 30 ตัว
X-Test-1...X-Test-30และตรวจสอบฟิลด์ _count
วิธีอ่านผลลัพธ์
- ความยาวตรงกัน แฮชตรงกัน: ไม่มีการตัดบนเส้นทางนี้
- ความยาวสั้นกว่า header ถูกตัดขาด: มีบางอย่างตัดหางออก ให้ดูอักขระตัวสุดท้ายของค่าที่มาถึง: มันจะบอกตำแหน่งรอยตัด ซึ่งมักเป็นขอบเขตกลมๆ 4096 หรือ 8192 ไบต์
- header หายไปทั้งหมด: โหนดทิ้งฟิลด์ที่ไม่พอดีกับบัฟเฟอร์ WAF บางตัวและเกตเวย์เก่าทำแบบนี้
- _count น้อยกว่าที่ส่งไป: ถึงขีดจำกัดจำนวน header Apache และ Gunicorn โดยค่าเริ่มต้นรับ 100 ฟิลด์ HAProxy 101 และบางการใช้งานจะทิ้งส่วนเกินอย่างเงียบๆ
- ความยาวตรงกัน แฮชไม่ตรงกัน: โหนดเปลี่ยนเนื้อหา สิ่งนี้เกิดขึ้นเมื่อ归一化ช่องว่างหรือเข้ารหัสใหม่ ตรวจสอบว่าค่ามีอักขระที่พร็อกซีถือว่าไม่อนุญาตหรือไม่
เคล็ดลับ: หากคุณทำงานผ่านพร็อกซีมือถือหรือพร็อกซีภายนอกอื่น ให้ตั้งเซิร์ฟเวอร์สะท้อนกลับบนโฮสต์ที่เข้าถึงได้จากสาธารณะ และรันคำขอผ่านพร็อกซีใน HTTP ธรรมดาที่ไม่มี TLS ในโหมดนี้เองที่พร็อกซีแยกวิเคราะห์ header ด้วยตัวเองและสามารถแสดงขีดจำกัดของมันได้ ในโหมด HTTPS ผ่าน CONNECT เนื้อหาจะทึบแสงสำหรับพร็อกซี และการตัดบนชั้นนี้เป็นไปไม่ได้ทางกายภาพ
การตรวจสอบ: คุณมีตาราง: โหนด, ไบต์ที่ส่ง, ไบต์ที่ได้รับ, การตรงกันของแฮช หากทุกบรรทัดตรงกัน ไม่มีการตัดแบบเงียบ และอาการของคุณอธิบายได้จากการปฏิเสธที่ชัดเจนจากขั้นตอนที่ 1-3 หากมีความไม่ตรงกัน คุณรู้ว่ามันอยู่ที่ไหน
การตรวจสอบเบราว์เซอร์แยกสำหรับ Set-Cookie
เบราว์เซอร์ก็ตัดอย่างเงียบๆ เช่นกัน แต่ไม่ใช่คำขอ แต่เป็นการตอบกลับ หากเซิร์ฟเวอร์ส่ง Set-Cookie ยาวเกินประมาณ 4096 ไบต์ Chrome และ Firefox จะเพิกเฉยต่อมันเลย โดยไม่มีคำเตือนใดๆ ตรวจสอบ: ในแท็บ Network ค้นหาการตอบกลับที่มี Set-Cookie ดูความยาวของบรรทัด จากนั้นเปิดแท็บ Application และยืนยันว่า cookie ถูกบันทึกไว้ หากไม่มี ให้แบ่งค่าออกเป็นส่วนๆ หรือย้ายข้อมูลไปที่เซิร์ฟเวอร์
ขั้นตอนที่ 5: ลดปริมาณ cookie และ header
เป้าหมายของขั้นตอนนี้: ขจัดรากของปัญหา เพื่อให้คำขอพอดีกับขีดจำกัดมาตรฐานและไม่ขึ้นอยู่กับความเมตตาของโหนดกลาง
การเพิ่มขีดจำกัดนั้นน่าดึงดูด แต่เป็นการรักษาอาการ ทุกกิโลไบต์ของ cookie ที่เกินมาจะไปกับทุกคำขอของผู้ใช้ทุกคน รวมถึงคำขอสำหรับรูปภาพ เริ่มจากการลดก่อน
การตรวจสอบ cookie
- นำรายการจากขั้นตอนที่ 2 ที่เรียงตามขนาดมา
- สำหรับแต่ละ cookie ตอบสามคำถาม: ใครตั้งมัน, เซิร์ฟเวอร์ต้องการมันไหม, ต้องการมันในทุกพาธของเว็บไซต์ไหม
- Cookie ของระบบวิเคราะห์และพิกเซลโฆษณาแทบไม่เคยจำเป็นต่อเซิร์ฟเวอร์ ไม่ต้องลบ但它们 แต่ไม่ต้องส่งมันไปยังโดเมน API
- Cookie ที่มีสถานะแบบ serialize (ตะกร้าใน JSON, การตั้งค่าอินเทอร์เฟซ, ประวัติการดู) เป็นตัวเลือกในการย้ายไปยัง localStorage หรือที่จัดเก็บบนเซิร์ฟเวอร์ที่มีตัวระบุสั้นๆ
เทคนิคการลด
- ย้าย API ไปยังซับโดเมนแยก Cookie ที่ตั้งบน www.сайт.ru โดยไม่มี Domain ที่ชัดเจนจะไม่ถูกส่งไปยัง api.сайт.ru Cookie การตลาดที่หนักจะอยู่ที่หน้าร้าน ส่วน API จะได้รับแค่เซสชัน
- กำหนดแอตทริบิวต์ Path Cookie ที่มี
Path=/adminจะไม่ไปในคำขอไปยัง/staticตรวจสอบว่าเฟรมเวิร์กของคุณไม่ได้ตั้ง cookie ทั้งหมดที่รากโดยไม่จำเป็น - เก็บตัวระบุใน cookie ไม่ใช่ข้อมูล แทน JSON 3 KB ให้ใส่คีย์ 32 อักขระและเก็บข้อมูลใน Redis หรือฐานข้อมูล การปลอมแปลงเนื้อหาจะได้รับการแก้ไขไปด้วย
- ย่อ JWT โทเค็นใน cookie หรือ Authorization บวมเพราะฟิลด์เกินใน payload: รายการบทบาท, ที่อยู่, อวตาร เหลือแค่ตัวระบุและอายุการใช้งาน ส่วนที่เหลือเรียกแยก JWT ทั่วไปควรอยู่ในช่วง 500-800 ไบต์
- ลบ cookie ที่ล้าสมัยอย่างชัดเจน หากคุณเปลี่ยนชื่อ cookie ตัวเก่าจะยังอยู่กับผู้ใช้จนหมดอายุ ส่ง Set-Cookie ด้วยชื่อเก่าและ Max-Age=0
- ใช้โดเมนแยกที่ไม่มี cookie สำหรับ static เทคนิคคลาสสิก: static.сайт.ru หรือโดเมน CDN ที่ไม่มีการตั้ง cookie เลย
- ตรวจสอบการซ้ำซ้อน บ่อยครั้ง cookie ตัวเดียวกันมีอยู่สองแบบ: สำหรับ сайт.ru และสำหรับ .сайт.ru ที่มีจุด เบราว์เซอร์จะส่งทั้งสอง
สำหรับสคริปต์และระบบอัตโนมัติ
หากคุณจัดการบัญชีจำนวนมากผ่านพร็อกซีและเบราว์เซอร์ต้านการตรวจจับ ให้ระวังโปรไฟล์ โปรไฟล์ที่อยู่มาครึ่งปีจะสะสม cookie ของโดเมนภายนอกหลายสิบแห่ง และคำขอไปยังเว็บไซต์เป้าหมายจะเริ่มถูกปฏิเสธเพราะ header ที่บวม ตั้งค่าการล้าง cookie ของโดเมนภายนอกเป็นระยะ โดยไม่แตะ cookie การอนุญาตของเว็บไซต์เป้าหมาย ในไลบรารีอย่าง requests หรือ httpx ให้เก็บ cookie ใน CookieJar แยกต่อบัญชี และวันละครั้งลบรายการที่หมดอายุ
เคล็ดลับ: เพิ่มการตรวจสอบง่ายๆ บนไคลเอนต์ก่อนคำขอ: หาก document.cookie.length เกิน 6000 อักขระ ส่งเมตริกไปยังระบบวิเคราะห์ของคุณ วิธีนี้คุณจะรู้ปัญหาจากผู้ใช้กลุ่มแรก ไม่ใช่จากการร้องเรียนเป็นจำนวนมาก
การตรวจสอบ: ทำซ้ำการวัดจากขั้นตอนที่ 2 บนโปรไฟล์ใหม่ ทำตามสถานการณ์ผู้ใช้ทั่วไป (เข้าสู่ระบบ, แคตตาล็อก, ตะกร้า, ชำระเงิน) และยืนยันว่าขนาดรวมของ header ไม่เกิน 4 KB บน API และ 8 KB บนหน้าร้าน นี่เป็นระยะเผื่อที่สบายเมื่อเทียบกับขีดจำกัดมาตรฐานใดๆ
ขั้นตอนที่ 6: ตั้งค่าขีดจำกัดบนเว็บเซิร์ฟเวอร์ ตัวโหลดบาลานซ์ และแอปพลิเคชัน
เป้าหมายของขั้นตอนนี้: ตั้งขีดจำกัดที่สอดคล้องกันบนทุกโหนดที่คุณดูแล เพื่อไม่ให้โหนดใดแคบกว่าเพื่อนบ้านอย่างไม่คาดคิด
กฎทอง: ขีดจำกัดของโหนดภายนอกต้อง ไม่มากกว่า ขีดจำกัดของโหนดภายใน มิฉะนั้น nginx จะปล่อย 32 KB แต่ Node.js ข้างหลังจะปฏิเสธด้วย 431 และคุณจะได้ข้อผิดพลาดจากส่วนลึกของสแตกที่วินิจฉัยยากขึ้น แนวทางที่สมเหตุสมผลสำหรับปี 2026: 16 KB สำหรับบล็อก header ทั้งหมด และ 8-16 KB สำหรับฟิลด์เดียว แค่นี้ก็เพียงพอสำหรับเกือบทุกคน พร้อมทั้งยังมีการป้องกันการใช้งานในทางที่ผิด
nginx
- เปิด
/etc/nginx/nginx.confค้นหาบล็อกhttp { ... } - เพิ่มหรือแก้ไขไดเรกทีฟสามตัว:
http {
client_header_buffer_size 4k;
large_client_header_buffers 4 16k;
proxy_buffer_size 16k;
proxy_buffers 8 16k;
}client_header_buffer_sizeคือบัฟเฟอร์เล็กตัวแรกสำหรับคำขอทั่วไป ค่า 1k เริ่มต้นบังคับให้ nginx สลับไปใช้บัฟเฟอร์ใหญ่เกือบทุกครั้ง ซึ่งไม่เป็นไร แต่ 4k ลดการจัดสรรเกินจำเป็นlarge_client_header_buffers 4 16kหมายถึง: ไม่เกินสี่บัฟเฟอร์ขนาด 16 KB แต่ละบรรทัด header ต้องพอดีกับบัฟเฟอร์เดียวทั้งหมด และบล็อกทั้งหมดต้องพอดีกับผลรวมบัฟเฟอร์ ดังนั้น cookie หรือ Authorization เดี่ยวไม่สามารถเกิน 16 KB และ header ทั้งหมดรวมกันไม่เกิน 64 KBproxy_buffer_sizeรับผิดชอบส่วนแรกของการตอบกลับ upstream รวมถึง header ของมัน การเพิ่มมันคือสิ่งที่กำจัด 502 ที่มีประโยค upstream sent too big header ค่าของproxy_buffersต้องไม่น้อยกว่า proxy_buffer_size- หากต้องการให้ไคลเอนต์เห็นการตอบกลับที่มีความหมายแทนหน้า 400 มาตรฐาน ให้เพิ่มภายใน server:
error_page 494 =431 /431.html;และวางไฟล์ 431.html ที่มีข้อความชัดเจนและคำแนะนำให้ล้าง cookie วิธีนี้คุณเปลี่ยน 494 ที่ไม่เป็นมาตรฐานให้เป็น 431 มาตรฐาน - ตรวจสอบไวยากรณ์:
sudo nginx -tควรปรากฏ syntax is ok และ test is successful - ใช้งานโดยไม่ตัดการเชื่อมต่อ:
sudo nginx -s reload
โปรดจำไว้ว่า large_client_header_buffers สามารถกำหนดในบริบท server ได้เช่นกัน แต่สำหรับ HTTP/2 จะใช้ค่าจากบริบท http ดังนั้นแก้ไขที่นั่น สำหรับ HTTP/2 ยังมีไดเรกทีฟ http2_max_header_size ในเวอร์ชันเก่า ในบิลด์ปัจจุบันมันถูกลบแล้ว และ large_client_header_buffers ก็เพียงพอ
Apache
- เปิดไฟล์กำหนดค่าหลักและเพิ่มที่ระดับเซิร์ฟเวอร์หรือ VirtualHost:
LimitRequestFieldSize 16384
LimitRequestFields 150
LimitRequestLine 16384LimitRequestFieldSizeจำกัดฟิลด์เดียว โดยค่าเริ่มต้น 8190 ไบต์LimitRequestFieldsจำกัดจำนวนฟิลด์ โดยค่าเริ่มต้น 100LimitRequestLineจำกัดบรรทัดเริ่มต้น ซึ่งสำคัญเมื่อมี URL ยาวพร้อมพารามิเตอร์- หาก Apache ทำงานเป็นรีเวิร์สพร็อกซีผ่าน mod_proxy_http ให้เพิ่ม
ProxyIOBufferSize 32768สำหรับการตอบกลับที่มี header ขนาดใหญ่ - ตรวจสอบ:
sudo apachectl configtestจากนั้นsudo systemctl reload apache2
Node.js
- ขีดจำกัดถูกกำหนดเมื่อเริ่มกระบวนการด้วยแฟล็ก
--max-http-header-sizeค่าเป็นไบต์:node --max-http-header-size=32768 server.js - หากคุณใช้ PM2 หรือ systemd ให้ระบุแฟล็กในฟิลด์ node_args หรือในตัวแปรสภาพแวดล้อม
NODE_OPTIONS=--max-http-header-size=32768 - ทางเลือกในโค้ด:
http.createServer({ maxHeaderSize: 32768 }, app)พารามิเตอร์นี้รองรับในเวอร์ชัน Node ปัจจุบันและช่วยให้กำหนดขีดจำกัดได้โดยไม่ต้องรีสตาร์ทด้วยแฟล็กใหม่ - ตรวจสอบหลังรีสตาร์ทด้วยชุด curl ตรงไปที่พอร์ต Node: เกณฑ์ควรเลื่อน
Tomcat และ Spring Boot
- ใน
server.xmlที่องค์ประกอบ Connector เพิ่มแอตทริบิวต์maxHttpHeaderSize="16384"โดยค่าเริ่มต้นที่นั่นคือ 8192 - ใน Spring Boot เพียงบรรทัดใน application.properties:
server.max-http-request-header-size=16KBชื่อพร็อพเพอร์ตี้เก่าอย่าง server.max-http-header-size ก็ใช้ได้ในบางเวอร์ชัน แต่ถูกทำเครื่องหมายว่าล้าสมัย - รีสตาร์ทแอปพลิเคชันและตรวจสอบเกณฑ์
Gunicorn และ Uvicorn
- สำหรับ Gunicorn เพิ่มในคอนฟิกหรือบรรทัดคำสั่ง:
--limit-request-field_size 16380 --limit-request-fields 150 --limit-request-line 8190สังเกตการเขียน field_size ที่มีขีดล่าง: นี่เป็นสิ่งตกค้างทางประวัติศาสตร์ และถ้าใช้ขีดกลาง พารามิเตอร์จะไม่ทำงาน - ค่า 0 ของ limit-request-field_size ยกเลิกขีดจำกัดทั้งหมด แต่ห้ามทำเช่นนั้นบนเซิร์ฟเวอร์สาธารณะ
- Uvicorn จำกัดขนาด header ผ่านตัวแยกวิเคราะห์ h11 และโดยค่าเริ่มต้นยอมรับค่าที่ค่อนข้างใหญ่ จุดแคบมักอยู่ข้างหน้ามัน ใน nginx
HAProxy
- ในส่วน global:
tune.bufsize 32768และtune.http.maxhdr 150 - คำขอทั้งหมดรวม header ทั้งหมดต้องพอดีกับบัฟเฟอร์เดียวขนาด tune.bufsize ลบด้วยสำรอง tune.maxrewrite ที่ค่าเริ่มต้น 16384 ปริมาณที่ใช้ได้จริงอยู่ที่ประมาณ 15 KB
- ตรวจสอบ
haproxy -c -f /etc/haproxy/haproxy.cfgและรีสตาร์ท โปรดทราบว่าการเพิ่ม bufsize เพิ่มการใช้หน่วยความจำต่อการเชื่อมต่อ
IIS
- ขีดจำกัดอยู่ในรีจิสทรีที่คีย์ HTTP.sys: พารามิเตอร์ MaxFieldLength และ MaxRequestBytes ในคีย์ HKLM SYSTEM CurrentControlSet Services HTTP Parameters ค่าเริ่มต้น 16384 ไบต์สำหรับทั้งสอง สูงสุด 65534
- หลังการเปลี่ยนแปลงต้องรีสตาร์ทบริการ HTTP หรือเซิร์ฟเวอร์
- เพิ่มเติมตรวจสอบ
maxAllowedContentLengthและmaxQueryStringใน requestFiltering หากปัญหเกี่ยวกับ URL ยาว
CDN และ WAF
CDN บนคลาวด์ส่วนใหญ่มีขีดจำกัดคงที่ในแพ็กเกจพื้นฐาน และเปลี่ยนได้เฉพาะในแพ็กเกจองค์กร หากเกณฑ์จากขั้นตอนที่ 3 ติดที่ CDN ทางเดียวที่เป็นสากลคือการลด cookie จากขั้นตอนที่ 5 เพิ่มเติมตรวจสอบว่า WAF ไม่ได้ตั้งค่าในโหมดที่ header ขนาดใหญ่ไม่ถูกบล็อกแต่ถูกตัดออก: โหมดดังกล่าวสร้างการตัดแบบเงียบนั้นเอง และควรเปลี่ยนเป็นการปฏิเสธอย่างชัดเจนด้วยรหัส
ข้อควรระวัง: อย่าตั้งขีดจำกัดเป็นเมกะไบต์เพื่อความสบายใจ ทุกกิโลไบต์ของบัฟเฟอร์คูณด้วยจำนวนการเชื่อมต่อพร้อมกัน และผู้โจมตีสามารถส่ง header ขนาดมหึมาโดยเจตนาเพื่อใช้หน่วยความจำจนหมด เก็บระยะเผื่อที่สมเหตุสมผลสองถึงสามเท่าของค่าสูงสุดจริง และไม่มากกว่านั้น
การตรวจสอบ: ทำซ้ำชุด curl จากขั้นตอนที่ 2 สำหรับแต่ละโหนดแยก (ตรงไปที่แอปพลิเคชัน, ผ่าน nginx, จากภายนอกผ่าน CDN) เกณฑ์ควรตรงกัน หรือลดลงจากภายในสู่นอก ยืนยันว่าเมื่อเกินขีดจำกัดแต่ละโหนดส่งรหัสที่เข้าใจได้ ไม่ใช่ตัดการเชื่อมต่อ
ขั้นตอนที่ 7: ทำให้การปฏิเสธชัดเจนและตั้งค่าการมอนิเตอร์
เป้าหมายของขั้นตอนนี้: กำจัดการตัดแบบเงียบในอนาคตและรู้เกี่ยวกับการเติบโตของ header ก่อนที่มันจะชนขีดจำกัด
การตอบกลับที่ชัดเจนแทนความเงียบ
- ยืนยันว่าแต่ละโหนดของคุณเมื่อเกินขีดจำกัดส่งคืน 431 หรืออย่างน้อย 400 พร้อมข้อความ ใน nginx ได้ทำแล้วในขั้นตอนที่ 6 ผ่าน error_page 494
- หากคุณมีพร็อกซีหรือเกตเวย์ที่เขียนเองบนบัฟเฟอร์คงที่ ให้เพิ่มการตรวจสอบ: หาก header ไม่พอดี ตอบ 431 และปิดการเชื่อมต่อ อย่าส่งค่าที่ถูกตัดต่อไป
- ในแอปพลิเคชันเพิ่มการตรวจสอบ header ที่สำคัญ เช่น หาก JWT แยกวิเคราะห์ไม่ได้หรือ cookie เซสชันสั้นกว่าความยาวที่คาดไว้ ให้บันทึกเป็นเหตุการณ์แยกที่มีเครื่องหมาย possible truncation นี่คือตัวตรวจจับปัญหาบนโหนดภายนอกใดๆ ที่ราคาถูก
การบันทึกขนาด
- ใน nginx ขยายรูปแบบ log ในบล็อก 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; }- ตัวเลือกง่ายและเชื่อถือได้โดยไม่ต้องใช้ map: บันทึกเฉพาะ
$request_lengthตัวแปรนี้เพียงพอที่จะเห็นการเติบโต - วันละครั้งรัน
awkบน access.log และหาค่าสูงสุดและเปอร์เซ็นไทล์ที่ 99 ของ req_len หากเปอร์เซ็นไทล์ที่ 99 เกินครึ่งหนึ่งของขีดจำกัด ถึงเวลาทำความสะอาด cookie - สำหรับ Apache ใช้ตัวแปร
%Iจาก mod_logio ใน LogFormat: มันแสดงไบต์ขาเข้ารวม header
การแจ้งเตือน
- ตั้งเมตริกจำนวนการตอบกลับ 431 และ 400 ที่มีเนื้อหาเกี่ยวกับ cookie ใน Prometheus กับ nginx-exporter นี่คือสถานะจาก access.log ในแผงมอนิเตอร์บนคลาวด์มักมีรายละเอียดตามรหัส
- ตั้งเกณฑ์: มากกว่า 10 การตอบกลับแบบนี้ใน 5 นาทีคือสัญญาณ ข้อผิดพลาด 431 จำนวนมากมักหมายความว่ามีคนนำ cookie หนักตัวใหม่ออกใช้
- เพิ่มการตรวจสอบสังเคราะห์: ทุกชั่วโมงสคริปต์ส่งคำขอที่มี header ขนาด 90 เปอร์เซ็นต์ของขีดจำกัดและตรวจสอบว่าผ่าน และกับ header ขนาด 110 เปอร์เซ็นต์ตรวจสอบว่าได้ 431 กลับมา วิธีนี้คุณจะจับการจำกัดขีดจำกัดโดยไม่ตั้งใจและการยกเลิกโดยไม่ตั้งใจได้
เคล็ดลับ: เก็บเอ็นด์พอยต์สะท้อนกลับจากขั้นตอนที่ 4 ไว้ตลอด ปิดด้วย IP หรือการอนุญาตง่ายๆ มันจะมีประโยชน์ทุกครั้งที่เปลี่ยนโครงสร้างพื้นฐาน: เพิ่ม WAF, เปลี่ยนโหลดบาลานซ์, เชื่อมต่อพูลพร็อกซีใหม่ และในหนึ่งนาทีก็ยืนยันได้ว่า header ไปถึงครบถ้วน
การตรวจสอบ: ส่งคำขอขนาดใหญ่ที่รู้แน่ว่าเกิน และยืนยันว่ามันเข้า log ด้วยขนาดที่ถูกต้อง ตัวนับ 431 เพิ่มขึ้น และการแจ้งเตือนทำงานเมื่อเกินเกณฑ์ หลังจากนั้นคืนเกณฑ์กลับเป็นค่าที่ใช้งานได้
การตรวจสอบผลลัพธ์
ไล่ตามเช็คลิสต์ แต่ละข้อต้องผ่าน ไม่เช่นนั้นให้กลับไปที่ขั้นตอนที่เกี่ยวข้อง
เช็คลิสต์
- หน้าที่มีปัญหาจากขั้นตอนที่ 1 เปิดได้โดยไม่มีข้อผิดพลาดในโปรไฟล์หลักของเบราว์เซอร์
- ขนาดรวมของ header ในคำขอทั่วไปไม่เกิน 8 KB และบนโดเมน API 4 KB
- ไม่มี cookie ใดเกิน 2 KB cookie ภายนอกที่หนักที่สุดไม่ถูกส่งไปยัง API
- เกณฑ์การปฏิเสธในแต่ละโหนดเป็นที่รู้และบันทึกไว้ ขีดจำกัดลดลงหรือเท่ากันจากแอปพลิเคชันไปยังขอบนอก
- เมื่อเกินขีดจำกัด ไคลเอนต์ได้รับรหัส 431 หรือ 400 พร้อมข้อความ ไม่ใช่การตัดการเชื่อมต่อและไม่ใช่คำขอที่ถูกตัดอย่างเงียบ
- เอ็นด์พอยต์สะท้อนกลับแสดงความยาวและแฮชที่ตรงกันเมื่อส่งผ่านห่วงโซ่ทั้งหมด รวมถึงผ่านพร็อกซีของคุณ
- ใน access.log มีขนาดคำขอ และตั้งการแจ้งเตือนการเติบโตของ 431 แล้ว
- ไฟล์สำรองของคอนฟิกอยู่ข้างๆ และคุณรู้คำสั่งในการย้อนกลับ
วิธีทดสอบทั้งหมด
- ล้าง cookie สำหรับโดเมนทดสอบและทำตามสถานการณ์ผู้ใช้ตั้งแต่เข้าสู่ระบบจนถึงการกระทำสำคัญ ไม่ควรมีข้อผิดพลาด
- รันลูป curl จากขั้นตอนที่ 2 จากภายนอก บันทึกเกณฑ์ มันควรสอดคล้องกับการตั้งค่าใหม่ของคุณ
- ส่งคำขอควบคุมไปยังเอ็นด์พอยต์สะท้อนกลับผ่านทุกเส้นทางที่ใช้: โดยตรง, ผ่าน CDN, ผ่านพูลพร็อกซี
- ส่ง header ที่ใหญ่เป็นสองเท่าของขีดจำกัดโดยเจตนาและยืนยันว่าได้รับ 431 พร้อมเนื้อหาที่ชัดเจน
- ตรวจสอบว่าการตอบกลับของแอปพลิเคชันที่มี Set-Cookie ขนาดใหญ่ไม่ทำให้ nginx ส่ง 502
ตัวชี้วัดความสำเร็จ
สัดส่วนการตอบกลับ 431 และ 400 ที่มีข้อความเกี่ยวกับ header เข้าใกล้ศูนย์ในทราฟฟิกปกติ เปอร์เซ็นไทล์ที่ 99 ของขนาดคำขอต่ำกว่าครึ่งหนึ่งของขีดจำกัดที่แคบที่สุด การถูกล็อกเอาท์โดยไม่มีสาเหตุและเซสชันที่หายไปไม่ปรากฏในการร้องเรียนของผู้ใช้อีกต่อไป
ข้อผิดพลาดทั่วไปและวิธีแก้ไข
เพิ่มขีดจำกัดใน nginx แล้ว แต่ 431 ยังคงอยู่
สาเหตุ: ข้างหลัง nginx มี Node.js หรือ Tomcat ที่มีขีดจำกัด 8-16 KB ของตัวเอง และตอนนี้มันเป็นผู้ปฏิเสธ วิธีแก้ไข: ตรวจสอบเกณฑ์ตรงที่พอร์ตแอปพลิเคชันจากขั้นตอนที่ 3 และเพิ่มมันด้วยแฟล็ก --max-http-header-size หรือ maxHttpHeaderSize จากนั้นยืนยันว่าขีดจำกัด nginx ไม่มากกว่าขีดจำกัดแอปพลิเคชัน
ตั้ง large_client_header_buffers ในบล็อก server แต่ไม่มีอะไรเปลี่ยนแปลง
สาเหตุ: สำหรับ HTTP/2 nginx ใช้ค่าจากบริบท http และไดเรกทีฟไม่สืบทอดตามที่คาดไว้ หากกำหนดในหลาย server สำหรับที่อยู่เดียวกัน วิธีแก้ไข: ย้ายไดเรกทีฟไปที่บล็อก http และโหลดคอนฟิกใหม่
ข้อผิดพลาดปรากฏเฉพาะกับผู้ใช้บางส่วน
สาเหตุ: ขนาด cookie ขึ้นอยู่กับประวัติของผู้ใช้แต่ละคน: ส่วนที่เยี่ยมชม, การทดลองที่เปิดใช้งาน, cookie เก่าจากเวอร์ชันก่อนของเว็บไซต์ วิธีแก้ไข: รวบรวมสถิติขนาดผ่าน $request_length ค้นหาว่า cookie ใดเติบโต และลบตัวที่ล้าสมัยอย่างชัดเจนผ่าน Set-Cookie ด้วย Max-Age=0
หลังล้าง cookie ทุกอย่างทำงาน แต่ผ่านไปหนึ่งสัปดาห์ก็พังอีก
สาเหตุ: แหล่งที่มาของการเติบโตยังไม่ถูกกำจัด: เช่น สคริปต์วิเคราะห์เขียนข้อมูลเพิ่มใน cookie ตัวเดียวทุกการเข้าชม วิธีแก้ไข: ค้นหา cookie ที่เติบโตผ่านการเรียงตามขนาดในวันต่างๆ และย้ายเนื้อหาของมันไปยัง localStorage หรือจำกัดฝั่งผู้ให้บริการสคริปต์
Nginx ส่ง 502 ทั้งที่แอปพลิเคชันยังทำงานอยู่
สาเหตุ: ใน error.log มีประโยค upstream sent too big header: header ของการตอบกลับแอปพลิเคชันไม่พอดีกับ proxy_buffer_size มักมี Set-Cookie ขนาดมหึมาหรือ header ดีบักจำนวนมากเป็นตัวการ วิธีแก้ไข: เพิ่ม proxy_buffer_size เป็น 16k และ proxy_buffers เป็น 8 16k และลด header การตอบกลับในแอปพลิเคชัน
ผ่านพร็อกซี คำขอ HTTP สูญเสีย header บางส่วน แต่ HTTPS ผ่าน
สาเหตุ: สำหรับ HTTP พร็อกซีแยกวิเคราะห์ header เองและติดที่บัฟเฟอร์ของมัน ส่วนสำหรับ HTTPS ผ่าน CONNECT เนื้อหาทึบแสงและผ่านไปไม่ถูกแตะ วิธีแก้ไข: เปลี่ยนไปใช้ HTTPS สำหรับทรัพยากรเป้าหมาย หรือลด header หากพร็อกซีเป็นของคุณเอง เพิ่มขีดจำกัดและตั้งการปฏิเสธที่ชัดเจนแทนการตัด
เบราว์เซอร์ไม่บันทึก cookie หลังการตอบกลับของเซิร์ฟเวอร์
สาเหตุ: บรรทัด Set-Cookie ยาวกว่า 4096 ไบต์ หรือจำนวน cookie ทั้งหมดในโดเมนเกินขีดจำกัดของเบราว์เซอร์ (ประมาณ 180 ใน Chrome) และมันทิ้งตัวใหม่หรือแทนที่ตัวเก่าอย่างเงียบๆ วิธีแก้ไข: เก็บเฉพาะตัวระบุใน cookie และเก็บข้อมูลบนเซิร์ฟเวอร์ อย่าสร้าง cookie เล็กๆ หลายสิบตัว รวม它们เข้าด้วยกัน
Gunicorn ไม่สนใจพารามิเตอร์ขีดจำกัด
สาเหตุ: พารามิเตอร์เขียนด้วยขีดกลางเป็น limit-request-field-size แต่ชื่อที่ถูกต้องมีขีดล่าง: limit-request-field_size วิธีแก้ไข: แก้การเขียนและรีสตาร์ทเวิร์กเกอร์
ความสามารถเพิ่มเติม
ขีดจำกัดที่แตกต่างสำหรับพาธที่แตกต่าง
ไม่จำเป็นต้องเพิ่มขีดจำกัดสำหรับทั้งเว็บไซต์ หากต้องการ header หนักเฉพาะบางพาธ เช่นเมื่ออัปโหลดไฟล์ที่มีเมทาดาทายาว ใน nginx สามารถแยกพาธนี้ออกเป็น server แยกบนชื่อหรือพอร์ตแยกที่มี large_client_header_buffers เพิ่มขึ้น และปล่อยให้เว็บไซต์หลักเข้มงวด วิธีนี้คุณรักษาการป้องกันการใช้งานในทางที่ผิดในจุดที่สำคัญกว่า
การบีบอัด header ใน HTTP/2 และ HTTP/3
โปรโตคอล HTTP/2 และ HTTP/3 บีบอัด header ด้วยอัลกอริทึม HPACK และ QPACK บนเครือข่าย cookie ที่ซ้ำกันไปอย่างกะทัดรัด แต่บนเซิร์ฟเวอร์它們ถูกคลายกลับเป็นขนาดเต็ม และขีดจำกัดถูกนำไปใช้กับข้อมูลที่คลายแล้ว ดังนั้นการเปิด HTTP/2 ประหยัดทราฟฟิก แต่ไม่ช่วยเรื่อง 431 พารามิเตอร์ SETTINGS_MAX_HEADER_LIST_SIZE ที่เซิร์ฟเวอร์ประกาศต่อไคลเอนต์กำหนดขอบเขตบนของรายการที่คลายแล้ว ใน nginx มันถูกคำนวณจาก large_client_header_buffers โดยอัตโนมัติ
Cookie แบบแบ่งส่วน
ไลบรารีการอนุญาตบางตัวสามารถแบ่งค่ายาวออกเป็นหลาย cookie ที่มีส่วนต่อท้าย .0, .1, .2 และประกอบกลับบนเซิร์ฟเวอร์ วิธีนี้แก้ปัญหาขีดจำกัดของเบราว์เซอร์ต่อ cookie หนึ่งตัวที่ 4 KB แต่ไม่ลดขนาดรวมของ header Cookie ใช้เทคนิคนี้เป็นมาตรการชั่วคราวเมื่อย้ายไปยังการเก็บเซสชันบนเซิร์ฟเวอร์เท่านั้น
เซสชันบนเซิร์ฟเวอร์แทน cookie คอนเทนเนอร์
วิธีแก้เชิงสถาปัตยกรรมที่เชื่อถือได้ที่สุด: ใน cookie เหลือเพียงตัวระบุสุ่มยาว 32-64 อักขระ และสถานะทั้งหมดอยู่ใน Redis ที่มี TTL header Cookie ในกรณีนี้แทบไม่เกิน 200 ไบต์ และหัวข้อขีดจำกัดทั้งหมดจะไม่เกี่ยวข้องอีกต่อไป การย้ายใช้เวลาตั้งแต่หนึ่งวันสำหรับแอปพลิเคชันเล็กจนถึงหลายสัปดาห์สำหรับแอปขนาดใหญ่ แต่คืนทุนด้วยการลดทราฟฟิกและความปลอดภัยที่ง่ายขึ้น
การตรวจสอบอัตโนมัติใน CI
เพิ่มการทดสอบในไปป์ไลน์: ตั้งแอปพลิเคชัน ส่งคำขอที่มี header ขนาด 90 เปอร์เซ็นต์ของขีดจำกัดที่ประกาศและตรวจสอบรหัส 200 จากนั้นที่ 120 เปอร์เซ็นต์และตรวจสอบรหัส 431 การทดสอบใช้เวลาไม่กี่วินาทีและจะไม่ให้ขีดจำกัดถูกจำกัดโดยไม่ตั้งใจเมื่ออัปเดตเฟรมเวิร์กที่ค่าเริ่มต้นเปลี่ยน
การทำงานกับพูลพร็อกซี
หากคุณใช้พร็อกซีหลายตัวหรือพูลมือถือที่มีการหมุนเวียน ให้รันคำขอควบคุมไปยังเอ็นด์พอยต์สะท้อนกลับผ่านทุกทางออกทั้ง HTTP และ HTTPS บันทึกผลลัพธ์ในตาราง วิธีนี้คุณจะพบทางออกที่มีพฤติกรรมไม่เป็นมาตรฐานและสามารถยกเว้น它們 หรือส่งเฉพาะทราฟฟิก HTTPS ผ่าน它們 ซึ่งการตัดเป็นไปไม่ได้
คำถามที่พบบ่อย
431 แตกต่างจาก 494 อย่างไร ถ้าโดยพื้นฐานทั้งคู่เกี่ยวกับ header ขนาดใหญ่?
431 เป็นรหัสมาตรฐานจากข้อกำหนด HTTP ไคลเอนต์และเครื่องมือมอนิเตอร์ทุกตัวเข้าใจมัน 494 เป็นรหัสภายในของ nginx ซึ่งโดยค่าเริ่มต้นภายนอกกลายเป็น 400 พร้อมข้อความ Request Header Or Cookie Too Large สำหรับผู้ใช้ไม่มีความแตกต่าง แต่สำหรับการวินิจฉัย 494 ใน log หรือใน error_page ชี้ไปที่ nginx อย่างชัดเจนว่าเป็นแหล่งที่มา
ตั้งขีดจำกัดให้ใหญ่มากแล้วลืมไปได้ไหม?
ในทางเทคนิคได้ แต่คุณจะเพิ่มการใช้หน่วยความจำต่อการเชื่อมต่อและทำให้การโจมตีด้วย header ขนาดมหึมาง่ายขึ้น นอกจากนี้คุณไม่ได้ควบคุมขีดจำกัดของ CDN และเบราว์เซอร์ และปัญหาก็จะย้ายไปที่นั่น ลำดับที่ถูกต้อง: ลด cookie ก่อน แล้วตั้งขีดจำกัดปานกลางพร้อมระยะเผื่อ
ทำไมในโหมดไม่ระบุตัวตนทุกอย่างทำงาน แต่ในโหมดปกติเกิดข้อผิดพลาด?
ในโหมดไม่ระบุตัวตนไม่มี cookie ที่สะสม นี่เป็นสัญญาณเกือบร้อยเปอร์เซ็นต์ว่าสาเหตุอยู่ที่ขนาดของ header Cookie ของผู้ใช้รายนั้น การล้าง cookie สำหรับโดเมนแก้ปัญหาได้ครั้งเดียว แต่ขั้นตอนที่ 5 แก้ได้ตลอดไป
จะวัดขนาด header ได้อย่างไรถ้าไม่มีสิทธิ์เข้าถึงเซิร์ฟเวอร์?
ใช้แผงนักพัฒนา: แท็บ Application แสดงขนาดของแต่ละ cookie และคำสั่ง document.cookie.length ในคอนโซลให้ความยาวรวมของ cookie ที่สคริปต์เข้าถึงได้ สำหรับเกณฑ์การปฏิเสธที่แม่นยำ ให้ส่ง curl ด้วย header ขนาดใหญ่ที่สร้างขึ้นเทียมและดูรหัสการตอบกลับ
พร็อกซีของฉันสามารถตัด header ในคำขอ HTTPS ได้ไหม?
ไม่ได้ เมื่อใช้ HTTPS ผ่านพร็อกซีจะใช้เมธอด CONNECT และพร็อกซีส่งสตรีมไบต์ที่เข้ารหัสโดยไม่เห็นเนื้อหาของมัน มันไม่สามารถตัดหรือเปลี่ยน header ภายในได้ทางกายภาพ แต่สำหรับคำขอ HTTP ธรรมดา พร็อกซีแยกวิเคราะห์ header เอง และที่นี่อาจมีทั้งขีดจำกัดและการตัด
จะรู้ได้อย่างไรว่า header ถูกตัด ถ้าไม่มีข้อผิดพลาด?
ตั้งเอ็นด์พอยต์สะท้อนกลับจากขั้นตอนที่ 4 ส่ง header ที่มีความยาวที่รู้พร้อมเครื่องหมายตำแหน่ง และเปรียบเทียบความยาวและแฮชของค่าที่ได้รับกับที่ส่งไป ความไม่ตรงกันจะแสดงทั้งข้อเท็จจริงของการตัดและตำแหน่งรอยตัด
Nginx ปล่อยผ่าน แต่แอปพลิเคชัน Node.js ตอบ 431 ควรทำอย่างไร?
เพิ่มขีดจำกัด Node.js ด้วยแฟล็ก --max-http-header-size หรือพารามิเตอร์ maxHeaderSize ใน createServer จากนั้นปรับขีดจำกัด nginx ให้เท่ากันหรือน้อยกว่า เพื่อให้การปฏิเสธเกิดขึ้นที่ชั้นภายนอกพร้อมหน้าที่เข้าใจได้
อะไรสำคัญกว่าที่จะจำกัด: ขนาดของ header เดียวหรือขนาดรวม?
ทั้งสองอย่าง ขนาดรวมป้องกันหน่วยความจำ ส่วนขีดจำกัดต่อฟิลด์ป้องกันตัวแยกวิเคราะห์ ใน nginx ขีดจำกัดทั้งสองมาจาก large_client_header_buffers: ขนาดบัฟเฟอร์คือขีดจำกัดต่อบรรทัด และจำนวนบัฟเฟอร์คูณขนาดคือขีดจำกัดรวม
ควรดักจับ 431 บนไคลเอนต์และล้าง cookie อัตโนมัติไหม?
สำหรับเว็บไซต์ของคุณเอง นี่เป็นเทคนิคที่ยอดเยี่ยม: เมื่อได้รับการตอบกลับ 431 หรือ 400 ที่มีข้อความที่ต้องการ ฟรอนต์เอนด์จะลบ cookie ที่ไม่จำเป็นอย่างชัดเจนและทำซ้ำคำขอ อย่าลบ cookie การอนุญาตโดยไม่ได้รับความยินยอมจากผู้ใช้ และต้องบันทึกเหตุการณ์ดังกล่าวเพื่อขจัดรากของปัญหา
จะยืนยันได้อย่างไรว่าเฟรมเวิร์กเวอร์ชันใหม่ไม่ได้เปลี่ยนขีดจำกัดเริ่มต้น?
เก็บการตรวจสอบสังเคราะห์จากขั้นตอนที่ 7 และการทดสอบใน CI จากส่วนความสามารถเพิ่มเติม ทั้งคู่ส่งคำขอที่ขอบของขีดจำกัดและจะแสดงทันทีหากเกณฑ์เลื่อนไปในทิศทางใด
บทสรุป
มาสรุปสิ่งที่คุณได้ทำ คุณเรียนรู้ที่จะทำซ้ำข้อผิดพลาดและแยกแยะ 431, 494 และรูปลักษณ์สาธารณะของมันในรูปแบบ 400 ด้วยลายเซ็นของการตอบกลับ คุณวัดขนาดจริงของ header และ cookie และพบเกณฑ์การปฏิเสธผ่านการค้นหาแบบไบนารีด้วย curl คุณพิจารณาว่าโหนดใดในห่วงโซ่เป็นผู้รับผิดชอบการปฏิเสธ และแยกปัญหานี้ออกจากรหัสชั้นพร็อกซีอย่าง 407, 502 และ 504 โดยเก็บเครื่องหมายที่มีประโยชน์เกี่ยวกับ upstream sent too big header ไว้ ด้วยเอ็นด์พอยต์สะท้อนกลับคุณจับหรือตัดความเป็นไปได้ของการตัดแบบเงียบที่ทิ้งร่องรอยใน log จากนั้นคุณลด cookie แยก API ไปยังโดเมนที่สะอาด ปรับขีดจำกัดให้สอดคล้องกันใน nginx, Apache, Node.js, Tomcat, Gunicorn และ HAProxy ทำให้การปฏิเสธชัดเจน และเชื่อมต่อการมอนิเตอร์
สิ่งที่ต้องทำต่อไป ในสัปดาห์หน้าให้สังเกตเมตริกขนาดคำขอและตัวนับ 431: พวกมันจะแสดงว่าแหล่งที่มาของการเติบโตของ cookie ยังเหลืออยู่หรือไม่ ตั้งกฎให้ทีม: cookie ใหม่ทุกตัวผ่านการรีวิวพร้อมคำถามเกี่ยวกับขนาด โดเมน และพาธ หากโปรเจกต์ใช้เซสชันใน cookie ในรูปแบบสถานะแบบ serialize ให้วางแผนการย้ายไปยังการเก็บบนเซิร์ฟเวอร์ที่มีตัวระบุสั้น
ทิศทางที่จะพัฒนา ระดับถัดไปคือความเข้าใจเชิงลึกเกี่ยวกับการบีบอัด header ใน HTTP/2 และ HTTP/3 การปรับบัฟเฟอร์อย่างละเอียดภายใต้โหลด และการสร้างชั้นสังเกตการณ์ที่โปร่งใสซึ่งขนาดของทุกคำขอปรากฏในการติดตาม ยังมีประโยชน์ที่จะศึกษาว่าขีดจำกัดทำงานอย่างไรเมื่อทำงานผ่านพร็อกซีและโหลดบาลานซ์ประเภทต่างๆ และสร้างตารางเกณฑ์ของตัวเองสำหรับโครงสร้างพื้นฐานที่คุณทำงานด้วย เครื่องมือที่รวบรวมไว้ในคู่มือนี้ รวมถึงเอ็นด์พอยต์สะท้อนกลับและลูป curl จะอยู่กับคุณและจะประหยัดเวลาหลายชั่วโมงในทุกครั้งที่เกิดการปฏิเสธที่ไม่คุ้นเคยครั้งถัดไป คุณทำสำเร็จแล้ว และตอนนี้ปัญหาประเภทนี้ก็ไม่ใช่ปริศนาอีกต่อไป