Skip to main content
Blog|
Latest news

NGINX2Root: what the nginx HTTP/2 vulnerabilities do, and how we patched in under four hours

|
Nov 18, 2026|11 min read
LATEST NEWSNGINX2Root: what the nginxHTTP/2 vulnerabilities do, andhow we patched in under fourhoursHOSTNEY™hostney.comNovember 18, 2026

Short answer: On November 18, 2026, nginx published security releases that fix ten vulnerabilities. The two that made the headlines, CVE-2026-123007 and CVE-2026-123633, are memory bugs in nginx’s HTTP/2 code that an attacker can reach without logging in to anything, and F5 rates both 9.2 on the CVSS v4.0 scale. Hostney had the fixed nginx running on the web servers that host customer websites 3 hours and 43 minutes after F5 published the CVEs. The software our web servers are built on had not shipped a fixed version yet, so we moved our build onto the new nginx release ourselves, proved the result was nginx’s signed code with every patch in its old place, and tested it against the build it replaced before it reached a server. If your sites are on Hostney, there is nothing to do. If you run nginx yourself, update and restart it (a reload is not enough), and turn HTTP/2 off until you can.

What happened#

At 15:23 UTC on November 18, F5, the company behind nginx, published the CVE records for the batch. The security advisories page on nginx.org followed at 15:49 UTC with ten entries, all fixed in the stable and mainline releases nginx published the same day. Several security firms have taken to calling the batch NGINX2Root.

The ratings depend on who you ask. F5 rates both HTTP/2 bugs critical, 9.2 on CVSS v4.0. nginx.org’s own advisory page rates CVE-2026-123007 major and CVE-2026-123633 medium. nginx credits Xint.io with finding the first and Albert of Vexera AI with the second. Wiz Research reports that it built proof-of-concept exploits and is keeping them private.

nginx published no separate patch files this time. The new releases were the only fix, and on release day the nginx packages of the major Linux distributions did not carry it yet.

What the two HTTP/2 bugs do#

HTTP/2 lets a browser send many requests over one connection at the same time. To stop a fast sender from overwhelming a slow receiver, each side tells the other how much data it may send before waiting. That allowance is the flow-control window, and the receiver raises it with WINDOW_UPDATE frames as it works through the data. Both bugs sit in the code that does this bookkeeping for a connection and its streams.

CVE-2026-123007: a flow-control window nginx did not check#

Wiz describes the root cause as incorrect flow-control accounting that leads to an invalid memory copy. When nginx gives window space back, it does not check the result against the maximum HTTP/2 allows, so a client that sends a large number of WINDOW_UPDATE frames can drive the window to values the code never expected. nginx’s changelog puts the outcome as a crashed worker process “or potential other impact”, and Wiz reports turning it into code execution.

This bug needs very little. HTTP/2 has to be on, and that is the whole list: no backend application, no third-party module, no unusual setting. Wiz demonstrated it against nginx serving content directly over HTTPS on 64-bit systems. Every nginx release with HTTP/2 since 2015 is in range.

CVE-2026-123633: running out of connection slots#

This one is narrower. nginx’s changelog describes a use-after-free in HTTP/2 “if worker_connections were not enough”, and Wiz places it in reverse-proxy processing when the available connection slots run low. The exposed setup is a server that passes requests to a backend, as nginx does in front of PHP, Node.js and most application servers, under enough load to approach its connection limit. An attacker can supply the load.

The other eight fixes in the same release#

The same releases fix eight more bugs, which got less attention:

  • A use-after-free in HTTP/3, also when worker connections run short.
  • A use-after-free in the resolver, when the same name is looked up by several subrequests at once.
  • An endless loop in a worker process while it reads a request body over TLS.
  • A use-after-free in the mail proxy.
  • Client certificates in the stream module checked against the default server’s settings instead of the server picked by SNI.
  • Malformed TLS ClientHello messages read differently by the stream ssl_preread module than by other TLS implementations.
  • A crash with PROXY protocol version 2 and dynamically loaded certificates.
  • A buffer overflow with try_files and alias in certain configurations.

