CVE-2026-90001: Software Security Vulnerability Vulnerability

HIGH
Advisory Identifier: GHSA-7wpm-8hvh-3rp4
CVSS 7.8
Published
Advisory Summary

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

CVE-2026-90001 at a Glance

CVE Identifier CVE-2026-90001
GHSA Identifier GHSA-7wpm-8hvh-3rp4
Severity HIGH
CVSS v3.1 Base Score 7.8
CWE Classification General Security Weakness
Affected Product Software
Package Ecosystem Maven
Published Date
Last Updated

Security Impact

CVSS: 7.8

The security impact metrics below are parsed directly from the CVSS v3.1 vector string (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H).

Attack Vector Local (AV:L)
Attack Complexity Low (AC:L)
Privileges Required Low (PR:L)
User Interaction None (UI:N)
Scope Unchanged (S:U)
Confidentiality High (C:H)
Integrity High (I:H)
Availability High (A:H)

How to Fix CVE-2026-90001

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-90001, 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: HID: bpf: serialize device reference release in struct_ops destroy path __hid_bpf_ops_destroy_device() and hid_bpf_unreg() can race on the same registration reference, double-putting struct hid_device and freeing it while hid_destroy_device() still uses it. Serialize the remove/NULL decision under hdev->bpf.prog_list_lock so exactly one path releases each registration reference: unreg re-checks ops->hdev under the lock and returns without putting when the destroy path already cleared it; all put_device() calls happen after the lock is dropped, which is safe because a concurrent unreg then observes ops->hdev == NULL under the lock. Background: each successful attach (hid_bpf_ops_reg) acquires one device reference (hid_get_device()). Two paths can release it: - device destruction: hid_destroy_device() -> hid_bpf_destroy_device() -> __hid_bpf_ops_destroy_device(), which walks hdev->bpf.prog_list under rcu_read_lock() and drops one reference per attached program; - BPF link release: bpf map delete (no BPF_F_LINK) synchronously calls st_ops->unreg() -> hid_bpf_unreg(), which drops the reference for its own registration. The coordination handshake (e->hdev = NULL on the destroy side vs "if (!hdev) return" on the unreg side) is a TOCTOU check: the two paths run under different lock domains (rcu_read_lock vs prog_list_lock), so a concurrent unreg can read ops->hdev as non-NULL, block on prog_list_lock, and then proceed while the destroy traversal executes - both paths then drop the same reference. The refcount reaches zero legitimately (each decrement is individually valid), so no refcount_t saturation fires: the device is simply freed while the transport is still inside hid_destroy_device(), and subsequent teardown touches freed memory. The fix serializes the remove/NULL decision under prog_list_lock on both sides and moves the destroy-side puts outside the lock. With the lock held, plain reads/writes of ops->hdev are sufficient; no READ_ONCE/WRITE_ONCE are added, keeping the patch minimal. Unlocked-read safety: the unlocked read of ops->hdev at the top of hid_bpf_unreg() cannot touch a freed device, because the unreg path itself still holds this registration's reference (released only by its own hid_put_device() after the lock is dropped), and a destroy traversal that already cleared ops->hdev makes the lock-internal re-check return early without any put. At most one of the two paths releases each registration reference.

References

Frequently Asked Questions

