Attackers are actively exploiting a critical remote code execution vulnerability in Alibaba’s Fastjson 1.x library, a widely used JSON parser for Java, with no official patch available as of July 25, 2026. The flaw, designated CVE-2026-16723 and carrying a CVSS score of 9.0, allows unauthenticated attackers to execute arbitrary code on affected Spring Boot applications simply by sending a malicious JSON request. Security firms ThreatBook and Imperva have confirmed in-the-wild exploitation targeting financial services, healthcare, retail, and other sectors, primarily in the United States, but also in Singapore and Canada.
What Is CVE-2026-16723 and Why Is It Critical?
The vulnerability resides in Fastjson versions 1.2.68 through 1.2.83, the final 1.x release line. Unlike previous Fastjson flaws that required AutoType to be enabled, CVE-2026-16723 works even with AutoType disabled and without any classpath gadget. The attack chain requires a Spring Boot application packaged as an executable fat-JAR, a network-reachable endpoint that passes attacker-controlled JSON to an affected parser, and SafeMode left at its default disabled state. The CVSS score of 9.0 reflects the ease of exploitation and the potential for full system compromise.
Alibaba published its advisory on July 21 following responsible disclosure by Kirill Firsov of FearsOff Cybersecurity. The maintainers verified the exploit chain on Spring Boot 2.x, 3.x, and 4.x with JDK 8, 11, 17, and 21. As of July 25, no patched Fastjson 1.x artifact exists in either the GitHub tags or Maven Central repository.
How Does the Exploit Work?
Firsov traced the root cause to Fastjson’s type-resolution mechanism. When parsing JSON, Fastjson processes an attacker-controlled @typecodecodecode value that can be turned into a class-resource lookup. In a Spring Boot fat-JAR, the application’s classloader allows fetching resources from nested JARs. A crafted nested JAR path can retrieve attacker-controlled bytecode. An @JSONTypecodecodecode annotation within that resource is then treated as a trust signal, allowing the class to bypass Fastjson’s type checks and be loaded into the JVM, ultimately executing arbitrary code.
Firsov’s technical analysis also describes a second variant for newer JDK versions: the exploit downloads a remote JAR file and references it through /proc/self/fdcodecodecode, bypassing the need for a local nested JAR. This method increases the attack surface for environments where outbound network access is allowed.
Key Exploit Requirements
- Fastjson version: 1.2.68 through 1.2.83
- Application packaging: Spring Boot executable fat-JAR (plain non-fat JARs, generic uber-JARs, Tomcat or Jetty WAR deployments are not affected)
- Entry point:
JSON.parsecodecodecode,JSON.parseObject(String)codecodecode, orJSON.parseObject(String, Class)codecodecode where user-controlled JSON is passed - SafeMode: Must be disabled (default)
Binding input to a fixed class does not provide protection if the object contains an Objectcodecodecode or Mapcodecodecode field, because the attacker can nest the payload there.
Active Exploitation in the Wild
ThreatBook reported on July 22 that its platform had captured in-the-wild exploitation attempts after adding detection support two days earlier. In its laboratory tests, the firm successfully reproduced full code execution on a Spring Boot fat-JAR with JDK 8, while its embedded Tomcat test produced only a remote JAR fetch or server-side request forgery (SSRF), not full code execution.
Imperva published a separate report detailing observed activity against financial services, healthcare, computing, retail, and other organizations. The attacks originated primarily from the United States, with smaller volumes from Singapore and Canada. Analysis of the attack traffic showed that browser impersonators generated the majority of requests, while Ruby and Go-based tools accounted for about 30% collectively. Neither vendor disclosed specific attack counts, raw request volumes, evidence of successful code execution, named victims, or confirmed compromises. Their reports establish that exploit activity is being conducted, but do not prove that any real-world target was breached.
Notably, a July 23 assessment from the CISAaa-ADP marked exploitation as nonecodecodecode, and the flaw does not appear in CISA’s Known Exploited Vulnerabilities catalog as of July 25. The available sources do not explain this mismatch, but it may reflect a lag in cataloging or a conservative assessment of the observed activity.
What Are the Mitigations for Fastjson CVE-2026-16723?
Because no patched Fastjson 1.x version exists, organizations must take immediate alternative steps. The primary mitigations are:
- Enable SafeMode immediately: Add the JVM parameter
-Dfastjson.parser.safeMode=truecodecodecode. This disables the feature that the exploit relies on. - Use the restricted build: Replace the standard
fastjson:1.2.83codecodecode dependency withcom.alibaba:fastjson:1.2.83_noneautotypecodecodecode. This build disables AutoType entirely and may block the attack chain. - Migrate to Fastjson2: Alibaba lists Fastjson2 as the long-term fix. Fastjson2 does not use the same resource-probing or annotation-based trust path, so it is not affected by this vulnerability.
- Inventory dependencies: Audit all direct and transitive dependencies for Fastjson 1.x versions within the affected range. Many projects may include it indirectly through Spring Boot starters or other libraries.
- Monitor for suspicious activity: Look for unusual
@typecodecodecode values in JSON payloads, nested JAR URLs in requests, unexpected outbound network connections, child processes spawned by the JVM, file changes, or web shells.
Technical Context: Why This Vulnerability Is Unusual
Fastjson has a long history of security issues, with multiple AutoType bypass vulnerabilities disclosed over the years. The 2022 update to version 1.2.83 was specifically recommended as a fix for a previous AutoType bypass. Now that same version sits inside the affected range for CVE-2026-16723, highlighting the difficulty of completely securing a library with such a complex feature set.
The key innovation in this exploit is that it bypasses the need for AutoType. Previous Fastjson RCEs required attackers to enable AutoType or find a way to bypass its restrictions. Here, the vulnerability uses a different trust mechanism: the @JSONTypecodecodecode annotation. When Fastjson loads a class from a resource that contains this annotation, it treats the class as trusted, allowing the load to proceed. By crafting a malicious resource, the attacker subverts the type-checking logic.
This makes the flaw particularly dangerous because many organizations had configured AutoType to be disabled, believing that to be sufficient protection. The exploit also does not require a classpath gadget, meaning attackers cannot rely on existing libraries—they provide their own malicious bytecode.
Impact on the Software Supply Chain
The active exploitation of a widely used open-source library like Fastjson underscores the risks of dependency chains. Fastjson is a popular choice for JSON processing in the Java ecosystem, especially in Alibaba Cloud and many Chinese enterprises, but also globally. The vulnerability affects any application that uses Fastjson 1.x and is deployed as a Spring Boot fat-JAR.
The lack of a patch after four days from advisory publication (July 21 to July 25) is concerning. Alibaba has not yet announced a timeline for a fixed Fastjson 1.x release. Organizations relying on the library must either accept the risk of continuing to use it, apply the workarounds, or migrate to Fastjson2. Migrating to a different library, such as Jackson or Gson, is also an option, but that may require significant code changes.
What Should Organizations Do Now?
Given the active exploitation, the priority is to enable SafeMode and switch to the restricted build if immediate migration is not possible. The mitigations are effective but must be tested in staging environments to ensure no breakage of existing functionality. SafeMode disables a wide range of Fastjson features, so it may cause application failures if the code relies on AutoType or other disabled features.
Security teams should also deploy network-level detection rules to flag JSON payloads containing suspicious @typecodecodecode values, especially those referencing nested JAR URLs or unusual class names. Web application firewalls (WAFs) can be updated to block requests with such patterns.
For organizations that cannot apply the mitigations quickly, restricting network access from the application server to external hosts may reduce the risk of remote JAR download, but the exploit can also use local nested JAR paths, so it is not a complete defense.
Looking Ahead
The Fastjson 1.x ecosystem reaches a critical junction. The library has been succeeded by Fastjson2, but many legacy systems remain on the 1.x branch. The inability to quickly patch a known exploited vulnerability will likely accelerate migration efforts across the industry. Security researchers and vendors will continue to monitor for new variants or additional attack vectors. The absence of confirmation of successful breaches from the reported exploitation activity does not diminish the urgency—attackers are actively probing, and the potential for a full compromise is high. Organizations should treat this as a zero-day situation and act accordingly.
/i.s3.glbimg.com/v1/AUTH_08fbf48bc0524877943fe86e43087e7a/internal_photos/bs/2026/B/N/5EQ9QeQAa2XoA9mRtS0w/marvels-wolverine-state-of-play.jpg "Marvel’s Wolverine Settings: What Actually Works in Combat")
