Skip to main content

jackson-dataformat-protobuf EUVDEUVD-2026-111531

| CVE-2026-110747 HIGH
Integer Overflow or Wraparound (CWE-190)
2026-10-28 HeroDevs
7.5
CVSS 3.1 · Vendor: HeroDevs
View

Attack ChainAIDerived

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

  1. Access
    Submit 8-byte malformed protobuf map message
  2. Exploit
    Integer overflow bypasses signed buffer-length check
  3. Execution
    Oversized text-buffer allocation throws OutOfMemoryError
  4. Impact
    JVM termination or service disruption

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer overflow checks
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 application parse attacker-controlled protobuf input using an affected jackson-dataformat-protobuf release (2.21.6-2.21.7, 2.22.0-2.22.3, 3.1.6-3.1.7, or 3.2.2-3.2.3) with a schema that contains a string-keyed map (map<string, V>); the vulnerable _readStringKey() path only executes for such map entries. No special parser configuration, no databind layer, and no user interaction are needed - a single 8-byte streaming-parser message triggers it, and configured StreamReadConstraints (maxStringLength/maxNameLength/maxDocumentLength/maxNestingDepth) do not prevent the failure. Limiting factors that reduce real-world exposure: versions 2.18-2.20, 3.0, 3.1.0-3.1.5 and 3.2.0-3.2.1 do not contain _readStringKey() and are not affected; the deployed schema must use a string-keyed map; and whether the triggering message can be sent by an unauthenticated remote attacker depends on how the hosting application exposes and authenticates its parsing endpoint. Impact is amplified on JVMs run with -XX:+ExitOnOutOfMemoryError, where the error terminates the process (observed exit code 3) rather than being recoverable.

Impact

All severity signals converge on a single, well-characterized denial-of-service issue rather than a code-execution threat. The supplied CVSS 3.1 vector (7.5, AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) scores only availability impact (A:H) with no confidentiality or integrity effect, which matches the described mechanism: an integer overflow in ProtobufParser._readStringKey() that defeats the signed (_inputPtr + len) <= _inputEnd bounds check and drives an oversized TextBuffer/Arrays.copyOf allocation, producing OutOfMemoryError from an 8-byte payload. The GHSA advisory documents a complete proof of concept (exact payload 0A 06 0A FF FF FF FF 07, reproduction procedure, and confirmed runtime reproduction in 2.21.6, 2.22.3 and 3.2.3), so exploitability is well established and effectively automatable via a single reproducible message. No EPSS score was provided in the input, and the CVE is not listed in CISA KEV, so there is no public evidence of active exploitation - this is a prompt-patch issue, not an in-the-wild emergency, consistent with the vuln.today 'this_week' decision label. The real priority is driven by three multipliers rather than the raw score: StreamReadConstraints (maxStringLength/maxNameLength/maxDocumentLength/maxNestingDepth) do NOT mitigate it; the 2.x branches were left unguarded after the related CVE-2026-104016/104017 fix touched only 3.x call sites; and hosts running -XX:+ExitOnOutOfMemoryError see full JVM termination (exit code 3), not just a caught parse error. The limiting factor that keeps this below a universal crisis is that it only applies where an application parses attacker-controlled protobuf with a schema containing a map<string, V> field in an affected version range.

Exploit ScenarioDerived

An attacker sends a single 8-byte malformed protobuf message to any endpoint that deserializes attacker-controlled protobuf using an affected jackson-dataformat-protobuf version with a string-keyed map field; the declared key length of 0x7FFFFFFF overflows the bounds check and forces a near-2GB buffer allocation, throwing OutOfMemoryError. A documented proof of concept (payload and reproduction steps) exists in the vendor GHSA advisory, with runtime reproduction confirmed in 2.21.6, 2.22.3 and 3.2.3. Because AV:N/AC:L applies, the message can be delivered remotely with low complexity, and on JVMs started with -XX:+ExitOnOutOfMemoryError it kills the process outright, enabling repeatable service disruption on resubmission.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.4% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 28, 2026