What is CVE-2026-90001?
CVE-2026-90001 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-90001?
Upgrading to current release patches (or the latest patched release for your respective branch) resolves the vulnerability.
What is the CVSS score of CVE-2026-90001?
CVE-2026-90001 has a CVSS v3.1 base score of 7.8 (HIGH) with vector string CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H.
What CWE is associated with CVE-2026-90001?
CVE-2026-90001 is classified under General Security Weakness.
How can I check Maven dependencies for CVE-2026-90001?
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
{
  "schema_version" : "1.4.0",
  "id" : "GHSA-7wpm-8hvh-3rp4",
  "modified" : "2026-09-16T15:31:06Z",
  "published" : "2026-09-16T12:30:44Z",
  "aliases" : [ "CVE-2026-90001" ],
  "details" : "In the Linux kernel, the following vulnerability has been resolved:\n\nHID: bpf: serialize device reference release in struct_ops destroy path\n\n__hid_bpf_ops_destroy_device() and hid_bpf_unreg() can race on the\nsame registration reference, double-putting struct hid_device and\nfreeing it while hid_destroy_device() still uses it.  Serialize the\nremove/NULL decision under hdev->bpf.prog_list_lock so exactly one\npath releases each registration reference: unreg re-checks ops->hdev\nunder the lock and returns without putting when the destroy path\nalready cleared it; all put_device() calls happen after the lock is\ndropped, which is safe because a concurrent unreg then observes\nops->hdev == NULL under the lock.\n\nBackground: each successful attach (hid_bpf_ops_reg) acquires one\ndevice reference (hid_get_device()).  Two paths can release it:\n\n- device destruction: hid_destroy_device() -> hid_bpf_destroy_device()\n  -> __hid_bpf_ops_destroy_device(), which walks hdev->bpf.prog_list\n  under rcu_read_lock() and drops one reference per attached program;\n- BPF link release: bpf map delete (no BPF_F_LINK) synchronously calls\n  st_ops->unreg() -> hid_bpf_unreg(), which drops the reference for\n  its own registration.\n\nThe coordination handshake (e->hdev = NULL on the destroy side vs\n\"if (!hdev) return\" on the unreg side) is a TOCTOU check: the two\npaths run under different lock domains (rcu_read_lock vs\nprog_list_lock), so a concurrent unreg can read ops->hdev as\nnon-NULL, block on prog_list_lock, and then proceed while the\ndestroy traversal executes - both paths then drop the same\nreference.  The refcount reaches zero legitimately (each decrement\nis individually valid), so no refcount_t saturation fires: the\ndevice is simply freed while the transport is still inside\nhid_destroy_device(), and subsequent teardown touches freed memory.\n\nThe fix serializes the remove/NULL decision under prog_list_lock on\nboth sides and moves the destroy-side puts outside the lock.  With\nthe lock held, plain reads/writes of ops->hdev are sufficient; no\nREAD_ONCE/WRITE_ONCE are added, keeping the patch minimal.\n\nUnlocked-read safety: the unlocked read of ops->hdev at the top of\nhid_bpf_unreg() cannot touch a freed device, because the unreg path\nitself still holds this registration's reference (released only by\nits own hid_put_device() after the lock is dropped), and a destroy\ntraversal that already cleared ops->hdev makes the lock-internal\nre-check return early without any put.  At most one of the two\npaths releases each registration reference.",
  "severity" : [ {
    "type" : "CVSS_V3",
    "score" : "CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H"
  } ],
  "affected" : [ ],
  "references" : [ {
    "type" : "ADVISORY",
    "url" : "https://nvd.nist.gov/vuln/detail/CVE-2026-90001"
  }, {
    "type" : "WEB",
    "url" : "https://git.kernel.org/stable/c/401359684620145be710de97b87e1a47abfe1459"
  }, {
    "type" : "WEB",
    "url" : "https://git.kernel.org/stable/c/9cdc7e6dc7a99ad7311ad5e7c145f2b9ce4e24b0"
  }, {
    "type" : "WEB",
    "url" : "https://git.kernel.org/stable/c/bfb7939788f3c8dd080a4dd81e38d625b35d194e"
  }, {
    "type" : "WEB",
    "url" : "https://git.kernel.org/stable/c/c7f927aa8b55008ed5ea0814313d5dad771dcf3c"
  } ],
  "database_specific" : {
    "cwe_ids" : [ ],
    "severity" : "HIGH",
    "github_reviewed" : false,
    "github_reviewed_at" : null,
    "nvd_published_at" : "2026-09-16T11:17:11Z"
  }
}