How to Patch NGINX2 Root and Verify the Fix

Patch NGINX2Root on Linux, Docker and Kubernetes. Find fixed NGINX releases, disable HTTP/2 where needed, and verify every origin runs a secure build.

How to Patch NGINX2 Root and Verify the Fix

NGINX2Root is a serious security issue affecting vulnerable NGINX installations, including servers using HTTP/2. If you're running NGINX on Ubuntu, Debian, RHEL, Docker or Kubernetes, this guide explains how to patch NGINX2Root, identify the correct security update and verify that your production servers are running the fixed version.

Quick answer: To patch NGINX2Root, upgrade NGINX Open Source to 1.30.7 stable or 1.31.9 mainline, released on 18 November 2026. For NGINX Plus, use the corrected build for your release track. If you can't upgrade immediately, disable HTTP/2 on affected listeners to mitigate CVE-2026-123007 and CVE-2026-123633. Always restart the affected instance and verify the running binary, not just the installed package version.

Why NGINX2Root Is a Serious Security Risk

NGINX2Root refers to a group of NGINX vulnerabilities that can allow unauthenticated attackers to execute code through vulnerable server components. The most widely discussed issues affect HTTP/2 processing, but related vulnerabilities also affect HTTP/3, DNS resolution and mail proxy functionality.

On 18 November 2026, NGINX released security updates addressing 10 vulnerabilities. Five received particular attention because of their potential for unauthenticated remote code execution.

According to

cert.europa.eu, all five can result in code execution with the privileges of the NGINX worker process. CERT-EU reports a CVSS v3.1 score of 8.1 for each.

Which NGINX vulnerabilities are involved?

CVE

Affected component

Main issue

CVE-2026-123007

HTTP/2

Integer overflow and heap memory corruption

CVE-2026-123633

HTTP/2

Use-after-free during connection draining

CVE-2026-121810

HTTP/3

Use-after-free involving QUIC connections

CVE-2026-123634

DNS resolver

Use-after-free during resolver response processing

CVE-2026-113425

Mail proxy

Use-after-free during authentication lookup

These vulnerabilities have different exploitation requirements.

CVE-2026-123007 requires HTTP/2 to be enabled on the affected listener. CVE-2026-123633 also involves HTTP/2 but requires particular reverse-proxy and connection-handling conditions.

The HTTP/3 vulnerability requires an affected QUIC configuration, while the resolver and mail proxy vulnerabilities require their respective features and vulnerable processing paths.

An attacker doesn't necessarily gain root access just by exploiting NGINX. The immediate code execution runs with the NGINX worker's privileges. Escalating to root would require additional conditions or a separate privilege-escalation vulnerability.

That distinction matters when assessing the impact, but it doesn't make the issue safe to ignore. A compromised worker can still expose application traffic, credentials and resources accessible to that process.

The correct response is to identify every vulnerable NGINX instance, apply the appropriate fix and confirm that the patched software is serving traffic.

Which NGINX2Root Patch Should You Install?

The correct NGINX2Root patch depends on your NGINX edition, release channel and package source. Don't assume that upgrading to the highest version number available in your operating system's repository automatically fixes the vulnerabilities.

The

nginx.orgconfirm that NGINX Open Source 1.30.7 and 1.31.9 contain the November 2026 security fixes.

nginx.org

NGINX installation

Corrected version

NGINX Open Source stable

1.30.7 or later patched stable release

NGINX Open Source mainline

1.31.9 or later patched mainline release

NGINX Plus LTS

PLS.37.0.8.1 or later corrected LTS build

NGINX Plus Continuous Release

PLS.37.3.0.1 or later corrected CR build

Ubuntu or Debian repository

Vendor-confirmed fixed package revision

RHEL, AlmaLinux or Rocky Linux

Distribution-confirmed fixed package revision

Docker or Kubernetes

Image or controller release confirmed to include the fixes

NGINX Plus uses its own release numbering. The

