← Back to blog
CVEnginxHTTP/2remote code execution

nginx HTTP/2 RCE (CVE-2026-123007): Public Exploit and Fixes

nginx HTTP/2 RCE (CVE-2026-123007, CVE-2026-123633) has a public exploit. Fixed in 1.30.7 and 1.31.9. Check if you're exposed and how to patch.

Darius J Davis · November 19, 2026

#Heads up: there's a public exploit, and your setup decides whether it reaches you.

On November 18, 2026, nginx shipped 1.30.7 and 1.31.9. The release fixes ten advisories. Two of them are memory bugs in the HTTP/2 code, CVE-2026-123007 and CVE-2026-123633, part of the batch some researchers are calling NGINX2Root. HTTP/2 is the newer, faster version of the language browsers and websites use to talk to each other.

Wiz confirmed remote code execution on official 1.31.7 and 1.31.8 builds, meaning a stranger can run their own commands on the server. They did it with an ASLR bypass, which gets around a standard memory protection. No login needed.

nginx runs a huge share of the web. If you have a website, an online store, a customer portal or an API (the behind-the-scenes connection other software uses to talk to yours), there's a good chance nginx sits somewhere in front of it. Sometimes you know. Sometimes it's buried inside a product you bought.

#The short version for business owners.

  • What it is: two bugs in nginx, the software that receives web traffic for a lot of sites, that can let a stranger run code on that server. No login needed.
  • Does it apply to you? Only if your nginx speaks HTTP/2 to visitors. Often that depends on what sits in front of it: a load balancer (the traffic cop in front of your web servers) or a CDN (a service like Cloudflare that delivers your site from servers around the world).
  • What fixing it costs: an nginx upgrade and a restart. If you can't upgrade yet, a two-part setting change.
  • What waiting costs: a public exploit already exists. Waiting means leaving it open through Thanksgiving and Black Friday, which for a lot of shops is the busiest weekend of the year.
  • My advice: patch this week. If someone else runs your site, get their answer in writing before Wednesday.

#If someone else runs your site.

Most small businesses don't run nginx themselves. If your site lives on a hosting company, a managed WordPress platform or a website builder, send them one email: "Are you affected by CVE-2026-123007 and CVE-2026-123633, and when will you be on nginx 1.30.7 or 1.31.9?" Get the answer in writing.

If a CDN sits in front of your site, also ask whether your origin server can be reached directly, without going through the CDN. More on why below.

The next few sections are for whoever decides when to act. After that it gets technical, for whoever runs the servers.

I spent the last day working through this one. Most of what I learned was about finding the nginx nobody knew was there, and about how the load balancer in front changes the answer.

#Risk vs reward: act this week, or after the holidays?

A quick decoder for the table. TLS is the encryption behind the padlock in your browser. ALPN is the quick handshake where a visitor and your server agree on which version of HTTP to use. gRPC is a way programs talk to each other that only works over HTTP/2.

Act this weekWait until after the holidays
What it costs youAn nginx upgrade and a restart. Or, as a stopgap, http2 off in nginx plus an ALPN change on the load balancer, in the same release.Nothing today.
What can go wrongTurn off HTTP/2 in nginx but not on a TLS-terminating load balancer, and the site breaks. gRPC services need HTTP/2 and can't use the stopgap at all.A public exploit stays pointed at an open server through Thanksgiving week, while your team is out.
Worst caseA short maintenance window and a rollback.Someone runs code on the server in front of your store, portal or API, on your busiest weekend.

#Why waiting costs more than it looks.

There's a public exploit. Upwind reports Rapid7 published a crash trigger and RCE chain for Debian 13 amd64 builds of 1.31.6 and 1.31.8, and Check Point confirms a public proof of concept exists for CVE-2026-123007. That's the big difference from Java4Shell, where no public exploit or exploitation has been reported yet.

Holidays are when attackers move. CISA and the FBI warned in 2021 about high-impact ransomware attacks on holidays and weekends, "when offices are normally closed." CISA is the federal government's cybersecurity agency.

Semperis found that more than three-quarters of companies cut SOC staffing by half or more on holidays and weekends. (A SOC, or security operations center, is the team that watches for attacks.) Sophos found that 88% of ransomware payloads are deployed outside business hours.

Patches get turned into exploits fast. nginx is open source, so the patch shows exactly what changed. On November 16, Google's threat intelligence team reported attackers using an AI framework that diffs patched code in popular web software, drafts an exploit and runs it, with no human in the loop. Last month, PHP2Shell exploitation started four days before the patch shipped.

