Skip to content

2.1-7 序列化对比与安全风险 ​

所属:02 Java 运行时 / 2.1 Java 基础 分级:B(按 A 类模板展开) 状态:◐ 初稿 关联:2.1-1、2.1-2、2.1-3、3.4-1、5.1-5

  • 题型:对比 / 原理 / 安全
  • 一句话结论:序列化选型的本质是**“类型信息由谁携带、schema 由谁定义、要不要跨语言”;Java 原生序列化只适合可信对端 + 同版本 JVM + 短生命周期的内部场景,一旦数据经过网络、缓存、MQ、Cookie,就必须换成显式 schema(Protobuf/JSON)+ 白名单**。反序列化是 Java 生态里最稳定的 RCE 入口之一:只要攻击者能控制字节流,就能让 readObject 帮你执行代码,防御的第一原则是“不反序列化不可信数据”,第二原则才是 JEP 290 过滤器与类白名单。

分层要点 ​

  1. 定位:序列化 = 对象图 → 字节流,反序列化 = 字节流 → 对象图。要解决的三个问题:结构(字段怎么排)、类型(用什么类还原)、引用(同一对象/循环引用怎么处理)。选型差异全部落在这三点上:JSON 不带类型(弱 schema)、Java 原生带全限定类名(强类型、不可跨语言)、Protobuf 用 IDL 定义 schema(强类型、跨语言、不带类名)。

  2. Java 原生机制:Serializable 是标记接口,没有任何方法;真正干活的是 ObjectOutputStream.writeObject0 / ObjectInputStream.readObject0。流以魔数 0xACED + 版本 5 开头(ObjectStreamConstants.STREAM_MAGIC / STREAM_VERSION),随后写类描述(ObjectStreamClass:类名、serialVersionUID、字段表)和字段值;同一个对象第二次出现只写引用句柄(handle),所以循环引用不会栈溢出——这是原生序列化少数比 JSON 强的地方。transient 字段不写;static 字段不写;writeObject/readObject 可自定义;writeReplace/readResolve 可替换对象(单例、枚举代理常用);Externalizable 完全自己控制读写,但要求 public 无参构造。

  3. 原生序列化的四个硬伤:① 兼容性靠手工维护——不写 serialVersionUID 时由编译器按类结构算,加一个 public 方法都可能变,发版即 InvalidClassException;② 性能与体积——反射 + 类名/字段名元数据,通常比 Protobuf 大数倍、慢数倍;③ 不可跨语言——流里是 JVM 类名;④ 反序列化会执行代码——readObject/readResolve/readExternal 都是攻击者可以“喂”给你的逻辑入口。

  4. 反序列化漏洞的本质:不是“解析出错”,而是攻击者指定了要实例化的类,且该类在反序列化路径上能触发危险调用。典型 gadget chain:AnnotationInvocationHandler(JDK 自带)→ LazyMap.get → TransformedMap/InvokerTransformer(commons-collections)→ 反射调用 Runtime.exec。所以漏洞成立需要三个条件同时满足:入口可控(RMI/JMX/HTTP body/Redis session/MQ 消息/Cookie)、链在 classpath 上(依赖里有 commons-collections、commons-beanutils、groovy 等)、没有类型白名单。防御就是打断任意一条。

  5. 高发入口:① 对外 HTTP 接口把参数声明成 Object、Serializable,或框架自动反序列化 session/Cookie(Shiro rememberMe);② RMI/JMX/Actuator 暴露;③ Redis 里存 JDK 序列化对象,一旦 Redis 被弱口令/SSRF 拿下,反序列化就是第二跳;④ MQ 消息体(内网也要当不可信);⑤ Dubbo 的 Hessian2 反序列化(CVE-2020-1948 一线);⑥ 配置/文件解析:XStream、SnakeYAML、Jackson 多态类型。

  6. 框架默认值是重灾区:Jackson 的 enableDefaultTyping()(2.10 起弃用)会把 @class 写进 JSON 并按其还原,等于把“选哪个类”交给数据;正确姿势是 activateDefaultTyping(PolymorphicTypeValidator, ...),validator 用 BasicPolymorphicTypeValidator 做包白名单,绝不能用 LaissezFaireSubTypeValidator。Fastjson 1.x 的 autoType 是同类问题(1.2.24 直接 RCE,1.2.25–1.2.47 黑名单被反复绕过,1.2.68 才给 safeMode);Fastjson2 默认关闭 autoType,但仍建议开 safeMode + 白名单。XStream 在 1.4.18 起默认不再允许任意类型,老版本必须显式 allow。SnakeYAML 历史版本 new Yaml() 可实例化任意类,2.0 起收紧了默认构造器。

  7. 防御体系(从强到弱):协议层用 Protobuf/JSON 这种“数据里不带类名”的格式 → 入口层不接收 Object/Serializable,DTO 显式声明 → 过滤器 JEP 290(JDK 9+):进程级 -Djdk.serialFilter=... 或流级 ObjectInputStream#setObjectInputFilter,可同时限制类名、深度、引用数、数组长度、总字节数,返回 REJECTED 即抛 InvalidClassException → 依赖治理剔除/升级 commons-collections 3.2.1、commons-beanutils、旧版 XStream 等 gadget 依赖 → 运行权限最小化(容器非 root、禁 Runtime.exec 的 seccomp/AppArmor)→ 监控(反序列化异常、异常类名、外连行为)。

  8. 工程落地:跨服务一律 IDL 优先(Protobuf/Thrift/Avro),字段号只增不改不复用;JSON 接口关掉多态自动类型、限制 payload 大小与嵌套深度;MQ 消息带 schema 版本/事件类型,消费端按版本解析而不是按类名;Redis 缓存 value 用 JSON/Protobuf,不要存 JDK 序列化;发版前用 -Djdk.serialFilter 灰度观察拒绝日志;把“反序列化不可信数据”写进代码规范与安全扫描规则(SCA 识别 gadget 依赖)。


