CVE-2026-99567 in Linuxinfo

Summary

by MITRE • 11/20/2026

In the Linux kernel, the following vulnerability has been resolved:

assoc_array: don't chain a new shortcut onto an existing one

When a full node's leaves and the new key all share the node's segment, assoc_array_insert_into_terminal_node() replaces the node with a shortcut to a pair of new nodes. If the node is itself the target of a shortcut, the new shortcut is installed as that shortcut's next node, and a shortcut leading to a shortcut is something nothing expects: assoc_array_walk() indexes the second one as a node, and assoc_array_apply_edit() hits the BUG_ON() in the loop that adjusts nr_leaves_on_branch, on that same insertion.

Deletion gets a node there. When the subtree below a shortcut shrinks enough, assoc_array_delete() collapses it into one node below the shortcut, and the leaves it collects can all share that node's segment. The next key that shares it too takes this path. Eighteen insertions and a deletion are enough: sixteen keys that agree on bits 0-11, one that leaves them at bit 8 and is deleted again, and one more that agrees with the sixteen.

Have the new shortcut replace the one in front of the node as well. assoc_array_insert_shortcut() gives it that shortcut's back pointer and parent slot, so the caller installs it where that one was, and excises the old shortcut along with the node, which takes a second entry in excised_meta[]. The new shortcut's index key comes from the new key up
to the new skip level, so it covers what the old one did.

Found by a userspace test doing random insertions and deletions on keys that share long prefixes; a targeted case builds a shortcut, deletes down to the collapse and inserts one more key.

If you want to get the best quality for vulnerability data then you always have to consider VulDB.

Analysis

by VulDB Data Team • 11/21/2026

The Linux kernel's associative array implementation contains a logic flaw in its handling of node shortcuts during insertion operations involving shared segments. The assoc_array data structure is designed for efficient storage and retrieval of key-value pairs by utilizing variable-length indexing, where nodes can point to other nodes or contain leaves directly. A specific optimization involves the use of shortcuts, which are compact representations that skip over common prefix bits in keys to reduce traversal depth. However, a vulnerability arises when an insertion operation attempts to chain a new shortcut onto an existing one rather than replacing it appropriately. This scenario occurs within the assoc_array_insert_into_terminal_node function when both the leaves of a full node and the newly inserted key share the same segment as the current node's prefix. In such cases, the system intends to replace the existing structure with a shortcut pointing to new nodes that handle the divergence in keys.

The core technical flaw lies in how the kernel handles situations where the target node is already the destination of an existing shortcut. Instead of replacing the old shortcut and its associated node entirely, the flawed logic installs the newly created shortcut as the next node following the original shortcut. This results in a chain consisting of a shortcut leading to another shortcut, which violates the internal structural assumptions of the assoc_array implementation. The traversal function, assoc_array_walk(), is not equipped to handle this nested shortcut configuration correctly; it attempts to index into what it expects to be a standard node but encounters the second shortcut instead. This mismatch triggers an assertion failure within assoc_array_apply_edit() during the loop that adjusts the number of leaves on the branch, specifically hitting a BUG_ON condition. Such a bug typically results in a kernel panic or denial of service for processes relying on this data structure, effectively crashing the system component using it.

The vulnerability can be triggered through specific sequences of insertions and deletions that manipulate key prefixes to force the problematic code path into execution. A targeted attack vector involves creating a scenario where eighteen operations are performed: sixteen initial keys sharing bits 0-11, followed by one key differing at bit eight which is subsequently deleted, and finally another insertion that shares the original prefix with the remaining nodes. This sequence forces the system to collapse a subtree due to deletion and then attempt an insertion that re-introduces the shared segment conflict. The existence of this bug highlights a gap in edge-case handling for dynamic data structures within the kernel space, particularly when dealing with high-frequency modifications to keys with long common prefixes.

From a classification perspective, this vulnerability aligns with CWE-617, which covers Reachable Assertion issues, as the flaw leads directly to an unreachable code path being executed via assertion failure. It also relates to CWE-823, involving use of pointers where dereferencing is not allowed or expected, given that the traversal logic misinterprets a shortcut structure as a standard node pointer. In terms of MITRE ATT&CK mapping for Linux systems, this could be categorized under T1059, Command and Scripting Interpreter, if exploited to cause denial of service through system instability, although it is primarily an internal kernel integrity failure rather than direct command execution. The impact is severe in environments where the assoc_array implementation is critical, such as networking stacks or memory management subsystems that rely on fast key lookups under heavy load.

The resolution involves modifying the insertion logic to ensure that when a new shortcut is created for a node that was previously targeted by an old shortcut, the new shortcut completely replaces both the old shortcut and its associated node in the tree structure. The fix utilizes assoc_array_insert_shortcut() to properly transfer back pointers and parent slot references from the obsolete shortcut to the new one. This ensures that the caller installs the replacement at the correct location in the data structure while excising the redundant elements, including updating metadata arrays like excised_meta[] to maintain consistency. By ensuring the new shortcut covers the same index key range as the old one but stands alone without chaining, the structural integrity of the associative array is preserved.

To mitigate this vulnerability, system administrators and developers should ensure that Linux kernels are updated with patches addressing this assoc_array logic error. For systems where immediate patching is not feasible, monitoring for kernel panics or unexpected crashes in services utilizing high-volume key-value operations may provide early detection indicators. Developers integrating custom data structures based on the Linux kernel's associative array implementation must review their insertion and deletion algorithms to ensure they do not trigger similar edge cases if they have modified the underlying traversal logic. Regular security audits focusing on dynamic memory management and pointer arithmetic within kernel modules are recommended to prevent analogous issues in other subsystems that share similar design patterns with assoc_array.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00167

KEV

no

Activities

very low

Sources

Do you need the next level of professionalism?

Upgrade your account now!