CVE-2026-103635

Executive Summary

CVE-2026-103635 is an out-of-bounds read vulnerability (CWE-125) in the compact Theta sketch deserialization routines of Apache DataSketches C++ (datasketches-cpp). The functions compact_theta_sketch::deserialize() and wrapped_compact_theta_sketch::wrap() read header fields before validating that the input buffer was long enough, and in the compressed format the size check could be defeated by a 32-bit integer overflow while two decoding-controlling header fields went unvalidated. Applications that deserialize Theta sketches from untrusted sources running versions from 3.1.0 before 5.3.0 are affected; successful exploitation can cause a crash (denial of service) and could expose adjacent memory contents, including making over-read bytes part of the deserialized sketch.

Technical Analysis

Apache DataSketches is a library of stochastic streaming algorithms used to summarize large data streams; the Theta sketch family estimates distinct counts (cardinality) and supports set operations. The C++ implementation (datasketches-cpp) serializes sketches to a binary format that is later deserialized by consumers — often across trust boundaries such as query services, ingestion pipelines, or data interchange endpoints that accept sketches from external clients.

The vulnerability resides in the compact Theta sketch deserialization path. According to the NVD description, two entry points are affected:

• compact_theta_sketch::deserialize()
• wrapped_compact_theta_sketch::wrap()

The defect is an out-of-bounds read (CWE-125) with two distinct contributing mechanism classes:

1. Order-of-operations flaw (header parsing before length validation). The affected functions "read header fields before checking that the input was long enough." This means an attacker-supplied buffer shorter than the minimum expected header is parsed as if it were well-formed, causing the parser to read bytes past the end of the allocated input.

2. Integer-overflow-defeated size check (compressed format). In the compressed serialization format, "the size check could be defeated by a 32-bit overflow." A maliciously chosen size value in the serialized sketch can wraparound a 32-bit computation so that a bounds check passes while the actual read region extends beyond the buffer.

3. Missing header-field validation. "Two header fields that control decoding were not validated." Because these fields influence how subsequent bytes are interpreted, an attacker can steer the decoder into reading beyond the buffer boundary. The advisory notes this vector "also affected deserialization from a stream."

The attack surface is any code path that accepts serialized Theta sketches from an untrusted or semi-trusted origin: network-facing ingestion APIs, RPC handlers, deserialization microservices, log/telemetry processors, and data-exchange endpoints. The flaw is reachable pre-authentication where sketches are accepted without prior trust checks, since no privilege is required beyond the ability to submit a serialized sketch.

Impact characteristics per the advisory: 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 is significant because it means out-of-bounds bytes are not merely touched (which would yield only a crash) but may be incorporated into the resulting sketch object — a potential information-disclosure primitive where adjacent heap/process memory is reflected back through the deserialized sketch's state or outputs. The primary reliable consequence is a crash (denial of service).

Affected range: Apache DataSketches C++ from 3.1.0 before 5.3.0. Only applications that deserialize Theta sketches from untrusted sources are affected. No CVSS base score or vector was published by the CNA/NVD (score N/A); the vector shown in METADATA is an analyst-derived estimate consistent with the described confidentiality and availability impact and should be treated as provisional. EPSS is not yet scored; no public PoC, exploit code, or Nuclei template is known; CISA KEV does not list this CVE. Patch confidence is 0/4 — no patch evidence was recovered from tracked sources, though the advisory recommends upgrading to 5.3.0 as the fix.

Exploitation Scenarios

No public PoC is available; the attack chain below is inferred from the vulnerability class (out-of-bounds read during binary deserialization) and the specific mechanisms named in the advisory.

1. Reconnaissance / target identification. The attacker identifies a service or application that deserializes Theta sketches from an external source. Candidate targets are Apache DataSketches C++-based services exposing sketch ingestion or query interfaces, or any pipeline component (message consumer, RPC handler) that accepts serialized sketches from clients. Fingerprinting focuses on endpoints or protocols that transmit compact Theta sketch payloads.

2. Triggering the flaw class. The attacker crafts a malicious serialized compact Theta sketch. Two construction approaches follow directly from the advisory:

   • Truncation: Supply a buffer shorter than the header length so that deserialize() / wrap() read header fields past the end of the input (the length check occurs too late).
   • 32-bit overflow in the compressed format: Encode a size value that wraps a 32-bit computation so the internal size check is bypassed, allowing a large over-read beyond the actual buffer. Fields that control decoding are left in states the parser does not validate, steering reads past the boundary. The same class of input can be delivered via a stream (stream deserialization is also affected).

