Skip to main content

DataSketches C++ CVE-2026-103501

| EUVDEUVD-2026-96306 CRITICAL
Heap-based Buffer Overflow (CWE-122)
2026-10-10 apache GHSA-w656-xfm5-jqjh
9.8
CVSS 3.1 · Vendor: apache
View

Attack ChainAIDerived

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

  1. Access
    Deliver crafted HLL sketch to application
  2. Delivery
    App deserializes sketch in LIST mode
  3. Exploit
    Oversized coupon count copied into 8-entry buffer
  4. Execution
    Heap write up to 988 bytes out of bounds
  5. Impact
    Heap corruption, crash or potential code execution

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Heap buffer bounds checking
MITRE ATT&CK

1 technique across 1 tactic: Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires that the target application invoke Apache DataSketches C++ HLL sketch deserialization (from a byte buffer or stream) on data from an untrusted source, and specifically that an attacker-controlled sketch be in LIST mode with a coupon count larger than the fixed 8-entry buffer. The key limiting factor is application design: the vulnerable code is a library routine with NO inherent network listener, so deployments that only deserialize internally generated or trusted sketches are not realistically exposed despite the AV:N vector. No authentication or user interaction is required at the library level (PR:N/UI:N), and the default code path performs no capacity check, so no non-default configuration is needed to trigger the bug once untrusted input reaches the parser. Affected versions 1.0.0-incubating through 5.2.0; fixed in 5.3.0.

Impact

Signals conflict and must be weighed carefully. NVD assigns CVSS 9.8 (AV:N/AC:L/PR:N/UI:N, C:H/I:H/A:H), but Apache's own release notes rate this 'moderate', and the description frames it as a library-level deserialization flaw affecting ONLY applications that deserialize HLL sketches from untrusted sources - so the AV:N/PR:N vector is only realized when a consuming application actually exposes sketch deserialization to attacker-controlled input. EPSS is low at 0.21% (11th percentile), there is no CISA KEV listing and no public exploit identified, consistent with a newly disclosed library bug rather than active or widespread exploitation. The demonstrable impact is a controlled heap write of up to 988 bytes (CWE-122) causing memory corruption and crash; the description states code execution is only 'potentially' enabled, so the full C:H/I:H claim is unproven rather than confirmed. Net: this is a genuine high-severity memory-corruption bug worth patching promptly wherever the library processes untrusted input, but the headline 9.8 overstates universal real-world risk - exposure is gated on application design, exploitation beyond DoS is unproven, and the vendor's 'moderate' rating plus low EPSS argue against treating it as an emergency for deployments that only process trusted, internally generated sketches.

Exploit ScenarioDerived

An application (e.g. a data-analytics service) accepts serialized Apache DataSketches HLL sketch images from untrusted clients and deserializes them. An attacker submits a crafted LIST-mode sketch whose coupon count far exceeds the 8-entry internal buffer, writing up to 988 bytes past the heap buffer, corrupting heap memory and crashing the process - with potential for further exploitation toward code execution. No public exploit code is identified at time of analysis, and the AV:N/AC:L vector makes triggering straightforward wherever untrusted sketch input is reachable.

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

Heap buffer overflow in Apache DataSketches C++ (versions 1.0.0-incubating through 5.2.0) allows an unauthenticated remote attacker who can supply a crafted HLL sketch for deserialization to write up to 988 bytes past a fixed 8-entry internal heap buffer, corrupting memory, crashing the process, and potentially enabling further exploitation. The vulnerable code is a library routine with no network listener of its own, so real-world exposure hinges on whether the consuming application deserializes sketch images from untrusted byte buffers or streams; services that only process trusted or internally generated sketches are not realistically exposed despite the AV:N vector. No public exploit code has been identified at time of analysis, and EPSS is low at 0.21% (11th percentile), while the assessed CVSS 3.1 base of 9.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) reflects the worst case for applications that do accept untrusted sketches, meaning the high score and low observed exploitation signal must be weighed together.

Earlier versions of this analysis (1)
v1 Oct 10, 2026 - 11:22

Heap buffer overflow in the HLL sketch deserialization path of Apache DataSketches C++ (versions 1.0.0-incubating through 5.2.0, fixed in 5.3.0) lets an attacker who controls a serialized sketch image drive a write of up to 988 bytes past a fixed 8-entry internal heap buffer, corrupting heap memory and causing a crash with the potential for further exploitation. Per the authoritative assessment (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:H), the flaw is reachable by unauthenticated remote attackers, but only in deployments that deserialize HLL sketches in LIST mode from untrusted byte buffers or streams; applications that only ingest sketches from trusted internal sources are not exposed, and reliable impact beyond denial of service depends on attacker-controlled heap layout. No public exploit code and no CISA KEV listing were identified at time of analysis, and the original report carried no CVSS vector, EPSS score, or SSVC data to corroborate exploitation likelihood.

