CVE-2026-97992: Software Security Vulnerability Vulnerability

UNKNOWN
Advisory Identifier: GHSA-hm65-mv9r-74m7
Share
Published
Advisory Summary

CVE-2026-97992 is a security vulnerability vulnerability (General Security Weakness) affecting Software libraries in the Maven ecosystem. Remediation is available in the latest vendor maintenance releases.

CVE-2026-97992 at a Glance

CVE Identifier CVE-2026-97992
GHSA Identifier GHSA-hm65-mv9r-74m7
Severity N/A
CVSS v3.1 Base Score N/A
CWE Classification General Security Weakness
Affected Product Software
Package Ecosystem Maven
Published Date
Last Updated

How to Fix CVE-2026-97992

To remediate this vulnerability, upgrade all affected Software dependencies to a patched release. Both direct and transitive dependencies should be checked, as frameworks or security libraries may pull in vulnerable versions transitively.

Verify Direct and Transitive Dependencies

Run the following command in your project directory to verify that all resolved dependencies use the patched release: 

mvn dependency:tree

How to Check if You Are Affected

To determine whether your Java application is affected by CVE-2026-97992, inspect your build dependencies using the Maven Dependency Plugin:

mvn dependency:tree

Analyze the terminal output to locate any version of Software in your dependency tree. If any resolved version matches the vulnerable ranges listed in the table below (for example, versions earlier than the patched release), your application is affected.

Note: The mvn dependency:tree command inspects the resolved dependency graph declared in your project's POM files; it does not perform automated security scanning or inspect runtime dynamic classpaths. Always verify runtime container classpaths and shaded JARs.

Technical Details

Vulnerability Mechanism & Technical Analysis

This vulnerability is classified under General Security Weakness. In Software, software state validation or input boundaries are circumvented during processing. Review the official source advisory statement below for specific affected components, classes, and reproduction details.

Source Advisory Statement

In the Linux kernel, the following vulnerability has been resolved: vhost-vdpa: protect config_ctx from being freed under the config callback vhost_vdpa_config_cb() loads v->config_ctx and signals it without taking a reference and without holding any lock: struct eventfd_ctx *config_ctx = v->config_ctx; if (config_ctx) eventfd_signal(config_ctx); VHOST_VDPA_SET_CONFIG_CALL replaces that field and drops what is normally the last reference to the old context: swap(ctx, v->config_ctx); if (ctx) eventfd_ctx_put(ctx); eventfd_ctx_put() drops the last kref and frees the context immediately, with no RCU grace period, so a callback that has already loaded the pointer goes on to dereference freed memory. The two sides share no lock: the ioctl runs under vhost_dev.mutex, while the parent invokes the callback from its own interrupt or workqueue context. This is not the reopen refcount underflow fixed by commit f6bbf0010ba0 ("vhost-vdpa: fix use-after-free of v->config_ctx"), which was about vhost_vdpa_config_put() leaving a stale pointer behind. Here the pointer is maintained correctly and it is the read side that is unprotected. With VDUSE as the parent this is reachable from userspace with access to /dev/vduse (root by default). VDUSE_DEV_INJECT_CONFIG_IRQ queues dev->inject, and vduse_dev_irq_inject() runs the callback under VDUSE's own dev->irq_lock, which vhost does not hold. vduse_dev_reset() does flush_work(&dev->inject), but VHOST_VDPA_SET_CONFIG_CALL never goes through reset, so an inject already in flight is not waited for. A process that injects config interrupts on the VDUSE fd while another thread swaps the call fd on the vhost-vdpa fd hits it in seconds: BUG: KASAN: slab-use-after-free in native_queued_spin_lock_slowpath Read of size 4 at addr ffff888107d21808 by task kworker/u17:1/2993 Workqueue: vduse-irq vduse_dev_irq_inject Call Trace: native_queued_spin_lock_slowpath+0x97/0x5b0 _raw_spin_lock_irqsave+0xd4/0xe0 eventfd_signal_mask+0x69/0x120 vhost_vdpa_config_cb+0x34/0x50 vduse_dev_irq_inject+0x46/0x60 process_one_work+0x468/0x950 Allocated by task 2992: do_eventfd+0x50/0x200 __x64_sys_eventfd2+0x2e/0x40 Freed by task 2992: eventfd_ctx_put+0xb9/0xc0 vhost_vdpa_unlocked_ioctl+0x116c/0x2190 Add a spinlock covering every access to config_ctx, so the callback either signals a context that is still alive or observes NULL, and the put happens only once no callback can reach the old value. Clearing the parent's callback before the put would not be enough: of the in-tree set_config_cb() implementations only VDUSE takes a lock, the rest store the pointer unlocked, so that would not order against an in-flight invocation.

References

NVD — CVE-2026-97992 NVD
https://nvd.nist.gov/vuln/detail/CVE-2026-97992
git.kernel.org/stable/c/5a075ee239... WEB
https://git.kernel.org/stable/c/5a075ee2398929d5cc1393666f219c35332becb1
git.kernel.org/stable/c/62be4e3e5f... WEB
https://git.kernel.org/stable/c/62be4e3e5f5f947fbf765b914cebdc478f715d12
git.kernel.org/stable/c/bf35c8948a... WEB
https://git.kernel.org/stable/c/bf35c8948ab7a3eaf1f724fa1e870e3f73a1749b
git.kernel.org/stable/c/f4a93f15ed... WEB
https://git.kernel.org/stable/c/f4a93f15ed1c8406ba5c8e5b28cafacb2b3bcd11

