CVE-2026-98284
Received Received - Intake

BaseFortify

Vulnerability report for CVE-2026-98284, including description, CVSS score, EPSS score, affected products, exploitability, helpful resources, and attack-flow context.

Publication date: 2026-10-06

Last updated on: 2026-10-19

Assigner: kernel.org

Description

In the Linux kernel, the following vulnerability has been resolved: netlink: do not free nlk->groups while lockless readers can use it netlink_realloc_groups() uses krealloc() under netlink_table_grab(). Whenever NLGRPSZ(groups) lands in a different kmalloc bucket, the old bitmap is freed immediately. Two readers of nlk->groups / nlk->ngroups do not hold the netlink table lock: 1) sk_diag_dump_groups(). Hashed (bound) sockets are dumped from the rhashtable walk in __netlink_diag_dump(), which only holds RCU. Only the mc_list part of the dump takes nl_table_lock. 2) netlink_native_seq_show() (/proc/net/netlink), whose walk has been lockless since commit 21e4902aea80 ("netlink: Lockless lookup with RCU grace period in socket release"). Both can read a freed buffer, and sk_diag_dump_groups() can also read past the end of the old (smaller) buffer if it happens to load the old @groups pointer together with the new @ngroups value, copying the result into a NETLINK_DIAG_GROUPS attribute. This is the same class of bug that commit f773608026ee ("netlink: access nlk groups safely in netlink bind and getname") fixed for bind() and getname(); these two readers were missed. Simply grabbing the table lock in sk_diag_dump_groups() is not an option, because it is also called with nl_table_lock already held from the mc_list section of the dump. Make the lockless readers safe instead: - Allocate a new bitmap and free the old one after an RCU grace period, instead of relying on the implicit kfree() done by krealloc(). - Publish @groups before @ngroups, both with release semantics, and have the lockless readers load @ngroups first. A reader can then never pair the new (bigger) size with the old (smaller) buffer, and a reader picking up the new pointer while still seeing the old size is guaranteed to see the initialized bitmap. netlink_realloc_groups() is called from process context (bind() and setsockopt()), so kfree_rcu_mightsleep() can be used, once the table has been released.

CVSS Scores

EPSS Scores

Probability:
Percentile:

Meta Information

Published
2026-10-06
Last Modified
2026-10-19
Generated
2026-10-19
AI Q&A
2026-10-06
EPSS Evaluated
2026-10-18
NVD
EUVD

Affected Vendors & Products

Showing 3 associated CPEs
Vendor Product Version / Range
Linux Linux 21e4902aea80ef35afc00ee8d2abdea4f519b7f7
Linux Linux 21e4902aea80ef35afc00ee8d2abdea4f519b7f7
Linux Linux 4.0

Helpful Resources

Exploitability

CWE
CWE Icon
KEV
KEV Icon
CWE ID Description
CWE-UNKNOWN

Attack-Flow Graph

AI Quick Actions

Instant insights powered by AI
Executive Summary

This is a race condition in the Linux kernel's netlink subsystem. It occurs when the kernel reallocates memory for group membership data while other parts of the kernel are reading it without proper locking. The issue arises because krealloc() frees the old memory immediately if the new size moves to a different memory bucket, but lockless readers may still access the freed memory.

Detection Guidance

This vulnerability is specific to the Linux kernel's netlink subsystem and requires kernel-level inspection. Detection involves checking kernel logs for related errors or verifying the kernel version against patched versions. Commands like 'uname -a' can show the kernel version, and 'dmesg' may reveal related errors. However, no direct detection commands are provided in the context.

Impact Analysis

An attacker could exploit this to read corrupted or freed memory, potentially causing system crashes or information leaks. Systems using netlink for inter-process communication could be affected, especially those with unprivileged users or network services relying on netlink.

Compliance Impact

This vulnerability does not directly affect compliance with standards like GDPR or HIPAA. It is a Linux kernel memory safety issue that could lead to data corruption or crashes but does not inherently violate data protection or privacy regulations.

Mitigation Strategies

Update the Linux kernel to a version that includes the fix for this vulnerability. Since the issue is resolved in a specific kernel version, applying the latest stable kernel update is the primary mitigation step. Check your distribution's security advisories for the patched version.

Chat Assistant

Ask questions about this CVE
Hi! I’m here to help you understand CVE-2026-98284. Ask me anything about the vulnerability, its impact, or mitigation strategies.
0/70

EPSS Chart