# NVIDIA open GPU kernel module flaw CVE-2026-47501 (ForgePtr) enables root access and container escape

> ForgePtr (CVE-2026-47501) is a missing error check in the event-buffer setup path of NVIDIA's Linux GPU kernel modules. It lets an unprivileged local user with access to the GPU device turn an arbitrary kernel decrement into an arbitrary byte write. Stealthium demonstrated host root, container escape and runtime bypass of kernel lockdown and module signature enforcement; NVIDIA fixed it in 615.71.09.

- **Published:** 2026-11-19T07:14:44Z
- **Last reviewed:** 2026-11-19T07:14:44Z
- **Canonical:** https://intel.threadlinqs.com/threat/TL-2026-6427
- **Card image:** https://intel.threadlinqs.com/og/threat/TL-2026-6427.png
- **ID:** TL-2026-6427
- **Severity:** HIGH (CVSS 7.8)
- **Category:** VULNERABILITY
- **Status:** PATCHED
- **Detections:** 9 (1 shown free below) · **IOCs:** 3
- **CVEs:** CVE-2026-47501

## Description

ForgePtr was found by Stealthium researcher Branislav Brzak and is tracked as CVE-2026-47501. Per Stealthium, the driver's event-buffer setup path converts a caller-supplied handle into a kernel pointer without checking that the conversion succeeded. If the handle does not resolve, the driver keeps the raw attacker-chosen value, treats it as a valid pointer and reports success. When the event-buffer object is later freed, the kernel decrements a counter at the attacker-supplied address. NVIDIA's CNA record describes the same flaw as an out-of-bounds write (CWE-787) caused by mismatched memory buffers during event buffer setup, rated CVSS 3.1 7.8 (AV:L/AC:L/PR:L).

The arbitrary decrement becomes an arbitrary byte write: repeated decrements step a byte through every value, so an attacker can reach any chosen byte provided the current value can be read. Stealthium paired it with a separate unprivileged KASLR leak primitive to resolve target offsets to live kernel addresses. The kernel itself performs the write, so GPU memory isolation, IOMMU, device isolation and confidential-compute controls do not block it. Exploitation needs only local access to the vulnerable GPU device: no special group membership and no CAP_SYS_ADMIN.

Stealthium's demonstrated impact: (1) Root - the attacker rewrites the global kernel core_pattern so a program runs as root when a process crashes. (2) Container escape - core_pattern is global and not namespaced; pointing it at a program reached through /proc/%P/root/ executes that program as host root from inside a container that has been granted GPU access, exposing other tenants on shared GPU nodes. (3) Hardening removal - the write can set kptr_restrict, dmesg_restrict, randomize_va_space, unprivileged_bpf_disabled, protected_symlinks/hardlinks, ptrace_scope, mmap_min_addr, kernel_locked_down and sig_enforce to permissive values. (4) Runtime Secure Boot bypass - setting sig_enforce to N and lockdown to none let an unsigned kernel module load on a machine that booted with Secure Boot; the signed boot chain stayed intact, so an expected Secure Boot status does not rule out runtime tampering.

Affected: the flaw is present in the source of every open-source NVIDIA kernel module release from 515.43.04 (2022-05-09) through 610.57.04 (2026-08-03); root was runtime-confirmed on 610.43.02 and 610.57.04. Stealthium notes it likely predates open-sourcing in the closed driver but this is unconfirmed. NVIDIA's CVE record also lists R595/R580 Linux branches and Linux/Windows vGPU guest and vGPU Manager builds. Version-note discrepancy: the CNA record lists R610 as affected 'prior to 610.57.04', whereas Stealthium confirmed root on 610.57.04 and states the fix is 615.71.09; defenders should treat 615.71.09 (or the distro's equivalent backport) as the safe target and verify the running kernel-module version on each host rather than the version in a container image.

