Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit ~10-byte crafted Smile feed to async endpoint
-
Exploit0xFD raw-binary VInt length decoded without overflow guard
-
Execution_startRawBinary eagerly allocates ~2GB byte[]
-
ImpactOutOfMemoryError 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
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.
Primary rating from Vendor (HeroDevs).
CVSS VectorVendor: HeroDevs
Lifecycle Timeline
2DescriptionCVE.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
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.
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
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
EUVD-2026-111530
NVD
CVE.org
EPSS
GitHub
VulDB
Exploit-DB