Busy weekends make one of these bugs easier. CVE-2026-123633 needs a worker (one of the nginx processes that handles visitors) near its connection limit. Think about when your servers run closest to that limit. For a lot of shops, that's Black Friday.

That's my inference. Nobody has reported an attack like it. Still, it's a good reason not to wait.

A breach costs far more than a restart. IBM's Cost of a Data Breach Report 2026 puts the global average cost of a breach at $4.99 million, a record high. That's an average across organizations of every size. Your number may be smaller, but so is the bank account that has to absorb it.

#When your risk is genuinely low.

Not everyone needs to rush. The middle two items are for your IT person, so forward this if the terms are new. Your exposure is low if:

  • HTTP/2 isn't on. Upwind notes that stock nginx ships with HTTP/2 off: "no shipped config enables it." Check what your config actually says.
  • Port 443 is an L4 stream passthrough with ssl_preread. nginx never terminates TLS there, so it never negotiates HTTP/2.
  • A CDN or L7 load balancer speaks HTTP/1.1 to your origin, and nothing else can reach the origin. Client HTTP/2 stops at the CDN.
  • For CVE-2026-123633 specifically, nginx isn't working as a reverse proxy, or its workers never get close to worker_connections.

To be fair to these bugs: as of disclosure, Check Point reports no confirmed attacks in the wild and no listing in CISA's Known Exploited Vulnerabilities catalog. It also says the public exploit needs about 128 GB of HTTP/2 traffic on one connection and likely fails through a proxy.

Check Point adds that it needs an AVX-512 processor, but Upwind says AVX2 also works, so an older CPU won't save you.

Xint and Wiz are holding back their exploits, and so is Metnir. The public chain came from Rapid7, which also found the bugs independently. None of that makes the public one go away. Plan as if it works.

Bottom line: the upgrade is cheap and a miss is expensive. There are no confirmed attacks yet, which gives you a short window. Use it this week, before the freeze.

#What the two bugs are.

From here down, this is for whoever runs your servers.

CVE-2026-123007: HTTP/2 flow control. When a stream is cancelled, nginx refunds its unsent bytes to the connection's send window without checking the HTTP/2 maximum. A later check does unsigned math that wraps around, and from then on the window is garbage.

That turns into an out-of-bounds memory copy, then heap corruption, then code execution. F5 classifies it as an integer underflow (CWE-191). Some write-ups call it an overflow, so expect to see both terms.

  • Vulnerable: 1.9.5 through 1.31.8. That's every release since HTTP/2 support arrived in 2015.
  • Wiz showed RCE serving plain static files, with no backend app and no third-party module.
  • The catch is volume. Upwind estimates about 60 GB on one connection to crash a worker and about 128 GB to execute code. Loud. Not impossible.

CVE-2026-123633: use-after-free on reusable connections. A partial HEADERS frame on an idle connection gets it marked reusable. When the rest arrives, nginx creates the request but never takes the connection off the reusable list. If the worker is short on connection slots, nginx reclaims it while the request is still using it. Metnir calls it Drainbreak.

Both are fixed in 1.30.7 and 1.31.9.

#Severity depends on who you ask.

nginx.org rates CVE-2026-123007 "major" and CVE-2026-123633 "medium." F5 scores both at CVSS 4.0 9.2 and CVSS 3.1 8.1 (K000163926, K000163928). Those don't line up, and they don't have to.

The "medium" reflects narrow preconditions. The 9.2 reflects what happens when they're met. Read the preconditions, then decide for your own servers.

#Who is actually exposed.

Stock nginx doesn't turn HTTP/2 on unless you configure it. Plenty of setups do configure it, though, often without anyone choosing to. Before you call a server exploitable, ask three questions:

  1. Does this nginx terminate TLS?
  2. Does it advertise h2 in ALPN?
  3. Can an untrusted client reach it?

If all three are yes, patch it today. One caveat, covered in Lesson 2: a load balancer in front can change the answer in either direction.

#Lesson 1: You run more nginx than you think.

The servers with nginx in the config are the easy part. The hard part was everything else:

  • Embedded nginx. OpenResty-based API gateways and ingress controllers compile nginx in. Their version number is the product's, not nginx's. You have to map one to the other from the build manifest.
  • HTTP/2 on by default. The community Kubernetes ingress-nginx turns HTTP/2 on by default. Gateway charts can do the same on the TLS listener without anyone setting it.
  • Dead and forked projects. That same ingress-nginx project is archived and won't get a fix. Forks like OpenResty, Tengine, Angie and freenginx may carry the same code and may lag.

