HelixML

NvRoot (CVE-2026-47591): A Rented GPU Is a Root Shell on an Unpatched NVIDIA Host

Nov 16, 2026

NvRoot (CVE-2026-47591) and ForgePtr (CVE-2026-47501) let an unprivileged user with a CUDA GPU, including one inside a container, become root on an NVIDIA Linux host. The mechanism, the affected range back to 515.43.04, which driver fixes which bug, and what GPU clouds and shared clusters should patch first.

Note

In short. A permission check in NVIDIA's Linux GPU driver looks at the CPU half of a memory request and ignores the GPU half. Any local user who can run CUDA can ask for a GPU-writable mapping of a file they are only allowed to read, then overwrite the cached copy of a setuid binary and become root. No special group, no CAP_SYS_ADMIN, and it works from inside an unprivileged GPU container. That is the access a GPU cloud sells. The bug, NvRoot (CVE-2026-47591), has been in every open-source driver since 515.43.04 (May 2022) and is fixed in 610.57.04, 595.91.07 (595.44.14 on the 595.44.x line) and 580.178.04. A second bug from the same researchers, ForgePtr (CVE-2026-47501), is still present in 610.57.04; Stealthium names 615.71.09 as its fix. The curated record is on Threat Watch.

Stealthium published NvRoot and ForgePtr on 12 November 2026. NVIDIA had already listed both CVEs in its September 2026 GPU display driver bulletin, rated CVSS 7.8, and the first fix shipped on 3 August without a disclosure. So the patched drivers have existed for months, but most operators learned what they fix last week. Stealthium has withheld proof-of-concept code and says it has more than 25 further high or critical findings in the AI runtime stack still under disclosure.

NvRoot in one table

ProductNVIDIA GPU display driver for Linux. Stealthium: the defect is in shared resource-manager code, so open and proprietary builds are both affected
IntroducedPresent in every open-source driver release from 515.43.04 (2022-05-09)
Fixed in610.57.04, 595.91.07 (or 595.44.14 on 595.44.x), 580.178.04, and later releases on those branches
No fix onR590, R575, R570, and R565 and earlier (per Stealthium)
SeverityCVSS 7.8, AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, CWE-863 (NVIDIA). Stealthium scores it 9.3 under CVSS 4.0 and advises treating it as critical on multi-tenant hosts
NeedsA CUDA-capable NVIDIA GPU and an unprivileged local account, or an unprivileged container with the GPU passed through
ExploitedNo in-the-wild reports. No public proof of concept
WorkaroundNone. Stealthium: no sysctl, seccomp profile or cgroup closes it

Two permission fields, one check

When a program wants the GPU to read or write ordinary host memory, it asks the driver to pin those pages and map them for the device. The request carries two access levels: one for the CPU side and one for the GPU side. A program that wants the GPU to read a file and write results elsewhere would normally ask for read-only on both.

The vulnerable drivers validate the CPU field against what the caller may do with the underlying pages, and then build the GPU mapping from the GPU field without checking it. In Stealthium's words, the driver derives the page permission "from the CPU field alone and never check[s] across the aisle".

An unprivileged process asks the NVIDIA driver to pin a page of /usr/bin/su, marked CPU read-only and GPU writable. A vulnerable driver checks only the CPU field, which passes because any user may read su, and never checks the GPU field. The GPU gets a writable mapping of the file's page cache, so a GPU kernel can overwrite the cached su binary and the next run of su executes the attacker's bytes as root. Drivers 610.57.04, 595.91.07 and 580.178.04 check both fields and refuse the request.

So a request saying "CPU read-only, GPU writable" against a file the caller can only read is honoured. The GPU ends up with write access to that file's page cache, the in-memory copy the kernel serves to every process that opens or executes it.

Stealthium's demonstration targets /usr/bin/su. Every user can read su, it runs as root, and the kernel executes it from the page cache. A GPU kernel overwrites the cached bytes, the next invocation of su runs them, and the attacker is root. The file on disk does not change, so a checksum of the binary on disk can come back clean while the copy the kernel actually runs has been modified.

ForgePtr: a separate bug with a later fix

ForgePtr (CVE-2026-47501) is a different defect in the same driver. During event buffer setup the driver turns a caller-supplied handle into a kernel pointer and never checks whether that conversion succeeded. When the buffer is later freed, the driver decrements a counter at an address the attacker chose. That is an arbitrary kernel write. Combined with an unprivileged kernel address leak to get past KASLR, Stealthium reached host root from a container and then disabled kernel lockdown, module signing and Secure Boot enforcement at runtime.

The version that matters here is different. Stealthium confirmed root with ForgePtr on 610.43.02 and 610.57.04, the release that fixes NvRoot, and names 615.71.09 (9 September 2026) as the fix. NVIDIA's bulletin covers both CVEs in one document, and we could not confirm a ForgePtr fix on the 595 or 580 branches from it. Treat 615.71.09 or later as the only release known to close both.

Why GPU clouds should patch first