3. Payload / delivery. The crafted or truncated sketch is submitted through whatever channel the target uses to accept sketches — an ingestion API, a serialized message, or a stream. Because this is a parsing flaw, no authentication is necessarily required to reach the vulnerable code path where sketches are accepted from untrusted sources.

4. Post-exploitation impact. A read past the end of the input causes either an immediate crash (denial of service) or, notably in the compressed case, the over-read bytes "become part of the deserialized sketch." Where the application returns or stores sketch state/outputs, an attacker could potentially observe adjacent memory contents reflected through the deserialized object — an information-disclosure effect against process memory. The reliable, demonstrable outcome is a crash; the disclosure outcome depends on how the application handles and exposes the resulting sketch.

Impact Assessment

The vulnerability is an out-of-bounds read during deserialization of untrusted input. Key impact dimensions:

• Availability (denial of service): The advisory explicitly states a crash can result. For a service that deserializes sketches on a request path, a single crafted payload can crash the process, enabling repeated denial of service against the affected endpoint. This is the most reliable impact.
• Confidentiality: In the compressed format, the over-read can be large and the read bytes can become part of the deserialized sketch, creating a potential memory-disclosure path to adjacent in-process data. The severity of disclosure depends on whether the application returns, logs, or otherwise exposes the deserialized sketch.
• Blast radius: Only applications that deserialize Theta sketches from untrusted sources are affected. Systems that keep all sketch deserialization within a trusted boundary are not exposed. The affected version range spans 3.1.0 up to (but not including) 5.3.0, so any deployment on an affected release with an untrusted-input path is at risk. Because DataSketches is a library, discovery requires identifying dependent applications rather than scanning for the library itself.
• Scoring note: No CVSS base score or vector was published (N/A). The provisional CVSS vector in METADATA (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:H) is an analyst estimate reflecting network reachability of deserialization services, no required privileges, high availability impact (crash), and potential high confidentiality impact from memory over-read; it is not authoritative and may change.
• Exploitability signals: EPSS not yet scored; no public PoC, exploit code, or Nuclei template; not listed in CISA KEV. Exploitation currently requires bespoke payload crafting, which slightly tempers near-term risk, but the mechanism is well understood.

Detection Guidance

No public exploit exists, so the detections below target the vulnerability class: malformed, truncated, or anomalously sized compact Theta sketch payloads and the crashes/over-reads they induce. Tune thresholds and byte-size bounds to your deployment.

Sigma Rule

title: Apache DataSketches C++ Theta Sketch Deserialization Anomaly (CVE-2026-103635)
id: 9f3c1a72-5b4e-4d0a-8c21-7c1e2d4b6a10
status: experimental
description: Detects process crashes or errors in Apache DataSketches C++ applications deserializing Theta sketches, consistent with out-of-bounds read (CWE-125) exploitation.
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-103635
author: valtersit.com
date: 2026/01/01
logsource:
  category: application
  product: datasketches
detection:
  keywords:
    - "compact_theta_sketch"
    - "wrapped_compact_theta_sketch"
    - "deserialize"
    - "out of bounds"
    - "buffer overflow"
  crash_keywords:
    - "SIGSEGV"
    - "Segmentation fault"
    - "std::bad_alloc"
    - "read past end"
  condition: keywords and crash_keywords
falsepositives:
  - Legitimate malformed input rejected gracefully
  - Application loading corrupted but trusted sketch files
level: medium

YARA Rule

rule CVE_2026_103635_Datasketches_Theta_Deserialization
{
    meta:
        author = "valtersit.com"
        description = "Detects DataSketches C++ Theta sketch deserialization symbols suggesting the affected code paths for CVE-2026-103635"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-103635"
        date = "2026-01-01"

    strings:
        $sym1 = "compact_theta_sketch" ascii
        $sym2 = "wrapped_compact_theta_sketch" ascii
        $sym3 = "deserialize" ascii
        $sym4 = "DataSketches" ascii
        $theta = "theta_sketch" ascii

    condition:
        uint32(0) == 0x464C457F and
        filesize < 50MB and
        ($sym1 or $sym2) and $sym3 and ($sym4 or $theta)
}

Suricata IDS Rule

alert http any any -> any any (msg:"CVE-2026-103635 Apache DataSketches C++ Theta Sketch Deserialization Attempt"; flow:established,to_server; content:"theta"; http_client_body; nocase; content:"sketch"; http_client_body; nocase; pcre:"/(?i)compact_theta|wrapped_compact_theta/Ui"; threshold:type both, track by_src, count 10, seconds 60; classtype:attempted-dos; reference:cve,2026-103635; reference:url,nvd.nist.gov/vuln/detail/CVE-2026-103635; sid:2026103635; rev:1;)

