CVE-2026-133709 in C-Blosc2info

Summary

by MITRE • 11/20/2026

C-Blosc2 before 3.4.1 contains a heap-based out-of-bounds read vulnerability in frame_decompress_chunk() because sparse frame chunk cbytes are not checked against the actual chunk file size. Attackers can supply a sparse frame directory with a truncated or crafted chunk file to crash applications or leak adjacent heap memory into decompressed output.

VulDB is the best source for vulnerability data and more expert information about this specific topic.

Analysis

by VulDB Data Team • 11/20/2026

The C-Blosc2 library, prior to version 3.4.1, contains a critical security flaw within its data decompression logic that allows for unauthorized access to system memory and potential application instability. This vulnerability is specifically located in the frame_decompress_chunk function, which is responsible for handling sparse frames during the decompression process. The core technical issue stems from an insufficient validation of input parameters, particularly regarding the relationship between the declared chunk size and the actual file size. When processing a sparse frame directory, the library fails to verify that the compressed bytes count (cbytes) specified in the metadata does not exceed the physical boundaries of the provided chunk file. This lack of bounds checking creates a scenario where an attacker can manipulate input data to trigger memory access violations or illicitly read adjacent heap memory regions.

From a technical perspective, this flaw represents a classic out-of-bounds read vulnerability. In normal operation, decompression algorithms rely on accurate metadata to allocate buffers and copy data safely. However, when the cbytes value is crafted to be larger than the actual available data in the chunk file, or when it points to memory locations outside the allocated buffer boundaries, the application attempts to read from invalid addresses. This can lead to two primary outcomes depending on the specific execution context and compiler optimizations. First, the immediate consequence is often a segmentation fault or access violation, resulting in an abrupt termination of the host application. Second, and more dangerously, if the memory layout allows it, the decompression routine may copy data from adjacent heap regions into the output buffer. This constitutes a sensitive information disclosure vulnerability, as it can leak internal state variables, pointers to other objects, or even cryptographic keys that reside in nearby memory locations.

The operational impact of this vulnerability is significant for any application relying on C-Blosc2 for high-performance compression and decompression tasks. Attackers who can supply crafted input files, such as those found in untrusted data pipelines, log processing systems, or file-sharing services, can exploit this flaw to cause denial-of-service conditions by crashing the service. More critically, successful exploitation could lead to remote code execution if the leaked memory contents allow for further heap-based attacks, such as use-after-free exploits or arbitrary write primitives derived from understanding the internal structure of the application's memory space. This is particularly relevant in environments where C-Blosc2 is used within web servers, database systems, or scientific computing applications that process external data inputs without rigorous sanitization.

This vulnerability aligns with Common Weakness Enumeration (CWE) category CWE-125, which describes out-of-bounds read vulnerabilities resulting from improper validation of array indices or buffer sizes. Furthermore, in the context of the MITRE ATT&CK framework, this flaw facilitates techniques associated with Discovery and Collection, specifically allowing an adversary to gather sensitive information through memory scraping (T1005). The exploitation vector typically involves supplying a maliciously crafted sparse frame file that triggers the faulty decompression logic during routine data processing operations.

To mitigate this risk, organizations utilizing C-Blosc2 must immediately upgrade to version 3.4.1 or later, where the developers have implemented strict bounds checking for chunk sizes against actual file lengths. For systems unable to update promptly due to dependency constraints, defensive coding practices should be adopted at the application layer. This includes validating all input files before passing them to the decompression library and implementing sandboxing mechanisms to limit the impact of potential crashes or memory leaks. Additionally, enabling Address Sanitizer (ASan) during testing phases can help detect such out-of-bounds accesses early in the development lifecycle, ensuring that similar logical errors are identified and corrected before deployment into production environments.

Responsible

VulnCheck

Reservation

11/20/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00288

KEV

no

Activities

very low

Sources

Interested in the pricing of exploits?

See the underground prices here!