图 / 流程 ​

text
Java 原生序列化流结构(简化):
  AC ED 00 05                         ← 魔数 + 版本
  TC_OBJECT | TC_CLASSDESC            ← 对象 / 类描述
    类名 "com.foo.User"、serialVersionUID、字段表
  TC_STRING / TC_REFERENCE            ← 字段值;重复对象只写句柄
  循环引用:A.b = B, B.a = A
    → 第二次遇到 A 时写 TC_REFERENCE(handle=0x7E0000),不会递归爆栈
text
反序列化 RCE 的成立条件:
  可控字节流 ──► 入口(HTTP/Cookie/MQ/Redis/RMI)
                   │
                   ▼
        ObjectInputStream.readObject
                   │
                   ▼
        readOrdinaryObject → 反射创建实例 → 调用 readObject()
                   │
                   ▼
        gadget chain:LazyMap.get → InvokerTransformer.transform
                   │
                   ▼
        Method.invoke(Runtime.getRuntime(), "exec", cmd)  ──► RCE
  三个必要条件:入口可控 + 链在 classpath + 无白名单
text
防御分层(任一层生效都能打断):
  ① 协议:Protobuf/JSON,数据里不带类名
  ② 入口:DTO 显式类型,拒绝 Object/Serializable 参数
  ③ 过滤器:jdk.serialFilter / ObjectInputFilter(类名+深度+字节数)
  ④ 依赖:移除/升级 gadget 库
  ⑤ 权限:非 root、只读文件系统、网络出站白名单
  ⑥ 监控:反序列化拒绝日志、异常类名告警
text
选型决策:
  需要跨语言?── 否 ──► 对端可信且同版本?── 是 ──► 原生/Kryo(内部高性能)
      │                                   └─ 否 ─► JSON
      └─ 是 ──► 有稳定 schema / 高性能要求?── 是 ──► Protobuf/Thrift/Avro
                          └─ 否 ──► JSON(可读、调试友好)
  任何一条路径,只要“数据来自不可信来源”,都必须加白名单/过滤器

