Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver crafted compressed Theta sketch to deserializer
-
DeliveryForge header length fields with 32-bit overflow
-
ExploitDefeat input-length check in deserialize()/wrap()
-
ExecutionTrigger out-of-bounds read past buffer
-
ImpactCrash process or leak adjacent memory into sketch
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK
1 technique across 1 tactic: Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The host application must call compact_theta_sketch::deserialize() or wrapped_compact_theta_sketch::wrap() (including the stream-based deserialization path) on Theta sketch data originating from an untrusted source - this is the explicit gating condition stated in the advisory and is NOT a default or common deployment pattern. The most severe over-read is reachable via the COMPRESSED compact Theta format, where a 32-bit integer overflow defeats the length check and two unvalidated header fields control decoding. Limiting factors: applications that only deserialize sketches from trusted/internal sources are unaffected; impact is bounded to a crash and disclosure of memory adjacent to the input buffer (no integrity impact); and affected versions are 3.1.0 through 5.2.0 of the C++ library only. |
| Impact | Signals conflict and point to a LOWER real-world priority than the raw 9.1 CVSS suggests. The input CVSS:3.1 vector (AV:N/AC:L/PR:N/UI:N/C:H/A:H) yields Critical, but the Apache release notes explicitly rate CVE-2026-103635 as 'low' severity - the sharpest discrepancy in the data. The vulnerability is purely an out-of-bounds READ (CWE-125), so the I:N in the vector is consistent, but C:H and A:H appear overstated: the description characterizes the impact as a crash (DoS) and possible exposure of ADJACENT memory, which is typically limited disclosure rather than full confidentiality loss. EPSS corroborates the low-priority read: 0.20% probability at the 9th percentile, indicating very low likelihood of near-term exploitation. The CVE is NOT in CISA KEV and no public exploit code was identified, so exploitation status is 'no public exploit identified at time of analysis.' Crucially, exploitation is gated on a non-default application behavior - the host application must deserialize Theta sketches from untrusted sources - which most deployments do not do. Net assessment: this is a high-CVSS-but-low-real-risk issue for the majority of users; it becomes a genuine concern only for the narrow set of applications that ingest attacker-controlled sketch images. The 9.1 should be treated with skepticism and the vendor's 'low' rating as the more credible impact signal. |
| Exploit ScenarioDerived | An application embeds datasketches-cpp and accepts serialized Theta sketch blobs from untrusted clients (e.g., over an API or message queue). An attacker submits a crafted or truncated compact/compressed Theta sketch whose header length fields are manipulated - including a 32-bit integer overflow that defeats the size check - causing the deserializer to read past the end of the buffer, crashing the process or incorporating adjacent heap memory into the resulting sketch. No public exploit code is known; exploitation requires the victim application to deserialize sketches from untrusted input. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Oct 16, 2026
Out-of-bounds read in Apache DataSketches C++ versions 3.1.0 through 5.2.0 is reachable when an application deserializes a compact Theta sketch from an untrusted source, allowing unauthenticated remote attackers to crash the process (denial of service) and potentially disclose adjacent memory contents. The flaw sits in compact_theta_sketch::deserialize() and wrapped_compact_theta_sketch::wrap(), which parse header fields before verifying the input length; in the compressed format a 32-bit integer overflow defeats the length check and two decoding-controlling header fields go unvalidated, and the stream-based deserialization path is affected as well. Apache rates this issue low severity in its 5.3.0 release notes, no public exploit code has been identified at time of analysis, the vulnerability is not in CISA KEV, and EPSS is only 0.20% (9th percentile); exploitation requires the explicit, non-default precondition that the host application accept Theta sketch images from untrusted sources, so the practical priority is lower than the raw 9.1 CVSS might suggest.
Earlier versions of this analysis (1)
An out-of-bounds read in Apache DataSketches C++ 3.1.0 through 5.2.0 allows remote, unauthenticated attackers to read past the end of a malformed or truncated compact Theta sketch image, potentially disclosing adjacent memory or crashing the process. Only applications that call compact_theta_sketch::deserialize(), wrapped_compact_theta_sketch::wrap(), or the equivalent stream-based deserialization on sketch data from untrusted sources are exposed; DataSketches is an embedded library with no network listener of its own, and applications that only handle internally generated sketches are unaffected. The upstream advisory rates the issue low, CVSS is assessed as CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:L (high attack complexity, limited confidentiality and availability impact), and no public exploit code has been identified at time of analysis.
RemediationAI
Vendor-released patch: upgrade Apache DataSketches C++ to 5.3.0, which fixes this issue along with four related deserialization flaws (CVE-2026-103501, CVE-2026-103513, CVE-2026-103634, CVE-2026-103636); see https://lists.apache.org/thread/15b86y9jstco39kzppjw7l5kvhjvwqvv and the release at https://github.com/apache/datasketches-cpp/releases/tag/5.3.0, and note that the release notes state there are no intentional breaking API changes, so the upgrade is generally low-risk for callers. Where upgrading is not immediately possible, the decisive control is architectural: ensure compact_theta_sketch::deserialize(), wrapped_compact_theta_sketch::wrap(), and the stream-based deserialization path are never invoked on data originating outside a trusted boundary - reject or re-serialize untrusted sketch images at the application edge, and restrict sketch-image ingestion endpoints to authenticated internal peers, accepting the trade-off that this breaks any legitimate cross-language or cross-tenant sketch exchange. Additionally, enforce a hard maximum input length and reject any image whose declared header length exceeds the actual buffer size before handing it to the library (this mitigates truncated images but cannot compensate for the 32-bit overflow in the compressed format, so it is a partial control only), and run the deserialization step in an isolated, resource-capped worker process so a successful over-read yields at most a contained crash rather than disclosure of host memory - at the cost of added process-management complexity and some latency. Because the over-read can surface adjacent heap bytes to the attacker, treat any host that has already parsed untrusted sketches as potentially having leaked process memory and plan for credential rotation and memory-content review alongside the upgrade. No vendor-released patch exists for 3.1.0-5.2.0; only 5.3.0 carries the fix.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Apache DataSketches is a library family for streaming approximate analytics, and the Theta sketch is its core distinct-counting data structure; the C++ implementation (datasketches-cpp) interoperates byte-for-byte with datasketches-java and other language ports by exchanging serialized sketch images. This CVE is a classic CWE-125 out-of-bounds read in the deserialization layer: compact_theta_sketch::deserialize() and wrapped_compact_theta_sketch::wrap() read the fixed header before confirming the buffer is at least as long as the header claims, so a truncated or crafted image causes reads past the end of the input. The compressed compact Theta encoding is the worst case - its length validation relies on 32-bit arithmetic that can be overflowed, and two header fields that govern subsequent decoding are not validated at all, so the over-read can be substantial and the bytes read can be folded into the resulting sketch object rather than merely inspected. The same weaknesses apply to deserialization from a stream, extending the attack surface beyond in-memory buffers. CPE data (cpe:2.3:a:apache_software_foundation:apache_datasketches:*:*:*:*:*:*:*:*) confirms the affected artefact is the Apache DataSketches package, and the 5.3.0 release notes show this was one of five deserialization CVEs fixed together (CVE-2026-103501 HLL heap buffer overflow, CVE-2026-103513 CPC out-of-bounds read/write, CVE-2026-103634 Count-Min out-of-bounds read/write, CVE-2026-103635 Theta out-of-bounds read, CVE-2026-103636 VarOpt union out-of-bounds read), delivered via pull requests #503, #536 and #538 - meaning anyone pasting sketch images from outside their trust boundary should review the whole batch of advisories, not just this one.
Know when Apache Datasketches 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
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:H
AV:N/PR:N/UI:N because untrusted serialized input typically arrives over the network with no auth; out-of-bounds read yields only limited adjacent-memory disclosure (C:L) and a process crash (A:H), with no integrity impact (I:N).
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
Lifecycle Timeline
1DescriptionCVE.org
Out-of-bounds read in the compact Theta sketch deserialization of Apache DataSketches C++ (repo: datasketches-cpp).
compact_theta_sketch::deserialize() and wrapped_compact_theta_sketch::wrap() read header fields before checking that the input was long enough. For the compressed format, the size check could be defeated by a 32-bit overflow, and two header fields that control decoding were not validated; this also affected deserialization from a stream. A crafted or truncated sketch could cause a read past the end of the input. In the compressed case the over-read can be large, and the bytes read can become part of the deserialized sketch. This can cause a crash (denial of service) and could expose adjacent memory contents.
This issue affects Apache DataSketches C++: from 3.1.0 before 5.3.0. Only applications that deserialize Theta sketches from untrusted sources are affected.
Users are recommended to upgrade to version 5.3.0, which fixes this issue.
Executive ViewAI
Apache DataSketches C++ versions 3.1.0 through 5.2.0 contain a critical out-of-bounds read that can crash services and potentially expose adjacent memory when applications deserialize Theta sketches from untrusted sources. The exposure is limited to deployments that accept untrusted sketch images, a non-default configuration, and there is no public exploit identified at time of analysis or confirmed active exploitation, with no vendor-released patch identified. Leadership should prioritize identifying affected services and restricting untrusted sketch ingestion while monitoring Apache's 5.3.0 release notes for remediation guidance.
No vendor-released patch identified at time of analysis. Avoid deserializing Theta sketches from untrusted sources; require authentication and integrity validation for sketch inputs; enforce strict input size limits and pre-parse length/header validation; run deserialization in isolated, least-privilege processes or sandboxes; monitor for crashes and anomalous memory access; restrict affected Apache DataSketches C++ 3.1.0 through 5.2.0 services to trusted network segments.
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
SSVC AssessmentENISA
Priority Score
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.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
More in Apache Datasketches
View allHeap buffer overflow in Apache DataSketches C++ (versions 1.0.0-incubating through 5.2.0) allows an unauthenticated remo
Out-of-bounds read and write in the CPC sketch deserialization path of Apache DataSketches C++ (datasketches-cpp) - spec
Out-of-bounds read in Apache DataSketches C++ (datasketches-cpp) allows an attacker who controls a serialized VarOpt uni
EUVD-2026-96308
GHSA-hh2m-8j82-33gp
NVD
CVE.org
EPSS
Exploit-DB