CVE-2026-64467
Received Received - Intake

Binder Reference Count Underflow in Linux Kernel

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

Publication date: 2026-07-25

Last updated on: 2026-07-27

Assigner: kernel.org

Description

In the Linux kernel, the following vulnerability has been resolved: rust_binder: use a u64 stride when cleaning up the offsets array Allocation's Drop walks the offsets array (binder_size_t = u64 entries), cleaning up the objects, but it used usize instead of u64 for both the stride and the per-entry read. On 64-bit kernels (usize == u64) this is harmless, but on 32-bit kernels it walks the 8-byte entries in 4-byte steps, iterating an N-entry array 2N times, and reads the always-zero high word as offset 0, cleaning up the object at offset 0 N extra times. As a result the referenced node or handle ends up with a lower reference count than it actually has (a refcount over-decrement), and binder's reference accounting is corrupted; for example, the owner can be notified of a strong reference release (BR_RELEASE) even though references still remain. Change the stride to u64, and read each entry as a u64, narrowing it to usize with try_into(). On 32-bit ARM, when this over-decrement would drive a count below zero, the driver's existing refcount guard refuses it and fires: rust_binder: Failure: refcount underflow!

CVSS Scores

EPSS Scores

Probability:
Percentile:

Meta Information

Published
2026-07-25
Last Modified
2026-07-27
Generated
2026-08-14
AI Q&A
2026-07-25
EPSS Evaluated
2026-08-13
NVD
EUVD

Affected Vendors & Products

Showing 1 associated CPE
Vendor Product Version / Range
linux linux_kernel to 416baaa9-dc9f-4396-8d5f-8c081fb06d67 (inc)

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 vulnerability is in the Linux kernel's rust_binder module. It involves incorrect cleanup of an offsets array during memory deallocation. On 32-bit systems, the cleanup code uses a 4-byte stride instead of the correct 8-byte stride for 64-bit entries, causing it to process the array twice and incorrectly decrement reference counts. This leads to corrupted reference accounting in the binder driver.

Detection Guidance

This vulnerability is specific to the Linux kernel's rust_binder implementation and primarily affects 32-bit systems. Detection requires checking kernel logs for the error message 'rust_binder: Failure: refcount underflow!' which indicates the vulnerability has been triggered.

Impact Analysis

On 32-bit systems, this flaw can cause reference count corruption in the binder driver. This may result in premature release notifications (BR_RELEASE) even when references still exist. In extreme cases, it can trigger a refcount underflow error on 32-bit ARM systems, potentially crashing the system or causing unexpected behavior in processes using binder IPC.

Compliance Impact

This vulnerability affects reference counting in the Linux kernel's binder driver, potentially leading to incorrect object cleanup. While it does not directly impact GDPR or HIPAA compliance, it could indirectly affect systems handling sensitive data by causing instability or crashes due to corrupted reference counts.

Mitigation Strategies

Apply the kernel patch that changes the stride to u64 and reads each entry as a u64. For 32-bit systems, upgrading to a patched kernel version is critical to prevent refcount corruption and potential system instability.

Chat Assistant

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

EPSS Chart