Two of these change the picture for the workaround everyone reaches for first. The TLS loop needs no HTTP/2 at all, and the HTTP/3 bug lives in the other new protocol. Turning HTTP/2 off closes two of the ten. The update closes all of them.

Why a security plugin or a firewall rule cannot help#

Flow control happens at the connection level, underneath anything that looks like a request. A WordPress security plugin runs inside PHP, after nginx has done its work, and a web application firewall rule inspects requests nginx has already parsed. Neither one ever sees a WINDOW_UPDATE frame. It is the same position we described for PHP2Shell in October: server-level security is the only layer that can deal with a bug like this, and for a bug in the web server itself, that means updating the web server.

What we did on Hostney#

The release we build on had not caught up#

Hostney’s web servers run OpenResty, a distribution of nginx that bundles the nginx core with its own patches and modules (why we run nginx in the first place). OpenResty releases follow nginx’s, and on November 18 there was no OpenResty release with the fixed nginx yet. Waiting for one would have left customer sites on a vulnerable web server for a number of days nobody could predict.

So we made the move ourselves. We took the OpenResty source our servers already ran and moved it onto nginx’s fixed release with OpenResty’s own upgrade tooling, the same scripts its maintainers use when a new nginx comes out. We did not write any of the code. The nginx code is nginx’s, the patches are OpenResty’s, and the only change between the build production ran and the new one is the nginx release underneath.

Three checks before it touched a server#

A build like this is only as good as the checks around it, so the pipeline that produces it stops when any of these fails.

The nginx code is nginx’s signed release. OpenResty builds from nginx’s tagged source code instead of the release download, and its patches expect that layout. We rebuilt it from nginx’s own repository and compared it, file by file, with the release download from nginx.org, after verifying the download’s signature against the key nginx’s release manager publishes. The only differences allowed are packaging ones, such as the changelog nginx generates for its downloads. One changed line anywhere in the code stops the build.

OpenResty’s patches landed where they belong. OpenResty carries more than forty patches to the nginx core, and every one the build uses applied to the new release. Some needed a little leeway to find their place, and they needed exactly the same leeway on the previous release. To be sure that leeway put each change in the right spot, we built the same tree a second way: OpenResty’s patches applied to the previous nginx release, with nginx’s own changes between the two releases merged on top. The two trees came out identical. The only place the merge needed a decision was the version number itself.

It behaves like the build it replaces. Our test rig sets up two servers side by side, one with the build production was running and one with the new build, configured the way our platform configures real sites: WordPress, static sites, Node.js apps, redirects, page caching, the firewall and bot protection. It runs the same 275 tests against both, over HTTP/1.1, HTTP/2 and HTTP/3, deliberately malformed requests included, and compares every answer. We ran it on both operating system versions we build for. Exactly one answer changed: a request carrying a header line without a colon now gets 400 Bad Request, a change nginx made on purpose in this release (what a 400 from nginx means). Every other answer was identical apart from timestamps and randomised content.

We also broke each check on purpose to make sure it fails: a wrong release, a wrong checksum, another version’s code, one tampered line. One check let a case through that it should have stopped. A comparison that could not run at all printed nothing, and the check read the silence as a clean result. We fixed it before the build went anywhere.

The rollout#

Time (UTC, November 18)Step
15:23F5 publishes the CVE records
15:49nginx.org publishes its advisories
18:53The fixed build is ready, testing starts
19:04The tested package is published to our package repository
19:06The web servers that host customer sites are running the fixed nginx

The update restarts nginx. A reload would only re-read the configuration: the old master process stays, and the old code with it, so only a restart puts the patched binary to work. A restart drops open connections, which browsers retry within a moment. Had the new version failed its configuration test or its restart, the update would have put the previous version back by itself. After the restart we checked on the server itself that the running process is the new binary and that HTTP/2 answers normally.

We kept HTTP/2 on throughout. Switching it off would have slowed every site for the hours the fix took, and it closes only two of the ten bugs.

What you should do#

If your sites are on Hostney#

