Skip to navigation

Threat reportVulnerabilityTL-2026-6427

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

highPATCHED

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. First disclosed .

Key facts

IdentifiersTL-2026-6427, CVE-2026-47501
Also known asForgePtr
SeverityHIGH
CVSS7.8 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H)
First disclosed
Affected productsNVIDIA Open GPU kernel modules / GPU Display Driver for Linux; NVIDIA Virtual GPU (vGPU) Linux/Windows guest drivers and vGPU Manager
Weaknesses (CWE)CWE-787
MITRE ATT&CK techniquesT1547.006 Boot or Logon Autostart Execution: Kernel Modules and Extensions, T1553 Subvert Trust Controls, T1611 Escape to Host, T1685 Disable or Modify Tools
MotivationUNKNOWN
Target sectorstechnology, cloud-services, infrastructure, research
Target regionsGlobal
Detection rules9 (1 shown free)
Sources9 cited sources

Detection coverage

As of 2026-11-19, Threadlinqs Intelligence publishes 9 detection rule(s) for TL-2026-6427 across Splunk SPL, Microsoft KQL and Sigma, covering 3 indicator(s) of compromise. The whole corpus is readable without an account. Every threat comes with one complete detection in Splunk SPL, Microsoft KQL and Sigma, free for everyone; a free account adds daily TL Creds to unlock the rest. Paid plans add a larger daily allowance, correlation and the MCP server. Threadlinqs MCP server · View plans.

Free detection: ForgePtr CVE-2026-47501 - Kernel core_pattern Tampering (Exploitation Impact)

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

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

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

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. Sign up free to unlock the detection rules or query them with the Threadlinqs MCP server (Purple)
  • ForgePtr CVE-2026-47501 - Root Process Spawned by Kernel Usermode Helper from Writable or Container Path · unlock with TL Creds
  • ForgePtr CVE-2026-47501 - Unsigned Kernel Module Loaded on Secure Boot Host · unlock with TL Creds
  • ForgePtr CVE-2026-47501 - Kernel Module Loaded from Writable Path (Persistence) · unlock with TL Creds
  • ForgePtr CVE-2026-47501 - Execution via /proc/PID/root (Container Escape Handler Path) · unlock with TL Creds
  • ForgePtr CVE-2026-47501 - Kernel Lockdown / sig_enforce Modification Attempt · unlock with TL Creds
  • ForgePtr CVE-2026-47501 - NVIDIA Driver Activity Followed by Kernel Setting Tampering (Correlation) · unlock with TL Creds
  • ForgePtr CVE-2026-47501 - Kernel Hardening Sysctls Relaxed (Post-Exploitation) · unlock with TL Creds
  • ForgePtr CVE-2026-47501 - Container Modifying Host-Global Kernel State · unlock with TL Creds

Indicators of compromise

As of 2026-11-19, Threadlinqs Intelligence tracks 3 indicators of compromise for TL-2026-6427.

3 indicators of compromise · unlock with TL Creds. Compare plans

Technical analysis

Stealthium demonstrated host root, container escape and runtime bypass of kernel lockdown and module signature enforcement; NVIDIA fixed it in 615.71.09.

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 techniques by tactic:

Persistence

T1547.006 Boot or Logon Autostart Execution: Kernel Modules and Extensions

Privilege Escalation

T1547.006 Boot or Logon Autostart Execution: Kernel Modules and Extensions; T1611 Escape to Host

defense-impairment

T1553 Subvert Trust Controls; T1685 Disable or Modify Tools

Remediation

Patches

  • NVIDIA driver 615.71.09 (released 2026-09-09)
  • NVIDIA Security Bulletin 5861 (2026-09-30)

Immediate actions

  • Upgrade NVIDIA Linux open GPU kernel modules to 615.71.09 or later (or the distro-packaged fixed build, e.g. 580.178.04 / 595.91.07 branches per NVIDIA's CVE record)
  • Prioritize nodes that expose GPUs to untrusted workloads or multi-tenant containers
  • Verify the driver version actually loaded on each host, not the version inside a container image

Workarounds

  • No meaningful workaround short of patching: sysctls, seccomp profiles, IOMMU, device isolation and confidential-compute controls do not close it
  • Limit GPU device access to trusted workloads until patched

Longer-term hardening

  • Alert on unprivileged or containerized writes to core_pattern, kernel_locked_down, sig_enforce and other sysctl-backed kernel globals
  • Correlate GPU driver errors with unexpected changes to host-wide kernel settings; do not treat an isolated process crash as proof of exploitation
  • Corroborate GPU device telemetry with host-level evidence
  • Audit kernel lockdown and module signature enforcement state at runtime, not only Secure Boot status at boot

Affected and fixed versions

  • NVIDIA — Open GPU kernel modules / GPU Display Driver for Linux
    Vulnerable versions: 515.43.04 through 610.57.04 (root confirmed on 610.43.02 and 610.57.04); R615 prior to 615.71.09; R595 prior to 595.91.07; R580 prior to 580.178.04
    Fixed in: 615.71.09
  • NVIDIA — Virtual GPU (vGPU) Linux/Windows guest drivers and vGPU Manager
    Vulnerable versions: vGPU 20 Linux guest 595.71.05 and earlier; vGPU 19 Linux guest 580.159.03 and earlier; vGPU 20 Windows guest 596.36 and earlier; vGPU 19 Windows guest 582.53 and earlier; vGPU 20 Manager 595.71.03 and earlier; vGPU 19 Manager 580.159.01 and earlier
    Fixed in: See NVIDIA Security Bulletin 5861

Timeline

  • NVIDIA open GPU kernel module release 515.43.04, the first release containing the vulnerable code, is published.
  • Release 610.57.04, the last open-source driver release affected per Stealthium, is published; root later confirmed on it.
  • NVIDIA ships driver 615.71.09 adding the missing error check.
  • NVIDIA publishes its security bulletin and CVE-2026-47501 (CVSS 3.1 7.8, CWE-787).
  • Stealthium publishes ForgePtr technical write-up, withholding the proof of concept (publication date per Phoronix/search reporting).
  • GBHackers reports the flaw, noting host root, container escape and runtime lockdown/module-signature bypass; no in-the-wild exploitation reported.

Sources cited

Drafted by the Threadlinqs research pipeline from 9 sources; published ; last updated —.

Threadlinqs Intelligence — Real-Time Threat Detection Platform

// threat_feed
$ sort --newest
Showing all threats

Live intelligence console

Threat level

Latest Threats