版本 / 源码锚点 ​

  • JDK:java.io.Serializable、Externalizable、ObjectOutputStream#writeObject0、writeClassDesc、Handles、ObjectInputStream#readObject0、readOrdinaryObject、ObjectStreamClass#computeDefaultSUID、ObjectStreamConstants(STREAM_MAGIC=0xACED、STREAM_VERSION=5)、InvalidClassException、readObjectNoData、serialPersistentFields。
  • JEP 290(JDK 9):java.io.ObjectInputFilter、ObjectInputFilter.Config.createFilter、ObjectInputFilter.Config.setSerialFilter(进程级)、ObjectInputStream#setObjectInputFilter(流级)、ObjectInputFilter.Status(UNDECIDED/ALLOWED/REJECTED)、系统属性 jdk.serialFilter;语法含 maxdepth=、maxrefs=、maxbytes=、maxarray=、!com.foo.*、com.foo.**。
  • Record(JDK 16+,JEP 395):record 若实现 Serializable,反序列化走规范构造器,而不是逐字段反射赋值;这与普通类行为不同。
  • Jackson 2.10+:enableDefaultTyping() 弃用;activateDefaultTyping(PolymorphicTypeValidator, DefaultTyping, As);BasicPolymorphicTypeValidator;安全修复集中在 2.12.x–2.15.x 一线。
  • Fastjson:1.2.24 RCE;1.2.25 引入黑名单后被 1.2.41/1.2.42/1.2.47 等多次绕过;1.2.68 引入 safeMode;1.2.83 为 1.x 末版;Fastjson2 默认关闭 autoType。
  • Dubbo:2.x 默认 hessian2;2.7.6 及以前存在 Hessian2 反序列化 RCE(CVE-2020-1948 一线),修复版本在 2.7.7/2.7.8;Dubbo 3 提供 triple(gRPC/Protobuf)与 fastjson2 序列化。具体以所用版本的官方公告为准。
  • Shiro:rememberMe Cookie 默认 AES 加密,Shiro < 1.2.5 使用硬编码密钥(CVE-2016-4437,Shiro-550),可构造序列化 payload 直接 RCE。
  • XStream:1.4.18 起默认安全框架收紧,需显式 allowTypes;历史版本默认允许任意类型。
  • SnakeYAML:2.0 起默认构造器收紧;此前 new Yaml() 可实例化任意类(CVE-2022-1471 一类)。
  • Kryo:流中默认携带类名,需 setRegistrationRequired(true) + 显式注册;Kryo 实例非线程安全。
  • Protobuf:字段号 1–15 编码为 1 字节;字段号只增不复用,删除字段用 reserved;未知字段会保留。

对比表 ​

表 1:五种序列化方案 ​

维度Java 原生JSON(Jackson/Gson)Hessian2ProtobufKryo
类型信息全限定类名(强)无(靠目标类型/多态注解)类名(Hessian 协议)无类名,靠 IDL类名或注册 ID
跨语言❌✅⚠️ 多语言实现弱✅❌(JVM 系为主)
schema无(靠类)无(弱)弱✅ IDL 强约束无(靠注册)
体积大大(可压缩)中小小
性能慢(反射+元数据)中中快最快(JVM 内)
版本兼容靠 serialVersionUID 手工维护宽松(未知字段可忽略)一般字段号规则清晰脆弱(字段顺序/注册 ID)
可读性无✅无无(有 IDL)无
安全面最危险(任意类实例化)中(多态类型、超大 payload)危险(类名可控)低(无类名)中(未注册类可带类名)
典型场景本地缓存、临时文件、旧系统HTTP API、配置、日志Dubbo 2.x 默认RPC、MQ、跨语言本地缓存、大数据

表 2:常见反序列化漏洞与锚点 ​

组件问题版本锚点处置
JDK 原生流gadget chain(AnnotationInvocationHandler + commons-collections)任意版本,取决于 classpath入口白名单 + JEP 290 + 移除 gadget 依赖
Fastjson 1.xautoType 任意类实例化1.2.24 直接 RCE;1.2.25–1.2.47 绕过;1.2.68+ 有 safeMode升级 1.2.83/Fastjson2,开 safeMode,禁 autoType
JacksonenableDefaultTyping 多态类型2.10 弃用;2.10+ 需 PolymorphicTypeValidator关闭 default typing;白名单 validator
XStream任意类实例化1.4.18 起默认收紧升级 + 显式 allowTypes
SnakeYAMLnew Yaml() 任意类2.0 起收紧升级 + SafeConstructor
ShirorememberMe 硬编码密钥< 1.2.5(Shiro-550)升级 + 随机密钥
DubboHessian2 反序列化2.7.6 及以前(CVE-2020-1948 一线)升级 2.7.7/2.7.8+,hessian 白名单
Redis 缓存存 JDK 序列化对象无版本,架构问题改 JSON/Protobuf;Redis 网络隔离

表 3:JEP 290 过滤器语义 ​

配置作用说明
-Djdk.serialFilter=...进程级默认过滤器对所有 ObjectInputStream 生效
ObjectInputFilter.Config.setSerialFilter(f)代码设置进程级只能设置一次,需在反序列化前
ObjectInputStream#setObjectInputFilter(f)单个流优先级最高,可覆盖进程级
maxdepth=N对象图最大深度防栈溢出/深嵌套
maxrefs=N最大引用数防对象炸弹
maxbytes=N流最大字节数防大 payload
maxarray=N数组最大长度防超大数组 OOM
com.foo.* / com.foo.**包/子包匹配* 不跨包,** 跨包
!com.foo.Bad拒绝只要出现负模式,未匹配类默认放行
仅正模式白名单未匹配类默认拒绝
返回 REJECTED中断反序列化抛 InvalidClassException

表 4:原生序列化的兼容性规则 ​

变更未声明 serialVersionUID已声明 serialVersionUID
新增字段UID 变化 → InvalidClassException新字段取默认值
删除字段UID 变化 → 失败多余字段被忽略
字段类型变更UID 变化 → 失败按名称+类型匹配,通常读不到(静默丢值)
新增 public 方法UID 可能变化无影响
修改 static/transient 字段不参与,UID 不变不参与序列化
类名/包名变更失败失败(类名在流里)
父类不可序列化反序列化需父类可访问无参构造父类字段不还原,构造器会执行

表 5:失效场景(现象 → 根因 → 处理) ​

现象根因处理
发版后老客户端报 InvalidClassException未显式声明 serialVersionUID声明固定 UID;新增字段用包装类型
反序列化后 transient 字段为 null/0不参与序列化,未走构造器在 readObject 里重建,或改为可序列化
单例反序列化后出现两个实例未实现 readResolve加 readResolve 返回单例
循环引用 JSON 报错JSON 无引用表用 @JsonIgnore/DTO 拆环,或换二进制格式
反序列化 CPU/内存飙高深嵌套、超大数组、对象炸弹maxdepth/maxrefs/maxarray/maxbytes
内网 MQ 消息触发 RCE误以为内网可信消息体白名单 + Protobuf + 生产方鉴权
Redis 被入侵后业务被 RCEvalue 存 JDK 序列化改 JSON/Protobuf,Redis 禁公网
Kryo 升级后字段错位类注册顺序/字段变化注册 ID 固定,版本化 schema

表 6:选型 checklist ​

问题若“是”若“否”
数据会离开本进程/本机?排除 Java 原生原生/Kryo 可接受
需要跨语言?Protobuf/JSON原生/Kryo/Hessian 可选
对端可信?可放宽,但仍建议白名单必须 schema + 过滤器
需要人工排查/抓包可读?JSON二进制
性能/体积敏感?Protobuf/KryoJSON
schema 会演进?Protobuf(字段号规则)JSON(宽松)
有历史 JDK 序列化数据?迁移期双读 + 过滤器直接换新格式

深挖点 ​

  1. serialVersionUID 到底怎么算?为什么加个方法也会变?ObjectStreamClass.computeDefaultSUID 用类名、修饰符、接口、非 private 的字段(排除 static/transient)、非 private 的构造器与方法、静态初始化块一起算 SHA-1 再截断。所以加一个 public 方法、改一个字段类型都会变;private 成员不影响。结论:生产类必须显式声明 private static final long serialVersionUID,并且把它当协议版本管理,而不是随手 1L 改来改去。

  2. 原生序列化为什么能处理循环引用?JSON 为什么不能?ObjectOutputStream 维护 Handles 表:对象第一次写出时分配 handle,之后遇到同一对象(== 或 equals? 实际按引用)只写 TC_REFERENCE;ObjectInputStream 用 handles 数组还原引用。JSON 规范里没有引用语义,只能靠 $ref 之类的扩展,默认会无限递归。这也是“对象图”与“树”的区别。

  3. readObject 为什么是攻击面? 反序列化不是“填字段”,而是执行类自己的钩子:readObject、readExternal、readResolve、readObjectNoData、validateObject。攻击者控制流内容后,可以让这些钩子走到任意可达代码;再加上 AccessController 在反序列化期间通常已无权限制约,于是形成 RCE。私有 readObject 也会被调用(反射 + setAccessible),这是最容易被误解的一点。

  4. JEP 290 怎么配才算真的生效? 进程级用 -Djdk.serialFilter="maxdepth=100;maxrefs=10000;maxbytes=10485760;maxarray=10000;!com.foo.**;java.base/*",流级用 ObjectInputStream#setObjectInputFilter 覆盖。注意三点:① 过滤器只覆盖 Java 原生流,JSON/Hessian/Protobuf 不走它;② 只写正模式是白名单、出现负模式后未匹配类默认放行,配错等于没配;③ 过滤器在 resolveClass 前调用,被拒绝时抛 InvalidClassException,要在日志里记录类名才能发现攻击。

  5. Jackson 的 @class / Fastjson 的 @type 危险在哪? 它们把“实例化哪个类”的决定权交给了数据。Jackson 的 activateDefaultTyping 必须配 PolymorphicTypeValidator,用 BasicPolymorphicTypeValidator.builder().allowIfSubType("com.foo.") 这类白名单;LaissezFaireSubTypeValidator 等于放行一切。Fastjson 1.x 的黑名单思路本身就不成立(绕过史很长),正确姿势是 safeMode + 显式白名单,或直接换 Fastjson2 并关闭 autoType。

  6. 序列化在分布式中间件里的取舍? Dubbo 2.x 默认 hessian2:Java 友好、体积性能中等,但类名在流里,有反序列化面;Dubbo 3 的 triple 用 Protobuf,天然无类名、跨语言,代价是要维护 IDL。MQ 场景要看消费方语言:全 Java 且内网可用 hessian/kryo,跨语言必须 Protobuf/Avro,并且消息头带 schema 版本,消费端按版本兼容而不是按类名反射。缓存场景优先 JSON(可读、可灰度)或 Protobuf(省带宽),不要用 JDK 原生——Redis 一旦失守就是第二跳 RCE。


追问链(46 条) ​