Elastic Detection

sequence by process.entity_id with maxspan=30s
  [ process where process.name != null and
      process.args != null and
      wildcard(process.args, "*theta*sketch*") ]
  [ process where event.action == "end" and
      (process.exit_code != 0 or wildcard(process.args, "*SIGSEGV*")) ]

Splunk SPL Query

index=app_logs sourcetype=datasketches OR sourcetype=application
( "compact_theta_sketch" OR "wrapped_compact_theta_sketch" OR "deserialize" OR "theta sketch" )
( "SIGSEGV" OR "Segmentation fault" OR "out of bounds" OR "read past end" OR "bad_alloc" )
| stats count min(_time) as first_seen max(_time) as last_seen by host, process, src_ip
| where count >= 3
| convert ctime(first_seen) ctime(last_seen)

Wazuh OSSEC Rule

<group name="datasketches,cve-2026-103635,">
  <rule id="100635" level="10">
    <decoded_as>json</decoded_as>
    <field name="message">compact_theta_sketch|wrapped_compact_theta_sketch</field>
    <field name="message">deserialize</field>
    <description>CVE-2026-103635: Apache DataSketches C++ Theta sketch deserialization OOB read attempt detected</description>
    <mitre>
      <id>T1190</id>
    </mitre>
  </rule>
  <rule id="100636" level="12">
    <decoded_as>json</decoded_as>
    <field name="message">SIGSEGV|Segmentation fault|read past end</field>
    <description>CVE-2026-103635: Possible crash from malicious Theta sketch deserialization</description>
    <mitre>
      <id>T1499</id>
    </mitre>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 (UNPATCHED — no patch evidence from any tracked source). The advisory recommends upgrading to version 5.3.0, which fixes the issue.

1. Immediate mitigations

   • Do not accept serialized Theta sketches from untrusted sources on affected versions. Enforce a strict trust boundary: validate the origin/authenticity of any sketch payload before deserialization.
   • Where untrusted sketches must be processed, isolate deserialization in a separate, resource-limited process or sandbox so an out-of-bounds read or crash (denial of service) does not affect the primary service, and so any memory-over-read disclosure is contained.
   • Enforce strict input length checks and reject buffers shorter than the minimum expected header at the application layer, ahead of the library call, as a defense-in-depth measure against the truncated-input and 32-bit-overflow cases.
   • Apply process supervision/auto-restart to reduce availability impact from crash-based denial of service.

2. Patch / upgrade steps

   • Upgrade Apache DataSketches C++ to version 5.3.0, which fixes this issue, per the advisory.
   • Inventory all applications and services that statically or dynamically link datasketches-cpp and confirm each is rebuilt against 5.3.0 or later; the affected range is 3.1.0 before 5.3.0.
   • Re-test any code paths that call compact_theta_sketch::deserialize() and wrapped_compact_theta_sketch::wrap(), including stream-based deserialization, after upgrading.

3. Long-term hardening

   • Treat all serialized binary formats as untrusted input: adopt length-prefixed, bounds-checked parsing and validate all header fields that influence decoding before use.
   • Use 64-bit or overflow-safe arithmetic in size/bounds computations to eliminate integer-overflow-defeated checks (this CVE's compressed-format vector).
   • Add fuzz testing (e.g., libFuzzer/AFL) for sketch deserialization entry points and integrate memory-safety tooling (ASan/UBSan) into CI.
   • Monitor the Apache DataSketches project for the official 5.3.0 release notes and any assigned CVE advisory, and track EPSS/CISA KEV status for exploitation signals.

References

• NVD — CVE-2026-103635: https://nvd.nist.gov/vuln/detail/CVE-2026-103635
• Apache DataSketches project: https://datasketches.apache.org/
• Apache DataSketches C++ (datasketches-cpp) repository: referenced in advisory as "repo: datasketches-cpp"
• CWE-125 — Out-of-bounds Read: https://cwe.mitre.org/data/definitions/125.html
• MITRE ATT&CK T1190 — Exploit Public-Facing Application: https://attack.mitre.org/techniques/T1190/

No threat actor campaigns or exploit-in-the-wild evidence have been identified for CVE-2026-103635. The CVE is not listed in CISA KEV, EPSS is not yet scored by FIRST.org, and no public PoC or exploit code is known at the time of writing.