docs.nginx.comidentifies the two corrected PLS.37 builds dated 18 November 2026. It also explains that nginx -v omits the final packaging number, so package-manager verification is necessary.

NGINX Documentation

For distribution packages, the revision is as important as the upstream version. Security fixes are often backported without changing the major NGINX version.

If your repository hasn't published a corrected package, don't treat a successful package update as proof that you're protected.

Step 1: Identify the NGINX Instance Serving Traffic

Before updating NGINX, find the actual installation receiving application traffic. Checking the wrong executable is one of the easiest ways to leave a vulnerable server exposed.

An application can have several layers: a CDN, a load balancer, an NGINX reverse proxy, and an application container. Each layer can use different versions and protocols.

Check NGINX on Ubuntu, Debian or RHEL

On a systemd-managed Linux server, run:

pid=$(systemctl show nginx --property=MainPID --value)

sudo readlink "/proc/$pid/exe"
sudo "/proc/$pid/exe" -v

The first command retrieves the running NGINX master process ID. The second identifies the executable associated with that process. The third reports its version.

You can also check the installed NGINX executable:

nginx -v
nginx -V

The distinction matters.

After a package update, nginx -v can report a new installation while an old master process is still running. If the executable path in /proc ends with (deleted), that can indicate that the binary on disk was replaced while the running process still references the old one.

If the systemd service is inactive, or its main PID is zero, identify the actual process or container manager before using these commands.

Check NGINX inside Docker

For a Docker Compose service named nginx, run:

docker compose ps
docker compose exec nginx nginx -v

To inspect the image currently associated with the container:

docker compose images nginx

Record the image reference and immutable digest as well as the version.

Updating NGINX on the Docker host doesn't update NGINX inside an existing application container.

Check NGINX behind a CDN

A CDN may negotiate HTTP/2 with visitors while communicating with the origin using HTTP/1.1. The reverse can also happen, depending on your setup.

You therefore need to inspect the origin rather than relying on the HTTP protocol reported by a public browser request.

For a load-balanced application, record every origin, its running version, and its deployment method before starting the rollout.

Step 2: Patch NGINX on Ubuntu, Debian and RHEL

On a Linux server, install the corrected package from the appropriate repository, validate the configuration, and restart the service.

Where possible, remove one origin from load-balancer rotation before making changes. Test it thoroughly before restoring traffic.

Patch NGINX on Ubuntu or Debian

First, identify the installed package and the available update:

dpkg-query -S /usr/sbin/nginx

sudo apt update

apt-cache policy nginx

Check the candidate revision against the vendor advisory.

If the package is named nginx, the upgrade command is:

sudo apt install --only-upgrade nginx

If a different package owns the NGINX binary, adjust the package name accordingly.

Next, validate the configuration and restart:

sudo nginx -t &&
sudo systemctl restart nginx

sudo systemctl is-active nginx

The configuration test catches syntax errors before the explicit restart.

The final command should report:

active

If the service fails to restart, check the logs before returning the instance to production:

sudo journalctl -u nginx -n 100 --no-pager

A successful restart is an important milestone, but it isn't the final security verification.

Patch NGINX on RHEL, AlmaLinux or Rocky Linux

First, identify the RPM package:

rpm -qf /usr/sbin/nginx

For a standard NGINX package, run:

sudo dnf upgrade nginx

Then validate and restart:

sudo nginx -t &&
sudo systemctl restart nginx

rpm -q nginx
sudo systemctl is-active nginx

Compare the complete installed package revision with your distribution's advisory.

The

access.redhat.comdocuments affected products across RHEL 8, 9 and 10, including differences in HTTP/3 support.

Red Hat Customer Portal

A package reporting NGINX 1.24 isn't automatically vulnerable if the distribution has backported the necessary fixes. Conversely, dnf reporting that there's nothing to upgrade doesn't prove a corrected build is installed.

Your vendor's security advisory is the deciding reference.

