Seeing HTTP/2 in browser developer tools does not prove that an underlying NGINX server is exposed to recent HTTP/2 vulnerabilities. A browser may negotiate HTTP/2 with an edge CDN that forwards requests to the origin over HTTP/1.1. Conversely, an alternate hostname or direct load balancer route might still deliver HTTP/2 straight to that origin.
Evaluating exposure to CVE-2026-123007 and CVE-2026-123633 requires answering three distinct questions: which executable is running, which protocols its active listeners accept, and which clients can reach those listeners. Matching an affected version confirms a patching requirement, but a version number alone does not prove an exploitable path exists.
Advisory check: November 18, 2026. This is a source-based defensive runbook, not an exploitation test or a claim that every NGINX deployment is vulnerable.
On this page
Two HTTP/2 bugs, a wider security release#
The official NGINX security advisory index identifies both defects and lists NGINX 1.30.7 on the stable branch and 1.31.9 on mainline as fixed releases. Use a supported fixed release or a vendor package whose advisory explicitly documents the backport.
| Issue | Upstream introduction | First fixed stable / mainline | NGINX severity |
|---|---|---|---|
| CVE-2026-123007: memory corruption in HTTP/2 flow control | 1.9.5 | 1.30.7 / 1.31.9 | Major |
| CVE-2026-123633: use-after-free in HTTP/2 | 1.19.7 | 1.30.7 / 1.31.9 | Medium |
Those introduction versions are not minimum safe versions. Unpatched upstream releases between introduction and the relevant fixed branch release remain affected. Distribution backports require checking the full package revision, not just the short version banner.
Because the same security release also resolves DNS resolver and HTTP/3 defects, turning off HTTP/2 only mitigates protocol-specific exposure rather than making the broader update unnecessary. Keep the full upgrade scheduled even on systems where neither HTTP/2 vulnerability is reachable.
F5’s published CVE records for CVE-2026-123007 and CVE-2026-123633 describe worker crashes and possible remote code execution. The latter requires HTTP/2 client connections, backend proxying and low remaining worker_connections. F5 conditions code execution on ASLR being disabled or bypassed; ASLR is not a substitute for patching.
Both records carry a CVSS 4.0 score of 9.2. The table preserves nginx.org’s separate qualitative severity labels rather than presenting them as CVSS categories. This runbook does not reproduce attacks or claim that a demanding exploit is harmless.
Build an exposure record for each hop#
Draw the request path from public endpoint to application. Separate the CDN, load balancer, ingress controller, reverse proxy and application server. Record where TLS terminates and the protocol used on each connection. A product name alone cannot answer those questions.
Application-layer proxies terminate incoming client sessions and open independent upstream connections. Even if both hops negotiate HTTP/2, the proxy generally reconstructs traffic rather than forwarding raw client frames intact. Document both the upstream protocol and any direct-to-origin bypass paths; sitting behind a CDN guarantees neither safety nor exposure. By contrast, a TCP pass-through load balancer forwards raw traffic without providing an application-layer boundary.
Do not infer origin software from a public Server header. Likewise, an Apache-based application container does not rule out an NGINX proxy in front of it. Mark a hop unknown when its executable, configuration or reachability cannot be established; do not convert missing access into a clean bill of health.
Inspect the actual executable and effective configuration#
Run the following inside the relevant host or container, using the executable and configuration arguments of the running service. The NGINX command-line documentation defines the version, build and configuration inspection switches.
nginx -v
nginx -V
umask 077
nginx -T > nginx-config.private.txt 2>&1
Inspect the exit status and the private output. A failed configuration read is not evidence that HTTP/2 is disabled. Configuration dumps can contain credentials, internal addresses and private paths; keep them on the authorized system rather than pasting them into tickets or public scanners.
The HTTP/2 module documentation distinguishes compiling the module from enabling the protocol. Look for the module in build options, then inspect active HTTP and server contexts for the current http2 directive and older listen-line syntax. Follow includes and inheritance rather than searching only the main file.
Log the exact package revision or container image digest alongside your configuration findings. After an upgrade on disk, running nginx -v checks the newly installed binary even if a long-running master process is still executing the unpatched image in memory. Always pair version output with proof of process replacement or pod rollout.
Contain HTTP/2 exposure without breaking gRPC#
When patching must wait for a maintenance window, turning off HTTP/2 strips the vulnerable protocol from affected listeners. Treat this strictly as temporary risk reduction rather than a vendor-endorsed workaround—F5's CVE advisories list none. On NGINX 1.25.1 and newer, disable the protocol within the relevant http or server block:
http2 off;
Remove legacy http2 parameters from affected listen directives too, and check every relevant virtual server. Earlier releases do not recognize the standalone directive; change their listen configuration instead. Review generated controller configuration through its supported settings rather than editing files that it will overwrite.
Validate the configuration syntax before reloading production traffic. While a reload spawns updated worker processes, graceful shutdown allows older workers to stay alive until existing connections close. Verify that legacy workers have exited and prior HTTP/2 sessions have drained before marking containment complete.
The NGINX gRPC module requires the HTTP/2 module, and native gRPC clients depend on HTTP/2. Turning it off can trade a security exposure for an outage. For those routes, prioritize a patched supported ingress or proxy, or restrict reachability through an approved alternative. Test real gRPC calls, not just a successful homepage request.
Identify the Kubernetes controller before choosing a fix#
Community ingress-nginx and F5’s NGINX Ingress Controller are different projects. NGINX Gateway Fabric is another product. Their release numbers and support commitments are not interchangeable, so a chart name or the word nginx is not a sufficient inventory.
The Kubernetes retirement announcement set March 2026 as the end of community Ingress NGINX maintenance, with no subsequent upstream releases or security fixes. Existing deployments continue to function; continued availability of an old image does not mean continued maintenance.
kubectl get pods --all-namespaces --selector=app.kubernetes.io/name=ingress-nginx
This label-based query is a starting point, not proof of absence when it returns nothing. Check controller images, installation records and generated listeners. For vendor-supported forks, require that vendor’s explicit fixed-build evidence rather than assuming either upstream retirement or upstream fixes apply unchanged.
Plan migration to a maintained controller or Gateway API implementation, including compatibility checks for annotations, certificates, authentication and gRPC. Also review what an ingress workload can access: the separate guide on Kubernetes Secret access boundaries explains why namespace permissions matter if a workload is compromised.
Replace the binary, then close the incident with evidence#
Installing a package and reloading configuration are different operations. The NGINX process-control documentation distinguishes configuration reload from executable upgrade. Use your supported service restart, controlled container replacement or documented binary-upgrade procedure, and verify that no old workers remain.
Before rollout, preserve a rollback path and check module compatibility. Afterward, verify the deployed image or package, process start state, effective listeners, ordinary pages and protocol-dependent routes. The earlier PHP and Node.js runtime patching guide covers the same mistake: updating application files does not replace the vulnerable runtime beneath them.
Keep exposure assessment separate from compromise assessment. A matching version does not prove intrusion, and ordinary access logs cannot rule out every protocol-level attempt. Preserve relevant error, network and process telemetry for investigation rather than running a crash-triggering proof of concept against production.
Mark an inventory item remediated only after recording the patched build identifier, proof that running processes were replaced, and verification of the full request path. If an exploit prerequisite is missing, document that narrower finding while keeping the upgrade scheduled. Where visibility is incomplete, assign an owner to investigate rather than assuming the service is unaffected.
Leave a Reply