Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend crafted polymorphic JSON to deserialization endpoint
-
DeliveryName gadget class inside permitted generic argument or array element
-
ExploitBypass PolymorphicTypeValidator outer-class-only check
-
ExecutionInstantiate FileSystemXmlApplicationContext loading attacker XML
-
ImpactExecute OS commands via ProcessBuilder.start()
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V1 - Encoding and Sanitization Safe deserialization, type allowlists
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the application to perform class-name polymorphic deserialization of attacker-controlled JSON through one of several concrete paths: annotation-based polymorphism using @JsonTypeInfo(use = Id.CLASS) or Id.MINIMAL_CLASS with a default Jackson 3.x JsonMapper (the default DefaultBaseTypeLimitingValidator case needs NO application-authored validator); configured default typing in Jackson 2.x or 3.x; an allowIfBaseType(...) rule approving an outer type such as Map; or exposed integrations including Spring Data Redis 4.0.7 RedisSerializer.json()/GenericJackson2JsonRedisSerializer() and Spring Security's legacy Jackson 2 module. For the demonstrated full RCE the attacker additionally needs Spring on the classpath plus XML loadable by the application account (reaching FileSystemXmlApplicationContext → ProcessBuilder.start()); stock-JDK gadgets otherwise permit file creation/truncation, descriptor consumption, or URL requests. LIMITING FACTORS: no user interaction is required and no authentication is indicated by the CVSS vector (PR:N), but exploitation is gated on the specific polymorphism configuration, the gadget classes present on the classpath, and a reachable deserialization entry point. Versions before 2.10.0 are NOT affected because PolymorphicTypeValidator did not yet exist. Applied CVE-2026-54512 fixes (2.18.8, 2.21.4, 3.1.4) do NOT remediate this bypass. |
| Impact | This is a genuine high-priority issue, not a CVSS-inflated one. The NVD CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N, C:H/I:H/A:H = 9.8) is corroborated by the vuln.today Decision label 'act_now', vendor-confirmed patches across five release branches, and a detailed GHSA advisory (GHSA-m8xf-2cr7-77ph) describing working reproduction against unmodified released artifacts (2.10.0, 2.19.2, 2.22.3, 3.0.0, 3.1.5, 3.2.3). The signals are mutually reinforcing rather than conflicting: deserialization RCE (CWE-502) in a near-universally deployed Java library warrants urgent remediation. Two caveats temper the raw score. First, this is an INCOMPLETE FIX for CVE-2026-54512 - organizations that applied the earlier fixed releases (2.18.8, 2.21.4, 3.1.4) are still exposed via the remaining generic-argument and array-element paths. Second, real-world exploitability is conditional: the application must expose a class-name polymorphic deserialization path over attacker-controlled input and have a usable gadget on the classpath, so the network/low-complexity base metrics overstate the number of installations actually reachable without specific configuration. No CISA KEV listing and no EPSS score were provided in the input; absence of a KEV entry means active exploitation is NOT confirmed. A public PoC reference (standalone reproducer) is attached to the advisory but is not stated by the input to be verified working weaponized exploit code. |
| Exploit ScenarioDerived | An unauthenticated attacker submits crafted JSON to a network-facing endpoint whose application deserializes polymorphic data (e.g., @JsonTypeInfo(use=Id.CLASS) or configured default typing) using an affected jackson-databind. Instead of a directly-blocked gadget type ID, the attacker names a permitted generic wrapper (such as Env<Gadget> or HashMap<FileSystemXmlApplicationContext,String>) so the gadget slips through validation as a generic argument; with Spring on the classpath and attacker-loadable XML this reaches ProcessBuilder.start() for command execution under the application account. A standalone reproducer is referenced in the GHSA advisory, though the input does not confirm it as verified working exploit code. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
Class-name polymorphic deserialization in jackson-databind is insufficiently validated: the outer class in a type ID is checked, but classes named inside generic arguments (and array element types) are accepted even when they would be rejected as direct type IDs, letting an attacker instantiate arbitrary classes. Affected are com.fasterxml.jackson.core:jackson-databind 2.10.0 through 2.18.11, 2.19.0 through 2.21.7 and 2.22.0 through 2.22.3, plus tools.jackson.core:jackson-databind 3.0.0 through 3.1.7 and 3.2.0 through 3.2.3; releases before 2.10.0 are unaffected because PolymorphicTypeValidator did not yet exist, and the earlier CVE-2026-54512 fixes (2.18.8, 2.21.4, 3.1.4) do not remediate this bypass. The default-validator case needs no application-authored validator at all, and the advisory's PoC demonstrates that with Spring on the classpath and attacker-controlled XML, FileSystemXmlApplicationContext is reached through map-key discovery and ProcessBuilder.start() executes arbitrary commands under the application account; the issue carries a public reproducer and warrants the act_now priority label, although exploitation remains gated on the specific polymorphism configuration, available classpath gadgets and a reachable deserialization entry point.
RemediationAI
Upgrade to a vendor-released fixed version: jackson-databind 2.18.12 for the 2.18 branch, 2.21.8 for the 2.19-2.21 branches, 2.22.4 for 2.22, tools.jackson.core:jackson-databind 3.1.8 for 3.0-3.1 and 3.2.4 for 3.2, per GHSA-m8xf-2cr7-77ph; the fixes land in PR #6287 with the remaining array-element-type bypass closed in follow-up PR #6289, and the 2.x release notes list the affected configurations. Do not rely on the earlier CVE-2026-54512 releases (2.18.8, 2.21.4, 3.1.4) - the advisory confirms they still accept the remaining path, and executed affected releases include 2.10.0, 2.19.2, 2.22.3, 3.0.0, 3.1.5 and 3.2.3. If upgrading is not immediately possible, the advisory's stated workarounds are to disable class-name polymorphism for untrusted data (this removes the type-ID attack surface but breaks legitimate class-name-based polymorphic serialization), use narrow subtype rules rather than broad allowIfBaseType(...) outer-type rules (note that approving an outer type substitutes LaissezFaireSubTypeValidator and stops constraining generic arguments), prevent attackers from writing serialized cache or session values (the Spring Data Redis convenience serializers expose this path, so untrusted writes to such caches must be blocked), and remove unnecessary gadget-bearing dependencies such as Spring XML context classes from the deserialization classpath (a trade-off in application functionality but it removes the demonstrated FileSystemXmlApplicationContext → ProcessBuilder.start() chain).
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
The root cause is CWE-502 (deserialization of untrusted data) in Jackson's PolymorphicTypeValidator enforcement path. DatabindContext._resolveAndValidateGeneric() verifies the outer class against the declared base type, then passes each type argument to _validateTypeParameter(), which validates the argument against the outer base type rather than enforcing its corresponding declared generic binding, and invokes validators with arguments that have never passed the subtype check those validators assume. Under the default DefaultBaseTypeLimitingValidator this permits an unrelated class inside a generic subtype even where the same class is rejected as a direct type ID; when an allowIfBaseType(...) rule approves the outer type, Jackson substitutes LaissezFaireSubTypeValidator, so the configured validator stops constraining the embedded arguments entirely. Array type IDs such as [Lpkg.Gadget; likewise leave the element type unvalidated once the array base type is approved (for example under allowIfBaseType(Serializable.class)). Concrete reachable paths include @JsonTypeInfo(use = Id.CLASS) or Id.MINIMAL_CLASS on interfaces/Iterable/Map properties with a default Jackson 3.x JsonMapper, configured default typing in Jackson 2.x and 3.x, Spring Security's legacy Jackson 2 module whose resolver checks only the raw allowlisted HashMap, and Spring Data Redis 4.0.7 convenience APIs RedisSerializer.json() and GenericJackson2JsonRedisSerializer() that expose default typing without an application-authored mapper. Where class-name default typing permits Map, a property declared Map<String,String> accepts HashMap<FileSystemXmlApplicationContext,String>, and map-key discovery passes the attacker-controlled JSON property name into the selected class's one-string constructor - the trigger is the incompatible generic binding itself, which the advisory confirms reaches the constructor even though direct selection of that class is rejected. The fix validates every class named in a type ID, including type parameters and array element types, as if it were a direct type ID.
Know when Jackson Databind 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:H/I:H/A:H
Remote unauthenticated attacker supplies JSON to a polymorphic deserialization path with no user interaction; the default-validator case needs no custom validator, yielding full RCE impact.
Primary rating from Vendor (HeroDevs).
CVSS VectorVendor: HeroDevs
Lifecycle Timeline
2DescriptionCVE.org
jackson-databind validates the outer class of a class-name type ID but accepts attacker-selected classes inside its generic arguments, even when those classes violate the declared type or would be rejected as direct type IDs. This bypasses the generic-argument validation added for CVE-2026-54512 (GHSA-j3rv-43j4-c7qm), of which this is an incomplete fix.
DatabindContext._resolveAndValidateGeneric() checks the outer class against the declared base type and then passes each argument from the type ID to _validateTypeParameter(), which validates the argument against the outer base type rather than enforcing its corresponding declared generic binding. It also invokes validators with arguments that have not passed the subtype check those validators expect. Under the default DefaultBaseTypeLimitingValidator this accepts an unrelated class inside a generic subtype even when the same class is rejected as a direct type ID. Where an allowIfBaseType(...) rule approves the outer type, Jackson substitutes LaissezFaireSubTypeValidator, so the configured validator no longer restricts the embedded arguments. The element type of a plain array type ID such as [Lpkg.Gadget; is likewise left unvalidated once the array's base type is approved.
Affected paths include annotation-based class-name polymorphism with a default Jackson 3.x JsonMapper, configured default typing in both Jackson 2.x and 3.x, and integrations that expose that default typing. The default-validator case requires no application-authored validator: with @JsonTypeInfo(use = Id.CLASS), a direct gadget type ID is rejected as "Not a subtype", while a type ID naming a generic wrapper around the same gadget is accepted and deserialized, including attacker-supplied bean properties. Where class-name default typing permits Map, a property declared as Map<String,String> accepts HashMap<FileSystemXmlApplicationContext,String>; map-key discovery then passes the attacker-controlled JSON property name to the selected class's one-string constructor. With Spring on the classpath and attacker-controlled XML the application can load, that constructor loads the XML and invokes ProcessBuilder.start() under the application account, giving arbitrary command execution.
This issue affects com.fasterxml.jackson.core:jackson-databind from 2.10.0 and tools.jackson.core:jackson-databind from 3.0.0. Releases before 2.10.0 are not affected, because PolymorphicTypeValidator was introduced in jackson-databind 2.10.0.
Articles & Coverage 1
Technical POC Analysis
CWE-502: Deserialization of Untrusted Data.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A critical vulnerability in jackson-databind (CVE-2026-110879, CVSS 9.8) allows unauthenticated attackers to bypass existing polymorphic type validation and instantiate arbitrary classes, potentially leading to remote code execution. This affects any Java application using Jackson for JSON/XML deserialization, including those that already applied fixes for prior CVEs, and the availability of a public proof-of-concept increases the urgency for immediate patching.
Apply vendor patch.
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
Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.
More in Jackson Databind
View allFasterXML jackson-databind 2.x before 2.9.10.4 mishandles the interaction between serialization gadgets and typing, rela
FasterXML jackson-databind 2.x before 2.9.10.4 mishandles the interaction between serialization gadgets and typing, rela
FasterXML jackson-databind 2.x before 2.9.10.4 mishandles the interaction between serialization gadgets and typing, rela
FasterXML jackson-databind 2.x before 2.9.10.8 mishandles the interaction between serialization gadgets and typing, rela
A Polymorphic Typing issue was discovered in FasterXML jackson-databind 2.x before 2.9.9. Rated high severity (CVSS 7.5)
FasterXML jackson-databind 2.0.0 through 2.9.10.2 lacks certain xbean-reflect/JNDI blocking, as demonstrated by org.apac
A flaw was found in FasterXML Jackson Databind, where it did not have entity expansion secured properly. Rated high seve
FasterXML jackson-databind 2.x before 2.9.9.1 might allow attackers to have a variety of impacts by leveraging failure t
FasterXML jackson-databind 2.x before 2.9.10.8 mishandles the interaction between serialization gadgets and typing, rela
FasterXML jackson-databind before 2.7.9.3, 2.8.x before 2.8.11.1 and 2.9.x before 2.9.5 allows unauthenticated remote co
FasterXML jackson-databind 2.x before 2.9.10.8 mishandles the interaction between serialization gadgets and typing, rela
FasterXML jackson-databind 2.x before 2.9.10.8 mishandles the interaction between serialization gadgets and typing, rela
Same weakness CWE-502 – Deserialization of Untrusted Data
View allSame technique Deserialization
View allVendor StatusVendor
Debian
| Release | Status | Fixed Version | Urgency |
|---|---|---|---|
| bookworm, bookworm (security) | vulnerable | 2.14.0-1+deb12u1 | - |
| trixie (security), trixie | fixed | 2.14.0+ds-1+deb13u1 | - |
| forky | vulnerable | 2.18.11-1 | - |
| sid | fixed | 2.22.4-1 | - |
| trixie | not-affected | - | - |
| (unstable) | fixed | 2.22.4-1 | - |
EUVD-2026-111532
NVD
CVE.org
EPSS
GitHub
VulDB
Exploit-DB