HIGH 7.8

CVE-2026-53118: Linux Kernel vdpa Use-After-Free via Unprotected driver_override Access

A race condition exists in the Linux kernel's vdpa (vhost data path acceleration) subsystem where the driver override mechanism can be accessed without proper locking. When the kernel attempts to attach a driver to a device, it calls the bus match function without holding the device lock. If another process simultaneously modifies the driver_override field, this can lead to a use-after-free (UAF) condition, where freed memory is incorrectly accessed. The fix involves adopting the kernel's generic driver_override infrastructure, which handles locking internally to prevent concurrent access issues.

Source data · NVD / CISA · public domain

CVSS
3.1 · 7.8 HIGH · CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
Weaknesses (CWE)
CWE-416
Affected products
1 configuration(s)
Published / Modified
2026-06-24 / 2026-07-23

NVD description (verbatim)

In the Linux kernel, the following vulnerability has been resolved: vdpa: use generic driver_override infrastructure When a driver is probed through __driver_attach(), the bus' match() callback is called without the device lock held, thus accessing the driver_override field without a lock, which can cause a UAF. Fix this by using the driver-core driver_override infrastructure taking care of proper locking internally. Note that calling match() from __driver_attach() without the device lock held is intentional. [1]

3 reference(s) · View on NVD →

SEC.co analysis · AI-assisted, reviewed against source

Technical summary

CVE-2026-53118 addresses a use-after-free vulnerability in the Linux kernel vdpa driver subsystem. The vulnerability occurs in the device-driver matching flow when __driver_attach() calls the bus match() callback without holding the device lock. The vdpa code was directly accessing the driver_override field in an unprotected manner, creating a race condition where concurrent modifications could trigger a UAF. The resolution involves replacing the custom driver_override handling with the driver-core's built-in driver_override infrastructure, which includes proper synchronization primitives to prevent this race. This is classified as CWE-416 (use-after-free).

Business impact

Exploitation of this vulnerability requires local access and unprivileged user privileges, but successful exploitation can compromise system stability and data confidentiality. An attacker could trigger kernel memory corruption, potentially leading to information disclosure or denial of service. In shared hosting, containerized, or multi-tenant environments, this becomes a significant lateral movement or privilege escalation vector. Organizations running Linux kernel versions containing the vulnerable vdpa code should prioritize assessment to determine exposure in their infrastructure.

Affected systems

The Linux kernel is affected, specifically the vdpa subsystem. Affected versions are those that contain the vulnerable vdpa driver_override implementation prior to the fix. Verify against the official Linux kernel security advisories and your Linux distribution's security notices for specific version ranges. The vdpa subsystem is used by hypervisors and virtualization platforms that depend on vhost data path acceleration, making virtual infrastructure particularly relevant to this issue.

Exploitability

The vulnerability requires local code execution (AV:L) with low privileges (PR:L) and no user interaction (UI:N). An unprivileged local attacker can trigger the race condition by simultaneously modifying driver_override while the kernel attempts device-driver attachment. The race is not guaranteed on every attempt, making exploitation probabilistic but feasible on systems with sufficient concurrency (multi-core systems). The attack surface is moderate; the attacker must have local system access and the ability to execute code or scripts.

Remediation

Update the Linux kernel to a patched version that incorporates the vdpa driver_override infrastructure fix. Consult your Linux distribution's security advisories and kernel update repositories for the specific patched kernel version. The fix involves replacing custom driver_override field access with calls to the driver-core's generic driver_override infrastructure, which is available in recent kernel versions. Verify patch status with your vendor before deploying.

Patch guidance

Obtain kernel updates from your distribution's official repositories (Ubuntu Security Updates, RHEL Errata, etc.) or directly from kernel.org. Test patches in a non-production environment first to ensure compatibility with your running systems and any custom kernel configurations. The fix is a subsystem-level change with low risk of regression, but validation in your specific environment is recommended before broad deployment. Monitor kernel mailing lists and CVE advisories for any related follow-up issues.

Detection guidance

Monitor system logs for unexpected kernel warnings or oops messages related to the vdpa subsystem, particularly those mentioning use-after-free or memory corruption. Network-based detection is not possible; focus on local host monitoring. Kernel Address Sanitizer (KASAN) or similar kernel debugging features may detect the UAF at runtime if enabled in your kernel build. Check the running kernel version against known patched versions using 'uname -r' and cross-reference against vendor security bulletins. Consider implementing kernel module integrity monitoring for vdpa if available in your endpoint detection solution.

Why prioritize this

This vulnerability scores 7.8 (HIGH) with potential for local privilege escalation and information disclosure. While it requires local access, the lack of barriers (low complexity, no user interaction, unprivileged users) makes it attractive for post-compromise lateral movement or privilege escalation in shared systems. The race condition nature introduces some exploitation difficulty, but multi-core systems and high-concurrency environments are at elevated risk. Prioritize patching for systems in sensitive roles (hypervisors, shared cloud hosts, development servers) and those with known high concurrency workloads.

Risk score, explained

CVSS 7.8 reflects a HIGH severity rating based on: local attack vector (AV:L), low attack complexity (AC:L), low privilege requirement (PR:L), no user interaction (UI:N), and high impact to confidentiality, integrity, and availability (C:H/I:H/A:H). The race condition does not elevate attack complexity significantly given multi-core prevalence. The vulnerability is not currently listed on the CISA KEV catalog, but the high CVSS and exploitability profile warrant proactive remediation regardless of active exploitation reports.

Frequently asked questions

Do I need local access to the system to exploit this vulnerability?

Yes. CVE-2026-53118 requires local code execution (AV:L). An attacker must have the ability to run code or scripts on the affected system. This makes it relevant primarily to multi-user systems, shared hosting environments, containers, and virtual machines where untrusted tenants may reside.

Can this be exploited remotely over the network?

No. The attack vector is local (AV:L), so network-based exploitation is not possible. However, if an attacker gains initial remote code execution through another vulnerability, they could then exploit CVE-2026-53118 for privilege escalation or lateral movement.

What is a use-after-free vulnerability and why is it dangerous?

A use-after-free (CWE-416) occurs when code accesses memory that has already been freed. In this case, concurrent access to the driver_override field without locks creates a window where freed memory may be dereferenced. This can lead to information disclosure (reading stale data), code execution (if memory is reallocated), or denial of service (kernel crash).

Is this vulnerability actively exploited in the wild?

CVE-2026-53118 is not listed on the CISA Known Exploited Vulnerabilities (KEV) catalog as of this writing, indicating no known active exploitation at the time of disclosure. However, the absence from KEV does not guarantee lack of threat actor interest. Organizations should treat HIGH-severity local privilege escalation vectors with appropriate urgency regardless of KEV status.

This analysis is provided for informational purposes. The vulnerability details, affected versions, and patched version numbers must be verified against official Linux kernel security advisories, your distribution's security notices, and vendor patch release notes. SEC.co makes no warranty regarding the completeness or accuracy of version information. Organizations must conduct their own risk assessment and testing before applying patches in production environments. No exploit code or attack techniques are provided herein. Always consult your security team and vendor advisories before taking remediation actions. Source: NVD (public-domain), retrieved 2026-08-02. Analysis generated by SEC.co (claude-haiku-4-5).