Nothing. The web servers that host your sites run the fixed nginx, and none of your settings changed. If a script or monitoring tool of yours sends hand-built HTTP requests, it is worth a look: a header line without a colon now gets a 400 from the server, as it does on any up-to-date nginx.

If you run nginx yourself#

Find out what you run. nginx -V prints the version and the build options. If nginx comes from your Linux distribution, the version number may stay the same after the fix, because Debian, Ubuntu and Red Hat backport security fixes into their own packages. Search the package changelog for the CVE IDs instead:

# Red Hat, AlmaLinux, Rocky Linux
rpm -q --changelog nginx nginx-core 2>/dev/null | grep -E 'CVE-2026-12(3007|3633)'

# Debian, Ubuntu
zgrep -E 'CVE-2026-12(3007|3633)' /usr/share/doc/nginx*/changelog.Debian.gz

No output means the fix is not in the installed package yet.

Update, then restart. Install the stable or mainline release nginx published on November 18, 2026, or anything newer, or your distribution’s fixed package once it exists. Then restart the service with sudo systemctl restart nginx (managing services with systemctl covers the difference between restart and reload).

If you run OpenResty or another product that bundles its own copy of nginx, the fix arrives with that product’s release. An update to your distribution’s nginx package does not touch the bundled copy.

If you cannot update right away, turn HTTP/2 off. nginx has two ways to switch it on, and a config can use both. Newer nginx has an http2 on; directive inside a server block. Older nginx, and plenty of configs written for it, put an http2 parameter on the listen line, as in our HTTP to HTTPS guide. Find every occurrence first:

sudo nginx -T 2>/dev/null | grep -nE '^\s*http2\s|listen[^;]*\bhttp2\b'

Change every http2 on; to http2 off; and remove http2 from every listen line. The listen parameter needs the most care. http2 off; does not override it, and it belongs to the port instead of the site: if a single server block on port 443 still has it, every site on that port keeps HTTP/2. If you also serve HTTP/3, remove the quic listeners, http3 on; and the Alt-Svc header the same way. That closes the HTTP/3 bug from the same release.

A reload applies the change, although old worker processes can keep serving HTTP/2 to connections that were already open until those close. Check from outside afterwards:

openssl s_client -connect example.com:443 -servername example.com -alpn h2 </dev/null 2>/dev/null | grep -i alpn

“No ALPN negotiated” means HTTP/2 is off for that name. Check each site name separately, and turn HTTP/2 back on once you have updated.

A CDN in front is no guarantee. It protects the server only if the server accepts connections from the CDN alone. Anyone who learns the origin’s address can speak HTTP/2 to it directly.

If nginx proxies to backends, as in a reverse proxy for several domains, you are also in the setup CVE-2026-123633 needs, and raising worker_connections is no substitute for the update.

Signs to look for#

Crashed worker processes leave a line in the error log:

sudo grep -E 'worker process [0-9]+ exited on signal' /var/log/nginx/error.log

Wiz names unexpected worker crashes and commands started by nginx’s worker processes as general warning signs. Neither confirms an attack, and a missing crash does not rule one out, but a crash after November 18 on a server that never crashed before deserves a closer look. If you find more than that, our hacked site guide covers the cleanup.

Summary#

NGINX2Root is a batch of ten nginx vulnerabilities fixed on November 18, 2026. The two worst, CVE-2026-123007 and CVE-2026-123633, are memory bugs in nginx’s HTTP/2 code: the first needs nothing but HTTP/2 being switched on, the second hits servers that proxy to a backend when connection slots run low. No plugin or firewall rule can stop either one, and turning HTTP/2 off closes only two of the ten bugs, so updating nginx and restarting it is the fix. Hostney did not wait for a fixed release of OpenResty, the nginx distribution our web servers run: we moved our build onto nginx’s fixed release, checked it against nginx’s signed code and against the build it replaced, and had it running on the web servers that host customer websites 3 hours and 43 minutes after the CVEs went public. Sites on Hostney need nothing from their owners. If you run nginx yourself, update and restart today, and turn HTTP/2 off until you can.

Related articles