Skip to main content

Apache DataSketches C++ CVE-2026-103635

| EUVDEUVD-2026-96308 CRITICAL
Out-of-bounds Read (CWE-125)
2026-10-10 apache GHSA-hh2m-8j82-33gp
9.1
CVSS 3.1 · Vendor: apache
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Deliver crafted compressed Theta sketch to deserializer
  2. Delivery
    Forge header length fields with 32-bit overflow
  3. Exploit
    Defeat input-length check in deserialize()/wrap()
  4. Execution
    Trigger out-of-bounds read past buffer
  5. Impact
    Crash 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.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
No patch listed yet 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv2 – 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)
v1 Oct 10, 2026 - 11:20

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

Apache DataSketches 3.1.0 ≤5.2.0

Affected Packages

euvd apache_datasketches no fix

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

Vendor (apache) PRIMARY 9.1 LOW
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:H
vuln.today AI 8.2 HIGH

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).

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (apache).

CVSS VectorVendor: apache

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
None
Availability
High

Lifecycle Timeline

1
CVSS changed
Oct 16, 2026 - 16:24 NVD
9.1 (CRITICAL)

DescriptionCVE.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

Why It Matters

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.

Business Impact: Medium
Compensating Controls

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

EPSS Score
0.2%
Top 91% exploitable
Prevalence
Low
niche C++ analytics library; the Java variant is more widely deployed
Social Media
2
Sightings
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity CRITICAL
CISA KEV No
Public POC No
EPSS 0.2%
Patch available No
Active threat No
Deciding rule
CRITICAL severity
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
Medium

Priority Score

20
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +20
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy