CVE-2026-16723: 
Java 취약성 분석 및 완화

CVE-2026-16723 is a critical remote code execution (RCE) vulnerability in Alibaba's fastjson library, affecting versions 1.2.68 through 1.2.83 (the last 1.x release). The vulnerability is exploitable under fastjson's stock default configuration — no AutoType enablement and no classpath gadget are required — making it exceptionally dangerous for the large number of applications using these versions. The sole deployment prerequisite is that the target application runs as a Spring Boot executable fat-jar (launched via java -jar), which is the most common Spring Boot deployment model. It was disclosed on July 23, 2026, with a patch released as fastjson 1.2.84. The CVSS v3.1 base score is 9.0 (Critical), assigned by Alibaba (Github Advisory, Alibaba Security Advisory).

The root cause is classified as CWE-502 (Deserialization of Untrusted Data) and CWE-20 (Improper Input Validation). In fastjson 1.x, the checkAutoType method probes user-controlled type names via getResourceAsStream calls on the Spring Boot fat-jar's classloader, which exposes an exploitable code path even when AutoType is disabled. An attacker can craft a malicious JSON payload containing a specially formed @type field with URL-special characters (e.g., :/!) that bypasses the denylist and triggers resource probing or class loading, ultimately achieving arbitrary code execution. All standard JSON parsing entry points are reachable: JSON.parse(), JSON.parseObject(String), and JSON.parseObject(String, Class) — and specifying a target DTO class is not a mitigation, as attackers can nest payloads inside Object/Map-typed fields. The vulnerability has been verified on Spring Boot 2.x/3.x/4.x and JDK 8/11/17/21. A public PoC exploit script (CVE-2026-16723.py) is available on GitHub (Alibaba Security Advisory, PoC GitHub).

Successful exploitation allows an unauthenticated remote attacker to execute arbitrary commands on the target server with the privileges of the Java process running the Spring Boot application, resulting in full system compromise. The impact spans all three security dimensions: complete confidentiality loss (access to application data, secrets, credentials), integrity loss (ability to modify files, inject code, or alter application state), and availability loss (service disruption or destruction). Given the prevalence of Spring Boot fat-jar deployments in enterprise environments, the blast radius is significant, with potential for lateral movement within internal networks, data exfiltration, and ransomware deployment. Reports indicate active targeting of US-based organizations (Bleeping Computer, CybersecurityNews).

1. Reconnaissance: Identify internet-facing Spring Boot applications using Shodan, Censys, or similar tools by fingerprinting fat-jar deployments. Confirm the target uses fastjson 1.2.68–1.2.83 by analyzing HTTP response headers, error messages, or dependency manifests if accessible.
2. Identify JSON parsing endpoints: Locate application endpoints that accept and parse JSON input (e.g., REST API endpoints accepting Content-Type: application/json). These are the entry points for JSON.parse(), JSON.parseObject(), or similar fastjson calls.
3. Craft malicious payload: Construct a JSON payload containing a specially crafted @type field with URL-special characters (e.g., :/!) that bypasses fastjson's denylist. The payload exploits the getResourceAsStream probing behavior in the Spring Boot fat-jar classloader to trigger class loading of an attacker-controlled type.
4. Deliver payload: Send the crafted JSON payload via HTTP POST (or other applicable method) to the target endpoint. No authentication is required. If the endpoint expects a specific DTO, nest the malicious @type payload inside an Object or Map-typed field of the expected structure.
5. Achieve code execution: The fastjson parser processes the @type value, probes the fat-jar classloader, and instantiates or invokes a class/method that executes attacker-controlled commands on the server (e.g., id > /tmp/result, reverse shell).
6. Post-exploitation: Use the established shell to enumerate the environment, exfiltrate credentials or data, establish persistence, or pivot to internal network resources (PoC GitHub, Alibaba Security Advisory).

• Network: Unusual HTTP POST requests to JSON-accepting API endpoints containing @type fields with URL-special characters (:, /, !) in the type name; unexpected outbound connections from the Java application server to unknown external IPs (potential reverse shell or C2 traffic); DNS lookups for attacker-controlled domains originating from the application server.
• Logs: Application logs showing fastjson parsing errors or exceptions related to type resolution with non-standard class names; access logs with large or malformed JSON bodies sent to REST endpoints; Java stack traces referencing ParserConfig.checkAutoType or TypeUtils.loadClass with unusual class name arguments.
• File System: Unexpected files written to world-writable directories (e.g., /tmp/result, /tmp/*.sh); new cron jobs, systemd units, or startup scripts created by the application service account; web shells or backdoor binaries dropped in the application directory.
• Process: Unusual child processes spawned by the JVM process (e.g., /bin/bash, /bin/sh, curl, wget, python, nc); processes running as the application service account performing network connections or file operations inconsistent with normal application behavior.
• YARA/Detection Rules: Community YARA rules for detecting CVE-2026-16723 payloads have been submitted (referenced via r/blueteamsec); Emerging Threats ruleset update 2026-07-29 (v11245) includes signatures for this vulnerability (Emerging Threats).

The primary remediation is to upgrade fastjson to version 1.2.84, which fixes the vulnerability by rejecting type names containing URL-special characters (:/!) before any resource probing or class loading occurs (Alibaba Security Advisory). If immediate upgrade is not possible, the following workarounds are available in priority order:

• Enable SafeMode (P0): Set -Dfastjson.parser.safeMode=true as a JVM argument, call ParserConfig.getGlobalInstance().setSafeMode(true) in code, or configure it in fastjson.properties. This rejects all @type processing before the vulnerable path is reached.
• Switch to noneautotype build (P0): Use com.alibaba:fastjson:1.2.83_noneautotype, which removes the vulnerable code at compile time.
• Migrate to fastjson2 (P1): fastjson2 architecturally eliminates this vulnerability and is not affected. Note: fastjson2 users should separately upgrade to 2.0.63+ for an unrelated AutoType hardening fix.
• Network restriction: If patching is not immediately possible, restrict network access to applications using affected fastjson versions to limit exposure (Github Advisory).

The vulnerability generated significant attention across the security community, with Risky Biz describing it as a bug "about to rock the Java world" (Risky Biz). Imperva published a blog post confirming their customers were protected and providing technical analysis (Imperva). Check Point published a defense advisory (CPAI-2026-9631), and Ireland's NCSC issued a dedicated PDF advisory. The Hacker News, Bleeping Computer, SecurityWeek, SC World, and eSecurity Planet all covered the active exploitation, with Bleeping Computer specifically reporting on attacks targeting US firms. Community discussion on Reddit (r/pwnhub, r/SecOpsDaily, r/AZURE, r/linuxadmin) highlighted concern about the large installed base of fastjson 1.x in enterprise Java applications and the lack of an initial patch. One commentator noted that "fastjson 1.x is dead" and organizations should treat migration to fastjson2 as urgent (Duggan USA Blog).