Skip to main content

jackson-dataformat-protobuf CVE-2026-104016

HIGH
Integer Overflow or Wraparound (CWE-190)
2026-10-28 36c7be3b-2937-45df-85ea-ca7133ea542c
7.5
CVSS 3.1 · Vendor: 36c7be3b-2937-45df-85ea-ca7133ea542c
View

Attack ChainAIDerived

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

  1. Access
    Reach endpoint parsing untrusted protobuf
  2. Delivery
    Craft 33-byte payload with oversized string-field varint
  3. Exploit
    Integer overflow bypasses bounds check
  4. Execution
    expandCurrentSegment requests huge array
  5. Impact
    OutOfMemoryError crashes service

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

The target application must accept untrusted protobuf input and parse it via jackson-dataformat-protobuf (ProtobufMapper/ProtobufParser) using a schema that contains a string or bytes field the attacker can influence - the condition is specifically a length-prefixed string/bytes field whose varint length is attacker-controlled. No authentication or user interaction is required (PR:N/UI:N), and default ProtobufMapper configuration is vulnerable. Critically, the usual limiting factors do NOT apply: StreamReadConstraints.maxStringLength, maxDocumentLength, and maxNestingDepth are all bypassed (confirmed empirically), and JVM -Xmx tuning does not help because the array-size-limit check fires before heap consultation. The real limiting factor is scope of exposure: only services that actually deserialize attacker-reachable protobuf with string/bytes fields are affected, and the impact is confined to availability (process OOM/crash) - no confidentiality or integrity loss.

Impact

This is a genuine but bounded priority. The CVSS 7.5 vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) is credible: a remote actor with no privileges or interaction can crash a process with a 33-byte payload, and the impact is strictly availability (C:N/I:N) - no data exposure or code execution. The decision label is 'this_week' (not act_now/emergency). KEV status is NO - this is not on CISA KEV, so there is no confirmed active exploitation. No EPSS score was provided, so statistical exploitation probability cannot be weighed here. A full working proof-of-concept is published in the GHSA advisory and was empirically confirmed by the reporter to trigger OutOfMemoryError against shipping 2.21.7 and 3.1.7 Maven Central jars, so exploitability is proven even without KEV/EPSS signals. The signals are internally consistent - network-reachable, trivial complexity, DoS-only - and the standout aggravator is that the two documented defenses (StreamReadConstraints maxStringLength/maxDocumentLength and JVM -Xmx heap tuning) do NOT mitigate this path, which raises its real-world weight above a typical availability bug. Net: prioritize patching for any service parsing untrusted protobuf, but it remains a denial-of-service issue, not a confidentiality/integrity compromise.

Exploit ScenarioDerived

An attacker submits a tiny (~33-byte) protobuf payload to a service that parses untrusted protobuf via jackson-dataformat-protobuf (e.g. a gRPC-to-JSON gateway or Kafka consumer using ProtobufMapper), encoding a string/bytes field whose varint length decodes to near Integer.MAX_VALUE. The signed-int bounds check overflows negative and passes, so the parser attempts a multi-gigabyte array allocation and the JVM throws OutOfMemoryError, crashing or destabilizing the service. Given AV:N/AC:L/PR:N/UI:N and a published, empirically confirmed PoC in the GHSA advisory, this requires no authentication, user interaction, or special timing.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.7% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 28, 2026

OutOfMemoryError denial of service in jackson-dataformat-protobuf allows a remote unauthenticated attacker to crash a protobuf-consuming service with a 33-byte payload when a length-prefixed string or bytes field has an attacker-controlled varint length near Integer.MAX_VALUE. Affected packages are com.fasterxml.jackson.dataformat:jackson-dataformat-protobuf through 2.22.3 (including 2.18.11 and 2.21.7) and tools.jackson.dataformat:jackson-dataformat-protobuf through 3.2.3 (including 3.1.7); default ProtobufMapper configurations are vulnerable, and the evidence confirms that maxStringLength, maxDocumentLength, maxNestingDepth, and -Xmx tuning do not prevent the allocation failure. This is a genuine but bounded priority: impact is availability-only, and exploitation requires that the service deserialize attacker-reachable protobuf using a schema with an attacker-influenced string or bytes field; the advisory includes a 33-byte reproduction confirmed against shipping 2.21.7 and 3.1.7 jars, while no CISA KEV listing is indicated.

RemediationAI

Upgrade to a vendor-fixed release: 2.18.12 for the 2.18 line, 2.21.8 for the 2.19-2.21 line, 2.22.4 for the 2.22 line, 3.1.8 for the 3.0-3.1 line, or 3.2.4 for the 3.2 line; see the GHSA advisory at https://github.com/FasterXML/jackson-dataformats-binary/security/advisories/GHSA-c2rq-mcfv-jw29. The evidence does not identify a configuration-only workaround: maxStringLength, maxDocumentLength, maxNestingDepth, and -Xmx were all confirmed not to mitigate. If upgrading is not immediately possible, the advisory's suggested code-level mitigation is to apply the bd2c681c-style newEnd < _inputPtr overflow guard to every remaining call site that computes _inputPtr + len before invoking _finishShortText(len), or, as defense in depth, to cap TextBuffer.expandCurrentSegment(int) at Integer.MAX_VALUE - 8 and throw a proper StreamReadException above that; both options require patching or replacing the affected library.

