EUVD-2026-103752
GHSA-2689-7jhq-fvhw
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain local unprivileged access
-
DeliverySubmit nouveau GPU job exporting fence
-
ExploitTrigger scheduler object free via kfree
-
ExecutionCall SYNC_IOC_FILE_INFO on stale fence
-
ImpactRead freed kernel slab memory
Vulnerability Assessment
| Exploitation Conditions | Requires the nouveau DRM driver to be in use (a system with an NVIDIA GPU driven by the open-source nouveau kernel driver), plus local access as an unprivileged user able to submit nouveau scheduler work and export a resulting fence to userspace through drm_syncobj or sync_file. The user must then cause the nouveau_sched object to be destroyed (nouveau_sched_destroy/kfree) while a finished, exported fence still references &sched->base, and finally invoke the unprivileged SYNC_IOC_FILE_INFO ioctl, which reaches drm_sched_fence_get_timeline_name() on the freed object. Limiting factors: exploitation is local only (no network vector), needs the nouveau driver present and active, and depends on arranging the free-then-query ordering; systems using the proprietary NVIDIA driver or lacking an NVIDIA GPU are not affected. |
| Impact | Signals converge on a real-but-not-urgent local issue. The CVSS vector (AV:L/AC:L/PR:L/UI:N, C:H/A:H) correctly frames this as a local, low-privilege, no-interaction kernel use-after-free with high confidentiality impact (reading freed slab memory) and high availability impact (potential kernel crash), yielding 7.1 - no remote exposure. EPSS is low at 0.20% (9th percentile), consistent with the absence of CISA KEV listing and the absence of any public exploit reference, so there is no evidence of widespread or active exploitation. The vuln.today decision label is 'this_week' rather than act_now/emergency, matching the pattern of a patched local privilege-boundary bug that should be rolled into routine kernel updates rather than treated as a fire. No SSVC decision fields (automatable, technical impact) were supplied, so that framework cannot be cross-referenced. Net: a genuine local memory-disclosure/DoS flaw worth patching on a normal cadence, not a high-CVSS-but-illusory issue, but also not an emergency given local-only reach, low EPSS, and no exploitation evidence. |
| Exploit ScenarioDerived | A local unprivileged user on a Linux system using the nouveau GPU driver submits work that exports a scheduler fence to userspace via drm_syncobj or sync_file, then triggers destruction of the nouveau scheduler object while a signalled fence still references it. Calling SYNC_IOC_FILE_INFO afterward makes the kernel dereference the freed scheduler through drm_sched_fence_get_timeline_name(), reading freed slab memory (KASAN slab-use-after-free) and potentially crashing the kernel. No public exploit identified at time of analysis; the attack requires local access and the nouveau driver in use. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 24, 2026
Use-after-free read in the Linux kernel's nouveau DRM scheduler: a finished dma-fence that has been exported to userspace can outlive the nouveau_sched object that backs its scheduler, so a later get_timeline_name() call dereferences freed slab memory (KASAN slab-use-after-free). Affected are systems running the open-source nouveau driver on NVIDIA GPUs, with the object reachable by a local user holding low privileges (CVSS PR:L) who can export a fence via drm_syncobj/sync_file and then trigger nouveau_sched_destroy() followed by the unprivileged SYNC_IOC_FILE_INFO ioctl. Impact is a kernel memory disclosure of high confidentiality severity plus denial of service through the fault, exposure is local only, and no public exploit code or CISA KEV entry was identified at time of analysis; EPSS is 0.20% (9th percentile), and vendor fixes are available in 6.12.112, 6.18.55, 7.2.9 and 7.3-rc5.
RemediationAI
Vendor-released patch: upgrade to Linux 6.12.112, 6.18.55, 7.2.9 or 7.3-rc5, which contain the change that frees the scheduler-containing nouveau_sched with kfree_rcu() instead of kfree(); the corresponding mainline and stable commits are https://git.kernel.org/stable/c/40edf5eefc3fd94592a91d6eb074d4fc6f606c75, https://git.kernel.org/stable/c/f7eae6d8d768fabd6b59779ca7da79e02c74e113, https://git.kernel.org/stable/c/35151e9a8274174ccbb92e3b3ba7dc7a008dcada and https://git.kernel.org/stable/c/cd6e11b6ebe04a0a1f1435df561acada9eadc563. The patch status supplied with this record is "Available from vendor" and the fix has been merged into the listed stable branches, so no separate workaround is required where updating is possible. Where a kernel update cannot yet be applied, exposure is confined to hosts that load nouveau on an NVIDIA GPU and allow local users to export scheduler fences and issue the unprivileged SYNC_IOC_FILE_INFO ioctl; removing those users from render-node access (/dev/dri/renderD*) or keeping the affected machines on the proprietary NVIDIA driver removes the described path, at the cost of GPU acceleration or of switching driver stack for those users.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
struct nouveau_sched embeds a struct drm_gpu_scheduler (base) and is torn down by nouveau_sched_destroy(), which calls nouveau_sched_fini() (and therefore drm_sched_fini(&sched->base)) before releasing the surrounding object with plain kfree(sched). Scheduler fences carry a .release callback, so they are not ops-detached when signalled; consequently a finished fence exported to userspace through drm_syncobj or sync_file continues to reference &sched->base after the containing object has been freed. When userspace later queries the fence, drm_sched_fence_get_timeline_name() returns fence->sched->name, reading through the dangling pointer; the unprivileged SYNC_IOC_FILE_INFO ioctl is the documented path to that read. The dma-fence lifetime contract requires the exporter to keep the data backing a signalled fence alive for an RCU grace period, so the upstream fix replaces kfree() with kfree_rcu(). The provided CWE field is unassigned; the root cause class is a use-after-free arising from that lifetime-contract violation, and the affected CPE is the Linux kernel (cpe:2.3:a:linux:linux).
Know when the next one hits your stack
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:H
Local ioctl reachable by any unprivileged user so AV:L/PR:L/AC:L/UI:N; use-after-free read discloses kernel memory (C:H) and can crash the kernel (A:H) with no integrity impact.
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
4DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
drm/nouveau: RCU-free the scheduler-containing nouveau_sched
struct nouveau_sched embeds a struct drm_gpu_scheduler (base). nouveau_sched_destroy() calls nouveau_sched_fini() (which does drm_sched_fini(&sched->base)) and then frees the object with plain kfree(sched).
drm_sched_fence_get_timeline_name() returns fence->sched->name, and the scheduler fence keeps a .release callback so it is not ops-detached on signalling. A finished fence exported to userspace via drm_syncobj / sync_file therefore keeps pointing at &sched->base after nouveau_sched_destroy(), and a later get_timeline_name() -- reachable unprivileged through SYNC_IOC_FILE_INFO -- dereferences freed memory (KASAN slab-use-after-free read).
Per the dma-fence lifetime contract the exporter must keep the data backing a signalled fence alive for an RCU grace period. Free the scheduler-containing object with kfree_rcu() instead of kfree().
Executive ViewAI
CVE-2026-98512 is a high-severity kernel use-after-free in the open-source nouveau driver for NVIDIA GPUs, enabling local users with low privileges to potentially read sensitive kernel memory or cause a denial of service. This affects systems running the nouveau driver, such as Linux workstations or servers with NVIDIA hardware, and requires an authenticated local attacker. Leadership should prioritize patching because compromised local accounts could lead to data exposure or service disruption, though no public exploit exists and exploitation likelihood is currently low.
Apply vendor patch.
Threat Intelligence Overview
NVD
CVE.org
EPSS
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Exploit-DB