# NGINX2Root: who patches your web server?

Five nginx flaws, chained with a Linux kernel bug, reach root on the host and out of a Docker container. Who has to patch depends on how you host Laravel.

## In short

- On 18 November 2026 Xint disclosed NGINX2Root, five flaws in nginx that let an unauthenticated attacker run commands as the nginx worker process.
- nginx fixed all five on the same day, in 1.31.9 (mainline) and 1.30.7 (stable); versions from 1.9.5 up to and including 1.31.8 are affected by the HTTP/2 flaw.
- Root is a second step, through a separate use-after-free in the Linux kernel's SCTP code, which had no CVE of its own when the research was published.
- In Xint's own tests the chain escaped a Docker container running nginx and reached root on the host underneath it.

On 18 November 2026 the security firm Xint disclosed NGINX2Root: five vulnerabilities in nginx, together with a way to chain them with a flaw in the Linux kernel and come out as root on the host. nginx published fixes the same day. CIRCL, the Luxembourg CERT, put out its own advisory, TR-105.

nginx runs in front of a very large share of the web, and in front of a very large share of Laravel applications. So the first question is which of your servers run it, and the second is who is supposed to patch them. That second question has a different answer depending on how you host.

## What is NGINX2Root?

NGINX2Root is five separate flaws in nginx that let an unauthenticated attacker run commands with the privileges of the nginx worker process. It is not one bug: each has its own CVE, its own affected versions and its own conditions, and nginx.org lists them all as fixed in 1.31.9 and 1.30.7.

| CVE | What it is, in nginx's own words | Severity | Vulnerable |
| --- | --- | --- | --- |
| CVE-2026-123007 | Memory corruption in HTTP/2 flow control | major | 1.9.5 – 1.31.8 |
| CVE-2026-113425 | Use-after-free in mail proxy module | major | 0.5.33 – 1.31.8 |
| CVE-2026-123634 | Use-after-free during response processing in resolver | medium | 0.6.18 – 1.31.8 |
| CVE-2026-123633 | Use-after-free in HTTP/2 | medium | 1.19.7 – 1.31.8 |
| CVE-2026-121810 | Use-after-free in HTTP/3 | medium | 1.25.0 – 1.31.8 |

The HTTP/2 one is the entry point in the demonstration: an attacker who can speak HTTP/2 to the server, with no account and no credentials, reaches memory the worker has already handed back.

> [!WARNING]
> Turning HTTP/2 off is not a fix. It closes the two HTTP/2 flaws and leaves the resolver, HTTP/3 and mail proxy ones open. A configuration reload is not enough either: the running executable has to be replaced, which means a restart.

## How do you get from a worker process to root?

Through a second flaw, in the kernel, not in nginx. The nginx bugs give the attacker the privileges of the worker process that handled the request — usually an unprivileged user such as `www-data`. To get further, the researchers chained a use-after-free in the Linux kernel's SCTP networking code, and bypassed kernel ASLR along the way.

CIRCL notes that this kernel flaw had no CVE identifier of its own when the research was published, and that it affects code introduced in Linux 4.15. It also says plainly that a vulnerable nginx does not by itself mean host root: whether the SCTP path is reachable depends on the kernel, on which modules can load, and on how the container is restricted.

That nuance matters, but so does the other side of it: once the second step works on your kernel, an attacker who got in through your web server owns the machine, and every container on it.

## Does a container protect you?

Not by itself. A container is a process on the host with a different view of the filesystem and the network; it shares the host's kernel. A kernel flaw is therefore a flaw on every container of that host at once.

Xint reports that in their own tests, the chain escaped a Docker container running nginx and reached root on the host underneath it. Running your web server in Docker on a server of your own is not a layer between the attacker and the kernel. It is a layer between the attacker and your files.

## Who patches what, by how you host?

The web server is part of the machine or of the image. Whoever runs that is the one who patches it.

| How you host Laravel | Who patches nginx | Who patches the kernel |
| --- | --- | --- |
| A VPS or dedicated server | You, with a package upgrade and a restart | You, with a reboot |
| Docker on servers you run | You, by rebuilding the image and restarting every container | You, on every host, with a reboot |
| A Kubernetes cluster you run | You, including the ingress controller | You, on every node |
| Serverless containers | There is no nginx unless your image puts it there | The provider |

