Skip to main content

Jackson Dataformat Smile CVE-2026-104895

| EUVDEUVD-2026-111530 HIGH
Memory Allocation with Excessive Size Value (CWE-789)
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 ~10-byte crafted Smile feed to async endpoint
  2. Exploit
    0xFD raw-binary VInt length decoded without overflow guard
  3. Execution
    _startRawBinary eagerly allocates ~2GB byte[]
  4. Impact
    OutOfMemoryError or NegativeArraySizeException crashes request/processing thread

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory allocation limits
Exploitation Conditions

Exploitation requires that the target application construct and feed the asynchronous, non-blocking Smile parser - SmileFactory.builder().build().createNonBlockingByteArrayParser(...) (class tools.jackson.dataformat.smile.async.NonBlockingByteArrayParser) - with attacker-supplied Smile bytes, the deployment pattern used by reactive/async stacks such as Spring WebFlux, Vert.x and Micronaut. No authentication, privileges, or user interaction are needed beyond the ability to submit data for parsing (PR:N/UI:N). The key LIMITING factor is the parser path: the blocking SmileParser._readUnsignedVInt already contains the (value >>> 25) != 0 overflow guard and is NOT vulnerable, so applications using only synchronous Smile parsing, or not accepting Smile input at all, are unaffected. Exploitation also depends on the JVM heap being small enough that an ~2 GB eager allocation (or the negative-length overflow variant) exhausts memory or throws before the body is read.

Impact

All quantitative signals point to a genuine but bounded availability problem rather than a top-tier emergency. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, base 7.5) describes a remotely reachable, low-complexity, unauthenticated flaw whose impact is confined to availability - confidentiality and integrity are explicitly N (CWE-789, memory allocation without limits). The vuln.today decision label is 'this_week', consistent with a serious DoS that is not under active attack. No EPSS score and no KEV status were provided in the input; per the precision rules this is 'no public exploit identified at time of analysis' in the KEV/POC sense, though the GHSA advisory contains a detailed, code-verified reproduction recipe (header + 0xFD marker + crafted 5-byte VInt), so a working proof-of-concept is clearly achievable even if no packaged exploit code is cited. The real limiter is reach, not difficulty: only applications that build the async NonBlockingByteArrayParser (createNonBlockingByteArrayParser) and feed it untrusted Smile data are exposed; the blocking SmileParser already carries the (value >>> 25) overflow guard and is not affected. This is a real priority for teams running reactive Smile endpoints (WebFlux, Vert.x, Micronaut), but for the large majority of Jackson deployments that use JSON or the blocking Smile parser it is not reachable. Missing data: EPSS and KEV are absent (not errors, just unsupplied), so widespread-exploitation probability cannot be quantified from the input.

Exploit ScenarioDerived

An attacker sends a roughly ten-byte Smile payload (a 4-byte Smile header, the 0xFD raw-binary marker, and a 5-byte VInt encoding ~2,000,000,000) to a reactive service that parses untrusted Smile input with the async NonBlockingByteArrayParser. On nextToken(), _startRawBinary eagerly executes new byte[len], forcing an ~2 GB allocation that throws OutOfMemoryError; a VInt crafted to overflow int instead yields a negative length and a NegativeArraySizeException that escapes the JacksonException contract. The GHSA advisory supplies a code-verified reproduction, so a working PoC is readily constructed, though no packaged exploit code is cited in the input.

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

Eager, unbounded memory allocation in the asynchronous Smile parser (NonBlockingByteArrayParser) lets a Smile feed of roughly ten bytes force a byte[] allocation of approximately 2 GB before any body bytes are consumed, producing an OutOfMemoryError that crashes the request or processing thread on reactive/async Smile endpoints; a VInt crafted to overflow int instead yields a negative length and a NegativeArraySizeException that is not a JacksonException and so escapes the parser contract. Only applications that construct the non-blocking parser via SmileFactory.createNonBlockingByteArrayParser and feed it attacker-supplied Smile bytes are exposed - the blocking SmileParser already contains the (value >>> 25) overflow guard - and no authentication, privileges or user interaction are required beyond the ability to submit data for parsing (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, CWE-789). No public exploit code has been identified at time of analysis, although the upstream advisory includes a code-verified reproduction recipe, and fixes are published across all supported branches.

RemediationAI