Denial of service in jackson-dataformat-protobuf (2.21.6-2.21.7, 2.22.0-2.22.3, 3.1.6-3.1.7 and 3.2.2-3.2.3) lets an 8-byte malformed protobuf message force an oversized buffer allocation that ends in OutOfMemoryError, so any application that streaming-parses untrusted protobuf against a schema containing a string-keyed map (map<string, V>) is exposed. The overflow occurs in ProtobufParser._readStringKey(), where a declared key length of 0x7FFFFFFF wraps the signed bounds check and reaches TextBuffer.expandCurrentSegment(); StreamReadConstraints (maxStringLength, maxNameLength, maxDocumentLength, maxNestingDepth) do not block it, and JVMs started with -XX:+ExitOnOutOfMemoryError terminate outright (observed exit code 3). The CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H (7.5), consistent with pure availability impact and no demonstrated confidentiality or integrity effect; a working proof-of-concept payload is documented in the vendor advisory, but there is no CISA KEV listing and no confirmed active exploitation, and the vuln.today decision label places remediation in this week's queue.

RemediationAI

Upgrade to the vendor-released fix versions: 2.21.8 for the 2.21 line, 2.22.4 for the 2.22 line, 3.1.8 for 3.1.x and 3.2.4 for 3.2.x (advisory: https://github.com/FasterXML/jackson-dataformats-binary/security/advisories/GHSA-fv7v-rrmh-4qcv); because the 2.x map-key call site was reported as still unguarded in branch inspection on 2026-10-06, confirm the corrected comparison (len <= (_inputEnd - _inputPtr) with name-length validation) is present in the 2.21.8/2.22.4 jars you deploy, for example by inspecting ProtobufParser._readStringKey or rerunning the 8-byte PoC payload. No configuration-based workaround is available from the vendor: explicitly setting StreamReadConstraints maxStringLength, maxNameLength, maxDocumentLength and maxNestingDepth at values such as 1000/1000/1000/5 was reproduced as ineffective, so do not treat constraints as a stopgap. Until patched artifacts are verified in place, reduce exposure by keeping the streaming protobuf parser away from untrusted input (accept protobuf only from authenticated, trusted producers, or terminate/re-sign messages at a gateway), and note the trade-off that this changes application trust boundaries rather than fixing the parser. Review JVM flags: removing -XX:+ExitOnOutOfMemoryError turns a process-killing OOM into a recoverable one but does not prevent the allocation attempt and leaves the parser thread wedged on a large allocation, and raising heap sizing only delays the failure; either way repeated malicious submissions can still disrupt service on auto-restarting deployments. The vuln.today decision label assigns this a this_week remediation window.

Affected VersionsENISA

jackson-dataformat-protobuf 2.22.0 <2.22.4
jackson-dataformat-protobuf 3.1.6 <3.1.8
jackson-dataformat-protobuf 3.2.2 <3.2.4
jackson-dataformat-protobuf 2.21.6 <2.21.8

Affected Packages

euvd jackson_dataformat_protobuf fix: 2.21.8, 2.22.4, 3.1.8, 3.2.4

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

The flaw is CWE-190 (integer overflow) in the protobuf wire-format decoder of jackson-dataformat-protobuf, registered under CPE cpe:2.3:a:fasterxml:jackson-dataformat-protobuf. Protobuf encodes a map<string, V> entry as a length-delimited submessage whose key field carries its own length prefix; _readStringKey() reads that prefix into an attacker-controlled int and then validates availability with the signed comparison (_inputPtr + len) <= _inputEnd. With len near Integer.MAX_VALUE the addition wraps negative, the guard passes on an 8-byte message (0A 06 0A FF FF FF FF 07) that contains no key bytes at all, and control proceeds to _finishShortText(len), which eagerly grows the text buffer through TextBuffer.expandCurrentSegment and Arrays.copyOf until the VM refuses the allocation with OutOfMemoryError: Requested array size exceeds VM limit. Because the constraint checks in StreamReadConstraints are not consulted on this path, maxStringLength/maxNameLength/maxDocumentLength/maxNestingDepth provide no protection. The corrected form on the 3.x branches uses len <= (_inputEnd - _inputPtr) plus name-length validation (upstream commit a4d05bd, tied to PR #817); that commit was described as '3.x only', so the map-key call site was left unguarded on the 2.x branches even though the same pattern was remediated elsewhere for CVE-2026-104016 and CVE-2026-104017. The method is absent from 2.18-2.20, 3.0, 3.1.0-3.1.5 and 3.2.0-3.2.1 (it first appears at 2.21.6 and, mirroring that, 3.1.6 and 3.2.2), and the vulnerable path runs in the streaming parser alone, with no databind layer involved.

Know when Jackson Dataformat Protobuf 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 (HeroDevs) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

Remotely submittable 8-byte message with no privileges, config, or interaction (AV:N/AC:L/PR:N/UI:N); DoS-only OutOfMemoryError gives A:H with C:N/I:N and no scope change.

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

Primary rating from Vendor (HeroDevs).

CVSS VectorVendor: HeroDevs

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

Lifecycle Timeline

2
Patch available
Oct 28, 2026 - 01:01 EUVD
CVE Published
Oct 28, 2026 - 00:02 cve.org
HIGH 7.5

DescriptionCVE.org

ProtobufParser._readStringKey() reads the length prefix of a protobuf map entry's string key into an attacker-controlled int and then checks (_inputPtr + len) <= _inputEnd using signed arithmetic. For values near Integer.MAX_VALUE the addition overflows to a negative value and the check passes even when the input contains no key data. The parser then calls _finishShortText(len), which expands the text buffer to the declared length via TextBuffer.expandCurrentSegment and Arrays.copyOf, throwing OutOfMemoryError: Requested array size exceeds VM limit.

An 8-byte malformed message containing a map entry with a declared key length of 0x7FFFFFFF is sufficient. Configured StreamReadConstraints, including maxStringLength, maxNameLength, maxDocumentLength and maxNestingDepth, do not prevent the failure. Applications running with -XX:+ExitOnOutOfMemoryError terminate the JVM.

This is the same integer-overflow pattern addressed for other call sites in the remediation associated with CVE-2026-104016 and CVE-2026-104017; the map-key call site was corrected on the 3.x branches only, leaving the corresponding 2.x branches unguarded. Release lines 2.18, 2.19 and 2.20 do not contain _readStringKey() and are not affected by this vector. No privileges or user interaction beyond the ability to submit data for parsing are required. The 3.0 release line and 3.1.0-3.1.5 / 3.2.0-3.2.1 do not contain _readStringKey() and are therefore not affected; the method first appears in 3.1.6 and 3.2.2, mirroring its introduction at 2.21.6 on the 2.x side.

Technical POC Analysis

CWE-190 (Integer Overflow or Wraparound), exploited as a signed-arithmetic bounds-check bypass leading to attacker-controlled buffer allocation.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

A high-severity denial-of-service vulnerability in Jackson's protobuf data format module (jackson-dataformat-protobuf) allows an unauthenticated attacker to send a single 8-byte message that crashes any affected application running on a Java VM with ExitOnOutOfMemoryError enabled. This puts availability at risk for services that stream-parse untrusted protobuf data into schemas containing string-keyed maps, and the public proof-of-concept increases the likelihood of exploitation. Leadership should prioritize patching because a successful attack can cause immediate service outages.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.4%
Top 67% exploitable
Prevalence
Medium
niche Jackson binary dataformat module, far narrower than core jackson-databind
Social Media
3
Sightings
Data Quality
7 sources
Confidence: High

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 HIGH
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
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

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

Integer overflow occurs when an arithmetic operation produces a result that exceeds the maximum value a given integer type can store.

Related Vulnerabilities in jackson-dataformat-protobuf Integer Overflow Flaws

View all 2

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