是什么 / 为什么

  1. 序列化要解决哪三个问题?→ 结构、类型、引用。
  2. Serializable 有方法吗?→ 没有,是标记接口;逻辑在流类里。
  3. 为什么 Java 原生序列化不能跨语言?→ 流里是全限定类名 + JVM 字段描述。
  4. serialVersionUID 不写会怎样?→ 编译器按类结构算,改动即变,反序列化失败。
  5. 写了 UID 就完全兼容吗?→ 不是,字段类型变更、类名变更仍会出问题。
  6. transient 字段反序列化后是什么?→ 默认值(0/false/null),不是构造器里的值。
  7. static 字段会被序列化吗?→ 不会。
  8. 父类不实现 Serializable 会报错吗?→ 不会,但父类字段不还原,且反序列化需要父类可访问无参构造。
  9. 枚举序列化会创建新对象吗?→ 不会,按名字还原并保证单例。
  10. record 的反序列化走 readObject 吗?→ 不走,走规范构造器(JDK 16+)。
  11. writeReplace / readResolve 干什么用?→ 序列化前替换、反序列化后替换(单例、代理)。
  12. readObjectNoData 什么时候调用?→ 流里没有该类的数据时(版本 skew)。
  13. Externalizable 和 Serializable 区别?→ 完全自控读写,要求 public 无参构造。
  14. 循环引用会栈溢出吗?→ 原生不会(handle 表),JSON 默认会。
  15. 为什么原生序列化体积大?→ 类名、字段名、类型描述都进流。

源码 / 机制

  1. 原生流的魔数是什么?→ 0xACED,版本 5。
  2. 同一个对象写两次会写几份?→ 一份 + 引用句柄。
  3. ObjectOutputStream#writeObject0 里 unshared 参数什么意思?→ 绕过 handle 表,强制独立写。
  4. ObjectStreamClass 缓存了什么?→ 类描述、字段表、UID,按类加载器缓存。
  5. computeDefaultSUID 包含哪些成员?→ 类名/修饰符/接口/非 private 字段/非 private 方法/静态初始化。
  6. readOrdinaryObject 怎么创建实例?→ 反射调用无参构造(或第一个非序列化父类构造)。
  7. 为什么私有 readObject 会被调用?→ 反射 + setAccessible。
  8. serialPersistentFields 有什么用?→ 显式声明序列化字段集合。
  9. JEP 290 的过滤器在什么时机调用?→ resolveClass 之前,逐类调用。
  10. 过滤器返回 UNDECIDED 会怎样?→ 继续交给下一个过滤器/默认策略。
  11. 只写正模式的过滤器是什么语义?→ 白名单,未匹配即拒绝。
  12. maxbytes 限制的是什么?→ 整个流的字节数(防大 payload)。
  13. ObjectInputFilter.Config.setSerialFilter 能调用几次?→ 进程级只能设置一次。

安全 / 攻击链

  1. 反序列化 RCE 的三个必要条件?→ 入口可控、gadget 在 classpath、无白名单。
  2. 常见 gadget 依赖有哪些?→ commons-collections、commons-beanutils、groovy、Spring 部分组件。
  3. 为什么“内网消息”也不能信?→ 生产方可能被控、MQ 可能被写、内部也有越权。
  4. Base64/加密能防反序列化吗?→ 不能,只能增加一点门槛;密钥泄露即失效。
  5. 签名能防吗?→ 能提高门槛,但密钥管理、重放、降级都要考虑。
  6. Shiro rememberMe 的问题根源?→ 硬编码 AES 密钥 + 反序列化。
  7. Fastjson 为什么黑名单防不住?→ 黑名单永远滞后,绕过手法多。
  8. Jackson default typing 为什么危险?→ 数据决定实例化类。
  9. LaissezFaireSubTypeValidator 能用吗?→ 不能,等于放行一切。
  10. XStream/SnakeYAML 的风险点?→ 默认允许任意类型实例化。
  11. Redis 存 JDK 序列化对象的风险?→ Redis 失守即 RCE。
  12. Dubbo Hessian2 的风险?→ 类名可控 + 历史漏洞。
  13. 反序列化 DoS 怎么打?→ 深嵌套、超大数组、对象炸弹。
  14. 过滤器能防 JSON 多态攻击吗?→ 不能,只覆盖 Java 原生流。

