MEDIUM 5.3

CVE-2026-54517 Jackson-Databind @JsonView Bypass Vulnerability Analysis

A flaw in Jackson's data-binding library allows attackers to bypass view-based access controls during JSON deserialization. When a JSON API uses @JsonView annotations to hide certain properties from specific clients or roles, this vulnerability can cause hidden collection or map properties to be populated anyway if they lack a setter method. An attacker sending crafted JSON can inject data into fields that should have been invisible, potentially modifying application state in unintended ways.

Source data · NVD / CISA · public domain

CVSS
3.1 · 5.3 MEDIUM · CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N
Weaknesses (CWE)
CWE-863
Affected products
1 configuration(s)
Published / Modified
2026-06-23 / 2026-06-27

NVD description (verbatim)

jackson-databind contains the general-purpose data-binding functionality and tree-model for Jackson Data Processor. From 2.21.0 until 2.21.4 and 3.1.4, in BeanDeserializer._deserializeUsingPropertyBased, the active-view (@JsonView) filter was applied only to creator properties; the regular property-buffering branch performed no prop.visibleInView(activeView) check. A change making SetterlessProperty.isMerging() return true routed setterless Collection/Map properties through this unguarded path, so a setterless collection annotated with a restricted @JsonView is populated from attacker JSON even when the active view excludes it. This vulnerability is fixed in 2.21.4 and 3.1.4.

5 reference(s) · View on NVD →

SEC.co analysis · AI-assisted, reviewed against source

Technical summary

CVE-2026-54517 is a property-visibility bypass in jackson-databind affecting versions 2.21.0–2.21.3 and 3.1.0–3.1.3. The root cause is incomplete @JsonView enforcement in BeanDeserializer._deserializeUsingPropertyBased. While creator properties respect the active-view filter, the regular property-buffering code path skips the visibleInView() check. A recent change to SetterlessProperty.isMerging() that returns true routes setterless Collection and Map properties through this unguarded deserialization path. Consequently, a restricted collection property annotated with @JsonView can be deserialized and populated from untrusted JSON input even when the active view should exclude it, violating the intended access-control semantics.

Business impact

Organizations relying on Jackson's @JsonView feature to enforce role-based or context-based data filtering in REST APIs face a data-integrity risk. An attacker can inject or modify collection-typed properties that an API was designed to hide from them, potentially leading to unauthorized state changes, privilege escalation, or data leakage depending on the affected properties. This is particularly concerning in multi-tenant or role-separated API endpoints where @JsonView is used as a primary isolation mechanism.

Affected systems

jackson-databind versions 2.21.0 through 2.21.3 and 3.1.0 through 3.1.3 are vulnerable. The issue does not affect versions prior to 2.21.0 or 3.1.0. Applications using these versions in deserialization workflows with @JsonView-annotated collection or map properties lacking setters are at risk. No other Jackson components (e.g., streaming parser, annotations module) are directly affected.

Exploitability

Exploitability is straightforward: an attacker needs only network access to an affected application and knowledge that a @JsonView-restricted collection property exists. No special privileges, authentication bypass, or user interaction are required. The attack surface is high for any REST API or microservice using Jackson to deserialize JSON payloads. However, the impact is limited to integrity of specific properties; confidentiality is not compromised. CVSS 5.3 (MEDIUM) reflects the moderate severity: low complexity, no authentication needed, but integrity impact only.

Remediation

Upgrade jackson-databind to version 2.21.4 or 3.1.4 or later. Both versions contain the fix restoring @JsonView validation to all property deserialization paths. Organizations should prioritize this update for applications using @JsonView annotations to enforce access control, especially those in production. After patching, no configuration changes are required.

Patch guidance

Jackson releases security patches via Maven Central and GitHub releases. Verify your current jackson-databind version (check pom.xml, gradle.build, or dependency-lock files). Update to 2.21.4 or 3.1.4 as appropriate for your major version line. Test in a staging environment to confirm compatibility, particularly if custom deserializers or view filters are in use. Consider automated dependency scanning (e.g., Maven Dependency Check or OWASP Dependency-Check) to detect similar issues going forward.

Detection guidance

Review application code for @JsonView annotations on collection or map properties. Enable debug logging on BeanDeserializer to observe which properties are deserialized and against which views. Monitor inbound JSON payloads for unexpected properties matching your restricted field names. Correlation of request source with view context may reveal anomalies. Post-patch, verify that no payloads bypass view filters by performing integration tests with deliberately restricted views and crafted payloads.

Why prioritize this

This vulnerability merits prompt but not emergency patching. The MEDIUM severity and straightforward fix (version bump) make it lower priority than critical RCE issues, but @JsonView-reliant APIs should not delay. Organizations with strict role-based data separation should prioritize more highly; those not using @JsonView annotations can defer slightly. Rapid patching reduces exposure to both known and opportunistic exploitation.

Risk score, explained

CVSS 5.3 reflects: Network-accessible attack vector (AV:N), low attack complexity (AC:L), no authentication requirement (PR:N), no user interaction (UI:N), and integrity impact only (I:L). The score appropriately captures a moderate, practical integrity risk without elevation to severity. The lack of confidentiality or availability impact prevents a higher score despite the relative ease of exploitation.

Frequently asked questions

Does this vulnerability affect applications that do not use @JsonView annotations?

No. Applications relying purely on other access-control mechanisms (e.g., explicit filtering in service layer, Spring Security filters) are unaffected. The vulnerability exists only in the @JsonView enforcement path. However, upgrading remains prudent as a general hygiene measure.

Can this vulnerability be exploited without network access to the application?

No. An attacker must send a malicious JSON payload over the network to a deserialization endpoint. Local code execution, process injection, or insider access is not required; standard network connectivity suffices.

If we patch to 2.21.4 or 3.1.4, do we need to reconfigure @JsonView rules?

No. The patch restores the original @JsonView enforcement logic transparently. Existing annotations and view configuration remain valid and effective without modification.

Does this affect JSON serialization (writing JSON), only deserialization (reading JSON)?

Only deserialization (reading) is affected. When Jackson converts incoming JSON into Java objects, the @JsonView filter is bypassed. Serialization (writing objects as JSON) is not impacted.

This analysis is based on published CVE data and vendor advisories current as of the analysis date. Organizations should verify patch availability and compatibility in their specific environments before deployment. No exploit code or weaponizable proof-of-concept is provided. For the latest patch versions and detailed vendor guidance, consult the FasterXML Jackson project repository and security advisories. This document is for informational purposes and does not constitute legal or compliance advice. Source: NVD (public-domain), retrieved 2026-07-29. Analysis generated by SEC.co (claude-haiku-4-5).