Status: no CVSS in the press article (7.8 from NVIDIA's CNA record), no in-the-wild exploitation reported, and Stealthium withheld the proof of concept. Stealthium states exploitation looks like normal GPU device use with no network, credential or file artifacts, so detection relies on host behaviour: malformed event-buffer setup calls, unprivileged writes to core_pattern/kernel_locked_down/sig_enforce or other sysctl-backed kernel globals, and containers modifying host-global kernel state. Stealthium reports 25+ further High/Critical issues across the AI runtime stack under responsible disclosure. Highest risk is multi-tenant GPU and container hosts.

## MITRE ATT&CK

- T1611 Escape to Host
- T1685 Disable or Modify Tools
- T1553 Subvert Trust Controls
- T1547.006 Boot or Logon Autostart Execution: Kernel Modules and Extensions
- T1547.006 Boot or Logon Autostart Execution: Kernel Modules and Extensions

## Free detection (Splunk SPL, Microsoft KQL, Sigma)

**ForgePtr CVE-2026-47501 - Kernel core_pattern Tampering (Exploitation Impact)** (`TL-2026-6427-SPL-001`)

Behaviour-first detection of writes to /proc/sys/kernel/core_pattern (kernel.core_pattern) by sysctl, echo, printf or tee, flagging pipe handlers and /proc/%P/root targets. ForgePtr (CVE-2026-47501, NVIDIA open GPU kernel module) turns an arbitrary kernel decrement into an arbitrary write that Stealthium used to rewrite core_pattern for host root and container escape. The exploit write is done by the kernel and is invisible to process telemetry, so this catches the userland variant and attacker verification or re-arming; pair with SPL-002 and SPL-003.

- **Languages:** Splunk SPL, Microsoft KQL, Sigma
- **ATT&CK:** T1068, T1611, T1059.004
- **Data sources:** sysmon_for_linux, linux_auditd
- **Severity:** high
- **Confidence:** high

### Splunk SPL

```spl
index=linux sourcetype="sysmon:linux" EventCode=1 earliest=-24h (CommandLine="*kernel.core_pattern*" OR CommandLine="*kernel/core_pattern*") | where match(CommandLine,"(sysctl\s+(-w|--write)|\becho\s|\bprintf\s|\btee\s|>\s*/proc/sys/kernel/core_pattern)") | where NOT match(coalesce(ParentImage,""),"(ansible|puppet|chef-client|salt-minion|systemd-sysctl)") | eval pipe_handler=if(match(CommandLine,"\|\s*/"),1,0), proc_root_target=if(match(CommandLine,"/proc/%[Pp]/root"),1,0) | stats count min(_time) as first_seen max(_time) as last_seen max(pipe_handler) as pipe_handler max(proc_root_target) as proc_root_target values(User) as users values(Image) as images values(ParentImage) as parents values(CommandLine) as commands by host | convert ctime(first_seen) ctime(last_seen)
```

### Microsoft KQL

```kql
DeviceProcessEvents
| where Timestamp > ago(24h)
| where ProcessCommandLine has_any ("kernel.core_pattern", "kernel/core_pattern")
| where ProcessCommandLine matches regex @"(?i)(sysctl\s+(-w|--write)|\becho\s|\bprintf\s|\btee\s|>\s*/proc/sys/kernel/core_pattern)"
| where InitiatingProcessFileName !in~ ("ansible-playbook", "puppet", "chef-client", "salt-minion", "systemd-sysctl")
| extend PipeHandler = ProcessCommandLine matches regex @"\|\s*/", ProcRootTarget = ProcessCommandLine matches regex @"(?i)/proc/%p/root"
| project Timestamp, DeviceName, AccountName, FileName, ProcessCommandLine, InitiatingProcessFileName, InitiatingProcessCommandLine, PipeHandler, ProcRootTarget
```

### Sigma

```yaml
title: ForgePtr Related - Kernel core_pattern Rewritten via Command Line
id: 6f1c2a40-3b7e-4d51-9a2e-1c0f5d8b7a01
status: experimental
description: Detects shell or sysctl writes to kernel.core_pattern, the global non-namespaced setting that CVE-2026-47501 (ForgePtr) exploitation rewrites to run an attacker program as host root when a process crashes. The kernel-level write itself is not visible in process telemetry, so this covers the userland variant and post-exploitation verification or re-arming.
references:
    - https://stealthium.io/blog/forgeptr
    - https://nvidia.custhelp.com/app/answers/detail/a_id/5861
    - https://nvd.nist.gov/vuln/detail/CVE-2026-47501
author: Threadlinqs Team
date: 2026-11-19
tags:
    - attack.privilege-escalation
    - attack.t1068
    - attack.t1611
    - cve.2026.47501
logsource:
    category: process_creation
    product: linux
detection:
    selection_target:
        CommandLine|contains:
            - 'kernel.core_pattern'
            - 'kernel/core_pattern'
    selection_write:
        CommandLine|re: '(sysctl\s+(-w|--write)|\becho\s|\bprintf\s|\btee\s|>\s*/proc/sys/kernel/core_pattern)'
    filter_cm:
        ParentImage|contains:
            - 'ansible'
            - 'puppet'
            - 'chef-client'
            - 'salt-minion'
    condition: selection_target and selection_write and not filter_cm
falsepositives:
    - Configuration management or administrators setting a coredump handler such as systemd-coredump or apport
    - Hardening or tuning scripts run during image build
level: high

```

**Known false positives:**

- Administrators or config management setting a legitimate core dump handler (systemd-coredump, apport, abrt)
- Image build or hardening scripts that set kernel.core_pattern once

**Tuning notes:** Requires Sysmon for Linux (EventCode 1) or equivalent process telemetry in index=linux. Add your approved handler paths and automation parents to the exclusions. Pipe handlers (pipe_handler=1) and /proc/%P/root targets (proc_root_target=1) should page immediately; plain writes can be lower priority. Sysctl state polling (osquery system_controls) is a useful complement because the exploit write itself produces no process event.

### 8 more detection rules (Splunk SPL, Microsoft KQL, Sigma), unlock with TL Creds

- ForgePtr CVE-2026-47501 - Root Process Spawned by Kernel Usermode Helper from Writable or Container Path (locked: unlock with TL Creds)
- ForgePtr CVE-2026-47501 - Unsigned Kernel Module Loaded on Secure Boot Host (locked: unlock with TL Creds)
- ForgePtr CVE-2026-47501 - Kernel Module Loaded from Writable Path (Persistence) (locked: unlock with TL Creds)
- ForgePtr CVE-2026-47501 - Execution via /proc/PID/root (Container Escape Handler Path) (locked: unlock with TL Creds)
- ForgePtr CVE-2026-47501 - Kernel Lockdown / sig_enforce Modification Attempt (locked: unlock with TL Creds)
- ForgePtr CVE-2026-47501 - NVIDIA Driver Activity Followed by Kernel Setting Tampering (Correlation) (locked: unlock with TL Creds)
- ForgePtr CVE-2026-47501 - Kernel Hardening Sysctls Relaxed (Post-Exploitation) (locked: unlock with TL Creds)
- ForgePtr CVE-2026-47501 - Container Modifying Host-Global Kernel State (locked: unlock with TL Creds)

Sign up free to unlock the detection rules: https://threadlinqs.com/?modal=signup

## Sources

- [NVIDIA GPU Driver Flaw Allows Attackers to Gain Root Access and Escape Containers (GBHackers)](https://gbhackers.com/nvidia-gpu-driver-flaw/)
- [ForgePtr (CVE-2026-47501) - Stealthium](https://stealthium.io/blog/forgeptr)
- [NVIDIA Security Bulletin, September 2026 (answer 5861)](https://nvidia.custhelp.com/app/answers/detail/a_id/5861)
- [NVIDIA product-security record 2026/5861](https://github.com/NVIDIA/product-security/tree/main/2026/5861)
- [NVD - CVE-2026-47501](https://nvd.nist.gov/vuln/detail/CVE-2026-47501)
- [CVE.org record CVE-2026-47501](https://www.cve.org/CVERecord?id=CVE-2026-47501)
- [OpenCVE - CVE-2026-47501](https://app.opencve.io/cve/CVE-2026-47501)
- [Red Hat CVE-2026-47501](https://access.redhat.com/security/cve/CVE-2026-47501)
- [Phoronix - NVIDIA NvRoot & ForgePtr Vulnerabilities Published For Linux Driver](https://phoronix.com/news/NVIDIA-NvRoot-ForgePtr)

## Full data

The other 8 detection rules (Splunk SPL / Microsoft KQL / Sigma) unlock with TL Creds; a free account includes daily creds: https://threadlinqs.com/?modal=signup
Indicator values unlock with TL Creds, at a lower price on Red and Purple; AI agents can query rules and IOCs through the Threadlinqs MCP server (Purple): https://intel.threadlinqs.com/mcp

Canonical: https://intel.threadlinqs.com/threat/TL-2026-6427