Frequently Asked Questions

What is CVE-2026-97992?
CVE-2026-97992 is a security vulnerability in Software classified as a security vulnerability vulnerability under General Security Weakness.
Which Software versions are affected?
Affected versions include releases prior to current release patches.
What version fixes CVE-2026-97992?
Upgrading to current release patches (or the latest patched release for your respective branch) resolves the vulnerability.
What CWE is associated with CVE-2026-97992?
CVE-2026-97992 is classified under General Security Weakness.
How can I check Maven dependencies for CVE-2026-97992?
Run the dependency tree command: 'mvn dependency:tree'. This command lists direct and transitive dependencies in your build configuration so you can verify if a vulnerable version is resolved.
Machine-readable OSV JSON OSV v1.5 Schema
Normalized schema output
View Raw JSON 
{
  "schema_version" : "1.4.0",
  "id" : "GHSA-hm65-mv9r-74m7",
  "modified" : "2026-09-25T12:31:32Z",
  "published" : "2026-09-25T12:31:32Z",
  "aliases" : [ "CVE-2026-97992" ],
  "details" : "In the Linux kernel, the following vulnerability has been resolved:\n\nvhost-vdpa: protect config_ctx from being freed under the config callback\n\nvhost_vdpa_config_cb() loads v->config_ctx and signals it without taking\na reference and without holding any lock:\n\n\tstruct eventfd_ctx *config_ctx = v->config_ctx;\n\n\tif (config_ctx)\n\t\teventfd_signal(config_ctx);\n\nVHOST_VDPA_SET_CONFIG_CALL replaces that field and drops what is normally\nthe last reference to the old context:\n\n\tswap(ctx, v->config_ctx);\n\n\tif (ctx)\n\t\teventfd_ctx_put(ctx);\n\neventfd_ctx_put() drops the last kref and frees the context immediately,\nwith no RCU grace period, so a callback that has already loaded the\npointer goes on to dereference freed memory.  The two sides share no\nlock: the ioctl runs under vhost_dev.mutex, while the parent invokes the\ncallback from its own interrupt or workqueue context.\n\nThis is not the reopen refcount underflow fixed by commit f6bbf0010ba0\n(\"vhost-vdpa: fix use-after-free of v->config_ctx\"), which was about\nvhost_vdpa_config_put() leaving a stale pointer behind.  Here the pointer\nis maintained correctly and it is the read side that is unprotected.\n\nWith VDUSE as the parent this is reachable from userspace with access to\n/dev/vduse (root by default).  VDUSE_DEV_INJECT_CONFIG_IRQ queues\ndev->inject, and vduse_dev_irq_inject() runs the callback under VDUSE's\nown dev->irq_lock, which vhost does not hold.  vduse_dev_reset() does\nflush_work(&dev->inject), but VHOST_VDPA_SET_CONFIG_CALL never goes\nthrough reset, so an inject already in flight is not waited for.  A\nprocess that injects config interrupts on the VDUSE fd while another\nthread swaps the call fd on the vhost-vdpa fd hits it in seconds:\n\n  BUG: KASAN: slab-use-after-free in native_queued_spin_lock_slowpath\n  Read of size 4 at addr ffff888107d21808 by task kworker/u17:1/2993\n  Workqueue: vduse-irq vduse_dev_irq_inject\n  Call Trace:\n   native_queued_spin_lock_slowpath+0x97/0x5b0\n   _raw_spin_lock_irqsave+0xd4/0xe0\n   eventfd_signal_mask+0x69/0x120\n   vhost_vdpa_config_cb+0x34/0x50\n   vduse_dev_irq_inject+0x46/0x60\n   process_one_work+0x468/0x950\n\n  Allocated by task 2992:\n   do_eventfd+0x50/0x200\n   __x64_sys_eventfd2+0x2e/0x40\n\n  Freed by task 2992:\n   eventfd_ctx_put+0xb9/0xc0\n   vhost_vdpa_unlocked_ioctl+0x116c/0x2190\n\nAdd a spinlock covering every access to config_ctx, so the callback\neither signals a context that is still alive or observes NULL, and the\nput happens only once no callback can reach the old value.\n\nClearing the parent's callback before the put would not be enough: of the\nin-tree set_config_cb() implementations only VDUSE takes a lock, the rest\nstore the pointer unlocked, so that would not order against an in-flight\ninvocation.",
  "severity" : [ ],
  "affected" : [ ],
  "references" : [ {
    "type" : "ADVISORY",
    "url" : "https://nvd.nist.gov/vuln/detail/CVE-2026-97992"
  }, {
    "type" : "WEB",
    "url" : "https://git.kernel.org/stable/c/5a075ee2398929d5cc1393666f219c35332becb1"
  }, {
    "type" : "WEB",
    "url" : "https://git.kernel.org/stable/c/62be4e3e5f5f947fbf765b914cebdc478f715d12"
  }, {
    "type" : "WEB",
    "url" : "https://git.kernel.org/stable/c/bf35c8948ab7a3eaf1f724fa1e870e3f73a1749b"
  }, {
    "type" : "WEB",
    "url" : "https://git.kernel.org/stable/c/f4a93f15ed1c8406ba5c8e5b28cafacb2b3bcd11"
  } ],
  "database_specific" : {
    "cwe_ids" : [ ],
    "severity" : null,
    "github_reviewed" : false,
    "github_reviewed_at" : null,
    "nvd_published_at" : "2026-09-25T11:17:27Z"
  }
}