Patch NGINX Plus

NGINX Plus requires the corrected package for the configured LTS or Continuous Release track.

On Debian-based installations, inspect the available revision:

apt-cache policy nginx-plus

Then upgrade using the configured NGINX Plus repository:

sudo apt update
sudo apt install --only-upgrade nginx-plus

On RPM-based systems, use:

sudo dnf upgrade nginx-plus

After confirming the package is correct for your intended track:

sudo nginx -t &&
sudo systemctl restart nginx

sudo systemctl is-active nginx

Finally, inspect the full installed package version using dpkg-query -W nginx-plus or rpm -q nginx-plus, as appropriate. This is particularly important because NGINX Plus's executable version output doesn't include every component of its package revision.

Step 3: Patch NGINX in Docker and Kubernetes

Container-based NGINX installations require replacement of the vulnerable container image. Updating the underlying server alone doesn't patch the NGINX executable inside the container.

Update NGINX with Docker Compose

Open your compose.yaml or docker-compose.yml file and update the image reference to a vendor-confirmed patched build.

For reproducible deployments, pin the image digest after you've verified it.

Next, pull the updated image:

docker compose pull nginx

Validate the configuration using the updated service image:

docker compose run --rm --no-deps nginx nginx -t

Then recreate the running service:

docker compose up -d --no-deps --force-recreate nginx

Confirm the new container is running:

docker compose ps nginx
docker compose exec nginx nginx -v

If the service builds a custom image using a Dockerfile, update its FROM reference first and run:

docker compose build --pull nginx

Then test the updated image and recreate the service.

Don't assume docker compose pull is sufficient. A running container can continue using the old image until it is replaced.

For a related container maintenance example, see Hitori Tech's guide on

hitoritech.com. The same principle applies: update the image, replace the container, and test the running application.

Patch NGINX ingress controllers in Kubernetes

Kubernetes environments need special attention because NGINX may be embedded inside an ingress controller rather than deployed as a standalone web server.

Check the controller vendor's security advisory and select a release that explicitly includes the necessary fixes.

Update the image through the Deployment, Helm chart or GitOps configuration that owns the ingress controller.

For a deployment using the namespace ingress-nginx and the Deployment name ingress-nginx-controller, check the rollout:

kubectl -n ingress-nginx rollout status \
  deployment/ingress-nginx-controller

Inspect the running pods:

kubectl -n ingress-nginx get pods -o wide

Then inspect their actual container image identities:

kubectl -n ingress-nginx get pods \
  -o jsonpath='{range .items[*]}{.metadata.name}{" "}{.status.containerStatuses[*].imageID}{"\n"}{end}'

Use the namespace, Deployment name and labels belonging to your actual installation.

Every serving replica must use a verified corrected image. Also check any standalone NGINX sidecars, gateway instances or additional ingress controllers that route traffic independently.

A successful Kubernetes rollout means the desired Deployment state was reached. It doesn't, by itself, prove the embedded NGINX binary contains the security patch.

Step 4: Disable HTTP/2 if You Can't Patch Immediately

Disabling HTTP/2 is an effective temporary mitigation for CVE-2026-123007 and CVE-2026-123633. It doesn't address the separate HTTP/3, resolver or mail proxy vulnerabilities.

Use this approach only when an immediate upgrade isn't available or requires a controlled maintenance window.

Find every HTTP/2 directive

Start by inspecting the full NGINX configuration:

sudo nginx -T 2>&1 |
  grep -nE '^# configuration file|^[[:space:]]*(http2[[:space:]]|listen[[:space:]].*http2)'

This searches loaded configuration files for the relevant directives, including older listen ... http2 syntax.

Check IPv4 and IPv6 listeners, inherited settings and application-specific server blocks.

If your configuration is generated by automation, update the source template rather than editing only the generated file.

Disable HTTP/2 in modern NGINX configurations

In versions supporting the standalone HTTP/2 directive, change:

