Cloudanix VulnDB

CVE-2026-89720

High · 7.7

CVSS

7.7

EPSS

0.2%

Published

Sep 11, 2026

CISA due date

—

Cloudanix analysis

Next patch cycle SSVC: Track

A Linux kernel bug could let someone read parts of memory they should not when a specially made storage image is attached to the system.

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

What it actually does

Out-of-bounds read in ubifs_sb_verify_signature caused by sign error in length check (addition instead of subtraction of UBIFS_SIG_NODE_SZ) that passes an inflated payload length to verify_pkcs7_signature and asn1_ber_decoder, allowing reads past the end of the vmalloc'd c->sbuf buffer when a crafted UBIFS image supplies the node length.

Why it matters to the business

Systems using UBIFS may experience memory disclosure or crashes when mounting attacker-supplied filesystem images; the flaw is reachable before cryptographic signature verification and affects any kernel exposing UBIFS mounts to untrusted media.

How an attack unfolds

An attacker creates a UBIFS image containing a superblock node whose ubifs_sig_node->len field is larger than the actual node size. When the image is mounted, ubifs_read_superblock invokes ubifs_sb_verify_signature which performs the faulty bounds check, supplies the oversized length to pkcs7_parse_message, and triggers the out-of-bounds read inside the BER decoder.

How to fix it

Apply the upstream kernel patch that changes the length check from addition to subtraction of sizeof(struct ubifs_sig_node) and rebuild the kernel; until then, restrict mounting of UBIFS volumes to trusted sources only.

How to confirm the fix worked

Inspect the UBIFS source for the corrected comparison using subtraction; confirm that snod->len - sizeof(struct ubifs_sig_node) is used to bound the signature payload before calling verify_pkcs7_signature; test by attempting to mount a crafted image that previously triggered the overflow.

Typical attack path

  1. Create a UBIFS filesystem image with a superblock signature node declaring an oversized len field
  2. Supply the image to a target system (e.g., via USB, network share, or container)
  3. Trigger mount of the image, causing ubifs_read_superblock to execute
  4. Faulty length check accepts the inflated value and passes it to verify_pkcs7_signature
  5. asn1_ber_decoder performs out-of-bounds memory reads while parsing DER headers

How to detect it

Search kernel logs and audit trails for UBIFS mount attempts on untrusted devices; look for oops or panic messages referencing ubifs_sb_verify_signature, verify_pkcs7_signature, or asn1_ber_decoder; correlate with unexpected filesystem mounts preceding crashes or anomalous memory access reports.

What your security team should do

  • Prioritize kernel updates containing the UBIFS signature length fix
  • Enforce policies that prevent mounting UBIFS images from untrusted origins
  • Review and harden default mount options for removable media and container storage
  • Monitor kernel update channels for the corrected UBIFS code

The record

In the Linux kernel, the following vulnerability has been resolved: ubifs: fix out-of-bounds read in signature length check ubifs_sb_verify_signature() bounds the on-disk ubifs_sig_node->len field before handing the signature payload to verify_pkcs7_signature(), but the check has the wrong sign: if (le32_to_cpu(signode->len) > snod->len + sizeof(struct ubifs_sig_node)) The signature bytes start sizeof(struct ubifs_sig_node) (UBIFS_SIG_NODE_SZ, 64 bytes) into the node, so the payload is at most snod->len - sizeof(struct ubifs_sig_node) bytes long. Adding the header size instead of subtracting it accepts a declared length up to 2 * UBIFS_SIG_NODE_SZ larger than the node actually holds -- past the end of c->sbuf, which is vmalloc(c->leb_size). verify_pkcs7_signature() -> pkcs7_parse_message() -> asn1_ber_decoder() is then handed that inflated length and reads beyond the allocation while walking the DER headers. The node length comes straight from the mounted image, so a crafted signed UBIFS image reaches this via ubifs_read_superblock() before the signature is cryptographically checked. snod->len is guaranteed to be >= UBIFS_SIG_NODE_SZ by the node scanner (c->ranges[UBIFS_SIG_NODE].min_len == UBIFS_SIG_NODE_SZ), so the corrected subtraction cannot underflow. Legitimately signed images are unaffected: a correct superblock never declares a signature longer than the node it is embedded in.

Affected packages

Ecosystem Package Introduced Fixed