Apache DataSketches
CVE-2026-103634
MEDIUM
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit crafted Count-Min sketch to deserializer
-
DeliveryOverflow 32-bit table-size calc to zero
-
ExploitAllocate empty/undersized heap table
-
ExecutionOOB read/write on later update or estimate query
-
ImpactCorrupt heap and crash or escalate
Vulnerability Assessment
| Exploitation Conditions | Exploitation requires that the target application calls count_min_sketch::deserialize() on serialized Count-Min sketch data originating from an untrusted or attacker-influenced source; the vendor explicitly states 'Only applications that deserialize Count-Min sketches from untrusted sources are affected.' The affected code path is datasketches-cpp versions 4.1.0 through 5.2.0. The over-read is triggered by a truncated sketch (missing preamble bytes), while the heap OOB read/write requires a crafted sketch whose serialized bucket count and hash-function count overflow 32-bit arithmetic to zero; the resulting corruption manifests only on subsequent update or estimate-query operations, not at deserialization time. The principal limiting factor is that deserializing sketches from untrusted input is not a default or universal usage pattern - closed pipelines that only process internally generated sketches are not exposed; versions 5.3.0 and later are not affected. |
| Impact | This is a memory-corruption flaw (out-of-bounds read and write) in Count-Min sketch deserialization in Apache DataSketches C++ (datasketches-cpp), rated moderate by the vendor. No CVSS vector, EPSS score, or CWE was supplied in any source, so quantitative exploitation-probability signals are unavailable. There is no CISA KEV listing and no public exploit code referenced, so exploitation status is 'no public exploit identified at time of analysis.' The root causes are concrete and well-described: deserialize() omits the preamble from its input-size check (up to a 16-byte over-read), and a 32-bit integer overflow in the bucket/hash-function table-size computation can wrap to zero, producing an empty table whose later updates and estimate queries read and write outside the heap allocation. Real-world risk is strongly gated by one precondition: the application must deserialize Count-Min sketches from untrusted sources - not a default behavior of most deployments. My independent CVSS 3.1 assessment (base ~7.3, High) comes out higher than the vendor's 'moderate' rating; the likely reason for the gap is that the vendor weighted the untrusted-deserialization precondition and the fact that reliable arbitrary code execution is only described as 'potentially' achievable, not demonstrated. Treat this as a genuine but conditional priority: urgent for services that ingest serialized sketches from external/untrusted parties, low-priority for closed pipelines that only process self-generated sketches. Authentication requirements cannot be confirmed because no CVSS vector was provided. |
| Exploit ScenarioDerived | An attacker supplies a crafted serialized Count-Min sketch to a service or pipeline that calls count_min_sketch::deserialize() on externally sourced data. A truncated preamble triggers a read up to 16 bytes past the input buffer, or manipulated bucket/hash-function counts overflow 32-bit arithmetic to zero, yielding an empty table whose subsequent updates and estimate queries corrupt heap memory, causing a crash and potentially enabling further exploitation. No public exploit code has been identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 10, 2026
Heap memory corruption in Apache DataSketches C++ (datasketches-cpp) versions 4.1.0 through 5.2.0 allows remote attackers to trigger out-of-bounds reads and writes via a crafted Count-Min sketch submitted to the deserialize() function. The flaw combines a missing preamble size check that permits up to 16 bytes over-read on truncated input, and a 32-bit integer overflow in the serialized bucket count that can wrap to zero, resulting in an empty table and subsequent heap memory corruption during updates or estimate queries. Exploitation requires an application to deserialize Count-Min sketches from untrusted sources; no public exploit code or active exploitation has been identified at time of analysis, and the vendor rates the severity as moderate.
RemediationAI
Upgrade to Apache DataSketches C++ version 5.3.0 or later, which includes the fix for the preamble size check and the integer overflow in table size computation. This is the only vendor-recommended remediation. If upgrading immediately is not possible, ensure that Count-Min sketches are only deserialized from trusted, internal sources; avoid accepting serialized sketches from untrusted or attacker-influenced inputs. As a compensating control, implement strict validation of serialized sketch sizes and sanity-check the bucket count and hash-function count before deserialization, rejecting values that could overflow or produce an empty table. However, such validation is not provided by the vendor and may be bypassed if not comprehensive; it also risks rejecting legitimate sketches if the limits are too tight. For detailed information, see the oss-security advisory at https://seclists.org/oss-sec/2026/q4/127 and the Apache DataSketches project page at https://datasketches.apache.org.
Affected ProductsAI
Apache DataSketches C++ (datasketches-cpp) versions 4.1.0 through 5.2.0 are affected. The vendor advisory specifies 'from 4.1.0 before 5.3.0', meaning all releases prior to 5.3.0 are vulnerable. No CPE strings were included in the CVE record, but the affected component is the Count-Min sketch deserialization routine. Applications that integrate this library and deserialize Count-Min sketches from untrusted sources are at risk. The official project page is https://datasketches.apache.org, and the oss-security advisory is available at https://seclists.org/oss-sec/2026/q4/127.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The vulnerability resides in the count_min_sketch::deserialize() function of the Apache DataSketches C++ library, which implements probabilistic streaming algorithms (sketches) for approximate frequency estimation. The root cause is a combination of an out-of-bounds read (CWE-125) due to the input size check omitting the preamble length, allowing a read of up to 16 bytes past the end of a truncated buffer, and an integer overflow (CWE-190) in the computation of the table size from the serialized bucket count and number of hash functions. When these 32-bit values multiply or wrap to zero, the deserialization creates an empty table, but subsequent update or estimate operations access memory outside the intended heap allocation, resulting in out-of-bounds write (CWE-787) and potential heap corruption. The library is designed for cross-language compatible binary representations, so the deserialization logic is a critical attack surface for applications that accept serialized sketches from external sources. No CPE data or official CWE mapping was provided in the advisory, but the described behavior aligns with these weakness classes.
Know when Java gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
Crafted sketch data can arrive over the network with no credentials or interaction (AV:N/PR:N/UI:N), the overflow is deterministic (AC:L), and the 16-byte over-read plus heap corruption give limited C/I and crash-level A.
Description PRE-NVD
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
Attack Technique
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.
Oracle Java SE 7 Update 6 and earlier contains multiple sandbox bypass vulnerabilities via the ClassFinder and forName m
Remote code execution in IBM Sterling B2B Integrator, Sterling Integrator, and Tivoli Common Reporting allows unauthenti
Java Runtime Environment sandbox bypass via incorrect image channel verification in 2D component allows remote unauthent
Oracle Java SE JDK/JRE 7 and 6 Update 27 and earlier allows remote code execution with complete system compromise throug
JBoss Seam 2 in Red Hat JBoss EAP 4.3.0 fails to sanitize JBoss Expression Language inputs, allowing remote attackers to
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 update 4 and earlier, 6 up
Multiple vulnerabilities in Oracle Java 7 before Update 11 allow remote attackers to execute arbitrary code by (1) using
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 2 and earlier, 6 Up
The WLS Security component in Oracle WebLogic Server 10.3.6.0, 12.1.2.0, 12.1.3.0, and 12.2.1.0 allows remote attackers
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 7 and earlier allow
Remote unauthenticated attackers can execute arbitrary code on Adobe ColdFusion servers through Java deserialization fla
The ExceptionDelegator component in Apache Struts before 2.2.3.1 interprets parameter values as OGNL expressions during
CVE.org
GitHub PoC
Exploit-DB