RemediationAI

Vendor-released patch: 5.3.0 - Apache DataSketches C++ users should upgrade to 5.3.0 or later, which fixes this heap overflow along with the four companion deserialization defects; the fix versions are documented in the advisory at https://lists.apache.org/thread/n2oc2j841dzsv4239jjp08of66bo79c5 and the release page at https://github.com/apache/datasketches-cpp/releases/tag/5.3.0, with code changes in pull requests #503, #536, and #538. Because the vulnerable routine is a library call with no listener of its own, the most effective compensating control while patching is architectural: stop feeding attacker-controlled sketch images into the HLL deserializer, for example by rejecting untrusted serialized sketches at the service boundary or re-deriving sketches from raw event data instead of accepting pre-built images, at the cost of losing the bandwidth savings of sketch exchange. If untrusted sketches must be parsed before the upgrade, isolate the parsing process (separate low-privilege worker, container, or sandboxed service) so that heap corruption cannot be leveraged in the host process, and validate or cap the declared coupon count and overall image length before calling the deserializer - both controls add processing overhead and, in the case of input validation, duplicate logic that the upstream fix already performs correctly. Applications that never deserialize sketches from untrusted sources are not realistically exposed and can schedule the 5.3.0 upgrade as part of routine maintenance, but should still confirm that no internal service is forwarding externally sourced sketch bytes into the parser.

Affected VersionsENISA

Apache DataSketches 1.0.0-incubating ≤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 of stochastic streaming algorithms, and the HLL (HyperLogLog) sketch is its approximate distinct-count implementation; sketches are persisted and exchanged as serialized binary images across processes, languages, and services, which makes the deserialization path an untrusted-input parser. When an HLL sketch is serialized in LIST mode, the image carries a coupon count that the deserializer reads from the input and then uses as the number of entries to copy into an internal fixed-size buffer of 8 entries; because no check compares that count against the buffer capacity, a crafted image drives a write of up to 988 bytes beyond the allocation. This is CWE-122, heap-based buffer overflow - the root-cause class for length fields trusted as copy counts - and it is reachable from both the byte-buffer and stream deserialization entry points. The CPE entry cpe:2.3:a:apache_software_foundation:apache_datasketches:*:*:*:*:*:*:*:* identifies the Apache DataSketches product family but is not granular enough to separate the C++ library from the Java implementation, and the affected code is specifically datasketches-cpp. The fix shipped in the 5.3.0 release, which explicitly hardens deserialization against malformed or truncated input and also addresses four related sketch-parsing defects: CVE-2026-103513 (CPC sketch out-of-bounds read/write), CVE-2026-103634 (Count-Min sketch out-of-bounds read/write), CVE-2026-103635 (compact Theta sketch out-of-bounds read), and CVE-2026-103636 (VarOpt union out-of-bounds read), with the underlying changes in pull requests #503, #536, and #538.

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.8 MEDIUM
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 9.8 CRITICAL

Library deserialization is reachable over the network in exposed apps (AV:N/AC:L/PR:N/UI:N); the controlled heap write yields reliable DoS (A:H) and plausibly memory corruption enabling C:H/I:H.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/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
High
Availability
High

Lifecycle Timeline

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

DescriptionCVE.org

Heap buffer overflow in the HLL sketch deserialization of Apache DataSketches C++ (repo: datasketches-cpp).

When deserializing a sketch in LIST mode, from either a byte buffer or a stream, the coupon count was read from the input and used as the number of entries to copy into a fixed buffer of 8 entries, without checking it against the buffer's capacity. A crafted sketch could cause a write of up to 988 bytes past the end of this internal heap buffer. This can corrupt heap memory, causing a crash and potentially enabling further exploitation.

This issue affects Apache DataSketches C++: from 1.0.0-incubating before 5.3.0. Only applications that deserialize HLL 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++ library versions 1.0.0-incubating through 5.2.0 are affected by a critical heap buffer overflow that unauthenticated attackers can trigger by supplying crafted HLL sketches for deserialization, causing memory corruption and potential service disruption. Organizations that use this library to process untrusted sketch inputs face the highest risk, while those handling only trusted internal data have minimal exposure. Despite the 9.8 CVSS score, no public exploit identified at time of analysis, and no vendor-released patch identified at time of analysis, so leadership should prioritize risk assessment and interim mitigations.

Business Impact: High
Compensating Controls

Disable or restrict deserialization of untrusted HLL sketches; validate input length and structure; run affected services with least privilege in isolated environments; monitor for crashes or memory anomalies.

Threat Intelligence Overview

EPSS Score
0.2%
Top 89% exploitable
Prevalence
Low
specialized C++ data-sketching library, limited production deployment footprint
Social Media
3
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
High

Priority Score

34
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +34
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.

A heap overflow occurs when a program writes data beyond the bounds of a buffer allocated in the heap memory region.

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.

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