Most local privilege escalations matter less on a box where every user is already trusted. A GPU host is often the opposite: the business model is handing strangers a shell or a container with a GPU in it.

  • Rented GPU instances and slices. If tenants share a physical host through containers rather than full VMs with their own kernel, one tenant reaching root reaches every other tenant's data, model weights and credentials on that host.
  • Shared training clusters. Research and ML platform clusters often give many users shell access to the same GPU nodes. Any of them can become root on any node they can schedule onto.
  • Kubernetes GPU nodes. A pod with an NVIDIA device plugin allocation is enough. Root on the node yields the kubelet's credentials and the service account tokens of every pod on it.
  • CI runners with GPUs. A pull request that runs a CUDA test is untrusted code with a GPU.

Single-tenant hosts where only your own team has accounts are lower priority, but not zero: any foothold as an unprivileged service user on a GPU box, through a vulnerable inference server for example, becomes root.

Check your driver version

# Driver version, from the kernel module itself
cat /proc/driver/nvidia/version
 
# Or through nvidia-smi
nvidia-smi --query-gpu=driver_version --format=csv,noheader
 
# Inside Kubernetes: what each GPU node is running
kubectl get nodes -l nvidia.com/gpu.present=true \
  -L nvidia.com/cuda.driver.major,nvidia.com/cuda.driver.minor,nvidia.com/cuda.driver.rev

The last command depends on GPU feature discovery labels, which the NVIDIA GPU Operator sets by default. Read the result against this table:

Your branchNvRoot fixed inForgePtr fixed in
R615615.71.09615.71.09
R610610.57.04not fixed on this branch per Stealthium; move to 615.71.09
R595595.91.07 (595.44.14 on 595.44.x)not confirmed
R580580.178.04not confirmed
R590, R575, R570, R565 and olderno fixno fix

For vGPU, NVIDIA's bulletin lists vGPU Manager 20.2 = 595.91.04 and 19.6 = 580.178.05, and Linux guest drivers 20.2 = 595.91.07 and 19.6 = 580.178.04.

Distro packages lag

On 12 November, ComputingForGeeks reported that Debian's tracker marked bookworm (535 branch), trixie and sid (550 branch) vulnerable with no security advisory, and that Ubuntu listed its 580 and 595 driver sources as needing evaluation. The 535 and 550 branches are not on NVIDIA's fixed list at all. A distro package name tells you the branch, not whether it carries the fix, so check the running module version.

What to do

  • Inventory every Linux host with an NVIDIA GPU and its loaded driver version, using the commands above.
  • Patch multi-tenant GPU hosts first: rented instances, shared clusters, Kubernetes GPU node pools, GPU CI runners.
  • Prefer 615.71.09 or later. It is the only release Stealthium names as fixing both bugs. 610.57.04, 595.91.07 and 580.178.04 fix NvRoot.
  • Leave unfixed branches. R590, R575, R570 and older have no fixed release, so waiting on them does not end.
  • Until a node is patched, assume any GPU tenant on it can become root, and keep untrusted workloads off it.
  • Reboot or reload the module after updating. Installing a new driver package does not replace the module already loaded in the kernel; /proc/driver/nvidia/version shows what is running.
What is NvRoot (CVE-2026-47591)?
A local privilege escalation in NVIDIA's Linux GPU driver. When pinning memory for the GPU, the driver validates only the CPU-side access level and builds the GPU mapping from the GPU-side level without checking it. An unprivileged user can obtain a GPU-writable mapping of a read-only file's page cache, overwrite a setuid binary such as /usr/bin/su in memory, and become root.
Which NVIDIA driver versions are affected and which fix it?
Stealthium reports the bug in every open-source driver release from 515.43.04 (May 2022), and says the proprietary builds are affected too because the code is shared. It is fixed in 610.57.04, 595.91.07 (595.44.14 on the 595.44.x line) and 580.178.04, and later releases on those branches. R590, R575, R570 and R565 and earlier have no fixed release.
Does it work from inside a container?
Yes. Stealthium says it works from an unprivileged container with GPU access, with no special group and no CAP_SYS_ADMIN. Container isolation does not help because the bug is in the host kernel driver that the container talks to.
Is ForgePtr fixed by the same update?
Not necessarily. ForgePtr (CVE-2026-47501) is a separate out-of-bounds kernel write in event buffer setup. Stealthium confirmed root with it on 610.57.04, the release that fixes NvRoot, and names 615.71.09 as its fix. Treat 615.71.09 or later as the release that closes both.
Is there a public exploit or in-the-wild exploitation?
No public proof of concept: Stealthium withheld code and some details. No in-the-wild exploitation had been reported as of 16 November 2026. NVIDIA rates both CVEs CVSS 7.8.
Is there a workaround if I cannot update the driver?
Stealthium says there is no practical workaround: no sysctl, seccomp profile or cgroup closes either bug. The only mitigation short of updating is to keep untrusted users and workloads off unpatched GPU hosts.

We track vulnerabilities like this on Helix Threat Watch, a public feed that states the preconditions and the fixed versions per branch. The NvRoot and ForgePtr record carries the sources and the timeline, and will be updated as NVD and the distros catch up.

Helix Cyber runs agent-driven penetration tests, including against the GPU and inference infrastructure behind AI products. Every candidate finding is reproduced by a second agent before it reaches a report.