工程 / 取舍

  1. 跨语言 RPC 选什么?→ Protobuf/Thrift,IDL 优先。
  2. 内部高性能缓存选什么?→ Kryo(注册类)或 Protobuf;不要原生。
  3. Kryo 的坑?→ 非线程安全、注册顺序/字段变化导致错位。
  4. Protobuf 字段号能复用吗?→ 不能,删除用 reserved。

生产案例 / 取舍 ​

  1. HTTP 接口收 Object 参数 → RCE:一个内部运营接口把请求体声明为 Object,Spring 用 Jackson 多态反序列化;攻击者构造 @class 指向 commons-collections gadget,拿到服务器权限。修复:接口改 DTO、关闭 default typing、加 PolymorphicTypeValidator 白名单,并把 commons-collections 3.2.1 升到 3.2.2。教训:内部接口不等于可信入口。

  2. Redis session 存 JDK 序列化:Redis 弱口令被扫到,攻击者写入序列化 payload,应用一读 session 就 RCE。修复:session 改 JSON、Redis 只在内网、加 ACL 与 rename-command。教训:缓存也是反序列化入口。

  3. Fastjson 1.2.47 绕过:安全扫描已把 Fastjson 升到“黑名单版本”,仍被 @type 绕过打到 RCE。修复:升到 1.2.83 并开 safeMode,业务侧移除 autoTypeSupport,最终迁 Fastjson2。教训:黑名单不是防御。

  4. Dubbo Hessian2 反序列化:老系统 Dubbo 2.7.5,注册中心暴露到办公网,攻击者通过泛化调用投递 payload。修复:升级 2.7.8、关闭公网注册中心、hessian 加类白名单、开启鉴权。教训:RPC 端口不是内网就安全。

  5. 没写 serialVersionUID 的代价:订单快照类没显式声明 UID,发版加了一个 public 方法,滚动发布期间新旧实例互相反序列化全部 InvalidClassException,消息积压 20 万。修复:补 UID = 1L、新增字段用包装类型、灰度先双读。教训:UID 是协议,不是装饰。

  6. 8MB 的 Redis value:商品详情用 JDK 序列化存 Redis,单 value 8MB,高峰带宽打满、GC 抖动。换 Protobuf + 压缩后降到 1.2MB,P99 从 180ms 降到 60ms。取舍:可读性换带宽,调试靠工具链补。

  7. Kryo 未注册类:本地缓存用 Kryo 默认配置,流里带类名;依赖升级后字段顺序变化,读出来的对象字段错位,出现“金额为 0”的资损。修复:setRegistrationRequired(true)、注册 ID 固定、加 schema 版本号。教训:快的代价是脆弱。

  8. 反序列化 DoS:对外接口接收 Java 序列化的“导入文件”,攻击者构造超深嵌套列表,单请求打满 CPU 并 OOM。修复:maxdepth=50;maxarray=10000;maxbytes=1MB,并改成 JSON。取舍:过滤器是兜底,格式才是根治。

  9. Shiro-550:老后台用 Shiro 1.2.4,rememberMe 密钥硬编码,被拿 shell。修复:升级 Shiro、随机密钥、下线 rememberMe。教训:默认配置可能就是漏洞。

  10. Jackson 处理第三方回调:为了兼容多类型事件开了 enableDefaultTyping,回调方被攻破后投递恶意 @class。修复:按事件类型显式路由到不同 DTO,彻底关闭多态自动类型。取舍:灵活性让位给边界清晰。

  11. 对账系统跨语言:Java 生产方用原生序列化写 Kafka,Go 消费方无法解析,临时加 Java 桥接服务。最终换 Protobuf + Schema Registry,字段号只增不改。教训:跨语言是选型第一问。

  12. 依赖治理不是银弹:把 commons-collections 升级后,仍存在其他 gadget(groovy、beanutils)。最终靠“入口白名单 + JEP 290 + 非 root 运行”三层兜底。取舍:没有单点防御,只有纵深。