Scanners missed the embedded copies. A scanner can flag plain nginx images reliably and say nothing about a gateway image with OpenResty inside, because it never identifies the nginx in there. A clean scan for those images proves nothing. Think of a home inspector who signs off on the house without ever opening the basement door.

The opposite happens too. Some images get flagged Critical on version alone, and the running config has no HTTP/2 at all. A custom nginx.conf with only a plain HTTP listener. A port 443 that's an L4 stream passthrough with ssl_preread, so nginx never terminates TLS there. Patch those anyway, as hygiene. Don't burn your emergency on them.

#Lesson 2: Your load balancer decides whether HTTP/2 reaches nginx.

It comes down to what sits in front of nginx and where TLS ends.

Four traffic paths to nginx: L4 passthrough and L4 TLS-terminating load balancers deliver HTTP/2 to nginx, an L7 load balancer or CDN stops it, and a direct path to the origin load balancer skips the CDN
Four traffic paths to nginx: L4 passthrough and L4 TLS-terminating load balancers deliver HTTP/2 to nginx, an L7 load balancer or CDN stops it, and a direct path to the origin load balancer skips the CDN
  • L4 load balancer passing TCP straight through: nginx is exposed directly. Whatever nginx negotiates, the client gets.
  • L4 load balancer that terminates TLS: the load balancer negotiates ALPN with the client using its own policy. If that policy prefers HTTP/2, it speaks h2 to the client and forwards h2 frames to nginx.
  • L7 load balancer or CDN: usually speaks HTTP/1.1 to the origin, so client HTTP/2 never reaches nginx. Check the backend protocol setting. Several cloud L7 load balancers can speak HTTP/2 to the backend if configured to.

The gotcha that cost the most time: turning off HTTP/2 on nginx alone, behind a TLS-terminating L4 load balancer that still prefers h2, breaks the site. The client doesn't fall back. The load balancer already agreed to h2 with the client, and it keeps forwarding h2 frames to a backend that now only speaks HTTP/1.1.

Picture the load balancer still talking h2 into the phone long after nginx stopped understanding a word of it. The fix has to change both layers in the same release: remove http2 from the nginx listener, and set the load balancer's ALPN policy to HTTP/1.1 only.

#Find the paths that skip your CDN.

The public hostname can go through a CDN that speaks HTTP/1.1 to the origin and look safe. Then you find the origin load balancer is internet-facing, and anyone with its hostname can speak h2 to it directly. Private links and internal clients can reach it without the CDN at all. Map every way traffic reaches the listener, including the ones that aren't in DNS.

#Lesson 3: Verify from outside your network.

If your office network does TLS inspection, the proxy terminates TLS itself. An openssl ALPN test from behind it shows you the proxy's certificate and the proxy's protocol choice. Check the issuer line. If it's your own security proxy, the test told you nothing, because your proxy was answering for nginx the whole time. Run it from a phone hotspot or a cloud shell instead.

Three checks settle each target. Replace HOST and NAME with your hostname:

echo | openssl s_client -connect HOST:443 -servername NAME -alpn h2,http/1.1 2>/dev/null | grep -E 'ALPN|issuer='
curl -sk --http2 -o /dev/null -w '%{http_version} %{http_code}\n' https://HOST/
nginx -T 2>/dev/null | grep -nE 'listen|http2|quic|http3|resolver'

The first shows which protocol the endpoint actually negotiates. The second shows whether an HTTP/2 client gets HTTP/2 back. The third, run on the server or inside the container, shows what nginx is really configured with.

Here's what those checks look like across the four paths in the diagram, including the ALPN mismatch:

~/southside/triage · nginx HTTP/2 (CVE-2026-123007, CVE-2026-123633) · four paths

Two more traps:

  • nginx -v is not a patch check on distro packages. Distributions backport fixes without bumping the version. Check your distro's security tracker.
  • Reload does not replace the binary. After upgrading, restart nginx. A reload keeps the old code running, which is a great way to patch a server without actually patching it.

#The workaround, and what it doesn't cover.

If you can't patch today, set http2 off; (nginx 1.25.1 and later) or remove http2 from the listen line. If a TLS-terminating load balancer sits in front, set its ALPN to HTTP/1.1 only in the same change. One limit: Check Point notes gRPC services need HTTP/2 and can't use this workaround.