http2 on;

to:

http2 off;

The

nginx.orgconfirms that the http2 on | off directive was introduced in version 1.25.1. It can be set in the http or server context.

Make sure individual server blocks don't override the intended setting.

Disable HTTP/2 in older NGINX configurations

Older installations commonly enable HTTP/2 through the listen directive.

For example:

listen 443 ssl http2;
listen [::]:443 ssl http2;

Change these to:

listen 443 ssl;
listen [::]:443 ssl;

Preserve the other listener settings, including TLS options, addresses and ports.

Once the changes are ready, validate and reload:

sudo nginx -t &&
sudo systemctl reload nginx

A graceful reload may leave existing connections handled by old workers while they drain. If immediate removal of vulnerable workers is required, drain the instance and perform a controlled restart.

Important: Disabling HTTP/2 can break gRPC services and other applications that require HTTP/2 rather than merely preferring it. Identify these dependencies before making the change and route them through a patched endpoint where necessary.

Keep the permanent security upgrade scheduled. A configuration workaround is not equivalent to installing the corrected release.

Step 5: Verify the NGINX2Root Fix on Every Origin

A successful package installation or configuration test isn't enough to confirm NGINX2Root has been patched. You must verify the executable associated with the running process and make an actual request to the origin.

Verify the running NGINX binary

On a systemd-managed server:

pid=$(systemctl show nginx --property=MainPID --value)

sudo readlink "/proc/$pid/exe"

sudo "/proc/$pid/exe" -v

sudo systemctl is-active nginx

Compare the running version with the corrected upstream release or the vendor-confirmed package revision.

For NGINX Plus and backported distribution packages, also inspect the full package revision. The binary version alone may not expose all of the information needed to confirm the fix.

Next, make a normal application request and check that it returns the expected status and content.

Verify HTTP/2 is disabled on the origin

If you're using the temporary HTTP/2 mitigation, don't test only the public CDN hostname.

Use curl to connect directly to your origin while preserving the proper hostname for TLS verification.

Replace the hostname and IP address with your own:

curl --http2 --noproxy '*' \
  --resolve www.example.com:443:192.0.2.10 \
  --silent --show-error --output /dev/null \
  --write-out 'HTTP/%{http_version} %{http_code}\n' \
  https://www.example.com/

Use a curl build with HTTP/2 support.

On a normal HTTPS endpoint where HTTP/2 has been disabled, you should see a response similar to:

HTTP/1.1 200

The status code will depend on the route you request.

If the response still reports:

HTTP/2 200

the tested origin still negotiates HTTP/2. Recheck the virtual host, listener configuration and target IP address.

Remember that this protocol test verifies the workaround, not the installed security patch.

Confirm application health after the upgrade

Check a real application route, not just the default NGINX welcome page.

Verify that reverse-proxy routing, TLS certificates, redirects and any required gRPC or WebSocket services still work. Review NGINX error logs for unexpected worker exits, upstream failures and configuration errors.

In production, repeat the verification against every serving origin and replica before marking the rollout complete.

For businesses running customer-facing applications,

hitoritech.comprovide a starting point for discussing hosting maintenance, security updates and operational requirements.

NGINX2Root Patching vs Temporary Mitigation

A verified software update is the preferred fix. Disabling HTTP/2 reduces exposure to the two HTTP/2 vulnerabilities but doesn't resolve every issue addressed by the security release.

Approach

HTTP/2 vulnerabilities

Other NGINX vulnerabilities

Recommended use

Install a corrected NGINX release

Fixed

Relevant release fixes included

Permanent solution

Disable HTTP/2

Mitigated

Not fixed

Temporary protection

Rely only on a CDN or WAF

Depends on traffic handling

Not fixed

Additional defence, not a patch

The distinction matters when reporting remediation. A temporarily mitigated server should remain on your security update list until it runs a corrected build.

Common NGINX2Root Patching Mistakes

