Cloudanix VulnDB

CVE-2026-89723

High · 7.8

CVSS

7.8

EPSS

0.2%

Published

Sep 11, 2026

CISA due date

—

Cloudanix analysis

Next patch cycle SSVC: Track

A bug in the Linux kernel's handling of one type of file system could let a person who already has access to the computer cause crashes or potentially run unwanted code.

Exploitation
Local Privilege
Attacker needs
Low Privilege
Complexity
Low
Impact
Full Compromise
Component
OS kernel
Class
Memory Corruption
Remediation
Upgrade
Effort
Medium
Patch risk
Low

What it actually does

Slab-out-of-bounds memory access in nilfs2 B-tree handling after file truncation leaves an orphaned intermediate node block that the log writer later processes via nilfs_direct_propagate, causing invalid virtual block number dereference outside the direct-mapping range.

Why it matters to the business

Local users on affected Linux systems using the nilfs2 file system can trigger kernel memory corruption leading to crashes, data loss, or potential privilege escalation; the 43-day-old issue remains unexploited in the wild with negligible EPSS and no KEV listing, limiting immediate operational urgency.

How an attack unfolds

An attacker with local access creates and truncates a file on a nilfs2 volume so that a B-tree node collapses into direct mapping without deleting the intermediate node; the dirty node remains in cache, the log writer later invokes the direct-propagate path on it, and the resulting out-of-bounds access corrupts kernel memory for denial-of-service or code execution.

How to fix it

Upgrade the Linux kernel to a version containing the nilfs_btree_discard fix and the deform flag change to bop_delete; rebuild and reboot with the patched kernel; avoid mounting untrusted nilfs2 volumes until updated.

How to confirm the fix worked

Confirm the running kernel contains the commit adding nilfs_btree_discard during mapping collapse; test by reproducing the truncation scenario under KASAN to verify absence of slab-out-of-bounds; inspect nilfs2 source for the deform flag handling in bop_delete.

Typical attack path

  1. Obtain local shell or user context on a system mounting nilfs2
  2. Create a file and perform truncation that collapses B-tree mapping
  3. Trigger log writer activity that reuses the orphaned node block
  4. nilfs_direct_propagate performs out-of-bounds slab access
  5. Kernel memory corruption yields crash or escalation

How to detect it

Search kernel logs and dmesg for KASAN reports mentioning nilfs_direct_propagate or slab-out-of-bounds during nilfs2 truncation; look for repeated log-writer activity immediately after file truncation on nilfs2 volumes; no public IOCs or threat-actor artifacts are known.

What your security team should do

  • Prioritize kernel updates on any systems actively using nilfs2
  • Disable nilfs2 module or avoid mounting nilfs2 volumes if updates cannot be applied promptly
  • Monitor kernel logs for KASAN or slab corruption messages referencing nilfs_direct_propagate
  • Review EPSS trend remains flat; no immediate KEV or ransomware indicators

The record

In the Linux kernel, the following vulnerability has been resolved: nilfs2: fix slab-out-of-bounds in nilfs_direct_propagate after truncation Shuangpeng Bai reported that KASAN detected a slab-out-of-bounds error in nilfs_direct_propagate() during testing. Analysis revealed that after truncating a file, a node block immediately below the B-tree root was not deleted. Instead, it remained in the B-tree node cache in a dirty state. The log writer subsequently detected this block and incorrectly invoked nilfs_direct_propagate() on it, which is designed to handle only data blocks in direct mapping. B-tree nodes in the cache are managed by virtual block numbers, and their logical keys typically exceed the range expected by direct mapping. Consequently, processing such a node as a direct mapping entry triggers a slab-out-of-bounds access. The root cause is that when a B-tree mapping collapses into a direct mapping during truncation, an intermediate node block pointed to by the root node is left behind as garbage instead of being explicitly deleted. This resolves the issue by adding a nilfs_btree_discard() operation to delete the remaining intermediate node block during the conversion. A 'deform' flag is added to the bop_delete interface to explicitly signal that the deletion is part of a mapping transformation. This allows the B-tree mapping implementation to perform the necessary cleanup and discarding of the residual node structure that would be otherwise be left orphaned after the transition.

Affected packages

Ecosystem Package Introduced Fixed