Turning off HTTP/2 blocks two of the five RCE-class bugs in this release. The rest need their own fixes:

  • CVE-2026-123634, resolver use-after-free. Avoid proxy_pass targets built from the request when resolver is set. Use a fixed upstream group. Turning off mirror alone isn't enough.
  • CVE-2026-121810, HTTP/3 use-after-free. Remove quic listeners, set http3 off;, send Alt-Svc: clear, and block UDP on that port.
  • CVE-2026-113425, mail proxy use-after-free. Bind mail listeners to loopback, or allow only trusted source IPs.
  • Plus an infinite loop on TLS 1.3 request bodies, an SNI bypass in stream, and a few minor bugs. The upgrade covers all of them.

On container hosts there's one more step. Researchers chained CVE-2026-123007 with an unpatched Linux kernel SCTP bug to get root on the host from inside a container. If you don't need SCTP, add install sctp /bin/false to a file in /etc/modprobe.d/. That does nothing if SCTP is built into the kernel or already loaded.

#Detection has gaps.

Patching is the fix. Detection tells you whether to dig further. Watch for:

  • Worker crashes, signal 11 or signal 6, in the nginx error log.
  • worker_connections are not enough, reusing connections warnings. That's the precondition for CVE-2026-123633.
  • nginx workers spawning child processes. They should never execve. An auditd rule on the worker user catches it.
  • One long-lived TLS connection with tens of gigabytes inbound. That fits the flood behind CVE-2026-123007.

Know the blind spot. The trigger frames aren't logged as requests, so access logs show nothing. And a managed detection rule for HTTP/2 exploits can't fire if the HTTP logs it depends on were never ingested.

Before you trust "no detections," check that each detection actually has a data source. A smoke detector with no battery is very quiet too.

Two smaller lessons from the response itself. Build your timeline from your cloud provider's audit log, not from chat. The times people post are often minutes late, and the audit log shows exactly when a listener changed and who changed it.

And find owners early. Unowned dev boxes, and "dev" systems a team actually treats as production, were the slowest part of the whole job. Somewhere in every company there's a box tagged "dev" that payroll quietly depends on. Ask the people who run each system which is which. Don't trust the tag.

#Before you log off for Thanksgiving.

Thanksgiving is November 26. Black Friday is the 27th. For a lot of businesses that means a change freeze (a stretch where nobody touches production), then a week where half the team is out.

Get this done before the freeze starts. Nobody wants to be reading nginx error logs on a phone at the kids' table.

If you run the servers:

  1. Upgrade to nginx 1.30.7 or 1.31.9, or your vendor's fixed build. Restart, don't reload.
  2. Inventory embedded nginx: API gateways, ingress controllers, appliances, sidecars. Map product versions to the nginx inside.
  3. If you can't patch yet, turn off HTTP/2 on nginx and set any TLS-terminating load balancer to HTTP/1.1 only, in the same change.
  4. Check every path to the listener: CDN, direct load balancer hostname, private links, internal clients.
  5. Verify live, from outside any TLS-inspecting proxy, with openssl and curl --http2.
  6. Handle the resolver, HTTP/3 and mail-proxy bugs separately. http2 off doesn't touch them.
  7. Block the SCTP module on container hosts until the kernel is fixed.
  8. Confirm your detections have data, then watch for worker crashes and nginx child processes.

For everyone:

  1. If someone else hosts your site, get their answer in writing before Wednesday.
  2. Name an on-call person for Thursday through Sunday, and make sure they can actually reach the servers.
  3. Write down who to call if something looks wrong: your hosting provider, your IT partner, your cyber insurance hotline.

#The patch is quick. Finding every nginx takes longer.

The upgrade is one package. The slow part was answering three questions. Where is nginx running inside things we bought? What does the load balancer in front of it negotiate? Is there a path around the CDN? If you can't answer those quickly, start there.

That's the part we help with. We find every nginx you run, including the copies inside gateways, ingress controllers and appliances, and map each one to the nginx version inside. We test every path to each listener from outside your network, including the ones that skip your CDN, and record what it actually negotiates.

You get a written answer, path by path: exposed or not, the fix, and who owns it. Your team, your hosting provider or your insurer can read it. If something is exposed, we help you upgrade or make the two-layer change and prove it took.

If you're not sure what's in front of your website, book thirty minutes. No pitch. We'll look at what's exposed and tell you straight whether it needs attention before Thanksgiving.

#Further reading

Ready to secure your business?

Free 30-minute consultation. No sales script.

Call (773) 417-9994