Affected ProductsAI

Affected Maven packages are com.fasterxml.jackson.dataformat:jackson-dataformat-protobuf from 2.6.0 through 2.18.11 (fixed in 2.18.12), 2.19.0 through 2.21.7 (fixed in 2.21.8), and 2.22.0 through 2.22.3 (fixed in 2.22.4); and tools.jackson.dataformat:jackson-dataformat-protobuf from 3.0.0 through 3.1.7 (fixed in 3.1.8) and 3.2.0 through 3.2.3 (fixed in 3.2.4). The GHSA advisory lists all currently supported Jackson Protobuf releases as affected, including the 2.18.11 and 2.21.7 LTS lines and the 3.1.7 LTS line. Vendor advisory: https://github.com/FasterXML/jackson-dataformats-binary/security/advisories/GHSA-c2rq-mcfv-jw29. No CPE strings were provided.

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The flaw is a CWE-190 signed 32-bit integer overflow in ProtobufParser's length-prefixed string/bytes handling. The parser checks (_inputPtr + len) <= _inputEnd; when len is a varint near Integer.MAX_VALUE, the addition wraps negative, so the bounds check passes and _finishShortText(len) calls TextBuffer.expandCurrentSegment(len), which performs Arrays.copyOf(curr, len) without a cap. The JVM rejects arrays larger than Integer.MAX_VALUE - 8 before consulting heap, producing OutOfMemoryError: Requested array size exceeds VM limit. The same root cause maps to CWE-770/CWE-789 resource exhaustion. A February 2026 hardening commit added a newEnd < _inputPtr overflow guard to the packed-array-length and message-length paths but left the string-length call sites unguarded, and the advisory notes the vulnerable pattern has existed since the module was created across the 2.x com.fasterxml.jackson.dataformat and 3.x tools.jackson.dataformat packages. The CVSS vector is AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, so no privileges or user interaction are required beyond submitting data for parsing; the trigger is specifically an attacker-controlled length-prefixed string or bytes field in a schema the attacker can influence.

Know when the next one hits your stack

  • 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 (36c7be3b-2937-45df-85ea-ca7133ea542c) 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

Remote, no auth or interaction against default config with a trivially crafted payload (AV:N/AC:L/PR:N/UI:N); impact is availability-only OOM crash, so C:N/I:N/A:H, scope unchanged.

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 (36c7be3b-2937-45df-85ea-ca7133ea542c).

CVSS VectorVendor: 36c7be3b-2937-45df-85ea-ca7133ea542c

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

DescriptionCVE.org

ProtobufParser parses length-prefixed protobuf string and bytes fields by checking (_inputPtr + len) <= _inputEnd and then, on the fast path, calling _finishShortText(len). Both use 32-bit signed integer arithmetic. When an attacker supplies a varint decoding to a length near Integer.MAX_VALUE, _inputPtr + len overflows to a negative value, the bounds check passes, and _finishShortText(len) reaches TextBuffer.expandCurrentSegment(len), which performs Arrays.copyOf with no cap and throws OutOfMemoryError: Requested array size exceeds VM limit.

The JVM refuses arrays larger than Integer.MAX_VALUE - 8 before consulting available heap, so -Xmx tuning does not mitigate the issue. StreamReadConstraints.maxStringLength and maxDocumentLength do not gate this path: a 33-byte payload is far below any document-length cap and the string-length check does not fire before the allocation. This was confirmed empirically against shipping artifacts with maxStringLength, maxDocumentLength and maxNestingDepth all configured.

A February 2026 hardening commit added the equivalent overflow guard to the packed-array-length and message-length paths but left the string-length call sites unguarded. No privileges or user interaction beyond the ability to submit data for parsing are required.

Technical POC Analysis

CWE-190 (integer overflow) leading to unbounded allocation (CWE-770 / CWE-789), in ProtobufParser of jackson-dataformat-protobuf: 2.x: protobuf/src/main/java/com/fasterxml/jackson/dataformat/protobuf…

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

CVE-2026-104016 is a high-severity (CVSS 7.5) availability vulnerability in the widely-used Jackson Protobuf data format library, affecting versions through 2.22.3 and 3.2.3. A remote, unauthenticated attacker can crash any service that deserializes protobuf messages with attacker-influenced string or bytes fields by sending a tiny 33-byte payload, causing an OutOfMemoryError and denial of service. This directly impacts service uptime and reliability for any application parsing protobuf from untrusted sources; while no data breach or code execution occurs, the operational disruption and potential cascading failures warrant management attention.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: (1) enforce strict maximum field-length validation before deserialization (e.g., custom deserializer or API gateway rules rejecting varint lengths above a safe threshold), (2) limit protobuf parsing to authenticated or trusted sources, (3) monitor for OutOfMemoryError and implement graceful restart/resource limits, and (4) apply network-level rate limiting and payload size restrictions.

Threat Intelligence Overview

EPSS Score
0.7%
Top 48% exploitable
Prevalence
Medium
popular Jackson library, but the protobuf binary-format module is a smaller subset
Social Media
3
Sightings
Data Quality
6 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.7%
Patch available No
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

39
Low Medium High Critical
KEV: 0
EPSS: +1
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