易错点(28 条) ​

  1. 认为 serialVersionUID 只是“版本号”,可以随便改成 1L 或每次发版递增。
  2. 认为加了 serialVersionUID 就完全兼容,忽略字段类型变更与类名变更。
  3. 认为 transient 字段反序列化后是构造器里的值(实际是默认值)。
  4. 认为 static 字段会随对象序列化。
  5. 认为父类不实现 Serializable 会直接报错(实际不会,但字段不还原)。
  6. 认为私有 readObject 不会被调用。
  7. 认为枚举反序列化会创建新对象。
  8. 认为 record 也走 readObject 逐字段赋值。
  9. 认为循环引用一定栈溢出(原生有 handle 表)。
  10. 认为原生序列化可以跨语言,只是“效率低一点”。
  11. 认为内网/内部接口的数据可信。
  12. 认为 Base64 或简单加密就能防反序列化攻击。
  13. 认为“有签名”就绝对安全,忽略密钥管理与重放。
  14. 认为 Jackson 默认就安全,随手 enableDefaultTyping。
  15. 认为 LaissezFaireSubTypeValidator 只是“宽松一点”。
  16. 认为 Fastjson 升到最新版就安全,不开 safeMode、不清 autoType。
  17. 认为 Fastjson 黑名单能长期挡住攻击。
  18. 认为 JEP 290 能防 JSON/Hessian 的反序列化问题。
  19. 认为过滤器写了类名白名单就够,忽略深度/字节数/数组长度。
  20. 认为过滤器只写负模式也能白名单生效(语义相反)。
  21. 认为 ObjectInputFilter.Config.setSerialFilter 可以反复设置。
  22. 认为 Hessian/Kryo 没有反序列化风险。
  23. 认为 Kryo 实例可以多线程共享。
  24. 认为 Kryo 升级后字段还能自动对齐。
  25. 认为 Protobuf 字段号可以复用,或可以随意改类型。
  26. 认为 JSON 一定没有反序列化漏洞(多态类型、超大 payload 仍在)。
  27. 认为升级 gadget 依赖就万事大吉,忽略其他链与入口。
  28. 认为反序列化只发生在 RPC 入口,忽略 MQ、缓存、Session、Cookie、文件导入。

30 秒口述稿 ​

“序列化我会先问三个问题:跨不跨语言、schema 谁定、数据可不可信。Java 原生序列化带全限定类名,只适合可信对端、同版本 JVM 的内部短生命周期场景,兼容性靠 serialVersionUID 手工维护,性能和体积都吃亏。跨服务我优先 Protobuf,HTTP 用 JSON,Dubbo 2.x 默认 Hessian2 但要加白名单。安全上,反序列化的本质是让数据决定实例化哪个类,readObject、readResolve 都会执行代码;常见入口是 HTTP 参数、Cookie、Redis、MQ 和 RMI。防御分四层:协议上不带类名、入口只收显式 DTO、JEP 290 过滤器限制类名和深度字节数、依赖治理加最小权限。我遇到过没写 UID 导致滚动发布消息积压,也处理过 Redis 存 JDK 序列化被当成第二跳的案例,所以结论是:不可信数据永远不要走原生反序列化。”

3 分钟展开顺序 ​

  1. 先给判断:选型看三点(跨语言、schema、可信度),原生只用于可信内部。
  2. 讲原生机制:标记接口 → 流头/类描述/字段 → handle 表 → 兼容性规则;点出 serialVersionUID 的坑。
  3. 讲安全:RCE 三条件 → 一条 gadget chain(AnnotationInvocationHandler + commons-collections)→ 高发入口。
  4. 讲框架默认值:Jackson default typing、Fastjson autoType、Shiro、Dubbo Hessian2,各给一个版本锚点。
  5. 讲防御:Protobuf/JSON → DTO → JEP 290(类名/深度/字节数)→ 依赖治理 → 最小权限。
  6. 给案例:UID 缺失导致积压 + Redis 序列化第二跳,各 30 秒。
  7. 收尾取舍:性能与安全的平衡点,以及“格式根治、过滤器兜底”。