The most common patching failure is checking the installed version without checking the running executable. If the old master process is still active, installing a fixed package hasn't necessarily replaced the code serving your customers. Verify the process after restarting.

Another mistake is updating one container or origin and assuming the entire application is secure. A load balancer can continue sending requests to vulnerable replicas. Every serving instance needs its own verification.

Don't assume that a vulnerability scanner reporting an older upstream version automatically proves a vendor package is vulnerable. Distribution-maintained builds can contain backported fixes. Confirm the full package revision and vendor advisory before drawing conclusions.

Finally, don't leave temporary HTTP/2 restrictions in place indefinitely without tracking the permanent patch. The workaround doesn't remove the independent resolver, mail proxy or HTTP/3 risks.

Real-World Deployment Example: Three NGINX Origins

Consider a production application using three NGINX reverse-proxy servers behind a load balancer. This is an illustrative deployment scenario, not a claimed Hitori Tech customer incident.

Suppose the deployment initially has three origins running NGINX 1.30.6. An administrator patches the first server to 1.30.7, verifies its running binary and returns it to traffic.

At that point, only one of the three origins is patched. Two remain on the vulnerable upstream release.

The correct rollout is to drain, upgrade, restart and verify the remaining two origins individually. Once all three report the corrected release, confirm that their application routes respond normally and review the error logs.

For the HTTP/2 workaround, test each origin IP independently using curl --resolve. A successful request to one origin doesn't say anything about the others.

This example illustrates why patching needs a deployment-wide checklist rather than a single successful command.

For larger environments, the same principles belong in your CI/CD pipeline and infrastructure maintenance process. Hitori Tech's

hitoritech.comcover the infrastructure and deployment work involved in maintaining production applications.

Frequently Asked Questions

How can I confirm that NGINX2Root is patched on my server?

Confirm the version of the executable used by the running NGINX master process, not just the copy found in your shell. For upstream NGINX Open Source, compare it with 1.30.7 stable or 1.31.9 mainline. For NGINX Plus or a distribution package, check the complete vendor-approved package revision and test every origin.

Can I mitigate NGINX2Root by disabling HTTP/2?

Yes, disabling HTTP/2 on every affected NGINX listener mitigates CVE-2026-123007 and CVE-2026-123633. It doesn't fix the separate HTTP/3, DNS resolver or mail proxy vulnerabilities. Check gRPC dependencies before switching protocols, verify the negotiated protocol directly at the origin, and install the corrected package as soon as it's available.

Which NGINX versions fix CVE-2026-123007 and CVE-2026-123633?

NGINX Open Source 1.30.7 stable and 1.31.9 mainline contain fixes for both HTTP/2 vulnerabilities. The corrected NGINX Plus PLS.37 builds are 37.0.8.1 for LTS and 37.3.0.1 for Continuous Release. Linux distribution packages can use backported fixes, so verify their complete package revision against a published vendor advisory.

Why does nginx -v still show an older release after updating?

The update may have installed a new package without replacing the running process, or your distribution may have backported the security patch to an older upstream version. Check the NGINX master process executable and restart the service if needed. For distribution packages and NGINX Plus, also compare the installed package revision with the vendor's confirmed fix.

What if NGINX sits behind a CDN or load balancer?

Check every NGINX origin even if the public CDN endpoint already negotiates HTTP/1.1 or uses a patched proxy. Edge and origin connections can use different protocols, and a CDN is not proof that the origin binary is fixed. Direct origin tests, package verification and a complete replica inventory are required before you close the incident.

Patching NGINX2Root means more than installing a package. Update every affected instance, verify the running binary and confirm your application still works. If you need support reviewing an NGINX deployment, Docker environment or production infrastructure,

Himanshu Verma

Written by

Himanshu Verma

Himanshu is a full-stack developer and SaaS builder behind VerifiSaaS. He shares practical insights on email verification, deliverability, and growth systems to help businesses scale smarter