On a server of your own, patching nginx means getting a fixed package from your distribution, then restarting nginx so that the new binary is the one running. Ubuntu 24.04 ships nginx 1.24.0, Ubuntu 22.04 ships 1.18.0 and Debian 12 ships 1.22.1, so what you need from them is a backported fix rather than a new version number. Until that package exists, you are left with partial mitigations.

## What does Brewless run instead?

Brewless deploys your Laravel application to Scaleway Serverless Containers, in your own Scaleway project, with bunny.net in front of it. There is no nginx anywhere in that path:

- **The container runs FrankenPHP, which is Caddy.** It is built into the public Brewless base image, in classic mode, not worker mode. See [FrankenPHP in classic mode](/blog/laravel-frankenphp-classic-mode).
- **There is no host of yours.** Scaleway starts your container on its own machines, each container in a sandbox of its own, and patches the kernel under it. There is nothing for you to reboot.
- **The edge in front is bunny.net's.** A visitor connects to bunny.net, and bunny.net to your container. Brewless is never in that path. See [how Brewless works](https://docs.brewless.eu/getting-started/how-it-works).

None of that makes your application immune to the next flaw in a web server. It means this particular night of work — find the servers, find the package, restart the right processes in the right order, reboot the hosts — is not yours to do, because the layer it happens in is not yours to run.

> [!NOTE]
> Moving the web server and the kernel to a provider also means trusting that provider to patch them. Neither you nor Brewless can see Scaleway's hosts or pick when they are updated. What you get back is the time.

## What is still yours on Brewless?

The image, and everything in it above the kernel:

- **PHP and its extensions.** Every release is built on the Brewless base image, pulled by digest. When a new base image is published, your next deploy picks it up. See [Deployments](https://docs.brewless.eu/deployments/deployments).
- **Your Composer packages.** `composer audit` names the ones with a known flaw. Brewless runs it in the pipeline, and a Brewless deploy is how a fix reaches production.
- **Anything you still run yourself.** A CI runner, a self-hosted database, an old VPS that still answers on a domain you forgot about. Those are servers, and this one is for them.

## What should you do today?

If you run nginx anywhere, start there:

```bash
nginx -v
```

Then install your distribution's fixed package and restart the service, rather than reloading it:

```bash
sudo apt update && sudo apt install --only-upgrade nginx
sudo systemctl restart nginx
```

Check the version the running process reports afterwards, and check the kernel on the same machines while you are there — the second half of this chain lives there. If a machine has nothing on it any more, that is the cheapest patch of all.

If your application runs on Brewless, there is no nginx of yours in this one. Use the moment for the parts that are still yours: run `composer audit`, and count how many servers you still keep next to your application.

## Frequently asked questions

### What is NGINX2Root?

A set of five vulnerabilities in nginx, disclosed by Xint on 18 November 2026, that let an unauthenticated attacker execute commands with the privileges of the nginx worker process. Chained with a separate flaw in the Linux kernel's SCTP subsystem, the researchers went from there to root on the host.

### Which nginx versions fix NGINX2Root?

nginx 1.31.9 on the mainline branch and 1.30.7 on the stable branch, both released on 18 November 2026. nginx.org lists all five CVEs as not vulnerable from those versions on. A distribution may also backport the fixes without changing the version number nginx -v prints, so check your distribution's tracker.

### Does running nginx in a container protect me?

Not by itself. Every container on a host shares that host's kernel, and the kernel flaw in the chain is what gets you root. Xint reports that in their tests the chain escaped a Docker container running nginx and reached root on the underlying host.

### Is Brewless affected by NGINX2Root?

Your application's containers do not run nginx. Brewless builds them on its public base image with FrankenPHP, which is Caddy, and bunny.net sits in front of them at the edge. There is no nginx for you to patch and no host of yours in the path.

### Does serverless mean I never have to patch anything?

No. The web server and the kernel move to the provider, but the image stays yours. PHP, its extensions and your Composer packages still need updates, composer audit still has something to say, and any server you still run next to your application is a server like any other.

Source: https://brewless.eu/blog/nginx2root-who-patches-your-web-server