Upgrade jackson-dataformat-smile to a fixed release: 2.18.12 for the 2.18 line, 2.21.8 for the 2.21 line, 2.22.4 for the 2.22 line, and for the 3.x tools.jackson coordinate 3.1.8 (3.1 line) or 3.2.4 (3.2 line). The upstream fix adds the (value >>> 25) != 0 overflow check to the async _decodeVInt and routes large raw-binary lengths through an incremental read, mirroring the blocking parser's handling above 250000 bytes. Until patched, the most direct reduction is to avoid constructing the vulnerable code path at all: use the blocking SmileParser, which already performs the overflow check and the chunked long-binary read, or stop accepting Smile content from untrusted clients and restrict Content-Type handling at the gateway - both cost the streaming/non-blocking behaviour these endpoints were built for. JVM heap sizing and request/body-size limits at the reverse proxy do not remove the flaw, since the allocation is triggered by a length prefix rather than by actual payload volume. Vendor advisory: https://github.com/FasterXML/jackson-dataformats-binary/security/advisories/GHSA-h3c2-2m49-r49w.

Affected VersionsENISA

jackson-dataformat-smile 2.19.0 <2.21.8
jackson-dataformat-smile 3.0.0 <3.1.8
jackson-dataformat-smile 2.9.0 <2.18.12
jackson-dataformat-smile 3.2.0 <3.2.4
jackson-dataformat-smile 2.22.0 <2.22.4

Affected Packages

euvd jackson_dataformat_smile fix: 2.18.12, 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

Smile is FasterXML Jackson's binary JSON-compatible data format. In its raw-binary encoding, an 0xFD marker prefixes a variable-length integer (VInt) that declares the binary payload length. In the asynchronous parser at smile/src/main/java/tools/jackson/dataformat/smile/async/NonBlockingByteArrayParser.java, _decodeVInt() computes the length as (value << 6) + (i & 0x3F) without the (value >>> 25) != 0 overflow guard that the blocking SmileParser._readUnsignedVInt uses, and _startRawBinary (~line 1484, with _finishRawBinaryLen ~line 1496) immediately performs new byte[len] rather than deferring the read - so a declared length is honoured before the body is required and without any upper bound. The root cause class is CWE-789 (Memory Allocation with Excessive Size Value); the same defect class was addressed in this library's CBOR parser as CVE-2020-28491 using a LONGEST_NON_CHUNKED_BINARY guard, and the blocking Smile path already routes lengths above 250000 bytes through an incremental read (_finishBinaryRawLong). The async parser received neither protection, so an over-large length exhausts heap while an int-overflowing VInt produces a negative length and a NegativeArraySizeException. The reported vulnerable artifacts are cpe:2.3:a:fasterxml:jackson-dataformat-smile across both the 2.x com.fasterxml.jackson.dataformat coordinate and the 3.x tools.jackson.dataformat coordinate.

Know when Jackson Dataformat Smile 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

Untrusted Smile bytes reach the async parser remotely with no auth or interaction (AV:N/AC:L/PR:N/UI:N); impact is availability-only via OOM/exception (C:N/I:N/A:H), 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:01 cve.org
HIGH 7.5

DescriptionCVE.org

The asynchronous Smile parser (NonBlockingByteArrayParser) uses a raw-binary length prefix taken from untrusted input to allocate a byte[] before the body is read, with no upper bound and no overflow check. On the raw-binary marker 0xFD, _decodeVInt() computes (value << 6) + (i & 0x3F) without the (value >>> 25) != 0 overflow guard present in the blocking SmileParser._readUnsignedVInt, and _startRawBinary then allocates the declared length immediately.

A Smile feed of roughly ten bytes can therefore force an eager allocation of approximately 2 GB, producing an OutOfMemoryError on reactive or asynchronous Smile endpoints. A VInt crafted to overflow int yields a negative length and a NegativeArraySizeException, a RuntimeException that is not a JacksonException and so escapes the parser contract. Either outcome crashes the request or processing thread.

This is the same class of issue as CVE-2020-28491 in the CBOR parser of this library, which was fixed with a LONGEST_NON_CHUNKED_BINARY guard; the asynchronous Smile parser never received the equivalent guard. No privileges or user interaction beyond the ability to submit data for parsing are required.

Technical POC Analysis

CWE-789: Memory Allocation with Excessive Size Value.

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 vulnerability in the Smile data format parser (CVE-2026-104895) allows unauthenticated attackers to crash applications that use Jackson's non-blocking parser with a tiny malicious payload, causing service outages. Organizations using this parser in reactive or asynchronous endpoints are at risk of denial-of-service, impacting availability of customer-facing services and internal processing threads.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: avoid using the non-blocking Smile parser for untrusted input; use the blocking SmileParser which contains an overflow guard; enforce strict size limits on incoming Smile payloads; implement exception handling to catch NegativeArraySizeException and prevent thread crashes; consider disabling Smile format support until a patch is available.

Threat Intelligence Overview

EPSS Score
0.4%
Top 68% exploitable
Prevalence
Medium
optional Smile binary-format module; async parser used only in reactive endpoints
Social Media
2
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

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